root/lang/objective-cplusplus/i3/trunk/tmp/pty2.c @ 36260

/*
 * Fake cygwin pty   --  fakecygpty --
 *
 *        Copyright (C) 2005 Kyotaro Horiguchi <horiguti@meaodwy.org>
 *
 *
 * 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 versions 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 fiber, see the file COPYING.  If not, write to the Free
 * Software Foundation Inc., 59 Temple Place - Suite 330, Boston,
 * MA 02111-1307, USA.
 */

/*
 * HISTORY
 * -------
 *
 *    09 Jun, 2005 : Version 1.0.0 - first release.
 *    15 Jun, 2005 : Version 1.0.1 - bug fix and change coding style.
 */

/*
 * COMPILATION
 * -------
 * gcc -o fakecygpty.exe fakecygpty.c
 *
 */

#if defined(__INTERIX) && !defined(_ALL_SOURCE)
#define _ALL_SOURCE
#endif

#include <errno.h>
#include <fcntl.h>
#include <signal.h>
//#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <termios.h>
#include <unistd.h>

#define BUFSIZE 1024 /* size of communication buffer */

/* global variables */
int child_pid;          /* pid of child proces  */
int master_fd;          /* fd of pty served to child process */

void e(const char* message) {
    char newline[] = "\r\n";
    write(2, message, strlen(message));
    write(2, newline, strlen(newline));
}


/* Create pty and fork/exec target process */
/* This function sets child_pid and master_fd */
void exec_target(char* argv[]) {
    int fd;
    int pid;

    master_fd = open("/dev/ptmx", O_RDWR);
    if (master_fd < 0) {
        e("Cannot open pseudo tty");
        exit(1);
    }

    pid = fork();
    if (pid < 0) {
        e("Failed to fork");
        return;
    }

    if (pid == 0) {
        int slave = 0;
        setsid();
        
        slave = open(ptsname(master_fd), O_RDWR);
        if (slave < 0) {
            e("Failed to open slave fd");
            exit(1);
        }

        for (fd = 0 ; fd < 3 ; fd++) {
            if (slave != fd) {
                if (dup2(slave, fd) < 0) {
                    e("Failed to dup2");
                    exit(1);
                }
            }
            fcntl(fd, F_SETFD, 0);
        }

        if (slave > 2) {
            close(slave);
        }

        execvp(argv[0], argv);

        e("Failed to execute");
        exit(1);
    }
        
    child_pid = pid;

    return;
}

struct termios oldtm;

void setup_tty_attributes(void) {
    struct termios tm;

    if (tcgetattr(master_fd, &tm) == 0) {
        /* Inhibit echo when executed under emacs/windows environment */
        if (!isatty(0)) {
            tm.c_iflag |= IGNCR;
            tm.c_lflag &= ~ECHO;
        }
        tcsetattr(master_fd, TCSANOW, &tm);
    }

    if (tcgetattr(0, &oldtm) == 0) {
        tm = oldtm;
        tm.c_iflag &= ~(ICRNL | IXON | IXOFF);
        tm.c_iflag |= IGNBRK;
        tm.c_lflag &= ~(ICANON | ECHO | ISIG | ECHOE);
        tcsetattr(0, TCSANOW, &tm);
    }
}

void restore_tty_attributes(void) {
    tcsetattr(0, TCSANOW, &oldtm);
}

#ifdef __CYGWIN__
/* Signal handler for convert SIGINT into ^C on pty */
/* This seems not able to be done within cygwin POSIX framework */
#include <windows.h>
BOOL WINAPI ctrl_handler(DWORD e) {
    switch (e) {
    case CTRL_C_EVENT:
        write(master_fd, "\003", 1);
        return TRUE;

    case CTRL_CLOSE_EVENT:
        kill(child_pid, SIGKILL);
        return FALSE;
    }
    return FALSE;
}
#endif

int main(int argc, char* argv[]) {
    fd_set read_fd_set;
    fd_set write_fd_set;
    int status = 0;

    if (argc < 2) {
        e("Unable to get argv[1]");
        return 1;
    }

#ifdef __CYGWIN__
    /* SIGINT and SIGBREAK are indistinctive under cygwin environment. */
    /* Using Win32API to handle SIGINT.                              */
    SetConsoleCtrlHandler(ctrl_handler, TRUE);
#endif
    setup_tty_attributes();
    exec_target(argv + 1);

    FD_ZERO(&read_fd_set);
    FD_SET(0, &read_fd_set);
    FD_SET(master_fd, &read_fd_set);

    FD_ZERO(&write_fd_set);
    FD_SET(1, &write_fd_set);
    FD_SET(master_fd, &write_fd_set);

    while (1) {
        if (select(master_fd + 1, 
                   &read_fd_set, &write_fd_set, NULL, NULL) < 0) {
            break;
        }

        if (FD_ISSET(master_fd, &read_fd_set)) {
            char buf[BUFSIZE];
            int ret = read(master_fd, buf, sizeof(buf));
            if (ret > 0) {
                write(1, buf, ret);
            } else if (ret == 0 || (errno != EAGAIN && errno != EWOULDBLOCK)) {
                break;
            }
        } 

        if (FD_ISSET(0, &sel)) {
            char buf[BUFSIZE];
            int ret = read(0, buf, sizeof(buf));
            if (ret > 0) {
                int ret2 = write(master_fd, buf, ret);
                if (ret2 == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
                    e("write(master_fd): noblocking !?");
                }
            } else if (ret == 0 || (errno != EAGAIN && errno != EWOULDBLOCK)) {
                break;
            }
        }
    }

    waitpid(child_pid, &status, 0);

    FD_CLR(0, &sel);
    restore_tty_attributes();
    close(master_fd);
    return status;
}