int main(int argc, char **argv)
{
addr_t addr;
double timeout = 5.0;
int sock;
if (argc < 2) {
printf("Usage: connect host:port [timeout_in_seconds]\n");
return 1;
}
if (argc > 2) {
timeout = atof(argv[2]);
if (timeout <= 0) {
timeout = 5.0;
printf("Warning: using timeout %gs\n", timeout);
}
}
printf("Resolving...\n");
if (init_addr(&addr, argv[1]) != 0)
perror_fatal("init_addr(%s)", argv[1]);
sock = socket(addr.name.sa_family, SOCK_STREAM, 0);
if (sock == -1)
perror_fatal("socket");
printf("Connecting...\n");
if (nonblock_connect(sock, &addr.name, addr.namelen, timeout * 1000) == -1)
perror_fatal("connect(%s)", addr.a_addr);
else
printf("Success!\n");
return 0;
}
/* close stdin/stdout/stderr file descriptors */
void close_stdx()
{
int fd;
if ((fd = open("/dev/null", O_RDWR, 0)) != -1) {
if(dup2(fd, STDIN_FILENO) < 0) perror_fatal("dup2 stdin");
if(dup2(fd, STDOUT_FILENO) < 0) perror_fatal("dup2 stdout");
if(dup2(fd, STDERR_FILENO) < 0) perror_fatal("dup2 stderr");
if (fd > STDERR_FILENO && close(fd) < 0) perror_fatal("close");
} else {
perror_fatal("open(\"/dev/null\")");
}
}
static void
daemonize(int do_daemonize, const char *pidfile, const char *run_as)
{
int fd;
/* Daemonize part 1 */
if (do_daemonize) {
switch (fork()) {
case -1:
perror("fork");
exit(1);
case 0:
break;
default:
exit(EXIT_SUCCESS);
}
if (setsid() == -1) perror_fatal("setsid");
}
/* Change effective uid/gid if requested */
if (run_as) {
struct passwd *pw = getpwnam(run_as);
if (!pw) {
fprintf(stderr, "No such user: \"%s\"\n", run_as);
exit(EXIT_FAILURE);
}
if (setgid(pw->pw_gid) < 0 || setuid(pw->pw_uid) < 0) {
fprintf(stderr, "Can't switch to user \"%s\": %s\n", run_as, strerror(errno));
exit(EXIT_FAILURE);
}
}
/* Save PID file if requested */
if (pidfile) {
FILE *fpid = fopen(pidfile, "w");
if (!fpid) perror_fatal("Can't create pid file");
fprintf(fpid, "%ld", (long)getpid());
fclose(fpid);
}
/* Daemonize part 2 */
if (do_daemonize) {
if(chdir("/") != 0) perror_fatal("chdir");
if ((fd = open("/dev/null", O_RDWR, 0)) != -1) {
if(dup2(fd, STDIN_FILENO) < 0) perror_fatal("dup2 stdin");
if(dup2(fd, STDOUT_FILENO) < 0) perror_fatal("dup2 stdout");
if(dup2(fd, STDERR_FILENO) < 0) perror_fatal("dup2 stderr");
if (fd > STDERR_FILENO && close(fd) < 0) perror_fatal("close");
} else {
perror_fatal("open(\"/dev/null\")");
}
}
}
static void
listen_sock(int mc_sock, addr_t *mc_addr) {
{
// set sock option
int flag = 1;
setsockopt(mc_sock, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag));
long fl = fcntl(mc_sock, F_GETFL);
if (fl == -1) perror_fatal("can't get fcntl sock option");
set_nonblock(mc_sock,1);
}
if ( bind(mc_sock, &mc_addr->name, mc_addr->namelen) < 0) perror_fatal("bind");
if (listen(mc_sock, 10) < 0) perror_fatal("publisher listen");
}
static void
set_rlimit() {
struct rlimit r;
if (max_clients) {
r.rlim_cur = r.rlim_max = max_clients;
if (setrlimit(RLIMIT_NOFILE, &r) == -1) {
perror_fatal("setrlimit");
}
} else {
if (getrlimit(RLIMIT_NOFILE, &r) == -1) {
perror_fatal("getrlimit");
}
max_clients = r.rlim_cur;
}
}
static size_t
ck_fread (char *buf, size_t size, FILE *f)
{
size_t r = fread (buf, sizeof (char), size, f);
if (r == 0 && ferror (f))
perror_fatal (_("read failed"));
return r;
}
static FILE *
ck_fopen (char const *fname, char const *type)
{
FILE *r = fopen (fname, type);
if (! r)
perror_fatal (fname);
return r;
}
static void
check_stdout (void)
{
if (ferror (stdout))
fatal ("write failed");
else if (fclose (stdout) != 0)
perror_fatal (_("standard output"));
}
static void
flush_line (void)
{
int c;
while ((c = getchar ()) != '\n' && c != EOF)
continue;
if (ferror (stdin))
perror_fatal (_("read failed"));
}
int connect_to(const char *host, int port)
{
addr_t a;
char buf[64];
int s;
sprintf(buf, "%s:%d", host, port);
if (init_addr(&a, buf) != 0)
perror_fatal("connect %s:%u", host, port);
free(a.a_addr);
s = socket(a.name.sa_family, SOCK_STREAM, 0);
if (s == -1)
perror_fatal("socket");
if (nonblock_connect(s, &a.name, a.namelen, 1000) != 0)
perror_fatal("connect(%s:%d)", host, port);
return s;
}
static int
skip_white (void)
{
int c;
for (;;)
{
c = getchar ();
if (! isspace (c) || c == '\n')
break;
checksigs ();
}
if (ferror (stdin))
perror_fatal (_("read failed"));
return c;
}
int main(int argc, char **argv){
int mc_sock;
addr_t mc_addr;
ev_io mc_io;
sophiadb_t * db;
int c;
while (1) {
int option_index = 0;
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'V'},
{"max-clients", required_argument, 0, 'l'},
{0, 0, 0, 0}
};
c = getopt_long(argc, argv, "n:Vc:t", long_options, &option_index);
if (c == -1)
break;
switch (c) {
case 'c':
confilename = optarg;
break;
case 'n':
max_clients = atoi(optarg);
break;
case 'V':
printf("Version %s\n", MYMC_VERSION);
exit(0);
case 't':
is_trace = 1;
break; default:
usage(argv[0], c == 'h' ? EXIT_SUCCESS : EXIT_FAILURE);
}
}
if (confilename)
parse(confilename, &server_ctx);
else
parse( CONFIGFILE, &server_ctx);
//assert(server_ctx.logfile);
//assert(server_ctx.listen);
if (!server_ctx.listen) {
perror("undefined listen port");
exit(1);
}
flog = server_ctx.logfile ? fopen(server_ctx.logfile, "a+") : fopen("error.log", "a+");
if (flog) {
time_t lt;
lt = time(NULL);
fprintf(flog, "server started at %s\n",ctime(<));
} else {
perror("can not create log file");
exit(1);
}
daemonize(server_ctx.is_demonize, server_ctx.pidfile, server_ctx.username);
set_rlimit();
ignore_sigpipe();
init_addr(&mc_addr, server_ctx.listen);
mc_sock = socket(mc_addr.pf_family, SOCK_STREAM, 0);
if (mc_sock < 0) {
perror("can't create socket");
exit(1);
}
listen_sock(mc_sock, &mc_addr);
//TODO
if (is_trace)
printf("pid=%ld\n\n", (long)getpid());
clients = calloc(max_clients, sizeof(fd_ctx));
if (!clients) {
perror_fatal("Cannot allocate array for client descriptors!");
}
int i=0;
while(i < max_clients) {
if(clients[i].mc)
printf("init err %i\n", i);
i++;
}
db = db_init(&server_ctx);
assert(db);
struct ev_loop *loop = ev_default_loop(0);
assert(loop);
ev_set_userdata(loop,(void*)db);
ev_io_init( &mc_io, memcached_on_connect, mc_sock, EV_READ);
ev_io_start(loop, &mc_io);
struct ev_timer timeout_watcher;
ev_init(&timeout_watcher, periodic_watcher);
timeout_watcher.repeat = TIME_CHECK_INTERVAL;
ev_timer_again(loop, &timeout_watcher);
struct ev_signal signal_watcher,signal_watcher2;
// ev_signal_init (&signal_watcher, sigint_cb, SIGINT);
// ev_signal_start (loop, &signal_watcher);
ev_signal_init (&signal_watcher, sigint_cb, SIGTERM);
ev_signal_start (loop, &signal_watcher);
ev_signal_init (&signal_watcher2, sighup_cb, SIGHUP);
ev_signal_start (loop, &signal_watcher2);
//start server
time(&stats.uptime);
gettimeofday(&t_start, NULL);
// event loop
ev_loop(loop, 0);
cllear_mc_all();
close(mc_sock);
if (clients)
free(clients);
//ev_loop_destroy(loop);
destroy(db);
if (mc_addr.a_addr) free(mc_addr.a_addr);
if (server_ctx.pidfile) {
if( unlink(server_ctx.pidfile))
printf("cannot delete pid file %s %s\n",server_ctx.pidfile, strerror(errno));
}
free_config();
if (flog) {
time_t lt;
lt = time(NULL);
fprintf(flog, "server finis Ok at %s\n",ctime(<));
fclose(flog);
}
return 0;
}
int
main (int argc, char *argv[])
{
int opt;
char const *prog;
exit_failure = EXIT_TROUBLE;
initialize_main (&argc, &argv);
program_name = argv[0];
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALEDIR);
textdomain (PACKAGE);
c_stack_action (cleanup);
prog = getenv ("EDITOR");
if (prog)
editor_program = prog;
diffarg (DEFAULT_DIFF_PROGRAM);
/* parse command line args */
while ((opt = getopt_long (argc, argv, "abBdEHiI:lo:stvw:W", longopts, 0))
!= -1)
{
switch (opt)
{
case 'a':
diffarg ("-a");
break;
case 'b':
diffarg ("-b");
break;
case 'B':
diffarg ("-B");
break;
case 'd':
diffarg ("-d");
break;
case 'E':
diffarg ("-E");
break;
case 'H':
diffarg ("-H");
break;
case 'i':
diffarg ("-i");
break;
case 'I':
diffarg ("-I");
diffarg (optarg);
break;
case 'l':
diffarg ("--left-column");
break;
case 'o':
output = optarg;
break;
case 's':
suppress_common_lines = true;
break;
case 't':
diffarg ("-t");
break;
case 'v':
version_etc (stdout, "sdiff", PACKAGE_NAME, PACKAGE_VERSION,
"Thomas Lord", (char *) 0);
check_stdout ();
return EXIT_SUCCESS;
case 'w':
diffarg ("-W");
diffarg (optarg);
break;
case 'W':
diffarg ("-w");
break;
case DIFF_PROGRAM_OPTION:
diffargv[0] = optarg;
break;
case HELP_OPTION:
usage ();
check_stdout ();
return EXIT_SUCCESS;
case STRIP_TRAILING_CR_OPTION:
diffarg ("--strip-trailing-cr");
break;
case TABSIZE_OPTION:
diffarg ("--tabsize");
diffarg (optarg);
break;
default:
try_help (0, 0);
}
}
if (argc - optind != 2)
{
if (argc - optind < 2)
try_help ("missing operand after `%s'", argv[argc - 1]);
else
try_help ("extra operand `%s'", argv[optind + 2]);
}
if (! output)
{
/* easy case: diff does everything for us */
if (suppress_common_lines)
diffarg ("--suppress-common-lines");
diffarg ("-y");
diffarg ("--");
diffarg (argv[optind]);
diffarg (argv[optind + 1]);
diffarg (0);
execvp (diffargv[0], (char **) diffargv);
perror_fatal (diffargv[0]);
}
else
{
char const *lname, *rname;
FILE *left, *right, *out, *diffout;
bool interact_ok;
struct line_filter lfilt;
struct line_filter rfilt;
struct line_filter diff_filt;
bool leftdir = diraccess (argv[optind]);
bool rightdir = diraccess (argv[optind + 1]);
if (leftdir & rightdir)
fatal ("both files to be compared are directories");
lname = expand_name (argv[optind], leftdir, argv[optind + 1]);
left = ck_fopen (lname, "r");
rname = expand_name (argv[optind + 1], rightdir, argv[optind]);
right = ck_fopen (rname, "r");
out = ck_fopen (output, "w");
diffarg ("--sdiff-merge-assist");
diffarg ("--");
diffarg (argv[optind]);
diffarg (argv[optind + 1]);
diffarg (0);
trapsigs ();
#if ! (HAVE_WORKING_FORK || HAVE_WORKING_VFORK)
{
size_t cmdsize = 1;
char *p, *command;
int i;
for (i = 0; diffargv[i]; i++)
cmdsize += quote_system_arg (0, diffargv[i]) + 1;
command = p = xmalloc (cmdsize);
for (i = 0; diffargv[i]; i++)
{
p += quote_system_arg (p, diffargv[i]);
*p++ = ' ';
}
p[-1] = 0;
errno = 0;
diffout = popen (command, "r");
if (! diffout)
perror_fatal (command);
free (command);
}
#else
{
int diff_fds[2];
# if HAVE_WORKING_VFORK
sigset_t procmask;
sigset_t blocked;
# endif
if (pipe (diff_fds) != 0)
perror_fatal ("pipe");
# if HAVE_WORKING_VFORK
/* Block SIGINT and SIGPIPE. */
sigemptyset (&blocked);
sigaddset (&blocked, SIGINT);
sigaddset (&blocked, SIGPIPE);
sigprocmask (SIG_BLOCK, &blocked, &procmask);
# endif
diffpid = vfork ();
if (diffpid < 0)
perror_fatal ("fork");
if (! diffpid)
{
/* Alter the child's SIGINT and SIGPIPE handlers;
this may munge the parent.
The child ignores SIGINT in case the user interrupts the editor.
The child does not ignore SIGPIPE, even if the parent does. */
if (initial_handler (handler_index_of_SIGINT) != SIG_IGN)
signal_handler (SIGINT, SIG_IGN);
signal_handler (SIGPIPE, SIG_DFL);
# if HAVE_WORKING_VFORK
/* Stop blocking SIGINT and SIGPIPE in the child. */
sigprocmask (SIG_SETMASK, &procmask, 0);
# endif
close (diff_fds[0]);
if (diff_fds[1] != STDOUT_FILENO)
{
dup2 (diff_fds[1], STDOUT_FILENO);
close (diff_fds[1]);
}
execvp (diffargv[0], (char **) diffargv);
_exit (errno == ENOENT ? 127 : 126);
}
# if HAVE_WORKING_VFORK
/* Restore the parent's SIGINT and SIGPIPE behavior. */
if (initial_handler (handler_index_of_SIGINT) != SIG_IGN)
signal_handler (SIGINT, catchsig);
if (initial_handler (handler_index_of_SIGPIPE) != SIG_IGN)
signal_handler (SIGPIPE, catchsig);
else
signal_handler (SIGPIPE, SIG_IGN);
/* Stop blocking SIGINT and SIGPIPE in the parent. */
sigprocmask (SIG_SETMASK, &procmask, 0);
# endif
close (diff_fds[1]);
diffout = fdopen (diff_fds[0], "r");
if (! diffout)
perror_fatal ("fdopen");
}
#endif
lf_init (&diff_filt, diffout);
lf_init (&lfilt, left);
lf_init (&rfilt, right);
interact_ok = interact (&diff_filt, &lfilt, lname, &rfilt, rname, out);
ck_fclose (left);
ck_fclose (right);
ck_fclose (out);
{
int wstatus;
int werrno = 0;
#if ! (HAVE_WORKING_FORK || HAVE_WORKING_VFORK)
wstatus = pclose (diffout);
if (wstatus == -1)
werrno = errno;
#else
ck_fclose (diffout);
while (waitpid (diffpid, &wstatus, 0) < 0)
if (errno == EINTR)
checksigs ();
else
perror_fatal ("waitpid");
diffpid = 0;
#endif
if (tmpname)
{
unlink (tmpname);
tmpname = 0;
}
if (! interact_ok)
exiterr ();
check_child_status (werrno, wstatus, EXIT_FAILURE, diffargv[0]);
untrapsig (0);
checksigs ();
exit (WEXITSTATUS (wstatus));
}
}
return EXIT_SUCCESS; /* Fool `-Wall'. */
}
static void
ck_fflush (FILE *f)
{
if (fflush (f) != 0)
perror_fatal (_("write failed"));
}
static void
ck_fwrite (char const *buf, size_t size, FILE *f)
{
if (fwrite (buf, sizeof (char), size, f) != size)
perror_fatal (_("write failed"));
}
void daemonize(int do_daemonize, const char *pidfile, const char *run_as)
{
/* Daemonize part 1 */
if (do_daemonize) {
switch (fork()) {
case -1:
perror_fatal("fork");
case 0:
break;
default:
exit(EXIT_SUCCESS);
}
if (setsid() == -1) perror_fatal("setsid");
}
/* Save PID file if requested */
if (pidfile) {
FILE *fpid = fopen(pidfile, "w");
if (!fpid) perror_fatal("Can't create pid file");
fprintf(fpid, "%ld", (long)getpid());
fclose(fpid);
}
/* Change effective uid/gid if requested */
if (run_as) {
gid_t gid, uid;
const char *p = strchr(run_as, ':');
if (p && p - run_as < 30) {
char name[32];
struct passwd *pw;
struct group *gw;
memcpy(name, run_as, p - run_as);
name[p - run_as] = 0;
pw = getpwnam(name);
if (!pw) {
fprintf(stderr, "No such user: \"%s\"\n", name);
exit(EXIT_FAILURE);
}
uid = pw->pw_uid;
strncpy(name, p + 1, sizeof(name));
gw = getgrnam(name);
if (!gw) {
fprintf(stderr, "No such group: \"%s\"\n", name);
exit(EXIT_FAILURE);
}
gid = gw->gr_gid;
} else {
struct passwd *pw = getpwnam(run_as);
if (!pw) {
fprintf(stderr, "No such user: \"%s\"\n", run_as);
exit(EXIT_FAILURE);
}
gid = pw->pw_gid;
uid = pw->pw_uid;
}
if (setregid(gid, gid) < 0 || setreuid(uid, uid) < 0) {
fprintf(stderr, "Can't run as user \"%s\": %s\n", run_as, strerror(errno));
exit(EXIT_FAILURE);
}
/* Now we need to allow process to make core dumps */
prctl(PR_SET_DUMPABLE, 1, 0, 0, 0);
}
/* Daemonize part 2 */
if (do_daemonize) {
if(chdir("/") != 0) perror_fatal("chdir");
}
}
static void
ck_fclose (FILE *f)
{
if (fclose (f))
perror_fatal ("fclose");
}
/* interpret an edit command */
static bool
edit (struct line_filter *left, char const *lname, lin lline, lin llen,
struct line_filter *right, char const *rname, lin rline, lin rlen,
FILE *outfile)
{
for (;;)
{
int cmd0, cmd1;
bool gotcmd = false;
cmd1 = 0; /* Pacify `gcc -W'. */
while (! gotcmd)
{
if (putchar ('%') != '%')
perror_fatal (_("write failed"));
ck_fflush (stdout);
cmd0 = skip_white ();
switch (cmd0)
{
case '1': case '2': case 'l': case 'r':
case 's': case 'v': case 'q':
if (skip_white () != '\n')
{
give_help ();
flush_line ();
continue;
}
gotcmd = true;
break;
case 'e':
cmd1 = skip_white ();
switch (cmd1)
{
case '1': case '2': case 'b': case 'd': case 'l': case 'r':
if (skip_white () != '\n')
{
give_help ();
flush_line ();
continue;
}
gotcmd = true;
break;
case '\n':
gotcmd = true;
break;
default:
give_help ();
flush_line ();
continue;
}
break;
case EOF:
if (feof (stdin))
{
gotcmd = true;
cmd0 = 'q';
break;
}
/* Fall through. */
default:
flush_line ();
/* Fall through. */
case '\n':
give_help ();
continue;
}
}
switch (cmd0)
{
case '1': case 'l':
lf_copy (left, llen, outfile);
lf_skip (right, rlen);
return true;
case '2': case 'r':
lf_copy (right, rlen, outfile);
lf_skip (left, llen);
return true;
case 's':
suppress_common_lines = true;
break;
case 'v':
suppress_common_lines = false;
break;
case 'q':
return false;
case 'e':
{
int fd;
if (tmpname)
tmp = fopen (tmpname, "w");
else
{
if ((fd = temporary_file ()) < 0)
perror_fatal ("mkstemp");
tmp = fdopen (fd, "w");
}
if (! tmp)
perror_fatal (tmpname);
switch (cmd1)
{
case 'd':
if (llen)
{
if (llen == 1)
fprintf (tmp, "--- %s %ld\n", lname, (long int) lline);
else
fprintf (tmp, "--- %s %ld,%ld\n", lname,
(long int) lline,
(long int) (lline + llen - 1));
}
/* Fall through. */
case '1': case 'b': case 'l':
lf_copy (left, llen, tmp);
break;
default:
lf_skip (left, llen);
break;
}
switch (cmd1)
{
case 'd':
if (rlen)
{
if (rlen == 1)
fprintf (tmp, "+++ %s %ld\n", rname, (long int) rline);
else
fprintf (tmp, "+++ %s %ld,%ld\n", rname,
(long int) rline,
(long int) (rline + rlen - 1));
}
/* Fall through. */
case '2': case 'b': case 'r':
lf_copy (right, rlen, tmp);
break;
default:
lf_skip (right, rlen);
break;
}
ck_fclose (tmp);
{
int wstatus;
int werrno = 0;
ignore_SIGINT = true;
checksigs ();
{
#if ! (HAVE_WORKING_FORK || HAVE_WORKING_VFORK)
char *command =
xmalloc (quote_system_arg (0, editor_program)
+ 1 + strlen (tmpname) + 1);
sprintf (command + quote_system_arg (command, editor_program),
" %s", tmpname);
wstatus = system (command);
if (wstatus == -1)
werrno = errno;
free (command);
#else
pid_t pid;
pid = vfork ();
if (pid == 0)
{
char const *argv[3];
int i = 0;
argv[i++] = editor_program;
argv[i++] = tmpname;
argv[i] = 0;
execvp (editor_program, (char **) argv);
_exit (errno == ENOENT ? 127 : 126);
}
if (pid < 0)
perror_fatal ("fork");
while (waitpid (pid, &wstatus, 0) < 0)
if (errno == EINTR)
checksigs ();
else
perror_fatal ("waitpid");
#endif
}
ignore_SIGINT = false;
check_child_status (werrno, wstatus, EXIT_SUCCESS,
editor_program);
}
{
char buf[SDIFF_BUFSIZE];
size_t size;
tmp = ck_fopen (tmpname, "r");
while ((size = ck_fread (buf, SDIFF_BUFSIZE, tmp)) != 0)
{
checksigs ();
ck_fwrite (buf, size, outfile);
}
ck_fclose (tmp);
}
return true;
}
default:
give_help ();
break;
}
}
}
int pam_authenticate_session(char** username, int fd)
{
int rv;
if ((rv = pam_start(PAM_APPL_NAME, *username, &conv, &pam_h)) != PAM_SUCCESS)
fatal("pam_start() failure: %d", rv);
#ifdef SUN_PAM_TTY_BUG
if ((rv = pam_set_item(pam_h, PAM_TTY, "/dev/nld")) != PAM_SUCCESS)
fatal("pam_set_item(PAM_TTY,/dev/nld");
#endif
pam_conv_fd = fd;
if ((rv = pam_authenticate(pam_h, 0)) != PAM_SUCCESS) {
debug("pam_authenticate(): %s", pam_strerror(pam_h, rv));
pam_conv_fd = -1;
return -1;
}
rv = pam_acct_mgmt(pam_h, 0);
char* pam_user = 0;
if ((rv = pam_get_item(pam_h, PAM_USER, (PAM_CONST void**)&pam_user)) !=
PAM_SUCCESS)
{
pam_user = 0;
debug("pam_get_item(PAM_USER): %s", pam_strerror(pam_h, rv));
} else if (!(pam_user = strdup(pam_user))) fatal("malloc()");
else {
free(*username);
*username = pam_user;
}
if (rv == PAM_NEW_AUTHTOK_REQD) {
debug("pam_acct_mgmt(): PAM_NEW_AUTHTOK_REQD for %s", *username);
#if CHAUTHTOK_CHECKS_RUID
struct passwd pw, *pwp;
char pw_buf[1024];
rv = getpwnam_r(*username, &pw, pw_buf, sizeof(pw_buf), &pwp);
if (!pwp) {
if (rv) {
errno = rv;
perror("Fetching user for pam_chauthtok failed. getpwnam_r()");
} else debug("Fetching user for pam_chauthtok failed: not found");
pam_conv_fd = -1;
return -1;
}
if (setreuid(pw.pw_uid,-1) < 0)
perror_fatal("setreuid() for pam_chauthtok failed");
#endif
rv = pam_chauthtok(pam_h, PAM_CHANGE_EXPIRED_AUTHTOK);
#if CHAUTHTOK_CHECKS_RUID
if (setreuid(0,-1) < 0)
perror_fatal("setreuid() after pam_chauthtok failed");
#endif
if (rv != PAM_SUCCESS) {
debug("pam_chauthtok(PAM_CHANGE_EXPIRED_AUTHTOK): %s",
pam_strerror(pam_h, rv));
pam_conv_fd = -1;
return -1;
}
} else if (rv != PAM_SUCCESS) {
debug("pam_acct_mgmt(): %s", pam_strerror(pam_h, rv));
pam_conv_fd = -1;
return -1;
}
pam_conv_fd = -1;
authenticated = 1;
return 0;
}