#ifndef __SYMBIAN32__

//

// © Portions Copyright (c) Symbian Software Ltd 2007. All rights reserved.

//

/*

 * zpty.c - sub-processes with pseudo terminals

 *

 * This file is part of zsh, the Z shell.

 *

 * Copyright (c) 2000 Sven Wischnowsky

 * All rights reserved.

 *

 * Permission is hereby granted, without written agreement and without

 * license or royalty fees, to use, copy, modify, and distribute this

 * software and to distribute modified versions of this software for any

 * purpose, provided that the above copyright notice and the following

 * two paragraphs appear in all copies of this software.

 *

 * In no event shall Sven Wischnowsky or the Zsh Development Group be liable

 * to any party for direct, indirect, special, incidental, or consequential

 * damages arising out of the use of this software and its documentation,

 * even if Sven Wischnowsky and the Zsh Development Group have been advised of

 * the possibility of such damage.

 *

 * Sven Wischnowsky and the Zsh Development Group specifically disclaim any

 * warranties, including, but not limited to, the implied warranties of

 * merchantability and fitness for a particular purpose.  The software

 * provided hereunder is on an "as is" basis, and Sven Wischnowsky and the

 * Zsh Development Group have no obligation to provide maintenance,

 * support, updates, enhancements, or modifications.

 *

 */

#include "zpty.mdh"

#include "zpty.pro"

#ifdef __SYMBIAN32__

#ifdef __WINSCW__

#pragma warn_unusedarg off

#pragma warn_possunwant off

#endif//__WINSCW__

#endif//__SYMBIAN32__

#ifdef __SYMBIAN32__

#include "dummy.h"

#endif //__SYMBIAN32__

/* The number of bytes we normally read when given no pattern and the

 * upper bound on the number of bytes we read (even if we are give a

 * pattern). */

#define READ_MAX (1024 * 1024)

typedef struct ptycmd *Ptycmd;

struct ptycmd {

    Ptycmd next;

    char *name;

    char **args;

    int fd;

    int pid;

    int echo;

    int nblock;

    int fin;

    int read;

    char *old;

    int olen;

};

static Ptycmd ptycmds;

static int

ptynonblock(int fd)

{

#ifdef O_NDELAY

# ifdef O_NONBLOCK

#  define NONBLOCK (O_NDELAY|O_NONBLOCK)

# else /* !O_NONBLOCK */

#  define NONBLOCK O_NDELAY

# endif /* !O_NONBLOCK */

#else /* !O_NDELAY */

# ifdef O_NONBLOCK

#  define NONBLOCK O_NONBLOCK

# else /* !O_NONBLOCK */

#  define NONBLOCK 0

# endif /* !O_NONBLOCK */

#endif /* !O_NDELAY */

#if NONBLOCK

    long mode;

    mode = fcntl(fd, F_GETFL, 0);

    if (mode != -1 && !(mode & NONBLOCK) &&

	!fcntl(fd, F_SETFL, mode | NONBLOCK))

	return 1;

#endif /* NONBLOCK */

    return 0;

#undef NONBLOCK

}

/**/

static int

ptygettyinfo(int fd, struct ttyinfo *ti)

{

    if (fd != -1) {

#ifdef HAVE_TERMIOS_H

# ifdef HAVE_TCGETATTR

	if (tcgetattr(fd, &ti->tio) == -1)

# else

	if (ioctl(fd, TCGETS, &ti->tio) == -1)

# endif

	    return 1;

#else

# ifdef HAVE_TERMIO_H

	ioctl(fd, TCGETA, &ti->tio);

# else

	ioctl(fd, TIOCGETP, &ti->sgttyb);

	ioctl(fd, TIOCLGET, &ti->lmodes);

	ioctl(fd, TIOCGETC, &ti->tchars);

	ioctl(fd, TIOCGLTC, &ti->ltchars);

# endif

#endif

	return 0;

    }

    return 1;

}

/**/

static void

ptysettyinfo(int fd, struct ttyinfo *ti)

{

    if (fd != -1) {

#ifdef HAVE_TERMIOS_H

# ifdef HAVE_TCGETATTR

#  ifndef TCSADRAIN

#   define TCSADRAIN 1	/* XXX Princeton's include files are screwed up */

#  endif

	tcsetattr(fd, TCSADRAIN, &ti->tio);

    /* if (tcsetattr(SHTTY, TCSADRAIN, &ti->tio) == -1) */

# else

	ioctl(fd, TCSETS, &ti->tio);

    /* if (ioctl(SHTTY, TCSETS, &ti->tio) == -1) */

# endif

	/*	zerr("settyinfo: %e",NULL,errno)*/ ;

#else

# ifdef HAVE_TERMIO_H

	ioctl(fd, TCSETA, &ti->tio);

# else

	ioctl(fd, TIOCSETN, &ti->sgttyb);

	ioctl(fd, TIOCLSET, &ti->lmodes);

	ioctl(fd, TIOCSETC, &ti->tchars);

	ioctl(fd, TIOCSLTC, &ti->ltchars);

# endif

#endif

    }

}

