ctrlcomm.cc

网络流量采集及分析软件

void CtrlComm::sendErrMsg(string msg, struct REQUEST *req, fd_sets_t *fds)
{
    string rep = rtemplate;

    rep.replace(rep.find("@STATUS@"), strlen("@STATUS@"), "Error");
    rep.replace(rep.find("@MESSAGE@"), strlen("@MESSAGE@"), xmlQuote(msg));
#ifdef DEBUG2
    cerr << rep;
#endif
    req->body = strdup(rep.c_str());
    req->mime = "text/xml";
    if (fds != NULL) {
        httpd_send_response(req, fds);
    } else {
        httpd_send_immediate_response(req);
    }
}


/* -------------------- handleFDEvent -------------------- */

int CtrlComm::handleFDEvent(eventVec_t *e, fd_set *rset, fd_set *wset, fd_sets_t *fds)
{
    assert(e != NULL);

    // make the pointer global for ctrlcomm
    retEventVec = e;
    retEvent = NULL;

    // check for incoming message
    if (httpd_handle_event(rset, wset, fds) < 0) {
        throw Error("ctrlcomm handle event error");
    }

    // processCmd callback funtion is called in case of new request

    // return resulting event (freed by event scheduler)
    return 0;
}


/* -------------------- processCmd -------------------- */

parseReq_t CtrlComm::parseRequest(struct REQUEST *req)
{
    parseReq_t preq;

    preq.comm = req->path;

    // parse headers
    struct strlist *hdr = req->header;
    while (hdr) {
        string l = hdr->line;
        int p = l.find(":");
        if (p > 0) {
            preq.params[l.substr(0,p)] = l.substr(p+1, l.length());
        }
        hdr = hdr->next;
    }

    // parse URL parameters
    if (req->query != NULL) {
        string q = req->query;
    
        int p1 = 0, p2 = q.length(), p3 = 0;
        while((p2 = q.find("&",p1)) > 0) {
            cerr << p2 << endl;
            p3 = q.find("=",p1);
            if (p3 > 0) {
                preq.params[q.substr(p1,p3-p1)] = q.substr(p3+1, p2-p3-1);
            }

            p1 = p2+1;
        } 
        p3 = q.find("=",p1);
        if (p3 > 0) {
            preq.params[q.substr(p1,p3-p1)] = q.substr(p3+1, p2-p3-1);
        }
    
    }

    // parse POST parameters in body
    if (req->lbreq != 0) {
        string q = req->post_body;
    
        int p1 = 0, p2 = q.length(), p3 = 0;
        while((p2 = q.find("&",p1)) > 0) {
            p3 = q.find("=",p1);
            if (p3 > 0) {
                preq.params[q.substr(p1,p3-p1)] = q.substr(p3+1, p2-p3-1);
            }

            p1 = p2+1;
        } 
        p3 = q.find("=",p1);
        if (p3 > 0) {
            preq.params[q.substr(p1,p3-p1)] = q.substr(p3+1, p2-p3-1);
        }
    
    }

#ifdef DEBUG
    for (paramListIter_t iter=preq.params.begin(); iter != preq.params.end(); iter++) {
        cerr << iter->first << "::" << iter->second << endl;
    }
#endif

    return preq;
}


int CtrlComm::processCmd(struct REQUEST *req)
{
    parseReq_t preq;
    
#ifdef PROFILING
    unsigned long long ini, end;
#endif

#ifdef PROFILING
    ini = PerfTimer::readTSC();
#endif

#ifdef DEBUG
    cerr << "client requested cmd: '" << req->path << "' and params '" << req->query 
         << req->post_body << "'" << endl;
#endif

    if (isEnabled(LOG_COMMAND)) {
        log->log(ch, "client requested cmd: '%s' and params '%s%s'", req->path, req->query,
                 req->post_body);
    }

    if ((req->path == NULL) || (strlen(req->path) == 0)) {
        return -1;
    }

    preq = parseRequest(req);

    // try lookup in repository of static meter pages
    string page = pcache.getPage(preq.comm); 

    try {
        if (page != "") {
            // send page
            req->body = strdup(page.c_str());  // FIXME not very performant
            req->mime = get_mime((char *) pcache.getFileName(preq.comm).c_str());
            // generate Expires header
            req->lifespan = EXPIRY_TIME;
            // immediatly send response
            httpd_send_immediate_response(req);
            
            // FIXME  better register those callback funtions onto the command name
        } else if (preq.comm == "/get_info") {
            processGetInfo(&preq);
        } else if (preq.comm == "/get_modinfo") {
            processGetModInfo(&preq);
        } else if (preq.comm == "/add_task") {
            processAddTask(&preq);
        } else if (preq.comm == "/rm_task") {
            processDelTask(&preq);
        } else {
            // unknown command will produce a 404 http error
            return -1;
        }
    } catch (Error &e) {
        sendErrMsg(e.getError(), req, NULL);
        return 0;
    }
    
#ifdef PROFILING
    end = PerfTimer::readTSC();
   
    cerr << "parse cmd in " << PerfTimer::ticks2ns(end-ini) << " ns" << endl;
#endif

    if (retEvent != NULL) {
        retEvent->setReq(req);
        retEventVec->push_back(retEvent);
    }

    return 0;
}


