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 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 post_jail_init(char *service_name, char **unused_argv) { /* * Special case: dump bounce templates. This is not part of the master(5) * public interface. This internal interface is used by the postconf * command. It was implemented before bounce templates were isolated into * modules that could have been called directly. */ if (strcmp(service_name, "dump_templates") == 0) { bounce_templates_dump(VSTREAM_OUT, bounce_templates); vstream_fflush(VSTREAM_OUT); exit(0); } if (strcmp(service_name, "expand_templates") == 0) { bounce_templates_expand(VSTREAM_OUT, bounce_templates); vstream_fflush(VSTREAM_OUT); exit(0); } /* * Initialize. We're single threaded so we can reuse some memory upon * successive requests. */ queue_id = vstring_alloc(10); queue_name = vstring_alloc(10); rcpt_buf = rcpb_create(); encoding = vstring_alloc(10); sender = vstring_alloc(10); dsn_envid = vstring_alloc(10); verp_delims = vstring_alloc(10); dsn_buf = dsb_create(); }
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(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); }
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 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); }
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); }
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 pcf_print_parameter(VSTREAM *fp, int mode, const char *name, PCF_PARAM_NODE *node) { const char *value; /* * Use the default or actual value. */ value = pcf_lookup_parameter_value(mode, name, (PCF_MASTER_ENT *) 0, node); /* * Optionally expand $name in the parameter value. Print the result with * or without the name= prefix. */ if (value != 0) { if (mode & PCF_HIDE_VALUE) { pcf_print_line(fp, mode, "%s\n", name); } else { if ((mode & PCF_SHOW_EVAL) != 0 && PCF_RAW_PARAMETER(node) == 0) value = pcf_expand_parameter_value((VSTRING *) 0, mode, value, (PCF_MASTER_ENT *) 0); if ((mode & PCF_HIDE_NAME) == 0) { pcf_print_line(fp, mode, "%s = %s\n", name, value); } else { pcf_print_line(fp, mode, "%s\n", value); } } if (msg_verbose) vstream_fflush(fp); } }
static int deliver_request_final(VSTREAM *stream, DELIVER_REQUEST *request, int status) { DSN *hop_status; int err; /* XXX This DSN structure initialization bypasses integrity checks. */ static DSN dummy_dsn = {"", "", "", "", "", "", ""}; /* * Send the status and the optional reason. */ if ((hop_status = request->hop_status) == 0) hop_status = &dummy_dsn; if (msg_verbose) msg_info("deliver_request_final: send: \"%s\" %d", hop_status->reason, status); attr_print(stream, ATTR_FLAG_NONE, ATTR_TYPE_FUNC, dsn_print, (void *) hop_status, ATTR_TYPE_INT, MAIL_ATTR_STATUS, status, ATTR_TYPE_END); if ((err = vstream_fflush(stream)) != 0) if (msg_verbose) msg_warn("send final status: %m"); /* * With some UNIX systems, stream sockets lose data when you close them * immediately after writing to them. That is not how sockets are * supposed to behave! The workaround is to wait until the receiver * closes the connection. Calling VSTREAM_GETC() has the benefit of using * whatever timeout is specified in the ipc_timeout parameter. */ (void) VSTREAM_GETC(stream); return (err); }
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 verify_service(VSTREAM *client_stream, char *unused_service, char **argv) { VSTRING *request = vstring_alloc(10); /* * Sanity check. This service takes no command-line arguments. */ if (argv[0]) msg_fatal("unexpected command-line argument: %s", argv[0]); /* * This routine runs whenever a client connects to the socket dedicated * to the address verification service. All connection-management stuff * is handled by the common code in multi_server.c. */ if (attr_scan(client_stream, ATTR_FLAG_MORE | ATTR_FLAG_STRICT, RECV_ATTR_STR(MAIL_ATTR_REQ, request), ATTR_TYPE_END) == 1) { if (STREQ(STR(request), VRFY_REQ_UPDATE)) { verify_update_service(client_stream); } else if (STREQ(STR(request), VRFY_REQ_QUERY)) { verify_query_service(client_stream); } else { msg_warn("unrecognized request: \"%s\", ignored", STR(request)); attr_print(client_stream, ATTR_FLAG_NONE, SEND_ATTR_INT(MAIL_ATTR_STATUS, VRFY_STAT_BAD), ATTR_TYPE_END); } } vstream_fflush(client_stream); vstring_free(request); }
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 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); }
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 edit_file_close(EDIT_FILE *ep) { VSTREAM *fp = ep->tmp_fp; int fd = vstream_fileno(fp); int saved_errno; /* * The rename/unlock portion of the protocol is relatively simple. The * only things that really matter here are that we change permissions as * late as possible, and that we rename the file to its final pathname * before we lose the exclusive lock. * * Applications that are concerned about maximal safety should protect the * edit_file_close() call with sigdelay() and sigresume() calls. It is * not safe for us to call these functions directly, because the calls do * not nest. It is also not nice to force every caller to run with * interrupts turned off. */ if (vstream_fflush(fp) < 0 || fchmod(fd, ep->final_mode) < 0 #ifdef HAS_FSYNC || fsync(fd) < 0 #endif || rename(ep->tmp_path, ep->final_path) < 0) { saved_errno = errno; edit_file_cleanup(ep); errno = saved_errno; return (VSTREAM_EOF); } else { (void) vstream_fclose(ep->tmp_fp); EDIT_FILE_FREE(ep); return (0); } }
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); }
static void print_parameter(int mode, char *ptr) { #define INSIDE(p,t) (ptr >= (char *) t && ptr < ((char *) t) + sizeof(t)) /* * This is gross, but the best we can do on short notice. */ if (INSIDE(ptr, time_table)) print_time(mode, (CONFIG_TIME_TABLE *) ptr); if (INSIDE(ptr, bool_table)) print_bool(mode, (CONFIG_BOOL_TABLE *) ptr); if (INSIDE(ptr, int_table)) print_int(mode, (CONFIG_INT_TABLE *) ptr); if (INSIDE(ptr, str_table)) print_str(mode, (CONFIG_STR_TABLE *) ptr); if (INSIDE(ptr, str_fn_table)) print_str_fn(mode, (CONFIG_STR_FN_TABLE *) ptr); if (INSIDE(ptr, str_fn_table_2)) print_str_fn_2(mode, (CONFIG_STR_FN_TABLE *) ptr); if (INSIDE(ptr, raw_table)) print_raw(mode, (CONFIG_RAW_TABLE *) ptr); if (INSIDE(ptr, nint_table)) print_nint(mode, (CONFIG_NINT_TABLE *) ptr); if (msg_verbose) vstream_fflush(VSTREAM_OUT); }
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 unused_argc, char **argv) { HTABLE *table = htable_create(1); msg_vstream_init(argv[0], VSTREAM_ERR); msg_verbose = 1; htable_enter(table, "foo-name", mystrdup("foo-value")); htable_enter(table, "bar-name", mystrdup("bar-value")); attr_print64(VSTREAM_OUT, ATTR_FLAG_NONE, ATTR_TYPE_NUM, ATTR_NAME_NUM, 4711, ATTR_TYPE_LONG, ATTR_NAME_LONG, 1234, ATTR_TYPE_STR, ATTR_NAME_STR, "whoopee", ATTR_TYPE_HASH, table, ATTR_TYPE_END); attr_print64(VSTREAM_OUT, ATTR_FLAG_NONE, ATTR_TYPE_NUM, ATTR_NAME_NUM, 4711, ATTR_TYPE_LONG, ATTR_NAME_LONG, 1234, ATTR_TYPE_STR, ATTR_NAME_STR, "whoopee", ATTR_TYPE_END); if (vstream_fflush(VSTREAM_OUT) != 0) msg_fatal("write error: %m"); htable_free(table, myfree); 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 **argv) { HTABLE *table = htable_create(1); msg_vstream_init(argv[0], VSTREAM_ERR); msg_verbose = 1; htable_enter(table, "foo-name", mystrdup("foo-value")); htable_enter(table, "bar-name", mystrdup("bar-value")); attr_print64(VSTREAM_OUT, ATTR_FLAG_NONE, SEND_ATTR_INT(ATTR_NAME_INT, 4711), SEND_ATTR_LONG(ATTR_NAME_LONG, 1234L), SEND_ATTR_STR(ATTR_NAME_STR, "whoopee"), SEND_ATTR_DATA(ATTR_NAME_DATA, strlen("whoopee"), "whoopee"), SEND_ATTR_HASH(table), SEND_ATTR_LONG(ATTR_NAME_LONG, 4321L), ATTR_TYPE_END); attr_print64(VSTREAM_OUT, ATTR_FLAG_NONE, SEND_ATTR_INT(ATTR_NAME_INT, 4711), SEND_ATTR_LONG(ATTR_NAME_LONG, 1234L), SEND_ATTR_STR(ATTR_NAME_STR, "whoopee"), SEND_ATTR_DATA(ATTR_NAME_DATA, strlen("whoopee"), "whoopee"), ATTR_TYPE_END); if (vstream_fflush(VSTREAM_OUT) != 0) msg_fatal("write error: %m"); htable_free(table, myfree); 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 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 resolve_proto(RES_CONTEXT *context, VSTREAM *stream) { int flags; if (attr_scan(stream, ATTR_FLAG_STRICT, ATTR_TYPE_STR, MAIL_ATTR_ADDR, query, ATTR_TYPE_END) != 1) return (-1); resolve_addr(context, STR(query), channel, nexthop, nextrcpt, &flags); if (msg_verbose) msg_info("%s -> (`%s' `%s' `%s' `%d')", STR(query), STR(channel), STR(nexthop), STR(nextrcpt), flags); attr_print(stream, ATTR_FLAG_NONE, ATTR_TYPE_STR, MAIL_ATTR_TRANSPORT, STR(channel), ATTR_TYPE_STR, MAIL_ATTR_NEXTHOP, STR(nexthop), ATTR_TYPE_STR, MAIL_ATTR_RECIP, STR(nextrcpt), ATTR_TYPE_NUM, MAIL_ATTR_FLAGS, flags, ATTR_TYPE_END); if (vstream_fflush(stream) != 0) { msg_warn("write resolver reply: %m"); return (-1); } return (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)) { if ((result = maps_find(maps, vstring_str(buf), 0)) != 0) { vstream_printf("%s\n", result); } else if (dict_errno != 0) { msg_fatal("lookup error: %m"); } else { vstream_printf("not found\n"); } vstream_fflush(VSTREAM_OUT); } maps_free(maps); vstring_free(buf); 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); }
void cleanup_final(CLEANUP_STATE *state) { const char *myname = "cleanup_final"; /* * vstream_fseek() would flush the buffer anyway, but the code just reads * better if we flush first, because it makes seek error handling more * straightforward. */ if (vstream_fflush(state->dst)) { if (errno == EFBIG) { msg_warn("%s: queue file size limit exceeded", state->queue_id); state->errs |= CLEANUP_STAT_SIZE; } else { msg_warn("%s: write queue file: %m", state->queue_id); state->errs |= CLEANUP_STAT_WRITE; } return; } /* * Update the preliminary message size and count fields with the actual * values. */ if (vstream_fseek(state->dst, 0L, SEEK_SET) < 0) msg_fatal("%s: vstream_fseek %s: %m", myname, cleanup_path); cleanup_out_format(state, REC_TYPE_SIZE, REC_TYPE_SIZE_FORMAT, (REC_TYPE_SIZE_CAST1) (state->xtra_offset - state->data_offset), (REC_TYPE_SIZE_CAST2) state->data_offset, (REC_TYPE_SIZE_CAST3) state->rcpt_count, (REC_TYPE_SIZE_CAST4) state->qmgr_opts, (REC_TYPE_SIZE_CAST5) state->cont_length); }
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); }