source: rtems/cpukit/telnetd/pty.c @ 8ad6681b

/*
 * /dev/ptyXX  (A first version for pseudo-terminals)
 *
 *  Author: Fernando RUIZ CASAS (fernando.ruiz@ctv.es)
 *  May 2001
 *
 *  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.
 *
 *  Till Straumann <strauman@slac.stanford.edu>
 *
 *   - converted into a loadable module
 *   - NAWS support / ioctls for querying/setting the window
 *     size added.
 *   - don't delete the running task when the connection
 *     is closed. Rather let 'read()' return a 0 count so
 *     they may cleanup. Some magic hack works around termios
 *     limitation.
 * 
 *  $Id$
 */

/*
                      LICENSE INFORMATION

RTEMS is free software; you can redistribute it and/or modify it under
terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.  RTEMS 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 RTEMS; see
file COPYING. If not, write to the Free Software Foundation, 675
Mass Ave, Cambridge, MA 02139, USA.

As a special exception, including RTEMS header files in a file,
instantiating RTEMS generics or templates, or linking other files
with RTEMS objects to produce an executable application, does not
by itself cause the resulting executable application to be covered
by the GNU General Public License. This exception does not
however invalidate any other reasons why the executable file might be
covered by the GNU Public License.

*/

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#define DEBUG_WH                (1<<0)
#define DEBUG_DETAIL    (1<<1)

/* #define DEBUG DEBUG_WH */

#ifdef __cplusplus
extern "C" {
#endif
/*-----------------------------------------*/
#include <termios.h>
#include <rtems/termiostypes.h>
#include <sys/ttycom.h>
#include <rtems.h>
#include <rtems/libio.h>
#include <bsp.h>
#include <rtems/bspIo.h>
#if 0
#include <rtems/pty.h>
#else
#define MAX_PTYS 8
#endif
#include <errno.h>
#include <sys/socket.h>
#ifdef __cplusplus
};
#endif
/*-----------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
/*-----------------------------------------*/
#define IAC_ESC    255
#define IAC_DONT   254
#define IAC_DO     253
#define IAC_WONT   252
#define IAC_WILL   251
#define IAC_SB     250
#define IAC_GA     249
#define IAC_EL     248
#define IAC_EC     247
#define IAC_AYT    246
#define IAC_AO     245
#define IAC_IP     244
#define IAC_BRK    243
#define IAC_DMARK  242
#define IAC_NOP    241
#define IAC_SE     240
#define IAC_EOR    239

#define SB_MAX          16

struct pty_tt;
typedef struct pty_tt pty_t;

struct pty_tt {
 char                     *devname;
 struct rtems_termios_tty *ttyp;
 tcflag_t                  c_cflag;
 int                       opened;
 int                       socket;
 int                       last_cr;
 unsigned                  iac_mode;   
 unsigned char             sb_buf[SB_MAX];      
 int                       sb_ind;
 int                       width;
 int                       height;
};


#ifdef __cplusplus

extern "C" {
int             printk(char*,...);

#endif

#if     MAX_PTYS > 5
#undef  MAX_PTYS
#define MAX_PTYS 5
#endif


static int   telnet_pty_inited=FALSE;
static pty_t telnet_ptys[MAX_PTYS];

static rtems_device_major_number pty_major;


/* This procedure returns the devname for a pty slot free.
 * If not slot availiable (field socket>=0) 
 *  then the socket argument is closed
 */

char *  telnet_get_pty(int socket) {
  int ndx;
  if (telnet_pty_inited) {
    for (ndx=0;ndx<MAX_PTYS;ndx++) {
      if (telnet_ptys[ndx].socket<0) {
        struct timeval t;
        /* set a long polling interval to save CPU time */
        t.tv_sec=2;
        t.tv_usec=00000;
        setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(t));
        telnet_ptys[ndx].socket=socket;
        return telnet_ptys[ndx].devname;
      };
    };
  }
  close(socket);
  return NULL;
}


