BridgeHead

मूल C++ Active Directory तक पहुंच ADWS पर, कोई .NET नहीं, कोई WCF नहीं, कोई HTTP स्टैक नहीं।

BridgeHead एक C++20 स्टैटिक लाइब्रेरी है जो पूर्ण Active Directory Web Services (ADWS) प्रोटोकॉल स्टैक को सीधे TCP पर लागू करती है। AD ब्रिजहेड सर्वर के नाम पर, वह गेटवे जिसके माध्यम से निर्देशिका ट्रैफिक प्रवाहित होता है, यह आपके C++ कोड को पोर्ट 9389 तक वही निम्न-स्तरीय पहुंच प्रदान करता है जो PowerShell के Get-ADUser और Get-ADComputer हुड के नीचे उपयोग करते हैं।

प्रोटोकॉल स्टैक

परिवहन परतें सामान्य bridgehead::transport::IByteStream इंटरफ़ेस के माध्यम से नीचे की परत को लपेटती हैं। NbfseCodec एक कोडेक उपयोगिता है जिसे AdwsClient द्वारा SOAP संदेशों को फ्रेमिंग से पहले और बाद में एन्कोड/डिकोड करने के लिए कहा जाता है:``` AdwsClient WS-Enumeration + WS-Transfer [MS-ADDM] ├── NbfseCodec .NET Binary Format for SOAP [MC-NBFSE] (encode/decode) └── NmfFramer .NET Message Framing [MC-NMF] (send/receive frames) └── NnsSession .NET NegotiateStream [MS-NNS] └── TcpSocket raw TCP/IP

उपभोक्ताओं के लिए प्रवेश बिंदु `bridgehead::adws::AdwsClient` है।

---

## त्वरित आरंभ

### क्वेरी करें, सभी उपयोगकर्ताओं की गणना करें```cpp
#include "bridgehead/adws/AdwsClient.hpp"

// NTLM (works on any host)
auto client = bridgehead::adws::AdwsClient::EnumerationClient(
    "192.168.1.10",     // DC IP or hostname
    "DC01.corp.local",  // DC FQDN, used in NMF Via header and Kerberos SPN
    "CORP",             // NetBIOS domain name
    "Administrator",    // username
    "Passw0rd"          // password
);

// Kerberos (username hidden on the wire; requires DC reachable on port 88)
auto client = bridgehead::adws::AdwsClient::EnumerationClient(
    "192.168.1.10", "DC01.corp.local", "CORP",
    "Administrator", "Passw0rd",
    bridgehead::adws::AuthPackage::Kerberos
);

auto users = client.Query(
    "(objectClass=user)",
    {"sAMAccountName", "distinguishedName", "memberOf"}
);

for (auto& obj : users)
    std::cout << obj.FirstValue("sAMAccountName") << '\n';

बड़े परिणाम सेट को स्ट्रीम करें```cpp

client.Enumerate( "(objectClass=computer)", {"dNSHostName", "operatingSystem"}, "", // empty = domain root base DN [](const bridgehead::adws::LdapObject& obj) { std::cout << obj.FirstValue("dNSHostName") << '\n'; return true; // return false to stop early (sends wsen:Release) } );

### दायरा और पृष्ठांकन```cpp
// OneLevel scope, 50 objects per Pull round-trip
client.Query(
    "(objectClass=user)",
    {"sAMAccountName"},
    "OU=Admins,DC=corp,DC=local",
    50,
    bridgehead::adws::SearchScope::OneLevel
);

बाइनरी विशेषताएँ, objectGUID, objectSid```cpp

auto objs = client.Query("(objectClass=user)", {"objectGUID", "objectSid"}); for (auto& obj : objs) { if (auto* b = obj.FirstBytes("objectGUID")) std::cout << bridgehead::adws::ParseGuid(b) << '\n'; // {XXXXXXXX-...} if (auto b = obj.FirstBytes("objectSid")) std::cout << bridgehead::adws::ParseSid(*b) << '\n'; // S-1-5-... }

### सुरक्षा विवरणक डिकोडिंग```cpp
#include "bridgehead/adws/SecurityDescriptor.hpp"

auto objs = client.Query("(objectClass=user)", {"nTSecurityDescriptor"});
if (auto* raw = objs[0].FirstBytes("nTSecurityDescriptor")) {
    auto sd = bridgehead::adws::ParseSecurityDescriptor(*raw);
    std::cout << "Owner: " << sd.ownerSid << '\n';
    for (auto& ace : sd.dacl.aces)
        std::cout << "  type=" << (int)ace.type
                  << " mask=0x" << std::hex << ace.mask
                  << " sid="   << ace.sid << '\n';
}

