From 86214eabc4bcdb19fc4171ef5bf3c231cbff6518 Mon Sep 17 00:00:00 2001 From: fatbob313 Date: Mon, 6 Dec 2010 14:20:27 +0000 Subject: [PATCH] Update Mumble protocol to 1.2.3 --- src/Mumble.pb-c.c | 761 ++++++++++++++++++++++++++++++++++++++++++++-- src/Mumble.pb-c.h | 200 +++++++++++- src/Mumble.proto | 55 +++- src/messages.c | 88 ++++++ src/messages.h | 7 +- 5 files changed, 1067 insertions(+), 44 deletions(-) diff --git a/src/Mumble.pb-c.c b/src/Mumble.pb-c.c index 2daa927..345c331 100644 --- a/src/Mumble.pb-c.c +++ b/src/Mumble.pb-c.c @@ -221,6 +221,49 @@ void mumble_proto__reject__free_unpacked PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__reject__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } +void mumble_proto__server_config__init + (MumbleProto__ServerConfig *message) +{ + static MumbleProto__ServerConfig init_value = MUMBLE_PROTO__SERVER_CONFIG__INIT; + *message = init_value; +} +size_t mumble_proto__server_config__get_packed_size + (const MumbleProto__ServerConfig *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_config__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t mumble_proto__server_config__pack + (const MumbleProto__ServerConfig *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_config__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t mumble_proto__server_config__pack_to_buffer + (const MumbleProto__ServerConfig *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_config__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +MumbleProto__ServerConfig * + mumble_proto__server_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (MumbleProto__ServerConfig *) + protobuf_c_message_unpack (&mumble_proto__server_config__descriptor, + allocator, len, data); +} +void mumble_proto__server_config__free_unpacked + (MumbleProto__ServerConfig *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__server_config__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} void mumble_proto__server_sync__init (MumbleProto__ServerSync *message) { @@ -982,6 +1025,98 @@ void mumble_proto__codec_version__free_unpacked PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__codec_version__descriptor); protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); } +void mumble_proto__user_stats__stats__init + (MumbleProto__UserStats__Stats *message) +{ + static MumbleProto__UserStats__Stats init_value = MUMBLE_PROTO__USER_STATS__STATS__INIT; + *message = init_value; +} +void mumble_proto__user_stats__init + (MumbleProto__UserStats *message) +{ + static MumbleProto__UserStats init_value = MUMBLE_PROTO__USER_STATS__INIT; + *message = init_value; +} +size_t mumble_proto__user_stats__get_packed_size + (const MumbleProto__UserStats *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_stats__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t mumble_proto__user_stats__pack + (const MumbleProto__UserStats *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_stats__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t mumble_proto__user_stats__pack_to_buffer + (const MumbleProto__UserStats *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_stats__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +MumbleProto__UserStats * + mumble_proto__user_stats__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (MumbleProto__UserStats *) + protobuf_c_message_unpack (&mumble_proto__user_stats__descriptor, + allocator, len, data); +} +void mumble_proto__user_stats__free_unpacked + (MumbleProto__UserStats *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__user_stats__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} +void mumble_proto__request_blob__init + (MumbleProto__RequestBlob *message) +{ + static MumbleProto__RequestBlob init_value = MUMBLE_PROTO__REQUEST_BLOB__INIT; + *message = init_value; +} +size_t mumble_proto__request_blob__get_packed_size + (const MumbleProto__RequestBlob *message) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__request_blob__descriptor); + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); +} +size_t mumble_proto__request_blob__pack + (const MumbleProto__RequestBlob *message, + uint8_t *out) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__request_blob__descriptor); + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); +} +size_t mumble_proto__request_blob__pack_to_buffer + (const MumbleProto__RequestBlob *message, + ProtobufCBuffer *buffer) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__request_blob__descriptor); + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); +} +MumbleProto__RequestBlob * + mumble_proto__request_blob__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data) +{ + return (MumbleProto__RequestBlob *) + protobuf_c_message_unpack (&mumble_proto__request_blob__descriptor, + allocator, len, data); +} +void mumble_proto__request_blob__free_unpacked + (MumbleProto__RequestBlob *message, + ProtobufCAllocator *allocator) +{ + PROTOBUF_C_ASSERT (message->base.descriptor == &mumble_proto__request_blob__descriptor); + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); +} static const ProtobufCFieldDescriptor mumble_proto__version__field_descriptors[4] = { { @@ -1433,8 +1568,97 @@ const ProtobufCMessageDescriptor mumble_proto__reject__descriptor = (ProtobufCMessageInit) mumble_proto__reject__init, NULL,NULL,NULL /* reserved[123] */ }; -static const protobuf_c_boolean mumble_proto__server_sync__allow_html__default_value = 1; -static const ProtobufCFieldDescriptor mumble_proto__server_sync__field_descriptors[5] = +static const ProtobufCFieldDescriptor mumble_proto__server_config__field_descriptors[5] = +{ + { + "max_bandwidth", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, has_max_bandwidth), + PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, max_bandwidth), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "welcome_text", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, welcome_text), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "allow_html", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, has_allow_html), + PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, allow_html), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "message_length", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, has_message_length), + PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, message_length), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "image_message_length", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, has_image_message_length), + PROTOBUF_C_OFFSETOF(MumbleProto__ServerConfig, image_message_length), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned mumble_proto__server_config__field_indices_by_name[] = { + 2, /* field[2] = allow_html */ + 4, /* field[4] = image_message_length */ + 0, /* field[0] = max_bandwidth */ + 3, /* field[3] = message_length */ + 1, /* field[1] = welcome_text */ +}; +static const ProtobufCIntRange mumble_proto__server_config__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 5 } +}; +const ProtobufCMessageDescriptor mumble_proto__server_config__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "MumbleProto.ServerConfig", + "ServerConfig", + "MumbleProto__ServerConfig", + "MumbleProto", + sizeof(MumbleProto__ServerConfig), + 5, + mumble_proto__server_config__field_descriptors, + mumble_proto__server_config__field_indices_by_name, + 1, mumble_proto__server_config__number_ranges, + (ProtobufCMessageInit) mumble_proto__server_config__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor mumble_proto__server_sync__field_descriptors[4] = { { "session", @@ -1484,21 +1708,8 @@ static const ProtobufCFieldDescriptor mumble_proto__server_sync__field_descripto 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, - { - "allow_html", - 5, - PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_BOOL, - PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, has_allow_html), - PROTOBUF_C_OFFSETOF(MumbleProto__ServerSync, allow_html), - NULL, - &mumble_proto__server_sync__allow_html__default_value, - 0, /* packed */ - 0,NULL,NULL /* reserved1,reserved2, etc */ - }, }; static const unsigned mumble_proto__server_sync__field_indices_by_name[] = { - 4, /* field[4] = allow_html */ 1, /* field[1] = max_bandwidth */ 3, /* field[3] = permissions */ 0, /* field[0] = session */ @@ -1507,7 +1718,7 @@ static const unsigned mumble_proto__server_sync__field_indices_by_name[] = { static const ProtobufCIntRange mumble_proto__server_sync__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 5 } + { 0, 4 } }; const ProtobufCMessageDescriptor mumble_proto__server_sync__descriptor = { @@ -1517,7 +1728,7 @@ const ProtobufCMessageDescriptor mumble_proto__server_sync__descriptor = "MumbleProto__ServerSync", "MumbleProto", sizeof(MumbleProto__ServerSync), - 5, + 4, mumble_proto__server_sync__field_descriptors, mumble_proto__server_sync__field_indices_by_name, 1, mumble_proto__server_sync__number_ranges, @@ -1564,7 +1775,7 @@ const ProtobufCMessageDescriptor mumble_proto__channel_remove__descriptor = }; static const protobuf_c_boolean mumble_proto__channel_state__temporary__default_value = 0; static const int32_t mumble_proto__channel_state__position__default_value = 0; -static const ProtobufCFieldDescriptor mumble_proto__channel_state__field_descriptors[9] = +static const ProtobufCFieldDescriptor mumble_proto__channel_state__field_descriptors[10] = { { "channel_id", @@ -1674,10 +1885,23 @@ static const ProtobufCFieldDescriptor mumble_proto__channel_state__field_descrip 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, + { + "description_hash", + 10, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, has_description_hash), + PROTOBUF_C_OFFSETOF(MumbleProto__ChannelState, description_hash), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, }; static const unsigned mumble_proto__channel_state__field_indices_by_name[] = { 0, /* field[0] = channel_id */ 4, /* field[4] = description */ + 9, /* field[9] = description_hash */ 3, /* field[3] = links */ 5, /* field[5] = links_add */ 6, /* field[6] = links_remove */ @@ -1689,7 +1913,7 @@ static const unsigned mumble_proto__channel_state__field_indices_by_name[] = { static const ProtobufCIntRange mumble_proto__channel_state__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 9 } + { 0, 10 } }; const ProtobufCMessageDescriptor mumble_proto__channel_state__descriptor = { @@ -1699,7 +1923,7 @@ const ProtobufCMessageDescriptor mumble_proto__channel_state__descriptor = "MumbleProto__ChannelState", "MumbleProto", sizeof(MumbleProto__ChannelState), - 9, + 10, mumble_proto__channel_state__field_descriptors, mumble_proto__channel_state__field_indices_by_name, 1, mumble_proto__channel_state__number_ranges, @@ -1783,7 +2007,7 @@ const ProtobufCMessageDescriptor mumble_proto__user_remove__descriptor = (ProtobufCMessageInit) mumble_proto__user_remove__init, NULL,NULL,NULL /* reserved[123] */ }; -static const ProtobufCFieldDescriptor mumble_proto__user_state__field_descriptors[15] = +static const ProtobufCFieldDescriptor mumble_proto__user_state__field_descriptors[19] = { { "session", @@ -1921,8 +2145,8 @@ static const ProtobufCFieldDescriptor mumble_proto__user_state__field_descriptor "plugin_context", 12, PROTOBUF_C_LABEL_OPTIONAL, - PROTOBUF_C_TYPE_STRING, - 0, /* quantifier_offset */ + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_plugin_context), PROTOBUF_C_OFFSETOF(MumbleProto__UserState, plugin_context), NULL, NULL, @@ -1965,28 +2189,80 @@ static const ProtobufCFieldDescriptor mumble_proto__user_state__field_descriptor 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, + { + "comment_hash", + 16, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_comment_hash), + PROTOBUF_C_OFFSETOF(MumbleProto__UserState, comment_hash), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "texture_hash", + 17, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_texture_hash), + PROTOBUF_C_OFFSETOF(MumbleProto__UserState, texture_hash), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "priority_speaker", + 18, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_priority_speaker), + PROTOBUF_C_OFFSETOF(MumbleProto__UserState, priority_speaker), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "recording", + 19, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + PROTOBUF_C_OFFSETOF(MumbleProto__UserState, has_recording), + PROTOBUF_C_OFFSETOF(MumbleProto__UserState, recording), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, }; static const unsigned mumble_proto__user_state__field_indices_by_name[] = { 1, /* field[1] = actor */ 4, /* field[4] = channel_id */ 13, /* field[13] = comment */ + 15, /* field[15] = comment_hash */ 6, /* field[6] = deaf */ 14, /* field[14] = hash */ 5, /* field[5] = mute */ 2, /* field[2] = name */ 11, /* field[11] = plugin_context */ 12, /* field[12] = plugin_identity */ + 17, /* field[17] = priority_speaker */ + 18, /* field[18] = recording */ 9, /* field[9] = self_deaf */ 8, /* field[8] = self_mute */ 0, /* field[0] = session */ 7, /* field[7] = suppress */ 10, /* field[10] = texture */ + 16, /* field[16] = texture_hash */ 3, /* field[3] = user_id */ }; static const ProtobufCIntRange mumble_proto__user_state__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 15 } + { 0, 19 } }; const ProtobufCMessageDescriptor mumble_proto__user_state__descriptor = { @@ -1996,7 +2272,7 @@ const ProtobufCMessageDescriptor mumble_proto__user_state__descriptor = "MumbleProto__UserState", "MumbleProto", sizeof(MumbleProto__UserState), - 15, + 19, mumble_proto__user_state__field_descriptors, mumble_proto__user_state__field_indices_by_name, 1, mumble_proto__user_state__number_ranges, @@ -2261,7 +2537,7 @@ const ProtobufCMessageDescriptor mumble_proto__text_message__descriptor = (ProtobufCMessageInit) mumble_proto__text_message__init, NULL,NULL,NULL /* reserved[123] */ }; -const ProtobufCEnumValue mumble_proto__permission_denied__deny_type__enum_values_by_number[8] = +const ProtobufCEnumValue mumble_proto__permission_denied__deny_type__enum_values_by_number[10] = { { "Text", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TEXT", 0 }, { "Permission", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__PERMISSION", 1 }, @@ -2271,12 +2547,15 @@ const ProtobufCEnumValue mumble_proto__permission_denied__deny_type__enum_values { "H9K", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__H9K", 5 }, { "TemporaryChannel", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TEMPORARYCHANNEL", 6 }, { "MissingCertificate", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__MISSINGCERTIFICATE", 7 }, + { "UserName", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__USERNAME", 8 }, + { "ChannelFull", "MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__CHANNELFULL", 9 }, }; static const ProtobufCIntRange mumble_proto__permission_denied__deny_type__value_ranges[] = { -{0, 0},{0, 8} +{0, 0},{0, 10} }; -const ProtobufCEnumValueIndex mumble_proto__permission_denied__deny_type__enum_values_by_name[8] = +const ProtobufCEnumValueIndex mumble_proto__permission_denied__deny_type__enum_values_by_name[10] = { + { "ChannelFull", 9 }, { "ChannelName", 3 }, { "H9K", 5 }, { "MissingCertificate", 7 }, @@ -2285,6 +2564,7 @@ const ProtobufCEnumValueIndex mumble_proto__permission_denied__deny_type__enum_v { "TemporaryChannel", 6 }, { "Text", 0 }, { "TextTooLong", 4 }, + { "UserName", 8 }, }; const ProtobufCEnumDescriptor mumble_proto__permission_denied__deny_type__descriptor = { @@ -2293,15 +2573,15 @@ const ProtobufCEnumDescriptor mumble_proto__permission_denied__deny_type__descri "DenyType", "MumbleProto__PermissionDenied__DenyType", "MumbleProto", - 8, + 10, mumble_proto__permission_denied__deny_type__enum_values_by_number, - 8, + 10, mumble_proto__permission_denied__deny_type__enum_values_by_name, 1, mumble_proto__permission_denied__deny_type__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; -static const ProtobufCFieldDescriptor mumble_proto__permission_denied__field_descriptors[5] = +static const ProtobufCFieldDescriptor mumble_proto__permission_denied__field_descriptors[6] = { { "permission", @@ -2363,9 +2643,22 @@ static const ProtobufCFieldDescriptor mumble_proto__permission_denied__field_des 0, /* packed */ 0,NULL,NULL /* reserved1,reserved2, etc */ }, + { + "name", + 6, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_STRING, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(MumbleProto__PermissionDenied, name), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, }; static const unsigned mumble_proto__permission_denied__field_indices_by_name[] = { 1, /* field[1] = channel_id */ + 5, /* field[5] = name */ 0, /* field[0] = permission */ 3, /* field[3] = reason */ 2, /* field[2] = session */ @@ -2374,7 +2667,7 @@ static const unsigned mumble_proto__permission_denied__field_indices_by_name[] = static const ProtobufCIntRange mumble_proto__permission_denied__number_ranges[1 + 1] = { { 1, 0 }, - { 0, 5 } + { 0, 6 } }; const ProtobufCMessageDescriptor mumble_proto__permission_denied__descriptor = { @@ -2384,7 +2677,7 @@ const ProtobufCMessageDescriptor mumble_proto__permission_denied__descriptor = "MumbleProto__PermissionDenied", "MumbleProto", sizeof(MumbleProto__PermissionDenied), - 5, + 6, mumble_proto__permission_denied__field_descriptors, mumble_proto__permission_denied__field_indices_by_name, 1, mumble_proto__permission_denied__number_ranges, @@ -3356,3 +3649,405 @@ const ProtobufCMessageDescriptor mumble_proto__codec_version__descriptor = (ProtobufCMessageInit) mumble_proto__codec_version__init, NULL,NULL,NULL /* reserved[123] */ }; +static const ProtobufCFieldDescriptor mumble_proto__user_stats__stats__field_descriptors[4] = +{ + { + "good", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, has_good), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, good), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "late", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, has_late), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, late), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "lost", + 3, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, has_lost), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, lost), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "resync", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, has_resync), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats__Stats, resync), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned mumble_proto__user_stats__stats__field_indices_by_name[] = { + 0, /* field[0] = good */ + 1, /* field[1] = late */ + 2, /* field[2] = lost */ + 3, /* field[3] = resync */ +}; +static const ProtobufCIntRange mumble_proto__user_stats__stats__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 4 } +}; +const ProtobufCMessageDescriptor mumble_proto__user_stats__stats__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "MumbleProto.UserStats.Stats", + "Stats", + "MumbleProto__UserStats__Stats", + "MumbleProto", + sizeof(MumbleProto__UserStats__Stats), + 4, + mumble_proto__user_stats__stats__field_descriptors, + mumble_proto__user_stats__stats__field_indices_by_name, + 1, mumble_proto__user_stats__stats__number_ranges, + (ProtobufCMessageInit) mumble_proto__user_stats__stats__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const protobuf_c_boolean mumble_proto__user_stats__stats_only__default_value = 0; +static const protobuf_c_boolean mumble_proto__user_stats__strong_certificate__default_value = 0; +static const ProtobufCFieldDescriptor mumble_proto__user_stats__field_descriptors[18] = +{ + { + "session", + 1, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_session), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, session), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "stats_only", + 2, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_stats_only), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, stats_only), + NULL, + &mumble_proto__user_stats__stats_only__default_value, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "certificates", + 3, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, n_certificates), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, certificates), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "from_client", + 4, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, from_client), + &mumble_proto__user_stats__stats__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "from_server", + 5, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, from_server), + &mumble_proto__user_stats__stats__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "udp_packets", + 6, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_udp_packets), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, udp_packets), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "tcp_packets", + 7, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_tcp_packets), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, tcp_packets), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "udp_ping_avg", + 8, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_FLOAT, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_udp_ping_avg), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, udp_ping_avg), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "udp_ping_var", + 9, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_FLOAT, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_udp_ping_var), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, udp_ping_var), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "tcp_ping_avg", + 10, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_FLOAT, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_tcp_ping_avg), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, tcp_ping_avg), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "tcp_ping_var", + 11, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_FLOAT, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_tcp_ping_var), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, tcp_ping_var), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "version", + 12, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_MESSAGE, + 0, /* quantifier_offset */ + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, version), + &mumble_proto__version__descriptor, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "celt_versions", + 13, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_INT32, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, n_celt_versions), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, celt_versions), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "address", + 14, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BYTES, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_address), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, address), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "bandwidth", + 15, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_bandwidth), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, bandwidth), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "onlinesecs", + 16, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_onlinesecs), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, onlinesecs), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "idlesecs", + 17, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_idlesecs), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, idlesecs), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "strong_certificate", + 18, + PROTOBUF_C_LABEL_OPTIONAL, + PROTOBUF_C_TYPE_BOOL, + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, has_strong_certificate), + PROTOBUF_C_OFFSETOF(MumbleProto__UserStats, strong_certificate), + NULL, + &mumble_proto__user_stats__strong_certificate__default_value, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned mumble_proto__user_stats__field_indices_by_name[] = { + 13, /* field[13] = address */ + 14, /* field[14] = bandwidth */ + 12, /* field[12] = celt_versions */ + 2, /* field[2] = certificates */ + 3, /* field[3] = from_client */ + 4, /* field[4] = from_server */ + 16, /* field[16] = idlesecs */ + 15, /* field[15] = onlinesecs */ + 0, /* field[0] = session */ + 1, /* field[1] = stats_only */ + 17, /* field[17] = strong_certificate */ + 6, /* field[6] = tcp_packets */ + 9, /* field[9] = tcp_ping_avg */ + 10, /* field[10] = tcp_ping_var */ + 5, /* field[5] = udp_packets */ + 7, /* field[7] = udp_ping_avg */ + 8, /* field[8] = udp_ping_var */ + 11, /* field[11] = version */ +}; +static const ProtobufCIntRange mumble_proto__user_stats__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 18 } +}; +const ProtobufCMessageDescriptor mumble_proto__user_stats__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "MumbleProto.UserStats", + "UserStats", + "MumbleProto__UserStats", + "MumbleProto", + sizeof(MumbleProto__UserStats), + 18, + mumble_proto__user_stats__field_descriptors, + mumble_proto__user_stats__field_indices_by_name, + 1, mumble_proto__user_stats__number_ranges, + (ProtobufCMessageInit) mumble_proto__user_stats__init, + NULL,NULL,NULL /* reserved[123] */ +}; +static const ProtobufCFieldDescriptor mumble_proto__request_blob__field_descriptors[3] = +{ + { + "session_texture", + 1, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, n_session_texture), + PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, session_texture), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "session_comment", + 2, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, n_session_comment), + PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, session_comment), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, + { + "channel_description", + 3, + PROTOBUF_C_LABEL_REPEATED, + PROTOBUF_C_TYPE_UINT32, + PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, n_channel_description), + PROTOBUF_C_OFFSETOF(MumbleProto__RequestBlob, channel_description), + NULL, + NULL, + 0, /* packed */ + 0,NULL,NULL /* reserved1,reserved2, etc */ + }, +}; +static const unsigned mumble_proto__request_blob__field_indices_by_name[] = { + 2, /* field[2] = channel_description */ + 1, /* field[1] = session_comment */ + 0, /* field[0] = session_texture */ +}; +static const ProtobufCIntRange mumble_proto__request_blob__number_ranges[1 + 1] = +{ + { 1, 0 }, + { 0, 3 } +}; +const ProtobufCMessageDescriptor mumble_proto__request_blob__descriptor = +{ + PROTOBUF_C_MESSAGE_DESCRIPTOR_MAGIC, + "MumbleProto.RequestBlob", + "RequestBlob", + "MumbleProto__RequestBlob", + "MumbleProto", + sizeof(MumbleProto__RequestBlob), + 3, + mumble_proto__request_blob__field_descriptors, + mumble_proto__request_blob__field_indices_by_name, + 1, mumble_proto__request_blob__number_ranges, + (ProtobufCMessageInit) mumble_proto__request_blob__init, + NULL,NULL,NULL /* reserved[123] */ +}; diff --git a/src/Mumble.pb-c.h b/src/Mumble.pb-c.h index 55da17f..51089bc 100644 --- a/src/Mumble.pb-c.h +++ b/src/Mumble.pb-c.h @@ -13,6 +13,7 @@ typedef struct _MumbleProto__UDPTunnel MumbleProto__UDPTunnel; typedef struct _MumbleProto__Authenticate MumbleProto__Authenticate; typedef struct _MumbleProto__Ping MumbleProto__Ping; typedef struct _MumbleProto__Reject MumbleProto__Reject; +typedef struct _MumbleProto__ServerConfig MumbleProto__ServerConfig; typedef struct _MumbleProto__ServerSync MumbleProto__ServerSync; typedef struct _MumbleProto__ChannelRemove MumbleProto__ChannelRemove; typedef struct _MumbleProto__ChannelState MumbleProto__ChannelState; @@ -35,6 +36,9 @@ typedef struct _MumbleProto__VoiceTarget MumbleProto__VoiceTarget; typedef struct _MumbleProto__VoiceTarget__Target MumbleProto__VoiceTarget__Target; typedef struct _MumbleProto__PermissionQuery MumbleProto__PermissionQuery; typedef struct _MumbleProto__CodecVersion MumbleProto__CodecVersion; +typedef struct _MumbleProto__UserStats MumbleProto__UserStats; +typedef struct _MumbleProto__UserStats__Stats MumbleProto__UserStats__Stats; +typedef struct _MumbleProto__RequestBlob MumbleProto__RequestBlob; /* --- enums --- */ @@ -57,7 +61,9 @@ typedef enum _MumbleProto__PermissionDenied__DenyType { MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TextTooLong = 4, MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__H9K = 5, MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__TemporaryChannel = 6, - MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__MissingCertificate = 7 + MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__MissingCertificate = 7, + MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__UserName = 8, + MUMBLE_PROTO__PERMISSION_DENIED__DENY_TYPE__ChannelFull = 9 } MumbleProto__PermissionDenied__DenyType; typedef enum _MumbleProto__ContextActionAdd__Context { MUMBLE_PROTO__CONTEXT_ACTION_ADD__CONTEXT__Server = 1, @@ -149,6 +155,24 @@ struct _MumbleProto__Reject , 0,0, NULL } +struct _MumbleProto__ServerConfig +{ + ProtobufCMessage base; + protobuf_c_boolean has_max_bandwidth; + uint32_t max_bandwidth; + char *welcome_text; + protobuf_c_boolean has_allow_html; + protobuf_c_boolean allow_html; + protobuf_c_boolean has_message_length; + uint32_t message_length; + protobuf_c_boolean has_image_message_length; + uint32_t image_message_length; +}; +#define MUMBLE_PROTO__SERVER_CONFIG__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__server_config__descriptor) \ + , 0,0, NULL, 0,0, 0,0, 0,0 } + + struct _MumbleProto__ServerSync { ProtobufCMessage base; @@ -159,12 +183,10 @@ struct _MumbleProto__ServerSync char *welcome_text; protobuf_c_boolean has_permissions; uint64_t permissions; - protobuf_c_boolean has_allow_html; - protobuf_c_boolean allow_html; }; #define MUMBLE_PROTO__SERVER_SYNC__INIT \ { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__server_sync__descriptor) \ - , 0,0, 0,0, NULL, 0,0, 0,1 } + , 0,0, 0,0, NULL, 0,0 } struct _MumbleProto__ChannelRemove @@ -196,10 +218,12 @@ struct _MumbleProto__ChannelState protobuf_c_boolean temporary; protobuf_c_boolean has_position; int32_t position; + protobuf_c_boolean has_description_hash; + ProtobufCBinaryData description_hash; }; #define MUMBLE_PROTO__CHANNEL_STATE__INIT \ { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__channel_state__descriptor) \ - , 0,0, 0,0, NULL, 0,NULL, NULL, 0,NULL, 0,NULL, 0,0, 0,0 } + , 0,0, 0,0, NULL, 0,NULL, NULL, 0,NULL, 0,NULL, 0,0, 0,0, 0,{0,NULL} } struct _MumbleProto__UserRemove @@ -241,14 +265,23 @@ struct _MumbleProto__UserState protobuf_c_boolean self_deaf; protobuf_c_boolean has_texture; ProtobufCBinaryData texture; - char *plugin_context; + protobuf_c_boolean has_plugin_context; + ProtobufCBinaryData plugin_context; char *plugin_identity; char *comment; char *hash; + protobuf_c_boolean has_comment_hash; + ProtobufCBinaryData comment_hash; + protobuf_c_boolean has_texture_hash; + ProtobufCBinaryData texture_hash; + protobuf_c_boolean has_priority_speaker; + protobuf_c_boolean priority_speaker; + protobuf_c_boolean has_recording; + protobuf_c_boolean recording; }; #define MUMBLE_PROTO__USER_STATE__INIT \ { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_state__descriptor) \ - , 0,0, 0,0, NULL, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,{0,NULL}, NULL, NULL, NULL, NULL } + , 0,0, 0,0, NULL, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, 0,{0,NULL}, 0,{0,NULL}, NULL, NULL, NULL, 0,{0,NULL}, 0,{0,NULL}, 0,0, 0,0 } struct _MumbleProto__BanList__BanEntry @@ -311,10 +344,11 @@ struct _MumbleProto__PermissionDenied char *reason; protobuf_c_boolean has_type; MumbleProto__PermissionDenied__DenyType type; + char *name; }; #define MUMBLE_PROTO__PERMISSION_DENIED__INIT \ { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__permission_denied__descriptor) \ - , 0,0, 0,0, 0,0, NULL, 0,0 } + , 0,0, 0,0, 0,0, NULL, 0,0, NULL } struct _MumbleProto__ACL__ChanGroup @@ -514,6 +548,80 @@ struct _MumbleProto__CodecVersion , 0, 0, 1 } +struct _MumbleProto__UserStats__Stats +{ + ProtobufCMessage base; + protobuf_c_boolean has_good; + uint32_t good; + protobuf_c_boolean has_late; + uint32_t late; + protobuf_c_boolean has_lost; + uint32_t lost; + protobuf_c_boolean has_resync; + uint32_t resync; +}; +#define MUMBLE_PROTO__USER_STATS__STATS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_stats__stats__descriptor) \ + , 0,0, 0,0, 0,0, 0,0 } + + +struct _MumbleProto__UserStats +{ + ProtobufCMessage base; + protobuf_c_boolean has_session; + uint32_t session; + protobuf_c_boolean has_stats_only; + protobuf_c_boolean stats_only; + size_t n_certificates; + ProtobufCBinaryData *certificates; + MumbleProto__UserStats__Stats *from_client; + MumbleProto__UserStats__Stats *from_server; + protobuf_c_boolean has_udp_packets; + uint32_t udp_packets; + protobuf_c_boolean has_tcp_packets; + uint32_t tcp_packets; + protobuf_c_boolean has_udp_ping_avg; + float udp_ping_avg; + protobuf_c_boolean has_udp_ping_var; + float udp_ping_var; + protobuf_c_boolean has_tcp_ping_avg; + float tcp_ping_avg; + protobuf_c_boolean has_tcp_ping_var; + float tcp_ping_var; + MumbleProto__Version *version; + size_t n_celt_versions; + int32_t *celt_versions; + protobuf_c_boolean has_address; + ProtobufCBinaryData address; + protobuf_c_boolean has_bandwidth; + uint32_t bandwidth; + protobuf_c_boolean has_onlinesecs; + uint32_t onlinesecs; + protobuf_c_boolean has_idlesecs; + uint32_t idlesecs; + protobuf_c_boolean has_strong_certificate; + protobuf_c_boolean strong_certificate; +}; +#define MUMBLE_PROTO__USER_STATS__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__user_stats__descriptor) \ + , 0,0, 0,0, 0,NULL, NULL, NULL, 0,0, 0,0, 0,0, 0,0, 0,0, 0,0, NULL, 0,NULL, 0,{0,NULL}, 0,0, 0,0, 0,0, 0,0 } + + +struct _MumbleProto__RequestBlob +{ + ProtobufCMessage base; + size_t n_session_texture; + uint32_t *session_texture; + size_t n_session_comment; + uint32_t *session_comment; + size_t n_channel_description; + uint32_t *channel_description; +}; +#define MUMBLE_PROTO__REQUEST_BLOB__INIT \ + { PROTOBUF_C_MESSAGE_INIT (&mumble_proto__request_blob__descriptor) \ + , 0,NULL, 0,NULL, 0,NULL } + + /* MumbleProto__Version methods */ void mumble_proto__version__init (MumbleProto__Version *message); @@ -609,6 +717,25 @@ MumbleProto__Reject * void mumble_proto__reject__free_unpacked (MumbleProto__Reject *message, ProtobufCAllocator *allocator); +/* MumbleProto__ServerConfig methods */ +void mumble_proto__server_config__init + (MumbleProto__ServerConfig *message); +size_t mumble_proto__server_config__get_packed_size + (const MumbleProto__ServerConfig *message); +size_t mumble_proto__server_config__pack + (const MumbleProto__ServerConfig *message, + uint8_t *out); +size_t mumble_proto__server_config__pack_to_buffer + (const MumbleProto__ServerConfig *message, + ProtobufCBuffer *buffer); +MumbleProto__ServerConfig * + mumble_proto__server_config__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void mumble_proto__server_config__free_unpacked + (MumbleProto__ServerConfig *message, + ProtobufCAllocator *allocator); /* MumbleProto__ServerSync methods */ void mumble_proto__server_sync__init (MumbleProto__ServerSync *message); @@ -947,6 +1074,47 @@ MumbleProto__CodecVersion * void mumble_proto__codec_version__free_unpacked (MumbleProto__CodecVersion *message, ProtobufCAllocator *allocator); +/* MumbleProto__UserStats__Stats methods */ +void mumble_proto__user_stats__stats__init + (MumbleProto__UserStats__Stats *message); +/* MumbleProto__UserStats methods */ +void mumble_proto__user_stats__init + (MumbleProto__UserStats *message); +size_t mumble_proto__user_stats__get_packed_size + (const MumbleProto__UserStats *message); +size_t mumble_proto__user_stats__pack + (const MumbleProto__UserStats *message, + uint8_t *out); +size_t mumble_proto__user_stats__pack_to_buffer + (const MumbleProto__UserStats *message, + ProtobufCBuffer *buffer); +MumbleProto__UserStats * + mumble_proto__user_stats__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void mumble_proto__user_stats__free_unpacked + (MumbleProto__UserStats *message, + ProtobufCAllocator *allocator); +/* MumbleProto__RequestBlob methods */ +void mumble_proto__request_blob__init + (MumbleProto__RequestBlob *message); +size_t mumble_proto__request_blob__get_packed_size + (const MumbleProto__RequestBlob *message); +size_t mumble_proto__request_blob__pack + (const MumbleProto__RequestBlob *message, + uint8_t *out); +size_t mumble_proto__request_blob__pack_to_buffer + (const MumbleProto__RequestBlob *message, + ProtobufCBuffer *buffer); +MumbleProto__RequestBlob * + mumble_proto__request_blob__unpack + (ProtobufCAllocator *allocator, + size_t len, + const uint8_t *data); +void mumble_proto__request_blob__free_unpacked + (MumbleProto__RequestBlob *message, + ProtobufCAllocator *allocator); /* --- per-message closures --- */ typedef void (*MumbleProto__Version_Closure) @@ -964,6 +1132,9 @@ typedef void (*MumbleProto__Ping_Closure) typedef void (*MumbleProto__Reject_Closure) (const MumbleProto__Reject *message, void *closure_data); +typedef void (*MumbleProto__ServerConfig_Closure) + (const MumbleProto__ServerConfig *message, + void *closure_data); typedef void (*MumbleProto__ServerSync_Closure) (const MumbleProto__ServerSync *message, void *closure_data); @@ -1030,6 +1201,15 @@ typedef void (*MumbleProto__PermissionQuery_Closure) typedef void (*MumbleProto__CodecVersion_Closure) (const MumbleProto__CodecVersion *message, void *closure_data); +typedef void (*MumbleProto__UserStats__Stats_Closure) + (const MumbleProto__UserStats__Stats *message, + void *closure_data); +typedef void (*MumbleProto__UserStats_Closure) + (const MumbleProto__UserStats *message, + void *closure_data); +typedef void (*MumbleProto__RequestBlob_Closure) + (const MumbleProto__RequestBlob *message, + void *closure_data); /* --- services --- */ @@ -1042,6 +1222,7 @@ extern const ProtobufCMessageDescriptor mumble_proto__authenticate__descriptor; extern const ProtobufCMessageDescriptor mumble_proto__ping__descriptor; extern const ProtobufCMessageDescriptor mumble_proto__reject__descriptor; extern const ProtobufCEnumDescriptor mumble_proto__reject__reject_type__descriptor; +extern const ProtobufCMessageDescriptor mumble_proto__server_config__descriptor; extern const ProtobufCMessageDescriptor mumble_proto__server_sync__descriptor; extern const ProtobufCMessageDescriptor mumble_proto__channel_remove__descriptor; extern const ProtobufCMessageDescriptor mumble_proto__channel_state__descriptor; @@ -1066,6 +1247,9 @@ extern const ProtobufCMessageDescriptor mumble_proto__voice_target__descriptor; extern const ProtobufCMessageDescriptor mumble_proto__voice_target__target__descriptor; extern const ProtobufCMessageDescriptor mumble_proto__permission_query__descriptor; extern const ProtobufCMessageDescriptor mumble_proto__codec_version__descriptor; +extern const ProtobufCMessageDescriptor mumble_proto__user_stats__descriptor; +extern const ProtobufCMessageDescriptor mumble_proto__user_stats__stats__descriptor; +extern const ProtobufCMessageDescriptor mumble_proto__request_blob__descriptor; PROTOBUF_C_END_DECLS diff --git a/src/Mumble.proto b/src/Mumble.proto index 3084892..9c2894d 100644 --- a/src/Mumble.proto +++ b/src/Mumble.proto @@ -49,12 +49,19 @@ message Reject { optional string reason = 2; } +message ServerConfig { + optional uint32 max_bandwidth = 1; + optional string welcome_text = 2; + optional bool allow_html = 3; + optional uint32 message_length = 4; + optional uint32 image_message_length = 5; +} + message ServerSync { optional uint32 session = 1; optional uint32 max_bandwidth = 2; optional string welcome_text = 3; optional uint64 permissions = 4; - optional bool allow_html = 5 [default = true]; } message ChannelRemove { @@ -71,6 +78,7 @@ message ChannelState { repeated uint32 links_remove = 7; optional bool temporary = 8 [default = false]; optional int32 position = 9 [default = 0]; + optional bytes description_hash = 10; } message UserRemove { @@ -92,10 +100,14 @@ message UserState { optional bool self_mute = 9; optional bool self_deaf = 10; optional bytes texture = 11; - optional string plugin_context = 12; + optional bytes plugin_context = 12; optional string plugin_identity = 13; optional string comment = 14; optional string hash = 15; + optional bytes comment_hash = 16; + optional bytes texture_hash = 17; + optional bool priority_speaker = 18; + optional bool recording = 19; } message BanList { @@ -130,12 +142,15 @@ message PermissionDenied { H9K = 5; TemporaryChannel = 6; MissingCertificate = 7; + UserName = 8; + ChannelFull = 9; } optional uint32 permission = 1; optional uint32 channel_id = 2; optional uint32 session = 3; optional string reason = 4; optional DenyType type = 5; + optional string name = 6; } message ACL { @@ -223,3 +238,39 @@ message CodecVersion { required int32 beta = 2; required bool prefer_alpha = 3 [default = true]; } + +message UserStats { + message Stats { + optional uint32 good = 1; + optional uint32 late = 2; + optional uint32 lost = 3; + optional uint32 resync = 4; + } + + optional uint32 session = 1; + optional bool stats_only = 2 [default = false]; + repeated bytes certificates = 3; + optional Stats from_client = 4; + optional Stats from_server = 5; + + optional uint32 udp_packets = 6; + optional uint32 tcp_packets = 7; + optional float udp_ping_avg = 8; + optional float udp_ping_var = 9; + optional float tcp_ping_avg = 10; + optional float tcp_ping_var = 11; + + optional Version version = 12; + repeated int32 celt_versions = 13; + optional bytes address = 14; + optional uint32 bandwidth = 15; + optional uint32 onlinesecs = 16; + optional uint32 idlesecs = 17; + optional bool strong_certificate = 18 [default = false]; +} + +message RequestBlob { + repeated uint32 session_texture = 1; + repeated uint32 session_comment = 2; + repeated uint32 channel_description = 3; +} diff --git a/src/messages.c b/src/messages.c index 5931edd..5a61082 100644 --- a/src/messages.c +++ b/src/messages.c @@ -226,6 +226,26 @@ int Msg_messageToNetwork(message_t *msg, uint8_t *buffer) Msg_addPreamble(buffer, msg->messageType, len); mumble_proto__channel_remove__pack(msg->payload.channelRemove, bufptr); break; + case UserStats: + { + len = mumble_proto__user_stats__get_packed_size(msg->payload.userStats); + if (len > MAX_MSGSIZE) { + Log_warn("Too big tx message. Discarding"); + break; + } + Msg_addPreamble(buffer, msg->messageType, len); + mumble_proto__user_stats__pack(msg->payload.userStats, bufptr); + break; + } + case ServerConfig: + len = mumble_proto__server_config__get_packed_size(msg->payload.serverConfig); + if (len > MAX_MSGSIZE) { + Log_warn("Too big tx message. Discarding"); + break; + } + Msg_addPreamble(buffer, msg->messageType, len); + mumble_proto__server_config__pack(msg->payload.serverConfig, bufptr); + break; default: Log_warn("Msg_MessageToNetwork: Unsupported message %d", msg->messageType); @@ -320,6 +340,27 @@ message_t *Msg_create(messageType_t messageType) msg->payload.channelRemove = malloc(sizeof(MumbleProto__ChannelRemove)); mumble_proto__channel_remove__init(msg->payload.channelRemove); break; + case UserStats: + msg->payload.userStats = malloc(sizeof(MumbleProto__UserStats)); + mumble_proto__user_stats__init(msg->payload.userStats); + + msg->payload.userStats->from_client = malloc(sizeof(MumbleProto__UserStats__Stats)); + mumble_proto__user_stats__stats__init(msg->payload.userStats->from_client); + + msg->payload.userStats->from_server = malloc(sizeof(MumbleProto__UserStats__Stats)); + mumble_proto__user_stats__stats__init(msg->payload.userStats->from_server); + + msg->payload.userStats->version = malloc(sizeof(MumbleProto__Version)); + mumble_proto__version__init(msg->payload.userStats->version); + + if (!msg->payload.userStats || !msg->payload.userStats->from_client || + !msg->payload.userStats->from_server || !msg->payload.userStats->version) + Log_fatal("Out of memory"); + break; + case ServerConfig: + msg->payload.serverConfig = malloc(sizeof(MumbleProto__ServerConfig)); + mumble_proto__server_config__init(msg->payload.serverConfig); + break; default: Log_warn("Msg_create: Unsupported message %d", msg->messageType); @@ -476,6 +517,44 @@ void Msg_free(message_t *msg) free(msg->payload.channelRemove); } break; + case UserStats: + if (msg->unpacked) + mumble_proto__user_stats__free_unpacked(msg->payload.userStats, NULL); + else { + if (msg->payload.userStats->from_client) + free(msg->payload.userStats->from_client); + if (msg->payload.userStats->from_server) + free(msg->payload.userStats->from_server); + if (msg->payload.userStats->version) { + if (msg->payload.userStats->version->release) + free(msg->payload.userStats->version->release); + if (msg->payload.userStats->version->os) + free(msg->payload.userStats->version->os); + if (msg->payload.userStats->version->os_version) + free(msg->payload.userStats->version->os_version); + + free(msg->payload.userStats->version); + } + if (msg->payload.userStats->celt_versions) + free(msg->payload.userStats->celt_versions); + if (msg->payload.userStats->certificates) { + if (msg->payload.userStats->certificates->data) + free(msg->payload.userStats->certificates->data); + free(msg->payload.userStats->certificates); + } + if (msg->payload.userStats->address.data) + free(msg->payload.userStats->address.data); + + free(msg->payload.userStats); + } + break; + case ServerConfig: + if (msg->unpacked) + mumble_proto__server_config__free_unpacked(msg->payload.serverConfig, NULL); + else { + free(msg->payload.serverConfig); + } + break; default: Log_warn("Msg_free: Unsupported message %d", msg->messageType); @@ -653,6 +732,15 @@ message_t *Msg_networkToMessage(uint8_t *data, int size) goto err_out; break; } + case UserStats: + { + msg = Msg_create_nopayload(UserStats); + msg->unpacked = true; + msg->payload.userStats = mumble_proto__user_stats__unpack(NULL, msgLen, msgData); + if (msg->payload.userStats == NULL) + goto err_out; + break; + } default: Log_warn("Unsupported message %d", messageType); diff --git a/src/messages.h b/src/messages.h index 9fde9f9..fd30666 100644 --- a/src/messages.h +++ b/src/messages.h @@ -38,7 +38,7 @@ #define PROTVER_MAJOR 1 #define PROTVER_MINOR 2 -#define PROTVER_PATCH 0 +#define PROTVER_PATCH 3 #define PROTOCOL_VERSION ((PROTVER_MAJOR << 16) | (PROTVER_MINOR << 8) | (PROTVER_PATCH)) #define PERM_NONE 0x0 @@ -86,6 +86,9 @@ typedef enum { VoiceTarget, PermissionQuery, /* 20 */ CodecVersion, + UserStats, + RequestBlob, + ServerConfig } messageType_t; typedef enum { @@ -123,6 +126,8 @@ typedef union payload { struct _MumbleProto__VoiceTarget *voiceTarget; struct _MumbleProto__PermissionQuery *permissionQuery; struct _MumbleProto__CodecVersion *codecVersion; + struct _MumbleProto__UserStats *userStats; + struct _MumbleProto__ServerConfig *serverConfig; } payload_t; typedef struct message { -- 2.30.2