Lines Matching refs:map
153 map_parseargs(map, ap) in map_parseargs() argument
154 MAP *map; in map_parseargs()
164 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL;
165 map->map_spacesub = SpaceSub; /* default value */
175 map->map_mflags |= MF_INCLNULL;
176 map->map_mflags &= ~MF_TRY0NULL;
180 map->map_mflags &= ~MF_TRY1NULL;
184 map->map_mflags |= MF_OPTIONAL;
188 map->map_mflags |= MF_NOFOLDCASE;
192 map->map_mflags |= MF_MATCHONLY;
196 map->map_mflags |= MF_APPEND;
200 map->map_mflags |= MF_KEEPQUOTES;
204 map->map_app = ++p;
215 map->map_timeout = convtime(p, 's');
222 map->map_tapp = ++p;
228 map->map_keycolnm = p;
234 map->map_valcolnm = p;
239 map->map_coldelim = *p;
245 map->map_coldelim = '\n';
249 map->map_coldelim = '\t';
253 map->map_coldelim = '\\';
259 map->map_mflags |= MF_NODEFER;
264 map->map_spacesub = *++p;
268 map->map_mflags |= MF_DEFER;
272 syserr("Illegal option %c map %s", *p, map->map_mname);
280 if (map->map_app != NULL)
281 map->map_app = newstr(map->map_app);
282 if (map->map_tapp != NULL)
283 map->map_tapp = newstr(map->map_tapp);
284 if (map->map_keycolnm != NULL)
285 map->map_keycolnm = newstr(map->map_keycolnm);
286 if (map->map_valcolnm != NULL)
287 map->map_valcolnm = newstr(map->map_valcolnm);
291 map->map_file = p;
296 map->map_file = newstr(map->map_file);
302 map->map_rebuild = newstr(p);
304 if (map->map_file == NULL &&
305 !bitset(MCF_OPTFILE, map->map_class->map_cflags))
308 map->map_class->map_cname, map->map_mname);
331 map_rewrite(map, s, slen, av) in map_rewrite() argument
332 register MAP *map; in map_rewrite()
381 if (map->map_app != NULL)
382 len += strlen(map->map_app);
434 if (map->map_app != NULL && len > 0)
435 (void) sm_strlcpy(bp, map->map_app, len);
483 register MAP *map; local
489 map = &s->s_map;
490 if (!bitset(MF_VALID, map->map_mflags))
495 map->map_class->map_cname == NULL ? "NULL" :
496 map->map_class->map_cname,
497 map->map_mname == NULL ? "NULL" : map->map_mname,
498 map->map_file == NULL ? "NULL" : map->map_file);
500 if (!bitset(MF_ALIAS, map->map_mflags) ||
501 !bitset(MCF_REBUILDABLE, map->map_class->map_cflags))
509 if (bitset(MF_OPEN, map->map_mflags))
511 map->map_mflags |= MF_CLOSING;
512 map->map_class->map_close(map);
513 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING);
516 (void) rebuildaliases(map, false);
530 openmap(map) in openmap() argument
531 MAP *map; in openmap()
538 if (!bitset(MF_VALID, map->map_mflags))
542 if (bitset(MF_OPEN, map->map_mflags))
555 if (map->map_class->map_open(map, O_RDONLY))
559 map->map_class->map_cname == NULL ? "NULL" :
560 map->map_class->map_cname,
561 map->map_mname == NULL ? "NULL" :
562 map->map_mname,
563 map->map_file == NULL ? "NULL" :
564 map->map_file);
565 map->map_mflags |= MF_OPEN;
566 map->map_pid = CurrentPid;
572 map->map_class->map_cname == NULL ? "NULL" :
573 map->map_class->map_cname,
574 map->map_mname == NULL ? "NULL" :
575 map->map_mname,
576 map->map_file == NULL ? "NULL" :
577 map->map_file,
580 if (!bitset(MF_OPTIONAL, map->map_mflags))
584 map->map_orgclass = map->map_class;
585 map->map_class = &BogusMapClass;
586 map->map_mflags |= MF_OPEN|MF_OPENBOGUS;
587 map->map_pid = CurrentPid;
592 map->map_mflags &= ~MF_VALID;
603 return bitset(MF_OPEN, map->map_mflags);
638 MAP *map; local
644 map = &s->s_map;
655 if (!bitset(MF_VALID, map->map_mflags) ||
656 !bitset(MF_OPEN, map->map_mflags) ||
657 bitset(MF_CLOSING, map->map_mflags) ||
658 map->map_pid != CurrentPid ||
659 (bogus && map->map_class != &BogusMapClass &&
660 !bitset(MCF_NOTPERSIST, map->map_class->map_cflags)))
663 if (map->map_class == &BogusMapClass && map->map_orgclass != NULL &&
664 map->map_orgclass != &BogusMapClass)
665 map->map_class = map->map_orgclass;
668 map->map_mname == NULL ? "NULL" : map->map_mname,
669 map->map_file == NULL ? "NULL" : map->map_file);
671 if (!bitset(MF_OPENBOGUS, map->map_mflags))
673 map->map_mflags |= MF_CLOSING;
674 map->map_class->map_close(map);
676 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_OPENBOGUS|MF_CLOSING);
992 dns_map_open(map, mode) in dns_map_open() argument
993 MAP *map; in dns_map_open()
997 sm_dprintf("dns_map_open(%s, %d)\n", map->map_mname, mode);
1029 dns_map_parseargs(map,args) in dns_map_parseargs() argument
1030 MAP *map; in dns_map_parseargs()
1038 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL;
1049 map->map_mflags |= MF_INCLNULL;
1050 map->map_mflags &= ~MF_TRY0NULL;
1054 map->map_mflags &= ~MF_TRY1NULL;
1058 map->map_mflags |= MF_OPTIONAL;
1062 map->map_mflags |= MF_NOFOLDCASE;
1066 map->map_mflags |= MF_MATCHONLY;
1070 map->map_mflags |= MF_APPEND;
1074 map->map_mflags |= MF_KEEPQUOTES;
1078 map->map_mflags |= MF_NODEFER;
1082 map->map_app = ++p;
1086 map->map_tapp = ++p;
1097 map->map_timeout = convtime(p, 's');
1106 map->map_retry = atoi(p);
1111 map->map_coldelim = *p;
1117 map->map_coldelim = '\n';
1121 map->map_coldelim = '\t';
1125 map->map_coldelim = '\\';
1133 map->map_sizelimit = atoi(p);
1151 map->map_mname, p);
1170 map->map_file = newstr(p);
1182 syserr("dns map %s: missing -R type", map->map_mname);
1183 if (map->map_app != NULL)
1184 map->map_app = newstr(map->map_app);
1185 if (map->map_tapp != NULL)
1186 map->map_tapp = newstr(map->map_tapp);
1194 map->map_db1 = (ARBPTR_T) map_p;
1213 dns_map_lookup(map, name, av, statp) in dns_map_lookup() argument
1214 MAP *map; in dns_map_lookup()
1231 map->map_mname, name);
1233 map_p = (struct dns_map *)(map->map_db1);
1234 if (map->map_file != NULL && *map->map_file != '\0')
1239 len = strlen(map->map_file) + strlen(name) + 2;
1246 (void) sm_strlcpyn(appdomain, len, 3, name, ".", map->map_file);
1248 map->map_timeout, map->map_retry);
1254 map->map_timeout, map->map_retry);
1344 (map->map_coldelim == '\0' ||
1345 map->map_sizelimit == 1 ||
1346 bitset(MF_MATCHONLY, map->map_mflags)))
1366 vp, map->map_coldelim, value);
1369 if (map->map_sizelimit > 0 &&
1370 ++resnum >= map->map_sizelimit)
1384 truncate_at_delim(vp, PSBUFSIZE / 2, map->map_coldelim);
1391 if (bitset(MF_MATCHONLY, map->map_mflags))
1392 result = map_rewrite(map, name, strlen(name), NULL);
1394 result = map_rewrite(map, vp, vsize, av);
1417 ndbm_map_open(map, mode) in ndbm_map_open() argument
1418 MAP *map; in ndbm_map_open()
1435 map->map_mname, map->map_file, mode);
1436 map->map_lockfd = -1;
1441 map->map_file, ".dir") >= sizeof(dirfile) ||
1443 map->map_file, ".pag") >= sizeof(pagfile))
1446 if (!bitset(MF_OPTIONAL, map->map_mflags))
1448 map->map_mname, map->map_file);
1483 if (!bitset(MF_OPTIONAL, map->map_mflags))
1485 map->map_mname, prob, map->map_file);
1536 map->map_file);
1547 map->map_file);
1560 map->map_file);
1565 map->map_lockfd = dirfd;
1575 dbm = dbm_open(map->map_file, mode, DBMMODE);
1579 if (bitset(MF_ALIAS, map->map_mflags) &&
1580 aliaswait(map, ".pag", false))
1583 if (map->map_lockfd >= 0)
1584 (void) close(map->map_lockfd);
1587 if (!bitset(MF_OPTIONAL, map->map_mflags))
1588 syserr("Cannot open DBM database %s", map->map_file);
1598 if (map->map_lockfd >= 0)
1599 (void) close(map->map_lockfd);
1603 map->map_mname);
1613 if (map->map_lockfd >= 0)
1614 (void) close(map->map_lockfd);
1618 map->map_file);
1622 map->map_db1 = (ARBPTR_T) dbm;
1631 map->map_mtime = st.st_mtime;
1637 (void) lockfile(dfd, map->map_file, ".dir", LOCK_UN);
1639 (void) lockfile(pfd, map->map_file, ".pag", LOCK_UN);
1641 if (bitset(MF_ALIAS, map->map_mflags) &&
1642 !aliaswait(map, ".pag", true))
1647 map->map_mflags |= MF_LOCKED;
1658 map->map_file, sm_errstring(err));
1660 map->map_file, sm_errstring(err));
1665 map->map_file);
1667 map->map_file);
1680 ndbm_map_lookup(map, name, av, statp) in ndbm_map_lookup() argument
1681 MAP *map; in ndbm_map_lookup()
1693 map->map_mname, name);
1697 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
1707 dfd = dbm_dirfno((DBM *) map->map_db1);
1708 if (dfd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
1709 (void) lockfile(dfd, map->map_file, ".dir", LOCK_SH);
1710 pfd = dbm_pagfno((DBM *) map->map_db1);
1712 stbuf.st_mtime > map->map_mtime)
1715 int omode = bitset(map->map_mflags, MF_WRITABLE) ? O_RDWR
1718 if (dfd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
1719 (void) lockfile(dfd, map->map_file, ".dir", LOCK_UN);
1720 map->map_mflags |= MF_CLOSING;
1721 map->map_class->map_close(map);
1722 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING);
1723 if (map->map_class->map_open(map, omode))
1725 map->map_mflags |= MF_OPEN;
1726 map->map_pid = CurrentPid;
1728 map->map_mflags |= MF_WRITABLE;
1733 if (!bitset(MF_OPTIONAL, map->map_mflags))
1738 map->map_orgclass = map->map_class;
1739 map->map_class = &BogusMapClass;
1740 map->map_mflags |= MF_OPEN;
1741 map->map_pid = CurrentPid;
1743 map->map_file);
1749 if (bitset(MF_TRY0NULL, map->map_mflags))
1751 val = dbm_fetch((DBM *) map->map_db1, key);
1753 map->map_mflags &= ~MF_TRY1NULL;
1755 if (val.dptr == NULL && bitset(MF_TRY1NULL, map->map_mflags))
1758 val = dbm_fetch((DBM *) map->map_db1, key);
1760 map->map_mflags &= ~MF_TRY0NULL;
1762 if (dfd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
1763 (void) lockfile(dfd, map->map_file, ".dir", LOCK_UN);
1766 if (bitset(MF_MATCHONLY, map->map_mflags))
1767 return map_rewrite(map, name, strlen(name), NULL);
1769 return map_rewrite(map, val.dptr, val.dsize, av);
1778 ndbm_map_store(map, lhs, rhs) in ndbm_map_store() argument
1779 register MAP *map; in ndbm_map_store()
1790 map->map_mname, lhs, rhs);
1794 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
1807 if (bitset(MF_INCLNULL, map->map_mflags))
1813 status = dbm_store((DBM *) map->map_db1, key, data, DBM_INSERT);
1816 if (!bitset(MF_APPEND, map->map_mflags))
1825 old.dptr = ndbm_map_lookup(map, key.dptr,
1846 status = dbm_store((DBM *) map->map_db1,
1859 ndbm_map_close(map) in ndbm_map_close() argument
1860 register MAP *map; in ndbm_map_close()
1864 map->map_mname, map->map_file, map->map_mflags);
1866 if (bitset(MF_WRITABLE, map->map_mflags))
1872 inclnull = bitset(MF_INCLNULL, map->map_mflags);
1873 map->map_mflags &= ~MF_INCLNULL;
1875 if (strstr(map->map_file, "/yp/") != NULL)
1877 long save_mflags = map->map_mflags;
1879 map->map_mflags |= MF_NOFOLDCASE;
1882 ndbm_map_store(map, "YP_LAST_MODIFIED", buf);
1885 ndbm_map_store(map, "YP_MASTER_NAME", buf);
1887 map->map_mflags = save_mflags;
1891 map->map_mflags |= MF_INCLNULL;
1895 ndbm_map_store(map, "@", "@");
1897 dbm_close((DBM *) map->map_db1);
1901 if (map->map_lockfd >= 0)
1902 (void) close(map->map_lockfd);
1938 bt_map_open(map, mode) in bt_map_open() argument
1939 MAP *map; in bt_map_open()
1954 map->map_mname, map->map_file, mode);
1963 return db_map_open(map, mode, "btree", DB_BTREE, &btinfo);
1967 hash_map_open(map, mode) in hash_map_open() argument
1968 MAP *map; in hash_map_open()
1983 map->map_mname, map->map_file, mode);
1995 return db_map_open(map, mode, "hash", DB_HASH, &hinfo);
1999 db_map_open(map, mode, mapclassname, dbtype, openinfo)
2000 MAP *map;
2025 if (sm_strlcpy(buf, map->map_file, sizeof(buf)) >= sizeof(buf))
2028 if (!bitset(MF_OPTIONAL, map->map_mflags))
2030 map->map_mname, map->map_file);
2039 if (!bitset(MF_OPTIONAL, map->map_mflags))
2041 map->map_mname, map->map_file);
2078 if (!bitset(MF_OPTIONAL, map->map_mflags))
2080 mapclassname, map->map_mname, prob, buf);
2086 map->map_lockfd = -1;
2103 if (!bitset(MF_OPTIONAL, map->map_mflags))
2206 map->map_lockfd = fd;
2213 if (mode == O_RDONLY && bitset(MF_ALIAS, map->map_mflags) &&
2214 aliaswait(map, ".db", false))
2217 if (map->map_lockfd >= 0)
2218 (void) close(map->map_lockfd);
2221 if (!bitset(MF_OPTIONAL, map->map_mflags))
2242 if (map->map_lockfd >= 0)
2243 (void) close(map->map_lockfd);
2251 map->map_mflags |= MF_LOCKED;
2279 map->map_file);
2281 map->map_file);
2286 map->map_db2 = (ARBPTR_T) db;
2295 map->map_mtime = st.st_mtime;
2297 if (mode == O_RDONLY && bitset(MF_ALIAS, map->map_mflags) &&
2298 !aliaswait(map, ".db", true))
2309 db_map_lookup(map, name, av, statp) in db_map_lookup() argument
2310 MAP *map; in db_map_lookup()
2316 register DB *db = (DB *) map->map_db2;
2330 map->map_mname, name);
2332 if (sm_strlcpy(buf, map->map_file, sizeof(buf)) >= sizeof(buf))
2335 if (!bitset(MF_OPTIONAL, map->map_mflags))
2337 map->map_mname, map->map_file);
2350 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
2359 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
2361 if (fd < 0 || fstat(fd, &stbuf) < 0 || stbuf.st_mtime > map->map_mtime)
2364 int omode = bitset(map->map_mflags, MF_WRITABLE) ? O_RDWR
2367 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
2369 map->map_mflags |= MF_CLOSING;
2370 map->map_class->map_close(map);
2371 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING);
2372 if (map->map_class->map_open(map, omode))
2374 map->map_mflags |= MF_OPEN;
2375 map->map_pid = CurrentPid;
2377 map->map_mflags |= MF_WRITABLE;
2378 db = (DB *) map->map_db2;
2383 if (!bitset(MF_OPTIONAL, map->map_mflags))
2388 map->map_orgclass = map->map_class;
2389 map->map_class = &BogusMapClass;
2390 map->map_mflags |= MF_OPEN;
2391 map->map_pid = CurrentPid;
2393 map->map_file);
2400 if (bitset(MF_TRY0NULL, map->map_mflags))
2423 map->map_mflags &= ~MF_TRY1NULL;
2425 if (st != 0 && bitset(MF_TRY1NULL, map->map_mflags))
2449 map->map_mflags &= ~MF_TRY0NULL;
2452 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
2461 if (bitset(MF_MATCHONLY, map->map_mflags))
2462 return map_rewrite(map, name, strlen(name), NULL);
2464 return map_rewrite(map, val.data, val.size, av);
2473 db_map_store(map, lhs, rhs) in db_map_store() argument
2474 register MAP *map; in db_map_store()
2481 register DB *db = map->map_db2;
2489 map->map_mname, lhs, rhs);
2493 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
2506 if (bitset(MF_INCLNULL, map->map_mflags))
2533 if (!bitset(MF_APPEND, map->map_mflags))
2543 old.data = db_map_lookup(map, key.data,
2581 db_map_close(map) in db_map_close() argument
2582 MAP *map; in db_map_close()
2584 register DB *db = map->map_db2;
2588 map->map_mname, map->map_file, map->map_mflags);
2590 if (bitset(MF_WRITABLE, map->map_mflags))
2593 db_map_store(map, "@", "@");
2599 if (map->map_lockfd >= 0)
2600 (void) close(map->map_lockfd);
2620 if (map->map_pid != CurrentPid)
2633 map->map_mname, map->map_file, map->map_mflags);
2651 nis_map_open(map, mode) in nis_map_open() argument
2652 MAP *map; in nis_map_open()
2662 map->map_mname, map->map_file, mode);
2672 p = strchr(map->map_file, '@');
2677 map->map_domain = p;
2680 if (*map->map_file == '\0')
2681 map->map_file = "mail.aliases";
2683 if (map->map_domain == NULL)
2685 yperr = yp_get_default_domain(&map->map_domain);
2688 if (!bitset(MF_OPTIONAL, map->map_mflags))
2690 map->map_file);
2697 yperr = yp_match(map->map_domain, map->map_file, "@", 1,
2701 map->map_domain, map->map_file, yperr_string(yperr));
2715 if (!bitset(MF_ALIAS, map->map_mflags) ||
2716 aliaswait(map, NULL, true))
2721 if (!bitset(MF_OPTIONAL, map->map_mflags))
2724 map->map_file, map->map_domain, yperr_string(yperr));
2737 nis_map_lookup(map, name, av, statp) in nis_map_lookup() argument
2738 MAP *map; in nis_map_lookup()
2752 map->map_mname, name);
2759 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
2763 if (bitset(MF_TRY0NULL, map->map_mflags))
2765 yperr = yp_match(map->map_domain, map->map_file, keybuf, buflen,
2768 map->map_mflags &= ~MF_TRY1NULL;
2770 if (yperr == YPERR_KEY && bitset(MF_TRY1NULL, map->map_mflags))
2774 yperr = yp_match(map->map_domain, map->map_file, keybuf, buflen,
2777 map->map_mflags &= ~MF_TRY0NULL;
2782 map->map_mflags &= ~(MF_VALID|MF_OPEN);
2788 if (bitset(MF_MATCHONLY, map->map_mflags))
2789 result = map_rewrite(map, name, strlen(name), NULL);
2791 result = map_rewrite(map, vp, vsize, av);
2914 nisplus_map_open(map, mode) in nisplus_map_open() argument
2915 MAP *map; in nisplus_map_open()
2924 map->map_mname, map->map_file, mode);
2933 if (*map->map_file == '\0')
2934 map->map_file = "mail_aliases.org_dir";
2936 if (PARTIAL_NAME(map->map_file) && map->map_domain == NULL)
2939 map->map_domain = newstr(nisplus_default_domain());
2942 map->map_file, map->map_domain);
2944 if (!PARTIAL_NAME(map->map_file))
2946 map->map_domain = newstr("");
2947 (void) sm_strlcpy(qbuf, map->map_file, sizeof(qbuf));
2953 map->map_file, ".", map->map_domain);
2979 if (!bitset(MF_OPTIONAL, map->map_mflags))
2981 map->map_file, map->map_domain,
2995 if (!bitset(MF_OPTIONAL, map->map_mflags))
2997 map->map_file, map->map_domain,
3004 if (map->map_keycolnm == NULL)
3005 map->map_keycolnm = newstr(COL_NAME(res,0));
3012 if (strcmp(map->map_keycolnm, COL_NAME(res,i)) == 0)
3019 map->map_file, map->map_keycolnm);
3025 if (map->map_valcolnm == NULL)
3027 map->map_valcolno = max_col - 1;
3033 if (strcmp(map->map_valcolnm, COL_NAME(res,i)) == 0)
3035 map->map_valcolno = i;
3042 map->map_file, map->map_keycolnm);
3053 nisplus_map_lookup(map, name, av, statp) in nisplus_map_lookup() argument
3054 MAP *map; in nisplus_map_lookup()
3069 map->map_mname, name);
3071 if (!bitset(MF_OPEN, map->map_mflags))
3073 if (nisplus_map_open(map, O_RDONLY))
3075 map->map_mflags |= MF_OPEN;
3076 map->map_pid = CurrentPid;
3119 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
3123 if (PARTIAL_NAME(map->map_file))
3125 map->map_keycolnm, search_key, map->map_file,
3126 map->map_domain);
3129 map->map_keycolnm, search_key, map->map_file);
3144 map->map_file, count);
3152 p = ((NIS_RES_OBJECT(result))->EN_col(map->map_valcolno));
3160 if (bitset(MF_MATCHONLY, map->map_mflags))
3161 str = map_rewrite(map, name, strlen(name), NULL);
3163 str = map_rewrite(map, p, vsize, av);
3177 map->map_mflags &= ~(MF_VALID|MF_OPEN);
3377 ldapmap_open(map, mode) in ldapmap_open() argument
3378 MAP *map; in ldapmap_open()
3386 sm_dprintf("ldapmap_open(%s, %d): ", map->map_mname, mode);
3391 strcmp(map->map_mname, "aliases.ldap") == 0)
3407 lmap = (SM_LDAP_STRUCT *) map->map_db1;
3418 s->s_lmap = map;
3440 map->map_orgclass = map->map_class;
3441 map->map_class = &NullMapClass;
3442 map->map_mflags |= MF_OPEN;
3443 map->map_pid = CurrentPid;
3448 if (!sm_ldap_start(map->map_mname, lmap))
3458 if (!bitset(MF_OPTIONAL, map->map_mflags))
3460 if (bitset(MF_NODEFER, map->map_mflags))
3468 id, map->map_mname);
3478 id, map->map_mname);
3485 s->s_lmap = map;
3494 ldapmap_close(map) in ldapmap_close() argument
3495 MAP *map; in ldapmap_close()
3501 sm_dprintf("ldapmap_close(%s)\n", map->map_mname);
3503 lmap = (SM_LDAP_STRUCT *) map->map_db1;
3519 if (tTd(38, 2) && smap != map)
3521 map->map_mname, smap->map_mname);
3572 ldapmap_lookup(map, name, av, statp) in ldapmap_lookup() argument
3573 MAP *map; in ldapmap_lookup()
3597 strcmp(map->map_mname, "aliases.ldap") == 0)
3622 if (bitset(MF_MATCHONLY, map->map_mflags))
3623 result = map_rewrite(map, name, strlen(name), NULL);
3625 result = map_rewrite(map, answer, strlen(answer), av);
3634 lmap = (SM_LDAP_STRUCT *) map->map_db1;
3656 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
3664 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
3673 map->map_mname);
3683 map->map_mname, name);
3701 if (!bitset(MF_OPTIONAL, map->map_mflags))
3708 if (bitset(MF_NODEFER, map->map_mflags))
3710 map->map_mname);
3713 map->map_mname);
3724 ldapmap_close(map);
3733 if (bitset(MF_NODEFER, map->map_mflags))
3735 map->map_mname);
3738 map->map_mname);
3748 if (bitset(MF_SINGLEMATCH, map->map_mflags))
3750 if (bitset(MF_MATCHONLY, map->map_mflags))
3753 if (bitset(MF_SINGLEDN, map->map_mflags))
3761 *statp = sm_ldap_results(lmap, msgid, flags, map->map_coldelim,
3774 ldapmap_close(map);
3780 if (!bitset(MF_OPTIONAL, map->map_mflags))
3782 if (bitset(MF_NODEFER, map->map_mflags))
3784 map->map_mname, name);
3787 map->map_mname, name);
3794 if (vp == NULL && !bitset(MF_MATCHONLY, map->map_mflags))
3801 "ldap=%s, %.100s=>%s", map->map_mname, name,
3803 if (bitset(MF_MATCHONLY, map->map_mflags))
3804 result = map_rewrite(map, name, strlen(name), NULL);
3808 result = map_rewrite(map, vp, strlen(vp), av);
3901 ldapmap_parseargs(map, args) in ldapmap_parseargs() argument
3902 MAP *map; in ldapmap_parseargs()
3917 lmap = (SM_LDAP_STRUCT *) map->map_db1;
3931 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL;
3932 map->map_spacesub = SpaceSub; /* default value */
3935 if (bitset(MF_ALIAS, map->map_mflags))
3938 map->map_coldelim = ',';
3969 map->map_mname);
3993 else if (bitset(MF_FILECLASS, map->map_mflags))
3996 map->map_coldelim = ' ';
4012 map->map_mflags |= MF_APPEND;
4016 map->map_app = ++p;
4020 map->map_mflags |= MF_DEFER;
4024 map->map_mflags |= MF_NOFOLDCASE;
4028 map->map_mflags |= MF_MATCHONLY;
4032 map->map_mflags |= MF_INCLNULL;
4033 map->map_mflags &= ~MF_TRY0NULL;
4037 map->map_mflags &= ~MF_TRY1NULL;
4041 map->map_mflags |= MF_OPTIONAL;
4045 map->map_mflags |= MF_KEEPQUOTES;
4049 map->map_spacesub = *++p;
4053 map->map_tapp = ++p;
4057 map->map_mflags |= MF_NODEFER;
4062 map->map_coldelim = *p;
4068 map->map_coldelim = '\n';
4072 map->map_coldelim = '\t';
4076 map->map_coldelim = '\\';
4083 map->map_mflags |= MF_SINGLEMATCH;
4088 map->map_mflags |= MF_SINGLEDN;
4115 map->map_mname);
4121 map->map_mname);
4136 map->map_mname);
4179 map->map_class->map_cflags))
4186 p, map->map_mname);
4245 map->map_class->map_cflags))
4252 p, map->map_mname);
4280 map->map_class->map_cflags))
4287 p, map->map_mname);
4333 map->map_mname);
4342 map->map_mname);
4355 syserr("Illegal option %c map %s", *p, map->map_mname);
4377 if (map->map_app != NULL)
4378 map->map_app = newstr(ldapmap_dequote(map->map_app));
4379 if (map->map_tapp != NULL)
4380 map->map_tapp = newstr(ldapmap_dequote(map->map_tapp));
4392 map->map_domain = lmap->ldap_host;
4399 map->map_domain = lmap->ldap_uri;
4508 if (bitset(MF_SINGLEMATCH, map->map_mflags))
4519 if (!bitset(MCF_OPTFILE, map->map_class->map_cflags))
4521 syserr("No filter given in map %s", map->map_mname);
4557 map->map_mname, LDAPMAP_MAX_ATTR);
4600 v, map->map_mname);
4644 type, map->map_mname);
4664 map->map_mname);
4670 map->map_mname);
4674 map->map_db1 = (ARBPTR_T) lmap;
4693 MAP map; local
4700 memset(&map, '\0', sizeof(map));
4709 map.map_class = &class->s_mapclass;
4710 map.map_db1 = (ARBPTR_T) LDAPDefaults;
4711 map.map_mname = "O LDAPDefaultSpec";
4713 (void) ldapmap_parseargs(&map, spec);
4716 if (map.map_mflags != (MF_TRY0NULL|MF_TRY1NULL) ||
4717 map.map_spacesub != SpaceSub ||
4718 map.map_app != NULL ||
4719 map.map_tapp != NULL)
4722 SM_FREE_CLR(map.map_app);
4723 SM_FREE_CLR(map.map_tapp);
4779 ph_map_parseargs(map, args) in ph_map_parseargs() argument
4780 MAP *map; in ph_map_parseargs()
4801 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL;
4811 map->map_mflags |= MF_INCLNULL;
4812 map->map_mflags &= ~MF_TRY0NULL;
4816 map->map_mflags &= ~MF_TRY1NULL;
4820 map->map_mflags |= MF_OPTIONAL;
4824 map->map_mflags |= MF_NOFOLDCASE;
4828 map->map_mflags |= MF_MATCHONLY;
4832 map->map_mflags |= MF_APPEND;
4836 map->map_mflags |= MF_KEEPQUOTES;
4840 map->map_mflags |= MF_NODEFER;
4844 map->map_app = ++p;
4848 map->map_tapp = ++p;
4858 map->map_spacesub = *++p;
4862 map->map_mflags |= MF_DEFER;
4901 if (map->map_app != NULL)
4902 map->map_app = newstr(ph_map_dequote(map->map_app));
4903 if (map->map_tapp != NULL)
4904 map->map_tapp = newstr(ph_map_dequote(map->map_tapp));
4917 map->map_db1 = (ARBPTR_T) pmap;
4926 ph_map_close(map) in ph_map_close() argument
4927 MAP *map; in ph_map_close()
4931 pmap = (PH_MAP_STRUCT *)map->map_db1;
4934 map->map_mname, pmap->ph_fastclose);
4944 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE);
5000 ph_map_open(map, mode) in ph_map_open() argument
5001 MAP *map; in ph_map_open()
5010 sm_dprintf("ph_map_open(%s)\n", map->map_mname);
5021 bitset(MF_DEFER, map->map_mflags))
5025 map->map_mname);
5033 map->map_mflags &= ~MF_DEFER;
5037 pmap = (PH_MAP_STRUCT *)map->map_db1;
5083 ph_map_close(map);
5087 if (bitset(MF_NODEFER, map->map_mflags))
5092 map->map_mname);
5094 else if (!bitset(MF_OPTIONAL, map->map_mflags) && LogLevel > 1)
5097 map->map_mname);
5107 ph_map_lookup(map, key, args, pstat) in ph_map_lookup() argument
5108 MAP *map; in ph_map_lookup()
5118 pmap = (PH_MAP_STRUCT *)map->map_db1;
5159 ph_map_close(map);
5168 if (bitset(MF_MATCHONLY, map->map_mflags))
5169 return map_rewrite(map, key, strlen(key), NULL);
5171 return map_rewrite(map, value, strlen(value), args);
5189 syslog_map_parseargs(map, args) in syslog_map_parseargs() argument
5190 MAP *map; in syslog_map_parseargs()
5206 map->map_mflags |= MF_DEFER;
5211 map->map_spacesub = *++p;
5235 map->map_prio = LOG_INFO;
5243 map->map_prio = LOG_EMERG;
5248 map->map_prio = LOG_ALERT;
5253 map->map_prio = LOG_CRIT;
5258 map->map_prio = LOG_ERR;
5263 map->map_prio = LOG_WARNING;
5268 map->map_prio = LOG_NOTICE;
5273 map->map_prio = LOG_INFO;
5278 map->map_prio = LOG_DEBUG;
5295 syslog_map_lookup(map, string, args, statp) in syslog_map_lookup() argument
5296 MAP *map; in syslog_map_lookup()
5301 char *ptr = map_rewrite(map, string, strlen(string), args);
5307 map->map_mname, map->map_prio, ptr);
5309 sm_syslog(map->map_prio, CurEnv->e_id, "%s", ptr);
5328 dprintf_map_parseargs(map, args) in dprintf_map_parseargs() argument
5329 MAP *map; in dprintf_map_parseargs()
5345 map->map_mflags |= MF_DEFER;
5350 map->map_spacesub = *++p;
5374 map->map_dbg_level = 0;
5380 map->map_mname, map->map_file,
5384 map->map_dbg_level = atoi(dbg_level);
5394 dprintf_map_lookup(map, string, args, statp) in dprintf_map_lookup() argument
5395 MAP *map; in dprintf_map_lookup()
5400 char *ptr = map_rewrite(map, string, strlen(string), args);
5402 if (ptr != NULL && tTd(85, map->map_dbg_level))
5416 hes_map_open(map, mode) in hes_map_open() argument
5417 MAP *map; in hes_map_open()
5422 map->map_mname, map->map_file, mode);
5435 if (!bitset(MF_OPTIONAL, map->map_mflags))
5449 if (!bitset(MF_OPTIONAL, map->map_mflags))
5457 hes_map_lookup(map, name, av, statp) in hes_map_lookup() argument
5458 MAP *map; in hes_map_lookup()
5466 sm_dprintf("hes_map_lookup(%s, %s)\n", map->map_file, name);
5483 hp = hesiod_resolve(HesiodContext, np, map->map_file);
5485 hp = hes_resolve(np, map->map_file);
5495 hp = hesiod_resolve(HesiodContext, name, map->map_file);
5497 hp = hes_resolve(name, map->map_file);
5546 if (bitset(MF_MATCHONLY, map->map_mflags))
5547 return map_rewrite(map, name, strlen(name), NULL);
5549 return map_rewrite(map, hp[0], strlen(hp[0]), av);
5557 hes_map_close(map) in hes_map_close() argument
5558 MAP *map; in hes_map_close()
5561 sm_dprintf("hes_map_close(%s)\n", map->map_file);
5588 ni_map_open(map, mode) in ni_map_open() argument
5589 MAP *map; in ni_map_open()
5594 map->map_mname, map->map_file, mode);
5597 if (*map->map_file == '\0')
5598 map->map_file = NETINFO_DEFAULT_DIR;
5600 if (map->map_valcolnm == NULL)
5601 map->map_valcolnm = NETINFO_DEFAULT_PROPERTY;
5603 if (map->map_coldelim == '\0')
5605 if (bitset(MF_ALIAS, map->map_mflags))
5606 map->map_coldelim = ',';
5607 else if (bitset(MF_FILECLASS, map->map_mflags))
5608 map->map_coldelim = ' ';
5619 ni_map_lookup(map, name, av, statp) in ni_map_lookup() argument
5620 MAP *map; in ni_map_lookup()
5629 sm_dprintf("ni_map_lookup(%s, %s)\n", map->map_mname, name);
5631 propval = ni_propval(map->map_file, map->map_keycolnm, name,
5632 map->map_valcolnm, map->map_coldelim);
5638 if (bitset(MF_MATCHONLY, map->map_mflags))
5639 res = map_rewrite(map, name, strlen(name), NULL);
5641 res = map_rewrite(map, propval, strlen(propval), av);
5714 text_map_open(map, mode) in text_map_open() argument
5715 MAP *map; in text_map_open()
5723 map->map_mname, map->map_file, mode);
5732 if (*map->map_file == '\0')
5735 map->map_mname);
5739 if (map->map_file[0] != '/')
5742 map->map_mname);
5751 if ((i = safefile(map->map_file, RunAsUid, RunAsGid, RunAsUserName,
5760 if (!bitset(MF_OPTIONAL, map->map_mflags))
5762 map->map_mname, map->map_file);
5766 if (map->map_keycolnm == NULL)
5767 map->map_keycolno = 0;
5770 if (!(isascii(*map->map_keycolnm) && isdigit(*map->map_keycolnm)))
5773 map->map_mname, map->map_file,
5774 map->map_keycolnm);
5777 map->map_keycolno = atoi(map->map_keycolnm);
5780 if (map->map_valcolnm == NULL)
5781 map->map_valcolno = 0;
5784 if (!(isascii(*map->map_valcolnm) && isdigit(*map->map_valcolnm)))
5787 map->map_mname, map->map_file,
5788 map->map_valcolnm);
5791 map->map_valcolno = atoi(map->map_valcolnm);
5797 map->map_mname, map->map_file);
5798 if (map->map_coldelim == '\0')
5801 sm_dprintf("%c\n", map->map_coldelim);
5804 map->map_sff = sff;
5814 text_map_lookup(map, name, av, statp) in text_map_lookup() argument
5815 MAP *map; in text_map_lookup()
5827 long sff = map->map_sff;
5834 sm_dprintf("text_map_lookup(%s, %s)\n", map->map_mname, name);
5841 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
5844 f = safefopen(map->map_file, O_RDONLY, FileMode, sff);
5847 map->map_mflags &= ~(MF_VALID|MF_OPEN);
5851 key_idx = map->map_keycolno;
5852 delim = map->map_coldelim;
5877 vp = get_column(linebuf, map->map_valcolno, delim, buf, sizeof(buf));
5885 if (bitset(MF_MATCHONLY, map->map_mflags))
5886 return map_rewrite(map, name, strlen(name), NULL);
5888 return map_rewrite(map, vp, vsize, av);
5964 stab_map_lookup(map, name, av, pstat) in stab_map_lookup() argument
5965 register MAP *map; in stab_map_lookup()
5974 map->map_mname, name);
5979 if (bitset(MF_MATCHONLY, map->map_mflags))
5980 return map_rewrite(map, name, strlen(name), NULL);
5982 return map_rewrite(map, s->s_alias, strlen(s->s_alias), av);
5990 stab_map_store(map, lhs, rhs) in stab_map_store() argument
5991 register MAP *map; in stab_map_store()
6012 stab_map_open(map, mode) in stab_map_open() argument
6013 register MAP *map; in stab_map_open()
6022 map->map_mname, map->map_file, mode);
6036 af = safefopen(map->map_file, O_RDONLY, 0444, sff);
6039 readaliases(map, af, false, false);
6042 map->map_mtime = st.st_mtime;
6059 impl_map_lookup(map, name, av, pstat) in impl_map_lookup() argument
6060 MAP *map; in impl_map_lookup()
6067 map->map_mname, name);
6070 if (bitset(MF_IMPL_HASH, map->map_mflags))
6071 return db_map_lookup(map, name, av, pstat);
6074 if (bitset(MF_IMPL_NDBM, map->map_mflags))
6075 return ndbm_map_lookup(map, name, av, pstat);
6077 return stab_map_lookup(map, name, av, pstat);
6085 impl_map_store(map, lhs, rhs) in impl_map_store() argument
6086 MAP *map; in impl_map_store()
6092 map->map_mname, lhs, rhs);
6094 if (bitset(MF_IMPL_HASH, map->map_mflags))
6095 db_map_store(map, lhs, rhs);
6098 if (bitset(MF_IMPL_NDBM, map->map_mflags))
6099 ndbm_map_store(map, lhs, rhs);
6101 stab_map_store(map, lhs, rhs);
6109 impl_map_open(map, mode) in impl_map_open() argument
6110 MAP *map; in impl_map_open()
6115 map->map_mname, map->map_file, mode);
6119 map->map_mflags |= MF_IMPL_HASH;
6120 if (hash_map_open(map, mode))
6123 if (mode == O_RDONLY || strstr(map->map_file, "/yp/") == NULL)
6128 map->map_mflags &= ~MF_IMPL_HASH;
6131 map->map_mflags |= MF_IMPL_NDBM;
6132 if (ndbm_map_open(map, mode))
6137 map->map_mflags &= ~MF_IMPL_NDBM;
6143 map->map_file,
6151 return stab_map_open(map, mode);
6162 impl_map_close(map) in impl_map_close() argument
6163 MAP *map; in impl_map_close()
6167 map->map_mname, map->map_file, map->map_mflags);
6169 if (bitset(MF_IMPL_HASH, map->map_mflags))
6171 db_map_close(map);
6172 map->map_mflags &= ~MF_IMPL_HASH;
6177 if (bitset(MF_IMPL_NDBM, map->map_mflags))
6179 ndbm_map_close(map);
6180 map->map_mflags &= ~MF_IMPL_NDBM;
6197 user_map_open(map, mode) in user_map_open() argument
6198 MAP *map; in user_map_open()
6203 map->map_mname, mode);
6212 if (map->map_valcolnm == NULL)
6215 else if (sm_strcasecmp(map->map_valcolnm, "name") == 0)
6216 map->map_valcolno = 1;
6217 else if (sm_strcasecmp(map->map_valcolnm, "passwd") == 0)
6218 map->map_valcolno = 2;
6219 else if (sm_strcasecmp(map->map_valcolnm, "uid") == 0)
6220 map->map_valcolno = 3;
6221 else if (sm_strcasecmp(map->map_valcolnm, "gid") == 0)
6222 map->map_valcolno = 4;
6223 else if (sm_strcasecmp(map->map_valcolnm, "gecos") == 0)
6224 map->map_valcolno = 5;
6225 else if (sm_strcasecmp(map->map_valcolnm, "dir") == 0)
6226 map->map_valcolno = 6;
6227 else if (sm_strcasecmp(map->map_valcolnm, "shell") == 0)
6228 map->map_valcolno = 7;
6232 map->map_mname, map->map_valcolnm);
6245 user_map_lookup(map, key, av, statp) in user_map_lookup() argument
6246 MAP *map; in user_map_lookup()
6256 map->map_mname, key);
6261 if (bitset(MF_MATCHONLY, map->map_mflags))
6262 return map_rewrite(map, key, strlen(key), NULL);
6268 switch (map->map_valcolno)
6304 map->map_mname, map->map_valcolno);
6307 return map_rewrite(map, rwval, strlen(rwval), av);
6319 prog_map_lookup(map, name, av, statp) in prog_map_lookup() argument
6320 MAP *map; in prog_map_lookup()
6337 map->map_mname, name, map->map_file);
6340 argv[i++] = map->map_file;
6341 if (map->map_rebuild != NULL)
6343 (void) sm_strlcpy(buf, map->map_rebuild, sizeof(buf));
6364 if (!bitset(MF_OPTIONAL, map->map_mflags))
6366 map->map_mname, sm_errstring(errno));
6369 map->map_mname, sm_errstring(errno));
6370 map->map_mflags &= ~(MF_VALID|MF_OPEN);
6378 map->map_mname, sm_errstring(errno));
6385 map->map_mname);
6396 if (bitset(MF_MATCHONLY, map->map_mflags))
6397 rval = map_rewrite(map, name, strlen(name), NULL);
6399 rval = map_rewrite(map, buf, strlen(buf), av);
6416 map->map_mname, sm_errstring(errno));
6428 map->map_mname, status);
6456 seq_map_parse(map, ap) in seq_map_parse() argument
6457 MAP *map; in seq_map_parse()
6463 sm_dprintf("seq_map_parse(%s, %s)\n", map->map_mname, ap);
6490 map->map_mname, ap);
6495 map->map_mname, MAXMAPSTACK);
6500 map->map_stack[maxmap++] = &s->s_map;
6519 switch_map_open(map, mode) in switch_map_open() argument
6520 MAP *map; in switch_map_open()
6529 map->map_mname, map->map_file, mode);
6532 nmaps = switch_map_find(map->map_file, maptype, map->map_return);
6550 map->map_mname, ".", maptype[mapno]);
6555 map->map_mname, nbuf);
6559 map->map_stack[mapno] = &s->s_map;
6576 seq_map_close(map)
6577 MAP *map;
6582 sm_dprintf("seq_map_close(%s)\n", map->map_mname);
6586 MAP *mm = map->map_stack[mapno];
6602 seq_map_lookup(map, key, args, pstat) in seq_map_lookup() argument
6603 MAP *map; in seq_map_lookup()
6613 sm_dprintf("seq_map_lookup(%s, %s)\n", map->map_mname, key);
6617 MAP *mm = map->map_stack[mapno];
6625 if (bitset(mapbit, map->map_return[MA_UNAVAIL]))
6638 if (bitset(mapbit, map->map_return[MA_TRYAGAIN]))
6642 else if (bitset(mapbit, map->map_return[MA_NOTFOUND]))
6657 seq_map_store(map, key, val) in seq_map_store() argument
6658 MAP *map; in seq_map_store()
6666 map->map_mname, key, val);
6670 MAP *mm = map->map_stack[mapno];
6679 map->map_mname, key, val);
6687 null_map_open(map, mode) in null_map_open() argument
6688 MAP *map; in null_map_open()
6696 null_map_close(map) in null_map_close() argument
6697 MAP *map; in null_map_close()
6703 null_map_lookup(map, key, args, pstat) in null_map_lookup() argument
6704 MAP *map; in null_map_lookup()
6715 null_map_store(map, key, val) in null_map_store() argument
6716 MAP *map; in null_map_store()
6735 bogus_map_lookup(map, key, args, pstat) in bogus_map_lookup() argument
6736 MAP *map; in bogus_map_lookup()
6756 macro_map_lookup(map, name, av, statp) in macro_map_lookup() argument
6757 MAP *map; in macro_map_lookup()
6765 sm_dprintf("macro_map_lookup(%s, %s)\n", map->map_mname,
6861 regex_map_init(map, ap) in regex_map_init() argument
6862 MAP *map; in regex_map_init()
6874 map->map_mname, ap);
6890 map->map_mflags |= MF_REGEX_NOT;
6894 map->map_mflags |= MF_NOFOLDCASE;
6912 map->map_app = ++p;
6916 map->map_mflags |= MF_MATCHONLY;
6920 map->map_mflags |= MF_KEEPQUOTES;
6924 map->map_spacesub = *++p;
6928 map->map_mflags |= MF_DEFER;
6953 if (map->map_app != NULL)
6954 map->map_app = newstr(map->map_app);
7006 map->map_db1 = (ARBPTR_T) map_p; /* dirty hack */
7011 regex_map_rewrite(map, s, slen, av) in regex_map_rewrite() argument
7012 MAP *map; in regex_map_rewrite()
7017 if (bitset(MF_MATCHONLY, map->map_mflags))
7018 return map_rewrite(map, av[0], strlen(av[0]), NULL);
7020 return map_rewrite(map, s, slen, av);
7024 regex_map_lookup(map, name, av, statp) in regex_map_lookup() argument
7025 MAP *map; in regex_map_lookup()
7043 map_p = (struct regex_map *)(map->map_db1);
7047 if (bitset(MF_REGEX_NOT, map->map_mflags))
7051 return regex_map_rewrite(map, "", (size_t) 0, av);
7157 map->map_mname, name);
7163 return regex_map_rewrite(map, retbuf, strlen(retbuf), av);
7165 return regex_map_rewrite(map, "", (size_t)0, av);
7179 ns_map_t *map; /* XXX ns_ ? */ member
7203 ns_map->map = (ns_map_t *) xalloc(sizeof(*ns_map->map));
7204 memset(ns_map->map, '\0', sizeof(*ns_map->map));
7208 return ns_map->map;
7212 nsd_map_lookup(map, name, av, statp) in nsd_map_lookup() argument
7213 MAP *map; in nsd_map_lookup()
7225 sm_dprintf("nsd_map_lookup(%s, %s)\n", map->map_mname, name);
7232 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
7235 ns_map = ns_map_t_find(map->map_file);
7243 r = ns_lookup(ns_map, NULL, map->map_file, keybuf, NULL,
7271 return map_rewrite(map, buf, strlen(buf), av);
7276 arith_map_lookup(map, name, av, statp) in arith_map_lookup() argument
7277 MAP *map; in arith_map_lookup()
7384 arpa_map_lookup(map, name, av, statp) in arpa_map_lookup() argument
7385 MAP *map; in arpa_map_lookup()
7454 if (bitset(MF_MATCHONLY, map->map_mflags))
7455 rval = map_rewrite(map, name, strlen(name), NULL);
7457 rval = map_rewrite(map, result, strlen(result), av);
7475 socket_map_open(map, mode) in socket_map_open() argument
7476 MAP *map; in socket_map_open()
7493 map->map_mname, map->map_file, mode);
7505 if (*map->map_file == '\0')
7508 map->map_mname);
7512 s = socket_map_findconn(map->map_file);
7516 map->map_db1 = s->s_socketmap->map_db1;
7519 map->socket_map_next = s->s_socketmap;
7520 s->s_socketmap = map;
7535 p = map->map_file;
7557 map->map_mname);
7584 map->map_mname, p);
7605 map->map_mname, p);
7621 map->map_mname, colon);
7631 map->map_mname, colon);
7658 map->map_mname, colon);
7668 map->map_mname, colon);
7677 map->map_mname, colon);
7724 map->map_mname, at);
7731 map->map_mname, at);
7741 map->map_mname, at);
7769 map->map_mname, at, hp->h_addrtype);
7781 map->map_mname);
7794 map->map_mname,
7812 map->map_mname, at, sm_errstring(save_errno));
7840 map->map_mname, at,
7853 map->map_mname, sm_errstring(save_errno));
7868 if ((map->map_db1 = (ARBPTR_T) sm_io_open(SmFtStdiofd,
7877 map->map_mname, sm_errstring(errno));
7881 tmo = map->map_timeout;
7886 sm_io_setinfo(map->map_db1, SM_IO_WHAT_TIMEOUT, &tmo);
7889 s->s_socketmap = map;
7930 socket_map_close(map) in socket_map_close() argument
7931 MAP *map; in socket_map_close()
7937 sm_dprintf("socket_map_close(%s), pid=%ld\n", map->map_file,
7941 if (map->map_db1 == NULL)
7945 map->map_file);
7948 sm_io_close((SM_FILE_T *)map->map_db1, SM_TIME_DEFAULT);
7951 s = socket_map_findconn(map->map_file);
7957 if (tTd(38, 2) && smap != map)
7959 map->map_mname, smap->map_mname);
7975 socket_map_lookup(map, name, av, statp) in socket_map_lookup() argument
7976 MAP *map; in socket_map_lookup()
7988 f = (SM_FILE_T *)map->map_db1;
7991 map->map_mname, name, map->map_file);
7993 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
8006 nettolen = strlen(map->map_mname) + 1 + strlen(key);
8007 SM_ASSERT(nettolen > strlen(map->map_mname));
8010 nettolen, map->map_mname, key) == SM_IO_EOF) ||
8015 map->map_mname);
8025 map->map_mname);
8030 map->map_mname, errno);
8038 map->map_mname, replylen);
8045 map->map_mname);
8054 map->map_mname, replylen + 1);
8063 map->map_mname, recvlen, replylen);
8070 map->map_mname);
8087 if (bitset(MF_MATCHONLY, map->map_mflags))
8088 rval = map_rewrite(map, key, strlen(key), NULL);
8090 rval = map_rewrite(map, value, strlen(value), av);
8097 map->map_mname, key);
8103 map->map_mname, key, status,
8119 socket_map_close(map);