Classes
struct	built_envelope
	Result of envelope construction. More...

struct	http_response
	HTTP response captured from a POST call. More...

struct	mtom_part
	One attachment part, mapped 1:1 to an xop:Include in the envelope. More...

struct	packaged_mtom
	Fully assembled MTOM request body. More...

struct	parsed_mtom
	Result of parsing an inbound multipart/related MTOM response. More...

struct	transport_request
	Optional test hook: replaces the real libcurl transport. More...

Typedefs
using	transport_override

Enumerations
enum class	stored_query_kind { find_documents , get_documents }
	Discriminator for the two stored queries this actor supports. More...

Functions
void	set_http_transport_override (transport_override fn)

void	clear_http_transport_override ()

kcenon::common::Result< http_response >	http_post (const http_options &opts, const std::string &content_type, const std::string &body)
	POST `body` to `opts.endpoint` with the given Content-Type.

kcenon::common::Result< packaged_mtom >	package_mtom (const std::string &envelope_xml, const std::vector< mtom_part > &parts)
	Assemble a multipart/related MTOM body.

kcenon::common::Result< parsed_mtom >	parse_mtom_response (const std::string &content_type_header, const std::string &body)
	Parse a multipart/related MTOM response body.

kcenon::common::Result< built_envelope >	build_iti41_envelope (const submission_set &s, const std::vector< std::string > &cid_refs)
	Build a SOAP envelope for ITI-41 from submission metadata and a list of content-id references for MTOM-attached document bytes.

kcenon::common::Result< bool >	sign_envelope (built_envelope &env, std::string_view cert_pem, std::string_view key_pem, std::string_view key_password)
	Sign the body + timestamp of `env` in place.

kcenon::common::Result< bool >	verify_envelope_integrity (std::string_view signed_xml)
	Verify the structural integrity of a previously signed envelope against the certificate embedded in its own BinarySecurityToken.

std::vector< std::uint8_t >	base64_decode_bytes (std::string_view b64)
	Base64-decode `b64` using the same BIO-backed decoder the signer and verifier use internally.

kcenon::common::Result< built_envelope >	build_iti43_envelope (const retrieve_request &req)
	Build a SOAP envelope for ITI-43 from a retrieve_request.

kcenon::common::Result< document_response >	parse_retrieve_response (const std::string &root_xml, const std::vector< mtom_part > &parts, const retrieve_request &req)
	Parse a RetrieveDocumentSetResponse envelope and resolve the attachment that matches `req`.

kcenon::common::Result< built_envelope >	build_iti18_envelope (const registry_query_request &req, stored_query_kind kind)
	Build a SOAP envelope for ITI-18 from a registry_query_request.

kcenon::common::Result< registry_query_result >	parse_query_response (const std::string &root_xml)
	Parse an AdhocQueryResponse envelope into a registry_query_result.

Typedef Documentation

◆ transport_override

using kcenon::pacs::ihe::xds::detail::transport_override

Initial value:

std::function<kcenon::common::Result<http_response>(const transport_request&)>

Definition at line 57 of file http_client.h.

Enumeration Type Documentation

◆ stored_query_kind

enum class kcenon::pacs::ihe::xds::detail::stored_query_kind

strong

Discriminator for the two stored queries this actor supports.

Enumerator
find_documents
get_documents

Definition at line 33 of file query_envelope.h.

                             {
    find_documents,
    get_documents,
};

Function Documentation

◆ base64_decode_bytes()

std::vector< std::uint8_t > kcenon::pacs::ihe::xds::detail::base64_decode_bytes ( std::string_view b64 )

Base64-decode b64 using the same BIO-backed decoder the signer and verifier use internally.

Exported so callers outside wss_signer.cpp (in particular the retrieve response parser, which needs to decode inline Document payloads on non-MTOM responses) do not have to re-implement the OpenSSL BIO dance. Returns an empty vector on decode failure; callers must check.

Definition at line 608 of file wss_signer.cpp.

                                                              {
    const auto raw = base64_decode(b64);
    std::vector<std::uint8_t> out;
    out.reserve(raw.size());
    for (const unsigned char c : raw) {
        out.push_back(static_cast<std::uint8_t>(c));
    }
    return out;
}

References out.

Referenced by parse_retrieve_response().

Here is the caller graph for this function:

◆ build_iti18_envelope()

kcenon::common::Result< built_envelope > kcenon::pacs::ihe::xds::detail::build_iti18_envelope	(	const registry_query_request &	req,
		stored_query_kind	kind )

Build a SOAP envelope for ITI-18 from a registry_query_request.

Emits an AdhocQueryRequest containing one AdhocQuery with the stored query id corresponding to kind. The envelope carries a wsa:Action of "urn:ihe:iti:2007:RegistryStoredQuery" and an empty wsse:Security header containing a Timestamp and BinarySecurityToken that sign_envelope fills in and signs afterwards.

For find_documents: emits $XDSDocumentEntryPatientId and $XDSDocumentEntryStatus slots, plus optional $XDSDocumentEntryCreationTimeFrom / $XDSDocumentEntryCreationTimeTo slots when req.options populates them.

For get_documents: emits $XDSDocumentEntryEntryUUID with the list literal form that ebRIM StoredQuery slots require.

Returns registry_query_missing_patient_id / registry_query_empty_uuid_list on empty required fields; envelope_serialization_failed if pugixml cannot serialize the document.

