Set a better default ciphers list if none was specified.
[pound.git] / svc.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 #include    "dh2048.h"
31
32
33 #ifndef LHASH_OF
34 #define LHASH_OF(x) LHASH
35 #define CHECKED_LHASH_OF(type, h) h
36 #endif
37
38 static DH   *DH2048_params;
39 static time_t   last_RSA, last_rescale, last_alive, last_expire;
40
41
42 DH *
43 DH_tmp_callback(/* not used */SSL *s, /* not used */int is_export, int keylength)
44 {
45     return DH2048_params;
46 }
47
48
49 /*
50  * Add a new key/content pair to a hash table
51  * the table should be already locked
52  */
53 static void
54 t_add(LHASH_OF(TABNODE) *const tab, const char *key, const void *content, const size_t cont_len)
55 {
56     TABNODE *t, *old;
57
58     if((t = (TABNODE *)malloc(sizeof(TABNODE))) == NULL) {
59         logmsg(LOG_WARNING, "t_add() content malloc");
60         return;
61     }
62     if((t->key = strdup(key)) == NULL) {
63         free(t);
64         logmsg(LOG_WARNING, "t_add() strdup");
65         return;
66     }
67     if((t->content = malloc(cont_len)) == NULL) {
68         free(t->key);
69         free(t);
70         logmsg(LOG_WARNING, "t_add() content malloc");
71         return;
72     }
73     memcpy(t->content, content, cont_len);
74     t->last_acc = time(NULL);
75 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
76     if((old = LHM_lh_insert(TABNODE, tab, t)) != NULL) {
77 #else
78     if((old = (TABNODE *)lh_insert(tab, t)) != NULL) {
79 #endif
80         free(old->key);
81         free(old->content);
82         free(old);
83         logmsg(LOG_WARNING, "t_add() DUP");
84     }
85     return;
86 }
87
88 /*
89  * Find a key
90  * returns the content in the parameter
91  * side-effect: update the time of last access
92  */
93 static void *
94 t_find(LHASH_OF(TABNODE) *const tab, char *const key)
95 {
96     TABNODE t, *res;
97
98     t.key = key;
99 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
100     if((res = (TABNODE *)LHM_lh_retrieve(TABNODE, tab, &t)) != NULL) {
101 #else
102     if((res = (TABNODE *)lh_retrieve(tab, &t)) != NULL) {
103 #endif
104         res->last_acc = time(NULL);
105         return res->content;
106     }
107     return NULL;
108 }
109
110 /*
111  * Delete a key
112  */
113 static void
114 t_remove(LHASH_OF(TABNODE) *const tab, char *const key)
115 {
116     TABNODE t, *res;
117
118     t.key = key;
119 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
120     if((res = LHM_lh_delete(TABNODE, tab, &t)) != NULL) {
121 #else
122     if((res = (TABNODE *)lh_delete(tab, &t)) != NULL) {
123 #endif
124         free(res->key);
125         free(res->content);
126         free(res);
127     }
128     return;
129 }
130
131 typedef struct  {
132     LHASH_OF(TABNODE)   *tab;
133     time_t              lim;
134     void                *content;
135     int                 cont_len;
136 }   ALL_ARG;
137
138 static void
139 t_old_doall_arg(TABNODE *t, ALL_ARG *a)
140 {
141     TABNODE *res;
142
143     if(t->last_acc < a->lim)
144 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
145         if((res = LHM_lh_delete(TABNODE, a->tab, t)) != NULL) {
146 #else
147         if((res = lh_delete(a->tab, t)) != NULL) {
148 #endif
149             free(res->key);
150             free(res->content);
151             free(res);
152         }
153     return;
154 }
155 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
156 IMPLEMENT_LHASH_DOALL_ARG_FN(t_old, TABNODE, ALL_ARG)
157 #else
158 #define t_old t_old_doall_arg
159 IMPLEMENT_LHASH_DOALL_ARG_FN(t_old, TABNODE *, ALL_ARG *)
160 #endif
161
162 /*
163  * Expire all old nodes
164  */
165 static void
166 t_expire(LHASH_OF(TABNODE) *const tab, const time_t lim)
167 {
168     ALL_ARG a;
169     int down_load;
170
171     a.tab = tab;
172     a.lim = lim;
173     down_load = CHECKED_LHASH_OF(TABNODE, tab)->down_load;
174     CHECKED_LHASH_OF(TABNODE, tab)->down_load = 0;
175 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
176     LHM_lh_doall_arg(TABNODE, tab, LHASH_DOALL_ARG_FN(t_old), ALL_ARG, &a);
177 #else
178     lh_doall_arg(tab, LHASH_DOALL_ARG_FN(t_old), &a);
179 #endif
180     CHECKED_LHASH_OF(TABNODE, tab)->down_load = down_load;
181     return;
182 }
183
184 static void
185 t_cont_doall_arg(TABNODE *t, ALL_ARG *arg)
186 {
187     TABNODE *res;
188
189     if(memcmp(t->content, arg->content, arg->cont_len) == 0)
190 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
191         if((res = LHM_lh_delete(TABNODE, arg->tab, t)) != NULL) {
192 #else
193         if((res = lh_delete(arg->tab, t)) != NULL) {
194 #endif
195             free(res->key);
196             free(res->content);
197             free(res);
198         }
199     return;
200 }
201 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
202 IMPLEMENT_LHASH_DOALL_ARG_FN(t_cont, TABNODE, ALL_ARG)
203 #else
204 #define t_cont t_cont_doall_arg
205 IMPLEMENT_LHASH_DOALL_ARG_FN(t_cont, TABNODE *, ALL_ARG *)
206 #endif
207
208 /*
209  * Remove all nodes with the given content
210  */
211 static void
212 t_clean(LHASH_OF(TABNODE) *const tab, void *const content, const size_t cont_len)
213 {
214     ALL_ARG a;
215     int down_load;
216
217     a.tab = tab;
218     a.content = content;
219     a.cont_len = cont_len;
220     down_load = CHECKED_LHASH_OF(TABNODE, tab)->down_load;
221     CHECKED_LHASH_OF(TABNODE, tab)->down_load = 0;
222 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
223     LHM_lh_doall_arg(TABNODE, tab, LHASH_DOALL_ARG_FN(t_cont), ALL_ARG, &a);
224 #else
225     lh_doall_arg(tab, LHASH_DOALL_ARG_FN(t_cont), &a);
226 #endif
227     CHECKED_LHASH_OF(TABNODE, tab)->down_load = down_load;
228     return;
229 }
230
231 /*
232  * Log an error to the syslog or to stderr
233  */
234 #ifdef  HAVE_STDARG_H
235 void
236 logmsg(const int priority, const char *fmt, ...)
237 {
238     char    buf[MAXBUF + 1];
239     va_list ap;
240     struct tm   *t_now, t_res;
241
242     buf[MAXBUF] = '\0';
243     va_start(ap, fmt);
244     vsnprintf(buf, MAXBUF, fmt, ap);
245     va_end(ap);
246     if(log_facility == -1) {
247         fprintf((priority == LOG_INFO || priority == LOG_DEBUG)? stdout: stderr, "%s\n", buf);
248     } else {
249         if(print_log)
250             printf("%s\n", buf);
251         else
252             syslog(log_facility | priority, "%s", buf);
253     }
254     return;
255 }
256 #else
257 void
258 logmsg(const int priority, const char *fmt, va_alist)
259 va_dcl
260 {
261     char    buf[MAXBUF + 1];
262     va_list ap;
263     struct tm   *t_now, t_res;
264
265     buf[MAXBUF] = '\0';
266     va_start(ap);
267     vsnprintf(buf, MAXBUF, fmt, ap);
268     va_end(ap);
269     if(log_facility == -1) {
270         fprintf((priority == LOG_INFO || priority == LOG_DEBUG)? stdout: stderr, "%s\n", buf);
271     } else {
272         if(print_log)
273             printf("%s\n", buf);
274         else
275             syslog(log_facility | priority, "%s", buf);
276     }
277     return;
278 }
279 #endif
280
281 /*
282  * Translate inet/inet6 address/port into a string
283  */
284 void
285 addr2str(char *const res, const int res_len, const struct addrinfo *addr, const int no_port)
286 {
287     char    buf[MAXBUF];
288     int     port;
289     void    *src;
290
291     memset(res, 0, res_len);
292 #ifdef  HAVE_INET_NTOP
293     switch(addr->ai_family) {
294     case AF_INET:
295         src = (void *)&((struct sockaddr_in *)addr->ai_addr)->sin_addr.s_addr;
296         port = ntohs(((struct sockaddr_in *)addr->ai_addr)->sin_port);
297         if(inet_ntop(AF_INET, src, buf, MAXBUF - 1) == NULL)
298             strncpy(buf, "(UNKNOWN)", MAXBUF - 1);
299         break;
300     case AF_INET6:
301         src = (void *)&((struct sockaddr_in6 *)addr->ai_addr)->sin6_addr.s6_addr;
302         port = ntohs(((struct sockaddr_in6 *)addr->ai_addr)->sin6_port);
303         if(inet_ntop(AF_INET6, src, buf, MAXBUF - 1) == NULL)
304             strncpy(buf, "(UNKNOWN)", MAXBUF - 1);
305         break;
306     case AF_UNIX:
307         strncpy(buf, (char *)addr->ai_addr, MAXBUF - 1);
308         port = 0;
309         break;
310     default:
311         strncpy(buf, "(UNKNOWN)", MAXBUF - 1);
312         port = 0;
313         break;
314     }
315     if(no_port)
316         snprintf(res, res_len, "%s", buf);
317     else
318         snprintf(res, res_len, "%s:%d", buf, port);
319 #else
320 #error "Pound needs inet_ntop()"
321 #endif
322     return;
323 }
324
325 /*
326  * Parse a URL, possibly decoding hexadecimal-encoded characters
327  */
328 int
329 cpURL(char *res, char *src, int len)
330 {
331     int     state;
332     char    *kp_res;
333
334     for(kp_res = res, state = 0; len > 0; len--)
335         switch(state) {
336         case 1:
337             if(*src >= '0' && *src <= '9') {
338                 *res = *src++ - '0';
339                 state = 2;
340             } else if(*src >= 'A' && *src <= 'F') {
341                 *res = *src++ - 'A' + 10;
342                 state = 2;
343             } else if(*src >= 'a' && *src <= 'f') {
344                 *res = *src++ - 'a' + 10;
345                 state = 2;
346             } else {
347                 *res++ = '%';
348                 *res++ = *src++;
349                 state = 0;
350             }
351             break;
352         case 2:
353             if(*src >= '0' && *src <= '9') {
354                 *res = *res * 16 + *src++ - '0';
355                 res++;
356                 state = 0;
357             } else if(*src >= 'A' && *src <= 'F') {
358                 *res = *res * 16 + *src++ - 'A' + 10;
359                 res++;
360                 state = 0;
361             } else if(*src >= 'a' && *src <= 'f') {
362                 *res = *res * 16 + *src++ - 'a' + 10;
363                 res++;
364                 state = 0;
365             } else {
366                 *res++ = '%';
367                 *res++ = *(src - 1);
368                 *res++ = *src++;
369                 state = 0;
370             }
371             break;
372         default:
373             if(*src != '%')
374                 *res++ = *src++;
375             else {
376                 src++;
377                 state = 1;
378             }
379             break;
380         }
381     if(state > 0)
382         *res++ = '%';
383     if(state > 1)
384         *res++ = *(src - 1);
385     *res = '\0';
386     return res - kp_res;
387 }
388
389 /*
390  * Parse a header
391  * return a code and possibly content in the arg
392  */
393 int
394 check_header(const char *header, char *const content)
395 {
396     regmatch_t  matches[4];
397     static struct {
398         char    header[32];
399         int     len;
400         int     val;
401     } hd_types[] = {
402         { "Transfer-encoding",  17, HEADER_TRANSFER_ENCODING },
403         { "Content-length",     14, HEADER_CONTENT_LENGTH },
404         { "Connection",         10, HEADER_CONNECTION },
405         { "Location",           8,  HEADER_LOCATION },
406         { "Content-location",   16, HEADER_CONTLOCATION },
407         { "Host",               4,  HEADER_HOST },
408         { "Referer",            7,  HEADER_REFERER },
409         { "User-agent",         10, HEADER_USER_AGENT },
410         { "Destination",        11, HEADER_DESTINATION },
411         { "Expect",             6,  HEADER_EXPECT },
412         { "",                   0,  HEADER_OTHER },
413     };
414     int i;
415
416     if(!regexec(&HEADER, header, 4, matches, 0)) {
417         for(i = 0; hd_types[i].len > 0; i++)
418             if((matches[1].rm_eo - matches[1].rm_so) == hd_types[i].len
419             && strncasecmp(header + matches[1].rm_so, hd_types[i].header, hd_types[i].len) == 0) {
420                 /* we know that the original header was read into a buffer of size MAXBUF, so no overflow */
421                 strncpy(content, header + matches[2].rm_so, matches[2].rm_eo - matches[2].rm_so);
422                 content[matches[2].rm_eo - matches[2].rm_so] = '\0';
423                 return hd_types[i].val;
424             }
425         return HEADER_OTHER;
426     } else if(header[0] == ' ' || header[0] == '\t') {
427         *content = '\0';
428         return HEADER_OTHER;
429     } else
430         return HEADER_ILLEGAL;
431 }
432
433 static int
434 match_service(const SERVICE *svc, const char *request, char **const headers)
435 {
436     MATCHER *m;
437     int     i, found;
438
439     /* check for request */
440     for(m = svc->url; m; m = m->next)
441         if(regexec(&m->pat, request, 0, NULL, 0))
442             return 0;
443
444     /* check for required headers */
445     for(m = svc->req_head; m; m = m->next) {
446         for(found = i = 0; i < (MAXHEADERS - 1) && !found; i++)
447             if(headers[i] && !regexec(&m->pat, headers[i], 0, NULL, 0))
448                 found = 1;
449         if(!found)
450             return 0;
451     }
452
453     /* check for forbidden headers */
454     for(m = svc->deny_head; m; m = m->next) {
455         for(found = i = 0; i < (MAXHEADERS - 1) && !found; i++)
456             if(headers[i] && !regexec(&m->pat, headers[i], 0, NULL, 0))
457                 found = 1;
458         if(found)
459             return 0;
460     }
461
462     return 1;
463 }
464
465 /*
466  * Find the right service for a request
467  */
468 SERVICE *
469 get_service(const LISTENER *lstn, const char *request, char **const headers)
470 {
471     SERVICE *svc;
472
473     for(svc = lstn->services; svc; svc = svc->next) {
474         if(svc->disabled)
475             continue;
476         if(match_service(svc, request, headers))
477             return svc;
478     }
479
480     /* try global services */
481     for(svc = services; svc; svc = svc->next) {
482         if(svc->disabled)
483             continue;
484         if(match_service(svc, request, headers))
485             return svc;
486     }
487
488     /* nothing matched */
489     return NULL;
490 }
491
492 /*
493  * extract the session key for a given request
494  */
495 static int
496 get_REQUEST(char *res, const SERVICE *svc, const char *request)
497 {
498     int         n, s;
499     regmatch_t  matches[4];
500
501     if(regexec(&svc->sess_start, request, 4, matches, 0)) {
502         res[0] = '\0';
503         return 0;
504     }
505     s = matches[0].rm_eo;
506     if(regexec(&svc->sess_pat, request + s, 4, matches, 0)) {
507         res[0] = '\0';
508         return 0;
509     }
510     if((n = matches[1].rm_eo - matches[1].rm_so) > KEY_SIZE)
511         n = KEY_SIZE;
512     strncpy(res, request + s + matches[1].rm_so, n);
513     res[n] = '\0';
514     return 1;
515 }
516
517 static int
518 get_HEADERS(char *res, const SERVICE *svc, char **const headers)
519 {
520     int         i, n, s;
521     regmatch_t  matches[4];
522
523     /* this will match SESS_COOKIE, SESS_HEADER and SESS_BASIC */
524     res[0] = '\0';
525     for(i = 0; i < (MAXHEADERS - 1); i++) {
526         if(headers[i] == NULL)
527             continue;
528         if(regexec(&svc->sess_start, headers[i], 4, matches, 0))
529             continue;
530         s = matches[0].rm_eo;
531         if(regexec(&svc->sess_pat, headers[i] + s, 4, matches, 0))
532             continue;
533         if((n = matches[1].rm_eo - matches[1].rm_so) > KEY_SIZE)
534             n = KEY_SIZE;
535         strncpy(res, headers[i] + s + matches[1].rm_so, n);
536         res[n] = '\0';
537     }
538     return res[0] != '\0';
539 }
540
541 /*
542  * Pick a random back-end from a candidate list
543  */
544 static BACKEND *
545 rand_backend(BACKEND *be, int pri)
546 {
547     while(be) {
548         if(!be->alive || be->disabled) {
549             be = be->next;
550             continue;
551         }
552         if((pri -= be->priority) < 0)
553             break;
554         be = be->next;
555     }
556     return be;
557 }
558
559 /*
560  * return a back-end based on a fixed hash value
561  * this is used for session_ttl < 0
562  *
563  * WARNING: the function may return different back-ends
564  * if the target back-end is disabled or not alive
565  */
566 static BACKEND *
567 hash_backend(BACKEND *be, int abs_pri, char *key)
568 {
569     unsigned long   hv;
570     BACKEND         *res, *tb;
571     int             pri;
572
573     hv = 2166136261;
574     while(*key)
575         hv = ((hv ^ *key++) * 16777619) & 0xFFFFFFFF;
576     pri = hv % abs_pri;
577     for(tb = be; tb; tb = tb->next)
578         if((pri -= tb->priority) < 0)
579             break;
580     if(!tb)
581         /* should NEVER happen */
582         return NULL;
583     for(res = tb; !res->alive || res->disabled; ) {
584         res = res->next;
585         if(res == NULL)
586             res = be;
587         if(res == tb)
588             /* NO back-end available */
589             return NULL;
590     }
591     return res;
592 }
593
594 /*
595  * Find the right back-end for a request
596  */
597 BACKEND *
598 get_backend(SERVICE *const svc, const struct addrinfo *from_host, const char *request, char **const headers)
599 {
600     BACKEND     *res;
601     char        key[KEY_SIZE + 1];
602     int         ret_val, no_be;
603     void        *vp;
604
605     if(ret_val = pthread_mutex_lock(&svc->mut))
606         logmsg(LOG_WARNING, "get_backend() lock: %s", strerror(ret_val));
607
608     no_be = (svc->tot_pri <= 0);
609
610     switch(svc->sess_type) {
611     case SESS_NONE:
612         /* choose one back-end randomly */
613         res = no_be? svc->emergency: rand_backend(svc->backends, random() % svc->tot_pri);
614         break;
615     case SESS_IP:
616         addr2str(key, KEY_SIZE, from_host, 1);
617         if(svc->sess_ttl < 0)
618             res = no_be? svc->emergency: hash_backend(svc->backends, svc->abs_pri, key);
619         else if((vp = t_find(svc->sessions, key)) == NULL) {
620             if(no_be)
621                 res = svc->emergency;
622             else {
623                 /* no session yet - create one */
624                 res = rand_backend(svc->backends, random() % svc->tot_pri);
625                 t_add(svc->sessions, key, &res, sizeof(res));
626             }
627         } else
628             memcpy(&res, vp, sizeof(res));
629         break;
630     case SESS_URL:
631     case SESS_PARM:
632         if(get_REQUEST(key, svc, request)) {
633             if(svc->sess_ttl < 0)
634                 res = no_be? svc->emergency: hash_backend(svc->backends, svc->abs_pri, key);
635             else if((vp = t_find(svc->sessions, key)) == NULL) {
636                 if(no_be)
637                     res = svc->emergency;
638                 else {
639                     /* no session yet - create one */
640                     res = rand_backend(svc->backends, random() % svc->tot_pri);
641                     t_add(svc->sessions, key, &res, sizeof(res));
642                 }
643             } else
644                 memcpy(&res, vp, sizeof(res));
645         } else {
646             res = no_be? svc->emergency: rand_backend(svc->backends, random() % svc->tot_pri);
647         }
648         break;
649     default:
650         /* this works for SESS_BASIC, SESS_HEADER and SESS_COOKIE */
651         if(get_HEADERS(key, svc, headers)) {
652             if(svc->sess_ttl < 0)
653                 res = no_be? svc->emergency: hash_backend(svc->backends, svc->abs_pri, key);
654             else if((vp = t_find(svc->sessions, key)) == NULL) {
655                 if(no_be)
656                     res = svc->emergency;
657                 else {
658                     /* no session yet - create one */
659                     res = rand_backend(svc->backends, random() % svc->tot_pri);
660                     t_add(svc->sessions, key, &res, sizeof(res));
661                 }
662             } else
663                 memcpy(&res, vp, sizeof(res));
664         } else {
665             res = no_be? svc->emergency: rand_backend(svc->backends, random() % svc->tot_pri);
666         }
667         break;
668     }
669     if(ret_val = pthread_mutex_unlock(&svc->mut))
670         logmsg(LOG_WARNING, "get_backend() unlock: %s", strerror(ret_val));
671
672     return res;
673 }
674
675 /*
676  * (for cookies/header only) possibly create session based on response headers
677  */
678 void
679 upd_session(SERVICE *const svc, char **const headers, BACKEND *const be)
680 {
681     char            key[KEY_SIZE + 1];
682     int             ret_val;
683
684     if(svc->sess_type != SESS_HEADER && svc->sess_type != SESS_COOKIE)
685         return;
686     if(ret_val = pthread_mutex_lock(&svc->mut))
687         logmsg(LOG_WARNING, "upd_session() lock: %s", strerror(ret_val));
688     if(get_HEADERS(key, svc, headers))
689         if(t_find(svc->sessions, key) == NULL)
690             t_add(svc->sessions, key, &be, sizeof(be));
691     if(ret_val = pthread_mutex_unlock(&svc->mut))
692         logmsg(LOG_WARNING, "upd_session() unlock: %s", strerror(ret_val));
693     return;
694 }
695
696 /*
697  * mark a backend host as dead/disabled; remove its sessions if necessary
698  *  disable_only == 1:  mark as disabled
699  *  disable_only == 0:  mark as dead, remove sessions
700  *  disable_only == -1:  mark as enabled
701  */
702 void
703 kill_be(SERVICE *const svc, const BACKEND *be, const int disable_mode)
704 {
705     BACKEND *b;
706     int     ret_val;
707     char    buf[MAXBUF];
708
709     if(ret_val = pthread_mutex_lock(&svc->mut))
710         logmsg(LOG_WARNING, "kill_be() lock: %s", strerror(ret_val));
711     svc->tot_pri = 0;
712     for(b = svc->backends; b; b = b->next) {
713         if(b == be)
714             switch(disable_mode) {
715             case BE_DISABLE:
716                 b->disabled = 1;
717                 str_be(buf, MAXBUF - 1, b);
718                 logmsg(LOG_NOTICE, "(%lx) BackEnd %s disabled", pthread_self(), buf);
719                 break;
720             case BE_KILL:
721                 b->alive = 0;
722                 str_be(buf, MAXBUF - 1, b);
723                 logmsg(LOG_NOTICE, "(%lx) BackEnd %s dead (killed)", pthread_self(), buf);
724                 t_clean(svc->sessions, &be, sizeof(be));
725                 break;
726             case BE_ENABLE:
727                 str_be(buf, MAXBUF - 1, b);
728                 logmsg(LOG_NOTICE, "(%lx) BackEnd %s enabled", pthread_self(), buf);
729                 b->disabled = 0;
730                 break;
731             default:
732                 logmsg(LOG_WARNING, "kill_be(): unknown mode %d", disable_mode);
733                 break;
734             }
735         if(b->alive && !b->disabled)
736             svc->tot_pri += b->priority;
737     }
738     if(ret_val = pthread_mutex_unlock(&svc->mut))
739         logmsg(LOG_WARNING, "kill_be() unlock: %s", strerror(ret_val));
740     return;
741 }
742
743 /*
744  * Update the number of requests and time to answer for a given back-end
745  */
746 void
747 upd_be(SERVICE *const svc, BACKEND *const be, const double elapsed)
748 {
749     int     ret_val;
750
751     if(svc->dynscale) {
752         if(ret_val = pthread_mutex_lock(&be->mut))
753             logmsg(LOG_WARNING, "upd_be() lock: %s", strerror(ret_val));
754         be->t_requests += elapsed;
755         if(++be->n_requests > RESCALE_MAX) {
756             /* scale it down */
757             be->n_requests /= 2;
758             be->t_requests /= 2;
759         }
760         be->t_average = be->t_requests / be->n_requests;
761         if(ret_val = pthread_mutex_unlock(&be->mut))
762             logmsg(LOG_WARNING, "upd_be() unlock: %s", strerror(ret_val));
763     }
764     return;
765 }
766
767 /*
768  * Search for a host name, return the addrinfo for it
769  */
770 int
771 get_host(char *const name, struct addrinfo *res, int ai_family)
772 {
773     struct addrinfo *chain, *ap;
774     struct addrinfo hints;
775     int             ret_val;
776
777 #ifdef  HAVE_INET_NTOP
778     memset (&hints, 0, sizeof(hints));
779     hints.ai_family = ai_family;
780     hints.ai_socktype = SOCK_STREAM;
781     hints.ai_flags = AI_CANONNAME;
782     if((ret_val = getaddrinfo(name, NULL, &hints, &chain)) == 0) {
783 #ifdef _AIX
784         ap = chain;
785 #else
786         for(ap = chain; ap != NULL; ap = ap->ai_next)
787             if(ap->ai_socktype == SOCK_STREAM)
788                 break;
789 #endif
790         if(ap == NULL) {
791             freeaddrinfo(chain);
792             return EAI_NONAME;
793         }
794         *res = *ap;
795         if((res->ai_addr = (struct sockaddr *)malloc(ap->ai_addrlen)) == NULL) {
796             freeaddrinfo(chain);
797             return EAI_MEMORY;
798         }
799         memcpy(res->ai_addr, ap->ai_addr, ap->ai_addrlen);
800         freeaddrinfo(chain);
801     }
802 #else
803 #error  "Pound requires getaddrinfo()"
804 #endif
805     return ret_val;
806 }
807
808 /*
809  * Find if a redirect needs rewriting
810  * In general we have two possibilities that require it:
811  * (1) if the redirect was done to the correct location with the wrong port
812  * (2) if the redirect was done to the back-end rather than the listener
813  */
814 int
815 need_rewrite(const int rewr_loc, char *const location, char *const path, const char *v_host, const LISTENER *lstn, const BACKEND *be)
816 {
817     struct addrinfo         addr;
818     struct sockaddr_in      in_addr, be_addr;
819     struct sockaddr_in6     in6_addr, be6_addr;
820     regmatch_t              matches[4];
821     char                    *proto, *host, *port, *cp, buf[MAXBUF];
822
823     /* check if rewriting is required at all */
824     if(rewr_loc == 0)
825         return 0;
826
827     /* applies only to INET/INET6 back-ends */
828     if(be->addr.ai_family != AF_INET && be->addr.ai_family != AF_INET6)
829         return 0;
830
831     /* split the location into its fields */
832     if(regexec(&LOCATION, location, 4, matches, 0))
833         return 0;
834     proto = location + matches[1].rm_so;
835     host = location + matches[2].rm_so;
836     if(location[matches[3].rm_so] == '/')
837         matches[3].rm_so++;
838     /* path is guaranteed to be large enough */
839     strcpy(path, location + matches[3].rm_so);
840     location[matches[1].rm_eo] = location[matches[2].rm_eo] = '\0';
841     if((port = strchr(host, ':')) != NULL)
842         *port++ = '\0';
843
844     /*
845      * Check if the location has the same address as the listener or the back-end
846      */
847     memset(&addr, 0, sizeof(addr));
848     if(get_host(host, &addr, be->addr.ai_family))
849         return 0;
850
851     /*
852      * compare the back-end
853      */
854     if(addr.ai_family != be->addr.ai_family) {
855         free(addr.ai_addr);
856         return 0;
857     }
858     if(addr.ai_family == AF_INET) {
859         memcpy(&in_addr, addr.ai_addr, sizeof(in_addr));
860         memcpy(&be_addr, be->addr.ai_addr, sizeof(be_addr));
861         if(port)
862             in_addr.sin_port = (in_port_t)htons(atoi(port));
863         else if(!strcasecmp(proto, "https"))
864             in_addr.sin_port = (in_port_t)htons(443);
865         else
866             in_addr.sin_port = (in_port_t)htons(80);
867         /*
868          * check if the Location points to the back-end
869          */
870         if(memcmp(&be_addr.sin_addr.s_addr, &in_addr.sin_addr.s_addr, sizeof(in_addr.sin_addr.s_addr)) == 0
871         && memcmp(&be_addr.sin_port, &in_addr.sin_port, sizeof(in_addr.sin_port)) == 0) {
872             free(addr.ai_addr);
873             return 1;
874         }
875     } else /* AF_INET6 */ {
876         memcpy(&in6_addr, addr.ai_addr, sizeof(in6_addr));
877         memcpy(&be6_addr, be->addr.ai_addr, sizeof(be6_addr));
878         if(port)
879             in6_addr.sin6_port = (in_port_t)htons(atoi(port));
880         else if(!strcasecmp(proto, "https"))
881             in6_addr.sin6_port = (in_port_t)htons(443);
882         else
883             in6_addr.sin6_port = (in_port_t)htons(80);
884         /*
885          * check if the Location points to the back-end
886          */
887         if(memcmp(&be6_addr.sin6_addr.s6_addr, &in6_addr.sin6_addr.s6_addr, sizeof(in6_addr.sin6_addr.s6_addr)) == 0
888         && memcmp(&be6_addr.sin6_port, &in6_addr.sin6_port, sizeof(in6_addr.sin6_port)) == 0) {
889             free(addr.ai_addr);
890             return 1;
891         }
892     }
893
894     /*
895      * compare the listener
896      */
897     if(rewr_loc != 1 || addr.ai_family != lstn->addr.ai_family) {
898         free(addr.ai_addr);
899         return 0;
900     }
901     memset(buf, '\0', MAXBUF);
902     strncpy(buf, v_host, MAXBUF - 1);
903     if((cp = strchr(buf, ':')) != NULL)
904         *cp = '\0';
905     if(addr.ai_family == AF_INET) {
906         memcpy(&be_addr, lstn->addr.ai_addr, sizeof(be_addr));
907         /*
908          * check if the Location points to the Listener but with the wrong port or protocol
909          */
910         if((memcmp(&be_addr.sin_addr.s_addr, &in_addr.sin_addr.s_addr, sizeof(in_addr.sin_addr.s_addr)) == 0
911           || strcasecmp(host, buf) == 0)
912         && (memcmp(&be_addr.sin_port, &in_addr.sin_port, sizeof(in_addr.sin_port)) != 0
913             || strcasecmp(proto, lstn->ctx? "http": "https"))) {
914             free(addr.ai_addr);
915             return 1;
916         }
917     } else {
918         memcpy(&be6_addr, lstn->addr.ai_addr, sizeof(be6_addr));
919         /*
920          * check if the Location points to the Listener but with the wrong port or protocol
921          */
922         if((memcmp(&be6_addr.sin6_addr.s6_addr, &in6_addr.sin6_addr.s6_addr, sizeof(in6_addr.sin6_addr.s6_addr)) == 0
923           || strcasecmp(host, buf) == 0)
924         && (memcmp(&be6_addr.sin6_port, &in6_addr.sin6_port, sizeof(in6_addr.sin6_port)) != 0
925             || strcasecmp(proto, lstn->ctx? "http": "https"))) {
926             free(addr.ai_addr);
927             return 1;
928         }
929     }
930
931     free(addr.ai_addr);
932     return 0;
933 }
934
935 /*
936  * Non-blocking connect(). Does the same as connect(2) but ensures
937  * it will time-out after a much shorter time period SERVER_TO
938  */
939 int
940 connect_nb(const int sockfd, const struct addrinfo *serv_addr, const int to)
941 {
942     int             flags, res, error;
943     socklen_t       len;
944     struct pollfd   p;
945
946     if((flags = fcntl(sockfd, F_GETFL, 0)) < 0) {
947         logmsg(LOG_WARNING, "(%lx) connect_nb: fcntl GETFL failed: %s", pthread_self(), strerror(errno));
948         return -1;
949     }
950     if(fcntl(sockfd, F_SETFL, flags | O_NONBLOCK) < 0) {
951         logmsg(LOG_WARNING, "(%lx) connect_nb: fcntl SETFL failed: %s", pthread_self(), strerror(errno));
952         return -1;
953     }
954
955     error = 0;
956     if((res = connect(sockfd, serv_addr->ai_addr, serv_addr->ai_addrlen)) < 0)
957         if(errno != EINPROGRESS) {
958             logmsg(LOG_WARNING, "(%lx) connect_nb: connect failed: %s", pthread_self(), strerror(errno));
959             return (-1);
960         }
961
962     if(res == 0) {
963         /* connect completed immediately (usually localhost) */
964         if(fcntl(sockfd, F_SETFL, flags) < 0) {
965             logmsg(LOG_WARNING, "(%lx) connect_nb: fcntl reSETFL failed: %s", pthread_self(), strerror(errno));
966             return -1;
967         }
968         return 0;
969     }
970
971     memset(&p, 0, sizeof(p));
972     p.fd = sockfd;
973     p.events = POLLOUT;
974     if((res = poll(&p, 1, to * 1000)) != 1) {
975         if(res == 0) {
976             /* timeout */
977             logmsg(LOG_WARNING, "(%lx) connect_nb: poll timed out", pthread_self());
978             errno = ETIMEDOUT;
979         } else
980             logmsg(LOG_WARNING, "(%lx) connect_nb: poll failed: %s", pthread_self(), strerror(errno));
981         return -1;
982     }
983
984     /* socket is writeable == operation completed */
985     len = sizeof(error);
986     if(getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
987         logmsg(LOG_WARNING, "(%lx) connect_nb: getsockopt failed: %s", pthread_self(), strerror(errno));
988         return -1;
989     }
990
991     /* restore file status flags */
992     if(fcntl(sockfd, F_SETFL, flags) < 0) {
993         logmsg(LOG_WARNING, "(%lx) connect_nb: fcntl reSETFL failed: %s", pthread_self(), strerror(errno));
994         return -1;
995     }
996
997     if(error) {
998         /* getsockopt() shows an error */
999         errno = error;
1000         logmsg(LOG_WARNING, "(%lx) connect_nb: error after getsockopt: %s", pthread_self(), strerror(errno));
1001         return -1;
1002     }
1003
1004     /* really connected */
1005     return 0;
1006 }
1007
1008 /*
1009  * Check if dead hosts returned to life;
1010  * runs every alive seconds
1011  */
1012 static void
1013 do_resurect(void)
1014 {
1015     LISTENER    *lstn;
1016     SERVICE     *svc;
1017     BACKEND     *be;
1018     struct      addrinfo    z_addr, *addr;
1019     int         sock, modified;
1020     char        buf[MAXBUF];
1021     int         ret_val;
1022
1023     /* check hosts still alive - HAport */
1024     memset(&z_addr, 0, sizeof(z_addr));
1025     for(lstn = listeners; lstn; lstn = lstn->next)
1026     for(svc = lstn->services; svc; svc = svc->next)
1027     for(be = svc->backends; be; be = be->next) {
1028         if(be->be_type)
1029             continue;
1030         if(!be->alive)
1031             /* already dead */
1032             continue;
1033         if(memcmp(&(be->ha_addr), &z_addr, sizeof(z_addr)) == 0)
1034             /* no HA port */
1035             continue;
1036         /* try connecting */
1037         switch(be->ha_addr.ai_family) {
1038         case AF_INET:
1039             if((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0)
1040                 continue;
1041             break;
1042         case AF_INET6:
1043             if((sock = socket(PF_INET6, SOCK_STREAM, 0)) < 0)
1044                 continue;
1045             break;
1046         case AF_UNIX:
1047             if((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
1048                 continue;
1049             break;
1050         default:
1051             continue;
1052         }
1053         if(connect_nb(sock, &be->ha_addr, be->conn_to) != 0) {
1054             kill_be(svc, be, BE_KILL);
1055             str_be(buf, MAXBUF - 1, be);
1056             logmsg(LOG_NOTICE, "BackEnd %s is dead (HA)", buf);
1057         }
1058         shutdown(sock, 2);
1059         close(sock);
1060     }
1061
1062     for(svc = services; svc; svc = svc->next)
1063     for(be = svc->backends; be; be = be->next) {
1064         if(be->be_type)
1065             continue;
1066         if(!be->alive)
1067             /* already dead */
1068             continue;
1069         if(memcmp(&(be->ha_addr), &z_addr, sizeof(z_addr)) == 0)
1070             /* no HA port */
1071             continue;
1072         /* try connecting */
1073         switch(be->ha_addr.ai_family) {
1074         case AF_INET:
1075             if((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0)
1076                 continue;
1077             break;
1078         case AF_INET6:
1079             if((sock = socket(PF_INET6, SOCK_STREAM, 0)) < 0)
1080                 continue;
1081             break;
1082         case AF_UNIX:
1083             if((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
1084                 continue;
1085             break;
1086         default:
1087             continue;
1088         }
1089         if(connect_nb(sock, &be->ha_addr, be->conn_to) != 0) {
1090             kill_be(svc, be, BE_KILL);
1091             str_be(buf, MAXBUF - 1, be);
1092             logmsg(LOG_NOTICE, "BackEnd %s is dead (HA)", buf);
1093         }
1094         shutdown(sock, 2);
1095         close(sock);
1096     }
1097
1098     /* check hosts alive again */
1099     for(lstn = listeners; lstn; lstn = lstn->next)
1100     for(svc = lstn->services; svc; svc = svc->next) {
1101         for(modified = 0, be = svc->backends; be; be = be->next) {
1102             be->resurrect = 0;
1103             if(be->be_type)
1104                 continue;
1105             if(be->alive)
1106                 continue;
1107             if(memcmp(&(be->ha_addr), &z_addr, sizeof(z_addr)) == 0) {
1108                 switch(be->addr.ai_family) {
1109                 case AF_INET:
1110                     if((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0)
1111                         continue;
1112                     break;
1113                 case AF_INET6:
1114                     if((sock = socket(PF_INET6, SOCK_STREAM, 0)) < 0)
1115                         continue;
1116                     break;
1117                 case AF_UNIX:
1118                     if((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
1119                         continue;
1120                     break;
1121                 default:
1122                     continue;
1123                 }
1124                 addr = &be->addr;
1125             } else {
1126                 switch(be->ha_addr.ai_family) {
1127                 case AF_INET:
1128                     if((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0)
1129                         continue;
1130                     break;
1131                 case AF_INET6:
1132                     if((sock = socket(PF_INET6, SOCK_STREAM, 0)) < 0)
1133                         continue;
1134                     break;
1135                 case AF_UNIX:
1136                     if((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
1137                         continue;
1138                     break;
1139                 default:
1140                     continue;
1141                 }
1142                 addr = &be->ha_addr;
1143             }
1144             if(connect_nb(sock, addr, be->conn_to) == 0) {
1145                 be->resurrect = 1;
1146                 modified = 1;
1147             }
1148             shutdown(sock, 2);
1149             close(sock);
1150         }
1151         if(modified) {
1152             if(ret_val = pthread_mutex_lock(&svc->mut))
1153                 logmsg(LOG_WARNING, "do_resurect() lock: %s", strerror(ret_val));
1154             svc->tot_pri = 0;
1155             for(be = svc->backends; be; be = be->next) {
1156                 if(be->resurrect) {
1157                     be->alive = 1;
1158                     str_be(buf, MAXBUF - 1, be);
1159                     logmsg(LOG_NOTICE, "BackEnd %s resurrect", buf);
1160                 }
1161                 if(be->alive && !be->disabled)
1162                     svc->tot_pri += be->priority;
1163             }
1164             if(ret_val = pthread_mutex_unlock(&svc->mut))
1165                 logmsg(LOG_WARNING, "do_resurect() unlock: %s", strerror(ret_val));
1166         }
1167     }
1168
1169     for(svc = services; svc; svc = svc->next) {
1170         for(modified = 0, be = svc->backends; be; be = be->next) {
1171             be->resurrect = 0;
1172             if(be->be_type)
1173                 continue;
1174             if(be->alive)
1175                 continue;
1176             if(memcmp(&(be->ha_addr), &z_addr, sizeof(z_addr)) == 0) {
1177                 switch(be->addr.ai_family) {
1178                 case AF_INET:
1179                     if((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0)
1180                         continue;
1181                     break;
1182                 case AF_INET6:
1183                     if((sock = socket(PF_INET6, SOCK_STREAM, 0)) < 0)
1184                         continue;
1185                     break;
1186                 case AF_UNIX:
1187                     if((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
1188                         continue;
1189                     break;
1190                 default:
1191                     continue;
1192                 }
1193                 addr = &be->addr;
1194             } else {
1195                 switch(be->ha_addr.ai_family) {
1196                 case AF_INET:
1197                     if((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0)
1198                         continue;
1199                     break;
1200                 case AF_INET6:
1201                     if((sock = socket(PF_INET6, SOCK_STREAM, 0)) < 0)
1202                         continue;
1203                     break;
1204                 case AF_UNIX:
1205                     if((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
1206                         continue;
1207                     break;
1208                 default:
1209                     continue;
1210                 }
1211                 addr = &be->ha_addr;
1212             }
1213             if(connect_nb(sock, addr, be->conn_to) == 0) {
1214                 be->resurrect = 1;
1215                 modified = 1;
1216             }
1217             shutdown(sock, 2);
1218             close(sock);
1219         }
1220         if(modified) {
1221             if(ret_val = pthread_mutex_lock(&svc->mut))
1222                 logmsg(LOG_WARNING, "do_resurect() lock: %s", strerror(ret_val));
1223             svc->tot_pri = 0;
1224             for(be = svc->backends; be; be = be->next) {
1225                 if(be->resurrect) {
1226                     be->alive = 1;
1227                     str_be(buf, MAXBUF - 1, be);
1228                     logmsg(LOG_NOTICE, "BackEnd %s resurrect", buf);
1229                 }
1230                 if(be->alive && !be->disabled)
1231                     svc->tot_pri += be->priority;
1232             }
1233             if(ret_val = pthread_mutex_unlock(&svc->mut))
1234                 logmsg(LOG_WARNING, "do_resurect() unlock: %s", strerror(ret_val));
1235         }
1236     }
1237
1238     return;
1239 }
1240
1241 /*
1242  * Remove expired sessions
1243  * runs every EXPIRE_TO seconds
1244  */
1245 static void
1246 do_expire(void)
1247 {
1248     LISTENER    *lstn;
1249     SERVICE     *svc;
1250     time_t      cur_time;
1251     int         ret_val;
1252
1253     /* remove stale sessions */
1254     cur_time = time(NULL);
1255
1256     for(lstn = listeners; lstn; lstn = lstn->next)
1257     for(svc = lstn->services; svc; svc = svc->next)
1258         if(svc->sess_type != SESS_NONE) {
1259             if(ret_val = pthread_mutex_lock(&svc->mut)) {
1260                 logmsg(LOG_WARNING, "do_expire() lock: %s", strerror(ret_val));
1261                 continue;
1262             }
1263             t_expire(svc->sessions, cur_time - svc->sess_ttl);
1264             if(ret_val = pthread_mutex_unlock(&svc->mut))
1265                 logmsg(LOG_WARNING, "do_expire() unlock: %s", strerror(ret_val));
1266         }
1267
1268     for(svc = services; svc; svc = svc->next)
1269         if(svc->sess_type != SESS_NONE) {
1270             if(ret_val = pthread_mutex_lock(&svc->mut)) {
1271                 logmsg(LOG_WARNING, "do_expire() lock: %s", strerror(ret_val));
1272                 continue;
1273             }
1274             t_expire(svc->sessions, cur_time - svc->sess_ttl);
1275             if(ret_val = pthread_mutex_unlock(&svc->mut))
1276                 logmsg(LOG_WARNING, "do_expire() unlock: %s", strerror(ret_val));
1277         }
1278
1279     return;
1280 }
1281
1282 /*
1283  * Rescale back-end priorities if needed
1284  * runs every 5 minutes
1285  */
1286 static void
1287 do_rescale(void)
1288 {
1289     LISTENER    *lstn;
1290     SERVICE     *svc;
1291     BACKEND     *be;
1292     int         n, ret_val;
1293     double      average, sq_average;
1294
1295     /* scale the back-end priorities */
1296     for(lstn = listeners; lstn; lstn = lstn->next)
1297     for(svc = lstn->services; svc; svc = svc->next) {
1298         if(!svc->dynscale)
1299             continue;
1300         average = sq_average = 0.0;
1301         n = 0;
1302         for(be = svc->backends; be; be = be->next) {
1303             if(be->be_type || !be->alive || be->disabled)
1304                 continue;
1305             if(ret_val = pthread_mutex_lock(&be->mut))
1306                 logmsg(LOG_WARNING, "do_rescale() lock: %s", strerror(ret_val));
1307             average += be->t_average;
1308             sq_average += be->t_average * be->t_average;
1309             if(ret_val = pthread_mutex_unlock(&be->mut))
1310                 logmsg(LOG_WARNING, "do_rescale() unlock: %s", strerror(ret_val));
1311             n++;
1312         }
1313         if(n <= 1)
1314             continue;
1315         sq_average /= n;
1316         average /= n;
1317         sq_average = sqrt(sq_average - average * average);  /* this is now the standard deviation */
1318         sq_average *= 3;    /* we only want things outside of 3 standard deviations */
1319         if(ret_val = pthread_mutex_lock(&svc->mut)) {
1320             logmsg(LOG_WARNING, "thr_rescale() lock: %s", strerror(ret_val));
1321             continue;
1322         }
1323         for(be = svc->backends; be; be = be->next) {
1324             if(be->be_type || !be->alive || be->disabled || be->n_requests < RESCALE_MIN)
1325                 continue;
1326             if(be->t_average < (average - sq_average)) {
1327                 be->priority++;
1328                 if(ret_val = pthread_mutex_lock(&be->mut))
1329                     logmsg(LOG_WARNING, "do_rescale() lock: %s", strerror(ret_val));
1330                 while(be->n_requests > RESCALE_BOT) {
1331                     be->n_requests /= 2;
1332                     be->t_requests /= 2;
1333                 }
1334                 if(ret_val = pthread_mutex_unlock(&be->mut))
1335                     logmsg(LOG_WARNING, "do_rescale() unlock: %s", strerror(ret_val));
1336                 svc->tot_pri++;
1337             }
1338             if(be->t_average > (average + sq_average) && be->priority > 1) {
1339                 be->priority--;
1340                 if(ret_val = pthread_mutex_lock(&be->mut))
1341                     logmsg(LOG_WARNING, "do_rescale() lock: %s", strerror(ret_val));
1342                 while(be->n_requests > RESCALE_BOT) {
1343                     be->n_requests /= 2;
1344                     be->t_requests /= 2;
1345                 }
1346                 if(ret_val = pthread_mutex_unlock(&be->mut))
1347                     logmsg(LOG_WARNING, "do_rescale() unlock: %s", strerror(ret_val));
1348                 svc->tot_pri--;
1349             }
1350         }
1351         if(ret_val = pthread_mutex_unlock(&svc->mut))
1352             logmsg(LOG_WARNING, "thr_rescale() unlock: %s", strerror(ret_val));
1353     }
1354
1355     for(svc = services; svc; svc = svc->next) {
1356         if(!svc->dynscale)
1357             continue;
1358         average = sq_average = 0.0;
1359         n = 0;
1360         for(be = svc->backends; be; be = be->next) {
1361             if(be->be_type || !be->alive || be->disabled)
1362                 continue;
1363             if(ret_val = pthread_mutex_lock(&be->mut))
1364                 logmsg(LOG_WARNING, "do_rescale() lock: %s", strerror(ret_val));
1365             average += be->t_average;
1366             sq_average += be->t_average * be->t_average;
1367             if(ret_val = pthread_mutex_unlock(&be->mut))
1368                 logmsg(LOG_WARNING, "do_rescale() unlock: %s", strerror(ret_val));
1369             n++;
1370         }
1371         if(n <= 1)
1372             continue;
1373         sq_average /= n;
1374         average /= n;
1375         sq_average = sqrt(sq_average - average * average);  /* this is now the standard deviation */
1376         sq_average *= 3;    /* we only want things outside of 3 standard deviations */
1377         if(ret_val = pthread_mutex_lock(&svc->mut)) {
1378             logmsg(LOG_WARNING, "thr_rescale() lock: %s", strerror(ret_val));
1379             continue;
1380         }
1381         for(be = svc->backends; be; be = be->next) {
1382             if(be->be_type || !be->alive || be->disabled || be->n_requests < RESCALE_MIN)
1383                 continue;
1384             if(be->t_average < (average - sq_average)) {
1385                 be->priority++;
1386                 if(ret_val = pthread_mutex_lock(&be->mut))
1387                     logmsg(LOG_WARNING, "do_rescale() lock: %s", strerror(ret_val));
1388                 while(be->n_requests > RESCALE_BOT) {
1389                     be->n_requests /= 2;
1390                     be->t_requests /= 2;
1391                 }
1392                 if(ret_val = pthread_mutex_unlock(&be->mut))
1393                     logmsg(LOG_WARNING, "do_rescale() unlock: %s", strerror(ret_val));
1394                 svc->tot_pri++;
1395             }
1396             if(be->t_average > (average + sq_average) && be->priority > 1) {
1397                 be->priority--;
1398                 if(ret_val = pthread_mutex_lock(&be->mut))
1399                     logmsg(LOG_WARNING, "do_rescale() lock: %s", strerror(ret_val));
1400                 while(be->n_requests > RESCALE_BOT) {
1401                     be->n_requests /= 2;
1402                     be->t_requests /= 2;
1403                 }
1404                 if(ret_val = pthread_mutex_unlock(&be->mut))
1405                     logmsg(LOG_WARNING, "do_rescale() unlock: %s", strerror(ret_val));
1406                 svc->tot_pri--;
1407             }
1408         }
1409         if(ret_val = pthread_mutex_unlock(&svc->mut))
1410             logmsg(LOG_WARNING, "thr_rescale() unlock: %s", strerror(ret_val));
1411     }
1412
1413     return;
1414 }
1415
1416 static pthread_mutex_t  RSA_mut;                    /* mutex for RSA keygen */
1417 static RSA              *RSA512_keys[N_RSA_KEYS];   /* ephemeral RSA keys */
1418 static RSA              *RSA1024_keys[N_RSA_KEYS];  /* ephemeral RSA keys */
1419
1420 /*
1421  * return a pre-generated RSA key
1422  */
1423 RSA *
1424 RSA_tmp_callback(/* not used */SSL *ssl, /* not used */int is_export, int keylength)
1425 {
1426     RSA *res;
1427     int ret_val;
1428
1429     if(ret_val = pthread_mutex_lock(&RSA_mut))
1430         logmsg(LOG_WARNING, "RSA_tmp_callback() lock: %s", strerror(ret_val));
1431     res = (keylength <= 512)? RSA512_keys[rand() % N_RSA_KEYS]: RSA1024_keys[rand() % N_RSA_KEYS];
1432     if(ret_val = pthread_mutex_unlock(&RSA_mut))
1433         logmsg(LOG_WARNING, "RSA_tmp_callback() unlock: %s", strerror(ret_val));
1434     return res;
1435 }
1436
1437 /*
1438  * Periodically regenerate ephemeral RSA keys
1439  * runs every T_RSA_KEYS seconds
1440  */
1441 static void
1442 do_RSAgen(void)
1443 {
1444     int n, ret_val;
1445     RSA *t_RSA512_keys[N_RSA_KEYS];
1446     RSA *t_RSA1024_keys[N_RSA_KEYS];
1447
1448     for(n = 0; n < N_RSA_KEYS; n++) {
1449         t_RSA512_keys[n] = RSA_generate_key(512, RSA_F4, NULL, NULL);
1450         t_RSA1024_keys[n] = RSA_generate_key(1024, RSA_F4, NULL, NULL);
1451     }
1452     if(ret_val = pthread_mutex_lock(&RSA_mut))
1453         logmsg(LOG_WARNING, "thr_RSAgen() lock: %s", strerror(ret_val));
1454     for(n = 0; n < N_RSA_KEYS; n++) {
1455         RSA_free(RSA512_keys[n]);
1456         RSA512_keys[n] = t_RSA512_keys[n];
1457         RSA_free(RSA1024_keys[n]);
1458         RSA1024_keys[n] = t_RSA1024_keys[n];
1459     }
1460     if(ret_val = pthread_mutex_unlock(&RSA_mut))
1461         logmsg(LOG_WARNING, "thr_RSAgen() unlock: %s", strerror(ret_val));
1462     return;
1463 }
1464
1465
1466 /*
1467  * initialise the timer functions:
1468  *  - RSA_mut and keys
1469  */
1470 void
1471 init_timer(void)
1472 {
1473     int n;
1474
1475     last_RSA = last_rescale = last_alive = last_expire = time(NULL);
1476
1477     /*
1478      * Pre-generate ephemeral RSA keys
1479      */
1480     for(n = 0; n < N_RSA_KEYS; n++) {
1481         if((RSA512_keys[n] = RSA_generate_key(512, RSA_F4, NULL, NULL)) == NULL) {
1482             logmsg(LOG_WARNING,"RSA_generate(%d, 512) failed", n);
1483             return;
1484         }
1485         if((RSA1024_keys[n] = RSA_generate_key(1024, RSA_F4, NULL, NULL)) == NULL) {
1486             logmsg(LOG_WARNING,"RSA_generate(%d, 1024) failed", n);
1487             return;
1488         }
1489     }
1490     /* pthread_mutex_init() always returns 0 */
1491     pthread_mutex_init(&RSA_mut, NULL);
1492
1493     DH2048_params = get_dh2048();
1494
1495     return;
1496 }
1497
1498 /*
1499  * run timed functions:
1500  *  - RSAgen every T_RSA_KEYS seconds
1501  *  - rescale every RESCALE_TO seconds
1502  *  - resurect every alive_to seconds
1503  *  - expire every EXPIRE_TO seconds
1504  */
1505 void *
1506 thr_timer(void *arg)
1507 {
1508     time_t  last_time, cur_time;
1509     int     n_wait, n_remain;
1510
1511     n_wait = EXPIRE_TO;
1512     if(n_wait > alive_to)
1513         n_wait = alive_to;
1514     if(n_wait > RESCALE_TO)
1515         n_wait = RESCALE_TO;
1516     if(n_wait > T_RSA_KEYS)
1517         n_wait = T_RSA_KEYS;
1518     for(last_time = time(NULL) - n_wait;;) {
1519         cur_time = time(NULL);
1520         if((n_remain = n_wait - (cur_time - last_time)) > 0)
1521             sleep(n_remain);
1522         last_time = time(NULL);
1523         if((last_time - last_RSA) >= T_RSA_KEYS) {
1524             last_RSA = time(NULL);
1525             do_RSAgen();
1526         }
1527         if((last_time - last_rescale) >= RESCALE_TO) {
1528             last_rescale = time(NULL);
1529             do_rescale();
1530         }
1531         if((last_time - last_alive) >= alive_to) {
1532             last_alive = time(NULL);
1533             do_resurect();
1534         }
1535         if((last_time - last_expire) >= EXPIRE_TO) {
1536             last_expire = time(NULL);
1537             do_expire();
1538         }
1539     }
1540 }
1541
1542 typedef struct  {
1543     int     control_sock;
1544     BACKEND *backends;
1545 }   DUMP_ARG;
1546
1547 static void
1548 t_dump_doall_arg(TABNODE *t, DUMP_ARG *arg)
1549 {
1550     BACKEND     *be, *bep;
1551     int         n_be, sz;
1552
1553     memcpy(&bep, t->content, sizeof(bep));
1554     for(n_be = 0, be = arg->backends; be; be = be->next, n_be++)
1555         if(be == bep)
1556             break;
1557     if(!be)
1558         /* should NEVER happen */
1559         n_be = 0;
1560     (void)write(arg->control_sock, t, sizeof(TABNODE));
1561     (void)write(arg->control_sock, &n_be, sizeof(n_be));
1562     sz = strlen(t->key);
1563     (void)write(arg->control_sock, &sz, sizeof(sz));
1564     (void)write(arg->control_sock, t->key, sz);
1565     return;
1566 }
1567 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
1568 IMPLEMENT_LHASH_DOALL_ARG_FN(t_dump, TABNODE, DUMP_ARG)
1569 #else
1570 #define t_dump t_dump_doall_arg
1571 IMPLEMENT_LHASH_DOALL_ARG_FN(t_dump, TABNODE *, DUMP_ARG *)
1572 #endif
1573
1574 /*
1575  * write sessions to the control socket
1576  */
1577 static void
1578 dump_sess(const int control_sock, LHASH_OF(TABNODE) *const sess, BACKEND *const backends)
1579 {
1580     DUMP_ARG a;
1581
1582     a.control_sock = control_sock;
1583     a.backends = backends;
1584 #if OPENSSL_VERSION_NUMBER >= 0x10000000L
1585     LHM_lh_doall_arg(TABNODE, sess, LHASH_DOALL_ARG_FN(t_dump), DUMP_ARG, &a);
1586 #else
1587     lh_doall_arg(sess, LHASH_DOALL_ARG_FN(t_dump), &a);
1588 #endif
1589     return;
1590 }
1591
1592 /*
1593  * given a command, select a listener
1594  */
1595 static LISTENER *
1596 sel_lstn(const CTRL_CMD *cmd)
1597 {
1598     LISTENER    *lstn;
1599     int         i;
1600
1601     if(cmd->listener < 0)
1602         return NULL;
1603     for(i = 0, lstn = listeners; lstn && i < cmd->listener; i++, lstn = lstn->next)
1604         ;
1605     return lstn;
1606 }
1607
1608 /*
1609  * given a command, select a service
1610  */
1611 static SERVICE *
1612 sel_svc(const CTRL_CMD *cmd)
1613 {
1614     SERVICE     *svc;
1615     LISTENER    *lstn;
1616     int         i;
1617
1618     if(cmd->listener < 0) {
1619         svc = services;
1620     } else {
1621         if((lstn = sel_lstn(cmd)) == NULL)
1622             return NULL;
1623         svc = lstn->services;
1624     }
1625     for(i = 0; svc && i < cmd->service; i++, svc = svc->next)
1626         ;
1627     return svc;
1628 }
1629
1630 /*
1631  * given a command, select a back-end
1632  */
1633 static BACKEND *
1634 sel_be(const CTRL_CMD *cmd)
1635 {
1636     BACKEND     *be;
1637     SERVICE     *svc;
1638     int         i;
1639
1640     if((svc = sel_svc(cmd)) == NULL)
1641         return NULL;
1642     for(i = 0, be = svc->backends; be && i < cmd->backend; i++, be = be->next)
1643         ;
1644     return be;
1645 }
1646
1647 /*
1648  * The controlling thread
1649  * listens to client requests and calls the appropriate functions
1650  */
1651 void *
1652 thr_control(void *arg)
1653 {
1654     CTRL_CMD        cmd;
1655     struct sockaddr sa;
1656     int             ctl, dummy, n, ret_val;
1657     LISTENER        *lstn, dummy_lstn;
1658     SERVICE         *svc, dummy_svc;
1659     BACKEND         *be, dummy_be;
1660     TABNODE         dummy_sess;
1661     struct pollfd   polls;
1662
1663     /* just to be safe */
1664     if(control_sock < 0)
1665         return NULL;
1666     memset(&dummy_lstn, 0, sizeof(dummy_lstn));
1667     dummy_lstn.disabled = -1;
1668     memset(&dummy_svc, 0, sizeof(dummy_svc));
1669     dummy_svc.disabled = -1;
1670     memset(&dummy_be, 0, sizeof(dummy_be));
1671     dummy_be.disabled = -1;
1672     memset(&dummy_sess, 0, sizeof(dummy_sess));
1673     dummy_sess.content = NULL;
1674     dummy = sizeof(sa);
1675     for(;;) {
1676         polls.fd = control_sock;
1677         polls.events = POLLIN | POLLPRI;
1678         polls.revents = 0;
1679         if(poll(&polls, 1, -1) < 0) {
1680             logmsg(LOG_WARNING, "thr_control() poll: %s", strerror(errno));
1681             continue;
1682         }
1683         if((ctl = accept(control_sock, &sa, (socklen_t *)&dummy)) < 0) {
1684             logmsg(LOG_WARNING, "thr_control() accept: %s", strerror(errno));
1685             continue;
1686         }
1687         if(read(ctl, &cmd, sizeof(cmd)) != sizeof(cmd)) {
1688             logmsg(LOG_WARNING, "thr_control() read: %s", strerror(errno));
1689             continue;
1690         }
1691         switch(cmd.cmd) {
1692         case CTRL_LST:
1693             /* logmsg(LOG_INFO, "thr_control() list"); */
1694             n = get_thr_qlen();
1695             (void)write(ctl, (void *)&n, sizeof(n));
1696             for(lstn = listeners; lstn; lstn = lstn->next) {
1697                 (void)write(ctl, (void *)lstn, sizeof(LISTENER));
1698                 (void)write(ctl, lstn->addr.ai_addr, lstn->addr.ai_addrlen);
1699                 for(svc = lstn->services; svc; svc = svc->next) {
1700                     (void)write(ctl, (void *)svc, sizeof(SERVICE));
1701                     for(be = svc->backends; be; be = be->next) {
1702                         (void)write(ctl, (void *)be, sizeof(BACKEND));
1703                         (void)write(ctl, be->addr.ai_addr, be->addr.ai_addrlen);
1704                         if(be->ha_addr.ai_addrlen > 0)
1705                             (void)write(ctl, be->ha_addr.ai_addr, be->ha_addr.ai_addrlen);
1706                     }
1707                     (void)write(ctl, (void *)&dummy_be, sizeof(BACKEND));
1708                     if(dummy = pthread_mutex_lock(&svc->mut))
1709                         logmsg(LOG_WARNING, "thr_control() lock: %s", strerror(dummy));
1710                     else {
1711                         dump_sess(ctl, svc->sessions, svc->backends);
1712                         if(dummy = pthread_mutex_unlock(&svc->mut))
1713                             logmsg(LOG_WARNING, "thr_control() unlock: %s", strerror(dummy));
1714                     }
1715                     (void)write(ctl, (void *)&dummy_sess, sizeof(TABNODE));
1716                 }
1717                 (void)write(ctl, (void *)&dummy_svc, sizeof(SERVICE));
1718             }
1719             (void)write(ctl, (void *)&dummy_lstn, sizeof(LISTENER));
1720             for(svc = services; svc; svc = svc->next) {
1721                 (void)write(ctl, (void *)svc, sizeof(SERVICE));
1722                 for(be = svc->backends; be; be = be->next) {
1723                     (void)write(ctl, (void *)be, sizeof(BACKEND));
1724                     (void)write(ctl, be->addr.ai_addr, be->addr.ai_addrlen);
1725                     if(be->ha_addr.ai_addrlen > 0)
1726                         (void)write(ctl, be->ha_addr.ai_addr, be->ha_addr.ai_addrlen);
1727                 }
1728                 (void)write(ctl, (void *)&dummy_be, sizeof(BACKEND));
1729                 if(dummy = pthread_mutex_lock(&svc->mut))
1730                     logmsg(LOG_WARNING, "thr_control() lock: %s", strerror(dummy));
1731                 else {
1732                     dump_sess(ctl, svc->sessions, svc->backends);
1733                     if(dummy = pthread_mutex_unlock(&svc->mut))
1734                         logmsg(LOG_WARNING, "thr_control() unlock: %s", strerror(dummy));
1735                 }
1736                 (void)write(ctl, (void *)&dummy_sess, sizeof(TABNODE));
1737             }
1738             (void)write(ctl, (void *)&dummy_svc, sizeof(SERVICE));
1739             break;
1740         case CTRL_EN_LSTN:
1741             if((lstn = sel_lstn(&cmd)) == NULL)
1742                 logmsg(LOG_INFO, "thr_control() bad listener %d", cmd.listener);
1743             else
1744                 lstn->disabled = 0;
1745             break;
1746         case CTRL_DE_LSTN:
1747             if((lstn = sel_lstn(&cmd)) == NULL)
1748                 logmsg(LOG_INFO, "thr_control() bad listener %d", cmd.listener);
1749             else
1750                 lstn->disabled = 1;
1751             break;
1752         case CTRL_EN_SVC:
1753             if((svc = sel_svc(&cmd)) == NULL)
1754                 logmsg(LOG_INFO, "thr_control() bad service %d/%d", cmd.listener, cmd.service);
1755             else
1756                 svc->disabled = 0;
1757             break;
1758         case CTRL_DE_SVC:
1759             if((svc = sel_svc(&cmd)) == NULL)
1760                 logmsg(LOG_INFO, "thr_control() bad service %d/%d", cmd.listener, cmd.service);
1761             else
1762                 svc->disabled = 1;
1763             break;
1764         case CTRL_EN_BE:
1765             if((svc = sel_svc(&cmd)) == NULL) {
1766                 logmsg(LOG_INFO, "thr_control() bad service %d/%d", cmd.listener, cmd.service);
1767                 break;
1768             }
1769             if((be = sel_be(&cmd)) == NULL)
1770                 logmsg(LOG_INFO, "thr_control() bad backend %d/%d/%d", cmd.listener, cmd.service, cmd.backend);
1771             else
1772                 kill_be(svc, be, BE_ENABLE);
1773             break;
1774         case CTRL_DE_BE:
1775             if((svc = sel_svc(&cmd)) == NULL) {
1776                 logmsg(LOG_INFO, "thr_control() bad service %d/%d", cmd.listener, cmd.service);
1777                 break;
1778             }
1779             if((be = sel_be(&cmd)) == NULL)
1780                 logmsg(LOG_INFO, "thr_control() bad backend %d/%d/%d", cmd.listener, cmd.service, cmd.backend);
1781             else
1782                 kill_be(svc, be, BE_DISABLE);
1783             break;
1784         case CTRL_ADD_SESS:
1785             if((svc = sel_svc(&cmd)) == NULL) {
1786                 logmsg(LOG_INFO, "thr_control() bad service %d/%d", cmd.listener, cmd.service);
1787                 break;
1788             }
1789             if((be = sel_be(&cmd)) == NULL) {
1790                 logmsg(LOG_INFO, "thr_control() bad back-end %d/%d", cmd.listener, cmd.service);
1791                 break;
1792             }
1793             if(ret_val = pthread_mutex_lock(&svc->mut))
1794                 logmsg(LOG_WARNING, "thr_control() add session lock: %s", strerror(ret_val));
1795             t_add(svc->sessions, cmd.key, &be, sizeof(be));
1796             if(ret_val = pthread_mutex_unlock(&svc->mut))
1797                 logmsg(LOG_WARNING, "thoriginalfiler_control() add session unlock: %s", strerror(ret_val));
1798             break;
1799         case CTRL_DEL_SESS:
1800             if((svc = sel_svc(&cmd)) == NULL) {
1801                 logmsg(LOG_INFO, "thr_control() bad service %d/%d", cmd.listener, cmd.service);
1802                 break;
1803             }
1804             if(ret_val = pthread_mutex_lock(&svc->mut))
1805                 logmsg(LOG_WARNING, "thr_control() del session lock: %s", strerror(ret_val));
1806             t_remove(svc->sessions, cmd.key);
1807             if(ret_val = pthread_mutex_unlock(&svc->mut))
1808                 logmsg(LOG_WARNING, "thr_control() del session unlock: %s", strerror(ret_val));
1809             break;
1810         default:
1811             logmsg(LOG_WARNING, "thr_control() unknown command");
1812             break;
1813         }
1814         close(ctl);
1815     }
1816 }
1817
1818 void
1819 SSLINFO_callback(const SSL *ssl, int where, int rc)
1820 {
1821     RENEG_STATE *reneg_state;
1822
1823     /* Get our thr_arg where we're tracking this connection info */
1824     if((reneg_state = (RENEG_STATE *)SSL_get_app_data(ssl)) == NULL)
1825         return;
1826
1827     /* If we're rejecting renegotiations, move to ABORT if Client Hello is being read. */
1828     if((where & SSL_CB_ACCEPT_LOOP) && *reneg_state == RENEG_REJECT) {
1829         int state;
1830
1831         state = SSL_get_state(ssl);
1832         if (state == SSL3_ST_SR_CLNT_HELLO_A || state == SSL23_ST_SR_CLNT_HELLO_A) {
1833            *reneg_state = RENEG_ABORT;
1834            logmsg(LOG_WARNING,"rejecting client initiated renegotiation");
1835         }
1836     } else if(where & SSL_CB_HANDSHAKE_DONE && *reneg_state == RENEG_INIT) {
1837        // Reject any followup renegotiations
1838        *reneg_state = RENEG_REJECT;
1839     }
1840 }