X-Git-Url: https://git.draconx.ca/gitweb/upkg.git/blobdiff_plain/a9b51e6d85e077f8e18c35ac3606d80b343927e0..a6f1f69cc4874e2f2f878289bfc0f677220dfda9:/src/upkg.c diff --git a/src/upkg.c b/src/upkg.c index 660819c..4a76fa2 100644 --- a/src/upkg.c +++ b/src/upkg.c @@ -1,6 +1,86 @@ +/* + * upkg: tool for manipulating Unreal Tournament packages. + * Copyright (C) 2009 Nick Bowler + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ + +#include #include #include +#include + +#include + #include "upkg.h" +#include "module.h" +#include "uobject.h" +#include "exportable.h" +#include "loadable.h" + +enum { + MODE_INFO, + MODE_EXPORT, + MODE_MAX +}; + +int verbose = 0; + +static const char *progname = "upkg"; +static const char *sopts = "ixvVH"; +static const struct option lopts[] = { + { "info", 0, NULL, 'i' }, + { "export", 0, NULL, 'x' }, + { "verbose", 0, NULL, 'v' }, + { "version", 0, NULL, 'V' }, + { "help", 0, NULL, 'H' }, + { 0 } +}; + +void print_version(void) +{ + printf("%s\n", PACKAGE_STRING); + puts("\ +Copyright (C) 2009 Nick Bowler.\n\ +This is free software: you are free to change and redistribute it.\n\ +There is NO WARRANTY, to the extent permitted by law." + ); +} + +void print_usage(FILE *f) +{ + fprintf(f, "Usage: %s [options] package\n", progname); +} + +void print_help(void) +{ + print_usage(stdout); + puts("Detailed help coming soon. Until then, I'll just list my options."); + for (unsigned i = 0; lopts[i].name; i++) { + const struct option *o = &lopts[i]; + printf("\t--%s", o->name); + + if (o->has_arg == 1) { + printf("=val"); + } else if (o->has_arg == 2) { + printf("[=val]"); + } + + printf(" (-%c)\n", o->val); + } +} void print_upkg_flags(const char *prefix, unsigned long flags) { @@ -18,36 +98,185 @@ void print_upkg_flags(const char *prefix, unsigned long flags) printf("%sRequired\n", prefix); } +void print_guid(unsigned char guid[static 16]) +{ + for (unsigned i = 0; i < 16; i++) { + printf("%02hhx", guid[i]); + if (i == 15) + putchar('\n'); + else + putchar(' '); + } +} -int main(int argc, char **argv) +void print_upkg_exports(struct upkg *pkg) { - struct upkg *pkg; + for (unsigned i = 0; i < pkg->export_count; i++) { + const char *name, *package, *class; - if (argc < 2) { - fprintf(stderr, "usage: upkg file\n"); - return EXIT_FAILURE; - } + name = upkg_export_name(pkg, i); + class = upkg_export_class(pkg, i, &package); - pkg = upkg_fopen(argv[1]); - if (!pkg) { - fprintf(stderr, "failed to open package!\n"); - return EXIT_FAILURE; + if (!name || !class) + continue; + + printf("%u - %s (%s.%s)\n", i+1, name, package, class); } +} +int package_info(struct upkg *pkg) +{ printf("Version: %u\n", pkg->version); printf("License: %u\n", pkg->license); + printf("GUID: "); + print_guid(pkg->guid); printf("Flags: %lx\n", pkg->flags); - print_upkg_flags("\t", pkg->flags); + if (verbose >= 1) { + print_upkg_flags("\t", pkg->flags); + } - printf("Names: %lu\n", pkg->name_count); - for (unsigned long i = 0; i < pkg->name_count; i++) { - printf("\t%s\n", upkg_get_name(pkg, i)); + if (verbose >= 1) { + printf("Names: %lu\n", pkg->name_count); + if (verbose >= 2) { + for (unsigned long i = 0; i < pkg->name_count; i++) { + printf("\t%s\n", upkg_get_name(pkg, i)); + } + } } printf("Exports: %lu\n", pkg->export_count); + if (verbose >= 1) print_upkg_exports(pkg); printf("Imports: %lu\n", pkg->import_count); + return EXIT_SUCCESS; +} + +static int export(struct upkg *pkg, GObject *obj, unsigned idx) +{ + struct upkg_file *f = upkg_export_open(pkg, idx); + char name[256]; + FILE *of; + int rc = -1; + + if (u_object_deserialize(obj, f) != 0) { + goto out; + } + + if (U_OBJECT_IS_LOADABLE(obj) && u_object_load(obj) != 0) { + goto out; + } + + u_object_export_name(obj, name, sizeof name); + + printf("exporting %s to %s\n", upkg_export_name(pkg, idx), name); + of = fopen(name, "wb"); + if (!of) { + perror(name); + goto out; + } + + rc = u_object_export(obj, of); + + if (fclose(of) != 0) { + perror(name); + rc = -1; + goto out; + } + + if (U_OBJECT_IS_LOADABLE(obj)) { + u_object_unload(obj); + } + +out: + upkg_export_close(f); + return rc; +} + +int package_export(struct upkg *pkg) +{ + const char *class, *package; + GObject *obj; + GType type; + int rc = EXIT_SUCCESS; + + for (unsigned i = 0; i < pkg->export_count; i++) { + class = upkg_export_class(pkg, i, &package); + if (!class) { + fprintf(stderr, "error getting class information.\n"); + return EXIT_FAILURE; + } + + type = module_get_class(package, class); + if (!type) continue; + + obj = g_object_new(type, NULL); + if (U_OBJECT_IS_EXPORTABLE(obj)) { + if (export(pkg, obj, i) != 0) { + rc = EXIT_FAILURE; + } + } + g_object_unref(obj); + } + + return rc; +} + +int main(int argc, char **argv) +{ + struct upkg *pkg; + unsigned mode = MODE_INFO; + int opt, rc = EXIT_FAILURE; + + if (argc > 0) progname = argv[0]; + + while ((opt = getopt_long(argc, argv, sopts, lopts, NULL)) != -1) { + switch (opt) { + case 'i': + mode = MODE_INFO; + break; + case 'x': + mode = MODE_EXPORT; + break; + case 'v': + verbose++; + break; + case 'V': + print_version(); + return EXIT_SUCCESS; + case 'H': + print_help(); + return EXIT_SUCCESS; + default: + print_usage(stderr); + return EXIT_FAILURE; + } + } + + if (argv[optind] == NULL) { + print_usage(stderr); + return EXIT_FAILURE; + } + + if (module_init() != 0) + return EXIT_FAILURE; + + pkg = upkg_fopen(argv[optind]); + if (!pkg) { + fprintf(stderr, "failed to open package!\n"); + return EXIT_FAILURE; + } + + switch (mode) { + case MODE_INFO: + rc = package_info(pkg); + break; + case MODE_EXPORT: + rc = package_export(pkg); + break; + } + upkg_close(pkg); - return 0; + module_exit(); + return rc; }