GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages
NETWIB_PKT(3) FreeBSD Library Functions Manual NETWIB_PKT(3)

netwib - section pkt

If you have a browser, read netwib-5.38.0-doc_html.tgz which is easier to read than this manpage.

This manpage contains a concatenation of includes for section PKT.

#ifndef NETWIB_PKT_TYPES_INCLUDED
#define NETWIB_PKT_TYPES_INCLUDED 1
/*-------------------------------------------------------------*/
/* Protocol values */
typedef enum {
  NETWIB_IPPROTO_IP = 0,        /* Dummy protocol for TCP */
  NETWIB_IPPROTO_HOPOPTS = 0,   /* IPv6 Hop-by-Hop options */
  NETWIB_IPPROTO_ICMP4 = 1,     /* Internet Control Message Protocol */
  NETWIB_IPPROTO_IGMP = 2,      /* Internet Group Management Protocol */
  NETWIB_IPPROTO_IPIP = 4,      /* IPIP tunnels */
  NETWIB_IPPROTO_TCP = 6,       /* Transmission Control Protocol */
  NETWIB_IPPROTO_EGP = 8,       /* Exterior Gateway Protocol */
  NETWIB_IPPROTO_PUP = 12,      /* PUP protocol */
  NETWIB_IPPROTO_UDP = 17,      /* User Datagram Protocol */
  NETWIB_IPPROTO_IDP = 22,      /* XNS IDP protocol */
  NETWIB_IPPROTO_TP = 29,       /* SO Transport Protocol Class 4 */
  NETWIB_IPPROTO_IP6 = 41,      /* IPv6 header */
  NETWIB_IPPROTO_ROUTING = 43,  /* IPv6 routing header */
  NETWIB_IPPROTO_FRAGMENT = 44, /* IPv6 fragmentation header */
  NETWIB_IPPROTO_RSVP = 46,     /* Reservation Protocol */
  NETWIB_IPPROTO_GRE = 47,      /* General Routing Encapsulation */
  NETWIB_IPPROTO_ESP = 50,      /* encapsulating security payload */
  NETWIB_IPPROTO_AH = 51,       /* authentication header */
  NETWIB_IPPROTO_ICMP6 = 58,    /* ICMPv6 */
  NETWIB_IPPROTO_NONE = 59,     /* IPv6 no next header */
  NETWIB_IPPROTO_DSTOPTS = 60,  /* IPv6 destination options */
  NETWIB_IPPROTO_MTP = 92,      /* Multicast Transport Protocol */
  NETWIB_IPPROTO_ENCAP = 98,    /* Encapsulation Header */
  NETWIB_IPPROTO_PIM = 103,     /* Protocol Independent Multicast */
  NETWIB_IPPROTO_COMP = 108,    /* Compression Header Protocol */
  NETWIB_IPPROTO_RAW = 255      /* Raw IP packets */
} netwib_ipproto;
/*-------------------------------------------------------------*/
#define netwib__data_append_uint8(data,u) *(data)++=(netwib_byte)(u)
#define netwib__data_append_uint16(data,u) *(data)++=netwib_c2_uint16_0(u);*(data)++=netwib_c2_uint16_1(u)
#define netwib__data_append_uint32(data,u) *(data)++=netwib_c2_uint32_0(u);*(data)++=netwib_c2_uint32_1(u);*(data)++=netwib_c2_uint32_2(u);*(data)++=netwib_c2_uint32_3(u)
#define netwib__data_append_uint64(data,u) *(data)++=netwib_c2_uint64_0(u);*(data)++=netwib_c2_uint64_1(u);*(data)++=netwib_c2_uint64_2(u);*(data)++=netwib_c2_uint64_3(u);*(data)++=netwib_c2_uint64_4(u);*(data)++=netwib_c2_uint64_5(u);*(data)++=netwib_c2_uint64_6(u);*(data)++=netwib_c2_uint64_7(u)
/* for structures created with little endian processors */
#define netwib__data_append_uint8_le(data,u) netwib__data_append_uint8(data,u)
#define netwib__data_append_uint16_le(data,u) *(data)++=netwib_c2_uint16_1(u);*(data)++=netwib_c2_uint16_0(u)
#define netwib__data_append_uint32_le(data,u) *(data)++=netwib_c2_uint32_3(u);*(data)++=netwib_c2_uint32_2(u);*(data)++=netwib_c2_uint32_1(u);*(data)++=netwib_c2_uint32_0(u)
#define netwib__data_append_uint64_le(data,u) *(data)++=netwib_c2_uint64_7(u);*(data)++=netwib_c2_uint64_6(u);*(data)++=netwib_c2_uint64_5(u);*(data)++=netwib_c2_uint64_4(u);*(data)++=netwib_c2_uint64_3(u);*(data)++=netwib_c2_uint64_2(u);*(data)++=netwib_c2_uint64_1(u);*(data)++=netwib_c2_uint64_0(u)
/*-------------------------------------------------------------*/
#define netwib__data_decode_uint8t(data,u,type) u=(type)(*(data)++)
#define netwib__data_decode_uint8t_le(data,u,type) netwib__data_decode_uint8t(data,u,type)
#define netwib__data_decode_uint16t(data,u,type) u=(type)((*(data)++)<<8);u=(type)((u)|*(data)++)
#define netwib__data_decode_uint16t_le(data,u,type) u=(type)(*(data)++);u=(type)(((*(data)++)<<8)|(u))
#define netwib__data_decode_uint32t(data,u,type) u=(type)((*(data)++)<<24);u=(type)((u)|((*(data)++)<<16));u=(type)((u)|((*(data)++)<<8));u=(type)((u)|*(data)++)
#define netwib__data_decode_uint32t_le(data,u,type) u=(type)(*(data)++);u=(type)(((*(data)++)<<8)|(u));u=(type)(((*(data)++)<<16)|(u));u=(type)(((*(data)++)<<24)|(u))
#if NETWIB_INT64_FAKE == 0
 #define netwib__data_decode_uint64t(data,u,type) u=(type)((netwib_uint64)(*(data)++)<<56);u=(type)((u)|((netwib_uint64)(*(data)++)<<48));u=(type)((u)|((netwib_uint64)(*(data)++)<<40));u=(type)((u)|((netwib_uint64)(*(data)++)<<32));u=(type)((u)|((netwib_uint64)(*(data)++)<<24));u=(type)((u)|((netwib_uint64)(*(data)++)<<16));u=(type)((u)|((netwib_uint64)(*(data)++)<<8));u=(type)((u)|(netwib_uint64)(*(data)++))
 #define netwib__data_decode_uint64t_le(data,u,type) u=(type)(netwib_uint64)(*(data)++);u=(type)(((netwib_uint64)(*(data)++)<<8)|(u));u=(type)(((netwib_uint64)(*(data)++)<<16)|(u));u=(type)(((netwib_uint64)(*(data)++)<<24)|(u));u=(type)(((netwib_uint64)(*(data)++)<<32)|(u));u=(type)(((netwib_uint64)(*(data)++)<<40)|(u));u=(type)(((netwib_uint64)(*(data)++)<<48)|(u));u=(type)(((netwib_uint64)(*(data)++)<<56)|(u))
#else
 #define netwib__data_decode_uint64t(data,u,type) netwib__data_decode_uint32(data,(u).high);netwib__data_decode_uint32(data,(u).low)
 #define netwib__data_decode_uint64t_le(data,u,type) netwib__data_decode_uint32_le(data,(u).low);netwib__data_decode_uint32_le(data,(u).high)
#endif
#define netwib__data_decode_uint8(data,u) netwib__data_decode_uint8t(data,u,netwib_uint8)
#define netwib__data_decode_uint8_le(data,u) netwib__data_decode_uint8(data,u)
#define netwib__data_decode_uint16(data,u) netwib__data_decode_uint16t(data,u,netwib_uint16)
#define netwib__data_decode_uint16_le(data,u) netwib__data_decode_uint16t_le(data,u,netwib_uint16)
#define netwib__data_decode_uint32(data,u) netwib__data_decode_uint32t(data,u,netwib_uint32)
#define netwib__data_decode_uint32_le(data,u) netwib__data_decode_uint32t_le(data,u,netwib_uint32)
#define netwib__data_decode_uint64(data,u) netwib__data_decode_uint64t(data,u,netwib_uint64)
#define netwib__data_decode_uint64_le(data,u) netwib__data_decode_uint64t_le(data,u,netwib_uint64)
#endif

