nmdb/main.c

   1
   2 #include <stdio.h>              /* printf() */
   3 #include <unistd.h>             /* malloc(), fork() and getopt() */
   4 #include <stdlib.h>             /* atoi() */
   5 #include <sys/types.h>          /* for pid_t */
   6 #include <string.h>             /* for strcpy() and strlen() */
   7 #include <pthread.h>            /* for pthread_t */
   8
   9 #include "cache.h"
  10 #include "net.h"
  11 #include "dbloop.h"
  12 #include "common.h"
  13 #include "net-const.h"
  14 #include "log.h"
  15 #include "stats.h"
  16
  17 #define DEFDBNAME "database"
  18
  19
  20 /* Define the common structures that are used throughout the whole server. */
  21 struct settings settings;
  22 struct stats stats;
  23 struct cache *cache_table;
  24 struct queue *op_queue;
  25
  26
  27 static void help(void) {
  28         char h[] = \
  29           "nmdb [options]\n"
  30           "  -d dbpath  database path ('database', must be created with dpmgr)\n"
  31           "  -l lower   TIPC lower port number (10)\n"
  32           "  -L upper   TIPC upper port number (= lower)\n"
  33           "  -t port    TCP listening port (26010)\n"
  34           "  -T addr    TCP listening address (all local addresses)\n"
  35           "  -u port    UDP listening port (26010)\n"
  36           "  -U addr    UDP listening address (all local addresses)\n"
  37           "  -s port    SCTP listening port (26010)\n"
  38           "  -S addr    SCTP listening address (all local addresses)\n"
  39           "  -c nobj    max. number of objects to be cached, in thousands (128)\n"
  40           "  -o fname   log to the given file (defaults to stdout).\n"
  41           "  -f         don't fork and stay in the foreground\n"
  42           "  -p         enable passive mode, for redundancy purposes (read docs.)\n"
  43           "  -h         show this help\n"
  44           "\n"
  45           "Please report bugs to Alberto Bertogli (albertito@gmail.com)\n"
  46           "\n";
  47         printf("%s", h);
  48 }
  49
  50
  51 static int load_settings(int argc, char **argv)
  52 {
  53         int c;
  54
  55         settings.tipc_lower = -1;
  56         settings.tipc_upper = -1;
  57         settings.tcp_addr = NULL;
  58         settings.tcp_port = -1;
  59         settings.udp_addr = NULL;
  60         settings.udp_port = -1;
  61         settings.sctp_addr = NULL;
  62         settings.sctp_port = -1;
  63         settings.numobjs = -1;
  64         settings.foreground = 0;
  65         settings.passive = 0;
  66         settings.logfname = "-";
  67
  68         settings.dbname = malloc(strlen(DEFDBNAME) + 1);
  69         strcpy(settings.dbname, DEFDBNAME);
  70
  71         while ((c = getopt(argc, argv, "d:l:L:t:T:u:U:c:o:fph?")) != -1) {
  72                 switch(c) {
  73                 case 'd':
  74                         free(settings.dbname);
  75                         settings.dbname = malloc(strlen(optarg) + 1);
  76                         strcpy(settings.dbname, optarg);
  77                         break;
  78
  79                 case 'l':
  80                         settings.tipc_lower = atoi(optarg);
  81                         break;
  82                 case 'L':
  83                         settings.tipc_upper = atoi(optarg);
  84                         break;
  85
  86                 case 't':
  87                         settings.tcp_port = atoi(optarg);
  88                         break;
  89                 case 'T':
  90                         settings.tcp_addr = optarg;
  91                         break;
  92
  93                 case 'u':
  94                         settings.udp_port = atoi(optarg);
  95                         break;
  96                 case 'U':
  97                         settings.udp_addr = optarg;
  98                         break;
  99
 100                 case 's':
 101                         settings.sctp_port = atoi(optarg);
 102                         break;
 103                 case 'S':
 104                         settings.sctp_addr = optarg;
 105                         break;
 106
 107                 case 'c':
 108                         settings.numobjs = atoi(optarg) * 1024;
 109                         break;
 110
 111                 case 'o':
 112                         settings.logfname = malloc(strlen(optarg) + 1);
 113                         strcpy(settings.logfname, optarg);
 114                         break;
 115
 116                 case 'f':
 117                         settings.foreground = 1;
 118                         break;
 119                 case 'p':
 120                         settings.passive = 1;
 121                         break;
 122
 123                 case 'h':
 124                 case '?':
 125                         help();
 126                         return 0;
 127                 default:
 128                         printf("Unknown parameter '%c'\n", c);
 129                         return 0;
 130                 }
 131         }
 132
 133         if (settings.tipc_lower == -1)
 134                 settings.tipc_lower = TIPC_SERVER_INST;
 135         if (settings.tipc_upper == -1)
 136                 settings.tipc_upper = settings.tipc_lower;
 137         if (settings.tcp_addr == NULL)
 138                 settings.tcp_addr = TCP_SERVER_ADDR;
 139         if (settings.tcp_port == -1)
 140                 settings.tcp_port = TCP_SERVER_PORT;
 141         if (settings.udp_addr == NULL)
 142                 settings.udp_addr = UDP_SERVER_ADDR;
 143         if (settings.udp_port == -1)
 144                 settings.udp_port = UDP_SERVER_PORT;
 145         if (settings.sctp_addr == NULL)
 146                 settings.sctp_addr = SCTP_SERVER_ADDR;
 147         if (settings.sctp_port == -1)
 148                 settings.sctp_port = SCTP_SERVER_PORT;
 149         if (settings.numobjs == -1)
 150                 settings.numobjs = 128 * 1024;
 151
 152         return 1;
 153 }
 154
 155
 156 int main(int argc, char **argv)
 157 {
 158         struct cache *cd;
 159         struct queue *q;
 160         db_t *db;
 161         pid_t pid;
 162         pthread_t *dbthread;
 163
 164         if (!load_settings(argc, argv))
 165                 return 1;
 166
 167         if (!log_init()) {
 168                 perror("Error opening log file");
 169                 return 1;
 170         }
 171
 172         stats_init(&stats);
 173
 174         cd = cache_create(settings.numobjs, 0);
 175         if (cd == NULL) {
 176                 errlog("Error creating cache");
 177                 return 1;
 178         }
 179         cache_table = cd;
 180
 181         q = queue_create();
 182         if (q == NULL) {
 183                 errlog("Error creating queue");
 184                 return 1;
 185         }
 186         op_queue = q;
 187
 188         db = db_open(settings.dbname, 0);
 189         if (db == NULL) {
 190                 errlog("Error opening DB");
 191                 return 1;
 192         }
 193
 194         if (!settings.foreground) {
 195                 pid = fork();
 196                 if (pid > 0) {
 197                         /* parent exits */
 198                         return 0;
 199                 } else if (pid < 0) {
 200                         errlog("Error in fork()");
 201                         return 1;
 202                 }
 203
 204                 close(0);
 205                 setsid();
 206         }
 207
 208         wlog("Starting nmdb\n");
 209
 210         dbthread = db_loop_start(db);
 211
 212         net_loop();
 213
 214         db_loop_stop(dbthread);
 215
 216         db_close(db);
 217
 218         queue_free(q);
 219
 220         cache_free(cd);
 221
 222         return 0;
 223 }
 224