ruby-lsapi 1.3

data/ext/lsapi/lsapilib.h

@@ -0,0 +1,296 @@
+/*
+Copyright (c) 2005, Lite Speed Technologies Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met: 
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer. 
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution. 
+    * Neither the name of the Lite Speed Technologies Inc nor the
+      names of its contributors may be used to endorse or promote
+      products derived from this software without specific prior
+      written permission.  
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+*/
+
+/***************************************************************************
+                          lsapilib.h  -  description
+                             -------------------
+    begin                : Mon Feb 21 2005
+    copyright            : (C) 2005 by George Wang
+    email                : gwang@litespeedtech.com
+ ***************************************************************************/
+
+
+#ifndef  _LSAPILIB_H_
+#define  _LSAPILIB_H_
+
+#if defined (c_plusplus) || defined (__cplusplus)
+extern "C" {
+#endif
+
+#include <stddef.h>
+#include <lsapidef.h>
+
+struct LSAPI_key_value_pair
+{
+    char * pKey;
+    char * pValue;
+    int    keyLen;
+    int    valLen;
+};
+
+
+#define LSAPI_MAX_RESP_HEADERS  100
+
+typedef struct lsapi_request
+{
+    int               m_fdListen;
+    int               m_fd;
+    
+    char            * m_pReqBuf;
+    int               m_reqBufSize;
+    
+    char            * m_pRespBuf;
+    char            * m_pRespBufEnd;
+    char            * m_pRespBufPos;
+
+    char            * m_pRespHeaderBuf;
+    char            * m_pRespHeaderBufEnd;
+    char            * m_pRespHeaderBufPos;
+
+
+    struct iovec    * m_pIovec;
+    struct iovec    * m_pIovecEnd;
+    struct iovec    * m_pIovecCur;
+    struct iovec    * m_pIovecToWrite;    
+
+    struct lsapi_packet_header      * m_respPktHeaderEnd;
+
+    struct lsapi_req_header         * m_pHeader;
+    struct LSAPI_key_value_pair     * m_pEnvList;
+    struct LSAPI_key_value_pair     * m_pSpecialEnvList;
+    int                               m_envListSize;
+    int                               m_specialEnvListSize;
+
+    struct lsapi_http_header_index  * m_pHeaderIndex;
+    struct lsapi_header_offset      * m_pUnknownHeader;
+    
+    char            * m_pScriptFile;
+    char            * m_pScriptName;
+    char            * m_pQueryString;
+    char            * m_pHttpHeader;
+    char            * m_pRequestMethod;
+    int               m_totalLen;
+    int               m_reqState;
+    int               m_reqBodyRead;
+    int               m_bufProcessed;
+    int               m_bufRead;
+    
+    struct lsapi_packet_header        m_respPktHeader[5];
+    
+    struct lsapi_resp_header          m_respHeader;
+    short                             m_respHeaderLen[LSAPI_MAX_RESP_HEADERS];
+
+}LSAPI_Request;
+
+extern LSAPI_Request g_req;
+
+
+//return: >0 continue, ==0 stop, -1 failed
+typedef int (*LSAPI_CB_EnvHandler )( const char * pKey, int keyLen,
+                const char * pValue, int valLen, void * arg );
+
+
+int LSAPI_Init(void);
+
+void LSAPI_stop(void);
+
+int LSAPI_Is_Listen_r( LSAPI_Request * pReq);
+
+int LSAPI_InitRequest( LSAPI_Request * pReq, int fd );
+
+int LSAPI_Accept_r( LSAPI_Request * pReq );
+
+void LSAPI_Reset_r( LSAPI_Request * pReq );
+
+int LSAPI_Finish_r( LSAPI_Request * pReq );
+
+int LSAPI_Release_r( LSAPI_Request * pReq );
+
+char * LSAPI_GetHeader_r( LSAPI_Request * pReq, int headerIndex );
+
+int LSAPI_ForeachHeader_r( LSAPI_Request * pReq,
+            LSAPI_CB_EnvHandler fn, void * arg );
+
+int LSAPI_ForeachEnv_r( LSAPI_Request * pReq,
+            LSAPI_CB_EnvHandler fn, void * arg );
+
+int LSAPI_ForeachSpecialEnv_r( LSAPI_Request * pReq,
+            LSAPI_CB_EnvHandler fn, void * arg );
+
+char * LSAPI_GetEnv_r( LSAPI_Request * pReq, const char * name );
+            
+
+int LSAPI_ReadReqBody_r( LSAPI_Request * pReq, char * pBuf, int len );
+
+
+int LSAPI_FinalizeRespHeaders_r( LSAPI_Request * pReq );
+
+int LSAPI_Write_r( LSAPI_Request * pReq, const char * pBuf, int len );
+
+int LSAPI_Write_Stderr_r( LSAPI_Request * pReq, const char * pBuf, int len );
+
+int LSAPI_Flush_r( LSAPI_Request * pReq );
+
+int LSAPI_AppendRespHeader_r( LSAPI_Request * pHeader, char * pBuf, int len );
+
+static inline int LSAPI_SetRespStatus_r( LSAPI_Request * pReq, int code )
+{
+    if ( !pReq )
+        return -1;
+    pReq->m_respHeader.m_respInfo.m_status = code;
+    return 0;
+}
+
+static inline char * LSAPI_GetQueryString_r( LSAPI_Request * pReq )
+{
+    if ( pReq )
+        return pReq->m_pQueryString;
+    return NULL;
+}
+
+
+static inline char * LSAPI_GetScriptFileName_r( LSAPI_Request * pReq )
+{
+    if ( pReq )
+        return pReq->m_pScriptFile;
+    return NULL;
+}
+
+
+static inline char * LSAPI_GetScriptName_r( LSAPI_Request * pReq )
+{
+    if ( pReq )
+        return pReq->m_pScriptName;
+    return NULL;
+}
+
+
+static inline char * LSAPI_GetRequestMethod_r( LSAPI_Request * pReq)
+{
+    if ( pReq )
+        return pReq->m_pRequestMethod;
+    return NULL;
+}
+
+
+
+static inline int  LSAPI_GetReqBodyLen_r( LSAPI_Request * pReq )
+{
+    if ( pReq )
+        return pReq->m_pHeader->m_reqBodyLen;
+    return -1;
+}
+
+static inline int LSAPI_GetReqBodyRemain_r( LSAPI_Request * pReq )
+{
+    if ( pReq )
+        return pReq->m_pHeader->m_reqBodyLen - pReq->m_reqBodyRead;
+    return -1;
+}
+
+
+int LSAPI_Is_Listen(void);
+
+static inline int LSAPI_Accept( void )
+{   return LSAPI_Accept_r( &g_req );                        }
+
+static inline int LSAPI_Finish(void)
+{   return LSAPI_Finish_r( &g_req );                        }
+
+static inline char * LSAPI_GetHeader( int headerIndex )
+{   return LSAPI_GetHeader_r( &g_req, headerIndex );        }
+
+static inline int LSAPI_ForeachHeader( LSAPI_CB_EnvHandler fn, void * arg )
+{   return LSAPI_ForeachHeader_r( &g_req, fn, arg );        }
+
+static inline int LSAPI_ForeachEnv( LSAPI_CB_EnvHandler fn, void * arg )
+{   return LSAPI_ForeachEnv_r( &g_req, fn, arg );           }
+
+static inline int LSAPI_ForeachSpecialEnv( LSAPI_CB_EnvHandler fn, void * arg )
+{   return LSAPI_ForeachSpecialEnv_r( &g_req, fn, arg );    }
+
+static inline char * LSAPI_GetEnv( const char * name )
+{   return LSAPI_GetEnv_r( &g_req, name );                  }
+
+static inline char * LSAPI_GetQueryString()
+{   return LSAPI_GetQueryString_r( &g_req );                }
+
+static inline char * LSAPI_GetScriptFileName()
+{   return LSAPI_GetScriptFileName_r( &g_req );             }
+
+static inline char * LSAPI_GetScriptName()
+{    return LSAPI_GetScriptName_r( &g_req );                }
+
+static inline char * LSAPI_GetRequestMethod()
+{   return LSAPI_GetRequestMethod_r( &g_req );              }
+
+static inline int LSAPI_GetReqBodyLen()
+{   return LSAPI_GetReqBodyLen_r( &g_req );                 }
+
+static inline int LSAPI_GetReqBodyRemain()
+{   return LSAPI_GetReqBodyRemain_r( &g_req );                 }
+
+static inline int LSAPI_ReadReqBody( char * pBuf, int len )
+{   return LSAPI_ReadReqBody_r( &g_req, pBuf, len );        }
+
+static inline int LSAPI_FinalizeRespHeaders(void)
+{   return LSAPI_FinalizeRespHeaders_r( &g_req );           }
+
+static inline int LSAPI_Write( const char * pBuf, int len )
+{   return LSAPI_Write_r( &g_req, pBuf, len );              }
+
+static inline int LSAPI_Write_Stderr( const char * pBuf, int len )
+{   return LSAPI_Write_Stderr_r( &g_req, pBuf, len );       }
+
+static inline int LSAPI_Flush()
+{   return LSAPI_Flush_r( &g_req );                         }
+
+static inline int LSAPI_AppendRespHeader( char * pBuf, int len )
+{   return LSAPI_AppendRespHeader_r( &g_req, pBuf, len );   }
+
+static inline int LSAPI_SetRespStatus( int code )
+{   return LSAPI_SetRespStatus_r( &g_req, code );           }
+
+
+#if defined (c_plusplus) || defined (__cplusplus)
+}
+#endif
+
+
+#endif
+
+
+
+
+
+
+

