/**
* CURLSOAPTransport.cpp
*
- * libcurl-based SOAPTransport implementation
+ * libcurl-based SOAPTransport implementation.
*/
#include "internal.h"
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");
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);
}
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<const OpenSSLCredential*>(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<const OpenSSLTrustEngine*>(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;
send(&in);
}
- void send(istream* in=NULL);
+ void send(istream* in=nullptr);
istream& receive() {
return m_stream;
const vector<string>& 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;
void xmltooling::termSOAPTransports()
{
delete g_CURLPool;
- g_CURLPool = NULL;
+ g_CURLPool = nullptr;
}
OpenSSLSOAPTransport::OpenSSLSOAPTransport()
// 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);
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) {
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) {
}
// For libcurl, the option is an enum and the value type depends on the option.
- CURLoption opt = static_cast<CURLoption>(strtol(option, NULL, 10));
+ CURLoption opt = static_cast<CURLoption>(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
}
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 : "";
}
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());
}
// 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.
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 {
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);
// 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<int (*)()>(verify_callback),NULL);
+ SSL_CTX_set_cert_verify_callback(ssl_ctx,reinterpret_cast<int (*)()>(verify_callback),nullptr);
SSL_CTX_set_verify_depth(ssl_ctx,reinterpret_cast<int>(userptr));
#endif
}
projects / shibboleth / cpp-xmltooling.git / blobdiff