apps/vms_term_sock.c

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