Go to main content

man pages section 3: Library Interfaces and Headers

Exit Print View

Updated: Thursday, June 13, 2019
 
 

dnet (3)

Name

dnet - dumb networking library

Synopsis

#include <dnet.h>

Network addressing
int
addr_cmp(const struct addr *a, const struct addr *b);

int
addr_bcast(const struct addr *a, struct addr *b);

int
addr_net(const struct addr *a, struct addr *b);

char *
addr_ntop(const struct addr *src, char *dst size_t size);

int
addr_pton(const char *src, struct addr *dst);

char *
addr_ntoa(const struct addr *a);

int
addr_aton(const char *src, struct addr *dst);

int
addr_ntos(const struct addr *a, struct sockaddr *sa);

int
addr_ston(const struct sockaddr *sa, struct addr *a);

int
addr_btos(uint16_t bits, struct sockaddr *sa);

int
addr_stob(const struct sockaddr *sa, uint16_t *bits);

int
addr_btom(uint16_t bits, void *mask, size_t size);

int
addr_mtob(const void *mask, size_t size, uint16_t *bits);

Address Resolution Protocol
typedef int (*arp_handler)(const struct arp_entry *entry, void *arg);

arp_t *
arp_open(void);

int
arp_add(arp_t *a, const struct arp_entry *entry);

int
arp_delete(arp_t *a, const struct arp_entry *entry);

int
arp_get(arp_t *a, struct arp_entry *entry);

int
arp_loop(arp_t *a, arp_handler callback, void *arg);

arp_t *
arp_close(arp_t *a);

Binary buffers
blob_t *
blob_new(void);

int
blob_read(blob_t *b, void *buf, int len);

int
blob_write(blob_t *b, const void *buf, int len);

int
blob_seek(blob_t *b, int off, int whence);

int
blob_index(blob_t *b, const void *buf, int len);

int
blob_rindex(blob_t *b, const void *buf, int len);

int
blob_pack(blob_t *b, const void *fmt, ...);

int
blob_unpack(blob_t *b, const void *fmt, ...);

int
blob_print(blob_t *b, char *style, int len);

blob_t *
blob_free(blob_t *b);

Ethernet
eth_t *
eth_open(const char *device);

int
eth_get(eth_t *e, eth_addr_t *ea);

int
eth_set(eth_t *e, const eth_addr_t *ea);

ssize_t
eth_send(eth_t *e, const void *buf, size_t len);

eth_t *
eth_close(eth_t *e);

Firewalling
typedef int (*fw_handler)(const struct fw_rule *rule, void *arg);

fw_t *
fw_open void

int
fw_add(fw_t *f, const struct fw_rule *rule);

int
fw_delete(fw_t *f, const struct fw_rule *rule);

int
fw_loop(fw_t *f, fw_handler callback, void *arg);

fw_t *
fw_close(fw_t *f);

Network interfaces
typedef int (*intf_handler)(const struct intf_entry *entry void *arg);

intf_t *
intf_open(void);

int
intf_get(intf_t *i, struct intf_entry *entry);

int
intf_get_src(intf_t *i, struct intf_entry *entry, struct addr *src);

int
intf_get_dst(intf_t *i, struct intf_entry *entry, struct addr *dst);

int
intf_set(intf_t *i, const struct intf_entry *entry);

int
intf_loop(intf_t *i, intf_handler callback, void *arg);

intf_t *
intf_close(intf_t *i);

Internet Protocol
ip_t *
ip_open(void);

ssize_t
ip_add_option(void *buf, size_t len, int proto, const void *optbuf, size_t optlen);

void
ip_checksum(void *buf, size_t len);

ssize_t
ip_send(ip_t *i, const void *buf, size_t len);

ip_t *
ip_close(ip_t *i);

Internet Protocol Version 6
void
ip6_checksum(void *buf, size_t len);

Random number generation
rand_t *
rand_open(void);

int
rand_get(rand_t *r, void *buf, size_t len);

int
rand_set(rand_t *r, const void *seed, size_t len);

int
rand_add(rand_t *r, const void *buf, size_t len);

uint8_t
rand_uint8(rand_t *r);

uint16_t
rand_uint16(rand_t *r);

