[glibc.git] / nis / nis_defaults.c

/* Copyright (c) 1997, 1998 Free Software Foundation, Inc.
   This file is part of the GNU C Library.
   Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1997.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public License as
   published by the Free Software Foundation; either version 2 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public
   License along with the GNU C Library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <rpc/rpc.h>
#include <rpcsvc/nis.h>

#define DEFAULT_TTL 43200

/*
** Some functions for parsing the -D param and NIS_DEFAULTS Environ
*/
static nis_name
searchgroup (char *str)
{
  char *cptr;
  int i;

  cptr = strstr (str, "group=");
  if (cptr == NULL)
    return NULL;

  cptr += 6;			/* points to the begin of the group string */
  i = 0;
  while (cptr[i] != '\0' && cptr[i] != ':')
    i++;
  if (i == 0)			/* only "group=" ? */
    return (nis_name) "";

  return strndup (cptr, i);
}

static nis_name
searchowner (char *str)
{
  char *cptr;
  int i;

  cptr = strstr (str, "owner=");
  if (cptr == NULL)
    return NULL;

  cptr += 6;			/* points to the begin of the owner string */
  i = 0;
  while (cptr[i] != '\0' && cptr[i] != ':')
    i++;
  if (i == 0)			/* only "owner=" ? */
    return strdup ("");

  return strndup (cptr, i);
}

static uint32_t
searchttl (char *str)
{
  char buf[strlen (str) + 1];
  char *cptr, *dptr;
  uint32_t time;
  int i;

  dptr = strstr (str, "ttl=");
  if (dptr == NULL)		/* should (could) not happen */
    return DEFAULT_TTL;;

  dptr += 4;			/* points to the begin of the new ttl */
  i = 0;
  while (dptr[i] != '\0' && dptr[i] != ':')
    i++;
  if (i == 0)			/* only "ttl=" ? */
    return DEFAULT_TTL;

  strncpy (buf, dptr, i);
  buf[i] = '\0';
  time = 0;

  dptr = buf;
  cptr = strchr (dptr, 'd');
  if (cptr != NULL)
    {
      *cptr = '\0';
      cptr++;
      time += atoi (dptr) * 60 * 60 * 24;
      dptr = cptr;
    }

  cptr = strchr (dptr, 'h');
  if (cptr != NULL)
    {
      *cptr = '\0';
      cptr++;
      time += atoi (dptr) * 60 * 60;
      dptr = cptr;
    }

  cptr = strchr (dptr, 'm');
  if (cptr != NULL)
    {
      *cptr = '\0';
      cptr++;
      time += atoi (dptr) * 60;
      dptr = cptr;
    }

  cptr = strchr (dptr, 's');
  if (cptr != NULL)
    *cptr = '\0';

  time += atoi (dptr);

  return time;
}

