jk_service_iis.c

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

                    SID_NAME_USE eUse;
                    // Get  the user name and the domain from the SID.
                    env->l->jkLog(env, env->l, JK_LOG_DEBUG, 
                           "jk2_service_iis_get_roles requesting name for member:%d attributes:%#lx SID:%#lx \n",
                            i,g->Groups[i].Attributes, g->Groups[i].Sid );
                    if ( ! LookupAccountSid(NULL,g->Groups[i].Sid,name,&nLen,domain,&dLen,&eUse) ){
                        env->l->jkLog(env, env->l, JK_LOG_INFO, 
                               "jk2_service_iis_get_roles problems requesting name for member:%d attributes:%#lx SID:%#lx \n",
                                i,g->Groups[i].Attributes, g->Groups[i].Sid );
                            
                    } else {
                        strcpy(roles+strlen(roles),name);
                        roles[strlen(roles)]=',';
                        roles[strlen(roles)+1]='\0';
                        env->l->jkLog(env, env->l, JK_LOG_DEBUG, 
                               "jk2_service_iis_get_roles member:%d attributes:%#lx SID:%#lx name:%s\n",
                                i,g->Groups[i].Attributes, g->Groups[i].Sid,name );
                    }
                }
                roles[strlen(roles)-1]='\0';
                env->l->jkLog(env, env->l, JK_LOG_INFO, 
                       "jk_ws_service_t::jk2_service_iis_get_roles roles:%s \n",
                        roles );
            }
            return roles;
        } else {
            return NULL;
        }
    }
    return NULL;
}

static int JK_METHOD jk2_service_iis_initService( struct jk_env *env, jk_ws_service_t *s,
                 struct jk_worker *w, void *serverObj )
