standardise the parameter functions

diff --git a/attach.c b/attach.c
index 3dadba516c1f5e9aeaa275df1e70b15383a80c61..97ab4b77f4309ce56f779f3e3373f7fb82be52a3 100644 (file)
--- a/attach.c
+++ b/attach.c
@@ -159,7 +159,7 @@ int mutt_compose_attachment(struct Body *a)
           {
             if (b->parameter)
             {
-              mutt_free_parameter(&a->parameter);
+              mutt_param_free(&a->parameter);
               a->parameter = b->parameter;
               b->parameter = NULL;
             }

diff --git a/body.c b/body.c
index 4b621b0ee671c1455e0bd29c9fbb7fcdf286dea1..303dbfbb5f05f9feb525234b56bd02938c8f4b92 100644 (file)
--- a/body.c
+++ b/body.c
@@ -127,7 +127,7 @@ void mutt_free_body(struct Body **p)
     a = a->next;
 
     if (b->parameter)
-      mutt_free_parameter(&b->parameter);
+      mutt_param_free(&b->parameter);
     if (b->filename)
     {
       if (b->unlink)

diff --git a/commands.c b/commands.c
index 70fc1860c3a4df957225f92168d755a33c23c2bd..b70fcc5c8a1f3735b917ce7bfc53efbe5171a68b 100644 (file)
--- a/commands.c
+++ b/commands.c
@@ -973,7 +973,7 @@ int mutt_edit_content_type(struct Header *h, struct Body *b, FILE *fp)
   short type_changed = 0;
   short structure_changed = 0;
 
-  cp = mutt_get_parameter("charset", b->parameter);
+  cp = mutt_param_get("charset", b->parameter);
   mutt_str_strfcpy(charset, NONULL(cp), sizeof(charset));
 
   snprintf(buf, sizeof(buf), "%s/%s", TYPE(b), b->subtype);
@@ -995,15 +995,14 @@ int mutt_edit_content_type(struct Header *h, struct Body *b, FILE *fp)
     return 0;
 
   /* clean up previous junk */
-  mutt_free_parameter(&b->parameter);
+  mutt_param_free(&b->parameter);
   FREE(&b->subtype);
 
   mutt_parse_content_type(buf, b);
 
   snprintf(tmp, sizeof(tmp), "%s/%s", TYPE(b), NONULL(b->subtype));
   type_changed = mutt_str_strcasecmp(tmp, obuf);
-  charset_changed =
-      mutt_str_strcasecmp(charset, mutt_get_parameter("charset", b->parameter));
+  charset_changed = mutt_str_strcasecmp(charset, mutt_param_get("charset", b->parameter));
 
   /* if in send mode, check for conversion - current setting is default. */
 
@@ -1011,7 +1010,7 @@ int mutt_edit_content_type(struct Header *h, struct Body *b, FILE *fp)
   {
     int r;
     snprintf(tmp, sizeof(tmp), _("Convert to %s upon sending?"),
-             mutt_get_parameter("charset", b->parameter));
+             mutt_param_get("charset", b->parameter));
     r = mutt_yesorno(tmp, !b->noconv);
     if (r != MUTT_ABORT)
       b->noconv = (r == MUTT_NO);
@@ -1027,7 +1026,7 @@ int mutt_edit_content_type(struct Header *h, struct Body *b, FILE *fp)
     if (type_changed)
       mutt_sleep(1);
     mutt_message(_("Character set changed to %s; %s."),
-                 mutt_get_parameter("charset", b->parameter),
+                 mutt_param_get("charset", b->parameter),
                  b->noconv ? _("not converting") : _("converting"));
   }
 

diff --git a/handler.c b/handler.c
index eae529880773029dd49c060fb4ffb6a6afa51c98..be410a6573fc5077c83324d4d06bf76b1a120eec 100644 (file)
--- a/handler.c
+++ b/handler.c
@@ -79,7 +79,7 @@ static void print_part_line(struct State *s, struct Body *b, int n)
   char length[5];
   mutt_pretty_size(length, sizeof(length), b->length);
   state_mark_attach(s);
-  char *charset = mutt_get_parameter("charset", b->parameter);
+  char *charset = mutt_param_get("charset", b->parameter);
   if (n != 0)
     state_printf(s, _("[-- Alternative Type #%d: "), n);
   else
@@ -1041,8 +1041,8 @@ static int alternative_handler(struct Body *a, struct State *s)
     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, (mutt_str_strcasecmp("digest", a->subtype) == 0));
+        s->fpin, mutt_param_get("boundary", a->parameter), (long) st.st_size,
+        (mutt_str_strcasecmp("digest", a->subtype) == 0));
   }
   else
     b = a;
@@ -1303,8 +1303,8 @@ static int multipart_handler(struct Body *a, struct State *s)
     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, (mutt_str_strcasecmp("digest", a->subtype) == 0));
+        s->fpin, mutt_param_get("boundary", a->parameter), (long) st.st_size,
+        (mutt_str_strcasecmp("digest", a->subtype) == 0));
   }
   else
     b = a;
@@ -1495,7 +1495,7 @@ static int external_body_handler(struct Body *b, struct State *s)
   const char *expiration = NULL;
   time_t expire;
 
