* net.cc (free_char_list): Delete.

(dup_addr_list): Delete.
(dup_char_list): Delete.
(free_hostent_ptr): Delete.
(free_protoent_ptr): Delete.
(free_servent_ptr): Delete.
(DWORD_round): New function.
(strlen_round): New function.  Returns strlen rounded up to word size.
(dup_ent): New, generic function to duplicate a {host,proto,serv}ent structure.
(gen_ent): New macro.  Generates a generic dup_{host,proto,serv}ent_ptr
function.
(cygwin_getservbyname): Remove call to free_servent_ptr, pass servent_buf to
dup_servent_ptr.
(cygwin_getservbyport): Ditto.
(cygwin_gethostbyname): Ditto for hostent.
(cygwin_gethostbyaddr): Ditto.
(cygwin_getprotobyname): Ditto for protoent.
(cygwin_getprotobynumber): Ditto.

winsup/cygwin/ChangeLog

@@ -1,3 +1,25 @@
+2003-08-31  Christopher Faylor  <cgf@redhat.com>
+
+	* net.cc (free_char_list): Delete.
+	(dup_addr_list): Delete.
+	(dup_char_list): Delete.
+	(free_hostent_ptr): Delete.
+	(free_protoent_ptr): Delete.
+	(free_servent_ptr): Delete.
+	(DWORD_round): New function.
+	(strlen_round): New function.  Returns strlen rounded up to word size.
+	(dup_ent): New, generic function to duplicate a {host,proto,serv}ent
+	structure.
+	(gen_ent): New macro.  Generates a generic dup_{host,proto,serv}ent_ptr
+	function.
+	(cygwin_getservbyname): Remove call to free_servent_ptr, pass
+	servent_buf to dup_servent_ptr.
+	(cygwin_getservbyport): Ditto.
+	(cygwin_gethostbyname): Ditto for hostent.
+	(cygwin_gethostbyaddr): Ditto.
+	(cygwin_getprotobyname): Ditto for protoent.
+	(cygwin_getprotobynumber): Ditto.
+
 2003-08-31  Christopher Faylor  <cgf@redhat.com>
 
 	* Makefile.in (MALLOC_OFILES): Always fill in with correct malloc

winsup/cygwin/heap.cc

@@ -139,7 +139,6 @@ sbrk (int n)
   /* Couldn't allocate memory.  Maybe we can reserve some more.
      Reserve either the maximum of the standard cygwin_shared->heap_chunk_size ()
      or the requested amount.  Then attempt to actually allocate it.  */
-
   if ((newbrksize = cygheap->user_heap.chunk) < commitbytes)
     newbrksize = commitbytes;
 
@@ -147,7 +146,7 @@ sbrk (int n)
         || VirtualAlloc (cygheap->user_heap.top, newbrksize = commitbytes, MEM_RESERVE, PAGE_NOACCESS))
        && VirtualAlloc (cygheap->user_heap.top, commitbytes, MEM_COMMIT, PAGE_READWRITE) != NULL)
      {
-	(char *) cygheap->user_heap.max += newbrksize;
+	(char *) cygheap->user_heap.max += pround (newbrksize);
 	goto good;
      }
 

winsup/cygwin/net.cc

@@ -25,6 +25,7 @@ details. */
 #include <netdb.h>
 #define USE_SYS_TYPES_FD_SET
 #include <winsock2.h>
+#include <assert.h>
 #include "cygerrno.h"
 #include "security.h"
 #include "fhandler.h"
@@ -381,96 +382,211 @@ set_host_errno ()
     h_errno = NETDB_INTERNAL;
 }
 
-static void
+inline int
-free_char_list (char **clist)
+DWORD_round (int n)
 {
-  if (clist)
+  return sizeof (DWORD) * (((n + sizeof (DWORD) - 1)) / sizeof (DWORD));
+}
+
+inline int
+strlen_round (const char *s)
+{
+  if (!s)
+    return 0;
+  return DWORD_round (strlen (s) + 1);
+}
+
+enum struct_type
+{
+  is_protoent, is_servent, is_hostent
+};
+
+#pragma pack(push,2)
+struct pservent
+{
+  char *s_name;
+  char **s_aliases;
+  short s_port;
+  char *s_proto;
+};
+#pragma pack(pop)
+
+struct unionent
+{
+  char *name;
+  char **list;
+  short port_proto_addrtype;
+  short h_len;
+  union
+  {
+    char *s_proto;
+    char **h_addr_list;
+  };
+};
+
+/* Generic "dup a {host,proto,serv}ent structure" function.
+   This is complicated because we need to be able to free the
+   structure at any point and we can't rely on the pointer contents
+   being untouched by callers.  So, we allocate a chunk of memory
+   large enough to hold the structure and all of the stuff it points
+   to then we copy the source into this new block of memory.
+   The 'unionent' struct is a union of all of the currently used
+   *ent structure.  */
+
+#ifdef DEBUGGING
+static void *
+#else
+static inline void *
+#endif
+dup_ent (void *src0, struct_type type)
+{
+  unionent *src = (unionent *) src0;
+
+  /* Find the size of the raw structure minus any character strings, etc. */
+  int sz, struct_sz;
+  switch (type)
     {
-      for (char **cl = clist; *cl; ++cl)
+    case is_protoent:
-	free (*cl);
+      struct_sz = sizeof (protoent);
-      free (clist);
+      break;
+    case is_servent:
+      struct_sz = sizeof (servent);
+      break;
+    case is_hostent:
+      struct_sz = sizeof (hostent);
+      break;
+    default:
+      api_fatal ("called with invalid value %d", type);
+      break;
     }
-}
 