static unsigned int
searchaccess (char *str, unsigned int access)
{
  char buf[strlen (str) + 1];
  char *cptr;
  unsigned int result = access;
  int i;
  int n, o, g, w;

  cptr = strstr (str, "access=");
  if (cptr == NULL)
    return 0;

  cptr += 7;			/* points to the begin of the access string */
  i = 0;
  while (cptr[i] != '\0' && cptr[i] != ':')
    i++;
  if (i == 0)			/* only "access=" ? */
    return 0;

  strncpy (buf, cptr, i);
  buf[i] = '\0';

  n = o = g = w = 0;
  cptr = buf;
  if (*cptr == ',') /* Fix for stupid Solaris scripts */
    ++cptr;
  while (*cptr != '\0')
    {
      switch (*cptr)
	{
	case 'n':
	  n = 1;
	  break;
	case 'o':
	  o = 1;
	  break;
	case 'g':
	  g = 1;
	  break;
	case 'w':
	  w = 1;
	  break;
	case 'a':
	  o = g = w = 1;
	  break;
	case '-':
	  cptr++;		/* Remove "-" from beginning */
	  while (*cptr != '\0' && *cptr != ',')
	    {
	      switch (*cptr)
		{
		case 'r':
		  if (n)
		    result = result & ~(NIS_READ_ACC << 24);
		  if (o)
		    result = result & ~(NIS_READ_ACC << 16);
		  if (g)
		    result = result & ~(NIS_READ_ACC << 8);
		  if (w)
		    result = result & ~(NIS_READ_ACC);
		  break;
		case 'm':
		  if (n)
		    result = result & ~(NIS_MODIFY_ACC << 24);
		  if (o)
		    result = result & ~(NIS_MODIFY_ACC << 16);
		  if (g)
		    result = result & ~(NIS_MODIFY_ACC << 8);
		  if (w)
		    result = result & ~(NIS_MODIFY_ACC);
		  break;
		case 'c':
		  if (n)
		    result = result & ~(NIS_CREATE_ACC << 24);
		  if (o)
		    result = result & ~(NIS_CREATE_ACC << 16);
		  if (g)
		    result = result & ~(NIS_CREATE_ACC << 8);
		  if (w)
		    result = result & ~(NIS_CREATE_ACC);
		  break;
		case 'd':
		  if (n)
		    result = result & ~(NIS_DESTROY_ACC << 24);
		  if (o)
		    result = result & ~(NIS_DESTROY_ACC << 16);
		  if (g)
		    result = result & ~(NIS_DESTROY_ACC << 8);
		  if (w)
		    result = result & ~(NIS_DESTROY_ACC);
		  break;
		default:
		  return (~0U);
		}
	      cptr++;
	    }
	  n = o = g = w = 0;
	  break;
	case '+':
	  cptr++;		/* Remove "+" from beginning */
	  while (*cptr != '\0' && *cptr != ',')
	    {
	      switch (*cptr)
		{
		case 'r':
		  if (n)
		    result = result | (NIS_READ_ACC << 24);
		  if (o)
		    result = result | (NIS_READ_ACC << 16);
		  if (g)
		    result = result | (NIS_READ_ACC << 8);
		  if (w)
		    result = result | (NIS_READ_ACC);
		  break;
		case 'm':
		  if (n)
		    result = result | (NIS_MODIFY_ACC << 24);
		  if (o)
		    result = result | (NIS_MODIFY_ACC << 16);
		  if (g)
		    result = result | (NIS_MODIFY_ACC << 8);
		  if (w)
		    result = result | (NIS_MODIFY_ACC);
		  break;
		case 'c':
		  if (n)
		    result = result | (NIS_CREATE_ACC << 24);
		  if (o)
		    result = result | (NIS_CREATE_ACC << 16);
		  if (g)
		    result = result | (NIS_CREATE_ACC << 8);
		  if (w)
		    result = result | (NIS_CREATE_ACC);
		  break;
		case 'd':
		  if (n)
		    result = result | (NIS_DESTROY_ACC << 24);
		  if (o)
		    result = result | (NIS_DESTROY_ACC << 16);
		  if (g)
		    result = result | (NIS_DESTROY_ACC << 8);
		  if (w)
		    result = result | (NIS_DESTROY_ACC);
		  break;
		default:
		  return (~0U);
		}
	      cptr++;
	    }
	  n = o = g = w = 0;
	  break;
	case '=':
	  cptr++;		/* Remove "=" from beginning */
	  /* Clear */
	  if (n)
	    result = result & ~((NIS_READ_ACC + NIS_MODIFY_ACC +
				 NIS_CREATE_ACC + NIS_DESTROY_ACC) << 24);

	  if (o)
	    result = result & ~((NIS_READ_ACC + NIS_MODIFY_ACC +
				 NIS_CREATE_ACC + NIS_DESTROY_ACC) << 16);
	  if (g)
	    result = result & ~((NIS_READ_ACC + NIS_MODIFY_ACC +
				 NIS_CREATE_ACC + NIS_DESTROY_ACC) << 8);
	  if (w)
	    result = result & ~(NIS_READ_ACC + NIS_MODIFY_ACC +
				NIS_CREATE_ACC + NIS_DESTROY_ACC);
	  while (*cptr != '\0' && *cptr != ',')
	    {
	      switch (*cptr)
		{
		case 'r':
		  if (n)
		    result = result | (NIS_READ_ACC << 24);
		  if (o)
		    result = result | (NIS_READ_ACC << 16);
		  if (g)
		    result = result | (NIS_READ_ACC << 8);
		  if (w)
		    result = result | (NIS_READ_ACC);
		  break;
		case 'm':
		  if (n)
		    result = result | (NIS_MODIFY_ACC << 24);
		  if (o)
		    result = result | (NIS_MODIFY_ACC << 16);
		  if (g)
		    result = result | (NIS_MODIFY_ACC << 8);
		  if (w)
		    result = result | (NIS_MODIFY_ACC);
		  break;
		case 'c':
		  if (n)
		    result = result | (NIS_CREATE_ACC << 24);
		  if (o)
		    result = result | (NIS_CREATE_ACC << 16);
		  if (g)
		    result = result | (NIS_CREATE_ACC << 8);
		  if (w)
		    result = result | (NIS_CREATE_ACC);
		  break;
		case 'd':
		  if (n)
		    result = result | (NIS_DESTROY_ACC << 24);
		  if (o)
		    result = result | (NIS_DESTROY_ACC << 16);
		  if (g)
		    result = result | (NIS_DESTROY_ACC << 8);
		  if (w)
		    result = result | (NIS_DESTROY_ACC);
		  break;
		default:
		  return result = (~0U);
		}
	      cptr++;
	    }
	  n = o = g = w = 0;
	  break;
	default:
	  return result = (~0U);
	}
      if (*cptr != '\0')
	cptr++;
    }

  return result;
}

