Boost/C++11 shared pointers.

10 files changed, 267 insertions, 265 deletions

diff --git a/src/net/imap/IMAPConnection.cpp b/src/net/imap/IMAPConnection.cpp
index 53f8ba9f..0dba1ecc 100644
--- a/src/net/imap/IMAPConnection.cpp
+++ b/src/net/imap/IMAPConnection.cpp
@@ -53,11 +53,11 @@
 
 // Helpers for service properties
 #define GET_PROPERTY(type, prop) \
-	(m_store.acquire()->getInfos().getPropertyValue <type>(getSession(), \
-		dynamic_cast <const IMAPServiceInfos&>(m_store.acquire()->getInfos()).getProperties().prop))
+	(m_store.lock()->getInfos().getPropertyValue <type>(getSession(), \
+		dynamic_cast <const IMAPServiceInfos&>(m_store.lock()->getInfos()).getProperties().prop))
 #define HAS_PROPERTY(prop) \
-	(m_store.acquire()->getInfos().hasProperty(getSession(), \
-		dynamic_cast <const IMAPServiceInfos&>(m_store.acquire()->getInfos()).getProperties().prop))
+	(m_store.lock()->getInfos().hasProperty(getSession(), \
+		dynamic_cast <const IMAPServiceInfos&>(m_store.lock()->getInfos()).getProperties().prop))
 
 
 namespace vmime {
@@ -65,9 +65,9 @@ namespace net {
 namespace imap {
 
 
-IMAPConnection::IMAPConnection(ref <IMAPStore> store, ref <security::authenticator> auth)
-	: m_store(store), m_auth(auth), m_socket(NULL), m_parser(NULL), m_tag(NULL),
-	  m_hierarchySeparator('\0'), m_state(STATE_NONE), m_timeoutHandler(NULL),
+IMAPConnection::IMAPConnection(shared_ptr <IMAPStore> store, shared_ptr <security::authenticator> auth)
+	: m_store(store), m_auth(auth), m_socket(null), m_parser(null), m_tag(null),
+	  m_hierarchySeparator('\0'), m_state(STATE_NONE), m_timeoutHandler(null),
 	  m_secured(false), m_firstTag(true), m_capabilitiesFetched(false), m_noModSeq(false)
 {
 }
@@ -100,7 +100,7 @@ void IMAPConnection::connect()
 	const string address = GET_PROPERTY(string, PROPERTY_SERVER_ADDRESS);
 	const port_t port = GET_PROPERTY(port_t, PROPERTY_SERVER_PORT);
 
-	ref <IMAPStore> store = m_store.acquire();
+	shared_ptr <IMAPStore> store = m_store.lock();
 
 	// Create the time-out handler
 	if (store->getTimeoutHandlerFactory())
@@ -112,29 +112,29 @@ void IMAPConnection::connect()
 #if VMIME_HAVE_TLS_SUPPORT
 	if (store->isIMAPS())  // dedicated port/IMAPS
 	{
-		ref <tls::TLSSession> tlsSession = tls::TLSSession::create
+		shared_ptr <tls::TLSSession> tlsSession = tls::TLSSession::create
 			(store->getCertificateVerifier(),
 			 store->getSession()->getTLSProperties());
 
-		ref <tls::TLSSocket> tlsSocket =
+		shared_ptr <tls::TLSSocket> tlsSocket =
 			tlsSession->getSocket(m_socket);
 
 		m_socket = tlsSocket;
 
 		m_secured = true;
-		m_cntInfos = vmime::create <tls::TLSSecuredConnectionInfos>(address, port, tlsSession, tlsSocket);
+		m_cntInfos = make_shared <tls::TLSSecuredConnectionInfos>(address, port, tlsSession, tlsSocket);
 	}
 	else
 #endif // VMIME_HAVE_TLS_SUPPORT
 	{
-		m_cntInfos = vmime::create <defaultConnectionInfos>(address, port);
+		m_cntInfos = make_shared <defaultConnectionInfos>(address, port);
 	}
 
 	m_socket->connect(address, port);
 
 
-	m_tag = vmime::create <IMAPTag>();
-	m_parser = vmime::create <IMAPParser>(m_tag, m_socket, m_timeoutHandler);
+	m_tag = make_shared <IMAPTag>();
+	m_parser = make_shared <IMAPParser>(m_tag, m_socket, m_timeoutHandler);
 
 
 	setState(STATE_NON_AUTHENTICATED);
@@ -145,7 +145,7 @@ void IMAPConnection::connect()
 	// eg:  C: <connection to server>
 	// ---  S: * OK mydomain.org IMAP4rev1 v12.256 server ready
 
-	utility::auto_ptr <IMAPParser::greeting> greet(m_parser->readGreeting());
+	std::auto_ptr <IMAPParser::greeting> greet(m_parser->readGreeting());
 	bool needAuth = false;
 
 	if (greet->resp_cond_bye())
@@ -223,7 +223,7 @@ void IMAPConnection::connect()
 
 void IMAPConnection::authenticate()
 {
-	getAuthenticator()->setService(m_store.acquire());
+	getAuthenticator()->setService(m_store.lock());
 
 #if VMIME_HAVE_SASL_SUPPORT
 	// First, try SASL authentication
@@ -262,7 +262,7 @@ void IMAPConnection::authenticate()
 	send(true, "LOGIN " + IMAPUtils::quoteString(username)
 		+ " " + IMAPUtils::quoteString(password), true);
 
-	utility::auto_ptr <IMAPParser::response> resp(m_parser->readResponse());
+	std::auto_ptr <IMAPParser::response> resp(m_parser->readResponse());
 
 	if (resp->isBad())
 	{
@@ -277,7 +277,7 @@ void IMAPConnection::authenticate()
 	}
 
 	// Server capabilities may change when logged in
-	if (!processCapabilityResponseData(resp))
+	if (!processCapabilityResponseData(resp.get()))
 		invalidateCapabilities();
 }
 
@@ -286,7 +286,7 @@ void IMAPConnection::authenticate()
 
 void IMAPConnection::authenticateSASL()
 {
-	if (!getAuthenticator().dynamicCast <security::sasl::SASLAuthenticator>())
+	if (!dynamicCast <security::sasl::SASLAuthenticator>(getAuthenticator()))
 		throw exceptions::authentication_error("No SASL authenticator available.");
 
 	const std::vector <string> capa = getCapabilities();
@@ -310,10 +310,10 @@ void IMAPConnection::authenticateSASL()
 	if (saslMechs.empty())
 		throw exceptions::authentication_error("No SASL mechanism available.");
 
-	std::vector <ref <security::sasl::SASLMechanism> > mechList;
+	std::vector <shared_ptr <security::sasl::SASLMechanism> > mechList;
 
-	ref <security::sasl::SASLContext> saslContext =
-		vmime::create <security::sasl::SASLContext>();
+	shared_ptr <security::sasl::SASLContext> saslContext =
+		make_shared <security::sasl::SASLContext>();
 
 	for (unsigned int i = 0 ; i < saslMechs.size() ; ++i)
 	{
@@ -332,14 +332,14 @@ void IMAPConnection::authenticateSASL()
 		throw exceptions::authentication_error("No SASL mechanism available.");
 
 	// Try to suggest a mechanism among all those supported
-	ref <security::sasl::SASLMechanism> suggestedMech =
+	shared_ptr <security::sasl::SASLMechanism> suggestedMech =
 		saslContext->suggestMechanism(mechList);
 
 	if (!suggestedMech)
 		throw exceptions::authentication_error("Unable to suggest SASL mechanism.");
 
 	// Allow application to choose which mechanisms to use
-	mechList = getAuthenticator().dynamicCast <security::sasl::SASLAuthenticator>()->
+	mechList = dynamicCast <security::sasl::SASLAuthenticator>(getAuthenticator())->
 		getAcceptableMechanisms(mechList, suggestedMech);
 
 	if (mechList.empty())
@@ -348,9 +348,9 @@ void IMAPConnection::authenticateSASL()
 	// Try each mechanism in the list in turn
 	for (unsigned int i = 0 ; i < mechList.size() ; ++i)
 	{
-		ref <security::sasl::SASLMechanism> mech = mechList[i];
+		shared_ptr <security::sasl::SASLMechanism> mech = mechList[i];
 
-		ref <security::sasl::SASLSession> saslSession =
+		shared_ptr <security::sasl::SASLSession> saslSession =
 			saslContext->createSession("imap", getAuthenticator(), mech);
 
 		saslSession->init();
@@ -359,7 +359,7 @@ void IMAPConnection::authenticateSASL()
 
 		for (bool cont = true ; cont ; )
 		{
-			utility::auto_ptr <IMAPParser::response> resp(m_parser->readResponse());
+			std::auto_ptr <IMAPParser::response> resp(m_parser->readResponse());
 
 			if (resp->response_done() &&
 			    resp->response_done()->response_tagged() &&
@@ -466,7 +466,7 @@ void IMAPConnection::startTLS()
 	{
 		send(true, "STARTTLS", true);
 
-		utility::auto_ptr <IMAPParser::response> resp(m_parser->readResponse());
+		std::auto_ptr <IMAPParser::response> resp(m_parser->readResponse());
 
 		if (resp->isBad() || resp->response_done()->response_tagged()->
 			resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -475,11 +475,11 @@ void IMAPConnection::startTLS()
 				("STARTTLS", resp->getErrorLog(), "bad response");
 		}
 
-		ref <tls::TLSSession> tlsSession = tls::TLSSession::create
-			(m_store.acquire()->getCertificateVerifier(),
-			 m_store.acquire()->getSession()->getTLSProperties());
+		shared_ptr <tls::TLSSession> tlsSession = tls::TLSSession::create
+			(m_store.lock()->getCertificateVerifier(),
+			 m_store.lock()->getSession()->getTLSProperties());
 
-		ref <tls::TLSSocket> tlsSocket =
+		shared_ptr <tls::TLSSocket> tlsSocket =
 			tlsSession->getSocket(m_socket);
 
 		tlsSocket->handshake(m_timeoutHandler);
@@ -488,7 +488,7 @@ void IMAPConnection::startTLS()
 		m_parser->setSocket(m_socket);
 
 		m_secured = true;
-		m_cntInfos = vmime::create <tls::TLSSecuredConnectionInfos>
+		m_cntInfos = make_shared <tls::TLSSecuredConnectionInfos>
 			(m_cntInfos->getHost(), m_cntInfos->getPort(), tlsSession, tlsSocket);
 
 		// " Once TLS has been started, the client MUST discard cached
@@ -551,12 +551,12 @@ void IMAPConnection::fetchCapabilities()
 {
 	send(true, "CAPABILITY", true);
 
-	utility::auto_ptr <IMAPParser::response> resp(m_parser->readResponse());
+	std::auto_ptr <IMAPParser::response> resp(m_parser->readResponse());
 
 	if (resp->response_done()->response_tagged()->
 		resp_cond_state()->status() == IMAPParser::resp_cond_state::OK)
 	{
-		processCapabilityResponseData(resp);
+		processCapabilityResponseData(resp.get());
 	}
 }
 
@@ -604,7 +604,7 @@ void IMAPConnection::processCapabilityResponseData(const IMAPParser::capability_
 }
 
 
-ref <security::authenticator> IMAPConnection::getAuthenticator()
+shared_ptr <security::authenticator> IMAPConnection::getAuthenticator()
 {
 	return m_auth;
 }
@@ -623,7 +623,7 @@ bool IMAPConnection::isSecuredConnection() const
 }
 
 
-ref <connectionInfos> IMAPConnection::getConnectionInfos() const
+shared_ptr <connectionInfos> IMAPConnection::getConnectionInfos() const
 {
 	return m_cntInfos;
 }
@@ -645,15 +645,15 @@ void IMAPConnection::internalDisconnect()
 		send(true, "LOGOUT", true);
 
 		m_socket->disconnect();
-		m_socket = NULL;
+		m_socket = null;
 	}
 
-	m_timeoutHandler = NULL;
+	m_timeoutHandler = null;
 
 	m_state = STATE_LOGOUT;
 
 	m_secured = false;
-	m_cntInfos = NULL;
+	m_cntInfos = null;
 }
 
 
@@ -661,7 +661,7 @@ void IMAPConnection::initHierarchySeparator()
 {
 	send(true, "LIST \"\" \"\"", true);
 
-	vmime::utility::auto_ptr <IMAPParser::response> resp(m_parser->readResponse());
+	std::auto_ptr <IMAPParser::response> resp(m_parser->readResponse());
 
 	if (resp->isBad() || resp->response_done()->response_tagged()->
 		resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -769,25 +769,25 @@ char IMAPConnection::hierarchySeparator() const
 }
 
 
-ref <const IMAPStore> IMAPConnection::getStore() const
+shared_ptr <const IMAPStore> IMAPConnection::getStore() const
 {
-	return m_store.acquire();
+	return m_store.lock();
 }
 
 
-ref <IMAPStore> IMAPConnection::getStore()
+shared_ptr <IMAPStore> IMAPConnection::getStore()
 {
-	return m_store.acquire();
+	return m_store.lock();
 }
 
 
-ref <session> IMAPConnection::getSession()
+shared_ptr <session> IMAPConnection::getSession()
 {
-	return m_store.acquire()->getSession();
+	return m_store.lock()->getSession();
 }
 
 
-ref <const socket> IMAPConnection::getSocket() const
+shared_ptr <const socket> IMAPConnection::getSocket() const
 {
 	return m_socket;
 }
diff --git a/src/net/imap/IMAPFolder.cpp b/src/net/imap/IMAPFolder.cpp
index 3a3615e6..06d331df 100644
--- a/src/net/imap/IMAPFolder.cpp
+++ b/src/net/imap/IMAPFolder.cpp
@@ -39,7 +39,6 @@
 #include "vmime/message.hpp"
 
 #include "vmime/exception.hpp"
-#include "vmime/utility/smartPtr.hpp"
 
 #include "vmime/utility/outputStreamAdapter.hpp"
 
@@ -52,20 +51,20 @@ namespace net {
 namespace imap {
 
 
-IMAPFolder::IMAPFolder(const folder::path& path, ref <IMAPStore> store, const int type, const int flags)
+IMAPFolder::IMAPFolder(const folder::path& path, shared_ptr <IMAPStore> store, const int type, const int flags)
 	: m_store(store), m_connection(store->connection()), m_path(path),
 	  m_name(path.isEmpty() ? folder::path::component("") : path.getLastComponent()), m_mode(-1),
 	  m_open(false), m_type(type), m_flags(flags)
 {
 	store->registerFolder(this);
 
-	m_status = vmime::create <IMAPFolderStatus>();
+	m_status = make_shared <IMAPFolderStatus>();
 }
 
 
 IMAPFolder::~IMAPFolder()
 {
-	ref <IMAPStore> store = m_store.acquire();
+	shared_ptr <IMAPStore> store = m_store.lock();
 
 	if (store)
 	{
@@ -76,7 +75,7 @@ IMAPFolder::~IMAPFolder()
 	}
 	else if (m_open)
 	{
-		m_connection = NULL;
+		m_connection = null;
 		onClose();
 	}
 }
@@ -145,7 +144,7 @@ const folder::path IMAPFolder::getFullPath() const
 
 void IMAPFolder::open(const int mode, bool failIfModeIsNotAvailable)
 {
-	ref <IMAPStore> store = m_store.acquire();
+	shared_ptr <IMAPStore> store = m_store.lock();
 
 	if (!store)
 		throw exceptions::illegal_state("Store disconnected");
@@ -159,8 +158,8 @@ void IMAPFolder::open(const int mode, bool failIfModeIsNotAvailable)
 	}
 
 	// Open a connection for this folder
-	ref <IMAPConnection> connection =
-		vmime::create <IMAPConnection>(store, store->getAuthenticator());
+	shared_ptr <IMAPConnection> connection =
+		make_shared <IMAPConnection>(store, store->getAuthenticator());
 
 	try
 	{
@@ -193,7 +192,7 @@ void IMAPFolder::open(const int mode, bool failIfModeIsNotAvailable)
 		connection->send(true, oss.str(), true);
 
 		// Read the response
-		utility::auto_ptr <IMAPParser::response> resp(connection->readResponse());
+		std::auto_ptr <IMAPParser::response> resp(connection->readResponse());
 
 		if (resp->isBad() || resp->response_done()->response_tagged()->
 				resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -259,7 +258,7 @@ void IMAPFolder::open(const int mode, bool failIfModeIsNotAvailable)
 			}
 		}
 
-		processStatusUpdate(resp);
+		processStatusUpdate(resp.get());
 
 		// Check for access mode (read-only or read-write)
 		const IMAPParser::resp_text_code* respTextCode = resp->response_done()->
@@ -292,7 +291,7 @@ void IMAPFolder::open(const int mode, bool failIfModeIsNotAvailable)
 
 void IMAPFolder::close(const bool expunge)
 {
-	ref <IMAPStore> store = m_store.acquire();
+	shared_ptr <IMAPStore> store = m_store.lock();
 
 	if (!store)
 		throw exceptions::illegal_state("Store disconnected");
@@ -300,7 +299,7 @@ void IMAPFolder::close(const bool expunge)
 	if (!isOpen())
 		throw exceptions::illegal_state("Folder not open");
 
-	ref <IMAPConnection> oldConnection = m_connection;
+	shared_ptr <IMAPConnection> oldConnection = m_connection;
 
 	// Emit the "CLOSE" command to expunge messages marked
 	// as deleted (this is fastest than "EXPUNGE")
@@ -316,12 +315,12 @@ void IMAPFolder::close(const bool expunge)
 	oldConnection->disconnect();
 
 	// Now use default store connection
-	m_connection = m_store.acquire()->connection();
+	m_connection = m_store.lock()->connection();
 
 	m_open = false;
 	m_mode = -1;
 
-	m_status = vmime::create <IMAPFolderStatus>();
+	m_status = make_shared <IMAPFolderStatus>();
 
 	onClose();
 }
@@ -341,7 +340,7 @@ void IMAPFolder::onClose()
 
 void IMAPFolder::create(const int type)
 {
-	ref <IMAPStore> store = m_store.acquire();
+	shared_ptr <IMAPStore> store = m_store.lock();
 
 	if (!store)
 		throw exceptions::illegal_state("Store disconnected");
@@ -371,7 +370,7 @@ void IMAPFolder::create(const int type)
 	m_connection->send(true, oss.str(), true);
 
 
-	utility::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
+	std::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
 
 	if (resp->isBad() || resp->response_done()->response_tagged()->
 			resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -381,9 +380,9 @@ void IMAPFolder::create(const int type)
 	}
 
 	// Notify folder created
-	ref <events::folderEvent> event =
-		vmime::create <events::folderEvent>
-			(thisRef().dynamicCast <folder>(),
+	shared_ptr <events::folderEvent> event =
+		make_shared <events::folderEvent>
+			(dynamicCast <folder>(shared_from_this()),
 			 events::folderEvent::TYPE_CREATED, m_path, m_path);
 
 	notifyFolder(event);
@@ -392,7 +391,7 @@ void IMAPFolder::create(const int type)
 
 void IMAPFolder::destroy()
 {
-	ref <IMAPStore> store = m_store.acquire();
+	shared_ptr <IMAPStore> store = m_store.lock();
 
 	if (!store)
 		throw exceptions::illegal_state("Store disconnected");
@@ -409,7 +408,7 @@ void IMAPFolder::destroy()
 	m_connection->send(true, oss.str(), true);
 
 
-	utility::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
+	std::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
 
 	if (resp->isBad() || resp->response_done()->response_tagged()->
 			resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -419,9 +418,9 @@ void IMAPFolder::destroy()
 	}
 
 	// Notify folder deleted
-	ref <events::folderEvent> event =
-		vmime::create <events::folderEvent>
-			(thisRef().dynamicCast <folder>(),
+	shared_ptr <events::folderEvent> event =
+		make_shared <events::folderEvent>
+			(dynamicCast <folder>(shared_from_this()),
 			 events::folderEvent::TYPE_DELETED, m_path, m_path);
 
 	notifyFolder(event);
@@ -430,7 +429,7 @@ void IMAPFolder::destroy()
 
 bool IMAPFolder::exists()
 {
-	ref <IMAPStore> store = m_store.acquire();
+	shared_ptr <IMAPStore> store = m_store.lock();
 
 	if (!isOpen() && !store)
 		throw exceptions::illegal_state("Store disconnected");
@@ -470,7 +469,7 @@ int IMAPFolder::testExistAndGetType()
 	m_connection->send(true, oss.str(), true);
 
 
-	utility::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
+	std::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
 
 	if (resp->isBad() || resp->response_done()->response_tagged()->
 			resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -517,7 +516,7 @@ bool IMAPFolder::isOpen() const
 }
 
 
-ref <message> IMAPFolder::getMessage(const int num)
+shared_ptr <message> IMAPFolder::getMessage(const int num)
 {
 	if (!isOpen())
 		throw exceptions::illegal_state("Folder not open");
@@ -525,28 +524,28 @@ ref <message> IMAPFolder::getMessage(const int num)
 	if (num < 1 || num > m_status->getMessageCount())
 		throw exceptions::message_not_found();
 
-	return vmime::create <IMAPMessage>(thisRef().dynamicCast <IMAPFolder>(), num);
+	return make_shared <IMAPMessage>(dynamicCast <IMAPFolder>(shared_from_this()), num);
 }
 
 
-std::vector <ref <message> > IMAPFolder::getMessages(const messageSet& msgs)
+std::vector <shared_ptr <message> > IMAPFolder::getMessages(const messageSet& msgs)
 {
 	if (!isOpen())
 		throw exceptions::illegal_state("Folder not open");
 
 	if (msgs.isEmpty())
-		return std::vector <ref <message> >();
+		return std::vector <shared_ptr <message> >();
 
-	std::vector <ref <message> > messages;
+	std::vector <shared_ptr <message> > messages;
 
 	if (msgs.isNumberSet())
 	{
 		const std::vector <int> numbers = IMAPUtils::messageSetToNumberList(msgs);
 
-		ref <IMAPFolder> thisFolder = thisRef().dynamicCast <IMAPFolder>();
+		shared_ptr <IMAPFolder> thisFolder = dynamicCast <IMAPFolder>(shared_from_this());
 
 		for (std::vector <int>::const_iterator it = numbers.begin() ; it != numbers.end() ; ++it)
-			messages.push_back(vmime::create <IMAPMessage>(thisFolder, *it));
+			messages.push_back(make_shared <IMAPMessage>(thisFolder, *it));
 	}
 	else if (msgs.isUIDSet())
 	{
@@ -566,7 +565,7 @@ std::vector <ref <message> > IMAPFolder::getMessages(const messageSet& msgs)
 		m_connection->send(true, cmd.str(), true);
 
 		// Get the response
-		utility::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
+		std::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
 
 		if (resp->isBad() || resp->response_done()->response_tagged()->
 				resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -613,8 +612,8 @@ std::vector <ref <message> > IMAPFolder::getMessages(const messageSet& msgs)
 
 			if (!msgUID.empty())
 			{
-				ref <IMAPFolder> thisFolder = thisRef().dynamicCast <IMAPFolder>();
-				messages.push_back(vmime::create <IMAPMessage>(thisFolder, msgNum, msgUID));
+				shared_ptr <IMAPFolder> thisFolder = dynamicCast <IMAPFolder>(shared_from_this());
+				messages.push_back(make_shared <IMAPMessage>(thisFolder, msgNum, msgUID));
 			}
 		}
 	}
@@ -650,20 +649,20 @@ vmime_uint64 IMAPFolder::getHighestModSequence() const
 }
 
 
-ref <folder> IMAPFolder::getFolder(const folder::path::component& name)
+shared_ptr <folder> IMAPFolder::getFolder(const folder::path::component& name)
 {
-	ref <IMAPStore> store = m_store.acquire();
+	shared_ptr <IMAPStore> store = m_store.lock();
 
 	if (!store)
 		throw exceptions::illegal_state("Store disconnected");
 
-	return vmime::create <IMAPFolder>(m_path / name, store);
+	return make_shared <IMAPFolder>(m_path / name, store);
 }
 
 
-std::vector <ref <folder> > IMAPFolder::getFolders(const bool recursive)
+std::vector <shared_ptr <folder> > IMAPFolder::getFolders(const bool recursive)
 {
-	ref <IMAPStore> store = m_store.acquire();
+	shared_ptr <IMAPStore> store = m_store.lock();
 
 	if (!isOpen() && !store)
 		throw exceptions::illegal_state("Store disconnected");
@@ -699,7 +698,7 @@ std::vector <ref <folder> > IMAPFolder::getFolders(const bool recursive)
 	m_connection->send(true, oss.str(), true);
 
 
-	utility::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
+	std::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
 
 	if (resp->isBad() || resp->response_done()->response_tagged()->
 			resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -711,7 +710,7 @@ std::vector <ref <folder> > IMAPFolder::getFolders(const bool recursive)
 		resp->continue_req_or_response_data();
 
 
-	std::vector <ref <folder> > v;
+	std::vector <shared_ptr <folder> > v;
 
 	for (std::vector <IMAPParser::continue_req_or_response_data*>::const_iterator
 	     it = respDataList.begin() ; it != respDataList.end() ; ++it)
@@ -741,7 +740,7 @@ std::vector <ref <folder> > IMAPFolder::getFolders(const bool recursive)
 			const class IMAPParser::mailbox_flag_list* mailbox_flag_list =
 				mailboxData->mailbox_list()->mailbox_flag_list();
 
-			v.push_back(vmime::create <IMAPFolder>(path, store,
+			v.push_back(make_shared <IMAPFolder>(path, store,
 				IMAPUtils::folderTypeFromFlags(mailbox_flag_list),
 				IMAPUtils::folderFlagsFromFlags(mailbox_flag_list)));
 		}
@@ -751,10 +750,10 @@ std::vector <ref <folder> > IMAPFolder::getFolders(const bool recursive)
 }
 
 
-void IMAPFolder::fetchMessages(std::vector <ref <message> >& msg, const fetchAttributes& options,
+void IMAPFolder::fetchMessages(std::vector <shared_ptr <message> >& msg, const fetchAttributes& options,
                                utility::progressListener* progress)
 {
-	ref <IMAPStore> store = m_store.acquire();
+	shared_ptr <IMAPStore> store = m_store.lock();
 
 	if (!store)
 		throw exceptions::illegal_state("Store disconnected");
@@ -765,12 +764,12 @@ void IMAPFolder::fetchMessages(std::vector <ref <message> >& msg, const fetchAtt
 	std::vector <int> list;
 	list.reserve(msg.size());
 
-	std::map <int, ref <IMAPMessage> > numberToMsg;
+	std::map <int, shared_ptr <IMAPMessage> > numberToMsg;
 
-	for (std::vector <ref <message> >::iterator it = msg.begin() ; it != msg.end() ; ++it)
+	for (std::vector <shared_ptr <message> >::iterator it = msg.begin() ; it != msg.end() ; ++it)
 	{
 		list.push_back((*it)->getNumber());
-		numberToMsg[(*it)->getNumber()] = (*it).dynamicCast <IMAPMessage>();
+		numberToMsg[(*it)->getNumber()] = dynamicCast <IMAPMessage>(*it);
 	}
 
 	// Send the request
@@ -780,7 +779,7 @@ void IMAPFolder::fetchMessages(std::vector <ref <message> >& msg, const fetchAtt
 	m_connection->send(true, command, true);
 
 	// Get the response
-	utility::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
+	std::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
 
 	if (resp->isBad() || resp->response_done()->response_tagged()->
 		resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -819,7 +818,7 @@ void IMAPFolder::fetchMessages(std::vector <ref <message> >& msg, const fetchAtt
 			// Process fetch response for this message
 			const int num = static_cast <int>(messageData->number());
 
-			std::map <int, ref <IMAPMessage> >::iterator msg = numberToMsg.find(num);
+			std::map <int, shared_ptr <IMAPMessage> >::iterator msg = numberToMsg.find(num);
 
 			if (msg != numberToMsg.end())
 			{
@@ -841,13 +840,13 @@ void IMAPFolder::fetchMessages(std::vector <ref <message> >& msg, const fetchAtt
 	if (progress)
 		progress->stop(total);
 
-	processStatusUpdate(resp);
+	processStatusUpdate(resp.get());
 }
 
 
-void IMAPFolder::fetchMessage(ref <message> msg, const fetchAttributes& options)
+void IMAPFolder::fetchMessage(shared_ptr <message> msg, const fetchAttributes& options)
 {
-	std::vector <ref <message> > msgs;
+	std::vector <shared_ptr <message> > msgs;
 	msgs.push_back(msg);
 
 	fetchMessages(msgs, options, /* progress */ NULL);
@@ -863,24 +862,24 @@ int IMAPFolder::getFetchCapabilities() const
 }
 
 
-ref <folder> IMAPFolder::getParent()
+shared_ptr <folder> IMAPFolder::getParent()
 {
 	if (m_path.isEmpty())
-		return NULL;
+		return null;
 	else
-		return vmime::create <IMAPFolder>(m_path.getParent(), m_store.acquire());
+		return make_shared <IMAPFolder>(m_path.getParent(), m_store.lock());
 }
 
 
-ref <const store> IMAPFolder::getStore() const
+shared_ptr <const store> IMAPFolder::getStore() const
 {
-	return m_store.acquire();
+	return m_store.lock();
 }
 
 
-ref <store> IMAPFolder::getStore()
+shared_ptr <store> IMAPFolder::getStore()
 {
-	return m_store.acquire();
+	return m_store.lock();
 }
 
 
@@ -902,13 +901,13 @@ void IMAPFolder::unregisterMessage(IMAPMessage* msg)
 
 void IMAPFolder::onStoreDisconnected()
 {
-	m_store = NULL;
+	m_store.reset();
 }
 
 
 void IMAPFolder::deleteMessages(const messageSet& msgs)
 {
-	ref <IMAPStore> store = m_store.acquire();
+	shared_ptr <IMAPStore> store = m_store.lock();
 
 	if (msgs.isEmpty())
 		throw exceptions::invalid_argument();
@@ -935,7 +934,7 @@ void IMAPFolder::deleteMessages(const messageSet& msgs)
 	m_connection->send(true, command.str(), true);
 
 	// Get the response
-	utility::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
+	std::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
 
 	if (resp->isBad() || resp->response_done()->response_tagged()->
 		resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -944,7 +943,7 @@ void IMAPFolder::deleteMessages(const messageSet& msgs)
 			resp->getErrorLog(), "bad response");
 	}
 
-	processStatusUpdate(resp);
+	processStatusUpdate(resp.get());
 }
 
 
@@ -977,7 +976,7 @@ void IMAPFolder::setMessageFlags(const messageSet& msgs, const int flags, const
 		m_connection->send(true, command.str(), true);
 
 		// Get the response
-		utility::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
+		std::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
 
 		if (resp->isBad() || resp->response_done()->response_tagged()->
 			resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -986,12 +985,12 @@ void IMAPFolder::setMessageFlags(const messageSet& msgs, const int flags, const
 				resp->getErrorLog(), "bad response");
 		}
 
-		processStatusUpdate(resp);
+		processStatusUpdate(resp.get());
 	}
 }
 
 
-void IMAPFolder::addMessage(ref <vmime::message> msg, const int flags,
+void IMAPFolder::addMessage(shared_ptr <vmime::message> msg, const int flags,
                             vmime::datetime* date, utility::progressListener* progress)
 {
 	std::ostringstream oss;
@@ -1009,7 +1008,7 @@ void IMAPFolder::addMessage(ref <vmime::message> msg, const int flags,
 void IMAPFolder::addMessage(utility::inputStream& is, const int size, const int flags,
                             vmime::datetime* date, utility::progressListener* progress)
 {
-	ref <IMAPStore> store = m_store.acquire();
+	shared_ptr <IMAPStore> store = m_store.lock();
 
 	if (!store)
 		throw exceptions::illegal_state("Store disconnected");
@@ -1045,7 +1044,7 @@ void IMAPFolder::addMessage(utility::inputStream& is, const int size, const int
 	m_connection->send(true, command.str(), true);
 
 	// Get the response
-	utility::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
+	std::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
 
 	bool ok = false;
 	const std::vector <IMAPParser::continue_req_or_response_data*>& respList
@@ -1097,7 +1096,7 @@ void IMAPFolder::addMessage(utility::inputStream& is, const int size, const int
 		progress->stop(total);
 
 	// Get the response
-	utility::auto_ptr <IMAPParser::response> finalResp(m_connection->readResponse());
+	std::auto_ptr <IMAPParser::response> finalResp(m_connection->readResponse());
 
 	if (finalResp->isBad() || finalResp->response_done()->response_tagged()->
 		resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -1106,13 +1105,13 @@ void IMAPFolder::addMessage(utility::inputStream& is, const int size, const int
 			resp->getErrorLog(), "bad response");
 	}
 
-	processStatusUpdate(resp);
+	processStatusUpdate(resp.get());
 }
 
 
 void IMAPFolder::expunge()
 {
-	ref <IMAPStore> store = m_store.acquire();
+	shared_ptr <IMAPStore> store = m_store.lock();
 
 	if (!store)
 		throw exceptions::illegal_state("Store disconnected");
@@ -1125,7 +1124,7 @@ void IMAPFolder::expunge()
 	m_connection->send(true, "EXPUNGE", true);
 
 	// Get the response
-	utility::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
+	std::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
 
 	if (resp->isBad() || resp->response_done()->response_tagged()->
 		resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -1134,13 +1133,13 @@ void IMAPFolder::expunge()
 			resp->getErrorLog(), "bad response");
 	}
 
-	processStatusUpdate(resp);
+	processStatusUpdate(resp.get());
 }
 
 
 void IMAPFolder::rename(const folder::path& newPath)
 {
-	ref <IMAPStore> store = m_store.acquire();
+	shared_ptr <IMAPStore> store = m_store.lock();
 
 	if (!store)
 		throw exceptions::illegal_state("Store disconnected");
@@ -1165,7 +1164,7 @@ void IMAPFolder::rename(const folder::path& newPath)
 	m_connection->send(true, command.str(), true);
 
 	// Get the response
-	utility::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
+	std::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
 
 	if (resp->isBad() || resp->response_done()->response_tagged()->
 		resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -1180,9 +1179,9 @@ void IMAPFolder::rename(const folder::path& newPath)
 	m_path = newPath;
 	m_name = newPath.getLastComponent();
 
-	ref <events::folderEvent> event =
-		vmime::create <events::folderEvent>
-			(thisRef().dynamicCast <folder>(),
+	shared_ptr <events::folderEvent> event =
+		make_shared <events::folderEvent>
+			(dynamicCast <folder>(shared_from_this()),
 			 events::folderEvent::TYPE_RENAMED, oldPath, newPath);
 
 	notifyFolder(event);
@@ -1197,22 +1196,22 @@ void IMAPFolder::rename(const folder::path& newPath)
 
 			(*it)->m_path.renameParent(oldPath, newPath);
 
-			ref <events::folderEvent> event =
-				vmime::create <events::folderEvent>
-					((*it)->thisRef().dynamicCast <folder>(),
+			shared_ptr <events::folderEvent> event =
+				make_shared <events::folderEvent>
+					(dynamicCast <folder>((*it)->shared_from_this()),
 					 events::folderEvent::TYPE_RENAMED, oldPath, (*it)->m_path);
 
 			(*it)->notifyFolder(event);
 		}
 	}
 
-	processStatusUpdate(resp);
+	processStatusUpdate(resp.get());
 }
 
 
 void IMAPFolder::copyMessages(const folder::path& dest, const messageSet& set)
 {
-	ref <IMAPStore> store = m_store.acquire();
+	shared_ptr <IMAPStore> store = m_store.lock();
 
 	if (!store)
 		throw exceptions::illegal_state("Store disconnected");
@@ -1231,7 +1230,7 @@ void IMAPFolder::copyMessages(const folder::path& dest, const messageSet& set)
 	m_connection->send(true, command.str(), true);
 
 	// Get the response
-	utility::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
+	std::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
 
 	if (resp->isBad() || resp->response_done()->response_tagged()->
 		resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -1240,7 +1239,7 @@ void IMAPFolder::copyMessages(const folder::path& dest, const messageSet& set)
 			resp->getErrorLog(), "bad response");
 	}
 
-	processStatusUpdate(resp);
+	processStatusUpdate(resp.get());
 }
 
 
@@ -1249,16 +1248,16 @@ void IMAPFolder::status(int& count, int& unseen)
 	count = 0;
 	unseen = 0;
 
-	ref <folderStatus> status = getStatus();
+	shared_ptr <folderStatus> status = getStatus();
 
 	count = status->getMessageCount();
 	unseen = status->getUnseenCount();
 }
 
 
-ref <folderStatus> IMAPFolder::getStatus()
+shared_ptr <folderStatus> IMAPFolder::getStatus()
 {
-	ref <IMAPStore> store = m_store.acquire();
+	shared_ptr <IMAPStore> store = m_store.lock();
 
 	if (!store)
 		throw exceptions::illegal_state("Store disconnected");
@@ -1283,7 +1282,7 @@ ref <folderStatus> IMAPFolder::getStatus()
 	m_connection->send(true, command.str(), true);
 
 	// Get the response
-	utility::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
+	std::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
 
 	if (resp->isBad() || resp->response_done()->response_tagged()->
 		resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -1305,7 +1304,7 @@ ref <folderStatus> IMAPFolder::getStatus()
 			if (responseData->mailbox_data() &&
 				responseData->mailbox_data()->type() == IMAPParser::mailbox_data::STATUS)
 			{
-				ref <IMAPFolderStatus> status = vmime::create <IMAPFolderStatus>();
+				shared_ptr <IMAPFolderStatus> status = make_shared <IMAPFolderStatus>();
 				status->updateFromResponse(responseData->mailbox_data());
 
 				m_status->updateFromResponse(responseData->mailbox_data());
@@ -1322,14 +1321,14 @@ ref <folderStatus> IMAPFolder::getStatus()
 
 void IMAPFolder::noop()
 {
-	ref <IMAPStore> store = m_store.acquire();
+	shared_ptr <IMAPStore> store = m_store.lock();
 
 	if (!store)
 		throw exceptions::illegal_state("Store disconnected");
 
 	m_connection->send(true, "NOOP", true);
 
-	utility::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
+	std::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
 
 	if (resp->isBad() || resp->response_done()->response_tagged()->
 			resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -1337,7 +1336,7 @@ void IMAPFolder::noop()
 		throw exceptions::command_error("NOOP", resp->getErrorLog());
 	}
 
-	processStatusUpdate(resp);
+	processStatusUpdate(resp.get());
 }
 
 
@@ -1354,7 +1353,7 @@ std::vector <int> IMAPFolder::getMessageNumbersStartingOnUID(const message::uid&
 	m_connection->send(true, command.str(), true);
 
 	// Get the response
-	utility::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
+	std::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
 
 	if (resp->isBad() ||
 	    resp->response_done()->response_tagged()->resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -1393,7 +1392,7 @@ std::vector <int> IMAPFolder::getMessageNumbersStartingOnUID(const message::uid&
 		}
 	}
 
-	processStatusUpdate(resp);
+	processStatusUpdate(resp.get());
 
 	return v;
 }
@@ -1401,9 +1400,9 @@ std::vector <int> IMAPFolder::getMessageNumbersStartingOnUID(const message::uid&
 
 void IMAPFolder::processStatusUpdate(const IMAPParser::response* resp)
 {
-	std::vector <ref <events::event> > events;
+	std::vector <shared_ptr <events::event> > events;
 
-	ref <IMAPFolderStatus> oldStatus = m_status->clone().dynamicCast <IMAPFolderStatus>();
+	shared_ptr <IMAPFolderStatus> oldStatus = vmime::clone(m_status);
 	int expungedMessageCount = 0;
 
 	// Process tagged response
@@ -1450,8 +1449,8 @@ void IMAPFolder::processStatusUpdate(const IMAPParser::response* resp)
 						(*mit)->processFetchResponse(/* options */ 0, msgData);
 				}
 
-				events.push_back(vmime::create <events::messageChangedEvent>
-					(thisRef().dynamicCast <folder>(),
+				events.push_back(make_shared <events::messageChangedEvent>
+					(dynamicCast <folder>(shared_from_this()),
 					 events::messageChangedEvent::TYPE_FLAGS,
 					 std::vector <int>(1, msgNumber)));
 			}
@@ -1467,8 +1466,8 @@ void IMAPFolder::processStatusUpdate(const IMAPParser::response* resp)
 						(*jt)->renumber((*jt)->getNumber() - 1);
 				}
 
-				events.push_back(vmime::create <events::messageCountEvent>
-					(thisRef().dynamicCast <folder>(),
+				events.push_back(make_shared <events::messageCountEvent>
+					(dynamicCast <folder>(shared_from_this()),
 					 events::messageCountEvent::TYPE_REMOVED,
 					 std::vector <int>(1, msgNumber)));
 
@@ -1488,14 +1487,14 @@ void IMAPFolder::processStatusUpdate(const IMAPParser::response* resp)
 			newMessageNumbers.push_back(msgNumber);
 		}
 
-		events.push_back(vmime::create <events::messageCountEvent>
-			(thisRef().dynamicCast <folder>(),
+		events.push_back(make_shared <events::messageCountEvent>
+			(dynamicCast <folder>(shared_from_this()),
 			 events::messageCountEvent::TYPE_ADDED,
 			 newMessageNumbers));
 	}
 
 	// Dispatch notifications
-	for (std::vector <ref <events::event> >::iterator evit =
+	for (std::vector <shared_ptr <events::event> >::iterator evit =
 	     events.begin() ; evit != events.end() ; ++evit)
 	{
 		notifyEvent(*evit);
diff --git a/src/net/imap/IMAPFolderStatus.cpp b/src/net/imap/IMAPFolderStatus.cpp
index c231cb38..25c88b02 100644
--- a/src/net/imap/IMAPFolderStatus.cpp
+++ b/src/net/imap/IMAPFolderStatus.cpp
@@ -94,9 +94,9 @@ vmime_uint64 IMAPFolderStatus::getHighestModSeq() const
 }
 
 
-ref <folderStatus> IMAPFolderStatus::clone() const
+shared_ptr <folderStatus> IMAPFolderStatus::clone() const
 {
-	return vmime::create <IMAPFolderStatus>(*this);
+	return make_shared <IMAPFolderStatus>(*this);
 }
 
 
diff --git a/src/net/imap/IMAPMessage.cpp b/src/net/imap/IMAPMessage.cpp
index d512e752..ae51bfe8 100644
--- a/src/net/imap/IMAPMessage.cpp
+++ b/src/net/imap/IMAPMessage.cpp
@@ -97,17 +97,17 @@ private:
 //
 
 
-IMAPMessage::IMAPMessage(ref <IMAPFolder> folder, const int num)
+IMAPMessage::IMAPMessage(shared_ptr <IMAPFolder> folder, const int num)
 	: m_folder(folder), m_num(num), m_size(-1), m_flags(FLAG_UNDEFINED),
-	  m_expunged(false), m_modseq(0), m_structure(NULL)
+	  m_expunged(false), m_modseq(0), m_structure(null)
 {
 	folder->registerMessage(this);
 }
 
 
-IMAPMessage::IMAPMessage(ref <IMAPFolder> folder, const int num, const uid& uid)
+IMAPMessage::IMAPMessage(shared_ptr <IMAPFolder> folder, const int num, const uid& uid)
 	: m_folder(folder), m_num(num), m_size(-1), m_flags(FLAG_UNDEFINED),
-	  m_expunged(false), m_uid(uid), m_modseq(0), m_structure(NULL)
+	  m_expunged(false), m_uid(uid), m_modseq(0), m_structure(null)
 {
 	folder->registerMessage(this);
 }
@@ -115,7 +115,7 @@ IMAPMessage::IMAPMessage(ref <IMAPFolder> folder, const int num, const uid& uid)
 
 IMAPMessage::~IMAPMessage()
 {
-	ref <IMAPFolder> folder = m_folder.acquire();
+	shared_ptr <IMAPFolder> folder = m_folder.lock();
 
 	if (folder)
 		folder->unregisterMessage(this);
@@ -124,7 +124,7 @@ IMAPMessage::~IMAPMessage()
 
 void IMAPMessage::onFolderClosed()
 {
-	m_folder = NULL;
+	m_folder.reset();
 }
 
 
@@ -170,7 +170,7 @@ int IMAPMessage::getFlags() const
 }
 
 
-ref <const messageStructure> IMAPMessage::getStructure() const
+shared_ptr <const messageStructure> IMAPMessage::getStructure() const
 {
 	if (m_structure == NULL)
 		throw exceptions::unfetched_object();
@@ -179,7 +179,7 @@ ref <const messageStructure> IMAPMessage::getStructure() const
 }
 
 
-ref <messageStructure> IMAPMessage::getStructure()
+shared_ptr <messageStructure> IMAPMessage::getStructure()
 {
 	if (m_structure == NULL)
 		throw exceptions::unfetched_object();
@@ -188,7 +188,7 @@ ref <messageStructure> IMAPMessage::getStructure()
 }
 
 
-ref <const header> IMAPMessage::getHeader() const
+shared_ptr <const header> IMAPMessage::getHeader() const
 {
 	if (m_header == NULL)
 		throw exceptions::unfetched_object();
@@ -200,20 +200,20 @@ ref <const header> IMAPMessage::getHeader() const
 void IMAPMessage::extract(utility::outputStream& os, utility::progressListener* progress,
                           const int start, const int length, const bool peek) const
 {
-	ref <const IMAPFolder> folder = m_folder.acquire();
+	shared_ptr <const IMAPFolder> folder = m_folder.lock();
 
 	if (!folder)
 		throw exceptions::folder_not_found();
 
-	extractImpl(NULL, os, progress, start, length, EXTRACT_HEADER | EXTRACT_BODY | (peek ? EXTRACT_PEEK : 0));
+	extractImpl(null, os, progress, start, length, EXTRACT_HEADER | EXTRACT_BODY | (peek ? EXTRACT_PEEK : 0));
 }
 
 
 void IMAPMessage::extractPart
-	(ref <const messagePart> p, utility::outputStream& os, utility::progressListener* progress,
+	(shared_ptr <const messagePart> p, utility::outputStream& os, utility::progressListener* progress,
 	 const int start, const int length, const bool peek) const
 {
-	ref <const IMAPFolder> folder = m_folder.acquire();
+	shared_ptr <const IMAPFolder> folder = m_folder.lock();
 
 	if (!folder)
 		throw exceptions::folder_not_found();
@@ -222,9 +222,9 @@ void IMAPMessage::extractPart
 }
 
 
-void IMAPMessage::fetchPartHeader(ref <messagePart> p)
+void IMAPMessage::fetchPartHeader(shared_ptr <messagePart> p)
 {
-	ref <IMAPFolder> folder = m_folder.acquire();
+	shared_ptr <IMAPFolder> folder = m_folder.lock();
 
 	if (!folder)
 		throw exceptions::folder_not_found();
@@ -234,15 +234,15 @@ void IMAPMessage::fetchPartHeader(ref <messagePart> p)
 
 	extractImpl(p, ossAdapter, NULL, 0, -1, EXTRACT_HEADER | EXTRACT_PEEK);
 
-	p.dynamicCast <IMAPMessagePart>()->getOrCreateHeader().parse(oss.str());
+	dynamicCast <IMAPMessagePart>(p)->getOrCreateHeader().parse(oss.str());
 }
 
 
-void IMAPMessage::fetchPartHeaderForStructure(ref <messageStructure> str)
+void IMAPMessage::fetchPartHeaderForStructure(shared_ptr <messageStructure> str)
 {
 	for (size_t i = 0, n = str->getPartCount() ; i < n ; ++i)
 	{
-		ref <messagePart> part = str->getPartAt(i);
+		shared_ptr <messagePart> part = str->getPartAt(i);
 
 		// Fetch header of current part
 		fetchPartHeader(part);
@@ -253,11 +253,11 @@ void IMAPMessage::fetchPartHeaderForStructure(ref <messageStructure> str)
 }
 
 
-void IMAPMessage::extractImpl(ref <const messagePart> p, utility::outputStream& os,
+void IMAPMessage::extractImpl(shared_ptr <const messagePart> p, utility::outputStream& os,
 	utility::progressListener* progress, const int start,
 	const int length, const int extractFlags) const
 {
-	ref <const IMAPFolder> folder = m_folder.acquire();
+	shared_ptr <const IMAPFolder> folder = m_folder.lock();
 
 	IMAPMessage_literalHandler literalHandler(os, progress);
 
@@ -267,7 +267,7 @@ void IMAPMessage::extractImpl(ref <const messagePart> p, utility::outputStream&
 
 	if (p != NULL)
 	{
-		ref <const IMAPMessagePart> currentPart = p.dynamicCast <const IMAPMessagePart>();
+		shared_ptr <const IMAPMessagePart> currentPart = dynamicCast <const IMAPMessagePart>(p);
 		std::vector <int> numbers;
 
 		numbers.push_back(currentPart->getNumber());
@@ -344,11 +344,11 @@ void IMAPMessage::extractImpl(ref <const messagePart> p, utility::outputStream&
 		command << "<" << start << "." << length << ">";
 
 	// Send the request
-	folder.constCast <IMAPFolder>()->m_connection->send(true, command.str(), true);
+	constCast <IMAPFolder>(folder)->m_connection->send(true, command.str(), true);
 
 	// Get the response
-	utility::auto_ptr <IMAPParser::response> resp
-		(folder.constCast <IMAPFolder>()->m_connection->readResponse(&literalHandler));
+	std::auto_ptr <IMAPParser::response> resp
+		(constCast <IMAPFolder>(folder)->m_connection->readResponse(&literalHandler));
 
 	if (resp->isBad() || resp->response_done()->response_tagged()->
 		resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -368,7 +368,7 @@ void IMAPMessage::extractImpl(ref <const messagePart> p, utility::outputStream&
 int IMAPMessage::processFetchResponse
 	(const fetchAttributes& options, const IMAPParser::message_data* msgData)
 {
-	ref <IMAPFolder> folder = m_folder.acquire();
+	shared_ptr <IMAPFolder> folder = m_folder.lock();
 
 	// Get message attributes
 	const std::vector <IMAPParser::msg_att_item*> atts = msgData->msg_att()->items();
@@ -406,7 +406,7 @@ int IMAPMessage::processFetchResponse
 			if (!options.has(fetchAttributes::FULL_HEADER))
 			{
 				const IMAPParser::envelope* env = (*it)->envelope();
-				ref <vmime::header> hdr = getOrCreateHeader();
+				shared_ptr <vmime::header> hdr = getOrCreateHeader();
 
 				// Date
 				hdr->Date()->setValue(env->env_date()->value());
@@ -463,7 +463,7 @@ int IMAPMessage::processFetchResponse
 		}
 		case IMAPParser::msg_att_item::BODY_STRUCTURE:
 		{
-			m_structure = vmime::create <IMAPMessageStructure>((*it)->body());
+			m_structure = make_shared <IMAPMessageStructure>((*it)->body());
 			break;
 		}
 		case IMAPParser::msg_att_item::RFC822_HEADER:
@@ -488,12 +488,12 @@ int IMAPMessage::processFetchResponse
 					tempHeader.parse((*it)->nstring()->value());
 
 					vmime::header& hdr = *getOrCreateHeader();
-					std::vector <ref <headerField> > fields = tempHeader.getFieldList();
+					std::vector <shared_ptr <headerField> > fields = tempHeader.getFieldList();
 
-					for (std::vector <ref <headerField> >::const_iterator jt = fields.begin() ;
+					for (std::vector <shared_ptr <headerField> >::const_iterator jt = fields.begin() ;
 					     jt != fields.end() ; ++jt)
 					{
-						hdr.appendField((*jt)->clone().dynamicCast <headerField>());
+						hdr.appendField(vmime::clone(*jt));
 					}
 				}
 			}
@@ -515,18 +515,18 @@ int IMAPMessage::processFetchResponse
 }
 
 
-ref <header> IMAPMessage::getOrCreateHeader()
+shared_ptr <header> IMAPMessage::getOrCreateHeader()
 {
 	if (m_header != NULL)
 		return (m_header);
 	else
-		return (m_header = vmime::create <header>());
+		return (m_header = make_shared <header>());
 }
 
 
 void IMAPMessage::setFlags(const int flags, const int mode)
 {
-	ref <IMAPFolder> folder = m_folder.acquire();
+	shared_ptr <IMAPFolder> folder = m_folder.lock();
 
 	if (!folder)
 		throw exceptions::folder_not_found();
@@ -539,20 +539,20 @@ void IMAPMessage::setFlags(const int flags, const int mode)
 
 
 void IMAPMessage::constructParsedMessage
-	(ref <bodyPart> parentPart, ref <messageStructure> str, int level)
+	(shared_ptr <bodyPart> parentPart, shared_ptr <messageStructure> str, int level)
 {
 	if (level == 0)
 	{
-		ref <messagePart> part = str->getPartAt(0);
+		shared_ptr <messagePart> part = str->getPartAt(0);
 
 		// Copy header
-		ref <const header> hdr = part->getHeader();
+		shared_ptr <const header> hdr = part->getHeader();
 		parentPart->getHeader()->copyFrom(*hdr);
 
 		// Initialize body
 		parentPart->getBody()->setContents
-			(vmime::create <IMAPMessagePartContentHandler>
-				(thisRef().dynamicCast <IMAPMessage>(),
+			(make_shared <IMAPMessagePartContentHandler>
+				(dynamicCast <IMAPMessage>(shared_from_this()),
 				 part, parentPart->getBody()->getEncoding()));
 
 		constructParsedMessage(parentPart, part->getStructure(), 1);
@@ -561,18 +561,18 @@ void IMAPMessage::constructParsedMessage
 	{
 		for (size_t i = 0, n = str->getPartCount() ; i < n ; ++i)
 		{
-			ref <messagePart> part = str->getPartAt(i);
+			shared_ptr <messagePart> part = str->getPartAt(i);
 
-			ref <bodyPart> childPart = vmime::create <bodyPart>();
+			shared_ptr <bodyPart> childPart = make_shared <bodyPart>();
 
 			// Copy header
-			ref <const header> hdr = part->getHeader();
+			shared_ptr <const header> hdr = part->getHeader();
 			childPart->getHeader()->copyFrom(*hdr);
 
 			// Initialize body
 			childPart->getBody()->setContents
-				(vmime::create <IMAPMessagePartContentHandler>
-					(thisRef().dynamicCast <IMAPMessage>(),
+				(make_shared <IMAPMessagePartContentHandler>
+					(dynamicCast <IMAPMessage>(shared_from_this()),
 					 part, childPart->getBody()->getEncoding()));
 
 			// Add child part
@@ -585,10 +585,10 @@ void IMAPMessage::constructParsedMessage
 }
 
 
-ref <vmime::message> IMAPMessage::getParsedMessage()
+shared_ptr <vmime::message> IMAPMessage::getParsedMessage()
 {
 	// Fetch structure
-	ref <messageStructure> structure = NULL;
+	shared_ptr <messageStructure> structure;
 
 	try
 	{
@@ -596,10 +596,10 @@ ref <vmime::message> IMAPMessage::getParsedMessage()
 	}
 	catch (exceptions::unfetched_object&)
 	{
-		std::vector <ref <message> > msgs;
-		msgs.push_back(thisRef().dynamicCast <IMAPMessage>());
+		std::vector <shared_ptr <message> > msgs;
+		msgs.push_back(dynamicCast <IMAPMessage>(shared_from_this()));
 
-		m_folder.acquire()->fetchMessages
+		m_folder.lock()->fetchMessages
 			(msgs, fetchAttributes(fetchAttributes::STRUCTURE), /* progress */ NULL);
 
 		structure = getStructure();
@@ -609,7 +609,7 @@ ref <vmime::message> IMAPMessage::getParsedMessage()
 	fetchPartHeaderForStructure(structure);
 
 	// Construct message from structure
-	ref <vmime::message> msg = vmime::create <vmime::message>();
+	shared_ptr <vmime::message> msg = make_shared <vmime::message>();
 
 	constructParsedMessage(msg, structure);
 
diff --git a/src/net/imap/IMAPMessagePart.cpp b/src/net/imap/IMAPMessagePart.cpp
index 48e063e8..153470cf 100644
--- a/src/net/imap/IMAPMessagePart.cpp
+++ b/src/net/imap/IMAPMessagePart.cpp
@@ -36,16 +36,16 @@ namespace net {
 namespace imap {
 
 
-IMAPMessagePart::IMAPMessagePart(ref <IMAPMessagePart> parent, const int number, const IMAPParser::body_type_mpart* mpart)
-	: m_parent(parent), m_header(NULL), m_number(number), m_size(0)
+IMAPMessagePart::IMAPMessagePart(shared_ptr <IMAPMessagePart> parent, const int number, const IMAPParser::body_type_mpart* mpart)
+	: m_parent(parent), m_header(null), m_number(number), m_size(0)
 {
 	m_mediaType = vmime::mediaType
 		("multipart", mpart->media_subtype()->value());
 }
 
 
-IMAPMessagePart::IMAPMessagePart(ref <IMAPMessagePart> parent, const int number, const IMAPParser::body_type_1part* part)
-	: m_parent(parent), m_header(NULL), m_number(number), m_size(0)
+IMAPMessagePart::IMAPMessagePart(shared_ptr <IMAPMessagePart> parent, const int number, const IMAPParser::body_type_1part* part)
+	: m_parent(parent), m_header(null), m_number(number), m_size(0)
 {
 	if (part->body_type_text())
 	{
@@ -70,11 +70,11 @@ IMAPMessagePart::IMAPMessagePart(ref <IMAPMessagePart> parent, const int number,
 		m_size = part->body_type_basic()->body_fields()->body_fld_octets()->value();
 	}
 
-	m_structure = NULL;
+	m_structure = null;
 }
 
 
-ref <const messageStructure> IMAPMessagePart::getStructure() const
+shared_ptr <const messageStructure> IMAPMessagePart::getStructure() const
 {
 	if (m_structure != NULL)
 		return m_structure;
@@ -83,7 +83,7 @@ ref <const messageStructure> IMAPMessagePart::getStructure() const
 }
 
 
-ref <messageStructure> IMAPMessagePart::getStructure()
+shared_ptr <messageStructure> IMAPMessagePart::getStructure()
 {
 	if (m_structure != NULL)
 		return m_structure;
@@ -92,9 +92,9 @@ ref <messageStructure> IMAPMessagePart::getStructure()
 }
 
 
-ref <const IMAPMessagePart> IMAPMessagePart::getParent() const
+shared_ptr <const IMAPMessagePart> IMAPMessagePart::getParent() const
 {
-	return m_parent.acquire();
+	return m_parent.lock();
 }
 
 
@@ -116,7 +116,7 @@ int IMAPMessagePart::getNumber() const
 }
 
 
-ref <const header> IMAPMessagePart::getHeader() const
+shared_ptr <const header> IMAPMessagePart::getHeader() const
 {
 	if (m_header == NULL)
 		throw exceptions::unfetched_object();
@@ -126,19 +126,19 @@ ref <const header> IMAPMessagePart::getHeader() const
 
 
 // static
-ref <IMAPMessagePart> IMAPMessagePart::create
-	(ref <IMAPMessagePart> parent, const int number, const IMAPParser::body* body)
+shared_ptr <IMAPMessagePart> IMAPMessagePart::create
+	(shared_ptr <IMAPMessagePart> parent, const int number, const IMAPParser::body* body)
 {
 	if (body->body_type_mpart())
 	{
-		ref <IMAPMessagePart> part = vmime::create <IMAPMessagePart>(parent, number, body->body_type_mpart());
-		part->m_structure = vmime::create <IMAPMessageStructure>(part, body->body_type_mpart()->list());
+		shared_ptr <IMAPMessagePart> part = make_shared <IMAPMessagePart>(parent, number, body->body_type_mpart());
+		part->m_structure = make_shared <IMAPMessageStructure>(part, body->body_type_mpart()->list());
 
 		return part;
 	}
 	else
 	{
-		return vmime::create <IMAPMessagePart>(parent, number, body->body_type_1part());
+		return make_shared <IMAPMessagePart>(parent, number, body->body_type_1part());
 	}
 }
 
@@ -148,7 +148,7 @@ header& IMAPMessagePart::getOrCreateHeader()
 	if (m_header != NULL)
 		return *m_header;
 	else
-		return *(m_header = vmime::create <header>());
+		return *(m_header = make_shared <header>());
 }
 
 
diff --git a/src/net/imap/IMAPMessagePartContentHandler.cpp b/src/net/imap/IMAPMessagePartContentHandler.cpp
index 10c7a040..7112e3d2 100644
--- a/src/net/imap/IMAPMessagePartContentHandler.cpp
+++ b/src/net/imap/IMAPMessagePartContentHandler.cpp
@@ -43,17 +43,17 @@ namespace imap {
 
 
 IMAPMessagePartContentHandler::IMAPMessagePartContentHandler
-	(ref <IMAPMessage> msg, ref <messagePart> part, const vmime::encoding& encoding)
+	(shared_ptr <IMAPMessage> msg, shared_ptr <messagePart> part, const vmime::encoding& encoding)
 	: m_message(msg), m_part(part), m_encoding(encoding)
 {
 }
 
 
-ref <contentHandler> IMAPMessagePartContentHandler::clone() const
+shared_ptr <contentHandler> IMAPMessagePartContentHandler::clone() const
 {
-	return create <IMAPMessagePartContentHandler>
-		(m_message.acquire().constCast <IMAPMessage>(),
-		 m_part.acquire().constCast <messagePart>(),
+	return make_shared <IMAPMessagePartContentHandler>
+		(constCast <IMAPMessage>(m_message.lock()),
+		 constCast <messagePart>(m_part.lock()),
 		 m_encoding);
 }
 
@@ -61,8 +61,8 @@ ref <contentHandler> IMAPMessagePartContentHandler::clone() const
 void IMAPMessagePartContentHandler::generate
 	(utility::outputStream& os, const vmime::encoding& enc, const string::size_type maxLineLength) const
 {
-	ref <IMAPMessage> msg = m_message.acquire().constCast <IMAPMessage>();
-	ref <messagePart> part = m_part.acquire().constCast <messagePart>();
+	shared_ptr <IMAPMessage> msg = constCast <IMAPMessage>(m_message.lock());
+	shared_ptr <messagePart> part = constCast <messagePart>(m_part.lock());
 
 	// Data is already encoded
 	if (isEncoded())
@@ -85,14 +85,14 @@ void IMAPMessagePartContentHandler::generate
 			std::ostringstream oss2;
 			utility::outputStreamAdapter tmp2(oss2);
 
-			ref <utility::encoder::encoder> theDecoder = m_encoding.getEncoder();
+			shared_ptr <utility::encoder::encoder> theDecoder = m_encoding.getEncoder();
 			theDecoder->decode(in, tmp2);
 
 			// Reencode to output stream
 			string str = oss2.str();
 			utility::inputStreamStringAdapter tempIn(str);
 
-			ref <utility::encoder::encoder> theEncoder = enc.getEncoder();
+			shared_ptr <utility::encoder::encoder> theEncoder = enc.getEncoder();
 			theEncoder->getProperties()["maxlinelength"] = maxLineLength;
 			theEncoder->getProperties()["text"] = (m_contentType.getType() == mediaTypes::TEXT);
 
@@ -114,7 +114,7 @@ void IMAPMessagePartContentHandler::generate
 		msg->extractPart(part, tmp, NULL);
 
 		// Encode temporary buffer to output stream
-		ref <utility::encoder::encoder> theEncoder = enc.getEncoder();
+		shared_ptr <utility::encoder::encoder> theEncoder = enc.getEncoder();
 		theEncoder->getProperties()["maxlinelength"] = maxLineLength;
 		theEncoder->getProperties()["text"] = (m_contentType.getType() == mediaTypes::TEXT);
 
@@ -128,8 +128,8 @@ void IMAPMessagePartContentHandler::generate
 void IMAPMessagePartContentHandler::extract
 	(utility::outputStream& os, utility::progressListener* progress) const
 {
-	ref <IMAPMessage> msg = m_message.acquire().constCast <IMAPMessage>();
-	ref <messagePart> part = m_part.acquire().constCast <messagePart>();
+	shared_ptr <IMAPMessage> msg = constCast <IMAPMessage>(m_message.lock());
+	shared_ptr <messagePart> part = constCast <messagePart>(m_part.lock());
 
 	// No decoding to perform
 	if (!isEncoded())
@@ -149,7 +149,7 @@ void IMAPMessagePartContentHandler::extract
 		utility::inputStreamStringAdapter is(oss.str());
 		utility::progressListenerSizeAdapter plsa(progress, getLength());
 
-		ref <utility::encoder::encoder> theDecoder = m_encoding.getEncoder();
+		shared_ptr <utility::encoder::encoder> theDecoder = m_encoding.getEncoder();
 		theDecoder->decode(is, os, &plsa);
 	}
 }
@@ -158,8 +158,8 @@ void IMAPMessagePartContentHandler::extract
 void IMAPMessagePartContentHandler::extractRaw
 	(utility::outputStream& os, utility::progressListener* progress) const
 {
-	ref <IMAPMessage> msg = m_message.acquire().constCast <IMAPMessage>();
-	ref <messagePart> part = m_part.acquire().constCast <messagePart>();
+	shared_ptr <IMAPMessage> msg = constCast <IMAPMessage>(m_message.lock());
+	shared_ptr <messagePart> part = constCast <messagePart>(m_part.lock());
 
 	msg->extractPart(part, os, progress);
 }
@@ -167,7 +167,7 @@ void IMAPMessagePartContentHandler::extractRaw
 
 string::size_type IMAPMessagePartContentHandler::getLength() const
 {
-	return m_part.acquire()->getSize();
+	return m_part.lock()->getSize();
 }
 
 
diff --git a/src/net/imap/IMAPMessageStructure.cpp b/src/net/imap/IMAPMessageStructure.cpp
index 60f26c68..8dc333e9 100644
--- a/src/net/imap/IMAPMessageStructure.cpp
+++ b/src/net/imap/IMAPMessageStructure.cpp
@@ -43,11 +43,11 @@ IMAPMessageStructure::IMAPMessageStructure()
 
 IMAPMessageStructure::IMAPMessageStructure(const IMAPParser::body* body)
 {
-	m_parts.push_back(IMAPMessagePart::create(NULL, 0, body));
+	m_parts.push_back(IMAPMessagePart::create(null, 0, body));
 }
 
 
-IMAPMessageStructure::IMAPMessageStructure(ref <IMAPMessagePart> parent, const std::vector <IMAPParser::body*>& list)
+IMAPMessageStructure::IMAPMessageStructure(shared_ptr <IMAPMessagePart> parent, const std::vector <IMAPParser::body*>& list)
 {
 	int number = 0;
 
@@ -59,13 +59,13 @@ IMAPMessageStructure::IMAPMessageStructure(ref <IMAPMessagePart> parent, const s
 }
 
 
-ref <const messagePart> IMAPMessageStructure::getPartAt(const size_t x) const
+shared_ptr <const messagePart> IMAPMessageStructure::getPartAt(const size_t x) const
 {
 	return m_parts[x];
 }
 
 
-ref <messagePart> IMAPMessageStructure::getPartAt(const size_t x)
+shared_ptr <messagePart> IMAPMessageStructure::getPartAt(const size_t x)
 {
 	return m_parts[x];
 }
@@ -78,9 +78,9 @@ size_t IMAPMessageStructure::getPartCount() const
 
 
 // static
-ref <IMAPMessageStructure> IMAPMessageStructure::emptyStructure()
+shared_ptr <IMAPMessageStructure> IMAPMessageStructure::emptyStructure()
 {
-	static ref <IMAPMessageStructure> emptyStructure = vmime::create <IMAPMessageStructure>();
+	static shared_ptr <IMAPMessageStructure> emptyStructure = make_shared <IMAPMessageStructure>();
 	return emptyStructure;
 }
 
diff --git a/src/net/imap/IMAPSStore.cpp b/src/net/imap/IMAPSStore.cpp
index b467d13a..c9e64f5b 100644
--- a/src/net/imap/IMAPSStore.cpp
+++ b/src/net/imap/IMAPSStore.cpp
@@ -35,7 +35,7 @@ namespace net {
 namespace imap {
 
 
-IMAPSStore::IMAPSStore(ref <session> sess, ref <security::authenticator> auth)
+IMAPSStore::IMAPSStore(shared_ptr <session> sess, shared_ptr <security::authenticator> auth)
 	: IMAPStore(sess, auth, true)
 {
 }
diff --git a/src/net/imap/IMAPStore.cpp b/src/net/imap/IMAPStore.cpp
index eca58ea7..a1a8c9ca 100644
--- a/src/net/imap/IMAPStore.cpp
+++ b/src/net/imap/IMAPStore.cpp
@@ -43,8 +43,8 @@ namespace net {
 namespace imap {
 
 
-IMAPStore::IMAPStore(ref <session> sess, ref <security::authenticator> auth, const bool secured)
-	: store(sess, getInfosInstance(), auth), m_connection(NULL), m_isIMAPS(secured)
+IMAPStore::IMAPStore(shared_ptr <session> sess, shared_ptr <security::authenticator> auth, const bool secured)
+	: store(sess, getInfosInstance(), auth), m_connection(null), m_isIMAPS(secured)
 {
 }
 
@@ -69,32 +69,35 @@ const string IMAPStore::getProtocolName() const
 }
 
 
-ref <folder> IMAPStore::getRootFolder()
+shared_ptr <folder> IMAPStore::getRootFolder()
 {
 	if (!isConnected())
 		throw exceptions::illegal_state("Not connected");
 
-	return vmime::create <IMAPFolder>(folder::path(),
-		thisRef().dynamicCast <IMAPStore>());
+	return make_shared <IMAPFolder>
+		(folder::path(),
+		 dynamicCast <IMAPStore>(shared_from_this()));
 }
 
 
-ref <folder> IMAPStore::getDefaultFolder()
+shared_ptr <folder> IMAPStore::getDefaultFolder()
 {
 	if (!isConnected())
 		throw exceptions::illegal_state("Not connected");
 
-	return vmime::create <IMAPFolder>(folder::path::component("INBOX"),
-		thisRef().dynamicCast <IMAPStore>());
+	return make_shared <IMAPFolder>
+		(folder::path::component("INBOX"),
+		 dynamicCast <IMAPStore>(shared_from_this()));
 }
 
 
-ref <folder> IMAPStore::getFolder(const folder::path& path)
+shared_ptr <folder> IMAPStore::getFolder(const folder::path& path)
 {
 	if (!isConnected())
 		throw exceptions::illegal_state("Not connected");
 
-	return vmime::create <IMAPFolder>(path, thisRef().dynamicCast <IMAPStore>());
+	return make_shared <IMAPFolder>
+		(path, dynamicCast <IMAPStore>(shared_from_this()));
 }
 
 
@@ -109,8 +112,8 @@ void IMAPStore::connect()
 	if (isConnected())
 		throw exceptions::already_connected();
 
-	m_connection = vmime::create <IMAPConnection>
-		(thisRef().dynamicCast <IMAPStore>(), getAuthenticator());
+	m_connection = make_shared <IMAPConnection>
+		(dynamicCast <IMAPStore>(shared_from_this()), getAuthenticator());
 
 	try
 	{
@@ -118,7 +121,7 @@ void IMAPStore::connect()
 	}
 	catch (std::exception&)
 	{
-		m_connection = NULL;
+		m_connection = null;
 		throw;
 	}
 }
@@ -145,16 +148,16 @@ bool IMAPStore::isSecuredConnection() const
 }
 
 
-ref <connectionInfos> IMAPStore::getConnectionInfos() const
+shared_ptr <connectionInfos> IMAPStore::getConnectionInfos() const
 {
 	if (m_connection == NULL)
-		return NULL;
+		return null;
 
 	return m_connection->getConnectionInfos();
 }
 
 
-ref <IMAPConnection> IMAPStore::getConnection()
+shared_ptr <IMAPConnection> IMAPStore::getConnection()
 {
 	return m_connection;
 }
@@ -176,7 +179,7 @@ void IMAPStore::disconnect()
 
 	m_connection->disconnect();
 
-	m_connection = NULL;
+	m_connection = null;
 }
 
 
@@ -187,7 +190,7 @@ void IMAPStore::noop()
 
 	m_connection->send(true, "NOOP", true);
 
-	utility::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
+	std::auto_ptr <IMAPParser::response> resp(m_connection->readResponse());
 
 	if (resp->isBad() || resp->response_done()->response_tagged()->
 			resp_cond_state()->status() != IMAPParser::resp_cond_state::OK)
@@ -205,7 +208,7 @@ void IMAPStore::noop()
 }
 
 
-ref <IMAPConnection> IMAPStore::connection()
+shared_ptr <IMAPConnection> IMAPStore::connection()
 {
 	return (m_connection);
 }
diff --git a/src/net/imap/IMAPUtils.cpp b/src/net/imap/IMAPUtils.cpp
index caaf6575..bf310414 100644
--- a/src/net/imap/IMAPUtils.cpp
+++ b/src/net/imap/IMAPUtils.cpp
@@ -544,7 +544,7 @@ const string IMAPUtils::dateTime(const vmime::datetime& date)
 
 // static
 const string IMAPUtils::buildFetchRequest
-	(ref <IMAPConnection> cnt, const messageSet& msgs, const fetchAttributes& options)
+	(shared_ptr <IMAPConnection> cnt, const messageSet& msgs, const fetchAttributes& options)
 {
 	// Example:
 	//   C: A654 FETCH 2:4 (FLAGS BODY[HEADER.FIELDS (DATE FROM)])
@@ -649,7 +649,7 @@ void IMAPUtils::convertAddressList
 		string email = addr.addr_mailbox()->value()
 			+ "@" + addr.addr_host()->value();
 
-		dest.appendMailbox(vmime::create <mailbox>(name, email));
+		dest.appendMailbox(make_shared <mailbox>(name, email));
 	}
 }