microspdy.h

Go to the documentation of this file.

/*
    This file is part of libmicrospdy
    Copyright (C) 2012, 2013 Christian Grothoff

    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 3 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, see <http://www.gnu.org/licenses/>.
*/

#ifndef SPDY_MICROSPDY_H
#define SPDY_MICROSPDY_H

#include <zlib.h>
#include <stdbool.h>

/* While we generally would like users to use a configure-driven
   build process which detects which headers are present and
   hence works on any platform, we use "standard" includes here
   to build out-of-the-box for beginning users on common systems.

   Once you have a proper build system and go for more exotic 
   platforms, you should define MHD_PLATFORM_H in some header that
   you always include *before* "microhttpd.h".  Then the following
   "standard" includes won't be used (which might be a good
   idea, especially on platforms where they do not exist). */
#ifndef MHD_PLATFORM_H
#include <unistd.h>
#include <stdarg.h>
#include <stdint.h>
#ifdef __MINGW32__
#include <ws2tcpip.h>
#else
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#endif
#endif


#define SPDY_YES 1

#define SPDY_NO 0

#define SPDY_INPUT_ERROR -1

#define SPDY_VERSION 3

#define SPDY_MAX_SUPPORTED_FRAME_SIZE 8192

#define SPDY_HTTP_CONTINUE 100
#define SPDY_HTTP_SWITCHING_PROTOCOLS 101
#define SPDY_HTTP_PROCESSING 102

#define SPDY_HTTP_OK 200
#define SPDY_HTTP_CREATED 201
#define SPDY_HTTP_ACCEPTED 202
#define SPDY_HTTP_NON_AUTHORITATIVE_INFORMATION 203
#define SPDY_HTTP_NO_CONTENT 204
#define SPDY_HTTP_RESET_CONTENT 205
#define SPDY_HTTP_PARTIAL_CONTENT 206
#define SPDY_HTTP_MULTI_STATUS 207

#define SPDY_HTTP_MULTIPLE_CHOICES 300
#define SPDY_HTTP_MOVED_PERMANENTLY 301
#define SPDY_HTTP_FOUND 302
#define SPDY_HTTP_SEE_OTHER 303
#define SPDY_HTTP_NOT_MODIFIED 304
#define SPDY_HTTP_USE_PROXY 305
#define SPDY_HTTP_SWITCH_PROXY 306
#define SPDY_HTTP_TEMPORARY_REDIRECT 307

#define SPDY_HTTP_BAD_REQUEST 400
#define SPDY_HTTP_UNAUTHORIZED 401
#define SPDY_HTTP_PAYMENT_REQUIRED 402
#define SPDY_HTTP_FORBIDDEN 403
#define SPDY_HTTP_NOT_FOUND 404
#define SPDY_HTTP_METHOD_NOT_ALLOWED 405
#define SPDY_HTTP_METHOD_NOT_ACCEPTABLE 406
#define SPDY_HTTP_PROXY_AUTHENTICATION_REQUIRED 407
#define SPDY_HTTP_REQUEST_TIMEOUT 408
#define SPDY_HTTP_CONFLICT 409
#define SPDY_HTTP_GONE 410
#define SPDY_HTTP_LENGTH_REQUIRED 411
#define SPDY_HTTP_PRECONDITION_FAILED 412
#define SPDY_HTTP_REQUEST_ENTITY_TOO_LARGE 413
#define SPDY_HTTP_REQUEST_URI_TOO_LONG 414
#define SPDY_HTTP_UNSUPPORTED_MEDIA_TYPE 415
#define SPDY_HTTP_REQUESTED_RANGE_NOT_SATISFIABLE 416
#define SPDY_HTTP_EXPECTATION_FAILED 417
#define SPDY_HTTP_UNPROCESSABLE_ENTITY 422
#define SPDY_HTTP_LOCKED 423
#define SPDY_HTTP_FAILED_DEPENDENCY 424
#define SPDY_HTTP_UNORDERED_COLLECTION 425
#define SPDY_HTTP_UPGRADE_REQUIRED 426
#define SPDY_HTTP_NO_RESPONSE 444
#define SPDY_HTTP_RETRY_WITH 449
#define SPDY_HTTP_BLOCKED_BY_WINDOWS_PARENTAL_CONTROLS 450
#define SPDY_HTTP_UNAVAILABLE_FOR_LEGAL_REASONS 451

