wwwhandler.h

Go to the documentation of this file.

/*
** Copyright (C) 2005 Russell Leighton
**
** This program 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.
**
** This program 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 this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/




#ifndef __AWHANDLER_WWW__
#define __AWHANDLER_WWW__

#include "monitor.h"

#include "trie.h"

/*\@{*/

#ifndef AW_WWWHANDLER_SERVER
#define AW_WWWHANDLER_SERVER "wwwhandler/Aware" AW_VERSION
#endif

/* safeguard against out of control cgi programs */
#define AW_WWWHANDLER_CGIPAGE_MAXSIZE (10 * (1024 * 1024))

typedef enum {

  AW_WWWHANDLER_FLAG_NOFILEOPS = 0x1,  
} aw_wwwhandler_flags_t;


typedef enum {

  AW_WWWHANDLER_XTN_HEAD,
  AW_WWWHANDLER_XTN_GET,

} aw_wwwhandler_xtn_type_cd_t;


typedef enum {

  AW_WWWHANDLER_XTN_WAIT_REQUEST,          
  AW_WWWHANDLER_XTN_WAIT_HDR_REPLY,        
  AW_WWWHANDLER_XTN_WAIT_SND_REPLY,        
  AW_WWWHANDLER_XTN_DONE,                  
} aw_wwwhandler_xtn_state_cd_t;

/* internal io return codes */
typedef enum {

  IO_OK,
  IO_CONT,
  IO_ERR,
  IO_KEEP_ALIVE_CLOSE

} aw_wwwhandler_io_code_t;


typedef struct {

  /* used on write */
  u_int64_t
   writesize;

  /* fd for file we are dumping */
  int32_t
   fd;

  /* ptr for data we mmap'd */
  byte_t
   *data;

  /* used for partial buffer writes */
  int64_t
   partial_offset, partial_len;

} aw_wwwhandler_xtn_getinfo_t;

typedef struct aw_wwwhandler_xtn_s {

  aw_wwwhandler_xtn_type_cd_t
   type_cd;

  aw_wwwhandler_xtn_state_cd_t
   state_cd;

  /* http response code sent */
  int32_t
   response_cd;

  /* back ptr to monitor */
  aw_monitor_t
   *mon;

  /* back ptr to handler */
  struct aw_wwwhandler_s
   *h;

  /* socket we are talking over */
  int32_t
   txfd;

  /* the ip address of the requestor */
  aw_ip_addr_t
   clientip;

  /* ptr to last char of header */
  byte_t
   *eoheader;

  /* non-zero if want keep alive */
  int32_t
   keep_alive;

  /* count of re-use due to keep_alive */
  int32_t
   count;

  /* start time of xtn and timeout */
  aw_timestamp_t
   starttime,
   timeout;

  /* event id for timeout callback */
  aw_address_t
   timeout_eventid;

  /* pid of forked process (used w/cgi) */
  int32_t
   forkpid;

  /* if not NULL , will be appended to log file.
     (note: this should be malloc()'d as it will
     be free()'d in free_xtn() */
  byte_t
   *appendlog;

  /* bytes read or written (depending on state_cd) */
  u_int32_t
   nbytes;

  /* space for docroot/path or command */
  byte_t
   path[1024]; 

  /* space to read packets and use for scratch NOTE: needs to big enough to hold an entire HTTP header! */
  byte_t
   buffer[2048]; 

  /* state info for GET file command */
  aw_wwwhandler_xtn_getinfo_t
   getinfo;

  /* optional cgi command info */
  struct {

    /* copy of full header of request (0 terminated) */ 
    byte_t
    *header_block; 

    /* copy of full message body (0 terminated) for POST */
    byte_t
    *message_block;

    /* size of message in a POST */
    u_int32_t
    content_length;

    /* points to parsed strings in header_block for a GET */
    byte_t
    *command, *args, *headers;
    
    /* points to the end of the memory segment with the cgi args */
    byte_t
    *args_end;

    /* dictionary pointing to form args */
    aw_hashString_t
    *args_dict;

    /* writes the response header */
    aw_wwwhandler_io_code_t (*header)(aw_handler_args_t *args, struct aw_wwwhandler_xtn_s *xtn);

    /* does the work */
    aw_wwwhandler_io_code_t (*handler)(aw_handler_args_t *args, struct aw_wwwhandler_xtn_s *xtn);

    struct { /* created in aw_wwwhandler_append_cgipage(),
                used in aw_wwwhandler_tx_cgipage(), 
                and free'd in clear_cgi() */

      u_int32_t
        nbytes_allocated, /* how much we realloc'd */
        nbytes;           /* actual size of copied data */

      byte_t
      *data;

    } page ;

  } cgi;

  /* reply handler */
  aw_wwwhandler_io_code_t (*do_reply)(aw_handler_args_t *args, struct aw_wwwhandler_xtn_s *xtn);

} aw_wwwhandler_xtn_t;


typedef struct {

  /* socket accept()ing connections */
  int32_t
   sfd;

  aw_cache_allocator_t
   xtn_factory;

  /* active transactions in 2 luts */
  aw_hash32_t
   *fd2xtn,           
   *eventid2xtn;      
} aw_wwwhandler_state_t;

typedef struct {

  aw_event_sig_t
   xtn_info;                 
} aw_wwwhandler_xtn_events_t;

