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