openssl/apps/lib/vms_term_sock.c

/*
 * Copyright 2016-2022 The OpenSSL Project Authors. All Rights Reserved.
 * Copyright 2016 VMS Software, Inc. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

#ifdef __VMS
#define OPENSSL_SYS_VMS
#pragma message disable DOLLARID

#include <openssl/opensslconf.h>

#if !defined(_POSIX_C_SOURCE) && defined(OPENSSL_SYS_VMS)
/*
 * On VMS, you need to define this to get the declaration of fileno().  The
 * value 2 is to make sure no function defined in POSIX-2 is left undefined.
 */
#define _POSIX_C_SOURCE 2
#endif

#include <stdio.h>

#undef _POSIX_C_SOURCE

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <inet.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <starlet.h>
#include <iodef.h>
#ifdef __alpha
#include <iosbdef.h>
#else
typedef struct _iosb { /* Copied from IOSBDEF.H for Alpha  */
#pragma __nomember_alignment
    __union
    {
        __struct
        {
            unsigned short int iosb$w_status; /* Final I/O status           */
            __union
            {
                __struct
                { /* 16-bit byte count variant        */
                    unsigned short int iosb$w_bcnt; /* 16-bit byte count    */
                    __union
                    {
                        unsigned int iosb$l_dev_depend; /* 32-bit device dependent info */
                        unsigned int iosb$l_pid; /* 32-bit pid              */
                    }
                    iosb$r_l;
                }
                iosb$r_bcnt_16;
                __struct
                { /* 32-bit byte count variant        */
                    unsigned int iosb$l_bcnt; /* 32-bit byte count (unaligned) */
                    unsigned short int iosb$w_dev_depend_high; /* 16-bit device dependent info */
                }
                iosb$r_bcnt_32;
            }
            iosb$r_devdepend;
        }
        iosb$r_io_64;
        __struct
        {
            __union
            {
                unsigned int iosb$l_getxxi_status; /* Final GETxxI status   */
                unsigned int iosb$l_reg_status; /* Final $Registry status   */
            }
            iosb$r_l_status;
            unsigned int iosb$l_reserved; /* Reserved field                 */
        }
        iosb$r_get_64;
    }
    iosb$r_io_get;
} IOSB;

#if !defined(__VAXC)
#define iosb$w_status iosb$r_io_get.iosb$r_io_64.iosb$w_status
#define iosb$w_bcnt iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_16.iosb$w_bcnt
#define iosb$r_l iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_16.iosb$r_l
#define iosb$l_dev_depend iosb$r_l.iosb$l_dev_depend
#define iosb$l_pid iosb$r_l.iosb$l_pid
#define iosb$l_bcnt iosb$r_io_get.iosb$r_io_64.iosb$r_devdepend.iosb$r_bcnt_32.iosb$l_bcnt
#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
#define iosb$l_getxxi_status iosb$r_io_get.iosb$r_get_64.iosb$r_l_status.iosb$l_getxxi_status
#define iosb$l_reg_status iosb$r_io_get.iosb$r_get_64.iosb$r_l_status.iosb$l_reg_status
#endif /* #if !defined(__VAXC) */

#endif /* End of IOSBDEF */

#include <efndef.h>
#include <stdlib.h>
#include <ssdef.h>
#include <time.h>
#include <stdarg.h>
#include <descrip.h>

#include "vms_term_sock.h"

#ifdef __alpha
static struct _iosb TerminalDeviceIosb;
#else
IOSB TerminalDeviceIosb;
#endif

static char TerminalDeviceBuff[255 + 2];
static int TerminalSocketPair[2] = { 0, 0 };
static unsigned short TerminalDeviceChan = 0;

static int CreateSocketPair(int, int, int, int *);
static void SocketPairTimeoutAst(int);
static int TerminalDeviceAst(int);
static void LogMessage(char *, ...);

/*
** Socket Pair Timeout Value (must be 0-59 seconds)
*/
#define SOCKET_PAIR_TIMEOUT_VALUE 20

/*
** Socket Pair Timeout Block which is passed to timeout AST
*/
typedef struct _SocketPairTimeoutBlock {
    unsigned short SockChan1;
    unsigned short SockChan2;
} SPTB;

#ifdef TERM_SOCK_TEST

