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 (head->size != 1 || priv->nbuf-len < head->size)
 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 (head->size != 4 || priv->nbuf-len < head->size)
 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                 if (head->size != 0)
 332                         return 0;
 333                 g_value_init(&val, G_TYPE_BOOLEAN);
 334                 g_value_set_boolean(&val, head->tag_msb);
 335                 g_object_set_property(G_OBJECT(uo), head->prop_name, &val);
 336                 break;
 337         case PROPERTY_OBJECT:
 338                 rc = decode_object_property(uo, &val, len);
 339                 if (rc != 0)
 340                         return 0;
 341                 g_object_set_property(G_OBJECT(uo), head->prop_name, &val);
 342                 break;
 343         default:
 344                 u_warn(uo, "%s: unsupported property type %u",
 345                            head->prop_name, (unsigned)head->type);
 346         }
 347         len += head->size;
 348
 349         if (len > priv->nbuf) {
 350                 long skip = len - priv->nbuf;
 351
 352                 /* XXX: Long properties are not supported yet, so just seek
 353                  * past them for now. */
 354                 if (upkg_export_seek(uo->pkg_file, skip, SEEK_CUR) != 0)
 355                         return 0;
 356
 357                 priv->nbuf = 0;
 358         } else {
 359                 priv->nbuf -= len;
 360                 memmove(priv->buf, priv->buf+len, priv->nbuf-len);
 361         }
 362
 363         return len;
 364 }
 365
 366 /* Deserialize properties from an Unreal package. */
 367 static int deserialize(UObject *uo)
 368 {
 369         struct u_object_priv *priv = U_OBJECT_GET_PRIV(uo);
 370         struct upkg_file *f = uo->pkg_file;
 371         unsigned long rc, tot_len = 0;
 372
 373         while (1) {
 374                 struct prop_head head;
 375
 376                 /* Prime the buffer; deserialize_property assumes that there's
 377                  * enough data for "small" properties already available. */
 378                 if (!f->eof) {
 379                         void  *buf = priv->buf + priv->nbuf;
 380                         size_t amt = sizeof priv->buf - priv->nbuf;
 381                         rc = upkg_export_read(f, buf, amt);
 382                         if (rc == 0 && priv->nbuf == 0)
 383                                 return -1;
 384                         priv->nbuf += rc;
 385                 }
 386
 387                 rc = deserialize_property(uo, &head);
 388                 if (rc == 0) {
 389                         return -1;
 390                 }
 391                 tot_len += rc;
 392
 393                 if (head.type == PROPERTY_END)
 394                         break;
 395         }
 396
 397         f->base += tot_len;
 398         f->len  -= tot_len;
 399         upkg_export_seek(f, 0, SEEK_SET);
 400
 401         return 0;
 402 }
 403
 404 /*
 405  * Get the full hierarchical object name for an export, used for diagnostics.
 406  * The package name is passed in pname.
 407  *
 408  * Returns a buffer allocated by malloc on success, or NULL on failure.
 409  */
 410 static char *get_obj_fullname(const char *pname, const struct upkg_export *e)
 411 {
 412         size_t total_len = strlen(pname) + 1, len;
 413         char *fullname;
 414
 415         assert(e != NULL);
 416
 417         for (const struct upkg_export *c = e; c; c = c->parent) {
 418                 len = strlen(c->name) + 1;
 419                 if (total_len > SIZE_MAX - len)
 420                         return NULL;
 421                 total_len += len;
 422         }
 423
 424         fullname = malloc(total_len);
 425         if (!fullname)
 426                 return NULL;
 427
 428         for (const struct upkg_export *c = e; c; c = c->parent) {
 429                 len = strlen(c->name);
 430                 assert(total_len > len);
 431
 432                 total_len -= len + 1;
 433                 memcpy(fullname + total_len, c->name, len);
 434                 fullname[total_len + len] = c == e ? '\0' : '.';
 435         }
 436
 437         assert(total_len == strlen(pname)+1);
 438         memcpy(fullname, pname, total_len-1);
 439         fullname[total_len-1] = '.';
 440
 441         return fullname;
 442 }
 443
 444 int u_object_deserialize(GObject *obj, GTypeModule *pkg, unsigned long idx)
 445 {
 446         g_return_val_if_fail(IS_U_OBJECT(obj), -1);
 447         g_return_val_if_fail(IS_U_PKG(pkg), -1);
 448
 449         UObject *uo = U_OBJECT(obj);
 450         struct upkg *upkg = U_PKG(pkg)->pkg;
 451         const struct upkg_export *e;
 452         struct upkg_file *f;
 453         int rc;
 454
 455         g_return_val_if_fail(uo->pkg_file == NULL, -1);
 456         f = upkg_export_open(upkg, idx);
 457         if (!f) {
 458                 return -1;
 459         }
 460
 461         uo->pkg = pkg;
 462         uo->pkg_file = f;
 463
 464         e = upkg_get_export(upkg, idx);
 465         if (!e)
 466                 return -1;
 467         uo->pkg_name = get_obj_fullname(pkg->name, e);
 468         if (!uo->pkg_name)
 469                 return -1;
 470
 471         rc = U_OBJECT_GET_CLASS(obj)->deserialize(uo);
 472         if (rc != 0) {
 473                 upkg_export_close(f);
 474                 uo->pkg_file = NULL;
 475         }
 476
 477         return rc;
 478 }
 479
 480 GObject *u_object_new_from_package(GTypeModule *pkg, unsigned long idx)
 481 {
 482         g_return_val_if_fail(IS_U_PKG(pkg), NULL);
 483
 484         const char *class, *package;
 485         GObject *obj = NULL;
 486         GType type;
 487
 488         class = upkg_export_class(U_PKG(pkg)->pkg, idx, &package);
 489
 490         type = u_object_module_get_class(package, class);
 491         if (type) {
 492                 obj = g_object_new(type, NULL);
 493                 if (u_object_deserialize(obj, pkg, idx) != 0) {
 494                         g_object_unref(obj);
 495                         return NULL;
 496                 }
 497         }
 498
 499         return obj;
 500 }
 501
 502 static void u_object_init(UObject *o)
 503 {
 504         o->pkg      = NULL;
 505         o->pkg_file = NULL;
 506 }
 507
 508 static void u_object_finalize(GObject *o)
 509 {
 510         UObject *uo = U_OBJECT(o);
 511
 512         if (uo->pkg_file) {
 513                 upkg_export_close(uo->pkg_file);
 514         }
 515
 516         free(uo->pkg_name);
 517
 518         G_OBJECT_CLASS(u_object_parent_class)->finalize(o);
 519 }
 520
 521 static void u_object_class_init(UObjectClass *class)
 522 {
 523         g_type_class_add_private(class, sizeof (struct u_object_priv));
 524         GObjectClass *go = G_OBJECT_CLASS(class);
 525
 526         class->deserialize = deserialize;
 527         go->finalize       = u_object_finalize;
 528 }
 529
 530 /*
 531  * Prepend a prefix to a printf-style format string.  Unfortunately, there's
 532  * no way to construct va_list values on the fly in C, so we cannot simply
 533  * prepend %s and pass the prefix as an argument.  Any % characters in the
 534  * prefix will be escaped.
 535  *
 536  * Returns a pointer to a newly allocated string, which should be freed by the
 537  * caller, or NULL otherwise.
 538  */
 539 static char *prepend_fmt(const char *prefix, const char *fmt)
 540 {
 541         size_t prefix_len = strlen(prefix), fmt_len = strlen(fmt);
 542         char *new_fmt;
 543
 544         if (prefix_len > SIZE_MAX/2 - sizeof ": ")
 545                 return NULL;
 546         if (2*prefix_len > SIZE_MAX - fmt_len)
 547                 return NULL;
 548
 549         new_fmt = malloc(2*prefix_len + fmt_len + 1);
 550         if (new_fmt) {
 551                 size_t offset = 0;
 552
 553                 for (size_t i = 0; i < prefix_len; i++) {
 554                         if (prefix[i] == '%')
 555                                 new_fmt[offset++] = '%';
 556                         new_fmt[offset++] = prefix[i];
 557                 }
 558
 559                 new_fmt[offset++] = ':';
 560                 new_fmt[offset++] = ' ';
 561                 strcpy(new_fmt+offset, fmt);
 562         }
 563
 564         return new_fmt;
 565 }
 566
 567 /* Logging helpers that automatically prepend the UObject class information. */
 568 void u_vlog_full(GObject *o, GLogLevelFlags level, const char *fmt, va_list ap)
 569 {
 570         g_return_if_fail(IS_U_OBJECT(o));
 571         UObject *uo = U_OBJECT(o);
 572         char *new_fmt = NULL;
 573
 574         if (uo->pkg_name) {
 575                 new_fmt = prepend_fmt(uo->pkg_name, fmt);
 576                 if (!new_fmt) {
 577                         g_log(G_OBJECT_TYPE_NAME(o), level, "%s",
 578                               uo->pkg_file->name);
 579                 } else {
 580                         fmt = new_fmt;
 581                 }
 582         }
 583
 584         g_logv(G_OBJECT_TYPE_NAME(o), level, fmt, ap);
 585         free(new_fmt);
 586 }
 587
 588 void u_log_full(GObject *o, GLogLevelFlags level, const char *fmt, ...)
 589 {
 590         va_list ap;
 591
 592         va_start(ap, fmt);
 593         u_vlog_full(o, level, fmt, ap);
 594         va_end(ap);
 595 }