Definition at line 149 of file query_envelope.cpp.

                                                               {
    if (kind == stored_query_kind::find_documents) {
        if (req.patient_id.empty()) {
            return kcenon::common::make_error<built_envelope>(
                static_cast<int>(
                    error_code::registry_query_missing_patient_id),
                "registry_query_request.patient_id is empty",
                std::string(error_source));
        }
        if (contains_slot_literal_metachar(req.patient_id)) {
            return kcenon::common::make_error<built_envelope>(
                static_cast<int>(
                    error_code::registry_query_invalid_patient_id),
                "patient_id contains a character that is not legal inside "
                "an ebRIM StoredQuery slot literal ('(),\\' or control "
                "character)",
                std::string(error_source));
        }
        for (const auto& s : req.options.status_values) {
            if (contains_slot_literal_metachar(s)) {
                return kcenon::common::make_error<built_envelope>(
                    static_cast<int>(
                        error_code::registry_query_invalid_patient_id),
                    "options.status_values contains an element with a "
                    "character that is not legal inside an ebRIM slot "
                    "literal",
                    std::string(error_source));
            }
        }
        if (contains_slot_literal_metachar(req.options.creation_time_from) ||
            contains_slot_literal_metachar(req.options.creation_time_to)) {
            return kcenon::common::make_error<built_envelope>(
                static_cast<int>(
                    error_code::registry_query_invalid_patient_id),
                "options.creation_time_* contains a character that is not "
                "legal inside an ebRIM slot literal",
                std::string(error_source));
        }
    }
    if (kind == stored_query_kind::get_documents) {
        if (req.document_uuids.empty()) {
            return kcenon::common::make_error<built_envelope>(
                static_cast<int>(
                    error_code::registry_query_empty_uuid_list),
                "registry_query_request.document_uuids is empty",
                std::string(error_source));
        }
        for (const auto& u : req.document_uuids) {
            if (u.empty()) {
                return kcenon::common::make_error<built_envelope>(
                    static_cast<int>(
                        error_code::registry_query_missing_document_uuid),
                    "registry_query_request.document_uuids contains an "
                    "empty element",
                    std::string(error_source));
            }
            if (contains_slot_literal_metachar(u)) {
                return kcenon::common::make_error<built_envelope>(
                    static_cast<int>(
                        error_code::registry_query_missing_document_uuid),
                    "registry_query_request.document_uuids contains an "
                    "element with a character that is not legal inside "
                    "an ebRIM StoredQuery slot literal",
                    std::string(error_source));
            }
        }
    }
 
    pugi::xml_document doc;
    auto decl = doc.append_child(pugi::node_declaration);
    decl.append_attribute("version") = "1.0";
    decl.append_attribute("encoding") = "UTF-8";
 
    auto env = doc.append_child("soap:Envelope");
    env.append_attribute("xmlns:soap") = kSoapEnv;
    env.append_attribute("xmlns:wsa") = kWsa;
    env.append_attribute("xmlns:wsse") = kWsse;
    env.append_attribute("xmlns:wsu") = kWsu;
    env.append_attribute("xmlns:query") = kQuery;
    env.append_attribute("xmlns:rim") = kRim;
 
    auto header = env.append_child("soap:Header");
 
    auto action = header.append_child("wsa:Action");
    action.append_attribute("soap:mustUnderstand") = "true";
    action.text().set("urn:ihe:iti:2007:RegistryStoredQuery");
 
    auto message_id = header.append_child("wsa:MessageID");
    message_id.text().set(("urn:uuid:" + make_xml_id("msg")).c_str());
 
    auto security = header.append_child("wsse:Security");
    security.append_attribute("soap:mustUnderstand") = "true";
 
    built_envelope out{};
    out.timestamp_id = make_xml_id("ts");
    out.binary_security_token_id = make_xml_id("bst");
    out.body_id = make_xml_id("body");
 
    auto timestamp = security.append_child("wsu:Timestamp");
    timestamp.append_attribute("wsu:Id") = out.timestamp_id.c_str();
    auto created = timestamp.append_child("wsu:Created");
    const std::string now = utc_iso8601_now();
    created.text().set(now.c_str());
 
    auto bst = security.append_child("wsse:BinarySecurityToken");
    bst.append_attribute("wsu:Id") = out.binary_security_token_id.c_str();
    bst.append_attribute("EncodingType") =
        "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-"
        "security-1.0#Base64Binary";
    bst.append_attribute("ValueType") =
        "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-x509-token-"
        "profile-1.0#X509v3";
 
    auto body = env.append_child("soap:Body");
    body.append_attribute("wsu:Id") = out.body_id.c_str();
 
    auto adhoc_request = body.append_child("query:AdhocQueryRequest");
    // ReturnType=LeafClass is the only form the XDS.b profile of ebRS
    // accepts for FindDocuments/GetDocuments. ObjectRef returns IDs only
    // and is unusable for the registry_query_result we assemble later.
    auto response_option =
        adhoc_request.append_child("query:ResponseOption");
    response_option.append_attribute("returnComposedObjects") = "true";
    response_option.append_attribute("returnType") = "LeafClass";
 
    auto adhoc_query = adhoc_request.append_child("rim:AdhocQuery");
    adhoc_query.append_attribute("id") =
        (kind == stored_query_kind::find_documents) ? kFindDocumentsQueryId
                                                    : kGetDocumentsQueryId;
 
    if (kind == stored_query_kind::find_documents) {
        append_slot_single(adhoc_query, "$XDSDocumentEntryPatientId",
                           req.patient_id);
        if (req.options.status_values.empty()) {
            append_slot_single(adhoc_query, "$XDSDocumentEntryStatus",
                               kDefaultApprovedStatus);
        } else {
            append_slot_list(adhoc_query, "$XDSDocumentEntryStatus",
                             req.options.status_values);
        }
        if (!req.options.creation_time_from.empty()) {
            append_slot_single(adhoc_query,
                               "$XDSDocumentEntryCreationTimeFrom",
                               req.options.creation_time_from);
        }
        if (!req.options.creation_time_to.empty()) {
            append_slot_single(adhoc_query,
                               "$XDSDocumentEntryCreationTimeTo",
                               req.options.creation_time_to);
        }
    } else {
        append_slot_list(adhoc_query, "$XDSDocumentEntryEntryUUID",
                         req.document_uuids);
    }
 
    xml_string_writer writer;
    doc.save(writer, "", pugi::format_raw | pugi::format_no_declaration,
             pugi::encoding_utf8);
    if (writer.out.empty()) {
        return kcenon::common::make_error<built_envelope>(
            static_cast<int>(error_code::envelope_serialization_failed),
            "pugixml produced an empty envelope",
            std::string(error_source));
    }
 
    out.xml = R"(<?xml version="1.0" encoding="UTF-8"?>)";
    out.xml += writer.out;
    return out;
}

Referenced by kcenon::pacs::ihe::xds::registry_query::impl::execute().

Here is the caller graph for this function:

◆ build_iti41_envelope()

kcenon::common::Result< built_envelope > kcenon::pacs::ihe::xds::detail::build_iti41_envelope	(	const submission_set &	s,
		const std::vector< std::string > &	cid_refs )

Build a SOAP envelope for ITI-41 from submission metadata and a list of content-id references for MTOM-attached document bytes.

The cid_refs vector must be the same length as s.documents. Each cid is placed inside the matching ExtrinsicObject as an xop:Include.

Returns envelope_build_failed on any input inconsistency; envelope_serialization_failed if pugixml cannot serialize the document.

Definition at line 201 of file soap_envelope.cpp.

                                                                   {
    if (cid_refs.size() != s.documents.size()) {
        return kcenon::common::make_error<built_envelope>(
            static_cast<int>(error_code::envelope_build_failed),
            "content-id list size does not match document count",
            std::string(error_source));
    }
 
    pugi::xml_document doc;
    auto decl = doc.append_child(pugi::node_declaration);
    decl.append_attribute("version") = "1.0";
    decl.append_attribute("encoding") = "UTF-8";
 
    auto env = doc.append_child("soap:Envelope");
    env.append_attribute("xmlns:soap") = kSoapEnv;
    env.append_attribute("xmlns:wsa") = kWsa;
    env.append_attribute("xmlns:wsse") = kWsse;
    env.append_attribute("xmlns:wsu") = kWsu;
    env.append_attribute("xmlns:lcm") = kLcm;
    env.append_attribute("xmlns:rim") = kRim;
    env.append_attribute("xmlns:xop") = kXop;
 
    auto header = env.append_child("soap:Header");
 
    auto action = header.append_child("wsa:Action");
    action.append_attribute("soap:mustUnderstand") = "true";
    action.text().set("urn:ihe:iti:2007:RegisterDocumentSet-b");
 
    auto message_id = header.append_child("wsa:MessageID");
    message_id.text().set(("urn:uuid:" + make_xml_id("msg")).c_str());
 
    auto security = header.append_child("wsse:Security");
    security.append_attribute("soap:mustUnderstand") = "true";
 
    built_envelope out{};
    out.timestamp_id = make_xml_id("ts");
    out.binary_security_token_id = make_xml_id("bst");
    out.body_id = make_xml_id("body");
 
    auto timestamp = security.append_child("wsu:Timestamp");
    timestamp.append_attribute("wsu:Id") = out.timestamp_id.c_str();
    auto created = timestamp.append_child("wsu:Created");
    const std::string now = utc_iso8601_now();
    created.text().set(now.c_str());
 
    auto bst = security.append_child("wsse:BinarySecurityToken");
    bst.append_attribute("wsu:Id") = out.binary_security_token_id.c_str();
    bst.append_attribute("EncodingType") =
        "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-"
        "security-1.0#Base64Binary";
    bst.append_attribute("ValueType") =
        "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-x509-token-"
        "profile-1.0#X509v3";
 
    auto body = env.append_child("soap:Body");
    body.append_attribute("wsu:Id") = out.body_id.c_str();
 
    auto req = body.append_child("lcm:SubmitObjectsRequest");
 
    auto leaf_list = req.append_child("rim:RegistryObjectList");
 
    if (s.patient_id.empty()) {
        return kcenon::common::make_error<built_envelope>(
            static_cast<int>(error_code::metadata_missing_patient_id),
            "submission_set.patient_id is empty",
            std::string(error_source));
    }
    if (s.source_id.empty()) {
        return kcenon::common::make_error<built_envelope>(
            static_cast<int>(error_code::metadata_missing_source_id),
            "submission_set.source_id is empty",
            std::string(error_source));
    }
    if (s.submission_set_unique_id.empty()) {
        return kcenon::common::make_error<built_envelope>(
            static_cast<int>(error_code::metadata_missing_submission_set_uid),
            "submission_set.submission_set_unique_id is empty",
            std::string(error_source));
    }
    if (s.documents.empty()) {
        return kcenon::common::make_error<built_envelope>(
            static_cast<int>(error_code::metadata_no_documents),
            "submission_set contains no documents",
            std::string(error_source));
    }
 
    for (std::size_t i = 0; i < s.documents.size(); ++i) {
        const auto& d = s.documents[i];
        if (d.unique_id.empty()) {
            return kcenon::common::make_error<built_envelope>(
                static_cast<int>(
                    error_code::metadata_document_missing_unique_id),
                "document[" + std::to_string(i) + "].unique_id is empty",
                std::string(error_source));
        }
        if (d.mime_type.empty()) {
            return kcenon::common::make_error<built_envelope>(
                static_cast<int>(
                    error_code::metadata_document_missing_mime_type),
                "document[" + std::to_string(i) + "].mime_type is empty",
                std::string(error_source));
        }
        if (d.content.empty()) {
            return kcenon::common::make_error<built_envelope>(
                static_cast<int>(error_code::metadata_document_empty),
                "document[" + std::to_string(i) + "].content is empty",
                std::string(error_source));
        }
        add_document_entry(leaf_list, d, cid_refs[i]);
    }
 
    add_registry_package(leaf_list, s);
 
    xml_string_writer writer;
    doc.save(writer, "", pugi::format_raw | pugi::format_no_declaration,
             pugi::encoding_utf8);
    if (writer.out.empty()) {
        return kcenon::common::make_error<built_envelope>(
            static_cast<int>(error_code::envelope_serialization_failed),
            "pugixml produced an empty envelope",
            std::string(error_source));
    }
 
    out.xml = R"(<?xml version="1.0" encoding="UTF-8"?>)";
    out.xml += writer.out;
    return out;
}

