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

misc.c

00001 /* 
00002  * Copyright (c) 2005-2008 by KoanLogic s.r.l. - All rights reserved.  
00003  */
00004 
00005 static const char rcsid[] =
00006     "$Id: misc.c,v 1.14 2008/04/25 20:58:36 tat 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 #include <sys/types.h>
00022 
00023 #include <toolbox/net.h>
00024 #include <toolbox/misc.h>
00025 #include <toolbox/carpal.h>
00026 #include <toolbox/memory.h>
00027 
00035 inline int u_isblank(int c)
00036 {
00037     return c == ' ' || c == '\t';
00038 }
00039 
00042 void u_trim(char *s)
00043 {
00044     char *p;
00045 
00046     if(!s)
00047         return;
00048 
00049     /* trim trailing blanks */
00050     p = s + strlen(s) -1;
00051     while(s < p && u_isblank(*p))
00052         --p;
00053     p[1] = 0;
00054 
00055     /* trim leading blanks */
00056     p = s;
00057     while(*p && u_isblank(*p))
00058         ++p;
00059 
00060     if(p > s)
00061         memmove(s, p, 1 + strlen(p));
00062 }
00063 
00067 inline int u_isblank_str(const char *ln)
00068 {
00069     for(; *ln; ++ln)
00070         if(!u_isblank(*ln))
00071             return 0;
00072     return 1;
00073 }
00074 
00078 inline int u_isnl(int c)
00079 {
00080     return c == '\n' || c == '\r';
00081 }
00082 
00086 char *u_strndup(const char *s, size_t len)
00087 {
00088     char *cp;
00089 
00090     if((cp = (char*) u_malloc(len + 1)) == NULL)
00091         return NULL;
00092     memcpy(cp, s, len);
00093     cp[len] = 0;
00094     return cp;
00095 }
00096 
00098 char *u_strdup(const char *s)
00099 {
00100     return u_strndup(s, strlen(s));
00101 }
00102 
00107 int u_savepid (const char *pf)
00108 {
00109     FILE *pfp = NULL;
00110 
00111     dbg_return_if (pf == NULL, ~0);
00112 
00113     dbg_err_sif ((pfp = fopen(pf, "w")) == NULL);
00114     dbg_err_sif (fprintf(pfp, "%ld\n", (long) getpid()) == 0);
00115     fclose(pfp);
00116 
00117     return 0;
00118 err:
00119     U_FCLOSE(pfp);
00120     return ~0;
00121 }
00122 
00128 char *u_sstrncpy (char *dst, const char *src, size_t size)
00129 {
00130     dst[size] = '\0';
00131     return strncpy(dst, src, size);
00132 }
00133 
00137 void* u_memdup(const void *src, size_t size)
00138 {
00139     void *p;
00140 
00141     p = u_malloc(size);
00142     if(p)
00143         memcpy(p, src, size);
00144     return p;
00145 }
00146 
00159 int u_tokenize (char *wlist, const char *delim, char **tokv, size_t tokv_sz)
00160 {
00161     char **ap;
00162 
00163     dbg_return_if (wlist == NULL, ~0);
00164     dbg_return_if (delim == NULL, ~0);
00165     dbg_return_if (tokv == NULL, ~0);
00166     dbg_return_if (tokv_sz == 0, ~0);
00167 
00168     ap = tokv;
00169 
00170     for ( ; (*ap = strsep(&wlist, delim)) != NULL; )
00171     {
00172         /* skip empty field */
00173         if (**ap == '\0')
00174             continue;
00175 
00176         /* check bounds */
00177         if (++ap >= &tokv[tokv_sz - 1])
00178             break;
00179     }
00180 
00181     /* put an explicit stopper to tokv */
00182     *ap = NULL;
00183 
00184     return 0;
00185 }
00186 
00198 int u_snprintf(char *str, size_t size, const char *fmt, ...)
00199 {
00200     va_list ap;
00201     int wr;
00202 
00203     va_start(ap, fmt);
00204 
00205     wr = vsnprintf(str, size, fmt, ap);
00206 
00207     va_end(ap);
00208 
00209     dbg_err_if(wr < 0 || wr >= (int)size);
00210 
00211     return 0;
00212 err:
00213     return ~0;
00214 }
00215 
00229 int u_path_snprintf(char *buf, size_t sz, char sep, const char *fmt, ...)
00230 {
00231     va_list ap;
00232     int wr, i, len;
00233 
00234     va_start(ap, fmt);
00235 
00236     wr = vsnprintf(buf, sz, fmt, ap);
00237 
00238     va_end(ap);
00239 
00240     dbg_err_if(wr < 0 || wr >= (int)sz);
00241 
00242     /* remove multiple consecutive '/' */
00243     for(len = i = strlen(buf); i > 0; --i)
00244     {
00245         if(buf[i] == sep && buf[i-1] == sep)
00246         {
00247             memmove(buf + i, buf + i + 1, len - i);
00248             len--;
00249         }
00250     }
00251 
00252     return 0;
00253 err:
00254     return ~0;
00255 }
00256 
00257 inline void u_use_unused_args(char *dummy, ...)
00258 {
00259     dummy = 0;
00260     return;
00261 }
00262 
00264 int u_data_is_bin (char *data, size_t sz)
00265 {
00266     size_t i;
00267 
00268     for (i = 0; i < sz; i++)
00269     {
00270         if (!isascii(data[i]))
00271             return 1;
00272     }
00273 
00274     return 0;
00275 }
00276 
00277 int u_data_dump (char *data, size_t sz, const char *file)
00278 {
00279     FILE *fp = NULL;
00280 
00281     dbg_err_if ((fp = fopen(file, "w")) == NULL); 
00282     dbg_err_if (fwrite(data, sz, 1, fp) < 1);
00283     fclose(fp);
00284 
00285     return 0;
00286 err:
00287     U_FCLOSE(fp); 
00288     return ~0;
00289 }
00290 
00302 int u_load_file (const char *path, size_t sz_max, char **pbuf, size_t *psz)
00303 {   
00304     FILE *fp = NULL;
00305     char *buf = NULL;
00306     size_t sz; 
00307     struct stat sb;
00308     
00309     dbg_return_if (path == NULL, ~0);
00310     dbg_return_if (pbuf == NULL, ~0);
00311     dbg_return_if (psz == NULL, ~0);
00312     
00313     dbg_err_sifm ((fp = fopen(path, "r")) == NULL, "%s", path);
00314     dbg_err_sifm (fstat(fileno(fp), &sb) == -1, "%s", path); 
00315     sz = sb.st_size;
00316     dbg_err_ifm (sz_max > 0 && sz > sz_max, 
00317             "file too big (%zu vs %zu bytes)", sz, sz_max);
00318     dbg_err_sif ((buf = u_zalloc(sz)) == NULL);
00319     dbg_err_sifm (fread(buf, sz, 1, fp) != 1, "%s", path);
00320     
00321     U_FCLOSE(fp);
00322     
00323     *pbuf = buf;
00324     *psz = sz;
00325     
00326     return 0;
00327 err:
00328     U_FCLOSE(fp);
00329     U_FREE(buf);
00330     return ~0;
00331 }
00332 
00355 int u_io (iof_t f, int sd, void *buf, size_t l, ssize_t *n, int *eof)
00356 {
00357 #define SET_PPTR(pptr, val) do {if ((pptr)) *(pptr) = (val);} while (0);
00358     ssize_t nret;
00359     size_t nleft = l;
00360     char *p = buf;
00361 
00362     SET_PPTR(n, 0);
00363     SET_PPTR(eof, 0);
00364 
00365     while (nleft > 0) 
00366     {
00367         if ((nret = (f) (sd, p, nleft)) == -1)
00368         {
00369             if (errno == EINTR)
00370                 continue;
00371             else
00372             {
00373                 dbg_strerror(errno);
00374                 goto end;
00375             }
00376         }
00377 
00378         /* test EOF */
00379         if (nret == 0)
00380         {
00381             SET_PPTR(eof, 1);
00382             goto end;
00383         }
00384         
00385         nleft -= nret;
00386         p += nret;
00387     }
00388 
00389 end:
00390     SET_PPTR(n, l - nleft);
00391     return nleft ? ~0 : 0;
00392 #undef SET_PPTR
00393 }
00394 
00402 int u_sleep(unsigned int secs)
00403 {
00404 #ifdef OS_WIN
00405     Sleep(secs * 1000);
00406 #else
00407     int sleep_for, c;
00408 
00409     for(sleep_for = secs; sleep_for > 0; sleep_for = c)
00410     {
00411         if((c = sleep(sleep_for)) == 0)
00412             break;
00413         else if(errno != EINTR)
00414             return -1; /* should never happen */
00415     }
00416 
00417 #endif
00418     return 0;
00419 }
00420 
00430 int u_accept(int ld, struct sockaddr *addr, int *addrlen)
00431 {
00432     int ad = -1;
00433 
00434 again:
00435     ad = accept(ld, addr, addrlen);
00436     if(ad == -1 && (errno == EINTR))
00437         goto again; /* interrupted */
00438 
00439     return ad;
00440 }
00441 
00451 ssize_t u_read(int fd, void *buf, size_t size)
00452 {
00453     ssize_t nw = 0;
00454     int eof = 0;
00455 
00456     if(u_io((iof_t) read, fd, buf, size, &nw, &eof))
00457     {
00458         if(eof)
00459             return nw; /* may be zero */
00460         else
00461             return -1;
00462     }
00463 
00464     return nw;
00465 }
00466 
00476 ssize_t u_write(int fd, void *buf, size_t size)
00477 {
00478     if(u_io((iof_t) write, fd, buf, size, NULL, NULL))
00479         return -1;
00480 
00481     return size;
00482 }
00483 

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