update

FutureKosmos · FutureKosmos · commit 1ffe1bdc7c97 · 2025-02-05T20:09:13.000+08:00
diff --git a/include/cdk/cdk-types.h b/include/cdk/cdk-types.h
@@ -262,7 +262,7 @@ struct cdk_unpacker_s {
         } lengthfield;
 
         struct {
-            void (*unpack)(cdk_channel_t* channel);
+            bool (*unpack)(cdk_channel_t* channel);
         } userdefined;
     };
 };
@@ -363,6 +363,7 @@ struct cdk_channel_error_s {
         CHANNEL_ERROR_POLLER_SHUTDOWN,
         CHANNEL_ERROR_SYSCALL_FAIL,
         CHANNEL_ERROR_TLS_FAIL,
+        CHANNEL_ERROR_BUFFER_OVERFLOW,
         CHANNEL_ERROR_END,
     } code;
     char* codestr;
diff --git a/src/net/channel.c b/src/net/channel.c
@@ -284,10 +284,15 @@ static void _tls_recv(cdk_channel_t* channel) {
     }
     channel->latest_rd_time = cdk_time_now();
     channel->rxbuf.off += n;
-    if (channel->rxbuf.off > MAX_TCP_RECVBUF_SIZE) {
-        abort();
+
+    if (!unpacker_unpack(channel)) {
+        cdk_channel_error_t error = {
+            .code = CHANNEL_ERROR_BUFFER_OVERFLOW,
+            .codestr = CHANNEL_ERROR_BUFFER_OVERFLOW_STR};
+        channel_error_update(channel, error);
+        channel_destroy(channel);
+        return;
     }
-    unpacker_unpack(channel);
 }
 
 static void _tcp_recv(cdk_channel_t* channel) {
@@ -320,7 +325,23 @@ static void _tcp_recv(cdk_channel_t* channel) {
     }
     channel->latest_rd_time = cdk_time_now();
     channel->rxbuf.off += n;
-    unpacker_unpack(channel);
+
+    if (channel->rxbuf.off > MAX_TCP_RECVBUF_SIZE) {
+        cdk_channel_error_t error = {
+            .code = CHANNEL_ERROR_BUFFER_OVERFLOW,
+            .codestr = CHANNEL_ERROR_BUFFER_OVERFLOW_STR};
+        channel_error_update(channel, error);
+        channel_destroy(channel);
+        return;
+    }
+    if (!unpacker_unpack(channel)) {
+        cdk_channel_error_t error = {
+            .code = CHANNEL_ERROR_BUFFER_OVERFLOW,
+            .codestr = CHANNEL_ERROR_BUFFER_OVERFLOW_STR};
+        channel_error_update(channel, error);
+        channel_destroy(channel);
+        return;
+    }
 }
 
 static void _udp_recv(cdk_channel_t* channel) {
diff --git a/src/net/channel.h b/src/net/channel.h
@@ -36,8 +36,10 @@ _Pragma("once")
     "Channel destroyed due to connection establishment timeout"
 #define CHANNEL_ERROR_POLLER_SHUTDOWN_STR                                     \
     "Channel destroyed due to poller shutdown"
+#define CHANNEL_ERROR_BUFFER_OVERFLOW_STR                                     \
+    "Channel destroyed due to buffer overflow"
 
-extern cdk_channel_t* channel_create(cdk_poller_t* poller, cdk_sock_t sock, cdk_channel_mode_t mode, cdk_side_t side, cdk_handler_t* handler, cdk_tls_ctx_t* tls_ctx);
+    extern cdk_channel_t* channel_create(cdk_poller_t* poller, cdk_sock_t sock, cdk_channel_mode_t mode, cdk_side_t side, cdk_handler_t* handler, cdk_tls_ctx_t* tls_ctx);
 extern void channel_destroy(cdk_channel_t* channel);
 extern void channel_recv(cdk_channel_t* channel);
 extern void channel_send(cdk_channel_t* channel);
diff --git a/src/net/unpacker.c b/src/net/unpacker.c
@@ -23,7 +23,7 @@
 #include "cdk/cdk-utils.h"
 #include "cdk/encoding/cdk-varint.h"
 
-static inline void _fixedlen_unpack(cdk_channel_t* channel) {
+static inline bool _fixedlen_unpack(cdk_channel_t* channel) {
 	char* head = channel->rxbuf.buf;
 	char* tail = (char*)channel->rxbuf.buf + channel->rxbuf.off;
 	char* tmp = head;
@@ -33,22 +33,26 @@ static inline void _fixedlen_unpack(cdk_channel_t* channel) {
 		if (accumulated < channel->handler->unpacker->fixedlen.len) {
 			break;
 		}
+        if (channel->handler->unpacker->fixedlen.len > channel->rxbuf.len) {
+            return false;
+		}
 		if (channel->handler->on_read) {
 			channel->handler->on_read(channel, tmp, channel->handler->unpacker->fixedlen.len);
 		}
 		tmp += channel->handler->unpacker->fixedlen.len;
 		accumulated -= channel->handler->unpacker->fixedlen.len;
 	}
 	if (tmp == head) {
-		return;
+		return true;
 	}
 	channel->rxbuf.off = accumulated;
 	if (accumulated) {
 		memmove(channel->rxbuf.buf, tmp, accumulated);
 	}
+    return true;
 }
 
-static inline void _delimiter_unpack(cdk_channel_t* channel) {
+static inline bool _delimiter_unpack(cdk_channel_t* channel) {
 	char* head = channel->rxbuf.buf;
 	char* tail = (char*)channel->rxbuf.buf + channel->rxbuf.off;
 	char* tmp = head;
@@ -57,7 +61,7 @@ static inline void _delimiter_unpack(cdk_channel_t* channel) {
 
 	uint32_t accumulated = (uint32_t)(tail - head);
 	if (accumulated < dlen) {
-		return;
+		return true;
 	}
 	/**
 	 * for performance, thus split buffer by KMP.
@@ -84,6 +88,9 @@ static inline void _delimiter_unpack(cdk_channel_t* channel) {
 			j++;
 		}
 		if (j == dlen) {
+            if (((i - dlen + 1) + dlen) > channel->rxbuf.len) {
+                return false;
+            }
 			if (channel->handler->on_read) {
 				channel->handler->on_read(channel, tmp, ((i - dlen + 1) + dlen));
 			}
@@ -97,16 +104,16 @@ static inline void _delimiter_unpack(cdk_channel_t* channel) {
 	free(next);
 	next = NULL;
 	if (tmp == head) {
-		return;
+		return true;
 	}
 	channel->rxbuf.off = accumulated;
 	if (accumulated) {
 		memmove(channel->rxbuf.buf, tmp, accumulated);
 	}
-	return;
+	return true;
 }
 
-static inline void _lengthfield_unpack(cdk_channel_t* channel) {
+static inline bool _lengthfield_unpack(cdk_channel_t* channel) {
 	uint32_t fs; /* frame size   */
 	uint32_t hs; /* header size  */
 	uint32_t ps; /* payload size */
@@ -144,7 +151,7 @@ static inline void _lengthfield_unpack(cdk_channel_t* channel) {
 		fs = hs + ps + channel->handler->unpacker->lengthfield.adj;
 
 		if (fs > channel->rxbuf.len) {
-			abort();
+            return false;
 		}
 		if (accumulated < fs) {
 			break;
@@ -156,40 +163,35 @@ static inline void _lengthfield_unpack(cdk_channel_t* channel) {
 		accumulated -= fs;
 	}
 	if (tmp == head) {
-		return;
+		return true;
 	}
 	channel->rxbuf.off = accumulated;
 	if (accumulated) {
 		memmove(channel->rxbuf.buf, tmp, accumulated);
 	}
-	return;
+	return true;
 }
 
-static void _userdefined_unpack(cdk_channel_t* channel) {
-	channel->handler->unpacker->userdefined.unpack(channel);
+static bool _userdefined_unpack(cdk_channel_t* channel) {
+	return channel->handler->unpacker->userdefined.unpack(channel);
 }
 
-void unpacker_unpack(cdk_channel_t* channel) {
+bool unpacker_unpack(cdk_channel_t* channel) {
 	switch (channel->handler->unpacker->type)
 	{
     case UNPACKER_TYPE_FIXEDLEN: {
-		_fixedlen_unpack(channel);
-		break;
+		return _fixedlen_unpack(channel);
 	}
     case UNPACKER_TYPE_DELIMITER: {
-		_delimiter_unpack(channel);
-		break;
+        return _delimiter_unpack(channel);
 	}
     case UNPACKER_TYPE_LENGTHFIELD: {
-		_lengthfield_unpack(channel);
-		break;
+        return _lengthfield_unpack(channel);
 	}
     case UNPACKER_TYPE_USERDEFINED: {
-		_userdefined_unpack(channel);
-		break;
+        return _userdefined_unpack(channel);
 	}
 	default:
-		abort();
+        return false;
 	}
-	return;
 }
diff --git a/src/net/unpacker.h b/src/net/unpacker.h
@@ -23,4 +23,4 @@ _Pragma("once")
 
 #include "cdk/cdk-types.h"
 
-extern void unpacker_unpack(cdk_channel_t* channel);
+extern bool unpacker_unpack(cdk_channel_t* channel);

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@`
`23`	`23`	`#include "cdk/cdk-utils.h"`
`24`	`24`	`#include "cdk/encoding/cdk-varint.h"`
`25`	`25`
`26`		`-static inline void _fixedlen_unpack(cdk_channel_t* channel) {`
	`26`	`+static inline bool _fixedlen_unpack(cdk_channel_t* channel) {`
`27`	`27`	`char* head = channel->rxbuf.buf;`
`28`	`28`	`char* tail = (char*)channel->rxbuf.buf + channel->rxbuf.off;`
`29`	`29`	`char* tmp = head;`
`@@ -33,22 +33,26 @@ static inline void _fixedlen_unpack(cdk_channel_t* channel) {`
`33`	`33`	`if (accumulated < channel->handler->unpacker->fixedlen.len) {`
`34`	`34`	`break;`
`35`	`35`	`}`
	`36`	`+ if (channel->handler->unpacker->fixedlen.len > channel->rxbuf.len) {`
	`37`	`+ return false;`
	`38`	`+ }`
`36`	`39`	`if (channel->handler->on_read) {`
`37`	`40`	`channel->handler->on_read(channel, tmp, channel->handler->unpacker->fixedlen.len);`
`38`	`41`	`}`
`39`	`42`	`tmp += channel->handler->unpacker->fixedlen.len;`
`40`	`43`	`accumulated -= channel->handler->unpacker->fixedlen.len;`
`41`	`44`	`}`
`42`	`45`	`if (tmp == head) {`
`43`		`- return;`
	`46`	`+ return true;`
`44`	`47`	`}`
`45`	`48`	`channel->rxbuf.off = accumulated;`
`46`	`49`	`if (accumulated) {`
`47`	`50`	`memmove(channel->rxbuf.buf, tmp, accumulated);`
`48`	`51`	`}`
	`52`	`+ return true;`
`49`	`53`	`}`
`50`	`54`
`51`		`-static inline void _delimiter_unpack(cdk_channel_t* channel) {`
	`55`	`+static inline bool _delimiter_unpack(cdk_channel_t* channel) {`
`52`	`56`	`char* head = channel->rxbuf.buf;`
`53`	`57`	`char* tail = (char*)channel->rxbuf.buf + channel->rxbuf.off;`
`54`	`58`	`char* tmp = head;`
`@@ -57,7 +61,7 @@ static inline void _delimiter_unpack(cdk_channel_t* channel) {`
`57`	`61`
`58`	`62`	`uint32_t accumulated = (uint32_t)(tail - head);`
`59`	`63`	`if (accumulated < dlen) {`
`60`		`- return;`
	`64`	`+ return true;`
`61`	`65`	`}`
`62`	`66`	`/**`
`63`	`67`	`* for performance, thus split buffer by KMP.`
`@@ -84,6 +88,9 @@ static inline void _delimiter_unpack(cdk_channel_t* channel) {`
`84`	`88`	`j++;`
`85`	`89`	`}`
`86`	`90`	`if (j == dlen) {`
	`91`	`+ if (((i - dlen + 1) + dlen) > channel->rxbuf.len) {`
	`92`	`+ return false;`
	`93`	`+ }`
`87`	`94`	`if (channel->handler->on_read) {`
`88`	`95`	`channel->handler->on_read(channel, tmp, ((i - dlen + 1) + dlen));`
`89`	`96`	`}`
`@@ -97,16 +104,16 @@ static inline void _delimiter_unpack(cdk_channel_t* channel) {`
`97`	`104`	`free(next);`
`98`	`105`	`next = NULL;`
`99`	`106`	`if (tmp == head) {`
`100`		`- return;`
	`107`	`+ return true;`
`101`	`108`	`}`
`102`	`109`	`channel->rxbuf.off = accumulated;`
`103`	`110`	`if (accumulated) {`
`104`	`111`	`memmove(channel->rxbuf.buf, tmp, accumulated);`
`105`	`112`	`}`
`106`		`- return;`
	`113`	`+ return true;`
`107`	`114`	`}`
`108`	`115`
`109`		`-static inline void _lengthfield_unpack(cdk_channel_t* channel) {`
	`116`	`+static inline bool _lengthfield_unpack(cdk_channel_t* channel) {`
`110`	`117`	`uint32_t fs; /* frame size */`
`111`	`118`	`uint32_t hs; /* header size */`
`112`	`119`	`uint32_t ps; /* payload size */`
`@@ -144,7 +151,7 @@ static inline void _lengthfield_unpack(cdk_channel_t* channel) {`
`144`	`151`	`fs = hs + ps + channel->handler->unpacker->lengthfield.adj;`
`145`	`152`
`146`	`153`	`if (fs > channel->rxbuf.len) {`
`147`		`- abort();`
	`154`	`+ return false;`
`148`	`155`	`}`
`149`	`156`	`if (accumulated < fs) {`
`150`	`157`	`break;`
`@@ -156,40 +163,35 @@ static inline void _lengthfield_unpack(cdk_channel_t* channel) {`
`156`	`163`	`accumulated -= fs;`
`157`	`164`	`}`
`158`	`165`	`if (tmp == head) {`
`159`		`- return;`
	`166`	`+ return true;`
`160`	`167`	`}`
`161`	`168`	`channel->rxbuf.off = accumulated;`
`162`	`169`	`if (accumulated) {`
`163`	`170`	`memmove(channel->rxbuf.buf, tmp, accumulated);`
`164`	`171`	`}`
`165`		`- return;`
	`172`	`+ return true;`
`166`	`173`	`}`
`167`	`174`
`168`		`-static void _userdefined_unpack(cdk_channel_t* channel) {`
`169`		`- channel->handler->unpacker->userdefined.unpack(channel);`
	`175`	`+static bool _userdefined_unpack(cdk_channel_t* channel) {`
	`176`	`+ return channel->handler->unpacker->userdefined.unpack(channel);`
`170`	`177`	`}`
`171`	`178`
`172`		`-void unpacker_unpack(cdk_channel_t* channel) {`
	`179`	`+bool unpacker_unpack(cdk_channel_t* channel) {`
`173`	`180`	`switch (channel->handler->unpacker->type)`
`174`	`181`	`{`
`175`	`182`	`case UNPACKER_TYPE_FIXEDLEN: {`
`176`		`- _fixedlen_unpack(channel);`
`177`		`- break;`
	`183`	`+ return _fixedlen_unpack(channel);`
`178`	`184`	`}`
`179`	`185`	`case UNPACKER_TYPE_DELIMITER: {`
`180`		`- _delimiter_unpack(channel);`
`181`		`- break;`
	`186`	`+ return _delimiter_unpack(channel);`
`182`	`187`	`}`
`183`	`188`	`case UNPACKER_TYPE_LENGTHFIELD: {`
`184`		`- _lengthfield_unpack(channel);`
`185`		`- break;`
	`189`	`+ return _lengthfield_unpack(channel);`
`186`	`190`	`}`
`187`	`191`	`case UNPACKER_TYPE_USERDEFINED: {`
`188`		`- _userdefined_unpack(channel);`
`189`		`- break;`
	`192`	`+ return _userdefined_unpack(channel);`
`190`	`193`	`}`
`191`	`194`	`default:`
`192`		`- abort();`
	`195`	`+ return false;`
`193`	`196`	`}`
`194`		`- return;`
`195`	`197`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,4 +23,4 @@ _Pragma("once")`
`23`	`23`
`24`	`24`	`#include "cdk/cdk-types.h"`
`25`	`25`
`26`		`-extern void unpacker_unpack(cdk_channel_t* channel);`
	`26`	`+extern bool unpacker_unpack(cdk_channel_t* channel);`