source/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 #include "includes.h"
  23
  24 #ifdef WITH_NISPLUS
  25
  26 #ifdef BROKEN_NISPLUS_INCLUDE_FILES
  27
  28 /*
  29  * The following lines are needed due to buggy include files
  30  * in Solaris 2.6 which define GROUP in both /usr/include/sys/acl.h and
  31  * also in /usr/include/rpcsvc/nis.h. The definitions conflict. JRA.
  32  * Also GROUP_OBJ is defined as 0x4 in /usr/include/sys/acl.h and as
  33  * an enum in /usr/include/rpcsvc/nis.h.
  34  */
  35
  36 #if defined(GROUP)
  37 #undef GROUP
  38 #endif
  39
  40 #if defined(GROUP_OBJ)
  41 #undef GROUP_OBJ
  42 #endif
  43
  44 #endif
  45
  46 #include <rpcsvc/nis.h>
  47
  48 extern int      DEBUGLEVEL;
  49 extern pstring samlogon_user;
  50 extern BOOL sam_logon_in_ssb;
  51
  52 static VOLATILE SIG_ATOMIC_T gotalarm;
  53
  54 /***************************************************************
  55
  56  the fields for the NIS+ table, generated from mknissmbpwtbl.sh, are:
  57
  58         name=S,nogw=r
  59         uid=S,nogw=r
  60                 user_rid=S,nogw=r
  61                 smb_grpid=,nw+r
  62                 group_rid=,nw+r
  63                 acb=,nw+r
  64
  65         lmpwd=C,nw=,g=r,o=rm
  66         ntpwd=C,nw=,g=r,o=rm
  67
  68                 logon_t=,nw+r
  69                 logoff_t=,nw+r
  70                 kick_t=,nw+r
  71                 pwdlset_t=,nw+r
  72                 pwdlchg_t=,nw+r
  73                 pwdmchg_t=,nw+r
  74
  75                 full_name=,nw+r
  76                 home_dir=,nw+r
  77                 dir_drive=,nw+r
  78                 logon_script=,nw+r
  79                 profile_path=,nw+r
  80                 acct_desc=,nw+r
  81                 workstations=,nw+r
  82
  83                 hours=,nw+r
  84
  85 ****************************************************************/
  86
  87 #define NPF_NAME          0
  88 #define NPF_UID           1
  89 #define NPF_USER_RID      2
  90 #define NPF_SMB_GRPID     3
  91 #define NPF_GROUP_RID     4
  92 #define NPF_ACB           5
  93 #define NPF_LMPWD         6
  94 #define NPF_NTPWD         7
  95 #define NPF_LOGON_T       8
  96 #define NPF_LOGOFF_T      9
  97 #define NPF_KICK_T        10
  98 #define NPF_PWDLSET_T     11
  99 #define NPF_PWDLCHG_T     12
 100 #define NPF_PWDMCHG_T     13
 101 #define NPF_FULL_NAME     14
 102 #define NPF_HOME_DIR      15
 103 #define NPF_DIR_DRIVE     16
 104 #define NPF_LOGON_SCRIPT  17
 105 #define NPF_PROFILE_PATH  18
 106 #define NPF_ACCT_DESC     19
 107 #define NPF_WORKSTATIONS  20
 108 #define NPF_HOURS         21
 109
 110 /***************************************************************
 111  Signal function to tell us we timed out.
 112 ****************************************************************/
 113 static void gotalarm_sig(void)
 114 {
 115   gotalarm = 1;
 116 }
 117
 118 /***************************************************************
 119  make_nisname_from_user_rid
 120  ****************************************************************/
 121 static char *make_nisname_from_user_rid(uint32 rid, char *pfile)
 122 {
 123         static pstring nisname;
 124
 125         safe_strcpy(nisname, "[user_rid=", sizeof(nisname)-1);
 126         slprintf(nisname, sizeof(nisname)-1, "%s%d", nisname, rid);
 127         safe_strcat(nisname, "],", sizeof(nisname)-strlen(nisname)-1);
 128         safe_strcat(nisname, pfile, sizeof(nisname)-strlen(nisname)-1);
 129
 130         return nisname;
 131 }
 132
 133 /***************************************************************
 134  make_nisname_from_uid
 135  ****************************************************************/
 136 static char *make_nisname_from_uid(int uid, char *pfile)
 137 {
 138         static pstring nisname;
 139
 140         safe_strcpy(nisname, "[uid=", sizeof(nisname)-1);
 141         slprintf(nisname, sizeof(nisname)-1, "%s%d", nisname, uid);
 142         safe_strcat(nisname, "],", sizeof(nisname)-strlen(nisname)-1);
 143         safe_strcat(nisname, pfile, sizeof(nisname)-strlen(nisname)-1);
 144
 145         return nisname;
 146 }
 147
 148 /***************************************************************
 149  make_nisname_from_name
 150  ****************************************************************/
 151 static char *make_nisname_from_name(char *user_name, char *pfile)
 152 {
 153         static pstring nisname;
 154
 155         safe_strcpy(nisname, "[name=", sizeof(nisname)-1);
 156         safe_strcat(nisname, user_name, sizeof(nisname) - strlen(nisname) - 1);
 157         safe_strcat(nisname, "],", sizeof(nisname)-strlen(nisname)-1);
 158         safe_strcat(nisname, pfile, sizeof(nisname)-strlen(nisname)-1);
 159
 160         return nisname;
 161 }
 162
 163 /*************************************************************************
 164  gets a NIS+ attribute
 165  *************************************************************************/
 166 static void get_single_attribute(nis_object *new_obj, int col,
 167                                 char *val, int len)
 168 {
 169         int entry_len;
 170
 171         if (new_obj == NULL || val == NULL) return;
 172
 173         entry_len = ENTRY_LEN(new_obj, col);
 174         if (len > entry_len)
 175         {
 176                 DEBUG(10,("get_single_attribute: entry length truncated\n"));
 177                 len = entry_len;
 178         }
 179
 180         safe_strcpy(val, ENTRY_VAL(new_obj, col), len-1);
 181 }
 182
 183 /************************************************************************
 184  makes a struct sam_passwd from a NIS+ object.
 185  ************************************************************************/
 186 static BOOL make_sam_from_nisp_object(struct sam_passwd *pw_buf, nis_object *obj)
 187 {
 188         int uidval;
 189         static pstring user_name;
 190         static pstring full_name;
 191         static pstring home_dir;
 192         static pstring home_drive;
 193         static pstring logon_script;
 194         static pstring profile_path;
 195         static pstring acct_desc;
 196         static pstring workstations;
 197         static pstring temp;
 198         static unsigned char smbpwd[16];
 199         static unsigned char smbntpwd[16];
 200
 201         char *p;
 202
 203         pdb_init_sam(pw_buf);
 204         pw_buf->acct_ctrl = ACB_NORMAL;
 205
 206         pstrcpy(user_name, ENTRY_VAL(obj, NPF_NAME));
 207         pw_buf->smb_name      = user_name;
 208
 209         uidval = atoi(ENTRY_VAL(obj, NPF_UID));
 210         pw_buf->smb_userid    = uidval;
 211
 212         /* Check the lanman password column. */
 213         p = (char *)ENTRY_VAL(obj, NPF_LMPWD);
 214         if (*p == '*' || *p == 'X') {
 215           /* Password deliberately invalid - end here. */
 216           DEBUG(10, ("make_sam_from_nisp_object: entry invalidated for user %s\n", user_name));
 217           pw_buf->smb_nt_passwd = NULL;
 218           pw_buf->smb_passwd = NULL;
 219           pw_buf->acct_ctrl |= ACB_DISABLED;
 220           return True;
 221         }
 222         if (!strncasecmp(p, "NO PASSWORD", 11)) {
 223           pw_buf->smb_passwd = NULL;
 224           pw_buf->acct_ctrl |= ACB_PWNOTREQ;
 225         } else {
 226           if (strlen(p) != 32 || !pdb_gethexpwd(p, smbpwd))
 227             {
 228               DEBUG(0, ("make_sam_from_nisp_object: malformed LM pwd entry.\n"));
 229               return False;
 230             }
 231         }
 232
 233         pw_buf->smb_passwd    = smbpwd;
 234
 235         /* Check the NT password column. */
 236         p = ENTRY_VAL(obj, NPF_NTPWD);
 237         if (*p != '*' && *p != 'X') {
 238           if (strlen(p) != 32 || !pdb_gethexpwd(p, smbntpwd))
 239             {
 240               DEBUG(0, ("make_smb_from_nisp_object: malformed NT pwd entry\n"));
 241               return False;
 242             }
 243           pw_buf->smb_nt_passwd = smbntpwd;
 244         }
 245
 246         p = (char *)ENTRY_VAL(obj, NPF_ACB);
 247         if (*p == '[')
 248           {
 249             pw_buf->acct_ctrl = pdb_decode_acct_ctrl(p);
 250
 251             /* Must have some account type set. */
 252             if(pw_buf->acct_ctrl == 0)
 253               pw_buf->acct_ctrl = ACB_NORMAL;
 254
 255             /* Now try and get the last change time. */
 256             if(*p == ']')
 257               p++;
 258             if(*p == ':') {
 259               p++;
 260               if(*p && (StrnCaseCmp(p, "LCT-", 4)==0)) {
 261                 int i;
 262                 p += 4;
 263                 for(i = 0; i < 8; i++) {
 264                   if(p[i] == '\0' || !isxdigit(p[i]))
 265                     break;
 266                 }
 267                 if(i == 8) {
 268                   /*
 269                    * p points at 8 characters of hex digits -
 270                    * read into a time_t as the seconds since
 271                    * 1970 that the password was last changed.
 272                    */
 273                   pw_buf->pass_last_set_time = (time_t)strtol(p, NULL, 16);
 274                 }
 275               }
 276             }
 277         } else {
 278           /* 'Old' style file. Fake up based on user name. */
 279           /*
 280            * Currently trust accounts are kept in the same
 281            * password file as 'normal accounts'. If this changes
 282            * we will have to fix this code. JRA.
 283            */
 284           if(pw_buf->smb_name[strlen(pw_buf->smb_name) - 1] == '$') {
 285             pw_buf->acct_ctrl &= ~ACB_NORMAL;
 286             pw_buf->acct_ctrl |= ACB_WSTRUST;
 287           }
 288         }
 289
 290         get_single_attribute(obj, NPF_SMB_GRPID, temp, sizeof(pstring));
 291         pw_buf->smb_grpid = atoi(temp);
 292
 293         get_single_attribute(obj, NPF_USER_RID, temp, sizeof(pstring));
 294         pw_buf->user_rid = (strlen(temp) > 0) ?
 295           strtol(temp, NULL, 16) : pdb_uid_to_user_rid (pw_buf->smb_userid);
 296
 297         if (pw_buf->smb_name[strlen(pw_buf->smb_name)-1] != '$') {
 298
 299           /* XXXX hack to get standard_sub_basic() to use sam logon username */
 300           /* possibly a better way would be to do a become_user() call */
 301           pstrcpy(samlogon_user, pw_buf->smb_name);
 302           sam_logon_in_ssb = True;
 303
 304           get_single_attribute(obj, NPF_GROUP_RID, temp, sizeof(pstring));
 305           pw_buf->group_rid = (strlen(temp) > 0) ?
 306             strtol(temp, NULL, 16) : pdb_gid_to_group_rid (pw_buf->smb_grpid);
 307
 308           get_single_attribute(obj, NPF_FULL_NAME, full_name, sizeof(pstring));
 309 #if 1
 310           /* It seems correct to use the global values - but in that case why
 311            * do we want these NIS+ entries anyway ??
 312            */
 313           pstrcpy(logon_script , lp_logon_script       ());
 314           pstrcpy(profile_path , lp_logon_path         ());
 315           pstrcpy(home_drive   , lp_logon_drive        ());
 316           pstrcpy(home_dir     , lp_logon_home         ());
 317 #else
 318           get_single_attribute(obj, NPF_LOGON_SCRIPT, logon_script, sizeof(pstring));
 319           get_single_attribute(obj, NPF_PROFILE_PATH, profile_path, sizeof(pstring));
 320           get_single_attribute(obj, NPF_DIR_DRIVE, home_drive, sizeof(pstring));
 321           get_single_attribute(obj, NPF_HOME_DIR, home_dir, sizeof(pstring));
 322 #endif
 323           get_single_attribute(obj, NPF_ACCT_DESC, acct_desc, sizeof(pstring));
 324           get_single_attribute(obj, NPF_WORKSTATIONS, workstations, sizeof(pstring));
 325
 326           sam_logon_in_ssb = False;
 327
 328         } else {
 329
 330           pw_buf->group_rid = DOMAIN_GROUP_RID_USERS; /* lkclXXXX this is OBSERVED behaviour by NT PDCs, enforced here. */
 331
 332           pstrcpy(full_name    , "");
 333           pstrcpy(logon_script , "");
 334           pstrcpy(profile_path , "");
 335           pstrcpy(home_drive   , "");
 336           pstrcpy(home_dir     , "");
 337           pstrcpy(acct_desc    , "");
 338           pstrcpy(workstations , "");
 339         }
 340
 341         pw_buf->full_name    = full_name;
 342         pw_buf->home_dir     = home_dir;
 343         pw_buf->dir_drive    = home_drive;
 344         pw_buf->logon_script = logon_script;
 345         pw_buf->profile_path = profile_path;
 346         pw_buf->acct_desc    = acct_desc;
 347         pw_buf->workstations = workstations;
 348
 349         pw_buf->unknown_str = NULL; /* don't know, yet! */
 350         pw_buf->munged_dial = NULL; /* "munged" dial-back telephone number */
 351
 352         pw_buf->unknown_3 = 0xffffff; /* don't know */
 353         pw_buf->logon_divs = 168; /* hours per week */
 354         pw_buf->hours_len = 21; /* 21 times 8 bits = 168 */
 355         memset(pw_buf->hours, 0xff, pw_buf->hours_len); /* available at all hours */
 356         pw_buf->unknown_5 = 0x00000000; /* don't know */
 357         pw_buf->unknown_6 = 0x000004ec; /* don't know */
 358
 359         return True;
 360 }
 361
 362 /************************************************************************
 363  makes a struct sam_passwd from a NIS+ result.
 364  ************************************************************************/
 365 static BOOL make_sam_from_nisresult(struct sam_passwd *pw_buf, nis_result *result)
 366 {
 367         if (pw_buf == NULL || result == NULL) return False;
 368
 369         if (result->status != NIS_SUCCESS && result->status != NIS_NOTFOUND)
 370         {
 371                 DEBUG(0, ("make_sam_from_nisresult: NIS+ lookup failure: %s\n",
 372                            nis_sperrno(result->status)));
 373                 return False;
 374         }
 375
 376         /* User not found. */
 377         if (NIS_RES_NUMOBJ(result) <= 0)
 378         {
 379                 DEBUG(10, ("make_sam_from_nisresult: user not found in NIS+\n"));
 380                 return False;
 381         }
 382
 383         if (NIS_RES_NUMOBJ(result) > 1)
 384         {
 385                 DEBUG(10, ("make_sam_from_nisresult: WARNING: Multiple entries for user in NIS+ table!\n"));
 386         }
 387
 388         /* Grab the first hit. */
 389         return make_sam_from_nisp_object(pw_buf, &NIS_RES_OBJECT(result)[0]);
 390       }
 391
 392 /***************************************************************
 393  calls nis_list, returns results.
 394  ****************************************************************/
 395 static nis_result *nisp_get_nis_list(char *nis_name)
 396 {
 397         nis_result *result;
 398         result = nis_list(nis_name, FOLLOW_PATH|EXPAND_NAME|HARD_LOOKUP,NULL,NULL);
 399
 400         alarm(0);
 401         CatchSignal(SIGALRM, SIGNAL_CAST SIG_DFL);
 402
 403         if (gotalarm)
 404         {
 405                 DEBUG(0,("nisp_get_nis_list: NIS+ lookup time out\n"));
 406                 nis_freeresult(result);
 407                 return NULL;
 408         }
 409         return result;
 410 }
 411
 412
 413
 414 struct nisp_enum_info
 415 {
 416         nis_result *result;
 417         int enum_entry;
 418 };
 419
 420 /***************************************************************
 421  Start to enumerate the nisplus passwd list. Returns a void pointer
 422  to ensure no modification outside this module.
 423
 424  do not call this function directly.  use passdb.c instead.
 425
 426  ****************************************************************/
 427 static void *startnisppwent(BOOL update)
 428 {
 429         static struct nisp_enum_info res;
 430         res.result = nisp_get_nis_list(lp_smb_passwd_file());
 431         res.enum_entry = 0;
 432         return res.result != NULL ? &res : NULL;
 433 }
 434
 435 /***************************************************************
 436  End enumeration of the nisplus passwd list.
 437 ****************************************************************/
 438 static void endnisppwent(void *vp)
 439 {
 440   struct nisp_enum_info *res = (struct nisp_enum_info *)vp;
 441   nis_freeresult(res->result);
 442   DEBUG(7,("endnisppwent: freed enumeration list\n"));
 443 }
 444
 445 /*************************************************************************
 446  Routine to return the next entry in the nisplus passwd list.
 447
 448  do not call this function directly.  use passdb.c instead.
 449
 450  *************************************************************************/
 451 static struct sam_passwd *getnisp21pwent(void *vp)
 452 {
 453   struct nisp_enum_info *res = (struct nisp_enum_info *)vp;
 454   static struct sam_passwd pw_buf;
 455   int which;
 456   BOOL ret;
 457
 458   if (res == NULL || (int)(res->enum_entry) < 0 ||
 459       (int)(res->enum_entry) > (NIS_RES_NUMOBJ(res->result) - 1)) {
 460     ret = False;
 461   } else {
 462     which = (int)(res->enum_entry);
 463     ret = make_sam_from_nisp_object(&pw_buf,
 464                  &NIS_RES_OBJECT(res->result)[which]);
 465     if (ret && which < (NIS_RES_NUMOBJ(res->result) - 1))
 466       (int)(res->enum_entry)++;
 467   }
 468
 469   return ret ? &pw_buf : NULL;
 470 }
 471
 472 /*************************************************************************
 473  Return the current position in the nisplus passwd list as an SMB_BIG_UINT.
 474  This must be treated as an opaque token.
 475
 476  do not call this function directly.  use passdb.c instead.
 477
 478 *************************************************************************/
 479 static SMB_BIG_UINT getnisppwpos(void *vp)
 480 {
 481   struct nisp_enum_info *res = (struct nisp_enum_info *)vp;
 482   return (SMB_BIG_UINT)(res->enum_entry);
 483 }
 484
 485 /*************************************************************************
 486  Set the current position in the nisplus passwd list from SMB_BIG_UINT.
 487  This must be treated as an opaque token.
 488
 489  do not call this function directly.  use passdb.c instead.
 490
 491 *************************************************************************/
 492 static BOOL setnisppwpos(void *vp, SMB_BIG_UINT tok)
 493 {
 494   struct nisp_enum_info *res = (struct nisp_enum_info *)vp;
 495   if (tok < (NIS_RES_NUMOBJ(res->result) - 1)) {
 496     res->enum_entry = tok;
 497     return True;
 498   } else {
 499     return False;
 500   }
 501 }
 502
 503 /*************************************************************************
 504  sets a NIS+ attribute
 505  *************************************************************************/
 506 static void set_single_attribute(nis_object *new_obj, int col,
 507                                 char *val, int len, int flags)
 508 {
 509         if (new_obj == NULL) return;
 510
 511         ENTRY_VAL(new_obj, col) = val;
 512         ENTRY_LEN(new_obj, col) = len+1;
 513
 514         if (flags != 0)
 515         {
 516                 new_obj->EN_data.en_cols.en_cols_val[col].ec_flags = flags;
 517         }
 518 }
 519
 520 /************************************************************************
 521  Routine to add an entry to the nisplus passwd file.
 522
 523  do not call this function directly.  use passdb.c instead.
 524
 525 *************************************************************************/
 526 static BOOL add_nisp21pwd_entry(struct sam_passwd *newpwd)
 527 {
 528         char           *pfile;
 529         char           *nisname;
 530         nis_result      *nis_user;
 531         nis_result *result = NULL,
 532         *tblresult = NULL,
 533         *addresult = NULL;
 534         nis_object new_obj, *obj;
 535
 536     fstring uid;
 537         fstring user_rid;
 538         fstring smb_grpid;
 539         fstring group_rid;
 540         fstring acb;
 541
 542         fstring smb_passwd;
 543         fstring smb_nt_passwd;
 544
 545         fstring logon_t;
 546         fstring logoff_t;
 547         fstring kickoff_t;
 548         fstring pwdlset_t;
 549         fstring pwdlchg_t;
 550         fstring pwdmchg_t;
 551
 552         memset((char *)logon_t  , '\0', sizeof(logon_t  ));
 553         memset((char *)logoff_t , '\0', sizeof(logoff_t ));
 554         memset((char *)kickoff_t, '\0', sizeof(kickoff_t));
 555         memset((char *)pwdlset_t, '\0', sizeof(pwdlset_t));
 556         memset((char *)pwdlchg_t, '\0', sizeof(pwdlchg_t));
 557         memset((char *)pwdmchg_t, '\0', sizeof(pwdmchg_t));
 558
 559         pfile = lp_smb_passwd_file();
 560
 561         nisname = make_nisname_from_name(newpwd->smb_name, pfile);
 562         result = nisp_get_nis_list(nisname);
 563         if (result->status != NIS_SUCCESS && result->status != NIS_NOTFOUND)
 564         {
 565                 DEBUG(3, ( "add_nis21ppwd_entry: nis_list failure: %s: %s\n",
 566                             nisname,  nis_sperrno(result->status)));
 567                 nis_freeresult(result);
 568                 return False;
 569         }
 570
 571         if (result->status == NIS_SUCCESS && NIS_RES_NUMOBJ(result) > 0)
 572         {
 573                 DEBUG(3, ("add_nisp21pwd_entry: User already exists in NIS+ password db: %s\n",
 574                             pfile));
 575                 nis_freeresult(result);
 576                 return False;
 577         }
 578
 579 #if 0
 580         /* User not found. */
 581         if (!add_user)
 582         {
 583                 DEBUG(3, ("add_nisp21pwd_entry: User not found in NIS+ password db: %s\n",
 584                             pfile));
 585                 nis_freeresult(result);
 586                 return False;
 587         }
 588
 589 #endif
 590
 591         tblresult = nis_lookup(pfile, FOLLOW_PATH | EXPAND_NAME | HARD_LOOKUP );
 592         if (tblresult->status != NIS_SUCCESS)
 593         {
 594                 nis_freeresult(result);
 595                 nis_freeresult(tblresult);
 596                 DEBUG(3, ( "add_nisp21pwd_entry: nis_lookup failure: %s\n",
 597                             nis_sperrno(tblresult->status)));
 598                 return False;
 599         }
 600
 601         new_obj.zo_name   = NIS_RES_OBJECT(tblresult)->zo_name;
 602         new_obj.zo_domain = NIS_RES_OBJECT(tblresult)->zo_domain;
 603         new_obj.zo_owner  = NIS_RES_OBJECT(tblresult)->zo_owner;
 604         new_obj.zo_group  = NIS_RES_OBJECT(tblresult)->zo_group;
 605         new_obj.zo_access = NIS_RES_OBJECT(tblresult)->zo_access;
 606         new_obj.zo_ttl    = NIS_RES_OBJECT(tblresult)->zo_ttl;
 607
 608         new_obj.zo_data.zo_type = ENTRY_OBJ;
 609
 610         new_obj.zo_data.objdata_u.en_data.en_type = NIS_RES_OBJECT(tblresult)->zo_data.objdata_u.ta_data.ta_type;
 611         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;
 612         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));
 613
 614         if (new_obj.zo_data.objdata_u.en_data.en_cols.en_cols_val == NULL)
 615         {
 616                 DEBUG(0, ("add_nisp21pwd_entry: memory allocation failure\n"));
 617                 nis_freeresult(result);
 618                 nis_freeresult(tblresult);
 619                 return False;
 620         }
 621
 622         pdb_sethexpwd(smb_passwd   , newpwd->smb_passwd   , newpwd->acct_ctrl);
 623         pdb_sethexpwd(smb_nt_passwd, newpwd->smb_nt_passwd, newpwd->acct_ctrl);
 624
 625         newpwd->pass_last_set_time = (time_t)time(NULL);
 626         newpwd->logon_time = (time_t)-1;
 627         newpwd->logoff_time = (time_t)-1;
 628         newpwd->kickoff_time = (time_t)-1;
 629         newpwd->pass_can_change_time = (time_t)-1;
 630         newpwd->pass_must_change_time = (time_t)-1;
 631
 632         slprintf(logon_t,   13, "LNT-%08X", (uint32)newpwd->logon_time);
 633         slprintf(logoff_t,  13, "LOT-%08X", (uint32)newpwd->logoff_time);
 634         slprintf(kickoff_t, 13, "KOT-%08X", (uint32)newpwd->kickoff_time);
 635         slprintf(pwdlset_t, 13, "LCT-%08X", (uint32)newpwd->pass_last_set_time);
 636         slprintf(pwdlchg_t, 13, "CCT-%08X", (uint32)newpwd->pass_can_change_time);
 637         slprintf(pwdmchg_t, 13, "MCT-%08X", (uint32)newpwd->pass_must_change_time);
 638
 639         slprintf(uid, sizeof(uid)-1, "%u", newpwd->smb_userid);
 640         slprintf(user_rid, sizeof(user_rid)-1, "0x%x", newpwd->user_rid);
 641         slprintf(smb_grpid, sizeof(smb_grpid)-1, "%u", newpwd->smb_grpid);
 642         slprintf(group_rid, sizeof(group_rid)-1, "0x%x", newpwd->group_rid);
 643
 644         safe_strcpy(acb, pdb_encode_acct_ctrl(newpwd->acct_ctrl, NEW_PW_FORMAT_SPACE_PADDED_LEN), sizeof(acb)-1);
 645
 646         set_single_attribute(&new_obj, NPF_NAME          , newpwd->smb_name     , strlen(newpwd->smb_name)     , 0);
 647         set_single_attribute(&new_obj, NPF_UID           , uid                  , strlen(uid)                  , 0);
 648         set_single_attribute(&new_obj, NPF_USER_RID      , user_rid             , strlen(user_rid)             , 0);
 649         set_single_attribute(&new_obj, NPF_SMB_GRPID     , smb_grpid            , strlen(smb_grpid)            , 0);
 650         set_single_attribute(&new_obj, NPF_GROUP_RID     , group_rid            , strlen(group_rid)            , 0);
 651         set_single_attribute(&new_obj, NPF_ACB           , acb                  , strlen(acb)                  , 0);
 652         set_single_attribute(&new_obj, NPF_LMPWD         , smb_passwd           , strlen(smb_passwd)           , EN_CRYPT);
 653         set_single_attribute(&new_obj, NPF_NTPWD         , smb_nt_passwd        , strlen(smb_nt_passwd)        , EN_CRYPT);
 654         set_single_attribute(&new_obj, NPF_LOGON_T       , logon_t              , strlen(logon_t)              , 0);
 655         set_single_attribute(&new_obj, NPF_LOGOFF_T      , logoff_t             , strlen(logoff_t)             , 0);
 656         set_single_attribute(&new_obj, NPF_KICK_T        , kickoff_t            , strlen(kickoff_t)            , 0);
 657         set_single_attribute(&new_obj, NPF_PWDLSET_T     , pwdlset_t            , strlen(pwdlset_t)            , 0);
 658         set_single_attribute(&new_obj, NPF_PWDLCHG_T     , pwdlchg_t            , strlen(pwdlchg_t)            , 0);
 659         set_single_attribute(&new_obj, NPF_PWDMCHG_T     , pwdmchg_t            , strlen(pwdmchg_t)            , 0);
 660 #if 0
 661         set_single_attribute(&new_obj, NPF_FULL_NAME     , newpwd->full_name    , strlen(newpwd->full_name)    , 0);
 662         set_single_attribute(&new_obj, NPF_HOME_DIR      , newpwd->home_dir     , strlen(newpwd->home_dir)     , 0);
 663         set_single_attribute(&new_obj, NPF_DIR_DRIVE     , newpwd->dir_drive    , strlen(newpwd->dir_drive)    , 0);
 664         set_single_attribute(&new_obj, NPF_LOGON_SCRIPT  , newpwd->logon_script , strlen(newpwd->logon_script) , 0);
 665         set_single_attribute(&new_obj, NPF_PROFILE_PATH  , newpwd->profile_path , strlen(newpwd->profile_path) , 0);
 666         set_single_attribute(&new_obj, NPF_ACCT_DESC     , newpwd->acct_desc    , strlen(newpwd->acct_desc)    , 0);
 667         set_single_attribute(&new_obj, NPF_WORKSTATIONS  , newpwd->workstations , strlen(newpwd->workstations) , 0);
 668         set_single_attribute(&new_obj, NPF_HOURS         , newpwd->hours        , newpwd->hours_len            , 0);
 669 #endif
 670
 671         obj = &new_obj;
 672
 673         addresult = nis_add_entry(pfile, obj, ADD_OVERWRITE | FOLLOW_PATH | EXPAND_NAME | HARD_LOOKUP);
 674
 675
 676         if (addresult->status != NIS_SUCCESS)
 677         {
 678                 DEBUG(3, ( "add_nisp21pwd_entry: NIS+ table update failed: %s\n",
 679                             nisname, nis_sperrno(addresult->status)));
 680                 nis_freeresult(tblresult);
 681                 nis_freeresult(addresult);
 682                 nis_freeresult(result);
 683                 return False;
 684         }
 685
 686         nis_freeresult(tblresult);
 687         nis_freeresult(addresult);
 688         nis_freeresult(result);
 689
 690         return True;
 691 }
 692
 693 /************************************************************************
 694  Routine to search the nisplus passwd file for an entry matching the username.
 695  and then modify its password entry. We can't use the startnisppwent()/
 696  getnisppwent()/endnisppwent() interfaces here as we depend on looking
 697  in the actual file to decide how much room we have to write data.
 698  override = False, normal
 699  override = True, override XXXXXXXX'd out password or NO PASS
 700
 701  do not call this function directly.  use passdb.c instead.
 702
 703 ************************************************************************/
 704 static BOOL mod_nisp21pwd_entry(struct sam_passwd* pwd, BOOL override)
 705 {
 706   char *oldnislmpwd, *oldnisntpwd, *oldnisacb, *oldnislct, *user_name;
 707   char lmpwd[33], ntpwd[33], lct[13];
 708   nis_result *result, *addresult;
 709   nis_object *obj;
 710   fstring acb;
 711   pstring nisname;
 712   BOOL got_pass_last_set_time, ret;
 713   int i;
 714
 715   if (!*lp_smb_passwd_file())
 716     {
 717       DEBUG(0, ("mod_getnisp21pwd_entry: no SMB password file set\n"));
 718       return False;
 719     }
 720
 721   DEBUG(10, ("mod_getnisp21pwd_entry: search by name: %s\n", pwd->smb_name));
 722   DEBUG(10, ("mod_getnisp21pwd_entry: using NIS+ table %s\n", lp_smb_passwd_file()));
 723
 724   slprintf(nisname, sizeof(nisname)-1, "[name=%s],%s", pwd->smb_name, lp_smb_passwd_file());
 725
 726   /* Search the table. */
 727   gotalarm = 0;
 728   CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig);
 729   alarm(5);
 730
 731   result = nis_list(nisname, FOLLOW_PATH | EXPAND_NAME | HARD_LOOKUP, NULL, NULL);
 732
 733   alarm(0);
 734   CatchSignal(SIGALRM, SIGNAL_CAST SIG_DFL);
 735
 736   if (gotalarm)
 737     {
 738       DEBUG(0,("mod_getnisp21pwd_entry: NIS+ lookup time out\n"));
 739       nis_freeresult(result);
 740       return False;
 741     }
 742
 743   if(result->status != NIS_SUCCESS || NIS_RES_NUMOBJ(result) <= 0) {
 744     /* User not found. */
 745     DEBUG(0,("mod_getnisp21pwd_entry: user not found in NIS+\n"));
 746     nis_freeresult(result);
 747     return False;
 748   }
 749
 750   DEBUG(6,("mod_getnisp21pwd_entry: entry exists\n"));
 751
 752   obj = NIS_RES_OBJECT(result);
 753
 754   user_name = ENTRY_VAL(obj, NPF_NAME);
 755   oldnislmpwd = ENTRY_VAL(obj, NPF_LMPWD);
 756   oldnisntpwd = ENTRY_VAL(obj, NPF_NTPWD);
 757   oldnisacb = ENTRY_VAL(obj, NPF_ACB);
 758   oldnislct = ENTRY_VAL(obj, NPF_PWDLSET_T);
 759
 760
 761   if (!override && (*oldnislmpwd == '*' || *oldnislmpwd == 'X' ||
 762                     *oldnisntpwd == '*' || *oldnisntpwd == 'X')) {
 763     /* Password deliberately invalid - end here. */
 764     DEBUG(10, ("mod_nisp21pwd_entry: entry invalidated for user %s\n", user_name));
 765     nis_freeresult(result);
 766     return False;
 767   }
 768
 769   if (strlen(oldnislmpwd) != 32 || strlen(oldnisntpwd) != 32) {
 770     DEBUG(0, ("mod_nisp21pwd_entry: malformed password entry (incorrect length)\n"));
 771     nis_freeresult(result);
 772     return False;
 773   }
 774
 775
 776
 777   /*
 778    * Now check if the account info and the password last
 779    * change time is available.
 780    */
 781
 782   /*
 783    * If both NT and lanman passwords are provided - reset password
 784    * not required flag.
 785    */
 786
 787   if(pwd->smb_passwd != NULL || pwd->smb_nt_passwd != NULL) {
 788     /* Require password in the future (should ACB_DISABLED also be reset?) */
 789     pwd->acct_ctrl &= ~(ACB_PWNOTREQ);
 790   }
 791
 792   if (*oldnisacb == '[') {
 793
 794     i = 0;
 795     acb[i++] = oldnisacb[i];
 796     while(i < (sizeof(fstring) - 2) && (oldnisacb[i] != ']'))
 797       acb[i] = oldnisacb[i++];
 798
 799     acb[i++] = ']';
 800     acb[i++] = '\0';
 801
 802     if (i == NEW_PW_FORMAT_SPACE_PADDED_LEN) {
 803       /*
 804        * We are using a new format, space padded
 805        * acct ctrl field. Encode the given acct ctrl
 806        * bits into it.
 807        */
 808       fstrcpy(acb, pdb_encode_acct_ctrl(pwd->acct_ctrl, NEW_PW_FORMAT_SPACE_PADDED_LEN));
 809     } else {
 810       /*
 811        * If using the old format and the ACB_DISABLED or
 812        * ACB_PWNOTREQ are set then set the lanman and NT passwords to NULL
 813        * here as we have no space to encode the change.
 814        */
 815       if(pwd->acct_ctrl & (ACB_DISABLED|ACB_PWNOTREQ)) {
 816         pwd->smb_passwd = NULL;
 817         pwd->smb_nt_passwd = NULL;
 818       }
 819     }
 820
 821     /* Now do the LCT stuff. */
 822     if (StrnCaseCmp(oldnislct, "LCT-", 4) == 0) {
 823
 824       for(i = 0; i < 8; i++) {
 825         if(oldnislct[i+4] == '\0' || !isxdigit(oldnislct[i+4]))
 826           break;
 827       }
 828       if (i == 8) {
 829         /*
 830          * p points at 8 characters of hex digits -
 831          * read into a time_t as the seconds since
 832          * 1970 that the password was last changed.
 833          */
 834         got_pass_last_set_time = True;
 835       } /* i == 8 */
 836     } /* StrnCaseCmp() */
 837
 838   } /* p == '[' */
 839
 840   /* Entry is correctly formed. */
 841
 842
 843
 844   /* Create the 32 byte representation of the new p16 */
 845   if(pwd->smb_passwd != NULL) {
 846     for (i = 0; i < 16; i++) {
 847       slprintf(&lmpwd[i*2], 32, "%02X", (uchar) pwd->smb_passwd[i]);
 848     }
 849   } else {
 850     if(pwd->acct_ctrl & ACB_PWNOTREQ)
 851       fstrcpy(lmpwd, "NO PASSWORDXXXXXXXXXXXXXXXXXXXXX");
 852     else
 853       fstrcpy(lmpwd, "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
 854   }
 855
 856   /* Add on the NT md4 hash */
 857   if (pwd->smb_nt_passwd != NULL) {
 858     for (i = 0; i < 16; i++) {
 859       slprintf(&ntpwd[i*2], 32, "%02X", (uchar) pwd->smb_nt_passwd[i]);
 860     }
 861   } else {
 862     if(pwd->acct_ctrl & ACB_PWNOTREQ)
 863       fstrcpy(ntpwd, "NO PASSWORDXXXXXXXXXXXXXXXXXXXXX");
 864     else
 865       fstrcpy(ntpwd, "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
 866   }
 867
 868   pwd->pass_last_set_time = time(NULL);
 869
 870   if(got_pass_last_set_time) {
 871     slprintf(lct, 13, "LCT-%08X", (uint32)pwd->pass_last_set_time);
 872   }
 873
 874   set_single_attribute(obj, NPF_LMPWD,     lmpwd, strlen(lmpwd), EN_CRYPT);
 875   set_single_attribute(obj, NPF_NTPWD,     ntpwd, strlen(ntpwd), EN_CRYPT);
 876   set_single_attribute(obj, NPF_ACB,       acb,   strlen(acb),   0);
 877   set_single_attribute(obj, NPF_PWDLSET_T, lct,   strlen(lct),   0);
 878
 879   addresult =
 880     nis_add_entry(lp_smb_passwd_file(), obj,
 881                   ADD_OVERWRITE | FOLLOW_PATH | EXPAND_NAME | HARD_LOOKUP);
 882
 883   if(addresult->status != NIS_SUCCESS) {
 884     DEBUG(0, ("mod_nisp21pwd_entry: NIS+ table update failed: %s %s\n", nisname, nis_sperrno(addresult->status)));
 885     nis_freeresult(addresult);
 886     nis_freeresult(result);
 887     return False;
 888   }
 889
 890   DEBUG(6,("mod_nisp21pwd_entry: password changed\n"));
 891
 892   nis_freeresult(addresult);
 893   nis_freeresult(result);
 894
 895   return True;
 896 }
 897
 898
 899 /*************************************************************************
 900  Routine to search the nisplus passwd file for an entry matching the username
 901  *************************************************************************/
 902 static struct sam_passwd *getnisp21pwnam(char *name)
 903 {
 904         /* Static buffers we will return. */
 905         static struct sam_passwd pw_buf;
 906         nis_result *result;
 907         pstring nisname;
 908         BOOL ret;
 909
 910         if (!*lp_smb_passwd_file())
 911         {
 912                 DEBUG(0, ("No SMB password file set\n"));
 913                 return NULL;
 914         }
 915
 916         DEBUG(10, ("getnisp21pwnam: search by name: %s\n", name));
 917         DEBUG(10, ("getnisp21pwnam: using NIS+ table %s\n", lp_smb_passwd_file()));
 918
 919         slprintf(nisname, sizeof(nisname)-1, "[name=%s],%s", name, lp_smb_passwd_file());
 920
 921         /* Search the table. */
 922         gotalarm = 0;
 923         CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig);
 924         alarm(5);
 925
 926         result = nis_list(nisname, FOLLOW_PATH | EXPAND_NAME | HARD_LOOKUP, NULL, NULL);
 927
 928         alarm(0);
 929         CatchSignal(SIGALRM, SIGNAL_CAST SIG_DFL);
 930
 931         if (gotalarm)
 932         {
 933                 DEBUG(0,("getnisp21pwnam: NIS+ lookup time out\n"));
 934                 nis_freeresult(result);
 935                 return NULL;
 936         }
 937
 938         ret = make_sam_from_nisresult(&pw_buf, result);
 939         nis_freeresult(result);
 940
 941         return ret ? &pw_buf : NULL;
 942 }
 943
 944 /*************************************************************************
 945  Routine to search the nisplus passwd file for an entry matching the username
 946  *************************************************************************/
 947 static struct sam_passwd *getnisp21pwrid(uint32 rid)
 948 {
 949         /* Static buffers we will return. */
 950         static struct sam_passwd pw_buf;
 951         nis_result *result;
 952         char *nisname;
 953         BOOL ret;
 954
 955         if (!*lp_smb_passwd_file())
 956         {
 957                 DEBUG(0, ("getnisp21pwrid: no SMB password file set\n"));
 958                 return NULL;
 959         }
 960
 961         DEBUG(10, ("getnisp21pwrid: search by rid: %x\n", rid));
 962         DEBUG(10, ("getnisp21pwrid: using NIS+ table %s\n", lp_smb_passwd_file()));
 963
 964         nisname = make_nisname_from_user_rid(rid, lp_smb_passwd_file());
 965
 966         /* Search the table. */
 967         gotalarm = 0;
 968         CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig);
 969         alarm(5);
 970
 971         result = nis_list(nisname, FOLLOW_PATH | EXPAND_NAME | HARD_LOOKUP, NULL, NULL);
 972
 973         alarm(0);
 974         CatchSignal(SIGALRM, SIGNAL_CAST SIG_DFL);
 975
 976         if (gotalarm)
 977         {
 978                 DEBUG(0,("getnisp21pwrid: NIS+ lookup time out\n"));
 979                 nis_freeresult(result);
 980                 return NULL;
 981         }
 982
 983         ret = make_sam_from_nisresult(&pw_buf, result);
 984         nis_freeresult(result);
 985
 986         return ret ? &pw_buf : NULL;
 987 }
 988
 989 /*
 990  * Derived functions for NIS+.
 991  */
 992
 993 static struct smb_passwd *getnisppwent(void *vp)
 994 {
 995         return pdb_sam_to_smb(getnisp21pwent(vp));
 996 }
 997
 998 static BOOL add_nisppwd_entry(struct smb_passwd *newpwd)
 999 {
1000         return add_nisp21pwd_entry(pdb_smb_to_sam(newpwd));
1001 }
1002
1003 static BOOL mod_nisppwd_entry(struct smb_passwd* pwd, BOOL override)
1004 {
1005         return mod_nisp21pwd_entry(pdb_smb_to_sam(pwd), override);
1006 }
1007
1008 static BOOL del_nisppwd_entry(const char *name)
1009 {
1010         return False; /* Dummy. */
1011 }
1012
1013 static struct smb_passwd *getnisppwnam(char *name)
1014 {
1015         return pdb_sam_to_smb(getnisp21pwnam(name));
1016 }
1017
1018 static struct sam_passwd *getnisp21pwuid(uid_t smb_userid)
1019 {
1020         return getnisp21pwrid(pdb_uid_to_user_rid(smb_userid));
1021 }
1022
1023 static struct smb_passwd *getnisppwrid(uint32 user_rid)
1024 {
1025         return pdb_sam_to_smb(getnisp21pwuid(pdb_user_rid_to_uid(user_rid)));
1026 }
1027
1028 static struct smb_passwd *getnisppwuid(uid_t smb_userid)
1029 {
1030         return pdb_sam_to_smb(getnisp21pwuid(smb_userid));
1031 }
1032
1033 static struct sam_disp_info *getnispdispnam(char *name)
1034 {
1035         return pdb_sam_to_dispinfo(getnisp21pwnam(name));
1036 }
1037
1038 static struct sam_disp_info *getnispdisprid(uint32 rid)
1039 {
1040         return pdb_sam_to_dispinfo(getnisp21pwrid(rid));
1041 }
1042
1043 static struct sam_disp_info *getnispdispent(void *vp)
1044 {
1045         return pdb_sam_to_dispinfo(getnisp21pwent(vp));
1046 }
1047
1048 static struct passdb_ops nispasswd_ops = {
1049   startnisppwent,
1050   endnisppwent,
1051   getnisppwpos,
1052   setnisppwpos,
1053   getnisppwnam,
1054   getnisppwuid,
1055   getnisppwrid,
1056   getnisppwent,
1057   add_nisppwd_entry,
1058   mod_nisppwd_entry,
1059   del_nisppwd_entry,
1060   getnisp21pwent,
1061   getnisp21pwnam,
1062   getnisp21pwuid,
1063   getnisp21pwrid,
1064   add_nisp21pwd_entry,
1065   mod_nisp21pwd_entry,
1066   getnispdispnam,
1067   getnispdisprid,
1068   getnispdispent
1069 };
1070
1071 struct passdb_ops *nisplus_initialize_password_db(void)
1072 {
1073   return &nispasswd_ops;
1074 }
1075
1076 #else
1077  void nisplus_dummy_function(void);
1078  void nisplus_dummy_function(void) { } /* stop some compilers complaining */
1079 #endif /* WITH_NISPLUS */
1080
1081 /* useful code i can't bring myself to delete */
1082 #if 0
1083 static void useful_code(void) {
1084         /* checks user in unix password database.  don't want to do that, here. */
1085         nisname = make_nisname_from_name(newpwd->smb_name, "passwd.org_dir");
1086
1087         nis_user = nis_list(nisname, FOLLOW_PATH | EXPAND_NAME | HARD_LOOKUP, NULL, NULL);
1088
1089         if (nis_user->status != NIS_SUCCESS || NIS_RES_NUMOBJ(nis_user) <= 0)
1090         {
1091                 DEBUG(3, ("useful_code: Unable to get NIS+ passwd entry for user: %s.\n",
1092                         nis_sperrno(nis_user->status)));
1093                 return False;
1094         }
1095
1096         user_obj = NIS_RES_OBJECT(nis_user);
1097         make_nisname_from_name(ENTRY_VAL(user_obj,0), pfile);
1098 }
1099 #endif