rawsock.c

// Rawsock library, licensed under GPLv2
// Version 0.3.4
#include "rawsock.h"
#include <stdio.h>
#include <stdlib.h>
#include <ifaddrs.h>
#include <string.h>
#include <unistd.h>
#include <linux/wireless.h>
#include <linux/ethtool.h>
#include <linux/sockios.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <arpa/inet.h>
#include "ipcsum_alth.h"
#include "minirighi_udp_checksum.h"

static uint64_t swap64(uint64_t unsignedvalue, uint32_t (*swap_byte_order)(uint32_t)) {
    #if __BYTE_ORDER == __BIG_ENDIAN
    return hostu64;
    #elif __BYTE_ORDER == __LITTLE_ENDIAN
    uint32_t low;
    uint32_t high;
    high=(uint32_t) (unsignedvalue>>32);
    low=(uint32_t) (unsignedvalue & ((1ULL << 32) - 1));
    return ((uint64_t) swap_byte_order(low))<<32 | ((uint64_t) swap_byte_order(high));
    #else
    #error "The system seems to be neither little endian nor big endian..." 
    #endif
}

static uint8_t is_if_tun(int sFd,char *devname) {
    struct ethtool_drvinfo drvinfo;
    struct ifreq ethtool_ifr;

    drvinfo.cmd=ETHTOOL_GDRVINFO;
    strncpy(ethtool_ifr.ifr_name,devname,IFNAMSIZ);
    ethtool_ifr.ifr_data=(void *)&drvinfo;

    return ioctl(sFd,SIOCETHTOOL,&ethtool_ifr)!=-1 && strncmp(drvinfo.bus_info,"tun",ETHTOOL_BUSINFO_LEN)==0;
}

macaddr_t prepareMacAddrT() {
    macaddr_t mac;
    int i;

    mac=malloc(MAC_ADDR_SIZE*sizeof(uint8_t));

    if(mac) {
        for(i=0;i<MAC_ADDR_SIZE;i++) {
            mac[i]=0xFF;
        }
    }

    return mac;
}

void freeMacAddrT(macaddr_t mac) {
    free(mac);
}

unsigned int macAddrTypeGet(macaddr_t mac) {
    if(mac!=NULL) {
        if(mac[0]==0x01) {
            return MAC_MULTICAST;
        } else if(mac[0]==0xFF && mac[1]==0xFF && mac[2]==0xFF && mac[3]==0xFF && mac[4]==0xFF && mac[5]==0xFF) {
            return MAC_BROADCAST;
        } else if(mac[0]==0x00 && mac[1]==0x00 && mac[2]==0x00 && mac[3]==0x00 && mac[4]==0x00 && mac[5]==0x00) {
            return MAC_ZERO;
        } else {
            return MAC_UNICAST;
        }
    } else {
        return MAC_NULL;
    }
}

