Quelle  pty.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2001 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
 */

#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\n");
  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\n");
 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,
};