orthanc: Plugins/Engine/OrthancPlugins.cpp comparison

comparison Plugins/Engine/OrthancPlugins.cpp @ 2884:497a637366b4 db-changes

integration mainline->db-changes

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Fri, 12 Oct 2018 15:18:10 +0200
parents	7133ad478eea
children	9d277f8ad698

comparison

equal deleted inserted replaced

-:2b91363cc1d1
+:497a637366b4
 /**
 * Orthanc - A Lightweight, RESTful DICOM Store
-* Copyright (C) 2012-2015 Sebastien Jodogne, Medical Physics
+* Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
 * Department, University Hospital of Liege, Belgium
+* Copyright (C) 2017-2018 Osimis S.A., Belgium
 *
 * This program is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 #include "../../OrthancServer/PrecompiledHeadersServer.h"
 #include "OrthancPlugins.h"
-#if ORTHANC_PLUGINS_ENABLED != 1
+#if ORTHANC_ENABLE_PLUGINS != 1
 #error The plugin support is disabled
 #endif
 #include "../../Core/ChunkedBuffer.h"
+#include "../../Core/DicomFormat/DicomArray.h"
 #include "../../Core/HttpServer/HttpToolbox.h"
 #include "../../Core/Logging.h"
 #include "../../Core/OrthancException.h"
+#include "../../Core/SerializationToolbox.h"
 #include "../../Core/Toolbox.h"
-#include "../../OrthancServer/FromDcmtkBridge.h"
+#include "../../Core/DicomParsing/FromDcmtkBridge.h"
+#include "../../Core/DicomParsing/ToDcmtkBridge.h"
 #include "../../OrthancServer/OrthancInitialization.h"
 #include "../../OrthancServer/ServerContext.h"
 #include "../../OrthancServer/ServerToolbox.h"
+#include "../../OrthancServer/Search/HierarchicalMatcher.h"
+#include "../../Core/DicomParsing/Internals/DicomImageDecoder.h"
 #include "../../Core/Compression/ZlibCompressor.h"
 #include "../../Core/Compression/GzipCompressor.h"
 #include "../../Core/Images/Image.h"
 #include "../../Core/Images/PngReader.h"
 #include "../../Core/Images/PngWriter.h"
 #include "../../Core/Images/JpegReader.h"
 #include "../../Core/Images/JpegWriter.h"
 #include "../../Core/Images/ImageProcessing.h"
+#include "../../OrthancServer/DefaultDicomImageDecoder.h"
+#include "../../OrthancServer/OrthancFindRequestHandler.h"
 #include "PluginsEnumerations.h"
+#include "PluginsJob.h"
 #include <boost/regex.hpp>
+#include <dcmtk/dcmdata/dcdict.h>
+#include <dcmtk/dcmdata/dcdicent.h>
 namespace Orthanc
 {
+static void CopyToMemoryBuffer(OrthancPluginMemoryBuffer& target,
+const void* data,
+size_t size)
+{
+target.size = size;
+if (size == 0)
+{
+target.data = NULL;
+}
+else
+{
+target.data = malloc(size);
+if (target.data != NULL)
+{
+memcpy(target.data, data, size);
+}
+else
+{
+throw OrthancException(ErrorCode_NotEnoughMemory);
+}
+}
+}
+static void CopyToMemoryBuffer(OrthancPluginMemoryBuffer& target,
+const std::string& str)
+{
+if (str.size() == 0)
+{
+target.size = 0;
+target.data = NULL;
+}
+else
+{
+CopyToMemoryBuffer(target, str.c_str(), str.size());
+}
+}
+static char* CopyString(const std::string& str)
+{
+char *result = reinterpret_cast<char*>(malloc(str.size() + 1));
+if (result == NULL)
+{
+throw OrthancException(ErrorCode_NotEnoughMemory);
+}
+if (str.size() == 0)
+{
+result[0] = '\0';
+}
+else
+{
+memcpy(result, &str[0], str.size() + 1);
+}
+return result;
+}
 namespace
 {
 class PluginStorageArea : public IStorageArea
 {
 private:
 IStorageArea* Create() const
 {
 return new PluginStorageArea(callbacks_, errorDictionary_);
 }
 };
-}
+class OrthancPeers : public boost::noncopyable
-struct OrthancPlugins::PImpl
+{
-{
+private:
+std::vector<std::string>           names_;
+std::vector<WebServiceParameters>  parameters_;
+void CheckIndex(size_t i) const
+{
+assert(names_.size() == parameters_.size());
+if (i >= names_.size())
+{
+throw OrthancException(ErrorCode_ParameterOutOfRange);
+}
+}
+public:
+OrthancPeers()
+{
+std::set<std::string> peers;
+Configuration::GetListOfOrthancPeers(peers);
+names_.reserve(peers.size());
+parameters_.reserve(peers.size());
+for (std::set<std::string>::const_iterator
+it = peers.begin(); it != peers.end(); ++it)
+{
+WebServiceParameters peer;
+if (Configuration::GetOrthancPeer(peer, *it))
+{
+names_.push_back(*it);
+parameters_.push_back(peer);
+}
+}
+}
+size_t GetPeersCount() const
+{
+return names_.size();
+}
+const std::string& GetPeerName(size_t i) const
+{
+CheckIndex(i);
+return names_[i];
+}
+const WebServiceParameters& GetPeerParameters(size_t i) const
+{
+CheckIndex(i);
+return parameters_[i];
+}
+};
+}
+class OrthancPlugins::PImpl
+{
+private:
+boost::mutex   contextMutex_;
+ServerContext* context_;
+public:
 class RestCallback : public boost::noncopyable
 {
 private:
 boost::regex              regex_;
 OrthancPluginRestCallback callback_;
 }
 }
 };
+class ServerContextLock
+{
+private:
+boost::mutex::scoped_lock  lock_;
+ServerContext* context_;
+public:
+ServerContextLock(PImpl& that) :
+lock_(that.contextMutex_),
+context_(that.context_)
+{
+if (context_ == NULL)
+{
+throw OrthancException(ErrorCode_DatabaseNotInitialized);
+}
+}
+ServerContext& GetContext()
+{
+assert(context_ != NULL);
+return *context_;
+}
+};
+void SetServerContext(ServerContext* context)
+{
+boost::mutex::scoped_lock lock(contextMutex_);
+context_ = context;
+}
 typedef std::pair<std::string, _OrthancPluginProperty>  Property;
 typedef std::list<RestCallback*>  RestCallbacks;
 typedef std::list<OrthancPluginOnStoredInstanceCallback>  OnStoredCallbacks;
 typedef std::list<OrthancPluginOnChangeCallback>  OnChangeCallbacks;
+typedef std::list<OrthancPluginIncomingHttpRequestFilter>  IncomingHttpRequestFilters;
+typedef std::list<OrthancPluginIncomingHttpRequestFilter2>  IncomingHttpRequestFilters2;
+typedef std::list<OrthancPluginDecodeImageCallback>  DecodeImageCallbacks;
+typedef std::list<OrthancPluginJobsUnserializer>  JobsUnserializers;
 typedef std::map<Property, std::string>  Properties;
 PluginsManager manager_;
-ServerContext* context_;
 RestCallbacks restCallbacks_;
 OnStoredCallbacks  onStoredCallbacks_;
 OnChangeCallbacks  onChangeCallbacks_;
+OrthancPluginFindCallback  findCallback_;
+OrthancPluginWorklistCallback  worklistCallback_;
+DecodeImageCallbacks  decodeImageCallbacks_;
+JobsUnserializers  jobsUnserializers_;
+_OrthancPluginMoveCallback moveCallbacks_;
+IncomingHttpRequestFilters  incomingHttpRequestFilters_;
+IncomingHttpRequestFilters2 incomingHttpRequestFilters2_;
 std::auto_ptr<StorageAreaFactory>  storageArea_;
 boost::recursive_mutex restCallbackMutex_;
 boost::recursive_mutex storedCallbackMutex_;
 boost::recursive_mutex changeCallbackMutex_;
+boost::mutex findCallbackMutex_;
+boost::mutex worklistCallbackMutex_;
+boost::mutex decodeImageCallbackMutex_;
+boost::mutex jobsUnserializersMutex_;
 boost::recursive_mutex invokeServiceMutex_;
 Properties properties_;
 int argc_;
 char** argv_;
 std::auto_ptr<OrthancPluginDatabase>  database_;
 PluginsErrorDictionary  dictionary_;
 PImpl() :
 context_(NULL),
+findCallback_(NULL),
+worklistCallback_(NULL),
 argc_(1),
 argv_(NULL)
 {
+memset(&moveCallbacks_, 0, sizeof(moveCallbacks_));
 }
 };
-static char* CopyString(const std::string& str)
+class OrthancPlugins::WorklistHandler : public IWorklistRequestHandler
 {
-char *result = reinterpret_cast<char*>(malloc(str.size() + 1));
+private:
-if (result == NULL)
+OrthancPlugins&  that_;
-{
+std::auto_ptr<HierarchicalMatcher> matcher_;
-throw OrthancException(ErrorCode_NotEnoughMemory);
+std::auto_ptr<ParsedDicomFile>     filtered_;
-}
+ParsedDicomFile* currentQuery_;
-if (str.size() == 0)
+void Reset()
 {
-result[0] = '\0';
+matcher_.reset();
-}
+filtered_.reset();
-else
+currentQuery_ = NULL;
-{
+}
-memcpy(result, &str[0], str.size() + 1);
-}
+public:
+WorklistHandler(OrthancPlugins& that) : that_(that)
-return result;
+{
-}
+Reset();
+}
+virtual void Handle(DicomFindAnswers& answers,
+ParsedDicomFile& query,
+const std::string& remoteIp,
+const std::string& remoteAet,
+const std::string& calledAet,
+ModalityManufacturer manufacturer)
+{
+static const char* LUA_CALLBACK = "IncomingWorklistRequestFilter";
+{
+PImpl::ServerContextLock lock(*that_.pimpl_);
+LuaScripting::Lock lua(lock.GetContext().GetLuaScripting());
+if (!lua.GetLua().IsExistingFunction(LUA_CALLBACK))
+{
+currentQuery_ = &query;
+}
+else
+{
+Json::Value source, origin;
+query.DatasetToJson(source, DicomToJsonFormat_Short, DicomToJsonFlags_None, 0);
+OrthancFindRequestHandler::FormatOrigin
+(origin, remoteIp, remoteAet, calledAet, manufacturer);
+LuaFunctionCall call(lua.GetLua(), LUA_CALLBACK);
+call.PushJson(source);
+call.PushJson(origin);
+Json::Value target;
+call.ExecuteToJson(target, true);
+filtered_.reset(ParsedDicomFile::CreateFromJson(target, DicomFromJsonFlags_None));
+currentQuery_ = filtered_.get();
+}
+}
+matcher_.reset(new HierarchicalMatcher(*currentQuery_));
+{
+boost::mutex::scoped_lock lock(that_.pimpl_->worklistCallbackMutex_);
+if (that_.pimpl_->worklistCallback_)
+{
+OrthancPluginErrorCode error = that_.pimpl_->worklistCallback_
+(reinterpret_cast<OrthancPluginWorklistAnswers*>(&answers),
+reinterpret_cast<const OrthancPluginWorklistQuery*>(this),
+remoteAet.c_str(),
+calledAet.c_str());
+if (error != OrthancPluginErrorCode_Success)
+{
+Reset();
+that_.GetErrorDictionary().LogError(error, true);
+throw OrthancException(static_cast<ErrorCode>(error));
+}
+}
+Reset();
+}
+}
+void GetDicomQuery(OrthancPluginMemoryBuffer& target) const
+{
+if (currentQuery_ == NULL)
+{
+throw OrthancException(ErrorCode_Plugin);
+}
+std::string dicom;
+currentQuery_->SaveToMemoryBuffer(dicom);
+CopyToMemoryBuffer(target, dicom.c_str(), dicom.size());
+}
+bool IsMatch(const void* dicom,
+size_t size) const
+{
+if (matcher_.get() == NULL)
+{
+throw OrthancException(ErrorCode_Plugin);
+}
+ParsedDicomFile f(dicom, size);
+return matcher_->Match(f);
+}
+void AddAnswer(OrthancPluginWorklistAnswers* answers,
+const void* dicom,
+size_t size) const
+{
+if (matcher_.get() == NULL)
+{
+throw OrthancException(ErrorCode_Plugin);
+}
+ParsedDicomFile f(dicom, size);
+std::auto_ptr<ParsedDicomFile> summary(matcher_->Extract(f));
+reinterpret_cast<DicomFindAnswers*>(answers)->Add(*summary);
+}
+};
+class OrthancPlugins::FindHandler : public IFindRequestHandler
+{
+private:
+OrthancPlugins&            that_;
+std::auto_ptr<DicomArray>  currentQuery_;
+void Reset()
+{
+currentQuery_.reset(NULL);
+}
+public:
+FindHandler(OrthancPlugins& that) : that_(that)
+{
+Reset();
+}
+virtual void Handle(DicomFindAnswers& answers,
+const DicomMap& input,
+const std::list<DicomTag>& sequencesToReturn,
+const std::string& remoteIp,
+const std::string& remoteAet,
+const std::string& calledAet,
+ModalityManufacturer manufacturer)
+{
+DicomMap tmp;
+tmp.Assign(input);
+for (std::list<DicomTag>::const_iterator it = sequencesToReturn.begin();
+it != sequencesToReturn.end(); ++it)
+{
+if (!input.HasTag(*it))
+{
+tmp.SetValue(*it, "", false);
+}
+}
+{
+boost::mutex::scoped_lock lock(that_.pimpl_->findCallbackMutex_);
+currentQuery_.reset(new DicomArray(tmp));
+if (that_.pimpl_->findCallback_)
+{
+OrthancPluginErrorCode error = that_.pimpl_->findCallback_
+(reinterpret_cast<OrthancPluginFindAnswers*>(&answers),
+reinterpret_cast<const OrthancPluginFindQuery*>(this),
+remoteAet.c_str(),
+calledAet.c_str());
+if (error != OrthancPluginErrorCode_Success)
+{
+Reset();
+that_.GetErrorDictionary().LogError(error, true);
+throw OrthancException(static_cast<ErrorCode>(error));
+}
+}
+Reset();
+}
+}
+void Invoke(_OrthancPluginService service,
+const _OrthancPluginFindOperation& operation) const
+{
+if (currentQuery_.get() == NULL)
+{
+throw OrthancException(ErrorCode_Plugin);
+}
+switch (service)
+{
+case _OrthancPluginService_GetFindQuerySize:
+*operation.resultUint32 = currentQuery_->GetSize();
+break;
+case _OrthancPluginService_GetFindQueryTag:
+{
+const DicomTag& tag = currentQuery_->GetElement(operation.index).GetTag();
+*operation.resultGroup = tag.GetGroup();
+*operation.resultElement = tag.GetElement();
+break;
+}
+case _OrthancPluginService_GetFindQueryTagName:
+{
+const DicomElement& element = currentQuery_->GetElement(operation.index);
+*operation.resultString = CopyString(FromDcmtkBridge::GetTagName(element));
+break;
+}
+case _OrthancPluginService_GetFindQueryValue:
+{
+*operation.resultString = CopyString(currentQuery_->GetElement(operation.index).GetValue().GetContent());
+break;
+}
+default:
+throw OrthancException(ErrorCode_InternalError);
+}
+}
+};
+class OrthancPlugins::MoveHandler : public IMoveRequestHandler
+{
+private:
+class Driver : public IMoveRequestIterator
+{
+private:
+void*                   driver_;
+unsigned int            count_;
+unsigned int            pos_;
+OrthancPluginApplyMove  apply_;
+OrthancPluginFreeMove   free_;
+public:
+Driver(void* driver,
+unsigned int count,
+OrthancPluginApplyMove apply,
+OrthancPluginFreeMove free) :
+driver_(driver),
+count_(count),
+pos_(0),
+apply_(apply),
+free_(free)
+{
+if (driver_ == NULL)
+{
+throw OrthancException(ErrorCode_Plugin);
+}
+}
+virtual ~Driver()
+{
+if (driver_ != NULL)
+{
+free_(driver_);
+driver_ = NULL;
+}
+}
+virtual unsigned int GetSubOperationCount() const
+{
+return count_;
+}
+virtual Status DoNext()
+{
+if (pos_ >= count_)
+{
+throw OrthancException(ErrorCode_BadSequenceOfCalls);
+}
+else
+{
+OrthancPluginErrorCode error = apply_(driver_);
+if (error != OrthancPluginErrorCode_Success)
+{
+LOG(ERROR) << "Error while doing C-Move from plugin: " << EnumerationToString(static_cast<ErrorCode>(error));
+return Status_Failure;
+}
+else
+{
+pos_++;
+return Status_Success;
+}
+}
+}
+};
+_OrthancPluginMoveCallback  params_;
+static std::string ReadTag(const DicomMap& input,
+const DicomTag& tag)
+{
+const DicomValue* value = input.TestAndGetValue(tag);
+if (value != NULL &&
+!value->IsBinary() &&
+!value->IsNull())
+{
+return value->GetContent();
+}
+else
+{
+return std::string();
+}
+}
+public:
+MoveHandler(OrthancPlugins& that)
+{
+boost::recursive_mutex::scoped_lock lock(that.pimpl_->invokeServiceMutex_);
+params_ = that.pimpl_->moveCallbacks_;
+if (params_.callback == NULL ||
+params_.getMoveSize == NULL ||
+params_.applyMove == NULL ||
+params_.freeMove == NULL)
+{
+throw OrthancException(ErrorCode_Plugin);
+}
+}
+virtual IMoveRequestIterator* Handle(const std::string& targetAet,
+const DicomMap& input,
+const std::string& originatorIp,
+const std::string& originatorAet,
+const std::string& calledAet,
+uint16_t originatorId)
+{
+std::string levelString = ReadTag(input, DICOM_TAG_QUERY_RETRIEVE_LEVEL);
+std::string patientId = ReadTag(input, DICOM_TAG_PATIENT_ID);
+std::string accessionNumber = ReadTag(input, DICOM_TAG_ACCESSION_NUMBER);
+std::string studyInstanceUid = ReadTag(input, DICOM_TAG_STUDY_INSTANCE_UID);
+std::string seriesInstanceUid = ReadTag(input, DICOM_TAG_SERIES_INSTANCE_UID);
+std::string sopInstanceUid = ReadTag(input, DICOM_TAG_SOP_INSTANCE_UID);
+OrthancPluginResourceType level = OrthancPluginResourceType_None;
+if (!levelString.empty())
+{
+level = Plugins::Convert(StringToResourceType(levelString.c_str()));
+}
+void* driver = params_.callback(level,
+patientId.empty() ? NULL : patientId.c_str(),
+accessionNumber.empty() ? NULL : accessionNumber.c_str(),
+studyInstanceUid.empty() ? NULL : studyInstanceUid.c_str(),
+seriesInstanceUid.empty() ? NULL : seriesInstanceUid.c_str(),
+sopInstanceUid.empty() ? NULL : sopInstanceUid.c_str(),
+originatorAet.c_str(),
+calledAet.c_str(),
+targetAet.c_str(),
+originatorId);
+if (driver == NULL)
+{
+LOG(ERROR) << "Plugin cannot create a driver for an incoming C-MOVE request";
+throw OrthancException(ErrorCode_Plugin);
+}
+unsigned int size = params_.getMoveSize(driver);
+return new Driver(driver, size, params_.applyMove, params_.freeMove);
+}
+};
 OrthancPlugins::OrthancPlugins()
 {
+/* Sanity check of the compiler */
 if (sizeof(int32_t) != sizeof(OrthancPluginErrorCode) ||
 sizeof(int32_t) != sizeof(OrthancPluginHttpMethod) ||
 sizeof(int32_t) != sizeof(_OrthancPluginService) ||
 sizeof(int32_t) != sizeof(_OrthancPluginProperty) ||
 sizeof(int32_t) != sizeof(OrthancPluginPixelFormat) ||
 sizeof(int32_t) != sizeof(OrthancPluginImageFormat) ||
 sizeof(int32_t) != sizeof(OrthancPluginCompressionType) ||
 sizeof(int32_t) != sizeof(OrthancPluginValueRepresentation) ||
 sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFlags) ||
 sizeof(int32_t) != sizeof(OrthancPluginDicomToJsonFormat) ||
