aboutsummaryrefslogtreecommitdiffstats
path: root/file.c
diff options
context:
space:
mode:
Diffstat (limited to 'file.c')
-rw-r--r--file.c8016
1 files changed, 8016 insertions, 0 deletions
diff --git a/file.c b/file.c
new file mode 100644
index 0000000..18346e9
--- /dev/null
+++ b/file.c
@@ -0,0 +1,8016 @@
+/* $Id: file.c,v 1.235 2004/04/16 18:47:19 ukai Exp $ */
+#include "fm.h"
+#include <sys/types.h>
+#include "myctype.h"
+#include <signal.h>
+#include <setjmp.h>
+#if defined(HAVE_WAITPID) || defined(HAVE_WAIT3)
+#include <sys/wait.h>
+#endif
+#include <stdio.h>
+#include <time.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <utime.h>
+/* foo */
+
+#include "html.h"
+#include "parsetagx.h"
+#include "local.h"
+#include "regex.h"
+
+#ifndef max
+#define max(a,b) ((a) > (b) ? (a) : (b))
+#endif /* not max */
+#ifndef min
+#define min(a,b) ((a) > (b) ? (b) : (a))
+#endif /* not min */
+
+static int frame_source = 0;
+
+static char *guess_filename(char *file);
+static int _MoveFile(char *path1, char *path2);
+static void uncompress_stream(URLFile *uf, char **src);
+static FILE *lessopen_stream(char *path);
+static Buffer *loadcmdout(char *cmd,
+ Buffer *(*loadproc) (URLFile *, Buffer *),
+ Buffer *defaultbuf);
+#ifndef USE_ANSI_COLOR
+#define addnewline(a,b,c,d,e,f,g) _addnewline(a,b,c,e,f,g)
+#endif
+static void addnewline(Buffer *buf, char *line, Lineprop *prop,
+ Linecolor *color, int pos, int width, int nlines);
+static void addLink(Buffer *buf, struct parsed_tag *tag);
+
+static JMP_BUF AbortLoading;
+
+static struct table *tables[MAX_TABLE];
+static struct table_mode table_mode[MAX_TABLE];
+
+#ifdef USE_IMAGE
+static ParsedURL *cur_baseURL = NULL;
+#ifdef USE_M17N
+static char cur_document_charset;
+#endif
+#endif
+
+static Str cur_title;
+static Str cur_select;
+static Str select_str;
+static int select_is_multiple;
+static int n_selectitem;
+static Str cur_option;
+static Str cur_option_value;
+static Str cur_option_label;
+static int cur_option_selected;
+static int cur_status;
+#ifdef MENU_SELECT
+/* menu based <select> */
+FormSelectOption *select_option;
+static int max_select = MAX_SELECT;
+static int n_select;
+static int cur_option_maxwidth;
+#endif /* MENU_SELECT */
+
+static Str cur_textarea;
+Str *textarea_str;
+static int cur_textarea_size;
+static int cur_textarea_rows;
+static int cur_textarea_readonly;
+static int n_textarea;
+static int ignore_nl_textarea;
+static int max_textarea = MAX_TEXTAREA;
+
+static int http_response_code;
+
+#ifdef USE_M17N
+static wc_ces content_charset = 0;
+static wc_ces meta_charset = 0;
+static char *check_charset(char *p);
+static char *check_accept_charset(char *p);
+#endif
+
+#define set_prevchar(x,y,n) Strcopy_charp_n((x),(y),(n))
+#define set_space_to_prevchar(x) Strcopy_charp_n((x)," ",1)
+
+struct link_stack {
+ int cmd;
+ short offset;
+ short pos;
+ struct link_stack *next;
+};
+
+static struct link_stack *link_stack = NULL;
+
+#define FORMSTACK_SIZE 10
+#define FRAMESTACK_SIZE 10
+
+#ifdef USE_NNTP
+#define Str_news_endline(s) ((s)->ptr[0]=='.'&&((s)->ptr[1]=='\n'||(s)->ptr[1]=='\r'||(s)->ptr[1]=='\0'))
+#endif /* USE_NNTP */
+
+#define INITIAL_FORM_SIZE 10
+static FormList **forms;
+static int *form_stack;
+static int form_max = -1;
+static int forms_size = 0;
+#define cur_form_id ((form_sp >= 0)? form_stack[form_sp] : -1)
+static int form_sp = 0;
+
+static clen_t current_content_length;
+
+static int cur_hseq;
+#ifdef USE_IMAGE
+static int cur_iseq;
+#endif
+
+#define MAX_UL_LEVEL 9
+#define UL_SYMBOL(x) (N_GRAPH_SYMBOL + (x))
+#define UL_SYMBOL_DISC UL_SYMBOL(9)
+#define UL_SYMBOL_CIRCLE UL_SYMBOL(10)
+#define UL_SYMBOL_SQUARE UL_SYMBOL(11)
+#define IMG_SYMBOL UL_SYMBOL(12)
+#define HR_SYMBOL 26
+
+#ifdef USE_COOKIE
+/* This array should be somewhere else */
+/* FIXME: gettextize? */
+char *violations[COO_EMAX] = {
+ "internal error",
+ "tail match failed",
+ "wrong number of dots",
+ "RFC 2109 4.3.2 rule 1",
+ "RFC 2109 4.3.2 rule 2.1",
+ "RFC 2109 4.3.2 rule 2.2",
+ "RFC 2109 4.3.2 rule 3",
+ "RFC 2109 4.3.2 rule 4",
+ "RFC XXXX 4.3.2 rule 5"
+};
+#endif
+
+/* *INDENT-OFF* */
+static struct compression_decoder {
+ int type;
+ char *ext;
+ char *mime_type;
+ int auxbin_p;
+ char *cmd;
+ char *name;
+ char *encoding;
+ char *encodings[4];
+} compression_decoders[] = {
+ { CMP_COMPRESS, ".gz", "application/x-gzip",
+ 0, GUNZIP_CMDNAME, GUNZIP_NAME, "gzip",
+ {"gzip", "x-gzip", NULL} },
+ { CMP_COMPRESS, ".Z", "application/x-compress",
+ 0, GUNZIP_CMDNAME, GUNZIP_NAME, "compress",
+ {"compress", "x-compress", NULL} },
+ { CMP_BZIP2, ".bz2", "application/x-bzip",
+ 0, BUNZIP2_CMDNAME, BUNZIP2_NAME, "bzip, bzip2",
+ {"x-bzip", "bzip", "bzip2", NULL} },
+ { CMP_DEFLATE, ".deflate", "application/x-deflate",
+ 1, INFLATE_CMDNAME, INFLATE_NAME, "deflate",
+ {"deflate", "x-deflate", NULL} },
+ { CMP_NOCOMPRESS, NULL, NULL, 0, NULL, NULL, NULL, {NULL}},
+};
+/* *INDENT-ON* */
+
+#define SAVE_BUF_SIZE 1536
+
+static MySignalHandler
+KeyAbort(SIGNAL_ARG)
+{
+ LONGJMP(AbortLoading, 1);
+ SIGNAL_RETURN;
+}
+
+static void
+UFhalfclose(URLFile *f)
+{
+ switch (f->scheme) {
+ case SCM_FTP:
+ closeFTP();
+ break;
+#ifdef USE_NNTP
+ case SCM_NEWS:
+ case SCM_NNTP:
+ closeNews();
+ break;
+#endif
+ default:
+ UFclose(f);
+ break;
+ }
+}
+
+int
+currentLn(Buffer *buf)
+{
+ if (buf->currentLine)
+ /* return buf->currentLine->real_linenumber + 1; */
+ return buf->currentLine->linenumber + 1;
+ else
+ return 1;
+}
+
+static Buffer *
+loadSomething(URLFile *f,
+ char *path,
+ Buffer *(*loadproc) (URLFile *, Buffer *), Buffer *defaultbuf)
+{
+ Buffer *buf;
+
+ if ((buf = loadproc(f, defaultbuf)) == NULL)
+ return NULL;
+
+ buf->filename = path;
+ if (buf->buffername == NULL || buf->buffername[0] == '\0') {
+ buf->buffername = checkHeader(buf, "Subject:");
+ if (buf->buffername == NULL)
+ buf->buffername = conv_from_system(lastFileName(path));
+ }
+ if (buf->currentURL.scheme == SCM_UNKNOWN)
+ buf->currentURL.scheme = f->scheme;
+ buf->real_scheme = f->scheme;
+ if (f->scheme == SCM_LOCAL && buf->sourcefile == NULL)
+ buf->sourcefile = path;
+ return buf;
+}
+
+int
+dir_exist(char *path)
+{
+ struct stat stbuf;
+
+ if (path == NULL || *path == '\0')
+ return 0;
+ if (stat(path, &stbuf) == -1)
+ return 0;
+ return IS_DIRECTORY(stbuf.st_mode);
+}
+
+static int
+is_dump_text_type(char *type)
+{
+ struct mailcap *mcap;
+ return (type && (mcap = searchExtViewer(type)) &&
+ (mcap->flags & (MAILCAP_HTMLOUTPUT | MAILCAP_COPIOUSOUTPUT)));
+}
+
+static int
+is_text_type(char *type)
+{
+ return (type == NULL || type[0] == '\0' ||
+ strncasecmp(type, "text/", 5) == 0 ||
+ strncasecmp(type, "message/", sizeof("message/") - 1) == 0);
+}
+
+static int
+is_plain_text_type(char *type)
+{
+ return ((type && strcasecmp(type, "text/plain") == 0) ||
+ (is_text_type(type) && !is_dump_text_type(type)));
+}
+
+static void
+check_compression(char *path, URLFile *uf)
+{
+ int len;
+ struct compression_decoder *d;
+
+ if (path == NULL)
+ return;
+
+ len = strlen(path);
+ uf->compression = CMP_NOCOMPRESS;
+ for (d = compression_decoders; d->type != CMP_NOCOMPRESS; d++) {
+ int elen;
+ if (d->ext == NULL)
+ continue;
+ elen = strlen(d->ext);
+ if (len > elen && strcasecmp(&path[len - elen], d->ext) == 0) {
+ uf->compression = d->type;
+ uf->guess_type = d->mime_type;
+ break;
+ }
+ }
+}
+
+static char *
+compress_application_type(int compression)
+{
+ struct compression_decoder *d;
+
+ for (d = compression_decoders; d->type != CMP_NOCOMPRESS; d++) {
+ if (d->type == compression)
+ return d->mime_type;
+ }
+ return NULL;
+}
+
+static char *
+uncompressed_file_type(char *path, char **ext)
+{
+ int len, slen;
+ Str fn;
+ char *t0;
+ struct compression_decoder *d;
+
+ if (path == NULL)
+ return NULL;
+
+ slen = 0;
+ len = strlen(path);
+ for (d = compression_decoders; d->type != CMP_NOCOMPRESS; d++) {
+ if (d->ext == NULL)
+ continue;
+ slen = strlen(d->ext);
+ if (len > slen && strcasecmp(&path[len - slen], d->ext) == 0)
+ break;
+ }
+ if (d->type == CMP_NOCOMPRESS)
+ return NULL;
+
+ fn = Strnew_charp(path);
+ Strshrink(fn, slen);
+ if (ext)
+ *ext = filename_extension(fn->ptr, 0);
+ t0 = guessContentType(fn->ptr);
+ if (t0 == NULL)
+ t0 = "text/plain";
+ return t0;
+}
+
+static int
+setModtime(char *path, time_t modtime)
+{
+ struct utimbuf t;
+ struct stat st;
+
+ if (stat(path, &st) == 0)
+ t.actime = st.st_atime;
+ else
+ t.actime = time(NULL);
+ t.modtime = modtime;
+ return utime(path, &t);
+}
+
+void
+examineFile(char *path, URLFile *uf)
+{
+ struct stat stbuf;
+
+ uf->guess_type = NULL;
+ if (path == NULL || *path == '\0' ||
+ stat(path, &stbuf) == -1 || NOT_REGULAR(stbuf.st_mode)) {
+ uf->stream = NULL;
+ return;
+ }
+ uf->stream = openIS(path);
+ if (!do_download) {
+ if (use_lessopen && getenv("LESSOPEN") != NULL) {
+ FILE *fp;
+ uf->guess_type = guessContentType(path);
+ if (uf->guess_type == NULL)
+ uf->guess_type = "text/plain";
+ if (strcasecmp(uf->guess_type, "text/html") == 0)
+ return;
+ if ((fp = lessopen_stream(path))) {
+ UFclose(uf);
+ uf->stream = newFileStream(fp, (void (*)())pclose);
+ uf->guess_type = "text/plain";
+ return;
+ }
+ }
+ check_compression(path, uf);
+ if (uf->compression != CMP_NOCOMPRESS) {
+ char *ext = uf->ext;
+ char *t0 = uncompressed_file_type(path, &ext);
+ uf->guess_type = t0;
+ uf->ext = ext;
+ uncompress_stream(uf, NULL);
+ return;
+ }
+ }
+}
+
+#define S_IXANY (S_IXUSR|S_IXGRP|S_IXOTH)
+
+int
+check_command(char *cmd, int auxbin_p)
+{
+ static char *path = NULL;
+ Str dirs;
+ char *p, *np;
+ Str pathname;
+ struct stat st;
+
+ if (path == NULL)
+ path = getenv("PATH");
+ if (auxbin_p)
+ dirs = Strnew_charp(w3m_auxbin_dir());
+ else
+ dirs = Strnew_charp(path);
+ for (p = dirs->ptr; p != NULL; p = np) {
+ np = strchr(p, PATH_SEPARATOR);
+ if (np)
+ *np++ = '\0';
+ pathname = Strnew();
+ Strcat_charp(pathname, p);
+ Strcat_char(pathname, '/');
+ Strcat_charp(pathname, cmd);
+ if (stat(pathname->ptr, &st) == 0 && S_ISREG(st.st_mode)
+ && (st.st_mode & S_IXANY) != 0)
+ return 1;
+ }
+ return 0;
+}
+
+char *
+acceptableEncoding()
+{
+ static Str encodings = NULL;
+ struct compression_decoder *d;
+ TextList *l;
+ char *p;
+
+ if (encodings != NULL)
+ return encodings->ptr;
+ l = newTextList();
+ for (d = compression_decoders; d->type != CMP_NOCOMPRESS; d++) {
+ if (check_command(d->cmd, d->auxbin_p)) {
+ pushText(l, d->encoding);
+ }
+ }
+ encodings = Strnew();
+ while ((p = popText(l)) != NULL) {
+ if (encodings->length)
+ Strcat_charp(encodings, ", ");
+ Strcat_charp(encodings, p);
+ }
+ return encodings->ptr;
+}
+
+/*
+ * convert line
+ */
+#ifdef USE_M17N
+Str
+convertLine(URLFile *uf, Str line, int mode, wc_ces * charset,
+ wc_ces doc_charset)
+#else
+Str
+convertLine0(URLFile *uf, Str line, int mode)
+#endif
+{
+#ifdef USE_M17N
+ line = wc_Str_conv_with_detect(line, charset, doc_charset, InnerCharset);
+#endif
+ if (mode != RAW_MODE)
+ cleanup_line(line, mode);
+#ifdef USE_NNTP
+ if (uf && uf->scheme == SCM_NEWS)
+ Strchop(line);
+#endif /* USE_NNTP */
+ return line;
+}
+
+/*
+ * loadFile: load file to buffer
+ */
+Buffer *
+loadFile(char *path)
+{
+ Buffer *buf;
+ URLFile uf;
+ init_stream(&uf, SCM_LOCAL, NULL);
+ examineFile(path, &uf);
+ if (uf.stream == NULL)
+ return NULL;
+ buf = newBuffer(INIT_BUFFER_WIDTH);
+ current_content_length = 0;
+#ifdef USE_M17N
+ content_charset = 0;
+#endif
+ buf = loadSomething(&uf, path, loadBuffer, buf);
+ UFclose(&uf);
+ return buf;
+}
+
+int
+matchattr(char *p, char *attr, int len, Str *value)
+{
+ int quoted;
+ char *q = NULL;
+
+ if (strncasecmp(p, attr, len) == 0) {
+ p += len;
+ SKIP_BLANKS(p);
+ if (value) {
+ *value = Strnew();
+ if (*p == '=') {
+ p++;
+ SKIP_BLANKS(p);
+ quoted = 0;
+ while (!IS_ENDL(*p) && (quoted || *p != ';')) {
+ if (!IS_SPACE(*p))
+ q = p;
+ if (*p == '"')
+ quoted = (quoted) ? 0 : 1;
+ else
+ Strcat_char(*value, *p);
+ p++;
+ }
+ if (q)
+ Strshrink(*value, p - q - 1);
+ }
+ return 1;
+ }
+ else {
+ if (IS_ENDT(*p)) {
+ return 1;
+ }
+ }
+ }
+ return 0;
+}
+
+#ifdef USE_IMAGE
+#ifdef USE_XFACE
+static char *
+xface2xpm(char *xface)
+{
+ Image image;
+ ImageCache *cache;
+ FILE *f;
+ struct stat st;
+
+ SKIP_BLANKS(xface);
+ image.url = xface;
+ image.ext = ".xpm";
+ image.width = 48;
+ image.height = 48;
+ image.cache = NULL;
+ cache = getImage(&image, NULL, IMG_FLAG_AUTO);
+ if (cache->loaded & IMG_FLAG_LOADED && !stat(cache->file, &st))
+ return cache->file;
+ cache->loaded = IMG_FLAG_ERROR;
+
+ f = popen(Sprintf("%s > %s", shell_quote(auxbinFile(XFACE2XPM)),
+ shell_quote(cache->file))->ptr, "w");
+ if (!f)
+ return NULL;
+ fputs(xface, f);
+ pclose(f);
+ if (stat(cache->file, &st) || !st.st_size)
+ return NULL;
+ cache->loaded = IMG_FLAG_LOADED | IMG_FLAG_DONT_REMOVE;
+ cache->index = 0;
+ return cache->file;
+}
+#endif
+#endif
+
+void
+readHeader(URLFile *uf, Buffer *newBuf, int thru, ParsedURL *pu)
+{
+ char *p, *q;
+#ifdef USE_COOKIE
+ char *emsg;
+#endif
+ char c;
+ Str lineBuf2 = NULL;
+ Str tmp;
+ TextList *headerlist;
+#ifdef USE_M17N
+ wc_ces charset = WC_CES_US_ASCII, mime_charset;
+#endif
+ char *tmpf;
+ FILE *src = NULL;
+ Lineprop *propBuffer;
+
+ headerlist = newBuf->document_header = newTextList();
+ if (uf->scheme == SCM_HTTP
+#ifdef USE_SSL
+ || uf->scheme == SCM_HTTPS
+#endif /* USE_SSL */
+ )
+ http_response_code = -1;
+ else
+ http_response_code = 0;
+
+ if (thru && !newBuf->header_source
+#ifdef USE_IMAGE
+ && !image_source
+#endif
+ ) {
+ tmpf = tmpfname(TMPF_DFL, NULL)->ptr;
+ src = fopen(tmpf, "w");
+ if (src)
+ newBuf->header_source = tmpf;
+ }
+ while ((tmp = StrmyUFgets(uf))->length) {
+#ifdef USE_NNTP
+ if (uf->scheme == SCM_NEWS && tmp->ptr[0] == '.')
+ Strshrinkfirst(tmp, 1);
+#endif
+#ifdef HTTP_DEBUG
+ {
+ FILE *ff;
+ ff = fopen("zzrequest", "a");
+ Strfputs(tmp, ff);
+ fclose(ff);
+ }
+#endif /* HTTP_DEBUG */
+ if (src)
+ Strfputs(tmp, src);
+ cleanup_line(tmp, HEADER_MODE);
+ if (tmp->ptr[0] == '\n' || tmp->ptr[0] == '\r' || tmp->ptr[0] == '\0') {
+ if (!lineBuf2)
+ /* there is no header */
+ break;
+ /* last header */
+ }
+ else if (!(w3m_dump & DUMP_HEAD)) {
+ if (lineBuf2) {
+ Strcat(lineBuf2, tmp);
+ }
+ else {
+ lineBuf2 = tmp;
+ }
+ c = UFgetc(uf);
+ UFundogetc(uf);
+ if (c == ' ' || c == '\t')
+ /* header line is continued */
+ continue;
+ lineBuf2 = decodeMIME(lineBuf2, &mime_charset);
+ lineBuf2 = convertLine(NULL, lineBuf2, RAW_MODE,
+ mime_charset ? &mime_charset : &charset,
+ mime_charset ? mime_charset
+ : DocumentCharset);
+ /* separated with line and stored */
+ tmp = Strnew_size(lineBuf2->length);
+ for (p = lineBuf2->ptr; *p; p = q) {
+ for (q = p; *q && *q != '\r' && *q != '\n'; q++) ;
+ lineBuf2 = checkType(Strnew_charp_n(p, q - p), &propBuffer,
+ NULL);
+ Strcat(tmp, lineBuf2);
+ if (thru)
+ addnewline(newBuf, lineBuf2->ptr, propBuffer, NULL,
+ lineBuf2->length, FOLD_BUFFER_WIDTH, -1);
+ for (; *q && (*q == '\r' || *q == '\n'); q++) ;
+ }
+#ifdef USE_IMAGE
+ if (thru && activeImage && displayImage) {
+ Str src = NULL;
+ if (!strncasecmp(tmp->ptr, "X-Image-URL:", 12)) {
+ tmpf = &tmp->ptr[12];
+ SKIP_BLANKS(tmpf);
+ src = Strnew_m_charp("<img src=\"", html_quote(tmpf),
+ "\" alt=\"X-Image-URL\">", NULL);
+ }
+#ifdef USE_XFACE
+ else if (!strncasecmp(tmp->ptr, "X-Face:", 7)) {
+ tmpf = xface2xpm(&tmp->ptr[7]);
+ if (tmpf)
+ src = Strnew_m_charp("<img src=\"file:",
+ html_quote(tmpf),
+ "\" alt=\"X-Face\"",
+ " width=48 height=48>", NULL);
+ }
+#endif
+ if (src) {
+ URLFile f;
+ Line *l;
+#ifdef USE_M17N
+ wc_ces old_charset = newBuf->document_charset;
+#endif
+ init_stream(&f, SCM_LOCAL, newStrStream(src));
+ loadHTMLstream(&f, newBuf, NULL, TRUE);
+ for (l = newBuf->lastLine; l && l->real_linenumber;
+ l = l->prev)
+ l->real_linenumber = 0;
+#ifdef USE_M17N
+ newBuf->document_charset = old_charset;
+#endif
+ }
+ }
+#endif
+ lineBuf2 = tmp;
+ }
+ else {
+ lineBuf2 = tmp;
+ }
+ if ((uf->scheme == SCM_HTTP
+#ifdef USE_SSL
+ || uf->scheme == SCM_HTTPS
+#endif /* USE_SSL */
+ ) && http_response_code == -1) {
+ p = lineBuf2->ptr;
+ while (*p && !IS_SPACE(*p))
+ p++;
+ while (*p && IS_SPACE(*p))
+ p++;
+ http_response_code = atoi(p);
+ if (fmInitialized) {
+ message(lineBuf2->ptr, 0, 0);
+ refresh();
+ }
+ }
+ if (!strncasecmp(lineBuf2->ptr, "content-transfer-encoding:", 26)) {
+ p = lineBuf2->ptr + 26;
+ while (IS_SPACE(*p))
+ p++;
+ if (!strncasecmp(p, "base64", 6))
+ uf->encoding = ENC_BASE64;
+ else if (!strncasecmp(p, "quoted-printable", 16))
+ uf->encoding = ENC_QUOTE;
+ else if (!strncasecmp(p, "uuencode", 8) ||
+ !strncasecmp(p, "x-uuencode", 10))
+ uf->encoding = ENC_UUENCODE;
+ else
+ uf->encoding = ENC_7BIT;
+ }
+ else if (!strncasecmp(lineBuf2->ptr, "content-encoding:", 17)) {
+ struct compression_decoder *d;
+ p = lineBuf2->ptr + 17;
+ while (IS_SPACE(*p))
+ p++;
+ uf->compression = CMP_NOCOMPRESS;
+ for (d = compression_decoders; d->type != CMP_NOCOMPRESS; d++) {
+ char **e;
+ for (e = d->encodings; *e != NULL; e++) {
+ if (strncasecmp(p, *e, strlen(*e)) == 0) {
+ uf->compression = d->type;
+ break;
+ }
+ }
+ if (uf->compression != CMP_NOCOMPRESS)
+ break;
+ }
+ }
+#ifdef USE_COOKIE
+ else if (use_cookie && accept_cookie &&
+ pu && check_cookie_accept_domain(pu->host) &&
+ (!strncasecmp(lineBuf2->ptr, "Set-Cookie:", 11) ||
+ !strncasecmp(lineBuf2->ptr, "Set-Cookie2:", 12))) {
+ Str name = Strnew(), value = Strnew(), domain = NULL, path = NULL,
+ comment = NULL, commentURL = NULL, port = NULL, tmp2;
+ int version, quoted, flag = 0;
+ time_t expires = (time_t) - 1;
+
+ q = NULL;
+ if (lineBuf2->ptr[10] == '2') {
+ p = lineBuf2->ptr + 12;
+ version = 1;
+ }
+ else {
+ p = lineBuf2->ptr + 11;
+ version = 0;
+ }
+#ifdef DEBUG
+ fprintf(stderr, "Set-Cookie: [%s]\n", p);
+#endif /* DEBUG */
+ SKIP_BLANKS(p);
+ while (*p != '=' && !IS_ENDT(*p))
+ Strcat_char(name, *(p++));
+ Strremovetrailingspaces(name);
+ if (*p == '=') {
+ p++;
+ SKIP_BLANKS(p);
+ quoted = 0;
+ while (!IS_ENDL(*p) && (quoted || *p != ';')) {
+ if (!IS_SPACE(*p))
+ q = p;
+ if (*p == '"')
+ quoted = (quoted) ? 0 : 1;
+ Strcat_char(value, *(p++));
+ }
+ if (q)
+ Strshrink(value, p - q - 1);
+ }
+ while (*p == ';') {
+ p++;
+ SKIP_BLANKS(p);
+ if (matchattr(p, "expires", 7, &tmp2)) {
+ /* version 0 */
+ expires = mymktime(tmp2->ptr);
+ }
+ else if (matchattr(p, "max-age", 7, &tmp2)) {
+ /* XXX Is there any problem with max-age=0? (RFC 2109 ss. 4.2.1, 4.2.2 */
+ expires = time(NULL) + atol(tmp2->ptr);
+ }
+ else if (matchattr(p, "domain", 6, &tmp2)) {
+ domain = tmp2;
+ }
+ else if (matchattr(p, "path", 4, &tmp2)) {
+ path = tmp2;
+ }
+ else if (matchattr(p, "secure", 6, NULL)) {
+ flag |= COO_SECURE;
+ }
+ else if (matchattr(p, "comment", 7, &tmp2)) {
+ comment = tmp2;
+ }
+ else if (matchattr(p, "version", 7, &tmp2)) {
+ version = atoi(tmp2->ptr);
+ }
+ else if (matchattr(p, "port", 4, &tmp2)) {
+ /* version 1, Set-Cookie2 */
+ port = tmp2;
+ }
+ else if (matchattr(p, "commentURL", 10, &tmp2)) {
+ /* version 1, Set-Cookie2 */
+ commentURL = tmp2;
+ }
+ else if (matchattr(p, "discard", 7, NULL)) {
+ /* version 1, Set-Cookie2 */
+ flag |= COO_DISCARD;
+ }
+ quoted = 0;
+ while (!IS_ENDL(*p) && (quoted || *p != ';')) {
+ if (*p == '"')
+ quoted = (quoted) ? 0 : 1;
+ p++;
+ }
+ }
+ if (pu && name->length > 0) {
+ int err;
+ if (flag & COO_SECURE)
+ disp_message_nsec("Received a secured cookie", FALSE, 1,
+ TRUE, FALSE);
+ else
+ disp_message_nsec(Sprintf("Received cookie: %s=%s",
+ name->ptr, value->ptr)->ptr,
+ FALSE, 1, TRUE, FALSE);
+ err =
+ add_cookie(pu, name, value, expires, domain, path, flag,
+ comment, version, port, commentURL);
+ if (err) {
+ char *ans = (accept_bad_cookie == ACCEPT_BAD_COOKIE_ACCEPT)
+ ? "y" : NULL;
+ if (fmInitialized && (err & COO_OVERRIDE_OK) &&
+ accept_bad_cookie == ACCEPT_BAD_COOKIE_ASK) {
+ Str msg = Sprintf("Accept bad cookie from %s for %s?",
+ pu->host,
+ ((domain && domain->ptr)
+ ? domain->ptr : "<localdomain>"));
+ if (msg->length > COLS - 10)
+ Strshrink(msg, msg->length - (COLS - 10));
+ Strcat_charp(msg, " (y/n)");
+ ans = inputAnswer(msg->ptr);
+ }
+ if (ans == NULL || TOLOWER(*ans) != 'y' ||
+ (err =
+ add_cookie(pu, name, value, expires, domain, path,
+ flag | COO_OVERRIDE, comment, version,
+ port, commentURL))) {
+ err = (err & ~COO_OVERRIDE_OK) - 1;
+ if (err >= 0 && err < COO_EMAX)
+ emsg = Sprintf("This cookie was rejected "
+ "to prevent security violation. [%s]",
+ violations[err])->ptr;
+ else
+ emsg =
+ "This cookie was rejected to prevent security violation.";
+ record_err_message(emsg);
+ disp_message_nsec(emsg, FALSE, 1, TRUE, FALSE);
+ }
+ else
+ disp_message_nsec(Sprintf
+ ("Accepting invalid cookie: %s=%s",
+ name->ptr, value->ptr)->ptr, FALSE,
+ 1, TRUE, FALSE);
+ }
+ }
+ }
+#endif /* USE_COOKIE */
+ else if (!strncasecmp(lineBuf2->ptr, "w3m-control:", 12) &&
+ uf->scheme == SCM_LOCAL_CGI) {
+ Str funcname = Strnew();
+ int f;
+
+ p = lineBuf2->ptr + 12;
+ SKIP_BLANKS(p);
+ while (*p && !IS_SPACE(*p))
+ Strcat_char(funcname, *(p++));
+ SKIP_BLANKS(p);
+ f = getFuncList(funcname->ptr);
+ if (f >= 0) {
+ tmp = Strnew_charp(p);
+ Strchop(tmp);
+ pushEvent(f, tmp->ptr);
+ }
+ }
+ if (headerlist)
+ pushText(headerlist, lineBuf2->ptr);
+ Strfree(lineBuf2);
+ lineBuf2 = NULL;
+ }
+ if (thru)
+ addnewline(newBuf, "", propBuffer, NULL, 0, -1, -1);
+ if (src)
+ fclose(src);
+}
+
+char *
+checkHeader(Buffer *buf, char *field)
+{
+ int len;
+ TextListItem *i;
+ char *p;
+
+ if (buf == NULL || field == NULL || buf->document_header == NULL)
+ return NULL;
+ len = strlen(field);
+ for (i = buf->document_header->first; i != NULL; i = i->next) {
+ if (!strncasecmp(i->ptr, field, len)) {
+ p = i->ptr + len;
+ return remove_space(p);
+ }
+ }
+ return NULL;
+}
+
+char *
+checkContentType(Buffer *buf)
+{
+ char *p;
+ Str r;
+ p = checkHeader(buf, "Content-Type:");
+ if (p == NULL)
+ return NULL;
+ r = Strnew();
+ while (*p && *p != ';' && !IS_SPACE(*p))
+ Strcat_char(r, *p++);
+#ifdef USE_M17N
+ if ((p = strcasestr(p, "charset")) != NULL) {
+ p += 7;
+ SKIP_BLANKS(p);
+ if (*p == '=') {
+ p++;
+ SKIP_BLANKS(p);
+ if (*p == '"')
+ p++;
+ content_charset = wc_guess_charset(p, 0);
+ }
+ }
+#endif
+ return r->ptr;
+}
+
+struct auth_param {
+ char *name;
+ Str val;
+};
+
+struct http_auth {
+ int pri;
+ char *scheme;
+ struct auth_param *param;
+ Str (*cred) (struct http_auth * ha, Str uname, Str pw, ParsedURL *pu,
+ HRequest *hr, FormList *request);
+};
+
+#define TOKEN_PAT "[^][()<>@,;:\\\"/?={} \t\001-\037\177]*"
+
+static Str
+extract_auth_val(char **q)
+{
+ unsigned char *qq = *(unsigned char **)q;
+ int quoted = 0;
+ Str val = Strnew();
+
+ SKIP_BLANKS(qq);
+ if (*qq == '"') {
+ quoted = TRUE;
+ Strcat_char(val, *qq++);
+ }
+ while (*qq != '\0') {
+ if (quoted && *qq == '"') {
+ Strcat_char(val, *qq++);
+ break;
+ }
+ if (!quoted) {
+ switch (*qq) {
+ case '(':
+ case ')':
+ case '<':
+ case '>':
+ case '@':
+ case ',':
+ case ';':
+ case ':':
+ case '\\':
+ case '"':
+ case '/':
+ case '?':
+ case '=':
+ case ' ':
+ case '\t':
+ qq++;
+ goto end_token;
+ default:
+ if (*qq <= 037 || *qq == 0177) {
+ qq++;
+ goto end_token;
+ }
+ }
+ }
+ else if (quoted && *qq == '\\')
+ Strcat_char(val, *qq++);
+ Strcat_char(val, *qq++);
+ }
+ end_token:
+ if (*qq != '\0') {
+ SKIP_BLANKS(qq);
+ if (*qq == ',')
+ qq++;
+ }
+ *q = (char *)qq;
+ return val;
+}
+
+static Str
+qstr_unquote(Str s)
+{
+ char *p;
+
+ if (s == NULL)
+ return NULL;
+ p = s->ptr;
+ if (*p == '"') {
+ Str tmp = Strnew();
+ for (p++; *p != '\0'; p++) {
+ if (*p == '\\')
+ p++;
+ Strcat_char(tmp, *p);
+ }
+ if (Strlastchar(tmp) == '"')
+ Strshrink(tmp, 1);
+ return tmp;
+ }
+ else
+ return s;
+}
+
+static char *
+extract_auth_param(char *q, struct auth_param *auth)
+{
+ struct auth_param *ap;
+ char *q0;
+ Regex re_token;
+
+ newRegex(TOKEN_PAT, FALSE, &re_token, NULL);
+
+ for (ap = auth; ap->name != NULL; ap++) {
+ ap->val = NULL;
+ }
+
+ while (*q != '\0') {
+ SKIP_BLANKS(q);
+ for (ap = auth; ap->name != NULL; ap++) {
+ if (strncasecmp(q, ap->name, strlen(ap->name)) == 0) {
+ q += strlen(ap->name);
+ SKIP_BLANKS(q);
+ if (*q != '=')
+ return q;
+ q++;
+ ap->val = extract_auth_val(&q);
+ break;
+ }
+ }
+ if (ap->name == NULL) {
+ /* skip unknown param */
+ if (RegexMatch(&re_token, q, -1, TRUE) == 0)
+ return q;
+ MatchedPosition(&re_token, &q0, &q);
+ SKIP_BLANKS(q);
+ if (*q != '=')
+ return q;
+ q++;
+ extract_auth_val(&q);
+ }
+ }
+ return q;
+}
+
+static Str
+get_auth_param(struct auth_param *auth, char *name)
+{
+ struct auth_param *ap;
+ for (ap = auth; ap->name != NULL; ap++) {
+ if (strcasecmp(name, ap->name) == 0)
+ return ap->val;
+ }
+ return NULL;
+}
+
+static Str
+AuthBasicCred(struct http_auth *ha, Str uname, Str pw, ParsedURL *pu,
+ HRequest *hr, FormList *request)
+{
+ Str s = Strdup(uname);
+ Strcat_char(s, ':');
+ Strcat(s, pw);
+ return Strnew_m_charp("Basic ", encodeB(s->ptr)->ptr, NULL);
+}
+
+#ifdef USE_DIGEST_AUTH
+#include <openssl/md5.h>
+
+/* RFC2617: 3.2.2 The Authorization Request Header
+ *
+ * credentials = "Digest" digest-response
+ * digest-response = 1#( username | realm | nonce | digest-uri
+ * | response | [ algorithm ] | [cnonce] |
+ * [opaque] | [message-qop] |
+ * [nonce-count] | [auth-param] )
+ *
+ * username = "username" "=" username-value
+ * username-value = quoted-string
+ * digest-uri = "uri" "=" digest-uri-value
+ * digest-uri-value = request-uri ; As specified by HTTP/1.1
+ * message-qop = "qop" "=" qop-value
+ * cnonce = "cnonce" "=" cnonce-value
+ * cnonce-value = nonce-value
+ * nonce-count = "nc" "=" nc-value
+ * nc-value = 8LHEX
+ * response = "response" "=" request-digest
+ * request-digest = <"> 32LHEX <">
+ * LHEX = "0" | "1" | "2" | "3" |
+ * "4" | "5" | "6" | "7" |
+ * "8" | "9" | "a" | "b" |
+ * "c" | "d" | "e" | "f"
+ */
+
+static Str
+digest_hex(char *p)
+{
+ char *h = "0123456789abcdef";
+ Str tmp = Strnew_size(MD5_DIGEST_LENGTH * 2 + 1);
+ int i;
+ for (i = 0; i < MD5_DIGEST_LENGTH; i++, p++) {
+ Strcat_char(tmp, h[(*p >> 4) & 0x0f]);
+ Strcat_char(tmp, h[*p & 0x0f]);
+ }
+ return tmp;
+}
+
+static Str
+AuthDigestCred(struct http_auth *ha, Str uname, Str pw, ParsedURL *pu,
+ HRequest *hr, FormList *request)
+{
+ Str tmp, a1buf, a2buf, rd, s;
+ char md5[MD5_DIGEST_LENGTH + 1];
+ Str uri = HTTPrequestURI(pu, hr);
+ char nc[] = "00000001";
+
+ Str algorithm = qstr_unquote(get_auth_param(ha->param, "algorithm"));
+ Str nonce = qstr_unquote(get_auth_param(ha->param, "nonce"));
+ Str cnonce = qstr_unquote(get_auth_param(ha->param, "cnonce"));
+ Str qop = qstr_unquote(get_auth_param(ha->param, "qop"));
+
+ if (cnonce == NULL)
+ cnonce = Strnew_charp("cnonce"); /* XXX */
+
+ /* A1 = unq(username-value) ":" unq(realm-value) ":" passwd */
+ tmp = Strnew_m_charp(uname->ptr, ":",
+ qstr_unquote(get_auth_param(ha->param, "realm"))->ptr,
+ ":", pw->ptr, NULL);
+ MD5(tmp->ptr, strlen(tmp->ptr), md5);
+ a1buf = digest_hex(md5);
+
+ if (algorithm) {
+ if (strcasecmp(algorithm->ptr, "MD5-sess") == 0) {
+ /* A1 = H(unq(username-value) ":" unq(realm-value) ":" passwd)
+ * ":" unq(nonce-value) ":" unq(cnonce-value)
+ */
+ if (nonce == NULL)
+ return NULL;
+ tmp = Strnew_m_charp(a1buf->ptr, ":",
+ qstr_unquote(nonce)->ptr,
+ ":", qstr_unquote(cnonce)->ptr, NULL);
+ MD5(tmp->ptr, strlen(tmp->ptr), md5);
+ a1buf = digest_hex(md5);
+ }
+ else if (strcasecmp(algorithm->ptr, "MD5") == 0)
+ /* ok default */
+ ;
+ else
+ /* unknown algorithm */
+ return NULL;
+ }
+
+ /* A2 = Method ":" digest-uri-value */
+ tmp = Strnew_m_charp(HTTPrequestMethod(hr)->ptr, ":", uri->ptr, NULL);
+ if (qop && (strcasecmp(qop->ptr, "auth-int") == 0)) {
+ /* A2 = Method ":" digest-uri-value ":" H(entity-body) */
+ Str ebody = Strnew();
+ if (request && request->body) {
+ FILE *fp = fopen(request->body, "r");
+ if (fp != NULL) {
+ int c;
+ while ((c = fgetc(fp)) != EOF)
+ Strcat_char(ebody, c);
+ fclose(fp);
+ }
+ }
+ MD5(ebody->ptr, strlen(ebody->ptr), md5);
+ ebody = digest_hex(md5);
+ Strcat_m_charp(tmp, ":", ebody->ptr, NULL);
+ }
+ MD5(tmp->ptr, strlen(tmp->ptr), md5);
+ a2buf = digest_hex(md5);
+
+ if (qop &&
+ (strcasecmp(qop->ptr, "auth") == 0
+ || strcasecmp(qop->ptr, "auth-int") == 0)) {
+ /* request-digest = <"> < KD ( H(A1), unq(nonce-value)
+ * ":" nc-value
+ * ":" unq(cnonce-value)
+ * ":" unq(qop-value)
+ * ":" H(A2)
+ * ) <">
+ */
+ if (nonce == NULL)
+ return NULL;
+ tmp = Strnew_m_charp(a1buf->ptr, ":", qstr_unquote(nonce)->ptr,
+ ":", nc,
+ ":", qstr_unquote(cnonce)->ptr,
+ ":", qstr_unquote(qop)->ptr,
+ ":", a2buf->ptr, NULL);
+ MD5(tmp->ptr, strlen(tmp->ptr), md5);
+ rd = digest_hex(md5);
+ }
+ else {
+ /* compatibility with RFC 2069
+ * request_digest = KD(H(A1), unq(nonce), H(A2))
+ */
+ tmp = Strnew_m_charp(a1buf->ptr, ":",
+ qstr_unquote(get_auth_param(ha->param, "nonce"))->
+ ptr, ":", a2buf->ptr, NULL);
+ MD5(tmp->ptr, strlen(tmp->ptr), md5);
+ rd = digest_hex(md5);
+ }
+
+ /*
+ * digest-response = 1#( username | realm | nonce | digest-uri
+ * | response | [ algorithm ] | [cnonce] |
+ * [opaque] | [message-qop] |
+ * [nonce-count] | [auth-param] )
+ */
+
+ tmp = Strnew_m_charp("Digest username=\"", uname->ptr, "\"", NULL);
+ Strcat_m_charp(tmp, ", realm=",
+ get_auth_param(ha->param, "realm")->ptr, NULL);
+ Strcat_m_charp(tmp, ", nonce=",
+ get_auth_param(ha->param, "nonce")->ptr, NULL);
+ Strcat_m_charp(tmp, ", uri=\"", uri->ptr, "\"", NULL);
+ Strcat_m_charp(tmp, ", response=\"", rd->ptr, "\"", NULL);
+
+ if (algorithm)
+ Strcat_m_charp(tmp, ", algorithm=",
+ get_auth_param(ha->param, "algorithm")->ptr, NULL);
+
+ if (cnonce)
+ Strcat_m_charp(tmp, ", cnonce=\"", cnonce->ptr, "\"", NULL);
+
+ if ((s = get_auth_param(ha->param, "opaque")) != NULL)
+ Strcat_m_charp(tmp, ", opaque=", s->ptr, NULL);
+
+ if (qop) {
+ Strcat_m_charp(tmp, ", qop=",
+ get_auth_param(ha->param, "qop")->ptr, NULL);
+ /* XXX how to count? */
+ Strcat_m_charp(tmp, ", nc=", nc, NULL);
+ }
+
+ return tmp;
+}
+#endif
+
+/* *INDENT-OFF* */
+struct auth_param none_auth_param[] = {
+ {NULL, NULL}
+};
+
+struct auth_param basic_auth_param[] = {
+ {"realm", NULL},
+ {NULL, NULL}
+};
+
+#ifdef USE_DIGEST_AUTH
+/* RFC2617: 3.2.1 The WWW-Authenticate Response Header
+ * challenge = "Digest" digest-challenge
+ *
+ * digest-challenge = 1#( realm | [ domain ] | nonce |
+ * [ opaque ] |[ stale ] | [ algorithm ] |
+ * [ qop-options ] | [auth-param] )
+ *
+ * domain = "domain" "=" <"> URI ( 1*SP URI ) <">
+ * URI = absoluteURI | abs_path
+ * nonce = "nonce" "=" nonce-value
+ * nonce-value = quoted-string
+ * opaque = "opaque" "=" quoted-string
+ * stale = "stale" "=" ( "true" | "false" )
+ * algorithm = "algorithm" "=" ( "MD5" | "MD5-sess" |
+ * token )
+ * qop-options = "qop" "=" <"> 1#qop-value <">
+ * qop-value = "auth" | "auth-int" | token
+ */
+struct auth_param digest_auth_param[] = {
+ {"realm", NULL},
+ {"domain", NULL},
+ {"nonce", NULL},
+ {"opaque", NULL},
+ {"stale", NULL},
+ {"algorithm", NULL},
+ {"qop", NULL},
+ {NULL, NULL}
+};
+#endif
+/* for RFC2617: HTTP Authentication */
+struct http_auth www_auth[] = {
+ { 1, "Basic ", basic_auth_param, AuthBasicCred },
+#ifdef USE_DIGEST_AUTH
+ { 10, "Digest ", digest_auth_param, AuthDigestCred },
+#endif
+ { 0, NULL, NULL, NULL,}
+};
+/* *INDENT-ON* */
+
+static struct http_auth *
+findAuthentication(struct http_auth *hauth, Buffer *buf, char *auth_field)
+{
+ struct http_auth *ha;
+ int len = strlen(auth_field);
+ TextListItem *i;
+ char *p0, *p;
+ Regex re_token;
+
+ newRegex(TOKEN_PAT, FALSE, &re_token, NULL);
+
+ bzero(hauth, sizeof(struct http_auth));
+ for (i = buf->document_header->first; i != NULL; i = i->next) {
+ if (strncasecmp(i->ptr, auth_field, len) == 0) {
+ for (p = i->ptr + len; p != NULL && *p != '\0';) {
+ SKIP_BLANKS(p);
+ p0 = p;
+ for (ha = &www_auth[0]; ha->scheme != NULL; ha++) {
+ if (strncasecmp(p, ha->scheme, strlen(ha->scheme)) == 0) {
+ if (hauth->pri < ha->pri) {
+ *hauth = *ha;
+ p += strlen(ha->scheme);
+ SKIP_BLANKS(p);
+ p = extract_auth_param(p, hauth->param);
+ break;
+ }
+ else {
+ /* weak auth */
+ p += strlen(ha->scheme);
+ SKIP_BLANKS(p);
+ p = extract_auth_param(p, none_auth_param);
+ }
+ }
+ }
+ if (p0 == p) {
+ /* all unknown auth failed */
+ if (RegexMatch(&re_token, p0, -1, TRUE) == 0)
+ return NULL;
+ MatchedPosition(&re_token, &p0, &p);
+ SKIP_BLANKS(p);
+ p = extract_auth_param(p, none_auth_param);
+ }
+ }
+ }
+ }
+ return hauth->scheme ? hauth : NULL;
+}
+
+static void
+getAuthCookie(struct http_auth *hauth, char *auth_header,
+ TextList *extra_header, ParsedURL *pu, HRequest *hr,
+ FormList *request,
+ volatile Str *uname, volatile Str *pwd)
+{
+ Str ss = NULL;
+ Str tmp;
+ TextListItem *i;
+ int a_found;
+ int auth_header_len = strlen(auth_header);
+ char *realm = NULL;
+ int proxy;
+
+ if (hauth)
+ realm = qstr_unquote(get_auth_param(hauth->param, "realm"))->ptr;
+
+ if (!realm)
+ return;
+
+ a_found = FALSE;
+ for (i = extra_header->first; i != NULL; i = i->next) {
+ if (!strncasecmp(i->ptr, auth_header, auth_header_len)) {
+ a_found = TRUE;
+ break;
+ }
+ }
+ proxy = !strncasecmp("Proxy-Authorization:", auth_header,
+ auth_header_len);
+ if (a_found) {
+ /* This means that *-Authenticate: header is received after
+ * Authorization: header is sent to the server.
+ */
+ if (fmInitialized) {
+ message("Wrong username or password", 0, 0);
+ refresh();
+ }
+ else
+ fprintf(stderr, "Wrong username or password\n");
+ sleep(1);
+ /* delete Authenticate: header from extra_header */
+ delText(extra_header, i);
+ invalidate_auth_user_passwd(pu, realm, *uname, *pwd, proxy);
+ }
+ *uname = NULL;
+ *pwd = NULL;
+
+ if (!a_found && find_auth_user_passwd(pu, realm, (Str*)uname, (Str*)pwd,
+ proxy)) {
+ /* found username & password in passwd file */ ;
+ }
+ else {
+ if (QuietMessage)
+ return;
+ /* input username and password */
+ sleep(2);
+ if (fmInitialized) {
+ char *pp;
+ term_raw();
+ /* FIXME: gettextize? */
+ if ((pp = inputStr(Sprintf("Username for %s: ", realm)->ptr,
+ NULL)) == NULL)
+ return;
+ *uname = Str_conv_to_system(Strnew_charp(pp));
+ if ((pp = inputLine(Sprintf("Password for %s: ", realm)->ptr, NULL,
+ IN_PASSWORD)) == NULL) {
+ *uname = NULL;
+ return;
+ }
+ *pwd = Str_conv_to_system(Strnew_charp(pp));
+ term_cbreak();
+ }
+ else {
+ /*
+ * If post file is specified as '-', stdin is closed at this
+ * point.
+ * In this case, w3m cannot read username from stdin.
+ * So exit with error message.
+ * (This is same behavior as lwp-request.)
+ */
+ if (feof(stdin) || ferror(stdin)) {
+ /* FIXME: gettextize? */
+ fprintf(stderr, "w3m: Authorization required for %s\n",
+ realm);
+ exit(1);
+ }
+
+ /* FIXME: gettextize? */
+ printf(proxy ? "Proxy Username for %s: " : "Username for %s: ",
+ realm);
+ fflush(stdout);
+ *uname = Strfgets(stdin);
+ Strchop(*uname);
+#ifdef HAVE_GETPASSPHRASE
+ *pwd = Strnew_charp((char *)
+ getpassphrase(proxy ? "Proxy Password: " :
+ "Password: "));
+#else
+ *pwd = Strnew_charp((char *)
+ getpass(proxy ? "Proxy Password: " :
+ "Password: "));
+#endif
+ }
+ }
+ ss = hauth->cred(hauth, *uname, *pwd, pu, hr, request);
+ if (ss) {
+ tmp = Strnew_charp(auth_header);
+ Strcat_m_charp(tmp, " ", ss->ptr, "\r\n", NULL);
+ pushText(extra_header, tmp->ptr);
+ }
+ else {
+ *uname = NULL;
+ *pwd = NULL;
+ }
+ return;
+}
+
+static int
+same_url_p(ParsedURL *pu1, ParsedURL *pu2)
+{
+ return (pu1->scheme == pu2->scheme && pu1->port == pu2->port &&
+ (pu1->host ? pu2->host ? !strcasecmp(pu1->host, pu2->host) : 0 : 1)
+ && (pu1->file ? pu2->
+ file ? !strcmp(pu1->file, pu2->file) : 0 : 1));
+}
+
+static int
+checkRedirection(ParsedURL *pu)
+{
+ static ParsedURL *puv = NULL;
+ static int nredir = 0;
+ static int nredir_size = 0;
+ Str tmp;
+
+ if (pu == NULL) {
+ nredir = 0;
+ nredir_size = 0;
+ puv = NULL;
+ return TRUE;
+ }
+ if (nredir >= FollowRedirection) {
+ /* FIXME: gettextize? */
+ tmp = Sprintf("Number of redirections exceeded %d at %s",
+ FollowRedirection, parsedURL2Str(pu)->ptr);
+ disp_err_message(tmp->ptr, FALSE);
+ return FALSE;
+ }
+ else if (nredir_size > 0 &&
+ (same_url_p(pu, &puv[(nredir - 1) % nredir_size]) ||
+ (!(nredir % 2)
+ && same_url_p(pu, &puv[(nredir / 2) % nredir_size])))) {
+ /* FIXME: gettextize? */
+ tmp = Sprintf("Redirection loop detected (%s)",
+ parsedURL2Str(pu)->ptr);
+ disp_err_message(tmp->ptr, FALSE);
+ return FALSE;
+ }
+ if (!puv) {
+ nredir_size = FollowRedirection / 2 + 1;
+ puv = New_N(ParsedURL, nredir_size);
+ memset(puv, 0, sizeof(ParsedURL) * nredir_size);
+ }
+ copyParsedURL(&puv[nredir % nredir_size], pu);
+ nredir++;
+ return TRUE;
+}
+
+/*
+ * loadGeneralFile: load file to buffer
+ */
+Buffer *
+loadGeneralFile(char *path, ParsedURL *volatile current, char *referer,
+ int flag, FormList *volatile request)
+{
+ URLFile f, *volatile of = NULL;
+ ParsedURL pu;
+ Buffer *b = NULL, *(*volatile proc)() = loadBuffer;
+ char *volatile tpath;
+ char *volatile t = "text/plain", *p, *volatile real_type = NULL;
+ Buffer *volatile t_buf = NULL;
+ int volatile searchHeader = SearchHeader;
+ int volatile searchHeader_through = TRUE;
+ MySignalHandler(*volatile prevtrap) (SIGNAL_ARG) = NULL;
+ TextList *extra_header = newTextList();
+ volatile Str uname = NULL;
+ volatile Str pwd = NULL;
+ volatile Str realm = NULL;
+ int volatile add_auth_cookie_flag;
+ unsigned char status = HTST_NORMAL;
+ URLOption url_option;
+ Str tmp;
+ Str volatile page = NULL;
+#ifdef USE_M17N
+ wc_ces charset = WC_CES_US_ASCII;
+#endif
+ HRequest hr;
+ ParsedURL *volatile auth_pu;
+
+ tpath = path;
+ prevtrap = NULL;
+ add_auth_cookie_flag = 0;
+
+ checkRedirection(NULL);
+ load_doc:
+ TRAP_OFF;
+ url_option.referer = referer;
+ url_option.flag = flag;
+ f = openURL(tpath, &pu, current, &url_option, request, extra_header, of,
+ &hr, &status);
+ of = NULL;
+#ifdef USE_M17N
+ content_charset = 0;
+#endif
+ if (f.stream == NULL) {
+ switch (f.scheme) {
+ case SCM_LOCAL:
+ {
+ struct stat st;
+ if (stat(pu.real_file, &st) < 0)
+ return NULL;
+ if (S_ISDIR(st.st_mode)) {
+ if (UseExternalDirBuffer) {
+ Str cmd = Sprintf("%s?dir=%s#current",
+ DirBufferCommand, pu.file);
+ b = loadGeneralFile(cmd->ptr, NULL, NO_REFERER, 0,
+ NULL);
+ if (b != NULL && b != NO_BUFFER) {
+ copyParsedURL(&b->currentURL, &pu);
+ b->filename = b->currentURL.real_file;
+ }
+ return b;
+ }
+ else {
+ page = loadLocalDir(pu.real_file);
+ t = "local:directory";
+#ifdef USE_M17N
+ charset = SystemCharset;
+#endif
+ }
+ }
+ }
+ break;
+ case SCM_FTPDIR:
+ page = loadFTPDir(&pu, &charset);
+ t = "ftp:directory";
+ break;
+#ifdef USE_NNTP
+ case SCM_NEWS_GROUP:
+ page = loadNewsgroup(&pu, &charset);
+ t = "news:group";
+ break;
+#endif
+ case SCM_UNKNOWN:
+#ifdef USE_EXTERNAL_URI_LOADER
+ tmp = searchURIMethods(&pu);
+ if (tmp != NULL) {
+ b = loadGeneralFile(tmp->ptr, current, referer, flag, request);
+ if (b != NULL && b != NO_BUFFER)
+ copyParsedURL(&b->currentURL, &pu);
+ return b;
+ }
+#endif
+ /* FIXME: gettextize? */
+ disp_err_message(Sprintf("Unknown URI: %s",
+ parsedURL2Str(&pu)->ptr)->ptr, FALSE);
+ break;
+ }
+ if (page && page->length > 0)
+ goto page_loaded;
+ return NULL;
+ }
+
+ if (status == HTST_MISSING) {
+ TRAP_OFF;
+ UFclose(&f);
+ return NULL;
+ }
+
+ /* openURL() succeeded */
+ if (SETJMP(AbortLoading) != 0) {
+ /* transfer interrupted */
+ TRAP_OFF;
+ if (b)
+ discardBuffer(b);
+ UFclose(&f);
+ return NULL;
+ }
+
+ b = NULL;
+ if (f.is_cgi) {
+ /* local CGI */
+ searchHeader = TRUE;
+ searchHeader_through = FALSE;
+ }
+ if (header_string)
+ header_string = NULL;
+ TRAP_ON;
+ if (pu.scheme == SCM_HTTP ||
+#ifdef USE_SSL
+ pu.scheme == SCM_HTTPS ||
+#endif /* USE_SSL */
+ ((
+#ifdef USE_GOPHER
+ (pu.scheme == SCM_GOPHER && non_null(GOPHER_proxy)) ||
+#endif /* USE_GOPHER */
+ (pu.scheme == SCM_FTP && non_null(FTP_proxy))
+ ) && !Do_not_use_proxy && !check_no_proxy(pu.host))) {
+
+ if (fmInitialized) {
+ term_cbreak();
+ /* FIXME: gettextize? */
+ message(Sprintf("%s contacted. Waiting for reply...", pu.host)->
+ ptr, 0, 0);
+ refresh();
+ }
+ if (t_buf == NULL)
+ t_buf = newBuffer(INIT_BUFFER_WIDTH);
+#if 0 /* USE_SSL */
+ if (IStype(f.stream) == IST_SSL) {
+ Str s = ssl_get_certificate(f.stream, pu.host);
+ if (s == NULL)
+ return NULL;
+ else
+ t_buf->ssl_certificate = s->ptr;
+ }
+#endif
+ readHeader(&f, t_buf, FALSE, &pu);
+ if (((http_response_code >= 301 && http_response_code <= 303)
+ || http_response_code == 307)
+ && (p = checkHeader(t_buf, "Location:")) != NULL
+ && checkRedirection(&pu)) {
+ /* document moved */
+ /* 301: Moved Permanently */
+ /* 302: Found */
+ /* 303: See Other */
+ /* 307: Temporary Redirect (HTTP/1.1) */
+ tpath = url_quote_conv(p, DocumentCharset);
+ request = NULL;
+ UFclose(&f);
+ current = New(ParsedURL);
+ copyParsedURL(current, &pu);
+ t_buf = newBuffer(INIT_BUFFER_WIDTH);
+ t_buf->bufferprop |= BP_REDIRECTED;
+ status = HTST_NORMAL;
+ goto load_doc;
+ }
+ t = checkContentType(t_buf);
+ if (t == NULL && pu.file != NULL) {
+ if (!((http_response_code >= 400 && http_response_code <= 407) ||
+ (http_response_code >= 500 && http_response_code <= 505)))
+ t = guessContentType(pu.file);
+ }
+ if (t == NULL)
+ t = "text/plain";
+ if (add_auth_cookie_flag && realm && uname && pwd) {
+ /* If authorization is required and passed */
+ add_auth_user_passwd(&pu, qstr_unquote(realm)->ptr, uname, pwd,
+ 0);
+ add_auth_cookie_flag = 0;
+ }
+ if ((p = checkHeader(t_buf, "WWW-Authenticate:")) != NULL &&
+ http_response_code == 401) {
+ /* Authentication needed */
+ struct http_auth hauth;
+ if (findAuthentication(&hauth, t_buf, "WWW-Authenticate:") != NULL
+ && (realm = get_auth_param(hauth.param, "realm")) != NULL) {
+ auth_pu = &pu;
+ getAuthCookie(&hauth, "Authorization:", extra_header,
+ auth_pu, &hr, request, &uname, &pwd);
+ if (uname == NULL) {
+ /* abort */
+ TRAP_OFF;
+ goto page_loaded;
+ }
+ UFclose(&f);
+ add_auth_cookie_flag = 1;
+ status = HTST_NORMAL;
+ goto load_doc;
+ }
+ }
+ if ((p = checkHeader(t_buf, "Proxy-Authenticate:")) != NULL &&
+ http_response_code == 407) {
+ /* Authentication needed */
+ struct http_auth hauth;
+ if (findAuthentication(&hauth, t_buf, "Proxy-Authenticate:")
+ != NULL
+ && (realm = get_auth_param(hauth.param, "realm")) != NULL) {
+ auth_pu = schemeToProxy(pu.scheme);
+ getAuthCookie(&hauth, "Proxy-Authorization:",
+ extra_header, auth_pu, &hr, request,
+ &uname, &pwd);
+ if (uname == NULL) {
+ /* abort */
+ TRAP_OFF;
+ goto page_loaded;
+ }
+ UFclose(&f);
+ add_auth_cookie_flag = 1;
+ status = HTST_NORMAL;
+ goto load_doc;
+ }
+ }
+ /* XXX: RFC2617 3.2.3 Authentication-Info: ? */
+
+ if (status == HTST_CONNECT) {
+ of = &f;
+ goto load_doc;
+ }
+
+ f.modtime = mymktime(checkHeader(t_buf, "Last-Modified:"));
+ }
+#ifdef USE_NNTP
+ else if (pu.scheme == SCM_NEWS || pu.scheme == SCM_NNTP) {
+ if (t_buf == NULL)
+ t_buf = newBuffer(INIT_BUFFER_WIDTH);
+ readHeader(&f, t_buf, TRUE, &pu);
+ t = checkContentType(t_buf);
+ if (t == NULL)
+ t = "text/plain";
+ }
+#endif /* USE_NNTP */
+#ifdef USE_GOPHER
+ else if (pu.scheme == SCM_GOPHER) {
+ switch (*pu.file) {
+ case '0':
+ t = "text/plain";
+ break;
+ case '1':
+ case 'm':
+ page = loadGopherDir(&f, &pu, &charset);
+ t = "gopher:directory";
+ TRAP_OFF;
+ goto page_loaded;
+ case 's':
+ t = "audio/basic";
+ break;
+ case 'g':
+ t = "image/gif";
+ break;
+ case 'h':
+ t = "text/html";
+ break;
+ }
+ }
+#endif /* USE_GOPHER */
+ else if (pu.scheme == SCM_FTP) {
+ check_compression(path, &f);
+ if (f.compression != CMP_NOCOMPRESS) {
+ char *t1 = uncompressed_file_type(pu.file, NULL);
+ real_type = f.guess_type;
+#if 0
+ if (t1 && strncasecmp(t1, "application/", 12) == 0) {
+ f.compression = CMP_NOCOMPRESS;
+ t = real_type;
+ }
+ else
+#endif
+ if (t1)
+ t = t1;
+ else
+ t = real_type;
+ }
+ else {
+ real_type = guessContentType(pu.file);
+ if (real_type == NULL)
+ real_type = "text/plain";
+ t = real_type;
+ }
+#if 0
+ if (!strncasecmp(t, "application/", 12)) {
+ char *tmpf = tmpfname(TMPF_DFL, NULL)->ptr;
+ current_content_length = 0;
+ if (save2tmp(f, tmpf) < 0)
+ UFclose(&f);
+ else {
+ UFclose(&f);
+ TRAP_OFF;
+ doFileMove(tmpf, guess_save_name(t_buf, pu.file));
+ }
+ return NO_BUFFER;
+ }
+#endif
+ }
+ else if (pu.scheme == SCM_DATA) {
+ t = f.guess_type;
+ }
+ else if (searchHeader) {
+ searchHeader = SearchHeader = FALSE;
+ if (t_buf == NULL)
+ t_buf = newBuffer(INIT_BUFFER_WIDTH);
+ readHeader(&f, t_buf, searchHeader_through, &pu);
+ if (f.is_cgi && (p = checkHeader(t_buf, "Location:")) != NULL &&
+ checkRedirection(&pu)) {
+ /* document moved */
+ tpath = url_quote_conv(remove_space(p), DocumentCharset);
+ request = NULL;
+ UFclose(&f);
+ add_auth_cookie_flag = 0;
+ current = New(ParsedURL);
+ copyParsedURL(current, &pu);
+ t_buf = newBuffer(INIT_BUFFER_WIDTH);
+ t_buf->bufferprop |= BP_REDIRECTED;
+ status = HTST_NORMAL;
+ goto load_doc;
+ }
+ t = checkContentType(t_buf);
+ if (t == NULL)
+ t = "text/plain";
+ }
+ else if (DefaultType) {
+ t = DefaultType;
+ DefaultType = NULL;
+ }
+ else {
+ t = guessContentType(pu.file);
+ if (t == NULL)
+ t = "text/plain";
+ real_type = t;
+ if (f.guess_type)
+ t = f.guess_type;
+ }
+
+ page_loaded:
+ if (page) {
+ FILE *src;
+#ifdef USE_IMAGE
+ if (image_source)
+ return NULL;
+#endif
+ tmp = tmpfname(TMPF_SRC, ".html");
+ src = fopen(tmp->ptr, "w");
+ if (src) {
+ Str s;
+ s = wc_Str_conv_strict(page, InnerCharset, charset);
+ Strfputs(s, src);
+ fclose(src);
+ }
+ if (do_download) {
+ char *file;
+ if (!src)
+ return NULL;
+ file = guess_filename(pu.file);
+#ifdef USE_GOPHER
+ if (f.scheme == SCM_GOPHER)
+ file = Sprintf("%s.html", file)->ptr;
+#endif
+#ifdef USE_NNTP
+ if (f.scheme == SCM_NEWS_GROUP)
+ file = Sprintf("%s.html", file)->ptr;
+#endif
+ doFileMove(tmp->ptr, file);
+ return NO_BUFFER;
+ }
+ b = loadHTMLString(page);
+ if (b) {
+ copyParsedURL(&b->currentURL, &pu);
+ b->real_scheme = pu.scheme;
+ b->real_type = t;
+ if (src)
+ b->sourcefile = tmp->ptr;
+#ifdef USE_M17N
+ b->document_charset = charset;
+#endif
+ }
+ return b;
+ }
+
+ if (real_type == NULL)
+ real_type = t;
+ proc = loadBuffer;
+#ifdef USE_IMAGE
+ cur_baseURL = New(ParsedURL);
+ copyParsedURL(cur_baseURL, &pu);
+#endif
+
+ current_content_length = 0;
+ if ((p = checkHeader(t_buf, "Content-Length:")) != NULL)
+ current_content_length = strtoclen(p);
+ if (do_download) {
+ /* download only */
+ char *file;
+ TRAP_OFF;
+ if (DecodeCTE && IStype(f.stream) != IST_ENCODED)
+ f.stream = newEncodedStream(f.stream, f.encoding);
+ if (pu.scheme == SCM_LOCAL) {
+ struct stat st;
+ if (PreserveTimestamp && !stat(pu.real_file, &st))
+ f.modtime = st.st_mtime;
+ file = conv_from_system(guess_save_name(NULL, pu.real_file));
+ }
+ else
+ file = guess_save_name(t_buf, pu.file);
+ if (doFileSave(f, file) == 0)
+ UFhalfclose(&f);
+ else
+ UFclose(&f);
+ return NO_BUFFER;
+ }
+
+ if (f.compression != CMP_NOCOMPRESS) {
+ if (!(w3m_dump & DUMP_SOURCE) &&
+ (w3m_dump & ~DUMP_FRAME || is_text_type(t)
+ || searchExtViewer(t))) {
+ if (t_buf == NULL)
+ t_buf = newBuffer(INIT_BUFFER_WIDTH);
+ uncompress_stream(&f, &t_buf->sourcefile);
+ uncompressed_file_type(pu.file, &f.ext);
+ }
+ else {
+ t = compress_application_type(f.compression);
+ f.compression = CMP_NOCOMPRESS;
+ }
+ }
+#ifdef USE_IMAGE
+ if (image_source) {
+ Buffer *b = NULL;
+ if (IStype(f.stream) != IST_ENCODED)
+ f.stream = newEncodedStream(f.stream, f.encoding);
+ if (save2tmp(f, image_source) == 0) {
+ b = newBuffer(INIT_BUFFER_WIDTH);
+ b->sourcefile = image_source;
+ b->real_type = t;
+ }
+ UFclose(&f);
+ TRAP_OFF;
+ return b;
+ }
+#endif
+
+ if (!strcasecmp(t, "text/html"))
+ proc = loadHTMLBuffer;
+ else if (is_plain_text_type(t))
+ proc = loadBuffer;
+#ifdef USE_IMAGE
+ else if (activeImage && displayImage && !useExtImageViewer &&
+ !(w3m_dump & ~DUMP_FRAME) && !strncasecmp(t, "image/", 6))
+ proc = loadImageBuffer;
+#endif
+ else if (w3m_backend) ;
+ else if (!(w3m_dump & ~DUMP_FRAME) || is_dump_text_type(t)) {
+ if (!do_download && doExternal(f,
+ pu.real_file ? pu.real_file : pu.file,
+ t, &b, t_buf)) {
+ if (b && b != NO_BUFFER) {
+ b->real_scheme = f.scheme;
+ b->real_type = real_type;
+ if (b->currentURL.host == NULL && b->currentURL.file == NULL)
+ copyParsedURL(&b->currentURL, &pu);
+ }
+ UFclose(&f);
+ TRAP_OFF;
+ return b;
+ }
+ else {
+ TRAP_OFF;
+ if (pu.scheme == SCM_LOCAL) {
+ UFclose(&f);
+ _doFileCopy(pu.real_file,
+ conv_from_system(guess_save_name
+ (NULL, pu.real_file)), TRUE);
+ }
+ else {
+ if (DecodeCTE && IStype(f.stream) != IST_ENCODED)
+ f.stream = newEncodedStream(f.stream, f.encoding);
+ if (doFileSave(f, guess_save_name(t_buf, pu.file)) == 0)
+ UFhalfclose(&f);
+ else
+ UFclose(&f);
+ }
+ return NO_BUFFER;
+ }
+ }
+ else if (w3m_dump & DUMP_FRAME)
+ return NULL;
+
+ if (flag & RG_FRAME) {
+ if (t_buf == NULL)
+ t_buf = newBuffer(INIT_BUFFER_WIDTH);
+ t_buf->bufferprop |= BP_FRAME;
+ }
+#ifdef USE_SSL
+ if (t_buf)
+ t_buf->ssl_certificate = f.ssl_certificate;
+#endif
+ frame_source = flag & RG_FRAME_SRC;
+ b = loadSomething(&f, pu.real_file ? pu.real_file : pu.file, proc, t_buf);
+ UFclose(&f);
+ frame_source = 0;
+ if (b) {
+ b->real_scheme = f.scheme;
+ b->real_type = real_type;
+ if (b->currentURL.host == NULL && b->currentURL.file == NULL)
+ copyParsedURL(&b->currentURL, &pu);
+ if (!strcasecmp(t, "text/html"))
+ b->type = "text/html";
+ else if (w3m_backend) {
+ Str s = Strnew_charp(t);
+ b->type = s->ptr;
+ }
+#ifdef USE_IMAGE
+ else if (proc == loadImageBuffer)
+ b->type = "text/html";
+#endif
+ else
+ b->type = "text/plain";
+ if (pu.label) {
+ if (proc == loadHTMLBuffer) {
+ Anchor *a;
+ a = searchURLLabel(b, pu.label);
+ if (a != NULL) {
+ gotoLine(b, a->start.line);
+ if (label_topline)
+ b->topLine = lineSkip(b, b->topLine,
+ b->currentLine->linenumber
+ - b->topLine->linenumber, FALSE);
+ b->pos = a->start.pos;
+ arrangeCursor(b);
+ }
+ }
+ else { /* plain text */
+ int l = atoi(pu.label);
+ gotoLine(b, l);
+ b->pos = 0;
+ arrangeCursor(b);
+ }
+ }
+ }
+ if (header_string)
+ header_string = NULL;
+#ifdef USE_NNTP
+ if (f.scheme == SCM_NNTP || f.scheme == SCM_NEWS)
+ reAnchorNewsheader(b);
+#endif
+ preFormUpdateBuffer(b);
+ TRAP_OFF;
+ return b;
+}
+
+#define TAG_IS(s,tag,len)\
+ (strncasecmp(s,tag,len)==0&&(s[len] == '>' || IS_SPACE((int)s[len])))
+
+static char *
+has_hidden_link(struct readbuffer *obuf, int cmd)
+{
+ Str line = obuf->line;
+ struct link_stack *p;
+
+ if (Strlastchar(line) != '>')
+ return NULL;
+
+ for (p = link_stack; p; p = p->next)
+ if (p->cmd == cmd)
+ break;
+ if (!p)
+ return NULL;
+
+ if (obuf->pos == p->pos)
+ return line->ptr + p->offset;
+
+ return NULL;
+}
+
+static void
+push_link(int cmd, int offset, int pos)
+{
+ struct link_stack *p;
+ p = New(struct link_stack);
+ p->cmd = cmd;
+ p->offset = offset;
+ p->pos = pos;
+ p->next = link_stack;
+ link_stack = p;
+}
+
+static int
+is_period_char(unsigned char *ch)
+{
+ switch (*ch) {
+ case ',':
+ case '.':
+ case ':':
+ case ';':
+ case '?':
+ case '!':
+ case ')':
+ case ']':
+ case '}':
+ case '>':
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+static int
+is_beginning_char(unsigned char *ch)
+{
+ switch (*ch) {
+ case '(':
+ case '[':
+ case '{':
+ case '`':
+ case '<':
+ return 1;
+ default:
+ return 0;
+ }
+}
+
+static int
+is_word_char(unsigned char *ch)
+{
+ Lineprop ctype = get_mctype(ch);
+
+#ifdef USE_M17N
+ if (ctype & (PC_CTRL | PC_KANJI | PC_UNKNOWN))
+ return 0;
+ if (ctype & (PC_WCHAR1 | PC_WCHAR2))
+ return 1;
+#else
+ if (ctype == PC_CTRL)
+ return 0;
+#endif
+
+ if (IS_ALNUM(*ch))
+ return 1;
+
+ switch (*ch) {
+ case ',':
+ case '.':
+ case ':':
+ case '\"': /* " */
+ case '\'':
+ case '$':
+ case '%':
+ case '*':
+ case '+':
+ case '-':
+ case '@':
+ case '~':
+ case '_':
+ return 1;
+ }
+#ifdef USE_M17N
+ if (*ch == NBSP_CODE)
+ return 1;
+#else
+ if (*ch == TIMES_CODE || *ch == DIVIDE_CODE || *ch == ANSP_CODE)
+ return 0;
+ if (*ch >= AGRAVE_CODE || *ch == NBSP_CODE)
+ return 1;
+#endif
+ return 0;
+}
+
+#ifdef USE_M17N
+static int
+is_combining_char(unsigned char *ch)
+{
+ Lineprop ctype = get_mctype(ch);
+
+ if (ctype & PC_WCHAR2)
+ return 1;
+ return 0;
+}
+#endif
+
+int
+is_boundary(unsigned char *ch1, unsigned char *ch2)
+{
+ if (!*ch1 || !*ch2)
+ return 1;
+
+ if (*ch1 == ' ' && *ch2 == ' ')
+ return 0;
+
+ if (*ch1 != ' ' && is_period_char(ch2))
+ return 0;
+
+ if (*ch2 != ' ' && is_beginning_char(ch1))
+ return 0;
+
+#ifdef USE_M17N
+ if (is_combining_char(ch2))
+ return 0;
+#endif
+ if (is_word_char(ch1) && is_word_char(ch2))
+ return 0;
+
+ return 1;
+}
+
+
+static void
+set_breakpoint(struct readbuffer *obuf, int tag_length)
+{
+ obuf->bp.len = obuf->line->length;
+ obuf->bp.pos = obuf->pos;
+ obuf->bp.tlen = tag_length;
+ obuf->bp.flag = obuf->flag;
+#ifdef FORMAT_NICE
+ obuf->bp.flag &= ~RB_FILL;
+#endif /* FORMAT_NICE */
+ obuf->bp.top_margin = obuf->top_margin;
+ obuf->bp.bottom_margin = obuf->bottom_margin;
+
+ if (!obuf->bp.init_flag)
+ return;
+
+ bcopy((void *)&obuf->anchor, (void *)&obuf->bp.anchor,
+ sizeof(obuf->anchor));
+ obuf->bp.img_alt = obuf->img_alt;
+ obuf->bp.in_bold = obuf->in_bold;
+ obuf->bp.in_under = obuf->in_under;
+ obuf->bp.nobr_level = obuf->nobr_level;
+ obuf->bp.prev_ctype = obuf->prev_ctype;
+ obuf->bp.init_flag = 0;
+}
+
+static void
+back_to_breakpoint(struct readbuffer *obuf)
+{
+ obuf->flag = obuf->bp.flag;
+ bcopy((void *)&obuf->bp.anchor, (void *)&obuf->anchor,
+ sizeof(obuf->anchor));
+ obuf->img_alt = obuf->bp.img_alt;
+ obuf->in_bold = obuf->bp.in_bold;
+ obuf->in_under = obuf->bp.in_under;
+ obuf->prev_ctype = obuf->bp.prev_ctype;
+ obuf->pos = obuf->bp.pos;
+ obuf->top_margin = obuf->bp.top_margin;
+ obuf->bottom_margin = obuf->bp.bottom_margin;
+ if (obuf->flag & RB_NOBR)
+ obuf->nobr_level = obuf->bp.nobr_level;
+}
+
+static void
+append_tags(struct readbuffer *obuf)
+{
+ int i;
+ int len = obuf->line->length;
+ int set_bp = 0;
+
+ for (i = 0; i < obuf->tag_sp; i++) {
+ switch (obuf->tag_stack[i]->cmd) {
+ case HTML_A:
+ case HTML_IMG_ALT:
+ case HTML_B:
+ case HTML_U:
+ push_link(obuf->tag_stack[i]->cmd, obuf->line->length, obuf->pos);
+ break;
+ }
+ Strcat_charp(obuf->line, obuf->tag_stack[i]->cmdname);
+ switch (obuf->tag_stack[i]->cmd) {
+ case HTML_NOBR:
+ if (obuf->nobr_level > 1)
+ break;
+ case HTML_WBR:
+ set_bp = 1;
+ break;
+ }
+ }
+ obuf->tag_sp = 0;
+ if (set_bp)
+ set_breakpoint(obuf, obuf->line->length - len);
+}
+
+static void
+push_tag(struct readbuffer *obuf, char *cmdname, int cmd)
+{
+ obuf->tag_stack[obuf->tag_sp] = New(struct cmdtable);
+ obuf->tag_stack[obuf->tag_sp]->cmdname = allocStr(cmdname, -1);
+ obuf->tag_stack[obuf->tag_sp]->cmd = cmd;
+ obuf->tag_sp++;
+ if (obuf->tag_sp >= TAG_STACK_SIZE || obuf->flag & (RB_SPECIAL & ~RB_NOBR))
+ append_tags(obuf);
+}
+
+static void
+push_nchars(struct readbuffer *obuf, int width,
+ char *str, int len, Lineprop mode)
+{
+ append_tags(obuf);
+ Strcat_charp_n(obuf->line, str, len);
+ obuf->pos += width;
+ if (width > 0) {
+ set_prevchar(obuf->prevchar, str, len);
+ obuf->prev_ctype = mode;
+ }
+ obuf->flag |= RB_NFLUSHED;
+}
+
+#define push_charp(obuf, width, str, mode)\
+push_nchars(obuf, width, str, strlen(str), mode)
+
+#define push_str(obuf, width, str, mode)\
+push_nchars(obuf, width, str->ptr, str->length, mode)
+
+static void
+check_breakpoint(struct readbuffer *obuf, int pre_mode, char *ch)
+{
+ int tlen, len = obuf->line->length;
+
+ append_tags(obuf);
+ if (pre_mode)
+ return;
+ tlen = obuf->line->length - len;
+ if (tlen > 0
+ || is_boundary((unsigned char *)obuf->prevchar->ptr,
+ (unsigned char *)ch))
+ set_breakpoint(obuf, tlen);
+}
+
+static void
+push_char(struct readbuffer *obuf, int pre_mode, char ch)
+{
+ check_breakpoint(obuf, pre_mode, &ch);
+ Strcat_char(obuf->line, ch);
+ obuf->pos++;
+ set_prevchar(obuf->prevchar, &ch, 1);
+ if (ch != ' ')
+ obuf->prev_ctype = PC_ASCII;
+ obuf->flag |= RB_NFLUSHED;
+}
+
+#define PUSH(c) push_char(obuf, obuf->flag & RB_SPECIAL, c)
+
+static void
+push_spaces(struct readbuffer *obuf, int pre_mode, int width)
+{
+ int i;
+
+ if (width <= 0)
+ return;
+ check_breakpoint(obuf, pre_mode, " ");
+ for (i = 0; i < width; i++)
+ Strcat_char(obuf->line, ' ');
+ obuf->pos += width;
+ set_space_to_prevchar(obuf->prevchar);
+ obuf->flag |= RB_NFLUSHED;
+}
+
+static void
+proc_mchar(struct readbuffer *obuf, int pre_mode,
+ int width, char **str, Lineprop mode)
+{
+ check_breakpoint(obuf, pre_mode, *str);
+ obuf->pos += width;
+ Strcat_charp_n(obuf->line, *str, get_mclen(*str));
+ if (width > 0) {
+ set_prevchar(obuf->prevchar, *str, 1);
+ if (**str != ' ')
+ obuf->prev_ctype = mode;
+ }
+ (*str) += get_mclen(*str);
+ obuf->flag |= RB_NFLUSHED;
+}
+
+void
+push_render_image(Str str, int width, int limit,
+ struct html_feed_environ *h_env)
+{
+ struct readbuffer *obuf = h_env->obuf;
+ int indent = h_env->envs[h_env->envc].indent;
+
+ push_spaces(obuf, 1, (limit - width) / 2);
+ push_str(obuf, width, str, PC_ASCII);
+ push_spaces(obuf, 1, (limit - width + 1) / 2);
+ if (width > 0)
+ flushline(h_env, obuf, indent, 0, h_env->limit);
+}
+
+static int
+sloppy_parse_line(char **str)
+{
+ if (**str == '<') {
+ while (**str && **str != '>')
+ (*str)++;
+ if (**str == '>')
+ (*str)++;
+ return 1;
+ }
+ else {
+ while (**str && **str != '<')
+ (*str)++;
+ return 0;
+ }
+}
+
+static void
+passthrough(struct readbuffer *obuf, char *str, int back)
+{
+ int cmd;
+ Str tok = Strnew();
+ char *str_bak;
+
+ if (back) {
+ Str str_save = Strnew_charp(str);
+ Strshrink(obuf->line, obuf->line->ptr + obuf->line->length - str);
+ str = str_save->ptr;
+ }
+ while (*str) {
+ str_bak = str;
+ if (sloppy_parse_line(&str)) {
+ char *q = str_bak;
+ cmd = gethtmlcmd(&q);
+ if (back) {
+ struct link_stack *p;
+ for (p = link_stack; p; p = p->next) {
+ if (p->cmd == cmd) {
+ link_stack = p->next;
+ break;
+ }
+ }
+ back = 0;
+ }
+ else {
+ Strcat_charp_n(tok, str_bak, str - str_bak);
+ push_tag(obuf, tok->ptr, cmd);
+ Strclear(tok);
+ }
+ }
+ else {
+ push_nchars(obuf, 0, str_bak, str - str_bak, obuf->prev_ctype);
+ }
+ }
+}
+
+#if 0
+int
+is_blank_line(char *line, int indent)
+{
+ int i, is_blank = 0;
+
+ for (i = 0; i < indent; i++) {
+ if (line[i] == '\0') {
+ is_blank = 1;
+ }
+ else if (line[i] != ' ') {
+ break;
+ }
+ }
+ if (i == indent && line[i] == '\0')
+ is_blank = 1;
+ return is_blank;
+}
+#endif
+
+void
+fillline(struct readbuffer *obuf, int indent)
+{
+ push_spaces(obuf, 1, indent - obuf->pos);
+ obuf->flag &= ~RB_NFLUSHED;
+}
+
+void
+flushline(struct html_feed_environ *h_env, struct readbuffer *obuf, int indent,
+ int force, int width)
+{
+ TextLineList *buf = h_env->buf;
+ FILE *f = h_env->f;
+ Str line = obuf->line, pass = NULL;
+ char *hidden_anchor = NULL, *hidden_img = NULL, *hidden_bold = NULL,
+ *hidden_under = NULL, *hidden = NULL;
+
+#ifdef DEBUG
+ if (w3m_debug) {
+ FILE *df = fopen("zzzproc1", "a");
+ fprintf(df, "flushline(%s,%d,%d,%d)\n", obuf->line->ptr, indent, force,
+ width);
+ if (buf) {
+ TextLineListItem *p;
+ for (p = buf->first; p; p = p->next) {
+ fprintf(df, "buf=\"%s\"\n", p->ptr->line->ptr);
+ }
+ }
+ fclose(df);
+ }
+#endif
+
+ if (!(obuf->flag & (RB_SPECIAL & ~RB_NOBR)) && Strlastchar(line) == ' ') {
+ Strshrink(line, 1);
+ obuf->pos--;
+ }
+
+ append_tags(obuf);
+
+ if (obuf->anchor.url)
+ hidden = hidden_anchor = has_hidden_link(obuf, HTML_A);
+ if (obuf->img_alt) {
+ if ((hidden_img = has_hidden_link(obuf, HTML_IMG_ALT)) != NULL) {
+ if (!hidden || hidden_img < hidden)
+ hidden = hidden_img;
+ }
+ }
+ if (obuf->in_bold) {
+ if ((hidden_bold = has_hidden_link(obuf, HTML_B)) != NULL) {
+ if (!hidden || hidden_bold < hidden)
+ hidden = hidden_bold;
+ }
+ }
+ if (obuf->in_under) {
+ if ((hidden_under = has_hidden_link(obuf, HTML_U)) != NULL) {
+ if (!hidden || hidden_under < hidden)
+ hidden = hidden_under;
+ }
+ }
+ if (hidden) {
+ pass = Strnew_charp(hidden);
+ Strshrink(line, line->ptr + line->length - hidden);
+ }
+
+ if (!(obuf->flag & (RB_SPECIAL & ~RB_NOBR)) && obuf->pos > width) {
+ char *tp = &line->ptr[obuf->bp.len - obuf->bp.tlen];
+ char *ep = &line->ptr[line->length];
+
+ if (obuf->bp.pos == obuf->pos && tp <= ep &&
+ tp > line->ptr && tp[-1] == ' ') {
+ bcopy(tp, tp - 1, ep - tp + 1);
+ line->length--;
+ obuf->pos--;
+ }
+ }
+
+ if (obuf->anchor.url && !hidden_anchor)
+ Strcat_charp(line, "</a>");
+ if (obuf->img_alt && !hidden_img)
+ Strcat_charp(line, "</img_alt>");
+ if (obuf->in_bold && !hidden_bold)
+ Strcat_charp(line, "</b>");
+ if (obuf->in_under && !hidden_under)
+ Strcat_charp(line, "</u>");
+
+ if (obuf->top_margin > 0) {
+ int i;
+ struct html_feed_environ h;
+ struct readbuffer o;
+ struct environment e[1];
+
+ init_henv(&h, &o, e, 1, NULL, width, indent);
+ o.line = Strnew_size(width + 20);
+ o.pos = obuf->pos;
+ o.flag = obuf->flag;
+ o.top_margin = -1;
+ o.bottom_margin = -1;
+ Strcat_charp(o.line, "<pre_int>");
+ for (i = 0; i < o.pos; i++)
+ Strcat_char(o.line, ' ');
+ Strcat_charp(o.line, "</pre_int>");
+ for (i = 0; i < obuf->top_margin; i++)
+ flushline(h_env, &o, indent, force, width);
+ }
+
+ if (force == 1 || obuf->flag & RB_NFLUSHED) {
+ TextLine *lbuf = newTextLine(line, obuf->pos);
+ if (RB_GET_ALIGN(obuf) == RB_CENTER) {
+ align(lbuf, width, ALIGN_CENTER);
+ }
+ else if (RB_GET_ALIGN(obuf) == RB_RIGHT) {
+ align(lbuf, width, ALIGN_RIGHT);
+ }
+ else if (RB_GET_ALIGN(obuf) == RB_LEFT && obuf->flag & RB_INTABLE) {
+ align(lbuf, width, ALIGN_LEFT);
+ }
+#ifdef FORMAT_NICE
+ else if (obuf->flag & RB_FILL) {
+ char *p;
+ int rest, rrest;
+ int nspace, d, i;
+
+ rest = width - get_Str_strwidth(line);
+ if (rest > 1) {
+ nspace = 0;
+ for (p = line->ptr + indent; *p; p++) {
+ if (*p == ' ')
+ nspace++;
+ }
+ if (nspace > 0) {
+ int indent_here = 0;
+ d = rest / nspace;
+ p = line->ptr;
+ while (IS_SPACE(*p)) {
+ p++;
+ indent_here++;
+ }
+ rrest = rest - d * nspace;
+ line = Strnew_size(width + 1);
+ for (i = 0; i < indent_here; i++)
+ Strcat_char(line, ' ');
+ for (; *p; p++) {
+ Strcat_char(line, *p);
+ if (*p == ' ') {
+ for (i = 0; i < d; i++)
+ Strcat_char(line, ' ');
+ if (rrest > 0) {
+ Strcat_char(line, ' ');
+ rrest--;
+ }
+ }
+ }
+ lbuf = newTextLine(line, width);
+ }
+ }
+ }
+#endif /* FORMAT_NICE */
+#ifdef TABLE_DEBUG
+ if (w3m_debug) {
+ FILE *f = fopen("zzzproc1", "a");
+ fprintf(f, "pos=%d,%d, maxlimit=%d\n",
+ visible_length(lbuf->line->ptr), lbuf->pos,
+ h_env->maxlimit);
+ fclose(f);
+ }
+#endif
+ if (lbuf->pos > h_env->maxlimit)
+ h_env->maxlimit = lbuf->pos;
+ if (buf)
+ pushTextLine(buf, lbuf);
+ else if (f) {
+ Strfputs(Str_conv_to_halfdump(lbuf->line), f);
+ fputc('\n', f);
+ }
+ if (obuf->flag & RB_SPECIAL || obuf->flag & RB_NFLUSHED)
+ h_env->blank_lines = 0;
+ else
+ h_env->blank_lines++;
+ }
+ else {
+ char *p = line->ptr, *q;
+ Str tmp = Strnew(), tmp2 = Strnew();
+
+#define APPEND(str) \
+ if (buf) \
+ appendTextLine(buf,(str),0); \
+ else if (f) \
+ Strfputs((str),f)
+
+ while (*p) {
+ q = p;
+ if (sloppy_parse_line(&p)) {
+ Strcat_charp_n(tmp, q, p - q);
+ if (force == 2) {
+ APPEND(tmp);
+ }
+ else
+ Strcat(tmp2, tmp);
+ Strclear(tmp);
+ }
+ }
+ if (force == 2) {
+ if (pass) {
+ APPEND(pass);
+ }
+ pass = NULL;
+ }
+ else {
+ if (pass)
+ Strcat(tmp2, pass);
+ pass = tmp2;
+ }
+ }
+
+ if (obuf->bottom_margin > 0) {
+ int i;
+ struct html_feed_environ h;
+ struct readbuffer o;
+ struct environment e[1];
+
+ init_henv(&h, &o, e, 1, NULL, width, indent);
+ o.line = Strnew_size(width + 20);
+ o.pos = obuf->pos;
+ o.flag = obuf->flag;
+ o.top_margin = -1;
+ o.bottom_margin = -1;
+ Strcat_charp(o.line, "<pre_int>");
+ for (i = 0; i < o.pos; i++)
+ Strcat_char(o.line, ' ');
+ Strcat_charp(o.line, "</pre_int>");
+ for (i = 0; i < obuf->bottom_margin; i++)
+ flushline(h_env, &o, indent, force, width);
+ }
+ if (obuf->top_margin < 0 || obuf->bottom_margin < 0)
+ return;
+
+ obuf->line = Strnew_size(256);
+ obuf->pos = 0;
+ obuf->top_margin = 0;
+ obuf->bottom_margin = 0;
+ set_space_to_prevchar(obuf->prevchar);
+ obuf->bp.init_flag = 1;
+ obuf->flag &= ~RB_NFLUSHED;
+ set_breakpoint(obuf, 0);
+ obuf->prev_ctype = PC_ASCII;
+ link_stack = NULL;
+ fillline(obuf, indent);
+ if (pass)
+ passthrough(obuf, pass->ptr, 0);
+ if (!hidden_anchor && obuf->anchor.url) {
+ Str tmp;
+ if (obuf->anchor.hseq > 0)
+ obuf->anchor.hseq = -obuf->anchor.hseq;
+ tmp = Sprintf("<A HSEQ=\"%d\" HREF=\"", obuf->anchor.hseq);
+ Strcat_charp(tmp, html_quote(obuf->anchor.url));
+ if (obuf->anchor.target) {
+ Strcat_charp(tmp, "\" TARGET=\"");
+ Strcat_charp(tmp, html_quote(obuf->anchor.target));
+ }
+ if (obuf->anchor.referer) {
+ Strcat_charp(tmp, "\" REFERER=\"");
+ Strcat_charp(tmp, html_quote(obuf->anchor.referer));
+ }
+ if (obuf->anchor.title) {
+ Strcat_charp(tmp, "\" TITLE=\"");
+ Strcat_charp(tmp, html_quote(obuf->anchor.title));
+ }
+ if (obuf->anchor.accesskey) {
+ char *c = html_quote_char(obuf->anchor.accesskey);
+ Strcat_charp(tmp, "\" ACCESSKEY=\"");
+ if (c)
+ Strcat_charp(tmp, c);
+ else
+ Strcat_char(tmp, obuf->anchor.accesskey);
+ }
+ Strcat_charp(tmp, "\">");
+ push_tag(obuf, tmp->ptr, HTML_A);
+ }
+ if (!hidden_img && obuf->img_alt) {
+ Str tmp = Strnew_charp("<IMG_ALT SRC=\"");
+ Strcat_charp(tmp, html_quote(obuf->img_alt->ptr));
+ Strcat_charp(tmp, "\">");
+ push_tag(obuf, tmp->ptr, HTML_IMG_ALT);
+ }
+ if (!hidden_bold && obuf->in_bold)
+ push_tag(obuf, "<B>", HTML_B);
+ if (!hidden_under && obuf->in_under)
+ push_tag(obuf, "<U>", HTML_U);
+}
+
+void
+do_blankline(struct html_feed_environ *h_env, struct readbuffer *obuf,
+ int indent, int indent_incr, int width)
+{
+ if (h_env->blank_lines == 0)
+ flushline(h_env, obuf, indent, 1, width);
+}
+
+void
+purgeline(struct html_feed_environ *h_env)
+{
+ char *p, *q;
+ Str tmp;
+
+ if (h_env->buf == NULL || h_env->blank_lines == 0)
+ return;
+
+ p = rpopTextLine(h_env->buf)->line->ptr;
+ tmp = Strnew();
+ while (*p) {
+ q = p;
+ if (sloppy_parse_line(&p)) {
+ Strcat_charp_n(tmp, q, p - q);
+ }
+ }
+ appendTextLine(h_env->buf, tmp, 0);
+ h_env->blank_lines--;
+}
+
+static int
+close_effect0(struct readbuffer *obuf, int cmd)
+{
+ int i;
+ char *p;
+
+ for (i = obuf->tag_sp - 1; i >= 0; i--) {
+ if (obuf->tag_stack[i]->cmd == cmd)
+ break;
+ }
+ if (i >= 0) {
+ obuf->tag_sp--;
+ bcopy(&obuf->tag_stack[i + 1], &obuf->tag_stack[i],
+ (obuf->tag_sp - i) * sizeof(struct cmdtable *));
+ return 1;
+ }
+ else if ((p = has_hidden_link(obuf, cmd)) != NULL) {
+ passthrough(obuf, p, 1);
+ return 1;
+ }
+ return 0;
+}
+
+static void
+close_anchor(struct html_feed_environ *h_env, struct readbuffer *obuf)
+{
+ if (obuf->anchor.url) {
+ int i;
+ char *p = NULL;
+ int is_erased = 0;
+
+ for (i = obuf->tag_sp - 1; i >= 0; i--) {
+ if (obuf->tag_stack[i]->cmd == HTML_A)
+ break;
+ }
+ if (i < 0 && obuf->anchor.hseq > 0 && Strlastchar(obuf->line) == ' ') {
+ Strshrink(obuf->line, 1);
+ obuf->pos--;
+ is_erased = 1;
+ }
+
+ if (i >= 0 || (p = has_hidden_link(obuf, HTML_A))) {
+ if (obuf->anchor.hseq > 0) {
+ HTMLlineproc1(ANSP, h_env);
+ set_space_to_prevchar(obuf->prevchar);
+ }
+ else {
+ if (i >= 0) {
+ obuf->tag_sp--;
+ bcopy(&obuf->tag_stack[i + 1], &obuf->tag_stack[i],
+ (obuf->tag_sp - i) * sizeof(struct cmdtable *));
+ }
+ else {
+ passthrough(obuf, p, 1);
+ }
+ bzero((void *)&obuf->anchor, sizeof(obuf->anchor));
+ return;
+ }
+ is_erased = 0;
+ }
+ if (is_erased) {
+ Strcat_char(obuf->line, ' ');
+ obuf->pos++;
+ }
+
+ push_tag(obuf, "</a>", HTML_N_A);
+ }
+ bzero((void *)&obuf->anchor, sizeof(obuf->anchor));
+}
+
+void
+save_fonteffect(struct html_feed_environ *h_env, struct readbuffer *obuf)
+{
+ if (obuf->fontstat_sp < FONT_STACK_SIZE)
+ bcopy(obuf->fontstat, obuf->fontstat_stack[obuf->fontstat_sp],
+ FONTSTAT_SIZE);
+ obuf->fontstat_sp++;
+ if (obuf->in_bold)
+ push_tag(obuf, "</b>", HTML_N_B);
+ if (obuf->in_under)
+ push_tag(obuf, "</u>", HTML_N_U);
+ bzero(obuf->fontstat, FONTSTAT_SIZE);
+}
+
+void
+restore_fonteffect(struct html_feed_environ *h_env, struct readbuffer *obuf)
+{
+ if (obuf->fontstat_sp > 0)
+ obuf->fontstat_sp--;
+ if (obuf->fontstat_sp < FONT_STACK_SIZE)
+ bcopy(obuf->fontstat_stack[obuf->fontstat_sp], obuf->fontstat,
+ FONTSTAT_SIZE);
+ if (obuf->in_bold)
+ push_tag(obuf, "<b>", HTML_B);
+ if (obuf->in_under)
+ push_tag(obuf, "<u>", HTML_U);
+}
+
+static Str
+process_title(struct parsed_tag *tag)
+{
+ cur_title = Strnew();
+ return NULL;
+}
+
+static Str
+process_n_title(struct parsed_tag *tag)
+{
+ Str tmp;
+
+ if (!cur_title)
+ return NULL;
+ Strremovefirstspaces(cur_title);
+ Strremovetrailingspaces(cur_title);
+ tmp = Strnew_m_charp("<title_alt title=\"",
+ html_quote(cur_title->ptr), "\">", NULL);
+ cur_title = NULL;
+ return tmp;
+}
+
+static void
+feed_title(char *str)
+{
+ if (!cur_title)
+ return;
+ while (*str) {
+ if (*str == '&')
+ Strcat_charp(cur_title, getescapecmd(&str));
+ else if (*str == '\n' || *str == '\r') {
+ Strcat_char(cur_title, ' ');
+ str++;
+ }
+ else
+ Strcat_char(cur_title, *(str++));
+ }
+}
+
+Str
+process_img(struct parsed_tag *tag, int width)
+{
+ char *p, *q, *r, *r2 = NULL, *s, *t;
+#ifdef USE_IMAGE
+ int w, i, nw, ni = 1, n, w0 = -1, i0 = -1;
+ int align, xoffset, yoffset, top, bottom, ismap = 0;
+ int use_image = activeImage && displayImage;
+#else
+ int w, i, nw, n;
+#endif
+ int pre_int = FALSE;
+ Str tmp = Strnew();
+
+ if (!parsedtag_get_value(tag, ATTR_SRC, &p))
+ return tmp;
+ p = remove_space(p);
+ q = NULL;
+ parsedtag_get_value(tag, ATTR_ALT, &q);
+ t = q;
+ parsedtag_get_value(tag, ATTR_TITLE, &t);
+ w = -1;
+ if (parsedtag_get_value(tag, ATTR_WIDTH, &w)) {
+ if (w < 0) {
+ if (width > 0)
+ w = (int)(-width * pixel_per_char * w / 100 + 0.5);
+ else
+ w = -1;
+ }
+#ifdef USE_IMAGE
+ if (use_image) {
+ if (w > 0) {
+ w = (int)(w * image_scale / 100 + 0.5);
+ if (w == 0)
+ w = 1;
+ else if (w > MAX_IMAGE_SIZE)
+ w = MAX_IMAGE_SIZE;
+ }
+ }
+#endif
+ }
+#ifdef USE_IMAGE
+ if (use_image) {
+ i = -1;
+ if (parsedtag_get_value(tag, ATTR_HEIGHT, &i)) {
+ if (i > 0) {
+ i = (int)(i * image_scale / 100 + 0.5);
+ if (i == 0)
+ i = 1;
+ else if (i > MAX_IMAGE_SIZE)
+ i = MAX_IMAGE_SIZE;
+ }
+ else {
+ i = -1;
+ }
+ }
+ align = -1;
+ parsedtag_get_value(tag, ATTR_ALIGN, &align);
+ ismap = 0;
+ if (parsedtag_exists(tag, ATTR_ISMAP))
+ ismap = 1;
+ }
+ else
+#endif
+ parsedtag_get_value(tag, ATTR_HEIGHT, &i);
+ r = NULL;
+ parsedtag_get_value(tag, ATTR_USEMAP, &r);
+
+ tmp = Strnew_size(128);
+#ifdef USE_IMAGE
+ if (use_image) {
+ switch (align) {
+ case ALIGN_LEFT:
+ Strcat_charp(tmp, "<div_int align=left>");
+ break;
+ case ALIGN_CENTER:
+ Strcat_charp(tmp, "<div_int align=center>");
+ break;
+ case ALIGN_RIGHT:
+ Strcat_charp(tmp, "<div_int align=right>");
+ break;
+ }
+ }
+#endif
+ if (r) {
+ Str tmp2;
+ r2 = strchr(r, '#');
+ s = "<form_int method=internal action=map>";
+ tmp2 = process_form(parse_tag(&s, TRUE));
+ if (tmp2)
+ Strcat(tmp, tmp2);
+ Strcat(tmp, Sprintf("<input_alt fid=\"%d\" "
+ "type=hidden name=link value=\"", cur_form_id));
+ Strcat_charp(tmp, html_quote((r2) ? r2 + 1 : r));
+ Strcat(tmp, Sprintf("\"><input_alt hseq=\"%d\" fid=\"%d\" "
+ "type=submit no_effect=true>",
+ cur_hseq++, cur_form_id));
+ }
+#ifdef USE_IMAGE
+ if (use_image) {
+ w0 = w;
+ i0 = i;
+ if (w < 0 || i < 0) {
+ Image image;
+ ParsedURL u;
+
+#ifdef USE_M17N
+ parseURL2(wc_conv(p, InnerCharset, cur_document_charset)->ptr, &u,
+ cur_baseURL);
+#else
+ parseURL2(p, &u, cur_baseURL);
+#endif
+ image.url = parsedURL2Str(&u)->ptr;
+ if (!uncompressed_file_type(u.file, &image.ext))
+ image.ext = filename_extension(u.file, TRUE);
+ image.cache = NULL;
+ image.width = w;
+ image.height = i;
+
+ image.cache = getImage(&image, cur_baseURL, IMG_FLAG_SKIP);
+ if (image.cache && image.cache->width > 0 &&
+ image.cache->height > 0) {
+ w = w0 = image.cache->width;
+ i = i0 = image.cache->height;
+ }
+ if (w < 0)
+ w = 8 * pixel_per_char;
+ if (i < 0)
+ i = pixel_per_line;
+ }
+ nw = (w > 3) ? (int)((w - 3) / pixel_per_char + 1) : 1;
+ ni = (i > 3) ? (int)((i - 3) / pixel_per_line + 1) : 1;
+ Strcat(tmp,
+ Sprintf("<pre_int><img_alt hseq=\"%d\" src=\"", cur_iseq++));
+ pre_int = TRUE;
+ }
+ else
+#endif
+ {
+ if (w < 0)
+ w = 12 * pixel_per_char;
+ nw = w ? (int)((w - 1) / pixel_per_char + 1) : 1;
+ if (r) {
+ Strcat_charp(tmp, "<pre_int>");
+ pre_int = TRUE;
+ }
+ Strcat_charp(tmp, "<img_alt src=\"");
+ }
+ Strcat_charp(tmp, html_quote(p));
+ Strcat_charp(tmp, "\"");
+ if (t) {
+ Strcat_charp(tmp, " title=\"");
+ Strcat_charp(tmp, html_quote(t));
+ Strcat_charp(tmp, "\"");
+ }
+#ifdef USE_IMAGE
+ if (use_image) {
+ if (w0 >= 0)
+ Strcat(tmp, Sprintf(" width=%d", w0));
+ if (i0 >= 0)
+ Strcat(tmp, Sprintf(" height=%d", i0));
+ switch (align) {
+ case ALIGN_TOP:
+ top = 0;
+ bottom = ni - 1;
+ yoffset = 0;
+ break;
+ case ALIGN_MIDDLE:
+ top = ni / 2;
+ bottom = top;
+ if (top * 2 == ni)
+ yoffset = (int)(((ni + 1) * pixel_per_line - i) / 2);
+ else
+ yoffset = (int)((ni * pixel_per_line - i) / 2);
+ break;
+ case ALIGN_BOTTOM:
+ top = ni - 1;
+ bottom = 0;
+ yoffset = (int)(ni * pixel_per_line - i);
+ break;
+ default:
+ top = ni - 1;
+ bottom = 0;
+ if (ni == 1 && ni * pixel_per_line > i)
+ yoffset = 0;
+ else {
+ yoffset = (int)(ni * pixel_per_line - i);
+ if (yoffset <= -2)
+ yoffset++;
+ }
+ break;
+ }
+ xoffset = (int)((nw * pixel_per_char - w) / 2);
+ if (xoffset)
+ Strcat(tmp, Sprintf(" xoffset=%d", xoffset));
+ if (yoffset)
+ Strcat(tmp, Sprintf(" yoffset=%d", yoffset));
+ if (top)
+ Strcat(tmp, Sprintf(" top_margin=%d", top));
+ if (bottom)
+ Strcat(tmp, Sprintf(" bottom_margin=%d", bottom));
+ if (r) {
+ Strcat_charp(tmp, " usemap=\"");
+ Strcat_charp(tmp, html_quote((r2) ? r2 + 1 : r));
+ Strcat_charp(tmp, "\"");
+ }
+ if (ismap)
+ Strcat_charp(tmp, " ismap");
+ }
+#endif
+ Strcat_charp(tmp, ">");
+ if (q != NULL && *q == '\0' && ignore_null_img_alt)
+ q = NULL;
+ if (q != NULL) {
+ n = get_strwidth(q);
+#ifdef USE_IMAGE
+ if (use_image) {
+ if (n > nw) {
+ char *r;
+ for (r = q, n = 0; r; r += get_mclen(r), n += get_mcwidth(r)) {
+ if (n + get_mcwidth(r) > nw)
+ break;
+ }
+ Strcat_charp(tmp, html_quote(Strnew_charp_n(q, r - q)->ptr));
+ }
+ else
+ Strcat_charp(tmp, html_quote(q));
+ }
+ else
+#endif
+ Strcat_charp(tmp, html_quote(q));
+ goto img_end;
+ }
+ if (w > 0 && i > 0) {
+ /* guess what the image is! */
+ if (w < 32 && i < 48) {
+ /* must be an icon or space */
+ n = 1;
+ if (strcasestr(p, "space") || strcasestr(p, "blank"))
+ Strcat_charp(tmp, "_");
+ else {
+ if (w * i < 8 * 16)
+ Strcat_charp(tmp, "*");
+ else {
+ if (!pre_int) {
+ Strcat_charp(tmp, "<pre_int>");
+ pre_int = TRUE;
+ }
+ push_symbol(tmp, IMG_SYMBOL, symbol_width, 1);
+ n = symbol_width;
+ }
+ }
+ goto img_end;
+ }
+ if (w > 200 && i < 13) {
+ /* must be a horizontal line */
+ if (!pre_int) {
+ Strcat_charp(tmp, "<pre_int>");
+ pre_int = TRUE;
+ }
+ w = w / pixel_per_char / symbol_width;
+ if (w <= 0)
+ w = 1;
+ push_symbol(tmp, HR_SYMBOL, symbol_width, w);
+ n = w * symbol_width;
+ goto img_end;
+ }
+ }
+ for (q = p; *q; q++) ;
+ while (q > p && *q != '/')
+ q--;
+ if (*q == '/')
+ q++;
+ Strcat_char(tmp, '[');
+ n = 1;
+ p = q;
+ for (; *q; q++) {
+ if (!IS_ALNUM(*q) && *q != '_' && *q != '-') {
+ break;
+ }
+ Strcat_char(tmp, *q);
+ n++;
+ if (n + 1 >= nw)
+ break;
+ }
+ Strcat_char(tmp, ']');
+ n++;
+ img_end:
+#ifdef USE_IMAGE
+ if (use_image) {
+ for (; n < nw; n++)
+ Strcat_char(tmp, ' ');
+ }
+#endif
+ Strcat_charp(tmp, "</img_alt>");
+ if (pre_int)
+ Strcat_charp(tmp, "</pre_int>");
+ if (r) {
+ Strcat_charp(tmp, "</input_alt>");
+ process_n_form();
+ }
+#ifdef USE_IMAGE
+ if (use_image) {
+ switch (align) {
+ case ALIGN_RIGHT:
+ case ALIGN_CENTER:
+ case ALIGN_LEFT:
+ Strcat_charp(tmp, "</div_int>");
+ break;
+ }
+ }
+#endif
+ return tmp;
+}
+
+Str
+process_anchor(struct parsed_tag *tag, char *tagbuf)
+{
+ if (parsedtag_need_reconstruct(tag)) {
+ parsedtag_set_value(tag, ATTR_HSEQ, Sprintf("%d", cur_hseq++)->ptr);
+ return parsedtag2str(tag);
+ }
+ else {
+ Str tmp = Sprintf("<a hseq=\"%d\"", cur_hseq++);
+ Strcat_charp(tmp, tagbuf + 2);
+ return tmp;
+ }
+}
+
+Str
+process_input(struct parsed_tag *tag)
+{
+ int i, w, v, x, y, z, iw, ih;
+ char *q, *p, *r, *p2, *s;
+ Str tmp = NULL;
+ char *qq = "";
+ int qlen = 0;
+
+ if (cur_form_id < 0) {
+ char *s = "<form_int method=internal action=none>";
+ tmp = process_form(parse_tag(&s, TRUE));
+ }
+ if (tmp == NULL)
+ tmp = Strnew();
+
+ p = "text";
+ parsedtag_get_value(tag, ATTR_TYPE, &p);
+ q = NULL;
+ parsedtag_get_value(tag, ATTR_VALUE, &q);
+ r = "";
+ parsedtag_get_value(tag, ATTR_NAME, &r);
+ w = 20;
+ parsedtag_get_value(tag, ATTR_SIZE, &w);
+ i = 20;
+ parsedtag_get_value(tag, ATTR_MAXLENGTH, &i);
+ p2 = NULL;
+ parsedtag_get_value(tag, ATTR_ALT, &p2);
+ x = parsedtag_exists(tag, ATTR_CHECKED);
+ y = parsedtag_exists(tag, ATTR_ACCEPT);
+ z = parsedtag_exists(tag, ATTR_READONLY);
+
+ v = formtype(p);
+ if (v == FORM_UNKNOWN)
+ return NULL;
+
+ if (!q) {
+ switch (v) {
+ case FORM_INPUT_IMAGE:
+ case FORM_INPUT_SUBMIT:
+ case FORM_INPUT_BUTTON:
+ q = "SUBMIT";
+ break;
+ case FORM_INPUT_RESET:
+ q = "RESET";
+ break;
+ /* if no VALUE attribute is specified in
+ * <INPUT TYPE=CHECKBOX> tag, then the value "on" is used
+ * as a default value. It is not a part of HTML4.0
+ * specification, but an imitation of Netscape behaviour.
+ */
+ case FORM_INPUT_CHECKBOX:
+ q = "on";
+ }
+ }
+ /* VALUE attribute is not allowed in <INPUT TYPE=FILE> tag. */
+ if (v == FORM_INPUT_FILE)
+ q = NULL;
+ if (q) {
+ qq = html_quote(q);
+ qlen = get_strwidth(q);
+ }
+
+ Strcat_charp(tmp, "<pre_int>");
+ switch (v) {
+ case FORM_INPUT_PASSWORD:
+ case FORM_INPUT_TEXT:
+ case FORM_INPUT_FILE:
+ case FORM_INPUT_CHECKBOX:
+ Strcat_char(tmp, '[');
+ break;
+ case FORM_INPUT_RADIO:
+ Strcat_char(tmp, '(');
+ }
+ Strcat(tmp, Sprintf("<input_alt hseq=\"%d\" fid=\"%d\" type=%s "
+ "name=\"%s\" width=%d maxlength=%d value=\"%s\"",
+ cur_hseq++, cur_form_id, p, html_quote(r), w, i, qq));
+ if (x)
+ Strcat_charp(tmp, " checked");
+ if (y)
+ Strcat_charp(tmp, " accept");
+ if (z)
+ Strcat_charp(tmp, " readonly");
+ Strcat_char(tmp, '>');
+
+ if (v == FORM_INPUT_HIDDEN)
+ Strcat_charp(tmp, "</input_alt></pre_int>");
+ else {
+ switch (v) {
+ case FORM_INPUT_PASSWORD:
+ case FORM_INPUT_TEXT:
+ case FORM_INPUT_FILE:
+ Strcat_charp(tmp, "<u>");
+ break;
+ case FORM_INPUT_IMAGE:
+ s = NULL;
+ parsedtag_get_value(tag, ATTR_SRC, &s);
+ if (s) {
+ Strcat(tmp, Sprintf("<img src=\"%s\"", html_quote(s)));
+ if (p2)
+ Strcat(tmp, Sprintf(" alt=\"%s\"", html_quote(p2)));
+ if (parsedtag_get_value(tag, ATTR_WIDTH, &iw))
+ Strcat(tmp, Sprintf(" width=\"%d\"", iw));
+ if (parsedtag_get_value(tag, ATTR_HEIGHT, &ih))
+ Strcat(tmp, Sprintf(" height=\"%d\"", ih));
+ Strcat_charp(tmp, ">");
+ Strcat_charp(tmp, "</input_alt></pre_int>");
+ return tmp;
+ }
+ case FORM_INPUT_SUBMIT:
+ case FORM_INPUT_BUTTON:
+ case FORM_INPUT_RESET:
+ Strcat_charp(tmp, "[");
+ break;
+ }
+ switch (v) {
+ case FORM_INPUT_PASSWORD:
+ i = 0;
+ if (q) {
+ for (; i < qlen && i < w; i++)
+ Strcat_char(tmp, '*');
+ }
+ for (; i < w; i++)
+ Strcat_char(tmp, ' ');
+ break;
+ case FORM_INPUT_TEXT:
+ case FORM_INPUT_FILE:
+ if (q)
+ Strcat(tmp, textfieldrep(Strnew_charp(q), w));
+ else {
+ for (i = 0; i < w; i++)
+ Strcat_char(tmp, ' ');
+ }
+ break;
+ case FORM_INPUT_SUBMIT:
+ case FORM_INPUT_BUTTON:
+ if (p2)
+ Strcat_charp(tmp, html_quote(p2));
+ else
+ Strcat_charp(tmp, qq);
+ break;
+ case FORM_INPUT_RESET:
+ Strcat_charp(tmp, qq);
+ break;
+ case FORM_INPUT_RADIO:
+ case FORM_INPUT_CHECKBOX:
+ if (x)
+ Strcat_char(tmp, '*');
+ else
+ Strcat_char(tmp, ' ');
+ break;
+ }
+ switch (v) {
+ case FORM_INPUT_PASSWORD:
+ case FORM_INPUT_TEXT:
+ case FORM_INPUT_FILE:
+ Strcat_charp(tmp, "</u>");
+ break;
+ case FORM_INPUT_IMAGE:
+ case FORM_INPUT_SUBMIT:
+ case FORM_INPUT_BUTTON:
+ case FORM_INPUT_RESET:
+ Strcat_charp(tmp, "]");
+ }
+ Strcat_charp(tmp, "</input_alt>");
+ switch (v) {
+ case FORM_INPUT_PASSWORD:
+ case FORM_INPUT_TEXT:
+ case FORM_INPUT_FILE:
+ case FORM_INPUT_CHECKBOX:
+ Strcat_char(tmp, ']');
+ break;
+ case FORM_INPUT_RADIO:
+ Strcat_char(tmp, ')');
+ }
+ Strcat_charp(tmp, "</pre_int>");
+ }
+ return tmp;
+}
+
+Str
+process_select(struct parsed_tag *tag)
+{
+ Str tmp = NULL;
+ char *p;
+
+ if (cur_form_id < 0) {
+ char *s = "<form_int method=internal action=none>";
+ tmp = process_form(parse_tag(&s, TRUE));
+ }
+
+ p = "";
+ parsedtag_get_value(tag, ATTR_NAME, &p);
+ cur_select = Strnew_charp(p);
+ select_is_multiple = parsedtag_exists(tag, ATTR_MULTIPLE);
+
+#ifdef MENU_SELECT
+ if (!select_is_multiple) {
+ select_str = Sprintf("<pre_int>[<input_alt hseq=\"%d\" "
+ "fid=\"%d\" type=select name=\"%s\" selectnumber=%d",
+ cur_hseq++, cur_form_id, html_quote(p), n_select);
+ Strcat_charp(select_str, ">");
+ if (n_select == max_select) {
+ max_select *= 2;
+ select_option =
+ New_Reuse(FormSelectOption, select_option, max_select);
+ }
+ select_option[n_select].first = NULL;
+ select_option[n_select].last = NULL;
+ cur_option_maxwidth = 0;
+ }
+ else
+#endif /* MENU_SELECT */
+ select_str = Strnew();
+ cur_option = NULL;
+ cur_status = R_ST_NORMAL;
+ n_selectitem = 0;
+ return tmp;
+}
+
+Str
+process_n_select(void)
+{
+ if (cur_select == NULL)
+ return NULL;
+ process_option();
+#ifdef MENU_SELECT
+ if (!select_is_multiple) {
+ if (select_option[n_select].first) {
+ FormItemList sitem;
+ chooseSelectOption(&sitem, select_option[n_select].first);
+ Strcat(select_str, textfieldrep(sitem.label, cur_option_maxwidth));
+ }
+ Strcat_charp(select_str, "</input_alt>]</pre_int>");
+ n_select++;
+ }
+ else
+#endif /* MENU_SELECT */
+ Strcat_charp(select_str, "<br>");
+ cur_select = NULL;
+ n_selectitem = 0;
+ return select_str;
+}
+
+void
+feed_select(char *str)
+{
+ Str tmp = Strnew();
+ int prev_status = cur_status;
+ static int prev_spaces = -1;
+ char *p;
+
+ if (cur_select == NULL)
+ return;
+ while (read_token(tmp, &str, &cur_status, 0, 0)) {
+ if (cur_status != R_ST_NORMAL || prev_status != R_ST_NORMAL)
+ continue;
+ p = tmp->ptr;
+ if (tmp->ptr[0] == '<' && Strlastchar(tmp) == '>') {
+ struct parsed_tag *tag;
+ char *q;
+ if (!(tag = parse_tag(&p, FALSE)))
+ continue;
+ switch (tag->tagid) {
+ case HTML_OPTION:
+ process_option();
+ cur_option = Strnew();
+ if (parsedtag_get_value(tag, ATTR_VALUE, &q))
+ cur_option_value = Strnew_charp(q);
+ else
+ cur_option_value = NULL;
+ if (parsedtag_get_value(tag, ATTR_LABEL, &q))
+ cur_option_label = Strnew_charp(q);
+ else
+ cur_option_label = NULL;
+ cur_option_selected = parsedtag_exists(tag, ATTR_SELECTED);
+ prev_spaces = -1;
+ break;
+ case HTML_N_OPTION:
+ /* do nothing */
+ break;
+ default:
+ /* never happen */
+ break;
+ }
+ }
+ else if (cur_option) {
+ while (*p) {
+ if (IS_SPACE(*p) && prev_spaces != 0) {
+ p++;
+ if (prev_spaces > 0)
+ prev_spaces++;
+ }
+ else {
+ if (IS_SPACE(*p))
+ prev_spaces = 1;
+ else
+ prev_spaces = 0;
+ if (*p == '&')
+ Strcat_charp(cur_option, getescapecmd(&p));
+ else
+ Strcat_char(cur_option, *(p++));
+ }
+ }
+ }
+ }
+}
+
+void
+process_option(void)
+{
+ char begin_char = '[', end_char = ']';
+ int len;
+
+ if (cur_select == NULL || cur_option == NULL)
+ return;
+ while (cur_option->length > 0 && IS_SPACE(Strlastchar(cur_option)))
+ Strshrink(cur_option, 1);
+ if (cur_option_value == NULL)
+ cur_option_value = cur_option;
+ if (cur_option_label == NULL)
+ cur_option_label = cur_option;
+#ifdef MENU_SELECT
+ if (!select_is_multiple) {
+ len = get_Str_strwidth(cur_option_label);
+ if (len > cur_option_maxwidth)
+ cur_option_maxwidth = len;
+ addSelectOption(&select_option[n_select],
+ cur_option_value,
+ cur_option_label, cur_option_selected);
+ return;
+ }
+#endif /* MENU_SELECT */
+ if (!select_is_multiple) {
+ begin_char = '(';
+ end_char = ')';
+ }
+ Strcat(select_str, Sprintf("<br><pre_int>%c<input_alt hseq=\"%d\" "
+ "fid=\"%d\" type=%s name=\"%s\" value=\"%s\"",
+ begin_char, cur_hseq++, cur_form_id,
+ select_is_multiple ? "checkbox" : "radio",
+ html_quote(cur_select->ptr),
+ html_quote(cur_option_value->ptr)));
+ if (cur_option_selected)
+ Strcat_charp(select_str, " checked>*</input_alt>");
+ else
+ Strcat_charp(select_str, "> </input_alt>");
+ Strcat_char(select_str, end_char);
+ Strcat_charp(select_str, html_quote(cur_option_label->ptr));
+ Strcat_charp(select_str, "</pre_int>");
+ n_selectitem++;
+}
+
+Str
+process_textarea(struct parsed_tag *tag, int width)
+{
+ Str tmp = NULL;
+ char *p;
+
+ if (cur_form_id < 0) {
+ char *s = "<form_int method=internal action=none>";
+ tmp = process_form(parse_tag(&s, TRUE));
+ }
+
+ p = "";
+ parsedtag_get_value(tag, ATTR_NAME, &p);
+ cur_textarea = Strnew_charp(p);
+ cur_textarea_size = 20;
+ if (parsedtag_get_value(tag, ATTR_COLS, &p)) {
+ cur_textarea_size = atoi(p);
+ if (p[strlen(p) - 1] == '%')
+ cur_textarea_size = width * cur_textarea_size / 100 - 2;
+ if (cur_textarea_size <= 0)
+ cur_textarea_size = 20;
+ }
+ cur_textarea_rows = 1;
+ if (parsedtag_get_value(tag, ATTR_ROWS, &p)) {
+ cur_textarea_rows = atoi(p);
+ if (cur_textarea_rows <= 0)
+ cur_textarea_rows = 1;
+ }
+ cur_textarea_readonly = parsedtag_exists(tag, ATTR_READONLY);
+ if (n_textarea >= max_textarea) {
+ max_textarea *= 2;
+ textarea_str = New_Reuse(Str, textarea_str, max_textarea);
+ }
+ textarea_str[n_textarea] = Strnew();
+ ignore_nl_textarea = TRUE;
+
+ return tmp;
+}
+
+Str
+process_n_textarea(void)
+{
+ Str tmp;
+ int i;
+
+ if (cur_textarea == NULL)
+ return NULL;
+
+ tmp = Strnew();
+ Strcat(tmp, Sprintf("<pre_int>[<input_alt hseq=\"%d\" fid=\"%d\" "
+ "type=textarea name=\"%s\" size=%d rows=%d "
+ "top_margin=%d textareanumber=%d",
+ cur_hseq, cur_form_id,
+ html_quote(cur_textarea->ptr),
+ cur_textarea_size, cur_textarea_rows,
+ cur_textarea_rows - 1, n_textarea));
+ if (cur_textarea_readonly)
+ Strcat_charp(tmp, " readonly");
+ Strcat_charp(tmp, "><u>");
+ for (i = 0; i < cur_textarea_size; i++)
+ Strcat_char(tmp, ' ');
+ Strcat_charp(tmp, "</u></input_alt>]</pre_int>\n");
+ cur_hseq++;
+ n_textarea++;
+ cur_textarea = NULL;
+
+ return tmp;
+}
+
+void
+feed_textarea(char *str)
+{
+ if (cur_textarea == NULL)
+ return;
+ if (ignore_nl_textarea) {
+ if (*str == '\r')
+ str++;
+ if (*str == '\n')
+ str++;
+ }
+ ignore_nl_textarea = FALSE;
+ while (*str) {
+ if (*str == '&')
+ Strcat_charp(textarea_str[n_textarea], getescapecmd(&str));
+ else if (*str == '\n') {
+ Strcat_charp(textarea_str[n_textarea], "\r\n");
+ str++;
+ }
+ else if (*str != '\r')
+ Strcat_char(textarea_str[n_textarea], *(str++));
+ }
+}
+
+Str
+process_hr(struct parsed_tag *tag, int width, int indent_width)
+{
+ Str tmp = Strnew_charp("<nobr>");
+ int w = 0;
+ int x = ALIGN_CENTER;
+
+ if (width > indent_width)
+ width -= indent_width;
+ if (parsedtag_get_value(tag, ATTR_WIDTH, &w))
+ w = REAL_WIDTH(w, width);
+ else
+ w = width;
+
+ parsedtag_get_value(tag, ATTR_ALIGN, &x);
+ switch (x) {
+ case ALIGN_CENTER:
+ Strcat_charp(tmp, "<div_int align=center>");
+ break;
+ case ALIGN_RIGHT:
+ Strcat_charp(tmp, "<div_int align=right>");
+ break;
+ case ALIGN_LEFT:
+ Strcat_charp(tmp, "<div_int align=left>");
+ break;
+ }
+ w /= symbol_width;
+ if (w <= 0)
+ w = 1;
+ push_symbol(tmp, HR_SYMBOL, symbol_width, w);
+ Strcat_charp(tmp, "</div_int></nobr>");
+ return tmp;
+}
+
+#ifdef USE_M17N
+static char *
+check_charset(char *p)
+{
+ return wc_guess_charset(p, 0) ? p : NULL;
+}
+
+static char *
+check_accept_charset(char *ac)
+{
+ char *s = ac, *e;
+
+ while (*s) {
+ while (*s && (IS_SPACE(*s) || *s == ','))
+ s++;
+ if (!*s)
+ break;
+ e = s;
+ while (*e && !(IS_SPACE(*e) || *e == ','))
+ e++;
+ if (wc_guess_charset(Strnew_charp_n(s, e - s)->ptr, 0))
+ return ac;
+ s = e;
+ }
+ return NULL;
+}
+#endif
+
+static Str
+process_form_int(struct parsed_tag *tag, int fid)
+{
+ char *p, *q, *r, *s, *tg, *n;
+
+ p = "get";
+ parsedtag_get_value(tag, ATTR_METHOD, &p);
+ q = "!CURRENT_URL!";
+ parsedtag_get_value(tag, ATTR_ACTION, &q);
+ r = NULL;
+#ifdef USE_M17N
+ if (parsedtag_get_value(tag, ATTR_ACCEPT_CHARSET, &r))
+ r = check_accept_charset(r);
+ if (!r && parsedtag_get_value(tag, ATTR_CHARSET, &r))
+ r = check_charset(r);
+#endif
+ s = NULL;
+ parsedtag_get_value(tag, ATTR_ENCTYPE, &s);
+ tg = NULL;
+ parsedtag_get_value(tag, ATTR_TARGET, &tg);
+ n = NULL;
+ parsedtag_get_value(tag, ATTR_NAME, &n);
+
+ if (fid < 0) {
+ form_max++;
+ form_sp++;
+ fid = form_max;
+ }
+ else { /* <form_int> */
+ if (form_max < fid)
+ form_max = fid;
+ form_sp = fid;
+ }
+ if (forms_size == 0) {
+ forms_size = INITIAL_FORM_SIZE;
+ forms = New_N(FormList *, forms_size);
+ form_stack = NewAtom_N(int, forms_size);
+ }
+ else if (forms_size <= form_max) {
+ forms_size += form_max;
+ forms = New_Reuse(FormList *, forms, forms_size);
+ form_stack = New_Reuse(int, form_stack, forms_size);
+ }
+ form_stack[form_sp] = fid;
+
+ if (w3m_halfdump) {
+ Str tmp = Sprintf("<form_int fid=\"%d\" action=\"%s\" method=\"%s\"",
+ fid, html_quote(q), html_quote(p));
+ if (s)
+ Strcat(tmp, Sprintf(" enctype=\"%s\"", html_quote(s)));
+ if (tg)
+ Strcat(tmp, Sprintf(" target=\"%s\"", html_quote(tg)));
+ if (n)
+ Strcat(tmp, Sprintf(" name=\"%s\"", html_quote(n)));
+#ifdef USE_M17N
+ if (r)
+ Strcat(tmp, Sprintf(" accept-charset=\"%s\"", html_quote(r)));
+#endif
+ Strcat_charp(tmp, ">");
+ return tmp;
+ }
+
+ forms[fid] = newFormList(q, p, r, s, tg, n, NULL);
+ return NULL;
+}
+
+Str
+process_form(struct parsed_tag *tag)
+{
+ return process_form_int(tag, -1);
+}
+
+Str
+process_n_form(void)
+{
+ if (form_sp >= 0)
+ form_sp--;
+ return NULL;
+}
+
+static void
+clear_ignore_p_flag(int cmd, struct readbuffer *obuf)
+{
+ static int clear_flag_cmd[] = {
+ HTML_HR, HTML_UNKNOWN
+ };
+ int i;
+
+ for (i = 0; clear_flag_cmd[i] != HTML_UNKNOWN; i++) {
+ if (cmd == clear_flag_cmd[i]) {
+ obuf->flag &= ~RB_IGNORE_P;
+ return;
+ }
+ }
+}
+
+static void
+set_alignment(struct readbuffer *obuf, struct parsed_tag *tag)
+{
+ long flag = -1;
+ int align;
+
+ if (parsedtag_get_value(tag, ATTR_ALIGN, &align)) {
+ switch (align) {
+ case ALIGN_CENTER:
+ flag = RB_CENTER;
+ break;
+ case ALIGN_RIGHT:
+ flag = RB_RIGHT;
+ break;
+ case ALIGN_LEFT:
+ flag = RB_LEFT;
+ }
+ }
+ RB_SAVE_FLAG(obuf);
+ if (flag != -1) {
+ RB_SET_ALIGN(obuf, flag);
+ }
+}
+
+#ifdef ID_EXT
+static void
+process_idattr(struct readbuffer *obuf, int cmd, struct parsed_tag *tag)
+{
+ char *id = NULL, *framename = NULL;
+ Str idtag = NULL;
+
+ /*
+ * HTML_TABLE is handled by the other process.
+ */
+ if (cmd == HTML_TABLE)
+ return;
+
+ parsedtag_get_value(tag, ATTR_ID, &id);
+ parsedtag_get_value(tag, ATTR_FRAMENAME, &framename);
+ if (id == NULL)
+ return;
+ if (framename)
+ idtag = Sprintf("<_id id=\"%s\" framename=\"%s\">",
+ html_quote(id), html_quote(framename));
+ else
+ idtag = Sprintf("<_id id=\"%s\">", html_quote(id));
+ push_tag(obuf, idtag->ptr, HTML_NOP);
+}
+#endif /* ID_EXT */
+
+#define CLOSE_P if (obuf->flag & RB_P) { \
+ flushline(h_env, obuf, envs[h_env->envc].indent,0,h_env->limit);\
+ RB_RESTORE_FLAG(obuf);\
+ obuf->flag &= ~RB_P;\
+ }
+
+#define CLOSE_A \
+ CLOSE_P; \
+ close_anchor(h_env, obuf);
+
+#define CLOSE_DT \
+ if (obuf->flag & RB_IN_DT) { \
+ obuf->flag &= ~RB_IN_DT; \
+ HTMLlineproc1("</b>", h_env); \
+ }
+
+#define PUSH_ENV(cmd) \
+ if (++h_env->envc_real < h_env->nenv) { \
+ ++h_env->envc; \
+ envs[h_env->envc].env = cmd; \
+ envs[h_env->envc].count = 0; \
+ if (h_env->envc <= MAX_INDENT_LEVEL) \
+ envs[h_env->envc].indent = envs[h_env->envc - 1].indent + INDENT_INCR; \
+ else \
+ envs[h_env->envc].indent = envs[h_env->envc - 1].indent; \
+ }
+
+#define POP_ENV \
+ if (h_env->envc_real-- < h_env->nenv) \
+ h_env->envc--;
+
+static int
+ul_type(struct parsed_tag *tag, int default_type)
+{
+ char *p;
+ if (parsedtag_get_value(tag, ATTR_TYPE, &p)) {
+ if (!strcasecmp(p, "disc"))
+ return (int)'d';
+ else if (!strcasecmp(p, "circle"))
+ return (int)'c';
+ else if (!strcasecmp(p, "square"))
+ return (int)'s';
+ }
+ return default_type;
+}
+
+int
+getMetaRefreshParam(char *q, Str *refresh_uri)
+{
+ int refresh_interval;
+ char *r;
+ Str s_tmp = NULL;
+
+ if (q == NULL || refresh_uri == NULL)
+ return 0;
+
+ refresh_interval = atoi(q);
+ if (refresh_interval < 0)
+ return 0;
+
+ while (*q) {
+ if (!strncasecmp(q, "url=", 4)) {
+ q += 4;
+ if (*q == '\"') /* " */
+ q++;
+ r = q;
+ while (*r && !IS_SPACE(*r) && *r != ';')
+ r++;
+ s_tmp = Strnew_charp_n(q, r - q);
+
+ if (s_tmp->ptr[s_tmp->length - 1] == '\"') { /* "
+ */
+ s_tmp->length--;
+ s_tmp->ptr[s_tmp->length] = '\0';
+ }
+ q = r;
+ }
+ while (*q && *q != ';')
+ q++;
+ if (*q == ';')
+ q++;
+ while (*q && *q == ' ')
+ q++;
+ }
+ *refresh_uri = s_tmp;
+ return refresh_interval;
+}
+
+int
+HTMLtagproc1(struct parsed_tag *tag, struct html_feed_environ *h_env)
+{
+ char *p, *q, *r;
+ int i, w, x, y, z, count, width;
+ struct readbuffer *obuf = h_env->obuf;
+ struct environment *envs = h_env->envs;
+ Str tmp;
+ int hseq;
+ int cmd;
+#ifdef ID_EXT
+ char *id = NULL;
+#endif /* ID_EXT */
+
+ cmd = tag->tagid;
+
+ if (obuf->flag & RB_PRE) {
+ switch (cmd) {
+ case HTML_NOBR:
+ case HTML_N_NOBR:
+ case HTML_PRE_INT:
+ case HTML_N_PRE_INT:
+ return 1;
+ }
+ }
+
+ switch (cmd) {
+ case HTML_B:
+ obuf->in_bold++;
+ if (obuf->in_bold > 1)
+ return 1;
+ return 0;
+ case HTML_N_B:
+ if (obuf->in_bold == 1 && close_effect0(obuf, HTML_B))
+ obuf->in_bold = 0;
+ if (obuf->in_bold > 0) {
+ obuf->in_bold--;
+ if (obuf->in_bold == 0)
+ return 0;
+ }
+ return 1;
+ case HTML_U:
+ obuf->in_under++;
+ if (obuf->in_under > 1)
+ return 1;
+ return 0;
+ case HTML_N_U:
+ if (obuf->in_under == 1 && close_effect0(obuf, HTML_U))
+ obuf->in_under = 0;
+ if (obuf->in_under > 0) {
+ obuf->in_under--;
+ if (obuf->in_under == 0)
+ return 0;
+ }
+ return 1;
+ case HTML_EM:
+ HTMLlineproc1("<b>", h_env);
+ return 1;
+ case HTML_N_EM:
+ HTMLlineproc1("</b>", h_env);
+ return 1;
+ case HTML_Q:
+ HTMLlineproc1("`", h_env);
+ return 1;
+ case HTML_N_Q:
+ HTMLlineproc1("'", h_env);
+ return 1;
+ case HTML_P:
+ case HTML_N_P:
+ CLOSE_A;
+ if (!(obuf->flag & RB_IGNORE_P)) {
+ flushline(h_env, obuf, envs[h_env->envc].indent, 1, h_env->limit);
+ do_blankline(h_env, obuf, envs[h_env->envc].indent, 0,
+ h_env->limit);
+ }
+ obuf->flag |= RB_IGNORE_P;
+ if (cmd == HTML_P) {
+ set_alignment(obuf, tag);
+ obuf->flag |= RB_P;
+ }
+ return 1;
+ case HTML_BR:
+ flushline(h_env, obuf, envs[h_env->envc].indent, 1, h_env->limit);
+ h_env->blank_lines = 0;
+ return 1;
+ case HTML_H:
+ if (!(obuf->flag & (RB_PREMODE | RB_IGNORE_P))) {
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ do_blankline(h_env, obuf, envs[h_env->envc].indent, 0,
+ h_env->limit);
+ }
+ HTMLlineproc1("<b>", h_env);
+ set_alignment(obuf, tag);
+ return 1;
+ case HTML_N_H:
+ HTMLlineproc1("</b>", h_env);
+ if (!(obuf->flag & RB_PREMODE)) {
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ }
+ do_blankline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ RB_RESTORE_FLAG(obuf);
+ close_anchor(h_env, obuf);
+ obuf->flag |= RB_IGNORE_P;
+ return 1;
+ case HTML_UL:
+ case HTML_OL:
+ case HTML_BLQ:
+ CLOSE_A;
+ if (!(obuf->flag & RB_IGNORE_P)) {
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ if (!(obuf->flag & RB_PREMODE) &&
+ (h_env->envc == 0 || cmd == HTML_BLQ))
+ do_blankline(h_env, obuf, envs[h_env->envc].indent, 0,
+ h_env->limit);
+ }
+ PUSH_ENV(cmd);
+ if (cmd == HTML_UL || cmd == HTML_OL) {
+ if (parsedtag_get_value(tag, ATTR_START, &count) && count > 0) {
+ envs[h_env->envc].count = count - 1;
+ }
+ }
+ if (cmd == HTML_OL) {
+ envs[h_env->envc].type = '1';
+ if (parsedtag_get_value(tag, ATTR_TYPE, &p)) {
+ envs[h_env->envc].type = (int)*p;
+ }
+ }
+ if (cmd == HTML_UL)
+ envs[h_env->envc].type = ul_type(tag, 0);
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ return 1;
+ case HTML_N_UL:
+ case HTML_N_OL:
+ case HTML_N_DL:
+ case HTML_N_BLQ:
+ CLOSE_DT;
+ CLOSE_A;
+ if (h_env->envc > 0) {
+ flushline(h_env, obuf, envs[h_env->envc - 1].indent, 0,
+ h_env->limit);
+ POP_ENV;
+ if (!(obuf->flag & RB_PREMODE) &&
+ (h_env->envc == 0 || cmd == HTML_N_DL || cmd == HTML_N_BLQ)) {
+ do_blankline(h_env, obuf,
+ envs[h_env->envc].indent,
+ INDENT_INCR, h_env->limit);
+ obuf->flag |= RB_IGNORE_P;
+ }
+ }
+ close_anchor(h_env, obuf);
+ return 1;
+ case HTML_DL:
+ CLOSE_A;
+ if (!(obuf->flag & RB_IGNORE_P)) {
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ if (!(obuf->flag & RB_PREMODE))
+ do_blankline(h_env, obuf, envs[h_env->envc].indent, 0,
+ h_env->limit);
+ }
+ PUSH_ENV(cmd);
+ if (parsedtag_exists(tag, ATTR_COMPACT))
+ envs[h_env->envc].env = HTML_DL_COMPACT;
+ obuf->flag |= RB_IGNORE_P;
+ return 1;
+ case HTML_LI:
+ CLOSE_A;
+ CLOSE_DT;
+ if (h_env->envc > 0) {
+ Str num;
+ flushline(h_env, obuf,
+ envs[h_env->envc - 1].indent, 0, h_env->limit);
+ envs[h_env->envc].count++;
+ if (parsedtag_get_value(tag, ATTR_VALUE, &p)) {
+ count = atoi(p);
+ if (count > 0)
+ envs[h_env->envc].count = count;
+ }
+ switch (envs[h_env->envc].env) {
+ case HTML_UL:
+ envs[h_env->envc].type = ul_type(tag, envs[h_env->envc].type);
+ for (i = 0; i < INDENT_INCR - 3; i++)
+ push_charp(obuf, 1, NBSP, PC_ASCII);
+ tmp = Strnew();
+ switch (envs[h_env->envc].type) {
+ case 'd':
+ push_symbol(tmp, UL_SYMBOL_DISC, symbol_width, 1);
+ break;
+ case 'c':
+ push_symbol(tmp, UL_SYMBOL_CIRCLE, symbol_width, 1);
+ break;
+ case 's':
+ push_symbol(tmp, UL_SYMBOL_SQUARE, symbol_width, 1);
+ break;
+ default:
+ push_symbol(tmp,
+ UL_SYMBOL((h_env->envc_real -
+ 1) % MAX_UL_LEVEL), symbol_width,
+ 1);
+ break;
+ }
+ if (symbol_width == 1)
+ push_charp(obuf, 1, NBSP, PC_ASCII);
+ push_str(obuf, symbol_width, tmp, PC_ASCII);
+ push_charp(obuf, 1, NBSP, PC_ASCII);
+ set_space_to_prevchar(obuf->prevchar);
+ break;
+ case HTML_OL:
+ if (parsedtag_get_value(tag, ATTR_TYPE, &p))
+ envs[h_env->envc].type = (int)*p;
+ switch (envs[h_env->envc].type) {
+ case 'i':
+ num = romanNumeral(envs[h_env->envc].count);
+ break;
+ case 'I':
+ num = romanNumeral(envs[h_env->envc].count);
+ Strupper(num);
+ break;
+ case 'a':
+ num = romanAlphabet(envs[h_env->envc].count);
+ break;
+ case 'A':
+ num = romanAlphabet(envs[h_env->envc].count);
+ Strupper(num);
+ break;
+ default:
+ num = Sprintf("%d", envs[h_env->envc].count);
+ break;
+ }
+ if (INDENT_INCR >= 4)
+ Strcat_charp(num, ". ");
+ else
+ Strcat_char(num, '.');
+ push_spaces(obuf, 1, INDENT_INCR - num->length);
+ push_str(obuf, num->length, num, PC_ASCII);
+ if (INDENT_INCR >= 4)
+ set_space_to_prevchar(obuf->prevchar);
+ break;
+ default:
+ push_spaces(obuf, 1, INDENT_INCR);
+ break;
+ }
+ }
+ else {
+ flushline(h_env, obuf, 0, 0, h_env->limit);
+ }
+ obuf->flag |= RB_IGNORE_P;
+ return 1;
+ case HTML_DT:
+ CLOSE_A;
+ if (h_env->envc == 0 ||
+ (h_env->envc_real < h_env->nenv &&
+ envs[h_env->envc].env != HTML_DL &&
+ envs[h_env->envc].env != HTML_DL_COMPACT)) {
+ PUSH_ENV(HTML_DL);
+ }
+ if (h_env->envc > 0) {
+ flushline(h_env, obuf,
+ envs[h_env->envc - 1].indent, 0, h_env->limit);
+ }
+ if (!(obuf->flag & RB_IN_DT)) {
+ HTMLlineproc1("<b>", h_env);
+ obuf->flag |= RB_IN_DT;
+ }
+ obuf->flag |= RB_IGNORE_P;
+ return 1;
+ case HTML_DD:
+ CLOSE_A;
+ CLOSE_DT;
+ if (envs[h_env->envc].env == HTML_DL_COMPACT) {
+ if (obuf->pos > envs[h_env->envc].indent)
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0,
+ h_env->limit);
+ else
+ push_spaces(obuf, 1, envs[h_env->envc].indent - obuf->pos);
+ }
+ else
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ /* obuf->flag |= RB_IGNORE_P; */
+ return 1;
+ case HTML_TITLE:
+ close_anchor(h_env, obuf);
+ process_title(tag);
+ obuf->flag |= RB_TITLE;
+ obuf->end_tag = HTML_N_TITLE;
+ return 1;
+ case HTML_N_TITLE:
+ if (!(obuf->flag & RB_TITLE))
+ return 1;
+ obuf->flag &= ~RB_TITLE;
+ obuf->end_tag = 0;
+ tmp = process_n_title(tag);
+ if (tmp)
+ HTMLlineproc1(tmp->ptr, h_env);
+ return 1;
+ case HTML_TITLE_ALT:
+ if (parsedtag_get_value(tag, ATTR_TITLE, &p))
+ h_env->title = html_unquote(p);
+ return 0;
+ case HTML_FRAMESET:
+ PUSH_ENV(cmd);
+ push_charp(obuf, 9, "--FRAME--", PC_ASCII);
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ return 0;
+ case HTML_N_FRAMESET:
+ if (h_env->envc > 0) {
+ POP_ENV;
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ }
+ return 0;
+ case HTML_NOFRAMES:
+ CLOSE_A;
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ obuf->flag |= (RB_NOFRAMES | RB_IGNORE_P);
+ /* istr = str; */
+ return 1;
+ case HTML_N_NOFRAMES:
+ CLOSE_A;
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ obuf->flag &= ~RB_NOFRAMES;
+ return 1;
+ case HTML_FRAME:
+ q = r = NULL;
+ parsedtag_get_value(tag, ATTR_SRC, &q);
+ parsedtag_get_value(tag, ATTR_NAME, &r);
+ if (q) {
+ q = html_quote(q);
+ push_tag(obuf, Sprintf("<a hseq=\"%d\" href=\"%s\">",
+ cur_hseq++, q)->ptr, HTML_A);
+ if (r)
+ q = html_quote(r);
+ push_charp(obuf, get_strwidth(q), q, PC_ASCII);
+ push_tag(obuf, "</a>", HTML_N_A);
+ }
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ return 0;
+ case HTML_HR:
+ close_anchor(h_env, obuf);
+ tmp = process_hr(tag, h_env->limit, envs[h_env->envc].indent);
+ HTMLlineproc1(tmp->ptr, h_env);
+ set_space_to_prevchar(obuf->prevchar);
+ return 1;
+ case HTML_PRE:
+ x = parsedtag_exists(tag, ATTR_FOR_TABLE);
+ CLOSE_A;
+ if (!(obuf->flag & RB_IGNORE_P)) {
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ if (!x)
+ do_blankline(h_env, obuf, envs[h_env->envc].indent, 0,
+ h_env->limit);
+ }
+ else
+ fillline(obuf, envs[h_env->envc].indent);
+ obuf->flag |= (RB_PRE | RB_IGNORE_P);
+ /* istr = str; */
+ return 1;
+ case HTML_N_PRE:
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ if (!(obuf->flag & RB_IGNORE_P)) {
+ do_blankline(h_env, obuf, envs[h_env->envc].indent, 0,
+ h_env->limit);
+ obuf->flag |= RB_IGNORE_P;
+ }
+ obuf->flag &= ~RB_PRE;
+ close_anchor(h_env, obuf);
+ return 1;
+ case HTML_PRE_INT:
+ i = obuf->line->length;
+ append_tags(obuf);
+ if (!(obuf->flag & RB_SPECIAL)) {
+ set_breakpoint(obuf, obuf->line->length - i);
+ }
+ obuf->flag |= RB_PRE_INT;
+ return 0;
+ case HTML_N_PRE_INT:
+ push_tag(obuf, "</pre_int>", HTML_N_PRE_INT);
+ obuf->flag &= ~RB_PRE_INT;
+ if (!(obuf->flag & RB_SPECIAL) && obuf->pos > obuf->bp.pos) {
+ set_prevchar(obuf->prevchar, "", 0);
+ obuf->prev_ctype = PC_CTRL;
+ }
+ return 1;
+ case HTML_NOBR:
+ obuf->flag |= RB_NOBR;
+ obuf->nobr_level++;
+ return 0;
+ case HTML_N_NOBR:
+ if (obuf->nobr_level > 0)
+ obuf->nobr_level--;
+ if (obuf->nobr_level == 0)
+ obuf->flag &= ~RB_NOBR;
+ return 0;
+ case HTML_PRE_PLAIN:
+ CLOSE_A;
+ if (!(obuf->flag & RB_IGNORE_P)) {
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ do_blankline(h_env, obuf, envs[h_env->envc].indent, 0,
+ h_env->limit);
+ }
+ obuf->flag |= (RB_PRE | RB_IGNORE_P);
+ return 1;
+ case HTML_N_PRE_PLAIN:
+ CLOSE_A;
+ if (!(obuf->flag & RB_IGNORE_P)) {
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ do_blankline(h_env, obuf, envs[h_env->envc].indent, 0,
+ h_env->limit);
+ obuf->flag |= RB_IGNORE_P;
+ }
+ obuf->flag &= ~RB_PRE;
+ return 1;
+ case HTML_LISTING:
+ case HTML_XMP:
+ case HTML_PLAINTEXT:
+ CLOSE_A;
+ if (!(obuf->flag & RB_IGNORE_P)) {
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ do_blankline(h_env, obuf, envs[h_env->envc].indent, 0,
+ h_env->limit);
+ }
+ obuf->flag |= (RB_PLAIN | RB_IGNORE_P);
+ switch (cmd) {
+ case HTML_LISTING:
+ obuf->end_tag = HTML_N_LISTING;
+ break;
+ case HTML_XMP:
+ obuf->end_tag = HTML_N_XMP;
+ break;
+ case HTML_PLAINTEXT:
+ obuf->end_tag = MAX_HTMLTAG;
+ break;
+ }
+ return 1;
+ case HTML_N_LISTING:
+ case HTML_N_XMP:
+ CLOSE_A;
+ if (!(obuf->flag & RB_IGNORE_P)) {
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ do_blankline(h_env, obuf, envs[h_env->envc].indent, 0,
+ h_env->limit);
+ obuf->flag |= RB_IGNORE_P;
+ }
+ obuf->flag &= ~RB_PLAIN;
+ obuf->end_tag = 0;
+ return 1;
+ case HTML_SCRIPT:
+ obuf->flag |= RB_SCRIPT;
+ obuf->end_tag = HTML_N_SCRIPT;
+ return 1;
+ case HTML_STYLE:
+ obuf->flag |= RB_STYLE;
+ obuf->end_tag = HTML_N_STYLE;
+ return 1;
+ case HTML_N_SCRIPT:
+ obuf->flag &= ~RB_SCRIPT;
+ obuf->end_tag = 0;
+ return 1;
+ case HTML_N_STYLE:
+ obuf->flag &= ~RB_STYLE;
+ obuf->end_tag = 0;
+ return 1;
+ case HTML_A:
+ if (obuf->anchor.url)
+ close_anchor(h_env, obuf);
+
+ hseq = 0;
+
+ if (parsedtag_get_value(tag, ATTR_HREF, &p))
+ obuf->anchor.url = Strnew_charp(p)->ptr;
+ if (parsedtag_get_value(tag, ATTR_TARGET, &p))
+ obuf->anchor.target = Strnew_charp(p)->ptr;
+ if (parsedtag_get_value(tag, ATTR_REFERER, &p))
+ obuf->anchor.referer = Strnew_charp(p)->ptr;
+ if (parsedtag_get_value(tag, ATTR_TITLE, &p))
+ obuf->anchor.title = Strnew_charp(p)->ptr;
+ if (parsedtag_get_value(tag, ATTR_ACCESSKEY, &p))
+ obuf->anchor.accesskey = (unsigned char)*p;
+ if (parsedtag_get_value(tag, ATTR_HSEQ, &hseq))
+ obuf->anchor.hseq = hseq;
+
+ if (hseq == 0 && obuf->anchor.url) {
+ obuf->anchor.hseq = cur_hseq;
+ tmp = process_anchor(tag, h_env->tagbuf->ptr);
+ push_tag(obuf, tmp->ptr, HTML_A);
+ return 1;
+ }
+ return 0;
+ case HTML_N_A:
+ close_anchor(h_env, obuf);
+ return 1;
+ case HTML_IMG:
+ tmp = process_img(tag, h_env->limit);
+ HTMLlineproc1(tmp->ptr, h_env);
+ return 1;
+ case HTML_IMG_ALT:
+ if (parsedtag_get_value(tag, ATTR_SRC, &p))
+ obuf->img_alt = Strnew_charp(p);
+#ifdef USE_IMAGE
+ i = 0;
+ if (parsedtag_get_value(tag, ATTR_TOP_MARGIN, &i)) {
+ if (i > obuf->top_margin)
+ obuf->top_margin = i;
+ }
+ i = 0;
+ if (parsedtag_get_value(tag, ATTR_BOTTOM_MARGIN, &i)) {
+ if (i > obuf->bottom_margin)
+ obuf->bottom_margin = i;
+ }
+#endif
+ return 0;
+ case HTML_N_IMG_ALT:
+ if (obuf->img_alt) {
+ if (!close_effect0(obuf, HTML_IMG_ALT))
+ push_tag(obuf, "</img_alt>", HTML_N_IMG_ALT);
+ obuf->img_alt = NULL;
+ }
+ return 1;
+ case HTML_INPUT_ALT:
+ i = 0;
+ if (parsedtag_get_value(tag, ATTR_TOP_MARGIN, &i)) {
+ if (i > obuf->top_margin)
+ obuf->top_margin = i;
+ }
+ i = 0;
+ if (parsedtag_get_value(tag, ATTR_BOTTOM_MARGIN, &i)) {
+ if (i > obuf->bottom_margin)
+ obuf->bottom_margin = i;
+ }
+ return 0;
+ case HTML_TABLE:
+ close_anchor(h_env, obuf);
+ obuf->table_level++;
+ if (obuf->table_level >= MAX_TABLE)
+ break;
+ w = BORDER_NONE;
+ /* x: cellspacing, y: cellpadding */
+ x = 2;
+ y = 1;
+ z = 0;
+ width = 0;
+ if (parsedtag_exists(tag, ATTR_BORDER)) {
+ if (parsedtag_get_value(tag, ATTR_BORDER, &w)) {
+ if (w > 2)
+ w = BORDER_THICK;
+ else if (w < 0) { /* weird */
+ w = BORDER_THIN;
+ }
+ }
+ else
+ w = BORDER_THIN;
+ }
+ if (parsedtag_get_value(tag, ATTR_WIDTH, &i)) {
+ if (obuf->table_level == 0)
+ width = REAL_WIDTH(i, h_env->limit - envs[h_env->envc].indent);
+ else
+ width = RELATIVE_WIDTH(i);
+ }
+ if (parsedtag_exists(tag, ATTR_HBORDER))
+ w = BORDER_NOWIN;
+ parsedtag_get_value(tag, ATTR_CELLSPACING, &x);
+ parsedtag_get_value(tag, ATTR_CELLPADDING, &y);
+ parsedtag_get_value(tag, ATTR_VSPACE, &z);
+#ifdef ID_EXT
+ parsedtag_get_value(tag, ATTR_ID, &id);
+#endif /* ID_EXT */
+ tables[obuf->table_level] = begin_table(w, x, y, z);
+#ifdef ID_EXT
+ if (id != NULL)
+ tables[obuf->table_level]->id = Strnew_charp(id);
+#endif /* ID_EXT */
+ table_mode[obuf->table_level].pre_mode = 0;
+ table_mode[obuf->table_level].indent_level = 0;
+ table_mode[obuf->table_level].nobr_level = 0;
+ table_mode[obuf->table_level].caption = 0;
+ table_mode[obuf->table_level].end_tag = 0; /* HTML_UNKNOWN */
+#ifndef TABLE_EXPAND
+ tables[obuf->table_level]->total_width = width;
+#else
+ tables[obuf->table_level]->real_width = width;
+ tables[obuf->table_level]->total_width = 0;
+#endif
+ return 1;
+ case HTML_N_TABLE:
+ /* should be processed in HTMLlineproc() */
+ return 1;
+ case HTML_CENTER:
+ CLOSE_A;
+ if (!(obuf->flag & (RB_PREMODE | RB_IGNORE_P)))
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ RB_SAVE_FLAG(obuf);
+ RB_SET_ALIGN(obuf, RB_CENTER);
+ return 1;
+ case HTML_N_CENTER:
+ CLOSE_A;
+ if (!(obuf->flag & RB_PREMODE))
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ RB_RESTORE_FLAG(obuf);
+ return 1;
+ case HTML_DIV:
+ CLOSE_A;
+ if (!(obuf->flag & RB_IGNORE_P))
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ set_alignment(obuf, tag);
+ return 1;
+ case HTML_N_DIV:
+ CLOSE_A;
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ RB_RESTORE_FLAG(obuf);
+ return 1;
+ case HTML_DIV_INT:
+ CLOSE_P;
+ if (!(obuf->flag & RB_IGNORE_P))
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ set_alignment(obuf, tag);
+ return 1;
+ case HTML_N_DIV_INT:
+ CLOSE_P;
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ RB_RESTORE_FLAG(obuf);
+ return 1;
+ case HTML_FORM:
+ CLOSE_A;
+ if (!(obuf->flag & RB_IGNORE_P))
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ tmp = process_form(tag);
+ if (tmp)
+ HTMLlineproc1(tmp->ptr, h_env);
+ return 1;
+ case HTML_N_FORM:
+ CLOSE_A;
+ flushline(h_env, obuf, envs[h_env->envc].indent, 0, h_env->limit);
+ obuf->flag |= RB_IGNORE_P;
+ process_n_form();
+ return 1;
+ case HTML_INPUT:
+ close_anchor(h_env, obuf);
+ tmp = process_input(tag);
+ if (tmp)
+ HTMLlineproc1(tmp->ptr, h_env);
+ return 1;
+ case HTML_SELECT:
+ close_anchor(h_env, obuf);
+ tmp = process_select(tag);
+ if (tmp)
+ HTMLlineproc1(tmp->ptr, h_env);
+ obuf->flag |= RB_INSELECT;
+ obuf->end_tag = HTML_N_SELECT;
+ return 1;
+ case HTML_N_SELECT:
+ obuf->flag &= ~RB_INSELECT;
+ obuf->end_tag = 0;
+ tmp = process_n_select();
+ if (tmp)
+ HTMLlineproc1(tmp->ptr, h_env);
+ return 1;
+ case HTML_OPTION:
+ /* nothing */
+ return 1;
+ case HTML_TEXTAREA:
+ close_anchor(h_env, obuf);
+ tmp = process_textarea(tag, h_env->limit);
+ if (tmp)
+ HTMLlineproc1(tmp->ptr, h_env);
+ obuf->flag |= RB_INTXTA;
+ obuf->end_tag = HTML_N_TEXTAREA;
+ return 1;
+ case HTML_N_TEXTAREA:
+ obuf->flag &= ~RB_INTXTA;
+ obuf->end_tag = 0;
+ tmp = process_n_textarea();
+ if (tmp)
+ HTMLlineproc1(tmp->ptr, h_env);
+ return 1;
+ case HTML_ISINDEX:
+ p = "";
+ q = "!CURRENT_URL!";
+ parsedtag_get_value(tag, ATTR_PROMPT, &p);
+ parsedtag_get_value(tag, ATTR_ACTION, &q);
+ tmp = Strnew_m_charp("<form method=get action=\"",
+ html_quote(q),
+ "\">",
+ html_quote(p),
+ "<input type=text name=\"\" accept></form>",
+ NULL);
+ HTMLlineproc1(tmp->ptr, h_env);
+ return 1;
+ case HTML_META:
+ p = q = NULL;
+ parsedtag_get_value(tag, ATTR_HTTP_EQUIV, &p);
+ parsedtag_get_value(tag, ATTR_CONTENT, &q);
+#ifdef USE_M17N
+ if (p && q && !strcasecmp(p, "Content-Type") &&
+ (q = strcasestr(q, "charset")) != NULL) {
+ q += 7;
+ SKIP_BLANKS(q);
+ if (*q == '=') {
+ q++;
+ SKIP_BLANKS(q);
+ meta_charset = wc_guess_charset(q, 0);
+ }
+ }
+ else
+#endif
+ if (p && q && !strcasecmp(p, "refresh")) {
+ int refresh_interval;
+ tmp = NULL;
+ refresh_interval = getMetaRefreshParam(q, &tmp);
+ if (tmp) {
+ q = html_quote(tmp->ptr);
+ tmp = Sprintf("Refresh (%d sec) <a href=\"%s\">%s</a>",
+ refresh_interval, q, q);
+ }
+ else if (refresh_interval > 0)
+ tmp = Sprintf("Refresh (%d sec)", refresh_interval);
+ if (tmp) {
+ HTMLlineproc1(tmp->ptr, h_env);
+ do_blankline(h_env, obuf, envs[h_env->envc].indent, 0,
+ h_env->limit);
+ if (!is_redisplay &&
+ !((obuf->flag & RB_NOFRAMES) && RenderFrame)) {
+ tag->need_reconstruct = TRUE;
+ return 0;
+ }
+ }
+ }
+ return 1;
+ case HTML_BASE:
+#ifdef USE_IMAGE
+ p = NULL;
+ if (parsedtag_get_value(tag, ATTR_HREF, &p)) {
+ if (!cur_baseURL)
+ cur_baseURL = New(ParsedURL);
+ parseURL(p, cur_baseURL, NULL);
+ }
+#endif
+ case HTML_MAP:
+ case HTML_N_MAP:
+ case HTML_AREA:
+ return 0;
+ case HTML_DEL:
+ if (displayInsDel)
+ HTMLlineproc1("<U>[DEL:</U>", h_env);
+ else
+ obuf->flag |= RB_DEL;
+ return 1;
+ case HTML_N_DEL:
+ if (displayInsDel)
+ HTMLlineproc1("<U>:DEL]</U>", h_env);
+ else
+ obuf->flag &= ~RB_DEL;
+ return 1;
+ case HTML_S:
+ if (displayInsDel)
+ HTMLlineproc1("<U>[S:</U>", h_env);
+ else
+ obuf->flag |= RB_S;
+ return 1;
+ case HTML_N_S:
+ if (displayInsDel)
+ HTMLlineproc1("<U>:S]</U>", h_env);
+ else
+ obuf->flag &= ~RB_S;
+ return 1;
+ case HTML_INS:
+ if (displayInsDel)
+ HTMLlineproc1("<U>[INS:</U>", h_env);
+ return 1;
+ case HTML_N_INS:
+ if (displayInsDel)
+ HTMLlineproc1("<U>:INS]</U>", h_env);
+ return 1;
+ case HTML_SUP:
+ if (!(obuf->flag & (RB_DEL | RB_S)))
+ HTMLlineproc1("^", h_env);
+ return 1;
+ case HTML_N_SUP:
+ return 1;
+ case HTML_SUB:
+ if (!(obuf->flag & (RB_DEL | RB_S)))
+ HTMLlineproc1("[", h_env);
+ return 1;
+ case HTML_N_SUB:
+ if (!(obuf->flag & (RB_DEL | RB_S)))
+ HTMLlineproc1("]", h_env);
+ return 1;
+ case HTML_FONT:
+ case HTML_N_FONT:
+ case HTML_NOP:
+ return 1;
+ case HTML_BGSOUND:
+ if (view_unseenobject) {
+ if (parsedtag_get_value(tag, ATTR_SRC, &p)) {
+ Str s;
+ q = html_quote(p);
+ s = Sprintf("<A HREF=\"%s\">bgsound(%s)</A>", q, q);
+ HTMLlineproc1(s->ptr, h_env);
+ }
+ }
+ return 1;
+ case HTML_EMBED:
+ if (view_unseenobject) {
+ if (parsedtag_get_value(tag, ATTR_SRC, &p)) {
+ Str s;
+ q = html_quote(p);
+ s = Sprintf("<A HREF=\"%s\">embed(%s)</A>", q, q);
+ HTMLlineproc1(s->ptr, h_env);
+ }
+ }
+ return 1;
+ case HTML_APPLET:
+ if (view_unseenobject) {
+ if (parsedtag_get_value(tag, ATTR_ARCHIVE, &p)) {
+ Str s;
+ q = html_quote(p);
+ s = Sprintf("<A HREF=\"%s\">applet archive(%s)</A>", q, q);
+ HTMLlineproc1(s->ptr, h_env);
+ }
+ }
+ return 1;
+ case HTML_BODY:
+ if (view_unseenobject) {
+ if (parsedtag_get_value(tag, ATTR_BACKGROUND, &p)) {
+ Str s;
+ q = html_quote(p);
+ s = Sprintf("<IMG SRC=\"%s\" ALT=\"bg image(%s)\"><BR>", q, q);
+ HTMLlineproc1(s->ptr, h_env);
+ }
+ }
+ case HTML_N_HEAD:
+ if (obuf->flag & RB_TITLE)
+ HTMLlineproc1("</title>", h_env);
+ case HTML_HEAD:
+ case HTML_N_BODY:
+ return 1;
+ default:
+ /* obuf->prevchar = '\0'; */
+ return 0;
+ }
+ /* not reached */
+ return 0;
+}
+
+#define PPUSH(p,c) {outp[pos]=(p);outc[pos]=(c);pos++;}
+#define PSIZE \
+ if (out_size <= pos + 1) { \
+ out_size = pos * 3 / 2; \
+ outc = New_Reuse(char, outc, out_size); \
+ outp = New_Reuse(Lineprop, outp, out_size); \
+ }
+
+static TextLineListItem *_tl_lp2;
+
+static Str
+textlist_feed()
+{
+ TextLine *p;
+ if (_tl_lp2 != NULL) {
+ p = _tl_lp2->ptr;
+ _tl_lp2 = _tl_lp2->next;
+ return p->line;
+ }
+ return NULL;
+}
+
+static void
+HTMLlineproc2body(Buffer *buf, Str (*feed) (), int llimit)
+{
+ static char *outc = NULL;
+ static Lineprop *outp = NULL;
+ static int out_size = 0;
+ Anchor *a_href = NULL, *a_img = NULL, *a_form = NULL;
+ char *p, *q, *r, *s, *t, *str;
+ Lineprop mode, effect;
+ int pos;
+ int nlines;
+#ifdef DEBUG
+ FILE *debug = NULL;
+#endif
+ struct frameset *frameset_s[FRAMESTACK_SIZE];
+ int frameset_sp = -1;
+ union frameset_element *idFrame = NULL;
+ char *id = NULL;
+ int hseq, form_id;
+ Str line;
+ char *endp;
+ char symbol = '\0';
+ int internal = 0;
+ Anchor **a_textarea = NULL;
+#ifdef MENU_SELECT
+ Anchor **a_select = NULL;
+#endif
+
+ if (out_size == 0) {
+ out_size = LINELEN;
+ outc = NewAtom_N(char, out_size);
+ outp = NewAtom_N(Lineprop, out_size);
+ }
+
+ n_textarea = -1;
+ if (!max_textarea) { /* halfload */
+ max_textarea = MAX_TEXTAREA;
+ textarea_str = New_N(Str, max_textarea);
+ a_textarea = New_N(Anchor *, max_textarea);
+ }
+#ifdef MENU_SELECT
+ n_select = -1;
+ if (!max_select) { /* halfload */
+ max_select = MAX_SELECT;
+ select_option = New_N(FormSelectOption, max_select);
+ a_select = New_N(Anchor *, max_select);
+ }
+#endif
+
+#ifdef DEBUG
+ if (w3m_debug)
+ debug = fopen("zzzerr", "a");
+#endif
+
+ effect = 0;
+ nlines = 0;
+ while ((line = feed()) != NULL) {
+#ifdef DEBUG
+ if (w3m_debug) {
+ Strfputs(line, debug);
+ fputc('\n', debug);
+ }
+#endif
+ if (n_textarea >= 0 && *(line->ptr) != '<') { /* halfload */
+ Strcat(textarea_str[n_textarea], line);
+ continue;
+ }
+ proc_again:
+ if (++nlines == llimit)
+ break;
+ pos = 0;
+#ifdef ENABLE_REMOVE_TRAILINGSPACES
+ Strremovetrailingspaces(line);
+#endif
+ str = line->ptr;
+ endp = str + line->length;
+ while (str < endp) {
+ PSIZE;
+ mode = get_mctype(str);
+ if (effect & PC_SYMBOL && *str != '<') {
+#ifdef USE_M17N
+ char **buf = set_symbol(symbol_width0);
+ int len;
+
+ p = buf[(int)symbol];
+ len = get_mclen(p);
+ mode = get_mctype(p);
+ PPUSH(mode | effect, *(p++));
+ if (--len) {
+ mode = (mode & ~PC_WCHAR1) | PC_WCHAR2;
+ while (len--) {
+ PSIZE;
+ PPUSH(mode | effect, *(p++));
+ }
+ }
+#else
+ PPUSH(PC_ASCII | effect, SYMBOL_BASE + symbol);
+#endif
+ str += symbol_width;
+ }
+#ifdef USE_M17N
+ else if (mode == PC_CTRL || mode == PC_UNDEF) {
+#else
+ else if (mode == PC_CTRL || IS_INTSPACE(*str)) {
+#endif
+ PPUSH(PC_ASCII | effect, ' ');
+ str++;
+ }
+#ifdef USE_M17N
+ else if (mode & PC_UNKNOWN) {
+ PPUSH(PC_ASCII | effect, ' ');
+ str += get_mclen(str);
+ }
+#endif
+ else if (*str != '<' && *str != '&') {
+#ifdef USE_M17N
+ int len = get_mclen(str);
+#endif
+ PPUSH(mode | effect, *(str++));
+#ifdef USE_M17N
+ if (--len) {
+ mode = (mode & ~PC_WCHAR1) | PC_WCHAR2;
+ while (len--) {
+ PSIZE;
+ PPUSH(mode | effect, *(str++));
+ }
+ }
+#endif
+ }
+ else if (*str == '&') {
+ /*
+ * & escape processing
+ */
+ p = getescapecmd(&str);
+ while (*p) {
+ PSIZE;
+ mode = get_mctype((unsigned char *)p);
+#ifdef USE_M17N
+ if (mode == PC_CTRL || mode == PC_UNDEF) {
+#else
+ if (mode == PC_CTRL || IS_INTSPACE(*str)) {
+#endif
+ PPUSH(PC_ASCII | effect, ' ');
+ p++;
+ }
+#ifdef USE_M17N
+ else if (mode & PC_UNKNOWN) {
+ PPUSH(PC_ASCII | effect, ' ');
+ p += get_mclen(p);
+ }
+#endif
+ else {
+#ifdef USE_M17N
+ int len = get_mclen(p);
+#endif
+ PPUSH(mode | effect, *(p++));
+#ifdef USE_M17N
+ if (--len) {
+ mode = (mode & ~PC_WCHAR1) | PC_WCHAR2;
+ while (len--) {
+ PSIZE;
+ PPUSH(mode | effect, *(p++));
+ }
+ }
+#endif
+ }
+ }
+ }
+ else {
+ /* tag processing */
+ struct parsed_tag *tag;
+ if (!(tag = parse_tag(&str, TRUE)))
+ continue;
+ switch (tag->tagid) {
+ case HTML_B:
+ effect |= PE_BOLD;
+ break;
+ case HTML_N_B:
+ effect &= ~PE_BOLD;
+ break;
+ case HTML_U:
+ effect |= PE_UNDER;
+ break;
+ case HTML_N_U:
+ effect &= ~PE_UNDER;
+ break;
+ case HTML_A:
+ if (renderFrameSet &&
+ parsedtag_get_value(tag, ATTR_FRAMENAME, &p)) {
+ p = url_quote_conv(p, buf->document_charset);
+ if (!idFrame || strcmp(idFrame->body->name, p)) {
+ idFrame = search_frame(renderFrameSet, p);
+ if (idFrame && idFrame->body->attr != F_BODY)
+ idFrame = NULL;
+ }
+ }
+ p = r = s = NULL;
+ q = buf->baseTarget;
+ t = "";
+ hseq = 0;
+ id = NULL;
+ if (parsedtag_get_value(tag, ATTR_NAME, &id)) {
+ id = url_quote_conv(id, buf->document_charset);
+ registerName(buf, id, currentLn(buf), pos);
+ }
+ if (parsedtag_get_value(tag, ATTR_HREF, &p))
+ p = url_quote_conv(remove_space(p),
+ buf->document_charset);
+ if (parsedtag_get_value(tag, ATTR_TARGET, &q))
+ q = url_quote_conv(q, buf->document_charset);
+ if (parsedtag_get_value(tag, ATTR_REFERER, &r))
+ r = url_quote_conv(r, buf->document_charset);
+ parsedtag_get_value(tag, ATTR_TITLE, &s);
+ parsedtag_get_value(tag, ATTR_ACCESSKEY, &t);
+ parsedtag_get_value(tag, ATTR_HSEQ, &hseq);
+ if (hseq > 0)
+ buf->hmarklist =
+ putHmarker(buf->hmarklist, currentLn(buf),
+ pos, hseq - 1);
+ if (id && idFrame)
+ idFrame->body->nameList =
+ putAnchor(idFrame->body->nameList, id, NULL,
+ (Anchor **)NULL, NULL, NULL, '\0',
+ currentLn(buf), pos);
+ if (p) {
+ effect |= PE_ANCHOR;
+ a_href = registerHref(buf, p, q, r, s,
+ *t, currentLn(buf), pos);
+ a_href->hseq = ((hseq > 0) ? hseq : -hseq) - 1;
+ a_href->slave = (hseq > 0) ? FALSE : TRUE;
+ }
+ break;
+ case HTML_N_A:
+ effect &= ~PE_ANCHOR;
+ if (a_href) {
+ a_href->end.line = currentLn(buf);
+ a_href->end.pos = pos;
+ if (a_href->start.line == a_href->end.line &&
+ a_href->start.pos == a_href->end.pos)
+ a_href->hseq = -1;
+ a_href = NULL;
+ }
+ break;
+
+ case HTML_LINK:
+ addLink(buf, tag);
+ break;
+
+ case HTML_IMG_ALT:
+ if (parsedtag_get_value(tag, ATTR_SRC, &p)) {
+#ifdef USE_IMAGE
+ int w = -1, h = -1, iseq = 0, ismap = 0;
+ int xoffset = 0, yoffset = 0, top = 0, bottom = 0;
+ parsedtag_get_value(tag, ATTR_HSEQ, &iseq);
+ parsedtag_get_value(tag, ATTR_WIDTH, &w);
+ parsedtag_get_value(tag, ATTR_HEIGHT, &h);
+ parsedtag_get_value(tag, ATTR_XOFFSET, &xoffset);
+ parsedtag_get_value(tag, ATTR_YOFFSET, &yoffset);
+ parsedtag_get_value(tag, ATTR_TOP_MARGIN, &top);
+ parsedtag_get_value(tag, ATTR_BOTTOM_MARGIN, &bottom);
+ if (parsedtag_exists(tag, ATTR_ISMAP))
+ ismap = 1;
+ q = NULL;
+ parsedtag_get_value(tag, ATTR_USEMAP, &q);
+ if (iseq > 0) {
+ buf->imarklist = putHmarker(buf->imarklist,
+ currentLn(buf), pos,
+ iseq - 1);
+ }
+#endif
+ s = NULL;
+ parsedtag_get_value(tag, ATTR_TITLE, &s);
+ p = url_quote_conv(remove_space(p),
+ buf->document_charset);
+ a_img = registerImg(buf, p, s, currentLn(buf), pos);
+#ifdef USE_IMAGE
+ a_img->hseq = iseq;
+ a_img->image = NULL;
+ if (iseq > 0) {
+ ParsedURL u;
+ Image *image;
+
+ parseURL2(a_img->url, &u, cur_baseURL);
+ a_img->image = image = New(Image);
+ image->url = parsedURL2Str(&u)->ptr;
+ if (!uncompressed_file_type(u.file, &image->ext))
+ image->ext = filename_extension(u.file, TRUE);
+ image->cache = NULL;
+ image->width =
+ (w > MAX_IMAGE_SIZE) ? MAX_IMAGE_SIZE : w;
+ image->height =
+ (h > MAX_IMAGE_SIZE) ? MAX_IMAGE_SIZE : h;
+ image->xoffset = xoffset;
+ image->yoffset = yoffset;
+ image->y = currentLn(buf) - top;
+ if (image->xoffset < 0 && pos == 0)
+ image->xoffset = 0;
+ if (image->yoffset < 0 && image->y == 1)
+ image->yoffset = 0;
+ image->rows = 1 + top + bottom;
+ image->map = q;
+ image->ismap = ismap;
+ image->touch = 0;
+ image->cache = getImage(image, cur_baseURL,
+ IMG_FLAG_SKIP);
+ }
+ else if (iseq < 0) {
+ BufferPoint *po = buf->imarklist->marks - iseq - 1;
+ Anchor *a = retrieveAnchor(buf->img,
+ po->line, po->pos);
+ if (a) {
+ a_img->url = a->url;
+ a_img->image = a->image;
+ }
+ }
+#endif
+ }
+ effect |= PE_IMAGE;
+ break;
+ case HTML_N_IMG_ALT:
+ effect &= ~PE_IMAGE;
+ if (a_img) {
+ a_img->end.line = currentLn(buf);
+ a_img->end.pos = pos;
+ }
+ a_img = NULL;
+ break;
+ case HTML_INPUT_ALT:
+ {
+ FormList *form;
+ int top = 0, bottom = 0;
+ int textareanumber = -1;
+#ifdef MENU_SELECT
+ int selectnumber = -1;
+#endif
+ hseq = 0;
+ form_id = -1;
+
+ parsedtag_get_value(tag, ATTR_HSEQ, &hseq);
+ parsedtag_get_value(tag, ATTR_FID, &form_id);
+ parsedtag_get_value(tag, ATTR_TOP_MARGIN, &top);
+ parsedtag_get_value(tag, ATTR_BOTTOM_MARGIN, &bottom);
+ if (form_id < 0 || form_id > form_max || forms == NULL)
+ break; /* outside of <form>..</form> */
+ form = forms[form_id];
+ if (hseq > 0) {
+ int hpos = pos;
+ if (*str == '[')
+ hpos++;
+ buf->hmarklist =
+ putHmarker(buf->hmarklist, currentLn(buf),
+ hpos, hseq - 1);
+ }
+ if (!form->target)
+ form->target = buf->baseTarget;
+ if (a_textarea &&
+ parsedtag_get_value(tag, ATTR_TEXTAREANUMBER,
+ &textareanumber)) {
+ if (textareanumber >= max_textarea) {
+ max_textarea = 2 * textareanumber;
+ textarea_str = New_Reuse(Str, textarea_str,
+ max_textarea);
+ a_textarea = New_Reuse(Anchor *, a_textarea,
+ max_textarea);
+ }
+ }
+#ifdef MENU_SELECT
+ if (a_select &&
+ parsedtag_get_value(tag, ATTR_SELECTNUMBER,
+ &selectnumber)) {
+ if (selectnumber >= max_select) {
+ max_select = 2 * selectnumber;
+ select_option = New_Reuse(FormSelectOption,
+ select_option,
+ max_select);
+ a_select = New_Reuse(Anchor *, a_select,
+ max_select);
+ }
+ }
+#endif
+ a_form =
+ registerForm(buf, form, tag, currentLn(buf), pos);
+ if (a_textarea && textareanumber >= 0)
+ a_textarea[textareanumber] = a_form;
+#ifdef MENU_SELECT
+ if (a_select && selectnumber >= 0)
+ a_select[selectnumber] = a_form;
+#endif
+ if (a_form) {
+ a_form->hseq = hseq - 1;
+ a_form->y = currentLn(buf) - top;
+ a_form->rows = 1 + top + bottom;
+ if (!parsedtag_exists(tag, ATTR_NO_EFFECT))
+ effect |= PE_FORM;
+ break;
+ }
+ }
+ case HTML_N_INPUT_ALT:
+ effect &= ~PE_FORM;
+ if (a_form) {
+ a_form->end.line = currentLn(buf);
+ a_form->end.pos = pos;
+ if (a_form->start.line == a_form->end.line &&
+ a_form->start.pos == a_form->end.pos)
+ a_form->hseq = -1;
+ }
+ a_form = NULL;
+ break;
+ case HTML_MAP:
+ if (parsedtag_get_value(tag, ATTR_NAME, &p)) {
+ MapList *m = New(MapList);
+ m->name = Strnew_charp(p);
+ m->area = newGeneralList();
+ m->next = buf->maplist;
+ buf->maplist = m;
+ }
+ break;
+ case HTML_N_MAP:
+ /* nothing to do */
+ break;
+ case HTML_AREA:
+ if (buf->maplist == NULL) /* outside of <map>..</map> */
+ break;
+ if (parsedtag_get_value(tag, ATTR_HREF, &p)) {
+ MapArea *a;
+ p = url_quote_conv(remove_space(p),
+ buf->document_charset);
+ t = NULL;
+ parsedtag_get_value(tag, ATTR_TARGET, &t);
+ q = "";
+ parsedtag_get_value(tag, ATTR_ALT, &q);
+ r = NULL;
+ s = NULL;
+#ifdef USE_IMAGE
+ parsedtag_get_value(tag, ATTR_SHAPE, &r);
+ parsedtag_get_value(tag, ATTR_COORDS, &s);
+#endif
+ a = newMapArea(p, t, q, r, s);
+ pushValue(buf->maplist->area, (void *)a);
+ }
+ break;
+ case HTML_FRAMESET:
+ frameset_sp++;
+ if (frameset_sp >= FRAMESTACK_SIZE)
+ break;
+ frameset_s[frameset_sp] = newFrameSet(tag);
+ if (frameset_s[frameset_sp] == NULL)
+ break;
+ if (frameset_sp == 0) {
+ if (buf->frameset == NULL) {
+ buf->frameset = frameset_s[frameset_sp];
+ }
+ else
+ pushFrameTree(&(buf->frameQ),
+ frameset_s[frameset_sp], NULL);
+ }
+ else
+ addFrameSetElement(frameset_s[frameset_sp - 1],
+ *(union frameset_element *)
+ &frameset_s[frameset_sp]);
+ break;
+ case HTML_N_FRAMESET:
+ if (frameset_sp >= 0)
+ frameset_sp--;
+ break;
+ case HTML_FRAME:
+ if (frameset_sp >= 0 && frameset_sp < FRAMESTACK_SIZE) {
+ union frameset_element element;
+
+ element.body = newFrame(tag, buf);
+ addFrameSetElement(frameset_s[frameset_sp], element);
+ }
+ break;
+ case HTML_BASE:
+ if (parsedtag_get_value(tag, ATTR_HREF, &p)) {
+ p = url_quote_conv(remove_space(p),
+ buf->document_charset);
+ if (!buf->baseURL)
+ buf->baseURL = New(ParsedURL);
+ parseURL(p, buf->baseURL, NULL);
+ }
+ if (parsedtag_get_value(tag, ATTR_TARGET, &p))
+ buf->baseTarget =
+ url_quote_conv(p, buf->document_charset);
+ break;
+ case HTML_META:
+ p = q = NULL;
+ parsedtag_get_value(tag, ATTR_HTTP_EQUIV, &p);
+ parsedtag_get_value(tag, ATTR_CONTENT, &q);
+ if (p && q && !strcasecmp(p, "refresh") && MetaRefresh) {
+ Str tmp = NULL;
+ int refresh_interval = getMetaRefreshParam(q, &tmp);
+#ifdef USE_ALARM
+ if (tmp) {
+ p = url_quote_conv(remove_space(tmp->ptr),
+ buf->document_charset);
+ buf->event = setAlarmEvent(buf->event,
+ refresh_interval,
+ AL_IMPLICIT_ONCE,
+ FUNCNAME_gorURL, p);
+ }
+ else if (refresh_interval > 0)
+ buf->event = setAlarmEvent(buf->event,
+ refresh_interval,
+ AL_IMPLICIT,
+ FUNCNAME_reload, NULL);
+#else
+ if (tmp && refresh_interval == 0) {
+ p = url_quote_conv(remove_space(tmp->ptr),
+ buf->document_charset);
+ pushEvent(FUNCNAME_gorURL, p);
+ }
+#endif
+ }
+ break;
+ case HTML_INTERNAL:
+ internal = HTML_INTERNAL;
+ break;
+ case HTML_N_INTERNAL:
+ internal = HTML_N_INTERNAL;
+ break;
+ case HTML_FORM_INT:
+ if (parsedtag_get_value(tag, ATTR_FID, &form_id))
+ process_form_int(tag, form_id);
+ break;
+ case HTML_TEXTAREA_INT:
+ if (parsedtag_get_value(tag, ATTR_TEXTAREANUMBER,
+ &n_textarea)
+ && n_textarea < max_textarea) {
+ textarea_str[n_textarea] = Strnew();
+ }
+ else
+ n_textarea = -1;
+ break;
+ case HTML_N_TEXTAREA_INT:
+ if (n_textarea >= 0) {
+ FormItemList *item =
+ (FormItemList *)a_textarea[n_textarea]->url;
+ item->init_value = item->value =
+ textarea_str[n_textarea];
+ }
+ break;
+#ifdef MENU_SELECT
+ case HTML_SELECT_INT:
+ if (parsedtag_get_value(tag, ATTR_SELECTNUMBER, &n_select)
+ && n_select < max_select) {
+ select_option[n_select].first = NULL;
+ select_option[n_select].last = NULL;
+ }
+ else
+ n_select = -1;
+ break;
+ case HTML_N_SELECT_INT:
+ if (n_select >= 0) {
+ FormItemList *item =
+ (FormItemList *)a_select[n_select]->url;
+ item->select_option = select_option[n_select].first;
+ chooseSelectOption(item, item->select_option);
+ item->init_selected = item->selected;
+ item->init_value = item->value;
+ item->init_label = item->label;
+ }
+ break;
+ case HTML_OPTION_INT:
+ if (n_select >= 0) {
+ int selected;
+ q = "";
+ parsedtag_get_value(tag, ATTR_LABEL, &q);
+ p = q;
+ parsedtag_get_value(tag, ATTR_VALUE, &p);
+ selected = parsedtag_exists(tag, ATTR_SELECTED);
+ addSelectOption(&select_option[n_select],
+ Strnew_charp(p), Strnew_charp(q),
+ selected);
+ }
+ break;
+#endif
+ case HTML_TITLE_ALT:
+ if (parsedtag_get_value(tag, ATTR_TITLE, &p))
+ buf->buffername = html_unquote(p);
+ break;
+ case HTML_SYMBOL:
+ effect |= PC_SYMBOL;
+ if (parsedtag_get_value(tag, ATTR_TYPE, &p))
+ symbol = (char)atoi(p);
+ break;
+ case HTML_N_SYMBOL:
+ effect &= ~PC_SYMBOL;
+ break;
+ }
+#ifdef ID_EXT
+ id = NULL;
+ if (parsedtag_get_value(tag, ATTR_ID, &id)) {
+ id = url_quote_conv(id, buf->document_charset);
+ registerName(buf, id, currentLn(buf), pos);
+ }
+ if (renderFrameSet &&
+ parsedtag_get_value(tag, ATTR_FRAMENAME, &p)) {
+ p = url_quote_conv(p, buf->document_charset);
+ if (!idFrame || strcmp(idFrame->body->name, p)) {
+ idFrame = search_frame(renderFrameSet, p);
+ if (idFrame && idFrame->body->attr != F_BODY)
+ idFrame = NULL;
+ }
+ }
+ if (id && idFrame)
+ idFrame->body->nameList =
+ putAnchor(idFrame->body->nameList, id, NULL,
+ (Anchor **)NULL, NULL, NULL, '\0',
+ currentLn(buf), pos);
+#endif /* ID_EXT */
+ }
+ }
+ /* end of processing for one line */
+ if (!internal)
+ addnewline(buf, outc, outp, NULL, pos, -1, nlines);
+ if (internal == HTML_N_INTERNAL)
+ internal = 0;
+ if (str != endp) {
+ line = Strsubstr(line, str - line->ptr, endp - str);
+ goto proc_again;
+ }
+ }
+#ifdef DEBUG
+ if (w3m_debug)
+ fclose(debug);
+#endif
+ for (form_id = 1; form_id <= form_max; form_id++)
+ forms[form_id]->next = forms[form_id - 1];
+ buf->formlist = (form_max >= 0) ? forms[form_max] : NULL;
+ if (n_textarea)
+ addMultirowsForm(buf, buf->formitem);
+#ifdef USE_IMAGE
+ addMultirowsImg(buf, buf->img);
+#endif
+}
+
+static void
+addLink(Buffer *buf, struct parsed_tag *tag)
+{
+ char *href = NULL, *title = NULL, *ctype = NULL, *rel = NULL, *rev = NULL;
+ char type = LINK_TYPE_NONE;
+ LinkList *l;
+
+ parsedtag_get_value(tag, ATTR_HREF, &href);
+ if (href)
+ href = url_quote_conv(remove_space(href), buf->document_charset);
+ parsedtag_get_value(tag, ATTR_TITLE, &title);
+ parsedtag_get_value(tag, ATTR_TYPE, &ctype);
+ parsedtag_get_value(tag, ATTR_REL, &rel);
+ if (rel != NULL) {
+ /* forward link type */
+ type = LINK_TYPE_REL;
+ if (title == NULL)
+ title = rel;
+ }
+ parsedtag_get_value(tag, ATTR_REV, &rev);
+ if (rev != NULL) {
+ /* reverse link type */
+ type = LINK_TYPE_REV;
+ if (title == NULL)
+ title = rev;
+ }
+
+ l = New(LinkList);
+ l->url = href;
+ l->title = title;
+ l->ctype = ctype;
+ l->type = type;
+ l->next = NULL;
+ if (buf->linklist) {
+ LinkList *i;
+ for (i = buf->linklist; i->next; i = i->next) ;
+ i->next = l;
+ }
+ else
+ buf->linklist = l;
+}
+
+void
+HTMLlineproc2(Buffer *buf, TextLineList *tl)
+{
+ _tl_lp2 = tl->first;
+ HTMLlineproc2body(buf, textlist_feed, -1);
+}
+
+static InputStream _file_lp2;
+
+static Str
+file_feed()
+{
+ Str s;
+ s = StrISgets(_file_lp2);
+ if (s->length == 0) {
+ ISclose(_file_lp2);
+ return NULL;
+ }
+ return s;
+}
+
+void
+HTMLlineproc3(Buffer *buf, InputStream stream)
+{
+ _file_lp2 = stream;
+ HTMLlineproc2body(buf, file_feed, -1);
+}
+
+static void
+proc_escape(struct readbuffer *obuf, char **str_return)
+{
+ char *str = *str_return, *estr;
+ int ech = getescapechar(str_return);
+ int width, n_add = *str_return - str;
+ Lineprop mode = PC_ASCII;
+
+ if (ech < 0) {
+ *str_return = str;
+ proc_mchar(obuf, obuf->flag & RB_SPECIAL, 1, str_return, PC_ASCII);
+ return;
+ }
+ mode = IS_CNTRL(ech) ? PC_CTRL : PC_ASCII;
+
+ estr = conv_entity(ech);
+ check_breakpoint(obuf, obuf->flag & RB_SPECIAL, estr);
+ width = get_strwidth(estr);
+ if (width == 1 && ech == (unsigned char)*estr &&
+ ech != '&' && ech != '<' && ech != '>') {
+ if (IS_CNTRL(ech))
+ mode = PC_CTRL;
+ push_charp(obuf, width, estr, mode);
+ }
+ else
+ push_nchars(obuf, width, str, n_add, mode);
+ set_prevchar(obuf->prevchar, estr, strlen(estr));
+ obuf->prev_ctype = mode;
+}
+
+
+static int
+need_flushline(struct html_feed_environ *h_env, struct readbuffer *obuf,
+ Lineprop mode)
+{
+ char ch;
+
+ if (obuf->flag & RB_PRE_INT) {
+ if (obuf->pos > h_env->limit)
+ return 1;
+ else
+ return 0;
+ }
+
+ ch = Strlastchar(obuf->line);
+ /* if (ch == ' ' && obuf->tag_sp > 0) */
+ if (ch == ' ')
+ return 0;
+
+ if (obuf->pos > h_env->limit)
+ return 1;
+
+ return 0;
+}
+
+static int
+table_width(struct html_feed_environ *h_env, int table_level)
+{
+ int width;
+ if (table_level < 0)
+ return 0;
+ width = tables[table_level]->total_width;
+ if (table_level > 0 || width > 0)
+ return width;
+ return h_env->limit - h_env->envs[h_env->envc].indent;
+}
+
+/* HTML processing first pass */
+void
+HTMLlineproc0(char *line, struct html_feed_environ *h_env, int internal)
+{
+ Lineprop mode;
+ int cmd;
+ struct readbuffer *obuf = h_env->obuf;
+ int indent, delta;
+ struct parsed_tag *tag;
+ Str tokbuf;
+ struct table *tbl = NULL;
+ struct table_mode *tbl_mode = NULL;
+ int tbl_width = 0;
+#ifdef USE_M17N
+ int is_hangul, prev_is_hangul = 0;
+#endif
+
+#ifdef DEBUG
+ if (w3m_debug) {
+ FILE *f = fopen("zzzproc1", "a");
+ fprintf(f, "%c%c%c%c",
+ (obuf->flag & RB_PREMODE) ? 'P' : ' ',
+ (obuf->table_level >= 0) ? 'T' : ' ',
+ (obuf->flag & RB_INTXTA) ? 'X' : ' ',
+ (obuf->flag & (RB_SCRIPT | RB_STYLE)) ? 'S' : ' ');
+ fprintf(f, "HTMLlineproc1(\"%s\",%d,%lx)\n", line, h_env->limit,
+ (unsigned long)h_env);
+ fclose(f);
+ }
+#endif
+
+ tokbuf = Strnew();
+
+ table_start:
+ if (obuf->table_level >= 0) {
+ int level = min(obuf->table_level, MAX_TABLE - 1);
+ tbl = tables[level];
+ tbl_mode = &table_mode[level];
+ tbl_width = table_width(h_env, level);
+ }
+
+ while (*line != '\0') {
+ char *str, *p;
+ int is_tag = FALSE;
+ int pre_mode = (obuf->table_level >= 0) ? tbl_mode->pre_mode :
+ obuf->flag;
+ int end_tag = (obuf->table_level >= 0) ? tbl_mode->end_tag :
+ obuf->end_tag;
+
+ if (*line == '<' || obuf->status != R_ST_NORMAL) {
+ /*
+ * Tag processing
+ */
+ if (obuf->status == R_ST_EOL)
+ obuf->status = R_ST_NORMAL;
+ else {
+ read_token(h_env->tagbuf, &line, &obuf->status,
+ pre_mode & RB_PREMODE, obuf->status != R_ST_NORMAL);
+ if (obuf->status != R_ST_NORMAL)
+ return;
+ }
+ if (h_env->tagbuf->length == 0)
+ continue;
+ str = h_env->tagbuf->ptr;
+ if (*str == '<') {
+ if (str[1] && REALLY_THE_BEGINNING_OF_A_TAG(str))
+ is_tag = TRUE;
+ else if (!(pre_mode & (RB_PLAIN | RB_INTXTA | RB_INSELECT |
+ RB_SCRIPT | RB_STYLE | RB_TITLE))) {
+ line = Strnew_m_charp(str + 1, line, NULL)->ptr;
+ str = "&lt;";
+ }
+ }
+ }
+ else {
+ read_token(tokbuf, &line, &obuf->status, pre_mode & RB_PREMODE, 0);
+ if (obuf->status != R_ST_NORMAL) /* R_ST_AMP ? */
+ obuf->status = R_ST_NORMAL;
+ str = tokbuf->ptr;
+ }
+
+ if (pre_mode & (RB_PLAIN | RB_INTXTA | RB_INSELECT | RB_SCRIPT |
+ RB_STYLE | RB_TITLE)) {
+ if (is_tag) {
+ p = str;
+ if ((tag = parse_tag(&p, internal))) {
+ if (tag->tagid == end_tag ||
+ (pre_mode & RB_INSELECT && tag->tagid == HTML_N_FORM)
+ || (pre_mode & RB_TITLE
+ && (tag->tagid == HTML_N_HEAD
+ || tag->tagid == HTML_BODY)))
+ goto proc_normal;
+ }
+ }
+ /* title */
+ if (pre_mode & RB_TITLE) {
+ feed_title(str);
+ continue;
+ }
+ /* select */
+ if (pre_mode & RB_INSELECT) {
+ if (obuf->table_level >= 0)
+ goto proc_normal;
+ feed_select(str);
+ continue;
+ }
+ if (is_tag) {
+ if (strncmp(str, "<!--", 4) && (p = strchr(str + 1, '<'))) {
+ str = Strnew_charp_n(str, p - str)->ptr;
+ line = Strnew_m_charp(p, line, NULL)->ptr;
+ }
+ is_tag = FALSE;
+ }
+ if (obuf->table_level >= 0)
+ goto proc_normal;
+ /* textarea */
+ if (pre_mode & RB_INTXTA) {
+ feed_textarea(str);
+ continue;
+ }
+ /* script */
+ if (pre_mode & RB_SCRIPT)
+ continue;
+ /* style */
+ if (pre_mode & RB_STYLE)
+ continue;
+ }
+
+ proc_normal:
+ if (obuf->table_level >= 0) {
+ /*
+ * within table: in <table>..</table>, all input tokens
+ * are fed to the table renderer, and then the renderer
+ * makes HTML output.
+ */
+ switch (feed_table(tbl, str, tbl_mode, tbl_width, internal)) {
+ case 0:
+ /* </table> tag */
+ obuf->table_level--;
+ if (obuf->table_level >= MAX_TABLE - 1)
+ continue;
+ end_table(tbl);
+ if (obuf->table_level >= 0) {
+ struct table *tbl0 = tables[obuf->table_level];
+ str = Sprintf("<table_alt tid=%d>", tbl0->ntable)->ptr;
+ pushTable(tbl0, tbl);
+ tbl = tbl0;
+ tbl_mode = &table_mode[obuf->table_level];
+ tbl_width = table_width(h_env, obuf->table_level);
+ feed_table(tbl, str, tbl_mode, tbl_width, TRUE);
+ continue;
+ /* continue to the next */
+ }
+ if (obuf->flag & RB_DEL)
+ continue;
+ /* all tables have been read */
+ if (tbl->vspace > 0 && !(obuf->flag & RB_IGNORE_P)) {
+ int indent = h_env->envs[h_env->envc].indent;
+ flushline(h_env, obuf, indent, 0, h_env->limit);
+ do_blankline(h_env, obuf, indent, 0, h_env->limit);
+ }
+ save_fonteffect(h_env, obuf);
+ renderTable(tbl, tbl_width, h_env);
+ restore_fonteffect(h_env, obuf);
+ obuf->flag &= ~RB_IGNORE_P;
+ if (tbl->vspace > 0) {
+ int indent = h_env->envs[h_env->envc].indent;
+ do_blankline(h_env, obuf, indent, 0, h_env->limit);
+ obuf->flag |= RB_IGNORE_P;
+ }
+ set_space_to_prevchar(obuf->prevchar);
+ continue;
+ case 1:
+ /* <table> tag */
+ break;
+ default:
+ continue;
+ }
+ }
+
+ if (is_tag) {
+/*** Beginning of a new tag ***/
+ if ((tag = parse_tag(&str, internal)))
+ cmd = tag->tagid;
+ else
+ continue;
+ /* process tags */
+ if (HTMLtagproc1(tag, h_env) == 0) {
+ /* preserve the tag for second-stage processing */
+ if (parsedtag_need_reconstruct(tag))
+ h_env->tagbuf = parsedtag2str(tag);
+ push_tag(obuf, h_env->tagbuf->ptr, cmd);
+ }
+#ifdef ID_EXT
+ else {
+ process_idattr(obuf, cmd, tag);
+ }
+#endif /* ID_EXT */
+ obuf->bp.init_flag = 1;
+ clear_ignore_p_flag(cmd, obuf);
+ if (cmd == HTML_TABLE)
+ goto table_start;
+ else
+ continue;
+ }
+
+ if (obuf->flag & (RB_DEL | RB_S))
+ continue;
+ while (*str) {
+ mode = get_mctype(str);
+ delta = get_mcwidth(str);
+ if (obuf->flag & (RB_SPECIAL & ~RB_NOBR)) {
+ char ch = *str;
+ if (!(obuf->flag & RB_PLAIN) && (*str == '&')) {
+ char *p = str;
+ int ech = getescapechar(&p);
+ if (ech == '\n' || ech == '\r') {
+ ch = '\n';
+ str = p - 1;
+ }
+ else if (ech == '\t') {
+ ch = '\t';
+ str = p - 1;
+ }
+ }
+ if (ch != '\n')
+ obuf->flag &= ~RB_IGNORE_P;
+ if (ch == '\n') {
+ str++;
+ if (obuf->flag & RB_IGNORE_P) {
+ obuf->flag &= ~RB_IGNORE_P;
+ continue;
+ }
+ if (obuf->flag & RB_PRE_INT)
+ PUSH(' ');
+ else
+ flushline(h_env, obuf, h_env->envs[h_env->envc].indent,
+ 1, h_env->limit);
+ }
+ else if (ch == '\t') {
+ do {
+ PUSH(' ');
+ } while ((h_env->envs[h_env->envc].indent + obuf->pos)
+ % Tabstop != 0);
+ str++;
+ }
+ else if (obuf->flag & RB_PLAIN) {
+ char *p = html_quote_char(*str);
+ if (p) {
+ push_charp(obuf, 1, p, PC_ASCII);
+ str++;
+ }
+ else {
+ proc_mchar(obuf, 1, delta, &str, mode);
+ }
+ }
+ else {
+ if (*str == '&')
+ proc_escape(obuf, &str);
+ else
+ proc_mchar(obuf, 1, delta, &str, mode);
+ }
+ if (obuf->flag & (RB_SPECIAL & ~RB_PRE_INT))
+ continue;
+ }
+ else {
+ if (!IS_SPACE(*str))
+ obuf->flag &= ~RB_IGNORE_P;
+ if ((mode == PC_ASCII || mode == PC_CTRL) && IS_SPACE(*str)) {
+ if (*obuf->prevchar->ptr != ' ') {
+ PUSH(' ');
+ }
+ str++;
+ }
+ else {
+#ifdef USE_M17N
+ if (mode == PC_KANJI1)
+ is_hangul = wtf_is_hangul((wc_uchar *) str);
+ else
+ is_hangul = 0;
+ if (mode == PC_KANJI1 &&
+ !is_hangul && !prev_is_hangul &&
+ obuf->pos > h_env->envs[h_env->envc].indent &&
+ Strlastchar(obuf->line) == ' ') {
+ while (obuf->line->length >= 2 &&
+ !strncmp(obuf->line->ptr + obuf->line->length -
+ 2, " ", 2)
+ && obuf->pos >= h_env->envs[h_env->envc].indent) {
+ Strshrink(obuf->line, 1);
+ obuf->pos--;
+ }
+ if (obuf->line->length >= 3 &&
+ obuf->prev_ctype == PC_KANJI1 &&
+ Strlastchar(obuf->line) == ' ' &&
+ obuf->pos >= h_env->envs[h_env->envc].indent) {
+ Strshrink(obuf->line, 1);
+ obuf->pos--;
+ }
+ }
+ prev_is_hangul = is_hangul;
+#endif
+ if (*str == '&')
+ proc_escape(obuf, &str);
+ else
+ proc_mchar(obuf, obuf->flag & RB_SPECIAL, delta, &str,
+ mode);
+ }
+ }
+ if (need_flushline(h_env, obuf, mode)) {
+ char *bp = obuf->line->ptr + obuf->bp.len;
+ char *tp = bp - obuf->bp.tlen;
+ int i = 0;
+
+ if (tp > obuf->line->ptr && tp[-1] == ' ')
+ i = 1;
+
+ indent = h_env->envs[h_env->envc].indent;
+ if (obuf->bp.pos - i > indent) {
+ Str line;
+ append_tags(obuf);
+ line = Strnew_charp(bp);
+ Strshrink(obuf->line, obuf->line->length - obuf->bp.len);
+#ifdef FORMAT_NICE
+ if (obuf->pos - i > h_env->limit)
+ obuf->flag |= RB_FILL;
+#endif /* FORMAT_NICE */
+ back_to_breakpoint(obuf);
+ flushline(h_env, obuf, indent, 0, h_env->limit);
+#ifdef FORMAT_NICE
+ obuf->flag &= ~RB_FILL;
+#endif /* FORMAT_NICE */
+ HTMLlineproc1(line->ptr, h_env);
+ }
+ }
+ }
+ }
+ if (!(obuf->flag & (RB_SPECIAL | RB_INTXTA | RB_INSELECT))) {
+ char *tp;
+ int i = 0;
+
+ if (obuf->bp.pos == obuf->pos) {
+ tp = &obuf->line->ptr[obuf->bp.len - obuf->bp.tlen];
+ }
+ else {
+ tp = &obuf->line->ptr[obuf->line->length];
+ }
+
+ if (tp > obuf->line->ptr && tp[-1] == ' ')
+ i = 1;
+ indent = h_env->envs[h_env->envc].indent;
+ if (obuf->pos - i > h_env->limit) {
+#ifdef FORMAT_NICE
+ obuf->flag |= RB_FILL;
+#endif /* FORMAT_NICE */
+ flushline(h_env, obuf, indent, 0, h_env->limit);
+#ifdef FORMAT_NICE
+ obuf->flag &= ~RB_FILL;
+#endif /* FORMAT_NICE */
+ }
+ }
+}
+
+extern char *NullLine;
+extern Lineprop NullProp[];
+
+#ifndef USE_ANSI_COLOR
+#define addnewline2(a,b,c,d,e,f) _addnewline2(a,b,c,e,f)
+#endif
+static void
+addnewline2(Buffer *buf, char *line, Lineprop *prop, Linecolor *color, int pos,
+ int nlines)
+{
+ Line *l;
+ l = New(Line);
+ l->next = NULL;
+ l->lineBuf = line;
+ l->propBuf = prop;
+#ifdef USE_ANSI_COLOR
+ l->colorBuf = color;
+#endif
+ l->len = pos;
+ l->width = -1;
+ l->size = pos;
+ l->bpos = 0;
+ l->bwidth = 0;
+ l->prev = buf->currentLine;
+ if (buf->currentLine) {
+ l->next = buf->currentLine->next;
+ buf->currentLine->next = l;
+ }
+ else
+ l->next = NULL;
+ if (buf->lastLine == NULL || buf->lastLine == buf->currentLine)
+ buf->lastLine = l;
+ buf->currentLine = l;
+ if (buf->firstLine == NULL)
+ buf->firstLine = l;
+ l->linenumber = ++buf->allLine;
+ if (nlines < 0) {
+ /* l->real_linenumber = l->linenumber; */
+ l->real_linenumber = 0;
+ }
+ else {
+ l->real_linenumber = nlines;
+ }
+ l = NULL;
+}
+
+static void
+addnewline(Buffer *buf, char *line, Lineprop *prop, Linecolor *color, int pos,
+ int width, int nlines)
+{
+ char *s;
+ Lineprop *p;
+#ifdef USE_ANSI_COLOR
+ Linecolor *c;
+#endif
+ Line *l;
+ int i, bpos, bwidth;
+
+ if (pos > 0) {
+ s = allocStr(line, pos);
+ p = NewAtom_N(Lineprop, pos);
+ bcopy((void *)prop, (void *)p, pos * sizeof(Lineprop));
+ }
+ else {
+ s = NullLine;
+ p = NullProp;
+ }
+#ifdef USE_ANSI_COLOR
+ if (pos > 0 && color) {
+ c = NewAtom_N(Linecolor, pos);
+ bcopy((void *)color, (void *)c, pos * sizeof(Linecolor));
+ }
+ else {
+ c = NULL;
+ }
+#endif
+ addnewline2(buf, s, p, c, pos, nlines);
+ if (pos <= 0 || width <= 0)
+ return;
+ bpos = 0;
+ bwidth = 0;
+ while (1) {
+ l = buf->currentLine;
+ l->bpos = bpos;
+ l->bwidth = bwidth;
+ i = columnLen(l, width);
+ if (i == 0) {
+ i++;
+#ifdef USE_M17N
+ while (i < l->len && p[i] & PC_WCHAR2)
+ i++;
+#endif
+ }
+ l->len = i;
+ l->width = COLPOS(l, l->len);
+ if (pos <= i)
+ return;
+ bpos += l->len;
+ bwidth += l->width;
+ s += i;
+ p += i;
+#ifdef USE_ANSI_COLOR
+ if (c)
+ c += i;
+#endif
+ pos -= i;
+ addnewline2(buf, s, p, c, pos, nlines);
+ }
+}
+
+/*
+ * loadHTMLBuffer: read file and make new buffer
+ */
+Buffer *
+loadHTMLBuffer(URLFile *f, Buffer *newBuf)
+{
+ FILE *src = NULL;
+ Str tmp;
+
+ if (newBuf == NULL)
+ newBuf = newBuffer(INIT_BUFFER_WIDTH);
+ if (newBuf->sourcefile == NULL &&
+ (f->scheme != SCM_LOCAL || newBuf->mailcap)) {
+ tmp = tmpfname(TMPF_SRC, ".html");
+ src = fopen(tmp->ptr, "w");
+ if (src)
+ newBuf->sourcefile = tmp->ptr;
+ }
+
+ loadHTMLstream(f, newBuf, src, newBuf->bufferprop & BP_FRAME);
+
+ newBuf->topLine = newBuf->firstLine;
+ newBuf->lastLine = newBuf->currentLine;
+ newBuf->currentLine = newBuf->firstLine;
+ if (n_textarea)
+ formResetBuffer(newBuf, newBuf->formitem);
+ if (src)
+ fclose(src);
+
+ return newBuf;
+}
+
+static char *_size_unit[] = { "b", "kb", "Mb", "Gb", "Tb",
+ "Pb", "Eb", "Zb", "Bb", "Yb", NULL
+};
+
+char *
+convert_size(clen_t size, int usefloat)
+{
+ float csize;
+ int sizepos = 0;
+ char **sizes = _size_unit;
+
+ csize = (float)size;
+ while (csize >= 999.495 && sizes[sizepos + 1]) {
+ csize = csize / 1024.0;
+ sizepos++;
+ }
+ return Sprintf(usefloat ? "%.3g%s" : "%.0f%s",
+ floor(csize * 100.0 + 0.5) / 100.0, sizes[sizepos])->ptr;
+}
+
+char *
+convert_size2(clen_t size1, clen_t size2, int usefloat)
+{
+ char **sizes = _size_unit;
+ float csize, factor = 1;
+ int sizepos = 0;
+
+ csize = (float)((size1 > size2) ? size1 : size2);
+ while (csize / factor >= 999.495 && sizes[sizepos + 1]) {
+ factor *= 1024.0;
+ sizepos++;
+ }
+ return Sprintf(usefloat ? "%.3g/%.3g%s" : "%.0f/%.0f%s",
+ floor(size1 / factor * 100.0 + 0.5) / 100.0,
+ floor(size2 / factor * 100.0 + 0.5) / 100.0,
+ sizes[sizepos])->ptr;
+}
+
+void
+showProgress(clen_t * linelen, clen_t * trbyte)
+{
+ int i, j, rate, duration, eta, pos;
+ static time_t last_time, start_time;
+ time_t cur_time;
+ Str messages;
+ char *fmtrbyte, *fmrate;
+
+ if (!fmInitialized)
+ return;
+
+ if (*linelen < 1024)
+ return;
+ if (current_content_length > 0) {
+ double ratio;
+ cur_time = time(0);
+ if (*trbyte == 0) {
+ move(LASTLINE, 0);
+ clrtoeolx();
+ start_time = cur_time;
+ }
+ *trbyte += *linelen;
+ *linelen = 0;
+ if (cur_time == last_time)
+ return;
+ last_time = cur_time;
+ move(LASTLINE, 0);
+ ratio = 100.0 * (*trbyte) / current_content_length;
+ fmtrbyte = convert_size2(*trbyte, current_content_length, 1);
+ duration = cur_time - start_time;
+ if (duration) {
+ rate = *trbyte / duration;
+ fmrate = convert_size(rate, 1);
+ eta = rate ? (current_content_length - *trbyte) / rate : -1;
+ messages = Sprintf("%11s %3.0f%% "
+ "%7s/s "
+ "eta %02d:%02d:%02d ",
+ fmtrbyte, ratio,
+ fmrate,
+ eta / (60 * 60), (eta / 60) % 60, eta % 60);
+ }
+ else {
+ messages = Sprintf("%11s %3.0f%% ",
+ fmtrbyte, ratio);
+ }
+ addstr(messages->ptr);
+ pos = 42;
+ i = pos + (COLS - pos - 1) * (*trbyte) / current_content_length;
+ move(LASTLINE, pos);
+ standout();
+ addch(' ');
+ for (j = pos + 1; j <= i; j++)
+ addch('|');
+ standend();
+ /* no_clrtoeol(); */
+ refresh();
+ }
+ else {
+ cur_time = time(0);
+ if (*trbyte == 0) {
+ move(LASTLINE, 0);
+ clrtoeolx();
+ start_time = cur_time;
+ }
+ *trbyte += *linelen;
+ *linelen = 0;
+ if (cur_time == last_time)
+ return;
+ last_time = cur_time;
+ move(LASTLINE, 0);
+ fmtrbyte = convert_size(*trbyte, 1);
+ duration = cur_time - start_time;
+ if (duration) {
+ fmrate = convert_size(*trbyte / duration, 1);
+ messages = Sprintf("%7s loaded %7s/s", fmtrbyte, fmrate);
+ }
+ else {
+ messages = Sprintf("%7s loaded", fmtrbyte);
+ }
+ message(messages->ptr, 0, 0);
+ refresh();
+ }
+}
+
+void
+init_henv(struct html_feed_environ *h_env, struct readbuffer *obuf,
+ struct environment *envs, int nenv, TextLineList *buf,
+ int limit, int indent)
+{
+ envs[0].indent = indent;
+
+ obuf->line = Strnew();
+ obuf->cprop = 0;
+ obuf->pos = 0;
+ obuf->prevchar = Strnew_size(8);
+ set_space_to_prevchar(obuf->prevchar);
+ obuf->flag = RB_IGNORE_P;
+ obuf->flag_sp = 0;
+ obuf->status = R_ST_NORMAL;
+ obuf->table_level = -1;
+ obuf->nobr_level = 0;
+ bzero((void *)&obuf->anchor, sizeof(obuf->anchor));
+ obuf->img_alt = 0;
+ obuf->in_bold = 0;
+ obuf->in_under = 0;
+ obuf->prev_ctype = PC_ASCII;
+ obuf->tag_sp = 0;
+ obuf->fontstat_sp = 0;
+ obuf->top_margin = 0;
+ obuf->bottom_margin = 0;
+ obuf->bp.init_flag = 1;
+ set_breakpoint(obuf, 0);
+
+ h_env->buf = buf;
+ h_env->f = NULL;
+ h_env->obuf = obuf;
+ h_env->tagbuf = Strnew();
+ h_env->limit = limit;
+ h_env->maxlimit = 0;
+ h_env->envs = envs;
+ h_env->nenv = nenv;
+ h_env->envc = 0;
+ h_env->envc_real = 0;
+ h_env->title = NULL;
+ h_env->blank_lines = 0;
+}
+
+void
+completeHTMLstream(struct html_feed_environ *h_env, struct readbuffer *obuf)
+{
+ close_anchor(h_env, obuf);
+ if (obuf->img_alt) {
+ push_tag(obuf, "</img_alt>", HTML_N_IMG_ALT);
+ obuf->img_alt = NULL;
+ }
+ if (obuf->in_bold) {
+ push_tag(obuf, "</b>", HTML_N_B);
+ obuf->in_bold = 0;
+ }
+ if (obuf->in_under) {
+ push_tag(obuf, "</u>", HTML_N_U);
+ obuf->in_under = 0;
+ }
+ if (obuf->flag & RB_INTXTA)
+ HTMLlineproc1("</textarea>", h_env);
+ /* for unbalanced select tag */
+ if (obuf->flag & RB_INSELECT)
+ HTMLlineproc1("</select>", h_env);
+ if (obuf->flag & RB_TITLE)
+ HTMLlineproc1("</title>", h_env);
+
+ /* for unbalanced table tag */
+ if (obuf->table_level >= MAX_TABLE)
+ obuf->table_level = MAX_TABLE - 1;
+
+ while (obuf->table_level >= 0) {
+ table_mode[obuf->table_level].pre_mode
+ &= ~(TBLM_SCRIPT | TBLM_STYLE | TBLM_PLAIN);
+ HTMLlineproc1("</table>", h_env);
+ }
+}
+
+static void
+print_internal_information(struct html_feed_environ *henv)
+{
+ int i;
+ Str s;
+ TextLineList *tl = newTextLineList();
+
+ s = Strnew_charp("<internal>");
+ pushTextLine(tl, newTextLine(s, 0));
+ if (henv->title) {
+ s = Strnew_m_charp("<title_alt title=\"",
+ html_quote(henv->title), "\">", NULL);
+ pushTextLine(tl, newTextLine(s, 0));
+ }
+#if 0
+ if (form_max >= 0) {
+ FormList *fp;
+ for (i = 0; i <= form_max; i++) {
+ fp = forms[i];
+ s = Sprintf("<form_int fid=\"%d\" action=\"%s\" method=\"%s\"",
+ i, html_quote(fp->action->ptr),
+ (fp->method == FORM_METHOD_POST) ? "post"
+ : ((fp->method ==
+ FORM_METHOD_INTERNAL) ? "internal" : "get"));
+ if (fp->target)
+ Strcat(s, Sprintf(" target=\"%s\"", html_quote(fp->target)));
+ if (fp->enctype == FORM_ENCTYPE_MULTIPART)
+ Strcat_charp(s, " enctype=\"multipart/form-data\"");
+#ifdef USE_M17N
+ if (fp->charset)
+ Strcat(s, Sprintf(" accept-charset=\"%s\"",
+ html_quote(fp->charset)));
+#endif
+ Strcat_charp(s, ">");
+ pushTextLine(tl, newTextLine(s, 0));
+ }
+ }
+#endif
+#ifdef MENU_SELECT
+ if (n_select > 0) {
+ FormSelectOptionItem *ip;
+ for (i = 0; i < n_select; i++) {
+ s = Sprintf("<select_int selectnumber=%d>", i);
+ pushTextLine(tl, newTextLine(s, 0));
+ for (ip = select_option[i].first; ip; ip = ip->next) {
+ s = Sprintf("<option_int value=\"%s\" label=\"%s\"%s>",
+ html_quote(ip->value ? ip->value->ptr :
+ ip->label->ptr),
+ html_quote(ip->label->ptr),
+ ip->checked ? " selected" : "");
+ pushTextLine(tl, newTextLine(s, 0));
+ }
+ s = Strnew_charp("</select_int>");
+ pushTextLine(tl, newTextLine(s, 0));
+ }
+ }
+#endif /* MENU_SELECT */
+ if (n_textarea > 0) {
+ for (i = 0; i < n_textarea; i++) {
+ s = Sprintf("<textarea_int textareanumber=%d>", i);
+ pushTextLine(tl, newTextLine(s, 0));
+ s = Strnew_charp(html_quote(textarea_str[i]->ptr));
+ Strcat_charp(s, "</textarea_int>");
+ pushTextLine(tl, newTextLine(s, 0));
+ }
+ }
+ s = Strnew_charp("</internal>");
+ pushTextLine(tl, newTextLine(s, 0));
+
+ if (henv->buf)
+ appendTextLineList(henv->buf, tl);
+ else if (henv->f) {
+ TextLineListItem *p;
+ for (p = tl->first; p; p = p->next)
+ fprintf(henv->f, "%s\n", Str_conv_to_halfdump(p->ptr->line)->ptr);
+ }
+}
+
+void
+loadHTMLstream(URLFile *f, Buffer *newBuf, FILE * src, int internal)
+{
+ struct environment envs[MAX_ENV_LEVEL];
+ clen_t linelen = 0;
+ clen_t trbyte = 0;
+ Str lineBuf2 = Strnew();
+#ifdef USE_M17N
+ wc_ces charset = WC_CES_US_ASCII;
+ wc_ces volatile doc_charset = DocumentCharset;
+#endif
+ struct html_feed_environ htmlenv1;
+ struct readbuffer obuf;
+#ifdef USE_IMAGE
+ int volatile image_flag;
+#endif
+ MySignalHandler(*volatile prevtrap) (SIGNAL_ARG) = NULL;
+
+#ifdef USE_M17N
+ if (fmInitialized && graph_ok()) {
+ symbol_width = symbol_width0 = 1;
+ }
+ else {
+ symbol_width0 = 0;
+ get_symbol(DisplayCharset, &symbol_width0);
+ symbol_width = WcOption.use_wide ? symbol_width0 : 1;
+ }
+#else
+ symbol_width = symbol_width0 = 1;
+#endif
+
+ cur_title = NULL;
+ n_textarea = 0;
+ cur_textarea = NULL;
+ max_textarea = MAX_TEXTAREA;
+ textarea_str = New_N(Str, max_textarea);
+#ifdef MENU_SELECT
+ n_select = 0;
+ max_select = MAX_SELECT;
+ select_option = New_N(FormSelectOption, max_select);
+#endif /* MENU_SELECT */
+ cur_select = NULL;
+ form_sp = -1;
+ form_max = -1;
+ forms_size = 0;
+ forms = NULL;
+ cur_hseq = 1;
+#ifdef USE_IMAGE
+ cur_iseq = 1;
+ if (newBuf->image_flag)
+ image_flag = newBuf->image_flag;
+ else if (activeImage && displayImage && autoImage)
+ image_flag = IMG_FLAG_AUTO;
+ else
+ image_flag = IMG_FLAG_SKIP;
+ if (newBuf->currentURL.file)
+ cur_baseURL = baseURL(newBuf);
+#endif
+
+ if (w3m_halfload) {
+ newBuf->buffername = "---";
+#ifdef USE_M17N
+ newBuf->document_charset = InnerCharset;
+#endif
+ max_textarea = 0;
+#ifdef MENU_SELECT
+ max_select = 0;
+#endif
+ HTMLlineproc3(newBuf, f->stream);
+ w3m_halfload = FALSE;
+ return;
+ }
+
+ init_henv(&htmlenv1, &obuf, envs, MAX_ENV_LEVEL, NULL, newBuf->width, 0);
+
+ if (w3m_halfdump)
+ htmlenv1.f = stdout;
+ else
+ htmlenv1.buf = newTextLineList();
+
+ if (SETJMP(AbortLoading) != 0) {
+ HTMLlineproc1("<br>Transfer Interrupted!<br>", &htmlenv1);
+ goto phase2;
+ }
+ TRAP_ON;
+
+#ifdef USE_M17N
+ if (newBuf != NULL) {
+ if (newBuf->bufferprop & BP_FRAME)
+ charset = InnerCharset;
+ else if (newBuf->document_charset)
+ charset = doc_charset = newBuf->document_charset;
+ }
+ if (content_charset && UseContentCharset)
+ doc_charset = content_charset;
+ meta_charset = 0;
+#endif
+#if 0
+ do_blankline(&htmlenv1, &obuf, 0, 0, htmlenv1.limit);
+ obuf.flag = RB_IGNORE_P;
+#endif
+ if (IStype(f->stream) != IST_ENCODED)
+ f->stream = newEncodedStream(f->stream, f->encoding);
+ while ((lineBuf2 = StrmyUFgets(f))->length) {
+#ifdef USE_NNTP
+ if (f->scheme == SCM_NEWS && lineBuf2->ptr[0] == '.') {
+ Strshrinkfirst(lineBuf2, 1);
+ if (lineBuf2->ptr[0] == '\n' || lineBuf2->ptr[0] == '\r' ||
+ lineBuf2->ptr[0] == '\0') {
+ /*
+ * iseos(f->stream) = TRUE;
+ */
+ break;
+ }
+ }
+#endif /* USE_NNTP */
+ if (src)
+ Strfputs(lineBuf2, src);
+ linelen += lineBuf2->length;
+ if (w3m_dump & DUMP_SOURCE)
+ continue;
+ showProgress(&linelen, &trbyte);
+ /*
+ * if (frame_source)
+ * continue;
+ */
+#ifdef USE_M17N
+ if (meta_charset) { /* <META> */
+ if (content_charset == 0 && UseContentCharset) {
+ doc_charset = meta_charset;
+ charset = WC_CES_US_ASCII;
+ }
+ meta_charset = 0;
+ }
+#endif
+ lineBuf2 = convertLine(f, lineBuf2, HTML_MODE, &charset, doc_charset);
+#if defined(USE_M17N) && defined(USE_IMAGE)
+ cur_document_charset = charset;
+#endif
+ HTMLlineproc0(lineBuf2->ptr, &htmlenv1, internal);
+ }
+ if (obuf.status != R_ST_NORMAL) {
+ obuf.status = R_ST_EOL;
+ HTMLlineproc0("\n", &htmlenv1, internal);
+ }
+ obuf.status = R_ST_NORMAL;
+ completeHTMLstream(&htmlenv1, &obuf);
+ flushline(&htmlenv1, &obuf, 0, 2, htmlenv1.limit);
+ if (htmlenv1.title)
+ newBuf->buffername = htmlenv1.title;
+ if (w3m_halfdump) {
+ TRAP_OFF;
+ print_internal_information(&htmlenv1);
+ return;
+ }
+ if (w3m_backend) {
+ TRAP_OFF;
+ print_internal_information(&htmlenv1);
+ backend_halfdump_buf = htmlenv1.buf;
+ return;
+ }
+ phase2:
+ newBuf->trbyte = trbyte + linelen;
+ TRAP_OFF;
+#ifdef USE_M17N
+ if (!(newBuf->bufferprop & BP_FRAME))
+ newBuf->document_charset = charset;
+#endif
+#ifdef USE_IMAGE
+ newBuf->image_flag = image_flag;
+#endif
+ HTMLlineproc2(newBuf, htmlenv1.buf);
+}
+
+/*
+ * loadHTMLString: read string and make new buffer
+ */
+Buffer *
+loadHTMLString(Str page)
+{
+ URLFile f;
+ MySignalHandler(*volatile prevtrap) (SIGNAL_ARG) = NULL;
+ Buffer *newBuf;
+
+ newBuf = newBuffer(INIT_BUFFER_WIDTH);
+ if (SETJMP(AbortLoading) != 0) {
+ TRAP_OFF;
+ discardBuffer(newBuf);
+ return NULL;
+ }
+ TRAP_ON;
+
+ init_stream(&f, SCM_LOCAL, newStrStream(page));
+
+#ifdef USE_M17N
+ newBuf->document_charset = InnerCharset;
+#endif
+ loadHTMLstream(&f, newBuf, NULL, TRUE);
+#ifdef USE_M17N
+ newBuf->document_charset = WC_CES_US_ASCII;
+#endif
+
+ TRAP_OFF;
+ newBuf->topLine = newBuf->firstLine;
+ newBuf->lastLine = newBuf->currentLine;
+ newBuf->currentLine = newBuf->firstLine;
+ newBuf->type = "text/html";
+ newBuf->real_type = newBuf->type;
+ if (n_textarea)
+ formResetBuffer(newBuf, newBuf->formitem);
+ return newBuf;
+}
+
+#ifdef USE_GOPHER
+
+/*
+ * loadGopherDir: get gopher directory
+ */
+Str
+loadGopherDir(URLFile *uf, ParsedURL *pu, wc_ces * charset)
+{
+ Str volatile tmp;
+ Str lbuf, name, file, host, port;
+ char *volatile p, *volatile q;
+ MySignalHandler(*volatile prevtrap) (SIGNAL_ARG) = NULL;
+#ifdef USE_M17N
+ wc_ces doc_charset = DocumentCharset;
+#endif
+
+ tmp = parsedURL2Str(pu);
+ p = html_quote(tmp->ptr);
+ tmp =
+ convertLine(NULL, Strnew_charp(file_unquote(tmp->ptr)), RAW_MODE,
+ charset, doc_charset);
+ q = html_quote(tmp->ptr);
+ tmp = Strnew_m_charp("<html>\n<head>\n<base href=\"", p, "\">\n<title>", q,
+ "</title>\n</head>\n<body>\n<h1>Index of ", q,
+ "</h1>\n<table>\n", NULL);
+
+ if (SETJMP(AbortLoading) != 0)
+ goto gopher_end;
+ TRAP_ON;
+
+ while (1) {
+ if (lbuf = StrUFgets(uf), lbuf->length == 0)
+ break;
+ if (lbuf->ptr[0] == '.' &&
+ (lbuf->ptr[1] == '\n' || lbuf->ptr[1] == '\r'))
+ break;
+ lbuf = convertLine(uf, lbuf, HTML_MODE, charset, doc_charset);
+ p = lbuf->ptr;
+ for (q = p; *q && *q != '\t'; q++) ;
+ name = Strnew_charp_n(p, q - p);
+ if (!*q)
+ continue;
+ p = q + 1;
+ for (q = p; *q && *q != '\t'; q++) ;
+ file = Strnew_charp_n(p, q - p);
+ if (!*q)
+ continue;
+ p = q + 1;
+ for (q = p; *q && *q != '\t'; q++) ;
+ host = Strnew_charp_n(p, q - p);
+ if (!*q)
+ continue;
+ p = q + 1;
+ for (q = p; *q && *q != '\t' && *q != '\r' && *q != '\n'; q++) ;
+ port = Strnew_charp_n(p, q - p);
+
+ switch (name->ptr[0]) {
+ case '0':
+ p = "[text file]";
+ break;
+ case '1':
+ p = "[directory]";
+ break;
+ case 'm':
+ p = "[message]";
+ break;
+ case 's':
+ p = "[sound]";
+ break;
+ case 'g':
+ p = "[gif]";
+ break;
+ case 'h':
+ p = "[HTML]";
+ break;
+ default:
+ p = "[unsupported]";
+ break;
+ }
+ q = Strnew_m_charp("gopher://", host->ptr, ":", port->ptr,
+ "/", file->ptr, NULL)->ptr;
+ Strcat_m_charp(tmp, "<a href=\"",
+ html_quote(url_quote_conv(q, *charset)),
+ "\">", p, html_quote(name->ptr + 1), "</a>\n", NULL);
+ }
+
+ gopher_end:
+ TRAP_OFF;
+
+ Strcat_charp(tmp, "</table>\n</body>\n</html>\n");
+ return tmp;
+}
+#endif /* USE_GOPHER */
+
+/*
+ * loadBuffer: read file and make new buffer
+ */
+Buffer *
+loadBuffer(URLFile *uf, Buffer *volatile newBuf)
+{
+ FILE *volatile src = NULL;
+#ifdef USE_M17N
+ wc_ces charset = WC_CES_US_ASCII;
+ wc_ces volatile doc_charset = DocumentCharset;
+#endif
+ Str lineBuf2;
+ volatile char pre_lbuf = '\0';
+ int nlines;
+ Str tmpf;
+ clen_t linelen = 0, trbyte = 0;
+ Lineprop *propBuffer = NULL;
+#ifdef USE_ANSI_COLOR
+ Linecolor *colorBuffer = NULL;
+#endif
+ MySignalHandler(*volatile prevtrap) (SIGNAL_ARG) = NULL;
+
+ if (newBuf == NULL)
+ newBuf = newBuffer(INIT_BUFFER_WIDTH);
+ lineBuf2 = Strnew();
+
+ if (SETJMP(AbortLoading) != 0) {
+ goto _end;
+ }
+ TRAP_ON;
+
+ if (newBuf->sourcefile == NULL &&
+ (uf->scheme != SCM_LOCAL || newBuf->mailcap)) {
+ tmpf = tmpfname(TMPF_SRC, NULL);
+ src = fopen(tmpf->ptr, "w");
+ if (src)
+ newBuf->sourcefile = tmpf->ptr;
+ }
+#ifdef USE_M17N
+ if (newBuf->document_charset)
+ charset = doc_charset = newBuf->document_charset;
+ if (content_charset && UseContentCharset)
+ doc_charset = content_charset;
+#endif
+
+ nlines = 0;
+ if (IStype(uf->stream) != IST_ENCODED)
+ uf->stream = newEncodedStream(uf->stream, uf->encoding);
+ while ((lineBuf2 = StrmyISgets(uf->stream))->length) {
+#ifdef USE_NNTP
+ if (uf->scheme == SCM_NEWS && lineBuf2->ptr[0] == '.') {
+ Strshrinkfirst(lineBuf2, 1);
+ if (lineBuf2->ptr[0] == '\n' || lineBuf2->ptr[0] == '\r' ||
+ lineBuf2->ptr[0] == '\0') {
+ /*
+ * iseos(uf->stream) = TRUE;
+ */
+ break;
+ }
+ }
+#endif /* USE_NNTP */
+ if (src)
+ Strfputs(lineBuf2, src);
+ linelen += lineBuf2->length;
+ if (w3m_dump & DUMP_SOURCE)
+ continue;
+ showProgress(&linelen, &trbyte);
+ if (frame_source)
+ continue;
+ lineBuf2 =
+ convertLine(uf, lineBuf2, PAGER_MODE, &charset, doc_charset);
+ if (squeezeBlankLine) {
+ if (lineBuf2->ptr[0] == '\n' && pre_lbuf == '\n') {
+ ++nlines;
+ continue;
+ }
+ pre_lbuf = lineBuf2->ptr[0];
+ }
+ ++nlines;
+ Strchop(lineBuf2);
+ lineBuf2 = checkType(lineBuf2, &propBuffer, NULL);
+ addnewline(newBuf, lineBuf2->ptr, propBuffer, colorBuffer,
+ lineBuf2->length, FOLD_BUFFER_WIDTH, nlines);
+ }
+ _end:
+ TRAP_OFF;
+ newBuf->topLine = newBuf->firstLine;
+ newBuf->lastLine = newBuf->currentLine;
+ newBuf->currentLine = newBuf->firstLine;
+ newBuf->trbyte = trbyte + linelen;
+#ifdef USE_M17N
+ newBuf->document_charset = charset;
+#endif
+ if (src)
+ fclose(src);
+
+ return newBuf;
+}
+
+#ifdef USE_IMAGE
+Buffer *
+loadImageBuffer(URLFile *uf, Buffer *newBuf)
+{
+ Image image;
+ ImageCache *cache;
+ Str tmp, tmpf;
+ FILE *src = NULL;
+ URLFile f;
+ MySignalHandler(*volatile prevtrap) (SIGNAL_ARG) = NULL;
+ struct stat st;
+
+ loadImage(newBuf, IMG_FLAG_STOP);
+ image.url = uf->url;
+ image.ext = uf->ext;
+ image.width = -1;
+ image.height = -1;
+ image.cache = NULL;
+ cache = getImage(&image, cur_baseURL, IMG_FLAG_AUTO);
+ if (!cur_baseURL->is_nocache && cache->loaded & IMG_FLAG_LOADED &&
+ !stat(cache->file, &st))
+ goto image_buffer;
+
+ TRAP_ON;
+ if (IStype(uf->stream) != IST_ENCODED)
+ uf->stream = newEncodedStream(uf->stream, uf->encoding);
+ if (save2tmp(*uf, cache->file) < 0) {
+ UFclose(uf);
+ TRAP_OFF;
+ return NULL;
+ }
+ UFclose(uf);
+ TRAP_OFF;
+
+ cache->loaded = IMG_FLAG_LOADED;
+ cache->index = 0;
+
+ image_buffer:
+ if (newBuf == NULL)
+ newBuf = newBuffer(INIT_BUFFER_WIDTH);
+ cache->loaded |= IMG_FLAG_DONT_REMOVE;
+ if (newBuf->sourcefile == NULL && uf->scheme != SCM_LOCAL)
+ newBuf->sourcefile = cache->file;
+
+ tmp = Sprintf("<img src=\"%s\"><br><br>", html_quote(image.url));
+ tmpf = tmpfname(TMPF_SRC, ".html");
+ src = fopen(tmpf->ptr, "w");
+ newBuf->mailcap_source = tmpf->ptr;
+
+ init_stream(&f, SCM_LOCAL, newStrStream(tmp));
+ loadHTMLstream(&f, newBuf, src, TRUE);
+ if (src)
+ fclose(src);
+
+ newBuf->topLine = newBuf->firstLine;
+ newBuf->lastLine = newBuf->currentLine;
+ newBuf->currentLine = newBuf->firstLine;
+ newBuf->image_flag = IMG_FLAG_AUTO;
+ return newBuf;
+}
+#endif
+
+static Str
+conv_symbol(Line *l)
+{
+ Str tmp = NULL;
+ char *p = l->lineBuf, *ep = p + l->len;
+ Lineprop *pr = l->propBuf;
+#ifdef USE_M17N
+ int w;
+ char **symbol = NULL;
+#else
+ char **symbol = get_symbol();
+#endif
+
+ for (; p < ep; p++, pr++) {
+ if (*pr & PC_SYMBOL) {
+#ifdef USE_M17N
+ char c = ((char)wtf_get_code((wc_uchar *) p) & 0x7f) - SYMBOL_BASE;
+ int len = get_mclen(p);
+#else
+ char c = *p - SYMBOL_BASE;
+#endif
+ if (tmp == NULL) {
+ tmp = Strnew_size(l->len);
+ Strcopy_charp_n(tmp, l->lineBuf, p - l->lineBuf);
+#ifdef USE_M17N
+ w = (*pr & PC_KANJI) ? 2 : 1;
+ symbol = get_symbol(DisplayCharset, &w);
+#endif
+ }
+ Strcat_charp(tmp, symbol[(int)c]);
+#ifdef USE_M17N
+ p += len - 1;
+ pr += len - 1;
+#endif
+ }
+ else if (tmp != NULL)
+ Strcat_char(tmp, *p);
+ }
+ if (tmp)
+ return tmp;
+ else
+ return Strnew_charp_n(l->lineBuf, l->len);
+}
+
+/*
+ * saveBuffer: write buffer to file
+ */
+static void
+_saveBuffer(Buffer *buf, Line *l, FILE * f, int cont)
+{
+ Str tmp;
+ int is_html = FALSE;
+#ifdef USE_M17N
+ int set_charset = !DisplayCharset;
+ wc_ces charset = DisplayCharset ? DisplayCharset : WC_CES_US_ASCII;
+#endif
+
+ if (buf->type && !strcasecmp(buf->type, "text/html"))
+ is_html = TRUE;
+
+ pager_next:
+ for (; l != NULL; l = l->next) {
+ if (is_html)
+ tmp = conv_symbol(l);
+ else
+ tmp = Strnew_charp_n(l->lineBuf, l->len);
+ tmp = wc_Str_conv(tmp, InnerCharset, charset);
+ Strfputs(tmp, f);
+ if (Strlastchar(tmp) != '\n' && !(cont && l->next && l->next->bpos))
+ putc('\n', f);
+ }
+ if (buf->pagerSource && !(buf->bufferprop & BP_CLOSE)) {
+ l = getNextPage(buf, PagerMax);
+#ifdef USE_M17N
+ if (set_charset)
+ charset = buf->document_charset;
+#endif
+ goto pager_next;
+ }
+}
+
+void
+saveBuffer(Buffer *buf, FILE * f, int cont)
+{
+ _saveBuffer(buf, buf->firstLine, f, cont);
+}
+
+void
+saveBufferBody(Buffer *buf, FILE * f, int cont)
+{
+ Line *l = buf->firstLine;
+
+ while (l != NULL && l->real_linenumber == 0)
+ l = l->next;
+ _saveBuffer(buf, l, f, cont);
+}
+
+static Buffer *
+loadcmdout(char *cmd,
+ Buffer *(*loadproc) (URLFile *, Buffer *), Buffer *defaultbuf)
+{
+ FILE *f, *popen(const char *, const char *);
+ Buffer *buf;
+ URLFile uf;
+
+ if (cmd == NULL || *cmd == '\0')
+ return NULL;
+ f = popen(cmd, "r");
+ if (f == NULL)
+ return NULL;
+ init_stream(&uf, SCM_UNKNOWN, newFileStream(f, (void (*)())pclose));
+ buf = loadproc(&uf, defaultbuf);
+ UFclose(&uf);
+ return buf;
+}
+
+/*
+ * getshell: execute shell command and get the result into a buffer
+ */
+Buffer *
+getshell(char *cmd)
+{
+ Buffer *buf;
+
+ buf = loadcmdout(cmd, loadBuffer, NULL);
+ if (buf == NULL)
+ return NULL;
+ buf->filename = cmd;
+ buf->buffername = Sprintf("%s %s", SHELLBUFFERNAME,
+ conv_from_system(cmd))->ptr;
+ return buf;
+}
+
+/*
+ * getpipe: execute shell command and connect pipe to the buffer
+ */
+Buffer *
+getpipe(char *cmd)
+{
+ FILE *f, *popen(const char *, const char *);
+ Buffer *buf;
+
+ if (cmd == NULL || *cmd == '\0')
+ return NULL;
+ f = popen(cmd, "r");
+ if (f == NULL)
+ return NULL;
+ buf = newBuffer(INIT_BUFFER_WIDTH);
+ buf->pagerSource = newFileStream(f, (void (*)())pclose);
+ buf->filename = cmd;
+ buf->buffername = Sprintf("%s %s", PIPEBUFFERNAME,
+ conv_from_system(cmd))->ptr;
+ buf->bufferprop |= BP_PIPE;
+#ifdef USE_M17N
+ buf->document_charset = WC_CES_US_ASCII;
+#endif
+ return buf;
+}
+
+/*
+ * Open pager buffer
+ */
+Buffer *
+openPagerBuffer(InputStream stream, Buffer *buf)
+{
+
+ if (buf == NULL)
+ buf = newBuffer(INIT_BUFFER_WIDTH);
+ buf->pagerSource = stream;
+ buf->buffername = getenv("MAN_PN");
+ if (buf->buffername == NULL)
+ buf->buffername = PIPEBUFFERNAME;
+ else
+ buf->buffername = conv_from_system(buf->buffername);
+ buf->bufferprop |= BP_PIPE;
+#ifdef USE_M17N
+ if (content_charset && UseContentCharset)
+ buf->document_charset = content_charset;
+ else
+ buf->document_charset = WC_CES_US_ASCII;
+#endif
+ buf->currentLine = buf->firstLine;
+
+ return buf;
+}
+
+Buffer *
+openGeneralPagerBuffer(InputStream stream)
+{
+ Buffer *buf;
+ char *t = "text/plain";
+ Buffer *t_buf = NULL;
+ URLFile uf;
+
+ init_stream(&uf, SCM_UNKNOWN, stream);
+
+#ifdef USE_M17N
+ content_charset = 0;
+#endif
+ if (SearchHeader) {
+ t_buf = newBuffer(INIT_BUFFER_WIDTH);
+ readHeader(&uf, t_buf, TRUE, NULL);
+ t = checkContentType(t_buf);
+ if (t == NULL)
+ t = "text/plain";
+ if (t_buf) {
+ t_buf->topLine = t_buf->firstLine;
+ t_buf->currentLine = t_buf->lastLine;
+ }
+ SearchHeader = FALSE;
+ }
+ else if (DefaultType) {
+ t = DefaultType;
+ DefaultType = NULL;
+ }
+ if (!strcasecmp(t, "text/html")) {
+ buf = loadHTMLBuffer(&uf, t_buf);
+ buf->type = "text/html";
+ }
+ else if (is_plain_text_type(t)) {
+ if (IStype(stream) != IST_ENCODED)
+ stream = newEncodedStream(stream, uf.encoding);
+ buf = openPagerBuffer(stream, t_buf);
+ buf->type = "text/plain";
+ }
+#ifdef USE_IMAGE
+ else if (activeImage && displayImage && !useExtImageViewer &&
+ !(w3m_dump & ~DUMP_FRAME) && !strncasecmp(t, "image/", 6)) {
+ cur_baseURL = New(ParsedURL);
+ parseURL("-", cur_baseURL, NULL);
+ buf = loadImageBuffer(&uf, t_buf);
+ buf->type = "text/html";
+ }
+#endif
+ else {
+ if (doExternal(uf, "-", t, &buf, t_buf)) {
+ UFclose(&uf);
+ if (buf == NULL || buf == NO_BUFFER)
+ return buf;
+ }
+ else { /* unknown type is regarded as text/plain */
+ if (IStype(stream) != IST_ENCODED)
+ stream = newEncodedStream(stream, uf.encoding);
+ buf = openPagerBuffer(stream, t_buf);
+ buf->type = "text/plain";
+ }
+ }
+ buf->real_type = t;
+ buf->currentURL.scheme = SCM_LOCAL;
+ buf->currentURL.file = "-";
+ return buf;
+}
+
+Line *
+getNextPage(Buffer *buf, int plen)
+{
+ Line *volatile top = buf->topLine, *volatile last = buf->lastLine,
+ *volatile cur = buf->currentLine;
+ int i;
+ int volatile nlines = 0;
+ clen_t linelen = 0, trbyte = buf->trbyte;
+ Str lineBuf2;
+ char volatile pre_lbuf = '\0';
+ URLFile uf;
+#ifdef USE_M17N
+ wc_ces charset;
+ wc_ces volatile doc_charset = DocumentCharset;
+ wc_uint8 old_auto_detect = WcOption.auto_detect;
+#endif
+ int volatile squeeze_flag = FALSE;
+ Lineprop *propBuffer = NULL;
+
+#ifdef USE_ANSI_COLOR
+ Linecolor *colorBuffer = NULL;
+#endif
+ MySignalHandler(*volatile prevtrap) (SIGNAL_ARG) = NULL;
+
+ if (buf->pagerSource == NULL)
+ return NULL;
+
+ if (last != NULL) {
+ nlines = last->real_linenumber;
+ pre_lbuf = *(last->lineBuf);
+ if (pre_lbuf == '\0')
+ pre_lbuf = '\n';
+ buf->currentLine = last;
+ }
+
+#ifdef USE_M17N
+ charset = buf->document_charset;
+ if (buf->document_charset != WC_CES_US_ASCII)
+ doc_charset = buf->document_charset;
+ else if (UseContentCharset) {
+ content_charset = 0;
+ checkContentType(buf);
+ if (content_charset)
+ doc_charset = content_charset;
+ }
+ WcOption.auto_detect = buf->auto_detect;
+#endif
+
+ if (SETJMP(AbortLoading) != 0) {
+ goto pager_end;
+ }
+ TRAP_ON;
+
+ init_stream(&uf, SCM_UNKNOWN, NULL);
+ for (i = 0; i < plen; i++) {
+ lineBuf2 = StrmyISgets(buf->pagerSource);
+ if (lineBuf2->length == 0) {
+ /* Assume that `cmd == buf->filename' */
+ if (buf->filename)
+ buf->buffername = Sprintf("%s %s",
+ CPIPEBUFFERNAME,
+ conv_from_system(buf->filename))->
+ ptr;
+ else if (getenv("MAN_PN") == NULL)
+ buf->buffername = CPIPEBUFFERNAME;
+ buf->bufferprop |= BP_CLOSE;
+ break;
+ }
+ linelen += lineBuf2->length;
+ showProgress(&linelen, &trbyte);
+ lineBuf2 =
+ convertLine(&uf, lineBuf2, PAGER_MODE, &charset, doc_charset);
+ if (squeezeBlankLine) {
+ squeeze_flag = FALSE;
+ if (lineBuf2->ptr[0] == '\n' && pre_lbuf == '\n') {
+ ++nlines;
+ --i;
+ squeeze_flag = TRUE;
+ continue;
+ }
+ pre_lbuf = lineBuf2->ptr[0];
+ }
+ ++nlines;
+ Strchop(lineBuf2);
+ lineBuf2 = checkType(lineBuf2, &propBuffer, &colorBuffer);
+ addnewline(buf, lineBuf2->ptr, propBuffer, colorBuffer,
+ lineBuf2->length, FOLD_BUFFER_WIDTH, nlines);
+ if (!top) {
+ top = buf->firstLine;
+ cur = top;
+ }
+ if (buf->lastLine->real_linenumber - buf->firstLine->real_linenumber
+ >= PagerMax) {
+ Line *l = buf->firstLine;
+ do {
+ if (top == l)
+ top = l->next;
+ if (cur == l)
+ cur = l->next;
+ if (last == l)
+ last = NULL;
+ l = l->next;
+ } while (l && l->bpos);
+ buf->firstLine = l;
+ buf->firstLine->prev = NULL;
+ }
+ }
+ pager_end:
+ TRAP_OFF;
+
+ buf->trbyte = trbyte + linelen;
+#ifdef USE_M17N
+ buf->document_charset = charset;
+ WcOption.auto_detect = old_auto_detect;
+#endif
+ buf->topLine = top;
+ buf->currentLine = cur;
+ if (!last)
+ last = buf->firstLine;
+ else if (last && (last->next || !squeeze_flag))
+ last = last->next;
+ return last;
+}
+
+int
+save2tmp(URLFile uf, char *tmpf)
+{
+ FILE *ff;
+ int check;
+ clen_t linelen = 0, trbyte = 0;
+ MySignalHandler(*volatile prevtrap) (SIGNAL_ARG) = NULL;
+ static JMP_BUF env_bak;
+
+ ff = fopen(tmpf, "wb");
+ if (ff == NULL) {
+ /* fclose(f); */
+ return -1;
+ }
+ bcopy(AbortLoading, env_bak, sizeof(JMP_BUF));
+ if (SETJMP(AbortLoading) != 0) {
+ goto _end;
+ }
+ TRAP_ON;
+ check = 0;
+#ifdef USE_NNTP
+ if (uf.scheme == SCM_NEWS) {
+ char c;
+ while (c = UFgetc(&uf), !iseos(uf.stream)) {
+ if (c == '\n') {
+ if (check == 0)
+ check++;
+ else if (check == 3)
+ break;
+ }
+ else if (c == '.' && check == 1)
+ check++;
+ else if (c == '\r' && check == 2)
+ check++;
+ else
+ check = 0;
+ putc(c, ff);
+ linelen += sizeof(c);
+ showProgress(&linelen, &trbyte);
+ }
+ }
+ else
+#endif /* USE_NNTP */
+ {
+ Str buf = Strnew_size(SAVE_BUF_SIZE);
+ while (UFread(&uf, buf, SAVE_BUF_SIZE)) {
+ Strfputs(buf, ff);
+ linelen += buf->length;
+ showProgress(&linelen, &trbyte);
+ }
+ }
+ _end:
+ bcopy(env_bak, AbortLoading, sizeof(JMP_BUF));
+ TRAP_OFF;
+ fclose(ff);
+ current_content_length = 0;
+ return 0;
+}
+
+int
+doExternal(URLFile uf, char *path, char *type, Buffer **bufp,
+ Buffer *defaultbuf)
+{
+ Str tmpf, command;
+ struct mailcap *mcap;
+ int mc_stat;
+ Buffer *buf = NULL;
+ char *header, *src = NULL, *ext = uf.ext;
+
+ if (!(mcap = searchExtViewer(type)))
+ return 0;
+
+ if (mcap->nametemplate) {
+ tmpf = unquote_mailcap(mcap->nametemplate, NULL, "", NULL, NULL);
+ if (tmpf->ptr[0] == '.')
+ ext = tmpf->ptr;
+ }
+ tmpf = tmpfname(TMPF_DFL, (ext && *ext) ? ext : NULL);
+
+ if (IStype(uf.stream) != IST_ENCODED)
+ uf.stream = newEncodedStream(uf.stream, uf.encoding);
+ header = checkHeader(defaultbuf, "Content-Type:");
+ if (header)
+ header = conv_to_system(header);
+ command = unquote_mailcap(mcap->viewer, type, tmpf->ptr, header, &mc_stat);
+#ifndef __EMX__
+ if (!(mc_stat & MCSTAT_REPNAME)) {
+ Str tmp = Sprintf("(%s) < %s", command->ptr, shell_quote(tmpf->ptr));
+ command = tmp;
+ }
+#endif
+
+#ifdef HAVE_SETPGRP
+ if (!(mcap->flags & (MAILCAP_HTMLOUTPUT | MAILCAP_COPIOUSOUTPUT)) &&
+ !(mcap->flags & MAILCAP_NEEDSTERMINAL) && BackgroundExtViewer) {
+ flush_tty();
+ if (!fork()) {
+ setup_child(FALSE, 0, UFfileno(&uf));
+ if (save2tmp(uf, tmpf->ptr) < 0)
+ exit(1);
+ UFclose(&uf);
+ myExec(command->ptr);
+ }
+ *bufp = NO_BUFFER;
+ return 1;
+ }
+ else
+#endif
+ {
+ if (save2tmp(uf, tmpf->ptr) < 0) {
+ *bufp = NULL;
+ return 1;
+ }
+ }
+ if (mcap->flags & (MAILCAP_HTMLOUTPUT | MAILCAP_COPIOUSOUTPUT)) {
+ if (defaultbuf == NULL)
+ defaultbuf = newBuffer(INIT_BUFFER_WIDTH);
+ if (defaultbuf->sourcefile)
+ src = defaultbuf->sourcefile;
+ else
+ src = tmpf->ptr;
+ defaultbuf->sourcefile = NULL;
+ defaultbuf->mailcap = mcap;
+ }
+ if (mcap->flags & MAILCAP_HTMLOUTPUT) {
+ buf = loadcmdout(command->ptr, loadHTMLBuffer, defaultbuf);
+ if (buf && buf != NO_BUFFER) {
+ buf->type = "text/html";
+ buf->mailcap_source = buf->sourcefile;
+ buf->sourcefile = src;
+ }
+ }
+ else if (mcap->flags & MAILCAP_COPIOUSOUTPUT) {
+ buf = loadcmdout(command->ptr, loadBuffer, defaultbuf);
+ if (buf && buf != NO_BUFFER) {
+ buf->type = "text/plain";
+ buf->mailcap_source = buf->sourcefile;
+ buf->sourcefile = src;
+ }
+ }
+ else {
+ if (mcap->flags & MAILCAP_NEEDSTERMINAL || !BackgroundExtViewer) {
+ fmTerm();
+ mySystem(command->ptr, 0);
+ fmInit();
+ if (CurrentTab && Currentbuf)
+ displayBuffer(Currentbuf, B_FORCE_REDRAW);
+ }
+ else {
+ mySystem(command->ptr, 1);
+ }
+ buf = NO_BUFFER;
+ }
+ if (buf && buf != NO_BUFFER) {
+ buf->filename = path;
+ if (buf->buffername == NULL || buf->buffername[0] == '\0')
+ buf->buffername = conv_from_system(lastFileName(path));
+ buf->edit = mcap->edit;
+ buf->mailcap = mcap;
+ }
+ *bufp = buf;
+ return 1;
+}
+
+static int
+_MoveFile(char *path1, char *path2)
+{
+ InputStream f1;
+ FILE *f2;
+ int is_pipe;
+ clen_t linelen = 0, trbyte = 0;
+ Str buf;
+
+ f1 = openIS(path1);
+ if (f1 == NULL)
+ return -1;
+ if (*path2 == '|' && PermitSaveToPipe) {
+ is_pipe = TRUE;
+ f2 = popen(path2 + 1, "w");
+ }
+ else {
+ is_pipe = FALSE;
+ f2 = fopen(path2, "wb");
+ }
+ if (f2 == NULL) {
+ ISclose(f1);
+ return -1;
+ }
+ current_content_length = 0;
+ buf = Strnew_size(SAVE_BUF_SIZE);
+ while (ISread(f1, buf, SAVE_BUF_SIZE)) {
+ Strfputs(buf, f2);
+ linelen += buf->length;
+ showProgress(&linelen, &trbyte);
+ }
+ ISclose(f1);
+ if (is_pipe)
+ pclose(f2);
+ else
+ fclose(f2);
+ return 0;
+}
+
+int
+_doFileCopy(char *tmpf, char *defstr, int download)
+{
+ Str msg;
+ Str filen;
+ char *p, *q = NULL;
+ pid_t pid;
+ char *lock;
+#if !(defined(HAVE_SYMLINK) && defined(HAVE_LSTAT))
+ FILE *f;
+#endif
+ struct stat st;
+ clen_t size = 0;
+ int is_pipe = FALSE;
+
+ if (fmInitialized) {
+ p = searchKeyData();
+ if (p == NULL || *p == '\0') {
+ /* FIXME: gettextize? */
+ q = inputLineHist("(Download)Save file to: ",
+ defstr, IN_COMMAND, SaveHist);
+ if (q == NULL || *q == '\0')
+ return FALSE;
+ p = conv_to_system(q);
+ }
+ if (*p == '|' && PermitSaveToPipe)
+ is_pipe = TRUE;
+ else {
+ if (q) {
+ p = unescape_spaces(Strnew_charp(q))->ptr;
+ p = conv_to_system(q);
+ }
+ p = expandPath(p);
+ if (checkOverWrite(p) < 0)
+ return -1;
+ }
+ if (checkCopyFile(tmpf, p) < 0) {
+ /* FIXME: gettextize? */
+ msg = Sprintf("Can't copy. %s and %s are identical.",
+ conv_from_system(tmpf), conv_from_system(p));
+ disp_err_message(msg->ptr, FALSE);
+ return -1;
+ }
+ if (!download) {
+ if (_MoveFile(tmpf, p) < 0) {
+ /* FIXME: gettextize? */
+ msg = Sprintf("Can't save to %s", conv_from_system(p));
+ disp_err_message(msg->ptr, FALSE);
+ }
+ return -1;
+ }
+ lock = tmpfname(TMPF_DFL, ".lock")->ptr;
+#if defined(HAVE_SYMLINK) && defined(HAVE_LSTAT)
+ symlink(p, lock);
+#else
+ f = fopen(lock, "w");
+ if (f)
+ fclose(f);
+#endif
+ flush_tty();
+ pid = fork();
+ if (!pid) {
+ setup_child(FALSE, 0, -1);
+ if (!_MoveFile(tmpf, p) && PreserveTimestamp && !is_pipe &&
+ !stat(tmpf, &st))
+ setModtime(p, st.st_mtime);
+ unlink(lock);
+ exit(0);
+ }
+ if (!stat(tmpf, &st))
+ size = st.st_size;
+ addDownloadList(pid, conv_from_system(tmpf), p, lock, size);
+ }
+ else {
+ q = searchKeyData();
+ if (q == NULL || *q == '\0') {
+ /* FIXME: gettextize? */
+ printf("(Download)Save file to: ");
+ fflush(stdout);
+ filen = Strfgets(stdin);
+ if (filen->length == 0)
+ return -1;
+ q = filen->ptr;
+ }
+ for (p = q + strlen(q) - 1; IS_SPACE(*p); p--) ;
+ *(p + 1) = '\0';
+ if (*q == '\0')
+ return -1;
+ p = q;
+ if (*p == '|' && PermitSaveToPipe)
+ is_pipe = TRUE;
+ else {
+ p = expandPath(p);
+ if (checkOverWrite(p) < 0)
+ return -1;
+ }
+ if (checkCopyFile(tmpf, p) < 0) {
+ /* FIXME: gettextize? */
+ printf("Can't copy. %s and %s are identical.", tmpf, p);
+ return -1;
+ }
+ if (_MoveFile(tmpf, p) < 0) {
+ /* FIXME: gettextize? */
+ printf("Can't save to %s\n", p);
+ return -1;
+ }
+ if (PreserveTimestamp && !is_pipe && !stat(tmpf, &st))
+ setModtime(p, st.st_mtime);
+ }
+ return 0;
+}
+
+int
+doFileMove(char *tmpf, char *defstr)
+{
+ int ret = doFileCopy(tmpf, defstr);
+ unlink(tmpf);
+ return ret;
+}
+
+int
+doFileSave(URLFile uf, char *defstr)
+{
+ Str msg;
+ Str filen;
+ char *p, *q;
+ pid_t pid;
+ char *lock;
+#if !(defined(HAVE_SYMLINK) && defined(HAVE_LSTAT))
+ FILE *f;
+#endif
+
+ if (fmInitialized) {
+ p = searchKeyData();
+ if (p == NULL || *p == '\0') {
+ /* FIXME: gettextize? */
+ p = inputLineHist("(Download)Save file to: ",
+ defstr, IN_FILENAME, SaveHist);
+ if (p == NULL || *p == '\0')
+ return -1;
+ p = conv_to_system(p);
+ }
+ if (checkOverWrite(p) < 0)
+ return -1;
+ if (checkSaveFile(uf.stream, p) < 0) {
+ /* FIXME: gettextize? */
+ msg = Sprintf("Can't save. Load file and %s are identical.",
+ conv_from_system(p));
+ disp_err_message(msg->ptr, FALSE);
+ return -1;
+ }
+ /*
+ * if (save2tmp(uf, p) < 0) {
+ * msg = Sprintf("Can't save to %s", conv_from_system(p));
+ * disp_err_message(msg->ptr, FALSE);
+ * }
+ */
+ lock = tmpfname(TMPF_DFL, ".lock")->ptr;
+#if defined(HAVE_SYMLINK) && defined(HAVE_LSTAT)
+ symlink(p, lock);
+#else
+ f = fopen(lock, "w");
+ if (f)
+ fclose(f);
+#endif
+ flush_tty();
+ pid = fork();
+ if (!pid) {
+ setup_child(FALSE, 0, UFfileno(&uf));
+ if (!save2tmp(uf, p) && PreserveTimestamp && uf.modtime != -1)
+ setModtime(p, uf.modtime);
+ UFclose(&uf);
+ unlink(lock);
+ exit(0);
+ }
+ addDownloadList(pid, uf.url, p, lock, current_content_length);
+ }
+ else {
+ q = searchKeyData();
+ if (q == NULL || *q == '\0') {
+ /* FIXME: gettextize? */
+ printf("(Download)Save file to: ");
+ fflush(stdout);
+ filen = Strfgets(stdin);
+ if (filen->length == 0)
+ return -1;
+ q = filen->ptr;
+ }
+ for (p = q + strlen(q) - 1; IS_SPACE(*p); p--) ;
+ *(p + 1) = '\0';
+ if (*q == '\0')
+ return -1;
+ p = expandPath(q);
+ if (checkOverWrite(p) < 0)
+ return -1;
+ if (checkSaveFile(uf.stream, p) < 0) {
+ /* FIXME: gettextize? */
+ printf("Can't save. Load file and %s are identical.", p);
+ return -1;
+ }
+ if (save2tmp(uf, p) < 0) {
+ /* FIXME: gettextize? */
+ printf("Can't save to %s\n", p);
+ return -1;
+ }
+ if (PreserveTimestamp && uf.modtime != -1)
+ setModtime(p, uf.modtime);
+ }
+ return 0;
+}
+
+int
+checkCopyFile(char *path1, char *path2)
+{
+ struct stat st1, st2;
+
+ if (*path2 == '|' && PermitSaveToPipe)
+ return 0;
+ if ((stat(path1, &st1) == 0) && (stat(path2, &st2) == 0))
+ if (st1.st_ino == st2.st_ino)
+ return -1;
+ return 0;
+}
+
+int
+checkSaveFile(InputStream stream, char *path2)
+{
+ struct stat st1, st2;
+ int des = ISfileno(stream);
+
+ if (des < 0)
+ return 0;
+ if (*path2 == '|' && PermitSaveToPipe)
+ return 0;
+ if ((fstat(des, &st1) == 0) && (stat(path2, &st2) == 0))
+ if (st1.st_ino == st2.st_ino)
+ return -1;
+ return 0;
+}
+
+int
+checkOverWrite(char *path)
+{
+ struct stat st;
+ char *ans;
+
+ if (stat(path, &st) < 0)
+ return 0;
+ /* FIXME: gettextize? */
+ ans = inputAnswer("File exists. Overwrite? (y/n)");
+ if (ans && TOLOWER(*ans) == 'y')
+ return 0;
+ else
+ return -1;
+}
+
+char *
+inputAnswer(char *prompt)
+{
+ char *ans;
+
+ if (QuietMessage)
+ return "n";
+ if (fmInitialized) {
+ term_raw();
+ ans = inputChar(prompt);
+ }
+ else {
+ printf(prompt);
+ fflush(stdout);
+ ans = Strfgets(stdin)->ptr;
+ }
+ return ans;
+}
+
+static void
+uncompress_stream(URLFile *uf, char **src)
+{
+ pid_t pid1;
+ FILE *f1;
+ char *expand_cmd = GUNZIP_CMDNAME;
+ char *expand_name = GUNZIP_NAME;
+ char *tmpf = NULL;
+ char *ext = NULL;
+ struct compression_decoder *d;
+
+ if (IStype(uf->stream) != IST_ENCODED) {
+ uf->stream = newEncodedStream(uf->stream, uf->encoding);
+ uf->encoding = ENC_7BIT;
+ }
+ for (d = compression_decoders; d->type != CMP_NOCOMPRESS; d++) {
+ if (uf->compression == d->type) {
+ if (d->auxbin_p)
+ expand_cmd = auxbinFile(d->cmd);
+ else
+ expand_cmd = d->cmd;
+ expand_name = d->name;
+ ext = d->ext;
+ break;
+ }
+ }
+ uf->compression = CMP_NOCOMPRESS;
+
+ if (uf->scheme != SCM_LOCAL
+#ifdef USE_IMAGE
+ && !image_source
+#endif
+ ) {
+ tmpf = tmpfname(TMPF_DFL, ext)->ptr;
+ }
+
+ /* child1 -- stdout|f1=uf -> parent */
+ pid1 = open_pipe_rw(&f1, NULL);
+ if (pid1 < 0) {
+ UFclose(uf);
+ return;
+ }
+ if (pid1 == 0) {
+ /* child */
+ pid_t pid2;
+ FILE *f2 = stdin;
+
+ /* uf -> child2 -- stdout|stdin -> child1 */
+ pid2 = open_pipe_rw(&f2, NULL);
+ if (pid2 < 0) {
+ UFclose(uf);
+ exit(1);
+ }
+ if (pid2 == 0) {
+ /* child2 */
+ Str buf = Strnew_size(SAVE_BUF_SIZE);
+ FILE *f = NULL;
+
+ setup_child(TRUE, 2, UFfileno(uf));
+ if (tmpf)
+ f = fopen(tmpf, "wb");
+ while (UFread(uf, buf, SAVE_BUF_SIZE)) {
+ if (Strfputs(buf, stdout) < 0)
+ break;
+ if (f)
+ Strfputs(buf, f);
+ }
+ UFclose(uf);
+ if (f)
+ fclose(f);
+ exit(0);
+ }
+ /* child1 */
+ dup2(1, 2); /* stderr>&stdout */
+ setup_child(TRUE, -1, -1);
+ execlp(expand_cmd, expand_name, NULL);
+ exit(1);
+ }
+ if (tmpf) {
+ if (src)
+ *src = tmpf;
+ else
+ uf->scheme = SCM_LOCAL;
+ }
+ UFhalfclose(uf);
+ uf->stream = newFileStream(f1, (void (*)())pclose);
+}
+
+static FILE *
+lessopen_stream(char *path)
+{
+ char *lessopen;
+ FILE *fp;
+
+ lessopen = getenv("LESSOPEN");
+ if (lessopen == NULL) {
+ return NULL;
+ }
+ if (lessopen[0] == '\0') {
+ return NULL;
+ }
+
+ if (lessopen[0] == '|') {
+ /* pipe mode */
+ Str tmpf;
+ int c;
+
+ ++lessopen;
+ tmpf = Sprintf(lessopen, shell_quote(path));
+ fp = popen(tmpf->ptr, "r");
+ if (fp == NULL) {
+ return NULL;
+ }
+ c = getc(fp);
+ if (c == EOF) {
+ fclose(fp);
+ return NULL;
+ }
+ ungetc(c, fp);
+ }
+ else {
+ /* filename mode */
+ /* not supported m(__)m */
+ fp = NULL;
+ }
+ return fp;
+}
+
+#if 0
+void
+reloadBuffer(Buffer *buf)
+{
+ URLFile uf;
+
+ if (buf->sourcefile == NULL || buf->pagerSource != NULL)
+ return;
+ init_stream(&uf, SCM_UNKNOWN, NULL);
+ examineFile(buf->mailcap_source ? buf->mailcap_source : buf->sourcefile,
+ &uf);
+ if (uf.stream == NULL)
+ return;
+ is_redisplay = TRUE;
+ buf->allLine = 0;
+ buf->href = NULL;
+ buf->name = NULL;
+ buf->img = NULL;
+ buf->formitem = NULL;
+ buf->linklist = NULL;
+ buf->maplist = NULL;
+ if (buf->hmarklist)
+ buf->hmarklist->nmark = 0;
+ if (buf->imarklist)
+ buf->imarklist->nmark = 0;
+ if (!strcasecmp(buf->type, "text/html"))
+ loadHTMLBuffer(&uf, buf);
+ else
+ loadBuffer(&uf, buf);
+ UFclose(&uf);
+ is_redisplay = FALSE;
+}
+#endif
+
+static char *
+guess_filename(char *file)
+{
+ char *p = NULL, *s;
+
+ if (file != NULL)
+ p = mybasename(file);
+ if (p == NULL || *p == '\0')
+ return DEF_SAVE_FILE;
+ s = p;
+ if (*p == '#')
+ p++;
+ while (*p != '\0') {
+ if ((*p == '#' && *(p + 1) != '\0') || *p == '?') {
+ *p = '\0';
+ break;
+ }
+ p++;
+ }
+ return s;
+}
+
+char *
+guess_save_name(Buffer *buf, char *path)
+{
+ if (buf && buf->document_header) {
+ Str name = NULL;
+ char *p, *q;
+ if ((p = checkHeader(buf, "Content-Disposition:")) != NULL &&
+ (q = strcasestr(p, "filename")) != NULL &&
+ (q == p || IS_SPACE(*(q - 1)) || *(q - 1) == ';') &&
+ matchattr(q, "filename", 8, &name))
+ path = name->ptr;
+ else if ((p = checkHeader(buf, "Content-Type:")) != NULL &&
+ (q = strcasestr(p, "name")) != NULL &&
+ (q == p || IS_SPACE(*(q - 1)) || *(q - 1) == ';') &&
+ matchattr(q, "name", 4, &name))
+ path = name->ptr;
+ }
+ return guess_filename(path);
+}
+
+/* Local Variables: */
+/* c-basic-offset: 4 */
+/* tab-width: 8 */
+/* End: */
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-21 21:47:42 +0000