added some log statements, fixed some typos
[Evergreen.git] / OpenSRF / 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 = (growing_buffer*) safe_malloc(len);
142
143         gb->n_used = 0;/* nothing stored so far */
144         gb->size = num_initial_bytes;
145         gb->buf = (char *) safe_malloc(gb->size + 1);
146
147         return gb;
148 }
149
150
151 int buffer_fadd(growing_buffer* gb, const char* format, ... ) {
152
153         if(!gb || !format) return 0; 
154
155         long len = 0;
156         va_list args;
157         va_list a_copy;
158
159         va_copy(a_copy, args);
160
161         va_start(args, format);
162         len = va_list_size(format, args);
163
164         char buf[len];
165         memset(buf, 0, len);
166
167         va_start(a_copy, format);
168         vsnprintf(buf, len - 1, format, a_copy);
169         va_end(a_copy);
170
171         return buffer_add(gb, buf);
172
173 }
174
175 int buffer_add(growing_buffer* gb, char* data) {
176
177
178         if( ! gb || ! data  ) { return 0; }
179         int data_len = strlen( data );
180
181         if( data_len == 0 ) { return 0; }
182         int total_len = data_len + gb->n_used;
183
184         while( total_len >= gb->size ) {
185                 gb->size *= 2;
186         }
187
188         if( gb->size > BUFFER_MAX_SIZE ) {
189                 fprintf(stderr, "Buffer reached MAX_SIZE of %d", BUFFER_MAX_SIZE );
190                 buffer_free( gb );
191                 return 0;
192         }
193
194         char* new_data = (char*) safe_malloc( gb->size );
195
196         strcpy( new_data, gb->buf );
197         free( gb->buf );
198         gb->buf = new_data;
199
200         strcat( gb->buf, data );
201         gb->n_used = total_len;
202         return total_len;
203 }
204
205
206 int buffer_reset( growing_buffer *gb){
207         if( gb == NULL ) { return 0; }
208         if( gb->buf == NULL ) { return 0; }
209         memset( gb->buf, 0, gb->size );
210         gb->n_used = 0;
211         return 1;
212 }
213
214 int buffer_free( growing_buffer* gb ) {
215         if( gb == NULL ) 
216                 return 0;
217         free( gb->buf );
218         free( gb );
219         return 1;
220 }
221
222 char* buffer_data( growing_buffer *gb) {
223         return strdup( gb->buf );
224 }
225
226
227 int buffer_add_char(growing_buffer* gb, char c) {
228         char buf[2];
229         buf[0] = c;
230         buf[1] = '\0';
231         buffer_add(gb, buf);
232         return 1;
233 }
234
235
236
237 char* uescape( const char* string, int size, int full_escape ) {
238
239         growing_buffer* buf = buffer_init(size + 64);
240         int idx = 0;
241         long unsigned int c = 0;
242
243         while (string[idx]) {
244         
245                 c ^= c;
246                 
247                 if ((string[idx] & 0xF0) == 0xF0) {
248                         c = string[idx]<<18;
249
250                         if( size - idx < 4 ) return NULL;
251                         
252                         idx++;
253                         c |= (string[idx] & 0x3F)<<12;
254                         
255                         idx++;
256                         c |= (string[idx] & 0x3F)<<6;
257                         
258                         idx++;
259                         c |= (string[idx] & 0x3F);
260                         
261                         c ^= 0xFF000000;
262                         
263                         buffer_fadd(buf, "\\u%0.4x", c);
264
265                 } else if ((string[idx] & 0xE0) == 0xE0) {
266                         c = string[idx]<<12;
267                         if( size - idx < 3 ) return NULL;
268                         
269                         idx++;
270                         c |= (string[idx] & 0x3F)<<6;
271                         
272                         idx++;
273                         c |= (string[idx] & 0x3F);
274                         
275                         c ^= 0xFFF80000;
276                         
277                         buffer_fadd(buf, "\\u%0.4x", c);
278
279                 } else if ((string[idx] & 0xC0) == 0xC0) {
280                         // Two byte char
281                         c = string[idx]<<6;
282                         if( size - idx < 2 ) return NULL;
283                         
284                         idx++;
285                         c |= (string[idx] & 0x3F);
286                         
287                         c ^= 0xFFFFF000;
288                         
289                         buffer_fadd(buf, "\\u%0.4x", c);
290
291                 } else {
292                         c = string[idx];
293
294                         /* escape the usual suspects */
295                         if(full_escape) {
296                                 switch(c) {
297                                         case '"':
298                                                 buffer_add_char(buf, '\\');
299                                                 buffer_add_char(buf, '"');
300                                                 break;
301         
302                                         case '\b':
303                                                 buffer_add_char(buf, '\\');
304                                                 buffer_add_char(buf, 'b');
305                                                 break;
306         
307                                         case '\f':
308                                                 buffer_add_char(buf, '\\');
309                                                 buffer_add_char(buf, 'f');
310                                                 break;
311         
312                                         case '\t':
313                                                 buffer_add_char(buf, '\\');
314                                                 buffer_add_char(buf, 't');
315                                                 break;
316         
317                                         case '\n':
318                                                 buffer_add_char(buf, '\\');
319                                                 buffer_add_char(buf, 'n');
320                                                 break;
321         
322                                         case '\r':
323                                                 buffer_add_char(buf, '\\');
324                                                 buffer_add_char(buf, 'r');
325                                                 break;
326
327                                         default:
328                                                 buffer_add_char(buf, c);
329                                 }
330
331                         } else {
332                                 buffer_add_char(buf, c);
333                         }
334                 }
335
336                 idx++;
337         }
338
339         char* d = buffer_data(buf);
340         buffer_free(buf);
341         return d;
342 }
343
344
345 // A function to turn a process into a daemon and set it's process name in ps/top
346 int daemonize() {
347         int f = fork();
348
349         if (f == -1) {
350                 perror("Failed to fork!");
351                 return -1;
352
353         } else if (f == 0) { // We're in the child now...
354                 setsid();
355                 return 0;
356
357         } else { // We're in the parent...
358                 exit(0);
359         }
360 }
361
362 int stringisnum(char* s) {
363         char* w = (char*) malloc(strlen(s) * sizeof(char*));
364         bzero(w, strlen(s));
365         strtol(s, &w, 10);
366         if(strlen(w) > 0)  
367                 return 0;
368         return 1;
369 }
370         
371
372
373 char* file_to_string(const char* filename) {
374
375         if(!filename) return NULL;
376
377         int len = 1024;
378         char buf[len];
379         bzero(buf, len);
380         growing_buffer* gb = buffer_init(len);
381
382         FILE* file = fopen(filename, "r");
383         if(!file) {
384                 int l = strlen(filename) + 64;
385                 char b[l];
386                 snprintf(b,l,"Unable to open file [%s] in file_to_string()", filename);
387                 perror(b);
388                 return NULL;
389         }
390
391         while(fgets(buf, len - 1, file)) {
392                 buffer_add(gb, buf);
393                 bzero(buf, len);
394         }
395
396         fclose(file);
397
398         char* data = buffer_data(gb);
399         buffer_free(gb);
400         return data;
401 }
402
403
404 char* md5sum( char* text, ... ) {
405
406         struct md5_ctx ctx;
407         unsigned char digest[16];
408
409         MD5_start (&ctx);
410
411         VA_LIST_TO_STRING(text);
412
413         int i;
414         for ( i=0 ; i != strlen(VA_BUF) ; i++ )
415                 MD5_feed (&ctx, VA_BUF[i]);
416
417         MD5_stop (&ctx, digest);
418
419         char buf[16];
420         memset(buf,0,16);
421
422         char final[256];
423         memset(final,0,256);
424
425         for ( i=0 ; i<16 ; i++ ) {
426                 sprintf(buf, "%02x", digest[i]);
427                 strcat( final, buf );
428         }
429
430         return strdup(final);
431
432 }
433
434 int osrfUtilsCheckFileDescriptor( int fd ) {
435
436         fd_set tmpset;
437         FD_ZERO(&tmpset);
438         FD_SET(fd, &tmpset);
439
440         struct timeval tv;
441         tv.tv_sec = 0;
442         tv.tv_usec = 0;
443
444         if( select(fd + 1, &tmpset, NULL, NULL, &tv) == -1 ) {
445                 if( errno == EBADF ) return -1;
446         }
447
448         return 0;
449 }
450