Debian Codegraph @

modules/lsp-runtime-lib/src/main/protocol/osc/parse.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: 29 мая 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 #define __LSP_PROTOCOL_OSC_IMPL
23
24 #include <lsp-plug.in/common/endian.h>
25 #include <lsp-plug.in/common/debug.h>
26 #include <lsp-plug.in/protocol/osc.h>
27 #include <lsp-plug.in/stdlib/string.h>
28 #include <lsp-plug.in/stdlib/math.h>
29
30 #include <stdint.h>
31 #include <stdlib.h>
32 #include <stdarg.h>
33
34 namespace lsp
35 {
36 namespace osc
37 {
38 bool parse_check_child(parse_frame_t *child, parse_frame_t *ref)
39 {
40 if ((ref == NULL) || (child == NULL))
41 return false;
42
43 for ( ; ref != NULL; ref = ref->parent)
44 if (ref == child)
45 return false;
46
47 return true;
48 }
49
50 status_t parse_begin(parse_frame_t *ref, parser_t *parser, const void *data, size_t size)
51 {
52 if ((ref == NULL) || (parser == NULL) || (data == NULL))
53 return STATUS_BAD_ARGUMENTS;
54 if ((size < sizeof(uint32_t)) || ((size % sizeof(uint32_t)) != 0))
55 return STATUS_BAD_ARGUMENTS;
56
57 ref->parser = parser;
58 ref->parent = NULL;
59 ref->child = NULL;
60 ref->type = FRT_ROOT;
61 ref->limit = size;
62
63 parser->data = reinterpret_cast<const uint8_t *>(data);
64 parser->offset = 0;
65 parser->size = size;
66 parser->refs = 1;
67 parser->args = NULL;
68
69 return STATUS_OK;
70 }
71
72 status_t parse_token(parse_frame_t *ref, parse_token_t *token)
73 {
74 if (ref == NULL)
75 return STATUS_BAD_ARGUMENTS;
76 if ((ref->child != NULL) || (ref->parser == NULL))
77 return STATUS_BAD_STATE;
78
79 parser_t *buf = ref->parser;
80 int tok = -1;
81 ssize_t left = ref->limit - buf->offset;
82
83 switch (ref->type)
84 {
85 case FRT_ROOT:
86 case FRT_BUNDLE:
87 {
88 // End of record?
89 if (left == 0)
90 {
91 tok = PT_EOR;
92 break;
93 }
94
95 union
96 {
97 const bundle_header_t *hdr;
98 const uint32_t *u32;
99 const uint8_t *u8;
100 } xptr;
101
102 xptr.u8 = &buf->data[buf->offset];
103 size_t size = buf->size;
104
105 // End of record?
106 if (ref->type != FRT_ROOT)
107 {
108 size = BE_TO_CPU(xptr.u32[0]);
109 ++xptr.u32;
110 left -= 4;
111 }
112 else if (buf->offset > 0)
113 return STATUS_CORRUPTED;
114
115 // Check that size field is valid
116 if (size_t(left) < size)
117 return STATUS_CORRUPTED;
118
119 if ((size >= sizeof(uint32_t)) && (xptr.u8[0] == '/'))
120 tok = PT_MESSAGE;
121 else if ((size >= sizeof(bundle_header_t)) && (xptr.hdr->sig == BUNDLE_SIG))
122 tok = PT_BUNDLE;
123 break;
124 }
125
126 case FRT_MESSAGE:
127 case FRT_ARRAY:
128 if (buf->args == NULL)
129 return STATUS_BAD_STATE;
130
131 switch (*(buf->args))
132 {
133 case FPT_INT32: tok = PT_INT32; break;
134 case FPT_FLOAT32: tok = PT_FLOAT32; break;
135 case FPT_OSC_STRING: tok = PT_OSC_STRING; break;
136 case FPT_OSC_BLOB: tok = PT_OSC_BLOB; break;
137 case FPT_INT64: tok = PT_INT64; break;
138 case FPT_OSC_TIMETAG: tok = PT_OSC_TIMETAG; break;
139 case FPT_DOUBLE64: tok = PT_DOUBLE64; break;
140 case FPT_TYPE: tok = PT_TYPE; break;
141 case FPT_ASCII_CHAR: tok = PT_ASCII_CHAR; break;
142 case FPT_RGBA_COLOR: tok = PT_RGBA_COLOR; break;
143 case FPT_MIDI_MESSAGE: tok = PT_MIDI_MESSAGE; break;
144 case FPT_TRUE: tok = PT_TRUE; break;
145 case FPT_FALSE: tok = PT_FALSE; break;
146 case FPT_NULL: tok = PT_NULL; break;
147 case FPT_INF: tok = PT_INF; break;
148 case FPT_ARRAY_START: tok = PT_ARRAY; break;
149
150 case FPT_ARRAY_END:
151 if (ref->type == FRT_ARRAY)
152 tok = PT_EOR;
153 break;
154
155 case 0:
156 if ((ref->type == FRT_MESSAGE) && (left <= 0))
157 tok = PT_EOR;
158 break;
159
160 default:
161 break;
162 }
163 break;
164
165 default:
166 return STATUS_BAD_STATE;
167 }
168
169 if (tok == -1)
170 return STATUS_CORRUPTED;
171
172 if (token != NULL)
173 *token = parse_token_t(tok);
174 return STATUS_OK;
175 }
176
177 status_t parse_begin_message(parse_frame_t *child, parse_frame_t *ref, const char **address)
178 {
179 // Check state and arguments
180 if (!parse_check_child(child, ref))
181 return STATUS_BAD_ARGUMENTS;
182 if ((ref->child != NULL) || (ref->parser == NULL))
183 return STATUS_BAD_STATE;
184 if ((ref->type != FRT_ROOT) && (ref->type != FRT_BUNDLE))
185 return STATUS_BAD_STATE;
186
187 // Initialize lookup
188 union
189 {
190 const uint8_t *u8;
191 const uint32_t *u32;
192 const char *ch;
193 } xptr;
194
195 parser_t *buf = ref->parser;
196 ssize_t left = ref->limit - buf->offset;
197 size_t size = buf->size;
198 xptr.u8 = &buf->data[buf->offset];
199
200 // Need to read size?
201 if (ref->type == FRT_BUNDLE)
202 {
203 if (size_t(left) <= sizeof(uint32_t))
204 return STATUS_CORRUPTED;
205 size = BE_TO_CPU(*(xptr.u32)) + sizeof(uint32_t);
206 xptr.u8 += sizeof(uint32_t);
207
208 // Analyze size
209 if (size_t(left) < size)
210 return STATUS_CORRUPTED;
211 left -= sizeof(uint32_t);
212 }
213
214 // Is there enough size to read address?
215 if (left <= ssize_t(sizeof(uint32_t)))
216 return STATUS_CORRUPTED;
217 else if ((xptr.ch[0] != '/'))
218 return STATUS_BAD_TYPE;
219
220 // Check address length
221 const char *addr = xptr.ch;
222 size_t addr_len = ::strnlen(addr, left);
223 if (ssize_t(addr_len) >= left)
224 return STATUS_CORRUPTED;
225
226 // Estimate the padded data size and move pointer
227 size_t padded = ((addr_len + sizeof(uint32_t)) >> 2) << 2;
228 left -= padded;
229 xptr.u8 += padded;
230
231 // From OSC spec:
232 // Note: some older implementations of OSC may omit the OSC Type Tag string.
233 // Until all such implementations are updated, OSC implementations should be
234 // robust in the case of a missing OSC Type Tag String.
235 const char *args = "";
236 if (left > 0)
237 {
238 // Check that second argument is a type tag string
239 if (xptr.ch[0] != ',')
240 return STATUS_CORRUPTED;
241
242 // Ensure that type tag string is valid
243 size_t arg_len = ::strnlen(xptr.ch, left);
244 if (ssize_t(arg_len) >= left)
245 return STATUS_CORRUPTED;
246
247 args = &xptr.ch[1];
248 padded = ((arg_len + sizeof(uint32_t)) >> 2) << 2;
249 left -= padded;
250 xptr.u8 += padded;
251 }
252
253 // Store new frame data
254 child->parser = buf;
255 child->parent = ref;
256 child->child = NULL;
257 child->type = FRT_MESSAGE;
258 child->limit = buf->offset + size;
259 ref->child = child;
260
261 buf->offset = ref->limit - left;
262 buf->args = args;
263 ++ buf->refs;
264
265 if (address != NULL)
266 *address = addr;
267
268 return STATUS_OK;
269 }
270
271 status_t parse_begin_bundle(parse_frame_t *child, parse_frame_t *ref, uint64_t *time_tag)
272 {
273 // Check state and arguments
274 if (!parse_check_child(child, ref))
275 return STATUS_BAD_ARGUMENTS;
276 if ((ref->child != NULL) || (ref->parser == NULL))
277 return STATUS_BAD_STATE;
278 if ((ref->type != FRT_ROOT) && (ref->type != FRT_BUNDLE))
279 return STATUS_BAD_STATE;
280
281 // Initialize lookup
282 union
283 {
284 const uint8_t *u8;
285 const uint32_t *u32;
286 const bundle_header_t *hdr;
287 } xptr;
288
289 parser_t *buf = ref->parser;
290 ssize_t left = ref->limit - buf->offset;
291 size_t size = buf->size;
292 xptr.u8 = &buf->data[buf->offset];
293
294 // Need to read size?
295 if (ref->type == FRT_BUNDLE)
296 {
297 if (left <= ssize_t(sizeof(uint32_t)))
298 return STATUS_CORRUPTED;
299 size = BE_TO_CPU(*(xptr.u32)) + sizeof(uint32_t);
300 xptr.u8 += sizeof(uint32_t);
301
302 // Analyze size
303 if (size_t(left) < size)
304 return STATUS_CORRUPTED;
305 left -= sizeof(uint32_t);
306 }
307
308 // Is there enough size to read bundle header? Bundle header is valid
309 if (left <= ssize_t(sizeof(bundle_header_t)))
310 return STATUS_CORRUPTED;
311 else if (xptr.hdr->sig != BUNDLE_SIG)
312 return STATUS_BAD_TYPE;
313 left -= sizeof(bundle_header_t);
314
315 // Store new frame data
316 child->parser = buf;
317 child->parent = ref;
318 child->child = NULL;
319 child->type = FRT_BUNDLE;
320 child->limit = buf->offset + size;
321 ref->child = child;
322
323 buf->offset = ref->limit - left;
324 buf->args = NULL;
325 ++ buf->refs;
326
327 if (time_tag != NULL)
328 *time_tag = BE_TO_CPU(xptr.hdr->tag);
329
330 return STATUS_OK;
331 }
332
333 status_t parse_raw_message(parse_frame_t *ref, const void **start, size_t *msize, const char **address)
334 {
335 // Check state and arguments
336 if ((ref->child != NULL) || (ref->parser == NULL))
337 return STATUS_BAD_STATE;
338 if ((ref->type != FRT_ROOT) && (ref->type != FRT_BUNDLE))
339 return STATUS_BAD_STATE;
340
341 // Initialize lookup
342 union
343 {
344 const uint8_t *u8;
345 const uint32_t *u32;
346 const char *ch;
347 } xptr;
348
349 parser_t *buf = ref->parser;
350 ssize_t left = ref->limit - buf->offset;
351 size_t xsize = buf->size;
352 xptr.u8 = &buf->data[buf->offset];
353
354 // Need to read size?
355 if (ref->type == FRT_BUNDLE)
356 {
357 if (size_t(left) <= sizeof(uint32_t))
358 return STATUS_CORRUPTED;
359 xsize = BE_TO_CPU(*(xptr.u32));
360 xptr.u8 += sizeof(uint32_t);
361
362 // Analyze size
363 if (size_t(left) < (xsize + sizeof(uint32_t)))
364 return STATUS_CORRUPTED;
365 left -= sizeof(uint32_t);
366 }
367
368 // Is there enough size to read address?
369 if (left <= ssize_t(sizeof(uint32_t)))
370 return STATUS_CORRUPTED;
371 else if ((xptr.ch[0] != '/'))
372 return STATUS_BAD_TYPE;
373
374 // Check address length
375 const char *addr = xptr.ch;
376 size_t addr_len = ::strnlen(addr, left);
377 if (ssize_t(addr_len) >= left)
378 return STATUS_CORRUPTED;
379
380 // Return address string
381 if (address != NULL)
382 *address = addr;
383 if (start != NULL)
384 *start = xptr.u8;
385 if (msize != NULL)
386 *msize = xsize;
387 return STATUS_OK;
388 }
389
390 inline bool parse_check_msg(parse_frame_t *ref)
391 {
392 if ((ref->child != NULL) || (ref->parser == NULL))
393 return false;
394 if ((ref->type != FRT_ARRAY) && (ref->type != FRT_MESSAGE))
395 return false;
396 return (ref->parser->args != NULL);
397 }
398
399 status_t parse_begin_array(parse_frame_t *child, parse_frame_t *ref)
400 {
401 // Check state and arguments
402 if (!parse_check_child(child, ref))
403 return STATUS_BAD_ARGUMENTS;
404 if (!parse_check_msg(ref))
405 return STATUS_BAD_STATE;
406
407 parser_t *buf = ref->parser;
408 if (*(buf->args) != FPT_ARRAY_START)
409 return STATUS_BAD_STATE;
410
411 // Store new frame data
412 child->parser = buf;
413 child->parent = ref;
414 child->child = NULL;
415 child->type = FRT_ARRAY;
416 child->limit = ref->limit;
417 ref->child = child;
418
419 ++ buf->args;
420 ++ buf->refs;
421
422 return STATUS_OK;
423 }
424
425 status_t parse_skip(parse_frame_t *ref)
426 {
427 if ((ref->child != NULL) || (ref->parser == NULL))
428 return STATUS_BAD_STATE;
429
430 if ((ref->type == FRT_ROOT) || (ref->type == FRT_BUNDLE))
431 {
432 if (ref->parser->offset == ref->limit)
433 return STATUS_EOF;
434 else if ((ref->type == FRT_ROOT) && (ref->parser->offset > 0))
435 return STATUS_CORRUPTED;
436
437 parse_frame_t frm;
438
439 // Try to parse as message
440 status_t res = parse_begin_message(&frm, ref, NULL);
441 if (res == STATUS_OK)
442 res = parse_end(&frm);
443 else
444 {
445 // Try to parse as bundle
446 res = parse_begin_bundle(&frm, ref, NULL);
447 if (res == STATUS_OK)
448 res = parse_end(&frm);
449 }
450 return res;
451 }
452 else if ((ref->type == FRT_ARRAY) || (ref->type == FRT_MESSAGE))
453 {
454 parser_t *buf = ref->parser;
455 if (buf->args == NULL)
456 return STATUS_BAD_STATE;
457
458 size_t skip = 0;
459
460 switch (*(buf->args))
461 {
462 case FPT_INT32: skip = sizeof(int32_t); break;
463 case FPT_FLOAT32: skip = sizeof(float); break;
464 case FPT_INT64: skip = sizeof(int64_t); break;
465 case FPT_OSC_TIMETAG: skip = sizeof(uint64_t); break;
466 case FPT_DOUBLE64: skip = sizeof(double); break;
467 case FPT_ASCII_CHAR: skip = sizeof(uint32_t); break;
468 case FPT_RGBA_COLOR: skip = sizeof(uint32_t); break;
469 case FPT_MIDI_MESSAGE: skip = sizeof(uint32_t); break;
470
471 case FPT_TRUE:
472 case FPT_FALSE:
473 case FPT_NULL:
474 case FPT_INF:
475 break; // skip = 0
476
477 case FPT_OSC_STRING:
478 case FPT_TYPE:
479 {
480 ssize_t left = ref->limit - buf->offset;
481 if (left <= 0)
482 return STATUS_CORRUPTED;
483 const char *ch = reinterpret_cast<const char *>(&buf->data[buf->offset]);
484 size_t len = ::strnlen(ch, left);
485 skip = ((len + sizeof(uint32_t)) >> 2) << 2;
486 if (skip > size_t(left))
487 return STATUS_CORRUPTED;
488 break;
489 }
490
491 case FPT_OSC_BLOB:
492 {
493 ssize_t left = ref->limit - buf->offset;
494 if (left < ssize_t(sizeof(uint32_t)))
495 return STATUS_CORRUPTED;
496 const uint32_t *u32 = reinterpret_cast<const uint32_t *>(&buf->data[buf->offset]);
497 size_t size = BE_TO_CPU(*u32);
498 skip = ((size + 2*sizeof(uint32_t) - 1) >> 2) << 2;
499 if (skip > size_t(left))
500 return STATUS_CORRUPTED;
501 break;
502 }
503
504 case FPT_ARRAY_START: // Skip the entire array
505 {
506 parse_frame_t frm;
507 status_t res = parse_begin_array(&frm, ref);
508 if (res == STATUS_OK)
509 res = parse_end(&frm);
510 return res;
511 }
512
513 case FPT_ARRAY_END: // Do not allow to skip array end
514 return (ref->type == FRT_ARRAY) ? STATUS_EOF : STATUS_CORRUPTED;
515
516 case 0:
517 if ((ref->type == FRT_ARRAY) || (buf->offset != ref->limit))
518 return STATUS_CORRUPTED;
519 return STATUS_EOF;
520
521 default:
522 return STATUS_CORRUPTED;
523 }
524
525 // Update position
526 buf->offset += skip;
527 ++buf->args;
528 }
529 else
530 return STATUS_BAD_STATE;
531
532 return STATUS_OK;
533 }
534
535 template <class T>
536 inline status_t parse_int(parse_frame_t *ref, T *value, forge_param_type_t type)
537 {
538 // Check state and arguments
539 if (!parse_check_msg(ref))
540 return STATUS_BAD_STATE;
541
542 parser_t *buf = ref->parser;
543 char ch = *(buf->args);
544 if (ch == type)
545 {
546 // Parse integer value
547 if ((ref->limit - buf->offset) < sizeof(T))
548 return STATUS_CORRUPTED;
549 if (value != NULL)
550 *value = BE_TO_CPU(*(reinterpret_cast<const T *>(&buf->data[buf->offset])));
551 buf->offset += sizeof(T);
552 ++buf->args;
553 return STATUS_OK;
554 }
555
556 if (!ch)
557 return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED;
558
559 if (ch == FPT_NULL)
560 {
561 ++buf->args;
562 return STATUS_NULL;
563 }
564
565 return STATUS_BAD_TYPE;
566 }
567
568 status_t parse_int32(parse_frame_t *ref, int32_t *value)
569 {
570 return parse_int(ref, value, FPT_INT32);
571 }
572
573 status_t parse_rgba(parse_frame_t *ref, uint32_t *rgba)
574 {
575 return parse_int(ref, rgba, FPT_RGBA_COLOR);
576 }
577
578 status_t parse_int64(parse_frame_t *ref, int64_t *value)
579 {
580 return parse_int(ref, value, FPT_INT64);
581 }
582
583 status_t parse_time_tag(parse_frame_t *ref, uint64_t *value)
584 {
585 return parse_int(ref, value, FPT_OSC_TIMETAG);
586 }
587
588 status_t parse_ascii(parse_frame_t *ref, char *c)
589 {
590 // Check state and arguments
591 if (!parse_check_msg(ref))
592 return STATUS_BAD_STATE;
593
594 parser_t *buf = ref->parser;
595 char ch = *(buf->args);
596
597 if (ch == FPT_ASCII_CHAR)
598 {
599 // Parse as 32-bit value
600 if ((ref->limit - buf->offset) < sizeof(uint32_t))
601 return STATUS_CORRUPTED;
602 if (c != NULL)
603 *c = buf->data[buf->offset + 3];
604
605 buf->offset += sizeof(uint32_t);
606 ++buf->args;
607 return STATUS_OK;
608 }
609
610 if (!ch)
611 return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED;
612
613 if (ch == FPT_NULL)
614 {
615 ++buf->args;
616 return STATUS_NULL;
617 }
618
619 return STATUS_BAD_TYPE;
620 }
621
622 template <class T>
623 inline status_t parse_float(parse_frame_t *ref, T *value, forge_param_type_t type)
624 {
625 // Check state and arguments
626 if (!parse_check_msg(ref))
627 return STATUS_BAD_STATE;
628
629 parser_t *buf = ref->parser;
630 char ch = *(buf->args);
631 if (ch == type)
632 {
633 // Parse float value
634 if ((ref->limit - buf->offset) < sizeof(T))
635 return STATUS_CORRUPTED;
636 if (value != NULL)
637 *value = BE_TO_CPU(*(reinterpret_cast<const T *>(&buf->data[buf->offset])));
638 buf->offset += sizeof(T);
639 ++buf->args;
640 return STATUS_OK;
641 }
642
643 if (!ch)
644 return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED;
645
646 if (ch == FPT_NULL)
647 {
648 ++buf->args;
649 return STATUS_NULL;
650 }
651
652 if (ch == FPT_INF)
653 {
654 if (value != NULL)
655 *value = INFINITY;
656 ++buf->args;
657 return STATUS_OK;
658 }
659
660 return STATUS_BAD_TYPE;
661 }
662
663 status_t parse_float32(parse_frame_t *ref, float *value)
664 {
665 return parse_float(ref, value, FPT_FLOAT32);
666 }
667
668 status_t parse_double64(parse_frame_t *ref, double *value)
669 {
670 return parse_float(ref, value, FPT_DOUBLE64);
671 }
672
673 status_t parse_string_value(parse_frame_t *ref, const char **s, forge_param_type_t type)
674 {
675 // Check state and arguments
676 if (!parse_check_msg(ref))
677 return STATUS_BAD_STATE;
678
679 parser_t *buf = ref->parser;
680 char ch = *(buf->args);
681 if (ch == type)
682 {
683 // Perform string read
684 const char *str = reinterpret_cast<const char *>(&buf->data[buf->offset]);
685 size_t left = ref->limit - buf->offset;
686 size_t len = ::strnlen(str, left);
687
688 if (s != NULL)
689 *s = str;
690
691 buf->offset += ((len + sizeof(uint32_t)) >> 2) << 2;
692 ++buf->args;
693 return STATUS_OK;
694 }
695
696 if (!ch)
697 return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED;
698
699 if (ch == FPT_NULL)
700 {
701 ++buf->args;
702 if (s == NULL)
703 return STATUS_NULL;
704 *s = NULL;
705 return STATUS_OK;
706 }
707
708 return STATUS_BAD_TYPE;
709 }
710
711 status_t parse_string(parse_frame_t *ref, const char **s)
712 {
713 return parse_string_value(ref, s, FPT_OSC_STRING);
714 }
715
716 status_t parse_type(parse_frame_t *ref, const char **s)
717 {
718 return parse_string_value(ref, s, FPT_TYPE);
719 }
720
721 status_t parse_symbol(parse_frame_t *ref, const char **s)
722 {
723 return parse_string_value(ref, s, FPT_TYPE);
724 }
725
726 status_t parse_blob(parse_frame_t *ref, const void **data, size_t *len)
727 {
728 // Check state and arguments
729 if (!parse_check_msg(ref))
730 return STATUS_BAD_STATE;
731
732 parser_t *buf = ref->parser;
733 switch (*(buf->args))
734 {
735 case FPT_OSC_BLOB:
736 {
737 size_t left = ref->limit - buf->offset;
738 if (left < sizeof(uint32_t))
739 return STATUS_CORRUPTED;
740
741 size_t size = BE_TO_CPU(*(reinterpret_cast<const uint32_t *>(&buf->data[buf->offset])));
742 size_t skip = ((size + 2*sizeof(uint32_t) - 1) >> 2) << 2;
743 if (skip > left)
744 return STATUS_CORRUPTED;
745
746 if (data != NULL)
747 *data = &buf->data[buf->offset + sizeof(uint32_t)];
748 if (len != NULL)
749 *len = size;
750
751 buf->offset += skip;
752 ++buf->args;
753 return STATUS_OK;
754 }
755 case FPT_NULL:
756 {
757 ++buf->args;
758 if (data == NULL)
759 return STATUS_NULL;
760 *data = NULL;
761 if (len != NULL)
762 *len = 0;
763 return STATUS_OK;
764 }
765 case 0:
766 return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED;
767 default:
768 break;
769 }
770
771 return STATUS_BAD_TYPE;
772 }
773
774 inline status_t parse_flag(parse_frame_t *ref, forge_param_type_t type)
775 {
776 // Check state and arguments
777 if (!parse_check_msg(ref))
778 return STATUS_BAD_STATE;
779
780 parser_t *buf = ref->parser;
781 char ch = *(buf->args);
782 if (!ch)
783 return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED;
784 else if (ch != type)
785 return STATUS_BAD_TYPE;
786
787 ++buf->args;
788 return STATUS_OK;
789 }
790
791 status_t parse_null(parse_frame_t *ref)
792 {
793 return parse_flag(ref, FPT_NULL);
794 }
795
796 status_t parse_inf(parse_frame_t *ref)
797 {
798 return parse_flag(ref, FPT_INF);
799 }
800
801 status_t parse_bool(parse_frame_t *ref, bool *value)
802 {
803 // Check state and arguments
804 if (!parse_check_msg(ref))
805 return STATUS_BAD_STATE;
806
807 parser_t *buf = ref->parser;
808 switch (*(buf->args))
809 {
810 case FPT_TRUE:
811 ++buf->args;
812 if (value != NULL)
813 *value = true;
814 return STATUS_OK;
815 case FPT_FALSE:
816 ++buf->args;
817 if (value != NULL)
818 *value = false;
819 return STATUS_OK;
820 case FPT_NULL:
821 ++buf->args;
822 return STATUS_NULL;
823 case 0:
824 return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED;
825 default:
826 break;
827 }
828
829 return STATUS_BAD_TYPE;
830 }
831
832 status_t parse_midi(parse_frame_t *ref, midi::event_t *event)
833 {
834 // Check state and arguments
835 if (!parse_check_msg(ref))
836 return STATUS_BAD_STATE;
837
838 parser_t *buf = ref->parser;
839 switch (*(buf->args))
840 {
841 case FPT_MIDI_MESSAGE:
842 {
843 size_t left = ref->limit - buf->offset;
844 if (left < sizeof(uint32_t))
845 return STATUS_CORRUPTED;
846
847 midi::event_t ev;
848 ssize_t res = midi::decode(&ev, &buf->data[buf->offset]);
849 if (res < 0)
850 return status_t(-res);
851 if (event != NULL)
852 *event = ev;
853
854 buf->offset += sizeof(uint32_t);
855 ++buf->args;
856 return STATUS_OK;
857 }
858 case FPT_NULL:
859 ++buf->args;
860 return STATUS_NULL;
861 case 0:
862 return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED;
863 default:
864 break;
865 }
866
867 return STATUS_BAD_TYPE;
868 }
869
870 status_t parse_midi_raw(parse_frame_t *ref, const uint8_t **event, size_t *len)
871 {
872 // Check state and arguments
873 if (!parse_check_msg(ref))
874 return STATUS_BAD_STATE;
875
876 parser_t *buf = ref->parser;
877 switch (*(buf->args))
878 {
879 case FPT_MIDI_MESSAGE:
880 {
881 size_t left = ref->limit - buf->offset;
882 if (left < sizeof(uint32_t))
883 return STATUS_CORRUPTED;
884
885 midi::event_t ev;
886 ssize_t res = midi::decode(&ev, &buf->data[buf->offset]);
887 if (res < 0)
888 return status_t(-res);
889 if (event != NULL)
890 *event = &buf->data[buf->offset];
891 if (len != NULL)
892 *len = res;
893
894 buf->offset += sizeof(uint32_t);
895 ++buf->args;
896 return STATUS_OK;
897 }
898 case FPT_NULL:
899 ++buf->args;
900 return STATUS_NULL;
901 case 0:
902 return (buf->offset == ref->limit) ? STATUS_EOF : STATUS_CORRUPTED;
903 default:
904 break;
905 }
906
907 return STATUS_BAD_TYPE;
908 }
909
910 status_t parse_end(parse_frame_t *ref)
911 {
912 if (ref == NULL)
913 return STATUS_BAD_ARGUMENTS;
914 if (ref->child != NULL)
915 return STATUS_BAD_STATE;
916
917 parser_t *buf = ref->parser;
918 if (buf == NULL)
919 return STATUS_BAD_STATE;
920
921 status_t res = STATUS_OK;
922 switch (ref->type)
923 {
924 case FRT_ROOT:
925 if (buf->refs <= 0)
926 return STATUS_BAD_STATE;
927 --buf->refs;
928 return STATUS_OK;
929
930 case FRT_ARRAY:
931 if ((ref->parent == NULL) || (buf->args == NULL))
932 return STATUS_BAD_STATE;
933 while (*(buf->args) != FPT_ARRAY_END)
934 {
935 res = parse_skip(ref);
936 if (res != STATUS_OK)
937 return (res == STATUS_EOF) ? STATUS_CORRUPTED : res;
938 }
939 --buf->refs;
940 ++buf->args;
941 break;
942
943 case FRT_BUNDLE:
944 case FRT_MESSAGE:
945 if (ref->parent == NULL)
946 return STATUS_BAD_STATE;
947 else if (buf->offset > ref->limit)
948 return STATUS_CORRUPTED;
949
950 buf->offset = ref->limit;
951 --buf->refs;
952 break;
953
954 default:
955 return STATUS_CORRUPTED;
956 }
957
958 // Unlink frame
959 ref->parent->child = NULL;
960 ref->parser = NULL;
961 ref->parent = NULL;
962 ref->type = FRT_UNKNOWN;
963 ref->limit = buf->size;
964
965 return res;
966 }
967
968 status_t parse_destroy(parser_t *parser)
969 {
970 if (parser == NULL)
971 return STATUS_BAD_ARGUMENTS;
972
973 parser->data = NULL;
974 parser->offset = 0;
975 parser->size = 0;
976 parser->refs = 0;
977 parser->args = NULL;
978
979 return STATUS_OK;
980 }
981
982 status_t parse_message(parse_frame_t *ref, const char *params, const char **address...)
983 {
984 va_list args;
985 va_start(args, address);
986 status_t res = parse_messagev(ref, params, address, args);
987 va_end(args);
988 return res;
989 }
990
991 status_t parse_messagev(parse_frame_t *ref, const char *params, const char **address, va_list args)
992 {
993 parse_frame_t message;
994 status_t res = parse_begin_message(&message, ref, address);
995 if (res != STATUS_OK)
996 return res;
997
998 ssize_t recursive = 0;
999
1000 if (params != NULL)
1001 {
1002 for (const char *fmt=params; *fmt != '\0'; ++fmt)
1003 {
1004 switch (*fmt)
1005 {
1006 case FPT_INT32:
1007 res = parse_int32(&message, va_arg(args, int32_t *));
1008 break;
1009 case FPT_FLOAT32:
1010 res = parse_float32(&message, va_arg(args, float *));
1011 break;
1012 case FPT_OSC_STRING:
1013 res = parse_string(&message, va_arg(args, const char **));
1014 break;
1015 case FPT_INT64:
1016 res = parse_int64(&message, va_arg(args, int64_t *));
1017 break;
1018 case FPT_OSC_TIMETAG:
1019 res = parse_time_tag(&message, va_arg(args, uint64_t *));
1020 break;
1021 case FPT_DOUBLE64:
1022 res = parse_double64(&message, va_arg(args, double *));
1023 break;
1024 case FPT_TYPE:
1025 res = parse_type(&message, va_arg(args, const char **));
1026 break;
1027 case FPT_ASCII_CHAR:
1028 res = parse_ascii(&message, va_arg(args, char *));
1029 break;
1030 case FPT_RGBA_COLOR:
1031 res = parse_rgba(&message, va_arg(args, uint32_t *));
1032 break;
1033 case FPT_TRUE:
1034 case FPT_FALSE:
1035 res = parse_bool(&message, va_arg(args, bool *));
1036 break;
1037
1038 case FPT_ARRAY_START:
1039 if (message.parser->args[0] == FPT_ARRAY_START)
1040 {
1041 ++recursive;
1042 ++message.parser->args;
1043 }
1044 else
1045 res = STATUS_BAD_TYPE;
1046
1047 break;
1048 case FPT_ARRAY_END:
1049 if (message.parser->args[0] == FPT_ARRAY_START)
1050 {
1051 if (--recursive < 0)
1052 res = STATUS_BAD_FORMAT;
1053 else
1054 ++ message.parser->args;
1055 }
1056 else
1057 res = STATUS_BAD_TYPE;
1058 break;
1059
1060 case FPT_OSC_BLOB:
1061 {
1062 size_t *size = va_arg(args, size_t *);
1063 const void **ptr = va_arg(args, const void **);
1064 res = parse_blob(&message, ptr, size);
1065 break;
1066 }
1067
1068 case FPT_MIDI_MESSAGE:
1069 res = STATUS_NOT_SUPPORTED;
1070 break;
1071
1072 default:
1073 res = STATUS_BAD_FORMAT;
1074 break;
1075 }
1076
1077 if (res == STATUS_NULL)
1078 res = STATUS_OK;
1079 else if (res != STATUS_OK)
1080 break;
1081 }
1082 }
1083
1084 if ((res == STATUS_OK) && (recursive != 0))
1085 res = STATUS_BAD_FORMAT;
1086
1087 if (res == STATUS_OK)
1088 res = parse_end(&message);
1089 else
1090 parse_end(&message);
1091
1092 return res;
1093 }
1094
1095 } /* namespace osc */
1096 } /* namespace lsp */
1097