root/cserver/server.h

/*
 * Copyright (c) 2006, Federico Tomassini AKA efphe (effetom AT gmail DOT com)
 * 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 University of California, Berkeley 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 REGENTS 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 REGENTS AND 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 SERVER_
#define SERVER_H

#include <stdint.h>
#include <stdlib.h>
#include <errno.h>
#include <netdb.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <poll.h>
#include <signal.h>
typedef void (*sighandler_t)(int);

#include "wlog.h"

#define MAX_SERVER_NAME_LEN     32
#define MAX_SERVER_HOSTNAMES    12
#define MAX_SERVER_SOCKETS      12
#define MAX_THREADS_PER_SOCKET  25
#define DEF_THREADS_PER_SOCKET  10
#define MAX_SERVER_BACKLOG      12
#define DEF_SERVER_BACKLOG      12


/*
 **                    
 ***                  *
 **** ABOUT LOGGING: **
 ***                  *
 **                    
 * 
 * With the function:
 *  
 *   server_log_init(LogLevel level, SyslogFacility facility, int on_stderr)
 *
 * it's possible to configure the logging library.
 * In particular, if `level` and `facility` are -1, default values are used,
 * and it's safe to call:
 *
 *   server_log_init(-1, -1, on_stderr);
 *
 * If on_stderr is 1 (or, in general, is True), logging will be printed to 
 * STDERR, otherwise syslog will be used.
 * By default, STDERR is used.
 *
 * To debug your code, you can use the following function:
 *
 *   void     fatal(const char *, ...)   -> log and exit (deliver a SIGINT)
 *   void     error(const char *, ...)   -> log
 *   void     logit(const char *, ...)   -> log
 *   void     verbose(const char *, ...) -> log
 *   void     debug(const char *, ...)   -> log if level is high enough
 *   void     debug2(const char *, ...)  -> log if level is high enough
 *   void     debug3(const char *, ...)  -> log if level is high enough
 *
 * For example:
 *   
 *   char *msg= "ciao"
 *   logit("This is a beatiful message: %s", a);
 *  
 */


/*
 **                    
 ***                  *
 **** ABOUT SIGNALS: **
 ***                  *
 **                    
 *                
 * Signals are programmable for each server instance.
 * Using the function:
 *
 *   void server_set_signal_handler(server *s, int signum, void(*f)(int));
 *
 * it's possible to define server behaviour when receiving the signal
 * signum.
 *
 **
 ***                    *
 **** STOPPING SERVERS **
 ***                    *
 **
 *
 * To stop the server when a signal is delivered, it's sufficient 
 * to call the function:
 *
 *   void servers_stop()
 *
 * inside the handler. Note that the memory allocated by servers struct
 * will be free() automatically.
 *
 * To stop servers, but waiting for active connections to be worked, call:
 *
 *   void servers_slow_stop()
 *
 **
 ***                   *
 **** DEFAULT ACTIONS **
 ***                   *
 **
 *
 * If the same handler is set for multiple signals, all
 * signals associate to that handler will be blocked during
 * the execution of the hanlder.
 *
 * By default, the following signals will be handled:
 *
 *  - SIGINT 
 *      - Threads exit immediately.
 *      - Memory allocation of server(s) struct will be free()
 *
 *          (simply call of:  servers_stop() )
 *
 *  - SIGTERM (simply call of servers_slow_stop() )
 *      - Threads waiting for connections exit immediately.
 *      - Threads working for active connections finish their work and exit.
 *      - Memory allocation of server(s) struct will be free()
 *      
 *          (simply call of:  servers_slow_stop() )
 *
 ***
 * By the way, you can overwrite the handler of the two signals.
 ***
 */


typedef pthread_mutex_t pmt;
typedef pthread_cond_t pct;

/* server signal handler */
struct ssh
{
    int         signum;
    void        (*f)(int);
    sigset_t    sa_mask;
    struct ssh  *next;
};
typedef struct ssh ssh;
#define SSH_SIZE sizeof(ssh)

typedef struct 
{
    char            name[MAX_SERVER_NAME_LEN];
    int             port;
    int             type; /* default SOCK_STREAM */
    int             family; /* default AF_INET */
    int             backlog; /* default DEF_SERVER_BACKLOG */
    int             threads_per_socket; /* default DEF_THREADS_PER_SOCKET */        
    int             hostnames_n;
    char            *hostnames[MAX_SERVER_HOSTNAMES];
    int             sockets_n;
    int             sockets[MAX_SERVER_SOCKETS];
    pmt             sockets_mutex[MAX_SERVER_SOCKETS];
    int             processing_socket; 
    pmt             processing_socket_mutex; 
    int             threads_counter;
    pmt             threads_counter_mutex;
    pct             threads_counter_cond;
    void            (*handler)(int,struct sockaddr*,socklen_t*);
    pmt             start;
    ssh             *signal_handlers;
} server;

/* 
 * Api.
 */


void    server_log_init(LogLevel level, SyslogFacility facility, int on_stderr);
void    server_set_signal_handler(server *s, int signum, void(*f)(int));
void    server_init(server *s);
void    server_set_name(server *s,char *name);
void    server_set_backlog(server *s,int backlog);
void    server_set_tps(server *s,int tps);
void    servers_destroy(server *s, int nserver);
int     server_add_hostname(server *s,char *hname);
void    server_set_type(server *s, int type);
void    server_set_family(server *s, int family);
void    server_set_port(server *s,uint16_t port);
void    server_set_handler(server *s, void (*f)(int,struct sockaddr*,socklen_t*));
void    servers_serve(server *servers,int nserver);
int     server_setsockopt(server *s,int level,int optname,const void *optval,socklen_t optlen);
void    servers_stop(void);
void    servers_slow_stop(void);


/*
 * Internals.
 */

ssh*    _server_new_signal_handler(int signum, sigset_t *sa_mask, void(*f)(int));
ssh*    _server_has_signal_handler(server *s, int signum);
int     _servers_are_stopped();
void    _server_destroy(server *s);
int     _server_add_socket(server *s,int skt);
int     _server_prepare_bind_sockets(server *s);
void    _server_listen(server *s);
void    _servers_thread_begin_work(void);
void    _server_thread_ends_work(void);
int     _server_thread_begins(pmt *m);
void*   _server_accept_thread(void *arg);
void    _server_init_signals(server *s);
void    _server_init_mutexes(server *s);
void    _server_default_sigint_handler(int signum);
void    _server_default_sigterm_handler(int signum);
void    _server_serve(server *s);
#endif