← Back to branch summary

~ubuntu-branches/ubuntu/vivid/keepalived/vivid

« back to all changes in this revision

Viewing changes to keepalived/check/check_http.c

  • Committer: Package Import Robot
  • Author(s): Colin Watson
  • Date: 2011-10-25 16:10:58 UTC
  • mfrom: (3.1.7 sid)
  • Revision ID: package-import@ubuntu.com-20111025161058-bgqn5elt0xo1tq0a
Tags: 1:1.2.2-1ubuntu1
* Resynchronise with Debian.  Remaining changes:
  - debian/rules: DEB_UPDATE_RCD_PARAMS := explicit init start/stop
    parameters (don't stop at 0 and 6)
  - debian/init.d: init script header adapted to stop rule
  - debian/keepalived.postinst: Remove shutdown and reboot links
* Build with libnl3, thanks to a patch from Marc - A. Dahlhaus.

Show diffs side-by-side

added added

removed removed

Lines of Context:
keepalived/check/check_http.c
18
18
 *              as published by the Free Software Foundation; either version
19
19
 *              2 of the License, or (at your option) any later version.
20
20
 *
21
 
 * Copyright (C) 2001-2010 Alexandre Cassen, <acassen@freebox.fr>
 
21
 * Copyright (C) 2001-2011 Alexandre Cassen, <acassen@linux-vs.org>
22
22
 */
23
23
 
24
24
#include <openssl/err.h>
31
31
#include "utils.h"
32
32
#include "html.h"
33
33
 
34
 
int http_connect_thread(thread *);
 
34
int http_connect_thread(thread_t *);
35
35
 
36
36
/* Configuration stream handling */
37
37
void
38
38
free_url(void *data)
39
39
{
40
 
        url *url_obj = data;
41
 
        FREE(url_obj->path);
42
 
        FREE(url_obj->digest);
43
 
        FREE(url_obj);
 
40
        url_t *url = data;
 
41
        FREE(url->path);
 
42
        FREE(url->digest);
 
43
        FREE(url);
44
44
}
45
45
 
46
46
void
47
47
dump_url(void *data)
48
48
{
49
 
        url *url_obj = data;
50
 
        log_message(LOG_INFO, "   Checked url = %s", url_obj->path);
51
 
        if (url_obj->digest)
 
49
        url_t *url = data;
 
50
        log_message(LOG_INFO, "   Checked url = %s", url->path);
 
51
        if (url->digest)
52
52
                log_message(LOG_INFO, "           digest = %s",
53
 
                       url_obj->digest);
54
 
        if (url_obj->status_code)
 
53
                       url->digest);
 
54
        if (url->status_code)
55
55
                log_message(LOG_INFO, "           HTTP Status Code = %d",
56
 
                       url_obj->status_code);
 
56
                       url->status_code);
57
57
}
58
58
 
59
59
void
60
60
free_http_get_check(void *data)
61
61
{
62
 
        http_get_checker *http_get_chk = CHECKER_DATA(data);
 
62
        http_checker_t *http_get_chk = CHECKER_DATA(data);
63
63
 
64
64
        free_list(http_get_chk->url);
65
65
        FREE(http_get_chk->arg);
70
70
void
71
71
dump_http_get_check(void *data)
72
72
{
73
 
        http_get_checker *http_get_chk = CHECKER_DATA(data);
 
73
        http_checker_t *http_get_chk = CHECKER_DATA(data);
74
74
 
75
75
        if (http_get_chk->proto == PROTO_HTTP)
76
76
                log_message(LOG_INFO, "   Keepalive method = HTTP_GET");
77
77
        else
78
78
                log_message(LOG_INFO, "   Keepalive method = SSL_GET");
79
 
        if (http_get_chk->connection_port)
80
 
                log_message(LOG_INFO, "   Connection port = %d",
81
 
                       ntohs(http_get_chk->connection_port));
82
 
        if (http_get_chk->bindto)
83
 
                log_message(LOG_INFO, "   Bind to = %s",
84
 
                       inet_ntop2(http_get_chk->bindto));
 
79
        log_message(LOG_INFO, "   Connection port = %d", ntohs(inet_sockaddrport(&http_get_chk->dst)));
 
80
        if (http_get_chk->bindto.ss_family)
 
81
                log_message(LOG_INFO, "   Bind to = %s", inet_sockaddrtos(&http_get_chk->bindto));
85
82
        log_message(LOG_INFO, "   Connection timeout = %lu",
86
83
               http_get_chk->connection_to/TIMER_HZ);
87
84
        log_message(LOG_INFO, "   Nb get retry = %d", http_get_chk->nb_get_retry);
89
86
               http_get_chk->delay_before_retry/TIMER_HZ);
90
87
        dump_list(http_get_chk->url);
91
88
}
92
 
static http_get_checker *
 
