ruby-lsapi 1.8 → 1.9

data/ext/lsapi/extconf.rb

@@ -1,3 +1,6 @@
 require 'mkmf'
 dir_config( 'lsapi' )
+if ( have_library( "socket" ))
+    have_library( "nsl" )
+end
 create_makefile( "lsapi" )

data/ext/lsapi/lsapilib.c

@@ -513,9 +513,9 @@ static int readReq( LSAPI_Request * pReq )
     if ( packetLen > LSAPI_MAX_HEADER_LEN )
         return -1;
 
-    if ( packetLen > pReq->m_reqBufSize )
+    if ( packetLen + 1024 > pReq->m_reqBufSize )
     {
-        if ( allocateBuf( pReq, packetLen ) == -1 )
+        if ( allocateBuf( pReq, packetLen + 1024 ) == -1 )
             return -1;
     }
     while( packetLen > pReq->m_bufRead )
@@ -717,6 +717,85 @@ char * LSAPI_GetHeader_r( LSAPI_Request * pReq, int headerIndex )
     return pReq->m_pHttpHeader + off;
 }
 
+static int readBodyToReqBuf( LSAPI_Request * pReq )
+{
+    int bodyLeft;
+    int len = pReq->m_bufRead - pReq->m_bufProcessed;
+    if ( len > 0 )
+        return len;
+    pReq->m_bufRead = pReq->m_bufProcessed = pReq->m_pHeader->m_pktHeader.m_packetLen.m_iLen;
+
+    bodyLeft = pReq->m_pHeader->m_reqBodyLen - pReq->m_reqBodyRead;
+    len = pReq->m_reqBufSize - pReq->m_bufRead;
+    if ( len < 0 )
+        return -1;
+    if ( len > bodyLeft )
+        len = bodyLeft;
+        
+    len = lsapi_read( pReq->m_fd, pReq->m_pReqBuf + pReq->m_bufRead, len );
+    if ( len > 0 )
+        pReq->m_bufRead += len;
+    return len;
+}
+
+
+int LSAPI_ReqBodyGetChar_r( LSAPI_Request * pReq )
+{
+    if ( pReq->m_bufProcessed >= pReq->m_bufRead )
+    {
+        if ( readBodyToReqBuf( pReq ) <= 0 )
+            return EOF;
+    }
+    ++pReq->m_reqBodyRead;
+    return (unsigned char)*(pReq->m_pReqBuf + pReq->m_bufProcessed++);
+}
+
+
+
+int LSAPI_ReqBodyGetLine_r( LSAPI_Request * pReq, char * pBuf, int bufLen, int *getLF )
+{
+    int len;
+    int left;
+    char * pBufEnd = pBuf + bufLen - 1;
+    char * pBufCur = pBuf;
+    if (!pReq || ( !pBuf )||(bufLen < 0 )|| !getLF )
+        return -1;
+    *getLF = 0;
+    while( (left = pBufEnd - pBufCur ) > 0 )
+    {
+        
+        len = pReq->m_bufRead - pReq->m_bufProcessed;
+        if ( len <= 0 )
+        {
+            if ( (len = readBodyToReqBuf( pReq )) <= 0 )
+            {
+                *getLF = 1;
+                break;
+            }
+        }
+        if ( len > left )
+            len = left;
+        char * pCur = pReq->m_pReqBuf + pReq->m_bufProcessed;
+        char * p = memchr( pCur, '\n', len );
+        if ( p )
+            len = p - pCur + 1;
+        memmove( pBufCur, pCur, len );
+        pBufCur += len;
+        pReq->m_bufProcessed += len;
+
+        pReq->m_reqBodyRead += len;
+        
+        if ( p )
+        {
+            *getLF = 1;
+            break;
+        }
+    }
+    *pBufCur = 0;
+  
+    return pBufCur - pBuf;
+}
+
 
 int LSAPI_ReadReqBody_r( LSAPI_Request * pReq, char * pBuf, int bufLen )
 {
@@ -755,7 +834,8 @@ int LSAPI_ReadReqBody_r( LSAPI_Request * pReq, char * pBuf, int bufLen )
             bufLen -= len;
         }
         else if ( len < 0 )
-            return (total)?total:-1;
+            if ( !total)
+                return -1;
     }
     pReq->m_reqBodyRead += total;
     return total;

