summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
c65e926)
Signed-off-by: Pierre Habouzit <madcoder@debian.org>
12 files changed:
short charset_changed = 0;
short type_changed = 0;
short charset_changed = 0;
short type_changed = 0;
- cp = mutt_get_parameter ("charset", b->parameter);
+ cp = parameter_getval(b->parameter, "charset");
m_strcpy(charset, sizeof(charset), NONULL(cp));
snprintf (buf, sizeof (buf), "%s/%s", TYPE (b), b->subtype);
m_strcpy(charset, sizeof(charset), NONULL(cp));
snprintf (buf, sizeof (buf), "%s/%s", TYPE (b), b->subtype);
snprintf (tmp, sizeof (tmp), "%s/%s", TYPE (b), NONULL (b->subtype));
type_changed = ascii_strcasecmp (tmp, obuf);
charset_changed =
snprintf (tmp, sizeof (tmp), "%s/%s", TYPE (b), NONULL (b->subtype));
type_changed = ascii_strcasecmp (tmp, obuf);
charset_changed =
- ascii_strcasecmp (charset, mutt_get_parameter ("charset", b->parameter));
+ ascii_strcasecmp (charset, parameter_getval(b->parameter, "charset"));
/* if in send mode, check for conversion - current setting is default. */
/* if in send mode, check for conversion - current setting is default. */
int r;
snprintf (tmp, sizeof (tmp), _("Convert to %s upon sending?"),
int r;
snprintf (tmp, sizeof (tmp), _("Convert to %s upon sending?"),
- mutt_get_parameter ("charset", b->parameter));
+ parameter_getval(b->parameter, "charset"));
if ((r = mutt_yesorno (tmp, !b->noconv)) != -1)
b->noconv = (r == M_NO);
}
if ((r = mutt_yesorno (tmp, !b->noconv)) != -1)
b->noconv = (r == M_NO);
}
if (type_changed)
mutt_sleep (1);
mutt_message (_("Character set changed to %s; %s."),
if (type_changed)
mutt_sleep (1);
mutt_message (_("Character set changed to %s; %s."),
- mutt_get_parameter ("charset", b->parameter),
+ parameter_getval(b->parameter, "charset"),
b->noconv ? _("not converting") : _("converting"));
}
b->noconv ? _("not converting") : _("converting"));
}
fstat (fileno (s->fpin), &st);
b = mutt_new_body ();
b->length = (long) st.st_size;
fstat (fileno (s->fpin), &st);
b = mutt_new_body ();
b->length = (long) st.st_size;
- b->parts = mutt_parse_multipart (s->fpin,
- mutt_get_parameter ("boundary",
- a->parameter),
- (long) st.st_size,
- ascii_strcasecmp ("digest",
- a->subtype) == 0);
+ b->parts = mutt_parse_multipart(s->fpin,
+ parameter_getval(a->parameter, "boundary"),
+ (long)st.st_size,
+ !ascii_strcasecmp("digest", a->subtype));
fstat (fileno (s->fpin), &st);
b = mutt_new_body ();
b->length = (long) st.st_size;
fstat (fileno (s->fpin), &st);
b = mutt_new_body ();
b->length = (long) st.st_size;
- b->parts = mutt_parse_multipart (s->fpin,
- mutt_get_parameter ("boundary",
- a->parameter),
- (long) st.st_size,
- ascii_strcasecmp ("digest",
- a->subtype) == 0);
+ b->parts = mutt_parse_multipart(s->fpin,
+ parameter_getval(a->parameter, "boundary"),
+ (long)st.st_size,
+ !ascii_strcasecmp("digest", a->subtype));
const char *expiration;
time_t expire;
const char *expiration;
time_t expire;
- access_type = mutt_get_parameter ("access-type", b->parameter);
+ access_type = parameter_getval(b->parameter, "access-type");
if (!access_type) {
if (s->flags & M_DISPLAY) {
state_mark_attach (s);
if (!access_type) {
if (s->flags & M_DISPLAY) {
state_mark_attach (s);
- expiration = mutt_get_parameter ("expiration", b->parameter);
+ expiration = parameter_getval(b->parameter, "expiration");
if (expiration)
expire = mutt_parse_date (expiration, NULL);
else
if (expiration)
expire = mutt_parse_date (expiration, NULL);
else
state_mark_attach (s);
state_printf (s, _("[-- This %s/%s attachment "),
TYPE (b->parts), b->parts->subtype);
state_mark_attach (s);
state_printf (s, _("[-- This %s/%s attachment "),
TYPE (b->parts), b->parts->subtype);
- length = mutt_get_parameter ("length", b->parameter);
+ length = parameter_getval(b->parameter, "length");
if (length) {
mutt_pretty_size (pretty_size, sizeof (pretty_size),
strtol (length, NULL, 10));
if (length) {
mutt_pretty_size (pretty_size, sizeof (pretty_size),
strtol (length, NULL, 10));
if (istext) {
if (s->flags & M_CHARCONV) {
if (istext) {
if (s->flags & M_CHARCONV) {
- const char *charset = mutt_get_parameter ("charset", b->parameter);
+ const char *charset = parameter_getval(b->parameter, "charset");
if (!option (OPTSTRICTMIME) && !charset)
charset = charset_getfirst(AssumedCharset);
if (!option (OPTSTRICTMIME) && !charset)
charset = charset_getfirst(AssumedCharset);
if (mutt_is_application_pgp (b))
handler = crypt_pgp_application_pgp_handler;
else
if (mutt_is_application_pgp (b))
handler = crypt_pgp_application_pgp_handler;
else
- if (ascii_strcasecmp
- ("flowed", mutt_get_parameter ("format", b->parameter)) == 0)
- handler = rfc3676_handler;
+ if (!ascii_strcasecmp("flowed", parameter_getval(b->parameter, "format")))
+ handler = rfc3676_handler;
if (ascii_strcasecmp ("alternative", b->subtype) == 0)
handler = alternative_handler;
else if (ascii_strcasecmp ("signed", b->subtype) == 0) {
if (ascii_strcasecmp ("alternative", b->subtype) == 0)
handler = alternative_handler;
else if (ascii_strcasecmp ("signed", b->subtype) == 0) {
- p = mutt_get_parameter ("protocol", b->parameter);
+ p = parameter_getval(b->parameter, "protocol");
if (!p)
mutt_error (_("Error: multipart/signed has no protocol."));
if (!p)
mutt_error (_("Error: multipart/signed has no protocol."));
handler = mutt_signed_handler;
}
else if (m_strcasecmp("encrypted", b->subtype) == 0) {
handler = mutt_signed_handler;
}
else if (m_strcasecmp("encrypted", b->subtype) == 0) {
- p = mutt_get_parameter ("protocol", b->parameter);
+ p = parameter_getval(b->parameter, "protocol");
!b->subtype || ascii_strcasecmp (b->subtype, "signed"))
return 0;
!b->subtype || ascii_strcasecmp (b->subtype, "signed"))
return 0;
- if (!(p = mutt_get_parameter ("protocol", b->parameter)))
+ if (!(p = parameter_getval(b->parameter, "protocol")))
return 0;
if (!(ascii_strcasecmp (p, "multipart/mixed")))
return 0;
if (!(ascii_strcasecmp (p, "multipart/mixed")))
if (!b || b->type != TYPEMULTIPART ||
!b->subtype || ascii_strcasecmp (b->subtype, "encrypted") ||
if (!b || b->type != TYPEMULTIPART ||
!b->subtype || ascii_strcasecmp (b->subtype, "encrypted") ||
- !(p = mutt_get_parameter ("protocol", b->parameter)) ||
+ !(p = parameter_getval(b->parameter, "protocol")) ||
ascii_strcasecmp (p, "application/pgp-encrypted"))
return 0;
ascii_strcasecmp (p, "application/pgp-encrypted"))
return 0;
if (m->type == TYPEAPPLICATION) {
if (!ascii_strcasecmp (m->subtype, "pgp")
|| !ascii_strcasecmp (m->subtype, "x-pgp-message")) {
if (m->type == TYPEAPPLICATION) {
if (!ascii_strcasecmp (m->subtype, "pgp")
|| !ascii_strcasecmp (m->subtype, "x-pgp-message")) {
- if ((p = mutt_get_parameter ("x-action", m->parameter))
+ if ((p = parameter_getval(m->parameter, "x-action"))
&& (!ascii_strcasecmp (p, "sign")
|| !ascii_strcasecmp (p, "signclear")))
t |= PGPSIGN;
&& (!ascii_strcasecmp (p, "sign")
|| !ascii_strcasecmp (p, "signclear")))
t |= PGPSIGN;
- if ((p = mutt_get_parameter ("format", m->parameter)) &&
+ if ((p = parameter_getval(m->parameter, "format")) &&
!ascii_strcasecmp (p, "keys-only"))
t |= PGPKEY;
!ascii_strcasecmp (p, "keys-only"))
t |= PGPKEY;
t |= PGPKEY;
}
else if (m->type == TYPETEXT && ascii_strcasecmp ("plain", m->subtype) == 0) {
t |= PGPKEY;
}
else if (m->type == TYPETEXT && ascii_strcasecmp ("plain", m->subtype) == 0) {
- if (((p = mutt_get_parameter ("x-mutt-action", m->parameter))
- || (p = mutt_get_parameter ("x-action", m->parameter))
- || (p = mutt_get_parameter ("action", m->parameter)))
+ if (((p = parameter_getval(m->parameter, "x-mutt-action"))
+ || (p = parameter_getval(m->parameter, "x-action"))
+ || (p = parameter_getval(m->parameter, "action")))
&& !ascii_strncasecmp ("pgp-sign", p, 8))
t |= PGPSIGN;
else if (p && !ascii_strncasecmp ("pgp-encrypt", p, 11))
&& !ascii_strncasecmp ("pgp-sign", p, 8))
t |= PGPSIGN;
else if (p && !ascii_strncasecmp ("pgp-encrypt", p, 11))
/* S/MIME MIME types don't need x- anymore, see RFC2311 */
if (!ascii_strcasecmp (m->subtype, "x-pkcs7-mime") ||
!ascii_strcasecmp (m->subtype, "pkcs7-mime")) {
/* S/MIME MIME types don't need x- anymore, see RFC2311 */
if (!ascii_strcasecmp (m->subtype, "x-pkcs7-mime") ||
!ascii_strcasecmp (m->subtype, "pkcs7-mime")) {
- if ((t = mutt_get_parameter ("smime-type", m->parameter))) {
+ if ((t = parameter_getval(m->parameter, "smime-type"))) {
if (!ascii_strcasecmp (t, "enveloped-data"))
return SMIMEENCRYPT;
else if (!ascii_strcasecmp (t, "signed-data"))
if (!ascii_strcasecmp (t, "enveloped-data"))
return SMIMEENCRYPT;
else if (!ascii_strcasecmp (t, "signed-data"))
else if (ascii_strcasecmp (m->subtype, "octet-stream"))
return 0;
else if (ascii_strcasecmp (m->subtype, "octet-stream"))
return 0;
- t = mutt_get_parameter ("name", m->parameter);
+ t = parameter_getval(m->parameter, "name");
if (!t)
t = m->d_filename;
if (!t)
t = m->d_filename;
short goodsig = 1;
int rc = 0;
short goodsig = 1;
int rc = 0;
- protocol = mutt_get_parameter ("protocol", a->parameter);
+ protocol = parameter_getval(a->parameter, "protocol");
a = a->parts;
/* extract the protocol information */
a = a->parts;
/* extract the protocol information */
DO_DELETE(PARAMETER, parameter);
DO_SLIST(PARAMETER, parameter, parameter_delete);
DO_DELETE(PARAMETER, parameter);
DO_SLIST(PARAMETER, parameter, parameter_delete);
+char *parameter_getval(PARAMETER *, const char *);
/****************************************************************************/
/* rfc822 envelopes */
/****************************************************************************/
/* rfc822 envelopes */
+/****************************************************************************/
+/* rfc822 header parameters */
+/****************************************************************************/
+
+char *parameter_getval(PARAMETER *parm, const char *s)
+{
+ while (parm) {
+ if (!ascii_strcasecmp(parm->attribute, s))
+ return parm->value;
+ parm = parm->next;
+ }
+ return NULL;
+}
+
+/****************************************************************************/
+/* XXX */
+/****************************************************************************/
+
void rfc1524_entry_wipe(rfc1524_entry *p)
{
p_delete(&p->command);
void rfc1524_entry_wipe(rfc1524_entry *p)
{
p_delete(&p->command);
param[z] = '\0';
m_strcpy(pval, sizeof(pval),
param[z] = '\0';
m_strcpy(pval, sizeof(pval),
- mutt_get_parameter(param, a->parameter));
+ parameter_getval(a->parameter, param));
if (option(OPTMAILCAPSANITIZE))
mutt_sanitize_filename(pval, 0);
if (option(OPTMAILCAPSANITIZE))
mutt_sanitize_filename(pval, 0);
*curline='\0';
/* respect DelSP of RfC3676 only with f=f parts */
*curline='\0';
/* respect DelSP of RfC3676 only with f=f parts */
- if ((t = (char*) mutt_get_parameter ("delsp", a->parameter))) {
+ if ((t = parameter_getval(a->parameter, "delsp"))) {
delsp = m_strlen(t) == 3 && ascii_strncasecmp (t, "yes", 3) == 0;
t = NULL;
}
delsp = m_strlen(t) == 3 && ascii_strncasecmp (t, "yes", 3) == 0;
t = NULL;
}
/* Some pre-RFC1521 gateways still use the "name=filename" convention,
* but if a filename has already been set in the content-disposition,
* let that take precedence, and don't set it here */
/* Some pre-RFC1521 gateways still use the "name=filename" convention,
* but if a filename has already been set in the content-disposition,
* let that take precedence, and don't set it here */
- pc = mutt_get_parameter("name", ct->parameter);
+ pc = parameter_getval(ct->parameter, "name");
if (pc && !ct->filename)
ct->filename = m_strdup(pc);
}
if (pc && !ct->filename)
ct->filename = m_strdup(pc);
}
/* Default character set for text types. */
if (ct->type == TYPETEXT) {
/* Default character set for text types. */
if (ct->type == TYPETEXT) {
- pc = mutt_get_parameter("charset", ct->parameter);
+ pc = parameter_getval(ct->parameter, "charset");
if (!pc) {
mutt_set_parameter("charset",
option(OPTSTRICTMIME) ? "us-ascii" :
if (!pc) {
mutt_set_parameter("charset",
option(OPTSTRICTMIME) ? "us-ascii" :
-static void parse_content_disposition(char *s, BODY *ct)
+static void parse_content_disposition(const char *s, BODY *ct)
{
if (!ascii_strncasecmp(s, "inline", 6)) {
ct->disposition = DISPINLINE;
{
if (!ascii_strncasecmp(s, "inline", 6)) {
ct->disposition = DISPINLINE;
if ((s = strchr (s, ';'))) {
PARAMETER *parms = parse_parameters(vskipspaces(s));
if ((s = strchr (s, ';'))) {
PARAMETER *parms = parse_parameters(vskipspaces(s));
- if ((s = mutt_get_parameter("filename", parms)))
+ if ((s = parameter_getval(parms, "filename")))
m_strreplace(&ct->filename, s);
m_strreplace(&ct->filename, s);
- if ((s = mutt_get_parameter ("name", parms)))
+ if ((s = parameter_getval(parms, "name")))
ct->form_name = m_strdup(s);
parameter_list_wipe(&parms);
ct->form_name = m_strdup(s);
parameter_list_wipe(&parms);
switch (b->type) {
case TYPEMULTIPART:
switch (b->type) {
case TYPEMULTIPART:
- bound = mutt_get_parameter("boundary", b->parameter);
+ bound = parameter_getval(b->parameter, "boundary");
fseeko(fp, b->offset, SEEK_SET);
b->parts = mutt_parse_multipart(fp, bound, b->offset + b->length,
mime_which_token(b->subtype, -1) == MIME_DIGEST);
fseeko(fp, b->offset, SEEK_SET);
b->parts = mutt_parse_multipart(fp, bound, b->offset + b->length,
mime_which_token(b->subtype, -1) == MIME_DIGEST);
-char *mutt_get_parameter (const char *s, PARAMETER * p)
-{
- while (p) {
- if (!ascii_strcasecmp(s, p->attribute))
- return (p->value);
- p = p->next;
- }
-
- return NULL;
-}
-
void mutt_set_parameter (const char *attribute, const char *value,
PARAMETER ** p)
{
void mutt_set_parameter (const char *attribute, const char *value,
PARAMETER ** p)
{
if (mutt_is_multipart_signed (newhdr->content)) {
newhdr->security |= SIGN;
if (mutt_is_multipart_signed (newhdr->content)) {
newhdr->security |= SIGN;
- if (ascii_strcasecmp (mutt_get_parameter
- ("protocol", newhdr->content->parameter),
- "application/pgp-signature") == 0)
+ if (ascii_strcasecmp(parameter_getval(newhdr->content->parameter, "protocol"),
+ "application/pgp-signature") == 0)
newhdr->security |= APPLICATION_PGP;
else
newhdr->security |= APPLICATION_SMIME;
newhdr->security |= APPLICATION_PGP;
else
newhdr->security |= APPLICATION_SMIME;
if (b->type == TYPETEXT) {
if (!ascii_strcasecmp
if (b->type == TYPETEXT) {
if (!ascii_strcasecmp
- ("yes", mutt_get_parameter ("x-mutt-noconv", b->parameter)))
+ ("yes", parameter_getval(b->parameter, "x-mutt-noconv")))
b->noconv = 1;
else {
s.flags |= M_CHARCONV;
b->noconv = 1;
else {
s.flags |= M_CHARCONV;
char *mutt_gen_msgid (void);
char *mutt_get_body_charset (char *, ssize_t, BODY *);
const char *mutt_get_name (address_t *);
char *mutt_gen_msgid (void);
char *mutt_get_body_charset (char *, ssize_t, BODY *);
const char *mutt_get_name (address_t *);
-char *mutt_get_parameter (const char *, PARAMETER *);
const char *mutt_crypt_hook (address_t *);
char *mutt_make_date (char *, ssize_t);
const char *mutt_crypt_hook (address_t *);
char *mutt_make_date (char *, ssize_t);
int mutt_write_mime_body (BODY * a, FILE * f)
{
int mutt_write_mime_body (BODY * a, FILE * f)
{
- char *p, boundary[SHORT_STRING];
+ const char *p;
+ char boundary[SHORT_STRING];
char send_charset[SHORT_STRING];
FILE *fpin;
BODY *t;
char send_charset[SHORT_STRING];
FILE *fpin;
BODY *t;
if (a->type == TYPEMULTIPART) {
/* First, find the boundary to use */
if (a->type == TYPEMULTIPART) {
/* First, find the boundary to use */
- if (!(p = mutt_get_parameter ("boundary", a->parameter))) {
+ if (!(p = parameter_getval(a->parameter, "boundary"))) {
mutt_error _("No boundary parameter found! [report this error]");
return (-1);
mutt_error _("No boundary parameter found! [report this error]");
return (-1);
p_clear(&state, 1);
if (b != NULL && b->type == TYPETEXT && (!b->noconv && !b->force_charset)) {
p_clear(&state, 1);
if (b != NULL && b->type == TYPETEXT && (!b->noconv && !b->force_charset)) {
- char *chs = mutt_get_parameter ("charset", b->parameter);
+ const char *chs = parameter_getval(b->parameter, "charset");
char *fchs = b->use_disp ? ((FileCharset && *FileCharset) ?
FileCharset : Charset) : Charset;
if (Charset && (chs || SendCharset) &&
char *fchs = b->use_disp ? ((FileCharset && *FileCharset) ?
FileCharset : Charset) : Charset;
if (Charset && (chs || SendCharset) &&
char *mutt_get_body_charset (char *d, ssize_t dlen, BODY * b)
{
char *mutt_get_body_charset (char *d, ssize_t dlen, BODY * b)
{
if (b && b->type != TYPETEXT)
return NULL;
if (b)
if (b && b->type != TYPETEXT)
return NULL;
if (b)
- p = mutt_get_parameter ("charset", b->parameter);
+ p = parameter_getval(b->parameter, "charset");
- charset_canonicalize (d, dlen, NONULL (p));
+ charset_canonicalize (d, dlen, p);
else
m_strcpy(d, dlen, "us-ascii");
else
m_strcpy(d, dlen, "us-ascii");