HTAnchor * HTHistory_moveBy
ARGS1 (int,offset)
{
HTAnchor * last = HTList_objectAt (history, 1);
if (! last)
return NULL; /* No last visited node */
if (last != (HTAnchor *) last->parent) { /* Was a child */
HTList * kids = last->parent->children;
int i = HTList_indexOf (kids, last);
HTAnchor * nextOne = HTList_objectAt (kids, i - offset);
if (nextOne) {
HTAnchor * destination = HTAnchor_followMainLink (nextOne);
if (destination) {
HTList_removeLastObject (history);
HTList_removeLastObject (history);
HTList_addObject (history, nextOne);
HTList_addObject (history, destination);
}
return destination;
} else {
if (TRACE) fprintf(stderr,
"HTHistory_moveBy: offset by %+d goes out of list %p.\n",
offset, kids);
return NULL;
}
} else { /* Was a parent */
return NULL; /* FIXME we could possibly follow the next link... */
}
}
/* SERVER PUBLIC HTAA_authenticate()
** AUTHENTICATE USER
** ON ENTRY:
** req request.
** req->scheme used authentication scheme.
** HTAuthString
** the scheme specific parameters
** (authentication string for Basic and
** Pubkey schemes).
** global HTProt is the protection information structure
** for the file.
**
** ON EXIT:
** returns YES, if authentication succeeds and
** HTUser is set to point to the authenticated
** user. NO, if authentication fails.
*/
PUBLIC BOOL HTAA_authenticate ARGS1(HTRequest *, req)
{
if (HTAA_UNKNOWN == req->scheme || !HTProt ||
-1 == HTList_indexOf(HTProt->valid_schemes, (void*)req->scheme))
return NO;
HTUser = NULL;
switch (req->scheme) {
case HTAA_BASIC:
case HTAA_PUBKEY:
{
HTAAUser *user =
decompose_auth_string(HTAuthString, req->scheme);
/* Remember, user is auto-freed */
if (user &&
HTAA_checkPassword(user->username,
user->password,
HTAssocList_lookup(HTProt->values,
"passw")) &&
(HTAA_BASIC == req->scheme ||
(HTAA_checkTimeStamp(user->timestamp) &&
HTAA_checkInetAddress(user->inet_addr)))) {
HTUser = user;
return YES;
}
else return NO;
}
break;
default:
/* Other authentication routines go here */
return NO;
}
}
BOOL HTHistory_canMoveBy
ARGS1 (int,offset)
{
HTAnchor * last = HTList_objectAt (history, 1);
if (! last)
return NO; /* No last visited node */
if (last != (HTAnchor *) last->parent) { /* Was a child */
HTList * kids = last->parent->children;
int i = HTList_indexOf (kids, last);
return (HTList_objectAt (kids, i - offset) != NULL);
} else { /* Was a parent */
return NO; /* FIXME we could possibly follow the next link... */
}
}
/* Load a document
** ---------------
**
** On entry,
** addr must point to the fully qualified hypertext reference.
** This is the physsical address of the file
**
** On exit,
** returns <0 Error has occured.
** HTLOADED OK
**
*/
PUBLIC int HTLoadFile ARGS4 (
WWW_CONST char *, addr,
HTParentAnchor *, anchor,
HTFormat, format_out,
HTStream *, sink
)
{
char * filename;
HTFormat format;
int fd = -1; /* Unix file descriptor number = INVALID */
char * nodename = 0;
char * newname=0; /* Simplified name of file */
HTAtom * encoding; /* @@ not used yet */
int compressed;
extern char *HTgeticonname(HTFormat, char *);
/* Reduce the filename to a basic form (hopefully unique!)
*/
StrAllocCopy(newname, addr);
filename=HTParse(newname, "", PARSE_PATH|PARSE_PUNCTUATION);
nodename=HTParse(newname, "", PARSE_HOST);
free(newname);
format = HTFileFormat(filename, &encoding, WWW_PLAINTEXT, &compressed);
#ifdef vms
/* Assume that the file is in Unix-style syntax if it contains a '/'
after the leading one @@ */
{
char * vmsname = strchr(filename + 1, '/') ?
vms_name(nodename, filename) : filename + 1;
fd = open(vmsname, O_RDONLY, 0);
/* If the file wasn't VMS syntax, then perhaps it is ultrix
*/
if (fd<0) {
char ultrixname[INFINITY];
#ifndef DISABLE_TRACE
if (www2Trace) fprintf(stderr, "HTFile: Can't open as %s\n", vmsname);
#endif
sprintf(ultrixname, "%s::\"%s\"", nodename, filename);
fd = open(ultrixname, O_RDONLY, 0);
if (fd<0) {
#ifndef DISABLE_TRACE
if (www2Trace) fprintf(stderr,
"HTFile: Can't open as %s\n", ultrixname);
#endif
}
}
}
#else
free(filename);
/* For unix, we try to translate the name into the name of a transparently
** mounted file.
**
** Not allowed in secure (HTClienntHost) situations TBL 921019
*/
#ifndef NO_UNIX_IO
/* Need protection here for telnet server but not httpd server */
{ /* try local file system */
char * localname = HTLocalName(addr);
struct stat dir_info;
if (!localname)
goto suicide;
#ifdef GOT_READ_DIR
/* Multiformat handling
**
** If needed, scan directory to find a good file.
** Bug: we don't stat the file to find the length
*/
if ( (strlen(localname) > strlen(MULTI_SUFFIX))
&& (0==strcmp(localname + strlen(localname) - strlen(MULTI_SUFFIX),
MULTI_SUFFIX))) {
DIR *dp;
STRUCT_DIRENT * dirbuf;
float best = NO_VALUE_FOUND; /* So far best is bad */
HTFormat best_rep = NULL; /* Set when rep found */
STRUCT_DIRENT best_dirbuf; /* Best dir entry so far */
char * base = strrchr(localname, '/');
int baselen;
if (!base || base == localname) goto forget_multi;
*base++ = 0; /* Just got directory name */
baselen = strlen(base)- strlen(MULTI_SUFFIX);
base[baselen] = 0; /* Chop off suffix */
dp = opendir(localname);
if (!dp) {
forget_multi:
free(localname);
return HTLoadError(sink, 500,
"Multiformat: directory scan failed.");
}
while (dirbuf = readdir(dp)) {
/* while there are directory entries to be read */
if (dirbuf->d_ino == 0) continue;
/* if the entry is not being used, skip it */
if (!strncmp(dirbuf->d_name, base, baselen)) {
HTFormat rep = HTFileFormat(dirbuf->d_name, &encoding,
WWW_PLAINTEXT, &compressed);
float value = HTStackValue(rep, format_out,
HTFileValue(dirbuf->d_name),
0.0 /* @@@@@@ */);
if (value != NO_VALUE_FOUND) {
#ifndef DISABLE_TRACE
if (www2Trace) fprintf(stderr,
"HTFile: value of presenting %s is %f\n",
HTAtom_name(rep), value);
#endif
if (value > best) {
best_rep = rep;
best = value;
best_dirbuf = *dirbuf;
}
} /* if best so far */
} /* if match */
} /* end while directory entries left to read */
closedir(dp);
if (best_rep) {
format = best_rep;
base[-1] = '/'; /* Restore directory name */
base[0] = 0;
StrAllocCat(localname, best_dirbuf.d_name);
goto open_file;
} else { /* If not found suitable file */
free(localname);
return HTLoadError(sink, 403, /* List formats? */
"Could not find suitable representation for transmission.");
}
/*NOTREACHED*/
} /* if multi suffix */
/*
** Check to see if the 'localname' is in fact a directory. If it is
** create a new hypertext object containing a list of files and
** subdirectories contained in the directory. All of these are links
** to the directories or files listed.
** NB This assumes the existance of a type 'STRUCT_DIRENT', which will
** hold the directory entry, and a type 'DIR' which is used to point to
** the current directory being read.
*/
if (stat(localname,&dir_info) == -1) { /* get file information */
/* if can't read file information */
#ifndef DISABLE_TRACE
if (www2Trace) fprintf(stderr, "HTFile: can't stat %s\n", localname);
#endif
} else { /* Stat was OK */
if (((dir_info.st_mode) & S_IFMT) == S_IFDIR) {
/* if localname is a directory */
/*
**
** Read the localdirectory and present a nicely formatted list to the user
** Re-wrote most of the read directory code here, excepting for the checking
** access.
**
** Author: Charles Henrich ([email protected]) 10-09-93
**
** This is still pretty messy, need to go through and clean it up at some point
**
*/
/* Define some parameters that everyone should already have */
#ifndef MAXPATHLEN
#define MAXPATHLEN 1024
#endif
#ifndef BUFSIZ
#define BUFSIZ 4096
#endif
char filepath[MAXPATHLEN];
char buffer[4096];
char *ptr;
char *dataptr;
HText * HT;
HTFormat format;
HTAtom *pencoding;
struct stat statbuf;
STRUCT_DIRENT * dp;
DIR *dfp;
int cmpr;
int count;
#ifndef DISABLE_TRACE
if (www2Trace)
fprintf(stderr,"%s is a directory\n",localname);
#endif
/* Check directory access.
** Selective access means only those directories containing a
** marker file can be browsed
*/
if (HTDirAccess == HT_DIR_FORBID) {
free(localname);
return HTLoadError(sink, 403,
"Directory browsing is not allowed.");
}
if (HTDirAccess == HT_DIR_SELECTIVE) {
char * enable_file_name =
malloc(strlen(localname)+ 1 +
strlen(HT_DIR_ENABLE_FILE) + 1);
strcpy(enable_file_name, localname);
strcat(enable_file_name, "/");
strcat(enable_file_name, HT_DIR_ENABLE_FILE);
if (stat(enable_file_name, &statbuf) != 0) {
free(localname);
return HTLoadError(sink, 403,
"Selective access is not enabled for this directory.");
}
}
dfp = opendir(localname);
if (!dfp) {
free(localname);
return HTLoadError(sink, 403, "This directory is not readable.");
}
/* Suck the directory up into a list to be sorted */
HTSortInit();
for(dp=readdir(dfp);dp != NULL;dp=readdir(dfp))
{
ptr = malloc(strlen(dp->d_name)+1);
if(ptr == NULL)
{
return HTLoadError(sink, 403, "Ran out of memory in directory read!");
}
strcpy(ptr,dp->d_name);
HTSortAdd(ptr);
}
closedir(dfp);
/* Sort the dir list */
HTSortSort();
/* Start a new HTML page */
HT = HText_new();
HText_beginAppend(HT);
HText_appendText(HT, "<H1>Local Directory ");
HText_appendText(HT, localname);
HText_appendText(HT, "</H1>\n");
HText_appendText(HT,"<DL>\n");
/* Sort the list and then spit it out in a nice form */
/* How this for a disgusting loop :) */
for(count=0,dataptr=HTSortFetch(count);
dataptr != NULL;
free(dataptr), count++, dataptr=HTSortFetch(count))
{
/* We dont want to see . */
if(strcmp(dataptr,".") == 0) continue;
/* If its .. *and* the current directory is / dont show anything, otherwise
/* print out a nice Parent Directory entry.
/* */
if(strcmp(dataptr,"..") == 0)
{
if(strcmp(localname,"/") != 0)
{
strcpy(buffer,localname);
ptr = strrchr(buffer, '/');
if(ptr != NULL) *ptr='\0';
if(buffer[0] == '\0') strcpy(buffer,"/");
HText_appendText(HT,"<DD><A HREF=\"");
HText_appendText(HT, buffer);
HText_appendText(HT,"\"><IMG SRC=\"");
HText_appendText(HT, HTgeticonname(NULL, "directory"));
HText_appendText(HT,"\"> Parent Directory</a>");
continue;
}
else
{
continue;
}
}
/* Get the filesize information from a stat, if we cant stat it, we probably */
/* cant read it either, so ignore it. */
sprintf(filepath,"%s/%s",localname, dataptr);
if(stat(filepath, &statbuf) == -1) continue;
HText_appendText(HT,"<DD><A HREF=\"");
HText_appendText (HT, localname);
if(localname[strlen(localname)-1] != '/')
{
HText_appendText (HT, "/");
}
HText_appendText (HT, dataptr);
HText_appendText (HT, "\">");
/* If its a directory, dump out a dir icon, dont bother with anything else */
/* if it is a file try and figure out what type of file it is, and grab */
/* the appropriate icon. If we cant figure it out, call it text. If its */
/* a compressed file, call it binary no matter what */
if(statbuf.st_mode & S_IFDIR)
{
sprintf(buffer,"%s",dataptr);
HText_appendText(HT, "<IMG SRC=\"");
HText_appendText(HT, HTgeticonname(NULL, "directory"));
HText_appendText(HT, "\"> ");
}
else
{
sprintf(buffer,"%s (%d bytes)",
dataptr, (int)statbuf.st_size);
format = HTFileFormat(dataptr, &pencoding,
WWW_SOURCE, &cmpr);
/* If its executable then call it application, else it might as well be text */
if(cmpr == 0)
{
HText_appendText(HT, "<IMG SRC=\"");
if((statbuf.st_mode & S_IXUSR) ||
(statbuf.st_mode & S_IXGRP) ||
(statbuf.st_mode & S_IXOTH))
{
HText_appendText(HT,
HTgeticonname(format, "application"));
}
else
{
HText_appendText(HT,
HTgeticonname(format, "text"));
}
HText_appendText(HT, "\"> ");
}
else
{
HText_appendText(HT, "<IMG SRC=\"");
HText_appendText(HT, HTgeticonname(NULL, "application"));
HText_appendText(HT, "\"> ");
}
}
/* Spit out the anchor */
HText_appendText (HT, buffer);
HText_appendText (HT, "</A>\n");
}
/* End of list, clean up and we are done */
HText_appendText (HT, "</DL>\n");
HText_endAppend (HT);
free(localname);
return HT_LOADED;
} /* end if localname is directory */
} /* end if file stat worked */
/* End of directory reading section
*/
#endif
open_file:
{
FILE * fp = fopen(localname,"r");
#ifndef DISABLE_TRACE
if(www2Trace) fprintf (stderr, "HTFile: Opening `%s' gives %p\n",
localname, (void*)fp);
#endif
if (fp) { /* Good! */
if (HTEditable(localname)) {
HTAtom * put = HTAtom_for("PUT");
HTList * methods = HTAnchor_methods(anchor);
if (HTList_indexOf(methods, put) == (-1)) {
HTList_addObject(methods, put);
}
}
free(localname);
HTParseFile(format, format_out, anchor, fp, sink, compressed);
/*
This is closed elsewhere...SWP
fclose(fp);
*/
return HT_LOADED;
} /* If succesfull open */
} /* scope of fp */
} /* local unix file system */
#endif
#endif
/* Now, as transparently mounted access has failed, we try FTP.
*/
suicide:
/*
return HTFTPLoad(addr, anchor, format_out, sink);
*/
/* Sorry Charlie...if we are given a file:// URL and it fails, then it
fails! Do NOT FTP!! */
return HT_NOT_LOADED;
}
