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