← Back to branch summary

~brianaker/gearmand/ssl-update

« back to all changes in this revision

Viewing changes to util/instance.cc

  • Committer: Continuous Integration
  • Date: 2013-08-09 19:42:53 UTC
  • mfrom: (847.2.5 gearmand-1.2)
  • Revision ID: ci@tangent.org-20130809194253-7qi3duw695qkhlwz
Merge lp:~brianaker/gearmand/ssl-update Build: jenkins-Gearmand-817

Show diffs side-by-side

added added

removed removed

Lines of Context:
util/instance.cc
39
39
#include "gear_config.h"
40
40
 
41
41
#include "util/instance.hpp"
 
42
#include "libgearman/ssl.h"
42
43
 
43
44
#include <cstdio>
44
45
#include <iostream>
101
102
 
102
103
  delete _finish_fn;
103
104
 
104
 
#if defined(HAVE_CYASSL) && HAVE_CYASSL
 
105
#if defined(HAVE_SSL) && HAVE_SSL
105
106
  if (_ssl)
106
107
  {
107
 
    CyaSSL_shutdown(_ssl);
108
 
    CyaSSL_free(_ssl);
 
108
    SSL_shutdown(_ssl);
 
109
    SSL_free(_ssl);
109
110
  }
 
111
 
110
112
  if (_ctx_ssl)
111
113
  {
112
 
    CyaSSL_CTX_free(_ctx_ssl);
 
114
    SSL_CTX_free(_ctx_ssl);
113
115
  }
 
116
# if defined(HAVE_CYASSL) && HAVE_CYASSL
114
117
  CyaSSL_Cleanup();
 
118
# endif // defined(HAVE_CYASSL)
115
119
#endif
116
120
}
117
121
 
