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>

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

#define MAX_CLIENT_RECV 4024
#define MAX_LIMIT_SERVER_RECV 4024
#define RECV_THREAD_AMOUNT 1

enum AUTH_STATE
{
        AUTH_STATE_UNKNOWN = 0,
        AUTH_STATE_BANNED = 1,
        AUTH_STATE_IGNORE_BANNED = 2
};

//#define DEBUG

#define t_int int
extern int curr_month; 
enum CONFIG_ENTRY_CHECK_MODE {
        CHECK_TRAFFIC = 1,
        CHECK_HOSTING = 2,
        CHECK_BOTH = 3
};

struct config_entry {
        char            check_mode; // 1 - traffic, 2 - hosting, 3 - both (use CONFIG_ENTRY_CHECK_MODE)
        unsigned char   zone_index;
        
        //user-dest specyfic
        int                     ttl;
        long long       traffic_month;
        long long       traffic_day;
        long long       traffic_quarter;
        
        //dest - specyfic limit (for hosting use)
        long long       hosting_traffic_month;
        long long       hosting_traffic_day;
        long long       hosting_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 {
                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);
        }
    void allocate(uint32_t length_new){
            if(length>0) delete[] data;
        length = length_new;
            data = new char[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() {
                traffic_month=traffic_day=traffic_quarter=_set=0; 
                timestamp=time(NULL);
        }
        t_traffic(t_traffic_int diff) {
                _set=0;
                timestamp = time(NULL);
                traffic_month=traffic_day=traffic_quarter=diff;
        }
        inline void update_() {
            time_t curr_time = time(NULL);
            time_t interval = curr_time - timestamp;
            tm info; 
            localtime_r(&timestamp,&info);
            if(info.tm_mon != curr_month) {
            traffic_month=0;
                }
            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);
                if( traffic_month > x.traffic_month ) return false;
                if( traffic_day > x.traffic_day ) return false;
                if( traffic_quarter > x.traffic_quarter ) return false;
                return true;
        }       
};

enum conn_state  { opened, closed };
class proxy_server;
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;
                
                std::list<buf_el> packets_to_send;      
                proxy_server * proxy;
                client_s() {
                        read_position = 0;
                        state = closed;
                        proxy = 0;
                        write = 0;
                        read = 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;
                
        ~proxy_server() {
                delete[] host;
        }
};

struct thread_s{
        public: 
                int i;
                event * pipe_ev;
                event * ev;
};

//extern int uid_ttl;
extern bool pending_reload;

void reload_config();
#endif

---