-static char **
+  /* Every *ent begins with a name.  Calculate it's length. */
-dup_char_list (char **src)
+  int namelen = strlen_round (src->name);
-{
+  sz = struct_sz + namelen;
-  char **dst;
-  int cnt = 0;
 
-  for (char **cl = src; *cl; ++cl)
+  char **av;
-    ++cnt;
+  /* The next field in every *ent is an argv list of "something".
-  if (!(dst = (char **) calloc (cnt + 1, sizeof *dst)))
+     Calculate the number of components and how much space the
-    return NULL;
+     character strings will take.  */
-  while (cnt-- > 0)
+  int list_len = 0;
-    if (!(dst[cnt] = strdup (src[cnt])))
+  for (av = src->list; av && *av; av++)
-      return NULL;
-  return dst;
-}
-
-#define free_addr_list(addr_list)	free_char_list (addr_list)
-
-static char **
-dup_addr_list (char **src, unsigned int size)
-{
-  char **dst;
-  int cnt = 0;
-
-  for (char **cl = src; *cl; ++cl)
-    ++cnt;
-  if (!(dst = (char **) calloc (cnt + 1, sizeof *dst)))
-    return NULL;
-  while (cnt-- > 0)
     {
-      if (!(dst[cnt] = (char *) malloc (size)))
+      list_len++;
-	return NULL;
+      sz += sizeof (char **) + strlen_round (*av);
-      memcpy (dst[cnt], src[cnt], size);
+    }
+
+  /* NULL terminate if there actually was a list */
+  if (av)
+    {
+      sz += sizeof (char **);
+      list_len++;
+    }
+
+  /* Do servent/hostent specific processing */
+  int protolen = 0;
+  int addr_list_len = 0;
+  if (type == is_servent)
+    sz += (protolen = strlen_round (src->s_proto));
+  else if (type == is_hostent)
+    {
+      /* Calculate the length and storage used for h_addr_list */
+      for (av = src->h_addr_list; av && *av; av++)
+	{
+	  addr_list_len++;
+	  sz += sizeof (char **) + DWORD_round (src->h_len);
+	}
+      if (av)
+	{
+	  sz += sizeof (char **);
+	  addr_list_len++;
+	}
+    }
+
+  /* Allocate the storage needed */
+  unionent *dst = (unionent *) calloc (1, sz);
+
+  /* Hopefully, this worked. */
+  if (dst)
+    {
+      /* This field is common to all *ent structures but named differently
+	 in each, of course.  */
+      dst->port_proto_addrtype = src->port_proto_addrtype;
+
+      /* Copy the name field to dst, using space just beyond the end of
+	 the dst structure. */
+      char *dp = ((char *) dst) + struct_sz;
+      strcpy (dst->name = dp, src->name);
+      dp += namelen;
+
+      /* Copy the 'list' type to dst, using space beyond end of structure
+	 + storage for name. */
+      if (src->list)
+	{
+	  char **dav = dst->list = (char **) dp;
+	  dp += sizeof (char **) * list_len;
+	  for (av = src->list; av && *av; av++)
+	    {
+	      int len = strlen (*av) + 1;
+	      memcpy (*dav++ = dp, *av, len);
+	      dp += DWORD_round (len);
+	    }
+	}
+
+      /* Do servent/hostent specific processing. */
+      if (type == is_servent)
+	{
+	  if (src->s_proto)
+	    {
+	      char *s_proto;
+	      /* Windows 95 idiocy.  Structure is misaligned on Windows 95.
+		 Kludge around this by trying a different pointer alignment.  */
+	      if (IsBadReadPtr (src->s_proto, sizeof (src->s_proto))
+		  && !IsBadReadPtr (((pservent *) src)->s_proto, sizeof (src->s_proto)))
+		s_proto = ((pservent *) src)->s_proto;
+	      else
+		s_proto = src->s_proto;
+	      strcpy (dst->s_proto = dp, s_proto);
+	      dp += protolen;
+	    }
+	}
+      else if (type == is_hostent)
+	{
+	  /* Transfer h_len and duplicate contents of h_addr_list, using
+	     memory after 'list' allocation. */
+	  dst->h_len = src->h_len;
+	  char **dav = dst->h_addr_list = (char **) dp;
+	  dp += sizeof (char **) * addr_list_len;
+	  for (av = src->h_addr_list; av && *av; av++)
+	    {
+	      memcpy (*dav++ = dp, *av, src->h_len);
+	      dp += DWORD_round (src->h_len);
+	    }
+	}
+      /* Sanity check that we did our bookkeeping correctly. */
+      assert ((dp - (char *) dst) == sz);
     }
   return dst;
 }
 
