Main Page | Modules | Data Structures | File List | Data Fields

misc.c

00001 /* 
00002  * Copyright (c) 2005, 2006 by KoanLogic s.r.l. - All rights reserved.  
00003  */
00004 
00005 static const char rcsid[] =
00006     "$Id: misc.c,v 1.2 2006/12/07 08:32:14 tho Exp $";
00007 
00008 #include <u/libu_conf.h>
00009 #include <sys/types.h>
00010 #include <sys/stat.h>
00011 #include <stdlib.h>
00012 #include <string.h>
00013 #include <stdio.h>
00014 #include <time.h>
00015 #include <errno.h>
00016 #include <signal.h>
00017 #include <ctype.h>
00018 #include <fcntl.h>
00019 #include <unistd.h>
00020 #include <dirent.h>
00021 
00022 #include <toolbox/misc.h>
00023 #include <toolbox/carpal.h>
00024 #include <toolbox/memory.h>
00025 
00033 inline int u_isblank(int c)
00034 {
00035     return c == ' ' || c == '\t';
00036 }
00037 
00040 void u_trim(char *s)
00041 {
00042     char *p;
00043 
00044     if(!s)
00045         return;
00046 
00047     /* trim trailing blanks */
00048     p = s + strlen(s) -1;
00049     while(s < p && u_isblank(*p))
00050         --p;
00051     p[1] = 0;
00052 
00053     /* trim leading blanks */
00054     p = s;
00055     while(*p && u_isblank(*p))
00056         ++p;
00057 
00058     if(p > s)
00059         memmove(s, p, 1 + strlen(p));
00060 }
00061 
00065 inline int u_isblank_str(const char *ln)
00066 {
00067     for(; *ln; ++ln)
00068         if(!u_isblank(*ln))
00069             return 0;
00070     return 1;
00071 }
00072 
00076 inline int u_isnl(int c)
00077 {
00078     return c == '\n' || c == '\r';
00079 }
00080 
00084 char *u_strndup(const char *s, size_t len)
00085 {
00086     char *cp;
00087 
00088     if((cp = (char*) u_malloc(len + 1)) == NULL)
00089         return NULL;
00090     memcpy(cp, s, len);
00091     cp[len] = 0;
00092     return cp;
00093 }
00094 
00096 char *u_strdup(const char *s)
00097 {
00098     return u_strndup(s, strlen(s));
00099 }
00100 
00105 int u_savepid (const char *pf)
00106 {
00107     FILE *pfp;
00108 
00109     dbg_return_if ((pfp = fopen(pf, "w")) == NULL, ~0);
00110 
00111     fprintf(pfp, "%ld\n", (long) getpid());
00112     fclose(pfp);
00113 
00114     return 0;
00115 }
00116 
00122 char *u_sstrncpy (char *dst, const char *src, size_t size)
00123 {
00124     dst[size] = '\0';
00125     return strncpy(dst, src, size);
00126 }
00127 
00131 void* u_memdup(const void *src, size_t size)
00132 {
00133     void *p;
00134 
00135     p = u_malloc(size);
00136     if(p)
00137         memcpy(p, src, size);
00138     return p;
00139 }
00140 
00153 int u_tokenize (char *wlist, const char *delim, char **tokv, size_t tokv_sz)
00154 {
00155     char **ap;
00156 
00157     dbg_return_if (wlist == NULL, ~0);
00158     dbg_return_if (delim == NULL, ~0);
00159     dbg_return_if (tokv == NULL, ~0);
00160     dbg_return_if (tokv_sz == 0, ~0);
00161 
00162     ap = tokv;
00163 
00164     for ( ; (*ap = strsep(&wlist, delim)) != NULL; )
00165     {
00166         /* skip empty field */
00167         if (**ap == '\0')
00168             continue;
00169 
00170         /* check bounds */
00171         if (++ap >= &tokv[tokv_sz - 1])
00172             break;
00173     }
00174 
00175     /* put an explicit stopper to tokv */
00176     *ap = NULL;
00177 
00178     return 0;
00179 }
00180 
00192 int u_snprintf(char *str, size_t size, const char *fmt, ...)
00193 {
00194     va_list ap;
00195     int wr;
00196 
00197     va_start(ap, fmt);
00198 
00199     wr = vsnprintf(str, size, fmt, ap);
00200 
00201     va_end(ap);
00202 
00203     dbg_err_if(wr < 0 || wr >= (int)size);
00204 
00205     return 0;
00206 err:
00207     return ~0;
00208 }
00209 
00223 int u_path_snprintf(char *buf, size_t sz, char sep, const char *fmt, ...)
00224 {
00225     va_list ap;
00226     int wr, i, len;
00227 
00228     va_start(ap, fmt);
00229 
00230     wr = vsnprintf(buf, sz, fmt, ap);
00231 
00232     va_end(ap);
00233 
00234     dbg_err_if(wr < 0 || wr >= (int)sz);
00235 
00236     /* remove multiple consecutive '/' */
00237     for(len = i = strlen(buf); i > 0; --i)
00238         if(buf[i] == sep && buf[i-1] == sep)
00239             memmove(buf + i, buf + i + 1, len--);
00240 
00241     return 0;
00242 err:
00243     return ~0;
00244 }
00245 
00246 inline void u_use_unused_args(char *dummy, ...)
00247 {
00248     dummy = 0;
00249     return;
00250 }
00251 
00253 int u_data_is_bin (char *data, size_t sz)
00254 {
00255     size_t i;
00256 
00257     for (i = 0; i < sz; i++)
00258     {
00259         if (!isascii(data[i]))
00260             return 1;
00261     }
00262 
00263     return 0;
00264 }
00265 
00266 int u_data_dump (char *data, size_t sz, const char *file)
00267 {
00268     FILE *fp = NULL;
00269 
00270     dbg_err_if ((fp = fopen(file, "w")) == NULL); 
00271     dbg_err_if (fwrite(data, sz, 1, fp) < 1);
00272     fclose(fp);
00273 
00274     return 0;
00275 err:
00276     U_FCLOSE(fp); 
00277     return ~0;
00278 }
00279 
00291 int u_load_file (const char *path, size_t sz_max, char **pbuf, size_t *psz)
00292 {   
00293     FILE *fp = NULL;
00294     char *buf = NULL;
00295     size_t sz; 
00296     struct stat sb;
00297     
00298     dbg_return_if (path == NULL, ~0);
00299     dbg_return_if (pbuf == NULL, ~0);
00300     dbg_return_if (psz == NULL, ~0);
00301     
00302     warn_err_sifm ((fp = fopen(path, "r")) == NULL, "%s", path);
00303     warn_err_sifm (fstat(fileno(fp), &sb) == -1, "%s", path); 
00304     sz = sb.st_size;
00305     warn_err_ifm (sz_max > 0 && sz > sz_max, 
00306             "file too big (%zu vs %zu bytes)", sz, sz_max);
00307     warn_err_sif ((buf = u_zalloc(sz)) == NULL);
00308     warn_err_sifm (fread(buf, sz, 1, fp) != 1, "%s", path);
00309     
00310     U_FCLOSE(fp);
00311     
00312     *pbuf = buf;
00313     *psz = sz;
00314     
00315     return 0;
00316 err:
00317     U_FCLOSE(fp);
00318     U_FREE(buf);
00319     return ~0;
00320 }
00321 
00322 

←Products
© 2005-2006 - KoanLogic S.r.l. - All rights reserved