Update from Debian version 2.7-1.2.
[pound.git] / http.c
1 /*
2  * Pound - the reverse-proxy load-balancer
3  * Copyright (C) 2002-2010 Apsis GmbH
4  *
5  * This file is part of Pound.
6  *
7  * Pound is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 3 of the License, or
10  * (at your option) any later version.
11  * 
12  * Pound is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
19  *
20  * Contact information:
21  * Apsis GmbH
22  * P.O.Box
23  * 8707 Uetikon am See
24  * Switzerland
25  * EMail: roseg@apsis.ch
26  */
27
28 #include    "pound.h"
29
30 /* HTTP error replies */
31 static char *h500 = "500 Internal Server Error",
32             *h501 = "501 Not Implemented",
33             *h503 = "503 Service Unavailable",
34             *h414 = "414 Request URI too long";
35
36 static char *err_response = "HTTP/1.0 %s\r\nContent-Type: text/html\r\nContent-Length: %d\r\nExpires: now\r\nPragma: no-cache\r\nCache-control: no-cache,no-store\r\n\r\n%s";
37
38 /*
39  * Reply with an error
40  */
41 static void
42 err_reply(BIO *const c, const char *head, const char *txt)
43 {
44     BIO_printf(c, err_response, head, strlen(txt), txt);
45     BIO_flush(c);
46     return;
47 }
48
49 /*
50  * Reply with a redirect
51  */
52 static void
53 redirect_reply(BIO *const c, const char *url, const int code)
54 {
55     char    rep[MAXBUF], cont[MAXBUF], safe_url[MAXBUF], *code_msg;
56     int     i, j;
57
58     switch(code) {
59     case 301:
60         code_msg = "Moved Permanently";
61         break;
62     case 307:
63         code_msg = "Temporary Redirect";
64         break;
65     default:
66         code_msg = "Found";
67         break;
68     }
69     /*
70      * Make sure to return a safe version of the URL (otherwise CSRF becomes a possibility)
71      */
72     memset(safe_url, 0, MAXBUF);
73     for(i = j = 0; i < MAXBUF && j < MAXBUF && url[i]; i++)
74         if(isalnum(url[i]) || url[i] == '_' || url[i] == '.' || url[i] == ':' || url[i] == '/'
75         || url[i] == '?' || url[i] == '&' || url[i] == ';' || url[i] == '-' || url[i] == '=')
76             safe_url[j++] = url[i];
77         else {
78             sprintf(safe_url + j, "%%%02x", url[i]);
79             j += 3;
80         }
81     snprintf(cont, sizeof(cont),
82         "<html><head><title>Redirect</title></head><body><h1>Redirect</h1><p>You should go to <a href=\"%s\">%s</a></p></body></html>",
83         safe_url, safe_url);
84     snprintf(rep, sizeof(rep),
85         "HTTP/1.0 %d %s\r\nLocation: %s\r\nContent-Type: text/html\r\nContent-Length: %d\r\n\r\n",
86         code, code_msg, safe_url, strlen(cont));
87     BIO_write(c, rep, strlen(rep));
88     BIO_write(c, cont, strlen(cont));
89     BIO_flush(c);
90     return;
91 }
92
93 /*
94  * Read and write some binary data
95  */
96 static int
97 copy_bin(BIO *const cl, BIO *const be, LONG cont, LONG *res_bytes, const int no_write)
98 {
99     char        buf[MAXBUF];
100     int         res;
101
102     while(cont > L0) {
103         if((res = BIO_read(cl, buf, cont > MAXBUF? MAXBUF: cont)) < 0)
104             return -1;
105         else if(res == 0)
106             return -2;
107         if(!no_write)
108             if(BIO_write(be, buf, res) != res)
109                 return -3;
110         cont -= res;
111         if(res_bytes)
112             *res_bytes += res;
113     }
114     if(!no_write)
115         if(BIO_flush(be) != 1)
116             return -4;
117     return 0;
118 }
119
120 /*
121  * Get a "line" from a BIO, strip the trailing newline, skip the input stream if buffer too small
122  * The result buffer is NULL terminated
123  * Return 0 on success
124  */
125 static int
126 get_line(BIO *const in, char *const buf, const int bufsize)
127 {
128     char    tmp;
129     int     i, n_read;
130
131     memset(buf, 0, bufsize);
132     for(n_read = 0;;)
133         switch(BIO_gets(in, buf + n_read, bufsize - n_read - 1)) {
134         case -2:
135             /* BIO_gets not implemented */
136             return -1;
137         case 0:
138         case -1:
139             return 1;
140         default:
141             for(i = n_read; i < bufsize && buf[i]; i++)
142                 if(buf[i] == '\n' || buf[i] == '\r') {
143                     buf[i] = '\0';
144                     return 0;
145                 }
146             if(i < bufsize) {
147                 n_read = i;
148                 continue;
149             }
150             logmsg(LOG_NOTICE, "(%lx) line too long: %s", pthread_self(), buf);
151             /* skip rest of "line" */
152             tmp = '\0';
153             while(tmp != '\n')
154                 if(BIO_read(in, &tmp, 1) != 1)
155                     return 1;
156             break;
157         }
158     return 0;
159 }
160
161 /*
162  * Strip trailing CRLF
163  */
164 static int
165 strip_eol(char *lin)
166 {
167     while(*lin)
168         if(*lin == '\n' || (*lin == '\r' && *(lin + 1) == '\n')) {
169             *lin = '\0';
170             return 1;
171         } else
172             lin++;
173     return 0;
174 }
175
176 /*
177  * Copy chunked
178  */
179 static int
180 copy_chunks(BIO *const cl, BIO *const be, LONG *res_bytes, const int no_write, const LONG max_size)
181 {
182     char        buf[MAXBUF];
183     LONG        cont, tot_size;
184     regmatch_t  matches[2];
185     int         res;
186
187     for(tot_size = 0L;;) {
188         if((res = get_line(cl, buf, MAXBUF)) < 0) {
189             logmsg(LOG_NOTICE, "(%lx) chunked read error: %s", pthread_self(), strerror(errno));
190             return -1;
191         } else if(res > 0)
192             /* EOF */
193             return 0;
194         if(!regexec(&CHUNK_HEAD, buf, 2, matches, 0))
195             cont = STRTOL(buf, NULL, 16);
196         else {
197             /* not chunk header */
198             logmsg(LOG_NOTICE, "(%lx) bad chunk header <%s>: %s", pthread_self(), buf, strerror(errno));
199             return -2;
200         }
201         if(!no_write)
202             if(BIO_printf(be, "%s\r\n", buf) <= 0) {
203                 logmsg(LOG_NOTICE, "(%lx) error write chunked: %s", pthread_self(), strerror(errno));
204                 return -3;
205             }
206
207         tot_size += cont;
208         if(max_size > L0 && tot_size > max_size) {
209             logmsg(LOG_WARNING, "(%lx) chunk content too large", pthread_self);
210                 return -4;
211         }
212
213         if(cont > L0) {
214             if(copy_bin(cl, be, cont, res_bytes, no_write)) {
215                 if(errno)
216                     logmsg(LOG_NOTICE, "(%lx) error copy chunk cont: %s", pthread_self(), strerror(errno));
217                 return -4;
218             }
219         } else
220             break;
221         /* final CRLF */
222         if((res = get_line(cl, buf, MAXBUF)) < 0) {
223             logmsg(LOG_NOTICE, "(%lx) error after chunk: %s", pthread_self(), strerror(errno));
224             return -5;
225         } else if(res > 0) {
226             logmsg(LOG_NOTICE, "(%lx) unexpected EOF after chunk", pthread_self());
227             return -5;
228         }
229         if(buf[0])
230             logmsg(LOG_NOTICE, "(%lx) unexpected after chunk \"%s\"", pthread_self(), buf);
231         if(!no_write)
232             if(BIO_printf(be, "%s\r\n", buf) <= 0) {
233                 logmsg(LOG_NOTICE, "(%lx) error after chunk write: %s", pthread_self(), strerror(errno));
234                 return -6;
235             }
236     }
237     /* possibly trailing headers */
238     for(;;) {
239         if((res = get_line(cl, buf, MAXBUF)) < 0) {
240             logmsg(LOG_NOTICE, "(%lx) error post-chunk: %s", pthread_self(), strerror(errno));
241             return -7;
242         } else if(res > 0)
243             break;
244         if(!no_write)
245             if(BIO_printf(be, "%s\r\n", buf) <= 0) {
246                 logmsg(LOG_NOTICE, "(%lx) error post-chunk write: %s", pthread_self(), strerror(errno));
247                 return -8;
248             }
249         if(!buf[0])
250             break;
251     }
252     if(!no_write)
253         if(BIO_flush(be) != 1) {
254             logmsg(LOG_NOTICE, "(%lx) copy_chunks flush error: %s", pthread_self(), strerror(errno));
255             return -4;
256         }
257     return 0;
258 }
259
260 static int  err_to = -1;
261
262 typedef struct {
263     int         timeout;
264     RENEG_STATE *reneg_state;
265 } BIO_ARG;
266
267 /*
268  * Time-out for client read/gets
269  * the SSL manual says not to do it, but it works well enough anyway...
270  */
271 static long
272 bio_callback(BIO *const bio, const int cmd, const char *argp, int argi, long argl, long ret)
273 {
274     BIO_ARG *bio_arg;
275     struct pollfd   p;
276     int             to, p_res, p_err;
277
278     if(cmd != BIO_CB_READ && cmd != BIO_CB_WRITE)
279         return ret;
280
281     /* a time-out already occured */
282     if((bio_arg = (BIO_ARG*)BIO_get_callback_arg(bio))==NULL)
283         return ret;
284     if((to = bio_arg->timeout * 1000) < 0) {
285         errno = ETIMEDOUT;
286         return -1;
287     }
288
289     /* Renegotiations */
290     /* logmsg(LOG_NOTICE, "RENEG STATE %d", bio_arg->reneg_state==NULL?-1:*bio_arg->reneg_state); */
291     if (bio_arg->reneg_state != NULL && *bio_arg->reneg_state == RENEG_ABORT) {
292         logmsg(LOG_NOTICE, "REJECTING renegotiated session");
293         errno = ECONNABORTED;
294         return -1;
295     }
296
297     if (to == 0)
298         return ret;
299
300     for(;;) {
301         memset(&p, 0, sizeof(p));
302         BIO_get_fd(bio, &p.fd);
303         p.events = (cmd == BIO_CB_READ)? (POLLIN | POLLPRI): POLLOUT;
304         p_res = poll(&p, 1, to);
305         p_err = errno;
306         switch(p_res) {
307         case 1:
308             if(cmd == BIO_CB_READ) {
309                 if((p.revents & POLLIN) || (p.revents & POLLPRI))
310                     /* there is readable data */
311                     return ret;
312                 else {
313 #ifdef  EBUG
314                     logmsg(LOG_WARNING, "(%lx) CALLBACK read 0x%04x poll: %s",
315                         pthread_self(), p.revents, strerror(p_err));
316 #endif
317                     errno = EIO;
318                 }
319             } else {
320                 if(p.revents & POLLOUT)
321                     /* data can be written */
322                     return ret;
323                 else {
324 #ifdef  EBUG
325                     logmsg(LOG_WARNING, "(%lx) CALLBACK write 0x%04x poll: %s",
326                         pthread_self(), p.revents, strerror(p_err));
327 #endif
328                     errno = ECONNRESET;
329                 }
330             }
331             return -1;
332         case 0:
333             /* timeout - mark the BIO as unusable for the future */
334             bio_arg->timeout = err_to;
335 #ifdef  EBUG
336             logmsg(LOG_WARNING, "(%lx) CALLBACK timeout poll after %d secs: %s",
337                 pthread_self(), to / 1000, strerror(p_err));
338 #endif
339             errno = ETIMEDOUT;
340             return 0;
341         default:
342             /* error */
343             if(p_err != EINTR) {
344 #ifdef  EBUG
345                 logmsg(LOG_WARNING, "(%lx) CALLBACK bad %d poll: %s",
346                     pthread_self(), p_res, strerror(p_err));
347 #endif
348                 return -2;
349 #ifdef  EBUG
350             } else
351                 logmsg(LOG_WARNING, "(%lx) CALLBACK interrupted %d poll: %s",
352                     pthread_self(), p_res, strerror(p_err));
353 #else
354             }
355 #endif
356         }
357     }
358 }
359
360 /*
361  * Check if the file underlying a BIO is readable
362  */
363 static int
364 is_readable(BIO *const bio, const int to_wait)
365 {
366     struct pollfd   p;
367
368     if(BIO_pending(bio) > 0)
369         return 1;
370     memset(&p, 0, sizeof(p));
371     BIO_get_fd(bio, &p.fd);
372     p.events = POLLIN | POLLPRI;
373     return (poll(&p, 1, to_wait * 1000) > 0);
374 }
375
376 static void
377 free_headers(char **headers)
378 {
379     int     i;
380
381     for(i = 0; i < MAXHEADERS; i++)
382         if(headers[i])
383             free(headers[i]);
384     free(headers);
385     return;
386 }
387
388 static char **
389 get_headers(BIO *const in, BIO *const cl, const LISTENER *lstn)
390 {
391     char    **headers, buf[MAXBUF];
392     int     res, n, has_eol;
393
394     /* HTTP/1.1 allows leading CRLF */
395     memset(buf, 0, MAXBUF);
396     while((res = BIO_gets(in, buf, MAXBUF - 1)) > 0) {
397         has_eol = strip_eol(buf);
398         if(buf[0])
399             break;
400     }
401
402     if(res <= 0) {
403         /* this is expected to occur only on client reads */
404         /* logmsg(LOG_NOTICE, "headers: bad starting read"); */
405         return NULL;
406     } else if(!has_eol) {
407         /* check for request length limit */
408         logmsg(LOG_WARNING, "(%lx) e414 headers: request URI too long", pthread_self());
409         err_reply(cl, h414, lstn->err414);
410         return NULL;
411     }
412     if((headers = (char **)calloc(MAXHEADERS, sizeof(char *))) == NULL) {
413         logmsg(LOG_WARNING, "(%lx) e500 headers: out of memory", pthread_self());
414         err_reply(cl, h500, lstn->err500);
415         return NULL;
416     }
417     if((headers[0] = (char *)malloc(MAXBUF)) == NULL) {
418         free_headers(headers);
419         logmsg(LOG_WARNING, "(%lx) e500 header: out of memory", pthread_self());
420         err_reply(cl, h500, lstn->err500);
421         return NULL;
422     }
423     memset(headers[0], 0, MAXBUF);
424     strncpy(headers[0], buf, MAXBUF - 1);
425
426     for(n = 1; n < MAXHEADERS; n++) {
427         if(get_line(in, buf, MAXBUF)) {
428             free_headers(headers);
429             logmsg(LOG_WARNING, "(%lx) e500 can't read header", pthread_self());
430             err_reply(cl, h500, lstn->err500);
431             return NULL;
432         }
433         if(!buf[0])
434             return headers;
435         if((headers[n] = (char *)malloc(MAXBUF)) == NULL) {
436             free_headers(headers);
437             logmsg(LOG_WARNING, "(%lx) e500 header: out of memory", pthread_self());
438             err_reply(cl, h500, lstn->err500);
439             return NULL;
440         }
441         memset(headers[n], 0, MAXBUF);
442         strncpy(headers[n], buf, MAXBUF - 1);
443     }
444
445     free_headers(headers);
446     logmsg(LOG_NOTICE, "(%lx) e500 too many headers", pthread_self());
447     err_reply(cl, h500, lstn->err500);
448     return NULL;
449 }
450
451 #define LOG_TIME_SIZE   32
452 /*
453  * Apache log-file-style time format
454  */
455 static void
456 log_time(char *res)
457 {
458     time_t  now;
459     struct tm   *t_now, t_res;
460
461     now = time(NULL);
462 #ifdef  HAVE_LOCALTIME_R
463     t_now = localtime_r(&now, &t_res);
464 #else
465     t_now = localtime(&now);
466 #endif
467     strftime(res, LOG_TIME_SIZE - 1, "%d/%b/%Y:%H:%M:%S %z", t_now);
468     return;
469 }
470
471 static double
472 cur_time(void)
473 {
474 #ifdef  HAVE_GETTIMEOFDAY
475     struct timeval  tv;
476     struct timezone tz;
477     int             sv_errno;
478
479     sv_errno = errno;
480     gettimeofday(&tv, &tz);
481     errno = sv_errno;
482     return tv.tv_sec * 1000000.0 + tv.tv_usec;
483 #else
484     return time(NULL) * 1000000.0;
485 #endif
486 }
487
488 #define LOG_BYTES_SIZE  32
489 /*
490  * Apache log-file-style number format
491  */
492 static void
493 log_bytes(char *res, const LONG cnt)
494 {
495     if(cnt > L0)
496 #ifdef  HAVE_LONG_LONG_INT
497         snprintf(res, LOG_BYTES_SIZE - 1, "%lld", cnt);
498 #else
499         snprintf(res, LOG_BYTES_SIZE - 1, "%ld", cnt);
500 #endif
501     else
502         strcpy(res, "-");
503     return;
504 }
505
506 /* Cleanup code. This should really be in the pthread_cleanup_push, except for bugs in some implementations */
507
508 #define clean_all() {   \
509     if(ssl != NULL) { BIO_ssl_shutdown(cl); } \
510     if(be != NULL) { BIO_flush(be); BIO_reset(be); BIO_free_all(be); be = NULL; } \
511     if(cl != NULL) { BIO_flush(cl); BIO_reset(cl); BIO_free_all(cl); cl = NULL; } \
512     if(x509 != NULL) { X509_free(x509); x509 = NULL; } \
513     if(ssl != NULL) { ERR_clear_error(); ERR_remove_state(0); } \
514 }
515
516 /*
517  * handle an HTTP request
518  */
519 void
520 do_http(thr_arg *arg)
521 {
522     int                 cl_11, be_11, res, chunked, n, sock, no_cont, skip, conn_closed, force_10, sock_proto, is_rpc;
523     LISTENER            *lstn;
524     SERVICE             *svc;
525     BACKEND             *backend, *cur_backend, *old_backend;
526     struct addrinfo     from_host, z_addr;
527     struct sockaddr_storage from_host_addr;
528     BIO                 *cl, *be, *bb, *b64;
529     X509                *x509;
530     char                request[MAXBUF], response[MAXBUF], buf[MAXBUF], url[MAXBUF], loc_path[MAXBUF], **headers,
531                         headers_ok[MAXHEADERS], v_host[MAXBUF], referer[MAXBUF], u_agent[MAXBUF], u_name[MAXBUF],
532                         caddr[MAXBUF], req_time[LOG_TIME_SIZE], s_res_bytes[LOG_BYTES_SIZE], *mh;
533     SSL                 *ssl, *be_ssl;
534     LONG                cont, res_bytes;
535     regmatch_t          matches[4];
536     struct linger       l;
537     double              start_req, end_req;
538     RENEG_STATE         reneg_state;
539     BIO_ARG             ba1, ba2;
540
541     reneg_state = RENEG_INIT;
542     ba1.reneg_state =  &reneg_state;
543     ba2.reneg_state = &reneg_state;
544     ba1.timeout = 0;
545     ba2.timeout = 0;
546     from_host = ((thr_arg *)arg)->from_host;
547     memcpy(&from_host_addr, from_host.ai_addr, from_host.ai_addrlen);
548     from_host.ai_addr = (struct sockaddr *)&from_host_addr;
549     lstn = ((thr_arg *)arg)->lstn;
550     sock = ((thr_arg *)arg)->sock;
551     free(((thr_arg *)arg)->from_host.ai_addr);
552     free(arg);
553
554     if(lstn->allow_client_reneg)
555         reneg_state = RENEG_ALLOW;
556
557     n = 1;
558     setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (void *)&n, sizeof(n));
559     l.l_onoff = 1;
560     l.l_linger = 10;
561     setsockopt(sock, SOL_SOCKET, SO_LINGER, (void *)&l, sizeof(l));
562 #ifdef  TCP_LINGER2
563     n = 5;
564     setsockopt(sock, SOL_TCP, TCP_LINGER2, (void *)&n, sizeof(n));
565 #endif
566     n = 1;
567     setsockopt(sock, SOL_TCP, TCP_NODELAY, (void *)&n, sizeof(n));
568
569     cl = NULL;
570     be = NULL;
571     ssl = NULL;
572     x509 = NULL;
573
574     if((cl = BIO_new_socket(sock, 1)) == NULL) {
575         logmsg(LOG_WARNING, "(%lx) BIO_new_socket failed", pthread_self());
576         shutdown(sock, 2);
577         close(sock);
578         return;
579     }
580     ba1.timeout = lstn->to;
581     BIO_set_callback_arg(cl, (char *)&ba1);
582     BIO_set_callback(cl, bio_callback);
583
584     if(lstn->ctx != NULL) {
585         if((ssl = SSL_new(lstn->ctx->ctx)) == NULL) {
586             logmsg(LOG_WARNING, "(%lx) SSL_new: failed", pthread_self());
587             BIO_reset(cl);
588             BIO_free_all(cl);
589             return;
590         }
591         SSL_set_app_data(ssl, &reneg_state);
592         SSL_set_bio(ssl, cl, cl);
593         if((bb = BIO_new(BIO_f_ssl())) == NULL) {
594             logmsg(LOG_WARNING, "(%lx) BIO_new(Bio_f_ssl()) failed", pthread_self());
595             BIO_reset(cl);
596             BIO_free_all(cl);
597             return;
598         }
599         BIO_set_ssl(bb, ssl, BIO_CLOSE);
600         BIO_set_ssl_mode(bb, 0);
601         cl = bb;
602         if(BIO_do_handshake(cl) <= 0) {
603             /* no need to log every client without a certificate...
604             addr2str(caddr, MAXBUF - 1, &from_host, 1);
605             logmsg(LOG_NOTICE, "BIO_do_handshake with %s failed: %s", caddr,
606                 ERR_error_string(ERR_get_error(), NULL));
607             x509 = NULL;
608             */
609             BIO_reset(cl);
610             BIO_free_all(cl);
611             return;
612         } else {
613             if((x509 = SSL_get_peer_certificate(ssl)) != NULL && lstn->clnt_check < 3
614             && SSL_get_verify_result(ssl) != X509_V_OK) {
615                 addr2str(caddr, MAXBUF - 1, &from_host, 1);
616                 logmsg(LOG_NOTICE, "Bad certificate from %s", caddr);
617                 X509_free(x509);
618                 BIO_reset(cl);
619                 BIO_free_all(cl);
620                 return;
621             }
622         }
623     } else {
624         x509 = NULL;
625     }
626     cur_backend = NULL;
627
628     if((bb = BIO_new(BIO_f_buffer())) == NULL) {
629         logmsg(LOG_WARNING, "(%lx) BIO_new(buffer) failed", pthread_self());
630         if(x509 != NULL)
631             X509_free(x509);
632         BIO_reset(cl);
633         BIO_free_all(cl);
634         return;
635     }
636     BIO_set_close(cl, BIO_CLOSE);
637     BIO_set_buffer_size(cl, MAXBUF);
638     cl = BIO_push(bb, cl);
639
640     for(cl_11 = be_11 = 0;;) {
641         res_bytes = L0;
642         is_rpc = -1;
643         v_host[0] = referer[0] = u_agent[0] = u_name[0] = '\0';
644         conn_closed = 0;
645         for(n = 0; n < MAXHEADERS; n++)
646             headers_ok[n] = 1;
647         if((headers = get_headers(cl, cl, lstn)) == NULL) {
648             if(!cl_11) {
649                 if(errno) {
650                     addr2str(caddr, MAXBUF - 1, &from_host, 1);
651                     logmsg(LOG_NOTICE, "(%lx) error read from %s: %s", pthread_self(), caddr, strerror(errno));
652                     /* err_reply(cl, h500, lstn->err500); */
653                 }
654             }
655             clean_all();
656             return;
657         }
658         memset(req_time, 0, LOG_TIME_SIZE);
659         start_req = cur_time();
660         log_time(req_time);
661
662         /* check for correct request */
663         strncpy(request, headers[0], MAXBUF);
664         if(!regexec(&lstn->verb, request, 3, matches, 0)) {
665             no_cont = !strncasecmp(request + matches[1].rm_so, "HEAD", matches[1].rm_eo - matches[1].rm_so);
666             if(!strncasecmp(request + matches[1].rm_so, "RPC_IN_DATA", matches[1].rm_eo - matches[1].rm_so))
667                 is_rpc = 1;
668             else if(!strncasecmp(request + matches[1].rm_so, "RPC_OUT_DATA", matches[1].rm_eo - matches[1].rm_so))
669                 is_rpc = 0;
670         } else {
671             addr2str(caddr, MAXBUF - 1, &from_host, 1);
672             logmsg(LOG_WARNING, "(%lx) e501 bad request \"%s\" from %s", pthread_self(), request, caddr);
673             err_reply(cl, h501, lstn->err501);
674             free_headers(headers);
675             clean_all();
676             return;
677         }
678         cl_11 = (request[strlen(request) - 1] == '1');
679         n = cpURL(url, request + matches[2].rm_so, matches[2].rm_eo - matches[2].rm_so);
680         if(n != strlen(url)) {
681             /* the URL probably contained a %00 aka NULL - which we don't allow */
682             addr2str(caddr, MAXBUF - 1, &from_host, 1);
683             logmsg(LOG_NOTICE, "(%lx) e501 URL \"%s\" (contains NULL) from %s", pthread_self(), url, caddr);
684             err_reply(cl, h501, lstn->err501);
685             free_headers(headers);
686             clean_all();
687             return;
688         }
689         if(lstn->has_pat && regexec(&lstn->url_pat,  url, 0, NULL, 0)) {
690             addr2str(caddr, MAXBUF - 1, &from_host, 1);
691             logmsg(LOG_NOTICE, "(%lx) e501 bad URL \"%s\" from %s", pthread_self(), url, caddr);
692             err_reply(cl, h501, lstn->err501);
693             free_headers(headers);
694             clean_all();
695             return;
696         }
697
698         /* check other headers */
699         for(chunked = 0, cont = L_1, n = 1; n < MAXHEADERS && headers[n]; n++) {
700             /* no overflow - see check_header for details */
701             switch(check_header(headers[n], buf)) {
702             case HEADER_HOST:
703                 strcpy(v_host, buf);
704                 break;
705             case HEADER_REFERER:
706                 strcpy(referer, buf);
707                 break;
708             case HEADER_USER_AGENT:
709                 strcpy(u_agent, buf);
710                 break;
711             case HEADER_CONNECTION:
712                 if(!strcasecmp("close", buf))
713                     conn_closed = 1;
714                 break;
715             case HEADER_TRANSFER_ENCODING:
716                 if(cont >= L0)
717                     headers_ok[n] = 0;
718                 else if(!strcasecmp("chunked", buf))
719                     if(chunked)
720                         headers_ok[n] = 0;
721                     else
722                         chunked = 1;
723                 break;
724             case HEADER_CONTENT_LENGTH:
725                 if(chunked || cont >= 0L)
726                     headers_ok[n] = 0;
727                 else {
728                      if((cont = ATOL(buf)) < 0L)
729                          headers_ok[n] = 0;
730                     if(is_rpc == 1 && (cont < 0x20000L || cont > 0x80000000L))
731                         is_rpc = -1;
732                 }
733                 break;
734             case HEADER_EXPECT:
735                 /*
736                  * we do NOT support the "Expect: 100-continue" headers
737                  * support may involve severe performance penalties (non-responding back-end, etc)
738                  * as a stop-gap measure we just skip these headers
739                  */
740                 if(!strcasecmp("100-continue", buf))
741                     headers_ok[n] = 0;
742                 break;
743             case HEADER_ILLEGAL:
744                 if(lstn->log_level > 0) {
745                     addr2str(caddr, MAXBUF - 1, &from_host, 1);
746                     logmsg(LOG_NOTICE, "(%lx) bad header from %s (%s)", pthread_self(), caddr, headers[n]);
747                 }
748                 headers_ok[n] = 0;
749                 break;
750             }
751             if(headers_ok[n] && lstn->head_off) {
752                 /* maybe header to be removed */
753                 MATCHER *m;
754
755                 for(m = lstn->head_off; m; m = m->next)
756                     if(!(headers_ok[n] = regexec(&m->pat, headers[n], 0, NULL, 0)))
757                         break;
758             }
759             /* get User name */
760             if(!regexec(&AUTHORIZATION, headers[n], 2, matches, 0)) {
761                 int inlen;
762
763                 if((bb = BIO_new(BIO_s_mem())) == NULL) {
764                     logmsg(LOG_WARNING, "(%lx) Can't alloc BIO_s_mem", pthread_self());
765                     continue;
766                 }
767                 if((b64 = BIO_new(BIO_f_base64())) == NULL) {
768                     logmsg(LOG_WARNING, "(%lx) Can't alloc BIO_f_base64", pthread_self());
769                     BIO_free(bb);
770                     continue;
771                 }
772                 b64 = BIO_push(b64, bb);
773                 BIO_write(bb, headers[n] + matches[1].rm_so, matches[1].rm_eo - matches[1].rm_so);
774                 BIO_write(bb, "\n", 1);
775                 if((inlen = BIO_read(b64, buf, MAXBUF - 1)) <= 0) {
776                     logmsg(LOG_WARNING, "(%lx) Can't read BIO_f_base64", pthread_self());
777                     BIO_free_all(b64);
778                     continue;
779                 }
780                 BIO_free_all(b64);
781                 if((mh = strchr(buf, ':')) == NULL) {
782                     logmsg(LOG_WARNING, "(%lx) Unknown authentication", pthread_self());
783                     continue;
784                 }
785                 *mh = '\0';
786                 strcpy(u_name, buf);
787             }
788         }
789
790         /* possibly limited request size */
791         if(lstn->max_req > L0 && cont > L0 && cont > lstn->max_req && is_rpc != 1) {
792             addr2str(caddr, MAXBUF - 1, &from_host, 1);
793             logmsg(LOG_NOTICE, "(%lx) e501 request too large (%ld) from %s", pthread_self(), cont, caddr);
794             err_reply(cl, h501, lstn->err501);
795             free_headers(headers);
796             clean_all();
797             return;
798         }
799
800         if(be != NULL) {
801             if(is_readable(be, 0)) {
802                 /* The only way it's readable is if it's at EOF, so close it! */
803                 BIO_reset(be);
804                 BIO_free_all(be);
805                 be = NULL;
806             }
807         }
808
809         /* check that the requested URL still fits the old back-end (if any) */
810         if((svc = get_service(lstn, url, &headers[1])) == NULL) {
811             addr2str(caddr, MAXBUF - 1, &from_host, 1);
812             logmsg(LOG_NOTICE, "(%lx) e503 no service \"%s\" from %s %s", pthread_self(), request, caddr, v_host[0]? v_host: "-");
813             err_reply(cl, h503, lstn->err503);
814             free_headers(headers);
815             clean_all();
816             return;
817         }
818         if((backend = get_backend(svc, &from_host, url, &headers[1])) == NULL) {
819             addr2str(caddr, MAXBUF - 1, &from_host, 1);
820             logmsg(LOG_NOTICE, "(%lx) e503 no back-end \"%s\" from %s %s", pthread_self(), request, caddr, v_host[0]? v_host: "-");
821             err_reply(cl, h503, lstn->err503);
822             free_headers(headers);
823             clean_all();
824             return;
825         }
826
827         if(be != NULL && backend != cur_backend) {
828             BIO_reset(be);
829             BIO_free_all(be);
830             be = NULL;
831         }
832         while(be == NULL && backend->be_type == 0) {
833             switch(backend->addr.ai_family) {
834             case AF_INET:
835                 sock_proto = PF_INET;
836                 break;
837             case AF_INET6:
838                 sock_proto = PF_INET6;
839                 break;
840             case AF_UNIX:
841                 sock_proto = PF_UNIX;
842                 break;
843             default:
844                 logmsg(LOG_WARNING, "(%lx) e503 backend: unknown family %d", pthread_self(), backend->addr.ai_family);
845                 err_reply(cl, h503, lstn->err503);
846                 free_headers(headers);
847                 clean_all();
848                 return;
849             }
850             if((sock = socket(sock_proto, SOCK_STREAM, 0)) < 0) {
851                 str_be(buf, MAXBUF - 1, backend);
852                 logmsg(LOG_WARNING, "(%lx) e503 backend %s socket create: %s", pthread_self(), buf, strerror(errno));
853                 err_reply(cl, h503, lstn->err503);
854                 free_headers(headers);
855                 clean_all();
856                 return;
857             }
858             if(connect_nb(sock, &backend->addr, backend->conn_to) < 0) {
859                 str_be(buf, MAXBUF - 1, backend);
860                 logmsg(LOG_WARNING, "(%lx) backend %s connect: %s", pthread_self(), buf, strerror(errno));
861                 shutdown(sock, 2);
862                 close(sock);
863                 /*
864                  * kill the back-end only if no HAport is defined for it
865                  * otherwise allow the HAport mechanism to do its job
866                  */
867                 memset(&z_addr, 0, sizeof(z_addr));
868                 if(memcmp(&(backend->ha_addr), &(z_addr), sizeof(z_addr)) == 0)
869                     kill_be(svc, backend, BE_KILL);
870                 /*
871                  * ...but make sure we don't get into a loop with the same back-end
872                  */
873                 old_backend = backend;
874                 if((backend = get_backend(svc, &from_host, url, &headers[1])) == NULL || backend == old_backend) {
875                     addr2str(caddr, MAXBUF - 1, &from_host, 1);
876                     logmsg(LOG_NOTICE, "(%lx) e503 no back-end \"%s\" from %s", pthread_self(), request, caddr);
877                     err_reply(cl, h503, lstn->err503);
878                     free_headers(headers);
879                     clean_all();
880                     return;
881                 }
882                 continue;
883             }
884             if(sock_proto == PF_INET || sock_proto == PF_INET6) {
885                 n = 1;
886                 setsockopt(sock, SOL_SOCKET, SO_KEEPALIVE, (void *)&n, sizeof(n));
887                 l.l_onoff = 1;
888                 l.l_linger = 10;
889                 setsockopt(sock, SOL_SOCKET, SO_LINGER, (void *)&l, sizeof(l));
890 #ifdef  TCP_LINGER2
891                 n = 5;
892                 setsockopt(sock, SOL_TCP, TCP_LINGER2, (void *)&n, sizeof(n));
893 #endif
894                 n = 1;
895                 setsockopt(sock, SOL_TCP, TCP_NODELAY, (void *)&n, sizeof(n));
896             }
897             if((be = BIO_new_socket(sock, 1)) == NULL) {
898                 logmsg(LOG_WARNING, "(%lx) e503 BIO_new_socket server failed", pthread_self());
899                 shutdown(sock, 2);
900                 close(sock);
901                 err_reply(cl, h503, lstn->err503);
902                 free_headers(headers);
903                 clean_all();
904                 return;
905             }
906             BIO_set_close(be, BIO_CLOSE);
907             if(backend->to > 0) {
908                 ba2.timeout = backend->to;
909                 BIO_set_callback_arg(be, (char *)&ba2);
910                 BIO_set_callback(be, bio_callback);
911             }
912             if(backend->ctx != NULL) {
913                 if((be_ssl = SSL_new(backend->ctx)) == NULL) {
914                     logmsg(LOG_WARNING, "(%lx) be SSL_new: failed", pthread_self());
915                     err_reply(cl, h503, lstn->err503);
916                     free_headers(headers);
917                     clean_all();
918                     return;
919                 }
920                 SSL_set_bio(be_ssl, be, be);
921                 if((bb = BIO_new(BIO_f_ssl())) == NULL) {
922                     logmsg(LOG_WARNING, "(%lx) BIO_new(Bio_f_ssl()) failed", pthread_self());
923                     err_reply(cl, h503, lstn->err503);
924                     free_headers(headers);
925                     clean_all();
926                     return;
927                 }
928                 BIO_set_ssl(bb, be_ssl, BIO_CLOSE);
929                 BIO_set_ssl_mode(bb, 1);
930                 be = bb;
931                 if(BIO_do_handshake(be) <= 0) {
932                     str_be(buf, MAXBUF - 1, backend);
933                     logmsg(LOG_NOTICE, "BIO_do_handshake with %s failed: %s", buf,
934                         ERR_error_string(ERR_get_error(), NULL));
935                     err_reply(cl, h503, lstn->err503);
936                     free_headers(headers);
937                     clean_all();
938                     return;
939                 }
940             }
941             if((bb = BIO_new(BIO_f_buffer())) == NULL) {
942                 logmsg(LOG_WARNING, "(%lx) e503 BIO_new(buffer) server failed", pthread_self());
943                 err_reply(cl, h503, lstn->err503);
944                 free_headers(headers);
945                 clean_all();
946                 return;
947             }
948             BIO_set_buffer_size(bb, MAXBUF);
949             BIO_set_close(bb, BIO_CLOSE);
950             be = BIO_push(bb, be);
951         }
952         cur_backend = backend;
953
954         /* if we have anything but a BACK_END we close the channel */
955         if(be != NULL && cur_backend->be_type) {
956             BIO_reset(be);
957             BIO_free_all(be);
958             be = NULL;
959         }
960
961         /* send the request */
962         if(cur_backend->be_type == 0) {
963             for(n = 0; n < MAXHEADERS && headers[n]; n++) {
964                 if(!headers_ok[n])
965                     continue;
966                 /* this is the earliest we can check for Destination - we had no back-end before */
967                 if(lstn->rewr_dest && check_header(headers[n], buf) == HEADER_DESTINATION) {
968                     if(regexec(&LOCATION, buf, 4, matches, 0)) {
969                         logmsg(LOG_NOTICE, "(%lx) Can't parse Destination %s", pthread_self(), buf);
970                         break;
971                     }
972                     str_be(caddr, MAXBUF - 1, cur_backend);
973                     strcpy(loc_path, buf + matches[3].rm_so);
974                     snprintf(buf, MAXBUF, "Destination: http://%s%s", caddr, loc_path);
975                     free(headers[n]);
976                     if((headers[n] = strdup(buf)) == NULL) {
977                         logmsg(LOG_WARNING, "(%lx) rewrite Destination - out of memory: %s",
978                             pthread_self(), strerror(errno));
979                         free_headers(headers);
980                         clean_all();
981                         return;
982                     }
983                 }
984                 if(BIO_printf(be, "%s\r\n", headers[n]) <= 0) {
985                     str_be(buf, MAXBUF - 1, cur_backend);
986                     end_req = cur_time();
987                     logmsg(LOG_WARNING, "(%lx) e500 error write to %s/%s: %s (%.3f sec)",
988                         pthread_self(), buf, request, strerror(errno),
989                         (end_req - start_req) / 1000000.0);
990                     err_reply(cl, h500, lstn->err500);
991                     free_headers(headers);
992                     clean_all();
993                     return;
994                 }
995             }
996             /* add header if required */
997             if(lstn->add_head != NULL)
998                 if(BIO_printf(be, "%s\r\n", lstn->add_head) <= 0) {
999                     str_be(buf, MAXBUF - 1, cur_backend);
1000                     end_req = cur_time();
1001                     logmsg(LOG_WARNING, "(%lx) e500 error write AddHeader to %s: %s (%.3f sec)",
1002                         pthread_self(), buf, strerror(errno), (end_req - start_req) / 1000000.0);
1003                     err_reply(cl, h500, lstn->err500);
1004                     free_headers(headers);
1005                     clean_all();
1006                     return;
1007                 }
1008         }
1009         free_headers(headers);
1010
1011         /* if SSL put additional headers for client certificate */
1012         if(cur_backend->be_type == 0 && ssl != NULL) {
1013             const SSL_CIPHER  *cipher;
1014
1015             if((cipher = SSL_get_current_cipher(ssl)) != NULL) {
1016                 SSL_CIPHER_description(cipher, buf, MAXBUF - 1);
1017                 strip_eol(buf);
1018                 if(BIO_printf(be, "X-SSL-cipher: %s/%s\r\n", SSL_get_version(ssl), buf) <= 0) {
1019                     str_be(buf, MAXBUF - 1, cur_backend);
1020                     end_req = cur_time();
1021                     logmsg(LOG_WARNING, "(%lx) e500 error write X-SSL-cipher to %s: %s (%.3f sec)",
1022                         pthread_self(), buf, strerror(errno), (end_req - start_req) / 1000000.0);
1023                     err_reply(cl, h500, lstn->err500);
1024                     clean_all();
1025                     return;
1026                 }
1027             }
1028
1029             if(lstn->clnt_check > 0 && x509 != NULL && (bb = BIO_new(BIO_s_mem())) != NULL) {
1030                 X509_NAME_print_ex(bb, X509_get_subject_name(x509), 8, XN_FLAG_ONELINE & ~ASN1_STRFLGS_ESC_MSB);
1031                 get_line(bb, buf, MAXBUF);
1032                 if(BIO_printf(be, "X-SSL-Subject: %s\r\n", buf) <= 0) {
1033                     str_be(buf, MAXBUF - 1, cur_backend);
1034                     end_req = cur_time();
1035                     logmsg(LOG_WARNING, "(%lx) e500 error write X-SSL-Subject to %s: %s (%.3f sec)",
1036                         pthread_self(), buf, strerror(errno), (end_req - start_req) / 1000000.0);
1037                     err_reply(cl, h500, lstn->err500);
1038                     BIO_free_all(bb);
1039                     clean_all();
1040                     return;
1041                 }
1042
1043                 X509_NAME_print_ex(bb, X509_get_issuer_name(x509), 8, XN_FLAG_ONELINE & ~ASN1_STRFLGS_ESC_MSB);
1044                 get_line(bb, buf, MAXBUF);
1045                 if(BIO_printf(be, "X-SSL-Issuer: %s\r\n", buf) <= 0) {
1046                     str_be(buf, MAXBUF - 1, cur_backend);
1047                     end_req = cur_time();
1048                     logmsg(LOG_WARNING, "(%lx) e500 error write X-SSL-Issuer to %s: %s (%.3f sec)",
1049                         pthread_self(), buf, strerror(errno), (end_req - start_req) / 1000000.0);
1050                     err_reply(cl, h500, lstn->err500);
1051                     BIO_free_all(bb);
1052                     clean_all();
1053                     return;
1054                 }
1055
1056                 ASN1_TIME_print(bb, X509_get_notBefore(x509));
1057                 get_line(bb, buf, MAXBUF);
1058                 if(BIO_printf(be, "X-SSL-notBefore: %s\r\n", buf) <= 0) {
1059                     str_be(buf, MAXBUF - 1, cur_backend);
1060                     end_req = cur_time();
1061                     logmsg(LOG_WARNING, "(%lx) e500 error write X-SSL-notBefore to %s: %s (%.3f sec)",
1062                         pthread_self(), buf, strerror(errno), (end_req - start_req) / 1000000.0);
1063                     err_reply(cl, h500, lstn->err500);
1064                     BIO_free_all(bb);
1065                     clean_all();
1066                     return;
1067                 }
1068
1069                 ASN1_TIME_print(bb, X509_get_notAfter(x509));
1070                 get_line(bb, buf, MAXBUF);
1071                 if(BIO_printf(be, "X-SSL-notAfter: %s\r\n", buf) <= 0) {
1072                     str_be(buf, MAXBUF - 1, cur_backend);
1073                     end_req = cur_time();
1074                     logmsg(LOG_WARNING, "(%lx) e500 error write X-SSL-notAfter to %s: %s (%.3f sec)",
1075                         pthread_self(), buf, strerror(errno), (end_req - start_req) / 1000000.0);
1076                     err_reply(cl, h500, lstn->err500);
1077                     BIO_free_all(bb);
1078                     clean_all();
1079                     return;
1080                 }
1081                 if(BIO_printf(be, "X-SSL-serial: %ld\r\n", ASN1_INTEGER_get(X509_get_serialNumber(x509))) <= 0) {
1082                     str_be(buf, MAXBUF - 1, cur_backend);
1083                     end_req = cur_time();
1084                     logmsg(LOG_WARNING, "(%lx) e500 error write X-SSL-serial to %s: %s (%.3f sec)",
1085                         pthread_self(), buf, strerror(errno), (end_req - start_req) / 1000000.0);
1086                     err_reply(cl, h500, lstn->err500);
1087                     BIO_free_all(bb);
1088                     clean_all();
1089                     return;
1090                 }
1091 #ifdef  CERT1L
1092                 PEM_write_bio_X509(bb, x509);
1093                 get_line(bb, buf, MAXBUF);
1094                 if(BIO_printf(be, "X-SSL-certificate: %s", buf) <= 0) {
1095                     str_be(buf, MAXBUF - 1, cur_backend);
1096                     end_req = cur_time();
1097                     logmsg(LOG_WARNING, "(%lx) e500 error write X-SSL-certificate to %s: %s (%.3f sec)",
1098                         pthread_self(), buf, strerror(errno), (end_req - start_req) / 1000000.0);
1099                     err_reply(cl, h500, lstn->err500);
1100                     BIO_free_all(bb);
1101                     clean_all();
1102                     return;
1103                 }
1104                 while(get_line(bb, buf, MAXBUF) == 0) {
1105                     if(BIO_printf(be, "%s", buf) <= 0) {
1106                         str_be(buf, MAXBUF - 1, cur_backend);
1107                         end_req = cur_time();
1108                         logmsg(LOG_WARNING, "(%lx) e500 error write X-SSL-certificate to %s: %s (%.3f sec)",
1109                             pthread_self(), buf, strerror(errno), (end_req - start_req) / 1000000.0);
1110                         err_reply(cl, h500, lstn->err500);
1111                         BIO_free_all(bb);
1112                         clean_all();
1113                         return;
1114                     }
1115                 }
1116                 if(BIO_printf(be, "\r\n", buf) <= 0) {
1117                     str_be(buf, MAXBUF - 1, cur_backend);
1118                     end_req = cur_time();
1119                     logmsg(LOG_WARNING, "(%lx) e500 error write X-SSL-certificate to %s: %s (%.3f sec)",
1120                         pthread_self(), buf, strerror(errno), (end_req - start_req) / 1000000.0);
1121                     err_reply(cl, h500, lstn->err500);
1122                     BIO_free_all(bb);
1123                     clean_all();
1124                     return;
1125                 }
1126 #else
1127                 PEM_write_bio_X509(bb, x509);
1128                 get_line(bb, buf, MAXBUF);
1129                 if(BIO_printf(be, "X-SSL-certificate: %s\r\n", buf) <= 0) {
1130                     str_be(buf, MAXBUF - 1, cur_backend);
1131                     end_req = cur_time();
1132                     logmsg(LOG_WARNING, "(%lx) e500 error write X-SSL-certificate to %s: %s (%.3f sec)",
1133                         pthread_self(), buf, strerror(errno), (end_req - start_req) / 1000000.0);
1134                     err_reply(cl, h500, lstn->err500);
1135                     BIO_free_all(bb);
1136                     clean_all();
1137                     return;
1138                 }
1139                 while(get_line(bb, buf, MAXBUF) == 0) {
1140                     if(BIO_printf(be, "\t%s\r\n", buf) <= 0) {
1141                         str_be(buf, MAXBUF - 1, cur_backend);
1142                         end_req = cur_time();
1143                         logmsg(LOG_WARNING, "(%lx) e500 error write X-SSL-certificate to %s: %s (%.3f sec)",
1144                             pthread_self(), buf, strerror(errno), (end_req - start_req) / 1000000.0);
1145                         err_reply(cl, h500, lstn->err500);
1146                         BIO_free_all(bb);
1147                         clean_all();
1148                         return;
1149                     }
1150                 }
1151 #endif
1152                 BIO_free_all(bb);
1153             }
1154         }
1155         /* put additional client IP header */
1156         if(cur_backend->be_type == 0) {
1157             addr2str(caddr, MAXBUF - 1, &from_host, 1);
1158             BIO_printf(be, "X-Forwarded-For: %s\r\n", caddr);
1159
1160             /* final CRLF */
1161             BIO_puts(be, "\r\n");
1162         }
1163
1164         if(cl_11 && chunked) {
1165             /* had Transfer-encoding: chunked so read/write all the chunks (HTTP/1.1 only) */
1166             if(copy_chunks(cl, be, NULL, cur_backend->be_type, lstn->max_req)) {
1167                 str_be(buf, MAXBUF - 1, cur_backend);
1168                 end_req = cur_time();
1169                 addr2str(caddr, MAXBUF - 1, &from_host, 1);
1170                 logmsg(LOG_NOTICE, "(%lx) e500 for %s copy_chunks to %s/%s (%.3f sec)",
1171                     pthread_self(), caddr, buf, request, (end_req - start_req) / 1000000.0);
1172                 err_reply(cl, h500, lstn->err500);
1173                 clean_all();
1174                 return;
1175             }
1176         } else if(cont > L0 && is_rpc != 1) {
1177             /* had Content-length, so do raw reads/writes for the length */
1178             if(copy_bin(cl, be, cont, NULL, cur_backend->be_type)) {
1179                 str_be(buf, MAXBUF - 1, cur_backend);
1180                 end_req = cur_time();
1181                 addr2str(caddr, MAXBUF - 1, &from_host, 1);
1182                 logmsg(LOG_NOTICE, "(%lx) e500 for %s error copy client cont to %s/%s: %s (%.3f sec)",
1183                     pthread_self(), caddr, buf, request, strerror(errno), (end_req - start_req) / 1000000.0);
1184                 err_reply(cl, h500, lstn->err500);
1185                 clean_all();
1186                 return;
1187             }
1188         } else if(cont > 0L && is_readable(cl, lstn->to)) {
1189             char one;
1190             BIO  *cl_unbuf;
1191             /*
1192              * special mode for RPC_IN_DATA - content until EOF
1193              * force HTTP/1.0 - client closes connection when done.
1194              */
1195             cl_11 = be_11 = 0;
1196
1197             /*
1198              * first read whatever is already in the input buffer
1199              */
1200             while(BIO_pending(cl)) {
1201                 if(BIO_read(cl, &one, 1) != 1) {
1202                     logmsg(LOG_NOTICE, "(%lx) error read request pending: %s",
1203                         pthread_self(), strerror(errno));
1204                     clean_all();
1205                     pthread_exit(NULL);
1206                 }
1207                 if (++res_bytes > cont) {
1208                     logmsg(LOG_NOTICE, "(%lx) error read request pending: max. RPC length exceeded",
1209                         pthread_self());
1210                     clean_all();
1211                     pthread_exit(NULL);
1212                 }
1213                 if(BIO_write(be, &one, 1) != 1) {
1214                     if(errno)
1215                         logmsg(LOG_NOTICE, "(%lx) error write request pending: %s",
1216                             pthread_self(), strerror(errno));
1217                     clean_all();
1218                     pthread_exit(NULL);
1219                 }
1220             }
1221             BIO_flush(be);
1222
1223             /*
1224              * find the socket BIO in the chain
1225              */
1226             if ((cl_unbuf = BIO_find_type(cl, lstn->ctx? BIO_TYPE_SSL : BIO_TYPE_SOCKET)) == NULL) {
1227                  logmsg(LOG_WARNING, "(%lx) error get unbuffered: %s", pthread_self(), strerror(errno));
1228                  clean_all();
1229                  pthread_exit(NULL);
1230             }
1231
1232             /*
1233              * copy till EOF
1234              */
1235             while((res = BIO_read(cl_unbuf, buf, MAXBUF)) > 0) {
1236                 if((res_bytes += res) > cont) {
1237                     logmsg(LOG_NOTICE, "(%lx) error copy request body: max. RPC length exceeded",
1238                         pthread_self());
1239                     clean_all();
1240                     pthread_exit(NULL);
1241                 }
1242                 if(BIO_write(be, buf, res) != res) {
1243                     if(errno)
1244                         logmsg(LOG_NOTICE, "(%lx) error copy request body: %s",
1245                             pthread_self(), strerror(errno));
1246                     clean_all();
1247                     pthread_exit(NULL);
1248                 } else {
1249                     BIO_flush(be);
1250                 }
1251             }
1252         }
1253
1254         /* flush to the back-end */
1255         if(cur_backend->be_type == 0 && BIO_flush(be) != 1) {
1256             str_be(buf, MAXBUF - 1, cur_backend);
1257             end_req = cur_time();
1258             addr2str(caddr, MAXBUF - 1, &from_host, 1);
1259             logmsg(LOG_NOTICE, "(%lx) e500 for %s error flush to %s/%s: %s (%.3f sec)",
1260                 pthread_self(), caddr, buf, request, strerror(errno), (end_req - start_req) / 1000000.0);
1261             err_reply(cl, h500, lstn->err500);
1262             clean_all();
1263             return;
1264         }
1265
1266         /*
1267          * check on no_https_11:
1268          *  - if 0 ignore
1269          *  - if 1 and SSL force HTTP/1.0
1270          *  - if 2 and SSL and MSIE force HTTP/1.0
1271          */
1272         switch(lstn->noHTTPS11) {
1273         case 1:
1274             force_10 = (ssl != NULL);
1275             break;
1276         case 2:
1277             force_10 = (ssl != NULL && strstr(u_agent, "MSIE") != NULL);
1278             break;
1279         default:
1280             force_10 = 0;
1281             break;
1282         }
1283
1284         /* if we have a redirector */
1285         if(cur_backend->be_type) {
1286             memset(buf, 0, sizeof(buf));
1287             if(!cur_backend->redir_req)
1288                 snprintf(buf, sizeof(buf) - 1, "%s%s", cur_backend->url, url);
1289             else 
1290                 strncpy(buf, cur_backend->url, sizeof(buf) - 1);
1291             redirect_reply(cl, buf, cur_backend->be_type);
1292             addr2str(caddr, MAXBUF - 1, &from_host, 1);
1293             switch(lstn->log_level) {
1294             case 0:
1295                 break;
1296             case 1:
1297             case 2:
1298                 logmsg(LOG_INFO, "%s %s - REDIRECT %s", caddr, request, buf);
1299                 break;
1300             case 3:
1301                 if(v_host[0])
1302                     logmsg(LOG_INFO, "%s %s - %s [%s] \"%s\" %d 0 \"%s\" \"%s\"", v_host, caddr,
1303                         u_name[0]? u_name: "-", req_time, request, cur_backend->be_type, referer, u_agent);
1304                 else
1305                     logmsg(LOG_INFO, "%s - %s [%s] \"%s\" %d 0 \"%s\" \"%s\"", caddr,
1306                         u_name[0]? u_name: "-", req_time, request, cur_backend->be_type, referer, u_agent);
1307                 break;
1308             case 4:
1309             case 5:
1310                 logmsg(LOG_INFO, "%s - %s [%s] \"%s\" %d 0 \"%s\" \"%s\"", caddr,
1311                     u_name[0]? u_name: "-", req_time, request, cur_backend->be_type, referer, u_agent);
1312                 break;
1313             }
1314             if(!cl_11 || conn_closed || force_10)
1315                 break;
1316             continue;
1317         } else if(is_rpc == 1) {
1318             /* log RPC_IN_DATA */
1319             end_req = cur_time();
1320             memset(s_res_bytes, 0, LOG_BYTES_SIZE);
1321             /* actual request length */
1322             log_bytes(s_res_bytes, res_bytes);
1323             addr2str(caddr, MAXBUF - 1, &from_host, 1);
1324             str_be(buf, MAXBUF - 1, cur_backend);
1325             switch(lstn->log_level) {
1326             case 0:
1327                 break;
1328             case 1:
1329                 logmsg(LOG_INFO, "%s %s - -", caddr, request);
1330                 break;
1331             case 2:
1332                 if(v_host[0])
1333                     logmsg(LOG_INFO, "%s %s - - (%s/%s -> %s) %.3f sec",
1334                         caddr, request, v_host, svc->name[0]? svc->name: "-", buf,
1335                         (end_req - start_req) / 1000000.0);
1336                 else
1337                     logmsg(LOG_INFO, "%s %s - - (%s -> %s) %.3f sec",
1338                         caddr, request, svc->name[0]? svc->name: "-", buf,
1339                         (end_req - start_req) / 1000000.0);
1340                 break;
1341             case 3:
1342                 logmsg(LOG_INFO, "%s %s - %s [%s] \"%s\" 000 %s \"%s\" \"%s\"",
1343                     v_host[0]? v_host: "-",
1344                     caddr, u_name[0]? u_name: "-", req_time, request,
1345                     s_res_bytes, referer, u_agent);
1346                 break;
1347             case 4:
1348                 logmsg(LOG_INFO, "%s - %s [%s] \"%s\" 000 %s \"%s\" \"%s\"",
1349                     caddr, u_name[0]? u_name: "-", req_time, request,
1350                     s_res_bytes, referer, u_agent);
1351                 break;
1352             case 5:
1353                 logmsg(LOG_INFO, "%s %s - %s [%s] \"%s\" 000 %s \"%s\" \"%s\" (%s -> %s) %.3f sec",
1354                     v_host[0]? v_host: "-",
1355                     caddr, u_name[0]? u_name: "-", req_time, request,
1356                     s_res_bytes, referer, u_agent, svc->name[0]? svc->name: "-", buf,
1357                     (end_req - start_req) / 1000000.0);
1358                 break;
1359             }
1360             /* no response expected - bail out */
1361             break;
1362         }
1363
1364         /* get the response */
1365         for(skip = 1; skip;) {
1366             if((headers = get_headers(be, cl, lstn)) == NULL) {
1367                 str_be(buf, MAXBUF - 1, cur_backend);
1368                 end_req = cur_time();
1369                 addr2str(caddr, MAXBUF - 1, &from_host, 1);
1370                 logmsg(LOG_NOTICE, "(%lx) e500 for %s response error read from %s/%s: %s (%.3f secs)",
1371                     pthread_self(), caddr, buf, request, strerror(errno), (end_req - start_req) / 1000000.0);
1372                 err_reply(cl, h500, lstn->err500);
1373                 clean_all();
1374                 return;
1375             }
1376
1377             strncpy(response, headers[0], MAXBUF);
1378             be_11 = (response[7] == '1');
1379             /* responses with code 100 are never passed back to the client */
1380             skip = !regexec(&RESP_SKIP, response, 0, NULL, 0);
1381             /* some response codes (1xx, 204, 304) have no content */
1382             if(!no_cont && !regexec(&RESP_IGN, response, 0, NULL, 0))
1383                 no_cont = 1;
1384
1385             for(chunked = 0, cont = -1L, n = 1; n < MAXHEADERS && headers[n]; n++) {
1386                 switch(check_header(headers[n], buf)) {
1387                 case HEADER_CONNECTION:
1388                     if(!strcasecmp("close", buf))
1389                         conn_closed = 1;
1390                     break;
1391                 case HEADER_TRANSFER_ENCODING:
1392                     if(!strcasecmp("chunked", buf)) {
1393                         chunked = 1;
1394                         no_cont = 0;
1395                     }
1396                     break;
1397                 case HEADER_CONTENT_LENGTH:
1398                     cont = ATOL(buf);
1399                     /* treat RPC_OUT_DATA like reply without content-length */
1400                     if(is_rpc == 0) {
1401                         if(cont >= 0x20000L && cont <= 0x80000000L)
1402                             cont = -1L;
1403                         else
1404                             is_rpc = -1;
1405                     }
1406                     break;
1407                 case HEADER_LOCATION:
1408                     if(v_host[0] && need_rewrite(lstn->rewr_loc, buf, loc_path, v_host, lstn, cur_backend)) {
1409                         snprintf(buf, MAXBUF, "Location: %s://%s/%s",
1410                             (ssl == NULL? "http": "https"), v_host, loc_path);
1411                         free(headers[n]);
1412                         if((headers[n] = strdup(buf)) == NULL) {
1413                             logmsg(LOG_WARNING, "(%lx) rewrite Location - out of memory: %s",
1414                                 pthread_self(), strerror(errno));
1415                             free_headers(headers);
1416                             clean_all();
1417                             return;
1418                         }
1419                     }
1420                     break;
1421                 case HEADER_CONTLOCATION:
1422                     if(v_host[0] && need_rewrite(lstn->rewr_loc, buf, loc_path, v_host, lstn, cur_backend)) {
1423                         snprintf(buf, MAXBUF, "Content-location: %s://%s/%s",
1424                             (ssl == NULL? "http": "https"), v_host, loc_path);
1425                         free(headers[n]);
1426                         if((headers[n] = strdup(buf)) == NULL) {
1427                             logmsg(LOG_WARNING, "(%lx) rewrite Content-location - out of memory: %s",
1428                                 pthread_self(), strerror(errno));
1429                             free_headers(headers);
1430                             clean_all();
1431                             return;
1432                         }
1433                     }
1434                     break;
1435                 }
1436             }
1437
1438             /* possibly record session information (only for cookies/header) */
1439             upd_session(svc, &headers[1], cur_backend);
1440
1441             /* send the response */
1442             if(!skip)
1443                 for(n = 0; n < MAXHEADERS && headers[n]; n++) {
1444                     if(BIO_printf(cl, "%s\r\n", headers[n]) <= 0) {
1445                         if(errno) {
1446                             addr2str(caddr, MAXBUF - 1, &from_host, 1);
1447                             logmsg(LOG_NOTICE, "(%lx) error write to %s: %s", pthread_self(), caddr, strerror(errno));
1448                         }
1449                         free_headers(headers);
1450                         clean_all();
1451                         return;
1452                     }
1453                 }
1454             free_headers(headers);
1455
1456             /* final CRLF */
1457             if(!skip)
1458                 BIO_puts(cl, "\r\n");
1459             if(BIO_flush(cl) != 1) {
1460                 if(errno) {
1461                     addr2str(caddr, MAXBUF - 1, &from_host, 1);
1462                     logmsg(LOG_NOTICE, "(%lx) error flush headers to %s: %s", pthread_self(), caddr, strerror(errno));
1463                 }
1464                 clean_all();
1465                 return;
1466             }
1467
1468             if(!no_cont) {
1469                 /* ignore this if request was HEAD or similar */
1470                 if(be_11 && chunked) {
1471                     /* had Transfer-encoding: chunked so read/write all the chunks (HTTP/1.1 only) */
1472                     if(copy_chunks(be, cl, &res_bytes, skip, L0)) {
1473                         /* copy_chunks() has its own error messages */
1474                         clean_all();
1475                         return;
1476                     }
1477                 } else if(cont >= L0) {
1478                     /* may have had Content-length, so do raw reads/writes for the length */
1479                     if(copy_bin(be, cl, cont, &res_bytes, skip)) {
1480                         if(errno)
1481                             logmsg(LOG_NOTICE, "(%lx) error copy server cont: %s", pthread_self(), strerror(errno));
1482                         clean_all();
1483                         return;
1484                     }
1485                 } else if(!skip) {
1486                     if(is_readable(be, cur_backend->to)) {
1487                         char    one;
1488                         BIO     *be_unbuf;
1489                         /*
1490                          * old-style response - content until EOF
1491                          * also implies the client may not use HTTP/1.1
1492                          */
1493                         cl_11 = be_11 = 0;
1494
1495                         /*
1496                          * first read whatever is already in the input buffer
1497                          */
1498                         while(BIO_pending(be)) {
1499                             if(BIO_read(be, &one, 1) != 1) {
1500                                 logmsg(LOG_NOTICE, "(%lx) error read response pending: %s",
1501                                     pthread_self(), strerror(errno));
1502                                 clean_all();
1503                                 return;
1504                             }
1505                             if(BIO_write(cl, &one, 1) != 1) {
1506                                 if(errno)
1507                                     logmsg(LOG_NOTICE, "(%lx) error write response pending: %s",
1508                                         pthread_self(), strerror(errno));
1509                                 clean_all();
1510                                 return;
1511                             }
1512                             res_bytes++;
1513                         }
1514                         BIO_flush(cl);
1515
1516                         /*
1517                          * find the socket BIO in the chain
1518                          */
1519                         if((be_unbuf = BIO_find_type(be, cur_backend->ctx? BIO_TYPE_SSL : BIO_TYPE_SOCKET)) == NULL) {
1520                             logmsg(LOG_WARNING, "(%lx) error get unbuffered: %s", pthread_self(), strerror(errno));
1521                             clean_all();
1522                             return;
1523                         }
1524
1525                         /*
1526                          * copy till EOF
1527                          */
1528                         while((res = BIO_read(be_unbuf, buf, MAXBUF)) > 0) {
1529                             if(BIO_write(cl, buf, res) != res) {
1530                                 if(errno)
1531                                     logmsg(LOG_NOTICE, "(%lx) error copy response body: %s",
1532                                         pthread_self(), strerror(errno));
1533                                 clean_all();
1534                                 return;
1535                             } else {
1536                                 res_bytes += res;
1537                                 BIO_flush(cl);
1538                             }
1539                         }
1540                     }
1541                 }
1542                 if(BIO_flush(cl) != 1) {
1543                     /* client closes RPC_OUT_DATA connection - no error */
1544                     if(is_rpc == 0 && res_bytes > 0L)
1545                         break;
1546                     if(errno) {
1547                         addr2str(caddr, MAXBUF - 1, &from_host, 1);
1548                         logmsg(LOG_NOTICE, "(%lx) error final flush to %s: %s", pthread_self(), caddr, strerror(errno));
1549                     }
1550                     clean_all();
1551                     return;
1552                 }
1553             }
1554         }
1555         end_req = cur_time();
1556         upd_be(svc, cur_backend, end_req - start_req);
1557
1558         /* log what happened */
1559         memset(s_res_bytes, 0, LOG_BYTES_SIZE);
1560         log_bytes(s_res_bytes, res_bytes);
1561         addr2str(caddr, MAXBUF - 1, &from_host, 1);
1562         if(anonymise) {
1563             char    *last;
1564
1565             if((last = strrchr(caddr, '.')) != NULL || (last = strrchr(caddr, ':')) != NULL)
1566                 strcpy(++last, "0");
1567         }
1568         str_be(buf, MAXBUF - 1, cur_backend);
1569         switch(lstn->log_level) {
1570         case 0:
1571             break;
1572         case 1:
1573             logmsg(LOG_INFO, "%s %s - %s", caddr, request, response);
1574             break;
1575         case 2:
1576             if(v_host[0])
1577                 logmsg(LOG_INFO, "%s %s - %s (%s/%s -> %s) %.3f sec",
1578                     caddr, request, response, v_host, svc->name[0]? svc->name: "-", buf,
1579                     (end_req - start_req) / 1000000.0);
1580             else
1581                 logmsg(LOG_INFO, "%s %s - %s (%s -> %s) %.3f sec",
1582                     caddr, request, response, svc->name[0]? svc->name: "-", buf,
1583                     (end_req - start_req) / 1000000.0);
1584             break;
1585         case 3:
1586             logmsg(LOG_INFO, "%s %s - %s [%s] \"%s\" %c%c%c %s \"%s\" \"%s\"",
1587                 v_host[0]? v_host: "-",
1588                 caddr, u_name[0]? u_name: "-", req_time, request, response[9],
1589                 response[10], response[11], s_res_bytes, referer, u_agent);
1590             break;
1591         case 4:
1592             logmsg(LOG_INFO, "%s - %s [%s] \"%s\" %c%c%c %s \"%s\" \"%s\"",
1593                 caddr, u_name[0]? u_name: "-", req_time, request, response[9], response[10],
1594                 response[11], s_res_bytes, referer, u_agent);
1595             break;
1596         case 5:
1597             logmsg(LOG_INFO, "%s %s - %s [%s] \"%s\" %c%c%c %s \"%s\" \"%s\" (%s -> %s) %.3f sec",
1598                 v_host[0]? v_host: "-",
1599                 caddr, u_name[0]? u_name: "-", req_time, request, response[9], response[10],
1600                 response[11], s_res_bytes, referer, u_agent, svc->name[0]? svc->name: "-", buf,
1601                 (end_req - start_req) / 1000000.0);
1602             break;
1603         }
1604
1605         if(!be_11) {
1606             BIO_reset(be);
1607             BIO_free_all(be);
1608             be = NULL;
1609         }
1610         /*
1611          * Stop processing if:
1612          *  - client is not HTTP/1.1
1613          *      or
1614          *  - we had a "Connection: closed" header
1615          *      or
1616          *  - this is an SSL connection and we had a NoHTTPS11 directive
1617          */
1618         if(!cl_11 || conn_closed || force_10)
1619             break;
1620     }
1621
1622     /*
1623      * This may help with some versions of IE with a broken channel shutdown
1624      */
1625     if(ssl != NULL)
1626         SSL_set_shutdown(ssl, SSL_SENT_SHUTDOWN | SSL_RECEIVED_SHUTDOWN);
1627
1628     clean_all();
1629     return;
1630 }
1631
1632 void *
1633 thr_http(void *dummy)
1634 {
1635     thr_arg *arg;
1636
1637     for(;;) {
1638         while((arg = get_thr_arg()) == NULL)
1639             logmsg(LOG_NOTICE, "NULL get_thr_arg");
1640         do_http(arg);
1641     }
1642 }