rawsockerr_t wlanLookup(char *devname, int *ifindex, macaddr_t mac, struct in_addr *srcIP, int index, int mode) {
    // Variables for wlan interfaces detection
    int sFd=-1;
    // struct ifaddrs used to look for available interfaces and bind to a wireless interface
    struct ifaddrs *ifaddr_head, *ifaddr_it;
    // struct ifreq to check whether an interface is wireless or not. The ifr_name field is used to specify which device to affect.
    struct ifreq wifireq;
    // Pointers to manage the list containing all valid wireless interfaces
    struct iflist *iflist_head=NULL; // Head
    struct iflist *curr_ptr=NULL; // Current element
    struct iflist *iflist_it=NULL; // To iterate the list
    struct iflist *iflist_u=NULL; // To free the list
    int ifno=0;
    int ioctl_result=0; // Result of the call to ioctl(sFd,SIOCGIWNAME,&wifireq)
    int return_value=1; // Return value: >0 ok - # of found interfaces, <=0 error 
                                 // (=0 for no WLAN interfaces, =-1 for socket error, =-2 for getifaddrs error)
                                 // (=-3 for wrong index, =-4 unable to get MAC address, =-5 unable to get ifindex)

    // Linked list nodes to store the WLAN interfaces
    struct iflist {
        struct iflist *next;
        struct ifaddrs *ifaddr_ptr;
    };

    // Open socket (needed)
    sFd=socket(AF_INET,SOCK_DGRAM,0); // Any socket should be fine (to be better investigated!)
    if(sFd==-1) {
        return_value=ERR_WLAN_SOCK;
        goto sock_error_occurred;
    }

    // Getting all interface addresses
    if(getifaddrs(&ifaddr_head)==-1) {
        return_value=ERR_WLAN_GETIFADDRS;
        goto getifaddrs_error_occurred;
    }

    // Looking for wlan interfaces
    memset(&wifireq,0,sizeof(wifireq));
    // Iterating over the interfaces linked list
    for(ifaddr_it=ifaddr_head;ifaddr_it!=NULL;ifaddr_it=ifaddr_it->ifa_next) {
        if(index==-1 && ifaddr_it->ifa_addr!=NULL && (ifaddr_it->ifa_flags & IFF_LOOPBACK)) {
            // This is the first loopback interface
            strncpy(devname,ifaddr_it->ifa_name,IFNAMSIZ);

            // One loopback interface is returned
            return_value=1;

            break;
        } else {
            if(ifaddr_it->ifa_addr!=NULL && (ifaddr_it->ifa_addr->sa_family == AF_PACKET || (ifaddr_it->ifa_addr->sa_family == AF_INET && is_if_tun(sFd,ifaddr_it->ifa_name)))) {
                // fprintf(stdout,"Checking interface %s for use.\n",ifaddr_it->ifa_name);
                // IFNAMSIZ is defined by system libraries and it "defines the maximum buffer size needed to hold an interface name, 
                //  including its terminating zero byte"
                // This is done because (from man7.org) "normally, the user specifies which device to affect by setting
                //  ifr_name to the name of the interface"
                strncpy(wifireq.ifr_name,ifaddr_it->ifa_name,IFNAMSIZ);

                // Trying to get the Wireless Extensions (a socket descriptor must be specified to ioctl())
                ioctl_result=ioctl(sFd,SIOCGIWNAME,&wifireq);

                // Current interface should be considered
                if((ioctl_result!=-1 && mode==WLANLOOKUP_WLAN) || (ioctl_result==-1 && mode==WLANLOOKUP_NONWLAN)) {
                    if(ifaddr_it->ifa_addr!=NULL && (ifaddr_it->ifa_flags & IFF_UP) && !(ifaddr_it->ifa_flags & IFF_LOOPBACK)) {
                        // If the interface is up, add it to the head of the "iflist" (it is not added to the tail in order to
                        //  avoid defining an extra pointer)
                        ifno++;
                        curr_ptr=malloc(sizeof(struct iflist));
                        curr_ptr->ifaddr_ptr=ifaddr_it;
                        if(iflist_head==NULL) {
                            iflist_head=curr_ptr;
                            iflist_head->next=NULL;
                        } else {
                            curr_ptr->next=iflist_head;
                            iflist_head=curr_ptr;
                        }
                    }
                }
            }
        }
    }

    // Scan the list of returned interfaces only if lookback was not specified
    if(index!=-1) {
        // No wireless interfaces found (the list is empty)
        if(iflist_head==NULL) {
            return_value=0;
            goto error_occurred;
        } else if(ifno==1) {
            // Only one wireless interface found
            if(index>=1) {
                return_value=ERR_WLAN_INDEX;
                goto error_occurred;
            }
            strncpy(devname,iflist_head->ifaddr_ptr->ifa_name,IFNAMSIZ);
        } else {
            // Multiple interfaces found -> use the value of 'index'
            if(index>=ifno) {
                return_value=ERR_WLAN_INDEX;
                goto error_occurred;
            }
            return_value=ifno; // Return the number of interfaces found
            // Iterate the list until the chosen interface is reached
            iflist_it=iflist_head;
            while(index<=ifno-2) {
                iflist_it=iflist_it->next;
                index++;
            }
            strncpy(devname,iflist_it->ifaddr_ptr->ifa_name,IFNAMSIZ);
        }
    }

    // Get MAC address of the interface (if requested by the user with a non-NULL mac)
    if(mac!=NULL) {
        strncpy(wifireq.ifr_name,devname,IFNAMSIZ); 
        if(ioctl(sFd,SIOCGIFHWADDR,&wifireq)!=-1) {
            memcpy(mac,wifireq.ifr_hwaddr.sa_data,MAC_ADDR_SIZE);
        } else {
            return_value=ERR_WLAN_GETSRCMAC;
            goto error_occurred;
        }
    }

    // Get interface index of the interface (if requested by the user with a non-NULL ifindex)
    if(ifindex!=NULL) {
        strncpy(wifireq.ifr_name,devname,IFNAMSIZ);
        if(ioctl(sFd,SIOCGIFINDEX,&wifireq)!=-1) {
            *ifindex=wifireq.ifr_ifindex;
        } else {
            return_value=ERR_WLAN_GETIFINDEX;
            goto error_occurred;
        }
    }

    // Get the IP address of the interface (if requested by the user with a non-NULL struct in_addr)
    if(srcIP!=NULL) {
        strncpy(wifireq.ifr_name,devname,IFNAMSIZ);
        wifireq.ifr_addr.sa_family = AF_INET;
        if(ioctl(sFd,SIOCGIFADDR,&wifireq)!=-1) {
            *srcIP=((struct sockaddr_in*)&wifireq.ifr_addr)->sin_addr;
        } else {
            return_value=ERR_WLAN_GETSRCIP;
            // No need to go to error_occurred, as we are already there
        }
    }

    error_occurred:
    // iflist and the other list are no more useful -> free them
    freeifaddrs(ifaddr_head);
    for(iflist_it=iflist_head;iflist_it!=NULL;iflist_it=iflist_u) {
        iflist_u=iflist_it->next;
        free(iflist_it);
    }

    getifaddrs_error_occurred:
    // Close socket
    close(sFd);

    sock_error_occurred:
    return return_value;
}

