c++ - Boost access violation while deleting ssl::stream<ip::tcp::socket>* sslSocket -

while deleting sslsocket after successful connection made , used getting access violation

unhandled exception @ 0x770f32d0 in application_client_example.exe: 0xc0000005: access violation reading location 0x00000dd3c0c76c48.

the access violation coming part of boost code:

engine::~engine() {   if (ssl_get_app_data(ssl_))   {     delete static_cast<verify_callback_base*>(ssl_get_app_data(ssl_));     ssl_set_app_data(ssl_, 0);   }    ::bio_free(ext_bio_);   ::ssl_free(ssl_); } 

this code worked in boost version 1.47. changes have made updated boost libraries current version 1.53 , built 64 bit version of library , exe.

here ssl connection created , deleted:

// connect      sslsocket* socket = new sslsocket();      if ((errorcode = socket->connect((char*)server.c_str(), (char*)port.c_str())) != 0)      {         logger::log(log4cpp::priority::fatal, "secure socket error");          return errorcode;     }          delete socket 

here sslsocket destructor

sslsocket::~sslsocket(void) {     try {         sslsocket->shutdown();         delete sslsocket;     }     catch (std::exception& e)     {         std::string exception(e.what());         logger::log(log4cpp::priority::fatal, "[sslsocket] error deleting sslsocket. exception: " + exception);     }  } 

here def sslsocket. sslsocket wrapper class ssl socket:

#ifndef __sslsocket__ #define __sslsocket__  #include <boost/bind.hpp> #include <boost/asio.hpp> #include <boost/array.hpp> #include <boost/asio/ssl.hpp> #include <string>  #include "logger.h" #include "config.h"  using namespace boost::asio;  class sslsocket { private:     io_service io_service;     ssl::stream<ip::tcp::socket>* sslsocket;  public:     sslsocket(void);     ~sslsocket(void);      dword connect(char* remoteserver, char* remoteport);     dword sendstring(std::string data);     std::string receivestring(void); };  #endif 

here code use shut down socket connection in sslsockets class, wrapper around asio ssl connection. using boost asio version 1.52 windows 32 bit libraries. used receive exception when shutting down socket until discovered how properly:

void sslsocket::stop() {    // method calls shutdown method on socket in order stop reads or writes might going on.  if not done, exception thrown    // when comes time delete object.    //    boost::system::error_code ec;    try    {       // method can called handler well.  once shuttingdown flag set, don't go throught same code again.       if (shuttingdown)          return;       lockcode->acquire(); // single thread code.       // once.       if (!shuttingdown)       {          shuttingdown = true;          psocket->next_layer().cancel();          psocket->shutdown(ec);          // note ec have error condition, not seem problem.          delete psocket;          psocket = 0;          reqalive = false;          setevent(hevent);          ioservice->stop();          lobbysocketopen = false;          // wait until 2 threads have exited before returning.          workerthreads.join_all();       }       lockcode->release();       delete lockcode;       lockcode = 0;    }    catch (std::exception& e)    {       stringstream ss;       ss << "sslsocket::stop: threw error - " << e.what() << ".\n";       log.logstring(ss.str(), logerror);       stop();    } } 

in answer question lock variable

lock class encapsulates critical section (specific microsoft) code can single threaded. here definition it:

class lock { public:    lock()    {       ::initializecriticalsection(&cs);    }     ~lock()    {       ::deletecriticalsection(&cs);    }     void acquire()    {       ::entercriticalsection(&cs);    }     void release()    {       ::leavecriticalsection(&cs);    }  private:    lock(const lock&);    lock& operator=(const lock&);    critical_section cs; }; 

socket creation code

this code use create ssl context object , ssl socket object:

void sslsocket::connect(sslsocket* pssls, const string& serverpath, string& port) {    // connects server.    // serverpath - specifies path server.  can either ip address or url.    // port - port server listening on.    //    try    {       lockcode->acquire(); // single thread code.       // if user has tried connect before, make sure clean before trying again.       if (psocket)       {          delete psocket;          psocket = 0;       }                                                                                                         // if serverpath url, resolve address.       if ((serverpath[0] < '0') || (serverpath[0] > '9')) // assumes first char of server path not number when resolving ip addr.       {          // create resolver , query objects resolve host name in serverpath ip address.          boost::asio::ip::tcp::resolver resolver(*ioservice);          boost::asio::ip::tcp::resolver::query query(serverpath, port);          boost::asio::ip::tcp::resolver::iterator endpointiterator = resolver.resolve(query);          // set ssl context.          boost::asio::ssl::context ctx(*ioservice, boost::asio::ssl::context::tlsv1_client);          // specify not verify server certificiate right now.          ctx.set_verify_mode(boost::asio::ssl::context::verify_none);          // init socket object used communicate server.          psocket = new boost::asio::ssl::stream<boost::asio::ip::tcp::socket>(*ioservice, ctx);          //          // thread on now, user interface thread.  create thread handle incoming socket work messages.          // 1 thread created handle socket i/o reading , thread created handle writing.          if (!rcvthreadcreated)          {             workerthreads.create_thread(boost::bind(&sslsocket::rcvworkerthread, this));             rcvthreadcreated = true;             workerthreads.create_thread(boost::bind(&sslsocket::sendworkerthread, this));          }          // try connect server.  note - add timeout logic @ point.          boost::asio::async_connect(psocket->lowest_layer(), endpointiterator,             boost::bind(&sslsocket::handleconnect, this, boost::asio::placeholders::error));       }       else       {          // serverpath ip address, try connect using that.          //          stringstream ss1;          boost::system::error_code ec;          ss1 << "sslsocket::connect: preparing connect game server " << serverpath << " : " << port << ".\n";          log.logstring(ss1.str(), loginfo);          // create endpoint specified ip address.          const boost::asio::ip::address ip(boost::asio::ip::address::from_string(serverpath));          int iport = atoi(port.c_str());          const boost::asio::ip::tcp::endpoint ep(ip, iport);          // set ssl context.          boost::asio::ssl::context ctx(*ioservice, boost::asio::ssl::context::tlsv1_client);          // specify not verify server certificiate right now.          ctx.set_verify_mode(boost::asio::ssl::context::verify_none);          // init socket object used communicate server.          psocket = new boost::asio::ssl::stream<boost::asio::ip::tcp::socket>(*ioservice, ctx);          //          // try connect server.  note - add timeout logic @ point.          psocket->next_layer().connect(ep, ec);          if (ec)          {             // log error.  worker thread should exit gracefully after this.             stringstream ss;             ss << "sslsocket::connect: connect failed " << sclientip << " : " << uiclientport << ".  error: " << ec.message() + ".\n";             log.logstring(ss.str(), logerror);          }          stringstream ss;          ss << "sslsocket::connect: calling handleconnect game server " << serverpath << " : " << port << ".\n";          log.logstring(ss.str(), loginfo);          handleconnect(ec);       }    }    catch (std::exception& e)    {       stringstream ss;       ss << "sslsocket::connect: threw error - " << e.what() << ".\n";       log.logstring(ss.str(), logerror);       stop();    }    lockcode->release(); }