/*-------------------------------------------------------------*/
/* Ethernet header (NETWIB_DEVICE_DLTTYPE_EN10MB) */
typedef enum {
  NETWIB_ETHERHDRTYPE_IP4 =    0x0800,
  NETWIB_ETHERHDRTYPE_ARP =    0x0806,
  NETWIB_ETHERHDRTYPE_VINES =  0x0bad,
  NETWIB_ETHERHDRTYPE_TRAIN =  0x1984,
  NETWIB_ETHERHDRTYPE_CDP =    0x2000,
  NETWIB_ETHERHDRTYPE_RARP =   0x8035,
  NETWIB_ETHERHDRTYPE_ATALK =  0x809b,
  NETWIB_ETHERHDRTYPE_AARP =   0x80f3,
  NETWIB_ETHERHDRTYPE_VLAN =   0x8100,
  NETWIB_ETHERHDRTYPE_IPX =    0x8137,
  NETWIB_ETHERHDRTYPE_IP6 =    0x86DD,
  NETWIB_ETHERHDRTYPE_PPPOED = 0x8863,
  NETWIB_ETHERHDRTYPE_PPPOES = 0x8864,
  NETWIB_ETHERHDRTYPE_LOOP =   0x9000
} netwib_etherhdrtype;
typedef struct {
  netwib_eth dst;
  netwib_eth src;
  netwib_etherhdrtype type;
} netwib_etherhdr;
typedef const netwib_etherhdr netwib_constetherhdr;
#define NETWIB_ETHERHDR_LEN 14
/*-------------------------------------------------------------*/
/* NULL header (NETWIB_DEVICE_DLTTYPE_NULL) */
typedef struct {
  netwib_etherhdrtype type;
} netwib_nullhdr;
typedef const netwib_nullhdr netwib_constnullhdr;
#define NETWIB_NULLHDR_LEN 4
/*-------------------------------------------------------------*/
/* LOOP header (NETWIB_DEVICE_DLTTYPE_LOOP) */
typedef struct {
  netwib_etherhdrtype type;
} netwib_loophdr;
typedef const netwib_loophdr netwib_constloophdr;
#define NETWIB_LOOPHDR_LEN 4
/*-------------------------------------------------------------*/
/* RAW header (NETWIB_DEVICE_DLTTYPE_RAW) */
#define NETWIB_RAWHDR_LEN 0
/*-------------------------------------------------------------*/
/* PPP header (NETWIB_DEVICE_DLTTYPE_PPP) */
typedef enum {
  NETWIB_PPPHDRPROTO_IP4 =     0x0021, /* Internet Protocol */
  NETWIB_PPPHDRPROTO_AT =      0x0029, /* AppleTalk Protocol */
  NETWIB_PPPHDRPROTO_IPX =     0x002b, /* IPX protocol */
  NETWIB_PPPHDRPROTO_VJC_COMP =   0x002d, /* VJ compressed TCP */
  NETWIB_PPPHDRPROTO_VJC_UNCOMP = 0x002f, /* VJ uncompressed TCP */
  NETWIB_PPPHDRPROTO_IP6 =     0x0057, /* Internet Protocol Version 6 */
  NETWIB_PPPHDRPROTO_COMP =    0x00fd, /* compressed packet */
  NETWIB_PPPHDRPROTO_IPCP =    0x8021, /* IP Control Protocol */
  NETWIB_PPPHDRPROTO_ATCP =    0x8029, /* AppleTalk Control Protocol */
  NETWIB_PPPHDRPROTO_IPXCP =   0x802b, /* IPX Control Protocol */
  NETWIB_PPPHDRPROTO_IP6CP =   0x8057, /* IPv6 Control Protocol */
  NETWIB_PPPHDRPROTO_CCP =     0x80fd, /* Compression Control Protocol */
  NETWIB_PPPHDRPROTO_LCP =     0xc021, /* Link Control Protocol */
  NETWIB_PPPHDRPROTO_PAP =     0xc023, /* Password Authentication Proto */
  NETWIB_PPPHDRPROTO_LQR =     0xc025, /* Link Quality Report protocol */
  NETWIB_PPPHDRPROTO_CHAP =    0xc223, /* Crypto. Handshake Auth. P. */
  NETWIB_PPPHDRPROTO_CBCP =    0xc029  /* Callback Control Protocol */
} netwib_ppphdrproto;
typedef struct {
  netwib_byte address;
  netwib_byte control;
  netwib_ppphdrproto protocol;
} netwib_ppphdr;
typedef const netwib_ppphdr netwib_constppphdr;
#define NETWIB_PPPHDR_LEN 4
/*-------------------------------------------------------------*/
/* LINUX_SLL header (NETWIB_DEVICE_DLTTYPE_LINUX_SLL) */
typedef enum {
  NETWIB_LINUXSLLHDRPKTTYPE_HOST = 0,
  NETWIB_LINUXSLLHDRPKTTYPE_BROADCAST = 1,
  NETWIB_LINUXSLLHDRPKTTYPE_MULTICAST = 2,
  NETWIB_LINUXSLLHDRPKTTYPE_OTHERHOST = 3,
  NETWIB_LINUXSLLHDRPKTTYPE_OUTGOING = 4
} netwib_linuxsllhdrpkttype;
typedef enum {
  NETWIB_LINUXSLLHDRHATYPE_NETROM = 0,
  NETWIB_LINUXSLLHDRHATYPE_ETHER = 1
} netwib_linuxsllhdrhatype;
typedef struct {
  netwib_linuxsllhdrpkttype pkttype;   /* packet type */
  netwib_linuxsllhdrhatype hatype;     /* link-layer address type */
  netwib_uint16 halen;                 /* link-layer address length */
  netwib_byte srcaddr[8];              /* link-layer address */
  netwib_etherhdrtype protocol;        /* protocol */
} netwib_linuxsllhdr;
typedef const netwib_linuxsllhdr netwib_constlinuxsllhdr;
#define NETWIB_LINUXSLLHDR_LEN 16
/*-------------------------------------------------------------*/
/* Link header */
typedef struct {
  netwib_device_dlttype type;
  union {
    netwib_etherhdr    ether;
    netwib_nullhdr     null;
    netwib_loophdr     loop;
    /* no netwib_rawhdr needed */
    netwib_ppphdr      ppp;
    netwib_linuxsllhdr linuxsll;
  } hdr;
} netwib_linkhdr;
typedef const netwib_linkhdr netwib_constlinkhdr;
#define NETWIB_LINKHDR_MAXLEN NETWIB_LINUXSLLHDR_LEN
/*-------------------------------------------------------------*/
/* Name : netwib_linkhdr_initdefault
   Description :
     Initialize a netwib_linkhdr with default values.
   Input parameter(s) :
     type : header type
   Input/output parameter(s) :
   Output parameter(s) :
     *plinkhdr : netwib_linkhdr to initialize
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_linkhdr_initdefault(netwib_device_dlttype type,
                                      netwib_linkhdr *plinkhdr);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_append_linkhdr
   Description :
     Initialize physical data from a netwib_linkhdr.
   Input parameter(s) :
     linkhdr : netwib_linkhdr
   Input/output parameter(s) :
     *ppht : buffer to initialize
   Output parameter(s) :
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_append_linkhdr(netwib_constlinkhdr *plinkhdr,
                                     netwib_buf *ppkt);
netwib_err netwib_pkt_prepend_linkhdr(netwib_constlinkhdr *plinkhdr,
                                      netwib_buf *ppkt);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_decode_linkhdr
   Description :
     Decode a netwib_linkhdr from data coming from wire.
   Input parameter(s) :
     dlttype : DLT type of packet
     *ppkt : buffer containing physical data
   Input/output parameter(s) :
   Output parameter(s) :
     *plinkhdr : netwib_linkhdr to initialize
     *pskipsize : size to skip this header
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_decode_linkhdr(netwib_device_dlttype dlttype,
                                     netwib_constbuf *ppkt,
                                     netwib_linkhdr *plinkhdr,
                                     netwib_uint32 *pskipsize);
/*-------------------------------------------------------------*/
/***************************************************************
 * Link headers are horribly incompatible. The only field      *
 * which can be considered as compatible is the type/protocol. *
 * Following functions permit to set/get it from header.       *
 * Type netwib_linkhdrproto is the generic type.               *
 ***************************************************************/
typedef enum {
  NETWIB_LINKHDRPROTO_UNKNOWN = 0,
  NETWIB_LINKHDRPROTO_IP4,
  NETWIB_LINKHDRPROTO_IP6,
  NETWIB_LINKHDRPROTO_ARP,
  NETWIB_LINKHDRPROTO_RARP,
  NETWIB_LINKHDRPROTO_IPX
} netwib_linkhdrproto;
netwib_err netwib_linkhdr_set_proto(netwib_linkhdr *plinkhdr,
                                    netwib_linkhdrproto linkhdrproto);
netwib_err netwib_linkhdr_get_proto(netwib_constlinkhdr *plinkhdr,
                                    netwib_linkhdrproto *plinkhdrproto);

/*-------------------------------------------------------------*/
/***************************************************************
 * A netwib_iphdr permits to store :                           *
 *  - an IPv4 header (rfc 791), or                             *
 *  - an IPv6 header (rfc 2460)                                *
 ***************************************************************/
typedef struct {
  /* common fields */
  netwib_iptype iptype;
  netwib_ip src;
  netwib_ip dst;
  netwib_uint8 ttl;
  netwib_ipproto protocol;
  /* specific fields */
  union {
    struct {
      netwib_uint8 ihl;
      netwib_uint8 tos;
      netwib_uint16 totlen;
      netwib_uint16 id;
      netwib_bool reserved;
      netwib_bool dontfrag;
      netwib_bool morefrag;
      netwib_uint16 offsetfrag;
      netwib_uint16 check;
      netwib_bufext opts; /* IPv4 options as defined in ip4opts.h */
    } ip4;
    struct {
      netwib_uint8 trafficclass;
      netwib_uint32 flowlabel;
      netwib_uint16 payloadlength;
      netwib_bufext exts; /* IPv6 extensions as defined in ip6exts.h */
    } ip6;
  } header;
} netwib_iphdr;
typedef const netwib_iphdr netwib_constiphdr;
#define NETWIB_IPHDR_MINLEN 40
/*-------------------------------------------------------------*/
/* Name : netwib_iphdr_initdefault
   Description :
     Initialize a netwib_iphdr with default values.
   Input parameter(s) :
   Input/output parameter(s) :
   Output parameter(s) :
     *piphdr : netwib_iphdr to initialize
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_iphdr_initdefault(netwib_iptype iptype,
                                    netwib_iphdr *piphdr);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_append_iphdr
   Description :
     Initialize physical data from a netwib_iphdr.
   Input parameter(s) :
     *piphdr : netwib_iphdr
   Input/output parameter(s) :
     *ppht : buffer to initialize
   Output parameter(s) :
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_append_iphdr(netwib_constiphdr *piphdr,
                                   netwib_buf *ppkt);
netwib_err netwib_pkt_prepend_iphdr(netwib_constiphdr *piphdr,
                                    netwib_buf *ppkt);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_decode_iphdr
   Description :
     Decode a netwib_iphdr from physical data.
   Input parameter(s) :
     *ppkt : buffer containing physical data
   Input/output parameter(s) :
   Output parameter(s) :
     *piphdr : netwib_iphdr contained in pkt
     *pskipsize : size to use to skip this header
   Normal return values :
     NETWIB_ERR_OK : ok
     NETWIB_ERR_NOTCONVERTED : pkt could not be decoded
     NETWIB_ERR_DATAMISSING : pkt was not big enough
*/
netwib_err netwib_pkt_decode_iphdr(netwib_constbuf *ppkt,
                                   netwib_iphdr *piphdr,
                                   netwib_uint32 *pskipsize);
/*-------------------------------------------------------------*/
/***************************************************************
 * A netwib_iphdr contains a protocol field, it is stored :    *
 *  - IPv4 : in header.protocol                                *
 *  - IPv6 : if exts is empty : in header.protocol,            *
 *           else : in last extension of header.ip6.exts       *
 ***************************************************************/
netwib_err netwib_iphdr_set_proto(netwib_iphdr *piphdr,
                                  netwib_ipproto ipproto);
netwib_err netwib_iphdr_get_proto(netwib_constiphdr *piphdr,
                                  netwib_ipproto *pipproto);

/*-------------------------------------------------------------*/
/***************************************************************
 * Refer to RFC 791 to obtain more information about IPv4      *
 * options.                                                    *
 ***************************************************************/