data/ext/lsapi/lsruby.c

@@ -0,0 +1,579 @@
+
+#include "ruby.h"
+
+#include "lsapilib.h"
+#include <errno.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <signal.h>
+#include <sys/socket.h>
+#include <sys/wait.h>
+
+//RUBY_EXTERN VALUE ruby_errinfo;
+RUBY_EXTERN VALUE rb_stdin;
+RUBY_EXTERN VALUE rb_stdout;
+#if RUBY_VERSION_CODE < 180
+RUBY_EXTERN VALUE rb_defout;
+#endif
+
+static VALUE orig_stdin;
+static VALUE orig_stdout;
+#if RUBY_VERSION_CODE < 180
+static VALUE orig_defout;
+#endif
+
+static VALUE orig_env;
+
+static VALUE lsapi_env;
+
+static VALUE lsapi_objrefs;
+
+typedef struct lsapi_data
+{
+    LSAPI_Request * req;
+    VALUE           env;
+}lsapi_data;
+
+
+static VALUE cLSAPI;
+
+static VALUE s_req = Qnil;
+static lsapi_data * s_req_data;
+
+static int  s_children = 0;
+static int  s_cur_children = 0;
+
+static void lsapi_ruby_setenv(const char *name, const char *value)
+{
+    if (!name) return;
+
+    if (value && *value)
+	    ruby_setenv(name, value);
+    else
+        ruby_unsetenv(name);
+}
+
+
+
+static void lsapi_mark( lsapi_data * data )
+{
+    rb_gc_mark( data->env );
+}
+
+static void lsapi_free_data( lsapi_data * data )
+{
+    free( data );
+}
+
+static int add_env( const char * pKey, int keyLen, const char * pValue, int valLen,
+                         void * arg )
+{
+    //lsapi_ruby_setenv(pKey, pValue );
+    rb_hash_aset( lsapi_env,rb_tainted_str_new2(pKey),
+                    rb_tainted_str_new2(pValue));
+    return 1;
+}
+
+
+static void clear_env()
+{
+    rb_funcall( lsapi_env, rb_intern( "clear" ), 0 );
+}
+
+static void setup_cgi_env( lsapi_data * data )
+{
+
+    clear_env();
+    
+    LSAPI_ForeachHeader_r( data->req, add_env, data );
+    LSAPI_ForeachEnv_r( data->req, add_env, data );
+    
+}
+
+
+
+static int s_stop;
+void lsapi_cleanup(int signal)
+{
+    s_stop = signal;
+}
+
+void lsapi_sigchild( int signal )
+{
+    int status, pid;
+    while( 1 )
+    {
+        pid = waitpid( -1, &status, WNOHANG|WUNTRACED );
+        if ( pid <= 0 )
+        {
+            break;
+        }
+
+    }
+
+}
+
+static int lsapi_fork_child()
+{
+    struct sigaction act, old_term, old_quit, old_int, old_usr1, old_child;
+
+    char        achPeer[128];
+    socklen_t   len;
+    int         nodelay = 1;
+
+    setsid();
+
+    act.sa_flags = 0;
+    act.sa_handler = lsapi_sigchild;
+    if( sigaction( SIGCHLD, &act, &old_child ) )
+    {
+        perror( "Can't set signal handler for SIGCHILD" );
+        return -1;
+    }
+
+    /* Set up handler to kill children upon exit */
+    act.sa_flags = 0;
+    act.sa_handler = lsapi_cleanup;
+    if( sigaction( SIGTERM, &act, &old_term ) ||
+        sigaction( SIGINT,  &act, &old_int  ) ||
+        sigaction( SIGUSR1, &act, &old_usr1 ) ||
+        sigaction( SIGQUIT, &act, &old_quit ))
+    {
+        perror( "Can't set signals" );
+        return -1;
+    }
+    s_stop = 0;
+    while( !s_stop )
+    {
+        len = sizeof( achPeer );
+        g_req.m_fd = accept( g_req.m_fdListen,
+                    (struct sockaddr *)&achPeer, &len );
+        if ( g_req.m_fd != -1 )
+        {
+            if (((struct sockaddr *)&achPeer)->sa_family == AF_INET )
+            {
+                setsockopt(g_req.m_fd, IPPROTO_TCP, TCP_NODELAY,
+                        (char *)&nodelay, sizeof(nodelay));
+            }
+            int pid = fork();
+            if ( !pid )
+            {
+                close( g_req.m_fdListen );
+                g_req.m_fdListen = -1;
+
+                /* don't catch our signals */
+		sigaction( SIGCHLD, &old_child, 0 );
+                sigaction( SIGTERM, &old_term, 0 );
+                sigaction( SIGQUIT, &old_quit, 0 );
+                sigaction( SIGINT,  &old_int,  0 );
+                sigaction( SIGUSR1, &old_usr1, 0 );
+                return 0;
+            }
+            else if ( pid == -1 )
+            {
+                perror( "fork() failed" );
+                return -1;
+            }
+            else
+            {
+                close( g_req.m_fd );
+                g_req.m_fd = -1;
+            }
+        }
+        else
+        {
+            if (( errno == EINTR )||( errno == EAGAIN))
+                continue;
+            perror( "accept() failed" );
+            return -1;
+        }
+    }
+    kill( -getpgrp(), SIGUSR1 );
+    return -1;
+
+}
+
+static VALUE lsapi_s_accept( VALUE self )
+{
+//    lsapi_data * req_data;
+//    VALUE   req;
+    fd_set  readfds;
+    int     fd;
+    int     ret;
+
+    LSAPI_Finish_r( &g_req );
+    if ( s_children )
+    {
+        if ( g_req.m_fdListen != -1 )
+            if ( lsapi_fork_child() == -1 )
+                return Qnil;
+    }
+    if ( g_req.m_fd != -1 )
+    {
+        fd = g_req.m_fd;
+    }
+    else if ( g_req.m_fdListen != -1 )
+        fd = g_req.m_fdListen;
+    else
+        return Qnil;
+
+    FD_ZERO( &readfds );
+    FD_SET( fd, &readfds );
+
+    if (rb_thread_select(fd+1, &readfds, NULL, NULL, NULL) < 1)
+    {
+        return Qnil;
+    }
+
+    ret = LSAPI_Accept_r( &g_req );
+
+    if ( !ret )
+    {
+//        req = Data_Make_Struct( self, lsapi_data, lsapi_mark, free, req_data );
+//        s_req = req;
+//        req_data->req = &g_req;
+//        rb_stdin = rb_stdout = req;
+//#if RUBY_VERSION_CODE < 180
+//        rb_defout = req;
+//#endif
+        setup_cgi_env( s_req_data );
+        return s_req;
+    }
+    return Qnil;
+}
+
+
+static int chdir_file( const char * pFile )
+{
+    char * p = strrchr( pFile, '/' );
+    int ret;
+    if ( !p )
+        return -1;
+    *p = 0;
+    ret = chdir( pFile );
+    *p = '/';
+    return ret;
+}
+
+static VALUE lsapi_eval_string_wrap(VALUE self, VALUE str)
+{
+    if (rb_safe_level() >= 4)
+    {
+        Check_Type(str, T_STRING);
+    }
+    else
+    {
+        Check_SafeStr(str);
+    }
+    return rb_eval_string_wrap(StringValuePtr(str), NULL);
+}
+
+static VALUE lsapi_process( VALUE self )
+{
+    lsapi_data *data;
+    const char * pScriptPath;
+    Data_Get_Struct(self,lsapi_data, data);
+    pScriptPath = LSAPI_GetScriptFileName_r( data->req );
+//    if ( chdir_file( pScriptPath ) == -1 )
+//    {
+//        lsapi_send_error( 404 );
+//    }
+//    rb_load_file( pScriptPath );
+    return Qnil;
+}
+
+
+static VALUE lsapi_putc(VALUE self, VALUE c)
+{
+    char ch = NUM2CHR(c);
+//    lsapi_data *data;
+//    Data_Get_Struct(self,lsapi_data, data);
+    if ( LSAPI_Write_r( &g_req, &ch, 1 ) == 1 )
+        return c;
+    else
+        return INT2NUM( EOF );
+}
+
+
+static VALUE lsapi_write( VALUE self, VALUE str )
+{
+    lsapi_data *data;
+    int len;
+//    Data_Get_Struct(self,lsapi_data, data);
+//    len = LSAPI_Write_r( data->req, RSTRING(str)->ptr, RSTRING(str)->len );
+    if (TYPE(str) != T_STRING)
+	    str = rb_obj_as_string(str);
+    len = LSAPI_Write_r( &g_req, RSTRING(str)->ptr, RSTRING(str)->len );
+    return INT2NUM( len );
+}
+
+static VALUE lsapi_print( int argc, VALUE *argv, VALUE out )
+{
+    int i;
+    VALUE line;
+
+    /* if no argument given, print `$_' */
+    if (argc == 0)
+    {
+      argc = 1;
+      line = rb_lastline_get();
+      argv = &line;
+    }
+    for (i = 0; i<argc; i++)
+    {
+        if (!NIL_P(rb_output_fs) && i>0)
+        {
+            lsapi_write(out, rb_output_fs);
+        }
+        switch (TYPE(argv[i]))
+        {
+        case T_NIL:
+            lsapi_write(out, rb_str_new2("nil"));
+            break;
+        default:
+            lsapi_write(out, argv[i]);
+            break;
+        }
+    }
+    if (!NIL_P(rb_output_rs))
+    {
+        lsapi_write(out, rb_output_rs);
+    }
+
+    return Qnil;
+}
+
+static VALUE lsapi_printf(int argc, VALUE *argv, VALUE out)
+{
+    lsapi_write(out, rb_f_sprintf(argc, argv));
+    return Qnil;
+}
+
+static VALUE lsapi_puts _((int, VALUE*, VALUE));
+
+static VALUE lsapi_puts_ary(VALUE ary, VALUE out)
+{
+    VALUE tmp;
+    int i;
+
+    for (i=0; i<RARRAY(ary)->len; i++)
+    {
+        tmp = RARRAY(ary)->ptr[i];
+	    if (rb_inspecting_p(tmp))
+        {
+	        tmp = rb_str_new2("[...]");
+	    }
+	    lsapi_puts(1, &tmp, out);
+    }
+    return Qnil;
+}
+
+static VALUE lsapi_puts(int argc, VALUE *argv, VALUE out)
+{
+    int i;
+    VALUE line;
+
+    /* if no argument given, print newline. */
+    if (argc == 0)
+    {
+        lsapi_write(out, rb_default_rs);
+        return Qnil;
+    }
+    for (i=0; i<argc; i++)
+    {
+        switch (TYPE(argv[i]))
+        {
+        case T_NIL:
+            line = rb_str_new2("nil");
+            break;
+        case T_ARRAY:
+            rb_protect_inspect(lsapi_puts_ary, argv[i], out);
+            continue;
+        default:
+            line = argv[i];
+            break;
+        }
+        line = rb_obj_as_string(line);
+        lsapi_write(out, line);
+        if (RSTRING(line)->ptr[RSTRING(line)->len-1] != '\n')
+        {
+            lsapi_write(out, rb_default_rs);
+        }
+    }
+
+    return Qnil;
+}
+
+
+static VALUE lsapi_addstr(VALUE out, VALUE str)
+{
+    lsapi_write(out, str);
+    return out;
+}
+
+static VALUE lsapi_flush( VALUE self )
+{
+    //lsapi_data *data;
+    //Data_Get_Struct(self,lsapi_data, data);
+    LSAPI_Flush_r( &g_req ); 
+    return Qnil;
+}
+
+static VALUE lsapi_getc( VALUE self )
+{
+    char ch;
+    //lsapi_data *data;
+    //Data_Get_Struct(self,lsapi_data, data);
+    LSAPI_ReadReqBody_r( &g_req, &ch, 1 );
+    return INT2NUM( (int)ch );
+}
+
+
+static VALUE lsapi_read(int argc, VALUE *argv, VALUE self)
+{
+    VALUE str;
+    lsapi_data *data;
+    int n;
+    int remain;
+    char buff[8192];
+
+    if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
+    {
+        rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+    }
+
+    Data_Get_Struct(self, lsapi_data, data);
+
+    remain = LSAPI_GetReqBodyRemain();
+    if ( remain <= 0 )
+        return Qnil;
+    if (argc != 0)
+    {
+        n = NUM2INT(argv[0]);
+        if ( remain > n )
+            remain = n;
+    }
+    str = rb_str_buf_new( remain );
+    OBJ_TAINT(str);
+    while( remain > 0 )
+    {
+        n = LSAPI_ReadReqBody_r(data->req, buff,
+                        (remain > 8192)?8192:remain );
+        if ( n > 0 )
+        {
+            rb_str_buf_cat( str, buff, n );
+            remain -= n;
+        }
+        else if ( n <= 0 )
+        {
+            //FIXME: broken connection
+            break;
+        }
+    }
+    return str;
+}
+
+static VALUE lsapi_eof(VALUE self)
+{
+//    lsapi_data *data;
+//
+//    if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
+//    {
+//        rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+//    }
+//    Data_Get_Struct(self, lsapi_data, data);
+    return (LSAPI_GetReqBodyRemain( &g_req ) <= 0) ? Qtrue : Qfalse;
+}
+
+static VALUE lsapi_binmode(VALUE self)
+{
+//    if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
+//        rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+//    }
+    return self;
+}
+
+static VALUE lsapi_isatty(VALUE self)
+{
+//    if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
+//        rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+//    }
+    return Qfalse;
+}
+
+static VALUE lsapi_sync(VALUE self)
+{
+//    if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
+//        rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+//    }
+    return Qfalse;
+}
+
+static VALUE lsapi_setsync(VALUE self,VALUE sync)
+{
+//    if (rb_safe_level() >= 4 && !OBJ_TAINTED(self)) {
+//        rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+//    }
+    return Qfalse;
+}
+
+void Init_lsapi()
+{
+    char * p = getenv( "LSAPI_CHILDREN" );
+    if ( p )
+    {
+        s_children = atoi( p );
+    }
+
+    orig_stdin = rb_stdin;
+    orig_stdout = rb_stdout;
+#if RUBY_VERSION_CODE < 180
+    orig_defout = rb_defout;
+#endif
+    orig_env = rb_const_get( rb_cObject, rb_intern("ENV") );
+//    lsapi_env = orig_env;
+    lsapi_env = rb_hash_new();
+    //redefine ENV using a hash table, should be faster than char **environment
+    rb_define_global_const("ENV", lsapi_env);
+        
+    LSAPI_Init();
+
+    rb_define_global_function("eval_string_wrap", lsapi_eval_string_wrap, 1);
+
+    cLSAPI = rb_define_class("LSAPI", rb_cObject);
+    rb_define_singleton_method(cLSAPI, "accept", lsapi_s_accept, 0);
+
+    rb_define_method(cLSAPI, "process", lsapi_process, 0 );
+    //rb_define_method(cLSAPI, "initialize", lsapi_initialize, 0);
+    rb_define_method(cLSAPI, "putc", lsapi_putc, 1);
+    rb_define_method(cLSAPI, "write", lsapi_write, 1);
+    rb_define_method(cLSAPI, "print", lsapi_print, -1);
+    rb_define_method(cLSAPI, "printf", lsapi_printf, -1);
+    rb_define_method(cLSAPI, "puts", lsapi_puts, -1);
+    rb_define_method(cLSAPI, "<<", lsapi_addstr, 1);
+    rb_define_method(cLSAPI, "flush", lsapi_flush, 0);
+    rb_define_method(cLSAPI, "getc", lsapi_getc, 0);
+    //rb_define_method(cLSAPI, "ungetc", lsapi_ungetc, 1);
+    //rb_define_method(cLSAPI, "gets", lsapi_gets, 0);
+    rb_define_method(cLSAPI, "read", lsapi_read, -1);
+    rb_define_method(cLSAPI, "eof", lsapi_eof, 0);
+    rb_define_method(cLSAPI, "eof?", lsapi_eof, 0);
+//    rb_define_method(cLSAPI, "close", lsapi_close, 0);
+//    rb_define_method(cLSAPI, "closed?", lsapi_closed, 0);
+    rb_define_method(cLSAPI, "binmode", lsapi_binmode, 0);
+    //rb_define_method(cLSAPI, "isatty", lsapi_isatty, 0);
+    //rb_define_method(cLSAPI, "tty?", lsapi_isatty, 0);
+    rb_define_method(cLSAPI, "sync", lsapi_sync, 0);
+    rb_define_method(cLSAPI, "sync=", lsapi_setsync, 1);
+        
+    s_req = Data_Make_Struct( cLSAPI, lsapi_data, lsapi_mark, free, s_req_data );
+    s_req_data->req = &g_req;
+    rb_stdin = rb_stdout = s_req;
+#if RUBY_VERSION_CODE < 180
+    rb_defout = s_req;
+#endif
+    rb_global_variable(&s_req );
+
+    return;
+}
+