citadel/utils/ctdlload.c

   1 // Load (restore) the Citadel database from a flat file created by ctdldump
   2 //
   3 // Copyright (c) 2023-2024 by citadel.org (Art Cancro et al.)
   4 //
   5 // This program is open source software.  Use, duplication, or disclosure
   6 // is subject to the terms of the GNU General Public License, version 3.
   7
   8 #include <stdlib.h>
   9 #include <unistd.h>
  10 #include <ctype.h>
  11 #include <stdio.h>
  12 #include <signal.h>
  13 #include <sys/types.h>
  14 #include <sys/socket.h>
  15 #include <sys/un.h>
  16 #include <netdb.h>
  17 #include <string.h>
  18 #include <pwd.h>
  19 #include <errno.h>
  20 #include <stdarg.h>
  21 #include <limits.h>
  22 #include <syslog.h>
  23 #include <libcitadel.h>
  24 #include <zlib.h>
  25 #include "../server/sysdep.h"
  26 #include "../server/citadel_defs.h"
  27 #include "../server/server.h"
  28 #include "../server/makeuserkey.h"
  29 #include "../server/citadel_dirs.h"
  30 #include "../server/database.h"
  31
  32 uid_t ctdluid = 0;
  33
  34 // Wrapper for realloc() that crashes and burns if the call fails.
  35 void *reallok(void *ptr, size_t size) {
  36         void *p = realloc(ptr, size);
  37         if (!p) {
  38                 fprintf(stderr, "realloc() failed to resize %p to %ld bytes, error: %m\n", ptr, size);
  39                 abort();
  40         }
  41         return p;
  42 }
  43
  44
  45 // Convert a "msgtext" record to a message on disk.   NOT THREADSAFE
  46 // This also works for "bigmsg" records.
  47 int import_msgtext(char *line, struct cdbkeyval *kv) {
  48
  49         static char *b64_decoded_msg = NULL;
  50         static size_t b64_decoded_alloc = 0;
  51         long msgnum;
  52         char *token;
  53
  54         token = strtok(line, "|");
  55         msgnum = atol(strtok(NULL, "|"));
  56         token = strtok(NULL, "|");
  57
  58         // The record key will be the message number
  59         kv->key.len = sizeof(long);
  60         kv->key.ptr = reallok(kv->key.ptr, kv->key.len);
  61         memcpy(kv->key.ptr, &msgnum, kv->key.len);
  62
  63         // The record data will be the decoded message text.
  64         // We are allocating more memory than we need, but BDB will only write the number of bytes we tell it to.
  65         kv->val.ptr = (char *) reallok(kv->val.ptr, strlen(token));
  66         kv->val.len = CtdlDecodeBase64(kv->val.ptr, token, strlen(token));
  67         return(1);
  68 }
  69
  70
  71 // Convert a "msgmeta" record to a message metadata record on disk.  NOT THREADSAFE
  72 int import_msgmeta(char *line, struct cdbkeyval *kv) {
  73         char *token;
  74         struct MetaData *m;
  75
  76         m = malloc(sizeof(struct MetaData));
  77         if (!m) {
  78                 fprintf(stderr, "import_msgmeta: malloc: %s\n", strerror(errno));
  79                 return(0);
  80         }
  81         memset(m, 0, sizeof(struct MetaData));
  82         char *p = line;
  83
  84         for (int i=0; (token = strsep(&p, "|")); ++i) {
  85                 switch(i) {
  86                         case 1:
  87                                 m->meta_msgnum = atol(token);
  88                                 break;
  89                         case 2:
  90                                 m->meta_refcount = atoi(token);
  91                                 break;
  92                         case 3:
  93                                 strncpy(m->meta_content_type, token, sizeof(m->meta_content_type));
  94                                 break;
  95                         case 4:
  96                                 m->meta_rfc822_length = atol(token);
  97                                 break;
  98                 }
  99         }
 100
 101         // metadata records are stored in the CDB_MSGMAIN table,
 102         // but with the index being the *negative* of the message number.
 103         long index = 0 - m->meta_msgnum;
 104         kv->key.len = sizeof(long);
 105         kv->key.ptr = reallok(NULL, kv->key.len);
 106         memcpy(kv->key.ptr, &index, kv->key.len);
 107
 108         // data
 109         kv->val.len = sizeof(struct MetaData);
 110         kv->val.ptr = (char *) m;                               // out_data owns this memory now
 111
 112         return(1);
 113 }
 114
 115
 116 // Convert a "user" record to a record on disk.  (Source string is unusable after this function is called.)
 117 int import_user(char *line, struct cdbkeyval *kv) {
 118         char userkey[USERNAME_SIZE];
 119         char *token;
 120         struct ctdluser *u;
 121         int dlen = 0;
 122
 123         u = malloc(sizeof(struct ctdluser));
 124         if (!u) {
 125                 fprintf(stderr, "malloc failed\n");
 126                 return(0);
 127         }
 128         memset(u, 0, sizeof(struct ctdluser));
 129         char *p = line;
 130
 131         for (int i=0; (token = strsep(&p, "|")); ++i) {
 132                 switch(i) {
 133                         case 1:
 134                                 u->version = atoi(token);
 135                                 break;
 136                         case 2:
 137                                 u->uid = atoi(token);
 138                                 break;
 139                         case 3:
 140                                 safestrncpy(u->password, token, sizeof(u->password));
 141                                 break;
 142                         case 4:
 143                                 u->flags = atoi(token);
 144                                 break;
 145                         case 5:
 146                                 u->axlevel = atoi(token);
 147                                 break;
 148                         case 6:
 149                                 u->usernum = atol(token);
 150                                 break;
 151                         case 7:
 152                                 u->lastcall = atol(token);
 153                                 break;
 154                         case 8:
 155                                 u->USuserpurge = atoi(token);
 156                                 break;
 157                         case 9:
 158                                 safestrncpy(u->fullname, token, sizeof(u->fullname));
 159                                 break;
 160                         case 10:
 161                                 u->msgnum_bio = atol(token);
 162                                 break;
 163                         case 11:
 164                                 u->msgnum_pic = atol(token);
 165                                 break;
 166                         case 12:
 167                                 dlen = CtdlDecodeBase64(token, token, strlen(token));                   // Decode in place
 168                                 if (dlen >= sizeof(u->emailaddrs)) {
 169                                         dlen = sizeof(u->emailaddrs) - 1;
 170                                 }
 171                                 memcpy(u->emailaddrs, token, dlen);
 172                                 u->emailaddrs[dlen] = 0;
 173                                 break;
 174                         case 13:
 175                                 u->msgnum_inboxrules = atol(token);
 176                                 break;
 177                         case 14:
 178                                 u->lastproc_inboxrules = atol(token);
 179                                 break;
 180                 }
 181         }
 182
 183         // reject any user records without names
 184         if (strlen(u->fullname) == 0) {
 185                 free(u);
 186                 return(0);
 187         }
 188
 189         // ok, good to go
 190         makeuserkey(userkey, u->fullname);
 191         kv->key.len = strlen(userkey);
 192         kv->key.ptr = strdup(userkey);
 193         kv->val.len = sizeof(struct ctdluser);
 194         kv->val.ptr = (char *) u;
 195         return(1);
 196 }
 197
 198
 199 // Convert a "room" record to a record on disk.  (Source string is unusable after this function is called.)
 200 int import_room(char *line, struct cdbkeyval *kv) {
 201         char *token;
 202         struct ctdlroom *r;
 203
 204         r = malloc(sizeof(struct ctdlroom));
 205         if (!r) {
 206                 fprintf(stderr, "import_room: malloc: %s\n", strerror(errno));
 207                 return(0);
 208         }
 209         memset(r, 0, sizeof(struct ctdlroom));
 210         char *p = line;
 211
 212         for (int i=0; (token = strsep(&p, "|")); ++i) {
 213                 switch(i) {
 214                         case 1:
 215                                 strncpy(r->QRname, token, sizeof(r->QRname));
 216                                 break;
 217                         case 2:
 218                                 strncpy(r->QRpasswd, token, sizeof (r->QRpasswd));
 219                                 break;
 220                         case 3:
 221                                 r->QRroomaide = atol(token);
 222                                 break;
 223                         case 4:
 224                                 r->QRhighest = atol(token);
 225                                 break;
 226                         case 5:
 227                                 r->QRgen = atol(token);
 228                                 break;
 229                         case 6:
 230                                 r->QRflags = atoi(token);
 231                                 break;
 232                         case 7:
 233                                 strncpy(r->QRdirname, token, sizeof(r->QRdirname));
 234                                 break;
 235                         case 8:
 236                                 r->msgnum_info = atol(token);
 237                                 break;
 238                         case 9:
 239                                 r->QRfloor = atoi(token);
 240                                 break;
 241                         case 10:
 242                                 r->QRmtime = atol(token);
 243                                 break;
 244                         case 11:
 245                                 r->QRep.expire_mode = atoi(token);
 246                                 break;
 247                         case 12:
 248                                 r->QRep.expire_value = atoi(token);
 249                                 break;
 250                         case 13:
 251                                 r->QRnumber = atol(token);
 252                                 break;
 253                         case 14:
 254                                 r->QRorder = atoi(token);
 255                                 break;
 256                         case 15:
 257                                 r->QRflags2 = atoi(token);
 258                                 break;
 259                         case 16:
 260                                 r->QRdefaultview = atoi(token);
 261                                 break;
 262                         case 17:
 263                                 r->msgnum_pic = atol(token);
 264                                 break;
 265                 }
 266         }
 267
 268         // The key is the room name in all lower case
 269         kv->key.len = strlen(r->QRname);
 270         kv->key.ptr = strdup(r->QRname);
 271         char *k = (char *)kv->key.ptr;
 272         for (int i=0; i<=kv->key.len; ++i) {
 273                 k[i] = tolower(k[i]);
 274         }
 275
 276         kv->val.len = sizeof(struct ctdlroom);
 277         kv->val.ptr = (char *) r;
 278         return(1);
 279 }
 280
 281
 282 // Convert a floor record to a record on disk.
 283 int import_floor(char *line, struct cdbkeyval *kv) {
 284         char *token;
 285         struct floor *f;
 286         int floor_num;
 287
 288         f = malloc(sizeof(struct floor));
 289         if (!f) {
 290                 fprintf(stderr, "import_floor: malloc: %s\n", strerror(errno));
 291                 return(0);
 292         }
 293         memset(f, 0, sizeof(struct floor));
 294         char *p = line;
 295
 296         for (int i=0; (token = strsep(&p, "|")); ++i) {
 297                 switch(i) {
 298                         case 1:
 299                                 floor_num = atoi(token);
 300                                 break;
 301                         case 2:
 302                                 f->f_flags = atoi(token);
 303                                 break;
 304                         case 3:
 305                                 strncpy(f->f_name, token, sizeof(f->f_name));
 306                                 break;
 307                         case 4:
 308                                 f->f_ref_count = atoi(token);
 309                                 break;
 310                         case 5:
 311                                 f->f_ep.expire_mode = atoi(token);
 312                                 break;
 313                         case 6:
 314                                 f->f_ep.expire_value = atoi(token);
 315                                 break;
 316                 }
 317         }
 318
 319         kv->key.len = sizeof(int);
 320         kv->key.ptr = malloc(kv->key.len);
 321         memcpy(kv->key.ptr, &floor_num, kv->key.len);
 322
 323         kv->val.len = sizeof(struct floor);
 324         kv->val.ptr = (char *) f;
 325         return(1);
 326 }
 327
 328
 329 // Import a msglist record
 330 // msglist|26|32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51|
 331 int import_msglist(char *line, struct cdbkeyval *kv) {
 332         long roomnum;
 333         char *token, *mtoken;
 334         char *p = line;
 335         char *q = NULL;
 336         int num_msgs = 0;
 337         long *msglist = NULL;
 338
 339         for (int i=0; (token = strsep(&p, "|")); ++i) {
 340                 switch(i) {
 341                         case 1:
 342                                 roomnum = atol(token);
 343                                 break;
 344                         case 2:
 345                                 q = token;
 346                                 for (int j=0; (mtoken = strsep(&q, ",")); ++j) {
 347                                         msglist = realloc(msglist, (num_msgs+1) * sizeof(long));
 348                                         msglist[num_msgs++] = atol(mtoken);
 349                                 }
 350                                 break;
 351                 }
 352         }
 353
 354         kv->key.len = sizeof(long);
 355         kv->key.ptr = malloc(kv->key.len);
 356         memcpy(kv->key.ptr, &roomnum, kv->key.len);
 357
 358         kv->val.len = num_msgs * sizeof(long);
 359         kv->val.ptr = (char *) msglist;
 360
 361         return(1);
 362 }
 363
 364
 365 // Convert a "visit" record to a record on disk.
 366 int import_visit(char *line, struct cdbkeyval *kv) {
 367         char *token;
 368         struct visit *v;
 369
 370         v = malloc(sizeof(struct visit));
 371         if (!v) {
 372                 fprintf(stderr, "import_visit: malloc: %s\n", strerror(errno));
 373                 return(0);
 374         }
 375         memset(v, 0, sizeof(struct visit));
 376         char *p = line;
 377
 378         for (int i=0; (token = strsep(&p, "|")); ++i) {
 379                 switch(i) {
 380                         case 1:
 381                                 v->v_roomnum = atol(token);
 382                                 break;
 383                         case 2:
 384                                 v->v_roomgen = atol(token);
 385                                 break;
 386                         case 3:
 387                                 v->v_usernum = atol(token);
 388                                 break;
 389                         case 4:
 390                                 v->v_lastseen = atoi(token);
 391                                 break;
 392                         case 5:
 393                                 v->v_flags = atoi(token);
 394                                 break;
 395                         case 6:
 396                                 strncpy(v->v_seen, token, sizeof(v->v_seen));
 397                                 break;
 398                         case 7:
 399                                 strncpy(v->v_answered, token, sizeof(v->v_answered));
 400                                 break;
 401                         case 8:
 402                                 v->v_view = atoi(token);
 403                                 break;
 404                 }
 405         }
 406
 407         // The key is the same as the first three data members (3 x long)
 408         kv->key.len = sizeof(long) * 3;
 409         kv->key.ptr = reallok(NULL, kv->key.len);
 410         memcpy(kv->key.ptr, v, kv->key.len);
 411
 412         kv->val.len = sizeof(struct visit);
 413         kv->val.ptr = (char *) v;
 414         return(1);
 415 }
 416
 417
 418 // Convert a "dir" record to a record on disk.
 419 int import_dir(char *line, struct cdbkeyval *kv) {
 420         char dirkey[SIZ];
 421         char username[USERNAME_SIZE];
 422         char *token;
 423
 424         char *p = line;
 425         for (int i=0; (token = strsep(&p, "|")); ++i) {
 426                 switch(i) {
 427                         case 1:
 428                                 strncpy(dirkey, token, sizeof(dirkey));
 429                                 break;
 430                         case 2:
 431                                 strncpy(username, token, sizeof(username));
 432                                 break;
 433                 }
 434         }
 435
 436         kv->key.len = strlen(dirkey);
 437         kv->key.ptr = reallok(NULL, kv->key.len);
 438         memcpy(kv->key.ptr, dirkey, strlen(dirkey));
 439
 440         kv->val.len = strlen(username) + 1;
 441         kv->val.ptr = strdup(username);
 442
 443         return(1);
 444 }
 445
 446
 447 // Convert a "usetable" record to a record on disk.
 448 int import_usetable(char *line, struct cdbkeyval *kv) {
 449         char *token;
 450         struct UseTable *u;
 451
 452         u = malloc(sizeof(struct UseTable));
 453         if (!u) {
 454                 fprintf(stderr, "import_usetable: malloc: %s\n", strerror(errno));
 455                 return(0);
 456         }
 457         memset(u, 0, sizeof(struct UseTable));
 458         char *p = line;
 459
 460         for (int i=0; (token = strsep(&p, "|")); ++i) {
 461                 switch(i) {
 462                         case 1:
 463                                 u->hash = atoi(token);
 464                                 break;
 465                         case 2:
 466                                 u->timestamp = atol(token);
 467                                 break;
 468                 }
 469         }
 470
 471         // the key is just an int (the hash)
 472         kv->key.len = sizeof(int);
 473         kv->key.ptr = reallok(NULL, kv->key.len);
 474         memcpy(kv->key.ptr, &u->hash, kv->key.len);
 475
 476         kv->val.len = sizeof(struct UseTable);
 477         kv->val.ptr = (char *) u;
 478         return(1);
 479 }
 480
 481
 482 // Import a full text search index record.
 483 // It's just like a msglists record: a key and a list of message numbers, but the key is "int" instead of "long"
 484 int import_fulltext(char *line, struct cdbkeyval *kv) {
 485         int indexnum;
 486         char *token, *mtoken;
 487         char *p = line;
 488         char *q = NULL;
 489         int num_msgs = 0;
 490         long *msglist = NULL;
 491
 492         for (int i=0; (token = strsep(&p, "|")); ++i) {
 493                 switch(i) {
 494                         case 1:
 495                                 indexnum = atoi(token);
 496                                 break;
 497                         case 2:
 498                                 q = token;
 499                                 for (int j=0; (mtoken = strsep(&q, ",")); ++j) {
 500                                         msglist = realloc(msglist, (num_msgs+1) * sizeof(long));
 501                                         msglist[num_msgs++] = atol(mtoken);
 502                                 }
 503                                 break;
 504                 }
 505         }
 506
 507         kv->key.len = sizeof(int);
 508         kv->key.ptr = malloc(kv->key.len);
 509         memcpy(kv->key.ptr, &indexnum, kv->key.len);
 510
 511         kv->val.len = num_msgs * sizeof(long);
 512         kv->val.ptr = (char *) msglist;
 513
 514         return(1);
 515 }
 516
 517
 518 // Import an EUID Index record
 519 // euidindex|msgnum|roomnum|euid|
 520 int import_euidindex(char *line, struct cdbkeyval *kv) {
 521         char euid[SIZ];
 522         long msgnum;
 523         long roomnum;
 524         char *token;
 525
 526         char *p = line;
 527         for (int i=0; (token = strsep(&p, "|")); ++i) {
 528                 switch(i) {
 529                         case 1:
 530                                 msgnum = atol(token);
 531                                 break;
 532                         case 2:
 533                                 roomnum = atol(token);
 534                                 break;
 535                         case 3:
 536                                 strncpy(euid, token, sizeof(euid));
 537                                 break;
 538                 }
 539         }
 540
 541         // The structure of an euidindex record *key* is:
 542         // |----room_number----|----------EUID-------------|
 543         //    (sizeof long)       (actual length of euid)
 544         kv->key.len = sizeof(long) + strlen(euid) + 1;
 545         kv->key.ptr = reallok(NULL, kv->key.len);
 546         memcpy(kv->key.ptr, &roomnum, sizeof(long));
 547         strcpy(kv->key.ptr + sizeof(long), euid);
 548
 549         // The structure of an euidindex record *value* is:
 550         // |-----msg_number----|----room_number----|----------EUID-------------|
 551         //    (sizeof long)       (sizeof long)       (actual length of euid)
 552         kv->val.len = sizeof(long) + sizeof(long) + strlen(euid) + 1;
 553         kv->val.ptr = (char *) reallok(NULL, kv->val.len);
 554         memcpy(kv->val.ptr, &msgnum, sizeof(long));
 555         memcpy(kv->val.ptr + sizeof(long), &roomnum, sizeof(long));
 556         strcpy(kv->val.ptr + sizeof(long) + sizeof(long), euid);
 557
 558         return(1);
 559 }
 560
 561
 562 // Import a "users by number" (secondary index) record
 563 // The key is a "long"
 564 int import_usersbynumber(char *line, struct cdbkeyval *kv) {
 565         char *token;
 566         long usernum;
 567
 568         char *p = line;
 569         for (int i=0; (token = strsep(&p, "|")); ++i) {
 570                 switch(i) {
 571                         case 1:
 572                                 usernum = atol(token);
 573                                 break;
 574                         case 2:
 575                                 kv->key.len = sizeof(long);
 576                                 kv->key.ptr = reallok(NULL, sizeof(long));
 577                                 memcpy(kv->key.ptr, &usernum, kv->key.len);
 578                                 kv->val.ptr = (char *) strdup(token);
 579                                 kv->val.len = strlen(kv->val.ptr) + 1;
 580                                 return(1);
 581                 }
 582         }
 583
 584         return(0);              // should never get here unless it's a bad record
 585 }
 586
 587
 588 // Import a config record
 589 // The key is the config key
 590 // The data is the config key, a null, the value, and another null
 591 int import_config(char *line, struct cdbkeyval *kv) {
 592         char *token;
 593         char *p = line;
 594         char *k, *v;
 595
 596         for (int i=0; (token = strsep(&p, "|")); ++i) {
 597                 switch(i) {
 598                         case 1:
 599                                 k = token;
 600                                 kv->key.len = strlen(token);
 601                                 kv->key.ptr = strdup(token);
 602                                 break;
 603                         case 2:
 604                                 v = token;
 605                                 kv->val.len = strlen(k) + strlen(v) + 2;
 606                                 kv->val.ptr = (char *) reallok(NULL, kv->val.len);
 607                                 strcpy(kv->val.ptr, k);
 608                                 strcpy(kv->val.ptr + strlen(k) + 1, v);
 609                                 break;
 610                 }
 611         }
 612
 613         return(1);
 614 }
 615
 616
 617 // Ingest one line of dump data.  NOT REENTRANT
 618 void ingest_one(char *line, struct cdbkeyval *kv) {
 619
 620         static int good_rows = 0;
 621         static int bad_rows = 0;
 622         static int current_cdb = -1 ;
 623         char record_type[32];
 624         int row_was_good;
 625
 626         // Clear out our record buffer
 627         memset(kv, 0, sizeof(struct cdbkeyval));
 628         row_was_good = 0;
 629
 630         // Identify the record type we are currently working with,
 631         // then call the correct conversion function to load up our record buffer.
 632         extract_token(record_type, line, 0, '|', sizeof record_type);
 633         if (!strcasecmp(record_type, "msgtext")) {
 634                 current_cdb = CDB_MSGMAIN;
 635                 row_was_good = import_msgtext(line, kv);
 636         }
 637         else if (!strcasecmp(record_type, "msgmeta")) {
 638                 current_cdb = CDB_MSGMAIN;
 639                 row_was_good = import_msgmeta(line, kv);
 640         }
 641         else if (!strcasecmp(record_type, "user")) {
 642                 current_cdb = CDB_USERS;
 643                 row_was_good = import_user(line, kv);
 644         }
 645         else if (!strcasecmp(record_type, "room")) {
 646                 current_cdb = CDB_ROOMS;
 647                 row_was_good = import_room(line, kv);
 648         }
 649         else if (!strcasecmp(record_type, "floor")) {
 650                 current_cdb = CDB_FLOORTAB;
 651                 row_was_good = import_floor(line, kv);
 652         }
 653         else if (!strcasecmp(record_type, "msglist")) {
 654                 current_cdb = CDB_MSGLISTS;
 655                 row_was_good = import_msglist(line, kv);
 656         }
 657         else if (!strcasecmp(record_type, "visit")) {
 658                 current_cdb = CDB_VISIT;
 659                 row_was_good = import_visit(line, kv);
 660         }
 661         else if (!strcasecmp(record_type, "dir")) {
 662                 current_cdb = CDB_DIRECTORY;
 663                 row_was_good = import_dir(line, kv);
 664         }
 665         else if (!strcasecmp(record_type, "use")) {
 666                 current_cdb = CDB_USETABLE;
 667                 row_was_good = import_usetable(line, kv);
 668         }
 669         else if (!strcasecmp(record_type, "bigmsg")) {
 670                 current_cdb = CDB_BIGMSGS;
 671                 row_was_good = import_msgtext(line, kv);
 672         }
 673         else if (!strcasecmp(record_type, "fulltext")) {
 674                 current_cdb = CDB_FULLTEXT;
 675                 row_was_good = import_fulltext(line, kv);
 676         }
 677         else if (!strcasecmp(record_type, "euidindex")) {
 678                 current_cdb = CDB_EUIDINDEX;
 679                 row_was_good = import_euidindex(line, kv);
 680         }
 681         else if (!strcasecmp(record_type, "usersbynumber")) {
 682                 current_cdb = CDB_USERSBYNUMBER;
 683                 row_was_good = import_usersbynumber(line, kv);
 684         }
 685         else if (!strcasecmp(record_type, "config")) {
 686                 current_cdb = CDB_CONFIG;
 687                 row_was_good = import_config(line, kv);
 688         }
 689         else {
 690                 current_cdb = -1 ;
 691         }
 692
 693         // If the conversion function was successful, write the record to the database.
 694         if ( (row_was_good) && (current_cdb >= 0) ) {
 695                 cdb_store(current_cdb, kv->key.ptr, kv->key.len, kv->val.ptr, kv->val.len);
 696                 ++good_rows;
 697         }
 698         else {
 699                 fprintf(stderr, "bad row: <%s>\n", line);
 700                 ++bad_rows;
 701         }
 702
 703         fprintf(stderr, "\r   \033[32m%9d\033[0m / \033[31m%8d\033[0m ", good_rows, bad_rows);
 704         fflush(stderr);
 705
 706 }
 707
 708
 709 // This is the loop that loads the dump data.  NOT REENTRANT
 710 void ingest(void) {
 711         static size_t line_alloc = 1;
 712         static char *line;
 713         static size_t line_len = 0;
 714         int ch;
 715         int begin_found = 0;
 716         int end_found = 0;
 717         struct cdbkeyval kv;
 718
 719         memset(&kv, 0, sizeof(struct cdbkeyval));
 720
 721         line = reallok(NULL, line_alloc);
 722
 723         do {
 724                 line_len = 0;
 725
 726                 while (ch = getc(stdin), ((ch != '\n') && (ch > 0))) {
 727                         if ((line_len+2) > line_alloc) {
 728                                 line_alloc *= 2;
 729                                 line = reallok(line, line_alloc);
 730                         }
 731                         line[line_len++] = ch;
 732                         line[line_len] = 0;
 733                 }
 734
 735                 if (ch <= 0) {
 736                         return;
 737                 }
 738
 739                 if (line_len > 0) {
 740                         if (!strncasecmp(line, HKEY("end|"))) {
 741                                 fprintf(stderr, "\n");
 742                                 end_found = 1;
 743                         }
 744                         if ( (begin_found) && (!end_found) ) {
 745                                 ingest_one(line, &kv);
 746                         }
 747                         if (!strncasecmp(line, HKEY("begin|"))) {
 748                                 begin_found = 1;
 749                                 fprintf(stderr, "   good rows / bad rows:\n");
 750                         }
 751                 }
 752
 753         } while (ch >= 0);
 754
 755         if (!begin_found) {
 756                 fprintf(stderr, "\033[31mWARNING: \"begin\" line was not found in the loaded data.\033[0m\n");
 757         }
 758         if (!end_found) {
 759                 fprintf(stderr, "\033[31mWARNING: \"end\" line was not found in the loaded data.\033[0m\n");
 760         }
 761 }
 762
 763
 764 // Main entry point
 765 int main(int argc, char **argv) {
 766         int confirmed = 0;
 767         char *ctdldir = CTDLDIR;
 768
 769         // display the greeting
 770         fprintf(stderr,
 771                 "\033[44m\033[1m╔════════════════════════════════════════════════════════════════════════╗\033[0m\n"
 772                 "\033[44m\033[1m║ DB Load utility for Citadel                               version %-4d ║\033[0m\n"
 773                 "\033[44m\033[1m║ Copyright (c) 2023-2024 by citadel.org et al.                          ║\033[0m\n"
 774                 "\033[44m\033[1m║ This program is open source software.  Use, duplication, or disclosure ║\033[0m\n"
 775                 "\033[44m\033[1m║ is subject to the terms of the GNU General Public license v3.          ║\033[0m\n"
 776                 "\033[44m\033[1m╚════════════════════════════════════════════════════════════════════════╝\033[0m\n",
 777                 REV_LEVEL
 778         );
 779
 780         // Parse command line
 781         int a;
 782         while ((a = getopt(argc, argv, "h:y")) != EOF) {
 783                 switch (a) {
 784                 case 'h':
 785                         ctdldir = optarg;
 786                         break;
 787                 case 'y':
 788                         confirmed = 1;
 789                         break;
 790                 default:
 791                         fprintf(stderr, "%s: usage: %s -h citadel_dir [<dumpfile]\n", argv[0], argv[0]);
 792                         exit(2);
 793                 }
 794         }
 795
 796         if (confirmed == 1) {
 797                 fprintf(stderr, "ctdlload: You have specified the [-y] flag, so processing will continue.\n");
 798         }
 799         else {
 800                 fprintf(stderr, "ctdlload: usage: ctdlload -y -h[citadel_dir] <[dump_file]\n");
 801                 fprintf(stderr, "          -y : yes, I know this program can do damage and I want to run it anyway.\n");
 802                 fprintf(stderr, "          -h : [citadel_dir] is your server directory, usually /usr/local/citadel\n");
 803                 fprintf(stderr, "          Please read [ https://www.citadel.org/dump-and-load.html ] to learn how to proceed.\n");
 804                 exit(1);
 805         }
 806
 807         if (chdir(ctdldir) != 0) {
 808                 fprintf(stderr, "ctdlload: unable to change directory to [%s]: %m", ctdldir);
 809                 exit(2);
 810         }
 811
 812         // backend modules use syslog -- redirect to stderr
 813         openlog("ctdlload", LOG_PERROR , LOG_DAEMON);
 814
 815         // Remove any database that is already in the target directory (yes, delete it, be careful)
 816         system("rm -fv ./data/*");
 817
 818         // initialize the database backend
 819         cdb_init_backends();
 820         cdb_open_databases();
 821
 822         // Load rows from the input source
 823         ingest();
 824
 825         // close databases
 826         cdb_close_databases();
 827
 828         fprintf(stderr, "ctdlload: \033[32m\033[1mfinished\033[0m\n");
 829         exit(0);
 830 }