summaryrefslogtreecommitdiff
path: root/inet
diff options
context:
space:
mode:
Diffstat (limited to 'inet')
-rw-r--r--inet/Makefile2
-rw-r--r--inet/Versions4
-rw-r--r--inet/inet6_option.c342
-rw-r--r--inet/netinet/in.h18
-rw-r--r--inet/netinet/ip6.h49
5 files changed, 395 insertions, 20 deletions
diff --git a/inet/Makefile b/inet/Makefile
index 96313f40c2..6a0c0c5d17 100644
--- a/inet/Makefile
+++ b/inet/Makefile
@@ -45,7 +45,7 @@ routines := htonl htons \
rcmd rexec ruserpass \
getnetgrent_r getnetgrent \
getaliasent_r getaliasent getaliasname getaliasname_r \
- in6_addr getnameinfo if_index ifaddrs
+ in6_addr getnameinfo if_index ifaddrs inet6_option
aux := check_pf ifreq
diff --git a/inet/Versions b/inet/Versions
index 0eb1e77838..67bd0ed5b0 100644
--- a/inet/Versions
+++ b/inet/Versions
@@ -70,6 +70,10 @@ libc {
# g*
getifaddrs;
}
+ GLIBC_2.3.3 {
+ inet6_option_space; inet6_option_init; inet6_option_append;
+ inet6_option_alloc; inet6_option_next; inet6_option_find;
+ }
GLIBC_PRIVATE {
# functions used in other libraries
__internal_endnetgrent; __internal_getnetgrent_r;
diff --git a/inet/inet6_option.c b/inet/inet6_option.c
new file mode 100644
index 0000000000..9a1e8686b9
--- /dev/null
+++ b/inet/inet6_option.c
@@ -0,0 +1,342 @@
+/* Copyright (C) 2003 Free Software Foundation, Inc.
+ This file is part of the GNU C Library.
+ Contributed by Ulrich Drepper <drepper@redhat.com>, 2003.
+
+ The GNU C Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ The GNU C Library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with the GNU C Library; if not, write to the Free
+ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ 02111-1307 USA. */
+
+#include <assert.h>
+#include <string.h>
+#include <netinet/in.h>
+#include <netinet/ip6.h>
+#include <sys/param.h>
+
+
+static void
+internal_function
+add_pad (struct cmsghdr *cmsg, int len)
+{
+ unsigned char *p = CMSG_DATA (cmsg) + cmsg->cmsg_len - CMSG_LEN (0);
+
+ if (len == 1)
+ /* Special handling for 1, a one-byte solution. */
+ *p++ = IP6OPT_PAD1;
+ else if (len != 0)
+ {
+ /* Multibyte padding. */
+ *p++ = IP6OPT_PADN;
+ *p++ = len - 2; /* Discount the two header bytes. */
+ /* The rest is filled with zero. */
+ memset (p, '\0', len - 2);
+ p += len - 2;
+ }
+
+ /* Account for the bytes. */
+ cmsg->cmsg_len += len;
+}
+
+
+static int
+get_opt_end (const uint8_t **result, const uint8_t *startp,
+ const uint8_t *endp)
+{
+ if (startp >= endp)
+ /* Out of bounds. */
+ return -1;
+
+ if (*startp == IP6OPT_PAD1)
+ {
+ /* Just this one byte. */
+ *result = startp + 1;
+ return 0;
+ }
+
+ /* Now we know there must be at least two bytes. */
+ if (startp + 2 > endp
+ /* Now we can get the length byte. */
+ || startp + startp[1] + 2 > endp)
+ return -1;
+
+ *result = startp + startp[1] + 2;
+
+ return 0;
+}
+
+
+/* RFC 2292, 6.3.1
+
+ This function returns the number of bytes required to hold an option
+ when it is stored as ancillary data, including the cmsghdr structure
+ at the beginning, and any padding at the end (to make its size a
+ multiple of 8 bytes). The argument is the size of the structure
+ defining the option, which must include any pad bytes at the
+ beginning (the value y in the alignment term "xn + y"), the type
+ byte, the length byte, and the option data. */
+int
+inet6_option_space (nbytes)
+ int nbytes;
+{
+ /* Add room for the extension header. */
+ nbytes += sizeof (struct ip6_ext);
+
+ return CMSG_SPACE (roundup (nbytes, 8));
+}
+
+
+/* RFC 2292, 6.3.2
+
+ This function is called once per ancillary data object that will
+ contain either Hop-by-Hop or Destination options. It returns 0 on
+ success or -1 on an error. */
+int
+inet6_option_init (bp, cmsgp, type)
+ void *bp;
+ struct cmsghdr **cmsgp;
+ int type;
+{
+ /* Only Hop-by-Hop or Destination options allowed. */
+ if (type != IPV6_HOPOPTS && type != IPV6_DSTOPTS)
+ return -1;
+
+ /* BP is a pointer to the previously allocated space. */
+ struct cmsghdr *newp = (struct cmsghdr *) bp;
+
+ /* Initialize the message header.
+
+ Length: No data yet, only the cmsghdr struct. */
+ newp->cmsg_len = CMSG_LEN (0);
+ /* Originating protocol: obviously IPv6. */
+ newp->cmsg_level = IPPROTO_IPV6;
+ /* Message type. */
+ newp->cmsg_type = type;
+
+ /* Pass up the result. */
+ *cmsgp = newp;
+
+ return 0;
+}
+
+
+/* RFC 2292, 6.3.3
+
+ This function appends a Hop-by-Hop option or a Destination option
+ into an ancillary data object that has been initialized by
+ inet6_option_init(). This function returns 0 if it succeeds or -1 on
+ an error. */
+int
+inet6_option_append (cmsg, typep, multx, plusy)
+ struct cmsghdr *cmsg;
+ const uint8_t *typep;
+ int multx;
+ int plusy;
+{
+ /* typep is a pointer to the 8-bit option type. It is assumed that this
+ field is immediately followed by the 8-bit option data length field,
+ which is then followed immediately by the option data.
+
+ The option types IP6OPT_PAD1 and IP6OPT_PADN also must be handled. */
+ int len = typep[0] == IP6OPT_PAD1 ? 1 : typep[1] + 2;
+
+ /* Get the pointer to the space in the message. */
+ uint8_t *ptr = inet6_option_alloc (cmsg, len, multx, plusy);
+ if (ptr == NULL)
+ /* Some problem with the parameters. */
+ return -1;
+
+ /* Copy the content. */
+ memcpy (ptr, typep, len);
+
+ return 0;
+}
+
+
+/* RFC 2292, 6.3.4
+
+ This function appends a Hop-by-Hop option or a Destination option
+ into an ancillary data object that has been initialized by
+ inet6_option_init(). This function returns a pointer to the 8-bit
+ option type field that starts the option on success, or NULL on an
+ error. */
+uint8_t *
+inet6_option_alloc (cmsg, datalen, multx, plusy)
+ struct cmsghdr *cmsg;
+ int datalen;
+ int multx;
+ int plusy;
+{
+ /* The RFC limits the value of the alignment values. */
+ if ((multx != 1 && multx != 2 && multx != 4 && multx != 8)
+ || ! (plusy >= 0 && plusy <= 7))
+ return NULL;
+
+ /* Current data size. */
+ int dsize = cmsg->cmsg_len - CMSG_LEN (0);
+
+ /* The first two bytes of the option are for the extended header. */
+ if (__builtin_expect (dsize == 0, 0))
+ {
+ cmsg->cmsg_len += sizeof (struct ip6_ext);
+ dsize = sizeof (struct ip6_ext);
+ }
+
+ /* First add padding. */
+ add_pad (cmsg, ((multx - (dsize & (multx - 1))) & (multx - 1)) + plusy);
+
+ /* Return the pointer to the start of the option space. */
+ uint8_t *result = CMSG_DATA (cmsg) + cmsg->cmsg_len - CMSG_LEN (0);
+ cmsg->cmsg_len += datalen;
+
+ /* The extended option header length is measured in 8-byte groups.
+ To represent the current length we might have to add padding. */
+ dsize = cmsg->cmsg_len - CMSG_LEN (0);
+ add_pad (cmsg, (8 - (dsize & (8 - 1))) & (8 - 1));
+
+ /* Record the new length of the option. */
+ assert (((cmsg->cmsg_len - CMSG_LEN (0)) % 8) == 0);
+ int len8b = (cmsg->cmsg_len - CMSG_LEN (0)) / 8 - 1;
+ if (len8b >= 256)
+ /* Too long. */
+ return NULL;
+
+ ((struct ip6_ext *) CMSG_DATA (cmsg))->ip6e_len = len8b;
+
+ return result;
+}
+
+
+/* RFC 2292, 6.3.5
+
+ This function processes the next Hop-by-Hop option or Destination
+ option in an ancillary data object. If another option remains to be
+ processed, the return value of the function is 0 and *tptrp points to
+ the 8-bit option type field (which is followed by the 8-bit option
+ data length, followed by the option data). If no more options remain
+ to be processed, the return value is -1 and *tptrp is NULL. If an
+ error occurs, the return value is -1 and *tptrp is not NULL. */
+int
+inet6_option_next (cmsg, tptrp)
+ const struct cmsghdr *cmsg;
+ uint8_t **tptrp;
+{
+ /* Make sure it is an option of the right type. */
+ if (cmsg->cmsg_level != IPPROTO_IPV6
+ || (cmsg->cmsg_type != IPV6_HOPOPTS && cmsg->cmsg_type != IPV6_DSTOPTS))
+ return -1;
+
+ /* Pointer to the extension header. We only compute the address, we
+ don't access anything yet. */
+ const struct ip6_ext *ip6e = (const struct ip6_ext *) CMSG_DATA (cmsg);
+
+ /* Make sure the message is long enough. */
+ if (cmsg->cmsg_len < CMSG_LEN (sizeof (struct ip6_ext))
+ /* Now we can access the extension header. */
+ || cmsg->cmsg_len < CMSG_LEN ((ip6e->ip6e_len + 1) * 8))
+ /* Too small. */
+ return -1;
+
+ /* Determine the address of the byte past the message. */
+ const uint8_t *endp = CMSG_DATA (cmsg) + (ip6e->ip6e_len + 1) * 8;
+
+ const uint8_t *result;
+ if (tptrp == NULL)
+ /* This is the first call, return the first option if there is one. */
+ result = (const uint8_t *) (ip6e + 1);
+ else
+ {
+ /* Make sure *TPTRP points to a beginning of a new option in
+ the message. The upper limit is checked in get_opt_end. */
+ if (*tptrp < (const uint8_t *) (ip6e + 1))
+ return -1;
+
+ /* Get the beginning of the next option. */
+ if (get_opt_end (&result, *tptrp, endp) != 0)
+ return -1;
+ }
+
+ /* We know where the next option starts. */
+ *tptrp = (uint8_t *) result;
+
+ /* Check the option is fully represented in the message. */
+ return get_opt_end (&result, result, endp);
+}
+
+
+/* RFC 2292, 6.3.6
+
+ This function is similar to the previously described
+ inet6_option_next() function, except this function lets the caller
+ specify the option type to be searched for, instead of always
+ returning the next option in the ancillary data object. cmsg is a
+ pointer to cmsghdr structure of which cmsg_level equals IPPROTO_IPV6
+ and cmsg_type equals either IPV6_HOPOPTS or IPV6_DSTOPTS. */
+int
+inet6_option_find (cmsg, tptrp, type)
+ const struct cmsghdr *cmsg;
+ uint8_t **tptrp;
+ int type;
+{
+ /* Make sure it is an option of the right type. */
+ if (cmsg->cmsg_level != IPPROTO_IPV6
+ || (cmsg->cmsg_type != IPV6_HOPOPTS && cmsg->cmsg_type != IPV6_DSTOPTS))
+ return -1;
+
+ /* Pointer to the extension header. We only compute the address, we
+ don't access anything yet. */
+ const struct ip6_ext *ip6e = (const struct ip6_ext *) CMSG_DATA (cmsg);
+
+ /* Make sure the message is long enough. */
+ if (cmsg->cmsg_len < CMSG_LEN (sizeof (struct ip6_ext))
+ /* Now we can access the extension header. */
+ || cmsg->cmsg_len < CMSG_LEN ((ip6e->ip6e_len + 1) * 8))
+ /* Too small. */
+ return -1;
+
+ /* Determine the address of the byte past the message. */
+ const uint8_t *endp = CMSG_DATA (cmsg) + (ip6e->ip6e_len + 1) * 8;
+
+ const uint8_t *next;
+ if (tptrp == NULL)
+ /* This is the first call, return the first option if there is one. */
+ next = (const uint8_t *) (ip6e + 1);
+ else
+ {
+ /* Make sure *TPTRP points to a beginning of a new option in
+ the message. The upper limit is checked in get_opt_end. */
+ if (*tptrp < (const uint8_t *) (ip6e + 1))
+ return -1;
+
+ /* Get the beginning of the next option. */
+ if (get_opt_end (&next, *tptrp, endp) != 0)
+ return -1;
+ }
+
+ /* Now search for the appropriate typed entry. */
+ const uint8_t *result;
+ do
+ {
+ result = next;
+
+ /* Get the end of this entry. */
+ if (get_opt_end (&next, result, endp) != 0)
+ return -1;
+ }
+ while (*result != type);
+
+ /* We know where the next option starts. */
+ *tptrp = (uint8_t *) result;
+
+ /* Success. */
+ return 0;
+}
diff --git a/inet/netinet/in.h b/inet/netinet/in.h
index a87f35e99a..9f969ccc5c 100644
--- a/inet/netinet/in.h
+++ b/inet/netinet/in.h
@@ -21,6 +21,7 @@
#include <features.h>
#include <stdint.h>
+#include <sys/socket.h>
#include <bits/types.h>
@@ -366,6 +367,23 @@ struct in6_pktinfo
unsigned int ipi6_ifindex; /* send/recv interface index */
};
+
+#ifdef __USE_GNU
+/* Hop-by-Hop and Destination Options Processing. */
+extern int inet6_option_space (int __nbytes);
+extern int inet6_option_init (void *__bp, struct cmsghdr **__cmsgp,
+ int __type);
+extern int inet6_option_append (struct cmsghdr *__cmsg,
+ __const uint8_t *__typep, int __multx,
+ int __plusy);
+extern uint8_t *inet6_option_alloc (struct cmsghdr *__cmsg, int __datalen,
+ int __multx, int __plusy);
+extern int inet6_option_next (__const struct cmsghdr *__cmsg,
+ uint8_t **__tptrp);
+extern int inet6_option_find (__const struct cmsghdr *__cmsg,
+ uint8_t **__tptrp, int __type);
+#endif /* use GNU */
+
__END_DECLS
#endif /* netinet/in.h */
diff --git a/inet/netinet/ip6.h b/inet/netinet/ip6.h
index c6fc2b31c7..7045836df6 100644
--- a/inet/netinet/ip6.h
+++ b/inet/netinet/ip6.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 1991-1997, 2001 Free Software Foundation, Inc.
+/* Copyright (C) 1991-1997, 2001, 2003 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
@@ -47,51 +47,58 @@ struct ip6_hdr
#define ip6_hlim ip6_ctlun.ip6_un1.ip6_un1_hlim
#define ip6_hops ip6_ctlun.ip6_un1.ip6_un1_hlim
+/* Generic extension header. */
+struct ip6_ext
+ {
+ uint8_t ip6e_nxt; /* next header. */
+ uint8_t ip6e_len; /* length in units of 8 octets. */
+ };
+
/* Hop-by-Hop options header. */
struct ip6_hbh
{
- uint8_t ip6h_nxt; /* next hesder. */
- uint8_t ip6h_len; /* length in units of 8 octets. */
+ uint8_t ip6h_nxt; /* next header. */
+ uint8_t ip6h_len; /* length in units of 8 octets. */
/* followed by options */
};
/* Destination options header */
struct ip6_dest
{
- uint8_t ip6d_nxt; /* next header */
- uint8_t ip6d_len; /* length in units of 8 octets */
+ uint8_t ip6d_nxt; /* next header */
+ uint8_t ip6d_len; /* length in units of 8 octets */
/* followed by options */
};
/* Routing header */
struct ip6_rthdr
{
- uint8_t ip6r_nxt; /* next header */
- uint8_t ip6r_len; /* length in units of 8 octets */
- uint8_t ip6r_type; /* routing type */
- uint8_t ip6r_segleft; /* segments left */
+ uint8_t ip6r_nxt; /* next header */
+ uint8_t ip6r_len; /* length in units of 8 octets */
+ uint8_t ip6r_type; /* routing type */
+ uint8_t ip6r_segleft; /* segments left */
/* followed by routing type specific data */
};
/* Type 0 Routing header */
struct ip6_rthdr0
{
- uint8_t ip6r0_nxt; /* next header */
- uint8_t ip6r0_len; /* length in units of 8 octets */
- uint8_t ip6r0_type; /* always zero */
- uint8_t ip6r0_segleft; /* segments left */
- uint8_t ip6r0_reserved; /* reserved field */
- uint8_t ip6r0_slmap[3]; /* strict/loose bit map */
+ uint8_t ip6r0_nxt; /* next header */
+ uint8_t ip6r0_len; /* length in units of 8 octets */
+ uint8_t ip6r0_type; /* always zero */
+ uint8_t ip6r0_segleft; /* segments left */
+ uint8_t ip6r0_reserved; /* reserved field */
+ uint8_t ip6r0_slmap[3]; /* strict/loose bit map */
struct in6_addr ip6r0_addr[1]; /* up to 23 addresses */
};
/* Fragment header */
struct ip6_frag
{
- uint8_t ip6f_nxt; /* next header */
- uint8_t ip6f_reserved; /* reserved field */
- uint16_t ip6f_offlg; /* offset, reserved, and flag */
- uint32_t ip6f_ident; /* identification */
+ uint8_t ip6f_nxt; /* next header */
+ uint8_t ip6f_reserved; /* reserved field */
+ uint16_t ip6f_offlg; /* offset, reserved, and flag */
+ uint32_t ip6f_ident; /* identification */
};
#if BYTE_ORDER == BIG_ENDIAN
@@ -104,4 +111,8 @@ struct ip6_frag
#define IP6F_MORE_FRAG 0x0100 /* more-fragments flag */
#endif
+/* Special option types for padding. */
+#define IP6OPT_PAD1 0
+#define IP6OPT_PADN 1
+
#endif /* netinet/ip6.h */