(unix_ops): Mark as const.
[kopensolaris-gnu/glibc.git] / sunrpc / auth_unix.c
index 92703fb..1740e58 100644 (file)
@@ -1,4 +1,3 @@
-/* @(#)auth_unix.c     2.2 88/08/01 4.0 RPCSRC */
 /*
  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  * unrestricted use provided that this legend is included on all tape
 /*
  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  * unrestricted use provided that this legend is included on all tape
  * 2550 Garcia Avenue
  * Mountain View, California  94043
  */
  * 2550 Garcia Avenue
  * Mountain View, California  94043
  */
-#if !defined(lint) && defined(SCCSIDS)
-static char sccsid[] = "@(#)auth_unix.c 1.19 87/08/11 Copyr 1984 Sun Micro";
-#endif
-
 /*
 /*
- * auth_unix.c, Implements UNIX style authentication parameters.
- *
  * Copyright (C) 1984, Sun Microsystems, Inc.
  * Copyright (C) 1984, Sun Microsystems, Inc.
+ */
+/*
+ * auth_unix.c, Implements UNIX style authentication parameters.
  *
  * The system is very weak.  The client uses no encryption for it's
  * credentials and only sends null verifiers.  The server sends backs
  * null verifiers or optionally a verifier that suggests a new short hand
  * for the credentials.
  *
  * The system is very weak.  The client uses no encryption for it's
  * credentials and only sends null verifiers.  The server sends backs
  * null verifiers or optionally a verifier that suggests a new short hand
  * for the credentials.
- *
  */
 
  */
 
+#include <errno.h>
+#include <limits.h>
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <libintl.h>
+#include <sys/param.h>
 
 #include <rpc/types.h>
 #include <rpc/xdr.h>
 #include <rpc/auth.h>
 #include <rpc/auth_unix.h>
 
 
 #include <rpc/types.h>
 #include <rpc/xdr.h>
 #include <rpc/auth.h>
 #include <rpc/auth_unix.h>
 
+#ifdef USE_IN_LIBIO
+# include <wchar.h>
+#endif
+
 /*
  * Unix authenticator operations vector
  */
 /*
  * Unix authenticator operations vector
  */
-static void    authunix_nextverf();
-static bool_t  authunix_marshal();
-static bool_t  authunix_validate();
-static bool_t  authunix_refresh();
-static void    authunix_destroy();
-
-static struct auth_ops auth_unix_ops = {
-       authunix_nextverf,
-       authunix_marshal,
-       authunix_validate,
-       authunix_refresh,
-       authunix_destroy
+static void authunix_nextverf (AUTH *);
+static bool_t authunix_marshal (AUTH *, XDR *);
+static bool_t authunix_validate (AUTH *, struct opaque_auth *);
+static bool_t authunix_refresh (AUTH *);
+static void authunix_destroy (AUTH *);
+
+static const struct auth_ops auth_unix_ops = {
+  authunix_nextverf,
+  authunix_marshal,
+  authunix_validate,
+  authunix_refresh,
+  authunix_destroy
 };
 
 /*
  * This struct is pointed to by the ah_private field of an auth_handle.
  */
 struct audata {
 };
 
 /*
  * This struct is pointed to by the ah_private field of an auth_handle.
  */
 struct audata {
-       struct opaque_auth      au_origcred;    /* original credentials */
-       struct opaque_auth      au_shcred;      /* short hand cred */
-       u_long                  au_shfaults;    /* short hand cache faults */
-       char                    au_marshed[MAX_AUTH_BYTES];
-       u_int                   au_mpos;        /* xdr pos at end of marshed */
+  struct opaque_auth au_origcred;      /* original credentials */
+  struct opaque_auth au_shcred;        /* short hand cred */
+  u_long au_shfaults;          /* short hand cache faults */
+  char au_marshed[MAX_AUTH_BYTES];
+  u_int au_mpos;               /* xdr pos at end of marshed */
 };
 #define        AUTH_PRIVATE(auth)      ((struct audata *)auth->ah_private)
 
 };
 #define        AUTH_PRIVATE(auth)      ((struct audata *)auth->ah_private)
 
-static bool_t marshal_new_auth();
+static bool_t marshal_new_auth (AUTH *) internal_function;
 
 
 /*
 
 
 /*
@@ -87,213 +93,243 @@ static bool_t marshal_new_auth();
  * Returns an auth handle with the given stuff in it.
  */
 AUTH *
  * Returns an auth handle with the given stuff in it.
  */
 AUTH *
