code.grnet.gr Git - archipelago/blob - xseg/peers/user/common.c

   1 /*
   2  *
   3  * vkoukis.c
   4  *
   5  * Some commonly used functions
   6  */
   7
   8 #define _GNU_SOURCE
   9
  10 #include "pthread.h"
  11
  12 #include <time.h>
  13 #include <errno.h>
  14 #include <stdio.h>
  15 #include <stdlib.h>
  16 #include <string.h>
  17 #include <stdarg.h>
  18 #include <unistd.h>
  19 #include <signal.h>
  20
  21 #include <sys/time.h>
  22 #include <sys/types.h>
  23
  24 #include "common.h"
  25
  26 static char *perr_prog_name = NULL;
  27
  28 /*
  29  * perr_func:           Main error reporting function
  30  */
  31 void perr_func(enum perr_type type, int want_errno, char *fmt, ...)
  32 {
  33         va_list ap;
  34         time_t timeval;
  35         int err_number = errno;         /* We need errno NOW */
  36         char buf[PERR_BUF_SIZE], errbuf[PERR_BUF_SIZE], timebuf[PERR_BUF_SIZE];
  37         char *t = NULL, *p = buf;
  38
  39         va_start(ap, fmt);
  40         switch (type) {
  41                 case PFE: t = "Fatal error"; break;
  42                 case PE: t = "Error"; break;
  43                 case PW: t = "Warning"; break;
  44                 case PI: t = "Info"; break;
  45                 case PD: t = "Debug"; break;
  46                 default: raise(SIGABRT);
  47         }
  48         if (!perr_prog_name) {
  49                 perr_prog_name = "Internal perr error";
  50                 perr(1, 0, "init_perr has not been called");
  51         }
  52
  53         time(&timeval);
  54         ctime_r(&timeval, timebuf);
  55         *strchr(timebuf, '\n') = '\0';
  56
  57         p += sprintf(p, "%s: %s: ", perr_prog_name, t);
  58         p += sprintf(p, "Thread %lu, PID %lu\n\t",
  59                         (unsigned long)pthread_self(), (unsigned long)getpid());
  60
  61         p += sprintf(p, "%s (%ld):\n\t", timebuf, timeval);
  62
  63         p += vsprintf(p, fmt, ap);
  64         p += sprintf(p, "\n");
  65
  66         if (want_errno == 1)
  67                 /* Print last error returned from system call */
  68                 p += sprintf(p, "\tErrno was: %d - %s\n",
  69                                 err_number, strerror_r(err_number, errbuf, PERR_BUF_SIZE));
  70
  71         /*
  72          * Output the buffer to stderr with a single call to fprintf,
  73          * which is thread-safe and locks the stderr semaphore
  74          */
  75         fprintf(stderr, "%s", buf);
  76         fflush(stderr);
  77         va_end(ap);
  78
  79         if (type > 0)
  80                 exit(1);
  81 }
  82
  83 void init_perr(char *prog_name)
  84 {
  85         perr_prog_name = prog_name;
  86 }
  87
  88 /*
  89  * Adapted from FreeBSD source:
  90  *
  91  * Appends src to string dst of size siz (unlike strncat, siz is the
  92  * full size of dst, not space left).  At most siz-1 characters
  93  * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
  94  * Returns strlen(src) + MIN(siz, strlen(initial dst)).
  95  * If retval >= siz, truncation occurred.
  96  */
  97 size_t strlcat(char *dst, const char *src, size_t siz)
  98 {
  99         char *d = dst;
 100         const char *s = src;
 101         size_t n = siz;
 102         size_t dlen;
 103
 104         /* Find the end of dst and adjust bytes left but don't go past end */
 105         while (n-- != 0 && *d != '\0')
 106                 d++;
 107         dlen = d - dst;
 108         n = siz - dlen;
 109
 110         if (n == 0)
 111                 return(dlen + strlen(s));
 112         while (*s != '\0') {
 113                 if (n != 1) {
 114                         *d++ = *s;
 115                         n--;
 116                 }
 117                 s++;
 118         }
 119         *d = '\0';
 120
 121         return (dlen + (s - src));      /* count does not include NUL */
 122 }
 123
 124 /*
 125  * Adapted from FreeBSD source:
 126  *
 127  * Copy src to string dst of size siz.  At most siz-1 characters
 128  * will be copied.  Always NUL terminates (unless siz == 0).
 129  * Returns strlen(src); if retval >= siz, truncation occurred.
 130  */
 131 size_t strlcpy(char *dst, const char *src, size_t siz)
 132 {
 133         char *d = dst;
 134         const char *s = src;
 135         size_t n = siz;
 136
 137         /* Copy as many bytes as will fit */
 138         if (n != 0 && --n != 0) {
 139                 do {
 140                         if ((*d++ = *s++) == 0)
 141                                 break;
 142                 } while (--n != 0);
 143         }
 144
 145         /* Not enough room in dst, add NUL and traverse rest of src */
 146         if (n == 0) {
 147                 if (siz != 0)
 148                         *d = '\0';              /* NUL-terminate dst */
 149                 while (*s++)
 150                         ;
 151         }
 152
 153         return (s - src - 1);   /* count does not include NUL */
 154 }
 155