Commit 0dcf2d7572 for freeswitch.com

commit 0dcf2d75726415b5e46b49263c4a1c3b35f8b927
Author: Dmitry Verenitsin <morbit85@gmail.com>
Date:   Wed Nov 18 22:19:42 2026 +0500

    Merge commit from fork

    `skinny_read_packet()` checked the declared length as `length + 8 >
    2048` on a `uint32_t`, which wraps for lengths of `0xFFFFFFF8` and
    above, and `skinny_check_data_length()` in the handlers only enforces a
    minimum. Compare the length against the constant side instead, and
    advance `ptr` on every read so a length field that arrives in pieces is
    stored contiguously instead of being overwritten by later bytes.

    - The message buffer gets one spare zero byte, so fixed-width string
      fields of a full-size message terminate inside the allocation.
    - The data and extended data handlers check `data_length` against the
      bytes left after their header, with no addition on the wire value.
    - Those two handlers and `skinny_handle_xml_alarm()` build the event
      body with `%.*s` instead of an unchecked `malloc` copy.
    - `skinny_handle_extended_data_message()` takes the body from the
      `extended_data` member instead of `data`, so the event body no longer
      starts with 20 bytes of header fields.
    - `skinny_handle_updatecapabilities()` rejects an empty audio
      capability list, as `skinny_handle_capabilities_response()` already
      does.

diff --git a/src/mod/endpoints/mod_skinny/skinny_protocol.c b/src/mod/endpoints/mod_skinny/skinny_protocol.c
index e345f00930..d25d1dc629 100644
--- a/src/mod/endpoints/mod_skinny/skinny_protocol.c
+++ b/src/mod/endpoints/mod_skinny/skinny_protocol.c
@@ -110,7 +110,8 @@ switch_status_t skinny_read_packet(listener_t *listener, skinny_message_t **req)
 	char *ptr;
 	switch_status_t status = SWITCH_STATUS_SUCCESS;

