#define min(a,b) ((a<b)?a:b)
if (s[0] != 0) { /* avoid empty string as strstr argument */
- memset (bestname, 0, sizeof (bestname));
+ p_clear(bestname, sizeof(bestname));
while (a) {
if (a->name && strstr (a->name, s) == a->name) {
if (use_pager) {
pager_t info;
+ p_clear(&info, 1);
- memset (&info, 0, sizeof (info));
- info.fp = fp;
+ info.fp = fp;
info.bdy = a;
info.ctx = Context;
info.idx = idx;
info.idxlen = idxlen;
info.hdr = hdr;
- rc = mutt_do_pager (descrip, pagerfile,
- M_PAGER_ATTACHMENT | (is_message ? M_PAGER_MESSAGE :
- 0), &info);
+ rc = mutt_do_pager(descrip, pagerfile,
+ M_PAGER_ATTACHMENT | (is_message ? M_PAGER_MESSAGE : 0),
+ &info);
*pagerfile = '\0';
}
else
if (fp) {
/* recv case */
-
STATE s;
-
- memset (&s, 0, sizeof (STATE));
+ p_clear(&s, 1);
if (outfile && *outfile)
- thepid =
- mutt_create_filter_fd (path, &s.fpout, NULL, NULL, -1, out, -1);
+ thepid = mutt_create_filter_fd(path, &s.fpout, NULL, NULL, -1, out, -1);
else
- thepid = mutt_create_filter (path, &s.fpout, NULL, NULL);
+ thepid = mutt_create_filter(path, &s.fpout, NULL, NULL);
if (thepid < 0) {
mutt_perror (_("Can't create filter"));
/* In recv mode, extract from folder and decode */
STATE s;
+ p_clear(&s, 1);
- memset (&s, 0, sizeof (s));
if ((s.fpout = mutt_save_attachment_open (path, flags)) == NULL) {
mutt_perror ("fopen");
return (-1);
BODY *saved_parts = NULL;
HEADER *saved_hdr = NULL;
- memset (&s, 0, sizeof (s));
+ p_clear(&s, 1);
s.flags = displaying;
if (flags == M_SAVE_APPEND)
buffy = buffy && folder;
- memset (&state, 0, sizeof (struct browser_state));
+ p_clear(&state, 1);
if (!folder)
strfcpy (LastDirBackup, LastDir, sizeof (LastDirBackup));
*/
BUFFER *mutt_buffer_init(BUFFER *b)
{
- if (!b) {
- b = p_new(BUFFER, 1);
- if (!b)
- return NULL;
- }
- else {
+ if (!b) {
+ b = p_new(BUFFER, 1);
+ }
p_delete(&b->data);
- }
- memset (b, 0, sizeof (BUFFER));
- return b;
+ p_clear(b, 1);
+ return b;
}
/*
tok->dptr = pc + 1;
/* read line */
- memset (&expn, 0, sizeof (expn));
+ p_clear(&expn, 1);
expn.data = mutt_read_line (NULL, &expn.dsize, fp, &line);
fclose (fp);
mutt_wait_filter (pid);
int bytes_read;
int i; /* Index into `buffer' for scanning. */
- memset (buffer, 0, sizeof (buffer));
+ p_clear(buffer, 1);
fseeko (f, 0, SEEK_END);
pos = ftello (f);
void ci_start_color (void)
{
- memset (ColorDefs, A_NORMAL, sizeof (int) * MT_COLOR_MAX);
- ColorQuote = p_new(int, COLOR_QUOTE_INIT);
- memset (ColorQuote, A_NORMAL, sizeof (int) * COLOR_QUOTE_INIT);
- ColorQuoteSize = COLOR_QUOTE_INIT;
- ColorQuoteUsed = 0;
-
- /* set some defaults */
- ColorDefs[MT_COLOR_STATUS] = A_REVERSE;
- ColorDefs[MT_COLOR_INDICATOR] = A_REVERSE;
- ColorDefs[MT_COLOR_SEARCH] = A_REVERSE;
- ColorDefs[MT_COLOR_MARKERS] = A_REVERSE;
- /* special meaning: toggle the relevant attribute */
- ColorDefs[MT_COLOR_BOLD] = 0;
- ColorDefs[MT_COLOR_UNDERLINE] = 0;
+ memset(ColorDefs, A_NORMAL, sizeof(int) * MT_COLOR_MAX);
+ ColorQuote = p_new(int, COLOR_QUOTE_INIT);
+ memset(ColorQuote, A_NORMAL, sizeof(int) * COLOR_QUOTE_INIT);
+ ColorQuoteSize = COLOR_QUOTE_INIT;
+ ColorQuoteUsed = 0;
+
+ /* set some defaults */
+ ColorDefs[MT_COLOR_STATUS] = A_REVERSE;
+ ColorDefs[MT_COLOR_INDICATOR] = A_REVERSE;
+ ColorDefs[MT_COLOR_SEARCH] = A_REVERSE;
+ ColorDefs[MT_COLOR_MARKERS] = A_REVERSE;
+ /* special meaning: toggle the relevant attribute */
+ ColorDefs[MT_COLOR_BOLD] = 0;
+ ColorDefs[MT_COLOR_UNDERLINE] = 0;
#ifdef HAVE_COLOR
- start_color ();
+ start_color ();
#endif
}
}
/* Invoke the builtin pager */
- memset (&info, 0, sizeof (pager_t));
+ p_clear(&info, 1);
info.hdr = cur;
info.ctx = Context;
rc = mutt_pager (NULL, tempfile, M_PAGER_MESSAGE, &info);
return;
err.data = errbuf;
err.dsize = sizeof (errbuf);
- memset (&token, 0, sizeof (token));
+ p_clear(&token, 1);
r = mutt_parse_rc_line (buffer, &token, &err);
p_delete(&token.data);
if (errbuf[0]) {
if (flags & M_CM_DECODE) {
/* now make a text/plain version of the message */
- memset (&s, 0, sizeof (STATE));
+ p_clear(&s, 1);
s.fpin = fpin;
s.fpout = fpout;
if (flags & M_CM_PREFIX)
b = b->parts->next;
- memset (&s, 0, sizeof (s));
+ p_clear(&s, 1);
s.fpin = fpin;
mutt_mktemp (tempfile);
if (!(*fpout = safe_fopen (tempfile, "w+"))) {
saved_b_type = b->type;
saved_b_offset = b->offset;
saved_b_length = b->length;
- memset (&s, 0, sizeof (s));
+ p_clear(&s, 1);
s.fpin = fpin;
fseeko (s.fpin, b->offset, 0);
mutt_mktemp (tempfile);
b->offset = 0;
rewind (tmpfp);
- memset (&s, 0, sizeof (s));
+ p_clear(&s, 1);
s.fpin = tmpfp;
s.fpout = 0;
mutt_mktemp (tempfile);
saved_b_type = bb->type;
saved_b_offset = bb->offset;
saved_b_length = bb->length;
- memset (&s, 0, sizeof (s));
+ p_clear(&s, 1);
s.fpin = *fpout;
fseeko (s.fpin, bb->offset, 0);
mutt_mktemp (tempfile);
rewind (tmpfp);
fclose (*fpout);
- memset (&s, 0, sizeof (s));
+ p_clear(&s, 1);
s.fpin = tmpfp;
s.fpout = 0;
mutt_mktemp (tempfile);
mbstate_t mbstate;
size_t n1, n2;
- memset (&mbstate, 0, sizeof (mbstate));
+ p_clear(&mbstate, 1);
if ((n1 = wcrtomb (buf, wc, &mbstate)) == (size_t) (-1) ||
(n2 = wcrtomb (buf + n1, 0, &mbstate)) == (size_t) (-1))
return -1; /* ERR */
char scratch[MB_LEN_MAX];
mbstate_t mbstate1, mbstate2;
- memset (&mbstate1, 0, sizeof (mbstate1));
- memset (&mbstate2, 0, sizeof (mbstate2));
+ p_clear(&mbstate1, 1);
+ p_clear(&mbstate2, 1);
--destlen;
p = dest;
for (; n && (k = mbrtowc (&wc, s, n, &mbstate1)); s += k, n -= k) {
size_t len = m_strlen(s);
mbstate_t mbstate;
- memset (&mbstate, 0, sizeof (mbstate));
+ p_clear(&mbstate, 1);
for (; len && (k = mbrtowc (&wc, s, len, &mbstate)); s += k, len -= k) {
if (k == (size_t) (-1) || k == (size_t) (-2)) {
k = (k == (size_t) (-1)) ? 1 : len;
n = m_strlen(s);
- memset (&mbstate, 0, sizeof (mbstate));
+ p_clear(&mbstate, 1);
for (w = 0; n && (k = mbrtowc (&wc, s, n, &mbstate)); s += k, n -= k) {
if (k == (size_t) (-1) || k == (size_t) (-2)) {
k = (k == (size_t) (-1)) ? 1 : n;
size_t k;
/* First convert directly into the destination buffer */
- memset (&st, 0, sizeof (st));
+ p_clear(&st, 1);
for (; slen && dlen >= MB_LEN_MAX; dest += k, dlen -= k, src++, slen--)
if ((k = wcrtomb (dest, *src, &st)) == (size_t) (-1))
break;
size_t wbuflen;
wbuf = *pwbuf, wbuflen = *pwbuflen;
- memset (&st, 0, sizeof (st));
+ p_clear(&st, 1);
for (; (k = mbrtowc (&wc, buf, MB_LEN_MAX, &st)) &&
k != (size_t) (-1) && k != (size_t) (-2); buf += k) {
if (i >= wbuflen) {
int rv = 0;
- memset (&mbstate, 0, sizeof (mbstate));
+ p_clear(&mbstate, 1);
if (state->wbuf) {
/* Coming back after return 1 */
if (k == (size_t) (-2))
continue;
else if (k && k != 1) {
- memset (&mbstate, 0, sizeof (mbstate));
+ p_clear(&mbstate, 1);
continue;
}
}
int tag_len = 0;
char tag[LONG_STRING + 1];
- memset (&stte, 0, sizeof (stte));
+ p_clear(&stte, 1);
stte.s = s;
stte.WrapMargin =
((s->flags & M_DISPLAY) ? (COLS - 4) : ((COLS - 4) <
size_t len = m_strlen(*macro);
mbstate_t mbstate1, mbstate2;
- memset (&mbstate1, 0, sizeof (mbstate1));
- memset (&mbstate2, 0, sizeof (mbstate2));
+ p_clear(&mbstate1, 1);
+ p_clear(&mbstate2, 1);
for (; len && (k = mbrtowc (&wc, *macro, len, &mbstate1));
*macro += k, len -= k) {
if (k == (size_t) (-1) || k == (size_t) (-2)) {
pattern_t *pat = NULL;
char path[_POSIX_PATH_MAX];
- memset (&pattern, 0, sizeof (pattern));
- memset (&command, 0, sizeof (command));
+ p_clear(&pattern, 1);
+ p_clear(&command, 1);
if (*s->dptr == '!') {
s->dptr++;
strfcpy (path, pattern.data, sizeof (path));
_mutt_expand_path (path, sizeof (path), 1);
p_delete(&pattern.data);
- memset (&pattern, 0, sizeof (pattern));
+ p_clear(&pattern, 1);
pattern.data = m_strdup(path);
}
#ifdef USE_COMPRESSED
strfcpy (tmp, pattern.data, sizeof (tmp));
mutt_check_simple (tmp, sizeof (tmp), DefaultHook);
p_delete(&pattern.data);
- memset (&pattern, 0, sizeof (pattern));
+ p_clear(&pattern, 1);
pattern.data = m_strdup(tmp);
}
strfcpy (path, command.data, sizeof (path));
mutt_expand_path (path, sizeof (path));
p_delete(&command.data);
- memset (&command, 0, sizeof (command));
+ p_clear(&command, 1);
command.data = m_strdup(path);
}
err.data = buf;
err.dsize = sizeof (buf);
- memset (&token, 0, sizeof (token));
+ p_clear(&token, 1);
for (; tmp; tmp = tmp->next) {
if (!tmp->command)
continue;
err.data = buf;
err.dsize = sizeof (buf);
- memset (&token, 0, sizeof (token));
+ p_clear(&token, 1);
for (hook = Hooks; hook; hook = hook->next) {
if (!hook->command)
continue;
err.data = buf;
err.dsize = sizeof (buf);
- memset (&token, 0, sizeof (token));
+ p_clear(&token, 1);
for (hook = Hooks; hook; hook = hook->next) {
if (!(hook->command && (hook->type & M_ACCOUNTHOOK)))
else
strfcpy ((char *) secret, password, sizeof (secret));
- memset (ipad, 0, sizeof (ipad));
- memset (opad, 0, sizeof (opad));
+ p_clear(ipad, 1);
+ p_clear(opad, 1);
memcpy (ipad, secret, secret_len);
memcpy (opad, secret, secret_len);
p_delete(&idata->capstr);
idata->capstr = m_strdup(s);
- memset (idata->capabilities, 0, sizeof (idata->capabilities));
+ p_clear(idata->capabilities, 1);
while (*s) {
for (x = 0; x < CAPMAX; x++)
url.user = NULL;
url_ciss_tostring (&url, buf + 11, sizeof (buf) - 10, 0);
str_cat (buf, sizeof (buf), "\"");
- memset (&token, 0, sizeof (token));
+ p_clear(&token, 1);
err.data = errstr;
err.dsize = sizeof (errstr);
if (mutt_parse_rc_line (buf, &token, &err))
s = imap_next_word (s);
/* zero out current rights set */
- memset (idata->rights, 0, sizeof (idata->rights));
+ p_clear(idata->rights, 1);
while (*s && !isspace ((unsigned char) *s)) {
switch (*s) {
if ((rc = imap_check_mailbox (ctx, index_hint, 0)) != 0)
return rc;
- memset (&cmd, 0, sizeof (cmd));
+ p_clear(&cmd, 1);
/* if we are expunging anyway, we can do deleted messages very quickly... */
if (expunge && mutt_bit_isset (idata->rights, ACL_DELETE)) {
if (!do_search (pat, 1))
return 0;
- memset (&buf, 0, sizeof (buf));
+ p_clear(&buf, 1);
mutt_buffer_addstr (&buf, "UID SEARCH ");
if (imap_compile_search (pat, &buf) < 0) {
p_delete(&buf.data);
imap_fix_path (idata, mx.mbox, buf, sizeof (buf));
if (option (OPTIMAPCHECKSUBSCRIBED)) {
- memset (&token, 0, sizeof (token));
+ p_clear(&token, 1);
err.data = errstr;
err.dsize = sizeof (errstr);
snprintf (mbox, sizeof (mbox), "%smailboxes \"%s\"",
mutt_message (_("Evaluating cache... [%d/%d]"), msgno + 1, msgend + 1);
rewind (fp);
- memset (&h, 0, sizeof (h));
+ p_clear(&h, 1);
h.data = p_new(IMAP_HEADER_DATA, 1);
do {
mfhrc = 0;
/* freshen fp, h */
rewind (fp);
- memset (&h, 0, sizeof (h));
+ p_clear(&h, 1);
h.data = p_new(IMAP_HEADER_DATA, 1);
/* this DO loop does two things:
imap_fix_path (idata, mx.mbox, mbox, sizeof (mbox));
- memset (&sync_cmd, 0, sizeof (sync_cmd));
- memset (&cmd, 0, sizeof (cmd));
+ p_clear(&sync_cmd, 1);
+ p_clear(&cmd, 1);
mutt_buffer_addstr (&cmd, "UID COPY ");
/* Null HEADER* means copy tagged messages */
IMAP_HEADER newh;
unsigned char readonly;
- memset (&newh, 0, sizeof (newh));
+ p_clear(&newh, 1);
newh.data = p_new(IMAP_HEADER_DATA, 1);
debug_print (2, ("parsing FLAGS\n"));
BUFFER token;
struct option_t* option = NULL;
- memset (&token, 0, sizeof(token));
+ p_clear(&token, 1);
mutt_extract_token (tmp, s, 0);
/* is the item defined as a variable or a function? */
{
BUFFER templ;
- memset (&templ, 0, sizeof(templ));
+ p_clear(&templ, 1);
/* Insist on at least one parameter */
if (!MoreArgs (s)) {
/* replace the old value */
p_delete(&tmp->data);
tmp->data = buf->data;
- memset (buf, 0, sizeof(BUFFER));
+ p_clear(buf, 1);
return 0;
}
if (!tmp->next)
UserHeader = tmp;
}
tmp->data = buf->data;
- memset (buf, 0, sizeof(BUFFER));
+ p_clear(buf, 1);
return 0;
}
/* only expand for string as it's the only place where
* we want to expand vars right now */
if (src->init && *src->init) {
- memset (&token, 0, sizeof(BUFFER));
- memset (&in, 0, sizeof(BUFFER));
+ p_clear(&token, 1);
+ p_clear(&in, 1);
len = m_strlen(src->init) + 2;
in.data = p_new(char, len + 1);
snprintf (in.data, len, "\"%s\"", src->init);
return (-1);
}
- memset (&token, 0, sizeof(token));
+ p_clear(&token, 1);
while ((linebuf = mutt_read_line (linebuf, &buflen, f, &line)) != NULL) {
conv = ConfigCharset && (*ConfigCharset) && Charset;
if (conv) {
int i, r = -1;
BUFFER expn;
- memset (&expn, 0, sizeof(expn));
+ p_clear(&expn, 1);
expn.data = expn.dptr = line;
expn.dsize = m_strlen(line);
if (numtabs == 1) {
Num_matched = 0;
strfcpy (User_typed, pt, sizeof(User_typed));
- memset (Matches, 0, sizeof(Matches));
- memset (Completed, 0, sizeof(Completed));
+ p_clear(Matches, sizeof(Matches));
+ p_clear(Completed, sizeof(Completed));
for (num = 0; Commands[num].name; num++)
candidate (Completed, User_typed, Commands[num].name,
sizeof(Completed));
if (numtabs == 1) {
Num_matched = 0;
strfcpy (User_typed, pt, sizeof(User_typed));
- memset (Matches, 0, sizeof(Matches));
- memset (Completed, 0, sizeof(Completed));
+ p_clear(Matches, sizeof(Matches));
+ p_clear(Completed, sizeof(Completed));
for (num = 0; MuttVars[num].option; num++)
- candidate (Completed, User_typed, MuttVars[num].option,
- sizeof(Completed));
+ candidate(Completed, User_typed, MuttVars[num].option,
+ sizeof(Completed));
Matches[Num_matched++] = User_typed;
/* All matches are stored. Longest non-ambiguous string is ""
if (numtabs == 1) {
Num_matched = 0;
strfcpy (User_typed, pt, sizeof(User_typed));
- memset (Matches, 0, sizeof(Matches));
- memset (Completed, 0, sizeof(Completed));
+ p_clear(Matches, sizeof(Matches));
+ p_clear(Completed, sizeof(Completed));
for (num = 0; menu[num].name; num++)
candidate (Completed, User_typed, menu[num].name, sizeof(Completed));
/* try the generic menu */
BUFFER err, token;
- memset (&err, 0, sizeof(err));
- memset (&token, 0, sizeof(token));
+ p_clear(&err, 1);
+ p_clear(&token, 1);
err.data = errbuff;
err.dsize = sizeof(errbuff);
BUFFER err, token;
char errstr[SHORT_STRING];
- memset (&err, 0, sizeof(err));
+ p_clear(&err, 1);
err.data = errstr;
err.dsize = sizeof(errstr);
- memset (&token, 0, sizeof(token));
+ p_clear(&token, 1);
for (; p; p = p->next) {
if (mutt_parse_rc_line (p->data, &token, &err) != 0) {
fprintf (stderr, _("Error in command line: %s\n"), err.data);
int i, default_rc = 0, need_pause = 0;
BUFFER err;
- memset (&err, 0, sizeof(err));
+ p_clear(&err, 1);
err.data = error;
err.dsize = sizeof(error);
snprintf (buffer, sizeof(buffer), "Reply-To: %s", p);
- memset (&buf, 0, sizeof(buf));
+ p_clear(&buf, 1);
buf.data = buf.dptr = buffer;
buf.dsize = m_strlen(buffer);
- memset (&token, 0, sizeof(token));
+ p_clear(&token, 1);
parse_my_hdr (&token, &buf, 0, &err);
p_delete(&token.data);
}
void km_init (void)
{
- memset (Keymaps, 0, sizeof (struct keymap_t *) * MENU_MAX);
+ p_clear(Keymaps, MENU_MAX);
create_bindings (OpAttach, MENU_ATTACH);
create_bindings (OpBrowser, MENU_FOLDER);
int i = 0;
char *p, *q;
- memset (&buf, 0, sizeof (buf));
+ p_clear(&buf, 1);
/* menu name */
mutt_extract_token (&buf, s, 0);
if ((f = fdopen (fd, "r+"))) {
unlink (s);
- memset (buf, 0, sizeof (buf));
+ p_clear(buf, sizeof(buf));
while (sb.st_size > 0) {
fwrite (buf, 1, MIN (sizeof (buf), sb.st_size), f);
sb.st_size -= MIN (sizeof (buf), sb.st_size);
SRAND (time (NULL));
umask (077);
- memset (Options, 0, sizeof (Options));
- memset (QuadOptions, 0, sizeof (QuadOptions));
+ p_clear(Options, sizeof(Options));
+ p_clear(QuadOptions, sizeof(QuadOptions));
#ifdef USE_NNTP
while ((i =
return;
}
- memset (val, 0, sizeof (val));
+ memset(val, 0, sizeof(val));
do {
if (!strcmp (buff, "}"))
r = my_iconv(cd, &ib, &ibl, &ob, &obl);
if (ob > bufo && (!k || ib > bufi + k)) {
/* we have a character */
- memset (ps, 0, sizeof (*ps));
+ p_clear(ps, 1);
utf8rtowc (pwc, bufo, ob - bufo, &mbstate);
return (pwc && *pwc) ? (ib - (k ? bufi + k : s)) : 0;
}
}
else {
/* save the state and give up */
- memset (ps, 0, sizeof (*ps));
+ p_clear(ps, 1);
if (ibl <= sizeof (mbstate_t)) /* need extra condition here! */
memcpy (ps, ib, ibl);
return (size_t) (-2);
return mbrtowc_iconv (pwc, s, n, ps, charset_to_utf8);
else {
if (!s) {
- memset (ps, 0, sizeof (*ps));
+ p_clear(ps, 1);
return 0;
}
if (!n)
size_t n = m_strlen((char *) s);
mbstate_t mbstate;
- memset (&mbstate, 0, sizeof (mbstate));
+ p_clear(&mbstate, 1);
while (*s) {
if (*s < M_TREE_MAX) {
if (do_color)
int i, r = 0;
struct mh_sequences mhs;
- memset (&mhs, 0, sizeof (mhs));
+ p_clear(&mhs, 1);
mh_read_sequences (&mhs, path);
for (i = 0; !r && i <= mhs.max; i++)
struct mh_sequences mhs;
- memset (&mhs, 0, sizeof (mhs));
+ p_clear(&mhs, 1);
snprintf (seq_unseen, sizeof (seq_unseen), "%s:", NONULL (MhUnseen));
snprintf (seq_replied, sizeof (seq_replied), "%s:", NONULL (MhReplied));
int count;
- memset (&mhs, 0, sizeof (mhs));
+ p_clear(&mhs, 1);
maildir_update_mtime (ctx);
ctx->mtime_cur = st_cur.st_mtime;
ctx->mtime = st.st_mtime;
- memset (&mhs, 0, sizeof (mhs));
+ p_clear(&mhs, 1);
md = NULL;
last = &md;
* just fall back to LOGIN in the IMAP case anyway. If that doesn't
* work for POP, we can make it a flag or move this code into
* imap/auth_sasl.c */
- memset (&secprops, 0, sizeof (secprops));
+ p_clear(&secprops, 1);
/* Work around a casting bug in the SASL krb4 module */
secprops.max_ssf = 0x7fff;
secprops.maxbufsize = M_SASL_MAXBUF;
struct addrinfo *cur;
/* we accept v4 or v6 STREAM sockets */
- memset (&hints, 0, sizeof (hints));
+ p_clear(&hints, 1);
if (option (OPTUSEIPV6))
hints.ai_family = AF_UNSPEC;
struct hostent *he;
int i;
- memset (&sin, 0, sizeof (sin));
+ p_clear(&sin, 1);
sin.sin_port = htons (conn->account.port);
sin.sin_family = AF_INET;
if (!pw || !pw->pw_gecos)
return NULL;
- memset (dest, 0, destlen);
+ p_clear(dest, destlen);
if (GecosMask.rx) {
if (regexec (GecosMask.rx, pw->pw_gecos, 1, pat_match, 0) == 0)
struct flock lck;
- memset (&lck, 0, sizeof (struct flock));
+ p_clear(&lck, 1);
lck.l_type = excl ? F_WRLCK : F_RDLCK;
lck.l_whence = SEEK_SET;
#ifdef USE_FCNTL
struct flock unlockit;
- memset (&unlockit, 0, sizeof (struct flock));
+ p_clear(&unlockit, 1);
unlockit.l_type = F_UNLCK;
unlockit.l_whence = SEEK_SET;
fcntl (fd, F_SETLK, &unlockit);
if (ctx->limit_pattern)
mutt_pattern_free (&ctx->limit_pattern);
safe_fclose (&ctx->fp);
- memset (ctx, 0, sizeof (CONTEXT));
+ p_clear(ctx, 1);
}
/* save changes to disk */
NNTP_SERVER *serv;
CONNECTION *conn;
- memset (&acct, 0, sizeof (ACCOUNT));
+ p_clear(&acct, 1);
if (!server || !*server) {
mutt_error _("No newsserver defined!");
unsigned int first;
ACCOUNT acct;
- memset (&acct, 0, sizeof (ACCOUNT));
+ p_clear(&acct, 1);
if (nntp_parse_url (ctx->path, &acct, buf, sizeof (buf)) < 0 || !*buf) {
mutt_error (_("%s is an invalid newsgroup specification!"), ctx->path);
mbstate_t mbstate;
size_t k;
- memset (&mbstate, 0, sizeof (mbstate));
+ p_clear(&mbstate, 1);
for (; len > 0; buf += k, len -= k) {
k = mbrtowc (NULL, (char *) buf, len, &mbstate);
if (k == -2)
wrap_cols = COLS;
/* FIXME: this should come from lineInfo */
- memset (&mbstate, 0, sizeof (mbstate));
+ p_clear(&mbstate, 1);
for (ch = 0, vch = 0; ch < cnt; ch += k, vch += k) {
/* Handle ANSI sequences */
if (*last == *max) {
p_realloc(lineInfo, *max += LINES);
for (ch = *last; ch < *max; ch++) {
- memset (&((*lineInfo)[ch]), 0, sizeof (struct line_t));
+ p_clear(&(*lineInfo)[ch], 1);
(*lineInfo)[ch].type = -1;
(*lineInfo)[ch].search_cnt = -1;
(*lineInfo)[ch].syntax = p_new(struct syntax_t, 1);
lineInfo = p_new(struct line_t, maxLine = LINES);
for (i = 0; i < maxLine; i++) {
- memset (&lineInfo[i], 0, sizeof (struct line_t));
+ p_clear(&lineInfo[i], 1);
lineInfo[i].type = -1;
lineInfo[i].search_cnt = -1;
lineInfo[i].syntax = p_new(struct syntax_t, 1);
t = scratch;
SKIPWS (t);
- memset (&tm, 0, sizeof (tm));
+ p_clear(&tm, 1);
while ((t = strtok (t, " \t")) != NULL) {
switch (count) {
if ((msg = mx_open_message (ctx, msgno)) != NULL) {
if (option (OPTTHOROUGHSRC)) {
/* decode the header / body */
- memset (&s, 0, sizeof (s));
+ p_clear(&s, 1);
s.fpin = msg->fp;
s.flags = M_CHARCONV;
mutt_mktemp (tempfile);
BUFFER buf;
int r;
- memset (&buf, 0, sizeof (buf));
+ p_clear(&buf, 1);
if (mutt_extract_token (&buf, s, M_TOKEN_PATTERN | M_TOKEN_COMMENT) != 0 ||
!buf.data) {
BUFFER buffer;
struct tm min, max;
- memset (&buffer, 0, sizeof (buffer));
+ p_clear(&buffer, 1);
if (mutt_extract_token (&buffer, s, M_TOKEN_COMMENT | M_TOKEN_PATTERN) != 0
|| !buffer.data) {
strfcpy (err->data, _("error in expression"), err->dsize);
return (-1);
}
- memset (&min, 0, sizeof (min));
+ p_clear(&min, 1);
/* the `0' time is Jan 1, 1970 UTC, so in order to prevent a negative time
when doing timezone conversion, we use Jan 2, 1970 UTC as the base
here */
min.tm_mday = 2;
min.tm_year = 70;
- memset (&max, 0, sizeof (max));
+ p_clear(&max, 1);
/* Arbitrary year in the future. Don't set this too high
or mutt_mktime() returns something larger than will
char *buf;
BUFFER ps;
- memset (&ps, 0, sizeof (ps));
+ p_clear(&ps, 1);
ps.dptr = s;
ps.dsize = m_strlen(s);
void pgp_void_passphrase (void)
{
- memset (PgpPass, 0, sizeof (PgpPass));
+ p_clear(PgpPass, sizeof(PgpPass));
PgpExptime = 0;
}
return;
}
- memset (&s, 0, sizeof (STATE));
+ p_clear(&s, 1);
s.fpin = fp;
s.fpout = tempfp;
b = b->parts->next;
- memset (&s, 0, sizeof (s));
+ p_clear(&s, 1);
s.fpin = fpin;
mutt_mktemp (tempfile);
if ((*fpout = safe_fopen (tempfile, "w+")) == NULL) {
struct pgp_command_context cctx;
char cmd[HUGE_STRING];
- memset (&cctx, 0, sizeof (cctx));
+ p_clear(&cctx, 1);
if (!format || !*format)
return (pid_t) - 1;
char cmd[HUGE_STRING];
struct pgp_command_context cctx;
- memset (&cctx, 0, sizeof (cctx));
+ p_clear(&cctx, 1);
mutt_quote_filename (_fname, sizeof (_fname), fname);
cctx.fname = _fname;
if (!PgpGetkeysCommand)
return;
- memset (&cctx, 0, sizeof (cctx));
+ p_clear(&cctx, 1);
personal = addr->personal;
addr->personal = NULL;
STATE state;
- memset (&state, 0, sizeof (STATE));
+ p_clear(&state, 1);
state.fpin = in;
state.fpout = out;
memcpy (p->fingerprint, digest, MD5_DIGEST_LENGTH);
}
else /* just to be usre */
- memset (p->fingerprint, 0, MD5_DIGEST_LENGTH);
+ p_clear(p->fingerprint, MD5_DIGEST_LENGTH);
expl = 0;
for (i = 0; i < 2; i++)
int rv = -1;
STATE s;
- memset (&s, 0, sizeof (s));
+ p_clear(&s, 1);
if (!fp && (msg = mx_open_message (ctx, hdr->msgno)) == NULL)
return (-1);
int tagged = 0;
size_t curpos = 0;
- memset (buf, 0, buflen);
+ p_clear(buf, buflen);
/* check for tagged entries */
for (i = 0; i < menu->max; i++) {
filter = 0; /* sanity check: we can't filter in the recv case yet */
buf[0] = 0;
- memset (&state, 0, sizeof (STATE));
+ p_clear(&state, 1);
if (mutt_get_field ((filter ? _("Filter through: ") : _("Pipe to: ")),
buf, sizeof (buf), M_CMD) != 0 || !buf[0])
if (!can_print (top, tag))
return;
mutt_endwin (NULL);
- memset (&state, 0, sizeof (STATE));
+ p_clear(&state, 1);
thepid = mutt_create_filter (NONULL (PrintCmd), &state.fpout, NULL, NULL);
print_attachment_list (fp, tag, top, &state);
fclose (state.fpout);
/* initialize a state structure */
- memset (&st, 0, sizeof (st));
+ p_clear(&st, 1);
if (option (OPTFORWQUOTE))
st.prefix = prefix;
else {
mutt_make_attribution (Context, parent, tmpfp);
- memset (&st, 0, sizeof (STATE));
+ p_clear(&st, 1);
st.fpin = fp;
st.fpout = tmpfp;
return (-1);
}
pattern = buf->data;
- memset (buf, 0, sizeof (BUFFER));
+ p_clear(buf, 1);
mutt_extract_token (buf, s, 0);
if (MoreArgs (s)) {
p_delete(&pattern);
}
info = p_new(CONTENT, 1);
- memset (&state, 0, sizeof (state));
+ p_clear(&state, 1);
if (b != NULL && b->type == TYPETEXT && (!b->noconv && !b->force_charset)) {
char *chs = mutt_get_parameter ("charset", b->parameter);
STATE s;
struct stat sb;
- memset (&s, 0, sizeof (s));
+ p_clear(&s, 1);
for (; a; a = a->next) {
if (a->type == TYPEMULTIPART) {
if (a->encoding != ENC7BIT)
mutt_FormatString (no, len, NONULL (SidebarNumberFormat),
sidebar_number_format, idx, M_FORMAT_OPTIONAL);
lencnt = m_strlen(no);
- memset (&entry, ' ', sizeof (entry));
+ memset(&entry, ' ', sizeof(entry));
#if USE_IMAP
if (l > 0 && str_ncmp (box, ImapHomeNamespace, l) == 0 &&
SETCOLOR (MT_COLOR_NORMAL);
/* fill with blanks to bottom */
- memset (&blank, ' ', sizeof (blank));
+ memset(&blank, ' ', sizeof(blank));
for (; line < last_line; line++) {
move (line, 0);
addnstr (blank, SidebarWidth-delim_len);
{
struct sigaction sa;
- memset (&sa, 0, sizeof sa);
+ p_clear(&sa, 1);
sa.sa_handler = sighandler;
#ifdef SA_RESTART
if (disposition == 0)
void smime_void_passphrase (void)
{
- memset (SmimePass, 0, sizeof (SmimePass));
+ p_clear(SmimePass, sizeof(SmimePass));
SmimeExptime = 0;
}
struct smime_command_context cctx;
char cmd[HUGE_STRING];
- memset (&cctx, 0, sizeof (cctx));
+ p_clear(&cctx, 1);
if (!format || !*format)
return (pid_t) - 1;
if (b->parts)
return -1;
- memset (&s, 0, sizeof (s));
+ p_clear(&s, 1);
s.fpin = fpin;
fseeko (s.fpin, b->offset, 0);