[doldaconnect.git] / include / utils.h

/*
 *  Dolda Connect - Modular multiuser Direct Connect-style client
 *  Copyright (C) 2004 Fredrik Tolf <fredrik@dolda2000.com>
 *  
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *  
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *  
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
#ifndef _UTILS_H
#define _UTILS_H

#include <stdarg.h>
#include <stdlib.h>
#ifdef DAEMON
#include "log.h"
#endif

struct wcspair {
    struct wcspair *next;
    wchar_t *key;
    wchar_t *val;
};

struct strpair {
    struct strpair *next;
    char *key;
    char *val;
};

struct btree {
    struct btree *l, *r;
    int h;
    void *d;
};

/* "Safe" functions */
#ifdef DAEMON
#define LOGOOM(size) flog(LOG_CRIT, "%s (%s:%i): out of memory (alloc %zi)", __FUNCTION__, __FILE__, __LINE__, (size))
#define smalloc(size) ({void *__result__; ((__result__ = malloc(size)) == NULL)?({LOGOOM((ssize_t)(size)); abort(); (void *)0;}):__result__;})
#define srealloc(ptr, size) ({void *__result__; ((__result__ = realloc((ptr), (size))) == NULL)?({LOGOOM((ssize_t)(size)); abort(); (void *)0;}):__result__;})
#define swcsdup(wcs) ({wchar_t *__eval__; __eval__ = (wcs); (wchar_t *)wcscpy(smalloc(sizeof(wchar_t) * (wcslen(__eval__) + 1)), __eval__);})
#define sstrdup(str) ((char *)strcpy(smalloc(strlen(str) + 1), (str)))
#else
#define LOGOOM(size)
#define smalloc(size) ({void *__result__; ((__result__ = malloc(size)) == NULL)?({exit(-1); (void *)0;}):__result__;})
#define srealloc(ptr, size) ({void *__result__; ((__result__ = realloc((ptr), (size))) == NULL)?({exit(-1); (void *)0;}):__result__;})
#define swcsdup(wcs) ((wchar_t *)wcscpy(smalloc(sizeof(wchar_t) * (wcslen(wcs) + 1)), (wcs)))
#define sstrdup(str) ((char *)strcpy(smalloc(strlen(str) + 1), (str)))
#endif

#define CBCHAIN(name, args...) \
struct cbchain_ ## name { \
    struct cbchain_ ## name *next, *prev; \
    int (*func)(args, void *data); \
    void (*destroy)(void *data); \
    void *data; \
} * name

#define GCBCHAIN(name, args...) \
struct cbchain_ ## name * name = NULL

#define EGCBCHAIN(name, args...) \
extern struct cbchain_ ## name { \
    struct cbchain_ ## name *next, *prev; \
    int (*func)(args, void *data); \
    void *data; \
} * name

char *vsprintf2(char *format, va_list al);
char *sprintf2(char *format, ...)
#if defined(__GNUC__)
    __attribute__ ((format (printf, 1, 2)))
#endif
;
wchar_t *vswprintf2(wchar_t *format, va_list al);
wchar_t *swprintf2(wchar_t *format, ...);
int havecharset(char *charset);
wchar_t *icmbstowcs(char *mbs, char *charset);
wchar_t *icsmbstowcs(char *mbs, char *charset, wchar_t *def);
char *icwcstombs(wchar_t *wcs, char *charset);
char *icswcstombs(wchar_t *wcs, char *charset, char *def);
wchar_t *wcstolower(wchar_t *wcs);
wchar_t ucptowc(int ucp);
void _sizebuf(void **buf, size_t *bufsize, size_t reqsize, size_t elsize, int algo);
double ntime(void);
int wcsexists(wchar_t *h, wchar_t *n);
#ifndef HAVE_WCSCASECMP
int wcscasecmp(const wchar_t *s1, const wchar_t *s2);
#endif
char *hexencode(char *data, size_t datalen);
char *hexdecode(char *data, size_t *len);
char *base64encode(char *data, size_t datalen);
char *base64decode(char *data, size_t *datalen);
char *base32encode(char *data, size_t datalen);
char *base32decode(char *data, size_t *datalen);
void _freeparr(void **arr);
int _parrlen(void **arr);
char *findfile(char *name, char *homedir, int filldef);
struct strpair *newstrpair(char *key, char *val, struct strpair **list);
void freestrpair(struct strpair *pair, struct strpair **list);
char *spfind(struct strpair *list, char *key);
struct wcspair *newwcspair(wchar_t *key, wchar_t *val, struct wcspair **list);
void freewcspair(struct wcspair *pair, struct wcspair **list);
wchar_t *wpfind(struct wcspair *list, wchar_t *key);
int bbtreedel(struct btree **tree, void *item, int (*cmp)(void *, void *));
int bbtreeput(struct btree **tree, void *item, int (*cmp)(void *, void *));
void *btreeget(struct btree *tree, void *key, int (*cmp)(void *, void *));