rawsockerr_t vifPrinter(FILE *stream) {
    int sFd=-1;
    struct ifaddrs *ifaddr_head, *ifaddr_it;
    struct ifreq wifireq;
    int wlan_ifno=0;
    int nonwlan_ifno=0;

    // Open socket (needed)
    sFd=socket(AF_INET,SOCK_DGRAM,0); // Any socket should be fine (to be better investigated!)
    if(sFd==-1) {
        return ERR_VIFPRINTER_SOCK;
    }

    // Getting all interface addresses
    if(getifaddrs(&ifaddr_head)==-1) {
        close(sFd);
        return ERR_VIFPRINTER_GETIFADDRS;
    }

    fprintf(stream,"Interface name   | Interface type | Interface internal index\n"
         "--------------   | -------------- | ------------------------\n");

    // Looking for wlan interfaces
    memset(&wifireq,0,sizeof(wifireq));
    // Iterating over the interfaces linked list
    for(ifaddr_it=ifaddr_head;ifaddr_it!=NULL;ifaddr_it=ifaddr_it->ifa_next) {
        if(ifaddr_it->ifa_addr!=NULL && (ifaddr_it->ifa_flags & IFF_LOOPBACK) && ifaddr_it->ifa_addr->sa_family==AF_PACKET) {
            fprintf(stream,"%s\t\t | %-14s | %s\t\n",ifaddr_it->ifa_name,"Loopback","(lo)");
        } else {
            if(ifaddr_it->ifa_addr!=NULL && ifaddr_it->ifa_addr->sa_family==AF_PACKET) {
                strncpy(wifireq.ifr_name,ifaddr_it->ifa_name,IFNAMSIZ); 
                if(ioctl(sFd,SIOCGIWNAME,&wifireq)!=-1) {
                    if(ioctl(sFd,SIOCGIFFLAGS,&wifireq)!=-1 && (wifireq.ifr_flags & IFF_UP)) {
                        // If the interface is up, print the information related to such interface
                        fprintf(stream,"%-*s | %-14s | (wlan) %d\t\n",IFNAMSIZ,ifaddr_it->ifa_name,"Wireless",wlan_ifno);
                        wlan_ifno++;
                    }
                } else {
                    // Interface is not wireless
                    if(ifaddr_it->ifa_addr!=NULL && (ifaddr_it->ifa_flags & IFF_UP)) {
                        fprintf(stream,"%-*s | %-14s | (non-wlan) %d\t\n",IFNAMSIZ,ifaddr_it->ifa_name,"Non-wireless",nonwlan_ifno);
                        nonwlan_ifno++;
                    }
                }
            } else if(ifaddr_it->ifa_addr!=NULL && ifaddr_it->ifa_addr->sa_family==AF_INET && is_if_tun(sFd,ifaddr_it->ifa_name)) {
                fprintf(stream,"%-*s | %-14s | (non-wlan) %d\t\n",IFNAMSIZ,ifaddr_it->ifa_name,"tun (AF_INET)",nonwlan_ifno);
                nonwlan_ifno++;
            }
        }
    }

    return 1;
}

