aboutsummaryrefslogtreecommitdiffstats
path: root/src/inputStream_http.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/inputStream_http.c1049
1 files changed, 0 insertions, 1049 deletions
diff --git a/src/inputStream_http.c b/src/inputStream_http.c
deleted file mode 100644
index bbde11825..000000000
--- a/src/inputStream_http.c
+++ /dev/null
@@ -1,1049 +0,0 @@
-/* the Music Player Daemon (MPD)
- * Copyright (C) 2003-2007 by Warren Dukes (warren.dukes@gmail.com)
- * This project's homepage is: http://www.musicpd.org
- *
- * 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 2 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, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- */
-
-#include "inputStream_http.h"
-#include "inputStream_http_auth.h"
-
-#include "utils.h"
-#include "log.h"
-#include "conf.h"
-#include "os_compat.h"
-#include "ringbuf.h"
-#include "condition.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
-
-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;
-
-struct http_data {
- int fd;
- enum conn_state state;
-
- /* { we may have a non-multithreaded HTTP discipline in the future */
- enum conn_action action;
- int pipe_fds[2];
-
- pthread_t io_thread;
- struct ringbuf *rb;
-
- struct condition full_cond;
- struct condition empty_cond;
- struct condition action_cond;
- /* } */
-
- int nr_redirect;
- size_t icy_metaint;
- size_t icy_offset;
- char *host;
- char *path;
- char *port;
- char *proxy_auth;
- char *http_auth;
-};
-
-static int awaken_buffer_task(struct http_data *data);
-
-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);
-
- cond_init(&data->action_cond);
- cond_init(&data->full_cond);
- cond_init(&data->empty_cond);
-}
-
-static struct http_data *new_http_data(void)
-{
- struct http_data *ret = xmalloc(sizeof(struct http_data));
- init_http_data(ret);
- return ret;
-}
-
-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->proxy_auth) free(data->proxy_auth);
- if (data->http_auth) free(data->http_auth);
-
- cond_destroy(&data->action_cond);
- cond_destroy(&data->full_cond);
- cond_destroy(&data->empty_cond);
-
- xclose(data->pipe_fds[0]);
- xclose(data->pipe_fds[1]);
- ringbuf_free(data->rb);
- free(data);
-}
-
-static int parse_url(struct http_data * data, char *url)
-{
- char *colon;
- char *slash;
- char *at;
- int len;
- char *cur = url;
- size_t offset;
-
- if (!match("http://"))
- return -1;
-
- cur = url + offset;
- colon = strchr(cur, ':');
- at = strchr(cur, '@');
-
- if (data->http_auth) {
- free(data->http_auth);
- data->http_auth = NULL;
- }
-
- if (at) {
- char *user;
- char *passwd;
-
- if (colon && colon < at) {
- 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 - cur + 1);
- memcpy(user, cur, at - cur);
- user[at - cur] = '\0';
-
- passwd = xstrdup("");
- }
-
- data->http_auth = http_auth_string(user, passwd);
-
- free(user);
- free(passwd);
-
- cur = at + 1;
- colon = strchr(cur, ':');
- }
-
- slash = strchr(cur, '/');
-
- if (slash && colon && slash <= colon)
- return -1;
-
- /* fetch the host portion */
- if (colon)
- len = colon - cur + 1;
- else if (slash)
- len = slash - cur + 1;
- else
- len = strlen(cur) + 1;
-
- if (len <= 1)
- return -1;
-
- if (data->host)
- free(data->host);
- data->host = xmalloc(len);
- memcpy(data->host, cur, len - 1);
- data->host[len - 1] = '\0';
- if (data->port)
- free(data->port);
- /* fetch the port */
- if (colon && (!slash || slash != colon + 1)) {
- len = strlen(colon) - 1;
- if (slash)
- len -= strlen(slash);
- data->port = xmalloc(len + 1);
- memcpy(data->port, colon + 1, len);
- data->port[len] = '\0';
- DEBUG(__FILE__ ": Port: %s\n", data->port);
- } else {
- data->port = xstrdup("80");
- }
-
- if (data->path)
- free(data->path);
- /* fetch the path */
- data->path = proxy_host ? xstrdup(url) : xstrdup(slash ? slash : "/");
-
- return 0;
-}
-
-/* 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()));
- cond_enter(&data->action_cond);
- 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)
- cond_timedwait(&data->action_cond, 1);
- else
- cond_wait(&data->action_cond);
- ret = 0;
-out:
- cond_leave(&data->action_cond);
- return ret;
-}
-
-static int take_action(struct http_data *data)
-{
- assert(pthread_equal(data->io_thread, pthread_self()));
-
- cond_enter(&data->action_cond);
- switch (data->action) {
- case CONN_ACTION_NONE:
- cond_leave(&data->action_cond);
- 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;
- cond_signal_sync(&data->action_cond);
- cond_leave(&data->action_cond);
- 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)
-{
- struct addrinfo hints;
- int error;
-
- hints.ai_flags = 0;
- hints.ai_family = PF_UNSPEC;
- hints.ai_socktype = SOCK_STREAM;
- hints.ai_protocol = IPPROTO_TCP;
- hints.ai_addrlen = 0;
- hints.ai_addr = NULL;
- hints.ai_canonname = NULL;
- hints.ai_next = NULL;
-
- if ((error = getaddrinfo(host, port, &hints, dest))) {
- DEBUG(__FILE__ ": Error getting address info for %s:%s: %s\n",
- host, port, gai_strerror(error));
- return -1;
- }
- return 0;
-}
-
-/* returns the fd we connected to, or -1 on error */
-static int my_connect_addrs(struct addrinfo *ans)
-{
- int fd;
- struct addrinfo *ap;
-
- /* loop through possible addresses */
- for (ap = ans; ap != NULL; ap = ap->ai_next) {
- fd = socket(ap->ai_family, ap->ai_socktype, ap->ai_protocol);
- if (fd < 0) {
- DEBUG(__FILE__ ": unable to get socket: %s\n",
- strerror(errno));
- continue;
- }
-
- set_nonblocking(fd);
- 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 init_connection(struct http_data *data)
-{
- struct addrinfo *ans = NULL;
-
- 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;
-
- assert(data->fd < 0);
- data->fd = my_connect_addrs(ans);
- freeaddrinfo(ans);
-
- if (data->fd < 0)
- return -1; /* failed */
- data->state = CONN_STATE_CONNECTED;
- return 0;
-}
-
-#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)
-{
- int ret;
- int error = 0;
- socklen_t error_len = sizeof(int);
-
- ret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &error, &error_len);
- return (ret < 0 || error) ? AWAIT_ERROR : AWAIT_READY;
-}
-
-static enum await_result await_sendable(struct http_data *data)
-{
- fd_set rfds, wfds;
-
- assert(pthread_equal(data->io_thread, pthread_self()));
- assert_state(CONN_STATE_CONNECTED);
-
- 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);
-}
-
-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);
- cond_wait(&data->full_cond);
- 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()));
- cond_signal_async(&data->empty_cond);
-}
-
-static int starved_wait(struct http_data *data, const long sec)
-{
- assert(!pthread_equal(data->io_thread, pthread_self()));
- return cond_timedwait(&data->empty_cond, sec);
-}
-
-static int awaken_buffer_task(struct http_data *data)
-{
- assert(!pthread_equal(data->io_thread, pthread_self()));
-
- return ! cond_signal_async(&data->full_cond);
-}
-
-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;
-}
-
-/*
- * 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 */
-
- 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"
- "User-Agent: " PACKAGE_NAME "/" PACKAGE_VERSION "\r\n"
- "Range: bytes=%ld-\r\n"
- "%s" /* authorization */
- "Icy-Metadata:1\r\n"
- "\r\n",
- data->path,
- data->host,
- 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;
-}
-
-/* handles parsing of the first line of the HTTP response */
-static int parse_response_code(InputStream * is, const char *response)
-{
- 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;
-}
-
-static int leading_space(int c)
-{
- return (c == ' ' || c == '\t');
-}
-
-static int parse_header_dup(char **dst, char *cur)
-{
- char *eol;
- size_t len;
-
- 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;
-}
-
-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;
-
- while (cur && cur != needle) {
- assert(cur < needle);
- if (match("\r\nLocation:"))
- goto found;
- cur = strstr(cur + 2, "\r\n");
- }
- 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;
- is->ready = 1;
- return 0; /* success */
- }
- 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;
-
- 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;
-}
-
-/* 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 (parse_response_code(is, response)) {
- case 200: /* OK */
- case 206: /* Partial Content */
- break;
- case 301: /* Moved Permanently */
- case 302: /* Moved Temporarily */
- if (parse_redirect(is, response, needle) == 0)
- return 0; /* success, reconnect */
- default:
- return err_close(data);
- }
-
- parse_headers(is, response, needle);
- if (is->size <= 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;
- is->ready = 1;
-
- return 0;
-}
-
-static void * http_io_task(void *arg)
-{
- InputStream *is = (InputStream *) arg;
- struct http_data *data = (struct http_data *) is->data;
-
- cond_enter(&data->full_cond);
- 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);
- cond_leave(&data->full_cond);
- return NULL;
-}
-
-int inputStream_httpBuffer(mpd_unused InputStream *is)
-{
- return 0;
-}
-
-int inputStream_httpOpen(InputStream * is, char *url)
-{
- struct http_data *data = new_http_data();
- pthread_attr_t attr;
-
- is->seekable = 0;
- is->data = data;
- if (parse_url(data, url) < 0) {
- free_http_data(data);
- return -1;
- }
-
- is->seekFunc = inputStream_httpSeek;
- is->closeFunc = inputStream_httpClose;
- is->readFunc = inputStream_httpRead;
- is->atEOFFunc = inputStream_httpAtEOF;
- is->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));
-
- cond_enter(&data->empty_cond); /* httpClose will leave this */
- return 0;
-}
-
-int inputStream_httpSeek(InputStream * is, long offset, int whence)
-{
- 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:
- is->offset = offset;
- break;
- case SEEK_CUR:
- is->offset += offset;
- break;
- case SEEK_END:
- is->offset = is->size + offset;
- break;
- default:
- is->error = EINVAL;
- return -1;
- }
-
- diff = is->offset - old_offset;
- if (!diff)
- return 0; /* nothing to seek */
- 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 parse_icy_metadata(InputStream * is, char *metadata, size_t size)
-{
- char *r = NULL;
- 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;
- }
- cur = strtok_r(NULL, ";", &r);
- }
-}
-
-static size_t read_with_metadata(InputStream *is, unsigned char *ptr,
- ssize_t len)
-{
- 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;
- 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) {
- r = ringbuf_read(data->rb, metabuf, metalen);
- assert(r == metalen && "short metadata read");
- parse_icy_metadata(is, (char*)metabuf, metalen);
- }
- data->icy_offset = 0;
- }
- 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 readed;
-}
-
-size_t inputStream_httpRead(InputStream * is, void *_ptr, size_t size)
-{
- struct http_data *data = (struct http_data *) is->data;
- size_t len = size;
- size_t r;
- unsigned char *ptr = _ptr, *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;
- case CONN_STATE_CLOSED:
- if (!ringbuf_read_space(data->rb))
- return 0;
- }
-
- 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);
- cond_leave(&data->empty_cond);
- free_http_data(data);
- return 0;
-}
-
-int inputStream_httpAtEOF(InputStream * is)
-{
- struct http_data *data = (struct http_data *) is->data;
- if (data->state == CONN_STATE_CLOSED && !ringbuf_read_space(data->rb))
- return 1;
- return 0;
-}
-
-void inputStream_initHttp(void)
-{
- ConfigParam *param = getConfigParam(CONF_HTTP_PROXY_HOST);
- char *test;
- if (param) {
- proxy_host = 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);
- }
- proxy_port = param->value;
-
- 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);
- }
-
- 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");
-
- param = getConfigParam(CONF_HTTP_PREBUFFER_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_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");
-}
-