#define sizebuf(b, bs, rs, es, a) _sizebuf((void **)(void *)(b), (bs), (rs), (es), (a))
#define sizebuf2(b, rs, a) _sizebuf((void **)(void *)(&(b)), &(b ## size), (rs), sizeof(*(b)), (a))
#define addtobuf(b, c) \
do { \
    _sizebuf((void **)(void *)(&(b)), &(b ## size), (b ## data) + 1, sizeof(*(b)), 1); \
    (b)[(b ## data)++] = (c); \
} while(0)
#define bufcat(d, s, n) \
do { \
    size_t __bufcat_size__; \
    __bufcat_size__ = (n); \
    _sizebuf((void **)(void *)(&(d)), &(d ## size), (d ## data) + __bufcat_size__, sizeof(*(d)), 1); \
    memcpy((d) + (d ## data), (s), sizeof(*(d)) * __bufcat_size__); \
    (d ## data) += __bufcat_size__; \
} while (0)
#define bprintf(b, fmt...) \
    do { \
	char *__bprintf_dest__; \
	__bprintf_dest__ = sprintf2(fmt); \
	bufcat(b, __bprintf_dest__, strlen(__bprintf_dest__)); \
	free(__bprintf_dest__); \
    } while(0)

#define freeparr(parr) _freeparr((void **)(parr))
#define parrlen(parr) _parrlen((void **)(parr))

#define CBREG(obj, name, funca, destroya, dataa) \
do { \
    struct cbchain_ ## name *__new_cb__; \
    __new_cb__ = smalloc(sizeof(*__new_cb__)); \
    __new_cb__->func = funca; \
    __new_cb__->destroy = destroya; \
    __new_cb__->data = dataa; \
    __new_cb__->prev = NULL; \
    __new_cb__->next = (obj)->name; \
    if((obj)->name != NULL) { \
        (obj)->name->prev = __new_cb__; \
    } \
    (obj)->name = __new_cb__; \
} while(0)

#define CBUNREG(obj, name, dataa) \
do { \
    struct cbchain_ ## name *__cur__; \
    for(__cur__ = (obj)->name; __cur__ != NULL; __cur__ = __cur__->next) { \
        if(__cur__->data == (dataa)) { \
            if(__cur__->destroy != NULL) \
                __cur__->destroy(__cur__->data); \
            if(__cur__->prev != NULL) \
                __cur__->prev->next = __cur__->next; \
            if(__cur__->next != NULL) \
                __cur__->next->prev = __cur__->prev; \
            if(__cur__ == (obj)->name) \
                (obj)->name = __cur__->next; \
            free(__cur__); \
            break; \
        } \
    } \
} while(0)

#define GCBREG(name, funca, dataa) \
do { \
    struct cbchain_ ## name *__new_cb__; \
    __new_cb__ = smalloc(sizeof(*__new_cb__)); \
    __new_cb__->func = funca; \
    __new_cb__->data = dataa; \
    __new_cb__->prev = NULL; \
    __new_cb__->next = name; \
    if(name != NULL) { \
        name->prev = __new_cb__; \
    } \
    name = __new_cb__; \
} while(0)

#define CBCHAININIT(obj, name) (obj)->name = NULL

#define CBCHAINFREE(obj, name) \
do { \
    struct cbchain_ ## name *__cur__; \
    while((__cur__ = (obj)->name) != NULL) { \
        (obj)->name = __cur__->next; \
        if(__cur__->destroy != NULL) \
            __cur__->destroy(__cur__->data); \
        free(__cur__); \
    } \
} while(0)

#define CBCHAINDOCB(obj, name, args...) \
do { \
    struct cbchain_ ## name *__cur__, *__next__; \
    for(__cur__ = (obj)->name; __cur__ != NULL; __cur__ = __next__) { \
        __next__ = __cur__->next; \
        if(__cur__->func(args, __cur__->data)) { \
            if(__cur__->next != NULL) \
                __cur__->next->prev = __cur__->prev; \
            if(__cur__->prev != NULL) \
                __cur__->prev->next = __cur__->next; \
            if(__cur__ == (obj)->name) \
                (obj)->name = __cur__->next; \
            free(__cur__); \
        } \
    } \
} while(0)

#define GCBCHAINDOCB(name, args...) \
({ \
    struct cbchain_ ## name *__cur__; \
    int __ret__; \
    __ret__ = 0; \
    for(__cur__ = name; __cur__ != NULL; __cur__ = __cur__->next) { \
        if(__cur__->func(args, __cur__->data)) { \
            __ret__ = 1; \
            break; \
        } \
    } \
    __ret__; \
})

#endif
Commit	Line	Data
d3372da9	1	/*
d3372da9	2	* Dolda Connect - Modular multiuser Direct Connect-style client
302a2600	3	* Copyright (C) 2004 Fredrik Tolf <fredrik@dolda2000.com>
d3372da9	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2 of the License, or
	8	* (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*/
	19	#ifndef _UTILS_H
	20	#define _UTILS_H
	21
	22	#include <stdarg.h>
	23	#include <stdlib.h>
8b17e919	24	#ifdef DAEMON
d3372da9	25	#include "log.h"
8b17e919	26	#endif
d3372da9	27
9ec790e8	28	struct wcspair {
	29	struct wcspair *next;
	30	wchar_t *key;
	31	wchar_t *val;
	32	};
	33
ba087e49 FT	34	struct strpair {
	35	struct strpair *next;
	36	char *key;
	37	char *val;
	38	};
8b17e919	39
ffb8ed40 FT	40	struct btree {
	41	struct btree l, r;
	42	int h;
	43	void *d;
	44	};
	45
d3372da9	46	/* "Safe" functions */
8b17e919	47	#ifdef DAEMON
12e320a0	48	#define LOGOOM(size) flog(LOG_CRIT, "%s (%s:%i): out of memory (alloc %zi)", __FUNCTION__, __FILE__, __LINE__, (size))
	49	#define smalloc(size) ({void __result__; ((__result__ = malloc(size)) == NULL)?({LOGOOM((ssize_t)(size)); abort(); (void )0;}):__result__;})
	50	#define srealloc(ptr, size) ({void __result__; ((__result__ = realloc((ptr), (size))) == NULL)?({LOGOOM((ssize_t)(size)); abort(); (void )0;}):__result__;})
4344b8c8	51	#define swcsdup(wcs) ({wchar_t __eval__; __eval__ = (wcs); (wchar_t )wcscpy(smalloc(sizeof(wchar_t) * (wcslen(__eval__) + 1)), __eval__);})
d3372da9	52	#define sstrdup(str) ((char *)strcpy(smalloc(strlen(str) + 1), (str)))
8b17e919	53	#else
	54	#define LOGOOM(size)
	55	#define smalloc(size) ({void __result__; ((__result__ = malloc(size)) == NULL)?({exit(-1); (void )0;}):__result__;})
	56	#define srealloc(ptr, size) ({void __result__; ((__result__ = realloc((ptr), (size))) == NULL)?({exit(-1); (void )0;}):__result__;})
	57	#define swcsdup(wcs) ((wchar_t )wcscpy(smalloc(sizeof(wchar_t) (wcslen(wcs) + 1)), (wcs)))
	58	#define sstrdup(str) ((char *)strcpy(smalloc(strlen(str) + 1), (str)))
	59	#endif
d3372da9	60
	61	#define CBCHAIN(name, args...) \
	62	struct cbchain_ ## name { \
	63	struct cbchain_ ## name next, prev; \
	64	int (func)(args, void data); \
	65	void (destroy)(void data); \
	66	void *data; \
	67	} * name
	68
	69	#define GCBCHAIN(name, args...) \
	70	struct cbchain_ ## name * name = NULL
	71
	72	#define EGCBCHAIN(name, args...) \
	73	extern struct cbchain_ ## name { \
	74	struct cbchain_ ## name next, prev; \
	75	int (func)(args, void data); \
	76	void *data; \
	77	} * name
	78
d3372da9	79	char vsprintf2(char format, va_list al);
d3372da9	80	char sprintf2(char format, ...)
735f4b1a	81	#if defined(__GNUC__)
d3372da9	82	__attribute__ ((format (printf, 1, 2)))
d3372da9	83	#endif
d3372da9	84	;
	85	wchar_t vswprintf2(wchar_t format, va_list al);
	86	wchar_t swprintf2(wchar_t format, ...);
6a3ef546	87	int havecharset(char *charset);
d3372da9	88	wchar_t icmbstowcs(char mbs, char *charset);
	89	wchar_t icsmbstowcs(char mbs, char charset, wchar_t def);
	90	char icwcstombs(wchar_t wcs, char *charset);
	91	char icswcstombs(wchar_t wcs, char charset, char def);
	92	wchar_t wcstolower(wchar_t wcs);
	93	wchar_t ucptowc(int ucp);
	94	void _sizebuf(void *buf, size_t bufsize, size_t reqsize, size_t elsize, int algo);
	95	double ntime(void);
	96	int wcsexists(wchar_t h, wchar_t n);
	97	#ifndef HAVE_WCSCASECMP
	98	int wcscasecmp(const wchar_t s1, const wchar_t s2);
	99	#endif
	100	char hexencode(char data, size_t datalen);
	101	char hexdecode(char data, size_t *len);
	102	char base64encode(char data, size_t datalen);
	103	char base64decode(char data, size_t *datalen);
	104	char base32encode(char data, size_t datalen);
	105	char base32decode(char data, size_t *datalen);
	106	void _freeparr(void **arr);
	107	int _parrlen(void **arr);
7a83517c	108	char findfile(char name, char *homedir, int filldef);
ba087e49 FT	109	struct strpair newstrpair(char key, char val, struct strpair *list);
	110	void freestrpair(struct strpair pair, struct strpair *list);
	111	char spfind(struct strpair list, char *key);
9ec790e8	112	struct wcspair newwcspair(wchar_t key, wchar_t val, struct wcspair *list);
9ec790e8	113	void freewcspair(struct wcspair pair, struct wcspair *list);
14a9e5fd	114	wchar_t wpfind(struct wcspair list, wchar_t *key);
ffb8ed40 FT	115	int bbtreedel(struct btree *tree, void item, int (cmp)(void , void *));
	116	int bbtreeput(struct btree *tree, void item, int (cmp)(void , void *));
	117	void btreeget(struct btree tree, void key, int (cmp)(void , void ));
d3372da9	118
e0cbc756 FT	119	#define sizebuf(b, bs, rs, es, a) _sizebuf((void *)(void )(b), (bs), (rs), (es), (a))
e0cbc756 FT	120	#define sizebuf2(b, rs, a) _sizebuf((void *)(void )(&(b)), &(b ## size), (rs), sizeof(*(b)), (a))
d3372da9	121	#define addtobuf(b, c) \
d3372da9	122	do { \
e0cbc756	123	_sizebuf((void *)(void )(&(b)), &(b ## size), (b ## data) + 1, sizeof(*(b)), 1); \
d3372da9	124	(b)[(b ## data)++] = (c); \
	125	} while(0)
	126	#define bufcat(d, s, n) \
	127	do { \
	128	size_t __bufcat_size__; \
	129	__bufcat_size__ = (n); \
e0cbc756	130	_sizebuf((void *)(void )(&(d)), &(d ## size), (d ## data) + __bufcat_size__, sizeof(*(d)), 1); \
d3372da9	131	memcpy((d) + (d ## data), (s), sizeof((d)) __bufcat_size__); \
	132	(d ## data) += __bufcat_size__; \
	133	} while (0)
c660fffa FT	134	#define bprintf(b, fmt...) \
	135	do { \
	136	char *__bprintf_dest__; \
	137	__bprintf_dest__ = sprintf2(fmt); \
	138	bufcat(b, __bprintf_dest__, strlen(__bprintf_dest__)); \
	139	free(__bprintf_dest__); \
	140	} while(0)
d3372da9	141
	142	#define freeparr(parr) _freeparr((void **)(parr))
	143	#define parrlen(parr) _parrlen((void **)(parr))
	144
	145	#define CBREG(obj, name, funca, destroya, dataa) \
	146	do { \
	147	struct cbchain_ ## name *__new_cb__; \
	148	__new_cb__ = smalloc(sizeof(*__new_cb__)); \
	149	__new_cb__->func = funca; \
	150	__new_cb__->destroy = destroya; \
	151	__new_cb__->data = dataa; \
	152	__new_cb__->prev = NULL; \
	153	__new_cb__->next = (obj)->name; \
5c851d43	154	if((obj)->name != NULL) { \
	155	(obj)->name->prev = __new_cb__; \
	156	} \
d3372da9	157	(obj)->name = __new_cb__; \
	158	} while(0)
	159
cab0b442	160	#define CBUNREG(obj, name, dataa) \
cab0b442	161	do { \
d3372da9	162	struct cbchain_ ## name *__cur__; \
d3372da9	163	for(__cur__ = (obj)->name; __cur__ != NULL; __cur__ = __cur__->next) { \
cab0b442	164	if(__cur__->data == (dataa)) { \
d3372da9	165	if(__cur__->destroy != NULL) \
	166	__cur__->destroy(__cur__->data); \
	167	if(__cur__->prev != NULL) \
	168	__cur__->prev->next = __cur__->next; \
	169	if(__cur__->next != NULL) \
	170	__cur__->next->prev = __cur__->prev; \
	171	if(__cur__ == (obj)->name) \
	172	(obj)->name = __cur__->next; \
	173	free(__cur__); \
	174	break; \
	175	} \
	176	} \
cab0b442	177	} while(0)
d3372da9	178
	179	#define GCBREG(name, funca, dataa) \
	180	do { \
	181	struct cbchain_ ## name *__new_cb__; \
	182	__new_cb__ = smalloc(sizeof(*__new_cb__)); \
	183	__new_cb__->func = funca; \
	184	__new_cb__->data = dataa; \
	185	__new_cb__->prev = NULL; \
	186	__new_cb__->next = name; \
5c851d43	187	if(name != NULL) { \
	188	name->prev = __new_cb__; \
	189	} \
d3372da9	190	name = __new_cb__; \
	191	} while(0)
	192
	193	#define CBCHAININIT(obj, name) (obj)->name = NULL
	194
	195	#define CBCHAINFREE(obj, name) \
	196	do { \
	197	struct cbchain_ ## name *__cur__; \
	198	while((__cur__ = (obj)->name) != NULL) { \
	199	(obj)->name = __cur__->next; \
cab0b442	200	if(__cur__->destroy != NULL) \
	201	__cur__->destroy(__cur__->data); \
	202	free(__cur__); \
d3372da9	203	} \
	204	} while(0)
	205
	206	#define CBCHAINDOCB(obj, name, args...) \
	207	do { \
	208	struct cbchain_ ## name __cur__, __next__; \
	209	for(__cur__ = (obj)->name; __cur__ != NULL; __cur__ = __next__) { \
	210	__next__ = __cur__->next; \
cab0b442	211	if(__cur__->func(args, __cur__->data)) { \
d3372da9	212	if(__cur__->next != NULL) \
	213	__cur__->next->prev = __cur__->prev; \
	214	if(__cur__->prev != NULL) \
	215	__cur__->prev->next = __cur__->next; \
	216	if(__cur__ == (obj)->name) \
	217	(obj)->name = __cur__->next; \
	218	free(__cur__); \
	219	} \
	220	} \
	221	} while(0)
	222
	223	#define GCBCHAINDOCB(name, args...) \
	224	({ \
	225	struct cbchain_ ## name *__cur__; \
	226	int __ret__; \
	227	__ret__ = 0; \
	228	for(__cur__ = name; __cur__ != NULL; __cur__ = __cur__->next) { \
	229	if(__cur__->func(args, __cur__->data)) { \
	230	__ret__ = 1; \
	231	break; \
	232	} \
	233	} \
	234	__ret__; \
	235	})
	236
	237	#endif