/* */
{
    LPEXTENSION_CONTROL_BLOCK  lpEcb=(LPEXTENSION_CONTROL_BLOCK)serverObj;
    char huge_buf[16 * 1024]; /* should be enough for all */

    DWORD huge_buf_sz;

    s->jvm_route = NULL;

    GET_SERVER_VARIABLE_VALUE(s->pool,HTTP_URI_HEADER_NAME, s->req_uri);     
    GET_SERVER_VARIABLE_VALUE(s->pool,HTTP_QUERY_HEADER_NAME, s->query_string);     
    
    if (s->req_uri == NULL) {
        s->query_string = lpEcb->lpszQueryString;
        /* *worker_name    = DEFAULT_WORKER_NAME; */
        GET_SERVER_VARIABLE_VALUE(s->pool,"URL", s->req_uri);       
        if (jk_requtil_unescapeUrl(s->req_uri) < 0)
            return JK_ERR;
        jk_requtil_getParents(s->req_uri);
    }
    
    GET_SERVER_VARIABLE_VALUE(s->pool,"AUTH_TYPE", s->auth_type);
    GET_SERVER_VARIABLE_VALUE(s->pool,"REMOTE_USER", s->remote_user);
    GET_SERVER_VARIABLE_VALUE(s->pool,"SERVER_PROTOCOL", s->protocol);
    GET_SERVER_VARIABLE_VALUE(s->pool,"REMOTE_HOST", s->remote_host);
    GET_SERVER_VARIABLE_VALUE(s->pool,"REMOTE_ADDR", s->remote_addr);
    GET_SERVER_VARIABLE_VALUE(s->pool,SERVER_NAME, s->server_name);
    GET_SERVER_VARIABLE_VALUE_INT("SERVER_PORT", s->server_port, 80);
    GET_SERVER_VARIABLE_VALUE(s->pool,SERVER_SOFTWARE, s->server_software);
    GET_SERVER_VARIABLE_VALUE_INT("SERVER_PORT_SECURE", s->is_ssl, 0);

    s->method           = lpEcb->lpszMethod;
    s->content_length   = lpEcb->cbTotalBytes;
    s->end_of_stream    = JK_FALSE;

    s->ssl_cert     = NULL;
    s->ssl_cert_len = 0;
    s->ssl_cipher   = NULL;
    s->ssl_session  = NULL;
    s->ssl_key_size = -1;

    if (JK_OK!=jk2_map_default_create(env, &s->headers_out, s->pool )){
        env->l->jkLog(env, env->l, JK_LOG_ERROR, 
               "jk_ws_service_t::init, Failed to create headers_out map \n");
        return JK_ERR;

    }
    if (JK_OK!=jk2_map_default_create(env, &s->attributes, s->pool )){
        env->l->jkLog(env, env->l, JK_LOG_ERROR, 
               "jk_ws_service_t::init, Failed to create attributes map \n");
        return JK_ERR;

    }
    if (JK_OK!=jk2_map_default_create(env, &s->headers_in, s->pool )){
        env->l->jkLog(env, env->l, JK_LOG_ERROR, 
               "jk_ws_service_t::init, Failed to create headers_in map \n");
        return JK_ERR;
    }
//    s->headers_values   = NULL;
//  s->num_headers      = 0;
    
    /*
     * Add SSL IIS environment
     */

    if ( strlen(s->remote_user) > 0 ){
        char *groups=jk2_service_iis_get_roles(env, s);
        if( groups != NULL){
            s->attributes->put( env, s->attributes,ROLES_ATTRIBUTE_NAME,groups,NULL);
        }
    }

    if (s->is_ssl) {         
        char *ssl_env_names[9] = {
            "CERT_ISSUER", 
            "CERT_SUBJECT", 
            "CERT_COOKIE", 
            "HTTPS_SERVER_SUBJECT", 
            "CERT_FLAGS", 
            "HTTPS_SECRETKEYSIZE", 
            "CERT_SERIALNUMBER", 
            "HTTPS_SERVER_ISSUER", 
            "HTTPS_KEYSIZE"
        };
        char *ssl_env_values[9] = {
            NULL, 
            NULL, 
            NULL, 
            NULL, 
            NULL, 
            NULL, 
            NULL, 
            NULL, 
            NULL
        };
        unsigned i;
        unsigned num_of_vars = 0;

        for(i = 0 ; i < 9 ; i++) {
            GET_SERVER_VARIABLE_VALUE(s->pool,ssl_env_names[i], ssl_env_values[i]);
            if (ssl_env_values[i]) {
                num_of_vars++;
            }
        }
        if (num_of_vars) {
            unsigned j=0;
            for(i = 0 ; i < 9 ; i++) {                
                if (ssl_env_values[i]) {
                    s->attributes->put( env, s->attributes, 
                                        ssl_env_names[i], ssl_env_values[i],NULL);
                    j++;
                }
            }
            if (ssl_env_values[4] && ssl_env_values[4][0] == '1') {
                CERT_CONTEXT_EX cc;
                DWORD cc_sz = sizeof(cc);
                cc.cbAllocated = sizeof(huge_buf);
                cc.CertContext.pbCertEncoded = (BYTE*) huge_buf;
                cc.CertContext.cbCertEncoded = 0;
                
                if (lpEcb->ServerSupportFunction(lpEcb->ConnID,
                                                 (DWORD)HSE_REQ_GET_CERT_INFO_EX,                               
                                                 (LPVOID)&cc,NULL,NULL) != FALSE)
                    {
                        env->l->jkLog(env, env->l, JK_LOG_DEBUG,"Client Certificate encoding:%d sz:%d flags:%ld\n",
                                      cc.CertContext.dwCertEncodingType & X509_ASN_ENCODING ,
                                      cc.CertContext.cbCertEncoded,
                                      cc.dwCertificateFlags);
                        s->ssl_cert=s->pool->alloc(env, s->pool,
                                                   jk_requtil_base64CertLen(cc.CertContext.cbCertEncoded));
                        
                        s->ssl_cert_len = jk_requtil_base64EncodeCert(s->ssl_cert,
                                                                      huge_buf,cc.CertContext.cbCertEncoded) - 1;
                    }
            }
        }
    }

    
    huge_buf_sz = sizeof(huge_buf);         
    if (get_server_value(lpEcb,
                         "ALL_HTTP",             
                         huge_buf,           
                         huge_buf_sz,        
                         "")) {              
        unsigned cnt = 0;
        char *tmp;

        for(tmp = huge_buf ; *tmp ; tmp++) {
            if (*tmp == '\n'){
                cnt++;
            }
        }
        
        if (cnt) {
            char *headers_buf = s->pool->pstrdup(env, s->pool, huge_buf);
            unsigned i;
            unsigned len_of_http_prefix = strlen("HTTP_");
            BOOL need_content_length_header = (s->content_length == 0);
            
            cnt -= 2; /* For our two special headers */
            /* allocate an extra header slot in case we need to add a content-length header */
            for(i = 0, tmp = headers_buf ; *tmp && i < cnt ; ) {
                int real_header = JK_TRUE;
                char *headerName;
                /* Skipp the HTTP_ prefix to the beginning of th header name */
                tmp += len_of_http_prefix;

                if (!strnicmp(tmp, URI_HEADER_NAME, strlen(URI_HEADER_NAME)) ||
                    !strnicmp(tmp, WORKER_HEADER_NAME, strlen(WORKER_HEADER_NAME))) {
                    real_header = JK_FALSE;
                } else if(need_content_length_header &&
                          !strnicmp(tmp, CONTENT_LENGTH, strlen(CONTENT_LENGTH))) {
                    need_content_length_header = FALSE;
                    headerName  = tmp;
                } else if (!strnicmp(tmp, TOMCAT_TRANSLATE_HEADER_NAME,
                                     strlen(TOMCAT_TRANSLATE_HEADER_NAME))) {
                    tmp += 6; /* TOMCAT */
                    headerName  = tmp;
                } else {
                    headerName  = tmp;
                }
                
                while(':' != *tmp && *tmp) {
                    if ('_' == *tmp) {
                        *tmp = '-';
                    } else {
                        *tmp = tolower(*tmp);
                    }
                    tmp++;
                }
                *tmp = '\0';
                tmp++;

                /* Skip all the WS chars after the ':' to the beginning of th header value */
                while(' ' == *tmp || '\t' == *tmp || '\v' == *tmp) {
                    tmp++;
                }

                if (real_header) {
                    s->headers_in->put( env, s->headers_in, headerName, tmp, NULL );
                }
                
                while(*tmp != '\n' && *tmp != '\r') {
                    tmp++;
                }
                *tmp = '\0';
                tmp++;
                
                /* skipp CR LF */
                while(*tmp == '\n' || *tmp == '\r') {
                    tmp++;
                }
                
                if (real_header) {
                    i++;
                }
            }
            /* Add a content-length = 0 header if needed.
             * Ajp13 assumes an absent content-length header means an unknown,
             * but non-zero length body.
             */
            if(need_content_length_header) {
                s->headers_in->put( env, s->headers_in,
                                    "content-length", "0",NULL);
                cnt++;
            }
        } else {
            /* We must have our two headers */
            return JK_ERR;
        }
    } else {
        return JK_ERR;
    }
    
    return JK_OK;
}

static void JK_METHOD jk2_service_iis_afterRequest(jk_env_t *env, jk_ws_service_t *s )
{
    
    if (s->content_read < s->content_length ||
        (s->is_chunked && ! s->no_more_chunks)) {

        LPEXTENSION_CONTROL_BLOCK  lpEcb=(LPEXTENSION_CONTROL_BLOCK)s->ws_private;

#if 0
        char *buff = s->pool->calloc(env,s->pool, 2048);
        if (buff != NULL) {
            /* int rd; */
            /* FIXME Is there a IIS equivalent ? */
            /*             while ((rd = ap_get_client_block(r, buff, 2048)) > 0) { */
            /*                 s->content_read += rd; */
            /*             } */
        }
#endif
    }
}


int jk2_service_iis_init(jk_env_t *env, jk_ws_service_t *s)
{
    if(s==NULL ) {
        return JK_ERR;
    }
    jk2_requtil_initRequest(env, s);
    s->head   = jk2_service_iis_head;
    s->read   = jk2_service_iis_read;
    s->write  = jk2_service_iis_write;
    s->init   = jk2_service_iis_initService;
    s->afterRequest = jk2_service_iis_afterRequest;
    
    return JK_OK;
}