20050708
- Bugfix: missing returns in 20050706 caching disabling code.
- File: global/scache_clnt.c.
+ Bugfix: missing returns in 20050706 caching disabling code
+ (in error handling code that never executes). File:
+ global/scache_clnt.c.
+
+ Portability: use explicitly unsigned operands when doing
+ bit-wise shift operations on data larger than a character.
+
+20050709-14
+
+ Migration of data object sizes from int->ssize_t and
+ unsigned->size_t for better portability to LP64 and LLP64
+ systems. Simply changing everything to size_t would be
+ dangerous. A lot of code was written assuming signed
+ arithmetic; for example, it recognizes negative lengths as
+ an indication of integer overflow. Files: util/vbuf.[hc],
+ util/mymalloc.[hc], util/vstring.[hc], util/vstream.[hc],
+ util/timed_read.c, util/timed_write.c and functions that
+ override timed_read/write.c; in a later round updated pretty
+ much everything that contains a length of, or an offset
+ into, a buffer. This eliminates unnecessary conversions
+ back and forth between 32-bit and 64-bit integers.
+
+20050710-3
+
+ Portability: on LP64 systems, integer expressions are int,
+ but sizeof() and pointer difference expressions are larger.
+ Fixed a few discrepancies with functions that expect int:
+ util/clean_env.c, util/argv.c, util/attr_print*.c.
+
+20050711
+
+ Bugfix: don't include <> when auto-generating an ORCPT
+ address from a client RCPT TO command. File: smtpd.c.
+
+20050712
+
+ Cleanup: cleanup_out_recipient() still generated DSN records
+ that were incompatible with pre-DSN Postfix versions. File:
+ cleanup/cleanup_out_recipient.c.
Open problems:
<b><a href="postconf.5.html#remote_header_rewrite_domain">remote_header_rewrite_domain</a> (empty)</b>
Don't rewrite message headers from remote clients
at all when this parameter is empty; otherwise, re-
- write remote message headers and append the speci-
- fied domain name to incomplete addresses.
+ write message headers and append the specified
+ domain name to incomplete addresses.
<b>ROUTING CONTROLS</b>
The following is applicable to Postfix version 2.0 and
Available in Postfix 2.2 and later:
.IP "\fBremote_header_rewrite_domain (empty)\fR"
Don't rewrite message headers from remote clients at all when
-this parameter is empty; otherwise, rewrite remote message headers
-and append the specified domain name to incomplete addresses.
+this parameter is empty; otherwise, rewrite message headers and
+append the specified domain name to incomplete addresses.
.SH "ROUTING CONTROLS"
.na
.nf
/* bounce_print - line_wrap callback */
-static void bounce_print(const char *str, int len, int indent, char *context)
+static void bounce_print(const char *str, ssize_t len, ssize_t indent, char *context)
{
VSTREAM *bounce = (VSTREAM *) context;
- post_mail_fprintf(bounce, "%*s%.*s", indent, "", len, str);
+ post_mail_fprintf(bounce, "%*s%.*s", (int) indent, "", (int) len, str);
}
/* bounce_print_wrap - print and wrap a line */
cleanup_out.o: cleanup.h
cleanup_out.o: cleanup_out.c
cleanup_out_recipient.o: ../../include/argv.h
+cleanup_out_recipient.o: ../../include/attr.h
cleanup_out_recipient.o: ../../include/been_here.h
cleanup_out_recipient.o: ../../include/bounce.h
cleanup_out_recipient.o: ../../include/cleanup_user.h
cleanup_out_recipient.o: ../../include/ext_prop.h
cleanup_out_recipient.o: ../../include/header_opts.h
cleanup_out_recipient.o: ../../include/htable.h
+cleanup_out_recipient.o: ../../include/iostuff.h
cleanup_out_recipient.o: ../../include/mail_conf.h
cleanup_out_recipient.o: ../../include/mail_params.h
+cleanup_out_recipient.o: ../../include/mail_proto.h
cleanup_out_recipient.o: ../../include/mail_queue.h
cleanup_out_recipient.o: ../../include/mail_stream.h
cleanup_out_recipient.o: ../../include/maps.h
int hop_count; /* count of received: headers */
char *resent; /* any resent- header seen */
BH_TABLE *dups; /* recipient dup filter */
- void (*action) (struct CLEANUP_STATE *, int, const char *, int);
+ void (*action) (struct CLEANUP_STATE *, int, const char *, ssize_t);
off_t data_offset; /* start of message content */
off_t xtra_offset; /* start of extra segment */
- int rcpt_count; /* recipient count */
+ ssize_t rcpt_count; /* recipient count */
char *reason; /* failure reason */
NVTABLE *attr; /* queue file attribute list */
MIME_STATE *mime_state; /* MIME state engine */
/*
* cleanup_out.c
*/
-extern void cleanup_out(CLEANUP_STATE *, int, const char *, int);
+extern void cleanup_out(CLEANUP_STATE *, int, const char *, ssize_t);
extern void cleanup_out_string(CLEANUP_STATE *, int, const char *);
extern void PRINTFLIKE(3, 4) cleanup_out_format(CLEANUP_STATE *, int, const char *,...);
/*
* cleanup_envelope.c
*/
-extern void cleanup_envelope(CLEANUP_STATE *, int, const char *, int);
+extern void cleanup_envelope(CLEANUP_STATE *, int, const char *, ssize_t);
/*
* cleanup_message.c
*/
-extern void cleanup_message(CLEANUP_STATE *, int, const char *, int);
+extern void cleanup_message(CLEANUP_STATE *, int, const char *, ssize_t);
/*
* cleanup_extracted.c
*/
-extern void cleanup_extracted(CLEANUP_STATE *, int, const char *, int);
+extern void cleanup_extracted(CLEANUP_STATE *, int, const char *, ssize_t);
/*
* cleanup_rewrite.c
/* CLEANUP_STATE *state;
/* int type;
/* const char *buf;
-/* int len;
+/* ssize_t len;
/* DESCRIPTION
/* This module processes envelope records and writes the result
/* to the queue file. It validates the message structure, rewrites
#define STR vstring_str
#define STREQ(x,y) (strcmp((x), (y)) == 0)
-static void cleanup_envelope_process(CLEANUP_STATE *, int, const char *, int);
+static void cleanup_envelope_process(CLEANUP_STATE *, int, const char *, ssize_t);
/* cleanup_envelope - initialize message envelope */
void cleanup_envelope(CLEANUP_STATE *state, int type,
- const char *str, int len)
+ const char *str, ssize_t len)
{
/*
/* cleanup_envelope_process - process one envelope record */
static void cleanup_envelope_process(CLEANUP_STATE *state, int type,
- const char *buf, int len)
+ const char *buf, ssize_t len)
{
char *attr_name;
char *attr_value;
const char *mapped_buf = buf;
if (msg_verbose)
- msg_info("initial envelope %c %.*s", type, len, buf);
+ msg_info("initial envelope %c %.*s", type, (int) len, buf);
if (type == REC_TYPE_FLGS) {
/* Not part of queue file format. */
/* CLEANUP_STATE *state;
/* int type;
/* const char *buf;
-/* int len;
+/* ssize_t len;
/* DESCRIPTION
/* This module processes message records with information extracted
/* from message content, or with recipients that are stored after the
#define STR(x) vstring_str(x)
-static void cleanup_extracted_process(CLEANUP_STATE *, int, const char *, int);
+static void cleanup_extracted_process(CLEANUP_STATE *, int, const char *, ssize_t);
static void cleanup_extracted_finish(CLEANUP_STATE *);
/* cleanup_extracted - initialize extracted segment */
void cleanup_extracted(CLEANUP_STATE *state, int type,
- const char *buf, int len)
+ const char *buf, ssize_t len)
{
/*
/* cleanup_extracted_process - process one extracted envelope record */
void cleanup_extracted_process(CLEANUP_STATE *state, int type,
- const char *buf, int len)
+ const char *buf, ssize_t len)
{
const char *encoding;
const char generated_by_cleanup[] = {
int junk;
if (msg_verbose)
- msg_info("extracted envelope %c %.*s", type, len, buf);
+ msg_info("extracted envelope %c %.*s", type, (int) len, buf);
if (strchr(REC_TYPE_EXTRACT, type) == 0) {
msg_warn("%s: message rejected: "
int cleanup_masquerade_external(VSTRING *addr, ARGV *masq_domains)
{
char *domain;
- int domain_len;
+ ssize_t domain_len;
char **masqp;
char *masq;
- int masq_len;
+ ssize_t masq_len;
char *parent;
int truncate;
int did_rewrite = 0;
/* CLEANUP_STATE *state;
/* int type;
/* const char *buf;
-/* int len;
+/* ssize_t len;
/* DESCRIPTION
/* This module processes message content records and copies the
/* result to the queue file. It validates the input, rewrites
/* cleanup_body_callback - output one body record */
static void cleanup_body_callback(void *context, int type,
- const char *buf, int len,
+ const char *buf, ssize_t len,
off_t offset)
{
CLEANUP_STATE *state = (CLEANUP_STATE *) context;
/* cleanup_message_headerbody - process message content, header and body */
static void cleanup_message_headerbody(CLEANUP_STATE *state, int type,
- const char *buf, int len)
+ const char *buf, ssize_t len)
{
char *myname = "cleanup_message_headerbody";
MIME_STATE_DETAIL *detail;
/* cleanup_message - initialize message content segment */
-void cleanup_message(CLEANUP_STATE *state, int type, const char *buf, int len)
+void cleanup_message(CLEANUP_STATE *state, int type, const char *buf, ssize_t len)
{
char *myname = "cleanup_message";
int mime_options;
/* CLEANUP_STATE *state;
/* int type;
/* const char *data;
-/* int len;
+/* ssize_t len;
/*
/* void cleanup_out_string(state, type, str)
/* CLEANUP_STATE *state;
/* cleanup_out - output one single record */
-void cleanup_out(CLEANUP_STATE *state, int type, const char *string, int len)
+void cleanup_out(CLEANUP_STATE *state, int type, const char *string, ssize_t len)
{
int err = 0;
#include <dsn.h>
#include <trace.h>
#include <mail_queue.h> /* cleanup_trace_path */
+#include <mail_proto.h>
/* Application-specific. */
if (been_here(state->dups, "%s\n%d\n%s\n%s",
dsn_orcpt, dsn_notify, orcpt, recip) == 0) {
if (dsn_notify)
- cleanup_out_format(state, REC_TYPE_DSN_NOTIFY, "%d",
- dsn_notify);
+ cleanup_out_format(state, REC_TYPE_ATTR, "%s=%d",
+ MAIL_ATTR_DSN_NOTIFY, dsn_notify);
if (*dsn_orcpt)
- cleanup_out_string(state, REC_TYPE_DSN_ORCPT, dsn_orcpt);
+ cleanup_out_format(state, REC_TYPE_ATTR, "%s=%s",
+ MAIL_ATTR_DSN_ORCPT, dsn_orcpt);
cleanup_out_string(state, REC_TYPE_ORCP, orcpt);
cleanup_out_string(state, REC_TYPE_RCPT, recip);
state->rcpt_count++;
if (been_here(state->dups, "%s\n%d\n%s\n%s",
dsn_orcpt, dsn_notify, orcpt, *cpp) == 0) {
if (dsn_notify)
- cleanup_out_format(state, REC_TYPE_DSN_NOTIFY, "%d",
- dsn_notify);
+ cleanup_out_format(state, REC_TYPE_ATTR, "%s=%d",
+ MAIL_ATTR_DSN_NOTIFY, dsn_notify);
if (*dsn_orcpt)
- cleanup_out_string(state, REC_TYPE_DSN_ORCPT, dsn_orcpt);
+ cleanup_out_format(state, REC_TYPE_ATTR, "%s=%s",
+ MAIL_ATTR_DSN_ORCPT, dsn_orcpt);
cleanup_out_string(state, REC_TYPE_ORCP, orcpt);
cleanup_out_string(state, REC_TYPE_RCPT, *cpp);
state->rcpt_count++;
unsigned int ttl; /* always */
unsigned short pref; /* T_MX only */
struct DNS_RR *next; /* linkage */
- unsigned data_len; /* actual data size */
+ size_t data_len; /* actual data size */
char data[1]; /* actually a bunch of data */
} DNS_RR;
*/
extern DNS_RR *dns_rr_create(const char *, ushort, ushort,
unsigned, unsigned,
- const char *, unsigned);
+ const char *, size_t);
extern void dns_rr_free(DNS_RR *);
extern DNS_RR *dns_rr_copy(DNS_RR *);
extern DNS_RR *dns_rr_append(DNS_RR *, DNS_RR *);
char *rr_name, DNS_FIXED *fixed)
{
char temp[DNS_NAME_LEN];
- int data_len;
+ ssize_t data_len;
unsigned pref = 0;
unsigned char *src;
unsigned char *dst;
/* unsigned int ttl;
/* unsigned preference;
/* const char *data;
-/* unsigned len;
+/* size_t data_len;
/*
/* void dns_rr_free(list)
/* DNS_RR *list;
DNS_RR *dns_rr_create(const char *name, ushort type, ushort class,
unsigned int ttl, unsigned pref,
- const char *data, unsigned data_len)
+ const char *data, size_t data_len)
{
DNS_RR *rr;
DNS_RR *dns_rr_copy(DNS_RR *src)
{
- int len = sizeof(*src) + src->data_len - 1;
+ ssize_t len = sizeof(*src) + src->data_len - 1;
DNS_RR *dst;
/*
vstream_fflush(VSTREAM_OUT);
argv += 1;
}
+ return (0);
}
#endif
VSTRING *inbuf = vstring_alloc(1);
char *bufp;
char *cmd;
- int cmd_len;
+ ssize_t cmd_len;
char *service;
char *addr;
int count;
/* const char *queue;
/* const char *id;
/* int flags;
-/* int mode;
+/* mode_t mode;
/*
/* BOUNCE_LOG *bounce_log_read(bp)
/* BOUNCE_LOG *bp;
/* file has the same name as the original message file.
/* .IP flags
/* File open flags, as with open(2).
-/* .IP more
+/* .IP mode
/* File permissions, as with open(2).
/* .PP
/* Recipient results:
/* bounce_log_open - open bounce read stream */
BOUNCE_LOG *bounce_log_open(const char *queue_name, const char *queue_id,
- int flags, int mode)
+ int flags, mode_t mode)
{
BOUNCE_LOG *bp;
VSTREAM *fp;
DSN dsn; /* delivery status */
} BOUNCE_LOG;
-extern BOUNCE_LOG *bounce_log_open(const char *, const char *, int, int);
+extern BOUNCE_LOG *bounce_log_open(const char *, const char *, int, mode_t);
extern BOUNCE_LOG *bounce_log_read(BOUNCE_LOG *);
extern BOUNCE_LOG *bounce_log_delrcpt(BOUNCE_LOG *);
extern BOUNCE_LOG *bounce_log_forge(RECIPIENT *, DSN *);
* do not flush the log */
int defer_warn(int flags, const char *queue, const char *id,
- const char *sender, const char *envid, int ret)
+ const char *sender, const char *envid, int dsn_ret)
{
if (mail_command_client(MAIL_CLASS_PRIVATE, var_defer_service,
ATTR_TYPE_NUM, MAIL_ATTR_NREQ, BOUNCE_CMD_WARN,
ATTR_TYPE_STR, MAIL_ATTR_QUEUEID, id,
ATTR_TYPE_STR, MAIL_ATTR_SENDER, sender,
ATTR_TYPE_STR, MAIL_ATTR_DSN_ENVID, envid,
- ATTR_TYPE_NUM, MAIL_ATTR_DSN_RET, ret,
+ ATTR_TYPE_NUM, MAIL_ATTR_DSN_RET, dsn_ret,
ATTR_TYPE_END) == 0) {
return (0);
} else {
/*
/* DICT *dict_proxy_open(map, open_flags, dict_flags)
/* const char *map;
-/* int dummy;
+/* int open_flags;
/* int dict_flags;
/* DESCRIPTION
/* dict_proxy_open() relays read-only operations through
"YES" : "NO");
vstream_fflush(VSTREAM_OUT);
domain_list_free(list);
+ return (0);
}
#endif
size_t dsn_valid(const char *text)
{
const unsigned char *cp = (unsigned char *) text;
- int len;
+ size_t len;
/* First portion is one digit followed by dot. */
if ((cp[0] != '2' && cp[0] != '4' && cp[0] != '5') || cp[1] != '.')
/*
* Stand-alone test program.
*/
+#include <stdlib.h>
#include <vstream.h>
#include <vstring.h>
#include <vstring_vstream.h>
/* .in
/* } HEADER_TOKEN;
/*
-/* int header_token(token, token_len, token_buffer, ptr,
+/* ssize_t header_token(token, token_len, token_buffer, ptr,
/* specials, terminator)
/* HEADER_TOKEN *token;
-/* int token_len;
+/* ssize_t token_len;
/* VSTRING *token_buffer;
/* const char **ptr;
/* const char *specials;
/* header_token - parse out the next item in a message header */
-int header_token(HEADER_TOKEN *token, int token_len,
+ssize_t header_token(HEADER_TOKEN *token, ssize_t token_len,
VSTRING *token_buffer, const char **ptr,
const char *user_specials, int user_terminator)
{
- int comment_level;
+ ssize_t comment_level;
const unsigned char *cp;
- int len;
+ ssize_t len;
int ch;
- int tok_count;
- int n;
+ ssize_t tok_count;
+ ssize_t n;
/*
* Initialize.
int type; /* see below */
union {
const char *value; /* just a pointer, not a copy */
- int offset; /* index into token buffer */
+ ssize_t offset; /* index into token buffer */
} u; /* indent beats any alternative */
} HEADER_TOKEN;
#define HEADER_TOK_TOKEN 256
#define HEADER_TOK_QSTRING 257
-extern int header_token(HEADER_TOKEN *, int, VSTRING *, const char **, const char *, int);
+extern ssize_t header_token(HEADER_TOKEN *, ssize_t, VSTRING *, const char **, const char *, int);
/* LICENSE
/* .ad
TOK822 **addr_list;
TOK822 **tpp;
char *ratsign;
- int extlen;
+ ssize_t extlen;
if (extension)
extlen = strlen(extension);
/*
* Stand-alone test program, sort of interactive.
*/
+#include <stdlib.h>
#include <unistd.h>
#include <msg.h>
#include <vstream.h>
vstream_printf(" %s\n", *cpp);
vstream_fflush(VSTREAM_OUT);
}
+ return (0);
}
#endif
vstring_free(buffer);
maps_free(path);
+ return (0);
}
#endif
}
vstring_free(buffer);
maps_free(path);
+ return (0);
}
#endif
static void check_mail_conf_raw(const char *name, const char *strval,
int min, int max)
{
- int len = strlen(strval);
+ ssize_t len = strlen(strval);
if (min && len < min)
- msg_fatal("bad string length (%d < %d): %s = %s",
- len, min, name, strval);
+ msg_fatal("bad string length (%ld < %d): %s = %s",
+ (long) len, min, name, strval);
if (max && len > max)
- msg_fatal("bad string length (%d > %d): %s = %s",
- len, max, name, strval);
+ msg_fatal("bad string length (%ld > %d): %s = %s",
+ (long) len, max, name, strval);
}
/* get_mail_conf_raw - evaluate string-valued configuration variable */
static void check_mail_conf_str(const char *name, const char *strval,
int min, int max)
{
- int len = strlen(strval);
+ ssize_t len = strlen(strval);
if (min && len < min)
- msg_fatal("bad string length %d < %d: %s = %s",
- len, min, name, strval);
+ msg_fatal("bad string length %ld < %d: %s = %s",
+ (long) len, min, name, strval);
if (max && len > max)
- msg_fatal("bad string length %d > %d: %s = %s",
- len, max, name, strval);
+ msg_fatal("bad string length %ld > %d: %s = %s",
+ (long) len, max, name, strval);
}
/* get_mail_conf_str - evaluate string-valued configuration variable */
vstream_printf("10 days = %d\n", days);
vstream_printf("10 weeks = %d\n", weeks);
vstream_fflush(VSTREAM_OUT);
+ return (0);
}
#endif
extern VSTREAM *mail_connect_wait(const char *, const char *);
extern int mail_command_client(const char *, const char *,...);
extern int mail_command_server(VSTREAM *,...);
-extern int mail_trigger(const char *, const char *, const char *, int);
+extern int mail_trigger(const char *, const char *, const char *, ssize_t);
extern char *mail_pathname(const char *, const char *);
/*
/*
/* VSTREAM *mail_queue_enter(queue_name, mode)
/* const char *queue_name;
-/* int mode;
+/* mode_t mode;
/*
/* VSTREAM *mail_queue_open(queue_name, queue_id, flags, mode)
/* const char *queue_name;
/* const char *queue_id;
/* int flags;
-/* int mode;
+/* mode_t mode;
/*
/* char *mail_queue_dir(buf, queue_name, queue_id)
/* VSTRING *buf;
/* mail_queue_enter - make mail queue entry with locally-unique name */
-VSTREAM *mail_queue_enter(const char *queue_name, int mode)
+VSTREAM *mail_queue_enter(const char *queue_name, mode_t mode)
{
char *myname = "mail_queue_enter";
static VSTRING *id_buf;
/* mail_queue_open - open mail queue file */
VSTREAM *mail_queue_open(const char *queue_name, const char *queue_id,
- int flags, int mode)
+ int flags, mode_t mode)
{
const char *path = mail_queue_path((VSTRING *) 0, queue_name, queue_id);
VSTREAM *fp;
#define MAIL_QUEUE_STAT_READY (S_IRUSR | S_IWUSR | S_IXUSR)
#define MAIL_QUEUE_STAT_CORRUPT (S_IRUSR)
-extern struct VSTREAM *mail_queue_enter(const char *, int);
-extern struct VSTREAM *mail_queue_open(const char *, const char *, int, int);
+extern struct VSTREAM *mail_queue_enter(const char *, mode_t);
+extern struct VSTREAM *mail_queue_open(const char *, const char *, int, mode_t);
extern int mail_queue_rename(const char *, const char *, const char *);
extern int mail_queue_remove(const char *, const char *);
extern const char *mail_queue_dir(VSTRING *, const char *, const char *);
/* .IP "MAIL_STREAM_CTL_SERVICE (char *)"
/* The argument specifies an alternate trigger service.
/* .IP "MAIL_STREAM_CTL_MODE (int)"
-/* The argument specifies an altername file mode.
+/* The argument specifies alternate permissions that override
+/* the permissions specified with mail_stream_file().
/* LICENSE
/* .ad
/* .fi
/* const char *class;
/* const char *service;
/* const char *request;
-/* int length;
+/* ssize_t length;
/* DESCRIPTION
/* mail_trigger() wakes up the specified mail subsystem, by
/* sending it the specified request.
/* mail_trigger - trigger a service */
int mail_trigger(const char *class, const char *service,
- const char *req_buf, int req_len)
+ const char *req_buf, ssize_t req_len)
{
struct stat st;
char *path;
* Patches change both the patchlevel and the release date. Snapshots have no
* patchlevel; they change the release date only.
*/
-#define MAIL_RELEASE_DATE "20050708"
+#define MAIL_RELEASE_DATE "20050714"
#define MAIL_VERSION_NUMBER "2.3"
#define VAR_MAIL_VERSION "mail_version"
}
maps_free(maps);
vstring_free(buf);
+ return (0);
}
#endif
/* def_dsn, why)
/* const char *path;
/* int flags;
-/* int mode;
+/* mode_t mode;
/* struct stat *st;
/* uid_t user;
/* gid_t group;
/* mbox_open - open mailbox-style file for exclusive access */
-MBOX *mbox_open(const char *path, int flags, int mode, struct stat * st,
+MBOX *mbox_open(const char *path, int flags, mode_t mode, struct stat * st,
uid_t chown_uid, gid_t chown_gid,
int lock_style, const char *def_dsn,
DSN_BUF *why)
VSTREAM *fp; /* open stream or null */
int locked; /* what locks were set */
} MBOX;
-extern MBOX *mbox_open(const char *, int, int, struct stat *, uid_t, gid_t,
+extern MBOX *mbox_open(const char *, int, mode_t, struct stat *, uid_t, gid_t,
int, const char *, DSN_BUF *);
extern void mbox_release(MBOX *);
extern const char *mbox_dsn(int, const char *);
/* #include <mime_state.h>
/*
/* MIME_STATE *mime_state_alloc(flags, head_out, head_end,
-/* body_out, body_end,
-/* err_print, context)
+/* body_out, body_end,
+/* err_print, context)
/* int flags;
/* void (*head_out)(void *ptr, int header_class,
/* HEADER_OPTS *header_info,
/* VSTRING *buf, off_t offset);
/* void (*head_end)(void *ptr);
/* void (*body_out)(void *ptr, int rec_type,
-/* const char *buf, int len,
+/* const char *buf, ssize_t len,
/* off_t offset);
/* void (*body_end)(void *ptr);
/* void (*err_print)(void *ptr, int err_flag, const char *text)
/* MIME_STATE *state;
/* int rec_type;
/* const char *buf;
-/* int len;
+/* ssize_t len;
/*
/* MIME_STATE *mime_state_free(state)
/* MIME_STATE *state;
int def_ctype; /* default content type */
int def_stype; /* default content subtype */
char *boundary; /* boundary string */
- int bound_len; /* boundary length */
+ ssize_t bound_len; /* boundary length */
struct MIME_STACK *next; /* linkage */
} MIME_STACK;
HEADER_OPTS *header_info)
{
const char *cp;
- int tok_count;
+ ssize_t tok_count;
int def_ctype;
int def_stype;
/* mime_state_downgrade - convert 8-bit data to quoted-printable */
static void mime_state_downgrade(MIME_STATE *state, int rec_type,
- const char *text, int len)
+ const char *text, ssize_t len)
{
static char hexchars[] = "0123456789ABCDEF";
const unsigned char *cp;
/* mime_state_update - update MIME state machine */
int mime_state_update(MIME_STATE *state, int rec_type,
- const char *text, int len)
+ const char *text, ssize_t len)
{
int input_is_text = (rec_type == REC_TYPE_NORM
|| rec_type == REC_TYPE_CONT);
vstream_fprintf(stream, "HEADER END\n");
}
-static void body_out(void *context, int rec_type, const char *buf, int len,
+static void body_out(void *context, int rec_type, const char *buf, ssize_t len,
off_t offset)
{
VSTREAM *stream = (VSTREAM *) context;
*/
typedef struct MIME_STATE MIME_STATE;
typedef void (*MIME_STATE_HEAD_OUT) (void *, int, HEADER_OPTS *, VSTRING *, off_t);
-typedef void (*MIME_STATE_BODY_OUT) (void *, int, const char *, int, off_t);
+typedef void (*MIME_STATE_BODY_OUT) (void *, int, const char *, ssize_t, off_t);
typedef void (*MIME_STATE_ANY_END) (void *);
typedef void (*MIME_STATE_ERR_PRINT) (void *, int, const char *);
extern MIME_STATE *mime_state_alloc(int, MIME_STATE_HEAD_OUT, MIME_STATE_ANY_END, MIME_STATE_BODY_OUT, MIME_STATE_ANY_END, MIME_STATE_ERR_PRINT, void *);
-extern int mime_state_update(MIME_STATE *, int, const char *, int);
+extern int mime_state_update(MIME_STATE *, int, const char *, ssize_t);
extern MIME_STATE *mime_state_free(MIME_STATE *);
/*
char *myname = "mynetworks";
INET_ADDR_LIST *my_addr_list;
INET_ADDR_LIST *my_mask_list;
- int shift;
- int junk;
+ unsigned shift;
+ unsigned junk;
int i;
- int mask_style;
+ unsigned mask_style;
struct sockaddr_storage *sa;
struct sockaddr_storage *ma;
int net_mask_count = 0;
* require exactly one value, or we need to provide an API that is
* dedicated for single-valued flags.
*/
- for (i = 0, junk = mask_style; junk != 0; junk >>= 1)
+ for (i = 0, junk = mask_style; junk != 0; junk >>= 1U)
i += (junk & 1);
if (i != 1)
msg_fatal("bad %s value: %s; specify exactly one value",
var_mynetworks_style = argv[2];
var_inet_interfaces = argv[3];
mynetworks();
+ return (0);
}
#endif
}
myfree((char *) mypwd);
+ return (0);
}
#endif
"YES" : "NO");
vstream_fflush(VSTREAM_OUT);
namadr_list_free(list);
+ return (0);
}
#endif
vstream_fflush(VSTREAM_OUT);
}
vstring_free(buf);
+ return (0);
}
#endif
/* \fImail_copy\fR() routine.
/* .IP "PIPE_CMD_EOL (char *)"
/* End-of-line delimiter. The default is to use the newline character.
-/* .IP "PIPE_CMD_UID (int)"
+/* .IP "PIPE_CMD_UID (uid_t)"
/* The user ID to execute the command as. The default is
/* the user ID corresponding to the \fIdefault_privs\fR
/* configuration parameter. The user ID must be non-zero.
-/* .IP "PIPE_CMD_GID (int)"
+/* .IP "PIPE_CMD_GID (gid_t)"
/* The group ID to execute the command as. The default is
/* the group ID corresponding to the \fIdefault_privs\fR
/* configuration parameter. The group ID must be non-zero.
args->command = va_arg(ap, char *);
break;
case PIPE_CMD_UID:
- args->uid = va_arg(ap, int); /* in case uid_t is short */
+ args->uid = va_arg(ap, uid_t); /* in case uid_t is short */
break;
case PIPE_CMD_GID:
- args->gid = va_arg(ap, int); /* in case gid_t is short */
+ args->gid = va_arg(ap, gid_t); /* in case gid_t is short */
break;
case PIPE_CMD_TIME_LIMIT:
pipe_command_maxtime = va_arg(ap, int);
/* pipe_command_write - write to command with time limit */
-static int pipe_command_write(int fd, void *buf, unsigned len)
+static ssize_t pipe_command_write(int fd, void *buf, ssize_t len)
{
int maxtime = (pipe_command_timeout == 0) ? pipe_command_maxtime : 0;
char *myname = "pipe_command_write";
/* pipe_command_read - read from command with time limit */
-static int pipe_command_read(int fd, void *buf, unsigned len)
+static ssize_t pipe_command_read(int fd, void *buf, ssize_t len)
{
int maxtime = (pipe_command_timeout == 0) ? pipe_command_maxtime : 0;
char *myname = "pipe_command_read";
else if (dsn_valid(log_buf) > 0) {
dsn_split(&dp, "5.3.0", log_buf);
dsb_unix(why, DSN_STATUS(dp.dsn), DSN_CLASS(dp.dsn) == '4' ?
- EX_TEMPFAIL : EX_UNAVAILABLE, dp.text, "%s", dp.text);
+ EX_TEMPFAIL : EX_UNAVAILABLE, dp.text, "%s", dp.text);
return (DSN_CLASS(dp.dsn) == '4' ?
PIPE_STAT_DEFER : PIPE_STAT_BOUNCE);
}
int post_mail_fputs(VSTREAM *cleanup, const char *str)
{
- int len = str ? strlen(str) : 0;
+ ssize_t len = str ? strlen(str) : 0;
return (rec_put(cleanup, REC_TYPE_NORM, str, len) != REC_TYPE_NORM ?
CLEANUP_STAT_WRITE : 0);
vstring_free(unquoted);
vstring_free(quoted);
vstring_free(raw);
+ return (0);
}
#endif
while ((type = rec_get(VSTREAM_IN, buf, 0)) > 0)
REC_STREAMLF_PUT_BUF(VSTREAM_OUT, type, buf);
vstream_fflush(VSTREAM_OUT);
+ return (0);
}
/* System library. */
#include <sys_defs.h>
+#include <stdlib.h>
/* Utility library. */
while (offset = vstream_ftell(VSTREAM_IN),
((type = rec_get(VSTREAM_IN, buf, 0)) != REC_TYPE_EOF
&& type != REC_TYPE_ERROR)) {
- vstream_fprintf(VSTREAM_OUT, "%15s|%4ld|%3d|%s\n",
+ vstream_fprintf(VSTREAM_OUT, "%15s|%4ld|%3ld|%s\n",
rec_type_name(type), offset,
- VSTRING_LEN(buf), vstring_str(buf));
+ (long) VSTRING_LEN(buf), vstring_str(buf));
}
vstream_fflush(VSTREAM_OUT);
vstring_free(buf);
/* int rec_get(stream, buf, maxsize)
/* VSTREAM *stream;
/* VSTRING *buf;
-/* int maxsize;
+/* ssize_t maxsize;
/*
/* int rec_put(stream, type, data, len)
/* VSTREAM *stream;
/* int type;
/* const char *data;
-/* int len;
+/* ssize_t len;
/* AUXILIARY FUNCTIONS
/* int rec_put_type(stream, type, offset)
/* VSTREAM *stream;
/* rec_put - store typed record */
-int rec_put(VSTREAM *stream, int type, const char *data, int len)
+int rec_put(VSTREAM *stream, int type, const char *data, ssize_t len)
{
- int len_rest;
- int len_byte;
+ ssize_t len_rest;
+ ssize_t len_byte;
if (type < 0 || type > 255)
msg_panic("rec_put: bad record type %d", type);
if (msg_verbose > 2)
- msg_info("rec_put: type %c len %d data %.10s", type, len, data);
+ msg_info("rec_put: type %c len %ld data %.10s",
+ type, (long) len, data);
/*
* Write the record type, one byte.
len_rest = len;
do {
len_byte = len_rest & 0177;
- if (len_rest >>= 7)
+ if (len_rest >>= 7U)
len_byte |= 0200;
if (VSTREAM_PUTC(len_byte, stream) == VSTREAM_EOF) {
return (REC_TYPE_ERROR);
/* rec_get - retrieve typed record */
-int rec_get(VSTREAM *stream, VSTRING *buf, int maxsize)
+int rec_get(VSTREAM *stream, VSTRING *buf, ssize_t maxsize)
{
char *myname = "rec_get";
int type;
- int len;
+ ssize_t len;
int len_byte;
- int shift;
+ unsigned shift;
/*
* Sanity check.
*/
if (maxsize < 0)
- msg_panic("%s: bad record size limit: %d", myname, maxsize);
+ msg_panic("%s: bad record size limit: %ld", myname, (long) maxsize);
/*
* Extract the record type.
break;
}
if (len < 0 || (maxsize > 0 && len > maxsize)) {
- msg_warn("%s: illegal length %d, record type %d",
- VSTREAM_PATH(stream), len, type);
+ msg_warn("%s: illegal length %ld, record type %d",
+ VSTREAM_PATH(stream), (long) len, type);
while (len-- > 0 && VSTREAM_GETC(stream) != VSTREAM_EOF)
/* void */ ;
return (REC_TYPE_ERROR);
VSTRING_RESET(buf);
VSTRING_SPACE(buf, len);
if (vstream_fread(stream, vstring_str(buf), len) != len) {
- msg_warn("%s: unexpected EOF in data, record type %d length %d",
- VSTREAM_PATH(stream), type, len);
+ msg_warn("%s: unexpected EOF in data, record type %d length %ld",
+ VSTREAM_PATH(stream), type, (long) len);
return (REC_TYPE_ERROR);
}
VSTRING_AT_OFFSET(buf, len);
VSTRING_TERMINATE(buf);
if (msg_verbose > 2)
- msg_info("%s: type %c len %d data %.10s", myname,
- type, len, vstring_str(buf));
+ msg_info("%s: type %c len %ld data %.10s", myname,
+ type, (unsigned long) len, vstring_str(buf));
return (type);
}
/*
* Functional interface.
*/
-extern int rec_get(VSTREAM *, VSTRING *, int);
-extern int rec_put(VSTREAM *, int, const char *, int);
+extern int rec_get(VSTREAM *, VSTRING *, ssize_t);
+extern int rec_put(VSTREAM *, int, const char *, ssize_t);
extern int rec_put_type(VSTREAM *, int, long);
extern int PRINTFLIKE(3, 4) rec_fprintf(VSTREAM *, int, const char *,...);
extern int rec_fputs(VSTREAM *, int, const char *);
char *dest;
const char *bare_dest;
struct addrinfo *res0 = 0;
- int len;
+ ssize_t len;
#define RETURN(x) \
do { \
mail_conf_read();
vstream_printf("%s\n", resolve_local(argv[1]) ? "yes" : "no");
vstream_fflush(VSTREAM_OUT);
+ return (0);
}
#endif
#include <sys_defs.h>
#include <stdlib.h>
#include <unistd.h>
+#include <string.h>
/* Utility library. */
/* int smtp_get(vp, stream, maxlen)
/* VSTRING *vp;
/* VSTREAM *stream;
-/* int maxlen;
+/* ssize_t maxlen;
/*
/* void smtp_fputs(str, len, stream)
/* const char *str;
-/* int len;
+/* ssize_t len;
/* VSTREAM *stream;
/*
/* void smtp_fwrite(str, len, stream)
/* const char *str;
-/* int len;
+/* ssize_t len;
/* VSTREAM *stream;
/*
/* void smtp_fputc(ch, stream)
/* smtp_get - read one line from SMTP peer */
-int smtp_get(VSTRING *vp, VSTREAM *stream, int bound)
+int smtp_get(VSTRING *vp, VSTREAM *stream, ssize_t bound)
{
int last_char;
int next_char;
/* smtp_fputs - write one line to SMTP peer */
-void smtp_fputs(const char *cp, int todo, VSTREAM *stream)
+void smtp_fputs(const char *cp, ssize_t todo, VSTREAM *stream)
{
- unsigned err;
+ size_t err;
if (todo < 0)
- msg_panic("smtp_fputs: negative todo %d", todo);
+ msg_panic("smtp_fputs: negative todo %ld", (long) todo);
/*
* Do the I/O, protected against timeout.
/* smtp_fwrite - write one string to SMTP peer */
-void smtp_fwrite(const char *cp, int todo, VSTREAM *stream)
+void smtp_fwrite(const char *cp, ssize_t todo, VSTREAM *stream)
{
- unsigned err;
+ size_t err;
if (todo < 0)
- msg_panic("smtp_fwrite: negative todo %d", todo);
+ msg_panic("smtp_fwrite: negative todo %ld", (long) todo);
/*
* Do the I/O, protected against timeout.
extern void PRINTFLIKE(2, 3) smtp_printf(VSTREAM *, const char *,...);
extern void smtp_flush(VSTREAM *);
extern int smtp_fgetc(VSTREAM *);
-extern int smtp_get(VSTRING *, VSTREAM *, int);
-extern void smtp_fputs(const char *, int len, VSTREAM *);
-extern void smtp_fwrite(const char *, int len, VSTREAM *);
+extern int smtp_get(VSTRING *, VSTREAM *, ssize_t);
+extern void smtp_fputs(const char *, ssize_t len, VSTREAM *);
+extern void smtp_fwrite(const char *, ssize_t len, VSTREAM *);
extern void smtp_fputc(int, VSTREAM *);
extern void smtp_vprintf(VSTREAM *, const char *, va_list);
while ((type = rec_streamlf_get(VSTREAM_IN, buf, 150)) > 0)
REC_PUT_BUF(VSTREAM_OUT, type, buf);
vstream_fflush(VSTREAM_OUT);
+ return (0);
}
"YES" : "NO");
vstream_fflush(VSTREAM_OUT);
string_list_free(list);
+ return (0);
}
#endif
/* strip_address - strip non-address text from address expression */
-static void strip_address(VSTRING *vp, int start, TOK822 *addr)
+static void strip_address(VSTRING *vp, ssize_t start, TOK822 *addr)
{
VSTRING *tmp;
{
VSTRING *tmp;
TOK822 *tp;
- int start;
+ ssize_t start;
TOK822 *addr;
- int addr_len;
+ ssize_t addr_len;
/*
* Guard against a Sendmail buffer overflow (CERT advisory CA-2003-07).
msg_warn("unrecognized command: %s", command);
}
vstring_free(buffer);
+ return (0);
}
#endif
VSTRING *verp_sender(VSTRING *buf, const char *delimiters,
const char *sender, const char *recipient)
{
- int send_local_len;
- int rcpt_local_len;
+ ssize_t send_local_len;
+ ssize_t rcpt_local_len;
const char *cp;
/*
#define BUFLEN 1024
-static int read_buf(VSTREAM *fp, VSTRING *buf)
+static ssize_t read_buf(VSTREAM *fp, VSTRING *buf)
{
- int len;
+ ssize_t len;
VSTRING_RESET(buf);
len = vstream_fread(fp, STR(buf), vstring_avail(buf));
{
VSTRING *unquoted = vstring_alloc(BUFLEN);
VSTRING *quoted = vstring_alloc(100);
- int len;
+ ssize_t len;
while ((len = read_buf(VSTREAM_IN, unquoted)) > 0) {
xtext_quote(quoted, STR(unquoted), "+=");
if (xtext_unquote(unquoted, STR(quoted)) == 0)
msg_fatal("bad input: %.100s", STR(quoted));
if (LEN(unquoted) != len)
- msg_fatal("len %d != unquoted len %d", len, LEN(unquoted));
+ msg_fatal("len %ld != unquoted len %ld",
+ (long) len, (long) LEN(unquoted));
if (vstream_fwrite(VSTREAM_OUT, STR(unquoted), LEN(unquoted)) != LEN(unquoted))
msg_fatal("write error: %m");
}
/* print_line - line_wrap callback */
-static void print_line(const char *str, int len, int indent, char *context)
+static void print_line(const char *str, ssize_t len, ssize_t indent, char *context)
{
VSTREAM *notice = (VSTREAM *) context;
- post_mail_fprintf(notice, " %*s%.*s", indent, "", len, str);
+ post_mail_fprintf(notice, " %*s%.*s", (int) indent, "", (int) len, str);
}
/* lmtp_chat_notify - notify postmaster */
/*
/* void biff_notify(text, len)
/* const char *text;
-/* int len;
+/* ssize_t len;
/* DESCRIPTION
/* biff_notify() sends a \fBBIFF\fR notification request to the
/* \fBcomsat\fR daemon.
/* biff_notify - notify recipient via the biff "protocol" */
-void biff_notify(const char *text, int len)
+void biff_notify(const char *text, ssize_t len)
{
static struct sockaddr_in sin;
static int sock = -1;
/*
* External interface.
*/
-extern void biff_notify(const char *, int);
+extern void biff_notify(const char *, ssize_t);
/* LICENSE
/* .ad
char *myname = "deliver_resolve_tree";
RESOLVE_REPLY reply;
int status;
- int ext_len;
+ ssize_t ext_len;
char *ratsign;
/*
/* SYNOPSIS
/* #include <mail_flow.h>
/*
-/* int mail_flow_get(count)
-/* int count;
+/* ssize_t mail_flow_get(count)
+/* ssize_t count;
/*
-/* void mail_flow_put(count)
-/* int count;
+/* ssize_t mail_flow_put(count)
+/* ssize_t count;
/*
-/* int mail_flow_count()
+/* ssize_t mail_flow_count()
/* DESCRIPTION
/* This module implements a simple flow control mechanism that
/* is based on tokens that are consumed by mail receiving processes
/* mail_flow_get - read N tokens */
-int mail_flow_get(int len)
+ssize_t mail_flow_get(ssize_t len)
{
char *myname = "mail_flow_get";
char buf[BUFFER_SIZE];
struct stat st;
- int count;
- int n = 0;
+ ssize_t count;
+ ssize_t n = 0;
/*
* Sanity check.
*/
if (len <= 0)
- msg_panic("%s: bad length %d", myname, len);
+ msg_panic("%s: bad length %ld", myname, (long) len);
/*
* Silence some wild claims.
BUFFER_SIZE : count)) <= 0)
return (-1);
if (msg_verbose)
- msg_info("%s: %d %d", myname, len, len - count);
+ msg_info("%s: %ld %ld", myname, (long) len, (long) (len - count));
return (len - count);
}
/* mail_flow_put - put N tokens */
-int mail_flow_put(int len)
+ssize_t mail_flow_put(ssize_t len)
{
char *myname = "mail_flow_put";
char buf[BUFFER_SIZE];
- int count;
- int n = 0;
+ ssize_t count;
+ ssize_t n = 0;
/*
* Sanity check.
*/
if (len <= 0)
- msg_panic("%s: bad length %d", myname, len);
+ msg_panic("%s: bad length %ld", myname, (long) len);
/*
* Write or discard N bytes.
BUFFER_SIZE : count)) < 0)
return (-1);
if (msg_verbose)
- msg_info("%s: %d %d", myname, len, len - count);
+ msg_info("%s: %ld %ld", myname, (long) len, (long) (len - count));
return (len - count);
}
/* mail_flow_count - return number of available tokens */
-int mail_flow_count(void)
+ssize_t mail_flow_count(void)
{
char *myname = "mail_flow_count";
- int count;
+ ssize_t count;
if ((count = peekfd(MASTER_FLOW_READ)) < 0)
msg_warn("%s: %m", myname);
/*
* Functional interface.
*/
-extern int mail_flow_get(int);
-extern int mail_flow_put(int);
-extern int mail_flow_count(void);
+extern ssize_t mail_flow_get(ssize_t);
+extern ssize_t mail_flow_put(ssize_t);
+extern ssize_t mail_flow_count(void);
/* LICENSE
/* .ad
char *at;
char **cpp;
char *nexthop;
- int len;
+ ssize_t len;
int status;
DSN dsn;
int mode = PQ_MODE_DEFAULT;
char *site_to_flush = 0;
ARGV *import_env;
- char *last;
int bad_site;
/*
char *at;
char **cpp;
char *nexthop;
- int len;
+ ssize_t len;
int status;
DSN dsn;
/* output_text - output partial or complete text line */
-static void output_text(void *context, int rec_type, const char *buf, int len,
+static void output_text(void *context, int rec_type, const char *buf, ssize_t len,
off_t unused_offset)
{
SM_STATE *state = (SM_STATE *) context;
char *start;
char *line;
char *next_line;
- int len;
+ ssize_t len;
/*
* Parse the header line, and save copies of recipient addresses in the
/* print_line - line_wrap callback */
-static void print_line(const char *str, int len, int indent, char *context)
+static void print_line(const char *str, ssize_t len, ssize_t indent, char *context)
{
VSTREAM *notice = (VSTREAM *) context;
- post_mail_fprintf(notice, " %*s%.*s", indent, "", len, str);
+ post_mail_fprintf(notice, " %*s%.*s", (int) indent, "", (int) len, str);
}
/* smtp_chat_notify - notify postmaster */
/* smtp_text_out - output one header/body record */
static void smtp_text_out(void *context, int rec_type,
- const char *text, int len,
+ const char *text, ssize_t len,
off_t unused_offset)
{
SMTP_STATE *state = (SMTP_STATE *) context;
SMTP_SESSION *session = state->session;
- int data_left;
+ ssize_t data_left;
const char *data_start;
/*
}
vstring_free(addr);
vstring_free(result);
+ return (0);
}
#endif
char *arg;
int rate;
const char *dsn_orcpt_addr = 0;
+ ssize_t dsn_orcpt_addr_len = 0;
const char *dsn_orcpt_type = 0;
int dsn_notify = 0;
const char *coded_addr;
return (-1);
}
dsn_orcpt_addr = STR(state->dsn_buf);
+ dsn_orcpt_addr_len = LEN(state->dsn_buf);
} else {
state->error_mask |= MAIL_ERROR_PROTOCOL;
smtpd_chat_reply(state, "555 5.5.4 Unsupported option: %s", arg);
if (dsn_orcpt_addr == 0) {
dsn_orcpt_type = "rfc822";
dsn_orcpt_addr = argv[2].strval;
+ dsn_orcpt_addr_len = strlen(argv[2].strval);
+ if (dsn_orcpt_addr[0] == '<'
+ && dsn_orcpt_addr[dsn_orcpt_addr_len - 1] == '>') {
+ dsn_orcpt_addr += 1;
+ dsn_orcpt_addr_len -= 2;
+ }
}
if (dsn_notify)
rec_fprintf(state->cleanup, REC_TYPE_ATTR, "%s=%d",
MAIL_ATTR_DSN_NOTIFY, dsn_notify);
- rec_fprintf(state->cleanup, REC_TYPE_ATTR, "%s=%s;%s",
- MAIL_ATTR_DSN_ORCPT, dsn_orcpt_type, dsn_orcpt_addr);
+ rec_fprintf(state->cleanup, REC_TYPE_ATTR, "%s=%s;%.*s",
+ MAIL_ATTR_DSN_ORCPT, dsn_orcpt_type,
+ (int) dsn_orcpt_addr_len, dsn_orcpt_addr);
rec_fputs(state->cleanup, REC_TYPE_RCPT, STR(state->addr_buf));
vstream_fflush(state->cleanup);
}
int first = 1;
VSTRING *why = 0;
int saved_err;
- int (*out_record) (VSTREAM *, int, const char *, int);
+ int (*out_record) (VSTREAM *, int, const char *, ssize_t);
int (*out_fprintf) (VSTREAM *, int, const char *,...);
VSTREAM *out_stream;
int out_error;
* verification unless TLS is required.
*/
state->tls_context =
- tls_server_start(smtpd_tls_ctx, state->client,
- var_smtpd_starttls_tmout,
- state->name, state->addr, &(state->tls_info),
- (var_smtpd_tls_req_ccert && state->tls_enforce_tls));
+ tls_server_start(smtpd_tls_ctx, state->client,
+ var_smtpd_starttls_tmout,
+ state->name, state->addr, &(state->tls_info),
+ (var_smtpd_tls_req_ccert && state->tls_enforce_tls));
/*
* When the TLS handshake fails, the conversation is in an unknown state.
* recipient checks, address mapping, header_body_checks?.
*/
smtpd_input_transp_mask =
- input_transp_mask(VAR_INPUT_TRANSP, var_input_transp);
+ input_transp_mask(VAR_INPUT_TRANSP, var_input_transp);
/*
* Sanity checks. The queue_minfree value should be at least as large as
/* print_line - line_wrap callback */
-static void print_line(const char *str, int len, int indent, char *context)
+static void print_line(const char *str, ssize_t len, ssize_t indent, char *context)
{
VSTREAM *notice = (VSTREAM *) context;
- post_mail_fprintf(notice, " %*s%.*s", indent, "", len, str);
+ post_mail_fprintf(notice, " %*s%.*s", (int) indent, "", (int) len, str);
}
/* smtpd_chat_notify - notify postmaster */
static char *dup_if_truncate(char *name)
{
- int len;
+ ssize_t len;
char *result;
/*
char *reply_name, char *reply_class)
{
char *myname = "reject_invalid_hostaddr";
- int len;
+ ssize_t len;
char *test_addr;
int stat;
if (*domain == '[') {
char *saved_addr;
const char *bare_addr;
- int len;
+ ssize_t len;
if (type != T_MX)
return (SMTPD_CHECK_DUNNO);
/* VSTREAM *stream;
/* int rec_type;
/* const char *data;
-/* int len;
+/* ssize_t len;
/*
/* int smtpd_proxy_rec_fprintf(stream, rec_type, format, ...)
/* VSTREAM *stream;
/* smtpd_proxy_rec_put - send message content, rec_put() clone */
int smtpd_proxy_rec_put(VSTREAM *stream, int rec_type,
- const char *data, int len)
+ const char *data, ssize_t len)
{
int err;
extern int smtpd_proxy_open(SMTPD_STATE *, const char *, int, const char *, const char *);
extern int PRINTFLIKE(3, 4) smtpd_proxy_cmd(SMTPD_STATE *, int, const char *,...);
-extern int smtpd_proxy_rec_put(VSTREAM *, int, const char *, int);
+extern int smtpd_proxy_rec_put(VSTREAM *, int, const char *, ssize_t);
extern int PRINTFLIKE(3, 4) smtpd_proxy_rec_fprintf(VSTREAM *, int, const char *,...);
extern void smtpd_proxy_close(SMTPD_STATE *);
STR(message_buffer), LEN(message_buffer),
STR(sender_buffer), LEN(sender_buffer),
STR(recipient_buffer), LEN(recipient_buffer),
- 0);
+ (ssize_t) 0);
netstring_fflush(session->stream);
/*
int path_len;
int sessions = 1;
int ch;
+ ssize_t len;
int n;
int i;
char *buf;
STR(buffer)[message_length - 1] = '\n';
netstring_memcpy(message_buffer, STR(buffer), message_length);
- n = strlen(sender);
- sender_buffer = vstring_alloc(n);
- netstring_memcpy(sender_buffer, sender, n);
+ len = strlen(sender);
+ sender_buffer = vstring_alloc(len);
+ netstring_memcpy(sender_buffer, sender, len);
if (recipients == 1) {
- n = strlen(recipient);
- recipient_buffer = vstring_alloc(n);
- netstring_memcpy(recipient_buffer, recipient, n);
+ len = strlen(recipient);
+ recipient_buffer = vstring_alloc(len);
+ netstring_memcpy(recipient_buffer, recipient, len);
} else {
recipient_buffer = vstring_alloc(100);
for (n = 0; n < recipients; n++) {
*/
if (rdata.buf == 0) {
rdata.buf = vstring_alloc(100);
- vstring_ctl(rdata.buf, VSTRING_CTL_MAXLEN, var_line_limit, 0);
+ vstring_ctl(rdata.buf, VSTRING_CTL_MAXLEN, (ssize_t) var_line_limit, 0);
}
/*
*/
if (buffer == 0) {
buffer = vstring_alloc(100);
- vstring_ctl(buffer, VSTRING_CTL_MAXLEN, var_line_limit, 0);
+ vstring_ctl(buffer, VSTRING_CTL_MAXLEN, (ssize_t) var_line_limit, 0);
}
/*
tls_tmp_dh_cb(0, 1, 1024);
tls_tmp_dh_cb(0, 1, 2048);
tls_tmp_dh_cb(0, 0, 512);
+ return (0);
}
#endif
/* int cache_type;
/* const char *cache_id;
/* const char *buf;
-/* int len;
+/* ssize_t len;
/*
/* int tls_mgr_lookup(cache_type, cache_id, buf)
/* int cache_type;
/* tls_mgr_update - save session to cache */
int tls_mgr_update(int cache_type, const char *cache_id,
- const char *buf, int len)
+ const char *buf, ssize_t len)
{
int status;
argv_free(argv);
vstring_free(inbuf);
+ return (0);
}
#endif /* TEST */
extern int tls_mgr_seed(VSTRING *, int);
extern int tls_mgr_policy(int *);
extern int tls_mgr_lookup(int, const char *, VSTRING *);
-extern int tls_mgr_update(int, const char *, const char *, int);
+extern int tls_mgr_update(int, const char *, const char *, ssize_t);
extern int tls_mgr_delete(int, const char *);
/* LICENSE
{
const char *myname = "tls_prng_file_read";
char buffer[8192];
- int to_read;
- int count;
+ ssize_t to_read;
+ ssize_t count;
if (msg_verbose)
msg_info("%s: seed internal pool from file %s", myname, fh->name);
static VSTRING *tls_scache_encode(TLS_SCACHE *cp, const char *cache_id,
const char *session,
- int session_len)
+ ssize_t session_len)
{
TLS_SCACHE_ENTRY *entry;
VSTRING *hex_data;
- int binary_data_len;
+ ssize_t binary_data_len;
/*
* Assemble the TLS session cache entry.
* Logging.
*/
if (cp->log_level >= 3)
- msg_info("write %s TLS cache entry %s: time=%ld [data %d bytes]",
+ msg_info("write %s TLS cache entry %s: time=%ld [data %ld bytes]",
cp->cache_label, cache_id, (long) entry->timestamp,
- session_len);
+ (long) session_len);
/*
* Clean up.
/* tls_scache_decode - decode TLS session cache entry */
static int tls_scache_decode(TLS_SCACHE *cp, const char *cache_id,
- const char *hex_data, int hex_data_len,
+ const char *hex_data, ssize_t hex_data_len,
VSTRING *out_session)
{
TLS_SCACHE_ENTRY *entry;
* Logging.
*/
if (cp->log_level >= 3)
- msg_info("read %s TLS cache entry %s: time=%ld [data %d bytes]",
+ msg_info("read %s TLS cache entry %s: time=%ld [data %ld bytes]",
cp->cache_label, cache_id, (long) entry->timestamp,
- LEN(bin_data) - offsetof(TLS_SCACHE_ENTRY, session));
+ (long) (LEN(bin_data) - offsetof(TLS_SCACHE_ENTRY, session)));
/*
* Other mandatory restrictions.
/* tls_scache_update - save session to cache */
int tls_scache_update(TLS_SCACHE *cp, const char *cache_id,
- const char *buf, int len)
+ const char *buf, ssize_t len)
{
VSTRING *hex_data;
* Logging.
*/
if (cp->log_level >= 3)
- msg_info("put %s session id=%s [data %d bytes]",
- cp->cache_label, cache_id, len);
+ msg_info("put %s session id=%s [data %ld bytes]",
+ cp->cache_label, cache_id, (long) len);
/*
* Encode the cache entry.
extern TLS_SCACHE *tls_scache_open(const char *, const char *, int, int);
extern void tls_scache_close(TLS_SCACHE *);
extern int tls_scache_lookup(TLS_SCACHE *, const char *, VSTRING *);
-extern int tls_scache_update(TLS_SCACHE *, const char *, const char *, int);
+extern int tls_scache_update(TLS_SCACHE *, const char *, const char *, ssize_t);
extern int tls_scache_delete(TLS_SCACHE *, const char *);
extern int tls_scache_sequence(TLS_SCACHE *, int, char **, VSTRING *);
if (X509_digest(peer, EVP_md5(), TLScontext->md, &n)) {
for (j = 0; j < (int) n; j++) {
TLScontext->fingerprint[j * 3] =
- hexcodes[(TLScontext->md[j] & 0xf0) >> 4];
+ hexcodes[(TLScontext->md[j] & 0xf0) >> 4U];
TLScontext->fingerprint[(j * 3) + 1] =
hexcodes[(TLScontext->md[j] & 0x0f)];
if (j + 1 != (int) n)
/* tls_timed_read - read content from stream, then TLS decapsulate */
-static int tls_timed_read(int fd, void *buf, unsigned len, int timeout,
- void *context)
+static ssize_t tls_timed_read(int fd, void *buf, size_t len, int timeout,
+ void *context)
{
char *myname = "tls_timed_read";
- int ret;
+ ssize_t ret;
TLScontext_t *TLScontext;
TLScontext = (TLScontext_t *) context;
ret = tls_bio_read(fd, buf, len, timeout, TLScontext);
if (ret > 0 && TLScontext->log_level >= 4)
- msg_info("Read %d chars: %.*s",
- ret, ret > 40 ? 40 : ret, (char *) buf);
+ msg_info("Read %ld chars: %.*s",
+ (long) ret, (int) (ret > 40 ? 40 : ret), (char *) buf);
return (ret);
}
/* tls_timed_write - TLS encapsulate content, then write to stream */
-static int tls_timed_write(int fd, void *buf, unsigned len, int timeout,
- void *context)
+static ssize_t tls_timed_write(int fd, void *buf, size_t len, int timeout,
+ void *context)
{
const char *myname = "tls_timed_write";
TLScontext_t *TLScontext;
msg_panic("%s: no context", myname);
if (TLScontext->log_level >= 4)
- msg_info("Write %d chars: %.*s",
- len, (int) (len > 40 ? 40 : len), (char *) buf);
+ msg_info("Write %ld chars: %.*s",
+ (long) len, (int) (len > 40 ? 40 : len), (char *) buf);
return (tls_bio_write(fd, buf, len, timeout, TLScontext));
}
/* tls_stream_start - start VSTREAM over TLS */
-void tls_stream_start(VSTREAM *stream, TLScontext_t * context)
+void tls_stream_start(VSTREAM *stream, TLScontext_t *context)
{
vstream_control(stream,
VSTREAM_CTL_READ_FN, tls_timed_read,
char *destination;
const char *blame = 0;
const char *rcpt_domain;
- int addr_len;
+ ssize_t addr_len;
int loop_count;
int loop_max;
char *local;
/* Available in Postfix 2.2 and later:
/* .IP "\fBremote_header_rewrite_domain (empty)\fR"
/* Don't rewrite message headers from remote clients at all when
-/* this parameter is empty; otherwise, rewrite remote message headers
-/* and append the specified domain name to incomplete addresses.
+/* this parameter is empty; otherwise, rewrite message headers and
+/* append the specified domain name to incomplete addresses.
/* ROUTING CONTROLS
/* .ad
/* .fi
/* #include <argv.h>
/*
/* ARGV *argv_alloc(len)
-/* int len;
+/* ssize_t len;
/*
/* ARGV *argv_free(argvp)
/* ARGV *argvp;
/* void argv_addn(argvp, arg, arg_len, ..., ARGV_END)
/* ARGV *argvp;
/* char *arg;
-/* int arg_len;
+/* ssize_t arg_len;
/*
/* void argv_terminate(argvp);
/* ARGV *argvp;
/*
/* void argv_truncate(argvp, len);
/* ARGV *argvp;
-/* int len;
+/* ssize_t len;
/* DESCRIPTION
/* The functions in this module manipulate arrays of string
/* pointers. An ARGV structure contains the following members:
/* argv_alloc - initialize string array */
-ARGV *argv_alloc(int len)
+ARGV *argv_alloc(ssize_t len)
{
ARGV *argvp;
- int sane_len;
+ ssize_t sane_len;
/*
* Make sure that always argvp->argc < argvp->len.
static void argv_extend(ARGV *argvp)
{
- int new_len;
+ ssize_t new_len;
new_len = argvp->len * 2;
argvp->argv = (char **)
void argv_addn(ARGV *argvp,...)
{
char *arg;
- int len;
+ ssize_t len;
va_list ap;
/*
*/
va_start(ap, argvp);
while ((arg = va_arg(ap, char *)) != 0) {
- if ((len = va_arg(ap, int)) < 0)
- msg_panic("argv_addn: bad string length %d", len);
+ if ((len = va_arg(ap, ssize_t)) < 0)
+ msg_panic("argv_addn: bad string length %ld", (long) len);
if (ARGV_SPACE_LEFT(argvp) <= 0)
argv_extend(argvp);
argvp->argv[argvp->argc++] = mystrndup(arg, len);
/* argv_truncate - truncate string array */
-void argv_truncate(ARGV *argvp, int len)
+void argv_truncate(ARGV *argvp, ssize_t len)
{
char **cpp;
* Sanity check.
*/
if (len < 0)
- msg_panic("argv_truncate: bad length %d", len);
+ msg_panic("argv_truncate: bad length %ld", (long) len);
if (len < argvp->argc) {
for (cpp = argvp->argv + len; cpp < argvp->argv + argvp->argc; cpp++)
* External interface.
*/
typedef struct ARGV {
- int len; /* number of array elements */
- int argc; /* array elements in use */
+ ssize_t len; /* number of array elements */
+ ssize_t argc; /* array elements in use */
char **argv; /* string array */
} ARGV;
-extern ARGV *argv_alloc(int);
+extern ARGV *argv_alloc(ssize_t);
extern void argv_add(ARGV *,...);
extern void argv_addn(ARGV *,...);
extern void argv_terminate(ARGV *);
-extern void argv_truncate(ARGV *, int);
+extern void argv_truncate(ARGV *, ssize_t);
extern ARGV *argv_free(ARGV *);
extern ARGV *argv_split(const char *, const char *);
SKIP_ARG(ap, char *);
break;
case ATTR_TYPE_DATA:
- SKIP_ARG2(ap, char *, int);
+ SKIP_ARG2(ap, ssize_t, char *);
break;
case ATTR_TYPE_NUM:
SKIP_ARG(ap, int);
/* .IP "ATTR_TYPE_STR (char *, char *)"
/* This argument is followed by an attribute name and a null-terminated
/* string.
-/* .IP "ATTR_TYPE_DATA (char *, int, char *)"
+/* .IP "ATTR_TYPE_DATA (char *, ssize_t, char *)"
/* This argument is followed by an attribute name, an attribute value
/* length, and an attribute value pointer.
/* .IP "ATTR_TYPE_FUNC (ATTR_PRINT_SLAVE_FN, void *)"
char *str_val;
HTABLE_INFO **ht_info_list;
HTABLE_INFO **ht;
- int len_val;
+ ssize_t len_val;
static VSTRING *base64_buf;
ATTR_PRINT_SLAVE_FN print_fn;
void *print_arg;
case ATTR_TYPE_DATA:
attr_name = va_arg(ap, char *);
vstream_fwrite(fp, attr_name, strlen(attr_name) + 1);
- len_val = va_arg(ap, int);
+ len_val = va_arg(ap, ssize_t);
str_val = va_arg(ap, char *);
if (base64_buf == 0)
base64_buf = vstring_alloc(10);
base64_encode(base64_buf, str_val, len_val);
vstream_fwrite(fp, STR(base64_buf), LEN(base64_buf) + 1);
if (msg_verbose)
- msg_info("send attr %s = [data %d bytes]", attr_name, len_val);
+ msg_info("send attr %s = [data %ld bytes]",
+ attr_name, (long) len_val);
break;
case ATTR_TYPE_FUNC:
print_fn = va_arg(ap, ATTR_PRINT_SLAVE_FN);
/* .IP "ATTR_TYPE_STR (char *, char *)"
/* This argument is followed by an attribute name and a null-terminated
/* string.
+/* .IP "ATTR_TYPE_DATA (char *, ssize_t, char *)"
+/* This argument is followed by an attribute name, an attribute value
+/* length, and an attribute value pointer.
/* .IP "ATTR_TYPE_FUNC (ATTR_PRINT_SLAVE_FN, void *)"
/* This argument is followed by a function pointer and generic data
/* pointer. The caller-specified function returns whatever the
/* attr_print64_str - encode and send attribute information */
-static void attr_print64_str(VSTREAM *fp, const char *str, int len)
+static void attr_print64_str(VSTREAM *fp, const char *str, ssize_t len)
{
static VSTRING *base64_buf;
char *str_val;
HTABLE_INFO **ht_info_list;
HTABLE_INFO **ht;
- int len_val;
+ ssize_t len_val;
ATTR_PRINT_SLAVE_FN print_fn;
void *print_arg;
case ATTR_TYPE_DATA:
attr_name = va_arg(ap, char *);
attr_print64_str(fp, attr_name, strlen(attr_name));
- len_val = va_arg(ap, int);
+ len_val = va_arg(ap, ssize_t);
str_val = va_arg(ap, char *);
VSTREAM_PUTC(':', fp);
attr_print64_str(fp, str_val, len_val);
VSTREAM_PUTC('\n', fp);
if (msg_verbose)
- msg_info("send attr %s = [data %d bytes]", attr_name, len_val);
+ msg_info("send attr %s = [data %ld bytes]",
+ attr_name, (long) len_val);
break;
case ATTR_TYPE_FUNC:
print_fn = va_arg(ap, ATTR_PRINT_SLAVE_FN);
ATTR_TYPE_NUM, ATTR_NAME_NUM, 4711,
ATTR_TYPE_LONG, ATTR_NAME_LONG, 1234,
ATTR_TYPE_STR, ATTR_NAME_STR, "whoopee",
- ATTR_TYPE_DATA, ATTR_NAME_DATA, strlen("whoopee"), "whoopee",
+ ATTR_TYPE_DATA, ATTR_NAME_DATA, strlen("whoopee"), "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_DATA, ATTR_NAME_DATA, strlen("whoopee"), "whoopee",
+ ATTR_TYPE_DATA, ATTR_NAME_DATA, strlen("whoopee"), "whoopee",
ATTR_TYPE_END);
if (vstream_fflush(VSTREAM_OUT) != 0)
msg_fatal("write error: %m");
/* .IP "ATTR_TYPE_STR (char *, char *)"
/* This argument is followed by an attribute name and a null-terminated
/* string.
-/* .IP "ATTR_TYPE_DATA (char *, int, char *)"
+/* .IP "ATTR_TYPE_DATA (char *, ssize_t, char *)"
/* This argument is followed by an attribute name, an attribute value
/* length, and a pointer to attribute value.
/* .IP "ATTR_TYPE_FUNC (ATTR_PRINT_SLAVE_FN, void *)"
HTABLE_INFO **ht_info_list;
HTABLE_INFO **ht;
static VSTRING *base64_buf;
- int len_val;
+ ssize_t len_val;
ATTR_PRINT_SLAVE_FN print_fn;
void *print_arg;
break;
case ATTR_TYPE_DATA:
attr_name = va_arg(ap, char *);
- len_val = va_arg(ap, int);
+ len_val = va_arg(ap, ssize_t);
str_val = va_arg(ap, char *);
if (base64_buf == 0)
base64_buf = vstring_alloc(10);
base64_encode(base64_buf, str_val, len_val);
vstream_fprintf(fp, "%s=%s\n", attr_name, STR(base64_buf));
if (msg_verbose)
- msg_info("send attr %s = [data %d bytes]", attr_name, len_val);
+ msg_info("send attr %s = [data %ld bytes]",
+ attr_name, (long) len_val);
break;
case ATTR_TYPE_FUNC:
print_fn = va_arg(ap, ATTR_PRINT_SLAVE_FN);
ATTR_TYPE_NUM, ATTR_NAME_NUM, 4711,
ATTR_TYPE_LONG, ATTR_NAME_LONG, 1234,
ATTR_TYPE_STR, ATTR_NAME_STR, "whoopee",
- ATTR_TYPE_DATA, ATTR_NAME_DATA, strlen("whoopee"), "whoopee",
+ ATTR_TYPE_DATA, ATTR_NAME_DATA, strlen("whoopee"), "whoopee",
ATTR_TYPE_HASH, table,
ATTR_TYPE_END);
attr_print_plain(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_DATA, ATTR_NAME_DATA, strlen("whoopee"), "whoopee",
+ ATTR_TYPE_DATA, ATTR_NAME_DATA, strlen("whoopee"), "whoopee",
ATTR_TYPE_END);
if (vstream_fflush(VSTREAM_OUT) != 0)
msg_fatal("write error: %m");
} else if (wanted_type == ATTR_TYPE_HASH) {
wanted_name = "(any attribute name or list terminator)";
hash_table = va_arg(ap, HTABLE *);
- if (va_arg(ap, int) !=ATTR_TYPE_END)
+ if (va_arg(ap, int) != ATTR_TYPE_END)
msg_panic("%s: ATTR_TYPE_HASH not followed by ATTR_TYPE_END",
myname);
} else if (wanted_type != ATTR_TYPE_FUNC) {
} else if (wanted_type == ATTR_TYPE_HASH) {
wanted_name = "(any attribute name or list terminator)";
hash_table = va_arg(ap, HTABLE *);
- if (va_arg(ap, int) !=ATTR_TYPE_END)
+ if (va_arg(ap, int) != ATTR_TYPE_END)
msg_panic("%s: ATTR_TYPE_HASH not followed by ATTR_TYPE_END",
myname);
} else if (wanted_type != ATTR_TYPE_FUNC) {
} else if (wanted_type == ATTR_TYPE_HASH) {
wanted_name = "(any attribute name or list terminator)";
hash_table = va_arg(ap, HTABLE *);
- if (va_arg(ap, int) !=ATTR_TYPE_END)
+ if (va_arg(ap, int) != ATTR_TYPE_END)
msg_panic("%s: ATTR_TYPE_HASH not followed by ATTR_TYPE_END",
myname);
} else if (wanted_type != ATTR_TYPE_FUNC) {
/* VSTRING *base64_encode(result, in, len)
/* VSTRING *result;
/* const char *in;
-/* int len;
+/* ssize_t len;
/*
/* VSTRING *base64_decode(result, in, len)
/* VSTRING *result;
/* const char *in;
-/* int len;
+/* ssize_t len;
/* DESCRIPTION
/* base64_encode() takes a block of len bytes and encodes it as one
/* null-terminated string. The result value is the result argument.
/* base64_encode - raw data to encoded */
-VSTRING *base64_encode(VSTRING *result, const char *in, int len)
+VSTRING *base64_encode(VSTRING *result, const char *in, ssize_t len)
{
const unsigned char *cp;
- int count;
+ ssize_t count;
/*
* Encode 3 -> 4.
/* base64_decode - encoded data to raw */
-VSTRING *base64_decode(VSTRING *result, const char *in, int len)
+VSTRING *base64_decode(VSTRING *result, const char *in, ssize_t len)
{
static unsigned char *un_b64 = 0;
const unsigned char *cp;
- int count;
+ ssize_t count;
unsigned int ch0;
unsigned int ch1;
unsigned int ch2;
/*
* External interface.
*/
-extern VSTRING *base64_encode(VSTRING *, const char *, int);
-extern VSTRING *base64_decode(VSTRING *, const char *, int);
+extern VSTRING *base64_encode(VSTRING *, const char *, ssize_t);
+extern VSTRING *base64_decode(VSTRING *, const char *, ssize_t);
/* LICENSE
/* .ad
*/
while (len-- > 0) {
- h = (h << 4) + *key++;
+ h = (h << 4U) + *key++;
if ((g = (h & 0xf0000000)) != 0) {
- h ^= (g >> 24);
+ h ^= (g >> 24U);
h ^= g;
}
}
/*
* Preserve or specify selected environment variables.
*/
-#define STRING_AND_LENGTH(x, y) (x), (y)
+#define STRING_AND_LENGTH(x, y) (x), (ssize_t) (y)
save_list = argv_alloc(10);
for (cpp = preserve_list; *cpp; cpp++)
{
char *result;
va_list ap;
- int len;
+ ssize_t len;
char *arg;
/*
* the source file changed only seconds ago.
*/
if (stat(path, &st) == 0
- && st.st_mtime > dict_cdbq->dict.mtime
- && st.st_mtime < time((time_t *)0) - 100)
+ && st.st_mtime > dict_cdbq->dict.mtime
+ && st.st_mtime < time((time_t *) 0) - 100)
msg_warn("database %s is older than source file %s", cdb_path, path);
/*
static void dict_cdbm_update(DICT *dict, const char *name, const char *value)
{
DICT_CDBM *dict_cdbm = (DICT_CDBM *) dict;
- unsigned ksize,
- vsize;
+ unsigned ksize, vsize;
int r;
ksize = strlen(name);
char *cdb_path;
char *tmp_path;
int fd;
- struct stat st0,
- st1;
+ struct stat st0, st1;
cdb_path = concatenate(path, CDB_SUFFIX, (char *) 0);
tmp_path = concatenate(path, CDB_TMP_SUFFIX, (char *) 0);
DICT *dict_cdb_open(const char *path, int open_flags, int dict_flags)
{
switch (open_flags & (O_RDONLY | O_RDWR | O_WRONLY | O_CREAT | O_TRUNC)) {
- case O_RDONLY: /* query mode */
+ case O_RDONLY: /* query mode */
return dict_cdbq_open(path, dict_flags);
case O_WRONLY | O_CREAT | O_TRUNC: /* create mode */
case O_RDWR | O_CREAT | O_TRUNC: /* sloppiness */
if (values.ni_namelist_len <= 0)
ni_namelist_free(&values);
else {
- unsigned int i,
- l,
- n;
+ unsigned int i, l, n;
for (i = l = 0; i < values.ni_namelist_len; i++)
l += 1 + strlen(values.ni_namelist_val[i]);
d->dict.close = dict_ni_close;
d->dict.flags = dict_flags | DICT_FLAG_FIXED;
- return (DICT_DEBUG(&d->dict));
+ return (DICT_DEBUG (&d->dict));
}
#endif
/* SYNOPSIS
/* #include <iostuff.h>
/*
-/* int dummy_read(fd, buf, buf_len, timeout, context)
+/* ssize_t dummy_read(fd, buf, buf_len, timeout, context)
/* int fd;
/* void *buf;
-/* unsigned len;
+/* size_t len;
/* int timeout;
/* void *context;
/* DESCRIPTION
/* dummy_read - dummy read operation */
-int dummy_read(int fd, void *unused_buf, unsigned len,
+ssize_t dummy_read(int fd, void *unused_buf, size_t len,
int unused_timeout, void *unused_context)
{
if (msg_verbose)
- msg_info("dummy_read: fd %d, len %d", fd, len);
+ msg_info("dummy_read: fd %d, len %lu", fd, (unsigned long) len);
return (0);
}
/* SYNOPSIS
/* #include <iostuff.h>
/*
-/* int dummy_write(fd, buf, buf_len, timeout, context)
+/* ssize_t dummy_write(fd, buf, buf_len, timeout, context)
/* int fd;
/* void *buf;
-/* unsigned len;
+/* size_t len;
/* int timeout;
/* void *context;
/* DESCRIPTION
/* dummy_write - dummy write operation */
-int dummy_write(int fd, void *unused_buf, unsigned len,
- int unused_timeout, void *unused_context)
+ssize_t dummy_write(int fd, void *unused_buf, size_t len,
+ int unused_timeout, void *unused_context)
{
if (msg_verbose)
- msg_info("dummy_write: fd %d, len %d", fd, len);
+ msg_info("dummy_write: fd %d, len %lu", fd, (unsigned long) len);
return (len);
}
#include <stdio.h>
#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
#define DO(s) if (s < 0) { perror(#s); exit(1); }
/* namelength - determine length of name in "name=whatever" */
-static int namelength(const char *name)
+static ssize_t namelength(const char *name)
{
char *equal;
/* cmalloc - malloc and copy block of memory */
-static char *cmalloc(int new_len, char *old, int old_len)
+static char *cmalloc(ssize_t new_len, char *old, ssize_t old_len)
{
char *new = malloc(new_len);
static int addenv(char *nameval)
{
char **envp;
- int n_used; /* number of environment entries */
- int l_used; /* bytes used excl. terminator */
- int l_need; /* bytes needed incl. terminator */
+ ssize_t n_used; /* number of environment entries */
+ ssize_t l_used; /* bytes used excl. terminator */
+ ssize_t l_need; /* bytes needed incl. terminator */
for (envp = environ; envp && *envp; envp++)
/* void */ ;
*/
#include <stdio.h>
#include <ctype.h>
+#include <stdlib.h>
/* timer_event - display event */
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
+#include <stdlib.h>
#define FIFO_PATH "test-fifo"
#define perrorexit(s) { perror(s); exit(1); }
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
+#include <string.h>
#define FIFO_PATH "test-fifo"
#define TRIGGER_DELAY 5
#include <signal.h>
#include <unistd.h>
#include <stdlib.h>
+#include <string.h>
#define FIFO_PATH "test-fifo"
#define perrorexit(s) { perror(s); exit(1); }
/* int fifo_trigger(service, buf, len, timeout)
/* const char *service;
/* const char *buf;
-/* int len;
+/* ssize_t len;
/* int timeout;
/* DESCRIPTION
/* fifo_trigger() wakes up the named fifo server by writing
/* fifo_trigger - wakeup fifo server */
-int fifo_trigger(const char *service, const char *buf, int len, int timeout)
+int fifo_trigger(const char *service, const char *buf, ssize_t len, int timeout)
{
static VSTRING *why;
char *myname = "fifo_trigger";
static void read_event(int unused_event, char *context)
{
- int fd = (int) context;
+ int fd = CAST_CHAR_PTR_TO_INT(context);
char ch;
wakeup_count++;
listen_fd = fifo_listen(TEST_FIFO, 0600, NON_BLOCKING);
msg_cleanup(cleanup);
- event_enable_read(listen_fd, read_event, (char *) listen_fd);
+ event_enable_read(listen_fd, read_event, CAST_INT_TO_CHAR_PTR(listen_fd));
signal(SIGINT, handler);
signal(SIGALRM, handler);
for (;;) {
const char *cp = fullname();
printf("%s\n", cp ? cp : "null!");
+ return (0);
}
#endif
/* VSTRING *hex_encode(result, in, len)
/* VSTRING *result;
/* const char *in;
-/* int len;
+/* ssize_t len;
/*
/* VSTRING *hex_decode(result, in, len)
/* VSTRING *result;
/* const char *in;
-/* int len;
+/* ssize_t len;
/* DESCRIPTION
/* hex_encode() takes a block of len bytes and encodes it as one
/* upper-case null-terminated string. The result value is
/* hex_encode - raw data to encoded */
-VSTRING *hex_encode(VSTRING *result, const char *in, int len)
+VSTRING *hex_encode(VSTRING *result, const char *in, ssize_t len)
{
const unsigned char *cp;
int ch;
- int count;
+ ssize_t count;
VSTRING_RESET(result);
for (cp = UCHAR_PTR(in), count = len; count > 0; count--, cp++) {
/* hex_decode - encoded data to raw */
-VSTRING *hex_decode(VSTRING *result, const char *in, int len)
+VSTRING *hex_decode(VSTRING *result, const char *in, ssize_t len)
{
const unsigned char *cp;
- int count;
+ ssize_t count;
unsigned int hex;
unsigned int bin;
return (0);
hex = cp[1];
if (hex >= '0' && hex <= '9')
- bin |= (hex - '0') ;
+ bin |= (hex - '0');
else if (hex >= 'A' && hex <= 'F')
- bin |= (hex - 'A' + 10) ;
+ bin |= (hex - 'A' + 10);
else if (hex >= 'a' && hex <= 'f')
- bin |= (hex - 'a' + 10) ;
+ bin |= (hex - 'a' + 10);
else
return (0);
VSTRING_ADDCH(result, bin);
/*
* External interface.
*/
-extern VSTRING *hex_encode(VSTRING *, const char *, int);
-extern VSTRING *hex_decode(VSTRING *, const char *, int);
+extern VSTRING *hex_encode(VSTRING *, const char *, ssize_t);
+extern VSTRING *hex_decode(VSTRING *, const char *, ssize_t);
/* LICENSE
/* .ad
#define BUFLEN 1024
-static int read_buf(VSTREAM *fp, VSTRING *buf)
+static ssize_t read_buf(VSTREAM *fp, VSTRING *buf)
{
- int len;
+ ssize_t len;
VSTRING_RESET(buf);
len = vstream_fread(fp, STR(buf), vstring_avail(buf));
{
VSTRING *raw = vstring_alloc(BUFLEN);
VSTRING *hex = vstring_alloc(100);
- int len;
+ ssize_t len;
while ((len = read_buf(VSTREAM_IN, raw)) > 0) {
hex_quote(hex, STR(raw));
if (hex_unquote(raw, STR(hex)) == 0)
msg_fatal("bad input: %.100s", STR(hex));
if (LEN(raw) != len)
- msg_fatal("len %d != raw len %d", len, LEN(raw));
+ msg_fatal("len %ld != raw len %ld", len, LEN(raw));
if (vstream_fwrite(VSTREAM_OUT, STR(raw), LEN(raw)) != LEN(raw))
msg_fatal("write error: %m");
}
*/
while (*s) {
- h = (h << 4) + *s++;
+ h = (h << 4U) + *s++;
if ((g = (h & 0xf0000000)) != 0) {
- h ^= (g >> 24);
+ h ^= (g >> 24U);
h ^= g;
}
}
*/
hash = htable_create(10);
while (vstring_get(buf, VSTREAM_IN) != VSTREAM_EOF)
- htable_enter(hash, vstring_str(buf), (void *) count++);
+ htable_enter(hash, vstring_str(buf), CAST_INT_TO_CHAR_PTR(count++));
ht_info = htable_list(hash);
for (i = 0; i < hash->used; i++) {
r = myrand() % hash->used;
struct addrinfo *res0;
struct addrinfo *res;
int aierr;
- int hostnamelen;
+ ssize_t hostnamelen;
const char *hname;
const char *serv;
int initial_count = addr_list->used;
if (argc < 3)
msg_fatal("usage: %s protocols hostname...", argv[0]);
- proto_info = inet_proto_init(argv[0], *++argv);
+ proto_info = inet_proto_init(argv[0], argv[1]);
+ argv += 1;
inet_addr_list_init(&list);
}
inet_addr_list_free(&addr_list);
inet_addr_list_free(&mask_list);
+ return (0);
}
#endif
/* int inet_trigger(service, buf, len, timeout)
/* char *service;
/* const char *buf;
-/* int len;
+/* ssize_t len;
/* int timeout;
/* DESCRIPTION
/* inet_trigger() wakes up the named INET-domain server by making
/* inet_trigger - wakeup INET-domain server */
-int inet_trigger(const char *service, const char *buf, int len, int timeout)
+int inet_trigger(const char *service, const char *buf, ssize_t len, int timeout)
{
char *myname = "inet_trigger";
struct inet_trigger *ip;
extern int writable(int);
extern off_t get_file_limit(void);
extern void set_file_limit(off_t);
-extern int peekfd(int);
+extern ssize_t peekfd(int);
extern int read_wait(int, int);
extern int write_wait(int, int);
-extern int write_buf(int, const char *, int, int);
-extern int timed_read(int, void *, unsigned, int, void *);
-extern int timed_write(int, void *, unsigned, int, void *);
+extern ssize_t write_buf(int, const char *, ssize_t, int);
+extern ssize_t timed_read(int, void *, size_t, int, void *);
+extern ssize_t timed_write(int, void *, size_t, int, void *);
extern void doze(unsigned);
extern void rand_sleep(unsigned, unsigned);
extern int duplex_pipe(int *);
extern int stream_send_fd(int, int);
extern int unix_recv_fd(int);
extern int unix_send_fd(int, int);
-extern int dummy_read(int, void *, unsigned, int, void *);
-extern int dummy_write(int, void *, unsigned, int, void *);
+extern ssize_t dummy_read(int, void *, size_t, int, void *);
+extern ssize_t dummy_write(int, void *, size_t, int, void *);
#define BLOCKING 0
#define NON_BLOCKING 1
/* line_wrap - wrap long lines upon output */
-void line_wrap(const char *str, int len, int indent, LINE_WRAP_FN output_fn,
+void line_wrap(const char *str, ssize_t len, ssize_t indent, LINE_WRAP_FN output_fn,
char *context)
{
const char *start_line;
const char *word;
const char *next_word;
const char *next_space;
- int line_len;
- int curr_len;
- int curr_indent;
+ ssize_t line_len;
+ ssize_t curr_len;
+ ssize_t curr_indent;
if (indent < 0) {
curr_indent = -indent;
/*
* External interface.
*/
-typedef void (*LINE_WRAP_FN) (const char *, int, int, char *);
-extern void line_wrap(const char *, int, int, LINE_WRAP_FN, char *);
+typedef void (*LINE_WRAP_FN) (const char *, ssize_t, ssize_t, char *);
+extern void line_wrap(const char *, ssize_t, ssize_t, LINE_WRAP_FN, char *);
/* LICENSE
/* .ad
static int mac_expand_callback(int type, VSTRING *buf, char *ptr)
{
- char *myname = "mac_expand_callback";
MAC_EXP *mc = (MAC_EXP *) ptr;
int lookup_mode;
const char *text;
char *cp;
int ch;
- int len;
+ ssize_t len;
/*
* Sanity check.
/*
* This code certainly deserves a stand-alone test program.
*/
+#include <stdlib.h>
#include <stringops.h>
#include <htable.h>
#include <vstream.h>
vstream_fflush(VSTREAM_OUT);
}
vstring_free(buf);
+ return (0);
}
#endif
if (strcasecmp(addr, pattern) == 0)
return (1);
} else {
- int addr_len = strlen(addr);
+ ssize_t addr_len = strlen(addr);
if (strncasecmp(addr, pattern + 1, addr_len) == 0
&& strcmp(pattern + 1 + addr_len, "]") == 0)
#include <string.h>
#include <errno.h>
#include <stdlib.h>
+#include <stdio.h> /* sprintf() */
/* Utility library. */
{
#ifdef EMULATE_IPV4_ADDRINFO
char portbuf[sizeof("65535")];
- int len;
+ ssize_t len;
/*
* Emulated getnameinfo(3) version. The buffer length includes the space
/* #include <mymalloc.h>
/*
/* char *mymalloc(len)
-/* int len;
+/* ssize_t len;
/*
/* char *myrealloc(ptr, len)
/* char *ptr;
-/* int len;
+/* ssize_t len;
/*
/* void myfree(ptr)
/* char *ptr;
/*
/* char *mystrndup(str, len)
/* const char *str;
-/* int len;
+/* ssize_t len;
/*
/* char *mymemdup(ptr, len)
/* const char *ptr;
-/* int len;
+/* ssize_t len;
/* DESCRIPTION
/* This module performs low-level memory management with error
/* handling. A call of these functions either succeeds or it does
*/
typedef struct MBLOCK {
int signature; /* set when block is active */
- int length; /* user requested length */
+ ssize_t length; /* user requested length */
union {
ALIGN_TYPE align;
char payload[1]; /* actually a bunch of bytes */
- } u;
+ } u;
} MBLOCK;
#define SIGNATURE 0xdead
/* mymalloc - allocate memory or bust */
-char *mymalloc(int len)
+char *mymalloc(ssize_t len)
{
char *ptr;
MBLOCK *real_ptr;
if (len < 1)
- msg_panic("mymalloc: requested length %d", len);
+ msg_panic("mymalloc: requested length %ld", (long) len);
if ((real_ptr = (MBLOCK *) malloc(SPACE_FOR(len))) == 0)
msg_fatal("mymalloc: insufficient memory: %m");
CHECK_OUT_PTR(ptr, real_ptr, len);
/* myrealloc - reallocate memory or bust */
-char *myrealloc(char *ptr, int len)
+char *myrealloc(char *ptr, ssize_t len)
{
MBLOCK *real_ptr;
- int old_len;
+ ssize_t old_len;
if (len < 1)
- msg_panic("myrealloc: requested length %d", len);
+ msg_panic("myrealloc: requested length %ld", (long) len);
CHECK_IN_PTR(ptr, real_ptr, old_len, "myrealloc");
if ((real_ptr = (MBLOCK *) realloc((char *) real_ptr, SPACE_FOR(len))) == 0)
msg_fatal("myrealloc: insufficient memory: %m");
void myfree(char *ptr)
{
MBLOCK *real_ptr;
- int len;
+ ssize_t len;
CHECK_IN_PTR(ptr, real_ptr, len, "myfree");
memset((char *) real_ptr, FILLER, SPACE_FOR(len));
/* mystrndup - save substring to heap */
-char *mystrndup(const char *str, int len)
+char *mystrndup(const char *str, ssize_t len)
{
char *result;
char *cp;
if (str == 0)
msg_panic("mystrndup: null pointer argument");
+ if (len < 0)
+ msg_panic("mystrndup: requested length %ld", (long) len);
if ((cp = memchr(str, 0, len)) != 0)
len = cp - str;
result = memcpy(mymalloc(len + 1), str, len);
/* mymemdup - copy memory */
-char *mymemdup(const char *ptr, int len)
+char *mymemdup(const char *ptr, ssize_t len)
{
if (ptr == 0)
msg_panic("mymemdup: null pointer argument");
/*
* External interface.
*/
-extern char *mymalloc(int);
-extern char *myrealloc(char *, int);
+extern char *mymalloc(ssize_t);
+extern char *myrealloc(char *, ssize_t);
extern void myfree(char *);
extern char *mystrdup(const char *);
-extern char *mystrndup(const char *, int len);
-extern char *mymemdup(const char *, int);
+extern char *mystrndup(const char *, ssize_t);
+extern char *mymemdup(const char *, ssize_t);
/* LICENSE
/* .ad
vstream_fflush(VSTREAM_OUT);
}
vstring_free(vp);
+ return (0);
}
#endif
/*
* Stand-alone test program.
*/
-
+#include <stdlib.h>
#include <vstream.h>
int main(int argc, char **argv)
/* VSTRING *netstring_get(stream, buf, limit)
/* VSTREAM *stream;
/* VSTRING *buf;
-/* int limit;
+/* ssize_t limit;
/*
/* void netstring_put(stream, data, len)
/* VSTREAM *stream;
/* const char *data;
-/* int len;
+/* int ssize_t;
/*
/* void netstring_put_multi(stream, data, len, data, len, ..., 0)
/* VSTREAM *stream;
/* const char *data;
-/* int len;
+/* ssize_t len;
/*
/* void NETSTRING_PUT_BUF(stream, buf)
/* VSTREAM *stream;
/* VSTRING *netstring_memcpy(buf, data, len)
/* VSTRING *buf;
/* const char *data;
-/* int len;
+/* int ssize_t;
/*
/* VSTRING *netstring_memcat(buf, data, len)
/* VSTRING *buf;
/* const char *src;
-/* int len;
+/* ssize_t len;
/* AUXILIARY ROUTINES
-/* int netstring_get_length(stream)
+/* ssize_t netstring_get_length(stream)
/* VSTREAM *stream;
/*
/* VSTRING *netstring_get_data(stream, buf, len)
/* VSTREAM *stream;
/* VSTRING *buf;
-/* int len;
+/* ssize_t len;
/*
/* void netstring_get_terminator(stream)
/* VSTREAM *stream;
/* netstring_get_length - read netstring length + terminator */
-int netstring_get_length(VSTREAM *stream)
+ssize_t netstring_get_length(VSTREAM *stream)
{
char *myname = "netstring_get_length";
- int len = 0;
+ ssize_t len = 0;
int ch;
for (;;) {
NETSTRING_ERR_TIME : NETSTRING_ERR_EOF);
case ':':
if (msg_verbose > 1)
- msg_info("%s: read netstring length %d", myname, len);
+ msg_info("%s: read netstring length %ld", myname, (long) len);
return (len);
default:
if (!ISDIGIT(ch))
/* netstring_get_data - read netstring payload + terminator */
-VSTRING *netstring_get_data(VSTREAM *stream, VSTRING *buf, int len)
+VSTRING *netstring_get_data(VSTREAM *stream, VSTRING *buf, ssize_t len)
{
char *myname = "netstring_get_data";
NETSTRING_ERR_TIME : NETSTRING_ERR_EOF);
if (msg_verbose > 1)
msg_info("%s: read netstring data %.*s",
- myname, len < 30 ? len : 30, STR(buf));
+ myname, (int) (len < 30 ? len : 30), STR(buf));
netstring_get_terminator(stream);
/*
/* netstring_get - read string from netstring stream */
-VSTRING *netstring_get(VSTREAM *stream, VSTRING *buf, int limit)
+VSTRING *netstring_get(VSTREAM *stream, VSTRING *buf, ssize_t limit)
{
- int len;
+ ssize_t len;
len = netstring_get_length(stream);
if (limit && len > limit)
/* netstring_put - send string as netstring */
-void netstring_put(VSTREAM *stream, const char *data, int len)
+void netstring_put(VSTREAM *stream, const char *data, ssize_t len)
{
char *myname = "netstring_put";
if (msg_verbose > 1)
- msg_info("%s: write netstring len %d data %.*s",
- myname, len, len < 30 ? len : 30, data);
- vstream_fprintf(stream, "%d:", len);
+ msg_info("%s: write netstring len %ld data %.*s",
+ myname, (long) len, (int) (len < 30 ? len : 30), data);
+ vstream_fprintf(stream, "%ld:", (long) len);
vstream_fwrite(stream, data, len);
VSTREAM_PUTC(',', stream);
}
void netstring_put_multi(VSTREAM *stream,...)
{
char *myname = "netstring_put_multi";
- int total;
+ ssize_t total;
char *data;
- int data_len;
+ ssize_t data_len;
va_list ap;
/*
*/
va_start(ap, stream);
for (total = 0; (data = va_arg(ap, char *)) != 0; total += data_len)
- if ((data_len = va_arg(ap, int)) < 0)
- msg_panic("netstring_put_multi: bad data length %d", data_len);
+ if ((data_len = va_arg(ap, ssize_t)) < 0)
+ msg_panic("netstring_put_multi: bad data length %ld", (long) data_len);
va_end(ap);
/*
if (msg_verbose > 1) {
va_start(ap, stream);
data = va_arg(ap, char *);
- data_len = va_arg(ap, int);
- msg_info("%s: write netstring len %d data %.*s",
- myname, total, data_len < 30 ? data_len : 30, data);
+ data_len = va_arg(ap, ssize_t);
+ msg_info("%s: write netstring len %ld data %.*s",
+ myname, (long) total, (int) (data_len < 30 ? data_len : 30), data);
va_end(ap);
}
-
+
/*
* Send the length, content and terminator.
*/
- vstream_fprintf(stream, "%d:", total);
+ vstream_fprintf(stream, "%ld:", (long) total);
va_start(ap, stream);
while ((data = va_arg(ap, char *)) != 0) {
- data_len = va_arg(ap, int);
+ data_len = va_arg(ap, ssize_t);
if (data_len > 0)
if (vstream_fwrite(stream, data, data_len) != data_len)
netstring_except(stream, vstream_ftimeout(stream) ?
/* netstring_memcpy - copy data as in-memory netstring */
-VSTRING *netstring_memcpy(VSTRING *buf, const char *src, int len)
+VSTRING *netstring_memcpy(VSTRING *buf, const char *src, ssize_t len)
{
- vstring_sprintf(buf, "%d:", len);
+ vstring_sprintf(buf, "%ld:", (long) len);
vstring_memcat(buf, src, len);
VSTRING_ADDCH(buf, ',');
return (buf);
/* netstring_memcat - append data as in-memory netstring */
-VSTRING *netstring_memcat(VSTRING *buf, const char *src, int len)
+VSTRING *netstring_memcat(VSTRING *buf, const char *src, ssize_t len)
{
- vstring_sprintf_append(buf, "%d:", len);
+ vstring_sprintf_append(buf, "%ld:", (long) len);
vstring_memcat(buf, src, len);
VSTRING_ADDCH(buf, ',');
return (buf);
extern void netstring_except(VSTREAM *, int);
extern void netstring_setup(VSTREAM *, int);
-extern int netstring_get_length(VSTREAM *);
-extern VSTRING *netstring_get_data(VSTREAM *, VSTRING *, int);
+extern ssize_t netstring_get_length(VSTREAM *);
+extern VSTRING *netstring_get_data(VSTREAM *, VSTRING *, ssize_t);
extern void netstring_get_terminator(VSTREAM *);
-extern VSTRING *netstring_get(VSTREAM *, VSTRING *, int);
-extern void netstring_put(VSTREAM *, const char *, int);
+extern VSTRING *netstring_get(VSTREAM *, VSTRING *, ssize_t);
+extern void netstring_put(VSTREAM *, const char *, ssize_t);
extern void netstring_put_multi(VSTREAM *,...);
extern void netstring_fflush(VSTREAM *);
-extern VSTRING *netstring_memcpy(VSTRING *, const char *, int);
-extern VSTRING *netstring_memcat(VSTRING *, const char *, int);
+extern VSTRING *netstring_memcpy(VSTRING *, const char *, ssize_t);
+extern VSTRING *netstring_memcat(VSTRING *, const char *, ssize_t);
#define NETSTRING_PUT_BUF(str, buf) \
netstring_put((str), vstring_str(buf), VSTRING_LEN(buf))
/* SYNOPSIS
/* #include <open_lock.h>
/*
-/* VSTREAM *open_lock(path, int flags, int mode, why)
+/* VSTREAM *open_lock(path, flags, mode, why)
/* const char *path;
/* int flags;
-/* int mode;
+/* mode_t mode;
/* VSTRING *why;
/* DESCRIPTION
/* This module opens or creates the named file and attempts to
/* open_lock - open file and lock it for exclusive access */
-VSTREAM *open_lock(const char *path, int flags, int mode, VSTRING *why)
+VSTREAM *open_lock(const char *path, int flags, mode_t mode, VSTRING *why)
{
VSTREAM *fp;
/*
* External interface.
*/
-extern VSTREAM *open_lock(const char *, int, int, VSTRING *);
+extern VSTREAM *open_lock(const char *, int, mode_t, VSTRING *);
/* LICENSE
/* .ad
/* SYNOPSIS
/* #include <iostuff.h>
/*
-/* int peekfd(fd)
+/* ssize_t peekfd(fd)
/* int fd;
/* DESCRIPTION
/* peekfd() attempts to find out how many bytes are available to
/* peekfd - return amount of data ready to read */
-int peekfd(int fd)
+ssize_t peekfd(int fd)
{
- int count;
/*
* Anticipate a series of system-dependent code fragments.
*/
#ifdef FIONREAD
+ int count;
+
return (ioctl(fd, FIONREAD, (char *) &count) < 0 ? -1 : count);
#else
#error "don't know how to look ahead"
#endif
}
-
{
int ch;
int next;
- int start;
+ ssize_t start;
char *cp;
VSTRING_RESET(buf);
/* VSTREAM *safe_open(path, flags, mode, st, user, group, why)
/* const char *path;
/* int flags;
-/* int mode;
+/* mode_t mode;
/* struct stat *st;
/* uid_t user;
/* gid_t group;
/* safe_open_create - create new file */
-static VSTREAM *safe_open_create(const char *path, int flags, int mode,
+static VSTREAM *safe_open_create(const char *path, int flags, mode_t mode,
struct stat * st, uid_t user, uid_t group, VSTRING *why)
{
VSTREAM *fp;
/* safe_open - safely open or create file */
-VSTREAM *safe_open(const char *path, int flags, int mode,
+VSTREAM *safe_open(const char *path, int flags, mode_t mode,
struct stat * st, uid_t user, gid_t group, VSTRING *why)
{
VSTREAM *fp;
/*
* External interface.
*/
-extern VSTREAM *safe_open(const char *, int, int, struct stat *, uid_t, gid_t, VSTRING *);
+extern VSTREAM *safe_open(const char *, int, mode_t, struct stat *, uid_t, gid_t, VSTRING *);
/* LICENSE
/* .ad
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
+#include <stdlib.h>
#include <string.h> /* bzero() prototype for 44BSD */
/* Utility library. */
}
}
-main(int argc, char **argv)
+int main(int argc, char **argv)
{
int pair1[2];
int pair2[2];
msg_fatal("write: %m");
while (wait((int *) 0) >= 0)
/* void */ ;
+ return (0);
}
#include <stdio.h>
#include <unistd.h>
+#include <stdlib.h>
static void gotsig(int sig)
{
printf("Got signal %d\n", sig);
}
-int main(int unused_argc, int unused_argv)
+int main(int unused_argc, char **unused_argv)
{
signal(SIGINT, gotsig);
signal(SIGQUIT, gotsig);
/* .IP "SPAWN_CMD_STDERR (int)"
/* Each of these specifies I/O redirection of one of the standard file
/* descriptors for the command.
-/* .IP "SPAWN_CMD_UID (int)"
+/* .IP "SPAWN_CMD_UID (uid_t)"
/* The user ID to execute the command as. The value -1 is reserved
/* and cannot be specified.
-/* .IP "SPAWN_CMD_GID (int)"
+/* .IP "SPAWN_CMD_GID (gid_t)"
/* The group ID to execute the command as. The value -1 is reserved
/* and cannot be specified.
/* .IP "SPAWN_CMD_TIME_LIMIT (int)"
* stream_send_fd test program) and copy its content until EOF.
*/
#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
#include <split_at.h>
#include <listen.h>
#ifdef STREAM_CONNECTIONS
if (ioctl(fd, I_SENDFD, sendfd) < 0)
msg_fatal("%s: send file descriptor: %m", myname);
+ return (0);
#else
msg_fatal("stream connections are not implemented");
#endif
*/
#include <unistd.h>
#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
#include <split_at.h>
#include <connect.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
-#include <stropts.h>
-#include "iostuff.h"
+#include "iostuff.h"
#include "msg.h"
#include "msg_vstream.h"
#include "listen.h"
#include "connect.h"
+#ifdef SUNOS5
+#include <stropts.h>
+
#define FIFO "/tmp/test-fifo"
static const char *progname;
-static print_fstat(int fd)
+static void print_fstat(int fd)
{
struct stat st;
if (fstat(fd, &st) < 0)
msg_fatal("fstat: %m");
vstream_printf("fd %d\n", fd);
- vstream_printf("dev %d\n", st.st_dev);
- vstream_printf("ino %d\n", st.st_ino);
+ vstream_printf("dev %ld\n", (long) st.st_dev);
+ vstream_printf("ino %ld\n", (long) st.st_ino);
vstream_fflush(VSTREAM_OUT);
}
msg_fatal("usage: %s [-p] [-n count] [-v]", progname);
}
-main(int argc, char **argv)
+int main(int argc, char **argv)
{
int server_fd;
int client_fd;
}
if (close(server_fd) < 0)
msg_fatal("close server fd");
+ return (0);
+}
+#else
+int main(int argc, char **argv)
+{
+ return (0);
}
+#endif
/* int stream_trigger(service, buf, len, timeout)
/* const char *service;
/* const char *buf;
-/* int len;
+/* ssize_t len;
/* int timeout;
/* DESCRIPTION
/* stream_trigger() wakes up the named stream server by making
/* stream_trigger - wakeup stream server */
-int stream_trigger(const char *service, const char *buf, int len, int timeout)
+int stream_trigger(const char *service, const char *buf, ssize_t len, int timeout)
{
char *myname = "stream_trigger";
struct stream_trigger *sp;
* not (Clive Jones). So we'll set the threshold at 2.7.
*/
#ifndef NORETURN
-#if __GNUC__ == 2 && __GNUC_MINOR__ >= 7 || __GNUC__ >= 3
+#if (__GNUC__ == 2 && __GNUC_MINOR__ >= 7) || __GNUC__ >= 3
#define NORETURN void __attribute__((__noreturn__))
#endif
#endif
/* int timed_connect(fd, buf, buf_len, timeout)
/* int fd;
/* struct sockaddr *buf;
-/* unsigned buf_len;
+/* int buf_len;
/* int timeout;
/* DESCRIPTION
/* timed_connect() implement a BSD socket connect() operation that is
/* SYNOPSIS
/* #include <iostuff.h>
/*
-/* int timed_read(fd, buf, buf_len, timeout, context)
+/* ssize_t timed_read(fd, buf, len, timeout, context)
/* int fd;
/* void *buf;
-/* unsigned len;
+/* size_t len;
/* int timeout;
/* void *context;
/* DESCRIPTION
/* File descriptor in the range 0..FD_SETSIZE.
/* .IP buf
/* Read buffer pointer.
-/* .IP buf_len
+/* .IP len
/* Read buffer size.
/* .IP timeout
/* The deadline in seconds. If this is <= 0, the deadline feature
/* timed_read - read with deadline */
-int timed_read(int fd, void *buf, unsigned len,
+ssize_t timed_read(int fd, void *buf, size_t len,
int timeout, void *unused_context)
{
- int ret;
+ ssize_t ret;
/*
* Wait for a limited amount of time for something to happen. If nothing
/* SYNOPSIS
/* #include <iostuff.h>
/*
-/* int timed_write(fd, buf, buf_len, timeout, context)
+/* ssize_t timed_write(fd, buf, len, timeout, context)
/* int fd;
/* const void *buf;
-/* unsigned len;
+/* size_t len;
/* int timeout;
/* void *context;
/* DESCRIPTION
/* File descriptor in the range 0..FD_SETSIZE.
/* .IP buf
/* Write buffer pointer.
-/* .IP buf_len
+/* .IP len
/* Write buffer size.
/* .IP timeout
/* The deadline in seconds. If this is <= 0, the deadline feature
/* timed_write - write with deadline */
-int timed_write(int fd, void *buf, unsigned len,
+ssize_t timed_write(int fd, void *buf, size_t len,
int timeout, void *unused_context)
{
- int ret;
+ ssize_t ret;
/*
* Wait for a limited amount of time for something to happen. If nothing
/*
* External interface.
*/
-extern int unix_trigger(const char *, const char *, int, int);
-extern int inet_trigger(const char *, const char *, int, int);
-extern int fifo_trigger(const char *, const char *, int, int);
-extern int stream_trigger(const char *, const char *, int, int);
+extern int unix_trigger(const char *, const char *, ssize_t, int);
+extern int inet_trigger(const char *, const char *, ssize_t, int);
+extern int fifo_trigger(const char *, const char *, ssize_t, int);
+extern int stream_trigger(const char *, const char *, ssize_t, int);
/* LICENSE
/* .ad
#ifdef TEST
+#include <stdlib.h>
#include <vstring_vstream.h>
int main(int unused_argc, char **unused_argv)
/* int unix_trigger(service, buf, len, timeout)
/* const char *service;
/* const char *buf;
-/* int len;
+/* ssize_t len;
/* int timeout;
/* DESCRIPTION
/* unix_trigger() wakes up the named UNIX-domain server by making
/* unix_trigger - wakeup UNIX-domain server */
-int unix_trigger(const char *service, const char *buf, int len, int timeout)
+int unix_trigger(const char *service, const char *buf, ssize_t len, int timeout)
{
char *myname = "unix_trigger";
struct unix_trigger *up;
/*
/* int VBUF_SPACE(bp, len)
/* VBUF *bp;
-/* int len;
+/* ssize_t len;
/*
/* int vbuf_unget(bp, ch)
/* VBUF *bp;
/* int ch;
/*
-/* int vbuf_read(bp, buf, len)
+/* ssize_t vbuf_read(bp, buf, len)
/* VBUF *bp;
/* char *buf;
-/* int len;
+/* ssize_t len;
/*
-/* int vbuf_write(bp, buf, len)
+/* ssize_t vbuf_write(bp, buf, len)
/* VBUF *bp;
/* const char *buf;
-/* int len;
+/* ssize_t len;
/*
/* int vbuf_err(bp)
/* VBUF *bp;
/*
/* int space(bp, len)
/* VBUF *bp;
-/* int len;
+/* ssize_t len;
/* APPLICATION CALLBACK DESCRIPTION
/* .ad
/* .fi
/* vbuf_read - bulk read from buffer */
-int vbuf_read(VBUF *bp, char *buf, int len)
+ssize_t vbuf_read(VBUF *bp, char *buf, ssize_t len)
{
- int count;
+ ssize_t count;
char *cp;
- int n;
+ ssize_t n;
#if 0
for (count = 0; count < len; count++)
/* vbuf_write - bulk write to buffer */
-int vbuf_write(VBUF *bp, const char *buf, int len)
+ssize_t vbuf_write(VBUF *bp, const char *buf, ssize_t len)
{
- int count;
+ ssize_t count;
const char *cp;
- int n;
+ ssize_t n;
#if 0
for (count = 0; count < len; count++)
*
* This interface is pretty normal. With one exception: the number of bytes
* left to read is negated. This is done so that we can change direction
- * between reading and writing on the fly.
+ * between reading and writing on the fly. The alternative would be to use
+ * separate read and write counters per buffer.
*/
typedef struct VBUF VBUF;
typedef int (*VBUF_GET_READY_FN) (VBUF *);
typedef int (*VBUF_PUT_READY_FN) (VBUF *);
-typedef int (*VBUF_SPACE_FN) (VBUF *, int);
+typedef int (*VBUF_SPACE_FN) (VBUF *, ssize_t);
struct VBUF {
int flags; /* status, see below */
unsigned char *data; /* variable-length buffer */
- int len; /* buffer length */
- int cnt; /* bytes left to read/write */
+ ssize_t len; /* buffer length */
+ ssize_t cnt; /* bytes left to read/write */
unsigned char *ptr; /* read/write position */
VBUF_GET_READY_FN get_ready; /* read buffer empty action */
VBUF_PUT_READY_FN put_ready; /* write buffer full action */
extern int vbuf_get(VBUF *);
extern int vbuf_put(VBUF *, int);
extern int vbuf_unget(VBUF *, int);
-extern int vbuf_read(VBUF *, char *, int);
-extern int vbuf_write(VBUF *, const char *, int);
+extern ssize_t vbuf_read(VBUF *, char *, ssize_t);
+extern ssize_t vbuf_write(VBUF *, const char *, ssize_t);
/* LICENSE
/* .ad
/* VSTREAM *vstream_fopen(path, flags, mode)
/* char *path;
/* int flags;
-/* int mode;
+/* mode_t mode;
/*
/* VSTREAM *vstream_fdopen(fd, flags)
/* int fd;
/* int vstream_fflush(stream)
/* VSTREAM *stream;
/*
-/* int vstream_fread(stream, buf, len)
+/* ssize_t vstream_fread(stream, buf, len)
/* VSTREAM *stream;
/* char *buf;
-/* int len;
+/* ssize_t len;
/*
-/* int vstream_fwrite(stream, buf, len)
+/* ssize_t vstream_fwrite(stream, buf, len)
/* VSTREAM *stream;
/* char *buf;
-/* int len;
+/* ssize_t len;
/*
/* void vstream_control(stream, name, ...)
/* VSTREAM *stream;
/* char *format;
/* va_list *ap;
/*
-/* int vstream_peek(stream)
+/* ssize_t vstream_peek(stream)
/* VSTREAM *stream;
/*
/* int vstream_setjmp(stream)
/* value) pairs, terminated with VSTREAM_CTL_END.
/* The following lists the names and the types of the corresponding
/* value arguments.
-/* .IP "VSTREAM_CTL_READ_FN (int (*)(int, void *, unsigned, int, void *))"
+/* .IP "VSTREAM_CTL_READ_FN (ssize_t (*)(int, void *, size_t, int, void *))"
/* The argument specifies an alternative for the timed_read(3) function,
/* for example, a read function that performs decryption.
-/* .IP "VSTREAM_CTL_WRITE_FN (int (*)(int, void *, unsigned, int, void *))"
+/* .IP "VSTREAM_CTL_WRITE_FN (ssize_t (*)(int, void *, size_t, int, void *))"
/* The argument specifies an alternative for the timed_write(3) function,
/* for example, a write function that performs encryption.
/* .IP "VSTREAM_CTL_CONTEXT (char *)"
*/
static int vstream_buf_get_ready(VBUF *);
static int vstream_buf_put_ready(VBUF *);
-static int vstream_buf_space(VBUF *, int);
+static int vstream_buf_space(VBUF *, ssize_t);
/*
* Initialization of the three pre-defined streams. Pre-allocate a static
/* vstream_buf_alloc - allocate buffer memory */
-static void vstream_buf_alloc(VBUF *bp, int len)
+static void vstream_buf_alloc(VBUF *bp, ssize_t len)
{
- int used = bp->ptr - bp->data;
+ ssize_t used = bp->ptr - bp->data;
char *myname = "vstream_buf_alloc";
if (len < bp->len)
/* vstream_fflush_some - flush some buffered data */
-static int vstream_fflush_some(VSTREAM *stream, int to_flush)
+static int vstream_fflush_some(VSTREAM *stream, ssize_t to_flush)
{
char *myname = "vstream_fflush_some";
VBUF *bp = &stream->buf;
- int used;
- int left_over;
+ ssize_t used;
+ ssize_t left_over;
char *data;
- int len;
- int n;
+ ssize_t len;
+ ssize_t n;
/*
* Sanity checks. It is illegal to flush a read-only stream. Otherwise,
left_over = used - to_flush;
if (msg_verbose > 2 && stream != VSTREAM_ERR)
- msg_info("%s: fd %d flush %d", myname, stream->fd, to_flush);
+ msg_info("%s: fd %d flush %ld", myname, stream->fd, (long) to_flush);
if (to_flush < 0 || left_over < 0)
- msg_panic("%s: bad to_flush %d", myname, to_flush);
+ msg_panic("%s: bad to_flush %ld", myname, (long) to_flush);
if (to_flush < left_over)
msg_panic("%s: to_flush < left_over", myname);
if (to_flush == 0)
if (stream->timeout)
stream->iotime = time((time_t *) 0);
if (msg_verbose > 2 && stream != VSTREAM_ERR && n != to_flush)
- msg_info("%s: %d flushed %d/%d", myname, stream->fd, n, to_flush);
+ msg_info("%s: %d flushed %ld/%ld", myname, stream->fd,
+ (long) n, (long) to_flush);
}
if (bp->flags & VSTREAM_FLAG_SEEK)
stream->offset += to_flush;
{
VSTREAM *stream = VBUF_TO_APPL(bp, VSTREAM, buf);
char *myname = "vstream_buf_get_ready";
- int n;
+ ssize_t n;
/*
* Detect a change of I/O direction or position. If so, flush any
if (stream->timeout)
stream->iotime = time((time_t *) 0);
if (msg_verbose > 2)
- msg_info("%s: fd %d got %d", myname, stream->fd, n);
+ msg_info("%s: fd %d got %ld", myname, stream->fd, (long) n);
bp->cnt = -n;
bp->ptr = bp->data;
if (bp->flags & VSTREAM_FLAG_SEEK)
/* vstream_buf_space - reserve space ahead of time */
-static int vstream_buf_space(VBUF *bp, int want)
+static int vstream_buf_space(VBUF *bp, ssize_t want)
{
VSTREAM *stream = VBUF_TO_APPL(bp, VSTREAM, buf);
- int used;
- int incr;
- int shortage;
+ ssize_t used;
+ ssize_t incr;
+ ssize_t shortage;
char *myname = "vstream_buf_space";
/*
/* vstream_fopen - open buffered file stream */
-VSTREAM *vstream_fopen(const char *path, int flags, int mode)
+VSTREAM *vstream_fopen(const char *path, int flags, mode_t mode)
{
VSTREAM *stream;
int fd;
/* vstream_peek - peek at a stream */
-int vstream_peek(VSTREAM *vp)
+ssize_t vstream_peek(VSTREAM *vp)
{
if (vp->buf.flags & VSTREAM_FLAG_READ) {
return (-vp->buf.cnt);
* Simple buffered stream. The members of this structure are not part of the
* official interface and can change without prior notice.
*/
-typedef int (*VSTREAM_FN) (int, void *, unsigned, int, void *);
+typedef ssize_t(*VSTREAM_FN) (int, void *, size_t, int, void *);
typedef int (*VSTREAM_WAITPID_FN) (pid_t, WAIT_STATUS_T *, int);
typedef struct VSTREAM {
#define VSTREAM_BUFSIZE 4096
-extern VSTREAM *vstream_fopen(const char *, int, int);
+extern VSTREAM *vstream_fopen(const char *, int, mode_t);
extern int vstream_fclose(VSTREAM *);
extern off_t vstream_fseek(VSTREAM *, off_t, int);
extern off_t vstream_ftell(VSTREAM *);
extern VSTREAM *vstream_vfprintf(VSTREAM *, const char *, va_list);
-extern int vstream_peek(VSTREAM *);
+extern ssize_t vstream_peek(VSTREAM *);
/*
* Exception handling. We use pointer to jmp_buf to avoid a lot of unused
/* .IP "VSTREAM_POPEN_EXPORT (char **)"
/* Null-terminated array of names of environment parameters
/* that can be exported. By default, everything is exported.
-/* .IP "VSTREAM_POPEN_UID (int)"
+/* .IP "VSTREAM_POPEN_UID (uid_t)"
/* The user ID to execute the command as. The user ID must be non-zero.
-/* .IP "VSTREAM_POPEN_GID (int)"
+/* .IP "VSTREAM_POPEN_GID (gid_t)"
/* The group ID to execute the command as. The group ID must be non-zero.
/* .IP "VSTREAM_POPEN_SHELL (char *)"
/* The shell to use when executing the command specified with
break;
case VSTREAM_POPEN_UID:
args->privileged = 1;
- args->uid = va_arg(ap, int);
+ args->uid = va_arg(ap, uid_t);
break;
case VSTREAM_POPEN_GID:
args->privileged = 1;
- args->gid = va_arg(ap, int);
+ args->gid = va_arg(ap, gid_t);
break;
case VSTREAM_POPEN_ENV:
args->env = va_arg(ap, char **);
/* #include <vstring.h>
/*
/* VSTRING *vstring_alloc(len)
-/* int len;
+/* ssize_t len;
/*
/* vstring_ctl(vp, type, value, ..., VSTRING_CTL_END)
/* VSTRING *vp;
/* char *vstring_str(vp)
/* VSTRING *vp;
/*
-/* VSTRING *VSTRING_LEN(vp)
+/* ssize_t VSTRING_LEN(vp)
/* VSTRING *vp;
/*
/* char *vstring_end(vp)
/*
/* int VSTRING_SPACE(vp, len)
/* VSTRING *vp;
-/* int len;
+/* ssize_t len;
/*
-/* int vstring_avail(vp)
+/* ssize_t vstring_avail(vp)
/* VSTRING *vp;
/*
/* VSTRING *vstring_truncate(vp, len)
/* VSTRING *vp;
-/* int len;
+/* ssize_t len;
/*
/* void VSTRING_RESET(vp)
/* VSTRING *vp;
/* VSTRING *vstring_strncpy(vp, src, len)
/* VSTRING *vp;
/* const char *src;
-/* int len;
+/* ssize_t len;
/*
/* VSTRING *vstring_strcat(vp, src)
/* VSTRING *vp;
/* VSTRING *vstring_strncat(vp, src, len)
/* VSTRING *vp;
/* const char *src;
-/* int len;
+/* ssize_t len;
/*
/* VSTRING *vstring_memcpy(vp, src, len)
/* VSTRING *vp;
/* const char *src;
-/* int len;
+/* ssize_t len;
/*
/* VSTRING *vstring_memcat(vp, src, len)
/* VSTRING *vp;
/* const char *src;
-/* int len;
+/* ssize_t len;
/*
/* char *vstring_memchr(vp, ch)
/* VSTRING *vp;
/* VSTRING *vstring_prepend(vp, src, len)
/* VSTRING *vp;
/* const char *src;
-/* int len;
+/* ssize_t len;
/*
/* VSTRING *vstring_sprintf(vp, format, ...)
/* VSTRING *vp;
/* The function takes a VSTRING pointer and a list of zero
/* or more (name,value) pairs. The expected value type
/* depends on the specified name. The value name codes are:
-/* .IP "VSTRING_CTL_MAXLEN (int)"
+/* .IP "VSTRING_CTL_MAXLEN (ssize_t)"
/* Specifies a hard upper limit on a string's length. When the
/* length would be exceeded, the program simulates a memory
/* allocation problem (i.e. it terminates through msg_fatal()).
/*
/* vstring_memchr() locates a byte in a variable-length string.
/*
-/* vstring_prepend() prepends a buffer content to a variable-length
+/* vstring_prepend() prepends a buffer content to a variable-length
/* string. The result is null-terminated.
/*
/* vstring_sprintf() produces a formatted string according to its
/* vstring_extend - variable-length string buffer extension policy */
-static void vstring_extend(VBUF *bp, int incr)
+static void vstring_extend(VBUF *bp, ssize_t incr)
{
- unsigned used = bp->ptr - bp->data;
- int new_len;
+ size_t used = bp->ptr - bp->data;
+ ssize_t new_len;
/*
* Note: vp->vbuf.len is the current buffer size (both on entry and on
* size to avoid silly little buffer increments. With really large
* strings we might want to abandon the length doubling strategy, and go
* to fixed increments.
+ *
+ * The length overflow tests here and in vstring_alloc() should protect us
+ * against all length overflow problems within vstring library routines.
*/
new_len = bp->len + (bp->len > incr ? bp->len : incr);
+ if (new_len < 0)
+ msg_fatal("vstring_extend: length overflow");
bp->data = (unsigned char *) myrealloc((char *) bp->data, new_len);
bp->len = new_len;
bp->ptr = bp->data + used;
/* vstring_buf_space - vbuf callback to reserve space */
-static int vstring_buf_space(VBUF *bp, int len)
+static int vstring_buf_space(VBUF *bp, ssize_t len)
{
- int need;
+ ssize_t need;
if (len < 0)
- msg_panic("vstring_buf_space: bad length %d", len);
+ msg_panic("vstring_buf_space: bad length %ld", (long) len);
if ((need = len - bp->cnt) > 0)
vstring_extend(bp, need);
return (0);
/* vstring_alloc - create variable-length string */
-VSTRING *vstring_alloc(int len)
+VSTRING *vstring_alloc(ssize_t len)
{
VSTRING *vp;
if (len < 1)
- msg_panic("vstring_alloc: bad length %d", len);
+ msg_panic("vstring_alloc: bad length %ld", (long) len);
vp = (VSTRING *) mymalloc(sizeof(*vp));
vp->vbuf.flags = 0;
vp->vbuf.len = 0;
default:
msg_panic("vstring_ctl: unknown code: %d", code);
case VSTRING_CTL_MAXLEN:
- vp->maxlen = va_arg(ap, int);
+ vp->maxlen = va_arg(ap, ssize_t);
if (vp->maxlen < 0)
- msg_panic("vstring_ctl: bad max length %d", vp->maxlen);
+ msg_panic("vstring_ctl: bad max length %ld", (long) vp->maxlen);
break;
}
}
/* vstring_truncate - truncate string */
-VSTRING *vstring_truncate(VSTRING *vp, int len)
+VSTRING *vstring_truncate(VSTRING *vp, ssize_t len)
{
if (len < 0)
- msg_panic("vstring_truncate: bad length %d", len);
+ msg_panic("vstring_truncate: bad length %ld", (long) len);
if (len < VSTRING_LEN(vp))
VSTRING_AT_OFFSET(vp, len);
return (vp);
/* vstring_strncpy - copy string of limited length */
-VSTRING *vstring_strncpy(VSTRING *vp, const char *src, int len)
+VSTRING *vstring_strncpy(VSTRING *vp, const char *src, ssize_t len)
{
VSTRING_RESET(vp);
/* vstring_strncat - append string of limited length */
-VSTRING *vstring_strncat(VSTRING *vp, const char *src, int len)
+VSTRING *vstring_strncat(VSTRING *vp, const char *src, ssize_t len)
{
while (len-- > 0 && *src) {
VSTRING_ADDCH(vp, *src);
/* vstring_memcpy - copy buffer of limited length */
-VSTRING *vstring_memcpy(VSTRING *vp, const char *src, int len)
+VSTRING *vstring_memcpy(VSTRING *vp, const char *src, ssize_t len)
{
VSTRING_RESET(vp);
/* vstring_memcat - append buffer of limited length */
-VSTRING *vstring_memcat(VSTRING *vp, const char *src, int len)
+VSTRING *vstring_memcat(VSTRING *vp, const char *src, ssize_t len)
{
VSTRING_SPACE(vp, len);
memcpy(vstring_end(vp), src, len);
/* vstring_prepend - prepend text to string */
-VSTRING *vstring_prepend(VSTRING *vp, const char *buf, int len)
+VSTRING *vstring_prepend(VSTRING *vp, const char *buf, ssize_t len)
{
- int new_len;
+ ssize_t new_len;
/*
* Sanity check.
*/
if (len < 0)
- msg_panic("vstring_prepend: bad length %d", len);
+ msg_panic("vstring_prepend: bad length %ld", (long) len);
/*
* Move the existing content and copy the new content.
VSTRING *vstring_import(char *str)
{
VSTRING *vp;
- int len;
+ ssize_t len;
vp = (VSTRING *) mymalloc(sizeof(*vp));
len = strlen(str);
/* vstring_sprintf_prepend - format + prepend string, vsprintf-like interface */
-VSTRING *vstring_sprintf_prepend(VSTRING *vp, const char *format, ...)
+VSTRING *vstring_sprintf_prepend(VSTRING *vp, const char *format,...)
{
va_list ap;
- int old_len = VSTRING_LEN(vp);
- int result_len;
+ ssize_t old_len = VSTRING_LEN(vp);
+ ssize_t result_len;
/* Construct: old|new|free */
va_start(ap, format);
}
printf("argv concatenated: %s\n", vstring_str(vp));
vstring_free(vp);
+ return (0);
}
#endif
*/
typedef struct VSTRING {
VBUF vbuf;
- int maxlen;
+ ssize_t maxlen;
} VSTRING;
-extern VSTRING *vstring_alloc(int);
+extern VSTRING *vstring_alloc(ssize_t);
extern void vstring_ctl(VSTRING *,...);
-extern VSTRING *vstring_truncate(VSTRING *, int);
+extern VSTRING *vstring_truncate(VSTRING *, ssize_t);
extern VSTRING *vstring_free(VSTRING *);
extern VSTRING *vstring_strcpy(VSTRING *, const char *);
-extern VSTRING *vstring_strncpy(VSTRING *, const char *, int);
+extern VSTRING *vstring_strncpy(VSTRING *, const char *, ssize_t);
extern VSTRING *vstring_strcat(VSTRING *, const char *);
-extern VSTRING *vstring_strncat(VSTRING *, const char *, int);
-extern VSTRING *vstring_memcpy(VSTRING *, const char *, int);
-extern VSTRING *vstring_memcat(VSTRING *, const char *, int);
+extern VSTRING *vstring_strncat(VSTRING *, const char *, ssize_t);
+extern VSTRING *vstring_memcpy(VSTRING *, const char *, ssize_t);
+extern VSTRING *vstring_memcat(VSTRING *, const char *, ssize_t);
extern char *vstring_memchr(VSTRING *, int);
-extern VSTRING *vstring_prepend(VSTRING *, const char *, int);
+extern VSTRING *vstring_prepend(VSTRING *, const char *, ssize_t);
extern VSTRING *PRINTFLIKE(2, 3) vstring_sprintf(VSTRING *, const char *,...);
extern VSTRING *PRINTFLIKE(2, 3) vstring_sprintf_append(VSTRING *, const char *,...);
extern VSTRING *PRINTFLIKE(2, 3) vstring_sprintf_prepend(VSTRING *, const char *, ...);
*/
#define VSTRING_SPACE(vp, len) ((vp)->vbuf.space(&(vp)->vbuf, len))
#define vstring_str(vp) ((char *) (vp)->vbuf.data)
-#define VSTRING_LEN(vp) ((vp)->vbuf.ptr - (vp)->vbuf.data)
+#define VSTRING_LEN(vp) ((ssize_t) ((vp)->vbuf.ptr - (vp)->vbuf.data))
#define vstring_end(vp) ((char *) (vp)->vbuf.ptr)
#define VSTRING_TERMINATE(vp) { if ((vp)->vbuf.cnt <= 0) \
VSTRING_SPACE((vp),1); \
vstream_fclose(fp);
vstream_fflush(VSTREAM_OUT);
vstring_free(vp);
+ return (0);
}
#endif
watchdog_pat();
} while (VSTREAM_GETCHAR() != VSTREAM_EOF);
watchdog_destroy(wp);
+ return (0);
}
#endif
/* SYNOPSIS
/* #include <iostuff.h>
/*
-/* int write_buf(fd, buf, len, timeout)
+/* ssize_t write_buf(fd, buf, len, timeout)
/* int fd;
/* const char *buf;
-/* int len;
+/* ssize_t len;
/* int timeout;
/* DESCRIPTION
/* write_buf() writes a buffer to the named stream in as many
/* write_buf - write buffer or bust */
-int write_buf(int fd, const char *buf, int len, int timeout)
+ssize_t write_buf(int fd, const char *buf, ssize_t len, int timeout)
{
- int count;
+ ssize_t count;
while (len > 0) {
if (timeout > 0 && write_wait(fd, timeout) < 0)
long probed;
long updated;
char *text;
- VSTREAM *post;
if (attr_scan(client_stream, ATTR_FLAG_STRICT,
ATTR_TYPE_STR, MAIL_ATTR_ADDR, addr,
projects / thirdparty / postfix.git / commitdiff