/*----------------------------------------------------------------------------*/
/*                                                                            */
/*----------------------------------------------------------------------------*/
int main(int argc, char *argv[], char *envp[])
{
    char TermBuff[80];
    int TermSock,
        status,
        len;

    LogMessage("Enter 'q' or 'Q' to quit ...");
    while (OPENSSL_strcasecmp(TermBuff, "Q")) {
        /*
        ** Create the terminal socket
        */
        status = TerminalSocket(TERM_SOCK_CREATE, &TermSock);
        if (status != TERM_SOCK_SUCCESS)
            exit(1);

        /*
        ** Process the terminal input
        */
        LogMessage("Waiting on terminal I/O ...\n");
        len = recv(TermSock, TermBuff, sizeof(TermBuff), 0);
        TermBuff[len] = '\0';
        LogMessage("Received terminal I/O [%s]", TermBuff);

        /*
        ** Delete the terminal socket
        */
        status = TerminalSocket(TERM_SOCK_DELETE, &TermSock);
        if (status != TERM_SOCK_SUCCESS)
            exit(1);
    }

    return 1;
}
#endif

/*----------------------------------------------------------------------------*/
/*                                                                            */
/*----------------------------------------------------------------------------*/
int TerminalSocket(int FunctionCode, int *ReturnSocket)
{
    int status;
    $DESCRIPTOR(TerminalDeviceDesc, "SYS$COMMAND");

    /*
    ** Process the requested function code
    */
    switch (FunctionCode) {
    case TERM_SOCK_CREATE:
        /*
        ** Create a socket pair
        */
        status = CreateSocketPair(AF_INET, SOCK_STREAM, 0, TerminalSocketPair);
        if (status == -1) {
            LogMessage("TerminalSocket: CreateSocketPair () - %08X", status);
            if (TerminalSocketPair[0])
                close(TerminalSocketPair[0]);
            if (TerminalSocketPair[1])
                close(TerminalSocketPair[1]);
            return TERM_SOCK_FAILURE;
        }

        /*
        ** Assign a channel to the terminal device
        */
        status = sys$assign(&TerminalDeviceDesc,
            &TerminalDeviceChan,
            0, 0, 0);
        if (!(status & 1)) {
            LogMessage("TerminalSocket: SYS$ASSIGN () - %08X", status);
            close(TerminalSocketPair[0]);
            close(TerminalSocketPair[1]);
            return TERM_SOCK_FAILURE;
        }

        /*
        ** Queue an async IO to the terminal device
        */
        status = sys$qio(EFN$C_ENF,
            TerminalDeviceChan,
            IO$_READVBLK,
            &TerminalDeviceIosb,
            TerminalDeviceAst,
            0,
            TerminalDeviceBuff,
            sizeof(TerminalDeviceBuff) - 2,
            0, 0, 0, 0);
        if (!(status & 1)) {
            LogMessage("TerminalSocket: SYS$QIO () - %08X", status);
            close(TerminalSocketPair[0]);
            close(TerminalSocketPair[1]);
            return TERM_SOCK_FAILURE;
        }

        /*
        ** Return the input side of the socket pair
        */
        *ReturnSocket = TerminalSocketPair[1];
        break;

    case TERM_SOCK_DELETE:
        /*
        ** Cancel any pending IO on the terminal channel
        */
        status = sys$cancel(TerminalDeviceChan);
        if (!(status & 1)) {
            LogMessage("TerminalSocket: SYS$CANCEL () - %08X", status);
            close(TerminalSocketPair[0]);
            close(TerminalSocketPair[1]);
            return TERM_SOCK_FAILURE;
        }

        /*
        ** Deassign the terminal channel
        */
        status = sys$dassgn(TerminalDeviceChan);
        if (!(status & 1)) {
            LogMessage("TerminalSocket: SYS$DASSGN () - %08X", status);
            close(TerminalSocketPair[0]);
            close(TerminalSocketPair[1]);
            return TERM_SOCK_FAILURE;
        }

        /*
        ** Close the terminal socket pair
        */
        close(TerminalSocketPair[0]);
        close(TerminalSocketPair[1]);

        /*
        ** Return the initialized socket
        */
        *ReturnSocket = 0;
        break;

    default:
        /*
        ** Invalid function code
        */
        LogMessage("TerminalSocket: Invalid Function Code - %d", FunctionCode);
        return TERM_SOCK_FAILURE;
        break;
    }

    /*
    ** Return success
    */
    return TERM_SOCK_SUCCESS;
}