गुण लिखें (संसाधन एंडपॉइंट)```cpp

auto rc = bridgehead::adws::AdwsClient::ResourceClient( "192.168.1.10", "DC01.corp.local", "CORP", "Administrator", "Passw0rd");

// Modify attributes rc.Put("CN=Alice,OU=Users,DC=corp,DC=local", { {"description", {"managed by bridgehead"}}, {"telephoneNumber", {"555-1234"}}, });

// Clear an attribute (both values and bytes empty = delete) rc.Put("CN=Alice,OU=Users,DC=corp,DC=local", { {"telephoneNumber", {}}, });

// Read back auto obj = rc.Get("CN=Alice,OU=Users,DC=corp,DC=local", {"description", "telephoneNumber"});

// Delete object rc.Delete("CN=TempUser,OU=Users,DC=corp,DC=local");

### LDAP संशोधन प्रकार, जोड़ें / बदलें / हटाएं

`Put` डिफ़ॉल्ट रूप से `Replace` (सभी मौजूदा मानों को अधिलेखित करता है) होता है। बहु-मूल्यवान गुणों पर सूक्ष्म-नियंत्रण के लिए `ModifyOperation` का उपयोग करें:```cpp
using bridgehead::adws::LdapModification;
using bridgehead::adws::ModifyOperation;

rc.Put("CN=Alice,OU=Users,DC=corp,DC=local", {
    // Append a value to an existing multi-valued attribute
    LdapModification{"otherTelephone", {"555-9999"}, {}, ModifyOperation::Add},

    // Remove one specific value (leave others intact)
    LdapModification{"otherTelephone", {"555-0000"}, {}, ModifyOperation::Delete},

    // Replace is the default, explicit here for clarity
    LdapModification{"description", {"updated"}, {}, ModifyOperation::Replace},
});

स्थानांतरित करें / नाम बदलें```cpp

// Move to a different OU rc.Move( "CN=Alice,OU=OldOU,DC=corp,DC=local", // current DN "CN=Alice,OU=NewOU,DC=corp,DC=local" // new DN );

// Rename in place (same parent, new CN) rc.Move( "CN=Alice,OU=Users,DC=corp,DC=local", "CN=AliceSmith,OU=Users,DC=corp,DC=local" );

### बाइनरी विशेषताएँ लिखें

`LdapModification` के `bytes` फ़ील्ड में बाइनरी मान प्रदान करें। ये वायर पर स्वचालित रूप से base64-एन्कोडेड होते हैं:```cpp
std::vector<uint8_t> thumbnail = loadFile("photo.jpg");

rc.Put("CN=Alice,OU=Users,DC=corp,DC=local", {
    LdapModification{"thumbnailPhoto", {}, {thumbnail}},
});

ऑब्जेक्ट बनाएँ (ResourceFactory endpoint)```cpp

auto rf = bridgehead::adws::AdwsClient::ResourceFactoryClient( "192.168.1.10", "DC01.corp.local", "CORP", "Administrator", "Passw0rd");

rf.Create( "CN=NewUser,OU=Users,DC=corp,DC=local", "user", {{"sAMAccountName", {"newuser"}}, {"userAccountControl", {"512"}}} );

### एसिंक संचालन```cpp
#include "bridgehead/adws/AdwsClientAsync.hpp"

auto ac = bridgehead::adws::AdwsClientAsync::EnumerationClient(
    "192.168.1.10", "DC01.corp.local", "CORP", "Administrator", "Passw0rd");

auto future = ac.QueryAsync("(objectClass=user)", {"sAMAccountName"});

// ... do other work while the query runs ...

auto users = future.get();  // blocks until complete; re-throws any exception

धीमे DC पर टाइमआउट:```cpp if (future.wait_for(std::chrono::seconds(5)) == std::future_status::timeout) { // query is still running }

सभी ऑपरेशनों में async वेरिएंट होते हैं: `QueryAsync`, `EnumerateAsync`, `GetAsync`, `PutAsync`, `DeleteAsync`, `CreateAsync`, `MoveAsync`।

### कनेक्शन पूल (उच्च-आवृत्ति / बहु-थ्रेडेड कार्यभार)```cpp
#include "bridgehead/adws/AdwsClientPool.hpp"