Referenced by kcenon::pacs::ihe::xds::document_source::impl::submit().

Here is the caller graph for this function:

◆ build_iti43_envelope()

kcenon::common::Result< built_envelope > kcenon::pacs::ihe::xds::detail::build_iti43_envelope ( const retrieve_request & req )

Build a SOAP envelope for ITI-43 from a retrieve_request.

Emits one xdsb:DocumentRequest element per call. The envelope carries a wsa:Action of "urn:ihe:iti:2007:RetrieveDocumentSet" and an empty wsse:Security header containing a Timestamp and BinarySecurityToken that sign_envelope fills in and signs afterwards.

Returns consumer_retrieve_missing_document_id / consumer_retrieve_missing_repository_id on empty fields; envelope_serialization_failed if pugixml cannot serialize the document.

Definition at line 68 of file retrieve_envelope.cpp.

                                 {
    if (req.document_unique_id.empty()) {
        return kcenon::common::make_error<built_envelope>(
            static_cast<int>(
                error_code::consumer_retrieve_missing_document_id),
            "retrieve_request.document_unique_id is empty",
            std::string(error_source));
    }
    if (req.repository_unique_id.empty()) {
        return kcenon::common::make_error<built_envelope>(
            static_cast<int>(
                error_code::consumer_retrieve_missing_repository_id),
            "retrieve_request.repository_unique_id is empty",
            std::string(error_source));
    }
 
    pugi::xml_document doc;
    auto decl = doc.append_child(pugi::node_declaration);
    decl.append_attribute("version") = "1.0";
    decl.append_attribute("encoding") = "UTF-8";
 
    auto env = doc.append_child("soap:Envelope");
    env.append_attribute("xmlns:soap") = kSoapEnv;
    env.append_attribute("xmlns:wsa") = kWsa;
    env.append_attribute("xmlns:wsse") = kWsse;
    env.append_attribute("xmlns:wsu") = kWsu;
    env.append_attribute("xmlns:xdsb") = kXdsb;
 
    auto header = env.append_child("soap:Header");
 
    auto action = header.append_child("wsa:Action");
    action.append_attribute("soap:mustUnderstand") = "true";
    action.text().set("urn:ihe:iti:2007:RetrieveDocumentSet");
 
    auto message_id = header.append_child("wsa:MessageID");
    message_id.text().set(("urn:uuid:" + make_xml_id("msg")).c_str());
 
    auto security = header.append_child("wsse:Security");
    security.append_attribute("soap:mustUnderstand") = "true";
 
    built_envelope out{};
    out.timestamp_id = make_xml_id("ts");
    out.binary_security_token_id = make_xml_id("bst");
    out.body_id = make_xml_id("body");
 
    auto timestamp = security.append_child("wsu:Timestamp");
    timestamp.append_attribute("wsu:Id") = out.timestamp_id.c_str();
    auto created = timestamp.append_child("wsu:Created");
    const std::string now = utc_iso8601_now();
    created.text().set(now.c_str());
 
    auto bst = security.append_child("wsse:BinarySecurityToken");
    bst.append_attribute("wsu:Id") = out.binary_security_token_id.c_str();
    bst.append_attribute("EncodingType") =
        "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-soap-message-"
        "security-1.0#Base64Binary";
    bst.append_attribute("ValueType") =
        "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-x509-token-"
        "profile-1.0#X509v3";
 
    auto body = env.append_child("soap:Body");
    body.append_attribute("wsu:Id") = out.body_id.c_str();
 
    auto rq = body.append_child("xdsb:RetrieveDocumentSetRequest");
    auto doc_req = rq.append_child("xdsb:DocumentRequest");
 
    // TODO(#1129-follow-up): emit xdsb:HomeCommunityId here when XCA
    // Cross-Community Access support lands. ITI-43 intra-community
    // retrieve (the scope of this PR) omits the element.
    doc_req.append_child("xdsb:RepositoryUniqueId")
        .text()
        .set(req.repository_unique_id.c_str());
    doc_req.append_child("xdsb:DocumentUniqueId")
        .text()
        .set(req.document_unique_id.c_str());
 
    xml_string_writer writer;
    doc.save(writer, "", pugi::format_raw | pugi::format_no_declaration,
             pugi::encoding_utf8);
    if (writer.out.empty()) {
        return kcenon::common::make_error<built_envelope>(
            static_cast<int>(error_code::envelope_serialization_failed),
            "pugixml produced an empty envelope",
            std::string(error_source));
    }
 
    out.xml = R"(<?xml version="1.0" encoding="UTF-8"?>)";
    out.xml += writer.out;
    return out;
}

References kcenon::pacs::ihe::xds::consumer_retrieve_missing_document_id, kcenon::pacs::ihe::xds::consumer_retrieve_missing_repository_id, kcenon::pacs::ihe::xds::retrieve_request::document_unique_id, kcenon::pacs::ihe::xds::envelope_serialization_failed, kcenon::pacs::ihe::xds::error_source, out, and kcenon::pacs::ihe::xds::retrieve_request::repository_unique_id.

Referenced by kcenon::pacs::ihe::xds::document_consumer::impl::retrieve().

Here is the caller graph for this function:

◆ clear_http_transport_override()

void kcenon::pacs::ihe::xds::detail::clear_http_transport_override ( )

Definition at line 111 of file http_client.cpp.

                                     {
    std::lock_guard<std::mutex> lock(override_mutex());
    override_fn() = {};
}

◆ http_post()

kcenon::common::Result< http_response > kcenon::pacs::ihe::xds::detail::http_post	(	const http_options &	opts,
		const std::string &	content_type,
		const std::string &	body )

POST body to opts.endpoint with the given Content-Type.

Adds a SOAPAction header, a User-Agent, and forwards the TLS settings from opts. Returns transport_curl_failed / transport_tls_error / transport_http_error with context in the message.

