CCF_100/ncsa-mosaic
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
1997c69ca6
ncsa-mosaic/libwww2/HTAccess.c
Robert Clausecker 1446c97470 Automatically remove trailing whitespace
2013-03-10 01:59:42 +01:00

651 lines
16 KiB
C
Raw Blame History

/* Access Manager HTAccess.c
** ==============
**
** Authors
** TBL Tim Berners-Lee timbl@info.cern.ch
** JFG Jean-Francois Groff jfg@dxcern.cern.ch
** DD Denis DeLaRoca (310) 825-4580 <CSP1DWD@mvs.oac.ucla.edu>
** History
** 8 Jun 92 Telnet hopping prohibited as telnet is not secure TBL
** 26 Jun 92 When over DECnet, suppressed FTP, Gopher and News. JFG
** 6 Oct 92 Moved HTClientHost and logfile into here. TBL
** 17 Dec 92 Tn3270 added, bug fix. DD
** 4 Feb 93 Access registration, Search escapes bad chars TBL
** PARAMETERS TO HTSEARCH AND HTLOADRELATIVE CHANGED
** 28 May 93 WAIS gateway explicit if no WAIS library linked in.
**
** Bugs
** This module assumes that that the graphic object is hypertext, as it
** needs to select it when it has been loaded. A superclass needs to be
** defined which accepts select and select_anchor.
*/
#include "../config.h"
#ifndef DEFAULT_WAIS_GATEWAY
#define DEFAULT_WAIS_GATEWAY "http://www.ncsa.uiuc.edu:8001/"
#endif
/* Implements:
*/
#include "HTAccess.h"
/* Uses:
*/
#include "HTParse.h"
#include "HTUtils.h"
#include "HTML.h" /* SCW */
#include <stdio.h>
#include "HTList.h"
#include "HText.h" /* See bugs above */
#include "HTAlert.h"
#include "../src/mosaic.h"
#include "../src/gui.h"
#include "../src/mo-www.h"
#include "../src/proxy.h"
#include "../src/proxy-dialogs.h"
#ifndef DISABLE_TRACE
extern int www2Trace;
#endif
extern char *mo_check_for_proxy (char *);
int has_fallbacks(char *protocol);
char *currentURL=NULL;
/* These flags may be set to modify the operation of this module
*/
PUBLIC char * HTClientHost = 0; /* Name of remote login host if any */
/* To generate other things, play with these:
*/
PUBLIC HTFormat HTOutputFormat = NULL;
PUBLIC HTStream* HTOutputStream = NULL; /* For non-interactive, set this */
PUBLIC BOOL using_gateway = NO; /* are we using a gateway? */
PUBLIC BOOL using_proxy = NO; /* are we using a proxy gateway? */
PUBLIC char *proxy_host_fix=NULL; /* Host: header fix */
PRIVATE HTList * protocols = NULL; /* List of registered protocol descriptors */
/* Register a Protocol HTRegisterProtocol
** -------------------
*/
PUBLIC BOOL HTRegisterProtocol(protocol)
HTProtocol * protocol;
{
if (!protocols) protocols = HTList_new();
HTList_addObject(protocols, protocol);
return YES;
}
/* Register all known protocols
** ----------------------------
**
** Add to or subtract from this list if you add or remove protocol modules.
** This routine is called the first time the protocol list is needed,
** unless any protocols are already registered, in which case it is not called.
** Therefore the application can override this list.
*/
PRIVATE void HTAccessInit NOARGS /* Call me once */
{
extern HTProtocol HTTP, HTFile, HTTelnet, HTTn3270, HTRlogin;
extern HTProtocol HTFTP, HTNews, HTGopher, HTMailto, HTNNTP;
#ifdef DIRECT_WAIS
extern HTProtocol HTWAIS;
#endif
HTRegisterProtocol(&HTFTP);
HTRegisterProtocol(&HTNews);
HTRegisterProtocol(&HTGopher);
#ifdef DIRECT_WAIS
HTRegisterProtocol(&HTWAIS);
#endif
HTRegisterProtocol(&HTTP);
HTRegisterProtocol(&HTFile);
HTRegisterProtocol(&HTTelnet);
HTRegisterProtocol(&HTTn3270);
HTRegisterProtocol(&HTRlogin);
HTRegisterProtocol(&HTMailto);
HTRegisterProtocol(&HTNNTP);
}
/* Find physical name and access protocol
** --------------------------------------
**
**
** On entry,
** addr must point to the fully qualified hypertext reference.
** anchor a pareent anchor with whose address is addr
**
** On exit,
** returns HT_NO_ACCESS Error has occured.
** HT_OK Success
**
*/
PRIVATE int get_physical ARGS3(
char *, addr,
HTParentAnchor *, anchor,
int, bong)
{
char * access=NULL; /* Name of access method */
char * host = NULL;
struct Proxy *GetNoProxy();
extern int useKeepAlive;
HTAnchor_setPhysical(anchor, addr);
access = HTParse(HTAnchor_physical(anchor),
"file:", PARSE_ACCESS);
host = HTParse(HTAnchor_physical(anchor), "", PARSE_HOST);
/*
** set useKeepAlive to the default here because the last pass might
** have turned this off, and the default might have been on.
*/
/*
Init_useKeepAlive();
*/
useKeepAlive=1;
/* Check whether gateway access has been set up for this
*/
#define USE_GATEWAYS
#ifdef USE_GATEWAYS
/* make sure the using_proxy variable is false */
using_proxy = NO;
if (proxy_host_fix) {
free(proxy_host_fix);
proxy_host_fix=NULL;
}
{
char *tmp_access,*tmp_host,*ptr;
for (ptr=tmp_access=strdup(access); ptr && *ptr; ptr++) *ptr=tolower(*ptr);
for (ptr=tmp_host=strdup(host); ptr && *ptr; ptr++) *ptr=tolower(*ptr);
if (!GetNoProxy(tmp_access, tmp_host)) {
char *gateway_parameter, *gateway, *proxy;
struct Proxy *proxent = NULL, *GetProxy();
char *proxyentry = NULL;
proxy_host_fix=strdup(tmp_host);
/* search for gateways */
gateway_parameter = (char *)malloc(strlen(tmp_access)+20);
if (gateway_parameter == NULL) outofmem(__FILE__, "HTLoad");
strcpy(gateway_parameter, "WWW_");
strcat(gateway_parameter, tmp_access);
strcat(gateway_parameter, "_GATEWAY");
gateway = (char *)getenv(gateway_parameter); /* coerce for decstation */
/* search for proxy servers */
strcpy(gateway_parameter, tmp_access);
strcat(gateway_parameter, "_proxy");
proxy = (char *)getenv(gateway_parameter);
free(gateway_parameter);
/*
* Check the proxies list
*/
if ((proxy == NULL)||(proxy[0] == '\0')) {
int fMatchEnd;
char *scheme_info;
scheme_info =HTParse(HTAnchor_physical(anchor), "", PARSE_HOST);
fMatchEnd = 1; /* match hosts from the end */
if ((scheme_info != NULL) && (*scheme_info == '\0')) {
scheme_info = HTParse(HTAnchor_physical(anchor), "", PARSE_PATH);
fMatchEnd = 0; /* match other scheme_info at beginning*/
}
if (bong) { /* this one is bad - disable! */
proxent =
GetProxy(tmp_access, scheme_info, fMatchEnd);
if (proxent != NULL) proxent->alive = bong;
}
proxent = GetProxy(tmp_access, scheme_info, fMatchEnd);
if (proxent != NULL) {
useKeepAlive = 0; /* proxies don't keepalive */
StrAllocCopy(proxyentry, proxent->transport);
StrAllocCat(proxyentry, "://");
StrAllocCat(proxyentry, proxent->address);
StrAllocCat(proxyentry, ":");
StrAllocCat(proxyentry, proxent->port);
StrAllocCat(proxyentry, "/");
proxy = proxyentry;
}
}
#ifndef DIRECT_WAIS
if (!gateway && 0==strcmp(tmp_access, "wais")) {
gateway = DEFAULT_WAIS_GATEWAY;
}
#endif
/* proxy servers have precedence over gateway servers */
if (proxy) {
char * gatewayed;
gatewayed = NULL;
StrAllocCopy(gatewayed,proxy);
StrAllocCat(gatewayed,addr);
using_proxy = YES;
HTAnchor_setPhysical(anchor, gatewayed);
free(gatewayed);
free(access);
if (proxyentry)
free(proxyentry);
access = HTParse(HTAnchor_physical(anchor),
"http:", PARSE_ACCESS);
} else if (gateway) {
char * gatewayed;
gatewayed = NULL;
StrAllocCopy(gatewayed,gateway);
StrAllocCat(gatewayed,addr);
using_gateway = YES;
HTAnchor_setPhysical(anchor, gatewayed);
free(gatewayed);
free(access);
access = HTParse(HTAnchor_physical(anchor),
"http:", PARSE_ACCESS);
} else {
if (proxy_host_fix) {
free(proxy_host_fix);
}
proxy_host_fix=NULL;
using_proxy = NO;
using_gateway = NO;
ClearTempBongedProxies();
}
}
free(tmp_access);
free(tmp_host);
}
#endif
/* Search registered protocols to find suitable one
*/
{
int i, n;
if (!protocols) HTAccessInit();
n = HTList_count(protocols);
for (i=0; i<n; i++) {
HTProtocol *p = HTList_objectAt(protocols, i);
if (strcmp(p->name, access)==0) {
HTAnchor_setProtocol(anchor, p);
free(access);
return (HT_OK);
}
}
}
free(access);
return HT_NO_ACCESS;
}
/* Load a document
** ---------------
**
** This is an internal routine, which has an address AND a matching
** anchor. (The public routines are called with one OR the other.)
**
** On entry,
** addr must point to the fully qualified hypertext reference.
** anchor a pareent anchor with whose address is addr
**
** On exit,
** returns <0 Error has occured.
** HT_LOADED Success
** HT_NO_DATA Success, but no document loaded.
** (telnet sesssion started etc)
**
*/
PRIVATE int HTLoad ARGS4(
WWW_CONST char *, addr,
HTParentAnchor *, anchor,
HTFormat, format_out,
HTStream *, sink)
{
HTProtocol* p;
int ret, status = get_physical(addr, anchor, 0);
int retry=5;
static char *buf1="Do you want to disable the proxy server:\n\n";
static char *buf2="\n\nAlready attempted 5 contacts.";
char *finbuf,*host;
int fallbacks;
/*
* Yes...I know I'm only calling this to get the "name", but it is better
* than looping through all of the proxy list everytime a proxy fails!
* --SWP
*/
p = HTAnchor_protocol(anchor);
if (!p) {
return(HT_NOT_LOADED);
}
fallbacks=has_fallbacks(p->name);
while (1) {
if (status < 0) return status; /* Can't resolve or forbidden */
retry=5;
retry_proxy:
p = HTAnchor_protocol(anchor);
ret = (*(p->load))(HTAnchor_physical(anchor),
anchor, format_out, sink);
if (ret==HT_INTERRUPTED || HTCheckActiveIcon(0)==HT_INTERRUPTED) {
if (using_proxy) {
ClearTempBongedProxies();
}
return(HT_INTERRUPTED);
}
/*
* HT_REDIRECTING supplied by Dan Riley -- dsr@lns598.lns.cornell.edu
*/
if (!using_proxy || !fallbacks
|| ret == HT_LOADED || ret == HT_REDIRECTING
|| (ret == HT_NO_DATA && strncmp((char *)anchor, "telnet", 6) == 0)) {
if (using_proxy) {
ClearTempBongedProxies();
}
return(ret);
}
if (retry>0) {
retry--;
HTProgress("Retrying proxy server...");
goto retry_proxy;
}
/* must be using proxy and have a problem to get here! */
host=HTParse(HTAnchor_physical(anchor), "", PARSE_HOST);
finbuf=(char *)calloc((strlen(host)+
strlen(buf1)+
strlen(buf2)+
5),
sizeof(char));
sprintf(finbuf,"%s%s?%s",buf1,host,buf2);
if (HTConfirm(finbuf)) {
free(finbuf);
finbuf=(char *)calloc((strlen(host)+
strlen("Disabling proxy server ")+
strlen(" and trying again.")+
5),
sizeof(char));
sprintf(finbuf,"Disabling proxy server %s and trying again.",
host);
HTProgress(finbuf);
application_user_feedback(finbuf);
free(finbuf);
finbuf=NULL;
status = get_physical(addr, anchor, 1); /* Perm disable */
}
else if (HTConfirm("Try next fallback proxy server?")) {
status = get_physical(addr, anchor, 2); /* Temp disable */
}
/* else -- Try the same one again */
if (finbuf) {
free(finbuf);
}
}
}
/* Get a save stream for a document
** --------------------------------
*/
PUBLIC HTStream *HTSaveStream ARGS1(HTParentAnchor *, anchor)
{
HTProtocol * p = HTAnchor_protocol(anchor);
if (!p) return NULL;
return (*p->saveStream)(anchor);
}
/* Load a document - with logging etc
** ----------------------------------
**
** - Checks or documents already loaded
** - Logs the access
** - Allows stdin filter option
** - Trace ouput and error messages
**
** On Entry,
** anchor is the node_anchor for the document
** full_address The address of the document to be accessed.
** filter if YES, treat stdin as HTML
**
** On Exit,
** returns 1 Success in opening document
** 0 Failure
** -1 Interrupted
**
*/
/* This is exported all the way to gui-documents.c at the moment,
to tell mo_load_window_text when to use a redirected URL instead. */
char *use_this_url_instead;
PRIVATE int HTLoadDocument ARGS4(
WWW_CONST char *, full_address,
HTParentAnchor *, anchor,
HTFormat, format_out,
HTStream*, sink)
{
int status;
use_this_url_instead = NULL;
/* We LOVE goto's!
*
* Let's rephrase this..._You_ love goto's...we _abhore_ goto's. People who
* LOVE goto's should be shot.
*/
try_again:
#ifndef DISABLE_TRACE
if (www2Trace) fprintf (stderr,
"HTAccess: loading document %s\n", full_address);
#endif
status = HTLoad(full_address, anchor, format_out, sink);
if (status == HT_LOADED) {
#ifndef DISABLE_TRACE
if (www2Trace) {
fprintf(stderr, "HTAccess: `%s' has been accessed.\n",
full_address);
}
#endif
return 1;
}
if (status == HT_REDIRECTING)
{
/* Exported from HTMIME.c, of all places. */
extern char *redirecting_url;
#ifndef DISABLE_TRACE
if (www2Trace)
{
fprintf (stderr, "HTAccess: '%s' is a redirection URL.\n",
full_address);
fprintf (stderr, "HTAccess: Redirecting to '%s'\n",
redirecting_url);
}
#endif
full_address = redirecting_url;
use_this_url_instead = full_address;
goto try_again;
}
if (status == HT_INTERRUPTED)
{
#ifndef DISABLE_TRACE
if (www2Trace)
fprintf (stderr,
"HTAccess: We were interrupted.\n");
#endif
return -1;
}
if (status == HT_NO_DATA) {
#ifndef DISABLE_TRACE
if (www2Trace) {
fprintf(stderr,
"HTAccess: `%s' has been accessed, No data left.\n",
full_address);
}
#endif
return 0;
}
if (status<0) { /* Failure in accessing a document */
#ifndef DISABLE_TRACE
if (www2Trace) fprintf(stderr,
"HTAccess: Can't access `%s'\n", full_address);
#endif
return 0;
}
/* If you get this, then please find which routine is returning
a positive unrecognised error code! */
#ifndef DISABLE_TRACE
if (www2Trace)
fprintf(stderr,
"**** HTAccess: socket or file number %d returned by obsolete load routine!\n", status);
#endif
return 0;
} /* HTLoadDocument */
/* Load a document from absolute name
** ---------------
**
** On Entry,
** addr The absolute address of the document to be accessed.
** filter if YES, treat document as HTML
**
** On Exit,
** returns 1 Success in opening document
** 0 Failure
** -1 Interrupted
**
**
*/
PUBLIC int HTLoadAbsolute ARGS1(WWW_CONST char *,addr)
{
if (currentURL) {
free(currentURL);
}
currentURL=strdup(addr);
return HTLoadDocument( addr,
HTAnchor_parent(HTAnchor_findAddress(addr)),
HTOutputFormat ? HTOutputFormat : WWW_PRESENT,
HTOutputStream);
}
/* Load a document from absolute name to stream
** --------------------------------------------
**
** On Entry,
** addr The absolute address of the document to be accessed.
** sink if non-NULL, send data down this stream
**
** On Exit,
** returns YES Success in opening document
** NO Failure
**
**
*/
PUBLIC BOOL HTLoadToStream ARGS3(
WWW_CONST char *, addr,
BOOL, filter,
HTStream *, sink)
{
return HTLoadDocument(addr,
HTAnchor_parent(HTAnchor_findAddress(addr)),
HTOutputFormat ? HTOutputFormat : WWW_PRESENT,
sink);
}
/* Load a document from relative name
** ---------------
**
** On Entry,
** relative_name The relative address of the document
** to be accessed.
**
** On Exit,
** returns YES Success in opening document
** NO Failure
**
**
*/
PUBLIC BOOL HTLoadRelative ARGS2(
WWW_CONST char *, relative_name,
HTParentAnchor *, here)
{
char * full_address = 0;
BOOL result;
char * mycopy = 0;
char * stripped = 0;
char * current_address =
HTAnchor_address((HTAnchor*)here);
StrAllocCopy(mycopy, relative_name);
stripped = HTStrip(mycopy);
full_address = HTParse(stripped,
current_address,
PARSE_ACCESS|PARSE_HOST|PARSE_PATH|PARSE_PUNCTUATION);
result = HTLoadAbsolute(full_address);
free(full_address);
free(current_address);
free(mycopy);
return result;
}
Reference in New Issue View Git Blame Copy Permalink