#include #include #include #include #include #include #ifdef __MINGW32__ int kbhit(void); #ifdef UNIX #undef UNIX #endif /* UNIX */ #endif /* __MINGW32__ */ #include #include #include #include #include #include #include #include #include #include #include #include #ifdef __DJGPP__ #include #include #endif /* __DJGPP__ */ #ifndef NO_GROUPS #include #endif #ifdef _WINDOWS /* 1998/04/30 (Thu) 19:04:25 */ #define GETPID() (getpid() & 0xffff) #else #define GETPID() getpid() #endif /* _WINDOWS */ #ifdef DJGPP_KEYHANDLER #include #endif /* DJGPP_KEYHANDLER */ #ifdef __EMX__ # define BOOLEAN OS2_BOOLEAN /* Conflicts, but is used */ # undef HT_ERROR /* Conflicts too */ # define INCL_PM /* I want some PM functions.. */ # define INCL_DOSPROCESS /* TIB PIB. */ # include # undef BOOLEAN #endif #ifdef VMS #include #include #include #endif /* VMS */ #ifdef HAVE_UTMP #include #ifdef UTMPX_FOR_UTMP #include #define utmp utmpx #ifdef UTMPX_FILE #ifdef UTMP_FILE #undef UTMP_FILE #endif /* UTMP_FILE */ #define UTMP_FILE UTMPX_FILE #else #ifdef __UTMPX_FILE #define UTMP_FILE __UTMPX_FILE /* at least in OS/390 S/390 -- gil -- 2100 */ #else #define UTMP_FILE "/var/adm/utmpx" /* Digital Unix 4.0 */ #endif #endif /* UTMPX_FILE */ #else #include #endif /* UTMPX_FOR_UTMP */ #endif /* HAVE_UTMP */ #ifdef NEED_PTEM_H /* they neglected to define struct winsize in termios.h -- it's only in * termio.h and ptem.h (the former conflicts with other definitions). */ #include #include #endif #include #ifdef USE_COLOR_STYLE #include #include #include #endif #ifdef SVR4_BSDSELECT extern int BSDselect(int nfds, fd_set * readfds, fd_set * writefds, fd_set * exceptfds, struct timeval *timeout); #ifdef select #undef select #endif /* select */ #define select BSDselect #ifdef SOCKS #ifdef Rselect #undef Rselect #endif /* Rselect */ #define Rselect BSDselect #endif /* SOCKS */ #endif /* SVR4_BSDSELECT */ #ifdef __DJGPP__ #undef select /* defined to select_s in www_tcp.h */ #endif #ifndef UTMP_FILE #if defined(__FreeBSD__) || defined(__bsdi__) #define UTMP_FILE _PATH_UTMP #else #define UTMP_FILE "/etc/utmp" #endif /* __FreeBSD__ || __bsdi__ */ #endif /* !UTMP_FILE */ /* * experimental - make temporary filenames random to make the scheme less * obvious. However, as noted by KW, there are instances (such as the * 'O'ption page, for which Lynx will store a temporary filename even when * it no longer applies, since it will reuse that filename at a later time. */ #ifdef EXP_RAND_TEMPNAME #if defined(LYNX_RAND_MAX) #define USE_RAND_TEMPNAME 1 #define MAX_TEMPNAME 10000 #ifndef BITS_PER_CHAR #define BITS_PER_CHAR 8 #endif #endif #endif #define COPY_COMMAND "%s %s %s" static HTList *localhost_aliases = NULL; /* Hosts to treat as local */ static char *HomeDir = NULL; /* HOME directory */ HTList *sug_filenames = NULL; /* Suggested filenames */ /* * Maintain a list of all of the temp-files we create so that we can remove * them during the cleanup. */ typedef struct _LYTemp { struct _LYTemp *next; char *name; BOOLEAN outs; FILE *file; } LY_TEMP; static LY_TEMP *ly_temp; static LY_TEMP *FindTempfileByName(const char *name) { LY_TEMP *p; for (p = ly_temp; p != 0; p = p->next) { if (!strcmp(p->name, name)) { break; } } return p; } static LY_TEMP *FindTempfileByFP(FILE *fp) { LY_TEMP *p; for (p = ly_temp; p != 0; p = p->next) { if (p->file == fp) { break; } } return p; } /* * Get an environment variable, rejecting empty strings */ char *LYGetEnv(const char *name) { char *result = getenv(name); return non_empty(result) ? result : 0; } /* * ascii versions of locale sensitive functions needed because in * Turkish locales tolower("I") is not "i". That's fatal for case * sensitive operations with charset names, HTML tags etc. */ #ifdef EXP_ASCII_CTYPES int ascii_tolower(int i) { if (91 > i && i > 64) return (i + 32); else return i; } int ascii_toupper(int i) { if (123 > i && i > 96) return (i - 32); else return i; } int ascii_isupper(int i) { if (91 > i && i > 64) return 1; else return 0; } #endif /* EXP_ASCII_CTYPES */ /* * Check for UTF-8 data, returning the length past the first character. * Return zero if we found an ordinary character rather than UTF-8. */ size_t utf8_length(BOOL utf_flag, const char *data) { size_t utf_extra = 0; if (utf_flag && is8bits(*data)) { if ((*data & 0xe0) == 0xc0) { utf_extra = 1; } else if ((*data & 0xf0) == 0xe0) { utf_extra = 2; } else if ((*data & 0xf8) == 0xf0) { utf_extra = 3; } else if ((*data & 0xfc) == 0xf8) { utf_extra = 4; } else if ((*data & 0xfe) == 0xfc) { utf_extra = 5; } else { /* * Garbage. */ utf_extra = 0; } if (strlen(data + 1) < utf_extra) { /* * Shouldn't happen. */ utf_extra = 0; } } return utf_extra; } /* * Free storage used for the link-highlighting. */ void LYFreeHilites(int first, int last) { int i; for (i = first; i < last; i++) { LYSetHilite(i, NULL); FREE(links[i].lname); } } #define LXP (links[cur].lx) #define LYP (links[cur].ly) /* * Set the initial highlight information for a given link. */ void LYSetHilite(int cur, const char *text) { links[cur].list.hl_base.hl_text = (char *) text; links[cur].list.hl_len = (text != NULL) ? 1 : 0; FREE(links[cur].list.hl_info); } /* * Add highlight information for the next line of a link. */ void LYAddHilite(int cur, char *text, int x) { HiliteList *list = &(links[cur].list); HiliteInfo *have = list->hl_info; unsigned need = (list->hl_len - 1); unsigned want = (list->hl_len += 1); if (have != NULL) { have = typeRealloc(HiliteInfo, have, want); } else { have = typeMallocn(HiliteInfo, want); } list->hl_info = have; have[need].hl_text = text; have[need].hl_x = x; } /* * Get the highlight text, counting from zero. */ const char *LYGetHiliteStr(int cur, int count) { const char *result; if (count >= links[cur].list.hl_len) result = NULL; else if (count > 0) result = links[cur].list.hl_info[count - 1].hl_text; else result = links[cur].list.hl_base.hl_text; return result; } /* * Get the X-ordinate at which to draw the corresponding highlight-text */ int LYGetHilitePos(int cur, int count) { int result; if (count >= links[cur].list.hl_len) result = -1; else if (count > 0) result = links[cur].list.hl_info[count - 1].hl_x; else result = LXP; return result; } #ifdef SHOW_WHEREIS_TARGETS #define SKIP_GLYPHS(theFlag, theData, theOffset) \ (theFlag \ ? LYmbcs_skip_glyphs(theData, (theOffset), theFlag) \ : (theData + (theOffset))) /* * If we have an emphasized WHEREIS hit in the highlighted text, restore the * emphasis. Note that we never emphasize the first and last characters of the * highlighted text when we are making the link current, so the link attributes * for the current link will persist at the beginning and end, providing an * indication to the user that it has been made current. Also note that we use * HText_getFirstTargetInLine() to determine if there's a hit in the HText * structure line containing the link, and if so, get back a copy of the line * starting at that first hit (which might be before or after our link), and * with all IsSpecial characters stripped, so we don't need to deal with them * here. -FM */ static BOOL show_whereis_targets(int flag, int cur, int count, const char *target, BOOL TargetEmphasisON, BOOL utf_flag) { const char *Data = NULL; const char *cp; char *theData = NULL; char buffer[MAX_LINE]; char tmp[7]; int HitOffset; int LenNeeded; int Offset; int tLen; tmp[0] = tmp[1] = tmp[2] = '\0'; if (non_empty(target) && (links[cur].type & WWW_LINK_TYPE) && non_empty(LYGetHiliteStr(cur, count)) && LYP + count < display_lines && HText_getFirstTargetInLine(HTMainText, links[cur].anchor_line_num + count, utf_flag, &Offset, &tLen, &theData, target)) { int itmp, written, len, y, offset; const char *data; int tlen = strlen(target); int hlen, hLen; int hLine = LYP + count; int hoffset = LYGetHilitePos(cur, count); size_t utf_extra = 0; /* * Copy into the buffer only what will fit up to the right border of * the screen. -FM */ LYmbcsstrncpy(buffer, NonNull(LYGetHiliteStr(cur, count)), (sizeof(buffer) - 1), (LYcolLimit - LYGetHilitePos(cur, count)), utf_flag); hlen = strlen(buffer); hLen = ((HTCJK != NOCJK || utf_flag) ? LYmbcsstrlen(buffer, utf_flag, YES) : hlen); /* * Break out if the first hit in the line starts after this link. -FM */ if (Offset < (hoffset + hLen)) { /* * Recursively skip hits that end before this link, and break out * if there is no hit beyond those. -FM */ Data = theData; while ((Offset < hoffset) && ((Offset + tLen) <= hoffset)) { data = (Data + tlen); offset = (Offset + tLen); if (((cp = LYno_attr_mb_strstr(data, target, utf_flag, YES, &HitOffset, &LenNeeded)) != NULL) && (offset + LenNeeded) < LYcols) { Data = cp; Offset = (offset + HitOffset); } else { goto highlight_search_done; } } data = buffer; offset = hoffset; /* * If the hit starts before the hightext, and ends in or beyond the * hightext, restore the emphasis, skipping the first and last * characters of the hightext if we're making the link current. * -FM */ if ((Offset < offset) && ((Offset + tLen) > offset)) { itmp = 0; written = 0; len = (tlen - (offset - Offset)); /* * Go to the start of the hightext and handle its first * character. -FM */ LYmove(hLine, offset); tmp[0] = data[itmp]; utf_extra = utf8_length(utf_flag, data + itmp); if (utf_extra) { LYstrncpy(&tmp[1], &data[itmp + 1], utf_extra); itmp += utf_extra; /* * Start emphasis immediately if we are making the link * non-current. -FM */ if (flag != ON) { LYstartTargetEmphasis(); TargetEmphasisON = TRUE; LYaddstr(tmp); } else { LYmove(hLine, (offset + 1)); } tmp[1] = '\0'; written += (utf_extra + 1); utf_extra = 0; } else if (HTCJK != NOCJK && is8bits(tmp[0])) { /* * For CJK strings, by Masanobu Kimura. */ tmp[1] = data[++itmp]; /* * Start emphasis immediately if we are making the link * non-current. -FM */ if (flag != ON) { LYstartTargetEmphasis(); TargetEmphasisON = TRUE; LYaddstr(tmp); } else { LYmove(hLine, (offset + 1)); } tmp[1] = '\0'; written += 2; } else { /* * Start emphasis immediately if we are making the link * non-current. -FM */ if (flag != ON) { LYstartTargetEmphasis(); TargetEmphasisON = TRUE; LYaddstr(tmp); } else { LYmove(hLine, (offset + 1)); } written++; } itmp++; /* * Start emphasis after the first character if we are making * the link current and this is not the last character. -FM */ if (!TargetEmphasisON && data[itmp] != '\0') { LYstartTargetEmphasis(); TargetEmphasisON = TRUE; } /* * Handle the remaining characters. -FM */ for (; written < len && (tmp[0] = data[itmp]) != '\0'; itmp++) { /* * Print all the other target chars, except the last * character if it is also the last character of hightext * and we are making the link current. -FM */ utf_extra = utf8_length(utf_flag, data + itmp); if (utf_extra) { LYstrncpy(&tmp[1], &data[itmp + 1], utf_extra); itmp += utf_extra; /* * Make sure we don't restore emphasis to the last * character of hightext if we are making the link * current. -FM */ if (flag == ON && data[(itmp + 1)] == '\0') { LYstopTargetEmphasis(); TargetEmphasisON = FALSE; LYGetYX(y, offset); LYmove(hLine, (offset + 1)); } else { LYaddstr(tmp); } tmp[1] = '\0'; written += (utf_extra + 1); utf_extra = 0; } else if (HTCJK != NOCJK && is8bits(tmp[0])) { /* * For CJK strings, by Masanobu Kimura. */ tmp[1] = data[++itmp]; /* * Make sure we don't restore emphasis to the last * character of hightext if we are making the link * current. -FM */ if (flag == ON && data[(itmp + 1)] == '\0') { LYstopTargetEmphasis(); TargetEmphasisON = FALSE; LYGetYX(y, offset); LYmove(hLine, (offset + 1)); } else { LYaddstr(tmp); } tmp[1] = '\0'; written += 2; } else { /* * Make sure we don't restore emphasis to the last * character of hightext if we are making the link * current. -FM */ if (flag == ON && data[(itmp + 1)] == '\0') { LYstopTargetEmphasis(); TargetEmphasisON = FALSE; LYGetYX(y, offset); LYmove(hLine, (offset + 1)); } else { LYaddstr(tmp); } written++; } } /* * Stop the emphasis if we haven't already, then reset the * offset to our current position in the line, and if that is * beyond the link, or or we are making the link current and it * is the last character of the hightext, we are done. -FM */ if (TargetEmphasisON) { LYstopTargetEmphasis(); TargetEmphasisON = FALSE; } LYGetYX(y, offset); if (offset < (hoffset + (flag == ON ? (hLen - 1) : hLen)) /* * See if we have another hit that starts within the * hightext. -FM */ && ((cp = LYno_attr_mb_strstr(data = SKIP_GLYPHS(utf_flag, Data, offset - Offset), target, utf_flag, YES, &HitOffset, &LenNeeded)) != NULL) && (offset + LenNeeded) < LYcols /* * If the hit starts after the end of the hightext, or we * are making the link current and the hit starts at its * last character, we are done. -FM */ && (HitOffset + offset) < (hoffset + (flag == ON ? (hLen - 1) : hLen))) { /* * Set up the data and offset for the hit, and let the code * for within hightext hits handle it. -FM */ Data = cp; Offset = (offset + HitOffset); data = buffer; offset = hoffset; goto highlight_hit_within_hightext; } goto highlight_search_done; } highlight_hit_within_hightext: /* * If we get to here, the hit starts within the hightext. If we * are making the link current and it's the last character in the * hightext, we are done. Otherwise, move there and start * restoring the emphasis. -FM */ if ((Offset - offset) <= (flag == ON ? (hLen - 1) : hLen)) { data = SKIP_GLYPHS(utf_flag, data, Offset - offset); if (utf_flag) { LYrefresh(); } offset = Offset; itmp = 0; written = 0; len = tlen; /* * Go to the start of the hit and handle its first character. * -FM */ LYmove(hLine, offset); tmp[0] = data[itmp]; utf_extra = utf8_length(utf_flag, data + itmp); if (utf_extra) { LYstrncpy(&tmp[1], &data[itmp + 1], utf_extra); itmp += utf_extra; /* * Start emphasis immediately if we are making the link * non-current, or we are making it current but this is not * the first or last character of the hightext. -FM */ if (flag != ON || (offset > hoffset && data[itmp + 1] != '\0')) { LYstartTargetEmphasis(); TargetEmphasisON = TRUE; LYaddstr(tmp); } else { LYmove(hLine, (offset + 1)); } tmp[1] = '\0'; written += (utf_extra + 1); utf_extra = 0; } else if (HTCJK != NOCJK && is8bits(tmp[0])) { /* * For CJK strings, by Masanobu Kimura. */ tmp[1] = data[++itmp]; /* * Start emphasis immediately if we are making the link * non-current, or we are making it current but this is not * the first or last character of the hightext. -FM */ if (flag != ON || (offset > hoffset && data[itmp + 1] != '\0')) { LYstartTargetEmphasis(); TargetEmphasisON = TRUE; LYaddstr(tmp); } else { LYmove(hLine, (offset + 2)); } tmp[1] = '\0'; written += 2; } else { /* * Start emphasis immediately if we are making the link * non-current, or we are making it current but this is not * the first or last character of the hightext. -FM */ if (flag != ON || (offset > hoffset && data[itmp + 1] != '\0')) { LYstartTargetEmphasis(); TargetEmphasisON = TRUE; LYaddstr(tmp); } else { LYmove(hLine, (offset + 1)); } written++; } itmp++; /* * Start emphasis after the first character if we are making * the link current and this is not the last character. -FM */ if (!TargetEmphasisON && data[itmp] != '\0') { LYstartTargetEmphasis(); TargetEmphasisON = TRUE; } for (; written < len && (tmp[0] = data[itmp]) != '\0'; itmp++) { /* * Print all the other target chars, except the last * character if it is also the last character of hightext * and we are making the link current. -FM */ utf_extra = utf8_length(utf_flag, data + itmp); if (utf_extra) { LYstrncpy(&tmp[1], &data[itmp + 1], utf_extra); itmp += utf_extra; /* * Make sure we don't restore emphasis to the last * character of hightext if we are making the link * current. -FM */ if (flag == ON && data[(itmp + 1)] == '\0') { LYstopTargetEmphasis(); TargetEmphasisON = FALSE; LYGetYX(y, offset); LYmove(hLine, (offset + 1)); } else { LYaddstr(tmp); } tmp[1] = '\0'; written += (utf_extra + 1); utf_extra = 0; } else if (HTCJK != NOCJK && is8bits(tmp[0])) { /* * For CJK strings, by Masanobu Kimura. */ tmp[1] = data[++itmp]; /* * Make sure we don't restore emphasis to the last * character of hightext if we are making the link * current. -FM */ if (flag == ON && data[(itmp + 1)] == '\0') { LYstopTargetEmphasis(); TargetEmphasisON = FALSE; LYGetYX(y, offset); LYmove(hLine, (offset + 1)); } else { LYaddstr(tmp); } tmp[1] = '\0'; written += 2; } else { /* * Make sure we don't restore emphasis to the last * character of hightext if we are making the link * current. -FM */ if (flag == ON && data[(itmp + 1)] == '\0') { LYstopTargetEmphasis(); TargetEmphasisON = FALSE; LYGetYX(y, offset); LYmove(hLine, (offset + 1)); } else { LYaddstr(tmp); } written++; } } /* * Stop the emphasis if we haven't already, then reset the * offset to our current position in the line, and if that is * beyond the link, or we are making the link current and it is * the last character in the hightext, we are done. -FM */ if (TargetEmphasisON) { LYstopTargetEmphasis(); TargetEmphasisON = FALSE; } LYGetYX(y, offset); if (offset < (hoffset + (flag == ON ? (hLen - 1) : hLen)) /* * See if we have another hit that starts within the * hightext. -FM */ && ((cp = LYno_attr_mb_strstr(data = SKIP_GLYPHS(utf_flag, Data, offset - Offset), target, utf_flag, YES, &HitOffset, &LenNeeded)) != NULL) && (offset + LenNeeded) < LYcols /* * If the hit starts after the end of the hightext, or we * are making the link current and the hit starts at its * last character, we are done. -FM */ && (HitOffset + offset) < (hoffset + (flag == ON ? (hLen - 1) : hLen))) { /* * If the target extends beyond our buffer, emphasize * everything in the hightext starting at this hit. * Otherwise, set up the data and offsets, and loop back. * -FM */ if ((HitOffset + (offset + tLen)) >= (hoffset + hLen)) { offset = (HitOffset + offset); data = SKIP_GLYPHS(utf_flag, Data, offset - hoffset); if (utf_flag) { LYrefresh(); } LYmove(hLine, offset); itmp = 0; written = 0; len = strlen(data); /* * Turn the emphasis back on. -FM */ LYstartTargetEmphasis(); TargetEmphasisON = TRUE; for (; written < len && (tmp[0] = data[itmp]) != '\0'; itmp++) { /* * Print all the other target chars, except the * last character if it is also the last character * of hightext and we are making the link current. * -FM */ utf_extra = utf8_length(utf_flag, data + itmp); if (utf_extra) { LYstrncpy(&tmp[1], &data[itmp + 1], utf_extra); itmp += utf_extra; /* * Make sure we don't restore emphasis to the * last character of hightext if we are making * the link current. -FM */ if (flag == ON && data[(itmp + 1)] == '\0') { LYstopTargetEmphasis(); TargetEmphasisON = FALSE; LYGetYX(y, offset); LYmove(hLine, (offset + 1)); } else { LYaddstr(tmp); } tmp[1] = '\0'; written += (utf_extra + 1); utf_extra = 0; } else if (HTCJK != NOCJK && is8bits(tmp[0])) { /* * For CJK strings, by Masanobu Kimura. */ tmp[1] = data[++itmp]; /* * Make sure we don't restore emphasis to the * last character of hightext if we are making * the link current. -FM */ if (flag == ON && data[(itmp + 1)] == '\0') { LYstopTargetEmphasis(); TargetEmphasisON = FALSE; } else { LYaddstr(tmp); } tmp[1] = '\0'; written += 2; } else { /* * Make sure we don't restore emphasis to the * last character of hightext if we are making * the link current. -FM */ if (flag == ON && data[(itmp + 1)] == '\0') { LYstopTargetEmphasis(); TargetEmphasisON = FALSE; } else { LYaddstr(tmp); } written++; } } /* * Turn off the emphasis if we haven't already, and * then we're done. -FM */ if (TargetEmphasisON) { LYstopTargetEmphasis(); } } else { Data = cp; Offset = (offset + HitOffset); data = buffer; offset = hoffset; goto highlight_hit_within_hightext; } } } } } highlight_search_done: FREE(theData); return TargetEmphasisON; } #endif /* SHOW_WHEREIS_TARGETS */ #ifdef USE_COLOR_STYLE static int find_cached_style(int cur, int flag) { int s = s_alink; #ifdef TEXTFIELDS_MAY_NEED_ACTIVATION if (textfields_need_activation && links[cur].type == WWW_FORM_LINK_TYPE && F_TEXTLIKE(links[cur].l_form->type)) s = s_curedit; #endif if (flag != ON) { int x; /* * This is where we try to restore the original style when a link is * unhighlighted. The purpose of cached_styles[][] is to save the * original style just for this case. If it doesn't have a color * change saved at just the right position, we look at preceding * positions in the same line until we find one. */ if (CACHE_VALIDATE_YX(LYP, LXP)) { CTRACE2(TRACE_STYLE, (tfp, "STYLE.highlight.off: cached style @(%d,%d): ", LYP, LXP)); s = cached_styles[LYP][LXP]; if (s == 0) { for (x = LXP - 1; x >= 0; x--) { if (cached_styles[LYP][x]) { if (cached_styles[LYP][x] > 0) { s = cached_styles[LYP][x]; cached_styles[LYP][LXP] = s; } CTRACE((tfp, "found %u, x_offset=%d.\n", cached_styles[LYP][x], (int) x - LXP)); break; } } if (s == 0) { CTRACE((tfp, "not found, assume .\n")); s = s_a; } } else { CTRACE((tfp, "found %d.\n", s)); } } else { CTRACE2(TRACE_STYLE, (tfp, "STYLE.highlight.off: can't use cache.\n")); s = s_a; } } else { CTRACE2(TRACE_STYLE, (tfp, "STYLE.highlight.on: @(%d,%d).\n", LYP, LXP)); } return s; } #endif /* USE_COLOR_STYLE */ /* * Highlight (or unhighlight) a given link. */ void LYhighlight(int flag, int cur, const char *target) { char buffer[MAX_LINE]; int i; int hi_count; int hi_offset; int title_adjust = (no_title ? -TITLE_LINES : 0); char tmp[7]; const char *hi_string; #ifdef SHOW_WHEREIS_TARGETS BOOL TargetEmphasisON = FALSE; BOOL target1_drawn = NO; #endif BOOL utf_flag = (BOOL) (LYCharSet_UC[current_char_set].enc == UCT_ENC_UTF8); BOOL hl1_drawn = NO; #ifdef USE_COLOR_STYLE BOOL hl2_drawn = FALSE; /* whether links[cur].l_hightext2 is already drawn properly */ #endif tmp[0] = tmp[1] = tmp[2] = '\0'; /* * Bugs in the history code might cause -1 to be sent for cur, which yields * a crash when LYstrncpy() is called with a nonsense pointer. As far as I * know, such bugs have been squashed, but if they should reappear, this * works around them. -FM */ if (cur < 0) cur = 0; #if defined(TEXTFIELDS_MAY_NEED_ACTIVATION) && defined(INACTIVE_INPUT_STYLE_VH) if (flag == OFF) textinput_redrawn = FALSE; #endif if (nlinks > 0) { #ifdef USE_COLOR_STYLE if (flag == ON || links[cur].type == WWW_FORM_LINK_TYPE) { LYmove(LYP + title_adjust, LXP); LynxChangeStyle(find_cached_style(cur, flag), STACK_ON); } #else if (links[cur].type == WWW_FORM_LINK_TYPE || LYGetHiliteStr(cur, 0) == NULL) { LYMoveToLink(cur, target, NULL, flag, links[cur].inUnderline, utf_flag); lynx_start_link_color(flag == ON, links[cur].inUnderline); } else { LYMoveToLink(cur, target, LYGetHiliteStr(cur, 0), flag, links[cur].inUnderline, utf_flag); hl1_drawn = YES; #ifdef SHOW_WHEREIS_TARGETS target1_drawn = YES; #endif } #endif if (links[cur].type == WWW_FORM_LINK_TYPE) { int len; int avail_space = (LYcolLimit - LXP) + (LYcolLimit * (LYlines - LYP)); const char *text = LYGetHiliteStr(cur, 0); if (avail_space > links[cur].l_form->size) avail_space = links[cur].l_form->size; if (avail_space > (int) sizeof(buffer) - 1) avail_space = (int) sizeof(buffer) - 1; LYstrncpy(buffer, NonNull(text), avail_space); len = strlen(buffer); while (len < avail_space) { buffer[len++] = '_'; } buffer[len] = 0; LYaddstr(buffer); #ifdef USE_COLOR_STYLE } else if (flag == OFF) { hl2_drawn = TRUE; redraw_lines_of_link(cur); CTRACE2(TRACE_STYLE, (tfp, "STYLE.highlight.off: NOFIX branch @(%d,%d).\n", LYP, LXP)); #endif } else if (!hl1_drawn) { /* * Copy into the buffer only what will fit within the width of the * screen. */ LYmbcsstrncpy(buffer, NonNull(LYGetHiliteStr(cur, 0)), (sizeof(buffer) - 1), (LYcolLimit - LXP), utf_flag); LYaddstr(buffer); } /* * Display a second line as well. */ #ifdef USE_COLOR_STYLE if (hl2_drawn == FALSE) #endif { for (hi_count = 1; (hi_string = LYGetHiliteStr(cur, hi_count)) != NULL && LYP + hi_count <= display_lines; ++hi_count) { int row = LYP + hi_count + title_adjust; hi_offset = LYGetHilitePos(cur, hi_count); lynx_stop_link_color(flag == ON, links[cur].inUnderline); LYmove(row, hi_offset); #ifdef USE_COLOR_STYLE CTRACE2(TRACE_STYLE, (tfp, "STYLE.highlight.line2: @(%d,%d), style=%d.\n", row, hi_offset, flag == ON ? s_alink : s_a)); LynxChangeStyle(flag == ON ? s_alink : s_a, ABS_ON); #else lynx_start_link_color(flag == ON, links[cur].inUnderline); #endif for (i = 0; (tmp[0] = hi_string[i]) != '\0' && (i + hi_offset) < LYcols; i++) { if (!IsSpecialAttrChar(hi_string[i])) { /* * For CJK strings, by Masanobu Kimura. */ if (HTCJK != NOCJK && is8bits(tmp[0])) { tmp[1] = hi_string[++i]; LYaddstr(tmp); tmp[1] = '\0'; } else { LYaddstr(tmp); } } } } lynx_stop_link_color(flag == ON, links[cur].inUnderline); } #ifdef SHOW_WHEREIS_TARGETS for (hi_count = target1_drawn ? 1 : 0; LYGetHiliteStr(cur, hi_count) != NULL; hi_count++) { TargetEmphasisON = show_whereis_targets(flag, cur, hi_count, target, TargetEmphasisON, utf_flag); } if (!LYShowCursor) /* * Get cursor out of the way. */ LYHideCursor(); else #endif /* SHOW_WHEREIS_TARGETS */ /* * Never hide the cursor if there's no FANCY CURSES or SLANG. */ LYmove(LYP + title_adjust, ((LXP > 0) ? (LXP - 1) : 0)); if (flag) LYrefresh(); } return; } /* * free_and_clear will free a pointer if it is non-zero and then set it to * zero. */ void free_and_clear(char **pointer) { if (*pointer) { FREE(*pointer); *pointer = 0; } return; } /* * Convert single or serial newlines to single spaces throughout a string * (ignore newlines if the preceding character is a space) and convert tabs to * single spaces. Don't ignore any explicit tabs or spaces if the condense * argument is FALSE, otherwise, condense any serial spaces or tabs to one * space. - FM */ void convert_to_spaces(char *string, BOOL condense) { char *s = string; char *ns; BOOL last_is_space = FALSE; if (!s) return; for (; (*s && !isspace(*s)); s++) ; ns = s; while (*s) { switch (*s) { case ' ': case '\t': if (!(condense && last_is_space)) *(ns++) = ' '; last_is_space = TRUE; break; case '\r': case '\n': if (!last_is_space) { *(ns++) = ' '; last_is_space = TRUE; } break; default: *(ns++) = *s; last_is_space = FALSE; break; } s++; } *ns = '\0'; return; } /* * Strip trailing slashes from directory paths. */ char *strip_trailing_slash(char *dirname) { int i; i = strlen(dirname) - 1; while (i >= 0 && dirname[i] == '/') dirname[i--] = '\0'; return (dirname); } /* * Remove most blanks, but restore one trailing blank to make prompts nicer. */ static void remove_most_blanks(char *buffer) { int length = strlen(buffer); BOOL trailing = (length != 0) && (buffer[length - 1] == ' '); LYReduceBlanks(buffer); if (trailing) strcat(buffer, " "); } /* * Display (or hide) the status line. */ BOOLEAN mustshow = FALSE; void statusline(const char *text) { char buffer[MAX_LINE]; unsigned char *temp = NULL; int max_length, len, i, j; unsigned char k; char *p; char text_buff[MAX_LINE]; if (text == NULL) return; /* * Don't print statusline messages if dumping to stdout. */ if (dump_output_immediately) return; /* * Don't print statusline message if turned off. */ if (mustshow != TRUE) { if (no_statusline == TRUE) { return; } } mustshow = FALSE; /* "LYNXDOWNLOAD://Method=-1/File=%s/SugFile=%s%s\">Save to disk\n" */ LYstrncpy(text_buff, text, sizeof(text_buff) - 1); p = strchr(text_buff, '\n'); if (p) p = '\0'; /* * Deal with any CJK escape sequences and Kanji if we have a CJK character * set selected, otherwise, strip any escapes. Also, make sure text is not * longer than the statusline window. - FM */ max_length = (((LYcolLimit - 1) < (int) sizeof(buffer)) ? (LYcolLimit - 1) : (int) sizeof(buffer) - 1); if ((text_buff[0] != '\0') && (LYHaveCJKCharacterSet)) { /* * Translate or filter any escape sequences. - FM */ if ((temp = typecallocn(unsigned char, strlen(text_buff) + 1)) == NULL) outofmem(__FILE__, "statusline"); if (kanji_code == EUC) { TO_EUC((const unsigned char *) text_buff, temp); } else if (kanji_code == SJIS) { #ifdef KANJI_CODE_OVERRIDE if (!LYRawMode || last_kcode == SJIS) strcpy(temp, text_buff); else TO_SJIS((const unsigned char *) text_buff, temp); #else strcpy((char *) temp, text_buff); #endif } else { for (i = 0, j = 0; text_buff[i]; i++) { if (text_buff[i] != CH_ESC) { /* S/390 -- gil -- 2119 */ temp[j++] = text_buff[i]; } } temp[j] = '\0'; } /* * Deal with any newlines or tabs in the string. - FM */ remove_most_blanks((char *) temp); /* * Handle the Kanji, making sure the text is not longer than the * statusline window. - FM */ for (i = 0, j = 0, len = 0, k = '\0'; temp[i] != '\0' && len < max_length; i++) { if (k != '\0') { buffer[j++] = k; buffer[j++] = temp[i]; k = '\0'; len += 2; } else if ((temp[i] & 0200) != 0) { k = temp[i]; } else { buffer[j++] = temp[i]; len++; } } buffer[j] = '\0'; FREE(temp); } else { /* * Deal with any newlines or tabs in the string. - FM */ remove_most_blanks(text_buff); #ifdef WIDEC_CURSES len = strlen(text_buff); if (len >= (int) (sizeof(buffer) - 1)) len = (int) (sizeof(buffer) - 1); strncpy(buffer, text_buff, len)[len] = '\0'; /* FIXME: a binary search might be faster */ while (len > 0 && LYstrExtent(buffer, len, len) > max_length) buffer[--len] = '\0'; #else /* * Strip any escapes, and shorten text if necessary. Note that we * don't deal with the possibility of UTF-8 characters in the string. * This is unlikely, but if strings with such characters are used in * LYMessages_en.h, a compilation symbol of HAVE_UTF8_STATUSLINES could * be added there, and code added here for determining the displayed * string length, as we do above for CJK. - FM */ for (i = 0, len = 0; text_buff[i] != '\0' && len < max_length; i++) { if (text_buff[i] != CH_ESC) { /* S/390 -- gil -- 2119 */ buffer[len++] = text_buff[i]; } } buffer[len] = '\0'; #endif } /* * Move to the desired statusline window and output the text highlighted. * - FM */ if (LYStatusLine >= 0) { if (LYStatusLine < LYlines - 1) { LYmove(LYStatusLine, 0); } else { LYmove(LYlines - 1, 0); } } else if (user_mode == NOVICE_MODE) { LYmove(LYlines - 3, 0); } else { LYmove(LYlines - 1, 0); } LYclrtoeol(); if (non_empty(buffer)) { BOOLEAN has_CJK = FALSE; if (HTCJK != NOCJK) { for (i = 0; buffer[i] != '\0'; i++) { if (buffer[i] & 0x80) { has_CJK = TRUE; break; } } } if (has_CJK #ifdef HAVE_UTF8_STATUSLINES || (LYCharSet_UC[current_char_set].enc == UCT_ENC_UTF8) #endif ) { LYrefresh(); } #ifndef USE_COLOR_STYLE lynx_start_status_color(); LYaddstr(buffer); lynx_stop_status_color(); #else /* draw the status bar in the STATUS style */ { int a = ((strncmp(buffer, ALERT_FORMAT, ALERT_PREFIX_LEN) || !hashStyles[s_alert].name) ? s_status : s_alert); LynxChangeStyle(a, STACK_ON); LYaddstr(buffer); wbkgdset(LYwin, ((lynx_has_color && LYShowColor >= SHOW_COLOR_ON) ? hashStyles[a].color : A_NORMAL) | ' '); LYclrtoeol(); if (!(lynx_has_color && LYShowColor >= SHOW_COLOR_ON)) wbkgdset(LYwin, A_NORMAL | ' '); else if (s_normal != NOSTYLE) wbkgdset(LYwin, hashStyles[s_normal].color | ' '); else wbkgdset(LYwin, displayStyles[DSTYLE_NORMAL].color | ' '); LynxChangeStyle(a, STACK_OFF); } #endif } LYrefresh(); return; } static const char *novice_lines(int lineno) { switch (lineno) { case 0: return NOVICE_LINE_TWO_A; case 1: return NOVICE_LINE_TWO_B; case 2: return NOVICE_LINE_TWO_C; default: return ""; } } static int lineno = 0; void toggle_novice_line(void) { lineno++; if (*novice_lines(lineno) == '\0') lineno = 0; return; } void noviceline(int more_flag GCC_UNUSED) { if (dump_output_immediately) return; LYmove(LYlines - 2, 0); /* lynx_stop_reverse(); */ LYclrtoeol(); LYaddstr(NOVICE_LINE_ONE); LYclrtoeol(); #if defined(DIRED_SUPPORT ) && defined(OK_OVERRIDE) if (lynx_edit_mode && !no_dired_support) LYaddstr(DIRED_NOVICELINE); else #endif /* DIRED_SUPPORT && OK_OVERRIDE */ if (LYUseNoviceLineTwo) LYaddstr(NOVICE_LINE_TWO); else LYaddstr(novice_lines(lineno)); LYrefresh(); return; } #if defined(MISC_EXP) || defined(TTY_DEVICE) || defined(HAVE_TTYNAME) /* * If the standard input is not a tty, and Lynx is really reading from the * standard input, attempt to reopen it, pointing to a real tty. Normally * this would happen if the user pipes data to Lynx and wants to run * interactively after that. * * Returns: * 1 if successfully reopened * -1 if we cannot reopen * 0 if we do not have to reopen */ int LYReopenInput(void) { int result = 0; int fd; if ((fd = fileno(stdin)) == 0 && !isatty(fd) && LYConsoleInputFD(FALSE) == fd) { char *term_name = NULL; int new_fd = -1; #ifdef HAVE_TTYNAME if (isatty(fileno(stdout)) && (term_name = ttyname(fileno(stdout))) != NULL) new_fd = open(term_name, O_RDONLY); if (new_fd == -1 && isatty(fileno(stderr)) && (term_name = ttyname(fileno(stderr))) != NULL) new_fd = open(term_name, O_RDONLY); #endif #ifdef HAVE_CTERMID if (new_fd == -1 && (term_name = ctermid(NULL)) != NULL) new_fd = open(term_name, O_RDONLY); #endif #ifdef TTY_DEVICE if (new_fd == -1) new_fd = open(term_name = TTY_DEVICE, O_RDONLY); #endif CTRACE((tfp, "LYReopenInput open(%s) returned %d.\n", term_name, new_fd)); if (new_fd >= 0) { FILE *frp; close(new_fd); frp = freopen(term_name, "r", stdin); CTRACE((tfp, "LYReopenInput freopen(%s,\"r\",stdin) returned %p, stdin is now %p with fd %d.\n", term_name, frp, stdin, fileno(stdin))); result = 1; } else { result = -1; } } return result; } #endif #if defined(NSL_FORK) || defined(MISC_EXP) || defined (TTY_DEVICE) || defined(HAVE_TTYNAME) /* * Returns the file descriptor from which keyboard input is expected, or INVSOC * (-1) if not available. If need_selectable is true, returns non-INVSOC fd * only if select() is possible - actually, currently only checks if fd is * connected to a tty. - kw */ int LYConsoleInputFD(BOOLEAN need_selectable) { int fd = INVSOC; #ifdef USE_SLANG if (!LYCursesON) fd = fileno(stdin); #if ((SLANG_VERSION >= 9919) && defined(REAL_UNIX_SYSTEM) && !defined(__CYGWIN__)) /* SLang_TT_Read_FD introduced in slang 0.99.19, from its changelog: * SLang_TT_Read_FD variable is now available for unix. This is the file * descriptor used by SLang_getkey. */ else fd = SLang_TT_Read_FD; #endif /* SLANG_VERSION >= 9919 */ #else /* !USE_SLANG */ fd = fileno(stdin); #endif /* !USE_SLANG */ if (need_selectable && fd != INVSOC) { if (isatty(fd)) { return fd; } else { return INVSOC; } } return fd; } #endif /* NSL_FORK || MISC_EXP */ static int fake_zap = 0; void LYFakeZap(BOOL set) { if (set && fake_zap < 1) { CTRACE((tfp, "\r *** Set simulated 'Z'")); if (fake_zap) CTRACE((tfp, ", %d pending", fake_zap)); CTRACE((tfp, " ***\n")); fake_zap++; } else if (!set && fake_zap) { CTRACE((tfp, "\r *** Unset simulated 'Z'")); CTRACE((tfp, ", %d pending", fake_zap)); CTRACE((tfp, " ***\n")); fake_zap = 0; } } static int DontCheck(void) { static long last; long next; /** Curses or slang setup was not invoked **/ if (dump_output_immediately) return (TRUE); if (LYHaveCmdScript()) /* we may be running from a script */ return (TRUE); #ifdef MISC_EXP if (LYNoZapKey) return (TRUE); #endif /* * Avoid checking interrupts more than one per second, since it is a slow * and expensive operation - TD */ #ifdef HAVE_GETTIMEOFDAY #undef timezone /* U/Win defines a conflicting macro */ { struct timeval tv; gettimeofday(&tv, (struct timezone *) 0); next = tv.tv_usec / 100000L; /* 0.1 seconds is a compromise */ } #else next = time((time_t *) 0); #endif if (next == last) return (TRUE); last = next; return FALSE; } int HTCheckForInterrupt(void) { int c; int cmd; #ifndef VMS /* UNIX stuff: */ #if !defined(USE_SLANG) struct timeval socket_timeout; int ret = 0; fd_set readfds; #endif /* !USE_SLANG */ if (fake_zap > 0) { fake_zap--; CTRACE((tfp, "\r *** Got simulated 'Z' ***\n")); CTRACE_FLUSH(tfp); CTRACE_SLEEP(AlertSecs); return ((int) TRUE); } /** Curses or slang setup was not invoked **/ if (DontCheck()) return ((int) FALSE); #if !defined(_WINDOWS) || defined(__MINGW32__) #ifdef USE_SLANG /** No keystroke was entered Note that this isn't taking possible SOCKSification and the socks_flag into account, and may fail on the slang library's select() when SOCKSified. - FM **/ #ifdef DJGPP_KEYHANDLER if (0 == _bios_keybrd(_NKEYBRD_READY)) #else if (0 == SLang_input_pending(0)) #endif /* DJGPP_KEYHANDLER */ return (FALSE); #else /* Unix curses: */ socket_timeout.tv_sec = 0; socket_timeout.tv_usec = 0; FD_ZERO(&readfds); FD_SET(0, &readfds); #ifdef SOCKS if (socks_flag) ret = Rselect(1, &readfds, NULL, NULL, &socket_timeout); else #endif /* SOCKS */ ret = select(1, &readfds, NULL, NULL, &socket_timeout); /** Suspended? **/ if ((ret == -1) && (SOCKET_ERRNO == EINTR)) return ((int) FALSE); /** No keystroke was entered? **/ if (!FD_ISSET(0, &readfds)) return ((int) FALSE); #endif /* USE_SLANG */ #endif /* !_WINDOWS */ #if defined(PDCURSES) nodelay(LYwin, TRUE); #endif /* PDCURSES */ /* * 'c' contains whatever character we're able to read from keyboard */ c = LYgetch(); #if defined(PDCURSES) nodelay(LYwin, FALSE); #endif /* PDCURSES */ #else /* VMS: */ extern int typeahead(void); if (fake_zap > 0) { fake_zap--; CTRACE((tfp, "\r *** Got simulated 'Z' ***\n")); CTRACE_FLUSH(tfp); CTRACE_SLEEP(AlertSecs); return ((int) TRUE); } /** Curses or slang setup was not invoked **/ if (DontCheck()) return ((int) FALSE); /** Control-C or Control-Y and a 'N'o reply to exit query **/ if (HadVMSInterrupt) { HadVMSInterrupt = FALSE; return ((int) TRUE); } /* * 'c' contains whatever character we're able to read from keyboard */ c = typeahead(); #endif /* !VMS */ /* * 'c' contains whatever character we're able to read from keyboard */ /** Keyboard 'Z' or 'z', or Control-G or Control-C **/ if (LYCharIsINTERRUPT(c)) return ((int) TRUE); /* There is a subset of mainloop() actions available at this stage: no new * getfile() cycle is possible until the previous finished. Currently we * have scrolling in partial mode, toggling of trace log, and pasting. * User search now in progress... */ cmd = (LKC_TO_LAC(keymap, c)); switch (cmd) { case LYK_TRACE_TOGGLE: /* Toggle TRACE mode. */ handle_LYK_TRACE_TOGGLE(); break; #ifdef CAN_CUT_AND_PASTE case LYK_TO_CLIPBOARD:{ /* ^S */ const char *s = LYDownLoadAddress(); if (!s || !*s || put_clip(s)) HTInfoMsg(gettext("Copy to clipboard failed.")); else HTInfoMsg(gettext("Download document URL put to clipboard.")); break; } #endif /* defined CAN_CUT_AND_PASTE */ default: #ifdef DISP_PARTIAL /* OK, we got several lines from new document and want to scroll... */ if (display_partial && (NumOfLines_partial > 2)) { BOOLEAN do_refresh; int res; int Newline_partial = LYGetNewline(); switch (cmd) { case LYK_WHEREIS: /* search within the document */ case LYK_NEXT: /* search for the next occurrence in the document */ case LYK_PREV: /* search for the previous occurrence in the document */ handle_LYK_WHEREIS(cmd, &do_refresh); if (www_search_result != -1) { Newline_partial = www_search_result; www_search_result = -1; /* reset */ } break; case LYK_FASTBACKW_LINK: if (Newline_partial <= (display_lines) + 1) { Newline_partial -= display_lines; } else if ((res = HTGetLinkOrFieldStart(-1, &Newline_partial, NULL, -1, TRUE)) == LINK_LINE_FOUND) { Newline_partial++; } else if (res == LINK_DO_ARROWUP) { Newline_partial -= display_lines; } break; case LYK_FASTFORW_LINK: if (HText_canScrollDown()) { /* This is not an exact science... - kw */ if ((res = HTGetLinkOrFieldStart(HText_LinksInLines(HTMainText, Newline_partial, display_lines) - 1, &Newline_partial, NULL, 1, TRUE)) == LINK_LINE_FOUND) { Newline_partial++; } } break; case LYK_PREV_PAGE: if (Newline_partial > 1) Newline_partial -= display_lines; break; case LYK_NEXT_PAGE: if (HText_canScrollDown()) Newline_partial += display_lines; break; case LYK_UP_HALF: if (Newline_partial > 1) Newline_partial -= (display_lines / 2); break; case LYK_DOWN_HALF: if (HText_canScrollDown()) Newline_partial += (display_lines / 2); break; case LYK_UP_TWO: if (Newline_partial > 1) Newline_partial -= 2; break; case LYK_DOWN_TWO: if (HText_canScrollDown()) Newline_partial += 2; break; case LYK_HOME: if (Newline_partial > 1) Newline_partial = 1; break; case LYK_END: if (HText_canScrollDown()) Newline_partial = HText_getNumOfLines() - display_lines + 1; /* calculate for "current" bottom value */ break; case LYK_REFRESH: break; default: /** Other or no keystrokes **/ return ((int) FALSE); } /* end switch */ if (Newline_partial < 1) Newline_partial = 1; if (LYMainLoop_pageDisplay(Newline_partial)) NumOfLines_partial = HText_getNumOfLines(); } #endif /* DISP_PARTIAL */ break; } /* end switch */ /** Other or no keystrokes **/ return ((int) FALSE); } /* * Check if the given filename looks like it's an absolute pathname, i.e., * references a directory. */ BOOLEAN LYisAbsPath(const char *path) { BOOLEAN result = FALSE; if (non_empty(path)) { #ifdef VMS result = TRUE; #else #if defined(USE_DOS_DRIVES) result = (BOOL) (LYIsPathSep(path[0]) || (LYIsDosDrive(path) && LYIsPathSep(path[2]))); #else result = (LYIsPathSep(path[0])); #endif /* USE_DOS_DRIVES */ #endif } return result; } /* * Check if the given filename is the root path, e.g., "/" on Unix. */ BOOLEAN LYisRootPath(const char *path) { #if defined(USE_DOS_DRIVES) if (strlen(path) == 3 && LYIsDosDrive(path) && LYIsPathSep(path[2])) return TRUE; #endif return (BOOL) ((strlen(path) == 1) && LYIsPathSep(path[0])); } /* * A file URL for a remote host is an obsolete ftp URL. * Return YES only if we're certain it's a local file. - FM */ BOOLEAN LYisLocalFile(const char *filename) { char *host = NULL; char *acc_method = NULL; char *cp; if (!filename) return NO; if (!(host = HTParse(filename, "", PARSE_HOST))) return NO; if (!*host) { FREE(host); return NO; } if ((cp = strchr(host, ':')) != NULL) *cp = '\0'; if ((acc_method = HTParse(filename, "", PARSE_ACCESS))) { if (0 == strcmp("file", acc_method) && (0 == strcmp(host, "localhost") || LYSameFilename(host, HTHostName()))) { FREE(host); FREE(acc_method); return YES; } } FREE(host); FREE(acc_method); return NO; } /* * Utility for checking URLs with a host field. Return YES only if we're * certain it's the local host. - FM */ BOOLEAN LYisLocalHost(const char *filename) { char *host = NULL; char *cp; if (!filename) return NO; if (!(host = HTParse(filename, "", PARSE_HOST))) return NO; if (!*host) { FREE(host); return NO; } if ((cp = strchr(host, ':')) != NULL) *cp = '\0'; if ((LYSameFilename(host, "localhost") || LYSameFilename(host, LYHostName) || LYSameFilename(host, HTHostName()))) { FREE(host); return YES; } FREE(host); return NO; } /* * Free an HTList that contains strings. */ void LYFreeStringList(HTList *list) { if (list != NULL) { char *argument; HTList *cur = list; while (NULL != (argument = (char *) HTList_nextObject(cur))) { FREE(argument); } HTList_delete(list); } } /* * Utility for freeing the list of local host aliases. - FM */ void LYLocalhostAliases_free(void) { LYFreeStringList(localhost_aliases); localhost_aliases = NULL; } /* * Utility for listing hosts to be treated as local aliases. - FM */ void LYAddLocalhostAlias(char *alias) { char *LocalAlias = NULL; if (!non_empty(alias)) return; if (!localhost_aliases) { localhost_aliases = HTList_new(); #ifdef LY_FIND_LEAKS atexit(LYLocalhostAliases_free); #endif } StrAllocCopy(LocalAlias, alias); HTList_addObject(localhost_aliases, LocalAlias); return; } /* * Utility for checking URLs with a host field. Return YES only if we've * listed the host as a local alias. - FM */ BOOLEAN LYisLocalAlias(const char *filename) { char *host = NULL; char *alias; char *cp; HTList *cur = localhost_aliases; if (!cur || !filename) return NO; if (!(host = HTParse(filename, "", PARSE_HOST))) return NO; if (!(*host)) { FREE(host); return NO; } if ((cp = strchr(host, ':')) != NULL) *cp = '\0'; while (NULL != (alias = (char *) HTList_nextObject(cur))) { if (LYSameFilename(host, alias)) { FREE(host); return YES; } } FREE(host); return NO; } /* * This function checks for a URL with an unknown scheme, * but for which proxying has been set up, and if so, * returns PROXY_URL_TYPE. - FM * * If a colon is present but the string segment which * precedes it is not being proxied, and we can be sure * that what follows the colon is not a port field, * it returns UNKNOWN_URL_TYPE. Otherwise, it returns * 0 (not a URL). - FM */ UrlTypes LYCheckForProxyURL(char *filename) { char *cp = filename; char *cp1; char *cp2 = NULL; /* * Don't crash on an empty argument. */ if (isEmpty(cp)) return (NOT_A_URL_TYPE); /* kill beginning spaces */ cp = LYSkipBlanks(cp); /* * Check for a colon, and if present, * see if we have proxying set up. */ if ((cp1 = strchr((cp + 1), ':')) != NULL) { if ((cp2 = strchr((cp + 1), '/')) != NULL && cp2 < cp1) return (NOT_A_URL_TYPE); *cp1 = '\0'; cp2 = NULL; StrAllocCopy(cp2, cp); *cp1 = ':'; StrAllocCat(cp2, "_proxy"); if (LYGetEnv(cp2) != NULL) { FREE(cp2); return (PROXY_URL_TYPE); } FREE(cp2); #if defined (USE_DOS_DRIVES) if (LYIsDosDrive(cp)) return (NOT_A_URL_TYPE); #endif cp1++; if (!*cp) { return (NOT_A_URL_TYPE); } else if (isdigit(UCH(*cp1))) { while (*cp1 && isdigit(UCH(*cp1))) cp1++; if (*cp1 && !LYIsHtmlSep(*cp1)) return (UNKNOWN_URL_TYPE); } else { return (UNKNOWN_URL_TYPE); } } return (NOT_A_URL_TYPE); } /* * Compare a "type:" string, replacing it by the comparison-string if it * matches (and return true in that case). */ static BOOLEAN compare_type(char *tst, const char *cmp, size_t len) { if (!strncasecomp(tst, cmp, len)) { if (strncmp(tst, cmp, len)) { size_t i; for (i = 0; i < len; i++) tst[i] = cmp[i]; } return TRUE; } return FALSE; } #define DoubleHtmlSep(s) (LYIsHtmlSep((s)[0]) && LYIsHtmlSep((s)[1])) #define compare_two(tst,cmp,len,limit) \ ((len + 2) <= limit \ && DoubleHtmlSep(tst + len) \ && compare_type(tst, cmp, len)) /* * Must recognize a URL and return the type. * If recognized, based on a case-insensitive * analysis of the scheme field, ensures that * the scheme field has the expected case. * * Returns 0 (not a URL) for a NULL argument, * one which lacks a colon. * * Chains to LYCheckForProxyURL() if a colon * is present but the type is not recognized. */ UrlTypes is_url(char *filename) { char *cp = filename; char *cp1; UrlTypes result = NOT_A_URL_TYPE; int len; int limit; /* * Don't crash on an empty argument. */ if (isEmpty(cp)) return (result); /* * Can't be a URL if it lacks a colon. */ if (NULL == strchr(cp, ':')) return (result); /* * Kill beginning spaces. */ cp = LYSkipBlanks(cp); /* * Can't be a URL if it starts with a slash. So return immediately for * this common case, also to avoid false positives if there was a colon * later in the string. Also can't be a URL if it starts with a colon. - * KW */ if (*cp == ':' || LYIsHtmlSep(*cp)) { result = NOT_A_URL_TYPE; } else { limit = strlen(cp); switch (*cp) { case 'L': case 'l': /* * Lynx internal pages ("LYNXfoo:" or "lynxfoo:") start with 'l' or * 'L', other URLs aren't. */ if (compare_type(cp, STR_LYNXEXEC, LEN_LYNXEXEC)) { /* * Special External Lynx type to handle execution of commands * or scripts which require a pause to read the screen upon * completion. */ result = LYNXEXEC_URL_TYPE; } else if (compare_type(cp, STR_LYNXPROG, LEN_LYNXPROG)) { /* * Special External Lynx type to handle execution of commands, * scripts or programs with do not require a pause to read * screen upon completion. */ result = LYNXPROG_URL_TYPE; } else if (compare_type(cp, STR_LYNXCGI, LEN_LYNXCGI)) { /* * Special External Lynx type to handle cgi scripts. */ result = LYNXCGI_URL_TYPE; } else if (compare_type(cp, STR_LYNXPRINT, LEN_LYNXPRINT)) { /* * Special Internal Lynx type. */ result = LYNXPRINT_URL_TYPE; } else if (compare_type(cp, STR_LYNXOPTIONS, LEN_LYNXOPTIONS)) { /* * Special Internal Lynx type. */ result = LYNXOPTIONS_URL_TYPE; } else if (compare_type(cp, STR_LYNXCFG, LEN_LYNXCFG)) { /* * Special Internal Lynx type. */ result = LYNXCFG_URL_TYPE; } else if (compare_type(cp, STR_LYNXMESSAGES, LEN_LYNXMESSAGES)) { /* * Special Internal Lynx type. */ result = LYNXMESSAGES_URL_TYPE; } else if (compare_type(cp, STR_LYNXCFLAGS, LEN_LYNXCFLAGS)) { /* * Special Internal Lynx type. */ result = LYNXCOMPILE_OPTS_URL_TYPE; } else if (compare_type(cp, STR_LYNXDOWNLOAD, LEN_LYNXDOWNLOAD)) { /* * Special Internal Lynx type. */ result = LYNXDOWNLOAD_URL_TYPE; } else if (compare_type(cp, STR_LYNXDIRED, LEN_LYNXDIRED)) { /* * Special Internal Lynx type. */ result = LYNXDIRED_URL_TYPE; } else if (compare_type(cp, STR_LYNXHIST, LEN_LYNXHIST)) { /* * Special Internal Lynx type. */ result = LYNXHIST_URL_TYPE; } else if (compare_type(cp, STR_LYNXKEYMAP, LEN_LYNXKEYMAP)) { /* * Special Internal Lynx type. */ result = LYNXKEYMAP_URL_TYPE; } else if (compare_type(cp, STR_LYNXIMGMAP, LEN_LYNXIMGMAP)) { /* * Special Internal Lynx type. */ /* force lower/uppercase of next part */ (void) is_url(&cp[LEN_LYNXIMGMAP]); result = LYNXIMGMAP_URL_TYPE; } else if (compare_type(cp, STR_LYNXCOOKIE, LEN_LYNXCOOKIE)) { /* * Special Internal Lynx type. */ result = LYNXCOOKIE_URL_TYPE; } break; #ifndef DISABLE_NEWS /* * NEWSfoo: schemes - */ case 'N': case 'n': if (compare_type(cp, STR_NEWS_URL, LEN_NEWS_URL)) { result = NEWS_URL_TYPE; } else if (compare_type(cp, STR_NNTP_URL, LEN_NNTP_URL)) { result = NNTP_URL_TYPE; } else if (compare_type(cp, "newspost:", 9)) { /* * Special Lynx type to handle news posts. */ result = NEWSPOST_URL_TYPE; } else if (compare_type(cp, "newsreply:", 10)) { /* * Special Lynx type to handle news replies (followups). */ result = NEWSREPLY_URL_TYPE; } break; /* * SNEWSfoo: schemes - */ case 'S': case 's': if (compare_type(cp, STR_SNEWS_URL, LEN_SNEWS_URL)) { result = SNEWS_URL_TYPE; } else if (compare_type(cp, "snewspost:", 10)) { /* * Special Lynx type to handle snews posts. */ result = NEWSPOST_URL_TYPE; } else if (compare_type(cp, "snewsreply:", 11)) { /* * Special Lynx type to handle snews replies (followups). */ result = NEWSREPLY_URL_TYPE; } break; #endif case 'M': case 'm': if (compare_type(cp, STR_MAILTO_URL, LEN_MAILTO_URL)) { result = MAILTO_URL_TYPE; } break; case 'F': case 'f': if (compare_type(cp, STR_FILE_URL, len = LEN_FILE_URL)) { if (LYisLocalFile(cp)) { result = FILE_URL_TYPE; } else if (DoubleHtmlSep(cp + len)) { result = FTP_URL_TYPE; } } #ifndef DISABLE_FTP else if (compare_two(cp, STR_FTP_URL, LEN_FTP_URL, limit)) { result = FTP_URL_TYPE; } #endif #ifndef DISABLE_FINGER else if (compare_two(cp, STR_FINGER_URL, LEN_FINGER_URL, limit)) { result = FINGER_URL_TYPE; } #endif break; case 'B': case 'b': #ifndef DISABLE_BIBP if (compare_type(cp, STR_BIBP_URL, LEN_BIBP_URL)) { result = BIBP_URL_TYPE; } #endif break; case 'D': case 'd': if (compare_type(cp, "data:", 5)) { result = DATA_URL_TYPE; } break; default: if (limit >= 3 && ((cp1 = strchr(cp + 3, ':')) == NULL || !DoubleHtmlSep(cp1 + 1))) { /* * If it doesn't contain "://", and it's not one of the the * above, it can't be a URL with a scheme we know, so check if * it's an unknown scheme for which proxying has been set up. * - FM */ if (cp1 != NULL && (cp1 - cp) > 1 /* exclude DOS-style device:/path */ && LYisAbsPath(cp1 + 1)) { result = NCFTP_URL_TYPE; } } else { switch (*cp) { case 'H': case 'h': if (compare_type(cp, STR_HTTP_URL, LEN_HTTP_URL)) { result = HTTP_URL_TYPE; } else if (compare_type(cp, STR_HTTPS_URL, LEN_HTTPS_URL)) { result = HTTPS_URL_TYPE; } break; #ifndef DISABLE_GOPHER case 'G': case 'g': if (compare_type(cp, STR_GOPHER_URL, LEN_GOPHER_URL)) { if (strlen(cp) >= 11 && (cp1 = strchr(cp + 11, '/')) != NULL) { if (TOUPPER(*(cp1 + 1)) == 'H' || *(cp1 + 1) == 'w') /* if this is a gopher html type */ result = HTML_GOPHER_URL_TYPE; else if (*(cp1 + 1) == 'T' || *(cp1 + 1) == '8') result = TELNET_GOPHER_URL_TYPE; else if (*(cp1 + 1) == '7') result = INDEX_GOPHER_URL_TYPE; else result = GOPHER_URL_TYPE; } else { result = GOPHER_URL_TYPE; } } break; #endif case 'W': case 'w': if (compare_type(cp, STR_WAIS_URL, LEN_WAIS_URL)) { result = WAIS_URL_TYPE; } break; case 'T': case 't': if (compare_type(cp, STR_TELNET_URL, LEN_TELNET_URL)) { result = TELNET_URL_TYPE; } else if (compare_type(cp, STR_TN3270_URL, LEN_TN3270_URL)) { result = TN3270_URL_TYPE; } break; case 'R': case 'r': if (compare_type(cp, STR_RLOGIN_URL, LEN_RLOGIN_URL)) { result = RLOGIN_URL_TYPE; } break; case 'C': case 'c': if (compare_type(cp, STR_CSO_URL, LEN_CSO_URL)) { result = CSO_URL_TYPE; } break; case 'A': case 'a': if (compare_type(cp, "afs:", 4)) { result = AFS_URL_TYPE; } break; case 'P': case 'p': if (compare_type(cp, "prospero:", 9)) { result = PROSPERO_URL_TYPE; } break; } } } /* * Check if it is an unknown scheme for which proxying has been set up. */ if (result == NOT_A_URL_TYPE) result = LYCheckForProxyURL(filename); } return result; } /* * Sometimes it is just expected that curses is on when an alert or other * statusline message needs to be shown and we are not just dumping * immediately. Calling this will 'fix' it, but may not always be appropriate. * - kw */ void LYFixCursesOn(const char *reason) { if (dump_output_immediately || LYCursesON) return; if (reason) { CTRACE((tfp, "Forcing curses on to %s\n", reason)); } start_curses(); } /* * Most protocol modules called through HTLoad* expect that curses is on unless * dump_output_immediately is set, so that statusline messages can be shown. * Some protocols expect the opposite, namely telnet and friends. This * function should be called after the 'physical' URL for accessing addr has * been established. It does the right thing to the degree that curses is * turned on for known problem cases. In any normal circumstances this should * never apply, but proxying or rule substitution is not prevented for * telnet-like URLs, and this 'fix' avoids some crashes that can otherwise * occur. - kw */ BOOLEAN LYFixCursesOnForAccess(const char *addr, const char *physical) { /* * If curses is off when maybe it shouldn't... */ if (!dump_output_immediately && !LYCursesON && physical) { char *cp1; /* * If requested resource wants to be accessed with curses off, and * getfile() would indeed have turned curses off for it... */ if (strstr(addr, "://") != NULL && (isTELNET_URL(addr) || isRLOGIN_URL(addr) || isTN3270_URL(addr) || (!isGOPHER_URL(addr) && (cp1 = strchr(addr + 11, '/')) != NULL && (*(cp1 + 1) == 'T' || *(cp1 + 1) == '8')))) { /* * If actual access that will be done is ok with curses off, then * do nothing special, else force curses on. - kw */ if (!isTELNET_URL(physical) && !isRLOGIN_URL(physical) && !isTN3270_URL(physical)) { start_curses(); HTAlert(gettext("Unexpected access protocol for this URL scheme.")); return TRUE; } } } return FALSE; } /* * Determine whether we allow HEAD and related flags for a URL. - kw */ BOOLEAN LYCanDoHEAD(const char *address) { char *temp0 = NULL; int isurl; if (!non_empty(address)) return FALSE; if (!strncmp(address, "http", 4)) return TRUE; /* Make copy for is_url() since caller may not care for case changes */ StrAllocCopy(temp0, address); isurl = is_url(temp0); if (!isurl) { FREE(temp0); return FALSE; } if (isurl == LYNXCGI_URL_TYPE) { FREE(temp0); #if defined(LYNXCGI_LINKS) && !defined(VMS) return TRUE; #else return FALSE; #endif } /* * The idea of the following is to allow HEAD for news URLs that identify * single articles, not those that identify ranges of articles or groups or * a list of groups. - kw */ if (isurl == NEWS_URL_TYPE || isurl == NNTP_URL_TYPE) { char *temp = HTParse(address, "", PARSE_PATH); char *cp = strrchr(temp, '/'); if (strchr((cp ? cp : temp), '@') != NULL) { FREE(temp0); FREE(temp); return TRUE; } if (cp && isdigit(UCH(cp[1])) && strchr(cp, '-') == NULL) { FREE(temp0); FREE(temp); return TRUE; } FREE(temp); } #define ALLOW_PROXY_HEAD /* If defined, also allow head requests for URLs proxied through the "http" or * "lynxcgi" protocols, which understand HEAD. Only the proxy environment * variables are checked, not the HTRules system. - kw */ #ifdef ALLOW_PROXY_HEAD if (isurl != FILE_URL_TYPE) { char *acc_method = HTParse(temp0, "", PARSE_ACCESS); if (non_empty(acc_method)) { char *proxy; StrAllocCat(acc_method, "_proxy"); proxy = LYGetEnv(acc_method); if (proxy && (isHTTP_URL(proxy) || isLYNXCGI(proxy)) && !override_proxy(temp0)) { FREE(temp0); FREE(acc_method); return TRUE; } } FREE(acc_method); } #endif /* ALLOW_PROXY_HEAD */ FREE(temp0); return FALSE; } /* * Close an input file. */ BOOLEAN LYCloseInput(FILE *fp) { if (fp != 0) { int err = ferror(fp); fclose(fp); if (!err) { return TRUE; } } return FALSE; } /* * Close an output file, reporting any problems with writing to it. */ BOOLEAN LYCloseOutput(FILE *fp) { if (fp != 0) { int err = ferror(fp); fclose(fp); if (!err) { return TRUE; } } HTAlert(CANNOT_WRITE_TO_FILE); return FALSE; } /* * Test if we'll be able to write a file. If not, warn the user. */ BOOLEAN LYCanWriteFile(const char *filename) { if (LYCloseOutput(fopen(filename, "w"))) { remove(filename); return TRUE; } else { _statusline(NEW_FILENAME_PROMPT); return FALSE; } } /* * Test if we'll be able to read a file. */ BOOLEAN LYCanReadFile(const char *filename) { FILE *fp; if ((fp = fopen(filename, "r")) != 0) { return LYCloseInput(fp); } return FALSE; } /* * Remove backslashes from any string. */ void remove_backslashes(char *buf) { char *cp; for (cp = buf; *cp != '\0'; cp++) { if (*cp != '\\') { /* don't print slashes */ *buf = *cp; buf++; } else if (*cp == '\\' && /* print one slash if there */ *(cp + 1) == '\\') { /* are two in a row */ *buf = *cp; buf++; } } *buf = '\0'; return; } /* * Checks to see if the current process is attached via a terminal in the local * domain. */ BOOLEAN inlocaldomain(void) { #ifdef HAVE_UTMP int n; FILE *fp; struct utmp me; char *cp, *mytty = NULL; if ((cp = ttyname(0))) mytty = strrchr(cp, '/'); if (mytty && (fp = fopen(UTMP_FILE, "r")) != NULL) { mytty++; do { n = fread((char *) &me, sizeof(struct utmp), 1, fp); } while (n > 0 && !STREQ(me.ut_line, mytty)); (void) LYCloseInput(fp); if (n > 0 && strlen(me.ut_host) > strlen(LYLocalDomain) && STREQ(LYLocalDomain, me.ut_host + strlen(me.ut_host) - strlen(LYLocalDomain))) return (TRUE); #ifdef LINUX /* Linux fix to check for local user. J.Cullen 11Jul94 */ if ((n > 0) && (strlen(me.ut_host) == 0)) return (TRUE); #endif /* LINUX */ } else { CTRACE((tfp, "Could not get ttyname (returned %s) or open UTMP file %s\n", NONNULL(cp), UTMP_FILE)); } return (FALSE); #else CTRACE((tfp, "LYUtils: inlocaldomain() not support.\n")); return (TRUE); #endif /* HAVE_UTMP */ } #ifdef HAVE_SIGACTION /* * An extended alternative for calling signal(), sets some flags for signal * handler as we want them if that functionality is available. (We don't * return anything from this function since the return value would currently be * ignored anyway.) - kw */ void LYExtSignal(int sig, LYSigHandlerFunc_t * handler) { #ifdef SIGWINCH /* add more cases to if(condition) if required... */ if (sig == SIGWINCH && LYNonRestartingSIGWINCH) { struct sigaction act; act.sa_handler = handler; sigemptyset(&act.sa_mask); act.sa_flags = 0; #ifdef SA_RESTART if (sig != SIGWINCH) act.sa_flags |= SA_RESTART; #endif /* SA_RESTART */ sigaction(sig, &act, NULL); } else #endif /* defined(SIGWINCH) */ signal(sig, handler); } #endif /* HAVE_SIGACTION */ #if defined(SIGTSTP) && !defined(USE_SLANG) #ifdef HAVE_SIGACTION /* * For switching a signal's handling between SIG_DFL and something (possibly) * different that may have been set up by lynx code or e.g. by curses library. * Uses sigaction to preserve / restore as much state as possible. * * Second arg is where to save or restore from. * * Third arg to_dfl specifies what to do: * 1 Save current state in where, set handling to SIG_DFL * 0 Restore current state to previously saved one in where * * Currently only used for SIGTSTP without SLANG, to prevent (n)curses signal * handler from running while lynx is waiting in system() for an interactive * command like an editor. - kw */ static BOOLEAN LYToggleSigDfl(int sig, struct sigaction *where, int to_dfl) { int rv = -1; struct sigaction oact; if (to_dfl == 1) { rv = sigaction(sig, NULL, &oact); if (rv == 0) { if (oact.sa_handler != SIG_DFL) { oact.sa_handler = SIG_DFL; rv = sigaction(sig, &oact, where); } else if (where) { memcpy(where, &oact, sizeof(oact)); rv = 0; } } } else { rv = sigaction(sig, where, NULL); } if (rv != 0) { CTRACE((tfp, "Error in LYToggleSigDfl: %s\n", LYStrerror(errno))); return FALSE; } else return TRUE; } #endif /* HAVE_SIGACTION */ #endif /* SIGTSTP && !USE_SLANG */ /************** * This bit of code catches window size change signals */ #ifdef HAVE_SYS_IOCTL_H #include #endif /* For systems that have both, but both can't be included, duh (or neither) */ /* FIXME: this whole chunk may be redundant */ #ifdef TERMIO_AND_CURSES # ifdef TERMIO_AND_TERMIOS # include # else # ifdef HAVE_TERMIOS_H # include # else # ifdef HAVE_TERMIO_H # include # endif /* HAVE_TERMIO_H */ # endif /* HAVE_TERMIOS_H */ # endif /* TERMIO_AND_TERMIOS */ #endif /* TERMIO_AND_CURSES */ void size_change(int sig GCC_UNUSED) { int old_lines = LYlines; int old_cols = LYcols; #ifdef USE_SLANG #if defined(VMS) || defined(UNIX) SLtt_get_screen_size(); #endif /* VMS || UNIX */ LYlines = SLtt_Screen_Rows; LYcols = SLtt_Screen_Cols; #ifdef SLANG_MBCS_HACK PHYSICAL_SLtt_Screen_Cols = LYcols; #ifdef SLANG_NO_LIMIT /* define this if slang has been fixed */ SLtt_Screen_Cols = LYcolLimit * 6; #else /* Needs to be limited: fixed buffer bugs in slang can cause crash, see slang's SLtt_smart_puts - kw */ SLtt_Screen_Cols = HTMIN(LYcolLimit * 6, 255); #endif #endif /* SLANG_MBCS_HACK */ if (sig == 0) /* * Called from start_curses(). */ return; #else /* Curses: */ #ifdef HAVE_SIZECHANGE #ifdef TIOCGSIZE struct ttysize win; #else #ifdef TIOCGWINSZ struct winsize win; #endif /* TIOCGWINSZ */ #endif /* TIOCGSIZE */ #ifdef TIOCGSIZE if (ioctl(0, TIOCGSIZE, &win) == 0) { if (win.ts_lines != 0) { LYlines = win.ts_lines; } if (win.ts_cols != 0) { LYcols = win.ts_cols; } } #else #ifdef TIOCGWINSZ if (ioctl(0, TIOCGWINSZ, &win) == 0) { if (win.ws_row != 0) { LYlines = win.ws_row; } if (win.ws_col != 0) { LYcols = win.ws_col; } } #endif /* TIOCGWINSZ */ #endif /* TIOCGSIZE */ #endif /* HAVE_SIZECHANGE */ #ifdef __EMX__ { int scrsize[2]; _scrsize(scrsize); LYcols = scrsize[0]; LYlines = scrsize[1]; } #endif if (LYlines <= 0) LYlines = DFT_ROWS; if (LYcols <= 0) LYcols = DFT_COLS; #endif /* USE_SLANG */ /* * Check if the screen size has actually changed. - AJL */ if (LYlines != old_lines || LYcols != old_cols) { recent_sizechange = TRUE; CTRACE((tfp, "Window size changed from (%d,%d) to (%d,%d)\n", old_lines, old_cols, LYlines, LYcols)); #if defined(CAN_SWITCH_DISPLAY_CHARSET) && defined(CAN_AUTODETECT_DISPLAY_CHARSET) /* May need to reload the font due to different char-box size */ if (current_char_set != auto_display_charset) Switch_Display_Charset(current_char_set, SWITCH_DISPLAY_CHARSET_RESIZE); #endif } #ifdef SIGWINCH LYExtSignal(SIGWINCH, size_change); #endif /* SIGWINCH */ return; } /* * Utility for freeing the list of previous suggested filenames. - FM */ void HTSugFilenames_free(void) { LYFreeStringList(sug_filenames); sug_filenames = NULL; } /* * Utility for listing suggested filenames, making any repeated filenames the * most current in the list. - FM */ void HTAddSugFilename(char *fname) { char *tmp = NULL; char *old; HTList *cur; if (!non_empty(fname)) return; StrAllocCopy(tmp, fname); if (!sug_filenames) { sug_filenames = HTList_new(); #ifdef LY_FIND_LEAKS atexit(HTSugFilenames_free); #endif HTList_addObject(sug_filenames, tmp); return; } cur = sug_filenames; while (NULL != (old = (char *) HTList_nextObject(cur))) { if (!strcmp(old, tmp)) { HTList_removeObject(sug_filenames, old); FREE(old); break; } } HTList_addObject(sug_filenames, tmp); return; } /* * CHANGE_SUG_FILENAME -- Foteos Macrides 29-Dec-1993 Upgraded for use with * Lynx2.2 - FM 17-Jan-1994 */ void change_sug_filename(char *fname) { const char *cp2; char *temp = 0, *cp, *cp1, *end; #ifdef VMS char *dot; int j, k; #endif /* VMS */ /* * Establish the current end of fname. */ end = fname + strlen(fname); /* * Unescape fname. */ HTUnEscape(fname); /* * Rename any temporary files. */ cp2 = wwwName(lynx_temp_space); #ifdef FNAMES_8_3 if (LYIsHtmlSep(*cp2)) { HTSprintf0(&temp, "file://localhost%s%04x", cp2, GETPID()); } else { HTSprintf0(&temp, "file://localhost/%s%04x", cp2, GETPID()); } #else if (LYIsHtmlSep(*cp2)) { HTSprintf0(&temp, "file://localhost%s%d", cp2, (int) getpid()); } else { HTSprintf0(&temp, "file://localhost/%s%d", cp2, (int) getpid()); } #endif if (!strncmp(fname, temp, strlen(temp))) { cp = strrchr(fname, '.'); if (strlen(cp) > (strlen(temp) - 4)) cp = NULL; StrAllocCopy(temp, NonNull(cp)); sprintf(fname, "temp%.*s", LY_MAXPATH - 10, temp); } FREE(temp); if (fname[strlen(fname) - 1] == '/') /* * Hmm... we have a directory name. It is annoying to see a * scheme+host+path name as a suggested one, let's remove the * last_slash and go ahead like we have a file name. - LP */ fname[strlen(fname) - 1] = '\0'; /* * Remove everything up the the last_slash if there is one. */ if ((cp = strrchr(fname, '/')) != NULL && strlen(cp) > 1) { cp1 = fname; /* * Go past the slash. */ cp++; for (; *cp != '\0'; cp++, cp1++) { *cp1 = *cp; } *cp1 = '\0'; } #ifdef _WINDOWS /* 1998/05/05 (Tue) 10:08:05 */ if ((cp = strrchr(fname, '=')) != NULL && strlen(cp) > 1) { cp1 = fname; /* * Go past the '='. */ cp++; for (; *cp != '\0'; cp++, cp1++) { *cp1 = *cp; } *cp1 = '\0'; } #endif /* * Trim off date-size suffix, if present. */ if ((*(end - 1) == ']') && ((cp = strrchr(fname, '[')) != NULL) && (cp > fname) && *(--cp) == ' ') { while (*cp == ' ') { *(cp--) = '\0'; } } /* * Trim off VMS device and/or directory specs, if present. */ if ((cp = strchr(fname, '[')) != NULL && (cp1 = strrchr(cp, ']')) != NULL && strlen(cp1) > 1) { cp1++; for (cp = fname; *cp1 != '\0'; cp1++) { *(cp++) = *cp1; } *cp = '\0'; } #ifdef VMS /* * Replace illegal or problem characters. */ dot = fname + strlen(fname); for (cp = fname; cp < dot; cp++) { /* * Replace with underscores. */ if (*cp == ' ' || *cp == '/' || *cp == ':' || *cp == '[' || *cp == ']' || *cp == '&') { *cp = '_'; /* * Replace with dashes. */ } else if (*cp == '!' || *cp == '?' || *cp == '\'' || *cp == ',' || *cp == ':' || *cp == '"' || *cp == '+' || *cp == '@' || *cp == '\\' || *cp == '(' || *cp == ')' || *cp == '=' || *cp == '<' || *cp == '>' || *cp == '#' || *cp == '%' || *cp == '*' || *cp == '`' || *cp == '~' || *cp == '^' || *cp == '|' || *cp < ' ' || (UCH(*cp)) > 126) { *cp = '-'; } } /* * Collapse any serial underscores. */ cp = fname + 1; j = 0; while (cp < dot) { if (fname[j] == '_' && *cp == '_') { cp++; } else { fname[++j] = *cp++; } } fname[++j] = '\0'; /* * Collapse any serial dashes. */ dot = fname + (strlen(fname)); cp = fname + 1; j = 0; while (cp < dot) { if (fname[j] == '-' && *cp == '-') { cp++; } else { fname[++j] = *cp++; } } fname[++j] = '\0'; /* * Trim any trailing or leading underscores or dashes. */ cp = fname + (strlen(fname)) - 1; while (*cp == '_' || *cp == '-') { *cp-- = '\0'; } if (fname[0] == '_' || fname[0] == '-') { dot = fname + (strlen(fname)); cp = fname; while ((*cp == '_' || *cp == '-') && cp < dot) { cp++; } j = 0; while (cp < dot) { fname[j++] = *cp++; } fname[j] = '\0'; } /* * Replace all but the last period with _'s, or second to last if last is * followed by a terminal Z or z, or GZ or gz, * e.g., convert foo.tar.Z to foo.tar_Z * or, convert foo.tar.gz to foo.tar-gz */ j = strlen(fname) - 1; if ((dot = strrchr(fname, '.')) != NULL) { if (TOUPPER(fname[j]) == 'Z') { if ((fname[j - 1] == '.') && (((cp = strchr(fname, '.')) != NULL) && cp < dot)) { *dot = '_'; dot = strrchr(fname, '.'); } else if (((TOUPPER(fname[j - 1]) == 'G') && fname[j - 2] == '.') && (((cp = strchr(fname, '.')) != NULL) && cp < dot)) { *dot = '-'; dot = strrchr(fname, '.'); } } cp = fname; while ((cp = strchr(cp, '.')) != NULL && cp < dot) { *cp = '_'; } /* * But if the root is > 39 characters, move the period appropriately to * the left. */ while (dot - fname > 39) { *dot = '\0'; if ((cp = strrchr(fname, '_')) != NULL) { *cp = '.'; *dot = '_'; } else if ((cp = strrchr(fname, '-')) != NULL) { *cp = '.'; *dot = '_'; } else if (*(dot + 1) == '\0') { j = strlen(fname); while (j > 39) { fname[j] = fname[j - 1]; j--; } fname[j] = '.'; } else { *dot = '.'; j = 39; k = 0; while (dot[k] != '\0') { fname[j++] = dot[k++]; } fname[j] = '\0'; } dot = strrchr(fname, '.'); } /* * Make sure the extension is < 40 characters. */ if ((fname + strlen(fname) - dot) > 39) { *(dot + 40) = '\0'; } /* * Trim trailing dashes or underscores. */ j = (strlen(fname) - 1); while (fname[j] == '_' || fname[j] == '-') { fname[j--] = '\0'; } } else { /* * No period, so put one on the end, or after the 39th character, * trimming trailing dashes or underscores. */ if (strlen(fname) > 39) { fname[39] = '\0'; } j = (strlen(fname) - 1); while ((fname[j] == '_') || (fname[j] == '-')) { j--; } fname[++j] = '.'; fname[++j] = '\0'; } #else /* Not VMS (UNIX): */ /* * Replace problem characters. */ for (cp = fname; *cp != '\0'; cp++) { switch (*cp) { case '\'': case '"': case '/': case ' ': *cp = '-'; } } #endif /* VMS (UNIX) */ /* * Make sure the rest of the original string in nulled. */ cp = fname + strlen(fname); while (cp < end) { *cp++ = '\0'; } return; } /* * Construct a temporary-filename. Assumes result is LY_MAXPATH chars long. */ static int fmt_tempname(char *result, const char *prefix, const char *suffix) { int code; #ifdef USE_RAND_TEMPNAME #define SIZE_TEMPNAME ((MAX_TEMPNAME / BITS_PER_CHAR) + 1) static BOOL first = TRUE; static int names_used = 0; static unsigned char used_tempname[SIZE_TEMPNAME]; unsigned offset, mask; #endif static unsigned counter; char leaf[LY_MAXPATH]; if (prefix == 0) prefix = ""; if (suffix == 0) suffix = ""; /* * Prefer a random value rather than a counter. */ #ifdef USE_RAND_TEMPNAME if (first) { lynx_srand((unsigned) ((long) time((time_t *) 0) + (long) result)); first = FALSE; } /* We don't really need all of the bits from rand(). The high-order bits * are the more-random portion in any case, but limiting the width of the * generated name is done partly to avoid problems on systems that may not * support long filenames. */ counter = MAX_TEMPNAME; if (names_used < MAX_TEMPNAME) { counter = (unsigned) (((float) MAX_TEMPNAME * lynx_rand()) / LYNX_RAND_MAX + 1); /* * Avoid reusing a temporary name, since there are places in the code * which can refer to a temporary filename even after it has been * closed and removed from the filesystem. */ do { counter %= MAX_TEMPNAME; offset = counter / BITS_PER_CHAR; mask = 1 << (counter % BITS_PER_CHAR); if ((used_tempname[offset] & mask) == 0) { names_used++; used_tempname[offset] |= mask; break; } } while ((used_tempname[offset] & mask) == 0); } if (names_used >= MAX_TEMPNAME) HTAlert(gettext("Too many tempfiles")); #else counter++; #endif #ifdef FNAMES_8_3 /* * The 'lynx_temp_space' string ends with a '/' or '\\', so we only have to * limit the length of the leaf. As received (e.g., from HTCompressed), * the suffix may contain more than a ".htm", e.g., "-txt.gz", so we trim * off from the filename portion to make room. */ #ifdef _WINDOWS sprintf(leaf, "%04x%04x", counter, (unsigned) GETPID()); #else sprintf(leaf, "%u%u", counter, (unsigned) getpid()); #endif if (strlen(leaf) > 8) leaf[8] = 0; if (strlen(suffix) > 4 || *suffix != '.') { const char *tail = strchr(suffix, '.'); if (tail == 0) tail = suffix + strlen(suffix); if (8 - (tail - suffix) >= 0) leaf[8 - (tail - suffix)] = 0; } strcat(leaf, suffix); #else sprintf(leaf, "L%u-%uTMP%s", (unsigned) getpid(), counter, suffix); #endif /* * Someone could have configured the temporary pathname to be too long. */ if ((strlen(prefix) + strlen(leaf)) < LY_MAXPATH) { sprintf(result, "%s%s", prefix, leaf); code = TRUE; } else { sprintf(result, "%.*s", LY_MAXPATH - 1, leaf); code = FALSE; } CTRACE((tfp, "-> '%s'\n", result)); return (code); } /* * Convert 4, 6, 2, 8 to left, right, down, up, etc. */ int number2arrows(int number) { switch (number) { case '1': number = END_KEY; break; case '2': number = DNARROW; break; case '3': number = PGDOWN; break; case '4': number = LTARROW; break; case '5': number = DO_NOTHING; break; case '6': number = RTARROW; break; case '7': number = HOME; break; case '8': number = UPARROW; break; case '9': number = PGUP; break; } return (number); } /* * parse_restrictions takes a string of comma-separated restrictions and sets * the corresponding flags to restrict the facilities available. */ /* The first two are special: we want to record whether "default" or "all" * restrictions were applied, in addition to the detailed effects of those * options. - kw */ /* skip the special flags when processing "all" and "default": */ #define N_SPECIAL_RESTRICT_OPTIONS 2 /* *INDENT-OFF* */ static const struct { const char *name; BOOLEAN *flag; BOOLEAN can; } restrictions[] = { { "default", &had_restrictions_default, TRUE }, { "all", &had_restrictions_all, TRUE }, { "inside_telnet", &no_inside_telnet, CAN_ANONYMOUS_INSIDE_DOMAIN_TELNET }, { "outside_telnet", &no_outside_telnet, CAN_ANONYMOUS_OUTSIDE_DOMAIN_TELNET }, { "telnet_port", &no_telnet_port, CAN_ANONYMOUS_GOTO_TELNET_PORT }, { "inside_ftp", &no_inside_ftp, CAN_ANONYMOUS_INSIDE_DOMAIN_FTP }, { "outside_ftp", &no_outside_ftp, CAN_ANONYMOUS_OUTSIDE_DOMAIN_FTP }, { "inside_rlogin", &no_inside_rlogin, CAN_ANONYMOUS_INSIDE_DOMAIN_RLOGIN }, { "outside_rlogin", &no_outside_rlogin, CAN_ANONYMOUS_OUTSIDE_DOMAIN_RLOGIN }, { "suspend", &no_suspend, FALSE }, { "editor", &no_editor, FALSE }, { "shell", &no_shell, FALSE }, { "bookmark", &no_bookmark, FALSE }, { "multibook", &no_multibook, FALSE }, { "bookmark_exec", &no_bookmark_exec, FALSE }, { "option_save", &no_option_save, FALSE }, { "print", &no_print, CAN_ANONYMOUS_PRINT }, { "download", &no_download, FALSE }, { "disk_save", &no_disk_save, FALSE }, #if defined(EXEC_LINKS) || defined(EXEC_SCRIPTS) { "exec", &no_exec, LOCAL_EXECUTION_LINKS_ALWAYS_OFF_FOR_ANONYMOUS }, #endif { "lynxcgi", &no_lynxcgi, FALSE }, { "exec_frozen", &exec_frozen, FALSE }, { "goto", &no_goto, CAN_ANONYMOUS_GOTO }, { "jump", &no_jump, CAN_ANONYMOUS_JUMP }, { "file_url", &no_file_url, FALSE }, #ifndef DISABLE_NEWS { "news_post", &no_newspost, FALSE }, { "inside_news", &no_inside_news, CAN_ANONYMOUS_INSIDE_DOMAIN_READ_NEWS }, { "outside_news", &no_outside_news, CAN_ANONYMOUS_OUTSIDE_DOMAIN_READ_NEWS }, #endif { "mail", &no_mail, CAN_ANONYMOUS_MAIL }, { "dotfiles", &no_dotfiles, FALSE }, { "useragent", &no_useragent, FALSE }, #ifdef SUPPORT_CHDIR { "chdir", &no_chdir, FALSE }, #endif #ifdef DIRED_SUPPORT { "dired_support", &no_dired_support, FALSE }, #ifdef OK_PERMIT { "change_exec_perms", &no_change_exec_perms, FALSE }, #endif /* OK_PERMIT */ #endif /* DIRED_SUPPORT */ #ifdef USE_EXTERNALS { "externals", &no_externals, FALSE }, #endif { "lynxcfg_info", &no_lynxcfg_info, CAN_ANONYMOUS_VIEW_LYNXCFG_INFO }, #ifndef NO_CONFIG_INFO { "lynxcfg_xinfo", &no_lynxcfg_xinfo, CAN_ANONYMOUS_VIEW_LYNXCFG_EXTENDED_INFO }, #ifdef HAVE_CONFIG_H { "compileopts_info", &no_compileopts_info, CAN_ANONYMOUS_VIEW_COMPILEOPTS_INFO }, #endif #endif /* put "goto" restrictions on the end, since they are a refinement */ #ifndef DISABLE_BIBP { "goto_bibp", &no_goto_bibp, CAN_ANONYMOUS_GOTO_BIBP }, #endif #ifdef HAVE_CONFIG_H #ifndef NO_CONFIG_INFO { "goto_configinfo", &no_goto_configinfo, CAN_ANONYMOUS_GOTO_CONFIGINFO }, #endif #endif { "goto_cso", &no_goto_cso, CAN_ANONYMOUS_GOTO_CSO }, { "goto_file", &no_goto_file, CAN_ANONYMOUS_GOTO_FILE }, #ifndef DISABLE_FINGER { "goto_finger", &no_goto_finger, CAN_ANONYMOUS_GOTO_FINGER }, #endif { "goto_ftp", &no_goto_ftp, CAN_ANONYMOUS_GOTO_FTP }, #ifndef DISABLE_GOPHER { "goto_gopher", &no_goto_gopher, CAN_ANONYMOUS_GOTO_GOPHER }, #endif { "goto_http", &no_goto_http, CAN_ANONYMOUS_GOTO_HTTP }, { "goto_https", &no_goto_https, CAN_ANONYMOUS_GOTO_HTTPS }, { "goto_lynxcgi", &no_goto_lynxcgi, CAN_ANONYMOUS_GOTO_LYNXCGI }, { "goto_lynxexec", &no_goto_lynxexec, CAN_ANONYMOUS_GOTO_LYNXEXEC }, { "goto_lynxprog", &no_goto_lynxprog, CAN_ANONYMOUS_GOTO_LYNXPROG }, { "goto_mailto", &no_goto_mailto, CAN_ANONYMOUS_GOTO_MAILTO }, #ifndef DISABLE_NEWS { "goto_news", &no_goto_news, CAN_ANONYMOUS_GOTO_NEWS }, { "goto_nntp", &no_goto_nntp, CAN_ANONYMOUS_GOTO_NNTP }, #endif { "goto_rlogin", &no_goto_rlogin, CAN_ANONYMOUS_GOTO_RLOGIN }, #ifndef DISABLE_NEWS { "goto_snews", &no_goto_snews, CAN_ANONYMOUS_GOTO_SNEWS }, #endif { "goto_telnet", &no_goto_telnet, CAN_ANONYMOUS_GOTO_TELNET }, { "goto_tn3270", &no_goto_tn3270, CAN_ANONYMOUS_GOTO_TN3270 }, { "goto_wais", &no_goto_wais, CAN_ANONYMOUS_GOTO_WAIS }, }; /* *INDENT-ON* */ /* This will make no difference between '-' and '_'. It does only in/equality * compare. It assumes that p2 can't contain dashes, but p1 can. This * function is also used (if macro OPTNAME_ALLOW_DASHES doesn't have value of * zero) for compare of commandline options -VH */ BOOL strn_dash_equ(const char *p1, const char *p2, int len) { while (len--) { if (!*p2) return 0; /* canonical name is shorter */ switch (*p1) { case 0: return 0; case '-': case '_': if (*p2 != '_') return 0; else break; default: if (*p1 != *p2) return 0; } ++p1; ++p2; } return 1; } /* Uncomment following lines to allow only exact string matching */ /* #define RESTRICT_NM_ALLOW_DASHES 0 */ #ifndef RESTRICT_NM_ALLOW_DASHES # define RESTRICT_NM_ALLOW_DASHES 1 #endif #if RESTRICT_NM_ALLOW_DASHES # define RESTRICT_NM_EQU(a,b,len) strn_dash_equ(a,b,len) #else # define RESTRICT_NM_EQU(a,b,len) STRNEQ(a,b,len) #endif /* * Returns the inx'th name from the restrictions table, or null if inx is * out of range. */ const char *index_to_restriction(int inx) { if (inx >= 0 && inx < (int) TABLESIZE(restrictions)) return restrictions[inx].name; return NULL; } /* * Returns the value TRUE/FALSE of a given restriction, or -1 if it is not * one that we recognize. */ int find_restriction(const char *name, int len) { unsigned i; if (len < 0) len = strlen(name); for (i = 0; i < TABLESIZE(restrictions); i++) { if (RESTRICT_NM_EQU(name, restrictions[i].name, len)) { return (*restrictions[i].flag); } } return -1; } void parse_restrictions(const char *s) { const char *p; const char *word; unsigned i; BOOLEAN found; p = s; while (*p) { p = LYSkipCBlanks(p); if (*p == '\0') break; word = p; while (*p != ',' && *p != '\0') p++; found = FALSE; if (RESTRICT_NM_EQU(word, "all", p - word)) { found = TRUE; for (i = N_SPECIAL_RESTRICT_OPTIONS; i < TABLESIZE(restrictions); i++) *(restrictions[i].flag) = TRUE; } else if (RESTRICT_NM_EQU(word, "default", p - word)) { found = TRUE; for (i = N_SPECIAL_RESTRICT_OPTIONS; i < TABLESIZE(restrictions); i++) *(restrictions[i].flag) = !restrictions[i].can; } else { for (i = 0; i < TABLESIZE(restrictions); i++) { if (RESTRICT_NM_EQU(word, restrictions[i].name, p - word)) { *(restrictions[i].flag) = TRUE; found = TRUE; break; } } } if (!found) { printf("%s: %.*s\n", gettext("unknown restriction"), p - word, word); exit_immediately(EXIT_FAILURE); } if (*p) p++; } /* * If shell is restricted, set restrictions on related topics. */ if (no_shell) { no_goto_lynxexec = TRUE; no_goto_lynxprog = TRUE; no_goto_lynxcgi = TRUE; #ifdef EXEC_LINKS local_exec_on_local_files = TRUE; #endif } } void print_restrictions_to_fd(FILE *fp) { unsigned i, count = 0; for (i = 0; i < TABLESIZE(restrictions); i++) { if (*(restrictions[i].flag) == TRUE) { count++; } } if (!count) { fprintf(fp, gettext("No restrictions set.\n")); return; } fprintf(fp, gettext("Restrictions set:\n")); for (i = 0; i < TABLESIZE(restrictions); i++) { if (*(restrictions[i].flag) == TRUE) { /* if "goto" is restricted, don't bother tell about its * refinements */ if (strncmp(restrictions[i].name, "goto_", 5) || !no_goto) fprintf(fp, " %s\n", restrictions[i].name); } } } #ifdef VMS #include #include #include typedef struct _VMSMailItemList { short buffer_length; short item_code; void *buffer_address; long *return_length_address; } VMSMailItemList; void LYCheckMail(void) { static BOOL firsttime = TRUE, failure = FALSE; static char user[13], dir[252]; static long userlen = 0, dirlen; static time_t lastcheck = 0; time_t now; static short new, lastcount; long ucontext = 0, status; short flags = MAIL$M_NEWMSG; /* *INDENT-OFF* */ VMSMailItemList null_list[] = {{0,0,0,0}}, jpi_list[] = {{sizeof(user) - 1,JPI$_USERNAME,(void *)user,&userlen}, {0,0,0,0}}, uilist[] = {{0,MAIL$_USER_USERNAME,0,0}, {0,0,0,0}}, uolist[] = {{sizeof(new),MAIL$_USER_NEW_MESSAGES,&new,0}, {sizeof(dir),MAIL$_USER_FULL_DIRECTORY,dir,&dirlen}, {0,0,0,0}}; /* *INDENT-ON* */ extern long mail$user_begin(); extern long mail$user_get_info(); extern long mail$user_end(); if (failure) return; if (firsttime) { firsttime = FALSE; /* Get the username. */ status = sys$getjpiw(0, 0, 0, jpi_list, 0, 0, 0); if (!(status & 1)) { failure = TRUE; return; } user[userlen] = '\0'; LYTrimTrailing(user); } /* Minimum report interval is 60 sec. */ time(&now); if (now - lastcheck < 60) return; lastcheck = now; /* Get the current newmail count. */ status = mail$user_begin(&ucontext, null_list, null_list); if (!(status & 1)) { failure = TRUE; return; } uilist[0].buffer_length = strlen(user); uilist[0].buffer_address = user; status = mail$user_get_info(&ucontext, uilist, uolist); if (!(status & 1)) { failure = TRUE; return; } /* Should we report anything to the user? */ if (new > 0) { if (lastcount == 0) /* Have newmail at startup of Lynx. */ HTUserMsg(HAVE_UNREAD_MAIL_MSG); else if (new > lastcount) /* Have additional mail since last report. */ HTUserMsg(HAVE_NEW_MAIL_MSG); lastcount = new; return; } lastcount = new; /* Clear the context */ mail$user_end((long *) &ucontext, null_list, null_list); return; } #else void LYCheckMail(void) { static BOOL firsttime = TRUE; static char *mf; static time_t lastcheck; static time_t lasttime; static long lastsize; time_t now; struct stat st; if (firsttime) { mf = LYGetEnv("MAIL"); firsttime = FALSE; time(&lasttime); } if (mf == NULL) return; time(&now); if (now - lastcheck < 60) return; lastcheck = now; if ((stat(mf, &st) < 0) || !S_ISREG(st.st_mode)) { mf = NULL; return; } if (st.st_size > 0) { if (((lasttime != st.st_mtime) && (st.st_mtime > st.st_atime)) || ((lastsize != 0) && (st.st_size > lastsize))) HTUserMsg(HAVE_NEW_MAIL_MSG); else if (lastsize == 0) HTUserMsg(HAVE_MAIL_MSG); } lastsize = st.st_size; lasttime = st.st_mtime; return; } #endif /* VMS */ /* * This function ensures that an href will be * converted to a fully resolved, absolute URL, * with guessing of the host or expansions of * lead tildes via LYConvertToURL() if needed, * and tweaking/simplifying via HTParse(). It * is used for LynxHome, startfile, homepage, * and 'g'oto entries, after they have been * passed to LYFillLocalFileURL(). - FM * Such URLs have no `base' reference to which they * could be resolved. LYLegitimizeHREF could not be used. */ void LYEnsureAbsoluteURL(char **href, const char *name, int fixit) { char *temp = NULL; if (isEmpty(*href)) return; /* * Check whether to fill in localhost. - FM */ LYFillLocalFileURL(href, "file://localhost"); /* * If it is not a URL then make it one. */ if (!strcasecomp(*href, STR_NEWS_URL)) { StrAllocCat(*href, "*"); } else if (!strcasecomp(*href, STR_SNEWS_URL)) { StrAllocCat(*href, "/*"); } if (!is_url(*href)) { CTRACE((tfp, "%s%s'%s' is not a URL\n", NonNull(name), (name ? " " : ""), *href)); LYConvertToURL(href, fixit); } temp = HTParse(*href, "", PARSE_ALL); if (non_empty(temp)) StrAllocCopy(*href, temp); FREE(temp); } /* * Rewrite and reallocate a previously allocated string as a file URL if the * string resolves to a file or directory on the local system, otherwise as an * http URL. - FM */ void LYConvertToURL(char **AllocatedString, int fixit) { char *old_string = *AllocatedString; char *temp = NULL; char *cp = NULL; #ifndef VMS struct stat st; #endif /* !VMS */ if (!old_string || *old_string == '\0') return; #if defined(USE_DOS_DRIVES) { char *cp_url = *AllocatedString; for (; *cp_url != '\0'; cp_url++) if (*cp_url == '\\') *cp_url = '/'; cp_url--; if (LYIsDosDrive(*AllocatedString) && *cp_url == ':') LYAddPathSep(AllocatedString); } #endif /* USE_DOS_DRIVES */ *AllocatedString = NULL; /* so StrAllocCopy doesn't free it */ StrAllocCopy(*AllocatedString, "file://localhost"); if (*old_string != '/') { char *fragment = NULL; #if defined(USE_DOS_DRIVES) StrAllocCat(*AllocatedString, "/"); #endif /* USE_DOS_DRIVES */ #ifdef VMS /* * Not a SHELL pathspec. Get the full VMS spec and convert it. */ char *cur_dir = NULL; static char url_file[LY_MAXPATH], file_name[LY_MAXPATH], dir_name[LY_MAXPATH]; unsigned long context = 0; $DESCRIPTOR(url_file_dsc, url_file); $DESCRIPTOR(file_name_dsc, file_name); if (*old_string == '~') { /* * On VMS, we'll accept '~' on the command line as Home_Dir(), and * assume the rest of the path, if any, has SHELL syntax. */ StrAllocCat(*AllocatedString, HTVMS_wwwName(Home_Dir())); if ((cp = strchr(old_string, '/')) != NULL) { /* * Append rest of path, if present, skipping "user" if "~user" * was entered, simplifying, and eliminating any residual * relative elements. - FM */ StrAllocCopy(temp, cp); LYTrimRelFromAbsPath(temp); StrAllocCat(*AllocatedString, temp); FREE(temp); } goto have_VMS_URL; } else { fragment = trimPoundSelector(old_string); LYstrncpy(url_file, old_string, sizeof(url_file) - 1); } url_file_dsc.dsc$w_length = (short) strlen(url_file); if (1 & lib$find_file(&url_file_dsc, &file_name_dsc, &context, 0, 0, 0, 0)) { /* * We found the file. Convert to a URL pathspec. */ if ((cp = strchr(file_name, ';')) != NULL) { *cp = '\0'; } LYLowerCase(file_name); StrAllocCat(*AllocatedString, HTVMS_wwwName(file_name)); if ((cp = strchr(old_string, ';')) != NULL) { StrAllocCat(*AllocatedString, cp); } if (fragment != NULL) { restorePoundSelector(fragment); StrAllocCat(*AllocatedString, fragment); fragment = NULL; } } else if ((NULL != getcwd(dir_name, sizeof(dir_name) - 1, 0)) && 0 == chdir(old_string)) { /* * Probably a directory. Try converting that. */ StrAllocCopy(cur_dir, dir_name); restorePoundSelector(fragment); if (NULL != getcwd(dir_name, sizeof(dir_name) - 1, 0)) { /* * Yup, we got it! */ LYLowerCase(dir_name); StrAllocCat(*AllocatedString, dir_name); if (fragment != NULL) { StrAllocCat(*AllocatedString, fragment); fragment = NULL; } } else { /* * Nope. Assume it's an http URL with the "http://" defaulted, * if we can't rule out a bad VMS path. */ fragment = NULL; if (strchr(old_string, '[') || ((cp = strchr(old_string, ':')) != NULL && !isdigit(UCH(cp[1]))) || !LYExpandHostForURL(&old_string, URLDomainPrefixes, URLDomainSuffixes)) { /* * Probably a bad VMS path (but can't be sure). Use * original pathspec for the error message that will * result. */ sprintf(url_file, "/%.*s", sizeof(url_file) - 2, old_string); CTRACE((tfp, "Can't find '%s' Will assume it's a bad path.\n", old_string)); StrAllocCat(*AllocatedString, url_file); } else { /* * Assume a URL is wanted, so guess the scheme with * "http://" as the default. - FM */ if (!LYAddSchemeForURL(&old_string, "http://")) { StrAllocCopy(*AllocatedString, "http://"); StrAllocCat(*AllocatedString, old_string); } else { StrAllocCopy(*AllocatedString, old_string); } } } } else { /* * Nothing found. Assume it's an http URL with the "http://" * defaulted, if we can't rule out a bad VMS path. */ restorePoundSelector(fragment); fragment = NULL; if (strchr(old_string, '[') || ((cp = strchr(old_string, ':')) != NULL && !isdigit(UCH(cp[1]))) || !LYExpandHostForURL(&old_string, URLDomainPrefixes, URLDomainSuffixes)) { /* * Probably a bad VMS path (but can't be sure). Use original * pathspec for the error message that will result. */ sprintf(url_file, "/%.*s", sizeof(url_file) - 2, old_string); CTRACE((tfp, "Can't find '%s' Will assume it's a bad path.\n", old_string)); StrAllocCat(*AllocatedString, url_file); } else { /* * Assume a URL is wanted, so guess the scheme with "http://" * as the default. - FM */ if (!LYAddSchemeForURL(&old_string, "http://")) { StrAllocCopy(*AllocatedString, "http://"); StrAllocCat(*AllocatedString, old_string); } else { StrAllocCopy(*AllocatedString, old_string); } } } lib$find_file_end(&context); FREE(cur_dir); have_VMS_URL: CTRACE((tfp, "Trying: '%s'\n", *AllocatedString)); #else /* not VMS: */ #if defined(USE_DOS_DRIVES) #ifdef _WINDOWS if (*old_string == '.') { char fullpath[MAX_PATH + 1]; char *filepart = NULL; DWORD chk; chk = GetFullPathNameA(old_string, MAX_PATH + 1, fullpath, &filepart); if (chk != 0) { StrAllocCopy(temp, wwwName(fullpath)); StrAllocCat(*AllocatedString, temp); FREE(temp); CTRACE((tfp, "Converted '%s' to '%s'\n", old_string, *AllocatedString)); } else { StrAllocCat(*AllocatedString, old_string); } } #else if (strlen(old_string) == 1 && *old_string == '.') { /* * They want . */ char curdir[LY_MAXPATH]; StrAllocCopy(temp, wwwName(Current_Dir(curdir))); StrAllocCat(*AllocatedString, temp); FREE(temp); CTRACE((tfp, "Converted '%s' to '%s'\n", old_string, *AllocatedString)); } #endif else #endif /* USE_DOS_DRIVES */ if (*old_string == '~') { /* * On Unix, convert '~' to Home_Dir(). */ StrAllocCat(*AllocatedString, wwwName(Home_Dir())); if ((cp = strchr(old_string, '/')) != NULL) { /* * Append rest of path, if present, skipping "user" if "~user" * was entered, simplifying, and eliminating any residual * relative elements. - FM */ StrAllocCopy(temp, cp); LYTrimRelFromAbsPath(temp); StrAllocCat(*AllocatedString, temp); FREE(temp); } CTRACE((tfp, "Converted '%s' to '%s'\n", old_string, *AllocatedString)); } else { /* * Create a full path to the current default directory. */ char curdir[LY_MAXPATH]; char *temp2 = NULL; BOOL is_local = FALSE; Current_Dir(curdir); /* * Concatenate and simplify, trimming any residual relative * elements. - FM */ #if defined (USE_DOS_DRIVES) if (old_string[1] != ':' && old_string[1] != '|') { StrAllocCopy(temp, wwwName(curdir)); LYAddHtmlSep(&temp); LYstrncpy(curdir, temp, (sizeof(curdir) - 1)); StrAllocCat(temp, old_string); } else { curdir[0] = '\0'; /* 1998/01/13 (Tue) 12:24:33 */ if (old_string[1] == '|') old_string[1] = ':'; StrAllocCopy(temp, old_string); if (strlen(temp) == 2 && LYIsDosDrive(temp)) LYAddPathSep(&temp); } #else StrAllocCopy(temp, curdir); StrAllocCat(temp, "/"); StrAllocCat(temp, old_string); #endif /* USE_DOS_DRIVES */ LYTrimRelFromAbsPath(temp); CTRACE((tfp, "Converted '%s' to '%s'\n", old_string, temp)); if ((stat(temp, &st) > -1) || LYCanReadFile(temp)) { /* * It is a subdirectory or file on the local system. */ #if defined (USE_DOS_DRIVES) /* Don't want to see DOS local paths like c: escaped */ /* especially when we really have file://localhost/ */ /* at the beginning. To avoid any confusion we allow */ /* escaping the path if URL specials % or # present. */ if (strchr(temp, '#') == NULL && strchr(temp, '%') == NULL) StrAllocCopy(cp, temp); else cp = HTEscape(temp, URL_PATH); #else cp = HTEscape(temp, URL_PATH); #endif /* USE_DOS_DRIVES */ StrAllocCat(*AllocatedString, cp); FREE(cp); CTRACE((tfp, "Converted '%s' to '%s'\n", old_string, *AllocatedString)); is_local = TRUE; } else { char *cp2 = NULL; StrAllocCopy(temp2, curdir); LYAddPathSep(&temp2); StrAllocCopy(cp, old_string); fragment = trimPoundSelector(cp); HTUnEscape(cp); /* unescape given path without fragment */ StrAllocCat(temp2, cp); /* append to current dir */ StrAllocCopy(cp2, temp2); /* keep a copy in cp2 */ LYTrimRelFromAbsPath(temp2); #ifdef WIN_EX /* 1998/07/31 (Fri) 09:09:03 */ HTUnEscape(temp2); /* for LFN */ #endif if (strcmp(temp2, temp) != 0 && ((stat(temp2, &st) > -1) || LYCanReadFile(temp2))) { /* * It is a subdirectory or file on the local system with * escaped characters and/or a fragment to be appended to * the URL. - FM */ FREE(temp); if (strcmp(cp2, temp2) == 0) { /* * LYTrimRelFromAbsPath did nothing, use old_string as * given. - kw */ temp = HTEscape(curdir, URL_PATH); LYAddHtmlSep(&temp); StrAllocCat(temp, old_string); } else { temp = HTEscape(temp2, URL_PATH); if (fragment != NULL) { restorePoundSelector(fragment); StrAllocCat(temp, fragment); } } StrAllocCat(*AllocatedString, temp); CTRACE((tfp, "Converted '%s' to '%s'\n", old_string, *AllocatedString)); is_local = TRUE; } else if (strchr(curdir, '#') != NULL || strchr(curdir, '%') != NULL) { /* * If PWD has some unusual characters, construct a filename * in temp where those are escaped. This is mostly to * prevent this function from returning with some weird URL * if the LYExpandHostForURL tests further down fail. - kw */ FREE(temp); if (strcmp(cp2, temp2) == 0) { /* * LYTrimRelFromAbsPath did nothing, use old_string as * given. - kw */ temp = HTEscape(curdir, URL_PATH); LYAddHtmlSep(&temp); StrAllocCat(temp, old_string); } else { temp = HTEscape(temp2, URL_PATH); if (fragment != NULL) { restorePoundSelector(fragment); StrAllocCat(temp, fragment); } } } FREE(cp); FREE(cp2); } if (is_local == FALSE) { /* * It's not an accessible subdirectory or file on the local * system, so assume it's a URL request and guess the scheme * with "http://" as the default. */ CTRACE((tfp, "Can't stat() or fopen() '%s'\n", temp2 ? temp2 : temp)); #ifdef WIN_EX /* 1998/01/13 (Tue) 09:07:37 */ { const char *p, *q; char buff[LY_MAXPATH + 128]; p = Home_Dir(); q = temp2 ? temp2 : temp; if (strlen(q) == 3 && LYIsDosDrive(q)) { sprintf(buff, "'%s' not exist, Goto LynxHome '%s'.", q, p); _statusline(buff); LYSleepAlert(); FREE(temp); StrAllocCat(*AllocatedString, p); goto Retry; } } #endif if (LYExpandHostForURL(&old_string, URLDomainPrefixes, URLDomainSuffixes)) { if (!LYAddSchemeForURL(&old_string, "http://")) { StrAllocCopy(*AllocatedString, "http://"); StrAllocCat(*AllocatedString, old_string); } else { StrAllocCopy(*AllocatedString, old_string); } } else if (fixit) { /* RW 1998Mar16 Restore AllocatedString to 'old_string' */ StrAllocCopy(*AllocatedString, old_string); } else { /* Return file URL for the file that does not exist */ StrAllocCat(*AllocatedString, temp); } #ifdef WIN_EX Retry: #endif CTRACE((tfp, "Trying: '%s'\n", *AllocatedString)); } FREE(temp); FREE(temp2); } #endif /* VMS */ } else { /* * Path begins with a slash. Simplify and use it. */ if (old_string[1] == '\0') { /* * Request for root. Respect it on Unix, but on VMS we treat that * as a listing of the login directory. - FM */ #ifdef VMS StrAllocCat(*AllocatedString, HTVMS_wwwName(Home_Dir())); #else StrAllocCat(*AllocatedString, "/"); } else if ((stat(old_string, &st) > -1) || LYCanReadFile(old_string)) { /* * It is an absolute directory or file on the local system. - KW */ StrAllocCopy(temp, old_string); LYTrimRelFromAbsPath(temp); CTRACE((tfp, "Converted '%s' to '%s'\n", old_string, temp)); cp = HTEscape(temp, URL_PATH); StrAllocCat(*AllocatedString, cp); FREE(cp); FREE(temp); CTRACE((tfp, "Converted '%s' to '%s'\n", old_string, *AllocatedString)); #endif /* VMS */ } else if (old_string[1] == '~') { /* * Has a Home_Dir() reference. Handle it as if there weren't a * lead slash. - FM */ StrAllocCat(*AllocatedString, wwwName(Home_Dir())); if ((cp = strchr((old_string + 1), '/')) != NULL) { /* * Append rest of path, if present, skipping "user" if "~user" * was entered, simplifying, and eliminating any residual * relative elements. - FM */ StrAllocCopy(temp, cp); LYTrimRelFromAbsPath(temp); StrAllocCat(*AllocatedString, temp); FREE(temp); } } else { /* * Normal absolute path. Simplify, trim any residual relative * elements, and append it. - FM */ StrAllocCopy(temp, old_string); LYTrimRelFromAbsPath(temp); StrAllocCat(*AllocatedString, temp); FREE(temp); } CTRACE((tfp, "Converted '%s' to '%s'\n", old_string, *AllocatedString)); } FREE(old_string); /* Pause so we can read the messages before invoking curses */ CTRACE_SLEEP(AlertSecs); } #if defined(_WINDOWS) /* 1998/06/23 (Tue) 16:45:20 */ int win32_check_interrupt(void) { int c; if (kbhit()) { c = LYgetch(); /** Keyboard 'Z' or 'z', or Control-G or Control-C **/ if (LYCharIsINTERRUPT(c) || c == 0x1b) { return TRUE; } } return FALSE; } void sleep(unsigned sec) { unsigned int i, j; int c; for (j = 0; j < sec; j++) { for (i = 0; i < 10; i++) { Sleep(100); if (kbhit()) { c = LYgetch(); return; } } } } #endif /* * This function rewrites and reallocates a previously allocated string so that * the first element is a confirmed Internet host, and returns TRUE, otherwise * it does not modify the string and returns FALSE. It first tries the element * as is, then, if the element does not end with a dot, it adds prefixes from * the (comma separated) prefix list argument, and, if the element does not * begin with a dot, suffixes from the (comma separated) suffix list arguments * (e.g., www.host.com, then www.host,edu, then www.host.net, then * www.host.org). The remaining path, if one is present, will be appended to * the expanded host. It also takes into account whether a colon is in the * element or suffix, and includes that and what follows as a port field for * the expanded host field (e.g, wfbr:8002/dir/lynx should yield * www.wfbr.edu:8002/dir/lynx). The calling function should prepend the scheme * field (e.g., http://), or pass the string to LYAddSchemeForURL(), if this * function returns TRUE. - FM */ BOOLEAN LYExpandHostForURL(char **AllocatedString, char *prefix_list, char *suffix_list) { char *DomainPrefix = NULL; const char *StartP, *EndP; char *DomainSuffix = NULL; const char *StartS, *EndS; char *Str = NULL, *StrColon = NULL, *MsgStr = NULL; char *Host = NULL, *HostColon = NULL, *host = NULL; char *Path = NULL; char *Fragment = NULL; BOOLEAN GotHost = FALSE; BOOLEAN Startup = (BOOL) (helpfilepath == NULL); #ifdef INET6 struct addrinfo hints, *res; int error; #endif /* INET6 */ /* * If it's a NULL or zero-length string, or if it begins with a slash or * hash, don't continue pointlessly. - FM */ if (!(*AllocatedString) || *AllocatedString[0] == '\0' || *AllocatedString[0] == '/' || *AllocatedString[0] == '#') { return GotHost; } /* * If it's a partial or relative path, don't continue pointlessly. - FM */ if (!strncmp(*AllocatedString, "..", 2) || !strncmp(*AllocatedString, "./", 2)) { return GotHost; } /* * Make a clean copy of the string, and trim off the path if one is * present, but save the information so we can restore the path after * filling in the Host[:port] field. - FM */ StrAllocCopy(Str, *AllocatedString); if ((Path = strchr(Str, '/')) != NULL) { /* * Have a path. Any fragment should already be included in Path. - FM */ *Path = '\0'; } else { /* * No path, so check for a fragment and trim that, to be restored after * filling in the Host[:port] field. - FM */ Fragment = trimPoundSelector(Str); } /* * If the potential host string has a colon, assume it begins a port field, * and trim it off, but save the information so we can restore the port * field after filling in the host field. - FM */ if ((StrColon = strrchr(Str, ':')) != NULL && isdigit(UCH(StrColon[1]))) { if (StrColon == Str) { goto cleanup; } *StrColon = '\0'; } /* * Do a DNS test on the potential host field as presently trimmed. - FM */ StrAllocCopy(host, Str); HTUnEscape(host); if (LYCursesON) { StrAllocCopy(MsgStr, WWW_FIND_MESSAGE); StrAllocCat(MsgStr, host); StrAllocCat(MsgStr, FIRST_SEGMENT); HTProgress(MsgStr); } else if (Startup && !dump_output_immediately) { fprintf(stdout, "%s '%s'%s\r\n", WWW_FIND_MESSAGE, host, FIRST_SEGMENT); } #ifdef INET6 memset(&hints, 0, sizeof(hints)); hints.ai_family = PF_UNSPEC; hints.ai_socktype = SOCK_STREAM; error = getaddrinfo(host, "80", &hints, &res); if (!error && res) #else if (LYGetHostByName(host) != NULL) #endif /* INET6 */ { /* * Clear any residual interrupt. - FM */ if (LYCursesON && HTCheckForInterrupt()) { CTRACE((tfp, "LYExpandHostForURL: Ignoring interrupt because '%s' resolved.\n", host)); } /* * Return success. - FM */ GotHost = TRUE; goto cleanup; } else if (LYCursesON && (lynx_nsl_status == HT_INTERRUPTED)) { /* * Give the user chance to interrupt lookup cycles. - KW & FM */ CTRACE((tfp, "LYExpandHostForURL: Interrupted while '%s' failed to resolve.\n", host)); /* * Return failure. - FM */ goto cleanup; } /* * Set the first prefix, making it a zero-length string if the list is NULL * or if the potential host field ends with a dot. - FM */ StartP = ((prefix_list && Str[strlen(Str) - 1] != '.') ? prefix_list : ""); /* * If we have a prefix, but the allocated string is one of the common host * prefixes, make our prefix a zero-length string. - FM */ if (*StartP && *StartP != '.') { if (!strncasecomp(*AllocatedString, "www.", 4) || !strncasecomp(*AllocatedString, "ftp.", 4) || !strncasecomp(*AllocatedString, "gopher.", 7) || !strncasecomp(*AllocatedString, "wais.", 5) || !strncasecomp(*AllocatedString, "cso.", 4) || !strncasecomp(*AllocatedString, "ns.", 3) || !strncasecomp(*AllocatedString, "ph.", 3) || !strncasecomp(*AllocatedString, "finger.", 7) || !strncasecomp(*AllocatedString, "news.", 5) || !strncasecomp(*AllocatedString, "nntp.", 5)) { StartP = ""; } } while ((*StartP) && (WHITE(*StartP) || *StartP == ',')) { StartP++; /* Skip whitespace and separators */ } EndP = StartP; while (*EndP && !WHITE(*EndP) && *EndP != ',') { EndP++; /* Find separator */ } StrAllocCopy(DomainPrefix, StartP); DomainPrefix[EndP - StartP] = '\0'; /* * Test each prefix with each suffix. - FM */ do { /* * Set the first suffix, making it a zero-length string if the list is * NULL or if the potential host field begins with a dot. - FM */ StartS = ((suffix_list && *Str != '.') ? suffix_list : ""); while ((*StartS) && (WHITE(*StartS) || *StartS == ',')) { StartS++; /* Skip whitespace and separators */ } EndS = StartS; while (*EndS && !WHITE(*EndS) && *EndS != ',') { EndS++; /* Find separator */ } StrAllocCopy(DomainSuffix, StartS); DomainSuffix[EndS - StartS] = '\0'; /* * Create domain names and do DNS tests. - FM */ do { StrAllocCopy(Host, DomainPrefix); StrAllocCat(Host, ((*Str == '.') ? (Str + 1) : Str)); if (Host[strlen(Host) - 1] == '.') { Host[strlen(Host) - 1] = '\0'; } StrAllocCat(Host, DomainSuffix); if ((HostColon = strrchr(Host, ':')) != NULL && isdigit(UCH(HostColon[1]))) { *HostColon = '\0'; } StrAllocCopy(host, Host); HTUnEscape(host); if (LYCursesON) { StrAllocCopy(MsgStr, WWW_FIND_MESSAGE); StrAllocCat(MsgStr, host); StrAllocCat(MsgStr, GUESSING_SEGMENT); HTProgress(MsgStr); } else if (Startup && !dump_output_immediately) { fprintf(stdout, "%s '%s'%s\n", WWW_FIND_MESSAGE, host, GUESSING_SEGMENT); } GotHost = (BOOL) (LYGetHostByName(host) != NULL); if (HostColon != NULL) { *HostColon = ':'; } if (GotHost == FALSE) { /* * Give the user chance to interrupt lookup cycles. - KW */ if (LYCursesON && (lynx_nsl_status == HT_INTERRUPTED)) { CTRACE((tfp, "LYExpandHostForURL: Interrupted while '%s' failed to resolve.\n", host)); goto cleanup; /* We didn't find a valid name. */ } /* * Advance to the next suffix, or end of suffix list. - FM */ StartS = ((*EndS == '\0') ? EndS : (EndS + 1)); while ((*StartS) && (WHITE(*StartS) || *StartS == ',')) { StartS++; /* Skip whitespace and separators */ } EndS = StartS; while (*EndS && !WHITE(*EndS) && *EndS != ',') { EndS++; /* Find separator */ } LYstrncpy(DomainSuffix, StartS, (EndS - StartS)); } } while ((GotHost == FALSE) && (*DomainSuffix != '\0')); if (GotHost == FALSE) { /* * Advance to the next prefix, or end of prefix list. - FM */ StartP = ((*EndP == '\0') ? EndP : (EndP + 1)); while ((*StartP) && (WHITE(*StartP) || *StartP == ',')) { StartP++; /* Skip whitespace and separators */ } EndP = StartP; while (*EndP && !WHITE(*EndP) && *EndP != ',') { EndP++; /* Find separator */ } LYstrncpy(DomainPrefix, StartP, (EndP - StartP)); } } while ((GotHost == FALSE) && (*DomainPrefix != '\0')); /* * If a test passed, restore the port field if we had one and there is no * colon in the expanded host, and the path if we had one, and reallocate * the original string with the expanded Host[:port] field included. - FM */ if (GotHost) { if (StrColon && strchr(Host, ':') == NULL) { *StrColon = ':'; StrAllocCat(Host, StrColon); } if (Path) { *Path = '/'; StrAllocCat(Host, Path); } else if (Fragment) { StrAllocCat(Host, "/"); restorePoundSelector(Fragment); StrAllocCat(Host, Fragment); } StrAllocCopy(*AllocatedString, Host); } /* * Clear any residual interrupt. - FM */ if (LYCursesON && HTCheckForInterrupt()) { CTRACE((tfp, "LYExpandHostForURL: Ignoring interrupt because '%s' %s.\n", host, (GotHost ? "resolved" : "timed out"))); } /* * Clean up and return the last test result. - FM */ cleanup: FREE(DomainPrefix); FREE(DomainSuffix); FREE(Str); FREE(MsgStr); FREE(Host); FREE(host); return GotHost; } /* * This function rewrites and reallocates a previously allocated string that * begins with an Internet host name so that the string begins with its guess * of the scheme based on the first field of the host name, or the default * scheme if no guess was made, and returns TRUE, otherwise it does not modify * the string and returns FALSE. It also returns FALSE without modifying the * string if the default_scheme argument was NULL or zero-length and no guess * was made. - FM */ BOOLEAN LYAddSchemeForURL(char **AllocatedString, const char *default_scheme) { char *Str = NULL; BOOLEAN GotScheme = FALSE; /* * If we were passed a NULL or zero-length string, don't continue * pointlessly. - FM */ if (!(*AllocatedString) || *AllocatedString[0] == '\0') { return GotScheme; } /* * Try to guess the appropriate scheme. - FM */ if (0 == strncasecomp(*AllocatedString, "www", 3)) { /* * This could be either http or https, so check the default and * otherwise use "http". - FM */ if (default_scheme != NULL && NULL != strstr(default_scheme, "http")) { StrAllocCopy(Str, default_scheme); } else { StrAllocCopy(Str, "http://"); } GotScheme = TRUE; } else if (0 == strncasecomp(*AllocatedString, "ftp", 3)) { StrAllocCopy(Str, "ftp://"); GotScheme = TRUE; } else if (0 == strncasecomp(*AllocatedString, "gopher", 6)) { StrAllocCopy(Str, "gopher://"); GotScheme = TRUE; } else if (0 == strncasecomp(*AllocatedString, "wais", 4)) { StrAllocCopy(Str, "wais://"); GotScheme = TRUE; } else if (0 == strncasecomp(*AllocatedString, "cso", 3) || 0 == strncasecomp(*AllocatedString, "ns.", 3) || 0 == strncasecomp(*AllocatedString, "ph.", 3)) { StrAllocCopy(Str, "cso://"); GotScheme = TRUE; } else if (0 == strncasecomp(*AllocatedString, "finger", 6)) { StrAllocCopy(Str, "finger://"); GotScheme = TRUE; } else if (0 == strncasecomp(*AllocatedString, "news", 4)) { /* * This could be either news, snews, or nntp, so check the default, and * otherwise use news. - FM */ if ((default_scheme != NULL) && (NULL != strstr(default_scheme, "news") || NULL != strstr(default_scheme, "nntp"))) { StrAllocCopy(Str, default_scheme); } else { StrAllocCopy(Str, "news://"); } GotScheme = TRUE; } else if (0 == strncasecomp(*AllocatedString, "nntp", 4)) { StrAllocCopy(Str, "nntp://"); GotScheme = TRUE; } /* * If we've make a guess, use it. Otherwise, if we were passed a default * scheme prefix, use that. - FM */ if (GotScheme == TRUE) { StrAllocCat(Str, *AllocatedString); StrAllocCopy(*AllocatedString, Str); FREE(Str); return GotScheme; } else if (non_empty(default_scheme)) { StrAllocCopy(Str, default_scheme); GotScheme = TRUE; StrAllocCat(Str, *AllocatedString); StrAllocCopy(*AllocatedString, Str); FREE(Str); return GotScheme; } return GotScheme; } /* * This function expects an absolute Unix or VMS SHELL path spec as an * allocated string, simplifies it, and trims out any residual relative * elements. It also checks whether the path had a terminal slash, and if it * didn't, makes sure that the simplified path doesn't either. If it's a * directory, our convention is to exclude "Up to parent" links when a terminal * slash is present. - FM */ void LYTrimRelFromAbsPath(char *path) { char *cp; int i; BOOL TerminalSlash; /* * Make sure we have a pointer to an absolute path. - FM */ if (path == NULL || !LYIsPathSep(*path)) return; /* * Check whether the path has a terminal slash. - FM */ TerminalSlash = (BOOL) (LYIsPathSep(path[(strlen(path) - 1)])); /* * Simplify the path and then do any necessary trimming. - FM */ HTSimplify(path); cp = path; while (cp[1] == '.') { if (cp[2] == '\0') { /* * Eliminate trailing dot. - FM */ cp[1] = '\0'; } else if (LYIsPathSep(cp[2])) { /* * Skip over the "/." of a "/./". - FM */ cp += 2; } else if (cp[2] == '.' && cp[3] == '\0') { /* * Eliminate trailing dotdot. - FM */ cp[1] = '\0'; } else if (cp[2] == '.' && cp[3] == '/') { /* * Skip over the "/.." of a "/../". - FM */ cp += 3; } else { /* * Done trimming. - FM */ break; } } /* * Load any shifts into path, and eliminate any terminal slash created by * HTSimplify() or our walk, but not present originally. - FM */ if (cp > path) { for (i = 0; cp[i] != '\0'; i++) path[i] = cp[i]; path[i] = '\0'; } if (TerminalSlash == FALSE) { LYTrimPathSep(path); } } /* * Example Client-Side Include interface. * * This is called from SGML.c and simply returns markup for reporting the URL * of the document being loaded if a comment begins with "