1 /* Copyright (C) 2009-2014, Martin Johansson <martin@fatbob.nu>
2 Copyright (C) 2005-2014, Thorvald Natvig <thorvald@natvig.com>
6 Redistribution and use in source and binary forms, with or without
7 modification, are permitted provided that the following conditions
10 - Redistributions of source code must retain the above copyright notice,
11 this list of conditions and the following disclaimer.
12 - Redistributions in binary form must reproduce the above copyright notice,
13 this list of conditions and the following disclaimer in the documentation
14 and/or other materials provided with the distribution.
15 - Neither the name of the Developers nor the names of its contributors may
16 be used to endorse or promote products derived from this software without
17 specific prior written permission.
19 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
23 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 #include <arpa/inet.h>
43 #define PREAMBLE_SIZE 6
45 static message_t *Msg_create_nopayload(messageType_t messageType);
47 static void Msg_addPreamble(uint8_t *buffer, uint16_t type, uint32_t len)
49 buffer[1] = (type) & 0xff;
50 buffer[0] = (type >> 8) & 0xff;
52 buffer[5] = (len) & 0xff;
53 buffer[4] = (len >> 8) & 0xff;
54 buffer[3] = (len >> 16) & 0xff;
55 buffer[2] = (len >> 24) & 0xff;
58 static void Msg_getPreamble(uint8_t *buffer, int *type, int *len)
63 msgType = buffer[1] | (buffer[0] << 8);
64 msgLen = buffer[5] | (buffer[4] << 8) | (buffer[3] << 16) | (buffer[2] << 24);
69 #define MAX_MSGSIZE (BUFSIZE - PREAMBLE_SIZE)
70 int Msg_messageToNetwork(message_t *msg, uint8_t *buffer)
73 uint8_t *bufptr = buffer + PREAMBLE_SIZE;
75 Log_debug("To net: msg type %d", msg->messageType);
76 switch (msg->messageType) {
78 len = mumble_proto__version__get_packed_size(msg->payload.version);
79 if (len > MAX_MSGSIZE) {
80 Log_warn("Too big tx message. Discarding");
83 Msg_addPreamble(buffer, msg->messageType, len);
84 mumble_proto__version__pack(msg->payload.version, bufptr);
86 case UDPTunnel: /* Non-standard handling of tunneled voice traffic. */
87 if (msg->payload.UDPTunnel->packet.len > MAX_MSGSIZE) {
88 Log_warn("Too big tx message. Discarding");
91 len = msg->payload.UDPTunnel->packet.len;
92 Msg_addPreamble(buffer, msg->messageType, msg->payload.UDPTunnel->packet.len);
93 memcpy(bufptr, msg->payload.UDPTunnel->packet.data, msg->payload.UDPTunnel->packet.len);
96 len = mumble_proto__authenticate__get_packed_size(msg->payload.authenticate);
97 if (len > MAX_MSGSIZE) {
98 Log_warn("Too big tx message. Discarding");
101 Msg_addPreamble(buffer, msg->messageType, len);
102 mumble_proto__authenticate__pack(msg->payload.authenticate, bufptr);
105 len = mumble_proto__ping__get_packed_size(msg->payload.ping);
106 if (len > MAX_MSGSIZE) {
107 Log_warn("Too big tx message. Discarding");
110 Msg_addPreamble(buffer, msg->messageType, len);
111 mumble_proto__ping__pack(msg->payload.ping, bufptr);
114 len = mumble_proto__reject__get_packed_size(msg->payload.reject);
115 if (len > MAX_MSGSIZE) {
116 Log_warn("Too big tx message. Discarding");
119 Msg_addPreamble(buffer, msg->messageType, len);
120 mumble_proto__reject__pack(msg->payload.reject, bufptr);
123 len = mumble_proto__server_sync__get_packed_size(msg->payload.serverSync);
124 if (len > MAX_MSGSIZE) {
125 Log_warn("Too big tx message. Discarding");
128 Msg_addPreamble(buffer, msg->messageType, len);
129 mumble_proto__server_sync__pack(msg->payload.serverSync, bufptr);
132 len = mumble_proto__text_message__get_packed_size(msg->payload.textMessage);
133 if (len > MAX_MSGSIZE) {
134 Log_warn("Too big tx message. Discarding");
137 Msg_addPreamble(buffer, msg->messageType, len);
138 mumble_proto__text_message__pack(msg->payload.textMessage, bufptr);
140 case PermissionDenied:
141 len = mumble_proto__permission_denied__get_packed_size(msg->payload.permissionDenied);
142 if (len > MAX_MSGSIZE) {
143 Log_warn("Too big tx message. Discarding");
146 Msg_addPreamble(buffer, msg->messageType, len);
147 mumble_proto__permission_denied__pack(msg->payload.permissionDenied, bufptr);
150 len = mumble_proto__crypt_setup__get_packed_size(msg->payload.cryptSetup);
151 if (len > MAX_MSGSIZE) {
152 Log_warn("Too big tx message. Discarding");
155 Msg_addPreamble(buffer, msg->messageType, len);
156 mumble_proto__crypt_setup__pack(msg->payload.cryptSetup, bufptr);
159 len = mumble_proto__user_list__get_packed_size(msg->payload.userList);
160 if (len > MAX_MSGSIZE) {
161 Log_warn("Too big tx message. Discarding");
164 Msg_addPreamble(buffer, msg->messageType, len);
165 mumble_proto__user_list__pack(msg->payload.userList, bufptr);
168 len = mumble_proto__user_state__get_packed_size(msg->payload.userState);
169 if (len > MAX_MSGSIZE) {
170 Log_warn("Too big tx message. Discarding");
173 Msg_addPreamble(buffer, msg->messageType, len);
174 mumble_proto__user_state__pack(msg->payload.userState, bufptr);
177 len = mumble_proto__user_remove__get_packed_size(msg->payload.userRemove);
178 if (len > MAX_MSGSIZE) {
179 Log_warn("Too big tx message. Discarding");
182 Msg_addPreamble(buffer, msg->messageType, len);
183 mumble_proto__user_remove__pack(msg->payload.userRemove, bufptr);
186 len = mumble_proto__channel_state__get_packed_size(msg->payload.channelState);
187 if (len > MAX_MSGSIZE) {
188 Log_warn("Too big tx message. Discarding");
191 Msg_addPreamble(buffer, msg->messageType, len);
192 mumble_proto__channel_state__pack(msg->payload.channelState, bufptr);
195 len = mumble_proto__voice_target__get_packed_size(msg->payload.voiceTarget);
196 if (len > MAX_MSGSIZE) {
197 Log_warn("Too big tx message. Discarding");
200 Msg_addPreamble(buffer, msg->messageType, len);
201 mumble_proto__voice_target__pack(msg->payload.voiceTarget, bufptr);
204 len = mumble_proto__codec_version__get_packed_size(msg->payload.codecVersion);
205 if (len > MAX_MSGSIZE) {
206 Log_warn("Too big tx message. Discarding");
209 Msg_addPreamble(buffer, msg->messageType, len);
210 mumble_proto__codec_version__pack(msg->payload.codecVersion, bufptr);
212 case PermissionQuery:
213 len = mumble_proto__permission_query__get_packed_size(msg->payload.permissionQuery);
214 if (len > MAX_MSGSIZE) {
215 Log_warn("Too big tx message. Discarding");
218 Msg_addPreamble(buffer, msg->messageType, len);
219 mumble_proto__permission_query__pack(msg->payload.permissionQuery, bufptr);
222 len = mumble_proto__channel_remove__get_packed_size(msg->payload.channelRemove);
223 if (len > MAX_MSGSIZE) {
224 Log_warn("Too big tx message. Discarding");
227 Msg_addPreamble(buffer, msg->messageType, len);
228 mumble_proto__channel_remove__pack(msg->payload.channelRemove, bufptr);
232 len = mumble_proto__user_stats__get_packed_size(msg->payload.userStats);
233 if (len > MAX_MSGSIZE) {
234 Log_warn("Too big tx message. Discarding");
237 Msg_addPreamble(buffer, msg->messageType, len);
238 mumble_proto__user_stats__pack(msg->payload.userStats, bufptr);
242 len = mumble_proto__server_config__get_packed_size(msg->payload.serverConfig);
243 if (len > MAX_MSGSIZE) {
244 Log_warn("Too big tx message. Discarding");
247 Msg_addPreamble(buffer, msg->messageType, len);
248 mumble_proto__server_config__pack(msg->payload.serverConfig, bufptr);
252 len = mumble_proto__ban_list__get_packed_size(msg->payload.banList);
253 if (len > MAX_MSGSIZE) {
254 Log_warn("Too big tx message. Discarding");
257 Msg_addPreamble(buffer, msg->messageType, len);
258 Log_debug("Msg_MessageToNetwork: BanList size %d", len);
259 mumble_proto__ban_list__pack(msg->payload.banList, bufptr);
262 Log_warn("Msg_MessageToNetwork: Unsupported message %d", msg->messageType);
265 return len + PREAMBLE_SIZE;
268 static message_t *Msg_create_nopayload(messageType_t messageType)
270 message_t *msg = Memory_safeCalloc(1, sizeof(message_t));
273 msg->messageType = messageType;
274 init_list_entry(&msg->node);
278 message_t *Msg_create(messageType_t messageType)
280 message_t *msg = Msg_create_nopayload(messageType);
283 switch (messageType) {
285 msg->payload.version = Memory_safeMalloc(1, sizeof(MumbleProto__Version));
286 mumble_proto__version__init(msg->payload.version);
289 msg->payload.UDPTunnel = Memory_safeMalloc(1, sizeof(MumbleProto__UDPTunnel));
290 mumble_proto__udptunnel__init(msg->payload.UDPTunnel);
293 msg->payload.authenticate = Memory_safeMalloc(1, sizeof(MumbleProto__Authenticate));
294 mumble_proto__authenticate__init(msg->payload.authenticate);
297 msg->payload.ping = Memory_safeMalloc(1, sizeof(MumbleProto__Ping));
298 mumble_proto__ping__init(msg->payload.ping);
301 msg->payload.reject = Memory_safeMalloc(1, sizeof(MumbleProto__Reject));
302 mumble_proto__reject__init(msg->payload.reject);
305 msg->payload.serverSync = Memory_safeMalloc(1, sizeof(MumbleProto__ServerSync));
306 mumble_proto__server_sync__init(msg->payload.serverSync);
309 msg->payload.textMessage = Memory_safeMalloc(1, sizeof(MumbleProto__TextMessage));
310 mumble_proto__text_message__init(msg->payload.textMessage);
312 case PermissionDenied:
313 msg->payload.permissionDenied = Memory_safeMalloc(1, sizeof(MumbleProto__PermissionDenied));
314 mumble_proto__permission_denied__init(msg->payload.permissionDenied);
317 msg->payload.cryptSetup = Memory_safeMalloc(1, sizeof(MumbleProto__CryptSetup));
318 mumble_proto__crypt_setup__init(msg->payload.cryptSetup);
321 msg->payload.userList = Memory_safeMalloc(1, sizeof(MumbleProto__UserList));
322 mumble_proto__user_list__init(msg->payload.userList);
325 msg->payload.userState = Memory_safeMalloc(1, sizeof(MumbleProto__UserState));
326 mumble_proto__user_state__init(msg->payload.userState);
329 msg->payload.channelState = Memory_safeMalloc(1, sizeof(MumbleProto__ChannelState));
330 mumble_proto__channel_state__init(msg->payload.channelState);
333 msg->payload.userRemove = Memory_safeMalloc(1, sizeof(MumbleProto__UserRemove));
334 mumble_proto__user_remove__init(msg->payload.userRemove);
337 msg->payload.voiceTarget = Memory_safeMalloc(1, sizeof(MumbleProto__VoiceTarget));
338 mumble_proto__voice_target__init(msg->payload.voiceTarget);
341 msg->payload.codecVersion = Memory_safeMalloc(1, sizeof(MumbleProto__CodecVersion));
342 mumble_proto__codec_version__init(msg->payload.codecVersion);
344 case PermissionQuery:
345 msg->payload.permissionQuery = Memory_safeMalloc(1, sizeof(MumbleProto__PermissionQuery));
346 mumble_proto__permission_query__init(msg->payload.permissionQuery);
349 msg->payload.channelRemove = Memory_safeMalloc(1, sizeof(MumbleProto__ChannelRemove));
350 mumble_proto__channel_remove__init(msg->payload.channelRemove);
353 msg->payload.userStats = Memory_safeMalloc(1, sizeof(MumbleProto__UserStats));
354 mumble_proto__user_stats__init(msg->payload.userStats);
356 msg->payload.userStats->from_client = Memory_safeMalloc(1, sizeof(MumbleProto__UserStats__Stats));
357 mumble_proto__user_stats__stats__init(msg->payload.userStats->from_client);
359 msg->payload.userStats->from_server = Memory_safeMalloc(1, sizeof(MumbleProto__UserStats__Stats));
360 mumble_proto__user_stats__stats__init(msg->payload.userStats->from_server);
362 msg->payload.userStats->version = Memory_safeMalloc(1, sizeof(MumbleProto__Version));
363 mumble_proto__version__init(msg->payload.userStats->version);
367 msg->payload.serverConfig = Memory_safeMalloc(1, sizeof(MumbleProto__ServerConfig));
368 mumble_proto__server_config__init(msg->payload.serverConfig);
372 Log_warn("Msg_create: Unsupported message %d", msg->messageType);
379 message_t *Msg_banList_create(int n_bans)
381 message_t *msg = Msg_create_nopayload(BanList);
384 msg->payload.banList = Memory_safeCalloc(1, sizeof(MumbleProto__BanList));
385 mumble_proto__ban_list__init(msg->payload.banList);
386 msg->payload.banList->n_bans = n_bans;
387 msg->payload.banList->bans = Memory_safeMalloc(n_bans, sizeof(MumbleProto__BanList__BanEntry *));
388 for (i = 0; i < n_bans; i++) {
389 msg->payload.banList->bans[i] = Memory_safeCalloc(1, sizeof(MumbleProto__BanList__BanEntry));
390 mumble_proto__ban_list__ban_entry__init(msg->payload.banList->bans[i]);
395 void Msg_banList_addEntry(message_t *msg, int index, uint8_t *address, uint32_t mask,
396 char *name, char *hash, char *reason, char *start, uint32_t duration)
398 MumbleProto__BanList__BanEntry *entry = msg->payload.banList->bans[index];
400 entry->address.data = Memory_safeMalloc(1, 16);
401 memcpy(entry->address.data, address, 16);
402 entry->address.len = 16;
404 entry->name = strdup(name);
405 entry->hash = strdup(hash);
406 entry->reason = strdup(reason);
407 entry->start = strdup(start);
408 if (!entry->name || !entry->hash || !entry->reason || !entry->start)
409 Log_fatal("Out of memory");
412 entry->duration = duration;
413 entry->has_duration = true;
415 Log_debug("Msg_banList_addEntry: %s %s %s %s %s",
416 entry->name, entry->hash, entry->address.data, entry->reason, entry->start);
419 void Msg_banList_getEntry(message_t *msg, int index, uint8_t **address, uint32_t *mask,
420 char **name, char **hash, char **reason, char **start, uint32_t *duration)
422 MumbleProto__BanList__BanEntry *entry = msg->payload.banList->bans[index];
424 *address = entry->address.data;
428 *reason = entry->reason;
429 *start = entry->start;
430 if (entry->has_duration)
431 *duration = entry->duration;
437 void Msg_inc_ref(message_t *msg)
442 void Msg_free(message_t *msg)
446 if (msg->refcount) msg->refcount--;
447 if (msg->refcount > 0)
450 switch (msg->messageType) {
453 mumble_proto__version__free_unpacked(msg->payload.version, NULL);
455 free(msg->payload.version->release);
456 free(msg->payload.version->os);
457 free(msg->payload.version->os_version);
458 free(msg->payload.version);
463 mumble_proto__udptunnel__free_unpacked(msg->payload.UDPTunnel, NULL);
465 free(msg->payload.UDPTunnel->packet.data);
466 free(msg->payload.UDPTunnel);
471 mumble_proto__authenticate__free_unpacked(msg->payload.authenticate, NULL);
473 free(msg->payload.authenticate);
477 mumble_proto__ping__free_unpacked(msg->payload.ping, NULL);
479 free(msg->payload.ping);
484 mumble_proto__reject__free_unpacked(msg->payload.reject, NULL);
486 free(msg->payload.reject->reason);
487 free(msg->payload.reject);
492 mumble_proto__server_sync__free_unpacked(msg->payload.serverSync, NULL);
494 free(msg->payload.serverSync->welcome_text);
495 free(msg->payload.serverSync);
500 mumble_proto__text_message__free_unpacked(msg->payload.textMessage, NULL);
502 free(msg->payload.textMessage->message);
503 free(msg->payload.textMessage->session);
504 free(msg->payload.textMessage->channel_id);
505 free(msg->payload.textMessage->tree_id);
506 free(msg->payload.textMessage);
509 case PermissionDenied:
511 mumble_proto__permission_denied__free_unpacked(msg->payload.permissionDenied, NULL);
513 free(msg->payload.permissionDenied->reason);
514 free(msg->payload.permissionDenied);
519 mumble_proto__crypt_setup__free_unpacked(msg->payload.cryptSetup, NULL);
521 free(msg->payload.cryptSetup);
526 mumble_proto__user_list__free_unpacked(msg->payload.userList, NULL);
528 free(msg->payload.userList);
533 mumble_proto__user_state__free_unpacked(msg->payload.userState, NULL);
535 free(msg->payload.userState->name);
536 free(msg->payload.userState);
541 mumble_proto__channel_state__free_unpacked(msg->payload.channelState, NULL);
543 free(msg->payload.channelState->name);
544 free(msg->payload.channelState->description);
545 free(msg->payload.channelState->links);
546 free(msg->payload.channelState);
551 mumble_proto__user_remove__free_unpacked(msg->payload.userRemove, NULL);
553 free(msg->payload.userRemove);
558 mumble_proto__voice_target__free_unpacked(msg->payload.voiceTarget, NULL);
560 free(msg->payload.voiceTarget);
565 mumble_proto__codec_version__free_unpacked(msg->payload.codecVersion, NULL);
567 free(msg->payload.codecVersion);
570 case PermissionQuery:
572 mumble_proto__permission_query__free_unpacked(msg->payload.permissionQuery, NULL);
574 free(msg->payload.permissionQuery);
579 mumble_proto__channel_remove__free_unpacked(msg->payload.channelRemove, NULL);
581 free(msg->payload.channelRemove);
586 mumble_proto__user_stats__free_unpacked(msg->payload.userStats, NULL);
588 free(msg->payload.userStats->from_client);
589 free(msg->payload.userStats->from_server);
590 if (msg->payload.userStats->version) {
591 free(msg->payload.userStats->version->release);
592 free(msg->payload.userStats->version->os);
593 free(msg->payload.userStats->version->os_version);
594 free(msg->payload.userStats->version);
596 free(msg->payload.userStats->celt_versions);
597 if (msg->payload.userStats->certificates) {
598 free(msg->payload.userStats->certificates->data);
599 free(msg->payload.userStats->certificates);
601 free(msg->payload.userStats->address.data);
603 free(msg->payload.userStats);
608 mumble_proto__server_config__free_unpacked(msg->payload.serverConfig, NULL);
610 free(msg->payload.serverConfig);
615 mumble_proto__ban_list__free_unpacked(msg->payload.banList, NULL);
617 for (i = 0; i < msg->payload.banList->n_bans; i++) {
618 free(msg->payload.banList->bans[i]->address.data);
619 free(msg->payload.banList->bans[i]->name);
620 free(msg->payload.banList->bans[i]->hash);
621 free(msg->payload.banList->bans[i]->reason);
622 free(msg->payload.banList->bans[i]->start);
623 free(msg->payload.banList->bans[i]);
625 free(msg->payload.banList->bans);
626 free(msg->payload.banList);
631 Log_warn("Msg_free: Unsupported message %d", msg->messageType);
637 message_t *Msg_CreateVoiceMsg(uint8_t *data, int size)
639 message_t *msg = NULL;
641 msg = Msg_create_nopayload(UDPTunnel);
642 msg->unpacked = false;
643 msg->payload.UDPTunnel = Memory_safeMalloc(1, sizeof(struct _MumbleProto__UDPTunnel));
644 msg->payload.UDPTunnel->packet.data = Memory_safeMalloc(1, size);
645 memcpy(msg->payload.UDPTunnel->packet.data, data, size);
646 msg->payload.UDPTunnel->packet.len = size;
650 message_t *Msg_networkToMessage(uint8_t *data, int size)
652 message_t *msg = NULL;
653 uint8_t *msgData = &data[6];
654 int messageType, msgLen;
656 Msg_getPreamble(data, &messageType, &msgLen);
658 Log_debug("Message type %d size %d", messageType, msgLen);
659 //dumpmsg(data, size);
661 switch (messageType) {
664 msg = Msg_create_nopayload(Version);
665 msg->unpacked = true;
666 msg->payload.version = mumble_proto__version__unpack(NULL, msgLen, msgData);
667 if (msg->payload.version == NULL)
671 case UDPTunnel: /* Non-standard handling of tunneled voice data */
673 msg = Msg_CreateVoiceMsg(msgData, msgLen);
678 msg = Msg_create_nopayload(Authenticate);
679 msg->unpacked = true;
680 msg->payload.authenticate = mumble_proto__authenticate__unpack(NULL, msgLen, msgData);
681 if (msg->payload.authenticate == NULL)
687 msg = Msg_create_nopayload(Ping);
688 msg->unpacked = true;
689 msg->payload.ping = mumble_proto__ping__unpack(NULL, msgLen, msgData);
690 if (msg->payload.ping == NULL)
696 msg = Msg_create_nopayload(Reject);
697 msg->unpacked = true;
698 msg->payload.reject = mumble_proto__reject__unpack(NULL, msgLen, msgData);
699 if (msg->payload.reject == NULL)
705 msg = Msg_create_nopayload(ServerSync);
706 msg->unpacked = true;
707 msg->payload.serverSync = mumble_proto__server_sync__unpack(NULL, msgLen, msgData);
708 if (msg->payload.serverSync == NULL)
714 msg = Msg_create_nopayload(TextMessage);
715 msg->unpacked = true;
716 msg->payload.textMessage = mumble_proto__text_message__unpack(NULL, msgLen, msgData);
717 if (msg->payload.textMessage == NULL)
721 case PermissionDenied:
723 msg = Msg_create_nopayload(PermissionDenied);
724 msg->unpacked = true;
725 msg->payload.permissionDenied = mumble_proto__permission_denied__unpack(NULL, msgLen, msgData);
726 if (msg->payload.permissionDenied == NULL)
732 msg = Msg_create_nopayload(CryptSetup);
733 msg->unpacked = true;
734 msg->payload.cryptSetup = mumble_proto__crypt_setup__unpack(NULL, msgLen, msgData);
735 if (msg->payload.cryptSetup == NULL)
741 msg = Msg_create_nopayload(UserList);
742 msg->unpacked = true;
743 msg->payload.userList = mumble_proto__user_list__unpack(NULL, msgLen, msgData);
744 if (msg->payload.userList == NULL)
750 msg = Msg_create_nopayload(UserState);
751 msg->unpacked = true;
752 msg->payload.userState = mumble_proto__user_state__unpack(NULL, msgLen, msgData);
753 if (msg->payload.userState == NULL)
759 msg = Msg_create_nopayload(ChannelState);
760 msg->unpacked = true;
761 msg->payload.channelState = mumble_proto__channel_state__unpack(NULL, msgLen, msgData);
762 if (msg->payload.channelState == NULL)
768 msg = Msg_create_nopayload(VoiceTarget);
769 msg->unpacked = true;
770 msg->payload.voiceTarget = mumble_proto__voice_target__unpack(NULL, msgLen, msgData);
771 if (msg->payload.voiceTarget == NULL)
777 msg = Msg_create_nopayload(CodecVersion);
778 msg->unpacked = true;
779 msg->payload.codecVersion = mumble_proto__codec_version__unpack(NULL, msgLen, msgData);
780 if (msg->payload.codecVersion == NULL)
784 case PermissionQuery:
786 msg = Msg_create_nopayload(PermissionQuery);
787 msg->unpacked = true;
788 msg->payload.permissionQuery = mumble_proto__permission_query__unpack(NULL, msgLen, msgData);
789 if (msg->payload.permissionQuery == NULL)
795 msg = Msg_create_nopayload(ChannelRemove);
796 msg->unpacked = true;
797 msg->payload.channelRemove = mumble_proto__channel_remove__unpack(NULL, msgLen, msgData);
798 if (msg->payload.channelRemove == NULL)
804 msg = Msg_create_nopayload(UserStats);
805 msg->unpacked = true;
806 msg->payload.userStats = mumble_proto__user_stats__unpack(NULL, msgLen, msgData);
807 if (msg->payload.userStats == NULL)
813 msg = Msg_create_nopayload(UserRemove);
814 msg->unpacked = true;
815 msg->payload.userRemove = mumble_proto__user_remove__unpack(NULL, msgLen, msgData);
816 if (msg->payload.userRemove == NULL)
822 msg = Msg_create_nopayload(BanList);
823 msg->unpacked = true;
824 msg->payload.banList = mumble_proto__ban_list__unpack(NULL, msgLen, msgData);
825 if (msg->payload.banList == NULL)
831 Log_warn("Msg_networkToMessage: Unsupported message %d", messageType);