orthanc: Core/DicomNetworking/DicomUserConnection.cpp comparison

comparison Core/DicomNetworking/DicomUserConnection.cpp @ 3786:3801435e34a1 SylvainRouquette/fix-issue169-95b752c

integration Orthanc-1.6.0->SylvainRouquette

author	Sebastien Jodogne <s.jodogne@gmail.com>
date	Thu, 19 Mar 2020 11:48:30 +0100
parents	763533d6dd67 c6658187e4b1
children

comparison

equal deleted inserted replaced

-:763533d6dd67
+:3801435e34a1
 /**
 * Orthanc - A Lightweight, RESTful DICOM Store
 * Copyright (C) 2012-2016 Sebastien Jodogne, Medical Physics
 * Department, University Hospital of Liege, Belgium
-* Copyright (C) 2017-2019 Osimis S.A., Belgium
+* Copyright (C) 2017-2020 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.
 #if !defined(DCMTK_VERSION_NUMBER)
 #  error The macro DCMTK_VERSION_NUMBER must be defined
 #endif
+#include "../Compatibility.h"
 #include "../DicomFormat/DicomArray.h"
 #include "../Logging.h"
 #include "../OrthancException.h"
 #include "../DicomParsing/FromDcmtkBridge.h"
 #include "../DicomParsing/ToDcmtkBridge.h"
 return assoc_ != NULL;
 }
 void CheckIsOpen() const;
-void Store(DcmInputStream& is,
+void Store(std::string& sopClassUidOut  /* out */,
+std::string& sopInstanceUidOut  /* out */,
+DcmInputStream& is,
 DicomUserConnection& connection,
 const std::string& moveOriginatorAET,
 uint16_t moveOriginatorID);
 };
 presentationContextId += 2;
 }
 }
-void DicomUserConnection::SetupPresentationContexts(const std::string& preferredTransferSyntax)
+void DicomUserConnection::SetupPresentationContexts(Mode mode,
+const std::string& preferredTransferSyntax)
 {
 // Flatten an array with the preferred transfer syntax
 const char* asPreferred[1] = { preferredTransferSyntax.c_str() };
 // Setup the fallback transfer syntaxes
 {
 asFallback.push_back(it->c_str());
 }
 CheckStorageSOPClassesInvariant();
-unsigned int presentationContextId = 1;
+switch (mode)
-for (std::list<std::string>::const_iterator it = reservedStorageSOPClasses_.begin();
+{
-it != reservedStorageSOPClasses_.end(); ++it)
+case Mode_Generic:
 {
-RegisterStorageSOPClass(pimpl_->params_, presentationContextId,
+unsigned int presentationContextId = 1;
-*it, asPreferred, asFallback, remoteAet_);
-}
+for (std::list<std::string>::const_iterator it = reservedStorageSOPClasses_.begin();
+it != reservedStorageSOPClasses_.end(); ++it)
-for (std::set<std::string>::const_iterator it = storageSOPClasses_.begin();
+{
-it != storageSOPClasses_.end(); ++it)
+RegisterStorageSOPClass(pimpl_->params_, presentationContextId,
-{
+*it, asPreferred, asFallback, remoteAet_);
-RegisterStorageSOPClass(pimpl_->params_, presentationContextId,
+}
-*it, asPreferred, asFallback, remoteAet_);
-}
+for (std::set<std::string>::const_iterator it = storageSOPClasses_.begin();
+it != storageSOPClasses_.end(); ++it)
-for (std::set<std::string>::const_iterator it = defaultStorageSOPClasses_.begin();
+{
-it != defaultStorageSOPClasses_.end(); ++it)
+RegisterStorageSOPClass(pimpl_->params_, presentationContextId,
-{
+*it, asPreferred, asFallback, remoteAet_);
-RegisterStorageSOPClass(pimpl_->params_, presentationContextId,
+}
-*it, asPreferred, asFallback, remoteAet_);
-}
+for (std::set<std::string>::const_iterator it = defaultStorageSOPClasses_.begin();
-}
+it != defaultStorageSOPClasses_.end(); ++it)
+{
+RegisterStorageSOPClass(pimpl_->params_, presentationContextId,
+*it, asPreferred, asFallback, remoteAet_);
+}
+break;
+}
+case Mode_RequestStorageCommitment:
+case Mode_ReportStorageCommitment:
+{
+const char* as = UID_StorageCommitmentPushModelSOPClass;
+std::vector<const char*> ts;
+ts.push_back(UID_LittleEndianExplicitTransferSyntax);
+ts.push_back(UID_LittleEndianImplicitTransferSyntax);
+T_ASC_SC_ROLE role;
+switch (mode)
+{
+case Mode_RequestStorageCommitment:
+role = ASC_SC_ROLE_DEFAULT;
+break;
+case Mode_ReportStorageCommitment:
+role = ASC_SC_ROLE_SCP;
+break;
+default:
+throw OrthancException(ErrorCode_InternalError);
+}
+Check(ASC_addPresentationContext(pimpl_->params_, 1 /*presentationContextId*/,
+as, &ts[0], ts.size(), role),
+remoteAet_, "initializing");
+break;
+}
+default:
+throw OrthancException(ErrorCode_InternalError);
+}
+}
 static bool IsGenericTransferSyntax(const std::string& syntax)
 {
 return (syntax == UID_LittleEndianExplicitTransferSyntax ||
 syntax == UID_BigEndianExplicitTransferSyntax ||
 syntax == UID_LittleEndianImplicitTransferSyntax);
 }
