archie/prospero/user/vcache/gopherget.c

471 lines
16 KiB
C
Raw Normal View History

2024-05-27 16:13:40 +02:00
/*
* 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;
}