jk_workerenv.c

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

    if( wEnv->shm != NULL && ! wEnv->shm->mbean->disabled ) {
        wEnv->shm->init( env, wEnv->shm );
    }

    wEnv->epStat=NULL;
    
    wEnv->uriMap->init(env, wEnv->uriMap );

    env->l->jkLog(env, env->l, JK_LOG_INFO, "workerEnv.init() ok %s\n", configFile );
    return JK_OK;
}

static int jk2_workerEnv_dispatch(jk_env_t *env, jk_workerEnv_t *wEnv,
                                  void *target, jk_endpoint_t *e, int code, jk_msg_t *msg)
{
    jk_handler_t *handler;
    int rc;
    jk_handler_t **handlerTable=wEnv->handlerTable;
    int maxHandler=wEnv->lastMessageId;
    
    rc=-1;
    handler=NULL;
        
    if( code < maxHandler ) {
        handler=handlerTable[ code ];
    }
    
    if( handler==NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "workerEnv.dispatch() Invalid code: %d\n", code);
        e->reply->dump(env, e->reply, "Message: ");
        return JK_ERR;
    }

    if( wEnv->mbean->debug > 0 ) 
        env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                      "workerEnv.dispatch() Calling %d %s\n", handler->messageId,
                      handler->name);
    
    /* Call the message handler */
    rc=handler->callback( env, target, e, msg );
    return rc;
}

/* XXX This should go to channel ( or a base class for socket channels ) */
/*
 * Process incoming messages.
 *
 * We will know only at read time if the remote host closed
 * the connection (half-closed state - FIN-WAIT2). In that case
 * we must close our side of the socket and abort emission.
 * We will need another connection to send the request
 * There is need of refactoring here since we mix 
 * reply reception (tomcat -> apache) and request send (apache -> tomcat)
 * and everything using the same buffer (repmsg)
 * ajp13/ajp14 is async but handling read/send this way prevent nice recovery
 * In fact if tomcat link is broken during upload (browser ->apache ->tomcat)
 * we'll loose data and we'll have to abort the whole request.
 */
static int jk2_workerEnv_processCallbacks(jk_env_t *env, jk_workerEnv_t *wEnv,
                                          jk_endpoint_t *ep, jk_ws_service_t *req )
{
    int code;
    jk_handler_t *handler;
    int rc;
    jk_handler_t **handlerTable=wEnv->handlerTable;
    int maxHandler=wEnv->lastMessageId;

    ep->currentRequest=req;
    
    /* Process reply - this is the main loop */
    /* Start read all reply message */
    while(1) {
        jk_msg_t *msg=ep->reply;
        rc=-1;
        handler=NULL;

        if( ep->worker->mbean->debug > 0 )
            env->l->jkLog(env, env->l, JK_LOG_DEBUG,
                          "workerEnv.callbacks() %s\n",
                          ep->worker->channel->mbean->name);
        
        msg->reset(env, msg);
        
        rc= ep->worker->channel->recv( env, ep->worker->channel,  ep,
                                       msg);
        if( rc!=JK_OK ) {
            env->l->jkLog(env, env->l, JK_LOG_ERROR,
                          "workerEnv.processCallbacks() Error reading reply\n");
            /* It may be the first receive, let the caller decide if it's ok to retry
             */
            /* ep->recoverable=JK_FALSE; */
            return rc;
        }

        /** After I received the first message ( head most likely ), it
            is impossible to recover */
        ep->recoverable=JK_FALSE;
        
        if( ep->worker->mbean->debug > 10 )
            ep->request->dump( env, msg, "Received" );

        /* XXX Use this _only_ for backward compatibility.
           invoke() and jk_bean should be used, probably with a first parameter
           indicating the target component and a second param indicating the
           code ( local to each component ).
        */
        code = (int)msg->getByte(env, msg);
        rc=jk2_workerEnv_dispatch( env, wEnv, req, ep, code, msg );

        /* Process the status code returned by handler */
        switch( rc ) {
        case JK_HANDLER_LAST:
            /* no more data to be sent, fine we have finish here */
            return JK_OK;
        case JK_HANDLER_OK:
            /* One-time request, continue to listen */
            break;
        case JK_HANDLER_RESPONSE:
            /* 
             * in upload-mode there is no second chance since
             * we may have allready send part of uploaded data 
             * to Tomcat.
             * In this case if Tomcat connection is broken we must 
             * abort request and indicate error.
             * A possible work-around could be to store the uploaded
             * data to file and replay for it
             */
            req->is_recoverable_error = JK_FALSE;
            if( ep->worker->mbean->debug > 10 )
                msg->dump( env, msg, "Apache->tomcat" );

            rc = ep->worker->channel->send(env, ep->worker->channel, ep,
                                           msg );
            if (rc < 0) {
                env->l->jkLog(env, env->l, JK_LOG_ERROR,
                              "ajp14.processCallbacks() error sending response data\n");
                ep->recoverable = JK_FALSE;
                return rc;
            }
            break;
        case JK_HANDLER_ERROR:
            /* Normal error ( for example writing to the client failed ).
             * The ajp connection is still in a stable state.
             */
            ep->recoverable = JK_TRUE;
            return rc;
        case JK_HANDLER_FATAL:
            /*
             * Protocol error. We'll disconnect the ajp connection and reconnect.
             */
            ep->recoverable = JK_FALSE; 
            return rc;
        default:
            /* Unknown status */
            env->l->jkLog(env, env->l, JK_LOG_ERROR,
                          "ajp14.processCallbacks() unknonwn status %d\n", rc);
            ep->recoverable = JK_FALSE; 
            return rc;
        }
    }
    return JK_ERR;
}

