From 13106ac8bb95e325cf522817f91ad1f3b0fcecb0 Mon Sep 17 00:00:00 2001 From: Lars-Dominik Braun Date: Tue, 23 Nov 2010 21:59:31 +0100 Subject: Better directory layout Removed useless AUTHORS, COPYING and README files. Move manpage to contrib (it's not exactly source code). --- src/libwaitress/config.h | 1 + src/libwaitress/waitress.c | 573 +++++++++++++++++++++++++++++++++++++++++++++ src/libwaitress/waitress.h | 78 ++++++ 3 files changed, 652 insertions(+) create mode 100644 src/libwaitress/config.h create mode 100644 src/libwaitress/waitress.c create mode 100644 src/libwaitress/waitress.h (limited to 'src/libwaitress') diff --git a/src/libwaitress/config.h b/src/libwaitress/config.h new file mode 100644 index 0000000..e13fe40 --- /dev/null +++ b/src/libwaitress/config.h @@ -0,0 +1 @@ +#define PACKAGE "libwaitress" diff --git a/src/libwaitress/waitress.c b/src/libwaitress/waitress.c new file mode 100644 index 0000000..27f7b3d --- /dev/null +++ b/src/libwaitress/waitress.c @@ -0,0 +1,573 @@ +/* +Copyright (c) 2009-2010 + Lars-Dominik Braun + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +#define _POSIX_C_SOURCE 1 /* required by getaddrinfo() */ +#define _BSD_SOURCE /* snprintf() */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "config.h" +#include "waitress.h" + +typedef struct { + char *buf; + size_t pos; +} WaitressFetchBufCbBuffer_t; + +inline void WaitressInit (WaitressHandle_t *waith) { + memset (waith, 0, sizeof (*waith)); + waith->socktimeout = 30000; +} + +inline void WaitressFree (WaitressHandle_t *waith) { + memset (waith, 0, sizeof (*waith)); +} + +/* Proxy set up? + * @param Waitress handle + * @return true|false + */ +static inline char WaitressProxyEnabled (const WaitressHandle_t *waith) { + return *waith->proxyHost != '\0' && *waith->proxyPort != '\0'; +} + +/* Set http proxy + * @param waitress handle + * @param host + * @param port + */ +inline void WaitressSetProxy (WaitressHandle_t *waith, const char *host, + const char *port) { + strncpy (waith->proxyHost, host, sizeof (waith->proxyHost)-1); + strncpy (waith->proxyPort, port, sizeof (waith->proxyPort)-1); +} + +/* urlencode post-data + * @param encode this + * @return malloc'ed encoded string, don't forget to free it + */ +char *WaitressUrlEncode (const char *in) { + size_t inLen = strlen (in); + /* worst case: encode all characters */ + char *out = calloc (inLen * 3 + 1, sizeof (*in)); + const char *inPos = in; + char *outPos = out; + + while (inPos - in < inLen) { + if (!isalnum (*inPos) && *inPos != '_' && *inPos != '-' && *inPos != '.') { + *outPos++ = '%'; + snprintf (outPos, 3, "%02x", *inPos & 0xff); + outPos += 2; + } else { + /* copy character */ + *outPos++ = *inPos; + } + ++inPos; + } + + return out; +} + +/* Split http url into host, port and path + * @param url + * @param return buffer: host + * @param host buffer size + * @param return buffer: port, defaults to 80 + * @param port buffer size + * @param return buffer: path + * @param path buffer size + * @param 1 = ok, 0 = not a http url; if your buffers are too small horrible + * things will happen... But 1 is returned anyway. + */ +char WaitressSplitUrl (const char *url, char *retHost, size_t retHostSize, + char *retPort, size_t retPortSize, char *retPath, size_t retPathSize) { + size_t urlSize = strlen (url); + const char *urlPos = url, *lastPos; + + if (urlSize > sizeof ("http://")-1 && + memcmp (url, "http://", sizeof ("http://")-1) == 0) { + memset (retHost, 0, retHostSize); + memset (retPort, 0, retPortSize); + strncpy (retPort, "80", retPortSize-1); + memset (retPath, 0, retPathSize); + + urlPos += sizeof ("http://")-1; + lastPos = urlPos; + + /* find host */ + while (*urlPos != '\0' && *urlPos != ':' && *urlPos != '/' && + urlPos - lastPos < retHostSize-1) { + *retHost++ = *urlPos++; + } + lastPos = urlPos; + + /* port, if available */ + if (*urlPos == ':') { + /* skip : */ + ++urlPos; + ++lastPos; + while (*urlPos != '\0' && *urlPos != '/' && + urlPos - lastPos < retPortSize-1) { + *retPort++ = *urlPos++; + } + } + lastPos = urlPos; + + /* path */ + while (*urlPos != '\0' && *urlPos != '#' && + urlPos - lastPos < retPathSize-1) { + *retPath++ = *urlPos++; + } + } else { + return 0; + } + return 1; +} + +/* Parse url and set host, port, path + * @param Waitress handle + * @param url: protocol://host:port/path + */ +inline char WaitressSetUrl (WaitressHandle_t *waith, const char *url) { + return WaitressSplitUrl (url, waith->host, sizeof (waith->host), + waith->port, sizeof (waith->port), waith->path, sizeof (waith->path)); +} + +/* Set host, port, path + * @param Waitress handle + * @param host + * @param port (getaddrinfo () needs a string...) + * @param path, including leading / + */ +inline void WaitressSetHPP (WaitressHandle_t *waith, const char *host, + const char *port, const char *path) { + strncpy (waith->host, host, sizeof (waith->host)-1); + strncpy (waith->port, port, sizeof (waith->port)-1); + strncpy (waith->path, path, sizeof (waith->path)-1); +} + +/* Callback for WaitressFetchBuf, appends received data to NULL-terminated buffer + * @param received data + * @param data size + * @param buffer structure + */ +static WaitressCbReturn_t WaitressFetchBufCb (void *recvData, size_t recvDataSize, + void *extraData) { + char *recvBytes = recvData; + WaitressFetchBufCbBuffer_t *buffer = extraData; + + if (buffer->buf == NULL) { + if ((buffer->buf = malloc (sizeof (*buffer->buf) * + (recvDataSize + 1))) == NULL) { + return WAITRESS_CB_RET_ERR; + } + } else { + char *newbuf; + if ((newbuf = realloc (buffer->buf, + sizeof (*buffer->buf) * + (buffer->pos + recvDataSize + 1))) == NULL) { + free (buffer->buf); + return WAITRESS_CB_RET_ERR; + } + buffer->buf = newbuf; + } + memcpy (buffer->buf + buffer->pos, recvBytes, recvDataSize); + buffer->pos += recvDataSize; + *(buffer->buf+buffer->pos) = '\0'; + + return WAITRESS_CB_RET_OK; +} + +/* Fetch string. Beware! This overwrites your waith->data pointer + * @param waitress handle + * @param result buffer, malloced (don't forget to free it yourself) + */ +WaitressReturn_t WaitressFetchBuf (WaitressHandle_t *waith, char **buf) { + WaitressFetchBufCbBuffer_t buffer; + WaitressReturn_t wRet; + + memset (&buffer, 0, sizeof (buffer)); + + waith->data = &buffer; + waith->callback = WaitressFetchBufCb; + + wRet = WaitressFetchCall (waith); + *buf = buffer.buf; + return wRet; +} + +/* poll wrapper that retries after signal interrupts, required for socksify + * wrapper + */ +static int WaitressPollLoop (struct pollfd *fds, nfds_t nfds, int timeout) { + int pollres = -1; + int pollerr = 0; + + do { + pollres = poll (fds, nfds, timeout); + pollerr = errno; + errno = 0; + } while (pollerr == EINTR || pollerr == EINPROGRESS || pollerr == EAGAIN); + + return pollres; +} + +/* write () wrapper with poll () timeout + * @param socket fd + * @param write buffer + * @param write count bytes + * @param reuse existing pollfd structure + * @param timeout (microseconds) + * @return WAITRESS_RET_OK, WAITRESS_RET_TIMEOUT or WAITRESS_RET_ERR + */ +static WaitressReturn_t WaitressPollWrite (int sockfd, const char *buf, size_t count, + struct pollfd *sockpoll, int timeout) { + int pollres = -1; + + sockpoll->events = POLLOUT; + pollres = WaitressPollLoop (sockpoll, 1, timeout); + if (pollres == 0) { + return WAITRESS_RET_TIMEOUT; + } else if (pollres == -1) { + return WAITRESS_RET_ERR; + } + if (write (sockfd, buf, count) == -1) { + return WAITRESS_RET_ERR; + } + return WAITRESS_RET_OK; +} + +/* read () wrapper with poll () timeout + * @param socket fd + * @param write to this buf, not NULL terminated + * @param buffer size + * @param reuse existing pollfd struct + * @param timeout (in microseconds) + * @param read () return value/written bytes + * @return WAITRESS_RET_OK, WAITRESS_RET_TIMEOUT, WAITRESS_RET_ERR + */ +static WaitressReturn_t WaitressPollRead (int sockfd, char *buf, size_t count, + struct pollfd *sockpoll, int timeout, ssize_t *retSize) { + int pollres = -1; + + sockpoll->events = POLLIN; + pollres = WaitressPollLoop (sockpoll, 1, timeout); + if (pollres == 0) { + return WAITRESS_RET_TIMEOUT; + } else if (pollres == -1) { + return WAITRESS_RET_ERR; + } + if ((*retSize = read (sockfd, buf, count)) == -1) { + return WAITRESS_RET_READ_ERR; + } + return WAITRESS_RET_OK; +} + +/* FIXME: compiler macros are ugly... */ +#define CLOSE_RET(ret) close (sockfd); return ret; +#define WRITE_RET(buf, count) \ + if ((wRet = WaitressPollWrite (sockfd, buf, count, \ + &sockpoll, waith->socktimeout)) != WAITRESS_RET_OK) { \ + CLOSE_RET (wRet); \ + } +#define READ_RET(buf, count, size) \ + if ((wRet = WaitressPollRead (sockfd, buf, count, \ + &sockpoll, waith->socktimeout, size)) != WAITRESS_RET_OK) { \ + CLOSE_RET (wRet); \ + } + +/* Receive data from host and call *callback () + * @param waitress handle + * @return WaitressReturn_t + */ +WaitressReturn_t WaitressFetchCall (WaitressHandle_t *waith) { + struct addrinfo hints, *res; + int sockfd; + char recvBuf[WAITRESS_RECV_BUFFER]; + char writeBuf[2*1024]; + ssize_t recvSize = 0; + WaitressReturn_t wRet = WAITRESS_RET_OK; + struct pollfd sockpoll; + int pollres; + /* header parser vars */ + char *nextLine = NULL, *thisLine = NULL; + enum {HDRM_HEAD, HDRM_LINES, HDRM_FINISHED} hdrParseMode = HDRM_HEAD; + char statusCode[3], val[256]; + unsigned int bufFilled = 0; + + /* initialize */ + waith->contentLength = 0; + waith->contentReceived = 0; + memset (&hints, 0, sizeof hints); + + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + + /* Use proxy? */ + if (WaitressProxyEnabled (waith)) { + if (getaddrinfo (waith->proxyHost, waith->proxyPort, &hints, &res) != 0) { + return WAITRESS_RET_GETADDR_ERR; + } + } else { + if (getaddrinfo (waith->host, waith->port, &hints, &res) != 0) { + return WAITRESS_RET_GETADDR_ERR; + } + } + + if ((sockfd = socket (res->ai_family, res->ai_socktype, res->ai_protocol)) == -1) { + freeaddrinfo (res); + return WAITRESS_RET_SOCK_ERR; + } + sockpoll.fd = sockfd; + + /* we need shorter timeouts for connect() */ + fcntl (sockfd, F_SETFL, O_NONBLOCK); + + /* increase socket receive buffer */ + const int sockopt = 256*1024; + setsockopt (sockfd, SOL_SOCKET, SO_RCVBUF, &sockopt, sizeof (sockopt)); + + /* non-blocking connect will return immediately */ + connect (sockfd, res->ai_addr, res->ai_addrlen); + + sockpoll.events = POLLOUT; + pollres = WaitressPollLoop (&sockpoll, 1, waith->socktimeout); + freeaddrinfo (res); + if (pollres == 0) { + return WAITRESS_RET_TIMEOUT; + } else if (pollres == -1) { + return WAITRESS_RET_ERR; + } + /* check connect () return value */ + socklen_t pollresSize = sizeof (pollres); + getsockopt (sockfd, SOL_SOCKET, SO_ERROR, &pollres, &pollresSize); + if (pollres != 0) { + return WAITRESS_RET_CONNECT_REFUSED; + } + + /* send request */ + if (WaitressProxyEnabled (waith)) { + snprintf (writeBuf, sizeof (writeBuf), + "%s http://%s:%s%s HTTP/1.0\r\n", + (waith->method == WAITRESS_METHOD_GET ? "GET" : "POST"), + waith->host, waith->port, waith->path); + } else { + snprintf (writeBuf, sizeof (writeBuf), + "%s %s HTTP/1.0\r\n", + (waith->method == WAITRESS_METHOD_GET ? "GET" : "POST"), + waith->path); + } + WRITE_RET (writeBuf, strlen (writeBuf)); + + snprintf (writeBuf, sizeof (writeBuf), + "Host: %s\r\nUser-Agent: " PACKAGE "\r\n", waith->host); + WRITE_RET (writeBuf, strlen (writeBuf)); + + if (waith->method == WAITRESS_METHOD_POST && waith->postData != NULL) { + snprintf (writeBuf, sizeof (writeBuf), "Content-Length: %zu\r\n", + strlen (waith->postData)); + WRITE_RET (writeBuf, strlen (writeBuf)); + } + + if (waith->extraHeaders != NULL) { + WRITE_RET (waith->extraHeaders, strlen (waith->extraHeaders)); + } + + WRITE_RET ("\r\n", 2); + + if (waith->method == WAITRESS_METHOD_POST && waith->postData != NULL) { + WRITE_RET (waith->postData, strlen (waith->postData)); + } + + /* receive answer */ + nextLine = recvBuf; + while (hdrParseMode != HDRM_FINISHED) { + READ_RET (recvBuf+bufFilled, sizeof (recvBuf)-1 - bufFilled, &recvSize); + if (recvSize == 0) { + /* connection closed too early */ + CLOSE_RET (WAITRESS_RET_CONNECTION_CLOSED); + } + bufFilled += recvSize; + memset (recvBuf+bufFilled, 0, sizeof (recvBuf) - bufFilled); + thisLine = recvBuf; + + /* split */ + while ((nextLine = strchr (thisLine, '\n')) != NULL && + hdrParseMode != HDRM_FINISHED) { + /* make lines parseable by string routines */ + *nextLine = '\0'; + if (*(nextLine-1) == '\r') { + *(nextLine-1) = '\0'; + } + /* skip \0 */ + ++nextLine; + + switch (hdrParseMode) { + /* Status code */ + case HDRM_HEAD: + if (sscanf (thisLine, "HTTP/1.%*1[0-9] %3[0-9] ", + statusCode) == 1) { + if (memcmp (statusCode, "200", 3) == 0 || + memcmp (statusCode, "206", 3) == 0) { + /* everything's fine... */ + } else if (memcmp (statusCode, "403", 3) == 0) { + CLOSE_RET (WAITRESS_RET_FORBIDDEN); + } else if (memcmp (statusCode, "404", 3) == 0) { + CLOSE_RET (WAITRESS_RET_NOTFOUND); + } else { + CLOSE_RET (WAITRESS_RET_STATUS_UNKNOWN); + } + hdrParseMode = HDRM_LINES; + } /* endif */ + break; + + /* Everything else, except status code */ + case HDRM_LINES: + /* empty line => content starts here */ + if (*thisLine == '\0') { + hdrParseMode = HDRM_FINISHED; + } else { + memset (val, 0, sizeof (val)); + if (sscanf (thisLine, "Content-Length: %255c", val) == 1) { + waith->contentLength = atol (val); + } + } + break; + + default: + break; + } /* end switch */ + thisLine = nextLine; + } /* end while strchr */ + memmove (recvBuf, thisLine, thisLine-recvBuf); + bufFilled -= (thisLine-recvBuf); + } /* end while hdrParseMode */ + + /* push remaining bytes */ + if (bufFilled > 0) { + waith->contentReceived += bufFilled; + if (waith->callback (thisLine, bufFilled, waith->data) == + WAITRESS_CB_RET_ERR) { + CLOSE_RET (WAITRESS_RET_CB_ABORT); + } + } + + /* receive content */ + do { + READ_RET (recvBuf, sizeof (recvBuf), &recvSize); + if (recvSize > 0) { + waith->contentReceived += recvSize; + if (waith->callback (recvBuf, recvSize, waith->data) == + WAITRESS_CB_RET_ERR) { + wRet = WAITRESS_RET_CB_ABORT; + break; + } + } + } while (recvSize > 0); + + close (sockfd); + + if (wRet == WAITRESS_RET_OK && waith->contentReceived < waith->contentLength) { + return WAITRESS_RET_PARTIAL_FILE; + } + return wRet; +} + +#undef CLOSE_RET +#undef WRITE_RET +#undef READ_RET + +const char *WaitressErrorToStr (WaitressReturn_t wRet) { + switch (wRet) { + case WAITRESS_RET_OK: + return "Everything's fine :)"; + break; + + case WAITRESS_RET_ERR: + return "Unknown."; + break; + + case WAITRESS_RET_STATUS_UNKNOWN: + return "Unknown HTTP status code."; + break; + + case WAITRESS_RET_NOTFOUND: + return "File not found."; + break; + + case WAITRESS_RET_FORBIDDEN: + return "Forbidden."; + break; + + case WAITRESS_RET_CONNECT_REFUSED: + return "Connection refused."; + break; + + case WAITRESS_RET_SOCK_ERR: + return "Socket error."; + break; + + case WAITRESS_RET_GETADDR_ERR: + return "getaddr failed."; + break; + + case WAITRESS_RET_CB_ABORT: + return "Callback aborted request."; + break; + + case WAITRESS_RET_HDR_OVERFLOW: + return "HTTP header overflow."; + break; + + case WAITRESS_RET_PARTIAL_FILE: + return "Partial file."; + break; + + case WAITRESS_RET_TIMEOUT: + return "Timeout."; + break; + + case WAITRESS_RET_READ_ERR: + return "Read error."; + break; + + case WAITRESS_RET_CONNECTION_CLOSED: + return "Connection closed by remote host."; + break; + + default: + return "No error message available."; + break; + } +} + diff --git a/src/libwaitress/waitress.h b/src/libwaitress/waitress.h new file mode 100644 index 0000000..04333fb --- /dev/null +++ b/src/libwaitress/waitress.h @@ -0,0 +1,78 @@ +/* +Copyright (c) 2009-2010 + Lars-Dominik Braun + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +#ifndef _WAITRESS_H +#define _WAITRESS_H + +#include + +#define WAITRESS_HOST_SIZE 100 +/* max: 65,535 */ +#define WAITRESS_PORT_SIZE 6 +#define WAITRESS_PATH_SIZE 1000 +#define WAITRESS_RECV_BUFFER 10*1024 + +typedef enum {WAITRESS_METHOD_GET = 0, WAITRESS_METHOD_POST} WaitressMethod_t; + +typedef enum {WAITRESS_CB_RET_ERR, WAITRESS_CB_RET_OK} WaitressCbReturn_t; + +typedef struct { + char host[WAITRESS_HOST_SIZE]; + char port[WAITRESS_PORT_SIZE]; + char path[WAITRESS_PATH_SIZE]; + WaitressMethod_t method; + const char *extraHeaders; + const char *postData; + size_t contentLength; + size_t contentReceived; + char proxyHost[WAITRESS_HOST_SIZE]; + char proxyPort[WAITRESS_PORT_SIZE]; + /* extra data handed over to callback function */ + void *data; + WaitressCbReturn_t (*callback) (void *, size_t, void *); + int socktimeout; +} WaitressHandle_t; + +typedef enum {WAITRESS_RET_ERR = 0, WAITRESS_RET_OK, WAITRESS_RET_STATUS_UNKNOWN, + WAITRESS_RET_NOTFOUND, WAITRESS_RET_FORBIDDEN, WAITRESS_RET_CONNECT_REFUSED, + WAITRESS_RET_SOCK_ERR, WAITRESS_RET_GETADDR_ERR, + WAITRESS_RET_CB_ABORT, WAITRESS_RET_HDR_OVERFLOW, + WAITRESS_RET_PARTIAL_FILE, WAITRESS_RET_TIMEOUT, WAITRESS_RET_READ_ERR, + WAITRESS_RET_CONNECTION_CLOSED +} WaitressReturn_t; + +void WaitressInit (WaitressHandle_t *); +void WaitressFree (WaitressHandle_t *); +void WaitressSetProxy (WaitressHandle_t *, const char *, const char *); +char *WaitressUrlEncode (const char *); +char WaitressSplitUrl (const char *, char *, size_t, char *, size_t, char *, + size_t); +char WaitressSetUrl (WaitressHandle_t *, const char *); +void WaitressSetHPP (WaitressHandle_t *, const char *, const char *, + const char *); +WaitressReturn_t WaitressFetchBuf (WaitressHandle_t *, char **); +WaitressReturn_t WaitressFetchCall (WaitressHandle_t *); +const char *WaitressErrorToStr (WaitressReturn_t); + +#endif /* _WAITRESS_H */ + -- cgit v1.2.3