uint32_t
rand_uint32(rand_t *r);

int
rand_shuffle(rand_t *r, void *base, size_t nmemb, size_t size);

rand_t *
rand_close(rand_t *r);

Routing
typedef int (*route_handler)(const struct route_entry *entry void *arg);

route_t *
route_open(void);

int
route_add(route_t *r, const struct route_entry *entry);

int
route_delete(route_t *r, const struct route_entry *entry);

int
route_get(route_t *r, struct route_entry *entry);

int
route_loop(route_t *r, route_handler callback, void *arg);

route_t *
route_close(route_t *r);

Tunnel interface
tun_t *
tun_open(struct addr *src, struct addr *dst, int mtu);

int
tun_fileno(tun_t *t);

const char *
tun_name(tun_t *t);

ssize_t
tun_send(tun_t *t, const void *buf, size_t size);

ssize_t
tun_recv(tun_t *t, void *buf, size_t size);

tun_t *
tun_close(tun_t *t);

Description

DNET(3)                    Library Functions Manual                    DNET(3)



NAME
       dnet - dumb networking library

SYNOPSIS
       #include <dnet.h>

   Network addressing
       int
       addr_cmp(const struct addr *a, const struct addr *b);

       int
       addr_bcast(const struct addr *a, struct addr *b);

       int
       addr_net(const struct addr *a, struct addr *b);

       char *
       addr_ntop(const struct addr *src, char *dst size_t size);

       int
       addr_pton(const char *src, struct addr *dst);

       char *
       addr_ntoa(const struct addr *a);

       int
       addr_aton(const char *src, struct addr *dst);

       int
       addr_ntos(const struct addr *a, struct sockaddr *sa);

       int
       addr_ston(const struct sockaddr *sa, struct addr *a);

       int
       addr_btos(uint16_t bits, struct sockaddr *sa);

       int
       addr_stob(const struct sockaddr *sa, uint16_t *bits);

       int
       addr_btom(uint16_t bits, void *mask, size_t size);

       int
       addr_mtob(const void *mask, size_t size, uint16_t *bits);

   Address Resolution Protocol
       typedef int (*arp_handler)(const struct arp_entry *entry, void *arg);

       arp_t *
       arp_open(void);

       int
       arp_add(arp_t *a, const struct arp_entry *entry);

       int
       arp_delete(arp_t *a, const struct arp_entry *entry);

       int
       arp_get(arp_t *a, struct arp_entry *entry);

       int
       arp_loop(arp_t *a, arp_handler callback, void *arg);

       arp_t *
       arp_close(arp_t *a);

   Binary buffers
       blob_t *
       blob_new(void);

       int
       blob_read(blob_t *b, void *buf, int len);

       int
       blob_write(blob_t *b, const void *buf, int len);

       int
       blob_seek(blob_t *b, int off, int whence);

       int
       blob_index(blob_t *b, const void *buf, int len);

       int
       blob_rindex(blob_t *b, const void *buf, int len);

       int
       blob_pack(blob_t *b, const void *fmt, ...);

       int
       blob_unpack(blob_t *b, const void *fmt, ...);

       int
       blob_print(blob_t *b, char *style, int len);

       blob_t *
       blob_free(blob_t *b);

   Ethernet
       eth_t *
       eth_open(const char *device);

       int
       eth_get(eth_t *e, eth_addr_t *ea);

       int
       eth_set(eth_t *e, const eth_addr_t *ea);

       ssize_t
       eth_send(eth_t *e, const void *buf, size_t len);

       eth_t *
       eth_close(eth_t *e);

   Firewalling
       typedef int (*fw_handler)(const struct fw_rule *rule, void *arg);

       fw_t *
       fw_open void

       int
       fw_add(fw_t *f, const struct fw_rule *rule);

       int
       fw_delete(fw_t *f, const struct fw_rule *rule);

       int
       fw_loop(fw_t *f, fw_handler callback, void *arg);

       fw_t *
       fw_close(fw_t *f);

   Network interfaces
       typedef int (*intf_handler)(const struct intf_entry *entry void *arg);

       intf_t *
       intf_open(void);

       int
       intf_get(intf_t *i, struct intf_entry *entry);

       int
       intf_get_src(intf_t *i, struct intf_entry *entry, struct addr *src);

       int
       intf_get_dst(intf_t *i, struct intf_entry *entry, struct addr *dst);

       int
       intf_set(intf_t *i, const struct intf_entry *entry);

       int
       intf_loop(intf_t *i, intf_handler callback, void *arg);

       intf_t *
       intf_close(intf_t *i);

   Internet Protocol
       ip_t *
       ip_open(void);

       ssize_t
       ip_add_option(void *buf, size_t len, int proto, const void *optbuf, size_t optlen);

       void
       ip_checksum(void *buf, size_t len);

       ssize_t
       ip_send(ip_t *i, const void *buf, size_t len);

       ip_t *
       ip_close(ip_t *i);

   Internet Protocol Version 6
       void
       ip6_checksum(void *buf, size_t len);

   Random number generation
       rand_t *
       rand_open(void);

       int
       rand_get(rand_t *r, void *buf, size_t len);

       int
       rand_set(rand_t *r, const void *seed, size_t len);

       int
       rand_add(rand_t *r, const void *buf, size_t len);

       uint8_t
       rand_uint8(rand_t *r);

       uint16_t
       rand_uint16(rand_t *r);

       uint32_t
       rand_uint32(rand_t *r);

       int
       rand_shuffle(rand_t *r, void *base, size_t nmemb, size_t size);

       rand_t *
       rand_close(rand_t *r);

   Routing
       typedef int (*route_handler)(const struct route_entry *entry void *arg);

       route_t *
       route_open(void);

       int
       route_add(route_t *r, const struct route_entry *entry);

       int
       route_delete(route_t *r, const struct route_entry *entry);

       int
       route_get(route_t *r, struct route_entry *entry);

       int
       route_loop(route_t *r, route_handler callback, void *arg);

       route_t *
       route_close(route_t *r);

   Tunnel interface
       tun_t *
       tun_open(struct addr *src, struct addr *dst, int mtu);

       int
       tun_fileno(tun_t *t);

       const char *
       tun_name(tun_t *t);

       ssize_t
       tun_send(tun_t *t, const void *buf, size_t size);

       ssize_t
       tun_recv(tun_t *t, void *buf, size_t size);

       tun_t *
       tun_close(tun_t *t);

