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