-  access_type = mutt_get_parameter("access-type", b->parameter);
+  access_type = mutt_param_get("access-type", b->parameter);
   if (!access_type)
   {
     if (s->flags & MUTT_DISPLAY)
@@ -1510,7 +1510,7 @@ static int external_body_handler(struct Body *b, struct State *s)
       return -1;
   }
 
-  expiration = mutt_get_parameter("expiration", b->parameter);
+  expiration = mutt_param_get("expiration", b->parameter);
   if (expiration)
     expire = mutt_date_parse_date(expiration, NULL);
   else
@@ -1525,7 +1525,7 @@ static int external_body_handler(struct Body *b, struct State *s)
 
       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 = mutt_param_get("length", b->parameter);
       if (length)
       {
         mutt_pretty_size(pretty_size, sizeof(pretty_size), strtol(length, NULL, 10));
@@ -1590,7 +1590,7 @@ void mutt_decode_attachment(struct Body *b, struct State *s)
 
   if (istext && s->flags & MUTT_CHARCONV)
   {
-    char *charset = mutt_get_parameter("charset", b->parameter);
+    char *charset = mutt_param_get("charset", b->parameter);
     if (!charset && AssumedCharset && *AssumedCharset)
       charset = mutt_get_default_charset();
     if (charset && Charset)
@@ -1851,7 +1851,7 @@ int mutt_body_handler(struct Body *b, struct State *s)
       if ((WithCrypto & APPLICATION_PGP) && mutt_is_application_pgp(b))
         handler = crypt_pgp_application_pgp_handler;
       else if (option(OPT_REFLOW_TEXT) &&
-               (mutt_str_strcasecmp("flowed", mutt_get_parameter("format", b->parameter)) == 0))
+               (mutt_str_strcasecmp("flowed", mutt_param_get("format", b->parameter)) == 0))
       {
         handler = rfc3676_handler;
       }
@@ -1885,7 +1885,7 @@ int mutt_body_handler(struct Body *b, struct State *s)
     }
     else if (WithCrypto && (mutt_str_strcasecmp("signed", b->subtype) == 0))
     {
-      p = mutt_get_parameter("protocol", b->parameter);
+      p = mutt_param_get("protocol", b->parameter);
 
       if (!p)
         mutt_error(_("Error: multipart/signed has no protocol."));

diff --git a/ncrypt/crypt.c b/ncrypt/crypt.c
index 01db5753adad681f463eab4317f0385a6c1f431b..43735dd8bb18a8344064a75ab0c3b677c9445838 100644 (file)
--- a/ncrypt/crypt.c
+++ b/ncrypt/crypt.c
@@ -159,8 +159,8 @@ int mutt_protect(struct Header *msg, char *keylist)
         return -1;
       }
     }
