IPv6 Nat Mapping

Implementation of RFC6296. More...

Files
file	rfc6296.c
	Implementation of RFC6296.

Data Structures
struct	natmap
	RFC6296 Nat map. More...

Typedefs
typedef struct natmap	natmap
	Forward decleration of structure. More...

Functions
void	rfc6296_map (struct natmap *map, struct in6_addr *ipaddr, int out)
	Lookup and process a NAT transform as per RFC 6296. More...
int	rfc6296_map_add (char *intaddr, char *extaddr)
	Calculate and add a NAT map. More...
void	rfc6296_test (blist_cb callback, struct in6_addr *internal)
	Quick test function. More...

Detailed Description

Implementation of RFC6296.

Typedef Documentation

typedef struct natmap natmap

Forward decleration of structure.

Definition at line 189 of file dtsapp.h.

Function Documentation

void rfc6296_map	(	struct natmap *	map,
		struct in6_addr *	ipaddr,
		int	out
	)

Lookup and process a NAT transform as per RFC 6296.

Parameters

map	Nat map structure to procees against.
ipaddr	Address to transform.
out	Set to non zero if ipaddr is internal and must be transformed to external.

Definition at line 62 of file rfc6296.c.

References natmap::adji, natmap::adjo, natmap::epre, natmap::ipre, and natmap::mask.

                                                                              {
    uint16_t *addr_16 = (uint16_t *)&ipaddr->s6_addr;
    uint32_t calc;
    uint8_t cnt, *prefix, bitlen, bytelen;
    uint16_t adj;

    prefix = (out) ? map->epre : map->ipre;
    adj = (out) ? map->adjo : map->adji;

    if ((bitlen = map->mask % 8)) {
        bytelen = (map->mask - bitlen) / 8;
        bytelen++;
    } else {
        bytelen = map->mask / 8;
    }

    /*as per RFC we handle /48 and longer /48 changes are reflected in SN*/
    if ((bytelen == 6) && (~addr_16[3]) && (!bitlen)) {
        memcpy(&ipaddr->s6_addr, prefix, bytelen);
        calc = ntohs(addr_16[3]) + adj;
        addr_16[3] = htons((calc & 0xFFFF) + (calc >> 16));
        if (! ~addr_16[3]) {
            addr_16[3] = 0;
        }
    } else if ((bytelen > 6) && (bytelen < 15)) {
        /* find first non 0xFFFF word in lower 64 bits*/
        for(cnt = ((bytelen-1) >> 1) + 1; cnt < 8; cnt++) {
            if (! ~addr_16[cnt]) {
                continue;
            }
            if (bitlen) {
                ipaddr->s6_addr[bytelen-1] = prefix[bytelen-1] | (ipaddr->s6_addr[bytelen-1] & ((1 << (8 - bitlen)) -1));
            } else {
                ipaddr->s6_addr[bytelen-1] = prefix[bytelen-1];
            }
            memcpy(&ipaddr->s6_addr, prefix, bytelen - 1);
            calc = ntohs(addr_16[cnt]) + adj;
            addr_16[cnt] = htons((calc & 0xFFFF) + (calc >> 16));
            if (! ~addr_16[cnt]) {
                addr_16[cnt] = 0;
            }
            break;
        }
    }
}

int rfc6296_map_add	(	char *	intaddr,
		char *	extaddr
	)

Calculate and add a NAT map.

Parameters

intaddr	Internal prefix/subnet.
extaddr	External prefix/subnet.

Definition at line 111 of file rfc6296.c.

References addtobucket(), natmap::adji, natmap::adjo, checksum(), create_bucketlist(), natmap::epre, natmap::ipre, natmap::mask, objalloc(), and objunref().

                                                         {
    struct natmap *map;
    uint16_t emask, imask, isum, esum, bytelen, bitlen;
    char inip[43], exip[43], *tmp2;
    struct in6_addr i6addr;
    uint32_t adj;

    strncpy(inip, intaddr, 43);
    if ((tmp2 = rindex(inip, '/'))) {
        tmp2[0] = '\0';
        tmp2++;
        imask = atoi(tmp2);
    } else {
        return (-1);
    }

    strncpy(exip, extaddr, 43);
    if ((tmp2 = rindex(exip, '/'))) {
        tmp2[0] = '\0';
        tmp2++;
        emask = atoi(tmp2);
    } else {
        return (-1);
    }

    map = objalloc(sizeof(*map), NULL);
    map->mask = (emask > imask) ? emask : imask;

    /*rfc says we must zero extend this is what we do here looking at each supplied len*/
    /*external range*/
    inet_pton(AF_INET6, exip, &i6addr);
    if ((bitlen = emask % 8)) {
        bytelen = (emask - bitlen) / 8;
        i6addr.s6_addr[bytelen] &= ~((1 << (8 - bitlen)) - 1);
        bytelen++;
    } else {
        bytelen = emask / 8;
    }
    memcpy(map->epre, &i6addr.s6_addr, bytelen);

    /*internal range*/
    inet_pton(AF_INET6, inip, &i6addr);
    if ((bitlen = imask % 8)) {
        bytelen = (imask - bitlen) / 8;
        i6addr.s6_addr[bytelen] &= ~((1 << (8 - bitlen)) - 1);
        bytelen++;
    } else {
        bytelen = imask / 8;
    }
    memcpy(map->ipre, &i6addr.s6_addr, bytelen);

    /*calculate the adjustments from checksums of prefixes*/
    if ((bitlen = map->mask % 8)) {
        bytelen = (map->mask - bitlen) / 8;
        bytelen++;
    } else {
        bytelen = map->mask / 8;
    }
    esum = ntohs(checksum(map->epre, bytelen));
    isum = ntohs(checksum(map->ipre, bytelen));

    /*outgoing transform*/
    adj = esum - isum;
    adj = (adj & 0xFFFF) + (adj >> 16);
    map->adjo = (uint16_t)adj;

    /*incoming transform*/
    adj = isum - esum;
    adj = (adj & 0xFFFF) + (adj >> 16);
    map->adji = (uint16_t)adj;

    if (!nptv6tbl && (!(nptv6tbl = create_bucketlist(5, nptv6_hash)))) {
        objunref(map);
        return (-1);
    }
    addtobucket(nptv6tbl, map);
    objunref(map);

    return (0);
}

void rfc6296_test	(	blist_cb	callback,
		struct in6_addr *	internal
	)

Quick test function.

Run a callback against each entry in the table with the internal address as data.

Parameters

callback	Bucket list callback.
internal	Ip addr passed as data to the callback.

Definition at line 197 of file rfc6296.c.

References bucketlist_callback(), and objunref().

                                                                       {
    /*find and run map*/
    bucketlist_callback(nptv6tbl, callback, internal);

    objunref(nptv6tbl);
}