Question #266555 on rohc changed:
https://answers.launchpad.net/rohc/+question/266555

    Status: Needs information => Open

Ashok Kumar gave more information on the question:
Hi Didier,
                  The following is the figure showing the test scenario,


               ............        ping 192.168.0.30        ............        
  Wired connection          ............                                        
      ............      
        |  Host M/C-1  |  ---------------------->  |  Linux/ARM  |      
<----------------->     |  Linux/ARM  |   ------------------->  |Host M/C-2|   
               ............            Ethernet                     
............                                                    ............    
              Ethernet             ............       
         172.16.0.25                          Application instance 1            
          Application instance 2                             192.168.0.30
                                                                        running 
on                                          running on
                                                                  Target 
platform 1                              Target platform 2

Here I am trying to send ICMP/IP packet from Host M/C-1 to Host M/C-2
using ping. These host machines are connected to target platform
through Ethernet.Application instance are running on the target
platform. A wired connection exist between these platforms making end-
to-end connection between the host machines possible. I used the
following APIs of your library ROHC-1.7.0 in my source code:

1.COMPRESSOR

                compressor = rohc_comp_new2(ROHC_SMALL_CID, ROHC_SMALL_CID_MAX, 
gen_random_num, NULL);
                if(compressor == NULL)
                {
                        rohc_comp_free(compressor);
                }

                if(!rohc_comp_set_traces_cb2(compressor, 
print_rohc_traces,NULL))
                {
                        printf("CE: Failed to set the callback for traces on 
compressor\n");
                        rohc_comp_free(compressor);
                }

                if(!rohc_comp_enable_profiles(compressor, 
ROHC_PROFILE_UNCOMPRESSED, ROHC_PROFILE_UDP, ROHC_PROFILE_IP, ROHC_PROFILE_TCP, 
-1))
                {
                        rohc_comp_free(compressor);
                }

               struct rohc_buf rohcBuf_IpPacket = 
rohc_buf_init_full(&luchar_Buffer[sizeof(IP_Packet)], 
((IP_Packet*)luchar_Buffer)->int_data_size, 0);
               unsigned char rohc_Combuffer[BUFFER_SIZE];
               struct rohc_buf rohc_Compacket = 
rohc_buf_init_empty(rohc_Combuffer, BUFFER_SIZE);
               luchar_RohcComStatus = rohc_compress4(compressor, 
rohcBuf_IpPacket, &rohc_Compacket);
               if(luchar_RohcComStatus!= ROHC_STATUS_OK)
               {
                         rohc_comp_free(compressor);
               }

2.DE-COMPRESSOR

           decompressor=rohc_decomp_new2(ROHC_SMALL_CID, ROHC_SMALL_CID_MAX, 
ROHC_U_MODE);
            if(decompressor == NULL)
            {
                    rohc_decomp_free(decompressor);
            }

            if(!rohc_decomp_set_traces_cb2(decompressor,print_rohc_traces,NULL))
            {
                    rohc_decomp_free(decompressor);
            }
            if(!rohc_decomp_enable_profiles(decompressor, 
ROHC_PROFILE_UNCOMPRESSED, ROHC_PROFILE_UDP, ROHC_PROFILE_IP, ROHC_PROFILE_TCP, 
-1))
            {
                    rohc_decomp_free(decompressor);
            }
            struct rohc_buf rohc_packet = 
rohc_buf_init_full(&luchar_Buffer[sizeof(LLCDataInd)+sizeof(CL_D_pdu)],      
((LLCDataInd*) luchar_Buffer)->uint16_Size - sizeof(CL_D_pdu), 0);
             unsigned char rohc_Decombuffer[BUFFER_SIZE];
             struct rohc_buf rohc_Decompacket = 
rohc_buf_init_empty(rohc_Decombuffer, BUFFER_SIZE);
             luchar_RohcDecStatus = rohc_decompress3(decompressor, rohc_packet, 
&rohc_Decompacket,
rcvd_feedback, feedback_send);
             if(luchar_RohcDecStatus !=  ROHC_STATUS_OK)
             {
                   rohc_decomp_free(decompressor);
            }
                    
I had captured these ICMP/IP packets sent from M/C-1 to Target Platform-1 using 
Wireshark and observed that the checksum field of these IP packet headers are 
found to be correct and containing a value. This indicates there is no checksum 
offloading. The IP packets received in the target platfrom-1 running the 
application is not compressing these IP packets saying checksum incorrect in 
the debug prints but there seems to be no checksum error as per wireshark log. 
Then the application chooses Uncompressed profile and sends the packets 
uncompressed to Target Platform-2. Application running on the platform-2 
receives this Uncompressed profiled packet and sends to M/C-2 via Ethernet. 
M/C-2 captured these received packets using Wireshark, its checksum field is 
also found to be correct.So, the thing is that actual ICMP packets does not 
seems to contain checksum error but the application is treating them as error. 
Wireshark logs are with me, if u want to have a look I can attach. Please, hel
 p me to sort out this issue. Thanks in advance....

-- 
You received this question notification because you are a member of ROHC
Team, which is an answer contact for rohc.

_______________________________________________
Mailing list: https://launchpad.net/~rohc
Post to     : [email protected]
Unsubscribe : https://launchpad.net/~rohc
More help   : https://help.launchpad.net/ListHelp

Reply via email to