/** * nginx handler to feed request body (if any) to IronBee * * @param[in] r the nginx request object * @return NGX_DECLINED for normal operation * @return NGX_DONE if body is not yet available (processing will resume * on new data) * @return Error status if set by IronBee on sight of request data. */ ngx_int_t ngxib_handler(ngx_http_request_t *r) { ngx_chain_t *link; ngxib_req_ctx *ctx; ngx_int_t rv = NGX_DECLINED; ngx_http_request_body_t *rb; /* Don't process internal requests */ if (r->internal) return rv; ctx = ngx_http_get_module_ctx(r, ngx_ironbee_module); if (ctx->body_done) return rv; /* We already completed handling of no-body requests * when we looked at headers */ if (!ngxib_has_request_body(r, ctx)) return rv; ngx_regex_malloc_init(r->pool); /* We can now read the body. * This may come asynchronously in many chunks, so we need * to check for AGAIN and return DONE if waiting. * We pass it a handler to go round again while waiting. * * TODO: figure out how to pass data to ironbee asynchronously */ rv = ngx_http_read_client_request_body(r, ngxib_post_handler); if (rv == NGX_AGAIN) { ctx->body_wait = 1; cleanup_return NGX_DONE; } /* We now have the request body. Feed it to ironbee */ rb = r->request_body; if (!rb) { ib_log_error_tx(ctx->tx, "Failed to read request body."); cleanup_return NGX_HTTP_INTERNAL_SERVER_ERROR; } if (!rb->bufs) { /* I think this shouldn't happen */ /* But rethink if this turns up in logs when all is fine */ ib_log_error_tx(ctx->tx, "Probable error reading request body."); } if (rb->temp_file && (rb->temp_file->file.fd != NGX_INVALID_FILE)) { /* Reader has put request body in temp file */ off_t count = 0; u_char buf[BUFSIZE]; size_t buf_len; ib_log_debug_tx(ctx->tx, "Reading request body in temp file."); while (buf_len = ngx_read_file(&rb->temp_file->file, buf, BUFSIZE, count), buf_len > 0) { ib_log_debug_tx(ctx->tx, "Feeding %zd bytes request data to ironbee.", buf_len); ib_state_notify_request_body_data(ctx->tx->ib, ctx->tx, (const char*)buf, buf_len); count += buf_len; } if ((int)buf_len == NGX_ERROR) { ib_log_error_tx(ctx->tx, "Failed to read request body in temp file."); } } for (link = rb->bufs; link != NULL; link = link->next) { size_t len = (link->buf->last - link->buf->pos); ib_log_debug_tx(ctx->tx, "Feeding %zd bytes request data to ironbee.", len); if (len > 0) { ib_state_notify_request_body_data(ctx->tx->ib, ctx->tx, (const char*)link->buf->pos, len); } } ctx->body_done = 1; ib_state_notify_request_finished(ctx->tx->ib, ctx->tx); /* If IronBee signaled an error, we can return it */ if (STATUS_IS_ERROR(ctx->status)) { rv = ctx->status; ctx->internal_errordoc = 1; ib_log_error_tx(ctx->tx, "IronBee set %d reading request body.", (int)rv); } cleanup_return rv; }
/** * nginx post-read-request handler to feed request line and headers to Ironbee. * * @param[in] r The nginx request object. * @return Declined (ignoreme) or error status. */ static ngx_int_t ironbee_post_read_request(ngx_http_request_t *r) { ngx_log_t *prev_log; ngxib_req_ctx *ctx; ib_conn_t *iconn; ib_parsed_req_line_t *rline; ib_parsed_header_wrapper_t *ibhdrs; ib_status_t rc; ngx_list_part_t *part; ngx_table_elt_t *hdr; unsigned int i; /* Don't process internal requests */ if (r->internal) return NGX_DECLINED; prev_log = ngxib_log(r->connection->log); ngx_regex_malloc_init(r->pool); ctx = ngx_pcalloc(r->pool, sizeof(ngxib_req_ctx)); ctx->r = r; ngx_http_set_ctx(r, ctx, ngx_ironbee_module); iconn = ngxib_conn_get(ctx, ironbee); ib_tx_create(&ctx->tx, iconn, ctx); /* Notify Ironbee of request line and headers */ rc = ib_parsed_req_line_create(ctx->tx, &rline, (const char*)r->request_line.data, r->request_line.len, (const char*)r->method_name.data, r->method_name.len, (const char*)r->unparsed_uri.data, r->unparsed_uri.len, (const char*)r->http_protocol.data, r->http_protocol.len); if (rc != IB_OK) cleanup_return(prev_log) NGX_ERROR; ib_state_notify_request_started(ironbee, ctx->tx, rline); rc = ib_parsed_name_value_pair_list_wrapper_create(&ibhdrs, ctx->tx); if (rc != IB_OK) cleanup_return(prev_log) NGX_ERROR; for (part = &r->headers_in.headers.part; part != NULL; part = part->next) { hdr = part->elts; for (i = 0; i < part->nelts; ++i) { ib_parsed_name_value_pair_list_add(ibhdrs, (const char*)hdr->key.data, hdr->key.len, (const char*)hdr->value.data, hdr->value.len); ++hdr; } } rc = ib_state_notify_request_header_data(ironbee, ctx->tx, ibhdrs); if (rc != IB_OK) cleanup_return(prev_log) NGX_ERROR; rc = ib_state_notify_request_header_finished(ironbee, ctx->tx); if (rc != IB_OK) cleanup_return(prev_log) NGX_ERROR; if (!ngxib_has_request_body(r, ctx)) { rc = ib_state_notify_request_finished(ironbee, ctx->tx); if (rc != IB_OK) cleanup_return(prev_log) NGX_ERROR; } ctx->hdrs_in = 1; if (STATUS_IS_ERROR(ctx->status)) { ctx->internal_errordoc = 1; cleanup_return(prev_log) ctx->status; } cleanup_return(prev_log) NGX_DECLINED; }