/*-------------------------------------------------------------*/
/* Comments starting with "NI" are not implemented */
typedef enum {
  NETWIB_IP4OPTTYPE_END = 0,        /* end of options */
  NETWIB_IP4OPTTYPE_NOOP = 1,       /* no operation */
  NETWIB_IP4OPTTYPE_RR = 7,         /* record route */
  NETWIB_IP4OPTTYPE_TIME = 68,      /* timestamp */
  NETWIB_IP4OPTTYPE_SECURITY = 130, /* NI security compartmentation */
  NETWIB_IP4OPTTYPE_LSRR = 131,     /* loose source and record route */
  NETWIB_IP4OPTTYPE_STREAM = 136,   /* NI SATNET stream identifier */
  NETWIB_IP4OPTTYPE_SSRR = 137      /* strict source and record route */
} netwib_ip4opttype;
/*-------------------------------------------------------------*/
/* maximum length of one IP4 option */
#define NETWIB_IP4OPT_MAXLEN 40
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint32 storagesize; /* 0 to 9 */
  netwib_uint32 storedvalues; /* 0 to storagesize */
#define NETWIB_IP4OPT_RR_IP_LEN 9
  netwib_ip ip[NETWIB_IP4OPT_RR_IP_LEN];
} netwib_ip4opt_rr;
typedef const netwib_ip4opt_rr netwib_constip4opt_rr;
typedef struct {
  netwib_uint32 storagesize; /* 0 to 9 */
  netwib_uint32 usedvalues; /* 0 to storagesize */
#define NETWIB_IP4OPT_SRR_IP_LEN 9
  netwib_ip ip[NETWIB_IP4OPT_SRR_IP_LEN];
} netwib_ip4opt_srr;
typedef const netwib_ip4opt_srr netwib_constip4opt_srr;
typedef enum {
  NETWIB_IP4OPT_TIMEFLAG_TS = 0,
  NETWIB_IP4OPT_TIMEFLAG_IPTS = 1,
  NETWIB_IP4OPT_TIMEFLAG_IPPTS = 3
} netwib_ip4opt_timeflag;
typedef struct {
  netwib_uint32 storagesize; /* 0 to 4or9 (4 for ipts/ippts; 9 for ts) */
  netwib_uint32 storedvalues; /* 0 to storeagesize */
  netwib_uint8 overflow;
  netwib_ip4opt_timeflag flag;
#define NETWIB_IP4OPT_TIME_IP_LEN 4
  netwib_ip ip[NETWIB_IP4OPT_TIME_IP_LEN];
#define NETWIB_IP4OPT_TIME_TIMESTAMP_LEN 9
  netwib_uint32 timestamp[NETWIB_IP4OPT_TIME_TIMESTAMP_LEN];
} netwib_ip4opt_time;
typedef const netwib_ip4opt_time netwib_constip4opt_time;
typedef struct {
  netwib_ip4opttype type;
  union {
    /* type end : no value */
    /* type noop : no value */
    netwib_ip4opt_rr rr;
    netwib_ip4opt_time time;
    /* type security : NI */
    netwib_ip4opt_srr lsrr;
    /* type stream : NI */
    netwib_ip4opt_srr ssrr;
  } opt;
} netwib_ip4opt;
typedef const netwib_ip4opt netwib_constip4opt;
/*-------------------------------------------------------------*/
/* Name : netwib_ip4opt_initdefault
   Description :
     Initialize a netwib_ip4opt with default values.
   Input parameter(s) :
   Input/output parameter(s) :
   Output parameter(s) :
     *pip4opt : netwib_ip4opt to initialize
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_ip4opt_initdefault(netwib_ip4opttype ip4opttype,
                                     netwib_ip4opt *pip4opt);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_append_ip4opt
   Description :
     Initialize physical data from a netwib_ip4opt.
   Input parameter(s) :
     ip4opt : netwib_ip4opt
   Input/output parameter(s) :
     *ppht : buffer to initialize
   Output parameter(s) :
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_append_ip4opt(netwib_constip4opt *pip4opt,
                                    netwib_buf *ppkt);
netwib_err netwib_pkt_prepend_ip4opt(netwib_constip4opt *pip4opt,
                                     netwib_buf *ppkt);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_decode_ip4opt
   Description :
     Decode a netwib_ip4opt from data coming from wire.
   Input parameter(s) :
     *ppkt : buffer containing physical data
   Input/output parameter(s) :
   Output parameter(s) :
     *pip4opt : netwib_ip4opt to initialize
     *pskipsize : size to skip this option
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_decode_ip4opt(netwib_constbuf *ppkt,
                                    netwib_ip4opt *pip4opt,
                                    netwib_uint32 *pskipsize);

/*-------------------------------------------------------------*/
/***************************************************************
 * A "netwib_ip4opts" is a netwib_buf storing 0, 1 or more     *
 * netwib_ip4opt. There is no typedef for netwib_ip4opts.      *
 ***************************************************************/
/*-------------------------------------------------------------*/
/* maximum length of a buffer containing a "netwib_ip4opts" */
#define NETWIB_IP4OPTS_MAXLEN 40
/*-------------------------------------------------------------*/
/***************************************************************
 * To create a "netwib_ip4opts", loop using function           *
 * netwib_pkt_append_ip4opt.                                   *
 * To decode a "netwib_ip4opts", loop using function           *
 * netwib_pkt_decode_ip4opt.                                   *
 ***************************************************************/

/*-------------------------------------------------------------*/
/***************************************************************
 * Following functions work on extension headers of IPv6.      *
 ***************************************************************/
/*-------------------------------------------------------------*/
/* IPv6 Hop-by-Hop Options extension header */
typedef struct {
  netwib_bufext options;
} netwib_ip6ext_hopopts;
typedef const netwib_ip6ext_hopopts netwib_constip6ext_hopopts;
/*-------------------------------------------------------------*/
/* IPv6 Destination Options extension header */
typedef struct {
  netwib_bufext options;
} netwib_ip6ext_dstopts;
typedef const netwib_ip6ext_dstopts netwib_constip6ext_dstopts;
/*-------------------------------------------------------------*/
/* IPv6 Routing extension header */
typedef struct {
  netwib_uint8 routingtype;
  netwib_uint8 segmentsleft;
  netwib_bufext data;
} netwib_ip6ext_routing;
typedef const netwib_ip6ext_routing netwib_constip6ext_routing;
/*-------------------------------------------------------------*/
/* IPv6 Fragment extension header */
typedef struct {
  netwib_uint16 fragmentoffset;
  netwib_bool reservedb1;
  netwib_bool reservedb2;
  netwib_bool morefrag;
  netwib_uint32 id;
} netwib_ip6ext_fragment;
typedef const netwib_ip6ext_fragment netwib_constip6ext_fragment;
/*-------------------------------------------------------------*/
/* IPv6 Authentication Header extension header (rfc 2402) */
typedef struct {
  netwib_uint16 reserved;
  netwib_uint32 spi;
  netwib_uint32 seqnum;
  netwib_bufext data;
} netwib_ip6ext_ah;
typedef const netwib_ip6ext_ah netwib_constip6ext_ah;
/*-------------------------------------------------------------*/
/* Generic IPv6 extension header */
typedef struct {
  netwib_ipproto proto;
  union {
    netwib_ip6ext_hopopts hopopts;
    netwib_ip6ext_dstopts dstopts;
    netwib_ip6ext_routing routing;
    netwib_ip6ext_fragment fragment;
    netwib_ip6ext_ah ah;
  } ext;
  netwib_ipproto nextproto;
} netwib_ip6ext;
typedef const netwib_ip6ext netwib_constip6ext;
/*-------------------------------------------------------------*/
/* Name : netwib_ip6ext_initdefault
   Description :
     Initialize a netwib_ip6ext with default values.
   Input parameter(s) :
   Input/output parameter(s) :
   Output parameter(s) :
     *pip6ext : netwib_ip6ext to initialize
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_ip6ext_initdefault(netwib_ipproto proto,
                                     netwib_ip6ext *pip6ext);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_append_ip6ext
   Description :
     Initialize physical data from a netwib_ip6ext.
   Input parameter(s) :
     ip6ext : netwib_ip6ext
   Input/output parameter(s) :
     *ppht : buffer to initialize
   Output parameter(s) :
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_append_ip6ext(netwib_constip6ext *pip6ext,
                                    netwib_buf *ppkt);
netwib_err netwib_pkt_prepend_ip6ext(netwib_constip6ext *pip6ext,
                                     netwib_buf *ppkt);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_decode_ip6ext
   Description :
     Decode a netwib_ip6ext from data coming from wire.
   Input parameter(s) :
     pktproto : protocol of the netwib_ip6ext in ppkt
     *ppkt : buffer containing physical data
   Input/output parameter(s) :
   Output parameter(s) :
     *pip6ext : netwib_ip6ext to initialize
     *pskipsize : size to skip this header
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_decode_ip6ext(netwib_ipproto pktproto,
                                    netwib_constbuf *ppkt,
                                    netwib_ip6ext *pip6ext,
                                    netwib_uint32 *pskipsize);

/*-------------------------------------------------------------*/
/***************************************************************
 * A "netwib_ip6exts" is a netwib_buf storing 0, 1 or more     *
 * netwib_ip6ext. There is no typedef for netwib_ip6exts.      *
 ***************************************************************/
/*-------------------------------------------------------------*/
/***************************************************************
 * To create a "netwib_ip6exts", loop using function           *
 * netwib_pkt_append_ip6ext.                                   *
 * To decode a "netwib_ip6exts", loop using function           *
 * netwib_pkt_decode_ip6ext.                                   *
 ***************************************************************/
