src/upkg.c

   1 /*
   2  *  upkg: tool for manipulating Unreal Tournament packages.
   3  *  Copyright © 2009-2011 Nick Bowler
   4  *
   5  *  This program is free software: you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation, either version 3 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <config.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <errno.h>
  24 #include <getopt.h>
  25
  26 #include <glib-object.h>
  27
  28 #include "upkg.h"
  29 #include <uobject/uobject.h>
  30 #include <uobject/exportable.h>
  31 #include <uobject/loadable.h>
  32 #include <uobject/module.h>
  33 #include <uobject/package.h>
  34 #include <uobject/vfs.h>
  35
  36 enum {
  37         MODE_INFO,
  38         MODE_LIST,
  39         MODE_EXPORT,
  40         MODE_MAX
  41 };
  42
  43 int verbose = 0;
  44
  45 static const char *progname = "upkg";
  46 static const char *sopts = "ilxvf:VH";
  47 static const struct option lopts[] = {
  48         { "info",     0, NULL, 'i' },
  49         { "list",     0, NULL, 'l' },
  50         { "export",   0, NULL, 'x' },
  51         { "file",     1, NULL, 'f' },
  52         { "verbose",  0, NULL, 'v' },
  53         { "version",  0, NULL, 'V' },
  54         { "help",     0, NULL, 'H' },
  55         { 0 }
  56 };
  57
  58 void print_version(void)
  59 {
  60         printf("%s\n", PACKAGE_STRING);
  61         puts("\
  62 Copyright (C) 2009 Nick Bowler.\n\
  63 License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>.\n\
  64 This is free software: you are free to change and redistribute it.\n\
  65 There is NO WARRANTY, to the extent permitted by law."
  66         );
  67 }
  68
  69 void print_usage(FILE *f)
  70 {
  71         fprintf(f, "Usage: %s [options] [object ...]\n", progname);
  72 }
  73
  74 void print_help(void)
  75 {
  76         print_usage(stdout);
  77         puts("Detailed help coming soon.  Until then, I'll just list my options.");
  78         for (unsigned i = 0; lopts[i].name; i++) {
  79                 const struct option *o = &lopts[i];
  80                 printf("\t--%s", o->name);
  81
  82                 if (o->has_arg == 1) {
  83                         printf("=val");
  84                 } else if (o->has_arg == 2) {
  85                         printf("[=val]");
  86                 }
  87
  88                 printf(" (-%c)\n", o->val);
  89         }
  90 }
  91
  92 static void print_upkg_flags(const char *prefix, unsigned long flags)
  93 {
  94         if (flags & UPKG_FLAG_ALLOW_DOWNLOAD)
  95                 printf("%sAllowDownload\n", prefix);
  96         if (flags & UPKG_FLAG_CLIENT_OPTIONAL)
  97                 printf("%sClientOptional\n", prefix);
  98         if (flags & UPKG_FLAG_SERVER_ONLY)
  99                 printf("%sServerOnly\n", prefix);
 100         if (flags & UPKG_FLAG_BROKEN_LINKS)
 101                 printf("%sBrokenLinks\n", prefix);
 102         if (flags & UPKG_FLAG_INSECURE)
 103                 printf("%sInsecure\n", prefix);
 104         if (flags & UPKG_FLAG_REQUIRED)
 105                 printf("%sRequired\n", prefix);
 106 }
 107
 108 static void print_upkg_object_flags(const char *prefix, unsigned long flags)
 109 {
 110         if (flags & UPKG_OBJ_FLAG_TRANSACTIONAL)
 111                 printf("%sTransactional\n", prefix);
 112         if (flags & UPKG_OBJ_FLAG_UNREACHABLE)
 113                 printf("%sUnreachable\n", prefix);
 114         if (flags & UPKG_OBJ_FLAG_PUBLIC)
 115                 printf("%sPublic\n", prefix);
 116         if (flags & UPKG_OBJ_FLAG_TAG_IMPORT)
 117                 printf("%sImport\n", prefix);
 118         if (flags & UPKG_OBJ_FLAG_TAG_EXPORT)
 119                 printf("%sTagExport\n", prefix);
 120         if (flags & UPKG_OBJ_FLAG_SOURCE_MODIFIED)
 121                 printf("%sSourceModified\n", prefix);
 122         if (flags & UPKG_OBJ_FLAG_TAG_GARBAGE)
 123                 printf("%sTagGarbage\n", prefix);
 124         if (flags & UPKG_OBJ_FLAG_NEED_LOAD)
 125                 printf("%sNeedLoad\n", prefix);
 126         if (flags & UPKG_OBJ_FLAG_HIGHLIGHT_NAME)
 127                 printf("%sHighlightName\n", prefix);
 128         if (flags & UPKG_OBJ_FLAG_IN_SINGULAR_FUNC)
 129                 printf("%sInSingularFunc\n", prefix);
 130         if (flags & UPKG_OBJ_FLAG_SUPPRESSED)
 131                 printf("%sSuppressed\n", prefix);
 132         if (flags & UPKG_OBJ_FLAG_IN_END_STATE)
 133                 printf("%sInEndState\n", prefix);
 134         if (flags & UPKG_OBJ_FLAG_TRANSIENT)
 135                 printf("%sTransient\n", prefix);
 136         if (flags & UPKG_OBJ_FLAG_PRELOADING)
 137                 printf("%sPreloading\n", prefix);
 138         if (flags & UPKG_OBJ_FLAG_LOAD_FOR_CLIENT)
 139                 printf("%sLoadForClient\n", prefix);
 140         if (flags & UPKG_OBJ_FLAG_LOAD_FOR_SERVER)
 141                 printf("%sLoadForServer\n", prefix);
 142         if (flags & UPKG_OBJ_FLAG_LOAD_FOR_EDIT)
 143                 printf("%sLoadForEdit\n", prefix);
 144         if (flags & UPKG_OBJ_FLAG_STANDALONE)
 145                 printf("%sStandalone\n", prefix);
 146         if (flags & UPKG_OBJ_FLAG_NOT_FOR_CLIENT)
 147                 printf("%sNotForClient\n", prefix);
 148         if (flags & UPKG_OBJ_FLAG_NOT_FOR_SERVER)
 149                 printf("%sNotForServer\n", prefix);
 150         if (flags & UPKG_OBJ_FLAG_NOT_FOR_EDIT)
 151                 printf("%sNotForEdit\n", prefix);
 152         if (flags & UPKG_OBJ_FLAG_DESTROYED)
 153                 printf("%sDestroyed\n", prefix);
 154         if (flags & UPKG_OBJ_FLAG_NEED_POST_LOAD)
 155                 printf("%sNeedPostLoad\n", prefix);
 156         if (flags & UPKG_OBJ_FLAG_HAS_STACK)
 157                 printf("%sHasStack\n", prefix);
 158         if (flags & UPKG_OBJ_FLAG_NATIVE)
 159                 printf("%sNative\n", prefix);
 160         if (flags & UPKG_OBJ_FLAG_MARKED)
 161                 printf("%sMarked\n", prefix);
 162         if (flags & UPKG_OBJ_FLAG_ERROR_SHUTDOWN)
 163                 printf("%sErrorShutdown\n", prefix);
 164         if (flags & UPKG_OBJ_FLAG_DEBUG_POST_LOAD)
 165                 printf("%sDebugPostLoad\n", prefix);
 166         if (flags & UPKG_OBJ_FLAG_DEBUG_SERIALIZE)
 167                 printf("%sDebugSerialize\n", prefix);
 168         if (flags & UPKG_OBJ_FLAG_DEBUG_DESTROY)
 169                 printf("%sDebugDestroy\n", prefix);
 170 }
 171
 172 void print_guid(unsigned char guid[static 16])
 173 {
 174         for (unsigned i = 0; i < 16; i++) {
 175                 printf("%02hhx", guid[i]);
 176                 if (i == 15)
 177                         putchar('\n');
 178                 else
 179                         putchar(' ');
 180         }
 181 }
 182
 183 void print_upkg_exports(struct upkg *pkg)
 184 {
 185         for (unsigned i = 0; i < pkg->export_count; i++) {
 186                 const struct upkg_export *export = upkg_get_export(pkg, i);
 187                 const char *package, *class;
 188
 189                 class = upkg_export_class(pkg, i, &package);
 190
 191                 if (!class)
 192                         continue;
 193
 194                 printf("%u - %s (%s.%s)\n", i+1, export->name, package, class);
 195                 printf("  Flags: %lx\n", export->flags);
 196                 if (verbose >= 2) {
 197                         print_upkg_object_flags("    ", export->flags);
 198                 }
 199         }
 200 }
 201
 202 int package_info(struct upkg *pkg)
 203 {
 204         printf("Version: %u\n",  pkg->version);
 205         printf("License: %u\n",  pkg->license);
 206         printf("GUID: ");
 207         print_guid(pkg->guid);
 208
 209         printf("Flags:   %lx\n", pkg->flags);
 210         if (verbose >= 2) {
 211                 print_upkg_flags("        ", pkg->flags);
 212         }
 213
 214         printf("Names:   %lu\n", pkg->name_count);
 215         if (verbose >= 3) {
 216                 for (unsigned long i = 0; i < pkg->name_count; i++) {
 217                         printf("%lu - %s\n", i, upkg_get_name(pkg, i));
 218                 }
 219         }
 220
 221         printf("Exports: %lu\n", pkg->export_count);
 222         if (verbose >= 1) print_upkg_exports(pkg);
 223         printf("Imports: %lu\n", pkg->import_count);
 224
 225         return 0;
 226 }
 227
 228 static void export_print_name(struct upkg *upkg, const struct upkg_export *e)
 229 {
 230         if (e) {
 231                 export_print_name(upkg, upkg_get_export(upkg, e->package-1));
 232                 printf(".%s", e->name);
 233         }
 234 }
 235
 236 static void
 237 export_print_fullname(GTypeModule *pkg, const struct upkg_export *export)
 238 {
 239         printf("%s", pkg->name);
 240         export_print_name(U_PKG(pkg)->pkg, export);
 241 }
 242
 243 static int package_list(GTypeModule *pkg, long parent)
 244 {
 245         struct upkg *upkg = U_PKG(pkg)->pkg;
 246         const struct upkg_export *export;
 247
 248         for (unsigned i = 0; i < upkg->export_count; i++) {
 249                 export = upkg_get_export(upkg, i);
 250
 251                 if (export->package != parent)
 252                         continue;
 253
 254                 export_print_fullname(pkg, export);
 255
 256                 if (verbose >= 1) {
 257                         const char *class, *package;
 258
 259                         class = upkg_export_class(upkg, i, &package);
 260                         printf(" (%s.%s)", package, class);
 261                 }
 262
 263                 putchar('\n');
 264         }
 265
 266         return 0;
 267 }
 268
 269 static int object_info(GTypeModule *pkg, unsigned long idx)
 270 {
 271         struct upkg *upkg = U_PKG(pkg)->pkg;
 272         const struct upkg_export *export;
 273         const char *class, *package;
 274
 275         export = upkg_get_export(upkg, idx);
 276         export_print_fullname(pkg, export);
 277
 278         class = upkg_export_class(upkg, idx, &package);
 279         printf(" (%s.%s)\n", package, class);
 280
 281         /* Print out object properties. */
 282         if (verbose >= 1) {
 283                 GParamSpec **props;
 284                 GObject *obj;
 285                 unsigned n;
 286
 287                 obj = u_object_new_from_package(upkg, idx);
 288                 if (!obj) {
 289                         fprintf(stderr, "%s: failed to load object.\n",
 290                                         progname);
 291                         return -1;
 292                 }
 293
 294                 props = g_object_class_list_properties(G_OBJECT_GET_CLASS(obj), &n);
 295                 for (unsigned i = 0; i < n; i++) {
 296                         GValue val = {0};
 297                         char *valstr;
 298
 299                         printf("  property %s:", props[i]->name);
 300                         fflush(stdout);
 301
 302                         g_value_init(&val, props[i]->value_type);
 303                         g_object_get_property(obj, props[i]->name, &val);
 304
 305                         if (G_VALUE_HOLDS(&val, U_TYPE_OBJECT)) {
 306                                 UObject *obj = g_value_get_object(&val);
 307
 308                                 /* TODO: Display full object names here. */
 309                                 if (obj->pkg_file) {
 310                                         printf(" %s", obj->pkg_file->name);
 311                                 }
 312                         }
 313
 314                         valstr = g_strdup_value_contents(&val);
 315                         printf(" %s\n", valstr);
 316                         g_free(valstr);
 317                 }
 318                 free(props);
 319
 320                 g_object_unref(obj);
 321         }
 322
 323         /* Print raw file info. */
 324         if (verbose >= 3) {
 325                 struct upkg_file *f = upkg_export_open(upkg, idx);
 326                 if (!f) {
 327                         fprintf(stderr, "%s: failed to open export.\n",
 328                                         progname);
 329                         return -1;
 330                 }
 331
 332                 printf("  file size: %lu\n", f->len);
 333                 printf("  file start: %#lx\n", f->base);
 334                 printf("  file end: %#lx\n", f->base + f->len);
 335
 336                 upkg_export_close(f);
 337         }
 338
 339         return 0;
 340 }
 341
 342 static int export(GTypeModule *pkg, GObject *obj, unsigned idx)
 343 {
 344         struct upkg *upkg = U_PKG(pkg)->pkg;
 345         char name[256];
 346         FILE *of;
 347         int rc;
 348
 349         if (U_OBJECT_IS_LOADABLE(obj) && u_object_load(obj) != 0) {
 350                 fprintf(stderr, "%s: failed to load export data.\n", progname);
 351                 return -1;
 352         }
 353
 354         rc = u_object_export_name(obj, name, sizeof name);
 355         if (rc <= 0) {
 356                 /* XXX: We could use a default name here. */
 357                 fprintf(stderr, "%s: failed to determine export filename.\n",
 358                                 progname);
 359                 return -1;
 360         }
 361
 362         printf("exporting ");
 363         export_print_fullname(pkg, upkg_get_export(upkg, idx));
 364         printf(" to %s\n", name);
 365
 366         of = fopen(name, "wb");
 367         if (!of) {
 368                 perror(name);
 369                 return -1;
 370         }
 371
 372         u_object_export(obj, of);
 373
 374         if (fclose(of) != 0) {
 375                 perror(name);
 376                 return -1;
 377         }
 378
 379         if (U_OBJECT_IS_LOADABLE(obj)) {
 380                 u_object_unload(obj);
 381         }
 382
 383         return 0;
 384 }
 385
 386 static int object_export(GTypeModule *pkg, unsigned long idx)
 387 {
 388         struct upkg *upkg = U_PKG(pkg)->pkg;
 389         GObject *obj;
 390         int ret = -1;
 391
 392         obj = u_object_new_from_package(upkg, idx);
 393         if (!obj) {
 394                 fprintf(stderr, "%s: failed to load object.\n", progname);
 395                 return -1;
 396         }
 397
 398         if (!U_OBJECT_IS_EXPORTABLE(obj)) {
 399                 fprintf(stderr, "%s: object is not exportable.\n", progname);
 400                 goto out;
 401         }
 402
 403         ret = export(pkg, obj, idx);
 404 out:
 405         g_object_unref(obj);
 406         return ret;
 407 }
 408
 409 int package_export(GTypeModule *pkg)
 410 {
 411         struct upkg *upkg = U_PKG(pkg)->pkg;
 412         const char *class, *package;
 413         GObject *obj;
 414         GType type;
 415         int ret = 0;
 416
 417         for (unsigned i = 0; i < upkg->export_count; i++) {
 418                 class = upkg_export_class(upkg, i, &package);
 419                 if (!class) {
 420                         fprintf(stderr, "error getting class information.\n");
 421                         return -1;
 422                 }
 423
 424                 type = u_object_module_get_class(package, class);
 425                 if (!type)
 426                         continue;
 427
 428                 obj = g_object_new(type, NULL);
 429                 if (U_OBJECT_IS_EXPORTABLE(obj)) {
 430                         if (u_object_deserialize(obj, upkg, i) != 0
 431                             || export(pkg, obj, i) != 0) {
 432                                 ret = -1;
 433                         }
 434                 }
 435                 g_object_unref(obj);
 436         }
 437
 438         return ret;
 439 }
 440
 441 static int process_object(int mode, const char *objname)
 442 {
 443         char work[strlen(objname)+1], *p = work, *c;
 444         GTypeModule *pkg;
 445         long current = -1;
 446         int ret = 0;
 447
 448         strcpy(work, objname);
 449
 450         /* First, find and open the actual package. */
 451         c = strchr(p, '.');
 452         if (c) *c = 0;
 453
 454         pkg = u_pkg_open(p);
 455         if (!pkg || !g_type_module_use(pkg)) {
 456                 fprintf(stderr, "%s: %s: failed to open package.\n",
 457                                 progname, work);
 458                 goto out;
 459         }
 460
 461         if (!U_PKG(pkg)->pkg) {
 462                 if (u_pkg_is_native(pkg)) {
 463                         fprintf(stderr, "%s: %s: not a UObject package.\n",
 464                                         progname, work);
 465                 } else {
 466                         fprintf(stderr, "%s: %s: package not found.\n",
 467                                         progname, work);
 468                 }
 469
 470                 goto out_unuse;
 471         }
 472
 473         /* Resolve the hierarchical reference. */
 474         while (c) {
 475                 p = c+1;
 476                 c = strchr(p, '.');
 477                 if (c) *c = 0;
 478
 479                 current = upkg_export_find(U_PKG(pkg)->pkg, current, p);
 480                 if (current == -1) {
 481                         /* We want to print the full name up to this point. */
 482                         strcpy(work, objname);
 483                         if (c) *c = 0;
 484
 485                         fprintf(stderr, "%s: %s: object not found.\n",
 486                                         progname, work);
 487                         goto out_unuse;
 488                 }
 489         }
 490
 491         switch (mode) {
 492         case MODE_INFO:
 493                 if (current < 0)
 494                         ret = package_info(U_PKG(pkg)->pkg);
 495                 else
 496                         ret = object_info(pkg, current);
 497                 break;
 498         case MODE_LIST:
 499                 ret = package_list(pkg, current+1);
 500                 break;
 501         case MODE_EXPORT:
 502                 if (current < 0)
 503                         ret = package_export(pkg);
 504                 else
 505                         ret = object_export(pkg, current);
 506                 break;
 507         default:
 508                 abort();
 509         }
 510
 511 out_unuse:
 512         g_type_module_unuse(pkg);
 513 out:
 514         return ret;
 515 }
 516
 517 int main(int argc, char **argv)
 518 {
 519         const char *pkgname = NULL;
 520         unsigned mode = MODE_INFO;
 521         int opt, rc;
 522
 523         if (argc > 0) progname = argv[0];
 524
 525         if (u_pkg_vfs_init() != 0)
 526                 return EXIT_FAILURE;
 527         if (u_object_module_init() != 0)
 528                 return EXIT_FAILURE;
 529
 530         while ((opt = getopt_long(argc, argv, sopts, lopts, NULL)) != -1) {
 531                 switch (opt) {
 532                 case 'f':
 533                         pkgname = u_pkg_vfs_add_local(NULL, optarg);
 534                         if (!pkgname) {
 535                                 fprintf(stderr, "failed to add package `%s'.\n", optarg);
 536                                 return EXIT_FAILURE;
 537                         }
 538                         break;
 539                 case 'i':
 540                         mode = MODE_INFO;
 541                         break;
 542                 case 'l':
 543                         mode = MODE_LIST;
 544                         break;
 545                 case 'x':
 546                         mode = MODE_EXPORT;
 547                         break;
 548                 case 'v':
 549                         verbose++;
 550                         break;
 551                 case 'V':
 552                         print_version();
 553                         return EXIT_SUCCESS;
 554                 case 'H':
 555                         print_help();
 556                         return EXIT_SUCCESS;
 557                 default:
 558                         print_usage(stderr);
 559                         return EXIT_FAILURE;
 560                 }
 561         }
 562
 563         if (!pkgname && !argv[optind]) {
 564                 print_usage(stderr);
 565                 return EXIT_FAILURE;
 566         }
 567
 568         rc = EXIT_SUCCESS;
 569         if (argv[optind]) {
 570                 for (int i = optind; i < argc; i++) {
 571                         if (process_object(mode, argv[i]) != 0)
 572                                 rc = EXIT_FAILURE;
 573                 }
 574         } else {
 575                 if (process_object(mode, pkgname) != 0)
 576                         rc = EXIT_FAILURE;
 577         }
 578
 579         u_object_module_exit();
 580         u_pkg_vfs_exit();
 581         return rc;
 582 }