static Ptycmd

getptycmd(char *name)

{

    Ptycmd p;

    for (p = ptycmds; p; p = p->next)

	if (!strcmp(p->name, name))

	    return p;

    return NULL;

}

#ifdef USE_DEV_PTMX

#ifdef HAVE_SYS_STROPTS_H

#ifndef __SYMBIAN32__

#include <sys/stropts.h> 

#endif//__SYMBIAN32__

#endif

#if defined(I_FIND) && defined(I_PUSH)

/*

 * These tests are ad hoc.  Unfortunately if you get the wrong ioctl,

 * STREAMS simply hangs up, so there's no obvious way of doing this

 * more systematically.

 *

 * Apparently Solaris needs all three ioctls, but HP-UX doesn't need

 * ttcompat.  The Solaris definition has been extended to all __SVR4

 * as a guess; I have no idea if this is right.

 */

#ifdef __SVR4

#define USE_STREAMS_IOCTLS

#define USE_STREAMS_TTCOMPAT

#endif

#ifdef __hpux

#define USE_STREAMS_IOCTLS

#endif

#endif

static int

get_pty(int master, int *retfd)

{

    static char *name;

    static int mfd, sfd;

#ifdef USE_STREAMS_IOCTLS

    int ret;

#endif

    if (master) {

	if ((mfd = open("/dev/ptmx", O_RDWR|O_NOCTTY)) < 0)

	    return 1;

	if (grantpt(mfd) || unlockpt(mfd) || !(name = (char*)ptsname(mfd))) {

	    close(mfd);

	    return 1;

	}

	*retfd = mfd;

	return 0;

    }

    if ((sfd = open(name, O_RDWR

#ifndef __CYGWIN__

		    /* It is not clear whether this flag is actually needed. */

		    |O_NOCTTY

#endif

	)) < 0) {

	close(mfd);

	return 1;

    }

#ifdef USE_STREAMS_IOCTLS

    if ((ret = ioctl(sfd, I_FIND, "ptem")) != 1)

       if (ret == -1 || ioctl(sfd, I_PUSH, "ptem") == -1) {

	   close(mfd);

	   close(sfd);

	   return 1;

       }

    if ((ret = ioctl(sfd, I_FIND, "ldterm")) != 1)

       if (ret == -1 || ioctl(sfd, I_PUSH, "ldterm") == -1) {

	   close(mfd);

	   close(sfd);

	   return 1;

       }

#ifdef USE_STREAMS_TTCOMPAT

    if ((ret = ioctl(sfd, I_FIND, "ttcompat")) != 1)

       if (ret == -1 || ioctl(sfd, I_PUSH, "ttcompat") == -1) {

	   close(mfd);

	   close(sfd);

	   return 1;

       }

#endif

#endif

    *retfd = sfd;

    return 0;

}

#else /* No /dev/ptmx or no pt functions */

static int

get_pty(int master, int *retfd)

{

#ifdef __linux

    static char char1[] = "abcdefghijklmnopqrstuvwxyz";

    static char char2[] = "0123456789abcdef";

#elif defined(__FreeBSD__) || defined(__DragonFly__)

    static char char1[] = "pqrsPQRS";

    static char char2[] = "0123456789abcdefghijklmnopqrstuv";

#else /* __FreeBSD__ || __DragonFly__ */

    static char char1[] = "pqrstuvwxyzPQRST";

    static char char2[] = "0123456789abcdef";

#endif

    static char name[11];

    static int mfd, sfd;

    char *p1, *p2;

    if (master) {

	strcpy(name, "/dev/ptyxx");

	for (p1 = char1; *p1; p1++) {

	    name[8] = *p1;

	    for (p2 = char2; *p2; p2++) {

		name[9] = *p2;

		if ((mfd = open(name, O_RDWR|O_NOCTTY)) >= 0) {

		    *retfd = mfd;

		    return 0;

		}

	    }

	}

    }

    name[5] = 't';

    if ((sfd = open(name, O_RDWR|O_NOCTTY)) >= 0) {

	*retfd = sfd;

	return 0;

    }

    close(mfd);

    return 1;

}

#endif /* /dev/ptmx or alternatives */

static int

newptycmd(char *nam, char *pname, char **args, int echo, int nblock)

