types.hpp

Go to the documentation of this file.

/*
 *  Copyright 2009 DreamLab Onet.pl Sp. z o.o.
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *   Authors:
 *   Michal Szklarzewicz <michal(x)szklarzewicz(y)gmail(x)com>
 *   Grzegorz Jablonski  <jablonski(x)grzegorz(y)gmail(x)com>
 *   (use dot instead of x, and @ instead of y)
 */

#ifndef __TYPES__HPP__
#define __TYPES__HPP__

#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include <cstdio>
#include <event.h>
#include <time.h>

#include <list>

#define MAX_CLIENT_RECV 4024  
#define MAX_SERVER_RECV 4024  
#define RECV_THREAD_AMOUNT 1024 
enum AUTH_STATE 
{
        AUTH_STATE_UNKNOWN = 0,
        AUTH_STATE_BANNED = 1,
        AUTH_STATE_IGNORE_BANNED = 2
};
enum CONFIG_ENTRY_CHECK_MODE {
        CHECK_TRAFFIC = 1,
        CHECK_HOSTING = 2,
        CHECK_BOTH = 3
};

//#define DEBUG

#ifdef DEBUG
#define debug(...) fprintf(stderr, __VA_ARGS__ )
#else
#define debug(...) ;
#endif

#define log_error(...) fprintf(stderr, __VA_ARGS__ )

#define t_int int

extern int curr_month; 
struct config_entry    
{ 
        unsigned char zone_index;
        
        long long traffic_month;
        long long traffic_day;
        long long traffic_quarter;
        char ban;
        char allow;
};

struct buf_el{
    int     to_send; 
    int     pos;     
    char   *buf;     
    int     do_not_delete; 
    int     *count;        
    buf_el():do_not_delete(0){
                count = NULL;
                buf = NULL;
        };
};

struct t_uid
{
        uint32_t        length; 
        char            *data;  
        bool operator==(const t_uid& other) const {
                if(this->length != other.length) {
                        return false;
                }
                return memcmp(this->data, other.data, this->length) == 0;
        }
        bool operator!=(const t_uid& other) const {
                return !(*this == other);
        }
        void allocate(uint32_t length_new){
            if(length>0) delete[] data;
        length = length_new;
                if(length_new > 0) {
                        data = new char[length];
                }
    }
        bool operator<(const t_uid& other) const {
                int check_size = (this->length < other.length) ? this->length : other.length;
                int rc = memcmp(this->data, other.data, check_size);
                if(rc == 0) {
                        return this->length < other.length;
                } else if(rc < 0) {
                        return true;
                } else {
                        return false;
                }
                //return memcmp(this->data, other.data, (this->length < other.length) ? this->length : other.length);
        }
        t_uid(const char * dest){
                length = strlen(dest);
                data = new char[length];
                memcpy(data, dest, length);
        }
        t_uid(){ length=0; data=NULL; }
        t_uid(const t_uid &ref){
                length = ref.length;
                if(ref.length != 0) {
            data = new char[length];
                        memcpy(data, ref.data, length);
                }
        }
        t_uid& operator=(const t_uid &ref){
        if( &ref == this ) return *this;
            if( length > 0 ) {
                        length = 0;
                        delete[] data;
                }
            allocate(ref.length);
            memcpy(data, ref.data, length);
        return *this;
    }
        ~t_uid(){
            //debug("~[%d] %.*s\n",length, length, data);
        if(length>0) delete[] data;
    }
};
#define t_traffic_int long long 
#define QUARTER 900                     
#define HOUR 3600               
#define DAY 86400               
#define MONTH 2592000           
struct t_traffic
{ 
        long long traffic_month;  
        long long traffic_day;    
        long long traffic_quarter;
        time_t timestamp;         
        char ban;                 
        char allow;                               
        char _set;                                
        t_traffic() { 
                ban = allow = false;
                traffic_month=traffic_day=traffic_quarter=_set=0; 
                timestamp=time(NULL); 
        }
        t_traffic(t_traffic_int diff){
                _set=0;
                timestamp = time(NULL);
                ban = allow = false;
                traffic_month=traffic_day=traffic_quarter=diff;
        }
        inline void update_() {
            time_t curr_time = time(NULL);
            time_t interval = curr_time - timestamp;
            tm *info = new tm; 
            localtime_r(&timestamp,info);
            if(info->tm_mon != curr_month) {
            traffic_month=0;
                }
        delete info;

            traffic_day = traffic_day - traffic_day * interval / DAY;
            traffic_quarter = traffic_quarter - traffic_quarter * interval / QUARTER;    
            traffic_quarter =  traffic_quarter>0?traffic_quarter:0;
        traffic_day =  traffic_day>0?traffic_day:0;

        timestamp = curr_time;
    }   
        t_traffic& operator+=(const t_traffic_int &add) {
            update_();
                traffic_day += add;
                traffic_quarter += add;
                traffic_month += add;
                return (*this);
        }
        t_traffic& operator+=(const t_traffic &add) {
        update_();
                traffic_day+=add.traffic_day;
                traffic_month+=add.traffic_month;
                traffic_quarter+=add.traffic_quarter;
                return (*this);
        }
        t_traffic(const t_traffic &ref) {
                traffic_month = ref.traffic_month;
                traffic_day = ref.traffic_day;
                traffic_quarter = ref.traffic_quarter;
                timestamp = ref.timestamp;
                ban = ref.ban;
                allow = ref.allow;
                _set = ref._set;
        }
        int set() {
                return _set;
        }       
        bool operator<(const t_traffic &x) {
            //debug("traffic_quarter: %d\n",traffic_quarter);
        update_();
        //debug("traffic_quarter: %d\n",traffic_quarter);
                //debug("%lld %lld\n",traffic_month, x.traffic_month);
                if( traffic_month > x.traffic_month ) return false;
                //debug("%lld %lld\n",traffic_day, x.traffic_day);
                if( traffic_day > x.traffic_day ) return false;
                //debug("%lld %lld\n",traffic_quarter, x.traffic_quarter);
                if( traffic_quarter > x.traffic_quarter ) return false;
                return true;
        }       
};