#define SPDY_HTTP_INTERNAL_SERVER_ERROR 500
#define SPDY_HTTP_NOT_IMPLEMENTED 501
#define SPDY_HTTP_BAD_GATEWAY 502
#define SPDY_HTTP_SERVICE_UNAVAILABLE 503
#define SPDY_HTTP_GATEWAY_TIMEOUT 504
#define SPDY_HTTP_HTTP_VERSION_NOT_SUPPORTED 505
#define SPDY_HTTP_VARIANT_ALSO_NEGOTIATES 506
#define SPDY_HTTP_INSUFFICIENT_STORAGE 507
#define SPDY_HTTP_BANDWIDTH_LIMIT_EXCEEDED 509
#define SPDY_HTTP_NOT_EXTENDED 510

#define SPDY_HTTP_HEADER_ACCEPT "accept"
#define SPDY_HTTP_HEADER_ACCEPT_CHARSET "accept-charset"
#define SPDY_HTTP_HEADER_ACCEPT_ENCODING "accept-encoding"
#define SPDY_HTTP_HEADER_ACCEPT_LANGUAGE "accept-language"
#define SPDY_HTTP_HEADER_ACCEPT_RANGES "accept-ranges"
#define SPDY_HTTP_HEADER_AGE "age"
#define SPDY_HTTP_HEADER_ALLOW "allow"
#define SPDY_HTTP_HEADER_AUTHORIZATION "authorization"
#define SPDY_HTTP_HEADER_CACHE_CONTROL "cache-control"
/* Connection header is forbidden in SPDY */
#define SPDY_HTTP_HEADER_CONNECTION "connection"
#define SPDY_HTTP_HEADER_CONTENT_ENCODING "content-encoding"
#define SPDY_HTTP_HEADER_CONTENT_LANGUAGE "content-language"
#define SPDY_HTTP_HEADER_CONTENT_LENGTH "content-length"
#define SPDY_HTTP_HEADER_CONTENT_LOCATION "content-location"
#define SPDY_HTTP_HEADER_CONTENT_MD5 "content-md5"
#define SPDY_HTTP_HEADER_CONTENT_RANGE "content-range"
#define SPDY_HTTP_HEADER_CONTENT_TYPE "content-type"
#define SPDY_HTTP_HEADER_COOKIE "cookie"
#define SPDY_HTTP_HEADER_DATE "date"
#define SPDY_HTTP_HEADER_ETAG "etag"
#define SPDY_HTTP_HEADER_EXPECT "expect"
#define SPDY_HTTP_HEADER_EXPIRES "expires"
#define SPDY_HTTP_HEADER_FROM "from"
/* Host header is forbidden in SPDY */
#define SPDY_HTTP_HEADER_HOST "host"
#define SPDY_HTTP_HEADER_IF_MATCH "if-match"
#define SPDY_HTTP_HEADER_IF_MODIFIED_SINCE "if-modified-since"
#define SPDY_HTTP_HEADER_IF_NONE_MATCH "if-none-match"
#define SPDY_HTTP_HEADER_IF_RANGE "if-range"
#define SPDY_HTTP_HEADER_IF_UNMODIFIED_SINCE "if-unmodified-since"
/* Keep-Alive header is forbidden in SPDY */
#define SPDY_HTTP_HEADER_KEEP_ALIVE "keep-alive"
#define SPDY_HTTP_HEADER_LAST_MODIFIED "last-modified"
#define SPDY_HTTP_HEADER_LOCATION "location"
#define SPDY_HTTP_HEADER_MAX_FORWARDS "max-forwards"
#define SPDY_HTTP_HEADER_PRAGMA "pragma"
#define SPDY_HTTP_HEADER_PROXY_AUTHENTICATE "proxy-authenticate"
#define SPDY_HTTP_HEADER_PROXY_AUTHORIZATION "proxy-authorization"
/* Proxy-Connection header is forbidden in SPDY */
#define SPDY_HTTP_HEADER_PROXY_CONNECTION "proxy-connection"
#define SPDY_HTTP_HEADER_RANGE "range"
#define SPDY_HTTP_HEADER_REFERER "referer"
#define SPDY_HTTP_HEADER_RETRY_AFTER "retry-after"
#define SPDY_HTTP_HEADER_SERVER "server"
#define SPDY_HTTP_HEADER_SET_COOKIE "set-cookie"
#define SPDY_HTTP_HEADER_SET_COOKIE2 "set-cookie2"
#define SPDY_HTTP_HEADER_TE "te"
#define SPDY_HTTP_HEADER_TRAILER "trailer"
/* Transfer-Encoding header is forbidden in SPDY */
#define SPDY_HTTP_HEADER_TRANSFER_ENCODING "transfer-encoding"
#define SPDY_HTTP_HEADER_UPGRADE "upgrade"
#define SPDY_HTTP_HEADER_USER_AGENT "user-agent"
#define SPDY_HTTP_HEADER_VARY "vary"
#define SPDY_HTTP_HEADER_VIA "via"
#define SPDY_HTTP_HEADER_WARNING "warning"
#define SPDY_HTTP_HEADER_WWW_AUTHENTICATE "www-authenticate"