// Enumeration pool, Query / Enumerate
bridgehead::adws::AdwsClientPool pool({
    .host = "192.168.1.10", .fqdn = "DC01.corp.local",
    .domain = "CORP", .username = "Administrator", .password = "Passw0rd",
    .maxSize = 4,   // up to 4 concurrent authenticated sessions
});

auto users = pool.Query("(objectClass=user)", {"sAMAccountName"});

// Resource pool, Get / Put / Delete
bridgehead::adws::AdwsClientPool resPool({
    .host = "192.168.1.10", .fqdn = "DC01.corp.local",
    .domain = "CORP", .username = "Administrator", .password = "Passw0rd",
    .maxSize = 4,
    .endpoint = bridgehead::adws::PoolEndpoint::Resource,
});
auto obj = resPool.Get("CN=Alice,OU=Users,DC=corp,DC=local", {"mail"});
resPool.Put("CN=Alice,OU=Users,DC=corp,DC=local", {{"mail", {"[email protected]"}}});

// ResourceFactory pool, Create
bridgehead::adws::AdwsClientPool rfPool({
    .host = "192.168.1.10", .fqdn = "DC01.corp.local",
    .domain = "CORP", .username = "Administrator", .password = "Passw0rd",
    .endpoint = bridgehead::adws::PoolEndpoint::ResourceFactory,
});
rfPool.Create("CN=NewUser,OU=Users,DC=corp,DC=local", "user",
              {{"sAMAccountName", {"newuser"}}});

एपीआई संदर्भ

सभी सार्वजनिक हेडर include/bridgehead/ में स्थित हैं। पूर्ण एपीआई दस्तावेज़ीकरण Doxygen के साथ उत्पन्न किया जा सकता है (देखें निर्माण)।

`bridgehead::adws::AdwsClient`

`bridgehead::adws::AdwsClientAsync`

std::future-आधारित एसिंक रैपर। AdwsClient के समान फैक्टरी विधियाँ; प्रत्येक ऑपरेशन std::future<T> लौटाता है:```cpp std::future<std::vector> f = ac.QueryAsync(...); std::future e = ac.EnumerateAsync(filter, attrs, baseDN, callback); std::future g = ac.GetAsync(...); std::future h = ac.PutAsync(...); std::future i = ac.DeleteAsync(...); std::future j = ac.CreateAsync(...); std::future k = ac.MoveAsync(...);

एक साथ कई कनेक्शनों पर क्वेरी के लिए, `AdwsClientPool` का उपयोग करें।

### `bridgehead::adws::AdwsClientPool`

पूर्व-प्रमाणित सत्रों का थ्रेड-सुरक्षित पूल। कनेक्शन आलसी रूप से बनाए जाते हैं और कॉल में पुन: उपयोग किए जाते हैं।```cpp
pool.IdleCount();   // sessions currently idle
pool.TotalCount();  // idle + checked-out
pool.MaxSize();     // configured maximum pool size
pool.Move(dn, newDn);  // Move/rename (Resource pool)

`bridgehead::adws::SearchScope````cpp

enum class SearchScope { Base, OneLevel, Subtree /default/ };

### `bridgehead::adws::LdapObject` / `LdapAttribute````cpp
struct LdapAttribute {
    std::string name;
    std::string syntax;                         // LdapSyntax OID, empty if absent
    std::vector<std::string>          values;   // text values (raw base64 for binary)
    std::vector<std::vector<uint8_t>> bytes;    // decoded binary; parallel to values
};

struct LdapObject {
    std::vector<LdapAttribute>  attributes;                          // all returned attributes
    const LdapAttribute*        Find(const std::string& name) const;  // case-insensitive
    std::string                 FirstValue(const std::string& name) const;
    const std::vector<uint8_t>* FirstBytes(const std::string& name) const;
};

बाइनरी सहायक```cpp

std::string ParseGuid(const std::vector<uint8_t>& bytes); // → "{XXXXXXXX-XXXX-...}" std::string ParseSid (const std::vector<uint8_t>& bytes); // → "S-1-5-..."

### `FilterValue` और filter builder helpers

`FilterValue` एक type-safe wrapper है जो RFC 4515 §3 मेटाकैरेक्टर्स (`\`, `*`, `(`, `)`, NUL) को निर्माण के समय एस्केप करता है। इसे builder helpers के साथ उपयोग करें ताकि LDAP इंजेक्शन को संरचनात्मक रूप से असंभव बनाया जा सके:```cpp
// UNSAFE, raw string concatenation, easy to forget escaping
client.Query("(sAMAccountName=" + username + ")", ...);