DESCRIPTION
       dnet  provides  a  simplified,  portable interface to several low-level
       networking routines, including  network  address  manipulation,  kernel
       arp(8)  cache and route(8) table lookup and manipulation, network fire-
       walling, network interface lookup and manipulation, and raw  IP  packet
       and Ethernet frame transmission. It is intended to complement the func-
       tionality provided by pcap(3).

       In addition, dnet also  provides  platform-independent  definitions  of
       various network protocol formats and values for portable low-level net-
       work programming, as well as a simple binary buffer handling API.

   Network addressing
       Network addresses are described by the following structure:
       struct addr {
            uint16_t       addr_type;
            uint16_t       addr_bits;
            union {
                 eth_addr_t     __eth;
                 ip_addr_t __ip;
                 ip6_addr_t     __ip6;

                 uint8_t        __data8[16];
                 uint16_t  __data16[8];
                 uint32_t  __data32[4];
            } __addr_u;
       };
       #define addr_eth    __addr_u.__eth
       #define addr_ip          __addr_u.__ip
       #define addr_ip6    __addr_u.__ip6
       #define addr_data8  __addr_u.__data8
       #define addr_data16 __addr_u.__data16
       #define addr_data32 __addr_u.__data32

       The following values are defined for addr_type:
       #define ADDR_TYPE_NONE        0    /* No address set */
       #define   ADDR_TYPE_ETH       1    /* Ethernet */
       #define   ADDR_TYPE_IP        2    /* Internet Protocol v4 */
       #define   ADDR_TYPE_IP6       3    /* Internet Protocol v6 */

       The field addr_bits denotes the length of the network mask in bits.

       addr_cmp compares network addresses a and b, returning an integer  less
       than, equal to, or greater than zero if a is found, respectively, to be
       less than, equal to, or greater than b.  Both addresses must be of  the
       same address type.

       addr_bcast  computes the broadcast address for the network specified in
       a and writes it into b.

       addr_net computes the network address for the network  specified  in  a
       and writes it into b.

       addr_ntop converts an address from network format to a string.

       addr_pton  converts  an  address (or hostname) from a string to network
       format.

       addr_ntoa converts an address from network format to a string,  return-
       ing a pointer to the result in static memory.

       addr_aton is a synonym for addr_pton.

       addr_ntos  converts  an  address from network format to the appropriate
       struct sockaddr.

       addr_ston converts an address from a struct sockaddr to network format.

       addr_btos converts a network mask length to a network mask specified as
       a struct sockaddr.

       addr_stob  converts  a network mask specified in a struct sockaddr to a
       network mask length.

       addr_btom converts a network mask length to a network mask  in  network
       byte order.

       addr_mtob  converts  a  network mask in network byte order to a network
       mask length.

   Address Resolution Protocol
       ARP cache entries are described by the following structure:
       struct arp_entry {
            struct addr    arp_pa;        /* protocol address */
            struct addr    arp_ha;        /* hardware address */
       };

       arp_open is used to obtain a handle to access the kernel arp(8) cache.

       arp_add adds a new ARP entry.

       arp_delete deletes the ARP entry for the protocol address specified  by
       arp_pa.

       arp_get  retrieves  the ARP entry for the protocol address specified by
       arp_pa.

       arp_loop iterates over the kernel arp(8) cache, invoking the  specified
       callback with each entry and the context arg passed to arp_loop.

       arp_close closes the specified handle.

   Binary buffers
       Binary buffers are described by the following structure:
       typedef struct blob {
            u_char         *base;         /* start of data */
            int        off;          /* offset into data */
            int        end;          /* end of data */
            int        size;         /* size of allocation */
       } blob_t;

       blob_new  is  used  to  allocate a new dynamic binary buffer, returning
       NULL on failure.

       blob_read reads len bytes from the current offset in blob b  into  buf,
       returning the total number of bytes read, or -1 on failure.

       blob_write  writes  len bytes from buf to blob b, advancing the current
       offset. It returns the number of bytes written, or -1 on failure.

       blob_seek repositions the offset within blob b to off, according to the
       directive whence (see lseek(2) for details), returning the new absolute
       offset, or -1 on failure.

       blob_index returns the offset of the first occurence in blob b  of  the
       specified buf of length len, or -1 on failure.

       blob_rindex  returns  the offset of the last occurence in blob b of the
       specified buf of length len, or -1 on failure.

       blob_pack converts and writes, and blob_unpack reads and converts  data
       in blob b according to the given format fmt as described below, return-
       ing 0 on success, and -1 on failure.

       The format string is composed of  zero  or  more  directives:  ordinary
       characters (not % ), which are copied to / read from the blob, and con-
       version specifications, each of which results in reading / writing zero
       or more subsequent arguments.

       Each conversion specification is introduced by the character %, and may
       be prefixed by length specifier. The arguments must correspond properly
       (after type promotion) with the length and conversion specifiers.

       The  length specifier is either a a decimal digit string specifying the
       length of the following argument, or the literal character * indicating
       that  the  length should be read from an integer argument for the argu-
       ment following it.

       The conversion specifiers and their meanings are:

       D      An unsigned 32-bit integer in network byte order.

       H      An unsigned 16-bit integer in network byte order.

       b      A binary buffer (length specifier required).

       c      An unsigned character.

       d      An unsigned 32-bit integer in host byte order.

       h      An unsigned 16-bit integer in host byte order.

       s      A C-style null-terminated string, whose maximum length  must  be
              specified when unpacking.

       Custom  conversion  routines and their specifiers may be registered via
       blob_register_pack, currently undocumented.

       blob_print prints len bytes of the contents of blob b from the  current
       offset in the specified style; currently only ``hexl'' is available.

       blob_free  deallocates  the  memory  associated with blob b and returns
       NULL.

   Ethernet
       eth_open is used to obtain a handle to transmit raw Ethernet frames via
       the specified network device.

       eth_get  retrieves the hardware MAC address for the interface specified
       by e.

       eth_set configures the hardware MAC address for the interface specified
       by e.

       eth_send transmits len bytes of the Ethernet frame pointed to by buf.

       eth_close closes the specified handle.

   Firewalling
       Firewall rules are described by the following structure:
       struct fw_rule {
            char      fw_device[INTF_NAME_LEN]; /* interface name */
            uint8_t        fw_op;                /* operation */
            uint8_t        fw_dir;               /* direction */
            uint8_t        fw_proto;        /* IP protocol */
            struct addr    fw_src;               /* src address / net */
            struct addr    fw_dst;               /* dst address / net */
            uint16_t  fw_sport[2];          /* range / ICMP type */
            uint16_t  fw_dport[2];          /* range / ICMP code */
       };

       The following values are defined for fw_op:
       #define FW_OP_ALLOW 1
       #define FW_OP_BLOCK 2

       The following values are defined for fw_dir:
       #define FW_DIR_IN   1
       #define FW_DIR_OUT  2

       fw_open is used to obtain a handle to access the local network firewall
       configuration.

       fw_add adds the specified firewall rule.

       fw_delete deletes the specified firewall rule.

       fw_loop iterates over the active firewall ruleset, invoking the  speci-
       fied callback with each rule and the context arg passed to fw_loop.

       fw_close closes the specified handle.

   Network interfaces
       Network interface information is described by the following structure:
       #define INTF_NAME_LEN    16

       struct intf_entry {
            u_int          intf_len;          /* length of entry */
            char      intf_name[INTF_NAME_LEN];   /* interface name */
            u_short        intf_type;              /* interface type (r/o) */
            u_short        intf_flags;             /* interface flags */
            u_int          intf_mtu;          /* interface MTU */
            struct addr    intf_addr;              /* interface address */
            struct addr    intf_dst_addr;          /* point-to-point dst */
            struct addr    intf_link_addr;              /* link-layer address */
            u_int          intf_alias_num;              /* number of aliases */
            struct addr    intf_alias_addrs __flexarr; /* array of aliases */
       };

       The following bitmask values are defined for intf_type:
       #define INTF_TYPE_OTHER       1    /* other */
       #define INTF_TYPE_ETH         6    /* Ethernet */
       #define INTF_TYPE_LOOPBACK    24   /* software loopback */
       #define INTF_TYPE_TUN         53   /* proprietary virtual/internal */

       The following bitmask values are defined for intf_flags:
       #define INTF_FLAG_UP          0x01 /* enable interface */
       #define INTF_FLAG_LOOPBACK    0x02 /* is a loopback net (r/o) */
       #define INTF_FLAG_POINTOPOINT 0x04 /* point-to-point link (r/o) */
       #define INTF_FLAG_NOARP       0x08 /* disable ARP */
       #define INTF_FLAG_BROADCAST   0x10 /* supports broadcast (r/o) */
       #define INTF_FLAG_MULTICAST   0x20 /* supports multicast (r/o) */

       intf_open  is  used  to obtain a handle to access the network interface
       configuration.

       intf_get  retrieves  an  interface  configuration   entry,   keyed   on
       intf_name.   For  all intf_get functions, intf_len should be set to the
       size  of  the  buffer  pointed  to  by  entry  (usually   sizeof(struct
       intf_entry),  but  should  be  larger to accomodate any interface alias
       addresses.

       intf_get_src retrieves the configuration for the interface  whose  pri-
       mary address matches the specified src.

       intf_get_dst  retrieves  the  configuration for the best interface with
       which to reach the specified dst.

       intf_set sets the interface configuration entry.

       intf_loop iterates over all network interfaces, invoking the  specified
       callback  with  each  interface configuration entry and the context arg
       passed to intf_loop.

       intf_close closes the specified handle.

   Internet Protocol
       ip_open is used to obtain a handle to transmit raw IP  packets,  routed
       by the kernel.

       ip_add_option  adds  the header option for the protocol proto specified
       by optbuf of length optlen and appends it to the appropriate header  of
       the  IP packet contained in buf of size len, shifting any existing pay-
       load and adding NOPs to pad the option to a word boundary if necessary.

       ip_checksum sets the IP checksum and any appropriate transport protocol
       checksum for the IP packet pointed to by buf of length len.

       ip_send transmits len bytes of the IP packet pointed to by buf.

       ip_close closes the specified handle.

   Internet Protocol Version 6
       ip6_checksum  sets  the appropriate transport protocol checksum for the
       IPv6 packet pointed to by buf of length len.

   Random number generation
       rand_open is used to obtain a handle for fast, cryptographically strong
       pseudo-random  number generation. The starting seed is derived from the
       system random data source device (if one exists), or from  the  current
       time and random stack contents.

       rand_set re-initializes the PRNG to start from a known seed value, use-
       ful in generating repeatable sequences.

       rand_get writes len random bytes into buf.

       rand_add adds len bytes of entropy data from buf into the random mix.

       rand_uint8, rand_uint16, and  rand_uint32  return  8,  16,  and  32-bit
       unsigned random values, respectively.

       rand_shuffle  randomly  shuffles  an  array  of  nmemb elements of size
       bytes, starting at base.

       rand_close closes the specified handle.

   Routing
       Routing table entries are described by the following structure:
       struct route_entry {
            struct addr    route_dst;     /* destination address */
            struct addr    route_gw; /* gateway address */
       };

       route_open is used to obtain a handle to access the kernel route(8) ta-
       ble.

       route_add adds a new routing table entry.

       route_delete deletes the routing table entry for the destination prefix
       specified by route_dst.

       route_get retrieves the routing table entry for the destination  prefix
       specified by route_dst.

       route_loop iterates over the kernel route(8) table, invoking the speci-
       fied callback with each entry and the context arg passed to route_loop.

       route_close closes the specified handle.

   Tunnel interface
       tun_open is used to obtain a handle to a network tunnel  interface,  to
       which  IP packets destined for dst are delivered (with source addresses
       rewritten to src ), where they may be read by a  userland  process  and
       processed  as  desired.  IP  packets  written  back  to  the handle are
       injected into the kernel networking subsystem.

       tun_fileno returns a file descriptor associated with the tunnel handle,
       suitable for select(2).

       tun_name returns a pointer to the tunnel interface name.

       tun_send submits a packet to the kernel networking subsystem for deliv-
       ery.

       tun_recv reads the next packet delivered to the tunnel interface.

       tun_close closes the specified handle.

RETURN VALUES
       addr_ntop returns a pointer to the dst argument, or NULL on failure.

       addr_ntoa returns a pointer to a  static  memory  area  containing  the
       printable address, or NULL on failure.

       arp_open,   eth_open,   fw_open,  intf_open,  ip_open,  rand_open,  and
       route_open return a valid handle on success, or NULL on failure.

       arp_close, eth_close, fw_close, intf_close, ip_close,  rand_close,  and
       route_close always return NULL.

       eth_send  and  ip_send  return  the length of the datagram successfully
       sent, or -1 on failure.

       arp_loop, fw_loop, intf_loop, and route_loop return the status of their
       callback  routines.  Any non-zero return from a callback will cause the
       loop to exit immediately.

       ip_add_option returns the length of the inserted option (which may have
       been padded with NOPs for memory alignment) or -1 on failure.

       rand_uint8,  rand_uint16,  and  rand_uint32  return  8,  16, and 32-bit
       unsigned random values, respectively.

       All other dnet routines return 0 on success, or -1 on failure.


ATTRIBUTES
       See attributes(7) for descriptions of the following attributes:


       +---------------+------------------------+
       |ATTRIBUTE TYPE |    ATTRIBUTE VALUE     |
       +---------------+------------------------+
       |Availability   | system/library/libdnet |
       +---------------+------------------------+
       |Stability      | Uncommitted            |
       +---------------+------------------------+
SEE ALSO
       pcap(3)

AUTHORS
       Dug Song <dugsong@monkey.org>



NOTES
       This    software    was    built    from    source     available     at
       https://github.com/oracle/solaris-userland.    The  original  community
       source  was  downloaded  from    https://github.com/dugsong/libdnet/ar-
       chive/libdnet-1.12.tgz

       Further information about this software can be found on the open source
       community website at https://github.com/dugsong/libdnet.



Solaris 11.4                    August 21, 2001                        DNET(3)