http.h

Go to the documentation of this file.

/*
 * $Id: http.h,v 1.18 2005/11/09 19:16:53 cbiere Exp $
 *
 * Copyright (c) 2002-2003, Raphael Manfredi
 *
 *----------------------------------------------------------------------
 * This file is part of gtk-gnutella.
 *
 *  gtk-gnutella is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  gtk-gnutella is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with gtk-gnutella; if not, write to the Free Software
 *  Foundation, Inc.:
 *      59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *----------------------------------------------------------------------
 */

#ifndef _core_http_h_
#define _core_http_h_

#include "if/core/http.h"
#include "lib/host_addr.h"

#define HTTP_PORT       80      
typedef enum {
    HTTP_EXTRA_LINE,
    HTTP_EXTRA_CALLBACK,
    HTTP_EXTRA_BODY
} http_extra_type_t;

typedef void (*http_status_cb_t)(
    gchar *buf, gint *retlen, gpointer arg, guint32 flags);

typedef struct {
    http_extra_type_t he_type;      
    union {
        gchar *u_msg;               
        struct {
            http_status_cb_t u_cb;  
            gpointer u_arg;         
        } u_cbk;
    } u;
} http_extra_desc_t;

#define he_msg  u.u_msg
#define he_cb   u.u_cbk.u_cb
#define he_arg  u.u_cbk.u_arg

/*
 * Flags used during callback invocation.
 */

#define HTTP_CBF_SMALL_REPLY    0x00000001  
#define HTTP_CBF_BW_SATURATED   0x00000002  
#define HTTP_CBF_BUSY_SIGNAL    0x00000004  
#define HTTP_CBF_SHOW_RANGES    0x00000008  
struct header;

typedef gboolean (*http_header_cb_t)(
    gpointer h, struct header *header, gint code, const gchar *message);

typedef void (*http_data_cb_t)(gpointer h, gchar *data, gint len);

typedef enum {              
    HTTP_ASYNC_SYSERR,      
    HTTP_ASYNC_ERROR,       
    HTTP_ASYNC_HEADER,      
    HTTP_ASYNC_HTTP         
} http_errtype_t;

typedef struct {
    struct header *header;  
    gint code;              
    const gchar *message;   
} http_error_t;

typedef void (*http_error_cb_t)(gpointer h, http_errtype_t error, gpointer val);

typedef void (*http_user_free_t)(gpointer data);

typedef size_t (*http_op_request_t)(gpointer handle, gchar *buf, size_t len,
    const gchar *verb, const gchar *path, const gchar *host, guint16 port);

/*
 * Asynchronous request error codes.
 */

#define HTTP_ASYNC_OK               0   
#define HTTP_ASYNC_BAD_URL          1   
#define HTTP_ASYNC_CONN_FAILED      2   
#define HTTP_ASYNC_IO_ERROR         3   
#define HTTP_ASYNC_REQ2BIG          4   
#define HTTP_ASYNC_HEAD2BIG         5   
#define HTTP_ASYNC_CANCELLED        6   
#define HTTP_ASYNC_EOF              7   
#define HTTP_ASYNC_BAD_STATUS       8   
#define HTTP_ASYNC_NO_LOCATION      9   
#define HTTP_ASYNC_CONN_TIMEOUT     10  
#define HTTP_ASYNC_TIMEOUT          11  
#define HTTP_ASYNC_NESTED           12  
#define HTTP_ASYNC_BAD_LOCATION_URI 13  
#define HTTP_ASYNC_CLOSED           14  
#define HTTP_ASYNC_REDIRECTED       15  
extern guint http_async_errno;

typedef enum {
    HTTP_URL_OK = 0,                
    HTTP_URL_NOT_HTTP,              
    HTTP_URL_MULTIPLE_CREDENTIALS,  
    HTTP_URL_BAD_CREDENTIALS,       
    HTTP_URL_BAD_PORT_PARSING,      
    HTTP_URL_BAD_PORT_RANGE,        
    HTTP_URL_BAD_HOST_PART,         
    HTTP_URL_HOSTNAME_UNKNOWN,      
    HTTP_URL_MISSING_URI            
} http_url_error_t;

extern http_url_error_t http_url_errno;

typedef void (*http_state_change_t)(gpointer handle, http_state_t newstate);

typedef struct http_buffer {
    gchar *hb_arena;                
    gchar *hb_rptr;                 
    gchar *hb_end;                  
    gint hb_len;                    
} http_buffer_t;

#define http_buffer_base(hb)        ((hb)->hb_arena)
#define http_buffer_length(hb)      ((hb)->hb_len)
#define http_buffer_read_base(hb)   ((hb)->hb_rptr)
#define http_buffer_unread(hb)      ((hb)->hb_end - (hb)->hb_rptr)

#define http_buffer_add_read(hb,tx) do { (hb)->hb_rptr += (tx); } while (0)

/*
 * Public interface
 */

struct gnutella_socket;

void http_timer(time_t now);

gboolean http_send_status(struct gnutella_socket *s,
    gint code, gboolean keep_alive, http_extra_desc_t *hev, gint hevcnt,
    const gchar *reason, ...) G_GNUC_PRINTF(6, 7);

void http_hostname_add(
    gchar *buf, gint *retval, gpointer arg, guint32 flags);

gint http_status_parse(const gchar *line,
    const gchar *proto, const gchar **msg, guint *major, guint *minor);

gboolean http_extract_version(
    const gchar *request, gint len, guint *major, guint *minor);

http_buffer_t *http_buffer_alloc(gchar *buf, size_t len, size_t written);
void http_buffer_free(http_buffer_t *b);

gint
http_content_range_parse(const gchar *buf,
        filesize_t *start, filesize_t *end, filesize_t *total);

filesize_t http_range_size(const GSList *list);
void http_range_free(GSList *list);
GSList *http_range_parse(const gchar *field, const gchar *value,
        filesize_t size, const gchar *vendor);
gboolean http_range_contains(GSList *ranges, filesize_t from, filesize_t to);

const gchar *http_url_strerror(http_url_error_t errnum);
gboolean http_url_parse(
    const gchar *url, guint16 *port, const gchar **host, const gchar **path);

gpointer http_async_get(
    gchar *url,
    http_header_cb_t header_ind,
    http_data_cb_t data_ind,
    http_error_cb_t error_ind);

gpointer http_async_get_addr(
    gchar *path,
    const host_addr_t,
    guint16 port,
    http_header_cb_t header_ind,
    http_data_cb_t data_ind,
    http_error_cb_t error_ind);

const gchar *http_async_strerror(guint errnum);
const gchar *http_async_info(
    gpointer handle, const gchar **req, gchar **path,
    host_addr_t *addr, guint16 *port);
void http_async_connected(gpointer handle);
void http_async_close(gpointer handle);
void http_async_cancel(gpointer handle);
void http_async_error(gpointer handle, gint code);
http_state_t http_async_state(gpointer handle);

void http_async_set_opaque(gpointer handle, gpointer data, http_user_free_t fn);
gpointer http_async_get_opaque(gpointer handle);
void http_async_log_error(gpointer handle, http_errtype_t type, gpointer v);
void http_async_log_error_dbg(
    gpointer handle, http_errtype_t type, gpointer v, guint32 dbg_level);

void http_async_on_state_change(gpointer handle, http_state_change_t fn);
void http_async_allow_redirects(gpointer handle, gboolean allow);
void http_async_set_op_request(gpointer handle, http_op_request_t op);

void http_close(void);

#endif  /* _core_http_h_ */

/* vi: set ts=4 sw=4 cindent: */

---