Lines Matching refs:map
109 map_has_chged(map, fn, fd) in map_has_chged() argument
110 MAP *map; in map_has_chged()
122 fn, fd, bitset(MF_CHKED_CHGD, map->map_mflags));
127 if (bitset(MF_CHKED_CHGD, map->map_mflags) && !tTd(38, 101))
129 map->map_mflags |= MF_CHKED_CHGD;
131 if (fd < 0 || fstat(fd, &stbuf) < 0 || stbuf.st_mtime > map->map_mtime)
134 sm_dprintf("reopen map: name=%s, fd=%d\n", map->map_mname, fd);
172 MAP *map; local
181 map = &s->s_map;
182 if (!bitset(MF_VALID, map->map_mflags))
186 map->map_mname, bitset(MF_CHKED_CHGD, map->map_mflags));
187 map->map_mflags &= ~MF_CHKED_CHGD;
328 map_parseargs(map, ap) in map_parseargs() argument
329 MAP *map; in map_parseargs()
339 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL;
340 map->map_spacesub = SpaceSub; /* default value */
350 map->map_mflags |= MF_APPEND;
354 map->map_app = ++p;
358 map->map_mflags |= MF_DEFER;
369 map->map_timeout = convtime(p, 's');
376 map->map_mflags |= MF_NOFOLDCASE;
382 map->map_keycolnm = p;
386 map->map_mflags |= MF_MATCHONLY;
390 map->map_mflags |= MF_INCLNULL;
391 map->map_mflags &= ~MF_TRY0NULL;
395 map->map_mflags &= ~MF_TRY1NULL;
399 map->map_mflags |= MF_OPTIONAL;
403 map->map_mflags |= MF_KEEPQUOTES;
407 map->map_spacesub = *++p;
411 map->map_tapp = ++p;
415 map->map_mflags |= MF_NODEFER;
421 map->map_valcolnm = p;
426 map->map_coldelim = *p;
432 map->map_coldelim = '\n';
436 map->map_coldelim = '\t';
440 map->map_coldelim = '\\';
446 syserr("Illegal option %c map %s", *p, map->map_mname);
454 if (map->map_app != NULL)
455 map->map_app = newstr(map->map_app);
456 if (map->map_tapp != NULL)
457 map->map_tapp = newstr(map->map_tapp);
458 if (map->map_keycolnm != NULL)
459 map->map_keycolnm = newstr(map->map_keycolnm);
460 if (map->map_valcolnm != NULL)
461 map->map_valcolnm = newstr(map->map_valcolnm);
465 map->map_file = p;
470 map->map_file = newstr(map->map_file);
476 map->map_rebuild = newstr(p);
478 if (map->map_file == NULL &&
479 !bitset(MCF_OPTFILE, map->map_class->map_cflags))
482 map->map_class->map_cname, map->map_mname);
505 map_rewrite(map, s, slen, av) in map_rewrite() argument
506 register MAP *map; in map_rewrite()
555 if (map->map_app != NULL)
556 len += strlen(map->map_app);
607 if (map->map_app != NULL && len > 0)
608 (void) sm_strlcpy(bp, map->map_app, len);
612 if (!bitset(MF_KEEPXFMT, map->map_mflags))
717 register MAP *map; local
723 map = &s->s_map;
724 if (!bitset(MF_VALID, map->map_mflags))
729 map->map_class->map_cname == NULL ? "NULL" :
730 map->map_class->map_cname,
731 map->map_mname == NULL ? "NULL" : map->map_mname,
732 map->map_file == NULL ? "NULL" : map->map_file);
734 if (!bitset(MF_ALIAS, map->map_mflags) ||
735 !bitset(MCF_REBUILDABLE, map->map_class->map_cflags))
743 if (bitset(MF_OPEN, map->map_mflags))
745 map->map_mflags |= MF_CLOSING;
746 map->map_class->map_close(map);
747 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING);
750 (void) rebuildaliases(map);
764 openmap(map) in openmap() argument
765 MAP *map; in openmap()
772 if (!bitset(MF_VALID, map->map_mflags))
776 if (bitset(MF_OPEN, map->map_mflags))
789 if (map->map_class->map_open(map, O_RDONLY))
793 map->map_class->map_cname == NULL ? "NULL" :
794 map->map_class->map_cname,
795 map->map_mname == NULL ? "NULL" :
796 map->map_mname,
797 map->map_file == NULL ? "NULL" :
798 map->map_file);
799 map->map_mflags |= MF_OPEN;
800 map->map_pid = CurrentPid;
806 map->map_class->map_cname == NULL ? "NULL" :
807 map->map_class->map_cname,
808 map->map_mname == NULL ? "NULL" :
809 map->map_mname,
810 map->map_file == NULL ? "NULL" :
811 map->map_file,
814 if (!bitset(MF_OPTIONAL, map->map_mflags))
818 map->map_orgclass = map->map_class;
819 map->map_class = &BogusMapClass;
820 map->map_mflags |= MF_OPEN|MF_OPENBOGUS;
821 map->map_pid = CurrentPid;
826 map->map_mflags &= ~MF_VALID;
837 return bitset(MF_OPEN, map->map_mflags);
871 MAP *map; local
877 map = &s->s_map;
888 if (!bitset(MF_VALID, map->map_mflags) ||
889 !bitset(MF_OPEN, map->map_mflags) ||
890 bitset(MF_CLOSING, map->map_mflags) ||
891 map->map_pid != CurrentPid ||
892 (bogus && map->map_class != &BogusMapClass &&
893 !bitset(MCF_NOTPERSIST, map->map_class->map_cflags)))
896 if (map->map_class == &BogusMapClass && map->map_orgclass != NULL &&
897 map->map_orgclass != &BogusMapClass)
898 map->map_class = map->map_orgclass;
901 map->map_mname == NULL ? "NULL" : map->map_mname,
902 map->map_file == NULL ? "NULL" : map->map_file);
904 if (!bitset(MF_OPENBOGUS, map->map_mflags))
906 map->map_mflags |= MF_CLOSING;
907 map->map_class->map_close(map);
909 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_OPENBOGUS|MF_CLOSING|MF_CHKED_CHGD);
1231 dns_map_open(map, mode) in dns_map_open() argument
1232 MAP *map; in dns_map_open()
1236 sm_dprintf("dns_map_open(%s, %d)\n", map->map_mname, mode);
1269 dns_map_parseargs(map,args) in dns_map_parseargs() argument
1270 MAP *map; in dns_map_parseargs()
1279 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL;
1294 map->map_mname, p);
1299 map->map_mflags |= MF_APPEND;
1303 map->map_app = ++p;
1321 map->map_file = newstr(p);
1335 map->map_timeout = convtime(p, 's');
1342 map->map_mflags |= MF_NOFOLDCASE;
1346 map->map_mflags |= MF_MATCHONLY;
1350 map->map_mflags |= MF_INCLNULL;
1351 map->map_mflags &= ~MF_TRY0NULL;
1355 map->map_mflags &= ~MF_TRY1NULL;
1359 map->map_mflags |= MF_OPTIONAL;
1363 map->map_mflags |= MF_KEEPQUOTES;
1375 map->map_retry = atoi(p);
1379 map->map_mflags |= MF_NODEFER;
1383 map->map_tapp = ++p;
1388 map->map_coldelim = *p;
1394 map->map_coldelim = '\n';
1398 map->map_coldelim = '\t';
1402 map->map_coldelim = '\\';
1410 map->map_sizelimit = atoi(p);
1428 map->map_mname, p);
1439 syserr("dns map %s: missing -R type", map->map_mname);
1440 if (map->map_app != NULL)
1441 map->map_app = newstr(map->map_app);
1442 if (map->map_tapp != NULL)
1443 map->map_tapp = newstr(map->map_tapp);
1451 map->map_db1 = (ARBPTR_T) map_p;
1470 dns_map_lookup(map, name, av, statp) in dns_map_lookup() argument
1471 MAP *map; in dns_map_lookup()
1489 map->map_mname, name);
1491 map_p = (struct dns_map *)(map->map_db1);
1493 if (map->map_file != NULL && *map->map_file != '\0')
1498 len = strlen(map->map_file) + strlen(name) + 2;
1505 (void) sm_strlcpyn(appdomain, len, 3, name, ".", map->map_file);
1507 map->map_timeout, map->map_retry, options);
1513 map->map_timeout, map->map_retry, options);
1609 (map->map_coldelim == '\0' ||
1610 map->map_sizelimit == 1 ||
1611 bitset(MF_MATCHONLY, map->map_mflags)))
1631 vp, map->map_coldelim, value);
1634 if (map->map_sizelimit > 0 &&
1635 ++resnum >= map->map_sizelimit)
1649 truncate_at_delim(vp, PSBUFSIZE / 2, map->map_coldelim);
1656 if (bitset(MF_MATCHONLY, map->map_mflags))
1657 result = map_rewrite(map, name, strlen(name), NULL);
1659 result = map_rewrite(map, vp, vsize, av);
1680 ndbm_map_open(map, mode) in ndbm_map_open() argument
1681 MAP *map; in ndbm_map_open()
1698 map->map_mname, map->map_file, mode);
1699 map->map_lockfd = -1;
1704 map->map_file, ".dir") >= sizeof(dirfile) ||
1706 map->map_file, ".pag") >= sizeof(pagfile))
1709 if (!bitset(MF_OPTIONAL, map->map_mflags))
1711 map->map_mname, map->map_file);
1746 if (!bitset(MF_OPTIONAL, map->map_mflags))
1748 map->map_mname, prob, map->map_file);
1799 map->map_file);
1810 map->map_file);
1823 map->map_file);
1828 map->map_lockfd = dirfd;
1838 dbm = dbm_open(map->map_file, mode, DBMMODE);
1842 if (bitset(MF_ALIAS, map->map_mflags) &&
1843 aliaswait(map, ".pag", false))
1846 if (map->map_lockfd >= 0)
1847 (void) close(map->map_lockfd);
1850 if (!bitset(MF_OPTIONAL, map->map_mflags))
1851 syserr("Cannot open DBM database %s", map->map_file);
1861 if (map->map_lockfd >= 0)
1862 (void) close(map->map_lockfd);
1866 map->map_mname);
1876 if (map->map_lockfd >= 0)
1877 (void) close(map->map_lockfd);
1881 map->map_file);
1885 map->map_db1 = (ARBPTR_T) dbm;
1894 map->map_mtime = st.st_mtime;
1900 (void) lockfile(dfd, map->map_file, ".dir", LOCK_UN);
1902 (void) lockfile(pfd, map->map_file, ".pag", LOCK_UN);
1904 if (bitset(MF_ALIAS, map->map_mflags) &&
1905 !aliaswait(map, ".pag", true))
1910 map->map_mflags |= MF_LOCKED;
1911 mapchown(map->map_file, dfd, pfd, map->map_file);
1922 ndbm_map_lookup(map, name, av, statp) in ndbm_map_lookup() argument
1923 MAP *map; in ndbm_map_lookup()
1938 map->map_mname, name);
1942 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
1952 if (!smdb_add_extension(buf, sizeof(buf), map->map_file, "pag"))
1955 if (!bitset(MF_OPTIONAL, map->map_mflags))
1957 map->map_mname, map->map_file);
1963 dfd = dbm_dirfno((DBM *) map->map_db1);
1964 if (dfd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
1965 (void) lockfile(dfd, map->map_file, ".dir", LOCK_SH);
1966 pfd = dbm_pagfno((DBM *) map->map_db1);
1968 if (map_has_chged(map, fn, pfd))
1971 int omode = bitset(map->map_mflags, MF_WRITABLE) ? O_RDWR
1974 if (dfd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
1975 (void) lockfile(dfd, map->map_file, ".dir", LOCK_UN);
1976 map->map_mflags |= MF_CLOSING;
1977 map->map_class->map_close(map);
1978 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING);
1979 if (map->map_class->map_open(map, omode))
1981 map->map_mflags |= MF_OPEN;
1982 map->map_pid = CurrentPid;
1984 map->map_mflags |= MF_WRITABLE;
1989 if (!bitset(MF_OPTIONAL, map->map_mflags))
1994 map->map_orgclass = map->map_class;
1995 map->map_class = &BogusMapClass;
1996 map->map_mflags |= MF_OPEN;
1997 map->map_pid = CurrentPid;
1999 map->map_file);
2005 if (bitset(MF_TRY0NULL, map->map_mflags))
2007 val = dbm_fetch((DBM *) map->map_db1, key);
2009 map->map_mflags &= ~MF_TRY1NULL;
2011 if (val.dptr == NULL && bitset(MF_TRY1NULL, map->map_mflags))
2014 val = dbm_fetch((DBM *) map->map_db1, key);
2016 map->map_mflags &= ~MF_TRY0NULL;
2018 if (dfd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
2019 (void) lockfile(dfd, map->map_file, ".dir", LOCK_UN);
2022 if (bitset(MF_MATCHONLY, map->map_mflags))
2023 return map_rewrite(map, name, strlen(name), NULL);
2025 return map_rewrite(map, val.dptr, val.dsize, av);
2034 ndbm_map_store(map, lhs, rhs) in ndbm_map_store() argument
2035 register MAP *map; in ndbm_map_store()
2046 map->map_mname, lhs, rhs);
2050 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
2063 if (bitset(MF_INCLNULL, map->map_mflags))
2069 status = dbm_store((DBM *) map->map_db1, key, data, DBM_INSERT);
2072 if (!bitset(MF_APPEND, map->map_mflags))
2081 old.dptr = ndbm_map_lookup(map, key.dptr,
2101 status = dbm_store((DBM *) map->map_db1,
2114 ndbm_map_close(map) in ndbm_map_close() argument
2115 register MAP *map; in ndbm_map_close()
2119 map->map_mname, map->map_file, map->map_mflags);
2121 if (bitset(MF_WRITABLE, map->map_mflags))
2127 inclnull = bitset(MF_INCLNULL, map->map_mflags);
2128 map->map_mflags &= ~MF_INCLNULL;
2130 if (strstr(map->map_file, "/yp/") != NULL)
2132 long save_mflags = map->map_mflags;
2134 map->map_mflags |= MF_NOFOLDCASE;
2137 ndbm_map_store(map, "YP_LAST_MODIFIED", buf);
2140 ndbm_map_store(map, "YP_MASTER_NAME", buf);
2142 map->map_mflags = save_mflags;
2146 map->map_mflags |= MF_INCLNULL;
2150 ndbm_map_store(map, "@", "@");
2152 dbm_close((DBM *) map->map_db1);
2156 if (map->map_lockfd >= 0)
2157 (void) close(map->map_lockfd);
2193 bt_map_open(map, mode) in bt_map_open() argument
2194 MAP *map; in bt_map_open()
2209 map->map_mname, map->map_file, mode);
2218 return db_map_open(map, mode, "btree", DB_BTREE, &btinfo);
2222 hash_map_open(map, mode) in hash_map_open() argument
2223 MAP *map; in hash_map_open()
2238 map->map_mname, map->map_file, mode);
2250 return db_map_open(map, mode, "hash", DB_HASH, &hinfo);
2254 db_map_open(map, mode, mapclassname, dbtype, openinfo)
2255 MAP *map;
2280 if (!smdb_add_extension(buf, sizeof(buf), map->map_file, "db"))
2283 if (!bitset(MF_OPTIONAL, map->map_mflags))
2285 map->map_mname, map->map_file);
2321 if (!bitset(MF_OPTIONAL, map->map_mflags))
2323 mapclassname, map->map_mname, prob, buf);
2329 map->map_lockfd = -1;
2346 if (!bitset(MF_OPTIONAL, map->map_mflags))
2449 map->map_lockfd = fd;
2456 if (mode == O_RDONLY && bitset(MF_ALIAS, map->map_mflags) &&
2457 aliaswait(map, ".db", false))
2460 if (map->map_lockfd >= 0)
2461 (void) close(map->map_lockfd);
2464 if (!bitset(MF_OPTIONAL, map->map_mflags))
2485 if (map->map_lockfd >= 0)
2486 (void) close(map->map_lockfd);
2494 map->map_mflags |= MF_LOCKED;
2504 mapchown(map->map_file, fd, -1, buf);
2507 map->map_db2 = (ARBPTR_T) db;
2516 map->map_mtime = st.st_mtime;
2530 if (mode == O_RDONLY && bitset(MF_ALIAS, map->map_mflags) &&
2531 !aliaswait(map, ".db", true))
2542 db_map_lookup(map, name, av, statp) in db_map_lookup() argument
2543 MAP *map; in db_map_lookup()
2549 register DB *db = (DB *) map->map_db2;
2561 map->map_mname, name);
2562 if (!smdb_add_extension(buf, sizeof(buf), map->map_file, "db"))
2565 if (!bitset(MF_OPTIONAL, map->map_mflags))
2567 map->map_mname, map->map_file);
2577 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
2586 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
2588 if (map_has_chged(map, buf, fd))
2591 int omode = bitset(map->map_mflags, MF_WRITABLE) ? O_RDWR
2594 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
2596 map->map_mflags |= MF_CLOSING;
2597 map->map_class->map_close(map);
2598 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING);
2599 if (map->map_class->map_open(map, omode))
2601 map->map_mflags |= MF_OPEN;
2602 map->map_pid = CurrentPid;
2604 map->map_mflags |= MF_WRITABLE;
2605 db = (DB *) map->map_db2;
2610 if (!bitset(MF_OPTIONAL, map->map_mflags))
2615 map->map_orgclass = map->map_class;
2616 map->map_class = &BogusMapClass;
2617 map->map_mflags |= MF_OPEN;
2618 map->map_pid = CurrentPid;
2620 map->map_file);
2627 if (bitset(MF_TRY0NULL, map->map_mflags))
2650 map->map_mflags &= ~MF_TRY1NULL;
2652 if (st != 0 && bitset(MF_TRY1NULL, map->map_mflags))
2676 map->map_mflags &= ~MF_TRY0NULL;
2679 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
2688 if (bitset(MF_MATCHONLY, map->map_mflags))
2689 return map_rewrite(map, name, strlen(name), NULL);
2691 return map_rewrite(map, val.data, val.size, av);
2700 db_map_store(map, lhs, rhs) in db_map_store() argument
2701 register MAP *map; in db_map_store()
2708 register DB *db = map->map_db2;
2716 map->map_mname, lhs, rhs);
2720 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
2733 if (bitset(MF_INCLNULL, map->map_mflags))
2760 if (!bitset(MF_APPEND, map->map_mflags))
2770 old.data = db_map_lookup(map, key.data,
2807 db_map_close(map) in db_map_close() argument
2808 MAP *map; in db_map_close()
2810 register DB *db = map->map_db2;
2814 map->map_mname, map->map_file, map->map_mflags);
2816 if (bitset(MF_WRITABLE, map->map_mflags))
2819 db_map_store(map, "@", "@");
2825 if (map->map_lockfd >= 0)
2826 (void) close(map->map_lockfd);
2846 if (map->map_pid != CurrentPid)
2859 map->map_mname, map->map_file, map->map_mflags);
2869 cdb_map_open(map, mode) in cdb_map_open() argument
2870 MAP *map; in cdb_map_open()
2881 map->map_mname, map->map_file,
2883 map->map_db1 = (ARBPTR_T)NULL;
2884 map->map_db2 = (ARBPTR_T)NULL;
2896 if (!smdb_add_extension(buf, sizeof(buf), map->map_file, CDBext))
2899 if (!bitset(MF_OPTIONAL, map->map_mflags))
2901 map->map_mname, map->map_file);
2914 map->map_mflags |= MF_LOCKED;
2935 if (!bitset(MF_OPTIONAL, map->map_mflags))
2937 map->map_mname, prob, buf, sm_errstring(status));
2956 if (!bitset(MF_OPTIONAL, map->map_mflags))
2983 map->map_lockfd = fd;
2986 map->map_mtime = st.st_mtime;
2998 if (!bitset(MF_OPTIONAL, map->map_mflags))
3003 map->map_db2 = (ARBPTR_T)cdbmp;
3004 mapchown(map->map_file, fd, -1, buf);
3024 if (!bitset(MF_OPTIONAL, map->map_mflags))
3029 map->map_db1 = (ARBPTR_T)cdbp;
3030 if (bitset(MF_ALIAS, map->map_mflags) && !aliaswait(map, CDBEXT, true))
3039 cdb_map_lookup(map, name, av, statp) in cdb_map_lookup() argument
3040 MAP *map; in cdb_map_lookup()
3053 cdbmap = map->map_db1;
3055 sm_dprintf("cdb_map_lookup(%s, %s)\n", map->map_mname, name);
3057 if (!smdb_add_extension(buf, sizeof(buf), map->map_file, CDBext))
3060 if (!bitset(MF_OPTIONAL, map->map_mflags))
3062 map->map_mname, map->map_file);
3072 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
3076 fd = map->map_lockfd;
3077 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
3079 if (map_has_chged(map, buf, fd))
3082 int omode = bitset(map->map_mflags, MF_WRITABLE) ? O_RDWR
3085 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
3087 map->map_mflags |= MF_CLOSING;
3088 map->map_class->map_close(map);
3089 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE|MF_CLOSING);
3090 if (map->map_class->map_open(map, omode))
3092 map->map_mflags |= MF_OPEN;
3094 map->map_mflags |= MF_WRITABLE;
3095 cdbmap = map->map_db1;
3100 if (!bitset(MF_OPTIONAL, map->map_mflags))
3105 map->map_orgclass = map->map_class;
3106 map->map_class = &BogusMapClass;
3107 map->map_mflags |= MF_OPEN;
3109 map->map_file);
3116 if (bitset(MF_TRY0NULL, map->map_mflags))
3120 map->map_mflags &= ~MF_TRY1NULL;
3122 if (st != 1 && bitset(MF_TRY1NULL, map->map_mflags))
3126 map->map_mflags &= ~MF_TRY0NULL;
3128 if (fd >= 0 && !bitset(MF_LOCKED, map->map_mflags))
3143 if (bitset(MF_MATCHONLY, map->map_mflags))
3144 return map_rewrite(map, name, strlen(name), NULL);
3146 return map_rewrite(map, data, dlen, av);
3154 cdb_map_store(map, lhs, rhs) in cdb_map_store() argument
3155 MAP *map; in cdb_map_store()
3165 cdbmp = map->map_db2;
3171 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
3181 if (bitset(MF_INCLNULL, map->map_mflags))
3193 cdb_map_close(map) in cdb_map_close() argument
3194 MAP * map; in cdb_map_close()
3201 cdbp = map->map_db1;
3210 cdbmp = map->map_db2;
3219 cdb_map_store(map, "@", "@");
3223 map->map_file);
3227 syserr("cdb: fsync(%s) failed", map->map_file);
3229 syserr("cdb: close(%s) failed", map->map_file);
3254 nis_map_open(map, mode) in nis_map_open() argument
3255 MAP *map; in nis_map_open()
3265 map->map_mname, map->map_file, mode);
3275 p = strchr(map->map_file, '@');
3280 map->map_domain = p;
3283 if (*map->map_file == '\0')
3284 map->map_file = "mail.aliases";
3286 if (map->map_domain == NULL)
3288 yperr = yp_get_default_domain(&map->map_domain);
3291 if (!bitset(MF_OPTIONAL, map->map_mflags))
3293 map->map_file);
3300 yperr = yp_match(map->map_domain, map->map_file, "@", 1,
3304 map->map_domain, map->map_file, yperr_string(yperr));
3317 if (!bitset(MF_ALIAS, map->map_mflags) ||
3318 aliaswait(map, NULL, true))
3323 if (!bitset(MF_OPTIONAL, map->map_mflags))
3326 map->map_file, map->map_domain, yperr_string(yperr));
3339 nis_map_lookup(map, name, av, statp) in nis_map_lookup() argument
3340 MAP *map; in nis_map_lookup()
3354 map->map_mname, name);
3361 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
3365 if (bitset(MF_TRY0NULL, map->map_mflags))
3367 yperr = yp_match(map->map_domain, map->map_file, keybuf, buflen,
3370 map->map_mflags &= ~MF_TRY1NULL;
3372 if (yperr == YPERR_KEY && bitset(MF_TRY1NULL, map->map_mflags))
3376 yperr = yp_match(map->map_domain, map->map_file, keybuf, buflen,
3379 map->map_mflags &= ~MF_TRY0NULL;
3384 map->map_mflags &= ~(MF_VALID|MF_OPEN);
3389 if (bitset(MF_MATCHONLY, map->map_mflags))
3390 result = map_rewrite(map, name, strlen(name), NULL);
3392 result = map_rewrite(map, vp, vsize, av);
3513 nisplus_map_open(map, mode) in nisplus_map_open() argument
3514 MAP *map; in nisplus_map_open()
3523 map->map_mname, map->map_file, mode);
3532 if (*map->map_file == '\0')
3533 map->map_file = "mail_aliases.org_dir";
3535 if (PARTIAL_NAME(map->map_file) && map->map_domain == NULL)
3538 map->map_domain = newstr(nisplus_default_domain());
3541 map->map_file, map->map_domain);
3543 if (!PARTIAL_NAME(map->map_file))
3545 map->map_domain = newstr("");
3546 (void) sm_strlcpy(qbuf, map->map_file, sizeof(qbuf));
3552 map->map_file, ".", map->map_domain);
3578 if (!bitset(MF_OPTIONAL, map->map_mflags))
3580 map->map_file, map->map_domain,
3594 if (!bitset(MF_OPTIONAL, map->map_mflags))
3596 map->map_file, map->map_domain,
3603 if (map->map_keycolnm == NULL)
3604 map->map_keycolnm = newstr(COL_NAME(res,0));
3611 if (strcmp(map->map_keycolnm, COL_NAME(res,i)) == 0)
3618 map->map_file, map->map_keycolnm);
3624 if (map->map_valcolnm == NULL)
3626 map->map_valcolno = max_col - 1;
3632 if (strcmp(map->map_valcolnm, COL_NAME(res,i)) == 0)
3634 map->map_valcolno = i;
3641 map->map_file, map->map_keycolnm);
3652 nisplus_map_lookup(map, name, av, statp) in nisplus_map_lookup() argument
3653 MAP *map; in nisplus_map_lookup()
3668 map->map_mname, name);
3670 if (!bitset(MF_OPEN, map->map_mflags))
3672 if (nisplus_map_open(map, O_RDONLY))
3674 map->map_mflags |= MF_OPEN;
3675 map->map_pid = CurrentPid;
3718 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
3722 if (PARTIAL_NAME(map->map_file))
3724 map->map_keycolnm, search_key, map->map_file,
3725 map->map_domain);
3728 map->map_keycolnm, search_key, map->map_file);
3743 map->map_file, count);
3751 p = ((NIS_RES_OBJECT(result))->EN_col(map->map_valcolno));
3759 if (bitset(MF_MATCHONLY, map->map_mflags))
3760 str = map_rewrite(map, name, strlen(name), NULL);
3762 str = map_rewrite(map, p, vsize, av);
3776 map->map_mflags &= ~(MF_VALID|MF_OPEN);
3976 ldapmap_open(map, mode) in ldapmap_open() argument
3977 MAP *map; in ldapmap_open()
3985 sm_dprintf("ldapmap_open(%s, %d): ", map->map_mname, mode);
3990 strcmp(map->map_mname, "aliases.ldap") == 0)
4006 lmap = (SM_LDAP_STRUCT *) map->map_db1;
4017 s->s_lmap = map;
4039 map->map_orgclass = map->map_class;
4040 map->map_class = &NullMapClass;
4041 map->map_mflags |= MF_OPEN;
4042 map->map_pid = CurrentPid;
4047 if (!sm_ldap_start(map->map_mname, lmap))
4057 if (!bitset(MF_OPTIONAL, map->map_mflags))
4059 if (bitset(MF_NODEFER, map->map_mflags))
4067 id, map->map_mname);
4077 id, map->map_mname);
4084 s->s_lmap = map;
4093 ldapmap_close(map) in ldapmap_close() argument
4094 MAP *map; in ldapmap_close()
4100 sm_dprintf("ldapmap_close(%s)\n", map->map_mname);
4102 lmap = (SM_LDAP_STRUCT *) map->map_db1;
4118 if (tTd(38, 2) && smap != map)
4120 map->map_mname, smap->map_mname);
4171 ldapmap_lookup(map, name, av, statp) in ldapmap_lookup() argument
4172 MAP *map; in ldapmap_lookup()
4215 strcmp(map->map_mname, "aliases.ldap") == 0)
4240 if (bitset(MF_MATCHONLY, map->map_mflags))
4241 result = map_rewrite(map, name, strlen(name), NULL);
4243 result = map_rewrite(map, answer, strlen(answer), av);
4252 lmap = (SM_LDAP_STRUCT *) map->map_db1;
4271 if (!bitset(MF_MATCHONLY, map->map_mflags))
4295 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
4323 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
4332 map->map_mname);
4342 map->map_mname, name);
4359 if (!bitset(MF_OPTIONAL, map->map_mflags))
4366 if (bitset(MF_NODEFER, map->map_mflags))
4368 map->map_mname);
4371 map->map_mname);
4382 ldapmap_close(map);
4391 if (bitset(MF_NODEFER, map->map_mflags))
4393 map->map_mname);
4396 map->map_mname);
4406 if (bitset(MF_SINGLEMATCH, map->map_mflags))
4408 if (bitset(MF_MATCHONLY, map->map_mflags))
4411 if (bitset(MF_SINGLEDN, map->map_mflags))
4419 *statp = sm_ldap_results(lmap, msgid, flags, map->map_coldelim,
4432 ldapmap_close(map);
4438 if (!bitset(MF_OPTIONAL, map->map_mflags))
4440 if (bitset(MF_NODEFER, map->map_mflags))
4442 map->map_mname, name);
4445 map->map_mname, name);
4452 if (vp == NULL && !bitset(MF_MATCHONLY, map->map_mflags))
4459 "ldap=%s, %.100s=>%s", map->map_mname, name,
4461 if (bitset(MF_MATCHONLY, map->map_mflags))
4462 result = map_rewrite(map, name, strlen(name), NULL);
4466 result = map_rewrite(map, vp, strlen(vp), largs);
4567 ldapmap_parseargs(map, args) in ldapmap_parseargs() argument
4568 MAP *map; in ldapmap_parseargs()
4584 lmap = (SM_LDAP_STRUCT *) map->map_db1;
4600 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL;
4601 map->map_spacesub = SpaceSub; /* default value */
4604 if (bitset(MF_ALIAS, map->map_mflags))
4607 map->map_coldelim = ',';
4638 map->map_mname);
4662 else if (bitset(MF_FILECLASS, map->map_mflags))
4665 map->map_coldelim = ' ';
4683 map->map_mflags |= MF_APPEND;
4687 map->map_app = ++p;
4691 map->map_mflags |= MF_DEFER;
4695 map->map_mflags |= MF_NOFOLDCASE;
4699 map->map_mflags |= MF_MATCHONLY;
4703 map->map_mflags |= MF_INCLNULL;
4704 map->map_mflags &= ~MF_TRY0NULL;
4708 map->map_mflags &= ~MF_TRY1NULL;
4712 map->map_mflags |= MF_OPTIONAL;
4716 map->map_mflags |= MF_KEEPQUOTES;
4720 map->map_spacesub = *++p;
4724 map->map_tapp = ++p;
4728 map->map_mflags |= MF_NODEFER;
4733 map->map_coldelim = *p;
4739 map->map_coldelim = '\n';
4743 map->map_coldelim = '\t';
4747 map->map_coldelim = '\\';
4754 map->map_mflags |= MF_SINGLEMATCH;
4759 map->map_mflags |= MF_SINGLEDN;
4786 map->map_mname);
4792 map->map_mname);
4807 map->map_mname);
4850 map->map_class->map_cflags))
4857 p, map->map_mname);
4916 map->map_class->map_cflags))
4923 p, map->map_mname);
4951 map->map_class->map_cflags))
4958 p, map->map_mname);
5004 map->map_mname);
5013 map->map_mname);
5034 syserr("Illegal option %c map %s", *p, map->map_mname);
5056 if (map->map_app != NULL)
5057 map->map_app = newstr(ldapmap_dequote(map->map_app));
5058 if (map->map_tapp != NULL)
5059 map->map_tapp = newstr(ldapmap_dequote(map->map_tapp));
5071 map->map_domain = lmap->ldap_host;
5078 map->map_domain = lmap->ldap_uri;
5187 if (bitset(MF_SINGLEMATCH, map->map_mflags))
5198 if (!bitset(MCF_OPTFILE, map->map_class->map_cflags))
5200 syserr("No filter given in map %s", map->map_mname);
5236 map->map_mname, LDAPMAP_MAX_ATTR);
5279 v, map->map_mname);
5323 type, map->map_mname);
5343 map->map_mname);
5349 map->map_mname);
5353 map->map_db1 = (ARBPTR_T) lmap;
5375 MAP map; local
5382 memset(&map, '\0', sizeof(map));
5391 map.map_class = &class->s_mapclass;
5392 map.map_db1 = (ARBPTR_T) LDAPDefaults;
5393 map.map_mname = "O LDAPDefaultSpec";
5395 (void) ldapmap_parseargs(&map, spec);
5398 if (map.map_mflags != (MF_TRY0NULL|MF_TRY1NULL) ||
5399 map.map_spacesub != SpaceSub ||
5400 map.map_app != NULL ||
5401 map.map_tapp != NULL)
5404 SM_FREE(map.map_app);
5405 SM_FREE(map.map_tapp);
5461 ph_map_parseargs(map, args) in ph_map_parseargs() argument
5462 MAP *map; in ph_map_parseargs()
5483 map->map_mflags |= MF_TRY0NULL|MF_TRY1NULL;
5493 map->map_mflags |= MF_INCLNULL;
5494 map->map_mflags &= ~MF_TRY0NULL;
5498 map->map_mflags &= ~MF_TRY1NULL;
5502 map->map_mflags |= MF_OPTIONAL;
5506 map->map_mflags |= MF_NOFOLDCASE;
5510 map->map_mflags |= MF_MATCHONLY;
5514 map->map_mflags |= MF_APPEND;
5518 map->map_mflags |= MF_KEEPQUOTES;
5522 map->map_mflags |= MF_NODEFER;
5526 map->map_app = ++p;
5530 map->map_tapp = ++p;
5540 map->map_spacesub = *++p;
5544 map->map_mflags |= MF_DEFER;
5583 if (map->map_app != NULL)
5584 map->map_app = newstr(ph_map_dequote(map->map_app));
5585 if (map->map_tapp != NULL)
5586 map->map_tapp = newstr(ph_map_dequote(map->map_tapp));
5599 map->map_db1 = (ARBPTR_T) pmap;
5608 ph_map_close(map) in ph_map_close() argument
5609 MAP *map; in ph_map_close()
5613 pmap = (PH_MAP_STRUCT *)map->map_db1;
5616 map->map_mname, pmap->ph_fastclose);
5626 map->map_mflags &= ~(MF_OPEN|MF_WRITABLE);
5682 ph_map_open(map, mode) in ph_map_open() argument
5683 MAP *map; in ph_map_open()
5692 sm_dprintf("ph_map_open(%s)\n", map->map_mname);
5703 bitset(MF_DEFER, map->map_mflags))
5707 map->map_mname);
5715 map->map_mflags &= ~MF_DEFER;
5719 pmap = (PH_MAP_STRUCT *)map->map_db1;
5765 ph_map_close(map);
5769 if (bitset(MF_NODEFER, map->map_mflags))
5774 map->map_mname);
5776 else if (!bitset(MF_OPTIONAL, map->map_mflags) && LogLevel > 1)
5779 map->map_mname);
5789 ph_map_lookup(map, key, args, pstat) in ph_map_lookup() argument
5790 MAP *map; in ph_map_lookup()
5800 pmap = (PH_MAP_STRUCT *)map->map_db1;
5841 ph_map_close(map);
5850 if (bitset(MF_MATCHONLY, map->map_mflags))
5851 return map_rewrite(map, key, strlen(key), NULL);
5853 return map_rewrite(map, value, strlen(value), args);
5871 syslog_map_parseargs(map, args) in syslog_map_parseargs() argument
5872 MAP *map; in syslog_map_parseargs()
5888 map->map_mflags |= MF_DEFER;
5893 map->map_spacesub = *++p;
5917 map->map_prio = LOG_INFO;
5925 map->map_prio = LOG_EMERG;
5930 map->map_prio = LOG_ALERT;
5935 map->map_prio = LOG_CRIT;
5940 map->map_prio = LOG_ERR;
5945 map->map_prio = LOG_WARNING;
5950 map->map_prio = LOG_NOTICE;
5955 map->map_prio = LOG_INFO;
5960 map->map_prio = LOG_DEBUG;
5970 map->map_mflags |= MF_KEEPXFMT;
5980 syslog_map_lookup(map, string, args, statp) in syslog_map_lookup() argument
5981 MAP *map; in syslog_map_lookup()
5986 char *ptr = map_rewrite(map, string, strlen(string), args);
5992 map->map_mname, map->map_prio, ptr);
5994 sm_syslog(map->map_prio, CurEnv->e_id, "%s", ptr);
6013 dprintf_map_parseargs(map, args) in dprintf_map_parseargs() argument
6014 MAP *map; in dprintf_map_parseargs()
6030 map->map_mflags |= MF_DEFER;
6035 map->map_spacesub = *++p;
6059 map->map_dbg_level = 0;
6065 map->map_mname, map->map_file,
6069 map->map_dbg_level = atoi(dbg_level);
6072 map->map_mflags |= MF_KEEPXFMT;
6082 dprintf_map_lookup(map, string, args, statp) in dprintf_map_lookup() argument
6083 MAP *map; in dprintf_map_lookup()
6088 char *ptr = map_rewrite(map, string, strlen(string), args);
6090 if (ptr != NULL && tTd(85, map->map_dbg_level))
6104 hes_map_open(map, mode) in hes_map_open() argument
6105 MAP *map; in hes_map_open()
6110 map->map_mname, map->map_file, mode);
6123 if (!bitset(MF_OPTIONAL, map->map_mflags))
6137 if (!bitset(MF_OPTIONAL, map->map_mflags))
6145 hes_map_lookup(map, name, av, statp) in hes_map_lookup() argument
6146 MAP *map; in hes_map_lookup()
6154 sm_dprintf("hes_map_lookup(%s, %s)\n", map->map_file, name);
6171 hp = hesiod_resolve(HesiodContext, np, map->map_file);
6173 hp = hes_resolve(np, map->map_file);
6183 hp = hesiod_resolve(HesiodContext, name, map->map_file);
6185 hp = hes_resolve(name, map->map_file);
6234 if (bitset(MF_MATCHONLY, map->map_mflags))
6235 return map_rewrite(map, name, strlen(name), NULL);
6237 return map_rewrite(map, hp[0], strlen(hp[0]), av);
6245 hes_map_close(map) in hes_map_close() argument
6246 MAP *map; in hes_map_close()
6249 sm_dprintf("hes_map_close(%s)\n", map->map_file);
6276 ni_map_open(map, mode) in ni_map_open() argument
6277 MAP *map; in ni_map_open()
6282 map->map_mname, map->map_file, mode);
6285 if (*map->map_file == '\0')
6286 map->map_file = NETINFO_DEFAULT_DIR;
6288 if (map->map_valcolnm == NULL)
6289 map->map_valcolnm = NETINFO_DEFAULT_PROPERTY;
6291 if (map->map_coldelim == '\0')
6293 if (bitset(MF_ALIAS, map->map_mflags))
6294 map->map_coldelim = ',';
6295 else if (bitset(MF_FILECLASS, map->map_mflags))
6296 map->map_coldelim = ' ';
6307 ni_map_lookup(map, name, av, statp) in ni_map_lookup() argument
6308 MAP *map; in ni_map_lookup()
6317 sm_dprintf("ni_map_lookup(%s, %s)\n", map->map_mname, name);
6319 propval = ni_propval(map->map_file, map->map_keycolnm, name,
6320 map->map_valcolnm, map->map_coldelim);
6326 if (bitset(MF_MATCHONLY, map->map_mflags))
6327 res = map_rewrite(map, name, strlen(name), NULL);
6329 res = map_rewrite(map, propval, strlen(propval), av);
6402 text_map_open(map, mode) in text_map_open() argument
6403 MAP *map; in text_map_open()
6411 map->map_mname, map->map_file, mode);
6420 if (*map->map_file == '\0')
6423 map->map_mname);
6427 if (map->map_file[0] != '/')
6430 map->map_mname);
6439 if ((i = safefile(map->map_file, RunAsUid, RunAsGid, RunAsUserName,
6448 if (!bitset(MF_OPTIONAL, map->map_mflags))
6450 map->map_mname, map->map_file);
6454 if (map->map_keycolnm == NULL)
6455 map->map_keycolno = 0;
6458 if (!(isascii(*map->map_keycolnm) && isdigit(*map->map_keycolnm)))
6461 map->map_mname, map->map_file,
6462 map->map_keycolnm);
6465 map->map_keycolno = atoi(map->map_keycolnm);
6468 if (map->map_valcolnm == NULL)
6469 map->map_valcolno = 0;
6472 if (!(isascii(*map->map_valcolnm) && isdigit(*map->map_valcolnm)))
6475 map->map_mname, map->map_file,
6476 map->map_valcolnm);
6479 map->map_valcolno = atoi(map->map_valcolnm);
6485 map->map_mname, map->map_file);
6486 if (map->map_coldelim == '\0')
6489 sm_dprintf("%c\n", map->map_coldelim);
6492 map->map_sff = sff;
6502 text_map_lookup(map, name, av, statp) in text_map_lookup() argument
6503 MAP *map; in text_map_lookup()
6515 long sff = map->map_sff;
6522 sm_dprintf("text_map_lookup(%s, %s)\n", map->map_mname, name);
6529 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
6532 f = safefopen(map->map_file, O_RDONLY, FileMode, sff);
6535 map->map_mflags &= ~(MF_VALID|MF_OPEN);
6539 key_idx = map->map_keycolno;
6540 delim = map->map_coldelim;
6565 vp = get_column(linebuf, map->map_valcolno, delim, buf, sizeof(buf));
6573 if (bitset(MF_MATCHONLY, map->map_mflags))
6574 return map_rewrite(map, name, strlen(name), NULL);
6576 return map_rewrite(map, vp, vsize, av);
6652 stab_map_lookup(map, name, av, pstat) in stab_map_lookup() argument
6653 register MAP *map; in stab_map_lookup()
6662 map->map_mname, name);
6667 if (bitset(MF_MATCHONLY, map->map_mflags))
6668 return map_rewrite(map, name, strlen(name), NULL);
6670 return map_rewrite(map, s->s_alias, strlen(s->s_alias), av);
6678 stab_map_store(map, lhs, rhs) in stab_map_store() argument
6679 register MAP *map; in stab_map_store()
6700 stab_map_open(map, mode) in stab_map_open() argument
6701 register MAP *map; in stab_map_open()
6710 map->map_mname, map->map_file, mode);
6724 af = safefopen(map->map_file, O_RDONLY, 0444, sff);
6727 readaliases(map, af, false, false);
6730 map->map_mtime = st.st_mtime;
6747 impl_map_lookup(map, name, av, pstat) in impl_map_lookup() argument
6748 MAP *map; in impl_map_lookup()
6755 map->map_mname, name);
6758 if (bitset(MF_IMPL_HASH, map->map_mflags))
6759 return db_map_lookup(map, name, av, pstat);
6762 if (bitset(MF_IMPL_NDBM, map->map_mflags))
6763 return ndbm_map_lookup(map, name, av, pstat);
6766 if (bitset(MF_IMPL_CDB, map->map_mflags))
6767 return cdb_map_lookup(map, name, av, pstat);
6769 return stab_map_lookup(map, name, av, pstat);
6777 impl_map_store(map, lhs, rhs) in impl_map_store() argument
6778 MAP *map; in impl_map_store()
6784 map->map_mname, lhs, rhs);
6786 if (bitset(MF_IMPL_HASH, map->map_mflags))
6787 db_map_store(map, lhs, rhs);
6790 if (bitset(MF_IMPL_NDBM, map->map_mflags))
6791 ndbm_map_store(map, lhs, rhs);
6794 if (bitset(MF_IMPL_CDB, map->map_mflags))
6795 cdb_map_store(map, lhs, rhs);
6797 stab_map_store(map, lhs, rhs);
6805 impl_map_open(map, mode) in impl_map_open() argument
6806 MAP *map; in impl_map_open()
6813 map->map_mname, map->map_file, mode);
6816 wasopt = bitset(MF_OPTIONAL, map->map_mflags);
6819 map->map_mflags |= MF_OPTIONAL;
6821 map->map_mflags |= MF_IMPL_HASH;
6822 if (hash_map_open(map, mode))
6825 if (mode == O_RDONLY || strstr(map->map_file, "/yp/") == NULL)
6830 map->map_mflags &= ~MF_IMPL_HASH;
6833 map->map_mflags |= MF_IMPL_NDBM;
6834 if (ndbm_map_open(map, mode))
6837 map->map_mflags &= ~MF_IMPL_NDBM;
6841 map->map_mflags |= MF_IMPL_CDB;
6842 if (cdb_map_open(map, mode))
6845 map->map_mflags &= ~MF_IMPL_CDB;
6848 if (!bitset(MF_ALIAS, map->map_mflags))
6853 map->map_file,
6860 if (mode == O_RDONLY && stab_map_open(map, mode))
6865 map->map_mflags &= ~MF_OPTIONAL;
6870 map->map_mflags &= ~MF_OPTIONAL;
6880 impl_map_close(map) in impl_map_close() argument
6881 MAP *map; in impl_map_close()
6885 map->map_mname, map->map_file, map->map_mflags);
6887 if (bitset(MF_IMPL_HASH, map->map_mflags))
6889 db_map_close(map);
6890 map->map_mflags &= ~MF_IMPL_HASH;
6895 if (bitset(MF_IMPL_NDBM, map->map_mflags))
6897 ndbm_map_close(map);
6898 map->map_mflags &= ~MF_IMPL_NDBM;
6902 if (bitset(MF_IMPL_CDB, map->map_mflags))
6904 cdb_map_close(map);
6905 map->map_mflags &= ~MF_IMPL_CDB;
6923 user_map_open(map, mode) in user_map_open() argument
6924 MAP *map; in user_map_open()
6929 map->map_mname, mode);
6938 if (map->map_valcolnm == NULL)
6941 else if (SM_STRCASEEQ(map->map_valcolnm, "name"))
6942 map->map_valcolno = 1;
6943 else if (SM_STRCASEEQ(map->map_valcolnm, "passwd"))
6944 map->map_valcolno = 2;
6945 else if (SM_STRCASEEQ(map->map_valcolnm, "uid"))
6946 map->map_valcolno = 3;
6947 else if (SM_STRCASEEQ(map->map_valcolnm, "gid"))
6948 map->map_valcolno = 4;
6949 else if (SM_STRCASEEQ(map->map_valcolnm, "gecos"))
6950 map->map_valcolno = 5;
6951 else if (SM_STRCASEEQ(map->map_valcolnm, "dir"))
6952 map->map_valcolno = 6;
6953 else if (SM_STRCASEEQ(map->map_valcolnm, "shell"))
6954 map->map_valcolno = 7;
6958 map->map_mname, map->map_valcolnm);
6971 user_map_lookup(map, key, av, statp) in user_map_lookup() argument
6972 MAP *map; in user_map_lookup()
6982 map->map_mname, key);
6987 if (bitset(MF_MATCHONLY, map->map_mflags))
6988 return map_rewrite(map, key, strlen(key), NULL);
6994 switch (map->map_valcolno)
7030 map->map_mname, map->map_valcolno);
7033 return map_rewrite(map, rwval, strlen(rwval), av);
7045 prog_map_lookup(map, name, av, statp) in prog_map_lookup() argument
7046 MAP *map; in prog_map_lookup()
7063 map->map_mname, name, map->map_file);
7066 argv[i++] = map->map_file;
7067 if (map->map_rebuild != NULL)
7069 (void) sm_strlcpy(buf, map->map_rebuild, sizeof(buf));
7090 if (!bitset(MF_OPTIONAL, map->map_mflags))
7092 map->map_mname, sm_errstring(errno));
7095 map->map_mname, sm_errstring(errno));
7096 map->map_mflags &= ~(MF_VALID|MF_OPEN);
7104 map->map_mname, sm_errstring(errno));
7111 map->map_mname);
7122 if (bitset(MF_MATCHONLY, map->map_mflags))
7123 rval = map_rewrite(map, name, strlen(name), NULL);
7125 rval = map_rewrite(map, buf, strlen(buf), av);
7142 map->map_mname, sm_errstring(errno));
7154 map->map_mname, status);
7182 seq_map_parse(map, ap) in seq_map_parse() argument
7183 MAP *map; in seq_map_parse()
7189 sm_dprintf("seq_map_parse(%s, %s)\n", map->map_mname, ap);
7216 map->map_mname, ap);
7221 map->map_mname, MAXMAPSTACK);
7226 map->map_stack[maxmap++] = &s->s_map;
7245 switch_map_open(map, mode) in switch_map_open() argument
7246 MAP *map; in switch_map_open()
7255 map->map_mname, map->map_file, mode);
7258 nmaps = switch_map_find(map->map_file, maptype, map->map_return);
7276 map->map_mname, ".", maptype[mapno]);
7281 map->map_mname, nbuf);
7285 map->map_stack[mapno] = &s->s_map;
7302 seq_map_close(map)
7303 MAP *map;
7308 sm_dprintf("seq_map_close(%s)\n", map->map_mname);
7312 MAP *mm = map->map_stack[mapno];
7328 seq_map_lookup(map, key, args, pstat) in seq_map_lookup() argument
7329 MAP *map; in seq_map_lookup()
7339 sm_dprintf("seq_map_lookup(%s, %s)\n", map->map_mname, key);
7343 MAP *mm = map->map_stack[mapno];
7351 if (bitset(mapbit, map->map_return[MA_UNAVAIL]))
7364 if (bitset(mapbit, map->map_return[MA_TRYAGAIN]))
7368 else if (bitset(mapbit, map->map_return[MA_NOTFOUND]))
7383 seq_map_store(map, key, val) in seq_map_store() argument
7384 MAP *map; in seq_map_store()
7392 map->map_mname, key, val);
7396 MAP *mm = map->map_stack[mapno];
7405 map->map_mname, key, val);
7413 null_map_open(map, mode) in null_map_open() argument
7414 MAP *map; in null_map_open()
7422 null_map_close(map) in null_map_close() argument
7423 MAP *map; in null_map_close()
7429 null_map_lookup(map, key, args, pstat) in null_map_lookup() argument
7430 MAP *map; in null_map_lookup()
7441 null_map_store(map, key, val) in null_map_store() argument
7442 MAP *map; in null_map_store()
7461 bogus_map_lookup(map, key, args, pstat) in bogus_map_lookup() argument
7462 MAP *map; in bogus_map_lookup()
7482 macro_map_lookup(map, name, av, statp) in macro_map_lookup() argument
7483 MAP *map; in macro_map_lookup()
7491 sm_dprintf("macro_map_lookup(%s, %s)\n", map->map_mname,
7587 regex_map_init(map, ap) in regex_map_init() argument
7588 MAP *map; in regex_map_init()
7600 map->map_mname, ap);
7616 map->map_mflags |= MF_REGEX_NOT;
7620 map->map_mflags |= MF_NOFOLDCASE;
7638 map->map_app = ++p;
7642 map->map_mflags |= MF_MATCHONLY;
7646 map->map_mflags |= MF_KEEPQUOTES;
7650 map->map_spacesub = *++p;
7654 map->map_mflags |= MF_DEFER;
7682 if (map->map_app != NULL)
7683 map->map_app = newstr(map->map_app);
7741 map->map_db1 = (ARBPTR_T) map_p; /* dirty hack */
7746 regex_map_rewrite(map, s, slen, av) in regex_map_rewrite() argument
7747 MAP *map; in regex_map_rewrite()
7752 if (bitset(MF_MATCHONLY, map->map_mflags))
7753 return map_rewrite(map, av[0], strlen(av[0]), NULL);
7755 return map_rewrite(map, s, slen, av);
7759 regex_map_lookup(map, name, av, statp) in regex_map_lookup() argument
7760 MAP *map; in regex_map_lookup()
7774 map->map_mname, name);
7779 map_p = (struct regex_map *)(map->map_db1);
7783 if (bitset(MF_REGEX_NOT, map->map_mflags))
7787 return regex_map_rewrite(map, "", (size_t) 0, av);
7893 map->map_mname, name);
7897 return regex_map_rewrite(map, retbuf, strlen(retbuf), av);
7899 return regex_map_rewrite(map, "", (size_t)0, av);
7913 ns_map_t *map; /* XXX ns_ ? */ member
7937 ns_map->map = (ns_map_t *) xalloc(sizeof(*ns_map->map));
7938 memset(ns_map->map, '\0', sizeof(*ns_map->map));
7942 return ns_map->map;
7946 nsd_map_lookup(map, name, av, statp) in nsd_map_lookup() argument
7947 MAP *map; in nsd_map_lookup()
7959 sm_dprintf("nsd_map_lookup(%s, %s)\n", map->map_mname, name);
7966 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
7969 ns_map = ns_map_t_find(map->map_file);
7977 r = ns_lookup(ns_map, NULL, map->map_file, keybuf, NULL,
8005 return map_rewrite(map, buf, strlen(buf), av);
8010 arith_map_lookup(map, name, av, statp) in arith_map_lookup() argument
8011 MAP *map; in arith_map_lookup()
8118 arpa_map_lookup(map, name, av, statp) in arpa_map_lookup() argument
8119 MAP *map; in arpa_map_lookup()
8188 if (bitset(MF_MATCHONLY, map->map_mflags))
8189 rval = map_rewrite(map, name, strlen(name), NULL);
8191 rval = map_rewrite(map, result, strlen(result), av);
8198 setdebug_map_lookup(map, name, av, statp) in setdebug_map_lookup() argument
8199 MAP *map; in setdebug_map_lookup()
8221 setopt_map_lookup(map, name, av, statp) in setopt_map_lookup() argument
8222 MAP *map; in setopt_map_lookup()
8286 socket_map_open(map, mode) in socket_map_open() argument
8287 MAP *map; in socket_map_open()
8304 map->map_mname, map->map_file, mode);
8316 if (*map->map_file == '\0')
8319 map->map_mname);
8323 s = socket_map_findconn(map->map_file);
8327 map->map_db1 = s->s_socketmap->map_db1;
8330 map->socket_map_next = s->s_socketmap;
8331 s->s_socketmap = map;
8346 p = map->map_file;
8368 map->map_mname);
8395 map->map_mname, p);
8416 map->map_mname, p);
8432 map->map_mname, colon);
8442 map->map_mname, colon);
8469 map->map_mname, colon);
8479 map->map_mname, colon);
8488 map->map_mname, colon);
8535 map->map_mname, at);
8542 map->map_mname, at);
8552 map->map_mname, at);
8580 map->map_mname, at, hp->h_addrtype);
8592 map->map_mname);
8605 map->map_mname,
8623 map->map_mname, at, sm_errstring(save_errno));
8651 map->map_mname, at,
8664 map->map_mname, sm_errstring(save_errno));
8679 if ((map->map_db1 = (ARBPTR_T) sm_io_open(SmFtStdiofd,
8688 map->map_mname, sm_errstring(errno));
8692 tmo = map->map_timeout;
8697 sm_io_setinfo(map->map_db1, SM_IO_WHAT_TIMEOUT, &tmo);
8700 s->s_socketmap = map;
8741 socket_map_close(map) in socket_map_close() argument
8742 MAP *map; in socket_map_close()
8748 sm_dprintf("socket_map_close(%s), pid=%ld\n", map->map_file,
8752 if (map->map_db1 == NULL)
8756 map->map_file);
8759 sm_io_close((SM_FILE_T *)map->map_db1, SM_TIME_DEFAULT);
8762 s = socket_map_findconn(map->map_file);
8768 if (tTd(38, 2) && smap != map)
8770 map->map_mname, smap->map_mname);
8786 socket_map_lookup(map, name, av, statp) in socket_map_lookup() argument
8787 MAP *map; in socket_map_lookup()
8800 f = (SM_FILE_T *)map->map_db1;
8803 map->map_mname, name, map->map_file);
8805 if (!bitset(MF_NOFOLDCASE, map->map_mflags))
8818 nettolen = strlen(map->map_mname) + 1 + strlen(key);
8819 SM_ASSERT(nettolen > strlen(map->map_mname));
8822 nettolen, map->map_mname, key) == SM_IO_EOF) ||
8827 map->map_mname);
8837 map->map_mname);
8844 map->map_mname);
8849 map->map_mname, errno);
8857 map->map_mname, replylen);
8864 map->map_mname);
8873 map->map_mname, replylen + 1);
8882 map->map_mname, recvlen, replylen);
8889 map->map_mname);
8906 if (bitset(MF_MATCHONLY, map->map_mflags))
8907 rval = map_rewrite(map, key, strlen(key), NULL);
8909 rval = map_rewrite(map, value, strlen(value), av);
8916 map->map_mname, key);
8922 map->map_mname, key, status,
8937 socket_map_close(map);