Definition at line 116 of file http_client.cpp.

                                                                       {
    if (opts.endpoint.empty()) {
        return kcenon::common::make_error<http_response>(
            static_cast<int>(error_code::transport_not_configured),
            "http_options.endpoint is empty", std::string(error_source));
    }
 
    {
        transport_override fn_copy;
        {
            std::lock_guard<std::mutex> lock(override_mutex());
            fn_copy = override_fn();
        }
        if (fn_copy) {
            transport_request req;
            req.url = opts.endpoint;
            req.content_type = content_type;
            req.soap_action = opts.soap_action;
            req.body = body;
            req.verify_peer = opts.verify_peer;
            return fn_copy(req);
        }
    }
 
    // libcurl 7.84+ auto-inits on first curl_easy_init, but that implicit
    // path is not thread-safe. Call curl_global_init once per process
    // under a std::once_flag so concurrent first-use from different
    // threads does not race. curl_global_cleanup is deliberately NOT
    // paired here - libcurl documents that a single init for process
    // lifetime is the supported pattern.
    static std::once_flag s_curl_once;
    std::call_once(s_curl_once, [] {
        (void)curl_global_init(CURL_GLOBAL_DEFAULT);
    });
 
    curl_ptr curl(curl_easy_init());
    if (!curl) {
        return kcenon::common::make_error<http_response>(
            static_cast<int>(error_code::transport_init_failed),
            "curl_easy_init failed", std::string(error_source));
    }
 
    slist_ptr headers;
    {
        curl_slist* raw = nullptr;
        const std::string ct_header = "Content-Type: " + content_type;
        raw = curl_slist_append(raw, ct_header.c_str());
        const std::string action_header =
            "SOAPAction: \"" + opts.soap_action + "\"";
        raw = curl_slist_append(raw, action_header.c_str());
        raw = curl_slist_append(raw, "Accept: multipart/related, application/xop+xml, application/soap+xml");
        raw = curl_slist_append(raw, "Expect:");
        headers.reset(raw);
    }
 
    response_sink response;
 
    curl_easy_setopt(curl.get(), CURLOPT_URL, opts.endpoint.c_str());
    curl_easy_setopt(curl.get(), CURLOPT_POST, 1L);
    curl_easy_setopt(curl.get(), CURLOPT_HTTPHEADER, headers.get());
    curl_easy_setopt(curl.get(), CURLOPT_USERAGENT, opts.user_agent.c_str());
    curl_easy_setopt(curl.get(), CURLOPT_POSTFIELDS, body.data());
    curl_easy_setopt(curl.get(), CURLOPT_POSTFIELDSIZE_LARGE,
                     static_cast<curl_off_t>(body.size()));
    curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, write_callback);
    curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &response);
    curl_easy_setopt(curl.get(), CURLOPT_HEADERFUNCTION, header_callback);
    curl_easy_setopt(curl.get(), CURLOPT_HEADERDATA, &response);
    curl_easy_setopt(curl.get(), CURLOPT_FOLLOWLOCATION, 0L);
    curl_easy_setopt(curl.get(), CURLOPT_NOSIGNAL, 1L);
 
    curl_easy_setopt(curl.get(), CURLOPT_CONNECTTIMEOUT_MS,
                     static_cast<long>(opts.connect_timeout.count()));
    curl_easy_setopt(curl.get(), CURLOPT_TIMEOUT_MS,
                     static_cast<long>(opts.request_timeout.count()));
 
    curl_easy_setopt(curl.get(), CURLOPT_SSL_VERIFYPEER,
                     opts.verify_peer ? 1L : 0L);
    curl_easy_setopt(curl.get(), CURLOPT_SSL_VERIFYHOST,
                     opts.verify_host ? 2L : 0L);
    if (!opts.ca_bundle_path.empty()) {
        curl_easy_setopt(curl.get(), CURLOPT_CAINFO,
                         opts.ca_bundle_path.c_str());
    }
    if (!opts.client_certificate_path.empty()) {
        curl_easy_setopt(curl.get(), CURLOPT_SSLCERT,
                         opts.client_certificate_path.c_str());
    }
    if (!opts.client_private_key_path.empty()) {
        curl_easy_setopt(curl.get(), CURLOPT_SSLKEY,
                         opts.client_private_key_path.c_str());
    }
 
    const CURLcode rc = curl_easy_perform(curl.get());
    if (rc != CURLE_OK) {
        // write_callback returned 0 once the response exceeded
        // kMaxResponseBytes, which libcurl surfaces as CURLE_WRITE_ERROR.
        // Promote that specific case to a dedicated error code so callers
        // can distinguish DoS protection from other transport failures.
        if (rc == CURLE_WRITE_ERROR && response.oversize) {
            return kcenon::common::make_error<http_response>(
                static_cast<int>(error_code::transport_response_too_large),
                "registry response exceeds " +
                    std::to_string(kMaxResponseBytes) +
                    " byte cap; transfer aborted",
                std::string(error_source));
        }
        const bool tls =
            rc == CURLE_PEER_FAILED_VERIFICATION || rc == CURLE_SSL_CONNECT_ERROR ||
            rc == CURLE_SSL_CERTPROBLEM || rc == CURLE_SSL_CIPHER ||
            rc == CURLE_SSL_ISSUER_ERROR || rc == CURLE_SSL_CACERT_BADFILE;
        const auto code = tls ? error_code::transport_tls_error
                               : (rc == CURLE_OPERATION_TIMEDOUT
                                      ? error_code::transport_timeout
                                      : error_code::transport_curl_failed);
        return kcenon::common::make_error<http_response>(
            static_cast<int>(code),
            std::string("libcurl error ") + std::to_string(static_cast<int>(rc)) +
                ": " + curl_easy_strerror(rc),
            std::string(error_source));
    }
 
    http_response out;
    curl_easy_getinfo(curl.get(), CURLINFO_RESPONSE_CODE, &out.status_code);
    out.content_type = std::move(response.content_type);
    out.body = std::move(response.buffer);
 
    if (out.status_code < 200 || out.status_code >= 300) {
        return kcenon::common::make_error<http_response>(
            static_cast<int>(error_code::transport_http_error),
            std::string("unexpected HTTP status ") +
                std::to_string(out.status_code),
            std::string(error_source));
    }
 
    return out;
}

Referenced by kcenon::pacs::ihe::xds::registry_query::impl::execute(), kcenon::pacs::ihe::xds::document_consumer::impl::retrieve(), and kcenon::pacs::ihe::xds::document_source::impl::submit().

Here is the caller graph for this function:

◆ package_mtom()

kcenon::common::Result< packaged_mtom > kcenon::pacs::ihe::xds::detail::package_mtom	(	const std::string &	envelope_xml,
		const std::vector< mtom_part > &	parts )

Assemble a multipart/related MTOM body.

envelope_xml is the signed SOAP 1.2 envelope; parts are the document binaries referenced from the envelope by xop:Include.

The boundary is generated from a thread-local PRNG and guaranteed not to appear in any of the inputs via a fallback re-seed if a collision is detected.

Definition at line 59 of file mtom_packager.cpp.

                                                                      {
    if (envelope_xml.empty()) {
        return kcenon::common::make_error<packaged_mtom>(
            static_cast<int>(error_code::mtom_empty_payload),
            "envelope XML is empty", std::string(error_source));
    }
 
    std::string boundary;
    bool ok = false;
    for (int attempt = 0; attempt < 8; ++attempt) {
        boundary = make_boundary();
        if (contains(envelope_xml, boundary)) continue;
        bool collides = false;
        for (const auto& p : parts) {
            if (bytes_contain(p.content, boundary)) {
                collides = true;
                break;
            }
        }
        if (!collides) {
            ok = true;
            break;
        }
    }
    if (!ok) {
        return kcenon::common::make_error<packaged_mtom>(
            static_cast<int>(error_code::mtom_boundary_generation_failed),
            "failed to generate a collision-free MIME boundary",
            std::string(error_source));
    }
 
    packaged_mtom out;
    out.content_type =
        std::string("multipart/related; boundary=\"") + boundary +
        std::string("\"; type=\"application/xop+xml\"; start=\"<") +
        kSoapStartCid +
        std::string(">\"; start-info=\"application/soap+xml; action=\\\"urn:ihe:iti:2007:RegisterDocumentSet-b\\\"\"");
 
    std::string body;
    body.reserve(envelope_xml.size() + 4096);
 
    body += "--";
    body += boundary;
    body += kCrLf;
    body += "Content-Type: application/xop+xml; charset=UTF-8; type=\"application/soap+xml\"";
    body += kCrLf;
    body += "Content-Transfer-Encoding: 8bit";
    body += kCrLf;
    body += "Content-ID: <";
    body += kSoapStartCid;
    body += ">";
    body += kCrLf;
    body += kCrLf;
    body += envelope_xml;
    body += kCrLf;
 
    for (const auto& p : parts) {
        if (p.content_id.empty()) {
            return kcenon::common::make_error<packaged_mtom>(
                static_cast<int>(error_code::mtom_empty_payload),
                "part has empty content-id", std::string(error_source));
        }
        if (p.content.empty()) {
            return kcenon::common::make_error<packaged_mtom>(
                static_cast<int>(error_code::mtom_empty_payload),
                "part '" + p.content_id + "' has empty content",
                std::string(error_source));
        }
 
        body += "--";
        body += boundary;
        body += kCrLf;
        body += "Content-Type: ";
        body += (p.mime_type.empty() ? "application/octet-stream" : p.mime_type);
        body += kCrLf;
        body += "Content-Transfer-Encoding: binary";
        body += kCrLf;
        body += "Content-ID: <";
        body += p.content_id;
        body += ">";
        body += kCrLf;
        body += kCrLf;
        body.append(reinterpret_cast<const char*>(p.content.data()),
                    p.content.size());
        body += kCrLf;
    }
 
    body += "--";
    body += boundary;
    body += "--";
    body += kCrLf;
 
    out.body = std::move(body);
    return out;
}

References kcenon::pacs::ihe::xds::error_source, kcenon::pacs::ihe::xds::mtom_boundary_generation_failed, kcenon::pacs::ihe::xds::mtom_empty_payload, and out.

Referenced by kcenon::pacs::ihe::xds::document_source::impl::submit().

Here is the caller graph for this function:

◆ parse_mtom_response()

kcenon::common::Result< parsed_mtom > kcenon::pacs::ihe::xds::detail::parse_mtom_response	(	const std::string &	content_type_header,
		const std::string &	body )

Parse a multipart/related MTOM response body.

Prefers the boundary parameter from content_type_header when it is non-empty and carries a boundary="..." (or bare boundary=...) attribute. Falls back to sniffing the first --<boundary> marker in body when the header is absent or malformed. The 8 MiB response cap in http_client.cpp bounds the walk in either path.