/* ------------------------- processAddTaskCmd ------------------------- */

char *CtrlComm::processAddTask(parseReq_t *preq)
{
    paramListIter_t rule = preq->params.find("Rule");

    if (rule == preq->params.end()) {
        throw Error("add_task: missing parameter 'Rule'" );
    }

    // FIXME sufficient?
    if (rule->second.find("!DOCTYPE RULESET") <= rule->second.length()) {
        // assume xml rule def
        retEvent = new AddRulesCtrlEvent((char *) rule->second.c_str(), rule->second.size());
    } else {
        retEvent = new AddRulesCtrlEvent((char *) rule->second.c_str(), rule->second.size(), 1);
    }

    return NULL;
}


/* ------------------------- processDelTaskCmd ------------------------- */

char *CtrlComm::processDelTask(parseReq_t *preq )
{
    paramListIter_t id = preq->params.find("RuleID");

    if (id == preq->params.end() ) {
        throw Error("rm_task: missing parameter 'RuleID'" );
    }
    
    retEvent = new RemoveRulesCtrlEvent(id->second);
  
    return NULL;
}


/* ------------------------- processGetInfo ------------------------- */

char *CtrlComm::processGetInfo( parseReq_t *preq )
{
    MeterInfo infos;

    paramListIter_t type = preq->params.find("IType");
    paramListIter_t param = preq->params.find("IParam");
    
    if (type == preq->params.end()) {
        throw Error("get_info: missing parameter 'IType'" );
    }
   
    if (param == preq->params.end()) {
        infos.addInfo(type->second);
    } else { 
        infos.addInfo(type->second, param->second);
    }

    retEvent = new GetInfoEvent(infos.getList());
    
    return NULL;
}


/* ------------------------- processGetModInfo ------------------------- */

char *CtrlComm::processGetModInfo( parseReq_t *preq )
{
    paramListIter_t name = preq->params.find("IName");
    
    if (name == preq->params.end()) {
        throw Error("get_modinfo: missing parameter 'IName'" );
    }
   
    retEvent = new GetModInfoEvent(name->second);

    return NULL;
}


/* -------------------- logAccess -------------------- */

int CtrlComm::logAccess(struct REQUEST *req, time_t now )
{
  
    if (isEnabled(LOG_CONNECT)) {
        if (0 == req->status) {
            req->status = 400; /* bad request */
        }
        if (400 == req->status) {
            log->log(ch,"%s - - \"-\" 400 %d",
                     req->peerhost,
                     req->bc);
        } else {
            log->log(ch,"%s - - \"%s %s HTTP/%d.%d\" %d %d",
                     req->peerhost,
                     req->type,
                     req->uri,
                     req->major,
                     req->minor,
                     req->status,
                     req->bc);
        }
    }

    return 0;
}


int CtrlComm::logError(int eno, int loglevel, char *txt, char *peerhost)
{
    char buf[256];
  
    buf[0] = '\0';

    // FIXME loglevel is currently ignored
    if (eno) {
        if (peerhost) {
            sprintf(buf,"%s: %s (peer=%s)", txt, strerror(errno), peerhost);
        } else {
            sprintf(buf,"%s: %s", txt, strerror(errno));
        }
    } else {
        if (peerhost) {
            sprintf(buf,"%s (peer=%s)", txt, peerhost);
        } else {
            sprintf(buf,"%s", txt);
        }
    }

    log->elog(ch,"%s", buf);

    return 0;
}


/* ------------------------- dump ------------------------- */

void CtrlComm::dump( ostream &os )
{
    os << "CtrlComm dump : listening on port " << portnum  << endl ;
}


/* ------------------------- operator<< ------------------------- */

ostream& operator<< ( ostream &os, CtrlComm &cio )
{
    cio.dump(os);
    return os;
}