+sizeof(int32_t) != sizeof(OrthancPluginCreateDicomFlags) ||
 sizeof(int32_t) != sizeof(_OrthancPluginDatabaseAnswerType) ||
 sizeof(int32_t) != sizeof(OrthancPluginIdentifierConstraint) ||
+sizeof(int32_t) != sizeof(OrthancPluginInstanceOrigin) ||
+sizeof(int32_t) != sizeof(OrthancPluginJobStepStatus) ||
 static_cast<int>(OrthancPluginDicomToJsonFlags_IncludeBinary) != static_cast<int>(DicomToJsonFlags_IncludeBinary) ||
 static_cast<int>(OrthancPluginDicomToJsonFlags_IncludePrivateTags) != static_cast<int>(DicomToJsonFlags_IncludePrivateTags) ||
 static_cast<int>(OrthancPluginDicomToJsonFlags_IncludeUnknownTags) != static_cast<int>(DicomToJsonFlags_IncludeUnknownTags) ||
 static_cast<int>(OrthancPluginDicomToJsonFlags_IncludePixelData) != static_cast<int>(DicomToJsonFlags_IncludePixelData) ||
 static_cast<int>(OrthancPluginDicomToJsonFlags_ConvertBinaryToNull) != static_cast<int>(DicomToJsonFlags_ConvertBinaryToNull) ||
