path: root/lib/ssl/c_src/esock_osio.c

/*<copyright>
 * <year>1999-2008</year>
 * <holder>Ericsson AB, All Rights Reserved</holder>
 *</copyright>
 *<legalnotice>
 * The contents of this file are subject to the Erlang Public License,
 * Version 1.1, (the "License"); you may not use this file except in
 * compliance with the License. You should have received a copy of the
 * Erlang Public License along with this software. If not, it can be
 * retrieved online at http://www.erlang.org/.
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Initial Developer of the Original Code is Ericsson AB.
 *</legalnotice>
 */
/*
 * Purpose:  Std filedescriptors, break handler
 *
 */

#include <stdio.h>
#include <stdlib.h>
#ifdef __WIN32__
#include "esock_winsock.h"
#include <process.h>
#include <io.h>
#include <fcntl.h>
#else
#include <unistd.h>
#include <signal.h>  
#endif 

#include "esock.h"
#include "debuglog.h"
#include "esock_utils.h"
#include "esock_osio.h"

#ifdef __WIN32__
#define write	_write
#define read	_read
#define LOCALHOSTADDR	"127.0.0.1"
#define LOCBUFSIZE      1024
#endif

#define PACKET_SIZE	4
#define EBUFSIZE	256

FD local_read_fd = 0;

static int inc_rbuf(int size);
static void free_rbuf(void);
static int read_fill(unsigned char *buf, int len);
#ifdef __WIN32__
static int create_local_thread(void);
static DWORD WINAPI local_thread(LPVOID lpvParam);
static BOOL WINAPI signal_handler(DWORD ctrl);
#endif

static unsigned char *rbuf = NULL;
static int rbuf_malloced = 0;
#ifdef __WIN32__
static unsigned long one = 1, zero = 0;
static int local_portno;
static char *local_buf;
#endif

int set_break_handler(void) 
{
#ifndef __WIN32__
    struct sigaction act;

    /* Ignore SIGPIPE signal */
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;
    act.sa_handler = SIG_IGN;
    sigaction(SIGPIPE, &act, NULL);
    return 0;
#else 
    SetConsoleCtrlHandler(signal_handler, TRUE);
    return 0;
#endif
}


#ifdef __WIN32__

int set_binary_mode(void)
{
    _setmode(0, _O_BINARY);
    _setmode(1, _O_BINARY);
    return 0;
}

int esock_osio_init(void)
{
    return create_local_thread();
}

void esock_osio_finish(void)
{
    sock_close(local_read_fd);
}

#endif

int read_ctrl(unsigned char **ebufp)
{
    int tbh, cc;
    unsigned char *mbuf;

    if (inc_rbuf(EBUFSIZE) < 0) {
	fprintf(stderr, "read_ctrl: cannot alloc rbuf\n");
	return -1;
    }
    cc = read_fill(rbuf, PACKET_SIZE);
    if (cc < 0) {
	free_rbuf();
	return -1;
    }
    if (cc == 0) {
	free_rbuf();
	return -1;		/* XXX 0 ?? */
    }
    tbh = GET_INT32(rbuf);

    if (tbh > rbuf_malloced - 4) {
	if (inc_rbuf(tbh + 4) < 0)
	    return -1;
    }
    
    mbuf = rbuf + PACKET_SIZE;
    cc = read_fill(mbuf, tbh);
    DEBUGF(("-----------------------------------\n"));
    DEBUGF(("read_ctrl: cc = %d\n", cc));
    if(cc > 0) {
	DEBUGMSGF(("message (hex) : [%3.*a]\n", cc, mbuf));
	DEBUGMSGF(("message (char): [%3.*b]\n", cc, mbuf));
    }
    *ebufp = mbuf;
    return cc;
}

int write_ctrl(unsigned char *buf, int len)
{
    unsigned char lb[4];

    PUT_INT32(len, lb);
    DEBUGF(("write_ctrl: len = %d\n", len));
    DEBUGMSGF(("message (hex) : [%3.*a] [%3.*a]\n", PACKET_SIZE, lb, 
	       len, buf));
    DEBUGMSGF(("message (char): [%3.*b] [%3.*b]\n", PACKET_SIZE, lb, 
	       len, buf));

    if (write(1, lb, PACKET_SIZE) != PACKET_SIZE) { /* XXX */
	fprintf(stderr, "write_ctrl: Bad write \n");
	return -1;
    }
    if (write(1, buf, len) != len) { /* XXX */
	fprintf(stderr, "write_ctrl: Bad write \n");
	return -1;
    }
    return len;
}


