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 "jsstddef.h"
40 #include "jsconfig.h"
41
42 #if JS_HAS_XDR
43
44 #include <string.h>
45 #include "jstypes.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_ = JS_realloc((xdr)->cx, MEM_BASE(xdr), limit_); \
94 if (!data_) \
95 return 0; \
96 MEM_BASE(xdr) = 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
mem_get32(JSXDRState * xdr,uint32 * lp)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
mem_set32(JSXDRState * xdr,uint32 * lp)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
mem_getbytes(JSXDRState * xdr,char * bytes,uint32 len)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
mem_setbytes(JSXDRState * xdr,char * bytes,uint32 len)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 *
mem_raw(JSXDRState * xdr,uint32 len)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
mem_seek(JSXDRState * xdr,int32 offset,JSXDRWhence whence)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
mem_tell(JSXDRState * xdr)211 mem_tell(JSXDRState *xdr)
212 {
213 return MEM_COUNT(xdr);
214 }
215
216 static void
mem_finalize(JSXDRState * xdr)217 mem_finalize(JSXDRState *xdr)
218 {
219 JS_free(xdr->cx, 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)
JS_XDRInitBase(JSXDRState * xdr,JSXDRMode mode,JSContext * cx)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 *)
JS_XDRNewMem(JSContext * cx,JSXDRMode mode)240 JS_XDRNewMem(JSContext *cx, JSXDRMode mode)
241 {
242 JSXDRState *xdr = (JSXDRState *) JS_malloc(cx, sizeof(JSXDRMemState));
243 if (!xdr)
244 return NULL;
245 JS_XDRInitBase(xdr, mode, cx);
246 if (mode == JSXDR_ENCODE) {
247 if (!(MEM_BASE(xdr) = JS_malloc(cx, MEM_BLOCK))) {
248 JS_free(cx, 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 *)
JS_XDRMemGetData(JSXDRState * xdr,uint32 * lp)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)
JS_XDRMemSetData(JSXDRState * xdr,void * data,uint32 len)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) = data;
277 MEM_COUNT(xdr) = 0;
278 }
279
280 JS_PUBLIC_API(uint32)
JS_XDRMemDataLeft(JSXDRState * xdr)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)
JS_XDRMemResetData(JSXDRState * xdr)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)
JS_XDRDestroy(JSXDRState * xdr)297 JS_XDRDestroy(JSXDRState *xdr)
298 {
299 JSContext *cx = xdr->cx;
300 xdr->ops->finalize(xdr);
301 if (xdr->registry) {
302 JS_free(cx, xdr->registry);
303 if (xdr->reghash)
304 JS_DHashTableDestroy(xdr->reghash);
305 }
306 JS_free(cx, xdr);
307 }
308
309 JS_PUBLIC_API(JSBool)
JS_XDRUint8(JSXDRState * xdr,uint8 * b)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)
JS_XDRUint16(JSXDRState * xdr,uint16 * s)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)
JS_XDRUint32(JSXDRState * xdr,uint32 * lp)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)
JS_XDRBytes(JSXDRState * xdr,char * bytes,uint32 len)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)
JS_XDRCString(JSXDRState * xdr,char ** sp)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 *) JS_malloc(xdr->cx, len + 1)))
385 return JS_FALSE;
386 }
387 if (!JS_XDRBytes(xdr, *sp, len)) {
388 if (xdr->mode == JSXDR_DECODE)
389 JS_free(xdr->cx, *sp);
390 return JS_FALSE;
391 }
392 if (xdr->mode == JSXDR_DECODE) {
393 (*sp)[len] = '\0';
394 } else if (xdr->mode == JSXDR_FREE) {
395 JS_free(xdr->cx, *sp);
396 *sp = NULL;
397 }
398 return JS_TRUE;
399 }
400
401 JS_PUBLIC_API(JSBool)
JS_XDRCStringOrNull(JSXDRState * xdr,char ** sp)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
XDRChars(JSXDRState * xdr,jschar * chars,uint32 nchars)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)
JS_XDRString(JSXDRState * xdr,JSString ** strp)444 JS_XDRString(JSXDRState *xdr, JSString **strp)
445 {
446 uint32 nchars;
447 jschar *chars;
448
449 if (xdr->mode == JSXDR_ENCODE)
450 nchars = JSSTRING_LENGTH(*strp);
451 if (!JS_XDRUint32(xdr, &nchars))
452 return JS_FALSE;
453
454 if (xdr->mode == JSXDR_DECODE) {
455 chars = (jschar *) JS_malloc(xdr->cx, (nchars + 1) * sizeof(jschar));
456 if (!chars)
457 return JS_FALSE;
458 } else {
459 chars = JSSTRING_CHARS(*strp);
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 JS_free(xdr->cx, chars);
475 return JS_FALSE;
476 }
477
478 JS_PUBLIC_API(JSBool)
JS_XDRStringOrNull(JSXDRState * xdr,JSString ** strp)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
XDRDoubleValue(JSXDRState * xdr,jsdouble * dp)492 XDRDoubleValue(JSXDRState *xdr, jsdouble *dp)
493 {
494 jsdpun u;
495
496 if (xdr->mode == JSXDR_ENCODE)
497 u.d = *dp;
498 if (!JS_XDRUint32(xdr, &u.s.lo) || !JS_XDRUint32(xdr, &u.s.hi))
499 return JS_FALSE;
500 if (xdr->mode == JSXDR_DECODE)
501 *dp = u.d;
502 return JS_TRUE;
503 }
504
505 JS_PUBLIC_API(JSBool)
JS_XDRDouble(JSXDRState * xdr,jsdouble ** dpp)506 JS_XDRDouble(JSXDRState *xdr, jsdouble **dpp)
507 {
508 jsdouble d;
509
510 if (xdr->mode == JSXDR_ENCODE)
511 d = **dpp;
512 if (!XDRDoubleValue(xdr, &d))
513 return JS_FALSE;
514 if (xdr->mode == JSXDR_DECODE) {
515 *dpp = JS_NewDouble(xdr->cx, d);
516 if (!*dpp)
517 return JS_FALSE;
518 }
519 return JS_TRUE;
520 }
521
522 /* These are magic pseudo-tags: see jsapi.h, near the top, for real tags. */
523 #define JSVAL_XDRNULL 0x8
524 #define JSVAL_XDRVOID 0xA
525
526 static JSBool
XDRValueBody(JSXDRState * xdr,uint32 type,jsval * vp)527 XDRValueBody(JSXDRState *xdr, uint32 type, jsval *vp)
528 {
529 switch (type) {
530 case JSVAL_XDRNULL:
531 *vp = JSVAL_NULL;
532 break;
533 case JSVAL_XDRVOID:
534 *vp = JSVAL_VOID;
535 break;
536 case JSVAL_STRING: {
537 JSString *str;
538 if (xdr->mode == JSXDR_ENCODE)
539 str = JSVAL_TO_STRING(*vp);
540 if (!JS_XDRString(xdr, &str))
541 return JS_FALSE;
542 if (xdr->mode == JSXDR_DECODE)
543 *vp = STRING_TO_JSVAL(str);
544 break;
545 }
546 case JSVAL_DOUBLE: {
547 jsdouble *dp;
548 if (xdr->mode == JSXDR_ENCODE)
549 dp = JSVAL_TO_DOUBLE(*vp);
550 if (!JS_XDRDouble(xdr, &dp))
551 return JS_FALSE;
552 if (xdr->mode == JSXDR_DECODE)
553 *vp = DOUBLE_TO_JSVAL(dp);
554 break;
555 }
556 case JSVAL_OBJECT: {
557 JSObject *obj;
558 if (xdr->mode == JSXDR_ENCODE)
559 obj = JSVAL_TO_OBJECT(*vp);
560 if (!js_XDRObject(xdr, &obj))
561 return JS_FALSE;
562 if (xdr->mode == JSXDR_DECODE)
563 *vp = OBJECT_TO_JSVAL(obj);
564 break;
565 }
566 case JSVAL_BOOLEAN: {
567 uint32 b;
568 if (xdr->mode == JSXDR_ENCODE)
569 b = (uint32) JSVAL_TO_BOOLEAN(*vp);
570 if (!JS_XDRUint32(xdr, &b))
571 return JS_FALSE;
572 if (xdr->mode == JSXDR_DECODE)
573 *vp = BOOLEAN_TO_JSVAL((JSBool) b);
574 break;
575 }
576 default: {
577 uint32 i;
578
579 JS_ASSERT(type & JSVAL_INT);
580 if (xdr->mode == JSXDR_ENCODE)
581 i = (uint32) JSVAL_TO_INT(*vp);
582 if (!JS_XDRUint32(xdr, &i))
583 return JS_FALSE;
584 if (xdr->mode == JSXDR_DECODE)
585 *vp = INT_TO_JSVAL((int32) i);
586 break;
587 }
588 }
589 return JS_TRUE;
590 }
591
592 JS_PUBLIC_API(JSBool)
JS_XDRValue(JSXDRState * xdr,jsval * vp)593 JS_XDRValue(JSXDRState *xdr, jsval *vp)
594 {
595 uint32 type;
596
597 if (xdr->mode == JSXDR_ENCODE) {
598 if (JSVAL_IS_NULL(*vp))
599 type = JSVAL_XDRNULL;
600 else if (JSVAL_IS_VOID(*vp))
601 type = JSVAL_XDRVOID;
602 else
603 type = JSVAL_TAG(*vp);
604 }
605 return JS_XDRUint32(xdr, &type) && XDRValueBody(xdr, type, vp);
606 }
607
608 JSBool
js_XDRAtom(JSXDRState * xdr,JSAtom ** atomp)609 js_XDRAtom(JSXDRState *xdr, JSAtom **atomp)
610 {
611 jsval v;
612 uint32 type;
613 jsdouble d;
614 JSAtom *atom;
615
616 if (xdr->mode == JSXDR_ENCODE) {
617 v = ATOM_KEY(*atomp);
618 return JS_XDRValue(xdr, &v);
619 }
620
621 /*
622 * Inline JS_XDRValue when decoding to avoid ceation of GC things when
623 * then corresponding atom already exists. See bug 321985.
624 */
625 if (!JS_XDRUint32(xdr, &type))
626 return JS_FALSE;
627 if (type == JSVAL_STRING)
628 return js_XDRStringAtom(xdr, atomp);
629
630 if (type == JSVAL_DOUBLE) {
631 if (!XDRDoubleValue(xdr, &d))
632 return JS_FALSE;
633 atom = js_AtomizeDouble(xdr->cx, d, 0);
634 } else {
635 if (!XDRValueBody(xdr, type, &v))
636 return JS_FALSE;
637 atom = js_AtomizeValue(xdr->cx, v, 0);
638 }
639
640 if (!atom)
641 return JS_FALSE;
642 *atomp = atom;
643 return JS_TRUE;
644 }
645
646 extern JSBool
js_XDRStringAtom(JSXDRState * xdr,JSAtom ** atomp)647 js_XDRStringAtom(JSXDRState *xdr, JSAtom **atomp)
648 {
649 JSString *str;
650 uint32 nchars;
651 JSAtom *atom;
652 JSContext *cx;
653 void *mark;
654 jschar *chars;
655
656 if (xdr->mode == JSXDR_ENCODE) {
657 JS_ASSERT(ATOM_IS_STRING(*atomp));
658 str = ATOM_TO_STRING(*atomp);
659 return JS_XDRString(xdr, &str);
660 }
661
662 /*
663 * Inline JS_XDRString when decoding to avoid JSString allocation
664 * for already existing atoms. See bug 321985.
665 */
666 if (!JS_XDRUint32(xdr, &nchars))
667 return JS_FALSE;
668 atom = NULL;
669 cx = xdr->cx;
670 mark = JS_ARENA_MARK(&cx->tempPool);
671 JS_ARENA_ALLOCATE_CAST(chars, jschar *, &cx->tempPool,
672 nchars * sizeof(jschar));
673 if (!chars)
674 JS_ReportOutOfMemory(cx);
675 else if (XDRChars(xdr, chars, nchars))
676 atom = js_AtomizeChars(cx, chars, nchars, 0);
677 JS_ARENA_RELEASE(&cx->tempPool, mark);
678 if (!atom)
679 return JS_FALSE;
680 *atomp = atom;
681 return JS_TRUE;
682 }
683
684 /*
685 * FIXME: This performs lossy conversion and we need to switch to
686 * js_XDRStringAtom while allowing to read older XDR files. See bug 325202.
687 */
688 JSBool
js_XDRCStringAtom(JSXDRState * xdr,JSAtom ** atomp)689 js_XDRCStringAtom(JSXDRState *xdr, JSAtom **atomp)
690 {
691 char *bytes;
692 uint32 nbytes;
693 JSAtom *atom;
694 JSContext *cx;
695 void *mark;
696
697 if (xdr->mode == JSXDR_ENCODE) {
698 JS_ASSERT(ATOM_IS_STRING(*atomp));
699 bytes = JS_GetStringBytes(ATOM_TO_STRING(*atomp));
700 return JS_XDRCString(xdr, &bytes);
701 }
702
703 /*
704 * Inline JS_XDRCString when decoding not to malloc temporary buffer
705 * just to free it after atomization. See bug 321985.
706 */
707 if (!JS_XDRUint32(xdr, &nbytes))
708 return JS_FALSE;
709 atom = NULL;
710 cx = xdr->cx;
711 mark = JS_ARENA_MARK(&cx->tempPool);
712 JS_ARENA_ALLOCATE_CAST(bytes, char *, &cx->tempPool,
713 nbytes * sizeof *bytes);
714 if (!bytes)
715 JS_ReportOutOfMemory(cx);
716 else if (JS_XDRBytes(xdr, bytes, nbytes))
717 atom = js_Atomize(cx, bytes, nbytes, 0);
718 JS_ARENA_RELEASE(&cx->tempPool, mark);
719 if (!atom)
720 return JS_FALSE;
721 *atomp = atom;
722 return JS_TRUE;
723 }
724
725 JS_PUBLIC_API(JSBool)
JS_XDRScript(JSXDRState * xdr,JSScript ** scriptp)726 JS_XDRScript(JSXDRState *xdr, JSScript **scriptp)
727 {
728 if (!js_XDRScript(xdr, scriptp, NULL))
729 return JS_FALSE;
730 if (xdr->mode == JSXDR_DECODE)
731 js_CallNewScriptHook(xdr->cx, *scriptp, NULL);
732 return JS_TRUE;
733 }
734
735 #define CLASS_REGISTRY_MIN 8
736 #define CLASS_INDEX_TO_ID(i) ((i)+1)
737 #define CLASS_ID_TO_INDEX(id) ((id)-1)
738
739 typedef struct JSRegHashEntry {
740 JSDHashEntryHdr hdr;
741 const char *name;
742 uint32 index;
743 } JSRegHashEntry;
744
745 JS_PUBLIC_API(JSBool)
JS_XDRRegisterClass(JSXDRState * xdr,JSClass * clasp,uint32 * idp)746 JS_XDRRegisterClass(JSXDRState *xdr, JSClass *clasp, uint32 *idp)
747 {
748 uintN numclasses, maxclasses;
749 JSClass **registry;
750
751 numclasses = xdr->numclasses;
752 maxclasses = xdr->maxclasses;
753 if (numclasses == maxclasses) {
754 maxclasses = (maxclasses == 0) ? CLASS_REGISTRY_MIN : maxclasses << 1;
755 registry = (JSClass **)
756 JS_realloc(xdr->cx, xdr->registry, maxclasses * sizeof(JSClass *));
757 if (!registry)
758 return JS_FALSE;
759 xdr->registry = registry;
760 xdr->maxclasses = maxclasses;
761 } else {
762 JS_ASSERT(numclasses && numclasses < maxclasses);
763 registry = xdr->registry;
764 }
765
766 registry[numclasses] = clasp;
767 if (xdr->reghash) {
768 JSRegHashEntry *entry = (JSRegHashEntry *)
769 JS_DHashTableOperate(xdr->reghash, clasp->name, JS_DHASH_ADD);
770 if (!entry) {
771 JS_ReportOutOfMemory(xdr->cx);
772 return JS_FALSE;
773 }
774 entry->name = clasp->name;
775 entry->index = numclasses;
776 }
777 *idp = CLASS_INDEX_TO_ID(numclasses);
778 xdr->numclasses = ++numclasses;
779 return JS_TRUE;
780 }
781
782 JS_PUBLIC_API(uint32)
JS_XDRFindClassIdByName(JSXDRState * xdr,const char * name)783 JS_XDRFindClassIdByName(JSXDRState *xdr, const char *name)
784 {
785 uintN i, numclasses;
786
787 numclasses = xdr->numclasses;
788 if (numclasses >= 10) {
789 JSRegHashEntry *entry;
790
791 /* Bootstrap reghash from registry on first overpopulated Find. */
792 if (!xdr->reghash) {
793 xdr->reghash = JS_NewDHashTable(JS_DHashGetStubOps(), NULL,
794 sizeof(JSRegHashEntry),
795 numclasses);
796 if (xdr->reghash) {
797 for (i = 0; i < numclasses; i++) {
798 JSClass *clasp = xdr->registry[i];
799 entry = (JSRegHashEntry *)
800 JS_DHashTableOperate(xdr->reghash, clasp->name,
801 JS_DHASH_ADD);
802 entry->name = clasp->name;
803 entry->index = i;
804 }
805 }
806 }
807
808 /* If we managed to create reghash, use it for O(1) Find. */
809 if (xdr->reghash) {
810 entry = (JSRegHashEntry *)
811 JS_DHashTableOperate(xdr->reghash, name, JS_DHASH_LOOKUP);
812 if (JS_DHASH_ENTRY_IS_BUSY(&entry->hdr))
813 return CLASS_INDEX_TO_ID(entry->index);
814 }
815 }
816
817 /* Only a few classes, or we couldn't malloc reghash: use linear search. */
818 for (i = 0; i < numclasses; i++) {
819 if (!strcmp(name, xdr->registry[i]->name))
820 return CLASS_INDEX_TO_ID(i);
821 }
822 return 0;
823 }
824
825 JS_PUBLIC_API(JSClass *)
JS_XDRFindClassById(JSXDRState * xdr,uint32 id)826 JS_XDRFindClassById(JSXDRState *xdr, uint32 id)
827 {
828 uintN i = CLASS_ID_TO_INDEX(id);
829
830 if (i >= xdr->numclasses)
831 return NULL;
832 return xdr->registry[i];
833 }
834
835 #endif /* JS_HAS_XDR */
836