X-Git-Url: http://git.madism.org/?p=apps%2Fmadmutt.git;a=blobdiff_plain;f=init.c;h=734f88e2aa1e7dfa340e57e0eaabbb6896afbdf6;hp=b9fbf582b5b52a7699570eaf608a6e4fda25f40f;hb=0995d7520848a31481107d897b9a930bff222ce7;hpb=7132fe3b1612c153f3638d1f9664ba9eab9063d6

diff --git a/init.c b/init.c
index b9fbf58..734f88e 100644
--- a/init.c
+++ b/init.c
@@ -53,6 +53,15 @@
 #include <errno.h>
 #include <sys/wait.h>
 
+#define CHECK_PAGER \
+  if ((CurrentMenu == MENU_PAGER) && \
+      (!option || (option->flags & R_RESORT))) \
+  { \
+    snprintf (err->data, err->dsize, \
+              _("Not available in this menu.")); \
+    return (-1); \
+  } else
+
 /*
  * prototypes
  */
@@ -200,7 +209,7 @@ static int bool_from_string (struct option_t* dst, const char* val,
     set_option (dst->data);
   else
     unset_option (dst->data);
-  return (0);
+  return (1);
 }
 
 static void num_to_string (char* dst, size_t dstlen,
@@ -270,10 +279,26 @@ static void sys_to_string (char* dst, size_t dstlen,
     val = CurrentFolder;
   } else if (ascii_strcmp ("muttng_folder_name", option->option) == 0 &&
              CurrentFolder && *CurrentFolder) {
-    if ((t = strrchr (CurrentFolder, '/')) != NULL)
+
+    size_t Maildirlength = str_len (Maildir);
+
+    /*
+     * if name starts with $folder, just strip it to keep hierarchy
+     * $folder=imap://host, path=imap://host/inbox/b -> inbox/b
+     */
+    if (Maildirlength > 0 && str_ncmp (CurrentFolder, Maildir, 
+                                      Maildirlength) == 0 && 
+       str_len (CurrentFolder) > Maildirlength) {
+     val = CurrentFolder + Maildirlength;
+     if (Maildir[strlen(Maildir)-1]!='/')
+       val += 1;
+     /* if not $folder, just use everything after last / */
+    } else if ((t = strrchr (CurrentFolder, '/')) != NULL)
       val = t+1;
+    /* default: use as-is */
     else
       val = CurrentFolder;
+
   } else
     val = option->init;
 
@@ -442,9 +467,10 @@ static int rx_from_string (struct option_t* dst, const char* val,
     regerror (e, rx, errbuf, errlen);
     regfree (rx);
     mem_free (&rx);
+    return (0);
   }
 
-  if (p->pattern) {
+  if (p->rx) {
     regfree (p->rx);
     mem_free (&p->rx);
   }
@@ -505,10 +531,11 @@ static void addr_to_string (char* dst, size_t dstlen,
 
 static int addr_from_string (struct option_t* dst, const char* val,
                              char* errbuf, size_t errlen) {
-  if (!dst || !val || !*val)
+  if (!dst)
     return (0);
   rfc822_free_address ((ADDRESS**) dst->data);
-  *((ADDRESS**) dst->data) = rfc822_parse_adrlist (NULL, val);
+  if (val && *val)
+    *((ADDRESS**) dst->data) = rfc822_parse_adrlist (NULL, val);
   return (1);
 }
 
@@ -1053,6 +1080,247 @@ static int parse_lists (BUFFER * buf, BUFFER * s, unsigned long data,
   return 0;
 }
 
+/* always wise to do what someone else did before */
+static void _attachments_clean (void) {
+  int i;
+  if (Context && Context->msgcount) {
+    for (i = 0; i < Context->msgcount; i++)
+      Context->hdrs[i]->attach_valid = 0;
+  }
+}
+
+static int parse_attach_list (BUFFER *buf, BUFFER *s, LIST **ldata,
+                              BUFFER *err) {
+  ATTACH_MATCH *a;
+  LIST *listp, *lastp;
+  char *p;
+  char *tmpminor;
+  int len;
+
+  /* Find the last item in the list that data points to. */
+  lastp = NULL;
+  debug_print (5, ("parse_attach_list: ldata = %08x, *ldata = %08x\n",
+                   (unsigned int)ldata, (unsigned int)*ldata));
+  for (listp = *ldata; listp; listp = listp->next) {
+    a = (ATTACH_MATCH *)listp->data;
+    debug_print (5, ("parse_attach_list: skipping %s/%s\n", a->major, a->minor));
+    lastp = listp;
+  }
+
+  do {
+    mutt_extract_token (buf, s, 0);
+
+    if (!buf->data || *buf->data == '\0')
+      continue;
+    
+    a = mem_malloc(sizeof(ATTACH_MATCH));
+    
+    /* some cheap hacks that I expect to remove */
+    if (!str_casecmp(buf->data, "any"))
+      a->major = str_dup("*/.*");
+    else if (!str_casecmp(buf->data, "none"))
+      a->major = str_dup("cheap_hack/this_should_never_match");
+    else
+      a->major = str_dup(buf->data);
+    
+    if ((p = strchr(a->major, '/'))) {
+      *p = '\0';
+      ++p;
+      a->minor = p;
+    } else {
+      a->minor = "unknown";
+    }
+
+    len = str_len (a->minor);
+    tmpminor = mem_malloc(len+3);
+    strcpy(&tmpminor[1], a->minor); /* __STRCPY_CHECKED__ */
+    tmpminor[0] = '^';
+    tmpminor[len+1] = '$';
+    tmpminor[len+2] = '\0';
+    
+    a->major_int = mutt_check_mime_type(a->major);
+    regcomp(&a->minor_rx, tmpminor, REG_ICASE|REG_EXTENDED);
+    
+    mem_free (&tmpminor);
+
+    debug_print (5, ("parse_attach_list: added %s/%s [%d]\n",
+                     a->major, a->minor, a->major_int));
+
+    listp = mem_malloc(sizeof(LIST));
+    listp->data = (char *)a;
+    listp->next = NULL;
+    if (lastp) {
+      lastp->next = listp;
+    } else {
+      *ldata = listp;
+    }
+    lastp = listp;
+  }
+  while (MoreArgs (s));
+
+  _attachments_clean();
+  return 0;
+}
+
+static int parse_unattach_list (BUFFER *buf, BUFFER *s, LIST **ldata, BUFFER *err) {
+  ATTACH_MATCH *a;
+  LIST *lp, *lastp, *newlp;
+  char *tmp;
+  int major;
+  char *minor;
+
+  do {
+    mutt_extract_token (buf, s, 0);
+    
+    if (!str_casecmp(buf->data, "any"))
+      tmp = str_dup("*/.*");
+    else if (!str_casecmp(buf->data, "none"))
+      tmp = str_dup("cheap_hack/this_should_never_match");
+    else
+      tmp = str_dup(buf->data);
+    
+    if ((minor = strchr(tmp, '/'))) {
+      *minor = '\0';
+      ++minor;
+    } else {
+      minor = "unknown";
+    }
+    major = mutt_check_mime_type(tmp);
+    
+    /* We must do our own walk here because remove_from_list() will only
+     * remove the LIST->data, not anything pointed to by the LIST->data. */
+    lastp = NULL;
+    for(lp = *ldata; lp; ) {
+      a = (ATTACH_MATCH *)lp->data;
+      debug_print(5, ("parse_unattach_list: check %s/%s [%d] : %s/%s [%d]\n",
+                      a->major, a->minor, a->major_int, tmp, minor, major));
+      if (a->major_int == major && !str_casecmp(minor, a->minor)) {
+        debug_print(5, ("parse_unattach_list: removed %s/%s [%d]\n",
+                        a->major, a->minor, a->major_int));
+        regfree(&a->minor_rx);
+        mem_free(&a->major);
+        
+        /* Relink backward */
+        if (lastp)
+          lastp->next = lp->next;
+        else
+          *ldata = lp->next;
+        
+        newlp = lp->next;
+        mem_free(&lp->data); /* same as a */
+        mem_free(&lp);
+        lp = newlp;
+        continue;
+      }
+        
+      lastp = lp;
+      lp = lp->next;
+    }
+  }
+  while (MoreArgs (s));
+  
+  mem_free (&tmp);
+  _attachments_clean();
+  return 0;
+}
+
+static int print_attach_list (LIST *lp, char op, char *name) {
+  while (lp) {
+    printf("attachments %c%s %s/%s\n", op, name,
+           ((ATTACH_MATCH *)lp->data)->major,
+           ((ATTACH_MATCH *)lp->data)->minor);
+    lp = lp->next;
+  }
+  
+  return 0;
+}
+
+static int parse_attachments (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) {
+  char op, *category;
+  LIST **listp;
+  
+  mutt_extract_token(buf, s, 0);
+  if (!buf->data || *buf->data == '\0') {
+    strfcpy(err->data, _("attachments: no disposition"), err->dsize);
+    return -1;
+  }
+ 
+  category = buf->data;
+  op = *category++;
+  
+  if (op == '?') {
+    mutt_endwin (NULL);
+    fflush (stdout);
+    printf("\nCurrent attachments settings:\n\n");
+    print_attach_list(AttachAllow, '+', "A");
+    print_attach_list(AttachExclude, '-', "A");
+    print_attach_list(InlineAllow, '+', "I");
+    print_attach_list(InlineExclude, '-', "I");
+    set_option (OPTFORCEREDRAWINDEX);
+    set_option (OPTFORCEREDRAWPAGER);
+    mutt_any_key_to_continue (NULL);
+    return 0;
+  }
+
+  if (op != '+' && op != '-') {
+    op = '+';
+    category--;
+  }
+  if (!str_ncasecmp(category, "attachment", strlen(category))) {
+    if (op == '+')
+      listp = &AttachAllow;
+    else
+      listp = &AttachExclude;
+  }
+  else if (!str_ncasecmp(category, "inline", strlen(category))) {
+    if (op == '+')
+      listp = &InlineAllow;
+    else
+      listp = &InlineExclude;
+  } else {
+    strfcpy(err->data, _("attachments: invalid disposition"), err->dsize);
+    return -1;
+  }
+  
+  return parse_attach_list(buf, s, listp, err);
+}
+
+static int parse_unattachments (BUFFER *buf, BUFFER *s, unsigned long data, BUFFER *err) {
+  char op, *p;
+  LIST **listp;
+  
+  mutt_extract_token(buf, s, 0);
+  if (!buf->data || *buf->data == '\0') {
+    strfcpy(err->data, _("unattachments: no disposition"), err->dsize);
+    return -1;
+  }
+  
+  p = buf->data;
+  op = *p++;
+  if (op != '+' && op != '-') {
+    op = '+';
+    p--;
+  }
+  if (!str_ncasecmp(p, "attachment", strlen(p))) {
+    if (op == '+')
+      listp = &AttachAllow;
+    else
+      listp = &AttachExclude;
+  }
+  else if (!str_ncasecmp(p, "inline", strlen(p))) {
+    if (op == '+')
+      listp = &InlineAllow;
+    else
+      listp = &InlineExclude;
+  }
+  else {
+    strfcpy(err->data, _("unattachments: invalid disposition"), err->dsize);
+    return -1;
+  }
+  
+  return parse_unattach_list(buf, s, listp, err);
+}
+
 static int parse_unlists (BUFFER * buf, BUFFER * s, unsigned long data,
                           BUFFER * err)
 {
@@ -1202,7 +1470,8 @@ static int parse_alias (BUFFER * buf, BUFFER * s, unsigned long data,
   if (DebugLevel >= 2) {
     ADDRESS *a;
 
-    for (a = tmp->addr; a; a = a->next) {
+    /* A group is terminated with an empty address, so check a->mailbox */
+    for (a = tmp->addr; a && a->mailbox; a = a->next) {
       if (!a->group)
         debug_print (2, ("%s\n", a->mailbox));
       else
@@ -1366,11 +1635,45 @@ static void del_option (void* p) {
   mem_free (&ptr);
 }
 
+static int init_expand (char** dst, struct option_t* src) {
+  BUFFER token, in;
+  size_t len = 0;
+
+  mem_free (dst);
+
+  if (DTYPE(src->type) == DT_STR ||
+      DTYPE(src->type) == DT_PATH) {
+    /* 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));
+      len = str_len (src->init) + 2;
+      in.data = mem_malloc (len+1);
+      snprintf (in.data, len, "\"%s\"", src->init);
+      in.dptr = in.data;
+      in.dsize = len;
+      mutt_extract_token (&token, &in, 0);
+      if (token.data && *token.data)
+        *dst = str_dup (token.data);
+      else
+        *dst = str_dup ("");
+      mem_free (&in.data);
+      mem_free (&token.data);
+    } else
+      *dst = str_dup ("");
+  } else
+    /* for non-string: take value as is */
+    *dst = str_dup (src->init);
+  return (1);
+}
+
 /* if additional data more == 1, we want to resolve synonyms */
 static void mutt_restore_default (const char* name, void* p,
                                   unsigned long more) {
   char errbuf[STRING];
   struct option_t* ptr = (struct option_t*) p;
+  char* init = NULL;
 
   if (DTYPE (ptr->type) == DT_SYN) {
     if (!more)
@@ -1379,13 +1682,18 @@ static void mutt_restore_default (const char* name, void* p,
   }
   if (!ptr)
     return;
-  if (FuncTable[DTYPE (ptr->type)].opt_from_string &&
-      FuncTable[DTYPE (ptr->type)].opt_from_string (ptr, ptr->init, errbuf,
-                                                    sizeof (errbuf)) < 0) {
-    mutt_endwin (NULL);
-    fprintf (stderr, _("Invalid default setting found. Please report this "
-                       "error:\n\"%s\"\n"), errbuf);
-    exit (1);
+  if (FuncTable[DTYPE (ptr->type)].opt_from_string) {
+    init_expand (&init, ptr);
+    if (!FuncTable[DTYPE (ptr->type)].opt_from_string (ptr, init, errbuf,
+                                                       sizeof (errbuf))) {
+      if (!option (OPTNOCURSES))
+        mutt_endwin (NULL);
+      fprintf (stderr, _("Invalid default setting for $%s found: \"%s\".\n"
+                         "Please report this error: \"%s\"\n"),
+               ptr->option, NONULL (init), errbuf);
+      exit (1);
+    }
+    mem_free (&init);
   }
 
   if (ptr->flags & R_INDEX)
@@ -1581,15 +1889,27 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
       }
 
       if (!str_cmp ("all", tmp->data)) {
+        if (CurrentMenu == MENU_PAGER) {
+          snprintf (err->data, err->dsize, _("Not available in this menu."));
+          return (-1);
+        }
         hash_map (ConfigOptions, mutt_restore_default, 1);
+        set_option (OPTFORCEREDRAWINDEX);
+        set_option (OPTFORCEREDRAWPAGER);
+        set_option (OPTSORTSUBTHREADS);
+        set_option (OPTNEEDRESORT);
+        set_option (OPTRESORTINIT);
+        set_option (OPTREDRAWTREE);
         return (0);
       }
       else if (!FuncTable[DTYPE (option->type)].opt_from_string) {
         snprintf (err->data, err->dsize, _("$%s is read-only"), option->option);
         r = -1;
         break;
-      } else
+      } else {
+        CHECK_PAGER;
         mutt_restore_default (NULL, option, 1);
+      }
     }
     else if (DTYPE (option->type) == DT_BOOL) {
       /* XXX this currently ignores the function table
@@ -1617,6 +1937,7 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
         return 0;
       }
 
+      CHECK_PAGER;
       if (unset)
         unset_option (option->data);
       else if (inv)
@@ -1641,6 +1962,7 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
           DTYPE (option->type) == DT_USER ||
           DTYPE (option->type) == DT_SYS) {
         if (unset) {
+          CHECK_PAGER;
           if (!FuncTable[DTYPE (option->type)].opt_from_string) {
             snprintf (err->data, err->dsize, _("$%s is read-only"),
                       option->option);
@@ -1671,6 +1993,7 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
         r = -1;
         break;
       } else {
+        CHECK_PAGER;
         s->dptr++;
         mutt_extract_token (tmp, s, 0);
         if (!FuncTable[DTYPE (option->type)].opt_from_string
@@ -1686,6 +2009,7 @@ static int parse_set (BUFFER * tmp, BUFFER * s, unsigned long data,
       }
 
       if (*s->dptr == '=') {
+        CHECK_PAGER;
         s->dptr++;
         mutt_extract_token (tmp, s, 0);
         if (ascii_strcasecmp ("yes", tmp->data) == 0)
@@ -2290,6 +2614,7 @@ void mutt_init (int skip_sys_rc, LIST * commands)
 
     Realname = str_dup (mutt_gecos_name (rnbuf, sizeof (rnbuf), pw));
     Shell = str_dup (pw->pw_shell);
+    endpwent ();
   }
   else {
     if (!Homedir) {