src/utils/utils.h

   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 #ifndef UTILS_H
  18 #define UTILS_H
  19
  20 #include <stdio.h>
  21 #include <stdarg.h>
  22 #include <fcntl.h>
  23 #include <unistd.h>
  24 #include <sys/time.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <sys/types.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 //#include <sys/timeb.h>
  31
  32 #include "md5.h"
  33
  34 #define OSRF_MALLOC(ptr, size) \
  35         ptr = (void*) malloc( size ); \
  36         if( ptr == NULL ) { \
  37                 perror("OSRF_MALLOC(): Out of Memory" );\
  38                 exit(99); \
  39         } \
  40         memset( ptr, 0, size );
  41
  42
  43 #define OSRF_BUFFER_ADD(gb, data) \
  44         do {\
  45                 int __tl; \
  46                 if(gb && data) {\
  47                         __tl = strlen(data) + gb->n_used;\
  48                         if( __tl < gb->size ) {\
  49                                 strcat(gb->buf, data);\
  50                                 gb->n_used = __tl; \
  51                         } else { buffer_add(gb, data); }\
  52                 }\
  53         } while(0)
  54
  55 #define OSRF_BUFFER_ADD_CHAR(gb, c)\
  56         do {\
  57                 if(gb) {\
  58                         if(gb->n_used < gb->size - 1)\
  59                                 gb->buf[gb->n_used++] = c;\
  60                         else\
  61                                 buffer_add_char(gb, c);\
  62                 }\
  63         }while(0)
  64
  65
  66
  67
  68 /* turns a va_list into a string */
  69 #define VA_LIST_TO_STRING(x) \
  70         unsigned long __len = 0;\
  71         va_list args; \
  72         va_list a_copy;\
  73         va_copy(a_copy, args); \
  74         va_start(args, x); \
  75         __len = vsnprintf(NULL, 0, x, args); \
  76         va_end(args); \
  77         __len += 2; \
  78         char _b[__len]; \
  79         bzero(_b, __len); \
  80         va_start(a_copy, x); \
  81         vsnprintf(_b, __len - 1, x, a_copy); \
  82         va_end(a_copy); \
  83         char* VA_BUF = _b; \
  84
  85 /* turns a long into a string */
  86 #define LONG_TO_STRING(l) \
  87         unsigned int __len = snprintf(NULL, 0, "%ld", l) + 2;\
  88         char __b[__len]; \
  89         bzero(__b, __len); \
  90         snprintf(__b, __len - 1, "%ld", l); \
  91         char* LONGSTR = __b;
  92
  93 #define DOUBLE_TO_STRING(l) \
  94         unsigned int __len = snprintf(NULL, 0, "%f", l) + 2; \
  95         char __b[__len]; \
  96         bzero(__b, __len); \
  97         snprintf(__b, __len - 1, "%f", l); \
  98         char* DOUBLESTR = __b;
  99
 100 #define LONG_DOUBLE_TO_STRING(l) \
 101         unsigned int __len = snprintf(NULL, 0, "%Lf", l) + 2; \
 102         char __b[__len]; \
 103         bzero(__b, __len); \
 104         snprintf(__b, __len - 1, "%Lf", l); \
 105         char* LONGDOUBLESTR = __b;
 106
 107
 108 #define INT_TO_STRING(l) \
 109         unsigned int __len = snprintf(NULL, 0, "%d", l) + 2; \
 110         char __b[__len]; \
 111         bzero(__b, __len); \
 112         snprintf(__b, __len - 1, "%d", l); \
 113         char* INTSTR = __b;
 114
 115
 116 /*
 117 #define MD5SUM(s) \
 118         struct md5_ctx ctx; \
 119         unsigned char digest[16];\
 120         MD5_start (&ctx);\
 121         int i;\
 122         for ( i=0 ; i != strlen(text) ; i++ ) MD5_feed (&ctx, text[i]);\
 123         MD5_stop (&ctx, digest);\
 124         char buf[16];\
 125         memset(buf,0,16);\
 126         char final[256];\
 127         memset(final,0,256);\
 128         for ( i=0 ; i<16 ; i++ ) {\
 129                 sprintf(buf, "%02x", digest[i]);\
 130                 strcat( final, buf );\
 131         }\
 132         char* MD5STR = final;
 133         */
 134
 135
 136
 137
 138
 139 #define BUFFER_MAX_SIZE 10485760
 140
 141 /* these are evil and should be condemned
 142         ! Only use these if you are done with argv[].
 143         call init_proc_title() first, then call
 144         set_proc_title.
 145         the title is only allowed to be as big as the
 146         initial process name of the process (full size of argv[]).
 147         truncation may occurr.
 148  */
 149 int init_proc_title( int argc, char* argv[] );
 150 int set_proc_title( char* format, ... );
 151
 152
 153 int daemonize();
 154
 155 void* safe_malloc(int size);
 156
 157 // ---------------------------------------------------------------------------------
 158 // Generic growing buffer. Add data all you want
 159 // ---------------------------------------------------------------------------------
 160 struct growing_buffer_struct {
 161         char *buf;
 162         int n_used;
 163         int size;
 164 };
 165 typedef struct growing_buffer_struct growing_buffer;
 166
 167 growing_buffer* buffer_init( int initial_num_bytes);
 168
 169 // XXX This isn't defined in utils.c!! removing for now...
 170 //int buffer_addchar(growing_buffer* gb, char c);
 171
 172 int buffer_add(growing_buffer* gb, char* c);
 173 int buffer_fadd(growing_buffer* gb, const char* format, ... );
 174 int buffer_reset( growing_buffer* gb);
 175 char* buffer_data( growing_buffer* gb);
 176 int buffer_free( growing_buffer* gb );
 177 int buffer_add_char(growing_buffer* gb, char c);
 178
 179 /* returns the size needed to fill in the vsnprintf buffer.
 180         * ! this calls va_end on the va_list argument*
 181         */
 182 long va_list_size(const char* format, va_list);
 183
 184 /* turns a va list into a string, caller must free the
 185         allocated char */
 186 char* va_list_to_string(const char* format, ...);
 187
 188
 189 /* string escape utility method.  escapes unicode embeded characters.
 190         escapes the usual \n, \t, etc.
 191         for example, if you provide a string like so:
 192
 193         hello,
 194                 you
 195
 196         you would get back:
 197         hello,\n\tyou
 198
 199  */
 200 char* uescape( const char* string, int size, int full_escape );
 201
 202 /* utility methods */
 203 int set_fl( int fd, int flags );
 204 int clr_fl( int fd, int flags );
 205
 206
 207
 208 // Utility method
 209 double get_timestamp_millis();
 210
 211
 212 /* returns true if the whole string is a number */
 213 int stringisnum(char* s);
 214
 215 /* reads a file and returns the string version of the file
 216         user is responsible for freeing the returned char*
 217         */
 218 char* file_to_string(const char* filename);
 219
 220
 221
 222 /**
 223   Calculates the md5 of the text provided.
 224   The returned string must be freed by the caller.
 225   */
 226 char* md5sum( char* text, ... );
 227
 228
 229 /**
 230   Checks the validity of the file descriptor
 231   returns -1 if the file descriptor is invalid
 232   returns 0 if the descriptor is OK
 233   */
 234 int osrfUtilsCheckFileDescriptor( int fd );
 235
 236 #endif