/*-----------------------------------------------------------*/
/*
 * The NVT terminal is negociated in PollRead and PollWrite
 * with every BYTE sendded or received. 
 * A litle status machine in the pty_read_byte(int minor) 
 * 
 */
static const char IAC_AYT_RSP[]="\r\nAYT? Yes, RTEMS-SHELL is here\r\n";
static const char IAC_BRK_RSP[]="<*Break*>";
static const char IAC_IP_RSP []="<*Interrupt*>";


static
int send_iac(int minor,unsigned char mode,unsigned char option) {
  unsigned char buf[3];
  buf[0]=IAC_ESC;
  buf[1]=mode;
  buf[2]=option;
  return write(telnet_ptys[minor].socket,buf,sizeof(buf));
}

static int
handleSB(pty_t *pty)
{
  switch (pty->sb_buf[0]) {
    case 31:    /* NAWS */
      pty->width  = (pty->sb_buf[1]<<8) + pty->sb_buf[2];
      pty->height = (pty->sb_buf[3]<<8) + pty->sb_buf[4];
#if DEBUG & DEBUG_WH
      fprintf(stderr,
          "Setting width/height to %ix%i\n",
          pty->width,
          pty->height);
#endif
      break;
    default:
      break;
  }
  return 0;
}

static int read_pty(int minor) { /* Characters written to the client side*/
   unsigned char        value;
   unsigned int omod;
   int                  count;
   int                  result;
   pty_t                        *pty=telnet_ptys+minor;

   count=read(pty->socket,&value,sizeof(value));
   if (count<0)
    return -1;

   if (count<1) {
      /* Unfortunately, there is no way of passing an EOF
       * condition through the termios driver. Hence, we
       * resort to an ugly hack. Setting cindex>ccount
       * causes the termios driver to return a read count
       * of '0' which is what we want here. We leave
       * 'errno' untouched.
       */
      pty->ttyp->cindex=pty->ttyp->ccount+1;
      return pty->ttyp->termios.c_cc[VEOF];
   };

   omod=pty->iac_mode;
   pty->iac_mode=0;
   switch(omod & 0xff) {
       case IAC_ESC:
           switch(value) {
               case IAC_ESC :
                   /* in case this is an ESC ESC sequence in SB mode */
                   pty->iac_mode = omod>>8;
                   return IAC_ESC;
               case IAC_DONT:
               case IAC_DO  :
               case IAC_WONT:
               case IAC_WILL:
                   pty->iac_mode=value;
                   return -1;
               case IAC_SB  :
#if DEBUG & DEBUG_DETAIL
                   printk("SB\n");
#endif
                   pty->iac_mode=value;
                   pty->sb_ind=0;
                   return -100;
               case IAC_GA  :
                   return -1;
               case IAC_EL  :
                   return 0x03; /* Ctrl-C*/
               case IAC_EC  :
                   return '\b';
               case IAC_AYT :
                   write(pty->socket,IAC_AYT_RSP,strlen(IAC_AYT_RSP));
                   return -1;
               case IAC_AO  :
                   return -1;
               case IAC_IP  :
                   write(pty->socket,IAC_IP_RSP,strlen(IAC_IP_RSP));
                   return -1;
               case IAC_BRK :
                   write(pty->socket,IAC_BRK_RSP,strlen(IAC_BRK_RSP));
                   return -1;
               case IAC_DMARK:
                   return -2;
               case IAC_NOP :
                   return -1;
               case IAC_SE  :
#if DEBUG & DEBUG_DETAIL
                  {
                  int i;
                  printk("SE");
                  for (i=0; i<pty->sb_ind; i++)
                    printk(" %02x",pty->sb_buf[i]);
                  printk("\n");
                  }
#endif
                  handleSB(pty);
               return -101;
               case IAC_EOR :
                   return -102;
               default      :
                   return -1;
           };
           break;

       case IAC_SB:
           pty->iac_mode=omod;
           if (IAC_ESC==value) {
            pty->iac_mode=(omod<<8)|value;
           } else {
            if (pty->sb_ind < SB_MAX)
              pty->sb_buf[pty->sb_ind++]=value;
           }
           return -1;

       case IAC_WILL:
           if (value==34){
              send_iac(minor,IAC_DONT,   34);   /*LINEMODE*/ 
              send_iac(minor,IAC_DO  ,    1);   /*ECHO    */
           } else if (value==31) {
              send_iac(minor,IAC_DO  ,   31);   /*NAWS    */
#if DEBUG & DEBUG_DETAIL
              printk("replied DO NAWS\n");
#endif
           } else {
              send_iac(minor,IAC_DONT,value);
           }
           return -1;
       case IAC_DONT:
           return -1;
       case IAC_DO  :
           if (value==3) {
              send_iac(minor,IAC_WILL,    3);   /* GO AHEAD*/
           } else       if (value==1) {                         
              /* ECHO */
           } else {
              send_iac(minor,IAC_WONT,value);
           };
           return -1;
       case IAC_WONT:
           if (value==1) {send_iac(minor,IAC_WILL,    1);} else /* ECHO */
           {send_iac(minor,IAC_WONT,value);};
           return -1;
       default:
           if (value==IAC_ESC) {
              pty->iac_mode=value;
              return -1;
           } else {
              result=value;  
              if ( 0
#if 0                                                    /* pass CRLF through - they should use termios to handle it */
                 ||     ((value=='\n') && (pty->last_cr))
#endif
                /* but map telnet CRNUL to CR down here */
                 || ((value==0) && pty->last_cr)
                ) result=-1;
               pty->last_cr=(value=='\r');
               return result;
           };
   };
  /* should never get here but keep compiler happy */
  return -1;
}

