Line data Source code
1 : /*
2 : * SPDX-License-Identifier: MPL-2.0
3 : *
4 : * This Source Code Form is subject to the terms of the Mozilla Public
5 : * License, v. 2.0. If a copy of the MPL was not distributed with this
6 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7 : *
8 : * Copyright 2024, 2025 MonetDB Foundation;
9 : * Copyright August 2008 - 2023 MonetDB B.V.;
10 : * Copyright 1997 - July 2008 CWI.
11 : */
12 :
13 : #include "monetdb_config.h"
14 : #include <string.h> /* strerror */
15 : #include <locale.h>
16 : #include "monet_options.h"
17 : #include "mal.h"
18 : #include "mal_session.h"
19 : #include "mal_import.h"
20 : #include "mal_client.h"
21 : #include "mal_function.h"
22 : #include "monet_version.h"
23 : #include "mal_authorize.h"
24 : #include "msabaoth.h"
25 : #include "mutils.h"
26 :
27 : #ifdef HAVE_GETOPT_H
28 : #include "getopt.h"
29 : #endif
30 :
31 : #ifdef _MSC_VER
32 : #include <Psapi.h> /* for GetModuleFileName */
33 : #include <crtdbg.h> /* for _CRT_ERROR, _CRT_ASSERT */
34 : #endif
35 :
36 : #ifdef _CRTDBG_MAP_ALLOC
37 : /* Windows only:
38 : our definition of new and delete clashes with the one if
39 : _CRTDBG_MAP_ALLOC is defined.
40 : */
41 : #undef _CRTDBG_MAP_ALLOC
42 : #endif
43 :
44 : /* NEEDED? */
45 : #if defined(_MSC_VER) && defined(__cplusplus)
46 : #include <eh.h>
47 : void
48 : mserver_abort()
49 : {
50 : fprintf(stderr, "\n! mserver_abort() was called by terminate(). !\n");
51 : fflush(stderr);
52 : exit(0);
53 : }
54 : #endif
55 :
56 : #ifdef _MSC_VER
57 : static void
58 : mserver_invalid_parameter_handler(const wchar_t *expression,
59 : const wchar_t *function, const wchar_t *file,
60 : unsigned int line, uintptr_t reserved)
61 : {
62 : (void) expression;
63 : (void) function;
64 : (void) file;
65 : (void) line;
66 : (void) reserved;
67 : /* the essential bit of this function is that it returns:
68 : * we don't want the server to quit when a function is called
69 : * with an invalid parameter */
70 : }
71 : #endif
72 :
73 : static _Noreturn void usage(char *prog, int xit);
74 :
75 : static void
76 0 : usage(char *prog, int xit)
77 : {
78 0 : fprintf(stderr, "Usage: %s [options]\n", prog);
79 0 : fprintf(stderr, " --dbpath=<directory> Specify database location\n");
80 0 : fprintf(stderr, " --dbextra=<directory> Directory for transient BATs\n");
81 0 : fprintf(stderr, " --dbtrace=<file> File for produced traces\n");
82 0 : fprintf(stderr, " --in-memory Run database in-memory only\n");
83 0 : fprintf(stderr, " --config=<config_file> Use config_file to read options from\n");
84 0 : fprintf(stderr, " --single-user Allow only one user at a time\n");
85 0 : fprintf(stderr, " --readonly Safeguard database\n");
86 0 : fprintf(stderr, " --set <option>=<value> Set configuration option\n");
87 0 : fprintf(stderr, " --loadmodule=<module> Load extra <module> from lib/monetdb5\n");
88 0 : fprintf(stderr, " --without-geom Do not enable geom module\n");
89 0 : fprintf(stderr, " --help Print this list of options\n");
90 0 : fprintf(stderr, " --version Print version and compile time info\n");
91 :
92 0 : fprintf(stderr, "The debug, testing & trace options:\n");
93 0 : fprintf(stderr, " --algorithms\n");
94 0 : fprintf(stderr, " --forcemito\n");
95 0 : fprintf(stderr, " --heaps\n");
96 0 : fprintf(stderr, " --io\n");
97 0 : fprintf(stderr, " --memory\n");
98 0 : fprintf(stderr, " --modules\n");
99 0 : fprintf(stderr, " --performance\n");
100 0 : fprintf(stderr, " --properties\n");
101 0 : fprintf(stderr, " --threads\n");
102 0 : fprintf(stderr, " --transactions\n");
103 0 : fprintf(stderr, " --debug=<bitmask>\n");
104 :
105 0 : exit(xit);
106 : }
107 :
108 : /*
109 : * Collect some global system properties to relate performance results later
110 : */
111 : static void
112 345 : monet_hello(void)
113 : {
114 345 : double sz_mem_h;
115 345 : const char qc[] = " kMGTPE";
116 345 : int qi = 0;
117 :
118 345 : printf("# MonetDB 5 server v%s", GDKversion());
119 : {
120 : #ifdef MONETDB_RELEASE
121 : printf(" (%s)", MONETDB_RELEASE);
122 : #else
123 345 : const char *rev = mercurial_revision();
124 345 : if (strcmp(rev, "Unknown") != 0)
125 0 : printf(" (hg id: %s)", rev);
126 : #endif
127 : }
128 : #ifndef MONETDB_RELEASE
129 345 : printf("\n# This is an unreleased version");
130 : #endif
131 345 : printf("\n# Serving database '%s', using %d thread%s\n",
132 : GDKgetenv("gdk_dbname"), GDKnr_threads,
133 345 : (GDKnr_threads != 1) ? "s" : "");
134 345 : printf("# Compiled for %s/%zubit%s\n", HOST, sizeof(ptr) * 8,
135 : #ifdef HAVE_HGE
136 : " with 128bit integers"
137 : #else
138 : ""
139 : #endif
140 : );
141 345 : sz_mem_h = (double) MT_npages() * MT_pagesize();
142 1380 : while (sz_mem_h >= 1000.0 && qi < 6) {
143 1035 : sz_mem_h /= 1024.0;
144 1035 : qi++;
145 : }
146 345 : printf("# Found %.3f %ciB available main-memory", sz_mem_h, qc[qi]);
147 345 : sz_mem_h = (double) GDK_mem_maxsize;
148 345 : qi = 0;
149 1380 : while (sz_mem_h >= 1000.0 && qi < 6) {
150 1035 : sz_mem_h /= 1024.0;
151 1035 : qi++;
152 : }
153 345 : printf(" of which we use %.3f %ciB\n", sz_mem_h, qc[qi]);
154 345 : if (GDK_vm_maxsize < GDK_VM_MAXSIZE) {
155 197 : sz_mem_h = (double) GDK_vm_maxsize;
156 197 : qi = 0;
157 788 : while (sz_mem_h >= 1000.0 && qi < 6) {
158 591 : sz_mem_h /= 1024.0;
159 591 : qi++;
160 : }
161 197 : printf("# Virtual memory usage limited to %.3f %ciB\n", sz_mem_h,
162 197 : qc[qi]);
163 : }
164 : #ifdef MONET_GLOBAL_DEBUG
165 : printf("# Database path:%s\n", GDKgetenv("gdk_dbpath"));
166 : printf("# Module path:%s\n", GDKgetenv("monet_mod_path"));
167 : #endif
168 345 : printf("# Copyright (c) 2024, 2025 MonetDB Foundation, all rights reserved\n");
169 345 : printf("# Visit https://www.monetdb.org/ for further information\n");
170 :
171 : // The properties shipped through the performance profiler
172 345 : (void) snprintf(monet_characteristics, sizeof(monet_characteristics),
173 : "{\n" "\"version\":\"%s\",\n" "\"release\":\"%s\",\n"
174 : "\"host\":\"%s\",\n" "\"threads\":\"%d\",\n"
175 : "\"memory\":\"%.3f %cB\",\n" "\"oid\":\"%zu\",\n"
176 : "\"packages\":["
177 : #ifdef HAVE_HGE
178 : "\"huge\""
179 : #endif
180 : "]\n}", GDKversion(),
181 : #ifdef MONETDB_RELEASE
182 : MONETDB_RELEASE,
183 : #else
184 : "unreleased",
185 : #endif
186 345 : HOST, GDKnr_threads, sz_mem_h, qc[qi], sizeof(oid) * 8);
187 345 : fflush(stdout);
188 345 : }
189 :
190 : static str
191 347 : absolute_path(const char *s)
192 : {
193 347 : if (!MT_path_absolute(s)) {
194 0 : str ret = (str) GDKmalloc(strlen(s) + strlen(monet_cwd) + 2);
195 :
196 0 : if (ret)
197 0 : sprintf(ret, "%s%c%s", monet_cwd, DIR_SEP, s);
198 0 : return ret;
199 : }
200 347 : return GDKstrdup(s);
201 : }
202 :
203 : #define BSIZE 8192
204 :
205 : static int
206 347 : monet_init(opt *set, int setlen, bool embedded)
207 : {
208 : /* check that library that we're linked against is compatible with
209 : * the one we were compiled with */
210 347 : int maj, min, patch;
211 347 : const char *version = GDKlibversion();
212 347 : sscanf(version, "%d.%d.%d", &maj, &min, &patch);
213 347 : if (maj != GDK_VERSION_MAJOR || min < GDK_VERSION_MINOR) {
214 0 : fprintf(stderr,
215 : "Linked GDK library not compatible with the one this was compiled with\n");
216 0 : fprintf(stderr, "Linked version: %s, compiled version: %s\n", version,
217 : GDK_VERSION);
218 0 : return 0;
219 : }
220 347 : version = mal_version();
221 347 : sscanf(version, "%d.%d.%d", &maj, &min, &patch);
222 347 : if (maj != MONETDB5_VERSION_MAJOR || min < MONETDB5_VERSION_MINOR) {
223 0 : fprintf(stderr,
224 : "Linked MonetDB5 library not compatible with the one this was compiled with\n");
225 0 : fprintf(stderr, "Linked version: %s, compiled version: %s\n", version,
226 : MONETDB5_VERSION);
227 0 : return 0;
228 : }
229 :
230 : /* determine Monet's kernel settings */
231 347 : if (GDKinit(set, setlen, embedded, mercurial_revision()) != GDK_SUCCEED)
232 : return 0;
233 :
234 : #ifdef HAVE_SETSID
235 345 : setsid();
236 : #endif
237 345 : monet_hello();
238 345 : return 1;
239 : }
240 :
241 : static void
242 : emergencyBreakpoint(void)
243 : {
244 : /* just a handle to break after system initialization for GDB */
245 : }
246 :
247 : static volatile sig_atomic_t interrupted = 0;
248 : static volatile sig_atomic_t usr1_interrupted = 0;
249 :
250 : #ifdef _MSC_VER
251 : static BOOL WINAPI
252 : winhandler(DWORD type)
253 : {
254 : (void) type;
255 : interrupted = 1;
256 : return TRUE;
257 : }
258 : #else
259 : static void
260 344 : handler(int sig)
261 : {
262 344 : (void) sig;
263 344 : interrupted = 1;
264 344 : }
265 : static void
266 118 : handler_usr1(int sig)
267 : {
268 118 : (void) sig;
269 118 : usr1_interrupted = 1;
270 118 : }
271 : #endif
272 :
273 : int
274 : #ifdef _MSC_VER
275 : wmain(int argc, wchar_t **argv)
276 : #else
277 348 : main(int argc, char **av)
278 : #endif
279 : {
280 : /* make sure stdout is line buffered, even when not to a terminal;
281 : * note, on Windows _IOLBF is interpreted as _IOFBF, but all
282 : * relevant calls to print to stdout are followed by a fflush
283 : * anyway */
284 348 : setvbuf(stdout, NULL, _IOLBF, BUFSIZ);
285 : #ifdef _MSC_VER
286 : char **av = malloc((argc + 1) * sizeof(char *));
287 : if (av == NULL) {
288 : fprintf(stderr, "cannot allocate memory for argument conversion\n");
289 : exit(1);
290 : }
291 : for (int i = 0; i < argc; i++) {
292 : if ((av[i] = utf16toutf8(argv[i])) == NULL) {
293 : fprintf(stderr, "cannot convert argument to UTF-8\n");
294 : exit(1);
295 : }
296 : }
297 : av[argc] = NULL;
298 : #endif
299 348 : char *prog = *av;
300 348 : opt *set = NULL;
301 348 : unsigned grpdebug = 0, debug = 0;
302 348 : int setlen = 0;
303 348 : str err = MAL_SUCCEED;
304 348 : char prmodpath[FILENAME_MAX];
305 348 : const char *modpath = NULL;
306 348 : char *binpath = NULL;
307 348 : char *dbpath = NULL;
308 348 : char *dbextra = NULL;
309 348 : char *dbtrace = NULL;
310 348 : bool inmemory = false;
311 348 : bool readpwdxit = false;
312 348 : static const struct option long_options[] = {
313 : {"config", required_argument, NULL, 'c'},
314 : {"dbextra", required_argument, NULL, 0},
315 : {"dbpath", required_argument, NULL, 0},
316 : {"dbtrace", required_argument, NULL, 0},
317 : {"debug", optional_argument, NULL, 'd'},
318 : {"help", no_argument, NULL, '?'},
319 : {"in-memory", no_argument, NULL, 0},
320 : {"readonly", no_argument, NULL, 'r'},
321 : {"set", required_argument, NULL, 's'},
322 : {"single-user", no_argument, NULL, 0},
323 : {"version", no_argument, NULL, 0},
324 :
325 : {"algorithms", no_argument, NULL, 0},
326 : {"forcemito", no_argument, NULL, 0},
327 : {"heaps", no_argument, NULL, 0},
328 : {"io", no_argument, NULL, 0},
329 : {"memory", no_argument, NULL, 0},
330 : {"modules", no_argument, NULL, 0},
331 : {"performance", no_argument, NULL, 0},
332 : {"properties", no_argument, NULL, 0},
333 : {"threads", no_argument, NULL, 0},
334 : {"transactions", no_argument, NULL, 0},
335 :
336 : {"loadmodule", required_argument, NULL, 0},
337 : {"without-geom", no_argument, NULL, 0},
338 :
339 : {"read-password-initialize-and-exit", no_argument, NULL, 0},
340 : {"process-wal-and-exit", no_argument, NULL, 0},
341 : {"clean-BBP", no_argument, NULL, 0},
342 :
343 : {NULL, 0, NULL, 0}
344 : };
345 :
346 : #define MAX_MODULES 32
347 348 : char *modules[MAX_MODULES + 1];
348 348 : int mods = 0;
349 :
350 348 : modules[mods++] = "sql";
351 348 : modules[mods++] = "generator";
352 : #ifdef HAVE_GEOM
353 348 : modules[mods++] = "geom";
354 : #endif
355 : #ifdef HAVE_LIBR
356 : /* TODO check for used */
357 348 : modules[mods++] = "rapi";
358 : #endif
359 : #ifdef HAVE_LIBPY3
360 : /* TODO check for used */
361 348 : modules[mods++] = "pyapi3";
362 : #endif
363 : #ifdef HAVE_CUDF
364 348 : modules[mods++] = "capi";
365 : #endif
366 : #ifdef HAVE_FITS
367 348 : modules[mods++] = "fits";
368 : #endif
369 : #ifdef HAVE_NETCDF
370 348 : modules[mods++] = "netcdf";
371 : #endif
372 348 : modules[mods++] = "csv";
373 348 : modules[mods++] = "monetdb_loader";
374 : #ifdef HAVE_SHP
375 348 : modules[mods++] = "shp";
376 : #endif
377 :
378 : #if defined(_MSC_VER) && defined(__cplusplus)
379 : set_terminate(mserver_abort);
380 : #endif
381 : #ifdef _MSC_VER
382 : _CrtSetReportMode(_CRT_ERROR, 0);
383 : _CrtSetReportMode(_CRT_ASSERT, 0);
384 : _set_invalid_parameter_handler(mserver_invalid_parameter_handler);
385 : #ifdef _TWO_DIGIT_EXPONENT
386 : _set_output_format(_TWO_DIGIT_EXPONENT);
387 : #endif
388 : #endif
389 348 : if (setlocale(LC_CTYPE, "") == NULL) {
390 0 : fprintf(stderr, "cannot set locale\n");
391 0 : exit(1);
392 : }
393 :
394 348 : if (MT_getcwd(monet_cwd, FILENAME_MAX - 1) == NULL) {
395 0 : perror("pwd");
396 0 : fprintf(stderr, "monet_init: could not determine current directory\n");
397 0 : exit(-1);
398 : }
399 :
400 : /* retrieve binpath early (before monet_init) because some
401 : * implementations require the working directory when the binary was
402 : * called */
403 348 : binpath = get_bin_path();
404 :
405 348 : if (!(setlen = mo_builtin_settings(&set)))
406 0 : usage(prog, -1);
407 :
408 3419 : for (;;) {
409 3767 : int option_index = 0;
410 :
411 3767 : int c = getopt_long(argc, av, "c:d::rs:t::v::?",
412 : long_options, &option_index);
413 :
414 3767 : if (c == -1)
415 : break;
416 :
417 3420 : switch (c) {
418 901 : case 0:
419 901 : if (strcmp(long_options[option_index].name, "in-memory") == 0) {
420 : inmemory = true;
421 : break;
422 : }
423 901 : if (strcmp(long_options[option_index].name, "dbpath") == 0) {
424 347 : size_t optarglen = strlen(optarg);
425 : /* remove trailing directory separator */
426 347 : while (optarglen > 0
427 347 : && (optarg[optarglen - 1] == '/'
428 347 : || optarg[optarglen - 1] == '\\'))
429 0 : optarg[--optarglen] = '\0';
430 347 : dbpath = absolute_path(optarg);
431 347 : if (dbpath == NULL)
432 0 : fprintf(stderr,
433 : "#error: can not allocate memory for dbpath\n");
434 : else
435 347 : setlen = mo_add_option(&set, setlen, opt_cmdline,
436 : "gdk_dbpath", dbpath);
437 : break;
438 : }
439 554 : if (strcmp(long_options[option_index].name, "dbextra") == 0) {
440 191 : if (dbextra)
441 0 : fprintf(stderr,
442 : "#warning: ignoring multiple --dbextra arguments\n");
443 : else
444 191 : dbextra = optarg;
445 : break;
446 : }
447 :
448 363 : if (strcmp(long_options[option_index].name, "dbtrace") == 0) {
449 0 : size_t optarglen = strlen(optarg);
450 : /* remove trailing directory separator */
451 0 : while (optarglen > 0
452 0 : && (optarg[optarglen - 1] == '/'
453 0 : || optarg[optarglen - 1] == '\\'))
454 0 : optarg[--optarglen] = '\0';
455 0 : dbtrace = absolute_path(optarg);
456 0 : if (dbtrace == NULL)
457 0 : fprintf(stderr,
458 : "#error: can not allocate memory for dbtrace\n");
459 : else
460 0 : setlen = mo_add_option(&set, setlen, opt_cmdline,
461 : "gdk_dbtrace", dbtrace);
462 : break;
463 : }
464 :
465 363 : if (strcmp(long_options[option_index].name, "single-user") == 0) {
466 0 : setlen = mo_add_option(&set, setlen, opt_cmdline,
467 : "gdk_single_user", "yes");
468 0 : break;
469 : }
470 363 : if (strcmp(long_options[option_index].name, "version") == 0) {
471 1 : monet_version();
472 1 : exit(0);
473 : }
474 : /* debugging options */
475 362 : if (strcmp(long_options[option_index].name, "algorithms") == 0) {
476 0 : grpdebug |= GRPalgorithms;
477 0 : break;
478 : }
479 362 : if (strcmp(long_options[option_index].name, "forcemito") == 0) {
480 348 : grpdebug |= GRPforcemito;
481 348 : break;
482 : }
483 14 : if (strcmp(long_options[option_index].name, "heaps") == 0) {
484 0 : grpdebug |= GRPheaps;
485 0 : break;
486 : }
487 14 : if (strcmp(long_options[option_index].name, "io") == 0) {
488 0 : grpdebug |= GRPio;
489 0 : break;
490 : }
491 14 : if (strcmp(long_options[option_index].name, "memory") == 0) {
492 0 : grpdebug |= GRPmemory;
493 0 : break;
494 : }
495 14 : if (strcmp(long_options[option_index].name, "modules") == 0) {
496 0 : grpdebug |= GRPmodules;
497 0 : break;
498 : }
499 14 : if (strcmp(long_options[option_index].name, "performance") == 0) {
500 0 : grpdebug |= GRPperformance;
501 0 : break;
502 : }
503 14 : if (strcmp(long_options[option_index].name, "properties") == 0) {
504 0 : grpdebug |= GRPproperties;
505 0 : break;
506 : }
507 14 : if (strcmp(long_options[option_index].name, "threads") == 0) {
508 0 : grpdebug |= GRPthreads;
509 0 : break;
510 : }
511 14 : if (strcmp(long_options[option_index].name, "transactions") == 0) {
512 0 : grpdebug |= GRPtransactions;
513 0 : break;
514 : }
515 14 : if (strcmp(long_options[option_index].name, "read-password-initialize-and-exit") == 0) {
516 : readpwdxit = true;
517 : break;
518 : }
519 14 : if (strcmp(long_options[option_index].name, "process-wal-and-exit") == 0) {
520 0 : setlen = mo_add_option(&set, setlen, opt_cmdline,
521 : "process-wal-and-exit", "yes");
522 0 : break;
523 : }
524 14 : if (strcmp(long_options[option_index].name, "clean-BBP") == 0) {
525 8 : setlen = mo_add_option(&set, setlen, opt_cmdline,
526 : "clean-BBP", "yes");
527 8 : break;
528 : }
529 6 : if (strcmp(long_options[option_index].name, "loadmodule") == 0) {
530 6 : if (mods < MAX_MODULES)
531 6 : modules[mods++] = optarg;
532 : else
533 0 : fprintf(stderr,
534 : "ERROR: maximum number of modules reached\n");
535 : break;
536 : }
537 0 : if (strcmp(long_options[option_index].name, "without-geom") == 0) {
538 0 : for (int i = 0; i < mods; i++) {
539 0 : if (strcmp(modules[i], "geom") == 0) {
540 0 : while (i + 1 < mods) {
541 0 : modules[i] = modules[i + 1];
542 0 : i++;
543 : }
544 0 : mods--;
545 0 : break;
546 : }
547 : }
548 : break;
549 : }
550 0 : usage(prog, -1);
551 : /* not reached */
552 0 : case 'c':
553 : /* coverity[var_deref_model] */
554 0 : setlen = mo_add_option(&set, setlen, opt_cmdline, "config", optarg);
555 0 : break;
556 694 : case 'd':
557 694 : if (optarg) {
558 694 : char *endarg;
559 694 : debug |= strtoul(optarg, &endarg, 10);
560 694 : if (*endarg != '\0') {
561 0 : fprintf(stderr, "ERROR: wrong format for --debug=%s\n",
562 : optarg);
563 0 : usage(prog, -1);
564 : }
565 : } else {
566 0 : debug |= CHECKMASK;
567 : }
568 : break;
569 3 : case 'r':
570 3 : setlen = mo_add_option(&set, setlen, opt_cmdline, "gdk_readonly",
571 : "yes");
572 3 : break;
573 1822 : case 's':{
574 : /* should add option to a list */
575 : /* coverity[var_deref_model] */
576 1822 : char *tmp = strchr(optarg, '=');
577 :
578 1822 : if (tmp) {
579 1822 : *tmp = '\0';
580 1822 : setlen = mo_add_option(&set, setlen, opt_cmdline, optarg,
581 1822 : tmp + 1);
582 : } else
583 0 : fprintf(stderr, "ERROR: wrong format %s\n", optarg);
584 : }
585 : break;
586 0 : case '?':
587 : /* a bit of a hack: look at the option that the
588 : current `c' is based on and see if we recognize
589 : it: if -? or --help, exit with 0, else with -1 */
590 0 : usage(prog, strcmp(av[optind - 1], "-?") == 0
591 0 : || strcmp(av[optind - 1], "--help") == 0 ? 0 : -1);
592 0 : default:
593 0 : fprintf(stderr,
594 : "ERROR: getopt returned character " "code '%c' 0%o\n", c,
595 : (unsigned) (uint8_t) c);
596 0 : usage(prog, -1);
597 : }
598 : }
599 :
600 347 : if (optind < argc)
601 0 : usage(prog, -1);
602 :
603 347 : if (!(setlen = mo_system_config(&set, setlen)))
604 0 : usage(prog, -1);
605 :
606 347 : if (debug)
607 347 : mo_print_options(set, setlen);
608 :
609 347 : if (dbpath && inmemory) {
610 0 : fprintf(stderr,
611 : "!ERROR: both dbpath and in-memory must not be set at the same time\n");
612 0 : exit(1);
613 : }
614 :
615 347 : if (inmemory && readpwdxit) {
616 0 : fprintf(stderr,
617 : "!ERROR: cannot have both in-memory and read-password-initialize-and-exit\n");
618 0 : exit(1);
619 : }
620 :
621 347 : if (inmemory) {
622 0 : if (BBPaddfarm(NULL, (1U << PERSISTENT) | (1U << TRANSIENT), true) !=
623 : GDK_SUCCEED) {
624 0 : fprintf(stderr, "!ERROR: cannot add in-memory farm\n");
625 0 : exit(1);
626 : }
627 : } else {
628 347 : if (dbpath == NULL) {
629 0 : dbpath = absolute_path(mo_find_option(set, setlen, "gdk_dbpath"));
630 0 : if (dbpath == NULL) {
631 0 : fprintf(stderr,
632 : "!ERROR: cannot allocate memory for database directory \n");
633 0 : exit(1);
634 : }
635 : }
636 347 : if (BBPaddfarm(dbpath, 1U << PERSISTENT, true) != GDK_SUCCEED
637 503 : || BBPaddfarm(dbextra ? dbextra : dbpath, 1U << TRANSIENT,
638 : true) != GDK_SUCCEED) {
639 0 : fprintf(stderr, "!ERROR: cannot add farm\n");
640 0 : exit(1);
641 : }
642 347 : GDKfree(dbpath);
643 : }
644 :
645 347 : if (dbtrace) {
646 : /* GDKcreatedir makes sure that all parent directories of dbtrace exist */
647 0 : if (!inmemory && GDKcreatedir(dbtrace) != GDK_SUCCEED) {
648 0 : fprintf(stderr, "!ERROR: cannot create directory for %s\n",
649 : dbtrace);
650 0 : exit(1);
651 : }
652 0 : GDKfree(dbtrace);
653 : }
654 :
655 347 : GDKsetdebug(debug | grpdebug); /* add the algorithm tracers */
656 347 : if (monet_init(set, setlen, false) == 0) {
657 2 : mo_free_options(set, setlen);
658 2 : if (GDKerrbuf && *GDKerrbuf)
659 0 : fprintf(stderr, "%s\n", GDKerrbuf);
660 2 : exit(1);
661 : }
662 345 : mo_free_options(set, setlen);
663 :
664 345 : if (GDKsetenv("monet_version", GDKversion()) != GDK_SUCCEED
665 345 : || GDKsetenv("monet_release",
666 : #ifdef MONETDB_RELEASE
667 : MONETDB_RELEASE
668 : #else
669 : "unreleased"
670 : #endif
671 : ) != GDK_SUCCEED) {
672 0 : fprintf(stderr, "!ERROR: GDKsetenv failed\n");
673 0 : exit(1);
674 : }
675 :
676 345 : if ((modpath = GDKgetenv("monet_mod_path")) == NULL) {
677 : /* start probing based on some heuristics given the binary
678 : * location:
679 : * bin/mserver5 -> ../
680 : * libX/monetdb5/lib/
681 : * probe libX = lib, lib32, lib64, lib/64 */
682 : size_t pref;
683 : /* "remove" common prefix of configured BIN and LIB
684 : * directories from LIBDIR */
685 22080 : for (pref = 0; LIBDIR[pref] != 0 && BINDIR[pref] == LIBDIR[pref];
686 21735 : pref++) ;
687 345 : const char *libdirs[] = {
688 345 : &LIBDIR[pref],
689 : "lib",
690 : "lib64",
691 : "lib/64",
692 : "lib32",
693 : NULL,
694 : };
695 345 : struct stat sb;
696 345 : if (binpath != NULL) {
697 345 : char *p = strrchr(binpath, DIR_SEP);
698 345 : if (p != NULL)
699 345 : *p = '\0';
700 345 : p = strrchr(binpath, DIR_SEP);
701 345 : if (p != NULL) {
702 345 : *p = '\0';
703 345 : for (int i = 0; libdirs[i] != NULL; i++) {
704 345 : int len = snprintf(prmodpath, sizeof(prmodpath),
705 : "%s%c%s%cmonetdb5-%s",
706 : binpath, DIR_SEP, libdirs[i], DIR_SEP,
707 : MONETDB_VERSION);
708 345 : if (len == -1 || len >= FILENAME_MAX)
709 0 : continue;
710 345 : if (MT_stat(prmodpath, &sb) == 0) {
711 : modpath = prmodpath;
712 : break;
713 : }
714 0 : len = snprintf(prmodpath, sizeof(prmodpath),
715 : "%s%c%s%cmonetdb5",
716 : binpath, DIR_SEP, libdirs[i], DIR_SEP);
717 0 : if (len == -1 || len >= FILENAME_MAX)
718 0 : continue;
719 0 : if (MT_stat(prmodpath, &sb) == 0) {
720 : modpath = prmodpath;
721 : break;
722 : }
723 : }
724 : } else {
725 0 : printf("#warning: unusable binary location, "
726 : "please use --set monet_mod_path=/path/to/... to "
727 : "allow finding modules\n");
728 0 : fflush(stdout);
729 : }
730 : } else {
731 0 : printf("#warning: unable to determine binary location, "
732 : "please use --set monet_mod_path=/path/to/... to "
733 : "allow finding modules\n");
734 0 : fflush(stdout);
735 : }
736 345 : if (modpath != NULL
737 345 : && GDKsetenv("monet_mod_path", modpath) != GDK_SUCCEED) {
738 0 : fprintf(stderr, "!ERROR: GDKsetenv failed\n");
739 0 : exit(1);
740 : }
741 : }
742 :
743 345 : if (!GDKinmemory(0)) {
744 : /* configure sabaoth to use the right dbpath and active database */
745 345 : msab_dbpathinit(GDKgetenv("gdk_dbpath"));
746 : /* wipe out all cruft, if left over */
747 345 : if ((err = msab_wildRetreat()) != NULL) {
748 : /* just swallow the error */
749 0 : free(err);
750 : }
751 : /* From this point, the server should exit cleanly. Discussion:
752 : * even earlier? Sabaoth here registers the server is starting up. */
753 345 : if ((err = msab_registerStarting()) != NULL) {
754 : /* throw the error at the user, but don't die */
755 0 : fprintf(stderr, "!%s\n", err);
756 0 : free(err);
757 : }
758 : }
759 :
760 : #ifdef HAVE_SIGACTION
761 : {
762 345 : struct sigaction sa;
763 :
764 345 : (void) sigemptyset(&sa.sa_mask);
765 345 : sa.sa_flags = 0;
766 345 : sa.sa_handler = handler;
767 345 : if (sigaction(SIGINT, &sa, NULL) == -1
768 345 : || sigaction(SIGQUIT, &sa, NULL) == -1
769 345 : || sigaction(SIGTERM, &sa, NULL) == -1) {
770 0 : fprintf(stderr, "!unable to create signal handlers\n");
771 : }
772 345 : (void) sigemptyset(&sa.sa_mask);
773 345 : sa.sa_flags = 0;
774 345 : sa.sa_handler = handler_usr1;
775 345 : if (sigaction(SIGUSR1, &sa, NULL) == -1) {
776 0 : fprintf(stderr, "!unable to create signal handler for SIGUSR1\n");
777 : }
778 : }
779 : #else
780 : #ifdef _MSC_VER
781 : if (!SetConsoleCtrlHandler(winhandler, TRUE))
782 : fprintf(stderr, "!unable to create console control handler\n");
783 : #else
784 : if (signal(SIGINT, handler) == SIG_ERR)
785 : fprintf(stderr, "!unable to create signal handlers\n");
786 : #ifdef SIGQUIT
787 : if (signal(SIGQUIT, handler) == SIG_ERR)
788 : fprintf(stderr, "!unable to create signal handlers\n");
789 : #endif
790 : if (signal(SIGTERM, handler) == SIG_ERR)
791 : fprintf(stderr, "!unable to create signal handlers\n");
792 : if (signal(SIGUSR1, handler_usr1) == SIG_ERR)
793 : fprintf(stderr, "!unable to create signal handler for SIGUSR1\n");
794 : #endif
795 : #endif
796 :
797 345 : if (!GDKinmemory(0)) {
798 345 : str lang = "mal";
799 : /* we inited mal before, so publish its existence */
800 345 : if ((err = msab_marchScenario(lang)) != NULL) {
801 : /* throw the error at the user, but don't die */
802 0 : fprintf(stderr, "!%s\n", err);
803 0 : free(err);
804 : }
805 : }
806 :
807 345 : char secret[1024];
808 : {
809 : /* unlock the vault, first see if we can find the file which
810 : * holds the secret */
811 345 : FILE *secretf;
812 345 : size_t len;
813 :
814 345 : if (GDKinmemory(0) || GDKgetenv("monet_vault_key") == NULL) {
815 : /* use a default (hard coded, non safe) key */
816 148 : snprintf(secret, sizeof(secret), "%s", "Xas632jsi2whjds8");
817 : } else {
818 197 : if ((secretf = MT_fopen(GDKgetenv("monet_vault_key"), "r")) == NULL) {
819 0 : fprintf(stderr, "unable to open vault_key_file %s: %s\n",
820 0 : GDKgetenv("monet_vault_key"), strerror(errno));
821 : /* don't show this as a crash */
822 0 : msab_registerStop();
823 0 : exit(1);
824 : }
825 197 : len = fread(secret, 1, sizeof(secret), secretf);
826 197 : secret[len] = '\0';
827 197 : len = strlen(secret); /* secret can contain null-bytes */
828 197 : if (len == 0) {
829 0 : fprintf(stderr, "vault key has zero-length!\n");
830 : /* don't show this as a crash */
831 0 : msab_registerStop();
832 0 : exit(1);
833 197 : } else if (len < 5) {
834 0 : fprintf(stderr,
835 : "#warning: your vault key is too short "
836 : "(%zu), enlarge your vault key!\n", len);
837 : }
838 197 : fclose(secretf);
839 : }
840 345 : if ((err = AUTHunlockVault(secret)) != MAL_SUCCEED) {
841 : /* don't show this as a crash */
842 0 : if (!GDKinmemory(0))
843 0 : msab_registerStop();
844 0 : fprintf(stderr, "%s\n", err);
845 0 : freeException(err);
846 0 : exit(1);
847 : }
848 345 : if (readpwdxit) {
849 0 : char *secretp;
850 0 : if (fgets(secret, (int) sizeof(secret), stdin) == NULL) {
851 0 : fprintf(stderr, "!ERROR: no password read\n");
852 0 : exit(1);
853 : }
854 0 : if ((secretp = strchr(secret, '\n')) == NULL) {
855 0 : fprintf(stderr, "!ERROR: password too long\n");
856 0 : exit(1);
857 : }
858 0 : *secretp = '\0';
859 : }
860 : }
861 :
862 345 : modules[mods++] = 0;
863 690 : if (mal_init(modules, false, readpwdxit ? secret : NULL, mercurial_revision())) {
864 : /* don't show this as a crash */
865 0 : if (!GDKinmemory(0))
866 0 : msab_registerStop();
867 0 : return 1;
868 : }
869 344 : if (readpwdxit) {
870 0 : msab_registerStop();
871 0 : return 0;
872 : }
873 :
874 344 : emergencyBreakpoint();
875 :
876 344 : if (!GDKinmemory(0) && (err = msab_registerStarted()) != NULL) {
877 : /* throw the error at the user, but don't die */
878 0 : fprintf(stderr, "!%s\n", err);
879 0 : free(err);
880 : }
881 :
882 : /* return all our free bats to global pool */
883 344 : BBPrelinquishbats();
884 :
885 : #ifdef _MSC_VER
886 : printf("# MonetDB server is started. To stop server press Ctrl-C.\n");
887 : fflush(stdout);
888 : #endif
889 :
890 17610 : while (!interrupted && !GDKexiting()) {
891 17266 : if (usr1_interrupted) {
892 118 : usr1_interrupted = 0;
893 : /* print some useful information */
894 118 : GDKprintinfo();
895 118 : fflush(stdout);
896 : }
897 17266 : MT_sleep_ms(100); /* pause(), except for sys.shutdown() */
898 : }
899 :
900 : /* mal_exit calls exit, so statements after this call will
901 : * never get reached */
902 344 : mal_exit(0);
903 :
904 : return 0;
905 : }
|