/*-------------------------------------------------------------*/
/***************************************************************
 * Normally, an IPv6 packet should be created and decoded      *
 * layer by layer. So, there should be no need for an          *
 * netwib_ip6exts, containing several layers/ip6_extensions.   *
 * However, this behavior makes harder the creation of         *
 * functions for both IPv4 (which contains IP4 options) and    *
 * IPv6.                                                       *
 * So, in netwib the netwib_ip6hdr contains a buffer of        *
 * netwib_ip6exts.                                             *
 *                                                             *
 * When decoding a packet, the netwib_ip6exts buffer is set to *
 * all recognized extensions :                                 *
 *   NETWIB_IPPROTO_HOPOPTS                                    *
 *   NETWIB_IPPROTO_DSTOPTS                                    *
 *   NETWIB_IPPROTO_ROUTING                                    *
 *   NETWIB_IPPROTO_FRAGMENT                                   *
 *   NETWIB_IPPROTO_AH                                         *
 * Then, the packet eventually starts with unknown extensions  *
 * or real data.                                               *
 * Example 1 :                                                 *
 *   packet is IP6+HOPOPTS+FRAGMENT+TCP                        *
 *   ip6exts in ip6hdr will contain : HOPOPTS+FRAGMENT         *
 *   next data will be : TCP                                   *
 * Example 2 :                                                 *
 *   packet is IP6+TCP                                         *
 *   ip6exts in ip6hdr will contain : nothing                  *
 *   next data will be : TCP                                   *
 * Example 3 :                                                 *
 *   packet is IP6+HOPOPTS+unknown+TCP                         *
 *   ip6exts in ip6hdr will contain : HOPOPTS                  *
 *   next data will be : unknown+TCP                           *
 * Example 4 :                                                 *
 *   packet is IP6+HOPOPTS+unknown+FRAGMENT+TCP                *
 *   ip6exts in ip6hdr will contain : HOPOPTS                  *
 *   next data will be : unknown+FRAGMENT+TCP                  *
 * If you prefer the layer by layer behavior, just concatenate *
 * ip6exts and next_data.                                      *
 *                                                             *
 * When creating a packet, there are 2 ways :                  *
 *  - store extensions in ip6exts, or                          *
 *  - left empty ip6exts, and put extensions at the beginning  *
 *    of data                                                  *
 * The first solution is preferred, because netwib will        *
 * magically deal with them if necessary.                      *
 ***************************************************************/
/*-------------------------------------------------------------*/
/***************************************************************
 * RFC 2640 says "The Hop-by-Hop Options header, when present, *
 * must immediately follow the IPv6 header". This is not       *
 * enforced in netwib.                                         *
 ***************************************************************/
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_decode_ip6exts
   Description :
     Obtain size of all recognized extensions. Also obtain
     the last proto and its offset (to easily overwrite it).
     The recognized extensions are :
        NETWIB_IPPROTO_HOPOPTS
        NETWIB_IPPROTO_DSTOPTS
        NETWIB_IPPROTO_ROUTING
        NETWIB_IPPROTO_FRAGMENT
        NETWIB_IPPROTO_AH
   Input parameter(s) :
     pktproto : protocol of the netwib_ip6ext in ppkt
     *ppkt : buffer containing physical data
   Input/output parameter(s) :
   Output parameter(s) :
     *plastproto : last protocol
     *plastprotooffset : offset of the byte describing the
                         last protocol. This value is unset
                         if skipsize == 0.
     *pskipsize : size to skip this/those extensions. If 0,
                  there is no extension (in this case,
                  lastproto is set to pktproto).
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_decode_ip6exts(netwib_ipproto pktproto,
                                     netwib_constbuf *ppkt,
                                     netwib_ipproto *plastproto,
                                     netwib_uint32 *plastprotooffset,
                                     netwib_uint32 *pskipsize);

/*-------------------------------------------------------------*/
/***************************************************************
 * Currently, only Ethernet-IPv4 is implemented as ARP.        *
 ***************************************************************/
/*-------------------------------------------------------------*/
/* ARP header */
typedef enum {
  NETWIB_ARPHDROP_ARPREQ = 1,
  NETWIB_ARPHDROP_ARPREP = 2,
  NETWIB_ARPHDROP_RARPREQ = 3,
  NETWIB_ARPHDROP_RARPREP = 4
} netwib_arphdrop;
typedef struct
{ netwib_arphdrop op;
  netwib_eth ethsrc;
  netwib_ip ipsrc;
  netwib_eth ethdst;
  netwib_ip ipdst;
} netwib_arphdr;
typedef const netwib_arphdr netwib_constarphdr;
#define NETWIB_ARPHDR_LEN 28
/*-------------------------------------------------------------*/
/* Name : netwib_arphdr_initdefault
   Description :
     Initialize a netwib_arphdr with default values.
   Input parameter(s) :
   Input/output parameter(s) :
   Output parameter(s) :
     *parphdr : netwib_arphdr to initialize
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_arphdr_initdefault(netwib_arphdr *parphdr);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_append_arphdr
   Description :
     Initialize physical data from a netwib_arphdr.
   Input parameter(s) :
     *parphdr : netwib_arphdr
   Input/output parameter(s) :
     *ppht : buffer to initialize
   Output parameter(s) :
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_append_arphdr(netwib_constarphdr *parphdr,
                                    netwib_buf *ppkt);
netwib_err netwib_pkt_prepend_arphdr(netwib_constarphdr *parphdr,
                                     netwib_buf *ppkt);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_decode_arphdr
   Description :
     Decode a netwib_arphdr from physical data.
   Input parameter(s) :
     *ppkt : buffer containing physical data
   Input/output parameter(s) :
   Output parameter(s) :
     *parphdr : netwib_arphdr contained in pkt
     *pskipsize : size to use to skip this header
   Normal return values :
     NETWIB_ERR_OK : ok
     NETWIB_ERR_NOTCONVERTED : pkt could not be decoded
     NETWIB_ERR_DATAMISSING : pkt was not big enough
*/
netwib_err netwib_pkt_decode_arphdr(netwib_constbuf *ppkt,
                                    netwib_arphdr *parphdr,
                                    netwib_uint32 *pskipsize);

/*-------------------------------------------------------------*/
/* TCP header */
typedef struct {
  netwib_port src;
  netwib_port dst;
  netwib_uint32 seqnum;
  netwib_uint32 acknum;
  netwib_uint8 doff;
  netwib_bool reserved1;
  netwib_bool reserved2;
  netwib_bool reserved3;
  netwib_bool reserved4;
  netwib_bool cwr; /* RFC 3168 */
  netwib_bool ece; /* RFC 3168 */
  netwib_bool urg;
  netwib_bool ack;
  netwib_bool psh;
  netwib_bool rst;
  netwib_bool syn;
  netwib_bool fin;
  netwib_uint16 window;
  netwib_uint16 check;
  netwib_uint16 urgptr;
  netwib_bufext opts; /* TCP options as defined in tcpopts.h */
} netwib_tcphdr;
typedef const netwib_tcphdr netwib_consttcphdr;
#define NETWIB_TCPHDR_MINLEN 20
#define NETWIB_TCPHDR_MAXLEN 64
/*-------------------------------------------------------------*/
/* Name : netwib_tcphdr_initdefault
   Description :
     Initialize a netwib_tcphdr with default values.
   Input parameter(s) :
   Input/output parameter(s) :
   Output parameter(s) :
     *ptcphdr : netwib_tcphdr to initialize
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_tcphdr_initdefault(netwib_tcphdr *ptcphdr);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_append_tcphdr
   Description :
     Initialize physical data from a netwib_tcphdr.
   Input parameter(s) :
     *ptcphdr : netwib_tcphdr
   Input/output parameter(s) :
     *ppht : buffer to initialize
   Output parameter(s) :
   Normal return values :
     NETWIB_ERR_OK : ok
   Note : field doff is eventually recomputed.
*/
netwib_err netwib_pkt_append_tcphdr(netwib_consttcphdr *ptcphdr,
                                    netwib_buf *ppkt);
netwib_err netwib_pkt_prepend_tcphdr(netwib_consttcphdr *ptcphdr,
                                     netwib_buf *ppkt);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_decode_tcphdr
   Description :
     Decode a netwib_tcphdr from physical data.
   Input parameter(s) :
     *ppkt : buffer containing physical data
   Input/output parameter(s) :
   Output parameter(s) :
     *ptcphdr : netwib_tcphdr contained in pkt
     *pskipsize : size to use to skip this header
   Normal return values :
     NETWIB_ERR_OK : ok
     NETWIB_ERR_NOTCONVERTED : pkt could not be decoded
     NETWIB_ERR_DATAMISSING : pkt was not big enough
*/
netwib_err netwib_pkt_decode_tcphdr(netwib_constbuf *ppkt,
                                    netwib_tcphdr *ptcphdr,
                                    netwib_uint32 *pskipsize);

/*-------------------------------------------------------------*/
/* UDP header */
typedef struct {
  netwib_port src;
  netwib_port dst;
  netwib_uint16 len;
  netwib_uint16 check;
} netwib_udphdr;
typedef const netwib_udphdr netwib_constudphdr;
#define NETWIB_UDPHDR_LEN 8
/*-------------------------------------------------------------*/
/* Name : netwib_udphdr_initdefault
   Description :
     Initialize a netwib_udphdr with default values.
   Input parameter(s) :
   Input/output parameter(s) :
   Output parameter(s) :
     *pudphdr : netwib_udphdr to initialize
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_udphdr_initdefault(netwib_udphdr *pudphdr);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_append_udphdr
   Description :
     Initialize physical data from a netwib_udphdr.
   Input parameter(s) :
     *pudphdr : netwib_udphdr
   Input/output parameter(s) :
     *ppht : buffer to initialize
   Output parameter(s) :
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_append_udphdr(netwib_constudphdr *pudphdr,
                                    netwib_buf *ppkt);
netwib_err netwib_pkt_prepend_udphdr(netwib_constudphdr *pudphdr,
                                     netwib_buf *ppkt);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_decode_udphdr
   Description :
     Decode a netwib_udphdr from physical data.
   Input parameter(s) :
     *ppkt : buffer containing physical data
   Input/output parameter(s) :
   Output parameter(s) :
     *pudphdr : netwib_udphdr contained in pkt
     *pskipsize : size to use to skip this header
   Normal return values :
     NETWIB_ERR_OK : ok
     NETWIB_ERR_NOTCONVERTED : pkt could not be decoded
     NETWIB_ERR_DATAMISSING : pkt was not big enough
*/
netwib_err netwib_pkt_decode_udphdr(netwib_constbuf *ppkt,
                                    netwib_udphdr *pudphdr,
                                    netwib_uint32 *pskipsize);

