src/server/daemon/httplistener.h

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2013 Olaf Wintermann. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. 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.
 *
 * 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.
 */

#ifndef HTTPLISTENER_H
#define	HTTPLISTENER_H

#include "sessionhandler.h"
#include "threadpools.h"
#include "config.h"
#include "../util/systems.h"

#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netdb.h>
#include <unistd.h>

#include <openssl/bio.h> 
#include <openssl/ssl.h> 
#include <openssl/err.h> 

#ifdef	__cplusplus
extern "C" {
#endif

/* HttpListener typedef in nsapi.h */
typedef struct _acceptor         Acceptor;
typedef struct _listener_config  ListenerConfig;
typedef struct _http_ssl         HttpSSL;

typedef struct _ws_socket        WSSocket;


union vs {
    VirtualServer    *vs;
    char             *vs_name;
};
struct _listener_config {
    ServerConfiguration  *cfg;
    cxmutstr             name;
    cxmutstr             vs;
    cxmutstr             threadpool;
    char                 *address;
    int                  port;
    int                  nacceptors;
    WSBool               blockingio;
    WSBool               ssl;
    cxstring             certfile;
    cxstring             privkeyfile;
    cxstring             chainfile;
    cxstring             disable_proto;
};

struct _acceptor {
    pthread_t      tid;
    HttpListener   *listener;
    WSBool         ipv6;
    WSBool         exit;
    WSBool         running;
};

struct _http_listener {
    ServerConfiguration  *cfg;
    cxmutstr             name;
    union vs             default_vs;
    int                  port;
    WSSocket             *server_socket;
    WSSocket             *server_socket6;
    SessionHandler       *session_handler;
    threadpool_t         *threadpool;
    HttpListener         *next;
    Acceptor             **acceptors;
    Acceptor             **acceptors6;
    int                  nacceptors;
    uint32_t             nacceptors_running;
    int                  running;
    
    pthread_mutex_t      shutdown_mutex;
    pthread_cond_t       shutdown_cond;
    WSBool               shutdown;
};

struct _http_ssl {
    /*
    unsigned char *cert;
    size_t        certlen;
    unsigned char *privkey;
    size_t        privkeylen;
    unsigned char *chain;
    size_t        chainlen;
    */
    
    SSL_CTX       *sslctx;
    
    // TODO: ssl/tls cipher, ... config
};

union ws_socketaddr {
    struct sockaddr_in  addr4;
    struct sockaddr_in6 addr6;
};

struct _ws_socket {
    union ws_socketaddr addr;
    struct sockaddr *sockaddr;
    size_t sockaddr_size;
    int socket;
    WSBool listening;
    HttpSSL *ssl;
    uint32_t ref; // reference counter
};

/*
 * global listener init function
 * must be called before any other listener initialization
 */
int http_listener_global_init(void);

int start_all_listener();

HttpListener* http_listener_create(ListenerConfig *conf);

void http_listener_destroy(HttpListener *listener);

int http_listener_start(HttpListener *listener);


/*
 * returns true of l1 and l2 share the same socket
 */
int http_listener_socket_eq(HttpListener *l1, HttpListener *l2);

/*
 * set the succeeding listener
 */
void http_listener_set_next(HttpListener *listener, HttpListener *next);

/*
 * Connect to the listener's server socket
 * Returns a file descriptor or -1
 */
int http_listener_connect(HttpListener *listener, WSBool ipv6);

/*
 * shutdown all acceptor threads
 * this should be called, before any new acceptors for the same socket
 * are started
 */
void http_listener_shutdown_acceptors(HttpListener *listener);

Acceptor* acceptor_new(HttpListener *listener);

void acceptor_start(Acceptor *a);

void* acceptor_thread(Acceptor *a);

void wssocket_ref(WSSocket *ws);
void wssocket_unref(WSSocket *ws);

int http_listener_apply_keep_alive_settings(HttpListener *listener, int fd);


#ifdef	__cplusplus
}
#endif

#endif	/* HTTPLISTENER_H */