1 # include <pwd.h> 2 # include <sys/types.h> 3 # include <sys/stat.h> 4 # include <signal.h> 5 # include "sendmail.h" 6 7 # ifdef DBM 8 SCCSID(@(#)alias.c 4.1 07/25/83 (with DBM)); 9 # else DBM 10 SCCSID(@(#)alias.c 4.1 07/25/83 (without DBM)); 11 # endif DBM 12 13 /* 14 ** ALIAS -- Compute aliases. 15 ** 16 ** Scans the alias file for an alias for the given address. 17 ** If found, it arranges to deliver to the alias list instead. 18 ** Uses libdbm database if -DDBM. 19 ** 20 ** Parameters: 21 ** a -- address to alias. 22 ** sendq -- a pointer to the head of the send queue 23 ** to put the aliases in. 24 ** 25 ** Returns: 26 ** none 27 ** 28 ** Side Effects: 29 ** Aliases found are expanded. 30 ** 31 ** Notes: 32 ** If NoAlias (the "-n" flag) is set, no aliasing is 33 ** done. 34 ** 35 ** Deficiencies: 36 ** It should complain about names that are aliased to 37 ** nothing. 38 */ 39 40 41 #ifdef DBM 42 typedef struct 43 { 44 char *dptr; 45 int dsize; 46 } DATUM; 47 extern DATUM fetch(); 48 #endif DBM 49 50 alias(a, sendq) 51 register ADDRESS *a; 52 ADDRESS **sendq; 53 { 54 register char *p; 55 extern char *aliaslookup(); 56 57 if (NoAlias) 58 return; 59 # ifdef DEBUG 60 if (tTd(27, 1)) 61 printf("alias(%s)\n", a->q_paddr); 62 # endif 63 64 /* don't realias already aliased names */ 65 if (bitset(QDONTSEND, a->q_flags)) 66 return; 67 68 CurEnv->e_to = a->q_paddr; 69 70 /* 71 ** Look up this name 72 */ 73 74 p = aliaslookup(a->q_user); 75 if (p == NULL) 76 return; 77 78 /* 79 ** Match on Alias. 80 ** Deliver to the target list. 81 */ 82 83 # ifdef DEBUG 84 if (tTd(27, 1)) 85 printf("%s (%s, %s) aliased to %s\n", 86 a->q_paddr, a->q_host, a->q_user, p); 87 # endif 88 message(Arpa_Info, "aliased to %s", p); 89 AliasLevel++; 90 sendtolist(p, a, sendq); 91 AliasLevel--; 92 } 93 /* 94 ** ALIASLOOKUP -- look up a name in the alias file. 95 ** 96 ** Parameters: 97 ** name -- the name to look up. 98 ** 99 ** Returns: 100 ** the value of name. 101 ** NULL if unknown. 102 ** 103 ** Side Effects: 104 ** none. 105 ** 106 ** Warnings: 107 ** The return value will be trashed across calls. 108 */ 109 110 char * 111 aliaslookup(name) 112 char *name; 113 { 114 # ifdef DBM 115 DATUM rhs, lhs; 116 117 /* create a key for fetch */ 118 lhs.dptr = name; 119 lhs.dsize = strlen(name) + 1; 120 rhs = fetch(lhs); 121 return (rhs.dptr); 122 # else DBM 123 register STAB *s; 124 125 s = stab(name, ST_ALIAS, ST_FIND); 126 if (s == NULL) 127 return (NULL); 128 return (s->s_alias); 129 # endif DBM 130 } 131 /* 132 ** INITALIASES -- initialize for aliasing 133 ** 134 ** Very different depending on whether we are running DBM or not. 135 ** 136 ** Parameters: 137 ** aliasfile -- location of aliases. 138 ** init -- if set and if DBM, initialize the DBM files. 139 ** 140 ** Returns: 141 ** none. 142 ** 143 ** Side Effects: 144 ** initializes aliases: 145 ** if DBM: opens the database. 146 ** if ~DBM: reads the aliases into the symbol table. 147 */ 148 149 # define DBMMODE 0666 150 151 initaliases(aliasfile, init) 152 char *aliasfile; 153 bool init; 154 { 155 #ifdef DBM 156 int atcnt; 157 char buf[MAXNAME]; 158 time_t modtime; 159 int (*oldsigint)(); 160 #endif DBM 161 struct stat stb; 162 163 if (stat(aliasfile, &stb) < 0) 164 { 165 NoAlias = TRUE; 166 errno = 0; 167 return; 168 } 169 170 # ifdef DBM 171 /* 172 ** Check to see that the alias file is complete. 173 ** If not, we will assume that someone died, and it is up 174 ** to us to rebuild it. 175 */ 176 177 dbminit(aliasfile); 178 atcnt = 10; 179 while (SafeAlias && !init && atcnt-- >= 0 && aliaslookup("@") == NULL) 180 sleep(30); 181 182 /* 183 ** See if the DBM version of the file is out of date with 184 ** the text version. If so, go into 'init' mode automatically. 185 ** This only happens if our effective userid owns the DBM 186 ** version or if the mode of the database is 666 -- this 187 ** is an attempt to avoid protection problems. Note the 188 ** unpalatable hack to see if the stat succeeded. 189 */ 190 191 modtime = stb.st_mtime; 192 (void) strcpy(buf, aliasfile); 193 (void) strcat(buf, ".pag"); 194 stb.st_ino = 0; 195 if (!init && (atcnt < 0 || stat(buf, &stb) < 0 || stb.st_mtime < modtime)) 196 { 197 errno = 0; 198 if (AutoRebuild && stb.st_ino != 0 && 199 ((stb.st_mode & 0777) == 0666 || stb.st_uid == geteuid())) 200 { 201 init = TRUE; 202 message(Arpa_Info, "rebuilding alias database"); 203 } 204 else 205 { 206 bool oldverb = Verbose; 207 208 Verbose = TRUE; 209 message(Arpa_Info, "Warning: alias database out of date"); 210 Verbose = oldverb; 211 } 212 } 213 214 /* 215 ** If initializing, create the new files. 216 ** We should lock the alias file here to prevent other 217 ** instantiations of sendmail from reading an incomplete 218 ** file -- or worse yet, doing a concurrent initialize. 219 */ 220 221 if (init) 222 { 223 oldsigint = signal(SIGINT, SIG_IGN); 224 (void) strcpy(buf, aliasfile); 225 (void) strcat(buf, ".dir"); 226 if (close(creat(buf, DBMMODE)) < 0) 227 { 228 syserr("cannot make %s", buf); 229 (void) signal(SIGINT, oldsigint); 230 return; 231 } 232 (void) strcpy(buf, aliasfile); 233 (void) strcat(buf, ".pag"); 234 if (close(creat(buf, DBMMODE)) < 0) 235 { 236 syserr("cannot make %s", buf); 237 (void) signal(SIGINT, oldsigint); 238 return; 239 } 240 } 241 242 /* 243 ** If necessary, load the DBM file. 244 ** If running without DBM, load the symbol table. 245 ** After loading the DBM file, add the distinquished alias "@". 246 */ 247 248 if (init) 249 { 250 DATUM key; 251 252 readaliases(aliasfile, TRUE); 253 key.dsize = 2; 254 key.dptr = "@"; 255 store(key, key); 256 (void) signal(SIGINT, oldsigint); 257 } 258 # else DBM 259 readaliases(aliasfile, init); 260 # endif DBM 261 } 262 /* 263 ** READALIASES -- read and process the alias file. 264 ** 265 ** This routine implements the part of initaliases that occurs 266 ** when we are not going to use the DBM stuff. 267 ** 268 ** Parameters: 269 ** aliasfile -- the pathname of the alias file master. 270 ** init -- if set, initialize the DBM stuff. 271 ** 272 ** Returns: 273 ** none. 274 ** 275 ** Side Effects: 276 ** Reads aliasfile into the symbol table. 277 ** Optionally, builds the .dir & .pag files. 278 */ 279 280 static 281 readaliases(aliasfile, init) 282 char *aliasfile; 283 bool init; 284 { 285 register char *p; 286 char *p2; 287 char *rhs; 288 bool skipping; 289 int naliases, bytes, longest; 290 FILE *af; 291 ADDRESS al, bl; 292 register STAB *s; 293 char line[BUFSIZ]; 294 295 if ((af = fopen(aliasfile, "r")) == NULL) 296 { 297 # ifdef DEBUG 298 if (tTd(27, 1)) 299 printf("Can't open %s\n", aliasfile); 300 # endif 301 errno = 0; 302 NoAlias++; 303 return; 304 } 305 306 /* 307 ** Read and interpret lines 308 */ 309 310 FileName = aliasfile; 311 LineNumber = 0; 312 naliases = bytes = longest = 0; 313 skipping = FALSE; 314 while (fgets(line, sizeof (line), af) != NULL) 315 { 316 int lhssize, rhssize; 317 318 LineNumber++; 319 switch (line[0]) 320 { 321 case '#': 322 case '\n': 323 case '\0': 324 skipping = FALSE; 325 continue; 326 327 case ' ': 328 case '\t': 329 if (!skipping) 330 syserr("Non-continuation line starts with space"); 331 skipping = TRUE; 332 continue; 333 } 334 skipping = FALSE; 335 336 /* 337 ** Process the LHS 338 ** Find the final colon, and parse the address. 339 ** It should resolve to a local name -- this will 340 ** be checked later (we want to optionally do 341 ** parsing of the RHS first to maximize error 342 ** detection). 343 */ 344 345 for (p = line; *p != '\0' && *p != ':' && *p != '\n'; p++) 346 continue; 347 if (*p++ != ':') 348 { 349 syserr("missing colon"); 350 continue; 351 } 352 if (parseaddr(line, &al, 1, ':') == NULL) 353 { 354 syserr("illegal alias name"); 355 continue; 356 } 357 358 /* 359 ** Process the RHS. 360 ** 'al' is the internal form of the LHS address. 361 ** 'p' points to the text of the RHS. 362 */ 363 364 rhs = p; 365 for (;;) 366 { 367 register char c; 368 369 if (init) 370 { 371 /* do parsing & compression of addresses */ 372 c = *p; 373 while (c != '\0') 374 { 375 p2 = p; 376 while (*p != '\n' && *p != ',' && *p != '\0') 377 p++; 378 c = *p; 379 *p++ = '\0'; 380 if (c == '\n') 381 c = '\0'; 382 if (*p2 == '\0') 383 { 384 p[-1] = c; 385 continue; 386 } 387 (void) parseaddr(p2, &bl, -1, ','); 388 p[-1] = c; 389 while (isspace(*p)) 390 p++; 391 } 392 } 393 else 394 p = &p[strlen(p)]; 395 396 /* see if there should be a continuation line */ 397 c = fgetc(af); 398 if (!feof(af)) 399 (void) ungetc(c, af); 400 if (c != ' ' && c != '\t') 401 break; 402 403 /* read continuation line */ 404 p--; 405 if (fgets(p, sizeof line - (p - line), af) == NULL) 406 break; 407 LineNumber++; 408 } 409 if (al.q_mailer != LocalMailer) 410 { 411 syserr("cannot alias non-local names"); 412 continue; 413 } 414 415 /* 416 ** Insert alias into symbol table or DBM file 417 */ 418 419 lhssize = strlen(al.q_user) + 1; 420 rhssize = strlen(rhs) + 1; 421 422 # ifdef DBM 423 if (init) 424 { 425 DATUM key, content; 426 427 key.dsize = lhssize; 428 key.dptr = al.q_user; 429 content.dsize = rhssize; 430 content.dptr = rhs; 431 store(key, content); 432 } 433 else 434 # endif DBM 435 { 436 s = stab(al.q_user, ST_ALIAS, ST_ENTER); 437 s->s_alias = newstr(rhs); 438 } 439 440 /* statistics */ 441 naliases++; 442 bytes += lhssize + rhssize; 443 if (rhssize > longest) 444 longest = rhssize; 445 } 446 (void) fclose(af); 447 CurEnv->e_to = NULL; 448 FileName = NULL; 449 message(Arpa_Info, "%d aliases, longest %d bytes, %d bytes total", 450 naliases, longest, bytes); 451 } 452 /* 453 ** FORWARD -- Try to forward mail 454 ** 455 ** This is similar but not identical to aliasing. 456 ** 457 ** Parameters: 458 ** user -- the name of the user who's mail we would like 459 ** to forward to. It must have been verified -- 460 ** i.e., the q_home field must have been filled 461 ** in. 462 ** sendq -- a pointer to the head of the send queue to 463 ** put this user's aliases in. 464 ** 465 ** Returns: 466 ** none. 467 ** 468 ** Side Effects: 469 ** New names are added to send queues. 470 */ 471 472 forward(user, sendq) 473 ADDRESS *user; 474 ADDRESS **sendq; 475 { 476 char buf[60]; 477 extern bool safefile(); 478 479 # ifdef DEBUG 480 if (tTd(27, 1)) 481 printf("forward(%s)\n", user->q_paddr); 482 # endif DEBUG 483 484 if (user->q_mailer != LocalMailer || bitset(QBADADDR, user->q_flags)) 485 return; 486 # ifdef DEBUG 487 if (user->q_home == NULL) 488 syserr("forward: no home"); 489 # endif DEBUG 490 491 /* good address -- look for .forward file in home */ 492 define('z', user->q_home, CurEnv); 493 expand("$z/.forward", buf, &buf[sizeof buf - 1], CurEnv); 494 if (!safefile(buf, user->q_uid, S_IREAD)) 495 return; 496 497 /* we do have an address to forward to -- do it */ 498 include(buf, "forwarding", user, sendq); 499 } 500