char *LYKeycodeToString(int c,
int upper8)
{
static char buf[30];
unsigned n;
BOOLEAN named = FALSE;
for (n = 0; n < TABLESIZE(named_keys); n++) {
if (named_keys[n].key == c) {
named = TRUE;
LYStrNCpy(buf, named_keys[n].name, sizeof(buf) - 1);
break;
}
}
if (!named) {
if (c <= 0377
&& TOASCII(c) > TOASCII(' ')
&& TOASCII(c) < 0177)
sprintf(buf, "%c", c);
else if (upper8
&& TOASCII(c) > TOASCII(' ')
&& c <= 0377
&& c <= LYlowest_eightbit[current_char_set])
sprintf(buf, "%c", c);
else if (TOASCII(c) < TOASCII(' '))
sprintf(buf, "^%c", FROMASCII(TOASCII(c) | 0100));
else if (c >= 0400)
sprintf(buf, "key-0x%x", c);
else
sprintf(buf, "0x%x", c);
}
return buf;
}
double FileDownloadTask::GetDownloadSize()
{
CURL *curl = curl_easy_init();
curl_easy_setopt(curl, CURLOPT_URL, TOASCII(m_src));
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, CurlBlankCallback);
curl_easy_setopt(curl, CURLOPT_NOBODY, true);
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, true);
curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 20);
if (curl_easy_perform(curl) != 0)
return -1;
long responseCode = 0;
double contentLen = 0;
curl_easy_getinfo(curl, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &contentLen);
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &responseCode);
curl_easy_cleanup(curl);
if (responseCode == 404 || responseCode == 403 || responseCode == 500)
return -responseCode;
else
return contentLen;
}
CURL* InitCurlHandle()
{
CURL* curl = curl_easy_init();
if (settings->GetProxyType() != Proxy_None)
{
curl_easy_setopt(curl, CURLOPT_PROXY, TOASCII(settings->GetProxyHostName()));
curl_easy_setopt(curl, CURLOPT_PROXYPORT, settings->GetProxyPort());
switch (settings->GetProxyType())
{
case Proxy_HTTP:
curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
break;
case Proxy_SOCKS4:
curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
break;
case Proxy_SOCKS5:
if (settings->GetProxyDNS())
curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5_HOSTNAME);
else
curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
break;
}
}
return curl;
}
/* Send a string down a socket
** ---------------------------
**
** The trailing zero is not sent.
** There is a maximum string length.
*/
PRIVATE int write_ascii(int soc, char * s)
{
char * p;
char ascii[255];
char *q = ascii;
for (p=s; *p; p++) {
*q++ = TOASCII(*p);
}
return write(soc, ascii, p-s);
}
/* Send a string down a socket
** ---------------------------
**
** The trailing zero is not sent.
** There is a maximum string length.
*/
PUBLIC int HTWriteASCII ARGS2(int, soc, char *, s)
{
#ifdef NOT_ASCII
char * p;
char ascii[255];
char *q = ascii;
for (p=s; *p; p++) {
*q++ = TOASCII(*p);
}
return NETWRITE(soc, ascii, p-s);
#else
return NETWRITE(soc, s, strlen(s));
#endif
}
BuildTag::BuildTag(const wxString &str)
{
wxArrayString strings = wxStringTokenize(str, _T("-"));
if (strings.GetCount() >= 3)
{
m_buildType = strings[0];
m_jobName = strings[1];
m_buildNumber = atoi(TOASCII(strings[strings.GetCount() - 1]));
}
else
{
m_buildType = _T("CustomBuild");
m_jobName = _T("MultiMC");
m_buildNumber = 0;
}
}
PRIVATE int response ARGS1(CONST char *,command)
{
int result;
char * p = response_text;
if (command) {
int status;
int length = strlen(command);
if (TRACE) fprintf(stderr, "NNTP command to be sent: %s", command);
#ifdef NOT_ASCII
{
CONST char * p;
char * q;
char ascii[LINE_LENGTH+1];
for(p = command, q=ascii; *p; p++, q++) {
*q = TOASCII(*p);
}
status = NETWRITE(s, ascii, length);
}
#else
status = NETWRITE(s, command, length);
#endif
if (status<0){
if (TRACE) fprintf(stderr,
"HTNews: Unable to send command. Disconnecting.\n");
NETCLOSE(s);
s = -1;
return status;
} /* if bad status */
} /* if command to be sent */
for(;;) {
if (((*p++=NEXT_CHAR) == '\n') || (p == &response_text[LINE_LENGTH])) {
*p++=0; /* Terminate the string */
if (TRACE) fprintf(stderr, "NNTP Response: %s\n", response_text);
sscanf(response_text, "%d", &result);
return result;
} /* if end of line */
if (*(p-1) < 0) {
if (TRACE) fprintf(stderr,
"HTNews: EOF on read, closing socket %d\n", s);
NETCLOSE(s); /* End of file, close socket */
return s = -1; /* End of file on response */
}
} /* Loop over characters */
}
/* HTCleanTelnetString()
* Make sure that the given string doesn't contain characters that
* could cause security holes, such as newlines in ftp, gopher,
* news or telnet URLs; more specifically: allows everything between
* ASCII 20-7E, and also A0-FE, inclusive. Also TAB ('\t') allowed!
*
* On entry,
* str the string that is *modified* if necessary. The
* string will be truncated at the first illegal
* character that is encountered.
* On exit,
* returns YES, if the string was modified.
* NO, otherwise.
*/
PUBLIC BOOL HTCleanTelnetString (char * str)
{
char * cur = str;
if (!str) return NO;
while (*cur) {
int a = TOASCII((unsigned char) *cur);
if (a != 0x9 && (a < 0x20 || (a > 0x7E && a < 0xA0) || a > 0xFE)) {
HTTRACE(URI_TRACE, "Illegal..... character in URL: \"%s\"\n" _ str);
*cur = 0;
HTTRACE(URI_TRACE, "Truncated... \"%s\"\n" _ str);
return YES;
}
cur++;
}
return NO;
}
int EditBinding(int xlkc)
{
int editaction, xleac = LYE_UNMOD;
int c = xlkc & LKC_MASK;
if (xlkc == -1)
return LYE_NOP; /* maybe LYE_ABORT? or LYE_FORM_LAC|LYK_UNKNOWN? */
#ifdef NOT_ASCII
if (c < 256) {
c = TOASCII(c);
}
#endif
#ifdef USE_ALT_BINDINGS
/*
* Get intermediate code from one of the lynxkeycode+modifier tables if
* applicable, otherwise get the lynxeditactioncode directly. If we have
* more than one modifier bits, the first currently wins. - kw
*/
if (xlkc & LKC_ISLECLAC) {
return LKC2_TO_LEC(xlkc);
} else if (xlkc & LKC_MOD1) {
xleac = LKC_TO_LEC_M1(c);
} else if (xlkc & LKC_MOD2) {
xleac = LKC_TO_LEC_M2(c);
} else if (xlkc & LKC_MOD3) {
xleac = LKC_TO_LEC_M3(c);
} else {
xleac = UCH(CurrentLineEditor()[c]);
}
#endif
/*
* If we have an intermediate code that says "same as without modifier",
* look that up now; otherwise we are already done. - kw
*/
if (xleac == LYE_UNMOD) {
editaction = CurrentLineEditor()[c];
} else {
editaction = xleac;
}
return editaction;
}
wxThread::ExitCode FileDownloadTask::TaskStart()
{
if (m_message.IsEmpty())
SetStatus(wxString::Format(_("Downloading file from %s..."), m_src.c_str()));
else
SetStatus(m_message);
double downloadSize = GetDownloadSize();
if (downloadSize < 0)
{
successful = false;
wxString baseError = _("An error occurred when downloading the file.\n");
switch (-(int)downloadSize)
{
case 404:
EmitErrorMessage(baseError + _("Error 404, the page could not be found."));
return (ExitCode)0;
default:
EmitErrorMessage(baseError + wxString::Format(_("Unknown error %i occurred."), -(int)downloadSize));
return (ExitCode)0;
}
}
CURL *curl = curl_easy_init();
curl_easy_setopt(curl, CURLOPT_URL, TOASCII(m_src));
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, CurlLambdaCallback);
curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, true);
curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 20);
size_t downloadedSize = 0;
wxFFileOutputStream outStream(m_dest.GetFullPath());
CurlLambdaCallbackFunction curlWrite = [&] (void *buffer, size_t size) -> size_t
{
outStream.Write(buffer, size);
size_t lastwrite = outStream.LastWrite();
downloadedSize += lastwrite;
int progress = ((double)downloadedSize / (double)downloadSize) * 100;
SetProgress(progress);
wxString sDownloadedSize = _("???");
if(progress >= 100 || downloadedSize > downloadSize)
{
sDownloadedSize = wxString::Format(wxT("%.0f"), (float)(downloadSize / 1000));
}
else
{
sDownloadedSize = wxString::Format(wxT("%.0f"), (float)(downloadedSize / 1000));
}
wxString sDownloadSize = wxString::Format(wxT("%.0f"), (float)(downloadSize / 1000));
SetStatus(wxString::Format(_("Downloading...\n(%skB/%skB)"), sDownloadedSize.c_str(), sDownloadSize.c_str()));
return outStream.LastWrite();
};
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &curlWrite);
int curlErr = curl_easy_perform(curl);
curl_easy_cleanup(curl);
if (curlErr != 0)
{
EmitErrorMessage(_("Download failed."));
successful = false;
return (ExitCode)0;
}
else
{
successful = true;
return (ExitCode)1;
}
}
/* PUBLIC HTAA_getUnfoldedLine()
* READ AN UNFOLDED HEADER LINE FROM SOCKET
* ON ENTRY:
* HTAA_setupReader must absolutely be called before
* this function to set up internal buffer.
*
* ON EXIT:
* returns a newly-allocated character string representing
* the read line. The line is unfolded, i.e.
* lines that begin with whitespace are appended
* to current line. E.g.
*
* Field-Name: Blaa-Blaa
* This-Is-A-Continuation-Line
* Here-Is_Another
*
* is seen by the caller as:
*
* Field-Name: Blaa-Blaa This-Is-A-Continuation-Line Here-Is_Another
*
*/
char *HTAA_getUnfoldedLine(void)
{
char *line = NULL;
char *cur;
int count;
BOOL peek_for_folding = NO;
if (in_soc < 0) {
CTRACE((tfp, "%s %s\n",
"HTAA_getUnfoldedLine: buffer not initialized",
"with function HTAA_setupReader()"));
return NULL;
}
for (;;) {
/* Reading from socket */
if (start_pointer >= end_pointer) { /*Read the next block and continue */
#ifdef USE_SSL
if (SSL_handle)
count = SSL_read(SSL_handle, buffer, BUFFER_SIZE);
else
count = NETREAD(in_soc, buffer, BUFFER_SIZE);
#else
count = NETREAD(in_soc, buffer, BUFFER_SIZE);
#endif /* USE_SSL */
if (count <= 0) {
in_soc = -1;
return line;
}
if (count > (int) buffer_length)
count = (int) buffer_length;
start_pointer = buffer;
end_pointer = buffer + count;
*end_pointer = '\0';
#ifdef NOT_ASCII
cur = start_pointer;
while (cur < end_pointer) {
*cur = TOASCII(*cur);
cur++;
}
#endif /*NOT_ASCII */
}
cur = start_pointer;
/* Unfolding */
if (peek_for_folding) {
if (*cur != ' ' && *cur != '\t')
return line; /* Ok, no continuation line */
else /* So this is a continuation line, continue */
peek_for_folding = NO;
}
/* Finding end-of-line */
while (cur < end_pointer && *cur != '\n') /* Find the end-of-line */
cur++; /* (or end-of-buffer). */
/* Terminating line */
if (cur < end_pointer) { /* So *cur==LF, terminate line */
*cur = '\0'; /* Overwrite LF */
if (*(cur - 1) == '\r')
*(cur - 1) = '\0'; /* Overwrite CR */
peek_for_folding = YES; /* Check for a continuation line */
}
/* Copying the result */
if (line)
StrAllocCat(line, start_pointer); /* Append */
else
StrAllocCopy(line, start_pointer); /* A new line */
start_pointer = cur + 1; /* Skip the read line */
} /* forever */
}
PRIVATE void parse_menu ARGS2 (
CONST char *, arg,
HTParentAnchor *,anAnchor)
{
char gtype;
char ch;
char line[BIG];
char address[BIG];
char *name, *selector; /* Gopher menu fields */
char *host;
char *port;
char *p = line;
#define TAB '\t'
#define HEX_ESCAPE '%'
if (!HTAnchor_title(anAnchor))
HTAnchor_setTitle(anAnchor, arg);/* Tell user something's happening */
node_anchor = anAnchor;
HT = HText_new(anAnchor);
HText_beginAppend(HT);
HText_appendText(HT, "Select one of:<P>\n<UL>");
/* HText_appendText(HT, "Select one of:<P>\n<UL>"); */
while ((ch=NEXT_CHAR) != (char)EOF)
{
if (ch != '\n')
{
*p = ch; /* Put character in line */
if (p< &line[BIG-1]) p++;
}
else
{
*p++ = 0; /* Terminate line */
p = line; /* Scan it to parse it */
port = 0; /* Flag "not parsed" */
if (TRACE) fprintf(stderr, "HTGopher: Menu item: %s\n", line);
gtype = *p++;
/* Break on line with a dot by itself */
if ((gtype=='.') && ((*p=='\r') || (*p==0))) break;
if (gtype && *p)
{
name = p;
selector = strchr(name, TAB);
if (selector) {
*selector++ = 0; /* Terminate name */
host = strchr(selector, TAB);
if (host) {
*host++ = 0; /* Terminate selector */
port = strchr(host, TAB);
if (port) {
char *junk;
port[0] = ':'; /* delimit host a la W3 */
junk = strchr(port, 13 /* was TAB */);
if (junk) *junk++ = 0; /* Chop port */
if ((port[1]=='0') && (!port[2]))
port[0] = 0; /* 0 means none */
} /* no port */
} /* host ok */
} /* selector ok */
} /* gtype and name ok */
if (gtype == GOPHER_WWW)
{ /* Gopher pointer to W3 */
HText_appendText(HT, "<LI> ");
write_anchor(name, selector);
HText_appendText(HT, "\n");
/* HText_appendParagraph(HT); */
}
else if (port)
{ /* Other types need port */
if (gtype == GOPHER_TELNET)
{
if (*selector)
sprintf(address, "telnet://%s@%s/",
selector, host);
else
sprintf(address, "telnet://%s/", host);
}
else if (gtype == GOPHER_TN3270)
{
if (*selector)
sprintf(address, "tn3270://%s@%s/",
selector, host);
else
sprintf(address, "tn3270://%s/", host);
}
else
{ /* If parsed ok */
char *q;
char *p;
sprintf(address, "gopher://%s/%c", host, gtype);
q = address+ strlen(address);
for(p=selector; *p; p++) { /* Encode selector string */
/* fprintf (stderr, "Checking %d (%c) for acceptable.\n",
*p, *p); */
if (acceptable[*p]) *q++ = *p;
else {
*q++ = HEX_ESCAPE; /* Means hex coming */
*q++ = hex[(TOASCII(*p)) >> 4];
*q++ = hex[(TOASCII(*p)) & 15];
}
}
*q++ = 0; /* terminate address */
}
/* HText_appendText(HT, " "); */ /* Prettier JW/TBL */
HText_appendText(HT, "<LI> ");
/* Error response from Gopher doesn't deserve to
be a hyperlink. */
if (strcmp (address, "gopher://error.host:1/0"))
write_anchor(name, address);
else
HText_appendText(HT, name);
HText_appendText(HT, "\n");
/* HText_appendParagraph(HT); */
}
else
{ /* parse error */
if (TRACE) fprintf(stderr,
"HTGopher: Bad menu item.\n");
HText_appendText(HT, line);
HText_appendParagraph(HT);
} /* parse error */
p = line; /* Start again at beginning of line */
} /* if end of line */
} /* Loop over characters */
/* Write to the socket
**
** According to Solaris 2.3 man on write:
**
** o If O_NONBLOCK and O_NDELAY are clear, write() blocks
** until the data can be accepted.
**
** o If O_NONBLOCK or O_NDELAY is set, write() does not
** block the process. If some data can be written
** without blocking the process, write() writes what it
** can and returns the number of bytes written. Other-
** wise, if O_NONBLOCK is set, it returns - 1 and sets
** errno to EAGAIN or if O_NDELAY is set, it returns 0.
**
** According to SunOS 4.1.1 man on write:
**
** + If the descriptor is marked for non-blocking I/O
** using fcntl() to set the FNONBLOCK or O_NONBLOCK
** flag (defined in <sys/fcntl.h>), write() requests
** for {PIPE_BUF} (see pathconf(2V)) or fewer bytes
** either succeed completely and return nbyte, or
** return -1 and set errno to EAGAIN. A write() request
** for greater than {PIPE_BUF} bytes either transfers
** what it can and returns the number of bytes written,
** or transfers no data and returns -1 and sets errno
** to EAGAIN. If a write() request is greater than
** {PIPE_BUF} bytes and all data previously written to
** the pipe has been read, write() transfers at least
** {PIPE_BUF} bytes.
*/
PRIVATE int HTWriter_write (HTOutputStream * me, const char * buf, int len)
{
HTHost * host = me->host;
SOCKET soc = HTChannel_socket(HTHost_channel(host));
HTNet * net = HTHost_getWriteNet(host);
int b_write;
char * wrtp;
const char *limit = buf+len;
/* If we don't have a Net object then return right away */
if (!net) {
HTTRACE(STREAM_TRACE, "Write Socket No Net object %d (offset %d)\n" _ soc _ me->offset);
return HT_ERROR;
}
#ifdef NOT_ASCII
if (len && !me->ascbuf) { /* Generate new buffer */
const char *orig = buf;
char *dest;
int cnt;
if ((me->ascbuf = (char *) HT_MALLOC(len)) == NULL)
HT_OUTOFMEM("HTWriter_write");
dest = me->ascbuf;
for (cnt=0; cnt<len; cnt++) {
*dest = TOASCII(*orig);
dest++, orig++;
}
wrtp = me->ascbuf;
limit = me->ascbuf+len;
}
#else
if (!me->offset)
wrtp = (char *) buf;
else {
wrtp = (char *) buf + me->offset;
len -= me->offset;
me->offset = 0;
}
#endif
/* Write data to the network */
while (wrtp < limit) {
if ((b_write = NETWRITE(soc, wrtp, len)) < 0) {
#ifdef EAGAIN
if (socerrno == EAGAIN || socerrno == EWOULDBLOCK)/* POSIX, SVR4 */
#else
if (socerrno == EWOULDBLOCK) /* BSD */
#endif
{
HTHost_register(host, net, HTEvent_WRITE);
me->offset = wrtp - buf;
HTTRACE(STREAM_TRACE, "Write Socket WOULD BLOCK %d (offset %d)\n" _ soc _ me->offset);
return HT_WOULD_BLOCK;
#ifdef EINTR
} else if (socerrno == EINTR) {
/*
** EINTR A signal was caught during the write opera-
** tion and no data was transferred.
*/
HTTRACE(STREAM_TRACE, "Write Socket call interrupted - try again\n");
continue;
#endif
} else {
host->broken_pipe = YES;
#ifdef EPIPE
if (socerrno == EPIPE) {
/* JK: an experimental bug solution proposed by
Olga and Mikhael */
HTTRACE(STREAM_TRACE, "Write Socket got EPIPE\n");
HTHost_unregister(host, net, HTEvent_WRITE);
HTHost_register(host, net, HTEvent_CLOSE);
/* @@ JK: seems that some functions check the errors
as part of the flow control */
HTRequest_addSystemError(net->request, ERR_FATAL, socerrno, NO,
"NETWRITE");
return HT_CLOSED;
}
#endif /* EPIPE */
/* all errors that aren't EPIPE */
HTRequest_addSystemError(net->request, ERR_FATAL, socerrno, NO,
"NETWRITE");
return HT_ERROR;
}
}
/* We do this unconditionally, should we check to see if we ever blocked? */
HTTRACEDATA(wrtp, b_write, "Writing to socket %d" _ soc);
HTNet_addBytesWritten(net, b_write);
wrtp += b_write;
len -= b_write;
HTTRACE(STREAM_TRACE, "Write Socket %d bytes written to %d\n" _ b_write _ soc);
{
HTAlertCallback *cbf = HTAlert_find(HT_PROG_WRITE);
if (cbf) {
int tw = HTNet_bytesWritten(net);
(*cbf)(net->request, HT_PROG_WRITE,
HT_MSG_NULL, NULL, &tw, NULL);
}
}
}
#ifdef NOT_ASCII
HT_FREE(me->ascbuf);
#endif
return HT_OK;
}
/* Handle one message
** ------------------
**
** On entry,
** soc A file descriptor for input and output.
** On exit,
** returns >0 Channel is still open.
** 0 End of file was found, please close file
** <0 Error found, please close file.
*/
int handle(int soc)
{
#define COMMAND_SIZE 255
#define MAX_LINES 10000 /* Maximum number of lines returned */
char command[COMMAND_SIZE+1];
char buffer[BUFFER_SIZE];
int status;
char * arg; /* Pointer to the argument string */
char * filename; /* Pointer to filename or group list*/
char * keywords; /* pointer to keywords */
char system_command[COMMAND_SIZE+1];
int lines; /* Number of lines returned by EXEC file */
int fd; /* File descriptor number */
int isIndex = 0; /* Is the thing asked for an index? */
for (;;) {
status = read(soc, command, COMMAND_SIZE);
if (status<=0) {
if (TRACE) printf("read returned %i, errno=%i\n", status, errno);
return status; /* Return and close file */
}
command[status]=0; /* terminate the string */
#ifdef VM
{
char * p;
for (p=command; *p; p++) {
*p = FROMASCII(*p);
if (*p == '\n') *p = ' ';
}
}
#endif
if (TRACE) printf("read string is `%s'\n", command);
arg=strchr(command,' ');
if (arg) {
*arg++ = 0; /* Terminate command */
arg = strip(arg); /* Strip space */
if (0==strcmp("GET", command)) { /* Get a file */
/* Remove host and any punctuation. (Could use HTParse to remove access too @)
*/
filename = arg;
if (arg[0]=='/') {
if (arg[1]=='/') {
filename = strchr(arg+2, '/'); /* Skip //host/ */
if (!filename) filename=arg+strlen(arg);
} else {
filename = arg+1; /* Assume root: skip slash */
}
}
if (*filename) { /* (else return test message) */
keywords=strchr(filename, '?');
if (keywords) *keywords++=0; /* Split into two */
#ifdef VM
/* Formats supported by FIND are:
**
** /FIND Help for find general index
** /FIND/ (same)
** /FIND/? (same)
** /FIND/group.disk.ft.fn Get a document from a disk- NOT INDEX
** /FIND/grouplist? Help for group index
** /FIND/grouplist?keylist Search a set of disks for keywords
** where grouplist = group+group+group.. or void
** keylist = key+key+key... (not void)
*/
if((
(0==strncmp(filename,"FIND",4))
|| (0==strncmp(filename,"find",4))
) && (
(filename[4]==0)
|| (filename[4]=='/')
|| (filename[4]='?')
)) {
filename=filename+4;
if (*filename=='/') filename++; /* Skip first slash */
if (!*filename) { /* If no data at all, */
if (!keywords)
keywords = filename; /* Respond as if just "?" given */
}
if (keywords) {
char *p;
while((p=strchr(filename,'+'))!=0) *p=' ';/* Remove +s */
while((p=strchr(keywords,'+'))!=0) *p=' ';/* Remove +s */
if (!*keywords) { /* If no keywords */
write_ascii(soc, "<IsIndex><TITLE>");
write_ascii(soc, filename);
write_ascii(soc, " keyword index</TITLE>\n");
if (*filename) {
write_ascii(soc, "This index covers groups: `");
write_ascii(soc, filename);
write_ascii(soc, "'");
} else {
write_ascii(soc,
"This is the general CERN public document index");
}
write_ascii(soc,
".<P>You may use your browser's keyword search on this index.<P>\n");
return 0;
}
strcpy(system_command,"EXEC NICFIND1 ");
strcat(system_command, keywords);
if (*filename) {
strcat(system_command, " ( ");
strcat(system_command, filename);
}
isIndex = 1;
} else {
strcpy(system_command,"EXEC NICFOUN1 ");
strcat(system_command, filename);
isIndex = 0;
}
} /* if FIND */
/* Formats supported by NEWS are:
**
** /NEWS General news
** /NEWS/grouplist News for given groups
** /NEWS/grouplist? All news for all given groups
** /NEWS/grouplist?keylist Search news for keywords
** where grouplist = group+group+group.. or void
** keylist = key+key+key... (can be void)
*/
else if((
(0==strncmp(filename,"NEWS",4))
|| (0==strncmp(filename,"news",4))
) && (
(filename[4]==0)
|| (filename[4]=='/')
|| (filename[4]='?')
)) {
isIndex = 1;
filename=filename+4;
if (*filename=='/') filename++; /* Skip first slash */
if (!*filename) { /* If no data at all, */
if (!keywords)
keywords = filename; /* Respond as if just "?" given */
}
if (!keywords) keywords = ""; /* "If nun, write none"-1066 */
{
char *p;
while((p=strchr(filename,'+'))!=0) *p=' ';/* Remove +s */
while((p=strchr(keywords,'+'))!=0) *p=' ';/* Remove +s */
strcpy(system_command,"EXEC NICFIND1 ");
if (keywords) strcat(system_command, keywords);
strcat(system_command, " ( NEWS ");
if (*filename) {
strcat(system_command, "(");
strcat(system_command, filename);
strcat(system_command, ") ");
}
}
} else { /* not FIND or NEWS */
write_ascii(soc, "Bad syntax. No such document.\n");
return 0;
}
/* Execute system command and get the results
*/
lines = system(system_command);
if (TRACE) printf("Command `%s' returned %i lines.\n",
system_command, lines);
if (lines<=0) {
write_ascii(soc,
"\nSorry, the FIND server could not execute\n `");
write_ascii(soc, system_command);
write_ascii(soc, "'\n\n");
return 0;
}
/* Copy the file across: */
if (isIndex) write_ascii(soc, "<IsIndex>\n");
for(;lines; lines--){ /* Speed necessary here */
char *p;
fgets(buffer, BUFFER_SIZE, stdin);
/* if (strcmp(buffer,"<END_OF_FILE>")==0) break; */
for(p=buffer; *p; p++) *p = TOASCII(*p);
write(soc, buffer, p-buffer);
}
return 0;
#else
fd = open(arg, O_RDONLY, 0 ); /* un*x open @@ */
if (fd<0) return fd;
status = read_file(soc, fd);
close(fd);
return 0;
#endif
}
}
}
write_ascii(soc, "<h1>FIND Server v1.03</h1><h2>Test response</h2>\n");
write_ascii(soc, "\n\nThe (unrecognised) command used was `");
write_ascii(soc, command);
write_ascii(soc, "'.\n\n");
if (TRACE) printf("Return test string written back'\n");
return 0; /* End of file - please close socket */
} /* for */
} /* handle */
/* Load Document from HTTP Server HTLoadHTTP()
** ==============================
**
** Given a hypertext address, this routine loads a document.
**
**
** On entry,
** arg is the hypertext reference of the article to be loaded.
** gate is nill if no gateway, else the gateway address.
**
** On exit,
** returns >=0 If no error, a good socket number
** <0 Error.
**
** The socket must be closed by the caller after the document has been
** read.
**
*/
PUBLIC int HTLoadHTTP ARGS4 (CONST char *, arg,
CONST char *, gate,
HTAnchor *, anAnchor,
int, diag)
{
int s; /* Socket number for returned data */
char *command; /* The whole command */
int status; /* tcp return */
char host[256]; /* Hold on to the host */
SockA soc_address; /* Binary network address */
SockA * sin = &soc_address;
if (!arg) return -3; /* Bad if no name sepcified */
if (!*arg) return -2; /* Bad if name had zero length */
/* Set up defaults:
*/
#ifdef DECNET
sin->sdn_family = AF_DECnet; /* Family = DECnet, host order */
sin->sdn_objnum = DNP_OBJ; /* Default: http object number */
#else /* Internet */
sin->sin_family = AF_INET; /* Family = internet, host order */
sin->sin_port = htons(TCP_PORT); /* Default: http port */
#endif
if (TRACE) {
if (gate) fprintf(stderr,
"HTTPAccess: Using gateway %s for %s\n", gate, arg);
else fprintf(stderr, "HTTPAccess: Direct access for %s\n", arg);
}
/* Get node name and optional port number:
*/
{
char *p1 = HTParse(gate ? gate : arg, "", PARSE_HOST);
strcpy(host, p1);
int status = HTParseInet(sin, p1); /* TBL 920622 */
free(p1);
if (status) return status; /* No such host for example */
}
/* Now, let's get a socket set up from the server for the sgml data:
*/
#ifdef DECNET
s = socket(AF_DECnet, SOCK_STREAM, 0);
#else
s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
#endif
status = connect(s, (struct sockaddr*)&soc_address, sizeof(soc_address));
if (status < 0) {
#ifndef DECNET
/* This code is temporary backward-compatibility. It should
go away when no server runs on port 2784 alone */
if (sin->sin_port == htons(TCP_PORT)) { /* Try the old one */
if (TRACE) printf (
"HTTP: Port %d doesn't answer (errno = %d). Trying good old port %d...\n",
TCP_PORT, errno, OLD_TCP_PORT);
sin->sin_port = htons(OLD_TCP_PORT);
/* First close current socket and open a clean one */
status = NETCLOSE (s);
s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
status = connect(s, (struct sockaddr*)&soc_address,
sizeof(soc_address));
}
if (status < 0)
#endif
{
if (TRACE) fprintf(stderr,
"HTTP: Unable to connect to remote host for `%s' (errno = %d).\n", arg, errno);
/* free(command); BUG OUT TBL 921121 */
return HTInetStatus("connect");
}
}
if (TRACE) fprintf(stderr, "HTTP connected, socket %d\n", s);
/* Ask that node for the document,
** omitting the host name & anchor if not gatewayed.
*/
if (gate) {
command = malloc(4 + strlen(arg)+ 2 + 1);
if (command == NULL) outofmem(__FILE__, "HTLoadHTTP");
strcpy(command, "GET ");
strcat(command, arg);
} else if ( HTTP11 ) { /* not gatewayed */
/* Switch this to HTTP 1.1 */
char * p1 = HTParse(arg, "", PARSE_PATH|PARSE_PUNCTUATION);
command = malloc(4 + strlen(arg) + 11 + 6 + strlen(host) + 2 + 20 + 2 + 1);
if (command == NULL) outofmem(__FILE__, "HTLoadHTTP");
strcpy(command, "GET ");
strcat(command, arg);
strcat(command, " HTTP/1.1\r\n");
strcat(command, "Host: ");
strcat(command, host);
strcat(command, "\r\n");
strcat(command, "Connection: close\r\n");
} else {
char * p1 = HTParse(arg, "", PARSE_PATH|PARSE_PUNCTUATION);
command = malloc(4 + strlen(p1)+ 2 + 1);
if (command == NULL) outofmem(__FILE__, "HTLoadHTTP");
strcpy(command, "GET ");
strcat(command, p1);
free(p1);
}
strcat(command, "\r\n"); /* Include CR for telnet compat. */
if (TRACE) fprintf(stderr, "HTTP writing command `%s' to socket %d\n", command, s);
#ifdef NOT_ASCII
{
char * p;
for(p = command; *p; p++) {
*p = TOASCII(*p);
}
}
#endif
status = NETWRITE(s, command, (int)strlen(command));
free(command);
if (status<0) {
if (TRACE) fprintf(stderr, "HTTPAccess: Unable to send command.\n");
return HTInetStatus("send");
}
/* Skip the HTTP 1.1 headers */
if ( HTTP11 ) {
char buffer[2];
int endhdr = 0;
while ( 1 ) {
int rc = read(s, buffer, 1) ;
if ( TRACE ) fprintf(stderr,"%c",buffer[0]);
if ( rc < 1 ) {
if (TRACE) fprintf(stderr, "HTTPAccess: EOF reading headers.\n");
return HTInetStatus("send");
}
if ( buffer[0] == '\r' && endhdr == 0 ) endhdr = 1;
else if ( buffer[0] == '\n' && endhdr == 1 ) endhdr = 2;
else if ( buffer[0] == '\r' && endhdr == 2 ) endhdr = 3;
else if ( buffer[0] == '\n' && endhdr == 3 ) break;
else endhdr = 0;
}
}
/* Now load the data
*/
{
char *url = HTParse(arg, "",
PARSE_ACCESS | PARSE_HOST | PARSE_PATH |
PARSE_PUNCTUATION);
int compressed;
int fmt =
diag ? WWW_PLAINTEXT : HTFileFormat (url, WWW_HTML, &compressed);
HTParseFormat(fmt, (HTParentAnchor *) anAnchor, s, compressed);
free (url);
}
if (TRACE) fprintf(stderr, "HTTP: close socket %d.\n", s);
status = NETCLOSE(s);
return HT_LOADED; /* Good return */
}