The body is split into parts, each part is stripped of its headers, and the first encountered part is treated as the root envelope.

Non-MTOM responses (the repository returned plain SOAP with no multipart framing) are detected and returned with root_xml set to the whole body and parts empty, so the caller can still invoke the signer and response parser uniformly. This matches the fallback behavior of Apache CXF repositories that omit MTOM when no attachments are present.

Definition at line 257 of file mtom_packager.cpp.

                                                                 {
    parsed_mtom out;
 
    if (body.empty()) {
        return kcenon::common::make_error<parsed_mtom>(
            static_cast<int>(error_code::consumer_response_mtom_malformed),
            "response body is empty", std::string(error_source));
    }
 
    // Plain SOAP (no multipart framing) fallback: if the body starts with
    // "<?xml" or "<soap" it is the envelope itself and we surface it as a
    // root-only parsed_mtom. This keeps the caller's pipeline uniform.
    {
        std::size_t leading = 0;
        while (leading < body.size() &&
               (body[leading] == ' ' || body[leading] == '\t' ||
                body[leading] == '\r' || body[leading] == '\n')) {
            ++leading;
        }
        if (body.compare(leading, 5, "<?xml") == 0 ||
            body.compare(leading, 5, "<soap") == 0 ||
            body.compare(leading, 14, "<soap:Envelope") == 0) {
            out.root_xml = body;
            return out;
        }
    }
 
    // Prefer the Content-Type header's boundary parameter - this is the
    // authoritative source per RFC 2387. The body-sniffing fallback in
    // detect_boundary only runs when the header was absent or missing a
    // boundary parameter, which happens in closed test harnesses that
    // bypass libcurl via the transport override.
    std::string boundary = extract_boundary_from_header(content_type_header);
    if (boundary.empty()) {
        boundary = detect_boundary(body);
    }
    if (boundary.empty()) {
        return kcenon::common::make_error<parsed_mtom>(
            static_cast<int>(error_code::consumer_response_mtom_malformed),
            "no MIME boundary detected in response body or Content-Type",
            std::string(error_source));
    }
 
    const std::string delim = "--" + boundary;
 
    // Split body on every occurrence of "--<boundary>". The last segment
    // before "--<boundary>--" is the final part; anything after the closer
    // is the epilogue (ignored).
    std::vector<std::string> segments;
    std::size_t cursor = 0;
    while (cursor < body.size()) {
        const auto next = body.find(delim, cursor);
        if (next == std::string::npos) break;
        if (next > cursor) {
            segments.push_back(body.substr(cursor, next - cursor));
        }
        cursor = next + delim.size();
        // Close marker: "--<boundary>--"
        if (cursor + 2 <= body.size() && body[cursor] == '-' &&
            body[cursor + 1] == '-') {
            cursor += 2;
            break;
        }
    }
    if (segments.empty()) {
        // The preamble before the first boundary is allowed by RFC 2046,
        // so an "empty" segments list only means the body had no proper
        // first-part marker.
        return kcenon::common::make_error<parsed_mtom>(
            static_cast<int>(error_code::consumer_response_mtom_malformed),
            "multipart body yielded zero parts",
            std::string(error_source));
    }
 
    // Discard any preamble-only first segment that isn't actually a part
    // (i.e. the bytes between the MIME body start and the first "--B").
    // Our parser starts cursor at 0, so the first segment is whatever
    // preceded the first boundary - usually empty after CRLFs. A real part
    // always has a header-body split we can detect.
    bool first_part_consumed = false;
    for (auto& seg : segments) {
        // A valid MIME part starts with CRLF, then headers, then CRLF CRLF,
        // then content, then CRLF. Strip the leading CRLF if present.
        std::size_t start = 0;
        while (start < seg.size() &&
               (seg[start] == '\r' || seg[start] == '\n')) {
            ++start;
        }
        if (start >= seg.size()) continue;
 
        const auto header_end = seg.find("\r\n\r\n", start);
        const std::size_t content_start =
            (header_end == std::string::npos) ? seg.size() : header_end + 4;
        if (content_start > seg.size()) continue;
 
        // Parse headers.
        const std::string_view header_block(
            seg.data() + start,
            (header_end == std::string::npos ? seg.size() - start
                                             : header_end - start));
        std::string mime_type;
        std::string content_id;
        std::size_t pos = 0;
        while (pos < header_block.size()) {
            const auto eol = header_block.find("\r\n", pos);
            const std::size_t line_end =
                (eol == std::string::npos) ? header_block.size() : eol;
            const std::string_view line = header_block.substr(pos, line_end - pos);
            if (iequals_prefix(line, "Content-Type:")) {
                mime_type = trim(line.substr(std::strlen("Content-Type:")));
                const auto semi = mime_type.find(';');
                if (semi != std::string::npos) {
                    mime_type = trim(std::string_view(mime_type).substr(0, semi));
                }
            } else if (iequals_prefix(line, "Content-ID:")) {
                content_id = strip_cid_brackets(
                    line.substr(std::strlen("Content-ID:")));
            }
            if (eol == std::string::npos) break;
            pos = eol + 2;
        }
 
        // Extract content, trimming the trailing CRLF that precedes the
        // next boundary delimiter.
        std::size_t content_end = seg.size();
        while (content_end > content_start &&
               (seg[content_end - 1] == '\r' ||
                seg[content_end - 1] == '\n')) {
            --content_end;
        }
        if (content_end < content_start) content_end = content_start;
        const std::size_t content_len = content_end - content_start;
 
        if (!first_part_consumed) {
            out.root_xml.assign(seg, content_start, content_len);
            first_part_consumed = true;
            continue;
        }
        mtom_part mp;
        mp.content_id = std::move(content_id);
        mp.mime_type = std::move(mime_type);
        mp.content.assign(
            reinterpret_cast<const std::uint8_t*>(seg.data() + content_start),
            reinterpret_cast<const std::uint8_t*>(seg.data() + content_end));
        out.parts.push_back(std::move(mp));
    }
 
    if (out.root_xml.empty()) {
        return kcenon::common::make_error<parsed_mtom>(
            static_cast<int>(error_code::consumer_response_missing_mtom_root),
            "multipart body had no root part with XML payload",
            std::string(error_source));
    }
 
    return out;
}

References kcenon::pacs::ihe::xds::consumer_response_missing_mtom_root, kcenon::pacs::ihe::xds::consumer_response_mtom_malformed, kcenon::pacs::ihe::xds::detail::mtom_part::content, kcenon::pacs::ihe::xds::detail::mtom_part::content_id, kcenon::pacs::ihe::xds::error_source, kcenon::pacs::ihe::xds::detail::mtom_part::mime_type, and out.

Referenced by kcenon::pacs::ihe::xds::document_consumer::impl::retrieve().

Here is the caller graph for this function:

◆ parse_query_response()

kcenon::common::Result< registry_query_result > kcenon::pacs::ihe::xds::detail::parse_query_response ( const std::string & root_xml )

Parse an AdhocQueryResponse envelope into a registry_query_result.

root_xml is the response envelope (already signature-verified).

Returns registry_failure_response when the registry reports a Failure status. Returns registry_partial_success on PartialSuccess - callers wanting to tolerate that state must inspect the status string of the returned error context.

An empty RegistryObjectList on Success is a successful empty result, not an error: the function returns a registry_query_result with an empty entries vector.

