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