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