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 346 : monet_hello(void)
113 : {
114 346 : double sz_mem_h;
115 346 : const char qc[] = " kMGTPE";
116 346 : int qi = 0;
117 :
118 346 : printf("# MonetDB 5 server v%s", GDKversion());
119 : {
120 : #ifdef MONETDB_RELEASE
121 : printf(" (%s)", MONETDB_RELEASE);
122 : #else
123 346 : const char *rev = mercurial_revision();
124 346 : if (strcmp(rev, "Unknown") != 0)
125 0 : printf(" (hg id: %s)", rev);
126 : #endif
127 : }
128 : #ifndef MONETDB_RELEASE
129 346 : printf("\n# This is an unreleased version");
130 : #endif
131 346 : printf("\n# Serving database '%s', using %d thread%s\n",
132 : GDKgetenv("gdk_dbname"), GDKnr_threads,
133 346 : (GDKnr_threads != 1) ? "s" : "");
134 346 : 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 346 : sz_mem_h = (double) MT_npages() * MT_pagesize();
142 1384 : while (sz_mem_h >= 1000.0 && qi < 6) {
143 1038 : sz_mem_h /= 1024.0;
144 1038 : qi++;
145 : }
146 346 : printf("# Found %.3f %ciB available main-memory", sz_mem_h, qc[qi]);
147 346 : sz_mem_h = (double) GDK_mem_maxsize;
148 346 : qi = 0;
149 1384 : while (sz_mem_h >= 1000.0 && qi < 6) {
150 1038 : sz_mem_h /= 1024.0;
151 1038 : qi++;
152 : }
153 346 : printf(" of which we use %.3f %ciB\n", sz_mem_h, qc[qi]);
154 346 : if (GDK_vm_maxsize < GDK_VM_MAXSIZE) {
155 198 : sz_mem_h = (double) GDK_vm_maxsize;
156 198 : qi = 0;
157 792 : while (sz_mem_h >= 1000.0 && qi < 6) {
158 594 : sz_mem_h /= 1024.0;
159 594 : qi++;
160 : }
161 198 : printf("# Virtual memory usage limited to %.3f %ciB\n", sz_mem_h,
162 198 : 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 346 : printf("# Copyright (c) 2024, 2025 MonetDB Foundation, all rights reserved\n");
169 346 : printf("# Visit https://www.monetdb.org/ for further information\n");
170 :
171 : // The properties shipped through the performance profiler
172 346 : (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 346 : HOST, GDKnr_threads, sz_mem_h, qc[qi], sizeof(oid) * 8);
187 346 : fflush(stdout);
188 346 : }
189 :
190 : static str
191 348 : absolute_path(const char *s)
192 : {
193 348 : 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 348 : return GDKstrdup(s);
201 : }
202 :
203 : #define BSIZE 8192
204 :
205 : static int
206 348 : 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 348 : int maj, min, patch;
211 348 : const char *version = GDKlibversion();
212 348 : sscanf(version, "%d.%d.%d", &maj, &min, &patch);
213 348 : 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 348 : version = mal_version();
221 348 : sscanf(version, "%d.%d.%d", &maj, &min, &patch);
222 348 : 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 348 : if (GDKinit(set, setlen, embedded, mercurial_revision()) != GDK_SUCCEED)
232 : return 0;
233 :
234 : #ifdef HAVE_SETSID
235 346 : setsid();
236 : #endif
237 346 : monet_hello();
238 346 : 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 345 : handler(int sig)
261 : {
262 345 : (void) sig;
263 345 : interrupted = 1;
264 345 : }
265 : static void
266 119 : handler_usr1(int sig)
267 : {
268 119 : (void) sig;
269 119 : usr1_interrupted = 1;
270 119 : }
271 : #endif
272 :
273 : int
274 : #ifdef _MSC_VER
275 : wmain(int argc, wchar_t **argv)
276 : #else
277 349 : 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 349 : 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 349 : char *prog = *av;
300 349 : opt *set = NULL;
301 349 : unsigned grpdebug = 0, debug = 0;
302 349 : int setlen = 0;
303 349 : str err = MAL_SUCCEED;
304 349 : char prmodpath[FILENAME_MAX];
305 349 : const char *modpath = NULL;
306 349 : char *binpath = NULL;
307 349 : char *dbpath = NULL;
308 349 : char *dbextra = NULL;
309 349 : char *dbtrace = NULL;
310 349 : bool inmemory = false;
311 349 : bool readpwdxit = false;
312 349 : 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 349 : char *modules[MAX_MODULES + 1];
348 349 : int mods = 0;
349 :
350 349 : modules[mods++] = "sql";
351 349 : modules[mods++] = "generator";
352 : #ifdef HAVE_GEOM
353 349 : modules[mods++] = "geom";
354 : #endif
355 : #ifdef HAVE_LIBR
356 : /* TODO check for used */
357 349 : modules[mods++] = "rapi";
358 : #endif
359 : #ifdef HAVE_LIBPY3
360 : /* TODO check for used */
361 349 : modules[mods++] = "pyapi3";
362 : #endif
363 : #ifdef HAVE_CUDF
364 349 : modules[mods++] = "capi";
365 : #endif
366 : #ifdef HAVE_FITS
367 349 : modules[mods++] = "fits";
368 : #endif
369 : #ifdef HAVE_NETCDF
370 349 : modules[mods++] = "netcdf";
371 : #endif
372 349 : modules[mods++] = "csv";
373 349 : modules[mods++] = "monetdb_loader";
374 349 : modules[mods++] = "json_loader";
375 : #ifdef HAVE_SHP
376 349 : modules[mods++] = "shp";
377 : #endif
378 :
379 : #if defined(_MSC_VER) && defined(__cplusplus)
380 : set_terminate(mserver_abort);
381 : #endif
382 : #ifdef _MSC_VER
383 : _CrtSetReportMode(_CRT_ERROR, 0);
384 : _CrtSetReportMode(_CRT_ASSERT, 0);
385 : _set_invalid_parameter_handler(mserver_invalid_parameter_handler);
386 : #ifdef _TWO_DIGIT_EXPONENT
387 : _set_output_format(_TWO_DIGIT_EXPONENT);
388 : #endif
389 : #endif
390 349 : if (setlocale(LC_CTYPE, "") == NULL) {
391 0 : fprintf(stderr, "cannot set locale\n");
392 0 : exit(1);
393 : }
394 :
395 349 : if (MT_getcwd(monet_cwd, FILENAME_MAX - 1) == NULL) {
396 0 : perror("pwd");
397 0 : fprintf(stderr, "monet_init: could not determine current directory\n");
398 0 : exit(-1);
399 : }
400 :
401 : /* retrieve binpath early (before monet_init) because some
402 : * implementations require the working directory when the binary was
403 : * called */
404 349 : binpath = get_bin_path();
405 :
406 349 : if (!(setlen = mo_builtin_settings(&set)))
407 0 : usage(prog, -1);
408 :
409 3430 : for (;;) {
410 3779 : int option_index = 0;
411 :
412 3779 : int c = getopt_long(argc, av, "c:d::rs:t::v::?",
413 : long_options, &option_index);
414 :
415 3779 : if (c == -1)
416 : break;
417 :
418 3431 : switch (c) {
419 904 : case 0:
420 904 : if (strcmp(long_options[option_index].name, "in-memory") == 0) {
421 : inmemory = true;
422 : break;
423 : }
424 904 : if (strcmp(long_options[option_index].name, "dbpath") == 0) {
425 348 : size_t optarglen = strlen(optarg);
426 : /* remove trailing directory separator */
427 348 : while (optarglen > 0
428 348 : && (optarg[optarglen - 1] == '/'
429 348 : || optarg[optarglen - 1] == '\\'))
430 0 : optarg[--optarglen] = '\0';
431 348 : dbpath = absolute_path(optarg);
432 348 : if (dbpath == NULL)
433 0 : fprintf(stderr,
434 : "#error: can not allocate memory for dbpath\n");
435 : else
436 348 : setlen = mo_add_option(&set, setlen, opt_cmdline,
437 : "gdk_dbpath", dbpath);
438 : break;
439 : }
440 556 : if (strcmp(long_options[option_index].name, "dbextra") == 0) {
441 192 : if (dbextra)
442 0 : fprintf(stderr,
443 : "#warning: ignoring multiple --dbextra arguments\n");
444 : else
445 192 : dbextra = optarg;
446 : break;
447 : }
448 :
449 364 : if (strcmp(long_options[option_index].name, "dbtrace") == 0) {
450 0 : size_t optarglen = strlen(optarg);
451 : /* remove trailing directory separator */
452 0 : while (optarglen > 0
453 0 : && (optarg[optarglen - 1] == '/'
454 0 : || optarg[optarglen - 1] == '\\'))
455 0 : optarg[--optarglen] = '\0';
456 0 : dbtrace = absolute_path(optarg);
457 0 : if (dbtrace == NULL)
458 0 : fprintf(stderr,
459 : "#error: can not allocate memory for dbtrace\n");
460 : else
461 0 : setlen = mo_add_option(&set, setlen, opt_cmdline,
462 : "gdk_dbtrace", dbtrace);
463 : break;
464 : }
465 :
466 364 : if (strcmp(long_options[option_index].name, "single-user") == 0) {
467 0 : setlen = mo_add_option(&set, setlen, opt_cmdline,
468 : "gdk_single_user", "yes");
469 0 : break;
470 : }
471 364 : if (strcmp(long_options[option_index].name, "version") == 0) {
472 1 : monet_version();
473 1 : exit(0);
474 : }
475 : /* debugging options */
476 363 : if (strcmp(long_options[option_index].name, "algorithms") == 0) {
477 0 : grpdebug |= GRPalgorithms;
478 0 : break;
479 : }
480 363 : if (strcmp(long_options[option_index].name, "forcemito") == 0) {
481 349 : grpdebug |= GRPforcemito;
482 349 : break;
483 : }
484 14 : if (strcmp(long_options[option_index].name, "heaps") == 0) {
485 0 : grpdebug |= GRPheaps;
486 0 : break;
487 : }
488 14 : if (strcmp(long_options[option_index].name, "io") == 0) {
489 0 : grpdebug |= GRPio;
490 0 : break;
491 : }
492 14 : if (strcmp(long_options[option_index].name, "memory") == 0) {
493 0 : grpdebug |= GRPmemory;
494 0 : break;
495 : }
496 14 : if (strcmp(long_options[option_index].name, "modules") == 0) {
497 0 : grpdebug |= GRPmodules;
498 0 : break;
499 : }
500 14 : if (strcmp(long_options[option_index].name, "performance") == 0) {
501 0 : grpdebug |= GRPperformance;
502 0 : break;
503 : }
504 14 : if (strcmp(long_options[option_index].name, "properties") == 0) {
505 0 : grpdebug |= GRPproperties;
506 0 : break;
507 : }
508 14 : if (strcmp(long_options[option_index].name, "threads") == 0) {
509 0 : grpdebug |= GRPthreads;
510 0 : break;
511 : }
512 14 : if (strcmp(long_options[option_index].name, "transactions") == 0) {
513 0 : grpdebug |= GRPtransactions;
514 0 : break;
515 : }
516 14 : if (strcmp(long_options[option_index].name, "read-password-initialize-and-exit") == 0) {
517 : readpwdxit = true;
518 : break;
519 : }
520 14 : if (strcmp(long_options[option_index].name, "process-wal-and-exit") == 0) {
521 0 : setlen = mo_add_option(&set, setlen, opt_cmdline,
522 : "process-wal-and-exit", "yes");
523 0 : break;
524 : }
525 14 : if (strcmp(long_options[option_index].name, "clean-BBP") == 0) {
526 8 : setlen = mo_add_option(&set, setlen, opt_cmdline,
527 : "clean-BBP", "yes");
528 8 : break;
529 : }
530 6 : if (strcmp(long_options[option_index].name, "loadmodule") == 0) {
531 6 : if (mods < MAX_MODULES)
532 6 : modules[mods++] = optarg;
533 : else
534 0 : fprintf(stderr,
535 : "ERROR: maximum number of modules reached\n");
536 : break;
537 : }
538 0 : if (strcmp(long_options[option_index].name, "without-geom") == 0) {
539 0 : for (int i = 0; i < mods; i++) {
540 0 : if (strcmp(modules[i], "geom") == 0) {
541 0 : while (i + 1 < mods) {
542 0 : modules[i] = modules[i + 1];
543 0 : i++;
544 : }
545 0 : mods--;
546 0 : break;
547 : }
548 : }
549 : break;
550 : }
551 0 : usage(prog, -1);
552 : /* not reached */
553 0 : case 'c':
554 : /* coverity[var_deref_model] */
555 0 : setlen = mo_add_option(&set, setlen, opt_cmdline, "config", optarg);
556 0 : break;
557 696 : case 'd':
558 696 : if (optarg) {
559 696 : char *endarg;
560 696 : debug |= strtoul(optarg, &endarg, 10);
561 696 : if (*endarg != '\0') {
562 0 : fprintf(stderr, "ERROR: wrong format for --debug=%s\n",
563 : optarg);
564 0 : usage(prog, -1);
565 : }
566 : } else {
567 0 : debug |= CHECKMASK;
568 : }
569 : break;
570 3 : case 'r':
571 3 : setlen = mo_add_option(&set, setlen, opt_cmdline, "gdk_readonly",
572 : "yes");
573 3 : break;
574 1828 : case 's':{
575 : /* should add option to a list */
576 : /* coverity[var_deref_model] */
577 1828 : char *tmp = strchr(optarg, '=');
578 :
579 1828 : if (tmp) {
580 1828 : *tmp = '\0';
581 1828 : setlen = mo_add_option(&set, setlen, opt_cmdline, optarg,
582 1828 : tmp + 1);
583 : } else
584 0 : fprintf(stderr, "ERROR: wrong format %s\n", optarg);
585 : }
586 : break;
587 0 : case '?':
588 : /* a bit of a hack: look at the option that the
589 : current `c' is based on and see if we recognize
590 : it: if -? or --help, exit with 0, else with -1 */
591 0 : usage(prog, strcmp(av[optind - 1], "-?") == 0
592 0 : || strcmp(av[optind - 1], "--help") == 0 ? 0 : -1);
593 0 : default:
594 0 : fprintf(stderr,
595 : "ERROR: getopt returned character " "code '%c' 0%o\n", c,
596 : (unsigned) (uint8_t) c);
597 0 : usage(prog, -1);
598 : }
599 : }
600 :
601 348 : if (optind < argc)
602 0 : usage(prog, -1);
603 :
604 348 : if (!(setlen = mo_system_config(&set, setlen)))
605 0 : usage(prog, -1);
606 :
607 348 : if (debug)
608 348 : mo_print_options(set, setlen);
609 :
610 348 : if (dbpath && inmemory) {
611 0 : fprintf(stderr,
612 : "!ERROR: both dbpath and in-memory must not be set at the same time\n");
613 0 : exit(1);
614 : }
615 :
616 348 : if (inmemory && readpwdxit) {
617 0 : fprintf(stderr,
618 : "!ERROR: cannot have both in-memory and read-password-initialize-and-exit\n");
619 0 : exit(1);
620 : }
621 :
622 348 : if (inmemory) {
623 0 : if (BBPaddfarm(NULL, (1U << PERSISTENT) | (1U << TRANSIENT), true) !=
624 : GDK_SUCCEED) {
625 0 : fprintf(stderr, "!ERROR: cannot add in-memory farm\n");
626 0 : exit(1);
627 : }
628 : } else {
629 348 : if (dbpath == NULL) {
630 0 : dbpath = absolute_path(mo_find_option(set, setlen, "gdk_dbpath"));
631 0 : if (dbpath == NULL) {
632 0 : fprintf(stderr,
633 : "!ERROR: cannot allocate memory for database directory \n");
634 0 : exit(1);
635 : }
636 : }
637 348 : if (BBPaddfarm(dbpath, 1U << PERSISTENT, true) != GDK_SUCCEED
638 504 : || BBPaddfarm(dbextra ? dbextra : dbpath, 1U << TRANSIENT,
639 : true) != GDK_SUCCEED) {
640 0 : fprintf(stderr, "!ERROR: cannot add farm\n");
641 0 : exit(1);
642 : }
643 348 : GDKfree(dbpath);
644 : }
645 :
646 348 : if (dbtrace) {
647 : /* GDKcreatedir makes sure that all parent directories of dbtrace exist */
648 0 : if (!inmemory && GDKcreatedir(dbtrace) != GDK_SUCCEED) {
649 0 : fprintf(stderr, "!ERROR: cannot create directory for %s\n",
650 : dbtrace);
651 0 : exit(1);
652 : }
653 0 : GDKfree(dbtrace);
654 : }
655 :
656 348 : GDKsetdebug(debug | grpdebug); /* add the algorithm tracers */
657 348 : if (monet_init(set, setlen, false) == 0) {
658 2 : mo_free_options(set, setlen);
659 2 : if (GDKerrbuf && *GDKerrbuf)
660 0 : fprintf(stderr, "%s\n", GDKerrbuf);
661 2 : exit(1);
662 : }
663 346 : mo_free_options(set, setlen);
664 :
665 346 : if (GDKsetenv("monet_version", GDKversion()) != GDK_SUCCEED
666 346 : || GDKsetenv("monet_release",
667 : #ifdef MONETDB_RELEASE
668 : MONETDB_RELEASE
669 : #else
670 : "unreleased"
671 : #endif
672 : ) != GDK_SUCCEED) {
673 0 : fprintf(stderr, "!ERROR: GDKsetenv failed\n");
674 0 : exit(1);
675 : }
676 :
677 346 : if ((modpath = GDKgetenv("monet_mod_path")) == NULL) {
678 : /* start probing based on some heuristics given the binary
679 : * location:
680 : * bin/mserver5 -> ../
681 : * libX/monetdb5/lib/
682 : * probe libX = lib, lib32, lib64, lib/64 */
683 : size_t pref;
684 : /* "remove" common prefix of configured BIN and LIB
685 : * directories from LIBDIR */
686 22144 : for (pref = 0; LIBDIR[pref] != 0 && BINDIR[pref] == LIBDIR[pref];
687 21798 : pref++) ;
688 346 : const char *libdirs[] = {
689 346 : &LIBDIR[pref],
690 : "lib",
691 : "lib64",
692 : "lib/64",
693 : "lib32",
694 : NULL,
695 : };
696 346 : struct stat sb;
697 346 : if (binpath != NULL) {
698 346 : char *p = strrchr(binpath, DIR_SEP);
699 346 : if (p != NULL)
700 346 : *p = '\0';
701 346 : p = strrchr(binpath, DIR_SEP);
702 346 : if (p != NULL) {
703 346 : *p = '\0';
704 346 : for (int i = 0; libdirs[i] != NULL; i++) {
705 346 : int len = snprintf(prmodpath, sizeof(prmodpath),
706 : "%s%c%s%cmonetdb5-%s",
707 : binpath, DIR_SEP, libdirs[i], DIR_SEP,
708 : MONETDB_VERSION);
709 346 : if (len == -1 || len >= FILENAME_MAX)
710 0 : continue;
711 346 : if (MT_stat(prmodpath, &sb) == 0) {
712 : modpath = prmodpath;
713 : break;
714 : }
715 0 : len = snprintf(prmodpath, sizeof(prmodpath),
716 : "%s%c%s%cmonetdb5",
717 : binpath, DIR_SEP, libdirs[i], DIR_SEP);
718 0 : if (len == -1 || len >= FILENAME_MAX)
719 0 : continue;
720 0 : if (MT_stat(prmodpath, &sb) == 0) {
721 : modpath = prmodpath;
722 : break;
723 : }
724 : }
725 : } else {
726 0 : printf("#warning: unusable binary location, "
727 : "please use --set monet_mod_path=/path/to/... to "
728 : "allow finding modules\n");
729 0 : fflush(stdout);
730 : }
731 : } else {
732 0 : printf("#warning: unable to determine binary location, "
733 : "please use --set monet_mod_path=/path/to/... to "
734 : "allow finding modules\n");
735 0 : fflush(stdout);
736 : }
737 346 : if (modpath != NULL
738 346 : && GDKsetenv("monet_mod_path", modpath) != GDK_SUCCEED) {
739 0 : fprintf(stderr, "!ERROR: GDKsetenv failed\n");
740 0 : exit(1);
741 : }
742 : }
743 :
744 346 : if (!GDKinmemory(0)) {
745 : /* configure sabaoth to use the right dbpath and active database */
746 346 : msab_dbpathinit(GDKgetenv("gdk_dbpath"));
747 : /* wipe out all cruft, if left over */
748 346 : if ((err = msab_wildRetreat()) != NULL) {
749 : /* just swallow the error */
750 0 : free(err);
751 : }
752 : /* From this point, the server should exit cleanly. Discussion:
753 : * even earlier? Sabaoth here registers the server is starting up. */
754 346 : if ((err = msab_registerStarting()) != NULL) {
755 : /* throw the error at the user, but don't die */
756 0 : fprintf(stderr, "!%s\n", err);
757 0 : free(err);
758 : }
759 : }
760 :
761 : #ifdef HAVE_SIGACTION
762 : {
763 346 : struct sigaction sa;
764 :
765 346 : (void) sigemptyset(&sa.sa_mask);
766 346 : sa.sa_flags = 0;
767 346 : sa.sa_handler = handler;
768 346 : if (sigaction(SIGINT, &sa, NULL) == -1
769 346 : || sigaction(SIGQUIT, &sa, NULL) == -1
770 346 : || sigaction(SIGTERM, &sa, NULL) == -1) {
771 0 : fprintf(stderr, "!unable to create signal handlers\n");
772 : }
773 346 : (void) sigemptyset(&sa.sa_mask);
774 346 : sa.sa_flags = 0;
775 346 : sa.sa_handler = handler_usr1;
776 346 : if (sigaction(SIGUSR1, &sa, NULL) == -1) {
777 0 : fprintf(stderr, "!unable to create signal handler for SIGUSR1\n");
778 : }
779 : }
780 : #else
781 : #ifdef _MSC_VER
782 : if (!SetConsoleCtrlHandler(winhandler, TRUE))
783 : fprintf(stderr, "!unable to create console control handler\n");
784 : #else
785 : if (signal(SIGINT, handler) == SIG_ERR)
786 : fprintf(stderr, "!unable to create signal handlers\n");
787 : #ifdef SIGQUIT
788 : if (signal(SIGQUIT, handler) == SIG_ERR)
789 : fprintf(stderr, "!unable to create signal handlers\n");
790 : #endif
791 : if (signal(SIGTERM, handler) == SIG_ERR)
792 : fprintf(stderr, "!unable to create signal handlers\n");
793 : if (signal(SIGUSR1, handler_usr1) == SIG_ERR)
794 : fprintf(stderr, "!unable to create signal handler for SIGUSR1\n");
795 : #endif
796 : #endif
797 :
798 346 : if (!GDKinmemory(0)) {
799 346 : str lang = "mal";
800 : /* we inited mal before, so publish its existence */
801 346 : if ((err = msab_marchScenario(lang)) != NULL) {
802 : /* throw the error at the user, but don't die */
803 0 : fprintf(stderr, "!%s\n", err);
804 0 : free(err);
805 : }
806 : }
807 :
808 346 : char secret[1024];
809 : {
810 : /* unlock the vault, first see if we can find the file which
811 : * holds the secret */
812 346 : FILE *secretf;
813 346 : size_t len;
814 :
815 346 : if (GDKinmemory(0) || GDKgetenv("monet_vault_key") == NULL) {
816 : /* use a default (hard coded, non safe) key */
817 148 : snprintf(secret, sizeof(secret), "%s", "Xas632jsi2whjds8");
818 : } else {
819 198 : if ((secretf = MT_fopen(GDKgetenv("monet_vault_key"), "r")) == NULL) {
820 0 : fprintf(stderr, "unable to open vault_key_file %s: %s\n",
821 0 : GDKgetenv("monet_vault_key"), strerror(errno));
822 : /* don't show this as a crash */
823 0 : msab_registerStop();
824 0 : exit(1);
825 : }
826 198 : len = fread(secret, 1, sizeof(secret), secretf);
827 198 : secret[len] = '\0';
828 198 : len = strlen(secret); /* secret can contain null-bytes */
829 198 : if (len == 0) {
830 0 : fprintf(stderr, "vault key has zero-length!\n");
831 : /* don't show this as a crash */
832 0 : msab_registerStop();
833 0 : exit(1);
834 198 : } else if (len < 5) {
835 0 : fprintf(stderr,
836 : "#warning: your vault key is too short "
837 : "(%zu), enlarge your vault key!\n", len);
838 : }
839 198 : fclose(secretf);
840 : }
841 346 : if ((err = AUTHunlockVault(secret)) != MAL_SUCCEED) {
842 : /* don't show this as a crash */
843 0 : if (!GDKinmemory(0))
844 0 : msab_registerStop();
845 0 : fprintf(stderr, "%s\n", err);
846 0 : freeException(err);
847 0 : exit(1);
848 : }
849 346 : if (readpwdxit) {
850 0 : char *secretp;
851 0 : if (fgets(secret, (int) sizeof(secret), stdin) == NULL) {
852 0 : fprintf(stderr, "!ERROR: no password read\n");
853 0 : exit(1);
854 : }
855 0 : if ((secretp = strchr(secret, '\n')) == NULL) {
856 0 : fprintf(stderr, "!ERROR: password too long\n");
857 0 : exit(1);
858 : }
859 0 : *secretp = '\0';
860 : }
861 : }
862 :
863 346 : modules[mods++] = 0;
864 692 : if (mal_init(modules, false, readpwdxit ? secret : NULL, mercurial_revision())) {
865 : /* don't show this as a crash */
866 0 : if (!GDKinmemory(0))
867 0 : msab_registerStop();
868 0 : return 1;
869 : }
870 345 : if (readpwdxit) {
871 0 : msab_registerStop();
872 0 : return 0;
873 : }
874 :
875 345 : emergencyBreakpoint();
876 :
877 345 : if (!GDKinmemory(0) && (err = msab_registerStarted()) != NULL) {
878 : /* throw the error at the user, but don't die */
879 0 : fprintf(stderr, "!%s\n", err);
880 0 : free(err);
881 : }
882 :
883 : /* return all our free bats to global pool */
884 345 : BBPrelinquishbats();
885 :
886 : #ifdef _MSC_VER
887 : printf("# MonetDB server is started. To stop server press Ctrl-C.\n");
888 : fflush(stdout);
889 : #endif
890 :
891 9749 : while (!interrupted && !GDKexiting()) {
892 9404 : if (usr1_interrupted) {
893 119 : usr1_interrupted = 0;
894 : /* print some useful information */
895 119 : GDKprintinfo();
896 119 : fflush(stdout);
897 : }
898 9404 : MT_sleep_ms(100); /* pause(), except for sys.shutdown() */
899 : }
900 :
901 : /* mal_exit calls exit, so statements after this call will
902 : * never get reached */
903 345 : mal_exit(0);
904 :
905 : return 0;
906 : }
|
