Example #1
0
static const char * query_format_str (char *dest, size_t destlen, size_t col,
char op, const char *src,
const char *fmt, const char *ifstring,
const char *elsestring,
unsigned long data, format_flag flags)
{
        ENTRY *entry = (ENTRY *)data;
        QUERY *query = entry->data;
        char tmp[SHORT_STRING];
        char buf2[STRING] = "";
        int optional = (flags & M_FORMAT_OPTIONAL);

        switch (op) {
                case 'a':
                        rfc822_write_address (buf2, sizeof (buf2), query->addr, 1);
                        snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
                        snprintf (dest, destlen, tmp, buf2);
                        break;
                case 'c':
                        snprintf (tmp, sizeof (tmp), "%%%sd", fmt);
                        snprintf (dest, destlen, tmp, query->num + 1);
                        break;
                case 'e':
                        if (!optional) {
                                snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
                                snprintf (dest, destlen, tmp, NONULL (query->other));
                        }
                        else if (!query->other || !*query->other)
                                optional = 0;
                        break;
                case 'n':
                        snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
                        snprintf (dest, destlen, tmp, NONULL (query->name));
                        break;
                case 't':
                        snprintf (tmp, sizeof (tmp), "%%%sc", fmt);
                        snprintf (dest, destlen, tmp, entry->tagged ? '*' : ' ');
                        break;
                default:
                        snprintf (tmp, sizeof (tmp), "%%%sc", fmt);
                        snprintf (dest, destlen, tmp, op);
                        break;
        }

        if (optional)
                mutt_FormatString (dest, destlen, col, ifstring, query_format_str, data, 0);
        else if (flags & M_FORMAT_OPTIONAL)
                mutt_FormatString (dest, destlen, col, elsestring, query_format_str, data, 0);

        return src;
}
Example #2
0
void mutt_pgp_command (char *d, size_t dlen, struct pgp_command_context *cctx,
                       const char *fmt)
{
  mutt_FormatString (d, dlen, NONULL (fmt), _mutt_fmt_pgp_command,
                     (unsigned long) cctx, 0);
  debug_print (2, ("%s\n", d));
}
Example #3
0
char* make_sidebar_entry(char *box, unsigned int size, unsigned int new_messages, unsigned int flagged)
{
    static char *entry = 0;
    struct sidebar_entry sbe;
    int SBvisual;

    SBvisual = SidebarWidth - strlen(SidebarDelim);

    if (SBvisual < 1)
        return NULL;

    sbe.new_messages = new_messages;
    sbe.flagged = flagged;
    sbe.size = size;
    strncpy(sbe.box, box, 31);

    safe_realloc(&entry, SBvisual + 2);
    entry[SBvisual + 1] = '\0';

    mutt_FormatString(entry,
                      SBvisual + 1,
                      0,
                      SidebarFormat,
                      sidebar_format_str,
                      (unsigned long)&sbe,
                      (format_flag)0);

    return entry;
}
Example #4
0
static char *get_compression_cmd (const char *cmd, const CONTEXT * ctx)
{
    char expanded[_POSIX_PATH_MAX];

    mutt_FormatString (expanded, sizeof (expanded), cmd,
                       compresshook_format_str, (unsigned long) ctx, 0);
    return str_dup (expanded);
}
Example #5
0
static void query_entry(char *s, size_t slen, MUTTMENU *m, int num)
{
    ENTRY *entry = &((ENTRY *)m->data)[num];

    entry->data->num = num;
    mutt_FormatString(s, slen, 0, NONULL(QueryFormat), query_format_str,
                      (unsigned long)entry, M_FORMAT_ARROWCURSOR);
}
Example #6
0
static void snd_entry(char *buf, size_t buflen, MUTTMENU *menu, int num)
{
    mutt_FormatString(buf,
                      buflen,
                      0,
                      NONULL(AttachFormat),
                      mutt_attach_fmt,
                      (unsigned long)(((ATTACHPTR **)menu->data)[num]),
                      (format_flag)(M_FORMAT_STAT_FILE | M_FORMAT_ARROWCURSOR));
}
Example #7
0
void menu_status_line(char *buf, size_t buflen, MUTTMENU *menu, const char *p)
{
    mutt_FormatString(buf,
                      buflen,
                      0,
                      p,
                      status_format_str,
                      (unsigned long)menu,
                      (format_flag)0);
}
Example #8
0
void
_mutt_make_string (char *dest, size_t destlen, const char *s, CONTEXT *ctx, HEADER *hdr, format_flag flags)
{
  struct hdr_format_info hfi;

  hfi.hdr = hdr;
  hfi.ctx = ctx;
  hfi.pager_progress = 0;

  mutt_FormatString (dest, destlen, 0, s, hdr_format_str, (unsigned long) &hfi, flags);
}
Example #9
0
static void pgp_entry (char *s, size_t l, MUTTMENU * menu, int num)
{
  pgp_uid_t **KeyTable = (pgp_uid_t **) menu->data;
  pgp_entry_t entry;

  entry.uid = KeyTable[num];
  entry.num = num + 1;

  mutt_FormatString (s, l, 0, NONULL (PgpEntryFormat), pgp_entry_fmt, 
		     (unsigned long) &entry, M_FORMAT_ARROWCURSOR);
}
Example #10
0
static void compose_status_line(char *buf,
                                size_t buflen,
                                size_t col,
                                MUTTMENU *menu,
                                const char *p)
{
    mutt_FormatString(buf,
                      buflen,
                      col,
                      p,
                      compose_format_str,
                      (unsigned long)menu,
                      (format_flag)0);
}
Example #11
0
void mutt_pgp_command(char                       *d,
                      size_t                     dlen,
                      struct pgp_command_context *cctx,
                      const char                 *fmt)
{
    mutt_FormatString(d,
                      dlen,
                      0,
                      NONULL(fmt),
                      _mutt_fmt_pgp_command,
                      (unsigned long)cctx,
                      (format_flag)0);
    dprint(2, "mutt_pgp_command: %s\n", d);
}
Example #12
0
void
mutt_make_string_info(char                   *dst,
                      size_t                 dstlen,
                      const char             *s,
                      struct hdr_format_info *hfi,
                      format_flag            flags)
{
    mutt_FormatString(dst,
                      dstlen,
                      0,
                      s,
                      hdr_format_str,
                      (unsigned long)hfi,
                      flags);
}
Example #13
0
static const char *pgp_entry_fmt (char *dest,
				  size_t destlen,
				  size_t col,
				  char op,
				  const char *src,
				  const char *prefix,
				  const char *ifstring,
				  const char *elsestring,
				  unsigned long data,
				  format_flag flags)
{
  char fmt[16];
  pgp_entry_t *entry;
  pgp_uid_t *uid;
  pgp_key_t key, pkey;
  int kflags = 0;
  int optional = (flags & M_FORMAT_OPTIONAL);

  entry = (pgp_entry_t *) data;
  uid   = entry->uid;
  key   = uid->parent;
  pkey  = pgp_principal_key (key);

  if (isupper ((unsigned char) op))
    key = pkey;

  kflags = key->flags | (pkey->flags & KEYFLAG_RESTRICTIONS)
    | uid->flags;

  switch (ascii_tolower (op))
  {
    case '[':

      {
	const char *cp;
	char buf2[SHORT_STRING], *p;
	int do_locales;
	struct tm *tm;
	size_t len;

	p = dest;

	cp = src;
	if (*cp == '!')
	{
	  do_locales = 0;
	  cp++;
	}
	else
	  do_locales = 1;

	len = destlen - 1;
	while (len > 0 && *cp != ']')
	{
	  if (*cp == '%')
	  {
	    cp++;
	    if (len >= 2)
	    {
	      *p++ = '%';
	      *p++ = *cp;
	      len -= 2;
	    }
	    else
	      break; /* not enough space */
	    cp++;
	  }
	  else
	  {
	    *p++ = *cp++;
	    len--;
	  }
	}
	*p = 0;

	if (do_locales && Locale)
	  setlocale (LC_TIME, Locale);

	tm = localtime (&key->gen_time);

	strftime (buf2, sizeof (buf2), dest, tm);

	if (do_locales)
	  setlocale (LC_TIME, "C");

	snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
	snprintf (dest, destlen, fmt, buf2);
	if (len > 0)
	  src = cp + 1;
      }
      break;
    case 'n':
      if (!optional)
      {
	snprintf (fmt, sizeof (fmt), "%%%sd", prefix);
	snprintf (dest, destlen, fmt, entry->num);
      }
      break;
    case 'k':
      if (!optional)
      {
	snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
	snprintf (dest, destlen, fmt, _pgp_keyid (key));
      }
      break;
    case 'u':
      if (!optional)
      {
	snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
	snprintf (dest, destlen, fmt, NONULL (uid->addr));
      }
      break;
    case 'a':
      if (!optional)
      {
	snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
	snprintf (dest, destlen, fmt, key->algorithm);
      }
      break;
    case 'l':
      if (!optional)
      {
	snprintf (fmt, sizeof (fmt), "%%%sd", prefix);
	snprintf (dest, destlen, fmt, key->keylen);
      }
      break;
    case 'f':
      if (!optional)
      {
	snprintf (fmt, sizeof (fmt), "%%%sc", prefix);
	snprintf (dest, destlen, fmt, pgp_flags (kflags));
      }
      else if (!(kflags & (KEYFLAG_RESTRICTIONS)))
        optional = 0;
      break;
    case 'c':
      if (!optional)
      {
	snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
	snprintf (dest, destlen, fmt, pgp_key_abilities (kflags));
      }
      else if (!(kflags & (KEYFLAG_ABILITIES)))
        optional = 0;
      break;
    case 't':
      if (!optional)
      {
	snprintf (fmt, sizeof (fmt), "%%%sc", prefix);
	snprintf (dest, destlen, fmt, trust_flags[uid->trust & 0x03]);
      }
      else if (!(uid->trust & 0x03))
        /* undefined trust */
        optional = 0;
      break;
    default:
      *dest = '\0';
  }

  if (optional)
    mutt_FormatString (dest, destlen, col, ifstring, mutt_attach_fmt, data, 0);
  else if (flags & M_FORMAT_OPTIONAL)
    mutt_FormatString (dest, destlen, col, elsestring, mutt_attach_fmt, data, 0);
  return (src);
}
Example #14
0
static void mix_entry (char *b, size_t blen, MUTTMENU *menu, int num)
{
  REMAILER **type2_list = (REMAILER **) menu->data;
  mutt_FormatString (b, blen, 0, MuttIndexWindow->cols, NONULL (MixEntryFormat), mix_entry_fmt,
		     (unsigned long) type2_list[num], MUTT_FORMAT_ARROWCURSOR);
}
Example #15
0
/* %a = address of author
 * %A = reply-to address (if present; otherwise: address of author
 * %b = filename of the originating folder
 * %B = the list to which the letter was sent
 * %c = size of message in bytes
 * %C = current message number
 * %d = date and time of message using $date_format and sender's timezone
 * %D = date and time of message using $date_format and local timezone
 * %e = current message number in thread
 * %E = number of messages in current thread
 * %f = entire from line
 * %F = like %n, unless from self
 * %i = message-id
 * %l = number of lines in the message
 * %L = like %F, except `lists' are displayed first
 * %m = number of messages in the mailbox
 * %n = name of author
 * %N = score
 * %O = like %L, except using address instead of name
 * %P = progress indicator for builtin pager
 * %s = subject
 * %S = short message status (e.g., N/O/D/!/r/-)
 * %t = `to:' field (recipients)
 * %T = $to_chars
 * %u = user (login) name of author
 * %v = first name of author, unless from self
 * %X = number of MIME attachments
 * %y = `x-label:' field (if present)
 * %Y = `x-label:' field (if present, tree unfolded, and != parent's x-label)
 * %Z = status flags	*/