nis_name
__nis_default_owner (char *defaults)
{
  char default_owner[NIS_MAXNAMELEN + 1];
  char *cptr, *dptr;

  strcpy (default_owner, nis_local_principal ());

  if (defaults != NULL)
    {
      dptr = strstr (defaults, "owner=");
      if (dptr != NULL)
	{
	  char *p = searchowner (defaults);
	  if (strlen (p) <= NIS_MAXNAMELEN)
	    strcpy (default_owner, p);
	  free (p);
	}
    }
  else
    {
      cptr = getenv ("NIS_DEFAULTS");
      if (cptr != NULL)
	{
	  dptr = strstr (cptr, "owner=");
	  if (dptr != NULL)
	    {
	      char *p = searchowner (cptr);
	      if (strlen (p) <= NIS_MAXNAMELEN)
		strcpy (default_owner, p);
	      free (p);
	    }
	}
    }

  return strdup (default_owner);
}

nis_name
__nis_default_group (char *defaults)
{
  char default_group[NIS_MAXNAMELEN + 1];
  char *cptr, *dptr;

  strcpy (default_group, nis_local_group ());

  if (defaults != NULL)
    {
      dptr = strstr (defaults, "group=");
      if (dptr != NULL)
	{
	  char *p = searchgroup (defaults);

	  if (strlen (p) <= NIS_MAXNAMELEN)
	    strcpy (default_group, p);
	  free (p);
	}
    }
  else
    {
      cptr = getenv ("NIS_DEFAULTS");
      if (cptr != NULL)
	{
	  dptr = strstr (cptr, "group=");
	  if (dptr != NULL)
	    {
	      char *p = searchgroup (cptr);

	      if (strlen (p) <= NIS_MAXNAMELEN)
		strcpy (default_group, p);
	      free (p);
	    }
	}
    }

  return strdup (default_group);
}

uint32_t
__nis_default_ttl (char *defaults)
{
  char *cptr, *dptr;

  if (defaults != NULL)
    {
      dptr = strstr (defaults, "ttl=");
      if (dptr != NULL)
	return searchttl (defaults);
    }

  cptr = getenv ("NIS_DEFAULTS");
  if (cptr == NULL)
    return DEFAULT_TTL;

  dptr = strstr (cptr, "ttl=");
  if (dptr == NULL)
    return DEFAULT_TTL;

  return searchttl (cptr);
}

/* Default access rights are ----rmcdr---r---, but we could change
   this with the NIS_DEFAULTS variable. */
