libogc/wiilaunch.c

   1 /*-------------------------------------------------------------
   2
   3 wiilaunch.c -- Wii NAND title launching and argument passing
   4
   5 Copyright (C) 2008
   6 Hector Martin (marcan)
   7
   8 This software is provided 'as-is', without any express or implied
   9 warranty.  In no event will the authors be held liable for any
  10 damages arising from the use of this software.
  11
  12 Permission is granted to anyone to use this software for any
  13 purpose, including commercial applications, and to alter it and
  14 redistribute it freely, subject to the following restrictions:
  15
  16 1.      The origin of this software must not be misrepresented; you
  17 must not claim that you wrote the original software. If you use
  18 this software in a product, an acknowledgment in the product
  19 documentation would be appreciated but is not required.
  20
  21 2.      Altered source versions must be plainly marked as such, and
  22 must not be misrepresented as being the original software.
  23
  24 3.      This notice may not be removed or altered from any source
  25 distribution.
  26
  27 -------------------------------------------------------------*/
  28
  29 #if defined(HW_RVL)
  30
  31 #include <string.h>
  32 #include <malloc.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <stdarg.h>
  36 #include "ipc.h"
  37 #include "asm.h"
  38 #include "processor.h"
  39 #include "es.h"
  40 #include "video.h"
  41 #include "network.h"
  42 #include "wiilaunch.h"
  43
  44 static char __nandbootinfo[] ATTRIBUTE_ALIGN(32) = "/shared2/sys/NANDBOOTINFO";
  45 static char __stateflags[] ATTRIBUTE_ALIGN(32) = "/title/00000001/00000002/data/state.dat";
  46
  47 static int __initialized = 0;
  48
  49 typedef struct {
  50         u32 checksum;
  51         u32 argsoff;
  52         u8 unk1;
  53         u8 unk2;
  54         u8 apptype;
  55         u8 titletype;
  56         u32 launchcode;
  57         u32 unknown[2];
  58         u64 launcher;
  59         u8 argbuf[0x1000];
  60 } NANDBootInfo;
  61
  62 typedef struct {
  63         u32 checksum;
  64         u8 flags;
  65         u8 type;
  66         u8 discstate;
  67         u8 returnto;
  68         u32 unknown[6];
  69 } StateFlags;
  70
  71 #define TYPE_RETURN 3
  72 #define TYPE_NANDBOOT 4
  73 #define TYPE_SHUTDOWNSYSTEM 5
  74 #define RETURN_TO_MENU 0
  75 #define RETURN_TO_SETTINGS 1
  76 #define RETURN_TO_ARGS 2
  77
  78
  79 static NANDBootInfo nandboot ATTRIBUTE_ALIGN(32);
  80
  81 static StateFlags stateflags ATTRIBUTE_ALIGN(32);
  82
  83 static u32 __CalcChecksum(u32 *buf, int len)
  84 {
  85         u32 sum = 0;
  86         int i;
  87         len = (len/4);
  88
  89         for(i=1; i<len; i++)
  90                 sum += buf[i];
  91
  92         return sum;
  93 }
  94
  95 static void __SetChecksum(void *buf, int len)
  96 {
  97         u32 *p = (u32*)buf;
  98         p[0] = __CalcChecksum(p, len);
  99 }
 100
 101 static int __ValidChecksum(void *buf, int len)
 102 {
 103         u32 *p = (u32*)buf;
 104         return p[0] == __CalcChecksum(p, len);
 105 }
 106
 107 static s32 __WII_ReadStateFlags(void)
 108 {
 109         int fd;
 110         int ret;
 111
 112         fd = IOS_Open(__stateflags,IPC_OPEN_READ);
 113         if(fd < 0) {
 114                 memset(&stateflags,0,sizeof(stateflags));
 115                 return WII_EINTERNAL;
 116         }
 117
 118         ret = IOS_Read(fd, &stateflags, sizeof(stateflags));
 119         IOS_Close(fd);
 120         if(ret != sizeof(stateflags)) {
 121                 memset(&stateflags,0,sizeof(stateflags));
 122                 return WII_EINTERNAL;
 123         }
 124         if(!__ValidChecksum(&stateflags, sizeof(stateflags))) {
 125                 memset(&stateflags,0,sizeof(stateflags));
 126                 return WII_ECHECKSUM;
 127         }
 128         return 0;
 129 }
 130
 131 static s32 __WII_ReadNANDBootInfo(void)
 132 {
 133         int fd;
 134         int ret;
 135
 136         fd = IOS_Open(__nandbootinfo,IPC_OPEN_READ);
 137         if(fd < 0) {
 138                 memset(&nandboot,0,sizeof(nandboot));
 139                 return WII_EINTERNAL;
 140         }
 141
 142         ret = IOS_Read(fd, &nandboot, sizeof(nandboot));
 143         IOS_Close(fd);
 144         if(ret != sizeof(nandboot)) {
 145                 memset(&nandboot,0,sizeof(nandboot));
 146                 return WII_EINTERNAL;
 147         }
 148         if(!__ValidChecksum(&nandboot, sizeof(nandboot))) {
 149                 memset(&nandboot,0,sizeof(nandboot));
 150                 return WII_ECHECKSUM;
 151         }
 152         return 0;
 153 }
 154
 155 static s32 __WII_WriteStateFlags(void)
 156 {
 157         int fd;
 158         int ret;
 159
 160         __SetChecksum(&stateflags, sizeof(stateflags));
 161
 162         fd = IOS_Open(__stateflags,IPC_OPEN_READ|IPC_OPEN_WRITE);
 163         if(fd < 0) {
 164                 return WII_EINTERNAL;
 165         }
 166
 167         ret = IOS_Write(fd, &stateflags, sizeof(stateflags));
 168         IOS_Close(fd);
 169         if(ret != sizeof(stateflags)) {
 170                 return WII_EINTERNAL;
 171         }
 172         return 0;
 173 }
 174
 175 static s32 __WII_WriteNANDBootInfo(void)
 176 {
 177         int fd;
 178         int ret;
 179
 180         __SetChecksum(&nandboot, sizeof(nandboot));
 181
 182         fd = IOS_Open(__nandbootinfo,IPC_OPEN_READ|IPC_OPEN_WRITE);
 183         if(fd < 0) {
 184                 return WII_EINTERNAL;
 185         }
 186
 187         ret = IOS_Write(fd, &nandboot, sizeof(nandboot));
 188         IOS_Close(fd);
 189         if(ret != sizeof(nandboot)) {
 190                 return WII_EINTERNAL;
 191         }
 192         return 0;
 193 }
 194
 195 s32 WII_Initialize(void)
 196 {
 197         __WII_ReadStateFlags();
 198         __WII_ReadNANDBootInfo();
 199         __initialized = 1;
 200         return 0;
 201 }
 202
 203 s32 __WII_SetArgs(const char **argv)
 204 {
 205         int argslen = 0;
 206         int buflen = 0;
 207         int argvp, argp;
 208         int argc = 0;
 209         int i;
 210
 211         if(!__initialized)
 212                 return WII_ENOTINIT;
 213
 214         for(i=0; argv[i] != NULL; i++) {
 215                 argslen += strlen(argv[i]) + 1;
 216                 argc++;
 217         }
 218         buflen = (argslen + 3) & ~3;
 219         buflen += 4 * argc;
 220         buflen += 8;
 221
 222         if(buflen > 0x1000)
 223                 return WII_E2BIG;
 224
 225         argp = 0x1000 - argslen;
 226         argvp = 0x1000 - buflen;
 227
 228         memset(&nandboot.argbuf, 0, sizeof(nandboot.argbuf));
 229
 230         nandboot.argsoff = 0x1000 + argvp;
 231         *((u32*)&nandboot.argbuf[argvp]) = argc;
 232         argvp += 4;
 233
 234         for(i=0; i<argc; i++) {
 235                 strcpy((char*)&nandboot.argbuf[argp], argv[i]);
 236                 *((u32*)&nandboot.argbuf[argvp]) = argp + 0x1000;
 237                 argvp += 4;
 238                 argp += strlen(argv[i]) + 1;
 239         }
 240         *((u32*)&nandboot.argbuf[argvp]) = 0;
 241
 242         return 0;
 243 }
 244
 245 s32 WII_LaunchTitle(u64 titleID)
 246 {
 247         s32 res;
 248         u32 numviews;
 249         STACK_ALIGN(tikview,views,4,32);
 250
 251         if(!__initialized)
 252                 return WII_ENOTINIT;
 253
 254         res = ES_GetNumTicketViews(titleID, &numviews);
 255         if(res < 0) {
 256                 return res;
 257         }
 258         if(numviews > 4) {
 259                 return WII_EINTERNAL;
 260         }
 261         res = ES_GetTicketViews(titleID, views, numviews);
 262         if(res < 0)
 263                 return res;
 264
 265         net_wc24cleanup();
 266
 267         memset(&nandboot,0,sizeof(NANDBootInfo));
 268         nandboot.apptype = 0x80;
 269         if(titleID == 0x100000002LL)
 270                 nandboot.titletype = 4;
 271         else
 272                 nandboot.titletype = 2;
 273         if(ES_GetTitleID(&nandboot.launcher) < 0)
 274                 nandboot.launcher = 0x0000000100000002LL;
 275         nandboot.checksum = __CalcChecksum((u32*)&nandboot,sizeof(NANDBootInfo));
 276         __WII_WriteNANDBootInfo();
 277
 278         VIDEO_SetBlack(1);
 279         VIDEO_Flush();
 280
 281         res = ES_LaunchTitle(titleID, &views[0]);
 282         if(res < 0)
 283                 return res;
 284         return WII_EINTERNAL;
 285 }
 286
 287 s32 WII_LaunchTitleWithArgs(u64 titleID, int launchcode, ...)
 288 {
 289         char argv0[20];
 290         const char *argv[256];
 291         int argc = 1;
 292         va_list args;
 293
 294         if(!__initialized)
 295                 return WII_ENOTINIT;
 296
 297         sprintf(argv0, "%016llx", titleID);
 298
 299         argv[0] = argv0;
 300
 301         va_start(args, launchcode);
 302
 303         do {
 304                 argv[argc++] = va_arg(args, const char *);
 305         } while(argv[argc - 1] != NULL);
 306
 307         va_end(args);
 308
 309         if(ES_GetTitleID(&nandboot.launcher) < 0)
 310                 nandboot.launcher = 0x100000002LL;
 311
 312         if(titleID == 0x100000002LL)
 313                 nandboot.titletype = 4;
 314         else
 315                 nandboot.titletype = 2;
 316         nandboot.apptype = 0x80;
 317         nandboot.launchcode = launchcode;
 318
 319         stateflags.type = TYPE_RETURN;
 320         stateflags.returnto = RETURN_TO_ARGS;
 321
 322         __WII_SetArgs(argv);
 323
 324         __WII_WriteStateFlags();
 325         __WII_WriteNANDBootInfo();
 326
 327         return WII_LaunchTitle(titleID);
 328 }
 329
 330 s32 WII_ReturnToMenu(void)
 331 {
 332         if(!__initialized)
 333                 return WII_ENOTINIT;
 334         stateflags.type = TYPE_RETURN;
 335         stateflags.returnto = RETURN_TO_MENU;
 336         __WII_WriteStateFlags();
 337         return WII_LaunchTitle(0x100000002LL);
 338 }
 339
 340 s32 WII_ReturnToSettings(void)
 341 {
 342         if(!__initialized)
 343                 return WII_ENOTINIT;
 344         stateflags.type = TYPE_RETURN;
 345         stateflags.returnto = RETURN_TO_SETTINGS;
 346         __WII_WriteStateFlags();
 347         return WII_LaunchTitle(0x100000002LL);
 348 }
 349
 350 s32 WII_ReturnToSettingsPage(const char *page)
 351 {
 352         if(!__initialized)
 353                 return WII_ENOTINIT;
 354
 355         return WII_LaunchTitleWithArgs(0x100000002LL, 1, page, NULL);
 356 }
 357
 358 s32 WII_OpenURL(const char *url)
 359 {
 360         u32 tmdsize;
 361         u64 tid = 0;
 362         u64 *list;
 363         u32 titlecount;
 364         s32 ret;
 365         u32 i;
 366
 367         if(!__initialized)
 368                 return WII_ENOTINIT;
 369
 370         ret = ES_GetNumTitles(&titlecount);
 371         if(ret < 0)
 372                 return WII_EINTERNAL;
 373
 374         list = memalign(32, titlecount * sizeof(u64) + 32);
 375
 376         ret = ES_GetTitles(list, titlecount);
 377         if(ret < 0) {
 378                 free(list);
 379                 return WII_EINTERNAL;
 380         }
 381
 382         for(i=0; i<titlecount; i++) {
 383                 if((list[i] & ~0xFF) == 0x1000148414400LL) {
 384                         tid = list[i];
 385                         break;
 386                 }
 387         }
 388         free(list);
 389
 390         if(!tid)
 391                 return WII_EINSTALL;
 392
 393         if(ES_GetStoredTMDSize(tid, &tmdsize) < 0)
 394                 return WII_EINSTALL;
 395
 396         return WII_LaunchTitleWithArgs(tid, 0, url, NULL);
 397 }
 398
 399 #endif