pbwire 0.1.17 → 0.1.18

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,1459 @@
1
+ /* Descriptor model: schema registry, field metadata, name resolution, lookup
2
+ * tables. */
3
+
4
+ #include "internal.h"
5
+
6
+ #include <stdio.h>
7
+
8
+ /* FNV-1a 32-bit for field names: one multiply-xor per byte, good enough for
9
+ * a few dozen keys and branch-free to compute. */
10
+ static uint32_t
11
+ name_hash(const char *s)
12
+ {
13
+ uint32_t h = 2166136261u;
14
+
15
+ while (*s) {
16
+ h ^= (uint8_t)*s++;
17
+ h *= 16777619u;
18
+ }
19
+ return h;
20
+ }
21
+
22
+ static char *
23
+ dup_str(const char *s)
24
+ {
25
+ size_t len;
26
+ char *copy;
27
+
28
+ if (s == NULL) {
29
+ return NULL;
30
+ }
31
+ len = strlen(s);
32
+ if (len == SIZE_MAX) {
33
+ return NULL;
34
+ }
35
+ copy = (char *)malloc(len + 1);
36
+ if (copy == NULL) {
37
+ return NULL;
38
+ }
39
+ memcpy(copy, s, len + 1);
40
+ return copy;
41
+ }
42
+
43
+ /* Drops the schema-wide name index; pbw_schema_find() then scans descs. */
44
+ static void
45
+ name_index_drop(pbw_schema *schema)
46
+ {
47
+ free(schema->name_index);
48
+ schema->name_index = NULL;
49
+ schema->name_index_size = 0;
50
+ schema->name_index_count = 0;
51
+ }
52
+
53
+ /* Builds the index over every descriptor added so far (doubling amortizes the
54
+ * rebuilds, so loading stays linear). 0 on allocation failure. */
55
+ static int
56
+ name_index_build(pbw_schema *schema, size_t want)
57
+ {
58
+ pbw_descriptor **index;
59
+ size_t i;
60
+
61
+ if (want < 16) {
62
+ want = 16;
63
+ }
64
+ while (want < schema->count * 2) {
65
+ if (want > SIZE_MAX / 2) {
66
+ return 0;
67
+ }
68
+ want *= 2;
69
+ }
70
+ if (want > SIZE_MAX / sizeof(*index)) {
71
+ return 0;
72
+ }
73
+ index = (pbw_descriptor **)calloc(want, sizeof(*index));
74
+ if (index == NULL) {
75
+ return 0;
76
+ }
77
+ for (i = 0; i < schema->count; i++) {
78
+ size_t slot =
79
+ (size_t)(name_hash(schema->descs[i]->name) & (uint32_t)(want - 1));
80
+
81
+ while (index[slot] != NULL) {
82
+ slot = (slot + 1) & (want - 1);
83
+ }
84
+ index[slot] = schema->descs[i];
85
+ }
86
+ free(schema->name_index);
87
+ schema->name_index = index;
88
+ schema->name_index_size = want;
89
+ schema->name_index_count = schema->count;
90
+ return 1;
91
+ }
92
+
93
+ /* Indexes the descriptor just appended. Losing the index is not an error:
94
+ * lookups fall back to the scan, so the schema stays correct. */
95
+ static void
96
+ name_index_add(pbw_schema *schema, pbw_descriptor *desc)
97
+ {
98
+ size_t mask;
99
+ size_t slot;
100
+
101
+ if (schema->name_index_size == 0 ||
102
+ (schema->name_index_count + 1) * 2 > schema->name_index_size) {
103
+ if (!name_index_build(schema, schema->name_index_size
104
+ ? schema->name_index_size * 2
105
+ : 16)) {
106
+ name_index_drop(schema);
107
+ }
108
+ return; /* the rebuild already holds this descriptor */
109
+ }
110
+ mask = schema->name_index_size - 1;
111
+ slot = (size_t)(name_hash(desc->name) & (uint32_t)mask);
112
+ while (schema->name_index[slot] != NULL) {
113
+ slot = (slot + 1) & mask;
114
+ }
115
+ schema->name_index[slot] = desc;
116
+ schema->name_index_count++;
117
+ }
118
+
119
+ void
120
+ pbw_descriptor_free(pbw_descriptor *desc)
121
+ {
122
+ size_t i;
123
+
124
+ if (desc == NULL) {
125
+ return;
126
+ }
127
+ for (i = 0; i < desc->field_count; i++) {
128
+ free(desc->fields[i].name);
129
+ free(desc->fields[i].full_name);
130
+ free(desc->fields[i].type_name);
131
+ free(desc->fields[i].default_value);
132
+ }
133
+ free(desc->fields);
134
+ for (i = 0; i < desc->enum_count; i++) {
135
+ free(desc->enum_values[i].name);
136
+ }
137
+ free(desc->enum_values);
138
+ free(desc->add_nums);
139
+ free(desc->add_names);
140
+ free(desc->fnum_map);
141
+ free(desc->tag_map);
142
+ free((void *)desc->name_map);
143
+ for (i = 0; i < desc->reserved_count; i++) {
144
+ free(desc->reserved[i]);
145
+ }
146
+ free(desc->reserved);
147
+ free(desc->name);
148
+ free(desc);
149
+ }
150
+
151
+ pbw_schema *
152
+ pbw_schema_new(void)
153
+ {
154
+ pbw_schema *schema = (pbw_schema *)calloc(1, sizeof(pbw_schema));
155
+
156
+ /* Hand-built schemas default to proto3 semantics, which is what this API
157
+ * did before a dialect could be chosen. */
158
+ if (schema != NULL) {
159
+ schema->proto3 = 1;
160
+ }
161
+ return schema;
162
+ }
163
+
164
+ void
165
+ pbw_schema_set_proto3(pbw_schema *schema, int proto3)
166
+ {
167
+ if (schema != NULL) {
168
+ schema->proto3 = proto3 != 0;
169
+ }
170
+ }
171
+
172
+ void
173
+ pbw_schema_free(pbw_schema *schema)
174
+ {
175
+ size_t i;
176
+
177
+ if (schema == NULL) {
178
+ return;
179
+ }
180
+ for (i = 0; i < schema->count; i++) {
181
+ pbw_descriptor_free(schema->descs[i]);
182
+ }
183
+ free(schema->descs);
184
+ free(schema->name_index);
185
+ for (i = 0; i < schema->service_count; i++) {
186
+ pbw_service *svc = schema->services[i];
187
+ size_t m;
188
+
189
+ if (svc == NULL) {
190
+ continue;
191
+ }
192
+ for (m = 0; m < svc->method_count; m++) {
193
+ free(svc->methods[m].name);
194
+ free(svc->methods[m].input_type);
195
+ free(svc->methods[m].output_type);
196
+ }
197
+ free(svc->methods);
198
+ free(svc->name);
199
+ free(svc);
200
+ }
201
+ free(schema->services);
202
+ free(schema);
203
+ }
204
+
205
+ static pbw_descriptor *
206
+ add_descriptor(pbw_schema *schema, const char *name,
207
+ int is_enum)
208
+ {
209
+ pbw_descriptor *desc;
210
+ pbw_descriptor **descs;
211
+
212
+ if (schema == NULL || name == NULL || pbw_schema_find(schema, name) != NULL) {
213
+ return NULL;
214
+ }
215
+ if (schema->count == schema->cap) {
216
+ size_t cap = schema->cap ? schema->cap * 2 : 8;
217
+ size_t bytes;
218
+
219
+ if (schema->cap > SIZE_MAX / 2) {
220
+ return NULL;
221
+ }
222
+ if (cap > SIZE_MAX / sizeof(*descs)) {
223
+ return NULL;
224
+ }
225
+ bytes = cap * sizeof(*descs);
226
+ descs = (pbw_descriptor **)realloc(schema->descs, bytes);
227
+ if (descs == NULL) {
228
+ return NULL;
229
+ }
230
+ schema->descs = descs;
231
+ schema->cap = cap;
232
+ }
233
+ desc = (pbw_descriptor *)calloc(1, sizeof(*desc));
234
+ if (desc == NULL) {
235
+ return NULL;
236
+ }
237
+ desc->name = dup_str(name);
238
+ if (desc->name == NULL) {
239
+ free(desc);
240
+ return NULL;
241
+ }
242
+ desc->is_enum = is_enum;
243
+ desc->proto3 = schema->proto3;
244
+ desc->edition = schema->edition;
245
+ desc->schema = schema;
246
+ schema->descs[schema->count++] = desc;
247
+ name_index_add(schema, desc);
248
+ schema->linked = 0;
249
+ return desc;
250
+ }
251
+
252
+ pbw_descriptor *
253
+ pbw_schema_add_message(pbw_schema *schema, const char *name)
254
+ {
255
+ return add_descriptor(schema, name, 0);
256
+ }
257
+
258
+ pbw_descriptor *
259
+ pbw_schema_add_enum(pbw_schema *schema, const char *name)
260
+ {
261
+ return add_descriptor(schema, name, 1);
262
+ }
263
+
264
+ pbw_descriptor *
265
+ pbw_schema_find(const pbw_schema *schema, const char *name)
266
+ {
267
+ size_t i;
268
+
269
+ if (schema == NULL || name == NULL) {
270
+ return NULL;
271
+ }
272
+ if (schema->name_index != NULL) {
273
+ size_t mask = schema->name_index_size - 1;
274
+ size_t slot = (size_t)(name_hash(name) & (uint32_t)mask);
275
+
276
+ for (;;) {
277
+ pbw_descriptor *desc = schema->name_index[slot];
278
+
279
+ if (desc == NULL) {
280
+ return NULL;
281
+ }
282
+ if (strcmp(desc->name, name) == 0) {
283
+ return desc;
284
+ }
285
+ slot = (slot + 1) & mask;
286
+ }
287
+ }
288
+ for (i = 0; i < schema->count; i++) {
289
+ if (strcmp(schema->descs[i]->name, name) == 0) {
290
+ return schema->descs[i];
291
+ }
292
+ }
293
+ return NULL;
294
+ }
295
+
296
+ pbw_status
297
+ pbw_enum_add_value(pbw_descriptor *enum_desc, const char *name,
298
+ int32_t number)
299
+ {
300
+ struct pbw_enum_value *values;
301
+ char *copy;
302
+ size_t bytes;
303
+ size_t i;
304
+
305
+ if (enum_desc == NULL || !enum_desc->is_enum || name == NULL) {
306
+ return PBW_ERR_INVALID;
307
+ }
308
+ if (enum_desc->schema != NULL && enum_desc->schema->frozen) {
309
+ return PBW_ERR_INVALID;
310
+ }
311
+ for (i = 0; i < enum_desc->enum_count; i++) {
312
+ if (strcmp(enum_desc->enum_values[i].name, name) == 0) {
313
+ /* Numbers may alias (allow_alias); names may not. */
314
+ return PBW_ERR_INVALID;
315
+ }
316
+ }
317
+ if (enum_desc->enum_count == SIZE_MAX) {
318
+ return PBW_ERR_NOMEM;
319
+ }
320
+ if ((enum_desc->enum_count + 1) > SIZE_MAX / sizeof(*values)) {
321
+ return PBW_ERR_NOMEM;
322
+ }
323
+ copy = dup_str(name);
324
+ if (copy == NULL) {
325
+ return PBW_ERR_NOMEM;
326
+ }
327
+ bytes = (enum_desc->enum_count + 1) * sizeof(*values);
328
+ values = (struct pbw_enum_value *)realloc(enum_desc->enum_values, bytes);
329
+ if (values == NULL) {
330
+ free(copy);
331
+ return PBW_ERR_NOMEM;
332
+ }
333
+ enum_desc->enum_values = values;
334
+ values[enum_desc->enum_count].name = copy;
335
+ values[enum_desc->enum_count].number = number;
336
+ enum_desc->enum_count++;
337
+ if (enum_desc->schema != NULL) {
338
+ enum_desc->schema->linked = 0;
339
+ }
340
+ return PBW_OK;
341
+ }
342
+
343
+ int
344
+ pbw_enum_find_name(const pbw_descriptor *enum_desc, int32_t number,
345
+ const char **name)
346
+ {
347
+ size_t i;
348
+
349
+ if (enum_desc == NULL || !enum_desc->is_enum) {
350
+ return 0;
351
+ }
352
+ for (i = 0; i < enum_desc->enum_count; i++) {
353
+ if (enum_desc->enum_values[i].number == number) {
354
+ if (name != NULL) {
355
+ *name = enum_desc->enum_values[i].name;
356
+ }
357
+ return 1;
358
+ }
359
+ }
360
+ return 0;
361
+ }
362
+
363
+ int
364
+ pbw_enum_find_value(const pbw_descriptor *enum_desc, const char *name,
365
+ int32_t *number)
366
+ {
367
+ size_t i;
368
+
369
+ if (enum_desc == NULL || !enum_desc->is_enum || name == NULL) {
370
+ return 0;
371
+ }
372
+ for (i = 0; i < enum_desc->enum_count; i++) {
373
+ if (strcmp(enum_desc->enum_values[i].name, name) == 0) {
374
+ if (number != NULL) {
375
+ *number = enum_desc->enum_values[i].number;
376
+ }
377
+ return 1;
378
+ }
379
+ }
380
+ return 0;
381
+ }
382
+
383
+ /* ---------------------------------------------------- add-time dup index */
384
+
385
+ /* Number key: multiplicative hash, folded into the table size. */
386
+ static size_t
387
+ add_num_slot(size_t size, uint32_t number)
388
+ {
389
+ return (size_t)((number * 2654435761u) & (uint32_t)(size - 1));
390
+ }
391
+
392
+ static void
393
+ add_index_drop(pbw_descriptor *msg)
394
+ {
395
+ free(msg->add_nums);
396
+ free(msg->add_names);
397
+ msg->add_nums = NULL;
398
+ msg->add_names = NULL;
399
+ msg->add_size = 0;
400
+ }
401
+
402
+ /* Drops the tables derived from the row layout of `fields`: name_map holds
403
+ * pointers into it, fnum_map/tag_map index its rows, and the add-time index
404
+ * stores row numbers. Growing the array can move it and a link sorts it, so
405
+ * both invalidate these. Only reachable after a *failed* link (a successful
406
+ * one freezes the descriptor), but a stale pointer there is a use-after-free. */
407
+ static void
408
+ row_tables_drop(pbw_descriptor *msg)
409
+ {
410
+ free(msg->fnum_map);
411
+ msg->fnum_map = NULL;
412
+ msg->fnum_map_size = 0;
413
+ free(msg->tag_map);
414
+ msg->tag_map = NULL;
415
+ free((void *)msg->name_map);
416
+ msg->name_map = NULL;
417
+ msg->name_map_size = 0;
418
+ }
419
+
420
+ /* Indexes (or re-indexes) every field added so far at `want` slots. The caller
421
+ * keeps the row it is about to add out of this call and inserts it itself. */
422
+ static int
423
+ add_index_build(pbw_descriptor *msg, size_t want)
424
+ {
425
+ uint32_t *nums;
426
+ uint32_t *names;
427
+ size_t i;
428
+
429
+ if (want < 16) {
430
+ want = 16;
431
+ }
432
+ while (want < msg->field_count * 2) {
433
+ if (want > SIZE_MAX / 2) {
434
+ return 0;
435
+ }
436
+ want *= 2;
437
+ }
438
+ nums = (uint32_t *)calloc(want, sizeof(*nums));
439
+ names = (uint32_t *)calloc(want, sizeof(*names));
440
+ if (nums == NULL || names == NULL) {
441
+ free(nums);
442
+ free(names);
443
+ return 0;
444
+ }
445
+ add_index_drop(msg);
446
+ msg->add_nums = nums;
447
+ msg->add_names = names;
448
+ msg->add_size = want;
449
+ for (i = 0; i < msg->field_count; i++) {
450
+ const pbw_field *f = &msg->fields[i];
451
+ size_t slot = add_num_slot(want, f->number);
452
+
453
+ while (nums[slot] != 0) {
454
+ slot = (slot + 1) & (want - 1);
455
+ }
456
+ nums[slot] = (uint32_t)i + 1;
457
+ if (!f->is_extension) {
458
+ slot = (size_t)(name_hash(f->name) & (uint32_t)(want - 1));
459
+ while (names[slot] != 0) {
460
+ slot = (slot + 1) & (want - 1);
461
+ }
462
+ names[slot] = (uint32_t)i + 1;
463
+ }
464
+ }
465
+ return 1;
466
+ }
467
+
468
+ /* Indexes the row that add_field() just appended, growing the table first when
469
+ * it is half full. Failure drops the index (the scan covers the next adds). */
470
+ static void
471
+ add_index_add_row(pbw_descriptor *msg)
472
+ {
473
+ const pbw_field *f = &msg->fields[msg->field_count - 1];
474
+ size_t size;
475
+ size_t slot;
476
+
477
+ if (msg->add_nums == NULL || msg->field_count * 2 >= msg->add_size) {
478
+ if (!add_index_build(msg, msg->add_size != 0 ? msg->add_size * 2 : 16)) {
479
+ add_index_drop(msg);
480
+ return;
481
+ }
482
+ /* The rebuild already indexed this row. */
483
+ return;
484
+ }
485
+ size = msg->add_size;
486
+ slot = add_num_slot(size, f->number);
487
+ while (msg->add_nums[slot] != 0) {
488
+ slot = (slot + 1) & (size - 1);
489
+ }
490
+ msg->add_nums[slot] = (uint32_t)msg->field_count;
491
+ if (!f->is_extension) {
492
+ slot = (size_t)(name_hash(f->name) & (uint32_t)(size - 1));
493
+ while (msg->add_names[slot] != 0) {
494
+ slot = (slot + 1) & (size - 1);
495
+ }
496
+ msg->add_names[slot] = (uint32_t)msg->field_count;
497
+ }
498
+ }
499
+
500
+ static int
501
+ add_has_number(const pbw_descriptor *msg, uint32_t number)
502
+ {
503
+ size_t slot = add_num_slot(msg->add_size, number);
504
+
505
+ while (msg->add_nums[slot] != 0) {
506
+ if (msg->fields[msg->add_nums[slot] - 1].number == number) {
507
+ return 1;
508
+ }
509
+ slot = (slot + 1) & (msg->add_size - 1);
510
+ }
511
+ return 0;
512
+ }
513
+
514
+ static int
515
+ add_has_name(const pbw_descriptor *msg, const char *name)
516
+ {
517
+ size_t slot = (size_t)(name_hash(name) & (uint32_t)(msg->add_size - 1));
518
+
519
+ while (msg->add_names[slot] != 0) {
520
+ const pbw_field *f = &msg->fields[msg->add_names[slot] - 1];
521
+
522
+ if (strcmp(f->name, name) == 0) {
523
+ return 1;
524
+ }
525
+ slot = (slot + 1) & (msg->add_size - 1);
526
+ }
527
+ return 0;
528
+ }
529
+
530
+ static pbw_field *
531
+ add_field(pbw_descriptor *msg, const char *name, uint32_t number, pbw_type type,
532
+ pbw_label label, int is_extension)
533
+ {
534
+ pbw_field *fields;
535
+ pbw_field *field;
536
+ size_t i;
537
+
538
+ if (msg == NULL || msg->is_enum || name == NULL) {
539
+ return NULL;
540
+ }
541
+ if (msg->schema != NULL && msg->schema->frozen) {
542
+ /* Growing field_count after a message exists would put that message's
543
+ * value slots out of sync with the descriptor, so the layout freezes at
544
+ * the first successful link. */
545
+ snprintf(msg->schema->error, sizeof(msg->schema->error),
546
+ "add field %s.%s before pbw_schema_link()", msg->name, name);
547
+ return NULL;
548
+ }
549
+ if (number == 0 || number > PBW_MAX_FIELD_NUMBER) {
550
+ return NULL;
551
+ }
552
+ if (type < PBW_TYPE_DOUBLE || type > PBW_TYPE_SINT64 ||
553
+ label < PBW_LABEL_OPTIONAL || label > PBW_LABEL_REPEATED) {
554
+ return NULL;
555
+ }
556
+ if (msg->field_count == SIZE_MAX ||
557
+ (msg->field_count + 1) > SIZE_MAX / sizeof(*fields)) {
558
+ return NULL;
559
+ }
560
+ /* Extensions from different scopes may share a name; only the number
561
+ * identifies one. Regular fields keep the name check too. */
562
+ if (msg->add_size != 0) {
563
+ if (add_has_number(msg, number) ||
564
+ (!is_extension && add_has_name(msg, name))) {
565
+ return NULL;
566
+ }
567
+ } else {
568
+ /* No index (an allocation failed earlier): the linear scan is
569
+ * correct, just quadratic for a very wide message. */
570
+ for (i = 0; i < msg->field_count; i++) {
571
+ if (msg->fields[i].number == number ||
572
+ (!is_extension && strcmp(msg->fields[i].name, name) == 0)) {
573
+ return NULL;
574
+ }
575
+ }
576
+ }
577
+ /* A row is about to be added, so the tables derived from the row layout
578
+ * are stale from here on: name_map holds pointers into the array, and
579
+ * fnum_map/tag_map index its rows. Drop them before the growth block,
580
+ * because a grow that moves the array followed by a failed name
581
+ * allocation returns from below with the old tables already dangling; a
582
+ * grow that does not move it still leaves the new row out of name_map. */
583
+ row_tables_drop(msg);
584
+ /* Geometric growth: doubling keeps one wide message linear in its field
585
+ * count, where a realloc per field was quadratic (8000 fields: 61 ms of
586
+ * memmove for 16 ms of work, measured). */
587
+ if (msg->field_count == msg->fields_cap) {
588
+ size_t cap = msg->fields_cap == 0 ? 8 : msg->fields_cap * 2;
589
+
590
+ if (cap < msg->fields_cap || cap > SIZE_MAX / sizeof(*fields)) {
591
+ return NULL;
592
+ }
593
+ fields = (pbw_field *)realloc(msg->fields, cap * sizeof(*fields));
594
+ if (fields == NULL) {
595
+ return NULL;
596
+ }
597
+ msg->fields = fields;
598
+ msg->fields_cap = cap;
599
+ }
600
+ field = &msg->fields[msg->field_count];
601
+ memset(field, 0, sizeof(*field));
602
+ field->name = dup_str(name);
603
+ if (field->name == NULL) {
604
+ return NULL;
605
+ }
606
+ field->schema = msg->schema;
607
+ field->number = number;
608
+ field->type = type;
609
+ field->label = label;
610
+ field->is_extension = is_extension ? 1u : 0u;
611
+ /* Hand-built schemas follow the dialect: a proto3 schema validates its
612
+ * string fields on decode, proto2 does not (see pbw_field_utf8_*). The
613
+ * descriptor-set loader overwrites this per field from the FeatureSet. */
614
+ field->utf8_check =
615
+ (uint8_t)(type == PBW_TYPE_STRING && msg->schema != NULL &&
616
+ msg->schema->proto3);
617
+ msg->field_count++;
618
+ msg->epoch++;
619
+ add_index_add_row(msg);
620
+ if (msg->schema != NULL) {
621
+ msg->schema->linked = 0;
622
+ }
623
+ return field;
624
+ }
625
+
626
+ pbw_field *
627
+ pbw_message_add_field(pbw_descriptor *msg, const char *name,
628
+ uint32_t number, pbw_type type,
629
+ pbw_label label)
630
+ {
631
+ return add_field(msg, name, number, type, label, 0);
632
+ }
633
+
634
+ pbw_field *
635
+ pbw_message_add_extension(pbw_descriptor *msg, const char *name,
636
+ uint32_t number, pbw_type type, pbw_label label)
637
+ {
638
+ return add_field(msg, name, number, type, label, 1);
639
+ }
640
+
641
+ void
642
+ pbw_field_set_type_name(pbw_field *field, const char *type_name)
643
+ {
644
+ char *copy;
645
+
646
+ if (field == NULL) {
647
+ return;
648
+ }
649
+ copy = dup_str(type_name);
650
+ if (type_name != NULL && copy == NULL) {
651
+ return;
652
+ }
653
+ free(field->type_name);
654
+ field->type_name = copy;
655
+ field->sub = NULL;
656
+ if (field->schema != NULL) {
657
+ field->schema->linked = 0;
658
+ }
659
+ }
660
+
661
+ void
662
+ pbw_descriptor_set_map_entry(pbw_descriptor *msg)
663
+ {
664
+ if (msg == NULL || msg->is_enum) {
665
+ return;
666
+ }
667
+ msg->map_entry = 1;
668
+ if (msg->schema != NULL) {
669
+ msg->schema->linked = 0;
670
+ }
671
+ }
672
+
673
+ void
674
+ pbw_field_set_full_name(pbw_field *field, const char *full_name)
675
+ {
676
+ char *copy;
677
+
678
+ if (field == NULL) {
679
+ return;
680
+ }
681
+ copy = dup_str(full_name);
682
+ if (full_name != NULL && copy == NULL) {
683
+ return;
684
+ }
685
+ free(field->full_name);
686
+ field->full_name = copy;
687
+ if (field->schema != NULL) {
688
+ field->schema->linked = 0;
689
+ }
690
+ }
691
+
692
+ void
693
+ pbw_field_set_packed(pbw_field *field, int packed)
694
+ {
695
+ if (field != NULL) {
696
+ field->packed = packed ? 1u : 0u;
697
+ if (field->schema != NULL) {
698
+ field->schema->linked = 0;
699
+ }
700
+ }
701
+ }
702
+
703
+ void
704
+ pbw_field_set_oneof(pbw_field *field, uint32_t oneof_index)
705
+ {
706
+ if (field == NULL) {
707
+ return;
708
+ }
709
+ if (field->schema != NULL && field->schema->frozen) {
710
+ /* Growing oneof_count after a link would leave existing messages
711
+ * with a oneof_case array shorter than the index they use. */
712
+ return;
713
+ }
714
+ field->oneof_index = oneof_index;
715
+ if (field->schema != NULL) {
716
+ pbw_schema *schema = field->schema;
717
+ size_t i;
718
+
719
+ schema->linked = 0;
720
+ /* The oneof_case table sizes from the max index at message creation:
721
+ * retire existing messages so a later set cannot index past it. */
722
+ for (i = 0; i < schema->count; i++) {
723
+ pbw_descriptor *desc = schema->descs[i];
724
+
725
+ if (!desc->is_enum && field >= desc->fields &&
726
+ field < desc->fields + desc->field_count) {
727
+ desc->epoch++;
728
+ break;
729
+ }
730
+ }
731
+ }
732
+ }
733
+
734
+ static int
735
+ compare_fields(const void *a, const void *b)
736
+ {
737
+ const pbw_field *fa = (const pbw_field *)a;
738
+ const pbw_field *fb = (const pbw_field *)b;
739
+
740
+ if (fa->number < fb->number) {
741
+ return -1;
742
+ }
743
+ return fa->number > fb->number ? 1 : 0;
744
+ }
745
+
746
+ /* Precomputes the wire bytes of a field's tag, so neither the encoder nor the
747
+ * decoder has to format or compare one again. */
748
+ static void
749
+ link_field_tags(pbw_field *field)
750
+ {
751
+ /* Editions message_encoding = DELIMITED: a MESSAGE field travels as
752
+ * group tags, so the tag bytes (and the decoder dispatch built on
753
+ * them) use the group wire type. Everything else keeps its type's. */
754
+ field->wire_type = (uint8_t)((field->type == PBW_TYPE_MESSAGE &&
755
+ field->msg_enc == 2)
756
+ ? PBW_WIRE_START_GROUP
757
+ : pbw_expected_wire_type(field->type));
758
+ field->tag_len =
759
+ (uint8_t)pbw_varint_write(field->tag, ((uint64_t)field->number << 3) |
760
+ field->wire_type);
761
+ field->len_tag_len = (uint8_t)pbw_varint_write(
762
+ field->len_tag, ((uint64_t)field->number << 3) | PBW_WIRE_LEN);
763
+ field->tag_word = pbw_read_le32(field->tag);
764
+ field->len_tag_word = pbw_read_le32(field->len_tag);
765
+ }
766
+
767
+ static pbw_status
768
+ link_message(pbw_schema *schema, pbw_descriptor *msg)
769
+ {
770
+ size_t i;
771
+ uint32_t max_fnum = 0;
772
+
773
+ for (i = 0; i < msg->field_count; i++) {
774
+ pbw_field *field = &msg->fields[i];
775
+
776
+ if (field->number == 0 || field->number > PBW_MAX_FIELD_NUMBER ||
777
+ field->type < PBW_TYPE_DOUBLE ||
778
+ field->type > PBW_TYPE_SINT64 ||
779
+ field->label < PBW_LABEL_OPTIONAL ||
780
+ field->label > PBW_LABEL_REPEATED ||
781
+ field->name == NULL) {
782
+ snprintf(schema->error, sizeof(schema->error),
783
+ "invalid field %s.#%zu", msg->name, i);
784
+ return PBW_ERR_INVALID;
785
+ }
786
+ if (field->oneof_index > msg->field_count + 1) {
787
+ snprintf(schema->error, sizeof(schema->error),
788
+ "oneof index %u out of range in %s.%s",
789
+ field->oneof_index, msg->name, field->name);
790
+ return PBW_ERR_INVALID;
791
+ }
792
+ if (field->oneof_index != 0 && field->label == PBW_LABEL_REPEATED) {
793
+ /* The store path never clears a sibling for a repeated field,
794
+ * so two members would stay present and encode together. */
795
+ snprintf(schema->error, sizeof(schema->error),
796
+ "repeated field %s.%s cannot be in a oneof", msg->name,
797
+ field->name);
798
+ return PBW_ERR_INVALID;
799
+ }
800
+
801
+ if (field->type == PBW_TYPE_MESSAGE || field->type == PBW_TYPE_ENUM ||
802
+ field->type == PBW_TYPE_GROUP) {
803
+ pbw_descriptor *sub;
804
+
805
+ if (field->type_name == NULL) {
806
+ snprintf(schema->error, sizeof(schema->error),
807
+ "field %s.%s needs a type name", msg->name, field->name);
808
+ return PBW_ERR_INVALID;
809
+ }
810
+ sub = pbw_schema_find(schema, field->type_name);
811
+ if (sub == NULL) {
812
+ snprintf(schema->error, sizeof(schema->error),
813
+ "unknown type %s for field %s.%s", field->type_name, msg->name,
814
+ field->name);
815
+ return PBW_ERR_NOT_FOUND;
816
+ }
817
+ if (sub->is_enum != (field->type == PBW_TYPE_ENUM)) {
818
+ snprintf(schema->error, sizeof(schema->error),
819
+ "type %s does not match field %s.%s", field->type_name,
820
+ msg->name, field->name);
821
+ return PBW_ERR_TYPE;
822
+ }
823
+ field->sub = sub;
824
+ }
825
+ if (field->packed &&
826
+ (field->label != PBW_LABEL_REPEATED || !pbw_is_packable(field->type))) {
827
+ snprintf(schema->error, sizeof(schema->error),
828
+ "field %s.%s cannot be packed", msg->name, field->name);
829
+ return PBW_ERR_INVALID;
830
+ }
831
+ link_field_tags(field);
832
+ if (pbw_field_is_required(field, msg)) {
833
+ msg->has_required = 1;
834
+ }
835
+ if (field->oneof_index > msg->oneof_count) {
836
+ msg->oneof_count = field->oneof_index;
837
+ }
838
+ if (field->number > max_fnum) {
839
+ max_fnum = field->number;
840
+ }
841
+ }
842
+
843
+ msg->has_closed_enum = 0;
844
+ for (i = 0; i < msg->field_count; i++) {
845
+ const pbw_field *field = &msg->fields[i];
846
+
847
+ if (pbw_enum_is_closed(field)) {
848
+ msg->has_closed_enum = 1;
849
+ break;
850
+ }
851
+ }
852
+
853
+ /* A zero-element qsort with a NULL base is undefined behavior. */
854
+ if (msg->field_count > 1) {
855
+ qsort(msg->fields, msg->field_count, sizeof(*msg->fields),
856
+ compare_fields);
857
+ /* Sorting permutes the rows the add-time index points at, so it has to
858
+ * go: the next add falls back to the linear scan and rebuilds it. */
859
+ add_index_drop(msg);
860
+ }
861
+ for (i = 1; i < msg->field_count; i++) {
862
+ if (msg->fields[i - 1].number == msg->fields[i].number) {
863
+ snprintf(schema->error, sizeof(schema->error),
864
+ "duplicate field number %u in %s", msg->fields[i].number,
865
+ msg->name);
866
+ return PBW_ERR_INVALID;
867
+ }
868
+ }
869
+
870
+ /* Dense field-number lookup table for the decoder; sparse messages use
871
+ * bsearch. */
872
+ free(msg->fnum_map);
873
+ msg->fnum_map = NULL;
874
+ msg->fnum_map_size = 0;
875
+ if (msg->field_count <= (SIZE_MAX - 8) / 8 &&
876
+ max_fnum <= PBW_FNUM_MAP_LIMIT &&
877
+ max_fnum <= (uint32_t)(msg->field_count * 8 + 8)) {
878
+ if ((size_t)max_fnum + 1 > SIZE_MAX / sizeof(pbw_field *)) {
879
+ return PBW_ERR_NOMEM;
880
+ }
881
+ pbw_field **map =
882
+ (pbw_field **)calloc(max_fnum + 1, sizeof(*map));
883
+ if (map == NULL) {
884
+ return PBW_ERR_NOMEM;
885
+ }
886
+ for (i = 0; i < msg->field_count; i++) {
887
+ map[msg->fields[i].number] = &msg->fields[i];
888
+ }
889
+ msg->fnum_map = map;
890
+ msg->fnum_map_size = max_fnum + 1;
891
+ }
892
+ /* Per-field decode action for the decoder hot loop (see dec_action):
893
+ * every field gets one regardless of tag size, so one- and multi-byte
894
+ * tags share a single action switch. Oneof members, groups and closed
895
+ * enums keep the generic logic: only shapes with no side branches get
896
+ * a fast action. */
897
+ for (i = 0; i < msg->field_count; i++) {
898
+ pbw_field *field = &msg->fields[i];
899
+ int closed = pbw_enum_is_closed(field);
900
+ /* A delimited message field travels as group tags: the LEN fast
901
+ * paths do not apply, so it keeps the generic logic like groups. */
902
+ int delimited =
903
+ field->type == PBW_TYPE_MESSAGE && field->msg_enc == 2;
904
+ uint8_t action = PBW_ACT_GENERIC;
905
+ if (field->oneof_index == 0 && field->type != PBW_TYPE_GROUP &&
906
+ !closed && !delimited) {
907
+ if (field->label != PBW_LABEL_REPEATED) {
908
+ switch (field->type) {
909
+ case PBW_TYPE_INT32:
910
+ case PBW_TYPE_ENUM:
911
+ action = PBW_ACT_I32;
912
+ break;
913
+ case PBW_TYPE_INT64:
914
+ case PBW_TYPE_UINT64:
915
+ action = PBW_ACT_I64;
916
+ break;
917
+ case PBW_TYPE_UINT32:
918
+ action = PBW_ACT_U32;
919
+ break;
920
+ case PBW_TYPE_SINT32:
921
+ action = PBW_ACT_S32;
922
+ break;
923
+ case PBW_TYPE_SINT64:
924
+ action = PBW_ACT_S64;
925
+ break;
926
+ case PBW_TYPE_BOOL:
927
+ action = PBW_ACT_BOOL;
928
+ break;
929
+ case PBW_TYPE_FIXED32:
930
+ case PBW_TYPE_SFIXED32:
931
+ case PBW_TYPE_FLOAT:
932
+ action = PBW_ACT_F32;
933
+ break;
934
+ case PBW_TYPE_FIXED64:
935
+ case PBW_TYPE_SFIXED64:
936
+ case PBW_TYPE_DOUBLE:
937
+ action = PBW_ACT_F64;
938
+ break;
939
+ case PBW_TYPE_STRING:
940
+ case PBW_TYPE_BYTES:
941
+ action = PBW_ACT_STR;
942
+ break;
943
+ case PBW_TYPE_MESSAGE:
944
+ action = PBW_ACT_MSG;
945
+ break;
946
+ default:
947
+ break;
948
+ }
949
+ } else {
950
+ switch (field->type) {
951
+ case PBW_TYPE_INT32:
952
+ case PBW_TYPE_ENUM:
953
+ case PBW_TYPE_INT64:
954
+ case PBW_TYPE_UINT64:
955
+ case PBW_TYPE_UINT32:
956
+ case PBW_TYPE_SINT32:
957
+ case PBW_TYPE_SINT64:
958
+ case PBW_TYPE_BOOL:
959
+ action = PBW_ACT_REP_VARINT;
960
+ break;
961
+ case PBW_TYPE_FIXED32:
962
+ case PBW_TYPE_SFIXED32:
963
+ case PBW_TYPE_FLOAT:
964
+ action = PBW_ACT_REP_F32;
965
+ break;
966
+ case PBW_TYPE_FIXED64:
967
+ case PBW_TYPE_SFIXED64:
968
+ case PBW_TYPE_DOUBLE:
969
+ action = PBW_ACT_REP_F64;
970
+ break;
971
+ case PBW_TYPE_STRING:
972
+ case PBW_TYPE_BYTES:
973
+ action = PBW_ACT_REP_STR;
974
+ break;
975
+ case PBW_TYPE_MESSAGE:
976
+ action = PBW_ACT_REP_MSG;
977
+ break;
978
+ default:
979
+ break;
980
+ }
981
+ }
982
+ }
983
+ field->dec_action = action;
984
+ }
985
+ /* One-byte tag dispatch for the decoder hot loop: a tag byte below 0x80
986
+ * indexes this table directly, skipping the field-number lookup. A tag
987
+ * byte is unique per field (number and wire type are both fixed), so no
988
+ * entry is ever shared. Lookup-only now: the action lives on the field.
989
+ * A repeated packable field also accepts the packed (LEN) form; its tag
990
+ * byte can never belong to another field. */
991
+ free(msg->tag_map);
992
+ msg->tag_map = NULL;
993
+ for (i = 0; i < msg->field_count; i++) {
994
+ if (msg->fields[i].tag_len == 1) {
995
+ break;
996
+ }
997
+ }
998
+ if (i < msg->field_count) {
999
+ pbw_field **map = (pbw_field **)calloc(128, sizeof(*map));
1000
+ if (map == NULL) {
1001
+ return PBW_ERR_NOMEM;
1002
+ }
1003
+ for (i = 0; i < msg->field_count; i++) {
1004
+ pbw_field *field = &msg->fields[i];
1005
+ if (field->tag_len == 1) {
1006
+ map[field->tag[0]] = field;
1007
+ }
1008
+ /* The packed-form entry: a repeated packable field accepts the
1009
+ * LEN (packed) form whatever its declared packedness, closed
1010
+ * enums included -- read_packed() moves unknown enum values to
1011
+ * the unknown fields one item at a time, like the reference
1012
+ * parsers. Omitting it here made a packed closed-enum field with
1013
+ * a one-byte tag skip wholesale into the unknown bytes (multi-byte
1014
+ * tags, which resolve through fnum_map, decoded it correctly). */
1015
+ if (field->len_tag_len == 1 &&
1016
+ field->label == PBW_LABEL_REPEATED &&
1017
+ pbw_is_packable(field->type) && field->oneof_index == 0) {
1018
+ map[field->len_tag[0]] = field;
1019
+ }
1020
+ }
1021
+ msg->tag_map = map;
1022
+ }
1023
+ /* Name dispatch for table/dict bindings: open-addressed hash, power of
1024
+ * two sized at 2x field count so probes stay short. */
1025
+ free((void *)msg->name_map);
1026
+ msg->name_map = NULL;
1027
+ msg->name_map_size = 0;
1028
+ if (msg->field_count > 0) {
1029
+ size_t size = 8;
1030
+ const pbw_field **map;
1031
+
1032
+ while (size < msg->field_count * 2) {
1033
+ size *= 2;
1034
+ }
1035
+ map = (const pbw_field **)calloc(size, sizeof(*map));
1036
+ if (map == NULL) {
1037
+ return PBW_ERR_NOMEM;
1038
+ }
1039
+ for (i = 0; i < msg->field_count; i++) {
1040
+ const pbw_field *field = &msg->fields[i];
1041
+ size_t slot = (size_t)(name_hash(field->name) & (uint32_t)(size - 1));
1042
+
1043
+ while (map[slot] != NULL) {
1044
+ slot = (slot + 1) & (size - 1);
1045
+ }
1046
+ map[slot] = field;
1047
+ }
1048
+ msg->name_map = map;
1049
+ msg->name_map_size = size;
1050
+ }
1051
+ return PBW_OK;
1052
+ }
1053
+
1054
+ pbw_status
1055
+ pbw_schema_link(pbw_schema *schema)
1056
+ {
1057
+ size_t i;
1058
+ pbw_status status;
1059
+
1060
+ if (schema == NULL) {
1061
+ return PBW_ERR_INVALID;
1062
+ }
1063
+ if (schema->linked) {
1064
+ return PBW_OK;
1065
+ }
1066
+ schema->error[0] = '\0';
1067
+ for (i = 0; i < schema->count; i++) {
1068
+ /* Even a failed link sorts before it validates, so every pass
1069
+ * retires pre-link messages whether it succeeds or not. */
1070
+ if (!schema->descs[i]->is_enum) {
1071
+ schema->descs[i]->epoch++;
1072
+ }
1073
+ }
1074
+ for (i = 0; i < schema->count; i++) {
1075
+ if (schema->descs[i]->is_enum) {
1076
+ continue;
1077
+ }
1078
+ schema->descs[i]->has_required = 0;
1079
+ status = link_message(schema, schema->descs[i]);
1080
+ if (status != PBW_OK) {
1081
+ return status;
1082
+ }
1083
+ }
1084
+ /* A message requires validation when it or any reachable submessage
1085
+ * declares a proto2 required field. Monotone fixpoint, so recursive
1086
+ * messages terminate: flags only flip 0 -> 1. */
1087
+ for (;;) {
1088
+ int changed = 0;
1089
+
1090
+ for (i = 0; i < schema->count; i++) {
1091
+ pbw_descriptor *msg = schema->descs[i];
1092
+ size_t k;
1093
+
1094
+ if (msg->is_enum || msg->has_required) {
1095
+ continue;
1096
+ }
1097
+ for (k = 0; k < msg->field_count; k++) {
1098
+ const pbw_field *field = &msg->fields[k];
1099
+
1100
+ if ((field->type == PBW_TYPE_MESSAGE ||
1101
+ field->type == PBW_TYPE_GROUP) &&
1102
+ field->sub != NULL && field->sub->has_required) {
1103
+ msg->has_required = 1;
1104
+ changed = 1;
1105
+ break;
1106
+ }
1107
+ }
1108
+ }
1109
+ if (!changed) {
1110
+ break;
1111
+ }
1112
+ }
1113
+ schema->linked = 1;
1114
+ schema->frozen = 1;
1115
+ return PBW_OK;
1116
+ }
1117
+
1118
+ const char *
1119
+ pbw_schema_error(const pbw_schema *schema)
1120
+ {
1121
+ return schema == NULL ? "" : schema->error;
1122
+ }
1123
+
1124
+ const char *
1125
+ pbw_descriptor_name(const pbw_descriptor *desc)
1126
+ {
1127
+ return desc == NULL ? NULL : desc->name;
1128
+ }
1129
+
1130
+ int
1131
+ pbw_descriptor_is_enum(const pbw_descriptor *desc)
1132
+ {
1133
+ return desc != NULL && desc->is_enum;
1134
+ }
1135
+
1136
+ int
1137
+ pbw_descriptor_is_map_entry(const pbw_descriptor *desc)
1138
+ {
1139
+ return desc != NULL && desc->map_entry;
1140
+ }
1141
+
1142
+ int
1143
+ pbw_descriptor_is_proto3(const pbw_descriptor *desc)
1144
+ {
1145
+ return desc != NULL && desc->proto3;
1146
+ }
1147
+
1148
+ size_t
1149
+ pbw_descriptor_field_count(const pbw_descriptor *desc)
1150
+ {
1151
+ return desc == NULL ? 0 : desc->field_count;
1152
+ }
1153
+
1154
+ const pbw_field *
1155
+ pbw_descriptor_field_at(const pbw_descriptor *desc,
1156
+ size_t index)
1157
+ {
1158
+ if (desc == NULL || index >= desc->field_count) {
1159
+ return NULL;
1160
+ }
1161
+ return &desc->fields[index];
1162
+ }
1163
+
1164
+ const pbw_field *
1165
+ pbw_descriptor_find_field(const pbw_descriptor *desc, uint32_t number)
1166
+ {
1167
+ if (desc == NULL || desc->is_enum ||
1168
+ (desc->schema != NULL && !desc->schema->linked)) {
1169
+ return NULL;
1170
+ }
1171
+ return pbw_find_field(desc, number);
1172
+ }
1173
+
1174
+ const pbw_field *
1175
+ pbw_descriptor_find_field_name(const pbw_descriptor *desc,
1176
+ const char *name)
1177
+ {
1178
+ if (desc == NULL || desc->is_enum || name == NULL) {
1179
+ return NULL;
1180
+ }
1181
+ if (desc->name_map != NULL) {
1182
+ size_t mask = desc->name_map_size - 1;
1183
+ size_t slot = (size_t)(name_hash(name) & (uint32_t)mask);
1184
+
1185
+ for (;;) {
1186
+ const pbw_field *field = desc->name_map[slot];
1187
+
1188
+ if (field == NULL) {
1189
+ return NULL;
1190
+ }
1191
+ if (strcmp(field->name, name) == 0) {
1192
+ return field;
1193
+ }
1194
+ slot = (slot + 1) & mask;
1195
+ }
1196
+ }
1197
+ {
1198
+ size_t i;
1199
+
1200
+ for (i = 0; i < desc->field_count; i++) {
1201
+ if (strcmp(desc->fields[i].name, name) == 0) {
1202
+ return &desc->fields[i];
1203
+ }
1204
+ }
1205
+ }
1206
+ return NULL;
1207
+ }
1208
+
1209
+ const char *
1210
+ pbw_field_name(const pbw_field *field)
1211
+ {
1212
+ return field == NULL ? NULL : field->name;
1213
+ }
1214
+
1215
+ const char *
1216
+ pbw_field_default_value(const pbw_field *field)
1217
+ {
1218
+ return field == NULL ? NULL : field->default_value;
1219
+ }
1220
+
1221
+ int
1222
+ pbw_field_is_extension(const pbw_field *field)
1223
+ {
1224
+ return field != NULL && field->is_extension != 0;
1225
+ }
1226
+
1227
+ uint32_t
1228
+ pbw_field_number(const pbw_field *field)
1229
+ {
1230
+ return field == NULL ? 0 : field->number;
1231
+ }
1232
+
1233
+ pbw_type
1234
+ pbw_field_type(const pbw_field *field)
1235
+ {
1236
+ return field == NULL ? PBW_TYPE_INT32 : field->type;
1237
+ }
1238
+
1239
+ pbw_label
1240
+ pbw_field_label(const pbw_field *field)
1241
+ {
1242
+ return field == NULL ? PBW_LABEL_OPTIONAL : field->label;
1243
+ }
1244
+
1245
+ int
1246
+ pbw_field_is_packed(const pbw_field *field)
1247
+ {
1248
+ return field != NULL && field->packed != 0;
1249
+ }
1250
+
1251
+ int
1252
+ pbw_field_requires_utf8_validation(const pbw_field *field)
1253
+ {
1254
+ return field != NULL && field->utf8_check != 0;
1255
+ }
1256
+
1257
+ uint32_t
1258
+ pbw_field_oneof_index(const pbw_field *field)
1259
+ {
1260
+ return field == NULL ? 0 : field->oneof_index;
1261
+ }
1262
+
1263
+ const pbw_descriptor *
1264
+ pbw_field_message_type(const pbw_field *field)
1265
+ {
1266
+ return field == NULL ? NULL : field->sub;
1267
+ }
1268
+
1269
+ int
1270
+ pbw_descriptor_is_reserved(const pbw_descriptor *desc, const char *name)
1271
+ {
1272
+ size_t i;
1273
+
1274
+ if (desc == NULL || name == NULL) {
1275
+ return 0;
1276
+ }
1277
+ for (i = 0; i < desc->reserved_count; i++) {
1278
+ if (strcmp(desc->reserved[i], name) == 0) {
1279
+ return 1;
1280
+ }
1281
+ }
1282
+ return 0;
1283
+ }
1284
+
1285
+ const pbw_field *
1286
+ pbw_schema_find_extension(const pbw_schema *schema, const char *name)
1287
+ {
1288
+ size_t d;
1289
+ size_t i;
1290
+
1291
+ if (schema == NULL || name == NULL) {
1292
+ return NULL;
1293
+ }
1294
+ for (d = 0; d < schema->count; d++) {
1295
+ const pbw_descriptor *desc = schema->descs[d];
1296
+
1297
+ if (desc->is_enum) {
1298
+ continue;
1299
+ }
1300
+ for (i = 0; i < desc->field_count; i++) {
1301
+ const pbw_field *field = &desc->fields[i];
1302
+
1303
+ if (!field->is_extension) {
1304
+ continue;
1305
+ }
1306
+ if (field->full_name != NULL) {
1307
+ if (strcmp(field->full_name, name) == 0) {
1308
+ return field;
1309
+ }
1310
+ } else if (strcmp(field->name, name) == 0) {
1311
+ return field;
1312
+ }
1313
+ }
1314
+ }
1315
+ return NULL;
1316
+ }
1317
+
1318
+ /* ------------------------------------------------------------- services */
1319
+
1320
+ size_t
1321
+ pbw_schema_service_count(const pbw_schema *schema)
1322
+ {
1323
+ return schema == NULL ? 0 : schema->service_count;
1324
+ }
1325
+
1326
+ const pbw_service *
1327
+ pbw_schema_service_at(const pbw_schema *schema, size_t index)
1328
+ {
1329
+ if (schema == NULL || index >= schema->service_count) {
1330
+ return NULL;
1331
+ }
1332
+ return schema->services[index];
1333
+ }
1334
+
1335
+ const pbw_service *
1336
+ pbw_schema_service_find(const pbw_schema *schema, const char *name)
1337
+ {
1338
+ size_t i;
1339
+
1340
+ if (schema == NULL || name == NULL) {
1341
+ return NULL;
1342
+ }
1343
+ for (i = 0; i < schema->service_count; i++) {
1344
+ if (schema->services[i] != NULL &&
1345
+ strcmp(schema->services[i]->name, name) == 0) {
1346
+ return schema->services[i];
1347
+ }
1348
+ }
1349
+ return NULL;
1350
+ }
1351
+
1352
+ const char *
1353
+ pbw_service_name(const pbw_service *svc)
1354
+ {
1355
+ return svc == NULL ? NULL : svc->name;
1356
+ }
1357
+
1358
+ size_t
1359
+ pbw_service_method_count(const pbw_service *svc)
1360
+ {
1361
+ return svc == NULL ? 0 : svc->method_count;
1362
+ }
1363
+
1364
+ const pbw_method *
1365
+ pbw_service_method_at(const pbw_service *svc, size_t index)
1366
+ {
1367
+ if (svc == NULL || index >= svc->method_count) {
1368
+ return NULL;
1369
+ }
1370
+ return &svc->methods[index];
1371
+ }
1372
+
1373
+ const pbw_method *
1374
+ pbw_service_method_find(const pbw_service *svc, const char *name)
1375
+ {
1376
+ size_t i;
1377
+
1378
+ if (svc == NULL || name == NULL) {
1379
+ return NULL;
1380
+ }
1381
+ for (i = 0; i < svc->method_count; i++) {
1382
+ if (svc->methods[i].name != NULL &&
1383
+ strcmp(svc->methods[i].name, name) == 0) {
1384
+ return &svc->methods[i];
1385
+ }
1386
+ }
1387
+ return NULL;
1388
+ }
1389
+
1390
+ const char *
1391
+ pbw_method_name(const pbw_method *method)
1392
+ {
1393
+ return method == NULL ? NULL : method->name;
1394
+ }
1395
+
1396
+ const char *
1397
+ pbw_method_input_type(const pbw_method *method)
1398
+ {
1399
+ return method == NULL ? NULL : method->input_type;
1400
+ }
1401
+
1402
+ const char *
1403
+ pbw_method_output_type(const pbw_method *method)
1404
+ {
1405
+ return method == NULL ? NULL : method->output_type;
1406
+ }
1407
+
1408
+ int
1409
+ pbw_method_client_streaming(const pbw_method *method)
1410
+ {
1411
+ return method == NULL ? 0 : method->client_streaming;
1412
+ }
1413
+
1414
+ int
1415
+ pbw_method_server_streaming(const pbw_method *method)
1416
+ {
1417
+ return method == NULL ? 0 : method->server_streaming;
1418
+ }
1419
+
1420
+ pbw_status
1421
+ pbw_service_resolve(const pbw_schema *schema, const char *service,
1422
+ const char *method, const pbw_descriptor **in_desc,
1423
+ const pbw_descriptor **out_desc)
1424
+ {
1425
+ const pbw_service *svc;
1426
+ const pbw_method *m;
1427
+ const pbw_descriptor *in;
1428
+ const pbw_descriptor *out;
1429
+
1430
+ if (in_desc != NULL) {
1431
+ *in_desc = NULL;
1432
+ }
1433
+ if (out_desc != NULL) {
1434
+ *out_desc = NULL;
1435
+ }
1436
+ if (schema == NULL || service == NULL || method == NULL) {
1437
+ return PBW_ERR_INVALID;
1438
+ }
1439
+ svc = pbw_schema_service_find(schema, service);
1440
+ if (svc == NULL) {
1441
+ return PBW_ERR_INVALID;
1442
+ }
1443
+ m = pbw_service_method_find(svc, method);
1444
+ if (m == NULL) {
1445
+ return PBW_ERR_INVALID;
1446
+ }
1447
+ in = pbw_schema_find(schema, pbw_method_input_type(m));
1448
+ out = pbw_schema_find(schema, pbw_method_output_type(m));
1449
+ if (in == NULL || out == NULL) {
1450
+ return PBW_ERR_INVALID;
1451
+ }
1452
+ if (in_desc != NULL) {
1453
+ *in_desc = in;
1454
+ }
1455
+ if (out_desc != NULL) {
1456
+ *out_desc = out;
1457
+ }
1458
+ return PBW_OK;
1459
+ }