int main(int unused_argc, char **unused_argv)
{
VSTRING *in_buf = vstring_alloc(10);
VSTRING *parse_buf = vstring_alloc(10);
char *host;
char *port;
const char *err;
while (vstring_fgets_nonl(in_buf, VSTREAM_IN)) {
vstream_printf(">> %s\n", STR(in_buf));
vstream_fflush(VSTREAM_OUT);
if (*STR(in_buf) == '#')
continue;
vstring_strcpy(parse_buf, STR(in_buf));
if ((err = host_port(STR(parse_buf), &host, (char *) 0, &port, "default-service")) != 0) {
msg_warn("%s in %s", err, STR(in_buf));
} else {
vstream_printf("host %s port %s\n", host, port);
vstream_fflush(VSTREAM_OUT);
}
}
vstring_free(in_buf);
vstring_free(parse_buf);
return (0);
}
int main(int argc, char **argv)
{
VSTRING *inbuf = vstring_alloc(1);
int have_tty = isatty(0);
if (argc > 1) {
while (--argc > 0 && *++argv)
parse_sample(*argv);
} else {
for (;;) {
if (have_tty) {
vstream_printf("> ");
vstream_fflush(VSTREAM_OUT);
}
if (vstring_fgets_nonl(inbuf, VSTREAM_IN) <= 0)
break;
if (have_tty == 0)
vstream_printf("> %s\n", STR(inbuf));
if (*STR(inbuf) == 0 || *STR(inbuf) == '#')
continue;
parse_sample(STR(inbuf));
}
}
vstring_free(inbuf);
return (0);
}
int main(int unused_argc, char **unused_argv)
{
VSTRING *vp = vstring_alloc(10);
int tok_argc;
POP3D_TOKEN *tok_argv;
int i;
for (;;) {
if (isatty(STDIN_FILENO))
vstream_printf("enter POP3D command: ");
vstream_fflush(VSTREAM_OUT);
if (vstring_get_nonl(vp, VSTREAM_IN) == VSTREAM_EOF)
break;
if (*vstring_str(vp) == '#')
continue;
if (!isatty(STDIN_FILENO))
vstream_printf("%s\n", vstring_str(vp));
tok_argc = pop3d_token(vstring_str(vp), &tok_argv);
for (i = 0; i < tok_argc; i++) {
vstream_printf("Token type: %s\n",
tok_argv[i].tokval == POP3D_TOK_OTHER ? "other" :
tok_argv[i].tokval == POP3D_TOK_ERROR ? "error" :
"unknown");
vstream_printf("Token value: %s\n", tok_argv[i].strval);
}
}
exit(0);
}
int main(int argc, char **argv)
{
VSTRING *buf = vstring_alloc(100);
MAPS *maps;
const char *result;
if (argc != 2)
msg_fatal("usage: %s maps", argv[0]);
msg_verbose = 2;
maps = maps_create("whatever", argv[1], DICT_FLAG_LOCK);
while (vstring_fgets_nonl(buf, VSTREAM_IN)) {
maps->error = 99;
vstream_printf("\"%s\": ", vstring_str(buf));
if ((result = maps_find(maps, vstring_str(buf), 0)) != 0) {
vstream_printf("%s\n", result);
} else if (maps->error != 0) {
vstream_printf("lookup error\n");
} else {
vstream_printf("not found\n");
}
vstream_fflush(VSTREAM_OUT);
}
maps_free(maps);
vstring_free(buf);
return (0);
}
int main(int argc, char **argv)
{
VSTRING *in = vstring_alloc(10);
VSTRING *out = vstring_alloc(10);
double tval;
int sec;
int usec;
int sig_dig;
int max_dig;
while (vstring_get_nonl(in, VSTREAM_IN) > 0) {
vstream_printf(">> %s\n", vstring_str(in));
if (vstring_str(in)[0] == 0 || vstring_str(in)[0] == '#')
continue;
if (sscanf(vstring_str(in), "%lf %d %d", &tval, &sig_dig, &max_dig) != 3)
msg_fatal("bad input: %s", vstring_str(in));
sec = (int) tval; /* raw seconds */
usec = (tval - sec) * MILLION; /* raw microseconds */
VSTRING_RESET(out);
format_tv(out, sec, usec, sig_dig, max_dig);
vstream_printf("%s\n", vstring_str(out));
vstream_fflush(VSTREAM_OUT);
}
vstring_free(in);
vstring_free(out);
return (0);
}
int main(int unused_argc, char **unused_argv)
{
static int seconds;
static int minutes;
static int hours;
static int days;
static int weeks;
static const CONFIG_TIME_TABLE time_table[] = {
"seconds", "10s", &seconds, 0, 0,
"minutes", "10m", &minutes, 0, 0,
"hours", "10h", &hours, 0, 0,
"days", "10d", &days, 0, 0,
"weeks", "10w", &weeks, 0, 0,
0,
};
get_mail_conf_time_table(time_table);
vstream_printf("10 seconds = %d\n", seconds);
vstream_printf("10 minutes = %d\n", minutes);
vstream_printf("10 hours = %d\n", hours);
vstream_printf("10 days = %d\n", days);
vstream_printf("10 weeks = %d\n", weeks);
vstream_fflush(VSTREAM_OUT);
return (0);
}
int main(int unused_argc, char **unused_argv)
{
VSTRING *extension = vstring_alloc(1);
VSTRING *buf = vstring_alloc(1);
ARGV *argv;
char **cpp;
mail_conf_read();
if (chdir(var_queue_dir) < 0)
msg_fatal("chdir %s: %m", var_queue_dir);
vstream_printf("extension: (CR for none): ");
vstream_fflush(VSTREAM_OUT);
if (vstring_get_nonl(extension, VSTREAM_IN) == VSTREAM_EOF)
exit(0);
vstream_printf("print strings to be translated, one per line\n");
vstream_fflush(VSTREAM_OUT);
while (vstring_get_nonl(buf, VSTREAM_IN) != VSTREAM_EOF) {
argv = mail_addr_crunch(STR(buf), VSTRING_LEN(extension) ? STR(extension) : 0);
for (cpp = argv->argv; *cpp; cpp++)
vstream_printf(" %s\n", *cpp);
vstream_fflush(VSTREAM_OUT);
}
return (0);
}
static void rewrite(char *rule, char *addr, VSTRING *reply)
{
rewrite_clnt(rule, addr, reply);
vstream_printf("%-10s %s\n", "rule", rule);
vstream_printf("%-10s %s\n", "address", addr);
vstream_printf("%-10s %s\n\n", "result", STR(reply));
vstream_fflush(VSTREAM_OUT);
}
static void show_intval(int mode, const char *name, int value)
{
if (mode & SHOW_NAME) {
vstream_printf("%s = %d\n", name, value);
} else {
vstream_printf("%d\n", value);
}
}
static void help(ARGV *argv)
{
struct action *ap;
vstream_printf("commands:");
for (ap = actions; ap->command != 0; ap++)
vstream_printf(" %s", ap->command);
vstream_printf("\n");
vstream_fflush(VSTREAM_OUT);
}
static void show_strval(int mode, const char *name, const char *value)
{
if (mode & SHOW_EVAL)
value = mail_conf_eval(value);
if (mode & SHOW_NAME) {
vstream_printf("%s = %s\n", name, value);
} else {
vstream_printf("%s\n", value);
}
}
int main(int unused_argc, char **unused_argv)
{
VSTRING *buf = vstring_alloc(100);
VSTRING *result = vstring_alloc(100);
char *cp;
char *name;
char *value;
HTABLE *table;
int stat;
while (!vstream_feof(VSTREAM_IN)) {
table = htable_create(0);
/*
* Read a block of definitions, terminated with an empty line.
*/
while (vstring_get_nonl(buf, VSTREAM_IN) != VSTREAM_EOF) {
vstream_printf("<< %s\n", vstring_str(buf));
vstream_fflush(VSTREAM_OUT);
if (VSTRING_LEN(buf) == 0)
break;
cp = vstring_str(buf);
name = mystrtok(&cp, " \t\r\n=");
value = mystrtok(&cp, " \t\r\n=");
htable_enter(table, name, value ? mystrdup(value) : 0);
}
/*
* Read a block of patterns, terminated with an empty line or EOF.
*/
while (vstring_get_nonl(buf, VSTREAM_IN) != VSTREAM_EOF) {
vstream_printf("<< %s\n", vstring_str(buf));
vstream_fflush(VSTREAM_OUT);
if (VSTRING_LEN(buf) == 0)
break;
cp = vstring_str(buf);
VSTRING_RESET(result);
stat = mac_expand(result, vstring_str(buf), MAC_EXP_FLAG_NONE,
(char *) 0, lookup, (char *) table);
vstream_printf("stat=%d result=%s\n", stat, vstring_str(result));
vstream_fflush(VSTREAM_OUT);
}
htable_free(table, myfree);
vstream_printf("\n");
}
/*
* Clean up.
*/
vstring_free(buf);
vstring_free(result);
exit(0);
}
int main(void)
{
VSTRING *buf = vstring_alloc(1);
while (vstring_get_nonl(buf, VSTREAM_IN) != VSTREAM_EOF) {
vstream_printf("%c", (LEN(buf) && !valid_utf8_string(STR(buf), LEN(buf))) ?
'!' : ' ');
vstream_fwrite(VSTREAM_OUT, STR(buf), LEN(buf));
vstream_printf("\n");
}
vstream_fflush(VSTREAM_OUT);
vstring_free(buf);
exit(0);
}
int main(void)
{
VSTRING *buf = vstring_alloc(100);
SERVER_ACL *argv;
int ret;
int have_tty = isatty(0);
char *bufp;
char *cmd;
char *value;
const NAME_CODE acl_map[] = {
SERVER_ACL_NAME_ERROR, SERVER_ACL_ACT_ERROR,
SERVER_ACL_NAME_PERMIT, SERVER_ACL_ACT_PERMIT,
SERVER_ACL_NAME_REJECT, SERVER_ACL_ACT_REJECT,
SERVER_ACL_NAME_DUNNO, SERVER_ACL_ACT_DUNNO,
0,
};
#define VAR_SERVER_ACL "server_acl"
while (vstring_get_nonl(buf, VSTREAM_IN) != VSTREAM_EOF) {
bufp = STR(buf);
if (have_tty == 0) {
vstream_printf("> %s\n", bufp);
vstream_fflush(VSTREAM_OUT);
}
if (*bufp == '#')
continue;
if ((cmd = mystrtok(&bufp, " =")) == 0 || STREQ(cmd, "?")) {
vstream_printf("usage: %s=value|%s=value|address=value\n",
VAR_MYNETWORKS, VAR_SERVER_ACL);
} else if ((value = mystrtok(&bufp, " =")) == 0) {
vstream_printf("missing value\n");
} else if (STREQ(cmd, VAR_MYNETWORKS)) {
UPDATE_VAR(var_mynetworks, value);
} else if (STREQ(cmd, VAR_SERVER_ACL)) {
UPDATE_VAR(var_server_acl, value);
} else if (STREQ(cmd, "address")) {
server_acl_pre_jail_init(var_mynetworks, VAR_SERVER_ACL);
argv = server_acl_parse(var_server_acl, VAR_SERVER_ACL);
ret = server_acl_eval(value, argv, VAR_SERVER_ACL);
argv_free(argv);
vstream_printf("%s: %s\n", value, str_name_code(acl_map, ret));
} else {
vstream_printf("unknown command: \"%s\"\n", cmd);
}
vstream_fflush(VSTREAM_OUT);
}
vstring_free(buf);
exit(0);
}
int main(int argc, char **argv)
{
DOMAIN_LIST *list;
char *host;
int ch;
msg_vstream_init(argv[0], VSTREAM_ERR);
while ((ch = GETOPT(argc, argv, "v")) > 0) {
switch (ch) {
case 'v':
msg_verbose++;
break;
default:
usage(argv[0]);
}
}
if (argc != optind + 2)
usage(argv[0]);
list = domain_list_init(MATCH_FLAG_PARENT, argv[optind]);
host = argv[optind + 1];
vstream_printf("%s: %s\n", host, domain_list_match(list, host) ?
"YES" : "NO");
vstream_fflush(VSTREAM_OUT);
domain_list_free(list);
return (0);
}
int main(int argc, char **argv)
{
DNS_RR *rr;
MAI_HOSTADDR_STR hostaddr;
VSTRING *why;
int type;
myname = argv[0];
if (argc < 3)
usage();
why = vstring_alloc(1);
while (*++argv) {
if (argv[1] == 0)
usage();
if ((type = dns_type(argv[0])) == 0)
usage();
if (dns_lookup(argv[1], type, 0, &rr, (VSTRING *) 0, why) != DNS_OK)
msg_fatal("%s: %s", argv[1], vstring_str(why));
if (dns_rr_to_pa(rr, &hostaddr) == 0)
msg_fatal("dns_rr_to_sa: %m");
vstream_printf("%s -> %s\n", argv[1], hostaddr.buf);
vstream_fflush(VSTREAM_OUT);
argv += 1;
dns_rr_free(rr);
}
vstring_free(why);
return (0);
}
static void update(char *query)
{
char *addr;
char *status_text;
char *cp = query;
if ((addr = mystrtok(&cp, " \t\r\n")) == 0
|| (status_text = mystrtok(&cp, " \t\r\n")) == 0) {
msg_warn("bad request format");
return;
}
while (*cp && ISSPACE(*cp))
cp++;
if (*cp == 0) {
msg_warn("bad request format");
return;
}
switch (verify_clnt_update(query, atoi(status_text), cp)) {
case VRFY_STAT_OK:
vstream_printf("OK\n");
vstream_fflush(VSTREAM_OUT);
break;
case VRFY_STAT_BAD:
msg_warn("bad request format");
break;
case VRFY_STAT_FAIL:
msg_warn("request failed");
break;
}
}
static void postmap_seq(const char *map_type, const char *map_name,
int dict_flags)
{
DICT *dict;
const char *key;
const char *value;
int func;
if (strcmp(map_type, DICT_TYPE_PROXY) == 0)
msg_fatal("can't sequence maps via the proxy service");
dict = dict_open3(map_type, map_name, O_RDONLY, dict_flags);
for (func = DICT_SEQ_FUN_FIRST; /* void */ ; func = DICT_SEQ_FUN_NEXT) {
if (dict_seq(dict, func, &key, &value) != 0)
break;
if (*key == 0) {
msg_warn("table %s:%s: empty lookup key value is not allowed",
map_type, map_name);
} else if (*value == 0) {
msg_warn("table %s:%s: key %s: empty string result is not allowed",
map_type, map_name, key);
msg_warn("table %s:%s should return NO RESULT in case of NOT FOUND",
map_type, map_name);
}
vstream_printf("%s %s\n", key, value);
}
if (dict->error)
msg_fatal("table %s:%s: sequence error: %m", dict->type, dict->name);
vstream_fflush(VSTREAM_OUT);
dict_close(dict);
}
static void postmap_body(void *ptr, int unused_rec_type,
const char *keybuf,
ssize_t unused_len,
off_t unused_offset)
{
POSTMAP_KEY_STATE *state = (POSTMAP_KEY_STATE *) ptr;
DICT **dicts = state->dicts;
char **maps = state->maps;
int map_count = state->map_count;
int dict_flags = state->dict_flags;
const char *map_name;
const char *value;
int n;
for (n = 0; n < map_count; n++) {
if (dicts[n] == 0)
dicts[n] = ((map_name = split_at(maps[n], ':')) != 0 ?
dict_open3(maps[n], map_name, O_RDONLY, dict_flags) :
dict_open3(var_db_type, maps[n], O_RDONLY, dict_flags));
if ((value = dict_get(dicts[n], keybuf)) != 0) {
if (*value == 0) {
msg_warn("table %s:%s: key %s: empty string result is not allowed",
dicts[n]->type, dicts[n]->name, keybuf);
msg_warn("table %s:%s should return NO RESULT in case of NOT FOUND",
dicts[n]->type, dicts[n]->name);
}
vstream_printf("%s %s\n", keybuf, value);
state->found = 1;
break;
}
if (dicts[n]->error)
msg_fatal("table %s:%s: query error: %m",
dicts[n]->type, dicts[n]->name);
}
}
int main(int argc, char **argv)
{
STRING_LIST *list;
char *string;
int ch;
msg_vstream_init(argv[0], VSTREAM_ERR);
while ((ch = GETOPT(argc, argv, "v")) > 0) {
switch (ch) {
case 'v':
msg_verbose++;
break;
default:
usage(argv[0]);
}
}
if (argc != optind + 2)
usage(argv[0]);
list = string_list_init(MATCH_FLAG_NONE, argv[optind]);
string = argv[optind + 1];
vstream_printf("%s: %s\n", string, string_list_match(list, string) ?
"YES" : "NO");
vstream_fflush(VSTREAM_OUT);
string_list_free(list);
}
static int get_buffer(VSTRING *buf, VSTREAM *fp, int interactive)
{
int status;
if (interactive) {
vstream_printf("> ");
vstream_fflush(VSTREAM_OUT);
}
if ((status = vstring_get_nonl(buf, fp)) != VSTREAM_EOF) {
if (!interactive) {
vstream_printf(">>> %s\n", STR(buf));
vstream_fflush(VSTREAM_OUT);
}
}
return (status);
}
int main(int unused_argc, char **unused_argv)
{
VSTRING *buf = vstring_alloc(100);
char *junk;
unsigned long ulval;
int base;
char ch;
unsigned long ulval2;
#ifdef MISSING_STRTOUL
#define strtoul strtol
#endif
while (vstring_get_nonl(buf, VSTREAM_IN) != VSTREAM_EOF) {
ch = 0;
if (sscanf(STR(buf), "%lu %d%c", &ulval, &base, &ch) != 2 || ch) {
msg_warn("bad input %s", STR(buf));
} else {
(void) safe_ultostr(buf, ulval, base, 5, '0');
vstream_printf("%lu = %s\n", ulval, STR(buf));
ulval2 = safe_strtoul(STR(buf), &junk, base);
if (*junk || (ulval2 == ULONG_MAX && errno == ERANGE))
msg_warn("%s: %m", STR(buf));
if (ulval2 != ulval)
msg_warn("%lu != %lu", ulval2, ulval);
}
vstream_fflush(VSTREAM_OUT);
}
vstring_free(buf);
return (0);
}
int main(int argc, char **argv)
{
VSTRING *buffer = vstring_alloc(100);
MAPS *path;
const char *result;
char *extent;
/*
* Parse JCL.
*/
if (argc != 2)
msg_fatal("usage: %s database", argv[0]);
msg_verbose = 1;
/*
* Initialize.
*/
mail_conf_read();
path = maps_create(argv[0], argv[1], DICT_FLAG_LOCK | DICT_FLAG_FOLD_FIX);
while (vstring_fgets_nonl(buffer, VSTREAM_IN)) {
extent = 0;
result = mail_addr_find(path, STR(buffer), &extent);
vstream_printf("%s -> %s (%s)\n", STR(buffer), result ? result :
path->error ? "(try again)" :
"(not found)", extent ? extent : "null extension");
vstream_fflush(VSTREAM_OUT);
if (extent)
myfree(extent);
}
vstring_free(buffer);
maps_free(path);
return (0);
}
static void iter_action(DICT_CACHE_SREQ *cp, DICT_CACHE *dp, VSTRING *bp)
{
const char *cache_key;
const char *cache_val;
const char *what;
const char *suffix;
if (dict_cache_sequence(dp, cp->first_next, &cache_key, &cache_val) == 0) {
if (strcmp(cache_key, cache_val) != 0)
msg_warn("value \"%s\" differs from key \"%s\"",
cache_val, cache_key);
suffix = cache_key + strspn(cache_key, "0123456789");
if (suffix[0] == '-' && strcmp(suffix + 1, cp->suffix) == 0) {
cp->done += 1;
cp->todo = cp->done + 1; /* XXX */
if ((cp->flags & DICT_CACHE_SREQ_FLAG_PURGE)
&& dict_cache_delete(dp, cache_key) != 0) {
if (dp->error)
msg_warn("purge_action: delete failed: %s: %m", STR(bp));
else
msg_warn("purge_action: delete failed: %s", STR(bp));
}
}
cp->first_next = DICT_SEQ_FUN_NEXT;
} else {
what = (cp->flags & DICT_CACHE_SREQ_FLAG_PURGE) ? "purge" : "count";
if (dp->error)
msg_warn("%s error after %d: %m", what, cp->done);
else
vstream_printf("suffix=%s %s=%d\n", cp->suffix, what, cp->done);
cp->todo = 0;
}
}
static void run_requests(DICT_CACHE_TEST *tp, DICT_CACHE *dp, VSTRING *bp)
{
DICT_CACHE_SREQ *cp;
int todo;
struct timeval start;
struct timeval finish;
struct timeval elapsed;
if (dp == 0) {
msg_warn("no cache");
return;
}
GETTIMEOFDAY(&start);
do {
todo = 0;
for (cp = tp->job_list; cp < tp->job_list + tp->used; cp++) {
if (cp->done < cp->todo) {
todo = 1;
cp->action(cp, dp, bp);
}
}
} while (todo);
GETTIMEOFDAY(&finish);
timersub(&finish, &start, &elapsed);
if (show_elapsed)
vstream_printf("Elapsed: %g\n",
elapsed.tv_sec + elapsed.tv_usec / 1000000.0);
reset_requests(tp);
}
int main(int argc, char **argv)
{
INET_ADDR_LIST list;
struct sockaddr_storage *sa;
MAI_HOSTADDR_STR hostaddr;
INET_PROTO_INFO *proto_info;
msg_vstream_init(argv[0], VSTREAM_ERR);
if (argc < 3)
msg_fatal("usage: %s protocols hostname...", argv[0]);
proto_info = inet_proto_init(argv[0], argv[1]);
argv += 1;
while (--argc && *++argv) {
inet_addr_list_init(&list);
if (inet_addr_host(&list, *argv) == 0)
msg_fatal("not found: %s", *argv);
for (sa = list.addrs; sa < list.addrs + list.used; sa++) {
SOCKADDR_TO_HOSTADDR(SOCK_ADDR_PTR(sa), SOCK_ADDR_LEN(sa),
&hostaddr, (MAI_SERVPORT_STR *) 0, 0);
vstream_printf("%s\t%s\n", *argv, hostaddr.buf);
}
vstream_fflush(VSTREAM_OUT);
inet_addr_list_free(&list);
}
return (0);
}
int main(int argc, char **argv)
{
int pair1[2];
int pair2[2];
msg_vstream_init(argv[0], VSTREAM_ERR);
#define DELAY 1
if (socketpair(AF_UNIX, SOCK_STREAM, 0, pair1) < 0)
msg_fatal("socketpair: %m");
if (socketpair(AF_UNIX, SOCK_STREAM, 0, pair2) < 0)
msg_fatal("socketpair: %m");
vstream_printf("Doing multiple select on socket1, then write to it...\n");
vstream_fflush(VSTREAM_OUT);
fork_and_read_select("socket1", DELAY, pair1[0]); /* one */
fork_and_read_select("socket1", DELAY, pair1[0]); /* two */
fork_and_read_select("socket2", DELAY, pair2[0]);
fork_and_read_select("stdin", DELAY, 0);
if (write(pair1[1], "", 1) != 1)
msg_fatal("write: %m");
while (wait((int *) 0) >= 0)
/* void */ ;
return (0);
}
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);
}
static void query(char *query, VSTRING *buf)
{
int status;
switch (verify_clnt_query(query, &status, buf)) {
case VRFY_STAT_OK:
vstream_printf("%-10s %d\n", "status", status);
vstream_printf("%-10s %s\n", "text", STR(buf));
vstream_fflush(VSTREAM_OUT);
break;
case VRFY_STAT_BAD:
msg_warn("bad request format");
break;
case VRFY_STAT_FAIL:
msg_warn("request failed");
break;
}
}
void pcf_show_locks(void)
{
ARGV *locks_argv;
int i;
locks_argv = mbox_lock_names();
for (i = 0; i < locks_argv->argc; i++)
vstream_printf("%s\n", locks_argv->argv[i]);
argv_free(locks_argv);
}