static const char *
hdr_format_str(char          *dest,
               size_t        destlen,
               size_t        col,
               char          op,
               const char    *src,
               const char    *prefix,
               const char    *ifstring,
               const char    *elsestring,
               unsigned long data,
               format_flag   flags)
{
    struct hdr_format_info *hfi = (struct hdr_format_info *)data;
    HEADER *hdr, *htmp;
    CONTEXT *ctx;
    char fmt[SHORT_STRING], buf2[LONG_STRING], ch, *p;
    int do_locales, i;
    int optional = (flags & M_FORMAT_OPTIONAL);
    int threads = ((Sort & SORT_MASK) == SORT_THREADS);
    int is_index = (flags & M_FORMAT_INDEX);

#define THREAD_NEW (threads                \
                    && hdr->collapsed      \
                    && hdr->num_hidden > 1 \
                    && mutt_thread_contains_unread(ctx, hdr) == 1)
#define THREAD_OLD (threads                \
                    && hdr->collapsed      \
                    && hdr->num_hidden > 1 \
                    && mutt_thread_contains_unread(ctx, hdr) == 2)
    size_t len;

    hdr = hfi->hdr;
    ctx = hfi->ctx;

    dest[0] = 0;

    switch (op) {
    case 'A':

        if (hdr->env->reply_to
            && hdr->env->reply_to->mailbox) {
            mutt_format_s(dest, destlen, prefix,
                          mutt_addr_for_display(hdr->env->reply_to));
            break;
        }

    /* fall through if 'A' returns nothing */

    case 'a':

        if (hdr->env->from
            && hdr->env->from->mailbox) {
            mutt_format_s(dest, destlen, prefix,
                          mutt_addr_for_display(hdr->env->from));
        } else
            dest[0] = '\0';
        break;

    case 'B':

        if (!first_mailing_list(dest, destlen, hdr->env->to)
            && !first_mailing_list(dest, destlen, hdr->env->cc))
            dest[0] = 0;

        if (dest[0]) {
            strfcpy(buf2, dest, sizeof(buf2));
            mutt_format_s(dest, destlen, prefix, buf2);
            break;
        }

    /* fall through if 'B' returns nothing */

    case 'b':

        if (ctx) {
            if ((p = strrchr(ctx->path, '/')))
                strfcpy(dest, p + 1, destlen);
            else
                strfcpy(dest, ctx->path, destlen);
        } else
            strfcpy(dest, "(null)", destlen);
        strfcpy(buf2, dest, sizeof(buf2));
        mutt_format_s(dest, destlen, prefix, buf2);
        break;

    case 'c':
        mutt_pretty_size(buf2, sizeof(buf2), (long)hdr->content->length);
        mutt_format_s(dest, destlen, prefix, buf2);
        break;

    case 'C':
        snprintf(fmt,  sizeof(fmt), "%%%sd", prefix);
        snprintf(dest, destlen,     fmt,     hdr->msgno + 1);
        break;

    case 'd':
    case 'D':
    case '{':
    case '[':
    case '(':
    case '<':

        /* preprocess $date_format to handle %Z */
    {
        const char *cp;
        struct tm *tm;
        time_t T;

        p = dest;

        cp = (op == 'd'
              || op == 'D') ? (NONULL(DateFmt)) : src;

        if (*cp == '!') {
            do_locales = 0;
            cp++;
        } else
            do_locales = 1;

        len = destlen - 1;

        while (len > 0
               && (((op == 'd'
                     || op == 'D')
                    && *cp)
                   || (op == '{'
                       && *cp != '}')
                   || (op == '['
                       && *cp != ']')
                   || (op == '('
                       && *cp != ')')
                   || (op == '<'
                       && *cp != '>'))) {
            if (*cp == '%') {
                cp++;

                if (((*cp == 'Z')
                     || (*cp == 'z'))
                    && ((op == 'd')
                        || (op == '{'))) {
                    if (len >= 5) {
                        sprintf(p, "%c%02u%02u", hdr->zoccident ? '-' : '+',
                                hdr->zhours, hdr->zminutes);
                        p += 5;
                        len -= 5;
                    } else
                        break;  /* not enough space left */
                } else {
                    if (len >= 2) {
                        *p++ = '%';
                        *p++ = *cp;
                        len -= 2;
                    } else
                        break;  /* not enough space */
                }
                cp++;
            } else {
                *p++ = *cp++;
                len--;
            }
        }
        *p = 0;

        if (do_locales
            && Locale)
            setlocale(LC_TIME, Locale);

        if ((op == '[')
            || (op == 'D'))
            tm = localtime(&hdr->date_sent);
        else if (op == '(')
            tm = localtime(&hdr->received);
        else if (op == '<') {
            T = time(NULL);
            tm = localtime(&T);
        } else {
            /* restore sender's time zone */
            T = hdr->date_sent;

            if (hdr->zoccident)
                T -= (hdr->zhours * 3600 + hdr->zminutes * 60);
            else
                T += (hdr->zhours * 3600 + hdr->zminutes * 60);
            tm = gmtime(&T);
        }

        strftime(buf2, sizeof(buf2), dest, tm);

        if (do_locales)
            setlocale(LC_TIME, "C");

        mutt_format_s(dest, destlen, prefix, buf2);

        if ((len > 0)
            && (op != 'd')
            && (op != 'D')) /* Skip ending op */
            src = cp + 1;
        break;
    }

    case 'e':
        snprintf(fmt,  sizeof(fmt), "%%%sd", prefix);
        snprintf(dest, destlen,     fmt,     mutt_messages_in_thread(ctx,
                                                                     hdr,
                                                                     1));
        break;

    case 'E':

        if (!optional) {
            snprintf(fmt,  sizeof(fmt), "%%%sd", prefix);
            snprintf(dest, destlen,     fmt,
                     mutt_messages_in_thread(ctx, hdr, 0));
        } else if (mutt_messages_in_thread(ctx, hdr, 0) <= 1)
            optional = 0;
        break;

    case 'f':
        buf2[0] = 0;
        rfc822_write_address(buf2, sizeof(buf2), hdr->env->from, 1);
        mutt_format_s(dest, destlen, prefix, buf2);
        break;

    case 'F':

        if (!optional) {
            make_from(hdr->env, buf2, sizeof(buf2), 0);
            mutt_format_s(dest, destlen, prefix, buf2);
        } else if (mutt_addr_is_user(hdr->env->from))
            optional = 0;
        break;

    case 'H':

        /* (Hormel) spam score */
        if (optional)
            optional = hdr->env->spam ? 1 : 0;

        if (hdr->env->spam)
            mutt_format_s(dest, destlen, prefix, NONULL(hdr->env->spam->data));
        else
            mutt_format_s(dest, destlen, prefix, "");

        break;

    case 'i':
        mutt_format_s(dest,
                      destlen,
                      prefix,
                      hdr->env->message_id ? hdr->env->message_id : "<no.id>");
        break;

    case 'l':

        if (!optional) {
            snprintf(fmt,  sizeof(fmt), "%%%sd", prefix);
            snprintf(dest, destlen,     fmt,     (int)hdr->lines);
        } else if (hdr->lines <= 0)
            optional = 0;
        break;

    case 'L':

        if (!optional) {
            make_from(hdr->env, buf2, sizeof(buf2), 1);
            mutt_format_s(dest, destlen, prefix, buf2);
        } else if (!check_for_mailing_list(hdr->env->to, NULL, NULL, 0)
                   && !check_for_mailing_list(hdr->env->cc, NULL, NULL, 0)) {
            optional = 0;
        }
        break;

    case 'm':

        if (ctx) {
            snprintf(fmt,  sizeof(fmt), "%%%sd", prefix);
            snprintf(dest, destlen,     fmt,     ctx->msgcount);
        } else
            strfcpy(dest, "(null)", destlen);
        break;

    case 'n':
        mutt_format_s(dest, destlen, prefix, mutt_get_name(hdr->env->from));
        break;

    case 'N':

        if (!optional) {
            snprintf(fmt,  sizeof(fmt), "%%%sd", prefix);
            snprintf(dest, destlen,     fmt,     hdr->score);
        } else {
            if (hdr->score == 0)
                optional = 0;
        }
        break;

    case 'O':

        if (!optional) {
            make_from_addr(hdr->env, buf2, sizeof(buf2), 1);

            if (!globals.has_option(OPTSAVEADDRESS) && (p = strpbrk(buf2, "%@")))
                *p = 0;
            mutt_format_s(dest, destlen, prefix, buf2);
        } else if (!check_for_mailing_list_addr(hdr->env->to, NULL, 0)
                   && !check_for_mailing_list_addr(hdr->env->cc, NULL, 0)) {
            optional = 0;
        }
        break;

    case 'M':
        snprintf(fmt, sizeof(fmt), "%%%sd", prefix);

        if (!optional) {
            if (threads
                && is_index
                && hdr->collapsed
                && (hdr->num_hidden > 1))
                snprintf(dest, destlen, fmt, hdr->num_hidden);
            else if (is_index
                     && threads)
                mutt_format_s(dest, destlen, prefix, " ");
            else
                *dest = '\0';
        } else {
            if (!(threads
                  && is_index
                  && hdr->collapsed
                  && (hdr->num_hidden > 1)))
                optional = 0;
        }
        break;

    case 'P':
        strfcpy(dest, NONULL(hfi->pager_progress), destlen);
        break;

    case 's':

        if (flags & M_FORMAT_TREE
            && !hdr->collapsed) {
            if (flags & M_FORMAT_FORCESUBJ) {
                mutt_format_s(dest, destlen, "", NONULL(hdr->env->subject));
                snprintf(buf2, sizeof(buf2), "%s%s", hdr->tree, dest);
                mutt_format_s_tree(dest, destlen, prefix, buf2);
            } else
                mutt_format_s_tree(dest, destlen, prefix, hdr->tree);
        } else
            mutt_format_s(dest, destlen, prefix, NONULL(hdr->env->subject));
        break;

    case 'S':

        if (hdr->deleted)
            ch = 'D';
        else if (hdr->attach_del)
            ch = 'd';
        else if (hdr->tagged)
            ch = '*';
        else if (hdr->flagged)
            ch = '!';
        else if (hdr->replied)
            ch = 'r';
        else if (hdr->read
                 && (ctx
                     && (ctx->msgnotreadyet != hdr->msgno)))
            ch = '-';
        else if (hdr->old)
            ch = 'O';
        else
            ch = 'N';

        /* FOO - this is probably unsafe, but we are not likely to have such
           a short string passed into this routine */
        *dest = ch;
        *(dest + 1) = 0;
        break;

    case 't':
        buf2[0] = 0;

        if (!check_for_mailing_list(hdr->env->to, "To ", buf2, sizeof(buf2))
            && !check_for_mailing_list(hdr->env->cc, "Cc ", buf2,
                                       sizeof(buf2))) {
            if (hdr->env->to)
                snprintf(buf2, sizeof(buf2), "To %s", mutt_get_name(
                             hdr->env->to));
            else if (hdr->env->cc)
                snprintf(buf2, sizeof(buf2), "Cc %s", mutt_get_name(
                             hdr->env->cc));
        }
        mutt_format_s(dest, destlen, prefix, buf2);
        break;

    case 'T':
        snprintf(fmt,  sizeof(fmt), "%%%sc", prefix);
        snprintf(dest, destlen,     fmt,
                 (Tochars
                  && ((i = mutt_user_is_recipient(hdr))) < mutt_strlen(
                      Tochars)) ? Tochars[i] : ' ');
        break;

    case 'u':

        if (hdr->env->from
            && hdr->env->from->mailbox) {
            strfcpy(buf2, mutt_addr_for_display(hdr->env->from), sizeof(buf2));

            if ((p = strpbrk(buf2, "%@")))
                *p = 0;
        } else
            buf2[0] = 0;
        mutt_format_s(dest, destlen, prefix, buf2);
        break;

    case 'v':

        if (mutt_addr_is_user(hdr->env->from)) {
            if (hdr->env->to)
                mutt_format_s(buf2, sizeof(buf2), prefix,
                              mutt_get_name(hdr->env->to));
            else if (hdr->env->cc)
                mutt_format_s(buf2, sizeof(buf2), prefix,
                              mutt_get_name(hdr->env->cc));
            else
                *buf2 = 0;
        } else
            mutt_format_s(buf2, sizeof(buf2), prefix,
                          mutt_get_name(hdr->env->from));

        if ((p = strpbrk(buf2, " %@")))
            *p = 0;
        mutt_format_s(dest, destlen, prefix, buf2);
        break;

    case 'Z':

        ch = ' ';

        if (WithCrypto
            && hdr->security & GOODSIGN)
            ch = 'S';
        else if (WithCrypto
                 && hdr->security & ENCRYPT)
            ch = 'P';
        else if (WithCrypto
                 && hdr->security & SIGN)
            ch = 's';
        else if ((WithCrypto & APPLICATION_PGP)
                 && hdr->security & PGPKEY)
            ch = 'K';

        snprintf(buf2, sizeof(buf2),
                 "%c%c%c", (THREAD_NEW ? 'n' : (THREAD_OLD ? 'o' :
                                                ((hdr->read
                                                  && (ctx
                                                      && ctx->msgnotreadyet !=
                                                      hdr->msgno))
                                                 ? (hdr->replied ? 'r' : ' ') : (
                                                     hdr->old ? 'O' : 'N')))),
                 hdr->deleted ? 'D' : (hdr->attach_del ? 'd' : ch),
                 hdr->tagged ? '*' :
                 (hdr->flagged ? '!' :
                  (Tochars
                   && ((i = mutt_user_is_recipient(hdr)) <
                       mutt_strlen(Tochars)) ? Tochars[i] : ' ')));
        mutt_format_s(dest, destlen, prefix, buf2);
        break;

    case 'X':
    {
        int count = mutt_count_body_parts(ctx, hdr);

        /* The recursion allows messages without depth to return 0. */
        if (optional)
            optional = count != 0;

        snprintf(fmt,  sizeof(fmt), "%%%sd", prefix);
        snprintf(dest, destlen,     fmt,     count);
        break;
    }

    case 'y':

        if (optional)
            optional = hdr->env->x_label ? 1 : 0;

        mutt_format_s(dest, destlen, prefix, NONULL(hdr->env->x_label));
        break;

    case 'Y':

        if (hdr->env->x_label) {
            i = 1; /* reduce reuse recycle */
            htmp = NULL;

            if (flags & M_FORMAT_TREE
                && (hdr->thread->prev
                    && hdr->thread->prev->message
                    && hdr->thread->prev->message->env->x_label))
                htmp = hdr->thread->prev->message;
            else if (flags & M_FORMAT_TREE
                     && (hdr->thread->parent
                         && hdr->thread->parent->message
                         && hdr->thread->parent->message->env->x_label))
                htmp = hdr->thread->parent->message;

            if (htmp
                && (mutt_strcasecmp(hdr->env->x_label,
                                    htmp->env->x_label) == 0))
                i = 0;
        } else
            i = 0;

        if (optional)
            optional = i;

        if (i)
            mutt_format_s(dest, destlen, prefix, NONULL(hdr->env->x_label));
        else
            mutt_format_s(dest, destlen, prefix, "");

        break;

    default:
        snprintf(dest, destlen, "%%%s%c", prefix, op);
        break;
    }

    if (optional)
        mutt_FormatString(dest, destlen, col, ifstring, hdr_format_str,
                          (unsigned long)hfi, flags);
    else if (flags & M_FORMAT_OPTIONAL)
        mutt_FormatString(dest, destlen, col, elsestring, hdr_format_str,
                          (unsigned long)hfi, flags);

    return src;

