[GNUnet-SVN] r10740 - gnunet/src/fragmentation

[gnunet]

Author: jilu
Date: 2010-04-01 16:56:59 +0200 (Thu, 01 Apr 2010)
New Revision: 10740

Modified:
   gnunet/src/fragmentation/fragmentation.c
   gnunet/src/fragmentation/test_frag_ji.c
Log:
to be continued

Modified: gnunet/src/fragmentation/fragmentation.c
===================================================================
--- gnunet/src/fragmentation/fragmentation.c    2010-04-01 11:18:27 UTC (rev 
10739)
+++ gnunet/src/fragmentation/fragmentation.c    2010-04-01 14:56:59 UTC (rev 
10740)
@@ -47,21 +47,22 @@
        /**
         * Fragment offset.
         */
-       uint32_t off GNUNET_PACKED;
+       uint16_t off GNUNET_PACKED;
 
        /**
-        * "unique" id for the fragment
-        */
-       uint64_t id GNUNET_PACKED;
+                        * "unique" id for the fragment
+                        */
+       uint32_t id GNUNET_PACKED;
 
-       size_t mtu;
-       uint32_t totalNum;
-       uint64_t totalSize;
+       uint16_t mtu;
+       uint16_t totalNum;
+       uint16_t totalSize;
+
 };
 
 struct GNUNET_FRAGEMENT_Ctxbuffer{
        struct GNUNET_FRAGEMENT_Ctxbuffer *next;
-       uint64_t id;
+       uint32_t id;
        uint16_t size;
        char * buff;
        int counter;
@@ -99,6 +100,7 @@
 {
        uint32_t id = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
        size_t size = sizeof(struct Fragment);
+
        if(ntohs(msg->size) > mtu-size){
                uint16_t lastSize;
                uint16_t num;
@@ -115,14 +117,14 @@
                        struct Fragment *frag;
                        if(actualNum != num){
                                                        if(i!=actualNum-1){
-                                                               frag = 
GNUNET_malloc(mtu);
+                                                               frag = (struct 
Fragment *)GNUNET_malloc(mtu);
                                                        }
                                                        else{
-                                                           frag = 
GNUNET_malloc(lastSize+size);
+                                                           frag = (struct 
Fragment *)GNUNET_malloc(lastSize+size);
                                                                }
                                                        }
                        else{
-                                       frag = GNUNET_malloc(mtu);
+                                       frag = (struct Fragment 
*)GNUNET_malloc(mtu);
                                }
                        frag->header.type = htons(GNUNET_MESSAGE_TYPE_FRAGMENT);
                        frag->id = htonl(id);
@@ -130,19 +132,20 @@
                        frag->mtu = htons(mtu);
                        frag->totalNum = htons(actualNum);
                        frag->totalSize = msg->size;
+                       char *m =  (char *)msg;
                        if(actualNum != num){
                                if(i!=actualNum-1){
-                                       frag->header.size = htons(mtu);
-                                       memcpy(&frag[1], msg + 
ntohs(frag->off), mtu - size);
+                                       frag->header.size = frag->mtu;
+                                       memcpy(&frag[1], m + (mtu-size)*i, mtu 
- size);
                                }
                                else{
                                        frag->header.size = 
htons(lastSize+size);
-                                       memcpy(&frag[1], msg + 
ntohs(frag->off), lastSize);
+                                       memcpy(&frag[1], m + (mtu-size)*i, 
lastSize);
                                }
                        }
                        else{
-                               frag->header.size = htons(mtu);
-                               memcpy(&frag[1], msg + ntohs(frag->off), mtu - 
size);
+                               frag->header.size = frag->mtu;
+                               memcpy(&frag[1], m + (mtu-size)*i, mtu - size);
                        }
                        proc(proc_cls, &frag->header);
                        GNUNET_free(frag);
@@ -234,7 +237,7 @@
        }
 
        if(!exist){
-               buffer = GNUNET_malloc(sizeof(struct 
GNUNET_FRAGEMENT_Ctxbuffer));
+               buffer = (struct 
GNUNET_FRAGEMENT_Ctxbuffer*)GNUNET_malloc(sizeof(struct 
GNUNET_FRAGEMENT_Ctxbuffer));
                buffer->num = 
(int*)GNUNET_malloc(ntohs(frag->totalNum)*sizeof(int));
                int j;
                for(j = 0; j<ntohs(frag->totalNum); j++){
@@ -243,9 +246,9 @@
                buffer->peerID = sender;
                buffer->id = ntohl(frag->id);
                buffer->receivedTime = GNUNET_TIME_absolute_get ();
-               uint64_t si = ntohs(frag->totalSize);
+               uint16_t si = ntohs(frag->totalSize);
                buffer->size = si;
-               buffer->buff = (char *)GNUNET_malloc(si);
+               buffer->buff = (char*)GNUNET_malloc(si);
                buffer->next = ctx->buffer;
                ctx->buffer = buffer;
        }

Modified: gnunet/src/fragmentation/test_frag_ji.c
===================================================================
--- gnunet/src/fragmentation/test_frag_ji.c     2010-04-01 11:18:27 UTC (rev 
10739)
+++ gnunet/src/fragmentation/test_frag_ji.c     2010-04-01 14:56:59 UTC (rev 
10740)
@@ -18,9 +18,12 @@
        if(ntohs(originalMsg->type) != ntohs(msg->type)){
                        fprintf(stderr, "the received message has the different 
type with the sent one!\n");
                }
-       if(memcmp(msg+960, originalMsg+960, 68)){
+       if(memcmp(msg, originalMsg, originalMsg->size)){
                        fprintf(stderr, "the received message is not the sent 
one!\n");
        }
+       else{
+               fprintf(stdout, "You got the right message!\n");
+       }
 
 }
 
@@ -28,25 +31,27 @@
        printf("enter into message_proc2\n");
        struct combine * com2 = (struct combine* )cls;
        GNUNET_FRAGMENT_process(com2->ctx, com2->sender, msg);
+
 }
 
 int
 main(int argc, char * argv[]){
        
-       uint16_t mtu = 512;
+       uint32_t mtu = 512;
        struct GNUNET_FRAGMENT_Context * ctx;
-       struct GNUNET_MessageHeader *msg = GNUNET_malloc(sizeof(struct 
GNUNET_MessageHeader)+2*mtu);
+       struct GNUNET_MessageHeader *msg = (struct GNUNET_MessageHeader 
*)GNUNET_malloc(sizeof(struct GNUNET_MessageHeader)+2*mtu);
        ctx = GNUNET_FRAGMENT_context_create(NULL, message_proc1, msg);
        msg->size = htons(sizeof(struct GNUNET_MessageHeader)+2*mtu);
        msg->type = htons(GNUNET_MESSAGE_TYPE_HELLO);
        struct GNUNET_PeerIdentity *sender;
-       sender = GNUNET_malloc(sizeof(struct GNUNET_PeerIdentity));
+       sender = (struct GNUNET_PeerIdentity *)GNUNET_malloc(sizeof(struct 
GNUNET_PeerIdentity));
 
        memset(sender, 9, sizeof(struct GNUNET_PeerIdentity));
 
        memset(&msg[1], 5, 2*mtu);
+
        struct combine *com;
-       com = GNUNET_malloc(sizeof(struct combine));
+       com = (struct combine *)GNUNET_malloc(sizeof(struct combine));
        com->ctx = ctx;
        com->sender = sender;
        GNUNET_FRAGMENT_fragment(msg, mtu, message_proc2, com);