-authunix_create(machname, uid, gid, len, aup_gids)
-       char *machname;
-       int uid;
-       int gid;
-       register int len;
-       int *aup_gids;
+authunix_create (char *machname, uid_t uid, gid_t gid, int len,
+                gid_t *aup_gids)
 {
 {
-       struct authunix_parms aup;
-       char mymem[MAX_AUTH_BYTES];
-       struct timeval now;
-       XDR xdrs;
-       register AUTH *auth;
-       register struct audata *au;
-
-       /*
-        * Allocate and set up auth handle
-        */
-       auth = (AUTH *)mem_alloc(sizeof(*auth));
-#ifndef KERNEL
-       if (auth == NULL) {
-               (void)fprintf(stderr, "authunix_create: out of memory\n");
-               return (NULL);
-       }
-#endif
-       au = (struct audata *)mem_alloc(sizeof(*au));
-#ifndef KERNEL
-       if (au == NULL) {
-               (void)fprintf(stderr, "authunix_create: out of memory\n");
-               return (NULL);
-       }
-#endif
-       auth->ah_ops = &auth_unix_ops;
-       auth->ah_private = (caddr_t)au;
-       auth->ah_verf = au->au_shcred = _null_auth;
-       au->au_shfaults = 0;
-
-       /*
-        * fill in param struct from the given params
-        */
-       (void)gettimeofday(&now,  (struct timezone *)0);
-       aup.aup_time = now.tv_sec;
-       aup.aup_machname = machname;
-       aup.aup_uid = uid;
-       aup.aup_gid = gid;
-       aup.aup_len = (u_int)len;
-       aup.aup_gids = aup_gids;
-
-       /*
-        * Serialize the parameters into origcred
-        */
-       xdrmem_create(&xdrs, mymem, MAX_AUTH_BYTES, XDR_ENCODE);
-       if (! xdr_authunix_parms(&xdrs, &aup))
-               abort();
-       au->au_origcred.oa_length = len = XDR_GETPOS(&xdrs);
-       au->au_origcred.oa_flavor = AUTH_UNIX;
-#ifdef KERNEL
-       au->au_origcred.oa_base = mem_alloc((u_int) len);
-#else
-       if ((au->au_origcred.oa_base = mem_alloc((u_int) len)) == NULL) {
-               (void)fprintf(stderr, "authunix_create: out of memory\n");
-               return (NULL);
-       }
-#endif
-       bcopy(mymem, au->au_origcred.oa_base, (u_int)len);
-
-       /*
-        * set auth handle to reflect new cred.
-        */
-       auth->ah_cred = au->au_origcred;
-       marshal_new_auth(auth);
-       return (auth);
+  struct authunix_parms aup;
+  char mymem[MAX_AUTH_BYTES];
+  struct timeval now;
+  XDR xdrs;
+  AUTH *auth;
+  struct audata *au;
+
+  /*
+   * Allocate and set up auth handle
+   */
+  auth = (AUTH *) mem_alloc (sizeof (*auth));
+  au = (struct audata *) mem_alloc (sizeof (*au));
+  if (auth == NULL || au == NULL)
+    {
+no_memory:
+      (void) __fxprintf (NULL, "%s", _("authunix_create: out of memory\n"));
+      mem_free (auth, sizeof (*auth));
+      mem_free (au, sizeof (*au));
+      return NULL;
+    }
+  auth->ah_ops = (struct auth_ops *) &auth_unix_ops;
+  auth->ah_private = (caddr_t) au;
+  auth->ah_verf = au->au_shcred = _null_auth;
+  au->au_shfaults = 0;
+
+  /*
+   * fill in param struct from the given params
+   */
+  (void) __gettimeofday (&now, (struct timezone *) 0);
+  aup.aup_time = now.tv_sec;
+  aup.aup_machname = machname;
+  aup.aup_uid = uid;
+  aup.aup_gid = gid;
+  aup.aup_len = (u_int) len;
+  aup.aup_gids = aup_gids;
+
+  /*
+   * Serialize the parameters into origcred
+   */
+  INTUSE(xdrmem_create) (&xdrs, mymem, MAX_AUTH_BYTES, XDR_ENCODE);
+  if (!INTUSE(xdr_authunix_parms) (&xdrs, &aup))
+    abort ();
+  au->au_origcred.oa_length = len = XDR_GETPOS (&xdrs);
+  au->au_origcred.oa_flavor = AUTH_UNIX;
+  au->au_origcred.oa_base = mem_alloc ((u_int) len);
+  if (au->au_origcred.oa_base == NULL)
+    goto no_memory;
+  memcpy(au->au_origcred.oa_base, mymem, (u_int) len);
+
+  /*
+   * set auth handle to reflect new cred.
+   */
+  auth->ah_cred = au->au_origcred;
+  marshal_new_auth (auth);
+  return auth;
 }
 }