data/ext/lsapi/lsapilib.h

@@ -151,6 +151,10 @@ char * LSAPI_GetEnv_r( LSAPI_Request * pReq, const char * name );
 
 int LSAPI_ReadReqBody_r( LSAPI_Request * pReq, char * pBuf, int len );
 
+int LSAPI_ReqBodyGetChar_r( LSAPI_Request * pReq );
+
+int LSAPI_ReqBodyGetLine_r( LSAPI_Request * pReq, char * pBuf, int bufLen, int *getLF );
+
 
 int LSAPI_FinalizeRespHeaders_r( LSAPI_Request * pReq );
 
@@ -262,6 +266,14 @@ static inline int LSAPI_GetReqBodyRemain()
 static inline int LSAPI_ReadReqBody( char * pBuf, int len )
 {   return LSAPI_ReadReqBody_r( &g_req, pBuf, len );        }
 
+static inline int LSAPI_ReqBodyGetChar()
+{   return LSAPI_ReqBodyGetChar_r( &g_req );        }
+
+static inline int LSAPI_ReqBodyGetLine( char * pBuf, int len, int *getLF )
+{   return LSAPI_ReqBodyGetLine_r( &g_req, pBuf, len, getLF );        }
+
+
+
 static inline int LSAPI_FinalizeRespHeaders(void)
 {   return LSAPI_FinalizeRespHeaders_r( &g_req );           }
 

data/ext/lsapi/lsruby.c

@@ -74,16 +74,76 @@ static void lsapi_free_data( lsapi_data * data )
     free( data );
 }
 
-static int add_env( const char * pKey, int keyLen, const char * pValue, int valLen,
+static int add_env_rails( const char * pKey, int keyLen, const char * pValue, int valLen,
                          void * arg )
 {
+    char * p;
+    int len;
+    //Fixup some environment variables for rails
+    switch( *pKey )
+    {
+    case 'Q':
+        if ( strcmp( pKey, "QUERY_STRING" ) == 0 )
+        {
+            if ( !*pValue )
+                return 1;
+        }
+        break;
+    case 'R':
+        if (( *(pKey+8) == 'U' )&&( strcmp( pKey, "REQUEST_URI" ) == 0 ))
+        {
+            p = strchr( pValue, '?' );
+            if ( p )
+            {
+                len = valLen - ( p - pValue ) - 1;
+                valLen = p - pValue;
+                *p++ = 0;
+            }
+            else
+            {
+                p = "";
+                len = 0;
+            }
+            rb_hash_aset( lsapi_env,rb_tainted_str_new("QUERY_STRING", 12),
+                        rb_tainted_str_new(p, len));
+            rb_hash_aset( lsapi_env,rb_tainted_str_new("PATH_INFO", 9),
+                        rb_tainted_str_new(pValue, valLen));
+        }
+        break;
+    case 'S':
+        if ( strcmp( pKey, "SCRIPT_NAME" ) == 0 )
+        {
+            pValue = "/";
+            valLen = 1;
+        }
+        break;
+    case 'P':
+        if ( strcmp( pKey, "PATH_INFO" ) == 0 )
+            return 1;
+    default:
+        break;
+    }
+    
     //lsapi_ruby_setenv(pKey, pValue );
-    rb_hash_aset( lsapi_env,rb_tainted_str_new2(pKey),
-                    rb_tainted_str_new2(pValue));
+    
+    rb_hash_aset( lsapi_env,rb_tainted_str_new(pKey, keyLen),
+                    rb_tainted_str_new(pValue, valLen));
     return 1;
 }
 
+static int add_env_no_fix( const char * pKey, int keyLen, const char * pValue, int valLen,
+                         void * arg )
+{
+    rb_hash_aset( lsapi_env,rb_tainted_str_new(pKey, keyLen),
+                    rb_tainted_str_new(pValue, valLen));
+    return 1;
+}
 
+typedef int (*fn_add_env)( const char * pKey, int keyLen, const char * pValue, int valLen,
+                         void * arg );
+                         
+fn_add_env s_fn_add_env = add_env_no_fix;
+                         
 static void clear_env()
 {
     //rb_funcall( lsapi_env, rb_intern( "clear" ), 0 );
@@ -92,11 +152,10 @@ static void clear_env()
 
 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 );
+    LSAPI_ForeachHeader_r( data->req, s_fn_add_env, data );
+    LSAPI_ForeachEnv_r( data->req, s_fn_add_env, data );
     
 }
 
