nis/nis_defaults.c

   1 /* Copyright (c) 1997 Free Software Foundation, Inc.
   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>
  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 {
  35   char *cptr;
  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=" ? */
  47     return (nis_name) "";
  48
  49   return strndup (cptr, i);
  50 }
  51
  52 static nis_name
  53 searchowner (char *str)
  54 {
  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=" ? */
  67     return strdup ("");
  68
  69   return strndup (cptr, i);
  70 }
  71
  72 static u_long
  73 searchttl (char *str)
  74 {
  75   char buf[1024];
  76   char *cptr, *dptr;
  77   u_long time;
  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);
  92   time = 0;
  93
  94   dptr = buf;
  95   cptr = strchr (dptr, 'd');
  96   if (cptr != NULL)
  97     {
  98       *cptr = '\0';
  99       cptr++;
 100       time += atoi (dptr) * 60 * 60 * 24;
 101       dptr = cptr;
 102     }
 103
 104   cptr = strchr (dptr, 'h');
 105   if (cptr != NULL)
 106     {
 107       *cptr = '\0';
 108       cptr++;
 109       time += atoi (dptr) * 60 * 60;
 110       dptr = cptr;
 111     }
 112
 113   cptr = strchr (dptr, 'm');
 114   if (cptr != NULL)
 115     {
 116       *cptr = '\0';
 117       cptr++;
 118       time += atoi (dptr) * 60;
 119       dptr = cptr;
 120     }
 121
 122   cptr = strchr (dptr, 's');
 123   if (cptr != NULL)
 124     *cptr = '\0';
 125
 126   time += atoi (dptr);
 127
 128   return time;
 129 }
 130
 131 static u_long
 132 searchaccess (char *str, u_long access)
 133 {
 134   char buf[NIS_MAXNAMELEN];
 135   char *cptr;
 136   u_long result = access;
 137   int i;
 138   int n, o, g, w;
 139
 140   cptr = strstr (str, "access=");
 141   if (cptr == NULL)
 142     return 0;
 143
 144   cptr += 7;                    /* points to the begin of the access string */
 145   i = 0;
 146   while (cptr[i] != '\0' && cptr[i] != ':')
 147     i++;
 148   if (i == 0)                   /* only "access=" ? */
 149     return 0;
 150
 151   strncpy (buf, cptr, i);
 152
 153   n = o = g = w = 0;
 154   cptr = buf;
 155   while (*cptr != '\0')
 156     {
 157       switch (*cptr)
 158         {
 159         case 'n':
 160           n = 1;
 161           break;
 162         case 'o':
 163           o = 1;
 164           break;
 165         case 'g':
 166           g = 1;
 167           break;
 168         case 'w':
 169           w = 1;
 170           break;
 171         case 'a':
 172           o = g = w = 1;
 173           break;
 174         case '-':
 175           cptr++;               /* Remove "=" from beginning */
 176           while (*cptr != '\0' && *cptr != ',')
 177             {
 178               switch (*cptr)
 179                 {
 180                 case 'r':
 181                   if (n)
 182                     result = result & ~(NIS_READ_ACC << 24);
 183                   if (o)
 184                     result = result & ~(NIS_READ_ACC << 16);
 185                   if (g)
 186                     result = result & ~(NIS_READ_ACC << 8);
 187                   if (w)
 188                     result = result & ~(NIS_READ_ACC);
 189                   break;
 190                 case 'm':
 191                   if (n)
 192                     result = result & ~(NIS_MODIFY_ACC << 24);
 193                   if (o)
 194                     result = result & ~(NIS_MODIFY_ACC << 16);
 195                   if (g)
 196                     result = result & ~(NIS_MODIFY_ACC << 8);
 197                   if (w)
 198                     result = result & ~(NIS_MODIFY_ACC);
 199                   break;
 200                 case 'c':
 201                   if (n)
 202                     result = result & ~(NIS_CREATE_ACC << 24);
 203                   if (o)
 204                     result = result & ~(NIS_CREATE_ACC << 16);
 205                   if (g)
 206                     result = result & ~(NIS_CREATE_ACC << 8);
 207                   if (w)
 208                     result = result & ~(NIS_CREATE_ACC);
 209                   break;
 210                 case 'd':
 211                   if (n)
 212                     result = result & ~(NIS_DESTROY_ACC << 24);
 213                   if (o)
 214                     result = result & ~(NIS_DESTROY_ACC << 16);
 215                   if (g)
 216                     result = result & ~(NIS_DESTROY_ACC << 8);
 217                   if (w)
 218                     result = result & ~(NIS_DESTROY_ACC);
 219                   break;
 220                 default:
 221                   return ULONG_MAX;
 222                 }
 223               cptr++;
 224             }
 225           n = o = g = w = 0;
 226           break;
 227         case '+':
 228           cptr++;               /* Remove "=" from beginning */
 229           while (*cptr != '\0' && *cptr != ',')
 230             {
 231               switch (*cptr)
 232                 {
 233                 case 'r':
 234                   if (n)
 235                     result = result | (NIS_READ_ACC << 24);
 236                   if (o)
 237                     result = result | (NIS_READ_ACC << 16);
 238                   if (g)
 239                     result = result | (NIS_READ_ACC << 8);
 240                   if (w)
 241                     result = result | (NIS_READ_ACC);
 242                   break;
 243                 case 'm':
 244                   if (n)
 245                     result = result | (NIS_MODIFY_ACC << 24);
 246                   if (o)
 247                     result = result | (NIS_MODIFY_ACC << 16);
 248                   if (g)
 249                     result = result | (NIS_MODIFY_ACC << 8);
 250                   if (w)
 251                     result = result | (NIS_MODIFY_ACC);
 252                   break;
 253                 case 'c':
 254                   if (n)
 255                     result = result | (NIS_CREATE_ACC << 24);
 256                   if (o)
 257                     result = result | (NIS_CREATE_ACC << 16);
 258                   if (g)
 259                     result = result | (NIS_CREATE_ACC << 8);
 260                   if (w)
 261                     result = result | (NIS_CREATE_ACC);
 262                   break;
 263                 case 'd':
 264                   if (n)
 265                     result = result | (NIS_DESTROY_ACC << 24);
 266                   if (o)
 267                     result = result | (NIS_DESTROY_ACC << 16);
 268                   if (g)
 269                     result = result | (NIS_DESTROY_ACC << 8);
 270                   if (w)
 271                     result = result | (NIS_DESTROY_ACC);
 272                   break;
 273                 default:
 274                   return ULONG_MAX;
 275                 }
 276               cptr++;
 277             }
 278           n = o = g = w = 0;
 279           break;
 280         case '=':
 281           cptr++;               /* Remove "=" from beginning */
 282           /* Clear */
 283           if (n)
 284             result = result & ~((NIS_READ_ACC + NIS_MODIFY_ACC +
 285                                  NIS_CREATE_ACC + NIS_DESTROY_ACC) << 24);
 286
 287           if (o)
 288             result = result & ~((NIS_READ_ACC + NIS_MODIFY_ACC +
 289                                  NIS_CREATE_ACC + NIS_DESTROY_ACC) << 16);
 290           if (g)
 291             result = result & ~((NIS_READ_ACC + NIS_MODIFY_ACC +
 292                                  NIS_CREATE_ACC + NIS_DESTROY_ACC) << 8);
 293           if (w)
 294             result = result & ~(NIS_READ_ACC + NIS_MODIFY_ACC +
 295                                 NIS_CREATE_ACC + NIS_DESTROY_ACC);
 296           while (*cptr != '\0' && *cptr != ',')
 297             {
 298               switch (*cptr)
 299                 {
 300                 case 'r':
 301                   if (n)
 302                     result = result | (NIS_READ_ACC << 24);
 303                   if (o)
 304                     result = result | (NIS_READ_ACC << 16);
 305                   if (g)
 306                     result = result | (NIS_READ_ACC << 8);
 307                   if (w)
 308                     result = result | (NIS_READ_ACC);
 309                   break;
 310                 case 'm':
 311                   if (n)
 312                     result = result | (NIS_MODIFY_ACC << 24);
 313                   if (o)
 314                     result = result | (NIS_MODIFY_ACC << 16);
 315                   if (g)
 316                     result = result | (NIS_MODIFY_ACC << 8);
 317                   if (w)
 318                     result = result | (NIS_MODIFY_ACC);
 319                   break;
 320                 case 'c':
 321                   if (n)
 322                     result = result | (NIS_CREATE_ACC << 24);
 323                   if (o)
 324                     result = result | (NIS_CREATE_ACC << 16);
 325                   if (g)
 326                     result = result | (NIS_CREATE_ACC << 8);
 327                   if (w)
 328                     result = result | (NIS_CREATE_ACC);
 329                   break;
 330                 case 'd':
 331                   if (n)
 332                     result = result | (NIS_DESTROY_ACC << 24);
 333                   if (o)
 334                     result = result | (NIS_DESTROY_ACC << 16);
 335                   if (g)
 336                     result = result | (NIS_DESTROY_ACC << 8);
 337                   if (w)
 338                     result = result | (NIS_DESTROY_ACC);
 339                   break;
 340                 default:
 341                   return result = ULONG_MAX;
 342                 }
 343               cptr++;
 344             }
 345           n = o = g = w = 0;
 346           break;
 347         default:
 348           return result = ULONG_MAX;
 349         }
 350       cptr++;
 351     }
 352
 353   return result;
 354 }
 355
 356 nis_name
 357 __nis_default_owner (char *defaults)
 358 {
 359   char default_owner[NIS_MAXNAMELEN];
 360   char *cptr, *dptr;
 361
 362   strcpy (default_owner, nis_local_principal ());
 363
 364   if (defaults != NULL)
 365     {
 366       dptr = strstr (defaults, "owner=");
 367       if (dptr != NULL)
 368         {
 369           char *p = searchowner (defaults);
 370           strcpy (default_owner, p);
 371           free (p);
 372         }
 373     }
 374   else
 375     {
 376       cptr = getenv ("NIS_DEFAULTS");
 377       if (cptr != NULL)
 378         {
 379           dptr = strstr (cptr, "owner=");
 380           if (dptr != NULL)
 381             {
 382               char *p = searchowner (cptr);
 383               strcpy (default_owner, p);
 384               free (p);
 385             }
 386         }
 387     }
 388
 389   return strdup (default_owner);
 390 }
 391
 392 nis_name
 393 __nis_default_group (char *defaults)
 394 {
 395   char default_group[NIS_MAXNAMELEN];
 396   char *cptr, *dptr;
 397
 398   strcpy (default_group, nis_local_group ());
 399
 400   if (defaults != NULL)
 401     {
 402       dptr = strstr (defaults, "group=");
 403       if (dptr != NULL)
 404         {
 405           char *p = searchgroup (defaults);
 406           strcpy (default_group, p);
 407           free (p);
 408         }
 409     }
 410   else
 411     {
 412       cptr = getenv ("NIS_DEFAULTS");
 413       if (cptr != NULL)
 414         {
 415           dptr = strstr (cptr, "group=");
 416           if (dptr != NULL)
 417             {
 418               char *p = searchgroup (cptr);
 419               strcpy (default_group, p);
 420               free (p);
 421             }
 422         }
 423     }
 424
 425   return strdup (default_group);
 426 }
 427
 428 u_long
 429 __nis_default_ttl (char *defaults)
 430 {
 431   char *cptr, *dptr;
 432
 433   if (defaults != NULL)
 434     {
 435       dptr = strstr (defaults, "ttl=");
 436       if (dptr != NULL)
 437         return searchttl (defaults);
 438     }
 439
 440   cptr = getenv ("NIS_DEFAULTS");
 441   if (cptr == NULL)
 442     return DEFAULT_TTL;
 443
 444   dptr = strstr (cptr, "ttl=");
 445   if (dptr == NULL)
 446     return DEFAULT_TTL;
 447
 448   return searchttl (cptr);
 449 }
 450
 451 /* Default access rights are ----rmcdr---r---, but we could change
 452    this with the NIS_DEFAULTS variable. */
 453 u_long
 454 __nis_default_access (char *param, u_long defaults)
 455 {
 456   u_long result;
 457   char *cptr;
 458
 459   if (defaults == 0)
 460     result = 0 | OWNER_DEFAULT | GROUP_DEFAULT | WORLD_DEFAULT;
 461   else
 462     result = defaults;
 463
 464   if (param != NULL && strstr (param, "access=") != NULL)
 465     result = searchaccess (param, result);
 466   else
 467     {
 468       cptr = getenv ("NIS_DEFAULTS");
 469       if (cptr != NULL && strstr (cptr, "access=") != NULL)
 470         result = searchaccess (getenv ("NIS_DEFAULTS"), result);
 471     }
 472
 473   return result;
 474 }