Add emacs/vim local variables
[yaz-moved-to-github.git] / src / http.c
1 /* This file is part of the YAZ toolkit.
2  * Copyright (C) 1995-2011 Index Data
3  * See the file LICENSE for details.
4  */
5 /**
6  * \file http.c
7  * \brief Implements HTTP decoding
8  */
9 #if HAVE_CONFIG_H
10 #include <config.h>
11 #endif
12
13 #include <yaz/odr.h>
14 #include <yaz/yaz-version.h>
15 #include <yaz/yaz-iconv.h>
16 #include <yaz/matchstr.h>
17 #include <yaz/zgdu.h>
18
19 #ifdef WIN32
20 #define strncasecmp _strnicmp
21 #define strcasecmp _stricmp
22 #endif
23  
24
25 /*
26  * This function's counterpart, yaz_base64decode(), is in srwutil.c.
27  * I feel bad that they're not together, but each function is only
28  * needed in one place, and those places are not together.  Maybe one
29  * day we'll move them into a new httputil.c, and declare them in a
30  * corresponding httputil.h
31  */
32 static void yaz_base64encode(const char *in, char *out)
33 {
34     static char encoding[] =
35         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
36     unsigned char buf[3];
37     long n;
38
39     while (*in != 0) {
40         char *pad = 0;
41         buf[0] = in[0];
42         buf[1] = in[1];
43         if (in[1] == 0) {
44             buf[2] = 0;
45             pad = "==";
46         } else {
47             buf[2] = in[2];
48             if (in[2] == 0)
49                 pad = "=";
50         }
51
52         /* Treat three eight-bit numbers as on 24-bit number */
53         n = (buf[0] << 16) + (buf[1] << 8) + buf[2];
54
55         /* Write the six-bit chunks out as four encoded characters */
56         *out++ = encoding[(n >> 18) & 63];
57         *out++ = encoding[(n >> 12) & 63];
58         if (in[1] != 0)
59             *out++ = encoding[(n >> 6) & 63];
60         if (in[1] != 0 && in[2] != 0)
61             *out++ = encoding[n & 63];
62
63         if (pad != 0) {
64             while (*pad != 0)
65                 *out++ = *pad++;
66             break;
67         }
68         in += 3;
69     }
70
71     *out++ = 0;
72 }
73
74
75 static int decode_headers_content(ODR o, int off, Z_HTTP_Header **headers,
76                                   char **content_buf, int *content_len)
77 {
78     int i = off;
79     int chunked = 0;
80
81     *headers = 0;
82     while (i < o->size-1 && o->buf[i] == '\n')
83     {
84         int po;
85         i++;
86         if (o->buf[i] == '\r' && i < o->size-1 && o->buf[i+1] == '\n')
87         {
88             i++;
89             break;
90         }
91         if (o->buf[i] == '\n')
92             break;
93         for (po = i; ; i++)
94         {
95             if (i == o->size)
96             {
97                 o->error = OHTTP;
98                 return 0;
99             }
100             else if (o->buf[i] == ':')
101                 break;
102         }
103         *headers = (Z_HTTP_Header *) odr_malloc(o, sizeof(**headers));
104         (*headers)->name = (char*) odr_malloc(o, i - po + 1);
105         memcpy ((*headers)->name, o->buf + po, i - po);
106         (*headers)->name[i - po] = '\0';
107         i++;
108         while (i < o->size-1 && o->buf[i] == ' ')
109             i++;
110         for (po = i; i < o->size-1 && !strchr("\r\n", o->buf[i]); i++)
111             ;
112         
113         (*headers)->value = (char*) odr_malloc(o, i - po + 1);
114         memcpy ((*headers)->value, o->buf + po, i - po);
115         (*headers)->value[i - po] = '\0';
116         
117         if (!strcasecmp((*headers)->name, "Transfer-Encoding")
118             &&
119             !strcasecmp((*headers)->value, "chunked"))
120             chunked = 1;
121         headers = &(*headers)->next;
122         if (i < o->size-1 && o->buf[i] == '\r')
123             i++;
124     }
125     *headers = 0;
126     if (o->buf[i] != '\n')
127     {
128         o->error = OHTTP;
129         return 0;
130     }
131     i++;
132
133     if (chunked)
134     {
135         int off = 0;
136         
137         /* we know buffer will be smaller than o->size - i*/
138         *content_buf = (char*) odr_malloc(o, o->size - i);  
139         
140         while (1)
141         {
142             /* chunk length .. */
143             int chunk_len = 0;
144             for (; i  < o->size-2; i++)
145                 if (yaz_isdigit(o->buf[i]))
146                     chunk_len = chunk_len * 16 + 
147                         (o->buf[i] - '0');
148                 else if (yaz_isupper(o->buf[i]))
149                     chunk_len = chunk_len * 16 + 
150                         (o->buf[i] - ('A'-10));
151                 else if (yaz_islower(o->buf[i]))
152                     chunk_len = chunk_len * 16 + 
153                         (o->buf[i] - ('a'-10));
154                 else
155                     break;
156             /* chunk extension ... */
157             while (o->buf[i] != '\r' && o->buf[i+1] != '\n')
158             {
159                 if (i >= o->size-2)
160                 {
161                     o->error = OHTTP;
162                     return 0;
163                 }
164                 i++;
165             }
166             i += 2;  /* skip CRLF */
167             if (chunk_len == 0)
168                 break;
169             if (chunk_len < 0 || off + chunk_len > o->size)
170             {
171                 o->error = OHTTP;
172                 return 0;
173             }
174             /* copy chunk .. */
175             memcpy (*content_buf + off, o->buf + i, chunk_len);
176             i += chunk_len + 2; /* skip chunk+CRLF */
177             off += chunk_len;
178         }
179         if (!off)
180             *content_buf = 0;
181         *content_len = off;
182     }
183     else
184     {
185         if (i > o->size)
186         {
187             o->error = OHTTP;
188             return 0;
189         }
190         else if (i == o->size)
191         {
192             *content_buf = 0;
193             *content_len = 0;
194         }
195         else 
196         {
197             *content_len = o->size - i;
198             *content_buf = (char*) odr_malloc(o, *content_len + 1);
199             memcpy(*content_buf, o->buf + i, *content_len);
200             (*content_buf)[*content_len] = '\0';
201         }
202     }
203     return 1;
204 }
205
206 void z_HTTP_header_add_content_type(ODR o, Z_HTTP_Header **hp,
207                                     const char *content_type,
208                                     const char *charset)
209 {
210     const char *l = "Content-Type";
211     if (charset)
212     {
213         char *ctype = (char *)
214             odr_malloc(o, strlen(content_type)+strlen(charset) + 15);
215         sprintf(ctype, "%s; charset=%s", content_type, charset);
216         z_HTTP_header_add(o, hp, l, ctype);
217     }
218     else
219         z_HTTP_header_add(o, hp, l, content_type);
220
221 }
222
223 /*
224  * HTTP Basic authentication is described at:
225  * http://tools.ietf.org/html/rfc1945#section-11.1
226  */
227 void z_HTTP_header_add_basic_auth(ODR o, Z_HTTP_Header **hp,
228                                   const char *username, const char *password)
229 {
230     char *tmp, *buf;
231     int len;
232
233     if (username == 0)
234         return;
235     if (password == 0)
236         password = "";
237
238     len = strlen(username) + strlen(password);
239     tmp = (char *) odr_malloc(o, len+2);
240     sprintf(tmp, "%s:%s", username, password);
241     buf = (char *) odr_malloc(o, (len+1) * 8/6 + 12);
242     strcpy(buf, "Basic ");
243     yaz_base64encode(tmp, &buf[strlen(buf)]);
244     z_HTTP_header_add(o, hp, "Authorization", buf);
245 }
246
247
248 void z_HTTP_header_add(ODR o, Z_HTTP_Header **hp, const char *n,
249                        const char *v)
250 {
251     while (*hp)
252         hp = &(*hp)->next;
253     *hp = (Z_HTTP_Header *) odr_malloc(o, sizeof(**hp));
254     (*hp)->name = odr_strdup(o, n);
255     (*hp)->value = odr_strdup(o, v);
256     (*hp)->next = 0;
257 }
258
259 const char *z_HTTP_header_lookup(const Z_HTTP_Header *hp, const char *n)
260 {
261     for (; hp; hp = hp->next)
262         if (!yaz_matchstr(hp->name, n))
263             return hp->value;
264     return 0;
265 }
266
267
268 Z_GDU *z_get_HTTP_Request(ODR o)
269 {
270     Z_GDU *p = (Z_GDU *) odr_malloc(o, sizeof(*p));
271     Z_HTTP_Request *hreq;
272
273     p->which = Z_GDU_HTTP_Request;
274     p->u.HTTP_Request = (Z_HTTP_Request *) odr_malloc(o, sizeof(*hreq));
275     hreq = p->u.HTTP_Request;
276     hreq->headers = 0;
277     hreq->content_len = 0;
278     hreq->content_buf = 0;
279     hreq->version = "1.1";
280     hreq->method = "POST";
281     hreq->path = "/";
282     z_HTTP_header_add(o, &hreq->headers, "User-Agent", "YAZ/" YAZ_VERSION);
283     return p;
284 }
285
286
287 Z_GDU *z_get_HTTP_Request_host_path(ODR odr,
288                                     const char *host,
289                                     const char *path)
290 {
291     Z_GDU *p = z_get_HTTP_Request(odr);
292
293     p->u.HTTP_Request->path = odr_strdup(odr, path);
294
295     if (host)
296     {
297         const char *cp0 = strstr(host, "://");
298         const char *cp1 = 0;
299         if (cp0)
300             cp0 = cp0+3;
301         else
302             cp0 = host;
303
304         cp1 = strchr(cp0, '/');
305         if (!cp1)
306             cp1 = cp0+strlen(cp0);
307
308         if (cp0 && cp1)
309         {
310             char *h = (char*) odr_malloc(odr, cp1 - cp0 + 1);
311             memcpy (h, cp0, cp1 - cp0);
312             h[cp1-cp0] = '\0';
313             z_HTTP_header_add(odr, &p->u.HTTP_Request->headers,
314                               "Host", h);
315         }
316     }
317     return p;
318 }
319
320
321 Z_GDU *z_get_HTTP_Response(ODR o, int code)
322 {
323     Z_GDU *p = (Z_GDU *) odr_malloc(o, sizeof(*p));
324     Z_HTTP_Response *hres;
325
326     p->which = Z_GDU_HTTP_Response;
327     p->u.HTTP_Response = (Z_HTTP_Response *) odr_malloc(o, sizeof(*hres));
328     hres = p->u.HTTP_Response;
329     hres->headers = 0;
330     hres->content_len = 0;
331     hres->content_buf = 0;
332     hres->code = code;
333     hres->version = "1.1";
334     z_HTTP_header_add(o, &hres->headers, "Server",
335                       "YAZ/" YAZ_VERSION);
336     if (code != 200)
337     {
338         hres->content_buf = (char*) odr_malloc(o, 400);
339         sprintf(hres->content_buf, 
340                 "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\""
341                 " \"http://www.w3.org/TR/html4/strict.dtd\">\n"
342                 "<HTML>\n"
343                 " <HEAD>\n"
344                 "  <TITLE>YAZ " YAZ_VERSION "</TITLE>\n"
345                 " </HEAD>\n"
346                 " <BODY>\n"
347                 "  <P><A HREF=\"http://www.indexdata.com/yaz/\">YAZ</A> " 
348                 YAZ_VERSION "</P>\n"
349                 "  <P>Error: %d</P>\n"
350                 "  <P>Description: %.50s</P>\n"
351                 " </BODY>\n"
352                 "</HTML>\n",
353                 code, z_HTTP_errmsg(code));
354         hres->content_len = strlen(hres->content_buf);
355         z_HTTP_header_add(o, &hres->headers, "Content-Type", "text/html");
356     }
357     return p;
358 }
359
360 const char *z_HTTP_errmsg(int code)
361 {
362     if (code == 200)
363         return "OK";
364     else if (code == 400)
365         return "Bad Request";
366     else if (code == 404)
367         return "Not Found";
368     else if (code == 405)
369         return "Method Not Allowed";
370     else if (code == 500)
371         return "Internal Error";
372     else
373         return "Unknown Error";
374 }
375
376 int yaz_decode_http_response(ODR o, Z_HTTP_Response **hr_p)
377 {
378     int i, po;
379     Z_HTTP_Response *hr = (Z_HTTP_Response *) odr_malloc(o, sizeof(*hr));
380     
381     *hr_p = hr;
382     hr->content_buf = 0;
383     hr->content_len = 0;
384     
385     po = i = 5;
386     while (i < o->size-2 && !strchr(" \r\n", o->buf[i]))
387         i++;
388     hr->version = (char *) odr_malloc(o, i - po + 1);
389     if (i - po)
390         memcpy(hr->version, o->buf + po, i - po);
391     hr->version[i-po] = 0;
392     if (o->buf[i] != ' ')
393     {
394         o->error = OHTTP;
395         return 0;
396     }
397     i++;
398     hr->code = 0;
399     while (i < o->size-2 && o->buf[i] >= '0' && o->buf[i] <= '9')
400     {
401         hr->code = hr->code*10 + (o->buf[i] - '0');
402         i++;
403     }
404     while (i < o->size-1 && o->buf[i] != '\n')
405         i++;
406     return decode_headers_content(o, i, &hr->headers,
407                                   &hr->content_buf, &hr->content_len);            
408 }
409
410 int yaz_decode_http_request(ODR o, Z_HTTP_Request **hr_p)
411 {
412     int i, po;
413     Z_HTTP_Request *hr = (Z_HTTP_Request *) odr_malloc(o, sizeof(*hr));
414     
415     *hr_p = hr;
416     
417     /* method .. */
418     for (i = 0; o->buf[i] != ' '; i++)
419         if (i >= o->size-5 || i > 30)
420         {
421             o->error = OHTTP;
422             return 0;
423         }
424     hr->method = (char *) odr_malloc(o, i+1);
425     memcpy (hr->method, o->buf, i);
426     hr->method[i] = '\0';
427     /* path */
428     po = i+1;
429     for (i = po; o->buf[i] != ' '; i++)
430         if (i >= o->size-5)
431         {
432             o->error = OHTTP;
433             return 0;
434         }
435     hr->path = (char *) odr_malloc(o, i - po + 1);
436     memcpy (hr->path, o->buf+po, i - po);
437     hr->path[i - po] = '\0';
438     /* HTTP version */
439     i++;
440     if (i > o->size-5 || memcmp(o->buf+i, "HTTP/", 5))
441     {
442         o->error = OHTTP;
443         return 0;
444     }
445     i+= 5;
446     po = i;
447     while (i < o->size && !strchr("\r\n", o->buf[i]))
448         i++;
449     hr->version = (char *) odr_malloc(o, i - po + 1);
450     memcpy(hr->version, o->buf + po, i - po);
451     hr->version[i - po] = '\0';
452     /* headers */
453     if (i < o->size-1 && o->buf[i] == '\r')
454         i++;
455     if (o->buf[i] != '\n')
456     {
457         o->error = OHTTP;
458         return 0;
459     }
460     return decode_headers_content(o, i, &hr->headers,
461                                   &hr->content_buf, &hr->content_len);
462 }
463
464 int yaz_encode_http_response(ODR o, Z_HTTP_Response *hr)
465 {
466     char sbuf[80];
467     Z_HTTP_Header *h;
468     int top0 = o->top;
469
470     sprintf(sbuf, "HTTP/%s %d %s\r\n", hr->version,
471             hr->code,
472             z_HTTP_errmsg(hr->code));
473     odr_write(o, (unsigned char *) sbuf, strlen(sbuf));
474     /* apply Content-Length if not already applied */
475     if (!z_HTTP_header_lookup(hr->headers,
476                               "Content-Length"))
477     {
478         char lstr[60];
479         sprintf(lstr, "Content-Length: %d\r\n",
480                 hr->content_len);
481         odr_write(o, (unsigned char *) lstr, strlen(lstr));
482     }
483     for (h = hr->headers; h; h = h->next)
484     {
485         odr_write(o, (unsigned char *) h->name, strlen(h->name));
486         odr_write(o, (unsigned char *) ": ", 2);
487         odr_write(o, (unsigned char *) h->value, strlen(h->value));
488         odr_write(o, (unsigned char *) "\r\n", 2);
489     }
490     odr_write(o, (unsigned char *) "\r\n", 2);
491     if (hr->content_buf)
492         odr_write(o, (unsigned char *) 
493                   hr->content_buf,
494                   hr->content_len);
495     if (o->direction == ODR_PRINT)
496     {
497         odr_printf(o, "-- HTTP response:\n%.*s\n", o->top - top0,
498                    o->buf + top0);
499         odr_printf(o, "-- \n");
500     }
501     return 1;
502 }
503
504 int yaz_encode_http_request(ODR o, Z_HTTP_Request *hr)
505 {
506     Z_HTTP_Header *h;
507     int top0 = o->top;
508
509     odr_write(o, (unsigned char *) hr->method,
510               strlen(hr->method));
511     odr_write(o, (unsigned char *) " ", 1);
512     odr_write(o, (unsigned char *) hr->path,
513               strlen(hr->path));
514     odr_write(o, (unsigned char *) " HTTP/", 6);
515     odr_write(o, (unsigned char *) hr->version,
516               strlen(hr->version));
517     odr_write(o, (unsigned char *) "\r\n", 2);
518     if (hr->content_len &&
519         !z_HTTP_header_lookup(hr->headers,
520                               "Content-Length"))
521     {
522         char lstr[60];
523         sprintf(lstr, "Content-Length: %d\r\n",
524                 hr->content_len);
525         odr_write(o, (unsigned char *) lstr, strlen(lstr));
526     }
527     for (h = hr->headers; h; h = h->next)
528     {
529         odr_write(o, (unsigned char *) h->name, strlen(h->name));
530         odr_write(o, (unsigned char *) ": ", 2);
531         odr_write(o, (unsigned char *) h->value, strlen(h->value));
532         odr_write(o, (unsigned char *) "\r\n", 2);
533     }
534     odr_write(o, (unsigned char *) "\r\n", 2);
535     if (hr->content_buf)
536         odr_write(o, (unsigned char *)
537                   hr->content_buf,
538                   hr->content_len);
539     if (o->direction == ODR_PRINT)
540     {
541         odr_printf(o, "-- HTTP request:\n%.*s\n", o->top - top0,
542                    o->buf + top0);
543         odr_printf(o, "-- \n");
544     }
545     return 1;
546 }
547
548 /*
549  * Local variables:
550  * c-basic-offset: 4
551  * c-file-style: "Stroustrup"
552  * indent-tabs-mode: nil
553  * End:
554  * vim: shiftwidth=4 tabstop=8 expandtab
555  */
556