int smtp_map11_internal(VSTRING *addr, MAPS *maps, int propagate)
{
VSTRING *temp = vstring_alloc(100);
int ret;
quote_822_local(temp, STR(addr));
ret = smtp_map11_external(temp, maps, propagate);
unquote_822_local(addr, STR(temp));
vstring_free(temp);
return (ret);
}
void cleanup_rewrite_internal(VSTRING *result, const char *addr)
{
VSTRING *dst = vstring_alloc(100);
VSTRING *src = vstring_alloc(100);
quote_822_local(src, addr);
cleanup_rewrite_external(dst, STR(src));
unquote_822_local(result, STR(dst));
vstring_free(dst);
vstring_free(src);
}
int cleanup_rewrite_internal(const char *context_name,
VSTRING *result, const char *addr)
{
VSTRING *dst = vstring_alloc(100);
VSTRING *src = vstring_alloc(100);
int did_rewrite;
quote_822_local(src, addr);
did_rewrite = cleanup_rewrite_external(context_name, dst, STR(src));
unquote_822_local(result, STR(dst));
vstring_free(dst);
vstring_free(src);
return (did_rewrite);
}
void cleanup_map11_internal(CLEANUP_STATE *state, VSTRING *addr,
MAPS *maps, int propagate)
{
VSTRING *temp = vstring_alloc(100);
/*
* Produce sensible output even in the face of a recoverable error. This
* simplifies error recovery considerably because we can do delayed error
* checking in one place, instead of having error handling code all over
* the place.
*/
quote_822_local(temp, STR(addr));
cleanup_map11_external(state, temp, maps, propagate);
unquote_822_local(addr, STR(temp));
vstring_free(temp);
}
VSTRING *rewrite_clnt_internal(const char *ruleset, const char *addr, VSTRING *result)
{
VSTRING *src = vstring_alloc(100);
VSTRING *dst = vstring_alloc(100);
/*
* Convert the address from internal address form to external RFC822
* form, then rewrite it. After rewriting, convert to internal form.
*/
quote_822_local(src, addr);
rewrite_clnt(ruleset, STR(src), dst);
unquote_822_local(result, STR(dst));
vstring_free(src);
vstring_free(dst);
return (result);
}
int main(int unused_argc, char **unused_argv)
{
VSTRING *raw = vstring_alloc(100);
VSTRING *quoted = vstring_alloc(100);
VSTRING *unquoted = vstring_alloc(100);
while (vstring_fgets_nonl(raw, VSTREAM_IN)) {
quote_822_local(quoted, STR(raw));
vstream_printf("quoted: %s\n", STR(quoted));
unquote_822_local(unquoted, STR(quoted));
vstream_printf("unquoted: %s\n", STR(unquoted));
vstream_fflush(VSTREAM_OUT);
}
vstring_free(unquoted);
vstring_free(quoted);
vstring_free(raw);
return (0);
}
ARGV *cleanup_map1n_internal(CLEANUP_STATE *state, const char *addr,
MAPS *maps, int propagate)
{
ARGV *argv;
ARGV *lookup;
int count;
int i;
int arg;
BH_TABLE *been_here;
char *saved_lhs;
/*
* Initialize.
*/
argv = argv_alloc(1);
argv_add(argv, addr, ARGV_END);
argv_terminate(argv);
been_here = been_here_init(0, BH_FLAG_FOLD);
/*
* Rewrite the address vector in place. With each map lookup result,
* split it into separate addresses, then rewrite and flatten each
* address, and repeat the process. Beware: argv is being changed, so we
* must index the array explicitly, instead of running along it with a
* pointer.
*/
#define UPDATE(ptr,new) do { \
if (ptr) myfree(ptr); ptr = mystrdup(new); \
} while (0)
#define STR vstring_str
#define RETURN(x) do { \
been_here_free(been_here); return (x); \
} while (0)
#define UNEXPAND(argv, addr) do { \
argv_truncate((argv), 0); argv_add((argv), (addr), (char *) 0); \
} while (0)
for (arg = 0; arg < argv->argc; arg++) {
if (argv->argc > var_virt_expan_limit) {
msg_warn("%s: unreasonable %s map expansion size for %s -- "
"message not accepted, try again later",
state->queue_id, maps->title, addr);
state->errs |= CLEANUP_STAT_DEFER;
UPDATE(state->reason, "4.6.0 Alias expansion error");
UNEXPAND(argv, addr);
RETURN(argv);
}
for (count = 0; /* void */ ; count++) {
/*
* Don't expand an address that already expanded into itself.
*/
if (been_here_check_fixed(been_here, argv->argv[arg]) != 0)
break;
if (count >= var_virt_recur_limit) {
msg_warn("%s: unreasonable %s map nesting for %s -- "
"message not accepted, try again later",
state->queue_id, maps->title, addr);
state->errs |= CLEANUP_STAT_DEFER;
UPDATE(state->reason, "4.6.0 Alias expansion error");
UNEXPAND(argv, addr);
RETURN(argv);
}
quote_822_local(state->temp1, argv->argv[arg]);
if ((lookup = mail_addr_map(maps, STR(state->temp1), propagate)) != 0) {
saved_lhs = mystrdup(argv->argv[arg]);
for (i = 0; i < lookup->argc; i++) {
unquote_822_local(state->temp1, lookup->argv[i]);
if (i == 0) {
UPDATE(argv->argv[arg], STR(state->temp1));
} else {
argv_add(argv, STR(state->temp1), ARGV_END);
argv_terminate(argv);
}
/*
* Allow an address to expand into itself once.
*/
if (strcasecmp(saved_lhs, STR(state->temp1)) == 0)
been_here_fixed(been_here, saved_lhs);
}
myfree(saved_lhs);
argv_free(lookup);
} else if (maps->error != 0) {
msg_warn("%s: %s map lookup problem for %s -- "
"message not accepted, try again later",
state->queue_id, maps->title, addr);
state->errs |= CLEANUP_STAT_WRITE;
UPDATE(state->reason, "4.6.0 Alias expansion error");
UNEXPAND(argv, addr);
RETURN(argv);
} else {
break;
}
}
}
RETURN(argv);
}
const char *mail_addr_find_opt(MAPS *path, const char *address, char **extp,
int in_form, int query_form,
int out_form, int strategy)
{
const char *myname = "mail_addr_find";
VSTRING *ext_addr_buf = 0;
VSTRING *int_addr_buf = 0;
const char *int_addr;
static VSTRING *int_result = 0;
const char *result;
char *ratsign = 0;
char *int_full_key;
char *int_bare_key;
char *saved_ext;
int rc = 0;
/*
* Optionally convert the address from external form.
*/
if (in_form == MA_FORM_EXTERNAL) {
int_addr_buf = vstring_alloc(100);
unquote_822_local(int_addr_buf, address);
int_addr = STR(int_addr_buf);
} else {
int_addr = address;
}
if (query_form == MA_FORM_EXTERNAL_FIRST
|| query_form == MA_FORM_EXTERNAL)
ext_addr_buf = vstring_alloc(100);
/*
* Initialize.
*/
int_full_key = mystrdup(int_addr);
if (*var_rcpt_delim == 0 || (strategy & MA_FIND_NOEXT) == 0) {
int_bare_key = saved_ext = 0;
} else {
/* XXX This could be done after user+foo@domain fails. */
int_bare_key =
strip_addr_internal(int_full_key, &saved_ext, var_rcpt_delim);
}
/*
* Try user+foo@domain and user@domain.
*/
if ((strategy & MA_FIND_FULL) != 0) {
result = find_addr(path, int_full_key, FULL, WITH_DOMAIN,
query_form, ext_addr_buf);
} else {
result = 0;
path->error = 0;
}
if (result == 0 && path->error == 0 && int_bare_key != 0
&& (result = find_addr(path, int_bare_key, PARTIAL, WITH_DOMAIN,
query_form, ext_addr_buf)) != 0
&& extp != 0) {
*extp = saved_ext;
saved_ext = 0;
}
/*
* Try user+foo if the domain matches user+foo@$myorigin,
* user+foo@$mydestination or user+foo@[${proxy,inet}_interfaces]. Then
* try with +foo stripped off.
*/
if (result == 0 && path->error == 0
&& (ratsign = strrchr(int_full_key, '@')) != 0
&& (strategy & (MA_FIND_LOCALPART_IF_LOCAL
| MA_FIND_LOCALPART_AT_IF_LOCAL)) != 0) {
if (strcasecmp_utf8(ratsign + 1, var_myorigin) == 0
|| (rc = resolve_local(ratsign + 1)) > 0) {
if ((strategy & MA_FIND_LOCALPART_IF_LOCAL) != 0)
result = find_local(path, ratsign, 0, int_full_key,
int_bare_key, query_form, extp, &saved_ext,
ext_addr_buf);
if (result == 0 && path->error == 0
&& (strategy & MA_FIND_LOCALPART_AT_IF_LOCAL) != 0)
result = find_local(path, ratsign, 1, int_full_key,
int_bare_key, query_form, extp, &saved_ext,
ext_addr_buf);
} else if (rc < 0)
path->error = rc;
}
/*
* Try @domain.
*/
if (result == 0 && path->error == 0 && ratsign != 0
&& (strategy & MA_FIND_AT_DOMAIN) != 0)
result = maps_find(path, ratsign, PARTIAL);
/*
* Try domain (optionally, subdomains).
*/
if (result == 0 && path->error == 0 && ratsign != 0
&& (strategy & MA_FIND_DOMAIN) != 0) {
const char *name;
const char *next;
if ((strategy & MA_FIND_PDMS) && (strategy & MA_FIND_PDDMDS))
msg_warn("mail_addr_find_opt: do not specify both "
"MA_FIND_PDMS and MA_FIND_PDDMDS");
for (name = ratsign + 1; *name != 0; name = next) {
if ((result = maps_find(path, name, PARTIAL)) != 0
|| path->error != 0
|| (strategy & (MA_FIND_PDMS | MA_FIND_PDDMDS)) == 0
|| (next = strchr(name + 1, '.')) == 0)
break;
if ((strategy & MA_FIND_PDDMDS) == 0)
next++;
}
}
/*
* Try localpart@ even if the domain is not local.
*/
if ((strategy & MA_FIND_LOCALPART_AT) != 0 \
&&result == 0 && path->error == 0)
result = find_local(path, ratsign, 1, int_full_key,
int_bare_key, query_form, extp, &saved_ext,
ext_addr_buf);
/*
* Optionally convert the result to internal form. The lookup result is
* supposed to be one external-form email address.
*/
if (result != 0 && out_form == MA_FORM_INTERNAL) {
if (int_result == 0)
int_result = vstring_alloc(100);
unquote_822_local(int_result, result);
result = STR(int_result);
}
/*
* Clean up.
*/
if (msg_verbose)
msg_info("%s: %s -> %s", myname, address,
result ? result :
path->error ? "(try again)" :
"(not found)");
myfree(int_full_key);
if (int_bare_key)
myfree(int_bare_key);
if (saved_ext)
myfree(saved_ext);
if (int_addr_buf)
vstring_free(int_addr_buf);
if (ext_addr_buf)
vstring_free(ext_addr_buf);
return (result);
}