// SAFE, FilterValue escapes on construction; FilterEq composes the assertion
FilterValue user = username;
client.Query(FilterEq("sAMAccountName", user), ...);

// Compose complex filters
client.Query(
    FilterAnd({
        FilterEq("objectClass", FilterValue::Raw("user")),  // Raw() for safe literals
        FilterOr({
            FilterEq("sAMAccountName", user),
            FilterEq("mail", FilterValue(email)),
        }),
        FilterNot(FilterPresent("userAccountControl")),
    }), {"sAMAccountName", "mail"}
);

EscapeLdapFilter(str) अभी भी एक निम्न-स्तरीय प्रारंभिक के रूप में उपलब्ध है जब आपको फ़िल्टर स्ट्रिंग्स मैन्युअल रूप से बनाने की आवश्यकता होती है।

`DnValue` और DN बिल्डर हेल्पर्स

FilterValue के समान पैटर्न, लेकिन वितरित नाम RDN मानों (RFC 4514 §2.4) के लिए। एस्केप करता है ,, +, ", \, <, >, ;, NUL, और अग्रणी/अनुगामी # और स्पेस:```cpp // UNSAFE, comma injection breaks the DN structure rc.Get("CN=" + username + ",OU=Users,DC=corp,DC=local", attrs);

// SAFE DnValue cn = username; // auto-escaped auto dn = BuildDn({DnAttr("CN", cn), "OU=Users", "DC=corp", "DC=local"}); rc.Get(dn, attrs);

// DnValue::Raw() for values you control auto dn2 = BuildDn({DnAttr("CN", DnValue::Raw("Service Account")), "OU=SvcAccounts", "DC=corp", "DC=local"});

### `bridgehead::adws::SecurityDescriptor````cpp
SecurityDescriptor ParseSecurityDescriptor(const std::vector<uint8_t>& bytes);

struct SecurityDescriptor {
    uint16_t    control;       // SdControl::* flags
    std::string ownerSid;
    std::string groupSid;
    bool hasDacl; Acl dacl;
    bool hasSacl; Acl sacl;
};
struct Acl { std::vector<Ace> aces; };
struct Ace {
    uint8_t     type;                  // AceType::*
    uint8_t     flags;                 // AceFlags::*
    uint32_t    mask;
    std::string sid;
    std::string objectType;            // GUID string, object ACEs only
    std::string inheritedObjectType;   // GUID string, object ACEs only
};

स्थिर नामस्थान: AceType::*, AceFlags::*, SdControl::*.

`bridgehead::ConnectionError` / `AuthenticationError` / `ProtocolError`

में परिभाषित include/bridgehead/Exceptions.hpp (AdwsClient.hpp द्वारा अप्रत्यक्ष रूप से शामिल)। ये तीनों std::runtime_error को विस्तारित करते हैं:

प्रकार	कब फेंका जाता है
`ConnectionError`	TCP-स्तर की विफलता: अस्वीकृत, समय समाप्ति, I/O त्रुटि
`AuthenticationError`	NTLM/Kerberos वार्ता विफल होती है
`ProtocolError`	किसी भी प्रोटोकॉल स्तर पर गलत स्वरूप का सर्वर प्रतिक्रिया