void rs_printerror(FILE *stream,rawsockerr_t code) {
    switch(code) {
        case ERR_WLAN_NOIF:
            fprintf(stream,"wlanLookup: No interfaces found.\n");
        break;

        case ERR_WLAN_SOCK:
            fprintf(stream,"wlanLookup: socket creation error.\n");
        break;

        case ERR_WLAN_GETIFADDRS:
            fprintf(stream,"wlanLookup: getifaddrs() error.\n");
        break;

        case ERR_WLAN_INDEX:
            fprintf(stream,"wlanLookup: wrong index specified.\n");
        break;

        case ERR_WLAN_GETSRCMAC:
            fprintf(stream,"wlanLookup: unable to get source MAC address.\n");
        break;

        case ERR_WLAN_GETIFINDEX:
            fprintf(stream,"wlanLookup: unable to get interface index.\n");
        break;

        case ERR_WLAN_GETSRCIP:
            fprintf(stream,"wlanLookup: unable to get source IP address.\n");
        break;

        case ERR_IPHEAD_SOCK:
            fprintf(stream,"IP4headPopulateB: socket creation error.\n");
        break;

        case ERR_IPHEAD_NOSRCADDR:
            fprintf(stream,"IP4headPopulateB: unable to retrieve source IP address.\n");
        break;

        default:
            fprintf(stream,"No error.\n");
    }
}

void display_packet(const char *text,byte_t *packet,unsigned int len) {
    int i;

    fprintf(stdout,"%s -> ",text);
    for(i=0;i<len;i++) {
        fprintf(stdout,"%02x ",packet[i]);
    }
    fprintf(stdout,"\n");
    fflush(stdout);
}

void display_packetc(const char *text,byte_t *packet,unsigned int len) {
    int i;

    fprintf(stdout,"%s -> ",text);
    for(i=0;i<len;i++) {
        fprintf(stdout,"%c",packet[i]);
    }
    fprintf(stdout,"\n");
    fflush(stdout);
}

uint64_t hton64 (uint64_t hostu64) {
    return swap64(hostu64,&htonl);
}

uint64_t ntoh64 (uint64_t netu64) {
    return swap64(netu64,&ntohl);
}

void etherheadPopulateB(struct ether_header *etherHeader, macaddr_t mac, ethertype_t type) {
    unsigned char broadcastMAC[ETHER_ADDR_LEN]={0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};

    memcpy(etherHeader->ether_dhost,broadcastMAC,ETHER_ADDR_LEN);
    memcpy(etherHeader->ether_shost,mac,ETHER_ADDR_LEN);
    etherHeader->ether_type = htons(type);
}

void etherheadPopulate(struct ether_header *etherHeader, macaddr_t macsrc, macaddr_t macdst, ethertype_t type) {
    memcpy(etherHeader->ether_dhost,macdst,ETHER_ADDR_LEN);
    memcpy(etherHeader->ether_shost,macsrc,ETHER_ADDR_LEN);
    etherHeader->ether_type = htons(type);
}

