

#ifdef __VMS
# define OPENSSL_SYS_VMS
# pragma message disable DOLLARID


# include <openssl/opensslconf.h>

# if !defined(_POSIX_C_SOURCE) && defined(OPENSSL_SYS_VMS)

#  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 {           
#  pragma __nomember_alignment
    __union  {
        __struct  {
            unsigned short int iosb$w_status; 
            __union  {
                __struct  {             
                    unsigned short int iosb$w_bcnt; 
                    __union  {
                        unsigned int iosb$l_dev_depend; 
                        unsigned int iosb$l_pid; 
                    } iosb$r_l;
                } iosb$r_bcnt_16;
                __struct  {             
                    unsigned int iosb$l_bcnt; 
                    unsigned short int iosb$w_dev_depend_high; 
                } iosb$r_bcnt_32;
            } iosb$r_devdepend;
        } iosb$r_io_64;
        __struct  {
            __union  {
                unsigned int iosb$l_getxxi_status; 
                unsigned int iosb$l_reg_status; 
            } iosb$r_l_status;
            unsigned int iosb$l_reserved; 
        } 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          

# endif  

# 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 *, ...);


# define SOCKET_PAIR_TIMEOUT_VALUE 20


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")) {
        
        status = TerminalSocket (TERM_SOCK_CREATE, &TermSock);
        if (status != TERM_SOCK_SUCCESS)
            exit (1);

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

        
        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");

    
    switch (FunctionCode) {
    case TERM_SOCK_CREATE:
        
        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;
        }

        
        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;
        }

        
        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;
        }

        
        *ReturnSocket = TerminalSocketPair[1];
        break;

    case TERM_SOCK_DELETE:
        
        status = sys$cancel (TerminalDeviceChan);
        if (! (status & 1)) {
            LogMessage ("TerminalSocket: SYS$CANCEL () - %08X", status);
            close (TerminalSocketPair[0]);
            close (TerminalSocketPair[1]);
            return TERM_SOCK_FAILURE;
        }

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

        
        close (TerminalSocketPair[0]);
        close (TerminalSocketPair[1]);

        
        *ReturnSocket = 0;
        break;

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

    
    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");

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

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

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

    
    status = getsockname (SockDesc1, (struct sockaddr *) &sin, &slen);
    if (status < 0) {
        LogMessage ("CreateSocketPair: getsockname () - %d", errno);
        close (SockDesc1);
        return -1;
    } else
        LocalHostPort = sin.sin_port;

    
    listen (SockDesc1, 5);

    
    sprintf (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;
    }

    
    status = sys$assign (&TcpDeviceDesc, &TcpDeviceChan, 0, 0, 0);
    if (! (status & 1)) {
        LogMessage ("CreateSocketPair: SYS$ASSIGN () - %08X", status);
        close (SockDesc1);
        return -1;
    }

    
    TcpAcceptChan = decc$get_sdc (SockDesc1);

    
    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;
    }

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

    
    sptb.SockChan1 = TcpAcceptChan;
    sptb.SockChan2 = decc$get_sdc (SockDesc2);

    
    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;
    }

    
    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;
    }

    
    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;
    }

    
    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); 
    sys$cancel (sptb->SockChan1); 

    return;

}




static int TerminalDeviceAst (int astparm)
{
    int status;

    
    TerminalDeviceBuff[TerminalDeviceIosb.iosb$w_bcnt] = '\0';
    strcat (TerminalDeviceBuff, "\n");

    
    send (TerminalSocketPair[0], TerminalDeviceBuff,
          TerminalDeviceIosb.iosb$w_bcnt + 1, 0);

    
    status = sys$qio (EFN$C_ENF,
                      TerminalDeviceChan,
                      IO$_READVBLK,
                      &TerminalDeviceIosb,
                      TerminalDeviceAst,
                      0,
                      TerminalDeviceBuff,
                      sizeof(TerminalDeviceBuff) - 1,
                      0, 0, 0, 0);

    
    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];

    
    if (pid == 0)
        pid = getpid ();

    
    CurTime = time (NULL);
    LocTime = localtime (&CurTime);

    
    sprintf (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);

    
    va_start (args, msg);
    vfprintf (stderr, MsgBuff, args);
    va_end (args);

    
    fsync (fileno (stderr));

    return;

}
#endif