89
static http_checker_t *
93
90
alloc_http_get(char *proto)
94
91
{
95
 
        http_get_checker *http_get_chk;
 
92
        http_checker_t *http_get_chk;
96
93
 
97
 
        http_get_chk = (http_get_checker *) MALLOC(sizeof (http_get_checker));
98
 
        http_get_chk->arg = (http_arg *) MALLOC(sizeof (http_arg));
 
94
        http_get_chk = (http_checker_t *) MALLOC(sizeof (http_checker_t));
 
95
        http_get_chk->arg = (http_arg_t *) MALLOC(sizeof (http_arg_t));
99
96
        http_get_chk->proto =
100
97
            (!strcmp(proto, "HTTP_GET")) ? PROTO_HTTP : PROTO_SSL;
101
98
        http_get_chk->url = alloc_list(free_url, dump_url);
107
104
void
108
105
http_get_handler(vector strvec)
109
106
{
110
 
        http_get_checker *http_get_chk;
 
107
        http_checker_t *http_get_chk;
111
108
        char *str = VECTOR_SLOT(strvec, 0);
112
109
 
113
110
        /* queue new checker */
114
111
        http_get_chk = alloc_http_get(str);
 
112
        checker_set_dst(&http_get_chk->dst);
115
113
        queue_checker(free_http_get_check, dump_http_get_check,
116
114
                      http_connect_thread, http_get_chk);
117
115
}
119
117
void
120
118
connect_p_handler(vector strvec)
121
119
{
122
 
        http_get_checker *http_get_chk = CHECKER_GET();
123
 
        http_get_chk->connection_port = htons(CHECKER_VALUE_INT(strvec));
 
120
        http_checker_t *http_get_chk = CHECKER_GET();
 
121
        checker_set_dst_port(&http_get_chk->dst, htons(CHECKER_VALUE_INT(strvec)));
124
122
}
125
123
 
126
124
void
127
125
bindto_handler(vector strvec)
128
126
{
129
 
        http_get_checker *http_get_chk = CHECKER_GET();
130
 
        inet_ston(VECTOR_SLOT(strvec, 1), &http_get_chk->bindto);
 
127
        http_checker_t *http_get_chk = CHECKER_GET();
 
128
        inet_stosockaddr(VECTOR_SLOT(strvec, 1), 0, &http_get_chk->bindto);
131
129
}
132
130
 
133
131
void
134
132
connect_to_handler(vector strvec)
135
133
{
136
 
        http_get_checker *http_get_chk = CHECKER_GET();
 
134
        http_checker_t *http_get_chk = CHECKER_GET();
137
135
        http_get_chk->connection_to = CHECKER_VALUE_INT(strvec) * TIMER_HZ;
138
136
}
139
137
 
140
138
void
141
139
nb_get_retry_handler(vector strvec)
142
140
{
143
 
        http_get_checker *http_get_chk = CHECKER_GET();
 
141
        http_checker_t *http_get_chk = CHECKER_GET();
144
142
        http_get_chk->nb_get_retry = CHECKER_VALUE_INT(strvec);
145
143
}
146
144
 
147
145
void
148
146
delay_before_retry_handler(vector strvec)
149
147
{
150
 
        http_get_checker *http_get_chk = CHECKER_GET();
 
148
        http_checker_t *http_get_chk = CHECKER_GET();
151
149
        http_get_chk->delay_before_retry = CHECKER_VALUE_INT(strvec) * TIMER_HZ;
152
150
}
153
151
 
154
152
void
155
153
url_handler(vector strvec)
156
154
{
157
 
        http_get_checker *http_get_chk = CHECKER_GET();
158
 
        url *new;
 
155
        http_checker_t *http_get_chk = CHECKER_GET();
 
156
        url_t *new;
159
157
 
160
158
        /* allocate the new URL */
161
 
        new = (url *) MALLOC(sizeof (url));
 
159
        new = (url_t *) MALLOC(sizeof (url_t));
162
160
 
163
161
        list_add(http_get_chk->url, new);
164
162
}
166
164
void
167
165
path_handler(vector strvec)
168
166
{
169
 
        http_get_checker *http_get_chk = CHECKER_GET();
170
 
        url *url_obj = LIST_TAIL_DATA(http_get_chk->url);
 
167
        http_checker_t *http_get_chk = CHECKER_GET();
 
168
        url_t *url = LIST_TAIL_DATA(http_get_chk->url);
171
169
 
172
 
        url_obj->path = CHECKER_VALUE_STRING(strvec);
 
170
        url->path = CHECKER_VALUE_STRING(strvec);
173
171
}
174
172
 
175
173
void
176
174
digest_handler(vector strvec)
177
175
{
178
 
        http_get_checker *http_get_chk = CHECKER_GET();
179
 
        url *url_obj = LIST_TAIL_DATA(http_get_chk->url);
 
176
        http_checker_t *http_get_chk = CHECKER_GET();
 
177
        url_t *url = LIST_TAIL_DATA(http_get_chk->url);
180
178
 
181
 
        url_obj->digest = CHECKER_VALUE_STRING(strvec);
 
179
        url->digest = CHECKER_VALUE_STRING(strvec);
182
180
}
183
181
 
184
182
void
185
183
status_code_handler(vector strvec)
186
184
{
187
 
        http_get_checker *http_get_chk = CHECKER_GET();
188
 
        url *url_obj = LIST_TAIL_DATA(http_get_chk->url);
 
185
        http_checker_t *http_get_chk = CHECKER_GET();
 
186
        url_t *url = LIST_TAIL_DATA(http_get_chk->url);
189
187
 
190
 
        url_obj->status_code = CHECKER_VALUE_INT(strvec);
 
188
        url->status_code = CHECKER_VALUE_INT(strvec);
191
189
}
192
190
 
193
191
void
254
252
 *     http_handle_response (next checker thread registration)
255
253
 */
256
254
 
257
 
uint16_t
258
 
get_service_port(checker * checker_obj)
259
 
{
260
 
        http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
261
 
        uint16_t addr_port;
262
 
 
263
 
        /*
264
 
         *  Set the remote connection port.
265
 
         *  If a specific checker port is specified, we used this.
266
 
         *  If we are balancing all services (host rather than service),
267
 
         *  then assume we want to use default ports for HTTP or HTTPS.
268
 
         *  Known as 'Layer3 stickyness'.
269
 
         */
270
 
        addr_port = CHECKER_RPORT(checker_obj);
271
 
        if (!addr_port)
272
 
                addr_port =
273
 
                    htons((http_get_check->proto == PROTO_SSL) ? 443 : 80);
274
 
        if (http_get_check->connection_port)
275
 
                addr_port = http_get_check->connection_port;
276
 
        return addr_port;
277
 
}
278
 
 
279
255
/*
280
256
 * Simple epilog functions. Handling event timeout.
281
257
 * Finish the checker with memory managment or url rety check.
286
262
 * method == 2 => register a retry on url checker thread
287
263
 */
288
264
int
289
 
epilog(thread * thread_obj, int method, int t, int c)
 
265
epilog(thread_t * thread, int method, int t, int c)
290
266
{
291
 
        checker *checker_obj = THREAD_ARG(thread_obj);
292
 
        http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
293
 
        http_arg *http_arg_obj = HTTP_ARG(http_get_check);
294
 
        REQ *req = HTTP_REQ(http_arg_obj);
295
 
        uint16_t addr_port = get_service_port(checker_obj);
 
267
        checker_t *checker = THREAD_ARG(thread);
 
268
        http_checker_t *http_get_check = CHECKER_ARG(checker);
 
269
        http_arg_t *http_arg = HTTP_ARG(http_get_check);
 
270
        request_t *req = HTTP_REQ(http_arg);
296
271
        long delay = 0;
297
272
 
298
273
        if (method) {
299
 
                http_arg_obj->url_it += t ? t : -http_arg_obj->url_it;
300
 
                http_arg_obj->retry_it += c ? c : -http_arg_obj->retry_it;
 
274
                http_arg->url_it += t ? t : -http_arg->url_it;
 
275
                http_arg->retry_it += c ? c : -http_arg->retry_it;
301
276
        }
302
277
 
303
278
        /*
306
281
         * html buffer. This is sometime needed with some applications
307
282
         * servers.
308
283
         */
309
 
        if (http_arg_obj->retry_it > http_get_check->nb_get_retry-1) {
310
 
                if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
311
 
                        log_message(LOG_INFO, "Check on service [%s:%d] failed after %d retry."
312
 
                               , inet_ntop2(CHECKER_RIP(checker_obj))
313
 
                               , ntohs(addr_port), http_arg_obj->retry_it);
314
 
                        smtp_alert(checker_obj->rs, NULL, NULL,
 
284
        if (http_arg->retry_it > http_get_check->nb_get_retry-1) {
 
285
                if (svr_checker_up(checker->id, checker->rs)) {
 
286
                        log_message(LOG_INFO, "Check on service [%s]:%d failed after %d retry."
 
287
                               , inet_sockaddrtos(&http_get_check->dst)
 
288
                               , ntohs(inet_sockaddrport(&http_get_check->dst)), http_arg->retry_it);
 
289
                        smtp_alert(checker->rs, NULL, NULL,
315
290
                                   "DOWN",
316
291
                                   "=> CHECK failed on service"
317
292
                                   " : MD5 digest mismatch <=");
318
 
                        update_svr_checker_state(DOWN, checker_obj->id
319
 
                                                     , checker_obj->vs
320
 
                                                     , checker_obj->rs);
 
293
                        update_svr_checker_state(DOWN, checker->id
 
294
                                                     , checker->vs
 
295
                                                     , checker->rs);
321
296
                }
322
297
 
323
298
                /* Reset it counters */
324
 
                http_arg_obj->url_it = 0;
325
 
                http_arg_obj->retry_it = 0;
 
299
                http_arg->url_it = 0;
 
300
                http_arg->retry_it = 0;
326
301
        }
327
302
 
328
303
        /* register next timer thread */
329
304
        switch (method) {
330
305
        case 1:
331
306
                if (req)
332
 
                        delay = checker_obj->vs->delay_loop;
 
307
                        delay = checker->vs->delay_loop;
333
308
                else
334
309
                        delay =
335
310
                            http_get_check->delay_before_retry;
336
311
                break;
337
312
        case 2:
338
 
                if (http_arg_obj->url_it == 0 && http_arg_obj->retry_it == 0)
339
 
                        delay = checker_obj->vs->delay_loop;
 
313
                if (http_arg->url_it == 0 && http_arg->retry_it == 0)
 
314
                        delay = checker->vs->delay_loop;
340
315
                else
341
316
                        delay = http_get_check->delay_before_retry;
342
317
                break;
349
324
                if (req->buffer)
350
325
                        FREE(req->buffer);
351
326
                FREE(req);
352
 
                http_arg_obj->req = NULL;
353
 
                close(thread_obj->u.fd);
 
327
                http_arg->req = NULL;
 
328
                close(thread->u.fd);
354
329
        }
355
330
 
356
331
        /* Register next checker thread */
357
 
        thread_add_timer(thread_obj->master, http_connect_thread, checker_obj, delay);
 
332
        thread_add_timer(thread->master, http_connect_thread, checker, delay);
358
333
        return 0;
359
334
}
360
335
 
361
336
int
362
 
timeout_epilog(thread * thread_obj, char *smtp_msg, char *debug_msg)
 
337
timeout_epilog(thread_t * thread, char *smtp_msg, char *debug_msg)
363
338
{
364
 
        checker *checker_obj = THREAD_ARG(thread_obj);
365
 
        uint16_t addr_port = get_service_port(checker_obj);
 
339
        checker_t *checker = THREAD_ARG(thread);
 
340
        http_checker_t *http_get_check = CHECKER_ARG(checker);
366
341
 
367
 
        log_message(LOG_INFO, "Timeout %s server [%s:%d].",
368
 
               debug_msg
369
 
               , inet_ntop2(CHECKER_RIP(checker_obj))
370
 
               , ntohs(addr_port));
 
342
        log_message(LOG_INFO, "Timeout %s server [%s]:%d."
 
343
                            , debug_msg
 
344
                            , inet_sockaddrtos(&http_get_check->dst)
 
345
                            , ntohs(inet_sockaddrport(&http_get_check->dst)));
371
346
 
372
347
        /* check if server is currently alive */
373
 
        if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
374
 
                smtp_alert(checker_obj->rs, NULL, NULL,
 
348
        if (svr_checker_up(checker->id, checker->rs)) {
 
349
                smtp_alert(checker->rs, NULL, NULL,
375
350
                           "DOWN", smtp_msg);
376
 
                update_svr_checker_state(DOWN, checker_obj->id
377
 
                                             , checker_obj->vs
378
 
                                             , checker_obj->rs);
 
351
                update_svr_checker_state(DOWN, checker->id
 
352
                                             , checker->vs
 
353
                                             , checker->rs);
379
354
        }
380
355
 
381
 
        return epilog(thread_obj, 1, 0, 0);
 
356
        return epilog(thread, 1, 0, 0);
382
357
}
383
358
 
384
359
/* return the url pointer of the current url iterator  */
385
 
url *
386
 
fetch_next_url(http_get_checker * http_get_check)
 
360
url_t *
 
361
fetch_next_url(http_checker_t * http_get_check)
387
362
{
388
 
        http_arg *http_arg_obj = HTTP_ARG(http_get_check);
 
363
        http_arg_t *http_arg = HTTP_ARG(http_get_check);
389
364
 
390
 
        return list_element(http_get_check->url, http_arg_obj->url_it);
 
365
        return list_element(http_get_check->url, http_arg->url_it);
391
366
}
392
367
 
393
368
/* Handle response */
394
369
int
395
 
http_handle_response(thread * thread_obj, unsigned char digest[16]
 
370
http_handle_response(thread_t * thread, unsigned char digest[16]
396
371
                     , int empty_buffer)
397
372
{
398
 
        checker *checker_obj = THREAD_ARG(thread_obj);
399
 
        http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
400
 
        http_arg *http_arg_obj = HTTP_ARG(http_get_check);
401
 
        REQ *req = HTTP_REQ(http_arg_obj);
402
 
        uint16_t addr_port = get_service_port(checker_obj);
 
373
        checker_t *checker = THREAD_ARG(thread);
 
374
        http_checker_t *http_get_check = CHECKER_ARG(checker);
 
375
        http_arg_t *http_arg = HTTP_ARG(http_get_check);
 
376
        request_t *req = HTTP_REQ(http_arg);
403
377
        int r, di = 0;
404
378
        char *digest_tmp;
405
 
        url *fetched_url = fetch_next_url(http_get_check);
 
379
        url_t *fetched_url = fetch_next_url(http_get_check);
406
380
 
407
381
        /* First check if remote webserver returned data */
408
382
        if (empty_buffer)
409
 
                return timeout_epilog(thread_obj, "=> CHECK failed on service"
 
383
                return timeout_epilog(thread, "=> CHECK failed on service"
410
384
                                      " : empty buffer received <=\n\n",
411
385
                                      "Read, no data received from ");
412
386
 
414
388
        if (fetched_url->status_code) {
415
389
                if (req->status_code != fetched_url->status_code) {
416
390
                        /* check if server is currently alive */
417
 
                        if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
 
391
                        if (svr_checker_up(checker->id, checker->rs)) {
418
392
                                log_message(LOG_INFO,
419
 
                                       "HTTP status code error to [%s:%d] url(%s)"
 
393
                                       "HTTP status code error to [%s]:%d url(%s)"
420
394
                                       ", status_code [%d].",
421
 
                                       inet_ntop2(CHECKER_RIP(checker_obj)),
422
 
                                       ntohs(addr_port), fetched_url->path,
 
395
                                       inet_sockaddrtos(&http_get_check->dst),
 
396
                                       ntohs(inet_sockaddrport(&http_get_check->dst)),
 
397
                                       fetched_url->path,
423
398
                                       req->status_code);
424
 
                                smtp_alert(checker_obj->rs, NULL, NULL,
 
399
                                smtp_alert(checker->rs, NULL, NULL,
425
400
                                           "DOWN",
426
401
                                           "=> CHECK failed on service"
427
402
                                           " : HTTP status code mismatch <=");
428
 
                                update_svr_checker_state(DOWN, checker_obj->id
429
 
                                                             , checker_obj->vs
430
 
                                                             , checker_obj->rs);
 
403
                                update_svr_checker_state(DOWN, checker->id
 
404
                                                             , checker->vs
 
405
                                                             , checker->rs);
431
406
                        } else {
432
 
                                DBG("HTTP Status_code to [%s:%d] url(%d) = [%d].",
433
 
                                    inet_ntop2(CHECKER_RIP(checker_obj))
434
 
                                    , ntohs(addr_port)
435
 
                                    , http_arg_obj->url_it + 1
 
407
                                DBG("HTTP Status_code to [%s]:%d url(%d) = [%d]."
 
408
                                    , inet_sockaddrtos(&http_get_check->dst)
 
409
                                    , ntohs(inet_sockaddrport(&http_get_check->dst))
 
410
                                    , http_arg->url_it + 1
436
411
                                    , req->status_code);
437
412
                                /*
438
413
                                 * We set retry iterator to max value to not retry
439
414
                                 * when service is already know as die.
440
415
                                 */
441
 
                                http_arg_obj->retry_it = http_get_check->nb_get_retry;
 
416
                                http_arg->retry_it = http_get_check->nb_get_retry;
442
417
                        }
443
 
                        return epilog(thread_obj, 2, 0, 1);
 
418
                        return epilog(thread, 2, 0, 1);
444
419
                } else {
445
 
                        if (!svr_checker_up(checker_obj->id, checker_obj->rs))
 
420
                        if (!svr_checker_up(checker->id, checker->rs))
446
421
                                log_message(LOG_INFO,
447
 
                                       "HTTP status code success to [%s:%d] url(%d).",
448
 
                                       inet_ntop2(CHECKER_RIP(checker_obj))
449
 
                                       , ntohs(addr_port)
450
 
                                       , http_arg_obj->url_it + 1);
451
 
                        return epilog(thread_obj, 1, 1, 0) + 1;
 
422
                                       "HTTP status code success to [%s]:%d url(%d)."
 
423
                                       , inet_sockaddrtos(&http_get_check->dst)
 
424
                                       , ntohs(inet_sockaddrport(&http_get_check->dst))
 
425
                                       , http_arg->url_it + 1);
 
426
                        return epilog(thread, 1, 1, 0) + 1;
452
427
                }
453
428
        }
454
429
 
463
438
 
464
439
                if (r) {
465
440
                        /* check if server is currently alive */
466
 
                        if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
 
441
                        if (svr_checker_up(checker->id, checker->rs)) {
467
442
                                log_message(LOG_INFO,
468
 
                                       "MD5 digest error to [%s:%d] url[%s]"
 
443
                                       "MD5 digest error to [%s]:%d url[%s]"
469
444
                                       ", MD5SUM [%s].",
470
 
                                       inet_ntop2(CHECKER_RIP(checker_obj)),
471
 
                                       ntohs(addr_port), fetched_url->path,
 
445
                                       inet_sockaddrtos(&http_get_check->dst),
 
446
                                       ntohs(inet_sockaddrport(&http_get_check->dst)),
 
447
                                       fetched_url->path,
472
448
                                       digest_tmp);
473
 
                                smtp_alert(checker_obj->rs, NULL, NULL,
 
449
                                smtp_alert(checker->rs, NULL, NULL,
474
450
                                           "DOWN",
475
451
                                           "=> CHECK failed on service"
476
452
                                           " : HTTP MD5SUM mismatch <=");
477
 
                                update_svr_checker_state(DOWN, checker_obj->id
478
 
                                                             , checker_obj->vs
479
 
                                                             , checker_obj->rs);
 
453
                                update_svr_checker_state(DOWN, checker->id
 
454
                                                             , checker->vs
 
455
                                                             , checker->rs);
480
456
                        } else {
481
 
                                DBG("MD5SUM to [%s:%d] url(%d) = [%s].",
482
 
                                    inet_ntop2(CHECKER_RIP(checker_obj))
483
 
                                    , ntohs(addr_port)
484
 
                                    , http_arg_obj->url_it + 1
 
457
                                DBG("MD5SUM to [%s]:%d url(%d) = [%s]."
 
458
                                    , inet_sockaddrtos(&http_get_check->dst)
 
459
                                    , ntohs(inet_sockaddrport(&http_get_check->dst))
 
460
                                    , http_arg->url_it + 1
485
461
                                    , digest_tmp);
486
462
                                /*
487
463
                                 * We set retry iterator to max value to not retry
488
464
                                 * when service is already know as die.
489
465
                                 */
490
 
                                http_arg_obj->retry_it = http_get_check->nb_get_retry;
 
466
                                http_arg->retry_it = http_get_check->nb_get_retry;
491
467
                        }
492
468
                        FREE(digest_tmp);
493
 
                        return epilog(thread_obj, 2, 0, 1);
 
469
                        return epilog(thread, 2, 0, 1);
494
470
                } else {
495
 
                        if (!svr_checker_up(checker_obj->id, checker_obj->rs))
496
 
                                log_message(LOG_INFO, "MD5 digest success to [%s:%d] url(%d).",
497
 
                                       inet_ntop2(CHECKER_RIP(checker_obj))
498
 
                                       , ntohs(addr_port)
499
 
                                       , http_arg_obj->url_it + 1);
 
471
                        if (!svr_checker_up(checker->id, checker->rs))
 
472
                                log_message(LOG_INFO, "MD5 digest success to [%s]:%d url(%d)."
 
473
                                       , inet_sockaddrtos(&http_get_check->dst)
 
474
                                       , ntohs(inet_sockaddrport(&http_get_check->dst))
 
475
                                       , http_arg->url_it + 1);
500
476
                        FREE(digest_tmp);
501
 
                        return epilog(thread_obj, 1, 1, 0) + 1;
 
477
                        return epilog(thread, 1, 1, 0) + 1;
502
478
                }
503
479
        }
504
480
 
505
 
        return epilog(thread_obj, 1, 0, 0) + 1;
 
481
        return epilog(thread, 1, 0, 0) + 1;
506
482
}
507
483
 
508
484
/* Handle response stream performing MD5 updates */
509
485
int
510
 
http_process_response(REQ *req, int r)
 
486
http_process_response(request_t *req, int r)
511
487
{
512
488
        req->len += r;
513
489
        if (!req->extracted) {
533
509
 
534
510
/* Asynchronous HTTP stream reader */
535
511
int
536
 
http_read_thread(thread * thread_obj)
 
512
http_read_thread(thread_t * thread)
537
513
{
538
 
        checker *checker_obj = THREAD_ARG(thread_obj);
539
 
        http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
540
 
        http_arg *http_arg_obj = HTTP_ARG(http_get_check);
541
 
        REQ *req = HTTP_REQ(http_arg_obj);
542
 
        uint16_t addr_port = get_service_port(checker_obj);
 
514
        checker_t *checker = THREAD_ARG(thread);
 
515
        http_checker_t *http_get_check = CHECKER_ARG(checker);
 
516
        http_arg_t *http_arg = HTTP_ARG(http_get_check);
 
517
        request_t *req = HTTP_REQ(http_arg);
543
518
        unsigned char digest[16];
544
519
        int r = 0;
545
520
        int val;
546
521
 
547
522
        /* Handle read timeout */
548
 
        if (thread_obj->type == THREAD_READ_TIMEOUT)
549
 
                return timeout_epilog(thread_obj, "=> HTTP CHECK failed on service"
 
523
        if (thread->type == THREAD_READ_TIMEOUT)
 
524
                return timeout_epilog(thread, "=> HTTP CHECK failed on service"
550
525
                                      " : recevice data <=\n\n", "HTTP read");
551
526
 
552
527
        /* Set descriptor non blocking */
553
 
        val = fcntl(thread_obj->u.fd, F_GETFL, 0);
554
 
        fcntl(thread_obj->u.fd, F_SETFL, val | O_NONBLOCK);
 
528
        val = fcntl(thread->u.fd, F_GETFL, 0);
 
529
        fcntl(thread->u.fd, F_SETFL, val | O_NONBLOCK);
555
530
 
556
531
        /* read the HTTP stream */
557
 
        r = read(thread_obj->u.fd, req->buffer + req->len,
 
532
        r = read(thread->u.fd, req->buffer + req->len,
558
533
                 MAX_BUFFER_LENGTH - req->len);
559
534
 
560
535
        /* restore descriptor flags */
561
 
        fcntl(thread_obj->u.fd, F_SETFL, val);
 
536
        fcntl(thread->u.fd, F_SETFL, val);
562
537
 
563
538
        /* Test if data are ready */
564
539
        if (r == -1 && (errno == EAGAIN || errno == EINTR)) {
565
 
                log_message(LOG_INFO, "Read error with server [%s:%d]: %s",
566
 
                       inet_ntop2(CHECKER_RIP(checker_obj))
567
 
                       , ntohs(addr_port)
568
 
                       , strerror(errno));
569
 
                thread_add_read(thread_obj->master, http_read_thread, checker_obj,
570
 
                                thread_obj->u.fd, http_get_check->connection_to);
 
540
                log_message(LOG_INFO, "Read error with server [%s]:%d: %s"
 
541
                                    , inet_sockaddrtos(&http_get_check->dst)
 
542
                                    , ntohs(inet_sockaddrport(&http_get_check->dst))
 
543
                                    , strerror(errno));
 
544
                thread_add_read(thread->master, http_read_thread, checker,
 
545
                                thread->u.fd, http_get_check->connection_to);
571
546
                return 0;
572
547
        }
573
548
 
578
553
 
579
554
                if (r == -1) {
580
555
                        /* We have encourred a real read error */
581
 
                        if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
582
 
                                log_message(LOG_INFO, "Read error with server [%s:%d]: %s",
583
 
                                       inet_ntop2(CHECKER_RIP(checker_obj))
584
 
                                       , ntohs(addr_port)
 
556
                        if (svr_checker_up(checker->id, checker->rs)) {
 
557
                                log_message(LOG_INFO, "Read error with server [%s]:%d: %s"
 
558
                                       , inet_sockaddrtos(&http_get_check->dst)
 
559
                                       , ntohs(inet_sockaddrport(&http_get_check->dst))
585
560
                                       , strerror(errno));
586
 
                                smtp_alert(checker_obj->rs, NULL, NULL,
 
561
                                smtp_alert(checker->rs, NULL, NULL,
587
562
                                           "DOWN",
588
563
                                           "=> HTTP CHECK failed on service"
589
564
                                           " : cannot receive data <=");
590
 
                                update_svr_checker_state(DOWN, checker_obj->id
591
 
                                                             , checker_obj->vs
592
 
                                                             , checker_obj->rs);
 
565
                                update_svr_checker_state(DOWN, checker->id
 
566
                                                             , checker->vs
 
567
                                                             , checker->rs);
593
568
                        }
594
 
                        return epilog(thread_obj, 1, 0, 0);
 
569
                        return epilog(thread, 1, 0, 0);
595
570
                }
596
571
 
597
572
                /* Handle response stream */
598
 
                http_handle_response(thread_obj, digest, (!req->extracted) ? 1 : 0);
 
573
                http_handle_response(thread, digest, (!req->extracted) ? 1 : 0);
599
574
 
600
575
        } else {
601
576
 
606
581
                 * Register next http stream reader.
607
582
                 * Register itself to not perturbe global I/O multiplexer.
608
583
                 */
609
 
                thread_add_read(thread_obj->master, http_read_thread, checker_obj,
610
 
                                thread_obj->u.fd, http_get_check->connection_to);
 
584
                thread_add_read(thread->master, http_read_thread, checker,
 
585
                                thread->u.fd, http_get_check->connection_to);
611
586
        }
612
587
 
613
588
        return 0;
618
593
 * Apply trigger check to this result.
619
594
 */
620
595
int
621
 
http_response_thread(thread * thread_obj)
 
596
http_response_thread(thread_t * thread)
622
597
{
623
 
        checker *checker_obj = THREAD_ARG(thread_obj);
624
 
        http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
625
 
        http_arg *http_arg_obj = HTTP_ARG(http_get_check);
626
 
        REQ *req = HTTP_REQ(http_arg_obj);
 
598
        checker_t *checker = THREAD_ARG(thread);
 
599
        http_checker_t *http_get_check = CHECKER_ARG(checker);
 
600
        http_arg_t *http_arg = HTTP_ARG(http_get_check);
 
601
        request_t *req = HTTP_REQ(http_arg);
627
602
 
628
603
        /* Handle read timeout */
629
 
        if (thread_obj->type == THREAD_READ_TIMEOUT)
630
 
                return timeout_epilog(thread_obj, "=> CHECK failed on service"
 
604
        if (thread->type == THREAD_READ_TIMEOUT)
 
605
                return timeout_epilog(thread, "=> CHECK failed on service"
631
606
                                      " : recevice data <=\n\n", "WEB read");
632
607
 
633
608
        /* Allocate & clean the get buffer */
639
614
 
640
615
        /* Register asynchronous http/ssl read thread */
641
616
        if (http_get_check->proto == PROTO_SSL)
642
 
                thread_add_read(thread_obj->master, ssl_read_thread, checker_obj,
643
 
                                thread_obj->u.fd, http_get_check->connection_to);
 
617
                thread_add_read(thread->master, ssl_read_thread, checker,
 
618
                                thread->u.fd, http_get_check->connection_to);
644
619
        else
645
 
                thread_add_read(thread_obj->master, http_read_thread, checker_obj,
646
 
                                thread_obj->u.fd, http_get_check->connection_to);
 
620
                thread_add_read(thread->master, http_read_thread, checker,
 
621
                                thread->u.fd, http_get_check->connection_to);
647
622
        return 0;
648
623
}
649
624
 
650
625
/* remote Web server is connected, send it the get url query.  */
651
626
int
652
 
http_request_thread(thread * thread_obj)
 
627
http_request_thread(thread_t * thread)
653
628
{
654
 
        checker *checker_obj = THREAD_ARG(thread_obj);
655
 
        http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
656
 
        http_arg *http_arg_obj = HTTP_ARG(http_get_check);
657
 
        REQ *req = HTTP_REQ(http_arg_obj);
658
 
        uint16_t addr_port = get_service_port(checker_obj);
659
 
        char *vhost = CHECKER_VHOST(checker_obj);
 
629
        checker_t *checker = THREAD_ARG(thread);
 
630
        http_checker_t *http_get_check = CHECKER_ARG(checker);
 
631
        http_arg_t *http_arg = HTTP_ARG(http_get_check);
 
632
        request_t *req = HTTP_REQ(http_arg);
 
633
        char *vhost = CHECKER_VHOST(checker);
660
634
        char *str_request;
661
 
        url *fetched_url;
 
635
        url_t *fetched_url;
662
636
        int ret = 0;
663
637
        int val;
664
638
 
665
639
        /* Handle read timeout */
666
 
        if (thread_obj->type == THREAD_WRITE_TIMEOUT)
667
 
                return timeout_epilog(thread_obj, "=> CHECK failed on service"
 
640
        if (thread->type == THREAD_WRITE_TIMEOUT)
 
641
                return timeout_epilog(thread, "=> CHECK failed on service"
668
642
                                      " : read timeout <=\n\n",
669
643
                                      "Web read, timeout");
670
644
 
674
648
        fetched_url = fetch_next_url(http_get_check);
675
649
        snprintf(str_request, GET_BUFFER_LENGTH, REQUEST_TEMPLATE,
676
650
                 fetched_url->path,
677
 
                 (vhost) ? vhost : inet_ntop2(CHECKER_RIP(checker_obj))
678
 
                 , ntohs(addr_port));
679
 
        DBG("Processing url(%d) of [%s:%d].",
680
 
            http_arg_obj->url_it + 1
681
 
            , inet_ntop2(CHECKER_RIP(checker_obj))
682
 
            , ntohs(addr_port));
 
651
                 (vhost) ? vhost : inet_sockaddrtos(&http_get_check->dst)
 
652
                 , ntohs(inet_sockaddrport(&http_get_check->dst)));
 
653
        DBG("Processing url(%d) of [%s]:%d.",
 
654
            http_arg->url_it + 1
 
655
            , inet_sockaddrtos(&http_get_check->dst)
 
656
            , ntohs(inet_sockaddrport(&http_get_check->dst)));
683
657
 
684
658
        /* Set descriptor non blocking */
685
 
        val = fcntl(thread_obj->u.fd, F_GETFL, 0);
686
 
        fcntl(thread_obj->u.fd, F_SETFL, val | O_NONBLOCK);
 
659
        val = fcntl(thread->u.fd, F_GETFL, 0);
 
660
        fcntl(thread->u.fd, F_SETFL, val | O_NONBLOCK);
687
661
 
688
662
        /* Send the GET request to remote Web server */
689
663
        if (http_get_check->proto == PROTO_SSL) {
690
664
                ret = ssl_send_request(req->ssl, str_request,
691
665
                                       strlen(str_request));
692
666
        } else {
693
 
                ret = (send(thread_obj->u.fd, str_request, strlen(str_request), 0) !=
 
667
                ret = (send(thread->u.fd, str_request, strlen(str_request), 0) !=
694
668
                       -1) ? 1 : 0;
695
669
        }
696
670
 
697
671
        /* restore descriptor flags */
698
 
        fcntl(thread_obj->u.fd, F_SETFL, val);
 
672
        fcntl(thread->u.fd, F_SETFL, val);
699
673
 
700
674
        FREE(str_request);
701
675
 
702
676
        if (!ret) {
703
 
                log_message(LOG_INFO, "Cannot send get request to [%s:%d].",
704
 
                       inet_ntop2(CHECKER_RIP(checker_obj))
705
 
                       , ntohs(addr_port));
 
677
                log_message(LOG_INFO, "Cannot send get request to [%s]:%d."
 
678
                                    , inet_sockaddrtos(&http_get_check->dst)
 
679
                                    , ntohs(inet_sockaddrport(&http_get_check->dst)));
706
680
 
707
681
                /* check if server is currently alive */
708
 
                if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
709
 
                        smtp_alert(checker_obj->rs, NULL, NULL,
 
682
                if (svr_checker_up(checker->id, checker->rs)) {
 
683
                        smtp_alert(checker->rs, NULL, NULL,
710
684
                                   "DOWN",
711
685
                                   "=> CHECK failed on service"
712
686
                                   " : cannot send data <=");
713
 
                        update_svr_checker_state(DOWN, checker_obj->id
714
 
                                                     , checker_obj->vs
715
 
                                                     , checker_obj->rs);
 
687
                        update_svr_checker_state(DOWN, checker->id
 
688
                                                     , checker->vs
 
689
                                                     , checker->rs);
716
690
                }
717
 
                return epilog(thread_obj, 1, 0, 0);
 
691
                return epilog(thread, 1, 0, 0);
718
692
        }
719
693
 
720
694
        /* Register read timeouted thread */
721
 
        thread_add_read(thread_obj->master, http_response_thread, checker_obj,
722
 
                        thread_obj->u.fd, http_get_check->connection_to);
 
695
        thread_add_read(thread->master, http_response_thread, checker,
 
696
                        thread->u.fd, http_get_check->connection_to);
723
697
        return 1;
724
698
}
725
699
 
726
700
/* WEB checkers threads */
727
701
int
728
 
http_check_thread(thread * thread_obj)
 
702
http_check_thread(thread_t * thread)
729
703
{
730
 
        checker *checker_obj = THREAD_ARG(thread_obj);
731
 
        http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
732
 
        uint16_t addr_port = get_service_port(checker_obj);
733
 
        http_arg *http_arg_obj = HTTP_ARG(http_get_check);
 
704
        checker_t *checker = THREAD_ARG(thread);
 
705
        http_checker_t *http_get_check = CHECKER_ARG(checker);
 
706
        http_arg_t *http_arg = HTTP_ARG(http_get_check);
734
707
#ifdef _DEBUG_
735
 
        REQ *req = HTTP_REQ(http_arg_obj);
 
708
        request_t *req = HTTP_REQ(http_arg);
736
709
#endif
737
710
        int ret = 1;
738
711
        int status;
740
713
        int ssl_err = 0;
741
714
        int new_req = 0;
742
715
 
743
 
        status = tcp_socket_state(thread_obj->u.fd, thread_obj, CHECKER_RIP(checker_obj)
744
 
                                  , addr_port, http_check_thread);
 
716
        status = tcp_socket_state(thread->u.fd, thread, http_check_thread);
745
717
        switch (status) {
746
718
        case connect_error:
747
719
                /* check if server is currently alive */
748
 
                if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
749
 
                        log_message(LOG_INFO, "Error connecting server [%s:%d].",
750
 
                               inet_ntop2(CHECKER_RIP(checker_obj))
751
 
                               , ntohs(addr_port));
752
 
                        smtp_alert(checker_obj->rs, NULL, NULL,
 
720
                if (svr_checker_up(checker->id, checker->rs)) {
 
721
                        log_message(LOG_INFO, "Error connecting server [%s]:%d."
 
722
                                            , inet_sockaddrtos(&http_get_check->dst)
 
723
                                            , ntohs(inet_sockaddrport(&http_get_check->dst)));
 
724
                        smtp_alert(checker->rs, NULL, NULL,
753
725
                                   "DOWN",
754
726
                                   "=> CHECK failed on service"
755
727
                                   " : connection error <=");
756
 
                        update_svr_checker_state(DOWN, checker_obj->id
757
 
                                                 , checker_obj->vs
758
 
                                                 , checker_obj->rs);
 
728
                        update_svr_checker_state(DOWN, checker->id
 
729
                                                 , checker->vs
 
730
                                                 , checker->rs);
759
731
                }
760
 
                return epilog(thread_obj, 1, 0, 0);
 
732
                return epilog(thread, 1, 0, 0);
761
733
                break;
762
734
 
763
735
        case connect_timeout:
764
 
                return timeout_epilog(thread_obj, "==> CHECK failed on service"
 
736
                return timeout_epilog(thread, "==> CHECK failed on service"
765
737
                                      " : connection timeout <=\n\n",
766
738
                                      "connect, timeout");
767
739
                break;
768
740
 
769
741
        case connect_success:{
770
 
                        if (!http_arg_obj->req) {
771
 
                                http_arg_obj->req = (REQ *) MALLOC(sizeof (REQ));
 
742
                        if (!http_arg->req) {
 
743
                                http_arg->req = (request_t *) MALLOC(sizeof (request_t));
772
744
                                new_req = 1;
773
745
                        } else
774
746
                                new_req = 0;
775
747
 
776
748
                        if (http_get_check->proto == PROTO_SSL) {
777
 
                                timeout = TIMER_LONG(thread_obj->sands)-TIMER_LONG(time_now);
778
 
                                if (thread_obj->type != THREAD_WRITE_TIMEOUT &&
779
 
                                    thread_obj->type != THREAD_READ_TIMEOUT)
780
 
                                        ret = ssl_connect(thread_obj, new_req);
 
749
                                timeout = TIMER_LONG(thread->sands)-TIMER_LONG(time_now);
 
750
                                if (thread->type != THREAD_WRITE_TIMEOUT &&
 
751
                                    thread->type != THREAD_READ_TIMEOUT)
 
752
                                        ret = ssl_connect(thread, new_req);
781
753
                                else {
782
 
                                        return timeout_epilog(thread_obj, "==> CHECK failed on service"
 
754
                                        return timeout_epilog(thread, "==> CHECK failed on service"
783
755
                                                              " : connection timeout <=\n\n",
784
756
                                                              "connect, timeout");
785
757
                                }
786
758
 
787
759
                                if (ret == -1) {
788
 
                                        switch ((ssl_err = SSL_get_error(http_arg_obj->req->ssl,
 
760
                                        switch ((ssl_err = SSL_get_error(http_arg->req->ssl,
789
761
                                                                         ret))) {
790
762
                                        case SSL_ERROR_WANT_READ:
791
 
                                                thread_add_read(thread_obj->master,
 
763
                                                thread_add_read(thread->master,
792
764
                                                                http_check_thread,
793
 
                                                                THREAD_ARG(thread_obj),
794
 
                                                                thread_obj->u.fd, timeout);
 
765
                                                                THREAD_ARG(thread),
 
766
                                                                thread->u.fd, timeout);
795
767
                                                break;
796
768
                                        case SSL_ERROR_WANT_WRITE:
797
 
                                                thread_add_write(thread_obj->master,
 
769
                                                thread_add_write(thread->master,
798
770
                                                                 http_check_thread,
799
 
                                                                 THREAD_ARG(thread_obj),
800
 
                                                                 thread_obj->u.fd, timeout);
 
771
                                                                 THREAD_ARG(thread),
 
772
                                                                 thread->u.fd, timeout);
801
773
                                                break;
802
774
                                        default:
803
775
                                                ret = 0;
813
785
                                /* Remote WEB server is connected.
814
786
                                 * Register the next step thread ssl_request_thread.
815
787
                                 */
816
 
                                DBG("Remote Web server [%s:%d] connected.",
817
 
                                    inet_ntop2(CHECKER_RIP(checker_obj)),
818
 
                                    ntohs(addr_port));
819
 
                                thread_add_write(thread_obj->master,
820
 
                                                 http_request_thread, checker_obj,
821
 
                                                 thread_obj->u.fd,
 
788
                                DBG("Remote Web server [%s]:%d connected."
 
789
                                    , inet_sockaddrtos(&http_get_check->dst)
 
790
                                    , ntohs(inet_sockaddrport(&http_get_check->dst)));
 
791
                                thread_add_write(thread->master,
 
792
                                                 http_request_thread, checker,
 
793
                                                 thread->u.fd,
822
794
                                                 http_get_check->connection_to);
823
795
                        } else {
824
 
                                DBG(LOG_INFO, "Connection trouble to: [%s:%d]."
825
 
                                    , inet_ntop2(CHECKER_RIP(checker_obj))
826
 
                                    , ntohs(addr_port));
 
796
                                DBG(LOG_INFO, "Connection trouble to: [%s]:%d."
 
797
                                            , inet_sockaddrtos(&http_get_check->dst)
 
798
                                            , ntohs(inet_sockaddrport(&http_get_check->dst)));
827
799
#ifdef _DEBUG_
828
800
                                if (http_get_check->proto == PROTO_SSL)
829
801
                                        ssl_printerr(SSL_get_error
830
802
                                                     (req->ssl, ret));
831
803
#endif
832
804
                                if ((http_get_check->proto == PROTO_SSL) &&
833
 
                                    (svr_checker_up(checker_obj->id, checker_obj->rs))) {
 
805
                                    (svr_checker_up(checker->id, checker->rs))) {
834
806
                                        log_message(LOG_INFO, "SSL handshake/communication error"
835
807
                                                         " connecting to server"
836
 
                                                         " (openssl errno: %d) [%s:%d]."
837
 
                                                       , SSL_get_error (http_arg_obj->req->ssl, ret)
838
 
                                                       , inet_ntop2(CHECKER_RIP(checker_obj))
839
 
                                                       , ntohs(addr_port));
840
 
                                        smtp_alert(checker_obj->rs, NULL, NULL,
 
808
                                                         " (openssl errno: %d) [%s]:%d."
 
809
                                                       , SSL_get_error (http_arg->req->ssl, ret)
 
810
                                                       , inet_sockaddrtos(&http_get_check->dst)
 
811
                                                       , ntohs(inet_sockaddrport(&http_get_check->dst)));
 
812
                                        smtp_alert(checker->rs, NULL, NULL,
841
813
                                                   "DOWN",
842
814
                                                   "=> CHECK failed on service"
843
815
                                                   " : SSL connection error <=");
844
 
                                        update_svr_checker_state(DOWN, checker_obj->id
845
 
                                                                 , checker_obj->vs
846
 
                                                                 , checker_obj->rs);
 
816
                                        update_svr_checker_state(DOWN, checker->id
 
817
                                                                 , checker->vs
 
818
                                                                 , checker->rs);
847
819
                                }
848
820
 
849
 
                                return epilog(thread_obj, 1, 0, 0);
 
821
                                return epilog(thread, 1, 0, 0);
850
822
                        }
851
823
                }
852
824
                break;
856
828
}
857
829
 
858
830
int
859
 
http_connect_thread(thread * thread_obj)
 
831
http_connect_thread(thread_t * thread)
860
832
{
861
 
        checker *checker_obj = THREAD_ARG(thread_obj);
862
 
        http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
863
 
        http_arg *http_arg_obj = HTTP_ARG(http_get_check);
864
 
        uint16_t addr_port = get_service_port(checker_obj);
865
 
        url *fetched_url;
 
833
        checker_t *checker = THREAD_ARG(thread);
 
834
        http_checker_t *http_get_check = CHECKER_ARG(checker);
 
835
        http_arg_t *http_arg = HTTP_ARG(http_get_check);
 
836
        url_t *fetched_url;
866
837
        enum connect_result status;
867
838
        int fd;
868
839
 
870
841
         * Register a new checker thread & return
871
842
         * if checker is disabled
872
843
         */
873
 
        if (!CHECKER_ENABLED(checker_obj)) {
874
 
                thread_add_timer(thread_obj->master, http_connect_thread, checker_obj,
875
 
                                 checker_obj->vs->delay_loop);
 
844
        if (!CHECKER_ENABLED(checker)) {
 
845
                thread_add_timer(thread->master, http_connect_thread, checker,
 
846
                                 checker->vs->delay_loop);
876
847
                return 0;
877
848
        }
878
849
 
884
855
                 * Check completed.
885
856
                 * check if server is currently alive.
886
857
                 */
887
 
                if (!svr_checker_up(checker_obj->id, checker_obj->rs)) {
888
 
                        log_message(LOG_INFO, "Remote Web server [%s:%d] succeed on service.",
889
 
                               inet_ntop2(CHECKER_RIP(checker_obj))
890
 
                               , ntohs(addr_port));
891
 
                        smtp_alert(checker_obj->rs, NULL, NULL, "UP",
 
858
                if (!svr_checker_up(checker->id, checker->rs)) {
 
859
                        log_message(LOG_INFO, "Remote Web server [%s]:%d succeed on service."
 
860
                                            , inet_sockaddrtos(&http_get_check->dst)
 
861
                                            , ntohs(inet_sockaddrport(&http_get_check->dst)));
 
862
                        smtp_alert(checker->rs, NULL, NULL, "UP",
892
863
                                   "=> CHECK succeed on service <=");
893
 
                        update_svr_checker_state(UP, checker_obj->id
894
 
                                                   , checker_obj->vs
895
 
                                                   , checker_obj->rs);
 
864
                        update_svr_checker_state(UP, checker->id
 
865
                                                   , checker->vs
 
866
                                                   , checker->rs);
896
867
                }
897
 
                http_arg_obj->req = NULL;
898
 
                return epilog(thread_obj, 1, 0, 0) + 1;
 
868
                http_arg->req = NULL;
 
869
                return epilog(thread, 1, 0, 0) + 1;
899
870
        }
900
871
 
901
872
        /* Create the socket */
902
 
        if ((fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
 
873
        if ((fd = socket(http_get_check->dst.ss_family, SOCK_STREAM, IPPROTO_TCP)) == -1) {
903
874
                DBG("WEB connection fail to create socket.");
904
875
                return 0;
905
876
        }
906
877
 
907
 
        status = tcp_bind_connect(fd, CHECKER_RIP(checker_obj), addr_port
908
 
                                  , http_get_check->bindto);
 
878
        status = tcp_bind_connect(fd, &http_get_check->dst, &http_get_check->bindto);
 
879
        if (status == connect_error) {
 
880
                thread_add_timer(thread->master, http_connect_thread, checker,
 
881
                                 checker->vs->delay_loop);
 
882
                return 0;
 
883
        }
909
884
 
910
885
        /* handle tcp connection status & register check worker thread */
911
 
        tcp_connection_state(fd, status, thread_obj, http_check_thread,
 
886
        tcp_connection_state(fd, status, thread, http_check_thread,
912
887
                             http_get_check->connection_to);
913
888
        return 0;
914
889
}