-static_cast<int>(OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii) != static_cast<int>(DicomToJsonFlags_ConvertBinaryToAscii))
+static_cast<int>(OrthancPluginDicomToJsonFlags_ConvertBinaryToAscii) != static_cast<int>(DicomToJsonFlags_ConvertBinaryToAscii) ||
-{
+static_cast<int>(OrthancPluginCreateDicomFlags_DecodeDataUriScheme) != static_cast<int>(DicomFromJsonFlags_DecodeDataUriScheme) ||
-/* Sanity check of the compiler */
+static_cast<int>(OrthancPluginCreateDicomFlags_GenerateIdentifiers) != static_cast<int>(DicomFromJsonFlags_GenerateIdentifiers))
+{
 throw OrthancException(ErrorCode_Plugin);
 }
 pimpl_.reset(new PImpl());
 pimpl_->manager_.RegisterServiceProvider(*this);
 }
 void OrthancPlugins::SetServerContext(ServerContext& context)
 {
-pimpl_->context_ = &context;
+pimpl_->SetServerContext(&context);
 }
+void OrthancPlugins::ResetServerContext()
+{
+pimpl_->SetServerContext(NULL);
+}
 OrthancPlugins::~OrthancPlugins()
 {
 for (PImpl::RestCallbacks::iterator it = pimpl_->restCallbacks_.begin();
 {
 return true;
 }
 else
 {
-GetErrorDictionary().LogError(error, true);
+GetErrorDictionary().LogError(error, false);
 throw OrthancException(static_cast<ErrorCode>(error));
 }
 }
 change.GetPublicId().c_str());
 }
-static void CopyToMemoryBuffer(OrthancPluginMemoryBuffer& target,
-const void* data,
-size_t size)
-{
-target.size = size;
-if (size == 0)
-{
-target.data = NULL;
-}
-else
-{
-target.data = malloc(size);
-if (target.data != NULL)
-{
-memcpy(target.data, data, size);
-}
-else
-{
-throw OrthancException(ErrorCode_NotEnoughMemory);
-}
-}
-}
-static void CopyToMemoryBuffer(OrthancPluginMemoryBuffer& target,
-const std::string& str)
-{
-if (str.size() == 0)
-{
-target.size = 0;
-target.data = NULL;
-}
-else
-{
-CopyToMemoryBuffer(target, str.c_str(), str.size());
-}
-}
 void OrthancPlugins::RegisterRestCallback(const void* parameters,
 bool lock)
 {
 const _OrthancPluginRestCallback& p =
 *reinterpret_cast<const _OrthancPluginRestCallback*>(parameters);
 LOG(INFO) << "Plugin has registered a REST callback "
-<< (lock ? "with" : "witout")
+<< (lock ? "with" : "without")
 << " mutual exclusion on: "
 << p.pathRegularExpression;
 pimpl_->restCallbacks_.push_back(new PImpl::RestCallback(p.pathRegularExpression, p.callback, lock));
 }
 LOG(INFO) << "Plugin has registered an OnChange callback";
 pimpl_->onChangeCallbacks_.push_back(p.callback);
 }
+void OrthancPlugins::RegisterWorklistCallback(const void* parameters)
+{
+const _OrthancPluginWorklistCallback& p =
+*reinterpret_cast<const _OrthancPluginWorklistCallback*>(parameters);
+boost::mutex::scoped_lock lock(pimpl_->worklistCallbackMutex_);
+if (pimpl_->worklistCallback_ != NULL)
+{
+LOG(ERROR) << "Can only register one plugin to handle modality worklists";
+throw OrthancException(ErrorCode_Plugin);
+}
+else
+{
+LOG(INFO) << "Plugin has registered a callback to handle modality worklists";
+pimpl_->worklistCallback_ = p.callback;
+}
+}
+void OrthancPlugins::RegisterFindCallback(const void* parameters)
+{
+const _OrthancPluginFindCallback& p =
+*reinterpret_cast<const _OrthancPluginFindCallback*>(parameters);
+boost::mutex::scoped_lock lock(pimpl_->findCallbackMutex_);
+if (pimpl_->findCallback_ != NULL)
+{
+LOG(ERROR) << "Can only register one plugin to handle C-FIND requests";
+throw OrthancException(ErrorCode_Plugin);
+}
+else
+{
+LOG(INFO) << "Plugin has registered a callback to handle C-FIND requests";
+pimpl_->findCallback_ = p.callback;
+}
+}
+void OrthancPlugins::RegisterMoveCallback(const void* parameters)
+{
+// invokeServiceMutex_ is assumed to be locked
+const _OrthancPluginMoveCallback& p =
+*reinterpret_cast<const _OrthancPluginMoveCallback*>(parameters);
+if (pimpl_->moveCallbacks_.callback != NULL)
+{
+LOG(ERROR) << "Can only register one plugin to handle C-MOVE requests";
+throw OrthancException(ErrorCode_Plugin);
+}
+else
+{
+LOG(INFO) << "Plugin has registered a callback to handle C-MOVE requests";
+pimpl_->moveCallbacks_ = p;
+}
+}
+void OrthancPlugins::RegisterDecodeImageCallback(const void* parameters)
+{
+const _OrthancPluginDecodeImageCallback& p =
+*reinterpret_cast<const _OrthancPluginDecodeImageCallback*>(parameters);
+boost::mutex::scoped_lock lock(pimpl_->decodeImageCallbackMutex_);
+pimpl_->decodeImageCallbacks_.push_back(p.callback);
+LOG(INFO) << "Plugin has registered a callback to decode DICOM images ("
+<< pimpl_->decodeImageCallbacks_.size() << " decoder(s) now active)";
+}
+void OrthancPlugins::RegisterJobsUnserializer(const void* parameters)
+{
+const _OrthancPluginJobsUnserializer& p =
+*reinterpret_cast<const _OrthancPluginJobsUnserializer*>(parameters);
+boost::mutex::scoped_lock lock(pimpl_->jobsUnserializersMutex_);
+pimpl_->jobsUnserializers_.push_back(p.unserializer);
+LOG(INFO) << "Plugin has registered a callback to unserialize jobs ("
+<< pimpl_->jobsUnserializers_.size() << " unserializer(s) now active)";
+}
+void OrthancPlugins::RegisterIncomingHttpRequestFilter(const void* parameters)
+{
+const _OrthancPluginIncomingHttpRequestFilter& p =
+*reinterpret_cast<const _OrthancPluginIncomingHttpRequestFilter*>(parameters);
+LOG(INFO) << "Plugin has registered a callback to filter incoming HTTP requests";
+pimpl_->incomingHttpRequestFilters_.push_back(p.callback);
+}
+void OrthancPlugins::RegisterIncomingHttpRequestFilter2(const void* parameters)
+{
+const _OrthancPluginIncomingHttpRequestFilter2& p =
+*reinterpret_cast<const _OrthancPluginIncomingHttpRequestFilter2*>(parameters);
+LOG(INFO) << "Plugin has registered a callback to filter incoming HTTP requests";
+pimpl_->incomingHttpRequestFilters2_.push_back(p.callback);
+}
 void OrthancPlugins::AnswerBuffer(const void* parameters)
 {
 const _OrthancPluginAnswerBuffer& p =
 translatedOutput->Answer(compressed);
 }
-void OrthancPlugins::CheckContextAvailable()
-{
-if (!pimpl_->context_)
-{
-throw OrthancException(ErrorCode_DatabaseNotInitialized);
-}
-}
 void OrthancPlugins::GetDicomForInstance(const void* parameters)
 {
 const _OrthancPluginGetDicomForInstance& p =
 *reinterpret_cast<const _OrthancPluginGetDicomForInstance*>(parameters);
 std::string dicom;
-CheckContextAvailable();
+{
-pimpl_->context_->ReadFile(dicom, p.instanceId, FileContentType_Dicom);
+PImpl::ServerContextLock lock(*pimpl_);
+lock.GetContext().ReadDicom(dicom, p.instanceId);
+}
 CopyToMemoryBuffer(*p.target, dicom);
 }
 *reinterpret_cast<const _OrthancPluginRestApiGet*>(parameters);
 LOG(INFO) << "Plugin making REST GET call on URI " << p.uri
 << (afterPlugins ? " (after plugins)" : " (built-in API)");
-CheckContextAvailable();
+IHttpHandler* handler;
-IHttpHandler& handler = pimpl_->context_->GetHttpHandler().RestrictToOrthancRestApi(!afterPlugins);
+{
+PImpl::ServerContextLock lock(*pimpl_);
+handler = &lock.GetContext().GetHttpHandler().RestrictToOrthancRestApi(!afterPlugins);
+}
 std::string result;
