Lines Matching refs:map
156 map_parseargs(map, ap) in map_parseargs() argument
157 MAP *map; in map_parseargs()
167 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL;
168 map->map_spacesub = SpaceSub; /* default value */
178 map->map_mflags |= MF_APPEND;
182 map->map_app = ++p;
186 map->map_mflags |= MF_DEFER;
197 map->map_timeout = convtime(p, 's');
204 map->map_mflags |= MF_NOFOLDCASE;
210 map->map_keycolnm = p;
214 map->map_mflags |= MF_MATCHONLY;
218 map->map_mflags |= MF_INCLNULL;
219 map->map_mflags &= ~MF_TRY0NULL;
223 map->map_mflags &= ~MF_TRY1NULL;
227 map->map_mflags |= MF_OPTIONAL;
231 map->map_mflags |= MF_KEEPQUOTES;
235 map->map_spacesub = *++p;
239 map->map_tapp = ++p;
243 map->map_mflags |= MF_NODEFER;
249 map->map_valcolnm = p;
254 map->map_coldelim = *p;
260 map->map_coldelim = '\n';
264 map->map_coldelim = '\t';
268 map->map_coldelim = '\\';
274 syserr("Illegal option %c map %s", *p, map->map_mname);
282 if (map->map_app != NULL)
283 map->map_app = newstr(map->map_app);
284 if (map->map_tapp != NULL)
285 map->map_tapp = newstr(map->map_tapp);
286 if (map->map_keycolnm != NULL)
287 map->map_keycolnm = newstr(map->map_keycolnm);
288 if (map->map_valcolnm != NULL)
289 map->map_valcolnm = newstr(map->map_valcolnm);
293 map->map_file = p;
298 map->map_file = newstr(map->map_file);
304 map->map_rebuild = newstr(p);
306 if (map->map_file == NULL &&
307 !bitset(MCF_OPTFILE, map->map_class->map_cflags))
310 map->map_class->map_cname, map->map_mname);
333 map_rewrite(map, s, slen, av) in map_rewrite() argument
334 register MAP *map; in map_rewrite()
383 if (map->map_app != NULL)
384 len += strlen(map->map_app);
436 if (map->map_app != NULL && len > 0)
437 (void) sm_strlcpy(bp, map->map_app, len);
485 register MAP *map; local
491 map = &s->s_map;
492 if (!bitset(MF_VALID, map->map_mflags))
497 map->map_class->map_cname == NULL ? "NULL" :
498 map->map_class->map_cname,
499 map->map_mname == NULL ? "NULL" : map->map_mname,
500 map->map_file == NULL ? "NULL" : map->map_file);
502 if (!bitset(MF_ALIAS, map->map_mflags) ||
503 !bitset(MCF_REBUILDABLE, map->map_class->map_cflags))
511 if (bitset(MF_OPEN, map->map_mflags))
513 map->map_mflags |= MF_CLOSING;
514 map->map_class->map_close(map);
515 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING);
518 (void) rebuildaliases(map, false);
532 openmap(map) in openmap() argument
533 MAP *map; in openmap()
540 if (!bitset(MF_VALID, map->map_mflags))
544 if (bitset(MF_OPEN, map->map_mflags))
557 if (map->map_class->map_open(map, O_RDONLY))
561 map->map_class->map_cname == NULL ? "NULL" :
562 map->map_class->map_cname,
563 map->map_mname == NULL ? "NULL" :
564 map->map_mname,
565 map->map_file == NULL ? "NULL" :
566 map->map_file);
567 map->map_mflags |= MF_OPEN;
568 map->map_pid = CurrentPid;
574 map->map_class->map_cname == NULL ? "NULL" :
575 map->map_class->map_cname,
576 map->map_mname == NULL ? "NULL" :
577 map->map_mname,
578 map->map_file == NULL ? "NULL" :
579 map->map_file,
582 if (!bitset(MF_OPTIONAL, map->map_mflags))
586 map->map_orgclass = map->map_class;
587 map->map_class = &BogusMapClass;
588 map->map_mflags |= MF_OPEN|MF_OPENBOGUS;
589 map->map_pid = CurrentPid;
594 map->map_mflags &= ~MF_VALID;
605 return bitset(MF_OPEN, map->map_mflags);
639 MAP *map; local
645 map = &s->s_map;
656 if (!bitset(MF_VALID, map->map_mflags) ||
657 !bitset(MF_OPEN, map->map_mflags) ||
658 bitset(MF_CLOSING, map->map_mflags) ||
659 map->map_pid != CurrentPid ||
660 (bogus && map->map_class != &BogusMapClass &&
661 !bitset(MCF_NOTPERSIST, map->map_class->map_cflags)))
664 if (map->map_class == &BogusMapClass && map->map_orgclass != NULL &&
665 map->map_orgclass != &BogusMapClass)
666 map->map_class = map->map_orgclass;
669 map->map_mname == NULL ? "NULL" : map->map_mname,
670 map->map_file == NULL ? "NULL" : map->map_file);
672 if (!bitset(MF_OPENBOGUS, map->map_mflags))
674 map->map_mflags |= MF_CLOSING;
675 map->map_class->map_close(map);
677 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_OPENBOGUS|MF_CLOSING);
999 dns_map_open(map, mode) in dns_map_open() argument
1000 MAP *map; in dns_map_open()
1004 sm_dprintf("dns_map_open(%s, %d)\n", map->map_mname, mode);
1037 dns_map_parseargs(map,args) in dns_map_parseargs() argument
1038 MAP *map; in dns_map_parseargs()
1047 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL;
1062 map->map_mname, p);
1067 map->map_mflags |= MF_APPEND;
1071 map->map_app = ++p;
1089 map->map_file = newstr(p);
1103 map->map_timeout = convtime(p, 's');
1110 map->map_mflags |= MF_NOFOLDCASE;
1114 map->map_mflags |= MF_MATCHONLY;
1118 map->map_mflags |= MF_INCLNULL;
1119 map->map_mflags &= ~MF_TRY0NULL;
1123 map->map_mflags &= ~MF_TRY1NULL;
1127 map->map_mflags |= MF_OPTIONAL;
1131 map->map_mflags |= MF_KEEPQUOTES;
1143 map->map_retry = atoi(p);
1147 map->map_mflags |= MF_NODEFER;
1151 map->map_tapp = ++p;
1156 map->map_coldelim = *p;
1162 map->map_coldelim = '\n';
1166 map->map_coldelim = '\t';
1170 map->map_coldelim = '\\';
1178 map->map_sizelimit = atoi(p);
1196 map->map_mname, p);
1207 syserr("dns map %s: missing -R type", map->map_mname);
1208 if (map->map_app != NULL)
1209 map->map_app = newstr(map->map_app);
1210 if (map->map_tapp != NULL)
1211 map->map_tapp = newstr(map->map_tapp);
1219 map->map_db1 = (ARBPTR_T) map_p;
1238 dns_map_lookup(map, name, av, statp) in dns_map_lookup() argument
1239 MAP *map; in dns_map_lookup()
1257 map->map_mname, name);
1259 map_p = (struct dns_map *)(map->map_db1);
1261 if (map->map_file != NULL && *map->map_file != '\0')
1266 len = strlen(map->map_file) + strlen(name) + 2;
1273 (void) sm_strlcpyn(appdomain, len, 3, name, ".", map->map_file);
1275 map->map_timeout, map->map_retry, options);
1281 map->map_timeout, map->map_retry, options);
1377 (map->map_coldelim == '\0' ||
1378 map->map_sizelimit == 1 ||
1379 bitset(MF_MATCHONLY, map->map_mflags)))
1399 vp, map->map_coldelim, value);
1402 if (map->map_sizelimit > 0 &&
1403 ++resnum >= map->map_sizelimit)
1417 truncate_at_delim(vp, PSBUFSIZE / 2, map->map_coldelim);
1424 if (bitset(MF_MATCHONLY, map->map_mflags))
1425 result = map_rewrite(map, name, strlen(name), NULL);
1427 result = map_rewrite(map, vp, vsize, av);
1449 ndbm_map_open(map, mode) in ndbm_map_open() argument
1450 MAP *map; in ndbm_map_open()
1467 map->map_mname, map->map_file, mode);
1468 map->map_lockfd = -1;
1473 map->map_file, ".dir") >= sizeof(dirfile) ||
1475 map->map_file, ".pag") >= sizeof(pagfile))
1478 if (!bitset(MF_OPTIONAL, map->map_mflags))
1480 map->map_mname, map->map_file);
1515 if (!bitset(MF_OPTIONAL, map->map_mflags))
1517 map->map_mname, prob, map->map_file);
1568 map->map_file);
1579 map->map_file);
1592 map->map_file);
1597 map->map_lockfd = dirfd;
1607 dbm = dbm_open(map->map_file, mode, DBMMODE);
1611 if (bitset(MF_ALIAS, map->map_mflags) &&
1612 aliaswait(map, ".pag", false))
1615 if (map->map_lockfd >= 0)
1616 (void) close(map->map_lockfd);
1619 if (!bitset(MF_OPTIONAL, map->map_mflags))
1620 syserr("Cannot open DBM database %s", map->map_file);
1630 if (map->map_lockfd >= 0)
1631 (void) close(map->map_lockfd);
1635 map->map_mname);
1645 if (map->map_lockfd >= 0)
1646 (void) close(map->map_lockfd);
1650 map->map_file);
1654 map->map_db1 = (ARBPTR_T) dbm;
1663 map->map_mtime = st.st_mtime;
1669 (void) lockfile(dfd, map->map_file, ".dir", LOCK_UN);
1671 (void) lockfile(pfd, map->map_file, ".pag", LOCK_UN);
1673 if (bitset(MF_ALIAS, map->map_mflags) &&
1674 !aliaswait(map, ".pag", true))
1679 map->map_mflags |= MF_LOCKED;
1690 map->map_file, sm_errstring(err));
1692 map->map_file, sm_errstring(err));
1697 map->map_file);
1699 map->map_file);
1712 ndbm_map_lookup(map, name, av, statp) in ndbm_map_lookup() argument
1713 MAP *map; in ndbm_map_lookup()
1725 map->map_mname, name);
1729 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
1739 dfd = dbm_dirfno((DBM *) map->map_db1);
1740 if (dfd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
1741 (void) lockfile(dfd, map->map_file, ".dir", LOCK_SH);
1742 pfd = dbm_pagfno((DBM *) map->map_db1);
1744 stbuf.st_mtime > map->map_mtime)
1747 int omode = bitset(map->map_mflags, MF_WRITABLE) ? O_RDWR
1750 if (dfd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
1751 (void) lockfile(dfd, map->map_file, ".dir", LOCK_UN);
1752 map->map_mflags |= MF_CLOSING;
1753 map->map_class->map_close(map);
1754 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING);
1755 if (map->map_class->map_open(map, omode))
1757 map->map_mflags |= MF_OPEN;
1758 map->map_pid = CurrentPid;
1760 map->map_mflags |= MF_WRITABLE;
1765 if (!bitset(MF_OPTIONAL, map->map_mflags))
1770 map->map_orgclass = map->map_class;
1771 map->map_class = &BogusMapClass;
1772 map->map_mflags |= MF_OPEN;
1773 map->map_pid = CurrentPid;
1775 map->map_file);
1781 if (bitset(MF_TRY0NULL, map->map_mflags))
1783 val = dbm_fetch((DBM *) map->map_db1, key);
1785 map->map_mflags &= ~MF_TRY1NULL;
1787 if (val.dptr == NULL && bitset(MF_TRY1NULL, map->map_mflags))
1790 val = dbm_fetch((DBM *) map->map_db1, key);
1792 map->map_mflags &= ~MF_TRY0NULL;
1794 if (dfd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
1795 (void) lockfile(dfd, map->map_file, ".dir", LOCK_UN);
1798 if (bitset(MF_MATCHONLY, map->map_mflags))
1799 return map_rewrite(map, name, strlen(name), NULL);
1801 return map_rewrite(map, val.dptr, val.dsize, av);
1810 ndbm_map_store(map, lhs, rhs) in ndbm_map_store() argument
1811 register MAP *map; in ndbm_map_store()
1822 map->map_mname, lhs, rhs);
1826 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
1839 if (bitset(MF_INCLNULL, map->map_mflags))
1845 status = dbm_store((DBM *) map->map_db1, key, data, DBM_INSERT);
1848 if (!bitset(MF_APPEND, map->map_mflags))
1857 old.dptr = ndbm_map_lookup(map, key.dptr,
1878 status = dbm_store((DBM *) map->map_db1,
1891 ndbm_map_close(map) in ndbm_map_close() argument
1892 register MAP *map; in ndbm_map_close()
1896 map->map_mname, map->map_file, map->map_mflags);
1898 if (bitset(MF_WRITABLE, map->map_mflags))
1904 inclnull = bitset(MF_INCLNULL, map->map_mflags);
1905 map->map_mflags &= ~MF_INCLNULL;
1907 if (strstr(map->map_file, "/yp/") != NULL)
1909 long save_mflags = map->map_mflags;
1911 map->map_mflags |= MF_NOFOLDCASE;
1914 ndbm_map_store(map, "YP_LAST_MODIFIED", buf);
1917 ndbm_map_store(map, "YP_MASTER_NAME", buf);
1919 map->map_mflags = save_mflags;
1923 map->map_mflags |= MF_INCLNULL;
1927 ndbm_map_store(map, "@", "@");
1929 dbm_close((DBM *) map->map_db1);
1933 if (map->map_lockfd >= 0)
1934 (void) close(map->map_lockfd);
1970 bt_map_open(map, mode) in bt_map_open() argument
1971 MAP *map; in bt_map_open()
1986 map->map_mname, map->map_file, mode);
1995 return db_map_open(map, mode, "btree", DB_BTREE, &btinfo);
1999 hash_map_open(map, mode) in hash_map_open() argument
2000 MAP *map; in hash_map_open()
2015 map->map_mname, map->map_file, mode);
2027 return db_map_open(map, mode, "hash", DB_HASH, &hinfo);
2031 db_map_open(map, mode, mapclassname, dbtype, openinfo)
2032 MAP *map;
2057 if (sm_strlcpy(buf, map->map_file, sizeof(buf)) >= sizeof(buf))
2060 if (!bitset(MF_OPTIONAL, map->map_mflags))
2062 map->map_mname, map->map_file);
2071 if (!bitset(MF_OPTIONAL, map->map_mflags))
2073 map->map_mname, map->map_file);
2110 if (!bitset(MF_OPTIONAL, map->map_mflags))
2112 mapclassname, map->map_mname, prob, buf);
2118 map->map_lockfd = -1;
2135 if (!bitset(MF_OPTIONAL, map->map_mflags))
2238 map->map_lockfd = fd;
2245 if (mode == O_RDONLY && bitset(MF_ALIAS, map->map_mflags) &&
2246 aliaswait(map, ".db", false))
2249 if (map->map_lockfd >= 0)
2250 (void) close(map->map_lockfd);
2253 if (!bitset(MF_OPTIONAL, map->map_mflags))
2274 if (map->map_lockfd >= 0)
2275 (void) close(map->map_lockfd);
2283 map->map_mflags |= MF_LOCKED;
2311 map->map_file);
2313 map->map_file);
2318 map->map_db2 = (ARBPTR_T) db;
2327 map->map_mtime = st.st_mtime;
2329 if (mode == O_RDONLY && bitset(MF_ALIAS, map->map_mflags) &&
2330 !aliaswait(map, ".db", true))
2341 db_map_lookup(map, name, av, statp) in db_map_lookup() argument
2342 MAP *map; in db_map_lookup()
2348 register DB *db = (DB *) map->map_db2;
2362 map->map_mname, name);
2364 if (sm_strlcpy(buf, map->map_file, sizeof(buf)) >= sizeof(buf))
2367 if (!bitset(MF_OPTIONAL, map->map_mflags))
2369 map->map_mname, map->map_file);
2382 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
2391 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
2393 if (fd < 0 || fstat(fd, &stbuf) < 0 || stbuf.st_mtime > map->map_mtime)
2396 int omode = bitset(map->map_mflags, MF_WRITABLE) ? O_RDWR
2399 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
2401 map->map_mflags |= MF_CLOSING;
2402 map->map_class->map_close(map);
2403 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING);
2404 if (map->map_class->map_open(map, omode))
2406 map->map_mflags |= MF_OPEN;
2407 map->map_pid = CurrentPid;
2409 map->map_mflags |= MF_WRITABLE;
2410 db = (DB *) map->map_db2;
2415 if (!bitset(MF_OPTIONAL, map->map_mflags))
2420 map->map_orgclass = map->map_class;
2421 map->map_class = &BogusMapClass;
2422 map->map_mflags |= MF_OPEN;
2423 map->map_pid = CurrentPid;
2425 map->map_file);
2432 if (bitset(MF_TRY0NULL, map->map_mflags))
2455 map->map_mflags &= ~MF_TRY1NULL;
2457 if (st != 0 && bitset(MF_TRY1NULL, map->map_mflags))
2481 map->map_mflags &= ~MF_TRY0NULL;
2484 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
2493 if (bitset(MF_MATCHONLY, map->map_mflags))
2494 return map_rewrite(map, name, strlen(name), NULL);
2496 return map_rewrite(map, val.data, val.size, av);
2505 db_map_store(map, lhs, rhs) in db_map_store() argument
2506 register MAP *map; in db_map_store()
2513 register DB *db = map->map_db2;
2521 map->map_mname, lhs, rhs);
2525 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
2538 if (bitset(MF_INCLNULL, map->map_mflags))
2565 if (!bitset(MF_APPEND, map->map_mflags))
2575 old.data = db_map_lookup(map, key.data,
2613 db_map_close(map) in db_map_close() argument
2614 MAP *map; in db_map_close()
2616 register DB *db = map->map_db2;
2620 map->map_mname, map->map_file, map->map_mflags);
2622 if (bitset(MF_WRITABLE, map->map_mflags))
2625 db_map_store(map, "@", "@");
2631 if (map->map_lockfd >= 0)
2632 (void) close(map->map_lockfd);
2652 if (map->map_pid != CurrentPid)
2665 map->map_mname, map->map_file, map->map_mflags);
2725 cdb_map_open(map, mode) in cdb_map_open() argument
2726 MAP *map; in cdb_map_open()
2736 map->map_mname, map->map_file, mode);
2737 map->map_db1 = (ARBPTR_T)NULL;
2738 map->map_db2 = (ARBPTR_T)NULL;
2754 if (!smdb_add_extension(buf, sizeof(buf), map->map_file, CDBext))
2757 if (!bitset(MF_OPTIONAL, map->map_mflags))
2759 map->map_mname, map->map_file);
2769 if (!bitset(MF_OPTIONAL, map->map_mflags))
2771 map->map_mname, map->map_file);
2800 if (!bitset(MF_OPTIONAL, map->map_mflags))
2802 map->map_mname, prob, buf, sm_errstring(status));
2821 if (!bitset(MF_OPTIONAL, map->map_mflags))
2854 if (!bitset(MF_OPTIONAL, map->map_mflags))
2859 map->map_db2 = (ARBPTR_T)cdbmp;
2871 if (!bitset(MF_OPTIONAL, map->map_mflags))
2875 map->map_db1 = (ARBPTR_T)cdbp;
2884 cdb_map_lookup (map, name, av, statp) in cdb_map_lookup() argument
2885 MAP * map; in cdb_map_lookup()
2897 cdbmap = map->map_db1;
2899 sm_dprintf("cdb_map_lookup(%s, %s)\n", map->map_mname, name);
2907 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
2911 if (bitset(MF_TRY0NULL, map->map_mflags))
2915 map->map_mflags &= ~MF_TRY1NULL;
2917 if (st != 1 && bitset(MF_TRY1NULL, map->map_mflags))
2921 map->map_mflags &= ~MF_TRY0NULL;
2936 if (bitset(MF_MATCHONLY, map->map_mflags))
2937 return map_rewrite(map, name, strlen(name), NULL);
2939 return map_rewrite(map, data, dlen, av);
2947 cdb_map_store(map, lhs, rhs) in cdb_map_store() argument
2948 MAP *map; in cdb_map_store()
2958 cdbmp = map->map_db2;
2964 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
2974 if (bitset(MF_INCLNULL, map->map_mflags))
2986 cdb_map_close(map) in cdb_map_close() argument
2987 MAP * map; in cdb_map_close()
2994 cdbp = map->map_db1;
3004 cdbmp = map->map_db2;
3015 cdb_map_store(map, "@", "@");
3018 syserr("cdb: failed to write %s", map->map_file);
3022 syserr("cdb: fsync(%s) failed", map->map_file);
3024 syserr("cdb: close(%s) failed", map->map_file);
3027 if (!smdb_add_extension(cdbfn, sizeof(cdbfn), map->map_file,
3031 map->map_file);
3037 map->map_file);
3066 nis_map_open(map, mode) in nis_map_open() argument
3067 MAP *map; in nis_map_open()
3077 map->map_mname, map->map_file, mode);
3087 p = strchr(map->map_file, '@');
3092 map->map_domain = p;
3095 if (*map->map_file == '\0')
3096 map->map_file = "mail.aliases";
3098 if (map->map_domain == NULL)
3100 yperr = yp_get_default_domain(&map->map_domain);
3103 if (!bitset(MF_OPTIONAL, map->map_mflags))
3105 map->map_file);
3112 yperr = yp_match(map->map_domain, map->map_file, "@", 1,
3116 map->map_domain, map->map_file, yperr_string(yperr));
3130 if (!bitset(MF_ALIAS, map->map_mflags) ||
3131 aliaswait(map, NULL, true))
3136 if (!bitset(MF_OPTIONAL, map->map_mflags))
3139 map->map_file, map->map_domain, yperr_string(yperr));
3152 nis_map_lookup(map, name, av, statp) in nis_map_lookup() argument
3153 MAP *map; in nis_map_lookup()
3167 map->map_mname, name);
3174 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
3178 if (bitset(MF_TRY0NULL, map->map_mflags))
3180 yperr = yp_match(map->map_domain, map->map_file, keybuf, buflen,
3183 map->map_mflags &= ~MF_TRY1NULL;
3185 if (yperr == YPERR_KEY && bitset(MF_TRY1NULL, map->map_mflags))
3189 yperr = yp_match(map->map_domain, map->map_file, keybuf, buflen,
3192 map->map_mflags &= ~MF_TRY0NULL;
3197 map->map_mflags &= ~(MF_VALID|MF_OPEN);
3203 if (bitset(MF_MATCHONLY, map->map_mflags))
3204 result = map_rewrite(map, name, strlen(name), NULL);
3206 result = map_rewrite(map, vp, vsize, av);
3329 nisplus_map_open(map, mode) in nisplus_map_open() argument
3330 MAP *map; in nisplus_map_open()
3339 map->map_mname, map->map_file, mode);
3348 if (*map->map_file == '\0')
3349 map->map_file = "mail_aliases.org_dir";
3351 if (PARTIAL_NAME(map->map_file) && map->map_domain == NULL)
3354 map->map_domain = newstr(nisplus_default_domain());
3357 map->map_file, map->map_domain);
3359 if (!PARTIAL_NAME(map->map_file))
3361 map->map_domain = newstr("");
3362 (void) sm_strlcpy(qbuf, map->map_file, sizeof(qbuf));
3368 map->map_file, ".", map->map_domain);
3394 if (!bitset(MF_OPTIONAL, map->map_mflags))
3396 map->map_file, map->map_domain,
3410 if (!bitset(MF_OPTIONAL, map->map_mflags))
3412 map->map_file, map->map_domain,
3419 if (map->map_keycolnm == NULL)
3420 map->map_keycolnm = newstr(COL_NAME(res,0));
3427 if (strcmp(map->map_keycolnm, COL_NAME(res,i)) == 0)
3434 map->map_file, map->map_keycolnm);
3440 if (map->map_valcolnm == NULL)
3442 map->map_valcolno = max_col - 1;
3448 if (strcmp(map->map_valcolnm, COL_NAME(res,i)) == 0)
3450 map->map_valcolno = i;
3457 map->map_file, map->map_keycolnm);
3468 nisplus_map_lookup(map, name, av, statp) in nisplus_map_lookup() argument
3469 MAP *map; in nisplus_map_lookup()
3484 map->map_mname, name);
3486 if (!bitset(MF_OPEN, map->map_mflags))
3488 if (nisplus_map_open(map, O_RDONLY))
3490 map->map_mflags |= MF_OPEN;
3491 map->map_pid = CurrentPid;
3534 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
3538 if (PARTIAL_NAME(map->map_file))
3540 map->map_keycolnm, search_key, map->map_file,
3541 map->map_domain);
3544 map->map_keycolnm, search_key, map->map_file);
3559 map->map_file, count);
3567 p = ((NIS_RES_OBJECT(result))->EN_col(map->map_valcolno));
3575 if (bitset(MF_MATCHONLY, map->map_mflags))
3576 str = map_rewrite(map, name, strlen(name), NULL);
3578 str = map_rewrite(map, p, vsize, av);
3592 map->map_mflags &= ~(MF_VALID|MF_OPEN);
3792 ldapmap_open(map, mode) in ldapmap_open() argument
3793 MAP *map; in ldapmap_open()
3801 sm_dprintf("ldapmap_open(%s, %d): ", map->map_mname, mode);
3806 strcmp(map->map_mname, "aliases.ldap") == 0)
3822 lmap = (SM_LDAP_STRUCT *) map->map_db1;
3833 s->s_lmap = map;
3855 map->map_orgclass = map->map_class;
3856 map->map_class = &NullMapClass;
3857 map->map_mflags |= MF_OPEN;
3858 map->map_pid = CurrentPid;
3863 if (!sm_ldap_start(map->map_mname, lmap))
3873 if (!bitset(MF_OPTIONAL, map->map_mflags))
3875 if (bitset(MF_NODEFER, map->map_mflags))
3883 id, map->map_mname);
3893 id, map->map_mname);
3900 s->s_lmap = map;
3909 ldapmap_close(map) in ldapmap_close() argument
3910 MAP *map; in ldapmap_close()
3916 sm_dprintf("ldapmap_close(%s)\n", map->map_mname);
3918 lmap = (SM_LDAP_STRUCT *) map->map_db1;
3934 if (tTd(38, 2) && smap != map)
3936 map->map_mname, smap->map_mname);
3987 ldapmap_lookup(map, name, av, statp) in ldapmap_lookup() argument
3988 MAP *map; in ldapmap_lookup()
4012 strcmp(map->map_mname, "aliases.ldap") == 0)
4037 if (bitset(MF_MATCHONLY, map->map_mflags))
4038 result = map_rewrite(map, name, strlen(name), NULL);
4040 result = map_rewrite(map, answer, strlen(answer), av);
4049 lmap = (SM_LDAP_STRUCT *) map->map_db1;
4071 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
4079 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
4088 map->map_mname);
4098 map->map_mname, name);
4116 if (!bitset(MF_OPTIONAL, map->map_mflags))
4123 if (bitset(MF_NODEFER, map->map_mflags))
4125 map->map_mname);
4128 map->map_mname);
4139 ldapmap_close(map);
4148 if (bitset(MF_NODEFER, map->map_mflags))
4150 map->map_mname);
4153 map->map_mname);
4163 if (bitset(MF_SINGLEMATCH, map->map_mflags))
4165 if (bitset(MF_MATCHONLY, map->map_mflags))
4168 if (bitset(MF_SINGLEDN, map->map_mflags))
4176 *statp = sm_ldap_results(lmap, msgid, flags, map->map_coldelim,
4189 ldapmap_close(map);
4195 if (!bitset(MF_OPTIONAL, map->map_mflags))
4197 if (bitset(MF_NODEFER, map->map_mflags))
4199 map->map_mname, name);
4202 map->map_mname, name);
4209 if (vp == NULL && !bitset(MF_MATCHONLY, map->map_mflags))
4216 "ldap=%s, %.100s=>%s", map->map_mname, name,
4218 if (bitset(MF_MATCHONLY, map->map_mflags))
4219 result = map_rewrite(map, name, strlen(name), NULL);
4223 result = map_rewrite(map, vp, strlen(vp), av);
4316 ldapmap_parseargs(map, args) in ldapmap_parseargs() argument
4317 MAP *map; in ldapmap_parseargs()
4332 lmap = (SM_LDAP_STRUCT *) map->map_db1;
4346 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL;
4347 map->map_spacesub = SpaceSub; /* default value */
4350 if (bitset(MF_ALIAS, map->map_mflags))
4353 map->map_coldelim = ',';
4384 map->map_mname);
4408 else if (bitset(MF_FILECLASS, map->map_mflags))
4411 map->map_coldelim = ' ';
4429 map->map_mflags |= MF_APPEND;
4433 map->map_app = ++p;
4437 map->map_mflags |= MF_DEFER;
4441 map->map_mflags |= MF_NOFOLDCASE;
4445 map->map_mflags |= MF_MATCHONLY;
4449 map->map_mflags |= MF_INCLNULL;
4450 map->map_mflags &= ~MF_TRY0NULL;
4454 map->map_mflags &= ~MF_TRY1NULL;
4458 map->map_mflags |= MF_OPTIONAL;
4462 map->map_mflags |= MF_KEEPQUOTES;
4466 map->map_spacesub = *++p;
4470 map->map_tapp = ++p;
4474 map->map_mflags |= MF_NODEFER;
4479 map->map_coldelim = *p;
4485 map->map_coldelim = '\n';
4489 map->map_coldelim = '\t';
4493 map->map_coldelim = '\\';
4500 map->map_mflags |= MF_SINGLEMATCH;
4505 map->map_mflags |= MF_SINGLEDN;
4532 map->map_mname);
4538 map->map_mname);
4553 map->map_mname);
4596 map->map_class->map_cflags))
4603 p, map->map_mname);
4662 map->map_class->map_cflags))
4669 p, map->map_mname);
4697 map->map_class->map_cflags))
4704 p, map->map_mname);
4750 map->map_mname);
4759 map->map_mname);
4780 syserr("Illegal option %c map %s", *p, map->map_mname);
4802 if (map->map_app != NULL)
4803 map->map_app = newstr(ldapmap_dequote(map->map_app));
4804 if (map->map_tapp != NULL)
4805 map->map_tapp = newstr(ldapmap_dequote(map->map_tapp));
4817 map->map_domain = lmap->ldap_host;
4824 map->map_domain = lmap->ldap_uri;
4933 if (bitset(MF_SINGLEMATCH, map->map_mflags))
4944 if (!bitset(MCF_OPTFILE, map->map_class->map_cflags))
4946 syserr("No filter given in map %s", map->map_mname);
4982 map->map_mname, LDAPMAP_MAX_ATTR);
5025 v, map->map_mname);
5069 type, map->map_mname);
5089 map->map_mname);
5095 map->map_mname);
5099 map->map_db1 = (ARBPTR_T) lmap;
5118 MAP map; local
5125 memset(&map, '\0', sizeof(map));
5134 map.map_class = &class->s_mapclass;
5135 map.map_db1 = (ARBPTR_T) LDAPDefaults;
5136 map.map_mname = "O LDAPDefaultSpec";
5138 (void) ldapmap_parseargs(&map, spec);
5141 if (map.map_mflags != (MF_TRY0NULL|MF_TRY1NULL) ||
5142 map.map_spacesub != SpaceSub ||
5143 map.map_app != NULL ||
5144 map.map_tapp != NULL)
5147 SM_FREE(map.map_app);
5148 SM_FREE(map.map_tapp);
5204 ph_map_parseargs(map, args) in ph_map_parseargs() argument
5205 MAP *map; in ph_map_parseargs()
5226 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL;
5236 map->map_mflags |= MF_INCLNULL;
5237 map->map_mflags &= ~MF_TRY0NULL;
5241 map->map_mflags &= ~MF_TRY1NULL;
5245 map->map_mflags |= MF_OPTIONAL;
5249 map->map_mflags |= MF_NOFOLDCASE;
5253 map->map_mflags |= MF_MATCHONLY;
5257 map->map_mflags |= MF_APPEND;
5261 map->map_mflags |= MF_KEEPQUOTES;
5265 map->map_mflags |= MF_NODEFER;
5269 map->map_app = ++p;
5273 map->map_tapp = ++p;
5283 map->map_spacesub = *++p;
5287 map->map_mflags |= MF_DEFER;
5326 if (map->map_app != NULL)
5327 map->map_app = newstr(ph_map_dequote(map->map_app));
5328 if (map->map_tapp != NULL)
5329 map->map_tapp = newstr(ph_map_dequote(map->map_tapp));
5342 map->map_db1 = (ARBPTR_T) pmap;
5351 ph_map_close(map) in ph_map_close() argument
5352 MAP *map; in ph_map_close()
5356 pmap = (PH_MAP_STRUCT *)map->map_db1;
5359 map->map_mname, pmap->ph_fastclose);
5369 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE);
5425 ph_map_open(map, mode) in ph_map_open() argument
5426 MAP *map; in ph_map_open()
5435 sm_dprintf("ph_map_open(%s)\n", map->map_mname);
5446 bitset(MF_DEFER, map->map_mflags))
5450 map->map_mname);
5458 map->map_mflags &= ~MF_DEFER;
5462 pmap = (PH_MAP_STRUCT *)map->map_db1;
5508 ph_map_close(map);
5512 if (bitset(MF_NODEFER, map->map_mflags))
5517 map->map_mname);
5519 else if (!bitset(MF_OPTIONAL, map->map_mflags) && LogLevel > 1)
5522 map->map_mname);
5532 ph_map_lookup(map, key, args, pstat) in ph_map_lookup() argument
5533 MAP *map; in ph_map_lookup()
5543 pmap = (PH_MAP_STRUCT *)map->map_db1;
5584 ph_map_close(map);
5593 if (bitset(MF_MATCHONLY, map->map_mflags))
5594 return map_rewrite(map, key, strlen(key), NULL);
5596 return map_rewrite(map, value, strlen(value), args);
5614 syslog_map_parseargs(map, args) in syslog_map_parseargs() argument
5615 MAP *map; in syslog_map_parseargs()
5631 map->map_mflags |= MF_DEFER;
5636 map->map_spacesub = *++p;
5660 map->map_prio = LOG_INFO;
5668 map->map_prio = LOG_EMERG;
5673 map->map_prio = LOG_ALERT;
5678 map->map_prio = LOG_CRIT;
5683 map->map_prio = LOG_ERR;
5688 map->map_prio = LOG_WARNING;
5693 map->map_prio = LOG_NOTICE;
5698 map->map_prio = LOG_INFO;
5703 map->map_prio = LOG_DEBUG;
5720 syslog_map_lookup(map, string, args, statp) in syslog_map_lookup() argument
5721 MAP *map; in syslog_map_lookup()
5726 char *ptr = map_rewrite(map, string, strlen(string), args);
5732 map->map_mname, map->map_prio, ptr);
5734 sm_syslog(map->map_prio, CurEnv->e_id, "%s", ptr);
5753 dprintf_map_parseargs(map, args) in dprintf_map_parseargs() argument
5754 MAP *map; in dprintf_map_parseargs()
5770 map->map_mflags |= MF_DEFER;
5775 map->map_spacesub = *++p;
5799 map->map_dbg_level = 0;
5805 map->map_mname, map->map_file,
5809 map->map_dbg_level = atoi(dbg_level);
5819 dprintf_map_lookup(map, string, args, statp) in dprintf_map_lookup() argument
5820 MAP *map; in dprintf_map_lookup()
5825 char *ptr = map_rewrite(map, string, strlen(string), args);
5827 if (ptr != NULL && tTd(85, map->map_dbg_level))
5841 hes_map_open(map, mode) in hes_map_open() argument
5842 MAP *map; in hes_map_open()
5847 map->map_mname, map->map_file, mode);
5860 if (!bitset(MF_OPTIONAL, map->map_mflags))
5874 if (!bitset(MF_OPTIONAL, map->map_mflags))
5882 hes_map_lookup(map, name, av, statp) in hes_map_lookup() argument
5883 MAP *map; in hes_map_lookup()
5891 sm_dprintf("hes_map_lookup(%s, %s)\n", map->map_file, name);
5908 hp = hesiod_resolve(HesiodContext, np, map->map_file);
5910 hp = hes_resolve(np, map->map_file);
5920 hp = hesiod_resolve(HesiodContext, name, map->map_file);
5922 hp = hes_resolve(name, map->map_file);
5971 if (bitset(MF_MATCHONLY, map->map_mflags))
5972 return map_rewrite(map, name, strlen(name), NULL);
5974 return map_rewrite(map, hp[0], strlen(hp[0]), av);
5982 hes_map_close(map) in hes_map_close() argument
5983 MAP *map; in hes_map_close()
5986 sm_dprintf("hes_map_close(%s)\n", map->map_file);
6013 ni_map_open(map, mode) in ni_map_open() argument
6014 MAP *map; in ni_map_open()
6019 map->map_mname, map->map_file, mode);
6022 if (*map->map_file == '\0')
6023 map->map_file = NETINFO_DEFAULT_DIR;
6025 if (map->map_valcolnm == NULL)
6026 map->map_valcolnm = NETINFO_DEFAULT_PROPERTY;
6028 if (map->map_coldelim == '\0')
6030 if (bitset(MF_ALIAS, map->map_mflags))
6031 map->map_coldelim = ',';
6032 else if (bitset(MF_FILECLASS, map->map_mflags))
6033 map->map_coldelim = ' ';
6044 ni_map_lookup(map, name, av, statp) in ni_map_lookup() argument
6045 MAP *map; in ni_map_lookup()
6054 sm_dprintf("ni_map_lookup(%s, %s)\n", map->map_mname, name);
6056 propval = ni_propval(map->map_file, map->map_keycolnm, name,
6057 map->map_valcolnm, map->map_coldelim);
6063 if (bitset(MF_MATCHONLY, map->map_mflags))
6064 res = map_rewrite(map, name, strlen(name), NULL);
6066 res = map_rewrite(map, propval, strlen(propval), av);
6139 text_map_open(map, mode) in text_map_open() argument
6140 MAP *map; in text_map_open()
6148 map->map_mname, map->map_file, mode);
6157 if (*map->map_file == '\0')
6160 map->map_mname);
6164 if (map->map_file[0] != '/')
6167 map->map_mname);
6176 if ((i = safefile(map->map_file, RunAsUid, RunAsGid, RunAsUserName,
6185 if (!bitset(MF_OPTIONAL, map->map_mflags))
6187 map->map_mname, map->map_file);
6191 if (map->map_keycolnm == NULL)
6192 map->map_keycolno = 0;
6195 if (!(isascii(*map->map_keycolnm) && isdigit(*map->map_keycolnm)))
6198 map->map_mname, map->map_file,
6199 map->map_keycolnm);
6202 map->map_keycolno = atoi(map->map_keycolnm);
6205 if (map->map_valcolnm == NULL)
6206 map->map_valcolno = 0;
6209 if (!(isascii(*map->map_valcolnm) && isdigit(*map->map_valcolnm)))
6212 map->map_mname, map->map_file,
6213 map->map_valcolnm);
6216 map->map_valcolno = atoi(map->map_valcolnm);
6222 map->map_mname, map->map_file);
6223 if (map->map_coldelim == '\0')
6226 sm_dprintf("%c\n", map->map_coldelim);
6229 map->map_sff = sff;
6239 text_map_lookup(map, name, av, statp) in text_map_lookup() argument
6240 MAP *map; in text_map_lookup()
6252 long sff = map->map_sff;
6259 sm_dprintf("text_map_lookup(%s, %s)\n", map->map_mname, name);
6266 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
6269 f = safefopen(map->map_file, O_RDONLY, FileMode, sff);
6272 map->map_mflags &= ~(MF_VALID|MF_OPEN);
6276 key_idx = map->map_keycolno;
6277 delim = map->map_coldelim;
6302 vp = get_column(linebuf, map->map_valcolno, delim, buf, sizeof(buf));
6310 if (bitset(MF_MATCHONLY, map->map_mflags))
6311 return map_rewrite(map, name, strlen(name), NULL);
6313 return map_rewrite(map, vp, vsize, av);
6389 stab_map_lookup(map, name, av, pstat) in stab_map_lookup() argument
6390 register MAP *map; in stab_map_lookup()
6399 map->map_mname, name);
6404 if (bitset(MF_MATCHONLY, map->map_mflags))
6405 return map_rewrite(map, name, strlen(name), NULL);
6407 return map_rewrite(map, s->s_alias, strlen(s->s_alias), av);
6415 stab_map_store(map, lhs, rhs) in stab_map_store() argument
6416 register MAP *map; in stab_map_store()
6437 stab_map_open(map, mode) in stab_map_open() argument
6438 register MAP *map; in stab_map_open()
6447 map->map_mname, map->map_file, mode);
6461 af = safefopen(map->map_file, O_RDONLY, 0444, sff);
6464 readaliases(map, af, false, false);
6467 map->map_mtime = st.st_mtime;
6484 impl_map_lookup(map, name, av, pstat) in impl_map_lookup() argument
6485 MAP *map; in impl_map_lookup()
6492 map->map_mname, name);
6495 if (bitset(MF_IMPL_HASH, map->map_mflags))
6496 return db_map_lookup(map, name, av, pstat);
6499 if (bitset(MF_IMPL_NDBM, map->map_mflags))
6500 return ndbm_map_lookup(map, name, av, pstat);
6503 if (bitset(MF_IMPL_CDB, map->map_mflags))
6504 return cdb_map_lookup(map, name, av, pstat);
6506 return stab_map_lookup(map, name, av, pstat);
6514 impl_map_store(map, lhs, rhs) in impl_map_store() argument
6515 MAP *map; in impl_map_store()
6521 map->map_mname, lhs, rhs);
6523 if (bitset(MF_IMPL_HASH, map->map_mflags))
6524 db_map_store(map, lhs, rhs);
6527 if (bitset(MF_IMPL_NDBM, map->map_mflags))
6528 ndbm_map_store(map, lhs, rhs);
6531 if (bitset(MF_IMPL_CDB, map->map_mflags))
6532 cdb_map_store(map, lhs, rhs);
6534 stab_map_store(map, lhs, rhs);
6542 impl_map_open(map, mode) in impl_map_open() argument
6543 MAP *map; in impl_map_open()
6550 map->map_mname, map->map_file, mode);
6553 wasopt = bitset(MF_OPTIONAL, map->map_mflags);
6556 map->map_mflags |= MF_OPTIONAL;
6558 map->map_mflags |= MF_IMPL_HASH;
6559 if (hash_map_open(map, mode))
6562 if (mode == O_RDONLY || strstr(map->map_file, "/yp/") == NULL)
6567 map->map_mflags &= ~MF_IMPL_HASH;
6570 map->map_mflags |= MF_IMPL_NDBM;
6571 if (ndbm_map_open(map, mode))
6574 map->map_mflags &= ~MF_IMPL_NDBM;
6578 map->map_mflags |= MF_IMPL_CDB;
6579 if (cdb_map_open(map, mode))
6582 map->map_mflags &= ~MF_IMPL_CDB;
6585 if (!bitset(MF_ALIAS, map->map_mflags))
6590 map->map_file,
6597 if (mode == O_RDONLY && stab_map_open(map, mode))
6602 map->map_mflags &= ~MF_OPTIONAL;
6607 map->map_mflags &= ~MF_OPTIONAL;
6617 impl_map_close(map) in impl_map_close() argument
6618 MAP *map; in impl_map_close()
6622 map->map_mname, map->map_file, map->map_mflags);
6624 if (bitset(MF_IMPL_HASH, map->map_mflags))
6626 db_map_close(map);
6627 map->map_mflags &= ~MF_IMPL_HASH;
6632 if (bitset(MF_IMPL_NDBM, map->map_mflags))
6634 ndbm_map_close(map);
6635 map->map_mflags &= ~MF_IMPL_NDBM;
6639 if (bitset(MF_IMPL_CDB, map->map_mflags))
6641 cdb_map_close(map);
6642 map->map_mflags &= ~MF_IMPL_CDB;
6660 user_map_open(map, mode) in user_map_open() argument
6661 MAP *map; in user_map_open()
6666 map->map_mname, mode);
6675 if (map->map_valcolnm == NULL)
6678 else if (sm_strcasecmp(map->map_valcolnm, "name") == 0)
6679 map->map_valcolno = 1;
6680 else if (sm_strcasecmp(map->map_valcolnm, "passwd") == 0)
6681 map->map_valcolno = 2;
6682 else if (sm_strcasecmp(map->map_valcolnm, "uid") == 0)
6683 map->map_valcolno = 3;
6684 else if (sm_strcasecmp(map->map_valcolnm, "gid") == 0)
6685 map->map_valcolno = 4;
6686 else if (sm_strcasecmp(map->map_valcolnm, "gecos") == 0)
6687 map->map_valcolno = 5;
6688 else if (sm_strcasecmp(map->map_valcolnm, "dir") == 0)
6689 map->map_valcolno = 6;
6690 else if (sm_strcasecmp(map->map_valcolnm, "shell") == 0)
6691 map->map_valcolno = 7;
6695 map->map_mname, map->map_valcolnm);
6708 user_map_lookup(map, key, av, statp) in user_map_lookup() argument
6709 MAP *map; in user_map_lookup()
6719 map->map_mname, key);
6724 if (bitset(MF_MATCHONLY, map->map_mflags))
6725 return map_rewrite(map, key, strlen(key), NULL);
6731 switch (map->map_valcolno)
6767 map->map_mname, map->map_valcolno);
6770 return map_rewrite(map, rwval, strlen(rwval), av);
6782 prog_map_lookup(map, name, av, statp) in prog_map_lookup() argument
6783 MAP *map; in prog_map_lookup()
6800 map->map_mname, name, map->map_file);
6803 argv[i++] = map->map_file;
6804 if (map->map_rebuild != NULL)
6806 (void) sm_strlcpy(buf, map->map_rebuild, sizeof(buf));
6827 if (!bitset(MF_OPTIONAL, map->map_mflags))
6829 map->map_mname, sm_errstring(errno));
6832 map->map_mname, sm_errstring(errno));
6833 map->map_mflags &= ~(MF_VALID|MF_OPEN);
6841 map->map_mname, sm_errstring(errno));
6848 map->map_mname);
6859 if (bitset(MF_MATCHONLY, map->map_mflags))
6860 rval = map_rewrite(map, name, strlen(name), NULL);
6862 rval = map_rewrite(map, buf, strlen(buf), av);
6879 map->map_mname, sm_errstring(errno));
6891 map->map_mname, status);
6919 seq_map_parse(map, ap) in seq_map_parse() argument
6920 MAP *map; in seq_map_parse()
6926 sm_dprintf("seq_map_parse(%s, %s)\n", map->map_mname, ap);
6953 map->map_mname, ap);
6958 map->map_mname, MAXMAPSTACK);
6963 map->map_stack[maxmap++] = &s->s_map;
6982 switch_map_open(map, mode) in switch_map_open() argument
6983 MAP *map; in switch_map_open()
6992 map->map_mname, map->map_file, mode);
6995 nmaps = switch_map_find(map->map_file, maptype, map->map_return);
7013 map->map_mname, ".", maptype[mapno]);
7018 map->map_mname, nbuf);
7022 map->map_stack[mapno] = &s->s_map;
7039 seq_map_close(map)
7040 MAP *map;
7045 sm_dprintf("seq_map_close(%s)\n", map->map_mname);
7049 MAP *mm = map->map_stack[mapno];
7065 seq_map_lookup(map, key, args, pstat) in seq_map_lookup() argument
7066 MAP *map; in seq_map_lookup()
7076 sm_dprintf("seq_map_lookup(%s, %s)\n", map->map_mname, key);
7080 MAP *mm = map->map_stack[mapno];
7088 if (bitset(mapbit, map->map_return[MA_UNAVAIL]))
7101 if (bitset(mapbit, map->map_return[MA_TRYAGAIN]))
7105 else if (bitset(mapbit, map->map_return[MA_NOTFOUND]))
7120 seq_map_store(map, key, val) in seq_map_store() argument
7121 MAP *map; in seq_map_store()
7129 map->map_mname, key, val);
7133 MAP *mm = map->map_stack[mapno];
7142 map->map_mname, key, val);
7150 null_map_open(map, mode) in null_map_open() argument
7151 MAP *map; in null_map_open()
7159 null_map_close(map) in null_map_close() argument
7160 MAP *map; in null_map_close()
7166 null_map_lookup(map, key, args, pstat) in null_map_lookup() argument
7167 MAP *map; in null_map_lookup()
7178 null_map_store(map, key, val) in null_map_store() argument
7179 MAP *map; in null_map_store()
7198 bogus_map_lookup(map, key, args, pstat) in bogus_map_lookup() argument
7199 MAP *map; in bogus_map_lookup()
7219 macro_map_lookup(map, name, av, statp) in macro_map_lookup() argument
7220 MAP *map; in macro_map_lookup()
7228 sm_dprintf("macro_map_lookup(%s, %s)\n", map->map_mname,
7324 regex_map_init(map, ap) in regex_map_init() argument
7325 MAP *map; in regex_map_init()
7337 map->map_mname, ap);
7353 map->map_mflags |= MF_REGEX_NOT;
7357 map->map_mflags |= MF_NOFOLDCASE;
7375 map->map_app = ++p;
7379 map->map_mflags |= MF_MATCHONLY;
7383 map->map_mflags |= MF_KEEPQUOTES;
7387 map->map_spacesub = *++p;
7391 map->map_mflags |= MF_DEFER;
7416 if (map->map_app != NULL)
7417 map->map_app = newstr(map->map_app);
7469 map->map_db1 = (ARBPTR_T) map_p; /* dirty hack */
7474 regex_map_rewrite(map, s, slen, av) in regex_map_rewrite() argument
7475 MAP *map; in regex_map_rewrite()
7480 if (bitset(MF_MATCHONLY, map->map_mflags))
7481 return map_rewrite(map, av[0], strlen(av[0]), NULL);
7483 return map_rewrite(map, s, slen, av);
7487 regex_map_lookup(map, name, av, statp) in regex_map_lookup() argument
7488 MAP *map; in regex_map_lookup()
7506 map_p = (struct regex_map *)(map->map_db1);
7510 if (bitset(MF_REGEX_NOT, map->map_mflags))
7514 return regex_map_rewrite(map, "", (size_t) 0, av);
7620 map->map_mname, name);
7626 return regex_map_rewrite(map, retbuf, strlen(retbuf), av);
7628 return regex_map_rewrite(map, "", (size_t)0, av);
7642 ns_map_t *map; /* XXX ns_ ? */ member
7666 ns_map->map = (ns_map_t *) xalloc(sizeof(*ns_map->map));
7667 memset(ns_map->map, '\0', sizeof(*ns_map->map));
7671 return ns_map->map;
7675 nsd_map_lookup(map, name, av, statp) in nsd_map_lookup() argument
7676 MAP *map; in nsd_map_lookup()
7688 sm_dprintf("nsd_map_lookup(%s, %s)\n", map->map_mname, name);
7695 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
7698 ns_map = ns_map_t_find(map->map_file);
7706 r = ns_lookup(ns_map, NULL, map->map_file, keybuf, NULL,
7734 return map_rewrite(map, buf, strlen(buf), av);
7739 arith_map_lookup(map, name, av, statp) in arith_map_lookup() argument
7740 MAP *map; in arith_map_lookup()
7847 arpa_map_lookup(map, name, av, statp) in arpa_map_lookup() argument
7848 MAP *map; in arpa_map_lookup()
7917 if (bitset(MF_MATCHONLY, map->map_mflags))
7918 rval = map_rewrite(map, name, strlen(name), NULL);
7920 rval = map_rewrite(map, result, strlen(result), av);
7927 setdebug_map_lookup(map, name, av, statp) in setdebug_map_lookup() argument
7928 MAP *map; in setdebug_map_lookup()
7950 setopt_map_lookup(map, name, av, statp) in setopt_map_lookup() argument
7951 MAP *map; in setopt_map_lookup()
8015 socket_map_open(map, mode) in socket_map_open() argument
8016 MAP *map; in socket_map_open()
8033 map->map_mname, map->map_file, mode);
8045 if (*map->map_file == '\0')
8048 map->map_mname);
8052 s = socket_map_findconn(map->map_file);
8056 map->map_db1 = s->s_socketmap->map_db1;
8059 map->socket_map_next = s->s_socketmap;
8060 s->s_socketmap = map;
8075 p = map->map_file;
8097 map->map_mname);
8124 map->map_mname, p);
8145 map->map_mname, p);
8161 map->map_mname, colon);
8171 map->map_mname, colon);
8198 map->map_mname, colon);
8208 map->map_mname, colon);
8217 map->map_mname, colon);
8264 map->map_mname, at);
8271 map->map_mname, at);
8281 map->map_mname, at);
8309 map->map_mname, at, hp->h_addrtype);
8321 map->map_mname);
8334 map->map_mname,
8352 map->map_mname, at, sm_errstring(save_errno));
8380 map->map_mname, at,
8393 map->map_mname, sm_errstring(save_errno));
8408 if ((map->map_db1 = (ARBPTR_T) sm_io_open(SmFtStdiofd,
8417 map->map_mname, sm_errstring(errno));
8421 tmo = map->map_timeout;
8426 sm_io_setinfo(map->map_db1, SM_IO_WHAT_TIMEOUT, &tmo);
8429 s->s_socketmap = map;
8470 socket_map_close(map) in socket_map_close() argument
8471 MAP *map; in socket_map_close()
8477 sm_dprintf("socket_map_close(%s), pid=%ld\n", map->map_file,
8481 if (map->map_db1 == NULL)
8485 map->map_file);
8488 sm_io_close((SM_FILE_T *)map->map_db1, SM_TIME_DEFAULT);
8491 s = socket_map_findconn(map->map_file);
8497 if (tTd(38, 2) && smap != map)
8499 map->map_mname, smap->map_mname);
8515 socket_map_lookup(map, name, av, statp) in socket_map_lookup() argument
8516 MAP *map; in socket_map_lookup()
8529 f = (SM_FILE_T *)map->map_db1;
8532 map->map_mname, name, map->map_file);
8534 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
8547 nettolen = strlen(map->map_mname) + 1 + strlen(key);
8548 SM_ASSERT(nettolen > strlen(map->map_mname));
8551 nettolen, map->map_mname, key) == SM_IO_EOF) ||
8556 map->map_mname);
8566 map->map_mname);
8573 map->map_mname);
8578 map->map_mname, errno);
8586 map->map_mname, replylen);
8593 map->map_mname);
8602 map->map_mname, replylen + 1);
8611 map->map_mname, recvlen, replylen);
8618 map->map_mname);
8635 if (bitset(MF_MATCHONLY, map->map_mflags))
8636 rval = map_rewrite(map, key, strlen(key), NULL);
8638 rval = map_rewrite(map, value, strlen(value), av);
8645 map->map_mname, key);
8651 map->map_mname, key, status,
8667 socket_map_close(map);