Definition at line 146 of file query_response_parser.cpp.

                               {
    if (root_xml.size() > kMaxRootXmlBytes) {
        return kcenon::common::make_error<registry_query_result>(
            static_cast<int>(error_code::transport_response_too_large),
            "AdhocQueryResponse root part exceeds 8 MiB cap (" +
                std::to_string(root_xml.size()) + " bytes)",
            std::string(error_source));
    }
 
    pugi::xml_document doc;
    auto parse = doc.load_buffer(root_xml.data(), root_xml.size(),
                                 pugi::parse_default, pugi::encoding_utf8);
    if (!parse) {
        return kcenon::common::make_error<registry_query_result>(
            static_cast<int>(error_code::transport_invalid_response),
            std::string("failed to parse response envelope: ") +
                parse.description(),
            std::string(error_source));
    }
 
    // Use local-name() selectors so we do not depend on the specific
    // namespace prefix the registry emits. ebRS stacks (Apache CXF,
    // .NET WIF, Gazelle, Open Health Tools) pick different prefixes for
    // the query and rim namespaces.
    auto adhoc_response =
        doc.select_node(
               "//*[local-name()='AdhocQueryResponse']").node();
    if (!adhoc_response) {
        return kcenon::common::make_error<registry_query_result>(
            static_cast<int>(error_code::registry_query_response_malformed),
            "response contains no AdhocQueryResponse element",
            std::string(error_source));
    }
 
    const std::string status =
        adhoc_response.attribute("status").as_string();
    if (status.empty()) {
        return kcenon::common::make_error<registry_query_result>(
            static_cast<int>(error_code::registry_query_response_malformed),
            "AdhocQueryResponse is missing status attribute",
            std::string(error_source));
    }
    // PartialSuccess means "some entries returned with warnings" in
    // IHE ITI-18 - the registry has produced a valid RegistryObjectList
    // alongside a RegistryErrorList. An earlier draft returned
    // registry_partial_success as an error, which dropped the entries
    // and contradicted the public-header contract that callers branch on
    // entries.empty() and inspect registry_response_status. Treat
    // PartialSuccess as a non-fatal status: fall through to the
    // ExtrinsicObject walk and surface the raw status string in the
    // returned result so callers can distinguish Success from
    // PartialSuccess if their policy differs (review M2).
    if (status != kSuccessStatus && status != kPartialSuccessStatus) {
        return kcenon::common::make_error<registry_query_result>(
            static_cast<int>(error_code::registry_failure_response),
            "registry reported non-success status: " + status,
            std::string(error_source));
    }
 
    registry_query_result out;
    out.registry_response_status = status;
 
    // Narrow child xpath (review m6): match ExtrinsicObject children of
    // RegistryObjectList only, not arbitrary descendants. This avoids
    // picking up nested ExtrinsicObject elements that could appear inside
    // a RegistryError's detail payload on non-conformant responses.
    // The RegistryObjectList is optional when no entries match; a Success
    // response with zero results is valid and maps to out.entries.empty().
    for (auto node : adhoc_response.select_nodes(
             "*[local-name()='RegistryObjectList']/"
             "*[local-name()='ExtrinsicObject']")) {
        out.entries.push_back(extract_entry(node.node()));
    }
 
    return out;
}

References kcenon::pacs::ihe::xds::error_source, out, kcenon::pacs::ihe::xds::registry_failure_response, kcenon::pacs::ihe::xds::registry_query_response_malformed, kcenon::pacs::ihe::xds::transport_invalid_response, and kcenon::pacs::ihe::xds::transport_response_too_large.

Referenced by kcenon::pacs::ihe::xds::registry_query::impl::execute().

Here is the caller graph for this function:

◆ parse_retrieve_response()

kcenon::common::Result< document_response > kcenon::pacs::ihe::xds::detail::parse_retrieve_response	(	const std::string &	root_xml,
		const std::vector< mtom_part > &	parts,
		const retrieve_request &	req )

Parse a RetrieveDocumentSetResponse envelope and resolve the attachment that matches req.

root_xml is the root part of the MTOM response (already verified). parts are the remaining attachment parts, keyed on the bare content-id that the xop:Include elements reference via "cid:".

Returns consumer_response_document_not_found when the registry reports a Failure status, when no DocumentResponse matches the requested document_unique_id, or when the matching xop:Include points to a cid that is not present in parts.

Definition at line 52 of file retrieve_response_parser.cpp.

                                 {
    if (root_xml.size() > kMaxRootXmlBytes) {
        return kcenon::common::make_error<document_response>(
            static_cast<int>(error_code::transport_response_too_large),
            "RetrieveDocumentSetResponse root part exceeds 8 MiB cap (" +
                std::to_string(root_xml.size()) + " bytes)",
            std::string(error_source));
    }
 
    pugi::xml_document doc;
    auto parse = doc.load_buffer(root_xml.data(), root_xml.size(),
                                 pugi::parse_default, pugi::encoding_utf8);
    if (!parse) {
        return kcenon::common::make_error<document_response>(
            static_cast<int>(error_code::transport_invalid_response),
            std::string("failed to parse response envelope: ") +
                parse.description(),
            std::string(error_source));
    }
 
    // Use local-name() selectors so we do not depend on the specific
    // namespace prefix the repository emits. Different XDS.b stacks
    // (Apache CXF, .NET WIF, Gazelle) pick different prefixes for the
    // xdsb namespace.
    auto rds_response =
        doc.select_node(
               "//*[local-name()='RetrieveDocumentSetResponse']").node();
    if (!rds_response) {
        return kcenon::common::make_error<document_response>(
            static_cast<int>(error_code::transport_invalid_response),
            "response contains no RetrieveDocumentSetResponse element",
            std::string(error_source));
    }
 
    auto registry_response =
        rds_response.select_node("*[local-name()='RegistryResponse']").node();
    if (!registry_response) {
        return kcenon::common::make_error<document_response>(
            static_cast<int>(error_code::transport_invalid_response),
            "response has no RegistryResponse",
            std::string(error_source));
    }
    const std::string status =
        registry_response.attribute("status").as_string();
    if (status.empty()) {
        return kcenon::common::make_error<document_response>(
            static_cast<int>(error_code::transport_invalid_response),
            "RegistryResponse is missing status attribute",
            std::string(error_source));
    }
    if (status == kPartialSuccessStatus) {
        return kcenon::common::make_error<document_response>(
            static_cast<int>(error_code::registry_partial_success),
            "repository reported PartialSuccess: " + status,
            std::string(error_source));
    }
    if (status != kSuccessStatus) {
        // A Failure here means the repository could not locate the
        // requested document - either the uid is unknown or the requester
        // has no access. Either way, surface as not-found to the caller.
        return kcenon::common::make_error<document_response>(
            static_cast<int>(error_code::consumer_response_document_not_found),
            "repository reported non-success status: " + status,
            std::string(error_source));
    }
 
    // Walk each DocumentResponse looking for the requested uid. Use
    // local-name() selectors throughout because repositories emit the
    // xdsb namespace with different prefixes (xdsb, ns2, ihe-xdsb, etc.).
    pugi::xml_node match;
    for (auto dr :
         rds_response.select_nodes("*[local-name()='DocumentResponse']")) {
        auto node = dr.node();
        const std::string uid =
            node.select_node("*[local-name()='DocumentUniqueId']")
                .node()
                .text()
                .as_string();
        if (uid == req.document_unique_id) {
            match = node;
            break;
        }
    }
    if (!match) {
        return kcenon::common::make_error<document_response>(
            static_cast<int>(error_code::consumer_response_document_not_found),
            "no DocumentResponse matched requested uid " +
                req.document_unique_id,
            std::string(error_source));
    }
 
    const std::string mime_type =
        match.select_node("*[local-name()='mimeType']").node().text().as_string();
 
    auto document_node =
        match.select_node("*[local-name()='Document']").node();
    if (!document_node) {
        return kcenon::common::make_error<document_response>(
            static_cast<int>(error_code::consumer_response_document_not_found),
            "matching DocumentResponse has no Document element",
            std::string(error_source));
    }
 
    // Prefer resolving an xop:Include reference to one of the MTOM
    // attachment parts. Fall back to base64-inlined Document text when the
    // repository returned a non-MTOM response (some stacks do that for
    // small payloads or test responders).
    auto include =
        document_node.select_node("*[local-name()='Include']").node();
 
    document_response out;
    out.registry_response_status = status;
    out.document_unique_id = req.document_unique_id;
    out.repository_unique_id = req.repository_unique_id;
    out.mime_type = mime_type;
 
    if (include) {
        const std::string raw_href = include.attribute("href").as_string();
        const std::string cid = strip_cid_href(raw_href);
        if (cid.empty()) {
            return kcenon::common::make_error<document_response>(
                static_cast<int>(
                    error_code::consumer_response_document_not_found),
                "xop:Include has empty href",
                std::string(error_source));
        }
        const mtom_part* found = nullptr;
        for (const auto& p : parts) {
            if (p.content_id == cid) {
                found = &p;
                break;
            }
        }
        if (found == nullptr) {
            return kcenon::common::make_error<document_response>(
                static_cast<int>(
                    error_code::consumer_response_document_not_found),
                "xop:Include references unknown cid: " + cid,
                std::string(error_source));
        }
        out.content = found->content;
        if (out.mime_type.empty()) {
            out.mime_type = found->mime_type;
        }
        return out;
    }
 
    // Non-MTOM fallback: Document carries inline base64.
    const std::string inline_b64 = document_node.text().as_string();
    if (inline_b64.empty()) {
        return kcenon::common::make_error<document_response>(
            static_cast<int>(error_code::consumer_response_document_not_found),
            "Document element has neither xop:Include nor inline content",
            std::string(error_source));
    }
    // Decode the inline base64 so document_response.content has the
    // same "already-decoded binary bytes" semantics regardless of
    // whether the repository used MTOM or inline-base64 framing. Review
    // Minor-1 fix: avoid divergent caller expectations.
    out.content = base64_decode_bytes(inline_b64);
    if (out.content.empty()) {
        return kcenon::common::make_error<document_response>(
            static_cast<int>(error_code::consumer_response_document_not_found),
            "inline Document base64 decode failed or yielded empty bytes",
            std::string(error_source));
    }
    return out;
}