/*----------------------------------------------------------------------------*/
/*                                                                            */
/*----------------------------------------------------------------------------*/
static int CreateSocketPair(int SocketFamily,
    int SocketType,
    int SocketProtocol,
    int *SocketPair)
{
    struct dsc$descriptor AscTimeDesc = { 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL };
    static const char *LocalHostAddr = { "127.0.0.1" };
    unsigned short TcpAcceptChan = 0,
                   TcpDeviceChan = 0;
    unsigned long BinTimeBuff[2];
    struct sockaddr_in sin;
    char AscTimeBuff[32];
    short LocalHostPort;
    int status;
    unsigned int slen;

#ifdef __alpha
    struct _iosb iosb;
#else
    IOSB iosb;
#endif

    int SockDesc1 = 0,
        SockDesc2 = 0;
    SPTB sptb;
    $DESCRIPTOR(TcpDeviceDesc, "TCPIP$DEVICE");

    /*
    ** Create a socket
    */
    SockDesc1 = socket(SocketFamily, SocketType, 0);
    if (SockDesc1 < 0) {
        LogMessage("CreateSocketPair: socket () - %d", errno);
        return -1;
    }

    /*
    ** Initialize the socket information
    */
    slen = sizeof(sin);
    memset((char *)&sin, 0, slen);
    sin.sin_family = SocketFamily;
    sin.sin_addr.s_addr = inet_addr(LocalHostAddr);
    sin.sin_port = 0;

    /*
    ** Bind the socket to the local IP
    */
    status = bind(SockDesc1, (struct sockaddr *)&sin, slen);
    if (status < 0) {
        LogMessage("CreateSocketPair: bind () - %d", errno);
        close(SockDesc1);
        return -1;
    }

    /*
    ** Get the socket name so we can save the port number
    */
    status = getsockname(SockDesc1, (struct sockaddr *)&sin, &slen);
    if (status < 0) {
        LogMessage("CreateSocketPair: getsockname () - %d", errno);
        close(SockDesc1);
        return -1;
    } else
        LocalHostPort = sin.sin_port;

    /*
    ** Setup a listen for the socket
    */
    listen(SockDesc1, 5);

    /*
    ** Get the binary (64-bit) time of the specified timeout value
    */
    BIO_snprintf(AscTimeBuff, sizeof(AscTimeBuff), "0 0:0:%02d.00", SOCKET_PAIR_TIMEOUT_VALUE);
    AscTimeDesc.dsc$w_length = strlen(AscTimeBuff);
    AscTimeDesc.dsc$a_pointer = AscTimeBuff;
    status = sys$bintim(&AscTimeDesc, BinTimeBuff);
    if (!(status & 1)) {
        LogMessage("CreateSocketPair: SYS$BINTIM () - %08X", status);
        close(SockDesc1);
        return -1;
    }

    /*
    ** Assign another channel to the TCP/IP device for the accept.
    ** This is the channel that ends up being connected to.
    */
    status = sys$assign(&TcpDeviceDesc, &TcpDeviceChan, 0, 0, 0);
    if (!(status & 1)) {
        LogMessage("CreateSocketPair: SYS$ASSIGN () - %08X", status);
        close(SockDesc1);
        return -1;
    }

    /*
    ** Get the channel of the first socket for the accept
    */
    TcpAcceptChan = decc$get_sdc(SockDesc1);

    /*
    ** Perform the accept using $QIO so we can do this asynchronously
    */
    status = sys$qio(EFN$C_ENF,
        TcpAcceptChan,
        IO$_ACCESS | IO$M_ACCEPT,
        &iosb,
        0, 0, 0, 0, 0,
        &TcpDeviceChan,
        0, 0);
    if (!(status & 1)) {
        LogMessage("CreateSocketPair: SYS$QIO () - %08X", status);
        close(SockDesc1);
        sys$dassgn(TcpDeviceChan);
        return -1;
    }

    /*
    ** Create the second socket to do the connect
    */
    SockDesc2 = socket(SocketFamily, SocketType, 0);
    if (SockDesc2 < 0) {
        LogMessage("CreateSocketPair: socket () - %d", errno);
        sys$cancel(TcpAcceptChan);
        close(SockDesc1);
        sys$dassgn(TcpDeviceChan);
        return (-1);
    }

    /*
    ** Setup the Socket Pair Timeout Block
    */
    sptb.SockChan1 = TcpAcceptChan;
    sptb.SockChan2 = decc$get_sdc(SockDesc2);

    /*
    ** Before we block on the connect, set a timer that can cancel I/O on our
    ** two sockets if it never connects.
    */
    status = sys$setimr(EFN$C_ENF,
        BinTimeBuff,
        SocketPairTimeoutAst,
        &sptb,
        0);
    if (!(status & 1)) {
        LogMessage("CreateSocketPair: SYS$SETIMR () - %08X", status);
        sys$cancel(TcpAcceptChan);
        close(SockDesc1);
        close(SockDesc2);
        sys$dassgn(TcpDeviceChan);
        return -1;
    }

    /*
    ** Now issue the connect
    */
    memset((char *)&sin, 0, sizeof(sin));
    sin.sin_family = SocketFamily;
    sin.sin_addr.s_addr = inet_addr(LocalHostAddr);
    sin.sin_port = LocalHostPort;

    status = connect(SockDesc2, (struct sockaddr *)&sin, sizeof(sin));
    if (status < 0) {
        LogMessage("CreateSocketPair: connect () - %d", errno);
        sys$cantim(&sptb, 0);
        sys$cancel(TcpAcceptChan);
        close(SockDesc1);
        close(SockDesc2);
        sys$dassgn(TcpDeviceChan);
        return -1;
    }

    /*
    ** Wait for the asynch $QIO to finish.  Note that if the I/O was aborted
    ** (SS$_ABORT), then we probably canceled it from the AST routine - so log
    ** a timeout.
    */
    status = sys$synch(EFN$C_ENF, &iosb);
    if (!(iosb.iosb$w_status & 1)) {
        if (iosb.iosb$w_status == SS$_ABORT)
            LogMessage("CreateSocketPair: SYS$QIO(iosb) timeout");
        else {
            LogMessage("CreateSocketPair: SYS$QIO(iosb) - %d",
                iosb.iosb$w_status);
            sys$cantim(&sptb, 0);
        }
        close(SockDesc1);
        close(SockDesc2);
        sys$dassgn(TcpDeviceChan);
        return -1;
    }

    /*
    ** Here we're successfully connected, so cancel the timer, convert the
    ** I/O channel to a socket fd, close the listener socket and return the
    ** connected pair.
    */
    sys$cantim(&sptb, 0);

    close(SockDesc1);
    SocketPair[0] = SockDesc2;
    SocketPair[1] = socket_fd(TcpDeviceChan);

    return (0);
}