#define SPDY_HTTP_VERSION_1_0 "HTTP/1.0"
#define SPDY_HTTP_VERSION_1_1 "HTTP/1.1"

#define SPDY_HTTP_METHOD_CONNECT "CONNECT"
#define SPDY_HTTP_METHOD_DELETE "DELETE"
#define SPDY_HTTP_METHOD_GET "GET"
#define SPDY_HTTP_METHOD_HEAD "HEAD"
#define SPDY_HTTP_METHOD_OPTIONS "OPTIONS"
#define SPDY_HTTP_METHOD_POST "POST"
#define SPDY_HTTP_METHOD_PUT "PUT"
#define SPDY_HTTP_METHOD_TRACE "TRACE"

#define SPDY_HTTP_POST_ENCODING_FORM_URLENCODED "application/x-www-form-urlencoded"
#define SPDY_HTTP_POST_ENCODING_MULTIPART_FORMDATA "multipart/form-data"


struct SPDY_Daemon;


struct SPDY_Session;


struct SPDY_Request;


struct SPDY_Response;


struct SPDY_NameValue;


struct SPDY_Settings;


enum SPDY_IO_SUBSYSTEM
{

        SPDY_IO_SUBSYSTEM_NONE = 0,

        SPDY_IO_SUBSYSTEM_OPENSSL = 1,

        SPDY_IO_SUBSYSTEM_RAW = 2,
};


enum SPDY_DAEMON_OPTION
{

        SPDY_DAEMON_OPTION_END = 0,

        SPDY_DAEMON_OPTION_SESSION_TIMEOUT = 1,
        
        SPDY_DAEMON_OPTION_SOCK_ADDR = 2,

        SPDY_DAEMON_OPTION_FLAGS = 4,

        SPDY_DAEMON_OPTION_IO_SUBSYSTEM = 8,
  
        SPDY_DAEMON_OPTION_MAX_NUM_FRAMES = 16,
};


enum SPDY_DAEMON_FLAG
{
        SPDY_DAEMON_FLAG_NO = 0,
  
        SPDY_DAEMON_FLAG_ONLY_IPV6 = 1,
  
        SPDY_DAEMON_FLAG_NO_DELAY = 2,
};

        
enum SPDY_SETTINGS
{
        
        SPDY_SETTINGS_UPLOAD_BANDWIDTH = 1,
        
        SPDY_SETTINGS_DOWNLOAD_BANDWIDTH = 2,
        
