[*] Fixed some weak places

stream/dap_stream_pkt.c

@@ -42,21 +42,21 @@
 
 
 
-const size_t dap_hdr_size=8+2+1+1+4;
-const uint8_t dap_sig[8]={0xa0,0x95,0x96,0xa9,0x9e,0x5c,0xfb,0xfa};
+static const size_t s_dap_hdr_size=8+2+1+1+4;
+const uint8_t c_dap_stream_sig[8]={0xa0,0x95,0x96,0xa9,0x9e,0x5c,0xfb,0xfa};
 
 
-dap_stream_pkt_t * dap_stream_pkt_detect(void * data, uint32_t data_size)
+dap_stream_pkt_t * dap_stream_pkt_detect(void * a_data, size_t data_size)
 {
-    void * sig_start=data;
+    uint8_t * sig_start=(uint8_t*) a_data;
     dap_stream_pkt_t * ret=NULL;
-    uint32_t length_left=data_size;
-    while(sig_start=memchr(sig_start, dap_sig[0],length_left) ){
-        length_left= data_size-( sig_start-data);
-        if(length_left < sizeof(dap_sig) )
+    size_t length_left=data_size;
+    while( (sig_start=memchr(sig_start, c_dap_stream_sig[0],length_left)) != NULL ){
+        length_left= data_size- (size_t)  ( sig_start- (uint8_t *) a_data);
+        if(length_left < sizeof(c_dap_stream_sig) )
             break;
-        if(memcmp(sig_start,dap_sig,sizeof(dap_sig))==0){
-            ret=sig_start;
+        if(memcmp(sig_start,c_dap_stream_sig,sizeof(c_dap_stream_sig))==0){
+            ret= (dap_stream_pkt_t*) sig_start;
             if(ret->hdr.size > STREAM_PKT_SIZE_MAX ){
                 //log_it(L_ERROR, "Too big packet size %u",ret->hdr.size);
                 ret=NULL;
@@ -68,9 +68,16 @@ dap_stream_pkt_t * dap_stream_pkt_detect(void * data, uint32_t data_size)
     return ret;
 }
 
-size_t encode_dummy(const void * buf, const size_t buf_size, void * buf_out){
-    if(memcpy(buf_out,buf,buf_size) != NULL)
-        return buf_size;
+/**
+ * @brief s_encode_dummy
+ * @param a_buf
+ * @param a_buf_size
+ * @param a_buf_out
+ * @return
+ */
+static size_t s_encode_dummy(const void * a_buf, size_t a_buf_size, void * a_buf_out){
+    if(memcpy(a_buf_out,a_buf,a_buf_size) != NULL)
+        return a_buf_size;
     else
         return 0;
 }
@@ -81,9 +88,9 @@ size_t encode_dummy(const void * buf, const size_t buf_size, void * buf_out){
  * @param pkt
  * @param buf_out
  */
-size_t dap_stream_pkt_read(struct dap_stream * sid,struct dap_stream_pkt * pkt, void * buf_out, size_t buf_out_size)
+size_t dap_stream_pkt_read( dap_stream_t * a_stream, dap_stream_pkt_t * a_pkt, void * a_buf_out, size_t a_buf_out_size)
 {
-    size_t ds = sid->session->key->dec_na(sid->session->key,pkt->data,pkt->hdr.size,buf_out, buf_out_size);
+    size_t ds = a_stream->session->key->dec_na(a_stream->session->key,a_pkt->data,a_pkt->hdr.size,a_buf_out, a_buf_out_size);
 //    log_it(L_DEBUG,"Stream decoded %lu bytes ( last bytes 0x%02x 0x%02x 0x%02x 0x%02x ) ", ds,
 //           *((uint8_t *)buf_out+ds-4),*((uint8_t *)buf_out+ds-3),*((uint8_t *)buf_out+ds-2),*((uint8_t *)buf_out+ds-1)
 //           );
@@ -104,48 +111,51 @@ size_t dap_stream_pkt_read(struct dap_stream * sid,struct dap_stream_pkt * pkt,
  * @return
  */
 
-size_t dap_stream_pkt_write(struct dap_stream * sid, const void * data, uint32_t data_size)
+size_t dap_stream_pkt_write(dap_stream_t * a_stream, const void * a_data, size_t a_data_size)
 {
     size_t ret=0;
     stream_pkt_hdr_t pkt_hdr;
 
-    if(data_size > STREAM_BUF_SIZE_MAX ){
-        log_it(L_ERROR,"Too big data size %lu, bigger than encryption buffer size %lu",data_size,sizeof(sid->buf));
-        data_size=sizeof(sid->buf);
+    if(a_data_size > STREAM_BUF_SIZE_MAX ){
+        log_it(L_ERROR,"Too big data size %lu, bigger than encryption buffer size %lu",a_data_size,sizeof(a_stream->buf));
+        a_data_size=sizeof(a_stream->buf);
     }
 
     memset(&pkt_hdr,0,sizeof(pkt_hdr));
-    memcpy(pkt_hdr.sig,dap_sig,sizeof(pkt_hdr.sig));
+    memcpy(pkt_hdr.sig,c_dap_stream_sig,sizeof(pkt_hdr.sig));
 
-    pkt_hdr.size = sid->session->key->enc_na(sid->session->key, data,data_size,sid->buf, STREAM_BUF_SIZE_MAX);
+    pkt_hdr.size =(uint32_t) a_stream->session->key->enc_na(a_stream->session->key, a_data,a_data_size,a_stream->buf, STREAM_BUF_SIZE_MAX);
 //    printf("*[dap_stream_pkt_write] size=%d key=0x%x _inheritor_size=%d\n", pkt_hdr.size, sid->session->key,
 //            sid->session->key->_inheritor_size);
 
-    if(sid->conn_udp){
-        ret+=dap_udp_client_write(sid->conn,&pkt_hdr,sizeof(pkt_hdr));
-        ret+=dap_udp_client_write(sid->conn,sid->buf,pkt_hdr.size);
+    if(a_stream->conn_udp){
+        ret+=dap_udp_client_write(a_stream->conn,&pkt_hdr,sizeof(pkt_hdr));
+        ret+=dap_udp_client_write(a_stream->conn,a_stream->buf,pkt_hdr.size);
     }
-    else if(sid->conn){
-        ret+=dap_client_remote_write(sid->conn,&pkt_hdr,sizeof(pkt_hdr));
-        ret+=dap_client_remote_write(sid->conn,sid->buf,pkt_hdr.size);
+    else if(a_stream->conn){
+        ret+=dap_client_remote_write(a_stream->conn,&pkt_hdr,sizeof(pkt_hdr));
+        ret+=dap_client_remote_write(a_stream->conn,a_stream->buf,pkt_hdr.size);
     }
-    else if(sid->events_socket) {
-        ret += dap_events_socket_write(sid->events_socket, &pkt_hdr, sizeof(pkt_hdr));
-        ret += dap_events_socket_write(sid->events_socket, sid->buf, pkt_hdr.size);
+    else if(a_stream->events_socket) {
+        ret += dap_events_socket_write(a_stream->events_socket, &pkt_hdr, sizeof(pkt_hdr));
+        ret += dap_events_socket_write(a_stream->events_socket, a_stream->buf, pkt_hdr.size);
         }
     return ret;
 }
 
-
-extern void dap_stream_send_keepalive(struct dap_stream * sid)
+/**
+ * @brief dap_stream_send_keepalive
+ * @param a_stream
+ */
+void dap_stream_send_keepalive(dap_stream_t * a_stream)
 {
-    for(int i=0;i<sid->channel_count;i++)
-    if(sid->channel[i]->proc){
-        if(sid->channel[i]->proc->id == SERVICE_CHANNEL_ID){
-            dap_stream_ch_send_keepalive(sid->channel[i]);
-            dap_stream_ch_set_ready_to_write(sid->channel[i],true);
+    for(size_t i=0;i<a_stream->channel_count;i++)
+        if(a_stream->channel[i]->proc){
+            if(a_stream->channel[i]->proc->id == SERVICE_CHANNEL_ID){
+                dap_stream_ch_send_keepalive(a_stream->channel[i]);
+                dap_stream_ch_set_ready_to_write(a_stream->channel[i],true);
+            }
         }
-    }
 }
 
 

stream/dap_stream_pkt.h

@@ -24,7 +24,7 @@
 
 #define STREAM_PKT_SIZE_MAX 500000
 struct dap_stream;
-
+typedef struct dap_stream dap_stream_t;
 #define STREAM_PKT_TYPE_DATA_PACKET 0x00
 #define STREAM_PKT_TYPE_SERVICE_PACKET 0xff
 //#define STREAM_PKT_TYPE_KEEPALIVE 0x11
@@ -50,14 +50,14 @@ typedef struct stream_srv_pkt{
 } __attribute__((packed)) stream_srv_pkt_t;
 
 
-extern const uint8_t dap_sig[8];
+extern const uint8_t c_dap_stream_sig[8];
 
-dap_stream_pkt_t * dap_stream_pkt_detect(void * data, uint32_t data_size);
+dap_stream_pkt_t * dap_stream_pkt_detect(void * a_data, size_t data_size);
 
-size_t dap_stream_pkt_read(struct dap_stream * sid,struct dap_stream_pkt * pkt, void * buf_out, size_t buf_out_size);
+size_t dap_stream_pkt_read(dap_stream_t * a_stream, dap_stream_pkt_t * a_pkt, void * a_buf_out, size_t a_buf_out_size);
 
-size_t dap_stream_pkt_write(struct dap_stream * sid, const void * data, uint32_t data_size);
+size_t dap_stream_pkt_write(dap_stream_t * a_stream, const void * data, size_t a_data_size);
 
-void dap_stream_send_keepalive(struct dap_stream * sid);
+void dap_stream_send_keepalive( dap_stream_t * a_stream);