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.
- checksums.yaml +4 -4
- data/ext/pbwire_ext/core_arena.c +322 -0
- data/ext/pbwire_ext/core_ctx.c +334 -0
- data/ext/pbwire_ext/core_decode.c +1735 -0
- data/ext/pbwire_ext/core_descriptor_set.c +1482 -0
- data/ext/pbwire_ext/core_encode.c +1606 -0
- data/ext/pbwire_ext/core_json.c +4792 -0
- data/ext/pbwire_ext/core_message.c +1100 -0
- data/ext/pbwire_ext/core_schema.c +1459 -0
- data/ext/pbwire_ext/core_stream.c +450 -0
- data/ext/pbwire_ext/core_text.c +2583 -0
- data/ext/pbwire_ext/core_wire.c +735 -0
- data/ext/pbwire_ext/core_wkt.c +255 -0
- data/ext/pbwire_ext/extconf.rb +8 -7
- data/ext/pbwire_ext/internal.h +980 -0
- data/ext/pbwire_ext/pbwire.h +746 -0
- metadata +15 -15
- data/.diffend-unextracted-0 +0 -34
|
@@ -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
|
+
}
|