diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/inputStream_http.c | 1349 | ||||
| -rw-r--r-- | src/inputStream_http_auth.h | 12 |
2 files changed, 799 insertions, 562 deletions
diff --git a/src/inputStream_http.c b/src/inputStream_http.c index c2009cfb7..64d4d5b64 100644 --- a/src/inputStream_http.c +++ b/src/inputStream_http.c @@ -23,187 +23,150 @@ #include "log.h" #include "conf.h" #include "os_compat.h" - -#define HTTP_CONN_STATE_CLOSED 0 -#define HTTP_CONN_STATE_INIT 1 -#define HTTP_CONN_STATE_HELLO 2 -#define HTTP_CONN_STATE_OPEN 3 -#define HTTP_CONN_STATE_REOPEN 4 +#include "ringbuf.h" + +enum conn_state { /* only written by io thread, read by both */ + CONN_STATE_NEW, /* just (re)initialized */ + CONN_STATE_REDIRECT, /* redirect */ + CONN_STATE_CONNECTED, /* connected to the socket */ + CONN_STATE_REQUESTED, /* sent HTTP request */ + CONN_STATE_RESP_HEAD, /* reading HTTP response header */ + CONN_STATE_PREBUFFER, /* prebuffering data stream */ + CONN_STATE_BUFFER, /* buffering data stream */ + CONN_STATE_BUFFER_FULL, /* reading actual data stream */ + CONN_STATE_CLOSED /* it's over, time to die */ +}; + +/* used by all HTTP header matching */ +#define match(s) !strncasecmp(cur, s, (offset = sizeof(s) - 1)) + +#define assert_state(st) assert(data->state == st) +#define assert_state2(s1,s2) assert((data->state == s1) || (data->state == s2)) + +enum conn_action { /* only written by control thread, read by both */ + CONN_ACTION_NONE, + CONN_ACTION_CLOSE, + CONN_ACTION_DOSEEK +}; #define HTTP_BUFFER_SIZE_DEFAULT 131072 #define HTTP_PREBUFFER_SIZE_DEFAULT (HTTP_BUFFER_SIZE_DEFAULT >> 2) - #define HTTP_REDIRECT_MAX 10 -#define HTTP_MAX_TRIES 100 - -static char *proxyHost; -static char *proxyPort; -static char *proxyUser; -static char *proxyPassword; -static size_t bufferSize = HTTP_BUFFER_SIZE_DEFAULT; -static size_t prebufferSize = HTTP_PREBUFFER_SIZE_DEFAULT; - -typedef struct _InputStreemHTTPData { - char *host; - char *path; - char *port; - int sock; - int connState; - char *buffer; - size_t buflen; - int timesRedirected; - size_t icyMetaint; - int prebuffer; - size_t icyOffset; - char *proxyAuth; - char *httpAuth; - /* Number of times mpd tried to get data */ - int tries; -} InputStreamHTTPData; - -void inputStream_initHttp(void) -{ - ConfigParam *param = getConfigParam(CONF_HTTP_PROXY_HOST); - char *test; - if (param) { - proxyHost = param->value; - - param = getConfigParam(CONF_HTTP_PROXY_PORT); - - if (!param) { - FATAL("%s specified but not %s\n", CONF_HTTP_PROXY_HOST, - CONF_HTTP_PROXY_PORT); - } - proxyPort = param->value; - - param = getConfigParam(CONF_HTTP_PROXY_USER); +static char *proxy_host; +static char *proxy_port; +static char *proxy_user; +static char *proxy_password; +static size_t buffer_size = HTTP_BUFFER_SIZE_DEFAULT; +static size_t prebuffer_size = HTTP_PREBUFFER_SIZE_DEFAULT; - if (param) { - proxyUser = param->value; - - param = getConfigParam(CONF_HTTP_PROXY_PASSWORD); - - if (!param) { - FATAL("%s specified but not %s\n", - CONF_HTTP_PROXY_USER, - CONF_HTTP_PROXY_PASSWORD); - } - - proxyPassword = param->value; - } else { - param = getConfigParam(CONF_HTTP_PROXY_PASSWORD); - - if (param) { - FATAL("%s specified but not %s\n", - CONF_HTTP_PROXY_PASSWORD, CONF_HTTP_PROXY_USER); - } - } - } else if ((param = getConfigParam(CONF_HTTP_PROXY_PORT))) { - FATAL("%s specified but not %s, line %i\n", - CONF_HTTP_PROXY_PORT, CONF_HTTP_PROXY_HOST, param->line); - } else if ((param = getConfigParam(CONF_HTTP_PROXY_USER))) { - FATAL("%s specified but not %s, line %i\n", - CONF_HTTP_PROXY_USER, CONF_HTTP_PROXY_HOST, param->line); - } else if ((param = getConfigParam(CONF_HTTP_PROXY_PASSWORD))) { - FATAL("%s specified but not %s, line %i\n", - CONF_HTTP_PROXY_PASSWORD, CONF_HTTP_PROXY_HOST, - param->line); - } +struct http_data { + int fd; + enum conn_state state; - param = getConfigParam(CONF_HTTP_BUFFER_SIZE); + /* { we may have a non-multithreaded HTTP discipline in the future */ + enum conn_action action; + int pipe_fds[2]; - if (param) { - long tmp = strtol(param->value, &test, 10); - if (*test != '\0' || tmp <= 0) { - FATAL("\"%s\" specified for %s at line %i is not a " - "positive integer\n", - param->value, CONF_HTTP_BUFFER_SIZE, param->line); - } + pthread_t io_thread; + struct ringbuf *rb; - bufferSize = tmp * 1024; - } + /* TODO: fix Notify so it doesn't use ugly "pending" flag */ + pthread_mutex_t full_lock; + pthread_cond_t full_cond; + pthread_mutex_t empty_lock; + pthread_cond_t empty_cond; - param = getConfigParam(CONF_HTTP_PREBUFFER_SIZE); + pthread_mutex_t action_lock; + pthread_cond_t action_cond; + /* } */ - if (param) { - long tmp = strtol(param->value, &test, 10); - if (*test != '\0' || tmp <= 0) { - FATAL("\"%s\" specified for %s at line %i is not a " - "positive integer\n", - param->value, CONF_HTTP_PREBUFFER_SIZE, - param->line); - } + int nr_redirect; + size_t icy_metaint; + size_t icy_offset; + char *host; + char *path; + char *port; + char *proxy_auth; + char *http_auth; +}; - prebufferSize = tmp * 1024; - } +static int awaken_buffer_task(struct http_data *data); - if (prebufferSize > bufferSize) - prebufferSize = bufferSize; - assert(bufferSize > 0 && "http bufferSize too small"); - assert(prebufferSize > 0 && "http prebufferSize too small"); +static void init_http_data(struct http_data *data) +{ + data->fd = -1; + data->action = CONN_ACTION_NONE; + data->state = CONN_STATE_NEW; + init_async_pipe(data->pipe_fds); + + data->proxy_auth = proxy_host ? + proxy_auth_string(proxy_user, proxy_password) : + NULL; + data->http_auth = NULL; + data->host = NULL; + data->path = NULL; + data->port = NULL; + data->nr_redirect = 0; + data->icy_metaint = 0; + data->icy_offset = 0; + data->rb = ringbuf_create(buffer_size); + + pthread_cond_init(&data->action_cond, NULL); + pthread_mutex_init(&data->action_lock, NULL); + pthread_cond_init(&data->full_cond, NULL); + pthread_mutex_init(&data->full_lock, NULL); + pthread_cond_init(&data->empty_cond, NULL); + pthread_mutex_init(&data->empty_lock, NULL); } -static InputStreamHTTPData *newInputStreamHTTPData(void) +static struct http_data *new_http_data(void) { - InputStreamHTTPData *ret = xmalloc(sizeof(InputStreamHTTPData)); - - if (proxyHost) { - ret->proxyAuth = proxyAuthString(proxyUser, proxyPassword); - } else - ret->proxyAuth = NULL; - - ret->httpAuth = NULL; - ret->host = NULL; - ret->path = NULL; - ret->port = NULL; - ret->connState = HTTP_CONN_STATE_CLOSED; - ret->timesRedirected = 0; - ret->icyMetaint = 0; - ret->prebuffer = 0; - ret->icyOffset = 0; - ret->buffer = xmalloc(bufferSize); - ret->tries = 0; + struct http_data *ret = xmalloc(sizeof(struct http_data)); + init_http_data(ret); return ret; } -static void freeInputStreamHTTPData(InputStreamHTTPData * data) +static void free_http_data(struct http_data * data) { - if (data->host) - free(data->host); - if (data->path) - free(data->path); - if (data->port) - free(data->port); - if (data->proxyAuth) - free(data->proxyAuth); - if (data->httpAuth) - free(data->httpAuth); - - free(data->buffer); - + if (data->host) free(data->host); + if (data->path) free(data->path); + if (data->port) free(data->port); + if (data->proxy_auth) free(data->proxy_auth); + if (data->http_auth) free(data->http_auth); + + xpthread_cond_destroy(&data->action_cond); + xpthread_mutex_destroy(&data->action_lock); + xpthread_cond_destroy(&data->full_cond); + xpthread_mutex_destroy(&data->full_lock); + xpthread_cond_destroy(&data->empty_cond); + xpthread_mutex_destroy(&data->empty_lock); + + xclose(data->pipe_fds[0]); + xclose(data->pipe_fds[1]); + ringbuf_free(data->rb); free(data); } -static int parseUrl(InputStreamHTTPData * data, char *url) +static int parse_url(struct http_data * data, char *url) { - char *temp; char *colon; char *slash; char *at; int len; + char *cur = url; + size_t offset; - if (strncmp("http://", url, strlen("http://")) != 0) + if (!match("http://")) return -1; - temp = url + strlen("http://"); + cur = url + offset; + colon = strchr(cur, ':'); + at = strchr(cur, '@'); - colon = strchr(temp, ':'); - at = strchr(temp, '@'); - - if (data->httpAuth) { - free(data->httpAuth); - data->httpAuth = NULL; + if (data->http_auth) { + free(data->http_auth); + data->http_auth = NULL; } if (at) { @@ -211,42 +174,42 @@ static int parseUrl(InputStreamHTTPData * data, char *url) char *passwd; if (colon && colon < at) { - user = xmalloc(colon - temp + 1); - memcpy(user, temp, colon - temp); - user[colon - temp] = '\0'; + user = xmalloc(colon - cur + 1); + memcpy(user, cur, colon - cur); + user[colon - cur] = '\0'; passwd = xmalloc(at - colon); memcpy(passwd, colon + 1, at - colon - 1); passwd[at - colon - 1] = '\0'; } else { - user = xmalloc(at - temp + 1); - memcpy(user, temp, at - temp); - user[at - temp] = '\0'; + user = xmalloc(at - cur + 1); + memcpy(user, cur, at - cur); + user[at - cur] = '\0'; passwd = xstrdup(""); } - data->httpAuth = httpAuthString(user, passwd); + data->http_auth = http_auth_string(user, passwd); free(user); free(passwd); - temp = at + 1; - colon = strchr(temp, ':'); + cur = at + 1; + colon = strchr(cur, ':'); } - slash = strchr(temp, '/'); + slash = strchr(cur, '/'); if (slash && colon && slash <= colon) return -1; /* fetch the host portion */ if (colon) - len = colon - temp + 1; + len = colon - cur + 1; else if (slash) - len = slash - temp + 1; + len = slash - cur + 1; else - len = strlen(temp) + 1; + len = strlen(cur) + 1; if (len <= 1) return -1; @@ -254,7 +217,7 @@ static int parseUrl(InputStreamHTTPData * data, char *url) if (data->host) free(data->host); data->host = xmalloc(len); - memcpy(data->host, temp, len - 1); + memcpy(data->host, cur, len - 1); data->host[len - 1] = '\0'; if (data->port) free(data->port); @@ -274,14 +237,84 @@ static int parseUrl(InputStreamHTTPData * data, char *url) if (data->path) free(data->path); /* fetch the path */ - if (proxyHost) - data->path = xstrdup(url); - else - data->path = xstrdup(slash ? slash : "/"); + data->path = proxy_host ? xstrdup(url) : xstrdup(slash ? slash : "/"); return 0; } +static struct timespec * ts_timeout(struct timespec *ts, const long sec) +{ + struct timeval tv; + gettimeofday(&tv, NULL); + ts->tv_sec = tv.tv_sec + sec; + ts->tv_nsec = tv.tv_usec * 1000; + return ts; +} + +/* triggers an action and waits for completion */ +static int trigger_action(struct http_data *data, + enum conn_action action, + int nonblocking) +{ + int ret = -1; + + assert(!pthread_equal(data->io_thread, pthread_self())); + pthread_mutex_lock(&data->action_lock); + if (data->action != CONN_ACTION_NONE) + goto out; + data->action = action; + if (awaken_buffer_task(data)) { + /* DEBUG("wokeup from cond_wait to trigger action\n"); */ + } else if (xwrite(data->pipe_fds[1], "", 1) != 1) { + ERROR(__FILE__ ": pipe full, couldn't trigger action\n"); + data->action = CONN_ACTION_NONE; + goto out; + } + if (nonblocking) { + struct timespec ts; + pthread_cond_timedwait(&data->action_cond, + &data->action_lock, + ts_timeout(&ts, 1)); + } else { + pthread_cond_wait(&data->action_cond, &data->action_lock); + } + ret = 0; +out: + pthread_mutex_unlock(&data->action_lock); + return ret; +} + +static int take_action(struct http_data *data) +{ + assert(pthread_equal(data->io_thread, pthread_self())); + + pthread_mutex_lock(&data->action_lock); + switch (data->action) { + case CONN_ACTION_NONE: + pthread_mutex_unlock(&data->action_lock); + return 0; + case CONN_ACTION_DOSEEK: + data->state = CONN_STATE_NEW; + break; + case CONN_ACTION_CLOSE: + data->state = CONN_STATE_CLOSED; + } + xclose(data->fd); + data->fd = -1; + data->action = CONN_ACTION_NONE; + pthread_cond_signal(&data->action_cond); + pthread_mutex_unlock(&data->action_lock); + return 1; +} + +static int err_close(struct http_data *data) +{ + assert(pthread_equal(data->io_thread, pthread_self())); + xclose(data->fd); + data->state = CONN_STATE_CLOSED; + return -1; +} + /* returns -1 on error, 0 on success (and sets dest) */ static int my_getaddrinfo(struct addrinfo **dest, const char *host, const char *port) @@ -325,69 +358,191 @@ static int my_connect_addrs(struct addrinfo *ans) if (connect(fd, ap->ai_addr, ap->ai_addrlen) >= 0 || errno == EINPROGRESS) return fd; /* success */ - DEBUG(__FILE__ ": unable to connect: %s\n", strerror(errno)); xclose(fd); /* failed, get the next one */ } return -1; } -static int initHTTPConnection(InputStream * inStream) +static int init_connection(struct http_data *data) { struct addrinfo *ans = NULL; - InputStreamHTTPData *data = (InputStreamHTTPData *) inStream->data; - if ((proxyHost ? my_getaddrinfo(&ans, proxyHost, proxyPort) : - my_getaddrinfo(&ans, data->host, data->port)) < 0) + assert(pthread_equal(data->io_thread, pthread_self())); + assert_state2(CONN_STATE_NEW, CONN_STATE_REDIRECT); + + if ((proxy_host ? my_getaddrinfo(&ans, proxy_host, proxy_port) : + my_getaddrinfo(&ans, data->host, data->port)) < 0) return -1; - data->sock = my_connect_addrs(ans); + assert(data->fd < 0); + data->fd = my_connect_addrs(ans); freeaddrinfo(ans); - if (data->sock < 0) + if (data->fd < 0) return -1; /* failed */ - data->connState = HTTP_CONN_STATE_INIT; - data->buflen = 0; + data->state = CONN_STATE_CONNECTED; return 0; } -static int finishHTTPInit(InputStream * inStream) +#define my_nfds(d) ((d->fd > d->pipe_fds[0] ? d->fd : d->pipe_fds[0]) + 1) + +static int pipe_notified(struct http_data * data, fd_set *rfds) +{ + char buf; + int fd = data->pipe_fds[0]; + + assert(pthread_equal(data->io_thread, pthread_self())); + return FD_ISSET(fd, rfds) && (xread(fd, &buf, 1) == 1); +} + +enum await_result { + AWAIT_READY, + AWAIT_ACTION_PENDING, + AWAIT_ERROR +}; + +static enum await_result socket_error_or_ready(int fd) { - InputStreamHTTPData *data = (InputStreamHTTPData *) inStream->data; - struct timeval tv; - fd_set writeSet; - fd_set errorSet; - int error; - socklen_t error_len = sizeof(int); int ret; - size_t length; - ssize_t nbytes; - char request[2048]; + int error = 0; + socklen_t error_len = sizeof(int); - tv.tv_sec = 0; - tv.tv_usec = 0; + ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &error_len); + return (ret < 0 || error) ? AWAIT_ERROR : AWAIT_READY; +} - FD_ZERO(&writeSet); - FD_ZERO(&errorSet); - FD_SET(data->sock, &writeSet); - FD_SET(data->sock, &errorSet); +static enum await_result await_sendable(struct http_data *data) +{ + fd_set rfds, wfds; - ret = select(data->sock + 1, NULL, &writeSet, &errorSet, &tv); + assert(pthread_equal(data->io_thread, pthread_self())); + assert_state(CONN_STATE_CONNECTED); - if (ret == 0 || (ret < 0 && errno == EINTR)) - return 0; + FD_ZERO(&rfds); + FD_ZERO(&wfds); + FD_SET(data->pipe_fds[0], &rfds); + FD_SET(data->fd, &wfds); + + if (select(my_nfds(data), &rfds, &wfds, NULL, NULL) <= 0) + return AWAIT_ERROR; + if (pipe_notified(data, &rfds)) return AWAIT_ACTION_PENDING; + return socket_error_or_ready(data->fd); +} - if (ret < 0) { - DEBUG(__FILE__ ": problem select'ing: %s\n", strerror(errno)); - goto close_err; +static enum await_result await_recvable(struct http_data *data) +{ + fd_set rfds; + + assert(pthread_equal(data->io_thread, pthread_self())); + + FD_ZERO(&rfds); + FD_SET(data->pipe_fds[0], &rfds); + FD_SET(data->fd, &rfds); + + if (select(my_nfds(data), &rfds, NULL, NULL, NULL) <= 0) + return AWAIT_ERROR; + if (pipe_notified(data, &rfds)) return AWAIT_ACTION_PENDING; + return socket_error_or_ready(data->fd); +} + +static void await_buffer_space(struct http_data *data) +{ + assert(pthread_equal(data->io_thread, pthread_self())); + assert_state(CONN_STATE_BUFFER_FULL); + pthread_cond_wait(&data->full_cond, &data->full_lock); + if (ringbuf_write_space(data->rb) > 0) + data->state = CONN_STATE_BUFFER; + /* else spurious wakeup or action triggered ... */ +} + +static void feed_starved(struct http_data *data) +{ + assert(pthread_equal(data->io_thread, pthread_self())); + + if (!pthread_mutex_trylock(&data->empty_lock)) { + pthread_cond_signal(&data->empty_cond); + pthread_mutex_unlock(&data->empty_lock); + } +} + +static int starved_wait(struct http_data *data, const long sec) +{ + struct timespec ts; + + assert(!pthread_equal(data->io_thread, pthread_self())); + return pthread_cond_timedwait(&data->empty_cond, + &data->empty_lock, + ts_timeout(&ts, sec)); +} + +static int awaken_buffer_task(struct http_data *data) +{ + assert(!pthread_equal(data->io_thread, pthread_self())); + if (!pthread_mutex_trylock(&data->full_lock)) { + pthread_cond_signal(&data->full_cond); + pthread_mutex_unlock(&data->full_lock); + return 1; + } + return 0; +} + +static ssize_t buffer_data(InputStream *is) +{ + struct iovec vec[2]; + ssize_t r; + struct http_data *data = (struct http_data *)is->data; + + assert(pthread_equal(data->io_thread, pthread_self())); + assert_state2(CONN_STATE_BUFFER, CONN_STATE_PREBUFFER); + + if (!ringbuf_get_write_vector(data->rb, vec)) { + data->state = CONN_STATE_BUFFER_FULL; + return 0; } + r = readv(data->fd, vec, vec[1].iov_len ? 2 : 1); + if (r > 0) { + size_t buflen; + + ringbuf_write_advance(data->rb, r); + buflen = ringbuf_read_space(data->rb); + if (buflen == 0 || buflen < data->icy_metaint) + data->state = CONN_STATE_PREBUFFER; + else if (buflen >= prebuffer_size) + data->state = CONN_STATE_BUFFER; + if (data->state == CONN_STATE_BUFFER) + feed_starved(data); + return r; + } else if (r < 0) { + if (errno == EAGAIN || errno == EINTR) + return 0; + is->error = errno; + } + err_close(data); + return r; +} - getsockopt(data->sock, SOL_SOCKET, SO_ERROR, &error, &error_len); - if (error) - goto close_err; +/* + * This requires the socket to be writable beforehand (determined via + * select(2)). This does NOT retry or continue if we can't write the + * HTTP header in one shot. One reason for this is laziness, I don't + * want to have to store the header when recalling this function, but + * the other reason is practical, too: if we can't send a small HTTP + * request without blocking, the connection is pathetic anyways and we + * should just stop + * + * Returns -1 on error, 0 on success + */ +static int send_request(InputStream * is) +{ + struct http_data *data = (struct http_data *) is->data; + int length; + ssize_t nbytes; + char request[2048]; /* todo(?): write item-at-a-time and cork */ - /* deal with ICY metadata later, for now its fucking up stuff! */ - length = (size_t)snprintf(request, sizeof(request), + assert(pthread_equal(data->io_thread, pthread_self())); + assert_state(CONN_STATE_CONNECTED); + length = snprintf(request, sizeof(request), "GET %s HTTP/1.1\r\n" "Host: %s\r\n" "Connection: close\r\n" @@ -398,447 +553,529 @@ static int finishHTTPInit(InputStream * inStream) "\r\n", data->path, data->host, - inStream->offset, - data->proxyAuth ? data->proxyAuth : - (data->httpAuth ? data->httpAuth : "")); - - if (length >= sizeof(request)) - goto close_err; - nbytes = write(data->sock, request, length); - if (nbytes < 0 || (size_t)nbytes != length) - goto close_err; - - data->connState = HTTP_CONN_STATE_HELLO; + is->offset, + data->proxy_auth ? data->proxy_auth : + (data->http_auth ? data->http_auth : "")); + if (length < 0 || length >= (int)sizeof(request)) + return err_close(data); + nbytes = write(data->fd, request, (size_t)length); + if (nbytes < 0 || nbytes != (ssize_t)length) + return err_close(data); + data->state = CONN_STATE_REQUESTED; return 0; - -close_err: - close(data->sock); - data->connState = HTTP_CONN_STATE_CLOSED; - return -1; } -static int getHTTPHello(InputStream * inStream) +/* handles parsing of the first line of the HTTP response */ +static int parse_response_code(InputStream * is, const char *response) { - InputStreamHTTPData *data = (InputStreamHTTPData *) inStream->data; - fd_set readSet; - struct timeval tv; - int ret; - char *needle; - char *cur = data->buffer; - int rc; - long readed; + size_t offset; + const char *cur = response; + + is->seekable = 0; + if (match("HTTP/1.0 ")) { + return atoi(cur + offset); + } else if (match("HTTP/1.1 ")) { + is->seekable = 1; + return atoi(cur + offset); + } else if (match("ICY 200 OK")) { + return 200; + } else if (match("ICY 400 Server Full")) { + return 400; + } else if (match("ICY 404")) + return 404; + return 0; +} - FD_ZERO(&readSet); - FD_SET(data->sock, &readSet); +static int leading_space(int c) +{ + return (c == ' ' || c == '\t'); +} - tv.tv_sec = 0; - tv.tv_usec = 0; +static int parse_header_dup(char **dst, char *cur) +{ + char *eol; + size_t len; - ret = select(data->sock + 1, &readSet, NULL, NULL, &tv); + if (!(eol = strstr(cur, "\r\n"))) + return -1; + *eol = '\0'; + while (leading_space(*cur)) + cur++; + len = strlen(cur) + 1; + *dst = xrealloc(*dst, len); + memcpy(*dst, cur, len); + *eol = '\r'; + return 0; +} - if (ret == 0 || (ret < 0 && errno == EINTR)) - return 0; +static int parse_redirect(InputStream * is, char *response, const char *needle) +{ + char *url = NULL; + char *cur = strstr(response, "\r\n"); + size_t offset; + struct http_data *data = (struct http_data *) is->data; + int ret; - if (ret < 0) { - data->connState = HTTP_CONN_STATE_CLOSED; - close(data->sock); - data->buflen = 0; - return -1; + while (cur && cur != needle) { + assert(cur < needle); + if (match("\r\nLocation:")) + goto found; + cur = strstr(cur + 2, "\r\n"); } - - if (data->buflen >= bufferSize - 1) { - data->connState = HTTP_CONN_STATE_CLOSED; - close(data->sock); + return -1; +found: + if (parse_header_dup(&url, cur + offset) < 0) return -1; + ret = parse_url(data, url); + free(url); + if (!ret && data->nr_redirect < HTTP_REDIRECT_MAX) { + data->nr_redirect++; + xclose(data->fd); + data->fd = -1; + data->state = CONN_STATE_REDIRECT; + return 0; /* success */ } + return -1; +} - readed = recv(data->sock, data->buffer + data->buflen, - bufferSize - 1 - data->buflen, 0); - - if (readed < 0 && (errno == EAGAIN || errno == EINTR)) - return 0; - - if (readed <= 0) { - data->connState = HTTP_CONN_STATE_CLOSED; - close(data->sock); - data->buflen = 0; - return -1; +static int parse_headers(InputStream * is, char *response, const char *needle) +{ + struct http_data *data = (struct http_data *) is->data; + char *cur = strstr(response, "\r\n"); + size_t offset; + long tmp; + + data->icy_metaint = 0; + data->icy_offset = 0; + if (is->mime) { + free(is->mime); + is->mime = NULL; } + if (is->metaName) { + free(is->metaName); + is->metaName = NULL; + } + is->size = 0; - data->buffer[data->buflen + readed] = '\0'; - data->buflen += readed; - - needle = strstr(data->buffer, "\r\n\r\n"); - - if (!needle) - return 0; + while (cur && cur != needle) { + assert(cur < needle); + if (match("\r\nContent-Length:")) { + if ((tmp = atol(cur + offset)) >= 0) + is->size = tmp; + } else if (match("\r\nicy-metaint:")) { + if ((tmp = atol(cur + offset)) >= 0) + data->icy_metaint = tmp; + } else if (match("\r\nicy-name:") || + match("\r\nice-name:") || + match("\r\nx-audiocast-name:")) { + if (parse_header_dup(&is->metaName, cur + offset) < 0) + return -1; + DEBUG(__FILE__": metaName: %s\n", is->metaName); + } else if (match("\r\nContent-Type:")) { + if (parse_header_dup(&is->mime, cur + offset) < 0) + return -1; + } + cur = strstr(cur + 2, "\r\n"); + } + return 0; +} - if (0 == strncmp(cur, "HTTP/1.0 ", 9)) { - inStream->seekable = 0; - rc = atoi(cur + 9); - } else if (0 == strncmp(cur, "HTTP/1.1 ", 9)) { - inStream->seekable = 1; - rc = atoi(cur + 9); - } else if (0 == strncmp(cur, "ICY 200 OK", 10)) { - inStream->seekable = 0; - rc = 200; - } else if (0 == strncmp(cur, "ICY 400 Server Full", 19)) - rc = 400; - else if (0 == strncmp(cur, "ICY 404", 7)) - rc = 404; - else { - close(data->sock); - data->connState = HTTP_CONN_STATE_CLOSED; +/* Returns -1 on error, 0 on success */ +static int recv_response(InputStream * is) +{ + struct http_data *data = (struct http_data *) is->data; + char *needle; + char response[2048]; + const size_t response_max = sizeof(response) - 1; + ssize_t r; + ssize_t peeked; + + assert(pthread_equal(data->io_thread, pthread_self())); + assert_state2(CONN_STATE_RESP_HEAD, CONN_STATE_REQUESTED); + do { + r = recv(data->fd, response, response_max, MSG_PEEK); + } while (r < 0 && errno == EINTR); + if (r <= 0) + return err_close(data); /* EOF */ + response[r] = '\0'; + if (!(needle = strstr(response, "\r\n\r\n"))) { + if ((size_t)r == response_max) + return err_close(data); + /* response too small, try again */ + data->state = CONN_STATE_RESP_HEAD; return -1; } - switch (rc) { - case 200: - case 206: + switch (parse_response_code(is, response)) { + case 200: /* OK */ + case 206: /* Partial Content */ break; - case 301: - case 302: - cur = strstr(cur, "Location: "); - if (cur) { - char *url; - int curlen = 0; - cur += strlen("Location: "); - while (*(cur + curlen) != '\0' - && *(cur + curlen) != '\r') { - curlen++; - } - url = xmalloc(curlen + 1); - memcpy(url, cur, curlen); - url[curlen] = '\0'; - ret = parseUrl(data, url); - free(url); - if (ret == 0 && data->timesRedirected < - HTTP_REDIRECT_MAX) { - data->timesRedirected++; - close(data->sock); - data->connState = HTTP_CONN_STATE_REOPEN; - data->buflen = 0; - return 0; - } - } - case 400: - case 401: - case 403: - case 404: + case 301: /* Moved Permanently */ + case 302: /* Moved Temporarily */ + if (parse_redirect(is, response, needle) == 0) + return 0; /* success, reconnect */ default: - close(data->sock); - data->connState = HTTP_CONN_STATE_CLOSED; - data->buflen = 0; - return -1; + return err_close(data); } - cur = strstr(data->buffer, "\r\n"); - while (cur && cur != needle) { - if (0 == strncasecmp(cur, "\r\nContent-Length: ", 18)) { - if (!inStream->size) - inStream->size = atol(cur + 18); - } else if (0 == strncasecmp(cur, "\r\nicy-metaint:", 14)) { - data->icyMetaint = strtoul(cur + 14, NULL, 0); - } else if (0 == strncasecmp(cur, "\r\nicy-name:", 11) || - 0 == strncasecmp(cur, "\r\nice-name:", 11)) { - int incr = 11; - char *temp = strstr(cur + incr, "\r\n"); - if (!temp) - break; - *temp = '\0'; - if (inStream->metaName) - free(inStream->metaName); - while (*(incr + cur) == ' ') - incr++; - inStream->metaName = xstrdup(cur + incr); - *temp = '\r'; - DEBUG("inputStream_http: metaName: %s\n", - inStream->metaName); - } else if (0 == strncasecmp(cur, "\r\nx-audiocast-name:", 19)) { - int incr = 19; - char *temp = strstr(cur + incr, "\r\n"); - if (!temp) - break; - *temp = '\0'; - if (inStream->metaName) - free(inStream->metaName); - while (*(incr + cur) == ' ') - incr++; - inStream->metaName = xstrdup(cur + incr); - *temp = '\r'; - DEBUG("inputStream_http: metaName: %s\n", - inStream->metaName); - } else if (0 == strncasecmp(cur, "\r\nContent-Type:", 15)) { - int incr = 15; - char *temp = strstr(cur + incr, "\r\n"); - if (!temp) - break; - *temp = '\0'; - if (inStream->mime) - free(inStream->mime); - while (*(incr + cur) == ' ') - incr++; - inStream->mime = xstrdup(cur + incr); - *temp = '\r'; - } - - cur = strstr(cur + 2, "\r\n"); - } + parse_headers(is, response, needle); + if (is->size <= 0) + is->seekable = 0; + is->seekable = 0; + needle += sizeof("\r\n\r\n") - 1; + peeked = needle - response; + assert(peeked <= r); + do { + r = recv(data->fd, response, peeked, 0); + } while (r < 0 && errno == EINTR); + assert(r == peeked && "r != peeked"); + + ringbuf_writer_reset(data->rb); + data->state = CONN_STATE_PREBUFFER; - if (inStream->size <= 0) - inStream->seekable = 0; - - needle += 4; /* 4 == strlen("\r\n\r\n") */ - data->buflen -= (needle - data->buffer); - memmove(data->buffer, needle, data->buflen); - - data->connState = HTTP_CONN_STATE_OPEN; + return 0; +} - data->prebuffer = 1; +static void * http_io_task(void *arg) +{ + InputStream *is = (InputStream *) arg; + struct http_data *data = (struct http_data *) is->data; + + pthread_mutex_lock(&data->full_lock); + while (1) { + take_action(data); + switch (data->state) { + case CONN_STATE_NEW: + case CONN_STATE_REDIRECT: + init_connection(data); + break; + case CONN_STATE_CONNECTED: + switch (await_sendable(data)) { + case AWAIT_READY: send_request(is); break; + case AWAIT_ACTION_PENDING: break; + case AWAIT_ERROR: goto err; + } + break; + case CONN_STATE_REQUESTED: + case CONN_STATE_RESP_HEAD: + switch (await_recvable(data)) { + case AWAIT_READY: recv_response(is); break; + case AWAIT_ACTION_PENDING: break; + case AWAIT_ERROR: goto err; + } + break; + case CONN_STATE_PREBUFFER: + case CONN_STATE_BUFFER: + switch (await_recvable(data)) { + case AWAIT_READY: buffer_data(is); break; + case AWAIT_ACTION_PENDING: break; + case AWAIT_ERROR: goto err; + } + break; + case CONN_STATE_BUFFER_FULL: + await_buffer_space(data); + break; + case CONN_STATE_CLOSED: goto closed; + } + } +err: + err_close(data); +closed: + assert_state(CONN_STATE_CLOSED); + pthread_mutex_unlock(&data->full_lock); + return NULL; +} +int inputStream_httpBuffer(InputStream *is) +{ return 0; } -int inputStream_httpOpen(InputStream * inStream, char *url) +int inputStream_httpOpen(InputStream * is, char *url) { - InputStreamHTTPData *data = newInputStreamHTTPData(); + struct http_data *data = new_http_data(); + pthread_attr_t attr; - inStream->data = data; - if (parseUrl(data, url) < 0) { - freeInputStreamHTTPData(data); + is->seekable = 0; + is->data = data; + if (parse_url(data, url) < 0) { + free_http_data(data); return -1; } - if (initHTTPConnection(inStream) < 0) { - freeInputStreamHTTPData(data); - return -1; - } + is->seekFunc = inputStream_httpSeek; + is->closeFunc = inputStream_httpClose; + is->readFunc = inputStream_httpRead; + is->atEOFFunc = inputStream_httpAtEOF; + is->bufferFunc = inputStream_httpBuffer; - inStream->seekFunc = inputStream_httpSeek; - inStream->closeFunc = inputStream_httpClose; - inStream->readFunc = inputStream_httpRead; - inStream->atEOFFunc = inputStream_httpAtEOF; - inStream->bufferFunc = inputStream_httpBuffer; + pthread_attr_init(&attr); + if (pthread_create(&data->io_thread, &attr, http_io_task, is)) + FATAL("failed to spawn http_io_task: %s", strerror(errno)); + pthread_mutex_lock(&data->empty_lock); return 0; } -int inputStream_httpSeek(InputStream * inStream, long offset, int whence) +int inputStream_httpSeek(InputStream * is, long offset, int whence) { - InputStreamHTTPData *data; - if (!inStream->seekable) + struct http_data *data = (struct http_data *)is->data; + long old_offset = is->offset; + long diff; + + if (!is->seekable) { + is->error = ESPIPE; return -1; + } + assert(is->size > 0); switch (whence) { case SEEK_SET: - inStream->offset = offset; + is->offset = offset; break; case SEEK_CUR: - inStream->offset += offset; + is->offset += offset; break; case SEEK_END: - inStream->offset = inStream->size + offset; + is->offset = is->size + offset; break; default: + is->error = EINVAL; return -1; } - data = (InputStreamHTTPData *)inStream->data; - close(data->sock); - data->connState = HTTP_CONN_STATE_REOPEN; - data->buflen = 0; - - inputStream_httpBuffer(inStream); - + diff = is->offset - old_offset; + if (diff > 0) { /* seek forward if we've already buffered it */ + long avail = (long)ringbuf_read_space(data->rb); + if (avail >= diff) { + ringbuf_read_advance(data->rb, diff); + return 0; + } + } + trigger_action(data, CONN_ACTION_DOSEEK, 0); return 0; } -static void parseIcyMetadata(InputStream * inStream, char *metadata, int size) +static void parse_icy_metadata(InputStream * is, char *metadata, size_t size) { char *r = NULL; - char *s; - char *temp = xmalloc(size + 1); - memcpy(temp, metadata, size); - temp[size] = '\0'; - s = strtok_r(temp, ";", &r); - while (s) { - if (0 == strncmp(s, "StreamTitle=", 12)) { - int cur = 12; - if (inStream->metaTitle) - free(inStream->metaTitle); - if (*(s + cur) == '\'') - cur++; - if (s[strlen(s) - 1] == '\'') { - s[strlen(s) - 1] = '\0'; - } - inStream->metaTitle = xstrdup(s + cur); - DEBUG("inputStream_http: metaTitle: %s\n", - inStream->metaTitle); + char *cur; + size_t offset; + + assert(size); + metadata[size] = '\0'; + cur = strtok_r(metadata, ";", &r); + while (cur) { + if (match("StreamTitle=")) { + if (is->metaTitle) + free(is->metaTitle); + if (cur[offset] == '\'') + offset++; + if (r[-2] == '\'') + r[-2] = '\0'; + is->metaTitle = xstrdup(cur + offset); + DEBUG(__FILE__ ": metaTitle: %s\n", is->metaTitle); + return; } - s = strtok_r(NULL, ";", &r); + cur = strtok_r(NULL, ";", &r); } - free(temp); } -size_t inputStream_httpRead(InputStream * inStream, void *ptr, size_t size, - size_t nmemb) +static size_t read_with_metadata(InputStream *is, void *ptr, ssize_t len) { - InputStreamHTTPData *data = (InputStreamHTTPData *) inStream->data; - size_t tosend = 0; - size_t inlen = size * nmemb; - size_t maxToSend = data->buflen; - - inputStream_httpBuffer(inStream); - - switch (data->connState) { - case HTTP_CONN_STATE_OPEN: - if (data->prebuffer || data->buflen < data->icyMetaint) - return 0; - - break; - case HTTP_CONN_STATE_CLOSED: - if (data->buflen) + struct http_data *data = (struct http_data *) is->data; + size_t readed = 0; + size_t r; + size_t to_read; + assert(data->icy_metaint > 0); + + while (len > 0) { + if (ringbuf_read_space(data->rb) < data->icy_metaint) break; - default: - return 0; - } - - if (data->icyMetaint > 0) { - if (data->icyOffset >= data->icyMetaint) { - size_t metalen = *(data->buffer); - /* maybe we're in some strange universe where a byte - * can hold more than 255 ... */ - assert(metalen <= 255 && "metalen greater than 255"); + if (data->icy_offset >= data->icy_metaint) { + unsigned char metabuf[(UCHAR_MAX << 4) + 1]; + size_t metalen; + r = ringbuf_read(data->rb, metabuf, 1); + assert(r == 1 && "failed to read"); + awaken_buffer_task(data); + metalen = *(metabuf); metalen <<= 4; - if (metalen + 1 > data->buflen) { - /* damn that's some fucking big metadata! */ - if (bufferSize < metalen + 1) { - data->connState = - HTTP_CONN_STATE_CLOSED; - close(data->sock); - data->buflen = 0; - } - return 0; + if (metalen) { + r = ringbuf_read(data->rb, metabuf, metalen); + assert(r == metalen && "short metadata read"); + parse_icy_metadata(is, (char*)metabuf, metalen); } - if (metalen > 0) { - parseIcyMetadata(inStream, data->buffer + 1, - metalen); - } - data->buflen -= metalen + 1; - memmove(data->buffer, data->buffer + metalen + 1, - data->buflen); - data->icyOffset = 0; + data->icy_offset = 0; } - assert(data->icyOffset <= data->icyMetaint && - "icyOffset bigger than icyMetaint!"); - maxToSend = data->icyMetaint - data->icyOffset; - maxToSend = maxToSend > data->buflen ? data->buflen : maxToSend; - } - - if (data->buflen > 0) { - tosend = inlen > maxToSend ? maxToSend : inlen; - tosend = (tosend / size) * size; - - memcpy(ptr, data->buffer, tosend); - data->buflen -= tosend; - data->icyOffset += tosend; - memmove(data->buffer, data->buffer + tosend, data->buflen); - - inStream->offset += tosend; + to_read = len; + if (to_read > (data->icy_metaint - data->icy_offset)) + to_read = data->icy_metaint - data->icy_offset; + if (!(r = ringbuf_read(data->rb, ptr, to_read))) + break; + awaken_buffer_task(data); + len -= r; + ptr += r; + readed += r; + data->icy_offset += r; } - - return tosend / size; + return readed; } -int inputStream_httpClose(InputStream * inStream) +size_t inputStream_httpRead(InputStream * is, void *ptr, size_t size, + size_t nmemb) { - InputStreamHTTPData *data = (InputStreamHTTPData *) inStream->data; - - switch (data->connState) { - case HTTP_CONN_STATE_CLOSED: + struct http_data *data = (struct http_data *) is->data; + size_t len = size * nmemb; + size_t r; + void *ptr0 = ptr; + long tries = len / 128; /* try harder for bigger reads */ + +retry: + switch (data->state) { + case CONN_STATE_NEW: + case CONN_STATE_REDIRECT: + case CONN_STATE_CONNECTED: + case CONN_STATE_REQUESTED: + case CONN_STATE_RESP_HEAD: + case CONN_STATE_PREBUFFER: + if ((starved_wait(data, 1) == 0) || (tries-- > 0)) + goto retry; /* success */ + return 0; + case CONN_STATE_BUFFER: + case CONN_STATE_BUFFER_FULL: break; - default: - close(data->sock); + case CONN_STATE_CLOSED: + if (!ringbuf_read_space(data->rb)) + return 0; } - freeInputStreamHTTPData(data); + while (1) { + if (data->icy_metaint > 0) + r = read_with_metadata(is, ptr, len); + else /* easy, no metadata to worry about */ + r = ringbuf_read(data->rb, ptr, len); + assert(r <= len); + if (r) { + awaken_buffer_task(data); + is->offset += r; + ptr += r; + len -= r; + } + if (!len || (--tries < 0) || + (data->state == CONN_STATE_CLOSED && + !ringbuf_read_space(data->rb))) + break; + starved_wait(data, 1); + } + return (ptr - ptr0) / size; +} +int inputStream_httpClose(InputStream * is) +{ + struct http_data *data = (struct http_data *) is->data; + + /* + * The cancellation routines in pthreads suck (and + * are probably unportable) and using signal handlers + * between threads is _definitely_ unportable. + */ + while (data->state != CONN_STATE_CLOSED) + trigger_action(data, CONN_ACTION_CLOSE, 1); + pthread_join(data->io_thread, NULL); + pthread_mutex_unlock(&data->empty_lock); + free_http_data(data); return 0; } -int inputStream_httpAtEOF(InputStream * inStream) +int inputStream_httpAtEOF(InputStream * is) { - InputStreamHTTPData *data = (InputStreamHTTPData *) inStream->data; - switch (data->connState) { - case HTTP_CONN_STATE_CLOSED: - if (data->buflen == 0) - return 1; - default: - return 0; - } + struct http_data *data = (struct http_data *) is->data; + if (data->state == CONN_STATE_CLOSED && !ringbuf_read_space(data->rb)) + return 1; + return 0; } -int inputStream_httpBuffer(InputStream * inStream) +void inputStream_initHttp(void) { - InputStreamHTTPData *data = (InputStreamHTTPData *) inStream->data; - ssize_t readed = 0; - if (data->connState == HTTP_CONN_STATE_REOPEN) { - if (initHTTPConnection(inStream) < 0) - return -1; - } + ConfigParam *param = getConfigParam(CONF_HTTP_PROXY_HOST); + char *test; + if (param) { + proxy_host = param->value; - if (data->connState == HTTP_CONN_STATE_INIT) { - if (finishHTTPInit(inStream) < 0) - return -1; - } + param = getConfigParam(CONF_HTTP_PROXY_PORT); - if (data->connState == HTTP_CONN_STATE_HELLO) { - if (getHTTPHello(inStream) < 0) - return -1; - } + if (!param) { + FATAL("%s specified but not %s\n", CONF_HTTP_PROXY_HOST, + CONF_HTTP_PROXY_PORT); + } + proxy_port = param->value; - switch (data->connState) { - case HTTP_CONN_STATE_OPEN: - case HTTP_CONN_STATE_CLOSED: - break; - default: - return -1; + param = getConfigParam(CONF_HTTP_PROXY_USER); + + if (param) { + proxy_user = param->value; + + param = getConfigParam(CONF_HTTP_PROXY_PASSWORD); + + if (!param) { + FATAL("%s specified but not %s\n", + CONF_HTTP_PROXY_USER, + CONF_HTTP_PROXY_PASSWORD); + } + + proxy_password = param->value; + } else { + param = getConfigParam(CONF_HTTP_PROXY_PASSWORD); + + if (param) { + FATAL("%s specified but not %s\n", + CONF_HTTP_PROXY_PASSWORD, CONF_HTTP_PROXY_USER); + } + } + } else if ((param = getConfigParam(CONF_HTTP_PROXY_PORT))) { + FATAL("%s specified but not %s, line %i\n", + CONF_HTTP_PROXY_PORT, CONF_HTTP_PROXY_HOST, param->line); + } else if ((param = getConfigParam(CONF_HTTP_PROXY_USER))) { + FATAL("%s specified but not %s, line %i\n", + CONF_HTTP_PROXY_USER, CONF_HTTP_PROXY_HOST, param->line); + } else if ((param = getConfigParam(CONF_HTTP_PROXY_PASSWORD))) { + FATAL("%s specified but not %s, line %i\n", + CONF_HTTP_PROXY_PASSWORD, CONF_HTTP_PROXY_HOST, + param->line); } - if (data->buflen == 0 || data->buflen < data->icyMetaint) { - data->prebuffer = 1; - } else if (data->buflen > prebufferSize) - data->prebuffer = 0; - - if (data->connState == HTTP_CONN_STATE_OPEN && - data->buflen < bufferSize - 1) { - readed = read(data->sock, data->buffer + data->buflen, - bufferSize - 1 - data->buflen); - /* - * If the connection is currently unavailable, or - * interrupted (EINTR) - * Don't give an error, so it's retried later. - * Max times in a row to retry this is HTTP_MAX_TRIES - */ - if (readed < 0 && - (errno == EAGAIN || errno == EINTR) && - data->tries < HTTP_MAX_TRIES) { - data->tries++; - DEBUG(__FILE__": Resource unavailable, trying %i " - "times again\n", HTTP_MAX_TRIES - data->tries); - readed = 0; - } else if (readed <= 0) { - while (close(data->sock) && errno == EINTR); - data->connState = HTTP_CONN_STATE_CLOSED; - readed = 0; - } else /* readed > 0, reset */ - data->tries = 0; - - data->buflen += readed; + param = getConfigParam(CONF_HTTP_BUFFER_SIZE); + + if (param) { + long tmp = strtol(param->value, &test, 10); + if (*test != '\0' || tmp <= 0) { + FATAL("\"%s\" specified for %s at line %i is not a " + "positive integer\n", + param->value, CONF_HTTP_BUFFER_SIZE, param->line); + } + + buffer_size = tmp * 1024; } + if (buffer_size < 4096) + FATAL(CONF_HTTP_BUFFER_SIZE" must be >= 4KB\n"); - if (data->buflen > prebufferSize) - data->prebuffer = 0; + param = getConfigParam(CONF_HTTP_PREBUFFER_SIZE); - return (readed ? 1 : 0); + if (param) { + long tmp = strtol(param->value, &test, 10); + if (*test != '\0' || tmp <= 0) { + FATAL("\"%s\" specified for %s at line %i is not a " + "positive integer\n", + param->value, CONF_HTTP_PREBUFFER_SIZE, + param->line); + } + + prebuffer_size = tmp * 1024; + } + + if (prebuffer_size > buffer_size) + prebuffer_size = buffer_size; + assert(buffer_size > 0 && "http buffer_size too small"); + assert(prebuffer_size > 0 && "http prebuffer_size too small"); } + diff --git a/src/inputStream_http_auth.h b/src/inputStream_http_auth.h index db4fb4584..2caf3a09d 100644 --- a/src/inputStream_http_auth.h +++ b/src/inputStream_http_auth.h @@ -27,7 +27,7 @@ #define BASE64_LENGTH(len) (4 * (((len) + 2) / 3)) -static char *base64Dup(char *s) +static char *base64dup(char *s) { int i; int len = strlen(s); @@ -64,8 +64,8 @@ static char *base64Dup(char *s) return ret; } -static char *authString(const char *header, - const char *user, const char *password) +static char *auth_string(const char *header, + const char *user, const char *password) { char *ret = NULL; int templen; @@ -80,7 +80,7 @@ static char *authString(const char *header, strcpy(temp, user); strcat(temp, ":"); strcat(temp, password); - temp64 = base64Dup(temp); + temp64 = base64dup(temp); free(temp); ret = xmalloc(strlen(temp64) + strlen(header) + 3); @@ -95,7 +95,7 @@ static char *authString(const char *header, #define PROXY_AUTH_HEADER "Proxy-Authorization: Basic " #define HTTP_AUTH_HEADER "Authorization: Basic " -#define proxyAuthString(x, y) authString(PROXY_AUTH_HEADER, x, y) -#define httpAuthString(x, y) authString(HTTP_AUTH_HEADER, x, y) +#define proxy_auth_string(x, y) auth_string(PROXY_AUTH_HEADER, x, y) +#define http_auth_string(x, y) auth_string(HTTP_AUTH_HEADER, x, y) #endif /* INPUT_STREAM_HTTP_AUTH_H */ |