/*

   * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)

   * Licensed under the GPL
   */
  
  #include <stdio.h>

  #include <stdlib.h>

  #include <unistd.h>

  #include <errno.h>

  #include <fcntl.h>
  #include <string.h>

  #include <termios.h>

  #include <sys/stat.h>

  #include "chan_user.h"

  #include "os.h"

  #include "um_malloc.h"

  
  struct pty_chan {
  	void (*announce)(char *dev_name, int dev);
  	int dev;
  	int raw;
  	struct termios tt;
  	char dev_name[sizeof("/dev/pts/0123456\0")];
  };

  static void *pty_chan_init(char *str, int device, const struct chan_opts *opts)

  {
  	struct pty_chan *data;

  	data = uml_kmalloc(sizeof(*data), UM_GFP_KERNEL);

  	if (data == NULL)
  		return NULL;

  	*data = ((struct pty_chan) { .announce  	= opts->announce,

  				     .dev  		= device,
  				     .raw  		= opts->raw });

  	return data;

  }
  
  static int pts_open(int input, int output, int primary, void *d,
  		    char **dev_out)
  {
  	struct pty_chan *data = d;
  	char *dev;
  	int fd, err;
  
  	fd = get_pty();

  	if (fd < 0) {

  		err = -errno;

  		printk(UM_KERN_ERR "open_pts : Failed to open pts
  ");

  		return err;

  	}

  
  	if (data->raw) {

  		CATCH_EINTR(err = tcgetattr(fd, &data->tt));

  		if (err)

  			goto out_close;

  
  		err = raw(fd);

  		if (err)

  			goto out_close;

  	}
  
  	dev = ptsname(fd);
  	sprintf(data->dev_name, "%s", dev);
  	*dev_out = data->dev_name;

  	if (data->announce)
  		(*data->announce)(dev, data->dev);

  
  	return fd;

  
  out_close:
  	close(fd);
  	return err;

  }
  
  static int getmaster(char *line)
  {

  	struct stat buf;

  	char *pty, *bank, *cp;
  	int master, err;
  
  	pty = &line[strlen("/dev/ptyp")];
  	for (bank = "pqrs"; *bank; bank++) {
  		line[strlen("/dev/pty")] = *bank;
  		*pty = '0';

  		/* Did we hit the end ? */
  		if ((stat(line, &buf) < 0) && (errno == ENOENT))

  			break;

  		for (cp = "0123456789abcdef"; *cp; cp++) {
  			*pty = *cp;

  			master = open(line, O_RDWR);

  			if (master >= 0) {
  				char *tp = &line[strlen("/dev/")];
  
  				/* verify slave side is usable */
  				*tp = 't';

  				err = access(line, R_OK | W_OK);

  				*tp = 'p';

  				if (!err)

  					return master;
  				close(master);

  			}
  		}
  	}

  
  	printk(UM_KERN_ERR "getmaster - no usable host pty devices
  ");
  	return -ENOENT;

  }
  
  static int pty_open(int input, int output, int primary, void *d,
  		    char **dev_out)
  {
  	struct pty_chan *data = d;
  	int fd, err;
  	char dev[sizeof("/dev/ptyxx\0")] = "/dev/ptyxx";
  
  	fd = getmaster(dev);

  	if (fd < 0)
  		return fd;

  	if (data->raw) {

  		err = raw(fd);

  		if (err) {
  			close(fd);

  			return err;

  		}

  	}

  	if (data->announce)
  		(*data->announce)(dev, data->dev);

  
  	sprintf(data->dev_name, "%s", dev);
  	*dev_out = data->dev_name;

  
  	return fd;

  }

  const struct chan_ops pty_ops = {

  	.type		= "pty",
  	.init		= pty_chan_init,
  	.open		= pty_open,
  	.close		= generic_close,
  	.read		= generic_read,
  	.write		= generic_write,

  	.console_write	= generic_console_write,

  	.window_size	= generic_window_size,
  	.free		= generic_free,
  	.winch		= 0,
  };

  const struct chan_ops pts_ops = {

  	.type		= "pts",
  	.init		= pty_chan_init,
  	.open		= pts_open,
  	.close		= generic_close,
  	.read		= generic_read,
  	.write		= generic_write,

  	.console_write	= generic_console_write,

  	.window_size	= generic_window_size,
  	.free		= generic_free,
  	.winch		= 0,
  };