src/hftctl.c

   1 /* IBM has disclaimed copyright on this module.  */
   2
   3 /***************************************************************/
   4 /*                                                             */
   5 /* Function: hftctl                                            */
   6 /*                                                             */
   7 /* Syntax:                                                     */
   8 /*    #include <sys/ioctl.h>                                   */
   9 /*    #include <sys/hft.h>                                     */
  10 /*                                                             */
  11 /*    int hftctl(fildes, request, arg )                        */
  12 /*    int fildes, request ;                                    */
  13 /*    char *arg ;                                              */
  14 /*                                                             */
  15 /* Description:                                                */
  16 /*                                                             */
  17 /*    Does the following:                                      */
  18 /*      1. determines if fildes is pty                         */
  19 /*         does normal ioctl it is not                         */
  20 /*      2. places fildes into raw mode                         */
  21 /*      3. converts ioctl arguments to datastream              */
  22 /*      4. waits for 2 secs for acknowledgement before         */
  23 /*         timimg out.                                         */
  24 /*      5. places response in callers buffer ( just like       */
  25 /*         ioctl.                                              */
  26 /*      6. returns fildes to its original mode                 */
  27 /*                                                             */
  28 /*    User of this program should review steps 1,4, and 3.     */
  29 /*    hftctl makes no check on the request type. It must be    */
  30 /*    a HFT ioctl that is supported remotely.                  */
  31 /*    This program will use the SIGALRM and alarm(2).  Any     */
  32 /*    Previous alarms are lost.                                */
  33 /*                                                             */
  34 /*    Users of this program are free to modify it any way      */
  35 /*    they want.                                               */
  36 /*                                                             */
  37 /* Return Value:                                               */
  38 /*                                                             */
  39 /*    If ioctl fails, a value of -1 is returned and errno      */
  40 /*    is set to indicate the error.                            */
  41 /*                                                             */
  42 /***************************************************************/
  43
  44
  45 #include <stdio.h>
  46 #include <fcntl.h>
  47 #include <errno.h>
  48 #include <setjmp.h>
  49 #include <sys/ioctl.h>
  50 #include <sys/signal.h>
  51 #include <sys/devinfo.h>
  52 #include <termio.h>
  53 #include <sys/hft.h>
  54 #include <termios.h>
  55 #include <sys/tty.h>
  56 /* #include <sys/pty.h> */
  57 #define REMOTE 0x01
  58
  59 #undef ioctl
  60 static char     SCCSid[] = "com/gnuemacs/src,3.1,9021-90/05/03-5/3/90" ;
  61
  62 /*************** LOCAL DEFINES **********************************/
  63
  64 typedef int     (*FUNC)() ;     /* pointer to a function        */
  65
  66 #define QDEV   ((HFQPDEVCH<<8)|HFQPDEVCL)
  67 #define QLOC   ((HFQLOCCH<<8)|HFQLOCCL)
  68 #define QPS    ((HFQPRESCH<<8)|HFQPRESCL)
  69
  70 /*************** EXTERNAL / GLOBAL DATA AREA ********************/
  71
  72        int              hfqry() ;
  73        int              hfskbd() ;
  74        char            *malloc() ;
  75
  76 extern int              errno ;
  77 static jmp_buf          hftenv ;
  78 static int              is_ack_vtd ;
  79 static FUNC             sav_alrm ;
  80 static struct hfctlreq  req =
  81                         { 0x1b,'[','x',0,0,0,21,HFCTLREQCH,HFCTLREQCL};
  82 static struct hfctlack  ACK =
  83                         { 0x1b,'[','x',0,0,0,21,HFCTLACKCH,HFCTLACKCL};
  84
  85        /* FUNC             signal() ; */
  86
  87 /*************** LOCAL MACROS ***********************************/
  88
  89 #define HFTYPE(p)   ((p->hf_typehi<<8)|(p->hf_typelo))
  90
  91 #define BYTE4(p)    ( (p)[0]<<24 | (p)[1]<<16 | (p)[2]<<8 | (p)[3] )
  92
  93                                         /* read a buffer        */
  94 #define RD_BUF(f,p,l) \
  95         while ( (l) ) \
  96           if ( ( j = read((f),(p),(l)) ) < 0 ) \
  97              if ( errno != EINTR ) return (-1) ; \
  98              else continue ; \
  99           else { (l)-=j ; (p)+=j ; }
 100
 101 /*************** HFTCTL FUNCTION *******************************/
 102
 103 hftctl( fd, request, arg )
 104         int     fd ;
 105         int     request ;
 106         union {
 107         struct hfintro *intro ;
 108         struct hfquery *query ;
 109         char           *c ;
 110         }       arg ;
 111 {
 112
 113         int             i ;
 114         int             fd_flag ;       /* fcntl flags          */
 115 register union {
 116  struct hfintro         *cmd ;          /* p.cmd - intro des.   */
 117  struct hfqphdevc       *ph ;           /* p.ph  - physical dev.*/
 118         char            *c ;            /* p.c   - char ptr     */
 119         }               p ;             /* general pointer      */
 120         int             pty_new ;       /* pty modes            */
 121         int             pty_old ;
 122         int             retcode ;
 123         struct termios   term_new ;      /* terminal attributes  */
 124         struct termios   term_old ;
 125         struct devinfo  devInfo ;       /* defined in sys/devinfo.h */
 126
 127
 128 if ( ioctl( fd, IOCINFO, &devInfo ) == -1 ) return(-1) ;
 129
 130 if ( devInfo.devtype != DD_PSEU )       /* is it a pty? */
 131    return (ioctl(fd, request, arg) ) ;  /* no, do IOCTL */
 132
 133                                 /******* START PTY **************/
 134                                 /**  Pty found, possible HFT    */
 135                                 /** set new file des as raw     */
 136                                 /** as you can.                 */
 137                                 /********************************/
 138
 139                                 /* Get current state of file    */
 140                                 /* descriptor & save            */
 141 if ( ( fd_flag = fcntl( fd, F_GETFL, 0 ) ) == -1 ) return (-1) ;
 142 if ( ioctl( fd, TCGETS, &term_old ) == -1 ) return (-1) ;
 143                                 /* set terminal attr to raw     */
 144                                 /* and to delay on read         */
 145 pty_new = pty_old | REMOTE ;
 146 memcpy( &term_new, &term_old, sizeof( term_new ) ) ;
 147 term_new.c_iflag = 0 ;
 148 term_new.c_oflag = 0 ;
 149 term_new.c_lflag = 0 ;
 150 /* term_new.c_line  = 0 ; */
 151 for ( i = 1 ; i <= 5 ; i++ )
 152 term_new.c_cc[i] = 0 ;
 153 term_new.c_cc[0] = -1 ;
 154 ioctl( fd, TCSETS, &term_new ) ;
 155 if ( fcntl( fd, F_SETFL, fd_flag & ~O_NDELAY ) == -1 )
 156    return(-1) ;
 157                                 /* call spacific function       */
 158 if ( request == HFSKBD )
 159    retcode = hfskbd( fd, request, arg.c) ;
 160 else /* assume HFQUERY */
 161    retcode = hfqry( fd, request, arg.c) ;
 162
 163 fcntl( fd, F_SETFL, fd_flag ) ; /* reset terminal to original   */
 164 ioctl( fd, TCSETS, &term_old ) ;
 165
 166
 167 return( retcode ) ;             /* return error                 */
 168 }
 169
 170 /*************** HFSKBD  FUNCTION ******************************/
 171 static hfskbd(fd, request, arg )
 172         int     fd ;
 173         int     request ;
 174         struct hfbuf *arg ;
 175 {
 176 WR_REQ(fd, request, arg->hf_buflen, arg->hf_bufp,0) ;
 177 return( GT_ACK(fd, request, arg->hf_bufp) ) ;
 178 }
 179
 180 /*************** HFQUERY FUNCTION ******************************/
 181 static hfqry(fd, request, arg )
 182         int     fd ;
 183         int     request ;
 184         struct hfquery *arg ;
 185 {
 186 WR_REQ(fd, request, arg->hf_cmdlen, arg->hf_cmd, arg->hf_resplen ) ;
 187 return( GT_ACK(fd, request, arg->hf_resp ) ) ;
 188 }
 189
 190
 191 /*************** GT_ACK FUNCTION ******************************/
 192 static GT_ACK(fd, req, buf )
 193         int     fd ;
 194         int     req ;
 195         char   *buf ;
 196 {
 197
 198         struct hfctlack ack ;
 199         int             i = sizeof( ack ) ;
 200         int             j = 0 ;
 201         union {
 202         char            *c ;
 203         struct hfctlack *ack ;
 204         }               p ;
 205
 206         int             hft_alrm() ;
 207
 208 is_ack_vtd = 0 ;                        /* flag no ACT VTD yet         */
 209
 210 if ( setjmp( hftenv ) )                 /* set environment in case     */
 211    {                                    /* of time out                 */
 212    errno=ENODEV ;                       /* if time out, set errno      */
 213    return( -1 ) ;                       /* flag error                  */
 214    }
 215
 216 alarm(3) ;                              /* time out in 3 secs          */
 217 sav_alrm = signal( SIGALRM, hft_alrm ) ;/* prepare to catch time out   */
 218
 219 p.ack = &ack ;
 220 while ( ! is_ack_vtd )                  /* do until valid ACK VTD      */
 221   {
 222   RD_BUF(fd, p.c, i ) ;                 /* read until a ACK VTD is fill*/
 223
 224   if ( ! memcmp( &ack, &ACK, sizeof( HFINTROSZ ) ) /* the ACK intro &  */
 225        && ( ack.hf_request == req ) )   /* is it the response we want ?*/
 226      {                                  /* yes, ACK VTD found          */
 227      is_ack_vtd = 1 ;                   /* quickly, flag it            */
 228      break ;                            /* get the %$%#@ out of here   */
 229      }
 230
 231   p.ack = &ack ;                        /* no, then skip 1st           */
 232   ++p.c ;                               /* char and start over         */
 233   i = sizeof( ack ) - 1 ;               /* one less ESC to cry over    */
 234
 235   while( ( *p.c != 0x1b ) && i )        /* scan for next ESC           */
 236      { ++p.c ; --i ; }                  /* if any                      */
 237
 238   ( i ? memcpy( &ack, p.c, i ) : 0 ) ;  /* if any left over, then move */
 239   p.ack = &ack ;                        /* ESC to front of ack struct  */
 240   p.c += i ;                            /* skip over whats been read   */
 241   i = sizeof( ack ) - i ;               /* set whats left to be read   */
 242   }                                     /***** TRY AGAIN               */
 243
 244 alarm(0) ;                              /* ACK VTD received, reset alrm*/
 245 signal( SIGALRM, sav_alrm ) ;           /* reset signal                */
 246
 247 if ( i = ack.hf_arg_len )               /* any data following ?        */
 248    {                                    /* yes,                        */
 249    RD_BUF(fd,buf,i) ;                   /* read until it is received   */
 250    }
 251
 252 if ( errno = ack.hf_retcode )           /* set errno based on returned */
 253    return (-1) ;                         /* code, if 0, then no error   */
 254 else
 255    return (0) ;                        /* if set, then error returned */
 256 }
 257
 258 /*************** HFT_ALRM FUNCTION ******************************/
 259 static hft_alrm(sig)                    /* Function hft_alrm - handle  */
 260         int             sig ;           /* alarm signal               */
 261 {
 262 signal( SIGALRM, sav_alrm ) ;           /* reset to previous          */
 263
 264 if ( is_ack_vtd )                       /* has ack vtd arrived ?      */
 265    return(0) ;                          /* yes, then continue         */
 266 else                                    /* no, then return with error */
 267    longjmp( hftenv, -1 ) ;
 268
 269 }
 270
 271 /*********************************************************************/
 272 /***                                                               ***/
 273 /***  NOTE: Both the HFCTLREQ and the arg structure should be      ***/
 274 /***        sent in one io write operation.  If terminal           ***/
 275 /***        emulators are in NODELAY mode then multiple writes     ***/
 276 /***        may cause bogus information to be read by the emulator ***/
 277 /***        depending on the timing.                               ***/
 278 /***                                                               ***/
 279 /*********************************************************************/
 280
 281 static WR_REQ(fd, request, cmdlen, cmd, resplen )
 282         int             fd ;
 283         int             request ;
 284         int             cmdlen ;
 285         char           *cmd ;
 286         int             resplen ;
 287 {
 288         struct {
 289         char            *c ;
 290         struct hfctlreq *req ;
 291         }              p ;
 292         int            size ;
 293
 294         req.hf_request = request ;
 295         req.hf_arg_len = cmdlen ;
 296         req.hf_rsp_len = resplen ;
 297
 298 if ( cmdlen )                           /* if arg structure to pass    */
 299    {
 300    size = sizeof( struct hfctlreq ) + cmdlen ;
 301    if ( ( p.c = malloc(size) ) == NULL ) /* malloc one area            */
 302       return( -1 ) ;
 303
 304    memcpy( p.c, &req, sizeof( req ) ) ; /* copy CTL REQ struct         */
 305    memcpy( p.c + sizeof( req ), cmd, cmdlen ) ; /* copy arg struct     */
 306    }
 307 else
 308    {
 309    p.req = &req ;                       /* otherwise use only CTL REQ  */
 310    size = sizeof( req ) ;
 311    }
 312
 313                                         /* write request to terminal   */
 314 if ( write(fd,p.c,size) == -1 ) return (-1) ;
 315 if ( p.req != &req )                    /* free if allocated           */
 316    free( p.c ) ;
 317 return (0) ;
 318
 319 }