/* 
 * Local functions
 *
 */

static int inc_rbuf(int size)
{
    unsigned char *nbuf;

    if (rbuf_malloced >= size)
	return 0;
    if (rbuf != NULL)		
	nbuf = esock_realloc(rbuf, size);
    else
	nbuf = esock_malloc(size);
    if(nbuf != NULL) {
	rbuf = nbuf;
	rbuf_malloced = size;
	return 0;
    }
    return -1;
}

static void free_rbuf(void) 
{
    if (rbuf != NULL) {
	esock_free(rbuf);
	rbuf = NULL;
	rbuf_malloced = 0;
    }
}

/* Fill buffer, return buffer length, 0 for EOF, < 0 for error. */

static int read_fill(unsigned char *buf, int len)
{
    int i, got = 0;
  
    do {
	if ((i = sock_read(local_read_fd, buf+got, len-got)) <= 0)
	    return i;
	got += i;
    } while (got < len);
    return len;
}


#ifdef __WIN32__

/* 
 * This routine creates a local thread, which reads from standard input
 * and writes to a socket. 
 */

static int create_local_thread(void)
{
    struct sockaddr_in iserv_addr;
    SOCKET tmpsock;
    int length;
    unsigned threadaddr;

    local_buf = esock_malloc(LOCBUFSIZE);
    if ((tmpsock = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET) {
 	fprintf(stderr, "create_local_thread could not create socket.\n");
	return -1;
    }
    memset(&iserv_addr, 0, sizeof(iserv_addr));
    iserv_addr.sin_family = AF_INET;
    iserv_addr.sin_addr.s_addr = inet_addr(LOCALHOSTADDR);
    iserv_addr.sin_port = htons(0); /* Have any port */

    if (bind(tmpsock, (struct sockaddr *) &iserv_addr, 
	     sizeof(iserv_addr)) < 0) {
	fprintf(stderr, "create_local_thread could not bind.\n");
	closesocket(tmpsock);
	return -1;
    }
    listen(tmpsock, 1);
    length = sizeof(iserv_addr);
    if (getsockname(tmpsock, (struct sockaddr *) &iserv_addr, &length) < 0) {
	fprintf(stderr, "create_local_thread could not getsockname.\n");
	closesocket(tmpsock);
	return -1;
    }
    local_portno = ntohs(iserv_addr.sin_port);

    if (_beginthreadex(NULL, 0, local_thread, NULL, 0, &threadaddr) == 0) {
	fprintf(stderr, "create_local_thread could not _beginthreadex().\n");
	closesocket(tmpsock);
	return -1;
    }
    local_read_fd = accept(tmpsock, (struct sockaddr *) NULL, (int *) NULL);
    if (local_read_fd == INVALID_FD) {
	fprintf(stderr, "create_local_thread could not accept.\n");
	closesocket(tmpsock);
	return -1;
    }
    closesocket(tmpsock);
    return 0;
}

static DWORD WINAPI local_thread(LPVOID lpvParam)
{
    SOCKET sock;
    struct hostent *host;
    char hostname[64];
    struct sockaddr_in iserv_addr;
    unsigned long addr;
    int len;
    HANDLE thread;

    sock = socket(AF_INET, SOCK_STREAM, 0);
    memset(&iserv_addr, 0, sizeof(struct sockaddr_in));
    iserv_addr.sin_family = AF_INET;
    iserv_addr.sin_addr.s_addr = inet_addr(LOCALHOSTADDR);
    iserv_addr.sin_port = htons(local_portno);
    if(connect(sock, (struct sockaddr*)&iserv_addr, sizeof iserv_addr) == 
       SOCKET_ERROR) {
	fprintf(stderr, "local_thread thread could not connect\n");
	closesocket(sock);
	return 0;
    }
    setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one));

    /* read from 0 and write to sock */
    while (1) {
	if ((len = read(0, local_buf, LOCBUFSIZE)) <= 0) {
	    closesocket(sock);
	    close(0);
	    return 0;
	}
	if (send(sock, local_buf, len, 0) != len ) {
	    closesocket(sock);
	    close(0);
	    return 0;
	}
    }
    return 0;
}

/* Signal handler */

static BOOL WINAPI signal_handler(DWORD ctrl)
{
    switch (ctrl) {
    case CTRL_C_EVENT:
    case CTRL_BREAK_EVENT:
	break;
    case CTRL_LOGOFF_EVENT:
	if (!getenv("ERLSRV_SERVICE_NAME"))
	    return FALSE;
	break;
    default:
	exit(1);
    }
    return TRUE;
}

#endif