sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2024-12-24 21:34:56 +03:00
Code

Remove last pstring from smbd/*.c

Browse Source 
Jeremy.
This commit is contained in:
Jeremy Allison 2007-11-13 12:51:31 -08:00
parent 4d3e84a3b3
commit f1680bada9
5 changed files with 312 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source/auth/auth_compat.c
View File

@ -92,7 +92,7 @@ check if a username/password pair is ok via the auth subsystem.
return True if the password is correct, False otherwise
****************************************************************************/
bool password_ok(char *smb_name, DATA_BLOB password_blob)
bool password_ok(const char *smb_name, DATA_BLOB password_blob)
{
DATA_BLOB null_password = data_blob_null;

47
source/smbd/message.c
View File

@ -38,7 +38,8 @@ static fstring msgto;
static void msg_deliver(void)
{
pstring name;
TALLOC_CTX *ctx = talloc_tos();
char *name = NULL;
int i;
int fd;
char *msg;
@ -52,7 +53,10 @@ static void msg_deliver(void)
}
/* put it in a temporary file */
slprintf(name,sizeof(name)-1, "%s/msg.XXXXXX",tmpdir());
name = talloc_asprintf(ctx, "%s/msg.XXXXXX",tmpdir());
if (!name) {
return;
}
fd = smb_mkstemp(name);
if (fd == -1) {
@ -95,14 +99,39 @@ static void msg_deliver(void)
if (*lp_msg_command()) {
fstring alpha_msgfrom;
fstring alpha_msgto;
pstring s;
char *s = talloc_strdup(ctx,
lp_msg_command());
pstrcpy(s,lp_msg_command());
pstring_sub(s,"%f",alpha_strcpy(alpha_msgfrom,msgfrom,NULL,sizeof(alpha_msgfrom)));
pstring_sub(s,"%t",alpha_strcpy(alpha_msgto,msgto,NULL,sizeof(alpha_msgto)));
standard_sub_basic(current_user_info.smb_name,
current_user_info.domain, s, sizeof(s));
pstring_sub(s,"%s",name);
if (!s) {
return;
}
s = talloc_string_sub(ctx, s, "%f",
alpha_strcpy(alpha_msgfrom,
msgfrom,
NULL,
sizeof(alpha_msgfrom)));
if (!s) {
return;
}
s = talloc_string_sub(ctx, s, "%t",
alpha_strcpy(alpha_msgto,
msgto,
NULL,
sizeof(alpha_msgto)));
if (!s) {
return;
}
s = talloc_sub_basic(ctx,
current_user_info.smb_name,
current_user_info.domain,
s);
if (!s) {
return;
}
s = talloc_string_sub(ctx, s, "%s",name);
if (!s) {
return;
}
smbrun(s,NULL);
}

66
source/smbd/password.c
View File

@ -669,46 +669,51 @@ static char *validate_group(char *group, DATA_BLOB password,int snum)
/*
* As user_ok can recurse doing a getgrent(), we must
* copy the member list into a pstring on the stack before
* copy the member list onto the heap before
* use. Bug pointed out by leon@eatworms.swmed.edu.
*/
if (gptr) {
pstring member_list;
char *member_list = NULL;
size_t list_len = 0;
char *member;
size_t copied_len = 0;
int i;
for(i = 0; gptr->gr_mem && gptr->gr_mem[i]; i++) {
list_len += strlen(gptr->gr_mem[i])+1;
}
list_len++;
member_list = SMB_MALLOC(list_len);
if (!member_list) {
endgrent();
return NULL;
}
*member_list = '\0';
member = member_list;
for(i = 0; gptr->gr_mem && gptr->gr_mem[i]; i++) {
size_t member_len = strlen(gptr->gr_mem[i])+1;
if(copied_len+member_len < sizeof(pstring)) {
DEBUG(10,("validate_group: = gr_mem = "
"%s\n", gptr->gr_mem[i]));
DEBUG(10,("validate_group: = gr_mem = "
"%s\n", gptr->gr_mem[i]));
safe_strcpy(member, gptr->gr_mem[i],
sizeof(pstring) -
copied_len - 1);
copied_len += member_len;
member += copied_len;
} else {
*member = '\0';
}
safe_strcpy(member, gptr->gr_mem[i],
list_len - (member-member_list));
member += member_len;
}
endgrent();
member = member_list;
while (*member) {
static fstring name;
fstrcpy(name,member);
if (user_ok(name,snum) &&
password_ok(name,password)) {
endgrent();
return(&name[0]);
if (user_ok(member,snum) &&
password_ok(member,password)) {
char *name = talloc_strdup(talloc_tos(),
member);
SAFE_FREE(member_list);
return name;
}
DEBUG(10,("validate_group = member = %s\n",
@ -716,6 +721,8 @@ static char *validate_group(char *group, DATA_BLOB password,int snum)
member += strlen(member) + 1;
}
SAFE_FREE(member_list);
} else {
endgrent();
return NULL;
@ -790,11 +797,22 @@ bool authorise_login(int snum, fstring user, DATA_BLOB password,
/* check the user= fields and the given password */
if (!ok && lp_username(snum)) {
TALLOC_CTX *ctx = talloc_tos();
char *auser;
pstring user_list;
pstrcpy(user_list,lp_username(snum));
char *user_list = talloc_strdup(ctx, lp_username(snum));
pstring_sub(user_list,"%S",lp_servicename(snum));
if (!user_list) {
goto check_guest;
}
user_list = talloc_string_sub(ctx,
user_list,
"%S",
lp_servicename(snum));
if (!user_list) {
goto check_guest;
}
for (auser=strtok(user_list,LIST_SEP); auser && !ok;
auser = strtok(NULL,LIST_SEP)) {
@ -823,6 +841,8 @@ bool authorise_login(int snum, fstring user, DATA_BLOB password,
}
}
check_guest:
/* check for a normal guest connection */
if (!ok && GUEST_OK(snum)) {
fstring guestname;

321
source/smbd/quotas.c
View File

@ -45,7 +45,7 @@
* Declare here, define at end: reduces likely "include" interaction problems.
* David Lee <T.D.Lee@durham.ac.uk>
*/
bool disk_quotas_vxfs(const pstring name, char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize);
bool disk_quotas_vxfs(const char *name, char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize);
#endif /* VXFS_QUOTA */
@ -308,94 +308,81 @@ try to get the disk space from disk quotas (CRAY VERSION)
bool disk_quotas(const char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
{
struct mntent *mnt;
FILE *fd;
SMB_STRUCT_STAT sbuf;
SMB_DEV_T devno ;
static SMB_DEV_T devno_cached = 0 ;
static pstring name;
struct q_request request ;
struct qf_header header ;
static int quota_default = 0 ;
int found ;
struct mntent *mnt;
FILE *fd;
SMB_STRUCT_STAT sbuf;
SMB_DEV_T devno ;
struct q_request request ;
struct qf_header header ;
int quota_default = 0 ;
bool found = false;
if ( sys_stat(path,&sbuf) == -1 )
return(False) ;
if (sys_stat(path,&sbuf) == -1) {
return false;
}
devno = sbuf.st_dev ;
devno = sbuf.st_dev ;
if ( devno != devno_cached ) {
if ((fd = setmntent(KMTAB)) == NULL) {
return false;
}
devno_cached = devno ;
while ((mnt = getmntent(fd)) != NULL) {
if (sys_stat(mnt->mnt_dir,&sbuf) == -1) {
continue;
}
if (sbuf.st_dev == devno) {
found = frue ;
break;
}
}
if ((fd = setmntent(KMTAB)) == NULL)
return(False) ;
name = talloc_strdup(talloc_tos(), mnt->mnt_dir);
endmntent(fd);
if (!found) {
return false;
}
found = False ;
if (!name) {
return false;
}
while ((mnt = getmntent(fd)) != NULL) {
request.qf_magic = QF_MAGIC ;
request.qf_entry.id = geteuid() ;
if ( sys_stat(mnt->mnt_dir,&sbuf) == -1 )
continue ;
if (quotactl(name, Q_GETQUOTA, &request) == -1) {
return false;
}
if (sbuf.st_dev == devno) {
if (!request.user) {
return False;
}
found = True ;
break ;
if (request.qf_entry.user_q.f_quota == QFV_DEFAULT) {
if (!quota_default) {
if (quotactl(name, Q_GETHEADER, &header) == -1) {
return false;
} else {
quota_default = header.user_h.def_fq;
}
}
*dfree = quota_default;
} else if (request.qf_entry.user_q.f_quota == QFV_PREVENT) {
*dfree = 0;
} else {
*dfree = request.qf_entry.user_q.f_quota;
}
}
*dsize = request.qf_entry.user_q.f_use;
}
pstrcpy(name,mnt->mnt_dir) ;
endmntent(fd) ;
if ( ! found )
return(False) ;
}
request.qf_magic = QF_MAGIC ;
request.qf_entry.id = geteuid() ;
if (quotactl(name, Q_GETQUOTA, &request) == -1)
return(False) ;
if ( ! request.user )
return(False) ;
if ( request.qf_entry.user_q.f_quota == QFV_DEFAULT ) {
if ( ! quota_default ) {
if ( quotactl(name, Q_GETHEADER, &header) == -1 )
return(False) ;
else
quota_default = header.user_h.def_fq ;
}
*dfree = quota_default ;
}else if ( request.qf_entry.user_q.f_quota == QFV_PREVENT ) {
*dfree = 0 ;
}else{
*dfree = request.qf_entry.user_q.f_quota ;
}
*dsize = request.qf_entry.user_q.f_use ;
if ( *dfree < *dsize )
*dfree = 0 ;
else
*dfree -= *dsize ;
*bsize = 4096 ; /* Cray blocksize */
return(True) ;
if (*dfree < *dsize) {
*dfree = 0;
} else {
*dfree -= *dsize;
}
*bsize = 4096 ; /* Cray blocksize */
return true;
}
@ -587,7 +574,10 @@ try to get the disk space from disk quotas (SunOS & Solaris2 version)
Quota code by Peter Urbanec (amiga@cse.unsw.edu.au).
****************************************************************************/
bool disk_quotas(const char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
bool disk_quotas(const char *path,
SMB_BIG_UINT *bsize,
SMB_BIG_UINT *dfree,
SMB_BIG_UINT *dsize)
{
uid_t euser_id;
int ret;
@ -595,84 +585,90 @@ bool disk_quotas(const char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB
#if defined(SUNOS5)
struct quotctl command;
int file;
static struct mnttab mnt;
static pstring name;
struct mnttab mnt;
#else /* SunOS4 */
struct mntent *mnt;
static pstring name;
#endif
char *name = NULL;
FILE *fd;
SMB_STRUCT_STAT sbuf;
SMB_DEV_T devno ;
static SMB_DEV_T devno_cached = 0 ;
static int found ;
SMB_DEV_T devno;
bool found = false;
euser_id = geteuid();
if ( sys_stat(path,&sbuf) == -1 )
return(False) ;
if (sys_stat(path,&sbuf) == -1) {
return false;
}
devno = sbuf.st_dev ;
DEBUG(5,("disk_quotas: looking for path \"%s\" devno=%x\n",
path, (unsigned int)devno));
if ( devno != devno_cached ) {
devno_cached = devno ;
#if defined(SUNOS5)
if ((fd = sys_fopen(MNTTAB, "r")) == NULL)
return(False) ;
found = False ;
while (getmntent(fd, &mnt) == 0) {
if (sys_stat(mnt.mnt_mountp, &sbuf) == -1)
continue;
DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n",
mnt.mnt_mountp, (unsigned int)devno));
/* quotas are only on vxfs, UFS or NFS */
if ( (sbuf.st_dev == devno) && (
strcmp( mnt.mnt_fstype, MNTTYPE_UFS ) == 0 ||
strcmp( mnt.mnt_fstype, "nfs" ) == 0 ||
strcmp( mnt.mnt_fstype, "vxfs" ) == 0 )) {
found = True ;
break;
}
}
pstrcpy(name,mnt.mnt_mountp) ;
pstrcat(name,"/quotas") ;
fclose(fd) ;
#else /* SunOS4 */
if ((fd = setmntent(MOUNTED, "r")) == NULL)
return(False) ;
found = False ;
while ((mnt = getmntent(fd)) != NULL) {
if ( sys_stat(mnt->mnt_dir,&sbuf) == -1 )
continue ;
DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n", mnt->mnt_dir,(unsigned int)sbuf.st_dev));
if (sbuf.st_dev == devno) {
found = True ;
break;
}
}
pstrcpy(name,mnt->mnt_fsname) ;
endmntent(fd) ;
#endif
if ((fd = sys_fopen(MNTTAB, "r")) == NULL) {
return false;
}
if ( ! found )
return(False) ;
while (getmntent(fd, &mnt) == 0) {
if (sys_stat(mnt.mnt_mountp, &sbuf) == -1) {
continue;
}
DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n",
mnt.mnt_mountp, (unsigned int)devno));
/* quotas are only on vxfs, UFS or NFS */
if ((sbuf.st_dev == devno) && (
strcmp( mnt.mnt_fstype, MNTTYPE_UFS ) == 0 ||
strcmp( mnt.mnt_fstype, "nfs" ) == 0 ||
strcmp( mnt.mnt_fstype, "vxfs" ) == 0 )) {
found = true;
name = talloc_asprintf(talloc_tos(),
"%s/quotas",
mnt.mnt_mountp);
break;
}
}
fclose(fd);
#else /* SunOS4 */
if ((fd = setmntent(MOUNTED, "r")) == NULL) {
return false;
}
while ((mnt = getmntent(fd)) != NULL) {
if (sys_stat(mnt->mnt_dir,&sbuf) == -1) {
continue;
}
DEBUG(5,("disk_quotas: testing \"%s\" devno=%x\n",
mnt->mnt_dir,
(unsigned int)sbuf.st_dev));
if (sbuf.st_dev == devno) {
found = true;
name = talloc_strdup(talloc_tos(),
mnt->mnt_fsname);
break;
}
}
endmntent(fd);
#endif
if (!found) {
return false;
}
if (!name) {
return false;
}
become_root();
#if defined(SUNOS5)
if ( strcmp( mnt.mnt_fstype, "nfs" ) == 0) {
if (strcmp(mnt.mnt_fstype, "nfs") == 0) {
bool retval;
DEBUG(5,("disk_quotas: looking for mountpath (NFS) \"%s\"\n", mnt.mnt_special));
retval = nfs_quotas(mnt.mnt_special, euser_id, bsize, dfree, dsize);
DEBUG(5,("disk_quotas: looking for mountpath (NFS) \"%s\"\n",
mnt.mnt_special));
retval = nfs_quotas(mnt.mnt_special,
euser_id, bsize, dfree, dsize);
unbecome_root();
return retval;
}
@ -680,7 +676,7 @@ bool disk_quotas(const char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB
DEBUG(5,("disk_quotas: looking for quotas file \"%s\"\n", name));
if((file=sys_open(name, O_RDONLY,0))<0) {
unbecome_root();
return(False);
return false;
}
command.op = Q_GETQUOTA;
command.uid = euser_id;
@ -695,7 +691,8 @@ bool disk_quotas(const char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB
unbecome_root();
if (ret < 0) {
DEBUG(5,("disk_quotas ioctl (Solaris) failed. Error = %s\n", strerror(errno) ));
DEBUG(5,("disk_quotas ioctl (Solaris) failed. Error = %s\n",
strerror(errno) ));
#if defined(SUNOS5) && defined(VXFS_QUOTA)
/* If normal quotactl() fails, try vxfs private calls */
@ -703,24 +700,27 @@ bool disk_quotas(const char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB
DEBUG(5,("disk_quotas: mount type \"%s\"\n", mnt.mnt_fstype));
if ( 0 == strcmp ( mnt.mnt_fstype, "vxfs" )) {
bool retval;
retval = disk_quotas_vxfs(name, path, bsize, dfree, dsize);
return(retval);
retval = disk_quotas_vxfs(name, path,
bsize, dfree, dsize);
return retval;
}
#else
return(False);
return false;
#endif
}
/* If softlimit is zero, set it equal to hardlimit.
*/
if (D.dqb_bsoftlimit==0)
if (D.dqb_bsoftlimit==0) {
D.dqb_bsoftlimit = D.dqb_bhardlimit;
}
/* Use softlimit to determine disk space. A user exceeding the quota is told
* that there's no space left. Writes might actually work for a bit if the
* hardlimit is set higher than softlimit. Effectively the disk becomes
* made of rubber latex and begins to expand to accommodate the user :-)
/* Use softlimit to determine disk space. A user exceeding the quota
* is told that there's no space left. Writes might actually work for
* a bit if the hardlimit is set higher than softlimit. Effectively
* the disk becomes made of rubber latex and begins to expand to
* accommodate the user :-)
*/
if (D.dqb_bsoftlimit==0)
@ -731,13 +731,15 @@ bool disk_quotas(const char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB
if (D.dqb_curblocks > D.dqb_bsoftlimit) {
*dfree = 0;
*dsize = D.dqb_curblocks;
} else
} else {
*dfree = D.dqb_bsoftlimit - D.dqb_curblocks;
}
DEBUG(5,("disk_quotas for path \"%s\" returning bsize %.0f, dfree %.0f, dsize %.0f\n",
DEBUG(5,("disk_quotas for path \"%s\" returning "
"bsize %.0f, dfree %.0f, dsize %.0f\n",
path,(double)*bsize,(double)*dfree,(double)*dsize));
return(True);
return true;
}
@ -1351,14 +1353,14 @@ Hints for porting:
#include <sys/fs/vx_aioctl.h>
#include <sys/fs/vx_ioctl.h>
bool disk_quotas_vxfs(const pstring name, char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
bool disk_quotas_vxfs(const char *name, char *path, SMB_BIG_UINT *bsize, SMB_BIG_UINT *dfree, SMB_BIG_UINT *dsize)
{
uid_t user_id, euser_id;
int ret;
struct vx_dqblk D;
struct vx_quotctl quotabuf;
struct vx_genioctl genbuf;
pstring qfname;
char *qfname;
int file;
/*
@ -1367,7 +1369,10 @@ bool disk_quotas_vxfs(const pstring name, char *path, SMB_BIG_UINT *bsize, SMB_B
* it might be easier to examine and adjust it here.
* Fortunately, VxFS seems not to mind at present.
*/
pstrcpy(qfname, name) ;
qfname = talloc_strdup(talloc_tos(), name);
if (!qfname) {
return false;
}
/* pstrcat(qfname, "/quotas") ; */ /* possibly examine and adjust "name" */
euser_id = geteuid();
@ -1434,15 +1439,15 @@ bool disk_quotas_vxfs(const pstring name, char *path, SMB_BIG_UINT *bsize, SMB_B
bool disk_quotas(const char *path,SMB_BIG_UINT *bsize,SMB_BIG_UINT *dfree,SMB_BIG_UINT *dsize)
{
(*bsize) = 512; /* This value should be ignored */
(*bsize) = 512; /* This value should be ignored */
/* And just to be sure we set some values that hopefully */
/* will be larger that any possible real-world value */
(*dfree) = (SMB_BIG_UINT)-1;
(*dsize) = (SMB_BIG_UINT)-1;
/* And just to be sure we set some values that hopefully */
/* will be larger that any possible real-world value */
(*dfree) = (SMB_BIG_UINT)-1;
(*dsize) = (SMB_BIG_UINT)-1;
/* As we have select not to use quotas, allways fail */
return False;
/* As we have select not to use quotas, allways fail */
return false;
}
#endif /* WITH_QUOTAS */

64
source/smbd/utmp.c
View File

@ -207,30 +207,36 @@ static const char *ll_pathname =
* utmp{,x}: try "utmp dir", then default (a define)
* wtmp{,x}: try "wtmp dir", then "utmp dir", then default (a define)
*/
static void uw_pathname(pstring fname, const char *uw_name, const char *uw_default)
static char *uw_pathname(TALLOC_CTX *ctx,
const char *uw_name,
const char *uw_default)
{
pstring dirname;
pstrcpy(dirname, "");
char *dirname = NULL;
/* For w-files, first look for explicit "wtmp dir" */
if (uw_name[0] == 'w') {
pstrcpy(dirname,lp_wtmpdir());
dirname = talloc_strdup(ctx, lp_wtmpdir());
if (!dirname) {
return NULL;
}
trim_char(dirname,'\0','/');
}
/* For u-files and non-explicit w-dir, look for "utmp dir" */
if (dirname == 0 || strlen(dirname) == 0) {
pstrcpy(dirname,lp_utmpdir());
if (!dirname == 0 || strlen(dirname) == 0) {
dirname = talloc_strdup(ctx, lp_utmpdir());
if (!dirname) {
return NULL;
}
trim_char(dirname,'\0','/');
}
/* If explicit directory above, use it */
if (dirname != 0 && strlen(dirname) != 0) {
pstrcpy(fname, dirname);
pstrcat(fname, "/");
pstrcat(fname, uw_name);
return;
if (dirname && strlen(dirname) != 0) {
return talloc_asprintf(ctx,
"%s/%s",
dirname,
uw_name);
}
/* No explicit directory: attempt to use default paths */
@ -240,16 +246,15 @@ static void uw_pathname(pstring fname, const char *uw_name, const char *uw_defau
*/
DEBUG(2,("uw_pathname: unable to determine pathname\n"));
}
pstrcpy(fname, uw_default);
return talloc_strdup(ctx, uw_default);
}
#ifndef HAVE_PUTUTLINE
/****************************************************************************
Update utmp file directly. No subroutine interface: probably a BSD system.
****************************************************************************/
static void pututline_my(pstring uname, struct utmp *u, bool claim)
static void pututline_my(const char *uname, struct utmp *u, bool claim)
{
DEBUG(1,("pututline_my: not yet implemented\n"));
/* BSD implementor: may want to consider (or not) adjusting "lastlog" */
@ -263,7 +268,7 @@ static void pututline_my(pstring uname, struct utmp *u, bool claim)
Credit: Michail Vidiassov <master@iaas.msu.ru>
****************************************************************************/
static void updwtmp_my(pstring wname, struct utmp *u, bool claim)
static void updwtmp_my(const char *wname, struct utmp *u, bool claim)
{
int fd;
struct stat buf;
@ -308,12 +313,16 @@ static void updwtmp_my(pstring wname, struct utmp *u, bool claim)
static void utmp_nox_update(struct utmp *u, bool claim)
{
pstring uname, wname;
char *uname = NULL;
char *wname = NULL;
#if defined(PUTUTLINE_RETURNS_UTMP)
struct utmp *urc;
#endif /* PUTUTLINE_RETURNS_UTMP */
uw_pathname(uname, "utmp", ut_pathname);
uname = uw_pathname(talloc_tos(), "utmp", ut_pathname);
if (!uname) {
return;
}
DEBUG(2,("utmp_nox_update: uname:%s\n", uname));
#ifdef HAVE_PUTUTLINE
@ -341,7 +350,10 @@ static void utmp_nox_update(struct utmp *u, bool claim)
}
#endif /* HAVE_PUTUTLINE */
uw_pathname(wname, "wtmp", wt_pathname);
wname = uw_pathname(talloc_tos(), "wtmp", wt_pathname);
if (!wname) {
return;
}
DEBUG(2,("utmp_nox_update: wname:%s\n", wname));
if (strlen(wname) != 0) {
#ifdef HAVE_UPDWTMP
@ -398,7 +410,8 @@ static void sys_utmp_update(struct utmp *u, const char *hostname, bool claim)
DEBUG(1,("utmp_update: have utmpx.h but no getutmpx() function\n"));
utmp_nox_update(u, claim);
#else
pstring uname, wname;
char *uname = NULL;
char *wname = NULL;
struct utmpx ux, *uxrc;
getutmpx(u, &ux);
@ -413,9 +426,12 @@ static void sys_utmp_update(struct utmp *u, const char *hostname, bool claim)
utmp_strcpy(ux.ut_host, hostname, sizeof(ux.ut_host));
#endif
uw_pathname(uname, "utmpx", ux_pathname);
uw_pathname(wname, "wtmpx", wx_pathname);
DEBUG(2,("utmp_update: uname:%s wname:%s\n", uname, wname));
uname = uw_pathname(talloc_tos(), "utmpx", ux_pathname);
wname = uw_pathname(talloc_tos(), "wtmpx", wx_pathname);
if (uname && wname) {
DEBUG(2,("utmp_update: uname:%s wname:%s\n", uname, wname));
}
/*
* Check for either uname or wname being empty.
* Some systems, such as Redhat 6, have a "utmpx.h" which doesn't
@ -423,7 +439,7 @@ static void sys_utmp_update(struct utmp *u, const char *hostname, bool claim)
* Also, our local installation has not provided an override.
* Drop to non-x method. (E.g. RH6 has good defaults in "utmp.h".)
*/
if ((strlen(uname) == 0) || (strlen(wname) == 0)) {
if (!uname || !wname || (strlen(uname) == 0) || (strlen(wname) == 0)) {
utmp_nox_update(u, claim);
} else {
utmpxname(uname);