/*-------------------------------------------------------------*/
typedef enum {
  NETWIB_TCPOPTTYPE_END = 0,          /* rfc 793 - end of options */
  NETWIB_TCPOPTTYPE_NOOP = 1,         /* rfc 793 - no operation */
  NETWIB_TCPOPTTYPE_MSS = 2,          /* rfc 793 - maximum segment size */
  NETWIB_TCPOPTTYPE_WINDOWSCALE = 3,  /* rfc 1323 - window scale */
  NETWIB_TCPOPTTYPE_SACKPERMITTED = 4,/* rfc 2018 - SACK permitted */
  NETWIB_TCPOPTTYPE_SACK = 5,    /* rfc 2018 - selective acknowledgment */
  NETWIB_TCPOPTTYPE_ECHOREQUEST = 6,  /* rfc 1072 - echo request */
  NETWIB_TCPOPTTYPE_ECHOREPLY = 7,    /* rfc 1072 - echo reply */
  NETWIB_TCPOPTTYPE_TIMESTAMP = 8,    /* rfc 1323 - timestamp */
  NETWIB_TCPOPTTYPE_CC = 11,          /* rfc 1644 - connection count */
  NETWIB_TCPOPTTYPE_CCNEW = 12,       /* rfc 1644 - connection count */
  NETWIB_TCPOPTTYPE_CCECHO = 13       /* rfc 1644 - connection count */
} netwib_tcpopttype;
/*-------------------------------------------------------------*/
/* maximum length of one TCP option */
#define NETWIB_TCPOPT_MAXLEN 40
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint16 maxsegsize;
} netwib_tcpopt_mss;
typedef const netwib_tcpopt_mss netwib_consttcpopt_mss;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint8 windowscale;
} netwib_tcpopt_windowscale;
typedef const netwib_tcpopt_windowscale netwib_consttcpopt_windowscale;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint32 storedvalues; /* 0 to 4 */
  netwib_uint32 leftedge[4];
  netwib_uint32 rightedge[4];
} netwib_tcpopt_sack;
typedef const netwib_tcpopt_sack netwib_consttcpopt_sack;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint32 data;
} netwib_tcpopt_echo;
typedef const netwib_tcpopt_echo netwib_consttcpopt_echo;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint32 val;
  netwib_uint32 echoreply;
} netwib_tcpopt_timestamp;
typedef const netwib_tcpopt_timestamp netwib_consttcpopt_timestamp;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint32 connectioncount;
} netwib_tcpopt_cc;
typedef const netwib_tcpopt_cc netwib_consttcpopt_cc;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_tcpopttype type;
  union {
    /* type end : no value */
    /* type noop : no value */
    netwib_tcpopt_mss mss;
    netwib_tcpopt_windowscale windowscale;
    /* type sackpermitted : no value */
    netwib_tcpopt_sack sack;
    netwib_tcpopt_echo echo; /* used for request and reply */
    netwib_tcpopt_timestamp timestamp;
    netwib_tcpopt_cc cc; /* used for cc, ccnew and ccecho */
  } opt;
} netwib_tcpopt;
typedef const netwib_tcpopt netwib_consttcpopt;
/*-------------------------------------------------------------*/
/* Name : netwib_tcpopt_initdefault
   Description :
     Initialize a netwib_tcpopt with default values.
   Input parameter(s) :
   Input/output parameter(s) :
   Output parameter(s) :
     *ptcpopt : netwib_tcpopt to initialize
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_tcpopt_initdefault(netwib_tcpopttype tcpopttype,
                                     netwib_tcpopt *ptcpopt);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_append_tcpopt
   Description :
     Initialize physical data from a netwib_tcpopt.
   Input parameter(s) :
     tcpopt : netwib_tcpopt
   Input/output parameter(s) :
     *ppht : buffer to initialize
   Output parameter(s) :
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_append_tcpopt(netwib_consttcpopt *ptcpopt,
                                    netwib_buf *ppkt);
netwib_err netwib_pkt_prepend_tcpopt(netwib_consttcpopt *ptcpopt,
                                     netwib_buf *ppkt);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_decode_tcpopt
   Description :
     Decode a netwib_tcpopt from data coming from wire.
   Input parameter(s) :
     *ppkt : buffer containing physical data
   Input/output parameter(s) :
   Output parameter(s) :
     *ptcpopt : netwib_tcpopt to initialize
     *pskipsize : size to skip this option
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_decode_tcpopt(netwib_constbuf *ppkt,
                                    netwib_tcpopt *ptcpopt,
                                    netwib_uint32 *pskipsize);

/*-------------------------------------------------------------*/
/***************************************************************
 * A "netwib_tcpopts" is a netwib_buf storing 0, 1 or more     *
 * netwib_tcpopt. There is no typedef for netwib_tcpopts.      *
 ***************************************************************/
/*-------------------------------------------------------------*/
/* maximum length of a buffer containing a "netwib_tcpopts" */
#define NETWIB_TCPOPTS_MAXLEN 40
/*-------------------------------------------------------------*/
/***************************************************************
 * To create a "netwib_tcpopts", loop using function           *
 * netwib_pkt_append_tcpopt.                                   *
 * To decode a "netwib_tcpopts", loop using function           *
 * netwib_pkt_decode_tcpopt.                                   *
 ***************************************************************/

/*-------------------------------------------------------------*/
/* Name : netwib_ip64bits_init_ippkt
   Description :
     Initialize a buffer containing an IP header and
     64 bits of data.
     This kind of packets are needed for errors (cf. rfc 792).
   Input parameter(s) :
     *piphdr : IP header
     *pipdata : IP data
     *phdrudp : udp header
     *phdrtcp : tcp header
   Input/output parameter(s) :
   Output parameter(s) :
     *pip64bits : buffer containing an IP header and
                  64 bits of data.
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_ip64bits_init_ippkt(netwib_constbuf *pippkt,
                                      netwib_bufext *pip64bits);
/*-------------------------------------------------------------*/
/* Name : netwib_ip64bits_decode_ipxyz
   Description :
     Try to decode ip packet contained in ip64bits.
   Input parameter(s) :
     *pip64bits : ip header and at least 64 bits of ip data
   Input/output parameter(s) :
   Output parameter(s) :
     *piphdr : decoded IP header
     *pipdata : buffer containing ip data
     *pudpsrc : udp source port
     *pudpdst : udp destination port
     *pudplen : udp len
     *pudpcheck : udp checksum
     *ptcpsrc : tcp source port
     *ptcpdst : tcp destination port
     *pseqnum : tcp sequence number
   Normal return values :
     NETWIB_ERR_OK : ok
     NETWIB_ERR_NOTCONVERTED : packet not decoded
     NETWIB_ERR_DATAMISSING : pkt was not big enough
*/
netwib_err netwib_ip64bits_decode_ipudp(netwib_constbuf *pip64bits,
                                        netwib_iphdr *piphdr,
                                        netwib_port *pudpsrc,
                                        netwib_port *pudpdst);
netwib_err netwib_ip64bits_decode_iptcp(netwib_constbuf *pip64bits,
                                        netwib_iphdr *piphdr,
                                        netwib_port *ptcpsrc,
                                        netwib_port *ptcpdst);
#define netwib_ip64bits_decode_ipdata(pip64bits,piphdr,pipdata) netwib_pkt_decode_ipdata(pip64bits,piphdr,pipdata)

/*-------------------------------------------------------------*/
/***************************************************************
 * Refer to RFC 792 to obtain more information about ICMPv4.   *
 ***************************************************************/