-static void
+/* Generic macro to build a dup_{host,proto,serv}ent_ptr function.
-free_protoent_ptr (struct protoent *&p)
+   The *ent buffers are allocated by dup_ent as contiguous storage.
-{
+   Frees any previously exiting `old' storage, as well.  */
-  if (p)
+#define gen_ent(x, p)								\
-    {
+static x *									\
-      debug_printf ("protoent: %s", p->p_name);
+dup_##x##_ptr (x *old, x *src)							\
+{										\
+  if (old)									\
+    {										\
+      debug_printf ("freeing %s", old->p##_name);				\
+      free (old);								\
+    }										\
+  debug_printf ("%s", src ? "<null!>" : src->p##_name);				\
+  x *dst = (x *) dup_ent (src, is_##x);						\
+  debug_printf ("copied %s", dst ? "<null!>" : dst->p##_name);			\
+  return dst;									\
+}										\
 
-      if (p->p_name)
+gen_ent (protoent, p)
-	free (p->p_name);
-      free_char_list (p->p_aliases);
-      free ((void *) p);
-      p = NULL;
-    }
-}
-
-static struct protoent *
-dup_protoent_ptr (struct protoent *src)
-{
-  if (!src)
-    return NULL;
-
-  struct protoent *dst = (struct protoent *) calloc (1, sizeof *dst);
-
-  if (!dst)
-    return NULL;
-
-  debug_printf ("protoent: %s", src->p_name);
-
-  dst->p_proto = src->p_proto;
-  if (src->p_name && !(dst->p_name = strdup (src->p_name)))
-    goto out;
-  if (src->p_aliases && !(dst->p_aliases = dup_char_list (src->p_aliases)))
-    goto out;
-
-  debug_printf ("protoent: copied %s", dst->p_name);
-
-  return dst;
-
-out:
-  free_protoent_ptr (dst);
-  return NULL;
-}
 
 #ifdef _MT_SAFE
 #define protoent_buf  _reent_winsup ()->_protoent_buf
@@ -484,8 +600,7 @@ cygwin_getprotobyname (const char *p)
 {
   if (check_null_str_errno (p))
     return NULL;
-  free_protoent_ptr (protoent_buf);
+  protoent_buf = dup_protoent_ptr (protoent_buf, getprotobyname (p));
-  protoent_buf = dup_protoent_ptr (getprotobyname (p));
   if (!protoent_buf)
     set_winsock_errno ();
 
@@ -497,8 +612,7 @@ cygwin_getprotobyname (const char *p)
 extern "C" struct protoent *
 cygwin_getprotobynumber (int number)
 {
-  free_protoent_ptr (protoent_buf);
+  protoent_buf = dup_protoent_ptr (protoent_buf, getprotobynumber (number));
-  protoent_buf = dup_protoent_ptr (getprotobynumber (number));
   if (!protoent_buf)
     set_winsock_errno ();
 
@@ -828,70 +942,7 @@ cygwin_connect (int fd, const struct sockaddr *name, int namelen)
   return res;
 }
 
-static void
+gen_ent (servent, s)
-free_servent_ptr (struct servent *&p)
-{
-  if (p)
-    {
-      debug_printf ("servent: %s", p->s_name);
-
-      if (p->s_name)
-	free (p->s_name);
-      if (p->s_proto)
-	free (p->s_proto);
-      free_char_list (p->s_aliases);
-      free ((void *) p);
-      p = NULL;
-    }
-}
-
-#pragma pack(push,2)
-struct pservent
-{
-  char *s_name;
-  char **s_aliases;
-  short s_port;
-  char *s_proto;
-};
-
-#pragma pack(pop)
-static struct servent *
-dup_servent_ptr (struct servent *src)
-{
-  if (!src)
-    return NULL;
-
-  struct servent *dst = (struct servent *) calloc (1, sizeof *dst);
-
-  if (!dst)
-    return NULL;
-
-  debug_printf ("servent: %s", src->s_name);
-
-  dst->s_port = src->s_port;
-  if (src->s_name && !(dst->s_name = strdup (src->s_name)))
-    goto out;
-  if (src->s_aliases && !(dst->s_aliases = dup_char_list (src->s_aliases)))
-    goto out;
-  char *s_proto;
-
-  if (IsBadReadPtr (src->s_proto, sizeof (src->s_proto))
-      && !IsBadReadPtr (((pservent *) src)->s_proto, sizeof (src->s_proto)))
-    s_proto = ((pservent *) src)->s_proto;
-  else
-    s_proto = src->s_proto;
-
-  if (s_proto && !(dst->s_proto = strdup (s_proto)))
-    goto out;
-
-  debug_printf ("servent: copied %s", dst->s_name);
-
-  return dst;
-
-out:
-  free_servent_ptr (dst);
-  return NULL;
-}
 
 #ifdef _MT_SAFE
 #define servent_buf  _reent_winsup ()->_servent_buf
@@ -909,8 +960,7 @@ cygwin_getservbyname (const char *name, const char *proto)
       || (proto != NULL && check_null_str_errno (proto)))
     return NULL;
 
-  free_servent_ptr (servent_buf);
+  servent_buf = dup_servent_ptr (servent_buf, getservbyname (name, proto));
-  servent_buf = dup_servent_ptr (getservbyname (name, proto));
   if (!servent_buf)
     set_winsock_errno ();
 
@@ -927,8 +977,7 @@ cygwin_getservbyport (int port, const char *proto)
   if (proto != NULL && check_null_str_errno (proto))
     return NULL;
 
-  free_servent_ptr (servent_buf);
+  servent_buf = dup_servent_ptr (servent_buf, getservbyport (port, proto));
-  servent_buf = dup_servent_ptr (getservbyport (port, proto));
   if (!servent_buf)
     set_winsock_errno ();
 
@@ -959,53 +1008,7 @@ cygwin_gethostname (char *name, size_t len)
   return 0;
 }
 
-static void
+gen_ent (hostent, h)
-free_hostent_ptr (struct hostent *&p)
-{
-  if (p)
-    {
-      debug_printf ("hostent: %s", p->h_name);
-
-      if (p->h_name)
-	free ((void *) p->h_name);
-      free_char_list (p->h_aliases);
-      free_addr_list (p->h_addr_list);
-      free ((void *) p);
-      p = NULL;
-    }
-}
-
-static struct hostent *
-dup_hostent_ptr (struct hostent *src)
-{
-  if (!src)
-    return NULL;
-
-  struct hostent *dst = (struct hostent *) calloc (1, sizeof *dst);
-
-  if (!dst)
-    return NULL;
-
-  debug_printf ("hostent: %s", src->h_name);
-
-  dst->h_addrtype = src->h_addrtype;
-  dst->h_length = src->h_length;
-  if (src->h_name && !(dst->h_name = strdup (src->h_name)))
-    goto out;
-  if (src->h_aliases && !(dst->h_aliases = dup_char_list (src->h_aliases)))
-    goto out;
-  if (src->h_addr_list
-      && !(dst->h_addr_list = dup_addr_list (src->h_addr_list, src->h_length)))
-    goto out;
-
-  debug_printf ("hostent: copied %s", dst->h_name);
-
-  return dst;
-
-out:
-  free_hostent_ptr (dst);
-  return NULL;
-}
 
 #ifdef _MT_SAFE
 #define hostent_buf  _reent_winsup ()->_hostent_buf
@@ -1045,8 +1048,7 @@ cygwin_gethostbyname (const char *name)
       return &tmp;
     }
 
-  free_hostent_ptr (hostent_buf);
+  hostent_buf = dup_hostent_ptr (hostent_buf, gethostbyname (name));
-  hostent_buf = dup_hostent_ptr (gethostbyname (name));
   if (!hostent_buf)
     {
       set_winsock_errno ();
@@ -1069,8 +1071,7 @@ cygwin_gethostbyaddr (const char *addr, int len, int type)
   if (__check_invalid_read_ptr_errno (addr, len))
     return NULL;
 
-  free_hostent_ptr (hostent_buf);
+  hostent_buf = dup_hostent_ptr (hostent_buf, gethostbyaddr (addr, len, type));
-  hostent_buf = dup_hostent_ptr (gethostbyaddr (addr, len, type));
   if (!hostent_buf)
     {
       set_winsock_errno ();