        SPDY_SETTINGS_ROUND_TRIP_TIME = 3,
        
        SPDY_SETTINGS_MAX_CONCURRENT_STREAMS = 4,
        
        SPDY_SETTINGS_CURRENT_CWND = 5,
        
        SPDY_SETTINGS_DOWNLOAD_RETRANS_RATE = 6,
        
        SPDY_SETTINGS_INITIAL_WINDOW_SIZE = 7,
        
        SPDY_SETTINGS_CLIENT_CERTIFICATE_VECTOR_SIZE = 8,
};


enum SPDY_FLAG_SETTINGS{
        
        SPDY_FLAG_SETTINGS_PERSIST_VALUE = 1,
        
        SPDY_FLAG_SETTINGS_PERSISTED = 2,
};      


enum SPDY_FLAG_SETTINGS_FRAME
{
        
        SPDY_FLAG_SETTINGS_CLEAR_SETTINGS = 1,
};


enum SPDY_SETTINGS_OPTION
{

        SPDY_SETTINGS_OPTION_END = 0,
};


enum SPDY_RESPONSE_RESULT
{

        SPDY_RESPONSE_RESULT_SUCCESS = 0,

        SPDY_RESPONSE_RESULT_SESSION_CLOSED = 1,

        SPDY_RESPONSE_RESULT_STREAM_CLOSED = 2,
};

typedef void
(*SPDY_PanicCallback) (void * cls,
                                                        const char * file,
                                                        unsigned int line,
                                                        const char * reason);


typedef void
(*SPDY_NewSessionCallback) (void * cls,
                                                        struct SPDY_Session * session);


typedef void
(*SPDY_SessionClosedCallback) (void * cls,
                                                                struct SPDY_Session * session,
                                                                int by_client);


typedef int
(*SPDY_NameValueIterator) (void * cls,
                                                        const char * name,
                                                        const char * const * value,
                                                        int num_values);
                           

typedef void (*SPDY_NewRequestCallback) (void * cls,
                                         struct SPDY_Request * request,
                                         uint8_t priority,
                                         const char * method,
                                         const char * path,
                                         const char * version,
                                         const char * host,
                                         const char * scheme,
                                         struct SPDY_NameValue * headers,
           bool more);


typedef int
(*SPDY_NewDataCallback) (void * cls,
                                         struct SPDY_Request *request,
                                         const void * buf,
                                         size_t size,
                                         bool more);
// How about passing POST encoding information
// here as well?
//TODO 


typedef ssize_t (*SPDY_ResponseCallback) (void * cls,
                                          void * buffer,
                                          size_t max,
                                          bool * more);


typedef void
(*SPDY_ResponseResultCallback) (void * cls,
                                                                struct SPDY_Response * response,
                                                                struct SPDY_Request * request,
                                                                enum SPDY_RESPONSE_RESULT status,
                                                                bool streamopened);


typedef void
(*SPDY_PingCallback) (void * cls,
                                                struct SPDY_Session * session,
                                                struct timeval * rtt);


typedef int
(*SPDY_SettingsIterator) (void * cls,
                                                                enum SPDY_SETTINGS id, 
                                                                int32_t value, 
                                                                uint8_t flags);


typedef void
(*SPDY_SettingsReceivedCallback) (struct SPDY_Session * session,
                                                                struct SPDY_Settings * settings,
                                                                uint8_t flags,
                                                                ...);


/* Global functions for the library */


int
(SPDY_init) (enum SPDY_IO_SUBSYSTEM io_subsystem, ...);
#define SPDY_init() SPDY_init(SPDY_IO_SUBSYSTEM_OPENSSL)


void
SPDY_deinit ();


void 
SPDY_set_panic_func (SPDY_PanicCallback cb,
                                        void *cls);


/* Daemon functions */


struct SPDY_Daemon *
SPDY_start_daemon (uint16_t port,
                                        const char * certfile,
                                        const char * keyfile,
                                        SPDY_NewSessionCallback nscb,
                                        SPDY_SessionClosedCallback sccb,
                                        SPDY_NewRequestCallback nrcb,
                                        SPDY_NewDataCallback npdcb,
                                        void * cls,
                                        ...);