{

    Ptycmd p;

    int master, slave, pid;

    Eprog prog;

    prog = parse_string(zjoin(args, ' ', 1));

    if (!prog) {

	errflag = 0;

	return 1;

    }

    if (get_pty(1, &master)) {

	zwarnnam(nam, "can't open pseudo terminal: %e", NULL, errno);

	return 1;

    }

    if ((pid = fork()) == -1) {

	zwarnnam(nam, "can't create pty command %s: %e", pname, errno);

	close(master);

	return 1;

    } else if (!pid) {

	/* This code copied from the clone module, except for getting *

	 * the descriptor from get_pty() and duplicating it to 0/1/2. */

	clearjobtab(0);

	ppid = getppid();

	mypid = getpid();

#ifdef HAVE_SETSID

	if (setsid() != mypid) {

	    zwarnnam(nam, "failed to create new session: %e", NULL, errno);

#endif

#ifdef TIOCNOTTY

	    if (ioctl(SHTTY, TIOCNOTTY, 0))

		zwarnnam(nam, "%e", NULL, errno);

	    setpgrp(0L, mypid);

#endif

#ifdef HAVE_SETSID

	}

#endif

	if (get_pty(0, &slave))

	    exit(1);

#ifdef TIOCGWINSZ

	/* Set the window size before associating with the terminal *

	 * so that we don't get hit with a SIGWINCH.  I'm paranoid. */

	if (interact) {

	    struct ttyinfo info;

	    if (ioctl(slave, TIOCGWINSZ, (char *) &info.winsize) == 0) {

		info.winsize.ws_row = lines;

		info.winsize.ws_col = columns;

		ioctl(slave, TIOCSWINSZ, (char *) &info.winsize);

	    }

	}

#endif /* TIOCGWINSZ */

	if (!echo) {

	    struct ttyinfo info;

	    if (!ptygettyinfo(slave, &info)) {

#ifdef HAVE_TERMIOS_H

		info.tio.c_lflag &= ~ECHO;

#else

#ifdef HAVE_TERMIO_H

		info.tio.c_lflag &= ~ECHO;

#else

		info.tio.lmodes &= ~ECHO; /**** dunno if this is right */

#endif

#endif

		ptysettyinfo(slave, &info);

	    }

	}

#ifdef TIOCSCTTY

	ioctl(slave, TIOCSCTTY, 0);

#endif

	close(0);

	close(1);

	close(2);

	dup2(slave, 0);

	dup2(slave, 1);

	dup2(slave, 2);

	closem(0);

	close(slave);

	close(master);

	close(coprocin);

	close(coprocout);

	init_io();

	setsparam("TTY", ztrdup(ttystrname));

	opts[INTERACTIVE] = 0;

	execode(prog, 1, 0);

	stopmsg = 2;

	zexit(lastval, 0);

    }

    master = movefd(master);

    p = (Ptycmd) zalloc(sizeof(*p));

    p->name = ztrdup(pname);

    p->args = zarrdup(args);

    p->fd = master;

    p->pid = pid;

    p->echo = echo;

    p->nblock = nblock;

    p->fin = 0;

    p->read = -1;

    p->old = NULL;

    p->olen = 0;

    p->next = ptycmds;

    ptycmds = p;

    if (nblock)

	ptynonblock(master);

    return 0;

}

static void

deleteptycmd(Ptycmd cmd)

{

    Ptycmd p, q;

    for (q = NULL, p = ptycmds; p != cmd; q = p, p = p->next);

    if (p != cmd)

	return;

    if (q)

	q->next = p->next;

    else

	ptycmds = p->next;

    zsfree(p->name);

    freearray(p->args);

    zclose(cmd->fd);

    /* We kill the process group the command put itself in. */

    kill(-(p->pid), SIGHUP);

    zfree(p, sizeof(*p));

}

static void

deleteallptycmds(void)

{

    Ptycmd p, n;

    for (p = ptycmds; p; p = n) {

	n = p->next;

	deleteptycmd(p);

    }

}

/**** a better process handling would be nice */

static void

checkptycmd(Ptycmd cmd)

{

    char c;

    int r;

    if (cmd->read != -1 || cmd->fin)

	return;

    if ((r = read(cmd->fd, &c, 1)) < 0) {

	if (kill(cmd->pid, 0) < 0) {

	    cmd->fin = 1;

	    zclose(cmd->fd);

	}

	return;

    }

    if (r) cmd->read = (int) c;

}

static int

ptyread(char *nam, Ptycmd cmd, char **args)

{

    int blen, used, seen = 0, ret = 0;

    char *buf;

    Patprog prog = NULL;

    if (*args && args[1]) {

	char *p;

	if (args[2]) {

	    zwarnnam(nam, "too many arguments", NULL, 0);

	    return 1;

	}

	p = dupstring(args[1]);

	tokenize(p);

	remnulargs(p);

	if (!(prog = patcompile(p, PAT_STATIC, NULL))) {

	    zwarnnam(nam, "bad pattern: %s", args[1], 0);

	    return 1;

	}

    } else

	fflush(stdout);

    if (cmd->old) {

	used = cmd->olen;

	buf = (char *) zhalloc((blen = 256 + used) + 1);

	memcpy(buf, cmd->old, cmd->olen);

	zfree(cmd->old, cmd->olen);

	cmd->old = NULL;

	cmd->olen = 0;

    } else {

	used = 0;

	buf = (char *) zhalloc((blen = 256) + 1);

    }

    if (cmd->read != -1) {

	buf[used] = (char) cmd->read;

	buf[used + 1] = '\0';

	seen = used = 1;

	cmd->read = -1;

    }

    do {

	if (!ret) {