コード例 #1
0
ファイル: mk_connection.c プロジェクト: leowzukw/monkey
int mk_conn_read(int socket)
{
    int ret;
    int status;
    struct mk_http_session *cs;
    struct mk_http_request *sr;
    struct sched_list_node *sched;

    MK_TRACE("[FD %i] Connection Handler / read", socket);

    /* Plugin hook */
    ret = mk_plugin_event_read(socket);

    switch (ret) {
    case MK_PLUGIN_RET_EVENT_OWNED:
        return MK_PLUGIN_RET_CONTINUE;
    case MK_PLUGIN_RET_EVENT_CLOSE:
        return -1;
    case MK_PLUGIN_RET_EVENT_CONTINUE:
        break; /* just return controller to invoker */
    }

    sched = mk_sched_get_thread_conf();
    cs = mk_http_session_get(socket);
    if (!cs) {
        /* Check if is this a new connection for the Scheduler */
        if (!mk_sched_get_connection(sched, socket)) {
            MK_TRACE("[FD %i] Registering new connection");
            if (mk_sched_register_client(socket, sched) == -1) {
                MK_TRACE("[FD %i] Close requested", socket);
                return -1;
            }
            /*
             * New connections are not registered yet into the
             * events loop, we need to do it manually:
             */
            mk_event_add(sched->loop, socket, MK_EVENT_READ, NULL);
            return 0;
        }

        /* Create session for the client */
        MK_TRACE("[FD %i] Create session", socket);
        cs = mk_http_session_create(socket, sched);
        if (!cs) {
            return -1;
        }
    }

    /* Invoke the read handler, on this case we only support HTTP (for now :) */
    ret = mk_http_handler_read(socket, cs);
    if (ret > 0) {
        if (mk_list_is_empty(&cs->request_list) == 0) {
            /* Add the first entry */
            sr = &cs->sr_fixed;
            mk_list_add(&sr->_head, &cs->request_list);
            mk_http_request_init(cs, sr);
        }
        else {
            sr = mk_list_entry_first(&cs->request_list, struct mk_http_request, _head);
        }

        status = mk_http_parser(sr, &cs->parser,
                                cs->body, cs->body_length);
        if (status == MK_HTTP_PARSER_OK) {
            MK_TRACE("[FD %i] HTTP_PARSER_OK", socket);
            mk_http_status_completed(cs);
            mk_event_add(sched->loop, socket, MK_EVENT_WRITE, NULL);
        }
        else if (status == MK_HTTP_PARSER_ERROR) {
            mk_http_session_remove(socket);
            MK_TRACE("[FD %i] HTTP_PARSER_ERROR", socket);
            return -1;
        }
        else {
            MK_TRACE("[FD %i] HTTP_PARSER_PENDING", socket);
        }
    }

    if (ret == -EAGAIN) {
        return 1;
    }

    return ret;
}
コード例 #2
0
ファイル: mk_http.c プロジェクト: ansd/monkey1
/*
 * Check if the client request still has pending data.
 *
 * Return 0 when all parts of the expected data has arrived or -1 when
 * the connection is on a pending status due to HTTP spec.
 *
 * This function is called from request.c :: mk_handler_read(..)
 */
int mk_http_pending_request(struct client_session *cs)
{
    int n; // ret;
    char *end;
    struct unparsed_method req;
    struct parsed_method rsp;

    if (cs->body_length >= mk_endblock.len) {
        end = (cs->body + cs->body_length) - mk_endblock.len;
    }
    else {
        return -1;
    }

    /* try to match CRLF at the end of the request */
    if (cs->body_pos_end < 0) {
        if (strncmp(end, mk_endblock.data, mk_endblock.len) == 0) {
            cs->body_pos_end = cs->body_length - mk_endblock.len;
        }
        else if ((n = mk_string_search(cs->body, mk_endblock.data, MK_STR_SENSITIVE)) >= 0 ){
            cs->body_pos_end = n;
        }
        else {
            return -1;
        }
    }

    memset(&req, 0, sizeof req);
    if (cs->first_method == MK_HTTP_METHOD_UNKNOWN) {
        /* Prepare message to send to the parser */
        req.flag = 1;
        strncpy(req.req_buf, cs->body, cs->body_length);

        /* Send the actual message to the parser */
        //ret = write(pfd_w, &req, sizeof(req.flag) + cs->body_length);
        //if(ret <= 0){
        //    fprintf(stderr, "Monkey: Write to pipe failed in pre-parsing mode\n");
        //}

        /* Monkey reads parsed request struct from parser */
        //memset(&rsp, 0, sizeof rsp);
        //ret = read(pfd_r, &rsp, sizeof rsp);
        //if(ret <= 0){
        //    fprintf(stderr, "Monkey: Read from pipe failed in pre-parsing mode\n");
        //}

        /* process parsed method */
        cs->first_method = rsp.first_method;
    }

    if (cs->first_method == MK_HTTP_METHOD_POST || cs->first_method == MK_HTTP_METHOD_PUT) {
        if (cs->body_pos_end > 0) {
            int content_length;
            int current;

            if (req.flag != 1)
            {
                /* send the request to the parser */
                req.flag = 1;
                strncpy(req.req_buf, cs->body, cs->body_length);
                //ret = write(pfd_w, &req, sizeof(req.flag) + cs->body_length);
                //if(ret <= 0){
                //    fprintf(stderr, "Monkey: Write to pipe failed in pre-parsing mode\n");
                //}

                /* Monkey reads parsed request struct from parser */
                //memset(&rsp, 0, sizeof rsp);
                //ret = read(pfd_r, &rsp, sizeof rsp);
                //if(ret <= 0){
                //    fprintf(stderr, "Monkey: Read from pipe failed in pre-parsing mode\n");
                //}
            }

            /* process reply from parser */
            content_length = rsp.content_length;

            current = cs->body_length - cs->body_pos_end - mk_endblock.len;
            MK_TRACE("HTTP DATA %i/%i", current, content_length);

            if (content_length >= config->max_request_size) {
                return 0;
            }

            /* if first block has ended, we need to verify if exists
             * a previous block end, that will means that the POST
             * method has sent the whole information.
             * just for ref: pipelining is not allowed with POST
             */
            if ((unsigned int) cs->body_pos_end == cs->body_length - mk_endblock.len) {
                /* Content-length is required, if is it not found,
                 * we pass as successful in order to raise the error
                 * later
                 */
                if (content_length <= 0) {
                    mk_http_status_completed(cs);
                    return 0;
                }
                else {
                    return -1;
                }
            }
            else {
                if (current < content_length) {
                    return -1;
                }
                else {
                    mk_http_status_completed(cs);
                    return 0;
                }
            }
        }
        else {
            return -1;
        }
    }

    mk_http_status_completed(cs);
    return 0;
}