auto client = bridgehead::adws::AdwsClient::EnumerationClient(...);
auto users  = client.Query(...);

} catch (const bridgehead::ConnectionError& e) { // unreachable DC, wrong port, timeout } catch (const bridgehead::AuthenticationError& e) { // bad credentials, KDC unreachable } catch (const bridgehead::ProtocolError& e) { // unexpected server response } catch (const bridgehead::adws::SoapFault& e) { // DC returned a SOAP fault (e.g. invalid filter) } // or coarse-grained: // } catch (const std::runtime_error& e) { ... }

### `bridgehead::adws::SoapFault`

DC से किसी भी `s:Fault` प्रतिक्रिया पर एक सादे `std::runtime_error` के बजाय उठाया जाता है:```cpp
struct SoapFault : std::runtime_error {
    std::string code;     // e.g. "Sender"
    std::string subcode;  // e.g. "InvalidEnumerationContext", empty if absent
    std::string reason;   // human-readable text
};

`bridgehead::adws::LdapModification`

Put और Create द्वारा उपयोग किया जाता है:```cpp enum class ModifyOperation { Replace /default/, Add, Delete };

struct LdapModification { std::string name; std::vectorstd::string values; // text values std::vector<std::vector<uint8_t>> bytes; // binary values (base64-encoded on the wire) ModifyOperation operation = ModifyOperation::Replace; };

जब `values` और `bytes` दोनों खाली हों, तो `operation` के बावजूद विशेषता साफ/हटा दी जाती है।

### `bridgehead::adws::ProtocolLimits`

सभी फैक्टरी विधियों, `AdwsClientAsync` फैक्टरियों और `AdwsClientPool::Config::limits` पर वैकल्पिक अंतिम पैरामीटर। सभी फ़ील्ड्स में सुरक्षित डिफ़ॉल्ट मान हैं, केवल तभी बदलें जब आपकी विशिष्ट आवश्यकताएँ हों:```cpp
struct ProtocolLimits {
    uint32_t nmfMaxFrameBytes   = 64 * 1024 * 1024;  // max NMF frame (default 64 MiB)
    uint32_t nnsMaxPayloadBytes = 16 * 1024 * 1024;  // max NNS packet (default 16 MB)
    int tcpKeepaliveIdleSec     = 60;   // idle seconds before first probe
    int tcpKeepaliveIntervalSec = 10;   // seconds between probes
    int tcpKeepaliveProbeCount  = 5;    // probes before declaring dead (POSIX only)
};

केवल तब nmfMaxFrameBytes / nnsMaxPayloadBytes बढ़ाएं जब आप असामान्य रूप से बड़े बाइनरी गुणों वाली वस्तुओं को पढ़ रहे हों (जैसे कि कई ACEs वाला nTSecurityDescriptor, या बड़ा thumbnailPhoto)। क्लाउड/NAT वातावरण में जहां निष्क्रिय कनेक्शनों को आक्रामक रूप से छोड़ दिया जाता है, वहां keepalive फ़ील्ड्स को कम करें।

नामित कंस्ट्रक्टर सहायक (इनलाइन स्टैटिक फैक्ट्रीज़):```cpp LdapModification::Replace(name, values) // Replace with text values (default) LdapModification::ReplaceBinary(name, bytes) // Replace with binary values LdapModification::Append(name, values) // Add to multi-valued attribute LdapModification::Remove(name, values={}) // Remove specific values (or all) LdapModification::Clear(name) // Delete the attribute entirely

---

## निर्माण

**आवश्यकताएँ:** CMake 3.25+ और एक C++20-सक्षम कंपाइलर (MSVC 2022+, GCC 12+, Clang 15+).```bash
# Configure and build (unit tests only, no live AD needed)
cmake -B build -A x64
cmake --build build --config Release

# Run unit tests
ctest --test-dir build -C Release --output-on-failure

# With integration tests (requires a live Domain Controller)
cmake -B build -A x64 -DBRIDGEHEAD_INTEGRATION_TESTS=ON
cmake --build build --config Release
./build/tests/Release/bridgehead_integration_tests.exe

# With CLI tool (adws_list, browse AD objects from the command line)
cmake -B build -A x64 -DBRIDGEHEAD_BUILD_TOOLS=ON
cmake --build build --config Release --target adws_list
./build/tools/Release/adws_list.exe --host <dc-ip> --fqdn <dc-fqdn> --domain <domain> --user <user>

# Generate API reference docs (requires Doxygen)
cmake --build build --target docs
# or directly:
doxygen Doxyfile
# Output: docs/doxygen/html/index.html

CMake विकल्प

एकीकरण

विकल्प A, CMake उपनिर्देशिका (कोई इंस्टॉल आवश्यक नहीं)```cmake

add_subdirectory(bridgehead) target_link_libraries(my_target PRIVATE bridgehead::bridgehead)

### विकल्प B, स्थापित पैकेज (`find_package`)```bash
cmake --install build --prefix /usr/local   # or any install prefix

इनपुट:```cmake find_package(bridgehead REQUIRED) target_link_libraries(my_target PRIVATE bridgehead::bridgehead)

`pugixml`, `ws2_32`, और `secur32` (Windows) / `gssapi_krb5` (Linux/macOS) सभी ट्रांज़िटिव रूप से खींचे जाते हैं।

---

## प्लेटफ़ॉर्म समर्थन

| प्लेटफ़ॉर्म | प्रमाणीकरण बैकएंड | स्थिति |
|----------|-------------|--------|
| Windows | SSPI (`secur32.dll`), NTLM और Kerberos | **काम कर रहा है** |
| Linux / macOS | GSSAPI (`libgssapi_krb5`), SPNEGO / Kerberos | संकलित; अभी तक एकीकरण-परीक्षण नहीं किया गया |

`AuthPackage::Ntlm` और `AuthPackage::Kerberos` दोनों Windows पर काम करते हैं। Kerberos वायर पर उपयोगकर्ता नाम को छिपाता है और उत्पादन में पसंद किया जाता है; NTLM फ़ॉलबैक है जब KDC (पोर्ट 88) अप्राप्य हो।

Linux/macOS पर GSSAPI बैकएंड Kerberos के साथ SPNEGO का उपयोग करता है। NTLM समर्थन के लिए `gss-ntlmssp` प्लगइन स्थापित करें:```bash
apt install libgss-ntlmssp   # Debian / Ubuntu
dnf install gssntlmssp       # Fedora / RHEL

प्लगइन के बिना सर्वर Kerberos पर बातचीत करेगा। स्पष्ट उपयोगकर्ता/पासवर्ड क्रेडेंशियल gss_acquire_cred_with_password (MIT Kerberos 1.9+) का उपयोग करते हैं; डिफ़ॉल्ट क्रेडेंशियल कैश (kinit) का उपयोग करने के लिए खाली स्ट्रिंग पास करें। GSSAPI पथ साफ-सुथरा संकलित होता है और डिज़ाइन द्वारा सही है, लेकिन अभी तक लाइव DC के खिलाफ एंड-टू-एंड मान्य नहीं किया गया है; Linux/macOS समर्थन को बीटा मानें।

एन्क्रिप्शन नोट: पोर्ट 9389 पर ADWS को NNS परत (NTLM सत्र कुंजी या Kerberos AES-256) पर एन्क्रिप्ट किया जाता है, TLS नहीं। यह डिज़ाइन के अनुसार है, DC इस पोर्ट पर TLS प्रदान नहीं करता है। यदि प्रमाणपत्र-आधारित सर्वर प्रमाणीकरण आवश्यक है, तो LDAPS (पोर्ट 636) विकल्प है।

निर्भरताएँ

कॉन्फ़िगरेशन समय पर cmake/Dependencies.cmake के माध्यम से स्वचालित रूप से प्राप्त किया जाता है, किसी मैन्युअल स्थापना की आवश्यकता नहीं है:

लाइब्रेरी	संस्करण	उद्देश्य
Catch2	v3.5.2	यूनिट टेस्ट फ्रेमवर्क (केवल परीक्षण लक्ष्य)
pugixml	v1.14	XML DOM (केवल ADWS प्रतिक्रिया पार्सिंग)

कोई OpenSSL नहीं। कोई Asio नहीं। कोई Boost नहीं।

ज्ञात सीमाएँ

Linux/macOS पर NTLM के लिए gss-ntlmssp GSSAPI प्लगइन आवश्यक है (देखें प्लेटफ़ॉर्म समर्थन). इसके बिना सर्वर Kerberos पर बातचीत करेगा। Windows पर NTLM SSPI के माध्यम से मूल रूप से काम करता है।
pugixml DOM, प्रत्येक SOAP प्रतिक्रिया को कोई भी परिणाम लौटाने से पहले मेमोरी में एक XML ट्री में पूरी तरह से पार्स किया जाता है। यह maxElements पृष्ठ आकार (प्रति Pull में डिफ़ॉल्ट 256 ऑब्जेक्ट) द्वारा सीमित है, इसलिए पूरा परिणाम सेट एक बार में मेमोरी में नहीं रखा जाता है। मेमोरी केवल बहुत बड़े पृष्ठ आकार या बड़े बाइनरी एट्रीब्यूट्स (जैसे कई ACE वाले ऑब्जेक्ट पर nTSecurityDescriptor) वाले ऑब्जेक्ट के साथ चिंता का विषय बनती है। SAX/स्ट्रीमिंग दृष्टिकोण इसे समाप्त कर देगा लेकिन वर्तमान में इसकी योजना नहीं है।

प्रोटोकॉल संदर्भ

[MS-ADDM], सक्रिय निर्देशिका वेब सेवाएँ: डेटा मॉडल और सामान्य तत्व
[MS-NNS], .NET NegotiateStream प्रोटोकॉल
[MC-NMF], .NET संदेश फ्रेमिंग
[MC-NBFSE], .NET बाइनरी प्रारूप: SOAP एक्सटेंशन
[MS-DTYP], Windows डेटा प्रकार (SECURITY_DESCRIPTOR, ACL, ACE, SID, GUID)
[MS-ADTS], सक्रिय निर्देशिका तकनीकी विनिर्देश (LDAP फ़िल्टर / विशेषताएँ)

सभी विनिर्देश Microsoft के ओपन स्पेसिफिकेशन दस्तावेज़ीकरण पर उपलब्ध हैं।

विशेष धन्यवाद

IBM X-Force और SoaPy प्रोजेक्ट को उनकी प्रेरणा, शोध और सार्वजनिक रूप से साझा किए गए कार्य के लिए विशेष धन्यवाद जिसने इस परियोजना को सूचित करने में मदद की। मैं IBM X-Force Red में SoaPy के निर्माता Logan Goins को भी उस प्रयास और अंतर्दृष्टि के लिए पहचानना चाहूंगा जिसने उस कार्य को संभव बनाया।

लाइसेंस

विवरण के लिए LICENSE देखें।

`EnumerationClient(host, fqdn, domain, user, pass [, auth, timeoutMs, opTimeoutMs, limits])`	`/Enumeration`	फैक्टरी, कनेक्ट और प्रमाणित करें
`ResourceClient(...)`	`/Resource`	Get/Put/Delete/Move के लिए फैक्टरी
`ResourceFactoryClient(...)`	`/ResourceFactory`	Create के लिए फैक्टरी
`Query(filter, attrs [, baseDN, maxElems, scope])`	एनुमरेशन	सभी परिणामों को `vector` में एकत्र करें
`Enumerate(filter, attrs, baseDN, callback [, maxElems, scope])`	एनुमरेशन	कॉलबैक के माध्यम से परिणाम स्ट्रीम करें
`Get(dn, attrs)`	Resource	एकल ऑब्जेक्ट की विशेषताएँ पढ़ें
`Put(dn, modifications)`	Resource	विशेषताएँ संशोधित करें
`Delete(dn)`	Resource	ऑब्जेक्ट हटाएँ
`Create(dn, objectClass, attrs)`	ResourceFactory	नया ऑब्जेक्ट बनाएँ
`Move(dn, newDn)`	Resource	मौजूदा ऑब्जेक्ट को स्थानांतरित या पुनर्नामित करें

`BRIDGEHEAD_BUILD_TESTS`	`ON`	यूनिट परीक्षण सूट बनाएँ
`BRIDGEHEAD_INTEGRATION_TESTS`	`OFF`	एकीकरण परीक्षण बनाएँ (लाइव DC आवश्यक है)
`BRIDGEHEAD_BUILD_TOOLS`	`OFF`	`adws_list` CLI उपकरण बनाएँ

BridgeHead

सबसे लोकप्रिय

BridgeHead

विषय सूची

प्रोटोकॉल स्टैक

बड़े परिणाम सेट को स्ट्रीम करें```cpp

बाइनरी विशेषताएँ, objectGUID, objectSid```cpp

गुण लिखें (संसाधन एंडपॉइंट)```cpp

स्थानांतरित करें / नाम बदलें```cpp

ऑब्जेक्ट बनाएँ (ResourceFactory endpoint)```cpp

एपीआई संदर्भ

bridgehead::adws::AdwsClient

bridgehead::adws::AdwsClientAsync

`bridgehead::adws::SearchScope````cpp

बाइनरी सहायक```cpp

DnValue और DN बिल्डर हेल्पर्स

bridgehead::ConnectionError / AuthenticationError / ProtocolError

bridgehead::adws::LdapModification

CMake विकल्प

एकीकरण

विकल्प A, CMake उपनिर्देशिका (कोई इंस्टॉल आवश्यक नहीं)```cmake

निर्भरताएँ

ज्ञात सीमाएँ

प्रोटोकॉल संदर्भ

विशेष धन्यवाद

लाइसेंस

`bridgehead::adws::AdwsClient`

`bridgehead::adws::AdwsClientAsync`

`DnValue` और DN बिल्डर हेल्पर्स

`bridgehead::ConnectionError` / `AuthenticationError` / `ProtocolError`

`bridgehead::adws::LdapModification`