Update.

2003-06-14  Ulrich Drepper  <drepper@redhat.com>

	* inet/netinet/ip6.h (IP6OPT_PAD1, IP6OPT_PADn): Define.
	* inet/netinet/in.h: Add prototypes for inet6_option_* functions.
	* inet/Makefile (routines): Add inet6_option.
	* inet/inet6_option.c: New file.
	* inet/Versions [GLIBC_2.3.3] (libc): Add inet6_option_space,
	inet6_option_init, inet6_option_append, inet6_option_alloc,
	inet6_option_next, and inet6_option_find.

	* inet/netinet/ip6.h (struct ip6_ext): Define.

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 */