← Back to branch summary

~ubuntu-branches/ubuntu/precise/mutt/precise

« back to all changes in this revision

Viewing changes to init.c

  • Committer: Bazaar Package Importer
  • Author(s): Christoph Berg, Adeodato Simó, Christoph Berg
  • Date: 2007-11-03 23:00:04 UTC
  • mfrom: (1.1.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20071103230004-43e36pnhub87junc
Tags: 1.5.17-1
http://bugs.debian.org/433425
http://bugs.debian.org/420598
http://bugs.debian.org/264014
http://bugs.debian.org/439775
http://bugs.debian.org/352478
http://bugs.debian.org/416555
http://bugs.debian.org/447340
[ Adeodato Simó ]
* Move the packaging back to Bazaar, adjust X-VCS-* accordingly.

[ Christoph Berg ]
* Mention libsasl2-modules-gssapi-mit in README.Debian. (Closes: #433425)
* Call autoreconf at build time, drop the autotools-update patch.
* Update menu file, add lintian override file.
* Refresh patches.

* New upstream version:
  + fix segfaults with single byte 8-bit characters in index_format.
    (Closes: #420598, Mutt: #2882)
  + properly render subject headers with encoded linefeeds.
    (Closes: #264014, Mutt: #1810)
  + only calls gnutls_error_is_fatal when gnutls_record_recv returns a
    negative value. (Closes: #439775, Mutt: #2954)
  + Large file support for mutt_pretty_size().
    (Closes: #352478, #416555, Mutt: #2191)
  + Do not consider empty pipes for filtering in format strings.
    (Closes: #447340)

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
 
2522
2591
    {
2523
2592
      if ((myvarval = myvar_get(var)) != NULL)
2524
2593
      {
2525
 
        snprintf (pt, len - (pt - buffer), "%s=\"%s\"", var, myvarval);
 
2594
        pretty_var (pt, len - (pt - buffer), var, myvarval);
2526
2595
        return 1;
2527
2596
      }
2528
2597
      return 0; /* no such variable. */
2539
2608
static int var_to_string (int idx, char* val, size_t len)
2540
2609
{
2541
2610
  char tmp[LONG_STRING];
2542
 
  char *s, *d;
2543
2611
  char *vals[] = { "no", "yes", "ask-no", "ask-yes" };
2544
2612
 
2545
2613
  tmp[0] = '\0';
2625
2693
  else
2626
2694
    return 0;
2627
2695
 
2628
 
  for (s = tmp, d = val; *s && len - (d - val) > 2; len--)
2629
 
  {
2630
 
    if (*s == '\\' || *s == '"')
2631
 
      *d++ = '\\';
2632
 
    *d++ = *s++;
2633
 
  }
2634
 
  *d = '\0';
 
2696
  escape_string (val, len - 1, tmp);
2635
2697
 
2636
2698
  return 1;
2637
2699
}