X-Git-Url: http://www.project-moonshot.org/gitweb/?p=shibboleth%2Fcpp-xmltooling.git;a=blobdiff_plain;f=xmltooling%2Fsoap%2Fimpl%2FCURLSOAPTransport.cpp;h=5dd48a3e38f5b3ad2307cbe8b91942a3ab4e6de6;hp=60e3e252db085d9ca0cf6e82d4bb851074271b2a;hb=a0d768778a8f5f539b909baf5b115e70ea765f0f;hpb=0c06299b0c4067705527f4d90eee69ee9b563c90 diff --git a/xmltooling/soap/impl/CURLSOAPTransport.cpp b/xmltooling/soap/impl/CURLSOAPTransport.cpp index 60e3e25..5dd48a3 100644 --- a/xmltooling/soap/impl/CURLSOAPTransport.cpp +++ b/xmltooling/soap/impl/CURLSOAPTransport.cpp @@ -17,7 +17,7 @@ /** * CURLSOAPTransport.cpp * - * libcurl-based SOAPTransport implementation + * libcurl-based SOAPTransport implementation. */ #include "internal.h" @@ -61,25 +61,25 @@ namespace xmltooling { Category& m_log; }; - static XMLTOOL_DLLLOCAL CURLPool* g_CURLPool = NULL; + static XMLTOOL_DLLLOCAL CURLPool* g_CURLPool = nullptr; class XMLTOOL_DLLLOCAL CURLSOAPTransport : public HTTPSOAPTransport, public OpenSSLSOAPTransport { public: CURLSOAPTransport(const Address& addr) : m_sender(addr.m_from ? addr.m_from : ""), m_peerName(addr.m_to ? addr.m_to : ""), m_endpoint(addr.m_endpoint), - m_handle(NULL), m_headers(NULL), + m_handle(nullptr), m_headers(nullptr), #ifndef XMLTOOLING_NO_XMLSEC - m_cred(NULL), m_trustEngine(NULL), m_peerResolver(NULL), m_mandatory(false), + m_cred(nullptr), m_trustEngine(nullptr), m_peerResolver(nullptr), m_mandatory(false), #endif - m_openssl_ops(SSL_OP_ALL|SSL_OP_NO_SSLv2), m_ssl_callback(NULL), m_ssl_userptr(NULL), - m_chunked(true), m_authenticated(false), m_cacheTag(NULL) { + m_openssl_ops(SSL_OP_ALL|SSL_OP_NO_SSLv2), m_ssl_callback(nullptr), m_ssl_userptr(nullptr), + m_chunked(true), m_authenticated(false), m_cacheTag(nullptr) { m_handle = g_CURLPool->get(addr); curl_easy_setopt(m_handle,CURLOPT_URL,addr.m_endpoint); curl_easy_setopt(m_handle,CURLOPT_CONNECTTIMEOUT,15); curl_easy_setopt(m_handle,CURLOPT_TIMEOUT,30); curl_easy_setopt(m_handle,CURLOPT_HTTPAUTH,0); - curl_easy_setopt(m_handle,CURLOPT_USERPWD,NULL); + curl_easy_setopt(m_handle,CURLOPT_USERPWD,nullptr); curl_easy_setopt(m_handle,CURLOPT_SSL_VERIFYHOST,2); curl_easy_setopt(m_handle,CURLOPT_HEADERDATA,this); m_headers=curl_slist_append(m_headers,"Content-Type: text/xml"); @@ -87,8 +87,8 @@ namespace xmltooling { virtual ~CURLSOAPTransport() { curl_slist_free_all(m_headers); - curl_easy_setopt(m_handle,CURLOPT_ERRORBUFFER,NULL); - curl_easy_setopt(m_handle,CURLOPT_PRIVATE,m_authenticated ? "secure" : NULL); // Save off security "state". + curl_easy_setopt(m_handle,CURLOPT_ERRORBUFFER,nullptr); + curl_easy_setopt(m_handle,CURLOPT_PRIVATE,m_authenticated ? "secure" : nullptr); // Save off security "state". g_CURLPool->put(m_sender.c_str(), m_peerName.c_str(), m_endpoint.c_str(), m_handle); } @@ -104,35 +104,35 @@ namespace xmltooling { return (curl_easy_setopt(m_handle,CURLOPT_TIMEOUT,timeout)==CURLE_OK); } - bool setAuth(transport_auth_t authType, const char* username=NULL, const char* password=NULL); + bool setAuth(transport_auth_t authType, const char* username=nullptr, const char* password=nullptr); bool setVerifyHost(bool verify) { return (curl_easy_setopt(m_handle,CURLOPT_SSL_VERIFYHOST,verify ? 2 : 0)==CURLE_OK); } #ifndef XMLTOOLING_NO_XMLSEC - bool setCredential(const Credential* cred=NULL) { + bool setCredential(const Credential* cred=nullptr) { const OpenSSLCredential* down = dynamic_cast(cred); if (!down) { - m_cred = NULL; - return (cred==NULL); + m_cred = nullptr; + return (cred==nullptr); } m_cred = down; return true; } bool setTrustEngine( - const X509TrustEngine* trustEngine=NULL, - const CredentialResolver* peerResolver=NULL, - CredentialCriteria* criteria=NULL, + const X509TrustEngine* trustEngine=nullptr, + const CredentialResolver* peerResolver=nullptr, + CredentialCriteria* criteria=nullptr, bool mandatory=true ) { const OpenSSLTrustEngine* down = dynamic_cast(trustEngine); if (!down) { - m_trustEngine = NULL; - m_peerResolver = NULL; - m_criteria = NULL; - return (trustEngine==NULL); + m_trustEngine = nullptr; + m_peerResolver = nullptr; + m_criteria = nullptr; + return (trustEngine==nullptr); } m_trustEngine = down; m_peerResolver = peerResolver; @@ -159,7 +159,7 @@ namespace xmltooling { send(&in); } - void send(istream* in=NULL); + void send(istream* in=nullptr); istream& receive() { return m_stream; @@ -185,7 +185,7 @@ namespace xmltooling { const vector& getResponseHeader(const char* val) const; - bool setSSLCallback(ssl_ctx_callback_fn fn, void* userptr=NULL) { + bool setSSLCallback(ssl_ctx_callback_fn fn, void* userptr=nullptr) { m_ssl_callback=fn; m_ssl_userptr=userptr; return true; @@ -249,7 +249,7 @@ void xmltooling::initSOAPTransports() void xmltooling::termSOAPTransports() { delete g_CURLPool; - g_CURLPool = NULL; + g_CURLPool = nullptr; } OpenSSLSOAPTransport::OpenSSLSOAPTransport() @@ -305,14 +305,14 @@ CURL* CURLPool::get(const SOAPTransport::Address& addr) // Create a new connection and set non-varying options. CURL* handle=curl_easy_init(); if (!handle) - return NULL; + return nullptr; curl_easy_setopt(handle,CURLOPT_NOPROGRESS,1); curl_easy_setopt(handle,CURLOPT_NOSIGNAL,1); curl_easy_setopt(handle,CURLOPT_FAILONERROR,1); curl_easy_setopt(handle,CURLOPT_SSL_CIPHER_LIST,"ALL:!aNULL:!LOW:!EXPORT:!SSLv2"); // Verification of the peer is via TrustEngine only. curl_easy_setopt(handle,CURLOPT_SSL_VERIFYPEER,0); - curl_easy_setopt(handle,CURLOPT_CAINFO,NULL); + curl_easy_setopt(handle,CURLOPT_CAINFO,nullptr); curl_easy_setopt(handle,CURLOPT_HEADERFUNCTION,&curl_header_hook); curl_easy_setopt(handle,CURLOPT_WRITEFUNCTION,&curl_write_hook); curl_easy_setopt(handle,CURLOPT_DEBUGFUNCTION,&curl_debug_hook); @@ -334,7 +334,7 @@ void CURLPool::put(const char* from, const char* to, const char* endpoint, CURL* else i->second.push_back(handle); - CURL* killit=NULL; + CURL* killit=nullptr; if (++m_size > 256) { // Kick a handle out from the back of the bus. while (true) { @@ -366,7 +366,7 @@ bool CURLSOAPTransport::setAuth(transport_auth_t authType, const char* username, if (authType==transport_auth_none) { if (curl_easy_setopt(m_handle,CURLOPT_HTTPAUTH,0)!=CURLE_OK) return false; - return (curl_easy_setopt(m_handle,CURLOPT_USERPWD,NULL)==CURLE_OK); + return (curl_easy_setopt(m_handle,CURLOPT_USERPWD,nullptr)==CURLE_OK); } long flag=0; switch (authType) { @@ -410,28 +410,28 @@ bool CURLSOAPTransport::setProviderOption(const char* provider, const char* opti } // For libcurl, the option is an enum and the value type depends on the option. - CURLoption opt = static_cast(strtol(option, NULL, 10)); + CURLoption opt = static_cast(strtol(option, nullptr, 10)); if (opt < CURLOPTTYPE_OBJECTPOINT) - return (curl_easy_setopt(m_handle, opt, strtol(value, NULL, 10)) == CURLE_OK); + return (curl_easy_setopt(m_handle, opt, strtol(value, nullptr, 10)) == CURLE_OK); #ifdef CURLOPTTYPE_OFF_T else if (opt < CURLOPTTYPE_OFF_T) { if (value) m_saved_options.push_back(value); - return (curl_easy_setopt(m_handle, opt, value ? m_saved_options.back().c_str() : NULL) == CURLE_OK); + return (curl_easy_setopt(m_handle, opt, value ? m_saved_options.back().c_str() : nullptr) == CURLE_OK); } # ifdef HAVE_CURL_OFF_T else if (sizeof(curl_off_t) == sizeof(long)) - return (curl_easy_setopt(m_handle, opt, strtol(value, NULL, 10)) == CURLE_OK); + return (curl_easy_setopt(m_handle, opt, strtol(value, nullptr, 10)) == CURLE_OK); # else else if (sizeof(off_t) == sizeof(long)) - return (curl_easy_setopt(m_handle, opt, strtol(value, NULL, 10)) == CURLE_OK); + return (curl_easy_setopt(m_handle, opt, strtol(value, nullptr, 10)) == CURLE_OK); # endif return false; #else else { if (value) m_saved_options.push_back(value); - return (curl_easy_setopt(m_handle, opt, value ? m_saved_options.back().c_str() : NULL) == CURLE_OK); + return (curl_easy_setopt(m_handle, opt, value ? m_saved_options.back().c_str() : nullptr) == CURLE_OK); } #endif } @@ -458,7 +458,7 @@ const vector& CURLSOAPTransport::getResponseHeader(const char* name) con string CURLSOAPTransport::getContentType() const { - char* content_type=NULL; + char* content_type=nullptr; curl_easy_getinfo(m_handle,CURLINFO_CONTENT_TYPE,&content_type); return content_type ? content_type : ""; } @@ -504,7 +504,7 @@ void CURLSOAPTransport::send(istream* in) msg.append(buf,in->gcount()); } curl_easy_setopt(m_handle,CURLOPT_POST,1); - curl_easy_setopt(m_handle,CURLOPT_READFUNCTION,NULL); + curl_easy_setopt(m_handle,CURLOPT_READFUNCTION,nullptr); curl_easy_setopt(m_handle,CURLOPT_POSTFIELDS,msg.c_str()); curl_easy_setopt(m_handle,CURLOPT_POSTFIELDSIZE,msg.length()); } @@ -540,14 +540,14 @@ void CURLSOAPTransport::send(istream* in) // Restore security "state". Necessary because the callback only runs // when handshakes occur. Even new TCP connections won't execute it. - char* priv=NULL; + char* priv=nullptr; curl_easy_getinfo(m_handle,CURLINFO_PRIVATE,&priv); if (priv) m_authenticated=true; } else { - curl_easy_setopt(m_handle,CURLOPT_SSL_CTX_FUNCTION,NULL); - curl_easy_setopt(m_handle,CURLOPT_SSL_CTX_DATA,NULL); + curl_easy_setopt(m_handle,CURLOPT_SSL_CTX_FUNCTION,nullptr); + curl_easy_setopt(m_handle,CURLOPT_SSL_CTX_DATA,nullptr); } // Make the call. @@ -644,7 +644,7 @@ int xmltooling::verify_callback(X509_STORE_CTX* x509_ctx, void* arg) if (ctx->m_criteria) { ctx->m_criteria->setUsage(Credential::TLS_CREDENTIAL); // Bypass name check (handled for us by curl). - ctx->m_criteria->setPeerName(NULL); + ctx->m_criteria->setPeerName(nullptr); success = ctx->m_trustEngine->validate(x509_ctx->cert,x509_ctx->untrusted,*(ctx->m_peerResolver),ctx->m_criteria); } else { @@ -686,7 +686,7 @@ CURLcode xmltooling::xml_ssl_ctx_callback(CURL* curl, SSL_CTX* ssl_ctx, void* us conf->m_cred->attach(ssl_ctx); if (conf->m_trustEngine) { - SSL_CTX_set_verify(ssl_ctx,SSL_VERIFY_PEER,NULL); + SSL_CTX_set_verify(ssl_ctx,SSL_VERIFY_PEER,nullptr); #if (OPENSSL_VERSION_NUMBER >= 0x00907000L) // With 0.9.7, we can pass a callback argument directly. SSL_CTX_set_cert_verify_callback(ssl_ctx,verify_callback,userptr); @@ -694,7 +694,7 @@ CURLcode xmltooling::xml_ssl_ctx_callback(CURL* curl, SSL_CTX* ssl_ctx, void* us // With 0.9.6, there's no argument, so we're going to use a really embarrassing hack and // stuff the argument in the depth property where it will get copied to the context object // that's handed to the callback. - SSL_CTX_set_cert_verify_callback(ssl_ctx,reinterpret_cast(verify_callback),NULL); + SSL_CTX_set_cert_verify_callback(ssl_ctx,reinterpret_cast(verify_callback),nullptr); SSL_CTX_set_verify_depth(ssl_ctx,reinterpret_cast(userptr)); #endif }