js/src/jsxdrapi.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
   2  *
   3  * ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is Mozilla Communicator client code, released
  17  * March 31, 1998.
  18  *
  19  * The Initial Developer of the Original Code is
  20  * Netscape Communications Corporation.
  21  * Portions created by the Initial Developer are Copyright (C) 1998
  22  * the Initial Developer. All Rights Reserved.
  23  *
  24  * Contributor(s):
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either of the GNU General Public License Version 2 or later (the "GPL"),
  28  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39 #include "jsversion.h"
  40
  41 #if JS_HAS_XDR
  42
  43 #include <string.h>
  44 #include "jstypes.h"
  45 #include "jsstdint.h"
  46 #include "jsutil.h" /* Added by JSIFY */
  47 #include "jsdhash.h"
  48 #include "jsprf.h"
  49 #include "jsapi.h"
  50 #include "jscntxt.h"
  51 #include "jsnum.h"
  52 #include "jsobj.h"              /* js_XDRObject */
  53 #include "jsscript.h"           /* js_XDRScript */
  54 #include "jsstr.h"
  55 #include "jsxdrapi.h"
  56
  57 #ifdef DEBUG
  58 #define DBG(x) x
  59 #else
  60 #define DBG(x) ((void)0)
  61 #endif
  62
  63 typedef struct JSXDRMemState {
  64     JSXDRState  state;
  65     char        *base;
  66     uint32      count;
  67     uint32      limit;
  68 } JSXDRMemState;
  69
  70 #define MEM_BLOCK       8192
  71 #define MEM_PRIV(xdr)   ((JSXDRMemState *)(xdr))
  72
  73 #define MEM_BASE(xdr)   (MEM_PRIV(xdr)->base)
  74 #define MEM_COUNT(xdr)  (MEM_PRIV(xdr)->count)
  75 #define MEM_LIMIT(xdr)  (MEM_PRIV(xdr)->limit)
  76
  77 #define MEM_LEFT(xdr, bytes)                                                  \
  78     JS_BEGIN_MACRO                                                            \
  79         if ((xdr)->mode == JSXDR_DECODE &&                                    \
  80             MEM_COUNT(xdr) + bytes > MEM_LIMIT(xdr)) {                        \
  81             JS_ReportErrorNumber((xdr)->cx, js_GetErrorMessage, NULL,         \
  82                                  JSMSG_END_OF_DATA);                          \
  83             return 0;                                                         \
  84         }                                                                     \
  85     JS_END_MACRO
  86
  87 #define MEM_NEED(xdr, bytes)                                                  \
  88     JS_BEGIN_MACRO                                                            \
  89         if ((xdr)->mode == JSXDR_ENCODE) {                                    \
  90             if (MEM_LIMIT(xdr) &&                                             \
  91                 MEM_COUNT(xdr) + bytes > MEM_LIMIT(xdr)) {                    \
  92                 uint32 limit_ = JS_ROUNDUP(MEM_COUNT(xdr) + bytes, MEM_BLOCK);\
  93                 void *data_ = (xdr)->cx->realloc(MEM_BASE(xdr), limit_);      \
  94                 if (!data_)                                                   \
  95                     return 0;                                                 \
  96                 MEM_BASE(xdr) = (char *) data_;                               \
  97                 MEM_LIMIT(xdr) = limit_;                                      \
  98             }                                                                 \
  99         } else {                                                              \
 100             MEM_LEFT(xdr, bytes);                                             \
 101         }                                                                     \
 102     JS_END_MACRO
 103
 104 #define MEM_DATA(xdr)        ((void *)(MEM_BASE(xdr) + MEM_COUNT(xdr)))
 105 #define MEM_INCR(xdr,bytes)  (MEM_COUNT(xdr) += (bytes))
 106
 107 static JSBool
 108 mem_get32(JSXDRState *xdr, uint32 *lp)
 109 {
 110     MEM_LEFT(xdr, 4);
 111     *lp = *(uint32 *)MEM_DATA(xdr);
 112     MEM_INCR(xdr, 4);
 113     return JS_TRUE;
 114 }
 115
 116 static JSBool
 117 mem_set32(JSXDRState *xdr, uint32 *lp)
 118 {
 119     MEM_NEED(xdr, 4);
 120     *(uint32 *)MEM_DATA(xdr) = *lp;
 121     MEM_INCR(xdr, 4);
 122     return JS_TRUE;
 123 }
 124
 125 static JSBool
 126 mem_getbytes(JSXDRState *xdr, char *bytes, uint32 len)
 127 {
 128     MEM_LEFT(xdr, len);
 129     memcpy(bytes, MEM_DATA(xdr), len);
 130     MEM_INCR(xdr, len);
 131     return JS_TRUE;
 132 }
 133
 134 static JSBool
 135 mem_setbytes(JSXDRState *xdr, char *bytes, uint32 len)
 136 {
 137     MEM_NEED(xdr, len);
 138     memcpy(MEM_DATA(xdr), bytes, len);
 139     MEM_INCR(xdr, len);
 140     return JS_TRUE;
 141 }
 142
 143 static void *
 144 mem_raw(JSXDRState *xdr, uint32 len)
 145 {
 146     void *data;
 147     if (xdr->mode == JSXDR_ENCODE) {
 148         MEM_NEED(xdr, len);
 149     } else if (xdr->mode == JSXDR_DECODE) {
 150         MEM_LEFT(xdr, len);
 151     }
 152     data = MEM_DATA(xdr);
 153     MEM_INCR(xdr, len);
 154     return data;
 155 }
 156
 157 static JSBool
 158 mem_seek(JSXDRState *xdr, int32 offset, JSXDRWhence whence)
 159 {
 160     switch (whence) {
 161       case JSXDR_SEEK_CUR:
 162         if ((int32)MEM_COUNT(xdr) + offset < 0) {
 163             JS_ReportErrorNumber(xdr->cx, js_GetErrorMessage, NULL,
 164                                  JSMSG_SEEK_BEYOND_START);
 165             return JS_FALSE;
 166         }
 167         if (offset > 0)
 168             MEM_NEED(xdr, offset);
 169         MEM_COUNT(xdr) += offset;
 170         return JS_TRUE;
 171       case JSXDR_SEEK_SET:
 172         if (offset < 0) {
 173             JS_ReportErrorNumber(xdr->cx, js_GetErrorMessage, NULL,
 174                                  JSMSG_SEEK_BEYOND_START);
 175             return JS_FALSE;
 176         }
 177         if (xdr->mode == JSXDR_ENCODE) {
 178             if ((uint32)offset > MEM_COUNT(xdr))
 179                 MEM_NEED(xdr, offset - MEM_COUNT(xdr));
 180             MEM_COUNT(xdr) = offset;
 181         } else {
 182             if ((uint32)offset > MEM_LIMIT(xdr)) {
 183                 JS_ReportErrorNumber(xdr->cx, js_GetErrorMessage, NULL,
 184                                      JSMSG_SEEK_BEYOND_END);
 185                 return JS_FALSE;
 186             }
 187             MEM_COUNT(xdr) = offset;
 188         }
 189         return JS_TRUE;
 190       case JSXDR_SEEK_END:
 191         if (offset >= 0 ||
 192             xdr->mode == JSXDR_ENCODE ||
 193             (int32)MEM_LIMIT(xdr) + offset < 0) {
 194             JS_ReportErrorNumber(xdr->cx, js_GetErrorMessage, NULL,
 195                                  JSMSG_END_SEEK);
 196             return JS_FALSE;
 197         }
 198         MEM_COUNT(xdr) = MEM_LIMIT(xdr) + offset;
 199         return JS_TRUE;
 200       default: {
 201         char numBuf[12];
 202         JS_snprintf(numBuf, sizeof numBuf, "%d", whence);
 203         JS_ReportErrorNumber(xdr->cx, js_GetErrorMessage, NULL,
 204                              JSMSG_WHITHER_WHENCE, numBuf);
 205         return JS_FALSE;
 206       }
 207     }
 208 }
 209
 210 static uint32
 211 mem_tell(JSXDRState *xdr)
 212 {
 213     return MEM_COUNT(xdr);
 214 }
 215
 216 static void
 217 mem_finalize(JSXDRState *xdr)
 218 {
 219     xdr->cx->free(MEM_BASE(xdr));
 220 }
 221
 222 static JSXDROps xdrmem_ops = {
 223     mem_get32,      mem_set32,      mem_getbytes,   mem_setbytes,
 224     mem_raw,        mem_seek,       mem_tell,       mem_finalize
 225 };
 226
 227 JS_PUBLIC_API(void)
 228 JS_XDRInitBase(JSXDRState *xdr, JSXDRMode mode, JSContext *cx)
 229 {
 230     xdr->mode = mode;
 231     xdr->cx = cx;
 232     xdr->registry = NULL;
 233     xdr->numclasses = xdr->maxclasses = 0;
 234     xdr->reghash = NULL;
 235     xdr->userdata = NULL;
 236     xdr->script = NULL;
 237 }
 238
 239 JS_PUBLIC_API(JSXDRState *)
 240 JS_XDRNewMem(JSContext *cx, JSXDRMode mode)
 241 {
 242     JSXDRState *xdr = (JSXDRState *) cx->malloc(sizeof(JSXDRMemState));
 243     if (!xdr)
 244         return NULL;
 245     JS_XDRInitBase(xdr, mode, cx);
 246     if (mode == JSXDR_ENCODE) {
 247         if (!(MEM_BASE(xdr) = (char *) cx->malloc(MEM_BLOCK))) {
 248             cx->free(xdr);
 249             return NULL;
 250         }
 251     } else {
 252         /* XXXbe ok, so better not deref MEM_BASE(xdr) if not ENCODE */
 253         MEM_BASE(xdr) = NULL;
 254     }
 255     xdr->ops = &xdrmem_ops;
 256     MEM_COUNT(xdr) = 0;
 257     MEM_LIMIT(xdr) = MEM_BLOCK;
 258     return xdr;
 259 }
 260
 261 JS_PUBLIC_API(void *)
 262 JS_XDRMemGetData(JSXDRState *xdr, uint32 *lp)
 263 {
 264     if (xdr->ops != &xdrmem_ops)
 265         return NULL;
 266     *lp = MEM_COUNT(xdr);
 267     return MEM_BASE(xdr);
 268 }
 269
 270 JS_PUBLIC_API(void)
 271 JS_XDRMemSetData(JSXDRState *xdr, void *data, uint32 len)
 272 {
 273     if (xdr->ops != &xdrmem_ops)
 274         return;
 275     MEM_LIMIT(xdr) = len;
 276     MEM_BASE(xdr) = (char *) data;
 277     MEM_COUNT(xdr) = 0;
 278 }
 279
 280 JS_PUBLIC_API(uint32)
 281 JS_XDRMemDataLeft(JSXDRState *xdr)
 282 {
 283     if (xdr->ops != &xdrmem_ops)
 284         return 0;
 285     return MEM_LIMIT(xdr) - MEM_COUNT(xdr);
 286 }
 287
 288 JS_PUBLIC_API(void)
 289 JS_XDRMemResetData(JSXDRState *xdr)
 290 {
 291     if (xdr->ops != &xdrmem_ops)
 292         return;
 293     MEM_COUNT(xdr) = 0;
 294 }
 295
 296 JS_PUBLIC_API(void)
 297 JS_XDRDestroy(JSXDRState *xdr)
 298 {
 299     JSContext *cx = xdr->cx;
 300     xdr->ops->finalize(xdr);
 301     if (xdr->registry) {
 302         cx->free(xdr->registry);
 303         if (xdr->reghash)
 304             JS_DHashTableDestroy((JSDHashTable *) xdr->reghash);
 305     }
 306     cx->free(xdr);
 307 }
 308
 309 JS_PUBLIC_API(JSBool)
 310 JS_XDRUint8(JSXDRState *xdr, uint8 *b)
 311 {
 312     uint32 l = *b;
 313     if (!JS_XDRUint32(xdr, &l))
 314         return JS_FALSE;
 315     *b = (uint8) l;
 316     return JS_TRUE;
 317 }
 318
 319 JS_PUBLIC_API(JSBool)
 320 JS_XDRUint16(JSXDRState *xdr, uint16 *s)
 321 {
 322     uint32 l = *s;
 323     if (!JS_XDRUint32(xdr, &l))
 324         return JS_FALSE;
 325     *s = (uint16) l;
 326     return JS_TRUE;
 327 }
 328
 329 JS_PUBLIC_API(JSBool)
 330 JS_XDRUint32(JSXDRState *xdr, uint32 *lp)
 331 {
 332     JSBool ok = JS_TRUE;
 333     if (xdr->mode == JSXDR_ENCODE) {
 334         uint32 xl = JSXDR_SWAB32(*lp);
 335         ok = xdr->ops->set32(xdr, &xl);
 336     } else if (xdr->mode == JSXDR_DECODE) {
 337         ok = xdr->ops->get32(xdr, lp);
 338         *lp = JSXDR_SWAB32(*lp);
 339     }
 340     return ok;
 341 }
 342
 343 JS_PUBLIC_API(JSBool)
 344 JS_XDRBytes(JSXDRState *xdr, char *bytes, uint32 len)
 345 {
 346     uint32 padlen;
 347     static char padbuf[JSXDR_ALIGN-1];
 348
 349     if (xdr->mode == JSXDR_ENCODE) {
 350         if (!xdr->ops->setbytes(xdr, bytes, len))
 351             return JS_FALSE;
 352     } else {
 353         if (!xdr->ops->getbytes(xdr, bytes, len))
 354             return JS_FALSE;
 355     }
 356     len = xdr->ops->tell(xdr);
 357     if (len % JSXDR_ALIGN) {
 358         padlen = JSXDR_ALIGN - (len % JSXDR_ALIGN);
 359         if (xdr->mode == JSXDR_ENCODE) {
 360             if (!xdr->ops->setbytes(xdr, padbuf, padlen))
 361                 return JS_FALSE;
 362         } else {
 363             if (!xdr->ops->seek(xdr, padlen, JSXDR_SEEK_CUR))
 364                 return JS_FALSE;
 365         }
 366     }
 367     return JS_TRUE;
 368 }
 369
 370 /**
 371  * Convert between a C string and the XDR representation:
 372  * leading 32-bit count, then counted vector of chars,
 373  * then possibly \0 padding to multiple of 4.
 374  */
 375 JS_PUBLIC_API(JSBool)
 376 JS_XDRCString(JSXDRState *xdr, char **sp)
 377 {
 378     uint32 len;
 379
 380     if (xdr->mode == JSXDR_ENCODE)
 381         len = strlen(*sp);
 382     JS_XDRUint32(xdr, &len);
 383     if (xdr->mode == JSXDR_DECODE) {
 384         if (!(*sp = (char *) xdr->cx->malloc(len + 1)))
 385             return JS_FALSE;
 386     }
 387     if (!JS_XDRBytes(xdr, *sp, len)) {
 388         if (xdr->mode == JSXDR_DECODE)
 389             xdr->cx->free(*sp);
 390         return JS_FALSE;
 391     }
 392     if (xdr->mode == JSXDR_DECODE) {
 393         (*sp)[len] = '\0';
 394     } else if (xdr->mode == JSXDR_FREE) {
 395         xdr->cx->free(*sp);
 396         *sp = NULL;
 397     }
 398     return JS_TRUE;
 399 }
 400
 401 JS_PUBLIC_API(JSBool)
 402 JS_XDRCStringOrNull(JSXDRState *xdr, char **sp)
 403 {
 404     uint32 null = (*sp == NULL);
 405     if (!JS_XDRUint32(xdr, &null))
 406         return JS_FALSE;
 407     if (null) {
 408         *sp = NULL;
 409         return JS_TRUE;
 410     }
 411     return JS_XDRCString(xdr, sp);
 412 }
 413
 414 static JSBool
 415 XDRChars(JSXDRState *xdr, jschar *chars, uint32 nchars)
 416 {
 417     uint32 i, padlen, nbytes;
 418     jschar *raw;
 419
 420     nbytes = nchars * sizeof(jschar);
 421     padlen = nbytes % JSXDR_ALIGN;
 422     if (padlen) {
 423         padlen = JSXDR_ALIGN - padlen;
 424         nbytes += padlen;
 425     }
 426     if (!(raw = (jschar *) xdr->ops->raw(xdr, nbytes)))
 427         return JS_FALSE;
 428     if (xdr->mode == JSXDR_ENCODE) {
 429         for (i = 0; i != nchars; i++)
 430             raw[i] = JSXDR_SWAB16(chars[i]);
 431         if (padlen)
 432             memset((char *)raw + nbytes - padlen, 0, padlen);
 433     } else if (xdr->mode == JSXDR_DECODE) {
 434         for (i = 0; i != nchars; i++)
 435             chars[i] = JSXDR_SWAB16(raw[i]);
 436     }
 437     return JS_TRUE;
 438 }
 439
 440 /*
 441  * Convert between a JS (Unicode) string and the XDR representation.
 442  */
 443 JS_PUBLIC_API(JSBool)
 444 JS_XDRString(JSXDRState *xdr, JSString **strp)
 445 {
 446     uint32 nchars;
 447     jschar *chars;
 448
 449     if (xdr->mode == JSXDR_ENCODE)
 450         nchars = (*strp)->length();
 451     if (!JS_XDRUint32(xdr, &nchars))
 452         return JS_FALSE;
 453
 454     if (xdr->mode == JSXDR_DECODE) {
 455         chars = (jschar *) xdr->cx->malloc((nchars + 1) * sizeof(jschar));
 456         if (!chars)
 457             return JS_FALSE;
 458     } else {
 459         chars = (*strp)->chars();
 460     }
 461
 462     if (!XDRChars(xdr, chars, nchars))
 463         goto bad;
 464     if (xdr->mode == JSXDR_DECODE) {
 465         chars[nchars] = 0;
 466         *strp = JS_NewUCString(xdr->cx, chars, nchars);
 467         if (!*strp)
 468             goto bad;
 469     }
 470     return JS_TRUE;
 471
 472 bad:
 473     if (xdr->mode == JSXDR_DECODE)
 474         xdr->cx->free(chars);
 475     return JS_FALSE;
 476 }
 477
 478 JS_PUBLIC_API(JSBool)
 479 JS_XDRStringOrNull(JSXDRState *xdr, JSString **strp)
 480 {
 481     uint32 null = (*strp == NULL);
 482     if (!JS_XDRUint32(xdr, &null))
 483         return JS_FALSE;
 484     if (null) {
 485         *strp = NULL;
 486         return JS_TRUE;
 487     }
 488     return JS_XDRString(xdr, strp);
 489 }
 490
 491 static JSBool
 492 XDRDoubleValue(JSXDRState *xdr, jsdouble *dp)
 493 {
 494     jsdpun u;
 495
 496     u.d = (xdr->mode == JSXDR_ENCODE) ? *dp : 0.0;
 497     if (!JS_XDRUint32(xdr, &u.s.lo) || !JS_XDRUint32(xdr, &u.s.hi))
 498         return JS_FALSE;
 499     if (xdr->mode == JSXDR_DECODE)
 500         *dp = u.d;
 501     return JS_TRUE;
 502 }
 503
 504 JS_PUBLIC_API(JSBool)
 505 JS_XDRDouble(JSXDRState *xdr, jsdouble **dpp)
 506 {
 507     jsdouble d = (xdr->mode == JSXDR_ENCODE) ? **dpp : 0.0;
 508     if (!XDRDoubleValue(xdr, &d))
 509         return JS_FALSE;
 510     if (xdr->mode == JSXDR_DECODE) {
 511         *dpp = JS_NewDouble(xdr->cx, d);
 512         if (!*dpp)
 513             return JS_FALSE;
 514     }
 515     return JS_TRUE;
 516 }
 517
 518 /* These are magic pseudo-tags: see jsapi.h, near the top, for real tags. */
 519 #define JSVAL_XDRNULL   0x8
 520 #define JSVAL_XDRVOID   0xA
 521
 522 static JSBool
 523 XDRValueBody(JSXDRState *xdr, uint32 type, jsval *vp)
 524 {
 525     switch (type) {
 526       case JSVAL_XDRNULL:
 527         *vp = JSVAL_NULL;
 528         break;
 529       case JSVAL_XDRVOID:
 530         *vp = JSVAL_VOID;
 531         break;
 532       case JSVAL_STRING: {
 533         JSString *str;
 534         if (xdr->mode == JSXDR_ENCODE)
 535             str = JSVAL_TO_STRING(*vp);
 536         if (!JS_XDRString(xdr, &str))
 537             return JS_FALSE;
 538         if (xdr->mode == JSXDR_DECODE)
 539             *vp = STRING_TO_JSVAL(str);
 540         break;
 541       }
 542       case JSVAL_DOUBLE: {
 543         jsdouble *dp = (xdr->mode == JSXDR_ENCODE) ? JSVAL_TO_DOUBLE(*vp) : NULL;
 544         if (!JS_XDRDouble(xdr, &dp))
 545             return JS_FALSE;
 546         if (xdr->mode == JSXDR_DECODE)
 547             *vp = DOUBLE_TO_JSVAL(dp);
 548         break;
 549       }
 550       case JSVAL_OBJECT: {
 551         JSObject *obj;
 552         if (xdr->mode == JSXDR_ENCODE)
 553             obj = JSVAL_TO_OBJECT(*vp);
 554         if (!js_XDRObject(xdr, &obj))
 555             return JS_FALSE;
 556         if (xdr->mode == JSXDR_DECODE)
 557             *vp = OBJECT_TO_JSVAL(obj);
 558         break;
 559       }
 560       case JSVAL_SPECIAL: {
 561         uint32 b;
 562         if (xdr->mode == JSXDR_ENCODE)
 563             b = (uint32) JSVAL_TO_BOOLEAN(*vp);
 564         if (!JS_XDRUint32(xdr, &b))
 565             return JS_FALSE;
 566         if (xdr->mode == JSXDR_DECODE)
 567             *vp = BOOLEAN_TO_JSVAL(!!b);
 568         break;
 569       }
 570       default: {
 571         uint32 i;
 572
 573         JS_ASSERT(type & JSVAL_INT);
 574         if (xdr->mode == JSXDR_ENCODE)
 575             i = (uint32) JSVAL_TO_INT(*vp);
 576         if (!JS_XDRUint32(xdr, &i))
 577             return JS_FALSE;
 578         if (xdr->mode == JSXDR_DECODE)
 579             *vp = INT_TO_JSVAL((int32) i);
 580         break;
 581       }
 582     }
 583     return JS_TRUE;
 584 }
 585
 586 JS_PUBLIC_API(JSBool)
 587 JS_XDRValue(JSXDRState *xdr, jsval *vp)
 588 {
 589     uint32 type;
 590
 591     if (xdr->mode == JSXDR_ENCODE) {
 592         if (JSVAL_IS_NULL(*vp))
 593             type = JSVAL_XDRNULL;
 594         else if (JSVAL_IS_VOID(*vp))
 595             type = JSVAL_XDRVOID;
 596         else
 597             type = JSVAL_TAG(*vp);
 598     }
 599     return JS_XDRUint32(xdr, &type) && XDRValueBody(xdr, type, vp);
 600 }
 601
 602 JSBool
 603 js_XDRAtom(JSXDRState *xdr, JSAtom **atomp)
 604 {
 605     jsval v;
 606     uint32 type;
 607
 608     if (xdr->mode == JSXDR_ENCODE) {
 609         v = ATOM_KEY(*atomp);
 610         return JS_XDRValue(xdr, &v);
 611     }
 612
 613     /*
 614      * Inline JS_XDRValue when decoding to avoid ceation of GC things when
 615      * then corresponding atom already exists. See bug 321985.
 616      */
 617     if (!JS_XDRUint32(xdr, &type))
 618         return JS_FALSE;
 619     if (type == JSVAL_STRING)
 620         return js_XDRStringAtom(xdr, atomp);
 621
 622     if (type == JSVAL_DOUBLE) {
 623         jsdouble d = 0;
 624         if (!XDRDoubleValue(xdr, &d))
 625             return JS_FALSE;
 626         *atomp = js_AtomizeDouble(xdr->cx, d);
 627         return *atomp != NULL;
 628     }
 629
 630     return XDRValueBody(xdr, type, &v) &&
 631            js_AtomizePrimitiveValue(xdr->cx, v, atomp);
 632 }
 633
 634 extern JSBool
 635 js_XDRStringAtom(JSXDRState *xdr, JSAtom **atomp)
 636 {
 637     JSString *str;
 638     uint32 nchars;
 639     JSAtom *atom;
 640     JSContext *cx;
 641     jschar *chars;
 642     jschar stackChars[256];
 643
 644     if (xdr->mode == JSXDR_ENCODE) {
 645         JS_ASSERT(ATOM_IS_STRING(*atomp));
 646         str = ATOM_TO_STRING(*atomp);
 647         return JS_XDRString(xdr, &str);
 648     }
 649
 650     /*
 651      * Inline JS_XDRString when decoding to avoid JSString allocation
 652      * for already existing atoms. See bug 321985.
 653      */
 654     if (!JS_XDRUint32(xdr, &nchars))
 655         return JS_FALSE;
 656     atom = NULL;
 657     cx = xdr->cx;
 658     if (nchars <= JS_ARRAY_LENGTH(stackChars)) {
 659         chars = stackChars;
 660     } else {
 661         /*
 662          * This is very uncommon. Don't use the tempPool arena for this as
 663          * most allocations here will be bigger than tempPool's arenasize.
 664          */
 665         chars = (jschar *) cx->malloc(nchars * sizeof(jschar));
 666         if (!chars)
 667             return JS_FALSE;
 668     }
 669
 670     if (XDRChars(xdr, chars, nchars))
 671         atom = js_AtomizeChars(cx, chars, nchars, 0);
 672     if (chars != stackChars)
 673         cx->free(chars);
 674
 675     if (!atom)
 676         return JS_FALSE;
 677     *atomp = atom;
 678     return JS_TRUE;
 679 }
 680
 681 JS_PUBLIC_API(JSBool)
 682 JS_XDRScript(JSXDRState *xdr, JSScript **scriptp)
 683 {
 684     if (!js_XDRScript(xdr, scriptp, true, NULL))
 685         return JS_FALSE;
 686     if (xdr->mode == JSXDR_DECODE)
 687         js_CallNewScriptHook(xdr->cx, *scriptp, NULL);
 688     return JS_TRUE;
 689 }
 690
 691 #define CLASS_REGISTRY_MIN      8
 692 #define CLASS_INDEX_TO_ID(i)    ((i)+1)
 693 #define CLASS_ID_TO_INDEX(id)   ((id)-1)
 694
 695 typedef struct JSRegHashEntry {
 696     JSDHashEntryHdr hdr;
 697     const char      *name;
 698     uint32          index;
 699 } JSRegHashEntry;
 700
 701 JS_PUBLIC_API(JSBool)
 702 JS_XDRRegisterClass(JSXDRState *xdr, JSClass *clasp, uint32 *idp)
 703 {
 704     uintN numclasses, maxclasses;
 705     JSClass **registry;
 706
 707     numclasses = xdr->numclasses;
 708     maxclasses = xdr->maxclasses;
 709     if (numclasses == maxclasses) {
 710         maxclasses = (maxclasses == 0) ? CLASS_REGISTRY_MIN : maxclasses << 1;
 711         registry = (JSClass **)
 712             xdr->cx->realloc(xdr->registry, maxclasses * sizeof(JSClass *));
 713         if (!registry)
 714             return JS_FALSE;
 715         xdr->registry = registry;
 716         xdr->maxclasses = maxclasses;
 717     } else {
 718         JS_ASSERT(numclasses && numclasses < maxclasses);
 719         registry = xdr->registry;
 720     }
 721
 722     registry[numclasses] = clasp;
 723     if (xdr->reghash) {
 724         JSRegHashEntry *entry = (JSRegHashEntry *)
 725             JS_DHashTableOperate((JSDHashTable *) xdr->reghash,
 726                                  clasp->name, JS_DHASH_ADD);
 727         if (!entry) {
 728             JS_ReportOutOfMemory(xdr->cx);
 729             return JS_FALSE;
 730         }
 731         entry->name = clasp->name;
 732         entry->index = numclasses;
 733     }
 734     *idp = CLASS_INDEX_TO_ID(numclasses);
 735     xdr->numclasses = ++numclasses;
 736     return JS_TRUE;
 737 }
 738
 739 JS_PUBLIC_API(uint32)
 740 JS_XDRFindClassIdByName(JSXDRState *xdr, const char *name)
 741 {
 742     uintN i, numclasses;
 743
 744     numclasses = xdr->numclasses;
 745     if (numclasses >= 10) {
 746         JSRegHashEntry *entry;
 747
 748         /* Bootstrap reghash from registry on first overpopulated Find. */
 749         if (!xdr->reghash) {
 750             xdr->reghash =
 751                 JS_NewDHashTable(JS_DHashGetStubOps(), NULL,
 752                                  sizeof(JSRegHashEntry),
 753                                  JS_DHASH_DEFAULT_CAPACITY(numclasses));
 754             if (xdr->reghash) {
 755                 for (i = 0; i < numclasses; i++) {
 756                     JSClass *clasp = xdr->registry[i];
 757                     entry = (JSRegHashEntry *)
 758                         JS_DHashTableOperate((JSDHashTable *) xdr->reghash,
 759                                              clasp->name, JS_DHASH_ADD);
 760                     entry->name = clasp->name;
 761                     entry->index = i;
 762                 }
 763             }
 764         }
 765
 766         /* If we managed to create reghash, use it for O(1) Find. */
 767         if (xdr->reghash) {
 768             entry = (JSRegHashEntry *)
 769                 JS_DHashTableOperate((JSDHashTable *) xdr->reghash,
 770                                      name, JS_DHASH_LOOKUP);
 771             if (JS_DHASH_ENTRY_IS_BUSY(&entry->hdr))
 772                 return CLASS_INDEX_TO_ID(entry->index);
 773         }
 774     }
 775
 776     /* Only a few classes, or we couldn't malloc reghash: use linear search. */
 777     for (i = 0; i < numclasses; i++) {
 778         if (!strcmp(name, xdr->registry[i]->name))
 779             return CLASS_INDEX_TO_ID(i);
 780     }
 781     return 0;
 782 }
 783
 784 JS_PUBLIC_API(JSClass *)
 785 JS_XDRFindClassById(JSXDRState *xdr, uint32 id)
 786 {
 787     uintN i = CLASS_ID_TO_INDEX(id);
 788
 789     if (i >= xdr->numclasses)
 790         return NULL;
 791     return xdr->registry[i];
 792 }
 793
 794 #endif /* JS_HAS_XDR */