example/common.c

   1 /*
   2  * 2008+ Copyright (c) Evgeniy Polyakov <zbr@ioremap.net>
   3  * All rights reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  */
  15
  16 #include <sys/types.h>
  17 #include <sys/stat.h>
  18 #include <sys/socket.h>
  19 #include <sys/time.h>
  20 #include <sys/syscall.h>
  21
  22 #include <ctype.h>
  23 #include <fcntl.h>
  24 #include <errno.h>
  25 #include <pthread.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <syslog.h>
  30 #include <time.h>
  31 #include <unistd.h>
  32
  33 #include <netinet/in.h>
  34
  35 #include <elliptics/packet.h>
  36 #include <elliptics/interface.h>
  37
  38 #include "common.h"
  39
  40 #define DNET_CONF_COMMENT       '#'
  41 #define DNET_CONF_DELIM         '='
  42 #define DNET_CONF_TIME_DELIM    '.'
  43
  44 int dnet_parse_groups(char *value, int **groupsp)
  45 {
  46         int len = strlen(value), i, num = 0, start = 0, pos = 0;
  47         char *ptr = value;
  48         int *groups;
  49
  50         if (sscanf(value, "auto%d", &num) == 1) {
  51                 *groupsp = NULL;
  52                 return num;
  53         }
  54
  55         for (i=0; i<len; ++i) {
  56                 if (value[i] == DNET_CONF_ADDR_DELIM)
  57                         start = 0;
  58                 else if (!start) {
  59                         start = 1;
  60                         num++;
  61                 }
  62         }
  63
  64         if (!num) {
  65                 fprintf(stderr, "no groups found\n");
  66                 return -ENOENT;
  67         }
  68
  69         groups = malloc(sizeof(int) * num);
  70         if (!groups)
  71                 return -ENOMEM;
  72
  73         memset(groups, 0, num * sizeof(int));
  74
  75         start = 0;
  76         for (i=0; i<len; ++i) {
  77                 if (value[i] == DNET_CONF_ADDR_DELIM) {
  78                         value[i] = '\0';
  79                         if (start) {
  80                                 groups[pos] = atoi(ptr);
  81                                 pos++;
  82                                 start = 0;
  83                         }
  84                 } else if (!start) {
  85                         ptr = &value[i];
  86                         start = 1;
  87                 }
  88         }
  89
  90         if (start) {
  91                 groups[pos] = atoi(ptr);
  92                 pos++;
  93         }
  94
  95         *groupsp = groups;
  96         return pos;
  97 }
  98
  99 int dnet_parse_numeric_id(char *value, unsigned char *id)
 100 {
 101         unsigned char ch[5];
 102         unsigned int i, len = strlen(value);
 103
 104         memset(id, 0, DNET_ID_SIZE);
 105
 106         if (len/2 > DNET_ID_SIZE)
 107                 len = DNET_ID_SIZE * 2;
 108
 109         ch[0] = '0';
 110         ch[1] = 'x';
 111         ch[4] = '\0';
 112         for (i=0; i<len / 2; i++) {
 113                 ch[2] = value[2*i + 0];
 114                 ch[3] = value[2*i + 1];
 115
 116                 id[i] = (unsigned char)strtol((const char *)ch, NULL, 16);
 117         }
 118
 119         if (len & 1) {
 120                 ch[2] = value[2*i + 0];
 121                 ch[3] = '0';
 122
 123                 id[i] = (unsigned char)strtol((const char *)ch, NULL, 16);
 124         }
 125
 126         return 0;
 127 }
 128
 129 void dnet_common_log(void *priv, int level, const char *msg)
 130 {
 131         char str[64];
 132         struct tm tm;
 133         struct timeval tv;
 134         FILE *stream = priv;
 135
 136         if (!stream)
 137                 stream = stdout;
 138
 139         gettimeofday(&tv, NULL);
 140         localtime_r((time_t *)&tv.tv_sec, &tm);
 141         strftime(str, sizeof(str), "%F %R:%S", &tm);
 142
 143         fprintf(stream, "%s.%06lu %ld/%4d %1d: %s", str, tv.tv_usec, dnet_get_id(), getpid(), level, msg);
 144         fflush(stream);
 145 }
 146
 147 void dnet_syslog(void *priv __attribute__ ((unused)), int level, const char *msg)
 148 {
 149         int prio = LOG_DEBUG;
 150         char str[64];
 151         struct tm tm;
 152         struct timeval tv;
 153
 154         if (level == DNET_LOG_ERROR)
 155                 prio = LOG_ERR;
 156         if (level == DNET_LOG_INFO)
 157                 prio = LOG_INFO;
 158
 159         gettimeofday(&tv, NULL);
 160         localtime_r((time_t *)&tv.tv_sec, &tm);
 161         strftime(str, sizeof(str), "%F %R:%S", &tm);
 162
 163         syslog(prio, "%s.%06lu %ld/%4d %1x: %s", str, tv.tv_usec, dnet_get_id(), getpid(), level, msg);
 164 }
 165
 166 int dnet_common_add_remote_addr(struct dnet_node *n, struct dnet_config *main_cfg, char *orig_addr)
 167 {
 168         char *a;
 169         char *addr, *p;
 170         int added = 0, err;
 171         struct dnet_config cfg;
 172
 173         if (!orig_addr)
 174                 return 0;
 175
 176         a = strdup(orig_addr);
 177         if (!a) {
 178                 err = -ENOMEM;
 179                 goto err_out_exit;
 180         }
 181
 182         addr = a;
 183
 184         while (addr) {
 185                 p = strchr(addr, ' ');
 186                 if (p)
 187                         *p++ = '\0';
 188
 189                 memcpy(&cfg, main_cfg, sizeof(struct dnet_config));
 190
 191                 err = dnet_parse_addr(addr, &cfg);
 192                 if (err) {
 193                         dnet_log_raw(n, DNET_LOG_ERROR, "Failed to parse addr '%s': %d.\n", addr, err);
 194                         goto next;
 195                 }
 196
 197                 err = dnet_add_state(n, &cfg);
 198                 if (err)
 199                         goto next;
 200
 201                 added++;
 202
 203                 if (!p)
 204                         break;
 205
 206 next:
 207                 addr = p;
 208
 209                 while (addr && *addr && isspace(*addr))
 210                         addr++;
 211         }
 212
 213         free(a);
 214
 215         if (!added) {
 216                 err = 0;
 217                 dnet_log_raw(n, DNET_LOG_ERROR, "No remote addresses added. Continue to work though.\n");
 218                 goto err_out_exit;
 219         }
 220
 221         return 0;
 222
 223 err_out_exit:
 224         return err;
 225 }
 226
 227 int dnet_common_prepend_data(struct timespec *ts, uint64_t size, void *buf, int *bufsize)
 228 {
 229         void *orig = buf;
 230         struct dnet_common_embed *e = buf;
 231         uint64_t *edata = (uint64_t *)e->data;
 232
 233         if (*bufsize < (int)(sizeof(struct dnet_common_embed) + sizeof(uint64_t)) * 2)
 234                 return -ENOBUFS;
 235
 236         e->size = sizeof(uint64_t) * 2;
 237         e->type = DNET_FCGI_EMBED_TIMESTAMP;
 238         e->flags = 0;
 239         dnet_common_convert_embedded(e);
 240
 241         edata[0] = dnet_bswap64(ts->tv_sec);
 242         edata[1] = dnet_bswap64(ts->tv_nsec);
 243
 244         buf += sizeof(struct dnet_common_embed) + sizeof(uint64_t) * 2;
 245
 246         e = buf;
 247         e->size = size;
 248         e->type = DNET_FCGI_EMBED_DATA;
 249         e->flags = 0;
 250         dnet_common_convert_embedded(e);
 251
 252         buf += sizeof(struct dnet_common_embed);
 253
 254         *bufsize = buf - orig;
 255         return 0;
 256 }
 257
 258 #define dnet_map_log(n, level, fmt, a...) do { if ((n)) dnet_log_raw((n), level, fmt, ##a); else fprintf(stderr, fmt, ##a); } while (0)
 259
 260 int dnet_map_history(struct dnet_node *n, char *file, struct dnet_history_map *map)
 261 {
 262         int err;
 263         struct stat st;
 264
 265         map->fd = open(file, O_RDWR | O_CLOEXEC);
 266         if (map->fd < 0) {
 267                 err = -errno;
 268                 dnet_map_log(n, DNET_LOG_ERROR, "Failed to open history file '%s': %s [%d].\n",
 269                                 file, strerror(errno), errno);
 270                 goto err_out_exit;
 271         }
 272
 273         err = fstat(map->fd, &st);
 274         if (err) {
 275                 err = -errno;
 276                 dnet_map_log(n, DNET_LOG_ERROR, "Failed to stat history file '%s': %s [%d].\n",
 277                                 file, strerror(errno), errno);
 278                 goto err_out_close;
 279         }
 280
 281         if (st.st_size % (int)sizeof(struct dnet_history_entry)) {
 282                 dnet_map_log(n, DNET_LOG_ERROR, "Corrupted history file '%s', "
 283                                 "its size %llu must be multiple of %zu.\n",
 284                                 file, (unsigned long long)st.st_size,
 285                                 sizeof(struct dnet_history_entry));
 286                 err = -EINVAL;
 287                 goto err_out_close;
 288         }
 289         map->size = st.st_size;
 290
 291         map->ent = mmap(NULL, map->size, PROT_READ | PROT_WRITE, MAP_SHARED, map->fd, 0);
 292         if (map->ent == MAP_FAILED) {
 293                 err = -errno;
 294                 dnet_map_log(n, DNET_LOG_ERROR, "Failed to mmap history file '%s': %s [%d].\n",
 295                                 file, strerror(errno), errno);
 296                 goto err_out_close;
 297         }
 298
 299         map->num = map->size / sizeof(struct dnet_history_entry);
 300
 301         dnet_map_log(n, DNET_LOG_NOTICE, "Mapped %ld entries in '%s'.\n", map->num, file);
 302
 303         return 0;
 304
 305 err_out_close:
 306         close(map->fd);
 307 err_out_exit:
 308         return err;
 309 }
 310
 311 void dnet_unmap_history(struct dnet_node *n __attribute((unused)), struct dnet_history_map *map)
 312 {
 313         munmap(map->ent, map->size);
 314         close(map->fd);
 315 }
 316
 317 struct dnet_meta * dnet_meta_search_cust(struct dnet_meta_container *mc, uint32_t type)
 318 {
 319         void *data = mc->data;
 320         uint32_t size = mc->size;
 321         struct dnet_meta m, *found = NULL;
 322
 323         while (size) {
 324                 if (size < sizeof(struct dnet_meta)) {
 325                         fprintf(stderr, "Metadata size %u is too small, min %zu, searching for 0x%x.\n",
 326                                         size, sizeof(struct dnet_meta), type);
 327                         break;
 328                 }
 329
 330                 m = *(struct dnet_meta *)data;
 331                 dnet_convert_meta(&m);
 332
 333                 if (m.size + sizeof(struct dnet_meta) > size) {
 334                         fprintf(stderr, "Metadata entry broken: entry size %u, type: 0x%x, struct size: %zu, "
 335                                         "total size left: %u, searching for 0x%x.\n",
 336                                         m.size, m.type, sizeof(struct dnet_meta), size, type);
 337                         break;
 338                 }
 339
 340                 if (m.type == type) {
 341                         found = data;
 342                         break;
 343                 }
 344
 345                 data += m.size + sizeof(struct dnet_meta);
 346                 size -= m.size + sizeof(struct dnet_meta);
 347         }
 348
 349         return found;
 350 }
 351
 352 int dnet_background(void)
 353 {
 354         pid_t pid;
 355         int fd;
 356
 357         pid = fork();
 358         if (pid == -1) {
 359                 fprintf(stderr, "Failed to fork to background: %s.\n", strerror(errno));
 360                 return -1;
 361         }
 362
 363         if (pid != 0) {
 364                 printf("Daemon pid: %d.\n", pid);
 365                 exit(0);
 366         }
 367
 368         setsid();
 369
 370         close(0);
 371         close(1);
 372         close(2);
 373
 374         fd = open("/dev/null", O_RDWR);
 375         if (fd < 0) {
 376                 fd = -errno;
 377                 fprintf(stderr, "Can not open /dev/null: %d\n", fd);
 378                 exit(fd);
 379         }
 380
 381         dup2(fd, 0);
 382         dup2(fd, 1);
 383         dup2(fd, 2);
 384
 385         return 0;
 386 }
 387