← Back to branch summary

~ubuntu-branches/ubuntu/vivid/mutt/vivid-updates

« back to all changes in this revision

Viewing changes to init.c

Tags: 1.5.18-6
http://bugs.debian.org/462266
http://bugs.debian.org/513230
http://bugs.debian.org/514309
* Grab from upstream:
  + Guard idata->mailbox read in imap_mailbox_state.
    The bug happens when a user has more than a imap mailbox, when
    he/she browses through them mutt will segfault.
    (Closes: #462266, #513230, #514309. Mutt: #3057)

Show diffs side-by-side

added added

removed removed

Lines of Context:
init.c
448
448
  return 0;
449
449
}
450
450
 
 
451
static int remove_from_spam_list (SPAM_LIST **list, const char *pat);
451
452
 
452
453
static int add_to_spam_list (SPAM_LIST **list, const char *pat, const char *templ, BUFFER *err)
453
454
{
515
516
    else
516
517
        ++p;
517
518
  }
518
 
  t->nmatch++;          /* match 0 is always the whole expr */
 
519
 
 
520
  if (t->nmatch > t->rx->rx->re_nsub)
 
521
  {
 
522
    snprintf (err->data, err->dsize, _("Not enough subexpressions for spam "
 
523
                                       "template"));
 
524
    remove_from_spam_list(list, pat);
 
525
    return -1;
 
526
  }
 
527
 
 
528
  t->nmatch++;         /* match 0 is always the whole expr */
519
529
 
520
530
  return 0;
521
531
}
1620
1630
    set_option (OPTREDRAWTREE);
1621
1631
}
1622
1632
 
 
1633
static size_t escape_string (char *dst, size_t len, const char* src)
 
1634
{
 
1635
  char* p = dst;
 
1636
 
 
1637
  if (!len)
 
1638
    return 0;
 
1639
  len--; /* save room for \0 */
 
1640
#define ESC_CHAR(C)     do { *p++ = '\\'; if (p - dst < len) *p++ = C; } while(0)
 
1641
  while (p - dst < len && src && *src)
 
1642
  {
 
1643
    switch (*src)
 
1644
    {
 
1645
    case '\n':
 
1646
      ESC_CHAR('n');
 
1647
      break;
 
1648
    case '\r':
 
1649
      ESC_CHAR('r');
 
1650
      break;
 
1651
    case '\t':
 
1652
      ESC_CHAR('t');
 
1653
      break;
 
1654
    default:
 
1655
      if ((*src == '\\' || *src == '"') && p - dst < len - 1)
 
1656
        *p++ = '\\';
 
1657
      *p++ = *src;
 
1658
    }
 
1659
    src++;
 
1660
  }
 
1661
#undef ESC_CHAR
 
1662
  *p = '\0';
 
1663
  return p - dst;
 
1664
}
 
1665
 
 
1666
static void pretty_var (char *dst, size_t len, const char *option, const char *val)
 
1667
{
 
1668
  char *p;
 
1669
 
 
1670
  if (!len)
 
1671
    return;
 
1672
 
 
1673
  strfcpy (dst, option, len);
 
1674
  len--; /* save room for \0 */
 
1675
  p = dst + mutt_strlen (dst);
 
1676
 
 
1677
  if (p - dst < len)
 
1678
    *p++ = '=';
 
1679
  if (p - dst < len)
 
1680
    *p++ = '"';
 
1681
  p += escape_string (p, len - (p - dst) + 1, val);     /* \0 terminate it */
 
1682
  if (p - dst < len)
 
1683
    *p++ = '"';
 
1684
  *p = 0;
 
1685
}
 
1686
 
1623
1687
static int parse_set (BUFFER *tmp, BUFFER *s, unsigned long data, BUFFER *err)
1624
1688
{
1625
1689
  int query, unset, inv, reset, r = 0;
1716
1780
      {
1717
1781
        if (unset || inv || query)
1718
1782
        {
1719
 
          snprintf (err->data, err->dsize, "Usage: set variable=yes|no");
 
1783
          snprintf (err->data, err->dsize, _("Usage: set variable=yes|no"));
1720
1784
          return (-1);
1721
1785
        }
1722
1786
 
1728
1792
          unset = 1;
1729
1793
        else
1730
1794
        {
1731
 
          snprintf (err->data, err->dsize, "Usage: set variable=yes|no");
 
1795
          snprintf (err->data, err->dsize, _("Usage: set variable=yes|no"));
1732
1796
          return (-1);
1733
1797
        }
1734
1798
      }
1773
1837
        {
1774
1838
          if ((val = myvar_get (myvar)))
1775
1839
          {
1776
 
            snprintf (err->data, err->dsize, "%s=\"%s\"", myvar, val);
 
1840
            pretty_var (err->data, err->dsize, myvar, val);
1777
1841
            break;
1778
1842
          }
1779
1843
          else
1788
1852
          rfc822_write_address (_tmp, sizeof (_tmp), *((ADDRESS **) MuttVars[idx].data), 0);
1789
1853
          val = _tmp;
1790
1854
        }
 
1855
        else if (DTYPE (MuttVars[idx].type) == DT_PATH)
 
1856
        {
 
1857
          _tmp[0] = '\0';
 
1858
          strfcpy (_tmp, NONULL(*((char **) MuttVars[idx].data)), sizeof (_tmp));
 
1859
          mutt_pretty_mailbox (_tmp);
 
1860
          val = _tmp;
 
1861
        }
1791
1862
        else
1792
1863
          val = *((char **) MuttVars[idx].data);
1793
1864
        
1794
1865
        /* user requested the value of this variable */
1795
 
        snprintf (err->data, err->dsize, "%s=\"%s\"", MuttVars[idx].option,
1796
 
                  NONULL (val));
 
1866
        pretty_var (err->data, err->dsize, MuttVars[idx].option, NONULL(val));
1797
1867
        break;
1798
1868
      }
