orthanc: OrthancServer/Sources/ServerContext.cpp comparison

comparison OrthancServer/Sources/ServerContext.cpp @ 4819:70d2a97ca8cb openssl-3.x

integration mainline->openssl-3.x

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Thu, 25 Nov 2021 13:12:32 +0100
parents	b2417ac5055a 7afbb54bd028
children	2e71a08eea15

comparison

equal deleted inserted replaced

-:61da49321754
+:70d2a97ca8cb
 #include "ServerJobs/OrthancJobUnserializer.h"
 #include "ServerToolbox.h"
 #include "StorageCommitmentReports.h"
 #include <dcmtk/dcmdata/dcfilefo.h>
+#include <dcmtk/dcmnet/dimse.h>
 static size_t DICOM_CACHE_SIZE = 128 * 1024 * 1024;  // 128 MB
 transferSyntax != DicomTransferSyntax_HEVCMain10ProfileLevel5_1 &&
 // Do not try to transcode special transfer syntaxes
 transferSyntax != DicomTransferSyntax_RFC2557MimeEncapsulation &&
 transferSyntax != DicomTransferSyntax_XML);
+}
+ServerContext::StoreResult::StoreResult() :
+status_(StoreStatus_Failure),
+cstoreStatusCode_(0)
+{
 }
 void ServerContext::ChangeThread(ServerContext* that,
 unsigned int sleepDelay)
 void ServerContext::RemoveFile(const std::string& fileUuid,
 FileContentType type)
 {
-StorageAccessor accessor(area_, GetMetricsRegistry());
+StorageAccessor accessor(area_, storageCache_, GetMetricsRegistry());
 accessor.Remove(fileUuid, type);
 }
