2007-02-28 03:40:23 +00:00
|
|
|
/*
|
2011-10-30 16:59:01 +00:00
|
|
|
* HTTP protocol for avconv client
|
2009-01-19 15:46:40 +00:00
|
|
|
* Copyright (c) 2000, 2001 Fabrice Bellard
|
2007-02-28 03:40:23 +00:00
|
|
|
*
|
2011-03-18 17:35:10 +00:00
|
|
|
* This file is part of Libav.
|
2007-02-28 03:40:23 +00:00
|
|
|
*
|
2011-03-18 17:35:10 +00:00
|
|
|
* Libav is free software; you can redistribute it and/or
|
2007-02-28 03:40:23 +00:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
2011-03-18 17:35:10 +00:00
|
|
|
* Libav is distributed in the hope that it will be useful,
|
2007-02-28 03:40:23 +00:00
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
2011-03-18 17:35:10 +00:00
|
|
|
* License along with Libav; if not, write to the Free Software
|
2007-02-28 03:40:23 +00:00
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*/
|
2008-05-09 11:56:36 +00:00
|
|
|
|
|
|
|
#include "libavutil/avstring.h"
|
2007-02-28 03:40:23 +00:00
|
|
|
#include "avformat.h"
|
|
|
|
#include <unistd.h>
|
2010-03-14 23:59:48 +00:00
|
|
|
#include "internal.h"
|
2007-02-28 03:40:23 +00:00
|
|
|
#include "network.h"
|
2010-06-08 10:26:16 +00:00
|
|
|
#include "http.h"
|
2007-11-22 02:27:39 +00:00
|
|
|
#include "os_support.h"
|
2010-03-24 22:32:05 +00:00
|
|
|
#include "httpauth.h"
|
2011-03-31 14:25:10 +00:00
|
|
|
#include "url.h"
|
2010-09-26 14:25:22 +00:00
|
|
|
#include "libavutil/opt.h"
|
2007-02-28 03:40:23 +00:00
|
|
|
|
2011-10-30 16:59:01 +00:00
|
|
|
/* XXX: POST protocol is not completely implemented because avconv uses
|
2007-04-07 14:09:20 +00:00
|
|
|
only a subset of it. */
|
2007-02-28 03:40:23 +00:00
|
|
|
|
|
|
|
/* used for protocol handling */
|
|
|
|
#define BUFFER_SIZE 1024
|
|
|
|
#define MAX_REDIRECTS 8
|
|
|
|
|
|
|
|
typedef struct {
|
2010-06-22 14:13:55 +00:00
|
|
|
const AVClass *class;
|
2007-02-28 03:40:23 +00:00
|
|
|
URLContext *hd;
|
|
|
|
unsigned char buffer[BUFFER_SIZE], *buf_ptr, *buf_end;
|
|
|
|
int line_count;
|
|
|
|
int http_code;
|
2009-06-23 15:38:53 +00:00
|
|
|
int64_t chunksize; /**< Used if "Transfer-Encoding: chunked" otherwise -1. */
|
2008-10-03 10:16:29 +00:00
|
|
|
int64_t off, filesize;
|
2010-08-19 14:50:40 +00:00
|
|
|
char location[MAX_URL_SIZE];
|
2010-03-24 22:32:05 +00:00
|
|
|
HTTPAuthState auth_state;
|
2011-11-11 09:21:42 +00:00
|
|
|
HTTPAuthState proxy_auth_state;
|
2011-11-07 09:43:13 +00:00
|
|
|
char *headers;
|
2010-08-09 08:14:48 +00:00
|
|
|
int willclose; /**< Set if the server correctly handles Connection: close and will close the connection after feeding us the content. */
|
http: Change the chunksize AVOption into chunked_post
The chunksize internal variable has two different uses - for
reading, it's the amount of data left of the current chunk
(or -1 if the server doesn't send data in chunked mode), where
it's only an internal state variable. For writing, it's used
to decide whether to enable chunked encoding (by default), by
using the value 0, or disable chunked encoding (value -1).
This, while consistent, doesn't make much sense to expose
as an AVOption. This splits the usage of the internal variable
into two variables, chunksize which is used for reading (as
before), and chunked_post which is the user-settable option,
with the values 0 and 1, where 1 is default.
Signed-off-by: Martin Storsjö <martin@martin.st>
2011-11-10 09:03:35 +00:00
|
|
|
int chunked_post;
|
2007-02-28 03:40:23 +00:00
|
|
|
} HTTPContext;
|
|
|
|
|
2010-06-22 14:13:55 +00:00
|
|
|
#define OFFSET(x) offsetof(HTTPContext, x)
|
2011-11-10 08:34:58 +00:00
|
|
|
#define D AV_OPT_FLAG_DECODING_PARAM
|
|
|
|
#define E AV_OPT_FLAG_ENCODING_PARAM
|
2010-06-22 14:13:55 +00:00
|
|
|
static const AVOption options[] = {
|
http: Change the chunksize AVOption into chunked_post
The chunksize internal variable has two different uses - for
reading, it's the amount of data left of the current chunk
(or -1 if the server doesn't send data in chunked mode), where
it's only an internal state variable. For writing, it's used
to decide whether to enable chunked encoding (by default), by
using the value 0, or disable chunked encoding (value -1).
This, while consistent, doesn't make much sense to expose
as an AVOption. This splits the usage of the internal variable
into two variables, chunksize which is used for reading (as
before), and chunked_post which is the user-settable option,
with the values 0 and 1, where 1 is default.
Signed-off-by: Martin Storsjö <martin@martin.st>
2011-11-10 09:03:35 +00:00
|
|
|
{"chunked_post", "use chunked transfer-encoding for posts", OFFSET(chunked_post), AV_OPT_TYPE_INT, {.dbl = 1}, 0, 1, E },
|
2011-11-10 08:34:58 +00:00
|
|
|
{"headers", "custom HTTP headers, can override built in default headers", OFFSET(headers), AV_OPT_TYPE_STRING, { 0 }, 0, 0, D|E },
|
2010-06-22 14:13:55 +00:00
|
|
|
{NULL}
|
|
|
|
};
|
2011-11-05 11:54:01 +00:00
|
|
|
#define HTTP_CLASS(flavor)\
|
|
|
|
static const AVClass flavor ## _context_class = {\
|
|
|
|
.class_name = #flavor,\
|
|
|
|
.item_name = av_default_item_name,\
|
|
|
|
.option = options,\
|
|
|
|
.version = LIBAVUTIL_VERSION_INT,\
|
2011-12-11 17:07:04 +00:00
|
|
|
}
|
2010-06-22 14:13:55 +00:00
|
|
|
|
2011-11-05 11:54:01 +00:00
|
|
|
HTTP_CLASS(http);
|
|
|
|
HTTP_CLASS(https);
|
|
|
|
|
2011-11-11 09:21:42 +00:00
|
|
|
static int http_connect(URLContext *h, const char *path, const char *local_path,
|
|
|
|
const char *hoststr, const char *auth,
|
|
|
|
const char *proxyauth, int *new_location);
|
2007-02-28 03:40:23 +00:00
|
|
|
|
2010-06-21 19:40:30 +00:00
|
|
|
void ff_http_init_auth_state(URLContext *dest, const URLContext *src)
|
|
|
|
{
|
|
|
|
memcpy(&((HTTPContext*)dest->priv_data)->auth_state,
|
|
|
|
&((HTTPContext*)src->priv_data)->auth_state, sizeof(HTTPAuthState));
|
2011-11-11 09:21:42 +00:00
|
|
|
memcpy(&((HTTPContext*)dest->priv_data)->proxy_auth_state,
|
|
|
|
&((HTTPContext*)src->priv_data)->proxy_auth_state,
|
|
|
|
sizeof(HTTPAuthState));
|
2010-06-21 19:40:30 +00:00
|
|
|
}
|
|
|
|
|
2007-02-28 03:40:23 +00:00
|
|
|
/* return non zero if error */
|
|
|
|
static int http_open_cnx(URLContext *h)
|
|
|
|
{
|
2011-11-11 09:21:42 +00:00
|
|
|
const char *path, *proxy_path, *lower_proto = "tcp", *local_path;
|
2011-02-05 22:20:26 +00:00
|
|
|
char hostname[1024], hoststr[1024], proto[10];
|
2011-12-01 09:24:23 +00:00
|
|
|
char auth[1024], proxyauth[1024] = "";
|
2007-02-28 03:40:23 +00:00
|
|
|
char path1[1024];
|
2011-11-11 09:21:42 +00:00
|
|
|
char buf[1024], urlbuf[1024];
|
2012-03-12 12:00:16 +00:00
|
|
|
int port, use_proxy, err, location_changed = 0, redirects = 0, attempts = 0;
|
2011-11-11 09:21:42 +00:00
|
|
|
HTTPAuthType cur_auth_type, cur_proxy_auth_type;
|
2007-02-28 03:40:23 +00:00
|
|
|
HTTPContext *s = h->priv_data;
|
|
|
|
URLContext *hd = NULL;
|
|
|
|
|
|
|
|
proxy_path = getenv("http_proxy");
|
|
|
|
use_proxy = (proxy_path != NULL) && !getenv("no_proxy") &&
|
2007-06-24 11:27:12 +00:00
|
|
|
av_strstart(proxy_path, "http://", NULL);
|
2007-02-28 03:40:23 +00:00
|
|
|
|
|
|
|
/* fill the dest addr */
|
|
|
|
redo:
|
|
|
|
/* needed in any case to build the host string */
|
2011-02-05 22:20:26 +00:00
|
|
|
av_url_split(proto, sizeof(proto), auth, sizeof(auth),
|
|
|
|
hostname, sizeof(hostname), &port,
|
2010-03-08 09:05:03 +00:00
|
|
|
path1, sizeof(path1), s->location);
|
2010-03-05 22:35:21 +00:00
|
|
|
ff_url_join(hoststr, sizeof(hoststr), NULL, NULL, hostname, port, NULL);
|
2007-02-28 03:40:23 +00:00
|
|
|
|
2011-11-10 12:55:18 +00:00
|
|
|
if (!strcmp(proto, "https")) {
|
|
|
|
lower_proto = "tls";
|
2011-11-10 12:57:15 +00:00
|
|
|
use_proxy = 0;
|
2011-11-10 12:55:18 +00:00
|
|
|
if (port < 0)
|
|
|
|
port = 443;
|
|
|
|
}
|
|
|
|
if (port < 0)
|
|
|
|
port = 80;
|
|
|
|
|
2011-11-11 09:21:42 +00:00
|
|
|
if (path1[0] == '\0')
|
|
|
|
path = "/";
|
|
|
|
else
|
|
|
|
path = path1;
|
|
|
|
local_path = path;
|
2007-02-28 03:40:23 +00:00
|
|
|
if (use_proxy) {
|
2011-11-11 09:21:42 +00:00
|
|
|
/* Reassemble the request URL without auth string - we don't
|
|
|
|
* want to leak the auth to the proxy. */
|
|
|
|
ff_url_join(urlbuf, sizeof(urlbuf), proto, NULL, hostname, port, "%s",
|
|
|
|
path1);
|
|
|
|
path = urlbuf;
|
|
|
|
av_url_split(NULL, 0, proxyauth, sizeof(proxyauth),
|
|
|
|
hostname, sizeof(hostname), &port, NULL, 0, proxy_path);
|
2007-02-28 03:40:23 +00:00
|
|
|
}
|
|
|
|
|
2011-02-05 22:20:26 +00:00
|
|
|
ff_url_join(buf, sizeof(buf), lower_proto, NULL, hostname, port, NULL);
|
2011-11-05 09:04:04 +00:00
|
|
|
err = ffurl_open(&hd, buf, AVIO_FLAG_READ_WRITE,
|
|
|
|
&h->interrupt_callback, NULL);
|
2007-02-28 03:40:23 +00:00
|
|
|
if (err < 0)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
s->hd = hd;
|
2010-03-24 22:32:05 +00:00
|
|
|
cur_auth_type = s->auth_state.auth_type;
|
2011-11-11 09:21:42 +00:00
|
|
|
cur_proxy_auth_type = s->auth_state.auth_type;
|
|
|
|
if (http_connect(h, path, local_path, hoststr, auth, proxyauth, &location_changed) < 0)
|
2007-02-28 03:40:23 +00:00
|
|
|
goto fail;
|
2012-03-12 12:00:16 +00:00
|
|
|
attempts++;
|
2010-03-24 22:32:05 +00:00
|
|
|
if (s->http_code == 401) {
|
2012-03-12 12:00:16 +00:00
|
|
|
if ((cur_auth_type == HTTP_AUTH_NONE || s->auth_state.stale) &&
|
|
|
|
s->auth_state.auth_type != HTTP_AUTH_NONE && attempts < 4) {
|
2011-03-31 15:36:06 +00:00
|
|
|
ffurl_close(hd);
|
2010-03-24 22:32:05 +00:00
|
|
|
goto redo;
|
|
|
|
} else
|
|
|
|
goto fail;
|
|
|
|
}
|
2011-11-11 09:21:42 +00:00
|
|
|
if (s->http_code == 407) {
|
2012-03-12 12:00:16 +00:00
|
|
|
if ((cur_proxy_auth_type == HTTP_AUTH_NONE || s->proxy_auth_state.stale) &&
|
|
|
|
s->proxy_auth_state.auth_type != HTTP_AUTH_NONE && attempts < 4) {
|
2011-11-11 09:21:42 +00:00
|
|
|
ffurl_close(hd);
|
|
|
|
goto redo;
|
|
|
|
} else
|
|
|
|
goto fail;
|
|
|
|
}
|
2010-11-02 20:37:01 +00:00
|
|
|
if ((s->http_code == 301 || s->http_code == 302 || s->http_code == 303 || s->http_code == 307)
|
|
|
|
&& location_changed == 1) {
|
2007-02-28 03:40:23 +00:00
|
|
|
/* url moved, get next */
|
2011-03-31 15:36:06 +00:00
|
|
|
ffurl_close(hd);
|
2007-02-28 03:40:23 +00:00
|
|
|
if (redirects++ >= MAX_REDIRECTS)
|
2007-07-19 15:23:32 +00:00
|
|
|
return AVERROR(EIO);
|
2012-03-12 12:03:46 +00:00
|
|
|
/* Restart the authentication process with the new target, which
|
|
|
|
* might use a different auth mechanism. */
|
|
|
|
memset(&s->auth_state, 0, sizeof(s->auth_state));
|
2012-03-12 12:00:16 +00:00
|
|
|
attempts = 0;
|
2007-02-28 03:40:23 +00:00
|
|
|
location_changed = 0;
|
|
|
|
goto redo;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
fail:
|
|
|
|
if (hd)
|
2011-03-31 15:36:06 +00:00
|
|
|
ffurl_close(hd);
|
2010-06-08 11:18:22 +00:00
|
|
|
s->hd = NULL;
|
2007-07-19 15:23:32 +00:00
|
|
|
return AVERROR(EIO);
|
2007-02-28 03:40:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int http_open(URLContext *h, const char *uri, int flags)
|
|
|
|
{
|
2010-06-22 14:12:34 +00:00
|
|
|
HTTPContext *s = h->priv_data;
|
2007-02-28 03:40:23 +00:00
|
|
|
|
|
|
|
h->is_streamed = 1;
|
|
|
|
|
|
|
|
s->filesize = -1;
|
2010-08-19 14:50:40 +00:00
|
|
|
av_strlcpy(s->location, uri, sizeof(s->location));
|
2007-02-28 03:40:23 +00:00
|
|
|
|
2011-11-07 09:43:13 +00:00
|
|
|
if (s->headers) {
|
|
|
|
int len = strlen(s->headers);
|
|
|
|
if (len < 2 || strcmp("\r\n", s->headers + len - 2))
|
2011-11-08 23:14:05 +00:00
|
|
|
av_log(h, AV_LOG_WARNING, "No trailing CRLF found in HTTP header.\n");
|
2011-11-07 09:43:13 +00:00
|
|
|
}
|
|
|
|
|
2010-06-22 14:15:00 +00:00
|
|
|
return http_open_cnx(h);
|
2007-02-28 03:40:23 +00:00
|
|
|
}
|
|
|
|
static int http_getc(HTTPContext *s)
|
|
|
|
{
|
|
|
|
int len;
|
|
|
|
if (s->buf_ptr >= s->buf_end) {
|
2011-03-31 14:31:43 +00:00
|
|
|
len = ffurl_read(s->hd, s->buffer, BUFFER_SIZE);
|
2007-02-28 03:40:23 +00:00
|
|
|
if (len < 0) {
|
2007-07-19 15:23:32 +00:00
|
|
|
return AVERROR(EIO);
|
2007-02-28 03:40:23 +00:00
|
|
|
} else if (len == 0) {
|
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
s->buf_ptr = s->buffer;
|
|
|
|
s->buf_end = s->buffer + len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return *s->buf_ptr++;
|
|
|
|
}
|
|
|
|
|
2009-06-06 16:44:21 +00:00
|
|
|
static int http_get_line(HTTPContext *s, char *line, int line_size)
|
|
|
|
{
|
|
|
|
int ch;
|
|
|
|
char *q;
|
|
|
|
|
|
|
|
q = line;
|
|
|
|
for(;;) {
|
|
|
|
ch = http_getc(s);
|
|
|
|
if (ch < 0)
|
|
|
|
return AVERROR(EIO);
|
|
|
|
if (ch == '\n') {
|
|
|
|
/* process line */
|
|
|
|
if (q > line && q[-1] == '\r')
|
|
|
|
q--;
|
|
|
|
*q = '\0';
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
} else {
|
|
|
|
if ((q - line) < line_size - 1)
|
|
|
|
*q++ = ch;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-02-28 03:40:23 +00:00
|
|
|
static int process_line(URLContext *h, char *line, int line_count,
|
|
|
|
int *new_location)
|
|
|
|
{
|
|
|
|
HTTPContext *s = h->priv_data;
|
2010-07-16 14:15:37 +00:00
|
|
|
char *tag, *p, *end;
|
2007-02-28 03:40:23 +00:00
|
|
|
|
|
|
|
/* end of header */
|
|
|
|
if (line[0] == '\0')
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
p = line;
|
|
|
|
if (line_count == 0) {
|
|
|
|
while (!isspace(*p) && *p != '\0')
|
|
|
|
p++;
|
|
|
|
while (isspace(*p))
|
|
|
|
p++;
|
2010-07-16 14:15:37 +00:00
|
|
|
s->http_code = strtol(p, &end, 10);
|
2009-06-06 17:32:59 +00:00
|
|
|
|
2011-01-29 16:46:18 +00:00
|
|
|
av_dlog(NULL, "http_code=%d\n", s->http_code);
|
2009-06-06 17:32:59 +00:00
|
|
|
|
2010-03-24 22:32:05 +00:00
|
|
|
/* error codes are 4xx and 5xx, but regard 401 as a success, so we
|
|
|
|
* don't abort until all headers have been parsed. */
|
2011-11-10 16:21:17 +00:00
|
|
|
if (s->http_code >= 400 && s->http_code < 600 && (s->http_code != 401
|
2011-11-11 09:21:42 +00:00
|
|
|
|| s->auth_state.auth_type != HTTP_AUTH_NONE) &&
|
|
|
|
(s->http_code != 407 || s->proxy_auth_state.auth_type != HTTP_AUTH_NONE)) {
|
2010-07-16 14:15:37 +00:00
|
|
|
end += strspn(end, SPACE_CHARS);
|
2011-04-20 09:40:29 +00:00
|
|
|
av_log(h, AV_LOG_WARNING, "HTTP error %d %s\n",
|
2010-07-16 14:15:37 +00:00
|
|
|
s->http_code, end);
|
2007-03-06 13:38:41 +00:00
|
|
|
return -1;
|
2010-07-16 14:15:37 +00:00
|
|
|
}
|
2007-02-28 03:40:23 +00:00
|
|
|
} else {
|
|
|
|
while (*p != '\0' && *p != ':')
|
|
|
|
p++;
|
|
|
|
if (*p != ':')
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
*p = '\0';
|
|
|
|
tag = line;
|
|
|
|
p++;
|
|
|
|
while (isspace(*p))
|
|
|
|
p++;
|
2011-11-02 19:17:25 +00:00
|
|
|
if (!av_strcasecmp(tag, "Location")) {
|
2007-02-28 03:40:23 +00:00
|
|
|
strcpy(s->location, p);
|
|
|
|
*new_location = 1;
|
2011-11-02 19:17:25 +00:00
|
|
|
} else if (!av_strcasecmp (tag, "Content-Length") && s->filesize == -1) {
|
2007-02-28 03:40:23 +00:00
|
|
|
s->filesize = atoll(p);
|
2011-11-02 19:17:25 +00:00
|
|
|
} else if (!av_strcasecmp (tag, "Content-Range")) {
|
2007-02-28 03:40:23 +00:00
|
|
|
/* "bytes $from-$to/$document_size" */
|
|
|
|
const char *slash;
|
|
|
|
if (!strncmp (p, "bytes ", 6)) {
|
|
|
|
p += 6;
|
|
|
|
s->off = atoll(p);
|
|
|
|
if ((slash = strchr(p, '/')) && strlen(slash) > 0)
|
|
|
|
s->filesize = atoll(slash+1);
|
|
|
|
}
|
|
|
|
h->is_streamed = 0; /* we _can_ in fact seek */
|
2011-11-02 19:17:25 +00:00
|
|
|
} else if (!av_strcasecmp(tag, "Accept-Ranges") && !strncmp(p, "bytes", 5)) {
|
2011-09-04 08:56:24 +00:00
|
|
|
h->is_streamed = 0;
|
2011-11-02 19:17:25 +00:00
|
|
|
} else if (!av_strcasecmp (tag, "Transfer-Encoding") && !av_strncasecmp(p, "chunked", 7)) {
|
2009-06-23 15:38:53 +00:00
|
|
|
s->filesize = -1;
|
|
|
|
s->chunksize = 0;
|
2011-11-02 19:17:25 +00:00
|
|
|
} else if (!av_strcasecmp (tag, "WWW-Authenticate")) {
|
2010-03-24 22:32:05 +00:00
|
|
|
ff_http_auth_handle_header(&s->auth_state, tag, p);
|
2011-11-02 19:17:25 +00:00
|
|
|
} else if (!av_strcasecmp (tag, "Authentication-Info")) {
|
2010-03-24 22:32:05 +00:00
|
|
|
ff_http_auth_handle_header(&s->auth_state, tag, p);
|
2011-11-11 09:21:42 +00:00
|
|
|
} else if (!av_strcasecmp (tag, "Proxy-Authenticate")) {
|
|
|
|
ff_http_auth_handle_header(&s->proxy_auth_state, tag, p);
|
2011-11-02 19:17:25 +00:00
|
|
|
} else if (!av_strcasecmp (tag, "Connection")) {
|
2010-08-09 08:14:48 +00:00
|
|
|
if (!strcmp(p, "close"))
|
|
|
|
s->willclose = 1;
|
2007-02-28 03:40:23 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2010-06-08 10:26:16 +00:00
|
|
|
static inline int has_header(const char *str, const char *header)
|
|
|
|
{
|
|
|
|
/* header + 2 to skip over CRLF prefix. (make sure you have one!) */
|
2011-11-07 09:43:13 +00:00
|
|
|
if (!str)
|
|
|
|
return 0;
|
2010-06-08 10:26:16 +00:00
|
|
|
return av_stristart(str, header + 2, NULL) || av_stristr(str, header);
|
|
|
|
}
|
|
|
|
|
2011-11-11 09:21:42 +00:00
|
|
|
static int http_connect(URLContext *h, const char *path, const char *local_path,
|
|
|
|
const char *hoststr, const char *auth,
|
|
|
|
const char *proxyauth, int *new_location)
|
2007-02-28 03:40:23 +00:00
|
|
|
{
|
|
|
|
HTTPContext *s = h->priv_data;
|
2009-06-06 16:44:21 +00:00
|
|
|
int post, err;
|
|
|
|
char line[1024];
|
2010-06-08 11:06:36 +00:00
|
|
|
char headers[1024] = "";
|
2011-11-11 09:21:42 +00:00
|
|
|
char *authstr = NULL, *proxyauthstr = NULL;
|
2008-10-03 10:16:29 +00:00
|
|
|
int64_t off = s->off;
|
2010-06-08 10:26:16 +00:00
|
|
|
int len = 0;
|
2011-11-11 09:21:42 +00:00
|
|
|
const char *method;
|
2007-02-28 03:40:23 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* send http header */
|
2011-04-15 14:42:09 +00:00
|
|
|
post = h->flags & AVIO_FLAG_WRITE;
|
2011-11-11 09:21:42 +00:00
|
|
|
method = post ? "POST" : "GET";
|
|
|
|
authstr = ff_http_auth_create_response(&s->auth_state, auth, local_path,
|
|
|
|
method);
|
|
|
|
proxyauthstr = ff_http_auth_create_response(&s->proxy_auth_state, proxyauth,
|
|
|
|
local_path, method);
|
2010-06-08 10:26:16 +00:00
|
|
|
|
|
|
|
/* set default headers if needed */
|
|
|
|
if (!has_header(s->headers, "\r\nUser-Agent: "))
|
|
|
|
len += av_strlcatf(headers + len, sizeof(headers) - len,
|
|
|
|
"User-Agent: %s\r\n", LIBAVFORMAT_IDENT);
|
|
|
|
if (!has_header(s->headers, "\r\nAccept: "))
|
|
|
|
len += av_strlcpy(headers + len, "Accept: */*\r\n",
|
|
|
|
sizeof(headers) - len);
|
2011-11-10 09:09:26 +00:00
|
|
|
if (!has_header(s->headers, "\r\nRange: ") && !post)
|
2010-06-08 10:26:16 +00:00
|
|
|
len += av_strlcatf(headers + len, sizeof(headers) - len,
|
2010-06-08 11:06:36 +00:00
|
|
|
"Range: bytes=%"PRId64"-\r\n", s->off);
|
2010-06-08 10:26:16 +00:00
|
|
|
if (!has_header(s->headers, "\r\nConnection: "))
|
|
|
|
len += av_strlcpy(headers + len, "Connection: close\r\n",
|
|
|
|
sizeof(headers)-len);
|
|
|
|
if (!has_header(s->headers, "\r\nHost: "))
|
|
|
|
len += av_strlcatf(headers + len, sizeof(headers) - len,
|
|
|
|
"Host: %s\r\n", hoststr);
|
|
|
|
|
|
|
|
/* now add in custom headers */
|
2011-11-07 09:43:13 +00:00
|
|
|
if (s->headers)
|
|
|
|
av_strlcpy(headers + len, s->headers, sizeof(headers) - len);
|
2010-06-08 10:26:16 +00:00
|
|
|
|
2007-02-28 03:40:23 +00:00
|
|
|
snprintf(s->buffer, sizeof(s->buffer),
|
|
|
|
"%s %s HTTP/1.1\r\n"
|
2010-03-24 22:32:05 +00:00
|
|
|
"%s"
|
2010-06-08 10:26:16 +00:00
|
|
|
"%s"
|
2010-01-12 16:36:00 +00:00
|
|
|
"%s"
|
2011-11-11 09:21:42 +00:00
|
|
|
"%s%s"
|
2007-02-28 03:40:23 +00:00
|
|
|
"\r\n",
|
2011-11-11 09:21:42 +00:00
|
|
|
method,
|
2007-02-28 03:40:23 +00:00
|
|
|
path,
|
http: Change the chunksize AVOption into chunked_post
The chunksize internal variable has two different uses - for
reading, it's the amount of data left of the current chunk
(or -1 if the server doesn't send data in chunked mode), where
it's only an internal state variable. For writing, it's used
to decide whether to enable chunked encoding (by default), by
using the value 0, or disable chunked encoding (value -1).
This, while consistent, doesn't make much sense to expose
as an AVOption. This splits the usage of the internal variable
into two variables, chunksize which is used for reading (as
before), and chunked_post which is the user-settable option,
with the values 0 and 1, where 1 is default.
Signed-off-by: Martin Storsjö <martin@martin.st>
2011-11-10 09:03:35 +00:00
|
|
|
post && s->chunked_post ? "Transfer-Encoding: chunked\r\n" : "",
|
2010-06-08 10:26:16 +00:00
|
|
|
headers,
|
2011-11-11 09:21:42 +00:00
|
|
|
authstr ? authstr : "",
|
|
|
|
proxyauthstr ? "Proxy-" : "", proxyauthstr ? proxyauthstr : "");
|
2007-02-28 03:40:23 +00:00
|
|
|
|
2010-03-24 22:32:05 +00:00
|
|
|
av_freep(&authstr);
|
2011-11-11 09:21:42 +00:00
|
|
|
av_freep(&proxyauthstr);
|
2011-03-31 14:48:01 +00:00
|
|
|
if (ffurl_write(s->hd, s->buffer, strlen(s->buffer)) < 0)
|
2007-07-19 15:23:32 +00:00
|
|
|
return AVERROR(EIO);
|
2007-02-28 03:40:23 +00:00
|
|
|
|
|
|
|
/* init input buffer */
|
|
|
|
s->buf_ptr = s->buffer;
|
|
|
|
s->buf_end = s->buffer;
|
|
|
|
s->line_count = 0;
|
|
|
|
s->off = 0;
|
2007-03-12 14:51:18 +00:00
|
|
|
s->filesize = -1;
|
2010-08-09 08:14:48 +00:00
|
|
|
s->willclose = 0;
|
2007-02-28 03:40:23 +00:00
|
|
|
if (post) {
|
2010-06-04 06:35:12 +00:00
|
|
|
/* Pretend that it did work. We didn't read any header yet, since
|
|
|
|
* we've still to send the POST data, but the code calling this
|
|
|
|
* function will check http_code after we return. */
|
|
|
|
s->http_code = 200;
|
2007-02-28 03:40:23 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2010-06-21 19:01:32 +00:00
|
|
|
s->chunksize = -1;
|
2007-02-28 03:40:23 +00:00
|
|
|
|
|
|
|
/* wait for header */
|
|
|
|
for(;;) {
|
2009-06-06 16:44:21 +00:00
|
|
|
if (http_get_line(s, line, sizeof(line)) < 0)
|
2007-07-19 15:23:32 +00:00
|
|
|
return AVERROR(EIO);
|
2009-06-06 17:32:59 +00:00
|
|
|
|
2011-01-29 16:46:18 +00:00
|
|
|
av_dlog(NULL, "header='%s'\n", line);
|
2009-06-06 17:32:59 +00:00
|
|
|
|
2009-06-06 16:46:40 +00:00
|
|
|
err = process_line(h, line, s->line_count, new_location);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
if (err == 0)
|
|
|
|
break;
|
|
|
|
s->line_count++;
|
2007-02-28 03:40:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return (off == s->off) ? 0 : -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-11-10 12:52:50 +00:00
|
|
|
static int http_buf_read(URLContext *h, uint8_t *buf, int size)
|
2007-02-28 03:40:23 +00:00
|
|
|
{
|
|
|
|
HTTPContext *s = h->priv_data;
|
|
|
|
int len;
|
2011-11-10 12:52:50 +00:00
|
|
|
/* read bytes from input buffer first */
|
|
|
|
len = s->buf_end - s->buf_ptr;
|
|
|
|
if (len > 0) {
|
|
|
|
if (len > size)
|
|
|
|
len = size;
|
|
|
|
memcpy(buf, s->buf_ptr, len);
|
|
|
|
s->buf_ptr += len;
|
|
|
|
} else {
|
|
|
|
if (!s->willclose && s->filesize >= 0 && s->off >= s->filesize)
|
|
|
|
return AVERROR_EOF;
|
|
|
|
len = ffurl_read(s->hd, buf, size);
|
|
|
|
}
|
|
|
|
if (len > 0) {
|
|
|
|
s->off += len;
|
|
|
|
if (s->chunksize > 0)
|
|
|
|
s->chunksize -= len;
|
|
|
|
}
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int http_read(URLContext *h, uint8_t *buf, int size)
|
|
|
|
{
|
|
|
|
HTTPContext *s = h->priv_data;
|
2007-02-28 03:40:23 +00:00
|
|
|
|
2009-06-23 15:38:53 +00:00
|
|
|
if (s->chunksize >= 0) {
|
|
|
|
if (!s->chunksize) {
|
|
|
|
char line[32];
|
|
|
|
|
|
|
|
for(;;) {
|
|
|
|
do {
|
|
|
|
if (http_get_line(s, line, sizeof(line)) < 0)
|
|
|
|
return AVERROR(EIO);
|
|
|
|
} while (!*line); /* skip CR LF from last chunk */
|
|
|
|
|
|
|
|
s->chunksize = strtoll(line, NULL, 16);
|
|
|
|
|
2011-01-29 16:46:18 +00:00
|
|
|
av_dlog(NULL, "Chunked encoding data size: %"PRId64"'\n", s->chunksize);
|
2009-06-23 15:38:53 +00:00
|
|
|
|
|
|
|
if (!s->chunksize)
|
|
|
|
return 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
size = FFMIN(size, s->chunksize);
|
|
|
|
}
|
2011-11-10 12:52:50 +00:00
|
|
|
return http_buf_read(h, buf, size);
|
2007-02-28 03:40:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* used only when posting data */
|
2010-06-01 07:46:23 +00:00
|
|
|
static int http_write(URLContext *h, const uint8_t *buf, int size)
|
2007-02-28 03:40:23 +00:00
|
|
|
{
|
2010-06-08 11:48:03 +00:00
|
|
|
char temp[11] = ""; /* 32-bit hex + CRLF + nul */
|
2010-01-12 16:36:00 +00:00
|
|
|
int ret;
|
|
|
|
char crlf[] = "\r\n";
|
2007-02-28 03:40:23 +00:00
|
|
|
HTTPContext *s = h->priv_data;
|
2010-01-12 16:36:00 +00:00
|
|
|
|
http: Change the chunksize AVOption into chunked_post
The chunksize internal variable has two different uses - for
reading, it's the amount of data left of the current chunk
(or -1 if the server doesn't send data in chunked mode), where
it's only an internal state variable. For writing, it's used
to decide whether to enable chunked encoding (by default), by
using the value 0, or disable chunked encoding (value -1).
This, while consistent, doesn't make much sense to expose
as an AVOption. This splits the usage of the internal variable
into two variables, chunksize which is used for reading (as
before), and chunked_post which is the user-settable option,
with the values 0 and 1, where 1 is default.
Signed-off-by: Martin Storsjö <martin@martin.st>
2011-11-10 09:03:35 +00:00
|
|
|
if (!s->chunked_post) {
|
2010-06-21 18:40:53 +00:00
|
|
|
/* non-chunked data is sent without any special encoding */
|
2011-03-31 14:48:01 +00:00
|
|
|
return ffurl_write(s->hd, buf, size);
|
2010-01-12 16:36:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* silently ignore zero-size data since chunk encoding that would
|
|
|
|
* signal EOF */
|
|
|
|
if (size > 0) {
|
|
|
|
/* upload data using chunked encoding */
|
2010-06-21 19:02:35 +00:00
|
|
|
snprintf(temp, sizeof(temp), "%x\r\n", size);
|
2010-06-08 11:48:03 +00:00
|
|
|
|
2011-03-31 14:48:01 +00:00
|
|
|
if ((ret = ffurl_write(s->hd, temp, strlen(temp))) < 0 ||
|
|
|
|
(ret = ffurl_write(s->hd, buf, size)) < 0 ||
|
|
|
|
(ret = ffurl_write(s->hd, crlf, sizeof(crlf) - 1)) < 0)
|
2010-01-12 16:36:00 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
return size;
|
2007-02-28 03:40:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int http_close(URLContext *h)
|
|
|
|
{
|
2010-01-12 16:36:00 +00:00
|
|
|
int ret = 0;
|
|
|
|
char footer[] = "0\r\n\r\n";
|
2007-02-28 03:40:23 +00:00
|
|
|
HTTPContext *s = h->priv_data;
|
2010-01-12 16:36:00 +00:00
|
|
|
|
|
|
|
/* signal end of chunked encoding if used */
|
http: Change the chunksize AVOption into chunked_post
The chunksize internal variable has two different uses - for
reading, it's the amount of data left of the current chunk
(or -1 if the server doesn't send data in chunked mode), where
it's only an internal state variable. For writing, it's used
to decide whether to enable chunked encoding (by default), by
using the value 0, or disable chunked encoding (value -1).
This, while consistent, doesn't make much sense to expose
as an AVOption. This splits the usage of the internal variable
into two variables, chunksize which is used for reading (as
before), and chunked_post which is the user-settable option,
with the values 0 and 1, where 1 is default.
Signed-off-by: Martin Storsjö <martin@martin.st>
2011-11-10 09:03:35 +00:00
|
|
|
if ((h->flags & AVIO_FLAG_WRITE) && s->chunked_post) {
|
2011-03-31 14:48:01 +00:00
|
|
|
ret = ffurl_write(s->hd, footer, sizeof(footer) - 1);
|
2010-01-12 16:36:00 +00:00
|
|
|
ret = ret > 0 ? 0 : ret;
|
|
|
|
}
|
|
|
|
|
2010-06-08 11:18:22 +00:00
|
|
|
if (s->hd)
|
2011-03-31 15:36:06 +00:00
|
|
|
ffurl_close(s->hd);
|
2010-01-12 16:36:00 +00:00
|
|
|
return ret;
|
2007-02-28 03:40:23 +00:00
|
|
|
}
|
|
|
|
|
2008-10-03 10:16:29 +00:00
|
|
|
static int64_t http_seek(URLContext *h, int64_t off, int whence)
|
2007-02-28 03:40:23 +00:00
|
|
|
{
|
|
|
|
HTTPContext *s = h->priv_data;
|
|
|
|
URLContext *old_hd = s->hd;
|
2008-10-03 10:16:29 +00:00
|
|
|
int64_t old_off = s->off;
|
2010-01-13 23:27:52 +00:00
|
|
|
uint8_t old_buf[BUFFER_SIZE];
|
|
|
|
int old_buf_size;
|
2007-02-28 03:40:23 +00:00
|
|
|
|
|
|
|
if (whence == AVSEEK_SIZE)
|
|
|
|
return s->filesize;
|
|
|
|
else if ((s->filesize == -1 && whence == SEEK_END) || h->is_streamed)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
/* we save the old context in case the seek fails */
|
2010-01-13 23:27:52 +00:00
|
|
|
old_buf_size = s->buf_end - s->buf_ptr;
|
|
|
|
memcpy(old_buf, s->buf_ptr, old_buf_size);
|
2007-02-28 03:40:23 +00:00
|
|
|
s->hd = NULL;
|
|
|
|
if (whence == SEEK_CUR)
|
|
|
|
off += s->off;
|
|
|
|
else if (whence == SEEK_END)
|
|
|
|
off += s->filesize;
|
|
|
|
s->off = off;
|
|
|
|
|
|
|
|
/* if it fails, continue on old connection */
|
|
|
|
if (http_open_cnx(h) < 0) {
|
2010-01-13 23:27:52 +00:00
|
|
|
memcpy(s->buffer, old_buf, old_buf_size);
|
|
|
|
s->buf_ptr = s->buffer;
|
|
|
|
s->buf_end = s->buffer + old_buf_size;
|
2007-02-28 03:40:23 +00:00
|
|
|
s->hd = old_hd;
|
|
|
|
s->off = old_off;
|
|
|
|
return -1;
|
|
|
|
}
|
2011-03-31 15:36:06 +00:00
|
|
|
ffurl_close(old_hd);
|
2007-02-28 03:40:23 +00:00
|
|
|
return off;
|
|
|
|
}
|
|
|
|
|
2009-03-03 17:04:51 +00:00
|
|
|
static int
|
|
|
|
http_get_file_handle(URLContext *h)
|
|
|
|
{
|
|
|
|
HTTPContext *s = h->priv_data;
|
2011-03-31 15:51:24 +00:00
|
|
|
return ffurl_get_file_handle(s->hd);
|
2009-03-03 17:04:51 +00:00
|
|
|
}
|
|
|
|
|
2011-02-05 22:20:26 +00:00
|
|
|
#if CONFIG_HTTP_PROTOCOL
|
2011-01-25 22:03:28 +00:00
|
|
|
URLProtocol ff_http_protocol = {
|
2011-04-08 05:41:47 +00:00
|
|
|
.name = "http",
|
|
|
|
.url_open = http_open,
|
|
|
|
.url_read = http_read,
|
|
|
|
.url_write = http_write,
|
|
|
|
.url_seek = http_seek,
|
|
|
|
.url_close = http_close,
|
2009-03-03 17:04:51 +00:00
|
|
|
.url_get_file_handle = http_get_file_handle,
|
2011-04-08 05:41:47 +00:00
|
|
|
.priv_data_size = sizeof(HTTPContext),
|
2011-11-05 11:54:01 +00:00
|
|
|
.priv_data_class = &http_context_class,
|
2011-12-30 09:38:05 +00:00
|
|
|
.flags = URL_PROTOCOL_FLAG_NETWORK,
|
2007-02-28 03:40:23 +00:00
|
|
|
};
|
2011-02-05 22:20:26 +00:00
|
|
|
#endif
|
|
|
|
#if CONFIG_HTTPS_PROTOCOL
|
|
|
|
URLProtocol ff_https_protocol = {
|
|
|
|
.name = "https",
|
|
|
|
.url_open = http_open,
|
|
|
|
.url_read = http_read,
|
|
|
|
.url_write = http_write,
|
|
|
|
.url_seek = http_seek,
|
|
|
|
.url_close = http_close,
|
|
|
|
.url_get_file_handle = http_get_file_handle,
|
|
|
|
.priv_data_size = sizeof(HTTPContext),
|
2011-11-05 11:54:01 +00:00
|
|
|
.priv_data_class = &https_context_class,
|
2011-12-30 09:38:05 +00:00
|
|
|
.flags = URL_PROTOCOL_FLAG_NETWORK,
|
2011-02-05 22:20:26 +00:00
|
|
|
};
|
|
|
|
#endif
|
2011-11-10 12:53:16 +00:00
|
|
|
|
|
|
|
#if CONFIG_HTTPPROXY_PROTOCOL
|
|
|
|
static int http_proxy_close(URLContext *h)
|
|
|
|
{
|
|
|
|
HTTPContext *s = h->priv_data;
|
|
|
|
if (s->hd)
|
|
|
|
ffurl_close(s->hd);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int http_proxy_open(URLContext *h, const char *uri, int flags)
|
|
|
|
{
|
|
|
|
HTTPContext *s = h->priv_data;
|
|
|
|
char hostname[1024], hoststr[1024];
|
|
|
|
char auth[1024], pathbuf[1024], *path;
|
|
|
|
char line[1024], lower_url[100];
|
2012-03-12 12:00:16 +00:00
|
|
|
int port, ret = 0, attempts = 0;
|
2011-11-10 12:53:16 +00:00
|
|
|
HTTPAuthType cur_auth_type;
|
|
|
|
char *authstr;
|
|
|
|
|
|
|
|
h->is_streamed = 1;
|
|
|
|
|
|
|
|
av_url_split(NULL, 0, auth, sizeof(auth), hostname, sizeof(hostname), &port,
|
|
|
|
pathbuf, sizeof(pathbuf), uri);
|
|
|
|
ff_url_join(hoststr, sizeof(hoststr), NULL, NULL, hostname, port, NULL);
|
|
|
|
path = pathbuf;
|
|
|
|
if (*path == '/')
|
|
|
|
path++;
|
|
|
|
|
|
|
|
ff_url_join(lower_url, sizeof(lower_url), "tcp", NULL, hostname, port,
|
|
|
|
NULL);
|
|
|
|
redo:
|
|
|
|
ret = ffurl_open(&s->hd, lower_url, AVIO_FLAG_READ_WRITE,
|
|
|
|
&h->interrupt_callback, NULL);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
authstr = ff_http_auth_create_response(&s->proxy_auth_state, auth,
|
|
|
|
path, "CONNECT");
|
|
|
|
snprintf(s->buffer, sizeof(s->buffer),
|
|
|
|
"CONNECT %s HTTP/1.1\r\n"
|
|
|
|
"Host: %s\r\n"
|
|
|
|
"Connection: close\r\n"
|
|
|
|
"%s%s"
|
|
|
|
"\r\n",
|
|
|
|
path,
|
|
|
|
hoststr,
|
|
|
|
authstr ? "Proxy-" : "", authstr ? authstr : "");
|
|
|
|
av_freep(&authstr);
|
|
|
|
|
|
|
|
if ((ret = ffurl_write(s->hd, s->buffer, strlen(s->buffer))) < 0)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
s->buf_ptr = s->buffer;
|
|
|
|
s->buf_end = s->buffer;
|
|
|
|
s->line_count = 0;
|
|
|
|
s->filesize = -1;
|
|
|
|
cur_auth_type = s->proxy_auth_state.auth_type;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
int new_loc;
|
|
|
|
// Note: This uses buffering, potentially reading more than the
|
|
|
|
// HTTP header. If tunneling a protocol where the server starts
|
|
|
|
// the conversation, we might buffer part of that here, too.
|
|
|
|
// Reading that requires using the proper ffurl_read() function
|
|
|
|
// on this URLContext, not using the fd directly (as the tls
|
|
|
|
// protocol does). This shouldn't be an issue for tls though,
|
|
|
|
// since the client starts the conversation there, so there
|
|
|
|
// is no extra data that we might buffer up here.
|
|
|
|
if (http_get_line(s, line, sizeof(line)) < 0) {
|
|
|
|
ret = AVERROR(EIO);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
av_dlog(h, "header='%s'\n", line);
|
|
|
|
|
|
|
|
ret = process_line(h, line, s->line_count, &new_loc);
|
|
|
|
if (ret < 0)
|
|
|
|
goto fail;
|
|
|
|
if (ret == 0)
|
|
|
|
break;
|
|
|
|
s->line_count++;
|
|
|
|
}
|
2012-03-12 12:00:16 +00:00
|
|
|
attempts++;
|
|
|
|
if (s->http_code == 407 &&
|
|
|
|
(cur_auth_type == HTTP_AUTH_NONE || s->proxy_auth_state.stale) &&
|
|
|
|
s->proxy_auth_state.auth_type != HTTP_AUTH_NONE && attempts < 2) {
|
2011-11-10 12:53:16 +00:00
|
|
|
ffurl_close(s->hd);
|
|
|
|
s->hd = NULL;
|
|
|
|
goto redo;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (s->http_code < 400)
|
|
|
|
return 0;
|
|
|
|
ret = AVERROR(EIO);
|
|
|
|
|
|
|
|
fail:
|
|
|
|
http_proxy_close(h);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int http_proxy_write(URLContext *h, const uint8_t *buf, int size)
|
|
|
|
{
|
|
|
|
HTTPContext *s = h->priv_data;
|
|
|
|
return ffurl_write(s->hd, buf, size);
|
|
|
|
}
|
|
|
|
|
|
|
|
URLProtocol ff_httpproxy_protocol = {
|
|
|
|
.name = "httpproxy",
|
|
|
|
.url_open = http_proxy_open,
|
|
|
|
.url_read = http_buf_read,
|
|
|
|
.url_write = http_proxy_write,
|
|
|
|
.url_close = http_proxy_close,
|
|
|
|
.url_get_file_handle = http_get_file_handle,
|
|
|
|
.priv_data_size = sizeof(HTTPContext),
|
2011-12-30 09:38:05 +00:00
|
|
|
.flags = URL_PROTOCOL_FLAG_NETWORK,
|
2011-11-10 12:53:16 +00:00
|
|
|
};
|
|
|
|
#endif
|