| 1 | /* Copyright (C) 2010-2020 The RetroArch team |
| 2 | * |
| 3 | * --------------------------------------------------------------------------------------- |
| 4 | * The following license statement only applies to this file (logiqx_dat.c). |
| 5 | * --------------------------------------------------------------------------------------- |
| 6 | * |
| 7 | * Permission is hereby granted, free of charge, |
| 8 | * to any person obtaining a copy of this software and associated documentation files (the "Software"), |
| 9 | * to deal in the Software without restriction, including without limitation the rights to |
| 10 | * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, |
| 11 | * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: |
| 12 | * |
| 13 | * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. |
| 14 | * |
| 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, |
| 16 | * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| 18 | * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, |
| 19 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 21 | */ |
| 22 | |
| 23 | #include <file/file_path.h> |
| 24 | #include <string/stdstring.h> |
| 25 | #include <formats/rxml.h> |
| 26 | |
| 27 | #include <formats/logiqx_dat.h> |
| 28 | |
| 29 | /* Holds all internal DAT file data */ |
| 30 | struct logiqx_dat |
| 31 | { |
| 32 | rxml_document_t *data; |
| 33 | rxml_node_t *current_node; |
| 34 | }; |
| 35 | |
| 36 | /* List of HTML formatting codes that must |
| 37 | * be replaced when parsing XML data */ |
| 38 | const char *logiqx_dat_html_code_list[][2] = { |
| 39 | {"&", "&"}, |
| 40 | {"'", "'"}, |
| 41 | {">", ">"}, |
| 42 | {"<", "<"}, |
| 43 | {""", "\""} |
| 44 | }; |
| 45 | |
| 46 | #define LOGIQX_DAT_HTML_CODE_LIST_SIZE 5 |
| 47 | |
| 48 | /* Validation */ |
| 49 | |
| 50 | /* Performs rudimentary validation of the specified |
| 51 | * Logiqx XML DAT file path (not rigorous - just |
| 52 | * enough to prevent obvious errors). |
| 53 | * Also provides access to file size (DAT files can |
| 54 | * be very large, so it is useful to have this information |
| 55 | * on hand - i.e. so we can check that the system has |
| 56 | * enough free memory to load the file). */ |
| 57 | bool logiqx_dat_path_is_valid(const char *path, uint64_t *file_size) |
| 58 | { |
| 59 | const char *file_ext = NULL; |
| 60 | int32_t file_size_int; |
| 61 | |
| 62 | if (string_is_empty(path)) |
| 63 | return false; |
| 64 | |
| 65 | /* Check file extension */ |
| 66 | file_ext = path_get_extension(path); |
| 67 | |
| 68 | if (string_is_empty(file_ext)) |
| 69 | return false; |
| 70 | |
| 71 | if (!string_is_equal_noncase(file_ext, "dat") && |
| 72 | !string_is_equal_noncase(file_ext, "xml")) |
| 73 | return false; |
| 74 | |
| 75 | /* Ensure file exists */ |
| 76 | if (!path_is_valid(path)) |
| 77 | return false; |
| 78 | |
| 79 | /* Get file size */ |
| 80 | file_size_int = path_get_size(path); |
| 81 | |
| 82 | if (file_size_int <= 0) |
| 83 | return false; |
| 84 | |
| 85 | if (file_size) |
| 86 | *file_size = (uint64_t)file_size_int; |
| 87 | |
| 88 | return true; |
| 89 | } |
| 90 | |
| 91 | /* File initialisation/de-initialisation */ |
| 92 | |
| 93 | /* Loads specified Logiqx XML DAT file from disk. |
| 94 | * Returned logiqx_dat_t object must be free'd using |
| 95 | * logiqx_dat_free(). |
| 96 | * Returns NULL if file is invalid or a read error |
| 97 | * occurs. */ |
| 98 | logiqx_dat_t *logiqx_dat_init(const char *path) |
| 99 | { |
| 100 | logiqx_dat_t *dat_file = NULL; |
| 101 | rxml_node_t *root_node = NULL; |
| 102 | |
| 103 | /* Check file path */ |
| 104 | if (!logiqx_dat_path_is_valid(path, NULL)) |
| 105 | goto error; |
| 106 | |
| 107 | /* Create logiqx_dat_t object */ |
| 108 | dat_file = (logiqx_dat_t*)calloc(1, sizeof(*dat_file)); |
| 109 | |
| 110 | if (!dat_file) |
| 111 | goto error; |
| 112 | |
| 113 | /* Read file from disk */ |
| 114 | dat_file->data = rxml_load_document(path); |
| 115 | |
| 116 | if (!dat_file->data) |
| 117 | goto error; |
| 118 | |
| 119 | /* Ensure root node has the correct name */ |
| 120 | root_node = rxml_root_node(dat_file->data); |
| 121 | |
| 122 | if (!root_node) |
| 123 | goto error; |
| 124 | |
| 125 | if (string_is_empty(root_node->name)) |
| 126 | goto error; |
| 127 | |
| 128 | /* > Logiqx XML uses: 'datafile' |
| 129 | * > MAME List XML uses: 'mame' |
| 130 | * > MAME 'Software List' uses: 'softwarelist' */ |
| 131 | if (!string_is_equal(root_node->name, "datafile") && |
| 132 | !string_is_equal(root_node->name, "mame") && |
| 133 | !string_is_equal(root_node->name, "softwarelist")) |
| 134 | goto error; |
| 135 | |
| 136 | /* Get pointer to initial child node */ |
| 137 | dat_file->current_node = root_node->children; |
| 138 | |
| 139 | if (!dat_file->current_node) |
| 140 | goto error; |
| 141 | |
| 142 | /* All is well - return logiqx_dat_t object */ |
| 143 | return dat_file; |
| 144 | |
| 145 | error: |
| 146 | logiqx_dat_free(dat_file); |
| 147 | return NULL; |
| 148 | } |
| 149 | |
| 150 | /* Frees specified DAT file */ |
| 151 | void logiqx_dat_free(logiqx_dat_t *dat_file) |
| 152 | { |
| 153 | if (!dat_file) |
| 154 | return; |
| 155 | |
| 156 | dat_file->current_node = NULL; |
| 157 | |
| 158 | if (dat_file->data) |
| 159 | { |
| 160 | rxml_free_document(dat_file->data); |
| 161 | dat_file->data = NULL; |
| 162 | } |
| 163 | |
| 164 | free(dat_file); |
| 165 | dat_file = NULL; |
| 166 | } |
| 167 | |
| 168 | /* Game information access */ |
| 169 | |
| 170 | /* Returns true if specified node is a 'game' entry */ |
| 171 | static bool logiqx_dat_is_game_node(rxml_node_t *node) |
| 172 | { |
| 173 | const char *node_name = NULL; |
| 174 | |
| 175 | if (!node) |
| 176 | return false; |
| 177 | |
| 178 | /* Check node name */ |
| 179 | node_name = node->name; |
| 180 | |
| 181 | if (string_is_empty(node_name)) |
| 182 | return false; |
| 183 | |
| 184 | /* > Logiqx XML uses: 'game' |
| 185 | * > MAME List XML uses: 'machine' |
| 186 | * > MAME 'Software List' uses: 'software' */ |
| 187 | return string_is_equal(node_name, "game") || |
| 188 | string_is_equal(node_name, "machine") || |
| 189 | string_is_equal(node_name, "software"); |
| 190 | } |
| 191 | |
| 192 | /* Returns true if specified node is a game |
| 193 | * node containing information for a game with |
| 194 | * the specified name */ |
| 195 | static bool logiqx_dat_game_node_matches_name( |
| 196 | rxml_node_t *node, const char *game_name) |
| 197 | { |
| 198 | const char *node_game_name = NULL; |
| 199 | |
| 200 | if (!logiqx_dat_is_game_node(node) || |
| 201 | string_is_empty(game_name)) |
| 202 | return false; |
| 203 | |
| 204 | /* Get 'name' attribute of XML node */ |
| 205 | node_game_name = rxml_node_attrib(node, "name"); |
| 206 | |
| 207 | if (string_is_empty(node_game_name)) |
| 208 | return false; |
| 209 | |
| 210 | return string_is_equal(node_game_name, game_name); |
| 211 | } |
| 212 | |
| 213 | /* The XML element data strings returned from |
| 214 | * DAT files are very 'messy'. This function |
| 215 | * removes all cruft, replaces formatting strings |
| 216 | * and copies the result (if valid) to 'str' */ |
| 217 | static void logiqx_dat_sanitise_element_data( |
| 218 | const char *data, char *str, size_t len) |
| 219 | { |
| 220 | char sanitised_data[PATH_MAX_LENGTH]; |
| 221 | size_t i; |
| 222 | |
| 223 | sanitised_data[0] = '\0'; |
| 224 | |
| 225 | if (string_is_empty(data)) |
| 226 | return; |
| 227 | |
| 228 | strlcpy(sanitised_data, data, sizeof(sanitised_data)); |
| 229 | |
| 230 | /* Element data includes leading/trailing |
| 231 | * newline characters - trim them away */ |
| 232 | string_trim_whitespace(sanitised_data); |
| 233 | |
| 234 | if (string_is_empty(sanitised_data)) |
| 235 | return; |
| 236 | |
| 237 | /* XML has a number of special characters that |
| 238 | * are handled using a HTML formatting codes. |
| 239 | * All of these have to be replaced... |
| 240 | * & -> & |
| 241 | * ' -> ' |
| 242 | * > -> > |
| 243 | * < -> < |
| 244 | * " -> " |
| 245 | */ |
| 246 | for (i = 0; i < LOGIQX_DAT_HTML_CODE_LIST_SIZE; i++) |
| 247 | { |
| 248 | const char *find_string = logiqx_dat_html_code_list[i][0]; |
| 249 | const char *replace_string = logiqx_dat_html_code_list[i][1]; |
| 250 | |
| 251 | /* string_replace_substring() is expensive |
| 252 | * > only invoke if element string contains |
| 253 | * HTML code */ |
| 254 | if (strstr(sanitised_data, find_string)) |
| 255 | { |
| 256 | char *tmp = string_replace_substring( |
| 257 | sanitised_data, |
| 258 | find_string, strlen(find_string), |
| 259 | replace_string, strlen(replace_string)); |
| 260 | |
| 261 | if (!string_is_empty(tmp)) |
| 262 | strlcpy(sanitised_data, tmp, sizeof(sanitised_data)); |
| 263 | |
| 264 | if (tmp) |
| 265 | free(tmp); |
| 266 | } |
| 267 | } |
| 268 | |
| 269 | if (string_is_empty(sanitised_data)) |
| 270 | return; |
| 271 | |
| 272 | /* All is well - can copy result */ |
| 273 | strlcpy(str, sanitised_data, len); |
| 274 | } |
| 275 | |
| 276 | /* Extracts game information from specified node. |
| 277 | * Returns false if node is invalid */ |
| 278 | static bool logiqx_dat_parse_game_node( |
| 279 | rxml_node_t *node, logiqx_dat_game_info_t *game_info) |
| 280 | { |
| 281 | const char *game_name = NULL; |
| 282 | const char *is_bios = NULL; |
| 283 | const char *is_runnable = NULL; |
| 284 | rxml_node_t *info_node = NULL; |
| 285 | bool description_found = false; |
| 286 | bool year_found = false; |
| 287 | bool manufacturer_found = false; |
| 288 | |
| 289 | if (!logiqx_dat_is_game_node(node)) |
| 290 | return false; |
| 291 | |
| 292 | if (!game_info) |
| 293 | return false; |
| 294 | |
| 295 | /* Initialise logiqx_dat_game_info_t object */ |
| 296 | game_info->name[0] = '\0'; |
| 297 | game_info->description[0] = '\0'; |
| 298 | game_info->year[0] = '\0'; |
| 299 | game_info->manufacturer[0] = '\0'; |
| 300 | game_info->is_bios = false; |
| 301 | game_info->is_runnable = true; |
| 302 | |
| 303 | /* Get game name */ |
| 304 | game_name = rxml_node_attrib(node, "name"); |
| 305 | |
| 306 | if (!string_is_empty(game_name)) |
| 307 | strlcpy(game_info->name, game_name, sizeof(game_info->name)); |
| 308 | |
| 309 | /* Get 'is bios' status */ |
| 310 | is_bios = rxml_node_attrib(node, "isbios"); |
| 311 | |
| 312 | if (!string_is_empty(is_bios)) |
| 313 | game_info->is_bios = string_is_equal(is_bios, "yes"); |
| 314 | |
| 315 | /* Get 'is runnable' status |
| 316 | * > Note: This attribute only exists in MAME List |
| 317 | * XML files, but there is no harm in checking for |
| 318 | * it generally. For normal Logiqx XML files, |
| 319 | * 'is runnable' is just the inverse of 'is bios' */ |
| 320 | is_runnable = rxml_node_attrib(node, "runnable"); |
| 321 | |
| 322 | if (!string_is_empty(is_runnable)) |
| 323 | game_info->is_runnable = string_is_equal(is_runnable, "yes"); |
| 324 | else |
| 325 | game_info->is_runnable = !game_info->is_bios; |
| 326 | |
| 327 | /* Loop over all game info nodes */ |
| 328 | for (info_node = node->children; info_node; info_node = info_node->next) |
| 329 | { |
| 330 | const char *info_node_name = info_node->name; |
| 331 | const char *info_node_data = info_node->data; |
| 332 | |
| 333 | if (string_is_empty(info_node_name)) |
| 334 | continue; |
| 335 | |
| 336 | /* Check description */ |
| 337 | if (string_is_equal(info_node_name, "description")) |
| 338 | { |
| 339 | logiqx_dat_sanitise_element_data( |
| 340 | info_node_data, game_info->description, |
| 341 | sizeof(game_info->description)); |
| 342 | description_found = true; |
| 343 | } |
| 344 | /* Check year */ |
| 345 | else if (string_is_equal(info_node_name, "year")) |
| 346 | { |
| 347 | logiqx_dat_sanitise_element_data( |
| 348 | info_node_data, game_info->year, |
| 349 | sizeof(game_info->year)); |
| 350 | year_found = true; |
| 351 | } |
| 352 | /* Check manufacturer */ |
| 353 | else if (string_is_equal(info_node_name, "manufacturer")) |
| 354 | { |
| 355 | logiqx_dat_sanitise_element_data( |
| 356 | info_node_data, game_info->manufacturer, |
| 357 | sizeof(game_info->manufacturer)); |
| 358 | manufacturer_found = true; |
| 359 | } |
| 360 | |
| 361 | /* If all required entries have been found, |
| 362 | * can end loop */ |
| 363 | if (description_found && year_found && manufacturer_found) |
| 364 | break; |
| 365 | } |
| 366 | |
| 367 | return true; |
| 368 | } |
| 369 | |
| 370 | /* Sets/resets internal node pointer to the first |
| 371 | * entry in the DAT file */ |
| 372 | void logiqx_dat_set_first(logiqx_dat_t *dat_file) |
| 373 | { |
| 374 | rxml_node_t *root_node = NULL; |
| 375 | |
| 376 | if (!dat_file) |
| 377 | return; |
| 378 | |
| 379 | if (!dat_file->data) |
| 380 | return; |
| 381 | |
| 382 | /* Get root node */ |
| 383 | root_node = rxml_root_node(dat_file->data); |
| 384 | |
| 385 | if (!root_node) |
| 386 | { |
| 387 | dat_file->current_node = NULL; |
| 388 | return; |
| 389 | } |
| 390 | |
| 391 | /* Get pointer to initial child node */ |
| 392 | dat_file->current_node = root_node->children; |
| 393 | } |
| 394 | |
| 395 | /* Fetches game information for the current entry |
| 396 | * in the DAT file and increments the internal node |
| 397 | * pointer. |
| 398 | * Returns false if the end of the DAT file has been |
| 399 | * reached (in which case 'game_info' will be invalid) */ |
| 400 | bool logiqx_dat_get_next( |
| 401 | logiqx_dat_t *dat_file, logiqx_dat_game_info_t *game_info) |
| 402 | { |
| 403 | if (!dat_file || !game_info) |
| 404 | return false; |
| 405 | |
| 406 | if (!dat_file->data) |
| 407 | return false; |
| 408 | |
| 409 | while (dat_file->current_node) |
| 410 | { |
| 411 | rxml_node_t *current_node = dat_file->current_node; |
| 412 | |
| 413 | /* Whatever happens, internal node pointer must |
| 414 | * be 'incremented' */ |
| 415 | dat_file->current_node = dat_file->current_node->next; |
| 416 | |
| 417 | /* If this is a game node, extract info |
| 418 | * and return */ |
| 419 | if (logiqx_dat_is_game_node(current_node)) |
| 420 | return logiqx_dat_parse_game_node(current_node, game_info); |
| 421 | } |
| 422 | |
| 423 | return false; |
| 424 | } |
| 425 | |
| 426 | /* Fetches information for the specified game. |
| 427 | * Returns false if game does not exist, or arguments |
| 428 | * are invalid. */ |
| 429 | bool logiqx_dat_search( |
| 430 | logiqx_dat_t *dat_file, const char *game_name, |
| 431 | logiqx_dat_game_info_t *game_info) |
| 432 | { |
| 433 | rxml_node_t *root_node = NULL; |
| 434 | rxml_node_t *game_node = NULL; |
| 435 | |
| 436 | if (!dat_file || !game_info || string_is_empty(game_name)) |
| 437 | return false; |
| 438 | |
| 439 | if (!dat_file->data) |
| 440 | return false; |
| 441 | |
| 442 | /* Get root node */ |
| 443 | root_node = rxml_root_node(dat_file->data); |
| 444 | |
| 445 | if (!root_node) |
| 446 | return false; |
| 447 | |
| 448 | /* Loop over all child nodes of the DAT file */ |
| 449 | for (game_node = root_node->children; game_node; game_node = game_node->next) |
| 450 | { |
| 451 | /* If this is the requested game, fetch info and return */ |
| 452 | if (logiqx_dat_game_node_matches_name(game_node, game_name)) |
| 453 | return logiqx_dat_parse_game_node(game_node, game_info); |
| 454 | } |
| 455 | |
| 456 | return false; |
| 457 | } |