size_t etherEncapsulate(byte_t *packet,struct ether_header *header,byte_t *sdu,size_t sdusize) {
    size_t packetsize=sizeof(struct ether_header)+sdusize;

    memcpy(packet,header,sizeof(struct ether_header));
    memcpy(packet+sizeof(struct ether_header),sdu,sdusize);

    return packetsize;
}

void getSrcMAC(struct ether_header *etherHeader, macaddr_t macsrc) {
    if(macsrc) {
        memcpy(macsrc,etherHeader->ether_shost,ETHER_ADDR_LEN);
    }
}

rawsockerr_t IP4headPopulate(struct iphdr *IPhead, char *devname, char *destIP, unsigned char tos,unsigned short frag_offset, unsigned char ttl, unsigned char protocol,unsigned int flags,struct ipaddrs *addrs) {
    struct in_addr destIPAddr;
    int sFd; // To get the current IP address
    struct ifreq wifireq;

    IPhead->ihl=BASIC_IHL;
    IPhead->version=IPV4;
    IPhead->tos=(__u8) tos;
    IPhead->frag_off=htons(frag_offset);
    IPhead->frag_off=(IPhead->frag_off) | flags;
    IPhead->ttl=(__u8) ttl;
    IPhead->protocol=(__u8) protocol;
    inet_pton(AF_INET,destIP,(struct in_addr *)&destIPAddr);
    IPhead->daddr=destIPAddr.s_addr;

    // Get own IP address
    sFd=socket(AF_INET,SOCK_DGRAM,0);
    if(sFd==-1) {
        return ERR_IPHEAD_SOCK;
    }
    strncpy(wifireq.ifr_name,devname,IFNAMSIZ);
    wifireq.ifr_addr.sa_family = AF_INET;
    if(ioctl(sFd,SIOCGIFADDR,&wifireq)!=0) {
        close(sFd);
        return ERR_IPHEAD_NOSRCADDR;
    }
    close(sFd);
    IPhead->saddr=((struct sockaddr_in*)&wifireq.ifr_addr)->sin_addr.s_addr;
    if(addrs!=NULL) {
        addrs->src=IPhead->saddr;
        addrs->dst=IPhead->daddr;
    }

    // Initialize checksum to 0
    IPhead->check=0;

    // Initialize ID to 0
    IPhead->id=0;

    return 0;
}

rawsockerr_t IP4headPopulateS(struct iphdr *IPhead, char *devname, struct in_addr destIP, unsigned char tos,unsigned short frag_offset, unsigned char ttl, unsigned char protocol,unsigned int flags,struct ipaddrs *addrs) {
    int sFd; // To get the current IP address
    struct ifreq wifireq;

    IPhead->ihl=BASIC_IHL;
    IPhead->version=IPV4;
    IPhead->tos=(__u8) tos;
    IPhead->frag_off=htons(frag_offset);
    IPhead->frag_off=(IPhead->frag_off) | flags;
    IPhead->ttl=(__u8) ttl;
    IPhead->protocol=(__u8) protocol;
    IPhead->daddr=destIP.s_addr;

    // Get own IP address
    sFd=socket(AF_INET,SOCK_DGRAM,0);
    if(sFd==-1) {
        return ERR_IPHEAD_SOCK;
    }
    strncpy(wifireq.ifr_name,devname,IFNAMSIZ);
    wifireq.ifr_addr.sa_family = AF_INET;
    if(ioctl(sFd,SIOCGIFADDR,&wifireq)!=0) {
        close(sFd);
        return ERR_IPHEAD_NOSRCADDR;
    }
    close(sFd);
    IPhead->saddr=((struct sockaddr_in*)&wifireq.ifr_addr)->sin_addr.s_addr;
    if(addrs!=NULL) {
        addrs->src=IPhead->saddr;
        addrs->dst=IPhead->daddr;
    }

    // Initialize checksum to 0
    IPhead->check=0;

    // Initialize ID to 0
    IPhead->id=0;

    return 0;
}

