source3/passdb/nispass.c

   1 /*
   2  * Unix SMB/Netbios implementation. Version 1.9. SMB parameters and setup
   3  * Copyright (C) Andrew Tridgell 1992-1998 Modified by Jeremy Allison 1995.
   4  * Copyright (C) Benny Holmgren 1998 <bigfoot@astrakan.hgs.se>
   5  * Copyright (C) Luke Kenneth Casson Leighton 1996-1998.
   6  *
   7  * This program is free software; you can redistribute it and/or modify it under
   8  * the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  15  * more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along with
  18  * this program; if not, write to the Free Software Foundation, Inc., 675
  19  * Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #ifdef USE_NISPLUS_DB
  23
  24 #include "includes.h"
  25 #include <rpcsvc/nis.h>
  26
  27 extern int      DEBUGLEVEL;
  28
  29 static int gotalarm;
  30
  31 /***************************************************************
  32
  33  the fields for the NIS+ table, generated from mknissmbpwtbl.sh, are:
  34
  35         name=S,nogw=r
  36         uid=S,nogw=r
  37                 user_rid=S,nogw=r
  38                 smb_grpid=,nw+r
  39                 group_rid=,nw+r
  40                 acb=,nw+r
  41
  42         lmpwd=C,nw=,g=r,o=rm
  43         ntpwd=C,nw=,g=r,o=rm
  44
  45                 logon_t=,nw+r
  46                 logoff_t=,nw+r
  47                 kick_t=,nw+r
  48                 pwdlset_t=,nw+r
  49                 pwdlchg_t=,nw+r
  50                 pwdmchg_t=,nw+r
  51
  52                 full_name=,nw+r
  53                 home_dir=,nw+r
  54                 dir_drive=,nw+r
  55                 logon_script=,nw+r
  56                 profile_path=,nw+r
  57                 acct_desc=,nw+r
  58                 workstations=,nw+r
  59
  60                 hours=,nw+r
  61
  62 ****************************************************************/
  63
  64 #define NPF_NAME          0
  65 #define NPF_UID           1
  66 #define NPF_USER_RID      2
  67 #define NPF_SMB_GRPID     3
  68 #define NPF_GROUP_RID     4
  69 #define NPF_ACB           5
  70 #define NPF_LMPWD         6
  71 #define NPF_NTPWD         7
  72 #define NPF_LOGON_T       8
  73 #define NPF_LOGOFF_T      9
  74 #define NPF_KICK_T        10
  75 #define NPF_PWDLSET_T     11
  76 #define NPF_PWDLCHG_T     12
  77 #define NPF_PWDMCHG_T     13
  78 #define NPF_FULL_NAME     14
  79 #define NPF_HOME_DIR      15
  80 #define NPF_DIR_DRIVE     16
  81 #define NPF_LOGON_SCRIPT  17
  82 #define NPF_PROFILE_PATH  18
  83 #define NPF_ACCT_DESC     19
  84 #define NPF_WORKSTATIONS  20
  85 #define NPF_HOURS         21
  86
  87 /***************************************************************
  88  Signal function to tell us we timed out.
  89 ****************************************************************/
  90 static void gotalarm_sig(void)
  91 {
  92   gotalarm = 1;
  93 }
  94
  95 /***************************************************************
  96  make_nisname_from_user_rid
  97  ****************************************************************/
  98 static char *make_nisname_from_user_rid(uint32 rid, char *pfile)
  99 {
 100         static pstring nisname;
 101
 102         safe_strcpy(nisname, "[user_rid=", sizeof(nisname)-1);
 103         slprintf(nisname, sizeof(nisname)-1, "%s%d", nisname, rid);
 104         safe_strcat(nisname, "],", sizeof(nisname)-strlen(nisname)-1);
 105         safe_strcat(nisname, pfile, sizeof(nisname)-strlen(nisname)-1);
 106
 107         return nisname;
 108 }
 109
 110 /***************************************************************
 111  make_nisname_from_uid
 112  ****************************************************************/
 113 static char *make_nisname_from_uid(int uid, char *pfile)
 114 {
 115         static pstring nisname;
 116
 117         safe_strcpy(nisname, "[uid=", sizeof(nisname)-1);
 118         slprintf(nisname, sizeof(nisname)-1, "%s%d", nisname, uid);
 119         safe_strcat(nisname, "],", sizeof(nisname)-strlen(nisname)-1);
 120         safe_strcat(nisname, pfile, sizeof(nisname)-strlen(nisname)-1);
 121
 122         return nisname;
 123 }
 124
 125 /***************************************************************
 126  make_nisname_from_name
 127  ****************************************************************/
 128 static char *make_nisname_from_name(char *user_name, char *pfile)
 129 {
 130         static pstring nisname;
 131
 132         safe_strcpy(nisname, "[name=", sizeof(nisname)-1);
 133         safe_strcat(nisname, user_name, sizeof(nisname) - strlen(nisname) - 1);
 134         safe_strcat(nisname, "],", sizeof(nisname)-strlen(nisname)-1);
 135         safe_strcat(nisname, pfile, sizeof(nisname)-strlen(nisname)-1);
 136
 137         return nisname;
 138 }
 139
 140 /*************************************************************************
 141  gets a NIS+ attribute
 142  *************************************************************************/
 143 static void get_single_attribute(nis_object *new_obj, int col,
 144                                 char *val, int len)
 145 {
 146         int entry_len;
 147
 148         if (new_obj == NULL || val == NULL) return;
 149
 150         entry_len = ENTRY_LEN(new_obj, col);
 151         if (len > entry_len)
 152         {
 153                 DEBUG(10,("get_single_attribute: entry length truncated\n"));
 154                 len = entry_len;
 155         }
 156
 157         safe_strcpy(val, len, ENTRY_VAL(new_obj, col));
 158 }
 159
 160 /***************************************************************
 161  calls nis_list, returns results.
 162  ****************************************************************/
 163 static nis_result *nisp_get_nis_list(char *nis_name)
 164 {
 165         nis_result *result;
 166         result = nis_list(nis_name, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP,NULL,NULL);
 167
 168         alarm(0);
 169         signal(SIGALRM, SIGNAL_CAST SIG_DFL);
 170
 171         if (gotalarm)
 172         {
 173                 DEBUG(0,("nisp_get_nis_list: NIS+ lookup time out\n"));
 174                 nis_freeresult(result);
 175                 return NULL;
 176         }
 177         return result;
 178 }
 179
 180
 181
 182 struct nisp_enum_info
 183 {
 184         nis_result *result;
 185         int enum_entry;
 186 };
 187
 188 /***************************************************************
 189  Start to enumerate the nisplus passwd list. Returns a void pointer
 190  to ensure no modification outside this module.
 191
 192  do not call this function directly.  use passdb.c instead.
 193
 194  ****************************************************************/
 195 static void *startnisppwent(BOOL update)
 196 {
 197         static struct nisp_enum_info res;
 198         res.result = nisp_get_nis_list(lp_smb_passwd_file());
 199         res.enum_entry = 0;
 200         return res.result != NULL ? &res : NULL;
 201 }
 202
 203 /***************************************************************
 204  End enumeration of the nisplus passwd list.
 205 ****************************************************************/
 206 static void endnisppwent(void *vp)
 207 {
 208 }
 209
 210 /*************************************************************************
 211  Routine to return the next entry in the nisplus passwd list.
 212  this function is a nice, messy combination of reading:
 213  - the nisplus passwd file
 214  - the unix password database
 215  - nisp.conf options (not done at present).
 216
 217  do not call this function directly.  use passdb.c instead.
 218
 219  *************************************************************************/
 220 static struct sam_passwd *getnisp21pwent(void *vp)
 221 {
 222         return NULL;
 223 }
 224
 225 /*************************************************************************
 226  Return the current position in the nisplus passwd list as an unsigned long.
 227  This must be treated as an opaque token.
 228
 229  do not call this function directly.  use passdb.c instead.
 230
 231 *************************************************************************/
 232 static unsigned long getnisppwpos(void *vp)
 233 {
 234         return 0;
 235 }
 236
 237 /*************************************************************************
 238  Set the current position in the nisplus passwd list from unsigned long.
 239  This must be treated as an opaque token.
 240
 241  do not call this function directly.  use passdb.c instead.
 242
 243 *************************************************************************/
 244 static BOOL setnisppwpos(void *vp, unsigned long tok)
 245 {
 246         return False;
 247 }
 248
 249 /*************************************************************************
 250  sets a NIS+ attribute
 251  *************************************************************************/
 252 static void set_single_attribute(nis_object *new_obj, int col,
 253                                 char *val, int len, int flags)
 254 {
 255         if (new_obj == NULL) return;
 256
 257         ENTRY_VAL(new_obj, col) = val;
 258         ENTRY_LEN(new_obj, col) = len;
 259
 260         if (flags != 0)
 261         {
 262                 new_obj->EN_data.en_cols.en_cols_val[col].ec_flags = flags;
 263         }
 264 }
 265
 266 /************************************************************************
 267  Routine to add an entry to the nisplus passwd file.
 268
 269  do not call this function directly.  use passdb.c instead.
 270
 271 *************************************************************************/
 272 static BOOL add_nisp21pwd_entry(struct sam_passwd *newpwd)
 273 {
 274         char           *pfile;
 275         char           *nisname;
 276         nis_result      *nis_user;
 277         nis_result *result = NULL,
 278         *tblresult = NULL,
 279         *addresult = NULL;
 280         nis_object new_obj, *obj;
 281
 282     fstring uid;
 283         fstring user_rid;
 284         fstring smb_grpid;
 285         fstring group_rid;
 286         fstring acb;
 287
 288         fstring smb_passwd;
 289         fstring smb_nt_passwd;
 290
 291         fstring logon_t;
 292         fstring logoff_t;
 293         fstring kickoff_t;
 294         fstring pwdlset_t;
 295         fstring pwdlchg_t;
 296         fstring pwdmchg_t;
 297
 298         bzero(logon_t  , sizeof(logon_t  ));
 299         bzero(logoff_t , sizeof(logoff_t ));
 300         bzero(kickoff_t, sizeof(kickoff_t));
 301         bzero(pwdlset_t, sizeof(pwdlset_t));
 302         bzero(pwdlchg_t, sizeof(pwdlchg_t));
 303         bzero(pwdmchg_t, sizeof(pwdmchg_t));
 304
 305         pfile = lp_smb_passwd_file();
 306
 307         nisname = make_nisname_from_name(newpwd->smb_name, pfile);
 308         result = nisp_get_nis_list(nisname);
 309         if (result->status != NIS_SUCCESS && result->status != NIS_NOTFOUND)
 310         {
 311                 DEBUG(3, ( "add_nisppwd_entry: nis_list failure: %s: %s\n",
 312                             nisname,  nis_sperrno(result->status)));
 313                 nis_freeresult(nis_user);
 314                 nis_freeresult(result);
 315                 return False;
 316         }
 317
 318         if (result->status == NIS_SUCCESS && NIS_RES_NUMOBJ(result) > 0)
 319         {
 320                 DEBUG(3, ("add_nisppwd_entry: User already exists in NIS+ password db: %s\n",
 321                             pfile));
 322                 nis_freeresult(result);
 323                 nis_freeresult(nis_user);
 324                 return False;
 325         }
 326
 327 #if 0
 328         /* User not found. */
 329         if (!add_user)
 330         {
 331                 DEBUG(3, ("add_nisppwd_entry: User not found in NIS+ password db: %s\n",
 332                             pfile));
 333                 nis_freeresult(result);
 334                 nis_freeresult(nis_user);
 335                 return False;
 336         }
 337
 338 #endif
 339
 340         tblresult = nis_lookup(pfile, FOLLOW_PATH | EXPAND_NAME | HARD_LOOKUP );
 341         if (tblresult->status != NIS_SUCCESS)
 342         {
 343                 nis_freeresult(result);
 344                 nis_freeresult(nis_user);
 345                 nis_freeresult(tblresult);
 346                 DEBUG(3, ( "add_nisppwd_entry: nis_lookup failure: %s\n",
 347                             nis_sperrno(tblresult->status)));
 348                 return False;
 349         }
 350
 351         new_obj.zo_name   = NIS_RES_OBJECT(tblresult)->zo_name;
 352         new_obj.zo_domain = NIS_RES_OBJECT(tblresult)->zo_domain;
 353         new_obj.zo_owner  = NIS_RES_OBJECT(tblresult)->zo_owner;
 354         new_obj.zo_group  = NIS_RES_OBJECT(tblresult)->zo_group;
 355         new_obj.zo_access = NIS_RES_OBJECT(tblresult)->zo_access;
 356         new_obj.zo_ttl    = NIS_RES_OBJECT(tblresult)->zo_ttl;
 357
 358         new_obj.zo_data.zo_type = ENTRY_OBJ;
 359
 360         new_obj.zo_data.objdata_u.en_data.en_type = NIS_RES_OBJECT(tblresult)->zo_data.objdata_u.ta_data.ta_type;
 361         new_obj.zo_data.objdata_u.en_data.en_cols.en_cols_len = NIS_RES_OBJECT(tblresult)->zo_data.objdata_u.ta_data.ta_maxcol;
 362         new_obj.zo_data.objdata_u.en_data.en_cols.en_cols_val = calloc(new_obj.zo_data.objdata_u.en_data.en_cols.en_cols_len, sizeof(entry_col));
 363
 364         pdb_sethexpwd(smb_passwd   , newpwd->smb_passwd   , newpwd->acct_ctrl);
 365         pdb_sethexpwd(smb_nt_passwd, newpwd->smb_nt_passwd, newpwd->acct_ctrl);
 366
 367         pdb_set_logon_time      (logon_t  , sizeof(logon_t  ), newpwd->logon_time           );
 368         pdb_set_logoff_time     (logoff_t , sizeof(logoff_t ), newpwd->logoff_time          );
 369         pdb_set_kickoff_time    (kickoff_t, sizeof(kickoff_t), newpwd->kickoff_time         );
 370         pdb_set_last_set_time   (pwdlset_t, sizeof(pwdlset_t), newpwd->pass_last_set_time   );
 371         pdb_set_can_change_time (pwdlchg_t, sizeof(pwdlchg_t), newpwd->pass_can_change_time );
 372         pdb_set_must_change_time(pwdmchg_t, sizeof(pwdmchg_t), newpwd->pass_must_change_time);
 373
 374         slprintf(uid, sizeof(uid), "%u", newpwd->smb_userid);
 375         slprintf(user_rid, sizeof(user_rid), "0x%x", newpwd->user_rid);
 376         slprintf(smb_grpid, sizeof(smb_grpid), "%u", newpwd->smb_grpid);
 377         slprintf(group_rid, sizeof(group_rid), "0x%x", newpwd->group_rid);
 378
 379         safe_strcpy(acb, pdb_encode_acct_ctrl(newpwd->acct_ctrl), sizeof(acb));
 380
 381         set_single_attribute(&new_obj, NPF_NAME          , newpwd->smb_name     , strlen(newpwd->smb_name)     , 0);
 382         set_single_attribute(&new_obj, NPF_UID           , uid                  , strlen(uid)                  , 0);
 383         set_single_attribute(&new_obj, NPF_USER_RID      , user_rid             , strlen(user_rid)             , 0);
 384         set_single_attribute(&new_obj, NPF_SMB_GRPID     , smb_grpid            , strlen(smb_grpid)            , 0);
 385         set_single_attribute(&new_obj, NPF_GROUP_RID     , group_rid            , strlen(group_rid)            , 0);
 386         set_single_attribute(&new_obj, NPF_ACB           , acb                  , strlen(acb)                  , 0);
 387         set_single_attribute(&new_obj, NPF_LMPWD         , smb_passwd           , strlen(smb_passwd)           , EN_CRYPT);
 388         set_single_attribute(&new_obj, NPF_NTPWD         , smb_nt_passwd        , strlen(smb_nt_passwd)        , EN_CRYPT);
 389         set_single_attribute(&new_obj, NPF_LOGON_T       , logon_t              , strlen(logon_t)              , 0);
 390         set_single_attribute(&new_obj, NPF_LOGOFF_T      , logoff_t             , strlen(logoff_t)             , 0);
 391         set_single_attribute(&new_obj, NPF_KICK_T        , kickoff_t            , strlen(kickoff_t)            , 0);
 392         set_single_attribute(&new_obj, NPF_PWDLSET_T     , pwdlset_t            , strlen(pwdlset_t)            , 0);
 393         set_single_attribute(&new_obj, NPF_PWDLCHG_T     , pwdlchg_t            , strlen(pwdlchg_t)            , 0);
 394         set_single_attribute(&new_obj, NPF_PWDMCHG_T     , pwdmchg_t            , strlen(pwdmchg_t)            , 0);
 395         set_single_attribute(&new_obj, NPF_FULL_NAME     , newpwd->full_name    , strlen(newpwd->full_name)    , 0);
 396         set_single_attribute(&new_obj, NPF_HOME_DIR      , newpwd->home_dir     , strlen(newpwd->home_dir)     , 0);
 397         set_single_attribute(&new_obj, NPF_DIR_DRIVE     , newpwd->dir_drive    , strlen(newpwd->dir_drive)    , 0);
 398         set_single_attribute(&new_obj, NPF_LOGON_SCRIPT  , newpwd->logon_script , strlen(newpwd->logon_script) , 0);
 399         set_single_attribute(&new_obj, NPF_PROFILE_PATH  , newpwd->profile_path , strlen(newpwd->profile_path) , 0);
 400         set_single_attribute(&new_obj, NPF_ACCT_DESC     , newpwd->acct_desc    , strlen(newpwd->acct_desc)    , 0);
 401         set_single_attribute(&new_obj, NPF_WORKSTATIONS  , newpwd->workstations , strlen(newpwd->workstations) , 0);
 402         set_single_attribute(&new_obj, NPF_HOURS         , newpwd->hours        , newpwd->hours_len            , 0);
 403
 404         obj = &new_obj;
 405
 406         addresult = nis_add_entry(pfile, obj, ADD_OVERWRITE | FOLLOW_PATH | EXPAND_NAME | HARD_LOOKUP);
 407
 408         nis_freeresult(nis_user);
 409         if (tblresult)
 410         {
 411                 nis_freeresult(tblresult);
 412         }
 413
 414         if (addresult->status != NIS_SUCCESS)
 415         {
 416                 DEBUG(3, ( "add_nisppwd_entry: NIS+ table update failed: %s\n",
 417                             nisname, nis_sperrno(addresult->status)));
 418                 nis_freeresult(addresult);
 419                 nis_freeresult(result);
 420                 return False;
 421         }
 422
 423         nis_freeresult(addresult);
 424         nis_freeresult(result);
 425
 426         return True;
 427 }
 428
 429 /************************************************************************
 430  Routine to search the nisplus passwd file for an entry matching the username.
 431  and then modify its password entry. We can't use the startnisppwent()/
 432  getnisppwent()/endnisppwent() interfaces here as we depend on looking
 433  in the actual file to decide how much room we have to write data.
 434  override = False, normal
 435  override = True, override XXXXXXXX'd out password or NO PASS
 436
 437  do not call this function directly.  use passdb.c instead.
 438
 439 ************************************************************************/
 440 static BOOL mod_nisp21pwd_entry(struct sam_passwd* pwd, BOOL override)
 441 {
 442         return False;
 443 }
 444
 445 /************************************************************************
 446  makes a struct sam_passwd from a NIS+ result.
 447  ************************************************************************/
 448 static BOOL make_sam_from_nisp(struct sam_passwd *pw_buf, nis_result *result)
 449 {
 450         int uidval;
 451         static pstring  user_name;
 452         static unsigned char smbpwd[16];
 453         static unsigned char smbntpwd[16];
 454         nis_object *obj;
 455         uchar *p;
 456
 457         if (pw_buf == NULL || result == NULL) return False;
 458
 459         pdb_init_sam(pw_buf);
 460
 461         if (result->status != NIS_SUCCESS)
 462         {
 463                 DEBUG(0, ("make_smb_from_nisp: NIS+ lookup failure: %s\n",
 464                            nis_sperrno(result->status)));
 465                 return False;
 466         }
 467
 468         /* User not found. */
 469         if (NIS_RES_NUMOBJ(result) <= 0)
 470         {
 471                 DEBUG(10, ("make_smb_from_nisp: user not found in NIS+\n"));
 472                 return False;
 473         }
 474
 475         if (NIS_RES_NUMOBJ(result) > 1)
 476         {
 477                 DEBUG(10, ("make_smb_from_nisp: WARNING: Multiple entries for user in NIS+ table!\n"));
 478         }
 479
 480         /* Grab the first hit. */
 481         obj = &NIS_RES_OBJECT(result)[0];
 482
 483         /* Check the lanman password column. */
 484         p = (uchar *)ENTRY_VAL(obj, NPF_LMPWD);
 485         if (strlen((char *)p) != 32 || !pdb_gethexpwd((char *)p, (char *)smbpwd))
 486         {
 487                 DEBUG(0, ("make_smb_from_nisp: malformed LM pwd entry.\n"));
 488                 return False;
 489         }
 490
 491         /* Check the NT password column. */
 492         p = (uchar *)ENTRY_VAL(obj, NPF_NTPWD);
 493         if (strlen((char *)p) != 32 || !pdb_gethexpwd((char *)p, (char *)smbntpwd))
 494         {
 495                 DEBUG(0, ("make_smb_from_nisp: malformed NT pwd entry\n"));
 496                 return False;
 497         }
 498
 499         strncpy(user_name, ENTRY_VAL(obj, NPF_NAME), sizeof(user_name));
 500         uidval = atoi(ENTRY_VAL(obj, NPF_UID));
 501
 502         pw_buf->smb_name      = user_name;
 503         pw_buf->smb_userid    = uidval;
 504         pw_buf->smb_passwd    = smbpwd;
 505         pw_buf->smb_nt_passwd = smbntpwd;
 506
 507         return True;
 508 }
 509
 510 /*************************************************************************
 511  Routine to search the nisplus passwd file for an entry matching the username
 512  *************************************************************************/
 513 static struct sam_passwd *getnisp21pwnam(char *name)
 514 {
 515         /* Static buffers we will return. */
 516         static struct sam_passwd pw_buf;
 517         nis_result *result;
 518         pstring nisname;
 519         BOOL ret;
 520
 521         if (!*lp_smb_passwd_file())
 522         {
 523                 DEBUG(0, ("No SMB password file set\n"));
 524                 return NULL;
 525         }
 526
 527         DEBUG(10, ("getnisppwnam: search by name: %s\n", name));
 528         DEBUG(10, ("getnisppwnam: using NIS+ table %s\n", lp_smb_passwd_file()));
 529
 530         slprintf(nisname, sizeof(nisname)-1, "[name=%s],%s", name, lp_smb_passwd_file());
 531
 532         /* Search the table. */
 533         gotalarm = 0;
 534         signal(SIGALRM, SIGNAL_CAST gotalarm_sig);
 535         alarm(5);
 536
 537         result = nis_list(nisname, FOLLOW_PATH | EXPAND_NAME | HARD_LOOKUP, NULL, NULL);
 538
 539         alarm(0);
 540         signal(SIGALRM, SIGNAL_CAST SIG_DFL);
 541
 542         if (gotalarm)
 543         {
 544                 DEBUG(0,("getnisppwnam: NIS+ lookup time out\n"));
 545                 nis_freeresult(result);
 546                 return NULL;
 547         }
 548
 549         ret = make_sam_from_nisp(&pw_buf, result);
 550         nis_freeresult(result);
 551
 552         return ret ? &pw_buf : NULL;
 553 }
 554
 555 /*************************************************************************
 556  Routine to search the nisplus passwd file for an entry matching the username
 557  *************************************************************************/
 558 static struct sam_passwd *getnisp21pwrid(uint32 rid)
 559 {
 560         /* Static buffers we will return. */
 561         static struct sam_passwd pw_buf;
 562         nis_result *result;
 563         char *nisname;
 564         BOOL ret;
 565
 566         if (!*lp_smb_passwd_file())
 567         {
 568                 DEBUG(0, ("No SMB password file set\n"));
 569                 return NULL;
 570         }
 571
 572         DEBUG(10, ("getnisp21pwrid: search by rid: %x\n", rid));
 573         DEBUG(10, ("getnisp21pwrid: using NIS+ table %s\n", lp_smb_passwd_file()));
 574
 575         nisname = make_nisname_from_user_rid(rid, lp_smb_passwd_file());
 576
 577         /* Search the table. */
 578         gotalarm = 0;
 579         signal(SIGALRM, SIGNAL_CAST gotalarm_sig);
 580         alarm(5);
 581
 582         result = nis_list(nisname, FOLLOW_PATH | EXPAND_NAME | HARD_LOOKUP, NULL, NULL);
 583
 584         alarm(0);
 585         signal(SIGALRM, SIGNAL_CAST SIG_DFL);
 586
 587         if (gotalarm)
 588         {
 589                 DEBUG(0,("getnisp21pwrid: NIS+ lookup time out\n"));
 590                 nis_freeresult(result);
 591                 return NULL;
 592         }
 593
 594         ret = make_sam_from_nisp(&pw_buf, result);
 595         nis_freeresult(result);
 596
 597         return ret ? &pw_buf : NULL;
 598 }
 599
 600 /*
 601  * Derived functions for NIS+.
 602  */
 603
 604 static struct smb_passwd *getnisppwent(void *vp)
 605 {
 606         return pdb_sam_to_smb(getnisp21pwent(vp));
 607 }
 608
 609 static BOOL add_nisppwd_entry(struct smb_passwd *newpwd)
 610 {
 611         return add_nisp21pwd_entry(pdb_smb_to_sam(newpwd));
 612 }
 613
 614 static BOOL mod_nisppwd_entry(struct smb_passwd* pwd, BOOL override)
 615 {
 616         return mod_nisp21pwd_entry(pdb_smb_to_sam(pwd), override);
 617 }
 618
 619 static struct smb_passwd *getnisppwnam(char *name)
 620 {
 621         return pdb_sam_to_smb(getnisp21pwnam(name));
 622 }
 623
 624 static struct sam_passwd *getnisp21pwuid(uid_t smb_userid)
 625 {
 626         return getnisp21pwrid(pdb_uid_to_user_rid(smb_userid));
 627 }
 628
 629 static struct smb_passwd *getnisppwuid(uid_t smb_userid)
 630 {
 631         return pdb_sam_to_smb(getnisp21pwuid(smb_userid));
 632 }
 633
 634 static struct sam_disp_info *getnispdispnam(char *name)
 635 {
 636         return pdb_sam_to_dispinfo(getnisp21pwnam(name));
 637 }
 638
 639 static struct sam_disp_info *getnispdisprid(uint32 rid)
 640 {
 641         return pdb_sam_to_dispinfo(getnisp21pwrid(rid));
 642 }
 643
 644 static struct sam_disp_info *getnispdispent(void *vp)
 645 {
 646         return pdb_sam_to_dispinfo(getnisp21pwent(vp));
 647 }
 648
 649 static struct passdb_ops nispasswd_ops = {
 650   startnisppwent,
 651   endnisppwent,
 652   getnisppwpos,
 653   setnisppwpos,
 654   getnisppwnam,
 655   getnisppwuid,
 656   getnisppwent,
 657   add_nisppwd_entry,
 658   mod_nisppwd_entry,
 659   getnisp21pwent,
 660   getnisp21pwnam,
 661   getnisp21pwuid,
 662   getnisp21pwrid,
 663   add_nisp21pwd_entry,
 664   mod_nisp21pwd_entry,
 665   getnispdispnam,
 666   getnispdisprid,
 667   getnispdispent
 668 };
 669
 670 struct passdb_ops *nisplus_initialize_password_db(void)
 671 {
 672   return &nispasswd_ops;
 673 }
 674
 675 #else
 676  void nisplus_dummy_function(void) { } /* stop some compilers complaining */
 677 #endif /* USE_NISPLUS_DB */
 678
 679 /* useful code i can't bring myself to delete */
 680 #if 0
 681         /* checks user in unix password database.  don't want to do that, here. */
 682         nisname = make_nisname_from_name(newpwd->smb_name, "passwd.org_dir");
 683
 684         nis_user = nis_list(nisname, FOLLOW_PATH | EXPAND_NAME | HARD_LOOKUP, NULL, NULL);
 685
 686         if (nis_user->status != NIS_SUCCESS || NIS_RES_NUMOBJ(nis_user) <= 0)
 687         {
 688                 DEBUG(3, ("add_nisppwd_entry: Unable to get NIS+ passwd entry for user: %s.\n",
 689                         nis_sperrno(nis_user->status)));
 690                 return False;
 691         }
 692
 693         user_obj = NIS_RES_OBJECT(nis_user);
 694         make_nisname_from_name(ENTRY_VAL(user_obj,0), pfile);
 695 #endif