unsigned int
__nis_default_access (char *param, unsigned int defaults)
{
  unsigned int result;
  char *cptr;

  if (defaults == 0)
    result = 0 | OWNER_DEFAULT | GROUP_DEFAULT | WORLD_DEFAULT;
  else
    result = defaults;

  if (param != NULL && strstr (param, "access=") != NULL)
    result = searchaccess (param, result);
  else
    {
      cptr = getenv ("NIS_DEFAULTS");
      if (cptr != NULL && strstr (cptr, "access=") != NULL)
	result = searchaccess (getenv ("NIS_DEFAULTS"), result);
    }

  return result;
}
Commit	Line	Data
3519948b	1	/* Copyright (c) 1997, 1998 Free Software Foundation, Inc.
51702635 UD	2	This file is part of the GNU C Library.
	3	Contributed by Thorsten Kukuk <kukuk@vt.uni-paderborn.de>, 1997.
	4
	5	The GNU C Library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Library General Public License as
	7	published by the Free Software Foundation; either version 2 of the
	8	License, or (at your option) any later version.
	9
	10	The GNU C Library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	Library General Public License for more details.
	14
	15	You should have received a copy of the GNU Library General Public
	16	License along with the GNU C Library; see the file COPYING.LIB. If not,
	17	write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	18	Boston, MA 02111-1307, USA. */
	19
	20	#include <stdio.h>
	21	#include <stdlib.h>
	22	#include <string.h>
	23	#include <sys/types.h>
	24	#include <rpc/rpc.h>
	25	#include <rpcsvc/nis.h>
51702635 UD	26
	27	#define DEFAULT_TTL 43200
	28
	29	/*
	30	** Some functions for parsing the -D param and NIS_DEFAULTS Environ
	31	*/
	32	static nis_name
	33	searchgroup (char *str)
	34	{
dfd2257a	35	char *cptr;
51702635 UD	36	int i;
	37
	38	cptr = strstr (str, "group=");
	39	if (cptr == NULL)
	40	return NULL;
	41
	42	cptr += 6; /* points to the begin of the group string */
	43	i = 0;
	44	while (cptr[i] != '\0' && cptr[i] != ':')
	45	i++;
	46	if (i == 0) /* only "group=" ? */
714a562f	47	return (nis_name) "";
51702635	48
dfd2257a	49	return strndup (cptr, i);
51702635 UD	50	}
	51
	52	static nis_name
	53	searchowner (char *str)
	54	{
51702635 UD	55	char *cptr;
	56	int i;
	57
	58	cptr = strstr (str, "owner=");
	59	if (cptr == NULL)
	60	return NULL;
	61
	62	cptr += 6; /* points to the begin of the owner string */
	63	i = 0;
	64	while (cptr[i] != '\0' && cptr[i] != ':')
	65	i++;
	66	if (i == 0) /* only "owner=" ? */
dfd2257a	67	return strdup ("");
51702635	68
dfd2257a	69	return strndup (cptr, i);
51702635 UD	70	}
51702635 UD	71
a1129917	72	static uint32_t
51702635 UD	73	searchttl (char *str)
51702635 UD	74	{
3519948b	75	char buf[strlen (str) + 1];
51702635	76	char cptr, dptr;
a1129917	77	uint32_t time;
51702635 UD	78	int i;
	79
	80	dptr = strstr (str, "ttl=");
	81	if (dptr == NULL) /* should (could) not happen */
	82	return DEFAULT_TTL;;
	83
	84	dptr += 4; /* points to the begin of the new ttl */
	85	i = 0;
	86	while (dptr[i] != '\0' && dptr[i] != ':')
	87	i++;
	88	if (i == 0) /* only "ttl=" ? */
	89	return DEFAULT_TTL;
	90
	91	strncpy (buf, dptr, i);
3519948b	92	buf[i] = '\0';
51702635 UD	93	time = 0;
	94
	95	dptr = buf;
	96	cptr = strchr (dptr, 'd');
	97	if (cptr != NULL)
	98	{
	99	*cptr = '\0';
	100	cptr++;
	101	time += atoi (dptr) * 60 * 60 * 24;
	102	dptr = cptr;
	103	}
	104
	105	cptr = strchr (dptr, 'h');
	106	if (cptr != NULL)
	107	{
	108	*cptr = '\0';
	109	cptr++;
	110	time += atoi (dptr) * 60 * 60;
	111	dptr = cptr;
	112	}
	113
	114	cptr = strchr (dptr, 'm');
	115	if (cptr != NULL)
	116	{
	117	*cptr = '\0';
	118	cptr++;
	119	time += atoi (dptr) * 60;
	120	dptr = cptr;
	121	}
	122
	123	cptr = strchr (dptr, 's');
	124	if (cptr != NULL)
	125	*cptr = '\0';
	126
	127	time += atoi (dptr);
	128
	129	return time;
	130	}
	131
