00001
00002
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
00050 p = s + strlen(s) -1;
00051 while(s < p && u_isblank(*p))
00052 --p;
00053 p[1] = 0;
00054
00055
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
00173 if (**ap == '\0')
00174 continue;
00175
00176
00177 if (++ap >= &tokv[tokv_sz - 1])
00178 break;
00179 }
00180
00181
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
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
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;
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;
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;
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