#include <grp.h>
#include <pwd.h>
-#include <utime.h>
#include <lib-mime/mime.h>
#include <lib-ui/curses.h>
*/
void mutt_adv_mktemp (const char* dir, char *s, ssize_t l)
{
- char buf[_POSIX_PATH_MAX];
- char tmp[_POSIX_PATH_MAX];
- char *period;
- ssize_t sl;
- struct stat sb;
-
- m_strcpy(buf, sizeof(buf), m_strisempty(dir) ? NONULL(Tempdir) : dir);
- mutt_expand_path (buf, sizeof (buf));
- if (s[0] == '\0') {
- snprintf (s, l, "%s/muttXXXXXX", buf);
- mktemp (s);
- }
- else {
- m_strcpy(tmp, sizeof(tmp), s);
- mutt_sanitize_filename (tmp, 1);
- snprintf (s, l, "%s/%s", buf, tmp);
- if (lstat (s, &sb) == -1 && errno == ENOENT)
- return;
- if ((period = strrchr (tmp, '.')) != NULL)
- *period = 0;
- snprintf (s, l, "%s/%s.XXXXXX", buf, tmp);
- mktemp (s);
- if (period != NULL) {
- *period = '.';
- sl = m_strlen(s);
- m_strcpy(s + sl, l - sl, period);
- }
- }
-}
-
-/* create a send-mode duplicate from a receive-mode body */
-
-int mutt_copy_body (FILE * fp, BODY ** tgt, BODY * src)
-{
- char tmp[_POSIX_PATH_MAX];
- BODY *b;
+ int fd;
- parameter_t *par, **ppar;
-
- short use_disp;
-
- if (src->filename) {
- use_disp = 1;
- m_strcpy(tmp, sizeof(tmp), src->filename);
- }
- else {
- use_disp = 0;
- tmp[0] = '\0';
- }
-
- mutt_adv_mktemp (NULL, tmp, sizeof (tmp));
- if (mutt_save_attachment (fp, src, tmp, 0, NULL) == -1)
- return -1;
-
- *tgt = body_new();
- b = *tgt;
-
- memcpy (b, src, sizeof (BODY));
- b->parts = NULL;
- b->next = NULL;
-
- b->filename = m_strdup(tmp);
- b->use_disp = use_disp;
- b->unlink = 1;
-
- if (mutt_is_text_part (b))
- b->noconv = 1;
-
- b->xtype = m_strdup(b->xtype);
- b->subtype = m_strdup(b->subtype);
- b->form_name = m_strdup(b->form_name);
- b->filename = m_strdup(b->filename);
- b->d_filename = m_strdup(b->d_filename);
- b->description = m_strdup(b->description);
-
- /*
- * we don't seem to need the HEADER structure currently.
- * XXX - this may change in the future
- */
-
- if (b->hdr)
- b->hdr = NULL;
-
- /* copy parameters */
- for (par = b->parameter, ppar = &b->parameter; par;
- ppar = &(*ppar)->next, par = par->next) {
- *ppar = parameter_new();
- (*ppar)->attribute = m_strdup(par->attribute);
- (*ppar)->value = m_strdup(par->value);
- }
-
- mutt_stamp_attachment (b);
-
- return 0;
+ fd = m_tempfd(s, l, m_strisempty(dir) ? NONULL(Tempdir) : dir, s);
+ if (fd < 0) {
+ *s = '\0';
+ } else {
+ close(fd);
+ unlink(s);
+ }
}
/* returns true if the header contained in "s" is in list "t" */
return m_strcpy(s, slen, tmp);
}
-void mutt_mktemp (char *s)
+void mutt_mktemp(char *s)
{
-
- snprintf (s, _POSIX_PATH_MAX, "%s/madmutt-%s-%d-%d-%d-%x%x", NONULL (Tempdir),
- NONULL (Hostname), (int) getuid (), (int) getpid (), Counter++,
- (unsigned int) rand(), (unsigned int) rand());
- unlink (s);
+ int fd = m_tempfd(s, _POSIX_PATH_MAX, NONULL(Tempdir), NULL);
+ if (fd < 0) {
+ *s = '\0';
+ } else {
+ close(fd);
+ unlink(s);
+ }
}
/* collapse the pathname using ~ or = when possible */
/* if s is an url, only collapse path component */
if (scheme != U_UNKNOWN) {
p = strchr (s, ':') + 1;
- if (!strncmp (p, "//", 2))
+ if (!m_strncmp (p, "//", 2))
q = strchr (p + 2, '/');
if (!q)
q = strchr (p, '\0');
}
}
-void mutt_pretty_size (char *s, ssize_t len, long n)
-{
- if (n == 0)
- m_strcpy(s, len, "0K");
- else if (n < 10189) /* 0.1K - 9.9K */
- snprintf (s, len, "%3.1fK", (n < 103) ? 0.1 : n / 1024.0);
- else if (n < 1023949) { /* 10K - 999K */
- /* 51 is magic which causes 10189/10240 to be rounded up to 10 */
- snprintf (s, len, "%ldK", (n + 51) / 1024);
- }
- else if (n < 10433332) /* 1.0M - 9.9M */
- snprintf (s, len, "%3.1fM", n / 1048576.0);
- else { /* 10M+ */
-
- /* (10433332 + 52428) / 1048576 = 10 */
- snprintf (s, len, "%ldM", (n + 52428) / 1048576);
- }
-}
-
-void mutt_expand_file_fmt(char *dest, ssize_t destlen,
- const char *fmt, const char *src)
-{
- char tmp[LONG_STRING];
-
- mutt_quote_filename(tmp, sizeof(tmp), src);
- mutt_expand_fmt(dest, destlen, fmt, tmp);
-}
-
-void mutt_expand_fmt(char *dst, ssize_t dlen,
- const char *fmt, const char *src)
-{
- ssize_t pos = 0;
- int found = 0;
-
- while (*fmt && pos < dlen - 1) {
- if (*fmt == '%') {
- switch (*++fmt) {
- case 's':
- found = 1;
- pos += m_strcpy(dst + pos, dlen - pos, src);
- break;
-
- case '%':
- dst[pos++] = *fmt++;
- break;
-
- default:
- dst[pos++] = '%';
- break;
- }
- } else {
- dst[pos++] = *fmt++;
- }
- }
-
- dst[pos] = '\0';
- if (!found) {
- pos += m_strcpy(dst + pos, dlen - pos, " ");
- pos += m_strcpy(dst + pos, dlen - pos, src);
- }
-}
-
/* return 0 on success, -1 on abort, 1 on error */
int mutt_check_overwrite (const char *attname, const char *path,
char *fname, ssize_t flen, int *append,
}
}
else
- if ((rc =
- mutt_yesorno (_("File is a directory, save under it?"),
- M_YES)) != M_YES)
+ if ((rc = mutt_yesorno(_("File is a directory, save under it?"),
+ M_YES)) != M_YES)
return (rc == M_NO) ? 1 : -1;
if (!attname || !attname[0]) {
}
}
-void mutt_FormatString (char *dest, /* output buffer */
- ssize_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];
- ssize_t wlen, wid, count, col, len;
-
- prefix[0] = '\0';
- destlen--; /* save room for the terminal \0 */
- wlen = (flags & M_FORMAT_ARROWCURSOR && option (OPTARROWCURSOR)) ? 3 : 0;
- col = wlen;
-
- while (*src && wlen < destlen) {
- if (*src == '%') {
- if (*++src == '%') {
- *wptr++ = '%';
- wlen++;
- col++;
- src++;
- continue;
- }
+ssize_t m_strformat(char *dst, ssize_t dlen, const char *fmt,
+ format_t *callback, unsigned long data, format_flag flags)
+{
+ ssize_t pos = (flags & M_FORMAT_ARROWCURSOR && option (OPTARROWCURSOR)) ? 3 : 0;
- if (*src == '?') {
- flags |= M_FORMAT_OPTIONAL;
- src++;
- }
- else {
- flags &= ~M_FORMAT_OPTIONAL;
-
- /* eat the format string */
- cp = prefix;
- count = 0;
- while (count < ssizeof (prefix) &&
- (isdigit ((unsigned char) *src) || *src == '.' || *src == '-'))
- {
- *cp++ = *src++;
- count++;
- }
- *cp = 0;
- }
+ while (*fmt) {
+ char ifstring[STRING], elsestring[STRING], prefix[STRING] = "";
+ int ch;
- if (!*src)
- break; /* bad format */
+ if (*fmt == '%') {
+ if (*++fmt == '%') {
+ pos += m_strputc(dst + pos, dlen - pos, *fmt++);
+ continue;
+ }
- ch = *src++; /* save the character to switch on */
+ if (*fmt == '?') {
+ flags |= M_FORMAT_OPTIONAL;
+ fmt++;
+ } else {
+ ssize_t pfxlen;
+ flags &= ~M_FORMAT_OPTIONAL;
- if (flags & M_FORMAT_OPTIONAL) {
- if (*src != '?')
- break; /* bad format */
- src++;
+ /* eat the format string */
+ pfxlen = strspn(fmt, "0123456789.-");
+ m_strncpy(prefix, sizeof(prefix), fmt, pfxlen);
+ fmt += pfxlen;
+ }
- /* eat the `if' part of the string */
- cp = ifstring;
- count = 0;
- while (count < ssizeof (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 < ssizeof (elsestring) && *src && *src != '?') {
- *cp++ = *src++;
- count++;
- }
- *cp = 0;
+ /* save the character to switch on */
+ if (!(ch = *fmt++))
+ break;
- if (!*src)
- break; /* bad format */
+ if (flags & M_FORMAT_OPTIONAL) {
+ ssize_t iflen;
+ const char *p;
- src++; /* move past the trailing `?' */
- }
+ if (*fmt++ != '?')
+ break; /* bad format */
- /* 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 */
- if (DrawFullLine || option (OPTSTATUSONTOP))
- count = (COLS < destlen ? COLS : destlen);
- else
- count = ((COLS - SW) < destlen ? (COLS - SW) : destlen);
- if (count > col) {
- count -= col; /* how many columns left on this line */
- mutt_FormatString (buf, sizeof (buf), src, callback, data, flags);
- wid = m_strlen(buf);
- if (count > wid) {
- count -= wid; /* how many chars to pad */
- memset (wptr, ch, count);
- wptr += count;
- col += count;
- }
- if (wid + wlen > destlen)
- len = destlen - wlen;
- else
- len = wid;
- memcpy (wptr, buf, len);
- wptr += len;
- wlen += len;
- col += mutt_strwidth (buf);
- }
- 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 lower = 0;
- short nodots = 0;
+ /* eat the `if' part of the string */
+ iflen = strcspn(fmt, "?&");
+ m_strncpy(ifstring, ssizeof(ifstring), fmt, iflen);
+ fmt += iflen;
- while (ch == '_' || ch == ':') {
- if (ch == '_')
- lower = 1;
- else if (ch == ':')
- nodots = 1;
+ /* eat the `else' part of the string (optional) */
+ if (*fmt == '&')
+ fmt++; /* skip the & */
- ch = *src++;
- }
+ p = m_strchrnul(fmt, '?');
+ m_strncpy(elsestring, ssizeof(elsestring), fmt, p - fmt);
+ fmt = p;
- /* use callback function to handle this case */
- src =
- callback (buf, sizeof (buf), ch, src, prefix, ifstring, elsestring,
- data, flags);
+ if (!*fmt++) /* move past the trailing `?' */
+ break; /* bad format */
+ } else {
+ *ifstring = *elsestring = '\0';
+ }
+
+ switch (ch) {
+ ssize_t col;
+ char lower, nodots, buf[LONG_STRING];
+
+ case '>': /* right justify to EOL */
+ col = mutt_strwidth(dst);
+
+ ch = *fmt++; /* pad char */
+
+ if (COLS - SW > col) {
+ m_strformat(buf, sizeof(buf), fmt, callback, data, flags);
+ pos += m_strpad(dst + pos, dlen - pos, ch,
+ COLS - SW - col - mutt_strwidth(buf));
+ pos += m_strcpy(dst + pos, dlen - pos, buf);
+ }
+ return pos; /* skip rest of input */
+
+ case '|':
+ col = mutt_strwidth(dst);
- if (lower)
- m_strtolower(buf);
- if (nodots) {
- char *p = buf;
+ ch = *fmt++;
+ /* pad to EOL */
+ pos += m_strpad(dst + pos, dlen - pos, ch, COLS - SW - col);
+ return pos; /* skip rest of input */
- for (; *p; p++)
- if (*p == '.')
- *p = '_';
+ default:
+ lower = nodots = 0;
+
+ while (ch == '_' || ch == ':') {
+ lower |= ch == '_';
+ nodots |= ch == ':';
+ ch = *fmt++;
+ }
+
+ /* use callback function to handle this case */
+ fmt = callback(buf, sizeof (buf), ch, fmt, prefix,
+ ifstring, elsestring, data, flags);
+
+ if (lower)
+ m_strtolower(buf);
+
+ if (nodots) {
+ char *p;
+
+ for (p = buf; *p; p++) {
+ if (*p == '.')
+ *p = '_';
+ }
+ }
+
+ pos += m_strcpy(dst + pos, dlen - pos, buf);
+ break;
+ }
+ continue;
}
- if ((len = m_strlen(buf)) + wlen > destlen)
- len = (destlen - wlen > 0) ? (destlen - wlen) : 0;
+ if (*fmt == '\\') {
+ if (!*++fmt)
+ break;
+ switch ((ch = *fmt++)) {
+ case 'n': pos += m_strputc(dst + pos, dlen - pos, '\n'); break;
+ case 't': pos += m_strputc(dst + pos, dlen - pos, '\t'); break;
+ case 'r': pos += m_strputc(dst + pos, dlen - pos, '\r'); break;
+ case 'f': pos += m_strputc(dst + pos, dlen - pos, '\f'); break;
+ case 'v': pos += m_strputc(dst + pos, dlen - pos, '\v'); break;
+ default: pos += m_strputc(dst + pos, dlen - pos, ch); break;
+ }
+ } else {
+ ssize_t len = strcspn(fmt, "%\\");
- memcpy (wptr, buf, len);
- wptr += len;
- wlen += len;
- col += mutt_strwidth (buf);
- }
- }
- 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++;
- col++;
+ pos += m_strncpy(dst + pos, dlen - pos, fmt, len);
+ fmt += len;
+ }
}
- else {
- unsigned int bar = strcspn(src, "%\\");
- char *bar2 = p_dupstr(src, bar);
- while (bar--) {
- *wptr++ = *src++;
- wlen++;
- }
- col += mutt_strwidth (bar2);
- p_delete(&bar2);
- }
- }
- *wptr = 0;
-
-#if 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) ? ' ' : '.';
- }
-#endif
+ return pos;
}
/* returns 0 if OK to proceed, -1 to abort, 1 to retry */
mutt_error (_("%s is not a mailbox!"), s);
return 1;
}
- }
- else {
+ } else {
if (magic != M_IMAP)
{
st->st_mtime = 0;
else if (rc == -1)
ret = -1;
}
- }
- else {
+ } else {
mutt_perror (s);
return 1;
}
sleep(MAX(s, SleepTime));
}
-/* Decrease a file's modification time by 1 second */
-time_t mutt_decrease_mtime (const char *f, struct stat *st)
-{
- struct utimbuf utim;
- struct stat _st;
- time_t mtime;
-
- if (!st) {
- if (stat (f, &_st) == -1)
- return -1;
- st = &_st;
- }
-
- if ((mtime = st->st_mtime) == time (NULL)) {
- mtime -= 1;
- utim.actime = mtime;
- utim.modtime = mtime;
- utime (f, &utim);
- }
-
- return mtime;
-}
-
const char *mutt_make_version (int full)
{
static char vstring[STRING];
return vstring;
}
-void mutt_free_spam_list (SPAM_LIST ** list)
-{
- SPAM_LIST *p;
-
- if (!list)
- return;
- while (*list) {
- p = *list;
- *list = (*list)->next;
- rx_delete(&p->rx);
- p_delete(&p->template);
- p_delete(&p);
- }
-}
-
-int mutt_match_spam_list (const char *s, SPAM_LIST * l, char *text, int x)
-{
- static regmatch_t *pmatch = NULL;
- static int nmatch = 0;
- int i, n, tlen;
- char *p;
-
- if (!s)
- return 0;
-
- tlen = 0;
-
- for (; l; l = l->next) {
- /* If this pattern needs more matches, expand pmatch. */
- if (l->nmatch > nmatch) {
- p_realloc(&pmatch, l->nmatch);
- nmatch = l->nmatch;
- }
-
- /* Does this pattern match? */
- if (regexec(l->rx->rx, s, l->nmatch, (regmatch_t *)pmatch, (int) 0) == 0)
- {
- /* Copy template into text, with substitutions. */
- for (p = l->template; *p;) {
- if (*p == '%') {
- n = atoi (++p); /* find pmatch index */
- while (isdigit ((unsigned char) *p))
- ++p; /* skip subst token */
- for (i = pmatch[n].rm_so; (i < pmatch[n].rm_eo) && (tlen < x); i++)
- text[tlen++] = s[i];
- }
- else {
- text[tlen++] = *p++;
- }
- }
- text[tlen] = '\0';
- return 1;
- }
- }
-
- return 0;
-}
-
/* return 1 if address lists are strictly identical */
static int mutt_cmp_addr (const address_t * a, const address_t * b)
{
if (!*tok->dptr)
return -1; /* premature end of token */
mutt_buffer_addch(dest,
- (ascii_toupper(*tok->dptr) - 'A' + 1) & 0x7f);
+ (toupper((unsigned char)*tok->dptr) - 'A' + 1) & 0x7f);
tok->dptr++;
break;
case 'r':
mutt_buffer_addch(dest, '\033');
} else
if (isalpha((unsigned char)ch)) {
- mutt_buffer_addch(dest, ascii_toupper(ch) - 'A' + 1);
+ mutt_buffer_addch(dest, toupper((unsigned char)ch) - 'A' + 1);
} else {
mutt_buffer_addch(dest, '^');
mutt_buffer_addch(dest, ch);
/* read line */
p_clear(&expn, 1);
expn.data = mutt_read_line(NULL, &expn.dsize, fp, &line);
- fclose(fp);
+ m_fclose(&fp);
mutt_wait_filter(pid);
/* if we got output, make a new string consiting of the shell ouptput
tok->dsize = expnlen + m_strlen(tok->dptr) + 1;
ptr = xmalloc(tok->dsize);
memcpy(ptr, expn.data, expnlen);
- strcpy(ptr + expnlen, tok->dptr); /* __STRCPY_CHECKED__ */
+ m_strcpy(ptr + expnlen, tok->dsize - expnlen, tok->dptr);
if (tok->destroy)
p_delete(&tok->data);
tok->data = ptr;
projects / apps / madmutt.git / blobdiff