/***************************************************************************

 * Copyright (c) 2009-2010 Open Information Security Foundation

 * Copyright (c) 2010-2013 Qualys, Inc.

 * All rights reserved.

 * 

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are

 * met:

 * 

 * - Redistributions of source code must retain the above copyright

 *   notice, this list of conditions and the following disclaimer.

 * - Redistributions in binary form must reproduce the above copyright

 *   notice, this list of conditions and the following disclaimer in the

 *   documentation and/or other materials provided with the distribution.

 * - Neither the name of the Qualys, Inc. nor the names of its

 *   contributors may be used to endorse or promote products derived from

 *   this software without specific prior written permission.

 * 

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

 * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 ***************************************************************************/

/**

 * @file

 * @author Ivan Ristic <ivanr@webkreator.com>

 */

#include "htp_config_auto.h"

#include "htp_private.h"

void htp_connp_clear_error(htp_connp_t *connp) {

    connp->last_error = NULL;

}

void htp_connp_req_close(htp_connp_t *connp, const htp_time_t *timestamp) {

    if (connp == NULL) return;

    // Update internal flags

    if (connp->in_status != HTP_STREAM_ERROR)

        connp->in_status = HTP_STREAM_CLOSED;

    // Call the parsers one last time, which will allow them

    // to process the events that depend on stream closure

    htp_connp_req_data(connp, timestamp, NULL, 0);

}

void htp_connp_close(htp_connp_t *connp, const htp_time_t *timestamp) {

    if (connp == NULL) return;

    // Close the underlying connection.

    htp_conn_close(connp->conn, timestamp);

    // Update internal flags

    if (connp->in_status != HTP_STREAM_ERROR)

        connp->in_status = HTP_STREAM_CLOSED;

    if (connp->out_status != HTP_STREAM_ERROR)

        connp->out_status = HTP_STREAM_CLOSED;

    // Call the parsers one last time, which will allow them

    // to process the events that depend on stream closure

    htp_connp_req_data(connp, timestamp, NULL, 0);

    htp_connp_res_data(connp, timestamp, NULL, 0);   

}

htp_connp_t *htp_connp_create(htp_cfg_t *cfg) {

    htp_connp_t *connp = calloc(1, sizeof (htp_connp_t));

    if (connp == NULL) return NULL;

    // Use the supplied configuration structure

    connp->cfg = cfg;

    // Create a new connection.

    connp->conn = htp_conn_create();

    if (connp->conn == NULL) {

        free(connp);

        return NULL;

    }

    // Request parsing

    connp->in_state = htp_connp_REQ_IDLE;

    connp->in_status = HTP_STREAM_NEW;

    // Response parsing

    connp->out_state = htp_connp_RES_IDLE; 

    connp->out_status = HTP_STREAM_NEW;

    return connp;

}

void htp_connp_destroy(htp_connp_t *connp) {

    if (connp == NULL) return;

    if (connp->in_buf != NULL) {

        free(connp->in_buf);

    }

    if (connp->out_buf != NULL) {

        free(connp->out_buf);

    }

    htp_connp_destroy_decompressors(connp);

    if (connp->put_file != NULL) {

        bstr_free(connp->put_file->filename);

        free(connp->put_file);

    }

    if (connp->in_header) {

        bstr_free(connp->in_header);

        connp->in_header = NULL;

    }

    if (connp->out_header) {

        bstr_free(connp->out_header);

        connp->out_header = NULL;

    }

    free(connp);

}

void htp_connp_destroy_all(htp_connp_t *connp) {

    if (connp == NULL) return;

    // Destroy connection

    htp_conn_destroy(connp->conn);

    connp->conn = NULL;

    // Destroy everything else

    htp_connp_destroy(connp);

}

htp_conn_t *htp_connp_get_connection(const htp_connp_t *connp) {

    if (connp == NULL) return NULL;

    return connp->conn;

}

htp_tx_t *htp_connp_get_in_tx(const htp_connp_t *connp) {

    if (connp == NULL) return NULL;

    return connp->in_tx;

}

htp_log_t *htp_connp_get_last_error(const htp_connp_t *connp) {

    if (connp == NULL) return NULL;

    return connp->last_error;

}

htp_tx_t *htp_connp_get_out_tx(const htp_connp_t *connp) {

    if (connp == NULL) return NULL;

    return connp->out_tx;

}

void *htp_connp_get_user_data(const htp_connp_t *connp) {

    if (connp == NULL) return NULL;

    return (void *)connp->user_data;

}

void htp_connp_in_reset(htp_connp_t *connp) {

    if (connp == NULL) return;

    connp->in_content_length = -1;

    connp->in_body_data_left = -1;

    connp->in_chunk_request_index = connp->in_chunk_count;

}

void htp_connp_open(htp_connp_t *connp, const char *client_addr, int client_port, const char *server_addr,

        int server_port, htp_time_t *timestamp)

{

    if (connp == NULL) return;

    // Check connection parser state first.

    if ((connp->in_status != HTP_STREAM_NEW) || (connp->out_status != HTP_STREAM_NEW)) {

        htp_log(connp, HTP_LOG_MARK, HTP_LOG_ERROR, 0, "Connection is already open");

        return;

    }

    if (htp_conn_open(connp->conn, client_addr, client_port, server_addr, server_port, timestamp) != HTP_OK) {

        return;

    }

    connp->in_status = HTP_STREAM_OPEN;

    connp->out_status = HTP_STREAM_OPEN;

}

void htp_connp_set_user_data(htp_connp_t *connp, const void *user_data) {

    if (connp == NULL) return;

    connp->user_data = user_data;

}

htp_tx_t *htp_connp_tx_create(htp_connp_t *connp) {

    if (connp == NULL) return NULL;

    // Detect pipelining.

    if (htp_list_size(connp->conn->transactions) > connp->out_next_tx_index) {

        connp->conn->flags |= HTP_CONN_PIPELINED;

    }

    if (connp->cfg->max_tx > 0 &&

        htp_list_size(connp->conn->transactions) > connp->cfg->max_tx) {

        return NULL;

    }

    htp_tx_t *tx = htp_tx_create(connp);

    if (tx == NULL) return NULL;

    connp->in_tx = tx;   

    htp_connp_in_reset(connp);

    return tx;

}

/**

 * Removes references to the supplied transaction.

 *

 * @param[in] connp

 * @param[in] tx

 */

void htp_connp_tx_remove(htp_connp_t *connp, htp_tx_t *tx) {

    if (connp == NULL) return;

    if (connp->in_tx == tx) {

        connp->in_tx = NULL;

    }

    if (connp->out_tx == tx) {

        connp->out_tx = NULL;

    }

}

/**

 * Removes all front NULL-ed transactions

 *

 * @param[in] connp

 * @return numbers of removed NULL transactions

 */

size_t htp_connp_tx_freed(htp_connp_t *connp) {

    // Transactions first got freed and NULLed

    // Now, we can recycle the space that hold them by shifting the list

    size_t r = 0;

    size_t nb = htp_list_size(connp->conn->transactions);

    for (size_t i = 0; i < nb; i++) {

        // 0 and not i because at next iteration, we have removed the first

        void * tx = htp_list_get(connp->conn->transactions, 0);

        if (tx != NULL) {

            break;

        }

        htp_list_shift(connp->conn->transactions);

        r++;

        connp->out_next_tx_index--;

    }

    return r;

}