#include "includes.h"
#ifdef WITH_SMBPASSWD_SAM
struct smb_passwd
{
uid_t smb_userid;
char *smb_name;
unsigned char *smb_passwd;
unsigned char *smb_nt_passwd;
uint16 acct_ctrl;
time_t pass_last_set_time;
};
extern pstring samlogon_user;
extern BOOL sam_logon_in_ssb;
extern struct passdb_ops pdb_ops;
static int pw_file_lock_depth;
static void *global_vp;
enum pwf_access_type { PWF_READ, PWF_UPDATE, PWF_CREATE };
static BOOL pw_file_lock(int fd, int type, int secs, int *plock_depth)
{
if (fd < 0)
return False;
if(*plock_depth == 0) {
if (!do_file_lock(fd, secs, type)) {
DEBUG(10,("pw_file_lock: locking file failed, error = %s.\n",
strerror(errno)));
return False;
}
}
(*plock_depth)++;
return True;
}
static BOOL pw_file_unlock(int fd, int *plock_depth)
{
BOOL ret=True;
if(*plock_depth == 1)
ret = do_file_lock(fd, 5, F_UNLCK);
if (*plock_depth > 0)
(*plock_depth)--;
if(!ret)
DEBUG(10,("pw_file_unlock: unlocking file failed, error = %s.\n",
strerror(errno)));
return ret;
}
static void pdb_init_smb(struct smb_passwd *user)
{
if (user == NULL)
return;
ZERO_STRUCTP (user);
user->pass_last_set_time = (time_t)0;
}
static void *startsmbfilepwent(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(2, ("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 endsmbfilepwent(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 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.\n"));
continue;
}
if (!isdigit(*p)) {
DEBUG(0, ("getsmbfilepwent: malformed password entry (uid not number)\n"));
continue;
}
uidval = atoi((char *) p);
while (*p && isdigit(*p))
p++;
if (*p != ':') {
DEBUG(0, ("getsmbfilepwent: malformed password entry (no : after uid)\n"));
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)\n"));
continue;
}
if (p[32] != ':') {
DEBUG(0, ("getsmbfilepwent: malformed password entry (no terminating :)\n"));
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)\n"));
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 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(pfile, PWF_UPDATE, &pw_file_lock_depth);
if (fp == NULL && errno == ENOENT) {
fp = startsmbfilepwent(pfile, PWF_CREATE, &pw_file_lock_depth);
}
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, &pw_file_lock_depth);
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, &pw_file_lock_depth);
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, &pw_file_lock_depth);
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, &pw_file_lock_depth);
free(new_entry);
return False;
}
free(new_entry);
endsmbfilepwent(fp, &pw_file_lock_depth);
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(pfile, PWF_UPDATE, &pw_file_lock_depth)) == NULL) {
DEBUG(0, ("del_smbfilepwd_entry: unable to open file %s.\n", pfile));
return False;
}
if((fp_write = startsmbfilepwent(pfile2, PWF_CREATE, &pfile2_lockdepth)) == NULL) {
DEBUG(0, ("del_smbfilepwd_entry: unable to open file %s.\n", pfile));
endsmbfilepwent(fp, &pw_file_lock_depth);
return False;
}
while ((pwd = getsmbfilepwent(fp)) != NULL) {
char *new_entry;
size_t new_entry_length;
if (strequal(name, pwd->smb_name)) {
DEBUG(10, ("del_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, &pw_file_lock_depth);
endsmbfilepwent(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, &pw_file_lock_depth);
endsmbfilepwent(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, &pw_file_lock_depth);
endsmbfilepwent(fp_write,&pfile2_lockdepth);
return False;
}
if(rename(pfile2,pfile) != 0) {
unlink(pfile2);
}
endsmbfilepwent(fp, &pw_file_lock_depth);
endsmbfilepwent(fp_write,&pfile2_lockdepth);
return True;
}
static BOOL build_smb_pass (struct smb_passwd *smb_pw, SAM_ACCOUNT *sampass)
{
if (sampass == NULL)
return False;
ZERO_STRUCTP(smb_pw);
smb_pw->smb_userid=pdb_get_uid(sampass);
smb_pw->smb_name=pdb_get_username(sampass);
smb_pw->smb_passwd=pdb_get_lanman_passwd(sampass);
smb_pw->smb_nt_passwd=pdb_get_nt_passwd(sampass);
smb_pw->acct_ctrl=pdb_get_acct_ctrl(sampass);
smb_pw->pass_last_set_time=pdb_get_pass_last_set_time(sampass);
return True;
}
static BOOL build_sam_account(SAM_ACCOUNT *sam_pass, struct smb_passwd *pw_buf)
{
struct passwd *pwfile;
if (sam_pass==NULL) {
DEBUG(5,("build_sam_account: SAM_ACCOUNT is NULL\n"));
return False;
}
pwfile = sys_getpwnam(pw_buf->smb_name);
if (pwfile == NULL) {
DEBUG(0,("build_sam_account: smbpasswd database is corrupt! username %s not in unix passwd database!\n", pw_buf->smb_name));
return False;
}
pstrcpy(samlogon_user, pw_buf->smb_name);
pdb_set_uid (sam_pass, pwfile->pw_uid);
pdb_set_gid (sam_pass, pwfile->pw_gid);
pdb_set_fullname(sam_pass, pwfile->pw_gecos);
pdb_set_user_rid(sam_pass, pdb_uid_to_user_rid (pwfile->pw_uid));
pdb_set_group_rid(sam_pass, pdb_gid_to_group_rid(pwfile->pw_gid));
pdb_set_username (sam_pass, pw_buf->smb_name);
if (!pdb_set_nt_passwd (sam_pass, pw_buf->smb_nt_passwd)) {
if (pw_buf->smb_nt_passwd)
return False;
}
if (!pdb_set_lanman_passwd (sam_pass, pw_buf->smb_passwd)) {
if (pw_buf->smb_passwd)
return False;
}
pdb_set_acct_ctrl (sam_pass, pw_buf->acct_ctrl);
pdb_set_pass_last_set_time (sam_pass, pw_buf->pass_last_set_time);
pdb_set_pass_can_change_time (sam_pass, pw_buf->pass_last_set_time);
pdb_set_domain (sam_pass, lp_workgroup());
pdb_set_dir_drive (sam_pass, lp_logon_drive(), False);
pdb_set_pass_must_change_time (sam_pass, time(NULL)+1814400);
if (samlogon_user[strlen(samlogon_user)-1] != '$')
{
pstring str;
gid_t gid = getegid();
sam_logon_in_ssb = True;
pstrcpy(str, lp_logon_script());
standard_sub_advanced(-1, pw_buf->smb_name, "", gid, str);
pdb_set_logon_script(sam_pass, str, False);
pstrcpy(str, lp_logon_path());
standard_sub_advanced(-1, pw_buf->smb_name, "", gid, str);
pdb_set_profile_path(sam_pass, str, False);
pstrcpy(str, lp_logon_home());
standard_sub_advanced(-1, pw_buf->smb_name, "", gid, str);
pdb_set_homedir(sam_pass, str, False);
sam_logon_in_ssb = False;
} else {
pdb_set_group_rid (sam_pass, DOMAIN_GROUP_RID_USERS);
}
return True;
}
BOOL pdb_setsampwent (BOOL update)
{
global_vp = startsmbfilepwent(lp_smb_passwd_file(),
update ? PWF_UPDATE : PWF_READ,
&pw_file_lock_depth);
if (!global_vp && update && errno == ENOENT)
{
FILE *fp;
DEBUG(0,("smbpasswd file did not exist - attempting to create it.\n"));
fp = sys_fopen(lp_smb_passwd_file(), "w");
if (fp)
{
fprintf(fp, "# Samba SMB password file\n");
fclose(fp);
}
global_vp = startsmbfilepwent(lp_smb_passwd_file(),
update ? PWF_UPDATE : PWF_READ,
&pw_file_lock_depth);
}
return (global_vp != NULL);
}
void pdb_endsampwent (void)
{
endsmbfilepwent(global_vp, &pw_file_lock_depth);
}
BOOL pdb_getsampwent(SAM_ACCOUNT *user)
{
struct smb_passwd *pw_buf=NULL;
BOOL done = False;
DEBUG(5,("pdb_getsampwent\n"));
if (user==NULL) {
DEBUG(5,("pdb_getsampwent: user is NULL\n"));
#if 0
smb_panic("NULL pointer passed to pdb_getsampwent\n");
#endif
return False;
}
while (!done)
{
pw_buf = getsmbfilepwent(global_vp);
if (pw_buf == NULL)
return False;
if (build_sam_account(user, pw_buf))
done = True;
}
DEBUG(5,("pdb_getsampwent:done\n"));
return True;
}
BOOL pdb_getsampwnam(SAM_ACCOUNT *sam_acct, char *username)
{
struct smb_passwd *smb_pw;
void *fp = NULL;
char *domain = NULL;
char *user = NULL;
fstring name;
DEBUG(10, ("pdb_getsampwnam: search by name: %s\n", username));
fstrcpy (name, username);
if ((user=strchr(name, '\\')) != NULL) {
domain = name;
*user = '\0';
user++;
}
if ( domain && !StrCaseCmp(domain, lp_workgroup()) )
return False;
fp = startsmbfilepwent(lp_smb_passwd_file(), PWF_READ, &pw_file_lock_depth);
if (fp == NULL) {
DEBUG(0, ("unable to open passdb database.\n"));
return False;
}
if ( domain )
map_username(user);
while ( ((smb_pw=getsmbfilepwent(fp)) != NULL)&& (!strequal(smb_pw->smb_name, username)) )
;
endsmbfilepwent(fp, &pw_file_lock_depth);
if (smb_pw == NULL)
return False;
DEBUG(10, ("pdb_getsampwnam: found by name: %s\n", smb_pw->smb_name));
if (!sam_acct) {
DEBUG(10,("pdb_getsampwnam:SAM_ACCOUNT is NULL\n"));
#if 0
smb_panic("NULL pointer passed to pdb_getsampwnam\n");
#endif
return False;
}
if (!build_sam_account(sam_acct, smb_pw))
return False;
return True;
}
BOOL pdb_getsampwrid(SAM_ACCOUNT *sam_acct,uint32 rid)
{
struct smb_passwd *smb_pw;
void *fp = NULL;
DEBUG(10, ("pdb_getsampwrid: search by rid: %d\n", rid));
fp = startsmbfilepwent(lp_smb_passwd_file(), PWF_READ, &pw_file_lock_depth);
if (fp == NULL) {
DEBUG(0, ("unable to open passdb database.\n"));
return False;
}
while ( ((smb_pw=getsmbfilepwent(fp)) != NULL) && (pdb_uid_to_user_rid(smb_pw->smb_userid) != rid) )
;
endsmbfilepwent(fp, &pw_file_lock_depth);
if (smb_pw == NULL)
return False;
DEBUG(10, ("pdb_getsampwrid: found by name: %s\n", smb_pw->smb_name));
if (!sam_acct) {
DEBUG(10,("pdb_getsampwrid:SAM_ACCOUNT is NULL\n"));
#if 0
smb_panic("NULL pointer passed to pdb_getsampwrid\n");
#endif
return False;
}
if (!build_sam_account (sam_acct, smb_pw))
return False;
return True;
}
BOOL pdb_add_sam_account(SAM_ACCOUNT *sampass)
{
struct smb_passwd smb_pw;
build_smb_pass(&smb_pw, sampass);
if(!add_smbfilepwd_entry(&smb_pw))
return False;
return True;
}
BOOL pdb_update_sam_account(SAM_ACCOUNT *sampass, BOOL override)
{
struct smb_passwd smb_pw;
build_smb_pass(&smb_pw, sampass);
if(!mod_smbfilepwd_entry(&smb_pw, override))
return False;
return True;
}
BOOL pdb_delete_sam_account (char* username)
{
return del_smbfilepwd_entry(username);
}
#else
void smbpass_dummy_function(void) { }
#endif