static int jk2_workerEnv_addChannel(jk_env_t *env, jk_workerEnv_t *wEnv,
                                    jk_channel_t *ch) 
{
    int err=JK_OK;
    jk_bean_t *jkb;
    
    ch->mbean->id=wEnv->channel_map->size( env, wEnv->channel_map );
    wEnv->channel_map->add(env, wEnv->channel_map, ch->mbean->name, ch);

    /* Automatically create the ajp13 worker to be used with this channel.
     */
    jkb=env->createBean2(env, ch->mbean->pool, "ajp13", ch->mbean->localName );
    if( jkb == NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "workerEnv.addChannel(): Can't find ajp13 worker\n" );
        return JK_ERR;
    }
    ch->worker=jkb->object;
    ch->worker->channelName=ch->mbean->name;
    ch->worker->channel=ch;
            
    return JK_OK;
}

static int jk2_workerEnv_addEndpoint(jk_env_t *env, jk_workerEnv_t *wEnv, jk_endpoint_t *ep)
{
    int pos=wEnv->endpointMap->size( env, wEnv->endpointMap );
    
    wEnv->endpointMap->add( env, wEnv->endpointMap, ep->mbean->localName, ep );
    ep->mbean->id=pos;
    
    if (ep->mbean->init( env, ep->mbean )==JK_ERR)
        return JK_ERR;

    return JK_OK;
}


static int jk2_workerEnv_addWorker(jk_env_t *env, jk_workerEnv_t *wEnv,
                                   jk_worker_t *w) 
{
    int err=JK_OK;
    jk_worker_t *oldW = NULL;
    
    w->workerEnv=wEnv;

    w->mbean->id=wEnv->worker_map->size( env, wEnv->worker_map );

    w->rPoolCache= jk2_objCache_create( env, w->mbean->pool  );

    err=w->rPoolCache->init( env, w->rPoolCache,
                             1024 ); /* XXX make it unbound */

    wEnv->worker_map->put(env, wEnv->worker_map, w->mbean->name, w, (void *)&oldW);
            
    if(oldW!=NULL) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "workerEnv.addWorker() duplicated %s worker \n",
                      w->mbean->name);
        if( w->mbean->destroy != NULL )
            oldW->mbean->destroy(env, oldW->mbean);
    }
    
    return JK_OK;
}

static jk_worker_t *jk2_workerEnv_createWorker(jk_env_t *env,
                                               jk_workerEnv_t *wEnv,
                                               char *type, char *name) 
{
    int err=JK_OK;
    jk_worker_t *w = NULL;
    jk_worker_t *oldW = NULL;
    jk_bean_t *jkb;

    /* First find if it already exists */
    w=env->getByName( env, name );
    if( w != NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_INFO,
                      "workerEnv.createWorker(): Using existing worker %s\n",
                      name);
        return w;
    }
    
    jkb=env->createBean(env, wEnv->pool, name );

    if( jkb == NULL || jkb->object==NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "workerEnv.createWorker(): factory can't create worker %s:%s\n",
                      type, name); 
        return NULL;
    }
    w=(jk_worker_t *)jkb->object;

    return w;
}


