?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
1:1 Userland threading stage 4.1/4:
[dragonfly.git] / contrib / sendmail-8.13.8 / sendmail / map.c
blob9a7bf7a558c8b379861083a6fd8ffa549034c546
1 /*
2 * Copyright (c) 1998-2005 Sendmail, Inc. and its suppliers.
3 * All rights reserved.
4 * Copyright (c) 1992, 1995-1997 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 <sendmail.h>
15
16 SM_RCSID("@(#)$Id: map.c,v 8.672 2006/04/18 01:26:41 ca Exp $")
17
18 #if LDAPMAP
19 # include <sm/ldap.h>
20 #endif /* LDAPMAP */
21
22 #if NDBM
23 # include <ndbm.h>
24 # ifdef R_FIRST
25 ERROR README: You are running the Berkeley DB version of ndbm.h. See
26 ERROR README: the README file about tweaking Berkeley DB so it can
27 ERROR README: coexist with NDBM, or delete -DNDBM from the Makefile
28 ERROR README: and use -DNEWDB instead.
29 # endif /* R_FIRST */
30 #endif /* NDBM */
31 #if NEWDB
32 # include "sm/bdb.h"
33 #endif /* NEWDB */
34 #if NIS
35 struct dom_binding; /* forward reference needed on IRIX */
36 # include <rpcsvc/ypclnt.h>
37 # if NDBM
38 # define NDBM_YP_COMPAT /* create YP-compatible NDBM files */
39 # endif /* NDBM */
40 #endif /* NIS */
41
42 #if NEWDB
43 # if DB_VERSION_MAJOR < 2
44 static bool db_map_open __P((MAP *, int, char *, DBTYPE, const void *));
45 # endif /* DB_VERSION_MAJOR < 2 */
46 # if DB_VERSION_MAJOR == 2
47 static bool db_map_open __P((MAP *, int, char *, DBTYPE, DB_INFO *));
48 # endif /* DB_VERSION_MAJOR == 2 */
49 # if DB_VERSION_MAJOR > 2
50 static bool db_map_open __P((MAP *, int, char *, DBTYPE, void **));
51 # endif /* DB_VERSION_MAJOR > 2 */
52 #endif /* NEWDB */
53 static bool extract_canonname __P((char *, char *, char *, char[], int));
54 static void map_close __P((STAB *, int));
55 static void map_init __P((STAB *, int));
56 #ifdef LDAPMAP
57 static STAB * ldapmap_findconn __P((SM_LDAP_STRUCT *));
58 #endif /* LDAPMAP */
59 #if NISPLUS
60 static bool nisplus_getcanonname __P((char *, int, int *));
61 #endif /* NISPLUS */
62 #if NIS
63 static bool nis_getcanonname __P((char *, int, int *));
64 #endif /* NIS */
65 #if NETINFO
66 static bool ni_getcanonname __P((char *, int, int *));
67 #endif /* NETINFO */
68 static bool text_getcanonname __P((char *, int, int *));
69 #if SOCKETMAP
70 static STAB *socket_map_findconn __P((const char*));
71
72 /* XXX arbitrary limit for sanity */
73 # define SOCKETMAP_MAXL 1000000
74 #endif /* SOCKETMAP */
75
76 /* default error message for trying to open a map in write mode */
77 #ifdef ENOSYS
78 # define SM_EMAPCANTWRITE ENOSYS
79 #else /* ENOSYS */
80 # ifdef EFTYPE
81 # define SM_EMAPCANTWRITE EFTYPE
82 # else /* EFTYPE */
83 # define SM_EMAPCANTWRITE ENXIO
84 # endif /* EFTYPE */
85 #endif /* ENOSYS */
86
87 /*
88 ** MAP.C -- implementations for various map classes.
89 **
90 ** Each map class implements a series of functions:
91 **
92 ** bool map_parse(MAP *map, char *args)
93 ** Parse the arguments from the config file. Return true
94 ** if they were ok, false otherwise. Fill in map with the
95 ** values.
96 **
97 ** char *map_lookup(MAP *map, char *key, char **args, int *pstat)
98 ** Look up the key in the given map. If found, do any
99 ** rewriting the map wants (including "args" if desired)
100 ** and return the value. Set *pstat to the appropriate status
101 ** on error and return NULL. Args will be NULL if called
102 ** from the alias routines, although this should probably
103 ** not be relied upon. It is suggested you call map_rewrite
104 ** to return the results -- it takes care of null termination
105 ** and uses a dynamically expanded buffer as needed.
106 **
107 ** void map_store(MAP *map, char *key, char *value)
108 ** Store the key:value pair in the map.
109 **
110 ** bool map_open(MAP *map, int mode)
111 ** Open the map for the indicated mode. Mode should
112 ** be either O_RDONLY or O_RDWR. Return true if it
113 ** was opened successfully, false otherwise. If the open
114 ** failed and the MF_OPTIONAL flag is not set, it should
115 ** also print an error. If the MF_ALIAS bit is set
116 ** and this map class understands the @:@ convention, it
117 ** should call aliaswait() before returning.
118 **
119 ** void map_close(MAP *map)
120 ** Close the map.
121 **
122 ** This file also includes the implementation for getcanonname.
123 ** It is currently implemented in a pretty ad-hoc manner; it ought
124 ** to be more properly integrated into the map structure.
125 */
126
127 #if O_EXLOCK && HASFLOCK && !BOGUS_O_EXCL
128 # define LOCK_ON_OPEN 1 /* we can open/create a locked file */
129 #else /* O_EXLOCK && HASFLOCK && !BOGUS_O_EXCL */
130 # define LOCK_ON_OPEN 0 /* no such luck -- bend over backwards */
131 #endif /* O_EXLOCK && HASFLOCK && !BOGUS_O_EXCL */
132
133 /*
134 ** MAP_PARSEARGS -- parse config line arguments for database lookup
135 **
136 ** This is a generic version of the map_parse method.
137 **
138 ** Parameters:
139 ** map -- the map being initialized.
140 ** ap -- a pointer to the args on the config line.
141 **
142 ** Returns:
143 ** true -- if everything parsed OK.
144 ** false -- otherwise.
145 **
146 ** Side Effects:
147 ** null terminates the filename; stores it in map
148 */
149
150 bool
151 map_parseargs(map, ap)
152 MAP *map;
153 char *ap;
154 {
155 register char *p = ap;
156
157 /*
158 ** There is no check whether there is really an argument,
159 ** but that's not important enough to warrant extra code.
160 */
161
162 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL;
163 map->map_spacesub = SpaceSub; /* default value */
164 for (;;)
165 {
166 while (isascii(*p) && isspace(*p))
167 p++;
168 if (*p != '-')
169 break;
170 switch (*++p)
171 {
172 case 'N':
173 map->map_mflags |= MF_INCLNULL;
174 map->map_mflags &= ~MF_TRY0NULL;
175 break;
176
177 case 'O':
178 map->map_mflags &= ~MF_TRY1NULL;
179 break;
180
181 case 'o':
182 map->map_mflags |= MF_OPTIONAL;
183 break;
184
185 case 'f':
186 map->map_mflags |= MF_NOFOLDCASE;
187 break;
188
189 case 'm':
190 map->map_mflags |= MF_MATCHONLY;
191 break;
192
193 case 'A':
194 map->map_mflags |= MF_APPEND;
195 break;
196
197 case 'q':
198 map->map_mflags |= MF_KEEPQUOTES;
199 break;
200
201 case 'a':
202 map->map_app = ++p;
203 break;
204
205 case 'T':
206 map->map_tapp = ++p;
207 break;
208
209 case 'k':
210 while (isascii(*++p) && isspace(*p))
211 continue;
212 map->map_keycolnm = p;
213 break;
214
215 case 'v':
216 while (isascii(*++p) && isspace(*p))
217 continue;
218 map->map_valcolnm = p;
219 break;
220
221 case 'z':
222 if (*++p != '\\')
223 map->map_coldelim = *p;
224 else
225 {
226 switch (*++p)
227 {
228 case 'n':
229 map->map_coldelim = '\n';
230 break;
231
232 case 't':
233 map->map_coldelim = '\t';
234 break;
235
236 default:
237 map->map_coldelim = '\\';
238 }
239 }
240 break;
241
242 case 't':
243 map->map_mflags |= MF_NODEFER;
244 break;
245
246
247 case 'S':
248 map->map_spacesub = *++p;
249 break;
250
251 case 'D':
252 map->map_mflags |= MF_DEFER;
253 break;
254
255 default:
256 syserr("Illegal option %c map %s", *p, map->map_mname);
257 break;
258 }
259 while (*p != '\0' && !(isascii(*p) && isspace(*p)))
260 p++;
261 if (*p != '\0')
262 *p++ = '\0';
263 }
264 if (map->map_app != NULL)
265 map->map_app = newstr(map->map_app);
266 if (map->map_tapp != NULL)
267 map->map_tapp = newstr(map->map_tapp);
268 if (map->map_keycolnm != NULL)
269 map->map_keycolnm = newstr(map->map_keycolnm);
270 if (map->map_valcolnm != NULL)
271 map->map_valcolnm = newstr(map->map_valcolnm);
272
273 if (*p != '\0')
274 {
275 map->map_file = p;
276 while (*p != '\0' && !(isascii(*p) && isspace(*p)))
277 p++;
278 if (*p != '\0')
279 *p++ = '\0';
280 map->map_file = newstr(map->map_file);
281 }
282
283 while (*p != '\0' && isascii(*p) && isspace(*p))
284 p++;
285 if (*p != '\0')
286 map->map_rebuild = newstr(p);
287
288 if (map->map_file == NULL &&
289 !bitset(MCF_OPTFILE, map->map_class->map_cflags))
290 {
291 syserr("No file name for %s map %s",
292 map->map_class->map_cname, map->map_mname);
293 return false;
294 }
295 return true;
296 }
297 /*
298 ** MAP_REWRITE -- rewrite a database key, interpolating %n indications.
299 **
300 ** It also adds the map_app string. It can be used as a utility
301 ** in the map_lookup method.
302 **
303 ** Parameters:
304 ** map -- the map that causes this.
305 ** s -- the string to rewrite, NOT necessarily null terminated.
306 ** slen -- the length of s.
307 ** av -- arguments to interpolate into buf.
308 **
309 ** Returns:
310 ** Pointer to rewritten result. This is static data that
311 ** should be copied if it is to be saved!
312 */
313
314 char *
315 map_rewrite(map, s, slen, av)
316 register MAP *map;
317 register const char *s;
318 size_t slen;
319 char **av;
320 {
321 register char *bp;
322 register char c;
323 char **avp;
324 register char *ap;
325 size_t l;
326 size_t len;
327 static size_t buflen = 0;
328 static char *buf = NULL;
329
330 if (tTd(39, 1))
331 {
332 sm_dprintf("map_rewrite(%.*s), av =", (int) slen, s);
333 if (av == NULL)
334 sm_dprintf(" (nullv)");
335 else
336 {
337 for (avp = av; *avp != NULL; avp++)
338 sm_dprintf("\n\t%s", *avp);
339 }
340 sm_dprintf("\n");
341 }
342
343 /* count expected size of output (can safely overestimate) */
344 l = len = slen;
345 if (av != NULL)
346 {
347 const char *sp = s;
348
349 while (l-- > 0 && (c = *sp++) != '\0')
350 {
351 if (c != '%')
352 continue;
353 if (l-- <= 0)
354 break;
355 c = *sp++;
356 if (!(isascii(c) && isdigit(c)))
357 continue;
358 for (avp = av; --c >= '0' && *avp != NULL; avp++)
359 continue;
360 if (*avp == NULL)
361 continue;
362 len += strlen(*avp);
363 }
364 }
365 if (map->map_app != NULL)
366 len += strlen(map->map_app);
367 if (buflen < ++len)
368 {
369 /* need to malloc additional space */
370 buflen = len;
371 if (buf != NULL)
372 sm_free(buf);
373 buf = sm_pmalloc_x(buflen);
374 }
375
376 bp = buf;
377 if (av == NULL)
378 {
379 memmove(bp, s, slen);
380 bp += slen;
381
382 /* assert(len > slen); */
383 len -= slen;
384 }
385 else
386 {
387 while (slen-- > 0 && (c = *s++) != '\0')
388 {
389 if (c != '%')
390 {
391 pushc:
392 if (len-- <= 1)
393 break;
394 *bp++ = c;
395 continue;
396 }
397 if (slen-- <= 0 || (c = *s++) == '\0')
398 c = '%';
399 if (c == '%')
400 goto pushc;
401 if (!(isascii(c) && isdigit(c)))
402 {
403 if (len-- <= 1)
404 break;
405 *bp++ = '%';
406 goto pushc;
407 }
408 for (avp = av; --c >= '0' && *avp != NULL; avp++)
409 continue;
410 if (*avp == NULL)
411 continue;
412
413 /* transliterate argument into output string */
414 for (ap = *avp; (c = *ap++) != '\0' && len > 0; --len)
415 *bp++ = c;
416 }
417 }
418 if (map->map_app != NULL && len > 0)
419 (void) sm_strlcpy(bp, map->map_app, len);
420 else
421 *bp = '\0';
422 if (tTd(39, 1))
423 sm_dprintf("map_rewrite => %s\n", buf);
424 return buf;
425 }
426 /*
427 ** INITMAPS -- rebuild alias maps
428 **
429 ** Parameters:
430 ** none.
431 **
432 ** Returns:
433 ** none.
434 */
435
436 void
437 initmaps()
438 {
439 #if XDEBUG
440 checkfd012("entering initmaps");
441 #endif /* XDEBUG */
442 stabapply(map_init, 0);
443 #if XDEBUG
444 checkfd012("exiting initmaps");
445 #endif /* XDEBUG */
446 }
447 /*
448 ** MAP_INIT -- rebuild a map
449 **
450 ** Parameters:
451 ** s -- STAB entry: if map: try to rebuild
452 ** unused -- unused variable
453 **
454 ** Returns:
455 ** none.
456 **
457 ** Side Effects:
458 ** will close already open rebuildable map.
459 */
460
461 /* ARGSUSED1 */
462 static void
463 map_init(s, unused)
464 register STAB *s;
465 int unused;
466 {
467 register MAP *map;
468
469 /* has to be a map */
470 if (s->s_symtype != ST_MAP)
471 return;
472
473 map = &s->s_map;
474 if (!bitset(MF_VALID, map->map_mflags))
475 return;
476
477 if (tTd(38, 2))
478 sm_dprintf("map_init(%s:%s, %s)\n",
479 map->map_class->map_cname == NULL ? "NULL" :
480 map->map_class->map_cname,
481 map->map_mname == NULL ? "NULL" : map->map_mname,
482 map->map_file == NULL ? "NULL" : map->map_file);
483
484 if (!bitset(MF_ALIAS, map->map_mflags) ||
485 !bitset(MCF_REBUILDABLE, map->map_class->map_cflags))
486 {
487 if (tTd(38, 3))
488 sm_dprintf("\tnot rebuildable\n");
489 return;
490 }
491
492 /* if already open, close it (for nested open) */
493 if (bitset(MF_OPEN, map->map_mflags))
494 {
495 map->map_mflags |= MF_CLOSING;
496 map->map_class->map_close(map);
497 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING);
498 }
499
500 (void) rebuildaliases(map, false);
501 return;
502 }
503 /*
504 ** OPENMAP -- open a map
505 **
506 ** Parameters:
507 ** map -- map to open (it must not be open).
508 **
509 ** Returns:
510 ** whether open succeeded.
511 */
512
513 bool
514 openmap(map)
515 MAP *map;
516 {
517 bool restore = false;
518 bool savehold = HoldErrs;
519 bool savequick = QuickAbort;
520 int saveerrors = Errors;
521
522 if (!bitset(MF_VALID, map->map_mflags))
523 return false;
524
525 /* better safe than sorry... */
526 if (bitset(MF_OPEN, map->map_mflags))
527 return true;
528
529 /* Don't send a map open error out via SMTP */
530 if ((OnlyOneError || QuickAbort) &&
531 (OpMode == MD_SMTP || OpMode == MD_DAEMON))
532 {
533 restore = true;
534 HoldErrs = true;
535 QuickAbort = false;
536 }
537
538 errno = 0;
539 if (map->map_class->map_open(map, O_RDONLY))
540 {
541 if (tTd(38, 4))
542 sm_dprintf("openmap()\t%s:%s %s: valid\n",
543 map->map_class->map_cname == NULL ? "NULL" :
544 map->map_class->map_cname,
545 map->map_mname == NULL ? "NULL" :
546 map->map_mname,
547 map->map_file == NULL ? "NULL" :
548 map->map_file);
549 map->map_mflags |= MF_OPEN;
550 map->map_pid = CurrentPid;
551 }
552 else
553 {
554 if (tTd(38, 4))
555 sm_dprintf("openmap()\t%s:%s %s: invalid%s%s\n",
556 map->map_class->map_cname == NULL ? "NULL" :
557 map->map_class->map_cname,
558 map->map_mname == NULL ? "NULL" :
559 map->map_mname,
560 map->map_file == NULL ? "NULL" :
561 map->map_file,
562 errno == 0 ? "" : ": ",
563 errno == 0 ? "" : sm_errstring(errno));
564 if (!bitset(MF_OPTIONAL, map->map_mflags))
565 {
566 extern MAPCLASS BogusMapClass;
567
568 map->map_orgclass = map->map_class;
569 map->map_class = &BogusMapClass;
570 map->map_mflags |= MF_OPEN|MF_OPENBOGUS;
571 map->map_pid = CurrentPid;
572 }
573 else
574 {
575 /* don't try again */
576 map->map_mflags &= ~MF_VALID;
577 }
578 }
579
580 if (restore)
581 {
582 Errors = saveerrors;
583 HoldErrs = savehold;
584 QuickAbort = savequick;
585 }
586
587 return bitset(MF_OPEN, map->map_mflags);
588 }
589 /*
590 ** CLOSEMAPS -- close all open maps opened by the current pid.
591 **
592 ** Parameters:
593 ** bogus -- only close bogus maps.
594 **
595 ** Returns:
596 ** none.
597 */
598
599 void
600 closemaps(bogus)
601 bool bogus;
602 {
603 stabapply(map_close, bogus);
604 }
605 /*
606 ** MAP_CLOSE -- close a map opened by the current pid.
607 **
608 ** Parameters:
609 ** s -- STAB entry: if map: try to close
610 ** bogus -- only close bogus maps or MCF_NOTPERSIST maps.
611 **
612 ** Returns:
613 ** none.
614 */
615
616 /* ARGSUSED1 */
617 static void
618 map_close(s, bogus)
619 register STAB *s;
620 int bogus; /* int because of stabapply(), used as bool */
621 {
622 MAP *map;
623 extern MAPCLASS BogusMapClass;
624
625 if (s->s_symtype != ST_MAP)
626 return;
627
628 map = &s->s_map;
629
630 /*
631 ** close the map iff:
632 ** it is valid and open and opened by this process
633 ** and (!bogus or it's a bogus map or it is not persistent)
634 ** negate this: return iff
635 ** it is not valid or it is not open or not opened by this process
636 ** or (bogus and it's not a bogus map and it's not not-persistent)
637 */
638
639 if (!bitset(MF_VALID, map->map_mflags) ||
640 !bitset(MF_OPEN, map->map_mflags) ||
641 bitset(MF_CLOSING, map->map_mflags) ||
642 map->map_pid != CurrentPid ||
643 (bogus && map->map_class != &BogusMapClass &&
644 !bitset(MCF_NOTPERSIST, map->map_class->map_cflags)))
645 return;
646
647 if (map->map_class == &BogusMapClass && map->map_orgclass != NULL &&
648 map->map_orgclass != &BogusMapClass)
649 map->map_class = map->map_orgclass;
650 if (tTd(38, 5))
651 sm_dprintf("closemaps: closing %s (%s)\n",
652 map->map_mname == NULL ? "NULL" : map->map_mname,
653 map->map_file == NULL ? "NULL" : map->map_file);
654
655 if (!bitset(MF_OPENBOGUS, map->map_mflags))
656 {
657 map->map_mflags |= MF_CLOSING;
658 map->map_class->map_close(map);
659 }
660 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_OPENBOGUS|MF_CLOSING);
661 }
662 /*
663 ** GETCANONNAME -- look up name using service switch
664 **
665 ** Parameters:
666 ** host -- the host name to look up.
667 ** hbsize -- the size of the host buffer.
668 ** trymx -- if set, try MX records.
669 ** pttl -- pointer to return TTL (can be NULL).
670 **
671 ** Returns:
672 ** true -- if the host was found.
673 ** false -- otherwise.
674 */
675
676 bool
677 getcanonname(host, hbsize, trymx, pttl)
678 char *host;
679 int hbsize;
680 bool trymx;
681 int *pttl;
682 {
683 int nmaps;
684 int mapno;
685 bool found = false;
686 bool got_tempfail = false;
687 auto int status;
688 char *maptype[MAXMAPSTACK];
689 short mapreturn[MAXMAPACTIONS];
690
691 nmaps = switch_map_find("hosts", maptype, mapreturn);
692 if (pttl != 0)
693 *pttl = SM_DEFAULT_TTL;
694 for (mapno = 0; mapno < nmaps; mapno++)
695 {
696 int i;
697
698 if (tTd(38, 20))
699 sm_dprintf("getcanonname(%s), trying %s\n",
700 host, maptype[mapno]);
701 if (strcmp("files", maptype[mapno]) == 0)
702 {
703 found = text_getcanonname(host, hbsize, &status);
704 }
705 #if NIS
706 else if (strcmp("nis", maptype[mapno]) == 0)
707 {
708 found = nis_getcanonname(host, hbsize, &status);
709 }
710 #endif /* NIS */
711 #if NISPLUS
712 else if (strcmp("nisplus", maptype[mapno]) == 0)
713 {
714 found = nisplus_getcanonname(host, hbsize, &status);
715 }
716 #endif /* NISPLUS */
717 #if NAMED_BIND
718 else if (strcmp("dns", maptype[mapno]) == 0)
719 {
720 found = dns_getcanonname(host, hbsize, trymx, &status, pttl);
721 }
722 #endif /* NAMED_BIND */
723 #if NETINFO
724 else if (strcmp("netinfo", maptype[mapno]) == 0)
725 {
726 found = ni_getcanonname(host, hbsize, &status);
727 }
728 #endif /* NETINFO */
729 else
730 {
731 found = false;
732 status = EX_UNAVAILABLE;
733 }
734
735 /*
736 ** Heuristic: if $m is not set, we are running during system
737 ** startup. In this case, when a name is apparently found
738 ** but has no dot, treat is as not found. This avoids
739 ** problems if /etc/hosts has no FQDN but is listed first
740 ** in the service switch.
741 */
742
743 if (found &&
744 (macvalue('m', CurEnv) != NULL || strchr(host, '.') != NULL))
745 break;
746
747 /* see if we should continue */
748 if (status == EX_TEMPFAIL)
749 {
750 i = MA_TRYAGAIN;
751 got_tempfail = true;
752 }
753 else if (status == EX_NOTFOUND)
754 i = MA_NOTFOUND;
755 else
756 i = MA_UNAVAIL;
757 if (bitset(1 << mapno, mapreturn[i]))
758 break;
759 }
760
761 if (found)
762 {
763 char *d;
764
765 if (tTd(38, 20))
766 sm_dprintf("getcanonname(%s), found\n", host);
767
768 /*
769 ** If returned name is still single token, compensate
770 ** by tagging on $m. This is because some sites set
771 ** up their DNS or NIS databases wrong.
772 */
773
774 if ((d = strchr(host, '.')) == NULL || d[1] == '\0')
775 {
776 d = macvalue('m', CurEnv);
777 if (d != NULL &&
778 hbsize > (int) (strlen(host) + strlen(d) + 1))
779 {
780 if (host[strlen(host) - 1] != '.')
781 (void) sm_strlcat2(host, ".", d,
782 hbsize);
783 else
784 (void) sm_strlcat(host, d, hbsize);
785 }
786 else
787 return false;
788 }
789 return true;
790 }
791
792 if (tTd(38, 20))
793 sm_dprintf("getcanonname(%s), failed, status=%d\n", host,
794 status);
795
796 if (got_tempfail)
797 SM_SET_H_ERRNO(TRY_AGAIN);
798 else
799 SM_SET_H_ERRNO(HOST_NOT_FOUND);
800
801 return false;
802 }
803 /*
804 ** EXTRACT_CANONNAME -- extract canonical name from /etc/hosts entry
805 **
806 ** Parameters:
807 ** name -- the name against which to match.
808 ** dot -- where to reinsert '.' to get FQDN
809 ** line -- the /etc/hosts line.
810 ** cbuf -- the location to store the result.
811 ** cbuflen -- the size of cbuf.
812 **
813 ** Returns:
814 ** true -- if the line matched the desired name.
815 ** false -- otherwise.
816 */
817
818 static bool
819 extract_canonname(name, dot, line, cbuf, cbuflen)
820 char *name;
821 char *dot;
822 char *line;
823 char cbuf[];
824 int cbuflen;
825 {
826 int i;
827 char *p;
828 bool found = false;
829
830 cbuf[0] = '\0';
831 if (line[0] == '#')
832 return false;
833
834 for (i = 1; ; i++)
835 {
836 char nbuf[MAXNAME + 1];
837
838 p = get_column(line, i, '\0', nbuf, sizeof nbuf);
839 if (p == NULL)
840 break;
841 if (*p == '\0')
842 continue;
843 if (cbuf[0] == '\0' ||
844 (strchr(cbuf, '.') == NULL && strchr(p, '.') != NULL))
845 {
846 (void) sm_strlcpy(cbuf, p, cbuflen);
847 }
848 if (sm_strcasecmp(name, p) == 0)
849 found = true;
850 else if (dot != NULL)
851 {
852 /* try looking for the FQDN as well */
853 *dot = '.';
854 if (sm_strcasecmp(name, p) == 0)
855 found = true;
856 *dot = '\0';
857 }
858 }
859 if (found && strchr(cbuf, '.') == NULL)
860 {
861 /* try to add a domain on the end of the name */
862 char *domain = macvalue('m', CurEnv);
863
864 if (domain != NULL &&
865 strlen(domain) + (i = strlen(cbuf)) + 1 < (size_t) cbuflen)
866 {
867 p = &cbuf[i];
868 *p++ = '.';
869 (void) sm_strlcpy(p, domain, cbuflen - i - 1);
870 }
871 }
872 return found;
873 }
874
875 /*
876 ** DNS modules
877 */
878
879 #if NAMED_BIND
880 # if DNSMAP
881
882 # include "sm_resolve.h"
883 # if NETINET || NETINET6
884 # include <arpa/inet.h>
885 # endif /* NETINET || NETINET6 */
886
887 /*
888 ** DNS_MAP_OPEN -- stub to check proper value for dns map type
889 */
890
891 bool
892 dns_map_open(map, mode)
893 MAP *map;
894 int mode;
895 {
896 if (tTd(38,2))
897 sm_dprintf("dns_map_open(%s, %d)\n", map->map_mname, mode);
898
899 mode &= O_ACCMODE;
900 if (mode != O_RDONLY)
901 {
902 /* issue a pseudo-error message */
903 errno = SM_EMAPCANTWRITE;
904 return false;
905 }
906 return true;
907 }
908
909 /*
910 ** DNS_MAP_PARSEARGS -- parse dns map definition args.
911 **
912 ** Parameters:
913 ** map -- pointer to MAP
914 ** args -- pointer to the args on the config line.
915 **
916 ** Returns:
917 ** true -- if everything parsed OK.
918 ** false -- otherwise.
919 */
920
921 # if _FFR_DNSMAP_MULTILIMIT
922 # if !_FFR_DNSMAP_MULTI
923 ERROR README: You must define _FFR_DNSMAP_MULTI to use _FFR_DNSMAP_MULTILIMIT
924 # endif /* ! _FFR_DNSMAP_MULTI */
925 # endif /* _FFR_DNSMAP_MULTILIMIT */
926
927 # if _FFR_DNSMAP_MULTI
928 # if _FFR_DNSMAP_MULTILIMIT
929 # define map_sizelimit map_lockfd /* overload field */
930 # endif /* _FFR_DNSMAP_MULTILIMIT */
931 # endif /* _FFR_DNSMAP_MULTI */
932
933 struct dns_map
934 {
935 int dns_m_type;
936 };
937
938 bool
939 dns_map_parseargs(map,args)
940 MAP *map;
941 char *args;
942 {
943 register char *p = args;
944 struct dns_map *map_p;
945
946 map_p = (struct dns_map *) xalloc(sizeof *map_p);
947 map_p->dns_m_type = -1;
948 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL;
949
950 for (;;)
951 {
952 while (isascii(*p) && isspace(*p))
953 p++;
954 if (*p != '-')
955 break;
956 switch (*++p)
957 {
958 case 'N':
959 map->map_mflags |= MF_INCLNULL;
960 map->map_mflags &= ~MF_TRY0NULL;
961 break;
962
963 case 'O':
964 map->map_mflags &= ~MF_TRY1NULL;
965 break;
966
967 case 'o':
968 map->map_mflags |= MF_OPTIONAL;
969 break;
970
971 case 'f':
972 map->map_mflags |= MF_NOFOLDCASE;
973 break;
974
975 case 'm':
976 map->map_mflags |= MF_MATCHONLY;
977 break;
978
979 case 'A':
980 map->map_mflags |= MF_APPEND;
981 break;
982
983 case 'q':
984 map->map_mflags |= MF_KEEPQUOTES;
985 break;
986
987 case 't':
988 map->map_mflags |= MF_NODEFER;
989 break;
990
991 case 'a':
992 map->map_app = ++p;
993 break;
994
995 case 'T':
996 map->map_tapp = ++p;
997 break;
998
999 case 'd':
1000 {
1001 char *h;
1002
1003 ++p;
1004 h = strchr(p, ' ');
1005 if (h != NULL)
1006 *h = '\0';
1007 map->map_timeout = convtime(p, 's');
1008 if (h != NULL)
1009 *h = ' ';
1010 }
1011 break;
1012
1013 case 'r':
1014 while (isascii(*++p) && isspace(*p))
1015 continue;
1016 map->map_retry = atoi(p);
1017 break;
1018
1019 # if _FFR_DNSMAP_MULTI
1020 case 'z':
1021 if (*++p != '\\')
1022 map->map_coldelim = *p;
1023 else
1024 {
1025 switch (*++p)
1026 {
1027 case 'n':
1028 map->map_coldelim = '\n';
1029 break;
1030
1031 case 't':
1032 map->map_coldelim = '\t';
1033 break;
1034
1035 default:
1036 map->map_coldelim = '\\';
1037 }
1038 }
1039 break;
1040
1041 # if _FFR_DNSMAP_MULTILIMIT
1042 case 'Z':
1043 while (isascii(*++p) && isspace(*p))
1044 continue;
1045 map->map_sizelimit = atoi(p);
1046 break;
1047 # endif /* _FFR_DNSMAP_MULTILIMIT */
1048 # endif /* _FFR_DNSMAP_MULTI */
1049
1050 /* Start of dns_map specific args */
1051 case 'R': /* search field */
1052 {
1053 char *h;
1054
1055 while (isascii(*++p) && isspace(*p))
1056 continue;
1057 h = strchr(p, ' ');
1058 if (h != NULL)
1059 *h = '\0';
1060 map_p->dns_m_type = dns_string_to_type(p);
1061 if (h != NULL)
1062 *h = ' ';
1063 if (map_p->dns_m_type < 0)
1064 syserr("dns map %s: wrong type %s",
1065 map->map_mname, p);
1066 }
1067 break;
1068
1069 # if _FFR_DNSMAP_BASE
1070 case 'B': /* base domain */
1071 {
1072 char *h;
1073
1074 while (isascii(*++p) && isspace(*p))
1075 continue;
1076 h = strchr(p, ' ');
1077 if (h != NULL)
1078 *h = '\0';
1079
1080 /*
1081 ** slight abuse of map->map_file; it isn't
1082 ** used otherwise in this map type.
1083 */
1084
1085 map->map_file = newstr(p);
1086 if (h != NULL)
1087 *h = ' ';
1088 }
1089 break;
1090 # endif /* _FFR_DNSMAP_BASE */
1091
1092 }
1093 while (*p != '\0' && !(isascii(*p) && isspace(*p)))
1094 p++;
1095 if (*p != '\0')
1096 *p++ = '\0';
1097 }
1098 if (map_p->dns_m_type < 0)
1099 syserr("dns map %s: missing -R type", map->map_mname);
1100 if (map->map_app != NULL)
1101 map->map_app = newstr(map->map_app);
1102 if (map->map_tapp != NULL)
1103 map->map_tapp = newstr(map->map_tapp);
1104
1105 /*
1106 ** Assumption: assert(sizeof int <= sizeof(ARBPTR_T));
1107 ** Even if this assumption is wrong, we use only one byte,
1108 ** so it doesn't really matter.
1109 */
1110
1111 map->map_db1 = (ARBPTR_T) map_p;
1112 return true;
1113 }
1114
1115 /*
1116 ** DNS_MAP_LOOKUP -- perform dns map lookup.
1117 **
1118 ** Parameters:
1119 ** map -- pointer to MAP
1120 ** name -- name to lookup
1121 ** av -- arguments to interpolate into buf.
1122 ** statp -- pointer to status (EX_)
1123 **
1124 ** Returns:
1125 ** result of lookup if succeeded.
1126 ** NULL -- otherwise.
1127 */
1128
1129 char *
1130 dns_map_lookup(map, name, av, statp)
1131 MAP *map;
1132 char *name;
1133 char **av;
1134 int *statp;
1135 {
1136 # if _FFR_DNSMAP_MULTI
1137 # if _FFR_DNSMAP_MULTILIMIT
1138 int resnum = 0;
1139 # endif /* _FFR_DNSMAP_MULTILIMIT */
1140 # endif /* _FFR_DNSMAP_MULTI */
1141 char *vp = NULL, *result = NULL;
1142 size_t vsize;
1143 struct dns_map *map_p;
1144 RESOURCE_RECORD_T *rr = NULL;
1145 DNS_REPLY_T *r = NULL;
1146 # if NETINET6
1147 static char buf6[INET6_ADDRSTRLEN];
1148 # endif /* NETINET6 */
1149
1150 if (tTd(38, 20))
1151 sm_dprintf("dns_map_lookup(%s, %s)\n",
1152 map->map_mname, name);
1153
1154 map_p = (struct dns_map *)(map->map_db1);
1155 # if _FFR_DNSMAP_BASE
1156 if (map->map_file != NULL && *map->map_file != '\0')
1157 {
1158 size_t len;
1159 char *appdomain;
1160
1161 len = strlen(map->map_file) + strlen(name) + 2;
1162 appdomain = (char *) sm_malloc(len);
1163 if (appdomain == NULL)
1164 {
1165 *statp = EX_UNAVAILABLE;
1166 return NULL;
1167 }
1168 (void) sm_strlcpyn(appdomain, len, 3, name, ".", map->map_file);
1169 r = dns_lookup_int(appdomain, C_IN, map_p->dns_m_type,
1170 map->map_timeout, map->map_retry);
1171 sm_free(appdomain);
1172 }
1173 else
1174 # endif /* _FFR_DNSMAP_BASE */
1175 {
1176 r = dns_lookup_int(name, C_IN, map_p->dns_m_type,
1177 map->map_timeout, map->map_retry);
1178 }
1179
1180 if (r == NULL)
1181 {
1182 result = NULL;
1183 if (h_errno == TRY_AGAIN || transienterror(errno))
1184 *statp = EX_TEMPFAIL;
1185 else
1186 *statp = EX_NOTFOUND;
1187 goto cleanup;
1188 }
1189 *statp = EX_OK;
1190 for (rr = r->dns_r_head; rr != NULL; rr = rr->rr_next)
1191 {
1192 char *type = NULL;
1193 char *value = NULL;
1194
1195 switch (rr->rr_type)
1196 {
1197 case T_NS:
1198 type = "T_NS";
1199 value = rr->rr_u.rr_txt;
1200 break;
1201 case T_CNAME:
1202 type = "T_CNAME";
1203 value = rr->rr_u.rr_txt;
1204 break;
1205 case T_AFSDB:
1206 type = "T_AFSDB";
1207 value = rr->rr_u.rr_mx->mx_r_domain;
1208 break;
1209 case T_SRV:
1210 type = "T_SRV";
1211 value = rr->rr_u.rr_srv->srv_r_target;
1212 break;
1213 case T_PTR:
1214 type = "T_PTR";
1215 value = rr->rr_u.rr_txt;
1216 break;
1217 case T_TXT:
1218 type = "T_TXT";
1219 value = rr->rr_u.rr_txt;
1220 break;
1221 case T_MX:
1222 type = "T_MX";
1223 value = rr->rr_u.rr_mx->mx_r_domain;
1224 break;
1225 # if NETINET
1226 case T_A:
1227 type = "T_A";
1228 value = inet_ntoa(*(rr->rr_u.rr_a));
1229 break;
1230 # endif /* NETINET */
1231 # if NETINET6
1232 case T_AAAA:
1233 type = "T_AAAA";
1234 value = anynet_ntop(rr->rr_u.rr_aaaa, buf6,
1235 sizeof buf6);
1236 break;
1237 # endif /* NETINET6 */
1238 }
1239
1240 (void) strreplnonprt(value, 'X');
1241 if (map_p->dns_m_type != rr->rr_type)
1242 {
1243 if (tTd(38, 40))
1244 sm_dprintf("\tskipping type %s (%d) value %s\n",
1245 type != NULL ? type : "<UNKNOWN>",
1246 rr->rr_type,
1247 value != NULL ? value : "<NO VALUE>");
1248 continue;
1249 }
1250
1251 # if NETINET6
1252 if (rr->rr_type == T_AAAA && value == NULL)
1253 {
1254 result = NULL;
1255 *statp = EX_DATAERR;
1256 if (tTd(38, 40))
1257 sm_dprintf("\tbad T_AAAA conversion\n");
1258 goto cleanup;
1259 }
1260 # endif /* NETINET6 */
1261 if (tTd(38, 40))
1262 sm_dprintf("\tfound type %s (%d) value %s\n",
1263 type != NULL ? type : "<UNKNOWN>",
1264 rr->rr_type,
1265 value != NULL ? value : "<NO VALUE>");
1266 # if _FFR_DNSMAP_MULTI
1267 if (value != NULL &&
1268 (map->map_coldelim == '\0' ||
1269 # if _FFR_DNSMAP_MULTILIMIT
1270 map->map_sizelimit == 1 ||
1271 # endif /* _FFR_DNSMAP_MULTILIMIT */
1272 bitset(MF_MATCHONLY, map->map_mflags)))
1273 {
1274 /* Only care about the first match */
1275 vp = newstr(value);
1276 break;
1277 }
1278 else if (vp == NULL)
1279 {
1280 /* First result */
1281 vp = newstr(value);
1282 }
1283 else
1284 {
1285 /* concatenate the results */
1286 int sz;
1287 char *new;
1288
1289 sz = strlen(vp) + strlen(value) + 2;
1290 new = xalloc(sz);
1291 (void) sm_snprintf(new, sz, "%s%c%s",
1292 vp, map->map_coldelim, value);
1293 sm_free(vp);
1294 vp = new;
1295 # if _FFR_DNSMAP_MULTILIMIT
1296 if (map->map_sizelimit > 0 &&
1297 ++resnum >= map->map_sizelimit)
1298 break;
1299 # endif /* _FFR_DNSMAP_MULTILIMIT */
1300 }
1301 # else /* _FFR_DNSMAP_MULTI */
1302 vp = value;
1303 break;
1304 # endif /* _FFR_DNSMAP_MULTI */
1305 }
1306 if (vp == NULL)
1307 {
1308 result = NULL;
1309 *statp = EX_NOTFOUND;
1310 if (tTd(38, 40))
1311 sm_dprintf("\tno match found\n");
1312 goto cleanup;
1313 }
1314
1315 # if _FFR_DNSMAP_MULTI
1316 /* Cleanly truncate for rulesets */
1317 truncate_at_delim(vp, PSBUFSIZE / 2, map->map_coldelim);
1318 # endif /* _FFR_DNSMAP_MULTI */
1319
1320 vsize = strlen(vp);
1321
1322 if (LogLevel > 9)
1323 sm_syslog(LOG_INFO, CurEnv->e_id, "dns %.100s => %s",
1324 name, vp);
1325 if (bitset(MF_MATCHONLY, map->map_mflags))
1326 result = map_rewrite(map, name, strlen(name), NULL);
1327 else
1328 result = map_rewrite(map, vp, vsize, av);
1329
1330 cleanup:
1331 # if _FFR_DNSMAP_MULTI
1332 if (vp != NULL)
1333 sm_free(vp);
1334 # endif /* _FFR_DNSMAP_MULTI */
1335 if (r != NULL)
1336 dns_free_data(r);
1337 return result;
1338 }
1339 # endif /* DNSMAP */
1340 #endif /* NAMED_BIND */
1341
1342 /*
1343 ** NDBM modules
1344 */
1345
1346 #if NDBM
1347
1348 /*
1349 ** NDBM_MAP_OPEN -- DBM-style map open
1350 */
1351
1352 bool
1353 ndbm_map_open(map, mode)
1354 MAP *map;
1355 int mode;
1356 {
1357 register DBM *dbm;
1358 int save_errno;
1359 int dfd;
1360 int pfd;
1361 long sff;
1362 int ret;
1363 int smode = S_IREAD;
1364 char dirfile[MAXPATHLEN];
1365 char pagfile[MAXPATHLEN];
1366 struct stat st;
1367 struct stat std, stp;
1368
1369 if (tTd(38, 2))
1370 sm_dprintf("ndbm_map_open(%s, %s, %d)\n",
1371 map->map_mname, map->map_file, mode);
1372 map->map_lockfd = -1;
1373 mode &= O_ACCMODE;
1374
1375 /* do initial file and directory checks */
1376 if (sm_strlcpyn(dirfile, sizeof dirfile, 2,
1377 map->map_file, ".dir") >= sizeof dirfile ||
1378 sm_strlcpyn(pagfile, sizeof pagfile, 2,
1379 map->map_file, ".pag") >= sizeof pagfile)
1380 {
1381 errno = 0;
1382 if (!bitset(MF_OPTIONAL, map->map_mflags))
1383 syserr("dbm map \"%s\": map file %s name too long",
1384 map->map_mname, map->map_file);
1385 return false;
1386 }
1387 sff = SFF_ROOTOK|SFF_REGONLY;
1388 if (mode == O_RDWR)
1389 {
1390 sff |= SFF_CREAT;
1391 if (!bitnset(DBS_WRITEMAPTOSYMLINK, DontBlameSendmail))
1392 sff |= SFF_NOSLINK;
1393 if (!bitnset(DBS_WRITEMAPTOHARDLINK, DontBlameSendmail))
1394 sff |= SFF_NOHLINK;
1395 smode = S_IWRITE;
1396 }
1397 else
1398 {
1399 if (!bitnset(DBS_LINKEDMAPINWRITABLEDIR, DontBlameSendmail))
1400 sff |= SFF_NOWLINK;
1401 }
1402 if (!bitnset(DBS_MAPINUNSAFEDIRPATH, DontBlameSendmail))
1403 sff |= SFF_SAFEDIRPATH;
1404 ret = safefile(dirfile, RunAsUid, RunAsGid, RunAsUserName,
1405 sff, smode, &std);
1406 if (ret == 0)
1407 ret = safefile(pagfile, RunAsUid, RunAsGid, RunAsUserName,
1408 sff, smode, &stp);
1409
1410 if (ret != 0)
1411 {
1412 char *prob = "unsafe";
1413
1414 /* cannot open this map */
1415 if (ret == ENOENT)
1416 prob = "missing";
1417 if (tTd(38, 2))
1418 sm_dprintf("\t%s map file: %d\n", prob, ret);
1419 if (!bitset(MF_OPTIONAL, map->map_mflags))
1420 syserr("dbm map \"%s\": %s map file %s",
1421 map->map_mname, prob, map->map_file);
1422 return false;
1423 }
1424 if (std.st_mode == ST_MODE_NOFILE)
1425 mode |= O_CREAT|O_EXCL;
1426
1427 # if LOCK_ON_OPEN
1428 if (mode == O_RDONLY)
1429 mode |= O_SHLOCK;
1430 else
1431 mode |= O_TRUNC|O_EXLOCK;
1432 # else /* LOCK_ON_OPEN */
1433 if ((mode & O_ACCMODE) == O_RDWR)
1434 {
1435 # if NOFTRUNCATE
1436 /*
1437 ** Warning: race condition. Try to lock the file as
1438 ** quickly as possible after opening it.
1439 ** This may also have security problems on some systems,
1440 ** but there isn't anything we can do about it.
1441 */
1442
1443 mode |= O_TRUNC;
1444 # else /* NOFTRUNCATE */
1445 /*
1446 ** This ugly code opens the map without truncating it,
1447 ** locks the file, then truncates it. Necessary to
1448 ** avoid race conditions.
1449 */
1450
1451 int dirfd;
1452 int pagfd;
1453 long sff = SFF_CREAT|SFF_OPENASROOT;
1454
1455 if (!bitnset(DBS_WRITEMAPTOSYMLINK, DontBlameSendmail))
1456 sff |= SFF_NOSLINK;
1457 if (!bitnset(DBS_WRITEMAPTOHARDLINK, DontBlameSendmail))
1458 sff |= SFF_NOHLINK;
1459
1460 dirfd = safeopen(dirfile, mode, DBMMODE, sff);
1461 pagfd = safeopen(pagfile, mode, DBMMODE, sff);
1462
1463 if (dirfd < 0 || pagfd < 0)
1464 {
1465 save_errno = errno;
1466 if (dirfd >= 0)
1467 (void) close(dirfd);
1468 if (pagfd >= 0)
1469 (void) close(pagfd);
1470 errno = save_errno;
1471 syserr("ndbm_map_open: cannot create database %s",
1472 map->map_file);
1473 return false;
1474 }
1475 if (ftruncate(dirfd, (off_t) 0) < 0 ||
1476 ftruncate(pagfd, (off_t) 0) < 0)
1477 {
1478 save_errno = errno;
1479 (void) close(dirfd);
1480 (void) close(pagfd);
1481 errno = save_errno;
1482 syserr("ndbm_map_open: cannot truncate %s.{dir,pag}",
1483 map->map_file);
1484 return false;
1485 }
1486
1487 /* if new file, get "before" bits for later filechanged check */
1488 if (std.st_mode == ST_MODE_NOFILE &&
1489 (fstat(dirfd, &std) < 0 || fstat(pagfd, &stp) < 0))
1490 {
1491 save_errno = errno;
1492 (void) close(dirfd);
1493 (void) close(pagfd);
1494 errno = save_errno;
1495 syserr("ndbm_map_open(%s.{dir,pag}): cannot fstat pre-opened file",
1496 map->map_file);
1497 return false;
1498 }
1499
1500 /* have to save the lock for the duration (bletch) */
1501 map->map_lockfd = dirfd;
1502 (void) close(pagfd);
1503
1504 /* twiddle bits for dbm_open */
1505 mode &= ~(O_CREAT|O_EXCL);
1506 # endif /* NOFTRUNCATE */
1507 }
1508 # endif /* LOCK_ON_OPEN */
1509
1510 /* open the database */
1511 dbm = dbm_open(map->map_file, mode, DBMMODE);
1512 if (dbm == NULL)
1513 {
1514 save_errno = errno;
1515 if (bitset(MF_ALIAS, map->map_mflags) &&
1516 aliaswait(map, ".pag", false))
1517 return true;
1518 # if !LOCK_ON_OPEN && !NOFTRUNCATE
1519 if (map->map_lockfd >= 0)
1520 (void) close(map->map_lockfd);
1521 # endif /* !LOCK_ON_OPEN && !NOFTRUNCATE */
1522 errno = save_errno;
1523 if (!bitset(MF_OPTIONAL, map->map_mflags))
1524 syserr("Cannot open DBM database %s", map->map_file);
1525 return false;
1526 }
1527 dfd = dbm_dirfno(dbm);
1528 pfd = dbm_pagfno(dbm);
1529 if (dfd == pfd)
1530 {
1531 /* heuristic: if files are linked, this is actually gdbm */
1532 dbm_close(dbm);
1533 # if !LOCK_ON_OPEN && !NOFTRUNCATE
1534 if (map->map_lockfd >= 0)
1535 (void) close(map->map_lockfd);
1536 # endif /* !LOCK_ON_OPEN && !NOFTRUNCATE */
1537 errno = 0;
1538 syserr("dbm map \"%s\": cannot support GDBM",
1539 map->map_mname);
1540 return false;
1541 }
1542
1543 if (filechanged(dirfile, dfd, &std) ||
1544 filechanged(pagfile, pfd, &stp))
1545 {
1546 save_errno = errno;
1547 dbm_close(dbm);
1548 # if !LOCK_ON_OPEN && !NOFTRUNCATE
1549 if (map->map_lockfd >= 0)
1550 (void) close(map->map_lockfd);
1551 # endif /* !LOCK_ON_OPEN && !NOFTRUNCATE */
1552 errno = save_errno;
1553 syserr("ndbm_map_open(%s): file changed after open",
1554 map->map_file);
1555 return false;
1556 }
1557
1558 map->map_db1 = (ARBPTR_T) dbm;
1559
1560 /*
1561 ** Need to set map_mtime before the call to aliaswait()
1562 ** as aliaswait() will call map_lookup() which requires
1563 ** map_mtime to be set
1564 */
1565
1566 if (fstat(pfd, &st) >= 0)
1567 map->map_mtime = st.st_mtime;
1568
1569 if (mode == O_RDONLY)
1570 {
1571 # if LOCK_ON_OPEN
1572 if (dfd >= 0)
1573 (void) lockfile(dfd, map->map_file, ".dir", LOCK_UN);
1574 if (pfd >= 0)
1575 (void) lockfile(pfd, map->map_file, ".pag", LOCK_UN);
1576 # endif /* LOCK_ON_OPEN */
1577 if (bitset(MF_ALIAS, map->map_mflags) &&
1578 !aliaswait(map, ".pag", true))
1579 return false;
1580 }
1581 else
1582 {
1583 map->map_mflags |= MF_LOCKED;
1584 if (geteuid() == 0 && TrustedUid != 0)
1585 {
1586 # if HASFCHOWN
1587 if (fchown(dfd, TrustedUid, -1) < 0 ||
1588 fchown(pfd, TrustedUid, -1) < 0)
1589 {
1590 int err = errno;
1591
1592 sm_syslog(LOG_ALERT, NOQID,
1593 "ownership change on %s failed: %s",
1594 map->map_file, sm_errstring(err));
1595 message("050 ownership change on %s failed: %s",
1596 map->map_file, sm_errstring(err));
1597 }
1598 # else /* HASFCHOWN */
1599 sm_syslog(LOG_ALERT, NOQID,
1600 "no fchown(): cannot change ownership on %s",
1601 map->map_file);
1602 message("050 no fchown(): cannot change ownership on %s",
1603 map->map_file);
1604 # endif /* HASFCHOWN */
1605 }
1606 }
1607 return true;
1608 }
1609
1610
1611 /*
1612 ** NDBM_MAP_LOOKUP -- look up a datum in a DBM-type map
1613 */
1614
1615 char *
1616 ndbm_map_lookup(map, name, av, statp)
1617 MAP *map;
1618 char *name;
1619 char **av;
1620 int *statp;
1621 {
1622 datum key, val;
1623 int dfd, pfd;
1624 char keybuf[MAXNAME + 1];
1625 struct stat stbuf;
1626
1627 if (tTd(38, 20))
1628 sm_dprintf("ndbm_map_lookup(%s, %s)\n",
1629 map->map_mname, name);
1630
1631 key.dptr = name;
1632 key.dsize = strlen(name);
1633 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
1634 {
1635 if (key.dsize > sizeof keybuf - 1)
1636 key.dsize = sizeof keybuf - 1;
1637 memmove(keybuf, key.dptr, key.dsize);
1638 keybuf[key.dsize] = '\0';
1639 makelower(keybuf);
1640 key.dptr = keybuf;
1641 }
1642 lockdbm:
1643 dfd = dbm_dirfno((DBM *) map->map_db1);
1644 if (dfd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
1645 (void) lockfile(dfd, map->map_file, ".dir", LOCK_SH);
1646 pfd = dbm_pagfno((DBM *) map->map_db1);
1647 if (pfd < 0 || fstat(pfd, &stbuf) < 0 ||
1648 stbuf.st_mtime > map->map_mtime)
1649 {
1650 /* Reopen the database to sync the cache */
1651 int omode = bitset(map->map_mflags, MF_WRITABLE) ? O_RDWR
1652 : O_RDONLY;
1653
1654 if (dfd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
1655 (void) lockfile(dfd, map->map_file, ".dir", LOCK_UN);
1656 map->map_mflags |= MF_CLOSING;
1657 map->map_class->map_close(map);
1658 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING);
1659 if (map->map_class->map_open(map, omode))
1660 {
1661 map->map_mflags |= MF_OPEN;
1662 map->map_pid = CurrentPid;
1663 if ((omode && O_ACCMODE) == O_RDWR)
1664 map->map_mflags |= MF_WRITABLE;
1665 goto lockdbm;
1666 }
1667 else
1668 {
1669 if (!bitset(MF_OPTIONAL, map->map_mflags))
1670 {
1671 extern MAPCLASS BogusMapClass;
1672
1673 *statp = EX_TEMPFAIL;
1674 map->map_orgclass = map->map_class;
1675 map->map_class = &BogusMapClass;
1676 map->map_mflags |= MF_OPEN;
1677 map->map_pid = CurrentPid;
1678 syserr("Cannot reopen NDBM database %s",
1679 map->map_file);
1680 }
1681 return NULL;
1682 }
1683 }
1684 val.dptr = NULL;
1685 if (bitset(MF_TRY0NULL, map->map_mflags))
1686 {
1687 val = dbm_fetch((DBM *) map->map_db1, key);
1688 if (val.dptr != NULL)
1689 map->map_mflags &= ~MF_TRY1NULL;
1690 }
1691 if (val.dptr == NULL && bitset(MF_TRY1NULL, map->map_mflags))
1692 {
1693 key.dsize++;
1694 val = dbm_fetch((DBM *) map->map_db1, key);
1695 if (val.dptr != NULL)
1696 map->map_mflags &= ~MF_TRY0NULL;
1697 }
1698 if (dfd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
1699 (void) lockfile(dfd, map->map_file, ".dir", LOCK_UN);
1700 if (val.dptr == NULL)
1701 return NULL;
1702 if (bitset(MF_MATCHONLY, map->map_mflags))
1703 return map_rewrite(map, name, strlen(name), NULL);
1704 else
1705 return map_rewrite(map, val.dptr, val.dsize, av);
1706 }
1707
1708
1709 /*
1710 ** NDBM_MAP_STORE -- store a datum in the database
1711 */
1712
1713 void
1714 ndbm_map_store(map, lhs, rhs)
1715 register MAP *map;
1716 char *lhs;
1717 char *rhs;
1718 {
1719 datum key;
1720 datum data;
1721 int status;
1722 char keybuf[MAXNAME + 1];
1723
1724 if (tTd(38, 12))
1725 sm_dprintf("ndbm_map_store(%s, %s, %s)\n",
1726 map->map_mname, lhs, rhs);
1727
1728 key.dsize = strlen(lhs);
1729 key.dptr = lhs;
1730 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
1731 {
1732 if (key.dsize > sizeof keybuf - 1)
1733 key.dsize = sizeof keybuf - 1;
1734 memmove(keybuf, key.dptr, key.dsize);
1735 keybuf[key.dsize] = '\0';
1736 makelower(keybuf);
1737 key.dptr = keybuf;
1738 }
1739
1740 data.dsize = strlen(rhs);
1741 data.dptr = rhs;
1742
1743 if (bitset(MF_INCLNULL, map->map_mflags))
1744 {
1745 key.dsize++;
1746 data.dsize++;
1747 }
1748
1749 status = dbm_store((DBM *) map->map_db1, key, data, DBM_INSERT);
1750 if (status > 0)
1751 {
1752 if (!bitset(MF_APPEND, map->map_mflags))
1753 message("050 Warning: duplicate alias name %s", lhs);
1754 else
1755 {
1756 static char *buf = NULL;
1757 static int bufsiz = 0;
1758 auto int xstat;
1759 datum old;
1760
1761 old.dptr = ndbm_map_lookup(map, key.dptr,
1762 (char **) NULL, &xstat);
1763 if (old.dptr != NULL && *(char *) old.dptr != '\0')
1764 {
1765 old.dsize = strlen(old.dptr);
1766 if (data.dsize + old.dsize + 2 > bufsiz)
1767 {
1768 if (buf != NULL)
1769 (void) sm_free(buf);
1770 bufsiz = data.dsize + old.dsize + 2;
1771 buf = sm_pmalloc_x(bufsiz);
1772 }
1773 (void) sm_strlcpyn(buf, bufsiz, 3,
1774 data.dptr, ",", old.dptr);
1775 data.dsize = data.dsize + old.dsize + 1;
1776 data.dptr = buf;
1777 if (tTd(38, 9))
1778 sm_dprintf("ndbm_map_store append=%s\n",
1779 data.dptr);
1780 }
1781 }
1782 status = dbm_store((DBM *) map->map_db1,
1783 key, data, DBM_REPLACE);
1784 }
1785 if (status != 0)
1786 syserr("readaliases: dbm put (%s): %d", lhs, status);
1787 }
1788
1789
1790 /*
1791 ** NDBM_MAP_CLOSE -- close the database
1792 */
1793
1794 void
1795 ndbm_map_close(map)
1796 register MAP *map;
1797 {
1798 if (tTd(38, 9))
1799 sm_dprintf("ndbm_map_close(%s, %s, %lx)\n",
1800 map->map_mname, map->map_file, map->map_mflags);
1801
1802 if (bitset(MF_WRITABLE, map->map_mflags))
1803 {
1804 # ifdef NDBM_YP_COMPAT
1805 bool inclnull;
1806 char buf[MAXHOSTNAMELEN];
1807
1808 inclnull = bitset(MF_INCLNULL, map->map_mflags);
1809 map->map_mflags &= ~MF_INCLNULL;
1810
1811 if (strstr(map->map_file, "/yp/") != NULL)
1812 {
1813 long save_mflags = map->map_mflags;
1814
1815 map->map_mflags |= MF_NOFOLDCASE;
1816
1817 (void) sm_snprintf(buf, sizeof buf, "%010ld", curtime());
1818 ndbm_map_store(map, "YP_LAST_MODIFIED", buf);
1819
1820 (void) gethostname(buf, sizeof buf);
1821 ndbm_map_store(map, "YP_MASTER_NAME", buf);
1822
1823 map->map_mflags = save_mflags;
1824 }
1825
1826 if (inclnull)
1827 map->map_mflags |= MF_INCLNULL;
1828 # endif /* NDBM_YP_COMPAT */
1829
1830 /* write out the distinguished alias */
1831 ndbm_map_store(map, "@", "@");
1832 }
1833 dbm_close((DBM *) map->map_db1);
1834
1835 /* release lock (if needed) */
1836 # if !LOCK_ON_OPEN
1837 if (map->map_lockfd >= 0)
1838 (void) close(map->map_lockfd);
1839 # endif /* !LOCK_ON_OPEN */
1840 }
1841
1842 #endif /* NDBM */
1843 /*
1844 ** NEWDB (Hash and BTree) Modules
1845 */
1846
1847 #if NEWDB
1848
1849 /*
1850 ** BT_MAP_OPEN, HASH_MAP_OPEN -- database open primitives.
1851 **
1852 ** These do rather bizarre locking. If you can lock on open,
1853 ** do that to avoid the condition of opening a database that
1854 ** is being rebuilt. If you don't, we'll try to fake it, but
1855 ** there will be a race condition. If opening for read-only,
1856 ** we immediately release the lock to avoid freezing things up.
1857 ** We really ought to hold the lock, but guarantee that we won't
1858 ** be pokey about it. That's hard to do.
1859 */
1860
1861 /* these should be K line arguments */
1862 # if DB_VERSION_MAJOR < 2
1863 # define db_cachesize cachesize
1864 # define h_nelem nelem
1865 # ifndef DB_CACHE_SIZE
1866 # define DB_CACHE_SIZE (1024 * 1024) /* database memory cache size */
1867 # endif /* ! DB_CACHE_SIZE */
1868 # ifndef DB_HASH_NELEM
1869 # define DB_HASH_NELEM 4096 /* (starting) size of hash table */
1870 # endif /* ! DB_HASH_NELEM */
1871 # endif /* DB_VERSION_MAJOR < 2 */
1872
1873 bool
1874 bt_map_open(map, mode)
1875 MAP *map;
1876 int mode;
1877 {
1878 # if DB_VERSION_MAJOR < 2
1879 BTREEINFO btinfo;
1880 # endif /* DB_VERSION_MAJOR < 2 */
1881 # if DB_VERSION_MAJOR == 2
1882 DB_INFO btinfo;
1883 # endif /* DB_VERSION_MAJOR == 2 */
1884 # if DB_VERSION_MAJOR > 2
1885 void *btinfo = NULL;
1886 # endif /* DB_VERSION_MAJOR > 2 */
1887
1888 if (tTd(38, 2))
1889 sm_dprintf("bt_map_open(%s, %s, %d)\n",
1890 map->map_mname, map->map_file, mode);
1891
1892 # if DB_VERSION_MAJOR < 3
1893 memset(&btinfo, '\0', sizeof btinfo);
1894 # ifdef DB_CACHE_SIZE
1895 btinfo.db_cachesize = DB_CACHE_SIZE;
1896 # endif /* DB_CACHE_SIZE */
1897 # endif /* DB_VERSION_MAJOR < 3 */
1898
1899 return db_map_open(map, mode, "btree", DB_BTREE, &btinfo);
1900 }
1901
1902 bool
1903 hash_map_open(map, mode)
1904 MAP *map;
1905 int mode;
1906 {
1907 # if DB_VERSION_MAJOR < 2
1908 HASHINFO hinfo;
1909 # endif /* DB_VERSION_MAJOR < 2 */
1910 # if DB_VERSION_MAJOR == 2
1911 DB_INFO hinfo;
1912 # endif /* DB_VERSION_MAJOR == 2 */
1913 # if DB_VERSION_MAJOR > 2
1914 void *hinfo = NULL;
1915 # endif /* DB_VERSION_MAJOR > 2 */
1916
1917 if (tTd(38, 2))
1918 sm_dprintf("hash_map_open(%s, %s, %d)\n",
1919 map->map_mname, map->map_file, mode);
1920
1921 # if DB_VERSION_MAJOR < 3
1922 memset(&hinfo, '\0', sizeof hinfo);
1923 # ifdef DB_HASH_NELEM
1924 hinfo.h_nelem = DB_HASH_NELEM;
1925 # endif /* DB_HASH_NELEM */
1926 # ifdef DB_CACHE_SIZE
1927 hinfo.db_cachesize = DB_CACHE_SIZE;
1928 # endif /* DB_CACHE_SIZE */
1929 # endif /* DB_VERSION_MAJOR < 3 */
1930
1931 return db_map_open(map, mode, "hash", DB_HASH, &hinfo);
1932 }
1933
1934 static bool
1935 db_map_open(map, mode, mapclassname, dbtype, openinfo)
1936 MAP *map;
1937 int mode;
1938 char *mapclassname;
1939 DBTYPE dbtype;
1940 # if DB_VERSION_MAJOR < 2
1941 const void *openinfo;
1942 # endif /* DB_VERSION_MAJOR < 2 */
1943 # if DB_VERSION_MAJOR == 2
1944 DB_INFO *openinfo;
1945 # endif /* DB_VERSION_MAJOR == 2 */
1946 # if DB_VERSION_MAJOR > 2
1947 void **openinfo;
1948 # endif /* DB_VERSION_MAJOR > 2 */
1949 {
1950 DB *db = NULL;
1951 int i;
1952 int omode;
1953 int smode = S_IREAD;
1954 int fd;
1955 long sff;
1956 int save_errno;
1957 struct stat st;
1958 char buf[MAXPATHLEN];
1959
1960 /* do initial file and directory checks */
1961 if (sm_strlcpy(buf, map->map_file, sizeof buf) >= sizeof buf)
1962 {
1963 errno = 0;
1964 if (!bitset(MF_OPTIONAL, map->map_mflags))
1965 syserr("map \"%s\": map file %s name too long",
1966 map->map_mname, map->map_file);
1967 return false;
1968 }
1969 i = strlen(buf);
1970 if (i < 3 || strcmp(&buf[i - 3], ".db") != 0)
1971 {
1972 if (sm_strlcat(buf, ".db", sizeof buf) >= sizeof buf)
1973 {
1974 errno = 0;
1975 if (!bitset(MF_OPTIONAL, map->map_mflags))
1976 syserr("map \"%s\": map file %s name too long",
1977 map->map_mname, map->map_file);
1978 return false;
1979 }
1980 }
1981
1982 mode &= O_ACCMODE;
1983 omode = mode;
1984
1985 sff = SFF_ROOTOK|SFF_REGONLY;
1986 if (mode == O_RDWR)
1987 {
1988 sff |= SFF_CREAT;
1989 if (!bitnset(DBS_WRITEMAPTOSYMLINK, DontBlameSendmail))
1990 sff |= SFF_NOSLINK;
1991 if (!bitnset(DBS_WRITEMAPTOHARDLINK, DontBlameSendmail))
1992 sff |= SFF_NOHLINK;
1993 smode = S_IWRITE;
1994 }
1995 else
1996 {
1997 if (!bitnset(DBS_LINKEDMAPINWRITABLEDIR, DontBlameSendmail))
1998 sff |= SFF_NOWLINK;
1999 }
2000 if (!bitnset(DBS_MAPINUNSAFEDIRPATH, DontBlameSendmail))
2001 sff |= SFF_SAFEDIRPATH;
2002 i = safefile(buf, RunAsUid, RunAsGid, RunAsUserName, sff, smode, &st);
2003
2004 if (i != 0)
2005 {
2006 char *prob = "unsafe";
2007
2008 /* cannot open this map */
2009 if (i == ENOENT)
2010 prob = "missing";
2011 if (tTd(38, 2))
2012 sm_dprintf("\t%s map file: %s\n", prob, sm_errstring(i));
2013 errno = i;
2014 if (!bitset(MF_OPTIONAL, map->map_mflags))
2015 syserr("%s map \"%s\": %s map file %s",
2016 mapclassname, map->map_mname, prob, buf);
2017 return false;
2018 }
2019 if (st.st_mode == ST_MODE_NOFILE)
2020 omode |= O_CREAT|O_EXCL;
2021
2022 map->map_lockfd = -1;
2023
2024 # if LOCK_ON_OPEN
2025 if (mode == O_RDWR)
2026 omode |= O_TRUNC|O_EXLOCK;
2027 else
2028 omode |= O_SHLOCK;
2029 # else /* LOCK_ON_OPEN */
2030 /*
2031 ** Pre-lock the file to avoid race conditions. In particular,
2032 ** since dbopen returns NULL if the file is zero length, we
2033 ** must have a locked instance around the dbopen.
2034 */
2035
2036 fd = open(buf, omode, DBMMODE);
2037 if (fd < 0)
2038 {
2039 if (!bitset(MF_OPTIONAL, map->map_mflags))
2040 syserr("db_map_open: cannot pre-open database %s", buf);
2041 return false;
2042 }
2043
2044 /* make sure no baddies slipped in just before the open... */
2045 if (filechanged(buf, fd, &st))
2046 {
2047 save_errno = errno;
2048 (void) close(fd);
2049 errno = save_errno;
2050 syserr("db_map_open(%s): file changed after pre-open", buf);
2051 return false;
2052 }
2053
2054 /* if new file, get the "before" bits for later filechanged check */
2055 if (st.st_mode == ST_MODE_NOFILE && fstat(fd, &st) < 0)
2056 {
2057 save_errno = errno;
2058 (void) close(fd);
2059 errno = save_errno;
2060 syserr("db_map_open(%s): cannot fstat pre-opened file",
2061 buf);
2062 return false;
2063 }
2064
2065 /* actually lock the pre-opened file */
2066 if (!lockfile(fd, buf, NULL, mode == O_RDONLY ? LOCK_SH : LOCK_EX))
2067 syserr("db_map_open: cannot lock %s", buf);
2068
2069 /* set up mode bits for dbopen */
2070 if (mode == O_RDWR)
2071 omode |= O_TRUNC;
2072 omode &= ~(O_EXCL|O_CREAT);
2073 # endif /* LOCK_ON_OPEN */
2074
2075 # if DB_VERSION_MAJOR < 2
2076 db = dbopen(buf, omode, DBMMODE, dbtype, openinfo);
2077 # else /* DB_VERSION_MAJOR < 2 */
2078 {
2079 int flags = 0;
2080 # if DB_VERSION_MAJOR > 2
2081 int ret;
2082 # endif /* DB_VERSION_MAJOR > 2 */
2083
2084 if (mode == O_RDONLY)
2085 flags |= DB_RDONLY;
2086 if (bitset(O_CREAT, omode))
2087 flags |= DB_CREATE;
2088 if (bitset(O_TRUNC, omode))
2089 flags |= DB_TRUNCATE;
2090 SM_DB_FLAG_ADD(flags);
2091
2092 # if DB_VERSION_MAJOR > 2
2093 ret = db_create(&db, NULL, 0);
2094 # ifdef DB_CACHE_SIZE
2095 if (ret == 0 && db != NULL)
2096 {
2097 ret = db->set_cachesize(db, 0, DB_CACHE_SIZE, 0);
2098 if (ret != 0)
2099 {
2100 (void) db->close(db, 0);
2101 db = NULL;
2102 }
2103 }
2104 # endif /* DB_CACHE_SIZE */
2105 # ifdef DB_HASH_NELEM
2106 if (dbtype == DB_HASH && ret == 0 && db != NULL)
2107 {
2108 ret = db->set_h_nelem(db, DB_HASH_NELEM);
2109 if (ret != 0)
2110 {
2111 (void) db->close(db, 0);
2112 db = NULL;
2113 }
2114 }
2115 # endif /* DB_HASH_NELEM */
2116 if (ret == 0 && db != NULL)
2117 {
2118 ret = db->open(db,
2119 DBTXN /* transaction for DB 4.1 */
2120 buf, NULL, dbtype, flags, DBMMODE);
2121 if (ret != 0)
2122 {
2123 #ifdef DB_OLD_VERSION
2124 if (ret == DB_OLD_VERSION)
2125 ret = EINVAL;
2126 #endif /* DB_OLD_VERSION */
2127 (void) db->close(db, 0);
2128 db = NULL;
2129 }
2130 }
2131 errno = ret;
2132 # else /* DB_VERSION_MAJOR > 2 */
2133 errno = db_open(buf, dbtype, flags, DBMMODE,
2134 NULL, openinfo, &db);
2135 # endif /* DB_VERSION_MAJOR > 2 */
2136 }
2137 # endif /* DB_VERSION_MAJOR < 2 */
2138 save_errno = errno;
2139
2140 # if !LOCK_ON_OPEN
2141 if (mode == O_RDWR)
2142 map->map_lockfd = fd;
2143 else
2144 (void) close(fd);
2145 # endif /* !LOCK_ON_OPEN */
2146
2147 if (db == NULL)
2148 {
2149 if (mode == O_RDONLY && bitset(MF_ALIAS, map->map_mflags) &&
2150 aliaswait(map, ".db", false))
2151 return true;
2152 # if !LOCK_ON_OPEN
2153 if (map->map_lockfd >= 0)
2154 (void) close(map->map_lockfd);
2155 # endif /* !LOCK_ON_OPEN */
2156 errno = save_errno;
2157 if (!bitset(MF_OPTIONAL, map->map_mflags))
2158 syserr("Cannot open %s database %s",
2159 mapclassname, buf);
2160 return false;
2161 }
2162
2163 # if DB_VERSION_MAJOR < 2
2164 fd = db->fd(db);
2165 # else /* DB_VERSION_MAJOR < 2 */
2166 fd = -1;
2167 errno = db->fd(db, &fd);
2168 # endif /* DB_VERSION_MAJOR < 2 */
2169 if (filechanged(buf, fd, &st))
2170 {
2171 save_errno = errno;
2172 # if DB_VERSION_MAJOR < 2
2173 (void) db->close(db);
2174 # else /* DB_VERSION_MAJOR < 2 */
2175 errno = db->close(db, 0);
2176 # endif /* DB_VERSION_MAJOR < 2 */
2177 # if !LOCK_ON_OPEN
2178 if (map->map_lockfd >= 0)
2179 (void) close(map->map_lockfd);
2180 # endif /* !LOCK_ON_OPEN */
2181 errno = save_errno;
2182 syserr("db_map_open(%s): file changed after open", buf);
2183 return false;
2184 }
2185
2186 if (mode == O_RDWR)
2187 map->map_mflags |= MF_LOCKED;
2188 # if LOCK_ON_OPEN
2189 if (fd >= 0 && mode == O_RDONLY)
2190 {
2191 (void) lockfile(fd, buf, NULL, LOCK_UN);
2192 }
2193 # endif /* LOCK_ON_OPEN */
2194
2195 /* try to make sure that at least the database header is on disk */
2196 if (mode == O_RDWR)
2197 {
2198 (void) db->sync(db, 0);
2199 if (geteuid() == 0 && TrustedUid != 0)
2200 {
2201 # if HASFCHOWN
2202 if (fchown(fd, TrustedUid, -1) < 0)
2203 {
2204 int err = errno;
2205
2206 sm_syslog(LOG_ALERT, NOQID,
2207 "ownership change on %s failed: %s",
2208 buf, sm_errstring(err));
2209 message("050 ownership change on %s failed: %s",
2210 buf, sm_errstring(err));
2211 }
2212 # else /* HASFCHOWN */
2213 sm_syslog(LOG_ALERT, NOQID,
2214 "no fchown(): cannot change ownership on %s",
2215 map->map_file);
2216 message("050 no fchown(): cannot change ownership on %s",
2217 map->map_file);
2218 # endif /* HASFCHOWN */
2219 }
2220 }
2221
2222 map->map_db2 = (ARBPTR_T) db;
2223
2224 /*
2225 ** Need to set map_mtime before the call to aliaswait()
2226 ** as aliaswait() will call map_lookup() which requires
2227 ** map_mtime to be set
2228 */
2229
2230 if (fd >= 0 && fstat(fd, &st) >= 0)
2231 map->map_mtime = st.st_mtime;
2232
2233 if (mode == O_RDONLY && bitset(MF_ALIAS, map->map_mflags) &&
2234 !aliaswait(map, ".db", true))
2235 return false;
2236 return true;
2237 }
2238
2239
2240 /*
2241 ** DB_MAP_LOOKUP -- look up a datum in a BTREE- or HASH-type map
2242 */
2243
2244 char *
2245 db_map_lookup(map, name, av, statp)
2246 MAP *map;
2247 char *name;
2248 char **av;
2249 int *statp;
2250 {
2251 DBT key, val;
2252 register DB *db = (DB *) map->map_db2;
2253 int i;
2254 int st;
2255 int save_errno;
2256 int fd;
2257 struct stat stbuf;
2258 char keybuf[MAXNAME + 1];
2259 char buf[MAXPATHLEN];
2260
2261 memset(&key, '\0', sizeof key);
2262 memset(&val, '\0', sizeof val);
2263
2264 if (tTd(38, 20))
2265 sm_dprintf("db_map_lookup(%s, %s)\n",
2266 map->map_mname, name);
2267
2268 if (sm_strlcpy(buf, map->map_file, sizeof buf) >= sizeof buf)
2269 {
2270 errno = 0;
2271 if (!bitset(MF_OPTIONAL, map->map_mflags))
2272 syserr("map \"%s\": map file %s name too long",
2273 map->map_mname, map->map_file);
2274 return NULL;
2275 }
2276 i = strlen(buf);
2277 if (i > 3 && strcmp(&buf[i - 3], ".db") == 0)
2278 buf[i - 3] = '\0';
2279
2280 key.size = strlen(name);
2281 if (key.size > sizeof keybuf - 1)
2282 key.size = sizeof keybuf - 1;
2283 key.data = keybuf;
2284 memmove(keybuf, name, key.size);
2285 keybuf[key.size] = '\0';
2286 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
2287 makelower(keybuf);
2288 lockdb:
2289 # if DB_VERSION_MAJOR < 2
2290 fd = db->fd(db);
2291 # else /* DB_VERSION_MAJOR < 2 */
2292 fd = -1;
2293 errno = db->fd(db, &fd);
2294 # endif /* DB_VERSION_MAJOR < 2 */
2295 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
2296 (void) lockfile(fd, buf, ".db", LOCK_SH);
2297 if (fd < 0 || fstat(fd, &stbuf) < 0 || stbuf.st_mtime > map->map_mtime)
2298 {
2299 /* Reopen the database to sync the cache */
2300 int omode = bitset(map->map_mflags, MF_WRITABLE) ? O_RDWR
2301 : O_RDONLY;
2302
2303 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
2304 (void) lockfile(fd, buf, ".db", LOCK_UN);
2305 map->map_mflags |= MF_CLOSING;
2306 map->map_class->map_close(map);
2307 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING);
2308 if (map->map_class->map_open(map, omode))
2309 {
2310 map->map_mflags |= MF_OPEN;
2311 map->map_pid = CurrentPid;
2312 if ((omode && O_ACCMODE) == O_RDWR)
2313 map->map_mflags |= MF_WRITABLE;
2314 db = (DB *) map->map_db2;
2315 goto lockdb;
2316 }
2317 else
2318 {
2319 if (!bitset(MF_OPTIONAL, map->map_mflags))
2320 {
2321 extern MAPCLASS BogusMapClass;
2322
2323 *statp = EX_TEMPFAIL;
2324 map->map_orgclass = map->map_class;
2325 map->map_class = &BogusMapClass;
2326 map->map_mflags |= MF_OPEN;
2327 map->map_pid = CurrentPid;
2328 syserr("Cannot reopen DB database %s",
2329 map->map_file);
2330 }
2331 return NULL;
2332 }
2333 }
2334
2335 st = 1;
2336 if (bitset(MF_TRY0NULL, map->map_mflags))
2337 {
2338 # if DB_VERSION_MAJOR < 2
2339 st = db->get(db, &key, &val, 0);
2340 # else /* DB_VERSION_MAJOR < 2 */
2341 errno = db->get(db, NULL, &key, &val, 0);
2342 switch (errno)
2343 {
2344 case DB_NOTFOUND:
2345 case DB_KEYEMPTY:
2346 st = 1;
2347 break;
2348
2349 case 0:
2350 st = 0;
2351 break;
2352
2353 default:
2354 st = -1;
2355 break;
2356 }
2357 # endif /* DB_VERSION_MAJOR < 2 */
2358 if (st == 0)
2359 map->map_mflags &= ~MF_TRY1NULL;
2360 }
2361 if (st != 0 && bitset(MF_TRY1NULL, map->map_mflags))
2362 {
2363 key.size++;
2364 # if DB_VERSION_MAJOR < 2
2365 st = db->get(db, &key, &val, 0);
2366 # else /* DB_VERSION_MAJOR < 2 */
2367 errno = db->get(db, NULL, &key, &val, 0);
2368 switch (errno)
2369 {
2370 case DB_NOTFOUND:
2371 case DB_KEYEMPTY:
2372 st = 1;
2373 break;
2374
2375 case 0:
2376 st = 0;
2377 break;
2378
2379 default:
2380 st = -1;
2381 break;
2382 }
2383 # endif /* DB_VERSION_MAJOR < 2 */
2384 if (st == 0)
2385 map->map_mflags &= ~MF_TRY0NULL;
2386 }
2387 save_errno = errno;
2388 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
2389 (void) lockfile(fd, buf, ".db", LOCK_UN);
2390 if (st != 0)
2391 {
2392 errno = save_errno;
2393 if (st < 0)
2394 syserr("db_map_lookup: get (%s)", name);
2395 return NULL;
2396 }
2397 if (bitset(MF_MATCHONLY, map->map_mflags))
2398 return map_rewrite(map, name, strlen(name), NULL);
2399 else
2400 return map_rewrite(map, val.data, val.size, av);
2401 }
2402
2403
2404 /*
2405 ** DB_MAP_STORE -- store a datum in the NEWDB database
2406 */
2407
2408 void
2409 db_map_store(map, lhs, rhs)
2410 register MAP *map;
2411 char *lhs;
2412 char *rhs;
2413 {
2414 int status;
2415 DBT key;
2416 DBT data;
2417 register DB *db = map->map_db2;
2418 char keybuf[MAXNAME + 1];
2419
2420 memset(&key, '\0', sizeof key);
2421 memset(&data, '\0', sizeof data);
2422
2423 if (tTd(38, 12))
2424 sm_dprintf("db_map_store(%s, %s, %s)\n",
2425 map->map_mname, lhs, rhs);
2426
2427 key.size = strlen(lhs);
2428 key.data = lhs;
2429 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
2430 {
2431 if (key.size > sizeof keybuf - 1)
2432 key.size = sizeof keybuf - 1;
2433 memmove(keybuf, key.data, key.size);
2434 keybuf[key.size] = '\0';
2435 makelower(keybuf);
2436 key.data = keybuf;
2437 }
2438
2439 data.size = strlen(rhs);
2440 data.data = rhs;
2441
2442 if (bitset(MF_INCLNULL, map->map_mflags))
2443 {
2444 key.size++;
2445 data.size++;
2446 }
2447
2448 # if DB_VERSION_MAJOR < 2
2449 status = db->put(db, &key, &data, R_NOOVERWRITE);
2450 # else /* DB_VERSION_MAJOR < 2 */
2451 errno = db->put(db, NULL, &key, &data, DB_NOOVERWRITE);
2452 switch (errno)
2453 {
2454 case DB_KEYEXIST:
2455 status = 1;
2456 break;
2457
2458 case 0:
2459 status = 0;
2460 break;
2461
2462 default:
2463 status = -1;
2464 break;
2465 }
2466 # endif /* DB_VERSION_MAJOR < 2 */
2467 if (status > 0)
2468 {
2469 if (!bitset(MF_APPEND, map->map_mflags))
2470 message("050 Warning: duplicate alias name %s", lhs);
2471 else
2472 {
2473 static char *buf = NULL;
2474 static int bufsiz = 0;
2475 DBT old;
2476
2477 memset(&old, '\0', sizeof old);
2478
2479 old.data = db_map_lookup(map, key.data,
2480 (char **) NULL, &status);
2481 if (old.data != NULL)
2482 {
2483 old.size = strlen(old.data);
2484 if (data.size + old.size + 2 > (size_t) bufsiz)
2485 {
2486 if (buf != NULL)
2487 sm_free(buf);
2488 bufsiz = data.size + old.size + 2;
2489 buf = sm_pmalloc_x(bufsiz);
2490 }
2491 (void) sm_strlcpyn(buf, bufsiz, 3,
2492 (char *) data.data, ",",
2493 (char *) old.data);
2494 data.size = data.size + old.size + 1;
2495 data.data = buf;
2496 if (tTd(38, 9))
2497 sm_dprintf("db_map_store append=%s\n",
2498 (char *) data.data);
2499 }
2500 }
2501 # if DB_VERSION_MAJOR < 2
2502 status = db->put(db, &key, &data, 0);
2503 # else /* DB_VERSION_MAJOR < 2 */
2504 status = errno = db->put(db, NULL, &key, &data, 0);
2505 # endif /* DB_VERSION_MAJOR < 2 */
2506 }
2507 if (status != 0)
2508 syserr("readaliases: db put (%s)", lhs);
2509 }
2510
2511
2512 /*
2513 ** DB_MAP_CLOSE -- add distinguished entries and close the database
2514 */
2515
2516 void
2517 db_map_close(map)
2518 MAP *map;
2519 {
2520 register DB *db = map->map_db2;
2521
2522 if (tTd(38, 9))
2523 sm_dprintf("db_map_close(%s, %s, %lx)\n",
2524 map->map_mname, map->map_file, map->map_mflags);
2525
2526 if (bitset(MF_WRITABLE, map->map_mflags))
2527 {
2528 /* write out the distinguished alias */
2529 db_map_store(map, "@", "@");
2530 }
2531
2532 (void) db->sync(db, 0);
2533
2534 # if !LOCK_ON_OPEN
2535 if (map->map_lockfd >= 0)
2536 (void) close(map->map_lockfd);
2537 # endif /* !LOCK_ON_OPEN */
2538
2539 # if DB_VERSION_MAJOR < 2
2540 if (db->close(db) != 0)
2541 # else /* DB_VERSION_MAJOR < 2 */
2542 /*
2543 ** Berkeley DB can use internal shared memory
2544 ** locking for its memory pool. Closing a map
2545 ** opened by another process will interfere
2546 ** with the shared memory and locks of the parent
2547 ** process leaving things in a bad state.
2548 */
2549
2550 /*
2551 ** If this map was not opened by the current
2552 ** process, do not close the map but recover
2553 ** the file descriptor.
2554 */
2555
2556 if (map->map_pid != CurrentPid)
2557 {
2558 int fd = -1;
2559
2560 errno = db->fd(db, &fd);
2561 if (fd >= 0)
2562 (void) close(fd);
2563 return;
2564 }
2565
2566 if ((errno = db->close(db, 0)) != 0)
2567 # endif /* DB_VERSION_MAJOR < 2 */
2568 syserr("db_map_close(%s, %s, %lx): db close failure",
2569 map->map_mname, map->map_file, map->map_mflags);
2570 }
2571 #endif /* NEWDB */
2572 /*
2573 ** NIS Modules
2574 */
2575
2576 #if NIS
2577
2578 # ifndef YPERR_BUSY
2579 # define YPERR_BUSY 16
2580 # endif /* ! YPERR_BUSY */
2581
2582 /*
2583 ** NIS_MAP_OPEN -- open DBM map
2584 */
2585
2586 bool
2587 nis_map_open(map, mode)
2588 MAP *map;
2589 int mode;
2590 {
2591 int yperr;
2592 register char *p;
2593 auto char *vp;
2594 auto int vsize;
2595
2596 if (tTd(38, 2))
2597 sm_dprintf("nis_map_open(%s, %s, %d)\n",
2598 map->map_mname, map->map_file, mode);
2599
2600 mode &= O_ACCMODE;
2601 if (mode != O_RDONLY)
2602 {
2603 /* issue a pseudo-error message */
2604 errno = SM_EMAPCANTWRITE;
2605 return false;
2606 }
2607
2608 p = strchr(map->map_file, '@');
2609 if (p != NULL)
2610 {
2611 *p++ = '\0';
2612 if (*p != '\0')
2613 map->map_domain = p;
2614 }
2615
2616 if (*map->map_file == '\0')
2617 map->map_file = "mail.aliases";
2618
2619 if (map->map_domain == NULL)
2620 {
2621 yperr = yp_get_default_domain(&map->map_domain);
2622 if (yperr != 0)
2623 {
2624 if (!bitset(MF_OPTIONAL, map->map_mflags))
2625 syserr("451 4.3.5 NIS map %s specified, but NIS not running",
2626 map->map_file);
2627 return false;
2628 }
2629 }
2630
2631 /* check to see if this map actually exists */
2632 vp = NULL;
2633 yperr = yp_match(map->map_domain, map->map_file, "@", 1,
2634 &vp, &vsize);
2635 if (tTd(38, 10))
2636 sm_dprintf("nis_map_open: yp_match(@, %s, %s) => %s\n",
2637 map->map_domain, map->map_file, yperr_string(yperr));
2638 if (vp != NULL)
2639 sm_free(vp);
2640
2641 if (yperr == 0 || yperr == YPERR_KEY || yperr == YPERR_BUSY)
2642 {
2643 /*
2644 ** We ought to be calling aliaswait() here if this is an
2645 ** alias file, but powerful HP-UX NIS servers apparently
2646 ** don't insert the @:@ token into the alias map when it
2647 ** is rebuilt, so aliaswait() just hangs. I hate HP-UX.
2648 */
2649
2650 # if 0
2651 if (!bitset(MF_ALIAS, map->map_mflags) ||
2652 aliaswait(map, NULL, true))
2653 # endif /* 0 */
2654 return true;
2655 }
2656
2657 if (!bitset(MF_OPTIONAL, map->map_mflags))
2658 {
2659 syserr("451 4.3.5 Cannot bind to map %s in domain %s: %s",
2660 map->map_file, map->map_domain, yperr_string(yperr));
2661 }
2662
2663 return false;
2664 }
2665
2666
2667 /*
2668 ** NIS_MAP_LOOKUP -- look up a datum in a NIS map
2669 */
2670
2671 /* ARGSUSED3 */
2672 char *
2673 nis_map_lookup(map, name, av, statp)
2674 MAP *map;
2675 char *name;
2676 char **av;
2677 int *statp;
2678 {
2679 char *vp;
2680 auto int vsize;
2681 int buflen;
2682 int yperr;
2683 char keybuf[MAXNAME + 1];
2684 char *SM_NONVOLATILE result = NULL;
2685
2686 if (tTd(38, 20))
2687 sm_dprintf("nis_map_lookup(%s, %s)\n",
2688 map->map_mname, name);
2689
2690 buflen = strlen(name);
2691 if (buflen > sizeof keybuf - 1)
2692 buflen = sizeof keybuf - 1;
2693 memmove(keybuf, name, buflen);
2694 keybuf[buflen] = '\0';
2695 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
2696 makelower(keybuf);
2697 yperr = YPERR_KEY;
2698 vp = NULL;
2699 if (bitset(MF_TRY0NULL, map->map_mflags))
2700 {
2701 yperr = yp_match(map->map_domain, map->map_file, keybuf, buflen,
2702 &vp, &vsize);
2703 if (yperr == 0)
2704 map->map_mflags &= ~MF_TRY1NULL;
2705 }
2706 if (yperr == YPERR_KEY && bitset(MF_TRY1NULL, map->map_mflags))
2707 {
2708 SM_FREE_CLR(vp);
2709 buflen++;
2710 yperr = yp_match(map->map_domain, map->map_file, keybuf, buflen,
2711 &vp, &vsize);
2712 if (yperr == 0)
2713 map->map_mflags &= ~MF_TRY0NULL;
2714 }
2715 if (yperr != 0)
2716 {
2717 if (yperr != YPERR_KEY && yperr != YPERR_BUSY)
2718 map->map_mflags &= ~(MF_VALID|MF_OPEN);
2719 if (vp != NULL)
2720 sm_free(vp);
2721 return NULL;
2722 }
2723 SM_TRY
2724 if (bitset(MF_MATCHONLY, map->map_mflags))
2725 result = map_rewrite(map, name, strlen(name), NULL);
2726 else
2727 result = map_rewrite(map, vp, vsize, av);
2728 SM_FINALLY
2729 if (vp != NULL)
2730 sm_free(vp);
2731 SM_END_TRY
2732 return result;
2733 }
2734
2735
2736 /*
2737 ** NIS_GETCANONNAME -- look up canonical name in NIS
2738 */
2739
2740 static bool
2741 nis_getcanonname(name, hbsize, statp)
2742 char *name;
2743 int hbsize;
2744 int *statp;
2745 {
2746 char *vp;
2747 auto int vsize;
2748 int keylen;
2749 int yperr;
2750 static bool try0null = true;
2751 static bool try1null = true;
2752 static char *yp_domain = NULL;
2753 char host_record[MAXLINE];
2754 char cbuf[MAXNAME];
2755 char nbuf[MAXNAME + 1];
2756
2757 if (tTd(38, 20))
2758 sm_dprintf("nis_getcanonname(%s)\n", name);
2759
2760 if (sm_strlcpy(nbuf, name, sizeof nbuf) >= sizeof nbuf)
2761 {
2762 *statp = EX_UNAVAILABLE;
2763 return false;
2764 }
2765 (void) shorten_hostname(nbuf);
2766 keylen = strlen(nbuf);
2767
2768 if (yp_domain == NULL)
2769 (void) yp_get_default_domain(&yp_domain);
2770 makelower(nbuf);
2771 yperr = YPERR_KEY;
2772 vp = NULL;
2773 if (try0null)
2774 {
2775 yperr = yp_match(yp_domain, "hosts.byname", nbuf, keylen,
2776 &vp, &vsize);
2777 if (yperr == 0)
2778 try1null = false;
2779 }
2780 if (yperr == YPERR_KEY && try1null)
2781 {
2782 SM_FREE_CLR(vp);
2783 keylen++;
2784 yperr = yp_match(yp_domain, "hosts.byname", nbuf, keylen,
2785 &vp, &vsize);
2786 if (yperr == 0)
2787 try0null = false;
2788 }
2789 if (yperr != 0)
2790 {
2791 if (yperr == YPERR_KEY)
2792 *statp = EX_NOHOST;
2793 else if (yperr == YPERR_BUSY)
2794 *statp = EX_TEMPFAIL;
2795 else
2796 *statp = EX_UNAVAILABLE;
2797 if (vp != NULL)
2798 sm_free(vp);
2799 return false;
2800 }
2801 (void) sm_strlcpy(host_record, vp, sizeof host_record);
2802 sm_free(vp);
2803 if (tTd(38, 44))
2804 sm_dprintf("got record `%s'\n", host_record);
2805 vp = strpbrk(host_record, "#\n");
2806 if (vp != NULL)
2807 *vp = '\0';
2808 if (!extract_canonname(nbuf, NULL, host_record, cbuf, sizeof cbuf))
2809 {
2810 /* this should not happen, but.... */
2811 *statp = EX_NOHOST;
2812 return false;
2813 }
2814 if (sm_strlcpy(name, cbuf, hbsize) >= hbsize)
2815 {
2816 *statp = EX_UNAVAILABLE;
2817 return false;
2818 }
2819 *statp = EX_OK;
2820 return true;
2821 }
2822
2823 #endif /* NIS */
2824 /*
2825 ** NISPLUS Modules
2826 **
2827 ** This code donated by Sun Microsystems.
2828 */
2829
2830 #if NISPLUS
2831
2832 # undef NIS /* symbol conflict in nis.h */
2833 # undef T_UNSPEC /* symbol conflict in nis.h -> ... -> sys/tiuser.h */
2834 # include <rpcsvc/nis.h>
2835 # include <rpcsvc/nislib.h>
2836
2837 # define EN_col(col) zo_data.objdata_u.en_data.en_cols.en_cols_val[(col)].ec_value.ec_value_val
2838 # define COL_NAME(res,i) ((res->objects.objects_val)->TA_data.ta_cols.ta_cols_val)[i].tc_name
2839 # define COL_MAX(res) ((res->objects.objects_val)->TA_data.ta_cols.ta_cols_len)
2840 # define PARTIAL_NAME(x) ((x)[strlen(x) - 1] != '.')
2841
2842 /*
2843 ** NISPLUS_MAP_OPEN -- open nisplus table
2844 */
2845
2846 bool
2847 nisplus_map_open(map, mode)
2848 MAP *map;
2849 int mode;
2850 {
2851 nis_result *res = NULL;
2852 int retry_cnt, max_col, i;
2853 char qbuf[MAXLINE + NIS_MAXNAMELEN];
2854
2855 if (tTd(38, 2))
2856 sm_dprintf("nisplus_map_open(%s, %s, %d)\n",
2857 map->map_mname, map->map_file, mode);
2858
2859 mode &= O_ACCMODE;
2860 if (mode != O_RDONLY)
2861 {
2862 errno = EPERM;
2863 return false;
2864 }
2865
2866 if (*map->map_file == '\0')
2867 map->map_file = "mail_aliases.org_dir";
2868
2869 if (PARTIAL_NAME(map->map_file) && map->map_domain == NULL)
2870 {
2871 /* set default NISPLUS Domain to $m */
2872 map->map_domain = newstr(nisplus_default_domain());
2873 if (tTd(38, 2))
2874 sm_dprintf("nisplus_map_open(%s): using domain %s\n",
2875 map->map_file, map->map_domain);
2876 }
2877 if (!PARTIAL_NAME(map->map_file))
2878 {
2879 map->map_domain = newstr("");
2880 (void) sm_strlcpy(qbuf, map->map_file, sizeof qbuf);
2881 }
2882 else
2883 {
2884 /* check to see if this map actually exists */
2885 (void) sm_strlcpyn(qbuf, sizeof qbuf, 3,
2886 map->map_file, ".", map->map_domain);
2887 }
2888
2889 retry_cnt = 0;
2890 while (res == NULL || res->status != NIS_SUCCESS)
2891 {
2892 res = nis_lookup(qbuf, FOLLOW_LINKS);
2893 switch (res->status)
2894 {
2895 case NIS_SUCCESS:
2896 break;
2897
2898 case NIS_TRYAGAIN:
2899 case NIS_RPCERROR:
2900 case NIS_NAMEUNREACHABLE:
2901 if (retry_cnt++ > 4)
2902 {
2903 errno = EAGAIN;
2904 return false;
2905 }
2906 /* try not to overwhelm hosed server */
2907 sleep(2);
2908 break;
2909
2910 default: /* all other nisplus errors */
2911 # if 0
2912 if (!bitset(MF_OPTIONAL, map->map_mflags))
2913 syserr("451 4.3.5 Cannot find table %s.%s: %s",
2914 map->map_file, map->map_domain,
2915 nis_sperrno(res->status));
2916 # endif /* 0 */
2917 errno = EAGAIN;
2918 return false;
2919 }
2920 }
2921
2922 if (NIS_RES_NUMOBJ(res) != 1 ||
2923 (NIS_RES_OBJECT(res)->zo_data.zo_type != TABLE_OBJ))
2924 {
2925 if (tTd(38, 10))
2926 sm_dprintf("nisplus_map_open: %s is not a table\n", qbuf);
2927 # if 0
2928 if (!bitset(MF_OPTIONAL, map->map_mflags))
2929 syserr("451 4.3.5 %s.%s: %s is not a table",
2930 map->map_file, map->map_domain,
2931 nis_sperrno(res->status));
2932 # endif /* 0 */
2933 errno = EBADF;
2934 return false;
2935 }
2936 /* default key column is column 0 */
2937 if (map->map_keycolnm == NULL)
2938 map->map_keycolnm = newstr(COL_NAME(res,0));
2939
2940 max_col = COL_MAX(res);
2941
2942 /* verify the key column exist */
2943 for (i = 0; i < max_col; i++)
2944 {
2945 if (strcmp(map->map_keycolnm, COL_NAME(res,i)) == 0)
2946 break;
2947 }
2948 if (i == max_col)
2949 {
2950 if (tTd(38, 2))
2951 sm_dprintf("nisplus_map_open(%s): can not find key column %s\n",
2952 map->map_file, map->map_keycolnm);
2953 errno = ENOENT;
2954 return false;
2955 }
2956
2957 /* default value column is the last column */
2958 if (map->map_valcolnm == NULL)
2959 {
2960 map->map_valcolno = max_col - 1;
2961 return true;
2962 }
2963
2964 for (i = 0; i< max_col; i++)
2965 {
2966 if (strcmp(map->map_valcolnm, COL_NAME(res,i)) == 0)
2967 {
2968 map->map_valcolno = i;
2969 return true;
2970 }
2971 }
2972
2973 if (tTd(38, 2))
2974 sm_dprintf("nisplus_map_open(%s): can not find column %s\n",
2975 map->map_file, map->map_keycolnm);
2976 errno = ENOENT;
2977 return false;
2978 }
2979
2980
2981 /*
2982 ** NISPLUS_MAP_LOOKUP -- look up a datum in a NISPLUS table
2983 */
2984
2985 char *
2986 nisplus_map_lookup(map, name, av, statp)
2987 MAP *map;
2988 char *name;
2989 char **av;
2990 int *statp;
2991 {
2992 char *p;
2993 auto int vsize;
2994 char *skp;
2995 int skleft;
2996 char search_key[MAXNAME + 4];
2997 char qbuf[MAXLINE + NIS_MAXNAMELEN];
2998 nis_result *result;
2999
3000 if (tTd(38, 20))
3001 sm_dprintf("nisplus_map_lookup(%s, %s)\n",
3002 map->map_mname, name);
3003
3004 if (!bitset(MF_OPEN, map->map_mflags))
3005 {
3006 if (nisplus_map_open(map, O_RDONLY))
3007 {
3008 map->map_mflags |= MF_OPEN;
3009 map->map_pid = CurrentPid;
3010 }
3011 else
3012 {
3013 *statp = EX_UNAVAILABLE;
3014 return NULL;
3015 }
3016 }
3017
3018 /*
3019 ** Copy the name to the key buffer, escaping double quote characters
3020 ** by doubling them and quoting "]" and "," to avoid having the
3021 ** NIS+ parser choke on them.
3022 */
3023
3024 skleft = sizeof search_key - 4;
3025 skp = search_key;
3026 for (p = name; *p != '\0' && skleft > 0; p++)
3027 {
3028 switch (*p)
3029 {
3030 case ']':
3031 case ',':
3032 /* quote the character */
3033 *skp++ = '"';
3034 *skp++ = *p;
3035 *skp++ = '"';
3036 skleft -= 3;
3037 break;
3038
3039 case '"':
3040 /* double the quote */
3041 *skp++ = '"';
3042 skleft--;
3043 /* FALLTHROUGH */
3044
3045 default:
3046 *skp++ = *p;
3047 skleft--;
3048 break;
3049 }
3050 }
3051 *skp = '\0';
3052 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
3053 makelower(search_key);
3054
3055 /* construct the query */
3056 if (PARTIAL_NAME(map->map_file))
3057 (void) sm_snprintf(qbuf, sizeof qbuf, "[%s=%s],%s.%s",
3058 map->map_keycolnm, search_key, map->map_file,
3059 map->map_domain);
3060 else
3061 (void) sm_snprintf(qbuf, sizeof qbuf, "[%s=%s],%s",
3062 map->map_keycolnm, search_key, map->map_file);
3063
3064 if (tTd(38, 20))
3065 sm_dprintf("qbuf=%s\n", qbuf);
3066 result = nis_list(qbuf, FOLLOW_LINKS | FOLLOW_PATH, NULL, NULL);
3067 if (result->status == NIS_SUCCESS)
3068 {
3069 int count;
3070 char *str;
3071
3072 if ((count = NIS_RES_NUMOBJ(result)) != 1)
3073 {
3074 if (LogLevel > 10)
3075 sm_syslog(LOG_WARNING, CurEnv->e_id,
3076 "%s: lookup error, expected 1 entry, got %d",
3077 map->map_file, count);
3078
3079 /* ignore second entry */
3080 if (tTd(38, 20))
3081 sm_dprintf("nisplus_map_lookup(%s), got %d entries, additional entries ignored\n",
3082 name, count);
3083 }
3084
3085 p = ((NIS_RES_OBJECT(result))->EN_col(map->map_valcolno));
3086 /* set the length of the result */
3087 if (p == NULL)
3088 p = "";
3089 vsize = strlen(p);
3090 if (tTd(38, 20))
3091 sm_dprintf("nisplus_map_lookup(%s), found %s\n",
3092 name, p);
3093 if (bitset(MF_MATCHONLY, map->map_mflags))
3094 str = map_rewrite(map, name, strlen(name), NULL);
3095 else
3096 str = map_rewrite(map, p, vsize, av);
3097 nis_freeresult(result);
3098 *statp = EX_OK;
3099 return str;
3100 }
3101 else
3102 {
3103 if (result->status == NIS_NOTFOUND)
3104 *statp = EX_NOTFOUND;
3105 else if (result->status == NIS_TRYAGAIN)
3106 *statp = EX_TEMPFAIL;
3107 else
3108 {
3109 *statp = EX_UNAVAILABLE;
3110 map->map_mflags &= ~(MF_VALID|MF_OPEN);
3111 }
3112 }
3113 if (tTd(38, 20))
3114 sm_dprintf("nisplus_map_lookup(%s), failed\n", name);
3115 nis_freeresult(result);
3116 return NULL;
3117 }
3118
3119
3120
3121 /*
3122 ** NISPLUS_GETCANONNAME -- look up canonical name in NIS+
3123 */
3124
3125 static bool
3126 nisplus_getcanonname(name, hbsize, statp)
3127 char *name;
3128 int hbsize;
3129 int *statp;
3130 {
3131 char *vp;
3132 auto int vsize;
3133 nis_result *result;
3134 char *p;
3135 char nbuf[MAXNAME + 1];
3136 char qbuf[MAXLINE + NIS_MAXNAMELEN];
3137
3138 if (sm_strlcpy(nbuf, name, sizeof nbuf) >= sizeof nbuf)
3139 {
3140 *statp = EX_UNAVAILABLE;
3141 return false;
3142 }
3143 (void) shorten_hostname(nbuf);
3144
3145 p = strchr(nbuf, '.');
3146 if (p == NULL)
3147 {
3148 /* single token */
3149 (void) sm_snprintf(qbuf, sizeof qbuf,
3150 "[name=%s],hosts.org_dir", nbuf);
3151 }
3152 else if (p[1] != '\0')
3153 {
3154 /* multi token -- take only first token in nbuf */
3155 *p = '\0';
3156 (void) sm_snprintf(qbuf, sizeof qbuf,
3157 "[name=%s],hosts.org_dir.%s", nbuf, &p[1]);
3158 }
3159 else
3160 {
3161 *statp = EX_NOHOST;
3162 return false;
3163 }
3164
3165 if (tTd(38, 20))
3166 sm_dprintf("\nnisplus_getcanonname(%s), qbuf=%s\n",
3167 name, qbuf);
3168
3169 result = nis_list(qbuf, EXPAND_NAME|FOLLOW_LINKS|FOLLOW_PATH,
3170 NULL, NULL);
3171
3172 if (result->status == NIS_SUCCESS)
3173 {
3174 int count;
3175 char *domain;
3176
3177 if ((count = NIS_RES_NUMOBJ(result)) != 1)
3178 {
3179 if (LogLevel > 10)
3180 sm_syslog(LOG_WARNING, CurEnv->e_id,
3181 "nisplus_getcanonname: lookup error, expected 1 entry, got %d",
3182 count);
3183
3184 /* ignore second entry */
3185 if (tTd(38, 20))
3186 sm_dprintf("nisplus_getcanonname(%s), got %d entries, all but first ignored\n",
3187 name, count);
3188 }
3189
3190 if (tTd(38, 20))
3191 sm_dprintf("nisplus_getcanonname(%s), found in directory \"%s\"\n",
3192 name, (NIS_RES_OBJECT(result))->zo_domain);
3193
3194
3195 vp = ((NIS_RES_OBJECT(result))->EN_col(0));
3196 vsize = strlen(vp);
3197 if (tTd(38, 20))
3198 sm_dprintf("nisplus_getcanonname(%s), found %s\n",
3199 name, vp);
3200 if (strchr(vp, '.') != NULL)
3201 {
3202 domain = "";
3203 }
3204 else
3205 {
3206 domain = macvalue('m', CurEnv);
3207 if (domain == NULL)
3208 domain = "";
3209 }
3210 if (hbsize > vsize + (int) strlen(domain) + 1)
3211 {
3212 if (domain[0] == '\0')
3213 (void) sm_strlcpy(name, vp, hbsize);
3214 else
3215 (void) sm_snprintf(name, hbsize,
3216 "%s.%s", vp, domain);
3217 *statp = EX_OK;
3218 }
3219 else
3220 *statp = EX_NOHOST;
3221 nis_freeresult(result);
3222 return true;
3223 }
3224 else
3225 {
3226 if (result->status == NIS_NOTFOUND)
3227 *statp = EX_NOHOST;
3228 else if (result->status == NIS_TRYAGAIN)
3229 *statp = EX_TEMPFAIL;
3230 else
3231 *statp = EX_UNAVAILABLE;
3232 }
3233 if (tTd(38, 20))
3234 sm_dprintf("nisplus_getcanonname(%s), failed, status=%d, nsw_stat=%d\n",
3235 name, result->status, *statp);
3236 nis_freeresult(result);
3237 return false;
3238 }
3239
3240 char *
3241 nisplus_default_domain()
3242 {
3243 static char default_domain[MAXNAME + 1] = "";
3244 char *p;
3245
3246 if (default_domain[0] != '\0')
3247 return default_domain;
3248
3249 p = nis_local_directory();
3250 (void) sm_strlcpy(default_domain, p, sizeof default_domain);
3251 return default_domain;
3252 }
3253
3254 #endif /* NISPLUS */
3255 /*
3256 ** LDAP Modules
3257 */
3258
3259 /*
3260 ** LDAPMAP_DEQUOTE - helper routine for ldapmap_parseargs
3261 */
3262
3263 #if defined(LDAPMAP) || defined(PH_MAP)
3264
3265 # if PH_MAP
3266 # define ph_map_dequote ldapmap_dequote
3267 # endif /* PH_MAP */
3268
3269 static char *ldapmap_dequote __P((char *));
3270
3271 static char *
3272 ldapmap_dequote(str)
3273 char *str;
3274 {
3275 char *p;
3276 char *start;
3277
3278 if (str == NULL)
3279 return NULL;
3280
3281 p = str;
3282 if (*p == '"')
3283 {
3284 /* Should probably swallow initial whitespace here */
3285 start = ++p;
3286 }
3287 else
3288 return str;
3289 while (*p != '"' && *p != '\0')
3290 p++;
3291 if (*p != '\0')
3292 *p = '\0';
3293 return start;
3294 }
3295 #endif /* defined(LDAPMAP) || defined(PH_MAP) */
3296
3297 #if LDAPMAP
3298
3299 static SM_LDAP_STRUCT *LDAPDefaults = NULL;
3300
3301 /*
3302 ** LDAPMAP_OPEN -- open LDAP map
3303 **
3304 ** Connect to the LDAP server. Re-use existing connections since a
3305 ** single server connection to a host (with the same host, port,
3306 ** bind DN, and secret) can answer queries for multiple maps.
3307 */
3308
3309 bool
3310 ldapmap_open(map, mode)
3311 MAP *map;
3312 int mode;
3313 {
3314 SM_LDAP_STRUCT *lmap;
3315 STAB *s;
3316 char *id;
3317
3318 if (tTd(38, 2))
3319 sm_dprintf("ldapmap_open(%s, %d): ", map->map_mname, mode);
3320
3321 mode &= O_ACCMODE;
3322
3323 /* sendmail doesn't have the ability to write to LDAP (yet) */
3324 if (mode != O_RDONLY)
3325 {
3326 /* issue a pseudo-error message */
3327 errno = SM_EMAPCANTWRITE;
3328 return false;
3329 }
3330
3331 lmap = (SM_LDAP_STRUCT *) map->map_db1;
3332
3333 s = ldapmap_findconn(lmap);
3334 if (s->s_lmap != NULL)
3335 {
3336 /* Already have a connection open to this LDAP server */
3337 lmap->ldap_ld = ((SM_LDAP_STRUCT *)s->s_lmap->map_db1)->ldap_ld;
3338 lmap->ldap_pid = ((SM_LDAP_STRUCT *)s->s_lmap->map_db1)->ldap_pid;
3339
3340 /* Add this map as head of linked list */
3341 lmap->ldap_next = s->s_lmap;
3342 s->s_lmap = map;
3343
3344 if (tTd(38, 2))
3345 sm_dprintf("using cached connection\n");
3346 return true;
3347 }
3348
3349 if (tTd(38, 2))
3350 sm_dprintf("opening new connection\n");
3351
3352 if (lmap->ldap_host != NULL)
3353 id = lmap->ldap_host;
3354 else if (lmap->ldap_uri != NULL)
3355 id = lmap->ldap_uri;
3356 else
3357 id = "localhost";
3358
3359 /* No connection yet, connect */
3360 if (!sm_ldap_start(map->map_mname, lmap))
3361 {
3362 if (errno == ETIMEDOUT)
3363 {
3364 if (LogLevel > 1)
3365 sm_syslog(LOG_NOTICE, CurEnv->e_id,
3366 "timeout conning to LDAP server %.100s",
3367 id);
3368 }
3369
3370 if (!bitset(MF_OPTIONAL, map->map_mflags))
3371 {
3372 if (bitset(MF_NODEFER, map->map_mflags))
3373 {
3374 syserr("%s failed to %s in map %s",
3375 # if USE_LDAP_INIT
3376 "ldap_init/ldap_bind",
3377 # else /* USE_LDAP_INIT */
3378 "ldap_open",
3379 # endif /* USE_LDAP_INIT */
3380 id, map->map_mname);
3381 }
3382 else
3383 {
3384 syserr("451 4.3.5 %s failed to %s in map %s",
3385 # if USE_LDAP_INIT
3386 "ldap_init/ldap_bind",
3387 # else /* USE_LDAP_INIT */
3388 "ldap_open",
3389 # endif /* USE_LDAP_INIT */
3390 id, map->map_mname);
3391 }
3392 }
3393 return false;
3394 }
3395
3396 /* Save connection for reuse */
3397 s->s_lmap = map;
3398 return true;
3399 }
3400
3401 /*
3402 ** LDAPMAP_CLOSE -- close ldap map
3403 */
3404
3405 void
3406 ldapmap_close(map)
3407 MAP *map;
3408 {
3409 SM_LDAP_STRUCT *lmap;
3410 STAB *s;
3411
3412 if (tTd(38, 2))
3413 sm_dprintf("ldapmap_close(%s)\n", map->map_mname);
3414
3415 lmap = (SM_LDAP_STRUCT *) map->map_db1;
3416
3417 /* Check if already closed */
3418 if (lmap->ldap_ld == NULL)
3419 return;
3420
3421 /* Close the LDAP connection */
3422 sm_ldap_close(lmap);
3423
3424 /* Mark all the maps that share the connection as closed */
3425 s = ldapmap_findconn(lmap);
3426
3427 while (s->s_lmap != NULL)
3428 {
3429 MAP *smap = s->s_lmap;
3430
3431 if (tTd(38, 2) && smap != map)
3432 sm_dprintf("ldapmap_close(%s): closed %s (shared LDAP connection)\n",
3433 map->map_mname, smap->map_mname);
3434 smap->map_mflags &= ~(MF_OPEN|MF_WRITABLE);
3435 lmap = (SM_LDAP_STRUCT *) smap->map_db1;
3436 lmap->ldap_ld = NULL;
3437 s->s_lmap = lmap->ldap_next;
3438 lmap->ldap_next = NULL;
3439 }
3440 }
3441
3442 # ifdef SUNET_ID
3443 /*
3444 ** SUNET_ID_HASH -- Convert a string to its Sunet_id canonical form
3445 ** This only makes sense at Stanford University.
3446 */
3447
3448 static char *
3449 sunet_id_hash(str)
3450 char *str;
3451 {
3452 char *p, *p_last;
3453
3454 p = str;
3455 p_last = p;
3456 while (*p != '\0')
3457 {
3458 if (islower(*p) || isdigit(*p))
3459 {
3460 *p_last = *p;
3461 p_last++;
3462 }
3463 else if (isupper(*p))
3464 {
3465 *p_last = tolower(*p);
3466 p_last++;
3467 }
3468 ++p;
3469 }
3470 if (*p_last != '\0')
3471 *p_last = '\0';
3472 return str;
3473 }
3474 # endif /* SUNET_ID */
3475
3476 /*
3477 ** LDAPMAP_LOOKUP -- look up a datum in a LDAP map
3478 */
3479
3480 char *
3481 ldapmap_lookup(map, name, av, statp)
3482 MAP *map;
3483 char *name;
3484 char **av;
3485 int *statp;
3486 {
3487 int flags;
3488 int plen = 0;
3489 int psize = 0;
3490 int msgid;
3491 int save_errno;
3492 char *vp, *p;
3493 char *result = NULL;
3494 SM_RPOOL_T *rpool;
3495 SM_LDAP_STRUCT *lmap = NULL;
3496 char keybuf[MAXKEY];
3497
3498 if (tTd(38, 20))
3499 sm_dprintf("ldapmap_lookup(%s, %s)\n", map->map_mname, name);
3500
3501 /* Get ldap struct pointer from map */
3502 lmap = (SM_LDAP_STRUCT *) map->map_db1;
3503 sm_ldap_setopts(lmap->ldap_ld, lmap);
3504
3505 (void) sm_strlcpy(keybuf, name, sizeof keybuf);
3506
3507 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
3508 {
3509 # ifdef SUNET_ID
3510 sunet_id_hash(keybuf);
3511 # else /* SUNET_ID */
3512 makelower(keybuf);
3513 # endif /* SUNET_ID */
3514 }
3515
3516 msgid = sm_ldap_search(lmap, keybuf);
3517 if (msgid == -1)
3518 {
3519 errno = sm_ldap_geterrno(lmap->ldap_ld) + E_LDAPBASE;
3520 save_errno = errno;
3521 if (!bitset(MF_OPTIONAL, map->map_mflags))
3522 {
3523 if (bitset(MF_NODEFER, map->map_mflags))
3524 syserr("Error in ldap_search using %s in map %s",
3525 keybuf, map->map_mname);
3526 else
3527 syserr("451 4.3.5 Error in ldap_search using %s in map %s",
3528 keybuf, map->map_mname);
3529 }
3530 *statp = EX_TEMPFAIL;
3531 switch (save_errno - E_LDAPBASE)
3532 {
3533 # ifdef LDAP_SERVER_DOWN
3534 case LDAP_SERVER_DOWN:
3535 # endif /* LDAP_SERVER_DOWN */
3536 case LDAP_TIMEOUT:
3537 case LDAP_UNAVAILABLE:
3538 /* server disappeared, try reopen on next search */
3539 ldapmap_close(map);
3540 break;
3541 }
3542 errno = save_errno;
3543 return NULL;
3544 }
3545
3546 *statp = EX_NOTFOUND;
3547 vp = NULL;
3548
3549 flags = 0;
3550 if (bitset(MF_SINGLEMATCH, map->map_mflags))
3551 flags |= SM_LDAP_SINGLEMATCH;
3552 if (bitset(MF_MATCHONLY, map->map_mflags))
3553 flags |= SM_LDAP_MATCHONLY;
3554 # if _FFR_LDAP_SINGLEDN
3555 if (bitset(MF_SINGLEDN, map->map_mflags))
3556 flags |= SM_LDAP_SINGLEDN;
3557 # endif /* _FFR_LDAP_SINGLEDN */
3558
3559 /* Create an rpool for search related memory usage */
3560 rpool = sm_rpool_new_x(NULL);
3561
3562 p = NULL;
3563 *statp = sm_ldap_results(lmap, msgid, flags, map->map_coldelim,
3564 rpool, &p, &plen, &psize, NULL);
3565 save_errno = errno;
3566
3567 /* Copy result so rpool can be freed */
3568 if (*statp == EX_OK && p != NULL)
3569 vp = newstr(p);
3570 sm_rpool_free(rpool);
3571
3572 /* need to restart LDAP connection? */
3573 if (*statp == EX_RESTART)
3574 {
3575 *statp = EX_TEMPFAIL;
3576 ldapmap_close(map);
3577 }
3578
3579 errno = save_errno;
3580 if (*statp != EX_OK && *statp != EX_NOTFOUND)
3581 {
3582 if (!bitset(MF_OPTIONAL, map->map_mflags))
3583 {
3584 if (bitset(MF_NODEFER, map->map_mflags))
3585 syserr("Error getting LDAP results in map %s",
3586 map->map_mname);
3587 else
3588 syserr("451 4.3.5 Error getting LDAP results in map %s",
3589 map->map_mname);
3590 }
3591 errno = save_errno;
3592 return NULL;
3593 }
3594
3595 /* Did we match anything? */
3596 if (vp == NULL && !bitset(MF_MATCHONLY, map->map_mflags))
3597 return NULL;
3598
3599 if (*statp == EX_OK)
3600 {
3601 if (LogLevel > 9)
3602 sm_syslog(LOG_INFO, CurEnv->e_id,
3603 "ldap %.100s => %s", name,
3604 vp == NULL ? "<NULL>" : vp);
3605 if (bitset(MF_MATCHONLY, map->map_mflags))
3606 result = map_rewrite(map, name, strlen(name), NULL);
3607 else
3608 {
3609 /* vp != NULL according to test above */
3610 result = map_rewrite(map, vp, strlen(vp), av);
3611 }
3612 if (vp != NULL)
3613 sm_free(vp); /* XXX */
3614 }
3615 return result;
3616 }
3617
3618 /*
3619 ** LDAPMAP_FINDCONN -- find an LDAP connection to the server
3620 **
3621 ** Cache LDAP connections based on the host, port, bind DN,
3622 ** secret, and PID so we don't have multiple connections open to
3623 ** the same server for different maps. Need a separate connection
3624 ** per PID since a parent process may close the map before the
3625 ** child is done with it.
3626 **
3627 ** Parameters:
3628 ** lmap -- LDAP map information
3629 **
3630 ** Returns:
3631 ** Symbol table entry for the LDAP connection.
3632 */
3633
3634 static STAB *
3635 ldapmap_findconn(lmap)
3636 SM_LDAP_STRUCT *lmap;
3637 {
3638 char *format;
3639 char *nbuf;
3640 char *id;
3641 STAB *SM_NONVOLATILE s = NULL;
3642
3643 if (lmap->ldap_host != NULL)
3644 id = lmap->ldap_host;
3645 else if (lmap->ldap_uri != NULL)
3646 id = lmap->ldap_uri;
3647 else
3648 id = "localhost";
3649
3650 format = "%s%c%d%c%d%c%s%c%s%d";
3651 nbuf = sm_stringf_x(format,
3652 id,
3653 CONDELSE,
3654 lmap->ldap_port,
3655 CONDELSE,
3656 lmap->ldap_version,
3657 CONDELSE,
3658 (lmap->ldap_binddn == NULL ? ""
3659 : lmap->ldap_binddn),
3660 CONDELSE,
3661 (lmap->ldap_secret == NULL ? ""
3662 : lmap->ldap_secret),
3663 (int) CurrentPid);
3664 SM_TRY
3665 s = stab(nbuf, ST_LMAP, ST_ENTER);
3666 SM_FINALLY
3667 sm_free(nbuf);
3668 SM_END_TRY
3669 return s;
3670 }
3671 /*
3672 ** LDAPMAP_PARSEARGS -- parse ldap map definition args.
3673 */
3674
3675 static struct lamvalues LDAPAuthMethods[] =
3676 {
3677 { "none", LDAP_AUTH_NONE },
3678 { "simple", LDAP_AUTH_SIMPLE },
3679 # ifdef LDAP_AUTH_KRBV4
3680 { "krbv4", LDAP_AUTH_KRBV4 },
3681 # endif /* LDAP_AUTH_KRBV4 */
3682 { NULL, 0 }
3683 };
3684
3685 static struct ladvalues LDAPAliasDereference[] =
3686 {
3687 { "never", LDAP_DEREF_NEVER },
3688 { "always", LDAP_DEREF_ALWAYS },
3689 { "search", LDAP_DEREF_SEARCHING },
3690 { "find", LDAP_DEREF_FINDING },
3691 { NULL, 0 }
3692 };
3693
3694 static struct lssvalues LDAPSearchScope[] =
3695 {
3696 { "base", LDAP_SCOPE_BASE },
3697 { "one", LDAP_SCOPE_ONELEVEL },
3698 { "sub", LDAP_SCOPE_SUBTREE },
3699 { NULL, 0 }
3700 };
3701
3702 bool
3703 ldapmap_parseargs(map, args)
3704 MAP *map;
3705 char *args;
3706 {
3707 bool secretread = true;
3708 bool attrssetup = false;
3709 int i;
3710 register char *p = args;
3711 SM_LDAP_STRUCT *lmap;
3712 struct lamvalues *lam;
3713 struct ladvalues *lad;
3714 struct lssvalues *lss;
3715 char ldapfilt[MAXLINE];
3716 char m_tmp[MAXPATHLEN + LDAPMAP_MAX_PASSWD];
3717
3718 /* Get ldap struct pointer from map */
3719 lmap = (SM_LDAP_STRUCT *) map->map_db1;
3720
3721 /* Check if setting the initial LDAP defaults */
3722 if (lmap == NULL || lmap != LDAPDefaults)
3723 {
3724 /* We need to alloc an SM_LDAP_STRUCT struct */
3725 lmap = (SM_LDAP_STRUCT *) xalloc(sizeof *lmap);
3726 if (LDAPDefaults == NULL)
3727 sm_ldap_clear(lmap);
3728 else
3729 STRUCTCOPY(*LDAPDefaults, *lmap);
3730 }
3731
3732 /* there is no check whether there is really an argument */
3733 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL;
3734 map->map_spacesub = SpaceSub; /* default value */
3735
3736 /* Check if setting up an alias or file class LDAP map */
3737 if (bitset(MF_ALIAS, map->map_mflags))
3738 {
3739 /* Comma separate if used as an alias file */
3740 map->map_coldelim = ',';
3741 if (*args == '\0')
3742 {
3743 int n;
3744 char *lc;
3745 char jbuf[MAXHOSTNAMELEN];
3746 char lcbuf[MAXLINE];
3747
3748 /* Get $j */
3749 expand("\201j", jbuf, sizeof jbuf, &BlankEnvelope);
3750 if (jbuf[0] == '\0')
3751 {
3752 (void) sm_strlcpy(jbuf, "localhost",
3753 sizeof jbuf);
3754 }
3755
3756 lc = macvalue(macid("{sendmailMTACluster}"), CurEnv);
3757 if (lc == NULL)
3758 lc = "";
3759 else
3760 {
3761 expand(lc, lcbuf, sizeof lcbuf, CurEnv);
3762 lc = lcbuf;
3763 }
3764
3765 n = sm_snprintf(ldapfilt, sizeof ldapfilt,
3766 "(&(objectClass=sendmailMTAAliasObject)(sendmailMTAAliasGrouping=aliases)(|(sendmailMTACluster=%s)(sendmailMTAHost=%s))(sendmailMTAKey=%%0))",
3767 lc, jbuf);
3768 if (n >= sizeof ldapfilt)
3769 {
3770 syserr("%s: Default LDAP string too long",
3771 map->map_mname);
3772 return false;
3773 }
3774
3775 /* default args for an alias LDAP entry */
3776 lmap->ldap_filter = ldapfilt;
3777 lmap->ldap_attr[0] = "objectClass";
3778 lmap->ldap_attr_type[0] = SM_LDAP_ATTR_OBJCLASS;
3779 lmap->ldap_attr_needobjclass[0] = NULL;
3780 lmap->ldap_attr[1] = "sendmailMTAAliasValue";
3781 lmap->ldap_attr_type[1] = SM_LDAP_ATTR_NORMAL;
3782 lmap->ldap_attr_needobjclass[1] = NULL;
3783 lmap->ldap_attr[2] = "sendmailMTAAliasSearch";
3784 lmap->ldap_attr_type[2] = SM_LDAP_ATTR_FILTER;
3785 lmap->ldap_attr_needobjclass[2] = "sendmailMTAMapObject";
3786 lmap->ldap_attr[3] = "sendmailMTAAliasURL";
3787 lmap->ldap_attr_type[3] = SM_LDAP_ATTR_URL;
3788 lmap->ldap_attr_needobjclass[3] = "sendmailMTAMapObject";
3789 lmap->ldap_attr[4] = NULL;
3790 lmap->ldap_attr_type[4] = SM_LDAP_ATTR_NONE;
3791 lmap->ldap_attr_needobjclass[4] = NULL;
3792 attrssetup = true;
3793 }
3794 }
3795 else if (bitset(MF_FILECLASS, map->map_mflags))
3796 {
3797 /* Space separate if used as a file class file */
3798 map->map_coldelim = ' ';
3799 }
3800
3801 for (;;)
3802 {
3803 while (isascii(*p) && isspace(*p))
3804 p++;
3805 if (*p != '-')
3806 break;
3807 switch (*++p)
3808 {
3809 case 'N':
3810 map->map_mflags |= MF_INCLNULL;
3811 map->map_mflags &= ~MF_TRY0NULL;
3812 break;
3813
3814 case 'O':
3815 map->map_mflags &= ~MF_TRY1NULL;
3816 break;
3817
3818 case 'o':
3819 map->map_mflags |= MF_OPTIONAL;
3820 break;
3821
3822 case 'f':
3823 map->map_mflags |= MF_NOFOLDCASE;
3824 break;
3825
3826 case 'm':
3827 map->map_mflags |= MF_MATCHONLY;
3828 break;
3829
3830 case 'A':
3831 map->map_mflags |= MF_APPEND;
3832 break;
3833
3834 case 'q':
3835 map->map_mflags |= MF_KEEPQUOTES;
3836 break;
3837
3838 case 'a':
3839 map->map_app = ++p;
3840 break;
3841
3842 case 'T':
3843 map->map_tapp = ++p;
3844 break;
3845
3846 case 't':
3847 map->map_mflags |= MF_NODEFER;
3848 break;
3849
3850 case 'S':
3851 map->map_spacesub = *++p;
3852 break;
3853
3854 case 'D':
3855 map->map_mflags |= MF_DEFER;
3856 break;
3857
3858 case 'z':
3859 if (*++p != '\\')
3860 map->map_coldelim = *p;
3861 else
3862 {
3863 switch (*++p)
3864 {
3865 case 'n':
3866 map->map_coldelim = '\n';
3867 break;
3868
3869 case 't':
3870 map->map_coldelim = '\t';
3871 break;
3872
3873 default:
3874 map->map_coldelim = '\\';
3875 }
3876 }
3877 break;
3878
3879 /* Start of ldapmap specific args */
3880 case 'V':
3881 if (*++p != '\\')
3882 lmap->ldap_attrsep = *p;
3883 else
3884 {
3885 switch (*++p)
3886 {
3887 case 'n':
3888 lmap->ldap_attrsep = '\n';
3889 break;
3890
3891 case 't':
3892 lmap->ldap_attrsep = '\t';
3893 break;
3894
3895 default:
3896 lmap->ldap_attrsep = '\\';
3897 }
3898 }
3899 break;
3900
3901 case 'k': /* search field */
3902 while (isascii(*++p) && isspace(*p))
3903 continue;
3904 lmap->ldap_filter = p;
3905 break;
3906
3907 case 'v': /* attr to return */
3908 while (isascii(*++p) && isspace(*p))
3909 continue;
3910 lmap->ldap_attr[0] = p;
3911 lmap->ldap_attr[1] = NULL;
3912 break;
3913
3914 case '1':
3915 map->map_mflags |= MF_SINGLEMATCH;
3916 break;
3917
3918 # if _FFR_LDAP_SINGLEDN
3919 case '2':
3920 map->map_mflags |= MF_SINGLEDN;
3921 break;
3922 # endif /* _FFR_LDAP_SINGLEDN */
3923
3924 /* args stolen from ldapsearch.c */
3925 case 'R': /* don't auto chase referrals */
3926 # ifdef LDAP_REFERRALS
3927 lmap->ldap_options &= ~LDAP_OPT_REFERRALS;
3928 # else /* LDAP_REFERRALS */
3929 syserr("compile with -DLDAP_REFERRALS for referral support");
3930 # endif /* LDAP_REFERRALS */
3931 break;
3932
3933 case 'n': /* retrieve attribute names only */
3934 lmap->ldap_attrsonly = LDAPMAP_TRUE;
3935 break;
3936
3937 case 'r': /* alias dereferencing */
3938 while (isascii(*++p) && isspace(*p))
3939 continue;
3940
3941 if (sm_strncasecmp(p, "LDAP_DEREF_", 11) == 0)
3942 p += 11;
3943
3944 for (lad = LDAPAliasDereference;
3945 lad != NULL && lad->lad_name != NULL; lad++)
3946 {
3947 if (sm_strncasecmp(p, lad->lad_name,
3948 strlen(lad->lad_name)) == 0)
3949 break;
3950 }
3951 if (lad->lad_name != NULL)
3952 lmap->ldap_deref = lad->lad_code;
3953 else
3954 {
3955 /* bad config line */
3956 if (!bitset(MCF_OPTFILE,
3957 map->map_class->map_cflags))
3958 {
3959 char *ptr;
3960
3961 if ((ptr = strchr(p, ' ')) != NULL)
3962 *ptr = '\0';
3963 syserr("Deref must be [never|always|search|find] (not %s) in map %s",
3964 p, map->map_mname);
3965 if (ptr != NULL)
3966 *ptr = ' ';
3967 return false;
3968 }
3969 }
3970 break;
3971
3972 case 's': /* search scope */
3973 while (isascii(*++p) && isspace(*p))
3974 continue;
3975
3976 if (sm_strncasecmp(p, "LDAP_SCOPE_", 11) == 0)
3977 p += 11;
3978
3979 for (lss = LDAPSearchScope;
3980 lss != NULL && lss->lss_name != NULL; lss++)
3981 {
3982 if (sm_strncasecmp(p, lss->lss_name,
3983 strlen(lss->lss_name)) == 0)
3984 break;
3985 }
3986 if (lss->lss_name != NULL)
3987 lmap->ldap_scope = lss->lss_code;
3988 else
3989 {
3990 /* bad config line */
3991 if (!bitset(MCF_OPTFILE,
3992 map->map_class->map_cflags))
3993 {
3994 char *ptr;
3995
3996 if ((ptr = strchr(p, ' ')) != NULL)
3997 *ptr = '\0';
3998 syserr("Scope must be [base|one|sub] (not %s) in map %s",
3999 p, map->map_mname);
4000 if (ptr != NULL)
4001 *ptr = ' ';
4002 return false;
4003 }
4004 }
4005 break;
4006
4007 case 'h': /* ldap host */
4008 while (isascii(*++p) && isspace(*p))
4009 continue;
4010 if (lmap->ldap_uri != NULL)
4011 {
4012 syserr("Can not specify both an LDAP host and an LDAP URI in map %s",
4013 map->map_mname);
4014 return false;
4015 }
4016 lmap->ldap_host = p;
4017 break;
4018
4019 case 'b': /* search base */
4020 while (isascii(*++p) && isspace(*p))
4021 continue;
4022 lmap->ldap_base = p;
4023 break;
4024
4025 case 'p': /* ldap port */
4026 while (isascii(*++p) && isspace(*p))
4027 continue;
4028 lmap->ldap_port = atoi(p);
4029 break;
4030
4031 case 'l': /* time limit */
4032 while (isascii(*++p) && isspace(*p))
4033 continue;
4034 lmap->ldap_timelimit = atoi(p);
4035 lmap->ldap_timeout.tv_sec = lmap->ldap_timelimit;
4036 break;
4037
4038 case 'Z':
4039 while (isascii(*++p) && isspace(*p))
4040 continue;
4041 lmap->ldap_sizelimit = atoi(p);
4042 break;
4043
4044 case 'd': /* Dn to bind to server as */
4045 while (isascii(*++p) && isspace(*p))
4046 continue;
4047 lmap->ldap_binddn = p;
4048 break;
4049
4050 case 'M': /* Method for binding */
4051 while (isascii(*++p) && isspace(*p))
4052 continue;
4053
4054 if (sm_strncasecmp(p, "LDAP_AUTH_", 10) == 0)
4055 p += 10;
4056
4057 for (lam = LDAPAuthMethods;
4058 lam != NULL && lam->lam_name != NULL; lam++)
4059 {
4060 if (sm_strncasecmp(p, lam->lam_name,
4061 strlen(lam->lam_name)) == 0)
4062 break;
4063 }
4064 if (lam->lam_name != NULL)
4065 lmap->ldap_method = lam->lam_code;
4066 else
4067 {
4068 /* bad config line */
4069 if (!bitset(MCF_OPTFILE,
4070 map->map_class->map_cflags))
4071 {
4072 char *ptr;
4073
4074 if ((ptr = strchr(p, ' ')) != NULL)
4075 *ptr = '\0';
4076 syserr("Method for binding must be [none|simple|krbv4] (not %s) in map %s",
4077 p, map->map_mname);
4078 if (ptr != NULL)
4079 *ptr = ' ';
4080 return false;
4081 }
4082 }
4083
4084 break;
4085
4086 /*
4087 ** This is a string that is dependent on the
4088 ** method used defined above.
4089 */
4090
4091 case 'P': /* Secret password for binding */
4092 while (isascii(*++p) && isspace(*p))
4093 continue;
4094 lmap->ldap_secret = p;
4095 secretread = false;
4096 break;
4097
4098 case 'H': /* Use LDAP URI */
4099 # if !USE_LDAP_INIT
4100 syserr("Must compile with -DUSE_LDAP_INIT to use LDAP URIs (-H) in map %s",
4101 map->map_mname);
4102 return false;
4103 # else /* !USE_LDAP_INIT */
4104 if (lmap->ldap_host != NULL)
4105 {
4106 syserr("Can not specify both an LDAP host and an LDAP URI in map %s",
4107 map->map_mname);
4108 return false;
4109 }
4110 while (isascii(*++p) && isspace(*p))
4111 continue;
4112 lmap->ldap_uri = p;
4113 break;
4114 # endif /* !USE_LDAP_INIT */
4115
4116 case 'w':
4117 /* -w should be for passwd, -P should be for version */
4118 while (isascii(*++p) && isspace(*p))
4119 continue;
4120 lmap->ldap_version = atoi(p);
4121 # ifdef LDAP_VERSION_MAX
4122 if (lmap->ldap_version > LDAP_VERSION_MAX)
4123 {
4124 syserr("LDAP version %d exceeds max of %d in map %s",
4125 lmap->ldap_version, LDAP_VERSION_MAX,
4126 map->map_mname);
4127 return false;
4128 }
4129 # endif /* LDAP_VERSION_MAX */
4130 # ifdef LDAP_VERSION_MIN
4131 if (lmap->ldap_version < LDAP_VERSION_MIN)
4132 {
4133 syserr("LDAP version %d is lower than min of %d in map %s",
4134 lmap->ldap_version, LDAP_VERSION_MIN,
4135 map->map_mname);
4136 return false;
4137 }
4138 # endif /* LDAP_VERSION_MIN */
4139 break;
4140
4141 default:
4142 syserr("Illegal option %c map %s", *p, map->map_mname);
4143 break;
4144 }
4145
4146 /* need to account for quoted strings here */
4147 while (*p != '\0' && !(isascii(*p) && isspace(*p)))
4148 {
4149 if (*p == '"')
4150 {
4151 while (*++p != '"' && *p != '\0')
4152 continue;
4153 if (*p != '\0')
4154 p++;
4155 }
4156 else
4157 p++;
4158 }
4159
4160 if (*p != '\0')
4161 *p++ = '\0';
4162 }
4163
4164 if (map->map_app != NULL)
4165 map->map_app = newstr(ldapmap_dequote(map->map_app));
4166 if (map->map_tapp != NULL)
4167 map->map_tapp = newstr(ldapmap_dequote(map->map_tapp));
4168
4169 /*
4170 ** We need to swallow up all the stuff into a struct
4171 ** and dump it into map->map_dbptr1
4172 */
4173
4174 if (lmap->ldap_host != NULL &&
4175 (LDAPDefaults == NULL ||
4176 LDAPDefaults == lmap ||
4177 LDAPDefaults->ldap_host != lmap->ldap_host))
4178 lmap->ldap_host = newstr(ldapmap_dequote(lmap->ldap_host));
4179 map->map_domain = lmap->ldap_host;
4180
4181 if (lmap->ldap_uri != NULL &&
4182 (LDAPDefaults == NULL ||
4183 LDAPDefaults == lmap ||
4184 LDAPDefaults->ldap_uri != lmap->ldap_uri))
4185 lmap->ldap_uri = newstr(ldapmap_dequote(lmap->ldap_uri));
4186 map->map_domain = lmap->ldap_uri;
4187
4188 if (lmap->ldap_binddn != NULL &&
4189 (LDAPDefaults == NULL ||
4190 LDAPDefaults == lmap ||
4191 LDAPDefaults->ldap_binddn != lmap->ldap_binddn))
4192 lmap->ldap_binddn = newstr(ldapmap_dequote(lmap->ldap_binddn));
4193
4194 if (lmap->ldap_secret != NULL &&
4195 (LDAPDefaults == NULL ||
4196 LDAPDefaults == lmap ||
4197 LDAPDefaults->ldap_secret != lmap->ldap_secret))
4198 {
4199 SM_FILE_T *sfd;
4200 long sff = SFF_OPENASROOT|SFF_ROOTOK|SFF_NOWLINK|SFF_NOWWFILES|SFF_NOGWFILES;
4201
4202 if (DontLockReadFiles)
4203 sff |= SFF_NOLOCK;
4204
4205 /* need to use method to map secret to passwd string */
4206 switch (lmap->ldap_method)
4207 {
4208 case LDAP_AUTH_NONE:
4209 /* Do nothing */
4210 break;
4211
4212 case LDAP_AUTH_SIMPLE:
4213
4214 /*
4215 ** Secret is the name of a file with
4216 ** the first line as the password.
4217 */
4218
4219 /* Already read in the secret? */
4220 if (secretread)
4221 break;
4222
4223 sfd = safefopen(ldapmap_dequote(lmap->ldap_secret),
4224 O_RDONLY, 0, sff);
4225 if (sfd == NULL)
4226 {
4227 syserr("LDAP map: cannot open secret %s",
4228 ldapmap_dequote(lmap->ldap_secret));
4229 return false;
4230 }
4231 lmap->ldap_secret = sfgets(m_tmp, sizeof m_tmp,
4232 sfd, TimeOuts.to_fileopen,
4233 "ldapmap_parseargs");
4234 (void) sm_io_close(sfd, SM_TIME_DEFAULT);
4235 if (strlen(m_tmp) > LDAPMAP_MAX_PASSWD)
4236 {
4237 syserr("LDAP map: secret in %s too long",
4238 ldapmap_dequote(lmap->ldap_secret));
4239 return false;
4240 }
4241 if (lmap->ldap_secret != NULL &&
4242 strlen(m_tmp) > 0)
4243 {
4244 /* chomp newline */
4245 if (m_tmp[strlen(m_tmp) - 1] == '\n')
4246 m_tmp[strlen(m_tmp) - 1] = '\0';
4247
4248 lmap->ldap_secret = m_tmp;
4249 }
4250 break;
4251
4252 # ifdef LDAP_AUTH_KRBV4
4253 case LDAP_AUTH_KRBV4:
4254
4255 /*
4256 ** Secret is where the ticket file is
4257 ** stashed
4258 */
4259
4260 (void) sm_snprintf(m_tmp, sizeof m_tmp,
4261 "KRBTKFILE=%s",
4262 ldapmap_dequote(lmap->ldap_secret));
4263 lmap->ldap_secret = m_tmp;
4264 break;
4265 # endif /* LDAP_AUTH_KRBV4 */
4266
4267 default: /* Should NEVER get here */
4268 syserr("LDAP map: Illegal value in lmap method");
4269 return false;
4270 /* NOTREACHED */
4271 break;
4272 }
4273 }
4274
4275 if (lmap->ldap_secret != NULL &&
4276 (LDAPDefaults == NULL ||
4277 LDAPDefaults == lmap ||
4278 LDAPDefaults->ldap_secret != lmap->ldap_secret))
4279 lmap->ldap_secret = newstr(ldapmap_dequote(lmap->ldap_secret));
4280
4281 if (lmap->ldap_base != NULL &&
4282 (LDAPDefaults == NULL ||
4283 LDAPDefaults == lmap ||
4284 LDAPDefaults->ldap_base != lmap->ldap_base))
4285 lmap->ldap_base = newstr(ldapmap_dequote(lmap->ldap_base));
4286
4287 /*
4288 ** Save the server from extra work. If request is for a single
4289 ** match, tell the server to only return enough records to
4290 ** determine if there is a single match or not. This can not
4291 ** be one since the server would only return one and we wouldn't
4292 ** know if there were others available.
4293 */
4294
4295 if (bitset(MF_SINGLEMATCH, map->map_mflags))
4296 lmap->ldap_sizelimit = 2;
4297
4298 /* If setting defaults, don't process ldap_filter and ldap_attr */
4299 if (lmap == LDAPDefaults)
4300 return true;
4301
4302 if (lmap->ldap_filter != NULL)
4303 lmap->ldap_filter = newstr(ldapmap_dequote(lmap->ldap_filter));
4304 else
4305 {
4306 if (!bitset(MCF_OPTFILE, map->map_class->map_cflags))
4307 {
4308 syserr("No filter given in map %s", map->map_mname);
4309 return false;
4310 }
4311 }
4312
4313 if (!attrssetup && lmap->ldap_attr[0] != NULL)
4314 {
4315 bool recurse = false;
4316 bool normalseen = false;
4317
4318 i = 0;
4319 p = ldapmap_dequote(lmap->ldap_attr[0]);
4320 lmap->ldap_attr[0] = NULL;
4321
4322 /* Prime the attr list with the objectClass attribute */
4323 lmap->ldap_attr[i] = "objectClass";
4324 lmap->ldap_attr_type[i] = SM_LDAP_ATTR_OBJCLASS;
4325 lmap->ldap_attr_needobjclass[i] = NULL;
4326 i++;
4327
4328 while (p != NULL)
4329 {
4330 char *v;
4331
4332 while (isascii(*p) && isspace(*p))
4333 p++;
4334 if (*p == '\0')
4335 break;
4336 v = p;
4337 p = strchr(v, ',');
4338 if (p != NULL)
4339 *p++ = '\0';
4340
4341 if (i >= LDAPMAP_MAX_ATTR)
4342 {
4343 syserr("Too many return attributes in %s (max %d)",
4344 map->map_mname, LDAPMAP_MAX_ATTR);
4345 return false;
4346 }
4347 if (*v != '\0')
4348 {
4349 int j;
4350 int use;
4351 char *type;
4352 char *needobjclass;
4353
4354 type = strchr(v, ':');
4355 if (type != NULL)
4356 {
4357 *type++ = '\0';
4358 needobjclass = strchr(type, ':');
4359 if (needobjclass != NULL)
4360 *needobjclass++ = '\0';
4361 }
4362 else
4363 {
4364 needobjclass = NULL;
4365 }
4366
4367 use = i;
4368
4369 /* allow override on "objectClass" type */
4370 if (sm_strcasecmp(v, "objectClass") == 0 &&
4371 lmap->ldap_attr_type[0] == SM_LDAP_ATTR_OBJCLASS)
4372 {
4373 use = 0;
4374 }
4375 else
4376 {
4377 /*
4378 ** Don't add something to attribute
4379 ** list twice.
4380 */
4381
4382 for (j = 1; j < i; j++)
4383 {
4384 if (sm_strcasecmp(v, lmap->ldap_attr[j]) == 0)
4385 {
4386 syserr("Duplicate attribute (%s) in %s",
4387 v, map->map_mname);
4388 return false;
4389 }
4390 }
4391
4392 lmap->ldap_attr[use] = newstr(v);
4393 if (needobjclass != NULL &&
4394 *needobjclass != '\0' &&
4395 *needobjclass != '*')
4396 {
4397 lmap->ldap_attr_needobjclass[use] = newstr(needobjclass);
4398 }
4399 else
4400 {
4401 lmap->ldap_attr_needobjclass[use] = NULL;
4402 }
4403
4404 }
4405
4406 if (type != NULL && *type != '\0')
4407 {
4408 if (sm_strcasecmp(type, "dn") == 0)
4409 {
4410 recurse = true;
4411 lmap->ldap_attr_type[use] = SM_LDAP_ATTR_DN;
4412 }
4413 else if (sm_strcasecmp(type, "filter") == 0)
4414 {
4415 recurse = true;
4416 lmap->ldap_attr_type[use] = SM_LDAP_ATTR_FILTER;
4417 }
4418 else if (sm_strcasecmp(type, "url") == 0)
4419 {
4420 recurse = true;
4421 lmap->ldap_attr_type[use] = SM_LDAP_ATTR_URL;
4422 }
4423 else if (sm_strcasecmp(type, "normal") == 0)
4424 {
4425 lmap->ldap_attr_type[use] = SM_LDAP_ATTR_NORMAL;
4426 normalseen = true;
4427 }
4428 else
4429 {
4430 syserr("Unknown attribute type (%s) in %s",
4431 type, map->map_mname);
4432 return false;
4433 }
4434 }
4435 else
4436 {
4437 lmap->ldap_attr_type[use] = SM_LDAP_ATTR_NORMAL;
4438 normalseen = true;
4439 }
4440 i++;
4441 }
4442 }
4443 lmap->ldap_attr[i] = NULL;
4444
4445 /* Set in case needed in future code */
4446 attrssetup = true;
4447
4448 if (recurse && !normalseen)
4449 {
4450 syserr("LDAP recursion requested in %s but no returnable attribute given",
4451 map->map_mname);
4452 return false;
4453 }
4454 if (recurse && lmap->ldap_attrsonly == LDAPMAP_TRUE)
4455 {
4456 syserr("LDAP recursion requested in %s can not be used with -n",
4457 map->map_mname);
4458 return false;
4459 }
4460 }
4461 map->map_db1 = (ARBPTR_T) lmap;
4462 return true;
4463 }
4464
4465 /*
4466 ** LDAPMAP_SET_DEFAULTS -- Read default map spec from LDAPDefaults in .cf
4467 **
4468 ** Parameters:
4469 ** spec -- map argument string from LDAPDefaults option
4470 **
4471 ** Returns:
4472 ** None.
4473 */
4474
4475 void
4476 ldapmap_set_defaults(spec)
4477 char *spec;
4478 {
4479 STAB *class;
4480 MAP map;
4481
4482 /* Allocate and set the default values */
4483 if (LDAPDefaults == NULL)
4484 LDAPDefaults = (SM_LDAP_STRUCT *) xalloc(sizeof *LDAPDefaults);
4485 sm_ldap_clear(LDAPDefaults);
4486
4487 memset(&map, '\0', sizeof map);
4488
4489 /* look up the class */
4490 class = stab("ldap", ST_MAPCLASS, ST_FIND);
4491 if (class == NULL)
4492 {
4493 syserr("readcf: LDAPDefaultSpec: class ldap not available");
4494 return;
4495 }
4496 map.map_class = &class->s_mapclass;
4497 map.map_db1 = (ARBPTR_T) LDAPDefaults;
4498 map.map_mname = "O LDAPDefaultSpec";
4499
4500 (void) ldapmap_parseargs(&map, spec);
4501
4502 /* These should never be set in LDAPDefaults */
4503 if (map.map_mflags != (MF_TRY0NULL|MF_TRY1NULL) ||
4504 map.map_spacesub != SpaceSub ||
4505 map.map_app != NULL ||
4506 map.map_tapp != NULL)
4507 {
4508 syserr("readcf: option LDAPDefaultSpec: Do not set non-LDAP specific flags");
4509 SM_FREE_CLR(map.map_app);
4510 SM_FREE_CLR(map.map_tapp);
4511 }
4512
4513 if (LDAPDefaults->ldap_filter != NULL)
4514 {
4515 syserr("readcf: option LDAPDefaultSpec: Do not set the LDAP search filter");
4516
4517 /* don't free, it isn't malloc'ed in parseargs */
4518 LDAPDefaults->ldap_filter = NULL;
4519 }
4520
4521 if (LDAPDefaults->ldap_attr[0] != NULL)
4522 {
4523 syserr("readcf: option LDAPDefaultSpec: Do not set the requested LDAP attributes");
4524 /* don't free, they aren't malloc'ed in parseargs */
4525 LDAPDefaults->ldap_attr[0] = NULL;
4526 }
4527 }
4528 #endif /* LDAPMAP */
4529 /*
4530 ** PH map
4531 */
4532
4533 #if PH_MAP
4534
4535 /*
4536 ** Support for the CCSO Nameserver (ph/qi).
4537 ** This code is intended to replace the so-called "ph mailer".
4538 ** Contributed by Mark D. Roth <roth@uiuc.edu>. Contact him for support.
4539 */
4540
4541 /* what version of the ph map code we're running */
4542 static char phmap_id[128];
4543
4544 /* sendmail version for phmap id string */
4545 extern const char Version[];
4546
4547 /* assume we're using nph-1.2.x if not specified */
4548 # ifndef NPH_VERSION
4549 # define NPH_VERSION 10200
4550 # endif
4551
4552 /* compatibility for versions older than nph-1.2.0 */
4553 # if NPH_VERSION < 10200
4554 # define PH_OPEN_ROUNDROBIN PH_ROUNDROBIN
4555 # define PH_OPEN_DONTID PH_DONTID
4556 # define PH_CLOSE_FAST PH_FASTCLOSE
4557 # define PH_ERR_DATAERR PH_DATAERR
4558 # define PH_ERR_NOMATCH PH_NOMATCH
4559 # endif /* NPH_VERSION < 10200 */
4560
4561 /*
4562 ** PH_MAP_PARSEARGS -- parse ph map definition args.
4563 */
4564
4565 bool
4566 ph_map_parseargs(map, args)
4567 MAP *map;
4568 char *args;
4569 {
4570 register bool done;
4571 register char *p = args;
4572 PH_MAP_STRUCT *pmap = NULL;
4573
4574 /* initialize version string */
4575 (void) sm_snprintf(phmap_id, sizeof phmap_id,
4576 "sendmail-%s phmap-20010529 libphclient-%s",
4577 Version, libphclient_version);
4578
4579 pmap = (PH_MAP_STRUCT *) xalloc(sizeof *pmap);
4580
4581 /* defaults */
4582 pmap->ph_servers = NULL;
4583 pmap->ph_field_list = NULL;
4584 pmap->ph = NULL;
4585 pmap->ph_timeout = 0;
4586 pmap->ph_fastclose = 0;
4587
4588 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL;
4589 for (;;)
4590 {
4591 while (isascii(*p) && isspace(*p))
4592 p++;
4593 if (*p != '-')
4594 break;
4595 switch (*++p)
4596 {
4597 case 'N':
4598 map->map_mflags |= MF_INCLNULL;
4599 map->map_mflags &= ~MF_TRY0NULL;
4600 break;
4601
4602 case 'O':
4603 map->map_mflags &= ~MF_TRY1NULL;
4604 break;
4605
4606 case 'o':
4607 map->map_mflags |= MF_OPTIONAL;
4608 break;
4609
4610 case 'f':
4611 map->map_mflags |= MF_NOFOLDCASE;
4612 break;
4613
4614 case 'm':
4615 map->map_mflags |= MF_MATCHONLY;
4616 break;
4617
4618 case 'A':
4619 map->map_mflags |= MF_APPEND;
4620 break;
4621
4622 case 'q':
4623 map->map_mflags |= MF_KEEPQUOTES;
4624 break;
4625
4626 case 't':
4627 map->map_mflags |= MF_NODEFER;
4628 break;
4629
4630 case 'a':
4631 map->map_app = ++p;
4632 break;
4633
4634 case 'T':
4635 map->map_tapp = ++p;
4636 break;
4637
4638 case 'l':
4639 while (isascii(*++p) && isspace(*p))
4640 continue;
4641 pmap->ph_timeout = atoi(p);
4642 break;
4643
4644 case 'S':
4645 map->map_spacesub = *++p;
4646 break;
4647
4648 case 'D':
4649 map->map_mflags |= MF_DEFER;
4650 break;
4651
4652 case 'h': /* PH server list */
4653 while (isascii(*++p) && isspace(*p))
4654 continue;
4655 pmap->ph_servers = p;
4656 break;
4657
4658 case 'k': /* fields to search for */
4659 while (isascii(*++p) && isspace(*p))
4660 continue;
4661 pmap->ph_field_list = p;
4662 break;
4663
4664 default:
4665 syserr("ph_map_parseargs: unknown option -%c", *p);
4666 }
4667
4668 /* try to account for quoted strings */
4669 done = isascii(*p) && isspace(*p);
4670 while (*p != '\0' && !done)
4671 {
4672 if (*p == '"')
4673 {
4674 while (*++p != '"' && *p != '\0')
4675 continue;
4676 if (*p != '\0')
4677 p++;
4678 }
4679 else
4680 p++;
4681 done = isascii(*p) && isspace(*p);
4682 }
4683
4684 if (*p != '\0')
4685 *p++ = '\0';
4686 }
4687
4688 if (map->map_app != NULL)
4689 map->map_app = newstr(ph_map_dequote(map->map_app));
4690 if (map->map_tapp != NULL)
4691 map->map_tapp = newstr(ph_map_dequote(map->map_tapp));
4692
4693 if (pmap->ph_field_list != NULL)
4694 pmap->ph_field_list = newstr(ph_map_dequote(pmap->ph_field_list));
4695
4696 if (pmap->ph_servers != NULL)
4697 pmap->ph_servers = newstr(ph_map_dequote(pmap->ph_servers));
4698 else
4699 {
4700 syserr("ph_map_parseargs: -h flag is required");
4701 return false;
4702 }
4703
4704 map->map_db1 = (ARBPTR_T) pmap;
4705 return true;
4706 }
4707
4708 /*
4709 ** PH_MAP_CLOSE -- close the connection to the ph server
4710 */
4711
4712 void
4713 ph_map_close(map)
4714 MAP *map;
4715 {
4716 PH_MAP_STRUCT *pmap;
4717
4718 pmap = (PH_MAP_STRUCT *)map->map_db1;
4719 if (tTd(38, 9))
4720 sm_dprintf("ph_map_close(%s): pmap->ph_fastclose=%d\n",
4721 map->map_mname, pmap->ph_fastclose);
4722
4723
4724 if (pmap->ph != NULL)
4725 {
4726 ph_set_sendhook(pmap->ph, NULL);
4727 ph_set_recvhook(pmap->ph, NULL);
4728 ph_close(pmap->ph, pmap->ph_fastclose);
4729 }
4730
4731 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE);
4732 }
4733
4734 static jmp_buf PHTimeout;
4735
4736 /* ARGSUSED */
4737 static void
4738 ph_timeout(unused)
4739 int unused;
4740 {
4741 /*
4742 ** NOTE: THIS CAN BE CALLED FROM A SIGNAL HANDLER. DO NOT ADD
4743 ** ANYTHING TO THIS ROUTINE UNLESS YOU KNOW WHAT YOU ARE
4744 ** DOING.
4745 */
4746
4747 errno = ETIMEDOUT;
4748 longjmp(PHTimeout, 1);
4749 }
4750
4751 static void
4752 #if NPH_VERSION >= 10200
4753 ph_map_send_debug(appdata, text)
4754 void *appdata;
4755 #else
4756 ph_map_send_debug(text)
4757 #endif
4758 char *text;
4759 {
4760 if (LogLevel > 9)
4761 sm_syslog(LOG_NOTICE, CurEnv->e_id,
4762 "ph_map_send_debug: ==> %s", text);
4763 if (tTd(38, 20))
4764 sm_dprintf("ph_map_send_debug: ==> %s\n", text);
4765 }
4766
4767 static void
4768 #if NPH_VERSION >= 10200
4769 ph_map_recv_debug(appdata, text)
4770 void *appdata;
4771 #else
4772 ph_map_recv_debug(text)
4773 #endif
4774 char *text;
4775 {
4776 if (LogLevel > 10)
4777 sm_syslog(LOG_NOTICE, CurEnv->e_id,
4778 "ph_map_recv_debug: <== %s", text);
4779 if (tTd(38, 21))
4780 sm_dprintf("ph_map_recv_debug: <== %s\n", text);
4781 }
4782
4783 /*
4784 ** PH_MAP_OPEN -- sub for opening PH map
4785 */
4786 bool
4787 ph_map_open(map, mode)
4788 MAP *map;
4789 int mode;
4790 {
4791 PH_MAP_STRUCT *pmap;
4792 register SM_EVENT *ev = NULL;
4793 int save_errno = 0;
4794 char *hostlist, *host;
4795
4796 if (tTd(38, 2))
4797 sm_dprintf("ph_map_open(%s)\n", map->map_mname);
4798
4799 mode &= O_ACCMODE;
4800 if (mode != O_RDONLY)
4801 {
4802 /* issue a pseudo-error message */
4803 errno = SM_EMAPCANTWRITE;
4804 return false;
4805 }
4806
4807 if (CurEnv != NULL && CurEnv->e_sendmode == SM_DEFER &&
4808 bitset(MF_DEFER, map->map_mflags))
4809 {
4810 if (tTd(9, 1))
4811 sm_dprintf("ph_map_open(%s) => DEFERRED\n",
4812 map->map_mname);
4813
4814 /*
4815 ** Unset MF_DEFER here so that map_lookup() returns
4816 ** a temporary failure using the bogus map and
4817 ** map->map_tapp instead of the default permanent error.
4818 */
4819
4820 map->map_mflags &= ~MF_DEFER;
4821 return false;
4822 }
4823
4824 pmap = (PH_MAP_STRUCT *)map->map_db1;
4825 pmap->ph_fastclose = 0; /* refresh field for reopen */
4826
4827 /* try each host in the list */
4828 hostlist = newstr(pmap->ph_servers);
4829 for (host = strtok(hostlist, " ");
4830 host != NULL;
4831 host = strtok(NULL, " "))
4832 {
4833 /* set timeout */
4834 if (pmap->ph_timeout != 0)
4835 {
4836 if (setjmp(PHTimeout) != 0)
4837 {
4838 ev = NULL;
4839 if (LogLevel > 1)
4840 sm_syslog(LOG_NOTICE, CurEnv->e_id,
4841 "timeout connecting to PH server %.100s",
4842 host);
4843 errno = ETIMEDOUT;
4844 goto ph_map_open_abort;
4845 }
4846 ev = sm_setevent(pmap->ph_timeout, ph_timeout, 0);
4847 }
4848
4849 /* open connection to server */
4850 if (ph_open(&(pmap->ph), host,
4851 PH_OPEN_ROUNDROBIN|PH_OPEN_DONTID,
4852 ph_map_send_debug, ph_map_recv_debug
4853 #if NPH_VERSION >= 10200
4854 , NULL
4855 #endif
4856 ) == 0
4857 && ph_id(pmap->ph, phmap_id) == 0)
4858 {
4859 if (ev != NULL)
4860 sm_clrevent(ev);
4861 sm_free(hostlist); /* XXX */
4862 return true;
4863 }
4864
4865 ph_map_open_abort:
4866 save_errno = errno;
4867 if (ev != NULL)
4868 sm_clrevent(ev);
4869 pmap->ph_fastclose = PH_CLOSE_FAST;
4870 ph_map_close(map);
4871 errno = save_errno;
4872 }
4873
4874 if (bitset(MF_NODEFER, map->map_mflags))
4875 {
4876 if (errno == 0)
4877 errno = EAGAIN;
4878 syserr("ph_map_open: %s: cannot connect to PH server",
4879 map->map_mname);
4880 }
4881 else if (!bitset(MF_OPTIONAL, map->map_mflags) && LogLevel > 1)
4882 sm_syslog(LOG_NOTICE, CurEnv->e_id,
4883 "ph_map_open: %s: cannot connect to PH server",
4884 map->map_mname);
4885 sm_free(hostlist); /* XXX */
4886 return false;
4887 }
4888
4889 /*
4890 ** PH_MAP_LOOKUP -- look up key from ph server
4891 */
4892
4893 char *
4894 ph_map_lookup(map, key, args, pstat)
4895 MAP *map;
4896 char *key;
4897 char **args;
4898 int *pstat;
4899 {
4900 int i, save_errno = 0;
4901 register SM_EVENT *ev = NULL;
4902 PH_MAP_STRUCT *pmap;
4903 char *value = NULL;
4904
4905 pmap = (PH_MAP_STRUCT *)map->map_db1;
4906
4907 *pstat = EX_OK;
4908
4909 /* set timeout */
4910 if (pmap->ph_timeout != 0)
4911 {
4912 if (setjmp(PHTimeout) != 0)
4913 {
4914 ev = NULL;
4915 if (LogLevel > 1)
4916 sm_syslog(LOG_NOTICE, CurEnv->e_id,
4917 "timeout during PH lookup of %.100s",
4918 key);
4919 errno = ETIMEDOUT;
4920 *pstat = EX_TEMPFAIL;
4921 goto ph_map_lookup_abort;
4922 }
4923 ev = sm_setevent(pmap->ph_timeout, ph_timeout, 0);
4924 }
4925
4926 /* perform lookup */
4927 i = ph_email_resolve(pmap->ph, key, pmap->ph_field_list, &value);
4928 if (i == -1)
4929 *pstat = EX_TEMPFAIL;
4930 else if (i == PH_ERR_NOMATCH || i == PH_ERR_DATAERR)
4931 *pstat = EX_UNAVAILABLE;
4932
4933 ph_map_lookup_abort:
4934 if (ev != NULL)
4935 sm_clrevent(ev);
4936
4937 /*
4938 ** Close the connection if the timer popped
4939 ** or we got a temporary PH error
4940 */
4941
4942 if (*pstat == EX_TEMPFAIL)
4943 {
4944 save_errno = errno;
4945 pmap->ph_fastclose = PH_CLOSE_FAST;
4946 ph_map_close(map);
4947 errno = save_errno;
4948 }
4949
4950 if (*pstat == EX_OK)
4951 {
4952 if (tTd(38,20))
4953 sm_dprintf("ph_map_lookup: %s => %s\n", key, value);
4954
4955 if (bitset(MF_MATCHONLY, map->map_mflags))
4956 return map_rewrite(map, key, strlen(key), NULL);
4957 else
4958 return map_rewrite(map, value, strlen(value), args);
4959 }
4960
4961 return NULL;
4962 }
4963 #endif /* PH_MAP */
4964 /*
4965 ** syslog map
4966 */
4967
4968 #define map_prio map_lockfd /* overload field */
4969
4970 /*
4971 ** SYSLOG_MAP_PARSEARGS -- check for priority level to syslog messages.
4972 */
4973
4974 bool
4975 syslog_map_parseargs(map, args)
4976 MAP *map;
4977 char *args;
4978 {
4979 char *p = args;
4980 char *priority = NULL;
4981
4982 /* there is no check whether there is really an argument */
4983 while (*p != '\0')
4984 {
4985 while (isascii(*p) && isspace(*p))
4986 p++;
4987 if (*p != '-')
4988 break;
4989 ++p;
4990 if (*p == 'D')
4991 {
4992 map->map_mflags |= MF_DEFER;
4993 ++p;
4994 }
4995 else if (*p == 'S')
4996 {
4997 map->map_spacesub = *++p;
4998 if (*p != '\0')
4999 p++;
5000 }
5001 else if (*p == 'L')
5002 {
5003 while (*++p != '\0' && isascii(*p) && isspace(*p))
5004 continue;
5005 if (*p == '\0')
5006 break;
5007 priority = p;
5008 while (*p != '\0' && !(isascii(*p) && isspace(*p)))
5009 p++;
5010 if (*p != '\0')
5011 *p++ = '\0';
5012 }
5013 else
5014 {
5015 syserr("Illegal option %c map syslog", *p);
5016 ++p;
5017 }
5018 }
5019
5020 if (priority == NULL)
5021 map->map_prio = LOG_INFO;
5022 else
5023 {
5024 if (sm_strncasecmp("LOG_", priority, 4) == 0)
5025 priority += 4;
5026
5027 #ifdef LOG_EMERG
5028 if (sm_strcasecmp("EMERG", priority) == 0)
5029 map->map_prio = LOG_EMERG;
5030 else
5031 #endif /* LOG_EMERG */
5032 #ifdef LOG_ALERT
5033 if (sm_strcasecmp("ALERT", priority) == 0)
5034 map->map_prio = LOG_ALERT;
5035 else
5036 #endif /* LOG_ALERT */
5037 #ifdef LOG_CRIT
5038 if (sm_strcasecmp("CRIT", priority) == 0)
5039 map->map_prio = LOG_CRIT;
5040 else
5041 #endif /* LOG_CRIT */
5042 #ifdef LOG_ERR
5043 if (sm_strcasecmp("ERR", priority) == 0)
5044 map->map_prio = LOG_ERR;
5045 else
5046 #endif /* LOG_ERR */
5047 #ifdef LOG_WARNING
5048 if (sm_strcasecmp("WARNING", priority) == 0)
5049 map->map_prio = LOG_WARNING;
5050 else
5051 #endif /* LOG_WARNING */
5052 #ifdef LOG_NOTICE
5053 if (sm_strcasecmp("NOTICE", priority) == 0)
5054 map->map_prio = LOG_NOTICE;
5055 else
5056 #endif /* LOG_NOTICE */
5057 #ifdef LOG_INFO
5058 if (sm_strcasecmp("INFO", priority) == 0)
5059 map->map_prio = LOG_INFO;
5060 else
5061 #endif /* LOG_INFO */
5062 #ifdef LOG_DEBUG
5063 if (sm_strcasecmp("DEBUG", priority) == 0)
5064 map->map_prio = LOG_DEBUG;
5065 else
5066 #endif /* LOG_DEBUG */
5067 {
5068 syserr("syslog_map_parseargs: Unknown priority %s",
5069 priority);
5070 return false;
5071 }
5072 }
5073 return true;
5074 }
5075
5076 /*
5077 ** SYSLOG_MAP_LOOKUP -- rewrite and syslog message. Always return empty string
5078 */
5079
5080 char *
5081 syslog_map_lookup(map, string, args, statp)
5082 MAP *map;
5083 char *string;
5084 char **args;
5085 int *statp;
5086 {
5087 char *ptr = map_rewrite(map, string, strlen(string), args);
5088
5089 if (ptr != NULL)
5090 {
5091 if (tTd(38, 20))
5092 sm_dprintf("syslog_map_lookup(%s (priority %d): %s\n",
5093 map->map_mname, map->map_prio, ptr);
5094
5095 sm_syslog(map->map_prio, CurEnv->e_id, "%s", ptr);
5096 }
5097
5098 *statp = EX_OK;
5099 return "";
5100 }
5101
5102 /*
5103 ** HESIOD Modules
5104 */
5105
5106 #if HESIOD
5107
5108 bool
5109 hes_map_open(map, mode)
5110 MAP *map;
5111 int mode;
5112 {
5113 if (tTd(38, 2))
5114 sm_dprintf("hes_map_open(%s, %s, %d)\n",
5115 map->map_mname, map->map_file, mode);
5116
5117 if (mode != O_RDONLY)
5118 {
5119 /* issue a pseudo-error message */
5120 errno = SM_EMAPCANTWRITE;
5121 return false;
5122 }
5123
5124 # ifdef HESIOD_INIT
5125 if (HesiodContext != NULL || hesiod_init(&HesiodContext) == 0)
5126 return true;
5127
5128 if (!bitset(MF_OPTIONAL, map->map_mflags))
5129 syserr("451 4.3.5 cannot initialize Hesiod map (%s)",
5130 sm_errstring(errno));
5131 return false;
5132 # else /* HESIOD_INIT */
5133 if (hes_error() == HES_ER_UNINIT)
5134 hes_init();
5135 switch (hes_error())
5136 {
5137 case HES_ER_OK:
5138 case HES_ER_NOTFOUND:
5139 return true;
5140 }
5141
5142 if (!bitset(MF_OPTIONAL, map->map_mflags))
5143 syserr("451 4.3.5 cannot initialize Hesiod map (%d)", hes_error());
5144
5145 return false;
5146 # endif /* HESIOD_INIT */
5147 }
5148
5149 char *
5150 hes_map_lookup(map, name, av, statp)
5151 MAP *map;
5152 char *name;
5153 char **av;
5154 int *statp;
5155 {
5156 char **hp;
5157
5158 if (tTd(38, 20))
5159 sm_dprintf("hes_map_lookup(%s, %s)\n", map->map_file, name);
5160
5161 if (name[0] == '\\')
5162 {
5163 char *np;
5164 int nl;
5165 int save_errno;
5166 char nbuf[MAXNAME];
5167
5168 nl = strlen(name);
5169 if (nl < sizeof nbuf - 1)
5170 np = nbuf;
5171 else
5172 np = xalloc(strlen(name) + 2);
5173 np[0] = '\\';
5174 (void) sm_strlcpy(&np[1], name, (sizeof nbuf) - 1);
5175 # ifdef HESIOD_INIT
5176 hp = hesiod_resolve(HesiodContext, np, map->map_file);
5177 # else /* HESIOD_INIT */
5178 hp = hes_resolve(np, map->map_file);
5179 # endif /* HESIOD_INIT */
5180 save_errno = errno;
5181 if (np != nbuf)
5182 sm_free(np); /* XXX */
5183 errno = save_errno;
5184 }
5185 else
5186 {
5187 # ifdef HESIOD_INIT
5188 hp = hesiod_resolve(HesiodContext, name, map->map_file);
5189 # else /* HESIOD_INIT */
5190 hp = hes_resolve(name, map->map_file);
5191 # endif /* HESIOD_INIT */
5192 }
5193 # ifdef HESIOD_INIT
5194 if (hp == NULL || *hp == NULL)
5195 {
5196 switch (errno)
5197 {
5198 case ENOENT:
5199 *statp = EX_NOTFOUND;
5200 break;
5201 case ECONNREFUSED:
5202 *statp = EX_TEMPFAIL;
5203 break;
5204 case EMSGSIZE:
5205 case ENOMEM:
5206 default:
5207 *statp = EX_UNAVAILABLE;
5208 break;
5209 }
5210 if (hp != NULL)
5211 hesiod_free_list(HesiodContext, hp);
5212 return NULL;
5213 }
5214 # else /* HESIOD_INIT */
5215 if (hp == NULL || hp[0] == NULL)
5216 {
5217 switch (hes_error())
5218 {
5219 case HES_ER_OK:
5220 *statp = EX_OK;
5221 break;
5222
5223 case HES_ER_NOTFOUND:
5224 *statp = EX_NOTFOUND;
5225 break;
5226
5227 case HES_ER_CONFIG:
5228 *statp = EX_UNAVAILABLE;
5229 break;
5230
5231 case HES_ER_NET:
5232 *statp = EX_TEMPFAIL;
5233 break;
5234 }
5235 return NULL;
5236 }
5237 # endif /* HESIOD_INIT */
5238
5239 if (bitset(MF_MATCHONLY, map->map_mflags))
5240 return map_rewrite(map, name, strlen(name), NULL);
5241 else
5242 return map_rewrite(map, hp[0], strlen(hp[0]), av);
5243 }
5244
5245 /*
5246 ** HES_MAP_CLOSE -- free the Hesiod context
5247 */
5248
5249 void
5250 hes_map_close(map)
5251 MAP *map;
5252 {
5253 if (tTd(38, 20))
5254 sm_dprintf("hes_map_close(%s)\n", map->map_file);
5255
5256 # ifdef HESIOD_INIT
5257 /* Free the hesiod context */
5258 if (HesiodContext != NULL)
5259 {
5260 hesiod_end(HesiodContext);
5261 HesiodContext = NULL;
5262 }
5263 # endif /* HESIOD_INIT */
5264 }
5265
5266 #endif /* HESIOD */
5267 /*
5268 ** NeXT NETINFO Modules
5269 */
5270
5271 #if NETINFO
5272
5273 # define NETINFO_DEFAULT_DIR "/aliases"
5274 # define NETINFO_DEFAULT_PROPERTY "members"
5275
5276 /*
5277 ** NI_MAP_OPEN -- open NetInfo Aliases
5278 */
5279
5280 bool
5281 ni_map_open(map, mode)
5282 MAP *map;
5283 int mode;
5284 {
5285 if (tTd(38, 2))
5286 sm_dprintf("ni_map_open(%s, %s, %d)\n",
5287 map->map_mname, map->map_file, mode);
5288 mode &= O_ACCMODE;
5289
5290 if (*map->map_file == '\0')
5291 map->map_file = NETINFO_DEFAULT_DIR;
5292
5293 if (map->map_valcolnm == NULL)
5294 map->map_valcolnm = NETINFO_DEFAULT_PROPERTY;
5295
5296 if (map->map_coldelim == '\0')
5297 {
5298 if (bitset(MF_ALIAS, map->map_mflags))
5299 map->map_coldelim = ',';
5300 else if (bitset(MF_FILECLASS, map->map_mflags))
5301 map->map_coldelim = ' ';
5302 }
5303 return true;
5304 }
5305
5306
5307 /*
5308 ** NI_MAP_LOOKUP -- look up a datum in NetInfo
5309 */
5310
5311 char *
5312 ni_map_lookup(map, name, av, statp)
5313 MAP *map;
5314 char *name;
5315 char **av;
5316 int *statp;
5317 {
5318 char *res;
5319 char *propval;
5320
5321 if (tTd(38, 20))
5322 sm_dprintf("ni_map_lookup(%s, %s)\n", map->map_mname, name);
5323
5324 propval = ni_propval(map->map_file, map->map_keycolnm, name,
5325 map->map_valcolnm, map->map_coldelim);
5326
5327 if (propval == NULL)
5328 return NULL;
5329
5330 SM_TRY
5331 if (bitset(MF_MATCHONLY, map->map_mflags))
5332 res = map_rewrite(map, name, strlen(name), NULL);
5333 else
5334 res = map_rewrite(map, propval, strlen(propval), av);
5335 SM_FINALLY
5336 sm_free(propval);
5337 SM_END_TRY
5338 return res;
5339 }
5340
5341
5342 static bool
5343 ni_getcanonname(name, hbsize, statp)
5344 char *name;
5345 int hbsize;
5346 int *statp;
5347 {
5348 char *vptr;
5349 char *ptr;
5350 char nbuf[MAXNAME + 1];
5351
5352 if (tTd(38, 20))
5353 sm_dprintf("ni_getcanonname(%s)\n", name);
5354
5355 if (sm_strlcpy(nbuf, name, sizeof nbuf) >= sizeof nbuf)
5356 {
5357 *statp = EX_UNAVAILABLE;
5358 return false;
5359 }
5360 (void) shorten_hostname(nbuf);
5361
5362 /* we only accept single token search key */
5363 if (strchr(nbuf, '.'))
5364 {
5365 *statp = EX_NOHOST;
5366 return false;
5367 }
5368
5369 /* Do the search */
5370 vptr = ni_propval("/machines", NULL, nbuf, "name", '\n');
5371
5372 if (vptr == NULL)
5373 {
5374 *statp = EX_NOHOST;
5375 return false;
5376 }
5377
5378 /* Only want the first machine name */
5379 if ((ptr = strchr(vptr, '\n')) != NULL)
5380 *ptr = '\0';
5381
5382 if (sm_strlcpy(name, vptr, hbsize) >= hbsize)
5383 {
5384 sm_free(vptr);
5385 *statp = EX_UNAVAILABLE;
5386 return true;
5387 }
5388 sm_free(vptr);
5389 *statp = EX_OK;
5390 return false;
5391 }
5392 #endif /* NETINFO */
5393 /*
5394 ** TEXT (unindexed text file) Modules
5395 **
5396 ** This code donated by Sun Microsystems.
5397 */
5398
5399 #define map_sff map_lockfd /* overload field */
5400
5401
5402 /*
5403 ** TEXT_MAP_OPEN -- open text table
5404 */
5405
5406 bool
5407 text_map_open(map, mode)
5408 MAP *map;
5409 int mode;
5410 {
5411 long sff;
5412 int i;
5413
5414 if (tTd(38, 2))
5415 sm_dprintf("text_map_open(%s, %s, %d)\n",
5416 map->map_mname, map->map_file, mode);
5417
5418 mode &= O_ACCMODE;
5419 if (mode != O_RDONLY)
5420 {
5421 errno = EPERM;
5422 return false;
5423 }
5424
5425 if (*map->map_file == '\0')
5426 {
5427 syserr("text map \"%s\": file name required",
5428 map->map_mname);
5429 return false;
5430 }
5431
5432 if (map->map_file[0] != '/')
5433 {
5434 syserr("text map \"%s\": file name must be fully qualified",
5435 map->map_mname);
5436 return false;
5437 }
5438
5439 sff = SFF_ROOTOK|SFF_REGONLY;
5440 if (!bitnset(DBS_LINKEDMAPINWRITABLEDIR, DontBlameSendmail))
5441 sff |= SFF_NOWLINK;
5442 if (!bitnset(DBS_MAPINUNSAFEDIRPATH, DontBlameSendmail))
5443 sff |= SFF_SAFEDIRPATH;
5444 if ((i = safefile(map->map_file, RunAsUid, RunAsGid, RunAsUserName,
5445 sff, S_IRUSR, NULL)) != 0)
5446 {
5447 int save_errno = errno;
5448
5449 /* cannot open this map */
5450 if (tTd(38, 2))
5451 sm_dprintf("\tunsafe map file: %d\n", i);
5452 errno = save_errno;
5453 if (!bitset(MF_OPTIONAL, map->map_mflags))
5454 syserr("text map \"%s\": unsafe map file %s",
5455 map->map_mname, map->map_file);
5456 return false;
5457 }
5458
5459 if (map->map_keycolnm == NULL)
5460 map->map_keycolno = 0;
5461 else
5462 {
5463 if (!(isascii(*map->map_keycolnm) && isdigit(*map->map_keycolnm)))
5464 {
5465 syserr("text map \"%s\", file %s: -k should specify a number, not %s",
5466 map->map_mname, map->map_file,
5467 map->map_keycolnm);
5468 return false;
5469 }
5470 map->map_keycolno = atoi(map->map_keycolnm);
5471 }
5472
5473 if (map->map_valcolnm == NULL)
5474 map->map_valcolno = 0;
5475 else
5476 {
5477 if (!(isascii(*map->map_valcolnm) && isdigit(*map->map_valcolnm)))
5478 {
5479 syserr("text map \"%s\", file %s: -v should specify a number, not %s",
5480 map->map_mname, map->map_file,
5481 map->map_valcolnm);
5482 return false;
5483 }
5484 map->map_valcolno = atoi(map->map_valcolnm);
5485 }
5486
5487 if (tTd(38, 2))
5488 {
5489 sm_dprintf("text_map_open(%s, %s): delimiter = ",
5490 map->map_mname, map->map_file);
5491 if (map->map_coldelim == '\0')
5492 sm_dprintf("(white space)\n");
5493 else
5494 sm_dprintf("%c\n", map->map_coldelim);
5495 }
5496
5497 map->map_sff = sff;
5498 return true;
5499 }
5500
5501
5502 /*
5503 ** TEXT_MAP_LOOKUP -- look up a datum in a TEXT table
5504 */
5505
5506 char *
5507 text_map_lookup(map, name, av, statp)
5508 MAP *map;
5509 char *name;
5510 char **av;
5511 int *statp;
5512 {
5513 char *vp;
5514 auto int vsize;
5515 int buflen;
5516 SM_FILE_T *f;
5517 char delim;
5518 int key_idx;
5519 bool found_it;
5520 long sff = map->map_sff;
5521 char search_key[MAXNAME + 1];
5522 char linebuf[MAXLINE];
5523 char buf[MAXNAME + 1];
5524
5525 found_it = false;
5526 if (tTd(38, 20))
5527 sm_dprintf("text_map_lookup(%s, %s)\n", map->map_mname, name);
5528
5529 buflen = strlen(name);
5530 if (buflen > sizeof search_key - 1)
5531 buflen = sizeof search_key - 1; /* XXX just cut if off? */
5532 memmove(search_key, name, buflen);
5533 search_key[buflen] = '\0';
5534 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
5535 makelower(search_key);
5536
5537 f = safefopen(map->map_file, O_RDONLY, FileMode, sff);
5538 if (f == NULL)
5539 {
5540 map->map_mflags &= ~(MF_VALID|MF_OPEN);
5541 *statp = EX_UNAVAILABLE;
5542 return NULL;
5543 }
5544 key_idx = map->map_keycolno;
5545 delim = map->map_coldelim;
5546 while (sm_io_fgets(f, SM_TIME_DEFAULT,
5547 linebuf, sizeof linebuf) != NULL)
5548 {
5549 char *p;
5550
5551 /* skip comment line */
5552 if (linebuf[0] == '#')
5553 continue;
5554 p = strchr(linebuf, '\n');
5555 if (p != NULL)
5556 *p = '\0';
5557 p = get_column(linebuf, key_idx, delim, buf, sizeof buf);
5558 if (p != NULL && sm_strcasecmp(search_key, p) == 0)
5559 {
5560 found_it = true;
5561 break;
5562 }
5563 }
5564 (void) sm_io_close(f, SM_TIME_DEFAULT);
5565 if (!found_it)
5566 {
5567 *statp = EX_NOTFOUND;
5568 return NULL;
5569 }
5570 vp = get_column(linebuf, map->map_valcolno, delim, buf, sizeof buf);
5571 if (vp == NULL)
5572 {
5573 *statp = EX_NOTFOUND;
5574 return NULL;
5575 }
5576 vsize = strlen(vp);
5577 *statp = EX_OK;
5578 if (bitset(MF_MATCHONLY, map->map_mflags))
5579 return map_rewrite(map, name, strlen(name), NULL);
5580 else
5581 return map_rewrite(map, vp, vsize, av);
5582 }
5583
5584 /*
5585 ** TEXT_GETCANONNAME -- look up canonical name in hosts file
5586 */
5587
5588 static bool
5589 text_getcanonname(name, hbsize, statp)
5590 char *name;
5591 int hbsize;
5592 int *statp;
5593 {
5594 bool found;
5595 char *dot;
5596 SM_FILE_T *f;
5597 char linebuf[MAXLINE];
5598 char cbuf[MAXNAME + 1];
5599 char nbuf[MAXNAME + 1];
5600
5601 if (tTd(38, 20))
5602 sm_dprintf("text_getcanonname(%s)\n", name);
5603
5604 if (sm_strlcpy(nbuf, name, sizeof nbuf) >= sizeof nbuf)
5605 {
5606 *statp = EX_UNAVAILABLE;
5607 return false;
5608 }
5609 dot = shorten_hostname(nbuf);
5610
5611 f = sm_io_open(SmFtStdio, SM_TIME_DEFAULT, HostsFile, SM_IO_RDONLY,
5612 NULL);
5613 if (f == NULL)
5614 {
5615 *statp = EX_UNAVAILABLE;
5616 return false;
5617 }
5618 found = false;
5619 while (!found &&
5620 sm_io_fgets(f, SM_TIME_DEFAULT,
5621 linebuf, sizeof linebuf) != NULL)
5622 {
5623 char *p = strpbrk(linebuf, "#\n");
5624
5625 if (p != NULL)
5626 *p = '\0';
5627 if (linebuf[0] != '\0')
5628 found = extract_canonname(nbuf, dot, linebuf,
5629 cbuf, sizeof cbuf);
5630 }
5631 (void) sm_io_close(f, SM_TIME_DEFAULT);
5632 if (!found)
5633 {
5634 *statp = EX_NOHOST;
5635 return false;
5636 }
5637
5638 if (sm_strlcpy(name, cbuf, hbsize) >= hbsize)
5639 {
5640 *statp = EX_UNAVAILABLE;
5641 return false;
5642 }
5643 *statp = EX_OK;
5644 return true;
5645 }
5646 /*
5647 ** STAB (Symbol Table) Modules
5648 */
5649
5650
5651 /*
5652 ** STAB_MAP_LOOKUP -- look up alias in symbol table
5653 */
5654
5655 /* ARGSUSED2 */
5656 char *
5657 stab_map_lookup(map, name, av, pstat)
5658 register MAP *map;
5659 char *name;
5660 char **av;
5661 int *pstat;
5662 {
5663 register STAB *s;
5664
5665 if (tTd(38, 20))
5666 sm_dprintf("stab_lookup(%s, %s)\n",
5667 map->map_mname, name);
5668
5669 s = stab(name, ST_ALIAS, ST_FIND);
5670 if (s == NULL)
5671 return NULL;
5672 if (bitset(MF_MATCHONLY, map->map_mflags))
5673 return map_rewrite(map, name, strlen(name), NULL);
5674 else
5675 return map_rewrite(map, s->s_alias, strlen(s->s_alias), av);
5676 }
5677
5678 /*
5679 ** STAB_MAP_STORE -- store in symtab (actually using during init, not rebuild)
5680 */
5681
5682 void
5683 stab_map_store(map, lhs, rhs)
5684 register MAP *map;
5685 char *lhs;
5686 char *rhs;
5687 {
5688 register STAB *s;
5689
5690 s = stab(lhs, ST_ALIAS, ST_ENTER);
5691 s->s_alias = newstr(rhs);
5692 }
5693
5694
5695 /*
5696 ** STAB_MAP_OPEN -- initialize (reads data file)
5697 **
5698 ** This is a wierd case -- it is only intended as a fallback for
5699 ** aliases. For this reason, opens for write (only during a
5700 ** "newaliases") always fails, and opens for read open the
5701 ** actual underlying text file instead of the database.
5702 */
5703
5704 bool
5705 stab_map_open(map, mode)
5706 register MAP *map;
5707 int mode;
5708 {
5709 SM_FILE_T *af;
5710 long sff;
5711 struct stat st;
5712
5713 if (tTd(38, 2))
5714 sm_dprintf("stab_map_open(%s, %s, %d)\n",
5715 map->map_mname, map->map_file, mode);
5716
5717 mode &= O_ACCMODE;
5718 if (mode != O_RDONLY)
5719 {
5720 errno = EPERM;
5721 return false;
5722 }
5723
5724 sff = SFF_ROOTOK|SFF_REGONLY;
5725 if (!bitnset(DBS_LINKEDMAPINWRITABLEDIR, DontBlameSendmail))
5726 sff |= SFF_NOWLINK;
5727 if (!bitnset(DBS_MAPINUNSAFEDIRPATH, DontBlameSendmail))
5728 sff |= SFF_SAFEDIRPATH;
5729 af = safefopen(map->map_file, O_RDONLY, 0444, sff);
5730 if (af == NULL)
5731 return false;
5732 readaliases(map, af, false, false);
5733
5734 if (fstat(sm_io_getinfo(af, SM_IO_WHAT_FD, NULL), &st) >= 0)
5735 map->map_mtime = st.st_mtime;
5736 (void) sm_io_close(af, SM_TIME_DEFAULT);
5737
5738 return true;
5739 }
5740 /*
5741 ** Implicit Modules
5742 **
5743 ** Tries several types. For back compatibility of aliases.
5744 */
5745
5746
5747 /*
5748 ** IMPL_MAP_LOOKUP -- lookup in best open database
5749 */
5750
5751 char *
5752 impl_map_lookup(map, name, av, pstat)
5753 MAP *map;
5754 char *name;
5755 char **av;
5756 int *pstat;
5757 {
5758 if (tTd(38, 20))
5759 sm_dprintf("impl_map_lookup(%s, %s)\n",
5760 map->map_mname, name);
5761
5762 #if NEWDB
5763 if (bitset(MF_IMPL_HASH, map->map_mflags))
5764 return db_map_lookup(map, name, av, pstat);
5765 #endif /* NEWDB */
5766 #if NDBM
5767 if (bitset(MF_IMPL_NDBM, map->map_mflags))
5768 return ndbm_map_lookup(map, name, av, pstat);
5769 #endif /* NDBM */
5770 return stab_map_lookup(map, name, av, pstat);
5771 }
5772
5773 /*
5774 ** IMPL_MAP_STORE -- store in open databases
5775 */
5776
5777 void
5778 impl_map_store(map, lhs, rhs)
5779 MAP *map;
5780 char *lhs;
5781 char *rhs;
5782 {
5783 if (tTd(38, 12))
5784 sm_dprintf("impl_map_store(%s, %s, %s)\n",
5785 map->map_mname, lhs, rhs);
5786 #if NEWDB
5787 if (bitset(MF_IMPL_HASH, map->map_mflags))
5788 db_map_store(map, lhs, rhs);
5789 #endif /* NEWDB */
5790 #if NDBM
5791 if (bitset(MF_IMPL_NDBM, map->map_mflags))
5792 ndbm_map_store(map, lhs, rhs);
5793 #endif /* NDBM */
5794 stab_map_store(map, lhs, rhs);
5795 }
5796
5797 /*
5798 ** IMPL_MAP_OPEN -- implicit database open
5799 */
5800
5801 bool
5802 impl_map_open(map, mode)
5803 MAP *map;
5804 int mode;
5805 {
5806 if (tTd(38, 2))
5807 sm_dprintf("impl_map_open(%s, %s, %d)\n",
5808 map->map_mname, map->map_file, mode);
5809
5810 mode &= O_ACCMODE;
5811 #if NEWDB
5812 map->map_mflags |= MF_IMPL_HASH;
5813 if (hash_map_open(map, mode))
5814 {
5815 # ifdef NDBM_YP_COMPAT
5816 if (mode == O_RDONLY || strstr(map->map_file, "/yp/") == NULL)
5817 # endif /* NDBM_YP_COMPAT */
5818 return true;
5819 }
5820 else
5821 map->map_mflags &= ~MF_IMPL_HASH;
5822 #endif /* NEWDB */
5823 #if NDBM
5824 map->map_mflags |= MF_IMPL_NDBM;
5825 if (ndbm_map_open(map, mode))
5826 {
5827 return true;
5828 }
5829 else
5830 map->map_mflags &= ~MF_IMPL_NDBM;
5831 #endif /* NDBM */
5832
5833 #if defined(NEWDB) || defined(NDBM)
5834 if (Verbose)
5835 message("WARNING: cannot open alias database %s%s",
5836 map->map_file,
5837 mode == O_RDONLY ? "; reading text version" : "");
5838 #else /* defined(NEWDB) || defined(NDBM) */
5839 if (mode != O_RDONLY)
5840 usrerr("Cannot rebuild aliases: no database format defined");
5841 #endif /* defined(NEWDB) || defined(NDBM) */
5842
5843 if (mode == O_RDONLY)
5844 return stab_map_open(map, mode);
5845 else
5846 return false;
5847 }
5848
5849
5850 /*
5851 ** IMPL_MAP_CLOSE -- close any open database(s)
5852 */
5853
5854 void
5855 impl_map_close(map)
5856 MAP *map;
5857 {
5858 if (tTd(38, 9))
5859 sm_dprintf("impl_map_close(%s, %s, %lx)\n",
5860 map->map_mname, map->map_file, map->map_mflags);
5861 #if NEWDB
5862 if (bitset(MF_IMPL_HASH, map->map_mflags))
5863 {
5864 db_map_close(map);
5865 map->map_mflags &= ~MF_IMPL_HASH;
5866 }
5867 #endif /* NEWDB */
5868
5869 #if NDBM
5870 if (bitset(MF_IMPL_NDBM, map->map_mflags))
5871 {
5872 ndbm_map_close(map);
5873 map->map_mflags &= ~MF_IMPL_NDBM;
5874 }
5875 #endif /* NDBM */
5876 }
5877 /*
5878 ** User map class.
5879 **
5880 ** Provides access to the system password file.
5881 */
5882
5883 /*
5884 ** USER_MAP_OPEN -- open user map
5885 **
5886 ** Really just binds field names to field numbers.
5887 */
5888
5889 bool
5890 user_map_open(map, mode)
5891 MAP *map;
5892 int mode;
5893 {
5894 if (tTd(38, 2))
5895 sm_dprintf("user_map_open(%s, %d)\n",
5896 map->map_mname, mode);
5897
5898 mode &= O_ACCMODE;
5899 if (mode != O_RDONLY)
5900 {
5901 /* issue a pseudo-error message */
5902 errno = SM_EMAPCANTWRITE;
5903 return false;
5904 }
5905 if (map->map_valcolnm == NULL)
5906 /* EMPTY */
5907 /* nothing */ ;
5908 else if (sm_strcasecmp(map->map_valcolnm, "name") == 0)
5909 map->map_valcolno = 1;
5910 else if (sm_strcasecmp(map->map_valcolnm, "passwd") == 0)
5911 map->map_valcolno = 2;
5912 else if (sm_strcasecmp(map->map_valcolnm, "uid") == 0)
5913 map->map_valcolno = 3;
5914 else if (sm_strcasecmp(map->map_valcolnm, "gid") == 0)
5915 map->map_valcolno = 4;
5916 else if (sm_strcasecmp(map->map_valcolnm, "gecos") == 0)
5917 map->map_valcolno = 5;
5918 else if (sm_strcasecmp(map->map_valcolnm, "dir") == 0)
5919 map->map_valcolno = 6;
5920 else if (sm_strcasecmp(map->map_valcolnm, "shell") == 0)
5921 map->map_valcolno = 7;
5922 else
5923 {
5924 syserr("User map %s: unknown column name %s",
5925 map->map_mname, map->map_valcolnm);
5926 return false;
5927 }
5928 return true;
5929 }
5930
5931
5932 /*
5933 ** USER_MAP_LOOKUP -- look up a user in the passwd file.
5934 */
5935
5936 /* ARGSUSED3 */
5937 char *
5938 user_map_lookup(map, key, av, statp)
5939 MAP *map;
5940 char *key;
5941 char **av;
5942 int *statp;
5943 {
5944 auto bool fuzzy;
5945 SM_MBDB_T user;
5946
5947 if (tTd(38, 20))
5948 sm_dprintf("user_map_lookup(%s, %s)\n",
5949 map->map_mname, key);
5950
5951 *statp = finduser(key, &fuzzy, &user);
5952 if (*statp != EX_OK)
5953 return NULL;
5954 if (bitset(MF_MATCHONLY, map->map_mflags))
5955 return map_rewrite(map, key, strlen(key), NULL);
5956 else
5957 {
5958 char *rwval = NULL;
5959 char buf[30];
5960
5961 switch (map->map_valcolno)
5962 {
5963 case 0:
5964 case 1:
5965 rwval = user.mbdb_name;
5966 break;
5967
5968 case 2:
5969 rwval = "x"; /* passwd no longer supported */
5970 break;
5971
5972 case 3:
5973 (void) sm_snprintf(buf, sizeof buf, "%d",
5974 (int) user.mbdb_uid);
5975 rwval = buf;
5976 break;
5977
5978 case 4:
5979 (void) sm_snprintf(buf, sizeof buf, "%d",
5980 (int) user.mbdb_gid);
5981 rwval = buf;
5982 break;
5983
5984 case 5:
5985 rwval = user.mbdb_fullname;
5986 break;
5987
5988 case 6:
5989 rwval = user.mbdb_homedir;
5990 break;
5991
5992 case 7:
5993 rwval = user.mbdb_shell;
5994 break;
5995 default:
5996 syserr("user_map %s: bogus field %d",
5997 map->map_mname, map->map_valcolno);
5998 return NULL;
5999 }
6000 return map_rewrite(map, rwval, strlen(rwval), av);
6001 }
6002 }
6003 /*
6004 ** Program map type.
6005 **
6006 ** This provides access to arbitrary programs. It should be used
6007 ** only very sparingly, since there is no way to bound the cost
6008 ** of invoking an arbitrary program.
6009 */
6010
6011 char *
6012 prog_map_lookup(map, name, av, statp)
6013 MAP *map;
6014 char *name;
6015 char **av;
6016 int *statp;
6017 {
6018 int i;
6019 int save_errno;
6020 int fd;
6021 int status;
6022 auto pid_t pid;
6023 register char *p;
6024 char *rval;
6025 char *argv[MAXPV + 1];
6026 char buf[MAXLINE];
6027
6028 if (tTd(38, 20))
6029 sm_dprintf("prog_map_lookup(%s, %s) %s\n",
6030 map->map_mname, name, map->map_file);
6031
6032 i = 0;
6033 argv[i++] = map->map_file;
6034 if (map->map_rebuild != NULL)
6035 {
6036 (void) sm_strlcpy(buf, map->map_rebuild, sizeof buf);
6037 for (p = strtok(buf, " \t"); p != NULL; p = strtok(NULL, " \t"))
6038 {
6039 if (i >= MAXPV - 1)
6040 break;
6041 argv[i++] = p;
6042 }
6043 }
6044 argv[i++] = name;
6045 argv[i] = NULL;
6046 if (tTd(38, 21))
6047 {
6048 sm_dprintf("prog_open:");
6049 for (i = 0; argv[i] != NULL; i++)
6050 sm_dprintf(" %s", argv[i]);
6051 sm_dprintf("\n");
6052 }
6053 (void) sm_blocksignal(SIGCHLD);
6054 pid = prog_open(argv, &fd, CurEnv);
6055 if (pid < 0)
6056 {
6057 if (!bitset(MF_OPTIONAL, map->map_mflags))
6058 syserr("prog_map_lookup(%s) failed (%s) -- closing",
6059 map->map_mname, sm_errstring(errno));
6060 else if (tTd(38, 9))
6061 sm_dprintf("prog_map_lookup(%s) failed (%s) -- closing",
6062 map->map_mname, sm_errstring(errno));
6063 map->map_mflags &= ~(MF_VALID|MF_OPEN);
6064 *statp = EX_OSFILE;
6065 return NULL;
6066 }
6067 i = read(fd, buf, sizeof buf - 1);
6068 if (i < 0)
6069 {
6070 syserr("prog_map_lookup(%s): read error %s",
6071 map->map_mname, sm_errstring(errno));
6072 rval = NULL;
6073 }
6074 else if (i == 0)
6075 {
6076 if (tTd(38, 20))
6077 sm_dprintf("prog_map_lookup(%s): empty answer\n",
6078 map->map_mname);
6079 rval = NULL;
6080 }
6081 else
6082 {
6083 buf[i] = '\0';
6084 p = strchr(buf, '\n');
6085 if (p != NULL)
6086 *p = '\0';
6087
6088 /* collect the return value */
6089 if (bitset(MF_MATCHONLY, map->map_mflags))
6090 rval = map_rewrite(map, name, strlen(name), NULL);
6091 else
6092 rval = map_rewrite(map, buf, strlen(buf), av);
6093
6094 /* now flush any additional output */
6095 while ((i = read(fd, buf, sizeof buf)) > 0)
6096 continue;
6097 }
6098
6099 /* wait for the process to terminate */
6100 (void) close(fd);
6101 status = waitfor(pid);
6102 save_errno = errno;
6103 (void) sm_releasesignal(SIGCHLD);
6104 errno = save_errno;
6105
6106 if (status == -1)
6107 {
6108 syserr("prog_map_lookup(%s): wait error %s",
6109 map->map_mname, sm_errstring(errno));
6110 *statp = EX_SOFTWARE;
6111 rval = NULL;
6112 }
6113 else if (WIFEXITED(status))
6114 {
6115 if ((*statp = WEXITSTATUS(status)) != EX_OK)
6116 rval = NULL;
6117 }
6118 else
6119 {
6120 syserr("prog_map_lookup(%s): child died on signal %d",
6121 map->map_mname, status);
6122 *statp = EX_UNAVAILABLE;
6123 rval = NULL;
6124 }
6125 return rval;
6126 }
6127 /*
6128 ** Sequenced map type.
6129 **
6130 ** Tries each map in order until something matches, much like
6131 ** implicit. Stores go to the first map in the list that can
6132 ** support storing.
6133 **
6134 ** This is slightly unusual in that there are two interfaces.
6135 ** The "sequence" interface lets you stack maps arbitrarily.
6136 ** The "switch" interface builds a sequence map by looking
6137 ** at a system-dependent configuration file such as
6138 ** /etc/nsswitch.conf on Solaris or /etc/svc.conf on Ultrix.
6139 **
6140 ** We don't need an explicit open, since all maps are
6141 ** opened on demand.
6142 */
6143
6144 /*
6145 ** SEQ_MAP_PARSE -- Sequenced map parsing
6146 */
6147
6148 bool
6149 seq_map_parse(map, ap)
6150 MAP *map;
6151 char *ap;
6152 {
6153 int maxmap;
6154
6155 if (tTd(38, 2))
6156 sm_dprintf("seq_map_parse(%s, %s)\n", map->map_mname, ap);
6157 maxmap = 0;
6158 while (*ap != '\0')
6159 {
6160 register char *p;
6161 STAB *s;
6162
6163 /* find beginning of map name */
6164 while (isascii(*ap) && isspace(*ap))
6165 ap++;
6166 for (p = ap;
6167 (isascii(*p) && isalnum(*p)) || *p == '_' || *p == '.';
6168 p++)
6169 continue;
6170 if (*p != '\0')
6171 *p++ = '\0';
6172 while (*p != '\0' && (!isascii(*p) || !isalnum(*p)))
6173 p++;
6174 if (*ap == '\0')
6175 {
6176 ap = p;
6177 continue;
6178 }
6179 s = stab(ap, ST_MAP, ST_FIND);
6180 if (s == NULL)
6181 {
6182 syserr("Sequence map %s: unknown member map %s",
6183 map->map_mname, ap);
6184 }
6185 else if (maxmap >= MAXMAPSTACK)
6186 {
6187 syserr("Sequence map %s: too many member maps (%d max)",
6188 map->map_mname, MAXMAPSTACK);
6189 maxmap++;
6190 }
6191 else if (maxmap < MAXMAPSTACK)
6192 {
6193 map->map_stack[maxmap++] = &s->s_map;
6194 }
6195 ap = p;
6196 }
6197 return true;
6198 }
6199
6200 /*
6201 ** SWITCH_MAP_OPEN -- open a switched map
6202 **
6203 ** This looks at the system-dependent configuration and builds
6204 ** a sequence map that does the same thing.
6205 **
6206 ** Every system must define a switch_map_find routine in conf.c
6207 ** that will return the list of service types associated with a
6208 ** given service class.
6209 */
6210
6211 bool
6212 switch_map_open(map, mode)
6213 MAP *map;
6214 int mode;
6215 {
6216 int mapno;
6217 int nmaps;
6218 char *maptype[MAXMAPSTACK];
6219
6220 if (tTd(38, 2))
6221 sm_dprintf("switch_map_open(%s, %s, %d)\n",
6222 map->map_mname, map->map_file, mode);
6223
6224 mode &= O_ACCMODE;
6225 nmaps = switch_map_find(map->map_file, maptype, map->map_return);
6226 if (tTd(38, 19))
6227 {
6228 sm_dprintf("\tswitch_map_find => %d\n", nmaps);
6229 for (mapno = 0; mapno < nmaps; mapno++)
6230 sm_dprintf("\t\t%s\n", maptype[mapno]);
6231 }
6232 if (nmaps <= 0 || nmaps > MAXMAPSTACK)
6233 return false;
6234
6235 for (mapno = 0; mapno < nmaps; mapno++)
6236 {
6237 register STAB *s;
6238 char nbuf[MAXNAME + 1];
6239
6240 if (maptype[mapno] == NULL)
6241 continue;
6242 (void) sm_strlcpyn(nbuf, sizeof nbuf, 3,
6243 map->map_mname, ".", maptype[mapno]);
6244 s = stab(nbuf, ST_MAP, ST_FIND);
6245 if (s == NULL)
6246 {
6247 syserr("Switch map %s: unknown member map %s",
6248 map->map_mname, nbuf);
6249 }
6250 else
6251 {
6252 map->map_stack[mapno] = &s->s_map;
6253 if (tTd(38, 4))
6254 sm_dprintf("\tmap_stack[%d] = %s:%s\n",
6255 mapno,
6256 s->s_map.map_class->map_cname,
6257 nbuf);
6258 }
6259 }
6260 return true;
6261 }
6262
6263 #if 0
6264 /*
6265 ** SEQ_MAP_CLOSE -- close all underlying maps
6266 */
6267
6268 void
6269 seq_map_close(map)
6270 MAP *map;
6271 {
6272 int mapno;
6273
6274 if (tTd(38, 9))
6275 sm_dprintf("seq_map_close(%s)\n", map->map_mname);
6276
6277 for (mapno = 0; mapno < MAXMAPSTACK; mapno++)
6278 {
6279 MAP *mm = map->map_stack[mapno];
6280
6281 if (mm == NULL || !bitset(MF_OPEN, mm->map_mflags))
6282 continue;
6283 mm->map_mflags |= MF_CLOSING;
6284 mm->map_class->map_close(mm);
6285 mm->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING);
6286 }
6287 }
6288 #endif /* 0 */
6289
6290 /*
6291 ** SEQ_MAP_LOOKUP -- sequenced map lookup
6292 */
6293
6294 char *
6295 seq_map_lookup(map, key, args, pstat)
6296 MAP *map;
6297 char *key;
6298 char **args;
6299 int *pstat;
6300 {
6301 int mapno;
6302 int mapbit = 0x01;
6303 bool tempfail = false;
6304
6305 if (tTd(38, 20))
6306 sm_dprintf("seq_map_lookup(%s, %s)\n", map->map_mname, key);
6307
6308 for (mapno = 0; mapno < MAXMAPSTACK; mapbit <<= 1, mapno++)
6309 {
6310 MAP *mm = map->map_stack[mapno];
6311 char *rv;
6312
6313 if (mm == NULL)
6314 continue;
6315 if (!bitset(MF_OPEN, mm->map_mflags) &&
6316 !openmap(mm))
6317 {
6318 if (bitset(mapbit, map->map_return[MA_UNAVAIL]))
6319 {
6320 *pstat = EX_UNAVAILABLE;
6321 return NULL;
6322 }
6323 continue;
6324 }
6325 *pstat = EX_OK;
6326 rv = mm->map_class->map_lookup(mm, key, args, pstat);
6327 if (rv != NULL)
6328 return rv;
6329 if (*pstat == EX_TEMPFAIL)
6330 {
6331 if (bitset(mapbit, map->map_return[MA_TRYAGAIN]))
6332 return NULL;
6333 tempfail = true;
6334 }
6335 else if (bitset(mapbit, map->map_return[MA_NOTFOUND]))
6336 break;
6337 }
6338 if (tempfail)
6339 *pstat = EX_TEMPFAIL;
6340 else if (*pstat == EX_OK)
6341 *pstat = EX_NOTFOUND;
6342 return NULL;
6343 }
6344
6345 /*
6346 ** SEQ_MAP_STORE -- sequenced map store
6347 */
6348
6349 void
6350 seq_map_store(map, key, val)
6351 MAP *map;
6352 char *key;
6353 char *val;
6354 {
6355 int mapno;
6356
6357 if (tTd(38, 12))
6358 sm_dprintf("seq_map_store(%s, %s, %s)\n",
6359 map->map_mname, key, val);
6360
6361 for (mapno = 0; mapno < MAXMAPSTACK; mapno++)
6362 {
6363 MAP *mm = map->map_stack[mapno];
6364
6365 if (mm == NULL || !bitset(MF_WRITABLE, mm->map_mflags))
6366 continue;
6367
6368 mm->map_class->map_store(mm, key, val);
6369 return;
6370 }
6371 syserr("seq_map_store(%s, %s, %s): no writable map",
6372 map->map_mname, key, val);
6373 }
6374 /*
6375 ** NULL stubs
6376 */
6377
6378 /* ARGSUSED */
6379 bool
6380 null_map_open(map, mode)
6381 MAP *map;
6382 int mode;
6383 {
6384 return true;
6385 }
6386
6387 /* ARGSUSED */
6388 void
6389 null_map_close(map)
6390 MAP *map;
6391 {
6392 return;
6393 }
6394
6395 char *
6396 null_map_lookup(map, key, args, pstat)
6397 MAP *map;
6398 char *key;
6399 char **args;
6400 int *pstat;
6401 {
6402 *pstat = EX_NOTFOUND;
6403 return NULL;
6404 }
6405
6406 /* ARGSUSED */
6407 void
6408 null_map_store(map, key, val)
6409 MAP *map;
6410 char *key;
6411 char *val;
6412 {
6413 return;
6414 }
6415
6416 /*
6417 ** BOGUS stubs
6418 */
6419
6420 char *
6421 bogus_map_lookup(map, key, args, pstat)
6422 MAP *map;
6423 char *key;
6424 char **args;
6425 int *pstat;
6426 {
6427 *pstat = EX_TEMPFAIL;
6428 return NULL;
6429 }
6430
6431 MAPCLASS BogusMapClass =
6432 {
6433 "bogus-map", NULL, 0,
6434 NULL, bogus_map_lookup, null_map_store,
6435 null_map_open, null_map_close,
6436 };
6437 /*
6438 ** MACRO modules
6439 */
6440
6441 char *
6442 macro_map_lookup(map, name, av, statp)
6443 MAP *map;
6444 char *name;
6445 char **av;
6446 int *statp;
6447 {
6448 int mid;
6449
6450 if (tTd(38, 20))
6451 sm_dprintf("macro_map_lookup(%s, %s)\n", map->map_mname,
6452 name == NULL ? "NULL" : name);
6453
6454 if (name == NULL ||
6455 *name == '\0' ||
6456 (mid = macid(name)) == 0)
6457 {
6458 *statp = EX_CONFIG;
6459 return NULL;
6460 }
6461
6462 if (av[1] == NULL)
6463 macdefine(&CurEnv->e_macro, A_PERM, mid, NULL);
6464 else
6465 macdefine(&CurEnv->e_macro, A_TEMP, mid, av[1]);
6466
6467 *statp = EX_OK;
6468 return "";
6469 }
6470 /*
6471 ** REGEX modules
6472 */
6473
6474 #if MAP_REGEX
6475
6476 # include <regex.h>
6477
6478 # define DEFAULT_DELIM CONDELSE
6479 # define END_OF_FIELDS -1
6480 # define ERRBUF_SIZE 80
6481 # define MAX_MATCH 32
6482
6483 # define xnalloc(s) memset(xalloc(s), '\0', s);
6484
6485 struct regex_map
6486 {
6487 regex_t *regex_pattern_buf; /* xalloc it */
6488 int *regex_subfields; /* move to type MAP */
6489 char *regex_delim; /* move to type MAP */
6490 };
6491
6492 static int parse_fields __P((char *, int *, int, int));
6493 static char *regex_map_rewrite __P((MAP *, const char*, size_t, char **));
6494
6495 static int
6496 parse_fields(s, ibuf, blen, nr_substrings)
6497 char *s;
6498 int *ibuf; /* array */
6499 int blen; /* number of elements in ibuf */
6500 int nr_substrings; /* number of substrings in the pattern */
6501 {
6502 register char *cp;
6503 int i = 0;
6504 bool lastone = false;
6505
6506 blen--; /* for terminating END_OF_FIELDS */
6507 cp = s;
6508 do
6509 {
6510 for (;; cp++)
6511 {
6512 if (*cp == ',')
6513 {
6514 *cp = '\0';
6515 break;
6516 }
6517 if (*cp == '\0')
6518 {
6519 lastone = true;
6520 break;
6521 }
6522 }
6523 if (i < blen)
6524 {
6525 int val = atoi(s);
6526
6527 if (val < 0 || val >= nr_substrings)
6528 {
6529 syserr("field (%d) out of range, only %d substrings in pattern",
6530 val, nr_substrings);
6531 return -1;
6532 }
6533 ibuf[i++] = val;
6534 }
6535 else
6536 {
6537 syserr("too many fields, %d max", blen);
6538 return -1;
6539 }
6540 s = ++cp;
6541 } while (!lastone);
6542 ibuf[i] = END_OF_FIELDS;
6543 return i;
6544 }
6545
6546 bool
6547 regex_map_init(map, ap)
6548 MAP *map;
6549 char *ap;
6550 {
6551 int regerr;
6552 struct regex_map *map_p;
6553 register char *p;
6554 char *sub_param = NULL;
6555 int pflags;
6556 static char defdstr[] = { (char) DEFAULT_DELIM, '\0' };
6557
6558 if (tTd(38, 2))
6559 sm_dprintf("regex_map_init: mapname '%s', args '%s'\n",
6560 map->map_mname, ap);
6561
6562 pflags = REG_ICASE | REG_EXTENDED | REG_NOSUB;
6563 p = ap;
6564 map_p = (struct regex_map *) xnalloc(sizeof *map_p);
6565 map_p->regex_pattern_buf = (regex_t *)xnalloc(sizeof(regex_t));
6566
6567 for (;;)
6568 {
6569 while (isascii(*p) && isspace(*p))
6570 p++;
6571 if (*p != '-')
6572 break;
6573 switch (*++p)
6574 {
6575 case 'n': /* not */
6576 map->map_mflags |= MF_REGEX_NOT;
6577 break;
6578
6579 case 'f': /* case sensitive */
6580 map->map_mflags |= MF_NOFOLDCASE;
6581 pflags &= ~REG_ICASE;
6582 break;
6583
6584 case 'b': /* basic regular expressions */
6585 pflags &= ~REG_EXTENDED;
6586 break;
6587
6588 case 's': /* substring match () syntax */
6589 sub_param = ++p;
6590 pflags &= ~REG_NOSUB;
6591 break;
6592
6593 case 'd': /* delimiter */
6594 map_p->regex_delim = ++p;
6595 break;
6596
6597 case 'a': /* map append */
6598 map->map_app = ++p;
6599 break;
6600
6601 case 'm': /* matchonly */
6602 map->map_mflags |= MF_MATCHONLY;
6603 break;
6604
6605 case 'q':
6606 map->map_mflags |= MF_KEEPQUOTES;
6607 break;
6608
6609 case 'S':
6610 map->map_spacesub = *++p;
6611 break;
6612
6613 case 'D':
6614 map->map_mflags |= MF_DEFER;
6615 break;
6616
6617 }
6618 while (*p != '\0' && !(isascii(*p) && isspace(*p)))
6619 p++;
6620 if (*p != '\0')
6621 *p++ = '\0';
6622 }
6623 if (tTd(38, 3))
6624 sm_dprintf("regex_map_init: compile '%s' 0x%x\n", p, pflags);
6625
6626 if ((regerr = regcomp(map_p->regex_pattern_buf, p, pflags)) != 0)
6627 {
6628 /* Errorhandling */
6629 char errbuf[ERRBUF_SIZE];
6630
6631 (void) regerror(regerr, map_p->regex_pattern_buf,
6632 errbuf, sizeof errbuf);
6633 syserr("pattern-compile-error: %s", errbuf);
6634 sm_free(map_p->regex_pattern_buf); /* XXX */
6635 sm_free(map_p); /* XXX */
6636 return false;
6637 }
6638
6639 if (map->map_app != NULL)
6640 map->map_app = newstr(map->map_app);
6641 if (map_p->regex_delim != NULL)
6642 map_p->regex_delim = newstr(map_p->regex_delim);
6643 else
6644 map_p->regex_delim = defdstr;
6645
6646 if (!bitset(REG_NOSUB, pflags))
6647 {
6648 /* substring matching */
6649 int substrings;
6650 int *fields = (int *) xalloc(sizeof(int) * (MAX_MATCH + 1));
6651
6652 substrings = map_p->regex_pattern_buf->re_nsub + 1;
6653
6654 if (tTd(38, 3))
6655 sm_dprintf("regex_map_init: nr of substrings %d\n",
6656 substrings);
6657
6658 if (substrings >= MAX_MATCH)
6659 {
6660 syserr("too many substrings, %d max", MAX_MATCH);
6661 sm_free(map_p->regex_pattern_buf); /* XXX */
6662 sm_free(map_p); /* XXX */
6663 return false;
6664 }
6665 if (sub_param != NULL && sub_param[0] != '\0')
6666 {
6667 /* optional parameter -sfields */
6668 if (parse_fields(sub_param, fields,
6669 MAX_MATCH + 1, substrings) == -1)
6670 return false;
6671 }
6672 else
6673 {
6674 int i;
6675
6676 /* set default fields */
6677 for (i = 0; i < substrings; i++)
6678 fields[i] = i;
6679 fields[i] = END_OF_FIELDS;
6680 }
6681 map_p->regex_subfields = fields;
6682 if (tTd(38, 3))
6683 {
6684 int *ip;
6685
6686 sm_dprintf("regex_map_init: subfields");
6687 for (ip = fields; *ip != END_OF_FIELDS; ip++)
6688 sm_dprintf(" %d", *ip);
6689 sm_dprintf("\n");
6690 }
6691 }
6692 map->map_db1 = (ARBPTR_T) map_p; /* dirty hack */
6693 return true;
6694 }
6695
6696 static char *
6697 regex_map_rewrite(map, s, slen, av)
6698 MAP *map;
6699 const char *s;
6700 size_t slen;
6701 char **av;
6702 {
6703 if (bitset(MF_MATCHONLY, map->map_mflags))
6704 return map_rewrite(map, av[0], strlen(av[0]), NULL);
6705 else
6706 return map_rewrite(map, s, slen, av);
6707 }
6708
6709 char *
6710 regex_map_lookup(map, name, av, statp)
6711 MAP *map;
6712 char *name;
6713 char **av;
6714 int *statp;
6715 {
6716 int reg_res;
6717 struct regex_map *map_p;
6718 regmatch_t pmatch[MAX_MATCH];
6719
6720 if (tTd(38, 20))
6721 {
6722 char **cpp;
6723
6724 sm_dprintf("regex_map_lookup: key '%s'\n", name);
6725 for (cpp = av; cpp != NULL && *cpp != NULL; cpp++)
6726 sm_dprintf("regex_map_lookup: arg '%s'\n", *cpp);
6727 }
6728
6729 map_p = (struct regex_map *)(map->map_db1);
6730 reg_res = regexec(map_p->regex_pattern_buf,
6731 name, MAX_MATCH, pmatch, 0);
6732
6733 if (bitset(MF_REGEX_NOT, map->map_mflags))
6734 {
6735 /* option -n */
6736 if (reg_res == REG_NOMATCH)
6737 return regex_map_rewrite(map, "", (size_t) 0, av);
6738 else
6739 return NULL;
6740 }
6741 if (reg_res == REG_NOMATCH)
6742 return NULL;
6743
6744 if (map_p->regex_subfields != NULL)
6745 {
6746 /* option -s */
6747 static char retbuf[MAXNAME];
6748 int fields[MAX_MATCH + 1];
6749 bool first = true;
6750 int anglecnt = 0, cmntcnt = 0, spacecnt = 0;
6751 bool quotemode = false, bslashmode = false;
6752 register char *dp, *sp;
6753 char *endp, *ldp;
6754 int *ip;
6755
6756 dp = retbuf;
6757 ldp = retbuf + sizeof(retbuf) - 1;
6758
6759 if (av[1] != NULL)
6760 {
6761 if (parse_fields(av[1], fields, MAX_MATCH + 1,
6762 (int) map_p->regex_pattern_buf->re_nsub + 1) == -1)
6763 {
6764 *statp = EX_CONFIG;
6765 return NULL;
6766 }
6767 ip = fields;
6768 }
6769 else
6770 ip = map_p->regex_subfields;
6771
6772 for ( ; *ip != END_OF_FIELDS; ip++)
6773 {
6774 if (!first)
6775 {
6776 for (sp = map_p->regex_delim; *sp; sp++)
6777 {
6778 if (dp < ldp)
6779 *dp++ = *sp;
6780 }
6781 }
6782 else
6783 first = false;
6784
6785 if (*ip >= MAX_MATCH ||
6786 pmatch[*ip].rm_so < 0 || pmatch[*ip].rm_eo < 0)
6787 continue;
6788
6789 sp = name + pmatch[*ip].rm_so;
6790 endp = name + pmatch[*ip].rm_eo;
6791 for (; endp > sp; sp++)
6792 {
6793 if (dp < ldp)
6794 {
6795 if (bslashmode)
6796 {
6797 *dp++ = *sp;
6798 bslashmode = false;
6799 }
6800 else if (quotemode && *sp != '"' &&
6801 *sp != '\\')
6802 {
6803 *dp++ = *sp;
6804 }
6805 else switch (*dp++ = *sp)
6806 {
6807 case '\\':
6808 bslashmode = true;
6809 break;
6810
6811 case '(':
6812 cmntcnt++;
6813 break;
6814
6815 case ')':
6816 cmntcnt--;
6817 break;
6818
6819 case '<':
6820 anglecnt++;
6821 break;
6822
6823 case '>':
6824 anglecnt--;
6825 break;
6826
6827 case ' ':
6828 spacecnt++;
6829 break;
6830
6831 case '"':
6832 quotemode = !quotemode;
6833 break;
6834 }
6835 }
6836 }
6837 }
6838 if (anglecnt != 0 || cmntcnt != 0 || quotemode ||
6839 bslashmode || spacecnt != 0)
6840 {
6841 sm_syslog(LOG_WARNING, NOQID,
6842 "Warning: regex may cause prescan() failure map=%s lookup=%s",
6843 map->map_mname, name);
6844 return NULL;
6845 }
6846
6847 *dp = '\0';
6848
6849 return regex_map_rewrite(map, retbuf, strlen(retbuf), av);
6850 }
6851 return regex_map_rewrite(map, "", (size_t)0, av);
6852 }
6853 #endif /* MAP_REGEX */
6854 /*
6855 ** NSD modules
6856 */
6857 #if MAP_NSD
6858
6859 # include <ndbm.h>
6860 # define _DATUM_DEFINED
6861 # include <ns_api.h>
6862
6863 typedef struct ns_map_list
6864 {
6865 ns_map_t *map; /* XXX ns_ ? */
6866 char *mapname;
6867 struct ns_map_list *next;
6868 } ns_map_list_t;
6869
6870 static ns_map_t *
6871 ns_map_t_find(mapname)
6872 char *mapname;
6873 {
6874 static ns_map_list_t *ns_maps = NULL;
6875 ns_map_list_t *ns_map;
6876
6877 /* walk the list of maps looking for the correctly named map */
6878 for (ns_map = ns_maps; ns_map != NULL; ns_map = ns_map->next)
6879 {
6880 if (strcmp(ns_map->mapname, mapname) == 0)
6881 break;
6882 }
6883
6884 /* if we are looking at a NULL ns_map_list_t, then create a new one */
6885 if (ns_map == NULL)
6886 {
6887 ns_map = (ns_map_list_t *) xalloc(sizeof *ns_map);
6888 ns_map->mapname = newstr(mapname);
6889 ns_map->map = (ns_map_t *) xalloc(sizeof *ns_map->map);
6890 memset(ns_map->map, '\0', sizeof *ns_map->map);
6891 ns_map->next = ns_maps;
6892 ns_maps = ns_map;
6893 }
6894 return ns_map->map;
6895 }
6896
6897 char *
6898 nsd_map_lookup(map, name, av, statp)
6899 MAP *map;
6900 char *name;
6901 char **av;
6902 int *statp;
6903 {
6904 int buflen, r;
6905 char *p;
6906 ns_map_t *ns_map;
6907 char keybuf[MAXNAME + 1];
6908 char buf[MAXLINE];
6909
6910 if (tTd(38, 20))
6911 sm_dprintf("nsd_map_lookup(%s, %s)\n", map->map_mname, name);
6912
6913 buflen = strlen(name);
6914 if (buflen > sizeof keybuf - 1)
6915 buflen = sizeof keybuf - 1; /* XXX simply cut off? */
6916 memmove(keybuf, name, buflen);
6917 keybuf[buflen] = '\0';
6918 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
6919 makelower(keybuf);
6920
6921 ns_map = ns_map_t_find(map->map_file);
6922 if (ns_map == NULL)
6923 {
6924 if (tTd(38, 20))
6925 sm_dprintf("nsd_map_t_find failed\n");
6926 *statp = EX_UNAVAILABLE;
6927 return NULL;
6928 }
6929 r = ns_lookup(ns_map, NULL, map->map_file, keybuf, NULL,
6930 buf, sizeof buf);
6931 if (r == NS_UNAVAIL || r == NS_TRYAGAIN)
6932 {
6933 *statp = EX_TEMPFAIL;
6934 return NULL;
6935 }
6936 if (r == NS_BADREQ
6937 # ifdef NS_NOPERM
6938 || r == NS_NOPERM
6939 # endif /* NS_NOPERM */
6940 )
6941 {
6942 *statp = EX_CONFIG;
6943 return NULL;
6944 }
6945 if (r != NS_SUCCESS)
6946 {
6947 *statp = EX_NOTFOUND;
6948 return NULL;
6949 }
6950
6951 *statp = EX_OK;
6952
6953 /* Null out trailing \n */
6954 if ((p = strchr(buf, '\n')) != NULL)
6955 *p = '\0';
6956
6957 return map_rewrite(map, buf, strlen(buf), av);
6958 }
6959 #endif /* MAP_NSD */
6960
6961 char *
6962 arith_map_lookup(map, name, av, statp)
6963 MAP *map;
6964 char *name;
6965 char **av;
6966 int *statp;
6967 {
6968 long r;
6969 long v[2];
6970 bool res = false;
6971 bool boolres;
6972 static char result[16];
6973 char **cpp;
6974
6975 if (tTd(38, 2))
6976 {
6977 sm_dprintf("arith_map_lookup: key '%s'\n", name);
6978 for (cpp = av; cpp != NULL && *cpp != NULL; cpp++)
6979 sm_dprintf("arith_map_lookup: arg '%s'\n", *cpp);
6980 }
6981 r = 0;
6982 boolres = false;
6983 cpp = av;
6984 *statp = EX_OK;
6985
6986 /*
6987 ** read arguments for arith map
6988 ** - no check is made whether they are really numbers
6989 ** - just ignores args after the second
6990 */
6991
6992 for (++cpp; cpp != NULL && *cpp != NULL && r < 2; cpp++)
6993 v[r++] = strtol(*cpp, NULL, 0);
6994
6995 /* operator and (at least) two operands given? */
6996 if (name != NULL && r == 2)
6997 {
6998 switch (*name)
6999 {
7000 case '|':
7001 r = v[0] | v[1];
7002 break;
7003
7004 case '&':
7005 r = v[0] & v[1];
7006 break;
7007
7008 case '%':
7009 if (v[1] == 0)
7010 return NULL;
7011 r = v[0] % v[1];
7012 break;
7013 case '+':
7014 r = v[0] + v[1];
7015 break;
7016
7017 case '-':
7018 r = v[0] - v[1];
7019 break;
7020
7021 case '*':
7022 r = v[0] * v[1];
7023 break;
7024
7025 case '/':
7026 if (v[1] == 0)
7027 return NULL;
7028 r = v[0] / v[1];
7029 break;
7030
7031 case 'l':
7032 res = v[0] < v[1];
7033 boolres = true;
7034 break;
7035
7036 case '=':
7037 res = v[0] == v[1];
7038 boolres = true;
7039 break;
7040
7041 default:
7042 /* XXX */
7043 *statp = EX_CONFIG;
7044 if (LogLevel > 10)
7045 sm_syslog(LOG_WARNING, NOQID,
7046 "arith_map: unknown operator %c",
7047 isprint(*name) ? *name : '?');
7048 return NULL;
7049 }
7050 if (boolres)
7051 (void) sm_snprintf(result, sizeof result,
7052 res ? "TRUE" : "FALSE");
7053 else
7054 (void) sm_snprintf(result, sizeof result, "%ld", r);
7055 return result;
7056 }
7057 *statp = EX_CONFIG;
7058 return NULL;
7059 }
7060
7061 #if SOCKETMAP
7062
7063 # if NETINET || NETINET6
7064 # include <arpa/inet.h>
7065 # endif /* NETINET || NETINET6 */
7066
7067 # define socket_map_next map_stack[0]
7068
7069 /*
7070 ** SOCKET_MAP_OPEN -- open socket table
7071 */
7072
7073 bool
7074 socket_map_open(map, mode)
7075 MAP *map;
7076 int mode;
7077 {
7078 STAB *s;
7079 int sock = 0;
7080 SOCKADDR_LEN_T addrlen = 0;
7081 int addrno = 0;
7082 int save_errno;
7083 char *p;
7084 char *colon;
7085 char *at;
7086 struct hostent *hp = NULL;
7087 SOCKADDR addr;
7088
7089 if (tTd(38, 2))
7090 sm_dprintf("socket_map_open(%s, %s, %d)\n",
7091 map->map_mname, map->map_file, mode);
7092
7093 mode &= O_ACCMODE;
7094
7095 /* sendmail doesn't have the ability to write to SOCKET (yet) */
7096 if (mode != O_RDONLY)
7097 {
7098 /* issue a pseudo-error message */
7099 errno = SM_EMAPCANTWRITE;
7100 return false;
7101 }
7102
7103 if (*map->map_file == '\0')
7104 {
7105 syserr("socket map \"%s\": empty or missing socket information",
7106 map->map_mname);
7107 return false;
7108 }
7109
7110 s = socket_map_findconn(map->map_file);
7111 if (s->s_socketmap != NULL)
7112 {
7113 /* Copy open connection */
7114 map->map_db1 = s->s_socketmap->map_db1;
7115
7116 /* Add this map as head of linked list */
7117 map->socket_map_next = s->s_socketmap;
7118 s->s_socketmap = map;
7119
7120 if (tTd(38, 2))
7121 sm_dprintf("using cached connection\n");
7122 return true;
7123 }
7124
7125 if (tTd(38, 2))
7126 sm_dprintf("opening new connection\n");
7127
7128 /* following code is ripped from milter.c */
7129 /* XXX It should be put in a library... */
7130
7131 /* protocol:filename or protocol:port@host */
7132 memset(&addr, '\0', sizeof addr);
7133 p = map->map_file;
7134 colon = strchr(p, ':');
7135 if (colon != NULL)
7136 {
7137 *colon = '\0';
7138
7139 if (*p == '\0')
7140 {
7141 # if NETUNIX
7142 /* default to AF_UNIX */
7143 addr.sa.sa_family = AF_UNIX;
7144 # else /* NETUNIX */
7145 # if NETINET
7146 /* default to AF_INET */
7147 addr.sa.sa_family = AF_INET;
7148 # else /* NETINET */
7149 # if NETINET6
7150 /* default to AF_INET6 */
7151 addr.sa.sa_family = AF_INET6;
7152 # else /* NETINET6 */
7153 /* no protocols available */
7154 syserr("socket map \"%s\": no valid socket protocols available",
7155 map->map_mname);
7156 return false;
7157 # endif /* NETINET6 */
7158 # endif /* NETINET */
7159 # endif /* NETUNIX */
7160 }
7161 # if NETUNIX
7162 else if (sm_strcasecmp(p, "unix") == 0 ||
7163 sm_strcasecmp(p, "local") == 0)
7164 addr.sa.sa_family = AF_UNIX;
7165 # endif /* NETUNIX */
7166 # if NETINET
7167 else if (sm_strcasecmp(p, "inet") == 0)
7168 addr.sa.sa_family = AF_INET;
7169 # endif /* NETINET */
7170 # if NETINET6
7171 else if (sm_strcasecmp(p, "inet6") == 0)
7172 addr.sa.sa_family = AF_INET6;
7173 # endif /* NETINET6 */
7174 else
7175 {
7176 # ifdef EPROTONOSUPPORT
7177 errno = EPROTONOSUPPORT;
7178 # else /* EPROTONOSUPPORT */
7179 errno = EINVAL;
7180 # endif /* EPROTONOSUPPORT */
7181 syserr("socket map \"%s\": unknown socket type %s",
7182 map->map_mname, p);
7183 return false;
7184 }
7185 *colon++ = ':';
7186 }
7187 else
7188 {
7189 colon = p;
7190 #if NETUNIX
7191 /* default to AF_UNIX */
7192 addr.sa.sa_family = AF_UNIX;
7193 #else /* NETUNIX */
7194 # if NETINET
7195 /* default to AF_INET */
7196 addr.sa.sa_family = AF_INET;
7197 # else /* NETINET */
7198 # if NETINET6
7199 /* default to AF_INET6 */
7200 addr.sa.sa_family = AF_INET6;
7201 # else /* NETINET6 */
7202 syserr("socket map \"%s\": unknown socket type %s",
7203 map->map_mname, p);
7204 return false;
7205 # endif /* NETINET6 */
7206 # endif /* NETINET */
7207 #endif /* NETUNIX */
7208 }
7209
7210 # if NETUNIX
7211 if (addr.sa.sa_family == AF_UNIX)
7212 {
7213 long sff = SFF_SAFEDIRPATH|SFF_OPENASROOT|SFF_NOLINK|SFF_EXECOK;
7214
7215 at = colon;
7216 if (strlen(colon) >= sizeof addr.sunix.sun_path)
7217 {
7218 syserr("socket map \"%s\": local socket name %s too long",
7219 map->map_mname, colon);
7220 return false;
7221 }
7222 errno = safefile(colon, RunAsUid, RunAsGid, RunAsUserName, sff,
7223 S_IRUSR|S_IWUSR, NULL);
7224
7225 if (errno != 0)
7226 {
7227 /* if not safe, don't create */
7228 syserr("socket map \"%s\": local socket name %s unsafe",
7229 map->map_mname, colon);
7230 return false;
7231 }
7232
7233 (void) sm_strlcpy(addr.sunix.sun_path, colon,
7234 sizeof addr.sunix.sun_path);
7235 addrlen = sizeof (struct sockaddr_un);
7236 }
7237 else
7238 # endif /* NETUNIX */
7239 # if NETINET || NETINET6
7240 if (false
7241 # if NETINET
7242 || addr.sa.sa_family == AF_INET
7243 # endif /* NETINET */
7244 # if NETINET6
7245 || addr.sa.sa_family == AF_INET6
7246 # endif /* NETINET6 */
7247 )
7248 {
7249 unsigned short port;
7250
7251 /* Parse port@host */
7252 at = strchr(colon, '@');
7253 if (at == NULL)
7254 {
7255 syserr("socket map \"%s\": bad address %s (expected port@host)",
7256 map->map_mname, colon);
7257 return false;
7258 }
7259 *at = '\0';
7260 if (isascii(*colon) && isdigit(*colon))
7261 port = htons((unsigned short) atoi(colon));
7262 else
7263 {
7264 # ifdef NO_GETSERVBYNAME
7265 syserr("socket map \"%s\": invalid port number %s",
7266 map->map_mname, colon);
7267 return false;
7268 # else /* NO_GETSERVBYNAME */
7269 register struct servent *sp;
7270
7271 sp = getservbyname(colon, "tcp");
7272 if (sp == NULL)
7273 {
7274 syserr("socket map \"%s\": unknown port name %s",
7275 map->map_mname, colon);
7276 return false;
7277 }
7278 port = sp->s_port;
7279 # endif /* NO_GETSERVBYNAME */
7280 }
7281 *at++ = '@';
7282 if (*at == '[')
7283 {
7284 char *end;
7285
7286 end = strchr(at, ']');
7287 if (end != NULL)
7288 {
7289 bool found = false;
7290 # if NETINET
7291 unsigned long hid = INADDR_NONE;
7292 # endif /* NETINET */
7293 # if NETINET6
7294 struct sockaddr_in6 hid6;
7295 # endif /* NETINET6 */
7296
7297 *end = '\0';
7298 # if NETINET
7299 if (addr.sa.sa_family == AF_INET &&
7300 (hid = inet_addr(&at[1])) != INADDR_NONE)
7301 {
7302 addr.sin.sin_addr.s_addr = hid;
7303 addr.sin.sin_port = port;
7304 found = true;
7305 }
7306 # endif /* NETINET */
7307 # if NETINET6
7308 (void) memset(&hid6, '\0', sizeof hid6);
7309 if (addr.sa.sa_family == AF_INET6 &&
7310 anynet_pton(AF_INET6, &at[1],
7311 &hid6.sin6_addr) == 1)
7312 {
7313 addr.sin6.sin6_addr = hid6.sin6_addr;
7314 addr.sin6.sin6_port = port;
7315 found = true;
7316 }
7317 # endif /* NETINET6 */
7318 *end = ']';
7319 if (!found)
7320 {
7321 syserr("socket map \"%s\": Invalid numeric domain spec \"%s\"",
7322 map->map_mname, at);
7323 return false;
7324 }
7325 }
7326 else
7327 {
7328 syserr("socket map \"%s\": Invalid numeric domain spec \"%s\"",
7329 map->map_mname, at);
7330 return false;
7331 }
7332 }
7333 else
7334 {
7335 hp = sm_gethostbyname(at, addr.sa.sa_family);
7336 if (hp == NULL)
7337 {
7338 syserr("socket map \"%s\": Unknown host name %s",
7339 map->map_mname, at);
7340 return false;
7341 }
7342 addr.sa.sa_family = hp->h_addrtype;
7343 switch (hp->h_addrtype)
7344 {
7345 # if NETINET
7346 case AF_INET:
7347 memmove(&addr.sin.sin_addr,
7348 hp->h_addr, INADDRSZ);
7349 addr.sin.sin_port = port;
7350 addrlen = sizeof (struct sockaddr_in);
7351 addrno = 1;
7352 break;
7353 # endif /* NETINET */
7354
7355 # if NETINET6
7356 case AF_INET6:
7357 memmove(&addr.sin6.sin6_addr,
7358 hp->h_addr, IN6ADDRSZ);
7359 addr.sin6.sin6_port = port;
7360 addrlen = sizeof (struct sockaddr_in6);
7361 addrno = 1;
7362 break;
7363 # endif /* NETINET6 */
7364
7365 default:
7366 syserr("socket map \"%s\": Unknown protocol for %s (%d)",
7367 map->map_mname, at, hp->h_addrtype);
7368 # if NETINET6
7369 freehostent(hp);
7370 # endif /* NETINET6 */
7371 return false;
7372 }
7373 }
7374 }
7375 else
7376 # endif /* NETINET || NETINET6 */
7377 {
7378 syserr("socket map \"%s\": unknown socket protocol",
7379 map->map_mname);
7380 return false;
7381 }
7382
7383 /* nope, actually connecting */
7384 for (;;)
7385 {
7386 sock = socket(addr.sa.sa_family, SOCK_STREAM, 0);
7387 if (sock < 0)
7388 {
7389 save_errno = errno;
7390 if (tTd(38, 5))
7391 sm_dprintf("socket map \"%s\": error creating socket: %s\n",
7392 map->map_mname,
7393 sm_errstring(save_errno));
7394 # if NETINET6
7395 if (hp != NULL)
7396 freehostent(hp);
7397 # endif /* NETINET6 */
7398 return false;
7399 }
7400
7401 if (connect(sock, (struct sockaddr *) &addr, addrlen) >= 0)
7402 break;
7403
7404 /* couldn't connect.... try next address */
7405 save_errno = errno;
7406 p = CurHostName;
7407 CurHostName = at;
7408 if (tTd(38, 5))
7409 sm_dprintf("socket_open (%s): open %s failed: %s\n",
7410 map->map_mname, at, sm_errstring(save_errno));
7411 CurHostName = p;
7412 (void) close(sock);
7413
7414 /* try next address */
7415 if (hp != NULL && hp->h_addr_list[addrno] != NULL)
7416 {
7417 switch (addr.sa.sa_family)
7418 {
7419 # if NETINET
7420 case AF_INET:
7421 memmove(&addr.sin.sin_addr,
7422 hp->h_addr_list[addrno++],
7423 INADDRSZ);
7424 break;
7425 # endif /* NETINET */
7426
7427 # if NETINET6
7428 case AF_INET6:
7429 memmove(&addr.sin6.sin6_addr,
7430 hp->h_addr_list[addrno++],
7431 IN6ADDRSZ);
7432 break;
7433 # endif /* NETINET6 */
7434
7435 default:
7436 if (tTd(38, 5))
7437 sm_dprintf("socket map \"%s\": Unknown protocol for %s (%d)\n",
7438 map->map_mname, at,
7439 hp->h_addrtype);
7440 # if NETINET6
7441 freehostent(hp);
7442 # endif /* NETINET6 */
7443 return false;
7444 }
7445 continue;
7446 }
7447 p = CurHostName;
7448 CurHostName = at;
7449 if (tTd(38, 5))
7450 sm_dprintf("socket map \"%s\": error connecting to socket map: %s\n",
7451 map->map_mname, sm_errstring(save_errno));
7452 CurHostName = p;
7453 # if NETINET6
7454 if (hp != NULL)
7455 freehostent(hp);
7456 # endif /* NETINET6 */
7457 return false;
7458 }
7459 # if NETINET6
7460 if (hp != NULL)
7461 {
7462 freehostent(hp);
7463 hp = NULL;
7464 }
7465 # endif /* NETINET6 */
7466 if ((map->map_db1 = (ARBPTR_T) sm_io_open(SmFtStdiofd,
7467 SM_TIME_DEFAULT,
7468 (void *) &sock,
7469 SM_IO_RDWR,
7470 NULL)) == NULL)
7471 {
7472 close(sock);
7473 if (tTd(38, 2))
7474 sm_dprintf("socket_open (%s): failed to create stream: %s\n",
7475 map->map_mname, sm_errstring(errno));
7476 return false;
7477 }
7478
7479 /* Save connection for reuse */
7480 s->s_socketmap = map;
7481 return true;
7482 }
7483
7484 /*
7485 ** SOCKET_MAP_FINDCONN -- find a SOCKET connection to the server
7486 **
7487 ** Cache SOCKET connections based on the connection specifier
7488 ** and PID so we don't have multiple connections open to
7489 ** the same server for different maps. Need a separate connection
7490 ** per PID since a parent process may close the map before the
7491 ** child is done with it.
7492 **
7493 ** Parameters:
7494 ** conn -- SOCKET map connection specifier
7495 **
7496 ** Returns:
7497 ** Symbol table entry for the SOCKET connection.
7498 */
7499
7500 static STAB *
7501 socket_map_findconn(conn)
7502 const char *conn;
7503 {
7504 char *nbuf;
7505 STAB *SM_NONVOLATILE s = NULL;
7506
7507 nbuf = sm_stringf_x("%s%c%d", conn, CONDELSE, (int) CurrentPid);
7508 SM_TRY
7509 s = stab(nbuf, ST_SOCKETMAP, ST_ENTER);
7510 SM_FINALLY
7511 sm_free(nbuf);
7512 SM_END_TRY
7513 return s;
7514 }
7515
7516 /*
7517 ** SOCKET_MAP_CLOSE -- close the socket
7518 */
7519
7520 void
7521 socket_map_close(map)
7522 MAP *map;
7523 {
7524 STAB *s;
7525 MAP *smap;
7526
7527 if (tTd(38, 20))
7528 sm_dprintf("socket_map_close(%s), pid=%ld\n", map->map_file,
7529 (long) CurrentPid);
7530
7531 /* Check if already closed */
7532 if (map->map_db1 == NULL)
7533 {
7534 if (tTd(38, 20))
7535 sm_dprintf("socket_map_close(%s) already closed\n",
7536 map->map_file);
7537 return;
7538 }
7539 sm_io_close((SM_FILE_T *)map->map_db1, SM_TIME_DEFAULT);
7540
7541 /* Mark all the maps that share the connection as closed */
7542 s = socket_map_findconn(map->map_file);
7543 smap = s->s_socketmap;
7544 while (smap != NULL)
7545 {
7546 MAP *next;
7547
7548 if (tTd(38, 2) && smap != map)
7549 sm_dprintf("socket_map_close(%s): closed %s (shared SOCKET connection)\n",
7550 map->map_mname, smap->map_mname);
7551
7552 smap->map_mflags &= ~(MF_OPEN|MF_WRITABLE);
7553 smap->map_db1 = NULL;
7554 next = smap->socket_map_next;
7555 smap->socket_map_next = NULL;
7556 smap = next;
7557 }
7558 s->s_socketmap = NULL;
7559 }
7560
7561 /*
7562 ** SOCKET_MAP_LOOKUP -- look up a datum in a SOCKET table
7563 */
7564
7565 char *
7566 socket_map_lookup(map, name, av, statp)
7567 MAP *map;
7568 char *name;
7569 char **av;
7570 int *statp;
7571 {
7572 unsigned int nettolen, replylen, recvlen;
7573 char *replybuf, *rval, *value, *status, *key;
7574 SM_FILE_T *f;
7575 char keybuf[MAXNAME + 1];
7576
7577 replybuf = NULL;
7578 rval = NULL;
7579 f = (SM_FILE_T *)map->map_db1;
7580 if (tTd(38, 20))
7581 sm_dprintf("socket_map_lookup(%s, %s) %s\n",
7582 map->map_mname, name, map->map_file);
7583
7584 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
7585 {
7586 nettolen = strlen(name);
7587 if (nettolen > sizeof keybuf - 1)
7588 nettolen = sizeof keybuf - 1;
7589 memmove(keybuf, name, nettolen);
7590 keybuf[nettolen] = '\0';
7591 makelower(keybuf);
7592 key = keybuf;
7593 }
7594 else
7595 key = name;
7596
7597 nettolen = strlen(map->map_mname) + 1 + strlen(key);
7598 SM_ASSERT(nettolen > strlen(map->map_mname));
7599 SM_ASSERT(nettolen > strlen(key));
7600 if ((sm_io_fprintf(f, SM_TIME_DEFAULT, "%u:%s %s,",
7601 nettolen, map->map_mname, key) == SM_IO_EOF) ||
7602 (sm_io_flush(f, SM_TIME_DEFAULT) != 0) ||
7603 (sm_io_error(f)))
7604 {
7605 syserr("451 4.3.0 socket_map_lookup(%s): failed to send lookup request",
7606 map->map_mname);
7607 *statp = EX_TEMPFAIL;
7608 goto errcl;
7609 }
7610
7611 if (sm_io_fscanf(f, SM_TIME_DEFAULT, "%9u", &replylen) != 1)
7612 {
7613 syserr("451 4.3.0 socket_map_lookup(%s): failed to read length parameter of reply",
7614 map->map_mname);
7615 *statp = EX_TEMPFAIL;
7616 goto errcl;
7617 }
7618 if (replylen > SOCKETMAP_MAXL)
7619 {
7620 syserr("451 4.3.0 socket_map_lookup(%s): reply too long: %u",
7621 map->map_mname, replylen);
7622 *statp = EX_TEMPFAIL;
7623 goto errcl;
7624 }
7625 if (sm_io_getc(f, SM_TIME_DEFAULT) != ':')
7626 {
7627 syserr("451 4.3.0 socket_map_lookup(%s): missing ':' in reply",
7628 map->map_mname);
7629 *statp = EX_TEMPFAIL;
7630 goto error;
7631 }
7632
7633 replybuf = (char *) sm_malloc(replylen + 1);
7634 if (replybuf == NULL)
7635 {
7636 syserr("451 4.3.0 socket_map_lookup(%s): can't allocate %u bytes",
7637 map->map_mname, replylen + 1);
7638 *statp = EX_OSERR;
7639 goto error;
7640 }
7641
7642 recvlen = sm_io_read(f, SM_TIME_DEFAULT, replybuf, replylen);
7643 if (recvlen < replylen)
7644 {
7645 syserr("451 4.3.0 socket_map_lookup(%s): received only %u of %u reply characters",
7646 map->map_mname, recvlen, replylen);
7647 *statp = EX_TEMPFAIL;
7648 goto errcl;
7649 }
7650 if (sm_io_getc(f, SM_TIME_DEFAULT) != ',')
7651 {
7652 syserr("451 4.3.0 socket_map_lookup(%s): missing ',' in reply",
7653 map->map_mname);
7654 *statp = EX_TEMPFAIL;
7655 goto errcl;
7656 }
7657 status = replybuf;
7658 replybuf[recvlen] = '\0';
7659 value = strchr(replybuf, ' ');
7660 if (value != NULL)
7661 {
7662 *value = '\0';
7663 value++;
7664 }
7665 if (strcmp(status, "OK") == 0)
7666 {
7667 *statp = EX_OK;
7668
7669 /* collect the return value */
7670 if (bitset(MF_MATCHONLY, map->map_mflags))
7671 rval = map_rewrite(map, key, strlen(key), NULL);
7672 else
7673 rval = map_rewrite(map, value, strlen(value), av);
7674 }
7675 else if (strcmp(status, "NOTFOUND") == 0)
7676 {
7677 *statp = EX_NOTFOUND;
7678 if (tTd(38, 20))
7679 sm_dprintf("socket_map_lookup(%s): %s not found\n",
7680 map->map_mname, key);
7681 }
7682 else
7683 {
7684 if (tTd(38, 5))
7685 sm_dprintf("socket_map_lookup(%s, %s): server returned error: type=%s, reason=%s\n",
7686 map->map_mname, key, status,
7687 value ? value : "");
7688 if ((strcmp(status, "TEMP") == 0) ||
7689 (strcmp(status, "TIMEOUT") == 0))
7690 *statp = EX_TEMPFAIL;
7691 else if(strcmp(status, "PERM") == 0)
7692 *statp = EX_UNAVAILABLE;
7693 else
7694 *statp = EX_PROTOCOL;
7695 }
7696
7697 if (replybuf != NULL)
7698 sm_free(replybuf);
7699 return rval;
7700
7701 errcl:
7702 socket_map_close(map);
7703 error:
7704 if (replybuf != NULL)
7705 sm_free(replybuf);
7706 return rval;
7707 }
7708 #endif /* SOCKETMAP */
DragonFly BSD