void 
SPDY_stop_daemon (struct SPDY_Daemon *daemon);


int
SPDY_get_fdset (struct SPDY_Daemon * daemon,
                                fd_set * read_fd_set,
                                fd_set * write_fd_set, 
                                fd_set * except_fd_set);


int
SPDY_get_timeout (struct SPDY_Daemon * daemon, 
                                        unsigned long long * timeout);


void 
SPDY_run (struct SPDY_Daemon *daemon);


/* SPDY Session handling functions */


void
SPDY_close_session(struct SPDY_Session * session);


void
SPDY_set_cls_to_session(struct SPDY_Session * session,
                                                void * cls);


void *
SPDY_get_cls_from_session(struct SPDY_Session * session);


socklen_t
SPDY_get_remote_addr(struct SPDY_Session * session,
                                         struct sockaddr ** addr);


/* SPDY name/value data structure handling functions */


struct SPDY_NameValue *
SPDY_name_value_create ();


int
SPDY_name_value_add (struct SPDY_NameValue * container,
                                        const char * name, 
                                        const char * value);


const char * const * 
SPDY_name_value_lookup (struct SPDY_NameValue *container,
                                                const char *name,
                                                int * num_values);


int
SPDY_name_value_iterate (struct SPDY_NameValue *container,
                                                SPDY_NameValueIterator iterator,
                                                void *iterator_cls);


void
SPDY_name_value_destroy (struct SPDY_NameValue * container);


/* SPDY request handling functions */


struct SPDY_Session *
SPDY_get_session_for_request(const struct SPDY_Request * request);


void
SPDY_set_cls_to_request(struct SPDY_Request * request,
                                                void * cls);

        
void *
SPDY_get_cls_from_request(struct SPDY_Request * request);


/* SPDY response handling functions */


struct SPDY_Response *
SPDY_build_response(int status,
                                        const char * statustext,
                                        const char * version,
                                        struct SPDY_NameValue * headers,
                                        const void * data,
                                        size_t size);


struct SPDY_Response *
SPDY_build_response_with_callback(int status,
                                        const char * statustext,
                                        const char * version,
                                        struct SPDY_NameValue * headers,
                                        SPDY_ResponseCallback rcb,
                                        void *rcb_cls,
                                        uint32_t block_size);


int
SPDY_queue_response (struct SPDY_Request * request,
                    struct SPDY_Response *response,
                    bool closestream,
                    bool consider_priority,
                        SPDY_ResponseResultCallback rrcb,
                        void * rrcb_cls);


void
SPDY_destroy_response (struct SPDY_Response *response);


/* SPDY settings ID/value data structure handling functions */  


const struct SPDY_Settings *
SPDY_settings_create ();


int
SPDY_settings_add (struct SPDY_Settings *container,
                                                        enum SPDY_SETTINGS id, 
                                                        enum SPDY_FLAG_SETTINGS flags, 
                                                        int32_t value);


int
SPDY_settings_lookup (const struct SPDY_Settings * container,
                                                                enum SPDY_SETTINGS id,
                                                                enum SPDY_FLAG_SETTINGS * flags,
                                                                int32_t * value);


int
SPDY_settings_iterate (const struct SPDY_Settings * container,
                                                                SPDY_SettingsIterator iterator,
                                                                void * iterator_cls);


void
SPDY_settings_destroy (struct SPDY_Settings * container);


/* SPDY SETTINGS handling functions */


int
SPDY_send_settings (struct SPDY_Session * session,
                                        struct SPDY_Settings * settings,
                                        enum SPDY_FLAG_SETTINGS_FRAME flags,
                                        ...);

 
/* SPDY misc functions */


void
SPDY_destroy_request (struct SPDY_Request * request);


int
SPDY_send_ping(struct SPDY_Session * session,
                                SPDY_PingCallback rttcb,
                                void * rttcb_cls);

#endif