Referenced by kcenon::pacs::ihe::xds::document_consumer::impl::retrieve().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_http_transport_override()

void kcenon::pacs::ihe::xds::detail::set_http_transport_override ( transport_override fn )

Definition at line 106 of file http_client.cpp.

                                                        {
    std::lock_guard<std::mutex> lock(override_mutex());
    override_fn() = std::move(fn);
}

◆ sign_envelope()

kcenon::common::Result< bool > kcenon::pacs::ihe::xds::detail::sign_envelope	(	built_envelope &	env,
		std::string_view	cert_pem,
		std::string_view	key_pem,
		std::string_view	key_password )

Sign the body + timestamp of env in place.

cert_pem is the PEM-encoded X.509 signer certificate. key_pem is the matching PEM RSA or EC private key; key_password decrypts it when the key is encrypted and is ignored otherwise.

The envelope's BinarySecurityToken is populated with the DER-encoded certificate (Base64). A ds:Signature element is appended to the wsse:Security header covering the body and timestamp by wsu:Id reference.

On success, env.xml is replaced by the signed envelope and the Result<bool> value is true (the bool is a sentinel; the signature itself is inside env.xml).

Definition at line 206 of file wss_signer.cpp.

                                                                        {
    if (cert_pem.empty()) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(error_code::signer_invalid_certificate),
            "certificate PEM is empty", std::string(error_source));
    }
    if (key_pem.empty()) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(error_code::signer_invalid_private_key),
            "private key PEM is empty", std::string(error_source));
    }
 
    auto cert = load_cert(cert_pem);
    if (!cert) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(error_code::signer_invalid_certificate),
            "PEM_read_bio_X509 failed", std::string(error_source));
    }
    auto key = load_key(key_pem, key_password);
    if (!key) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(error_code::signer_invalid_private_key),
            "PEM_read_bio_PrivateKey failed", std::string(error_source));
    }
 
    const auto der = cert_to_der(cert.get());
    if (der.empty()) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(error_code::signer_invalid_certificate),
            "i2d_X509 failed", std::string(error_source));
    }
    const std::string cert_b64 = base64_encode(der.data(), der.size());
    if (cert_b64.empty()) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(error_code::signer_invalid_certificate),
            "base64 of DER certificate failed", std::string(error_source));
    }
 
    pugi::xml_document doc;
    auto parse_result =
        doc.load_buffer(env.xml.data(), env.xml.size(),
                        pugi::parse_default, pugi::encoding_utf8);
    if (!parse_result) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(error_code::envelope_build_failed),
            std::string("failed to reparse envelope: ") +
                parse_result.description(),
            std::string(error_source));
    }
 
    auto envelope = doc.child("soap:Envelope");
    auto header = envelope.child("soap:Header");
    auto security = header.child("wsse:Security");
    auto bst = security.child("wsse:BinarySecurityToken");
    auto timestamp = security.child("wsu:Timestamp");
    auto body = envelope.child("soap:Body");
 
    if (!envelope || !header || !security || !bst || !timestamp || !body) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(error_code::envelope_build_failed),
            "envelope is missing required WS-Security scaffolding",
            std::string(error_source));
    }
 
    bst.text().set(cert_b64.c_str());
 
    const std::string body_c14n = serialize_subtree(body);
    const std::string ts_c14n = serialize_subtree(timestamp);
 
    if (body_c14n.empty() || ts_c14n.empty()) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(error_code::signer_digest_failed),
            "serialized Body or Timestamp is empty",
            std::string(error_source));
    }
 
    const std::string body_digest = sha256_base64(body_c14n);
    const std::string ts_digest = sha256_base64(ts_c14n);
    if (body_digest.empty() || ts_digest.empty()) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(error_code::signer_digest_failed),
            "SHA-256 digest failed", std::string(error_source));
    }
 
    auto signature = security.append_child("ds:Signature");
    signature.append_attribute("xmlns:ds") = "http://www.w3.org/2000/09/xmldsig#";
 
    auto signed_info = signature.append_child("ds:SignedInfo");
    auto c14n_method = signed_info.append_child("ds:CanonicalizationMethod");
    c14n_method.append_attribute("Algorithm") = kKcenonC14nUri;
    auto sig_method = signed_info.append_child("ds:SignatureMethod");
    sig_method.append_attribute("Algorithm") =
        "http://www.w3.org/2001/04/xmldsig-more#rsa-sha256";
 
    const auto add_reference = [&](const std::string& uri,
                                   const std::string& digest_b64) {
        auto ref = signed_info.append_child("ds:Reference");
        ref.append_attribute("URI") = ("#" + uri).c_str();
        auto transforms = ref.append_child("ds:Transforms");
        auto xform = transforms.append_child("ds:Transform");
        xform.append_attribute("Algorithm") = kKcenonC14nUri;
        auto digest_method = ref.append_child("ds:DigestMethod");
        digest_method.append_attribute("Algorithm") =
            "http://www.w3.org/2001/04/xmlenc#sha256";
        ref.append_child("ds:DigestValue").text().set(digest_b64.c_str());
    };
    add_reference(env.body_id, body_digest);
    add_reference(env.timestamp_id, ts_digest);
 
    const std::string signed_info_bytes = serialize_subtree(signed_info);
    if (signed_info_bytes.empty()) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(error_code::signer_sign_failed),
            "serialized SignedInfo is empty", std::string(error_source));
    }
 
    md_ctx_ptr md(EVP_MD_CTX_new());
    if (!md) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(error_code::signer_sign_failed),
            "EVP_MD_CTX_new failed", std::string(error_source));
    }
    if (EVP_DigestSignInit(md.get(), nullptr, EVP_sha256(), nullptr,
                           key.get()) != 1) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(error_code::signer_sign_failed),
            "EVP_DigestSignInit failed", std::string(error_source));
    }
    if (EVP_DigestSignUpdate(
            md.get(), signed_info_bytes.data(), signed_info_bytes.size()) != 1) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(error_code::signer_sign_failed),
            "EVP_DigestSignUpdate failed", std::string(error_source));
    }
 
    std::size_t sig_len = 0;
    if (EVP_DigestSignFinal(md.get(), nullptr, &sig_len) != 1 || sig_len == 0) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(error_code::signer_sign_failed),
            "EVP_DigestSignFinal probe failed", std::string(error_source));
    }
    std::vector<unsigned char> sig(sig_len);
    if (EVP_DigestSignFinal(md.get(), sig.data(), &sig_len) != 1) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(error_code::signer_sign_failed),
            "EVP_DigestSignFinal failed", std::string(error_source));
    }
    sig.resize(sig_len);
    const std::string sig_b64 = base64_encode(sig.data(), sig.size());
 
    signature.append_child("ds:SignatureValue").text().set(sig_b64.c_str());
 
    auto key_info = signature.append_child("ds:KeyInfo");
    auto sec_ref = key_info.append_child("wsse:SecurityTokenReference");
    auto ref = sec_ref.append_child("wsse:Reference");
    ref.append_attribute("URI") = ("#" + env.binary_security_token_id).c_str();
    ref.append_attribute("ValueType") =
        "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-x509-token-"
        "profile-1.0#X509v3";
 
    xml_string_writer w;
    doc.save(w, "", pugi::format_raw | pugi::format_no_declaration,
             pugi::encoding_utf8);
    env.xml = R"(<?xml version="1.0" encoding="UTF-8"?>)" + w.out;
    return true;
}

Referenced by kcenon::pacs::ihe::xds::registry_query::impl::execute(), kcenon::pacs::ihe::xds::document_consumer::impl::retrieve(), and kcenon::pacs::ihe::xds::document_source::impl::submit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ verify_envelope_integrity()

kcenon::common::Result< bool > kcenon::pacs::ihe::xds::detail::verify_envelope_integrity ( std::string_view signed_xml )

Verify the structural integrity of a previously signed envelope against the certificate embedded in its own BinarySecurityToken.

Reparses signed_xml, locates the ds:Signature in wsse:Security, decodes the BinarySecurityToken into an X.509 public key, re-digests Body and Timestamp with the same pugixml format_raw serializer used for signing, and calls EVP_DigestVerify against the SignedInfo bytes.

