apps/vms_term_sock.c

   1 /*
   2  * Copyright 2016 VMS Software, Inc. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #ifdef __VMS
  11 #define OPENSSL_SYS_VMS
  12 #pragma message disable DOLLARID
  13
  14
  15 #include <openssl/OPENSSLCONF.H>
  16
  17 #if !defined(_POSIX_C_SOURCE) && defined(OPENSSL_SYS_VMS)
  18 /*
  19  * On VMS, you need to define this to get the declaration of fileno().  The
  20  * value 2 is to make sure no function defined in POSIX-2 is left undefined.
  21  */
  22 # define _POSIX_C_SOURCE 2
  23 #endif
  24
  25 #include <stdio.h>
  26
  27 #undef _POSIX_C_SOURCE
  28
  29 #include <sys/types.h>
  30 #include <sys/socket.h>
  31 #include <netinet/in.h>
  32 #include <inet.h>
  33 #include <unistd.h>
  34 #include <string.h>
  35 #include <errno.h>
  36 #include <starlet.h>
  37 #include <iodef.h>
  38 #ifdef __alpha
  39 #include <iosbdef.h>
  40 #else
  41 typedef struct _iosb {                  /* Copied from IOSBDEF.H for Alpha  */
  42 #pragma __nomember_alignment
  43     __union  {
  44         __struct  {
  45             unsigned short int iosb$w_status; /* Final I/O status           */
  46             __union  {
  47                 __struct  {             /* 16-bit byte count variant        */
  48                     unsigned short int iosb$w_bcnt; /* 16-bit byte count    */
  49                     __union  {
  50                         unsigned int iosb$l_dev_depend; /* 32-bit device dependent info */
  51                         unsigned int iosb$l_pid; /* 32-bit pid              */
  52                         } iosb$r_l;
  53                     } iosb$r_bcnt_16;
  54                 __struct  {             /* 32-bit byte count variant        */
  55                     unsigned int iosb$l_bcnt; /* 32-bit byte count (unaligned) */
  56                     unsigned short int iosb$w_dev_depend_high; /* 16-bit device dependent info */
  57                     } iosb$r_bcnt_32;
  58                 } iosb$r_devdepend;
  59             } iosb$r_io_64;
  60         __struct  {
  61             __union  {
  62                 unsigned int iosb$l_getxxi_status; /* Final GETxxI status   */
  63                 unsigned int iosb$l_reg_status; /* Final $Registry status   */
  64                 } iosb$r_l_status;
  65             unsigned int iosb$l_reserved; /* Reserved field                 */
  66             } iosb$r_get_64;
  67         } iosb$r_io_get;
  68     } IOSB;
  69
  70 #if !defined(__VAXC)
  71 #define iosb$w_status iosb$r_io_get.iosb$r_io_64.iosb$w_status
  72 #define iosb$w_bcnt iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_16.iosb$w_bcnt
  73 #define iosb$r_l        iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_16.iosb$r_l
  74 #define iosb$l_dev_depend iosb$r_l.iosb$l_dev_depend
  75 #define iosb$l_pid iosb$r_l.iosb$l_pid
  76 #define iosb$l_bcnt iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_32.iosb$l_bcnt
  77 #define iosb$w_dev_depend_high iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_32.iosb$w_dev_depend_high
  78 #define iosb$l_getxxi_status iosb$r_io_get.iosb$r_get_64.iosb$r_l_status.iosb$l_getxxi_status
  79 #define iosb$l_reg_status iosb$r_io_get.iosb$r_get_64.iosb$r_l_status.iosb$l_reg_status
  80 #endif          /* #if !defined(__VAXC) */
  81
  82 #endif                                  /* End of IOSBDEF */
  83
  84 #include <efndef.h>
  85 #include <stdlib.h>
  86 #include <ssdef.h>
  87 #include <time.h>
  88 #include <stdarg.h>
  89 #include <descrip.h>
  90
  91 #include "vms_term_sock.h"
  92
  93 #ifdef __alpha
  94 static struct _iosb TerminalDeviceIosb;
  95 #else
  96 IOSB TerminalDeviceIosb;
  97 #endif
  98
  99 static char TerminalDeviceBuff[255 + 2];
 100 static int TerminalSocketPair[2] = {0, 0};
 101 static unsigned short TerminalDeviceChan = 0;
 102
 103 static int CreateSocketPair (int, int, int, int *);
 104 static void SocketPairTimeoutAst (int);
 105 static int TerminalDeviceAst (int);
 106 static void LogMessage (char *, ...);
 107
 108 /*
 109 ** Socket Pair Timeout Value (must be 0-59 seconds)
 110 */
 111 #define SOCKET_PAIR_TIMEOUT_VALUE 20
 112
 113 /*
 114 ** Socket Pair Timeout Block which is passed to timeout AST
 115 */
 116 typedef struct _SocketPairTimeoutBlock {
 117     unsigned short SockChan1;
 118     unsigned short SockChan2;
 119     } SPTB;
 120
 121 #ifdef TERM_SOCK_TEST
 122 \f
 123 /*----------------------------------------------------------------------------*/
 124 /*                                                                            */
 125 /*----------------------------------------------------------------------------*/
 126 int main (int argc, char *argv[], char *envp[])
 127 {
 128 char TermBuff[80];
 129 int TermSock,
 130     status,
 131     len;
 132
 133 LogMessage ("Enter 'q' or 'Q' to quit ...");
 134 while (strcasecmp (TermBuff, "Q"))
 135     {
 136     /*
 137     ** Create the terminal socket
 138     */
 139     status = TerminalSocket (TERM_SOCK_CREATE, &TermSock);
 140     if (status != TERM_SOCK_SUCCESS)
 141         exit (1);
 142
 143     /*
 144     ** Process the terminal input
 145     */
 146     LogMessage ("Waiting on terminal I/O ...\n");
 147     len = recv (TermSock, TermBuff, sizeof (TermBuff), 0) ;
 148     TermBuff[len] = '\0';
 149     LogMessage ("Received terminal I/O [%s]", TermBuff);
 150
 151     /*
 152     ** Delete the terminal socket
 153     */
 154     status = TerminalSocket (TERM_SOCK_DELETE, &TermSock);
 155     if (status != TERM_SOCK_SUCCESS)
 156         exit (1);
 157     }
 158
 159 return 1;
 160
 161 }
 162 #endif
 163 \f
 164 /*----------------------------------------------------------------------------*/
 165 /*                                                                            */
 166 /*----------------------------------------------------------------------------*/
 167 int TerminalSocket (int FunctionCode, int *ReturnSocket)
 168 {
 169 int status;
 170 $DESCRIPTOR (TerminalDeviceDesc, "SYS$COMMAND");
 171
 172 /*
 173 ** Process the requested function code
 174 */
 175 switch (FunctionCode)
 176    {
 177    case TERM_SOCK_CREATE:
 178         /*
 179         ** Create a socket pair
 180         */
 181         status = CreateSocketPair (AF_INET, SOCK_STREAM, 0, TerminalSocketPair);
 182         if (status == -1)
 183             {
 184             LogMessage ("TerminalSocket: CreateSocketPair () - %08X", status);
 185             if (TerminalSocketPair[0])
 186                 close (TerminalSocketPair[0]);
 187             if (TerminalSocketPair[1])
 188                 close (TerminalSocketPair[1]);
 189             return (TERM_SOCK_FAILURE);
 190             }
 191
 192         /*
 193         ** Assign a channel to the terminal device
 194         */
 195         status = sys$assign (&TerminalDeviceDesc,
 196                              &TerminalDeviceChan,
 197                              0, 0, 0);
 198         if (! (status & 1))
 199             {
 200             LogMessage ("TerminalSocket: SYS$ASSIGN () - %08X", status);
 201             close (TerminalSocketPair[0]);
 202             close (TerminalSocketPair[1]);
 203             return (TERM_SOCK_FAILURE);
 204             }
 205
 206         /*
 207         ** Queue an async IO to the terminal device
 208         */
 209         status = sys$qio (EFN$C_ENF,
 210                           TerminalDeviceChan,
 211                           IO$_READVBLK,
 212                           &TerminalDeviceIosb,
 213                           TerminalDeviceAst,
 214                           0,
 215                           TerminalDeviceBuff,
 216                           sizeof (TerminalDeviceBuff) - 2,
 217                           0, 0, 0, 0);
 218         if (! (status & 1))
 219             {
 220             LogMessage ("TerminalSocket: SYS$QIO () - %08X", status);
 221             close (TerminalSocketPair[0]);
 222             close (TerminalSocketPair[1]);
 223             return (TERM_SOCK_FAILURE);
 224             }
 225
 226         /*
 227         ** Return the input side of the socket pair
 228         */
 229         *ReturnSocket = TerminalSocketPair[1];
 230         break;
 231
 232    case TERM_SOCK_DELETE:
 233         /*
 234         ** Cancel any pending IO on the terminal channel
 235         */
 236         status = sys$cancel (TerminalDeviceChan);
 237         if (! (status & 1))
 238             {
 239             LogMessage ("TerminalSocket: SYS$CANCEL () - %08X", status);
 240             close (TerminalSocketPair[0]);
 241             close (TerminalSocketPair[1]);
 242             return (TERM_SOCK_FAILURE);
 243             }
 244
 245         /*
 246         ** Deassign the terminal channel
 247         */
 248         status = sys$dassgn (TerminalDeviceChan);
 249         if (! (status & 1))
 250             {
 251             LogMessage ("TerminalSocket: SYS$DASSGN () - %08X", status);
 252             close (TerminalSocketPair[0]);
 253             close (TerminalSocketPair[1]);
 254             return (TERM_SOCK_FAILURE);
 255             }
 256
 257         /*
 258         ** Close the terminal socket pair
 259         */
 260         close (TerminalSocketPair[0]);
 261         close (TerminalSocketPair[1]);
 262
 263         /*
 264         ** Return the initialized socket
 265         */
 266         *ReturnSocket = 0;
 267         break;
 268
 269     default:
 270         /*
 271         ** Invalid function code
 272         */
 273         LogMessage ("TerminalSocket: Invalid Function Code - %d", FunctionCode);
 274         return (TERM_SOCK_FAILURE);
 275         break;
 276     }
 277
 278 /*
 279 ** Return success
 280 */
 281 return (TERM_SOCK_SUCCESS);
 282
 283 }
 284 \f
 285 /*----------------------------------------------------------------------------*/
 286 /*                                                                            */
 287 /*----------------------------------------------------------------------------*/
 288 static int CreateSocketPair (
 289     int         SocketFamily,
 290     int         SocketType,
 291     int         SocketProtocol,
 292     int         *SocketPair)
 293 {
 294 struct dsc$descriptor AscTimeDesc = {0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL};
 295 static const char* LocalHostAddr = {"127.0.0.1"};
 296 unsigned short TcpAcceptChan = 0,
 297                TcpDeviceChan = 0;
 298 unsigned long BinTimeBuff[2];
 299 struct sockaddr_in sin;
 300 char AscTimeBuff[32];
 301 short LocalHostPort;
 302 int status;
 303 unsigned int slen;
 304
 305 #ifdef __alpha
 306 struct _iosb iosb;
 307 #else
 308 IOSB iosb;
 309 #endif
 310
 311 int SockDesc1 = 0,
 312     SockDesc2 = 0;
 313 SPTB sptb;
 314 $DESCRIPTOR (TcpDeviceDesc, "TCPIP$DEVICE");
 315
 316 /*
 317 ** Create a socket
 318 */
 319 SockDesc1 = socket (SocketFamily, SocketType, 0);
 320 if (SockDesc1 < 0)
 321     {
 322     LogMessage ("CreateSocketPair: socket () - %d", errno);
 323     return (-1);
 324     }
 325
 326 /*
 327 ** Initialize the socket information
 328 */
 329 slen = sizeof (sin);
 330 memset ((char *) &sin, 0, slen);
 331 sin.sin_family = SocketFamily;
 332 sin.sin_addr.s_addr = inet_addr (LocalHostAddr);
 333 sin.sin_port = 0;
 334
 335 /*
 336 ** Bind the socket to the local IP
 337 */
 338 status = bind (SockDesc1, (struct sockaddr *) &sin, slen);
 339 if (status < 0)
 340     {
 341     LogMessage ("CreateSocketPair: bind () - %d", errno);
 342     close (SockDesc1);
 343     return (-1);
 344     }
 345
 346 /*
 347 ** Get the socket name so we can save the port number
 348 */
 349 status = getsockname (SockDesc1, (struct sockaddr *) &sin, &slen);
 350 if (status < 0)
 351     {
 352     LogMessage ("CreateSocketPair: getsockname () - %d", errno);
 353     close (SockDesc1);
 354     return (-1);
 355     }
 356 else
 357     LocalHostPort = sin.sin_port;
 358
 359 /*
 360 ** Setup a listen for the socket
 361 */
 362 listen (SockDesc1, 5);
 363
 364 /*
 365 ** Get the binary (64-bit) time of the specified timeout value
 366 */
 367 sprintf (AscTimeBuff, "0 0:0:%02d.00", SOCKET_PAIR_TIMEOUT_VALUE);
 368 AscTimeDesc.dsc$w_length = strlen (AscTimeBuff);
 369 AscTimeDesc.dsc$a_pointer = AscTimeBuff;
 370 status = sys$bintim (&AscTimeDesc, BinTimeBuff);
 371 if (! (status & 1))
 372     {
 373     LogMessage ("CreateSocketPair: SYS$BINTIM () - %08X", status);
 374     close (SockDesc1);
 375     return (-1);
 376     }
 377
 378 /*
 379 ** Assign another channel to the TCP/IP device for the accept.
 380 ** This is the channel that ends up being connected to.
 381 */
 382 status = sys$assign (&TcpDeviceDesc, &TcpDeviceChan, 0, 0, 0);
 383 if (! (status & 1))
 384     {
 385     LogMessage ("CreateSocketPair: SYS$ASSIGN () - %08X", status);
 386     close (SockDesc1);
 387     return (-1);
 388     }
 389
 390 /*
 391 ** Get the channel of the first socket for the accept
 392 */
 393 TcpAcceptChan = decc$get_sdc (SockDesc1);
 394
 395 /*
 396 ** Perform the accept using $QIO so we can do this asynchronously
 397 */
 398 status = sys$qio (EFN$C_ENF,
 399                   TcpAcceptChan,
 400                   IO$_ACCESS | IO$M_ACCEPT,
 401                   &iosb,
 402                   0, 0, 0, 0, 0,
 403                   &TcpDeviceChan,
 404                   0, 0);
 405 if (! (status & 1))
 406     {
 407     LogMessage ("CreateSocketPair: SYS$QIO () - %08X", status);
 408     close (SockDesc1);
 409     sys$dassgn (TcpDeviceChan);
 410     return (-1);
 411     }
 412
 413 /*
 414 ** Create the second socket to do the connect
 415 */
 416 SockDesc2 = socket (SocketFamily, SocketType, 0);
 417 if (SockDesc2 < 0)
 418     {
 419     LogMessage ("CreateSocketPair: socket () - %d", errno);
 420     sys$cancel (TcpAcceptChan);
 421     close (SockDesc1);
 422     sys$dassgn (TcpDeviceChan);
 423     return (-1) ;
 424     }
 425
 426 /*
 427 ** Setup the Socket Pair Timeout Block
 428 */
 429 sptb.SockChan1 = TcpAcceptChan;
 430 sptb.SockChan2 = decc$get_sdc (SockDesc2);
 431
 432 /*
 433 ** Before we block on the connect, set a timer that can cancel I/O on our two
 434 ** sockets if it never connects.
 435 */
 436 status = sys$setimr (EFN$C_ENF,
 437                      BinTimeBuff,
 438                      SocketPairTimeoutAst,
 439                      &sptb,
 440                      0);
 441 if (! (status & 1))
 442     {
 443     LogMessage ("CreateSocketPair: SYS$SETIMR () - %08X", status);
 444     sys$cancel (TcpAcceptChan);
 445     close (SockDesc1);
 446     close (SockDesc2);
 447     sys$dassgn (TcpDeviceChan);
 448     return (-1);
 449     }
 450
 451 /*
 452 ** Now issue the connect
 453 */
 454 memset ((char *) &sin, 0, sizeof (sin)) ;
 455 sin.sin_family = SocketFamily;
 456 sin.sin_addr.s_addr = inet_addr (LocalHostAddr) ;
 457 sin.sin_port = LocalHostPort ;
 458
 459 status = connect (SockDesc2, (struct sockaddr *) &sin, sizeof (sin));
 460 if (status < 0 )
 461     {
 462     LogMessage ("CreateSocketPair: connect () - %d", errno);
 463     sys$cantim (&sptb, 0);
 464     sys$cancel (TcpAcceptChan);
 465     close (SockDesc1);
 466     close (SockDesc2);
 467     sys$dassgn (TcpDeviceChan);
 468     return (-1);
 469     }
 470
 471 /*
 472 ** Wait for the asynch $QIO to finish.  Note that if the I/O was aborted
 473 ** (SS$_ABORT), then we probably canceled it from the AST routine - so log a
 474 ** timeout.
 475 */
 476 status = sys$synch (EFN$C_ENF, &iosb);
 477 if (! (iosb.iosb$w_status & 1))
 478     {
 479     if (iosb.iosb$w_status == SS$_ABORT)
 480         LogMessage ("CreateSocketPair: SYS$QIO(iosb) timeout");
 481     else
 482         {
 483         LogMessage ("CreateSocketPair: SYS$QIO(iosb) - %d", iosb.iosb$w_status);
 484         sys$cantim (&sptb, 0);
 485         }
 486     close (SockDesc1);
 487     close (SockDesc2);
 488     sys$dassgn (TcpDeviceChan);
 489     return (-1);
 490     }
 491
 492 /*
 493 ** Here we're successfully connected, so cancel the timer, convert the I/O
 494 ** channel to a socket fd, close the listener socket and return the connected
 495 ** pair.
 496 */
 497 sys$cantim (&sptb, 0);
 498
 499 close (SockDesc1) ;
 500 SocketPair[0] = SockDesc2 ;
 501 SocketPair[1] = socket_fd (TcpDeviceChan);
 502
 503 return (0) ;
 504
 505 }
 506 \f
 507 /*----------------------------------------------------------------------------*/
 508 /*                                                                            */
 509 /*----------------------------------------------------------------------------*/
 510 static void SocketPairTimeoutAst (int astparm)
 511 {
 512 SPTB *sptb = (SPTB *) astparm;
 513
 514 sys$cancel (sptb->SockChan2);                   /* Cancel the connect() */
 515 sys$cancel (sptb->SockChan1);                   /* Cancel the accept()  */
 516
 517 return;
 518
 519 }
 520 \f
 521 /*----------------------------------------------------------------------------*/
 522 /*                                                                            */
 523 /*----------------------------------------------------------------------------*/
 524 static int TerminalDeviceAst (int astparm)
 525 {
 526 int status;
 527
 528 /*
 529 ** Terminate the terminal buffer
 530 */
 531 TerminalDeviceBuff[TerminalDeviceIosb.iosb$w_bcnt] = '\0';
 532 strcat (TerminalDeviceBuff, "\n");
 533
 534 /*
 535 ** Send the data read from the terminal device throught the socket pair
 536 */
 537 send (TerminalSocketPair[0], TerminalDeviceBuff, TerminalDeviceIosb.iosb$w_bcnt + 1, 0);
 538
 539 /*
 540 ** Queue another async IO to the terminal device
 541 */
 542 status = sys$qio (EFN$C_ENF,
 543                   TerminalDeviceChan,
 544                   IO$_READVBLK,
 545                   &TerminalDeviceIosb,
 546                   TerminalDeviceAst,
 547                   0,
 548                   TerminalDeviceBuff,
 549                   sizeof (TerminalDeviceBuff) - 1,
 550                   0, 0, 0, 0);
 551
 552 /*
 553 ** Return status
 554 */
 555 return status;
 556
 557 }
 558 \f
 559 /*----------------------------------------------------------------------------*/
 560 /*                                                                            */
 561 /*----------------------------------------------------------------------------*/
 562 static void LogMessage (char *msg, ...)
 563 {
 564 char *Month[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
 565                  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
 566 static unsigned int pid = 0;
 567 va_list args;
 568 time_t CurTime;
 569 struct tm *LocTime;
 570 char MsgBuff[256];
 571
 572 /*
 573 ** Get the process pid
 574 */
 575 if (pid == 0)
 576     pid = getpid ();
 577
 578 /*
 579 ** Convert the current time into local time
 580 */
 581 CurTime = time (NULL);
 582 LocTime = localtime (&CurTime);
 583
 584 /*
 585 ** Format the message buffer
 586 */
 587 sprintf (MsgBuff, "%02d-%s-%04d %02d:%02d:%02d [%08X] %s\n",
 588          LocTime->tm_mday, Month[LocTime->tm_mon], (LocTime->tm_year + 1900),
 589          LocTime->tm_hour, LocTime->tm_min, LocTime->tm_sec, pid, msg);
 590
 591 /*
 592 ** Get any variable arguments and add them to the print of the message buffer
 593 */
 594 va_start (args, msg);
 595 vfprintf (stderr, MsgBuff, args);
 596 va_end (args);
 597
 598 /*
 599 ** Flush standard error output
 600 */
 601 fsync (fileno (stderr));
 602
 603 return;
 604
 605 }
 606 #endif