Better check of marc leader info YAZ-691
[yaz-moved-to-github.git] / src / http.c
1 /* This file is part of the YAZ toolkit.
2  * Copyright (C) 1995-2013 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 #include <yaz/base64.h>
19
20 static int decode_headers_content(ODR o, int off, Z_HTTP_Header **headers,
21                                   char **content_buf, int *content_len)
22 {
23     int i = off;
24     int chunked = 0;
25
26     *headers = 0;
27     while (i < o->size-1 && o->buf[i] == '\n')
28     {
29         int po;
30         i++;
31         if (o->buf[i] == '\r' && i < o->size-1 && o->buf[i+1] == '\n')
32         {
33             i++;
34             break;
35         }
36         if (o->buf[i] == '\n')
37             break;
38         for (po = i; ; i++)
39         {
40             if (i == o->size)
41             {
42                 o->error = OHTTP;
43                 return 0;
44             }
45             else if (o->buf[i] == ':')
46                 break;
47         }
48         *headers = (Z_HTTP_Header *) odr_malloc(o, sizeof(**headers));
49         (*headers)->name = (char*) odr_malloc(o, i - po + 1);
50         memcpy ((*headers)->name, o->buf + po, i - po);
51         (*headers)->name[i - po] = '\0';
52         i++;
53         while (i < o->size-1 && o->buf[i] == ' ')
54             i++;
55         for (po = i; i < o->size-1 && !strchr("\r\n", o->buf[i]); i++)
56             ;
57
58         (*headers)->value = (char*) odr_malloc(o, i - po + 1);
59         memcpy ((*headers)->value, o->buf + po, i - po);
60         (*headers)->value[i - po] = '\0';
61
62         if (!yaz_strcasecmp((*headers)->name, "Transfer-Encoding")
63             &&
64             !yaz_strcasecmp((*headers)->value, "chunked"))
65             chunked = 1;
66         headers = &(*headers)->next;
67         if (i < o->size-1 && o->buf[i] == '\r')
68             i++;
69     }
70     *headers = 0;
71     if (o->buf[i] != '\n')
72     {
73         o->error = OHTTP;
74         return 0;
75     }
76     i++;
77
78     if (chunked)
79     {
80         int off = 0;
81
82         /* we know buffer will be smaller than o->size - i*/
83         *content_buf = (char*) odr_malloc(o, o->size - i);
84
85         while (1)
86         {
87             /* chunk length .. */
88             int chunk_len = 0;
89             for (; i  < o->size-2; i++)
90                 if (yaz_isdigit(o->buf[i]))
91                     chunk_len = chunk_len * 16 +
92                         (o->buf[i] - '0');
93                 else if (yaz_isupper(o->buf[i]))
94                     chunk_len = chunk_len * 16 +
95                         (o->buf[i] - ('A'-10));
96                 else if (yaz_islower(o->buf[i]))
97                     chunk_len = chunk_len * 16 +
98                         (o->buf[i] - ('a'-10));
99                 else
100                     break;
101             /* chunk extension ... */
102             while (o->buf[i] != '\r' && o->buf[i+1] != '\n')
103             {
104                 if (i >= o->size-2)
105                 {
106                     o->error = OHTTP;
107                     return 0;
108                 }
109                 i++;
110             }
111             i += 2;  /* skip CRLF */
112             if (chunk_len == 0)
113                 break;
114             if (chunk_len < 0 || off + chunk_len > o->size)
115             {
116                 o->error = OHTTP;
117                 return 0;
118             }
119             /* copy chunk .. */
120             memcpy (*content_buf + off, o->buf + i, chunk_len);
121             i += chunk_len + 2; /* skip chunk+CRLF */
122             off += chunk_len;
123         }
124         if (!off)
125             *content_buf = 0;
126         *content_len = off;
127     }
128     else
129     {
130         if (i > o->size)
131         {
132             o->error = OHTTP;
133             return 0;
134         }
135         else if (i == o->size)
136         {
137             *content_buf = 0;
138             *content_len = 0;
139         }
140         else
141         {
142             *content_len = o->size - i;
143             *content_buf = (char*) odr_malloc(o, *content_len + 1);
144             memcpy(*content_buf, o->buf + i, *content_len);
145             (*content_buf)[*content_len] = '\0';
146         }
147     }
148     return 1;
149 }
150
151 void z_HTTP_header_add_content_type(ODR o, Z_HTTP_Header **hp,
152                                     const char *content_type,
153                                     const char *charset)
154 {
155     const char *l = "Content-Type";
156     if (charset)
157     {
158         char *ctype = (char *)
159             odr_malloc(o, strlen(content_type)+strlen(charset) + 15);
160         sprintf(ctype, "%s; charset=%s", content_type, charset);
161         z_HTTP_header_add(o, hp, l, ctype);
162     }
163     else
164         z_HTTP_header_add(o, hp, l, content_type);
165
166 }
167
168 /*
169  * HTTP Basic authentication is described at:
170  * http://tools.ietf.org/html/rfc1945#section-11.1
171  */
172 void z_HTTP_header_add_basic_auth(ODR o, Z_HTTP_Header **hp,
173                                   const char *username, const char *password)
174 {
175     char *tmp, *buf;
176     int len;
177
178     if (username == 0)
179         return;
180     if (password == 0)
181         password = "";
182
183     len = strlen(username) + strlen(password);
184     tmp = (char *) odr_malloc(o, len+2);
185     sprintf(tmp, "%s:%s", username, password);
186     buf = (char *) odr_malloc(o, (len+1) * 8/6 + 12);
187     strcpy(buf, "Basic ");
188     yaz_base64encode(tmp, &buf[strlen(buf)]);
189     z_HTTP_header_set(o, hp, "Authorization", buf);
190 }
191
192
193 void z_HTTP_header_add(ODR o, Z_HTTP_Header **hp, const char *n,
194                        const char *v)
195 {
196     while (*hp)
197         hp = &(*hp)->next;
198     *hp = (Z_HTTP_Header *) odr_malloc(o, sizeof(**hp));
199     (*hp)->name = odr_strdup(o, n);
200     (*hp)->value = odr_strdup(o, v);
201     (*hp)->next = 0;
202 }
203
204 void z_HTTP_header_set(ODR o, Z_HTTP_Header **hp, const char *n,
205                        const char *v)
206 {
207     while (*hp)
208     {
209         if (!yaz_strcasecmp((*hp)->name, n))
210         {
211             (*hp)->value = odr_strdup(o, v);
212             return;
213         }
214         hp = &(*hp)->next;
215     }
216     *hp = (Z_HTTP_Header *) odr_malloc(o, sizeof(**hp));
217     (*hp)->name = odr_strdup(o, n);
218     (*hp)->value = odr_strdup(o, v);
219     (*hp)->next = 0;
220 }
221
222 const char *z_HTTP_header_remove(Z_HTTP_Header **hp, const char *n)
223 {
224     while (*hp)
225     {
226         if (!yaz_strcasecmp((*hp)->name, n))
227         {
228             const char *v = (*hp)->value;
229             *hp = (*hp)->next;
230             return v;
231         }
232         hp = &(*hp)->next;
233     }
234     return 0;
235 }
236
237 const char *z_HTTP_header_lookup(const Z_HTTP_Header *hp, const char *n)
238 {
239     for (; hp; hp = hp->next)
240         if (!yaz_strcasecmp(hp->name, n))
241             return hp->value;
242     return 0;
243 }
244
245
246 Z_GDU *z_get_HTTP_Request(ODR o)
247 {
248     Z_GDU *p = (Z_GDU *) odr_malloc(o, sizeof(*p));
249     Z_HTTP_Request *hreq;
250
251     p->which = Z_GDU_HTTP_Request;
252     p->u.HTTP_Request = (Z_HTTP_Request *) odr_malloc(o, sizeof(*hreq));
253     hreq = p->u.HTTP_Request;
254     hreq->headers = 0;
255     hreq->content_len = 0;
256     hreq->content_buf = 0;
257     hreq->version = "1.1";
258     hreq->method = "POST";
259     hreq->path = "/";
260     z_HTTP_header_add(o, &hreq->headers, "User-Agent", "YAZ/" YAZ_VERSION);
261     return p;
262 }
263
264
265 Z_GDU *z_get_HTTP_Request_host_path(ODR odr,
266                                     const char *host,
267                                     const char *path)
268 {
269     Z_GDU *p = z_get_HTTP_Request(odr);
270
271     p->u.HTTP_Request->path = odr_strdup(odr, path);
272
273     if (host)
274     {
275         const char *cp0 = strstr(host, "://");
276         const char *cp1 = 0;
277         if (cp0)
278             cp0 = cp0+3;
279         else
280             cp0 = host;
281
282         cp1 = strchr(cp0, '/');
283         if (!cp1)
284             cp1 = cp0+strlen(cp0);
285
286         if (cp0 && cp1)
287         {
288             char *h = (char*) odr_malloc(odr, cp1 - cp0 + 1);
289             memcpy (h, cp0, cp1 - cp0);
290             h[cp1-cp0] = '\0';
291             z_HTTP_header_add(odr, &p->u.HTTP_Request->headers,
292                               "Host", h);
293         }
294     }
295     return p;
296 }
297
298 Z_GDU *z_get_HTTP_Request_uri(ODR odr, const char *uri, const char *args,
299                               int use_full_uri)
300 {
301     Z_GDU *p = z_get_HTTP_Request(odr);
302     const char *cp0 = strstr(uri, "://");
303     const char *cp1 = 0;
304     if (cp0)
305         cp0 = cp0+3;
306     else
307         cp0 = uri;
308
309     cp1 = strchr(cp0, '/');
310     if (!cp1)
311         cp1 = cp0+strlen(cp0);
312
313     if (cp0 && cp1)
314     {
315         char *h = (char*) odr_malloc(odr, cp1 - cp0 + 1);
316         memcpy (h, cp0, cp1 - cp0);
317         h[cp1-cp0] = '\0';
318         z_HTTP_header_add(odr, &p->u.HTTP_Request->headers,
319                           "Host", h);
320     }
321
322     if (!args)
323     {
324         if (*cp1)
325             args = cp1 + 1;
326         else
327             args = "";
328     }
329     p->u.HTTP_Request->path = odr_malloc(odr, cp1 - uri + strlen(args) + 2);
330     if (use_full_uri)
331     {
332         memcpy(p->u.HTTP_Request->path, uri, cp1 - uri);
333         strcpy(p->u.HTTP_Request->path + (cp1 - uri), "/");
334     }
335     else
336         strcpy(p->u.HTTP_Request->path, "/");
337     strcat(p->u.HTTP_Request->path, args);
338     return p;
339 }
340
341 Z_GDU *z_get_HTTP_Response_server(ODR o, int code, const char *details,
342                                   const char *server, const char *server_url)
343 {
344     Z_GDU *p = (Z_GDU *) odr_malloc(o, sizeof(*p));
345     Z_HTTP_Response *hres;
346
347     p->which = Z_GDU_HTTP_Response;
348     p->u.HTTP_Response = (Z_HTTP_Response *) odr_malloc(o, sizeof(*hres));
349     hres = p->u.HTTP_Response;
350     hres->headers = 0;
351     hres->content_len = 0;
352     hres->content_buf = 0;
353     hres->code = code;
354     hres->version = "1.1";
355     z_HTTP_header_add(o, &hres->headers, "Server", server);
356     if (code != 200)
357     {
358         const char *http_err = z_HTTP_errmsg(code);
359         size_t sz = 400 + strlen(http_err) + (details ?
360                                               strlen(details) : 0);
361         hres->content_buf = (char*) odr_malloc(o, sz);
362         sprintf(hres->content_buf,
363                 "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01//EN\""
364                 " \"http://www.w3.org/TR/html4/strict.dtd\">\n"
365                 "<HTML>\n"
366                 " <HEAD>\n"
367                 "  <TITLE>%s</TITLE>\n"
368                 " </HEAD>\n"
369                 " <BODY>\n"
370                 "  <P><A HREF=\"%s\">%s</A></P>\n"
371                 "  <P>Error: %d</P>\n"
372                 "  <P>Description: %s</P>\n", server, server_url, server,
373                 code, http_err);
374         if (details)
375         {
376             sprintf(hres->content_buf + strlen(hres->content_buf),
377                     "<P>Details: %s</P>\n", details);
378         }
379         sprintf(hres->content_buf + strlen(hres->content_buf),
380                 " </BODY>\n"
381                 "</HTML>\n");
382         hres->content_len = strlen(hres->content_buf);
383         z_HTTP_header_add(o, &hres->headers, "Content-Type", "text/html");
384     }
385     return p;
386 }
387
388 Z_GDU *z_get_HTTP_Response_details(ODR o, int code, const char *details)
389 {
390     return z_get_HTTP_Response_server(o, code, details, "YAZ/" YAZ_VERSION,
391                                       "http://www.indexdata.com/yaz");
392 }
393
394 Z_GDU *z_get_HTTP_Response(ODR o, int code)
395 {
396     return z_get_HTTP_Response_details(o, code, 0);
397 }
398
399 const char *z_HTTP_errmsg(int code)
400 {
401     switch (code)
402     {
403     case 100:
404         return "Continue";
405     case 101:
406         return "Switching Protocols";
407     case 200:
408         return "OK";
409     case 201:
410         return "Created";
411     case 202:
412         return "Accepted";
413     case 203:
414         return "Non-Authoritative Information";
415     case 204:
416         return "No Content";
417     case 205:
418         return "Reset Content";
419     case 206:
420         return "Partial Content";
421     case 300:
422         return "Multiple Choices";
423     case 301:
424         return "Moved Permenently";
425     case 302:
426         return "Found";
427     case 303:
428         return "See Other";
429     case 304:
430         return "Not Modified";
431     case 305:
432         return "Use Proxy";
433     case 307:
434         return "Temporary Redirect";
435     case 400:
436         return "Bad Request";
437     case 404:
438         return "Not Found";
439     case 405:
440         return "Method Not Allowed";
441     case 406:
442         return "Not Acceptable";
443     case 407:
444         return "Proxy Authentication Required";
445     case 408:
446         return "Request Timeout";
447     case 409:
448         return "Conflict";
449     case 410:
450         return "Gone";
451     case 411:
452         return "Length Required";
453     case 412:
454         return "Precondition Failed";
455     case 413:
456         return "Request Entity Too Large";
457     case 414:
458         return "Request-URI Too Long";
459     case 415:
460         return "Unsupported Media Type";
461     case 416:
462         return "Requested Range Not Satisfiable";
463     case 417:
464         return "Expectation Failed";
465     case 500:
466         return "Internal Error";
467     case 501:
468         return "Not Implemented";
469     case 502:
470         return "Bad Gateway";
471     case 503:
472         return "Service Unavailable";
473     case 504:
474         return "Gateway Timeout";
475     case 505:
476         return "HTTP Version Not Supported";
477     default:
478         return "Unknown Error";
479     }
480 }
481
482 int yaz_decode_http_response(ODR o, Z_HTTP_Response **hr_p)
483 {
484     int i, po;
485     Z_HTTP_Response *hr = (Z_HTTP_Response *) odr_malloc(o, sizeof(*hr));
486
487     *hr_p = hr;
488     hr->content_buf = 0;
489     hr->content_len = 0;
490
491     po = i = 5;
492     while (i < o->size-2 && !strchr(" \r\n", o->buf[i]))
493         i++;
494     hr->version = (char *) odr_malloc(o, i - po + 1);
495     if (i - po)
496         memcpy(hr->version, o->buf + po, i - po);
497     hr->version[i-po] = 0;
498     if (o->buf[i] != ' ')
499     {
500         o->error = OHTTP;
501         return 0;
502     }
503     i++;
504     hr->code = 0;
505     while (i < o->size-2 && o->buf[i] >= '0' && o->buf[i] <= '9')
506     {
507         hr->code = hr->code*10 + (o->buf[i] - '0');
508         i++;
509     }
510     while (i < o->size-1 && o->buf[i] != '\n')
511         i++;
512     return decode_headers_content(o, i, &hr->headers,
513                                   &hr->content_buf, &hr->content_len);
514 }
515
516 int yaz_decode_http_request(ODR o, Z_HTTP_Request **hr_p)
517 {
518     int i, po;
519     Z_HTTP_Request *hr = (Z_HTTP_Request *) odr_malloc(o, sizeof(*hr));
520
521     *hr_p = hr;
522
523     /* method .. */
524     for (i = 0; o->buf[i] != ' '; i++)
525         if (i >= o->size-5 || i > 30)
526         {
527             o->error = OHTTP;
528             return 0;
529         }
530     hr->method = (char *) odr_malloc(o, i+1);
531     memcpy (hr->method, o->buf, i);
532     hr->method[i] = '\0';
533     /* path */
534     po = i+1;
535     for (i = po; o->buf[i] != ' '; i++)
536         if (i >= o->size-5)
537         {
538             o->error = OHTTP;
539             return 0;
540         }
541     hr->path = (char *) odr_malloc(o, i - po + 1);
542     memcpy (hr->path, o->buf+po, i - po);
543     hr->path[i - po] = '\0';
544     /* HTTP version */
545     i++;
546     if (i > o->size-5 || memcmp(o->buf+i, "HTTP/", 5))
547     {
548         o->error = OHTTP;
549         return 0;
550     }
551     i+= 5;
552     po = i;
553     while (i < o->size && !strchr("\r\n", o->buf[i]))
554         i++;
555     hr->version = (char *) odr_malloc(o, i - po + 1);
556     memcpy(hr->version, o->buf + po, i - po);
557     hr->version[i - po] = '\0';
558     /* headers */
559     if (i < o->size-1 && o->buf[i] == '\r')
560         i++;
561     if (o->buf[i] != '\n')
562     {
563         o->error = OHTTP;
564         return 0;
565     }
566     return decode_headers_content(o, i, &hr->headers,
567                                   &hr->content_buf, &hr->content_len);
568 }
569
570 static void dump_http_package(ODR o, const char *buf, size_t len)
571 {
572     int i;
573     for (i = 0; ; i++)
574     {
575         if (i == len)
576         {
577             odr_printf(o, "%.*s\n", i, buf);
578             break;
579         }
580         else if (i > 8192)
581         {
582             odr_printf(o, "%.*s\n", i, buf);
583             odr_printf(o, "(truncated\n", (long) len);
584             break;
585         }
586         else if (buf[i] == 0)
587         {
588             odr_printf(o, "%.*s\n", i, buf);
589             odr_printf(o, "(binary data)\n", (long) len);
590             break;
591         }
592     }
593 }
594
595 int yaz_encode_http_response(ODR o, Z_HTTP_Response *hr)
596 {
597     char sbuf[80];
598     Z_HTTP_Header *h;
599     int top0 = o->top;
600
601     sprintf(sbuf, "HTTP/%s %d %s\r\n", hr->version,
602             hr->code,
603             z_HTTP_errmsg(hr->code));
604     odr_write2(o, sbuf, strlen(sbuf));
605     /* use content_len for Content-Length */
606     sprintf(sbuf, "Content-Length: %d\r\n", hr->content_len);
607     odr_write2(o, sbuf, strlen(sbuf));
608     for (h = hr->headers; h; h = h->next)
609     {
610         if (yaz_strcasecmp(h->name, "Content-Length")
611             && yaz_strcasecmp(h->name, "Transfer-Encoding"))
612         {   /* skip Content-Length if given. content_len rules */
613             odr_write2(o, h->name, strlen(h->name));
614             odr_write2(o, ": ", 2);
615             odr_write2(o, h->value, strlen(h->value));
616             odr_write2(o, "\r\n", 2);
617         }
618     }
619     odr_write(o, (unsigned char *) "\r\n", 2);
620     if (hr->content_buf)
621         odr_write2(o, hr->content_buf, hr->content_len);
622     if (o->direction == ODR_PRINT)
623     {
624         odr_printf(o, "-- HTTP response:\n");
625         dump_http_package(o, (const char *) o->buf + top0, o->top - top0);
626         odr_printf(o, "--\n");
627     }
628     return 1;
629 }
630
631 int yaz_encode_http_request(ODR o, Z_HTTP_Request *hr)
632 {
633     Z_HTTP_Header *h;
634     int top0 = o->top;
635
636     odr_write2(o, hr->method, strlen(hr->method));
637     odr_write2(o, " ", 1);
638     odr_write2(o, hr->path, strlen(hr->path));
639     odr_write2(o, " HTTP/", 6);
640     odr_write2(o, hr->version, strlen(hr->version));
641     odr_write2(o, "\r\n", 2);
642     if (hr->content_len &&
643         !z_HTTP_header_lookup(hr->headers,
644                               "Content-Length"))
645     {
646         char lstr[60];
647         sprintf(lstr, "Content-Length: %d\r\n",
648                 hr->content_len);
649         odr_write2(o, lstr, strlen(lstr));
650     }
651     for (h = hr->headers; h; h = h->next)
652     {
653         odr_write2(o, h->name, strlen(h->name));
654         odr_write2(o, ": ", 2);
655         odr_write2(o, h->value, strlen(h->value));
656         odr_write2(o, "\r\n", 2);
657     }
658     odr_write2(o, "\r\n", 2);
659     if (hr->content_buf)
660         odr_write2(o, hr->content_buf, hr->content_len);
661     if (o->direction == ODR_PRINT)
662     {
663         odr_printf(o, "-- HTTP request:\n");
664         dump_http_package(o, (const char *) o->buf + top0, o->top - top0);
665         odr_printf(o, "--\n");
666     }
667     return 1;
668 }
669
670 /*
671  * Local variables:
672  * c-basic-offset: 4
673  * c-file-style: "Stroustrup"
674  * indent-tabs-mode: nil
675  * End:
676  * vim: shiftwidth=4 tabstop=8 expandtab
677  */
678