new unicode stuff compiles now
[OpenSRF.git] / src / utils / utils.c
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 #include "utils.h"
18 #include <errno.h>
19
20 inline void* safe_malloc( int size ) {
21         void* ptr = (void*) malloc( size );
22         if( ptr == NULL ) {
23                 perror("safe_malloc(): Out of Memory" );
24                 exit(99);
25         }
26         memset( ptr, 0, size );
27         return ptr;
28 }
29
30
31 char** __global_argv = NULL;
32 int __global_argv_size = 0;
33
34 int init_proc_title( int argc, char* argv[] ) {
35
36         __global_argv = argv;
37
38         int i = 0;
39         while( i < argc ) {
40                 int len = strlen( __global_argv[i]);
41                 bzero( __global_argv[i++], len );
42                 __global_argv_size += len;
43         }
44
45         __global_argv_size -= 2;
46         return 0;
47 }
48
49 int set_proc_title( char* format, ... ) {
50         VA_LIST_TO_STRING(format);
51         bzero( *(__global_argv), __global_argv_size );
52         return snprintf( *(__global_argv), __global_argv_size, VA_BUF );
53 }
54
55
56 /* utility method for profiling */
57 double get_timestamp_millis() {
58         struct timeval tv;
59         gettimeofday(&tv, NULL);
60         double time     = (int)tv.tv_sec        + ( ((double)tv.tv_usec / 1000000) );
61         return time;
62 }
63
64
65 /* setting/clearing file flags */
66 int set_fl( int fd, int flags ) {
67         
68         int val;
69
70         if( (val = fcntl( fd, F_GETFL, 0) ) < 0 ) {
71                 fprintf(stderr, "fcntl F_GETFL error");
72                 return -1;
73         }
74
75         val |= flags;
76
77         if( fcntl( fd, F_SETFL, val ) < 0 ) {
78                 fprintf(stderr, "fcntl F_SETFL error");
79                 return -1;
80         }
81         return 0;
82 }
83         
84 int clr_fl( int fd, int flags ) {
85         
86         int val;
87
88         if( (val = fcntl( fd, F_GETFL, 0) ) < 0 ) {
89                 fprintf(stderr, "fcntl F_GETFL error" );
90                 return -1;
91         }
92
93         val &= ~flags;
94
95         if( fcntl( fd, F_SETFL, val ) < 0 ) {
96                 fprintf( stderr, "fcntl F_SETFL error" );
97                 return -1;
98         }
99         return 0;
100 }
101
102 long va_list_size(const char* format, va_list args) {
103         int len = 0;
104         len = vsnprintf(NULL, 0, format, args);
105         va_end(args);
106         len += 2;
107         return len;
108 }
109
110
111 char* va_list_to_string(const char* format, ...) {
112
113         long len = 0;
114         va_list args;
115         va_list a_copy;
116
117         va_copy(a_copy, args);
118
119         va_start(args, format);
120         len = va_list_size(format, args);
121
122         char buf[len];
123         memset(buf, 0, len);
124
125         va_start(a_copy, format);
126         vsnprintf(buf, len - 1, format, a_copy);
127         va_end(a_copy);
128         return strdup(buf);
129 }
130
131 // ---------------------------------------------------------------------------------
132 // Flesh out a ubiqitous growing string buffer
133 // ---------------------------------------------------------------------------------
134
135 growing_buffer* buffer_init(int num_initial_bytes) {
136
137         if( num_initial_bytes > BUFFER_MAX_SIZE ) return NULL;
138
139         size_t len = sizeof(growing_buffer);
140
141         growing_buffer* gb;
142         OSRF_MALLOC(gb, len);
143
144         gb->n_used = 0;/* nothing stored so far */
145         gb->size = num_initial_bytes;
146         OSRF_MALLOC(gb->buf, gb->size + 1);
147
148         return gb;
149 }
150
151
152 int buffer_fadd(growing_buffer* gb, const char* format, ... ) {
153
154         if(!gb || !format) return 0; 
155
156         long len = 0;
157         va_list args;
158         va_list a_copy;
159
160         va_copy(a_copy, args);
161
162         va_start(args, format);
163         len = va_list_size(format, args);
164
165         char buf[len];
166         memset(buf, 0, len);
167
168         va_start(a_copy, format);
169         vsnprintf(buf, len - 1, format, a_copy);
170         va_end(a_copy);
171
172         return buffer_add(gb, buf);
173
174 }
175
176
177 int buffer_add(growing_buffer* gb, char* data) {
178         if(!(gb && data)) return 0;
179
180         int data_len = strlen( data );
181
182         if(data_len == 0) return 0;
183
184         int total_len = data_len + gb->n_used;
185
186         if( total_len >= gb->size ) {
187                 while( total_len >= gb->size ) {
188                         gb->size *= 2;
189                 }
190         
191                 if( gb->size > BUFFER_MAX_SIZE ) {
192                         fprintf(stderr, "Buffer reached MAX_SIZE of %d", BUFFER_MAX_SIZE );
193                         buffer_free( gb );
194                         return 0;
195                 }
196         
197                 char* new_data;
198                 OSRF_MALLOC(new_data, gb->size );
199         
200                 strcpy( new_data, gb->buf );
201                 free( gb->buf );
202                 gb->buf = new_data;
203         }
204
205         strcat( gb->buf, data );
206         gb->n_used = total_len;
207         return total_len;
208 }
209
210
211 int buffer_reset( growing_buffer *gb){
212         if( gb == NULL ) { return 0; }
213         if( gb->buf == NULL ) { return 0; }
214         memset( gb->buf, 0, gb->size );
215         gb->n_used = 0;
216         return 1;
217 }
218
219 int buffer_free( growing_buffer* gb ) {
220         if( gb == NULL ) 
221                 return 0;
222         free( gb->buf );
223         free( gb );
224         return 1;
225 }
226
227 char* buffer_data( growing_buffer *gb) {
228         return strdup( gb->buf );
229 }
230
231
232 /*
233 #define OSRF_BUFFER_ADD_CHAR(gb, c)\
234         do {\
235                 if(gb) {\
236                         if(gb->n_used < gb->size - 1)\
237                                 gb->buf[gb->n_used++] = c;\
238                         else\
239                                 buffer_add_char(gb, c);\
240                 }\
241         }while(0)
242         */
243
244 int buffer_add_char(growing_buffer* gb, char c) {
245         char buf[2];
246         buf[0] = c;
247         buf[1] = '\0';
248         buffer_add(gb, buf);
249         return 1;
250 }
251
252
253
254 char* uescape( const char* string, int size, int full_escape ) {
255
256         growing_buffer* buf = buffer_init(size + 64);
257         int idx = 0;
258         long unsigned int c = 0;
259
260         while (string[idx]) {
261
262                 c ^= c;
263
264                 if (!OSRF_UTF8_IS_ASCII((char)string[idx])) {
265                         if (OSRF_UTF8_IS_START((char)string[idx])) {
266                                 do {
267                                         c = OSRF_UTF8_ACCUMULATE(c, string[idx]);
268                                 } while (OSRF_UTF8_IS_CONTINUATION(string[idx + 1] && idx++));
269                                 buffer_fadd(buf, "\\u%0.4x", c);
270                         } else return NULL;
271                 } else {
272                         c = string[idx];
273
274                         /* escape the usual suspects */
275                         if(full_escape) {
276                                 switch(c) {
277                                         case '"':
278                                                 OSRF_BUFFER_ADD_CHAR(buf, '\\');
279                                                 OSRF_BUFFER_ADD_CHAR(buf, '"');
280                                                 break;
281         
282                                         case '\b':
283                                                 OSRF_BUFFER_ADD_CHAR(buf, '\\');
284                                                 OSRF_BUFFER_ADD_CHAR(buf, 'b');
285                                                 break;
286         
287                                         case '\f':
288                                                 OSRF_BUFFER_ADD_CHAR(buf, '\\');
289                                                 OSRF_BUFFER_ADD_CHAR(buf, 'f');
290                                                 break;
291         
292                                         case '\t':
293                                                 OSRF_BUFFER_ADD_CHAR(buf, '\\');
294                                                 OSRF_BUFFER_ADD_CHAR(buf, 't');
295                                                 break;
296         
297                                         case '\n':
298                                                 OSRF_BUFFER_ADD_CHAR(buf, '\\');
299                                                 OSRF_BUFFER_ADD_CHAR(buf, 'n');
300                                                 break;
301         
302                                         case '\r':
303                                                 OSRF_BUFFER_ADD_CHAR(buf, '\\');
304                                                 OSRF_BUFFER_ADD_CHAR(buf, 'r');
305                                                 break;
306
307                                         case '\\':
308                                                 OSRF_BUFFER_ADD_CHAR(buf, '\\');
309                                                 OSRF_BUFFER_ADD_CHAR(buf, '\\');
310                                                 break;
311
312                                         case 30: /* record separator */
313                                                 OSRF_BUFFER_ADD(buf, "\\u001E");
314                                                 break;
315
316                                         case 1: /* record separator */
317                                                 OSRF_BUFFER_ADD(buf, "\\u0001");
318                                                 break;
319
320
321                                         default:
322                                                 OSRF_BUFFER_ADD_CHAR(buf, c);
323                                 }
324
325                         } else {
326                                 OSRF_BUFFER_ADD_CHAR(buf, c);
327                         }
328                 }
329
330                 idx++;
331         }
332
333         char* d = buffer_data(buf);
334         buffer_free(buf);
335         return d;
336 }
337
338
339 // A function to turn a process into a daemon and set it's process name in ps/top
340 int daemonize() {
341         int f = fork();
342
343         if (f == -1) {
344                 perror("Failed to fork!");
345                 return -1;
346
347         } else if (f == 0) { // We're in the child now...
348                 setsid();
349                 return 0;
350
351         } else { // We're in the parent...
352                 exit(0);
353         }
354 }
355
356 int stringisnum(char* s) {
357         char* w = (char*) malloc(strlen(s) * sizeof(char*));
358         bzero(w, strlen(s));
359         strtol(s, &w, 10);
360         if(strlen(w) > 0)  
361                 return 0;
362         return 1;
363 }
364         
365
366
367 char* file_to_string(const char* filename) {
368
369         if(!filename) return NULL;
370
371         int len = 1024;
372         char buf[len];
373         bzero(buf, len);
374         growing_buffer* gb = buffer_init(len);
375
376         FILE* file = fopen(filename, "r");
377         if(!file) {
378                 int l = strlen(filename) + 64;
379                 char b[l];
380                 snprintf(b,l,"Unable to open file [%s] in file_to_string()", filename);
381                 perror(b);
382                 return NULL;
383         }
384
385         while(fgets(buf, len - 1, file)) {
386                 buffer_add(gb, buf);
387                 bzero(buf, len);
388         }
389
390         fclose(file);
391
392         char* data = buffer_data(gb);
393         buffer_free(gb);
394         return data;
395 }
396
397
398 char* md5sum( char* text, ... ) {
399
400         struct md5_ctx ctx;
401         unsigned char digest[16];
402
403         MD5_start (&ctx);
404
405         VA_LIST_TO_STRING(text);
406
407         int i;
408         for ( i=0 ; i != strlen(VA_BUF) ; i++ )
409                 MD5_feed (&ctx, VA_BUF[i]);
410
411         MD5_stop (&ctx, digest);
412
413         char buf[16];
414         memset(buf,0,16);
415
416         char final[256];
417         memset(final,0,256);
418
419         for ( i=0 ; i<16 ; i++ ) {
420                 sprintf(buf, "%02x", digest[i]);
421                 strcat( final, buf );
422         }
423
424         return strdup(final);
425
426 }
427
428 int osrfUtilsCheckFileDescriptor( int fd ) {
429
430         fd_set tmpset;
431         FD_ZERO(&tmpset);
432         FD_SET(fd, &tmpset);
433
434         struct timeval tv;
435         tv.tv_sec = 0;
436         tv.tv_usec = 0;
437
438         if( select(fd + 1, &tmpset, NULL, NULL, &tv) == -1 ) {
439                 if( errno == EBADF ) return -1;
440         }
441
442         return 0;
443 }
444