src/libopensrf/utils.c

   1 /*
   2 Copyright (C) 2005  Georgia Public Library Service
   3
   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.
   8
   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.
  13 */
  14
  15 #include <opensrf/utils.h>
  16 #include <opensrf/log.h>
  17 #include <errno.h>
  18
  19 static const char hex_chars[]   = "0123456789abcdef";
  20 static unsigned char hex_code[7] = "\\u00";
  21
  22 inline void* safe_malloc( int size ) {
  23         void* ptr = (void*) malloc( size );
  24         if( ptr == NULL ) {
  25                 osrfLogError( OSRF_LOG_MARK, "Out of Memory" );
  26                 exit(99);
  27         }
  28         memset( ptr, 0, size ); // remove this after safe_calloc transition
  29         return ptr;
  30 }
  31
  32 inline void* safe_calloc( int size ) {
  33         void* ptr = (void*) calloc( 1, size );
  34         if( ptr == NULL ) {
  35                 osrfLogError( OSRF_LOG_MARK, "Out of Memory" );
  36                 exit(99);
  37         }
  38         return ptr;
  39 }
  40
  41 /****************
  42  The following static variables, and the following two functions,
  43  overwrite the argv array passed to main().  The purpose is to
  44  change the program name as reported by ps and similar utilities.
  45
  46  Warning: this code makes the non-portable assumption that the
  47  strings to which argv[] points are contiguous in memory.  The
  48  C Standard makes no such guarantee.
  49  ****************/
  50 static char** global_argv = NULL;
  51 static int global_argv_size = 0;
  52
  53 int init_proc_title( int argc, char* argv[] ) {
  54
  55         global_argv = argv;
  56
  57         int i = 0;
  58         while( i < argc ) {
  59                 int len = strlen( global_argv[i]);
  60                 osrf_clearbuf( global_argv[i], len );
  61                 global_argv_size += len;
  62                 i++;
  63         }
  64
  65         global_argv_size -= 2;
  66         return 0;
  67 }
  68
  69 int set_proc_title( const char* format, ... ) {
  70         VA_LIST_TO_STRING(format);
  71         osrf_clearbuf( *(global_argv), global_argv_size);
  72         return snprintf( *(global_argv), global_argv_size, VA_BUF );
  73 }
  74
  75
  76 /* utility method for profiling */
  77 double get_timestamp_millis( void ) {
  78         struct timeval tv;
  79         gettimeofday(&tv, NULL);
  80         double time     = (int)tv.tv_sec        + ( ((double)tv.tv_usec / 1000000) );
  81         return time;
  82 }
  83
  84
  85 /* setting/clearing file flags */
  86 int set_fl( int fd, int flags ) {
  87
  88         int val;
  89
  90         if( (val = fcntl( fd, F_GETFL, 0) ) < 0 )
  91                 return -1;
  92
  93         val |= flags;
  94
  95         if( fcntl( fd, F_SETFL, val ) < 0 )
  96                 return -1;
  97
  98         return 0;
  99 }
 100
 101 int clr_fl( int fd, int flags ) {
 102
 103         int val;
 104
 105         if( (val = fcntl( fd, F_GETFL, 0) ) < 0 )
 106                 return -1;
 107
 108         val &= ~flags;
 109
 110         if( fcntl( fd, F_SETFL, val ) < 0 )
 111                 return -1;
 112
 113         return 0;
 114 }
 115
 116 long va_list_size(const char* format, va_list args) {
 117         int len = 0;
 118         len = vsnprintf(NULL, 0, format, args);
 119         va_end(args);
 120         len += 2;
 121         return len;
 122 }
 123
 124
 125 char* va_list_to_string(const char* format, ...) {
 126
 127         long len = 0;
 128         va_list args;
 129         va_list a_copy;
 130
 131         va_copy(a_copy, args);
 132
 133         va_start(args, format);
 134         len = va_list_size(format, args);
 135
 136         char buf[len];
 137         osrf_clearbuf(buf, sizeof(buf));
 138
 139         va_start(a_copy, format);
 140         vsnprintf(buf, len - 1, format, a_copy);
 141         va_end(a_copy);
 142         return strdup(buf);
 143 }
 144
 145 // ---------------------------------------------------------------------------------
 146 // Flesh out a ubiqitous growing string buffer
 147 // ---------------------------------------------------------------------------------
 148
 149 growing_buffer* buffer_init(int num_initial_bytes) {
 150
 151         if( num_initial_bytes > BUFFER_MAX_SIZE ) return NULL;
 152
 153         size_t len = sizeof(growing_buffer);
 154
 155         growing_buffer* gb;
 156         OSRF_MALLOC(gb, len);
 157
 158         gb->n_used = 0;/* nothing stored so far */
 159         gb->size = num_initial_bytes;
 160         OSRF_MALLOC(gb->buf, gb->size + 1);
 161
 162         return gb;
 163 }
 164
 165
 166 /* Expand the internal buffer of a growing_buffer so that it */
 167 /* will accommodate a specified string length.  Return 0 if  */
 168 /* successful, or 1 otherwise. */
 169
 170 /* Note that we do not check to see if the buffer is already */
 171 /* big enough.  It is the responsibility of the calling      */
 172 /* function to call this only when necessary. */
 173
 174 static int buffer_expand( growing_buffer* gb, size_t total_len ) {
 175
 176         // Make sure the request is not excessive
 177
 178         if( total_len >= BUFFER_MAX_SIZE ) {
 179                 fprintf(stderr, "Buffer reached MAX_SIZE of %lu",
 180                                 (unsigned long) BUFFER_MAX_SIZE );
 181                 buffer_free( gb );
 182                 return 1;
 183         }
 184
 185         // Pick a big enough buffer size, but don't exceed a maximum
 186
 187         while( total_len >= gb->size ) {
 188                 gb->size *= 2;
 189         }
 190
 191         if( gb->size > BUFFER_MAX_SIZE )
 192                 gb->size = BUFFER_MAX_SIZE;
 193
 194         // Allocate and populate the new buffer
 195
 196         char* new_data;
 197         OSRF_MALLOC( new_data, gb->size );
 198         memcpy( new_data, gb->buf, gb->n_used );
 199         new_data[ gb->n_used ] = '\0';
 200
 201         // Replace the old buffer
 202
 203         free( gb->buf );
 204         gb->buf = new_data;
 205         return 0;
 206 }
 207
 208
 209 int buffer_fadd(growing_buffer* gb, const char* format, ... ) {
 210
 211         if(!gb || !format) return 0;
 212
 213         long len = 0;
 214         va_list args;
 215         va_list a_copy;
 216
 217         va_copy(a_copy, args);
 218
 219         va_start(args, format);
 220         len = va_list_size(format, args);
 221
 222         char buf[len];
 223         osrf_clearbuf(buf, sizeof(buf));
 224
 225         va_start(a_copy, format);
 226         vsnprintf(buf, len - 1, format, a_copy);
 227         va_end(a_copy);
 228
 229         return buffer_add(gb, buf);
 230
 231 }
 232
 233
 234 int buffer_add(growing_buffer* gb, const char* data) {
 235         if(!(gb && data)) return 0;
 236
 237         int data_len = strlen( data );
 238
 239         if(data_len == 0) return 0;
 240
 241         int total_len = data_len + gb->n_used;
 242
 243         if( total_len >= gb->size ) {
 244                 if( buffer_expand( gb, total_len ) )
 245                         return -1;
 246         }
 247
 248         strcpy( gb->buf + gb->n_used, data );
 249         gb->n_used = total_len;
 250         return total_len;
 251 }
 252
 253
 254 int buffer_reset( growing_buffer *gb){
 255         if( gb == NULL ) { return -1; }
 256         if( gb->buf == NULL ) { return -1; }
 257         osrf_clearbuf( gb->buf, gb->size );
 258         gb->n_used = 0;
 259         gb->buf[ 0 ] = '\0';
 260         return gb->n_used;
 261 }
 262
 263 /* Return a pointer to the text within a growing_buffer, */
 264 /* while destroying the growing_buffer itself.           */
 265
 266 char* buffer_release( growing_buffer* gb) {
 267         char* s = gb->buf;
 268         s[gb->n_used] = '\0';
 269         free( gb );
 270         return s;
 271 }
 272
 273 /* Destroy a growing_buffer and the text it contains */
 274
 275 int buffer_free( growing_buffer* gb ) {
 276         if( gb == NULL )
 277                 return 0;
 278         free( gb->buf );
 279         free( gb );
 280         return 1;
 281 }
 282
 283 char* buffer_data( const growing_buffer *gb) {
 284         return strdup( gb->buf );
 285 }
 286
 287 int buffer_chomp(growing_buffer* gb) {
 288         if( gb == NULL ) { return -1; }
 289     if(gb->n_used > 0) {
 290             gb->n_used--;
 291             gb->buf[gb->n_used] = '\0';
 292     }
 293     return gb->n_used;
 294 }
 295
 296
 297 /*
 298 #define OSRF_BUFFER_ADD_CHAR(gb, c)\
 299         do {\
 300                 if(gb) {\
 301                         if(gb->n_used < gb->size - 1)\
 302                                 gb->buf[gb->n_used++] = c;\
 303                         else\
 304                                 buffer_add_char(gb, c);\
 305                 }\
 306         }while(0)
 307         */
 308
 309 int buffer_add_char(growing_buffer* gb, char c ) {
 310         if(gb && gb->buf) {
 311
 312                 int total_len = gb->n_used + 1;
 313
 314                 if( total_len >= gb->size ) {
 315                         if( buffer_expand( gb, total_len ) )
 316                                 return -1;
 317                 }
 318
 319                 gb->buf[ gb->n_used ]   = c;
 320                 gb->buf[ ++gb->n_used ] = '\0';
 321         }
 322
 323         return gb->n_used;
 324 }
 325
 326
 327 char* uescape( const char* string, int size, int full_escape ) {
 328
 329         if( NULL == string )
 330                 return NULL;
 331
 332         growing_buffer* buf = buffer_init(size + 64);
 333         int clen = 0;
 334         int idx = 0;
 335         unsigned long int c = 0x0;
 336
 337         while (string[idx]) {
 338
 339                 c = 0x0;
 340
 341                 if ((unsigned char)string[idx] >= 0x80) { // not ASCII
 342
 343                         if ((unsigned char)string[idx] >= 0xC0 && (unsigned char)string[idx] <= 0xF4) { // starts a UTF8 string
 344
 345                                 clen = 1;
 346                                 if (((unsigned char)string[idx] & 0xF0) == 0xF0) {
 347                                         clen = 3;
 348                                         c = (unsigned char)string[idx] ^ 0xF0;
 349
 350                                 } else if (((unsigned char)string[idx] & 0xE0) == 0xE0) {
 351                                         clen = 2;
 352                                         c = (unsigned char)string[idx] ^ 0xE0;
 353
 354                                 } else if (((unsigned char)string[idx] & 0xC0) == 0xC0) {
 355                                         clen = 1;
 356                                         c = (unsigned char)string[idx] ^ 0xC0;
 357                                 }
 358
 359                                 for (;clen;clen--) {
 360
 361                                         idx++; // look at the next byte
 362                                         c = (c << 6) | ((unsigned char)string[idx] & 0x3F); // add this byte worth
 363
 364                                 }
 365
 366                                 buffer_fadd(buf, "\\u%04x", c);
 367
 368                         } else {
 369                                 buffer_free(buf);
 370                                 return NULL;
 371                         }
 372
 373                 } else {
 374                         c = string[idx];
 375
 376                         /* escape the usual suspects */
 377                         if(full_escape) {
 378                                 switch(c) {
 379                                         case '"':
 380                                                 OSRF_BUFFER_ADD_CHAR(buf, '\\');
 381                                                 OSRF_BUFFER_ADD_CHAR(buf, '"');
 382                                                 break;
 383
 384                                         case '\b':
 385                                                 OSRF_BUFFER_ADD_CHAR(buf, '\\');
 386                                                 OSRF_BUFFER_ADD_CHAR(buf, 'b');
 387                                                 break;
 388
 389                                         case '\f':
 390                                                 OSRF_BUFFER_ADD_CHAR(buf, '\\');
 391                                                 OSRF_BUFFER_ADD_CHAR(buf, 'f');
 392                                                 break;
 393
 394                                         case '\t':
 395                                                 OSRF_BUFFER_ADD_CHAR(buf, '\\');
 396                                                 OSRF_BUFFER_ADD_CHAR(buf, 't');
 397                                                 break;
 398
 399                                         case '\n':
 400                                                 OSRF_BUFFER_ADD_CHAR(buf, '\\');
 401                                                 OSRF_BUFFER_ADD_CHAR(buf, 'n');
 402                                                 break;
 403
 404                                         case '\r':
 405                                                 OSRF_BUFFER_ADD_CHAR(buf, '\\');
 406                                                 OSRF_BUFFER_ADD_CHAR(buf, 'r');
 407                                                 break;
 408
 409                                         case '\\':
 410                                                 OSRF_BUFFER_ADD_CHAR(buf, '\\');
 411                                                 OSRF_BUFFER_ADD_CHAR(buf, '\\');
 412                                                 break;
 413
 414                                         default:
 415                                                 if( c < 32 ) buffer_fadd(buf, "\\u%04x", c);
 416                                                 else OSRF_BUFFER_ADD_CHAR(buf, c);
 417                                 }
 418
 419                         } else {
 420                                 OSRF_BUFFER_ADD_CHAR(buf, c);
 421                         }
 422                 }
 423
 424                 idx++;
 425         }
 426
 427         return buffer_release(buf);
 428 }
 429
 430 int buffer_append_uescape( growing_buffer* buf, const char* string ) {
 431
 432         if(NULL == string)
 433                 return 0;       // Nothing to add?  Nothing to do
 434
 435         if( NULL == buf )
 436                 return -1;      // Nothing to add to
 437
 438         int idx = 0;
 439         unsigned long int c;
 440
 441         while (string[idx]) {
 442
 443                 c = 0x0;
 444
 445                 if ((unsigned char)string[idx] >= 0x80) { // not ASCII
 446
 447                         if ((unsigned char)string[idx] >= 0xC0 && (unsigned char)string[idx] <= 0xF4) { // starts a UTF8 string
 448
 449                                 int clen = 1;
 450                                 if (((unsigned char)string[idx] & 0xF0) == 0xF0) {
 451                                         clen = 3;
 452                                         c = (unsigned char)string[idx] ^ 0xF0;
 453
 454                                 } else if (((unsigned char)string[idx] & 0xE0) == 0xE0) {
 455                                         clen = 2;
 456                                         c = (unsigned char)string[idx] ^ 0xE0;
 457
 458                                 } else if (((unsigned char)string[idx] & 0xC0) == 0xC0) {
 459                                         clen = 1;
 460                                         c = (unsigned char)string[idx] ^ 0xC0;
 461                                 }
 462
 463                                 for (;clen;clen--) {
 464
 465                                         idx++; // look at the next byte
 466                                         c = (c << 6) | ((unsigned char)string[idx] & 0x3F); // add this byte worth
 467                                 }
 468
 469                                 buffer_fadd(buf, "\\u%04x", c);
 470
 471                         } else {
 472                                 return idx + 1;
 473                         }
 474
 475                 } else if(string[idx] >= ' ' ) { // printable ASCII character
 476
 477                         c = string[idx];
 478                         switch(c) {
 479                                 case '"':
 480                                 case '\\':
 481                                         OSRF_BUFFER_ADD_CHAR(buf, '\\');
 482                                         OSRF_BUFFER_ADD_CHAR(buf, c);
 483                                         break;
 484
 485                 default:
 486                                 OSRF_BUFFER_ADD_CHAR(buf, c);
 487             }
 488
 489                 } else {
 490                         c = string[idx];
 491
 492                         /* escape the usual suspects */
 493                         switch(c) {
 494                                 case '\b':
 495                                         OSRF_BUFFER_ADD_CHAR(buf, '\\');
 496                                         OSRF_BUFFER_ADD_CHAR(buf, 'b');
 497                                         break;
 498
 499                                 case '\f':
 500                                         OSRF_BUFFER_ADD_CHAR(buf, '\\');
 501                                         OSRF_BUFFER_ADD_CHAR(buf, 'f');
 502                                         break;
 503
 504                                 case '\t':
 505                                         OSRF_BUFFER_ADD_CHAR(buf, '\\');
 506                                         OSRF_BUFFER_ADD_CHAR(buf, 't');
 507                                         break;
 508
 509                                 case '\n':
 510                                         OSRF_BUFFER_ADD_CHAR(buf, '\\');
 511                                         OSRF_BUFFER_ADD_CHAR(buf, 'n');
 512                                         break;
 513
 514                                 case '\r':
 515                                         OSRF_BUFFER_ADD_CHAR(buf, '\\');
 516                                         OSRF_BUFFER_ADD_CHAR(buf, 'r');
 517                                         break;
 518
 519                                 default:
 520                                 {
 521                                         // Represent as \u followed by four hex characters
 522                                         hex_code[ 4 ] = hex_chars[ c >> 4 ];    // high nybble
 523                                         hex_code[ 5 ] = hex_chars[ c & 0x0F ];  // low nybble
 524                                         hex_code[ 6 ] = '\0';
 525                                         OSRF_BUFFER_ADD(buf, (char *) hex_code);
 526                                         break;
 527                                 }
 528                         }
 529                 }
 530
 531                 idx++;
 532         }
 533
 534         return 0;
 535 }
 536
 537 // A function to turn a process into a daemon
 538 int daemonize( void ) {
 539         pid_t f = fork();
 540
 541         if (f == -1) {
 542                 osrfLogError( OSRF_LOG_MARK, "Failed to fork!" );
 543                 return -1;
 544
 545         } else if (f == 0) { // We're in the child now...
 546
 547                 // Change directories.  Otherwise whatever directory
 548                 // we're in couldn't be deleted until the program
 549                 // terminated -- possibly causing some inconvenience.
 550                 chdir( "/" );
 551
 552                 /* create new session */
 553                 setsid();
 554
 555                 // Now that we're no longer attached to a terminal,
 556                 // we don't want any traffic on the standard streams
 557                 freopen( "/dev/null", "r", stdin );
 558                 freopen( "/dev/null", "w", stdout );
 559                 freopen( "/dev/null", "w", stderr );
 560
 561                 return 0;
 562
 563         } else { // We're in the parent...
 564                 _exit(0);
 565         }
 566 }
 567
 568
 569 /* Return 1 if the string represents an integer,  */
 570 /* as recognized by strtol(); Otherwise return 0. */
 571
 572 int stringisnum(const char* s) {
 573         char* w;
 574         strtol(s, &w, 10);
 575         return *w ? 0 : 1;
 576 }
 577
 578
 579
 580 char* file_to_string(const char* filename) {
 581
 582         if(!filename) return NULL;
 583
 584         FILE * file = fopen( filename, "r" );
 585         if( !file ) {
 586                 osrfLogError( OSRF_LOG_MARK, "Unable to open file [%s]", filename );
 587                 return NULL;
 588         }
 589
 590         size_t num_read;
 591         char buf[ BUFSIZ + 1 ];
 592         growing_buffer* gb = buffer_init(sizeof(buf));
 593
 594         while( ( num_read = fread( buf, 1, sizeof(buf) - 1, file) ) ) {
 595                 buf[ num_read ] = '\0';
 596                 buffer_add(gb, buf);
 597         }
 598
 599         fclose(file);
 600
 601         return buffer_release(gb);
 602 }
 603
 604
 605 char* md5sum( const char* text, ... ) {
 606
 607         struct md5_ctx ctx;
 608         unsigned char digest[16];
 609
 610         MD5_start (&ctx);
 611
 612         VA_LIST_TO_STRING(text);
 613
 614         int i;
 615         for ( i=0 ; i != strlen(VA_BUF) ; i++ )
 616                 MD5_feed (&ctx, VA_BUF[i]);
 617
 618         MD5_stop (&ctx, digest);
 619
 620         char buf[16];
 621         char final[256];
 622         osrf_clearbuf(final, sizeof(final));
 623
 624         for ( i=0 ; i<16 ; i++ ) {
 625                 snprintf(buf, sizeof(buf), "%02x", digest[i]);
 626                 strcat( final, buf );
 627         }
 628
 629         return strdup(final);
 630
 631 }
 632
 633 int osrfUtilsCheckFileDescriptor( int fd ) {
 634
 635         fd_set tmpset;
 636         FD_ZERO(&tmpset);
 637         FD_SET(fd, &tmpset);
 638
 639         struct timeval tv;
 640         tv.tv_sec = 0;
 641         tv.tv_usec = 0;
 642
 643         if( select(fd + 1, &tmpset, NULL, NULL, &tv) == -1 ) {
 644                 if( errno == EBADF ) return -1;
 645         }
 646
 647         return 0;
 648 }
 649