/*-------------------------------------------------------------*/
/* ICMP4 types. Comments starting with "NI" are not implemented */
typedef enum {
  NETWIB_ICMP4TYPE_ECHOREP = 0,       /* echo reply */
  NETWIB_ICMP4TYPE_DSTUNREACH = 3,    /* destination unreachable */
  NETWIB_ICMP4TYPE_SRCQUENCH = 4,     /* source quench */
  NETWIB_ICMP4TYPE_REDIRECT = 5,      /* redirect */
  NETWIB_ICMP4TYPE_ALTHOSTAD = 6,     /* NI www.iana.org */
  NETWIB_ICMP4TYPE_ECHOREQ = 8,       /* echo request */
  NETWIB_ICMP4TYPE_ROUTERADVERT = 9,  /* NI rfc 1256 */
  NETWIB_ICMP4TYPE_ROUTERSELECT = 10, /* NI rfc 1256 */
  NETWIB_ICMP4TYPE_TIMEEXCEED = 11,   /* time exceeded */
  NETWIB_ICMP4TYPE_PARAPROB = 12,     /* parameter problem */
  NETWIB_ICMP4TYPE_TIMESTAMPREQ = 13, /* timestamp request */
  NETWIB_ICMP4TYPE_TIMESTAMPREP = 14, /* timestamp reply */
  NETWIB_ICMP4TYPE_INFOREQ = 15,      /* information request */
  NETWIB_ICMP4TYPE_INFOREP = 16,      /* information reply */
  NETWIB_ICMP4TYPE_ADMASKREQ = 17,    /* NI rfc 950 */
  NETWIB_ICMP4TYPE_ADMASKREP = 18,    /* NI rfc 950 */
  NETWIB_ICMP4TYPE_TRACEROUTE = 30,   /* NI rfc 1393 */
  NETWIB_ICMP4TYPE_DATACONVERR = 31,  /* NI rfc 1474 */
  NETWIB_ICMP4TYPE_MOBHOSTREDIR = 32, /* NI www.iana.org */
  NETWIB_ICMP4TYPE_IPV6WHEREYOU = 33, /* NI www.iana.org */
  NETWIB_ICMP4TYPE_IPV6IAMHERE = 34,  /* NI www.iana.org */
  NETWIB_ICMP4TYPE_MOBREGREQ = 35,    /* NI www.iana.org */
  NETWIB_ICMP4TYPE_MOBREGREP = 36,    /* NI www.iana.org */
  NETWIB_ICMP4TYPE_SKIP = 39,         /* NI www.iana.org */
  NETWIB_ICMP4TYPE_PHOTURIS = 40      /* NI www.iana.org */
} netwib_icmp4type;
/*-------------------------------------------------------------*/
typedef enum {
  NETWIB_ICMP4CODE_ECHOREP = 0,
  NETWIB_ICMP4CODE_DSTUNREACH_NET = 0,
  NETWIB_ICMP4CODE_DSTUNREACH_HOST = 1,
  NETWIB_ICMP4CODE_DSTUNREACH_PROTO = 2,
  NETWIB_ICMP4CODE_DSTUNREACH_PORT = 3,
  NETWIB_ICMP4CODE_DSTUNREACH_FRAG = 4,
  NETWIB_ICMP4CODE_DSTUNREACH_SR = 5,
  NETWIB_ICMP4CODE_DSTUNREACH_NETUNKNOWN = 6,
  NETWIB_ICMP4CODE_DSTUNREACH_HOSTUNKNOWN = 7,
  NETWIB_ICMP4CODE_DSTUNREACH_HOSTISOL = 8,
  NETWIB_ICMP4CODE_DSTUNREACH_NETPROHI = 9,
  NETWIB_ICMP4CODE_DSTUNREACH_HOSTPROHI = 10,
  NETWIB_ICMP4CODE_DSTUNREACH_NETTOS = 11,
  NETWIB_ICMP4CODE_DSTUNREACH_HOSTTOS = 12,
  NETWIB_ICMP4CODE_DSTUNREACH_PROHI = 13,
  NETWIB_ICMP4CODE_DSTUNREACH_PRECVIOL = 14,
  NETWIB_ICMP4CODE_DSTUNREACH_PRECCUTOFF = 15,
  NETWIB_ICMP4CODE_SRCQUENCH = 0,
  NETWIB_ICMP4CODE_REDIRECT_NET = 0,
  NETWIB_ICMP4CODE_REDIRECT_HOST = 1,
  NETWIB_ICMP4CODE_REDIRECT_NETTOS = 2,
  NETWIB_ICMP4CODE_REDIRECT_HOSTTOS = 3,
  NETWIB_ICMP4CODE_ECHOREQ = 0,
  NETWIB_ICMP4CODE_TIMEEXCEED_TTL = 0,
  NETWIB_ICMP4CODE_TIMEEXCEED_FRAG = 1,
  NETWIB_ICMP4CODE_PARAPROB_POINTER = 0,
  NETWIB_ICMP4CODE_PARAPROB_MISSOPT = 1,
  NETWIB_ICMP4CODE_PARAPROB_BADLEN = 2,
  NETWIB_ICMP4CODE_TIMESTAMPREQ = 0,
  NETWIB_ICMP4CODE_TIMESTAMPREP = 0,
  NETWIB_ICMP4CODE_INFOREQ = 0,
  NETWIB_ICMP4CODE_INFOREP = 0
} netwib_icmp4code;
/*-------------------------------------------------------------*/
/* Name : netwib_buf_append_icmp4type
   Description :
     Print the text corresponding to icmp type.
   Input parameter(s) :
     type : icmp4 type
   Input/output parameter(s) :
     *pbuf : netwib_buf receiving data
   Output parameter(s) :
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_buf_append_icmp4type(netwib_icmp4type type,
                                       netwib_buf *pbuf);
/*-------------------------------------------------------------*/
/* Name : netwib_buf_append_icmp4code
   Description :
     Print the text corresponding to icmp code.
   Input parameter(s) :
     type : icmp4 type
     code : icmp4 code
   Input/output parameter(s) :
     *pbuf : netwib_buf receiving data
   Output parameter(s) :
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_buf_append_icmp4code(netwib_icmp4type type,
                                       netwib_icmp4code code,
                                       netwib_buf *pbuf);
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint16 id;
  netwib_uint16 seqnum;
  netwib_bufext data;
} netwib_icmp4_echo;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint32 reserved;
  netwib_bufext badippacket;
} netwib_icmp4_dstunreach;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint32 reserved;
  netwib_bufext badippacket;
} netwib_icmp4_srcquench;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_ip gw;
  netwib_bufext badippacket;
} netwib_icmp4_redirect;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint32 reserved;
  netwib_bufext badippacket;
} netwib_icmp4_timeexceed;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint8 pointer;
  netwib_uint32 reserved;
  netwib_bufext badippacket;
} netwib_icmp4_paraprob;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint16 id;
  netwib_uint16 seqnum;
  netwib_uint32 originatetimestamp;
  netwib_uint32 receivetimestamp;
  netwib_uint32 transmittimestamp;
} netwib_icmp4_timestamp;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint16 id;
  netwib_uint16 seqnum;
  netwib_bufext data;
} netwib_icmp4_info;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_icmp4type type;
  netwib_icmp4code code;
  netwib_uint16 check;
  union {
    netwib_icmp4_echo echo; /* used for request and reply */
    netwib_icmp4_dstunreach dstunreach;
    netwib_icmp4_srcquench srcquench;
    netwib_icmp4_redirect redirect;
    netwib_icmp4_timeexceed timeexceed;
    netwib_icmp4_paraprob paraprob;
    netwib_icmp4_timestamp timestamp; /* used for req and rep */
    netwib_icmp4_info info; /* used for request and reply */
  } msg;
} netwib_icmp4;
typedef const netwib_icmp4 netwib_consticmp4;
#define NETWIB_ICMP4_MINLEN 4
/*-------------------------------------------------------------*/
/* Name : netwib_icmp4_initdefault
   Description :
     Initialize a netwib_icmp4 with default values.
   Input parameter(s) :
   Input/output parameter(s) :
   Output parameter(s) :
     *picmp4hdr : netwib_icmp4hdr to initialize
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_icmp4_initdefault(netwib_icmp4type type,
                                    netwib_icmp4 *picmp4);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_append_icmp4
   Description :
     Initialize physical data from a netwib_icmp4.
   Input parameter(s) :
     icmp4 : netwib_icmp4
   Input/output parameter(s) :
     *ppht : buffer to initialize
   Output parameter(s) :
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_append_icmp4(netwib_consticmp4 *picmp4,
                                   netwib_buf *ppkt);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_decode_icmp4
   Description :
     Decode a netwib_icmp4 from data coming from wire.
   Input parameter(s) :
     pktproto : protocol of the netwib_icmp4 in ppkt
     *ppkt : buffer containing physical data
   Input/output parameter(s) :
   Output parameter(s) :
     *picmp4 : netwib_icmp4 to initialize
     *pskipsize : size to skip this header
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_decode_icmp4(netwib_constbuf *ppkt,
                                   netwib_icmp4 *picmp4,
                                   netwib_uint32 *pskipsize);

/*-------------------------------------------------------------*/
/***************************************************************
 * Refer to RFC 2463 to obtain more information about ICMPv6.  *
 ***************************************************************/
/*-------------------------------------------------------------*/
/* ICMP6 types. Comments starting with "NI" are not implemented */
typedef enum {
  NETWIB_ICMP6TYPE_DSTUNREACH = 1,    /* destination unreachable */
  NETWIB_ICMP6TYPE_PKTTOOBIG = 2,     /* packet too big */
  NETWIB_ICMP6TYPE_TIMEEXCEED = 3,    /* time exceeded */
  NETWIB_ICMP6TYPE_PARAPROB = 4,      /* parameter problem */
  NETWIB_ICMP6TYPE_ECHOREQ = 128,     /* echo request */
  NETWIB_ICMP6TYPE_ECHOREP = 129,     /* echo reply */
  NETWIB_ICMP6TYPE_ROUTERSOLICIT = 133, /* router solicitation (rfc2461) */
  NETWIB_ICMP6TYPE_ROUTERADVERT = 134,    /* router advert. (rfc2461) */
  NETWIB_ICMP6TYPE_NEIGHBORSOLICIT = 135, /* neighbor soli. (rfc2461) */
  NETWIB_ICMP6TYPE_NEIGHBORADVERT = 136,  /* neighbor advert. (rfc2461) */
  NETWIB_ICMP6TYPE_REDIRECT = 137         /* redirect (rfc2461) */
} netwib_icmp6type;
/*-------------------------------------------------------------*/
typedef enum {
  NETWIB_ICMP6CODE_DSTUNREACH_NOROUTE = 0,
  NETWIB_ICMP6CODE_DSTUNREACH_PROHI = 1,
  NETWIB_ICMP6CODE_DSTUNREACH_HOST = 3,
  NETWIB_ICMP6CODE_DSTUNREACH_PORT = 4,
  NETWIB_ICMP6CODE_PKTTOOBIG = 0,
  NETWIB_ICMP6CODE_TIMEEXCEED_TTL = 0,
  NETWIB_ICMP6CODE_TIMEEXCEED_FRAG = 1,
  NETWIB_ICMP6CODE_PARAPROB_HDR = 0,
  NETWIB_ICMP6CODE_PARAPROB_NEXTHDR = 1,
  NETWIB_ICMP6CODE_PARAPROB_OPTION = 2,
  NETWIB_ICMP6CODE_ECHOREQ = 0,
  NETWIB_ICMP6CODE_ECHOREP = 0,
  NETWIB_ICMP6CODE_ROUTERSOLICIT = 0,
  NETWIB_ICMP6CODE_ROUTERADVERT = 0,
  NETWIB_ICMP6CODE_NEIGHBORSOLICIT = 0,
  NETWIB_ICMP6CODE_NEIGHBORADVERT = 0,
  NETWIB_ICMP6CODE_REDIRECT = 0
} netwib_icmp6code;
/*-------------------------------------------------------------*/
/* Name : netwib_buf_append_icmp6type
   Description :
     Print the text corresponding to icmp type.
   Input parameter(s) :
     type : icmp6 type
   Input/output parameter(s) :
     *pbuf : netwib_buf receiving data
   Output parameter(s) :
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_buf_append_icmp6type(netwib_icmp6type type,
                                       netwib_buf *pbuf);
/*-------------------------------------------------------------*/
/* Name : netwib_buf_append_icmp6code
   Description :
     Print the text corresponding to icmp code.
   Input parameter(s) :
     type : icmp6 type
     code : icmp6 code
   Input/output parameter(s) :
     *pbuf : netwib_buf receiving data
   Output parameter(s) :
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_buf_append_icmp6code(netwib_icmp6type type,
                                       netwib_icmp6code code,
                                       netwib_buf *pbuf);
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint32 reserved;
  netwib_bufext badippacket;
} netwib_icmp6_dstunreach;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint32 mtu;
  netwib_bufext badippacket;
} netwib_icmp6_pkttoobig;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint32 reserved;
  netwib_bufext badippacket;
} netwib_icmp6_timeexceed;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint32 pointer;
  netwib_bufext badippacket;
} netwib_icmp6_paraprob;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint16 id;
  netwib_uint16 seqnum;
  netwib_bufext data;
} netwib_icmp6_echo;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint32 reserved;
  netwib_bufext options; /* buffer contains netwib_icmp6nd */
} netwib_icmp6_routersolicit;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint8 curhoplimit;
  netwib_bool managedaddress;
  netwib_bool otherstateful;
  netwib_uint8 reserved;
  netwib_uint16 routerlifetime;
  netwib_uint32 reachabletime;
  netwib_uint32 retranstimer;
  netwib_bufext options; /* buffer contains netwib_icmp6nd */
} netwib_icmp6_routeradvert;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint32 reserved;
  netwib_ip target;
  netwib_bufext options; /* buffer contains netwib_icmp6nd */
} netwib_icmp6_neighborsolicit;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_bool router;
  netwib_bool solicited;
  netwib_bool override;
  netwib_uint32 reserved;
  netwib_ip target;
  netwib_bufext options; /* buffer contains netwib_icmp6nd */
} netwib_icmp6_neighboradvert;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_uint32 reserved;
  netwib_ip target;
  netwib_ip dst;
  netwib_bufext options; /* buffer contains netwib_icmp6nd */
} netwib_icmp6_redirect;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_icmp6type type;
  netwib_icmp6code code;
  netwib_uint16 check;
  union {
    netwib_icmp6_dstunreach dstunreach;
    netwib_icmp6_pkttoobig pkttoobig;
    netwib_icmp6_timeexceed timeexceed;
    netwib_icmp6_paraprob paraprob;
    netwib_icmp6_echo echo; /* used for request and reply */
    netwib_icmp6_routersolicit routersolicit;
    netwib_icmp6_routeradvert routeradvert;
    netwib_icmp6_neighborsolicit neighborsolicit;
    netwib_icmp6_neighboradvert neighboradvert;
    netwib_icmp6_redirect redirect;
  } msg;
} netwib_icmp6;
typedef const netwib_icmp6 netwib_consticmp6;
#define NETWIB_ICMP6_MINLEN 4
/*-------------------------------------------------------------*/
/* Name : netwib_icmp6_initdefault
   Description :
     Initialize a netwib_icmp6 with default values.
   Input parameter(s) :
   Input/output parameter(s) :
   Output parameter(s) :
     *picmp6hdr : netwib_icmp6hdr to initialize
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_icmp6_initdefault(netwib_icmp6type type,
                                    netwib_icmp6 *picmp6);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_append_icmp6
   Description :
     Initialize physical data from a netwib_icmp6.
   Input parameter(s) :
     icmp6 : netwib_icmp6
   Input/output parameter(s) :
     *ppht : buffer to initialize
   Output parameter(s) :
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_append_icmp6(netwib_consticmp6 *picmp6,
                                   netwib_buf *ppkt);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_decode_icmp6
   Description :
     Decode a netwib_icmp6 from data coming from wire.
   Input parameter(s) :
     pktproto : protocol of the netwib_icmp6 in ppkt
     *ppkt : buffer containing physical data
   Input/output parameter(s) :
   Output parameter(s) :
     *picmp6 : netwib_icmp6 to initialize
     *pskipsize : size to skip this header
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_decode_icmp6(netwib_constbuf *ppkt,
                                   netwib_icmp6 *picmp6,
                                   netwib_uint32 *pskipsize);

/*-------------------------------------------------------------*/
/***************************************************************
 * Refer to RFC 2461 to obtain more information about ICMPv6   *
 * Neighbor Discovery options.                                 *
 ***************************************************************/
