jk_service_iis.c

Tomcat 4.1与WebServer集成组件的源代码包.

/* ========================================================================= *
 *                                                                           *
 *                 The Apache Software License,  Version 1.1                 *
 *                                                                           *
 *          Copyright (c) 1999-2002 The Apache Software Foundation.          *
 *                           All rights reserved.                            *
 *                                                                           *
 * ========================================================================= *
 *                                                                           *
 * Redistribution and use in source and binary forms,  with or without modi- *
 * fication, are permitted provided that the following conditions are met:   *
 *                                                                           *
 * 1. Redistributions of source code  must retain the above copyright notice *
 *    notice, this list of conditions and the following disclaimer.          *
 *                                                                           *
 * 2. 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.   *
 *                                                                           *
 * 3. The end-user documentation  included with the redistribution,  if any, *
 *    must include the following acknowlegement:                             *
 *                                                                           *
 *       "This product includes  software developed  by the Apache  Software *
 *        Foundation <http://www.apache.org/>."                              *
 *                                                                           *
 *    Alternately, this acknowlegement may appear in the software itself, if *
 *    and wherever such third-party acknowlegements normally appear.         *
 *                                                                           *
 * 4. The names  "The  Jakarta  Project",  "Jk",  and  "Apache  Software     *
 *    Foundation"  must not be used  to endorse or promote  products derived *
 *    from this  software without  prior  written  permission.  For  written *
 *    permission, please contact <[e-mail]>.                        *
 *                                                                           *
 * 5. Products derived from this software may not be called "Apache" nor may *
 *    "Apache" appear in their names without prior written permission of the *
 *    Apache Software Foundation.                                            *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED 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 APACHE  SOFTWARE  FOUNDATION OR  ITS 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.                                               *
 *                                                                           *
 * ========================================================================= *
 *                                                                           *
 * This software  consists of voluntary  contributions made  by many indivi- *
 * duals on behalf of the  Apache Software Foundation.  For more information *
 * on the Apache Software Foundation, please see <http://www.apache.org/>.   *
 *                                                                           *
 * ========================================================================= */

/**
 * Description: IIS Jk2 Service 
 * Author:      Gal Shachor <[e-mail]>                           
 *              Henri Gomez <[e-mail]> 
 *              Ignacio J. Ortega <[e-mail]>
 */

// This define is needed to include wincrypt,h, needed to get client certificates
#define _WIN32_WINNT 0x0400

#include <httpext.h>
#include <httpfilt.h>
#include <wininet.h>

#include "jk_global.h"
#include "jk_requtil.h"
#include "jk_map.h"
#include "jk_pool.h"
#include "jk_env.h"
#include "jk_service.h"
#include "jk_worker.h"

#include "jk_iis.h"

#define ROLES_ATTRIBUTE_NAME  "org.apache.tomcat.jk.roles"

static int JK_METHOD jk2_service_iis_head(jk_env_t *env, jk_ws_service_t *s ){
    static char crlf[3] = { (char)13, (char)10, '\0' };
    const char *reason;
    LPEXTENSION_CONTROL_BLOCK  lpEcb=(LPEXTENSION_CONTROL_BLOCK)s->ws_private;
    DWORD len_of_status;
    char *status_str;
    char *headers_str;
    int headerCount;
    
    env->l->jkLog(env,env->l, JK_LOG_DEBUG, 
                  "Into jk_ws_service_t::head\n");

    if (s->status< 100 || s->status > 1000) {
        env->l->jkLog(env,env->l, JK_LOG_ERROR, 
               "jk_ws_service_t::jk2_service_iis_head, invalid status %d\n", s->status);
        return JK_ERR;
    }
    
    if( lpEcb == NULL ) {
        env->l->jkLog(env,env->l, JK_LOG_ERROR, 
                      "jk_ws_service_t::head, no lpEcp\n");
        return JK_ERR;
    }
    
    s->response_started = JK_TRUE;
            
    /*
     * Create the status line
     */
    if (s->msg==NULL) {
        reason = "";
    } else {
        reason = s->msg;
    }

    status_str = (char *)_alloca((6 + strlen(reason)) * sizeof(char));
    sprintf(status_str, "%d %s", s->status, reason);
    len_of_status = strlen(status_str); 

    headerCount=s->headers_out->size( env, s->headers_out );
    /*
     * Create response headers string
     */
    if ( headerCount> 0 ) {
        int i;
        unsigned len_of_headers;
        
        for(i = 0 , len_of_headers = 0 ; i < headerCount ; i++) {
            len_of_headers += strlen(s->headers_out->nameAt(env,s->headers_out,i));
            len_of_headers += strlen(s->headers_out->valueAt(env,s->headers_out,i));
            len_of_headers += 4; /* extra for colon, space and crlf */
        }
        
        len_of_headers += 3;  /* crlf and terminating null char */
        headers_str = (char *)_alloca(len_of_headers * sizeof(char));
        headers_str[0] = '\0';
            
        for(i = 0 ; i < headerCount ; i++) {
            strcat(headers_str, s->headers_out->nameAt(env,s->headers_out,i));
            strcat(headers_str, ": ");
            strcat(headers_str, s->headers_out->valueAt(env,s->headers_out,i));
            strcat(headers_str, crlf);
        }
        strcat(headers_str, crlf);
    } else {
        headers_str = crlf;
    }

    if (!lpEcb->ServerSupportFunction(lpEcb->ConnID, 
                                      HSE_REQ_SEND_RESPONSE_HEADER,
                                      status_str,
                                      (LPDWORD)&len_of_status,
                                      (LPDWORD)headers_str)) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR, 
                      "jk_ws_service_t::head, ServerSupportFunction failed\n");
        return JK_ERR;
    }       
    
    return JK_OK;
}

