iputil.c

Go to the documentation of this file.

/*
Copyright (C) 2012  Gregory Nietsky <gregory@distrotetch.co.za>
        http://www.distrotech.co.za

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#include <stdio.h>
#include <string.h>
#ifndef __WIN32
#include <linux/ip.h>
#include <linux/icmp.h>
#include <linux/tcp.h>
#include <linux/udp.h>
#include <netdb.h>
#else
#include <winsock2.h>
#include <ws2tcpip.h>
#endif

#include "include/dtsapp.h"

extern int checkipv6mask(const char *ipaddr, const char *network, uint8_t bits) {
    uint8_t cnt, bytelen, bitlen;
    uint32_t mask, res = 0;
    uint32_t *nw = (uint32_t *)network;
    uint32_t *ip = (uint32_t *)ipaddr;

    /*calculate significant bytes and bits outside boundry*/
    if ((bitlen = bits % 32)) {
        bytelen = (bits - bitlen) / 32;
        bytelen++;
    } else {
        bytelen = bits / 32;
    }

    /*end loop on first mismatch do not check last block*/
    for(cnt = 0; (!res && (cnt < (bytelen - 1))); cnt++) {
        res += nw[cnt] ^ ip[cnt];
    }

    /*process last block if no error sofar*/
    if (!res) {
        mask = (bitlen) ? htonl(~((1 << (32 - bitlen)) - 1)) : -1;
        res += (nw[cnt] & mask) ^ (ip[cnt] & mask);
    }

    return (res);
}

enum ipversion {
    IP_PROTO_V4 = 4,
    IP_PROTO_V6 = 6
};

struct pseudohdr {
    uint32_t saddr;
    uint32_t daddr;
    uint8_t zero;
    uint8_t proto;
    uint16_t len;
};

#ifndef __WIN32

extern void ipv4tcpchecksum(uint8_t *pkt) {
    struct iphdr *ip = (struct iphdr *)pkt;
    struct tcphdr *tcp = (struct tcphdr *)(pkt + (4 * ip->ihl));
    uint16_t plen, csum;
    struct pseudohdr phdr;

    /* get tcp packet len*/
    plen = ntohs(ip->tot_len) - (4 * ip->ihl);
    tcp->check = 0;
    phdr.saddr = ip->saddr;
    phdr.daddr = ip->daddr;
    phdr.zero = 0;
    phdr.proto = ip->protocol;
    phdr.len = htons(plen);
    csum = checksum(&phdr, sizeof(phdr));
    tcp->check = checksum_add(csum, tcp, plen);
}

extern void ipv4udpchecksum(uint8_t *pkt) {
    struct iphdr *ip = (struct iphdr *)pkt;
    struct udphdr *udp = (struct udphdr *)(pkt + (4 * ip->ihl));
    uint16_t csum, plen;
    struct pseudohdr phdr;

    /* get tcp packet len*/
    plen = ntohs(ip->tot_len) - (4 * ip->ihl);
    udp->check = 0;
    phdr.saddr = ip->saddr;
    phdr.daddr = ip->daddr;
    phdr.zero = 0;
    phdr.proto = ip->protocol;
    phdr.len = htons(plen);
    csum = checksum(&phdr, sizeof(phdr));
    udp->check = checksum_add(csum, udp, plen);
}

extern void ipv4icmpchecksum(uint8_t *pkt) {
    struct iphdr *ip = (struct iphdr *)pkt;
    struct icmphdr *icmp = (struct icmphdr *)(pkt + (4 * ip->ihl));

    icmp->checksum = 0;
    icmp->checksum = checksum(icmp, ntohs(ip->tot_len) - (ip->ihl *4));
}

extern void ipv4checksum(uint8_t *pkt) {
    struct iphdr *ip = (struct iphdr *)pkt;

    ip->check = 0;
    ip->check = checksum(ip, (4 * ip->ihl));
}

extern int packetchecksumv4(uint8_t *pkt) {
    struct iphdr *ip = (struct iphdr *)pkt;

    ipv4checksum(pkt);

    switch(ip->protocol) {
        case IPPROTO_ICMP:
            ipv4icmpchecksum(pkt);
            break;
        case IPPROTO_TCP:
            ipv4tcpchecksum(pkt);
            break;
        case IPPROTO_UDP:
            ipv4udpchecksum(pkt);
            break;
        default:
            return (-1);
    }
    return (0);
}

