ggz.h

Go to the documentation of this file.

#ifndef __GGZ_H__
#define __GGZ_H__

#define LIBGGZ_VERSION_MAJOR 0
#define LIBGGZ_VERSION_MINOR 0
#define LIBGGZ_VERSION_MICRO 14
#define LIBGGZ_VERSION_IFACE "5:0:3"

#include <sys/types.h>

#ifdef __cplusplus
extern "C" {
#endif

#ifdef __GNUC__
#  define ggz__attribute(att)  __attribute__(att)
#else
#  define ggz__attribute(att)
#endif

#if defined __GNUC__ && (__GNUC__ >= 3)
#  define _GGZFUNCTION_ ""
#elif defined(__sun)
#  define _GGZFUNCTION_ ""
#else
#  ifndef __cplusplus
#    define _GGZFUNCTION_ __FUNCTION__
#  else
#    define _GGZFUNCTION_ ""
#  endif
#endif

#define GGZ_MEM_DEBUG "ggz_mem"

#define ggz_malloc(size) _ggz_malloc(size, _GGZFUNCTION_ " in " __FILE__, __LINE__)
                                                   

#define ggz_realloc(mem, size) _ggz_realloc(mem, size, _GGZFUNCTION_ " in " __FILE__, __LINE__)
                                                       

#define ggz_free(mem) _ggz_free(mem, _GGZFUNCTION_ " in " __FILE__,  __LINE__)
                                                 

#define ggz_strdup(string) _ggz_strdup(string, _GGZFUNCTION_ " in " __FILE__,  __LINE__)
                                                 


void * _ggz_malloc(const size_t size, const char * tag, int line);

void * _ggz_realloc(const void * ptr, const size_t size,
                    const char * tag, int line)
                    ggz__attribute((warn_unused_result));

int _ggz_free(const void * ptr, const char * tag, int line);

char * _ggz_strdup(const char * ptr, const char * tag, int line)
                   ggz__attribute((warn_unused_result));

char * ggz_strncpy(char * dst, const char * src, size_t n);


int ggz_memory_check(void);

#define GGZ_CONF_DEBUG "ggz_conf"

typedef enum {
        GGZ_CONF_RDONLY = ((unsigned char) 0x01), 
        GGZ_CONF_RDWR = ((unsigned char) 0x02),   
        GGZ_CONF_CREATE = ((unsigned char) 0x04)  
} GGZConfType;


void ggz_conf_cleanup (void);

void ggz_conf_close (int handle);

int ggz_conf_parse              (const char *path,
                                 const GGZConfType options);

int ggz_conf_commit             (int handle);

int ggz_conf_write_string       (int    handle,
                         const char     *section,
                         const char     *key,
                         const char     *value);

int ggz_conf_write_int  (int    handle,
                         const char     *section,
                         const char     *key,
                         int    value);

int ggz_conf_write_list (int    handle,
                         const char     *section,
                         const char     *key,
                         int    argc,
                         char   **argv);

char * ggz_conf_read_string     (int    handle,
                         const char     *section,
                         const char     *key,
                         const char     *def);

int ggz_conf_read_int   (int    handle,
                         const char     *section,
                         const char     *key,
                         int    def);

int ggz_conf_read_list(int      handle,
                         const char     *section,
                         const char     *key,
                         int    *argcp,
                         char   ***argvp);

int ggz_conf_remove_section     (int    handle,
                         const char     *section);

int ggz_conf_remove_key (int    handle,
                         const char     *section,
                         const char     *key);

int ggz_conf_get_sections (int handle,
                         int    *argcp,
                         char   ***argvp);

int ggz_conf_get_keys (int handle,
                         const char *section,
                         int    *argcp,
                         char   ***argvp);

typedef int (*ggzEntryCompare)(const void *a, const void *b);


typedef void *  (*ggzEntryCreate)       (void *data);


typedef void    (*ggzEntryDestroy)      (void *data);


typedef struct _GGZListEntry {
        void                 *data;     
        struct _GGZListEntry *next, 
                             *prev;     
} GGZListEntry;


typedef struct _GGZList {
        GGZListEntry    *head,         
                        *tail;         
        ggzEntryCompare compare_func;  
        ggzEntryCreate  create_func;   
        ggzEntryDestroy destroy_func;  
        int             options;       
        int             entries;       
} GGZList;



#define GGZ_LIST_REPLACE_DUPS 0x00 
#define GGZ_LIST_ALLOW_DUPS   0x01 
GGZList *ggz_list_create (ggzEntryCompare compare_func,
                          ggzEntryCreate create_func,
                          ggzEntryDestroy destroy_func,
                          int options);


int ggz_list_insert            (GGZList *list, void *data);


GGZListEntry *ggz_list_head     (GGZList *list);


GGZListEntry *ggz_list_tail     (GGZList *list);


GGZListEntry *ggz_list_next     (GGZListEntry *entry);


GGZListEntry *ggz_list_prev     (GGZListEntry *entry);


void *ggz_list_get_data         (GGZListEntry *entry);


GGZListEntry *ggz_list_search   (GGZList *list, void *data);


GGZListEntry *ggz_list_search_alt(GGZList *list, void *data,
                                  ggzEntryCompare compare_func);

void ggz_list_delete_entry      (GGZList *list, GGZListEntry *entry);


void ggz_list_free              (GGZList *list);


int ggz_list_count              (GGZList *list);


/* String list functions */

int ggz_list_compare_str        (void *a, void *b);


void * ggz_list_create_str      (void *data);


void ggz_list_destroy_str       (void *data);

typedef struct _GGZList GGZStack;


GGZStack* ggz_stack_new(void);


void ggz_stack_push(GGZStack *stack, void *data);


void* ggz_stack_pop(GGZStack *stack);


void* ggz_stack_top(GGZStack *stack);


void ggz_stack_free(GGZStack *stack);

struct _GGZXMLElement {
        
        char *tag;           
        char *text;          
        GGZList *attributes; 
        void *data;          
        void (*free)(struct _GGZXMLElement*); 
        void (*process)(void*, struct _GGZXMLElement*); 
};


typedef struct _GGZXMLElement GGZXMLElement;


GGZXMLElement* ggz_xmlelement_new(const char *tag, const char * const *attrs,
        void (*process)(void*, GGZXMLElement*), void (*free)(GGZXMLElement*));


void ggz_xmlelement_init(GGZXMLElement *element, const char *tag,
        const char * const *attrs,
        void (*process)(void*, GGZXMLElement*), void (*free)(GGZXMLElement*));


void ggz_xmlelement_set_data(GGZXMLElement *element, void *data);


const char *ggz_xmlelement_get_tag(GGZXMLElement *element);


const char *ggz_xmlelement_get_attr(GGZXMLElement *element, const char *attr);


void* ggz_xmlelement_get_data(GGZXMLElement *element);


char* ggz_xmlelement_get_text(GGZXMLElement *element);


void ggz_xmlelement_add_text(GGZXMLElement *element, const char *text, int len);


void ggz_xmlelement_free(GGZXMLElement *element);

typedef enum {
        GGZ_CHECK_NONE = 0x00, 
        GGZ_CHECK_MEM = 0x01   
} GGZCheckType;

typedef void (*GGZDebugHandlerFunc)(int priority, const char *msg);

void ggz_debug_init(const char **types, const char* file);

GGZDebugHandlerFunc ggz_debug_set_func(GGZDebugHandlerFunc func);

void ggz_debug_enable(const char *type);

void ggz_debug_disable(const char *type);

void ggz_debug(const char *type, const char *fmt, ...)
               ggz__attribute((format(printf, 2, 3)));

void ggz_log(const char *type, const char *fmt, ...)
             ggz__attribute((format(printf, 2, 3)));

void ggz_error_sys(const char *fmt, ...)
                   ggz__attribute((format(printf, 1, 2)));

void ggz_error_sys_exit(const char *fmt, ...)
                        ggz__attribute((format(printf, 1, 2)))
                        ggz__attribute((noreturn));

void ggz_error_msg(const char *fmt, ...)
                   ggz__attribute((format(printf, 1, 2)));

void ggz_error_msg_exit(const char *fmt, ...)
                        ggz__attribute((format(printf, 1, 2)))
                        ggz__attribute((noreturn));

void ggz_debug_cleanup(GGZCheckType check);

char * ggz_xml_escape(const char *str);

char * ggz_xml_unescape(const char *str);

typedef struct _GGZFile GGZFile;

GGZFile * ggz_get_file_struct(int fdes);

int ggz_make_path(const char *full);

char * ggz_read_line(GGZFile *file);

void ggz_free_file_struct(GGZFile *file);


int ggz_strcmp(const char *s1, const char *s2);


int ggz_strcasecmp(const char *s1, const char *s2);
 
#define GGZ_SOCKET_DEBUG "socket"

typedef enum {
        GGZ_IO_CREATE,  
        GGZ_IO_READ,    
        GGZ_IO_WRITE,   
        GGZ_IO_ALLOCATE 
} GGZIOType;

typedef enum {
        GGZ_DATA_NONE,   
        GGZ_DATA_CHAR,   
        GGZ_DATA_INT,    
        GGZ_DATA_STRING, 
        GGZ_DATA_FD      
} GGZDataType;

typedef void (*ggzIOError) (const char * msg,
                            const GGZIOType type,
                            const int fd,
                            const GGZDataType data);

int ggz_set_io_error_func(ggzIOError func);

ggzIOError ggz_remove_io_error_func(void);


typedef void (*ggzIOExit) (int status);

int ggz_set_io_exit_func(ggzIOExit func);

ggzIOExit ggz_remove_io_exit_func(void);

unsigned int ggz_get_io_alloc_limit(void);

unsigned int ggz_set_io_alloc_limit(const unsigned int limit);


int ggz_init_network(void);


typedef void (*ggzNetworkNotify) (const char *address, int socket);

int ggz_set_network_notify_func(ggzNetworkNotify func);

const char *ggz_resolvename(const char *name);


const char *ggz_getpeername(int fd, int resolve);


/****************************************************************************
 * Creating a socket.
 * 
 * type  :  one of GGZ_SERVER or GGZ_CLIENT
 * port  :  tcp port number 
 * server:  hostname to connect to (only relevant for client)
 * 
 * Returns socket fd or -1 on error
 ***************************************************************************/

typedef enum {
        GGZ_SOCK_SERVER, 
        GGZ_SOCK_CLIENT  
} GGZSockType;

int ggz_make_socket(const GGZSockType type, 
                    const unsigned short port, 
                    const char *server);

int ggz_make_socket_or_die(const GGZSockType type,
                           const unsigned short port, 
                           const char *server);

int ggz_make_unix_socket(const GGZSockType type, const char* name);

int ggz_make_unix_socket_or_die(const GGZSockType type, const char* name);


int ggz_write_char(const int sock, const char data);

void ggz_write_char_or_die(const int sock, const char data);

int ggz_read_char(const int sock, char *data);

void ggz_read_char_or_die(const int sock, char *data);

int ggz_write_int(const int sock, const int data);

void ggz_write_int_or_die(const int sock, const int data);

int ggz_read_int(const int sock, int *data);

void ggz_read_int_or_die(const int sock, int *data);

int ggz_write_string(const int sock, const char *data);

void ggz_write_string_or_die(const int sock, const char *data);

int ggz_va_write_string(const int sock, const char *fmt, ...)
                        ggz__attribute((format(printf, 2, 3)));

void ggz_va_write_string_or_die(const int sock, const char *fmt, ...)
                                ggz__attribute((format(printf, 2, 3)));

int ggz_read_string(const int sock, char *data, const unsigned int len);

void ggz_read_string_or_die(const int sock, char *data, const unsigned int len);

int ggz_read_string_alloc(const int sock, char **data);

void ggz_read_string_alloc_or_die(const int sock, char **data);

/* ggz_write_fd/ggz_read_fd are not supported on all systems. */

int ggz_write_fd(const int sock, int sendfd);

int ggz_read_fd(const int sock, int *recvfd);

int ggz_writen(const int sock, const void *vdata, size_t n);

int ggz_readn(const int sock, void *data, size_t n);

typedef struct
{
        char *hash;             
        int hashlen;    
} hash_t;

hash_t ggz_hash_create(const char *algo, const char *text);

hash_t ggz_hmac_create(const char *algo, const char *text, const char *secret);

char *ggz_base16_encode(const char *text, int length);

char *ggz_base64_encode(const char *text, int length);

char *ggz_base64_decode(const char *text, int length);

typedef enum {
        GGZ_TLS_CLIENT,         
        GGZ_TLS_SERVER          
} GGZTLSType;

typedef enum {
        GGZ_TLS_VERIFY_NONE,            
        GGZ_TLS_VERIFY_PEER                     
} GGZTLSVerificationType;

void ggz_tls_init(const char *certfile, const char *keyfile, const char *password);

int ggz_tls_support_query(void);

const char *ggz_tls_support_name(void);

int ggz_tls_enable_fd(int fdes, GGZTLSType whoami, GGZTLSVerificationType verify);

int ggz_tls_disable_fd(int fdes);

size_t ggz_tls_write(int fd, void *ptr, size_t n);

size_t ggz_tls_read(int fd, void *ptr, size_t n);

#ifdef __cplusplus
}
#endif

#endif  /* __GGZ_H__ */

---