-StoreStatus ServerContext::StoreAfterTranscoding(std::string& resultPublicId,
+ServerContext::StoreResult ServerContext::StoreAfterTranscoding(std::string& resultPublicId,
 DicomInstanceToStore& dicom,
 StoreInstanceMode mode)
 {
 bool overwrite;
 switch (mode)
 {
 case StoreInstanceMode_Default:
 dicom.GetSummary(summary);
 try
 {
 MetricsRegistry::Timer timer(GetMetricsRegistry(), "orthanc_store_dicom_duration_ms");
-StorageAccessor accessor(area_, GetMetricsRegistry());
+StorageAccessor accessor(area_, storageCache_, GetMetricsRegistry());
 DicomInstanceHasher hasher(summary);
 resultPublicId = hasher.HashInstance();
 Json::Value dicomAsJson;
 Json::Value simplifiedTags;
 Toolbox::SimplifyDicomAsJson(simplifiedTags, dicomAsJson, DicomToJsonFormat_Human);
 // Test if the instance must be filtered out
-bool accepted = true;
+StoreResult result;
 {
 boost::shared_lock<boost::shared_mutex> lock(listenersMutex_);
 for (ServerListeners::iterator it = listeners_.begin(); it != listeners_.end(); ++it)
 {
 try
 {
 if (!it->GetListener().FilterIncomingInstance(dicom, simplifiedTags))
 {
-accepted = false;
+result.SetStatus(StoreStatus_FilteredOut);
+result.SetCStoreStatusCode(STATUS_Success); // to keep backward compatibility, we still return 'success'
 break;
 }
+if (dicom.GetOrigin().GetRequestOrigin() == Orthanc::RequestOrigin_DicomProtocol)
+{
+uint16_t filterResult = it->GetListener().FilterIncomingCStoreInstance(dicom, simplifiedTags);
+if (filterResult != 0x0000)
+{
+result.SetStatus(StoreStatus_FilteredOut);
+result.SetCStoreStatusCode(filterResult);
+break;
+}
+}
 }
 catch (OrthancException& e)
 {
 LOG(ERROR) << "Error in the " << it->GetDescription()
 << " callback while receiving an instance: " << e.What()
 throw;
 }
 }
 }
-if (!accepted)
+if (result.GetStatus() == StoreStatus_FilteredOut)
 {
 LOG(INFO) << "An incoming instance has been discarded by the filter";
-return StoreStatus_FilteredOut;
+return result;
 }
 // Remove the file from the DicomCache (useful if
 // "OverwriteInstances" is set to "true")
 dicomCache_.Invalidate(resultPublicId);
 attachments.push_back(dicomUntilPixelData);
 }
 typedef std::map<MetadataType, std::string>  InstanceMetadata;
 InstanceMetadata  instanceMetadata;
-StoreStatus status = index_.Store(
+result.SetStatus(index_.Store(
 instanceMetadata, summary, attachments, dicom.GetMetadata(), dicom.GetOrigin(), overwrite,
-hasTransferSyntax, transferSyntax, hasPixelDataOffset, pixelDataOffset);
+hasTransferSyntax, transferSyntax, hasPixelDataOffset, pixelDataOffset));
 // Only keep the metadata for the "instance" level
 dicom.ClearMetadata();
 for (InstanceMetadata::const_iterator it = instanceMetadata.begin();
 it != instanceMetadata.end(); ++it)
 {
 dicom.AddMetadata(ResourceType_Instance, it->first, it->second);
 }
-if (status != StoreStatus_Success)
+if (result.GetStatus() != StoreStatus_Success)
 {
 accessor.Remove(dicomInfo);
 if (dicomUntilPixelData.IsValid())
 {
 accessor.Remove(dicomUntilPixelData);
 }
 }
-switch (status)
+switch (result.GetStatus())
 {
 case StoreStatus_Success:
 LOG(INFO) << "New instance stored";
 break;
 default:
 // This should never happen
 break;
 }
-if (status == StoreStatus_Success ||
+if (result.GetStatus() == StoreStatus_Success ||
-status == StoreStatus_AlreadyStored)
+result.GetStatus() == StoreStatus_AlreadyStored)
 {
 boost::shared_lock<boost::shared_mutex> lock(listenersMutex_);
 for (ServerListeners::iterator it = listeners_.begin(); it != listeners_.end(); ++it)
 {
 << " (code " << e.GetErrorCode() << ")";
 }
 }
 }
-return status;
+return result;
 }
 catch (OrthancException& e)
 {
 if (e.GetErrorCode() == ErrorCode_InexistentTag)
 {
 throw;
 }
 }
-StoreStatus ServerContext::Store(std::string& resultPublicId,
+ServerContext::StoreResult ServerContext::Store(std::string& resultPublicId,
 DicomInstanceToStore& dicom,
 StoreInstanceMode mode)
 {
 if (!isIngestTranscoding_)
 {
 // No automated transcoding. This was the only path in Orthanc <= 1.6.1.
 return StoreAfterTranscoding(resultPublicId, dicom, mode);
 std::unique_ptr<ParsedDicomFile> tmp(transcoded.ReleaseAsParsedDicomFile());
 std::unique_ptr<DicomInstanceToStore> toStore(DicomInstanceToStore::CreateFromParsedDicomFile(*tmp));
 toStore->SetOrigin(dicom.GetOrigin());
-StoreStatus ok = StoreAfterTranscoding(resultPublicId, *toStore, mode);
+StoreResult result = StoreAfterTranscoding(resultPublicId, *toStore, mode);
 assert(resultPublicId == tmp->GetHasher().HashInstance());
-return ok;
+return result;
 }
 else
 {
 // Cannot transcode => store the original file
 return StoreAfterTranscoding(resultPublicId, dicom, mode);
 {
 throw OrthancException(ErrorCode_UnknownResource);
 }
 else
 {
-StorageAccessor accessor(area_, GetMetricsRegistry());
+StorageAccessor accessor(area_, storageCache_, GetMetricsRegistry());
 accessor.AnswerFile(output, attachment, GetFileContentMime(content));
 }
 }
 return;
 }
 std::string content;
-StorageAccessor accessor(area_, GetMetricsRegistry());
+StorageAccessor accessor(area_, storageCache_, GetMetricsRegistry());
 accessor.Read(content, attachment);
 FileInfo modified = accessor.Write(content.empty() ? NULL : content.c_str(),
 content.size(), attachmentType, compression, storeMD5_);
 if (index_.LookupAttachment(attachment, revision, instancePublicId, FileContentType_DicomUntilPixelData))
 {
 std::string dicom;
 {
-StorageAccessor accessor(area_, GetMetricsRegistry());
+StorageAccessor accessor(area_, storageCache_, GetMetricsRegistry());
 accessor.Read(dicom, attachment);
 }
 ParsedDicomFile parsed(dicom);
 OrthancConfiguration::DefaultDicomDatasetToJson(result, parsed, ignoreTagLength);
 * "true".
 **/
 std::unique_ptr<IMemoryBuffer> dicom;
 {
-MetricsRegistry::Timer timer(GetMetricsRegistry(), "orthanc_storage_read_range_duration_ms");
+StorageAccessor accessor(area_, storageCache_, GetMetricsRegistry());
-dicom.reset(area_.ReadRange(attachment.GetUuid(), FileContentType_Dicom, 0, pixelDataOffset));
+dicom.reset(accessor.ReadStartRange(attachment.GetUuid(), FileContentType_Dicom, pixelDataOffset, FileContentType_DicomUntilPixelData));
 }
 if (dicom.get() == NULL)
 {
 throw OrthancException(ErrorCode_InternalError);
 **/
 std::string dicomAsJson;
 {
-StorageAccessor accessor(area_, GetMetricsRegistry());
+StorageAccessor accessor(area_, storageCache_, GetMetricsRegistry());
 accessor.Read(dicomAsJson, attachment);
 }
 if (!Toolbox::ReadJson(result, dicomAsJson))
 {
 const std::string& instancePublicId)
 {
 int64_t revision;
 ReadAttachment(dicom, revision, instancePublicId, FileContentType_Dicom, true /* uncompress */);
 }
+void ServerContext::ReadDicomForHeader(std::string& dicom,
+const std::string& instancePublicId)
+{
+if (!ReadDicomUntilPixelData(dicom, instancePublicId))
+{
+ReadDicom(dicom, instancePublicId);
+}
+}
 bool ServerContext::ReadDicomUntilPixelData(std::string& dicom,
 const std::string& instancePublicId)
 {
 if (!area_.HasReadRange())
 {
 try
 {
 uint64_t pixelDataOffset = boost::lexical_cast<uint64_t>(s);
+StorageAccessor accessor(area_, storageCache_, GetMetricsRegistry());
 std::unique_ptr<IMemoryBuffer> buffer(
-area_.ReadRange(attachment.GetUuid(), attachment.GetContentType(), 0, pixelDataOffset));
+accessor.ReadStartRange(attachment.GetUuid(), attachment.GetContentType(), pixelDataOffset, FileContentType_DicomUntilPixelData));
 buffer->MoveToString(dicom);
 return true;   // Success
 }
 catch (boost::bad_lexical_cast&)
 {
 }
 assert(attachment.GetContentType() == content);
 {
-StorageAccessor accessor(area_, GetMetricsRegistry());
+StorageAccessor accessor(area_, storageCache_, GetMetricsRegistry());
 if (uncompressIfNeeded)
 {
 accessor.Read(result, attachment);
 }
 LOG(INFO) << "Adding attachment " << EnumerationToString(attachmentType) << " to resource " << resourceId;
 // TODO Should we use "gzip" instead?
 CompressionType compression = (compressionEnabled_ ? CompressionType_ZlibWithSize : CompressionType_None);
-StorageAccessor accessor(area_, GetMetricsRegistry());
+StorageAccessor accessor(area_, storageCache_, GetMetricsRegistry());
 FileInfo attachment = accessor.Write(data, size, attachmentType, compression, storeMD5_);
 try
 {
 StoreStatus status = index_.AddAttachment(
 const std::string& ServerContext::GetDeidentifiedContent(const DicomElement &element) const
 {
 static const std::string redactedContent = "*** POTENTIAL PHI ***";
 const DicomTag& tag = element.GetTag();
-if (deidentifyLogs_ && (
+if (deidentifyLogs_ &&
-logsDeidentifierRules_.IsCleared(tag) ||
+!element.GetValue().GetContent().empty() &&
-logsDeidentifierRules_.IsRemoved(tag) ||
+logsDeidentifierRules_.IsAlteredTag(tag))
-logsDeidentifierRules_.IsReplaced(tag)))
 {
 return redactedContent;
 }
 else
 {

Mercurial > hg > orthanc

comparison OrthancServer/Sources/ServerContext.cpp @ 4819:70d2a97ca8cb openssl-3.x