/*-------------------------------------------------------------*/
typedef enum {
  NETWIB_ICMP6NDTYPE_SRCLINK = 1, /* src link layer address */
  NETWIB_ICMP6NDTYPE_DSTLINK = 2, /* dst link layer address */
  NETWIB_ICMP6NDTYPE_PREFIX = 3,  /* prefix information */
  NETWIB_ICMP6NDTYPE_REDIR = 4,   /* redirected */
  NETWIB_ICMP6NDTYPE_MTU = 5      /* mtu */
} netwib_icmp6ndtype;
/*-------------------------------------------------------------*/
typedef struct {
  netwib_eth linkad;
} netwib_icmp6nd_link;
typedef const netwib_icmp6nd_link netwib_consticmp6nd_link;
typedef struct {
  netwib_uint8 prefixlength;
  netwib_bool onlink;
  netwib_bool autonomous;
  netwib_uint8 reserved1;
  netwib_uint32 validlifetime;
  netwib_uint32 preferredlifetime;
  netwib_uint32 reserved2;
  netwib_ip prefix;
} netwib_icmp6nd_prefix;
typedef const netwib_icmp6nd_prefix netwib_consticmp6nd_prefix;
typedef struct {
  netwib_uint16 reserved1;
  netwib_uint32 reserved2;
  netwib_bufext badippacket;
} netwib_icmp6nd_redir;
typedef const netwib_icmp6nd_redir netwib_consticmp6nd_redir;
typedef struct {
  netwib_uint16 reserved;
  netwib_uint32 mtu;
} netwib_icmp6nd_mtu;
typedef const netwib_icmp6nd_mtu netwib_consticmp6nd_mtu;
typedef struct {
  netwib_icmp6ndtype type;
  union {
    netwib_icmp6nd_link link;
    netwib_icmp6nd_prefix prefix;
    netwib_icmp6nd_redir redir;
    netwib_icmp6nd_mtu mtu;
  } opt;
} netwib_icmp6nd;
typedef const netwib_icmp6nd netwib_consticmp6nd;
/*-------------------------------------------------------------*/
/* Name : netwib_icmp6nd_initdefault
   Description :
     Initialize a netwib_icmp6nd with default values.
   Input parameter(s) :
   Input/output parameter(s) :
   Output parameter(s) :
     *picmp6nd : netwib_icmp6nd to initialize
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_icmp6nd_initdefault(netwib_icmp6ndtype icmp6ndtype,
                                      netwib_icmp6nd *picmp6nd);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_append_icmp6nd
   Description :
     Initialize physical data from a netwib_icmp6nd.
   Input parameter(s) :
     icmp6nd : netwib_icmp6nd
   Input/output parameter(s) :
     *ppht : buffer to initialize
   Output parameter(s) :
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_append_icmp6nd(netwib_consticmp6nd *picmp6nd,
                                     netwib_buf *ppkt);
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_decode_icmp6nd
   Description :
     Decode a netwib_icmp6nd from data coming from wire.
   Input parameter(s) :
     *ppkt : buffer containing physical data
   Input/output parameter(s) :
   Output parameter(s) :
     *picmp6nd : netwib_icmp6nd to initialize
     *pskipsize : size to skip this option
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_decode_icmp6nd(netwib_constbuf *ppkt,
                                     netwib_icmp6nd *picmp6nd,
                                     netwib_uint32 *pskipsize);

/*-------------------------------------------------------------*/
/***************************************************************
 * Following functions create/decode layers. Their names       *
 * should be self explaining.                                  *
 * Note : when decoding a layer, ppkt buffer is automatically  *
 *        shifted to point to next entry.                      *
 ***************************************************************/
/*-------------------------------------------------------------*/
/***************************************************************
 * Some header fields are computed by functions append_layer:  *
 *  - linkhdr.ethhdr.type                                      *
 *  - iphdr.protocol                                           *
 *  - iphdr.header.ip4.ihl                                     *
 *  - iphdr.header.ip4.totlen                                  *
 *  - iphdr.header.ip4.check                                   *
 *  - iphdr.header.ip6.payloadlength                           *
 *  - udphdr.len                                               *
 *  - udphdr.check                                             *
 *  - tcphdr.doff                                              *
 *  - tcphdr.check                                             *
 *  - icmp4hdr.check                                           *
 * To use fake values for those fields, they have to be edited *
 * after packet construction.                                  *
 ***************************************************************/
/*-------------------------------------------------------------*/
/***************************************************************
 * Which functions to use ?                                    *
 *                                                             *
 * Netwib has 3 kind of functions to decode packets:           *
 *  - netwib_pkt_decode_abc ie netwib_pkt_decode_iphdr         *
 *  - netwib_pkt_decode_layer_abc ie netwib_pkt_decode_layer_ip*
 *  - netwib_pkt_decode_abcABC ie netwib_pkt_decode_iptcp      *
 * Functions netwib_pkt_decode_abc and                         *
 * netwib_pkt_decode_layer_abc are almost equivalent.          *
 * Functions netwib_pkt_decode_abcABC permits to decode only   *
 * one kind of protocol : ABC on top of abc. So, they can only *
 * be used in simple cases.                                    *
 *                                                             *
 * Netwib has 3 kind of functions to create packets:           *
 *  - netwib_pkt_append_abc ie netwib_pkt_append_iphdr         *
 *  - netwib_pkt_append_layer_abc ie netwib_pkt_append_layer_ip*
 *  - netwib_pkt_append_abcABC ie netwib_pkt_append_iptcp      *
 * Functions netwib_pkt_append_abc use exact fields given as   *
 * parameters from users.                                      *
 * Functions netwib_pkt_append_layer_abc compute fields before *
 * storing them in the packet.                                 *
 * Functions netwib_pkt_append_abcABC permits to create only   *
 * one kind of protocol : ABC on top of abc. So, they can only *
 * be used in simple cases.                                    *
 *                                                             *
 * Summary: when possible, use netwib_pkt_append/decode_layer  *
 *          which are :                                        *
 *           - easier than netwib_pkt_append/decode_abc        *
 *             because they compute fields                     *
 *           - faster than netwib_pkt_append/decode_abcABC     *
 *             if several protocols of the same layer have to  *
 *             be decoded (for example : iptcp and ipudp)      *
 ***************************************************************/
/*-------------------------------------------------------------*/
netwib_err netwib_pkt_append_layer_data(netwib_constbuf *pdata,
                                        netwib_buf *ppkt);
netwib_err netwib_pkt_decode_layer_data(netwib_buf *ppkt,
                                        netwib_bufext *pdata);
/*-------------------------------------------------------------*/
netwib_err netwib_pkt_append_layer_link(netwib_constlinkhdr *plinkhdr,
                                        netwib_buf *ppkt);
netwib_err netwib_pkt_decode_layer_link(netwib_device_dlttype dlttype,
                                        netwib_buf *ppkt,
                                        netwib_linkhdr *plinkhdr);
/*-------------------------------------------------------------*/
netwib_err netwib_pkt_append_layer_ip(netwib_constiphdr *piphdr,
                                      netwib_uint32 datasize,
                                      netwib_buf *ppkt);
netwib_err netwib_pkt_decode_layer_ip(netwib_buf *ppkt,
                                      netwib_iphdr *piphdr);
/*-------------------------------------------------------------*/
/* fields followed by "checksum" are needed only for checksum
   computation */
netwib_err netwib_pkt_append_layer_udp(netwib_constiphdr *piphdr,/*checksum*/
                                       netwib_constudphdr *pudphdr,
                                       netwib_constbuf *pudpdata,/*checksum*/
                                       netwib_buf *ppkt);
netwib_err netwib_pkt_decode_layer_udp(netwib_buf *ppkt,
                                       netwib_udphdr *pudphdr);
/*-------------------------------------------------------------*/
netwib_err netwib_pkt_append_layer_tcp(netwib_constiphdr *piphdr,/*checksum*/
                                       netwib_consttcphdr *ptcphdr,
                                       netwib_constbuf *ptcpdata,/*checksum*/
                                       netwib_buf *ppkt);
