# include "config.h"
#endif
+#include <lib-lib/mem.h>
+
#include "mutt.h"
#include "ascii.h"
#include "handler.h"
#include "mutt_crypt.h"
#include "mutt_idna.h"
-#include "lib/mem.h"
#include "lib/str.h"
#include "lib/intl.h"
#include "lib/debug.h"
&& !strcmp (buffer, tmp))
snprintf (buffer, sizeof (buffer), "\"%s\"", tmp);
- mem_free (&tmp);
+ p_delete(&tmp);
tmplen = str_len (buffer) + str_len (p->attribute) + 1;
tmp = str_dup (t);
encode = rfc2231_encode_string (&tmp);
rfc822_cat (buffer, sizeof (buffer), tmp, MimeSpecials);
- mem_free (&tmp);
+ p_delete(&tmp);
fprintf (f, "; filename%s=%s", encode ? "*" : "", buffer);
}
}
#ifdef HAVE_ICONV
iconv_t cd1, *cd;
char bufi[256], bufu[512], bufo[4 * sizeof (bufi)];
- ICONV_CONST char *ib, *ub;
+ const char *ib, *ub;
char *ob;
size_t ibl, obl, ubl, ubl1, n, ret;
int i;
if (cd1 == (iconv_t) (-1))
return -1;
- cd = mem_calloc (ncodes, sizeof (iconv_t));
- score = mem_calloc (ncodes, sizeof (size_t));
- states = mem_calloc (ncodes, sizeof (CONTENT_STATE));
- infos = mem_calloc (ncodes, sizeof (CONTENT));
+ cd = p_new(iconv_t, ncodes);
+ score = p_new(size_t, ncodes);
+ states = p_new(CONTENT_STATE, ncodes);
+ infos = p_new(CONTENT, ncodes);
for (i = 0; i < ncodes; i++)
if (ascii_strcasecmp (tocodes[i], "UTF-8"))
/* Convert to UTF-8 */
ib = bufi;
ob = bufu, obl = sizeof (bufu);
- n = iconv (cd1, ibl ? &ib : 0, &ibl, &ob, &obl);
+ n = my_iconv(cd1, ibl ? &ib : 0, &ibl, &ob, &obl);
assert (n == (size_t) (-1) || !n || ICONV_NONTRANS);
if (n == (size_t) (-1) &&
((errno != EINVAL && errno != E2BIG) || ib == bufi)) {
if (cd[i] != (iconv_t) (-1) && score[i] != (size_t) (-1)) {
ub = bufu, ubl = ubl1;
ob = bufo, obl = sizeof (bufo);
- n = iconv (cd[i], (ibl || ubl) ? &ub : 0, &ubl, &ob, &obl);
+ n = my_iconv(cd[i], (ibl || ubl) ? &ub : 0, &ubl, &ob, &obl);
if (n == (size_t) (-1)) {
assert (errno == E2BIG ||
(BUGGY_ICONV && (errno == EILSEQ || errno == ENOENT)));
iconv_close (cd[i]);
iconv_close (cd1);
- mem_free (&cd);
- mem_free (&infos);
- mem_free (&score);
- mem_free (&states);
+ p_delete(&cd);
+ p_delete(&infos);
+ p_delete(&score);
+ p_delete(&states);
return ret;
#else
}
/* Copy them */
- tcode = mem_malloc (ncodes * sizeof (char *));
+ tcode = p_new(char *, ncodes);
for (c = tocodes, i = 0; c; c = c1 ? c1 + 1 : 0, i++) {
if ((c1 = strchr (c, ':')) == c)
continue;
tcode[cn] = 0;
break;
}
- mem_free (&fcode);
+ p_delete(&fcode);
}
}
else {
/* Free memory */
for (i = 0; i < ncodes; i++)
- mem_free (&tcode[i]);
+ p_delete(&tcode[i]);
- mem_free (tcode);
+ p_delete(tcode);
return ret;
}
return (NULL);
}
- info = mem_calloc (1, sizeof (CONTENT));
+ info = p_new(CONTENT, 1);
memset (&state, 0, sizeof (state));
if (b != NULL && b->type == TYPETEXT && (!b->noconv && !b->force_charset)) {
mutt_set_parameter ("charset", chsbuf, &b->parameter);
}
b->file_charset = fromcode;
- mem_free (&tocode);
+ p_delete(&tocode);
safe_fclose (&fp);
return info;
}
szf = str_len (path);
- for (count = 0; count < 3; count++) {
+ for (count = 0; count < 4; count++) {
/*
* can't use strtok() because we use it in an inner loop below, so use
* a switch statement here instead.
case 2:
strfcpy (buf, PKGDATADIR "/mime.types", sizeof (buf));
break;
+ case 3:
+ strfcpy (buf, SYSCONFDIR "/mime.types", sizeof (buf));
+ break;
default:
debug_print (1, ("Internal error, count = %d.\n", count));
goto bye; /* shouldn't happen */
mutt_write_mime_body (a->parts, fpout);
cleanup:
- mem_free (&line);
+ p_delete(&line);
if (fpin && !fp)
fclose (fpin);
mutt_set_encoding (a, info);
mutt_stamp_attachment (a);
- mem_free (&a->content);
+ p_delete(&a->content);
a->content = info;
}
for (; (TrimRef == 0 || refcnt < TrimRef) && r; r = r->next) {
if (refcnt == refmax)
- mem_realloc (&ref, (refmax += REF_INC) * sizeof (LIST *));
+ p_realloc(&ref, refmax += REF_INC);
ref[refcnt++] = r;
}
fputs (ref[refcnt]->data, f);
}
- mem_free (&ref);
+ p_delete(&ref);
}
/* Note: all RFC2047 encoding should be done outside of this routine, except
if (!option (OPTNEWSSEND))
#endif
if (EDIT_HEADER("To:"))
- fputs ("To: \n", fp);
+ fputs ("To:\n", fp);
if (env->cc) {
fputs ("Cc: ", fp);
if (!option (OPTNEWSSEND))
#endif
if (EDIT_HEADER("Cc:"))
- fputs ("Cc: \n", fp);
+ fputs ("Cc:\n", fp);
if (env->bcc) {
if (mode != 0 || option (OPTWRITEBCC)) {
if (!option (OPTNEWSSEND))
#endif
if (EDIT_HEADER("Bcc:"))
- fputs ("Bcc: \n", fp);
+ fputs ("Bcc:\n", fp);
#ifdef USE_NNTP
if (env->newsgroups)
fprintf (fp, "Newsgroups: %s\n", env->newsgroups);
else if (mode == 1 && option (OPTNEWSSEND) && EDIT_HEADER("Newsgroups:"))
- fputs ("Newsgroups: \n", fp);
+ fputs ("Newsgroups:\n", fp);
if (env->followup_to)
fprintf (fp, "Followup-To: %s\n", env->followup_to);
else if (mode == 1 && option (OPTNEWSSEND) && EDIT_HEADER("Followup-To:"))
- fputs ("Followup-To: \n", fp);
+ fputs ("Followup-To:\n", fp);
if (env->x_comment_to)
fprintf (fp, "X-Comment-To: %s\n", env->x_comment_to);
else if (mode == 1 && option (OPTNEWSSEND) && option (OPTXCOMMENTTO) &&
EDIT_HEADER("X-Comment-To:"))
- fputs ("X-Comment-To: \n", fp);
+ fputs ("X-Comment-To:\n", fp);
#endif
if (env->subject)
fprintf (fp, "Subject: %s\n", env->subject);
else if (mode == 1 && EDIT_HEADER("Subject:"))
- fputs ("Subject: \n", fp);
+ fputs ("Subject:\n", fp);
/* save message id if the user has set it */
if (env->message_id && !privacy)
mutt_write_address_list (env->reply_to, fp, 10, 0);
}
else if (mode > 0 && EDIT_HEADER("Reply-To:"))
- fputs ("Reply-To: \n", fp);
+ fputs ("Reply-To:\n", fp);
if (env->mail_followup_to)
#ifdef USE_NNTP
}
if (mode == 0 && !privacy && option (OPTXMAILER) && !has_agent) {
- struct utsname un;
- char *os;
+ const char *os;
if (OperatingSystem != NULL) {
os = OperatingSystem;
- }
- else {
- if (uname (&un) == -1) {
- os = "UNIX";
- }
- else {
- os = un.sysname;
- }
+ } else {
+ struct utsname un;
+ os = (uname(&un) == -1) ? "UNIX" : un.sysname;
}
/* Add a vanity header */
fprintf (fp, "User-Agent: %s (%s)\n", mutt_make_version (0), os);
}
- list_del (&hdrs, (list_del_t*) _mem_free);
+ list_del (&hdrs, (list_del_t*)xmemfree);
return (ferror (fp) == 0 ? 0 : -1);
}
continue;
rfc2047_encode_string (&tmp);
- mem_realloc (&h->data,
- str_len (h->data) + 2 + str_len (tmp) + 1);
+ p_realloc(&h->data, str_len(h->data) + 2 + str_len(tmp) + 1);
sprintf (h->data + i, ": %s", NONULL (tmp)); /* __SPRINTF_CHECKED__ */
- mem_free (&tmp);
+ p_delete(&tmp);
}
}
to the temporary file containing the stdout of the
child process */
static int
-send_msg (const char *path, char **args, const char *msg, char **tempfile)
+send_msg(const char *path, const char **args, const char *msg, char **tempfile)
{
sigset_t set;
int fd, st;
}
else if (pid == -1) {
unlink (msg);
- mem_free (tempfile);
+ p_delete(tempfile);
_exit (S_ERR);
}
st = WIFEXITED (st) ? WEXITSTATUS (st) : S_ERR;
if (SendmailWait && st == (0xff & EX_OK)) {
unlink (*tempfile); /* no longer needed */
- mem_free (tempfile);
+ p_delete(tempfile);
}
}
else {
st = (SendmailWait > 0 && errno == EINTR && SigAlrm) ? S_BKG : S_ERR;
if (SendmailWait > 0) {
unlink (*tempfile);
- mem_free (tempfile);
+ p_delete(tempfile);
}
}
if (kill (ppid, 0) == -1 && errno == ESRCH) {
/* the parent is already dead */
unlink (*tempfile);
- mem_free (tempfile);
+ p_delete(tempfile);
}
_exit (st);
return (st);
}
-static char **add_args (char **args, size_t * argslen, size_t * argsmax,
- ADDRESS * addr)
+static const char **
+add_args(const char **args, size_t *argslen, size_t *argsmax, ADDRESS * addr)
{
for (; addr; addr = addr->next) {
/* weed out group mailboxes, since those are for display only */
if (addr->mailbox && !addr->group) {
if (*argslen == *argsmax)
- mem_realloc (&args, (*argsmax += 5) * sizeof (char *));
+ p_realloc(&args, *argsmax += 5);
args[(*argslen)++] = addr->mailbox;
}
}
return (args);
}
-static char **add_option (char **args, size_t * argslen, size_t * argsmax,
- char *s)
+static const char **
+add_option(const char **args, size_t *argslen, size_t *argsmax, const char *s)
{
- if (*argslen == *argsmax)
- mem_realloc (&args, (*argsmax += 5) * sizeof (char *));
- args[(*argslen)++] = s;
- return (args);
+ if (*argslen == *argsmax) {
+ p_realloc(&args, *argsmax += 5);
+ }
+ args[(*argslen)++] = s;
+ return (args);
}
static int mutt_invoke_sendmail (ADDRESS * from, /* the sender */
int eightbit)
{ /* message contains 8bit chars */
char *ps = NULL, *path = NULL, *s = NULL, *childout = NULL;
- char **args = NULL;
+ const char **args = NULL;
size_t argslen = 0, argsmax = 0;
int i;
i = 0;
while ((ps = strtok (ps, " "))) {
if (argslen == argsmax)
- mem_realloc (&args, sizeof (char *) * (argsmax += 5));
+ p_realloc(&args, argsmax += 5);
if (i)
args[argslen++] = ps;
if (!option (OPTNEWSSEND)) {
#endif
if (eightbit && option (OPTUSE8BITMIME))
- args = add_option (args, &argslen, &argsmax, "-B8BITMIME");
+ args = add_option(args, &argslen, &argsmax, "-B8BITMIME");
if (option (OPTENVFROM)) {
ADDRESS *f = NULL;
#endif
if (argslen == argsmax)
- mem_realloc (&args, sizeof (char *) * (++argsmax));
+ p_realloc(&args, ++argsmax);
args[argslen++] = NULL;
else
unlink (childout);
- mem_free (&childout);
- mem_free (&path);
- mem_free (&s);
- mem_free (&args);
+ p_delete(&childout);
+ p_delete(&path);
+ p_delete(&s);
+ p_delete(&args);
if (i == (EX_OK & 0xff))
i = 0;
{
size_t la = str_len (a);
- mem_realloc (&a, la + str_len (b) + 1);
+ p_realloc(&a, la + str_len(b) + 1);
strcpy (a + la, b); /* __STRCPY_CHECKED__ */
return (a);
}
size_t rlen;
rlen = str_len (s) + 3;
- pr = r = (char *) mem_malloc (rlen);
+ pr = r = p_new(char, rlen);
*pr++ = '"';
while (*s) {
if (INVALID_CHAR (*s)) {
size_t o = pr - r;
- mem_realloc (&r, ++rlen);
+ p_realloc(&r, ++rlen);
pr = r + o;
*pr++ = '\\';
}
rewind (tempfp);
while (fgets (sasha, sizeof (sasha), tempfp) != NULL)
lines++;
- fprintf (msg->fp, "Content-Length: " OFF_T_FMT "\n", ftello (tempfp));
+ fprintf (msg->fp, "Content-Length: %zd\n", ftello (tempfp));
fprintf (msg->fp, "Lines: %d\n\n", lines);
/* copy the body and clean up */
projects / apps / madmutt.git / blobdiff