#include "includes.h"
#ifdef USE_SMBPASS_DB
extern int DEBUGLEVEL;
extern pstring samlogon_user;
extern BOOL sam_logon_in_ssb;
static int pw_file_lock_depth;
enum pwf_access_type { PWF_READ, PWF_UPDATE, PWF_CREATE };
static void *startsmbfilepwent_internal(const char *pfile, enum pwf_access_type type, int *lock_depth)
{
FILE *fp = NULL;
const char *open_mode = NULL;
int race_loop = 0;
int lock_type = F_RDLCK;
if (!*pfile) {
DEBUG(0, ("startsmbfilepwent: No SMB password file set\n"));
return (NULL);
}
switch(type) {
case PWF_READ:
open_mode = "rb";
lock_type = F_RDLCK;
break;
case PWF_UPDATE:
open_mode = "r+b";
lock_type = F_WRLCK;
break;
case PWF_CREATE:
{
int i, fd = -1;
for(i = 0; i < 5; i++) {
if((fd = sys_open(pfile, O_CREAT|O_TRUNC|O_EXCL|O_RDWR, 0600))!=-1)
break;
sys_usleep(200);
}
if(fd == -1) {
DEBUG(0,("startsmbfilepwent_internal: too many race conditions creating file %s\n", pfile));
return NULL;
}
close(fd);
open_mode = "r+b";
lock_type = F_WRLCK;
break;
}
}
for(race_loop = 0; race_loop < 5; race_loop++) {
DEBUG(10, ("startsmbfilepwent_internal: opening file %s\n", pfile));
if((fp = sys_fopen(pfile, open_mode)) == NULL) {
DEBUG(0, ("startsmbfilepwent_internal: unable to open file %s. Error was %s\n", pfile, strerror(errno) ));
return NULL;
}
if (!pw_file_lock(fileno(fp), lock_type, 5, lock_depth)) {
DEBUG(0, ("startsmbfilepwent_internal: unable to lock file %s. Error was %s\n", pfile, strerror(errno) ));
fclose(fp);
return NULL;
}
if(type == PWF_READ) {
break;
} else {
SMB_STRUCT_STAT sbuf1, sbuf2;
if (sys_stat(pfile,&sbuf1) != 0) {
DEBUG(0, ("startsmbfilepwent_internal: unable to stat file %s. Error was %s\n", pfile, strerror(errno)));
pw_file_unlock(fileno(fp), lock_depth);
fclose(fp);
return NULL;
}
if (sys_fstat(fileno(fp),&sbuf2) != 0) {
DEBUG(0, ("startsmbfilepwent_internal: unable to fstat file %s. Error was %s\n", pfile, strerror(errno)));
pw_file_unlock(fileno(fp), lock_depth);
fclose(fp);
return NULL;
}
if( sbuf1.st_ino == sbuf2.st_ino) {
break;
}
pw_file_unlock(fileno(fp), lock_depth);
fclose(fp);
}
}
if(race_loop == 5) {
DEBUG(0, ("startsmbfilepwent_internal: too many race conditions opening file %s\n", pfile));
return NULL;
}
setvbuf(fp, (char *)NULL, _IOFBF, 1024);
if(fchmod(fileno(fp), S_IRUSR|S_IWUSR) == -1) {
DEBUG(0, ("startsmbfilepwent_internal: failed to set 0600 permissions on password file %s. \
Error was %s\n.", pfile, strerror(errno) ));
pw_file_unlock(fileno(fp), lock_depth);
fclose(fp);
return NULL;
}
return (void *)fp;
}
static void *startsmbfilepwent(BOOL update)
{
return startsmbfilepwent_internal(lp_smb_passwd_file(), update ? PWF_UPDATE : PWF_READ, &pw_file_lock_depth);
}
static void endsmbfilepwent_internal(void *vp, int *lock_depth)
{
FILE *fp = (FILE *)vp;
pw_file_unlock(fileno(fp), lock_depth);
fclose(fp);
DEBUG(7, ("endsmbfilepwent_internal: closed password file.\n"));
}
static void endsmbfilepwent(void *vp)
{
endsmbfilepwent_internal(vp, &pw_file_lock_depth);
}
static struct smb_passwd *getsmbfilepwent(void *vp)
{
static struct smb_passwd pw_buf;
static pstring user_name;
static unsigned char smbpwd[16];
static unsigned char smbntpwd[16];
FILE *fp = (FILE *)vp;
char linebuf[256];
unsigned char c;
unsigned char *p;
long uidval;
size_t linebuf_len;
if(fp == NULL) {
DEBUG(0,("getsmbfilepwent: Bad password file pointer.\n"));
return NULL;
}
pdb_init_smb(&pw_buf);
pw_buf.acct_ctrl = ACB_NORMAL;
while (!feof(fp)) {
linebuf[0] = '\0';
fgets(linebuf, 256, fp);
if (ferror(fp)) {
return NULL;
}
if ((linebuf_len = strlen(linebuf)) == 0)
continue;
if (linebuf[linebuf_len - 1] != '\n') {
c = '\0';
while (!ferror(fp) && !feof(fp)) {
c = fgetc(fp);
if (c == '\n')
break;
}
} else
linebuf[linebuf_len - 1] = '\0';
#ifdef DEBUG_PASSWORD
DEBUG(100, ("getsmbfilepwent: got line |%s|\n", linebuf));
#endif
if ((linebuf[0] == 0) && feof(fp)) {
DEBUG(4, ("getsmbfilepwent: end of file reached\n"));
break;
}
if (linebuf[0] == '#' || linebuf[0] == '\0') {
DEBUG(6, ("getsmbfilepwent: skipping comment or blank line\n"));
continue;
}
p = (unsigned char *) strchr(linebuf, ':');
if (p == NULL) {
DEBUG(0, ("getsmbfilepwent: malformed password entry (no :)\n"));
continue;
}
strncpy(user_name, linebuf, PTR_DIFF(p, linebuf));
user_name[PTR_DIFF(p, linebuf)] = '\0';
p++;
if(*p == '-') {
DEBUG(0, ("getsmbfilepwent: uids in the smbpasswd file must not be negative for user: %s.\n", user_name));
continue;
}
if (!isdigit(*p)) {
DEBUG(0, ("getsmbfilepwent: malformed password entry (uid not number) for user: %s.\n", user_name));
continue;
}
uidval = atoi((char *) p);
while (*p && isdigit(*p))
p++;
if (*p != ':') {
DEBUG(0, ("getsmbfilepwent: malformed password entry (no : after uid) for user: %s.\n", user_name));
continue;
}
pw_buf.smb_name = user_name;
pw_buf.smb_userid = uidval;
p++;
if (*p == '*' || *p == 'X') {
DEBUG(10, ("getsmbfilepwent: entry invalidated for user %s\n", user_name));
pw_buf.smb_nt_passwd = NULL;
pw_buf.smb_passwd = NULL;
pw_buf.acct_ctrl |= ACB_DISABLED;
return &pw_buf;
}
if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
DEBUG(0, ("getsmbfilepwent: malformed password entry (passwd too short) for user %s\n", user_name));
continue;
}
if (p[32] != ':') {
DEBUG(0, ("getsmbfilepwent: malformed password entry (no terminating :) for user %s\n", user_name));
continue;
}
if (!strncasecmp((char *) p, "NO PASSWORD", 11)) {
pw_buf.smb_passwd = NULL;
pw_buf.acct_ctrl |= ACB_PWNOTREQ;
} else {
if (!pdb_gethexpwd((char *)p, smbpwd)) {
DEBUG(0, ("getsmbfilepwent: Malformed Lanman password entry (non hex chars) for user %s\n", user_name));
continue;
}
pw_buf.smb_passwd = smbpwd;
}
pw_buf.smb_nt_passwd = NULL;
p += 33;
if ((linebuf_len >= (PTR_DIFF(p, linebuf) + 33)) && (p[32] == ':')) {
if (*p != '*' && *p != 'X') {
if(pdb_gethexpwd((char *)p,smbntpwd))
pw_buf.smb_nt_passwd = smbntpwd;
}
p += 33;
}
DEBUG(5,("getsmbfilepwent: returning passwd entry for user %s, uid %ld\n",
user_name, uidval));
if (*p == '[')
{
unsigned char *end_p = (unsigned char *)strchr((char *)p, ']');
pw_buf.acct_ctrl = pdb_decode_acct_ctrl((char*)p);
if(pw_buf.acct_ctrl == 0)
pw_buf.acct_ctrl = ACB_NORMAL;
if(end_p)
p = end_p + 1;
if(*p == ':') {
p++;
if(*p && (StrnCaseCmp((char *)p, "LCT-", 4)==0)) {
int i;
p += 4;
for(i = 0; i < 8; i++) {
if(p[i] == '\0' || !isxdigit(p[i]))
break;
}
if(i == 8) {
pw_buf.pass_last_set_time = (time_t)strtol((char *)p, NULL, 16);
}
}
}
} else {
if(pw_buf.smb_name[strlen(pw_buf.smb_name) - 1] == '$') {
pw_buf.acct_ctrl &= ~ACB_NORMAL;
pw_buf.acct_ctrl |= ACB_WSTRUST;
}
}
return &pw_buf;
}
DEBUG(5,("getsmbfilepwent: end of file reached.\n"));
return NULL;
}
static struct sam_passwd* build_sampw_from_smbpw (struct smb_passwd *pw_buf)
{
static struct sam_passwd user;
struct passwd *pwfile;
static pstring full_name;
static pstring home_dir;
static pstring home_drive;
static pstring logon_script;
static pstring profile_path;
static pstring acct_desc;
static pstring workstations;
if (pw_buf == NULL) return NULL;
pwfile = sys_getpwnam(pw_buf->smb_name);
if (pwfile == NULL)
{
DEBUG(0,("getsmbfile21pwent: smbpasswd database is corrupt!\n"));
DEBUG(0,("getsmbfile21pwent: username %s not in unix passwd database!\n", pw_buf->smb_name));
return NULL;
}
ZERO_STRUCT (user);
pdb_init_sam (&user);
pstrcpy(samlogon_user, pw_buf->smb_name);
if (samlogon_user[strlen(samlogon_user)-1] != '$')
{
sam_logon_in_ssb = True;
user.smb_userid = pwfile->pw_uid;
user.smb_grpid = pwfile->pw_gid;
user.user_rid = pdb_uid_to_user_rid (user.smb_userid);
user.group_rid = pdb_gid_to_group_rid(user.smb_grpid );
pstrcpy(full_name, pwfile->pw_gecos);
pstrcpy(logon_script , lp_logon_script ());
pstrcpy(profile_path , lp_logon_path ());
pstrcpy(home_drive , lp_logon_drive ());
pstrcpy(home_dir , lp_logon_home ());
pstrcpy(acct_desc , "");
pstrcpy(workstations , "");
standard_sub_advanced(-1, samlogon_user, "", user.smb_grpid, logon_script);
standard_sub_advanced(-1, samlogon_user, "", user.smb_grpid, profile_path);
standard_sub_advanced(-1, samlogon_user, "", user.smb_grpid, home_drive);
standard_sub_advanced(-1, samlogon_user, "", user.smb_grpid, home_dir);
sam_logon_in_ssb = False;
}
else
{
user.smb_userid = pwfile->pw_uid;
user.smb_grpid = pwfile->pw_gid;
user.user_rid = pdb_uid_to_user_rid (user.smb_userid);
user.group_rid = DOMAIN_GROUP_RID_USERS;
pstrcpy(full_name , "");
pstrcpy(logon_script , "");
pstrcpy(profile_path , "");
pstrcpy(home_drive , "");
pstrcpy(home_dir , "");
pstrcpy(acct_desc , "");
pstrcpy(workstations , "");
}
user.smb_name = pw_buf->smb_name;
user.full_name = full_name;
user.home_dir = home_dir;
user.dir_drive = home_drive;
user.logon_script = logon_script;
user.profile_path = profile_path;
user.acct_desc = acct_desc;
user.workstations = workstations;
user.unknown_str = NULL;
user.munged_dial = NULL;
user.smb_nt_passwd = pw_buf->smb_nt_passwd;
user.smb_passwd = pw_buf->smb_passwd;
user.acct_ctrl = pw_buf->acct_ctrl;
user.unknown_3 = 0xffffff;
user.logon_divs = 168;
user.hours_len = 21;
memset(user.hours, 0xff, user.hours_len);
user.unknown_5 = 0x00000000;
user.unknown_6 = 0x000004ec;
return &user;
}
static struct sam_passwd *getsmbfile21pwent(void *vp)
{
struct smb_passwd *pw_buf = getsmbfilepwent(vp);
struct sam_passwd *user;
DEBUG(5,("getsmbfile21pwent\n"));
user = build_sampw_from_smbpw(pw_buf);
return user;
}
static SMB_BIG_UINT getsmbfilepwpos(void *vp)
{
return (SMB_BIG_UINT)sys_ftell((FILE *)vp);
}
static BOOL setsmbfilepwpos(void *vp, SMB_BIG_UINT tok)
{
return !sys_fseek((FILE *)vp, (SMB_OFF_T)tok, SEEK_SET);
}
char *format_new_smbpasswd_entry(struct smb_passwd *newpwd)
{
int new_entry_length;
char *new_entry;
char *p;
int i;
new_entry_length = strlen(newpwd->smb_name) + 1 + 15 + 1 + 32 + 1 + 32 + 1 + NEW_PW_FORMAT_SPACE_PADDED_LEN + 1 + 13 + 2;
if((new_entry = (char *)malloc( new_entry_length )) == NULL) {
DEBUG(0, ("format_new_smbpasswd_entry: Malloc failed adding entry for user %s.\n", newpwd->smb_name ));
return NULL;
}
slprintf(new_entry, new_entry_length - 1, "%s:%u:", newpwd->smb_name, (unsigned)newpwd->smb_userid);
p = &new_entry[strlen(new_entry)];
if(newpwd->smb_passwd != NULL) {
for( i = 0; i < 16; i++) {
slprintf((char *)&p[i*2], new_entry_length - (p - new_entry) - 1, "%02X", newpwd->smb_passwd[i]);
}
} else {
i=0;
if(newpwd->acct_ctrl & ACB_PWNOTREQ)
safe_strcpy((char *)p, "NO PASSWORDXXXXXXXXXXXXXXXXXXXXX", new_entry_length - 1 - (p - new_entry));
else
safe_strcpy((char *)p, "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", new_entry_length - 1 - (p - new_entry));
}
p += 32;
*p++ = ':';
if(newpwd->smb_nt_passwd != NULL) {
for( i = 0; i < 16; i++) {
slprintf((char *)&p[i*2], new_entry_length - 1 - (p - new_entry), "%02X", newpwd->smb_nt_passwd[i]);
}
} else {
if(newpwd->acct_ctrl & ACB_PWNOTREQ)
safe_strcpy((char *)p, "NO PASSWORDXXXXXXXXXXXXXXXXXXXXX", new_entry_length - 1 - (p - new_entry));
else
safe_strcpy((char *)p, "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", new_entry_length - 1 - (p - new_entry));
}
p += 32;
*p++ = ':';
slprintf((char *)p, new_entry_length - 1 - (p - new_entry), "%s:LCT-%08X:\n",
pdb_encode_acct_ctrl(newpwd->acct_ctrl, NEW_PW_FORMAT_SPACE_PADDED_LEN),
(uint32)newpwd->pass_last_set_time);
return new_entry;
}
static BOOL add_smbfilepwd_entry(struct smb_passwd *newpwd)
{
char *pfile = lp_smb_passwd_file();
struct smb_passwd *pwd = NULL;
FILE *fp = NULL;
int wr_len;
int fd;
size_t new_entry_length;
char *new_entry;
SMB_OFF_T offpos;
fp = startsmbfilepwent(True);
if (fp == NULL) {
DEBUG(0, ("add_smbfilepwd_entry: unable to open file.\n"));
return False;
}
while ((pwd = getsmbfilepwent(fp)) != NULL) {
if (strequal(newpwd->smb_name, pwd->smb_name)) {
DEBUG(0, ("add_smbfilepwd_entry: entry with name %s already exists\n", pwd->smb_name));
endsmbfilepwent(fp);
return False;
}
}
fd = fileno(fp);
if((offpos = sys_lseek(fd, 0, SEEK_END)) == -1) {
DEBUG(0, ("add_smbfilepwd_entry(sys_lseek): Failed to add entry for user %s to file %s. \
Error was %s\n", newpwd->smb_name, pfile, strerror(errno)));
endsmbfilepwent(fp);
return False;
}
if((new_entry = format_new_smbpasswd_entry(newpwd)) == NULL) {
DEBUG(0, ("add_smbfilepwd_entry(malloc): Failed to add entry for user %s to file %s. \
Error was %s\n", newpwd->smb_name, pfile, strerror(errno)));
endsmbfilepwent(fp);
return False;
}
new_entry_length = strlen(new_entry);
#ifdef DEBUG_PASSWORD
DEBUG(100, ("add_smbfilepwd_entry(%d): new_entry_len %d made line |%s|",
fd, new_entry_length, new_entry));
#endif
if ((wr_len = write(fd, new_entry, new_entry_length)) != new_entry_length) {
DEBUG(0, ("add_smbfilepwd_entry(write): %d Failed to add entry for user %s to file %s. \
Error was %s\n", wr_len, newpwd->smb_name, pfile, strerror(errno)));
if(sys_ftruncate(fd, offpos) == -1) {
DEBUG(0, ("add_smbfilepwd_entry: ERROR failed to ftruncate file %s. \
Error was %s. Password file may be corrupt ! Please examine by hand !\n",
newpwd->smb_name, strerror(errno)));
}
endsmbfilepwent(fp);
free(new_entry);
return False;
}
free(new_entry);
endsmbfilepwent(fp);
return True;
}
static BOOL mod_smbfilepwd_entry(struct smb_passwd* pwd, BOOL override)
{
static pstring user_name;
char linebuf[256];
char readbuf[1024];
unsigned char c;
fstring ascii_p16;
fstring encode_bits;
unsigned char *p = NULL;
size_t linebuf_len = 0;
FILE *fp;
int lockfd;
char *pfile = lp_smb_passwd_file();
BOOL found_entry = False;
BOOL got_pass_last_set_time = False;
SMB_OFF_T pwd_seekpos = 0;
int i;
int wr_len;
int fd;
if (!*pfile) {
DEBUG(0, ("No SMB password file set\n"));
return False;
}
DEBUG(10, ("mod_smbfilepwd_entry: opening file %s\n", pfile));
fp = sys_fopen(pfile, "r+");
if (fp == NULL) {
DEBUG(0, ("mod_smbfilepwd_entry: unable to open file %s\n", pfile));
return False;
}
setvbuf(fp, readbuf, _IOFBF, sizeof(readbuf));
lockfd = fileno(fp);
if (!pw_file_lock(lockfd, F_WRLCK, 5, &pw_file_lock_depth)) {
DEBUG(0, ("mod_smbfilepwd_entry: unable to lock file %s\n", pfile));
fclose(fp);
return False;
}
chmod(pfile, 0600);
while (!feof(fp)) {
pwd_seekpos = sys_ftell(fp);
linebuf[0] = '\0';
fgets(linebuf, sizeof(linebuf), fp);
if (ferror(fp)) {
pw_file_unlock(lockfd, &pw_file_lock_depth);
fclose(fp);
return False;
}
linebuf_len = strlen(linebuf);
if (linebuf[linebuf_len - 1] != '\n') {
c = '\0';
while (!ferror(fp) && !feof(fp)) {
c = fgetc(fp);
if (c == '\n') {
break;
}
}
} else {
linebuf[linebuf_len - 1] = '\0';
}
#ifdef DEBUG_PASSWORD
DEBUG(100, ("mod_smbfilepwd_entry: got line |%s|\n", linebuf));
#endif
if ((linebuf[0] == 0) && feof(fp)) {
DEBUG(4, ("mod_smbfilepwd_entry: end of file reached\n"));
break;
}
if (linebuf[0] == '#' || linebuf[0] == '\0') {
DEBUG(6, ("mod_smbfilepwd_entry: skipping comment or blank line\n"));
continue;
}
p = (unsigned char *) strchr(linebuf, ':');
if (p == NULL) {
DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (no :)\n"));
continue;
}
strncpy(user_name, linebuf, PTR_DIFF(p, linebuf));
user_name[PTR_DIFF(p, linebuf)] = '\0';
if (strequal(user_name, pwd->smb_name)) {
found_entry = True;
break;
}
}
if (!found_entry) {
pw_file_unlock(lockfd, &pw_file_lock_depth);
fclose(fp);
return False;
}
DEBUG(6, ("mod_smbfilepwd_entry: entry exists\n"));
p++;
if (!isdigit(*p)) {
DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (uid not number)\n"));
pw_file_unlock(lockfd, &pw_file_lock_depth);
fclose(fp);
return False;
}
while (*p && isdigit(*p))
p++;
if (*p != ':') {
DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (no : after uid)\n"));
pw_file_unlock(lockfd, &pw_file_lock_depth);
fclose(fp);
return False;
}
p++;
pwd_seekpos += PTR_DIFF(p, linebuf);
if (!override && (*p == '*' || *p == 'X')) {
DEBUG(10, ("mod_smbfilepwd_entry: entry invalidated for user %s\n", user_name));
pw_file_unlock(lockfd, &pw_file_lock_depth);
fclose(fp);
return False;
}
if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (passwd too short)\n"));
pw_file_unlock(lockfd,&pw_file_lock_depth);
fclose(fp);
return (False);
}
if (p[32] != ':') {
DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (no terminating :)\n"));
pw_file_unlock(lockfd,&pw_file_lock_depth);
fclose(fp);
return False;
}
if (!override && (*p == '*' || *p == 'X')) {
pw_file_unlock(lockfd,&pw_file_lock_depth);
fclose(fp);
return False;
}
p += 33;
if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (passwd too short)\n"));
pw_file_unlock(lockfd,&pw_file_lock_depth);
fclose(fp);
return (False);
}
if (p[32] != ':') {
DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (no terminating :)\n"));
pw_file_unlock(lockfd,&pw_file_lock_depth);
fclose(fp);
return False;
}
p += 33;
if(pwd->smb_passwd != NULL || pwd->smb_nt_passwd != NULL) {
pwd->acct_ctrl &= ~(ACB_PWNOTREQ);
}
if (*p == '[') {
i = 0;
encode_bits[i++] = *p++;
while((linebuf_len > PTR_DIFF(p, linebuf)) && (*p != ']'))
encode_bits[i++] = *p++;
encode_bits[i++] = ']';
encode_bits[i++] = '\0';
if(i == NEW_PW_FORMAT_SPACE_PADDED_LEN) {
fstrcpy(encode_bits, pdb_encode_acct_ctrl(pwd->acct_ctrl, NEW_PW_FORMAT_SPACE_PADDED_LEN));
} else {
if(pwd->acct_ctrl & (ACB_DISABLED|ACB_PWNOTREQ)) {
pwd->smb_passwd = NULL;
pwd->smb_nt_passwd = NULL;
}
}
if(linebuf_len > PTR_DIFF(p, linebuf))
p++;
if((linebuf_len > PTR_DIFF(p, linebuf)) && (*p == ':')) {
p++;
if((linebuf_len > (PTR_DIFF(p, linebuf) + 13)) && (StrnCaseCmp((char *)p, "LCT-", 4) == 0)) {
p += 4;
for(i = 0; i < 8; i++) {
if(p[i] == '\0' || !isxdigit(p[i]))
break;
}
if(i == 8) {
got_pass_last_set_time = True;
}
}
}
}
if(pwd->smb_passwd != NULL) {
for (i = 0; i < 16; i++) {
slprintf(&ascii_p16[i*2], sizeof(fstring) - 1, "%02X", (uchar) pwd->smb_passwd[i]);
}
} else {
if(pwd->acct_ctrl & ACB_PWNOTREQ)
fstrcpy(ascii_p16, "NO PASSWORDXXXXXXXXXXXXXXXXXXXXX");
else
fstrcpy(ascii_p16, "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
}
ascii_p16[32] = ':';
wr_len = 66;
if (pwd->smb_nt_passwd != NULL) {
for (i = 0; i < 16; i++) {
slprintf(&ascii_p16[(i*2)+33], sizeof(fstring) - 1, "%02X", (uchar) pwd->smb_nt_passwd[i]);
}
} else {
if(pwd->acct_ctrl & ACB_PWNOTREQ)
fstrcpy(&ascii_p16[33], "NO PASSWORDXXXXXXXXXXXXXXXXXXXXX");
else
fstrcpy(&ascii_p16[33], "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
}
ascii_p16[65] = ':';
ascii_p16[66] = '\0';
pwd->pass_last_set_time = time(NULL);
if(got_pass_last_set_time) {
slprintf(&ascii_p16[strlen(ascii_p16)],
sizeof(ascii_p16)-(strlen(ascii_p16)+1),
"%s:LCT-%08X:",
encode_bits, (uint32)pwd->pass_last_set_time );
wr_len = strlen(ascii_p16);
}
#ifdef DEBUG_PASSWORD
DEBUG(100,("mod_smbfilepwd_entry: "));
dump_data(100, ascii_p16, wr_len);
#endif
if(wr_len > sizeof(linebuf)) {
DEBUG(0, ("mod_smbfilepwd_entry: line to write (%d) is too long.\n", wr_len+1));
pw_file_unlock(lockfd,&pw_file_lock_depth);
fclose(fp);
return (False);
}
fd = fileno(fp);
if (sys_lseek(fd, pwd_seekpos - 1, SEEK_SET) != pwd_seekpos - 1) {
DEBUG(0, ("mod_smbfilepwd_entry: seek fail on file %s.\n", pfile));
pw_file_unlock(lockfd,&pw_file_lock_depth);
fclose(fp);
return False;
}
if (read(fd, linebuf, wr_len+1) != wr_len+1) {
DEBUG(0, ("mod_smbfilepwd_entry: read fail on file %s.\n", pfile));
pw_file_unlock(lockfd,&pw_file_lock_depth);
fclose(fp);
return False;
}
if ((linebuf[0] != ':') || (linebuf[wr_len] != ':')) {
DEBUG(0, ("mod_smbfilepwd_entry: check on passwd file %s failed.\n", pfile));
pw_file_unlock(lockfd,&pw_file_lock_depth);
fclose(fp);
return False;
}
if (sys_lseek(fd, pwd_seekpos, SEEK_SET) != pwd_seekpos) {
DEBUG(0, ("mod_smbfilepwd_entry: seek fail on file %s.\n", pfile));
pw_file_unlock(lockfd,&pw_file_lock_depth);
fclose(fp);
return False;
}
if (write(fd, ascii_p16, wr_len) != wr_len) {
DEBUG(0, ("mod_smbfilepwd_entry: write failed in passwd file %s\n", pfile));
pw_file_unlock(lockfd,&pw_file_lock_depth);
fclose(fp);
return False;
}
pw_file_unlock(lockfd,&pw_file_lock_depth);
fclose(fp);
return True;
}
static BOOL del_smbfilepwd_entry(const char *name)
{
char *pfile = lp_smb_passwd_file();
pstring pfile2;
struct smb_passwd *pwd = NULL;
FILE *fp = NULL;
FILE *fp_write = NULL;
int pfile2_lockdepth = 0;
slprintf(pfile2, sizeof(pfile2)-1, "%s.%u", pfile, (unsigned)sys_getpid() );
if((fp = startsmbfilepwent(True)) == NULL) {
DEBUG(0, ("del_smbfilepwd_entry: unable to open file %s.\n", pfile));
return False;
}
if((fp_write = startsmbfilepwent_internal(pfile2, PWF_CREATE, &pfile2_lockdepth)) == NULL) {
DEBUG(0, ("del_smbfilepwd_entry: unable to open file %s.\n", pfile));
endsmbfilepwent(fp);
return False;
}
while ((pwd = getsmbfilepwent(fp)) != NULL) {
char *new_entry;
size_t new_entry_length;
if (strequal(name, pwd->smb_name)) {
DEBUG(10, ("add_smbfilepwd_entry: found entry with name %s - deleting it.\n", name));
continue;
}
if((new_entry = format_new_smbpasswd_entry(pwd)) == NULL) {
DEBUG(0, ("del_smbfilepwd_entry(malloc): Failed to copy entry for user %s to file %s. \
Error was %s\n", pwd->smb_name, pfile2, strerror(errno)));
unlink(pfile2);
endsmbfilepwent(fp);
endsmbfilepwent_internal(fp_write,&pfile2_lockdepth);
return False;
}
new_entry_length = strlen(new_entry);
if(fwrite(new_entry, 1, new_entry_length, fp_write) != new_entry_length) {
DEBUG(0, ("del_smbfilepwd_entry(write): Failed to copy entry for user %s to file %s. \
Error was %s\n", pwd->smb_name, pfile2, strerror(errno)));
unlink(pfile2);
endsmbfilepwent(fp);
endsmbfilepwent_internal(fp_write,&pfile2_lockdepth);
free(new_entry);
return False;
}
free(new_entry);
}
if(fflush(fp_write) != 0) {
DEBUG(0, ("del_smbfilepwd_entry: Failed to flush file %s. Error was %s\n", pfile2, strerror(errno)));
endsmbfilepwent(fp);
endsmbfilepwent_internal(fp_write,&pfile2_lockdepth);
return False;
}
if(rename(pfile2,pfile) != 0) {
unlink(pfile2);
}
endsmbfilepwent(fp);
endsmbfilepwent_internal(fp_write,&pfile2_lockdepth);
return True;
}
static struct smb_passwd *iterate_getsmbpwuid(uid_t smb_userid)
{
struct smb_passwd *pwd = NULL;
void *fp = NULL;
DEBUG(10, ("search by smb_userid: %x\n", (int)smb_userid));
fp = startsmbpwent(False);
if (fp == NULL)
{
DEBUG(0, ("unable to open smb password database.\n"));
return NULL;
}
while ((pwd = getsmbpwent(fp)) != NULL && pwd->smb_userid != smb_userid)
;
if (pwd != NULL)
{
DEBUG(10, ("found by smb_userid: %x\n", (int)smb_userid));
}
endsmbpwent(fp);
return pwd;
}
static struct smb_passwd *iterate_getsmbpwrid(uint32 user_rid)
{
return iterate_getsmbpwuid(pdb_user_rid_to_uid(user_rid));
}
static struct smb_passwd *iterate_getsmbpwnam(char *name)
{
struct smb_passwd *pwd = NULL;
void *fp = NULL;
DEBUG(10, ("search by name: %s\n", name));
fp = startsmbpwent(False);
if (fp == NULL)
{
DEBUG(0, ("unable to open smb password database.\n"));
return NULL;
}
while ((pwd = getsmbpwent(fp)) != NULL && !strequal(pwd->smb_name, name))
;
if (pwd != NULL)
{
DEBUG(10, ("found by name: %s\n", name));
}
endsmbpwent(fp);
return pwd;
}
static struct sam_passwd *smbiterate_getsam21pwnam(char *name)
{
struct sam_passwd *pwd = NULL;
struct smb_passwd *smbpw = NULL;
DEBUG(10, ("search by name: %s\n", name));
smbpw = getsmbpwnam(name);
if (smbpw != NULL)
{
pwd = build_sampw_from_smbpw (smbpw);
DEBUG(10, ("found by name: %s\n", name));
}
return pwd;
}
struct sam_passwd *smbiterate_getsam21pwrid(uint32 rid)
{
struct sam_passwd *pwd = NULL;
struct smb_passwd *smbpw = NULL;
DEBUG(10, ("search by rid: %x\n", rid));
smbpw = getsmbpwrid(rid);
if (smbpw != NULL)
{
pwd = build_sampw_from_smbpw (smbpw);
DEBUG(10, ("found by user_rid: %x\n", rid));
}
return pwd;
}
struct sam_passwd *smbiterate_getsam21pwuid(uid_t uid)
{
struct sam_passwd *pwd = NULL;
struct smb_passwd *smbpw = NULL;
DEBUG(10, ("search by uid: %x\n", (int)uid));
smbpw = getsmbpwuid(uid);
if (smbpw != NULL)
{
pwd = build_sampw_from_smbpw (smbpw);
DEBUG(10, ("found by user_uid: %u\n", (unsigned int)uid));
}
return pwd;
}
static BOOL mod_smbfile21pwd_entry(struct sam_passwd* pwd, BOOL override)
{
return mod_smbfilepwd_entry(pdb_sam_to_smb(pwd), override);
}
static BOOL add_smbfile21pwd_entry(struct sam_passwd *newpwd)
{
return add_smbfilepwd_entry(pdb_sam_to_smb(newpwd));
}
static struct sam_disp_info *getsmbfiledispnam(char *name)
{
return pdb_sam_to_dispinfo(getsam21pwnam(name));
}
static struct sam_disp_info *getsmbfiledisprid(uint32 rid)
{
return pdb_sam_to_dispinfo(getsam21pwrid(rid));
}
static struct sam_disp_info *getsmbfiledispent(void *vp)
{
return pdb_sam_to_dispinfo(getsam21pwent(vp));
}
static struct passdb_ops file_ops = {
startsmbfilepwent,
endsmbfilepwent,
getsmbfilepwpos,
setsmbfilepwpos,
iterate_getsmbpwnam,
iterate_getsmbpwuid,
iterate_getsmbpwrid,
getsmbfilepwent,
add_smbfilepwd_entry,
mod_smbfilepwd_entry,
del_smbfilepwd_entry,
getsmbfile21pwent,
smbiterate_getsam21pwnam,
smbiterate_getsam21pwuid,
smbiterate_getsam21pwrid,
add_smbfile21pwd_entry,
mod_smbfile21pwd_entry,
getsmbfiledispnam,
getsmbfiledisprid,
getsmbfiledispent
};
struct passdb_ops *file_initialize_password_db(void)
{
return &file_ops;
}
#else
void smbpass_dummy_function(void) { }
#endif