1 /* Generated by the protocol buffer compiler. DO NOT EDIT! */
2 /* Generated from: Mumble.proto */
3
4 /* Do not generate deprecated warnings for self */
5 #ifndef PROTOBUF_C__NO_DEPRECATED
6 #define PROTOBUF_C__NO_DEPRECATED
7 #endif
8
9 #include "Mumble.pb-c.h"
mumble_proto__version__init(MumbleProto__Version * message)10 void mumble_proto__version__init
11 (MumbleProto__Version *message)
12 {
13 static MumbleProto__Version init_value = MUMBLE_PROTO__VERSION__INIT;
14 *message = init_value;
15 }
mumble_proto__version__get_packed_size(const MumbleProto__Version * message)16 size_t mumble_proto__version__get_packed_size
17 (const MumbleProto__Version *message)
18 {
19 assert(message->base.descriptor == &mumble_proto__version__descriptor);
20 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
21 }
mumble_proto__version__pack(const MumbleProto__Version * message,uint8_t * out)22 size_t mumble_proto__version__pack
23 (const MumbleProto__Version *message,
24 uint8_t *out)
25 {
26 assert(message->base.descriptor == &mumble_proto__version__descriptor);
27 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
28 }
mumble_proto__version__pack_to_buffer(const MumbleProto__Version * message,ProtobufCBuffer * buffer)29 size_t mumble_proto__version__pack_to_buffer
30 (const MumbleProto__Version *message,
31 ProtobufCBuffer *buffer)
32 {
33 assert(message->base.descriptor == &mumble_proto__version__descriptor);
34 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
35 }
36 MumbleProto__Version *
mumble_proto__version__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)37 mumble_proto__version__unpack
38 (ProtobufCAllocator *allocator,
39 size_t len,
40 const uint8_t *data)
41 {
42 return (MumbleProto__Version *)
43 protobuf_c_message_unpack (&mumble_proto__version__descriptor,
44 allocator, len, data);
45 }
mumble_proto__version__free_unpacked(MumbleProto__Version * message,ProtobufCAllocator * allocator)46 void mumble_proto__version__free_unpacked
47 (MumbleProto__Version *message,
48 ProtobufCAllocator *allocator)
49 {
50 assert(message->base.descriptor == &mumble_proto__version__descriptor);
51 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
52 }
mumble_proto__udptunnel__init(MumbleProto__UDPTunnel * message)53 void mumble_proto__udptunnel__init
54 (MumbleProto__UDPTunnel *message)
55 {
56 static MumbleProto__UDPTunnel init_value = MUMBLE_PROTO__UDPTUNNEL__INIT;
57 *message = init_value;
58 }
mumble_proto__udptunnel__get_packed_size(const MumbleProto__UDPTunnel * message)59 size_t mumble_proto__udptunnel__get_packed_size
60 (const MumbleProto__UDPTunnel *message)
61 {
62 assert(message->base.descriptor == &mumble_proto__udptunnel__descriptor);
63 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
64 }
mumble_proto__udptunnel__pack(const MumbleProto__UDPTunnel * message,uint8_t * out)65 size_t mumble_proto__udptunnel__pack
66 (const MumbleProto__UDPTunnel *message,
67 uint8_t *out)
68 {
69 assert(message->base.descriptor == &mumble_proto__udptunnel__descriptor);
70 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
71 }
mumble_proto__udptunnel__pack_to_buffer(const MumbleProto__UDPTunnel * message,ProtobufCBuffer * buffer)72 size_t mumble_proto__udptunnel__pack_to_buffer
73 (const MumbleProto__UDPTunnel *message,
74 ProtobufCBuffer *buffer)
75 {
76 assert(message->base.descriptor == &mumble_proto__udptunnel__descriptor);
77 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
78 }
79 MumbleProto__UDPTunnel *
mumble_proto__udptunnel__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)80 mumble_proto__udptunnel__unpack
81 (ProtobufCAllocator *allocator,
82 size_t len,
83 const uint8_t *data)
84 {
85 return (MumbleProto__UDPTunnel *)
86 protobuf_c_message_unpack (&mumble_proto__udptunnel__descriptor,
87 allocator, len, data);
88 }
mumble_proto__udptunnel__free_unpacked(MumbleProto__UDPTunnel * message,ProtobufCAllocator * allocator)89 void mumble_proto__udptunnel__free_unpacked
90 (MumbleProto__UDPTunnel *message,
91 ProtobufCAllocator *allocator)
92 {
93 assert(message->base.descriptor == &mumble_proto__udptunnel__descriptor);
94 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
95 }
mumble_proto__authenticate__init(MumbleProto__Authenticate * message)96 void mumble_proto__authenticate__init
97 (MumbleProto__Authenticate *message)
98 {
99 static MumbleProto__Authenticate init_value = MUMBLE_PROTO__AUTHENTICATE__INIT;
100 *message = init_value;
101 }
mumble_proto__authenticate__get_packed_size(const MumbleProto__Authenticate * message)102 size_t mumble_proto__authenticate__get_packed_size
103 (const MumbleProto__Authenticate *message)
104 {
105 assert(message->base.descriptor == &mumble_proto__authenticate__descriptor);
106 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
107 }
mumble_proto__authenticate__pack(const MumbleProto__Authenticate * message,uint8_t * out)108 size_t mumble_proto__authenticate__pack
109 (const MumbleProto__Authenticate *message,
110 uint8_t *out)
111 {
112 assert(message->base.descriptor == &mumble_proto__authenticate__descriptor);
113 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
114 }
mumble_proto__authenticate__pack_to_buffer(const MumbleProto__Authenticate * message,ProtobufCBuffer * buffer)115 size_t mumble_proto__authenticate__pack_to_buffer
116 (const MumbleProto__Authenticate *message,
117 ProtobufCBuffer *buffer)
118 {
119 assert(message->base.descriptor == &mumble_proto__authenticate__descriptor);
120 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
121 }
122 MumbleProto__Authenticate *
mumble_proto__authenticate__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)123 mumble_proto__authenticate__unpack
124 (ProtobufCAllocator *allocator,
125 size_t len,
126 const uint8_t *data)
127 {
128 return (MumbleProto__Authenticate *)
129 protobuf_c_message_unpack (&mumble_proto__authenticate__descriptor,
130 allocator, len, data);
131 }
mumble_proto__authenticate__free_unpacked(MumbleProto__Authenticate * message,ProtobufCAllocator * allocator)132 void mumble_proto__authenticate__free_unpacked
133 (MumbleProto__Authenticate *message,
134 ProtobufCAllocator *allocator)
135 {
136 assert(message->base.descriptor == &mumble_proto__authenticate__descriptor);
137 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
138 }
mumble_proto__ping__init(MumbleProto__Ping * message)139 void mumble_proto__ping__init
140 (MumbleProto__Ping *message)
141 {
142 static MumbleProto__Ping init_value = MUMBLE_PROTO__PING__INIT;
143 *message = init_value;
144 }
mumble_proto__ping__get_packed_size(const MumbleProto__Ping * message)145 size_t mumble_proto__ping__get_packed_size
146 (const MumbleProto__Ping *message)
147 {
148 assert(message->base.descriptor == &mumble_proto__ping__descriptor);
149 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
150 }
mumble_proto__ping__pack(const MumbleProto__Ping * message,uint8_t * out)151 size_t mumble_proto__ping__pack
152 (const MumbleProto__Ping *message,
153 uint8_t *out)
154 {
155 assert(message->base.descriptor == &mumble_proto__ping__descriptor);
156 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
157 }
mumble_proto__ping__pack_to_buffer(const MumbleProto__Ping * message,ProtobufCBuffer * buffer)158 size_t mumble_proto__ping__pack_to_buffer
159 (const MumbleProto__Ping *message,
160 ProtobufCBuffer *buffer)
161 {
162 assert(message->base.descriptor == &mumble_proto__ping__descriptor);
163 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
164 }
165 MumbleProto__Ping *
mumble_proto__ping__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)166 mumble_proto__ping__unpack
167 (ProtobufCAllocator *allocator,
168 size_t len,
169 const uint8_t *data)
170 {
171 return (MumbleProto__Ping *)
172 protobuf_c_message_unpack (&mumble_proto__ping__descriptor,
173 allocator, len, data);
174 }
mumble_proto__ping__free_unpacked(MumbleProto__Ping * message,ProtobufCAllocator * allocator)175 void mumble_proto__ping__free_unpacked
176 (MumbleProto__Ping *message,
177 ProtobufCAllocator *allocator)
178 {
179 assert(message->base.descriptor == &mumble_proto__ping__descriptor);
180 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
181 }
mumble_proto__reject__init(MumbleProto__Reject * message)182 void mumble_proto__reject__init
183 (MumbleProto__Reject *message)
184 {
185 static MumbleProto__Reject init_value = MUMBLE_PROTO__REJECT__INIT;
186 *message = init_value;
187 }
mumble_proto__reject__get_packed_size(const MumbleProto__Reject * message)188 size_t mumble_proto__reject__get_packed_size
189 (const MumbleProto__Reject *message)
190 {
191 assert(message->base.descriptor == &mumble_proto__reject__descriptor);
192 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
193 }
mumble_proto__reject__pack(const MumbleProto__Reject * message,uint8_t * out)194 size_t mumble_proto__reject__pack
195 (const MumbleProto__Reject *message,
196 uint8_t *out)
197 {
198 assert(message->base.descriptor == &mumble_proto__reject__descriptor);
199 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
200 }
mumble_proto__reject__pack_to_buffer(const MumbleProto__Reject * message,ProtobufCBuffer * buffer)201 size_t mumble_proto__reject__pack_to_buffer
202 (const MumbleProto__Reject *message,
203 ProtobufCBuffer *buffer)
204 {
205 assert(message->base.descriptor == &mumble_proto__reject__descriptor);
206 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
207 }
208 MumbleProto__Reject *
mumble_proto__reject__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)209 mumble_proto__reject__unpack
210 (ProtobufCAllocator *allocator,
211 size_t len,
212 const uint8_t *data)
213 {
214 return (MumbleProto__Reject *)
215 protobuf_c_message_unpack (&mumble_proto__reject__descriptor,
216 allocator, len, data);
217 }
mumble_proto__reject__free_unpacked(MumbleProto__Reject * message,ProtobufCAllocator * allocator)218 void mumble_proto__reject__free_unpacked
219 (MumbleProto__Reject *message,
220 ProtobufCAllocator *allocator)
221 {
222 assert(message->base.descriptor == &mumble_proto__reject__descriptor);
223 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
224 }
mumble_proto__server_config__init(MumbleProto__ServerConfig * message)225 void mumble_proto__server_config__init
226 (MumbleProto__ServerConfig *message)
227 {
228 static MumbleProto__ServerConfig init_value = MUMBLE_PROTO__SERVER_CONFIG__INIT;
229 *message = init_value;
230 }
mumble_proto__server_config__get_packed_size(const MumbleProto__ServerConfig * message)231 size_t mumble_proto__server_config__get_packed_size
232 (const MumbleProto__ServerConfig *message)
233 {
234 assert(message->base.descriptor == &mumble_proto__server_config__descriptor);
235 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
236 }
mumble_proto__server_config__pack(const MumbleProto__ServerConfig * message,uint8_t * out)237 size_t mumble_proto__server_config__pack
238 (const MumbleProto__ServerConfig *message,
239 uint8_t *out)
240 {
241 assert(message->base.descriptor == &mumble_proto__server_config__descriptor);
242 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
243 }
mumble_proto__server_config__pack_to_buffer(const MumbleProto__ServerConfig * message,ProtobufCBuffer * buffer)244 size_t mumble_proto__server_config__pack_to_buffer
245 (const MumbleProto__ServerConfig *message,
246 ProtobufCBuffer *buffer)
247 {
248 assert(message->base.descriptor == &mumble_proto__server_config__descriptor);
249 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
250 }
251 MumbleProto__ServerConfig *
mumble_proto__server_config__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)252 mumble_proto__server_config__unpack
253 (ProtobufCAllocator *allocator,
254 size_t len,
255 const uint8_t *data)
256 {
257 return (MumbleProto__ServerConfig *)
258 protobuf_c_message_unpack (&mumble_proto__server_config__descriptor,
259 allocator, len, data);
260 }
mumble_proto__server_config__free_unpacked(MumbleProto__ServerConfig * message,ProtobufCAllocator * allocator)261 void mumble_proto__server_config__free_unpacked
262 (MumbleProto__ServerConfig *message,
263 ProtobufCAllocator *allocator)
264 {
265 assert(message->base.descriptor == &mumble_proto__server_config__descriptor);
266 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
267 }
mumble_proto__server_sync__init(MumbleProto__ServerSync * message)268 void mumble_proto__server_sync__init
269 (MumbleProto__ServerSync *message)
270 {
271 static MumbleProto__ServerSync init_value = MUMBLE_PROTO__SERVER_SYNC__INIT;
272 *message = init_value;
273 }
mumble_proto__server_sync__get_packed_size(const MumbleProto__ServerSync * message)274 size_t mumble_proto__server_sync__get_packed_size
275 (const MumbleProto__ServerSync *message)
276 {
277 assert(message->base.descriptor == &mumble_proto__server_sync__descriptor);
278 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
279 }
mumble_proto__server_sync__pack(const MumbleProto__ServerSync * message,uint8_t * out)280 size_t mumble_proto__server_sync__pack
281 (const MumbleProto__ServerSync *message,
282 uint8_t *out)
283 {
284 assert(message->base.descriptor == &mumble_proto__server_sync__descriptor);
285 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
286 }
mumble_proto__server_sync__pack_to_buffer(const MumbleProto__ServerSync * message,ProtobufCBuffer * buffer)287 size_t mumble_proto__server_sync__pack_to_buffer
288 (const MumbleProto__ServerSync *message,
289 ProtobufCBuffer *buffer)
290 {
291 assert(message->base.descriptor == &mumble_proto__server_sync__descriptor);
292 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
293 }
294 MumbleProto__ServerSync *
mumble_proto__server_sync__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)295 mumble_proto__server_sync__unpack
296 (ProtobufCAllocator *allocator,
297 size_t len,
298 const uint8_t *data)
299 {
300 return (MumbleProto__ServerSync *)
301 protobuf_c_message_unpack (&mumble_proto__server_sync__descriptor,
302 allocator, len, data);
303 }
mumble_proto__server_sync__free_unpacked(MumbleProto__ServerSync * message,ProtobufCAllocator * allocator)304 void mumble_proto__server_sync__free_unpacked
305 (MumbleProto__ServerSync *message,
306 ProtobufCAllocator *allocator)
307 {
308 assert(message->base.descriptor == &mumble_proto__server_sync__descriptor);
309 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
310 }
mumble_proto__channel_remove__init(MumbleProto__ChannelRemove * message)311 void mumble_proto__channel_remove__init
312 (MumbleProto__ChannelRemove *message)
313 {
314 static MumbleProto__ChannelRemove init_value = MUMBLE_PROTO__CHANNEL_REMOVE__INIT;
315 *message = init_value;
316 }
mumble_proto__channel_remove__get_packed_size(const MumbleProto__ChannelRemove * message)317 size_t mumble_proto__channel_remove__get_packed_size
318 (const MumbleProto__ChannelRemove *message)
319 {
320 assert(message->base.descriptor == &mumble_proto__channel_remove__descriptor);
321 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
322 }
mumble_proto__channel_remove__pack(const MumbleProto__ChannelRemove * message,uint8_t * out)323 size_t mumble_proto__channel_remove__pack
324 (const MumbleProto__ChannelRemove *message,
325 uint8_t *out)
326 {
327 assert(message->base.descriptor == &mumble_proto__channel_remove__descriptor);
328 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
329 }
mumble_proto__channel_remove__pack_to_buffer(const MumbleProto__ChannelRemove * message,ProtobufCBuffer * buffer)330 size_t mumble_proto__channel_remove__pack_to_buffer
331 (const MumbleProto__ChannelRemove *message,
332 ProtobufCBuffer *buffer)
333 {
334 assert(message->base.descriptor == &mumble_proto__channel_remove__descriptor);
335 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
336 }
337 MumbleProto__ChannelRemove *
mumble_proto__channel_remove__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)338 mumble_proto__channel_remove__unpack
339 (ProtobufCAllocator *allocator,
340 size_t len,
341 const uint8_t *data)
342 {
343 return (MumbleProto__ChannelRemove *)
344 protobuf_c_message_unpack (&mumble_proto__channel_remove__descriptor,
345 allocator, len, data);
346 }
mumble_proto__channel_remove__free_unpacked(MumbleProto__ChannelRemove * message,ProtobufCAllocator * allocator)347 void mumble_proto__channel_remove__free_unpacked
348 (MumbleProto__ChannelRemove *message,
349 ProtobufCAllocator *allocator)
350 {
351 assert(message->base.descriptor == &mumble_proto__channel_remove__descriptor);
352 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
353 }
mumble_proto__channel_state__init(MumbleProto__ChannelState * message)354 void mumble_proto__channel_state__init
355 (MumbleProto__ChannelState *message)
356 {
357 static MumbleProto__ChannelState init_value = MUMBLE_PROTO__CHANNEL_STATE__INIT;
358 *message = init_value;
359 }
mumble_proto__channel_state__get_packed_size(const MumbleProto__ChannelState * message)360 size_t mumble_proto__channel_state__get_packed_size
361 (const MumbleProto__ChannelState *message)
362 {
363 assert(message->base.descriptor == &mumble_proto__channel_state__descriptor);
364 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
365 }
mumble_proto__channel_state__pack(const MumbleProto__ChannelState * message,uint8_t * out)366 size_t mumble_proto__channel_state__pack
367 (const MumbleProto__ChannelState *message,
368 uint8_t *out)
369 {
370 assert(message->base.descriptor == &mumble_proto__channel_state__descriptor);
371 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
372 }
mumble_proto__channel_state__pack_to_buffer(const MumbleProto__ChannelState * message,ProtobufCBuffer * buffer)373 size_t mumble_proto__channel_state__pack_to_buffer
374 (const MumbleProto__ChannelState *message,
375 ProtobufCBuffer *buffer)
376 {
377 assert(message->base.descriptor == &mumble_proto__channel_state__descriptor);
378 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
379 }
380 MumbleProto__ChannelState *
mumble_proto__channel_state__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)381 mumble_proto__channel_state__unpack
382 (ProtobufCAllocator *allocator,
383 size_t len,
384 const uint8_t *data)
385 {
386 return (MumbleProto__ChannelState *)
387 protobuf_c_message_unpack (&mumble_proto__channel_state__descriptor,
388 allocator, len, data);
389 }
mumble_proto__channel_state__free_unpacked(MumbleProto__ChannelState * message,ProtobufCAllocator * allocator)390 void mumble_proto__channel_state__free_unpacked
391 (MumbleProto__ChannelState *message,
392 ProtobufCAllocator *allocator)
393 {
394 assert(message->base.descriptor == &mumble_proto__channel_state__descriptor);
395 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
396 }
mumble_proto__user_remove__init(MumbleProto__UserRemove * message)397 void mumble_proto__user_remove__init
398 (MumbleProto__UserRemove *message)
399 {
400 static MumbleProto__UserRemove init_value = MUMBLE_PROTO__USER_REMOVE__INIT;
401 *message = init_value;
402 }
mumble_proto__user_remove__get_packed_size(const MumbleProto__UserRemove * message)403 size_t mumble_proto__user_remove__get_packed_size
404 (const MumbleProto__UserRemove *message)
405 {
406 assert(message->base.descriptor == &mumble_proto__user_remove__descriptor);
407 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
408 }
mumble_proto__user_remove__pack(const MumbleProto__UserRemove * message,uint8_t * out)409 size_t mumble_proto__user_remove__pack
410 (const MumbleProto__UserRemove *message,
411 uint8_t *out)
412 {
413 assert(message->base.descriptor == &mumble_proto__user_remove__descriptor);
414 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
415 }
mumble_proto__user_remove__pack_to_buffer(const MumbleProto__UserRemove * message,ProtobufCBuffer * buffer)416 size_t mumble_proto__user_remove__pack_to_buffer
417 (const MumbleProto__UserRemove *message,
418 ProtobufCBuffer *buffer)
419 {
420 assert(message->base.descriptor == &mumble_proto__user_remove__descriptor);
421 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
422 }
423 MumbleProto__UserRemove *
mumble_proto__user_remove__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)424 mumble_proto__user_remove__unpack
425 (ProtobufCAllocator *allocator,
426 size_t len,
427 const uint8_t *data)
428 {
429 return (MumbleProto__UserRemove *)
430 protobuf_c_message_unpack (&mumble_proto__user_remove__descriptor,
431 allocator, len, data);
432 }
mumble_proto__user_remove__free_unpacked(MumbleProto__UserRemove * message,ProtobufCAllocator * allocator)433 void mumble_proto__user_remove__free_unpacked
434 (MumbleProto__UserRemove *message,
435 ProtobufCAllocator *allocator)
436 {
437 assert(message->base.descriptor == &mumble_proto__user_remove__descriptor);
438 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
439 }
mumble_proto__user_state__init(MumbleProto__UserState * message)440 void mumble_proto__user_state__init
441 (MumbleProto__UserState *message)
442 {
443 static MumbleProto__UserState init_value = MUMBLE_PROTO__USER_STATE__INIT;
444 *message = init_value;
445 }
mumble_proto__user_state__get_packed_size(const MumbleProto__UserState * message)446 size_t mumble_proto__user_state__get_packed_size
447 (const MumbleProto__UserState *message)
448 {
449 assert(message->base.descriptor == &mumble_proto__user_state__descriptor);
450 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
451 }
mumble_proto__user_state__pack(const MumbleProto__UserState * message,uint8_t * out)452 size_t mumble_proto__user_state__pack
453 (const MumbleProto__UserState *message,
454 uint8_t *out)
455 {
456 assert(message->base.descriptor == &mumble_proto__user_state__descriptor);
457 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
458 }
mumble_proto__user_state__pack_to_buffer(const MumbleProto__UserState * message,ProtobufCBuffer * buffer)459 size_t mumble_proto__user_state__pack_to_buffer
460 (const MumbleProto__UserState *message,
461 ProtobufCBuffer *buffer)
462 {
463 assert(message->base.descriptor == &mumble_proto__user_state__descriptor);
464 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
465 }
466 MumbleProto__UserState *
mumble_proto__user_state__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)467 mumble_proto__user_state__unpack
468 (ProtobufCAllocator *allocator,
469 size_t len,
470 const uint8_t *data)
471 {
472 return (MumbleProto__UserState *)
473 protobuf_c_message_unpack (&mumble_proto__user_state__descriptor,
474 allocator, len, data);
475 }
mumble_proto__user_state__free_unpacked(MumbleProto__UserState * message,ProtobufCAllocator * allocator)476 void mumble_proto__user_state__free_unpacked
477 (MumbleProto__UserState *message,
478 ProtobufCAllocator *allocator)
479 {
480 assert(message->base.descriptor == &mumble_proto__user_state__descriptor);
481 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
482 }
mumble_proto__ban_list__ban_entry__init(MumbleProto__BanList__BanEntry * message)483 void mumble_proto__ban_list__ban_entry__init
484 (MumbleProto__BanList__BanEntry *message)
485 {
486 static MumbleProto__BanList__BanEntry init_value = MUMBLE_PROTO__BAN_LIST__BAN_ENTRY__INIT;
487 *message = init_value;
488 }
mumble_proto__ban_list__init(MumbleProto__BanList * message)489 void mumble_proto__ban_list__init
490 (MumbleProto__BanList *message)
491 {
492 static MumbleProto__BanList init_value = MUMBLE_PROTO__BAN_LIST__INIT;
493 *message = init_value;
494 }
mumble_proto__ban_list__get_packed_size(const MumbleProto__BanList * message)495 size_t mumble_proto__ban_list__get_packed_size
496 (const MumbleProto__BanList *message)
497 {
498 assert(message->base.descriptor == &mumble_proto__ban_list__descriptor);
499 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
500 }
mumble_proto__ban_list__pack(const MumbleProto__BanList * message,uint8_t * out)501 size_t mumble_proto__ban_list__pack
502 (const MumbleProto__BanList *message,
503 uint8_t *out)
504 {
505 assert(message->base.descriptor == &mumble_proto__ban_list__descriptor);
506 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
507 }
mumble_proto__ban_list__pack_to_buffer(const MumbleProto__BanList * message,ProtobufCBuffer * buffer)508 size_t mumble_proto__ban_list__pack_to_buffer
509 (const MumbleProto__BanList *message,
510 ProtobufCBuffer *buffer)
511 {
512 assert(message->base.descriptor == &mumble_proto__ban_list__descriptor);
513 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
514 }
515 MumbleProto__BanList *
mumble_proto__ban_list__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)516 mumble_proto__ban_list__unpack
517 (ProtobufCAllocator *allocator,
518 size_t len,
519 const uint8_t *data)
520 {
521 return (MumbleProto__BanList *)
522 protobuf_c_message_unpack (&mumble_proto__ban_list__descriptor,
523 allocator, len, data);
524 }
mumble_proto__ban_list__free_unpacked(MumbleProto__BanList * message,ProtobufCAllocator * allocator)525 void mumble_proto__ban_list__free_unpacked
526 (MumbleProto__BanList *message,
527 ProtobufCAllocator *allocator)
528 {
529 assert(message->base.descriptor == &mumble_proto__ban_list__descriptor);
530 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
531 }
mumble_proto__text_message__init(MumbleProto__TextMessage * message)532 void mumble_proto__text_message__init
533 (MumbleProto__TextMessage *message)
534 {
535 static MumbleProto__TextMessage init_value = MUMBLE_PROTO__TEXT_MESSAGE__INIT;
536 *message = init_value;
537 }
mumble_proto__text_message__get_packed_size(const MumbleProto__TextMessage * message)538 size_t mumble_proto__text_message__get_packed_size
539 (const MumbleProto__TextMessage *message)
540 {
541 assert(message->base.descriptor == &mumble_proto__text_message__descriptor);
542 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
543 }
mumble_proto__text_message__pack(const MumbleProto__TextMessage * message,uint8_t * out)544 size_t mumble_proto__text_message__pack
545 (const MumbleProto__TextMessage *message,
546 uint8_t *out)
547 {
548 assert(message->base.descriptor == &mumble_proto__text_message__descriptor);
549 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
550 }
mumble_proto__text_message__pack_to_buffer(const MumbleProto__TextMessage * message,ProtobufCBuffer * buffer)551 size_t mumble_proto__text_message__pack_to_buffer
552 (const MumbleProto__TextMessage *message,
553 ProtobufCBuffer *buffer)
554 {
555 assert(message->base.descriptor == &mumble_proto__text_message__descriptor);
556 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
557 }
558 MumbleProto__TextMessage *
mumble_proto__text_message__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)559 mumble_proto__text_message__unpack
560 (ProtobufCAllocator *allocator,
561 size_t len,
562 const uint8_t *data)
563 {
564 return (MumbleProto__TextMessage *)
565 protobuf_c_message_unpack (&mumble_proto__text_message__descriptor,
566 allocator, len, data);
567 }
mumble_proto__text_message__free_unpacked(MumbleProto__TextMessage * message,ProtobufCAllocator * allocator)568 void mumble_proto__text_message__free_unpacked
569 (MumbleProto__TextMessage *message,
570 ProtobufCAllocator *allocator)
571 {
572 assert(message->base.descriptor == &mumble_proto__text_message__descriptor);
573 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
574 }
mumble_proto__permission_denied__init(MumbleProto__PermissionDenied * message)575 void mumble_proto__permission_denied__init
576 (MumbleProto__PermissionDenied *message)
577 {
578 static MumbleProto__PermissionDenied init_value = MUMBLE_PROTO__PERMISSION_DENIED__INIT;
579 *message = init_value;
580 }
mumble_proto__permission_denied__get_packed_size(const MumbleProto__PermissionDenied * message)581 size_t mumble_proto__permission_denied__get_packed_size
582 (const MumbleProto__PermissionDenied *message)
583 {
584 assert(message->base.descriptor == &mumble_proto__permission_denied__descriptor);
585 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
586 }
mumble_proto__permission_denied__pack(const MumbleProto__PermissionDenied * message,uint8_t * out)587 size_t mumble_proto__permission_denied__pack
588 (const MumbleProto__PermissionDenied *message,
589 uint8_t *out)
590 {
591 assert(message->base.descriptor == &mumble_proto__permission_denied__descriptor);
592 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
593 }
mumble_proto__permission_denied__pack_to_buffer(const MumbleProto__PermissionDenied * message,ProtobufCBuffer * buffer)594 size_t mumble_proto__permission_denied__pack_to_buffer
595 (const MumbleProto__PermissionDenied *message,
596 ProtobufCBuffer *buffer)
597 {
598 assert(message->base.descriptor == &mumble_proto__permission_denied__descriptor);
599 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
600 }
601 MumbleProto__PermissionDenied *
mumble_proto__permission_denied__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)602 mumble_proto__permission_denied__unpack
603 (ProtobufCAllocator *allocator,
604 size_t len,
605 const uint8_t *data)
606 {
607 return (MumbleProto__PermissionDenied *)
608 protobuf_c_message_unpack (&mumble_proto__permission_denied__descriptor,
609 allocator, len, data);
610 }
mumble_proto__permission_denied__free_unpacked(MumbleProto__PermissionDenied * message,ProtobufCAllocator * allocator)611 void mumble_proto__permission_denied__free_unpacked
612 (MumbleProto__PermissionDenied *message,
613 ProtobufCAllocator *allocator)
614 {
615 assert(message->base.descriptor == &mumble_proto__permission_denied__descriptor);
616 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
617 }
mumble_proto__acl__chan_group__init(MumbleProto__ACL__ChanGroup * message)618 void mumble_proto__acl__chan_group__init
619 (MumbleProto__ACL__ChanGroup *message)
620 {
621 static MumbleProto__ACL__ChanGroup init_value = MUMBLE_PROTO__ACL__CHAN_GROUP__INIT;
622 *message = init_value;
623 }
mumble_proto__acl__chan_acl__init(MumbleProto__ACL__ChanACL * message)624 void mumble_proto__acl__chan_acl__init
625 (MumbleProto__ACL__ChanACL *message)
626 {
627 static MumbleProto__ACL__ChanACL init_value = MUMBLE_PROTO__ACL__CHAN_ACL__INIT;
628 *message = init_value;
629 }
mumble_proto__acl__init(MumbleProto__ACL * message)630 void mumble_proto__acl__init
631 (MumbleProto__ACL *message)
632 {
633 static MumbleProto__ACL init_value = MUMBLE_PROTO__ACL__INIT;
634 *message = init_value;
635 }
mumble_proto__acl__get_packed_size(const MumbleProto__ACL * message)636 size_t mumble_proto__acl__get_packed_size
637 (const MumbleProto__ACL *message)
638 {
639 assert(message->base.descriptor == &mumble_proto__acl__descriptor);
640 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
641 }
mumble_proto__acl__pack(const MumbleProto__ACL * message,uint8_t * out)642 size_t mumble_proto__acl__pack
643 (const MumbleProto__ACL *message,
644 uint8_t *out)
645 {
646 assert(message->base.descriptor == &mumble_proto__acl__descriptor);
647 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
648 }
mumble_proto__acl__pack_to_buffer(const MumbleProto__ACL * message,ProtobufCBuffer * buffer)649 size_t mumble_proto__acl__pack_to_buffer
650 (const MumbleProto__ACL *message,
651 ProtobufCBuffer *buffer)
652 {
653 assert(message->base.descriptor == &mumble_proto__acl__descriptor);
654 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
655 }
656 MumbleProto__ACL *
mumble_proto__acl__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)657 mumble_proto__acl__unpack
658 (ProtobufCAllocator *allocator,
659 size_t len,
660 const uint8_t *data)
661 {
662 return (MumbleProto__ACL *)
663 protobuf_c_message_unpack (&mumble_proto__acl__descriptor,
664 allocator, len, data);
665 }
mumble_proto__acl__free_unpacked(MumbleProto__ACL * message,ProtobufCAllocator * allocator)666 void mumble_proto__acl__free_unpacked
667 (MumbleProto__ACL *message,
668 ProtobufCAllocator *allocator)
669 {
670 assert(message->base.descriptor == &mumble_proto__acl__descriptor);
671 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
672 }
mumble_proto__query_users__init(MumbleProto__QueryUsers * message)673 void mumble_proto__query_users__init
674 (MumbleProto__QueryUsers *message)
675 {
676 static MumbleProto__QueryUsers init_value = MUMBLE_PROTO__QUERY_USERS__INIT;
677 *message = init_value;
678 }
mumble_proto__query_users__get_packed_size(const MumbleProto__QueryUsers * message)679 size_t mumble_proto__query_users__get_packed_size
680 (const MumbleProto__QueryUsers *message)
681 {
682 assert(message->base.descriptor == &mumble_proto__query_users__descriptor);
683 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
684 }
mumble_proto__query_users__pack(const MumbleProto__QueryUsers * message,uint8_t * out)685 size_t mumble_proto__query_users__pack
686 (const MumbleProto__QueryUsers *message,
687 uint8_t *out)
688 {
689 assert(message->base.descriptor == &mumble_proto__query_users__descriptor);
690 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
691 }
mumble_proto__query_users__pack_to_buffer(const MumbleProto__QueryUsers * message,ProtobufCBuffer * buffer)692 size_t mumble_proto__query_users__pack_to_buffer
693 (const MumbleProto__QueryUsers *message,
694 ProtobufCBuffer *buffer)
695 {
696 assert(message->base.descriptor == &mumble_proto__query_users__descriptor);
697 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
698 }
699 MumbleProto__QueryUsers *
mumble_proto__query_users__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)700 mumble_proto__query_users__unpack
701 (ProtobufCAllocator *allocator,
702 size_t len,
703 const uint8_t *data)
704 {
705 return (MumbleProto__QueryUsers *)
706 protobuf_c_message_unpack (&mumble_proto__query_users__descriptor,
707 allocator, len, data);
708 }
mumble_proto__query_users__free_unpacked(MumbleProto__QueryUsers * message,ProtobufCAllocator * allocator)709 void mumble_proto__query_users__free_unpacked
710 (MumbleProto__QueryUsers *message,
711 ProtobufCAllocator *allocator)
712 {
713 assert(message->base.descriptor == &mumble_proto__query_users__descriptor);
714 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
715 }
mumble_proto__crypt_setup__init(MumbleProto__CryptSetup * message)716 void mumble_proto__crypt_setup__init
717 (MumbleProto__CryptSetup *message)
718 {
719 static MumbleProto__CryptSetup init_value = MUMBLE_PROTO__CRYPT_SETUP__INIT;
720 *message = init_value;
721 }
mumble_proto__crypt_setup__get_packed_size(const MumbleProto__CryptSetup * message)722 size_t mumble_proto__crypt_setup__get_packed_size
723 (const MumbleProto__CryptSetup *message)
724 {
725 assert(message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
726 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
727 }
mumble_proto__crypt_setup__pack(const MumbleProto__CryptSetup * message,uint8_t * out)728 size_t mumble_proto__crypt_setup__pack
729 (const MumbleProto__CryptSetup *message,
730 uint8_t *out)
731 {
732 assert(message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
733 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
734 }
mumble_proto__crypt_setup__pack_to_buffer(const MumbleProto__CryptSetup * message,ProtobufCBuffer * buffer)735 size_t mumble_proto__crypt_setup__pack_to_buffer
736 (const MumbleProto__CryptSetup *message,
737 ProtobufCBuffer *buffer)
738 {
739 assert(message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
740 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
741 }
742 MumbleProto__CryptSetup *
mumble_proto__crypt_setup__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)743 mumble_proto__crypt_setup__unpack
744 (ProtobufCAllocator *allocator,
745 size_t len,
746 const uint8_t *data)
747 {
748 return (MumbleProto__CryptSetup *)
749 protobuf_c_message_unpack (&mumble_proto__crypt_setup__descriptor,
750 allocator, len, data);
751 }
mumble_proto__crypt_setup__free_unpacked(MumbleProto__CryptSetup * message,ProtobufCAllocator * allocator)752 void mumble_proto__crypt_setup__free_unpacked
753 (MumbleProto__CryptSetup *message,
754 ProtobufCAllocator *allocator)
755 {
756 assert(message->base.descriptor == &mumble_proto__crypt_setup__descriptor);
757 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
758 }
mumble_proto__context_action_modify__init(MumbleProto__ContextActionModify * message)759 void mumble_proto__context_action_modify__init
760 (MumbleProto__ContextActionModify *message)
761 {
762 static MumbleProto__ContextActionModify init_value = MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__INIT;
763 *message = init_value;
764 }
mumble_proto__context_action_modify__get_packed_size(const MumbleProto__ContextActionModify * message)765 size_t mumble_proto__context_action_modify__get_packed_size
766 (const MumbleProto__ContextActionModify *message)
767 {
768 assert(message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
769 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
770 }
mumble_proto__context_action_modify__pack(const MumbleProto__ContextActionModify * message,uint8_t * out)771 size_t mumble_proto__context_action_modify__pack
772 (const MumbleProto__ContextActionModify *message,
773 uint8_t *out)
774 {
775 assert(message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
776 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
777 }
mumble_proto__context_action_modify__pack_to_buffer(const MumbleProto__ContextActionModify * message,ProtobufCBuffer * buffer)778 size_t mumble_proto__context_action_modify__pack_to_buffer
779 (const MumbleProto__ContextActionModify *message,
780 ProtobufCBuffer *buffer)
781 {
782 assert(message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
783 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
784 }
785 MumbleProto__ContextActionModify *
mumble_proto__context_action_modify__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)786 mumble_proto__context_action_modify__unpack
787 (ProtobufCAllocator *allocator,
788 size_t len,
789 const uint8_t *data)
790 {
791 return (MumbleProto__ContextActionModify *)
792 protobuf_c_message_unpack (&mumble_proto__context_action_modify__descriptor,
793 allocator, len, data);
794 }
mumble_proto__context_action_modify__free_unpacked(MumbleProto__ContextActionModify * message,ProtobufCAllocator * allocator)795 void mumble_proto__context_action_modify__free_unpacked
796 (MumbleProto__ContextActionModify *message,
797 ProtobufCAllocator *allocator)
798 {
799 assert(message->base.descriptor == &mumble_proto__context_action_modify__descriptor);
800 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
801 }
mumble_proto__context_action__init(MumbleProto__ContextAction * message)802 void mumble_proto__context_action__init
803 (MumbleProto__ContextAction *message)
804 {
805 static MumbleProto__ContextAction init_value = MUMBLE_PROTO__CONTEXT_ACTION__INIT;
806 *message = init_value;
807 }
mumble_proto__context_action__get_packed_size(const MumbleProto__ContextAction * message)808 size_t mumble_proto__context_action__get_packed_size
809 (const MumbleProto__ContextAction *message)
810 {
811 assert(message->base.descriptor == &mumble_proto__context_action__descriptor);
812 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
813 }
mumble_proto__context_action__pack(const MumbleProto__ContextAction * message,uint8_t * out)814 size_t mumble_proto__context_action__pack
815 (const MumbleProto__ContextAction *message,
816 uint8_t *out)
817 {
818 assert(message->base.descriptor == &mumble_proto__context_action__descriptor);
819 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
820 }
mumble_proto__context_action__pack_to_buffer(const MumbleProto__ContextAction * message,ProtobufCBuffer * buffer)821 size_t mumble_proto__context_action__pack_to_buffer
822 (const MumbleProto__ContextAction *message,
823 ProtobufCBuffer *buffer)
824 {
825 assert(message->base.descriptor == &mumble_proto__context_action__descriptor);
826 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
827 }
828 MumbleProto__ContextAction *
mumble_proto__context_action__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)829 mumble_proto__context_action__unpack
830 (ProtobufCAllocator *allocator,
831 size_t len,
832 const uint8_t *data)
833 {
834 return (MumbleProto__ContextAction *)
835 protobuf_c_message_unpack (&mumble_proto__context_action__descriptor,
836 allocator, len, data);
837 }
mumble_proto__context_action__free_unpacked(MumbleProto__ContextAction * message,ProtobufCAllocator * allocator)838 void mumble_proto__context_action__free_unpacked
839 (MumbleProto__ContextAction *message,
840 ProtobufCAllocator *allocator)
841 {
842 assert(message->base.descriptor == &mumble_proto__context_action__descriptor);
843 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
844 }
mumble_proto__user_list__user__init(MumbleProto__UserList__User * message)845 void mumble_proto__user_list__user__init
846 (MumbleProto__UserList__User *message)
847 {
848 static MumbleProto__UserList__User init_value = MUMBLE_PROTO__USER_LIST__USER__INIT;
849 *message = init_value;
850 }
mumble_proto__user_list__init(MumbleProto__UserList * message)851 void mumble_proto__user_list__init
852 (MumbleProto__UserList *message)
853 {
854 static MumbleProto__UserList init_value = MUMBLE_PROTO__USER_LIST__INIT;
855 *message = init_value;
856 }
mumble_proto__user_list__get_packed_size(const MumbleProto__UserList * message)857 size_t mumble_proto__user_list__get_packed_size
858 (const MumbleProto__UserList *message)
859 {
860 assert(message->base.descriptor == &mumble_proto__user_list__descriptor);
861 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
862 }
mumble_proto__user_list__pack(const MumbleProto__UserList * message,uint8_t * out)863 size_t mumble_proto__user_list__pack
864 (const MumbleProto__UserList *message,
865 uint8_t *out)
866 {
867 assert(message->base.descriptor == &mumble_proto__user_list__descriptor);
868 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
869 }
mumble_proto__user_list__pack_to_buffer(const MumbleProto__UserList * message,ProtobufCBuffer * buffer)870 size_t mumble_proto__user_list__pack_to_buffer
871 (const MumbleProto__UserList *message,
872 ProtobufCBuffer *buffer)
873 {
874 assert(message->base.descriptor == &mumble_proto__user_list__descriptor);
875 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
876 }
877 MumbleProto__UserList *
mumble_proto__user_list__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)878 mumble_proto__user_list__unpack
879 (ProtobufCAllocator *allocator,
880 size_t len,
881 const uint8_t *data)
882 {
883 return (MumbleProto__UserList *)
884 protobuf_c_message_unpack (&mumble_proto__user_list__descriptor,
885 allocator, len, data);
886 }
mumble_proto__user_list__free_unpacked(MumbleProto__UserList * message,ProtobufCAllocator * allocator)887 void mumble_proto__user_list__free_unpacked
888 (MumbleProto__UserList *message,
889 ProtobufCAllocator *allocator)
890 {
891 assert(message->base.descriptor == &mumble_proto__user_list__descriptor);
892 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
893 }
mumble_proto__voice_target__target__init(MumbleProto__VoiceTarget__Target * message)894 void mumble_proto__voice_target__target__init
895 (MumbleProto__VoiceTarget__Target *message)
896 {
897 static MumbleProto__VoiceTarget__Target init_value = MUMBLE_PROTO__VOICE_TARGET__TARGET__INIT;
898 *message = init_value;
899 }
mumble_proto__voice_target__init(MumbleProto__VoiceTarget * message)900 void mumble_proto__voice_target__init
901 (MumbleProto__VoiceTarget *message)
902 {
903 static MumbleProto__VoiceTarget init_value = MUMBLE_PROTO__VOICE_TARGET__INIT;
904 *message = init_value;
905 }
mumble_proto__voice_target__get_packed_size(const MumbleProto__VoiceTarget * message)906 size_t mumble_proto__voice_target__get_packed_size
907 (const MumbleProto__VoiceTarget *message)
908 {
909 assert(message->base.descriptor == &mumble_proto__voice_target__descriptor);
910 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
911 }
mumble_proto__voice_target__pack(const MumbleProto__VoiceTarget * message,uint8_t * out)912 size_t mumble_proto__voice_target__pack
913 (const MumbleProto__VoiceTarget *message,
914 uint8_t *out)
915 {
916 assert(message->base.descriptor == &mumble_proto__voice_target__descriptor);
917 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
918 }
mumble_proto__voice_target__pack_to_buffer(const MumbleProto__VoiceTarget * message,ProtobufCBuffer * buffer)919 size_t mumble_proto__voice_target__pack_to_buffer
920 (const MumbleProto__VoiceTarget *message,
921 ProtobufCBuffer *buffer)
922 {
923 assert(message->base.descriptor == &mumble_proto__voice_target__descriptor);
924 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
925 }
926 MumbleProto__VoiceTarget *
mumble_proto__voice_target__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)927 mumble_proto__voice_target__unpack
928 (ProtobufCAllocator *allocator,
929 size_t len,
930 const uint8_t *data)
931 {
932 return (MumbleProto__VoiceTarget *)
933 protobuf_c_message_unpack (&mumble_proto__voice_target__descriptor,
934 allocator, len, data);
935 }
mumble_proto__voice_target__free_unpacked(MumbleProto__VoiceTarget * message,ProtobufCAllocator * allocator)936 void mumble_proto__voice_target__free_unpacked
937 (MumbleProto__VoiceTarget *message,
938 ProtobufCAllocator *allocator)
939 {
940 assert(message->base.descriptor == &mumble_proto__voice_target__descriptor);
941 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
942 }
mumble_proto__permission_query__init(MumbleProto__PermissionQuery * message)943 void mumble_proto__permission_query__init
944 (MumbleProto__PermissionQuery *message)
945 {
946 static MumbleProto__PermissionQuery init_value = MUMBLE_PROTO__PERMISSION_QUERY__INIT;
947 *message = init_value;
948 }
mumble_proto__permission_query__get_packed_size(const MumbleProto__PermissionQuery * message)949 size_t mumble_proto__permission_query__get_packed_size
950 (const MumbleProto__PermissionQuery *message)
951 {
952 assert(message->base.descriptor == &mumble_proto__permission_query__descriptor);
953 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
954 }
mumble_proto__permission_query__pack(const MumbleProto__PermissionQuery * message,uint8_t * out)955 size_t mumble_proto__permission_query__pack
956 (const MumbleProto__PermissionQuery *message,
957 uint8_t *out)
958 {
959 assert(message->base.descriptor == &mumble_proto__permission_query__descriptor);
960 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
961 }
mumble_proto__permission_query__pack_to_buffer(const MumbleProto__PermissionQuery * message,ProtobufCBuffer * buffer)962 size_t mumble_proto__permission_query__pack_to_buffer
963 (const MumbleProto__PermissionQuery *message,
964 ProtobufCBuffer *buffer)
965 {
966 assert(message->base.descriptor == &mumble_proto__permission_query__descriptor);
967 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
968 }
969 MumbleProto__PermissionQuery *
mumble_proto__permission_query__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)970 mumble_proto__permission_query__unpack
971 (ProtobufCAllocator *allocator,
972 size_t len,
973 const uint8_t *data)
974 {
975 return (MumbleProto__PermissionQuery *)
976 protobuf_c_message_unpack (&mumble_proto__permission_query__descriptor,
977 allocator, len, data);
978 }
mumble_proto__permission_query__free_unpacked(MumbleProto__PermissionQuery * message,ProtobufCAllocator * allocator)979 void mumble_proto__permission_query__free_unpacked
980 (MumbleProto__PermissionQuery *message,
981 ProtobufCAllocator *allocator)
982 {
983 assert(message->base.descriptor == &mumble_proto__permission_query__descriptor);
984 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
985 }
mumble_proto__codec_version__init(MumbleProto__CodecVersion * message)986 void mumble_proto__codec_version__init
987 (MumbleProto__CodecVersion *message)
988 {
989 static MumbleProto__CodecVersion init_value = MUMBLE_PROTO__CODEC_VERSION__INIT;
990 *message = init_value;
991 }
mumble_proto__codec_version__get_packed_size(const MumbleProto__CodecVersion * message)992 size_t mumble_proto__codec_version__get_packed_size
993 (const MumbleProto__CodecVersion *message)
994 {
995 assert(message->base.descriptor == &mumble_proto__codec_version__descriptor);
996 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
997 }
mumble_proto__codec_version__pack(const MumbleProto__CodecVersion * message,uint8_t * out)998 size_t mumble_proto__codec_version__pack
999 (const MumbleProto__CodecVersion *message,
1000 uint8_t *out)
1001 {
1002 assert(message->base.descriptor == &mumble_proto__codec_version__descriptor);
1003 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1004 }
mumble_proto__codec_version__pack_to_buffer(const MumbleProto__CodecVersion * message,ProtobufCBuffer * buffer)1005 size_t mumble_proto__codec_version__pack_to_buffer
1006 (const MumbleProto__CodecVersion *message,
1007 ProtobufCBuffer *buffer)
1008 {
1009 assert(message->base.descriptor == &mumble_proto__codec_version__descriptor);
1010 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1011 }
1012 MumbleProto__CodecVersion *
mumble_proto__codec_version__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)1013 mumble_proto__codec_version__unpack
1014 (ProtobufCAllocator *allocator,
1015 size_t len,
1016 const uint8_t *data)
1017 {
1018 return (MumbleProto__CodecVersion *)
1019 protobuf_c_message_unpack (&mumble_proto__codec_version__descriptor,
1020 allocator, len, data);
1021 }
mumble_proto__codec_version__free_unpacked(MumbleProto__CodecVersion * message,ProtobufCAllocator * allocator)1022 void mumble_proto__codec_version__free_unpacked
1023 (MumbleProto__CodecVersion *message,
1024 ProtobufCAllocator *allocator)
1025 {
1026 assert(message->base.descriptor == &mumble_proto__codec_version__descriptor);
1027 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1028 }
mumble_proto__user_stats__stats__init(MumbleProto__UserStats__Stats * message)1029 void mumble_proto__user_stats__stats__init
1030 (MumbleProto__UserStats__Stats *message)
1031 {
1032 static MumbleProto__UserStats__Stats init_value = MUMBLE_PROTO__USER_STATS__STATS__INIT;
1033 *message = init_value;
1034 }
mumble_proto__user_stats__init(MumbleProto__UserStats * message)1035 void mumble_proto__user_stats__init
1036 (MumbleProto__UserStats *message)
1037 {
1038 static MumbleProto__UserStats init_value = MUMBLE_PROTO__USER_STATS__INIT;
1039 *message = init_value;
1040 }
mumble_proto__user_stats__get_packed_size(const MumbleProto__UserStats * message)1041 size_t mumble_proto__user_stats__get_packed_size
1042 (const MumbleProto__UserStats *message)
1043 {
1044 assert(message->base.descriptor == &mumble_proto__user_stats__descriptor);
1045 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1046 }
mumble_proto__user_stats__pack(const MumbleProto__UserStats * message,uint8_t * out)1047 size_t mumble_proto__user_stats__pack
1048 (const MumbleProto__UserStats *message,
1049 uint8_t *out)
1050 {
1051 assert(message->base.descriptor == &mumble_proto__user_stats__descriptor);
1052 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1053 }
mumble_proto__user_stats__pack_to_buffer(const MumbleProto__UserStats * message,ProtobufCBuffer * buffer)1054 size_t mumble_proto__user_stats__pack_to_buffer
1055 (const MumbleProto__UserStats *message,
1056 ProtobufCBuffer *buffer)
1057 {
1058 assert(message->base.descriptor == &mumble_proto__user_stats__descriptor);
1059 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1060 }
1061 MumbleProto__UserStats *
mumble_proto__user_stats__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)1062 mumble_proto__user_stats__unpack
1063 (ProtobufCAllocator *allocator,
1064 size_t len,
1065 const uint8_t *data)
1066 {
1067 return (MumbleProto__UserStats *)
1068 protobuf_c_message_unpack (&mumble_proto__user_stats__descriptor,
1069 allocator, len, data);
1070 }
mumble_proto__user_stats__free_unpacked(MumbleProto__UserStats * message,ProtobufCAllocator * allocator)1071 void mumble_proto__user_stats__free_unpacked
1072 (MumbleProto__UserStats *message,
1073 ProtobufCAllocator *allocator)
1074 {
1075 assert(message->base.descriptor == &mumble_proto__user_stats__descriptor);
1076 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1077 }
mumble_proto__suggest_config__init(MumbleProto__SuggestConfig * message)1078 void mumble_proto__suggest_config__init
1079 (MumbleProto__SuggestConfig *message)
1080 {
1081 static MumbleProto__SuggestConfig init_value = MUMBLE_PROTO__SUGGEST_CONFIG__INIT;
1082 *message = init_value;
1083 }
mumble_proto__suggest_config__get_packed_size(const MumbleProto__SuggestConfig * message)1084 size_t mumble_proto__suggest_config__get_packed_size
1085 (const MumbleProto__SuggestConfig *message)
1086 {
1087 assert(message->base.descriptor == &mumble_proto__suggest_config__descriptor);
1088 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1089 }
mumble_proto__suggest_config__pack(const MumbleProto__SuggestConfig * message,uint8_t * out)1090 size_t mumble_proto__suggest_config__pack
1091 (const MumbleProto__SuggestConfig *message,
1092 uint8_t *out)
1093 {
1094 assert(message->base.descriptor == &mumble_proto__suggest_config__descriptor);
1095 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1096 }
mumble_proto__suggest_config__pack_to_buffer(const MumbleProto__SuggestConfig * message,ProtobufCBuffer * buffer)1097 size_t mumble_proto__suggest_config__pack_to_buffer
1098 (const MumbleProto__SuggestConfig *message,
1099 ProtobufCBuffer *buffer)
1100 {
1101 assert(message->base.descriptor == &mumble_proto__suggest_config__descriptor);
1102 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1103 }
1104 MumbleProto__SuggestConfig *
mumble_proto__suggest_config__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)1105 mumble_proto__suggest_config__unpack
1106 (ProtobufCAllocator *allocator,
1107 size_t len,
1108 const uint8_t *data)
1109 {
1110 return (MumbleProto__SuggestConfig *)
1111 protobuf_c_message_unpack (&mumble_proto__suggest_config__descriptor,
1112 allocator, len, data);
1113 }
mumble_proto__suggest_config__free_unpacked(MumbleProto__SuggestConfig * message,ProtobufCAllocator * allocator)1114 void mumble_proto__suggest_config__free_unpacked
1115 (MumbleProto__SuggestConfig *message,
1116 ProtobufCAllocator *allocator)
1117 {
1118 assert(message->base.descriptor == &mumble_proto__suggest_config__descriptor);
1119 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1120 }
mumble_proto__request_blob__init(MumbleProto__RequestBlob * message)1121 void mumble_proto__request_blob__init
1122 (MumbleProto__RequestBlob *message)
1123 {
1124 static MumbleProto__RequestBlob init_value = MUMBLE_PROTO__REQUEST_BLOB__INIT;
1125 *message = init_value;
1126 }
mumble_proto__request_blob__get_packed_size(const MumbleProto__RequestBlob * message)1127 size_t mumble_proto__request_blob__get_packed_size
1128 (const MumbleProto__RequestBlob *message)
1129 {
1130 assert(message->base.descriptor == &mumble_proto__request_blob__descriptor);
1131 return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1132 }
mumble_proto__request_blob__pack(const MumbleProto__RequestBlob * message,uint8_t * out)1133 size_t mumble_proto__request_blob__pack
1134 (const MumbleProto__RequestBlob *message,
1135 uint8_t *out)
1136 {
1137 assert(message->base.descriptor == &mumble_proto__request_blob__descriptor);
1138 return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1139 }
mumble_proto__request_blob__pack_to_buffer(const MumbleProto__RequestBlob * message,ProtobufCBuffer * buffer)1140 size_t mumble_proto__request_blob__pack_to_buffer
1141 (const MumbleProto__RequestBlob *message,
1142 ProtobufCBuffer *buffer)
1143 {
1144 assert(message->base.descriptor == &mumble_proto__request_blob__descriptor);
1145 return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1146 }
1147 MumbleProto__RequestBlob *
mumble_proto__request_blob__unpack(ProtobufCAllocator * allocator,size_t len,const uint8_t * data)1148 mumble_proto__request_blob__unpack
1149 (ProtobufCAllocator *allocator,
1150 size_t len,
1151 const uint8_t *data)
1152 {
1153 return (MumbleProto__RequestBlob *)
1154 protobuf_c_message_unpack (&mumble_proto__request_blob__descriptor,
1155 allocator, len, data);
1156 }
mumble_proto__request_blob__free_unpacked(MumbleProto__RequestBlob * message,ProtobufCAllocator * allocator)1157 void mumble_proto__request_blob__free_unpacked
1158 (MumbleProto__RequestBlob *message,
1159 ProtobufCAllocator *allocator)
1160 {
1161 assert(message->base.descriptor == &mumble_proto__request_blob__descriptor);
1162 protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1163 }
1164 static const ProtobufCFieldDescriptor mumble_proto__version__field_descriptors[4] =
1165 {
1166 {
1167 "version",
1168 1,
1169 PROTOBUF_C_LABEL_OPTIONAL,
1170 PROTOBUF_C_TYPE_UINT32,
1171 offsetof(MumbleProto__Version, has_version),
1172 offsetof(MumbleProto__Version, version),
1173 NULL,
1174 NULL,
1175 0, /* flags */
1176 0,NULL,NULL /* reserved1,reserved2, etc */
1177 },
1178 {
1179 "release",
1180 2,
1181 PROTOBUF_C_LABEL_OPTIONAL,
1182 PROTOBUF_C_TYPE_STRING,
1183 0, /* quantifier_offset */
1184 offsetof(MumbleProto__Version, release),
1185 NULL,
1186 NULL,
1187 0, /* flags */
1188 0,NULL,NULL /* reserved1,reserved2, etc */
1189 },
1190 {
1191 "os",
1192 3,
1193 PROTOBUF_C_LABEL_OPTIONAL,
1194 PROTOBUF_C_TYPE_STRING,
1195 0, /* quantifier_offset */
1196 offsetof(MumbleProto__Version, os),
1197 NULL,
1198 NULL,
1199 0, /* flags */
1200 0,NULL,NULL /* reserved1,reserved2, etc */
1201 },
1202 {
1203 "os_version",
1204 4,
1205 PROTOBUF_C_LABEL_OPTIONAL,
1206 PROTOBUF_C_TYPE_STRING,
1207 0, /* quantifier_offset */
1208 offsetof(MumbleProto__Version, os_version),
1209 NULL,
1210 NULL,
1211 0, /* flags */
1212 0,NULL,NULL /* reserved1,reserved2, etc */
1213 },
1214 };
1215 static const unsigned mumble_proto__version__field_indices_by_name[] = {
1216 2, /* field[2] = os */
1217 3, /* field[3] = os_version */
1218 1, /* field[1] = release */
1219 0, /* field[0] = version */
1220 };
1221 static const ProtobufCIntRange mumble_proto__version__number_ranges[1 + 1] =
1222 {
1223 { 1, 0 },
1224 { 0, 4 }
1225 };
1226 const ProtobufCMessageDescriptor mumble_proto__version__descriptor =
1227 {
1228 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1229 "MumbleProto.Version",
1230 "Version",
1231 "MumbleProto__Version",
1232 "MumbleProto",
1233 sizeof(MumbleProto__Version),
1234 4,
1235 mumble_proto__version__field_descriptors,
1236 mumble_proto__version__field_indices_by_name,
1237 1, mumble_proto__version__number_ranges,
1238 (ProtobufCMessageInit) mumble_proto__version__init,
1239 NULL,NULL,NULL /* reserved[123] */
1240 };
1241 static const ProtobufCFieldDescriptor mumble_proto__udptunnel__field_descriptors[1] =
1242 {
1243 {
1244 "packet",
1245 1,
1246 PROTOBUF_C_LABEL_REQUIRED,
1247 PROTOBUF_C_TYPE_BYTES,
1248 0, /* quantifier_offset */
1249 offsetof(MumbleProto__UDPTunnel, packet),
1250 NULL,
1251 NULL,
1252 0, /* flags */
1253 0,NULL,NULL /* reserved1,reserved2, etc */
1254 },
1255 };
1256 static const unsigned mumble_proto__udptunnel__field_indices_by_name[] = {
1257 0, /* field[0] = packet */
1258 };
1259 static const ProtobufCIntRange mumble_proto__udptunnel__number_ranges[1 + 1] =
1260 {
1261 { 1, 0 },
1262 { 0, 1 }
1263 };
1264 const ProtobufCMessageDescriptor mumble_proto__udptunnel__descriptor =
1265 {
1266 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1267 "MumbleProto.UDPTunnel",
1268 "UDPTunnel",
1269 "MumbleProto__UDPTunnel",
1270 "MumbleProto",
1271 sizeof(MumbleProto__UDPTunnel),
1272 1,
1273 mumble_proto__udptunnel__field_descriptors,
1274 mumble_proto__udptunnel__field_indices_by_name,
1275 1, mumble_proto__udptunnel__number_ranges,
1276 (ProtobufCMessageInit) mumble_proto__udptunnel__init,
1277 NULL,NULL,NULL /* reserved[123] */
1278 };
1279 static const protobuf_c_boolean mumble_proto__authenticate__opus__default_value = 0;
1280 static const ProtobufCFieldDescriptor mumble_proto__authenticate__field_descriptors[5] =
1281 {
1282 {
1283 "username",
1284 1,
1285 PROTOBUF_C_LABEL_OPTIONAL,
1286 PROTOBUF_C_TYPE_STRING,
1287 0, /* quantifier_offset */
1288 offsetof(MumbleProto__Authenticate, username),
1289 NULL,
1290 NULL,
1291 0, /* flags */
1292 0,NULL,NULL /* reserved1,reserved2, etc */
1293 },
1294 {
1295 "password",
1296 2,
1297 PROTOBUF_C_LABEL_OPTIONAL,
1298 PROTOBUF_C_TYPE_STRING,
1299 0, /* quantifier_offset */
1300 offsetof(MumbleProto__Authenticate, password),
1301 NULL,
1302 NULL,
1303 0, /* flags */
1304 0,NULL,NULL /* reserved1,reserved2, etc */
1305 },
1306 {
1307 "tokens",
1308 3,
1309 PROTOBUF_C_LABEL_REPEATED,
1310 PROTOBUF_C_TYPE_STRING,
1311 offsetof(MumbleProto__Authenticate, n_tokens),
1312 offsetof(MumbleProto__Authenticate, tokens),
1313 NULL,
1314 NULL,
1315 0, /* flags */
1316 0,NULL,NULL /* reserved1,reserved2, etc */
1317 },
1318 {
1319 "celt_versions",
1320 4,
1321 PROTOBUF_C_LABEL_REPEATED,
1322 PROTOBUF_C_TYPE_INT32,
1323 offsetof(MumbleProto__Authenticate, n_celt_versions),
1324 offsetof(MumbleProto__Authenticate, celt_versions),
1325 NULL,
1326 NULL,
1327 0, /* flags */
1328 0,NULL,NULL /* reserved1,reserved2, etc */
1329 },
1330 {
1331 "opus",
1332 5,
1333 PROTOBUF_C_LABEL_OPTIONAL,
1334 PROTOBUF_C_TYPE_BOOL,
1335 offsetof(MumbleProto__Authenticate, has_opus),
1336 offsetof(MumbleProto__Authenticate, opus),
1337 NULL,
1338 &mumble_proto__authenticate__opus__default_value,
1339 0, /* flags */
1340 0,NULL,NULL /* reserved1,reserved2, etc */
1341 },
1342 };
1343 static const unsigned mumble_proto__authenticate__field_indices_by_name[] = {
1344 3, /* field[3] = celt_versions */
1345 4, /* field[4] = opus */
1346 1, /* field[1] = password */
1347 2, /* field[2] = tokens */
1348 0, /* field[0] = username */
1349 };
1350 static const ProtobufCIntRange mumble_proto__authenticate__number_ranges[1 + 1] =
1351 {
1352 { 1, 0 },
1353 { 0, 5 }
1354 };
1355 const ProtobufCMessageDescriptor mumble_proto__authenticate__descriptor =
1356 {
1357 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1358 "MumbleProto.Authenticate",
1359 "Authenticate",
1360 "MumbleProto__Authenticate",
1361 "MumbleProto",
1362 sizeof(MumbleProto__Authenticate),
1363 5,
1364 mumble_proto__authenticate__field_descriptors,
1365 mumble_proto__authenticate__field_indices_by_name,
1366 1, mumble_proto__authenticate__number_ranges,
1367 (ProtobufCMessageInit) mumble_proto__authenticate__init,
1368 NULL,NULL,NULL /* reserved[123] */
1369 };
1370 static const ProtobufCFieldDescriptor mumble_proto__ping__field_descriptors[11] =
1371 {
1372 {
1373 "timestamp",
1374 1,
1375 PROTOBUF_C_LABEL_OPTIONAL,
1376 PROTOBUF_C_TYPE_UINT64,
1377 offsetof(MumbleProto__Ping, has_timestamp),
1378 offsetof(MumbleProto__Ping, timestamp),
1379 NULL,
1380 NULL,
1381 0, /* flags */
1382 0,NULL,NULL /* reserved1,reserved2, etc */
1383 },
1384 {
1385 "good",
1386 2,
1387 PROTOBUF_C_LABEL_OPTIONAL,
1388 PROTOBUF_C_TYPE_UINT32,
1389 offsetof(MumbleProto__Ping, has_good),
1390 offsetof(MumbleProto__Ping, good),
1391 NULL,
1392 NULL,
1393 0, /* flags */
1394 0,NULL,NULL /* reserved1,reserved2, etc */
1395 },
1396 {
1397 "late",
1398 3,
1399 PROTOBUF_C_LABEL_OPTIONAL,
1400 PROTOBUF_C_TYPE_UINT32,
1401 offsetof(MumbleProto__Ping, has_late),
1402 offsetof(MumbleProto__Ping, late),
1403 NULL,
1404 NULL,
1405 0, /* flags */
1406 0,NULL,NULL /* reserved1,reserved2, etc */
1407 },
1408 {
1409 "lost",
1410 4,
1411 PROTOBUF_C_LABEL_OPTIONAL,
1412 PROTOBUF_C_TYPE_UINT32,
1413 offsetof(MumbleProto__Ping, has_lost),
1414 offsetof(MumbleProto__Ping, lost),
1415 NULL,
1416 NULL,
1417 0, /* flags */
1418 0,NULL,NULL /* reserved1,reserved2, etc */
1419 },
1420 {
1421 "resync",
1422 5,
1423 PROTOBUF_C_LABEL_OPTIONAL,
1424 PROTOBUF_C_TYPE_UINT32,
1425 offsetof(MumbleProto__Ping, has_resync),
1426 offsetof(MumbleProto__Ping, resync),
1427 NULL,
1428 NULL,
1429 0, /* flags */
1430 0,NULL,NULL /* reserved1,reserved2, etc */
1431 },
1432 {
1433 "udp_packets",
1434 6,
1435 PROTOBUF_C_LABEL_OPTIONAL,
1436 PROTOBUF_C_TYPE_UINT32,
1437 offsetof(MumbleProto__Ping, has_udp_packets),
1438 offsetof(MumbleProto__Ping, udp_packets),
1439 NULL,
1440 NULL,
1441 0, /* flags */
1442 0,NULL,NULL /* reserved1,reserved2, etc */
1443 },
1444 {
1445 "tcp_packets",
1446 7,
1447 PROTOBUF_C_LABEL_OPTIONAL,
1448 PROTOBUF_C_TYPE_UINT32,
1449 offsetof(MumbleProto__Ping, has_tcp_packets),
1450 offsetof(MumbleProto__Ping, tcp_packets),
1451 NULL,
1452 NULL,
1453 0, /* flags */
1454 0,NULL,NULL /* reserved1,reserved2, etc */
1455 },
1456 {
1457 "udp_ping_avg",
1458 8,
1459 PROTOBUF_C_LABEL_OPTIONAL,
1460 PROTOBUF_C_TYPE_FLOAT,
1461 offsetof(MumbleProto__Ping, has_udp_ping_avg),
1462 offsetof(MumbleProto__Ping, udp_ping_avg),
1463 NULL,
1464 NULL,
1465 0, /* flags */
1466 0,NULL,NULL /* reserved1,reserved2, etc */
1467 },
1468 {
1469 "udp_ping_var",
1470 9,
1471 PROTOBUF_C_LABEL_OPTIONAL,
1472 PROTOBUF_C_TYPE_FLOAT,
1473 offsetof(MumbleProto__Ping, has_udp_ping_var),
1474 offsetof(MumbleProto__Ping, udp_ping_var),
1475 NULL,
1476 NULL,
1477 0, /* flags */
1478 0,NULL,NULL /* reserved1,reserved2, etc */
1479 },
1480 {
1481 "tcp_ping_avg",
1482 10,
1483 PROTOBUF_C_LABEL_OPTIONAL,
1484 PROTOBUF_C_TYPE_FLOAT,
1485 offsetof(MumbleProto__Ping, has_tcp_ping_avg),
1486 offsetof(MumbleProto__Ping, tcp_ping_avg),
1487 NULL,
1488 NULL,
1489 0, /* flags */
1490 0,NULL,NULL /* reserved1,reserved2, etc */
1491 },
1492 {
1493 "tcp_ping_var",
1494 11,
1495 PROTOBUF_C_LABEL_OPTIONAL,
1496 PROTOBUF_C_TYPE_FLOAT,
1497 offsetof(MumbleProto__Ping, has_tcp_ping_var),
1498 offsetof(MumbleProto__Ping, tcp_ping_var),
1499 NULL,
1500 NULL,
1501 0, /* flags */
1502 0,NULL,NULL /* reserved1,reserved2, etc */
1503 },
1504 };
1505 static const unsigned mumble_proto__ping__field_indices_by_name[] = {
1506 1, /* field[1] = good */
1507 2, /* field[2] = late */
1508 3, /* field[3] = lost */
1509 4, /* field[4] = resync */
1510 6, /* field[6] = tcp_packets */
1511 9, /* field[9] = tcp_ping_avg */
1512 10, /* field[10] = tcp_ping_var */
1513 0, /* field[0] = timestamp */
1514 5, /* field[5] = udp_packets */
1515 7, /* field[7] = udp_ping_avg */
1516 8, /* field[8] = udp_ping_var */
1517 };
1518 static const ProtobufCIntRange mumble_proto__ping__number_ranges[1 + 1] =
1519 {
1520 { 1, 0 },
1521 { 0, 11 }
1522 };
1523 const ProtobufCMessageDescriptor mumble_proto__ping__descriptor =
1524 {
1525 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1526 "MumbleProto.Ping",
1527 "Ping",
1528 "MumbleProto__Ping",
1529 "MumbleProto",
1530 sizeof(MumbleProto__Ping),
1531 11,
1532 mumble_proto__ping__field_descriptors,
1533 mumble_proto__ping__field_indices_by_name,
1534 1, mumble_proto__ping__number_ranges,
1535 (ProtobufCMessageInit) mumble_proto__ping__init,
1536 NULL,NULL,NULL /* reserved[123] */
1537 };
1538 const ProtobufCEnumValue mumble_proto__reject__reject_type__enum_values_by_number[8] =
1539 {
1540 { "None", "MUMBLE_PROTO__REJECT__REJECT_TYPE__None", 0 },
1541 { "WrongVersion", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongVersion", 1 },
1542 { "InvalidUsername", "MUMBLE_PROTO__REJECT__REJECT_TYPE__InvalidUsername", 2 },
1543 { "WrongUserPW", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongUserPW", 3 },
1544 { "WrongServerPW", "MUMBLE_PROTO__REJECT__REJECT_TYPE__WrongServerPW", 4 },
1545 { "UsernameInUse", "MUMBLE_PROTO__REJECT__REJECT_TYPE__UsernameInUse", 5 },
1546 { "ServerFull", "MUMBLE_PROTO__REJECT__REJECT_TYPE__ServerFull", 6 },
1547 { "NoCertificate", "MUMBLE_PROTO__REJECT__REJECT_TYPE__NoCertificate", 7 },
1548 };
1549 static const ProtobufCIntRange mumble_proto__reject__reject_type__value_ranges[] = {
1550 {0, 0},{0, 8}
1551 };
1552 const ProtobufCEnumValueIndex mumble_proto__reject__reject_type__enum_values_by_name[8] =
1553 {
1554 { "InvalidUsername", 2 },
1555 { "NoCertificate", 7 },
1556 { "None", 0 },
1557 { "ServerFull", 6 },
1558 { "UsernameInUse", 5 },
1559 { "WrongServerPW", 4 },
1560 { "WrongUserPW", 3 },
1561 { "WrongVersion", 1 },
1562 };
1563 const ProtobufCEnumDescriptor mumble_proto__reject__reject_type__descriptor =
1564 {
1565 PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
1566 "MumbleProto.Reject.RejectType",
1567 "RejectType",
1568 "MumbleProto__Reject__RejectType",
1569 "MumbleProto",
1570 8,
1571 mumble_proto__reject__reject_type__enum_values_by_number,
1572 8,
1573 mumble_proto__reject__reject_type__enum_values_by_name,
1574 1,
1575 mumble_proto__reject__reject_type__value_ranges,
1576 NULL,NULL,NULL,NULL /* reserved[1234] */
1577 };
1578 static const ProtobufCFieldDescriptor mumble_proto__reject__field_descriptors[2] =
1579 {
1580 {
1581 "type",
1582 1,
1583 PROTOBUF_C_LABEL_OPTIONAL,
1584 PROTOBUF_C_TYPE_ENUM,
1585 offsetof(MumbleProto__Reject, has_type),
1586 offsetof(MumbleProto__Reject, type),
1587 &mumble_proto__reject__reject_type__descriptor,
1588 NULL,
1589 0, /* flags */
1590 0,NULL,NULL /* reserved1,reserved2, etc */
1591 },
1592 {
1593 "reason",
1594 2,
1595 PROTOBUF_C_LABEL_OPTIONAL,
1596 PROTOBUF_C_TYPE_STRING,
1597 0, /* quantifier_offset */
1598 offsetof(MumbleProto__Reject, reason),
1599 NULL,
1600 NULL,
1601 0, /* flags */
1602 0,NULL,NULL /* reserved1,reserved2, etc */
1603 },
1604 };
1605 static const unsigned mumble_proto__reject__field_indices_by_name[] = {
1606 1, /* field[1] = reason */
1607 0, /* field[0] = type */
1608 };
1609 static const ProtobufCIntRange mumble_proto__reject__number_ranges[1 + 1] =
1610 {
1611 { 1, 0 },
1612 { 0, 2 }
1613 };
1614 const ProtobufCMessageDescriptor mumble_proto__reject__descriptor =
1615 {
1616 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1617 "MumbleProto.Reject",
1618 "Reject",
1619 "MumbleProto__Reject",
1620 "MumbleProto",
1621 sizeof(MumbleProto__Reject),
1622 2,
1623 mumble_proto__reject__field_descriptors,
1624 mumble_proto__reject__field_indices_by_name,
1625 1, mumble_proto__reject__number_ranges,
1626 (ProtobufCMessageInit) mumble_proto__reject__init,
1627 NULL,NULL,NULL /* reserved[123] */
1628 };
1629 static const ProtobufCFieldDescriptor mumble_proto__server_config__field_descriptors[5] =
1630 {
1631 {
1632 "max_bandwidth",
1633 1,
1634 PROTOBUF_C_LABEL_OPTIONAL,
1635 PROTOBUF_C_TYPE_UINT32,
1636 offsetof(MumbleProto__ServerConfig, has_max_bandwidth),
1637 offsetof(MumbleProto__ServerConfig, max_bandwidth),
1638 NULL,
1639 NULL,
1640 0, /* flags */
1641 0,NULL,NULL /* reserved1,reserved2, etc */
1642 },
1643 {
1644 "welcome_text",
1645 2,
1646 PROTOBUF_C_LABEL_OPTIONAL,
1647 PROTOBUF_C_TYPE_STRING,
1648 0, /* quantifier_offset */
1649 offsetof(MumbleProto__ServerConfig, welcome_text),
1650 NULL,
1651 NULL,
1652 0, /* flags */
1653 0,NULL,NULL /* reserved1,reserved2, etc */
1654 },
1655 {
1656 "allow_html",
1657 3,
1658 PROTOBUF_C_LABEL_OPTIONAL,
1659 PROTOBUF_C_TYPE_BOOL,
1660 offsetof(MumbleProto__ServerConfig, has_allow_html),
1661 offsetof(MumbleProto__ServerConfig, allow_html),
1662 NULL,
1663 NULL,
1664 0, /* flags */
1665 0,NULL,NULL /* reserved1,reserved2, etc */
1666 },
1667 {
1668 "message_length",
1669 4,
1670 PROTOBUF_C_LABEL_OPTIONAL,
1671 PROTOBUF_C_TYPE_UINT32,
1672 offsetof(MumbleProto__ServerConfig, has_message_length),
1673 offsetof(MumbleProto__ServerConfig, message_length),
1674 NULL,
1675 NULL,
1676 0, /* flags */
1677 0,NULL,NULL /* reserved1,reserved2, etc */
1678 },
1679 {
1680 "image_message_length",
1681 5,
1682 PROTOBUF_C_LABEL_OPTIONAL,
1683 PROTOBUF_C_TYPE_UINT32,
1684 offsetof(MumbleProto__ServerConfig, has_image_message_length),
1685 offsetof(MumbleProto__ServerConfig, image_message_length),
1686 NULL,
1687 NULL,
1688 0, /* flags */
1689 0,NULL,NULL /* reserved1,reserved2, etc */
1690 },
1691 };
1692 static const unsigned mumble_proto__server_config__field_indices_by_name[] = {
1693 2, /* field[2] = allow_html */
1694 4, /* field[4] = image_message_length */
1695 0, /* field[0] = max_bandwidth */
1696 3, /* field[3] = message_length */
1697 1, /* field[1] = welcome_text */
1698 };
1699 static const ProtobufCIntRange mumble_proto__server_config__number_ranges[1 + 1] =
1700 {
1701 { 1, 0 },
1702 { 0, 5 }
1703 };
1704 const ProtobufCMessageDescriptor mumble_proto__server_config__descriptor =
1705 {
1706 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1707 "MumbleProto.ServerConfig",
1708 "ServerConfig",
1709 "MumbleProto__ServerConfig",
1710 "MumbleProto",
1711 sizeof(MumbleProto__ServerConfig),
1712 5,
1713 mumble_proto__server_config__field_descriptors,
1714 mumble_proto__server_config__field_indices_by_name,
1715 1, mumble_proto__server_config__number_ranges,
1716 (ProtobufCMessageInit) mumble_proto__server_config__init,
1717 NULL,NULL,NULL /* reserved[123] */
1718 };
1719 static const ProtobufCFieldDescriptor mumble_proto__server_sync__field_descriptors[4] =
1720 {
1721 {
1722 "session",
1723 1,
1724 PROTOBUF_C_LABEL_OPTIONAL,
1725 PROTOBUF_C_TYPE_UINT32,
1726 offsetof(MumbleProto__ServerSync, has_session),
1727 offsetof(MumbleProto__ServerSync, session),
1728 NULL,
1729 NULL,
1730 0, /* flags */
1731 0,NULL,NULL /* reserved1,reserved2, etc */
1732 },
1733 {
1734 "max_bandwidth",
1735 2,
1736 PROTOBUF_C_LABEL_OPTIONAL,
1737 PROTOBUF_C_TYPE_UINT32,
1738 offsetof(MumbleProto__ServerSync, has_max_bandwidth),
1739 offsetof(MumbleProto__ServerSync, max_bandwidth),
1740 NULL,
1741 NULL,
1742 0, /* flags */
1743 0,NULL,NULL /* reserved1,reserved2, etc */
1744 },
1745 {
1746 "welcome_text",
1747 3,
1748 PROTOBUF_C_LABEL_OPTIONAL,
1749 PROTOBUF_C_TYPE_STRING,
1750 0, /* quantifier_offset */
1751 offsetof(MumbleProto__ServerSync, welcome_text),
1752 NULL,
1753 NULL,
1754 0, /* flags */
1755 0,NULL,NULL /* reserved1,reserved2, etc */
1756 },
1757 {
1758 "permissions",
1759 4,
1760 PROTOBUF_C_LABEL_OPTIONAL,
1761 PROTOBUF_C_TYPE_UINT64,
1762 offsetof(MumbleProto__ServerSync, has_permissions),
1763 offsetof(MumbleProto__ServerSync, permissions),
1764 NULL,
1765 NULL,
1766 0, /* flags */
1767 0,NULL,NULL /* reserved1,reserved2, etc */
1768 },
1769 };
1770 static const unsigned mumble_proto__server_sync__field_indices_by_name[] = {
1771 1, /* field[1] = max_bandwidth */
1772 3, /* field[3] = permissions */
1773 0, /* field[0] = session */
1774 2, /* field[2] = welcome_text */
1775 };
1776 static const ProtobufCIntRange mumble_proto__server_sync__number_ranges[1 + 1] =
1777 {
1778 { 1, 0 },
1779 { 0, 4 }
1780 };
1781 const ProtobufCMessageDescriptor mumble_proto__server_sync__descriptor =
1782 {
1783 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1784 "MumbleProto.ServerSync",
1785 "ServerSync",
1786 "MumbleProto__ServerSync",
1787 "MumbleProto",
1788 sizeof(MumbleProto__ServerSync),
1789 4,
1790 mumble_proto__server_sync__field_descriptors,
1791 mumble_proto__server_sync__field_indices_by_name,
1792 1, mumble_proto__server_sync__number_ranges,
1793 (ProtobufCMessageInit) mumble_proto__server_sync__init,
1794 NULL,NULL,NULL /* reserved[123] */
1795 };
1796 static const ProtobufCFieldDescriptor mumble_proto__channel_remove__field_descriptors[1] =
1797 {
1798 {
1799 "channel_id",
1800 1,
1801 PROTOBUF_C_LABEL_REQUIRED,
1802 PROTOBUF_C_TYPE_UINT32,
1803 0, /* quantifier_offset */
1804 offsetof(MumbleProto__ChannelRemove, channel_id),
1805 NULL,
1806 NULL,
1807 0, /* flags */
1808 0,NULL,NULL /* reserved1,reserved2, etc */
1809 },
1810 };
1811 static const unsigned mumble_proto__channel_remove__field_indices_by_name[] = {
1812 0, /* field[0] = channel_id */
1813 };
1814 static const ProtobufCIntRange mumble_proto__channel_remove__number_ranges[1 + 1] =
1815 {
1816 { 1, 0 },
1817 { 0, 1 }
1818 };
1819 const ProtobufCMessageDescriptor mumble_proto__channel_remove__descriptor =
1820 {
1821 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1822 "MumbleProto.ChannelRemove",
1823 "ChannelRemove",
1824 "MumbleProto__ChannelRemove",
1825 "MumbleProto",
1826 sizeof(MumbleProto__ChannelRemove),
1827 1,
1828 mumble_proto__channel_remove__field_descriptors,
1829 mumble_proto__channel_remove__field_indices_by_name,
1830 1, mumble_proto__channel_remove__number_ranges,
1831 (ProtobufCMessageInit) mumble_proto__channel_remove__init,
1832 NULL,NULL,NULL /* reserved[123] */
1833 };
1834 static const protobuf_c_boolean mumble_proto__channel_state__temporary__default_value = 0;
1835 static const int32_t mumble_proto__channel_state__position__default_value = 0;
1836 static const ProtobufCFieldDescriptor mumble_proto__channel_state__field_descriptors[10] =
1837 {
1838 {
1839 "channel_id",
1840 1,
1841 PROTOBUF_C_LABEL_OPTIONAL,
1842 PROTOBUF_C_TYPE_UINT32,
1843 offsetof(MumbleProto__ChannelState, has_channel_id),
1844 offsetof(MumbleProto__ChannelState, channel_id),
1845 NULL,
1846 NULL,
1847 0, /* flags */
1848 0,NULL,NULL /* reserved1,reserved2, etc */
1849 },
1850 {
1851 "parent",
1852 2,
1853 PROTOBUF_C_LABEL_OPTIONAL,
1854 PROTOBUF_C_TYPE_UINT32,
1855 offsetof(MumbleProto__ChannelState, has_parent),
1856 offsetof(MumbleProto__ChannelState, parent),
1857 NULL,
1858 NULL,
1859 0, /* flags */
1860 0,NULL,NULL /* reserved1,reserved2, etc */
1861 },
1862 {
1863 "name",
1864 3,
1865 PROTOBUF_C_LABEL_OPTIONAL,
1866 PROTOBUF_C_TYPE_STRING,
1867 0, /* quantifier_offset */
1868 offsetof(MumbleProto__ChannelState, name),
1869 NULL,
1870 NULL,
1871 0, /* flags */
1872 0,NULL,NULL /* reserved1,reserved2, etc */
1873 },
1874 {
1875 "links",
1876 4,
1877 PROTOBUF_C_LABEL_REPEATED,
1878 PROTOBUF_C_TYPE_UINT32,
1879 offsetof(MumbleProto__ChannelState, n_links),
1880 offsetof(MumbleProto__ChannelState, links),
1881 NULL,
1882 NULL,
1883 0, /* flags */
1884 0,NULL,NULL /* reserved1,reserved2, etc */
1885 },
1886 {
1887 "description",
1888 5,
1889 PROTOBUF_C_LABEL_OPTIONAL,
1890 PROTOBUF_C_TYPE_STRING,
1891 0, /* quantifier_offset */
1892 offsetof(MumbleProto__ChannelState, description),
1893 NULL,
1894 NULL,
1895 0, /* flags */
1896 0,NULL,NULL /* reserved1,reserved2, etc */
1897 },
1898 {
1899 "links_add",
1900 6,
1901 PROTOBUF_C_LABEL_REPEATED,
1902 PROTOBUF_C_TYPE_UINT32,
1903 offsetof(MumbleProto__ChannelState, n_links_add),
1904 offsetof(MumbleProto__ChannelState, links_add),
1905 NULL,
1906 NULL,
1907 0, /* flags */
1908 0,NULL,NULL /* reserved1,reserved2, etc */
1909 },
1910 {
1911 "links_remove",
1912 7,
1913 PROTOBUF_C_LABEL_REPEATED,
1914 PROTOBUF_C_TYPE_UINT32,
1915 offsetof(MumbleProto__ChannelState, n_links_remove),
1916 offsetof(MumbleProto__ChannelState, links_remove),
1917 NULL,
1918 NULL,
1919 0, /* flags */
1920 0,NULL,NULL /* reserved1,reserved2, etc */
1921 },
1922 {
1923 "temporary",
1924 8,
1925 PROTOBUF_C_LABEL_OPTIONAL,
1926 PROTOBUF_C_TYPE_BOOL,
1927 offsetof(MumbleProto__ChannelState, has_temporary),
1928 offsetof(MumbleProto__ChannelState, temporary),
1929 NULL,
1930 &mumble_proto__channel_state__temporary__default_value,
1931 0, /* flags */
1932 0,NULL,NULL /* reserved1,reserved2, etc */
1933 },
1934 {
1935 "position",
1936 9,
1937 PROTOBUF_C_LABEL_OPTIONAL,
1938 PROTOBUF_C_TYPE_INT32,
1939 offsetof(MumbleProto__ChannelState, has_position),
1940 offsetof(MumbleProto__ChannelState, position),
1941 NULL,
1942 &mumble_proto__channel_state__position__default_value,
1943 0, /* flags */
1944 0,NULL,NULL /* reserved1,reserved2, etc */
1945 },
1946 {
1947 "description_hash",
1948 10,
1949 PROTOBUF_C_LABEL_OPTIONAL,
1950 PROTOBUF_C_TYPE_BYTES,
1951 offsetof(MumbleProto__ChannelState, has_description_hash),
1952 offsetof(MumbleProto__ChannelState, description_hash),
1953 NULL,
1954 NULL,
1955 0, /* flags */
1956 0,NULL,NULL /* reserved1,reserved2, etc */
1957 },
1958 };
1959 static const unsigned mumble_proto__channel_state__field_indices_by_name[] = {
1960 0, /* field[0] = channel_id */
1961 4, /* field[4] = description */
1962 9, /* field[9] = description_hash */
1963 3, /* field[3] = links */
1964 5, /* field[5] = links_add */
1965 6, /* field[6] = links_remove */
1966 2, /* field[2] = name */
1967 1, /* field[1] = parent */
1968 8, /* field[8] = position */
1969 7, /* field[7] = temporary */
1970 };
1971 static const ProtobufCIntRange mumble_proto__channel_state__number_ranges[1 + 1] =
1972 {
1973 { 1, 0 },
1974 { 0, 10 }
1975 };
1976 const ProtobufCMessageDescriptor mumble_proto__channel_state__descriptor =
1977 {
1978 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
1979 "MumbleProto.ChannelState",
1980 "ChannelState",
1981 "MumbleProto__ChannelState",
1982 "MumbleProto",
1983 sizeof(MumbleProto__ChannelState),
1984 10,
1985 mumble_proto__channel_state__field_descriptors,
1986 mumble_proto__channel_state__field_indices_by_name,
1987 1, mumble_proto__channel_state__number_ranges,
1988 (ProtobufCMessageInit) mumble_proto__channel_state__init,
1989 NULL,NULL,NULL /* reserved[123] */
1990 };
1991 static const ProtobufCFieldDescriptor mumble_proto__user_remove__field_descriptors[4] =
1992 {
1993 {
1994 "session",
1995 1,
1996 PROTOBUF_C_LABEL_REQUIRED,
1997 PROTOBUF_C_TYPE_UINT32,
1998 0, /* quantifier_offset */
1999 offsetof(MumbleProto__UserRemove, session),
2000 NULL,
2001 NULL,
2002 0, /* flags */
2003 0,NULL,NULL /* reserved1,reserved2, etc */
2004 },
2005 {
2006 "actor",
2007 2,
2008 PROTOBUF_C_LABEL_OPTIONAL,
2009 PROTOBUF_C_TYPE_UINT32,
2010 offsetof(MumbleProto__UserRemove, has_actor),
2011 offsetof(MumbleProto__UserRemove, actor),
2012 NULL,
2013 NULL,
2014 0, /* flags */
2015 0,NULL,NULL /* reserved1,reserved2, etc */
2016 },
2017 {
2018 "reason",
2019 3,
2020 PROTOBUF_C_LABEL_OPTIONAL,
2021 PROTOBUF_C_TYPE_STRING,
2022 0, /* quantifier_offset */
2023 offsetof(MumbleProto__UserRemove, reason),
2024 NULL,
2025 NULL,
2026 0, /* flags */
2027 0,NULL,NULL /* reserved1,reserved2, etc */
2028 },
2029 {
2030 "ban",
2031 4,
2032 PROTOBUF_C_LABEL_OPTIONAL,
2033 PROTOBUF_C_TYPE_BOOL,
2034 offsetof(MumbleProto__UserRemove, has_ban),
2035 offsetof(MumbleProto__UserRemove, ban),
2036 NULL,
2037 NULL,
2038 0, /* flags */
2039 0,NULL,NULL /* reserved1,reserved2, etc */
2040 },
2041 };
2042 static const unsigned mumble_proto__user_remove__field_indices_by_name[] = {
2043 1, /* field[1] = actor */
2044 3, /* field[3] = ban */
2045 2, /* field[2] = reason */
2046 0, /* field[0] = session */
2047 };
2048 static const ProtobufCIntRange mumble_proto__user_remove__number_ranges[1 + 1] =
2049 {
2050 { 1, 0 },
2051 { 0, 4 }
2052 };
2053 const ProtobufCMessageDescriptor mumble_proto__user_remove__descriptor =
2054 {
2055 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2056 "MumbleProto.UserRemove",
2057 "UserRemove",
2058 "MumbleProto__UserRemove",
2059 "MumbleProto",
2060 sizeof(MumbleProto__UserRemove),
2061 4,
2062 mumble_proto__user_remove__field_descriptors,
2063 mumble_proto__user_remove__field_indices_by_name,
2064 1, mumble_proto__user_remove__number_ranges,
2065 (ProtobufCMessageInit) mumble_proto__user_remove__init,
2066 NULL,NULL,NULL /* reserved[123] */
2067 };
2068 static const ProtobufCFieldDescriptor mumble_proto__user_state__field_descriptors[19] =
2069 {
2070 {
2071 "session",
2072 1,
2073 PROTOBUF_C_LABEL_OPTIONAL,
2074 PROTOBUF_C_TYPE_UINT32,
2075 offsetof(MumbleProto__UserState, has_session),
2076 offsetof(MumbleProto__UserState, session),
2077 NULL,
2078 NULL,
2079 0, /* flags */
2080 0,NULL,NULL /* reserved1,reserved2, etc */
2081 },
2082 {
2083 "actor",
2084 2,
2085 PROTOBUF_C_LABEL_OPTIONAL,
2086 PROTOBUF_C_TYPE_UINT32,
2087 offsetof(MumbleProto__UserState, has_actor),
2088 offsetof(MumbleProto__UserState, actor),
2089 NULL,
2090 NULL,
2091 0, /* flags */
2092 0,NULL,NULL /* reserved1,reserved2, etc */
2093 },
2094 {
2095 "name",
2096 3,
2097 PROTOBUF_C_LABEL_OPTIONAL,
2098 PROTOBUF_C_TYPE_STRING,
2099 0, /* quantifier_offset */
2100 offsetof(MumbleProto__UserState, name),
2101 NULL,
2102 NULL,
2103 0, /* flags */
2104 0,NULL,NULL /* reserved1,reserved2, etc */
2105 },
2106 {
2107 "user_id",
2108 4,
2109 PROTOBUF_C_LABEL_OPTIONAL,
2110 PROTOBUF_C_TYPE_UINT32,
2111 offsetof(MumbleProto__UserState, has_user_id),
2112 offsetof(MumbleProto__UserState, user_id),
2113 NULL,
2114 NULL,
2115 0, /* flags */
2116 0,NULL,NULL /* reserved1,reserved2, etc */
2117 },
2118 {
2119 "channel_id",
2120 5,
2121 PROTOBUF_C_LABEL_OPTIONAL,
2122 PROTOBUF_C_TYPE_UINT32,
2123 offsetof(MumbleProto__UserState, has_channel_id),
2124 offsetof(MumbleProto__UserState, channel_id),
2125 NULL,
2126 NULL,
2127 0, /* flags */
2128 0,NULL,NULL /* reserved1,reserved2, etc */
2129 },
2130 {
2131 "mute",
2132 6,
2133 PROTOBUF_C_LABEL_OPTIONAL,
2134 PROTOBUF_C_TYPE_BOOL,
2135 offsetof(MumbleProto__UserState, has_mute),
2136 offsetof(MumbleProto__UserState, mute),
2137 NULL,
2138 NULL,
2139 0, /* flags */
2140 0,NULL,NULL /* reserved1,reserved2, etc */
2141 },
2142 {
2143 "deaf",
2144 7,
2145 PROTOBUF_C_LABEL_OPTIONAL,
2146 PROTOBUF_C_TYPE_BOOL,
2147 offsetof(MumbleProto__UserState, has_deaf),
2148 offsetof(MumbleProto__UserState, deaf),
2149 NULL,
2150 NULL,
2151 0, /* flags */
2152 0,NULL,NULL /* reserved1,reserved2, etc */
2153 },
2154 {
2155 "suppress",
2156 8,
2157 PROTOBUF_C_LABEL_OPTIONAL,
2158 PROTOBUF_C_TYPE_BOOL,
2159 offsetof(MumbleProto__UserState, has_suppress),
2160 offsetof(MumbleProto__UserState, suppress),
2161 NULL,
2162 NULL,
2163 0, /* flags */
2164 0,NULL,NULL /* reserved1,reserved2, etc */
2165 },
2166 {
2167 "self_mute",
2168 9,
2169 PROTOBUF_C_LABEL_OPTIONAL,
2170 PROTOBUF_C_TYPE_BOOL,
2171 offsetof(MumbleProto__UserState, has_self_mute),
2172 offsetof(MumbleProto__UserState, self_mute),
2173 NULL,
2174 NULL,
2175 0, /* flags */
2176 0,NULL,NULL /* reserved1,reserved2, etc */
2177 },
2178 {
2179 "self_deaf",
2180 10,
2181 PROTOBUF_C_LABEL_OPTIONAL,
2182 PROTOBUF_C_TYPE_BOOL,
2183 offsetof(MumbleProto__UserState, has_self_deaf),
2184 offsetof(MumbleProto__UserState, self_deaf),
2185 NULL,
2186 NULL,
2187 0, /* flags */
2188 0,NULL,NULL /* reserved1,reserved2, etc */
2189 },
2190 {
2191 "texture",
2192 11,
2193 PROTOBUF_C_LABEL_OPTIONAL,
2194 PROTOBUF_C_TYPE_BYTES,
2195 offsetof(MumbleProto__UserState, has_texture),
2196 offsetof(MumbleProto__UserState, texture),
2197 NULL,
2198 NULL,
2199 0, /* flags */
2200 0,NULL,NULL /* reserved1,reserved2, etc */
2201 },
2202 {
2203 "plugin_context",
2204 12,
2205 PROTOBUF_C_LABEL_OPTIONAL,
2206 PROTOBUF_C_TYPE_BYTES,
2207 offsetof(MumbleProto__UserState, has_plugin_context),
2208 offsetof(MumbleProto__UserState, plugin_context),
2209 NULL,
2210 NULL,
2211 0, /* flags */
2212 0,NULL,NULL /* reserved1,reserved2, etc */
2213 },
2214 {
2215 "plugin_identity",
2216 13,
2217 PROTOBUF_C_LABEL_OPTIONAL,
2218 PROTOBUF_C_TYPE_STRING,
2219 0, /* quantifier_offset */
2220 offsetof(MumbleProto__UserState, plugin_identity),
2221 NULL,
2222 NULL,
2223 0, /* flags */
2224 0,NULL,NULL /* reserved1,reserved2, etc */
2225 },
2226 {
2227 "comment",
2228 14,
2229 PROTOBUF_C_LABEL_OPTIONAL,
2230 PROTOBUF_C_TYPE_STRING,
2231 0, /* quantifier_offset */
2232 offsetof(MumbleProto__UserState, comment),
2233 NULL,
2234 NULL,
2235 0, /* flags */
2236 0,NULL,NULL /* reserved1,reserved2, etc */
2237 },
2238 {
2239 "hash",
2240 15,
2241 PROTOBUF_C_LABEL_OPTIONAL,
2242 PROTOBUF_C_TYPE_STRING,
2243 0, /* quantifier_offset */
2244 offsetof(MumbleProto__UserState, hash),
2245 NULL,
2246 NULL,
2247 0, /* flags */
2248 0,NULL,NULL /* reserved1,reserved2, etc */
2249 },
2250 {
2251 "comment_hash",
2252 16,
2253 PROTOBUF_C_LABEL_OPTIONAL,
2254 PROTOBUF_C_TYPE_BYTES,
2255 offsetof(MumbleProto__UserState, has_comment_hash),
2256 offsetof(MumbleProto__UserState, comment_hash),
2257 NULL,
2258 NULL,
2259 0, /* flags */
2260 0,NULL,NULL /* reserved1,reserved2, etc */
2261 },
2262 {
2263 "texture_hash",
2264 17,
2265 PROTOBUF_C_LABEL_OPTIONAL,
2266 PROTOBUF_C_TYPE_BYTES,
2267 offsetof(MumbleProto__UserState, has_texture_hash),
2268 offsetof(MumbleProto__UserState, texture_hash),
2269 NULL,
2270 NULL,
2271 0, /* flags */
2272 0,NULL,NULL /* reserved1,reserved2, etc */
2273 },
2274 {
2275 "priority_speaker",
2276 18,
2277 PROTOBUF_C_LABEL_OPTIONAL,
2278 PROTOBUF_C_TYPE_BOOL,
2279 offsetof(MumbleProto__UserState, has_priority_speaker),
2280 offsetof(MumbleProto__UserState, priority_speaker),
2281 NULL,
2282 NULL,
2283 0, /* flags */
2284 0,NULL,NULL /* reserved1,reserved2, etc */
2285 },
2286 {
2287 "recording",
2288 19,
2289 PROTOBUF_C_LABEL_OPTIONAL,
2290 PROTOBUF_C_TYPE_BOOL,
2291 offsetof(MumbleProto__UserState, has_recording),
2292 offsetof(MumbleProto__UserState, recording),
2293 NULL,
2294 NULL,
2295 0, /* flags */
2296 0,NULL,NULL /* reserved1,reserved2, etc */
2297 },
2298 };
2299 static const unsigned mumble_proto__user_state__field_indices_by_name[] = {
2300 1, /* field[1] = actor */
2301 4, /* field[4] = channel_id */
2302 13, /* field[13] = comment */
2303 15, /* field[15] = comment_hash */
2304 6, /* field[6] = deaf */
2305 14, /* field[14] = hash */
2306 5, /* field[5] = mute */
2307 2, /* field[2] = name */
2308 11, /* field[11] = plugin_context */
2309 12, /* field[12] = plugin_identity */
2310 17, /* field[17] = priority_speaker */
2311 18, /* field[18] = recording */
2312 9, /* field[9] = self_deaf */
2313 8, /* field[8] = self_mute */
2314 0, /* field[0] = session */
2315 7, /* field[7] = suppress */
2316 10, /* field[10] = texture */
2317 16, /* field[16] = texture_hash */
2318 3, /* field[3] = user_id */
2319 };
2320 static const ProtobufCIntRange mumble_proto__user_state__number_ranges[1 + 1] =
2321 {
2322 { 1, 0 },
2323 { 0, 19 }
2324 };
2325 const ProtobufCMessageDescriptor mumble_proto__user_state__descriptor =
2326 {
2327 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2328 "MumbleProto.UserState",
2329 "UserState",
2330 "MumbleProto__UserState",
2331 "MumbleProto",
2332 sizeof(MumbleProto__UserState),
2333 19,
2334 mumble_proto__user_state__field_descriptors,
2335 mumble_proto__user_state__field_indices_by_name,
2336 1, mumble_proto__user_state__number_ranges,
2337 (ProtobufCMessageInit) mumble_proto__user_state__init,
2338 NULL,NULL,NULL /* reserved[123] */
2339 };
2340 static const ProtobufCFieldDescriptor mumble_proto__ban_list__ban_entry__field_descriptors[7] =
2341 {
2342 {
2343 "address",
2344 1,
2345 PROTOBUF_C_LABEL_REQUIRED,
2346 PROTOBUF_C_TYPE_BYTES,
2347 0, /* quantifier_offset */
2348 offsetof(MumbleProto__BanList__BanEntry, address),
2349 NULL,
2350 NULL,
2351 0, /* flags */
2352 0,NULL,NULL /* reserved1,reserved2, etc */
2353 },
2354 {
2355 "mask",
2356 2,
2357 PROTOBUF_C_LABEL_REQUIRED,
2358 PROTOBUF_C_TYPE_UINT32,
2359 0, /* quantifier_offset */
2360 offsetof(MumbleProto__BanList__BanEntry, mask),
2361 NULL,
2362 NULL,
2363 0, /* flags */
2364 0,NULL,NULL /* reserved1,reserved2, etc */
2365 },
2366 {
2367 "name",
2368 3,
2369 PROTOBUF_C_LABEL_OPTIONAL,
2370 PROTOBUF_C_TYPE_STRING,
2371 0, /* quantifier_offset */
2372 offsetof(MumbleProto__BanList__BanEntry, name),
2373 NULL,
2374 NULL,
2375 0, /* flags */
2376 0,NULL,NULL /* reserved1,reserved2, etc */
2377 },
2378 {
2379 "hash",
2380 4,
2381 PROTOBUF_C_LABEL_OPTIONAL,
2382 PROTOBUF_C_TYPE_STRING,
2383 0, /* quantifier_offset */
2384 offsetof(MumbleProto__BanList__BanEntry, hash),
2385 NULL,
2386 NULL,
2387 0, /* flags */
2388 0,NULL,NULL /* reserved1,reserved2, etc */
2389 },
2390 {
2391 "reason",
2392 5,
2393 PROTOBUF_C_LABEL_OPTIONAL,
2394 PROTOBUF_C_TYPE_STRING,
2395 0, /* quantifier_offset */
2396 offsetof(MumbleProto__BanList__BanEntry, reason),
2397 NULL,
2398 NULL,
2399 0, /* flags */
2400 0,NULL,NULL /* reserved1,reserved2, etc */
2401 },
2402 {
2403 "start",
2404 6,
2405 PROTOBUF_C_LABEL_OPTIONAL,
2406 PROTOBUF_C_TYPE_STRING,
2407 0, /* quantifier_offset */
2408 offsetof(MumbleProto__BanList__BanEntry, start),
2409 NULL,
2410 NULL,
2411 0, /* flags */
2412 0,NULL,NULL /* reserved1,reserved2, etc */
2413 },
2414 {
2415 "duration",
2416 7,
2417 PROTOBUF_C_LABEL_OPTIONAL,
2418 PROTOBUF_C_TYPE_UINT32,
2419 offsetof(MumbleProto__BanList__BanEntry, has_duration),
2420 offsetof(MumbleProto__BanList__BanEntry, duration),
2421 NULL,
2422 NULL,
2423 0, /* flags */
2424 0,NULL,NULL /* reserved1,reserved2, etc */
2425 },
2426 };
2427 static const unsigned mumble_proto__ban_list__ban_entry__field_indices_by_name[] = {
2428 0, /* field[0] = address */
2429 6, /* field[6] = duration */
2430 3, /* field[3] = hash */
2431 1, /* field[1] = mask */
2432 2, /* field[2] = name */
2433 4, /* field[4] = reason */
2434 5, /* field[5] = start */
2435 };
2436 static const ProtobufCIntRange mumble_proto__ban_list__ban_entry__number_ranges[1 + 1] =
2437 {
2438 { 1, 0 },
2439 { 0, 7 }
2440 };
2441 const ProtobufCMessageDescriptor mumble_proto__ban_list__ban_entry__descriptor =
2442 {
2443 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2444 "MumbleProto.BanList.BanEntry",
2445 "BanEntry",
2446 "MumbleProto__BanList__BanEntry",
2447 "MumbleProto",
2448 sizeof(MumbleProto__BanList__BanEntry),
2449 7,
2450 mumble_proto__ban_list__ban_entry__field_descriptors,
2451 mumble_proto__ban_list__ban_entry__field_indices_by_name,
2452 1, mumble_proto__ban_list__ban_entry__number_ranges,
2453 (ProtobufCMessageInit) mumble_proto__ban_list__ban_entry__init,
2454 NULL,NULL,NULL /* reserved[123] */
2455 };
2456 static const protobuf_c_boolean mumble_proto__ban_list__query__default_value = 0;
2457 static const ProtobufCFieldDescriptor mumble_proto__ban_list__field_descriptors[2] =
2458 {
2459 {
2460 "bans",
2461 1,
2462 PROTOBUF_C_LABEL_REPEATED,
2463 PROTOBUF_C_TYPE_MESSAGE,
2464 offsetof(MumbleProto__BanList, n_bans),
2465 offsetof(MumbleProto__BanList, bans),
2466 &mumble_proto__ban_list__ban_entry__descriptor,
2467 NULL,
2468 0, /* flags */
2469 0,NULL,NULL /* reserved1,reserved2, etc */
2470 },
2471 {
2472 "query",
2473 2,
2474 PROTOBUF_C_LABEL_OPTIONAL,
2475 PROTOBUF_C_TYPE_BOOL,
2476 offsetof(MumbleProto__BanList, has_query),
2477 offsetof(MumbleProto__BanList, query),
2478 NULL,
2479 &mumble_proto__ban_list__query__default_value,
2480 0, /* flags */
2481 0,NULL,NULL /* reserved1,reserved2, etc */
2482 },
2483 };
2484 static const unsigned mumble_proto__ban_list__field_indices_by_name[] = {
2485 0, /* field[0] = bans */
2486 1, /* field[1] = query */
2487 };
2488 static const ProtobufCIntRange mumble_proto__ban_list__number_ranges[1 + 1] =
2489 {
2490 { 1, 0 },
2491 { 0, 2 }
2492 };
2493 const ProtobufCMessageDescriptor mumble_proto__ban_list__descriptor =
2494 {
2495 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2496 "MumbleProto.BanList",
2497 "BanList",
2498 "MumbleProto__BanList",
2499 "MumbleProto",
2500 sizeof(MumbleProto__BanList),
2501 2,
2502 mumble_proto__ban_list__field_descriptors,
2503 mumble_proto__ban_list__field_indices_by_name,
2504 1, mumble_proto__ban_list__number_ranges,
2505 (ProtobufCMessageInit) mumble_proto__ban_list__init,
2506 NULL,NULL,NULL /* reserved[123] */
2507 };
2508 static const ProtobufCFieldDescriptor mumble_proto__text_message__field_descriptors[5] =
2509 {
2510 {
2511 "actor",
2512 1,
2513 PROTOBUF_C_LABEL_OPTIONAL,
2514 PROTOBUF_C_TYPE_UINT32,
2515 offsetof(MumbleProto__TextMessage, has_actor),
2516 offsetof(MumbleProto__TextMessage, actor),
2517 NULL,
2518 NULL,
2519 0, /* flags */
2520 0,NULL,NULL /* reserved1,reserved2, etc */
2521 },
2522 {
2523 "session",
2524 2,
2525 PROTOBUF_C_LABEL_REPEATED,
2526 PROTOBUF_C_TYPE_UINT32,
2527 offsetof(MumbleProto__TextMessage, n_session),
2528 offsetof(MumbleProto__TextMessage, session),
2529 NULL,
2530 NULL,
2531 0, /* flags */
2532 0,NULL,NULL /* reserved1,reserved2, etc */
2533 },
2534 {
2535 "channel_id",
2536 3,
2537 PROTOBUF_C_LABEL_REPEATED,
2538 PROTOBUF_C_TYPE_UINT32,
2539 offsetof(MumbleProto__TextMessage, n_channel_id),
2540 offsetof(MumbleProto__TextMessage, channel_id),
2541 NULL,
2542 NULL,
2543 0, /* flags */
2544 0,NULL,NULL /* reserved1,reserved2, etc */
2545 },
2546 {
2547 "tree_id",
2548 4,
2549 PROTOBUF_C_LABEL_REPEATED,
2550 PROTOBUF_C_TYPE_UINT32,
2551 offsetof(MumbleProto__TextMessage, n_tree_id),
2552 offsetof(MumbleProto__TextMessage, tree_id),
2553 NULL,
2554 NULL,
2555 0, /* flags */
2556 0,NULL,NULL /* reserved1,reserved2, etc */
2557 },
2558 {
2559 "message",
2560 5,
2561 PROTOBUF_C_LABEL_REQUIRED,
2562 PROTOBUF_C_TYPE_STRING,
2563 0, /* quantifier_offset */
2564 offsetof(MumbleProto__TextMessage, message),
2565 NULL,
2566 NULL,
2567 0, /* flags */
2568 0,NULL,NULL /* reserved1,reserved2, etc */
2569 },
2570 };
2571 static const unsigned mumble_proto__text_message__field_indices_by_name[] = {
2572 0, /* field[0] = actor */
2573 2, /* field[2] = channel_id */
2574 4, /* field[4] = message */
2575 1, /* field[1] = session */
2576 3, /* field[3] = tree_id */
2577 };
2578 static const ProtobufCIntRange mumble_proto__text_message__number_ranges[1 + 1] =
2579 {
2580 { 1, 0 },
2581 { 0, 5 }
2582 };
2583 const ProtobufCMessageDescriptor mumble_proto__text_message__descriptor =
2584 {
2585 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2586 "MumbleProto.TextMessage",
2587 "TextMessage",
2588 "MumbleProto__TextMessage",
2589 "MumbleProto",
2590 sizeof(MumbleProto__TextMessage),
2591 5,
2592 mumble_proto__text_message__field_descriptors,
2593 mumble_proto__text_message__field_indices_by_name,
2594 1, mumble_proto__text_message__number_ranges,
2595 (ProtobufCMessageInit) mumble_proto__text_message__init,
2596 NULL,NULL,NULL /* reserved[123] */
2597 };
2598 const ProtobufCEnumValue mumble_proto__permission_denied__deny_type__enum_values_by_number[11] =
2599 {
2600 { "Text", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__Text", 0 },
2601 { "Permission", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__Permission", 1 },
2602 { "SuperUser", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__SuperUser", 2 },
2603 { "ChannelName", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__ChannelName", 3 },
2604 { "TextTooLong", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TextTooLong", 4 },
2605 { "H9K", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__H9K", 5 },
2606 { "TemporaryChannel", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TemporaryChannel", 6 },
2607 { "MissingCertificate", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__MissingCertificate", 7 },
2608 { "UserName", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__UserName", 8 },
2609 { "ChannelFull", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__ChannelFull", 9 },
2610 { "NestingLimit", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__NestingLimit", 10 },
2611 };
2612 static const ProtobufCIntRange mumble_proto__permission_denied__deny_type__value_ranges[] = {
2613 {0, 0},{0, 11}
2614 };
2615 const ProtobufCEnumValueIndex mumble_proto__permission_denied__deny_type__enum_values_by_name[11] =
2616 {
2617 { "ChannelFull", 9 },
2618 { "ChannelName", 3 },
2619 { "H9K", 5 },
2620 { "MissingCertificate", 7 },
2621 { "NestingLimit", 10 },
2622 { "Permission", 1 },
2623 { "SuperUser", 2 },
2624 { "TemporaryChannel", 6 },
2625 { "Text", 0 },
2626 { "TextTooLong", 4 },
2627 { "UserName", 8 },
2628 };
2629 const ProtobufCEnumDescriptor mumble_proto__permission_denied__deny_type__descriptor =
2630 {
2631 PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
2632 "MumbleProto.PermissionDenied.DenyType",
2633 "DenyType",
2634 "MumbleProto__PermissionDenied__DenyType",
2635 "MumbleProto",
2636 11,
2637 mumble_proto__permission_denied__deny_type__enum_values_by_number,
2638 11,
2639 mumble_proto__permission_denied__deny_type__enum_values_by_name,
2640 1,
2641 mumble_proto__permission_denied__deny_type__value_ranges,
2642 NULL,NULL,NULL,NULL /* reserved[1234] */
2643 };
2644 static const ProtobufCFieldDescriptor mumble_proto__permission_denied__field_descriptors[6] =
2645 {
2646 {
2647 "permission",
2648 1,
2649 PROTOBUF_C_LABEL_OPTIONAL,
2650 PROTOBUF_C_TYPE_UINT32,
2651 offsetof(MumbleProto__PermissionDenied, has_permission),
2652 offsetof(MumbleProto__PermissionDenied, permission),
2653 NULL,
2654 NULL,
2655 0, /* flags */
2656 0,NULL,NULL /* reserved1,reserved2, etc */
2657 },
2658 {
2659 "channel_id",
2660 2,
2661 PROTOBUF_C_LABEL_OPTIONAL,
2662 PROTOBUF_C_TYPE_UINT32,
2663 offsetof(MumbleProto__PermissionDenied, has_channel_id),
2664 offsetof(MumbleProto__PermissionDenied, channel_id),
2665 NULL,
2666 NULL,
2667 0, /* flags */
2668 0,NULL,NULL /* reserved1,reserved2, etc */
2669 },
2670 {
2671 "session",
2672 3,
2673 PROTOBUF_C_LABEL_OPTIONAL,
2674 PROTOBUF_C_TYPE_UINT32,
2675 offsetof(MumbleProto__PermissionDenied, has_session),
2676 offsetof(MumbleProto__PermissionDenied, session),
2677 NULL,
2678 NULL,
2679 0, /* flags */
2680 0,NULL,NULL /* reserved1,reserved2, etc */
2681 },
2682 {
2683 "reason",
2684 4,
2685 PROTOBUF_C_LABEL_OPTIONAL,
2686 PROTOBUF_C_TYPE_STRING,
2687 0, /* quantifier_offset */
2688 offsetof(MumbleProto__PermissionDenied, reason),
2689 NULL,
2690 NULL,
2691 0, /* flags */
2692 0,NULL,NULL /* reserved1,reserved2, etc */
2693 },
2694 {
2695 "type",
2696 5,
2697 PROTOBUF_C_LABEL_OPTIONAL,
2698 PROTOBUF_C_TYPE_ENUM,
2699 offsetof(MumbleProto__PermissionDenied, has_type),
2700 offsetof(MumbleProto__PermissionDenied, type),
2701 &mumble_proto__permission_denied__deny_type__descriptor,
2702 NULL,
2703 0, /* flags */
2704 0,NULL,NULL /* reserved1,reserved2, etc */
2705 },
2706 {
2707 "name",
2708 6,
2709 PROTOBUF_C_LABEL_OPTIONAL,
2710 PROTOBUF_C_TYPE_STRING,
2711 0, /* quantifier_offset */
2712 offsetof(MumbleProto__PermissionDenied, name),
2713 NULL,
2714 NULL,
2715 0, /* flags */
2716 0,NULL,NULL /* reserved1,reserved2, etc */
2717 },
2718 };
2719 static const unsigned mumble_proto__permission_denied__field_indices_by_name[] = {
2720 1, /* field[1] = channel_id */
2721 5, /* field[5] = name */
2722 0, /* field[0] = permission */
2723 3, /* field[3] = reason */
2724 2, /* field[2] = session */
2725 4, /* field[4] = type */
2726 };
2727 static const ProtobufCIntRange mumble_proto__permission_denied__number_ranges[1 + 1] =
2728 {
2729 { 1, 0 },
2730 { 0, 6 }
2731 };
2732 const ProtobufCMessageDescriptor mumble_proto__permission_denied__descriptor =
2733 {
2734 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2735 "MumbleProto.PermissionDenied",
2736 "PermissionDenied",
2737 "MumbleProto__PermissionDenied",
2738 "MumbleProto",
2739 sizeof(MumbleProto__PermissionDenied),
2740 6,
2741 mumble_proto__permission_denied__field_descriptors,
2742 mumble_proto__permission_denied__field_indices_by_name,
2743 1, mumble_proto__permission_denied__number_ranges,
2744 (ProtobufCMessageInit) mumble_proto__permission_denied__init,
2745 NULL,NULL,NULL /* reserved[123] */
2746 };
2747 static const protobuf_c_boolean mumble_proto__acl__chan_group__inherited__default_value = 1;
2748 static const protobuf_c_boolean mumble_proto__acl__chan_group__inherit__default_value = 1;
2749 static const protobuf_c_boolean mumble_proto__acl__chan_group__inheritable__default_value = 1;
2750 static const ProtobufCFieldDescriptor mumble_proto__acl__chan_group__field_descriptors[7] =
2751 {
2752 {
2753 "name",
2754 1,
2755 PROTOBUF_C_LABEL_REQUIRED,
2756 PROTOBUF_C_TYPE_STRING,
2757 0, /* quantifier_offset */
2758 offsetof(MumbleProto__ACL__ChanGroup, name),
2759 NULL,
2760 NULL,
2761 0, /* flags */
2762 0,NULL,NULL /* reserved1,reserved2, etc */
2763 },
2764 {
2765 "inherited",
2766 2,
2767 PROTOBUF_C_LABEL_OPTIONAL,
2768 PROTOBUF_C_TYPE_BOOL,
2769 offsetof(MumbleProto__ACL__ChanGroup, has_inherited),
2770 offsetof(MumbleProto__ACL__ChanGroup, inherited),
2771 NULL,
2772 &mumble_proto__acl__chan_group__inherited__default_value,
2773 0, /* flags */
2774 0,NULL,NULL /* reserved1,reserved2, etc */
2775 },
2776 {
2777 "inherit",
2778 3,
2779 PROTOBUF_C_LABEL_OPTIONAL,
2780 PROTOBUF_C_TYPE_BOOL,
2781 offsetof(MumbleProto__ACL__ChanGroup, has_inherit),
2782 offsetof(MumbleProto__ACL__ChanGroup, inherit),
2783 NULL,
2784 &mumble_proto__acl__chan_group__inherit__default_value,
2785 0, /* flags */
2786 0,NULL,NULL /* reserved1,reserved2, etc */
2787 },
2788 {
2789 "inheritable",
2790 4,
2791 PROTOBUF_C_LABEL_OPTIONAL,
2792 PROTOBUF_C_TYPE_BOOL,
2793 offsetof(MumbleProto__ACL__ChanGroup, has_inheritable),
2794 offsetof(MumbleProto__ACL__ChanGroup, inheritable),
2795 NULL,
2796 &mumble_proto__acl__chan_group__inheritable__default_value,
2797 0, /* flags */
2798 0,NULL,NULL /* reserved1,reserved2, etc */
2799 },
2800 {
2801 "add",
2802 5,
2803 PROTOBUF_C_LABEL_REPEATED,
2804 PROTOBUF_C_TYPE_UINT32,
2805 offsetof(MumbleProto__ACL__ChanGroup, n_add),
2806 offsetof(MumbleProto__ACL__ChanGroup, add),
2807 NULL,
2808 NULL,
2809 0, /* flags */
2810 0,NULL,NULL /* reserved1,reserved2, etc */
2811 },
2812 {
2813 "remove",
2814 6,
2815 PROTOBUF_C_LABEL_REPEATED,
2816 PROTOBUF_C_TYPE_UINT32,
2817 offsetof(MumbleProto__ACL__ChanGroup, n_remove),
2818 offsetof(MumbleProto__ACL__ChanGroup, remove),
2819 NULL,
2820 NULL,
2821 0, /* flags */
2822 0,NULL,NULL /* reserved1,reserved2, etc */
2823 },
2824 {
2825 "inherited_members",
2826 7,
2827 PROTOBUF_C_LABEL_REPEATED,
2828 PROTOBUF_C_TYPE_UINT32,
2829 offsetof(MumbleProto__ACL__ChanGroup, n_inherited_members),
2830 offsetof(MumbleProto__ACL__ChanGroup, inherited_members),
2831 NULL,
2832 NULL,
2833 0, /* flags */
2834 0,NULL,NULL /* reserved1,reserved2, etc */
2835 },
2836 };
2837 static const unsigned mumble_proto__acl__chan_group__field_indices_by_name[] = {
2838 4, /* field[4] = add */
2839 2, /* field[2] = inherit */
2840 3, /* field[3] = inheritable */
2841 1, /* field[1] = inherited */
2842 6, /* field[6] = inherited_members */
2843 0, /* field[0] = name */
2844 5, /* field[5] = remove */
2845 };
2846 static const ProtobufCIntRange mumble_proto__acl__chan_group__number_ranges[1 + 1] =
2847 {
2848 { 1, 0 },
2849 { 0, 7 }
2850 };
2851 const ProtobufCMessageDescriptor mumble_proto__acl__chan_group__descriptor =
2852 {
2853 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2854 "MumbleProto.ACL.ChanGroup",
2855 "ChanGroup",
2856 "MumbleProto__ACL__ChanGroup",
2857 "MumbleProto",
2858 sizeof(MumbleProto__ACL__ChanGroup),
2859 7,
2860 mumble_proto__acl__chan_group__field_descriptors,
2861 mumble_proto__acl__chan_group__field_indices_by_name,
2862 1, mumble_proto__acl__chan_group__number_ranges,
2863 (ProtobufCMessageInit) mumble_proto__acl__chan_group__init,
2864 NULL,NULL,NULL /* reserved[123] */
2865 };
2866 static const protobuf_c_boolean mumble_proto__acl__chan_acl__apply_here__default_value = 1;
2867 static const protobuf_c_boolean mumble_proto__acl__chan_acl__apply_subs__default_value = 1;
2868 static const protobuf_c_boolean mumble_proto__acl__chan_acl__inherited__default_value = 1;
2869 static const ProtobufCFieldDescriptor mumble_proto__acl__chan_acl__field_descriptors[7] =
2870 {
2871 {
2872 "apply_here",
2873 1,
2874 PROTOBUF_C_LABEL_OPTIONAL,
2875 PROTOBUF_C_TYPE_BOOL,
2876 offsetof(MumbleProto__ACL__ChanACL, has_apply_here),
2877 offsetof(MumbleProto__ACL__ChanACL, apply_here),
2878 NULL,
2879 &mumble_proto__acl__chan_acl__apply_here__default_value,
2880 0, /* flags */
2881 0,NULL,NULL /* reserved1,reserved2, etc */
2882 },
2883 {
2884 "apply_subs",
2885 2,
2886 PROTOBUF_C_LABEL_OPTIONAL,
2887 PROTOBUF_C_TYPE_BOOL,
2888 offsetof(MumbleProto__ACL__ChanACL, has_apply_subs),
2889 offsetof(MumbleProto__ACL__ChanACL, apply_subs),
2890 NULL,
2891 &mumble_proto__acl__chan_acl__apply_subs__default_value,
2892 0, /* flags */
2893 0,NULL,NULL /* reserved1,reserved2, etc */
2894 },
2895 {
2896 "inherited",
2897 3,
2898 PROTOBUF_C_LABEL_OPTIONAL,
2899 PROTOBUF_C_TYPE_BOOL,
2900 offsetof(MumbleProto__ACL__ChanACL, has_inherited),
2901 offsetof(MumbleProto__ACL__ChanACL, inherited),
2902 NULL,
2903 &mumble_proto__acl__chan_acl__inherited__default_value,
2904 0, /* flags */
2905 0,NULL,NULL /* reserved1,reserved2, etc */
2906 },
2907 {
2908 "user_id",
2909 4,
2910 PROTOBUF_C_LABEL_OPTIONAL,
2911 PROTOBUF_C_TYPE_UINT32,
2912 offsetof(MumbleProto__ACL__ChanACL, has_user_id),
2913 offsetof(MumbleProto__ACL__ChanACL, user_id),
2914 NULL,
2915 NULL,
2916 0, /* flags */
2917 0,NULL,NULL /* reserved1,reserved2, etc */
2918 },
2919 {
2920 "group",
2921 5,
2922 PROTOBUF_C_LABEL_OPTIONAL,
2923 PROTOBUF_C_TYPE_STRING,
2924 0, /* quantifier_offset */
2925 offsetof(MumbleProto__ACL__ChanACL, group),
2926 NULL,
2927 NULL,
2928 0, /* flags */
2929 0,NULL,NULL /* reserved1,reserved2, etc */
2930 },
2931 {
2932 "grant",
2933 6,
2934 PROTOBUF_C_LABEL_OPTIONAL,
2935 PROTOBUF_C_TYPE_UINT32,
2936 offsetof(MumbleProto__ACL__ChanACL, has_grant),
2937 offsetof(MumbleProto__ACL__ChanACL, grant),
2938 NULL,
2939 NULL,
2940 0, /* flags */
2941 0,NULL,NULL /* reserved1,reserved2, etc */
2942 },
2943 {
2944 "deny",
2945 7,
2946 PROTOBUF_C_LABEL_OPTIONAL,
2947 PROTOBUF_C_TYPE_UINT32,
2948 offsetof(MumbleProto__ACL__ChanACL, has_deny),
2949 offsetof(MumbleProto__ACL__ChanACL, deny),
2950 NULL,
2951 NULL,
2952 0, /* flags */
2953 0,NULL,NULL /* reserved1,reserved2, etc */
2954 },
2955 };
2956 static const unsigned mumble_proto__acl__chan_acl__field_indices_by_name[] = {
2957 0, /* field[0] = apply_here */
2958 1, /* field[1] = apply_subs */
2959 6, /* field[6] = deny */
2960 5, /* field[5] = grant */
2961 4, /* field[4] = group */
2962 2, /* field[2] = inherited */
2963 3, /* field[3] = user_id */
2964 };
2965 static const ProtobufCIntRange mumble_proto__acl__chan_acl__number_ranges[1 + 1] =
2966 {
2967 { 1, 0 },
2968 { 0, 7 }
2969 };
2970 const ProtobufCMessageDescriptor mumble_proto__acl__chan_acl__descriptor =
2971 {
2972 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
2973 "MumbleProto.ACL.ChanACL",
2974 "ChanACL",
2975 "MumbleProto__ACL__ChanACL",
2976 "MumbleProto",
2977 sizeof(MumbleProto__ACL__ChanACL),
2978 7,
2979 mumble_proto__acl__chan_acl__field_descriptors,
2980 mumble_proto__acl__chan_acl__field_indices_by_name,
2981 1, mumble_proto__acl__chan_acl__number_ranges,
2982 (ProtobufCMessageInit) mumble_proto__acl__chan_acl__init,
2983 NULL,NULL,NULL /* reserved[123] */
2984 };
2985 static const protobuf_c_boolean mumble_proto__acl__inherit_acls__default_value = 1;
2986 static const protobuf_c_boolean mumble_proto__acl__query__default_value = 0;
2987 static const ProtobufCFieldDescriptor mumble_proto__acl__field_descriptors[5] =
2988 {
2989 {
2990 "channel_id",
2991 1,
2992 PROTOBUF_C_LABEL_REQUIRED,
2993 PROTOBUF_C_TYPE_UINT32,
2994 0, /* quantifier_offset */
2995 offsetof(MumbleProto__ACL, channel_id),
2996 NULL,
2997 NULL,
2998 0, /* flags */
2999 0,NULL,NULL /* reserved1,reserved2, etc */
3000 },
3001 {
3002 "inherit_acls",
3003 2,
3004 PROTOBUF_C_LABEL_OPTIONAL,
3005 PROTOBUF_C_TYPE_BOOL,
3006 offsetof(MumbleProto__ACL, has_inherit_acls),
3007 offsetof(MumbleProto__ACL, inherit_acls),
3008 NULL,
3009 &mumble_proto__acl__inherit_acls__default_value,
3010 0, /* flags */
3011 0,NULL,NULL /* reserved1,reserved2, etc */
3012 },
3013 {
3014 "groups",
3015 3,
3016 PROTOBUF_C_LABEL_REPEATED,
3017 PROTOBUF_C_TYPE_MESSAGE,
3018 offsetof(MumbleProto__ACL, n_groups),
3019 offsetof(MumbleProto__ACL, groups),
3020 &mumble_proto__acl__chan_group__descriptor,
3021 NULL,
3022 0, /* flags */
3023 0,NULL,NULL /* reserved1,reserved2, etc */
3024 },
3025 {
3026 "acls",
3027 4,
3028 PROTOBUF_C_LABEL_REPEATED,
3029 PROTOBUF_C_TYPE_MESSAGE,
3030 offsetof(MumbleProto__ACL, n_acls),
3031 offsetof(MumbleProto__ACL, acls),
3032 &mumble_proto__acl__chan_acl__descriptor,
3033 NULL,
3034 0, /* flags */
3035 0,NULL,NULL /* reserved1,reserved2, etc */
3036 },
3037 {
3038 "query",
3039 5,
3040 PROTOBUF_C_LABEL_OPTIONAL,
3041 PROTOBUF_C_TYPE_BOOL,
3042 offsetof(MumbleProto__ACL, has_query),
3043 offsetof(MumbleProto__ACL, query),
3044 NULL,
3045 &mumble_proto__acl__query__default_value,
3046 0, /* flags */
3047 0,NULL,NULL /* reserved1,reserved2, etc */
3048 },
3049 };
3050 static const unsigned mumble_proto__acl__field_indices_by_name[] = {
3051 3, /* field[3] = acls */
3052 0, /* field[0] = channel_id */
3053 2, /* field[2] = groups */
3054 1, /* field[1] = inherit_acls */
3055 4, /* field[4] = query */
3056 };
3057 static const ProtobufCIntRange mumble_proto__acl__number_ranges[1 + 1] =
3058 {
3059 { 1, 0 },
3060 { 0, 5 }
3061 };
3062 const ProtobufCMessageDescriptor mumble_proto__acl__descriptor =
3063 {
3064 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3065 "MumbleProto.ACL",
3066 "ACL",
3067 "MumbleProto__ACL",
3068 "MumbleProto",
3069 sizeof(MumbleProto__ACL),
3070 5,
3071 mumble_proto__acl__field_descriptors,
3072 mumble_proto__acl__field_indices_by_name,
3073 1, mumble_proto__acl__number_ranges,
3074 (ProtobufCMessageInit) mumble_proto__acl__init,
3075 NULL,NULL,NULL /* reserved[123] */
3076 };
3077 static const ProtobufCFieldDescriptor mumble_proto__query_users__field_descriptors[2] =
3078 {
3079 {
3080 "ids",
3081 1,
3082 PROTOBUF_C_LABEL_REPEATED,
3083 PROTOBUF_C_TYPE_UINT32,
3084 offsetof(MumbleProto__QueryUsers, n_ids),
3085 offsetof(MumbleProto__QueryUsers, ids),
3086 NULL,
3087 NULL,
3088 0, /* flags */
3089 0,NULL,NULL /* reserved1,reserved2, etc */
3090 },
3091 {
3092 "names",
3093 2,
3094 PROTOBUF_C_LABEL_REPEATED,
3095 PROTOBUF_C_TYPE_STRING,
3096 offsetof(MumbleProto__QueryUsers, n_names),
3097 offsetof(MumbleProto__QueryUsers, names),
3098 NULL,
3099 NULL,
3100 0, /* flags */
3101 0,NULL,NULL /* reserved1,reserved2, etc */
3102 },
3103 };
3104 static const unsigned mumble_proto__query_users__field_indices_by_name[] = {
3105 0, /* field[0] = ids */
3106 1, /* field[1] = names */
3107 };
3108 static const ProtobufCIntRange mumble_proto__query_users__number_ranges[1 + 1] =
3109 {
3110 { 1, 0 },
3111 { 0, 2 }
3112 };
3113 const ProtobufCMessageDescriptor mumble_proto__query_users__descriptor =
3114 {
3115 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3116 "MumbleProto.QueryUsers",
3117 "QueryUsers",
3118 "MumbleProto__QueryUsers",
3119 "MumbleProto",
3120 sizeof(MumbleProto__QueryUsers),
3121 2,
3122 mumble_proto__query_users__field_descriptors,
3123 mumble_proto__query_users__field_indices_by_name,
3124 1, mumble_proto__query_users__number_ranges,
3125 (ProtobufCMessageInit) mumble_proto__query_users__init,
3126 NULL,NULL,NULL /* reserved[123] */
3127 };
3128 static const ProtobufCFieldDescriptor mumble_proto__crypt_setup__field_descriptors[3] =
3129 {
3130 {
3131 "key",
3132 1,
3133 PROTOBUF_C_LABEL_OPTIONAL,
3134 PROTOBUF_C_TYPE_BYTES,
3135 offsetof(MumbleProto__CryptSetup, has_key),
3136 offsetof(MumbleProto__CryptSetup, key),
3137 NULL,
3138 NULL,
3139 0, /* flags */
3140 0,NULL,NULL /* reserved1,reserved2, etc */
3141 },
3142 {
3143 "client_nonce",
3144 2,
3145 PROTOBUF_C_LABEL_OPTIONAL,
3146 PROTOBUF_C_TYPE_BYTES,
3147 offsetof(MumbleProto__CryptSetup, has_client_nonce),
3148 offsetof(MumbleProto__CryptSetup, client_nonce),
3149 NULL,
3150 NULL,
3151 0, /* flags */
3152 0,NULL,NULL /* reserved1,reserved2, etc */
3153 },
3154 {
3155 "server_nonce",
3156 3,
3157 PROTOBUF_C_LABEL_OPTIONAL,
3158 PROTOBUF_C_TYPE_BYTES,
3159 offsetof(MumbleProto__CryptSetup, has_server_nonce),
3160 offsetof(MumbleProto__CryptSetup, server_nonce),
3161 NULL,
3162 NULL,
3163 0, /* flags */
3164 0,NULL,NULL /* reserved1,reserved2, etc */
3165 },
3166 };
3167 static const unsigned mumble_proto__crypt_setup__field_indices_by_name[] = {
3168 1, /* field[1] = client_nonce */
3169 0, /* field[0] = key */
3170 2, /* field[2] = server_nonce */
3171 };
3172 static const ProtobufCIntRange mumble_proto__crypt_setup__number_ranges[1 + 1] =
3173 {
3174 { 1, 0 },
3175 { 0, 3 }
3176 };
3177 const ProtobufCMessageDescriptor mumble_proto__crypt_setup__descriptor =
3178 {
3179 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3180 "MumbleProto.CryptSetup",
3181 "CryptSetup",
3182 "MumbleProto__CryptSetup",
3183 "MumbleProto",
3184 sizeof(MumbleProto__CryptSetup),
3185 3,
3186 mumble_proto__crypt_setup__field_descriptors,
3187 mumble_proto__crypt_setup__field_indices_by_name,
3188 1, mumble_proto__crypt_setup__number_ranges,
3189 (ProtobufCMessageInit) mumble_proto__crypt_setup__init,
3190 NULL,NULL,NULL /* reserved[123] */
3191 };
3192 const ProtobufCEnumValue mumble_proto__context_action_modify__context__enum_values_by_number[3] =
3193 {
3194 { "Server", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__Server", 1 },
3195 { "Channel", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__Channel", 2 },
3196 { "User", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__CONTEXT__User", 4 },
3197 };
3198 static const ProtobufCIntRange mumble_proto__context_action_modify__context__value_ranges[] = {
3199 {1, 0},{4, 2},{0, 3}
3200 };
3201 const ProtobufCEnumValueIndex mumble_proto__context_action_modify__context__enum_values_by_name[3] =
3202 {
3203 { "Channel", 1 },
3204 { "Server", 0 },
3205 { "User", 2 },
3206 };
3207 const ProtobufCEnumDescriptor mumble_proto__context_action_modify__context__descriptor =
3208 {
3209 PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
3210 "MumbleProto.ContextActionModify.Context",
3211 "Context",
3212 "MumbleProto__ContextActionModify__Context",
3213 "MumbleProto",
3214 3,
3215 mumble_proto__context_action_modify__context__enum_values_by_number,
3216 3,
3217 mumble_proto__context_action_modify__context__enum_values_by_name,
3218 2,
3219 mumble_proto__context_action_modify__context__value_ranges,
3220 NULL,NULL,NULL,NULL /* reserved[1234] */
3221 };
3222 const ProtobufCEnumValue mumble_proto__context_action_modify__operation__enum_values_by_number[2] =
3223 {
3224 { "Add", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__OPERATION__Add", 0 },
3225 { "Remove", "MUMBLE_PROTO__CONTEXT_ACTION_MODIFY__OPERATION__Remove", 1 },
3226 };
3227 static const ProtobufCIntRange mumble_proto__context_action_modify__operation__value_ranges[] = {
3228 {0, 0},{0, 2}
3229 };
3230 const ProtobufCEnumValueIndex mumble_proto__context_action_modify__operation__enum_values_by_name[2] =
3231 {
3232 { "Add", 0 },
3233 { "Remove", 1 },
3234 };
3235 const ProtobufCEnumDescriptor mumble_proto__context_action_modify__operation__descriptor =
3236 {
3237 PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
3238 "MumbleProto.ContextActionModify.Operation",
3239 "Operation",
3240 "MumbleProto__ContextActionModify__Operation",
3241 "MumbleProto",
3242 2,
3243 mumble_proto__context_action_modify__operation__enum_values_by_number,
3244 2,
3245 mumble_proto__context_action_modify__operation__enum_values_by_name,
3246 1,
3247 mumble_proto__context_action_modify__operation__value_ranges,
3248 NULL,NULL,NULL,NULL /* reserved[1234] */
3249 };
3250 static const ProtobufCFieldDescriptor mumble_proto__context_action_modify__field_descriptors[4] =
3251 {
3252 {
3253 "action",
3254 1,
3255 PROTOBUF_C_LABEL_REQUIRED,
3256 PROTOBUF_C_TYPE_STRING,
3257 0, /* quantifier_offset */
3258 offsetof(MumbleProto__ContextActionModify, action),
3259 NULL,
3260 NULL,
3261 0, /* flags */
3262 0,NULL,NULL /* reserved1,reserved2, etc */
3263 },
3264 {
3265 "text",
3266 2,
3267 PROTOBUF_C_LABEL_OPTIONAL,
3268 PROTOBUF_C_TYPE_STRING,
3269 0, /* quantifier_offset */
3270 offsetof(MumbleProto__ContextActionModify, text),
3271 NULL,
3272 NULL,
3273 0, /* flags */
3274 0,NULL,NULL /* reserved1,reserved2, etc */
3275 },
3276 {
3277 "context",
3278 3,
3279 PROTOBUF_C_LABEL_OPTIONAL,
3280 PROTOBUF_C_TYPE_UINT32,
3281 offsetof(MumbleProto__ContextActionModify, has_context),
3282 offsetof(MumbleProto__ContextActionModify, context),
3283 NULL,
3284 NULL,
3285 0, /* flags */
3286 0,NULL,NULL /* reserved1,reserved2, etc */
3287 },
3288 {
3289 "operation",
3290 4,
3291 PROTOBUF_C_LABEL_OPTIONAL,
3292 PROTOBUF_C_TYPE_ENUM,
3293 offsetof(MumbleProto__ContextActionModify, has_operation),
3294 offsetof(MumbleProto__ContextActionModify, operation),
3295 &mumble_proto__context_action_modify__operation__descriptor,
3296 NULL,
3297 0, /* flags */
3298 0,NULL,NULL /* reserved1,reserved2, etc */
3299 },
3300 };
3301 static const unsigned mumble_proto__context_action_modify__field_indices_by_name[] = {
3302 0, /* field[0] = action */
3303 2, /* field[2] = context */
3304 3, /* field[3] = operation */
3305 1, /* field[1] = text */
3306 };
3307 static const ProtobufCIntRange mumble_proto__context_action_modify__number_ranges[1 + 1] =
3308 {
3309 { 1, 0 },
3310 { 0, 4 }
3311 };
3312 const ProtobufCMessageDescriptor mumble_proto__context_action_modify__descriptor =
3313 {
3314 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3315 "MumbleProto.ContextActionModify",
3316 "ContextActionModify",
3317 "MumbleProto__ContextActionModify",
3318 "MumbleProto",
3319 sizeof(MumbleProto__ContextActionModify),
3320 4,
3321 mumble_proto__context_action_modify__field_descriptors,
3322 mumble_proto__context_action_modify__field_indices_by_name,
3323 1, mumble_proto__context_action_modify__number_ranges,
3324 (ProtobufCMessageInit) mumble_proto__context_action_modify__init,
3325 NULL,NULL,NULL /* reserved[123] */
3326 };
3327 static const ProtobufCFieldDescriptor mumble_proto__context_action__field_descriptors[3] =
3328 {
3329 {
3330 "session",
3331 1,
3332 PROTOBUF_C_LABEL_OPTIONAL,
3333 PROTOBUF_C_TYPE_UINT32,
3334 offsetof(MumbleProto__ContextAction, has_session),
3335 offsetof(MumbleProto__ContextAction, session),
3336 NULL,
3337 NULL,
3338 0, /* flags */
3339 0,NULL,NULL /* reserved1,reserved2, etc */
3340 },
3341 {
3342 "channel_id",
3343 2,
3344 PROTOBUF_C_LABEL_OPTIONAL,
3345 PROTOBUF_C_TYPE_UINT32,
3346 offsetof(MumbleProto__ContextAction, has_channel_id),
3347 offsetof(MumbleProto__ContextAction, channel_id),
3348 NULL,
3349 NULL,
3350 0, /* flags */
3351 0,NULL,NULL /* reserved1,reserved2, etc */
3352 },
3353 {
3354 "action",
3355 3,
3356 PROTOBUF_C_LABEL_REQUIRED,
3357 PROTOBUF_C_TYPE_STRING,
3358 0, /* quantifier_offset */
3359 offsetof(MumbleProto__ContextAction, action),
3360 NULL,
3361 NULL,
3362 0, /* flags */
3363 0,NULL,NULL /* reserved1,reserved2, etc */
3364 },
3365 };
3366 static const unsigned mumble_proto__context_action__field_indices_by_name[] = {
3367 2, /* field[2] = action */
3368 1, /* field[1] = channel_id */
3369 0, /* field[0] = session */
3370 };
3371 static const ProtobufCIntRange mumble_proto__context_action__number_ranges[1 + 1] =
3372 {
3373 { 1, 0 },
3374 { 0, 3 }
3375 };
3376 const ProtobufCMessageDescriptor mumble_proto__context_action__descriptor =
3377 {
3378 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3379 "MumbleProto.ContextAction",
3380 "ContextAction",
3381 "MumbleProto__ContextAction",
3382 "MumbleProto",
3383 sizeof(MumbleProto__ContextAction),
3384 3,
3385 mumble_proto__context_action__field_descriptors,
3386 mumble_proto__context_action__field_indices_by_name,
3387 1, mumble_proto__context_action__number_ranges,
3388 (ProtobufCMessageInit) mumble_proto__context_action__init,
3389 NULL,NULL,NULL /* reserved[123] */
3390 };
3391 static const ProtobufCFieldDescriptor mumble_proto__user_list__user__field_descriptors[2] =
3392 {
3393 {
3394 "user_id",
3395 1,
3396 PROTOBUF_C_LABEL_REQUIRED,
3397 PROTOBUF_C_TYPE_UINT32,
3398 0, /* quantifier_offset */
3399 offsetof(MumbleProto__UserList__User, user_id),
3400 NULL,
3401 NULL,
3402 0, /* flags */
3403 0,NULL,NULL /* reserved1,reserved2, etc */
3404 },
3405 {
3406 "name",
3407 2,
3408 PROTOBUF_C_LABEL_OPTIONAL,
3409 PROTOBUF_C_TYPE_STRING,
3410 0, /* quantifier_offset */
3411 offsetof(MumbleProto__UserList__User, name),
3412 NULL,
3413 NULL,
3414 0, /* flags */
3415 0,NULL,NULL /* reserved1,reserved2, etc */
3416 },
3417 };
3418 static const unsigned mumble_proto__user_list__user__field_indices_by_name[] = {
3419 1, /* field[1] = name */
3420 0, /* field[0] = user_id */
3421 };
3422 static const ProtobufCIntRange mumble_proto__user_list__user__number_ranges[1 + 1] =
3423 {
3424 { 1, 0 },
3425 { 0, 2 }
3426 };
3427 const ProtobufCMessageDescriptor mumble_proto__user_list__user__descriptor =
3428 {
3429 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3430 "MumbleProto.UserList.User",
3431 "User",
3432 "MumbleProto__UserList__User",
3433 "MumbleProto",
3434 sizeof(MumbleProto__UserList__User),
3435 2,
3436 mumble_proto__user_list__user__field_descriptors,
3437 mumble_proto__user_list__user__field_indices_by_name,
3438 1, mumble_proto__user_list__user__number_ranges,
3439 (ProtobufCMessageInit) mumble_proto__user_list__user__init,
3440 NULL,NULL,NULL /* reserved[123] */
3441 };
3442 static const ProtobufCFieldDescriptor mumble_proto__user_list__field_descriptors[1] =
3443 {
3444 {
3445 "users",
3446 1,
3447 PROTOBUF_C_LABEL_REPEATED,
3448 PROTOBUF_C_TYPE_MESSAGE,
3449 offsetof(MumbleProto__UserList, n_users),
3450 offsetof(MumbleProto__UserList, users),
3451 &mumble_proto__user_list__user__descriptor,
3452 NULL,
3453 0, /* flags */
3454 0,NULL,NULL /* reserved1,reserved2, etc */
3455 },
3456 };
3457 static const unsigned mumble_proto__user_list__field_indices_by_name[] = {
3458 0, /* field[0] = users */
3459 };
3460 static const ProtobufCIntRange mumble_proto__user_list__number_ranges[1 + 1] =
3461 {
3462 { 1, 0 },
3463 { 0, 1 }
3464 };
3465 const ProtobufCMessageDescriptor mumble_proto__user_list__descriptor =
3466 {
3467 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3468 "MumbleProto.UserList",
3469 "UserList",
3470 "MumbleProto__UserList",
3471 "MumbleProto",
3472 sizeof(MumbleProto__UserList),
3473 1,
3474 mumble_proto__user_list__field_descriptors,
3475 mumble_proto__user_list__field_indices_by_name,
3476 1, mumble_proto__user_list__number_ranges,
3477 (ProtobufCMessageInit) mumble_proto__user_list__init,
3478 NULL,NULL,NULL /* reserved[123] */
3479 };
3480 static const protobuf_c_boolean mumble_proto__voice_target__target__links__default_value = 0;
3481 static const protobuf_c_boolean mumble_proto__voice_target__target__children__default_value = 0;
3482 static const ProtobufCFieldDescriptor mumble_proto__voice_target__target__field_descriptors[5] =
3483 {
3484 {
3485 "session",
3486 1,
3487 PROTOBUF_C_LABEL_REPEATED,
3488 PROTOBUF_C_TYPE_UINT32,
3489 offsetof(MumbleProto__VoiceTarget__Target, n_session),
3490 offsetof(MumbleProto__VoiceTarget__Target, session),
3491 NULL,
3492 NULL,
3493 0, /* flags */
3494 0,NULL,NULL /* reserved1,reserved2, etc */
3495 },
3496 {
3497 "channel_id",
3498 2,
3499 PROTOBUF_C_LABEL_OPTIONAL,
3500 PROTOBUF_C_TYPE_UINT32,
3501 offsetof(MumbleProto__VoiceTarget__Target, has_channel_id),
3502 offsetof(MumbleProto__VoiceTarget__Target, channel_id),
3503 NULL,
3504 NULL,
3505 0, /* flags */
3506 0,NULL,NULL /* reserved1,reserved2, etc */
3507 },
3508 {
3509 "group",
3510 3,
3511 PROTOBUF_C_LABEL_OPTIONAL,
3512 PROTOBUF_C_TYPE_STRING,
3513 0, /* quantifier_offset */
3514 offsetof(MumbleProto__VoiceTarget__Target, group),
3515 NULL,
3516 NULL,
3517 0, /* flags */
3518 0,NULL,NULL /* reserved1,reserved2, etc */
3519 },
3520 {
3521 "links",
3522 4,
3523 PROTOBUF_C_LABEL_OPTIONAL,
3524 PROTOBUF_C_TYPE_BOOL,
3525 offsetof(MumbleProto__VoiceTarget__Target, has_links),
3526 offsetof(MumbleProto__VoiceTarget__Target, links),
3527 NULL,
3528 &mumble_proto__voice_target__target__links__default_value,
3529 0, /* flags */
3530 0,NULL,NULL /* reserved1,reserved2, etc */
3531 },
3532 {
3533 "children",
3534 5,
3535 PROTOBUF_C_LABEL_OPTIONAL,
3536 PROTOBUF_C_TYPE_BOOL,
3537 offsetof(MumbleProto__VoiceTarget__Target, has_children),
3538 offsetof(MumbleProto__VoiceTarget__Target, children),
3539 NULL,
3540 &mumble_proto__voice_target__target__children__default_value,
3541 0, /* flags */
3542 0,NULL,NULL /* reserved1,reserved2, etc */
3543 },
3544 };
3545 static const unsigned mumble_proto__voice_target__target__field_indices_by_name[] = {
3546 1, /* field[1] = channel_id */
3547 4, /* field[4] = children */
3548 2, /* field[2] = group */
3549 3, /* field[3] = links */
3550 0, /* field[0] = session */
3551 };
3552 static const ProtobufCIntRange mumble_proto__voice_target__target__number_ranges[1 + 1] =
3553 {
3554 { 1, 0 },
3555 { 0, 5 }
3556 };
3557 const ProtobufCMessageDescriptor mumble_proto__voice_target__target__descriptor =
3558 {
3559 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3560 "MumbleProto.VoiceTarget.Target",
3561 "Target",
3562 "MumbleProto__VoiceTarget__Target",
3563 "MumbleProto",
3564 sizeof(MumbleProto__VoiceTarget__Target),
3565 5,
3566 mumble_proto__voice_target__target__field_descriptors,
3567 mumble_proto__voice_target__target__field_indices_by_name,
3568 1, mumble_proto__voice_target__target__number_ranges,
3569 (ProtobufCMessageInit) mumble_proto__voice_target__target__init,
3570 NULL,NULL,NULL /* reserved[123] */
3571 };
3572 static const ProtobufCFieldDescriptor mumble_proto__voice_target__field_descriptors[2] =
3573 {
3574 {
3575 "id",
3576 1,
3577 PROTOBUF_C_LABEL_OPTIONAL,
3578 PROTOBUF_C_TYPE_UINT32,
3579 offsetof(MumbleProto__VoiceTarget, has_id),
3580 offsetof(MumbleProto__VoiceTarget, id),
3581 NULL,
3582 NULL,
3583 0, /* flags */
3584 0,NULL,NULL /* reserved1,reserved2, etc */
3585 },
3586 {
3587 "targets",
3588 2,
3589 PROTOBUF_C_LABEL_REPEATED,
3590 PROTOBUF_C_TYPE_MESSAGE,
3591 offsetof(MumbleProto__VoiceTarget, n_targets),
3592 offsetof(MumbleProto__VoiceTarget, targets),
3593 &mumble_proto__voice_target__target__descriptor,
3594 NULL,
3595 0, /* flags */
3596 0,NULL,NULL /* reserved1,reserved2, etc */
3597 },
3598 };
3599 static const unsigned mumble_proto__voice_target__field_indices_by_name[] = {
3600 0, /* field[0] = id */
3601 1, /* field[1] = targets */
3602 };
3603 static const ProtobufCIntRange mumble_proto__voice_target__number_ranges[1 + 1] =
3604 {
3605 { 1, 0 },
3606 { 0, 2 }
3607 };
3608 const ProtobufCMessageDescriptor mumble_proto__voice_target__descriptor =
3609 {
3610 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3611 "MumbleProto.VoiceTarget",
3612 "VoiceTarget",
3613 "MumbleProto__VoiceTarget",
3614 "MumbleProto",
3615 sizeof(MumbleProto__VoiceTarget),
3616 2,
3617 mumble_proto__voice_target__field_descriptors,
3618 mumble_proto__voice_target__field_indices_by_name,
3619 1, mumble_proto__voice_target__number_ranges,
3620 (ProtobufCMessageInit) mumble_proto__voice_target__init,
3621 NULL,NULL,NULL /* reserved[123] */
3622 };
3623 static const protobuf_c_boolean mumble_proto__permission_query__flush__default_value = 0;
3624 static const ProtobufCFieldDescriptor mumble_proto__permission_query__field_descriptors[3] =
3625 {
3626 {
3627 "channel_id",
3628 1,
3629 PROTOBUF_C_LABEL_OPTIONAL,
3630 PROTOBUF_C_TYPE_UINT32,
3631 offsetof(MumbleProto__PermissionQuery, has_channel_id),
3632 offsetof(MumbleProto__PermissionQuery, channel_id),
3633 NULL,
3634 NULL,
3635 0, /* flags */
3636 0,NULL,NULL /* reserved1,reserved2, etc */
3637 },
3638 {
3639 "permissions",
3640 2,
3641 PROTOBUF_C_LABEL_OPTIONAL,
3642 PROTOBUF_C_TYPE_UINT32,
3643 offsetof(MumbleProto__PermissionQuery, has_permissions),
3644 offsetof(MumbleProto__PermissionQuery, permissions),
3645 NULL,
3646 NULL,
3647 0, /* flags */
3648 0,NULL,NULL /* reserved1,reserved2, etc */
3649 },
3650 {
3651 "flush",
3652 3,
3653 PROTOBUF_C_LABEL_OPTIONAL,
3654 PROTOBUF_C_TYPE_BOOL,
3655 offsetof(MumbleProto__PermissionQuery, has_flush),
3656 offsetof(MumbleProto__PermissionQuery, flush),
3657 NULL,
3658 &mumble_proto__permission_query__flush__default_value,
3659 0, /* flags */
3660 0,NULL,NULL /* reserved1,reserved2, etc */
3661 },
3662 };
3663 static const unsigned mumble_proto__permission_query__field_indices_by_name[] = {
3664 0, /* field[0] = channel_id */
3665 2, /* field[2] = flush */
3666 1, /* field[1] = permissions */
3667 };
3668 static const ProtobufCIntRange mumble_proto__permission_query__number_ranges[1 + 1] =
3669 {
3670 { 1, 0 },
3671 { 0, 3 }
3672 };
3673 const ProtobufCMessageDescriptor mumble_proto__permission_query__descriptor =
3674 {
3675 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3676 "MumbleProto.PermissionQuery",
3677 "PermissionQuery",
3678 "MumbleProto__PermissionQuery",
3679 "MumbleProto",
3680 sizeof(MumbleProto__PermissionQuery),
3681 3,
3682 mumble_proto__permission_query__field_descriptors,
3683 mumble_proto__permission_query__field_indices_by_name,
3684 1, mumble_proto__permission_query__number_ranges,
3685 (ProtobufCMessageInit) mumble_proto__permission_query__init,
3686 NULL,NULL,NULL /* reserved[123] */
3687 };
3688 static const protobuf_c_boolean mumble_proto__codec_version__prefer_alpha__default_value = 1;
3689 static const protobuf_c_boolean mumble_proto__codec_version__opus__default_value = 0;
3690 static const ProtobufCFieldDescriptor mumble_proto__codec_version__field_descriptors[4] =
3691 {
3692 {
3693 "alpha",
3694 1,
3695 PROTOBUF_C_LABEL_REQUIRED,
3696 PROTOBUF_C_TYPE_INT32,
3697 0, /* quantifier_offset */
3698 offsetof(MumbleProto__CodecVersion, alpha),
3699 NULL,
3700 NULL,
3701 0, /* flags */
3702 0,NULL,NULL /* reserved1,reserved2, etc */
3703 },
3704 {
3705 "beta",
3706 2,
3707 PROTOBUF_C_LABEL_REQUIRED,
3708 PROTOBUF_C_TYPE_INT32,
3709 0, /* quantifier_offset */
3710 offsetof(MumbleProto__CodecVersion, beta),
3711 NULL,
3712 NULL,
3713 0, /* flags */
3714 0,NULL,NULL /* reserved1,reserved2, etc */
3715 },
3716 {
3717 "prefer_alpha",
3718 3,
3719 PROTOBUF_C_LABEL_REQUIRED,
3720 PROTOBUF_C_TYPE_BOOL,
3721 0, /* quantifier_offset */
3722 offsetof(MumbleProto__CodecVersion, prefer_alpha),
3723 NULL,
3724 &mumble_proto__codec_version__prefer_alpha__default_value,
3725 0, /* flags */
3726 0,NULL,NULL /* reserved1,reserved2, etc */
3727 },
3728 {
3729 "opus",
3730 4,
3731 PROTOBUF_C_LABEL_OPTIONAL,
3732 PROTOBUF_C_TYPE_BOOL,
3733 offsetof(MumbleProto__CodecVersion, has_opus),
3734 offsetof(MumbleProto__CodecVersion, opus),
3735 NULL,
3736 &mumble_proto__codec_version__opus__default_value,
3737 0, /* flags */
3738 0,NULL,NULL /* reserved1,reserved2, etc */
3739 },
3740 };
3741 static const unsigned mumble_proto__codec_version__field_indices_by_name[] = {
3742 0, /* field[0] = alpha */
3743 1, /* field[1] = beta */
3744 3, /* field[3] = opus */
3745 2, /* field[2] = prefer_alpha */
3746 };
3747 static const ProtobufCIntRange mumble_proto__codec_version__number_ranges[1 + 1] =
3748 {
3749 { 1, 0 },
3750 { 0, 4 }
3751 };
3752 const ProtobufCMessageDescriptor mumble_proto__codec_version__descriptor =
3753 {
3754 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3755 "MumbleProto.CodecVersion",
3756 "CodecVersion",
3757 "MumbleProto__CodecVersion",
3758 "MumbleProto",
3759 sizeof(MumbleProto__CodecVersion),
3760 4,
3761 mumble_proto__codec_version__field_descriptors,
3762 mumble_proto__codec_version__field_indices_by_name,
3763 1, mumble_proto__codec_version__number_ranges,
3764 (ProtobufCMessageInit) mumble_proto__codec_version__init,
3765 NULL,NULL,NULL /* reserved[123] */
3766 };
3767 static const ProtobufCFieldDescriptor mumble_proto__user_stats__stats__field_descriptors[4] =
3768 {
3769 {
3770 "good",
3771 1,
3772 PROTOBUF_C_LABEL_OPTIONAL,
3773 PROTOBUF_C_TYPE_UINT32,
3774 offsetof(MumbleProto__UserStats__Stats, has_good),
3775 offsetof(MumbleProto__UserStats__Stats, good),
3776 NULL,
3777 NULL,
3778 0, /* flags */
3779 0,NULL,NULL /* reserved1,reserved2, etc */
3780 },
3781 {
3782 "late",
3783 2,
3784 PROTOBUF_C_LABEL_OPTIONAL,
3785 PROTOBUF_C_TYPE_UINT32,
3786 offsetof(MumbleProto__UserStats__Stats, has_late),
3787 offsetof(MumbleProto__UserStats__Stats, late),
3788 NULL,
3789 NULL,
3790 0, /* flags */
3791 0,NULL,NULL /* reserved1,reserved2, etc */
3792 },
3793 {
3794 "lost",
3795 3,
3796 PROTOBUF_C_LABEL_OPTIONAL,
3797 PROTOBUF_C_TYPE_UINT32,
3798 offsetof(MumbleProto__UserStats__Stats, has_lost),
3799 offsetof(MumbleProto__UserStats__Stats, lost),
3800 NULL,
3801 NULL,
3802 0, /* flags */
3803 0,NULL,NULL /* reserved1,reserved2, etc */
3804 },
3805 {
3806 "resync",
3807 4,
3808 PROTOBUF_C_LABEL_OPTIONAL,
3809 PROTOBUF_C_TYPE_UINT32,
3810 offsetof(MumbleProto__UserStats__Stats, has_resync),
3811 offsetof(MumbleProto__UserStats__Stats, resync),
3812 NULL,
3813 NULL,
3814 0, /* flags */
3815 0,NULL,NULL /* reserved1,reserved2, etc */
3816 },
3817 };
3818 static const unsigned mumble_proto__user_stats__stats__field_indices_by_name[] = {
3819 0, /* field[0] = good */
3820 1, /* field[1] = late */
3821 2, /* field[2] = lost */
3822 3, /* field[3] = resync */
3823 };
3824 static const ProtobufCIntRange mumble_proto__user_stats__stats__number_ranges[1 + 1] =
3825 {
3826 { 1, 0 },
3827 { 0, 4 }
3828 };
3829 const ProtobufCMessageDescriptor mumble_proto__user_stats__stats__descriptor =
3830 {
3831 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
3832 "MumbleProto.UserStats.Stats",
3833 "Stats",
3834 "MumbleProto__UserStats__Stats",
3835 "MumbleProto",
3836 sizeof(MumbleProto__UserStats__Stats),
3837 4,
3838 mumble_proto__user_stats__stats__field_descriptors,
3839 mumble_proto__user_stats__stats__field_indices_by_name,
3840 1, mumble_proto__user_stats__stats__number_ranges,
3841 (ProtobufCMessageInit) mumble_proto__user_stats__stats__init,
3842 NULL,NULL,NULL /* reserved[123] */
3843 };
3844 static const protobuf_c_boolean mumble_proto__user_stats__stats_only__default_value = 0;
3845 static const protobuf_c_boolean mumble_proto__user_stats__strong_certificate__default_value = 0;
3846 static const protobuf_c_boolean mumble_proto__user_stats__opus__default_value = 0;
3847 static const ProtobufCFieldDescriptor mumble_proto__user_stats__field_descriptors[19] =
3848 {
3849 {
3850 "session",
3851 1,
3852 PROTOBUF_C_LABEL_OPTIONAL,
3853 PROTOBUF_C_TYPE_UINT32,
3854 offsetof(MumbleProto__UserStats, has_session),
3855 offsetof(MumbleProto__UserStats, session),
3856 NULL,
3857 NULL,
3858 0, /* flags */
3859 0,NULL,NULL /* reserved1,reserved2, etc */
3860 },
3861 {
3862 "stats_only",
3863 2,
3864 PROTOBUF_C_LABEL_OPTIONAL,
3865 PROTOBUF_C_TYPE_BOOL,
3866 offsetof(MumbleProto__UserStats, has_stats_only),
3867 offsetof(MumbleProto__UserStats, stats_only),
3868 NULL,
3869 &mumble_proto__user_stats__stats_only__default_value,
3870 0, /* flags */
3871 0,NULL,NULL /* reserved1,reserved2, etc */
3872 },
3873 {
3874 "certificates",
3875 3,
3876 PROTOBUF_C_LABEL_REPEATED,
3877 PROTOBUF_C_TYPE_BYTES,
3878 offsetof(MumbleProto__UserStats, n_certificates),
3879 offsetof(MumbleProto__UserStats, certificates),
3880 NULL,
3881 NULL,
3882 0, /* flags */
3883 0,NULL,NULL /* reserved1,reserved2, etc */
3884 },
3885 {
3886 "from_client",
3887 4,
3888 PROTOBUF_C_LABEL_OPTIONAL,
3889 PROTOBUF_C_TYPE_MESSAGE,
3890 0, /* quantifier_offset */
3891 offsetof(MumbleProto__UserStats, from_client),
3892 &mumble_proto__user_stats__stats__descriptor,
3893 NULL,
3894 0, /* flags */
3895 0,NULL,NULL /* reserved1,reserved2, etc */
3896 },
3897 {
3898 "from_server",
3899 5,
3900 PROTOBUF_C_LABEL_OPTIONAL,
3901 PROTOBUF_C_TYPE_MESSAGE,
3902 0, /* quantifier_offset */
3903 offsetof(MumbleProto__UserStats, from_server),
3904 &mumble_proto__user_stats__stats__descriptor,
3905 NULL,
3906 0, /* flags */
3907 0,NULL,NULL /* reserved1,reserved2, etc */
3908 },
3909 {
3910 "udp_packets",
3911 6,
3912 PROTOBUF_C_LABEL_OPTIONAL,
3913 PROTOBUF_C_TYPE_UINT32,
3914 offsetof(MumbleProto__UserStats, has_udp_packets),
3915 offsetof(MumbleProto__UserStats, udp_packets),
3916 NULL,
3917 NULL,
3918 0, /* flags */
3919 0,NULL,NULL /* reserved1,reserved2, etc */
3920 },
3921 {
3922 "tcp_packets",
3923 7,
3924 PROTOBUF_C_LABEL_OPTIONAL,
3925 PROTOBUF_C_TYPE_UINT32,
3926 offsetof(MumbleProto__UserStats, has_tcp_packets),
3927 offsetof(MumbleProto__UserStats, tcp_packets),
3928 NULL,
3929 NULL,
3930 0, /* flags */
3931 0,NULL,NULL /* reserved1,reserved2, etc */
3932 },
3933 {
3934 "udp_ping_avg",
3935 8,
3936 PROTOBUF_C_LABEL_OPTIONAL,
3937 PROTOBUF_C_TYPE_FLOAT,
3938 offsetof(MumbleProto__UserStats, has_udp_ping_avg),
3939 offsetof(MumbleProto__UserStats, udp_ping_avg),
3940 NULL,
3941 NULL,
3942 0, /* flags */
3943 0,NULL,NULL /* reserved1,reserved2, etc */
3944 },
3945 {
3946 "udp_ping_var",
3947 9,
3948 PROTOBUF_C_LABEL_OPTIONAL,
3949 PROTOBUF_C_TYPE_FLOAT,
3950 offsetof(MumbleProto__UserStats, has_udp_ping_var),
3951 offsetof(MumbleProto__UserStats, udp_ping_var),
3952 NULL,
3953 NULL,
3954 0, /* flags */
3955 0,NULL,NULL /* reserved1,reserved2, etc */
3956 },
3957 {
3958 "tcp_ping_avg",
3959 10,
3960 PROTOBUF_C_LABEL_OPTIONAL,
3961 PROTOBUF_C_TYPE_FLOAT,
3962 offsetof(MumbleProto__UserStats, has_tcp_ping_avg),
3963 offsetof(MumbleProto__UserStats, tcp_ping_avg),
3964 NULL,
3965 NULL,
3966 0, /* flags */
3967 0,NULL,NULL /* reserved1,reserved2, etc */
3968 },
3969 {
3970 "tcp_ping_var",
3971 11,
3972 PROTOBUF_C_LABEL_OPTIONAL,
3973 PROTOBUF_C_TYPE_FLOAT,
3974 offsetof(MumbleProto__UserStats, has_tcp_ping_var),
3975 offsetof(MumbleProto__UserStats, tcp_ping_var),
3976 NULL,
3977 NULL,
3978 0, /* flags */
3979 0,NULL,NULL /* reserved1,reserved2, etc */
3980 },
3981 {
3982 "version",
3983 12,
3984 PROTOBUF_C_LABEL_OPTIONAL,
3985 PROTOBUF_C_TYPE_MESSAGE,
3986 0, /* quantifier_offset */
3987 offsetof(MumbleProto__UserStats, version),
3988 &mumble_proto__version__descriptor,
3989 NULL,
3990 0, /* flags */
3991 0,NULL,NULL /* reserved1,reserved2, etc */
3992 },
3993 {
3994 "celt_versions",
3995 13,
3996 PROTOBUF_C_LABEL_REPEATED,
3997 PROTOBUF_C_TYPE_INT32,
3998 offsetof(MumbleProto__UserStats, n_celt_versions),
3999 offsetof(MumbleProto__UserStats, celt_versions),
4000 NULL,
4001 NULL,
4002 0, /* flags */
4003 0,NULL,NULL /* reserved1,reserved2, etc */
4004 },
4005 {
4006 "address",
4007 14,
4008 PROTOBUF_C_LABEL_OPTIONAL,
4009 PROTOBUF_C_TYPE_BYTES,
4010 offsetof(MumbleProto__UserStats, has_address),
4011 offsetof(MumbleProto__UserStats, address),
4012 NULL,
4013 NULL,
4014 0, /* flags */
4015 0,NULL,NULL /* reserved1,reserved2, etc */
4016 },
4017 {
4018 "bandwidth",
4019 15,
4020 PROTOBUF_C_LABEL_OPTIONAL,
4021 PROTOBUF_C_TYPE_UINT32,
4022 offsetof(MumbleProto__UserStats, has_bandwidth),
4023 offsetof(MumbleProto__UserStats, bandwidth),
4024 NULL,
4025 NULL,
4026 0, /* flags */
4027 0,NULL,NULL /* reserved1,reserved2, etc */
4028 },
4029 {
4030 "onlinesecs",
4031 16,
4032 PROTOBUF_C_LABEL_OPTIONAL,
4033 PROTOBUF_C_TYPE_UINT32,
4034 offsetof(MumbleProto__UserStats, has_onlinesecs),
4035 offsetof(MumbleProto__UserStats, onlinesecs),
4036 NULL,
4037 NULL,
4038 0, /* flags */
4039 0,NULL,NULL /* reserved1,reserved2, etc */
4040 },
4041 {
4042 "idlesecs",
4043 17,
4044 PROTOBUF_C_LABEL_OPTIONAL,
4045 PROTOBUF_C_TYPE_UINT32,
4046 offsetof(MumbleProto__UserStats, has_idlesecs),
4047 offsetof(MumbleProto__UserStats, idlesecs),
4048 NULL,
4049 NULL,
4050 0, /* flags */
4051 0,NULL,NULL /* reserved1,reserved2, etc */
4052 },
4053 {
4054 "strong_certificate",
4055 18,
4056 PROTOBUF_C_LABEL_OPTIONAL,
4057 PROTOBUF_C_TYPE_BOOL,
4058 offsetof(MumbleProto__UserStats, has_strong_certificate),
4059 offsetof(MumbleProto__UserStats, strong_certificate),
4060 NULL,
4061 &mumble_proto__user_stats__strong_certificate__default_value,
4062 0, /* flags */
4063 0,NULL,NULL /* reserved1,reserved2, etc */
4064 },
4065 {
4066 "opus",
4067 19,
4068 PROTOBUF_C_LABEL_OPTIONAL,
4069 PROTOBUF_C_TYPE_BOOL,
4070 offsetof(MumbleProto__UserStats, has_opus),
4071 offsetof(MumbleProto__UserStats, opus),
4072 NULL,
4073 &mumble_proto__user_stats__opus__default_value,
4074 0, /* flags */
4075 0,NULL,NULL /* reserved1,reserved2, etc */
4076 },
4077 };
4078 static const unsigned mumble_proto__user_stats__field_indices_by_name[] = {
4079 13, /* field[13] = address */
4080 14, /* field[14] = bandwidth */
4081 12, /* field[12] = celt_versions */
4082 2, /* field[2] = certificates */
4083 3, /* field[3] = from_client */
4084 4, /* field[4] = from_server */
4085 16, /* field[16] = idlesecs */
4086 15, /* field[15] = onlinesecs */
4087 18, /* field[18] = opus */
4088 0, /* field[0] = session */
4089 1, /* field[1] = stats_only */
4090 17, /* field[17] = strong_certificate */
4091 6, /* field[6] = tcp_packets */
4092 9, /* field[9] = tcp_ping_avg */
4093 10, /* field[10] = tcp_ping_var */
4094 5, /* field[5] = udp_packets */
4095 7, /* field[7] = udp_ping_avg */
4096 8, /* field[8] = udp_ping_var */
4097 11, /* field[11] = version */
4098 };
4099 static const ProtobufCIntRange mumble_proto__user_stats__number_ranges[1 + 1] =
4100 {
4101 { 1, 0 },
4102 { 0, 19 }
4103 };
4104 const ProtobufCMessageDescriptor mumble_proto__user_stats__descriptor =
4105 {
4106 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4107 "MumbleProto.UserStats",
4108 "UserStats",
4109 "MumbleProto__UserStats",
4110 "MumbleProto",
4111 sizeof(MumbleProto__UserStats),
4112 19,
4113 mumble_proto__user_stats__field_descriptors,
4114 mumble_proto__user_stats__field_indices_by_name,
4115 1, mumble_proto__user_stats__number_ranges,
4116 (ProtobufCMessageInit) mumble_proto__user_stats__init,
4117 NULL,NULL,NULL /* reserved[123] */
4118 };
4119 static const ProtobufCFieldDescriptor mumble_proto__suggest_config__field_descriptors[3] =
4120 {
4121 {
4122 "version",
4123 1,
4124 PROTOBUF_C_LABEL_OPTIONAL,
4125 PROTOBUF_C_TYPE_UINT32,
4126 offsetof(MumbleProto__SuggestConfig, has_version),
4127 offsetof(MumbleProto__SuggestConfig, version),
4128 NULL,
4129 NULL,
4130 0, /* flags */
4131 0,NULL,NULL /* reserved1,reserved2, etc */
4132 },
4133 {
4134 "positional",
4135 2,
4136 PROTOBUF_C_LABEL_OPTIONAL,
4137 PROTOBUF_C_TYPE_BOOL,
4138 offsetof(MumbleProto__SuggestConfig, has_positional),
4139 offsetof(MumbleProto__SuggestConfig, positional),
4140 NULL,
4141 NULL,
4142 0, /* flags */
4143 0,NULL,NULL /* reserved1,reserved2, etc */
4144 },
4145 {
4146 "push_to_talk",
4147 3,
4148 PROTOBUF_C_LABEL_OPTIONAL,
4149 PROTOBUF_C_TYPE_BOOL,
4150 offsetof(MumbleProto__SuggestConfig, has_push_to_talk),
4151 offsetof(MumbleProto__SuggestConfig, push_to_talk),
4152 NULL,
4153 NULL,
4154 0, /* flags */
4155 0,NULL,NULL /* reserved1,reserved2, etc */
4156 },
4157 };
4158 static const unsigned mumble_proto__suggest_config__field_indices_by_name[] = {
4159 1, /* field[1] = positional */
4160 2, /* field[2] = push_to_talk */
4161 0, /* field[0] = version */
4162 };
4163 static const ProtobufCIntRange mumble_proto__suggest_config__number_ranges[1 + 1] =
4164 {
4165 { 1, 0 },
4166 { 0, 3 }
4167 };
4168 const ProtobufCMessageDescriptor mumble_proto__suggest_config__descriptor =
4169 {
4170 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4171 "MumbleProto.SuggestConfig",
4172 "SuggestConfig",
4173 "MumbleProto__SuggestConfig",
4174 "MumbleProto",
4175 sizeof(MumbleProto__SuggestConfig),
4176 3,
4177 mumble_proto__suggest_config__field_descriptors,
4178 mumble_proto__suggest_config__field_indices_by_name,
4179 1, mumble_proto__suggest_config__number_ranges,
4180 (ProtobufCMessageInit) mumble_proto__suggest_config__init,
4181 NULL,NULL,NULL /* reserved[123] */
4182 };
4183 static const ProtobufCFieldDescriptor mumble_proto__request_blob__field_descriptors[3] =
4184 {
4185 {
4186 "session_texture",
4187 1,
4188 PROTOBUF_C_LABEL_REPEATED,
4189 PROTOBUF_C_TYPE_UINT32,
4190 offsetof(MumbleProto__RequestBlob, n_session_texture),
4191 offsetof(MumbleProto__RequestBlob, session_texture),
4192 NULL,
4193 NULL,
4194 0, /* flags */
4195 0,NULL,NULL /* reserved1,reserved2, etc */
4196 },
4197 {
4198 "session_comment",
4199 2,
4200 PROTOBUF_C_LABEL_REPEATED,
4201 PROTOBUF_C_TYPE_UINT32,
4202 offsetof(MumbleProto__RequestBlob, n_session_comment),
4203 offsetof(MumbleProto__RequestBlob, session_comment),
4204 NULL,
4205 NULL,
4206 0, /* flags */
4207 0,NULL,NULL /* reserved1,reserved2, etc */
4208 },
4209 {
4210 "channel_description",
4211 3,
4212 PROTOBUF_C_LABEL_REPEATED,
4213 PROTOBUF_C_TYPE_UINT32,
4214 offsetof(MumbleProto__RequestBlob, n_channel_description),
4215 offsetof(MumbleProto__RequestBlob, channel_description),
4216 NULL,
4217 NULL,
4218 0, /* flags */
4219 0,NULL,NULL /* reserved1,reserved2, etc */
4220 },
4221 };
4222 static const unsigned mumble_proto__request_blob__field_indices_by_name[] = {
4223 2, /* field[2] = channel_description */
4224 1, /* field[1] = session_comment */
4225 0, /* field[0] = session_texture */
4226 };
4227 static const ProtobufCIntRange mumble_proto__request_blob__number_ranges[1 + 1] =
4228 {
4229 { 1, 0 },
4230 { 0, 3 }
4231 };
4232 const ProtobufCMessageDescriptor mumble_proto__request_blob__descriptor =
4233 {
4234 PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4235 "MumbleProto.RequestBlob",
4236 "RequestBlob",
4237 "MumbleProto__RequestBlob",
4238 "MumbleProto",
4239 sizeof(MumbleProto__RequestBlob),
4240 3,
4241 mumble_proto__request_blob__field_descriptors,
4242 mumble_proto__request_blob__field_indices_by_name,
4243 1, mumble_proto__request_blob__number_ranges,
4244 (ProtobufCMessageInit) mumble_proto__request_blob__init,
4245 NULL,NULL,NULL /* reserved[123] */
4246 };
4247