-if (HttpToolbox::SimpleGet(result, handler, RequestOrigin_Plugins, p.uri))
+if (HttpToolbox::SimpleGet(result, *handler, RequestOrigin_Plugins, p.uri))
 {
 CopyToMemoryBuffer(*p.target, result);
 }
 else
 {
-throw OrthancException(ErrorCode_BadRequest);
+throw OrthancException(ErrorCode_UnknownResource);
+}
+}
+void OrthancPlugins::RestApiGet2(const void* parameters)
+{
+const _OrthancPluginRestApiGet2& p =
+*reinterpret_cast<const _OrthancPluginRestApiGet2*>(parameters);
+LOG(INFO) << "Plugin making REST GET call on URI " << p.uri
+<< (p.afterPlugins ? " (after plugins)" : " (built-in API)");
+IHttpHandler::Arguments headers;
+for (uint32_t i = 0; i < p.headersCount; i++)
+{
+std::string name(p.headersKeys[i]);
+std::transform(name.begin(), name.end(), name.begin(), ::tolower);
+headers[name] = p.headersValues[i];
+}
+IHttpHandler* handler;
+{
+PImpl::ServerContextLock lock(*pimpl_);
+handler = &lock.GetContext().GetHttpHandler().RestrictToOrthancRestApi(!p.afterPlugins);
+}
+std::string result;
+if (HttpToolbox::SimpleGet(result, *handler, RequestOrigin_Plugins, p.uri, headers))
+{
+CopyToMemoryBuffer(*p.target, result);
+}
+else
+{
+throw OrthancException(ErrorCode_UnknownResource);
 }
 }
 void OrthancPlugins::RestApiPostPut(bool isPost,
 *reinterpret_cast<const _OrthancPluginRestApiPostPut*>(parameters);
 LOG(INFO) << "Plugin making REST " << EnumerationToString(isPost ? HttpMethod_Post : HttpMethod_Put)
 << " call on URI " << p.uri << (afterPlugins ? " (after plugins)" : " (built-in API)");
-CheckContextAvailable();
+IHttpHandler* handler;
-IHttpHandler& handler = pimpl_->context_->GetHttpHandler().RestrictToOrthancRestApi(!afterPlugins);
+{
+PImpl::ServerContextLock lock(*pimpl_);
+handler = &lock.GetContext().GetHttpHandler().RestrictToOrthancRestApi(!afterPlugins);
+}
 std::string result;
 if (isPost ?
-HttpToolbox::SimplePost(result, handler, RequestOrigin_Plugins, p.uri, p.body, p.bodySize) :
+HttpToolbox::SimplePost(result, *handler, RequestOrigin_Plugins, p.uri, p.body, p.bodySize) :
-HttpToolbox::SimplePut (result, handler, RequestOrigin_Plugins, p.uri, p.body, p.bodySize))
+HttpToolbox::SimplePut (result, *handler, RequestOrigin_Plugins, p.uri, p.body, p.bodySize))
 {
 CopyToMemoryBuffer(*p.target, result);
 }
 else
 {
-throw OrthancException(ErrorCode_BadRequest);
+throw OrthancException(ErrorCode_UnknownResource);
 }
 }
 void OrthancPlugins::RestApiDelete(const void* parameters,
 {
 const char* uri = reinterpret_cast<const char*>(parameters);
 LOG(INFO) << "Plugin making REST DELETE call on URI " << uri
 << (afterPlugins ? " (after plugins)" : " (built-in API)");
-CheckContextAvailable();
+IHttpHandler* handler;
-IHttpHandler& handler = pimpl_->context_->GetHttpHandler().RestrictToOrthancRestApi(!afterPlugins);
+{
-if (!HttpToolbox::SimpleDelete(handler, RequestOrigin_Plugins, uri))
+PImpl::ServerContextLock lock(*pimpl_);
-{
+handler = &lock.GetContext().GetHttpHandler().RestrictToOrthancRestApi(!afterPlugins);
-throw OrthancException(ErrorCode_BadRequest);
+}
+if (!HttpToolbox::SimpleDelete(*handler, RequestOrigin_Plugins, uri))
+{
+throw OrthancException(ErrorCode_UnknownResource);
 }
 }
 void OrthancPlugins::LookupResource(_OrthancPluginService service,
 default:
 throw OrthancException(ErrorCode_InternalError);
 }
-CheckContextAvailable();
 std::list<std::string> result;
-pimpl_->context_->GetIndex().LookupIdentifierExact(result, level, tag, p.argument);
+{
+PImpl::ServerContextLock lock(*pimpl_);
+lock.GetContext().GetIndex().LookupIdentifierExact(result, level, tag, p.argument);
+}
 if (result.size() == 1)
 {
 *p.result = CopyString(result.front());
 }
 *reinterpret_cast<DicomInstanceToStore*>(p.instance);
 switch (service)
 {
 case _OrthancPluginService_GetInstanceRemoteAet:
-*p.resultString = instance.GetRemoteAet();
+*p.resultString = instance.GetOrigin().GetRemoteAetC();
 return;
 case _OrthancPluginService_GetInstanceSize:
 *p.resultInt64 = instance.GetBufferSize();
 return;
 s = writer.write(instance.GetJson());
 }
 else
 {
 Json::Value simplified;
-Toolbox::SimplifyTags(simplified, instance.GetJson());
+ServerToolbox::SimplifyTags(simplified, instance.GetJson(), DicomToJsonFormat_Human);
 s = writer.write(simplified);
 }
 *p.resultStringToFree = CopyString(s);
 return;
 }
+case _OrthancPluginService_GetInstanceOrigin:   // New in Orthanc 0.9.5
+*p.resultOrigin = Plugins::Convert(instance.GetOrigin().GetRequestOrigin());
+return;
 default:
 throw OrthancException(ErrorCode_InternalError);
 }
 }
 CopyToMemoryBuffer(*p.target, result);
 }
+static OrthancPluginImage* ReturnImage(std::auto_ptr<ImageAccessor>& image)
+{
+// Images returned to plugins are assumed to be writeable. If the
+// input image is read-only, we return a copy so that it can be modified.
+if (image->IsReadOnly())
+{
+std::auto_ptr<Image> copy(new Image(image->GetFormat(), image->GetWidth(), image->GetHeight(), false));
+ImageProcessing::Copy(*copy, *image);
+image.reset(NULL);
+return reinterpret_cast<OrthancPluginImage*>(copy.release());
+}
+else
+{
+return reinterpret_cast<OrthancPluginImage*>(image.release());
+}
+}
 void OrthancPlugins::UncompressImage(const void* parameters)
 {
 const _OrthancPluginUncompressImage& p = *reinterpret_cast<const _OrthancPluginUncompressImage*>(parameters);
 std::auto_ptr<ImageAccessor> image;
 image.reset(new JpegReader);
 reinterpret_cast<JpegReader&>(*image).ReadFromMemory(p.data, p.size);
 break;
 }
+case OrthancPluginImageFormat_Dicom:
+{
+image.reset(Decode(p.data, p.size, 0));
+break;
+}
 default:
 throw OrthancException(ErrorCode_ParameterOutOfRange);
 }
-*(p.target) = reinterpret_cast<OrthancPluginImage*>(image.release());
+*(p.target) = ReturnImage(image);
 }
 void OrthancPlugins::CompressImage(const void* parameters)
 {
 const _OrthancPluginCompressImage& p = *reinterpret_cast<const _OrthancPluginCompressImage*>(parameters);
 std::string compressed;
+ImageAccessor accessor;
+accessor.AssignReadOnly(Plugins::Convert(p.pixelFormat), p.width, p.height, p.pitch, p.buffer);
 switch (p.imageFormat)
 {
 case OrthancPluginImageFormat_Png:
 {
 PngWriter writer;
-writer.WriteToMemory(compressed, p.width, p.height, p.pitch, Plugins::Convert(p.pixelFormat), p.buffer);
+writer.WriteToMemory(compressed, accessor);
 break;
 }
 case OrthancPluginImageFormat_Jpeg:
 {
 JpegWriter writer;
 writer.SetQuality(p.quality);
-writer.WriteToMemory(compressed, p.width, p.height, p.pitch, Plugins::Convert(p.pixelFormat), p.buffer);
+writer.WriteToMemory(compressed, accessor);
 break;
 }
 default:
 throw OrthancException(ErrorCode_ParameterOutOfRange);
 CopyToMemoryBuffer(*p.target, s);
 }
 }
+void OrthancPlugins::CallHttpClient2(const void* parameters)
+{
+const _OrthancPluginCallHttpClient2& p = *reinterpret_cast<const _OrthancPluginCallHttpClient2*>(parameters);
+HttpClient client;
+client.SetUrl(p.url);
+client.SetConvertHeadersToLowerCase(false);
+if (p.timeout != 0)
+{
+client.SetTimeout(p.timeout);
+}
+if (p.username != NULL &&
+p.password != NULL)
+{
+client.SetCredentials(p.username, p.password);
+}
+if (p.certificateFile != NULL)
+{
+std::string certificate(p.certificateFile);
+std::string key, password;
+if (p.certificateKeyFile)
+{
+key.assign(p.certificateKeyFile);
+}
+if (p.certificateKeyPassword)
+{
+password.assign(p.certificateKeyPassword);
+}
+client.SetClientCertificate(certificate, key, password);
+}
+client.SetPkcs11Enabled(p.pkcs11 ? true : false);
+for (uint32_t i = 0; i < p.headersCount; i++)
+{
+if (p.headersKeys[i] == NULL ||
+p.headersValues[i] == NULL)
+{
+throw OrthancException(ErrorCode_NullPointer);
+}
+client.AddHeader(p.headersKeys[i], p.headersValues[i]);
+}
+switch (p.method)
+{
+case OrthancPluginHttpMethod_Get:
+client.SetMethod(HttpMethod_Get);
+break;
+case OrthancPluginHttpMethod_Post:
+client.SetMethod(HttpMethod_Post);
+client.GetBody().assign(p.body, p.bodySize);
+break;
+case OrthancPluginHttpMethod_Put:
+client.SetMethod(HttpMethod_Put);
+client.GetBody().assign(p.body, p.bodySize);
+break;
+case OrthancPluginHttpMethod_Delete:
+client.SetMethod(HttpMethod_Delete);
+break;
+default:
+throw OrthancException(ErrorCode_ParameterOutOfRange);
+}
+std::string body;
+HttpClient::HttpHeaders headers;
+bool success = client.Apply(body, headers);
+// The HTTP request has succeeded
+*p.httpStatus = static_cast<uint16_t>(client.GetLastStatus());
+if (!success)
+{
+HttpClient::ThrowException(client.GetLastStatus());
+}
+// Copy the HTTP headers of the answer, if the plugin requested them
+if (p.answerHeaders != NULL)
+{
+Json::Value json = Json::objectValue;
+for (HttpClient::HttpHeaders::const_iterator
+it = headers.begin(); it != headers.end(); ++it)
+{
+json[it->first] = it->second;
+}
+std::string s = json.toStyledString();
+CopyToMemoryBuffer(*p.answerHeaders, s);
+}
+// Copy the body of the answer if it makes sense
+if (p.method != OrthancPluginHttpMethod_Delete)
+{
+CopyToMemoryBuffer(*p.answerBody, body);
+}
+}
+void OrthancPlugins::CallPeerApi(const void* parameters)
+{
+const _OrthancPluginCallPeerApi& p = *reinterpret_cast<const _OrthancPluginCallPeerApi*>(parameters);
+const OrthancPeers& peers = *reinterpret_cast<const OrthancPeers*>(p.peers);
+HttpClient client(peers.GetPeerParameters(p.peerIndex), p.uri);
+client.SetConvertHeadersToLowerCase(false);
+if (p.timeout != 0)
+{
+client.SetTimeout(p.timeout);
+}
+for (uint32_t i = 0; i < p.additionalHeadersCount; i++)
+{
+if (p.additionalHeadersKeys[i] == NULL ||
+p.additionalHeadersValues[i] == NULL)
+{
+throw OrthancException(ErrorCode_NullPointer);
+}
+client.AddHeader(p.additionalHeadersKeys[i], p.additionalHeadersValues[i]);
+}
+switch (p.method)
+{
+case OrthancPluginHttpMethod_Get:
+client.SetMethod(HttpMethod_Get);
+break;
+case OrthancPluginHttpMethod_Post:
+client.SetMethod(HttpMethod_Post);
+client.GetBody().assign(p.body, p.bodySize);
+break;
+case OrthancPluginHttpMethod_Put:
+client.SetMethod(HttpMethod_Put);
+client.GetBody().assign(p.body, p.bodySize);
+break;
+case OrthancPluginHttpMethod_Delete:
+client.SetMethod(HttpMethod_Delete);
+break;
+default:
+throw OrthancException(ErrorCode_ParameterOutOfRange);
+}
+std::string body;
+HttpClient::HttpHeaders headers;
+bool success = client.Apply(body, headers);
+// The HTTP request has succeeded
+*p.httpStatus = static_cast<uint16_t>(client.GetLastStatus());
+if (!success)
+{
+HttpClient::ThrowException(client.GetLastStatus());
+}
+// Copy the HTTP headers of the answer, if the plugin requested them
+if (p.answerHeaders != NULL)
+{
+Json::Value json = Json::objectValue;
+for (HttpClient::HttpHeaders::const_iterator
+it = headers.begin(); it != headers.end(); ++it)
+{
+json[it->first] = it->second;
+}
+std::string s = json.toStyledString();
+CopyToMemoryBuffer(*p.answerHeaders, s);
+}
+// Copy the body of the answer if it makes sense
+if (p.method != OrthancPluginHttpMethod_Delete)
+{
+CopyToMemoryBuffer(*p.answerBody, body);
+}
+}
 void OrthancPlugins::ConvertPixelFormat(const void* parameters)
 {
 const _OrthancPluginConvertPixelFormat& p = *reinterpret_cast<const _OrthancPluginConvertPixelFormat*>(parameters);
 const ImageAccessor& source = *reinterpret_cast<const ImageAccessor*>(p.source);
-std::auto_ptr<ImageAccessor> target(new Image(Plugins::Convert(p.targetFormat), source.GetWidth(), source.GetHeight()));
+std::auto_ptr<ImageAccessor> target(new Image(Plugins::Convert(p.targetFormat), source.GetWidth(), source.GetHeight(), false));
 ImageProcessing::Convert(*target, source);
-*(p.target) = reinterpret_cast<OrthancPluginImage*>(target.release());
+*(p.target) = ReturnImage(target);
 }
 void OrthancPlugins::GetFontInfo(const void* parameters)
 }
 else
 {
 if (p.instanceId == NULL)
 {
-throw OrthancException(ErrorCode_ParameterOutOfRange);
+throw OrthancException(ErrorCode_NullPointer);
 }
 std::string content;
-pimpl_->context_->ReadFile(content, p.instanceId, FileContentType_Dicom);
+{
+PImpl::ServerContextLock lock(*pimpl_);
+lock.GetContext().ReadDicom(content, p.instanceId);
+}
 dicom.reset(new ParsedDicomFile(content));
 }
 Json::Value json;
