00001
00002
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
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;
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
00169 if (**ap == '\0')
00170 continue;
00171
00172
00173 if (++ap >= &tokv[tokv_sz - 1])
00174 break;
00175 }
00176
00177
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
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
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;
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;
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;
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