nss/libnss_uniconf.cc

   1 #include "uniconfroot.h"
   2 #include "wvlog.h"
   3 #include "wvlogfile.h"
   4 #include "wvtclstring.h"
   5
   6 #include <stdlib.h>
   7 #include <nss.h>
   8 #include <pwd.h>
   9 #include <grp.h>
  10 #include <shadow.h>
  11 #include <utmp.h>
  12 #include <time.h>
  13 #include <sys/types.h>
  14 #include <pthread.h>
  15 #include <errno.h>
  16
  17 #define MY_RETURN(x) do \
  18                      { \
  19                          pthread_mutex_unlock(&nssunilock); \
  20                          return x; \
  21                      } while(0)
  22 #define MY_INIT do \
  23                 { \
  24                     pthread_mutex_lock(&nssunilock); \
  25                     init(); \
  26                 } while (0)
  27 #define LOCK pthread_mutex_lock(&nssunilock)
  28 #define UNLOCK pthread_mutex_unlock(&nssunilock)
  29
  30 pthread_mutex_t nssunilock = PTHREAD_MUTEX_INITIALIZER;
  31
  32 #ifdef DOLOG
  33 #define LOG(info...) log(info)
  34 static WvLog log("nss-uniconf", WvLog::Debug4);
  35 static WvLogFile logger("/tmp/nss-uniconf", WvLog::Debug5);
  36 #else
  37 #define LOG(info...) ;
  38 static WvLogFileBase logger("/dev/null", WvLog::Debug5);
  39 #endif
  40
  41 static UniConfRoot *cfgroot = NULL;
  42 static UniConf cfg, fnames, uids, groups;
  43 static UniConf::Iter *uiter = NULL;
  44 static UniConf::Iter *giter = NULL;
  45 static UniConf::Iter *siter = NULL;
  46
  47 static void init()
  48 {
  49     // FIXME: when do we plan to _free_ these?
  50     if (!cfgroot)
  51     {
  52         // connect to the local UniConf daemon
  53         cfgroot = new UniConfRoot();
  54         cfg = UniConf(*cfgroot);
  55
  56         // cache in the daemon, not here
  57         cfg.mount("auto:ca/nit/nssuniconf");
  58
  59         fnames = cfg["Full Names"];
  60         uids = cfg["UIDs"];
  61         groups = cfg["Groups"];
  62
  63         uiter = new UniConf::Iter(uids);
  64         giter = new UniConf::Iter(uids);
  65         siter = new UniConf::Iter(uids);
  66         uiter->rewind();
  67         giter->rewind();
  68         siter->rewind();
  69     }
  70 }
  71
  72 static bool putgroup(
  73     gid_t newgrp, gid_t **groupsp,
  74     long int *start, long int *size, long int limit)
  75 {
  76     if (*start == *size && limit <= 0)
  77     {
  78         LOG("Not enough room for group entries. Reallocating.\n");
  79         gid_t *newgroups =
  80             (gid_t *)realloc((*groupsp), (2 * (*size) + 1) * sizeof(gid_t));
  81
  82         if (!newgroups)
  83         {
  84             LOG("Failed to reallocate.\n");
  85             return false;
  86         }
  87
  88         *groupsp = newgroups;
  89         *size = 2 * (*size) + 1;
  90     }
  91
  92     if (*start < *size)
  93     {
  94         (*groupsp)[*start] = newgrp;
  95         *start += 1;
  96     }
  97
  98     LOG("Successfully added group %s to the list", newgrp);
  99     return true;
 100 }
 101
 102 static char *putmatch(WvBuf &out, WvStringParm s)
 103 {
 104     WvConstStringBuffer buf(s);
 105
 106     int startofs = out.used();
 107     while (buf.used())
 108     {
 109         out.putstr(wvtcl_getword(buf));
 110         if (buf.used())
 111             out.putstr(" ");
 112     }
 113     out.putch(0);
 114
 115     return (char *)out.mutablepeek(startofs, out.used() - (unsigned)startofs);
 116 }
 117
 118 static char **putmatches(WvBuf &out, WvStringParm s)
 119 {
 120     WvStringList users;
 121     users.split(s, " ");
 122
 123     if (0 == users.count())
 124         return NULL;
 125
 126     int startofl = out.used();
 127     int currptr = startofl;
 128
 129     // an extra ptr for NULL at the end
 130     size_t ptrsize = (users.count() + 1)*sizeof(char *);
 131     char *ptrs = new char[ptrsize];
 132
 133     memset(ptrs, 0, ptrsize);
 134     out.put(ptrs, ptrsize);
 135
 136     deletev ptrs;
 137
 138     // dump the strings into the buffer
 139     WvStringList::Iter i(users);
 140     for (i.rewind(); i.next(); )
 141     {
 142         char *bufstr = putmatch(out, i());
 143         out.poke(&bufstr, currptr, sizeof(char *));
 144         currptr += sizeof(char *);
 145     }
 146
 147     return (char **)out.mutablepeek(startofl, out.used() - (unsigned)startofl);
 148 }
 149
 150
 151 static enum nss_status pwmatch(struct passwd *pw, int *errnop,
 152                    char *buf, size_t buflen,
 153                    WvStringParm username)
 154 {
 155     WvInPlaceBuf out(buf, 0, buflen);
 156
 157     WvString homedir("/export/home/%s", username);
 158     WvString shell("/bin/bash");
 159     WvString gecos(fnames[username].getme());
 160     if (!gecos)
 161         gecos = username;
 162
 163     pw->pw_name   = putmatch(out, username);
 164     pw->pw_passwd = putmatch(out, "x");
 165     pw->pw_uid    = uids[username].getmeint(65534);
 166     pw->pw_gid    = uids[username].getmeint(65534);
 167     pw->pw_gecos  = putmatch(out, gecos);
 168     pw->pw_dir    = putmatch(out, homedir);
 169     pw->pw_shell  = putmatch(out, shell);
 170
 171     if (out.free() == 0)
 172     {
 173         *errnop = errno = ERANGE;
 174         return NSS_STATUS_TRYAGAIN;
 175     }
 176     else
 177     {
 178         *errnop = errno = 0;
 179         return NSS_STATUS_SUCCESS;
 180     }
 181 }
 182
 183
 184 static enum nss_status grmatch(struct group *gr, int *errnop,
 185                  char *buf, size_t buflen,
 186                  WvStringParm username)
 187 {
 188     WvInPlaceBuf out(buf, 0, buflen);
 189     WvString members = groups[username].getme();
 190     if (!members)
 191         members = username;
 192
 193     gr->gr_name   = putmatch(out, username);
 194     gr->gr_passwd = putmatch(out, "x");
 195     gr->gr_gid    = uids[username].getmeint(65534);
 196     gr->gr_mem    = putmatches(out, members);
 197
 198     if (out.free() == 0)
 199     {
 200         *errnop = errno = ERANGE;
 201         return NSS_STATUS_TRYAGAIN;
 202     }
 203     else
 204     {
 205         *errnop = errno = 0;
 206         return NSS_STATUS_SUCCESS;
 207     }
 208 }
 209
 210
 211 static enum nss_status spmatch(struct spwd *sp, int *errnop,
 212                  char *buf, size_t buflen,
 213                  WvStringParm username)
 214 {
 215     WvInPlaceBuf out(buf, 0, buflen);
 216     time_t now = time(NULL);
 217     long lastchg = (now / (60*60*24)) - 1;
 218
 219     sp->sp_namp   = putmatch(out, username);
 220     sp->sp_pwdp   = NULL;
 221     sp->sp_lstchg = lastchg;
 222     sp->sp_min    = 0;
 223     sp->sp_max    = LONG_MAX;
 224     sp->sp_warn   = 10;
 225     sp->sp_inact  = LONG_MAX;
 226     sp->sp_expire = LONG_MAX;
 227
 228     if (out.free() == 0)
 229     {
 230         *errnop = errno = ERANGE;
 231         return NSS_STATUS_TRYAGAIN;
 232     }
 233     else
 234     {
 235         *errnop = errno = 0;
 236         return NSS_STATUS_SUCCESS;
 237     }
 238 }
 239
 240
 241 extern "C" enum nss_status _nss_uniconf_getpwnam_r(
 242         const char *user, struct passwd *pw,
 243         char *buf, size_t buflen, int *errnop)
 244 {
 245     MY_INIT;
 246     LOG("%s(%s) called.\n", __func__, user);
 247
 248     enum nss_status ret = NSS_STATUS_NOTFOUND;
 249     *errnop = errno = ENOENT;
 250
 251     if (uids[user].exists())
 252         ret = pwmatch(pw, errnop, buf, buflen, user);
 253
 254     MY_RETURN(ret);
 255 }
 256
 257
 258 extern "C" enum nss_status _nss_uniconf_getpwuid_r(
 259         uid_t uid, struct passwd *pw,
 260         char *buf, size_t buflen, int *errnop)
 261 {
 262     MY_INIT;
 263     LOG("%s(%s) called.\n", __func__, uid);
 264
 265     WvString username;
 266     enum nss_status ret = NSS_STATUS_NOTFOUND;
 267     *errnop = errno = ENOENT;
 268
 269     UniConf::Iter i(uids);
 270     for (i.rewind(); i.next(); )
 271     {
 272         if (uid == (unsigned)i._value().num())
 273         {
 274             username = i().key().printable();
 275             ret = pwmatch(pw, errnop, buf, buflen, username);
 276             break;
 277         }
 278     }
 279
 280     MY_RETURN(ret);
 281 }
 282
 283
 284
 285 extern "C" enum nss_status _nss_uniconf_getgrnam_r(
 286         const char *user, struct group *gr,
 287         char *buf, size_t buflen, int *errnop)
 288 {
 289     MY_INIT;
 290     LOG("%s(%s) called.\n", __func__, user);
 291
 292     enum nss_status ret = NSS_STATUS_NOTFOUND;
 293     *errnop = errno = ENOENT;
 294
 295     if (uids[user].exists())
 296         ret = grmatch(gr, errnop, buf, buflen, user);
 297
 298     MY_RETURN(ret);
 299 }
 300
 301
 302 extern "C" enum nss_status _nss_uniconf_getgrgid_r(
 303         gid_t gid, struct group *gr,
 304         char *buf, size_t buflen, int *errnop)
 305 {
 306     MY_INIT;
 307     LOG("%s(%s) called.\n", __func__, gid);
 308
 309     WvString username;
 310     enum nss_status ret = NSS_STATUS_NOTFOUND;
 311     *errnop = errno = ENOENT;
 312
 313     UniConf::Iter i(uids);
 314     for (i.rewind(); i.next(); )
 315     {
 316         if (gid == (unsigned)i._value().num())
 317         {
 318             username = i().key().printable();
 319             ret = grmatch(gr, errnop, buf, buflen, username);
 320             break;
 321         }
 322     }
 323
 324     MY_RETURN(ret);
 325 }
 326
 327 extern "C" enum nss_status _nss_uniconf_getspnam_r(
 328         const char *user, struct spwd *sp,
 329         char *buf, size_t buflen, int *errnop)
 330 {
 331     MY_INIT;
 332     LOG("%s(%s) called.\n", __func__, user);
 333
 334     enum nss_status ret = NSS_STATUS_NOTFOUND;
 335     *errnop = errno = ENOENT;
 336
 337     if (uids[user].exists())
 338         ret = spmatch(sp, errnop, buf, buflen, user);
 339
 340     MY_RETURN(ret);
 341 }
 342
 343
 344 extern "C" enum nss_status _nss_uniconf_getspuid_r(
 345         uid_t uid, struct spwd *sp,
 346         char *buf, size_t buflen, int *errnop)
 347 {
 348     MY_INIT;
 349     LOG("%s(%s) called.\n", __func__, uid);
 350
 351     WvString username;
 352     enum nss_status ret = NSS_STATUS_NOTFOUND;
 353     *errnop = errno = ENOENT;
 354
 355     UniConf::Iter i(uids);
 356     for (i.rewind(); i.next(); )
 357     {
 358         if (uid == (unsigned)i._value().num())
 359         {
 360             username = i().key().printable();
 361             ret = spmatch(sp, errnop, buf, buflen, username);
 362             break;
 363         }
 364     }
 365
 366     MY_RETURN(ret);
 367 }
 368
 369 extern "C" enum nss_status _nss_uniconf_setpwent()
 370 {
 371     MY_INIT;
 372     LOG("%s() called.\n", __func__);
 373
 374     MY_RETURN(NSS_STATUS_SUCCESS);
 375 }
 376
 377 extern "C" enum nss_status _nss_uniconf_setgrent()
 378 {
 379     MY_INIT;
 380     LOG("%s() called.\n", __func__);
 381
 382     MY_RETURN(NSS_STATUS_SUCCESS);
 383 }
 384
 385 extern "C" enum nss_status _nss_uniconf_endpwent()
 386 {
 387     MY_INIT;
 388     LOG("%s() called.\n", __func__);
 389
 390     MY_RETURN(NSS_STATUS_SUCCESS);
 391 }
 392
 393 extern "C" enum nss_status _nss_uniconf_endgrent()
 394 {
 395     MY_INIT;
 396     LOG("%s() called.\n", __func__);
 397
 398     MY_RETURN(NSS_STATUS_SUCCESS);
 399 }
 400
 401 extern "C" enum nss_status _nss_uniconf_setspent()
 402 {
 403     MY_INIT;
 404     LOG("%s() called.\n", __func__);
 405
 406     MY_RETURN(NSS_STATUS_SUCCESS);
 407 }
 408
 409 extern "C" enum nss_status _nss_uniconf_endspent()
 410 {
 411     MY_INIT;
 412     LOG("%s() called.\n", __func__);
 413
 414     MY_RETURN(NSS_STATUS_SUCCESS);
 415 }
 416
 417 extern "C" enum nss_status _nss_uniconf_getpwent_r(
 418         struct passwd *pw, char *buf,
 419         int buflen, int *errnop)
 420 {
 421     MY_INIT;
 422     LOG("%s() called.\n", __func__);
 423
 424     UniConf::Iter &i = *uiter;
 425
 426     if (i.next())
 427     {
 428         WvString username = i().key().printable();
 429         MY_RETURN(_nss_uniconf_getpwnam_r(username, pw,
 430                                           buf, buflen, errnop));
 431     }
 432     else
 433         i.rewind();
 434
 435     errno = *errnop = ENOENT;
 436     MY_RETURN(NSS_STATUS_NOTFOUND);
 437 }
 438
 439 extern "C" enum nss_status _nss_uniconf_getgrent_r(
 440         struct group *gr, char *buf,
 441         int buflen, int *errnop)
 442 {
 443     MY_INIT;
 444     LOG("%s() called.\n", __func__);
 445
 446     UniConf::Iter &i = *uiter;
 447
 448     if (i.next())
 449     {
 450         WvString username = i().key().printable();
 451         MY_RETURN(_nss_uniconf_getgrnam_r(username, gr,
 452                                           buf, buflen, errnop));
 453     }
 454     else
 455         i.rewind();
 456
 457     errno = *errnop = ENOENT;
 458     MY_RETURN(NSS_STATUS_NOTFOUND);
 459 }
 460
 461 extern "C" enum nss_status _nss_uniconf_getspent_r(
 462         struct spwd *sp, char *buf,
 463         int buflen, int *errnop)
 464 {
 465     MY_INIT;
 466     LOG("%s() called.\n", __func__);
 467
 468     UniConf::Iter &i = *uiter;
 469
 470     if (i.next())
 471     {
 472         WvString username = i().key().printable();
 473         MY_RETURN(_nss_uniconf_getspnam_r(username, sp,
 474                                           buf, buflen, errnop));
 475     }
 476     else
 477         i.rewind();
 478
 479     errno = *errnop = ENOENT;
 480     MY_RETURN(NSS_STATUS_NOTFOUND);
 481 }
 482
 483 extern "C" struct passwd *_nss_uniconf_getpwent(void)
 484 {
 485     MY_INIT;
 486     LOG("%s() called.\n", __func__);
 487
 488     struct passwd *ret = (struct passwd *)malloc(sizeof(struct passwd));
 489     if (!ret)
 490         MY_RETURN(NULL);
 491
 492     int errnum = 0;
 493     size_t bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
 494     UniConf::Iter &i = *uiter;
 495
 496     if (i.next())
 497     {
 498         char *buf = (char *)malloc(bufsize);
 499         if (!buf)
 500             goto fail;
 501
 502         WvString username = i().key().printable();
 503
 504         // don't double-lock
 505         UNLOCK;
 506         enum nss_status status =
 507             _nss_uniconf_getpwnam_r(username, ret,
 508                                     buf, bufsize, &errnum);
 509         LOCK;
 510
 511         if (NSS_STATUS_SUCCESS == status)
 512             MY_RETURN(ret);
 513         else
 514             free(buf);
 515     }
 516     else
 517         i.rewind();
 518
 519 fail:
 520     free(ret);
 521
 522     MY_RETURN(NULL);
 523 }
 524
 525 extern "C" struct group *_nss_uniconf_getgrent(void)
 526 {
 527     MY_INIT;
 528     LOG("%s() called.\n", __func__);
 529
 530     struct group *ret = (struct group *)malloc(sizeof(struct group));
 531     if (!ret)
 532         MY_RETURN(NULL);
 533
 534     int errnum = 0;
 535     size_t bufsize = sysconf(_SC_GETGR_R_SIZE_MAX);
 536     UniConf::Iter &i = *giter;
 537
 538     if (i.next())
 539     {
 540         char *buf = (char *)malloc(bufsize);
 541         if (!buf)
 542             goto fail;
 543
 544         WvString username = i().key().printable();
 545
 546         // don't double-lock
 547         UNLOCK;
 548         enum nss_status status =
 549             _nss_uniconf_getgrnam_r(username, ret,
 550                                     buf, bufsize, &errnum);
 551         LOCK;
 552
 553         if (NSS_STATUS_SUCCESS == status)
 554             MY_RETURN(ret);
 555         else
 556             free(buf);
 557     }
 558     else
 559         i.rewind();
 560
 561 fail:
 562     free(ret);
 563
 564     MY_RETURN(NULL);
 565 }
 566
 567 extern "C" struct spwd *_nss_uniconf_getspent(void)
 568 {
 569     MY_INIT;
 570     LOG("%s() called.\n", __func__);
 571
 572     struct spwd *ret = (struct spwd *)malloc(sizeof(struct spwd));
 573     if (!ret)
 574         return NULL;
 575
 576     int errnum = 0;
 577     size_t bufsize = UT_NAMESIZE;
 578     UniConf::Iter &i = *siter;
 579
 580     if (i.next())
 581     {
 582         char *buf = (char *)malloc(bufsize);
 583         if (!buf)
 584             goto fail;
 585
 586         WvString username = i().key().printable();
 587
 588         // don't double-lock
 589         UNLOCK;
 590         enum nss_status status =
 591             _nss_uniconf_getspnam_r(username, ret,
 592                                     buf, bufsize, &errnum);
 593         LOCK;
 594
 595         if (NSS_STATUS_SUCCESS == status)
 596             MY_RETURN(ret);
 597         else
 598             free(buf);
 599     }
 600     else
 601         i.rewind();
 602
 603 fail:
 604     free(ret);
 605
 606     MY_RETURN(NULL);
 607 }
 608
 609 extern "C" enum nss_status _nss_uniconf_initgroups_dyn(
 610         const char *user, gid_t group, long int *start, long int *size,
 611         gid_t **groupsp, long int limit, int *errnop)
 612 {
 613     MY_INIT;
 614     LOG("%s() called.\n", __func__);
 615
 616     if (!user || !uids[user].exists())
 617     {
 618         errno = *errnop = ENOENT;
 619         MY_RETURN(NSS_STATUS_NOTFOUND);
 620     }
 621
 622     if (*start > *size)
 623     {
 624         errno = *errnop = EINVAL;
 625         MY_RETURN(NSS_STATUS_UNAVAIL);
 626     }
 627
 628     gid_t curr = 65534;
 629     int nmem = 0;
 630     WvString members;
 631     WvStringList mlist;
 632
 633     UniConf::Iter i(groups);
 634     for (i.rewind(); i.next(); )
 635     {
 636         members = i().getme();
 637         mlist.split(members, " ");
 638         curr = uids[i().key().printable()].getmeint();
 639         nmem = mlist.count();
 640
 641         if (curr == group || !nmem)
 642             continue;
 643
 644         while (nmem)
 645         {
 646             if (mlist.popstr() == user)
 647             {
 648                 LOG("I think %s is in group %s.\n", user, curr);
 649                 if (!putgroup(curr, groupsp, start, size, limit))
 650                 {
 651                     errno = *errnop = ENOMEM;
 652                     MY_RETURN(NSS_STATUS_TRYAGAIN);
 653                 }
 654
 655                 break;
 656             }
 657
 658             nmem--;
 659         }
 660     }
 661
 662     errno = *errnop = 0;
 663     MY_RETURN(NSS_STATUS_SUCCESS);
 664 }
 665