mirror of
https://github.com/sheumann/hush.git
synced 2024-08-26 12:29:04 +00:00
355 lines
10 KiB
C
355 lines
10 KiB
C
/* vi: set sw=4 ts=4: */
|
|
/*
|
|
* makemime: create MIME-encoded message
|
|
* reformime: parse MIME-encoded message
|
|
*
|
|
* Copyright (C) 2008 by Vladimir Dronnikov <dronnikov@gmail.com>
|
|
*
|
|
* Licensed under GPLv2, see file LICENSE in this tarball for details.
|
|
*/
|
|
#include "libbb.h"
|
|
#include "mail.h"
|
|
|
|
/*
|
|
makemime -c type [-o file] [-e encoding] [-C charset] [-N name] \
|
|
[-a "Header: Contents"] file
|
|
-m [ type ] [-o file] [-e encoding] [-a "Header: Contents"] file
|
|
-j [-o file] file1 file2
|
|
@file
|
|
|
|
file: filename - read or write from filename
|
|
- - read or write from stdin or stdout
|
|
&n - read or write from file descriptor n
|
|
\( opts \) - read from child process, that generates [ opts ]
|
|
|
|
Options:
|
|
|
|
-c type - create a new MIME section from "file" with this
|
|
Content-Type: (default is application/octet-stream).
|
|
-C charset - MIME charset of a new text/plain section.
|
|
-N name - MIME content name of the new mime section.
|
|
-m [ type ] - create a multipart mime section from "file" of this
|
|
Content-Type: (default is multipart/mixed).
|
|
-e encoding - use the given encoding (7bit, 8bit, quoted-printable,
|
|
or base64), instead of guessing. Omit "-e" and use
|
|
-c auto to set Content-Type: to text/plain or
|
|
application/octet-stream based on picked encoding.
|
|
-j file1 file2 - join mime section file2 to multipart section file1.
|
|
-o file - write ther result to file, instead of stdout (not
|
|
allowed in child processes).
|
|
-a header - prepend an additional header to the output.
|
|
|
|
@file - read all of the above options from file, one option or
|
|
value on each line.
|
|
*/
|
|
|
|
int makemime_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
|
int makemime_main(int argc UNUSED_PARAM, char **argv)
|
|
{
|
|
llist_t *opt_headers = NULL, *l;
|
|
const char *opt_output;
|
|
#define boundary opt_output
|
|
|
|
enum {
|
|
OPT_c = 1 << 0, // Content-Type:
|
|
OPT_e = 1 << 1, // Content-Transfer-Encoding. Ignored. Assumed base64
|
|
OPT_o = 1 << 2, // output to
|
|
OPT_C = 1 << 3, // charset
|
|
OPT_N = 1 << 4, // COMPAT
|
|
OPT_a = 1 << 5, // additional headers
|
|
OPT_m = 1 << 6, // COMPAT
|
|
OPT_j = 1 << 7, // COMPAT
|
|
};
|
|
|
|
INIT_G();
|
|
|
|
// parse options
|
|
opt_complementary = "a::";
|
|
opts = getopt32(argv,
|
|
"c:e:o:C:N:a:m:j:",
|
|
&G.content_type, NULL, &opt_output, &G.opt_charset, NULL, &opt_headers, NULL, NULL
|
|
);
|
|
//argc -= optind;
|
|
argv += optind;
|
|
|
|
// respect -o output
|
|
if (opts & OPT_o)
|
|
freopen(opt_output, "w", stdout);
|
|
|
|
// no files given on command line? -> use stdin
|
|
if (!*argv)
|
|
*--argv = (char *)"-";
|
|
|
|
// put additional headers
|
|
for (l = opt_headers; l; l = l->link)
|
|
puts(l->data);
|
|
|
|
// make a random string -- it will delimit message parts
|
|
srand(monotonic_us());
|
|
boundary = xasprintf("%d-%d-%d", rand(), rand(), rand());
|
|
|
|
// put multipart header
|
|
printf(
|
|
"Mime-Version: 1.0\n"
|
|
"Content-Type: multipart/mixed; boundary=\"%s\"\n"
|
|
, boundary
|
|
);
|
|
|
|
// put attachments
|
|
while (*argv) {
|
|
printf(
|
|
"\n--%s\n"
|
|
"Content-Type: %s; charset=%s\n"
|
|
"Content-Disposition: inline; filename=\"%s\"\n"
|
|
"Content-Transfer-Encoding: base64\n"
|
|
, boundary
|
|
, G.content_type
|
|
, G.opt_charset
|
|
, bb_get_last_path_component_strip(*argv)
|
|
);
|
|
encode_base64(*argv++, (const char *)stdin, "");
|
|
}
|
|
|
|
// put multipart footer
|
|
printf("\n--%s--\n" "\n", boundary);
|
|
|
|
return EXIT_SUCCESS;
|
|
#undef boundary
|
|
}
|
|
|
|
static const char *find_token(const char *const string_array[], const char *key, const char *defvalue)
|
|
{
|
|
const char *r = NULL;
|
|
for (int i = 0; string_array[i] != 0; i++) {
|
|
if (strcasecmp(string_array[i], key) == 0) {
|
|
r = (char *)string_array[i+1];
|
|
break;
|
|
}
|
|
}
|
|
return (r) ? r : defvalue;
|
|
}
|
|
|
|
static const char *xfind_token(const char *const string_array[], const char *key)
|
|
{
|
|
const char *r = find_token(string_array, key, NULL);
|
|
if (r)
|
|
return r;
|
|
bb_error_msg_and_die("header: %s", key);
|
|
}
|
|
|
|
enum {
|
|
OPT_x = 1 << 0,
|
|
OPT_X = 1 << 1,
|
|
#if ENABLE_FEATURE_REFORMIME_COMPAT
|
|
OPT_d = 1 << 2,
|
|
OPT_e = 1 << 3,
|
|
OPT_i = 1 << 4,
|
|
OPT_s = 1 << 5,
|
|
OPT_r = 1 << 6,
|
|
OPT_c = 1 << 7,
|
|
OPT_m = 1 << 8,
|
|
OPT_h = 1 << 9,
|
|
OPT_o = 1 << 10,
|
|
OPT_O = 1 << 11,
|
|
#endif
|
|
};
|
|
|
|
static int parse(const char *boundary, char **argv)
|
|
{
|
|
char *line, *s, *p;
|
|
const char *type;
|
|
int boundary_len = strlen(boundary);
|
|
const char *delims = " ;\"\t\r\n";
|
|
const char *uniq;
|
|
int ntokens;
|
|
const char *tokens[32]; // 32 is enough
|
|
|
|
// prepare unique string pattern
|
|
uniq = xasprintf("%%llu.%u.%s", (unsigned)getpid(), safe_gethostname());
|
|
|
|
//bb_info_msg("PARSE[%s]", terminator);
|
|
|
|
while ((line = xmalloc_fgets_str(stdin, "\r\n\r\n")) != NULL) {
|
|
|
|
// seek to start of MIME section
|
|
// N.B. to avoid false positives let us seek to the _last_ occurance
|
|
p = NULL;
|
|
s = line;
|
|
while ((s=strcasestr(s, "Content-Type:")) != NULL)
|
|
p = s++;
|
|
if (!p)
|
|
goto next;
|
|
//bb_info_msg("L[%s]", p);
|
|
|
|
// split to tokens
|
|
// TODO: strip of comments which are of form: (comment-text)
|
|
ntokens = 0;
|
|
tokens[ntokens] = NULL;
|
|
for (s = strtok(p, delims); s; s = strtok(NULL, delims)) {
|
|
tokens[ntokens] = s;
|
|
if (ntokens < ARRAY_SIZE(tokens) - 1)
|
|
ntokens++;
|
|
//bb_info_msg("L[%d][%s]", ntokens, s);
|
|
}
|
|
tokens[ntokens] = NULL;
|
|
//bb_info_msg("N[%d]", ntokens);
|
|
|
|
// analyse tokens
|
|
type = find_token(tokens, "Content-Type:", "text/plain");
|
|
//bb_info_msg("T[%s]", type);
|
|
if (0 == strncasecmp(type, "multipart/", 10)) {
|
|
if (0 == strcasecmp(type+10, "mixed")) {
|
|
parse(xfind_token(tokens, "boundary="), argv);
|
|
} else
|
|
bb_error_msg_and_die("no support of content type '%s'", type);
|
|
} else {
|
|
pid_t pid = pid;
|
|
int rc;
|
|
FILE *fp;
|
|
// fetch charset
|
|
const char *charset = find_token(tokens, "charset=", CONFIG_FEATURE_MIME_CHARSET);
|
|
// fetch encoding
|
|
const char *encoding = find_token(tokens, "Content-Transfer-Encoding:", "7bit");
|
|
// compose target filename
|
|
char *filename = (char *)find_token(tokens, "filename=", NULL);
|
|
if (!filename)
|
|
filename = xasprintf(uniq, monotonic_us());
|
|
else
|
|
filename = bb_get_last_path_component_strip(xstrdup(filename));
|
|
|
|
// start external helper, if any
|
|
if (opts & OPT_X) {
|
|
int fd[2];
|
|
xpipe(fd);
|
|
pid = vfork();
|
|
if (0 == pid) {
|
|
// child reads from fd[0]
|
|
xdup2(fd[0], STDIN_FILENO);
|
|
close(fd[0]); close(fd[1]);
|
|
xsetenv("CONTENT_TYPE", type);
|
|
xsetenv("CHARSET", charset);
|
|
xsetenv("ENCODING", encoding);
|
|
xsetenv("FILENAME", filename);
|
|
BB_EXECVP(*argv, argv);
|
|
_exit(EXIT_FAILURE);
|
|
}
|
|
// parent dumps to fd[1]
|
|
close(fd[0]);
|
|
fp = fdopen(fd[1], "w");
|
|
signal(SIGPIPE, SIG_IGN); // ignore EPIPE
|
|
// or create a file for dump
|
|
} else {
|
|
char *fname = xasprintf("%s%s", *argv, filename);
|
|
fp = xfopen_for_write(fname);
|
|
free(fname);
|
|
}
|
|
|
|
// housekeeping
|
|
free(filename);
|
|
|
|
// dump to fp
|
|
if (0 == strcasecmp(encoding, "base64")) {
|
|
decode_base64(stdin, fp);
|
|
} else if (0 != strcasecmp(encoding, "7bit")
|
|
&& 0 != strcasecmp(encoding, "8bit")) {
|
|
// quoted-printable, binary, user-defined are unsupported so far
|
|
bb_error_msg_and_die("no support of encoding '%s'", encoding);
|
|
} else {
|
|
// N.B. we have written redundant \n. so truncate the file
|
|
// The following weird 2-tacts reading technique is due to
|
|
// we have to not write extra \n at the end of the file
|
|
// In case of -x option we could truncate the resulting file as
|
|
// fseek(fp, -1, SEEK_END);
|
|
// if (ftruncate(fileno(fp), ftell(fp)))
|
|
// bb_perror_msg("ftruncate");
|
|
// But in case of -X we have to be much more careful. There is
|
|
// no means to truncate what we already have sent to the helper.
|
|
p = xmalloc_fgets_str(stdin, "\r\n");
|
|
while (p) {
|
|
if ((s = xmalloc_fgets_str(stdin, "\r\n")) == NULL)
|
|
break;
|
|
if ('-' == s[0] && '-' == s[1]
|
|
&& 0 == strncmp(s+2, boundary, boundary_len))
|
|
break;
|
|
fputs(p, fp);
|
|
p = s;
|
|
}
|
|
|
|
/*
|
|
while ((s = xmalloc_fgetline_str(stdin, "\r\n")) != NULL) {
|
|
if ('-' == s[0] && '-' == s[1]
|
|
&& 0 == strncmp(s+2, boundary, boundary_len))
|
|
break;
|
|
fprintf(fp, "%s\n", s);
|
|
}
|
|
// N.B. we have written redundant \n. so truncate the file
|
|
fseek(fp, -1, SEEK_END);
|
|
if (ftruncate(fileno(fp), ftell(fp)))
|
|
bb_perror_msg("ftruncate");
|
|
*/
|
|
}
|
|
fclose(fp);
|
|
|
|
// finalize helper
|
|
if (opts & OPT_X) {
|
|
signal(SIGPIPE, SIG_DFL);
|
|
// exit if helper exited >0
|
|
rc = wait4pid(pid);
|
|
if (rc)
|
|
return rc+20;
|
|
}
|
|
|
|
// check multipart finalized
|
|
if (s && '-' == s[2+boundary_len] && '-' == s[2+boundary_len+1]) {
|
|
free(line);
|
|
break;
|
|
}
|
|
}
|
|
next:
|
|
free(line);
|
|
}
|
|
|
|
//bb_info_msg("ENDPARSE[%s]", boundary);
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|
|
|
|
/*
|
|
Usage: reformime [options]
|
|
-d - parse a delivery status notification.
|
|
-e - extract contents of MIME section.
|
|
-x - extract MIME section to a file.
|
|
-X - pipe MIME section to a program.
|
|
-i - show MIME info.
|
|
-s n.n.n.n - specify MIME section.
|
|
-r - rewrite message, filling in missing MIME headers.
|
|
-r7 - also convert 8bit/raw encoding to quoted-printable, if possible.
|
|
-r8 - also convert quoted-printable encoding to 8bit, if possible.
|
|
-c charset - default charset for rewriting, -o, and -O.
|
|
-m [file] [file]... - create a MIME message digest.
|
|
-h "header" - decode RFC 2047-encoded header.
|
|
-o "header" - encode unstructured header using RFC 2047.
|
|
-O "header" - encode address list header using RFC 2047.
|
|
*/
|
|
|
|
int reformime_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
|
int reformime_main(int argc UNUSED_PARAM, char **argv)
|
|
{
|
|
const char *opt_prefix = "";
|
|
|
|
INIT_G();
|
|
|
|
// parse options
|
|
// N.B. only -x and -X are supported so far
|
|
opt_complementary = "x--X:X--x" USE_FEATURE_REFORMIME_COMPAT(":m::");
|
|
opts = getopt32(argv,
|
|
"x:X" USE_FEATURE_REFORMIME_COMPAT("deis:r:c:m:h:o:O:"),
|
|
&opt_prefix
|
|
USE_FEATURE_REFORMIME_COMPAT(, NULL, NULL, &G.opt_charset, NULL, NULL, NULL, NULL)
|
|
);
|
|
//argc -= optind;
|
|
argv += optind;
|
|
|
|
return parse("", (opts & OPT_X) ? argv : (char **)&opt_prefix);
|
|
}
|