@@ -510,11 +569,37 @@ static VALUE lsapi_flush( VALUE self )
 
 static VALUE lsapi_getc( VALUE self )
 {
-    char ch;
+    int ch;
     //lsapi_data *data;
     //Data_Get_Struct(self,lsapi_data, data);
-    LSAPI_ReadReqBody_r( &g_req, &ch, 1 );
-    return INT2NUM( (int)ch );
+    if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
+    {
+        rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+    }
+    ch = LSAPI_ReqBodyGetChar_r( &g_req );
+    return INT2NUM( ch );
+}
+
+static VALUE lsapi_gets( VALUE self )
+{
+    VALUE str;
+    int getLF = 0;
+    char buff[4096];
+    int len;
+    if (rb_safe_level() >= 4 && !OBJ_TAINTED(self))
+    {
+        rb_raise(rb_eSecurityError, "Insecure: operation on untainted IO");
+    }
+    str = rb_str_buf_new( 1024 );
+    OBJ_TAINT(str);
+    while( !getLF )
+    {
+        len = LSAPI_ReqBodyGetLine_r( &g_req, buff, 4096, &getLF );
+        if ( len > 0 )
+            rb_str_buf_cat( str, buff, len );
+        
+    }
+    return str;
 }
 
 
@@ -614,7 +699,7 @@ void Init_lsapi()
     if ( p )
     {
         s_children = atoi( p );
-        unsetenv( "LSAPI_CHILDREN" );
+        ruby_unsetenv( "LSAPI_CHILDREN" );
     }
     
     p = getenv( "LSAPI_MAX_REQS" );
@@ -623,7 +708,7 @@ void Init_lsapi()
         n = atoi( p );
         if ( n > 0 )
             s_max_reqs = n;
-        unsetenv( "LSAPI_MAX_REQS" );
+        ruby_unsetenv( "LSAPI_MAX_REQS" );
     }
     
     p = getenv( "LSAPI_MAX_IDLE" );
@@ -631,21 +716,23 @@ void Init_lsapi()
     {
         n = atoi( p );
         s_max_idle_secs = n;
-        unsetenv( "LSAPI_MAX_IDLE" );
+        ruby_unsetenv( "LSAPI_MAX_IDLE" );
     }
 
     p = getenv( "LSAPI_PGRP_MAX_IDLE" );
     if ( p )
     {
         s_max_grp_idle_secs = atoi( p );
-        unsetenv( "LSAPI_PGRP_MAX_IDLE" );
+        ruby_unsetenv( "LSAPI_PGRP_MAX_IDLE" );
     }
 
     if ( !getenv( "LSAPI_PPID_NO_CHECK" ) )
         s_ppid = getppid();
     else
-        unsetenv( "LSAPI_PPID_NO_CHECK" );
-
+        ruby_unsetenv( "LSAPI_PPID_NO_CHECK" );
+    if ( getenv( "RAILS_ROOT" )||getenv( "RAILS_ENV" ) )
+        s_fn_add_env = add_env_rails;
+        
     orig_stdin = rb_stdin;
     orig_stdout = rb_stdout;
 #if RUBY_VERSION_CODE < 180
@@ -657,8 +744,6 @@ void Init_lsapi()
     //Do not need those environments after initialization
     remove_env = rb_str_new( "RAILS_ROOT", 10 );
     rb_funcall( env_copy, rb_intern( "delete" ), 1, remove_env );
-    remove_env = rb_str_new( "RAILS_ENV", 9 );
-    rb_funcall( env_copy, rb_intern( "delete" ), 1, remove_env );
     
     lsapi_env = rb_hash_new();
     //redefine ENV using a hash table, should be faster than char **environment
@@ -685,7 +770,7 @@ void Init_lsapi()
     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, "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);

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: ruby-lsapi
 version: !ruby/object:Gem::Version 
-  version: "1.8"
-date: 2006-08-22 00:00:00 -04:00
+  version: "1.9"
+date: 2006-09-25 00:00:00 -04:00
 summary: A ruby extension for fast communication with LiteSpeed Web Server.
 require_paths: 
 - lib