+INTDEF (authunix_create)
 
 /*
  * Returns an auth handle with parameters determined by doing lots of
  * syscalls.
  */
 AUTH *
 
 /*
  * Returns an auth handle with parameters determined by doing lots of
  * syscalls.
  */
 AUTH *
-authunix_create_default()
+authunix_create_default (void)
 {
 {
-       register int len;
-       char machname[MAX_MACHINE_NAME + 1];
-       register int uid;
-       register int gid;
-       int gids[NGRPS];
-
-       if (gethostname(machname, MAX_MACHINE_NAME) == -1)
-               abort();
-       machname[MAX_MACHINE_NAME] = 0;
-       uid = geteuid();
-       gid = getegid();
-       if ((len = getgroups(NGRPS, gids)) < 0)
-               abort();
-       return (authunix_create(machname, uid, gid, len, gids));
+  char machname[MAX_MACHINE_NAME + 1];
+
+  if (__gethostname (machname, MAX_MACHINE_NAME) == -1)
+    abort ();
+  machname[MAX_MACHINE_NAME] = 0;
+  uid_t uid = __geteuid ();
+  gid_t gid = __getegid ();
+
+  int max_nr_groups;
+  /* When we have to try a second time, do not use alloca() again.  We
+     might have reached the stack limit already.  */
+  bool retry = false;
+ again:
+  /* Ask the kernel how many groups there are exactly.  Note that we
+     might have to redo all this if the number of groups has changed
+     between the two calls.  */
+  max_nr_groups = __getgroups (0, NULL);
+
+  /* Just some random reasonable stack limit.  */
+#define ALLOCA_LIMIT (1024 / sizeof (gid_t))
+  gid_t *gids = NULL;
+  if (max_nr_groups < ALLOCA_LIMIT && ! retry)
+    gids = (gid_t *) alloca (max_nr_groups * sizeof (gid_t));
+  else
+    {
+      gids = (gid_t *) malloc (max_nr_groups * sizeof (gid_t));
+      if (gids == NULL)
+       return NULL;
+    }
+
+  int len = __getgroups (max_nr_groups, gids);
+  if (len == -1)
+    {
+      if (errno == EINVAL)
+       {
+         /* New groups added in the meantime.  Try again.  */
+         if (max_nr_groups >= ALLOCA_LIMIT || retry)
+           free (gids);
+         retry = true;
+         goto again;
+       }
+      /* No other error can happen.  */
+      abort ();
+    }
+
+  /* This braindamaged Sun code forces us here to truncate the
+     list of groups to NGRPS members since the code in
+     authuxprot.c transforms a fixed array.  Grrr.  */
+  AUTH *result = INTUSE(authunix_create) (machname, uid, gid, MIN (NGRPS, len),
+                                         gids);
+
+  if (max_nr_groups >= ALLOCA_LIMIT || retry)
+    free (gids);
+
+  return result;
 }
 }
+INTDEF (authunix_create_default)
 
 /*
  * authunix operations
  */
 
 static void
 
 /*
  * authunix operations
  */
 
 static void
-authunix_nextverf(auth)
-       AUTH *auth;
+authunix_nextverf (AUTH *auth)
 {
 {
-       /* no action necessary */
+  /* no action necessary */
 }
 
 static bool_t
 }
 
 static bool_t
-authunix_marshal(auth, xdrs)
-       AUTH *auth;
-       XDR *xdrs;
+authunix_marshal (AUTH *auth, XDR *xdrs)
 {
 {
-       register struct audata *au = AUTH_PRIVATE(auth);
+  struct audata *au = AUTH_PRIVATE (auth);
 
 
-       return (XDR_PUTBYTES(xdrs, au->au_marshed, au->au_mpos));
+  return XDR_PUTBYTES (xdrs, au->au_marshed, au->au_mpos);
 }
 
 static bool_t
 }
 
 static bool_t