-void DicomUserConnection::PImpl::Store(DcmInputStream& is,
+void DicomUserConnection::PImpl::Store(std::string& sopClassUidOut,
+std::string& sopInstanceUidOut,
+DcmInputStream& is,
 DicomUserConnection& connection,
 const std::string& moveOriginatorAET,
 uint16_t moveOriginatorID)
 {
 DcmFileFormat dcmff;
 {
 throw OrthancException(ErrorCode_NoSopClassOrInstance,
 "Unable to determine the SOP class/instance for C-STORE with AET " +
 connection.remoteAet_);
 }
+sopClassUidOut.assign(sopClass);
+sopInstanceUidOut.assign(sopInstance);
 // Figure out which of the accepted presentation contexts should be used
 int presID = ASC_findAcceptedPresentationContextID(assoc_, sopClass);
 if (presID == 0)
 {
 request.MoveOriginatorID = moveOriginatorID;  // The type DIC_US is an alias for uint16_t
 request.opts |= O_STORE_MOVEORIGINATORID;
 }
 // Finally conduct transmission of data
-T_DIMSE_C_StoreRSP rsp;
+T_DIMSE_C_StoreRSP response;
 DcmDataset* statusDetail = NULL;
 Check(DIMSE_storeUser(assoc_, presID, &request,
 NULL, dcmff.getDataset(), /*progressCallback*/ NULL, NULL,
-/*opt_blockMode*/ DIMSE_BLOCKING, /*opt_dimse_timeout*/ dimseTimeout_,
+/*opt_blockMode*/ (dimseTimeout_ ? DIMSE_NONBLOCKING : DIMSE_BLOCKING),
-&rsp, &statusDetail, NULL),
+/*opt_dimse_timeout*/ dimseTimeout_,
+&response, &statusDetail, NULL),
 connection.remoteAet_, "C-STORE");
 if (statusDetail != NULL)
 {
 delete statusDetail;
+}
+/**
+* New in Orthanc 1.6.0: Deal with failures during C-STORE.
+* http://dicom.nema.org/medical/dicom/current/output/chtml/part04/sect_B.2.3.html#table_B.2-1
+**/
+if (response.DimseStatus != 0x0000 &&  // Success
+response.DimseStatus != 0xB000 &&  // Warning - Coercion of Data Elements
+response.DimseStatus != 0xB007 &&  // Warning - Data Set does not match SOP Class
+response.DimseStatus != 0xB006)    // Warning - Elements Discarded
+{
+char buf[16];
+sprintf(buf, "%04X", response.DimseStatus);
+throw OrthancException(ErrorCode_NetworkProtocol,
+"C-STORE SCU to AET \"" + connection.remoteAet_ +
+"\" has failed with DIMSE status 0x" + buf);
 }
 }
 namespace
 switch (manufacturer)
 {
 case ModalityManufacturer_GenericNoWildcardInDates:
 case ModalityManufacturer_GenericNoUniversalWildcard:
 {
-std::auto_ptr<DicomMap> fix(fields.Clone());
+std::unique_ptr<DicomMap> fix(fields.Clone());
 std::set<DicomTag> tags;
 fix->GetTags(tags);
 for (std::set<DicomTag>::const_iterator it = tags.begin(); it != tags.end(); ++it)
 OFCondition cond = DIMSE_findUser(association, presID, &request, dataset,
 #if DCMTK_VERSION_NUMBER >= 364
 				      responseCount,
 #endif
 FindCallback, &payload,
-/*opt_blockMode*/ DIMSE_BLOCKING,
+/*opt_blockMode*/ (dimseTimeout ? DIMSE_NONBLOCKING : DIMSE_BLOCKING),
 /*opt_dimse_timeout*/ dimseTimeout,
 &response, &statusDetail);
 if (statusDetail)
 {
 delete statusDetail;
 }
 Check(cond, remoteAet, "C-FIND");
+/**
+* New in Orthanc 1.6.0: Deal with failures during C-FIND.
+* http://dicom.nema.org/medical/dicom/current/output/chtml/part04/sect_C.4.html#table_C.4-1
+**/
+if (response.DimseStatus != 0x0000 &&  // Success
+response.DimseStatus != 0xFF00 &&  // Pending - Matches are continuing
+response.DimseStatus != 0xFF01)    // Pending - Matches are continuing
+{
+char buf[16];
+sprintf(buf, "%04X", response.DimseStatus);
+throw OrthancException(ErrorCode_NetworkProtocol,
+"C-FIND SCU to AET \"" + remoteAet +
+"\" has failed with DIMSE status 0x" + buf);
+}
 }
 void DicomUserConnection::Find(DicomFindAnswers& result,
 ResourceType level,
 const DicomMap& originalFields,
 bool normalize)
 {
 CheckIsOpen();
-std::auto_ptr<ParsedDicomFile> query;
+std::unique_ptr<ParsedDicomFile> query;
 if (normalize)
 {
 DicomMap fields;
 NormalizeFindQuery(fields, level, originalFields);
 DU_putStringDOElement(dataset, DCM_QueryRetrieveLevel, "SERIES");
 sopClass = UID_FINDStudyRootQueryRetrieveInformationModel;
 break;
 case ResourceType_Instance:
-clevel = "INSTANCE";
+clevel = "IMAGE";
-if (manufacturer_ == ModalityManufacturer_ClearCanvas ||
+DU_putStringDOElement(dataset, DCM_QueryRetrieveLevel, "IMAGE");
-manufacturer_ == ModalityManufacturer_Dcm4Chee ||
-manufacturer_ == ModalityManufacturer_GE)
-{
-// This is a particular case for ClearCanvas, thanks to Peter Somlo <peter.somlo@gmail.com>.
-// https://groups.google.com/d/msg/orthanc-users/j-6C3MAVwiw/iolB9hclom8J
-// http://www.clearcanvas.ca/Home/Community/OldForums/tabid/526/aff/11/aft/14670/afv/topic/Default.aspx
-DU_putStringDOElement(dataset, DCM_QueryRetrieveLevel, "IMAGE");
-clevel = "IMAGE";
-}
-else
-{
-DU_putStringDOElement(dataset, DCM_QueryRetrieveLevel, "INSTANCE");
-}
 sopClass = UID_FINDStudyRootQueryRetrieveInformationModel;
 break;
 default:
 throw OrthancException(ErrorCode_ParameterOutOfRange);
 ResourceType level,
 const DicomMap& fields)
 {
 CheckIsOpen();
-std::auto_ptr<ParsedDicomFile> query(ConvertQueryFields(fields, manufacturer_));
+std::unique_ptr<ParsedDicomFile> query(ConvertQueryFields(fields, manufacturer_));
 DcmDataset* dataset = query->GetDcmtkObject().getDataset();
 const char* sopClass = UID_MOVEStudyRootQueryRetrieveInformationModel;
 switch (level)
 {
 case ResourceType_Series:
 DU_putStringDOElement(dataset, DCM_QueryRetrieveLevel, "SERIES");
 break;
 case ResourceType_Instance:
-if (manufacturer_ == ModalityManufacturer_ClearCanvas ||
+DU_putStringDOElement(dataset, DCM_QueryRetrieveLevel, "IMAGE");
-manufacturer_ == ModalityManufacturer_Dcm4Chee ||
-manufacturer_ == ModalityManufacturer_GE)
-{
-// This is a particular case for ClearCanvas, thanks to Peter Somlo <peter.somlo@gmail.com>.
-// https://groups.google.com/d/msg/orthanc-users/j-6C3MAVwiw/iolB9hclom8J
-// http://www.clearcanvas.ca/Home/Community/OldForums/tabid/526/aff/11/aft/14670/afv/topic/Default.aspx
-DU_putStringDOElement(dataset, DCM_QueryRetrieveLevel, "IMAGE");
-}
-else
-{
-DU_putStringDOElement(dataset, DCM_QueryRetrieveLevel, "INSTANCE");
-}
 break;
 default:
 throw OrthancException(ErrorCode_ParameterOutOfRange);
 }
 T_DIMSE_C_MoveRSP response;
 DcmDataset* statusDetail = NULL;
 DcmDataset* responseIdentifiers = NULL;
 OFCondition cond = DIMSE_moveUser(pimpl_->assoc_, presID, &request, dataset,
 NULL, NULL,
-/*opt_blockMode*/ DIMSE_BLOCKING,
+/*opt_blockMode*/ (pimpl_->dimseTimeout_ ? DIMSE_NONBLOCKING : DIMSE_BLOCKING),
 /*opt_dimse_timeout*/ pimpl_->dimseTimeout_,
 pimpl_->net_, NULL, NULL,
 &response, &statusDetail, &responseIdentifiers);
 if (statusDetail)
 {
 delete responseIdentifiers;
 }
 Check(cond, remoteAet_, "C-MOVE");
+/**
+* New in Orthanc 1.6.0: Deal with failures during C-MOVE.
+* http://dicom.nema.org/medical/dicom/current/output/chtml/part04/sect_C.4.2.html#table_C.4-2
+**/
+if (response.DimseStatus != 0x0000 &&  // Success
+response.DimseStatus != 0xFF00)    // Pending - Sub-operations are continuing
+{
+char buf[16];
+sprintf(buf, "%04X", response.DimseStatus);
+throw OrthancException(ErrorCode_NetworkProtocol,
+"C-MOVE SCU to AET \"" + remoteAet_ +
+"\" has failed with DIMSE status 0x" + buf);
+}
 }
 void DicomUserConnection::ResetStorageSOPClasses()
 {
 Close();
 remotePort_ = port;
 }
 }
-void DicomUserConnection::Open()
+void DicomUserConnection::OpenInternal(Mode mode)
 {
 if (IsOpen())
 {
 // Don't reopen the connection
 return;
 // Set various options
 Check(ASC_setTransportLayerType(pimpl_->params_, /*opt_secureConnection*/ false),
 remoteAet_, "connecting");
-SetupPresentationContexts(preferredTransferSyntax_);
+SetupPresentationContexts(mode, preferredTransferSyntax_);
 // Do the association
 Check(ASC_requestAssociation(pimpl_->net_, pimpl_->params_, &pimpl_->assoc_),
 remoteAet_, "connecting");
 bool DicomUserConnection::IsOpen() const
 {
 return pimpl_->IsOpen();
 }
-void DicomUserConnection::Store(const char* buffer,
+void DicomUserConnection::Store(std::string& sopClassUid /* out */,
+std::string& sopInstanceUid /* out */,
+const char* buffer,
 size_t size,
 const std::string& moveOriginatorAET,
 uint16_t moveOriginatorID)
 {
 // Prepare an input stream for the memory buffer
 DcmInputBufferStream is;
 if (size > 0)
 is.setBuffer(buffer, size);
 is.setEos();
-pimpl_->Store(is, *this, moveOriginatorAET, moveOriginatorID);
+pimpl_->Store(sopClassUid, sopInstanceUid, is, *this, moveOriginatorAET, moveOriginatorID);
 }
-void DicomUserConnection::Store(const std::string& buffer,
+void DicomUserConnection::Store(std::string& sopClassUid /* out */,
+std::string& sopInstanceUid /* out */,
+const std::string& buffer,
 const std::string& moveOriginatorAET,
 uint16_t moveOriginatorID)
 {
 if (buffer.size() > 0)
-Store(&buffer[0], buffer.size(), moveOriginatorAET, moveOriginatorID);
+Store(sopClassUid, sopInstanceUid, &buffer[0], buffer.size(),
+moveOriginatorAET, moveOriginatorID);
 else
-Store(NULL, 0, moveOriginatorAET, moveOriginatorID);
+Store(sopClassUid, sopInstanceUid, NULL, 0, moveOriginatorAET, moveOriginatorID);
 }
-void DicomUserConnection::StoreFile(const std::string& path,
+void DicomUserConnection::StoreFile(std::string& sopClassUid /* out */,
+std::string& sopInstanceUid /* out */,
+const std::string& path,
 const std::string& moveOriginatorAET,
 uint16_t moveOriginatorID)
 {
 // Prepare an input stream for the file
 DcmInputFileStream is(path.c_str());
-pimpl_->Store(is, *this, moveOriginatorAET, moveOriginatorID);
+pimpl_->Store(sopClassUid, sopInstanceUid, is, *this, moveOriginatorAET, moveOriginatorID);
 }
 bool DicomUserConnection::Echo()
 {
 CheckIsOpen();
 DIC_US status;
 Check(DIMSE_echoUser(pimpl_->assoc_, pimpl_->assoc_->nextMsgID++,
-/*opt_blockMode*/ DIMSE_BLOCKING,
+/*opt_blockMode*/ (pimpl_->dimseTimeout_ ? DIMSE_NONBLOCKING : DIMSE_BLOCKING),
 /*opt_dimse_timeout*/ pimpl_->dimseTimeout_,
 &status, NULL), remoteAet_, "C-ECHO");
 return status == STATUS_Success;
 }
 }
 else
 {
 dcmConnectionTimeout.set(seconds);
 pimpl_->dimseTimeout_ = seconds;
-pimpl_->acseTimeout_ = 10;  // Timeout used during association negociation
+pimpl_->acseTimeout_ = seconds;  // Timeout used during association negociation and ASC_releaseAssociation()
 }
 }
 void DicomUserConnection::DisableTimeout()
 * Global timeout (seconds) for connecting to remote hosts.
 * Default value is -1 which selects infinite timeout, i.e. blocking connect().
 */
 dcmConnectionTimeout.set(-1);
 pimpl_->dimseTimeout_ = 0;
-pimpl_->acseTimeout_ = 10;  // Timeout used during association negociation
+pimpl_->acseTimeout_ = 10;  // Timeout used during association negociation and ASC_releaseAssociation()
 }
 void DicomUserConnection::CheckStorageSOPClassesInvariant() const
 {
 remoteAet_ == remote.GetApplicationEntityTitle() &&
 remoteHost_ == remote.GetHost() &&
 remotePort_ == remote.GetPortNumber() &&
 manufacturer_ == remote.GetManufacturer());
 }
+static void FillSopSequence(DcmDataset& dataset,
+const DcmTagKey& tag,
+const std::vector<std::string>& sopClassUids,
+const std::vector<std::string>& sopInstanceUids,
+const std::vector<StorageCommitmentFailureReason>& failureReasons,
+bool hasFailureReasons)
+{
+assert(sopClassUids.size() == sopInstanceUids.size() &&
+(hasFailureReasons ?
+failureReasons.size() == sopClassUids.size() :
+failureReasons.empty()));
+if (sopInstanceUids.empty())
+{
+// Add an empty sequence
+if (!dataset.insertEmptyElement(tag).good())
+{
+throw OrthancException(ErrorCode_InternalError);
+}
+}
+else
+{
+for (size_t i = 0; i < sopClassUids.size(); i++)
+{
+std::unique_ptr<DcmItem> item(new DcmItem);
+if (!item->putAndInsertString(DCM_ReferencedSOPClassUID, sopClassUids[i].c_str()).good() ||
+!item->putAndInsertString(DCM_ReferencedSOPInstanceUID, sopInstanceUids[i].c_str()).good() ||
+(hasFailureReasons &&
+!item->putAndInsertUint16(DCM_FailureReason, failureReasons[i]).good()) ||
+!dataset.insertSequenceItem(tag, item.release()).good())
+{
+throw OrthancException(ErrorCode_InternalError);
+}
+}
+}
+}
+void DicomUserConnection::ReportStorageCommitment(
+const std::string& transactionUid,
+const std::vector<std::string>& sopClassUids,
+const std::vector<std::string>& sopInstanceUids,
+const std::vector<StorageCommitmentFailureReason>& failureReasons)
+{
+if (sopClassUids.size() != sopInstanceUids.size() ||
+sopClassUids.size() != failureReasons.size())
+{
+throw OrthancException(ErrorCode_ParameterOutOfRange);
+}
+if (IsOpen())
+{
+Close();
+}
+std::vector<std::string> successSopClassUids, successSopInstanceUids, failedSopClassUids, failedSopInstanceUids;
+std::vector<StorageCommitmentFailureReason> failedReasons;
+successSopClassUids.reserve(sopClassUids.size());
+successSopInstanceUids.reserve(sopClassUids.size());
+failedSopClassUids.reserve(sopClassUids.size());
+failedSopInstanceUids.reserve(sopClassUids.size());
+failedReasons.reserve(sopClassUids.size());
+for (size_t i = 0; i < sopClassUids.size(); i++)
+{
+switch (failureReasons[i])
+{
+case StorageCommitmentFailureReason_Success:
+successSopClassUids.push_back(sopClassUids[i]);
+successSopInstanceUids.push_back(sopInstanceUids[i]);
+break;
+case StorageCommitmentFailureReason_ProcessingFailure:
+case StorageCommitmentFailureReason_NoSuchObjectInstance:
+case StorageCommitmentFailureReason_ResourceLimitation:
+case StorageCommitmentFailureReason_ReferencedSOPClassNotSupported:
+case StorageCommitmentFailureReason_ClassInstanceConflict:
+case StorageCommitmentFailureReason_DuplicateTransactionUID:
+failedSopClassUids.push_back(sopClassUids[i]);
+failedSopInstanceUids.push_back(sopInstanceUids[i]);
+failedReasons.push_back(failureReasons[i]);
+break;
+default:
+{
+char buf[16];
+sprintf(buf, "%04xH", failureReasons[i]);
+throw OrthancException(ErrorCode_ParameterOutOfRange,
+"Unsupported failure reason for storage commitment: " + std::string(buf));
+}
+}
+}
+try
+{
+OpenInternal(Mode_ReportStorageCommitment);
+/**
+* N-EVENT-REPORT
+* http://dicom.nema.org/medical/dicom/2019a/output/chtml/part04/sect_J.3.3.html
+* http://dicom.nema.org/medical/dicom/2019a/output/chtml/part07/chapter_10.html#table_10.1-1
+*
+* Status code:
+* http://dicom.nema.org/medical/dicom/2019a/output/chtml/part07/chapter_10.html#sect_10.1.1.1.8
+**/
+/**
+* Send the "EVENT_REPORT_RQ" request
+**/
+LOG(INFO) << "Reporting modality \"" << remoteAet_
+<< "\" about storage commitment transaction: " << transactionUid
+<< " (" << successSopClassUids.size() << " successes, "
+<< failedSopClassUids.size() << " failures)";
+const DIC_US messageId = pimpl_->assoc_->nextMsgID++;
+{
+T_DIMSE_Message message;
+memset(&message, 0, sizeof(message));
+message.CommandField = DIMSE_N_EVENT_REPORT_RQ;
+T_DIMSE_N_EventReportRQ& content = message.msg.NEventReportRQ;
+content.MessageID = messageId;
+strncpy(content.AffectedSOPClassUID, UID_StorageCommitmentPushModelSOPClass, DIC_UI_LEN);
+strncpy(content.AffectedSOPInstanceUID, UID_StorageCommitmentPushModelSOPInstance, DIC_UI_LEN);
+content.DataSetType = DIMSE_DATASET_PRESENT;
+DcmDataset dataset;
+if (!dataset.putAndInsertString(DCM_TransactionUID, transactionUid.c_str()).good())
+{
+throw OrthancException(ErrorCode_InternalError);
+}
+{
+std::vector<StorageCommitmentFailureReason> empty;
+FillSopSequence(dataset, DCM_ReferencedSOPSequence, successSopClassUids,
+successSopInstanceUids, empty, false);
+}
+// http://dicom.nema.org/medical/dicom/2019a/output/chtml/part04/sect_J.3.3.html
+if (failedSopClassUids.empty())
+{
+content.EventTypeID = 1;  // "Storage Commitment Request Successful"
+}
+else
+{
+content.EventTypeID = 2;  // "Storage Commitment Request Complete - Failures Exist"
+// Failure reason
+// http://dicom.nema.org/medical/dicom/2019a/output/chtml/part03/sect_C.14.html#sect_C.14.1.1
+FillSopSequence(dataset, DCM_FailedSOPSequence, failedSopClassUids,
+failedSopInstanceUids, failedReasons, true);
+}
+int presID = ASC_findAcceptedPresentationContextID(
+pimpl_->assoc_, UID_StorageCommitmentPushModelSOPClass);
+if (presID == 0)
+{
+throw OrthancException(ErrorCode_NetworkProtocol, "Storage commitment - "
+"Unable to send N-EVENT-REPORT request to AET: " + remoteAet_);
+}
+if (!DIMSE_sendMessageUsingMemoryData(
+pimpl_->assoc_, presID, &message, NULL /* status detail */,
+&dataset, NULL /* callback */, NULL /* callback context */,
+NULL /* commandSet */).good())
+{
+throw OrthancException(ErrorCode_NetworkProtocol);
+}
+}
+/**
+* Read the "EVENT_REPORT_RSP" response
+**/
+{
+T_ASC_PresentationContextID presID = 0;
+T_DIMSE_Message message;
+const int timeout = pimpl_->dimseTimeout_;
+if (!DIMSE_receiveCommand(pimpl_->assoc_,
+(timeout ? DIMSE_NONBLOCKING : DIMSE_BLOCKING), timeout,
+&presID, &message, NULL /* no statusDetail */).good() ||
+message.CommandField != DIMSE_N_EVENT_REPORT_RSP)
+{
+throw OrthancException(ErrorCode_NetworkProtocol, "Storage commitment - "
+"Unable to read N-EVENT-REPORT response from AET: " + remoteAet_);
+}
+const T_DIMSE_N_EventReportRSP& content = message.msg.NEventReportRSP;
+if (content.MessageIDBeingRespondedTo != messageId ||
+!(content.opts & O_NEVENTREPORT_AFFECTEDSOPCLASSUID) ||
+!(content.opts & O_NEVENTREPORT_AFFECTEDSOPINSTANCEUID) ||
+//(content.opts & O_NEVENTREPORT_EVENTTYPEID) ||  // Pedantic test - The "content.EventTypeID" is not used by Orthanc
+std::string(content.AffectedSOPClassUID) != UID_StorageCommitmentPushModelSOPClass ||
+std::string(content.AffectedSOPInstanceUID) != UID_StorageCommitmentPushModelSOPInstance ||
+content.DataSetType != DIMSE_DATASET_NULL)
+{
+throw OrthancException(ErrorCode_NetworkProtocol, "Storage commitment - "
+"Badly formatted N-EVENT-REPORT response from AET: " + remoteAet_);
+}
+if (content.DimseStatus != 0 /* success */)
+{
+throw OrthancException(ErrorCode_NetworkProtocol, "Storage commitment - "
+"The request cannot be handled by remote AET: " + remoteAet_);
+}
+}
+Close();
+}
+catch (OrthancException&)
+{
+Close();
+throw;
+}
+}
+void DicomUserConnection::RequestStorageCommitment(
+const std::string& transactionUid,
+const std::vector<std::string>& sopClassUids,
+const std::vector<std::string>& sopInstanceUids)
+{
+if (sopClassUids.size() != sopInstanceUids.size())
+{
+throw OrthancException(ErrorCode_ParameterOutOfRange);
+}
+for (size_t i = 0; i < sopClassUids.size(); i++)
+{
+if (sopClassUids[i].empty() ||
+sopInstanceUids[i].empty())
+{
+throw OrthancException(ErrorCode_ParameterOutOfRange,
+"The SOP class/instance UIDs cannot be empty, found: \"" +
+sopClassUids[i] + "\" / \"" + sopInstanceUids[i] + "\"");
+}
+}
+if (transactionUid.size() < 5 ||
+transactionUid.substr(0, 5) != "2.25.")
+{
+throw OrthancException(ErrorCode_ParameterOutOfRange);
+}
+if (IsOpen())
+{
+Close();
+}
+try
+{
+OpenInternal(Mode_RequestStorageCommitment);
+/**
+* N-ACTION
+* http://dicom.nema.org/medical/dicom/2019a/output/chtml/part04/sect_J.3.2.html
+* http://dicom.nema.org/medical/dicom/2019a/output/chtml/part07/chapter_10.html#table_10.1-4
+*
+* Status code:
+* http://dicom.nema.org/medical/dicom/2019a/output/chtml/part07/chapter_10.html#sect_10.1.1.1.8
+**/
+/**
+* Send the "N_ACTION_RQ" request
+**/
+LOG(INFO) << "Request to modality \"" << remoteAet_
+<< "\" about storage commitment for " << sopClassUids.size()
+<< " instances, with transaction UID: " << transactionUid;
+const DIC_US messageId = pimpl_->assoc_->nextMsgID++;
+{
+T_DIMSE_Message message;
+memset(&message, 0, sizeof(message));
+message.CommandField = DIMSE_N_ACTION_RQ;
+T_DIMSE_N_ActionRQ& content = message.msg.NActionRQ;
+content.MessageID = messageId;
+strncpy(content.RequestedSOPClassUID, UID_StorageCommitmentPushModelSOPClass, DIC_UI_LEN);
+strncpy(content.RequestedSOPInstanceUID, UID_StorageCommitmentPushModelSOPInstance, DIC_UI_LEN);
+content.ActionTypeID = 1;  // "Request Storage Commitment"
+content.DataSetType = DIMSE_DATASET_PRESENT;
+DcmDataset dataset;
+if (!dataset.putAndInsertString(DCM_TransactionUID, transactionUid.c_str()).good())
+{
+throw OrthancException(ErrorCode_InternalError);
+}
+{
+std::vector<StorageCommitmentFailureReason> empty;
+FillSopSequence(dataset, DCM_ReferencedSOPSequence, sopClassUids, sopInstanceUids, empty, false);
+}
+int presID = ASC_findAcceptedPresentationContextID(
+pimpl_->assoc_, UID_StorageCommitmentPushModelSOPClass);
+if (presID == 0)
+{
+throw OrthancException(ErrorCode_NetworkProtocol, "Storage commitment - "
+"Unable to send N-ACTION request to AET: " + remoteAet_);
+}
+if (!DIMSE_sendMessageUsingMemoryData(
+pimpl_->assoc_, presID, &message, NULL /* status detail */,
+&dataset, NULL /* callback */, NULL /* callback context */,
+NULL /* commandSet */).good())
+{
+throw OrthancException(ErrorCode_NetworkProtocol);
+}
+}
+/**
+* Read the "N_ACTION_RSP" response
+**/
+{
+T_ASC_PresentationContextID presID = 0;
+T_DIMSE_Message message;
+const int timeout = pimpl_->dimseTimeout_;
+if (!DIMSE_receiveCommand(pimpl_->assoc_,
+(timeout ? DIMSE_NONBLOCKING : DIMSE_BLOCKING), timeout,
+&presID, &message, NULL /* no statusDetail */).good() ||
+message.CommandField != DIMSE_N_ACTION_RSP)
+{
+throw OrthancException(ErrorCode_NetworkProtocol, "Storage commitment - "
+"Unable to read N-ACTION response from AET: " + remoteAet_);
+}
+const T_DIMSE_N_ActionRSP& content = message.msg.NActionRSP;
+if (content.MessageIDBeingRespondedTo != messageId ||
+!(content.opts & O_NACTION_AFFECTEDSOPCLASSUID) ||
+!(content.opts & O_NACTION_AFFECTEDSOPINSTANCEUID) ||
+//(content.opts & O_NACTION_ACTIONTYPEID) ||  // Pedantic test - The "content.ActionTypeID" is not used by Orthanc
+std::string(content.AffectedSOPClassUID) != UID_StorageCommitmentPushModelSOPClass ||
+std::string(content.AffectedSOPInstanceUID) != UID_StorageCommitmentPushModelSOPInstance ||
+content.DataSetType != DIMSE_DATASET_NULL)
+{
+throw OrthancException(ErrorCode_NetworkProtocol, "Storage commitment - "
+"Badly formatted N-ACTION response from AET: " + remoteAet_);
+}
+if (content.DimseStatus != 0 /* success */)
+{
+throw OrthancException(ErrorCode_NetworkProtocol, "Storage commitment - "
+"The request cannot be handled by remote AET: " + remoteAet_);
+}
+}
+Close();
+}
+catch (OrthancException&)
+{
+Close();
+throw;
+}
+}
 }

Mercurial > hg > orthanc

comparison Core/DicomNetworking/DicomUserConnection.cpp @ 3786:3801435e34a1 SylvainRouquette/fix-issue169-95b752c