netwib_err netwib_pkt_decode_layer_tcp(netwib_buf *ppkt,
                                       netwib_tcphdr *ptcphdr);
/*-------------------------------------------------------------*/
netwib_err netwib_pkt_append_layer_icmp4(netwib_consticmp4 *picmp4,
                                         netwib_buf *ppkt);
netwib_err netwib_pkt_decode_layer_icmp4(netwib_buf *ppkt,
                                         netwib_icmp4 *picmp4);
/*-------------------------------------------------------------*/
netwib_err netwib_pkt_append_layer_icmp6(netwib_constiphdr *piphdr,
                                         netwib_consticmp6 *picmp6,
                                         netwib_buf *ppkt);
netwib_err netwib_pkt_decode_layer_icmp6(netwib_buf *ppkt,
                                         netwib_icmp6 *picmp6);
/*-------------------------------------------------------------*/
netwib_err netwib_pkt_append_layer_arp(netwib_constarphdr *parphdr,
                                       netwib_buf *ppkt);
netwib_err netwib_pkt_decode_layer_arp(netwib_buf *ppkt,
                                       netwib_arphdr *parphdr);

/*-------------------------------------------------------------*/
/***************************************************************
 * Following functions create/decode packets. Their names      *
 * should be self explaining. They are specialized in decoding *
 * one kind of packet. To support several kind of packets, use *
 * netwib_pkt_decode_layer_abc instead.                        *
 ***************************************************************/
/*-------------------------------------------------------------*/
netwib_err netwib_pkt_append_linkdata(netwib_constlinkhdr *plinkhdr,
                                      netwib_constbuf *pdata,
                                      netwib_buf *ppkt);
netwib_err netwib_pkt_decode_linkdata(netwib_device_dlttype dlttype,
                                      netwib_constbuf *ppkt,
                                      netwib_linkhdr *plinkhdr,
                                      netwib_bufext *pdata);
/*-------------------------------------------------------------*/
netwib_err netwib_pkt_append_ipdata(netwib_constiphdr *piphdr,
                                    netwib_constbuf *pdata,
                                    netwib_buf *ppkt);
netwib_err netwib_pkt_decode_ipdata(netwib_constbuf *ppkt,
                                    netwib_iphdr *piphdr,
                                    netwib_bufext *pdata);
netwib_err netwib_pkt_append_linkipdata(netwib_constlinkhdr *plinkhdr,
                                        netwib_constiphdr *piphdr,
                                        netwib_constbuf *pdata,
                                        netwib_buf *ppkt);
netwib_err netwib_pkt_decode_linkipdata(netwib_device_dlttype dlttype,
                                        netwib_constbuf *ppkt,
                                        netwib_linkhdr *plinkhdr,
                                        netwib_iphdr *piphdr,
                                        netwib_bufext *pdata);
/*-------------------------------------------------------------*/
netwib_err netwib_pkt_append_ipudpdata(netwib_constiphdr *piphdr,
                                       netwib_constudphdr *pudphdr,
                                       netwib_constbuf *pdata,
                                       netwib_buf *ppkt);
netwib_err netwib_pkt_decode_ipudpdata(netwib_constbuf *ppkt,
                                       netwib_iphdr *piphdr,
                                       netwib_udphdr *pudphdr,
                                       netwib_bufext *pdata);
netwib_err netwib_pkt_append_linkipudpdata(netwib_constlinkhdr *plinkhdr,
                                           netwib_constiphdr *piphdr,
                                           netwib_constudphdr *pudphdr,
                                           netwib_constbuf *pdata,
                                           netwib_buf *ppkt);
netwib_err netwib_pkt_decode_linkipudpdata(netwib_device_dlttype dlttype,
                                           netwib_constbuf *ppkt,
                                           netwib_linkhdr *plinkhdr,
                                           netwib_iphdr *piphdr,
                                           netwib_udphdr *pudphdr,
                                           netwib_bufext *pdata);
/*-------------------------------------------------------------*/
netwib_err netwib_pkt_append_iptcpdata(netwib_constiphdr *piphdr,
                                       netwib_consttcphdr *ptcphdr,
                                       netwib_constbuf *pdata,
                                       netwib_buf *ppkt);
netwib_err netwib_pkt_decode_iptcpdata(netwib_constbuf *ppkt,
                                       netwib_iphdr *piphdr,
                                       netwib_tcphdr *ptcphdr,
                                       netwib_bufext *pdata);
netwib_err netwib_pkt_append_linkiptcpdata(netwib_constlinkhdr *plinkhdr,
                                           netwib_constiphdr *piphdr,
                                           netwib_consttcphdr *ptcphdr,
                                           netwib_constbuf *pdata,
                                           netwib_buf *ppkt);
netwib_err netwib_pkt_decode_linkiptcpdata(netwib_device_dlttype dlttype,
                                           netwib_constbuf *ppkt,
                                           netwib_linkhdr *plinkhdr,
                                           netwib_iphdr *piphdr,
                                           netwib_tcphdr *ptcphdr,
                                           netwib_bufext *pdata);
/*-------------------------------------------------------------*/
netwib_err netwib_pkt_append_ipicmp4(netwib_constiphdr *piphdr,
                                     netwib_consticmp4 *picmp4,
                                     netwib_buf *ppkt);
netwib_err netwib_pkt_decode_ipicmp4(netwib_constbuf *ppkt,
                                     netwib_iphdr *piphdr,
                                     netwib_icmp4 *picmp4);
netwib_err netwib_pkt_append_linkipicmp4(netwib_constlinkhdr *plinkhdr,
                                         netwib_constiphdr *piphdr,
                                         netwib_consticmp4 *picmp4,
                                         netwib_buf *ppkt);
netwib_err netwib_pkt_decode_linkipicmp4(netwib_device_dlttype dlttype,
                                         netwib_constbuf *ppkt,
                                         netwib_linkhdr *plinkhdr,
                                         netwib_iphdr *piphdr,
                                         netwib_icmp4 *picmp4);
/*-------------------------------------------------------------*/
netwib_err netwib_pkt_append_ipicmp6(netwib_constiphdr *piphdr,
                                     netwib_consticmp6 *picmp6,
                                     netwib_buf *ppkt);
netwib_err netwib_pkt_decode_ipicmp6(netwib_constbuf *ppkt,
                                     netwib_iphdr *piphdr,
                                     netwib_icmp6 *picmp6);
netwib_err netwib_pkt_append_linkipicmp6(netwib_constlinkhdr *plinkhdr,
                                         netwib_constiphdr *piphdr,
                                         netwib_consticmp6 *picmp6,
                                         netwib_buf *ppkt);
netwib_err netwib_pkt_decode_linkipicmp6(netwib_device_dlttype dlttype,
                                         netwib_constbuf *ppkt,
                                         netwib_linkhdr *plinkhdr,
                                         netwib_iphdr *piphdr,
                                         netwib_icmp6 *picmp6);
/*-------------------------------------------------------------*/
/* before calling this function, user has to set plinkhdr->type
   to ARP or RARP */
netwib_err netwib_pkt_append_linkarp(netwib_constlinkhdr *plinkhdr,
                                     netwib_constarphdr *parphdr,
                                     netwib_buf *ppkt);
netwib_err netwib_pkt_decode_linkarp(netwib_device_dlttype dlttype,
                                     netwib_constbuf *ppkt,
                                     netwib_linkhdr *plinkhdr,
                                     netwib_arphdr *parphdr);

/*-------------------------------------------------------------*/
typedef enum {
  NETWIB_PKT_NEWFIELD_BLANK = 1, /* do not try to compute field */
  NETWIB_PKT_NEWFIELD_FILL,      /* compute field */
  NETWIB_PKT_NEWFIELD_FILLBLANK, /* if can't compute left blank */
  NETWIB_PKT_NEWFIELD_BEST = NETWIB_PKT_NEWFIELD_FILLBLANK
} netwib_pkt_newfield;
/*-------------------------------------------------------------*/
/* Name : netwib_pkt_convert
   Description :
     Convert a packet from one type to another
   Input parameter(s) :
     dlttype : DLT type of input packet
     *ppktin : buffer containing physical input packet
     newfieldopt : type to use for optional fields
     newfieldreq : type to use for mandatory fields
     dlttypeout : wanted outtype
   Input/output parameter(s) :
     *plinkhdrout : new link header
     *ppktout : packet to put after the link header
   Output parameter(s) :
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_pkt_convert(netwib_device_dlttype dlttypein,
                              netwib_constbuf *ppktin,
                              netwib_pkt_newfield newfieldopt,
                              netwib_pkt_newfield newfieldreq,
                              netwib_device_dlttype dlttypeout,
                              netwib_linkhdr *plinkhdrout,
                              netwib_bufext *ppktout);

/*-------------------------------------------------------------*/
typedef netwib_err (*netwib_ip_frag_pf)(netwib_constbuf *pfrag,
                                        netwib_ptr infos);
/*-------------------------------------------------------------*/
/* Name : netwib_ip_frag
   Description :
     Fragment an IP packet
   Input parameter(s) :
     *pippkt : IP packet (containing IP header)
     fragdatasize : data size to send in each fragment in bytes.
                    It is rounded to 8 : 1->8bytes, 7->8bytes,
                    8->8, 9->16, etc.
                    The first fragment may be bigger than
                    the others because it contains more IPv4
                    options, or IPv6 extensions.
                    If fragdatasize == 0, this limit is not used.
     fragtotalsize : maximum total size of the packet in bytes.
                     If fragtotalsize == 0, this limit is not used.
     pfunc : memory address of the function which will
             be called for each fragment
             For each call, the first parameter ('infos')
             will be set with the optional parameter below.
   Input/output parameter(s) :
     infos : optional parameter (can be NULL) which will be
             used as the first parameter for *pfunc.
             This may be used to send information to *pfunc.
   Output parameter(s) :
   Normal return values :
     NETWIB_ERR_OK : ok
*/
netwib_err netwib_ip_frag(netwib_constbuf *pippkt,
                          netwib_uint32 fragdatasize,
                          netwib_uint32 fragtotalsize,
                          netwib_ip_frag_pf pfunc,
                          netwib_ptr infos);
/*-------------------------------------------------------------*/
#define NETWIB_MTU_MIN_IP4 576 /* rfc 791 */
#define NETWIB_MTU_MIN_IP6 1280 /* rfc 2460 */

netwib(3), netwib_dat(3), netwib_sys(3), netwib_net(3), netwib_pkt(3), netwib_shw(3), netwib_err(3)
14/02/2010

Search for    or go to Top of page |  Section 3 |  Main Index

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with ManDoc.