-dicom->ToJson(json, Plugins::Convert(p.format),
+dicom->DatasetToJson(json, Plugins::Convert(p.format),
 static_cast<DicomToJsonFlags>(p.flags), p.maxStringLength);
 Json::FastWriter writer;
 *p.result = CopyString(writer.write(json));
 }
-bool OrthancPlugins::InvokeService(SharedLibrary& plugin,
+void OrthancPlugins::ApplyCreateDicom(_OrthancPluginService service,
-_OrthancPluginService service,
+const void* parameters)
-const void* parameters)
+{
-{
+const _OrthancPluginCreateDicom& p =
-VLOG(1) << "Calling service " << service << " from plugin " << plugin.GetPath();
+*reinterpret_cast<const _OrthancPluginCreateDicom*>(parameters);
-boost::recursive_mutex::scoped_lock lock(pimpl_->invokeServiceMutex_);
+Json::Value json;
+if (p.json == NULL)
+{
+json = Json::objectValue;
+}
+else
+{
+Json::Reader reader;
+if (!reader.parse(p.json, json))
+{
+throw OrthancException(ErrorCode_BadJson);
+}
+}
+std::string dicom;
+{
+std::auto_ptr<ParsedDicomFile> file
+(ParsedDicomFile::CreateFromJson(json, static_cast<DicomFromJsonFlags>(p.flags)));
+if (p.pixelData)
+{
+file->EmbedImage(*reinterpret_cast<const ImageAccessor*>(p.pixelData));
+}
+file->SaveToMemoryBuffer(dicom);
+}
+CopyToMemoryBuffer(*p.target, dicom);
+}
+void OrthancPlugins::ComputeHash(_OrthancPluginService service,
+const void* parameters)
+{
+const _OrthancPluginComputeHash& p =
+*reinterpret_cast<const _OrthancPluginComputeHash*>(parameters);
+std::string hash;
 switch (service)
 {
+case _OrthancPluginService_ComputeMd5:
+Toolbox::ComputeMD5(hash, p.buffer, p.size);
+break;
+case _OrthancPluginService_ComputeSha1:
+Toolbox::ComputeSHA1(hash, p.buffer, p.size);
+break;
+default:
+throw OrthancException(ErrorCode_ParameterOutOfRange);
+}
+*p.result = CopyString(hash);
+}
+void OrthancPlugins::ApplyCreateImage(_OrthancPluginService service,
+const void* parameters)
+{
+const _OrthancPluginCreateImage& p =
+*reinterpret_cast<const _OrthancPluginCreateImage*>(parameters);
+std::auto_ptr<ImageAccessor> result;
+switch (service)
+{
+case _OrthancPluginService_CreateImage:
+result.reset(new Image(Plugins::Convert(p.format), p.width, p.height, false));
+break;
+case _OrthancPluginService_CreateImageAccessor:
+result.reset(new ImageAccessor);
+result->AssignWritable(Plugins::Convert(p.format), p.width, p.height, p.pitch, p.buffer);
+break;
+case _OrthancPluginService_DecodeDicomImage:
+{
+result.reset(Decode(p.constBuffer, p.bufferSize, p.frameIndex));
+break;
+}
+default:
+throw OrthancException(ErrorCode_InternalError);
+}
+*(p.target) = ReturnImage(result);
+}
+void OrthancPlugins::ApplySendMultipartItem(const void* parameters)
+{
+// An exception might be raised in this function if the
+// connection was closed by the HTTP client.
+const _OrthancPluginAnswerBuffer& p =
+*reinterpret_cast<const _OrthancPluginAnswerBuffer*>(parameters);
+HttpOutput* output = reinterpret_cast<HttpOutput*>(p.output);
+std::map<std::string, std::string> headers;  // No custom headers
+output->SendMultipartItem(p.answer, p.answerSize, headers);
+}
+void OrthancPlugins::ApplySendMultipartItem2(const void* parameters)
+{
+// An exception might be raised in this function if the
+// connection was closed by the HTTP client.
+const _OrthancPluginSendMultipartItem2& p =
+*reinterpret_cast<const _OrthancPluginSendMultipartItem2*>(parameters);
+HttpOutput* output = reinterpret_cast<HttpOutput*>(p.output);
+std::map<std::string, std::string> headers;
+for (uint32_t i = 0; i < p.headersCount; i++)
+{
+headers[p.headersKeys[i]] = p.headersValues[i];
+}
+output->SendMultipartItem(p.answer, p.answerSize, headers);
+}
+void OrthancPlugins::DatabaseAnswer(const void* parameters)
+{
+const _OrthancPluginDatabaseAnswer& p =
+*reinterpret_cast<const _OrthancPluginDatabaseAnswer*>(parameters);
+if (pimpl_->database_.get() != NULL)
+{
+pimpl_->database_->AnswerReceived(p);
+}
+else
+{
+LOG(ERROR) << "Cannot invoke this service without a custom database back-end";
+throw OrthancException(ErrorCode_BadRequest);
+}
+}
+namespace
+{
+class DictionaryReadLocker
+{
+private:
+const DcmDataDictionary& dictionary_;
+public:
+DictionaryReadLocker() : dictionary_(dcmDataDict.rdlock())
+{
+}
+~DictionaryReadLocker()
+{
+dcmDataDict.unlock();
+}
+const DcmDataDictionary* operator->()
+{
+return &dictionary_;
+}
+};
+}
+void OrthancPlugins::ApplyLookupDictionary(const void* parameters)
+{
+const _OrthancPluginLookupDictionary& p =
+*reinterpret_cast<const _OrthancPluginLookupDictionary*>(parameters);
+DicomTag tag(FromDcmtkBridge::ParseTag(p.name));
+DcmTagKey tag2(tag.GetGroup(), tag.GetElement());
+DictionaryReadLocker locker;
+const DcmDictEntry* entry = locker->findEntry(tag2, NULL);
+if (entry == NULL)
+{
+throw OrthancException(ErrorCode_UnknownDicomTag);
+}
+else
+{
+p.target->group = entry->getKey().getGroup();
+p.target->element = entry->getKey().getElement();
+p.target->vr = Plugins::Convert(FromDcmtkBridge::Convert(entry->getEVR()));
+p.target->minMultiplicity = static_cast<uint32_t>(entry->getVMMin());
+p.target->maxMultiplicity = (entry->getVMMax() == DcmVariableVM ? 0 : static_cast<uint32_t>(entry->getVMMax()));
+}
+}
+bool OrthancPlugins::InvokeSafeService(SharedLibrary& plugin,
+_OrthancPluginService service,
+const void* parameters)
+{
+// Services that can be run without mutual exclusion
+switch (service)
+{
 case _OrthancPluginService_GetOrthancPath:
 {
-std::string s = Toolbox::GetPathToExecutable();
+std::string s = SystemToolbox::GetPathToExecutable();
 *reinterpret_cast<const _OrthancPluginRetrieveDynamicString*>(parameters)->result = CopyString(s);
 return true;
 }
 case _OrthancPluginService_GetOrthancDirectory:
 {
-std::string s = Toolbox::GetDirectoryOfExecutable();
+std::string s = SystemToolbox::GetDirectoryOfExecutable();
 *reinterpret_cast<const _OrthancPluginRetrieveDynamicString*>(parameters)->result = CopyString(s);
 return true;
 }
 case _OrthancPluginService_GetConfigurationPath:
 case _OrthancPluginService_BufferCompression:
 BufferCompression(parameters);
 return true;
-case _OrthancPluginService_RegisterRestCallback:
-RegisterRestCallback(parameters, true);
-return true;
-case _OrthancPluginService_RegisterRestCallbackNoLock:
-RegisterRestCallback(parameters, false);
-return true;
-case _OrthancPluginService_RegisterOnStoredInstanceCallback:
-RegisterOnStoredInstanceCallback(parameters);
-return true;
-case _OrthancPluginService_RegisterOnChangeCallback:
-RegisterOnChangeCallback(parameters);
-return true;
 case _OrthancPluginService_AnswerBuffer:
 AnswerBuffer(parameters);
 return true;
 case _OrthancPluginService_CompressAndAnswerPngImage:
 RestApiGet(parameters, false);
 return true;
 case _OrthancPluginService_RestApiGetAfterPlugins:
 RestApiGet(parameters, true);
+return true;
+case _OrthancPluginService_RestApiGet2:
+RestApiGet2(parameters);
 return true;
 case _OrthancPluginService_RestApiPost:
 RestApiPostPut(true, parameters, false);
 return true;
 case _OrthancPluginService_GetInstanceData:
 case _OrthancPluginService_GetInstanceJson:
 case _OrthancPluginService_GetInstanceSimplifiedJson:
 case _OrthancPluginService_HasInstanceMetadata:
 case _OrthancPluginService_GetInstanceMetadata:
+case _OrthancPluginService_GetInstanceOrigin:
 AccessDicomInstance(service, parameters);
 return true;
-case _OrthancPluginService_RegisterStorageArea:
-{
-LOG(INFO) << "Plugin has registered a custom storage area";
-const _OrthancPluginRegisterStorageArea& p =
-*reinterpret_cast<const _OrthancPluginRegisterStorageArea*>(parameters);
-if (pimpl_->storageArea_.get() == NULL)
-{
-pimpl_->storageArea_.reset(new StorageAreaFactory(plugin, p, GetErrorDictionary()));
-}
-else
-{
-throw OrthancException(ErrorCode_StorageAreaAlreadyRegistered);
-}
-return true;
-}
-case _OrthancPluginService_SetPluginProperty:
-{
-const _OrthancPluginSetPluginProperty& p =
-*reinterpret_cast<const _OrthancPluginSetPluginProperty*>(parameters);
-pimpl_->properties_[std::make_pair(p.plugin, p.property)] = p.value;
-return true;
-}
 case _OrthancPluginService_SetGlobalProperty:
 {
 const _OrthancPluginGlobalProperty& p =
 *reinterpret_cast<const _OrthancPluginGlobalProperty*>(parameters);
 {
 return false;
 }
 else
 {
-CheckContextAvailable();
+PImpl::ServerContextLock lock(*pimpl_);
-pimpl_->context_->GetIndex().SetGlobalProperty(static_cast<GlobalProperty>(p.property), p.value);
+lock.GetContext().GetIndex().SetGlobalProperty(static_cast<GlobalProperty>(p.property), p.value);
 return true;
 }
 }
 case _OrthancPluginService_GetGlobalProperty:
 {
-CheckContextAvailable();
 const _OrthancPluginGlobalProperty& p =
 *reinterpret_cast<const _OrthancPluginGlobalProperty*>(parameters);
-std::string result = pimpl_->context_->GetIndex().GetGlobalProperty(static_cast<GlobalProperty>(p.property), p.value);
+std::string result;
+{
+PImpl::ServerContextLock lock(*pimpl_);
+result = lock.GetContext().GetIndex().GetGlobalProperty(static_cast<GlobalProperty>(p.property), p.value);
+}
 *(p.result) = CopyString(result);
 return true;
-}
-case _OrthancPluginService_GetCommandLineArgumentsCount:
-{
-const _OrthancPluginReturnSingleValue& p =
-*reinterpret_cast<const _OrthancPluginReturnSingleValue*>(parameters);
-*(p.resultUint32) = pimpl_->argc_ - 1;
-return true;
-}
-case _OrthancPluginService_GetCommandLineArgument:
-{
-const _OrthancPluginGlobalProperty& p =
-*reinterpret_cast<const _OrthancPluginGlobalProperty*>(parameters);
-if (p.property + 1 > pimpl_->argc_)
-{
-return false;
-}
-else
-{
-std::string arg = std::string(pimpl_->argv_[p.property + 1]);
-*(p.result) = CopyString(arg);
-return true;
-}
-}
-case _OrthancPluginService_RegisterDatabaseBackend:
-{
-LOG(INFO) << "Plugin has registered a custom database back-end";
-const _OrthancPluginRegisterDatabaseBackend& p =
-*reinterpret_cast<const _OrthancPluginRegisterDatabaseBackend*>(parameters);
-if (pimpl_->database_.get() == NULL)
-{
-pimpl_->database_.reset(new OrthancPluginDatabase(plugin, GetErrorDictionary(),
-*p.backend, NULL, 0, p.payload));
-}
-else
-{
-throw OrthancException(ErrorCode_DatabaseBackendAlreadyRegistered);
-}
-*(p.result) = reinterpret_cast<OrthancPluginDatabaseContext*>(pimpl_->database_.get());
-return true;
-}
-case _OrthancPluginService_RegisterDatabaseBackendV2:
-{
-LOG(INFO) << "Plugin has registered a custom database back-end";
-const _OrthancPluginRegisterDatabaseBackendV2& p =
-*reinterpret_cast<const _OrthancPluginRegisterDatabaseBackendV2*>(parameters);
-if (pimpl_->database_.get() == NULL)
-{
-pimpl_->database_.reset(new OrthancPluginDatabase(plugin, GetErrorDictionary(),
-*p.backend, p.extensions,
-p.extensionsSize, p.payload));
-}
-else
-{
-throw OrthancException(ErrorCode_DatabaseBackendAlreadyRegistered);
-}
-*(p.result) = reinterpret_cast<OrthancPluginDatabaseContext*>(pimpl_->database_.get());
-return true;
-}
-case _OrthancPluginService_DatabaseAnswer:
-{
-const _OrthancPluginDatabaseAnswer& p =
-*reinterpret_cast<const _OrthancPluginDatabaseAnswer*>(parameters);
-if (pimpl_->database_.get() != NULL)
-{
-pimpl_->database_->AnswerReceived(p);
-return true;
-}
-else
-{
-LOG(ERROR) << "Cannot invoke this service without a custom database back-end";
-throw OrthancException(ErrorCode_BadRequest);
-}
 }
 case _OrthancPluginService_GetExpectedDatabaseVersion:
 {
 const _OrthancPluginReturnSingleValue& p =
 output->StartMultipart(p.subType, p.contentType);
 return true;
 }
 case _OrthancPluginService_SendMultipartItem:
-{
+ApplySendMultipartItem(parameters);
-// An exception might be raised in this function if the
+return true;
-// connection was closed by the HTTP client.
-const _OrthancPluginAnswerBuffer& p =
+case _OrthancPluginService_SendMultipartItem2:
-*reinterpret_cast<const _OrthancPluginAnswerBuffer*>(parameters);
+ApplySendMultipartItem2(parameters);
-HttpOutput* output = reinterpret_cast<HttpOutput*>(p.output);
+return true;
-output->SendMultipartItem(p.answer, p.answerSize);
-return true;
-}
 case _OrthancPluginService_ReadFile:
 {
 const _OrthancPluginReadFile& p =
 *reinterpret_cast<const _OrthancPluginReadFile*>(parameters);
 std::string content;
-Toolbox::ReadFile(content, p.path);
+SystemToolbox::ReadFile(content, p.path);
 CopyToMemoryBuffer(*p.target, content.size() > 0 ? content.c_str() : NULL, content.size());
 return true;
 }
 case _OrthancPluginService_WriteFile:
 {
 const _OrthancPluginWriteFile& p =
 *reinterpret_cast<const _OrthancPluginWriteFile*>(parameters);
-Toolbox::WriteFile(p.data, p.size, p.path);
+SystemToolbox::WriteFile(p.data, p.size, p.path);
 return true;
 }
 case _OrthancPluginService_GetErrorDescription:
 {
 }
 case _OrthancPluginService_GetImageBuffer:
 {
 const _OrthancPluginGetImageInfo& p = *reinterpret_cast<const _OrthancPluginGetImageInfo*>(parameters);
-*(p.resultBuffer) = reinterpret_cast<const ImageAccessor*>(p.image)->GetConstBuffer();
+*(p.resultBuffer) = reinterpret_cast<const ImageAccessor*>(p.image)->GetBuffer();
 return true;
 }
 case _OrthancPluginService_FreeImage:
 {
 const _OrthancPluginFreeImage& p = *reinterpret_cast<const _OrthancPluginFreeImage*>(parameters);
-if (p.image == NULL)
-{
+if (p.image != NULL)
-throw OrthancException(ErrorCode_ParameterOutOfRange);
-}
-else
 {
 delete reinterpret_cast<ImageAccessor*>(p.image);
-return true;
+}
-}
+return true;
 }
 case _OrthancPluginService_UncompressImage:
 UncompressImage(parameters);
 return true;
 CompressImage(parameters);
 return true;
 case _OrthancPluginService_CallHttpClient:
 CallHttpClient(parameters);
+return true;
+case _OrthancPluginService_CallHttpClient2:
+CallHttpClient2(parameters);
 return true;
 case _OrthancPluginService_ConvertPixelFormat:
 ConvertPixelFormat(parameters);
 return true;
 case _OrthancPluginService_StorageAreaCreate:
 {
 const _OrthancPluginStorageAreaCreate& p =
 *reinterpret_cast<const _OrthancPluginStorageAreaCreate*>(parameters);
 IStorageArea& storage = *reinterpret_cast<IStorageArea*>(p.storageArea);
-storage.Create(p.uuid, p.content, p.size, Plugins::Convert(p.type));
+storage.Create(p.uuid, p.content, static_cast<size_t>(p.size), Plugins::Convert(p.type));
 return true;
 }
 case _OrthancPluginService_StorageAreaRead:
 {
 IStorageArea& storage = *reinterpret_cast<IStorageArea*>(p.storageArea);
 storage.Remove(p.uuid, Plugins::Convert(p.type));
 return true;
 }
+case _OrthancPluginService_DicomBufferToJson:
+case _OrthancPluginService_DicomInstanceToJson:
+ApplyDicomToJson(service, parameters);
+return true;
+case _OrthancPluginService_CreateDicom:
+ApplyCreateDicom(service, parameters);
+return true;
+case _OrthancPluginService_WorklistAddAnswer:
+{
+const _OrthancPluginWorklistAnswersOperation& p =
+*reinterpret_cast<const _OrthancPluginWorklistAnswersOperation*>(parameters);
+reinterpret_cast<const WorklistHandler*>(p.query)->AddAnswer(p.answers, p.dicom, p.size);
+return true;
+}
+case _OrthancPluginService_WorklistMarkIncomplete:
+{
+const _OrthancPluginWorklistAnswersOperation& p =
+*reinterpret_cast<const _OrthancPluginWorklistAnswersOperation*>(parameters);
+reinterpret_cast<DicomFindAnswers*>(p.answers)->SetComplete(false);
+return true;
+}
+case _OrthancPluginService_WorklistIsMatch:
+{
+const _OrthancPluginWorklistQueryOperation& p =
+*reinterpret_cast<const _OrthancPluginWorklistQueryOperation*>(parameters);
+*p.isMatch = reinterpret_cast<const WorklistHandler*>(p.query)->IsMatch(p.dicom, p.size);
+return true;
+}
+case _OrthancPluginService_WorklistGetDicomQuery:
+{
+const _OrthancPluginWorklistQueryOperation& p =
+*reinterpret_cast<const _OrthancPluginWorklistQueryOperation*>(parameters);
+reinterpret_cast<const WorklistHandler*>(p.query)->GetDicomQuery(*p.target);
+return true;
+}
+case _OrthancPluginService_FindAddAnswer:
+{
+const _OrthancPluginFindOperation& p =
+*reinterpret_cast<const _OrthancPluginFindOperation*>(parameters);
+reinterpret_cast<DicomFindAnswers*>(p.answers)->Add(p.dicom, p.size);
+return true;
+}
+case _OrthancPluginService_FindMarkIncomplete:
+{
+const _OrthancPluginFindOperation& p =
+*reinterpret_cast<const _OrthancPluginFindOperation*>(parameters);
+reinterpret_cast<DicomFindAnswers*>(p.answers)->SetComplete(false);
+return true;
+}
+case _OrthancPluginService_GetFindQuerySize:
+case _OrthancPluginService_GetFindQueryTag:
+case _OrthancPluginService_GetFindQueryTagName:
+case _OrthancPluginService_GetFindQueryValue:
+{
+const _OrthancPluginFindOperation& p =
+*reinterpret_cast<const _OrthancPluginFindOperation*>(parameters);
+reinterpret_cast<const FindHandler*>(p.query)->Invoke(service, p);
+return true;
+}
+case _OrthancPluginService_CreateImage:
+case _OrthancPluginService_CreateImageAccessor:
+case _OrthancPluginService_DecodeDicomImage:
+ApplyCreateImage(service, parameters);
+return true;
+case _OrthancPluginService_ComputeMd5:
+case _OrthancPluginService_ComputeSha1:
+ComputeHash(service, parameters);
+return true;
+case _OrthancPluginService_LookupDictionary:
+ApplyLookupDictionary(parameters);
+return true;
+case _OrthancPluginService_GenerateUuid:
+{
+*reinterpret_cast<const _OrthancPluginRetrieveDynamicString*>(parameters)->result =
+CopyString(Toolbox::GenerateUuid());
+return true;
+}
+case _OrthancPluginService_CreateFindMatcher:
+{
+const _OrthancPluginCreateFindMatcher& p =
+*reinterpret_cast<const _OrthancPluginCreateFindMatcher*>(parameters);
+ParsedDicomFile query(p.query, p.size);
+*(p.target) = reinterpret_cast<OrthancPluginFindMatcher*>(new HierarchicalMatcher(query));
+return true;
+}
+case _OrthancPluginService_FreeFindMatcher:
+{
+const _OrthancPluginFreeFindMatcher& p =
+*reinterpret_cast<const _OrthancPluginFreeFindMatcher*>(parameters);
+if (p.matcher != NULL)
+{
+delete reinterpret_cast<HierarchicalMatcher*>(p.matcher);
+}
+return true;
+}
+case _OrthancPluginService_FindMatcherIsMatch:
+{
+const _OrthancPluginFindMatcherIsMatch& p =
+*reinterpret_cast<const _OrthancPluginFindMatcherIsMatch*>(parameters);
+if (p.matcher == NULL)
+{
+throw OrthancException(ErrorCode_NullPointer);
+}
+else
+{
+ParsedDicomFile query(p.dicom, p.size);
+*p.isMatch = reinterpret_cast<const HierarchicalMatcher*>(p.matcher)->Match(query) ? 1 : 0;
+return true;
+}
+}
+case _OrthancPluginService_GetPeers:
+{
+const _OrthancPluginGetPeers& p =
+*reinterpret_cast<const _OrthancPluginGetPeers*>(parameters);
+*(p.peers) = reinterpret_cast<OrthancPluginPeers*>(new OrthancPeers);
+return true;
+}
+case _OrthancPluginService_FreePeers:
+{
+const _OrthancPluginFreePeers& p =
+*reinterpret_cast<const _OrthancPluginFreePeers*>(parameters);
+if (p.peers != NULL)
+{
+delete reinterpret_cast<OrthancPeers*>(p.peers);
+}
+return true;
+}
+case _OrthancPluginService_GetPeersCount:
+{
+const _OrthancPluginGetPeersCount& p =
+*reinterpret_cast<const _OrthancPluginGetPeersCount*>(parameters);
+if (p.peers == NULL)
+{
+throw OrthancException(ErrorCode_NullPointer);
+}
+else
+{
+*(p.target) = reinterpret_cast<const OrthancPeers*>(p.peers)->GetPeersCount();
+return true;
+}
+}
+case _OrthancPluginService_GetPeerName:
+{
+const _OrthancPluginGetPeerProperty& p =
+*reinterpret_cast<const _OrthancPluginGetPeerProperty*>(parameters);
+if (p.peers == NULL)
+{
+throw OrthancException(ErrorCode_NullPointer);
+}
+else
+{
+*(p.target) = reinterpret_cast<const OrthancPeers*>(p.peers)->GetPeerName(p.peerIndex).c_str();
+return true;
+}
+}
+case _OrthancPluginService_GetPeerUrl:
+{
+const _OrthancPluginGetPeerProperty& p =
+*reinterpret_cast<const _OrthancPluginGetPeerProperty*>(parameters);
+if (p.peers == NULL)
+{
+throw OrthancException(ErrorCode_NullPointer);
+}
+else
+{
+*(p.target) = reinterpret_cast<const OrthancPeers*>(p.peers)->GetPeerParameters(p.peerIndex).GetUrl().c_str();
+return true;
+}
+}
+case _OrthancPluginService_GetPeerUserProperty:
+{
+const _OrthancPluginGetPeerProperty& p =
+*reinterpret_cast<const _OrthancPluginGetPeerProperty*>(parameters);
+if (p.peers == NULL ||
+p.userProperty == NULL)
+{
+throw OrthancException(ErrorCode_NullPointer);
+}
+else
+{
+const WebServiceParameters::Dictionary& properties =
+reinterpret_cast<const OrthancPeers*>(p.peers)->GetPeerParameters(p.peerIndex).GetUserProperties();
+WebServiceParameters::Dictionary::const_iterator found =
+properties.find(p.userProperty);
+if (found == properties.end())
+{
+*(p.target) = NULL;
+}
+else
+{
+*(p.target) = found->second.c_str();
+}
+return true;
+}
+}
+case _OrthancPluginService_CallPeerApi:
+CallPeerApi(parameters);
+return true;
+case _OrthancPluginService_CreateJob:
+{
+const _OrthancPluginCreateJob& p =
+*reinterpret_cast<const _OrthancPluginCreateJob*>(parameters);
+*(p.target) = reinterpret_cast<OrthancPluginJob*>(new PluginsJob(p));
+return true;
+}
+case _OrthancPluginService_FreeJob:
+{
+const _OrthancPluginFreeJob& p =
+*reinterpret_cast<const _OrthancPluginFreeJob*>(parameters);
+if (p.job != NULL)
+{
+delete reinterpret_cast<PluginsJob*>(p.job);
+}
+return true;
+}
+case _OrthancPluginService_SubmitJob:
+{
+const _OrthancPluginSubmitJob& p =
+*reinterpret_cast<const _OrthancPluginSubmitJob*>(parameters);
+std::string uuid;
+PImpl::ServerContextLock lock(*pimpl_);
+lock.GetContext().GetJobsEngine().GetRegistry().Submit
+(uuid, reinterpret_cast<PluginsJob*>(p.job), p.priority);
+*p.resultId = CopyString(uuid);
+return true;
+}
+default:
+return false;
+}
+}
+bool OrthancPlugins::InvokeProtectedService(SharedLibrary& plugin,
+_OrthancPluginService service,
+const void* parameters)
+{
+// Services that must be run in mutual exclusion. Guideline:
+// Whenever "pimpl_" is directly accessed by the service, it
+// should be listed here.
+switch (service)
+{
+case _OrthancPluginService_RegisterRestCallback:
+RegisterRestCallback(parameters, true);
+return true;
+case _OrthancPluginService_RegisterRestCallbackNoLock:
+RegisterRestCallback(parameters, false);
+return true;
+case _OrthancPluginService_RegisterOnStoredInstanceCallback:
+RegisterOnStoredInstanceCallback(parameters);
+return true;
+case _OrthancPluginService_RegisterOnChangeCallback:
+RegisterOnChangeCallback(parameters);
+return true;
+case _OrthancPluginService_RegisterWorklistCallback:
+RegisterWorklistCallback(parameters);
+return true;
+case _OrthancPluginService_RegisterFindCallback:
+RegisterFindCallback(parameters);
+return true;
+case _OrthancPluginService_RegisterMoveCallback:
+RegisterMoveCallback(parameters);
+return true;
+case _OrthancPluginService_RegisterDecodeImageCallback:
+RegisterDecodeImageCallback(parameters);
+return true;
+case _OrthancPluginService_RegisterJobsUnserializer:
+RegisterJobsUnserializer(parameters);
+return true;
+case _OrthancPluginService_RegisterIncomingHttpRequestFilter:
+RegisterIncomingHttpRequestFilter(parameters);
+return true;
+case _OrthancPluginService_RegisterIncomingHttpRequestFilter2:
+RegisterIncomingHttpRequestFilter2(parameters);
+return true;
+case _OrthancPluginService_RegisterStorageArea:
+{
+LOG(INFO) << "Plugin has registered a custom storage area";
+const _OrthancPluginRegisterStorageArea& p =
+*reinterpret_cast<const _OrthancPluginRegisterStorageArea*>(parameters);
+if (pimpl_->storageArea_.get() == NULL)
+{
+pimpl_->storageArea_.reset(new StorageAreaFactory(plugin, p, GetErrorDictionary()));
+}
+else
+{
+throw OrthancException(ErrorCode_StorageAreaAlreadyRegistered);
+}
+return true;
+}
+case _OrthancPluginService_SetPluginProperty:
+{
+const _OrthancPluginSetPluginProperty& p =
+*reinterpret_cast<const _OrthancPluginSetPluginProperty*>(parameters);
+pimpl_->properties_[std::make_pair(p.plugin, p.property)] = p.value;
+return true;
+}
+case _OrthancPluginService_GetCommandLineArgumentsCount:
+{
+const _OrthancPluginReturnSingleValue& p =
+*reinterpret_cast<const _OrthancPluginReturnSingleValue*>(parameters);
+*(p.resultUint32) = pimpl_->argc_ - 1;
+return true;
+}
+case _OrthancPluginService_GetCommandLineArgument:
+{
+const _OrthancPluginGlobalProperty& p =
+*reinterpret_cast<const _OrthancPluginGlobalProperty*>(parameters);
+if (p.property + 1 > pimpl_->argc_)
+{
+return false;
+}
+else
+{
+std::string arg = std::string(pimpl_->argv_[p.property + 1]);
+*(p.result) = CopyString(arg);
+return true;
+}
+}
+case _OrthancPluginService_RegisterDatabaseBackend:
+{
+LOG(INFO) << "Plugin has registered a custom database back-end";
+const _OrthancPluginRegisterDatabaseBackend& p =
+*reinterpret_cast<const _OrthancPluginRegisterDatabaseBackend*>(parameters);
+if (pimpl_->database_.get() == NULL)
+{
+pimpl_->database_.reset(new OrthancPluginDatabase(plugin, GetErrorDictionary(),
+*p.backend, NULL, 0, p.payload));
+}
+else
+{
+throw OrthancException(ErrorCode_DatabaseBackendAlreadyRegistered);
+}
+*(p.result) = reinterpret_cast<OrthancPluginDatabaseContext*>(pimpl_->database_.get());
+return true;
+}
+case _OrthancPluginService_RegisterDatabaseBackendV2:
+{
+LOG(INFO) << "Plugin has registered a custom database back-end";
+const _OrthancPluginRegisterDatabaseBackendV2& p =
+*reinterpret_cast<const _OrthancPluginRegisterDatabaseBackendV2*>(parameters);
+if (pimpl_->database_.get() == NULL)
+{
+pimpl_->database_.reset(new OrthancPluginDatabase(plugin, GetErrorDictionary(),
+*p.backend, p.extensions,
+p.extensionsSize, p.payload));
+}
+else
+{
+throw OrthancException(ErrorCode_DatabaseBackendAlreadyRegistered);
+}
+*(p.result) = reinterpret_cast<OrthancPluginDatabaseContext*>(pimpl_->database_.get());
+return true;
+}
+case _OrthancPluginService_DatabaseAnswer:
+throw OrthancException(ErrorCode_InternalError);   // Implemented before locking (*)
 case _OrthancPluginService_RegisterErrorCode:
 {
 const _OrthancPluginRegisterErrorCode& p =
 *reinterpret_cast<const _OrthancPluginRegisterErrorCode*>(parameters);
 *(p.target) = pimpl_->dictionary_.Register(plugin, p.code, p.httpStatus, p.message);
 {
 const _OrthancPluginRegisterDictionaryTag& p =
 *reinterpret_cast<const _OrthancPluginRegisterDictionaryTag*>(parameters);
 FromDcmtkBridge::RegisterDictionaryTag(DicomTag(p.group, p.element),
 Plugins::Convert(p.vr), p.name,
-p.minMultiplicity, p.maxMultiplicity);
+p.minMultiplicity, p.maxMultiplicity, "");
+return true;
+}
+case _OrthancPluginService_RegisterPrivateDictionaryTag:
+{
+const _OrthancPluginRegisterPrivateDictionaryTag& p =
+*reinterpret_cast<const _OrthancPluginRegisterPrivateDictionaryTag*>(parameters);
+FromDcmtkBridge::RegisterDictionaryTag(DicomTag(p.group, p.element),
+Plugins::Convert(p.vr), p.name,
+p.minMultiplicity, p.maxMultiplicity, p.privateCreator);
 return true;
 }
 case _OrthancPluginService_ReconstructMainDicomTags:
 {
 LOG(ERROR) << "The service ReconstructMainDicomTags can only be invoked by custom database plugins";
 throw OrthancException(ErrorCode_DatabasePlugin);
 }
 IStorageArea& storage = *reinterpret_cast<IStorageArea*>(p.storageArea);
-Toolbox::ReconstructMainDicomTags(*pimpl_->database_, storage, Plugins::Convert(p.level));
+ServerToolbox::ReconstructMainDicomTags(*pimpl_->database_, storage, Plugins::Convert(p.level));
 return true;
 }
-case _OrthancPluginService_DicomBufferToJson:
-case _OrthancPluginService_DicomInstanceToJson:
-ApplyDicomToJson(service, parameters);
-return true;
 default:
 {
 // This service is unknown to the Orthanc plugin engine
 return false;
 }
 }
 }