a1129917 UD	132	static unsigned int
a1129917 UD	133	searchaccess (char *str, unsigned int access)
51702635	134	{
3519948b	135	char buf[strlen (str) + 1];
51702635	136	char *cptr;
a1129917	137	unsigned int result = access;
51702635 UD	138	int i;
	139	int n, o, g, w;
	140
	141	cptr = strstr (str, "access=");
	142	if (cptr == NULL)
	143	return 0;
	144
	145	cptr += 7; /* points to the begin of the access string */
	146	i = 0;
	147	while (cptr[i] != '\0' && cptr[i] != ':')
	148	i++;
	149	if (i == 0) /* only "access=" ? */
	150	return 0;
	151
	152	strncpy (buf, cptr, i);
3519948b	153	buf[i] = '\0';
51702635	154
dfd2257a	155	n = o = g = w = 0;
51702635	156	cptr = buf;
3519948b UD	157	if (cptr == ',') / Fix for stupid Solaris scripts */
3519948b UD	158	++cptr;
51702635 UD	159	while (*cptr != '\0')
	160	{
	161	switch (*cptr)
	162	{
	163	case 'n':
	164	n = 1;
	165	break;
	166	case 'o':
	167	o = 1;
	168	break;
	169	case 'g':
	170	g = 1;
	171	break;
	172	case 'w':
	173	w = 1;
	174	break;
	175	case 'a':
	176	o = g = w = 1;
	177	break;
	178	case '-':
3519948b	179	cptr++; /* Remove "-" from beginning */
51702635 UD	180	while (cptr != '\0' && cptr != ',')
	181	{
	182	switch (*cptr)
	183	{
	184	case 'r':
	185	if (n)
	186	result = result & ~(NIS_READ_ACC << 24);
	187	if (o)
	188	result = result & ~(NIS_READ_ACC << 16);
	189	if (g)
	190	result = result & ~(NIS_READ_ACC << 8);
	191	if (w)
	192	result = result & ~(NIS_READ_ACC);
	193	break;
	194	case 'm':
	195	if (n)
	196	result = result & ~(NIS_MODIFY_ACC << 24);
	197	if (o)
	198	result = result & ~(NIS_MODIFY_ACC << 16);
	199	if (g)
	200	result = result & ~(NIS_MODIFY_ACC << 8);
	201	if (w)
	202	result = result & ~(NIS_MODIFY_ACC);
	203	break;
	204	case 'c':
	205	if (n)
	206	result = result & ~(NIS_CREATE_ACC << 24);
	207	if (o)
	208	result = result & ~(NIS_CREATE_ACC << 16);
	209	if (g)
	210	result = result & ~(NIS_CREATE_ACC << 8);
	211	if (w)
	212	result = result & ~(NIS_CREATE_ACC);
	213	break;
	214	case 'd':
	215	if (n)
	216	result = result & ~(NIS_DESTROY_ACC << 24);
	217	if (o)
	218	result = result & ~(NIS_DESTROY_ACC << 16);
	219	if (g)
	220	result = result & ~(NIS_DESTROY_ACC << 8);
	221	if (w)
	222	result = result & ~(NIS_DESTROY_ACC);
	223	break;
	224	default:
a1129917	225	return (~0U);
51702635 UD	226	}
	227	cptr++;
	228	}
dfd2257a	229	n = o = g = w = 0;
51702635 UD	230	break;
51702635 UD	231	case '+':
3519948b	232	cptr++; /* Remove "+" from beginning */
51702635 UD	233	while (cptr != '\0' && cptr != ',')
	234	{
	235	switch (*cptr)
	236	{
	237	case 'r':
	238	if (n)
	239	result = result \| (NIS_READ_ACC << 24);
	240	if (o)
	241	result = result \| (NIS_READ_ACC << 16);
	242	if (g)
	243	result = result \| (NIS_READ_ACC << 8);
	244	if (w)
	245	result = result \| (NIS_READ_ACC);
	246	break;
	247	case 'm':
	248	if (n)
	249	result = result \| (NIS_MODIFY_ACC << 24);
	250	if (o)
	251	result = result \| (NIS_MODIFY_ACC << 16);
	252	if (g)
	253	result = result \| (NIS_MODIFY_ACC << 8);
	254	if (w)
	255	result = result \| (NIS_MODIFY_ACC);
	256	break;
	257	case 'c':
	258	if (n)
	259	result = result \| (NIS_CREATE_ACC << 24);
	260	if (o)
	261	result = result \| (NIS_CREATE_ACC << 16);
	262	if (g)
	263	result = result \| (NIS_CREATE_ACC << 8);
	264	if (w)
	265	result = result \| (NIS_CREATE_ACC);
	266	break;
	267	case 'd':
	268	if (n)
	269	result = result \| (NIS_DESTROY_ACC << 24);
	270	if (o)
	271	result = result \| (NIS_DESTROY_ACC << 16);
	272	if (g)
	273	result = result \| (NIS_DESTROY_ACC << 8);
	274	if (w)
	275	result = result \| (NIS_DESTROY_ACC);
	276	break;
	277	default:
a1129917	278	return (~0U);
51702635 UD	279	}
	280	cptr++;
	281	}
dfd2257a	282	n = o = g = w = 0;
51702635 UD	283	break;
	284	case '=':
	285	cptr++; /* Remove "=" from beginning */
	286	/* Clear */
	287	if (n)
	288	result = result & ~((NIS_READ_ACC + NIS_MODIFY_ACC +
	289	NIS_CREATE_ACC + NIS_DESTROY_ACC) << 24);
	290
	291	if (o)
	292	result = result & ~((NIS_READ_ACC + NIS_MODIFY_ACC +
	293	NIS_CREATE_ACC + NIS_DESTROY_ACC) << 16);
	294	if (g)
	295	result = result & ~((NIS_READ_ACC + NIS_MODIFY_ACC +
	296	NIS_CREATE_ACC + NIS_DESTROY_ACC) << 8);
	297	if (w)
	298	result = result & ~(NIS_READ_ACC + NIS_MODIFY_ACC +
	299	NIS_CREATE_ACC + NIS_DESTROY_ACC);
	300	while (cptr != '\0' && cptr != ',')
	301	{
	302	switch (*cptr)
	303	{
	304	case 'r':
	305	if (n)
	306	result = result \| (NIS_READ_ACC << 24);
	307	if (o)
	308	result = result \| (NIS_READ_ACC << 16);
	309	if (g)
	310	result = result \| (NIS_READ_ACC << 8);
	311	if (w)
	312	result = result \| (NIS_READ_ACC);
	313	break;
	314	case 'm':
	315	if (n)
	316	result = result \| (NIS_MODIFY_ACC << 24);
	317	if (o)
	318	result = result \| (NIS_MODIFY_ACC << 16);
	319	if (g)
	320	result = result \| (NIS_MODIFY_ACC << 8);
	321	if (w)
	322	result = result \| (NIS_MODIFY_ACC);
	323	break;
	324	case 'c':
	325	if (n)
	326	result = result \| (NIS_CREATE_ACC << 24);
	327	if (o)
	328	result = result \| (NIS_CREATE_ACC << 16);
	329	if (g)
	330	result = result \| (NIS_CREATE_ACC << 8);
	331	if (w)
	332	result = result \| (NIS_CREATE_ACC);
	333	break;
	334	case 'd':
	335	if (n)
	336	result = result \| (NIS_DESTROY_ACC << 24);
	337	if (o)
	338	result = result \| (NIS_DESTROY_ACC << 16);
	339	if (g)
	340	result = result \| (NIS_DESTROY_ACC << 8);
	341	if (w)
	342	result = result \| (NIS_DESTROY_ACC);
	343	break;
	344	default:
a1129917	345	return result = (~0U);
51702635 UD	346	}
	347	cptr++;
	348	}
dfd2257a	349	n = o = g = w = 0;
51702635 UD	350	break;
51702635 UD	351	default:
a1129917	352	return result = (~0U);
51702635	353	}
3519948b UD	354	if (*cptr != '\0')
3519948b UD	355	cptr++;
51702635 UD	356	}
51702635 UD	357
dfd2257a	358	return result;
51702635 UD	359	}
	360
	361	nis_name
	362	__nis_default_owner (char *defaults)
	363	{
3519948b	364	char default_owner[NIS_MAXNAMELEN + 1];
51702635 UD	365	char cptr, dptr;
	366
	367	strcpy (default_owner, nis_local_principal ());
	368
	369	if (defaults != NULL)
	370	{
	371	dptr = strstr (defaults, "owner=");
	372	if (dptr != NULL)
dfd2257a UD	373	{
dfd2257a UD	374	char *p = searchowner (defaults);
3519948b UD	375	if (strlen (p) <= NIS_MAXNAMELEN)
3519948b UD	376	strcpy (default_owner, p);
dfd2257a UD	377	free (p);
dfd2257a UD	378	}
51702635 UD	379	}
	380	else
	381	{
	382	cptr = getenv ("NIS_DEFAULTS");
	383	if (cptr != NULL)
	384	{
	385	dptr = strstr (cptr, "owner=");
	386	if (dptr != NULL)
dfd2257a UD	387	{
dfd2257a UD	388	char *p = searchowner (cptr);
3519948b UD	389	if (strlen (p) <= NIS_MAXNAMELEN)
3519948b UD	390	strcpy (default_owner, p);
dfd2257a UD	391	free (p);
dfd2257a UD	392	}
51702635 UD	393	}
	394	}
	395
dfd2257a	396	return strdup (default_owner);
51702635 UD	397	}
	398
	399	nis_name
	400	__nis_default_group (char *defaults)
	401	{
3519948b	402	char default_group[NIS_MAXNAMELEN + 1];
51702635 UD	403	char cptr, dptr;
	404
	405	strcpy (default_group, nis_local_group ());
	406
	407	if (defaults != NULL)
	408	{
	409	dptr = strstr (defaults, "group=");
	410	if (dptr != NULL)
dfd2257a UD	411	{
dfd2257a UD	412	char *p = searchgroup (defaults);
3519948b UD	413
	414	if (strlen (p) <= NIS_MAXNAMELEN)
	415	strcpy (default_group, p);
dfd2257a UD	416	free (p);
dfd2257a UD	417	}
51702635 UD	418	}
	419	else
	420	{
	421	cptr = getenv ("NIS_DEFAULTS");
	422	if (cptr != NULL)
	423	{
	424	dptr = strstr (cptr, "group=");
	425	if (dptr != NULL)
dfd2257a UD	426	{
dfd2257a UD	427	char *p = searchgroup (cptr);
3519948b UD	428
	429	if (strlen (p) <= NIS_MAXNAMELEN)
	430	strcpy (default_group, p);
dfd2257a UD	431	free (p);
dfd2257a UD	432	}
51702635 UD	433	}
	434	}
	435
dfd2257a	436	return strdup (default_group);
51702635 UD	437	}
51702635 UD	438
a1129917	439	uint32_t
51702635 UD	440	__nis_default_ttl (char *defaults)
	441	{
	442	char cptr, dptr;
	443
	444	if (defaults != NULL)
	445	{
	446	dptr = strstr (defaults, "ttl=");
	447	if (dptr != NULL)
	448	return searchttl (defaults);
	449	}
	450
	451	cptr = getenv ("NIS_DEFAULTS");
	452	if (cptr == NULL)
	453	return DEFAULT_TTL;
	454
	455	dptr = strstr (cptr, "ttl=");
	456	if (dptr == NULL)
	457	return DEFAULT_TTL;
	458
	459	return searchttl (cptr);
	460	}
	461
	462	/* Default access rights are ----rmcdr---r---, but we could change
	463	this with the NIS_DEFAULTS variable. */
a1129917 UD	464	unsigned int
a1129917 UD	465	__nis_default_access (char *param, unsigned int defaults)
51702635	466	{
a1129917	467	unsigned int result;
51702635 UD	468	char *cptr;
	469
	470	if (defaults == 0)
	471	result = 0 \| OWNER_DEFAULT \| GROUP_DEFAULT \| WORLD_DEFAULT;
	472	else
	473	result = defaults;
	474
	475	if (param != NULL && strstr (param, "access=") != NULL)
	476	result = searchaccess (param, result);
	477	else
	478	{
	479	cptr = getenv ("NIS_DEFAULTS");
	480	if (cptr != NULL && strstr (cptr, "access=") != NULL)
	481	result = searchaccess (getenv ("NIS_DEFAULTS"), result);
	482	}
	483
	484	return result;
	485	}