Lines Matching refs:m
122 else if (bitnset(SMF_TEMPFAIL, m->mf_flags)) \
124 else if (bitnset(SMF_TEMPDROP, m->mf_flags)) \
126 else if (bitnset(SMF_REJECT, m->mf_flags)) \
202 if (SM_FD_SETSIZE > 0 && m->mf_sock >= SM_FD_SETSIZE) \
206 (routine), m->mf_name, m->mf_sock, \
211 m->mf_name, (routine), m->mf_sock, \
213 milter_error(m, e); \
220 SM_FD_SET(m->mf_sock, &fds); \
223 ret = select(m->mf_sock + 1, \
234 (routine), m->mf_name, (function)); \
238 m->mf_name, \
241 milter_error(m, e); \
248 m->mf_name, sm_errstring(save_errno)); \
253 m->mf_name, (routine), \
256 milter_error(m, e); \
260 if (SM_FD_ISSET(m->mf_sock, &fds)) \
264 (routine), m->mf_name); \
269 m->mf_name, (routine)); \
271 milter_error(m, e); \
295 milter_sysread(m, buf, sz, to, e, where) in milter_sysread() argument
296 struct milter *m; in milter_sysread()
323 m->mf_name,
329 m->mf_name,
332 milter_error(m, e);
340 len = read(m->mf_sock, buf + curl, sz - curl);
348 m->mf_name, (long) len,
353 m->mf_name, (long) len,
355 milter_error(m, e);
370 m->mf_name, (long) curl, (long) sz);
374 m->mf_name, (long) curl, (long) sz);
375 milter_error(m, e);
382 milter_read(m, cmd, rlen, to, e, where) in milter_read() argument
383 struct milter *m; in milter_read()
399 if (m->mf_sock < 0)
404 m->mf_name, where);
405 milter_error(m, e);
416 setsockopt(m->mf_sock, IPPROTO_TCP, TCP_CORK, (char *)&cork,
420 if (milter_sysread(m, data, sizeof(data), to, e, where) == NULL)
425 setsockopt(m->mf_sock, IPPROTO_TCP, TCP_CORK, (char *)&cork,
439 m->mf_name, where);
443 m->mf_name, where);
444 milter_error(m, e);
457 m->mf_name, (long) expl);
463 m->mf_name, (long) expl, where);
467 m->mf_name, (long) expl, where);
468 milter_error(m, e);
477 if (milter_sysread(m, buf, expl, to, e, where) == NULL)
485 m->mf_name, (int) expl, buf);
508 milter_write(m, cmd, buf, len, to, e, where) in milter_write() argument
509 struct milter *m; in milter_write()
536 m->mf_name, (long) len, command);
538 m->mf_name, str2prt(buf));
543 m->mf_name, (long) len, command);
544 milter_error(m, e);
547 if (m->mf_sock < 0)
552 m->mf_name);
553 milter_error(m, e);
559 m->mf_name, command, (long) len);
596 m->mf_name, (int) len, buf);
603 i = writev(m->mf_sock, vector, num_vectors);
610 m->mf_name, command, (long) i, (long) sl,
615 m->mf_name, command, (long) i, (long) sl,
617 milter_error(m, e);
644 milter_open(m, parseonly, e) in milter_open() argument
645 struct milter *m; in milter_open()
659 if (m->mf_conn == NULL || m->mf_conn[0] == '\0')
663 m->mf_name);
666 m->mf_name);
670 m->mf_name);
671 milter_error(m, e);
677 p = m->mf_conn;
701 m->mf_name);
702 milter_error(m, e);
730 m->mf_name, p);
733 m->mf_name, p);
737 m->mf_name, p);
738 milter_error(m, e);
760 m->mf_name, colon);
764 m->mf_name, colon);
768 m->mf_name, colon);
769 milter_error(m, e);
782 m->mf_name, colon);
790 m->mf_name, colon);
798 m->mf_name, colon);
803 m->mf_name, colon);
804 milter_error(m, e);
832 m->mf_name, colon);
835 m->mf_name, colon);
839 m->mf_name, colon);
840 milter_error(m, e);
851 m->mf_name, colon);
854 m->mf_name, colon);
858 m->mf_name, colon);
859 milter_error(m, e);
870 m->mf_name, colon);
874 m->mf_name, colon);
878 m->mf_name, colon);
879 milter_error(m, e);
927 m->mf_name, at);
930 m->mf_name, at);
934 m->mf_name, at);
935 milter_error(m, e);
943 m->mf_name, at);
946 m->mf_name, at);
950 m->mf_name, at);
951 milter_error(m, e);
963 m->mf_name, at);
967 m->mf_name, at);
971 m->mf_name, at);
972 milter_error(m, e);
1001 m->mf_name, at,
1005 m->mf_name, at, hp->h_addrtype);
1009 m->mf_name, at,
1011 milter_error(m, e);
1024 m->mf_name);
1026 syserr("X%s: unknown socket protocol", m->mf_name);
1030 m->mf_name);
1031 milter_error(m, e);
1038 m->mf_state = SMFS_READY;
1047 if (m->mf_state != SMFS_READY &&
1048 m->mf_state != SMFS_CLOSED)
1053 m->mf_name, (char) m->mf_state);
1054 milter_error(m, e);
1071 m->mf_name,
1076 m->mf_name, sm_errstring(save_errno));
1077 milter_error(m, e);
1090 if (m->mf_timeout[SMFTO_CONNECT] > 0)
1091 ev = sm_setevent(m->mf_timeout[SMFTO_CONNECT],
1109 m->mf_name, at, sm_errstring(save_errno));
1113 m->mf_name, at, sm_errstring(save_errno));
1141 m->mf_name, at,
1146 m->mf_name, at,
1148 milter_error(m, e);
1160 m->mf_name, sm_errstring(save_errno));
1164 m->mf_name, sm_errstring(save_errno));
1166 milter_error(m, e);
1173 m->mf_state = SMFS_OPEN;
1185 setsockopt(m->mf_sock, IPPROTO_TCP, TCP_NODELAY,
1222 struct milter *m; local
1237 m = (struct milter *) xalloc(sizeof(*m));
1238 memset((char *) m, '\0', sizeof(*m));
1239 m->mf_name = newstr(line);
1240 m->mf_state = SMFS_READY;
1241 m->mf_sock = -1;
1242 m->mf_timeout[SMFTO_CONNECT] = (time_t) 300;
1243 m->mf_timeout[SMFTO_WRITE] = (time_t) 10;
1244 m->mf_timeout[SMFTO_READ] = (time_t) 10;
1245 m->mf_timeout[SMFTO_EOM] = (time_t) 300;
1247 m->mf_mta_prot_version = SMFI_PROT_VERSION;
1248 m->mf_mta_prot_flags = SMFI_CURR_PROT;
1249 m->mf_mta_actions = SMFI_CURR_ACTS;
1267 syserr("X%s: `=' expected", m->mf_name);
1281 m->mf_conn = NULL;
1283 m->mf_conn = newstr(p);
1290 setbitn(bitidx(*p), m->mf_flags);
1295 milter_parse_timeouts(p, m);
1300 m->mf_mta_actions = strtoul(p, NULL, 0);
1303 m->mf_mta_prot_flags = strtoul(p, NULL, 0);
1306 m->mf_mta_prot_version = strtoul(p, NULL, 0);
1312 m->mf_name, fcode);
1319 (void) milter_open(m, true, CurEnv);
1322 s = stab(m->mf_name, ST_MILTER, ST_ENTER);
1324 syserr("X%s: duplicate filter definition", m->mf_name);
1326 s->s_milter = m;
1406 milter_parse_timeouts(spec, m) in milter_parse_timeouts() argument
1408 struct milter *m;
1431 syserr("X%s, T=: `:' expected", m->mf_name);
1463 m->mf_name, fcode);
1465 m->mf_name, fcode);
1470 m->mf_timeout[tcode] = convtime(p, 's');
1473 m->mf_name, fcode,
1474 (u_long) m->mf_timeout[tcode]);
1824 milter_quit_filter(m, e) in milter_quit_filter() argument
1825 struct milter *m; in milter_quit_filter()
1829 sm_dprintf("milter_quit_filter(%s)\n", m->mf_name);
1832 m->mf_name);
1835 if (m->mf_state == SMFS_ERROR)
1838 if (m->mf_sock < 0 ||
1839 m->mf_state == SMFS_CLOSED ||
1840 m->mf_state == SMFS_READY)
1842 m->mf_sock = -1;
1843 m->mf_state = SMFS_CLOSED;
1847 (void) milter_write(m, SMFIC_QUIT, (char *) NULL, 0,
1848 m->mf_timeout[SMFTO_WRITE], e, "quit_filter");
1849 if (m->mf_sock >= 0)
1851 (void) close(m->mf_sock);
1852 m->mf_sock = -1;
1854 if (m->mf_state != SMFS_ERROR)
1855 m->mf_state = SMFS_CLOSED;
1870 milter_abort_filter(m, e) in milter_abort_filter() argument
1871 struct milter *m; in milter_abort_filter()
1875 sm_dprintf("milter_abort_filter(%s)\n", m->mf_name);
1878 m->mf_name);
1880 if (m->mf_sock < 0 ||
1881 m->mf_state != SMFS_INMSG)
1884 (void) milter_write(m, SMFIC_ABORT, (char *) NULL, 0,
1885 m->mf_timeout[SMFTO_WRITE], e, "abort_filter");
1886 if (m->mf_state != SMFS_ERROR)
1887 m->mf_state = SMFS_DONE;
1904 milter_send_macros(m, macros, cmd, e) in milter_send_macros() argument
1905 struct milter *m; in milter_send_macros()
1954 m->mf_name, command, macros[i], exp);
1961 (void) milter_write(m, SMFIC_MACRO, buf, s,
1962 m->mf_timeout[SMFTO_WRITE], e, "send_macros");
1982 milter_send_command(m, cmd, data, sz, e, state, where) in milter_send_command() argument
1983 struct milter *m; in milter_send_command()
2002 m->mf_name, (char) command, (long) sz);
2087 m->mf_name, skipflag, m->mf_pflags);
2090 if (skipflag != 0 && bitset(skipflag, m->mf_pflags))
2094 (void) milter_write(m, command, data, sz,
2095 m->mf_timeout[SMFTO_WRITE], e, where);
2096 if (m->mf_state == SMFS_ERROR)
2103 if (norespflag != 0 && bitset(norespflag, m->mf_pflags))
2107 response = milter_read(m, &rcmd, &rlen,
2108 m->mf_timeout[SMFTO_READ], e, where);
2109 if (m->mf_state == SMFS_ERROR)
2117 m->mf_name, (char) rcmd);
2126 m->mf_name, action, response);
2134 m->mf_name, action);
2142 m->mf_name, action);
2150 m->mf_name, action);
2158 m->mf_state = SMFS_CLOSABLE;
2160 m->mf_state = SMFS_DONE;
2164 m->mf_name, action);
2170 m->mf_state = SMFS_INMSG;
2174 m->mf_name, action);
2181 m->mf_name, action);
2182 m->mf_state = SMFS_SKIP;
2190 m->mf_name, action, rcmd);
2191 milter_error(m, e);
2243 struct milter *m = InputFilters[i]; local
2246 if (m->mf_state == SMFS_ERROR)
2253 if (m->mf_sock < 0 ||
2254 (m->mf_state != SMFS_OPEN && m->mf_state != SMFS_INMSG))
2260 milter_send_macros(m, macros, command, e);
2261 if (m->mf_state == SMFS_ERROR)
2282 (m->mf_pflags & SMFIP_RCPT_REJ) == 0))
2285 response = milter_send_command(m, command, data, sz, e, state,
2293 m->mf_name, command, (int) (tn - curtime()));
2305 milter_getsymlist(m, buf, rlen, offset) in milter_getsymlist() argument
2306 struct milter *m; in milter_getsymlist()
2314 SM_ASSERT(m != NULL);
2369 r = milter_set_macros(m->mf_name, macros,
2400 milter_negotiate(m, e, milters) in milter_negotiate() argument
2401 struct milter *m; in milter_negotiate()
2413 if (m->mf_sock < 0 || m->mf_state != SMFS_OPEN)
2418 m->mf_name);
2419 milter_error(m, e);
2424 mta_prot_vers = m->mf_mta_prot_version;
2425 mta_prot_flags = m->mf_mta_prot_flags;
2426 mta_actions = m->mf_mta_actions;
2447 (void) milter_write(m, SMFIC_OPTNEG, data, sizeof(data),
2448 m->mf_timeout[SMFTO_WRITE], e, "negotiate");
2450 if (m->mf_state == SMFS_ERROR)
2455 m->mf_name, ntohl(fvers), ntohl(fflags), ntohl(pflags));
2457 response = milter_read(m, &rcmd, &rlen, m->mf_timeout[SMFTO_READ], e,
2459 if (m->mf_state == SMFS_ERROR)
2466 m->mf_name, rcmd, SMFIC_OPTNEG);
2470 m->mf_name, rcmd, SMFIC_OPTNEG);
2473 milter_error(m, e);
2482 m->mf_name);
2486 m->mf_name);
2489 milter_error(m, e);
2501 m->mf_name);
2505 m->mf_name);
2508 milter_error(m, e);
2517 m->mf_fvers = ntohl(fvers);
2518 m->mf_fflags = ntohl(fflags);
2519 m->mf_pflags = ntohl(pflags);
2522 if (m->mf_fvers == 1 ||
2523 m->mf_fvers > SMFI_VERSION)
2527 m->mf_name, m->mf_fvers, SMFI_VERSION);
2531 m->mf_name, m->mf_fvers, SMFI_VERSION);
2532 milter_error(m, e);
2537 if ((m->mf_fflags & mta_actions) != m->mf_fflags)
2541 m->mf_name, m->mf_fflags,
2546 m->mf_name, m->mf_fflags,
2548 milter_error(m, e);
2554 if (bitset(SMFIP_MDS_1M, m->mf_pflags))
2565 else if (bitset(SMFIP_MDS_256K, m->mf_pflags))
2582 m->mf_pflags &= ~SMFI_INTERNAL;
2586 if ((m->mf_pflags & mta_prot_flags) != m->mf_pflags)
2590 m->mf_name, m->mf_pflags,
2595 m->mf_name, m->mf_pflags,
2597 milter_error(m, e);
2601 if (m->mf_fvers <= 2)
2602 m->mf_pflags |= SMFIP_NOUNKNOWN;
2603 if (m->mf_fvers <= 3)
2604 m->mf_pflags |= SMFIP_NODATA;
2608 milter_getsymlist(m, response, rlen, MILTER_OPTLEN);
2611 if (bitset(SMFIF_DELRCPT, m->mf_fflags))
2613 if (!bitset(SMFIP_NORCPT, m->mf_pflags) &&
2614 !bitset(SMFIP_NR_RCPT, m->mf_pflags))
2619 m->mf_name, m->mf_fvers, m->mf_fflags, m->mf_pflags);
2649 struct milter *m = InputFilters[i]; local
2651 if (m->mf_state == SMFS_CLOSABLE)
2652 milter_quit_filter(m, e);
2668 milter_error(m, e) in milter_error() argument
2669 struct milter *m; in milter_error()
2677 if (m->mf_sock >= 0)
2679 (void) close(m->mf_sock);
2680 m->mf_sock = -1;
2682 m->mf_state = SMFS_ERROR;
2686 m->mf_name);
2702 milter_headers(m, e, state) in milter_headers() argument
2703 struct milter *m; in milter_headers()
2712 m->mf_name);
2736 m->mf_name, h->h_field);
2738 if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags)
2762 response = milter_send_command(m, SMFIC_HEADER, buf,
2765 if (m->mf_state == SMFS_ERROR ||
2766 m->mf_state == SMFS_DONE ||
2772 m->mf_name);
2789 milter_body(m, e, state) in milter_body() argument
2790 struct milter *m; in milter_body()
2816 m->mf_name);
2850 response = milter_send_command(m, SMFIC_BODY, buf,
2861 if (m->mf_state == SMFS_ERROR ||
2862 m->mf_state == SMFS_DONE ||
2863 m->mf_state == SMFS_SKIP ||
2874 m->mf_state == SMFS_SKIP)
2891 m->mf_state != SMFS_ERROR &&
2892 m->mf_state != SMFS_DONE &&
2893 m->mf_state != SMFS_SKIP &&
2897 response = milter_send_command(m, SMFIC_BODY, buf, bp - buf,
2903 m->mf_name);
2904 if (m->mf_state == SMFS_SKIP)
2907 m->mf_state = SMFS_READY;
2962 milter_addheader(m, response, rlen, e) in milter_addheader() argument
2963 struct milter *m; in milter_addheader()
3032 if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags))
3050 !bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3074 milter_insheader(m, response, rlen, e) in milter_insheader() argument
3075 struct milter *m; in milter_insheader()
3136 !bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3154 milter_changeheader(m, response, rlen, e) in milter_changeheader() argument
3155 struct milter *m; in milter_changeheader()
3258 !bitset(SMFIP_HDR_LEADSPC, m->mf_pflags));
3333 if (bitset(SMFIP_HDR_LEADSPC, m->mf_pflags))
3848 struct milter *m = InputFilters[i]; local
3850 m->mf_sock = milter_open(m, false, e);
3851 if (m->mf_state == SMFS_ERROR)
3857 if (m->mf_sock < 0 ||
3858 milter_negotiate(m, e, milters) < 0 ||
3859 m->mf_state == SMFS_ERROR)
3863 m->mf_name,
3864 m->mf_sock < 0 ? "open" :
3869 m->mf_name,
3870 m->mf_sock < 0 ? "open" :
3874 milter_error(m, e);
3881 m->mf_name,
3882 m->mf_sock < 0 ? "open" : "negotiate");
4064 struct milter *m = InputFilters[i]; local
4066 switch (m->mf_state)
4070 milter_abort_filter(m, e);
4075 m->mf_state = SMFS_OPEN;
4130 struct milter *m = InputFilters[i]; local
4132 switch (m->mf_state)
4136 milter_abort_filter(m, e);
4141 m->mf_state = SMFS_OPEN;
4298 m->mf_state == SMFS_DONE || \
4299 m->mf_state == SMFS_ERROR) \
4301 if (m->mf_state != SMFS_ERROR) \
4302 m->mf_state = SMFS_DONE; \
4307 m->mf_state = SMFS_DONE; \
4342 struct milter *m = InputFilters[i]; local
4360 if (m->mf_state == SMFS_ERROR)
4367 if (m->mf_sock < 0 ||
4368 (m->mf_state != SMFS_OPEN && m->mf_state != SMFS_INMSG))
4371 m->mf_state = SMFS_INMSG;
4374 if (!bitset(SMFIP_NOHDRS, m->mf_pflags))
4376 response = milter_headers(m, e, state);
4381 if (!bitset(SMFIP_NOEOH, m->mf_pflags))
4388 milter_send_macros(m, MilterEOHMacros,
4394 response = milter_send_command(m, SMFIC_EOH, NULL, 0,
4400 if (!bitset(SMFIP_NOBODY, m->mf_pflags) &&
4404 response = milter_body(m, e, state);
4410 milter_send_macros(m, MilterEOMMacros,
4416 (void) milter_write(m, SMFIC_BODYEOB, NULL, 0,
4417 m->mf_timeout[SMFTO_WRITE], e, "eom");
4426 if (m->mf_timeout[SMFTO_EOM] > 0 &&
4427 curtime() - eomsent >= m->mf_timeout[SMFTO_EOM])
4431 m->mf_name);
4435 m->mf_name);
4436 milter_error(m, e);
4441 response = milter_read(m, &rcmd, &rlen,
4442 m->mf_timeout[SMFTO_READ], e,
4444 if (m->mf_state == SMFS_ERROR)
4449 m->mf_name, (char) rcmd);
4457 m->mf_name, response);
4459 m->mf_state = SMFS_DONE;
4465 m->mf_name);
4467 m->mf_state = SMFS_DONE;
4473 m->mf_name);
4475 m->mf_state = SMFS_DONE;
4481 m->mf_name);
4483 m->mf_state = SMFS_DONE;
4493 m->mf_state = SMFS_DONE;
4500 if (!bitset(SMFIF_QUARANTINE, m->mf_fflags))
4505 m->mf_name);
4512 m->mf_name, response);
4520 if (!bitset(SMFIF_ADDHDRS, m->mf_fflags))
4525 m->mf_name);
4527 milter_addheader(m, response, rlen, e);
4531 if (!bitset(SMFIF_ADDHDRS, m->mf_fflags))
4536 m->mf_name);
4538 milter_insheader(m, response, rlen, e);
4542 if (!bitset(SMFIF_CHGHDRS, m->mf_fflags))
4547 m->mf_name);
4549 milter_changeheader(m, response, rlen, e);
4553 if (!bitset(SMFIF_CHGFROM, m->mf_fflags))
4558 m->mf_name);
4564 if (!bitset(SMFIF_ADDRCPT, m->mf_fflags))
4569 m->mf_name);
4575 if (!bitset(SMFIF_ADDRCPT_PAR, m->mf_fflags))
4580 m->mf_name);
4586 if (!bitset(SMFIF_DELRCPT, m->mf_fflags))
4591 m->mf_name);
4597 if (!bitset(SMFIF_MODBODY, m->mf_fflags))
4602 m->mf_name);
4634 m->mf_name, rcmd);
4635 milter_error(m, e);
4644 if (m->mf_state == SMFS_ERROR)
4655 if (m->mf_state == SMFS_ERROR)
4784 struct milter *m = InputFilters[i]; local
4787 if (m->mf_sock < 0 || m->mf_state != SMFS_INMSG)
4790 milter_abort_filter(m, e);