src/supportbase.c

   1 #include "include/usbld.h"
   2 #include "include/lang.h"
   3 #include "include/util.h"
   4 #include "include/iosupport.h"
   5 #include "include/system.h"
   6 #include "include/supportbase.h"
   7 #include "include/ioman.h"
   8
   9 /// internal linked list used to populate the list from directory listing
  10 struct game_list_t {
  11         base_game_info_t gameinfo;
  12         struct game_list_t *next;
  13 };
  14
  15 int sbIsSameSize(const char* prefix, int prevSize) {
  16         int size = -1;
  17         char path[255];
  18         snprintf(path, 255, "%sul.cfg", prefix);
  19
  20         int fd = openFile(path, O_RDONLY);
  21         if (fd >= 0) {
  22                 size = getFileSize(fd);
  23                 fioClose(fd);
  24         }
  25
  26         return size == prevSize;
  27 }
  28
  29 static int isValidIsoName(char *name)
  30 {
  31         // SCUS_XXX.XX.ABCDEFGHIJKLMNOP.iso
  32
  33         // Minimum is 17 char, GameID (11) + "." (1) + filename (1 min.) + ".iso" (4)
  34         int size = strlen(name);
  35         if ((size >= 17) && (name[4] == '_') && (name[8] == '.') && (name[11] == '.') && (stricmp(&name[size - 4], ".iso") == 0)) {
  36                 size -= 16;
  37                 if (size <= ISO_GAME_NAME_MAX)
  38                         return size;
  39         }
  40
  41         return 0;
  42 }
  43
  44 static int scanForISO(char* path, char type, struct game_list_t** glist) {
  45         int fd, size, count = 0;
  46         fio_dirent_t record;
  47
  48         if ((fd = fioDopen(path)) > 0) {
  49                 while (fioDread(fd, &record) > 0) {
  50                         if ((size = isValidIsoName(record.name)) > 0) {
  51                                 struct game_list_t *next = (struct game_list_t*)malloc(sizeof(struct game_list_t));
  52
  53                                 next->next = *glist;
  54                                 *glist = next;
  55
  56                                 base_game_info_t *game = &(*glist)->gameinfo;
  57
  58                                 strncpy(game->name, &record.name[GAME_STARTUP_MAX], size);
  59                                 game->name[size] = '\0';
  60                                 strncpy(game->startup, record.name, GAME_STARTUP_MAX - 1);
  61                                 game->startup[GAME_STARTUP_MAX - 1] = '\0';
  62                                 strncpy(game->extension, &record.name[GAME_STARTUP_MAX + size], 4);
  63                                 game->extension[4] = '\0';
  64                                 game->parts = 0x01;
  65                                 game->media = type;
  66                                 game->isISO = 1;
  67                                 game->sizeMB = (record.stat.size >> 20) | (record.stat.hisize << 12);
  68
  69                                 count++;
  70                         }
  71                 }
  72                 fioDclose(fd);
  73         }
  74
  75         return count;
  76 }
  77
  78 void sbReadList(base_game_info_t **list, const char* prefix, int *fsize, int* gamecount) {
  79         int fd, size, id = 0;
  80         size_t count = 0;
  81         char path[255];
  82
  83         free(*list);
  84         *list = NULL;
  85         *fsize = -1;
  86         *gamecount = 0;
  87
  88         // temporary storage for the game names
  89         struct game_list_t *dlist_head = NULL;
  90
  91         // count iso games in "cd" directory
  92         snprintf(path, 255, "%sCD", prefix);
  93         count += scanForISO(path, 0x12, &dlist_head);
  94
  95         // count iso games in "dvd" directory
  96         snprintf(path, 255, "%sDVD", prefix);
  97         count += scanForISO(path, 0x14, &dlist_head);
  98
  99
 100         // count and process games in ul.cfg
 101         snprintf(path, 255, "%sul.cfg", prefix);
 102         fd = openFile(path, O_RDONLY);
 103         if(fd >= 0) {
 104                 char buffer[0x040];
 105
 106                 size = getFileSize(fd);
 107                 *fsize = size;
 108                 count += size / 0x040;
 109
 110                 if (count > 0) {
 111                         *list = (base_game_info_t*)malloc(sizeof(base_game_info_t) * count);
 112
 113                         while (size > 0) {
 114                                 fioRead(fd, buffer, 0x40);
 115
 116                                 base_game_info_t *g = &(*list)[id++];
 117
 118                                 // to ensure no leaks happen, we copy manually and pad the strings
 119                                 memcpy(g->name, buffer, UL_GAME_NAME_MAX);
 120                                 g->name[UL_GAME_NAME_MAX] = '\0';
 121                                 memcpy(g->startup, &buffer[UL_GAME_NAME_MAX + 3], GAME_STARTUP_MAX);
 122                                 g->startup[GAME_STARTUP_MAX] = '\0';
 123                                 g->extension[0] = '\0';
 124                                 memcpy(&g->parts, &buffer[47], 1);
 125                                 memcpy(&g->media, &buffer[48], 1);
 126                                 g->isISO = 0;
 127                                 g->sizeMB = -1;
 128                                 size -= 0x40;
 129                         }
 130                 }
 131                 fioClose(fd);
 132         }
 133         else if (count > 0)
 134                 *list = (base_game_info_t*)malloc(sizeof(base_game_info_t) * count);
 135
 136         // copy the dlist into the list
 137         while ((id < count) && dlist_head) {
 138                 // copy one game, advance
 139                 struct game_list_t *cur = dlist_head;
 140                 dlist_head = dlist_head->next;
 141
 142                 memcpy(&(*list)[id++], &cur->gameinfo, sizeof(base_game_info_t));
 143                 free(cur);
 144         }
 145
 146         *gamecount = count;
 147 }
 148
 149 int sbPrepare(base_game_info_t* game, config_set_t* configSet, int size_cdvdman, void** cdvdman_irx, int* patchindex) {
 150         int i;
 151
 152         unsigned int compatmask = 0;
 153         configGetInt(configSet, CONFIG_ITEM_COMPAT, &compatmask);
 154
 155         char gameid[5];
 156         configGetDiscIDBinary(configSet, gameid);
 157
 158
 159         for (i = 0; i < size_cdvdman; i++) {
 160                 if (!strcmp((const char*)((u32)cdvdman_irx + i),"######    GAMESETTINGS    ######")) {
 161                         break;
 162                 }
 163         }
 164
 165         memcpy((void*)((u32)cdvdman_irx + i + 33), &game->parts, 1);
 166         memcpy((void*)((u32)cdvdman_irx + i + 34), &game->media, 1);
 167         if (compatmask & COMPAT_MODE_2) {
 168                 u32 alt_read_mode = 1;
 169                 memcpy((void*)((u32)cdvdman_irx + i + 35), &alt_read_mode, 1);
 170         }
 171         if (compatmask & COMPAT_MODE_5) {
 172                 u32 no_dvddl = 1;
 173                 memcpy((void*)((u32)cdvdman_irx + i + 36), &no_dvddl, 4);
 174         }
 175         if (compatmask & COMPAT_MODE_4) {
 176                 u32 no_pss = 1;
 177                 memcpy((void*)((u32)cdvdman_irx + i + 40), &no_pss, 4);
 178         }
 179
 180         *patchindex = i;
 181
 182         for (i = 0; i < size_cdvdman; i++) {
 183                 if (!strcmp((const char*)((u32)cdvdman_irx + i),"B00BS")) {
 184                         break;
 185                 }
 186         }
 187         // game id
 188         memcpy((void*)((u32)cdvdman_irx + i), &gameid, 5);
 189
 190         // patches cdvdfsv
 191         /*void *cdvdfsv_irx;
 192         int size_cdvdfsv_irx;
 193
 194         sysGetCDVDFSV(&cdvdfsv_irx, &size_cdvdfsv_irx);
 195         u32 *p = (u32 *)cdvdfsv_irx;
 196         for (i = 0; i < (size_cdvdfsv_irx >> 2); i++) {
 197                 if (*p == 0xC0DEC0DE) {
 198                         if (compatmask & COMPAT_MODE_7)
 199                                 *p = 1;
 200                         else
 201                                 *p = 0;
 202                         break;
 203                 }
 204                 p++;
 205         }*/
 206
 207         return compatmask;
 208 }
 209
 210 static void sbRebuildULCfg(base_game_info_t **list, const char* prefix, int gamecount, int excludeID) {
 211         char path[255];
 212         snprintf(path, 255, "%sul.cfg", prefix);
 213
 214         file_buffer_t* fileBuffer = openFileBuffer(path, O_WRONLY | O_CREAT | O_TRUNC, 0, 4096);
 215         if (fileBuffer) {
 216                 int i;
 217                 char buffer[0x40];
 218                 base_game_info_t* game;
 219
 220                 memset(buffer, 0, 0x40);
 221                 buffer[32] = 0x75; // u
 222                 buffer[33] = 0x6C; // l
 223                 buffer[34] = 0x2E; // .
 224                 buffer[53] = 0x08; // just to be compatible with original ul.cfg
 225
 226                 for (i = 0; i < gamecount; i++) {
 227                         game = &(*list)[i];
 228
 229                         if (!game->isISO  && (i != excludeID)) {
 230                                 memset(buffer, 0, UL_GAME_NAME_MAX);
 231                                 memset(&buffer[UL_GAME_NAME_MAX + 3], 0, GAME_STARTUP_MAX);
 232
 233                                 memcpy(buffer, game->name, UL_GAME_NAME_MAX);
 234                                 memcpy(&buffer[UL_GAME_NAME_MAX + 3], game->startup, GAME_STARTUP_MAX);
 235                                 buffer[47] = game->parts;
 236                                 buffer[48] = game->media;
 237
 238                                 writeFileBuffer(fileBuffer, buffer, 0x40);
 239                         }
 240                 }
 241
 242                 closeFileBuffer(fileBuffer);
 243         }
 244 }
 245
 246 void sbDelete(base_game_info_t **list, const char* prefix, const char* sep, int gamecount, int id) {
 247         char path[255];
 248         base_game_info_t* game = &(*list)[id];
 249
 250         if (game->isISO) {
 251                 if (game->media == 0x12)
 252                         snprintf(path, 255, "%sCD%s%s.%s%s", prefix, sep, game->startup, game->name, game->extension);
 253                 else
 254                         snprintf(path, 255, "%sDVD%s%s.%s%s", prefix, sep, game->startup, game->name, game->extension);
 255                 fileXioRemove(path);
 256         } else {
 257                 char *pathStr = "%sul.%08X.%s.%02x";
 258                 unsigned int crc = USBA_crc32(game->name);
 259                 int i = 0;
 260                 do {
 261                         snprintf(path, 255, pathStr, prefix, crc, game->startup, i++);
 262                         fileXioRemove(path);
 263                 } while(i < game->parts);
 264
 265                 sbRebuildULCfg(list, prefix, gamecount, id);
 266         }
 267 }
 268
 269 void sbRename(base_game_info_t **list, const char* prefix, const char* sep, int gamecount, int id, char* newname) {
 270         char oldpath[255], newpath[255];
 271         base_game_info_t* game = &(*list)[id];
 272
 273         if (game->isISO) {
 274                 if (game->media == 0x12) {
 275                         snprintf(oldpath, 255, "%sCD%s%s.%s%s", prefix, sep, game->startup, game->name, game->extension);
 276                         snprintf(newpath, 255, "%sCD%s%s.%s%s", prefix, sep, game->startup, newname, game->extension);
 277                 } else {
 278                         snprintf(oldpath, 255, "%sDVD%s%s.%s%s", prefix, sep, game->startup, game->name, game->extension);
 279                         snprintf(newpath, 255, "%sDVD%s%s.%s%s", prefix, sep, game->startup, newname, game->extension);
 280                 }
 281                 fileXioRename(oldpath, newpath);
 282         } else {
 283                 memset(game->name, 0, UL_GAME_NAME_MAX);
 284                 memcpy(game->name, newname, UL_GAME_NAME_MAX);
 285
 286                 char *pathStr = "%sul.%08X.%s.%02x";
 287                 unsigned int oldcrc = USBA_crc32(game->name);
 288                 unsigned int newcrc = USBA_crc32(newname);
 289                 int i = 0;
 290                 do {
 291                         snprintf(oldpath, 255, pathStr, prefix, oldcrc, game->startup, i);
 292                         snprintf(newpath, 255, pathStr, prefix, newcrc, game->startup, i++);
 293                         fileXioRename(oldpath, newpath);
 294                 } while(i < game->parts);
 295
 296                 sbRebuildULCfg(list, prefix, gamecount, -1);
 297         }
 298 }
 299
 300 config_set_t* sbPopulateConfig(base_game_info_t* game, const char* prefix, const char* sep) {
 301         char path[255];
 302         snprintf(path, 255, "%sCFG%s%s.cfg", prefix, sep, game->startup);
 303         config_set_t* config = configAlloc(0, NULL, path);
 304         configRead(config);
 305
 306         configSetStr(config, CONFIG_ITEM_NAME, game->name);
 307         if (game->sizeMB != -1)
 308                 configSetInt(config, CONFIG_ITEM_SIZE, game->sizeMB);
 309         if (game->isISO)
 310                 configSetStr(config, CONFIG_ITEM_FORMAT, "ISO");
 311         else
 312                 configSetStr(config, CONFIG_ITEM_FORMAT, "UL");
 313
 314         if (game->media == 0x12)
 315                 configSetStr(config, CONFIG_ITEM_MEDIA, "CD");
 316         else
 317                 configSetStr(config, CONFIG_ITEM_MEDIA, "DVD");
 318
 319         configSetStr(config, CONFIG_ITEM_STARTUP, game->startup);
 320
 321         return config;
 322 }