← Back to branch summary

~ubuntu-branches/ubuntu/trusty/keepalived/trusty

« back to all changes in this revision

Viewing changes to keepalived/check/check_ssl.c

  • Committer: Bazaar Package Importer
  • Author(s): Alexander Wirt
  • Date: 2005-04-29 23:22:40 UTC
  • mfrom: (1.1.1 upstream) (2.1.1 hoary)
  • Revision ID: james.westby@ubuntu.com-20050429232240-a8m3jtpi3cvuyyy2
Tags: 1.1.11-3
Added a warning about sarge kernels to README.Debian and 
the package description 

Show diffs side-by-side

added added

removed removed

Lines of Context:
keepalived/check/check_ssl.c
7
7
 *              url, compute a MD5 over this result and match it to the
8
8
 *              expected value.
9
9
 *
10
 
 * Version:     $Id: check_ssl.c,v 1.1.7 2004/04/04 23:28:05 acassen Exp $
 
10
 * Version:     $Id: check_ssl.c,v 1.1.11 2005/03/01 01:22:13 acassen Exp $
11
11
 *
12
12
 * Authors:     Alexandre Cassen, <acassen@linux-vs.org>
13
13
 *              Jan Holmberg, <jan@artech.net>
22
22
 *              as published by the Free Software Foundation; either version
23
23
 *              2 of the License, or (at your option) any later version.
24
24
 *
25
 
 * Copyright (C) 2001-2004 Alexandre Cassen, <acassen@linux-vs.org>
 
25
 * Copyright (C) 2001-2005 Alexandre Cassen, <acassen@linux-vs.org>
26
26
 */
27
27
 
28
28
#include <openssl/err.h>
34
34
#include "utils.h"
35
35
#include "html.h"
36
36
 
37
 
/* External vars */
38
 
extern check_conf_data *check_data;
39
 
 
40
37
/* SSL primitives */
41
38
/* Free an SSL context */
42
39
void
192
189
}
193
190
 
194
191
int
195
 
ssl_connect(thread * thread)
 
192
ssl_connect(thread * thread_obj)
196
193
{
197
 
        checker *checker = THREAD_ARG(thread);
198
 
        http_get_checker *http_get_check = CHECKER_ARG(checker);
199
 
        http_arg *http_arg = HTTP_ARG(http_get_check);
200
 
        REQ *req = HTTP_REQ(http_arg);
 
194
        checker *checker_obj = THREAD_ARG(thread_obj);
 
195
        http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
 
196
        http_arg *http_arg_obj = HTTP_ARG(http_get_check);
 
197
        REQ *req = HTTP_REQ(http_arg_obj);
201
198
 
202
199
        req->ssl = SSL_new(check_data->ssl->ctx);
203
 
        req->bio = BIO_new_socket(thread->u.fd, BIO_NOCLOSE);
 
200
        req->bio = BIO_new_socket(thread_obj->u.fd, BIO_NOCLOSE);
204
201
        SSL_set_bio(req->ssl, req->bio, req->bio);
205
202
 
206
203
        return (SSL_connect(req->ssl) > 0) ? 1 : 0;
228
225
 
229
226
/* Asynchronous SSL stream reader */
230
227
int
231
 
ssl_read_thread(thread * thread)
 
228
ssl_read_thread(thread * thread_obj)
232
229
{
233
 
        checker *checker = THREAD_ARG(thread);
234
 
        http_get_checker *http_get_check = CHECKER_ARG(checker);
235
 
        http_arg *http_arg = HTTP_ARG(http_get_check);
236
 
        REQ *req = HTTP_REQ(http_arg);
 
230
        checker *checker_obj = THREAD_ARG(thread_obj);
 
231
        http_get_checker *http_get_check = CHECKER_ARG(checker_obj);
 
232
        http_arg *http_arg_obj = HTTP_ARG(http_get_check);
 
233
        REQ *req = HTTP_REQ(http_arg_obj);
237
234
        unsigned char digest[16];
238
235
        int r = 0;
 
236
        int val;
239
237
 
240
238
        /* Handle read timeout */
241
 
        if (thread->type == THREAD_READ_TIMEOUT && !req->extracted)
242
 
                return timeout_epilog(thread, "=> SSL CHECK failed on service"
 
239
        if (thread_obj->type == THREAD_READ_TIMEOUT && !req->extracted)
 
240
                return timeout_epilog(thread_obj, "=> SSL CHECK failed on service"
243
241
                                      " : recevice data <=\n\n", "SSL read");
244
242
 
 
243
        /* Set descriptor non blocking */
 
244
        val = fcntl(thread_obj->u.fd, F_GETFL, 0);
 
245
        fcntl(thread_obj->u.fd, F_SETFL, val | O_NONBLOCK);
 
246
 
245
247
        /* read the SSL stream */
246
248
        r = SSL_read(req->ssl, req->buffer + req->len,
247
249
                     MAX_BUFFER_LENGTH - req->len);
 
250
 
 
251
        /* restore descriptor flags */
 
252
        fcntl(thread_obj->u.fd, F_SETFL, val);
 
253
 
248
254
        req->error = SSL_get_error(req->ssl, r);
249
255
 
250
256
        if (req->error) {
258
264
 
259
265
                if (r && !req->extracted) {
260
266
                        /* check if server is currently alive */
261
 
                        if (svr_checker_up(checker->id, checker->rs)) {
262
 
                                smtp_alert(thread->master, checker->rs, NULL, NULL,
 
267
                        if (svr_checker_up(checker_obj->id, checker_obj->rs)) {
 
268
                                smtp_alert(checker_obj->rs, NULL, NULL,
263
269
                                           "DOWN",
264
270
                                           "=> SSL CHECK failed on service"
265
271
                                           " : cannot receive data <=\n\n");
266
 
                                update_svr_checker_state(DOWN, checker->id
267
 
                                                             , checker->vs
268
 
                                                             , checker->rs);
 
272
                                update_svr_checker_state(DOWN, checker_obj->id
 
273
                                                             , checker_obj->vs
 
274
                                                             , checker_obj->rs);
269
275
                        }
270
 
                        return epilog(thread, 1, 0, 0);
 
276
                        return epilog(thread_obj, 1, 0, 0);
271
277
                }
272
278
 
273
279
                /* Handle response stream */
274
 
                http_handle_response(thread, digest, (!req->extracted) ? 1 : 0);
 
280
                http_handle_response(thread_obj, digest, (!req->extracted) ? 1 : 0);
275
281
 
276
282
        } else if (r > 0 && req->error == 0) {
277
283
 
282
288
                 * Register next ssl stream reader.
283
289
                 * Register itself to not perturbe global I/O multiplexer.
284
290
                 */
285
 
                thread_add_read(thread->master, ssl_read_thread, checker,
286
 
                                thread->u.fd, http_get_check->connection_to);
 
291
                thread_add_read(thread_obj->master, ssl_read_thread, checker_obj,
 
292
                                thread_obj->u.fd, http_get_check->connection_to);
287
293
        }
288
294
 
289
295
        return 0;