Fix memleak, patch by I. Po % yyymmmm # gmail O com %
[ffmpeg.git] / libavformat / http.c
1 /*
2  * HTTP protocol for ffmpeg client
3  * Copyright (c) 2000, 2001 Fabrice Bellard.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18  */
19 #include "avformat.h"
20 #include <unistd.h>
21 #include <sys/types.h>
22 #include <sys/socket.h>
23 #include <netinet/in.h>
24 #ifndef __BEOS__
25 # include <arpa/inet.h>
26 #else
27 # include "barpainet.h"
28 #endif
29 #include <netdb.h>
30
31
32 /* XXX: POST protocol is not completly implemented because ffmpeg use
33    only a subset of it */
34
35 //#define DEBUG
36
37 /* used for protocol handling */
38 #define BUFFER_SIZE 1024
39 #define URL_SIZE    4096
40
41 typedef struct {
42     URLContext *hd;
43     unsigned char buffer[BUFFER_SIZE], *buf_ptr, *buf_end;
44     int line_count;
45     int http_code;
46     char location[URL_SIZE];
47 } HTTPContext;
48
49 static int http_connect(URLContext *h, const char *path, const char *hoststr,
50                         const char *auth);
51 static int http_write(URLContext *h, uint8_t *buf, int size);
52 static char *b64_encode(const unsigned char *src );
53
54
55 /* return non zero if error */
56 static int http_open(URLContext *h, const char *uri, int flags)
57 {
58     const char *path, *proxy_path;
59     char hostname[1024], hoststr[1024];
60     char auth[1024];
61     char path1[1024];
62     char buf[1024];
63     int port, use_proxy, err;
64     HTTPContext *s;
65     URLContext *hd = NULL;
66
67     h->is_streamed = 1;
68
69     s = av_malloc(sizeof(HTTPContext));
70     if (!s) {
71         return -ENOMEM;
72     }
73     h->priv_data = s;
74
75     proxy_path = getenv("http_proxy");
76     use_proxy = (proxy_path != NULL) && !getenv("no_proxy") &&
77         strstart(proxy_path, "http://", NULL);
78
79     /* fill the dest addr */
80  redo:
81     /* needed in any case to build the host string */
82     url_split(NULL, 0, auth, sizeof(auth), hostname, sizeof(hostname), &port,
83               path1, sizeof(path1), uri);
84     if (port > 0) {
85         snprintf(hoststr, sizeof(hoststr), "%s:%d", hostname, port);
86     } else {
87         pstrcpy(hoststr, sizeof(hoststr), hostname);
88     }
89
90     if (use_proxy) {
91         url_split(NULL, 0, auth, sizeof(auth), hostname, sizeof(hostname), &port,
92                   NULL, 0, proxy_path);
93         path = uri;
94     } else {
95         if (path1[0] == '\0')
96             path = "/";
97         else
98             path = path1;
99     }
100     if (port < 0)
101         port = 80;
102
103     snprintf(buf, sizeof(buf), "tcp://%s:%d", hostname, port);
104     err = url_open(&hd, buf, URL_RDWR);
105     if (err < 0)
106         goto fail;
107
108     s->hd = hd;
109     if (http_connect(h, path, hoststr, auth) < 0)
110         goto fail;
111     if (s->http_code == 303 && s->location[0] != '\0') {
112         /* url moved, get next */
113         uri = s->location;
114         url_close(hd);
115         goto redo;
116     }
117     return 0;
118  fail:
119     if (hd)
120         url_close(hd);
121     av_free(s);
122     return AVERROR_IO;
123 }
124
125 static int http_getc(HTTPContext *s)
126 {
127     int len;
128     if (s->buf_ptr >= s->buf_end) {
129         len = url_read(s->hd, s->buffer, BUFFER_SIZE);
130         if (len < 0) {
131             return AVERROR_IO;
132         } else if (len == 0) {
133             return -1;
134         } else {
135             s->buf_ptr = s->buffer;
136             s->buf_end = s->buffer + len;
137         }
138     }
139     return *s->buf_ptr++;
140 }
141
142 static int process_line(HTTPContext *s, char *line, int line_count)
143 {
144     char *tag, *p;
145
146     /* end of header */
147     if (line[0] == '\0')
148         return 0;
149
150     p = line;
151     if (line_count == 0) {
152         while (!isspace(*p) && *p != '\0')
153             p++;
154         while (isspace(*p))
155             p++;
156         s->http_code = strtol(p, NULL, 10);
157 #ifdef DEBUG
158         printf("http_code=%d\n", s->http_code);
159 #endif
160     } else {
161         while (*p != '\0' && *p != ':')
162             p++;
163         if (*p != ':')
164             return 1;
165
166         *p = '\0';
167         tag = line;
168         p++;
169         while (isspace(*p))
170             p++;
171         if (!strcmp(tag, "Location")) {
172             strcpy(s->location, p);
173         }
174     }
175     return 1;
176 }
177
178 static int http_connect(URLContext *h, const char *path, const char *hoststr,
179                         const char *auth)
180 {
181     HTTPContext *s = h->priv_data;
182     int post, err, ch;
183     char line[1024], *q;
184     char *auth_b64;
185
186
187     /* send http header */
188     post = h->flags & URL_WRONLY;
189
190     auth_b64 = b64_encode(auth);
191     snprintf(s->buffer, sizeof(s->buffer),
192              "%s %s HTTP/1.0\r\n"
193              "User-Agent: %s\r\n"
194              "Accept: */*\r\n"
195              "Host: %s\r\n"
196              "Authorization: Basic %s\r\n"
197              "\r\n",
198              post ? "POST" : "GET",
199              path,
200              LIBAVFORMAT_IDENT,
201              hoststr,
202              auth_b64);
203
204     av_freep(&auth_b64);
205     if (http_write(h, s->buffer, strlen(s->buffer)) < 0)
206         return AVERROR_IO;
207
208     /* init input buffer */
209     s->buf_ptr = s->buffer;
210     s->buf_end = s->buffer;
211     s->line_count = 0;
212     s->location[0] = '\0';
213     if (post) {
214         sleep(1);
215         return 0;
216     }
217
218     /* wait for header */
219     q = line;
220     for(;;) {
221         ch = http_getc(s);
222         if (ch < 0)
223             return AVERROR_IO;
224         if (ch == '\n') {
225             /* process line */
226             if (q > line && q[-1] == '\r')
227                 q--;
228             *q = '\0';
229 #ifdef DEBUG
230             printf("header='%s'\n", line);
231 #endif
232             err = process_line(s, line, s->line_count);
233             if (err < 0)
234                 return err;
235             if (err == 0)
236                 return 0;
237             s->line_count++;
238             q = line;
239         } else {
240             if ((q - line) < sizeof(line) - 1)
241                 *q++ = ch;
242         }
243     }
244 }
245
246
247 static int http_read(URLContext *h, uint8_t *buf, int size)
248 {
249     HTTPContext *s = h->priv_data;
250     int len;
251
252     /* read bytes from input buffer first */
253     len = s->buf_end - s->buf_ptr;
254     if (len > 0) {
255         if (len > size)
256             len = size;
257         memcpy(buf, s->buf_ptr, len);
258         s->buf_ptr += len;
259     } else {
260         len = url_read(s->hd, buf, size);
261     }
262     return len;
263 }
264
265 /* used only when posting data */
266 static int http_write(URLContext *h, uint8_t *buf, int size)
267 {
268     HTTPContext *s = h->priv_data;
269     return url_write(s->hd, buf, size);
270 }
271
272 static int http_close(URLContext *h)
273 {
274     HTTPContext *s = h->priv_data;
275     url_close(s->hd);
276     av_free(s);
277     return 0;
278 }
279
280 URLProtocol http_protocol = {
281     "http",
282     http_open,
283     http_read,
284     http_write,
285     NULL, /* seek */
286     http_close,
287 };
288
289 /*****************************************************************************
290  * b64_encode: stolen from VLC's http.c
291  * simplified by michael
292  *****************************************************************************/
293
294 static char *b64_encode( const unsigned char *src )
295 {
296     static const char b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
297     unsigned int len= strlen(src);
298     char *ret, *dst;
299     unsigned i_bits = 0;
300     unsigned i_shift = 0;
301
302     if(len < UINT_MAX/4){
303         ret=dst= av_malloc( len * 4 / 3 + 12 );
304     }else
305         return NULL;
306
307     while(*src){
308         i_bits = (i_bits << 8) + *src++;
309         i_shift += 8;
310
311         do{
312             *dst++ = b64[(i_bits << 6 >> i_shift) & 0x3f];
313             i_shift -= 6;
314         }while( i_shift > 6 || (*src == 0 && i_shift>0));
315     }
316     *dst++ = '=';
317     *dst   = '\0';
318
319     return ret;
320 }
321