+bool OrthancPlugins::InvokeService(SharedLibrary& plugin,
+_OrthancPluginService service,
+const void* parameters)
+{
+VLOG(1) << "Calling service " << service << " from plugin " << plugin.GetPath();
+if (service == _OrthancPluginService_DatabaseAnswer)
+{
+// This case solves a deadlock at (*) reported by James Webster
+// on 2015-10-27 that was present in versions of Orthanc <=
+// 0.9.4 and related to database plugins implementing a custom
+// index. The problem was that locking the database is already
+// ensured by the "ServerIndex" class if the invoked service is
+// "DatabaseAnswer".
+DatabaseAnswer(parameters);
+return true;
+}
+if (InvokeSafeService(plugin, service, parameters))
+{
+// The invoked service does not require locking
+return true;
+}
+else
+{
+// The invoked service requires locking
+boost::recursive_mutex::scoped_lock lock(pimpl_->invokeServiceMutex_);   // (*)
+return InvokeProtectedService(plugin, service, parameters);
+}
+}
 bool OrthancPlugins::HasStorageArea() const
 {
+boost::recursive_mutex::scoped_lock lock(pimpl_->invokeServiceMutex_);
 return pimpl_->storageArea_.get() != NULL;
 }
 bool OrthancPlugins::HasDatabaseBackend() const
 {
+boost::recursive_mutex::scoped_lock lock(pimpl_->invokeServiceMutex_);
 return pimpl_->database_.get() != NULL;
 }
 IStorageArea* OrthancPlugins::CreateStorageArea()
 PluginsErrorDictionary&  OrthancPlugins::GetErrorDictionary()
 {
 return pimpl_->dictionary_;
 }
