//hash的初始化
int
load_ucache()
{
int i;
int lockfd;
lockfd = lock_passwd();
bzero(binfo->ucachehashshm, sizeof (struct UCACHEHASH));
if (ucache_hashinit() < 0) {
unlock_passwd(lockfd);
return -1;
}
for (i = 0; i < MAXUSERS; i++) {
if (passwdptr[i].userid[0]
&& finduseridhash(passwdptr[i].userid) > 0) {
unlock_passwd(lockfd);
errlog("duplicate user %s", passwdptr[i].userid);
return -1;
}
insertuseridhash(passwdptr[i].userid, i + 1, 0);
}
unlock_passwd(lockfd);
return 0;
}
int
create_account(char *username)
{
struct passwd *pw;
int opt, type;
char pwbuf[PWLEN + 1];
int ret;
type = 0;
if ((pw=newacc(username)) == 0) {
fprintf(stderr, "Account not created\n");
return EXIT_FAILURE;
}
initdir(pw->pw_dir, pw->pw_uid, pw->pw_gid);
if ((ret = get_passwd(pwbuf, type)) == -1)
return EXIT_FAILURE;
pw->pw_passwd = ret ? passwd_stub : nil_passwd;
if (!lock_passwd()) {
fprintf(stderr,"unable to lock password database (%s)\n",strerror(errno));
return PasswdBusy;
}
if ((opt = addpwent(pw)) == 0) {
if (pw->pw_passwd && *pw->pw_passwd) {
struct spwd spw;
spw.sp_namp = pw->pw_name;
spw.sp_pwdp = pwbuf;
spw.sp_lstchg = time(0);
spw.sp_max = 0;
spw.sp_min = 0;
spw.sp_warn = 0;
spw.sp_inact = 0;
spw.sp_expire = 0;
spw.sp_flag = 0;
if ((opt = addshent(&spw))) {
fputs("cannot create shadow entry\n",stderr);
delpw_name(pw->pw_name);
}
}
} else {
fputs("cannot create password entry\n", stderr);
}
unlock_passwd();
return opt;
}
main (int ac, char *av[]) {
FILE *temp;
char lock[20];
strcpy(lock,av[1]);
strcat(lock,".LCK");
if (ac == 3) {
int delay,done;
delay = 0;
done = 0;
while (delay<=3 && done==0) {
puts("here");
if (lock_passwd(av[1],lock)==0) {
temp=fopen(av[1],"a");
fputs(strcat(av[2],"\n"),temp);
fclose(temp);
// int temp = open(av[1],O_APPEND);
//fprintf(temp,"%s",av[2]);
//close(temp);
done++;
sleep(2);
unlock_passwd(lock);
} else {
delay++;
sleep(1);
}
}
if (done!=0) {
oops("delay time","");
}
} else {
oops("Too many arguments","");
}
}
int change_passwd(struct passwd * pw) {
struct spwd *sp = NULL;
struct spwd spw;
char pwbuf[PWLEN];
int opt, ret;
printf("changing password for %s\n", pw->pw_name);
if (pw->pw_passwd && *pw->pw_passwd) sp=getspnam(pw->pw_name);
ret = 0;
if (getuid() != 0) {
if ((ret = chk_passwd(pw, sp)) == -1) {
fputs("Sorry!\n",stderr);
return EXIT_FAILURE;
}
}
if (get_passwd(pwbuf, ret) == -1)
return EXIT_FAILURE;
if (!lock_passwd()) {
fprintf(stderr,"unable to lock password database (%s)\n",strerror(errno));
return PasswdBusy;
}
/*-
* there are 4 normal cases covered here:
* 1: user did not previously have a password and now does.
* 2: user did not previously have a password and still doesn't.
* 3: user previously had a password and now doesn't.
* 4: user previously had a password and still does.
*
* plus the additional user should have had a password but
* there was none in /etc/shadow!
*
* #1 -- update password & shadow files.
* #2 -- do nothing.
* #3 -- update password & shadow files.
* #4 -- update shadow only.
* in #1, the shadow file must be updated first for consistency.
* in #3, the password file must be updated first for consistency.
*/
opt = Success;
if (*pwbuf) { /* user put a password in */
if (!sp) {
spw.sp_namp = pw->pw_name;
spw.sp_pwdp = pwbuf;
spw.sp_lstchg = time(0);
spw.sp_max = 0;
spw.sp_min = 0;
spw.sp_warn = 0;
spw.sp_inact = 0;
spw.sp_expire = 0;
spw.sp_flag = 0;
sp = &spw;
} else {
sp->sp_pwdp = pwbuf;
sp->sp_lstchg = time(0);
}
if (!(pw->pw_passwd && *pw->pw_passwd)) {
if ((opt=addshent(&spw)) != Success) {
unlock_passwd();
return opt;
}
pw->pw_passwd = passwd_stub;
opt = chgpw_name(pw->pw_name,pw);
} else {
sp->sp_pwdp = pwbuf;
opt = addshent(sp);
}
} else if (pw->pw_passwd && *pw->pw_passwd) {
if ((opt=delsh_name(pw->pw_name)) != Success) {
fputs("Warning: password,shadow files may be inconsistant\n",stderr);
// unlock_passwd();
// return opt;
}
pw->pw_passwd = nil_passwd;
opt=chgpw_name(pw->pw_name,pw);
}
unlock_passwd();
return opt;
}
