/*<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