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

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

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

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

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