extern int packetchecksumv6(uint8_t *pkt) {
    struct iphdr *ip = (struct iphdr *)pkt;
    switch(ip->protocol) {
        case IPPROTO_ICMP:
            break;
        case IPPROTO_TCP:
            break;
        case IPPROTO_UDP:
            break;
        default:
            return (-1);
    }
    return (0);
}

extern int packetchecksum(uint8_t *pkt) {
    struct iphdr *ip = (struct iphdr *)pkt;

    switch(ip->version) {
        case IP_PROTO_V4:
            return (packetchecksumv4(pkt));
            break;
        case IP_PROTO_V6:
            break;
    }
    return (-1);
}
#endif

extern const char *cidrtosn(int bitlen, char *buf, int size) {
    uint32_t nm;
    uint8_t *nmb = (uint8_t*)&nm;

    if (!buf) {
        return NULL;
    }

    if (bitlen) {
        nm = ~((1 << (32-bitlen))-1);
    } else {
        nm = 0;
    }

    snprintf(buf, size, "%i.%i.%i.%i", nmb[3], nmb[2], nmb[1], nmb[0]);
    return buf;
}

extern const char *getnetaddr(const char *ipaddr, int cidr, char *buf, int size) {
    uint32_t ip;
    uint8_t *ipb = (uint8_t*)&ip;
    
    if (!buf) {
        return NULL;
    }

#ifndef __WIN32
    inet_pton(AF_INET, ipaddr, &ip);
#else
    ip = inet_addr(ipaddr);
#endif
    if (cidr) {
        ip = ntohl(ip);
        ip = ip & ~((1 << (32-cidr))-1);
    } else {
        ip = 0;
    }

    snprintf(buf, size, "%i.%i.%i.%i", ipb[3], ipb[2], ipb[1], ipb[0]);
    return buf;
}

extern const char *getfirstaddr(const char *ipaddr, int cidr, char *buf, int size) {
    uint32_t ip;
    uint8_t *ipb = (uint8_t*)&ip;
    
    if (!buf) {
        return NULL;
    }

#ifndef __WIN32
    inet_pton(AF_INET, ipaddr, &ip);
#else
    ip = inet_addr(ipaddr);
#endif
    if (cidr) {
        ip = ntohl(ip);
        ip = ip & ~((1 << (32-cidr))-1);
        ip++;
    } else {
        ip = 1;
    }

    snprintf(buf, size, "%i.%i.%i.%i", ipb[3], ipb[2], ipb[1], ipb[0]);
    return buf;
}

extern const char *getbcaddr(const char *ipaddr, int cidr, char *buf, int size) {
    uint32_t ip, mask;
    uint8_t *ipb = (uint8_t*)&ip;

#ifndef __WIN32
    inet_pton(AF_INET, ipaddr, &ip);
#else
    ip = inet_addr(ipaddr);
#endif
    if (cidr) {
        mask = (1 << (32-cidr))-1;
        ip = ntohl(ip);
        ip = (ip & ~mask) | mask;
    } else {
        ip = 0;
    }
    snprintf(buf, size, "%i.%i.%i.%i", ipb[3], ipb[2], ipb[1], ipb[0]);
    return buf;
}

extern const char *getlastaddr(const char *ipaddr, int cidr, char *buf, int size) {
    uint32_t ip, mask;
    uint8_t *ipb = (uint8_t*)&ip;

#ifndef __WIN32
    inet_pton(AF_INET, ipaddr, &ip);
#else
    ip = inet_addr(ipaddr);
#endif
    if (cidr) {
        mask = (1 << (32-cidr))-1;
        ip = ntohl(ip);
        ip = (ip & ~mask) | mask;
        ip--;
    } else {
        ip = 0;
    }
    snprintf(buf, size, "%i.%i.%i.%i", ipb[3], ipb[2], ipb[1], ipb[0]);
    return buf;
}

extern uint32_t cidrcnt(int bitlen) {
    if (bitlen) {
        return pow(2, (32-bitlen));
    } else {
        return 0xFFFFFFFF;
    }
}

