d8ab4d3f448d39eeae60b410d5a56fef647451af
[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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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( 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
185
186     /* send http header */
187     post = h->flags & URL_WRONLY;
188
189     snprintf(s->buffer, sizeof(s->buffer),
190              "%s %s HTTP/1.0\r\n"
191              "User-Agent: %s\r\n"
192              "Accept: */*\r\n"
193              "Host: %s\r\n"
194              "Authorization: Basic %s\r\n"
195              "\r\n",
196              post ? "POST" : "GET",
197              path,
198              LIBAVFORMAT_IDENT,
199              hoststr,
200              b64_encode(auth));
201     
202     if (http_write(h, s->buffer, strlen(s->buffer)) < 0)
203         return AVERROR_IO;
204         
205     /* init input buffer */
206     s->buf_ptr = s->buffer;
207     s->buf_end = s->buffer;
208     s->line_count = 0;
209     s->location[0] = '\0';
210     if (post) {
211         sleep(1);
212         return 0;
213     }
214     
215     /* wait for header */
216     q = line;
217     for(;;) {
218         ch = http_getc(s);
219         if (ch < 0)
220             return AVERROR_IO;
221         if (ch == '\n') {
222             /* process line */
223             if (q > line && q[-1] == '\r')
224                 q--;
225             *q = '\0';
226 #ifdef DEBUG
227             printf("header='%s'\n", line);
228 #endif
229             err = process_line(s, line, s->line_count);
230             if (err < 0)
231                 return err;
232             if (err == 0)
233                 return 0;
234             s->line_count++;
235             q = line;
236         } else {
237             if ((q - line) < sizeof(line) - 1)
238                 *q++ = ch;
239         }
240     }
241 }
242
243
244 static int http_read(URLContext *h, uint8_t *buf, int size)
245 {
246     HTTPContext *s = h->priv_data;
247     int len;
248
249     /* read bytes from input buffer first */
250     len = s->buf_end - s->buf_ptr;
251     if (len > 0) {
252         if (len > size)
253             len = size;
254         memcpy(buf, s->buf_ptr, len);
255         s->buf_ptr += len;
256     } else {
257         len = url_read(s->hd, buf, size);
258     }
259     return len;
260 }
261
262 /* used only when posting data */
263 static int http_write(URLContext *h, uint8_t *buf, int size)
264 {
265     HTTPContext *s = h->priv_data;
266     return url_write(s->hd, buf, size);
267 }
268
269 static int http_close(URLContext *h)
270 {
271     HTTPContext *s = h->priv_data;
272     url_close(s->hd);
273     av_free(s);
274     return 0;
275 }
276
277 URLProtocol http_protocol = {
278     "http",
279     http_open,
280     http_read,
281     http_write,
282     NULL, /* seek */
283     http_close,
284 };
285
286 /*****************************************************************************
287  * b64_encode: stolen from VLC's http.c
288  *****************************************************************************/
289                                                                                 
290 static char *b64_encode( unsigned char *src )
291 {
292     static const char b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
293                                                                                 
294     char *dst = av_malloc( strlen( src ) * 4 / 3 + 12 );
295     char *ret = dst;
296     unsigned i_bits = 0;
297     unsigned i_shift = 0;
298                                                                                 
299     for( ;; )
300     {
301         if( *src )
302         {
303             i_bits = ( i_bits << 8 )|( *src++ );
304             i_shift += 8;
305         }
306         else if( i_shift > 0 )
307         {
308            i_bits <<= 6 - i_shift;
309            i_shift = 6;
310         }
311         else
312         {
313             *dst++ = '=';
314             break;
315         }
316                                                                                 
317         while( i_shift >= 6 )
318         {
319             i_shift -= 6;
320             *dst++ = b64[(i_bits >> i_shift)&0x3f];
321         }
322     }
323                                                                                 
324     *dst++ = '\0';
325                                                                                 
326     return ret;
327 }
328