rawsockerr_t IP4headPopulateB(struct iphdr *IPhead, char *devname,unsigned char tos,unsigned short frag_offset, unsigned char ttl, unsigned char protocol,unsigned int flags,struct ipaddrs *addrs) {
    struct in_addr broadIPAddr;
    int sFd; // To get the current IP address
    struct ifreq wifireq;

    IPhead->ihl=BASIC_IHL;
    IPhead->version=IPV4;
    IPhead->tos=(__u8) tos;
    IPhead->frag_off=htons(frag_offset);
    IPhead->frag_off=(IPhead->frag_off) | flags;
    IPhead->ttl=(__u8) ttl;
    IPhead->protocol=(__u8) protocol;
    inet_pton(AF_INET,"255.255.255.255",(struct in_addr *)&broadIPAddr);
    IPhead->daddr=broadIPAddr.s_addr;

    // Get own IP address
    sFd=socket(AF_INET,SOCK_DGRAM,0);
    if(sFd==-1) {
        return ERR_IPHEAD_SOCK;
    }
    strncpy(wifireq.ifr_name,devname,IFNAMSIZ);
    wifireq.ifr_addr.sa_family = AF_INET;
    if(ioctl(sFd,SIOCGIFADDR,&wifireq)!=0) {
        close(sFd);
        return ERR_IPHEAD_NOSRCADDR;
    }
    close(sFd);
    IPhead->saddr=((struct sockaddr_in*)&wifireq.ifr_addr)->sin_addr.s_addr;
    if(addrs!=NULL) {
        addrs->src=IPhead->saddr;
        addrs->dst=IPhead->daddr;
    }

    // Initialize checksum to 0
    IPhead->check=0;

    // Initialize ID to 0
    IPhead->id=0;

    return 0;
}

void IP4headAddID(struct iphdr *IPhead, unsigned short id) {
    IPhead->id=htons(id);
}

void IP4headAddTotLen(struct iphdr *IPhead, unsigned short len) {
    IPhead->tot_len=htons(len);
}

size_t IP4Encapsulate(byte_t *packet,struct iphdr *header,byte_t *sdu,size_t sdusize) {
    size_t packetsize=sizeof(struct iphdr)+sdusize;

    header->tot_len=htons(packetsize);
    header->check=0; // Reset to 0 in case of subsequent calls

    header->check=ip_fast_csum((__u8 *)header, BASIC_IHL);

    memcpy(packet,header,sizeof(struct iphdr));
    memcpy(packet+sizeof(struct iphdr),sdu,sdusize);

    return packetsize;
}

void UDPheadPopulate(struct udphdr *UDPhead, unsigned short sourceport, unsigned short destport) {
    UDPhead->source=htons(sourceport);
    UDPhead->dest=htons(destport);

    // Initialize checksum to 0
    UDPhead->check=0;
}

size_t UDPencapsulate(byte_t *packet,struct udphdr *header,byte_t *data,size_t payloadsize,struct ipaddrs addrs) {
    size_t packetsize=sizeof(struct udphdr)+payloadsize;

    header->len=htons(packetsize);
    header->check=0; // Reset to 0 in case of subsequent calls

    memcpy(packet,header,sizeof(struct udphdr));
    memcpy(packet+sizeof(struct udphdr),data,payloadsize);

    header->check=minirighi_udp_checksum(packet,packetsize,addrs.src,addrs.dst);

    memcpy(packet,header,sizeof(struct udphdr));

    return packetsize;
}

byte_t *UDPgetpacketpointers(byte_t *pktbuf,struct ether_header **etherHeader, struct iphdr **IPheader,struct udphdr **UDPheader) {
    byte_t *payload=NULL;

    if(pktbuf!=NULL) {
        if(etherHeader) *etherHeader=(struct ether_header*) pktbuf;
        if(IPheader) *IPheader=(struct iphdr*)(pktbuf+sizeof(struct ether_header));
        if(UDPheader) *UDPheader=(struct udphdr*)(pktbuf+sizeof(struct ether_header)+sizeof(struct iphdr));
        payload=(pktbuf+sizeof(struct ether_header)+sizeof(struct iphdr)+sizeof(struct udphdr));
    } else {
        payload=NULL;
    }

    return payload;
}

