src/uobject/uobject.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 <stdio.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <stdarg.h>
  23 #include <stdbool.h>
  24 #include <inttypes.h>
  25 #include <assert.h>
  26 #include <glib-object.h>
  27
  28 #include <uobject/uobject.h>
  29 #include <uobject/module.h>
  30 #include <uobject/package.h>
  31 #include "upkg.h"
  32 #include "pack.h"
  33
  34 #define U_OBJECT_GET_PRIV(o) \
  35         G_TYPE_INSTANCE_GET_PRIVATE(o, U_TYPE_OBJECT, struct u_object_priv)
  36
  37
  38 struct prop_head {
  39         const char *prop_name, *struct_name;
  40         unsigned long size, array_idx;
  41         bool tag_msb;
  42
  43         enum {
  44                 PROPERTY_END,
  45                 PROPERTY_BYTE,
  46                 PROPERTY_INTEGER,
  47                 PROPERTY_BOOLEAN,
  48                 PROPERTY_FLOAT,
  49                 PROPERTY_OBJECT,
  50                 PROPERTY_NAME,
  51                 PROPERTY_STRING,
  52                 PROPERTY_CLASS,
  53                 PROPERTY_ARRAY,
  54                 PROPERTY_STRUCT,
  55                 PROPERTY_VECTOR,
  56                 PROPERTY_ROTATOR,
  57                 PROPERTY_STR,
  58                 PROPERTY_MAP,
  59                 PROPERTY_FIXEDARRAY,
  60         } type;
  61 };
  62
  63 struct u_object_priv {
  64         struct upkg_file *f;
  65         size_t base, len;
  66
  67         unsigned char buf[2048];
  68         unsigned long nbuf;
  69 };
  70
  71 G_DEFINE_TYPE(UObject, u_object, G_TYPE_OBJECT);
  72
  73 /*
  74  * Determine the actual size (in bytes) of a property, given the 3-bit encoded
  75  * size from the tag byte.  Depending on the tag size, there will be 0, 1, 2
  76  * or 4 additional size bytes, which are to be found in the provided buffer
  77  * which is at least n bytes long.  The result is stored in *size.
  78  *
  79  * Returns the number of bytes that were read from the buffer, which may be 0.
  80  * On failure, (i.e., there was not enough material in the buffer) 0 is stored
  81  * in *size.
  82  */
  83 static unsigned long
  84 decode_tag_size(unsigned long *size, unsigned tag_size,
  85                 const unsigned char *buf, unsigned long n)
  86 {
  87         *size = 0;
  88
  89         switch (tag_size) {
  90         case 0: *size =  1; return 0;
  91         case 1: *size =  2; return 0;
  92         case 2: *size =  4; return 0;
  93         case 3: *size = 12; return 0;
  94         case 4: *size = 16; return 0;
  95         case 5:
  96                 if (n < 1)
  97                         return 0;
  98                 *size = buf[0];
  99                 return 1;
 100         case 6:
 101                 if (n < 2)
 102                         return 0;
 103                 *size = unpack_16_le(buf);
 104                 return 2;
 105         case 7:
 106                 if (n < 4)
 107                         return 0;
 108                 *size = unpack_32_le(buf);
 109                 return 4;
 110         }
 111
 112         assert(0);
 113 }
 114
 115 static unsigned long
 116 decode_array_index(unsigned long *index, const unsigned char *buf,
 117                                          unsigned long n)
 118 {
 119         if (n < 1)
 120                 return 0;
 121
 122         /* TODO: Actually implement this instead of aborting. */
 123         assert("FIXME" && !(buf[0] & 0x80));
 124
 125         *index = buf[0];
 126         return 1;
 127 }
 128
 129 /*
 130  * Decode the (mostly) generic property header, filling out the struct pointed
 131  * to by head.  Returns the number of bytes read from the buffer, or 0 on
 132  * failure.
 133  */
 134 static unsigned long
 135 decode_prop_header(struct upkg *upkg, struct prop_head *head,
 136                    const unsigned char *buf, unsigned long n)
 137 {
 138         unsigned long rc, len = 0;
 139         unsigned char tag_size;
 140         long index;
 141
 142         rc = upkg_decode_index(&index, buf+len, n-len);
 143         if (rc == 0)
 144                 return 0;
 145         if (!(head->prop_name = upkg_get_name(upkg, index)))
 146                 return 0;
 147         len += rc;
 148
 149         /* A property called "None" terminates the list, and does not have
 150          * the usual header. */
 151         if (!strcmp(head->prop_name, "None")) {
 152                 head->type = PROPERTY_END;
 153                 head->size = 0;
 154                 return len;
 155         }
 156
 157         if (n-len < 1)
 158                 return 0;
 159         head->tag_msb = (buf[len] >> 7) & 0x01;
 160         tag_size      = (buf[len] >> 4) & 0x07;
 161         head->type    = (buf[len] >> 0) & 0x0f;
 162         len++;
 163
 164         /*
 165          * TODO: Confirm the correct relative ordering of the next three
 166          * fields.
 167          */
 168         if (head->type == PROPERTY_STRUCT) {
 169                 rc = upkg_decode_index(&index, buf+len, n-len);
 170                 if (rc == 0)
 171                         return 0;
 172                 if (!(head->struct_name = upkg_get_name(upkg, index)))
 173                         return 0;
 174                 len += rc;
 175         }
 176
 177         rc = decode_tag_size(&head->size, tag_size, buf+len, n-len);
 178         if (rc == 0 && head->size == 0)
 179                 return 0;
 180         len += rc;
 181
 182         head->array_idx = 0;
 183         if (head->tag_msb && head->type != PROPERTY_BOOLEAN) {
 184                 rc = decode_array_index(&head->array_idx, buf+len, n-len);
 185                 if (rc == 0)
 186                         return 0;
 187                 len += rc;
 188         }
 189
 190         return len;
 191 }
 192
 193 /*
 194  * TODO: Make this use the uobject_module stuff so packages are not loaded
 195  * more than once.
 196  */
 197 static GTypeModule *
 198 open_import_package(UObject *uo, const struct upkg_import *i)
 199 {
 200         GTypeModule *pkg;
 201
 202         assert(i->parent == NULL);
 203
 204         if (strcmp(i->class_package, "Core") != 0
 205             || strcmp(i->class_name, "Package") != 0) {
 206                 u_err(uo, "import root must be Core.Package");
 207                 return NULL;
 208         }
 209
 210         pkg = u_pkg_open(i->name);
 211         if (!pkg || !g_type_module_use(pkg)) {
 212                 u_err(uo, "failed to open package: %s", i->name);
 213                 return NULL;
 214         }
 215
 216         if (!U_PKG(pkg)->pkg) {
 217                 g_type_module_unuse(pkg);
 218                 u_err(uo, "failed to open package: %s", pkg->name);
 219                 return NULL;
 220         }
 221
 222         return pkg;
 223 }
 224
 225 /* Find the export index of a package based on the import chain from another
 226  * package.  Returns the (non-negative) offset on success, or a negative value
 227  * on failure. */
 228 static long resolve_import(struct upkg *pkg, const struct upkg_import *import)
 229 {
 230         long current, index;
 231
 232         if (!import->parent)
 233                 return -1;
 234
 235         current = resolve_import(pkg, import->parent);
 236         if (current != -1 && current >= 0)
 237                 return -42;
 238
 239         index = upkg_export_find(pkg, current, import->name);
 240         if (index < 0)
 241                 return -42;
 242
 243         return index;
 244 }
 245
 246 static GObject *get_import_object(UObject *uo, unsigned long index)
 247 {
 248         const struct upkg_import *import;
 249         GObject *obj = NULL;
 250         GTypeModule *pkg;
 251         long obj_index;
 252
 253         import = upkg_get_import(uo->pkg_file->pkg, index);
 254         if (!import) {
 255                 u_err(uo, "invalid package import: %ld", index);
 256                 return NULL;
 257         }
 258
 259         /* Get the package name at the top of the hierarchy. */
 260         for (const struct upkg_import *i = import; i; i = i->parent) {
 261                 if (i->parent == NULL) {
 262                         pkg = open_import_package(uo, i);
 263                         if (!pkg)
 264                                 return NULL;
 265                 }
 266         }
 267
 268         obj_index = resolve_import(U_PKG(pkg)->pkg, import);
 269         if (obj_index < 0) {
 270                 u_err(uo, "could not find import in package: %s", pkg->name);
 271                 goto out;
 272         }
 273
 274         obj = u_object_new_from_package(pkg, obj_index);
 275 out:
 276         g_type_module_unuse(pkg);
 277         return obj;
 278 }
 279
 280 static int decode_object_property(UObject *uo, GValue *val, unsigned long len)
 281 {
 282         struct u_object_priv *priv = U_OBJECT_GET_PRIV(uo);
 283         GObject *obj = NULL;
 284         long index;
 285         int rc;
 286
 287         rc = upkg_decode_index(&index, priv->buf+len, priv->nbuf-len);
 288         if (rc == 0 || index == 0)
 289                 return -1;
 290
 291         if (index < 0) {
 292                 obj = get_import_object(uo, -(index+1));
 293         } else {
 294                 obj = u_object_new_from_package(uo->pkg, index-1);
 295         }
 296
 297         g_value_init(val, U_TYPE_OBJECT);
 298         g_value_take_object(val, obj);
 299         return 0;
 300 }
 301
 302 static unsigned long deserialize_property(UObject *uo, struct prop_head *head)
 303 {
 304         struct u_object_priv *priv = U_OBJECT_GET_PRIV(uo);
 305         unsigned long rc, len = 0;
 306         GValue val = {0};
 307
 308         rc = decode_prop_header(uo->pkg_file->pkg, head, priv->buf, priv->nbuf);
 309         if (rc == 0)
 310                 return 0;
 311         len += rc;
 312
 313         switch (head->type) {
 314         case PROPERTY_END:
 315                 break;
 316         case PROPERTY_BYTE:
 317                 if (priv->nbuf-len < 1)
 318                         return 0;
 319                 g_value_init(&val, G_TYPE_UCHAR);
 320                 g_value_set_uchar(&val, priv->buf[len]);
 321                 g_object_set_property(G_OBJECT(uo), head->prop_name, &val);
 322                 break;
 323         case PROPERTY_INTEGER:
 324                 if (priv->nbuf-len < 4)
 325                         return 0;
 326                 g_value_init(&val, G_TYPE_ULONG);
 327                 g_value_set_ulong(&val, unpack_32_le(priv->buf+len));
 328                 g_object_set_property(G_OBJECT(uo), head->prop_name, &val);
 329                 break;
 330         case PROPERTY_BOOLEAN:
 331                 g_value_init(&val, G_TYPE_BOOLEAN);
 332                 g_value_set_boolean(&val, head->tag_msb);
 333                 g_object_set_property(G_OBJECT(uo), head->prop_name, &val);
 334                 break;
 335         case PROPERTY_OBJECT:
 336                 rc = decode_object_property(uo, &val, len);
 337                 if (rc != 0)
 338                         return 0;
 339                 g_object_set_property(G_OBJECT(uo), head->prop_name, &val);
 340                 break;
 341         default:
 342                 fprintf(stderr, "Unhandled property type %x\n",
 343                                 (unsigned)head->type);
 344         }
 345         len += head->size;
 346
 347         if (len > priv->nbuf) {
 348                 long skip = len - priv->nbuf;
 349
 350                 /* XXX: Long properties are not supported yet, so just seek
 351                  * past them for now. */
 352                 if (upkg_export_seek(uo->pkg_file, skip, SEEK_CUR) != 0)
 353                         return 0;
 354
 355                 priv->nbuf = 0;
 356         } else {
 357                 priv->nbuf -= len;
 358                 memmove(priv->buf, priv->buf+len, priv->nbuf-len);
 359         }
 360
 361         return len;
 362 }
 363
 364 /* Deserialize properties from an Unreal package. */
 365 static int deserialize(UObject *uo)
 366 {
 367         struct u_object_priv *priv = U_OBJECT_GET_PRIV(uo);
 368         struct upkg_file *f = uo->pkg_file;
 369         unsigned long rc, tot_len = 0;
 370
 371         while (1) {
 372                 struct prop_head head;
 373
 374                 /* Prime the buffer; deserialize_property assumes that there's
 375                  * enough data for "small" properties already available. */
 376                 if (!f->eof) {
 377                         void  *buf = priv->buf + priv->nbuf;
 378                         size_t amt = sizeof priv->buf - priv->nbuf;
 379                         rc = upkg_export_read(f, buf, amt);
 380                         if (rc == 0 && priv->nbuf == 0)
 381                                 return -1;
 382                         priv->nbuf += rc;
 383                 }
 384
 385                 rc = deserialize_property(uo, &head);
 386                 if (rc == 0) {
 387                         return -1;
 388                 }
 389                 tot_len += rc;
 390
 391                 if (head.type == PROPERTY_END)
 392                         break;
 393         }
 394
 395         f->base += tot_len;
 396         f->len  -= tot_len;
 397         upkg_export_seek(f, 0, SEEK_SET);
 398
 399         return 0;
 400 }
 401
 402 /*
 403  * Get the full hierarchical object name for an export, used for diagnostics.
 404  * The package name is passed in pname.
 405  *
 406  * Returns a buffer allocated by malloc on success, or NULL on failure.
 407  */
 408 static char *get_obj_fullname(const char *pname, const struct upkg_export *e)
 409 {
 410         size_t total_len = strlen(pname) + 1, len;
 411         char *fullname;
 412
 413         assert(e != NULL);
 414
 415         for (const struct upkg_export *c = e; c; c = c->parent) {
 416                 len = strlen(c->name) + 1;
 417                 if (total_len > SIZE_MAX - len)
 418                         return NULL;
 419                 total_len += len;
 420         }
 421
 422         fullname = malloc(total_len);
 423         if (!fullname)
 424                 return NULL;
 425
 426         for (const struct upkg_export *c = e; c; c = c->parent) {
 427                 len = strlen(c->name);
 428                 assert(total_len > len);
 429
 430                 total_len -= len + 1;
 431                 memcpy(fullname + total_len, c->name, len);
 432                 fullname[total_len + len] = c == e ? '\0' : '.';
 433         }
 434
 435         assert(total_len == strlen(pname)+1);
 436         memcpy(fullname, pname, total_len-1);
 437         fullname[total_len-1] = '.';
 438
 439         return fullname;
 440 }
 441
 442 int u_object_deserialize(GObject *obj, GTypeModule *pkg, unsigned long idx)
 443 {
 444         g_return_val_if_fail(IS_U_OBJECT(obj), -1);
 445         g_return_val_if_fail(IS_U_PKG(pkg), -1);
 446
 447         UObject *uo = U_OBJECT(obj);
 448         struct upkg *upkg = U_PKG(pkg)->pkg;
 449         const struct upkg_export *e;
 450         struct upkg_file *f;
 451         int rc;
 452
 453         g_return_val_if_fail(uo->pkg_file == NULL, -1);
 454         f = upkg_export_open(upkg, idx);
 455         if (!f) {
 456                 return -1;
 457         }
 458
 459         uo->pkg = pkg;
 460         uo->pkg_file = f;
 461
 462         e = upkg_get_export(upkg, idx);
 463         if (!e)
 464                 return -1;
 465         uo->pkg_name = get_obj_fullname(pkg->name, e);
 466         if (!uo->pkg_name)
 467                 return -1;
 468
 469         rc = U_OBJECT_GET_CLASS(obj)->deserialize(uo);
 470         if (rc != 0) {
 471                 upkg_export_close(f);
 472                 uo->pkg_file = NULL;
 473         }
 474
 475         return rc;
 476 }
 477
 478 GObject *u_object_new_from_package(GTypeModule *pkg, unsigned long idx)
 479 {
 480         g_return_val_if_fail(IS_U_PKG(pkg), NULL);
 481
 482         const char *class, *package;
 483         GObject *obj = NULL;
 484         GType type;
 485
 486         class = upkg_export_class(U_PKG(pkg)->pkg, idx, &package);
 487
 488         type = u_object_module_get_class(package, class);
 489         if (type) {
 490                 obj = g_object_new(type, NULL);
 491                 if (u_object_deserialize(obj, pkg, idx) != 0) {
 492                         g_object_unref(obj);
 493                         return NULL;
 494                 }
 495         }
 496
 497         return obj;
 498 }
 499
 500 static void u_object_init(UObject *o)
 501 {
 502         o->pkg      = NULL;
 503         o->pkg_file = NULL;
 504 }
 505
 506 static void u_object_finalize(GObject *o)
 507 {
 508         UObject *uo = U_OBJECT(o);
 509
 510         if (uo->pkg_file) {
 511                 upkg_export_close(uo->pkg_file);
 512         }
 513
 514         free(uo->pkg_name);
 515
 516         G_OBJECT_CLASS(u_object_parent_class)->finalize(o);
 517 }
 518
 519 static void u_object_class_init(UObjectClass *class)
 520 {
 521         g_type_class_add_private(class, sizeof (struct u_object_priv));
 522         GObjectClass *go = G_OBJECT_CLASS(class);
 523
 524         class->deserialize = deserialize;
 525         go->finalize       = u_object_finalize;
 526 }
 527
 528 /*
 529  * Prepend a prefix to a printf-style format string.  Unfortunately, there's
 530  * no way to construct va_list values on the fly in C, so we cannot simply
 531  * prepend %s and pass the prefix as an argument.  Any % characters in the
 532  * prefix will be escaped.
 533  *
 534  * Returns a pointer to a newly allocated string, which should be freed by the
 535  * caller, or NULL otherwise.
 536  */
 537 static char *prepend_fmt(const char *prefix, const char *fmt)
 538 {
 539         size_t prefix_len = strlen(prefix), fmt_len = strlen(fmt);
 540         char *new_fmt;
 541
 542         if (prefix_len > SIZE_MAX/2 - sizeof ": ")
 543                 return NULL;
 544         if (2*prefix_len > SIZE_MAX - fmt_len)
 545                 return NULL;
 546
 547         new_fmt = malloc(2*prefix_len + fmt_len + 1);
 548         if (new_fmt) {
 549                 size_t offset = 0;
 550
 551                 for (size_t i = 0; i < prefix_len; i++) {
 552                         if (prefix[i] == '%')
 553                                 new_fmt[offset++] = '%';
 554                         new_fmt[offset++] = prefix[i];
 555                 }
 556
 557                 new_fmt[offset++] = ':';
 558                 new_fmt[offset++] = ' ';
 559                 strcpy(new_fmt+offset, fmt);
 560         }
 561
 562         return new_fmt;
 563 }
 564
 565 /* Logging helpers that automatically prepend the UObject class information. */
 566 void u_vlog_full(GObject *o, GLogLevelFlags level, const char *fmt, va_list ap)
 567 {
 568         g_return_if_fail(IS_U_OBJECT(o));
 569         UObject *uo = U_OBJECT(o);
 570         char *new_fmt = NULL;
 571
 572         if (uo->pkg_name) {
 573                 new_fmt = prepend_fmt(uo->pkg_name, fmt);
 574                 if (!new_fmt) {
 575                         g_log(G_OBJECT_TYPE_NAME(o), level, "%s",
 576                               uo->pkg_file->name);
 577                 } else {
 578                         fmt = new_fmt;
 579                 }
 580         }
 581
 582         g_logv(G_OBJECT_TYPE_NAME(o), level, fmt, ap);
 583         free(new_fmt);
 584 }
 585
 586 void u_log_full(GObject *o, GLogLevelFlags level, const char *fmt, ...)
 587 {
 588         va_list ap;
 589
 590         va_start(ap, fmt);
 591         u_vlog_full(o, level, fmt, ap);
 592         va_end(ap);
 593 }