static int JK_METHOD jk2_service_iis_read(jk_env_t *env, jk_ws_service_t *s,
                                          void *b, unsigned len, unsigned *actually_read)
{
    env->l->jkLog(env, env->l, JK_LOG_DEBUG, 
                  "Into jk_ws_service_t::read\n");
    
    if (s && s->ws_private && b && actually_read) {
        LPEXTENSION_CONTROL_BLOCK  lpEcb=(LPEXTENSION_CONTROL_BLOCK)s->ws_private;
        
        *actually_read = 0;
        if ((s->content_read < (long)lpEcb->cbTotalBytes)&& !s->end_of_stream ){
            if (len) {
                char *buf = b;
                long already_read = (long)lpEcb->cbAvailable - s->content_read;
      
                if (already_read >= (long)len) {
                    memcpy(buf, lpEcb->lpbData + s->content_read, len);
                    *actually_read = len;
                } else {
                    /*
                     * Try to copy what we already have 
                     */
                    if (already_read > 0) {
                        memcpy(buf, lpEcb->lpbData + s->content_read, already_read);
                        buf   += already_read;
                        len   -= already_read;
//                        s->content_read = lpEcb->cbAvailable;
            
                        *actually_read = already_read;
                    }
                    if ((s->content_read+*actually_read)==lpEcb->cbTotalBytes) {
                        s->end_of_stream=JK_TRUE;
                    }
                    /*
                     * Now try to read from the client ...
                     */
                    if (!s->end_of_stream ) {
                        if ( lpEcb->ReadClient(lpEcb->ConnID, buf, &len)) {
                            *actually_read +=  len;            
                        } else {
                            env->l->jkLog(env,env->l, JK_LOG_ERROR, 
                                   "jk_ws_service_t::read, ReadClient failed\n");
                            return JK_OK;
                        }
                    }
                }
            }
        }
        if ((s->content_read+*actually_read)==lpEcb->cbTotalBytes) {
            s->end_of_stream=JK_TRUE;
        }
        return JK_OK;
    }
    
    env->l->jkLog(env, env->l, JK_LOG_ERROR, 
                  "jk_ws_service_t::read, NULL parameters\n");
    return JK_ERR;
}

static int JK_METHOD jk2_service_iis_write(jk_env_t *env, jk_ws_service_t *s,
                                           const void *b, unsigned len)
{
    env->l->jkLog(env, env->l, JK_LOG_DEBUG, 
                  "Into jk_ws_service_t::write\n");
    
    if (s && s->ws_private && b) {
        LPEXTENSION_CONTROL_BLOCK  lpEcb=(LPEXTENSION_CONTROL_BLOCK)s->ws_private;
        
        if (len) {
            unsigned written = 0;           
            char *buf = (char *)b;
            
            if (!s->response_started) {
                s->head(env, s );
            }
            
            while(written < len) {
                DWORD try_to_write = len - written;
                if (!lpEcb->WriteClient(lpEcb->ConnID, 
                                        buf + written, 
                                        &try_to_write, 
                                        0)) {
                    env->l->jkLog(env, env->l, JK_LOG_ERROR, 
                           "jk_ws_service_t::write, WriteClient failed\n");
                    return JK_ERR;
                }
                written += try_to_write;
            }
        }
        
        return JK_OK;
        
    }
    
    env->l->jkLog(env, env->l, JK_LOG_ERROR, 
           "jk_ws_service_t::write, NULL parameters\n");
    
    return JK_ERR;
}

int get_server_value(LPEXTENSION_CONTROL_BLOCK lpEcb,
                            char *name,
                            char  *buf,
                            DWORD bufsz,
                            char  *def_val)
{
    if (!lpEcb->GetServerVariable(lpEcb->ConnID, 
                                 name,
                                 buf,
                                 (LPDWORD)&bufsz)) {
        strcpy(buf, def_val);
        return JK_FALSE;
    }

    if (bufsz > 0) {
        buf[bufsz - 1] = '\0';
    }

    return JK_TRUE;
}

#define MAX_NAME 256

char * jk2_service_iis_get_roles(jk_env_t *env, jk_ws_service_t *s)
{
    LPEXTENSION_CONTROL_BLOCK  lpEcb=(LPEXTENSION_CONTROL_BLOCK)s->ws_private;
    HANDLE h;
    DWORD len=0;
    PTOKEN_GROUPS g=NULL;
    unsigned i;
    char *roles=NULL;
    if ( lpEcb->ServerSupportFunction(lpEcb->ConnID,
                                      HSE_REQ_GET_IMPERSONATION_TOKEN,
                                      (LPVOID)&h, NULL,NULL) != FALSE ){
        // First get the length of the user's groups array and gets the memory 
        if ( !GetTokenInformation(h, TokenGroups, NULL, len , &len ) ) {
            if ( ERROR_INSUFFICIENT_BUFFER == GetLastError() ){
                g = (PTOKEN_GROUPS)s->pool->calloc(env,s->pool,len);
            }
        }
        if ( g != NULL ){
            if ( GetTokenInformation(h, TokenGroups, g, len, &len)) {
                roles=s->pool->calloc(env,s->pool,(g->GroupCount)*MAX_NAME);
                for (i=0; i < g->GroupCount ; i++){
                    char name[MAX_NAME],domain[MAX_NAME];
                    DWORD nLen = MAX_NAME, dLen = MAX_NAME;