自学教程：C++ vstream_printf函数代码示例

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 *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 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 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);}

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 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);}

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);}