1 /* 2 * Copyright (c) 1998-2001 Sendmail, Inc. and its suppliers. 3 * All rights reserved. 4 * Copyright (c) 1992 Eric P. Allman. All rights reserved. 5 * Copyright (c) 1992, 1993 6 * The Regents of the University of California. All rights reserved. 7 * 8 * By using this file, you agree to the terms and conditions set 9 * forth in the LICENSE file which can be found at the top level of 10 * the sendmail distribution. 11 * 12 */ 13 14 #include <sm/gen.h> 15 16 SM_IDSTR(copyright, 17 "@(#) Copyright (c) 1998-2001 Sendmail, Inc. and its suppliers.\n\ 18 All rights reserved.\n\ 19 Copyright (c) 1992 Eric P. Allman. All rights reserved.\n\ 20 Copyright (c) 1992, 1993\n\ 21 The Regents of the University of California. All rights reserved.\n") 22 23 SM_IDSTR(id, "@(#)$Id: makemap.c,v 8.175 2001/12/28 22:44:01 ca Exp $") 24 25 26 #include <sys/types.h> 27 #ifndef ISC_UNIX 28 # include <sys/file.h> 29 #endif /* ! ISC_UNIX */ 30 #include <ctype.h> 31 #include <stdlib.h> 32 #include <unistd.h> 33 #ifdef EX_OK 34 # undef EX_OK /* unistd.h may have another use for this */ 35 #endif /* EX_OK */ 36 #include <sysexits.h> 37 #include <sendmail/sendmail.h> 38 #include <sendmail/pathnames.h> 39 #include <libsmdb/smdb.h> 40 41 uid_t RealUid; 42 gid_t RealGid; 43 char *RealUserName; 44 uid_t RunAsUid; 45 uid_t RunAsGid; 46 char *RunAsUserName; 47 int Verbose = 2; 48 bool DontInitGroups = false; 49 uid_t TrustedUid = 0; 50 BITMAP256 DontBlameSendmail; 51 52 #define BUFSIZE 1024 53 #define ISSEP(c) (sep == '\0' ? isascii(c) && isspace(c) : (c) == sep) 54 55 static void 56 usage(progname) 57 char *progname; 58 { 59 /* XXX break the usage output into multiple lines? it's too long */ 60 sm_io_fprintf(smioerr, SM_TIME_DEFAULT, 61 "Usage: %s [-C cffile] [-N] [-c cachesize] [-d] [-e] [-f] [-l] [-o] [-r] [-s] [-t delimiter] [-u] [-v] type mapname\n", 62 progname); 63 #if _FFR_COMMENT_CHAR 64 /* add -D comment-char */ 65 #endif /* _FFR_COMMENT_CHAR */ 66 exit(EX_USAGE); 67 } 68 69 int 70 main(argc, argv) 71 int argc; 72 char **argv; 73 { 74 char *progname; 75 char *cfile; 76 bool inclnull = false; 77 bool notrunc = false; 78 bool allowreplace = false; 79 bool allowempty = false; 80 bool verbose = false; 81 bool foldcase = true; 82 bool unmake = false; 83 char sep = '\0'; 84 char comment = '#'; 85 int exitstat; 86 int opt; 87 char *typename = NULL; 88 char *mapname = NULL; 89 unsigned int lineno; 90 int st; 91 int mode; 92 int smode; 93 int putflags = 0; 94 long sff = SFF_ROOTOK|SFF_REGONLY; 95 struct passwd *pw; 96 SMDB_DATABASE *database; 97 SMDB_CURSOR *cursor; 98 SMDB_DBENT db_key, db_val; 99 SMDB_DBPARAMS params; 100 SMDB_USER_INFO user_info; 101 char ibuf[BUFSIZE]; 102 #if HASFCHOWN 103 SM_FILE_T *cfp; 104 char buf[MAXLINE]; 105 #endif /* HASFCHOWN */ 106 static char rnamebuf[MAXNAME]; /* holds RealUserName */ 107 extern char *optarg; 108 extern int optind; 109 110 memset(¶ms, '\0', sizeof params); 111 params.smdbp_cache_size = 1024 * 1024; 112 113 progname = strrchr(argv[0], '/'); 114 if (progname != NULL) 115 progname++; 116 else 117 progname = argv[0]; 118 cfile = getcfname(0, 0, SM_GET_SENDMAIL_CF, NULL); 119 120 clrbitmap(DontBlameSendmail); 121 RunAsUid = RealUid = getuid(); 122 RunAsGid = RealGid = getgid(); 123 pw = getpwuid(RealUid); 124 if (pw != NULL) 125 (void) sm_strlcpy(rnamebuf, pw->pw_name, sizeof rnamebuf); 126 else 127 (void) sm_snprintf(rnamebuf, sizeof rnamebuf, 128 "Unknown UID %d", (int) RealUid); 129 RunAsUserName = RealUserName = rnamebuf; 130 user_info.smdbu_id = RunAsUid; 131 user_info.smdbu_group_id = RunAsGid; 132 (void) sm_strlcpy(user_info.smdbu_name, RunAsUserName, 133 SMDB_MAX_USER_NAME_LEN); 134 135 #define OPTIONS "C:D:Nc:deflorst:uv" 136 while ((opt = getopt(argc, argv, OPTIONS)) != -1) 137 { 138 switch (opt) 139 { 140 case 'C': 141 cfile = optarg; 142 break; 143 144 case 'N': 145 inclnull = true; 146 break; 147 148 case 'c': 149 params.smdbp_cache_size = atol(optarg); 150 break; 151 152 case 'd': 153 params.smdbp_allow_dup = true; 154 break; 155 156 case 'e': 157 allowempty = true; 158 break; 159 160 case 'f': 161 foldcase = false; 162 break; 163 164 #if _FFR_COMMENT_CHAR 165 case 'D': 166 comment = *optarg; 167 break; 168 #endif /* _FFR_COMMENT_CHAR */ 169 170 case 'l': 171 smdb_print_available_types(); 172 exit(EX_OK); 173 break; 174 175 case 'o': 176 notrunc = true; 177 break; 178 179 case 'r': 180 allowreplace = true; 181 break; 182 183 case 's': 184 setbitn(DBS_MAPINUNSAFEDIRPATH, DontBlameSendmail); 185 setbitn(DBS_WRITEMAPTOHARDLINK, DontBlameSendmail); 186 setbitn(DBS_WRITEMAPTOSYMLINK, DontBlameSendmail); 187 setbitn(DBS_LINKEDMAPINWRITABLEDIR, DontBlameSendmail); 188 break; 189 190 case 't': 191 if (optarg == NULL || *optarg == '\0') 192 { 193 sm_io_fprintf(smioerr, SM_TIME_DEFAULT, 194 "Invalid separator\n"); 195 break; 196 } 197 sep = *optarg; 198 break; 199 200 case 'u': 201 unmake = true; 202 break; 203 204 case 'v': 205 verbose = true; 206 break; 207 208 default: 209 usage(progname); 210 /* NOTREACHED */ 211 } 212 } 213 214 if (!bitnset(DBS_WRITEMAPTOSYMLINK, DontBlameSendmail)) 215 sff |= SFF_NOSLINK; 216 if (!bitnset(DBS_WRITEMAPTOHARDLINK, DontBlameSendmail)) 217 sff |= SFF_NOHLINK; 218 if (!bitnset(DBS_LINKEDMAPINWRITABLEDIR, DontBlameSendmail)) 219 sff |= SFF_NOWLINK; 220 221 argc -= optind; 222 argv += optind; 223 if (argc != 2) 224 { 225 usage(progname); 226 /* NOTREACHED */ 227 } 228 else 229 { 230 typename = argv[0]; 231 mapname = argv[1]; 232 } 233 234 #if HASFCHOWN 235 /* Find TrustedUser value in sendmail.cf */ 236 if ((cfp = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, cfile, SM_IO_RDONLY, 237 NULL)) == NULL) 238 { 239 sm_io_fprintf(smioerr, SM_TIME_DEFAULT, "makemap: %s: %s", 240 cfile, sm_errstring(errno)); 241 exit(EX_NOINPUT); 242 } 243 while (sm_io_fgets(cfp, SM_TIME_DEFAULT, buf, sizeof(buf)) != NULL) 244 { 245 register char *b; 246 247 if ((b = strchr(buf, '\n')) != NULL) 248 *b = '\0'; 249 250 b = buf; 251 switch (*b++) 252 { 253 case 'O': /* option */ 254 if (strncasecmp(b, " TrustedUser", 12) == 0 && 255 !(isascii(b[12]) && isalnum(b[12]))) 256 { 257 b = strchr(b, '='); 258 if (b == NULL) 259 continue; 260 while (isascii(*++b) && isspace(*b)) 261 continue; 262 if (isascii(*b) && isdigit(*b)) 263 TrustedUid = atoi(b); 264 else 265 { 266 TrustedUid = 0; 267 pw = getpwnam(b); 268 if (pw == NULL) 269 (void) sm_io_fprintf(smioerr, 270 SM_TIME_DEFAULT, 271 "TrustedUser: unknown user %s\n", b); 272 else 273 TrustedUid = pw->pw_uid; 274 } 275 276 # ifdef UID_MAX 277 if (TrustedUid > UID_MAX) 278 { 279 (void) sm_io_fprintf(smioerr, 280 SM_TIME_DEFAULT, 281 "TrustedUser: uid value (%ld) > UID_MAX (%ld)", 282 (long) TrustedUid, 283 (long) UID_MAX); 284 TrustedUid = 0; 285 } 286 # endif /* UID_MAX */ 287 break; 288 } 289 290 291 default: 292 continue; 293 } 294 } 295 (void) sm_io_close(cfp, SM_TIME_DEFAULT); 296 #endif /* HASFCHOWN */ 297 298 if (!params.smdbp_allow_dup && !allowreplace) 299 putflags = SMDBF_NO_OVERWRITE; 300 301 if (unmake) 302 { 303 mode = O_RDONLY; 304 smode = S_IRUSR; 305 } 306 else 307 { 308 mode = O_RDWR; 309 if (!notrunc) 310 { 311 mode |= O_CREAT|O_TRUNC; 312 sff |= SFF_CREAT; 313 } 314 smode = S_IWUSR; 315 } 316 317 params.smdbp_num_elements = 4096; 318 319 errno = smdb_open_database(&database, mapname, mode, smode, sff, 320 typename, &user_info, ¶ms); 321 if (errno != SMDBE_OK) 322 { 323 char *hint; 324 325 if (errno == SMDBE_UNSUPPORTED_DB_TYPE && 326 (hint = smdb_db_definition(typename)) != NULL) 327 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT, 328 "%s: Need to recompile with -D%s for %s support\n", 329 progname, hint, typename); 330 else 331 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT, 332 "%s: error opening type %s map %s: %s\n", 333 progname, typename, mapname, 334 sm_errstring(errno)); 335 exit(EX_CANTCREAT); 336 } 337 338 (void) database->smdb_sync(database, 0); 339 340 if (!unmake && geteuid() == 0 && TrustedUid != 0) 341 { 342 errno = database->smdb_set_owner(database, TrustedUid, -1); 343 if (errno != SMDBE_OK) 344 { 345 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT, 346 "WARNING: ownership change on %s failed %s", 347 mapname, sm_errstring(errno)); 348 } 349 } 350 351 /* 352 ** Copy the data 353 */ 354 355 exitstat = EX_OK; 356 if (unmake) 357 { 358 errno = database->smdb_cursor(database, &cursor, 0); 359 if (errno != SMDBE_OK) 360 { 361 362 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT, 363 "%s: cannot make cursor for type %s map %s\n", 364 progname, typename, mapname); 365 exit(EX_SOFTWARE); 366 } 367 368 memset(&db_key, '\0', sizeof db_key); 369 memset(&db_val, '\0', sizeof db_val); 370 371 for (lineno = 0; ; lineno++) 372 { 373 errno = cursor->smdbc_get(cursor, &db_key, &db_val, 374 SMDB_CURSOR_GET_NEXT); 375 if (errno != SMDBE_OK) 376 break; 377 378 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 379 "%.*s\t%.*s\n", 380 (int) db_key.size, 381 (char *) db_key.data, 382 (int) db_val.size, 383 (char *)db_val.data); 384 385 } 386 (void) cursor->smdbc_close(cursor); 387 } 388 else 389 { 390 lineno = 0; 391 while (sm_io_fgets(smioin, SM_TIME_DEFAULT, ibuf, sizeof ibuf) 392 != NULL) 393 { 394 register char *p; 395 396 lineno++; 397 398 /* 399 ** Parse the line. 400 */ 401 402 p = strchr(ibuf, '\n'); 403 if (p != NULL) 404 *p = '\0'; 405 else if (!sm_io_eof(smioin)) 406 { 407 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT, 408 "%s: %s: line %u: line too long (%ld bytes max)\n", 409 progname, mapname, lineno, 410 (long) sizeof ibuf); 411 exitstat = EX_DATAERR; 412 continue; 413 } 414 415 if (ibuf[0] == '\0' || ibuf[0] == comment) 416 continue; 417 if (sep == '\0' && isascii(ibuf[0]) && isspace(ibuf[0])) 418 { 419 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT, 420 "%s: %s: line %u: syntax error (leading space)\n", 421 progname, mapname, lineno); 422 exitstat = EX_DATAERR; 423 continue; 424 } 425 426 memset(&db_key, '\0', sizeof db_key); 427 memset(&db_val, '\0', sizeof db_val); 428 db_key.data = ibuf; 429 430 for (p = ibuf; *p != '\0' && !(ISSEP(*p)); p++) 431 { 432 if (foldcase && isascii(*p) && isupper(*p)) 433 *p = tolower(*p); 434 } 435 db_key.size = p - ibuf; 436 if (inclnull) 437 db_key.size++; 438 439 if (*p != '\0') 440 *p++ = '\0'; 441 while (*p != '\0' && ISSEP(*p)) 442 p++; 443 if (!allowempty && *p == '\0') 444 { 445 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT, 446 "%s: %s: line %u: no RHS for LHS %s\n", 447 progname, mapname, lineno, 448 (char *) db_key.data); 449 exitstat = EX_DATAERR; 450 continue; 451 } 452 453 db_val.data = p; 454 db_val.size = strlen(p); 455 if (inclnull) 456 db_val.size++; 457 458 /* 459 ** Do the database insert. 460 */ 461 462 if (verbose) 463 { 464 (void) sm_io_fprintf(smioout, SM_TIME_DEFAULT, 465 "key=`%s', val=`%s'\n", 466 (char *) db_key.data, 467 (char *) db_val.data); 468 } 469 470 errno = database->smdb_put(database, &db_key, &db_val, 471 putflags); 472 switch (errno) 473 { 474 case SMDBE_KEY_EXIST: 475 st = 1; 476 break; 477 478 case 0: 479 st = 0; 480 break; 481 482 default: 483 st = -1; 484 break; 485 } 486 487 if (st < 0) 488 { 489 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT, 490 "%s: %s: line %u: key %s: put error: %s\n", 491 progname, mapname, lineno, 492 (char *) db_key.data, 493 sm_errstring(errno)); 494 exitstat = EX_IOERR; 495 } 496 else if (st > 0) 497 { 498 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT, 499 "%s: %s: line %u: key %s: duplicate key\n", 500 progname, mapname, 501 lineno, 502 (char *) db_key.data); 503 exitstat = EX_DATAERR; 504 } 505 } 506 } 507 508 /* 509 ** Now close the database. 510 */ 511 512 errno = database->smdb_close(database); 513 if (errno != SMDBE_OK) 514 { 515 (void) sm_io_fprintf(smioerr, SM_TIME_DEFAULT, 516 "%s: close(%s): %s\n", 517 progname, mapname, sm_errstring(errno)); 518 exitstat = EX_IOERR; 519 } 520 smdb_free_database(database); 521 522 exit(exitstat); 523 524 /* NOTREACHED */ 525 return exitstat; 526 } 527