-authunix_validate(auth, verf)
-       register AUTH *auth;
-       struct opaque_auth verf;
+authunix_validate (AUTH *auth, struct opaque_auth *verf)
 {
 {
-       register struct audata *au;
-       XDR xdrs;
-
-       if (verf.oa_flavor == AUTH_SHORT) {
-               au = AUTH_PRIVATE(auth);
-               xdrmem_create(&xdrs, verf.oa_base, verf.oa_length, XDR_DECODE);
-
-               if (au->au_shcred.oa_base != NULL) {
-                       mem_free(au->au_shcred.oa_base,
-                           au->au_shcred.oa_length);
-                       au->au_shcred.oa_base = NULL;
-               }
-               if (xdr_opaque_auth(&xdrs, &au->au_shcred)) {
-                       auth->ah_cred = au->au_shcred;
-               } else {
-                       xdrs.x_op = XDR_FREE;
-                       (void)xdr_opaque_auth(&xdrs, &au->au_shcred);
-                       au->au_shcred.oa_base = NULL;
-                       auth->ah_cred = au->au_origcred;
-               }
-               marshal_new_auth(auth);
+  struct audata *au;
+  XDR xdrs;
+
+  if (verf->oa_flavor == AUTH_SHORT)
+    {
+      au = AUTH_PRIVATE (auth);
+      INTUSE(xdrmem_create) (&xdrs, verf->oa_base, verf->oa_length,
+                            XDR_DECODE);
+
+      if (au->au_shcred.oa_base != NULL)
+       {
+         mem_free (au->au_shcred.oa_base,
+                   au->au_shcred.oa_length);
+         au->au_shcred.oa_base = NULL;
+       }
+      if (INTUSE(xdr_opaque_auth) (&xdrs, &au->au_shcred))
+       {
+         auth->ah_cred = au->au_shcred;
        }
        }
-       return (TRUE);
+      else
+       {
+         xdrs.x_op = XDR_FREE;
+         (void) INTUSE(xdr_opaque_auth) (&xdrs, &au->au_shcred);
+         au->au_shcred.oa_base = NULL;
+         auth->ah_cred = au->au_origcred;
+       }
+      marshal_new_auth (auth);
+    }
+  return TRUE;
 }
 
 static bool_t
 }
 
 static bool_t
-authunix_refresh(auth)
-       register AUTH *auth;
+authunix_refresh (AUTH *auth)
 {
 {
-       register struct audata *au = AUTH_PRIVATE(auth);
-       struct authunix_parms aup;
-       struct timeval now;
-       XDR xdrs;
-       register int stat;
-
-       if (auth->ah_cred.oa_base == au->au_origcred.oa_base) {
-               /* there is no hope.  Punt */
-               return (FALSE);
-       }
-       au->au_shfaults ++;
-
-       /* first deserialize the creds back into a struct authunix_parms */
-       aup.aup_machname = NULL;
-       aup.aup_gids = (int *)NULL;
-       xdrmem_create(&xdrs, au->au_origcred.oa_base,
-           au->au_origcred.oa_length, XDR_DECODE);
-       stat = xdr_authunix_parms(&xdrs, &aup);
-       if (! stat)
-               goto done;
-
-       /* update the time and serialize in place */
-       (void)gettimeofday(&now, (struct timezone *)0);
-       aup.aup_time = now.tv_sec;
-       xdrs.x_op = XDR_ENCODE;
-       XDR_SETPOS(&xdrs, 0);
-       stat = xdr_authunix_parms(&xdrs, &aup);
-       if (! stat)
-               goto done;
-       auth->ah_cred = au->au_origcred;
-       marshal_new_auth(auth);
+  struct audata *au = AUTH_PRIVATE (auth);
+  struct authunix_parms aup;
+  struct timeval now;
+  XDR xdrs;
+  int stat;
+
+  if (auth->ah_cred.oa_base == au->au_origcred.oa_base)
+    {
+      /* there is no hope.  Punt */
+      return FALSE;
+    }
+  au->au_shfaults++;
+
+  /* first deserialize the creds back into a struct authunix_parms */
+  aup.aup_machname = NULL;
+  aup.aup_gids = (gid_t *) NULL;
+  INTUSE(xdrmem_create) (&xdrs, au->au_origcred.oa_base,
+                        au->au_origcred.oa_length, XDR_DECODE);
+  stat = INTUSE(xdr_authunix_parms) (&xdrs, &aup);
+  if (!stat)
+    goto done;
+
+  /* update the time and serialize in place */
+  (void) __gettimeofday (&now, (struct timezone *) 0);
+  aup.aup_time = now.tv_sec;
+  xdrs.x_op = XDR_ENCODE;
+  XDR_SETPOS (&xdrs, 0);
+  stat = INTUSE(xdr_authunix_parms) (&xdrs, &aup);
+  if (!stat)
+    goto done;
+  auth->ah_cred = au->au_origcred;
+  marshal_new_auth (auth);
 done:
 done:
-       /* free the struct authunix_parms created by deserializing */
-       xdrs.x_op = XDR_FREE;
-       (void)xdr_authunix_parms(&xdrs, &aup);
-       XDR_DESTROY(&xdrs);
-       return (stat);
+  /* free the struct authunix_parms created by deserializing */
+  xdrs.x_op = XDR_FREE;
+  (void) INTUSE(xdr_authunix_parms) (&xdrs, &aup);
+  XDR_DESTROY (&xdrs);
+  return stat;
 }
 
 static void
 }
 
 static void
