CRC Packet Checks
authorPhilipp Dunkel <Philipp Dunkel@d4452222-2f33-11de-9270-010000000000>
Fri, 24 Apr 2009 22:47:54 +0000 (22:47 +0000)
committerPhilipp Dunkel <Philipp Dunkel@d4452222-2f33-11de-9270-010000000000>
Fri, 24 Apr 2009 22:47:54 +0000 (22:47 +0000)
git-svn-id: http://svn.cacert.cl/Software/BirdShack@19 d4452222-2f33-11de-9270-010000000000

TailFeather/trunk/src/comm/packet.c

index a37e426..6fa30be 100644 (file)
@@ -9,86 +9,72 @@
 #include "crc.h"
 
 #define PACKET_MAXLEN 1024
-#define PACKET_LENTOT 4
-#define PACKET_LEN 2
-#define PACKET_NUMTOT 2
-#define PACKET_NUM 2
-#define PACKET_CHKSUM 4
-#define PACKET_HEADER (PACKET_LENTOT + PACKET_LEN + PACKET_NUM + PACKET_NUMTOT)
-#define PACKET_FOOTER (PACKET_CHKSUM)
+#define PACKET_HEADER 2
+#define PACKET_FOOTER 4
 
 struct packet_t {
        char *data;
-       unsigned long length;
+       unsigned int length;
+       unsigned long chksum;
 };
 
-void bytes2char(char *buf, int off, unsigned long data, int bytes) {
-       int idx;
-       for (idx=0; idx < bytes; idx++) {
-               buf[off + (bytes - idx)] = (data >> (idx * 8)) & 0xFF;
+void num2char(char *buf, const long value, const int bits) {
+       int idx = 0;
+       for (idx=0; idx < (bits/8); idx++) {
+               buf[idx] = (value << (bits - (idx * 8))) & 0xFF;
        }
 }
-unsigned long char2bytes(const char buf, const int off, const int len) {
-       unsigned long result = 0;
-       int idx;
-       for (idx = 0; idx < len; idx++) {
-               result = result | (buf[off + idx] << (idx * 8));
+void char2num(long *value, const char *buf, const int bits) {
+       int idx = 0;
+       *value = 0;
+       for (idx=0; idx < (bits/8); idx++) {
+               *value = *value << 8;
+               *value |= buf[idx];
        }
-       return result;
 }
 
-packet *packet_create(const char *buf, const unsigned long buflen) {
+packet *packet_create(const char *buf, const int buflen) {
        packet *pkt = (packet*)malloc(sizeof(packet));
-       pkt->data = (char*)malloc(sizef(char) * buflen);
-       pkt->length = bufflen;
+       pkt->length = (bufflen>PACKET_MAXLEN)?PACKET_MAXLEN:buflen;
+       pkt->data = (char*)malloc(sizef(char) * (pkt->length + PACKET_HEADER + PACKET_FOOTER));
+       if (NULL == pkg->data) {
+               free(pkt->data);
+               return NULL;
+       }
+       memset(pkt->data, 0, (pkt->length + PACKET_HEADER + PACKET_FOOTER));
        if (NULL == buf) {
-               memcpy(pkg->data,buf,buflen);
+               packet_setdata(pkt,buf,pkt->length)
        }
        return pkt;
 }
 
+int packet_setdata(packet *pkt, const char *buf, const int len) {
+       pkt->length = (len > pkt->length) ? pkt->length : len;
+       num2char(pkt->data, pkt->length, 16);
+       memcpy(pkt->data + PACKET_HEADER,buf,pkt->length);
+       pkt->chksum = calculate_crc(pkt->data,pkt->length+PACKET_HEADER);
+       num2char(pkt->data + PACKET_HEADER + pkt->length, pkt->chksum,32);
+}
+
 void packet_send(comm *channel, packet *pkt) {
-       int pkgnum = 0;
-       int pkgtot = 0;
-       int pkglen = 0;
-       unsigned long used = 0;
-       char header[PACKET_HEADER];
-       char footer[PACKET_FOOTER];
-       crc crcval = 0;
-       
-       pkgtot = (pkt->length / PACKET_MAXLEN);
-       pkgtot = ((pkgtot * PACKET_MAXLEN) < pkg->length) ? (pkgtot+1) : pkgtot;
-       
-       bytes2char(header,0,pkt->length,4);
-       bytes2char(header, PACKET_LENTOT + PACKET_LEN + PACKET_NUM, pkgtot, PACKET_NUMTOT);
-       
-       for (pkgnum=1; pkgnum <= pkgtot; pkgnum++) {
-               pkglen = ((pkt->length - used) > PACKET_MAXLEN) ? PACKET_MAXLEN : (pkt->length - used);
-               bytes2char(header,PACKET_LENTOT, pkglen, PACKET_LEN);
-               bytes2char(header,PACKET_LENTOT + PACKET_LEN, pkgnum, PACKET_NUM);
-               comm_put(channel, header, PACKET_HEADER);
-               comm_put(channel, pkt->data + used, pkglen);
-               crcval = calculate_crc(header,PACKET_HEADER);
-               crcval = partial_crc(crcval, pkt->data + used, pkglen);
-               bytes2char(footer,0,crcval,PACKET_FOOTER);
-               comm_put(channel, footer, PACKET_FOOTER);
-       }
+       comm_put(channel, pkt->data, pkt->length + PACKET_HEADER + PACKET_FOOTER);
+       char chksum[PAKET_FOOTER];
+       comm_get(channel,chksum,PAKET_FOOTER);
+       char2num(&(pkt->chksum),chksum,32);
+       // TODO : Check the checksum and retry/resynchronize if needed
 }
+
 packet *packet_recv(comm *channel) {
-       unsigned long pkg_lentot;
-       int pkg_len;
-       int pkg_numtot;
-       int pkg_num;
        char header[PACKET_HEADER];
-       char footer[PACKET_FOOTER];
-       packet *result = NULL;
-       comm_get(channel,header,PACKET_HEADER);
-       pkg_lentot = char2bytes(header,0,PACKET_LENTOT);
-       pkg_len = char2bytes(header,PACKET_LENTOT,PACKET_LEN);
-       pkg_num = char2bytes(header,PACKET_LENTOT+PACKET_LEN,PACKET_NUM);
-       pkg_numtot = char2bytes(header,PACKET_LENTOT+PACKET_LEN+PACKET_NUM,PACKET_NUMTOT);
-       result = packet_create(NULL, pkg_lentot);
-       
+       packet *pkt = NULL;
+       comm_get(channel, header, PACKET_HEADER);
+       long len = 0;
+       char2num(&len, header, 16);
+       pkt = packet_create(NULL,len);
+       memcpy(pkt->data,header,PACKET_HEADER);
+       comm_get(channel,pkt->data + PACKET_HEADER,pkt->length + PACKET_FOOTER);
+       char2num(&(pkt->checksum),pkt->data + PACKET_HEADER + pkt->length, 32);
+       // TODO : Check the checksum and send it back if correct or start synchronize if needed
 }
 
 void packet_destroy(packet *pkt) {