118
122
bool Instance::init_ssl()
119
123
{
120
 
#if defined(HAVE_CYASSL) && HAVE_CYASSL
121
 
  CyaSSL_Init();
 
124
#if defined(HAVE_SSL) && HAVE_SSL
 
125
  SSL_load_error_strings();
 
126
  SSL_library_init();
122
127
 
123
 
  if ((_ctx_ssl= CyaSSL_CTX_new(CyaTLSv1_client_method())) == NULL)
 
128
  if ((_ctx_ssl= SSL_CTX_new(TLSv1_client_method())) == NULL)
124
129
  {
125
 
    _last_error= "CyaSSL_CTX_new error";
 
130
    _last_error= "SSL_CTX_new error";
126
131
    return false;
127
132
  }
128
133
 
129
 
  if (CyaSSL_CTX_load_verify_locations(_ctx_ssl, ssl_ca_file(), 0) != SSL_SUCCESS)
 
134
  if (SSL_CTX_load_verify_locations(_ctx_ssl, ssl_ca_file(), 0) != SSL_SUCCESS)
130
135
  {
131
136
    std::stringstream message;
132
137
    message << "Error loading CA file " << ssl_ca_file();
134
139
    return false;
135
140
  }
136
141
 
137
 
  if (CyaSSL_CTX_use_certificate_file(_ctx_ssl, ssl_certificate(), SSL_FILETYPE_PEM) != SSL_SUCCESS)
 
142
  if (SSL_CTX_use_certificate_file(_ctx_ssl, ssl_certificate(), SSL_FILETYPE_PEM) != SSL_SUCCESS)
138
143
  {
139
144
    std::stringstream message;
140
145
    message << "Error loading certificate file " << ssl_certificate();
142
147
    return false;
143
148
  }
144
149
 
145
 
  if (CyaSSL_CTX_use_PrivateKey_file(_ctx_ssl, ssl_key(), SSL_FILETYPE_PEM) != SSL_SUCCESS)
 
150
  if (SSL_CTX_use_PrivateKey_file(_ctx_ssl, ssl_key(), SSL_FILETYPE_PEM) != SSL_SUCCESS)
146
151
  {
147
152
    std::stringstream message;
148
153
    message << "Error loading private key file " << ssl_key();
252
257
        size_t packet_length= operation->size();
253
258
        const char *packet= operation->ptr();
254
259
 
255
 
#if defined(HAVE_CYASSL) && HAVE_CYASSL
 
260
#if defined(HAVE_SSL) && HAVE_SSL
256
261
        if (_ctx_ssl and not _ssl)
257
262
        {
258
 
          _ssl= CyaSSL_new(_ctx_ssl);
 
263
          _ssl= SSL_new(_ctx_ssl);
259
264
          if (_ssl == NULL)
260
265
          {
261
 
            _last_error= "CyaSSL_new() failed";
 
266
            _last_error= "SSL_new() failed";
262
267
            return false;
263
268
          }
264
269
 
265
270
          int ssl_error;
266
 
          if ((ssl_error= CyaSSL_set_fd(_ssl, _sockfd)) != SSL_SUCCESS)
 
271
          if ((ssl_error= SSL_set_fd(_ssl, _sockfd)) != SSL_SUCCESS)
267
272
          {
268
 
            _last_error= "CyaSSL_set_fd() failed";
 
273
            _last_error= "SSL_set_fd() failed";
269
274
            return false;
270
275
          }
271
276
        }
274
279
        while(packet_length)
275
280
        {
276
281
          ssize_t write_size;
277
 
#if defined(HAVE_CYASSL) && HAVE_CYASSL
 
282
#if defined(HAVE_SSL) && HAVE_SSL
278
283
          if (_ssl)
279
284
          {
280
 
            write_size= CyaSSL_write(_ssl, (const void*)packet, int(packet_length));
 
285
            write_size= SSL_write(_ssl, (const void*)packet, int(packet_length));
281
286
            if (write_size < 0)
282
287
            {
283
 
              char errorString[80];
284
 
              CyaSSL_ERR_error_string(CyaSSL_get_error(_ssl, 0), errorString);
 
288
              char errorString[SSL_ERROR_SIZE];
 
289
              ERR_error_string_n(SSL_get_error(_ssl, 0), errorString, sizeof(errorString));
285
290
              _last_error= errorString;
286
291
              return false;
287
292
            }
315
320
        do
316
321
        {
317
322
          char buffer[BUFSIZ];
318
 
#if defined(HAVE_CYASSL) && HAVE_CYASSL
 
323
#if defined(HAVE_SSL) && HAVE_SSL
319
324
          if (_ssl)
320
325
          {
321
 
            read_length= CyaSSL_read(_ssl, (void *)buffer, sizeof(buffer));
322
 
            if (read_length < 0)
 
326
            read_length= SSL_read(_ssl, (void *)buffer, sizeof(buffer));
 
327
            if (read_length == 0)
 
328
            { } // Socket has been closed
 
329
            else if (read_length < 0)
323
330
            {
324
 
              char errorString[80];
325
 
              CyaSSL_ERR_error_string(CyaSSL_get_error(_ssl, 0), errorString);
 
331
              char errorString[SSL_ERROR_SIZE];
 
332
              ERR_error_string_n(SSL_get_error(_ssl, 0), errorString, sizeof(errorString));
326
333
              _last_error= errorString;
327
334
              return false;
328
335
            }
333
340
            read_length= ::recv(_sockfd, buffer, sizeof(buffer), 0);
334
341
          }
335
342
 
336
 
          if (read_length < 0)
 
343
          if (read_length == 0)
 
344
          {
 
345
            _last_error.clear();
 
346
            _last_error+= "Socket was shutdown while reading from ";
 
347
            _last_error+= _host;
 
348
            return false;
 
349
          }
 
350
          else if (read_length < 0)
337
351
          {
338
352
            _last_error.clear();
339
353
            _last_error+= "Error occured while reading data from ";
340
354
            _last_error+= _host;
341
355
            return false;
342
356
          }
343
 
          else if (read_length == 0)
344
 
          {
345
 
            _last_error.clear();
346
 
            _last_error+= "Socket was shutdown while reading from ";
347
 
            _last_error+= _host;
348
 
            return false;
349
 
          }
350
357
 
351
358
          operation->push(buffer, static_cast<size_t>(read_length));
352
359
 
398
405
 
399
406
void Instance::close_socket()
400
407
{
401
 
  if (_sockfd == INVALID_SOCKET)
402
 
  {
403
 
    return;
404
 
  }
405
 
 
406
 
  /* in case of death shutdown to avoid blocking at close() */
407
 
  if (shutdown(_sockfd, SHUT_RDWR) == SOCKET_ERROR && get_socket_errno() != ENOTCONN)
408
 
  {
409
 
    perror("shutdown");
410
 
  }
411
 
  else if (closesocket(_sockfd) == SOCKET_ERROR)
412
 
  {
413
 
    perror("close");
414
 
  }
415
 
 
416
 
  _sockfd= INVALID_SOCKET;
 
408
  if (_sockfd != INVALID_SOCKET)
 
409
  {
 
410
    /* in case of death shutdown to avoid blocking at close() */
 
411
    if (shutdown(_sockfd, SHUT_RDWR) == SOCKET_ERROR && get_socket_errno() != ENOTCONN)
 
412
    {
 
413
      perror("shutdown");
 
414
    }
 
415
    else if (closesocket(_sockfd) == SOCKET_ERROR)
 
416
    {
 
417
      perror("close");
 
418
    }
 
419
 
 
420
    _sockfd= INVALID_SOCKET;
 
421
  }
417
422
}
418
423
 
419
424
void Instance::free_addrinfo()
420
425
{
421
 
  if (_addrinfo == NULL)
 
426
  if (_addrinfo)
422
427
  {
423
 
    return;
 
428
    freeaddrinfo(_addrinfo);
 
429
    _addrinfo= NULL;
 
430
    _addrinfo_next= NULL;
424
431
  }
425
 
 
426
 
  freeaddrinfo(_addrinfo);
427
 
  _addrinfo= NULL;
428
 
  _addrinfo_next= NULL;
429
432
}
430
433
 
431
434
} /* namespace util */