/*-----------------------------------------------------------*/
static int ptySetAttributes(int minor,const struct termios *t);
static int ptyPollInitialize(int major,int minor,void * arg) ;
static int ptyShutdown(int major,int minor,void * arg) ;
static int ptyPollWrite(int minor, const char * buf,int len) ;
static int ptyPollRead(int minor) ;
static const rtems_termios_callbacks * pty_get_termios_handlers(int polled) ;
/*-----------------------------------------------------------*/
/* Set the 'Hardware'                                        */ 
/*-----------------------------------------------------------*/
static int
ptySetAttributes(int minor,const struct termios *t) {
  if (minor<MAX_PTYS) { 
   telnet_ptys[minor].c_cflag=t->c_cflag;       
  } else {
   return -1;
  };
  return 0;
}
/*-----------------------------------------------------------*/
static int 
ptyPollInitialize(int major,int minor,void * arg) {
  rtems_libio_open_close_args_t * args = (rtems_libio_open_close_args_t*)arg;
  struct termios t;
        if (minor<MAX_PTYS) {   
         if (telnet_ptys[minor].socket<0) return -1;            
   telnet_ptys[minor].opened=TRUE;
   telnet_ptys[minor].ttyp= (struct rtems_termios_tty *) args->iop->data1;
   telnet_ptys[minor].iac_mode=0;
   telnet_ptys[minor].sb_ind=0;
   telnet_ptys[minor].width=0;
   telnet_ptys[minor].height=0;
   t.c_cflag=B9600|CS8;/* termios default */
   return ptySetAttributes(minor,&t);
  } else {
   return -1;
  };
}
/*-----------------------------------------------------------*/
static int 
ptyShutdown(int major,int minor,void * arg) {
        if (minor<MAX_PTYS) {   
   telnet_ptys[minor].opened=FALSE;
         if (telnet_ptys[minor].socket>=0) close(telnet_ptys[minor].socket);
   telnet_ptys[minor].socket=-1;
   chown(telnet_ptys[minor].devname,2,0);
  } else {
   return -1;
  };
  return 0;
}
/*-----------------------------------------------------------*/
/* Write Characters into pty device                          */ 
/*-----------------------------------------------------------*/
static int
ptyPollWrite(int minor, const char * buf,int len) {
  int count;
        if (minor<MAX_PTYS) {   
         if (telnet_ptys[minor].socket<0) return -1;            
   count=write(telnet_ptys[minor].socket,buf,len);
  } else {
   count=-1;
  };
  return count;
}
/*-----------------------------------------------------------*/
static int
ptyPollRead(int minor) {
  int result;
        if (minor<MAX_PTYS) {   
         if (telnet_ptys[minor].socket<0) return -1;            
   result=read_pty(minor);
   return result;
  };
  return -1;
}
/*-----------------------------------------------------------*/
/*  pty_initialize
 *
 *  This routine initializes the pty IO driver.
 *
 *  Input parameters: NONE
 *
 *  Output parameters:  NONE
 *
 *  Return values:
 */