enum conn_state  { opened, closed };
struct client_s {
        public:
                ssize_t read_position;                     
                char read_buffer[MAX_CLIENT_RECV]; 
                t_uid uid;                                                 
                event * read;                                      
                event * write;                                          
                int fd;                                                         
                conn_state state;                                       
                int thread_index;                                       
                char auth_result;                                       
                unsigned char auth_zone;
                
                bool is_mainserver;
                std::list<buf_el> packets_to_send;      
                client_s() {
                        read_position = 0;
                        state = closed;
                        is_mainserver = false;
                        read = 0;
                        write = 0;
                }
                
        ~client_s() {
                        for(std::list<buf_el>::iterator it = packets_to_send.begin(); it != packets_to_send.end(); ++it) {
                                if(it->do_not_delete) {
                                        *(it->count) = *(it->count) - 1;
                                }
                                if(!it->do_not_delete) {
                                        delete[] it->buf;
                                } else if(*(it->count)==0 ) {
                                        delete[] it->buf;
                                        delete it->count;
                                }
                        }
        }
};
typedef client_s client_t;
class proxy_server{
    public:
        int         port;
        char       *host;
        client_t   *cli;
        int         active;
};

struct thread_s{
        public: 
                int i;
                event * pipe_ev;
                event * ev;
};
extern struct event_base*               thread_loops[RECV_THREAD_AMOUNT];       
extern pthread_t                                thread_ids[RECV_THREAD_AMOUNT];     
extern int                                      thread_usage[RECV_THREAD_AMOUNT];   
extern pthread_mutex_t          thread_usage_guard; 
extern pthread_mutex_t          mutex_queue[RECV_THREAD_AMOUNT];
extern int                                      pipe_queue[RECV_THREAD_AMOUNT][2];
extern int                                      last_thread;                                    
extern pthread_mutex_t master_server_connecting; 
extern bool master_server_connected;
extern client_t *master_server_cli;

//extern int uid_ttl;
extern const char *NOTIFY;
extern std::list<client_t *>    queue[RECV_THREAD_AMOUNT];
extern pthread_mutex_t          mutex_queue[RECV_THREAD_AMOUNT];

extern pthread_mutex_t          master_guard;
#endif

---