unsigned short UDPgetpayloadsize(struct udphdr *UDPheader) {
    return (ntohs(UDPheader->len)-UDPHEADERLEN);
}

bool validateEthCsum(byte_t *packet, csum16_t csum, csum16_t *combinedcsum, csumt_t type, void *args) {
    csum16_t currCsum;
    bool returnVal=false;
    void *headerPtr; // Generic header pointer
    void *payloadPtr; // Generic payload/SDU pointer
    size_t packetsize; // Used in UDP checksum calculation
    __sum16 storedCsum; // To store the current value of checksum, read from 'packet'

    // Directly return 'false' (as an error occurred) if a combined type is specified but combinedcsum is NULL
    if(type>=0x80 && combinedcsum==NULL) {
        return false;
    }

    // Discriminate the different protocols
    switch(type) {
        case CSUM_IP:
            headerPtr=(struct iphdr*)(packet+sizeof(struct ether_header));

            // Checksum should start with a value of 0x0000 in order to be correctly computed:
            //  set it to 0 and restore it, to avoid making a copy of the packet in memory
            storedCsum=((struct iphdr *) headerPtr)->check;
            ((struct iphdr *) headerPtr)->check=0;

            currCsum=ip_fast_csum((__u8 *)headerPtr, ((struct iphdr *) headerPtr)->ihl);

            ((struct iphdr *) headerPtr)->check=storedCsum;

            returnVal=(currCsum==csum);
        break;
        case CSUM_UDP:
        case CSUM_UDPIP:
            // payloadsize should be specified, otherwise 'false' will be always returneds
            if(args==NULL) {
                returnVal=false;
            } else {
                // Get packetsize
                packetsize=sizeof(struct udphdr)+*((size_t *) args);

                headerPtr=(struct iphdr*)(packet+sizeof(struct ether_header));
                payloadPtr=(struct udphdr*)(packet+sizeof(struct ether_header)+sizeof(struct iphdr));

                storedCsum=((struct udphdr *) payloadPtr)->check;
                ((struct udphdr *) payloadPtr)->check=0;

                currCsum=minirighi_udp_checksum(payloadPtr,packetsize,((struct iphdr *)headerPtr)->saddr,((struct iphdr *)headerPtr)->daddr);

                ((struct udphdr *) payloadPtr)->check=storedCsum;

                returnVal=(currCsum==csum);

                if(type==CSUM_UDPIP) {
                    if(combinedcsum==NULL) {
                        returnVal=false;
                    } else {
                        // Compute IP checksum
                        storedCsum=((struct iphdr *) headerPtr)->check;
                        ((struct iphdr *) headerPtr)->check=0;

                        currCsum=ip_fast_csum((__u8 *)headerPtr, ((struct iphdr *)headerPtr)->ihl);

                        ((struct iphdr *) headerPtr)->check=storedCsum;

                        returnVal=returnVal && (currCsum==(*combinedcsum));
                    }
                }
            }
        break;
        default:
            returnVal=false;
    }

    return returnVal;
}

void test_injectIPCsumError(byte_t *IPpacket) {
    // Get header pointer
    struct iphdr *IPheader=(struct iphdr *) IPpacket;

    if(IPpacket!=NULL) {
        // Change checksum, avoiding possible overflow situations
        if(IPheader->check!=0xFF) {
            IPheader->check=IPheader->check+1;
        } else {
            IPheader->check=0x00;
        }
    }
}

void test_injectUDPCsumError(byte_t *UDPpacket) {
    // Get header pointer
    struct udphdr *UDPheader=(struct udphdr *) UDPpacket;

    if(UDPheader!=NULL) {
        // Change checksum, avoiding possible overflow situations
        if(UDPheader->check!=0xFF) {
            UDPheader->check=UDPheader->check+1;
        } else {
            UDPheader->check=0x00;
        }
    }
}