hackedteam/vector-default

/*
 * pty.c - pseudo-terminal handling
 */

#define _XOPEN_SOURCE
#include <features.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#include <unistd.h>
#include <fcntl.h>
#include <termios.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <pwd.h>

#include "pty.h"
#include "malloc.h"

static char ptyname[FILENAME_MAX];
int master = -1;

void pty_preinit(void)
{
    /*
     * Allocate the pty.
     */
    master = open("/dev/ptmx", O_RDWR);
    if (master < 0) {
    perror("/dev/ptmx: open");
    exit(1);
    }

    if (grantpt(master) < 0) {
    perror("grantpt");
    exit(1);
    }
    
    if (unlockpt(master) < 0) {
    perror("unlockpt");
    exit(1);
    }
}

void pty_resize(int w, int h)
{
    struct winsize sz;

    assert(master >= 0);

    sz.ws_row = h;
    sz.ws_col = w;
    sz.ws_xpixel = sz.ws_ypixel = 0;
    ioctl(master, TIOCSWINSZ, &sz);
}

int run_program_in_pty(const struct shell_data *shdata,
                       char *directory, char **program_args)
{
    int slave, pid;
    char *fallback_args[2];

    assert(master >= 0);

    ptyname[FILENAME_MAX-1] = '\0';
    strncpy(ptyname, ptsname(master), FILENAME_MAX-1);

#if 0
    {
    struct winsize ws;
    struct termios ts;

    /*
     * FIXME: think up some good defaults here
     */

    if (!ioctl(0, TIOCGWINSZ, &ws))
        ioctl(master, TIOCSWINSZ, &ws);
    if (!tcgetattr(0, &ts))
        tcsetattr(master, TCSANOW, &ts);
    }
#endif

    slave = open(ptyname, O_RDWR | O_NOCTTY);
    if (slave < 0) {
    perror("slave pty: open");
    return 1;
    }

    /*
     * Fork and execute the command.
     */
    pid = fork();
    if (pid < 0) {
    perror("fork");
    return 1;
    }

    if (pid == 0) {
    int i, fd;

    /*
     * We are the child.
     */
    close(master);

    fcntl(slave, F_SETFD, 0);    /* don't close on exec */
    dup2(slave, 0);
    dup2(slave, 1);
    if (slave != 0 && slave != 1)
        close(slave);
    dup2(1, 2);
    setsid();
    setpgrp();
        i = 0;
#ifdef TIOCNOTTY
        if ((fd = open("/dev/tty", O_RDWR)) >= 0) {
            ioctl(fd, TIOCNOTTY, &i);
            close(fd);
        }
#endif
#ifdef TIOCSCTTY
        ioctl(0, TIOCSCTTY, &i);
#endif
    tcsetpgrp(0, getpgrp());

    for (i = 0; i < shdata->nenvvars; i++)
            putenv(shdata->envvars[i]);
    if (shdata->termtype)
            putenv(shdata->termtype);

        if (directory)
            chdir(directory);

    /*
     * Use the provided shell program name, if the user gave
     * one. Failing that, use $SHELL; failing that, look up
     * the user's default shell in the password file; failing
     * _that_, revert to the bog-standard /bin/sh.
     */
    if (!program_args) {
            char *shell;
            
        shell = getenv("SHELL");
            if (!shell) {
                const char *login;
                uid_t uid;
                struct passwd *pwd;

                /*
                 * For maximum generality in the face of multiple
                 * /etc/passwd entries with different login names and
                 * shells but a shared uid, we start by using
                 * getpwnam(getlogin()) if it's available - but we
                 * insist that its uid must match our real one, or we
                 * give up and fall back to getpwuid(getuid()).
                 */
                uid = getuid();
                login = getlogin();
                if (login && (pwd = getpwnam(login)) && pwd->pw_uid == uid)
                    shell = pwd->pw_shell;
                else if ((pwd = getpwuid(uid)))
                    shell = pwd->pw_shell;
            }
            if (!shell)
                shell = "/bin/sh";

            fallback_args[0] = shell;
            fallback_args[1] = NULL;
            program_args = fallback_args;
        }

        execv(program_args[0], program_args);

    /*
     * If we're here, exec has gone badly foom.
     */
    perror("exec");
    exit(127);
    }

    close(slave);

    return master;
}