typedef struct aw_wwwhandler_s {

  aw_handler_t 
   handler_header;

  aw_wwwhandler_state_t
   state;

  u_int32_t 
   port;

  /* bind to specific ip if not 0 */
  aw_ip_addr_t 
   bind; 

  /* path of root of doc tree */
  byte_t
   *docroot;

  /* events to send on each xtn */
  aw_wwwhandler_xtn_events_t
   events;

  /* boolean configuration options */
  aw_wwwhandler_flags_t
   flags;

  /* value (seconds) to put in GET header Cache-Control: max-age=, if <=0 the no-cache is used */
  int32_t 
   get_cache_control_max_age; 

  /* if non-zero, then this is the max concurrent connections */
  u_int32_t
   max_connections;

  /* the default charset for Content-Type: header, defaults to ISO-8859-1 */
  byte_t
   default_charset[16];

  /* lookup that maps file suffix -> mime_type */
  aw_trie_t 
   *suffix2mime;

  int32_t (*dispatch_cgi)(aw_wwwhandler_xtn_t *xtn);           
  aw_handler_code_t (*start)(aw_monitor_t *mon, struct aw_wwwhandler_s *);  
  aw_handler_code_t (*stop)(aw_monitor_t *mon, struct aw_wwwhandler_s *);   
} aw_wwwhandler_t ;


/* mime types table rows */
typedef struct {

  byte_t *suffix;

  u_int32_t suffixlen; /* strlen of suffix */

  byte_t *mime_type;

} aw_suffix2mime_t;

/* things you can pass down to constructor */
typedef struct {
  
  byte_t *mime_types_path; 
  byte_t *default_charset; 
  aw_wwwhandler_flags_t flags;  
  aw_ip_addr_t bind; 
  int32_t get_cache_control_max_age; 
  u_int32_t max_connections;   
  aw_wwwhandler_xtn_events_t events; /*<! events to send */

  int32_t (*dispatch_cgi)(aw_wwwhandler_xtn_t *xtn);   
  aw_handler_code_t (*start)(aw_monitor_t *mon, struct aw_wwwhandler_s *);  
  aw_handler_code_t (*stop)(aw_monitor_t *mon, struct aw_wwwhandler_s *);   
} aw_wwwhandler_options_t;

aw_wwwhandler_io_code_t aw_wwwhandler_do_exec(aw_handler_args_t *args, aw_wwwhandler_xtn_t *xtn, 
                                              const byte_t *prog, const byte_t *prog_argv[],
                                              const byte_t *httpheader);

aw_wwwhandler_io_code_t aw_wwwhandler_tx_file(aw_handler_args_t *args, aw_wwwhandler_xtn_t *xtn);

aw_wwwhandler_io_code_t aw_wwwhandler_tx_header(aw_handler_args_t *args, aw_wwwhandler_xtn_t *xtn);

inline const byte_t *aw_wwwhandler_find_cgiheader_line(aw_wwwhandler_xtn_t *xtn, byte_t *key);

inline const byte_t *aw_wwwhandler_get_cgiarg(aw_wwwhandler_xtn_t *xtn, const byte_t *key);

inline const byte_t *aw_wwwhandler_get_multi_cgiarg(aw_wwwhandler_xtn_t *xtn, const byte_t *key, const byte_t *last);

int32_t aw_wwwhandler_printf_cgipage(aw_wwwhandler_xtn_t *xtn, const char *fmt,  ... ) __attribute__ ((format (printf, 2, 3)));

int32_t aw_wwwhandler_append_cgipage(aw_wwwhandler_xtn_t *xtn, void *data, u_int32_t nbytes);


aw_wwwhandler_io_code_t aw_wwwhandler_tx_cgi200(aw_handler_args_t *args, aw_wwwhandler_xtn_t *xtn, byte_t *headers);

aw_wwwhandler_io_code_t aw_wwwhandler_tx_cgipage(aw_handler_args_t *args, aw_wwwhandler_xtn_t *xtn);

aw_wwwhandler_io_code_t aw_wwwhandler_tx_200(aw_handler_args_t *args, aw_wwwhandler_xtn_t *xtn, 
                                             time_t lastmod, u_int64_t size, 
                                             int32_t max_age, 
                                             byte_t *mime_type, byte_t *charset,
                                             byte_t *headers);

aw_wwwhandler_io_code_t aw_wwwhandler_tx_metadata(aw_handler_args_t *args, aw_wwwhandler_xtn_t *xtn, u_int32_t dir);

aw_wwwhandler_io_code_t aw_wwwhandler_tx_error(aw_handler_args_t *args, aw_wwwhandler_xtn_t *xtn,
                                                u_int32_t code, byte_t *message);

int32_t aw_init_wwwhandler(aw_wwwhandler_t *h,
                           u_int32_t port,
                           byte_t *docroot,
                           aw_wwwhandler_options_t *options,
                           aw_logger_t *logger
                           );


aw_wwwhandler_t *aw_create_wwwhandler( u_int32_t port,
                                       byte_t *docroot,
                                       aw_wwwhandler_options_t *options,
                                       aw_logger_t *logger
                                       );

void aw_free_wwwhandler(aw_wwwhandler_t *p);

/*\@}*/

#endif

Aware 0.11.1 Copyright (C) 1998-2005 Russell Leighton (russ@elegant-software.com)