/*-----------------------------------------------------------*/
static
rtems_device_driver my_pty_initialize(
  rtems_device_major_number  major,
  rtems_device_minor_number  minor,
  void                      *arg
)
{
int ndx;        
rtems_status_code status ;

  /* 
   * Set up ptys
   */

  for (ndx=0;ndx<MAX_PTYS;ndx++) {
    telnet_ptys[ndx].devname=(char*)malloc(strlen("/dev/ptyXX")+1);
    sprintf(telnet_ptys[ndx].devname,"/dev/pty%X",ndx);
    telnet_ptys[ndx].ttyp=NULL;
    telnet_ptys[ndx].c_cflag=CS8|B9600;
    telnet_ptys[ndx].socket=-1;
    telnet_ptys[ndx].opened=FALSE;
    telnet_ptys[ndx].sb_ind=0;
    telnet_ptys[ndx].width=0;
    telnet_ptys[ndx].height=0;

  };

  /*
   * Register the devices
   */
  for (ndx=0;ndx<MAX_PTYS;ndx++) {
    status = rtems_io_register_name(telnet_ptys[ndx].devname, major, ndx);
    if (status != RTEMS_SUCCESSFUL)
        rtems_fatal_error_occurred(status);
    chmod(telnet_ptys[ndx].devname,0660);
    chown(telnet_ptys[ndx].devname,2,0); /* tty,root*/
  };
  printk("Device: /dev/pty%X../dev/pty%X (%d)pseudo-terminals registered.\n",0,MAX_PTYS-1,MAX_PTYS);

  return RTEMS_SUCCESSFUL;
}

static int pty_do_finalize()
{
int ndx;
rtems_status_code status;

    if ( !telnet_pty_inited )
      return 0;

    for (ndx=0;ndx<MAX_PTYS;ndx++) {
      if (telnet_ptys[ndx].opened) {
          fprintf(stderr,"There are still opened PTY devices, unable to proceed\n");
          return -1;
      }
    }
    if (RTEMS_SUCCESSFUL != rtems_io_unregister_driver(pty_major)) {
        fprintf(stderr,"Unable to remove this driver\n");
        return -1;
    }
    for (ndx=0;ndx<MAX_PTYS;ndx++) {
        /* rtems_io_register_name() actually creates a node in the filesystem
         * (mknod())
         */
        status = (rtems_status_code)unlink(telnet_ptys[ndx].devname);
        if (status != RTEMS_SUCCESSFUL)
          perror("removing pty device node from file system");
        else
          free(telnet_ptys[ndx].devname);
    };
    fprintf(stderr,"PTY driver unloaded successfully\n");
    telnet_pty_inited=FALSE;
    return 0;
}

/*
 *  Open entry point
 */

static
rtems_device_driver my_pty_open(
  rtems_device_major_number major,
  rtems_device_minor_number minor,
  void                    * arg
)
{
  rtems_status_code sc ;
  sc = rtems_termios_open(major,minor,arg,pty_get_termios_handlers(FALSE));
  return sc;
}
 
