/* handlers.c -- execute handlers specified in handlers configuration file

   Copyright (c) 2005 Red Hat, Inc.

   Written by Tomas Mraz <tmraz@redhat.com>

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 2, or (at your option)

   any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software Foundation,

   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#include "config.h"

#include <errno.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <unistd.h>

#include <signal.h>

#include <sys/wait.h>

#include <sys/types.h>

#include <pwd.h>

#include <syslog.h>

#include "handlers.h"

#include "pam_console.h"

enum types { UNKNOWN, LOCK, UNLOCK, CONSOLEDEVS };

enum flags { HF_LOGFAIL, HF_WAIT, HF_SETUID, HF_TTY, HF_USER, HF_PARAM };

struct console_handler {

        char *executable;

        enum types type;

        char *flags; /* this is a double zero terminated array 

                        allocated in one blob with executable */

        struct console_handler *next;

};

static struct console_handler *first_handler;

static void 

console_free_handlers (struct console_handler *handler) {

        if (handler != NULL) {

                console_free_handlers(handler->next);

                free(handler->executable);                

                free(handler);

        }

}

int

console_parse_handlers (pam_handle_t *pamh, const char *handlers_name) {

        FILE *fh;

        char linebuf[HANDLERS_MAXLINELEN+1];

        int forget;

        int skip = 0;

        int rv = PAM_SESSION_ERR;

        struct console_handler **previous_handler_ptr;

        fh = fopen(handlers_name, "r");

        if (fh == NULL) {

                _pam_log(pamh, LOG_ERR, FALSE, "cannot open file %s for reading", handlers_name);

                return rv;

        }

        previous_handler_ptr = &first_handler;

        while (fgets(linebuf, sizeof(linebuf), fh) != NULL)

        {

                int len;

                char *ptr;

                char *tokptr;

                char *temp;

                char *destptr = NULL; /* needed to silence warning */

                struct console_handler *handler;

                enum states { EXECUTABLE, TYPE, FLAGS } state;

                len = strlen(linebuf);

                if (linebuf[len-1] != '\n') {

                        _pam_log(pamh, LOG_INFO, FALSE, "line too long or not ending with new line char - will be ignored");

                        skip = 1;

                        continue;

                }

                if (skip) {

                        skip = 0;

                        continue;

                }

                linebuf[len-1] = '\0';

                if ((ptr=strchr(linebuf, '#')) != NULL) {

                        *ptr = '\0';

                }

                for (ptr = linebuf; isspace(*ptr); ptr++);

                if (*ptr == '\0')

                        continue;

                /* something on the line */

                if ((handler=calloc(sizeof(*handler), 1)) == NULL)

                        goto fail_exit;

                *previous_handler_ptr = handler;

                previous_handler_ptr = &handler->next;

                if ((handler->executable=malloc(len-(ptr-linebuf)+1)) == NULL) {

                        goto fail_exit;

                }

                state = EXECUTABLE;

                handler->type = UNKNOWN;

                while ((tokptr=strtok_r(ptr, " \t", &temp)) != NULL) {

                        if (state == EXECUTABLE) {

                                strcpy(handler->executable, tokptr);

                                ptr = NULL;

                                handler->flags = destptr = handler->executable + strlen(handler->executable) + 1;

                        }

                        else if (state == TYPE) {

                                if (strcmp(tokptr, "lock") == 0) {

                                        handler->type = LOCK;

                                } 

                                else if (strcmp(tokptr, "unlock") == 0) {

                                        handler->type = UNLOCK;

                                }

                                else if (strcmp(tokptr, "consoledevs") == 0) {

                                        handler->type = CONSOLEDEVS;

                                }

                        }

                        if (state == FLAGS) {

                                strcpy(destptr, tokptr);

                                destptr += strlen(destptr) + 1;

                        }

                        else {

                                state++;

                        }

                }

                *destptr = '\0';                

        }

        forget = fclose(fh);

        return PAM_SUCCESS;        

fail_exit:

        console_free_handlers(first_handler);

        return rv;

}

static enum flags testflag(const char *flag) {

        if (strcmp(flag, "logfail") == 0) {

                return HF_LOGFAIL;

        }

        if (strcmp(flag, "wait") == 0) {

                return HF_WAIT;

        }

        if (strcmp(flag, "setuid") == 0) {

                return HF_SETUID;

        }