int JK_METHOD jk2_workerEnv_factory(jk_env_t *env, jk_pool_t *pool,
                                    jk_bean_t *result,
                                    const char *type, const char *name)
{
    jk_workerEnv_t *wEnv;
    jk_bean_t *jkb;

    wEnv=(jk_workerEnv_t *)pool->calloc( env, pool, sizeof( jk_workerEnv_t ));

    /* env->l->jkLog(env, env->l, JK_LOG_DEBUG, "Creating workerEnv %#lx\n", wEnv); */

    result->object=wEnv;
    wEnv->mbean=result;
    result->setAttribute=jk2_workerEnv_setAttribute;
    
    wEnv->pool=pool;

    wEnv->initData = NULL;
    jk2_map_default_create(env, & wEnv->initData, pool);
    
    /* Add 'compile time' settings. Those are defined in jk_global,
       with the other platform-specific settings. No need to ask
       the user what we can find ourself
    */
    wEnv->initData->put( env, wEnv->initData, "fs",
                           FILE_SEPARATOR_STR, NULL );
    wEnv->initData->put( env, wEnv->initData, "ps",
                           PATH_SEPARATOR_STR, NULL );
    wEnv->initData->put( env, wEnv->initData, "so",
                           SO_EXTENSION, NULL );
    wEnv->initData->put( env, wEnv->initData, "arch",
                           ARCH, NULL );


    wEnv->logger_name     = NULL;
    wEnv->was_initialized = JK_FALSE;
    wEnv->options         = JK_OPT_FWDURIDEFAULT;

    /*
     * By default we will try to gather SSL info.
     * Disable this functionality through JkExtractSSL
     */
    wEnv->ssl_enable  = JK_TRUE;
    /*
     * The defaults ssl indicators match those in mod_ssl (seems
     * to be in more use).
     */
    wEnv->https_indicator  = "HTTPS";
    wEnv->certs_indicator  = "SSL_CLIENT_CERT";

    /*
     * The following (comented out) environment variables match apache_ssl!
     * If you are using apache_sslapache_ssl uncomment them (or use the
     * configuration directives to set them.
     *
    wEnv->cipher_indicator = "HTTPS_CIPHER";
    wEnv->session_indicator = NULL;
     */

    /*
     * The following environment variables match mod_ssl! If you
     * are using another module (say apache_ssl) comment them out.
     */
    wEnv->cipher_indicator = "SSL_CIPHER";
    wEnv->session_indicator = "SSL_SESSION_ID";
    wEnv->key_size_indicator = "SSL_CIPHER_USEKEYSIZE";

    /*     if(!map_alloc(&(wEnv->automount))) { */
    /*         jk_error_exit(APLOG_MARK, APLOG_EMERG, s, p, "Memory error"); */
    /*     } */

    wEnv->uriMap = NULL;

    wEnv->envvars_in_use = JK_FALSE;
    jk2_map_default_create(env, &wEnv->envvars, pool);

    jk2_map_default_create(env, &wEnv->worker_map, wEnv->pool);
    jk2_map_default_create(env, &wEnv->channel_map, wEnv->pool);
    jk2_map_default_create(env, &wEnv->endpointMap, wEnv->pool);

    wEnv->perThreadWorker=0;
    
    /* methods */
    wEnv->init=&jk2_workerEnv_init;
    wEnv->parentInit=&jk2_workerEnv_parentInit;
    wEnv->close=&jk2_workerEnv_close;
    wEnv->addWorker=&jk2_workerEnv_addWorker;
    wEnv->addChannel=&jk2_workerEnv_addChannel;
    wEnv->addEndpoint=&jk2_workerEnv_addEndpoint;
    wEnv->initChannel=&jk2_workerEnv_initChannel;
    wEnv->registerHandler=&jk2_workerEnv_registerHandler;
    wEnv->processCallbacks=&jk2_workerEnv_processCallbacks;
    wEnv->dispatch=&jk2_workerEnv_dispatch;
    wEnv->globalEnv=env;

    jkb=env->createBean2(env, wEnv->pool,"uriMap", "");
    if( jkb==NULL || jkb->object==NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "Error getting uriMap implementation\n");
        return JK_ERR;
    }
    wEnv->uriMap=jkb->object;
    wEnv->uriMap->workerEnv = wEnv;
    
    jkb=env->createBean2(env, wEnv->pool,"config", "");
    if( jkb==NULL ) {
        env->l->jkLog(env, env->l, JK_LOG_ERROR,
                      "Error creating config\n");
        return JK_ERR;
    }
    env->alias(env, "config:", "config");
    wEnv->config=jkb->object;
    wEnv->config->file = NULL;
    wEnv->config->workerEnv = wEnv;
    wEnv->config->map = wEnv->initData;

    wEnv->childId=-1;

    wEnv->epStat=NULL;
    jkb=env->createBean2(env, wEnv->pool,"shm", "");
    if( jkb==NULL ) {
        wEnv->shm=NULL;
    } else {
        env->alias(env, "shm:", "shm");
        wEnv->shm=(jk_shm_t *)jkb->object;
    }

    return JK_OK;
}