/*----------------------------------------------------------------------------*/
/*                                                                            */
/*----------------------------------------------------------------------------*/
static void SocketPairTimeoutAst(int astparm)
{
    SPTB *sptb = (SPTB *)astparm;

    sys$cancel(sptb->SockChan2); /* Cancel the connect() */
    sys$cancel(sptb->SockChan1); /* Cancel the accept() */

    return;
}

/*----------------------------------------------------------------------------*/
/*                                                                            */
/*----------------------------------------------------------------------------*/
static int TerminalDeviceAst(int astparm)
{
    int status;

    /*
    ** Terminate the terminal buffer
    */
    TerminalDeviceBuff[TerminalDeviceIosb.iosb$w_bcnt] = '\0';
    strcat(TerminalDeviceBuff, "\n");

    /*
    ** Send the data read from the terminal device through the socket pair
    */
    send(TerminalSocketPair[0], TerminalDeviceBuff,
        TerminalDeviceIosb.iosb$w_bcnt + 1, 0);

    /*
    ** Queue another async IO to the terminal device
    */
    status = sys$qio(EFN$C_ENF,
        TerminalDeviceChan,
        IO$_READVBLK,
        &TerminalDeviceIosb,
        TerminalDeviceAst,
        0,
        TerminalDeviceBuff,
        sizeof(TerminalDeviceBuff) - 2,
        0, 0, 0, 0);

    /*
    ** Return status
    */
    return status;
}

/*----------------------------------------------------------------------------*/
/*                                                                            */
/*----------------------------------------------------------------------------*/
static void LogMessage(char *msg, ...)
{
    char *Month[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
        "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
    static unsigned int pid = 0;
    va_list args;
    time_t CurTime;
    struct tm *LocTime;
    char MsgBuff[256];

    /*
    ** Get the process pid
    */
    if (pid == 0)
        pid = getpid();

    /*
    ** Convert the current time into local time
    */
    CurTime = time(NULL);
    LocTime = localtime(&CurTime);

    /*
    ** Format the message buffer
    */
    BIO_snprintf(MsgBuff, sizeof(MsgBuff), "%02d-%s-%04d %02d:%02d:%02d [%08X] %s\n",
        LocTime->tm_mday, Month[LocTime->tm_mon],
        (LocTime->tm_year + 1900), LocTime->tm_hour, LocTime->tm_min,
        LocTime->tm_sec, pid, msg);

    /*
    ** Get any variable arguments and add them to the print of the message
    ** buffer
    */
    va_start(args, msg);
    vfprintf(stderr, MsgBuff, args);
    va_end(args);

    /*
    ** Flush standard error output
    */
    fsync(fileno(stderr));

    return;
}
#endif