        if (strcmp(flag, "tty") == 0) {

                return HF_TTY;

        }

        if (strcmp(flag, "user") == 0) {

                return HF_USER;

        }

        return HF_PARAM;

}

static void

call_exec(struct console_handler *handler, int nparams, const char *user, const char *tty) {

        const char *flagptr;

        const char **argv;

        int i = 0;

        argv = malloc(sizeof(*argv)*(nparams+2));

        if (argv == NULL)

                return;

        argv[i++] = handler->executable;

        for (flagptr = handler->flags; *flagptr != '\0'; flagptr += strlen(flagptr)+1) {

                switch (testflag(flagptr)) {

                case HF_LOGFAIL:

                case HF_WAIT:

                case HF_SETUID:

                        break;

                case HF_TTY:

                        argv[i++] = tty;

                        break;

                case HF_USER:

                        argv[i++] = user;

			break;

                case HF_PARAM:

                        argv[i++] = flagptr;

                }

        }

        argv[i] = NULL;

        execvp(handler->executable, (char * const *)argv);

}

static int

execute_handler(pam_handle_t *pamh, struct console_handler *handler, const char *user, const char *tty) {

        const char *flagptr;

        int nparams = 0;

        int logfail = 0;

        int wait_exit = 0;

        int set_uid = 0;

        int child;

        int rv = 0;

	int max_fd;

	int fd;

	sighandler_t sighandler;

        for (flagptr = handler->flags; *flagptr != '\0'; flagptr += strlen(flagptr)+1) {

                switch (testflag(flagptr)) {

                case HF_LOGFAIL:

                        logfail = 1;

                        break;

                case HF_WAIT:

                        wait_exit = 1;

                        break;

                case HF_SETUID:

                        set_uid = 1;

                        break;

                case HF_TTY:

                case HF_USER:

                case HF_PARAM:

                        nparams++;

                }

        }

	sighandler = signal(SIGCHLD, SIG_DFL);

        child = fork();

        switch (child) {

        case -1:

		_pam_log(pamh, LOG_ERR, !logfail, "fork failed when executing handler '%s'",

				handler->executable);

		return -1;

        case 0:

		/* close all descriptors except std* */

		max_fd = getdtablesize();

		for(fd = 3; fd < max_fd; fd++)

			rv = close(fd); /* rv will be ignored */

                if (!wait_exit) {

			switch(fork()) {

			case 0:

				if(setsid() == -1) {

					_exit(255);

				}

				break;

			case -1:

				_exit(255);

			default:

				_exit(0);

			}

                }

                if (set_uid) {

                        struct passwd *pw;

                        pw = getpwnam(user);

                        if (pw == NULL)

                                _exit(255);

                        if (setgid(pw->pw_gid) == -1 ||

                            setgroups(0, NULL) == -1 ||

                            setuid(pw->pw_uid) == -1)

                                _exit(255);

                }

                call_exec(handler, nparams, user, tty);

                _exit(255);

        default:

                break;

        }

        waitpid(child, &rv, 0);

	if (sighandler != SIG_ERR)

		signal(SIGCHLD, sighandler);

	if (WIFEXITED(rv) && WEXITSTATUS(rv) != 0)

		_pam_log(pamh, LOG_ERR, !logfail, "handler '%s' returned %d on exit",

			handler->executable, (int)WEXITSTATUS(rv));

	else if (WIFSIGNALED(rv))

		_pam_log(pamh, LOG_ERR, !logfail, "handler '%s' caught a signal %d",

			handler->executable, (int)WTERMSIG(rv));

        return 0;

}

void

console_run_handlers(pam_handle_t *pamh, int lock, const char *user, const char *tty) {

        struct console_handler *handler;

        for (handler = first_handler; handler != NULL; handler = handler->next) {

                if (lock && handler->type == LOCK) {

                        execute_handler(pamh, handler, user, tty);

                }

                else if (!lock && handler->type == UNLOCK) {

                        execute_handler(pamh, handler, user, tty);

                }

        }

}

const char *

console_get_regexes(void) {

        struct console_handler *handler;

        for (handler = first_handler; handler != NULL; handler = handler->next) {

                if (handler->type == CONSOLEDEVS) {

                        return handler->flags;

                }

        }

	return NULL;

}