static void
create_headers (FILE *mailpipe)
{
/* create all the mail header stuff. Feel free to add your own */
/* It is advisable to leave the X-Mailer header though, as */
/* there is a possibilty of a Gimp mail scanner/reader in the */
/* future. It will probabaly need that header. */
fprintf (mailpipe, "To: %s \n", mail_info.receipt);
fprintf (mailpipe, "Subject: %s \n", mail_info.subject);
if (strlen (mail_info.from) > 0)
fprintf (mailpipe, "From: %s \n", mail_info.from);
fprintf (mailpipe, "X-Mailer: GIMP Useless Mail Plug-In %s\n", GIMP_VERSION);
fprintf (mailpipe, "MIME-Version: 1.0\n");
fprintf (mailpipe, "Content-type: multipart/mixed; "
"boundary=GUMP-MIME-boundary\n");
fprintf (mailpipe, "\n\n");
fprintf (mailpipe, "--GUMP-MIME-boundary\n");
fprintf (mailpipe, "Content-type: text/plain; charset=UTF-8\n\n");
if (mesg_body)
fprintf (mailpipe, "%s", mesg_body);
fprintf (mailpipe, "\n\n");
{
gchar *content = find_content_type (mail_info.filename);
fprintf (mailpipe, "--GUMP-MIME-boundary\n");
fprintf (mailpipe, "Content-type: %s\n", content);
fprintf (mailpipe, "Content-transfer-encoding: base64\n");
fprintf (mailpipe, "Content-disposition: attachment; filename=\"%s\"\n",
mail_info.filename);
fprintf (mailpipe, "Content-description: %s\n\n", mail_info.filename);
g_free (content);
}
}
int main (int argc, char **argv)
{
int ch;
char *progname = argv[0];
#define MIN_INTERFACES 1
#define MAX_INTERFACES 64
struct interface_config interfaces[MAX_INTERFACES];
#define MIN_SERVERS 1
#define MAX_SERVERS 64
struct server_config servers[MAX_SERVERS];
int num_interfaces = 0;
int num_servers = 0;
int interface_server_count = 0;
int verbose = 0;
int stats = 0;
int tcp_stats_assigned = 0;
unsigned int i;
int error;
struct uinet_in_addr tmpinaddr;
int ifnetmap_count = 0;
int ifpcap_count = 0;
struct content_type *contype;
memset(interfaces, 0, sizeof(interfaces));
memset(servers, 0, sizeof(servers));
for (i = 0; i < MAX_INTERFACES; i++) {
interfaces[i].type = UINET_IFTYPE_NETMAP;
}
for (i = 0; i < MAX_SERVERS; i++) {
servers[i].listen_port = -1;
}
while ((ch = getopt(argc, argv, "c:ehi:l:Pp:st:v")) != -1) {
switch (ch) {
case 'c':
#ifdef ENABLE_EXTRACT
if (0 == interface_server_count) {
printf("No listen address specified\n");
return (1);
} else if (MAX_CONTENT_TYPES == servers[num_servers - 1].num_content_types) {
printf("Maximum number of content types per server is %u\n", MAX_CONTENT_TYPES);
return (1);
} else {
contype = find_content_type(optarg, known_content_types);
if (NULL == contype) {
printf("Unknown content type %s\n", optarg);
return (1);
}
servers[num_servers - 1].extract = 1;
servers[num_servers - 1].content_types[servers[num_servers - 1].num_content_types] = contype;
servers[num_servers - 1].num_content_types++;
}
#else
printf("Extract mode not supported.\n");
return(1);
#endif
break;
case 'e':
#ifdef ENABLE_EXTRACT
if (0 == num_interfaces) {
printf("No interface specified\n");
return (1);
} else {
servers[num_servers - 1].extract = 1;
}
#else
printf("Extract mode not supported.\n");
return(1);
#endif
break;
case 'h':
usage(progname);
return (0);
case 'i':
if (MAX_INTERFACES == num_interfaces) {
printf("Maximum number of interfaces is %u\n", MAX_INTERFACES);
return (1);
} else {
interfaces[num_interfaces].ifname = optarg;
interfaces[num_interfaces].cdom = num_interfaces + 1;
num_interfaces++;
interface_server_count = 0;
}
break;
case 'l':
if (0 == num_interfaces) {
printf("No interface specified\n");
return (1);
} else if (MAX_SERVERS == num_servers) {
printf("Maximum number of servers is %u\n", MAX_SERVERS);
return (1);
} else {
servers[num_servers].listen_addr = optarg;
servers[num_servers].interface = &interfaces[num_interfaces - 1];
num_servers++;
interface_server_count++;
}
break;
case 'P':
if (0 == num_interfaces) {
printf("No interface specified\n");
return (1);
} else {
interfaces[num_interfaces - 1].promisc = 1;
}
break;
case 'p':
if (0 == interface_server_count) {
printf("No listen address specified\n");
return (1);
} else {
servers[num_servers - 1].listen_port = strtoul(optarg, NULL, 10);
}
break;
case 's':
if (0 == num_interfaces) {
printf("No interface specified\n");
return (1);
} else {
interfaces[num_interfaces - 1].stats = 1;
}
break;
case 't':
if (0 == num_interfaces) {
printf("No interface specified\n");
return (1);
} else if (0 == strcmp(optarg, "netmap")) {
interfaces[num_interfaces - 1].type = UINET_IFTYPE_NETMAP;
} else if (0 == strcmp(optarg, "pcap")) {
interfaces[num_interfaces - 1].type = UINET_IFTYPE_PCAP;
} else {
printf("Unknown interface type %s\n", optarg);
return (1);
}
break;
case 'v':
verbose++;
break;
default:
printf("Unknown option \"%c\"\n", ch);
case '?':
usage(progname);
return (1);
}
}
argc -= optind;
argv += optind;
if (num_interfaces < MIN_INTERFACES) {
printf("Specify at least %u interface%s\n", MIN_INTERFACES, MIN_INTERFACES == 1 ? "" : "s");
return (1);
}
if (num_servers < MIN_SERVERS) {
printf("Specify at least %u listen address%s\n", MIN_SERVERS, MIN_SERVERS == 1 ? "" : "es");
return (1);
}
for (i = 0; i < num_servers; i++) {
if (-1 == servers[i].listen_port) {
printf("No listen port specified for interface %s, listen address %s\n",
servers[i].interface->ifname, servers[i].listen_addr);
return (1);
}
if (servers[i].listen_port < 0 || servers[i].listen_port > 65535) {
printf("Listen port for interface %s, listen address %s is out of range [0, 65535]\n",
servers[i].interface->ifname, servers[i].listen_addr);
return (1);
}
if (0 == servers[i].listen_port)
servers[i].interface->promisc = 1;
if (uinet_inet_pton(UINET_AF_INET, servers[i].listen_addr, &tmpinaddr) <= 0) {
printf("%s is not a valid listen address\n", servers[i].listen_addr);
return (1);
}
if (tmpinaddr.s_addr == UINET_INADDR_ANY) {
servers[i].addrany = 1;
servers[i].interface->promisc = 1;
}
}
uinet_init(1, 128*1024, 0);
uinet_install_sighandlers();
for (i = 0; i < num_interfaces; i++) {
switch (interfaces[i].type) {
case UINET_IFTYPE_NETMAP:
interfaces[i].alias_prefix = "netmap";
interfaces[i].instance = ifnetmap_count;
ifnetmap_count++;
break;
case UINET_IFTYPE_PCAP:
interfaces[i].alias_prefix = "pcap";
interfaces[i].instance = ifpcap_count;
ifpcap_count++;
break;
default:
printf("Unknown interface type %d\n", interfaces[i].type);
return (1);
break;
}
if (interfaces[i].stats && !tcp_stats_assigned) {
interfaces[i].do_tcpstats = 1;
tcp_stats_assigned = 1;
}
snprintf(interfaces[i].alias, UINET_IF_NAMESIZE, "%s%d", interfaces[i].alias_prefix, interfaces[i].instance);
if (verbose) {
printf("Creating interface %s, Promiscuous INET %s, cdom=%u\n",
interfaces[i].alias, interfaces[i].promisc ? "enabled" : "disabled",
interfaces[i].promisc ? interfaces[i].cdom : 0);
}
error = uinet_ifcreate(interfaces[i].type, interfaces[i].ifname, interfaces[i].alias,
interfaces[i].promisc ? interfaces[i].cdom : 0,
0, NULL);
if (0 != error) {
printf("Failed to create interface %s (%d)\n", interfaces[i].alias, error);
}
interfaces[i].loop = ev_loop_new(EVFLAG_AUTO);
if (NULL == interfaces[i].loop) {
printf("Failed to create event loop interface %s\n", interfaces[i].alias);
break;
}
}
for (i = 0; i < num_servers; i++) {
if (!servers[i].addrany) {
if (verbose) {
printf("Adding address %s to interface %s\n", servers[i].listen_addr, servers[i].interface->alias);
}
error = uinet_interface_add_alias(servers[i].interface->alias, servers[i].listen_addr, "", "");
if (error) {
printf("Adding alias %s to interface %s failed (%d)\n", servers[i].listen_addr, servers[i].interface->alias, error);
}
}
}
for (i = 0; i < num_servers; i++) {
if (verbose) {
printf("Creating passive server at %s:%d on interface %s\n",
servers[i].listen_addr, servers[i].listen_port,
servers[i].interface->alias);
}
servers[i].verbose = verbose;
servers[i].passive = create_passive(servers[i].interface->loop, &servers[i]);
if (NULL == servers[i].passive) {
printf("Failed to create passive server at %s:%d on interface %s\n",
servers[i].listen_addr, servers[i].listen_port,
servers[i].interface->alias);
break;
}
}
for (i = 0; i < num_interfaces; i++) {
if (verbose) {
printf("Bringing up interface %s\n", interfaces[i].alias);
}
error = uinet_interface_up(interfaces[i].alias, 1, interfaces[i].promisc);
if (0 != error) {
printf("Failed to bring up interface %s (%d)\n", interfaces[i].alias, error);
}
if (verbose)
printf("Creating interface thread for interface %s\n", interfaces[i].alias);
interfaces[i].thread_create_result = pthread_create(&interfaces[i].thread, NULL,
interface_thread_start, &interfaces[i]);
}
for (i = 0; i < num_interfaces; i++) {
if (0 == interfaces[i].thread_create_result)
pthread_join(interfaces[i].thread, NULL);
}
uinet_shutdown(0);
return (0);
}
static int
on_http_resp_headers_complete(http_parser *parser)
{
struct connection_context *conn = parser->data;
struct content_type *type;
char filename[80];
int offset;
int thereisnobody;
/* Ensure the last value stored is nul-terminated */
if (conn->value)
conn->value->data[conn->value->index] = '\0';
if (conn->verbose) {
printf("%s: content type: %s\n", conn->label,
conn->content_type.index ? conn->content_type.data : "<unknown>");
printf("%s: content encoding: %s\n", conn->label,
conn->content_encoding.index ? conn->content_encoding.data : "identity");
}
if (conn->peer->ishead ||
parser->status_code / 100 == 1 ||
parser->status_code == 204 ||
parser->status_code == 304) {
thereisnobody = 1;
} else {
thereisnobody = 0;
type = find_content_type(conn->content_type.data, conn->server->content_types);
if (type)
conn->extract_body = 1;
}
if (conn->extract_body) {
conn->unknown_encoding = 0;
conn->inflate = 0;
if ((strcasecmp(conn->content_encoding.data, "x-gzip") == 0) ||
(strcasecmp(conn->content_encoding.data, "gzip") == 0) ||
(strcasecmp(conn->content_encoding.data, "deflate") == 0)) {
conn->inflate = 1;
} else if (conn->content_encoding.index > 0) {
conn->unknown_encoding = 1;
}
if (conn->inflate) {
conn->zstrm.zalloc = Z_NULL;
conn->zstrm.zfree = Z_NULL;
conn->zstrm.opaque = Z_NULL;
conn->zstrm.avail_in = 0;
conn->zstrm.next_in = Z_NULL;
if (Z_OK != inflateInit2(&conn->zstrm, 32 + MAX_WBITS)) {
conn->inflate = 0;
conn->unknown_encoding = 1;
}
}
snprintf(filename, sizeof(filename), "%s-%06d%s%s%s", conn->filename_prefix,
conn->file_counter, type->file_ext, conn->unknown_encoding ? "." : "",
conn->unknown_encoding ? conn->content_encoding.data : "");
conn->file_counter++;
conn->fd = open(filename, O_CREAT|O_TRUNC|O_WRONLY, S_IRUSR|S_IWUSR);
if (-1 == conn->fd) {
printf("%s: Failed to open %s for writing\n", conn->label, filename);
conn->extract_body = 0;
inflateEnd(&conn->zstrm);
}
}
if (thereisnobody) {
/* tell the parser there is no response body */
return (1);
} else {
return (0);
}
}
int handle_request(const struct mime *mime_tbl, const struct cgi *cgi_tbl, const char *path_prefix, const char *default_page, const int sockfd) {
char buf[BUFFER_SIZE], local_path[BUFFER_SIZE];
char basic_request[3][BUFFER_SIZE], *content_type=0, *query=0;
struct request req;
static time_t t;
t = time(0);
memset(buf, 0, sizeof buf);
memset(local_path, 0, sizeof local_path);
memset(&req, 0, sizeof(struct request));
read_line(buf, sockfd);
sscanf(buf, "%s %s %s", basic_request[METHOD], basic_request[PATH], basic_request[PROC]);
const int type = parse_request_type(basic_request[METHOD]);
query = has_query_string(basic_request[PATH]);
if(query) {
*query = 0;
++query;
}
/* Add default page */
if(strlen(basic_request[PATH])==1&&basic_request[PATH][0]=='/') {
strcat(basic_request[PATH], default_page);
}
strncat(local_path, path_prefix, BUFFER_SIZE-1);
strncat(local_path, basic_request[PATH], BUFFER_SIZE-1);
req.type = type;
req.uri = basic_request[PATH];
req.local_path = local_path;
req.query_string = query;
fprintf(stderr, "[%s] %s %s\n", str_strip(ctime(&t)), basic_request[METHOD], basic_request[PATH]);
write_socket(STR_PROC, strlen(STR_PROC), sockfd);
if(type==GET) {
FILE *fp = fopen(local_path, "r");
if(fp==0) {
/* File doesn't exist */
write_socket(RES_404, strlen(RES_404), sockfd);
write_socket("\r\n", 2, sockfd);
} else {
write_socket(RES_200, strlen(RES_200), sockfd);
if(handle_cgi(&req, cgi_tbl, sockfd)==0) {
content_type = find_content_type(mime_tbl, determine_ext(req.local_path));
write_socket(FLD_CONTENT_TYPE, strlen(FLD_CONTENT_TYPE), sockfd);
write_socket(content_type, strlen(content_type), sockfd);
write_socket("\r\n", 2, sockfd);
write_socket("\r\n", 2, sockfd);
send_file(local_path, sockfd);
}
}
fclose(fp);
} else if(type==POST) {
if(handle_cgi(&req, cgi_tbl, sockfd)==0) {
return -1;
}
} else {
write_socket(RES_400, strlen(RES_400), sockfd);
write_socket("\r\n", 2, sockfd);
write_socket("\r\n", 2, sockfd);
}
return 0;
}
