summaryrefslogtreecommitdiff
path: root/src/libwaitress
diff options
context:
space:
mode:
Diffstat (limited to 'src/libwaitress')
-rw-r--r--src/libwaitress/config.h1
-rw-r--r--src/libwaitress/waitress.c573
-rw-r--r--src/libwaitress/waitress.h78
3 files changed, 652 insertions, 0 deletions
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 <PromyLOPh@lavabit.com>
+
+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 <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <errno.h>
+
+#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 <PromyLOPh@lavabit.com>
+
+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 <stdlib.h>
+
+#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 */
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-05 18:34:40 +0000