Debian Codegraph @

modules/lsp-runtime-lib/src/main/fmt/java/ObjectStream.cpp

raw
1 /*
2 * Copyright (C) 2025 Linux Studio Plugins Project <https://lsp-plug.in/>
3 * (C) 2025 Vladimir Sadovnikov <[email protected]>
4 *
5 * This file is part of lsp-runtime-lib
6 * Created on: 28 авг. 2019 г.
7 *
8 * lsp-runtime-lib is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version.
12 *
13 * lsp-runtime-lib is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with lsp-runtime-lib. If not, see <https://www.gnu.org/licenses/>.
20 */
21
22 #include <lsp-plug.in/common/endian.h>
23 #include <lsp-plug.in/common/alloc.h>
24 #include <lsp-plug.in/stdlib/string.h>
25 #include <lsp-plug.in/io/InFileStream.h>
26 #include <lsp-plug.in/io/InMemoryStream.h>
27
28 #include <lsp-plug.in/fmt/java/defs.h>
29 #include <lsp-plug.in/fmt/java/wrappers.h>
30 #include <lsp-plug.in/fmt/java/ObjectStream.h>
31
32 namespace lsp
33 {
34 namespace java
35 {
36
37 ObjectStream::ObjectStream(Handles *handles)
38 {
39 pIS = NULL;
40 nFlags = 0;
41 nToken = -STATUS_CLOSED;
42 enToken = JST_UNDEFINED;
43 nDepth = 0;
44 nVersion = -STATUS_CLOSED;
45 pHandles = handles;
46
47 sBlock.data = NULL;
48 sBlock.size = 0;
49 sBlock.offset = 0;
50 sBlock.unread = 0;
51 sBlock.enabled = true;
52
53 for (size_t i=0; i<JFT_TOTAL; ++i)
54 vTypeStrings[i] = NULL;
55 }
56
57 ObjectStream::~ObjectStream()
58 {
59 do_close();
60 }
61
62 status_t ObjectStream::do_close()
63 {
64 status_t res = STATUS_OK;
65 if (pIS != NULL)
66 {
67 if (nFlags & WRAP_CLOSE)
68 res = pIS->close();
69 if (nFlags & WRAP_DELETE)
70 delete pIS;
71 pIS = NULL;
72 }
73
74 if (sBlock.data != NULL)
75 ::free(sBlock.data);
76
77 for (size_t i=0; i<JFT_TOTAL; ++i)
78 {
79 if (vTypeStrings[i] != NULL)
80 {
81 delete vTypeStrings[i];
82 vTypeStrings[i] = NULL;
83 }
84 }
85
86 sBlock.data = NULL;
87 sBlock.size = 0;
88 sBlock.offset = 0;
89 sBlock.unread = 0;
90 sBlock.enabled = true;
91
92 nFlags = 0;
93 nToken = -STATUS_UNSPECIFIED;
94 enToken = JST_UNDEFINED;
95 nVersion = -STATUS_UNSPECIFIED;
96
97 return res;
98 }
99
100 status_t ObjectStream::open(const char *file)
101 {
102 io::InFileStream *is = new io::InFileStream();
103 status_t res = is->open(file);
104 if (res == STATUS_OK)
105 {
106 res = initial_read(is);
107 if (res == STATUS_OK)
108 {
109 pIS = is;
110 nFlags = WRAP_CLOSE | WRAP_DELETE;
111 return res;
112 }
113 is->close();
114 }
115 delete is;
116 return res;
117 }
118
119 status_t ObjectStream::open(const LSPString *file)
120 {
121 io::InFileStream *is = new io::InFileStream();
122 status_t res = is->open(file);
123 if (res == STATUS_OK)
124 {
125 res = initial_read(is);
126 if (res == STATUS_OK)
127 {
128 pIS = is;
129 nFlags = WRAP_CLOSE | WRAP_DELETE;
130 return res;
131 }
132 is->close();
133 }
134 delete is;
135 return res;
136 }
137
138 status_t ObjectStream::open(const io::Path *file)
139 {
140 io::InFileStream *is = new io::InFileStream();
141 status_t res = is->open(file);
142 if (res == STATUS_OK)
143 {
144 res = initial_read(is);
145 if (res == STATUS_OK)
146 {
147 pIS = is;
148 nFlags = WRAP_CLOSE | WRAP_DELETE;
149 return res;
150 }
151 is->close();
152 }
153 delete is;
154 return res;
155 }
156
157 status_t ObjectStream::wrap(const void *buf, size_t count)
158 {
159 io::InMemoryStream *is = new io::InMemoryStream(buf, count);
160 status_t res = initial_read(is);
161 if (res == STATUS_OK)
162 {
163 pIS = is;
164 nFlags = WRAP_CLOSE | WRAP_DELETE;
165 return res;
166 }
167 is->close();
168 delete is;
169 return res;
170 }
171
172 status_t ObjectStream::wrap(void *buf, size_t count, lsp_memdrop_t drop)
173 {
174 io::InMemoryStream *is = new io::InMemoryStream(buf, count, drop);
175 status_t res = initial_read(is);
176 if (res == STATUS_OK)
177 {
178 pIS = is;
179 nFlags = WRAP_CLOSE | WRAP_DELETE;
180 return res;
181 }
182 is->close();
183 delete is;
184 return res;
185 }
186
187 status_t ObjectStream::wrap(io::IInStream *is, size_t flags)
188 {
189 status_t res = initial_read(is);
190 if (res == STATUS_OK)
191 {
192 pIS = is;
193 nFlags = flags;
194 }
195 return res;
196 }
197
198 status_t ObjectStream::close()
199 {
200 return do_close();
201 }
202
203 status_t ObjectStream::initial_read(io::IInStream *is)
204 {
205 // Read stream header
206 obj_stream_hdr_t hdr;
207 ssize_t nread = is->read_fully(&hdr, sizeof(hdr));
208 if (nread != sizeof(hdr))
209 return ((nread >= 0) || (nread == -STATUS_EOF)) ? STATUS_BAD_FORMAT : status_t(-nread);
210 if (BE_TO_CPU(hdr.magic) != JAVA_STREAM_MAGIC)
211 return STATUS_BAD_FORMAT;
212 uint8_t *block = reinterpret_cast<uint8_t *>(::malloc(JAVA_MAX_BLOCK_SIZE));
213 if (block == NULL)
214 return STATUS_NO_MEM;
215
216 nVersion = BE_TO_CPU(hdr.version);
217 clear_token();
218 sBlock.data = block;
219
220 return STATUS_OK;
221 }
222
223 status_t ObjectStream::fill_block()
224 {
225 while (sBlock.offset >= sBlock.size) // Is there data in a block
226 {
227 // Is there unread data in a block?
228 if (sBlock.unread > 0)
229 {
230 ssize_t amount = (sBlock.unread <= JAVA_MAX_BLOCK_SIZE) ? sBlock.unread : JAVA_MAX_BLOCK_SIZE;
231 ssize_t read = pIS->read_fully(sBlock.data, amount);
232 if (read != amount)
233 return (read >= 0) ? STATUS_CORRUPTED : status_t(-read);
234
235 sBlock.size = read;
236 sBlock.offset = 0;
237 sBlock.unread -= amount;
238
239 return STATUS_OK;
240 }
241
242 // Fetch next token
243 status_t res = lookup_token();
244 if (res <= 0)
245 return res;
246
247 switch (res)
248 {
249 case TC_RESET: // Handle stream reset
250 res = parse_reset();
251 if (res != STATUS_OK)
252 return res;
253 break;
254
255 case TC_BLOCKDATA:
256 {
257 uint8_t blen;
258 const ssize_t nread = pIS->read_fully(&blen, sizeof(blen));
259 if (nread != sizeof(blen))
260 return (nread < 0) ? status_t(nread) : -STATUS_CORRUPTED;
261 sBlock.unread = blen;
262 break;
263 }
264 case TC_BLOCKDATALONG:
265 {
266 int32_t blen;
267 const ssize_t nread = pIS->read_fully(&blen, sizeof(blen));
268 if (nread != sizeof(blen))
269 return (nread < 0) ? status_t(nread) : -STATUS_CORRUPTED;
270 sBlock.unread = blen;
271 break;
272 }
273 default:
274 return STATUS_CORRUPTED;
275 }
276 }
277
278 return STATUS_OK;
279 }
280
281 status_t ObjectStream::read_fully(void *dst, size_t count)
282 {
283 if (pIS == NULL)
284 return STATUS_CLOSED;
285
286 if (!sBlock.enabled)
287 {
288 ssize_t bytes = pIS->read_fully(dst, count);
289 if (bytes < 0)
290 return status_t(-bytes);
291 return (size_t(bytes) == count) ? STATUS_OK : STATUS_CORRUPTED;
292 }
293
294 // Read data from block
295 uint8_t *buf = reinterpret_cast<uint8_t *>(dst);
296 while (count > 0)
297 {
298 // Fetch block
299 status_t res = fill_block();
300 if (res != STATUS_OK)
301 return res;
302
303 // Copy data from block
304 size_t avail = sBlock.size - sBlock.offset;
305 if (avail > count)
306 avail = count;
307 ::memcpy(buf, &sBlock.data[sBlock.offset], avail);
308 sBlock.offset += avail;
309 count -= avail;
310 }
311
312 return STATUS_OK;
313 }
314
315 status_t ObjectStream::get_token()
316 {
317 // Read and parse token
318 ssize_t token = pIS->read_byte();
319 switch (token)
320 {
321 #define JDEC(a, b) case a: nToken = a; enToken = b; break;
322 JDEC(TC_NULL, JST_NULL)
323 JDEC(TC_REFERENCE, JST_REFERENCE)
324 JDEC(TC_CLASSDESC, JST_CLASS_DESC)
325 JDEC(TC_OBJECT, JST_OBJECT)
326 JDEC(TC_STRING, JST_STRING)
327 JDEC(TC_ARRAY, JST_ARRAY)
328 JDEC(TC_CLASS, JST_CLASS)
329 JDEC(TC_BLOCKDATA, JST_BLOCK_DATA)
330 JDEC(TC_ENDBLOCKDATA, JST_END_BLOCK_DATA)
331 JDEC(TC_RESET, JST_RESET)
332 JDEC(TC_BLOCKDATALONG, JST_BLOCK_DATA)
333 JDEC(TC_EXCEPTION, JST_EXCEPTION)
334 JDEC(TC_LONGSTRING, JST_STRING)
335 JDEC(TC_PROXYCLASSDESC, JST_PROXY_CLASS_DESC)
336 JDEC(TC_ENUM, JST_ENUM)
337 #undef JDEC
338 default:
339 nToken = (token < 0) ? status_t(token) : -STATUS_CORRUPTED;
340 enToken = JST_UNDEFINED;
341 break;
342 }
343
344 return nToken;
345 }
346
347 status_t ObjectStream::current_token()
348 {
349 if (pIS == NULL)
350 return - STATUS_CLOSED;
351
352 // Try to get token
353 if (enToken == JST_UNDEFINED)
354 {
355 if (sBlock.enabled)
356 {
357 if ((sBlock.unread > 0) || (sBlock.offset < sBlock.size))
358 return JST_BLOCK_DATA;
359 }
360 get_token();
361 }
362
363 // Return valid token or error code stored in nToken
364 return (enToken != JST_UNDEFINED) ? enToken : nToken;
365 }
366
367 inline void ObjectStream::clear_token()
368 {
369 nToken = -STATUS_UNSPECIFIED;
370 enToken = JST_UNDEFINED;
371 }
372
373 status_t ObjectStream::lookup_token()
374 {
375 // Check state
376 if (pIS == NULL)
377 return -STATUS_CLOSED;
378
379 // Return valid token immediately if it is
380 if (enToken != JST_UNDEFINED)
381 return nToken;
382
383 // Protect from reading token from inside of the TC_BLOCKDATA
384 if (sBlock.enabled)
385 {
386 if ((sBlock.unread > 0) || (sBlock.offset < sBlock.size))
387 return -STATUS_BAD_STATE;
388 }
389
390 // Loop and process TC_RESET tokens
391 while (true)
392 {
393 // Get token
394 status_t res = get_token();
395 if ((res < 0) || (res != TC_RESET))
396 return res;
397
398 // Handle TC_RESET
399 if (nDepth > 0)
400 return -STATUS_CORRUPTED;
401
402 pHandles->clear();
403 clear_token();
404 }
405 }
406
407 #define STREAM_READ_IMPL(name, type_t) \
408 status_t ObjectStream::read_ ## name(type_t *dst) \
409 { \
410 type_t tmp; \
411 status_t res = read_fully(&tmp, sizeof(tmp)); \
412 if ((res == STATUS_OK) && (dst != NULL)) \
413 *dst = BE_TO_CPU(tmp); \
414 clear_token(); \
415 return res; \
416 }
417
418 STREAM_READ_IMPL(byte, uint8_t)
419 STREAM_READ_IMPL(byte, int8_t)
420 STREAM_READ_IMPL(short, uint16_t)
421 STREAM_READ_IMPL(short, int16_t)
422 STREAM_READ_IMPL(int, uint32_t)
423 STREAM_READ_IMPL(int, int32_t)
424 STREAM_READ_IMPL(long, uint64_t)
425 STREAM_READ_IMPL(long, int64_t)
426 STREAM_READ_IMPL(float, float_t)
427 STREAM_READ_IMPL(double, double_t)
428 STREAM_READ_IMPL(char, lsp_utf16_t)
429 STREAM_READ_IMPL(bool, bool_t)
430
431 #undef STREAM_READ_IMPL
432
433 #define STREAM_READS_IMPL(name, type_t) \
434 status_t ObjectStream::read_ ## name(type_t *dst, size_t count) \
435 { \
436 if (dst == NULL) return STATUS_BAD_ARGUMENTS; \
437 status_t res = read_fully(dst, sizeof(type_t) * count); \
438 __IF_LE(if (res == STATUS_OK) byte_swap(dst, count)); \
439 clear_token(); \
440 return res; \
441 }
442
443 STREAM_READS_IMPL(bytes, uint8_t)
444 STREAM_READS_IMPL(bytes, int8_t)
445 STREAM_READS_IMPL(shorts, uint16_t)
446 STREAM_READS_IMPL(shorts, int16_t)
447 STREAM_READS_IMPL(ints, uint32_t)
448 STREAM_READS_IMPL(ints, int32_t)
449 STREAM_READS_IMPL(longs, uint64_t)
450 STREAM_READS_IMPL(longs, int64_t)
451 STREAM_READS_IMPL(floats, float_t)
452 STREAM_READS_IMPL(doubles, double_t)
453 STREAM_READS_IMPL(chars, lsp_utf16_t)
454 STREAM_READS_IMPL(bools, bool_t)
455
456 #undef STREAM_READS_IMPL
457
458 status_t ObjectStream::set_block_mode(bool enabled, bool *old)
459 {
460 if (sBlock.enabled == enabled)
461 return STATUS_OK;
462 if (enabled)
463 {
464 sBlock.offset = 0;
465 sBlock.size = 0;
466 sBlock.unread = 0;
467 }
468 else if ((sBlock.offset < sBlock.size) || (sBlock.unread > 0))
469 return STATUS_BAD_STATE;
470
471 if (old != NULL)
472 *old = sBlock.enabled;
473 sBlock.enabled = enabled;
474 return STATUS_OK;
475 }
476
477 status_t ObjectStream::start_object(bool &mode)
478 {
479 status_t res = set_block_mode(false, &mode);
480 if (res == STATUS_OK)
481 ++nDepth;
482 return res;
483 }
484
485 status_t ObjectStream::end_object(bool &mode, status_t res)
486 {
487 --nDepth;
488 set_block_mode(mode, NULL);
489 return res;
490 }
491
492 status_t ObjectStream::intern_type_string(String **dst, ftype_t type, char ptype)
493 {
494 if ((type < 0) || (type >= JFT_TOTAL))
495 return STATUS_CORRUPTED;
496
497 String *p = vTypeStrings[type];
498 if (p == NULL)
499 {
500 p = new String();
501 if (p == NULL)
502 return STATUS_NO_MEM;
503 if (!p->string()->set(ptype))
504 {
505 delete p;
506 return STATUS_NO_MEM;
507 }
508 vTypeStrings[type] = p;
509 }
510
511 if (dst != NULL)
512 *dst = p;
513 return STATUS_OK;
514 }
515
516 status_t ObjectStream::parse_reference(Object **dst, const char *type)
517 {
518 // Analyze token
519 status_t res = lookup_token();
520 if (res != TC_REFERENCE)
521 return (res >= 0) ? STATUS_BAD_TYPE : -res;
522 clear_token();
523
524 // Read handle number and validate
525 uint32_t handle = 0;
526 res = read_int(&handle);
527 if (res != STATUS_OK)
528 return res;
529 else if (handle < JAVA_BASE_WIRE_HANDLE)
530 return STATUS_CORRUPTED;
531
532 // Dereference handle
533 Object *obj = pHandles->get(handle - JAVA_BASE_WIRE_HANDLE);
534 if (obj == NULL)
535 return STATUS_CORRUPTED;
536 if ((type != NULL) && (!obj->instanceof(type)))
537 return STATUS_BAD_TYPE;
538
539 // Store handle
540 if (dst != NULL)
541 *dst = obj;
542
543 return STATUS_OK;
544 }
545
546 status_t ObjectStream::parse_utf(LSPString *dst, size_t bytes)
547 {
548 // Allocate temporary buffer for string data
549 char *buf = reinterpret_cast<char *>(::malloc(bytes));
550 if (buf == NULL)
551 return STATUS_NO_MEM;
552
553 // Read string data
554 status_t res = read_fully(buf, bytes);
555 if (res != STATUS_OK)
556 {
557 ::free(buf);
558 return res;
559 }
560
561 // Create string and return
562 LSPString tmp;
563 res = (tmp.set_utf8(buf, bytes)) ? STATUS_OK : STATUS_NO_MEM;
564 ::free(buf);
565 if ((res == STATUS_OK) && (dst != NULL))
566 dst->swap(&tmp);
567 return res;
568 }
569
570 status_t ObjectStream::read_utf(LSPString *dst)
571 {
572 // Read length
573 uint16_t bytes = 0;
574 status_t res = read_short(&bytes);
575 return (res == STATUS_OK) ? parse_utf(dst, bytes) : STATUS_CORRUPTED;
576 }
577
578 status_t ObjectStream::parse_string(String **dst)
579 {
580 status_t res = lookup_token();
581 if (res < 0)
582 return -res;
583
584 // Fetch size of string
585 size_t bytes;
586 switch (res)
587 {
588 case TC_STRING:
589 {
590 uint16_t slen = 0;
591 if ((res = read_short(&slen)) != STATUS_OK) // This will clear token
592 return STATUS_CORRUPTED;
593 bytes = slen;
594 break;
595 }
596 case TC_LONGSTRING:
597 {
598 uint32_t slen = 0;
599 if ((res = read_int(&slen)) != STATUS_OK) // This will clear token
600 return STATUS_CORRUPTED;
601 bytes = slen;
602 break;
603 }
604 default:
605 return STATUS_CORRUPTED;
606 }
607
608 // Allocate handle reference
609 String *str = new String();
610 if (str == NULL)
611 return STATUS_NO_MEM;
612
613 // Read string contents
614 res = parse_utf(str->string(), bytes);
615 if (res == STATUS_OK)
616 pHandles->assign(str);
617
618 // Need to return string?
619 if (dst != NULL)
620 *dst = str;
621
622 return res;
623 }
624
625 status_t ObjectStream::parse_reset()
626 {
627 if (nDepth > 0)
628 return STATUS_CORRUPTED;
629
630 pHandles->clear();
631 clear_token();
632 return STATUS_OK;
633 }
634
635 status_t ObjectStream::parse_null(Object **dst)
636 {
637 status_t token = lookup_token();
638 if (token != TC_NULL)
639 return (token >= 0) ? STATUS_CORRUPTED : -token;
640 clear_token();
641
642 if (dst != NULL)
643 *dst = NULL;
644
645 return STATUS_OK;
646 }
647
648 status_t ObjectStream::parse_class_field(ObjectStreamField **dst)
649 {
650 // Allocate object
651 ObjectStreamField *f = new ObjectStreamField();
652 if (f == NULL)
653 return STATUS_NO_MEM;
654
655 status_t res;
656 uint8_t tcode = 0;
657
658 // Type code
659 res = read_byte(&tcode);
660 if (res == STATUS_OK)
661 {
662 f->enType = decode_primitive_type(tcode);
663 if (f->enType == JFT_UNKNOWN)
664 res = STATUS_CORRUPTED;
665 }
666
667 // Name
668 if (res == STATUS_OK)
669 {
670 res = read_utf(&f->sName);
671 if (res == STATUS_OK)
672 {
673 f->sRawName = f->sName.clone_utf8();
674 if (f->sRawName == NULL)
675 res = STATUS_NO_MEM;
676 }
677 }
678
679 // Signature
680 if (res == STATUS_OK)
681 {
682 res = (f->is_reference()) ?
683 read_string(&f->pSignature) :
684 intern_type_string(&f->pSignature, f->enType, tcode);
685 }
686
687 // Return result
688 if ((res == STATUS_OK) && (dst != NULL))
689 *dst = f;
690
691 return res;
692 }
693
694 status_t ObjectStream::skip_block_data()
695 {
696 if (!sBlock.enabled)
697 return STATUS_OK;
698
699 do
700 {
701 sBlock.offset = sBlock.size;
702 status_t res = fill_block();
703 if (res != STATUS_OK)
704 return res;
705 } while (sBlock.unread > 0);
706
707 return STATUS_OK;
708 }
709
710 status_t ObjectStream::skip_custom_data()
711 {
712 status_t res;
713
714 while (true)
715 {
716 // Complete data block
717 if (sBlock.enabled)
718 {
719 res = skip_block_data();
720 if (res == STATUS_OK)
721 res = set_block_mode(false, NULL);
722 if (res != STATUS_OK)
723 return res;
724 }
725
726 // Read token
727 res = lookup_token();
728 if (res < 0)
729 return -res;
730
731 // Analyze token
732 switch (res)
733 {
734 case TC_BLOCKDATA:
735 case TC_BLOCKDATALONG:
736 res = set_block_mode(true, NULL);
737 if (res == STATUS_OK)
738 res = fill_block();
739 break;
740
741 case TC_ENDBLOCKDATA:
742 clear_token();
743 return STATUS_OK;
744
745 default:
746 res = read_object(NULL);
747 break;
748 }
749
750 // Analyze result
751 if (res != STATUS_OK)
752 return res;
753 }
754 }
755
756 status_t ObjectStream::read_custom_data(void **dst, size_t *size)
757 {
758 status_t res = STATUS_OK;
759 size_t capacity = 0;
760 uint8_t *ptr = NULL;
761 bool endblockdata = false;
762
763 do
764 {
765 // Complete data block
766 if (sBlock.enabled)
767 {
768 // Read the block
769 size_t extra = sBlock.unread + sBlock.size - sBlock.offset;
770 uint8_t *xptr = reinterpret_cast<uint8_t *>(::realloc(ptr, capacity + extra));
771 if (xptr == NULL)
772 {
773 res = STATUS_NO_MEM;
774 break;
775 }
776 ptr = xptr;
777
778 // Copy data from block
779 size_t gap = sBlock.size - sBlock.offset;
780 if (gap > 0)
781 {
782 ::memcpy(&xptr[capacity], &sBlock.data[sBlock.size], gap);
783 capacity += gap;
784 sBlock.size = sBlock.offset;
785 }
786
787 // Read the left data
788 if (sBlock.unread > 0)
789 {
790 const ssize_t nread = pIS->read_fully(&xptr[capacity], sBlock.unread);
791 if (nread == ssize_t(sBlock.unread))
792 {
793 capacity += res;
794 sBlock.unread = 0;
795 res = STATUS_OK;
796 }
797 else
798 res = STATUS_CORRUPTED;
799 }
800
801 if (res == STATUS_OK)
802 res = set_block_mode(false, NULL);
803 }
804 if (res != STATUS_OK)
805 break;
806
807 // Read token
808 if ((res = lookup_token()) < 0)
809 {
810 res = -res;
811 break;
812 }
813
814 // Analyze token
815 switch (res)
816 {
817 case TC_BLOCKDATA:
818 {
819 uint8_t blen;
820 const ssize_t nread = pIS->read_fully(&blen, sizeof(blen));
821 if (nread != sizeof(blen))
822 {
823 res = (nread < 0) ? status_t(-nread) : STATUS_CORRUPTED;
824 break;
825 }
826
827 sBlock.enabled = true;
828 sBlock.offset = 0;
829 sBlock.size = 0;
830 sBlock.unread = blen;
831 res = STATUS_OK;
832 break;
833 }
834
835 case TC_BLOCKDATALONG:
836 {
837 int32_t blen;
838 const ssize_t nread = pIS->read_fully(&blen, sizeof(blen));
839 if (nread != sizeof(blen))
840 {
841 res = (nread < 0) ? status_t(-nread) : STATUS_CORRUPTED;
842 break;
843 }
844
845 sBlock.enabled = true;
846 sBlock.offset = 0;
847 sBlock.size = 0;
848 sBlock.unread = blen;
849 res = STATUS_OK;
850 break;
851 }
852 case TC_ENDBLOCKDATA:
853 clear_token();
854 endblockdata = true;
855 break;
856
857 default:
858 res = STATUS_CORRUPTED;
859 break;
860 }
861
862 // Analyze result
863 if (res != STATUS_OK)
864 break;
865 } while (!endblockdata);
866
867 // Return result
868 if (res == STATUS_OK)
869 {
870 if (dst != NULL)
871 *dst = ptr;
872 else
873 ::free(ptr);
874 if (size != NULL)
875 *size = capacity;
876 }
877 else if (ptr != NULL)
878 ::free(ptr);
879
880 return res;
881 }
882
883 status_t ObjectStream::parse_class_descriptor(ObjectStreamClass **dst)
884 {
885 status_t res = lookup_token();
886 if (res != TC_CLASSDESC)
887 return (res >= 0) ? STATUS_CORRUPTED : -res;
888
889 ObjectStreamClass *desc = new ObjectStreamClass();
890 if (desc == NULL)
891 return STATUS_CORRUPTED;
892
893 // Class name, will do reset_token()
894 res = read_utf(&desc->sName);
895 if (res == STATUS_OK)
896 {
897 desc->pRawName = desc->sName.clone_utf8();
898 res = ((desc->pRawName) != NULL) ? STATUS_OK : STATUS_NO_MEM;
899 }
900 // lsp_trace("Class name: %s", desc->sName.get_native());
901
902 // Serial version UID
903 if (res == STATUS_OK)
904 {
905 res = read_long(&desc->nSuid);
906 // lsp_trace("Class suid: %lld", (long long)(desc->nSuid));
907 }
908
909 // Register handle
910 if (res == STATUS_OK)
911 pHandles->assign(desc);
912
913 // Read & decode flags
914 uint8_t flags = 0;
915 if (res == STATUS_OK)
916 res = read_byte(&flags);
917 if (res == STATUS_OK)
918 {
919 // lsp_trace("Class flags: 0x%x", int(flags));
920
921 // Validate flags
922 if ((flags & (SC_SERIALIZABLE | SC_EXTERNALIZABLE)) == (SC_SERIALIZABLE | SC_EXTERNALIZABLE))
923 res = STATUS_CORRUPTED;
924 else if ((flags & SC_ENUM) && (desc->nSuid != 0))
925 res = STATUS_CORRUPTED;
926 }
927 if (res == STATUS_OK)
928 {
929 // Decode flags
930 if (flags & SC_WRITE_METHOD)
931 desc->nFlags |= JCF_WRITE_METHOD;
932 if (flags & SC_BLOCK_DATA)
933 desc->nFlags |= JCF_BLOCK_DATA;
934 if (flags & SC_EXTERNALIZABLE)
935 desc->nFlags |= JCF_EXTERNALIZABLE;
936 if (flags & SC_SERIALIZABLE)
937 desc->nFlags |= JCF_SERIALIZABLE;
938 if (flags & SC_ENUM)
939 desc->nFlags |= JCF_ENUM;
940 }
941
942 // Read fields
943 uint16_t fields = 0;
944 if (res == STATUS_OK)
945 res = read_short(&fields);
946 if ((res == STATUS_OK) && (fields > 0))
947 {
948 desc->vFields = reinterpret_cast<ObjectStreamField **>(::malloc(fields * sizeof(ObjectStreamField *)));
949 if (desc->vFields != NULL)
950 {
951 // Clear the list
952 ObjectStreamField **fl = desc->vFields;
953 for (size_t i=0; i<fields; ++i)
954 fl[i] = NULL;
955 desc->nFields = fields;
956
957 // Read, parse and validate each field
958 size_t base = 0;
959 size_t num_obj_fields = 0;
960 ssize_t first_obj_idx = -1;
961
962 for (size_t i=0; i<fields; ++i)
963 {
964 ObjectStreamField *f = NULL;
965 if ((res = parse_class_field(&f)) != STATUS_OK)
966 break;
967 // lsp_trace("Class Field: %s, signature: %s, size=%d, offset=0x%x",
968 // f->name()->get_native(), f->signature()->get_native(),
969 // int(f->size_of()), int(prim_data_size));
970
971 // Determine field location
972 desc->vFields[i] = f;
973 if (f->is_reference())
974 {
975 ++num_obj_fields;
976 if (first_obj_idx < 0)
977 first_obj_idx = i;
978 }
979
980 // Store the offset of the field
981 f->nOffset = f->aligned_offset(base);
982 base = f->nOffset + f->size_of();
983 }
984
985 // Validate the final state
986 if ((first_obj_idx >= 0) && ((first_obj_idx + num_obj_fields) != fields))
987 res = STATUS_CORRUPTED;
988
989 // Update object statistics
990 desc->nSizeOf = base;
991 }
992 else
993 res = STATUS_NO_MEM;
994 }
995
996 // Skip class annotations
997 if (res == STATUS_OK)
998 res = skip_custom_data();
999
1000 // Read parent class
1001 if (res == STATUS_OK)
1002 {
1003 desc->pParent = NULL;
1004 res = read_class_descriptor(&desc->pParent);
1005 }
1006
1007 // Generate slots
1008 if (res == STATUS_OK)
1009 {
1010 // Store slots in reverse order to the class hierarchy
1011 size_t slots = 0;
1012 for (ObjectStreamClass *curr = desc; curr != NULL; curr = curr->pParent)
1013 ++slots;
1014 desc->vClasses = reinterpret_cast<ObjectStreamClass **>(::malloc(slots * sizeof(ObjectStreamClass *)));
1015 desc->nClasses = slots;
1016 if (desc->vClasses != NULL)
1017 {
1018 for (ObjectStreamClass *curr = desc; curr != NULL; curr = curr->pParent)
1019 desc->vClasses[--slots] = curr;
1020 }
1021 }
1022
1023 // Analyze result
1024 if ((res == STATUS_OK) && (dst != NULL))
1025 *dst = desc;
1026
1027 return res;
1028 }
1029
1030 status_t ObjectStream::parse_proxy_class_descriptor(ObjectStreamClass **dst)
1031 {
1032 //TODO
1033 return STATUS_NOT_SUPPORTED;
1034 }
1035
1036 status_t ObjectStream::parse_array(RawArray **dst)
1037 {
1038 // Fetch token
1039 ssize_t token = lookup_token();
1040 if (token != TC_ARRAY)
1041 return (token >= 0) ? STATUS_CORRUPTED : status_t(-token);
1042 clear_token();
1043
1044 // Read class descriptor
1045 ObjectStreamClass *desc = NULL;
1046 status_t res = read_class_descriptor(&desc);
1047 if (res != STATUS_OK)
1048 return res;
1049
1050 // Create array object
1051 RawArray *arr = new RawArray(desc->raw_name());
1052 if (arr == NULL)
1053 return STATUS_NO_MEM;
1054
1055 // Register array and allocate data
1056 res = pHandles->assign(arr);
1057
1058 // Read length
1059 uint32_t len = 0;
1060 if (res == STATUS_OK)
1061 res = read_int(&len);
1062
1063 // Create array instance
1064 if (res == STATUS_OK)
1065 res = arr->allocate(len);
1066
1067 // Read elements
1068 if (res == STATUS_OK)
1069 {
1070 switch (arr->item_type())
1071 {
1072 case JFT_BYTE: res = read_bytes(arr->get<uint8_t>(), len); break;
1073 case JFT_CHAR: res = read_chars(arr->get<lsp_utf16_t>(), len); break;
1074 case JFT_DOUBLE: res = read_doubles(arr->get<double_t>(), len); break;
1075 case JFT_FLOAT: res = read_floats(arr->get<float_t>(), len); break;
1076 case JFT_INTEGER: res = read_ints(arr->get<uint32_t>(), len); break;
1077 case JFT_LONG: res = read_longs(arr->get<uint64_t>(), len); break;
1078 case JFT_SHORT: res = read_shorts(arr->get<uint16_t>(), len); break;
1079 case JFT_BOOL: res = read_bools(arr->get<bool_t>(), len); break;
1080 case JFT_ARRAY:
1081 case JFT_OBJECT:
1082 {
1083 Object **data = arr->get<Object *>();
1084 for (size_t i=0; i<len; ++i)
1085 if ((res = read_object(&data[i])) != STATUS_OK)
1086 break;
1087 break;
1088 }
1089 default: res = STATUS_BAD_TYPE;
1090 }
1091 }
1092
1093 // Store result
1094 if ((res == STATUS_OK) && (dst != NULL))
1095 *dst = arr;
1096
1097 return res;
1098 }
1099
1100 status_t ObjectStream::parse_enum(Enum **dst)
1101 {
1102 // Fetch token
1103 status_t token = lookup_token();
1104 if (token != TC_ENUM)
1105 return (token >= 0) ? STATUS_CORRUPTED : -token;
1106 clear_token();
1107
1108 // Read class descriptor
1109 ObjectStreamClass *desc = NULL;
1110 status_t res = read_class_descriptor(&desc);
1111 if (res != STATUS_OK)
1112 return res;
1113
1114 // Create enum object
1115 Enum *en = new Enum();
1116 if (en == NULL)
1117 return STATUS_NO_MEM;
1118 en->pClass = desc->pRawName;
1119
1120 // Register enum and allocate data
1121 res = pHandles->assign(en);
1122
1123 // Read enum constant
1124 if (res == STATUS_OK)
1125 {
1126 String *pstr = NULL;
1127 res = read_string(&pstr);
1128 if (res == STATUS_OK)
1129 res = (en->sName.set(pstr->string())) ? STATUS_OK : STATUS_NO_MEM;
1130 }
1131
1132 // Store result
1133 if ((res == STATUS_OK) && (dst != NULL))
1134 *dst = en;
1135
1136 return res;
1137 }
1138
1139 status_t ObjectStream::parse_serial_data(Object *dst, ObjectStreamClass *desc)
1140 {
1141 // Initialize slots
1142 dst->vSlots = reinterpret_cast<object_slot_t *>(::malloc(desc->nClasses * sizeof(object_slot_t)));
1143 if (dst->vSlots == NULL)
1144 return STATUS_NO_MEM;
1145 dst->nSlots = desc->nClasses;
1146
1147 // Estimate number of initial data for allocation
1148 size_t allocated = 0, offset = 0;
1149 for (size_t i=0, n=desc->nClasses; i<n; ++i)
1150 {
1151 ObjectStreamClass *cl = desc->vClasses[i];
1152 // if (cl->is_serializable()) // Skip serializable objects
1153 // continue;
1154 allocated += align_size(cl->nSizeOf, MINIMUM_ALIGN);
1155 }
1156
1157 // Allocate memory
1158 dst->vData = reinterpret_cast<uint8_t *>(::malloc(allocated));
1159 if (dst->vData == NULL)
1160 return STATUS_NO_MEM;
1161 ::bzero(dst->vData, allocated);
1162
1163 // Perform read of the object
1164 status_t res = STATUS_OK;
1165 for (size_t i=0, n=desc->nClasses; i<n; ++i)
1166 {
1167 ObjectStreamClass *cl = desc->vClasses[i];
1168 object_slot_t *sl = &dst->vSlots[i];
1169
1170 sl->desc = cl;
1171 sl->offset = offset;
1172 sl->size = 0;
1173 sl->__pad = 0;
1174
1175 if (cl->has_write_method())
1176 {
1177 void *tmp = NULL;
1178 size_t tail = 0;
1179
1180 // Read object's serial data from underlying stream
1181 res = read_custom_data(&tmp, &tail);
1182 if (res != STATUS_OK)
1183 break;
1184 else if (tail <= 0)
1185 continue;
1186
1187 // Align the object's data to the boundary and re-allocate segment
1188 size_t space = align_size(tail, MINIMUM_ALIGN);
1189 sl->size = tail;
1190 allocated += space;
1191 uint8_t *xdata = reinterpret_cast<uint8_t *>(::realloc(dst->vData, space));
1192 if (xdata == NULL)
1193 {
1194 res = STATUS_NO_MEM;
1195 break;
1196 }
1197 dst->vData = xdata;
1198
1199 // Copy data to the class structure
1200 ::memcpy(&dst->vData[offset], tmp, tail);
1201 ::free(tmp);
1202 offset += space;
1203 }
1204 else
1205 {
1206 // Read serial data
1207 prim_ptr_t xdata;
1208 size_t space = align_size(cl->nSizeOf, MINIMUM_ALIGN);
1209 sl->size = cl->nSizeOf;
1210
1211 // Operate each field
1212 for (size_t j=0, m=cl->nFields; j<m; ++j)
1213 {
1214 ObjectStreamField *f = cl->vFields[j];
1215 xdata.p_ubyte = &dst->vData[f->offset()];
1216 // lsp_trace(" reading field: %s", f->sName.get_native());
1217 switch (f->type())
1218 {
1219 case JFT_BYTE: res = read_byte(xdata.p_ubyte); break;
1220 case JFT_CHAR: res = read_char(xdata.p_char); break;
1221 case JFT_DOUBLE: res = read_double(xdata.p_double); break;
1222 case JFT_FLOAT: res = read_float(xdata.p_float); break;
1223 case JFT_INTEGER: res = read_int(xdata.p_uint); break;
1224 case JFT_LONG: res = read_long(xdata.p_ulong); break;
1225 case JFT_SHORT: res = read_short(xdata.p_ushort); break;
1226 case JFT_BOOL: res = read_bool(xdata.p_bool); break;
1227 case JFT_ARRAY:
1228 case JFT_OBJECT:
1229 {
1230 Object *obj = NULL;
1231 res = read_object(&obj);
1232 if (res == STATUS_OK)
1233 *xdata.p_object = obj;
1234 break;
1235 }
1236 default:
1237 res = STATUS_CORRUPTED;
1238 break;
1239 }
1240
1241 if (res != STATUS_OK)
1242 break;
1243 }
1244
1245 offset += space;
1246 }
1247
1248 if (res != STATUS_OK)
1249 break;
1250 }
1251
1252 return res;
1253 }
1254
1255 status_t ObjectStream::parse_external_data(Object *dst, ObjectStreamClass *desc)
1256 {
1257 // TODO
1258 return STATUS_NOT_IMPLEMENTED;
1259 }
1260
1261 Object *ObjectStream::build_object(ObjectStreamClass *desc)
1262 {
1263 const char *raw_name = desc->raw_name();
1264
1265 if (!strcmp(raw_name, Byte::CLASS_NAME))
1266 return new Byte();
1267 if (!strcmp(raw_name, Short::CLASS_NAME))
1268 return new Short();
1269 if (!strcmp(raw_name, Integer::CLASS_NAME))
1270 return new Integer();
1271 if (!strcmp(raw_name, Long::CLASS_NAME))
1272 return new Long();
1273 if (!strcmp(raw_name, Double::CLASS_NAME))
1274 return new Double();
1275 if (!strcmp(raw_name, Float::CLASS_NAME))
1276 return new Float();
1277 if (!strcmp(raw_name, Boolean::CLASS_NAME))
1278 return new Boolean();
1279 if (!strcmp(raw_name, Character::CLASS_NAME))
1280 return new Character();
1281
1282 return new Object(desc->raw_name());
1283 }
1284
1285 status_t ObjectStream::parse_ordinary_object(Object **dst)
1286 {
1287 // Fetch token
1288 status_t token = lookup_token();
1289 if (token != TC_OBJECT)
1290 return (token >= 0) ? STATUS_CORRUPTED : -token;
1291 clear_token();
1292
1293 // Read class descriptor
1294 ObjectStreamClass *desc = NULL;
1295 status_t res = read_class_descriptor(&desc);
1296 if (res != STATUS_OK)
1297 return res;
1298
1299 // Create object
1300 Object *obj = build_object(desc);
1301 if (obj == NULL)
1302 return STATUS_NO_MEM;
1303
1304 // Register object and allocate data
1305 res = pHandles->assign(obj);
1306
1307 if (res == STATUS_OK)
1308 {
1309 res = (desc->is_externalizable()) ?
1310 parse_external_data(obj, desc) :
1311 parse_serial_data(obj, desc);
1312 }
1313
1314 // Store result
1315 if ((res == STATUS_OK) && (dst != NULL))
1316 *dst = obj;
1317
1318 return res;
1319 }
1320
1321
1322 status_t ObjectStream::parse_object(Object **dst)
1323 {
1324 // Fetch token
1325 status_t token = lookup_token();
1326 if (token < 0)
1327 return token;
1328
1329 // Start object mode
1330 bool mode = false;
1331 status_t res = start_object(mode);
1332 if (res != STATUS_OK)
1333 return res;
1334
1335 obj_ptr_t ret(dst);
1336 switch (token)
1337 {
1338 case TC_NULL: // Null reference, valid to be string
1339 return end_object(mode, parse_null(ret));
1340
1341 case TC_REFERENCE: // Some reference to object, required to be string
1342 return end_object(mode, parse_reference(ret, NULL));
1343
1344 case TC_STRING: // String with 16-bit length
1345 case TC_LONGSTRING: // String with 32-bit length
1346 return end_object(mode, parse_string(ret));
1347
1348 case TC_ARRAY: // Array
1349 return end_object(mode, parse_array(ret));
1350
1351 case TC_OBJECT: // Object
1352 return end_object(mode, parse_ordinary_object(ret));
1353
1354 case TC_ENUM: // Enumeration
1355 return end_object(mode, parse_enum(ret));
1356
1357 case TC_CLASSDESC:
1358 case TC_PROXYCLASSDESC:
1359 return end_object(mode, parse_class_descriptor(ret));
1360
1361 default:
1362 break;
1363 }
1364
1365 return end_object(mode, STATUS_BAD_STATE);
1366 }
1367
1368 status_t ObjectStream::read_object(Object **dst)
1369 {
1370 return parse_object(dst);
1371 }
1372
1373 status_t ObjectStream::read_string(String **dst)
1374 {
1375 // Fetch token
1376 status_t token = lookup_token();
1377 if (token < 0)
1378 return token;
1379
1380 // Start object mode
1381 bool mode = false;
1382 status_t res = start_object(mode);
1383 if (res != STATUS_OK)
1384 return res;
1385
1386 obj_ptr_t ret(dst);
1387 switch (token)
1388 {
1389 case TC_NULL: // Null reference, valid to be string
1390 return end_object(mode, parse_null(ret));
1391
1392 case TC_REFERENCE: // Some reference to object, required to be string
1393 return end_object(mode, parse_reference(ret, String::CLASS_NAME));
1394
1395 case TC_STRING:
1396 case TC_LONGSTRING:
1397 return end_object(mode, parse_string(ret));
1398
1399 default:
1400 break;
1401 }
1402
1403 return end_object(mode, STATUS_BAD_STATE);
1404 }
1405
1406 status_t ObjectStream::read_string(LSPString *dst)
1407 {
1408 String *str = NULL;
1409 status_t res = read_string(&str);
1410 if (res != STATUS_OK)
1411 return res;
1412 else if (str == NULL)
1413 return STATUS_NULL;
1414
1415 if (dst != NULL)
1416 {
1417 if (!dst->set(str->string()))
1418 return STATUS_NO_MEM;
1419 }
1420 return STATUS_OK;
1421 }
1422
1423 status_t ObjectStream::read_array(RawArray **dst)
1424 {
1425 // Fetch token
1426 status_t token = lookup_token();
1427 if (token < 0)
1428 return token;
1429
1430 // Start object mode
1431 bool mode = false;
1432 status_t res = start_object(mode);
1433 if (res != STATUS_OK)
1434 return res;
1435
1436 obj_ptr_t ret(dst);
1437 switch (token)
1438 {
1439 case TC_NULL: // Null reference, valid to be string
1440 return end_object(mode, parse_null(ret));
1441
1442 case TC_REFERENCE: // Some reference to object, required to be string
1443 return end_object(mode, parse_reference(ret, RawArray::CLASS_NAME));
1444
1445 case TC_ARRAY:
1446 return end_object(mode, parse_array(ret));
1447
1448 default:
1449 break;
1450 }
1451
1452 return end_object(mode, STATUS_BAD_STATE);
1453 }
1454
1455 status_t ObjectStream::read_enum(Enum **dst)
1456 {
1457 // Fetch token
1458 status_t token = lookup_token();
1459 if (token < 0)
1460 return token;
1461
1462 // Start object mode
1463 bool mode = false;
1464 status_t res = start_object(mode);
1465 if (res != STATUS_OK)
1466 return res;
1467
1468 obj_ptr_t ret(dst);
1469 switch (token)
1470 {
1471 case TC_NULL: // Null reference, valid to be string
1472 return end_object(mode, parse_null(ret));
1473
1474 case TC_REFERENCE: // Some reference to object, required to be string
1475 return end_object(mode, parse_reference(ret, Enum::CLASS_NAME));
1476
1477 case TC_ENUM:
1478 return end_object(mode, parse_enum(ret));
1479
1480 default:
1481 break;
1482 }
1483
1484 return end_object(mode, STATUS_BAD_STATE);
1485 }
1486
1487 status_t ObjectStream::read_class_descriptor(ObjectStreamClass **dst)
1488 {
1489 // Fetch token
1490 status_t token = lookup_token();
1491 if (token < 0)
1492 return token;
1493
1494 // Start object mode
1495 bool mode = false;
1496 status_t res = start_object(mode);
1497 if (res != STATUS_OK)
1498 return res;
1499
1500 obj_ptr_t ret(dst);
1501 switch (token)
1502 {
1503 case TC_NULL: // Null reference, valid to be string
1504 return end_object(mode, parse_null(ret));
1505
1506 case TC_REFERENCE: // Some reference to object, required to be string
1507 return end_object(mode, parse_reference(ret, ObjectStreamClass::CLASS_NAME));
1508
1509 case TC_CLASSDESC:
1510 return end_object(mode, parse_class_descriptor(ret));
1511
1512 case TC_PROXYCLASSDESC:
1513 return end_object(mode, parse_proxy_class_descriptor(ret));
1514
1515 default:
1516 break;
1517 }
1518
1519 return end_object(mode, STATUS_BAD_STATE);
1520 }
1521
1522 } /* namespace java */
1523 } /* namespace lsp */