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

srcs/toolbox/misc.c

00001 /* 
00002  * Copyright (c) 2005-2007 by KoanLogic s.r.l. - All rights reserved.  
00003  */
00004 
00005 static const char rcsid[] =
00006     "$Id: misc.c,v 1.10 2007/07/03 11:54:38 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 #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;
00110 
00111     dbg_return_if ((pfp = fopen(pf, "w")) == NULL, ~0);
00112 
00113     fprintf(pfp, "%ld\n", (long) getpid());
00114     fclose(pfp);
00115 
00116     return 0;
00117 }
00118 
00124 char *u_sstrncpy (char *dst, const char *src, size_t size)
00125 {
00126     dst[size] = '\0';
00127     return strncpy(dst, src, size);
00128 }
00129 
00133 void* u_memdup(const void *src, size_t size)
00134 {
00135     void *p;
00136 
00137     p = u_malloc(size);
00138     if(p)
00139         memcpy(p, src, size);
00140     return p;
00141 }
00142 
00155 int u_tokenize (char *wlist, const char *delim, char **tokv, size_t tokv_sz)
00156 {
00157     char **ap;
00158 
00159     dbg_return_if (wlist == NULL, ~0);
00160     dbg_return_if (delim == NULL, ~0);
00161     dbg_return_if (tokv == NULL, ~0);
00162     dbg_return_if (tokv_sz == 0, ~0);
00163 
00164     ap = tokv;
00165 
00166     for ( ; (*ap = strsep(&wlist, delim)) != NULL; )
00167     {
00168         /* skip empty field */
00169         if (**ap == '\0')
00170             continue;
00171 
00172         /* check bounds */
00173         if (++ap >= &tokv[tokv_sz - 1])
00174             break;
00175     }
00176 
00177     /* put an explicit stopper to tokv */
00178     *ap = NULL;
00179 
00180     return 0;
00181 }
00182 
00194 int u_snprintf(char *str, size_t size, const char *fmt, ...)
00195 {
00196     va_list ap;
00197     int wr;
00198 
00199     va_start(ap, fmt);
00200 
00201     wr = vsnprintf(str, size, fmt, ap);
00202 
00203     va_end(ap);
00204 
00205     dbg_err_if(wr < 0 || wr >= (int)size);
00206 
00207     return 0;
00208 err:
00209     return ~0;
00210 }
00211 
00225 int u_path_snprintf(char *buf, size_t sz, char sep, const char *fmt, ...)
00226 {
00227     va_list ap;
00228     int wr, i, len;
00229 
00230     va_start(ap, fmt);
00231 
00232     wr = vsnprintf(buf, sz, fmt, ap);
00233 
00234     va_end(ap);
00235 
00236     dbg_err_if(wr < 0 || wr >= (int)sz);
00237 
00238     /* remove multiple consecutive '/' */
00239     for(len = i = strlen(buf); i > 0; --i)
00240         if(buf[i] == sep && buf[i-1] == sep)
00241             memmove(buf + i, buf + i + 1, len--);
00242 
00243     return 0;
00244 err:
00245     return ~0;
00246 }
00247 
00248 inline void u_use_unused_args(char *dummy, ...)
00249 {
00250     dummy = 0;
00251     return;
00252 }
00253 
00255 int u_data_is_bin (char *data, size_t sz)
00256 {
00257     size_t i;
00258 
00259     for (i = 0; i < sz; i++)
00260     {
00261         if (!isascii(data[i]))
00262             return 1;
00263     }
00264 
00265     return 0;
00266 }
00267 
00268 int u_data_dump (char *data, size_t sz, const char *file)
00269 {
00270     FILE *fp = NULL;
00271 
00272     dbg_err_if ((fp = fopen(file, "w")) == NULL); 
00273     dbg_err_if (fwrite(data, sz, 1, fp) < 1);
00274     fclose(fp);
00275 
00276     return 0;
00277 err:
00278     U_FCLOSE(fp); 
00279     return ~0;
00280 }
00281 
00293 int u_load_file (const char *path, size_t sz_max, char **pbuf, size_t *psz)
00294 {   
00295     FILE *fp = NULL;
00296     char *buf = NULL;
00297     size_t sz; 
00298     struct stat sb;
00299     
00300     dbg_return_if (path == NULL, ~0);
00301     dbg_return_if (pbuf == NULL, ~0);
00302     dbg_return_if (psz == NULL, ~0);
00303     
00304     warn_err_sifm ((fp = fopen(path, "r")) == NULL, "%s", path);
00305     warn_err_sifm (fstat(fileno(fp), &sb) == -1, "%s", path); 
00306     sz = sb.st_size;
00307     warn_err_ifm (sz_max > 0 && sz > sz_max, 
00308             "file too big (%zu vs %zu bytes)", sz, sz_max);
00309     warn_err_sif ((buf = u_zalloc(sz)) == NULL);
00310     warn_err_sifm (fread(buf, sz, 1, fp) != 1, "%s", path);
00311     
00312     U_FCLOSE(fp);
00313     
00314     *pbuf = buf;
00315     *psz = sz;
00316     
00317     return 0;
00318 err:
00319     U_FCLOSE(fp);
00320     U_FREE(buf);
00321     return ~0;
00322 }
00323 
00346 int u_io (iof_t f, int sd, void *buf, size_t l, ssize_t *n, int *eof)
00347 {
00348 #define SET_PPTR(pptr, val) do {if ((pptr)) *(pptr) = (val);} while (0);
00349     ssize_t nret;
00350     size_t nleft = l;
00351     char *p = buf;
00352 
00353     SET_PPTR(n, 0);
00354     SET_PPTR(eof, 0);
00355 
00356     while (nleft > 0) 
00357     {
00358         if ((nret = (f) (sd, p, nleft)) == -1)
00359         {
00360             if (errno == EINTR)
00361                 continue;
00362             else
00363             {
00364                 warn_strerror(errno);
00365                 goto end;
00366             }
00367         }
00368 
00369         /* test EOF */
00370         if (nret == 0)
00371         {
00372             SET_PPTR(eof, 1);
00373             goto end;
00374         }
00375         
00376         nleft -= nret;
00377         p += nret;
00378     }
00379 
00380 end:
00381     SET_PPTR(n, l - nleft);
00382     return nleft ? ~0 : 0;
00383 #undef SET_PPTR
00384 }
00385 
00393 int u_sleep(unsigned int secs)
00394 {
00395 #ifdef OS_WIN
00396     Sleep(secs * 1000);
00397 #else
00398     int sleep_for, c;
00399 
00400     for(sleep_for = secs; sleep_for > 0; sleep_for = c)
00401     {
00402         if((c = sleep(sleep_for)) == 0)
00403             break;
00404         else if(errno != EINTR)
00405             return -1; /* should never happen */
00406     }
00407 
00408 #endif
00409     return 0;
00410 }
00411 
00421 int u_accept(int ld, struct sockaddr *addr, int *addrlen)
00422 {
00423     int ad = -1;
00424 
00425 again:
00426     ad = accept(ld, addr, addrlen);
00427     if(ad == -1 && (errno == EINTR))
00428         goto again; /* interrupted */
00429 
00430     return ad;
00431 }
00432 
00442 ssize_t u_read(int fd, void *buf, size_t size)
00443 {
00444     ssize_t nw = 0;
00445     int eof = 0;
00446 
00447     if(u_io((iof_t) read, fd, buf, size, &nw, &eof))
00448     {
00449         if(eof)
00450             return nw; /* may be zero */
00451         else
00452             return -1;
00453     }
00454 
00455     return nw;
00456 }
00457 
00467 ssize_t u_write(int fd, void *buf, size_t size)
00468 {
00469     if(u_io((iof_t) write, fd, buf, size, NULL, NULL))
00470         return -1;
00471 
00472     return size;
00473 }
00474 

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