2 Copyright (C) 2005 Georgia Public Library Service
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
18 inline void* safe_malloc( int size ) {
19 void* ptr = (void*) malloc( size );
21 perror("safe_malloc(): Out of Memory" );
24 memset( ptr, 0, size );
29 char** __global_argv = NULL;
30 int __global_argv_size = 0;
32 int init_proc_title( int argc, char* argv[] ) {
38 int len = strlen( __global_argv[i]);
39 bzero( __global_argv[i++], len );
40 __global_argv_size += len;
43 __global_argv_size -= 2;
47 int set_proc_title( char* format, ... ) {
48 VA_LIST_TO_STRING(format);
49 bzero( *(__global_argv), __global_argv_size );
50 return snprintf( *(__global_argv), __global_argv_size, VA_BUF );
54 /* utility method for profiling */
55 double get_timestamp_millis() {
57 gettimeofday(&tv, NULL);
58 double time = (int)tv.tv_sec + ( ((double)tv.tv_usec / 1000000) );
63 /* setting/clearing file flags */
64 int set_fl( int fd, int flags ) {
68 if( (val = fcntl( fd, F_GETFL, 0) ) < 0 )
73 if( fcntl( fd, F_SETFL, val ) < 0 )
79 int clr_fl( int fd, int flags ) {
83 if( (val = fcntl( fd, F_GETFL, 0) ) < 0 )
88 if( fcntl( fd, F_SETFL, val ) < 0 )
94 long va_list_size(const char* format, va_list args) {
96 len = vsnprintf(NULL, 0, format, args);
103 char* va_list_to_string(const char* format, ...) {
109 va_copy(a_copy, args);
111 va_start(args, format);
112 len = va_list_size(format, args);
117 va_start(a_copy, format);
118 vsnprintf(buf, len - 1, format, a_copy);
123 // ---------------------------------------------------------------------------------
124 // Flesh out a ubiqitous growing string buffer
125 // ---------------------------------------------------------------------------------
127 growing_buffer* buffer_init(int num_initial_bytes) {
129 if( num_initial_bytes > BUFFER_MAX_SIZE ) return NULL;
131 size_t len = sizeof(growing_buffer);
134 OSRF_MALLOC(gb, len);
136 gb->n_used = 0;/* nothing stored so far */
137 gb->size = num_initial_bytes;
138 OSRF_MALLOC(gb->buf, gb->size + 1);
144 int buffer_fadd(growing_buffer* gb, const char* format, ... ) {
146 if(!gb || !format) return 0;
152 va_copy(a_copy, args);
154 va_start(args, format);
155 len = va_list_size(format, args);
160 va_start(a_copy, format);
161 vsnprintf(buf, len - 1, format, a_copy);
164 return buffer_add(gb, buf);
169 int buffer_add(growing_buffer* gb, char* data) {
170 if(!(gb && data)) return 0;
172 int data_len = strlen( data );
174 if(data_len == 0) return 0;
176 int total_len = data_len + gb->n_used;
178 if( total_len >= gb->size ) {
179 while( total_len >= gb->size ) {
183 if( gb->size > BUFFER_MAX_SIZE ) {
184 fprintf(stderr, "Buffer reached MAX_SIZE of %d", BUFFER_MAX_SIZE );
190 OSRF_MALLOC(new_data, gb->size );
192 strcpy( new_data, gb->buf );
197 strcat( gb->buf, data );
198 gb->n_used = total_len;
203 int buffer_reset( growing_buffer *gb){
204 if( gb == NULL ) { return 0; }
205 if( gb->buf == NULL ) { return 0; }
206 memset( gb->buf, 0, gb->size );
211 /* Return a pointer to the text within a growing_buffer, */
212 /* while destroying the growing_buffer itself. */
214 char* buffer_release( growing_buffer* gb) {
216 s[gb->n_used] = '\0';
221 /* Destroy a growing_buffer and the text it contains */
223 int buffer_free( growing_buffer* gb ) {
231 char* buffer_data( growing_buffer *gb) {
232 return strdup( gb->buf );
237 #define OSRF_BUFFER_ADD_CHAR(gb, c)\
240 if(gb->n_used < gb->size - 1)\
241 gb->buf[gb->n_used++] = c;\
243 buffer_add_char(gb, c);\
248 int buffer_add_char(growing_buffer* gb, char c) {
258 char* uescape( const char* string, int size, int full_escape ) {
260 growing_buffer* buf = buffer_init(size + 64);
263 unsigned long int c = 0x0;
265 while (string[idx]) {
269 if ((unsigned char)string[idx] >= 0x80) { // not ASCII
271 if ((unsigned char)string[idx] >= 0xC0 && (unsigned char)string[idx] <= 0xF4) { // starts a UTF8 string
274 if (((unsigned char)string[idx] & 0xF0) == 0xF0) {
276 c = (unsigned char)string[idx] ^ 0xF0;
278 } else if (((unsigned char)string[idx] & 0xE0) == 0xE0) {
280 c = (unsigned char)string[idx] ^ 0xE0;
282 } else if (((unsigned char)string[idx] & 0xC0) == 0xC0) {
284 c = (unsigned char)string[idx] ^ 0xC0;
289 idx++; // look at the next byte
290 c = (c << 6) | ((unsigned char)string[idx] & 0x3F); // add this byte worth
294 buffer_fadd(buf, "\\u%04x", c);
304 /* escape the usual suspects */
308 OSRF_BUFFER_ADD_CHAR(buf, '\\');
309 OSRF_BUFFER_ADD_CHAR(buf, '"');
313 OSRF_BUFFER_ADD_CHAR(buf, '\\');
314 OSRF_BUFFER_ADD_CHAR(buf, 'b');
318 OSRF_BUFFER_ADD_CHAR(buf, '\\');
319 OSRF_BUFFER_ADD_CHAR(buf, 'f');
323 OSRF_BUFFER_ADD_CHAR(buf, '\\');
324 OSRF_BUFFER_ADD_CHAR(buf, 't');
328 OSRF_BUFFER_ADD_CHAR(buf, '\\');
329 OSRF_BUFFER_ADD_CHAR(buf, 'n');
333 OSRF_BUFFER_ADD_CHAR(buf, '\\');
334 OSRF_BUFFER_ADD_CHAR(buf, 'r');
338 OSRF_BUFFER_ADD_CHAR(buf, '\\');
339 OSRF_BUFFER_ADD_CHAR(buf, '\\');
343 if( c < 32 ) buffer_fadd(buf, "\\u%04x", c);
344 else OSRF_BUFFER_ADD_CHAR(buf, c);
348 OSRF_BUFFER_ADD_CHAR(buf, c);
355 char* d = buffer_data(buf);
361 // A function to turn a process into a daemon and set it's process name in ps/top
366 perror("Failed to fork!");
369 } else if (f == 0) { // We're in the child now...
373 } else { // We're in the parent...
379 /* Return 1 if the string represents an integer, */
380 /* as recognized by strtol(); Otherwise return 0. */
382 int stringisnum(char* s) {
390 char* file_to_string(const char* filename) {
392 if(!filename) return NULL;
397 growing_buffer* gb = buffer_init(len);
399 FILE* file = fopen(filename, "r");
401 int l = strlen(filename) + 64;
403 snprintf(b,l,"Unable to open file [%s] in file_to_string()", filename);
408 while(fgets(buf, len - 1, file)) {
415 char* data = buffer_data(gb);
421 char* md5sum( char* text, ... ) {
424 unsigned char digest[16];
428 VA_LIST_TO_STRING(text);
431 for ( i=0 ; i != strlen(VA_BUF) ; i++ )
432 MD5_feed (&ctx, VA_BUF[i]);
434 MD5_stop (&ctx, digest);
442 for ( i=0 ; i<16 ; i++ ) {
443 sprintf(buf, "%02x", digest[i]);
444 strcat( final, buf );
447 return strdup(final);
451 int osrfUtilsCheckFileDescriptor( int fd ) {
461 if( select(fd + 1, &tmpset, NULL, NULL, &tv) == -1 ) {
462 if( errno == EBADF ) return -1;