-authunix_destroy(auth)
-       register AUTH *auth;
+authunix_destroy (AUTH *auth)
 {
 {
-       register struct audata *au = AUTH_PRIVATE(auth);
+  struct audata *au = AUTH_PRIVATE (auth);
 
 
-       mem_free(au->au_origcred.oa_base, au->au_origcred.oa_length);
+  mem_free (au->au_origcred.oa_base, au->au_origcred.oa_length);
 
 
-       if (au->au_shcred.oa_base != NULL)
-               mem_free(au->au_shcred.oa_base, au->au_shcred.oa_length);
+  if (au->au_shcred.oa_base != NULL)
+    mem_free (au->au_shcred.oa_base, au->au_shcred.oa_length);
 
 
-       mem_free(auth->ah_private, sizeof(struct audata));
+  mem_free (auth->ah_private, sizeof (struct audata));
 
 
-       if (auth->ah_verf.oa_base != NULL)
-               mem_free(auth->ah_verf.oa_base, auth->ah_verf.oa_length);
+  if (auth->ah_verf.oa_base != NULL)
+    mem_free (auth->ah_verf.oa_base, auth->ah_verf.oa_length);
 
 
-       mem_free((caddr_t)auth, sizeof(*auth));
+  mem_free ((caddr_t) auth, sizeof (*auth));
 }
 
 /*
 }
 
 /*
@@ -301,19 +337,21 @@ authunix_destroy(auth)
  * sets private data, au_marshed and au_mpos
  */
 static bool_t
  * sets private data, au_marshed and au_mpos
  */
 static bool_t
-marshal_new_auth(auth)
-       register AUTH *auth;
+internal_function
+marshal_new_auth (AUTH *auth)
 {
 {
-       XDR             xdr_stream;
-       register XDR    *xdrs = &xdr_stream;
-       register struct audata *au = AUTH_PRIVATE(auth);
-
-       xdrmem_create(xdrs, au->au_marshed, MAX_AUTH_BYTES, XDR_ENCODE);
-       if ((! xdr_opaque_auth(xdrs, &(auth->ah_cred))) ||
-           (! xdr_opaque_auth(xdrs, &(auth->ah_verf)))) {
-               perror(_("auth_none.c - Fatal marshalling problem"));
-       } else {
-               au->au_mpos = XDR_GETPOS(xdrs);
-       }
-       XDR_DESTROY(xdrs);
+  XDR xdr_stream;
+  XDR *xdrs = &xdr_stream;
+  struct audata *au = AUTH_PRIVATE (auth);
+
+  INTUSE(xdrmem_create) (xdrs, au->au_marshed, MAX_AUTH_BYTES, XDR_ENCODE);
+  if ((!INTUSE(xdr_opaque_auth) (xdrs, &(auth->ah_cred))) ||
+      (!INTUSE(xdr_opaque_auth) (xdrs, &(auth->ah_verf))))
+    perror (_("auth_none.c - Fatal marshalling problem"));
+  else
+    au->au_mpos = XDR_GETPOS (xdrs);
+
+  XDR_DESTROY (xdrs);
+
+  return TRUE;
 }
 }