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                 perror("Unable to open file in json_parse_file()");
 385                 return NULL;
 386         }
 387
 388         while(fgets(buf, len - 1, file)) {
 389                 buffer_add(gb, buf);
 390                 bzero(buf, len);
 391         }
 392
 393         fclose(file);
 394
 395         char* data = buffer_data(gb);
 396         buffer_free(gb);
 397         return data;
 398 }
 399
 400
 401 char* md5sum( char* text, ... ) {
 402
 403         struct md5_ctx ctx;
 404         unsigned char digest[16];
 405
 406         MD5_start (&ctx);
 407
 408         VA_LIST_TO_STRING(text);
 409
 410         int i;
 411         for ( i=0 ; i != strlen(VA_BUF) ; i++ )
 412                 MD5_feed (&ctx, VA_BUF[i]);
 413
 414         MD5_stop (&ctx, digest);
 415
 416         char buf[16];
 417         memset(buf,0,16);
 418
 419         char final[256];
 420         memset(final,0,256);
 421
 422         for ( i=0 ; i<16 ; i++ ) {
 423                 sprintf(buf, "%02x", digest[i]);
 424                 strcat( final, buf );
 425         }
 426
 427         return strdup(final);
 428
 429 }
 430
 431 int osrfUtilsCheckFileDescriptor( int fd ) {
 432
 433         fd_set tmpset;
 434         FD_ZERO(&tmpset);
 435         FD_SET(fd, &tmpset);
 436
 437         struct timeval tv;
 438         tv.tv_sec = 0;
 439         tv.tv_usec = 0;
 440
 441         if( select(fd + 1, &tmpset, NULL, NULL, &tv) == -1 ) {
 442                 if( errno == EBADF ) return -1;
 443         }
 444
 445         return 0;
 446 }
 447