extern int reservedip(const char *ipaddr) {
    uint32_t ip;

#ifndef __WIN32
    inet_pton(PF_INET, ipaddr, &ip);
#else
    ip = inet_addr(ipaddr);
#endif

    ip = ntohl(ip);

    if (!((0xe0000000 ^ ip) >> 28)) { /* 224/4*/
        return 1;
    } else if (!((0x00000000 ^ ip) >> 24)) { /* 0/8 */
        return 1;
    } else if (!((0x0a000000 ^ ip) >> 24)) { /* 10/8 */
        return 1;
    } else if (!((0x7f000000 ^ ip) >> 24)) { /* 127/8 */
        return 1;
    } else if (!((0x64400000 ^ ip) >> 22)) { /* 100.64/10 */
        return 1;
    } else if (!((0xac100000 ^ ip) >> 20)) { /* 172.16/12 */
        return 1;
    } else if (!((0xc6120000 ^ ip) >> 17)) { /* 198.18/15 */
        return 1;
    } else if (!((0xc0a80000 ^ ip) >> 16)) { /* 192.168/16 */
        return 1;
    } else if (!((0xa9fe0000 ^ ip) >> 16)) { /* 169.254/16 */
        return 1;
    } else if (!((0xc0000200 ^ ip) >> 8)) { /* 192.0.2/24 */
        return 1;
    } else if (!((0xc6336400 ^ ip) >> 8)) { /* 198.51.100/24 */
        return 1;
    } else if (!((0xcb007100 ^ ip) >> 8)) { /* 203.0.113/24 */
        return 1;
    }
    return 0;
}

extern char* ipv6to4prefix(const char *ipaddr) {
    uint32_t ip;
    uint8_t *ipa;
    char *pre6;

#ifndef __WIN32
    if (!inet_pton(AF_INET, ipaddr, &ip)) {
        return NULL;
    }
#else
    if (!(ip = inet_addr(ipaddr))) {
        return NULL;
    }
#endif

    pre6 = malloc(10);
    ipa=(uint8_t*)&ip;
    snprintf(pre6, 10, "%02x%02x:%02x%02x", ipa[0], ipa[1], ipa[2], ipa[3]);
    return pre6;
}


extern int check_ipv4(const char* ip, int cidr, const char *test) {
    uint32_t ip1, ip2;

#ifndef __WIN32
    inet_pton(AF_INET, ip, &ip1);
    inet_pton(AF_INET, test, &ip2);
#else
    ip1 = inet_addr(ip);
    ip2 = inet_addr(test);
#endif

    ip1 = ntohl(ip1) >> (32-cidr);
    ip2 = ntohl(ip2) >> (32-cidr);

    if (!(ip1 ^ ip2)) {
        return 1;
    } else {
        return 0;
    }
}

void mcast6_ip(struct in6_addr *addr) {
    int mip, rand;
    uint32_t *i;

#ifndef __WIN32
    i = (uint32_t*)&addr->s6_addr32;
#else
    i = (uint32_t*)&addr->u.Word;
#endif
    i[0] = htonl(0xFF350000);
    i[1] = 0;
    i[2] = 0;
    i[3] = 1 << 31;

    do {
        rand = genrand(&mip, 4);
    } while (!rand);

    i[3] = htonl(i[3] | mip);
}

void mcast4_ip(struct in_addr *addr) {
    uint32_t mip, rand;

    do {
        rand = genrand(&mip, 3);
        mip >>= 8;
    } while (!rand || !(mip >> 8));
    mip |= 232 << 24;

    addr->s_addr = htonl(mip);
}

int inet_lookup(int family, const char *host, void *addr, socklen_t len) {
    struct addrinfo hint, *result, *ainfo;
    int ret = 0;

    memset(&hint, 0, sizeof(hint));
    hint.ai_family = family;

    if (getaddrinfo(host, NULL, &hint, &result) || !result) {
        return ret;
    }

    for(ainfo = result; ainfo; ainfo = ainfo->ai_next) {
        switch(ainfo->ai_family) {
            case PF_INET:
                if (len >= sizeof(struct in_addr)) {
                    struct sockaddr_in *sa4 = (struct sockaddr_in*)ainfo->ai_addr;
                    memcpy(addr, &sa4->sin_addr, len);
                    ret = 1;
                }
                break;
            case PF_INET6:
                if (len >= sizeof(struct in6_addr)) {
                    struct sockaddr_in6 *sa6 = (struct sockaddr_in6*)ainfo->ai_addr;
                    memcpy(addr, &sa6->sin6_addr, len);
                    ret = 1;
                }
                break;
        }
        if (ret) {
            break;
        }
    }
    freeaddrinfo(result);
    return ret;
}