static void web_node_free_siblings(WEB_NODE* web_node, WEB_NODE_ITEM* cur)
{
WEB_NODE_ITEM* sibling;
WEB_NODE_ITEM* next;
for (sibling = cur; sibling != NULL; sibling = next)
{
next = so_get(&web_node->items, sibling->next);
if (sibling->child != INVALID_HANDLE)
web_node_free_siblings(web_node, so_get(&web_node->items, sibling->child));
web_node_free_internal(web_node, sibling);
}
}
static WEB_NODE_ITEM* web_node_find_child(WEB_NODE* web_node, WEB_NODE_ITEM* parent, char* name, unsigned int len)
{
WEB_NODE_ITEM* cur;
for(cur = so_get(&web_node->items, parent->child); cur != NULL; cur = so_get(&web_node->items, cur->next))
{
if (web_stricmp(WEB_OBJ_WILDCARD, 1, cur->name))
return cur;
if (web_stricmp(name, len, cur->name))
return cur;
}
return NULL;
}
void web_node_free(WEB_NODE* web_node, HANDLE handle)
{
WEB_NODE_ITEM* cur;
WEB_NODE_ITEM* parent;
HANDLE h;
bool found;
cur = so_get(&web_node->items, handle);
if (cur == NULL)
return;
//remove all childs
if (cur->child != INVALID_HANDLE)
web_node_free_siblings(web_node, so_get(&web_node->items, cur->child));
//remove from parent/older brother
if (handle != web_node->root)
{
found = false;
for (h = so_first(&web_node->items); h != INVALID_HANDLE; h = so_next(&web_node->items, h))
{
parent = so_get(&web_node->items, h);
if (parent->child == handle)
{
parent->child = cur->next;
found = true;
break;
}
if (parent->next == handle)
{
parent->next = cur->next;
found = true;
break;
}
}
if (!found)
{
error(ERROR_NOT_FOUND);
return;
}
}
//destroy node itself
web_node_free_internal(web_node, cur);
//remove root item
if (handle == web_node->root)
web_node->root = INVALID_HANDLE;
}
/*
* Wrap the text in the given store to the given width.
* A new store is created for the result.
*/
STORE_S *
wrap_store(STORE_S *in, int width)
{
STORE_S *result;
void *ws;
gf_io_t ipc,opc;
if(width<10)
width = 10;
result = so_get(CharStar, NULL, EDIT_ACCESS);
ws = gf_wrap_filter_opt(width, width, NULL, 0, 0);
gf_filter_init();
gf_link_filter(gf_wrap, ws);
gf_set_so_writec(&opc, result);
gf_set_so_readc(&ipc, in);
gf_pipe(ipc, opc);
gf_clear_so_readc(in);
gf_clear_so_writec(result);
return result;
}
static inline void udps_read(TCPIPS* tcpips, HANDLE handle, IO* io)
{
IO* cur;
UDP_HANDLE* uh;
uh = so_get(&tcpips->udps.handles, handle);
if (uh == NULL)
return;
#if (ICMP)
if (uh->err != ERROR_OK)
{
error(uh->err);
return;
}
#endif //ICMP
io->data_size = 0;
*((IO**)io_data(io)) = NULL;
//add to head
if (uh->head == NULL)
uh->head = io;
//add to end
else
{
for (cur = uh->head; *((IO**)io_data(cur)) != NULL; cur = *((IO**)io_data(cur))) {}
*((IO**)io_data(cur)) = io;
}
error(ERROR_SYNC);
}
HANDLE web_node_find_path(WEB_NODE* web_node, char* url, unsigned int url_size)
{
WEB_NODE_ITEM* cur;
unsigned int len;
if (web_node->root == INVALID_HANDLE)
return INVALID_HANDLE;
if (!url_size || url[0] != '/')
return INVALID_HANDLE;
cur = so_get(&web_node->items, web_node->root);
//skip "/"
--url_size;
++url;
if (url_size == 0)
return web_node->root;
for (;;)
{
len = web_get_word(url, url_size, '/');
cur = web_node_find_child(web_node, cur, url, len);
if (cur == NULL)
return INVALID_HANDLE;
if (len == url_size)
return cur->self;
//also skip slash
url += len + 1;
url_size -= len + 1;
}
}
static void udps_send_user(TCPIPS* tcpips, IP* src, IO* io, HANDLE handle)
{
IO* user_io;
unsigned int offset, size;
UDP_STACK* udp_stack;
UDP_HANDLE* uh;
UDP_HEADER* hdr = io_data(io);
uh = so_get(&tcpips->udps.handles, handle);
for (offset = sizeof(UDP_HEADER); uh->head && offset < io->data_size; offset += size)
{
user_io = udps_peek_head(tcpips, uh);
udp_stack = io_push(user_io, sizeof(UDP_STACK));
udp_stack->remote_addr.u32.ip = src->u32.ip;
udp_stack->remote_port = be2short(hdr->src_port_be);
size = io_get_free(user_io);
if (size > io->data_size - offset)
size = io->data_size - offset;
memcpy(io_data(user_io), (uint8_t*)io_data(io) + offset, size);
user_io->data_size = size;
io_complete(uh->process, HAL_IO_CMD(HAL_UDP, IPC_READ), handle, user_io);
}
#if (UDP_DEBUG)
if (offset < io->data_size)
printf("UDP: %d byte(s) dropped\n", io->data_size - offset);
#endif //UDP_DEBUG
}
static inline void udps_write(TCPIPS* tcpips, HANDLE handle, IO* io)
{
IO* cur;
unsigned int offset, size;
unsigned short remote_port;
IP dst;
UDP_STACK* udp_stack;
UDP_HEADER* udp;
UDP_HANDLE* uh = so_get(&tcpips->udps.handles, handle);
if (uh == NULL)
return;
#if (ICMP)
if (uh->err != ERROR_OK)
{
error(uh->err);
return;
}
#endif //ICMP
//listening socket
if (uh->remote_port == 0)
{
if (io->stack_size < sizeof(UDP_STACK))
{
error(ERROR_INVALID_PARAMS);
return;
}
udp_stack = io_stack(io);
remote_port = udp_stack->remote_port;
dst.u32.ip = udp_stack->remote_addr.u32.ip;
io_pop(io, sizeof(UDP_STACK));
}
else
{
remote_port = uh->remote_port;
dst.u32.ip = uh->remote_addr.u32.ip;
}
for (offset = 0; offset < io->data_size; offset += size)
{
size = UDP_FRAME_MAX_DATA_SIZE;
if (size > io->data_size - offset)
size = io->data_size - offset;
cur = ips_allocate_io(tcpips, size + sizeof(UDP_HEADER), PROTO_UDP);
if (cur == NULL)
return;
//copy data
memcpy((uint8_t*)io_data(cur) + sizeof(UDP_HEADER), (uint8_t*)io_data(io) + offset, size);
udp = io_data(cur);
// correct size
cur->data_size = size + sizeof(UDP_HEADER);
//format header
short2be(udp->src_port_be, uh->local_port);
short2be(udp->dst_port_be, remote_port);
short2be(udp->len_be, size + sizeof(UDP_HEADER));
short2be(udp->checksum_be, 0);
short2be(udp->checksum_be, udp_checksum(io_data(cur), cur->data_size, &tcpips->ips.ip, &dst));
ips_tx(tcpips, cur, &dst);
}
}
static inline void udps_close(TCPIPS* tcpips, HANDLE handle)
{
UDP_HANDLE* uh;
if ((uh = so_get(&tcpips->udps.handles, handle)) == NULL)
return;
udps_flush(tcpips, handle);
so_free(&tcpips->udps.handles, handle);
}
bool web_node_check_flag(WEB_NODE* web_node, HANDLE handle, unsigned int flag)
{
WEB_NODE_ITEM* cur;
cur = so_get(&web_node->items, handle);
if (cur == NULL)
return false;
return cur->flags & flag ? true : false;
}
static HANDLE udps_find(TCPIPS* tcpips, uint16_t local_port)
{
HANDLE handle;
UDP_HANDLE* uh;
for (handle = so_first(&tcpips->udps.handles); handle != INVALID_HANDLE; handle = so_next(&tcpips->udps.handles, handle))
{
uh = so_get(&tcpips->udps.handles, handle);
if (uh->local_port == local_port)
return handle;
}
return INVALID_HANDLE;
}
/*----------------------------------------------------------------------
Read whole file into memory
Args: filename -- path name of file to read
Result: Returns pointer to malloced memory with the contents of the file
or NULL
This won't work very well if the file has NULLs in it.
----*/
char *
read_file(char *filename, int so_get_flags)
{
STORE_S *in_file = NULL, *out_store = NULL;
unsigned char c;
char *return_text = NULL;
if((in_file = so_get(FileStar, filename, so_get_flags | READ_ACCESS))){
if(!(out_store = so_get(CharStar, NULL, EDIT_ACCESS))){
so_give(&in_file);
return NULL;
}
/*
* We're just using the READ_FROM_LOCALE flag to translate
* to UTF-8.
*/
while(so_readc(&c, in_file))
so_writec(c, out_store);
if(in_file)
so_give(&in_file);
if(out_store){
return_text = (char *) so_text(out_store);
/* avoid freeing this */
if(out_store->txt)
out_store->txt = NULL;
so_give(&out_store);
}
}
return(return_text);
}
static void udps_flush(TCPIPS* tcpips, HANDLE handle)
{
IO* io;
UDP_HANDLE* uh;
int err;
uh = so_get(&tcpips->udps.handles, handle);
if (uh == NULL)
return;
err = ERROR_IO_CANCELLED;
#if (ICMP)
if (uh->err != ERROR_OK)
err = uh->err;
#endif //ICMP
while ((io = udps_peek_head(tcpips, uh)) != NULL)
io_complete_ex(uh->process, HAL_CMD(HAL_UDP, IPC_READ), handle, io, err);
}
void udps_icmps_error_process(TCPIPS* tcpips, IO* io, ICMP_ERROR code, const IP* src)
{
HANDLE handle;
UDP_HANDLE* uh;
uint16_t src_port, dst_port;
UDP_HEADER* hdr = io_data(io);
src_port = be2short(hdr->src_port_be);
dst_port = be2short(hdr->dst_port_be);
if ((handle = udps_find(tcpips, src_port)) == INVALID_HANDLE)
return;
uh = so_get(&tcpips->udps.handles, handle);
//ignore errors on listening sockets
if (uh->remote_port == dst_port && uh->remote_addr.u32.ip == src->u32.ip)
{
switch (code)
{
case ICMP_ERROR_NETWORK:
case ICMP_ERROR_HOST:
case ICMP_ERROR_PROTOCOL:
case ICMP_ERROR_PORT:
case ICMP_ERROR_FRAGMENTATION:
case ICMP_ERROR_ROUTE:
uh->err = ERROR_NOT_RESPONDING;
break;
case ICMP_ERROR_TTL_EXCEED:
case ICMP_ERROR_FRAGMENT_REASSEMBLY_EXCEED:
uh->err = ERROR_TIMEOUT;
break;
case ICMP_ERROR_PARAMETER:
uh->err = ERROR_INVALID_PARAMS;
break;
default:
break;
}
udps_flush(tcpips, handle);
}
}
static inline void udps_connect(TCPIPS* tcpips, IPC* ipc)
{
HANDLE handle;
UDP_HANDLE* uh;
IP dst;
uint16_t local_port;
dst.u32.ip = ipc->param2;
local_port = udps_allocate_port(tcpips);
if ((local_port = udps_allocate_port(tcpips)) == 0)
return;
if ((handle = so_allocate(&tcpips->udps.handles)) == INVALID_HANDLE)
return;
uh = so_get(&tcpips->udps.handles, handle);
uh->remote_port = (uint16_t)ipc->param1;
uh->local_port = local_port;
uh->remote_addr.u32.ip = dst.u32.ip;
uh->process = ipc->process;
uh->head = NULL;
#if (ICMP)
uh->err = ERROR_OK;
#endif //ICMP
ipc->param2 = handle;
}
static inline void udps_listen(TCPIPS* tcpips, IPC* ipc)
{
HANDLE handle;
UDP_HANDLE* uh;
if (udps_find(tcpips, (uint16_t)ipc->param1) != INVALID_HANDLE)
{
error(ERROR_ALREADY_CONFIGURED);
return;
}
handle = so_allocate(&tcpips->udps.handles);
if (handle == INVALID_HANDLE)
return;
uh = so_get(&tcpips->udps.handles, handle);
uh->remote_port = 0;
uh->local_port = (uint16_t)ipc->param1;
uh->remote_addr.u32.ip = __LOCALHOST.u32.ip;
uh->process = ipc->process;
uh->head = NULL;
#if (ICMP)
uh->err = ERROR_OK;
#endif //ICMP
ipc->param2 = handle;
}
void
output_cert_info(X509 *cert, gf_io_t pc)
{
char buf[256];
STORE_S *left,*right;
gf_io_t spc;
int len;
left = so_get(CharStar, NULL, EDIT_ACCESS);
right = so_get(CharStar, NULL, EDIT_ACCESS);
if(!(left && right))
return;
gf_set_so_writec(&spc, left);
if(!cert->cert_info){
gf_puts("Couldn't find certificate info.", spc);
gf_puts(NEWLINE, spc);
}
else{
gf_puts_uline("Subject (whose certificate it is)", spc);
gf_puts(NEWLINE, spc);
output_X509_NAME(cert->cert_info->subject, spc);
gf_puts(NEWLINE, spc);
gf_puts_uline("Serial Number", spc);
gf_puts(NEWLINE, spc);
snprintf(buf, sizeof(buf), "%ld", ASN1_INTEGER_get(cert->cert_info->serialNumber));
gf_puts(buf, spc);
gf_puts(NEWLINE, spc);
gf_puts(NEWLINE, spc);
gf_puts_uline("Validity", spc);
gf_puts(NEWLINE, spc);
{
BIO *mb = BIO_new(BIO_s_mem());
char iobuf[4096];
gf_puts("Not Before: ", spc);
(void) BIO_reset(mb);
ASN1_UTCTIME_print(mb, cert->cert_info->validity->notBefore);
(void) BIO_flush(mb);
while((len = BIO_read(mb, iobuf, sizeof(iobuf))) > 0)
gf_nputs(iobuf, len, spc);
gf_puts(NEWLINE, spc);
gf_puts("Not After: ", spc);
(void) BIO_reset(mb);
ASN1_UTCTIME_print(mb, cert->cert_info->validity->notAfter);
(void) BIO_flush(mb);
while((len = BIO_read(mb, iobuf, sizeof(iobuf))) > 0)
gf_nputs(iobuf, len, spc);
gf_puts(NEWLINE, spc);
gf_puts(NEWLINE, spc);
BIO_free(mb);
}
}
gf_clear_so_writec(left);
gf_set_so_writec(&spc, right);
if(!cert->cert_info){
gf_puts(_("Couldn't find certificate info."), spc);
gf_puts(NEWLINE, spc);
}
else{
gf_puts_uline("Issuer", spc);
gf_puts(NEWLINE, spc);
output_X509_NAME(cert->cert_info->issuer, spc);
gf_puts(NEWLINE, spc);
}
gf_clear_so_writec(right);
side_by_side(left, right, pc);
gf_puts_uline("SHA1 Fingerprint", pc);
gf_puts(NEWLINE, pc);
get_fingerprint(cert, EVP_sha1(), buf, sizeof(buf));
gf_puts(buf, pc);
gf_puts(NEWLINE, pc);
gf_puts_uline("MD5 Fingerprint", pc);
gf_puts(NEWLINE, pc);
get_fingerprint(cert, EVP_md5(), buf, sizeof(buf));
gf_puts(buf, pc);
gf_puts(NEWLINE, pc);
so_give(&left);
so_give(&right);
}
/*
* Display a new user or new version message.
*/
void
new_user_or_version(struct pine *ps)
{
char **shown_text;
int cmd = MC_NONE;
int first_time_alpine_user = 0;
char *error = NULL;
HelpType text;
SCROLL_S sargs;
STORE_S *store;
HANDLE_S *handles = NULL, *htmp;
gf_io_t pc;
char *vers = ps->vers_internal;
first_time_alpine_user = (ps->first_time_user
|| (ps->pine_pre_vers
&& isdigit((unsigned char) ps->pine_pre_vers[0])
&& ps->pine_pre_vers[1] == '.'
&& isdigit((unsigned char) vers[0])
&& vers[1] == '.'
&& ps->pine_pre_vers[0] < '5' /* it was Pine */
&& vers[0] >= '5')); /* Alpine */
text = ps->first_time_user ? new_user_greeting :
first_time_alpine_user ? new_alpine_user_greeting : new_version_greeting;
shown_text = text;
/*
* Set it if the major revision number
* (the first after the dot) has changed.
*/
ps->phone_home = (first_time_alpine_user
|| (ps->pine_pre_vers
&& isdigit((unsigned char) ps->pine_pre_vers[0])
&& ps->pine_pre_vers[1] == '.'
&& isdigit((unsigned char) ps->pine_pre_vers[2])
&& isdigit((unsigned char) vers[0])
&& vers[1] == '.'
&& isdigit((unsigned char) vers[2])
&& strncmp(ps->pine_pre_vers, vers, 3) < 0));
/*
* At this point, shown_text is a charstarstar with html
* Turn it into a charstar with digested html
*/
do{
init_helper_getc(shown_text);
init_handles(&handles);
if((store = so_get(CharStar, NULL, EDIT_ACCESS)) != NULL){
gf_set_so_writec(&pc, store);
gf_filter_init();
gf_link_filter(gf_html2plain,
gf_html2plain_opt("x-alpine-help:",
ps->ttyo->screen_cols, non_messageview_margin(),
&handles, NULL, GFHP_LOCAL_HANDLES));
error = gf_pipe(helper_getc, pc);
gf_clear_so_writec(store);
if(!error){
struct key_menu km;
struct key keys[24];
for(htmp = handles; htmp; htmp = htmp->next)
if(htmp->type == URL
&& htmp->h.url.path
&& (htmp->h.url.path[0] == 'x'
|| htmp->h.url.path[0] == '#'))
htmp->force_display = 1;
/* This is mostly here to get the curses variables
* for line and column in sync with where the
* cursor is on the screen. This gets warped when
* the composer is called because it does it's own
* stuff
*/
ClearScreen();
memset(&sargs, 0, sizeof(SCROLL_S));
sargs.text.text = so_text(store);
sargs.text.src = CharStar;
sargs.text.desc = "greeting text";
sargs.text.handles = handles;
sargs.bar.title = "GREETING TEXT";
sargs.bar.style = TextPercent;
sargs.proc.tool = nuov_processor;
sargs.help.text = main_menu_tx;
sargs.help.title = "MAIN PINE HELP";
sargs.resize_exit = 1;
sargs.keys.menu = &km;
km = nuov_keymenu;
km.keys = keys;
memcpy(&keys[0], nuov_keymenu.keys,
(nuov_keymenu.how_many * 12) * sizeof(struct key));
setbitmap(sargs.keys.bitmap);
if(ps->phone_home){
km.keys[NUOV_EXIT].label = "Exit this greeting";
km.keys[NUOV_EXIT].bind.nch = 1;
}
else{
km.keys[NUOV_EXIT].label = "[Exit this greeting]";
km.keys[NUOV_EXIT].bind.nch = 3;
clrbitn(NUOV_VIEW, sargs.keys.bitmap);
}
if(ps->first_time_user)
clrbitn(NUOV_RELNOTES, sargs.keys.bitmap);
cmd = scrolltool(&sargs);
flush_input();
if(F_ON(F_BLANK_KEYMENU,ps_global))
FOOTER_ROWS(ps_global) = 1;
ClearScreen();
}
so_give(&store);
}
free_handles(&handles);
}
while(cmd == MC_RESIZE);
}
/*----------------------------------------------------------------------
Handle fetching and filtering a text message segment to be displayed
by scrolltool or printed or exported or piped.
Args: att -- segment to fetch
msgno -- message number segment is a part of
pc -- function to write characters from segment with
style -- Indicates special handling for error messages
flags -- Indicates special necessary handling
Returns: 1 if errors encountered, 0 if everything went A-OK
----*/
int
decode_text(ATTACH_S *att,
long int msgno,
gf_io_t pc,
HANDLE_S **handlesp,
DetachErrStyle style,
int flags)
{
FILTLIST_S filters[14];
char *err, *charset;
int filtcnt = 0, error_found = 0, column, wrapit;
int is_in_sig = OUT_SIG_BLOCK;
int is_flowed_msg = 0, add_me = 1, doraw = RAWSTRING;
int is_delsp_yes = 0;
int filt_only_c0 = 0;
char *parmval;
char *free_this = NULL;
STORE_S *warn_so = NULL;
DELQ_S dq;
URL_HILITE_S uh;
column = (flags & FM_DISPLAY) ? ps_global->ttyo->screen_cols : 80;
if(!(flags & FM_DISPLAY))
flags |= FM_NOINDENT;
wrapit = column;
memset(filters, 0, sizeof(filters));
/* charset the body part is in */
charset = parameter_val(att->body->parameter, "charset");
/* determined if it's flowed, affects wrapping and quote coloring */
if(att->body->type == TYPETEXT
&& !strucmp(att->body->subtype, "plain")
&& (parmval = parameter_val(att->body->parameter, "format"))){
if(!strucmp(parmval, "flowed"))
is_flowed_msg = 1;
fs_give((void **) &parmval);
if(is_flowed_msg){
if((parmval = parameter_val(att->body->parameter, "delsp")) != NULL){
if(!strucmp(parmval, "yes"))
is_delsp_yes = 1;
fs_give((void **) &parmval);
}
}
}
if(!ps_global->pass_ctrl_chars){
filters[filtcnt++].filter = gf_escape_filter;
filters[filtcnt].filter = gf_control_filter;
filt_only_c0 = 1;
filters[filtcnt++].data = gf_control_filter_opt(&filt_only_c0);
}
if(flags & FM_DISPLAY)
filters[filtcnt++].filter = gf_tag_filter;
/*
* if it's just plain old text, look for url's
*/
if(!(att->body->subtype && strucmp(att->body->subtype, "plain"))){
struct variable *vars = ps_global->vars;
if((F_ON(F_VIEW_SEL_URL, ps_global)
|| F_ON(F_VIEW_SEL_URL_HOST, ps_global)
|| F_ON(F_SCAN_ADDR, ps_global))
&& handlesp){
/*
* The url_hilite filter really ought to come
* after flowing, because flowing with the DelSp=yes parameter
* can reassemble broken urls back into identifiable urls.
* We add the preflow filter to do only the reassembly part
* of the flowing so that we can spot the urls.
* At this time (2005-03-29) we know that Apple Mail does
* send mail like this sometimes. This filter removes the
* sequence SP CRLF if that seems safe.
*/
if(ps_global->full_header != 2 && is_delsp_yes)
filters[filtcnt++].filter = gf_preflow;
filters[filtcnt].filter = gf_line_test;
filters[filtcnt++].data = gf_line_test_opt(url_hilite,
gf_url_hilite_opt(&uh,handlesp,0));
}
if((flags & FM_DISPLAY)
&& !(flags & FM_NOCOLOR)
&& pico_usingcolor()
&& VAR_SPECIAL_TEXT_FORE_COLOR
&& VAR_SPECIAL_TEXT_BACK_COLOR){
filters[filtcnt].filter = gf_line_test;
filters[filtcnt++].data = gf_line_test_opt(color_this_text, NULL);
}
/*
* First, paint the signature.
* Disclaimers noted below for coloring quotes apply here as well.
*/
if((flags & FM_DISPLAY)
&& !(flags & FM_NOCOLOR)
&& pico_usingcolor()
&& VAR_SIGNATURE_FORE_COLOR
&& VAR_SIGNATURE_BACK_COLOR){
filters[filtcnt].filter = gf_quote_test;
filters[filtcnt++].data = gf_line_test_opt(color_signature,
&is_in_sig);
}
/*
* Gotta be careful with this. The color_a_quote filter adds color
* to the beginning and end of the line. This will break some
* line_test-style filters which come after it. For example, if they
* are looking for something at the start of a line (like color_a_quote
* itself). I guess we could fix that by ignoring tags at the
* beginning of the line when doing the search.
*/
if((flags & FM_DISPLAY)
&& !(flags & FM_NOCOLOR)
&& pico_usingcolor()
&& VAR_QUOTE1_FORE_COLOR
&& VAR_QUOTE1_BACK_COLOR){
add_me = 0;
filters[filtcnt].filter = gf_quote_test;
filters[filtcnt++].data = gf_line_test_opt(color_a_quote, &is_flowed_msg);
}
}
else if(!strucmp(att->body->subtype, "richtext")){
int plain_opt;
plain_opt = !(flags&FM_DISPLAY);
/* maybe strip everything! */
filters[filtcnt].filter = gf_rich2plain;
filters[filtcnt++].data = gf_rich2plain_opt(&plain_opt);
/* width to use for file or printer */
if(wrapit - 5 > 0)
wrapit -= 5;
}
else if(!strucmp(att->body->subtype, "enriched")){
int plain_opt;
plain_opt = !(flags&FM_DISPLAY);
filters[filtcnt].filter = gf_enriched2plain;
filters[filtcnt++].data = gf_enriched2plain_opt(&plain_opt);
/* width to use for file or printer */
if(wrapit - 5 > 0)
wrapit -= 5;
}
else if(!strucmp(att->body->subtype, "html") && ps_global->full_header < 2){
/*BUG: sniff the params for "version=2.0" ala draft-ietf-html-spec-01 */
int opts = 0;
clear_html_risk();
if(flags & FM_DISPLAY){
gf_io_t warn_pc;
if(handlesp){ /* pass on handles awareness */
opts |= GFHP_HANDLES;
if(F_OFF(F_QUELL_HOST_AFTER_URL, ps_global) && !(flags & FM_HIDESERVER))
opts |= GFHP_SHOW_SERVER;
}
if(!(flags & FM_NOEDITORIAL)){
warn_so = so_get(CharStar, NULL, EDIT_ACCESS);
gf_set_so_writec(&warn_pc, warn_so);
format_editorial(HTML_WARNING, column, flags, handlesp, warn_pc);
gf_clear_so_writec(warn_so);
so_puts(warn_so, "\015\012");
so_writec('\0', warn_so);
}
}
else
opts |= GFHP_STRIPPED; /* don't embed anything! */
if(flags & FM_NOHTMLREL)
opts |= GFHP_NO_RELATIVE;
if(flags & FM_HTMLRELATED)
opts |= GFHP_RELATED_CONTENT;
if(flags & FM_HTML)
opts |= GFHP_HTML;
if(flags & FM_HTMLIMAGES)
opts |= GFHP_HTML_IMAGES;
wrapit = 0; /* wrap already handled! */
filters[filtcnt].filter = gf_html2plain;
filters[filtcnt++].data = gf_html2plain_opt(NULL, column,
(flags & (FM_NOINDENT | FM_HTML))
? 0
: format_view_margin(),
handlesp, set_html_risk, opts);
if(warn_so){
filters[filtcnt].filter = gf_prepend_editorial;
filters[filtcnt++].data = gf_prepend_editorial_opt(get_html_risk,
(char *) so_text(warn_so));
}
}
if (add_me){
filters[filtcnt].filter = gf_quote_test;
filters[filtcnt++].data = gf_line_test_opt(select_quote, &doraw);
}
/*
* If the message is not flowed, we do the quote suppression before
* the wrapping, because the wrapping does not preserve the quote
* characters at the beginnings of the lines in that case.
* Otherwise, we defer until after the wrapping.
*
* Also, this is a good place to do quote-replacement on nonflowed
* messages because no other filters depend on the "> ".
* Quote-replacement is easier in the flowed case and occurs
* automatically in the flowed wrapping filter.
*/
if(!is_flowed_msg
&& ps_global->full_header == 0
&& !(att->body->subtype && strucmp(att->body->subtype, "plain"))
&& (flags & FM_DISPLAY)){
if(ps_global->quote_suppression_threshold != 0){
memset(&dq, 0, sizeof(dq));
dq.lines = ps_global->quote_suppression_threshold;
dq.is_flowed = is_flowed_msg;
dq.indent_length = 0; /* indent didn't happen yet */
dq.saved_line = &free_this;
dq.handlesp = handlesp;
dq.do_color = (!(flags & FM_NOCOLOR) && pico_usingcolor());
filters[filtcnt].filter = gf_quote_test;
filters[filtcnt++].data = gf_line_test_opt(delete_quotes, &dq);
}
if(ps_global->VAR_QUOTE_REPLACE_STRING
&& F_ON(F_QUOTE_REPLACE_NOFLOW, ps_global)){
filters[filtcnt].filter = gf_line_test;
filters[filtcnt++].data = gf_line_test_opt(replace_quotes, NULL);
}
}
if(wrapit && !(flags & FM_NOWRAP)){
int wrapflags = (flags & FM_DISPLAY) ? (GFW_HANDLES|GFW_SOFTHYPHEN)
: GFW_NONE;
if(flags & FM_DISPLAY
&& !(flags & FM_NOCOLOR)
&& pico_usingcolor())
wrapflags |= GFW_USECOLOR;
/* text/flowed (RFC 2646 + draft)? */
if(ps_global->full_header != 2 && is_flowed_msg){
wrapflags |= GFW_FLOWED;
if(is_delsp_yes)
wrapflags |= GFW_DELSP;
}
filters[filtcnt].filter = gf_wrap;
filters[filtcnt++].data = gf_wrap_filter_opt(wrapit, column,
(flags & FM_NOINDENT)
? 0
: format_view_margin(),
0, wrapflags);
}
/*
* This has to come after wrapping has happened because the user tells
* us how many quoted lines to display, and we want that number to be
* the wrapped lines, not the pre-wrapped lines. We do it before the
* wrapping if the message is not flowed, because the wrapping does not
* preserve the quote characters at the beginnings of the lines in that
* case.
*/
if(is_flowed_msg
&& ps_global->full_header == 0
&& !(att->body->subtype && strucmp(att->body->subtype, "plain"))
&& (flags & FM_DISPLAY)
&& ps_global->quote_suppression_threshold != 0){
memset(&dq, 0, sizeof(dq));
dq.lines = ps_global->quote_suppression_threshold;
dq.is_flowed = is_flowed_msg;
dq.indent_length = (wrapit && !(flags & FM_NOWRAP)
&& !(flags & FM_NOINDENT))
? format_view_margin()[0]
: 0;
dq.saved_line = &free_this;
dq.handlesp = handlesp;
dq.do_color = (!(flags & FM_NOCOLOR) && pico_usingcolor());
filters[filtcnt].filter = gf_quote_test;
filters[filtcnt++].data = gf_line_test_opt(delete_quotes, &dq);
}
if(charset){
if(F_OFF(F_QUELL_CHARSET_WARNING, ps_global)
&& !(flags & FM_NOEDITORIAL)){
int rv = TRUE;
CONV_TABLE *ct = NULL;
/*
* Need editorial if message charset is not ascii
* and the display charset is not either the same
* as the message charset or UTF-8.
*/
if(strucmp(charset, "us-ascii")
&& !((ps_global->display_charmap
&& !strucmp(charset, ps_global->display_charmap))
|| !strucmp("UTF-8", ps_global->display_charmap))){
/*
* This is probably overkill. We're just using this
* conversion_table routine to get at the quality.
*/
if(ps_global->display_charmap)
ct = conversion_table(charset, ps_global->display_charmap);
rv = charset_editorial(charset, msgno, handlesp, flags,
ct ? ct->quality : CV_NO_TRANSLATE_POSSIBLE,
column, pc);
}
if(!rv)
goto write_error;
}
fs_give((void **) &charset);
}
/* Format editorial comment about unknown encoding */
if(att->body->encoding > ENCQUOTEDPRINTABLE){
char buf[2048];
snprintf(buf, sizeof(buf), ENCODING_DISCLAIMER, body_encodings[att->body->encoding]);
if(!(format_editorial(buf, column, flags, handlesp, pc) == NULL
&& gf_puts(NEWLINE, pc) && gf_puts(NEWLINE, pc)))
goto write_error;
}
err = detach(ps_global->mail_stream, msgno, att->number, 0L,
NULL, pc, filtcnt ? filters : NULL, 0);
delete_unused_handles(handlesp);
if(free_this)
fs_give((void **) &free_this);
if(warn_so)
so_give(&warn_so);
if(err) {
error_found++;
if(style == QStatus) {
q_status_message1(SM_ORDER, 3, 4, "%.200s", err);
} else if(style == InLine) {
char buftmp[MAILTMPLEN];
snprintf(buftmp, sizeof(buftmp), "%s",
att->body->description ? att->body->description : "");
snprintf(tmp_20k_buf, SIZEOF_20KBUF, "%s [Error: %s] %c%s%c%s%s",
NEWLINE, err,
att->body->description ? '\"' : ' ',
att->body->description ? buftmp : "",
att->body->description ? '\"' : ' ',
NEWLINE, NEWLINE);
if(!gf_puts(tmp_20k_buf, pc))
goto write_error;
}
}
if(att->body->subtype
&& (!strucmp(att->body->subtype, "richtext")
|| !strucmp(att->body->subtype, "enriched"))
&& !(flags & FM_DISPLAY)){
if(!gf_puts(NEWLINE, pc) || !gf_puts(NEWLINE, pc))
goto write_error;
}
return(error_found);
write_error:
if(style == QStatus)
q_status_message1(SM_ORDER, 3, 4, "Error writing message: %.200s",
error_description(errno));
return(1);
}
int
rd_prompt_about_forged_remote_data(int reason, REMDATA_S *rd, char *extra)
{
char tmp[2000];
char *unknown = "<unknown>";
int rv = -1;
char *foldertype, *foldername, *special;
foldertype = (rd && rd->t.i.special_hdr && !strucmp(rd->t.i.special_hdr, REMOTE_ABOOK_SUBTYPE)) ? "address book" : (rd && rd->t.i.special_hdr && !strucmp(rd->t.i.special_hdr, REMOTE_PINERC_SUBTYPE)) ? "configuration" : "data";
foldername = (rd && rd->rn) ? rd->rn : unknown;
special = (rd && rd->t.i.special_hdr) ? rd->t.i.special_hdr : unknown;
dprint((1, "rd_check_out_forged_remote_data:\n"));
dprint((1, " reason=%d\n", reason));
dprint((1, " folder_type=%s\n", foldertype ? foldertype : "?"));
dprint((1, " remotename=%s\n\n", foldername ? foldername : "?"));
if(rd && rd->flags & USER_SAID_NO)
return rv;
if(reason == -2){
dprint((1, "The special header \"%s\" is missing from the last message in the folder.\nThis indicates that something is wrong.\nYou should probably answer \"No\"\nso that you don't use the corrupt data.\nThen you should investigate further.\n", special ? special : "?"));
}
else if(reason == -1){
dprint((1, "The last message in the folder contains \"Received\" headers.\nThis usually indicates that the message was put there by the mail\ndelivery system. Alpine does not add those Received headers.\nYou should probably answer \"No\" so that you don't use the corrupt data.\nThen you should investigate further.\n"));
}
else if(reason == 0){
dprint((1, "The special header \"%s\" in the last message\nin the folder has an unexpected value (%s)\nafter it. This could indicate that something is wrong.\nThis value should not normally be put there by Alpine.\nHowever, since there are no Received lines in the message we choose to\nbelieve that everything is ok and we will proceed.\n",
special ? special : "?", (extra && *extra) ? extra : "?"));
}
else if(reason == 1){
dprint((1, "The special header \"%s\" in the last message\nin the folder has an unexpected value (1)\nafter it. It appears that it may have been put there by an Pine\nwith a version number less than 4.50.\nSince there are no Received lines in the message we choose to believe that\nthe header was added by an old Pine and we will proceed.\n",
special ? special : "?"));
}
else if(reason > 1){
dprint((1, "The special header \"%s\" in the last message\nin the folder has an unexpected value (%s)\nafter it. This is the right sort of value that Alpine would normally put there,\nbut it doesn't match the value from the first message in the folder.\nThis may indicate that something is wrong.\nHowever, since there are no Received lines in the message we choose to\nbelieve that everything is ok and we will proceed.\n",
special ? special : "?", (extra && *extra) ? extra : "?"));
}
if(reason >= 0){
/*
* This check should not really be here. We have a cookie that
* has the wrong value so something is possibly wrong.
* But we are worried that old pines will put the bad value in
* there (which they will) and then the questions will bother
* users and mystify them. So we're just going to pretend the user
* said Yes in this case, and we'll try to fix the cookie.
* We still catch Received lines and use that or the complete absence
* of a special header as indicators of trouble.
*/
rd->flags |= USER_SAID_YES;
return(1);
}
if(ps_global->ttyo){
SCROLL_S sargs;
STORE_S *in_store, *out_store;
gf_io_t pc, gc;
HANDLE_S *handles = NULL;
int the_answer = 'n';
if(!(in_store = so_get(CharStar, NULL, EDIT_ACCESS)) ||
!(out_store = so_get(CharStar, NULL, EDIT_ACCESS)))
goto try_wantto;
/* TRANSLATORS: the first %s is the folder type, it may be address book or
configuration. The second %s is the folder name. Of course, the HTML
tags should be left as is. */
snprintf(tmp, sizeof(tmp), _("<HTML><P>The data in the remote %s folder<P><CENTER>%s</CENTER><P>looks suspicious. The reason for the suspicion is<P><CENTER>"),
foldertype, foldername);
tmp[sizeof(tmp)-1] = '\0';
so_puts(in_store, tmp);
if(reason == -2){
snprintf(tmp, sizeof(tmp), _("header \"%s\" is missing</CENTER><P>The special header \"%s\" is missing from the last message in the folder. This indicates that something is wrong. You should probably answer \"No\" so that you don't use the corrupt data. Then you should investigate further."),
special, special);
tmp[sizeof(tmp)-1] = '\0';
so_puts(in_store, tmp);
}
else if(reason == -1){
so_puts(in_store, _("\"Received\" headers detected</CENTER><P>The last message in the folder contains \"Received\" headers. This usually indicates that the message was put there by the mail delivery system. Alpine does not add those Received headers. You should probably answer \"No\" so that you don't use the corrupt data. Then you should investigate further."));
}
else if(reason == 0){
snprintf(tmp, sizeof(tmp), _("Unexpected value for header \"%s\"</CENTER><P>The special header \"%s\" in the last message in the folder has an unexpected value (%s) after it. This probably indicates that something is wrong. This value would not normally be put there by Alpine. You should probably answer \"No\" so that you don't use the corrupt data. Then you should investigate further."),
special, special, (extra && *extra) ? extra : "?");
tmp[sizeof(tmp)-1] = '\0';
so_puts(in_store, tmp);
}
else if(reason == 1){
snprintf(tmp, sizeof(tmp), _("Unexpected value for header \"%s\"</CENTER><P>The special header \"%s\" in the last message in the folder has an unexpected value (1) after it. It appears that it may have been put there by a Pine with a version number less than 4.50. If you believe that you have changed this data with an older Pine more recently than you've changed it with this version of Alpine, then you can probably safely answer \"Yes\". If you do not understand why this has happened, you should probably answer \"No\" so that you don't use the corrupt data. Then you should investigate further."),
special, special);
tmp[sizeof(tmp)-1] = '\0';
so_puts(in_store, tmp);
}
else if(reason > 1){
snprintf(tmp, sizeof(tmp), _("Unexpected value for header \"%s\"</CENTER><P>The special header \"%s\" in the last message in the folder has an unexpected value (%s) after it. This is the right sort of value that Alpine would normally put there, but it doesn't match the value from the first message in the folder. This may indicate that something is wrong. Unless you understand why this has happened, you should probably answer \"No\" so that you don't use the corrupt data. Then you should investigate further."),
special, special, (extra && *extra) ? extra : "?");
tmp[sizeof(tmp)-1] = '\0';
so_puts(in_store, tmp);
}
so_seek(in_store, 0L, 0);
init_handles(&handles);
gf_filter_init();
gf_link_filter(gf_html2plain,
gf_html2plain_opt(NULL,
ps_global->ttyo->screen_cols, non_messageview_margin(),
&handles, NULL, GFHP_LOCAL_HANDLES));
gf_set_so_readc(&gc, in_store);
gf_set_so_writec(&pc, out_store);
gf_pipe(gc, pc);
gf_clear_so_writec(out_store);
gf_clear_so_readc(in_store);
memset(&sargs, 0, sizeof(SCROLL_S));
sargs.text.handles = handles;
sargs.text.text = so_text(out_store);
sargs.text.src = CharStar;
sargs.bar.title = _("REMOTE DATA FORGERY WARNING");
sargs.proc.tool = rd_answer_forge_warning;
sargs.proc.data.p = (void *)&the_answer;
sargs.keys.menu = &forge_keymenu;
setbitmap(sargs.keys.bitmap);
scrolltool(&sargs);
if(the_answer == 'y'){
rv = 1;
rd->flags |= USER_SAID_YES;
}
else if(rd)
rd->flags |= USER_SAID_NO;
ps_global->mangled_screen = 1;
ps_global->painted_body_on_startup = 0;
ps_global->painted_footer_on_startup = 0;
so_give(&in_store);
so_give(&out_store);
free_handles(&handles);
}
else{
char *p = tmp;
snprintf(p, sizeof(tmp), _("\nThe data in the remote %s folder\n\n %s\n\nlooks suspicious. The reason for the suspicion is\n\n "),
foldertype, foldername);
tmp[sizeof(tmp)-1] = '\0';
p += strlen(p);
if(reason == -2){
snprintf(p, sizeof(tmp)-(p-tmp), _("header \"%s\" is missing\n\nThe special header \"%s\" is missing from the last message\nin the folder. This indicates that something is wrong.\nYou should probably answer \"No\" so that you don't use the corrupt data.\nThen you should investigate further.\n\n"),
special, special);
tmp[sizeof(tmp)-1] = '\0';
}
else if(reason == -1){
snprintf(p, sizeof(tmp)-(p-tmp), _("\"Received\" headers detected\n\nThe last message in the folder contains \"Received\" headers.\nThis usually indicates that the message was put there by the\nmail delivery system. Alpine does not add those Received headers.\nYou should probably answer \"No\" so that you don't use the corrupt data.\nThen you should investigate further.\n\n"));
tmp[sizeof(tmp)-1] = '\0';
}
else if(reason == 0){
snprintf(p, sizeof(tmp)-(p-tmp), _("Unexpected value for header \"%s\"\n\nThe special header \"%s\" in the last message in the folder\nhas an unexpected value (%s) after it. This probably\nindicates that something is wrong. This value would not normally be put\nthere by Alpine. You should probably answer \"No\" so that you don't use\nthe corrupt data. Then you should investigate further.\n\n"),
special, special, (extra && *extra) ? extra : "?");
tmp[sizeof(tmp)-1] = '\0';
}
else if(reason == 1){
snprintf(p, sizeof(tmp)-(p-tmp), _("Unexpected value for header \"%s\"\n\nThe special header \"%s\" in the last message in the folder\nhas an unexpected value (1) after it. It appears that it may have been\nput there by a Pine with a version number less than 4.50.\nIf you believe that you have changed this data with an older Pine more\nrecently than you've changed it with this version of Alpine, then you can\nprobably safely answer \"Yes\". If you do not understand why this has\nhappened, you should probably answer \"No\" so that you don't use the\ncorrupt data. Then you should investigate further.\n\n"),
special, special);
tmp[sizeof(tmp)-1] = '\0';
}
else if(reason > 1){
snprintf(p, sizeof(tmp)-(p-tmp), _("Unexpected value for header \"%s\"\n\nThe special header \"%s\" in the last message in the folder\nhas an unexpected\nvalue (%s) after it. This is\nthe right sort of value that Alpine would normally put there, but it\ndoesn't match the value from the first message in the folder. This may\nindicate that something is wrong. Unless you understand why this has happened,\nyou should probably answer \"No\" so that you don't use the\ncorrupt data. Then you should investigate further.\n\n"),
special, special, (extra && *extra) ? extra : "?");
tmp[sizeof(tmp)-1] = '\0';
}
try_wantto:
p += strlen(p);
snprintf(p, sizeof(tmp)-(p-tmp), _("Suspicious data in \"%s\": Continue anyway "),
(rd && rd->t.i.special_hdr) ? rd->t.i.special_hdr
: unknown);
tmp[sizeof(tmp)-1] = '\0';
if(want_to(tmp, 'n', 'x', NO_HELP, WT_NORM) == 'y'){
rv = 1;
rd->flags |= USER_SAID_YES;
}
else if(rd)
rd->flags |= USER_SAID_NO;
}
if(rv < 0)
q_status_message1(SM_ORDER, 1, 3, _("Can't open remote %s"),
(rd && rd->rn) ? rd->rn : "<noname>");
return(rv);
}
HANDLE web_node_allocate(WEB_NODE* web_node, HANDLE parent_handle, char* name, unsigned int flags)
{
WEB_NODE_ITEM* parent;
WEB_NODE_ITEM* cur;
WEB_NODE_ITEM* child;
HANDLE cur_handle;
unsigned int len;
len = strlen(name);
if (parent_handle == WEB_ROOT_NODE)
{
if (web_node->root != INVALID_HANDLE)
{
error(ERROR_ALREADY_CONFIGURED);
return INVALID_HANDLE;
}
}
else
{
parent = so_get(&web_node->items, parent_handle);
if (parent == NULL)
return INVALID_HANDLE;
if (web_node_find_child(web_node, parent, name, len) != NULL)
{
error(ERROR_ALREADY_CONFIGURED);
return INVALID_HANDLE;
}
}
if ((cur_handle = so_allocate(&web_node->items)) == INVALID_HANDLE)
return INVALID_HANDLE;
cur = so_get(&web_node->items, cur_handle);
if ((cur->name = malloc(len + 1)) == NULL)
{
so_free(&web_node->items, cur_handle);
return INVALID_HANDLE;
}
strcpy(cur->name, name);
cur->self = cur_handle;
cur->next = cur->child = INVALID_HANDLE;
cur->flags = flags;
if (parent_handle == WEB_ROOT_NODE)
web_node->root = cur_handle;
else
{
//re-fetch after allocate
parent = so_get(&web_node->items, parent_handle);
//first child
if (parent->child == INVALID_HANDLE)
parent->child = cur_handle;
//add sibling
else
{
for(child = so_get(&web_node->items, parent->child); child->next != INVALID_HANDLE;
child = so_get(&web_node->items, child->next)) {}
child->next = cur_handle;
}
}
return cur_handle;
}
void
smime_info_screen(struct pine *ps)
{
long msgno;
OtherMenu what;
int offset = 0;
BODY *body;
ENVELOPE *env;
HANDLE_S *handles = NULL;
SCROLL_S scrollargs;
STORE_S *store = NULL;
ps->prev_screen = smime_info_screen;
ps->next_screen = SCREEN_FUN_NULL;
if(mn_total_cur(ps->msgmap) > 1L){
q_status_message(SM_ORDER | SM_DING, 0, 3,
_("Can only view one message's information at a time."));
return;
}
/* else check for existence of smime bits */
msgno = mn_m2raw(ps->msgmap, mn_get_cur(ps->msgmap));
env = mail_fetch_structure(ps->mail_stream, msgno, &body, 0);
if(!env || !body){
q_status_message(SM_ORDER, 0, 3,
_("Can't fetch body of message."));
return;
}
what = FirstMenu;
store = so_get(CharStar, NULL, EDIT_ACCESS);
while(ps->next_screen == SCREEN_FUN_NULL){
ClearLine(1);
so_truncate(store, 0);
view_writec_init(store, &handles, HEADER_ROWS(ps),
HEADER_ROWS(ps) +
ps->ttyo->screen_rows - (HEADER_ROWS(ps)
+ HEADER_ROWS(ps)));
gf_puts_uline("Overview", view_writec);
gf_puts(NEWLINE, view_writec);
format_smime_info(1, body, msgno, view_writec);
gf_puts(NEWLINE, view_writec);
format_smime_info(2, body, msgno, view_writec);
view_writec_destroy();
ps->next_screen = SCREEN_FUN_NULL;
memset(&scrollargs, 0, sizeof(SCROLL_S));
scrollargs.text.text = so_text(store);
scrollargs.text.src = CharStar;
scrollargs.text.desc = "S/MIME information";
scrollargs.body_valid = 1;
if(offset){ /* resize? preserve paging! */
scrollargs.start.on = Offset;
scrollargs.start.loc.offset = offset;
offset = 0L;
}
scrollargs.bar.title = "S/MIME INFORMATION";
/* scrollargs.end_scroll = view_end_scroll; */
scrollargs.resize_exit = 1;
scrollargs.help.text = NULL;
scrollargs.help.title = "HELP FOR S/MIME INFORMATION VIEW";
scrollargs.keys.menu = &smime_info_keymenu;
scrollargs.keys.what = what;
setbitmap(scrollargs.keys.bitmap);
if(scrolltool(&scrollargs) == MC_RESIZE)
offset = scrollargs.start.loc.offset;
}
so_give(&store);
}
/*
* dfilter - pipe the data from the given storage object thru the
* global display filter and into whatever the putchar's
* function points to.
*
* Input is assumed to be UTF-8.
* That's converted to user's locale and passed to rawcmd.
* That's converted back to UTF-8 and passed through aux_filters.
*/
char *
dfilter(char *rawcmd, STORE_S *input_so, gf_io_t output_pc, FILTLIST_S *aux_filters)
{
char *status = NULL, *cmd, *resultf = NULL, *tmpfile = NULL;
int key = 0, silent = 0;
if((cmd = expand_filter_tokens(rawcmd,NULL,&tmpfile,&resultf,NULL,&key,NULL, &silent)) != NULL){
suspend_busy_cue();
#ifndef _WINDOWS
if(!silent){
ps_global->mangled_screen = 1;
ClearScreen();
}
fflush(stdout);
#endif
/*
* If it was requested that the interaction take place via
* a tmpfile, fill it with text from our input_so, and let
* system_pipe handle the rest. Session key and tmp file
* mode support additions based loosely on a patch
* supplied by Thomas Stroesslin <*****@*****.**>
*/
if(tmpfile){
PIPE_S *filter_pipe;
FILE *fp;
gf_io_t gc, pc;
STORE_S *tmpf_so;
/* write the tmp file */
so_seek(input_so, 0L, 0);
if((tmpf_so = so_get(FileStar, tmpfile, WRITE_ACCESS|OWNER_ONLY|WRITE_TO_LOCALE)) != NULL){
if(key){
so_puts(tmpf_so, filter_session_key());
so_puts(tmpf_so, NEWLINE);
}
/* copy input to tmp file */
gf_set_so_readc(&gc, input_so);
gf_set_so_writec(&pc, tmpf_so);
gf_filter_init();
status = gf_pipe(gc, pc);
gf_clear_so_readc(input_so);
gf_clear_so_writec(tmpf_so);
if(so_give(&tmpf_so) != 0 && status == NULL)
status = error_description(errno);
/* prepare the terminal in case the filter uses it */
if(status == NULL){
if((filter_pipe = open_system_pipe(cmd, NULL, NULL,
PIPE_USER | (silent ? PIPE_SILENT :
(F_ON(F_DISABLE_TERM_RESET_DISP, ps_global) ? 0 : PIPE_RESET)),
0, pipe_callback, NULL)) != NULL){
if(close_system_pipe(&filter_pipe, NULL, pipe_callback) == 0){
/* pull result out of tmp file */
if((fp = our_fopen(tmpfile, "rb")) != NULL){
gf_set_readc(&gc, fp, 0L, FileStar, READ_FROM_LOCALE);
gf_filter_init();
if(aux_filters)
for( ; aux_filters->filter; aux_filters++)
gf_link_filter(aux_filters->filter,
aux_filters->data);
status = gf_pipe(gc, output_pc);
fclose(fp);
}
else
status = "Can't read result of display filter";
}
else
status = "Filter command returned error.";
}
else
status = "Can't open pipe for display filter";
}
our_unlink(tmpfile);
}
else
status = "Can't open display filter tmp file";
}
else if((status = gf_filter(cmd, key ? filter_session_key() : NULL,
input_so, output_pc, aux_filters, silent,
F_ON(F_DISABLE_TERM_RESET_DISP, ps_global),
pipe_callback)) != NULL){
unsigned long ch;
fprintf(stdout,"\r\n%s Hit return to continue.", status);
fflush(stdout);
while((ch = read_char(300)) != ctrl('M') && ch != NO_OP_IDLE)
putchar(BELL);
}
if(resultf){
if(name_file_size(resultf) > 0L)
display_output_file(resultf, "Filter", NULL, DOF_BRIEF);
fs_give((void **)&resultf);
}
resume_busy_cue(0);
#ifndef _WINDOWS
if(!silent)
ClearScreen();
#endif
fs_give((void **)&cmd);
}
return(status);
}
void udps_rx(TCPIPS* tcpips, IO* io, IP* src)
{
HANDLE handle;
UDP_HEADER* hdr;
UDP_HANDLE* uh;
uint16_t src_port, dst_port;
#if(UDP_BROADCAST)
const IP* dst;
dst = (const IP*)io_data(io) - 1;
if (io->data_size < sizeof(UDP_HEADER) || udp_checksum(io_data(io), io->data_size, src, dst))
#else
if (io->data_size < sizeof(UDP_HEADER) || udp_checksum(io_data(io), io->data_size, src, &tcpips->ips.ip))
#endif
{
ips_release_io(tcpips, io);
return;
}
hdr = io_data(io);
src_port = be2short(hdr->src_port_be);
dst_port = be2short(hdr->dst_port_be);
#if (UDP_DEBUG_FLOW)
printf("UDP: ");
ip_print(src);
printf(":%d -> ", src_port);
ip_print(&tcpips->ips.ip);
printf(":%d, %d byte(s)\n", dst_port, io->data_size - sizeof(UDP_HEADER));
#endif //UDP_DEBUG_FLOW
#if(DHCPS)
if((dst_port == DHCP_SERVER_PORT)||(src_port == DHCP_CLIENT_PORT))
{
io_hide(io, sizeof(UDP_HEADER));
if(dhcps_rx(tcpips,io,src))
udps_replay(tcpips,io,&__BROADCAST);
else
ips_release_io(tcpips, io);
return;
}
#endif
#if(DNSS)
if((dst_port == DNS_PORT)&&(dst->u32.ip == tcpips->ips.ip.u32.ip))
{
io_hide(io, sizeof(UDP_HEADER));
if(dnss_rx(tcpips,io,src))
udps_replay(tcpips,io,src);
else
ips_release_io(tcpips, io);
return;
}
#endif
//search in listeners
handle = udps_find(tcpips, dst_port);
if (handle != INVALID_HANDLE)
{
uh = so_get(&tcpips->udps.handles, handle);
//listener or connected
if (uh->remote_port == 0 || (uh->remote_port == src_port && uh->remote_addr.u32.ip == src->u32.ip))
udps_send_user(tcpips, src, io, handle);
else
handle = INVALID_HANDLE;
}
#if(UDP_BROADCAST)
if ((handle == INVALID_HANDLE) && (dst->u32.ip != BROADCAST))
#else
if (handle == INVALID_HANDLE)
#endif
{
#if (UDP_DEBUG)
printf("UDP: no connection, datagramm dropped\n");
#endif //UDP_DEBUG
#if (ICMP)
icmps_tx_error(tcpips, io, ICMP_ERROR_PORT, 0);
#endif //ICMP
}
ips_release_io(tcpips, io);
}