1799
1869
      else
1848
1918
      if (query || *s->dptr != '=')
1849
1919
      {
1850
1920
        /* user requested the value of this variable */
1851
 
        snprintf (err->data, err->dsize, "%s=\"%s\"", MuttVars[idx].option,
1852
 
                  NONULL (ptr->pattern));
 
1921
        pretty_var (err->data, err->dsize, MuttVars[idx].option, NONULL(ptr->pattern));
1853
1922
        break;
1854
1923
      }
1855
1924
 
1974
2043
 
1975
2044
      if (query || *s->dptr != '=')
1976
2045
      {
 
2046
        val = *ptr;
 
2047
        /* compatibility alias */
 
2048
        if (mutt_strcmp (MuttVars[idx].option, "wrapmargin") == 0)
 
2049
          val = *ptr < 0 ? -*ptr : 0;
 
2050
 
1977
2051
        /* user requested the value of this variable */
1978
 
        snprintf (err->data, err->dsize, "%s=%d", MuttVars[idx].option, *ptr);
 
2052
        snprintf (err->data, err->dsize, "%s=%d", MuttVars[idx].option, val);
1979
2053
        break;
1980
2054
      }
1981
2055
 
2006
2080
        if (*ptr < 0)
2007
2081
          *ptr = 0;
2008
2082
      }
 
2083
      else if (mutt_strcmp (MuttVars[idx].option, "wrapmargin") == 0)
 
2084
      {
 
2085
        if (*ptr < 0)
 
2086
          *ptr = 0;
 
2087
        else
 
2088
          *ptr = -*ptr;
 
2089
      }
2009
2090
    }
2010
2091
    else if (DTYPE (MuttVars[idx].type) == DT_QUAD)
2011
2092
    {
2510
2591
    {
2511
2592
      if ((myvarval = myvar_get(var)) != NULL)
2512
2593
      {
2513
 
        snprintf (pt, len - (pt - buffer), "%s=\"%s\"", var, myvarval);
 
2594
        pretty_var (pt, len - (pt - buffer), var, myvarval);
2514
2595
        return 1;
2515
2596
      }
2516
2597
      return 0; /* no such variable. */
2527
2608
static int var_to_string (int idx, char* val, size_t len)
2528
2609
{
2529
2610
  char tmp[LONG_STRING];
2530
 
  char *s, *d;
2531
2611
  char *vals[] = { "no", "yes", "ask-no", "ask-yes" };
2532
2612
 
2533
2613
  tmp[0] = '\0';
2547
2627
  else if (DTYPE (MuttVars[idx].type) == DT_QUAD)
2548
2628
    strfcpy (tmp, vals[quadoption (MuttVars[idx].data)], sizeof (tmp));
2549
2629
  else if (DTYPE (MuttVars[idx].type) == DT_NUM)
2550
 
    snprintf (tmp, sizeof (tmp), "%d", (*((short *) MuttVars[idx].data)));
 
2630
  {
 
2631
    short sval = *((short *) MuttVars[idx].data);
 
2632
 
 
2633
    /* avert your eyes, gentle reader */
 
2634
    if (mutt_strcmp (MuttVars[idx].option, "wrapmargin") == 0)
 
2635
      sval = sval > 0 ? 0 : -sval;
 
2636
 
 
2637
    snprintf (tmp, sizeof (tmp), "%d", sval);
 
2638
  }
2551
2639
  else if (DTYPE (MuttVars[idx].type) == DT_SORT)
2552
2640
  {
2553
2641
    const struct mapping_t *map;
2605
2693
  else
2606
2694
    return 0;
2607
2695
 
2608
 
  for (s = tmp, d = val; *s && len - (d - val) > 2; len--)
2609
 
  {
2610
 
    if (*s == '\\' || *s == '"')
2611
 
      *d++ = '\\';
2612
 
    *d++ = *s++;
2613
 
  }
2614
 
  *d = '\0';
 
2696
  escape_string (val, len - 1, tmp);
2615
2697
 
2616
2698
  return 1;
2617
2699
}
2947
3029
      snprintf (buffer, sizeof (buffer), "%s/.mutt/muttrc-%s", NONULL(Homedir), MUTT_VERSION);
2948
3030
    if (access(buffer, F_OK) == -1)
2949
3031
      snprintf (buffer, sizeof (buffer), "%s/.mutt/muttrc", NONULL(Homedir));
2950
 
    
 
3032
    if (access(buffer, F_OK) == -1) /* default to .muttrc for alias_file */
 
3033
      snprintf (buffer, sizeof(buffer), "%s/.muttrc", NONULL(Homedir));
 
3034
 
2951
3035
    default_rc = 1;
2952
3036
    Muttrc = safe_strdup (buffer);
2953
3037
  }
3012
3096
      mutt_exit(1);
3013
3097
  }
3014
3098
 
 
3099
  mutt_read_histfile ();
 
3100
 
3015
3101
#if 0
3016
3102
  set_option (OPTWEED); /* turn weeding on by default */
3017
3103
#endif