#undef THREAD_NEW
#undef THREAD_OLD
}
Example #16
0
static const char * sidebar_format_str(char *dest,
                                       size_t destlen,
                                       size_t col,
                                       char op,
                                       const char *src,
                                       const char *prefix,
                                       const char *ifstring,
                                       const char *elsestring,
                                       unsigned long data,
                                       format_flag flags)
{
    /* casting from unsigned long - srsly?! */
    struct sidebar_entry *sbe = (struct sidebar_entry *)data;
    unsigned int optional;
    char fmt[SHORT_STRING], buf[SHORT_STRING];

    optional = flags & M_FORMAT_OPTIONAL;

    switch (op) {
    case 'F':

        if (!optional) {
            snprintf(fmt,  sizeof(fmt), "%%%sd", prefix);
            snprintf(dest, destlen,     fmt,     sbe->flagged);
        } else if (sbe->flagged == 0) {
            optional = 0;
        }
        break;

    case '!':

        if (sbe->flagged == 0)
            mutt_format_s(dest, destlen, prefix, "");

        if (sbe->flagged == 1)
            mutt_format_s(dest, destlen, prefix, "!");

        if (sbe->flagged == 2)
            mutt_format_s(dest, destlen, prefix, "!!");

        if (sbe->flagged > 2) {
            snprintf(buf, sizeof(buf), "%d!", sbe->flagged);
            mutt_format_s(dest, destlen, prefix, buf);
        }
        break;

    case 'S':
        snprintf(fmt,  sizeof(fmt), "%%%sd", prefix);
        snprintf(dest, destlen,     fmt,     sbe->size);
        break;

    case 'N':

        if (!optional) {
            snprintf(fmt,  sizeof(fmt), "%%%sd", prefix);
            snprintf(dest, destlen, fmt, sbe->new_messages);
        } else if (sbe->new_messages == 0) {
            optional = 0;
        }
        break;

    case 'B':
        mutt_format_s(dest, destlen, prefix, sbe->box);
        break;
    }

    if (optional)
        mutt_FormatString(dest, destlen, col, ifstring, sidebar_format_str,
                          (unsigned long)sbe, flags);
    else if (flags & M_FORMAT_OPTIONAL)
        mutt_FormatString(dest, destlen, col, elsestring, sidebar_format_str,
                          (unsigned long)sbe, flags);

    return src;
}
Example #17
0
File: smime.c Project: 0xAX/muttx
static const char *_mutt_fmt_smime_command(char *dest,
					    size_t destlen,
					    size_t col,
					    char op,
					    const char *src,
					    const char *prefix,
					    const char *ifstring,
					    const char *elsestring,
					    unsigned long data,
					    format_flag flags)
{
	char fmt[16];
	struct smime_command_context *cctx =(struct smime_command_context *) data;
	int optional =(flags & M_FORMAT_OPTIONAL);

	switch(op)
	{
	case 'C':
	{
		if (!optional)
		{
			char path[_POSIX_PATH_MAX];
			char buf1[LONG_STRING], buf2[LONG_STRING];
			struct stat sb;

			strfcpy(path, NONULL(SmimeCALocation), sizeof(path));
			mutt_expand_path(path, sizeof(path));
			mutt_quote_filename(buf1, sizeof(buf1), path);

			if (stat(path, &sb) != 0 || !S_ISDIR(sb.st_mode))
				snprintf(buf2, sizeof(buf2), "-CAfile %s", buf1);
			else
				snprintf(buf2, sizeof(buf2), "-CApath %s", buf1);

			snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
			snprintf(dest, destlen, fmt, buf2);
		}
		else if (!SmimeCALocation)
			optional = 0;
		break;
	}

	case 'c':
	{           /* certificate(list) */
		if (!optional) {
			snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
			snprintf(dest, destlen, fmt, NONULL(cctx->certificates));
		}
		else if (!cctx->certificates)
			optional = 0;
		break;
	}

	case 'i':
	{           /* intermediate certificates  */
		if (!optional) {
			snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
			snprintf(dest, destlen, fmt, NONULL(cctx->intermediates));
		}
		else if (!cctx->intermediates)
			optional = 0;
		break;
	}

	case 's':
	{           /* detached signature */
		if (!optional)
		{
			snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
			snprintf(dest, destlen, fmt, NONULL(cctx->sig_fname));
		}
		else if (!cctx->sig_fname)
			optional = 0;
		break;
	}

	case 'k':
	{           /* private key */
		if (!optional)
		{
			snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
			snprintf(dest, destlen, fmt, NONULL(cctx->key));
		}
		else if (!cctx->key)
			optional = 0;
		break;
	}

	case 'a':
	{           /* algorithm for encryption */
		if (!optional) {
			snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
			snprintf(dest, destlen, fmt, NONULL(cctx->cryptalg));
		}
		else if (!cctx->key)
			optional = 0;
		break;
	}

	case 'f':
	{           /* file to process */
		if (!optional)
		{
			snprintf(fmt, sizeof(fmt), "%%%ss", prefix);
			snprintf(dest, destlen, fmt, NONULL(cctx->fname));
		}
		else if (!cctx->fname)
			optional = 0;
		break;
	}

	default:
		*dest = '\0';
		break;
	}

	if (optional)
		mutt_FormatString(dest, destlen, col, ifstring, _mutt_fmt_smime_command,
				   data, 0);
	else if (flags & M_FORMAT_OPTIONAL)
		mutt_FormatString(dest, destlen, col, elsestring, _mutt_fmt_smime_command,
				   data, 0);

	return(src);
}
Example #18
0
const char *_mutt_fmt_pgp_command (char *dest,
                                   size_t destlen,
                                   char op,
                                   const char *src,
                                   const char *prefix,
                                   const char *ifstring,
                                   const char *elsestring,
                                   unsigned long data, format_flag flags)
{
  char fmt[16];
  struct pgp_command_context *cctx = (struct pgp_command_context *) data;
  int optional = (flags & M_FORMAT_OPTIONAL);

  switch (op) {
  case 'r':
    {
      if (!optional) {
        snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
        snprintf (dest, destlen, fmt, NONULL (cctx->ids));
      }
      else if (!cctx->ids)
        optional = 0;
      break;
    }

  case 'a':
    {
      if (!optional) {
        snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
        snprintf (dest, destlen, fmt, NONULL (cctx->signas));
      }
      else if (!cctx->signas)
        optional = 0;
      break;
    }

  case 's':
    {
      if (!optional) {
        snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
        snprintf (dest, destlen, fmt, NONULL (cctx->sig_fname));
      }
      else if (!cctx->sig_fname)
        optional = 0;
      break;
    }

  case 'f':
    {
      if (!optional) {
        snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
        snprintf (dest, destlen, fmt, NONULL (cctx->fname));
      }
      else if (!cctx->fname)
        optional = 0;
      break;
    }

  case 'p':
    {
      if (!optional) {
        snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
        snprintf (dest, destlen, fmt,
                  cctx->need_passphrase ? "PGPPASSFD=0" : "");
      }
      else if (!cctx->need_passphrase || pgp_use_gpg_agent ())
        optional = 0;
      break;
    }
  default:
    {
      *dest = '\0';
      break;
    }
  }

  if (optional)
    mutt_FormatString (dest, destlen, ifstring, _mutt_fmt_pgp_command, data,
                       0);
  else if (flags & M_FORMAT_OPTIONAL)
    mutt_FormatString (dest, destlen, elsestring, _mutt_fmt_pgp_command, data,
                       0);

  return (src);
}
Example #19
0
File: smime.c Project: 0xAX/muttx
static void mutt_smime_command(char *d, size_t dlen,
				struct smime_command_context *cctx, const char *fmt)
{
	mutt_FormatString(d, dlen, 0, NONULL(fmt), _mutt_fmt_smime_command,
			  (unsigned long) cctx, 0);
}
Example #20
0
static const char *mix_entry_fmt (char *dest,
				  size_t destlen,
				  size_t col,
                                  int cols,
				  char op,
				  const char *src,
				  const char *prefix,
				  const char *ifstring,
				  const char *elsestring,
				  unsigned long data,
				  format_flag flags)
{
  char fmt[16];
  REMAILER *remailer = (REMAILER *) data;
  int optional = (flags & MUTT_FORMAT_OPTIONAL);

  switch (op)
  {
    case 'n':
      if (!optional)
      {
	snprintf (fmt, sizeof (fmt), "%%%sd", prefix);
	snprintf (dest, destlen, fmt, remailer->num);
      }
      break;
    case 'c':
      if (!optional)
      {
	snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
	snprintf (dest, destlen, fmt, mix_format_caps(remailer));
      }
      break;
    case 's':
      if (!optional)
      {
	snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
	snprintf (dest, destlen, fmt, NONULL(remailer->shortname));
      }
      else if (!remailer->shortname)
        optional = 0;
      break;
    case 'a':
      if (!optional)
      {
	snprintf (fmt, sizeof (fmt), "%%%ss", prefix);
	snprintf (dest, destlen, fmt, NONULL(remailer->addr));
      }
      else if (!remailer->addr)
        optional = 0;
      break;
    
    default:
      *dest = '\0';
  }

  if (optional)
    mutt_FormatString (dest, destlen, col, cols, ifstring, mutt_attach_fmt, data, 0);
  else if (flags & MUTT_FORMAT_OPTIONAL)
    mutt_FormatString (dest, destlen, col, cols, elsestring, mutt_attach_fmt, data, 0);
  return (src);
}
void mutt_FormatString (char *dest,		/* output buffer */
			size_t destlen,		/* output buffer len */
			const char *src,	/* template string */
			format_t *callback,	/* callback for processing */
			unsigned long data,	/* callback data */
			format_flag flags)	/* callback flags */
{
  char prefix[SHORT_STRING], buf[LONG_STRING], *cp, *wptr = dest, ch;
  char ifstring[SHORT_STRING], elsestring[SHORT_STRING];
  size_t wlen, count, len;

  destlen--; /* save room for the terminal \0 */
  wlen = (flags & M_FORMAT_ARROWCURSOR && option (OPTARROWCURSOR)) ? 3 : 0;
    
  while (*src && wlen < destlen)
  {
    if (*src == '%')
    {
      if (*++src == '%')
      {
	*wptr++ = '%';
	wlen++;
	src++;
	continue;
      }

      if (*src == '?')
      {
	flags |= M_FORMAT_OPTIONAL;
	src++;
      }
      else
      {
	flags &= ~M_FORMAT_OPTIONAL;

	/* eat the format string */
	cp = prefix;
	count = 0;
	while (count < sizeof (prefix) &&
	       (isdigit ((unsigned char) *src) || *src == '.' || *src == '-'))
	{
	  *cp++ = *src++;
	  count++;
	}
	*cp = 0;
      }

      if (!*src)
	break; /* bad format */

      ch = *src++; /* save the character to switch on */

      if (flags & M_FORMAT_OPTIONAL)
      {
        if (*src != '?')
          break; /* bad format */
        src++;

        /* eat the `if' part of the string */
        cp = ifstring;
	count = 0;
        while (count < sizeof (ifstring) && *src && *src != '?' && *src != '&')
	{
          *cp++ = *src++;
	  count++;
	}
        *cp = 0;

	/* eat the `else' part of the string (optional) */
	if (*src == '&')
	  src++; /* skip the & */
	cp = elsestring;
	count = 0;
	while (count < sizeof (elsestring) && *src && *src != '?')
	{
	  *cp++ = *src++;
	  count++;
	}
	*cp = 0;

	if (!*src)
	  break; /* bad format */

        src++; /* move past the trailing `?' */
      }

      /* handle generic cases first */
      if (ch == '>')
      {
	/* right justify to EOL */
	ch = *src++; /* pad char */
	/* calculate space left on line.  if we've already written more data
	   than will fit on the line, ignore the rest of the line */
	count = (COLS < destlen ? COLS : destlen);
	if (count > wlen)
	{
	  count -= wlen; /* how many chars left on this line */
	  mutt_FormatString (buf, sizeof (buf), src, callback, data, flags);
	  len = mutt_strlen (buf);
	  if (count > len)
	  {
	    count -= len; /* how many chars to pad */
	    memset (wptr, ch, count);
	    wptr += count;
	    wlen += count;
	  }
	  if (len + wlen > destlen)
	    len = destlen - wlen;
	  memcpy (wptr, buf, len);
	  wptr += len;
	  wlen += len;
	}
	break; /* skip rest of input */
      }
      else if (ch == '|')
      {
	/* pad to EOL */
	ch = *src++;
	if (destlen > COLS)
	  destlen = COLS;
	if (destlen > wlen)
	{
	  count = destlen - wlen;
	  memset (wptr, ch, count);
	  wptr += count;
	}
	break; /* skip rest of input */
      }
      else
      {
	short tolower =  0;
	
	if (ch == '_')
	{
	  ch = *src++;
	  tolower = 1;
	}
	
	/* use callback function to handle this case */
	src = callback (buf, sizeof (buf), ch, src, prefix, ifstring, elsestring, data, flags);

	if (tolower)
	  mutt_strlower (buf);
	
	if ((len = mutt_strlen (buf)) + wlen > destlen)
	  len = (destlen - wlen > 0) ? (destlen - wlen) : 0;

	memcpy (wptr, buf, len);
	wptr += len;
	wlen += len;
      }
    }
    else if (*src == '\\')
    {
      if (!*++src)
	break;
      switch (*src)
      {
	case 'n':
	  *wptr = '\n';
	  break;
	case 't':
	  *wptr = '\t';
	  break;
	case 'r':
	  *wptr = '\r';
	  break;
	case 'f':
	  *wptr = '\f';
	  break;
	case 'v':
	  *wptr = '\v';
	  break;
	default:
	  *wptr = *src;
	  break;
      }
      src++;
      wptr++;
      wlen++;
    }
    else
    {
      *wptr++ = *src++;
      wlen++;
    }
  }
  *wptr = 0;

  if (flags & M_FORMAT_MAKEPRINT)
  {
    /* Make sure that the string is printable by changing all non-printable
       chars to dots, or spaces for non-printable whitespace */
    for (cp = dest ; *cp ; cp++)
      if (!IsPrint (*cp) &&
	  !((flags & M_FORMAT_TREE) && (*cp <= M_TREE_MAX)))
	*cp = isspace ((unsigned char) *cp) ? ' ' : '.';
  }
}
Example #22
0
void mutt_pgp_command (char *d, size_t dlen, struct pgp_command_context *cctx, const char *fmt)
{
  mutt_FormatString (d, dlen, 0, MuttIndexWindow->cols, NONULL (fmt), _mutt_fmt_pgp_command, (unsigned long) cctx, 0);
  dprint (2, (debugfile, "mutt_pgp_command: %s\n", d));
}