src/messages.c

   1 /* Copyright (C) 2009-2010, Martin Johansson <martin@fatbob.nu>
   2    Copyright (C) 2005-2010, Thorvald Natvig <thorvald@natvig.com>
   3
   4    All rights reserved.
   5
   6    Redistribution and use in source and binary forms, with or without
   7    modification, are permitted provided that the following conditions
   8    are met:
   9
  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.
  18
  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.
  30 */
  31
  32 #include <stdlib.h>
  33 #include <stdio.h>
  34 #include <string.h>
  35 #include <arpa/inet.h>
  36
  37 #include "messages.h"
  38 #include "client.h"
  39 #include "pds.h"
  40 #include "log.h"
  41
  42 #define PREAMBLE_SIZE 6
  43
  44 void dumpmsg(uint8_t *data, int size);
  45 static message_t *Msg_create_nopayload(messageType_t messageType);
  46
  47 void Msg_addPreamble(uint8_t *buffer, uint16_t type, uint32_t len)
  48 {
  49         type = htons(type);
  50         len = htonl(len);
  51
  52         buffer[0] = (type) & 0xff;
  53         buffer[1] = (type >> 8) & 0xff;
  54
  55         buffer[2] = (len) & 0xff;
  56         buffer[3] = (len >> 8) & 0xff;
  57         buffer[4] = (len >> 16) & 0xff;
  58         buffer[5] = (len >> 24) & 0xff;
  59 }
  60
  61 static void Msg_getPreamble(uint8_t *buffer, int *type, int *len)
  62 {
  63         uint16_t msgType;
  64         uint32_t msgLen;
  65
  66         msgType = buffer[0] | (buffer[1] << 8);
  67         msgLen = buffer[2] | (buffer[3] << 8) | (buffer[4] << 16) | (buffer[5] << 24);
  68         *type = (int)ntohs(msgType);
  69         *len = (int)ntohl(msgLen);
  70 }
  71
  72 #define MAX_MSGSIZE (BUFSIZE - PREAMBLE_SIZE)
  73 int Msg_messageToNetwork(message_t *msg, uint8_t *buffer)
  74 {
  75         int len;
  76         uint8_t *bufptr = buffer + PREAMBLE_SIZE;
  77
  78         Log_debug("To net: msg type %d", msg->messageType);
  79         switch (msg->messageType) {
  80         case Version:
  81                 len = mumble_proto__version__get_packed_size(msg->payload.version);
  82                 if (len > MAX_MSGSIZE) {
  83                         Log_warn("Too big tx message. Discarding");
  84                         break;
  85                 }
  86                 Msg_addPreamble(buffer, msg->messageType, len);
  87                 mumble_proto__version__pack(msg->payload.version, bufptr);
  88                 break;
  89         case UDPTunnel: /* Non-standard handling of tunneled voice traffic. */
  90                 if (msg->payload.UDPTunnel->packet.len > MAX_MSGSIZE) {
  91                         Log_warn("Too big tx message. Discarding");
  92                         break;
  93                 }
  94                 len = msg->payload.UDPTunnel->packet.len;
  95                 Msg_addPreamble(buffer, msg->messageType, msg->payload.UDPTunnel->packet.len);
  96                 memcpy(bufptr, msg->payload.UDPTunnel->packet.data, msg->payload.UDPTunnel->packet.len);
  97                 break;
  98         case Authenticate:
  99                 len = mumble_proto__authenticate__get_packed_size(msg->payload.authenticate);
 100                 if (len > MAX_MSGSIZE) {
 101                         Log_warn("Too big tx message. Discarding");
 102                         break;
 103                         }
 104                 Msg_addPreamble(buffer, msg->messageType, len);
 105                 mumble_proto__authenticate__pack(msg->payload.authenticate, bufptr);
 106                 break;
 107         case Ping:
 108                 len = mumble_proto__ping__get_packed_size(msg->payload.ping);
 109                 if (len > MAX_MSGSIZE) {
 110                         Log_warn("Too big tx message. Discarding");
 111                         break;
 112                         }
 113                 Msg_addPreamble(buffer, msg->messageType, len);
 114                 mumble_proto__ping__pack(msg->payload.ping, bufptr);
 115                 break;
 116         case Reject:
 117                 len = mumble_proto__reject__get_packed_size(msg->payload.reject);
 118                 if (len > MAX_MSGSIZE) {
 119                         Log_warn("Too big tx message. Discarding");
 120                         break;
 121                         }
 122                 Msg_addPreamble(buffer, msg->messageType, len);
 123                 mumble_proto__reject__pack(msg->payload.reject, bufptr);
 124                 break;
 125         case ServerSync:
 126                 len = mumble_proto__server_sync__get_packed_size(msg->payload.serverSync);
 127                 if (len > MAX_MSGSIZE) {
 128                         Log_warn("Too big tx message. Discarding");
 129                         break;
 130                         }
 131                 Msg_addPreamble(buffer, msg->messageType, len);
 132                 mumble_proto__server_sync__pack(msg->payload.serverSync, bufptr);
 133                 break;
 134         case TextMessage:
 135                 len = mumble_proto__text_message__get_packed_size(msg->payload.textMessage);
 136                 if (len > MAX_MSGSIZE) {
 137                         Log_warn("Too big tx message. Discarding");
 138                         break;
 139                         }
 140                 Msg_addPreamble(buffer, msg->messageType, len);
 141                 mumble_proto__text_message__pack(msg->payload.textMessage, bufptr);
 142                 break;
 143         case PermissionDenied:
 144                 len = mumble_proto__permission_denied__get_packed_size(msg->payload.permissionDenied);
 145                 if (len > MAX_MSGSIZE) {
 146                         Log_warn("Too big tx message. Discarding");
 147                         break;
 148                         }
 149                 Msg_addPreamble(buffer, msg->messageType, len);
 150                 mumble_proto__permission_denied__pack(msg->payload.permissionDenied, bufptr);
 151                 break;
 152         case CryptSetup:
 153                 len = mumble_proto__crypt_setup__get_packed_size(msg->payload.cryptSetup);
 154                 if (len > MAX_MSGSIZE) {
 155                         Log_warn("Too big tx message. Discarding");
 156                         break;
 157                         }
 158                 Msg_addPreamble(buffer, msg->messageType, len);
 159                 mumble_proto__crypt_setup__pack(msg->payload.cryptSetup, bufptr);
 160                 break;
 161         case UserList:
 162                 len = mumble_proto__user_list__get_packed_size(msg->payload.userList);
 163                 if (len > MAX_MSGSIZE) {
 164                         Log_warn("Too big tx message. Discarding");
 165                         break;
 166                         }
 167                 Msg_addPreamble(buffer, msg->messageType, len);
 168                 mumble_proto__user_list__pack(msg->payload.userList, bufptr);
 169                 break;
 170         case UserState:
 171                 len = mumble_proto__user_state__get_packed_size(msg->payload.userState);
 172                 if (len > MAX_MSGSIZE) {
 173                         Log_warn("Too big tx message. Discarding");
 174                         break;
 175                         }
 176                 Msg_addPreamble(buffer, msg->messageType, len);
 177                 mumble_proto__user_state__pack(msg->payload.userState, bufptr);
 178                 break;
 179         case UserRemove:
 180                 len = mumble_proto__user_remove__get_packed_size(msg->payload.userRemove);
 181                 if (len > MAX_MSGSIZE) {
 182                         Log_warn("Too big tx message. Discarding");
 183                         break;
 184                         }
 185                 Msg_addPreamble(buffer, msg->messageType, len);
 186                 mumble_proto__user_remove__pack(msg->payload.userRemove, bufptr);
 187                 break;
 188         case ChannelState:
 189                 len = mumble_proto__channel_state__get_packed_size(msg->payload.channelState);
 190                 if (len > MAX_MSGSIZE) {
 191                         Log_warn("Too big tx message. Discarding");
 192                         break;
 193                         }
 194                 Msg_addPreamble(buffer, msg->messageType, len);
 195                 mumble_proto__channel_state__pack(msg->payload.channelState, bufptr);
 196                 break;
 197         case VoiceTarget:
 198                 len = mumble_proto__voice_target__get_packed_size(msg->payload.voiceTarget);
 199                 if (len > MAX_MSGSIZE) {
 200                         Log_warn("Too big tx message. Discarding");
 201                         break;
 202                         }
 203                 Msg_addPreamble(buffer, msg->messageType, len);
 204                 mumble_proto__voice_target__pack(msg->payload.voiceTarget, bufptr);
 205                 break;
 206         case CodecVersion:
 207                 len = mumble_proto__codec_version__get_packed_size(msg->payload.codecVersion);
 208                 if (len > MAX_MSGSIZE) {
 209                         Log_warn("Too big tx message. Discarding");
 210                         break;
 211                         }
 212                 Msg_addPreamble(buffer, msg->messageType, len);
 213                 mumble_proto__codec_version__pack(msg->payload.codecVersion, bufptr);
 214                 break;
 215         case PermissionQuery:
 216                 len = mumble_proto__permission_query__get_packed_size(msg->payload.permissionQuery);
 217                 if (len > MAX_MSGSIZE) {
 218                         Log_warn("Too big tx message. Discarding");
 219                         break;
 220                         }
 221                 Msg_addPreamble(buffer, msg->messageType, len);
 222                 mumble_proto__permission_query__pack(msg->payload.permissionQuery, bufptr);
 223                 break;
 224         case ChannelRemove:
 225                 len = mumble_proto__channel_remove__get_packed_size(msg->payload.channelRemove);
 226                 if (len > MAX_MSGSIZE) {
 227                         Log_warn("Too big tx message. Discarding");
 228                         break;
 229                         }
 230                 Msg_addPreamble(buffer, msg->messageType, len);
 231                 mumble_proto__channel_remove__pack(msg->payload.channelRemove, bufptr);
 232                 break;
 233
 234         default:
 235                 Log_warn("Msg_networkToMessage: Unsupported message %d", msg->messageType);
 236                 return 0;
 237         }
 238         return len + PREAMBLE_SIZE;
 239 }
 240
 241 message_t *Msg_create_nopayload(messageType_t messageType)
 242 {
 243         message_t *msg = malloc(sizeof(message_t));
 244
 245         if (msg == NULL)
 246                 Log_fatal("Out of memory");
 247         memset(msg, 0, sizeof(message_t));
 248         msg->refcount = 1;
 249         msg->messageType = messageType;
 250         init_list_entry(&msg->node);
 251         return msg;
 252 }
 253
 254 message_t *Msg_create(messageType_t messageType)
 255 {
 256         message_t *msg = Msg_create_nopayload(messageType);
 257
 258         switch (messageType) {
 259         case Version:
 260                 msg->payload.version = malloc(sizeof(MumbleProto__Version));
 261                 mumble_proto__version__init(msg->payload.version);
 262                 break;
 263         case UDPTunnel:
 264                 msg->payload.UDPTunnel = malloc(sizeof(MumbleProto__UDPTunnel));
 265                 mumble_proto__udptunnel__init(msg->payload.UDPTunnel);
 266                 break;
 267         case Authenticate:
 268                 msg->payload.authenticate = malloc(sizeof(MumbleProto__Authenticate));
 269                 mumble_proto__authenticate__init(msg->payload.authenticate);
 270                 break;
 271         case Ping:
 272                 msg->payload.ping = malloc(sizeof(MumbleProto__Ping));
 273                 mumble_proto__ping__init(msg->payload.ping);
 274                 break;
 275         case Reject:
 276                 msg->payload.reject = malloc(sizeof(MumbleProto__Reject));
 277                 mumble_proto__reject__init(msg->payload.reject);
 278                 break;
 279         case ServerSync:
 280                 msg->payload.serverSync = malloc(sizeof(MumbleProto__ServerSync));
 281                 mumble_proto__server_sync__init(msg->payload.serverSync);
 282                 break;
 283         case TextMessage:
 284                 msg->payload.textMessage = malloc(sizeof(MumbleProto__TextMessage));
 285                 mumble_proto__text_message__init(msg->payload.textMessage);
 286                 break;
 287         case PermissionDenied:
 288                 msg->payload.permissionDenied = malloc(sizeof(MumbleProto__PermissionDenied));
 289                 mumble_proto__permission_denied__init(msg->payload.permissionDenied);
 290                 break;
 291         case CryptSetup:
 292                 msg->payload.cryptSetup = malloc(sizeof(MumbleProto__CryptSetup));
 293                 mumble_proto__crypt_setup__init(msg->payload.cryptSetup);
 294                 break;
 295         case UserList:
 296                 msg->payload.userList = malloc(sizeof(MumbleProto__UserList));
 297                 mumble_proto__user_list__init(msg->payload.userList);
 298                 break;
 299         case UserState:
 300                 msg->payload.userState = malloc(sizeof(MumbleProto__UserState));
 301                 mumble_proto__user_state__init(msg->payload.userState);
 302                 break;
 303         case ChannelState:
 304                 msg->payload.channelState = malloc(sizeof(MumbleProto__ChannelState));
 305                 mumble_proto__channel_state__init(msg->payload.channelState);
 306                 break;
 307         case UserRemove:
 308                 msg->payload.userRemove = malloc(sizeof(MumbleProto__UserRemove));
 309                 mumble_proto__user_remove__init(msg->payload.userRemove);
 310                 break;
 311         case VoiceTarget:
 312                 msg->payload.voiceTarget = malloc(sizeof(MumbleProto__VoiceTarget));
 313                 mumble_proto__voice_target__init(msg->payload.voiceTarget);
 314                 break;
 315         case CodecVersion:
 316                 msg->payload.codecVersion = malloc(sizeof(MumbleProto__CodecVersion));
 317                 mumble_proto__codec_version__init(msg->payload.codecVersion);
 318                 break;
 319         case PermissionQuery:
 320                 msg->payload.permissionQuery = malloc(sizeof(MumbleProto__PermissionQuery));
 321                 mumble_proto__permission_query__init(msg->payload.permissionQuery);
 322                 break;
 323         case ChannelRemove:
 324                 msg->payload.channelRemove = malloc(sizeof(MumbleProto__ChannelRemove));
 325                 mumble_proto__channel_remove__init(msg->payload.channelRemove);
 326                 break;
 327
 328         default:
 329                 Log_warn("Msg_create: Unsupported message %d", msg->messageType);
 330                 break;
 331         }
 332
 333         return msg;
 334 }
 335
 336 void Msg_inc_ref(message_t *msg)
 337 {
 338         msg->refcount++;
 339 }
 340
 341 void Msg_free(message_t *msg)
 342 {
 343         if (msg->refcount) msg->refcount--;
 344         if (msg->refcount > 0)
 345                 return;
 346
 347         switch (msg->messageType) {
 348         case Version:
 349                 if (msg->unpacked)
 350                         mumble_proto__version__free_unpacked(msg->payload.version, NULL);
 351                 else {
 352                         if (msg->payload.version->release)
 353                                 free(msg->payload.version->release);
 354                         if (msg->payload.version->os)
 355                                 free(msg->payload.version->os);
 356                         if (msg->payload.version->os_version)
 357                                 free(msg->payload.version->os_version);
 358                         free(msg->payload.version);
 359                 }
 360                 break;
 361         case UDPTunnel:
 362                 if (msg->unpacked)
 363                         mumble_proto__udptunnel__free_unpacked(msg->payload.UDPTunnel, NULL);
 364                 else {
 365                         free(msg->payload.UDPTunnel->packet.data);
 366                         free(msg->payload.UDPTunnel);
 367                 }
 368                 break;
 369         case Authenticate:
 370                 if (msg->unpacked)
 371                         mumble_proto__authenticate__free_unpacked(msg->payload.authenticate, NULL);
 372                 else
 373                         free(msg->payload.authenticate);
 374                 break;
 375         case Ping:
 376                 if (msg->unpacked)
 377                         mumble_proto__ping__free_unpacked(msg->payload.ping, NULL);
 378                 else {
 379                         free(msg->payload.ping);
 380                 }
 381                 break;
 382         case Reject:
 383                 if (msg->unpacked)
 384                         mumble_proto__reject__free_unpacked(msg->payload.reject, NULL);
 385                 else {
 386                         free(msg->payload.reject->reason);
 387                         free(msg->payload.reject);
 388                 }
 389                 break;
 390         case ServerSync:
 391                 if (msg->unpacked)
 392                         mumble_proto__server_sync__free_unpacked(msg->payload.serverSync, NULL);
 393                 else {
 394                         free(msg->payload.serverSync->welcome_text);
 395                         free(msg->payload.serverSync);
 396                 }
 397                 break;
 398         case TextMessage:
 399                 if (msg->unpacked)
 400                         mumble_proto__text_message__free_unpacked(msg->payload.textMessage, NULL);
 401                 else {
 402                         free(msg->payload.textMessage);
 403                 }
 404                 break;
 405         case PermissionDenied:
 406                 if (msg->unpacked)
 407                         mumble_proto__permission_denied__free_unpacked(msg->payload.permissionDenied, NULL);
 408                 else {
 409                         free(msg->payload.permissionDenied->reason);
 410                         free(msg->payload.permissionDenied);
 411                 }
 412                 break;
 413         case CryptSetup:
 414                 if (msg->unpacked)
 415                         mumble_proto__crypt_setup__free_unpacked(msg->payload.cryptSetup, NULL);
 416                 else {
 417                         free(msg->payload.cryptSetup);
 418                 }
 419                 break;
 420         case UserList:
 421                 if (msg->unpacked)
 422                         mumble_proto__user_list__free_unpacked(msg->payload.userList, NULL);
 423                 else {
 424                         free(msg->payload.userList);
 425                 }
 426                 break;
 427         case UserState:
 428                 if (msg->unpacked)
 429                         mumble_proto__user_state__free_unpacked(msg->payload.userState, NULL);
 430                 else {
 431                         free(msg->payload.userState->name);
 432                         free(msg->payload.userState);
 433                 }
 434                 break;
 435         case ChannelState:
 436                 if (msg->unpacked)
 437                         mumble_proto__channel_state__free_unpacked(msg->payload.channelState, NULL);
 438                 else {
 439                         free(msg->payload.channelState->name);
 440                         free(msg->payload.channelState->description);
 441                         free(msg->payload.channelState);
 442                 }
 443                 break;
 444         case UserRemove:
 445                 if (msg->unpacked)
 446                         mumble_proto__user_remove__free_unpacked(msg->payload.userRemove, NULL);
 447                 else {
 448                         free(msg->payload.userRemove);
 449                 }
 450                 break;
 451         case VoiceTarget:
 452                 if (msg->unpacked)
 453                         mumble_proto__voice_target__free_unpacked(msg->payload.voiceTarget, NULL);
 454                 else {
 455                         free(msg->payload.voiceTarget);
 456                 }
 457                 break;
 458         case CodecVersion:
 459                 if (msg->unpacked)
 460                         mumble_proto__codec_version__free_unpacked(msg->payload.codecVersion, NULL);
 461                 else {
 462                         free(msg->payload.codecVersion);
 463                 }
 464                 break;
 465         case PermissionQuery:
 466                 if (msg->unpacked)
 467                         mumble_proto__permission_query__free_unpacked(msg->payload.permissionQuery, NULL);
 468                 else {
 469                         free(msg->payload.permissionQuery);
 470                 }
 471                 break;
 472         case ChannelRemove:
 473                 if (msg->unpacked)
 474                         mumble_proto__channel_remove__free_unpacked(msg->payload.channelRemove, NULL);
 475                 else {
 476                         free(msg->payload.channelRemove);
 477                 }
 478                 break;
 479
 480         default:
 481                 Log_warn("Msg_free: Unsupported message %d", msg->messageType);
 482                 break;
 483         }
 484         free(msg);
 485 }
 486
 487 void dumpmsg(uint8_t *data, int size)
 488 {
 489         int i, r = 0, offset = 0;
 490         char buf[512];
 491
 492         while (r * 8 + i < size) {
 493                 for (i = 0; i < 8 && r * 8 + i < size; i++) {
 494                         offset += sprintf(buf + offset, "%x ", data[r * 8 + i]);
 495                 }
 496                 sprintf(buf + offset, "\n");
 497                 printf(buf);
 498                 offset = 0;
 499                 r++;
 500                 i = 0;
 501         }
 502 }
 503
 504 message_t *Msg_networkToMessage(uint8_t *data, int size)
 505 {
 506         message_t *msg = NULL;
 507         uint8_t *msgData = &data[6];
 508         int messageType, msgLen;
 509
 510         Msg_getPreamble(data, &messageType, &msgLen);
 511
 512         Log_debug("Message type %d size %d", messageType, msgLen);
 513         //dumpmsg(data, size);
 514
 515         switch (messageType) {
 516         case Version:
 517         {
 518                 msg = Msg_create_nopayload(Version);
 519                 msg->unpacked = true;
 520                 msg->payload.version = mumble_proto__version__unpack(NULL, msgLen, msgData);
 521                 if (msg->payload.version == NULL)
 522                         goto err_out;
 523                 break;
 524         }
 525         case UDPTunnel: /* Non-standard handling of tunneled voice data */
 526         {
 527                 msg = Msg_create_nopayload(UDPTunnel);
 528                 msg->unpacked = false;
 529                 msg->payload.UDPTunnel = malloc(sizeof(struct _MumbleProto__UDPTunnel));
 530                 if (msg->payload.UDPTunnel == NULL)
 531                         Log_fatal("Out of memory");
 532                 msg->payload.UDPTunnel->packet.data = malloc(msgLen);
 533                 if (msg->payload.UDPTunnel->packet.data == NULL)
 534                         Log_fatal("Out of memory");
 535                 memcpy(msg->payload.UDPTunnel->packet.data, msgData, msgLen);
 536                 msg->payload.UDPTunnel->packet.len = msgLen;
 537                 break;
 538         }
 539         case Authenticate:
 540         {
 541                 msg = Msg_create_nopayload(Authenticate);
 542                 msg->unpacked = true;
 543                 msg->payload.authenticate = mumble_proto__authenticate__unpack(NULL, msgLen, msgData);
 544                 if (msg->payload.authenticate == NULL)
 545                         goto err_out;
 546                 break;
 547         }
 548         case Ping:
 549         {
 550                 msg = Msg_create_nopayload(Ping);
 551                 msg->unpacked = true;
 552                 msg->payload.ping = mumble_proto__ping__unpack(NULL, msgLen, msgData);
 553                 if (msg->payload.ping == NULL)
 554                         goto err_out;
 555                 break;
 556         }
 557         case Reject:
 558         {
 559                 msg = Msg_create_nopayload(Reject);
 560                 msg->unpacked = true;
 561                 msg->payload.reject = mumble_proto__reject__unpack(NULL, msgLen, msgData);
 562                 if (msg->payload.reject == NULL)
 563                         goto err_out;
 564                 break;
 565         }
 566         case ServerSync:
 567         {
 568                 msg = Msg_create_nopayload(ServerSync);
 569                 msg->unpacked = true;
 570                 msg->payload.serverSync = mumble_proto__server_sync__unpack(NULL, msgLen, msgData);
 571                 if (msg->payload.serverSync == NULL)
 572                         goto err_out;
 573                 break;
 574         }
 575         case TextMessage:
 576         {
 577                 msg = Msg_create_nopayload(TextMessage);
 578                 msg->unpacked = true;
 579                 msg->payload.textMessage = mumble_proto__text_message__unpack(NULL, msgLen, msgData);
 580                 if (msg->payload.textMessage == NULL)
 581                         goto err_out;
 582                 break;
 583         }
 584         case PermissionDenied:
 585         {
 586                 msg = Msg_create_nopayload(PermissionDenied);
 587                 msg->unpacked = true;
 588                 msg->payload.permissionDenied = mumble_proto__permission_denied__unpack(NULL, msgLen, msgData);
 589                 if (msg->payload.permissionDenied == NULL)
 590                         goto err_out;
 591                 break;
 592         }
 593         case CryptSetup:
 594         {
 595                 msg = Msg_create_nopayload(CryptSetup);
 596                 msg->unpacked = true;
 597                 msg->payload.cryptSetup = mumble_proto__crypt_setup__unpack(NULL, msgLen, msgData);
 598                 if (msg->payload.cryptSetup == NULL)
 599                         goto err_out;
 600                 break;
 601         }
 602         case UserList:
 603         {
 604                 msg = Msg_create_nopayload(UserList);
 605                 msg->unpacked = true;
 606                 msg->payload.userList = mumble_proto__user_list__unpack(NULL, msgLen, msgData);
 607                 if (msg->payload.userList == NULL)
 608                         goto err_out;
 609                 break;
 610         }
 611         case UserState:
 612         {
 613                 msg = Msg_create_nopayload(UserState);
 614                 msg->unpacked = true;
 615                 msg->payload.userState = mumble_proto__user_state__unpack(NULL, msgLen, msgData);
 616                 if (msg->payload.userState == NULL)
 617                         goto err_out;
 618                 break;
 619         }
 620         case ChannelState:
 621         {
 622                 msg = Msg_create_nopayload(ChannelState);
 623                 msg->unpacked = true;
 624                 msg->payload.channelState = mumble_proto__channel_state__unpack(NULL, msgLen, msgData);
 625                 if (msg->payload.channelState == NULL)
 626                         goto err_out;
 627                 break;
 628         }
 629         case VoiceTarget:
 630         {
 631                 msg = Msg_create_nopayload(VoiceTarget);
 632                 msg->unpacked = true;
 633                 msg->payload.voiceTarget = mumble_proto__voice_target__unpack(NULL, msgLen, msgData);
 634                 if (msg->payload.voiceTarget == NULL)
 635                         goto err_out;
 636                 break;
 637         }
 638         case CodecVersion:
 639         {
 640                 msg = Msg_create_nopayload(CodecVersion);
 641                 msg->unpacked = true;
 642                 msg->payload.codecVersion = mumble_proto__codec_version__unpack(NULL, msgLen, msgData);
 643                 if (msg->payload.codecVersion == NULL)
 644                         goto err_out;
 645                 break;
 646         }
 647         case PermissionQuery:
 648         {
 649                 msg = Msg_create_nopayload(PermissionQuery);
 650                 msg->unpacked = true;
 651                 msg->payload.permissionQuery = mumble_proto__permission_query__unpack(NULL, msgLen, msgData);
 652                 if (msg->payload.permissionQuery == NULL)
 653                         goto err_out;
 654                 break;
 655         }
 656         case ChannelRemove:
 657         {
 658                 msg = Msg_create_nopayload(ChannelRemove);
 659                 msg->unpacked = true;
 660                 msg->payload.channelRemove = mumble_proto__channel_remove__unpack(NULL, msgLen, msgData);
 661                 if (msg->payload.channelRemove == NULL)
 662                         goto err_out;
 663                 break;
 664         }
 665
 666         default:
 667                 Log_warn("Unsupported message %d", messageType);
 668                 break;
 669         }
 670         return msg;
 671
 672 err_out:
 673         free(msg);
 674         return NULL;
 675 }