debian/newlisp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
newlisp/nl-web.c

1485 lines
36 KiB
C
Raw Normal View History

Imported Upstream version 10.7.0
2016-06-11 17:22:37 +00:00
/* nl-web.c --- HTTP network protocol routines for newLISPD
Copyright (C) 2016 Lutz Mueller
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "newlisp.h"
#include <errno.h>
#include "protos.h"
#ifdef WINDOWS
#include <winsock2.h>
#else
#include <sys/types.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/wait.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#endif
#define BUFFSIZE 10240
#ifndef WINDOWS
#define SOCKET_ERROR -1
#else
#define fgets win_fgets
#define close closesocket /* for file operations on Windows use _close */
#endif
/* from nl-sock.c */
extern UINT netErrorIdx;
extern char * netErrorMsg[];
#define OK_FILE_DELETED "file deleted"
#define MAX_PROTOCOL 8
#define NO_FLAGS_SET 0
char * requestMethod[] = {"GET", "HEAD", "PUT", "PUT", "POST", "DELETE"};
/* with MinGW gcc 3.4.5 not needed
#ifdef WINDOWS
struct timezone {
int tz_minuteswest;
int tz_dsttime;
};
int gettimeofday( struct timeval *tp, struct timezone *tzp );
#endif
*/
#ifdef WINDOWS
extern int IOchannelIsSocketStream;
#endif
extern SYMBOL * transferEvent;
ssize_t readFile(char * fileName, char * * buffer);
int writeFile(char * fileName, char * buffer, size_t size, char * type);
int parseUrl(char *url, char * protocol, char * host, int * port, char * path, size_t bufflen);
void parsePath(char * url, char * path, size_t bufflen);
size_t parseValue(char * str);
void trimTrailing(char * ptr);
CELL * webError(int no);
CELL * base64(CELL * params, int type);
#ifndef EMSCRIPTEN
jmp_buf socketTimeoutJump;
INT socketTimeout = 0;
struct timeval socketStart;
/* socket send and receive routines with timeout */
int recvc_tm(int sock)
{
struct timeval tm;
unsigned char chr;
ssize_t bytes;
while(wait_ready(sock, 1000, 0) <= 0)
{
if(socketTimeout)
{
gettimeofday(&tm, NULL);
if(timediff_ms(tm, socketStart) > socketTimeout)
longjmp(socketTimeoutJump, 1);
}
}
bytes = recv(sock, (void *)&chr, 1, NO_FLAGS_SET);
if(bytes <= 0) return(-1);
return(chr);
}
char * recvs_tm(char * buffer, size_t size, int sock)
{
ssize_t bytesReceived = 0;
int chr;
while(bytesReceived < size)
{
if((chr = recvc_tm(sock)) < 0)
{
if(bytesReceived == 0)
return(NULL);
else break;
}
*(buffer + bytesReceived++) = chr;
if(chr == '\n') break;
}
*(buffer + bytesReceived) = 0;
return(buffer);
}
void wait_until_read_ready(int sock)
{
struct timeval tm;
while(wait_ready(sock, 1000, 0) <= 0)
{
if(socketTimeout)
{
gettimeofday(&tm, NULL);
if(timediff_ms(tm, socketStart) > socketTimeout)
longjmp(socketTimeoutJump, 1);
}
}
}
size_t recvsize_tm(char * buffer, size_t size, int sock, int flag)
{
ssize_t sizeRead = 0;
size_t resultSize = 0;
wait_until_read_ready(sock);
memset(buffer, 0, size);
while(size)
{
sizeRead = recv(sock, buffer + resultSize, size, NO_FLAGS_SET);
if(sizeRead <= 0)
{
sizeRead = 0;
break;
}
resultSize += sizeRead;
size -= sizeRead;
if(flag && transferEvent != nilSymbol)
executeSymbol(transferEvent, stuffInteger(sizeRead), NULL);
wait_until_read_ready(sock);
}
return(resultSize);
}
ssize_t sendf(int sock, int debug, char * format, ...)
{
char * buffer;
va_list argptr;
int result;
va_start(argptr,format);
/* new in 7201 , defined in nl-filesys.c if not in libc */
vasprintf(&buffer, format, argptr);
result = send(sock, buffer, strlen(buffer), NO_FLAGS_SET);
if(debug) varPrintf(OUT_CONSOLE, "%s", buffer);
freeMemory(buffer);
va_end(argptr);
return(result);
}
CELL * p_getUrl(CELL * params)
{
return(getPutPostDeleteUrl(NULL, params, HTTP_GET, CONNECT_TIMEOUT));
}
CELL * p_putUrl(CELL * params)
{
return(getPutPostDeleteUrl(NULL, params, HTTP_PUT, CONNECT_TIMEOUT));
}
CELL * p_postUrl(CELL * params)
{
return(getPutPostDeleteUrl(NULL, params, HTTP_POST, CONNECT_TIMEOUT));
}
CELL * p_deleteUrl(CELL * params)
{
return(getPutPostDeleteUrl(NULL, params, HTTP_DELETE, CONNECT_TIMEOUT));
}
int transfer(int sock, char * buff, int len)
{
int bytesSend = 0, n;
while(bytesSend < len)
{
if((n = sendall(sock, buff + bytesSend,
(len - bytesSend) > BUFFSIZE ? BUFFSIZE : len - bytesSend) )
== SOCKET_ERROR)
return(SOCKET_ERROR);
bytesSend += n;
if(transferEvent != nilSymbol)
executeSymbol(transferEvent, stuffInteger(bytesSend), NULL);
}
return(bytesSend);
}
CELL * getPutPostDeleteUrl(char * url, CELL * params, int type, int timeout)
{
char * proxyUrl, * putPostStr = NULL, *contentType;
char * protocol;
char * host;
char * pHost;
char * path;
char * customHeader = NULL;
size_t bufflen;
int port, pPort, sock = 0;
char * option, * method = NULL;
char * buff;
char resultTxt[128];
char * buffPtr;
char * resultPtr = NULL;
int haveContentLength = FALSE, headRequest = FALSE, listFlag = FALSE, debugFlag = FALSE, rawFlag = FALSE;
int chunked = FALSE;
ssize_t sizeRead = 0;
size_t resultSize = 0, fSize = 0, size = 0;
CELL * result, * cell;
CELL * headerCell = NULL;
int ch, len;
int responseLoop;
int statusCode;
buff = alloca(BUFFSIZE);
/* reset net-error */
netErrorIdx = 0;
/* get parameters */
if(url == NULL)
params = getString(params, &url);
if(type == HTTP_PUT || type == HTTP_PUT_APPEND || type == HTTP_POST)
params = getStringSize(params, &putPostStr, &size, TRUE);
if(my_strnicmp(url, "file://", 7) == 0)
{
if(type == HTTP_GET)
{
if((size = readFile(url, &buffPtr)) == -1)
return(webError(ERROR_FILE_OP));
return(makeStringCell(buffPtr, size));
}
if(type == HTTP_PUT)
{
if(writeFile(url, putPostStr, size, "w") == -1)
return(webError(ERROR_FILE_OP));
snprintf(resultTxt, 64, "%u bytes written", (unsigned int)size);
return(stuffString(resultTxt)); /* not an error */
}
if(type == HTTP_DELETE)
{
url = getLocalPath(url);
return(unlink(url) == 0 ? stuffString(OK_FILE_DELETED) : webError(ERROR_FILE_OP));
}
return(webError(ERROR_BAD_URL));
}
if(type == HTTP_POST)
{
if(params->type != CELL_NIL)
params = getString(params, &contentType);
else
contentType = "application/x-www-form-urlencoded";
}
result = evaluateExpression(params);
params = params->next;
if(isNumber(result->type))
{
getIntegerExt(result, (UINT*)&socketTimeout, FALSE);
/* set connection timeout to total-timeout specified by user */
timeout = socketTimeout;
}
else if(result->type == CELL_STRING)
{
option = (char *)result->contents;
len = result->aux - 1;
if(searchBuffer(option, len, "header", 6, 0) != -1)
headRequest = TRUE;
if(searchBuffer(option, len, "list", 4, 0) != -1)
listFlag = TRUE;
if(searchBuffer(option, len, "debug", 5, 0) != -1)
debugFlag = TRUE;
if(searchBuffer(option, len, "raw", 3, 0) != -1)
rawFlag = TRUE;
if(params != nilCell)
params = getInteger(params, (UINT*)&socketTimeout);
}
else if(result != nilCell)
return(errorProcExt(ERR_NUMBER_OR_STRING_EXPECTED, result));
/* if total timeout is specified, custom-header can be specified too */
if(socketTimeout && params != nilCell)
getString(params, &customHeader);
bufflen = strlen(url) + 1;
if(bufflen < MAX_URL_LEN + 1) bufflen = MAX_URL_LEN + 1;
protocol = alloca(8);
host = alloca(bufflen);
pHost = alloca(bufflen);
path = alloca(bufflen);
/* parse URL for parameters */
if(parseUrl(url, protocol, host, &port, path, bufflen) == FALSE)
return(webError(ERROR_BAD_URL));
/* printf("protocol: %s host:%s port %d path:%s\n", protocol, host, port, path); */
proxyUrl = getenv("HTTP_PROXY");
if(proxyUrl == NULL)
{
strncpy(pHost, host, bufflen);
pPort = port;
}
else
{
if(parseUrl(proxyUrl, protocol, pHost, &pPort, NULL, bufflen) == FALSE)
return(webError(ERROR_BAD_URL));
}
/* start timer */
gettimeofday(&socketStart, NULL);
/* connect to host */
CONNECT_TO_HOST:
if(sock)
close(sock);
if((sock = netConnect(pHost, pPort, SOCK_STREAM, 0, timeout)) == SOCKET_ERROR)
return(webError(netErrorIdx));
if(type == HTTP_GET)
if(headRequest == TRUE) type = HTTP_HEAD;
method = requestMethod[type];
/* send header */
if(proxyUrl != NULL)
sendf(sock, debugFlag, "%s %s://%s:%d/%s HTTP/1.1\r\n", method, protocol, host, port, path);
else
sendf(sock, debugFlag, "%s /%s HTTP/1.1\r\n", method, path);
/* obligatory host spec */
sendf(sock, debugFlag, "Host: %s\r\n", host);
/* send optional custom header entries */
if (customHeader != NULL)
sendf(sock, debugFlag, "%s", customHeader);
else
sendf(sock, debugFlag, "User-Agent: newLISP v%d\r\n", version);
sendf(sock, debugFlag, "%s", "Connection: close\r\n");
/* expanded header for PUT, POST and body */
if(type == HTTP_PUT || type == HTTP_PUT_APPEND)
{
if(type == HTTP_PUT_APPEND) sendf(sock, debugFlag, "%s", "Pragma: append\r\n");
if(customHeader == NULL)
sendf(sock, debugFlag, "Content-type: text/html\r\nContent-length: %d\r\n\r\n", size);
else
sendf(sock, debugFlag, "Content-length: %d\r\n\r\n", size);
if(transfer(sock, putPostStr, size) == SOCKET_ERROR)
return(webError(ERROR_TRANSFER));
if(debugFlag) varPrintf(OUT_CONSOLE, "%s", putPostStr);
}
else if(type == HTTP_POST)
{
sendf(sock, debugFlag, "Content-type: %s\r\nContent-length: %d\r\n\r\n", contentType, size);
if(transfer(sock, putPostStr, size) == SOCKET_ERROR)
return(webError(ERROR_TRANSFER));
if(debugFlag) varPrintf(OUT_CONSOLE, "%s", putPostStr);
}
else /* HTTP_GET, HTTP_DELETE */
sendf(sock, debugFlag, "%s", "\r\n");
if(setjmp(socketTimeoutJump) != 0)
{
if(sock) close(sock);
if(resultPtr != NULL) free(resultPtr);
return(webError(ERR_INET_TIMEOUT));
}
/* Retrieve HTTP response and check for status code. */
responseLoop = 0;
READ_RESPONSE:
if(++responseLoop == 4)
return(webError(ERROR_INVALID_RESPONSE));
if (recvs_tm(buff, BUFFSIZE, sock) == NULL)
return(webError(ERROR_NO_RESPONSE));
if(debugFlag) varPrintf(OUT_CONSOLE, "\n%s\n", buff);
/* go past first token */
for (buffPtr = buff; *buffPtr != '\0' && !isspace((int)*buffPtr); ++buffPtr) {;}
/* trim leading spaces */
while(isspace((int)*buffPtr)) ++buffPtr;
/* get status code */
statusCode = atoi(buffPtr);
if(statusCode >= 400)
snprintf(resultTxt, 128, "ERR: %s", buff);
else
snprintf(resultTxt, 128, "%s", buff);
switch (statusCode)
{
case 0:
case 100:
/* drain and continue */
while (ch = recvc_tm(sock), ch != EOF && ch != '\n') {;}
goto READ_RESPONSE;
case 200:
case 201:
case 202:
case 203:
case 204:
case 205:
case 206:
case 300:
case 301:
case 302:
case 303:
case 307:
break;
default:
break;
}
/* Retrieve HTTP headers. */
memset(buff, 0, BUFFSIZE);
if(listFlag || headRequest)
headerCell = stuffString("");
/* Retrieve header */
while(strcmp(buff, "\r\n") != 0 && strcmp(buff, "\n") != 0)
{
if(recvs_tm(buff, BUFFSIZE, sock) == NULL)
return(webError(ERROR_HEADER));
if(listFlag || headRequest) appendCellString(headerCell, buff, strlen(buff));
if(my_strnicmp(buff, "content-length:", 15) == 0)
{
fSize = parseValue(buff + 15);
haveContentLength = TRUE;
}
/* 302 contradicts standard for redirection but is common practice */
if(my_strnicmp(buff, "location:", 9) == 0 && !rawFlag &&
(statusCode == 301 || statusCode == 302 || statusCode == 303))
{
buffPtr = buff + 9;
while(isspace((int)*buffPtr)) ++buffPtr;
if(*buffPtr == '/')
strncpy(path, buffPtr + 1, bufflen);
else /* its a url or path */
{
if(parseUrl(buffPtr, protocol, host, &port, path, bufflen) == FALSE)
/* path only */
parsePath(buffPtr, path, buffPtr - buff);
if(proxyUrl == NULL)
{
strncpy(pHost, host, bufflen);
pPort = port;
}
}
if(headerCell) deleteList(headerCell);
goto CONNECT_TO_HOST;
}
if(my_strnicmp(buff, "Transfer-Encoding:", 18) == 0
&& searchBuffer(buff, strlen(buff), "chunked", 7, 0) != -1)
chunked = TRUE;
}
if(headRequest)
return(headerCell);
/* changed in 10.6.4 should allow 0-length contents and 204 handled earlier */
/* if((haveContentLength == TRUE && fSize == 0) || statusCode == 204) */
if(statusCode == 204)
{
return(webError(ERROR_NO_CONTENT));
resultPtr = NULL;
}
/* Retrieve HTTP body. */
else if(chunked == TRUE)
{
resultPtr = NULL;
if(recvs_tm(buff, BUFFSIZE, sock) == NULL)
return(webError(ERROR_NO_CONTENT));
while((size = strtoul(buff, NULL, 16)) > 0)
{
if(resultSize == 0)
resultPtr = allocMemory(size + 1);
else
resultPtr = reallocMemory(resultPtr, resultSize + size + 1);
if(recvsize_tm(resultPtr + resultSize, size, sock, TRUE) != size)
{
free(resultPtr);
return(webError(ERROR_CHUNKED_FORMAT));
}
resultSize += size;
recvs_tm(buff, BUFFSIZE, sock); /* empty line */
recvs_tm(buff, BUFFSIZE, sock); /* chunck size */
}
}
else if(haveContentLength == TRUE && fSize)
{
resultPtr = allocMemory(fSize + 1);
if((resultSize = recvsize_tm(resultPtr, fSize, sock, TRUE)) == 0)
{
free(resultPtr);
return(webError(ERROR_NO_CONTENT));
}
}
else /* no content length given, relies on host closing the connection */
{
resultPtr = allocMemory(BUFFSIZE + 1);
resultSize = 0;
size = BUFFSIZE;
while ((sizeRead = recvsize_tm(buff, BUFFSIZE, sock, FALSE)) > 0)
{
if((resultSize + sizeRead) > size)
{
size = resultSize + BUFFSIZE;
resultPtr = reallocMemory(resultPtr, size + 1);
}
memcpy(resultPtr + resultSize, buff, sizeRead);
resultSize += sizeRead;
if(transferEvent != nilSymbol)
executeSymbol(transferEvent, stuffInteger(sizeRead), NULL);
}
}
if(resultPtr == NULL)
{
if(statusCode < 400)
result = stuffString("");
else
result = stuffString(resultTxt);
}
else
{
result = getCell(CELL_STRING);
if(statusCode >= 400 && listFlag == FALSE)
{
bufflen = strlen(resultTxt);
buffPtr = allocMemory(bufflen + resultSize + 1);
memcpy(buffPtr, resultTxt, bufflen);
memcpy(buffPtr + bufflen, resultPtr, resultSize);
free(resultPtr);
resultPtr = buffPtr;
resultSize += bufflen;
}
*(resultPtr + resultSize) = 0;
result->contents = (UINT)resultPtr;
result->aux = resultSize + 1;
}
close(sock);
if(listFlag)
{
cell = getCell(CELL_EXPRESSION);
addList(cell, headerCell);
addList(cell, result);
addList(cell, stuffString(statusCode >= 400 ? resultTxt + 5 : resultTxt));
addList(cell, stuffInteger(statusCode));
return(cell);
}
return(result);
}
int parseUrl(char * url, char * protocol, char * host, int * port, char * path, size_t bufflen)
{
char * bracketPtr = NULL;
char * colonPtr = NULL;
char * slashPtr;
int len;
/* trim trailing whitespace like '/r/n' from url */
len = strlen(url);
while(*(url + len) <= ' ' && len > 0)
{
*(url + len) = 0;
len--;
}
*port = 80;
if(my_strnicmp(url, "http://", 7) == 0)
{
strncpy(protocol,"http", MAX_PROTOCOL );
if( (ADDR_FAMILY == AF_INET6) && (*(url + 7) == '[') )
strncpy(host, url+8, bufflen);
else
strncpy(host, url+7, bufflen);
}
else if( my_strnicmp(url, "https://", 8) == 0)
{
strncpy(protocol, "https", MAX_PROTOCOL);
if( (ADDR_FAMILY == AF_INET6) && (*(url + 8) == '[') )
strncpy(host, url+9, bufflen);
else
strncpy(host, url+8, bufflen);
}
else
return(FALSE);
if(ADDR_FAMILY == AF_INET6)
bracketPtr = strchr(host, ']');
else
colonPtr = strchr(host, ':');
slashPtr = strchr(host, '/');
if(ADDR_FAMILY == AF_INET6)
{
if (bracketPtr != NULL && (slashPtr == NULL || bracketPtr < slashPtr))
{
*bracketPtr = '\0';
if(*(bracketPtr + 1) == ':')
*port = atoi(bracketPtr + 2);
}
else
{
colonPtr = strchr(host, ':');
if (colonPtr != NULL && (slashPtr == NULL || colonPtr < slashPtr))
{
*colonPtr++ = '\0';
*port = atoi(colonPtr);
}
}
}
else
{
if (colonPtr != NULL && (slashPtr == NULL || colonPtr < slashPtr))
{
*colonPtr++ = '\0';
*port = atoi(colonPtr);
}
}
if(path == NULL) return(TRUE);
if (slashPtr != NULL)
{
*slashPtr++ = '\0';
strncpy(path, slashPtr, bufflen);
}
else
strncpy(path, "", bufflen);
/* printf("protocol:%s host:%s port:%d path:%s\n", protocol, host, *port, path); */
return(TRUE);
}
void parsePath(char * url, char * path, size_t bufflen)
{
int len;
/* trim trailing whitespace like '/r/n' from url */
len = strlen(url);
while(*(url + len) <= ' ' && len > 0)
{
*(url + len) = 0;
len--;
}
/* trim leading whitespace */
while(*url <= ' ') url++;
strncpy(path, url, bufflen);
}
size_t parseValue(char * str)
{
while(!isDigit((unsigned char)*str) && *str != 0) ++str;
return atol(str);
}
CELL * webError(int errorNo)
{
char msg[64];
netErrorIdx = errorNo;
snprintf(msg, 64, "ERR: %s", netErrorMsg[errorNo]);
return(stuffString(msg));
}
#endif /* ifndef EMSCRIPTEN */
/***************************************************************************
* _ _ ____ _
* Project ___| | | | _ \| |
* / __| | | | |_) | |
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
* Copyright (C) 1998 - 2004, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
* are also available at http://curl.haxx.se/docs/copyright.html.
*
* You may opt to use, copy, modify, merge, publish, distribute and/or sell
* copies of the Software, and permit persons to whom the Software is
* furnished to do so, under the terms of the COPYING file.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
* $Id: base64.c,v 1.32 2004/12/15 01:38:25 danf Exp $
***************************************************************************/
/* Base64 encoding/decoding
this file from the cURL project is included in nl-web.c for the
newLISP functions 'base64-enc' and 'base64-dec'
all #include statements have and the test harness rootines have
been stripped. 2005-1-6 Lutz Mueller
*/
static void decodeQuantum(unsigned char *dest, const char *src)
{
unsigned int x = 0;
int i;
for(i = 0; i < 4; i++) {
if(src[i] >= 'A' && src[i] <= 'Z')
x = (x << 6) + (unsigned int)(src[i] - 'A' + 0);
else if(src[i] >= 'a' && src[i] <= 'z')
x = (x << 6) + (unsigned int)(src[i] - 'a' + 26);
else if(src[i] >= '0' && src[i] <= '9')
x = (x << 6) + (unsigned int)(src[i] - '0' + 52);
else if(src[i] == '+')
x = (x << 6) + 62;
else if(src[i] == '/')
x = (x << 6) + 63;
else if(src[i] == '=')
x = (x << 6);
}
dest[2] = (unsigned char)(x & 255);
x >>= 8;
dest[1] = (unsigned char)(x & 255);
x >>= 8;
dest[0] = (unsigned char)(x & 255);
}
/*
* Curl_base64_decode()
*
* Given a base64 string at src, decode it into the memory pointed to by
* dest. Returns the length of the decoded data.
*/
size_t Curl_base64_decode(const char *src, char *dest)
{
int length = 0;
int equalsTerm = 0;
int i;
int numQuantums;
unsigned char lastQuantum[3];
size_t rawlen=0;
while((src[length] != '=') && src[length])
length++;
while(src[length+equalsTerm] == '=')
equalsTerm++;
if(equalsTerm > 3) equalsTerm = 3; /* LM added 2006-09-08 */
numQuantums = (length + equalsTerm) / 4;
if(numQuantums == 0) return(0);
rawlen = (numQuantums * 3) - equalsTerm;
for(i = 0; i < numQuantums - 1; i++) {
decodeQuantum((unsigned char *)dest, src);
dest += 3; src += 4;
}
decodeQuantum(lastQuantum, src);
for(i = 0; i < 3 - equalsTerm; i++)
dest[i] = lastQuantum[i];
return rawlen;
}
#define BASE64_ENC 0
#define BASE64_DEC 1
CELL * p_base64Enc(CELL * params) { return(base64(params, BASE64_ENC)); }
CELL * p_base64Dec(CELL * params) { return(base64(params, BASE64_DEC)); }
CELL * base64(CELL * params, int type)
{
char * inPtr;
char * outPtr;
size_t sizein, sizeout;
int emptyFlag = 0;
params = getStringSize(params, &inPtr, &sizein, TRUE);
emptyFlag = getFlag(params);
if(type == BASE64_ENC)
{
if(sizein == 0)
return(emptyFlag ? stuffString("") : stuffString("===="));
if((sizeout = Curl_base64_encode(inPtr, sizein, &outPtr)) == 0)
return(stuffString(""));
}
else /* BASE64_DEC */
{
outPtr = allocMemory((sizein * 3) / 4 + 9);
sizeout = Curl_base64_decode(inPtr, outPtr);
*(outPtr + sizeout) = 0;
}
/*
strCell = getCell(CELL_STRING);
strCell->contents = (UINT)outPtr;
strCell->aux = sizeout + 1;
return(strCell);
*/
return(makeStringCell(outPtr, sizeout));
}
/* ---- Base64 Encoding --- */
static const char table64[]=
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
/*
* Curl_base64_encode()
*
* Returns the length of the newly created base64 string. The third argument
* is a pointer to an allocated area holding the base64 data. If something
* went wrong, -1 is returned.
*
*/
size_t Curl_base64_encode(const char *inp, size_t insize, char **outptr)
{
unsigned char ibuf[3];
unsigned char obuf[4];
int i;
int inputparts;
char *output;
char *base64data;
char *indata = (char *)inp;
*outptr = NULL; /* set to NULL in case of failure before we reach the end */
if(0 == insize)
insize = strlen(indata);
base64data = output = (char*)malloc(insize*4/3+4);
if(NULL == output)
return 0;
while(insize > 0) {
for (i = inputparts = 0; i < 3; i++) {
if(insize > 0) {
inputparts++;
ibuf[i] = *indata;
indata++;
insize--;
}
else
ibuf[i] = 0;
}
obuf [0] = (ibuf [0] & 0xFC) >> 2;
obuf [1] = ((ibuf [0] & 0x03) << 4) | ((ibuf [1] & 0xF0) >> 4);
obuf [2] = ((ibuf [1] & 0x0F) << 2) | ((ibuf [2] & 0xC0) >> 6);
obuf [3] = ibuf [2] & 0x3F;
switch(inputparts) {
case 1: /* only one byte read */
snprintf(output, 5, "%c%c==",
table64[obuf[0]],
table64[obuf[1]]);
break;
case 2: /* two bytes read */
snprintf(output, 5, "%c%c%c=",
table64[obuf[0]],
table64[obuf[1]],
table64[obuf[2]]);
break;
default:
snprintf(output, 5, "%c%c%c%c",
table64[obuf[0]],
table64[obuf[1]],
table64[obuf[2]],
table64[obuf[3]] );
break;
}
output += 4;
}
*output=0;
*outptr = base64data; /* make it return the actual data memory */
return strlen(base64data); /* return the length of the new data */
}
/* ---- End of Base64 Encoding ---- */
#ifndef EMSCRIPTEN
/* --------------------------- HTTP server mode -----------------------------
Handles GET, POST, PUT and DELETE requests
handles queries in GET requests and sets environment variables
DOCUMENT_ROOT, REQUEST_METHOD, SERVER_SOFTWARE and QUERY_STRING,
and when present in client request header HTTP_HOST, HTTP_USER_AGENT
and HTTP_COOKIE. REMOTE_ADDR is set when the client connects.
Subset HTTP/1.0 compliant.
*/
#ifndef LIBRARY
/* #define DEBUGHTTP */
#define SERVER_SOFTWARE "newLISP/10.7.0"
int sendHTTPmessage(int status, char * description, char * request);
void handleHTTPcgi(char * command, char * query, ssize_t querySize);
size_t readHeader(char * buff, int * pragmaFlag);
ssize_t readPayLoad(ssize_t size, char * content, int outFile, char * request);
int endsWith(char * str, char * ext);
char * getMediaType(char * request);
void url_decode(char *dest, char *src);
void sendHTTPpage(char * content, size_t size, char * media)
{
int pos = 0;
char status[128];
memset(status, 0, 128);
if(strncmp(content, "Status:", 7) == 0)
{
/* get content after */
while(*(content + pos) >= 32) pos++;
memcpy(status, content + 7, pos - 7);
content = content + pos;
if(size) size -= pos;
while(*content == '\r' || *content == '\n') { content++; size--; }
}
else
strncpy(status, "200 OK", 6);
varPrintf(OUT_CONSOLE, "HTTP/1.0 %s\r\n", status);
varPrintf(OUT_CONSOLE, "Server: newLISP v.%d (%s)\r\n", version, OSTYPE);
#ifdef DEBUGHTTP
puts("# Header sent:");
printf("HTTP/1.0 %s\r\n", status);
printf("Server: newLISP v.%d (%s)\r\n", version, OSTYPE);
#endif
if(media != NULL)
{
varPrintf(OUT_CONSOLE, "Content-length: %d\r\nContent-type: %s\r\n\r\n", size, media);
#ifdef DEBUGHTTP
printf("Content-length: %d\r\nContent-type: %s\r\n\r\n", (int)size, media);
#endif
}
#ifndef WINDOWS
size = write(fileno(IOchannel), content, size);
fflush(IOchannel);
fclose(IOchannel);
IOchannel = NULL;
#else /* it is WINDOWS */
if(IOchannel != NULL && IOchannelIsSocketStream)
{
sendall(getSocket(IOchannel), content, size);
close(getSocket(IOchannel));
}
else
varPrintf(OUT_CONSOLE, "%s", content);
return;
#endif
#ifdef DEBUGHTTP
printf("# content:%s:\r\n", content);
fflush(stdout);
#endif
}
#define MAX_BUFF 1024
#define ERROR_404 "File or Directory not found"
#define ERROR_411 "Length required for"
#define ERROR_500 "Server error"
#define DEFAULT_PAGE_1 "index.html"
#define DEFAULT_PAGE_2 "index.cgi"
#define CGI_EXTENSION ".cgi"
#define MEDIA_TEXT "text/plain"
int executeHTTPrequest(char * request, int type)
{
char * sptr;
char * query;
char * content = NULL;
char * decoded;
char buff[MAX_BUFF];
ssize_t transferred, size;
char * mediaType;
CELL * result = NULL;
int outFile;
int pragmaFlag;
int len;
char * fileMode = "w";
if(chdir(startupDir) < 0)
fatalError(ERR_IO_ERROR, 0, 0);
query = sptr = request;
setenv("DOCUMENT_ROOT", startupDir, 1);
setenv("SERVER_SOFTWARE", SERVER_SOFTWARE, 1);
setenv("REQUEST_METHOD", requestMethod[type], 1);
#ifdef DEBUGHTTP
printf("# HTTP request:%s:%s:\r\n", request, requestMethod[type]);
#endif
/* stuff after request */
while(*sptr > ' ') ++sptr;
*sptr = 0;
while(*query != 0 && *query != '?') ++query;
if(*query == '?')
{
*query = 0;
query++;
}
setenv("QUERY_STRING", query, 1);
/* do url_decode */
decoded = alloca(strlen(request) + 1);
url_decode(decoded, request);
request = decoded;
/* change to base dir of request file */
sptr = request + strlen(request);
while(*sptr != '/' && sptr != request) --sptr;
if(*sptr == '/')
{
*sptr = 0;
sptr++;
if(chdir(request))
{
sendHTTPmessage(404, ERROR_404, request);
return(TRUE);
}
request = sptr;
}
if((len = strlen(request)) == 0)
{
if(isFile(DEFAULT_PAGE_2, 0) == 0)
request = DEFAULT_PAGE_2;
else
request = DEFAULT_PAGE_1;
len = strlen(request);
}
size = readHeader(buff, &pragmaFlag);
switch(type)
{
case HTTP_GET:
case HTTP_HEAD:
if(endsWith(request, CGI_EXTENSION))
handleHTTPcgi(request, query, strlen(query));
else
{
mediaType = getMediaType(request);
if(type == HTTP_HEAD)
{
snprintf(buff, MAX_BUFF - 1,
"Content-length: %"PRId64"\r\nContent-type: %s\r\n\r\n",
fileSize(request), mediaType);
sendHTTPpage(buff, strlen(buff), NULL);
}
else
{
if((size = readFile(request, &content)) == -1)
sendHTTPmessage(404, ERROR_404, request);
else
sendHTTPpage(content, size, mediaType);
if(content) free(content);
}
}
break;
case HTTP_DELETE:
if(unlink(request) != 0)
sendHTTPmessage(500, "Could not delete", request);
else
sendHTTPpage("File deleted", 12, MEDIA_TEXT);
break;
case HTTP_POST:
if(!size)
{
sendHTTPmessage(411, ERROR_411, request);
break;
}
query = callocMemory(size + 1);
if(readPayLoad(size, query, 0, request) == -1)
{
free(query);
break;
}
handleHTTPcgi(request, query, size);
free(query);
break;
case HTTP_PUT:
if(pragmaFlag) fileMode = "a";
if(!size)
{
sendHTTPmessage(411, ERROR_411, request);
break;
}
if( (outFile = openFile(request, fileMode, NULL)) == (int)-1)
{
sendHTTPmessage(500, "Cannot create file", request);
break;
}
transferred = readPayLoad(size, buff, outFile, request);
#ifdef WINDOWS
_close(outFile);
#else
close(outFile);
#endif
if(transferred != -1)
{
snprintf(buff, 255, "%d bytes transferred for %s\r\n", (int)transferred, request);
sendHTTPpage(buff, strlen(buff), MEDIA_TEXT);
}
break;
default:
break;
}
if(chdir(startupDir) < 0) fatalError(ERR_IO_ERROR, 0, 0);
if(result != NULL) deleteList(result);
return(TRUE);
}
int sendHTTPmessage(int status, char * desc, char * req)
{
char msg[256];
snprintf(msg, 256, "Status:%d %s\r\nERR:%d %s: %s\r\n", status, desc, status, desc, req);
sendHTTPpage(msg, strlen(msg), MEDIA_TEXT);
return(0);
}
/* remove leading white space */
char * trim(char * buff)
{
char * ptr = buff;
while(*ptr <= ' ') ptr++;
return(ptr);
}
/* retrieve rest of header */
size_t readHeader(char * buff, int * pragmaFlag)
{
size_t size = 0;
int offset;
char numStr[16];
*pragmaFlag = 0;
memset(buff, 0, MAX_LINE);
setenv("HTTP_HOST", "", 1);
setenv("HTTP_USER_AGENT", "", 1);
setenv("HTTP_COOKIE", "", 1);
setenv("HTTP_AUTHORIZATION", "", 1);
while(fgets(buff, MAX_LINE - 1, IOchannel) != NULL)
{
if(strcmp(buff, "\r\n") == 0 || strcmp(buff, "\n") == 0) break;
/* trim trailing white space */
offset = strlen(buff) - 1;
while(offset > 0 && *(buff + offset) <= ' ')
*(buff + offset--) = 0;
if(my_strnicmp(buff, "content-length:", 15) == 0)
{
size = parseValue(buff + 15);
#if defined(WINDOWS) || defined(TRU64)
snprintf(numStr, 16, "%lu", (long unsigned int)size);
#else
snprintf(numStr, 16, "%llu", (long long unsigned int)size);
#endif
setenv("CONTENT_LENGTH", numStr, 1);
}
if(my_strnicmp(buff, "pragma: append", 14) == 0)
*pragmaFlag = TRUE;
/* trim leading white space */
if(my_strnicmp(buff, "content-type:", 13) == 0)
setenv("CONTENT_TYPE", trim(buff + 13), 1);
if(my_strnicmp(buff, "Host:", 5) == 0)
setenv("HTTP_HOST", trim(buff + 5), 1);
if(my_strnicmp(buff, "User-Agent:", 11) == 0)
setenv("HTTP_USER_AGENT", trim(buff + 11), 1);
if(my_strnicmp(buff, "Cookie:", 7) == 0)
setenv("HTTP_COOKIE", trim(buff + 7), 1);
if(my_strnicmp(buff, "Authorization:", 14) == 0)
setenv("HTTP_AUTHORIZATION", trim(buff + 14), 1);
}
return(size);
}
ssize_t readPayLoad(ssize_t size, char * buff, int outFile, char * request)
{
ssize_t bytes, readsize;
size_t offset = 0, transferred = 0;
#ifdef DEBUGHTTP
printf("# Payload size:%ld\r\n", (long)size);
#endif
while(size > 0)
{
readsize = (size > MAX_BUFF) ? MAX_BUFF : size;
#ifndef WINDOWS
bytes = read(fileno(IOchannel), buff + offset, readsize);
#else /* it is WINDOWS */
if(IOchannel != NULL && IOchannelIsSocketStream)
bytes = recv(getSocket(IOchannel), buff + offset, readsize, NO_FLAGS_SET);
else
bytes = read(fileno(IOchannel), buff + offset, readsize);
#endif
#ifdef DEBUGHTTP
printf("Payload bytes:%ld:%s:\r\n", (long)bytes, buff + offset);
#endif
if(bytes <= 0)
{
sendHTTPmessage(500, "Problem reading data", request);
return(-1);
}
if(outFile)
{
if(write(outFile, buff + offset, bytes) != bytes)
{
sendHTTPmessage(500, "Cannot create file", request);
return(-1);
}
}
else
offset += bytes;
transferred += bytes;
size -= bytes;
}
#ifndef WINDOWS
fflush(NULL);
#endif
return(transferred);
}
void handleHTTPcgi(char * request, char * query, ssize_t querySize)
{
FILE * handle;
char * command;
char * content = NULL;
ssize_t size;
char tempfile[PATH_MAX];
#ifdef WINDOWS_BEFORE_SETTING_BINARYMODE
char * ptr;
char * pos;
int bytes = 0;
#endif
srandom(milliSecTime());
#ifdef DEBUGHTTP
printf("# CGI request:%s:%s:\r\n", request, query);
#endif
if(isFile(request, 0) != 0)
{
sendHTTPmessage(404, ERROR_404, request);
return;
}
if(isFile(tempDir, 0) != 0)
{
sendHTTPmessage(500, "cannot find tmp directory", request);
return;
}
size = strlen(request) + PATH_MAX;
command = alloca(size);
snprintf(tempfile, PATH_MAX, "%s/nl%04x-%08x-%08x",
tempDir, (unsigned int)size, (unsigned int)random(), (unsigned int)random());
#if defined (WINDOWS) || (OS2)
snprintf(command, size - 1, "newlisp \"%s\" > %s", request, tempfile);
#else
snprintf(command, size - 1, "./\"%s\" > %s", request, tempfile);
#endif
if((handle = popen(command, "w")) == NULL)
{
sendHTTPmessage(500, "failed creating pipe", request);
return;
}
if((size = fwrite(query, 1, querySize, handle)) < 0)
fatalError(ERR_IO_ERROR, 0, 0);
fflush(handle);
pclose(handle);
size = readFile(tempfile, &content);
if(size == -1)
sendHTTPmessage(500, "cannot read output of", tempfile);
else
sendHTTPpage(content, size, NULL);
#ifdef DEBUGHTTP
printf("# Temporary file: %s\n", tempfile);
#else
unlink(tempfile);
#endif
if(content) free(content);
}
int endsWith(char * str, char * ext)
{
size_t size, len;
size = strlen(str);
len = strlen(ext);
return(strncmp(str + size - len, ext, len) == 0);
}
typedef struct
{
char * extension;
char * type;
} T_MEDIA_TYPE;
/* T_ prefix added in 10.4.8 to compile on later MinGW */
T_MEDIA_TYPE mediaType[] = {
{".avi", "video/x-msvideo"},
{".css", "text/css"},
{".gif", "image/gif"},
{".htm", "text/html"},
{".html","text/html"},
{".jpg", "image/jpeg"},
{".js", "application/javascript"},
{".mov", "video/quicktime"},
{".mp3", "audio/mpeg"},
{".mpg", "video/mpeg"},
{".pdf", "application/pdf"},
{".png", "image/png"},
{".wav", "audio/x-wav"},
{".zip", "application/zip"},
{ NULL, NULL},
};
char * getMediaType(char * request)
{
int i;
for(i = 0; mediaType[i].extension != NULL; i++)
{
if(endsWith(request, mediaType[i].extension))
return(mediaType[i].type);
}
return(MEDIA_TEXT);
}
void url_decode(char *dest, char *src)
{
char code[3] = {0};
unsigned int ascii = 0;
char *end = NULL;
while(*src)
{
if(*src == '%')
{
memcpy(code, ++src, 2);
ascii = strtoul(code, &end, 16);
*dest++ = (char)ascii;
src += 2;
}
else
*dest++ = *src++;
}
*dest = 0;
}
#endif /* ifndef EMSCRIPTEN */
#endif /* ifndef LIBRARY */
/* eof */
Reference in a new issue Copy permalink