-    else if (!mutt_str_strcasecmp(
-                 "flowed", mutt_get_parameter("format", msg->content->parameter)))
+    else if (!mutt_str_strcasecmp("flowed",
+                                  mutt_param_get("format", msg->content->parameter)))
     {
       if ((query_quadoption(OPT_PGP_MIME_AUTO,
                             _("Inline PGP can't be used with format=flowed.  "
@@ -320,7 +320,7 @@ int mutt_is_multipart_signed(struct Body *b)
     return 0;
   }
 
-  p = mutt_get_parameter("protocol", b->parameter);
+  p = mutt_param_get("protocol", b->parameter);
   if (!p)
     return 0;
 
@@ -355,7 +355,7 @@ int mutt_is_multipart_encrypted(struct Body *b)
 
     if (!b || b->type != TYPEMULTIPART || !b->subtype ||
         (mutt_str_strcasecmp(b->subtype, "encrypted") != 0) ||
-        !(p = mutt_get_parameter("protocol", b->parameter)) ||
+        !(p = mutt_param_get("protocol", b->parameter)) ||
         (mutt_str_strcasecmp(p, "application/pgp-encrypted") != 0))
       return 0;
 
@@ -449,12 +449,12 @@ int mutt_is_application_pgp(struct Body *m)
     if ((mutt_str_strcasecmp(m->subtype, "pgp") == 0) ||
         (mutt_str_strcasecmp(m->subtype, "x-pgp-message") == 0))
     {
-      if ((p = mutt_get_parameter("x-action", m->parameter)) &&
+      if ((p = mutt_param_get("x-action", m->parameter)) &&
           ((mutt_str_strcasecmp(p, "sign") == 0) ||
            (mutt_str_strcasecmp(p, "signclear") == 0)))
         t |= PGPSIGN;
 
-      if ((p = mutt_get_parameter("format", m->parameter)) &&
+      if ((p = mutt_param_get("format", m->parameter)) &&
           (mutt_str_strcasecmp(p, "keys-only") == 0))
       {
         t |= PGPKEY;
@@ -472,9 +472,9 @@ int mutt_is_application_pgp(struct Body *m)
   }
   else if (m->type == TYPETEXT && (mutt_str_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 = mutt_param_get("x-mutt-action", m->parameter)) ||
+         (p = mutt_param_get("x-action", m->parameter)) ||
+         (p = mutt_param_get("action", m->parameter))) &&
         (mutt_str_strncasecmp("pgp-sign", p, 8) == 0))
       t |= PGPSIGN;
     else if (p && (mutt_str_strncasecmp("pgp-encrypt", p, 11) == 0))
@@ -503,7 +503,7 @@ int mutt_is_application_smime(struct Body *m)
     if ((mutt_str_strcasecmp(m->subtype, "x-pkcs7-mime") == 0) ||
         (mutt_str_strcasecmp(m->subtype, "pkcs7-mime") == 0))
     {
-      if ((t = mutt_get_parameter("smime-type", m->parameter)))
+      if ((t = mutt_param_get("smime-type", m->parameter)))
       {
         if (mutt_str_strcasecmp(t, "enveloped-data") == 0)
           return SMIMEENCRYPT;
@@ -523,7 +523,7 @@ int mutt_is_application_smime(struct Body *m)
     else if (mutt_str_strcasecmp(m->subtype, "octet-stream") != 0)
       return 0;
 
-    t = mutt_get_parameter("name", m->parameter);
+    t = mutt_param_get("name", m->parameter);
 
     if (!t)
       t = m->d_filename;
@@ -974,7 +974,7 @@ int mutt_signed_handler(struct Body *a, struct State *s)
     /* A null protocol value is already checked for in mutt_body_handler() */
     state_printf(s, _("[-- Error: "
                       "Unknown multipart/signed protocol %s! --]\n\n"),
-                 mutt_get_parameter("protocol", b->parameter));
+                 mutt_param_get("protocol", b->parameter));
     return mutt_body_handler(a, s);
   }
 

diff --git a/ncrypt/crypt_gpgme.c b/ncrypt/crypt_gpgme.c
index e58c5c78d5de173d0e464867f0fc8cd1987100e8..5a1cfa2f81c4be33480b0a0291424c59a653cd92 100644 (file)
--- a/ncrypt/crypt_gpgme.c
+++ b/ncrypt/crypt_gpgme.c
@@ -1061,16 +1061,16 @@ static struct Body *sign_message(struct Body *a, int use_smime)
   t->disposition = DISPINLINE;
 
   mutt_generate_boundary(&t->parameter);
-  mutt_set_parameter("protocol",
-                     use_smime ? "application/pkcs7-signature" :
-                                 "application/pgp-signature",
-                     &t->parameter);
+  mutt_param_set("protocol",
+                 use_smime ? "application/pkcs7-signature" :
+                             "application/pgp-signature",
+                 &t->parameter);
   /* Get the micalg from gpgme.  Old gpgme versions don't support this
      for S/MIME so we assume sha-1 in this case. */
   if (!get_micalg(ctx, use_smime, buf, sizeof(buf)))
-    mutt_set_parameter("micalg", buf, &t->parameter);
+    mutt_param_set("micalg", buf, &t->parameter);
   else if (use_smime)
-    mutt_set_parameter("micalg", "sha1", &t->parameter);
+    mutt_param_set("micalg", "sha1", &t->parameter);
   gpgme_release(ctx);
 
   t->parts = a;
@@ -1082,7 +1082,7 @@ static struct Body *sign_message(struct Body *a, int use_smime)
   if (use_smime)
   {
     t->subtype = mutt_str_strdup("pkcs7-signature");
-    mutt_set_parameter("name", "smime.p7s", &t->parameter);
+    mutt_param_set("name", "smime.p7s", &t->parameter);
     t->encoding = ENCBASE64;
     t->use_disp = true;
     t->disposition = DISPATTACH;
@@ -1091,7 +1091,7 @@ static struct Body *sign_message(struct Body *a, int use_smime)
   else
   {
     t->subtype = mutt_str_strdup("pgp-signature");
-    mutt_set_parameter("name", "signature.asc", &t->parameter);
+    mutt_param_set("name", "signature.asc", &t->parameter);
     t->use_disp = false;
     t->disposition = DISPNONE;
     t->encoding = ENC7BIT;
@@ -1156,7 +1156,7 @@ struct Body *pgp_gpgme_encrypt_message(struct Body *a, char *keylist, int sign)
   t->disposition = DISPINLINE;
 
   mutt_generate_boundary(&t->parameter);
-  mutt_set_parameter("protocol", "application/pgp-encrypted", &t->parameter);
+  mutt_param_set("protocol", "application/pgp-encrypted", &t->parameter);
 
   t->parts = mutt_new_body();
   t->parts->type = TYPEAPPLICATION;
@@ -1218,8 +1218,8 @@ struct Body *smime_gpgme_build_smime_entity(struct Body *a, char *keylist)
   t = mutt_new_body();
   t->type = TYPEAPPLICATION;
   t->subtype = mutt_str_strdup("pkcs7-mime");
-  mutt_set_parameter("name", "smime.p7m", &t->parameter);
-  mutt_set_parameter("smime-type", "enveloped-data", &t->parameter);
+  mutt_param_set("name", "smime.p7m", &t->parameter);
+  mutt_param_set("smime-type", "enveloped-data", &t->parameter);
   t->encoding = ENCBASE64; /* The output of OpenSSL SHOULD be binary */
   t->use_disp = true;
   t->disposition = DISPATTACH;
@@ -2354,8 +2354,8 @@ static int pgp_check_traditional_one_body(FILE *fp, struct Body *b)
 
   /* fix the content type */
 
-  mutt_set_parameter("format", "fixed", &b->parameter);
-  mutt_set_parameter("x-action", enc ? "pgp-encrypted" : "pgp-signed", &b->parameter);
+  mutt_param_set("format", "fixed", &b->parameter);
+  mutt_param_set("x-action", enc ? "pgp-encrypted" : "pgp-signed", &b->parameter);
 
   return 1;
 }

diff --git a/ncrypt/pgp.c b/ncrypt/pgp.c
index 6af127700c04957b2bd0ca16fb49b3dca958736c..f7a1ca83fd34fc682dd319998117bc1479fb3ed9 100644 (file)
--- a/ncrypt/pgp.c
+++ b/ncrypt/pgp.c
@@ -668,13 +668,13 @@ static int pgp_check_traditional_one_body(FILE *fp, struct Body *b)
 
   /* fix the content type */
 
-  mutt_set_parameter("format", "fixed", &b->parameter);
+  mutt_param_set("format", "fixed", &b->parameter);
   if (enc)
-    mutt_set_parameter("x-action", "pgp-encrypted", &b->parameter);
+    mutt_param_set("x-action", "pgp-encrypted", &b->parameter);
   else if (sgn)
-    mutt_set_parameter("x-action", "pgp-signed", &b->parameter);
+    mutt_param_set("x-action", "pgp-signed", &b->parameter);
   else if (key)
-    mutt_set_parameter("x-action", "pgp-keys", &b->parameter);
+    mutt_param_set("x-action", "pgp-keys", &b->parameter);
 
   return 1;
 }
@@ -1209,8 +1209,8 @@ struct Body *pgp_sign_message(struct Body *a)
   t->disposition = DISPINLINE;
 
   mutt_generate_boundary(&t->parameter);
-  mutt_set_parameter("protocol", "application/pgp-signature", &t->parameter);
-  mutt_set_parameter("micalg", pgp_micalg(sigfile), &t->parameter);
+  mutt_param_set("protocol", "application/pgp-signature", &t->parameter);
+  mutt_param_set("micalg", pgp_micalg(sigfile), &t->parameter);
 
   t->parts = a;
   a = t;
@@ -1224,7 +1224,7 @@ struct Body *pgp_sign_message(struct Body *a)
   t->disposition = DISPNONE;
   t->encoding = ENC7BIT;
   t->unlink = true; /* ok to remove this file after sending. */
-  mutt_set_parameter("name", "signature.asc", &t->parameter);
+  mutt_param_set("name", "signature.asc", &t->parameter);
 
   return a;
 }
@@ -1464,7 +1464,7 @@ struct Body *pgp_encrypt_message(struct Body *a, char *keylist, int sign)
   t->disposition = DISPINLINE;
 
   mutt_generate_boundary(&t->parameter);
-  mutt_set_parameter("protocol", "application/pgp-encrypted", &t->parameter);
+  mutt_param_set("protocol", "application/pgp-encrypted", &t->parameter);
 
   t->parts = mutt_new_body();
   t->parts->type = TYPEAPPLICATION;
@@ -1641,9 +1641,8 @@ struct Body *pgp_traditional_encryptsign(struct Body *a, int flags, char *keylis
   b->type = TYPETEXT;
   b->subtype = mutt_str_strdup("plain");
 
-  mutt_set_parameter("x-action",
-                     flags & ENCRYPT ? "pgp-encrypted" : "pgp-signed", &b->parameter);
-  mutt_set_parameter("charset", send_charset, &b->parameter);
+  mutt_param_set("x-action", flags & ENCRYPT ? "pgp-encrypted" : "pgp-signed", &b->parameter);
+  mutt_param_set("charset", send_charset, &b->parameter);
 
   b->filename = mutt_str_strdup(pgpoutfile);
 

diff --git a/ncrypt/smime.c b/ncrypt/smime.c
index fe488c4f220a65d11bbc55a4d4ea9b90eb5794c3..9e9ad3ce3ac11ea762a9836fab4240a7a4495e2f 100644 (file)
--- a/ncrypt/smime.c
+++ b/ncrypt/smime.c
@@ -1434,8 +1434,8 @@ struct Body *smime_build_smime_entity(struct Body *a, char *certlist)
   t = mutt_new_body();
   t->type = TYPEAPPLICATION;
   t->subtype = mutt_str_strdup("x-pkcs7-mime");
-  mutt_set_parameter("name", "smime.p7m", &t->parameter);
-  mutt_set_parameter("smime-type", "enveloped-data", &t->parameter);
+  mutt_param_set("name", "smime.p7m", &t->parameter);
+  mutt_param_set("smime-type", "enveloped-data", &t->parameter);
   t->encoding = ENCBASE64; /* The output of OpenSSL SHOULD be binary */
   t->use_disp = true;
   t->disposition = DISPATTACH;
@@ -1591,10 +1591,10 @@ struct Body *smime_sign_message(struct Body *a)
   mutt_generate_boundary(&t->parameter);
 
   micalg = openssl_md_to_smime_micalg(SmimeSignDigestAlg);
-  mutt_set_parameter("micalg", micalg, &t->parameter);
+  mutt_param_set("micalg", micalg, &t->parameter);
   FREE(&micalg);
 
-  mutt_set_parameter("protocol", "application/x-pkcs7-signature", &t->parameter);
+  mutt_param_set("protocol", "application/x-pkcs7-signature", &t->parameter);
 
   t->parts = a;
   a = t;

diff --git a/parameter.c b/parameter.c
index 8cc5143417053009f3fbb411abd2c2b121437764..c8411a65b123ba6448b7198b0671c32abf15ba7e 100644 (file)
--- a/parameter.c
+++ b/parameter.c
@@ -27,20 +27,20 @@
  *
  * | Function                     | Description
  * | :--------------------------- | :---------------------------------------------------------
- * | mutt_delete_parameter()      | Delete a matching Parameter
- * | mutt_free_parameter()        | Free a Parameter
- * | mutt_get_parameter()         | Find a matching Parameter
- * | mutt_set_parameter()         | Set a Parameter
+ * | mutt_param_delete()      | Delete a matching Parameter
+ * | mutt_param_free()        | Free a Parameter
+ * | mutt_param_get()         | Find a matching Parameter
+ * | mutt_param_set()         | Set a Parameter
  */
 
 #include "config.h"
 #include "parameter.h"
 
 /**
- * mutt_free_parameter - Free a Parameter
+ * mutt_param_free - Free a Parameter
  * @param p Parameter to free
  */
-void mutt_free_parameter(struct Parameter **p)
+void mutt_param_free(struct Parameter **p)
 {
   struct Parameter *t = *p;
   struct Parameter *o = NULL;
@@ -57,13 +57,13 @@ void mutt_free_parameter(struct Parameter **p)
 }
 
 /**
- * mutt_get_parameter - Find a matching Parameter
+ * mutt_param_get - Find a matching Parameter
  * @param s String to match
  * @param p Parameter list
  * @retval ptr Matching Parameter
  * @retval NULL No match
  */
-char *mutt_get_parameter(const char *s, struct Parameter *p)
+char *mutt_param_get(const char *s, struct Parameter *p)
 {
   for (; p; p = p->next)
     if (mutt_str_strcasecmp(s, p->attribute) == 0)
@@ -73,7 +73,7 @@ char *mutt_get_parameter(const char *s, struct Parameter *p)
 }
 
 /**
- * mutt_set_parameter - Set a Parameter
+ * mutt_param_set - Set a Parameter
  * @param[in]  attribute Attribute to match
  * @param[in]  value     Value to set
  * @param[out] p         Parameter that was set
@@ -83,13 +83,13 @@ char *mutt_get_parameter(const char *s, struct Parameter *p)
  * @note If a matching Parameter isn't found a new one will be allocated.
  *       The new Parameter will be inserted at the front of the list.
  */
-void mutt_set_parameter(const char *attribute, const char *value, struct Parameter **p)
+void mutt_param_set(const char *attribute, const char *value, struct Parameter **p)
 {
   struct Parameter *q = NULL;
 
   if (!value)
   {
-    mutt_delete_parameter(attribute, p);
+    mutt_param_delete(attribute, p);
     return;
   }
 
@@ -110,11 +110,11 @@ void mutt_set_parameter(const char *attribute, const char *value, struct Paramet
 }
 
 /**
- * mutt_delete_parameter - Delete a matching Parameter
+ * mutt_param_delete - Delete a matching Parameter
  * @param[in]  attribute Attribute to match
  * @param[out] p         Parameter after the deleted Parameter
  */
-void mutt_delete_parameter(const char *attribute, struct Parameter **p)
+void mutt_param_delete(const char *attribute, struct Parameter **p)
 {
   for (struct Parameter *q = *p; q; p = &q->next, q = q->next)
   {
@@ -122,7 +122,7 @@ void mutt_delete_parameter(const char *attribute, struct Parameter **p)
     {
       *p = q->next;
       q->next = NULL;
-      mutt_free_parameter(&q);
+      mutt_param_free(&q);
       return;
     }
   }

diff --git a/parameter.h b/parameter.h
index c7f54e7020da59fe7c387cb2c5975c9c8b7ad07f..49486e247413a4b2ebf57a13009f65988872e033 100644 (file)
--- a/parameter.h
+++ b/parameter.h
@@ -44,9 +44,9 @@ static inline struct Parameter *mutt_new_parameter(void)
   return mutt_mem_calloc(1, sizeof(struct Parameter));
 }
 
-void mutt_delete_parameter(const char *attribute, struct Parameter **p);
-void mutt_set_parameter(const char *attribute, const char *value, struct Parameter **p);
-void mutt_free_parameter(struct Parameter **p);
-char *mutt_get_parameter(const char *s, struct Parameter *p);
+void mutt_param_delete(const char *attribute, struct Parameter **p);
+void mutt_param_set(const char *attribute, const char *value, struct Parameter **p);
+void mutt_param_free(struct Parameter **p);
+char *mutt_param_get(const char *s, struct Parameter *p);
 
 #endif /* _MUTT_PARAMETER_H */

diff --git a/parse.c b/parse.c
index f77195ba23a039d6eb532a95c32419f0872e8ec3..6b7b5dcbe12258007b4efd0f6a75c094c3fdfdd5 100644 (file)
--- a/parse.c
+++ b/parse.c
@@ -311,7 +311,7 @@ void mutt_parse_content_type(char *s, struct Body *ct)
   char *subtype = NULL;
 
   FREE(&ct->subtype);
-  mutt_free_parameter(&ct->parameter);
+  mutt_param_free(&ct->parameter);
 
   /* First extract any existing parameters */
   pc = strchr(s, ';');
@@ -325,12 +325,12 @@ void mutt_parse_content_type(char *s, struct Body *ct)
     /* 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 */
-    if ((pc = mutt_get_parameter("name", ct->parameter)) && !ct->filename)
+    if ((pc = mutt_param_get("name", ct->parameter)) && !ct->filename)
       ct->filename = mutt_str_strdup(pc);
 
 #ifdef SUN_ATTACHMENT
     /* this is deep and utter perversion */
-    if ((pc = mutt_get_parameter("conversions", ct->parameter)))
+    if ((pc = mutt_param_get("conversions", ct->parameter)))
       ct->encoding = mutt_check_encoding(pc);
 #endif
   }
@@ -384,13 +384,13 @@ void mutt_parse_content_type(char *s, struct Body *ct)
   /* Default character set for text types. */
   if (ct->type == TYPETEXT)
   {
-    pc = mutt_get_parameter("charset", ct->parameter);
+    pc = mutt_param_get("charset", ct->parameter);
     if (!pc)
-      mutt_set_parameter("charset",
-                         (AssumedCharset && *AssumedCharset) ?
-                             (const char *) mutt_get_default_charset() :
-                             "us-ascii",
-                         &ct->parameter);
+      mutt_param_set("charset",
+                     (AssumedCharset && *AssumedCharset) ?
+                         (const char *) mutt_get_default_charset() :
+                         "us-ascii",
+                     &ct->parameter);
   }
 }
 
@@ -410,11 +410,11 @@ static void parse_content_disposition(const char *s, struct Body *ct)
   if (s)
   {
     s = mutt_str_skip_email_wsp(s + 1);
-    if ((s = mutt_get_parameter("filename", (parms = parse_parameters(s)))))
+    if ((s = mutt_param_get("filename", (parms = parse_parameters(s)))))
       mutt_str_replace(&ct->filename, s);
-    if ((s = mutt_get_parameter("name", parms)))
+    if ((s = mutt_param_get("name", parms)))
       ct->form_name = mutt_str_strdup(s);
-    mutt_free_parameter(&parms);
+    mutt_param_free(&parms);
   }
 }
 
@@ -477,7 +477,7 @@ struct Body *mutt_read_mime_header(FILE *fp, int digest)
       else if (mutt_str_strcasecmp("encoding-info", line + 6) == 0)
         p->encoding = mutt_check_encoding(c);
       else if (mutt_str_strcasecmp("content-lines", line + 6) == 0)
-        mutt_set_parameter("content-lines", c, &(p->parameter));
+        mutt_param_set("content-lines", c, &(p->parameter));
       else if (mutt_str_strcasecmp("data-description", line + 6) == 0)
       {
         mutt_str_replace(&p->description, c);
@@ -509,7 +509,7 @@ void mutt_parse_part(FILE *fp, struct Body *b)
         bound = "--------";
       else
 #endif
-        bound = mutt_get_parameter("boundary", b->parameter);
+        bound = mutt_param_get("boundary", b->parameter);
 
       fseeko(fp, b->offset, SEEK_SET);
       b->parts = mutt_parse_multipart(fp, bound, b->offset + b->length,
@@ -630,9 +630,9 @@ struct Body *mutt_parse_multipart(FILE *fp, const char *boundary, LOFF_T end_off
         new = mutt_read_mime_header(fp, digest);
 
 #ifdef SUN_ATTACHMENT
-        if (mutt_get_parameter("content-lines", new->parameter))
+        if (mutt_param_get("content-lines", new->parameter))
         {
-          if (mutt_str_atoi(mutt_get_parameter("content-lines", new->parameter), &lines) < 0)
+          if (mutt_str_atoi(mutt_param_get("content-lines", new->parameter), &lines) < 0)
             lines = 0;
           for (; lines; lines--)
             if (ftello(fp) >= end_off || fgets(buffer, LONG_STRING, fp) == NULL)

diff --git a/postpone.c b/postpone.c
index c0f0432a72b11c54d711af1e0d31ec5fb0d2a120..660bee4de30632fe87453355ebd878d3047a23ce 100644 (file)
--- a/postpone.c
+++ b/postpone.c
@@ -608,7 +608,7 @@ int mutt_prepare_template(FILE *fp, struct Context *ctx, struct Header *newhdr,
   {
     newhdr->security |= SIGN;
     if ((WithCrypto & APPLICATION_PGP) &&
-        (mutt_str_strcasecmp(mutt_get_parameter("protocol", newhdr->content->parameter),
+        (mutt_str_strcasecmp(mutt_param_get("protocol", newhdr->content->parameter),
                              "application/pgp-signature") == 0))
       newhdr->security |= APPLICATION_PGP;
     else if ((WithCrypto & APPLICATION_SMIME))
@@ -659,7 +659,7 @@ int mutt_prepare_template(FILE *fp, struct Context *ctx, struct Header *newhdr,
 
     if (b->type == TYPETEXT)
     {
-      if (mutt_str_strcasecmp("yes", mutt_get_parameter("x-mutt-noconv", b->parameter)) == 0)
+      if (mutt_str_strcasecmp("yes", mutt_param_get("x-mutt-noconv", b->parameter)) == 0)
         b->noconv = true;
       else
       {
@@ -667,7 +667,7 @@ int mutt_prepare_template(FILE *fp, struct Context *ctx, struct Header *newhdr,
         b->noconv = false;
       }
 
-      mutt_delete_parameter("x-mutt-noconv", &b->parameter);
+      mutt_param_delete("x-mutt-noconv", &b->parameter);
     }
 
     mutt_adv_mktemp(file, sizeof(file));
@@ -684,7 +684,7 @@ int mutt_prepare_template(FILE *fp, struct Context *ctx, struct Header *newhdr,
 
       b->type = TYPETEXT;
       mutt_str_replace(&b->subtype, "plain");
-      mutt_delete_parameter("x-action", &b->parameter);
+      mutt_param_delete("x-action", &b->parameter);
     }
     else if ((WithCrypto & APPLICATION_SMIME) &&
              ((sec_type = mutt_is_application_smime(b)) & (ENCRYPT | SIGN)))

diff --git a/rfc1524.c b/rfc1524.c
index 33e83805e52c2b6e9ebdfb81e11c4aa15ef9795b..5b21a1709a234e419c41e275a22dc919d154ef39 100644 (file)
--- a/rfc1524.c
+++ b/rfc1524.c
@@ -94,7 +94,7 @@ int rfc1524_expand_command(struct Body *a, char *filename, char *_type, char *co
           param[z++] = command[x++];
         param[z] = '\0';
 
-        _pvalue = mutt_get_parameter(param, a->parameter);
+        _pvalue = mutt_param_get(param, a->parameter);
         mutt_str_strfcpy(pvalue, NONULL(_pvalue), sizeof(pvalue));
         if (option(OPT_MAILCAP_SANITIZE))
           mutt_file_sanitize_filename(pvalue, 0);

diff --git a/rfc2231.c b/rfc2231.c
index df37368085261d97a04ce6722c0c5ab21f750787..db1503269040a6f3ea7ec58641dd712d5a3eb384 100644 (file)
--- a/rfc2231.c
+++ b/rfc2231.c
@@ -68,7 +68,7 @@ static void purge_empty_parameters(struct Parameter **headp)
     {
       *last = q;
       p->next = NULL;
-      mutt_free_parameter(&p);
+      mutt_param_free(&p);
     }
     else
       last = &p->next;

diff --git a/rfc3676.c b/rfc3676.c
index 7723d789a4e9fe4c0bf71526f7cffa7f2d546444..4c126510878f7a27685553150ae8ea3b7172e10c 100644 (file)
--- a/rfc3676.c
+++ b/rfc3676.c
@@ -277,7 +277,7 @@ int rfc3676_handler(struct Body *a, struct State *s)
   memset(&fst, 0, sizeof(fst));
 
   /* respect DelSp of RFC3676 only with f=f parts */
-  if ((t = (char *) mutt_get_parameter("delsp", a->parameter)))
+  if ((t = (char *) mutt_param_get("delsp", a->parameter)))
   {
     delsp = mutt_str_strlen(t) == 3 && (mutt_str_strncasecmp(t, "yes", 3) == 0);
     t = NULL;

diff --git a/send.c b/send.c
index 22a17d40a4ea3fd82cc97f0f2da96dffb5d7d826..6f0bf4c77b9940945b63680156335dc81bf5e3ef 100644 (file)
--- a/send.c
+++ b/send.c
@@ -1592,7 +1592,7 @@ int ci_send_message(int flags, struct Header *msg, char *tempfile,
       if (option(OPT_TEXT_FLOWED) && msg->content->type == TYPETEXT &&
           (mutt_str_strcasecmp(msg->content->subtype, "plain") == 0))
       {
-        mutt_set_parameter("format", "flowed", &msg->content->parameter);
+        mutt_param_set("format", "flowed", &msg->content->parameter);
       }
     }
 
@@ -1706,7 +1706,7 @@ int ci_send_message(int flags, struct Header *msg, char *tempfile,
       if (option(OPT_TEXT_FLOWED) && msg->content->type == TYPETEXT &&
           (mutt_str_strcasecmp("plain", msg->content->subtype) == 0))
       {
-        char *p = mutt_get_parameter("format", msg->content->parameter);
+        char *p = mutt_param_get("format", msg->content->parameter);
         if (mutt_str_strcasecmp("flowed", NONULL(p)) != 0)
           rfc3676_space_stuff(msg);
       }

diff --git a/sendlib.c b/sendlib.c
index 9e4ff8848f4df5f7118a171c8ef47782ca08351b..6dd10adbe309c1af9d3a83cdf144b4e69c17dd51 100644 (file)
--- a/sendlib.c
+++ b/sendlib.c
@@ -435,7 +435,7 @@ int mutt_write_mime_body(struct Body *a, FILE *f)
   if (a->type == TYPEMULTIPART)
   {
     /* First, find the boundary to use */
-    p = mutt_get_parameter("boundary", a->parameter);
+    p = mutt_param_get("boundary", a->parameter);
     if (!p)
     {
       mutt_debug(1, "no boundary parameter found!\n");
@@ -509,7 +509,7 @@ void mutt_generate_boundary(struct Parameter **parm)
 
   mutt_rand_base32(rs, sizeof(rs) - 1);
   rs[MUTT_RANDTAG_LEN] = 0;
-  mutt_set_parameter("boundary", rs, parm);
+  mutt_param_set("boundary", rs, parm);
 }
 
 /**
@@ -939,7 +939,7 @@ struct Content *mutt_get_content_info(const char *fname, struct Body *b)
 
   if (b != NULL && b->type == TYPETEXT && (!b->noconv && !b->force_charset))
   {
-    char *chs = mutt_get_parameter("charset", b->parameter);
+    char *chs = mutt_param_get("charset", b->parameter);
     char *fchs = b->use_disp ?
                      ((AttachCharset && *AttachCharset) ? AttachCharset : Charset) :
                      Charset;
@@ -950,7 +950,7 @@ struct Content *mutt_get_content_info(const char *fname, struct Body *b)
       if (!chs)
       {
         mutt_canonical_charset(chsbuf, sizeof(chsbuf), tocode);
-        mutt_set_parameter("charset", chsbuf, &b->parameter);
+        mutt_param_set("charset", chsbuf, &b->parameter);
       }
       FREE(&b->charset);
       b->charset = fromcode;
@@ -968,10 +968,10 @@ struct Content *mutt_get_content_info(const char *fname, struct Body *b)
   mutt_file_fclose(&fp);
 
   if (b != NULL && b->type == TYPETEXT && (!b->noconv && !b->force_charset))
-    mutt_set_parameter(
-        "charset",
-        (!info->hibin ? "us-ascii" : Charset && !mutt_is_us_ascii(Charset) ? Charset : "unknown-8bit"),
-        &b->parameter);
+    mutt_param_set("charset",
+                   (!info->hibin ? "us-ascii" :
+                                   Charset && !mutt_is_us_ascii(Charset) ? Charset : "unknown-8bit"),
+                   &b->parameter);
 
   return info;
 }
@@ -1315,7 +1315,7 @@ char *mutt_get_body_charset(char *d, size_t dlen, struct Body *b)
     return NULL;
 
   if (b)
-    p = mutt_get_parameter("charset", b->parameter);
+    p = mutt_param_get("charset", b->parameter);
 
   if (p)
     mutt_canonical_charset(d, dlen, NONULL(p));
@@ -1340,7 +1340,7 @@ void mutt_update_encoding(struct Body *a)
     a->noconv = false;
 
   if (!a->force_charset && !a->noconv)
-    mutt_delete_parameter("charset", &a->parameter);
+    mutt_param_delete("charset", &a->parameter);
 
   info = mutt_get_content_info(a->filename, a);
   if (!info)
@@ -1557,8 +1557,7 @@ static bool check_boundary(const char *boundary, struct Body *b)
   if (b->next && check_boundary(boundary, b->next))
     return true;
 
-  if ((p = mutt_get_parameter("boundary", b->parameter)) &&
-      (mutt_str_strcmp(p, boundary) == 0))
+  if ((p = mutt_param_get("boundary", b->parameter)) && (mutt_str_strcmp(p, boundary) == 0))
   {
     return true;
   }
@@ -1576,9 +1575,9 @@ struct Body *mutt_make_multipart(struct Body *b)
   do
   {
     mutt_generate_boundary(&new->parameter);
-    if (check_boundary(mutt_get_parameter("boundary", new->parameter), b))
-      mutt_delete_parameter("boundary", &new->parameter);
-  } while (!mutt_get_parameter("boundary", new->parameter));
+    if (check_boundary(mutt_param_get("boundary", new->parameter), b))
+      mutt_param_delete("boundary", &new->parameter);
+  } while (!mutt_param_get("boundary", new->parameter));
   new->use_disp = false;
   new->disposition = DISPINLINE;
   new->parts = b;
@@ -2887,9 +2886,9 @@ static void set_noconv_flags(struct Body *b, short flag)
     else if (b->type == TYPETEXT && b->noconv)
     {
       if (flag)
-        mutt_set_parameter("x-mutt-noconv", "yes", &b->parameter);
+        mutt_param_set("x-mutt-noconv", "yes", &b->parameter);
       else
-        mutt_delete_parameter("x-mutt-noconv", &b->parameter);
+        mutt_param_delete("x-mutt-noconv", &b->parameter);
     }
   }
 }