/*
 *  Close entry point
 */

static
rtems_device_driver my_pty_close(
  rtems_device_major_number major,
  rtems_device_minor_number minor,
  void                    * arg
)
{
  return rtems_termios_close(arg);
}

/*
 * read bytes from the pty
 */

static
rtems_device_driver my_pty_read(
  rtems_device_major_number major,
  rtems_device_minor_number minor,
  void                    * arg
)
{
  return rtems_termios_read(arg);
}

/*
 * write bytes to the pty
 */

static
rtems_device_driver my_pty_write(
  rtems_device_major_number major,
  rtems_device_minor_number minor,
  void                    * arg
)
{
  return rtems_termios_write(arg);
}

/*
 *  IO Control entry point
 */

static
rtems_device_driver my_pty_control(
  rtems_device_major_number major,
  rtems_device_minor_number minor,
  void                    * arg
)
{
rtems_libio_ioctl_args_t *args = (rtems_libio_ioctl_args_t*)arg;
struct winsize                   *wp = (struct winsize*)args->buffer;
pty_t                                    *p=&telnet_ptys[minor];

  switch (args->command) {

    case TIOCGWINSZ:

      wp->ws_row = p->height;
      wp->ws_col = p->width;
      args->ioctl_return=0;
#if DEBUG & DEBUG_WH
      fprintf(stderr,
          "ioctl(TIOCGWINSZ), returning %ix%i\n",
          wp->ws_col,
          wp->ws_row);
#endif

      return RTEMS_SUCCESSFUL;

    case TIOCSWINSZ:
#if DEBUG & DEBUG_WH
      fprintf(stderr,
          "ioctl(TIOCGWINSZ), setting %ix%i\n",
          wp->ws_col,
          wp->ws_row);
#endif

      p->height = wp->ws_row;
      p->width  = wp->ws_col;
      args->ioctl_return=0;

      return RTEMS_SUCCESSFUL;

    default:

        break;
  }

  return rtems_termios_ioctl(arg);
}

static rtems_driver_address_table drvPty = {
    my_pty_initialize,
    my_pty_open,
    my_pty_close,
    my_pty_read,
    my_pty_write,
    my_pty_control
};

/*-----------------------------------------------------------*/
static const rtems_termios_callbacks pty_poll_callbacks = {
  ptyPollInitialize,    /* FirstOpen*/
  ptyShutdown,          /* LastClose*/
  ptyPollRead,          /* PollRead  */
  ptyPollWrite,         /* Write */
  ptySetAttributes,     /* setAttributes */
  NULL,                 /* stopRemoteTX */
  NULL,                 /* StartRemoteTX */
  0                     /* outputUsesInterrupts */
};
/*-----------------------------------------------------------*/
static const rtems_termios_callbacks * pty_get_termios_handlers(int polled) {
  return &pty_poll_callbacks;
}
/*-----------------------------------------------------------*/

static int pty_do_initialize()
{
  if ( !telnet_pty_inited ) {
    if (RTEMS_SUCCESSFUL==rtems_io_register_driver(0, &drvPty, &pty_major))
      telnet_pty_inited=TRUE;
    else
      fprintf(stderr,"WARNING: registering the PTY driver FAILED\n");
  }
  return telnet_pty_inited;
}

#ifdef __cplusplus

class TelnetPtyIni {
public:
  TelnetPtyIni() { if (!nest++) {
            pty_do_initialize();
        }
       };
  ~TelnetPtyIni(){ if (!--nest) {
            pty_do_finalize();
        }
       };
private:
static int nest;
};

static TelnetPtyIni onlyInst;
int TelnetPtyIni::nest=0;

int telnet_pty_initialize()
{
  return telnet_pty_inited;
}

int telnet_pty_finalize()
{
  return telnet_pty_inited;
}
};
#else
int telnet_pty_initialize()
{
  return pty_do_initialize();
}

int telnet_pty_finalize()
{
  return pty_do_finalize();
}
#endif