+IWorklistRequestHandler* OrthancPlugins::ConstructWorklistRequestHandler()
+{
+if (HasWorklistHandler())
+{
+return new WorklistHandler(*this);
+}
+else
+{
+return NULL;
+}
+}
+bool OrthancPlugins::HasWorklistHandler()
+{
+boost::mutex::scoped_lock lock(pimpl_->worklistCallbackMutex_);
+return pimpl_->worklistCallback_ != NULL;
+}
+IFindRequestHandler* OrthancPlugins::ConstructFindRequestHandler()
+{
+if (HasFindHandler())
+{
+return new FindHandler(*this);
+}
+else
+{
+return NULL;
+}
+}
+bool OrthancPlugins::HasFindHandler()
+{
+boost::mutex::scoped_lock lock(pimpl_->findCallbackMutex_);
+return pimpl_->findCallback_ != NULL;
+}
+IMoveRequestHandler* OrthancPlugins::ConstructMoveRequestHandler()
+{
+if (HasMoveHandler())
+{
+return new MoveHandler(*this);
+}
+else
+{
+return NULL;
+}
+}
+bool OrthancPlugins::HasMoveHandler()
+{
+boost::recursive_mutex::scoped_lock lock(pimpl_->invokeServiceMutex_);
+return pimpl_->moveCallbacks_.callback != NULL;
+}
+bool OrthancPlugins::HasCustomImageDecoder()
+{
+boost::mutex::scoped_lock lock(pimpl_->decodeImageCallbackMutex_);
+return !pimpl_->decodeImageCallbacks_.empty();
+}
+ImageAccessor*  OrthancPlugins::DecodeUnsafe(const void* dicom,
+size_t size,
+unsigned int frame)
+{
+boost::mutex::scoped_lock lock(pimpl_->decodeImageCallbackMutex_);
+for (PImpl::DecodeImageCallbacks::const_iterator
+decoder = pimpl_->decodeImageCallbacks_.begin();
+decoder != pimpl_->decodeImageCallbacks_.end(); ++decoder)
+{
+OrthancPluginImage* pluginImage = NULL;
+if ((*decoder) (&pluginImage, dicom, size, frame) == OrthancPluginErrorCode_Success &&
+pluginImage != NULL)
+{
+return reinterpret_cast<ImageAccessor*>(pluginImage);
+}
+}
+return NULL;
+}
+ImageAccessor* OrthancPlugins::Decode(const void* dicom,
+size_t size,
+unsigned int frame)
+{
+ImageAccessor* result = DecodeUnsafe(dicom, size, frame);
+if (result != NULL)
+{
+return result;
+}
+else
+{
+LOG(INFO) << "The installed image decoding plugins cannot handle an image, fallback to the built-in decoder";
+DefaultDicomImageDecoder defaultDecoder;
+return defaultDecoder.Decode(dicom, size, frame);
+}
+}
+bool OrthancPlugins::IsAllowed(HttpMethod method,
+const char* uri,
+const char* ip,
+const char* username,
+const IHttpHandler::Arguments& httpHeaders,
+const IHttpHandler::GetArguments& getArguments)
+{
+OrthancPluginHttpMethod cMethod = Plugins::Convert(method);
+std::vector<const char*> httpKeys(httpHeaders.size());
+std::vector<const char*> httpValues(httpHeaders.size());
+size_t pos = 0;
+for (IHttpHandler::Arguments::const_iterator
+it = httpHeaders.begin(); it != httpHeaders.end(); ++it, pos++)
+{
+httpKeys[pos] = it->first.c_str();
+httpValues[pos] = it->second.c_str();
+}
+std::vector<const char*> getKeys(getArguments.size());
+std::vector<const char*> getValues(getArguments.size());
+for (size_t i = 0; i < getArguments.size(); i++)
+{
+getKeys[i] = getArguments[i].first.c_str();
+getValues[i] = getArguments[i].second.c_str();
+}
+// Improved callback with support for GET arguments, since Orthanc 1.3.0
+for (PImpl::IncomingHttpRequestFilters2::const_iterator
+filter = pimpl_->incomingHttpRequestFilters2_.begin();
+filter != pimpl_->incomingHttpRequestFilters2_.end(); ++filter)
+{
+int32_t allowed = (*filter) (cMethod, uri, ip,
+httpKeys.size(),
+httpKeys.empty() ? NULL : &httpKeys[0],
+httpValues.empty() ? NULL : &httpValues[0],
+getKeys.size(),
+getKeys.empty() ? NULL : &getKeys[0],
+getValues.empty() ? NULL : &getValues[0]);
+if (allowed == 0)
+{
+return false;
+}
+else if (allowed != 1)
+{
+// The callback is only allowed to answer 0 or 1
+throw OrthancException(ErrorCode_Plugin);
+}
+}
+for (PImpl::IncomingHttpRequestFilters::const_iterator
+filter = pimpl_->incomingHttpRequestFilters_.begin();
+filter != pimpl_->incomingHttpRequestFilters_.end(); ++filter)
+{
+int32_t allowed = (*filter) (cMethod, uri, ip, httpKeys.size(),
+httpKeys.empty() ? NULL : &httpKeys[0],
+httpValues.empty() ? NULL : &httpValues[0]);
+if (allowed == 0)
+{
+return false;
+}
+else if (allowed != 1)
+{
+// The callback is only allowed to answer 0 or 1
+throw OrthancException(ErrorCode_Plugin);
+}
+}
+return true;
+}
+IJob* OrthancPlugins::UnserializeJob(const std::string& type,
+const Json::Value& value)
+{
+const std::string serialized = value.toStyledString();
+boost::mutex::scoped_lock lock(pimpl_->jobsUnserializersMutex_);
+for (PImpl::JobsUnserializers::iterator
+unserializer = pimpl_->jobsUnserializers_.begin();
+unserializer != pimpl_->jobsUnserializers_.end(); ++unserializer)
+{
+OrthancPluginJob* job = (*unserializer) (type.c_str(), serialized.c_str());
+if (job != NULL)
+{
+return reinterpret_cast<PluginsJob*>(job);
+}
+}
+return NULL;
+}
 }

Mercurial > hg > orthanc

comparison Plugins/Engine/OrthancPlugins.cpp @ 2884:497a637366b4 db-changes