-	request = calloc(1,SKINNY_MESSAGE_MAXSIZE);
+	/* One zero byte past the largest message, so fixed-width string fields always terminate inside the allocation */
+	request = calloc(1, SKINNY_MESSAGE_MAXSIZE + 1);

 	if (!request) {
 		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Unable to allocate memory.\n");
@@ -152,10 +153,10 @@ switch_status_t skinny_read_packet(listener_t *listener, skinny_message_t **req)

 		if(mlen) {
 			bytes += mlen;
+			ptr += mlen;

 			if(bytes >= SKINNY_MESSAGE_FIELD_SIZE) {
 				do_sleep = 0;
-				ptr += mlen;
 				memcpy(request, mbuf, bytes);
 #ifdef SKINNY_MEGA_DEBUG
 				switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
@@ -169,9 +170,9 @@ switch_status_t skinny_read_packet(listener_t *listener, skinny_message_t **req)
 					switch_safe_free(request);
 					return SWITCH_STATUS_FALSE;
 				}
-				if(request->length + 2*SKINNY_MESSAGE_FIELD_SIZE > SKINNY_MESSAGE_MAXSIZE) {
+				if(request->length > SKINNY_MESSAGE_MAXSIZE - 2*SKINNY_MESSAGE_FIELD_SIZE) {
 					switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
-							"Skinny client sent too huge data. Got %d which is above threshold %d.\n",
+							"Skinny client sent too huge data. Got %u which is above threshold %d.\n",
 							request->length, SKINNY_MESSAGE_MAXSIZE - 2*SKINNY_MESSAGE_FIELD_SIZE);
 					switch_safe_free(request);
 					return SWITCH_STATUS_FALSE;
diff --git a/src/mod/endpoints/mod_skinny/skinny_server.c b/src/mod/endpoints/mod_skinny/skinny_server.c
index af7702a363..87633b7616 100644
--- a/src/mod/endpoints/mod_skinny/skinny_server.c
+++ b/src/mod/endpoints/mod_skinny/skinny_server.c
@@ -2375,9 +2375,16 @@ switch_status_t skinny_handle_register_available_lines_message(listener_t *liste
 switch_status_t skinny_handle_data_message(listener_t *listener, skinny_message_t *request)
 {
 	switch_event_t *event = NULL;
-	char *tmp = NULL;
+
 	skinny_check_data_length(request, sizeof(request->data.data));
-	skinny_check_data_length(request, sizeof(request->data.data) + request->data.data.data_length - 1);
+
+	if (request->data.data.data_length > request->length - 4 - offsetof(struct data_message, data)) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
+				"Received Skinny Message %s (type=%x,length=%u) with data length %u past its end.\n",
+				skinny_message_type2str(request->type), request->type, request->length, request->data.data.data_length);
+
+		return SWITCH_STATUS_FALSE;
+	}

 	/* skinny::device_to_user event */
 	skinny_device_event(listener, &event, SWITCH_EVENT_CUSTOM, SKINNY_EVENT_DEVICE_TO_USER);
@@ -2388,15 +2395,7 @@ switch_status_t skinny_handle_data_message(listener_t *listener, skinny_message_
 	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-DeviceToUser-Call-Id", "%d", request->data.data.call_id);
 	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-DeviceToUser-Transaction-Id", "%d", request->data.data.transaction_id);
 	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-DeviceToUser-Data-Length", "%d", request->data.data.data_length);
-
-	tmp = malloc(request->data.data.data_length + 1);
-	memcpy(tmp, request->data.data.data, request->data.data.data_length);
-
-	/* Ensure that the body is null-terminated */
-	tmp[request->data.data.data_length] = '\0';
-	switch_event_add_body(event, "%s", tmp);
-
-	switch_safe_free(tmp);
+	switch_event_add_body(event, "%.*s", (int)request->data.data.data_length, request->data.data.data);

 	switch_event_fire(&event);

@@ -2446,9 +2445,16 @@ switch_status_t skinny_handle_feature_stat_request(listener_t *listener, skinny_
 switch_status_t skinny_handle_extended_data_message(listener_t *listener, skinny_message_t *request)
 {
 	switch_event_t *event = NULL;
-	char *tmp = NULL;
+
 	skinny_check_data_length(request, sizeof(request->data.extended_data));
-	skinny_check_data_length(request, sizeof(request->data.extended_data)+request->data.extended_data.data_length-1);
+
+	if (request->data.extended_data.data_length > request->length - 4 - offsetof(struct extended_data_message, data)) {
+		switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,
+				"Received Skinny Message %s (type=%x,length=%u) with data length %u past its end.\n",
+				skinny_message_type2str(request->type), request->type, request->length, request->data.extended_data.data_length);
+
+		return SWITCH_STATUS_FALSE;
+	}

 	/* skinny::device_to_user event */
 	skinny_device_event(listener, &event, SWITCH_EVENT_CUSTOM, SKINNY_EVENT_DEVICE_TO_USER);
@@ -2464,15 +2470,8 @@ switch_status_t skinny_handle_extended_data_message(listener_t *listener, skinny
 	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-DeviceToUser-Conference-Id", "%d", request->data.extended_data.conference_id);
 	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-DeviceToUser-App-Instance-Id", "%d", request->data.extended_data.app_instance_id);
 	switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Skinny-DeviceToUser-Routing-Id", "%d", request->data.extended_data.routing_id);
+	switch_event_add_body(event, "%.*s", (int)request->data.extended_data.data_length, request->data.extended_data.data);

-	tmp = malloc(request->data.data.data_length + 1);
-	memcpy(tmp, request->data.data.data, request->data.data.data_length);
-
-	/* Ensure that the body is null-terminated */
-	tmp[request->data.data.data_length] = '\0';
-	switch_event_add_body(event, "%s", tmp);
-
-	switch_safe_free(tmp);
 	switch_event_fire(&event);

 	return SWITCH_STATUS_SUCCESS;
@@ -2569,6 +2568,11 @@ switch_status_t skinny_handle_updatecapabilities(listener_t *listener, skinny_me
 	skinny_check_data_length(request, sizeof(request->data.upd_cap.audio_cap_count));

 	n = request->data.upd_cap.audio_cap_count;
+	if (n == 0) {
+		skinny_log_l_msg(listener, SWITCH_LOG_ERROR, "Device sent no audio capabilities.\n");
+
+		return SWITCH_STATUS_FALSE;
+	}
 	if (n > SKINNY_MAX_CAPABILITIES) {
 		n = SKINNY_MAX_CAPABILITIES;
 	}
@@ -2626,17 +2630,11 @@ switch_status_t skinny_handle_server_req_message(listener_t *listener, skinny_me
 switch_status_t skinny_handle_xml_alarm(listener_t *listener, skinny_message_t *request)
 {
 	switch_event_t *event = NULL;
-	char *tmp = NULL;

-	skinny_log_l(listener, SWITCH_LOG_DEBUG, "Received XML alarm (length=%d).\n", request->length);
+	skinny_log_l(listener, SWITCH_LOG_DEBUG, "Received XML alarm (length=%u).\n", request->length);
 	/* skinny::xml_alarm event */
 	skinny_device_event(listener, &event, SWITCH_EVENT_CUSTOM, SKINNY_EVENT_XML_ALARM);
-	/* Ensure that the body is null-terminated */
-	tmp = malloc(request->length - 4 + 1);
-	memcpy(tmp, request->data.as_char, request->length - 4);
-	tmp[request->length - 4] = '\0';
-	switch_event_add_body(event, "%s", tmp);
-	switch_safe_free(tmp);
+	switch_event_add_body(event, "%.*s", (int)(request->length - 4), request->data.as_char);
 	switch_event_fire(&event);

 	return SWITCH_STATUS_SUCCESS;