SECURITY NOTE - SELF-AUTHENTICATING CHECK, NOT TRUST VALIDATION: this function verifies that the ds:Signature binds the payload to the certificate embedded in the response's BST. It does NOT validate that certificate against a trust anchor, CRL, OCSP responder, or peer TLS identity. A man-in-the-middle who can serve any valid X.509 certificate can produce a response that passes this check - the embedded key, the embedded signature, and the embedded payload are all self-consistent by construction. Full trust-chain validation will land with the Gazelle conformance integration tracked in #1131. Until that lands, callers relying solely on this function for authenticity guarantees are trusting whatever party the TLS peer is.

The rename from verify_envelope to verify_envelope_integrity in the #1129 review cycle is deliberate: the new name closes the "what does this actually guarantee" gap at the call site.

Honest-URI policy: the CanonicalizationMethod and every Transform Algorithm URI inside SignedInfo MUST equal "urn:kcenon:xds:c14n:pugixml-format-raw-v1". If any Algorithm advertises exc-c14n or any other URI, verification is refused with consumer_signature_verification_failed rather than silently digesting a mismatched byte stream. This mirrors the signer's behavior.

Canonicalization caveat: verification is only reproducible for envelopes produced by this project's sign_envelope. Real exc-c14n interop is a follow-up issue that must land before production use against a third-party IHE XDS.b repository.

Returns consumer_signature_missing if the envelope carries no ds:Signature element; consumer_signature_verification_failed on any other mismatch (digest, signature, algorithm, KeyInfo shape).

Definition at line 413 of file wss_signer.cpp.

                               {
    if (signed_xml.empty()) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(
                error_code::consumer_signature_verification_failed),
            "signed envelope is empty", std::string(error_source));
    }
 
    pugi::xml_document doc;
    auto parse = doc.load_buffer(signed_xml.data(), signed_xml.size(),
                                 pugi::parse_default, pugi::encoding_utf8);
    if (!parse) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(
                error_code::consumer_signature_verification_failed),
            std::string("failed to reparse signed envelope: ") +
                parse.description(),
            std::string(error_source));
    }
 
    auto envelope = doc.child("soap:Envelope");
    auto header = envelope.child("soap:Header");
    auto security = header.child("wsse:Security");
    auto signature = security.child("ds:Signature");
    auto bst = security.child("wsse:BinarySecurityToken");
 
    if (!envelope || !header || !security) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(
                error_code::consumer_signature_verification_failed),
            "envelope lacks WS-Security scaffolding",
            std::string(error_source));
    }
    if (!signature) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(error_code::consumer_signature_missing),
            "envelope has no ds:Signature element",
            std::string(error_source));
    }
    if (!bst) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(
                error_code::consumer_signature_verification_failed),
            "envelope has no wsse:BinarySecurityToken",
            std::string(error_source));
    }
 
    // Enforce honest-URI policy on every Algorithm attribute within
    // SignedInfo before trusting the digests.
    auto signed_info = signature.child("ds:SignedInfo");
    if (!signed_info) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(
                error_code::consumer_signature_verification_failed),
            "Signature has no SignedInfo", std::string(error_source));
    }
    auto c14n = signed_info.child("ds:CanonicalizationMethod");
    if (!c14n ||
        std::string(c14n.attribute("Algorithm").as_string()) != kKcenonC14nUri) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(
                error_code::consumer_signature_verification_failed),
            "CanonicalizationMethod is not the kcenon project-local URI",
            std::string(error_source));
    }
 
    // Load public key from BST.
    const std::string bst_b64 = strip_b64_whitespace(bst.text().as_string());
    const auto der = base64_decode(bst_b64);
    if (der.empty()) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(
                error_code::consumer_signature_verification_failed),
            "BinarySecurityToken base64 decode failed",
            std::string(error_source));
    }
 
    // SECURITY NOTE: the X.509 we are about to pull out of the BST is
    // used only to recover a public key for EVP_DigestVerify; it is NOT
    // validated against a trust anchor. See the Doxygen on
    // verify_envelope_integrity for the deferral and tracking issue.
 
    const unsigned char* der_ptr = der.data();
    x509_ptr cert(d2i_X509(nullptr, &der_ptr, static_cast<long>(der.size())));
    if (!cert) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(
                error_code::consumer_signature_verification_failed),
            "d2i_X509 failed on BinarySecurityToken",
            std::string(error_source));
    }
    pkey_ptr pkey(X509_get_pubkey(cert.get()));
    if (!pkey) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(
                error_code::consumer_signature_verification_failed),
            "X509_get_pubkey failed", std::string(error_source));
    }
 
    // Recompute digests for every Reference in SignedInfo and compare
    // against the advertised DigestValue.
    for (auto ref = signed_info.child("ds:Reference"); ref;
         ref = ref.next_sibling("ds:Reference")) {
        for (auto xform = ref.child("ds:Transforms").child("ds:Transform");
             xform; xform = xform.next_sibling("ds:Transform")) {
            if (std::string(xform.attribute("Algorithm").as_string()) !=
                kKcenonC14nUri) {
                return kcenon::common::make_error<bool>(
                    static_cast<int>(
                        error_code::consumer_signature_verification_failed),
                    "Reference Transform is not the kcenon project-local URI",
                    std::string(error_source));
            }
        }
        const std::string uri = strip_uri_fragment(
            ref.attribute("URI").as_string());
        if (uri.empty()) {
            return kcenon::common::make_error<bool>(
                static_cast<int>(
                    error_code::consumer_signature_verification_failed),
                "Reference URI is empty", std::string(error_source));
        }
        auto target = find_by_wsu_id(envelope, uri);
        if (!target) {
            return kcenon::common::make_error<bool>(
                static_cast<int>(
                    error_code::consumer_signature_verification_failed),
                "Reference target not found: " + uri,
                std::string(error_source));
        }
        const std::string bytes = serialize_subtree(target);
        const std::string want_digest = sha256_base64(bytes);
        const std::string have_digest = strip_b64_whitespace(
            ref.child("ds:DigestValue").text().as_string());
        if (want_digest != have_digest) {
            return kcenon::common::make_error<bool>(
                static_cast<int>(
                    error_code::consumer_signature_verification_failed),
                "DigestValue mismatch for reference: " + uri,
                std::string(error_source));
        }
    }
 
    // Verify the signature over SignedInfo.
    const std::string signed_info_bytes = serialize_subtree(signed_info);
    if (signed_info_bytes.empty()) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(
                error_code::consumer_signature_verification_failed),
            "serialized SignedInfo is empty", std::string(error_source));
    }
    const auto sig_bytes = base64_decode(
        signature.child("ds:SignatureValue").text().as_string());
    if (sig_bytes.empty()) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(
                error_code::consumer_signature_verification_failed),
            "SignatureValue base64 decode failed",
            std::string(error_source));
    }
 
    md_ctx_ptr md(EVP_MD_CTX_new());
    if (!md) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(
                error_code::consumer_signature_verification_failed),
            "EVP_MD_CTX_new failed", std::string(error_source));
    }
    if (EVP_DigestVerifyInit(md.get(), nullptr, EVP_sha256(), nullptr,
                             pkey.get()) != 1) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(
                error_code::consumer_signature_verification_failed),
            "EVP_DigestVerifyInit failed", std::string(error_source));
    }
    if (EVP_DigestVerifyUpdate(md.get(), signed_info_bytes.data(),
                               signed_info_bytes.size()) != 1) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(
                error_code::consumer_signature_verification_failed),
            "EVP_DigestVerifyUpdate failed", std::string(error_source));
    }
    const int verdict =
        EVP_DigestVerifyFinal(md.get(), sig_bytes.data(), sig_bytes.size());
    if (verdict != 1) {
        return kcenon::common::make_error<bool>(
            static_cast<int>(
                error_code::consumer_signature_verification_failed),
            "EVP_DigestVerifyFinal rejected the signature",
            std::string(error_source));
    }
    return true;
}

References kcenon::pacs::ihe::xds::consumer_signature_missing, kcenon::pacs::ihe::xds::consumer_signature_verification_failed, and kcenon::pacs::ihe::xds::error_source.

Referenced by kcenon::pacs::ihe::xds::registry_query::impl::execute(), and kcenon::pacs::ihe::xds::document_consumer::impl::retrieve().

Here is the caller graph for this function:

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

◆ transport_override

Enumeration Type Documentation

◆ stored_query_kind

Function Documentation

◆ base64_decode_bytes()

◆ build_iti18_envelope()

◆ build_iti41_envelope()

◆ build_iti43_envelope()

◆ clear_http_transport_override()

◆ http_post()

◆ package_mtom()

◆ parse_mtom_response()

◆ parse_query_response()

◆ parse_retrieve_response()

◆ set_http_transport_override()

◆ sign_envelope()

◆ verify_envelope_integrity()