471 lines
16 KiB
C
471 lines
16 KiB
C
/*
|
|
* Copyright (c) 1992, 1993 by the University of Southern California
|
|
*
|
|
* For copying and distribution information, please see the file <usc-copyr.h>.
|
|
*/
|
|
|
|
/* gopherget.c
|
|
Part of the program "vcache" in the Prospero distribution.
|
|
This allows Prospero clients to use the GOPHER access method (i.e., to
|
|
retrieve files sitting on Gopher servers.)
|
|
Written: swa@isi.edu, 7/13/92 -- 7/15/92
|
|
Comments improved 8/6/92
|
|
Gopher TEXT access method made considerably looser 6/30/93
|
|
Got rid of necessity for writev. 9/15/93
|
|
*/
|
|
|
|
#include <usc-copyr.h>
|
|
|
|
#include <stdio.h>
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#include <netdb.h>
|
|
#include <perrno.h>
|
|
|
|
#include <pmachine.h>
|
|
#ifdef HAVE_WRITEV
|
|
#include <sys/uio.h> /* for writev */
|
|
#endif
|
|
|
|
#include <pfs.h> /* for assert() and internal_error() */
|
|
#include "vcache_macros.h"
|
|
/* If it doesnt respond in 5 secs, its probably gone away */
|
|
#define G_READ_TIMEOUT 5
|
|
#define G_OPEN_TIMEOUT 5
|
|
|
|
|
|
extern int pfs_debug, cache_verbose;
|
|
|
|
/* Use the Gopher protocol. Get the file denoted by the SELECTOR_STRING
|
|
from the Gopher server running at port PORT of HOST. Stores that file in
|
|
the local file named LOCAL. Return non-zero on error; 0 if OK. If it
|
|
returns non-zero, the existence and contents of the file LOCAL are
|
|
indeterminate. (If this presents a problem, we'll have to rewrite the code
|
|
to do the unlinking). */
|
|
|
|
int
|
|
gopherget(char *host, char *local, char *selector_string, int port,
|
|
int gophertype /* actually char, but make sure default
|
|
promotions work. */ )
|
|
{
|
|
FILE *local_file; /* file pointer for local destination */
|
|
int remote_sock; /* File Descriptor for remote socket. */
|
|
int retval; /* error status return. */
|
|
static int vcache_open_tcp_stream(), send_line();
|
|
|
|
int (*retrieval_method)(); /* What method will we use to retrieve this
|
|
file? Null means none. */
|
|
/* function to call to find out Gopher retrieval method. */
|
|
/* precede 'gophertype' with an _ to get rid of bogus whines from GCC 2.5.8
|
|
with -Wshadow. */
|
|
static int (*get_retrieval_method(int _gophertype))();
|
|
|
|
|
|
TRACE(5, "vcache: Attempting to retrieve remote document \"%s\" \n\
|
|
via Gopher from port %d of host %s\n", selector_string, port, host);
|
|
|
|
retrieval_method = get_retrieval_method(gophertype);
|
|
if (!retrieval_method)
|
|
return 1; /* Failure. */
|
|
|
|
/* Open Local Destination file. Note that PFS has already been disabled.
|
|
*/
|
|
local_file = fopen(local, "w");
|
|
if (local_file == NULL) {
|
|
ERRSYS("vcache: Couldn't create the local file %s:%s %s ", local);
|
|
return 1;
|
|
}
|
|
|
|
/* Open TCP stream to remote gopher server. */
|
|
TRACE(5,"Calling vcache_open_tcp_stream(host = %s, port = %d)\n",
|
|
host, port);
|
|
if ((remote_sock = vcache_open_tcp_stream(host, port)) < 0) {
|
|
/* No need to set p_err_string, vcache_open_tcp_stream will */
|
|
fclose(local_file);
|
|
return 1;
|
|
}
|
|
|
|
TRACE(5,"Sending selector string to remote GOPHER: %s\n",
|
|
selector_string);
|
|
/* At this point, if any errors occur, we still try to clean up as neatly
|
|
as possible. */
|
|
retval = send_line(remote_sock, selector_string);
|
|
if (!retval)
|
|
retval = (*retrieval_method)(remote_sock, local_file);
|
|
if (!retval && cache_verbose)
|
|
puts("vcache: Retrieval completed.");
|
|
|
|
if (fclose(local_file)) {
|
|
TRACE(5, "vcache: Error attempting to close local file \
|
|
%s\n", local);
|
|
retval = 1;
|
|
}
|
|
|
|
/* Close down both ends of the connection. shutdown() allegedly performs
|
|
actions that close() defers. */
|
|
if (shutdown(remote_sock, 2)) {
|
|
ERRSYS("vcache: shutdown(remote_sock, 2) failed:%s %s");
|
|
retval = 1;
|
|
}
|
|
if (close(remote_sock)) {
|
|
ERRSYS("vcache: close(remote_sock) failed:%s %s");
|
|
retval = 1;
|
|
}
|
|
|
|
if (retval)
|
|
return 1; /* failure. */
|
|
else
|
|
return 0; /* Done. Success! */
|
|
}
|
|
|
|
|
|
/* Open a TCP stream from here to the HOST at the PORT. */
|
|
/* Return socket descriptor on success, or -1 on failure. */
|
|
/* On failure set p_err_string to "user" friendly error message */
|
|
static int
|
|
vcache_open_tcp_stream(char host[],int port)
|
|
{
|
|
TRACE(2,"vcache: quick_open_tcp_stream(host=%s;port=%d;time=%d)\n",
|
|
host, port, G_OPEN_TIMEOUT);
|
|
/* Dont need to set error message - quick_open_tcp_stream sets p_err_string
|
|
to user-friendly error message */
|
|
return(quick_open_tcp_stream(host,port, G_OPEN_TIMEOUT));
|
|
}
|
|
|
|
|
|
/* Send a line to the remote host. The line we're given is NOT crlf
|
|
terminated. */
|
|
/* We use writev because it's more efficient than two writes (and saves copying
|
|
operations). The Berkeley TCP implementation lacks a "push" command, so
|
|
there's an implicit push after each "write" or "writev". */
|
|
/* Return nonzero if failure; 0 if success */
|
|
static int
|
|
send_line(remote_sock, str)
|
|
int remote_sock; /* A connected TCP socket */
|
|
char str[];
|
|
{
|
|
int expected_count; /* # of bytes we expect to send. */
|
|
int bytes_sent; /* # of bytes we actually sent. */
|
|
#ifdef HAVE_WRITEV
|
|
struct iovec iov[2];
|
|
|
|
iov[0].iov_base = str;
|
|
iov[0].iov_len = strlen(str);
|
|
iov[1].iov_base = "\r\n";
|
|
iov[1].iov_len = 2;
|
|
expected_count = iov[0].iov_len + iov[1].iov_len;
|
|
|
|
/* Selector strings are short enough that we should never send a partial
|
|
packet. */
|
|
bytes_sent = writev(remote_sock, iov, 2);
|
|
#else
|
|
static char *buf = NULL;
|
|
|
|
buf = qsprintf_stcopyr(buf, "%s\r\n", str);
|
|
expected_count = strlen(buf);
|
|
|
|
/* Gopher selector strings are short enough that we should never send a
|
|
partial packet. */
|
|
bytes_sent = write(remote_sock, buf, expected_count);
|
|
#endif /* HAVE_WRITEV */
|
|
if (bytes_sent != expected_count) {
|
|
ERRSYS("vcache: Error sending selector string %s to gopher server. \
|
|
\tExpected to send %d bytes; write() or writev() reported sending only %d. %s %s",
|
|
str, expected_count, bytes_sent);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* Read a gopher text stream from in_sock and save it in out_file.
|
|
Gopher text lines are terminated with crlf.
|
|
Their last line consists of ".\r\n".
|
|
This is implemented as a simple DFA.
|
|
*/
|
|
/* 6/30/93:
|
|
We do full error recovery & don't complain by default, since I've now
|
|
learned that the format is followed rather loosely. Thus the LOOSE
|
|
definition. */
|
|
#define LOOSE
|
|
static
|
|
int
|
|
receive_gopher_text(in_sock, out)
|
|
int in_sock; /* Input socket for Gopher text */
|
|
FILE *out; /* Where to save the received text. */
|
|
{
|
|
char buf[BUFSIZ]; /* buffer for reading. */
|
|
register int numread; /* Number of bytes actually read. */
|
|
char *complaint = NULL; /* Might be set to a string that contains a
|
|
complaint about the remote format. This is
|
|
usually used for recoverable errors. */
|
|
enum states { BOL, /* Beginning of line */
|
|
GOT_BEG_DOT, /* Got '.' following BOL */
|
|
MID_LINE, /* middle of line */
|
|
GOT_DOT_CR, /* Got ".\r",Expect LF */
|
|
GOT_CR, /* Got CR; expect LF */
|
|
EOT, /* got ".\r\n" by itself */
|
|
#ifndef LOOSE
|
|
BAD /* something gross happened. We have
|
|
complained about it and are now just marking
|
|
time. */
|
|
#endif
|
|
} state;
|
|
|
|
state = BOL;
|
|
while((numread = quick_read(in_sock, buf, sizeof buf, G_READ_TIMEOUT)) > 0) {
|
|
register int i;
|
|
/* Process the characters we read. */
|
|
for (i = 0; i < numread; ++i) {
|
|
register char c = buf[i]; /* current character */
|
|
|
|
switch(state) {
|
|
case BOL:
|
|
#ifdef LOOSE
|
|
case_bol: /* a label to go to from EOT. */
|
|
#endif
|
|
switch(c) {
|
|
case '.':
|
|
state = GOT_BEG_DOT;
|
|
break;
|
|
case '\r':
|
|
state = GOT_CR;
|
|
break;
|
|
case '\n':
|
|
complaint = "Got LF without CR";
|
|
putc(c, out);
|
|
state = BOL;
|
|
break;
|
|
default:
|
|
putc(c, out);
|
|
state = MID_LINE;
|
|
break;
|
|
}
|
|
break;
|
|
case GOT_BEG_DOT:
|
|
if (c == '.') {
|
|
putc('.', out);
|
|
state = MID_LINE;
|
|
} else if (c == '\r') {
|
|
state = GOT_DOT_CR;
|
|
} else if (c == '\n') {
|
|
complaint = "Got LF without CR";
|
|
state = EOT;
|
|
} else {
|
|
complaint = "Got initial dot without following dot or EOL";
|
|
putc('.', out);
|
|
putc(c, out);
|
|
state = MID_LINE;
|
|
}
|
|
break;
|
|
case MID_LINE:
|
|
if (c == '\r') {
|
|
state = GOT_CR;
|
|
} else if (c == '\n') {
|
|
complaint = "Got LF without CR";
|
|
putc('\n', out);
|
|
state = BOL;
|
|
} else {
|
|
putc(c, out);
|
|
state = MID_LINE;
|
|
}
|
|
break;
|
|
case GOT_DOT_CR:
|
|
if (c != '\n') {
|
|
complaint = "Got . CR without LF";
|
|
#ifdef LOOSE
|
|
putc('.', out);
|
|
putc('\n', out);
|
|
goto case_bol;
|
|
#else
|
|
state = BAD;
|
|
#endif
|
|
} else {
|
|
state = EOT;
|
|
}
|
|
break;
|
|
case GOT_CR:
|
|
if (c != '\n') {
|
|
complaint = "Got CR without LF";
|
|
#ifdef LOOSE
|
|
putc('\n', out);
|
|
putc(c, out);
|
|
goto case_bol;
|
|
#else
|
|
state = BAD;
|
|
#endif
|
|
} else {
|
|
putc('\n', out);
|
|
state = BOL;
|
|
}
|
|
break;
|
|
case EOT:
|
|
/* If we get text after EOT, just keep on gobbling it up. This
|
|
is not a fatal error, merely a warning. */
|
|
complaint = "Got text after EOT";
|
|
#ifdef LOOSE
|
|
putc('.', out);
|
|
putc('\n', out);
|
|
goto case_bol;
|
|
#endif
|
|
break;
|
|
#ifndef LOOSE
|
|
case BAD: /* nothing more to do */
|
|
goto abort;
|
|
break;
|
|
#endif
|
|
default:
|
|
ERR("vcache: Internal error in line %d of file %s:\
|
|
unhandled case %s", __LINE__, __FILE__);
|
|
return(-1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
abort:
|
|
if (complaint && cache_verbose)
|
|
ERR("vcache: we encountered incorrect formatting when\
|
|
reading from remote server: %s. \
|
|
This is not a serious problem by itself, and the retrieval did not\
|
|
necessarily fail, but you should notify your system maintainer %s", complaint);
|
|
|
|
if (numread < 0) { /* If read() returned an error */
|
|
ERRSYS("vcache: read from remote gopher server failed:%s %s");
|
|
return -1;
|
|
}
|
|
|
|
#ifndef LOOSE
|
|
if (state == EOT) /* normal completion (possibly with warnings,
|
|
but all errors seem recoverable.) */
|
|
#endif
|
|
return 0; /* success */
|
|
|
|
#ifndef LOOSE
|
|
ERR(stderr, "vcache: Premature end of transmission while \
|
|
reading text from remote gopher server. %s");
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
/* Read a gopher binary stream from in_sock and save it in out_file.
|
|
Keep on consuming it until end of transmission. */
|
|
static
|
|
int
|
|
receive_gopher_binary(in_sock, out)
|
|
int in_sock; /* Input socket for Gopher text */
|
|
FILE *out; /* Where to save the received text. */
|
|
{
|
|
char buf[BUFSIZ]; /* buffer for reading & writing. */
|
|
register int numread; /* Number of bytes actually read. */
|
|
|
|
while((numread = quick_read(in_sock, buf, sizeof buf, G_READ_TIMEOUT)) > 0) {
|
|
/* We might be writing to a pipe, so we might not be able to write an
|
|
entire buffer at once.
|
|
Write out the buffer, possibly in multiple chunks. */
|
|
int i;
|
|
int numwritten;
|
|
for (i = 0; i < numread; i += numwritten) {
|
|
numwritten = fwrite(&buf[i], sizeof buf[0], numread - i, out);
|
|
if (numwritten == 0) { /* write error! */
|
|
ERR("vcache: receive_gopher_binary(): write error %s");
|
|
return -1; /* error */
|
|
}
|
|
}
|
|
}
|
|
if (numread == 0) /* EOF! */
|
|
return 0; /* success */
|
|
else if (numread < 0) { /* If read() returned an error */
|
|
ERRSYS("vcache: read from remote gopher server failed:%s %s");
|
|
return -1;
|
|
} else {
|
|
/* should never get here! */
|
|
ERR("vcache: Internal error at line %d of file %s. %s",
|
|
__LINE__, __FILE__);
|
|
return(-1);
|
|
/*NOTREACHED*/
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/* Check 1st character of gopher selector string to decide if retrieval
|
|
method is supported. If no retrieval method, punt.
|
|
This table of retrieval methods comes from Edward Vielmetti's 13 July 1992
|
|
article in alt.gopher.
|
|
*/
|
|
|
|
|
|
/*
|
|
These use the Gopher TEXT retrieval method.
|
|
0 A_FILE Text file.
|
|
4 A_MACHEX Macintosh Binhex (.hqx) text file.
|
|
c A_CALENDAR Calendar text file.
|
|
e A_EVENT Event text file.
|
|
M A_MIME MIME (RFC 1341) text file.
|
|
|
|
These use the Gopher BINARY retrieval method.
|
|
9 A_UNIXBIN Binary file.
|
|
g A_GIF GIF (Graphics Interchange Format) binary file.
|
|
s A_SOUND Sound (8 bit u-law, no headers ?) binary file.
|
|
|
|
|
|
things to do with data as it's flying back at you:
|
|
- treat as binary, read until connection drops,
|
|
send to file A_UNIXBIN
|
|
send to process A_SOUND
|
|
send to screen A_GIF
|
|
- treat as text, read til "." alone on line,
|
|
send to screen A_FILE
|
|
send to process A_MIME
|
|
A_CALENDAR
|
|
A_EVENT
|
|
send to file A_MACHEX
|
|
*/
|
|
/* In addition, the gopher protocol.txt document describes two obsolete types
|
|
(use of these types is discouraged) which Ed has not mentioned in his
|
|
letter. I'll include them in the table
|
|
below, because we want to support as many types as possible. They are:
|
|
Type 5: DOS binary archive of some kind (binary)
|
|
Type 6: UUencoded UNIX file (text).
|
|
*/
|
|
|
|
struct {
|
|
char type_char;
|
|
int (*func)();
|
|
char *name;
|
|
} retrieval_method_tab[] = {
|
|
{'0', receive_gopher_text, "GOPHER_TEXT"},
|
|
{'4', receive_gopher_text, "GOPHER_TEXT"},
|
|
{'c', receive_gopher_text, "GOPHER_TEXT"},
|
|
{'e', receive_gopher_text, "GOPHER_TEXT"},
|
|
{'M', receive_gopher_text, "GOPHER_TEXT"},
|
|
{'9', receive_gopher_binary, "GOPHER_BINARY"},
|
|
{'g', receive_gopher_binary, "GOPHER_BINARY"},
|
|
{'s', receive_gopher_binary, "GOPHER_BINARY"},
|
|
{'5', receive_gopher_binary, "GOPHER_BINARY"},
|
|
{'6', receive_gopher_text, "GOPHER_TEXT" },
|
|
{'\0', NULL, NULL}
|
|
};
|
|
|
|
|
|
static
|
|
int
|
|
(*get_retrieval_method(int gophertype))() /* actually char. */
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; retrieval_method_tab[i].type_char != '\0'; ++i) {
|
|
if (gophertype == retrieval_method_tab[i].type_char) {
|
|
TRACE(5,"Using retrieval method: %s\n",
|
|
retrieval_method_tab[i].name);
|
|
return retrieval_method_tab[i].func;
|
|
}
|
|
}
|
|
ERR("vcache: Can't retrieve document -- item type %c \
|
|
unsupported. %s", gophertype);
|
|
return NULL;
|
|
}
|