as it turns out, this was actually a problem with the makefile, not the utils.h macro...
[OpenSRF.git] / include / opensrf / utils.h
1 /*
2 Copyright (C) 2005  Georgia Public Library Service 
3 Bill Erickson <highfalutin@gmail.com>
4 Mike Rylander <mrylander@gmail.com>
5
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License
8 as published by the Free Software Foundation; either version 2
9 of the License, or (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 GNU General Public License for more details.
15 */
16
17 #ifndef UTILS_H
18 #define UTILS_H
19
20 #include <stdio.h>
21 #include <stdarg.h>
22 #include <fcntl.h>
23 #include <unistd.h>
24 #include <sys/time.h>
25 #include <sys/stat.h>
26 #include <fcntl.h>
27 #include <sys/types.h>
28 #include <stdlib.h>
29 #include <string.h>
30 //#include <sys/timeb.h>
31
32 #include "md5.h"
33
34 #define OSRF_MALLOC(ptr, size) \
35         do {\
36                 ptr = (void*) malloc( size ); \
37                 if( ptr == NULL ) { \
38                         perror("OSRF_MALLOC(): Out of Memory" );\
39                         exit(99); \
40                 } \
41                 memset( ptr, 0, size );\
42         } while(0)
43
44 #ifdef NDEBUG
45 // The original ... replace with noop once no more errors occur in NDEBUG mode
46 #define osrf_clearbuf( s, n ) memset( s, 0, n )
47 #else
48 #define osrf_clearbuf( s, n ) \
49         do { \
50                 char * clearbuf_temp_s = (s); \
51                 size_t clearbuf_temp_n = (n); \
52                 memset( clearbuf_temp_s, '!', clearbuf_temp_n ); \
53                 clearbuf_temp_s[ clearbuf_temp_n - 1 ] = '\0'; \
54         } while( 0 )
55 #endif
56
57 #define OSRF_BUFFER_ADD(gb, data) \
58         do {\
59                 int __tl; \
60                 if(gb && data) {\
61                         __tl = strlen(data) + gb->n_used;\
62                         if( __tl < gb->size ) {\
63                                 strcat(gb->buf, data);\
64                                 gb->n_used = __tl; \
65                         } else { buffer_add(gb, data); }\
66                 }\
67         } while(0)
68
69 #define OSRF_BUFFER_ADD_CHAR(gb, c)\
70         do {\
71                 if(gb) {\
72                         if(gb->n_used < gb->size - 1)\
73                                 gb->buf[gb->n_used++] = c;\
74                         else\
75                                 buffer_add_char(gb, c);\
76                 }\
77         }while(0)
78
79 #define OSRF_BUFFER_RESET(gb) \
80     memset(gb->buf, 0, gb->size);\
81     gb->n_used = 0;
82
83         
84
85
86 /* turns a va_list into a string */
87 #define VA_LIST_TO_STRING(x) \
88         unsigned long __len = 0;\
89         va_list args; \
90         va_list a_copy;\
91         va_copy(a_copy, args); \
92         va_start(args, x); \
93         __len = vsnprintf(NULL, 0, x, args); \
94         va_end(args); \
95         __len += 2; \
96         char _b[__len]; \
97         bzero(_b, __len); \
98         va_start(a_copy, x); \
99         vsnprintf(_b, __len - 1, x, a_copy); \
100         va_end(a_copy); \
101         char* VA_BUF = _b; \
102
103 /* turns a long into a string */
104 #define LONG_TO_STRING(l) \
105         unsigned int __len = snprintf(NULL, 0, "%ld", l) + 2;\
106         char __b[__len]; \
107         bzero(__b, __len); \
108         snprintf(__b, __len - 1, "%ld", l); \
109         char* LONGSTR = __b;
110
111 #define DOUBLE_TO_STRING(l) \
112         unsigned int __len = snprintf(NULL, 0, "%f", l) + 2; \
113         char __b[__len]; \
114         bzero(__b, __len); \
115         snprintf(__b, __len - 1, "%f", l); \
116         char* DOUBLESTR = __b;
117
118 #define LONG_DOUBLE_TO_STRING(l) \
119         unsigned int __len = snprintf(NULL, 0, "%Lf", l) + 2; \
120         char __b[__len]; \
121         bzero(__b, __len); \
122         snprintf(__b, __len - 1, "%Lf", l); \
123         char* LONGDOUBLESTR = __b;
124
125
126 #define INT_TO_STRING(l) \
127         unsigned int __len = snprintf(NULL, 0, "%d", l) + 2; \
128         char __b[__len]; \
129         bzero(__b, __len); \
130         snprintf(__b, __len - 1, "%d", l); \
131         char* INTSTR = __b;
132
133
134 /*
135 #define MD5SUM(s) \
136         struct md5_ctx ctx; \
137         unsigned char digest[16];\
138         MD5_start (&ctx);\
139         int i;\
140         for ( i=0 ; i != strlen(text) ; i++ ) MD5_feed (&ctx, text[i]);\
141         MD5_stop (&ctx, digest);\
142         char buf[16];\
143         memset(buf,0,16);\
144         char final[256];\
145         memset(final,0,256);\
146         for ( i=0 ; i<16 ; i++ ) {\
147                 sprintf(buf, "%02x", digest[i]);\
148                 strcat( final, buf );\
149         }\
150         char* MD5STR = final;
151         */
152
153
154         
155
156
157 #define BUFFER_MAX_SIZE 10485760 
158
159 /* these are evil and should be condemned 
160         ! Only use these if you are done with argv[].
161         call init_proc_title() first, then call
162         set_proc_title. 
163         the title is only allowed to be as big as the
164         initial process name of the process (full size of argv[]).
165         truncation may occurr.
166  */
167 int init_proc_title( int argc, char* argv[] );
168 int set_proc_title( const char* format, ... );
169
170
171 int daemonize( void );
172
173 void* safe_malloc(int size);
174 void* safe_calloc(int size);
175
176 // ---------------------------------------------------------------------------------
177 // Generic growing buffer. Add data all you want
178 // ---------------------------------------------------------------------------------
179 struct growing_buffer_struct {
180         char *buf;
181         int n_used;
182         int size;
183 };
184 typedef struct growing_buffer_struct growing_buffer;
185
186 growing_buffer* buffer_init( int initial_num_bytes);
187
188 // XXX This isn't defined in utils.c!! removing for now...
189 //int buffer_addchar(growing_buffer* gb, char c);
190
191 int buffer_add(growing_buffer* gb, const char* c);
192 int buffer_fadd(growing_buffer* gb, const char* format, ... );
193 int buffer_reset( growing_buffer* gb);
194 char* buffer_data( const growing_buffer* gb);
195 char* buffer_release( growing_buffer* gb );
196 int buffer_free( growing_buffer* gb );
197 int buffer_add_char(growing_buffer* gb, char c);
198
199 /* returns the size needed to fill in the vsnprintf buffer.  
200         * ! this calls va_end on the va_list argument*
201         */
202 long va_list_size(const char* format, va_list);
203
204 /* turns a va list into a string, caller must free the 
205         allocated char */
206 char* va_list_to_string(const char* format, ...);
207
208
209 /* string escape utility method.  escapes unicode embeded characters.
210         escapes the usual \n, \t, etc. 
211         for example, if you provide a string like so:
212
213         hello,
214                 you
215
216         you would get back:
217         hello,\n\tyou
218  
219  */
220 char* uescape( const char* string, int size, int full_escape );
221
222 /* utility methods */
223 int set_fl( int fd, int flags );
224 int clr_fl( int fd, int flags );
225
226
227
228 // Utility method
229 double get_timestamp_millis( void );
230
231
232 /* returns true if the whole string is a number */
233 int stringisnum(const char* s);
234
235 /* reads a file and returns the string version of the file
236         user is responsible for freeing the returned char*
237         */
238 char* file_to_string(const char* filename);
239
240
241
242 /** 
243   Calculates the md5 of the text provided.
244   The returned string must be freed by the caller.
245   */
246 char* md5sum( const char* text, ... );
247
248
249 /**
250   Checks the validity of the file descriptor
251   returns -1 if the file descriptor is invalid
252   returns 0 if the descriptor is OK
253   */
254 int osrfUtilsCheckFileDescriptor( int fd );
255
256 #endif