Changeset 988 for vendor/current/librpc/rpc

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

Location:

vendor/current/librpc/rpc

Files:

• binding.c (modified) (26 diffs)
• binding_handle.c (modified) (12 diffs)
• dcerpc_error.c (modified) (2 diffs)
• dcerpc_util.c (modified) (8 diffs)
• rpc_common.h (modified) (10 diffs)

vendor/current/librpc/rpc/binding.c

@@ -8 +8 @@
    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005
    Copyright (C) Rafal Szczesniak 2006
+   Copyright (C) Stefan Metzmacher 2014
 
    This program is free software; you can redistribute it and/or modify
@@ -34 +35 @@
 
 #define MAX_PROTSEQ             10
+
+struct dcerpc_binding {
+        enum dcerpc_transport_t transport;
+        struct GUID object;
+        const char *object_string;
+        const char *host;
+        const char *target_hostname;
+        const char *target_principal;
+        const char *endpoint;
+        const char **options;
+        uint32_t flags;
+        uint32_t assoc_group_id;
+        char assoc_group_string[11]; /* 0x3456789a + '\0' */
+};
 
 static const struct {
@@ -74 +89 @@
 };
 
-static const struct {
+static const struct ncacn_option {
         const char *name;
         uint32_t flag;
@@ -84 +99 @@
         {"ntlm", DCERPC_AUTH_NTLM},
         {"krb5", DCERPC_AUTH_KRB5},
+        {"schannel", DCERPC_SCHANNEL},
         {"validate", DCERPC_DEBUG_VALIDATE_BOTH},
         {"print", DCERPC_DEBUG_PRINT_BOTH},
@@ -89 +105 @@
         {"bigendian", DCERPC_PUSH_BIGENDIAN},
         {"smb2", DCERPC_SMB2},
-        {"hdrsign", DCERPC_HEADER_SIGNING},
         {"ndr64", DCERPC_NDR64},
-        {"localaddress", DCERPC_LOCALADDRESS}
 };
+
+static const struct ncacn_option *ncacn_option_by_name(const char *name)
+{
+        size_t i;
+
+        for (i=0; i<ARRAY_SIZE(ncacn_options); i++) {
+                int ret;
+
+                ret = strcasecmp(ncacn_options[i].name, name);
+                if (ret != 0) {
+                        continue;
+                }
+
+                return &ncacn_options[i];
+        }
+
+        return NULL;
+}
 
 const char *epm_floor_string(TALLOC_CTX *mem_ctx, struct epm_floor *epm_floor)
@@ -106 +138 @@
                                 char *uuidstr;
 
-                                if (GUID_equal(&syntax.uuid, &ndr_transfer_syntax.uuid)) {
+                                if (GUID_equal(&syntax.uuid, &ndr_transfer_syntax_ndr.uuid)) {
                                         return "NDR";
                                 } 
 
-                                if (GUID_equal(&syntax.uuid, &ndr64_transfer_syntax.uuid)) {
+                                if (GUID_equal(&syntax.uuid, &ndr_transfer_syntax_ndr64.uuid)) {
                                         return "NDR64";
                                 } 
@@ -179 +211 @@
 {
         char *s = talloc_strdup(mem_ctx, "");
+        char *o = s;
         int i;
         const char *t_name = NULL;
+        bool option_section = false;
+        const char *target_hostname = NULL;
 
         if (b->transport != NCA_UNKNOWN) {
                 t_name = derpc_transport_string_by_transport(b->transport);
                 if (!t_name) {
-                        return NULL;
-                }
-        }
-
-        if (!GUID_all_zero(&b->object.uuid)) { 
-                s = talloc_asprintf(s, "%s@",
-                                    GUID_string(mem_ctx, &b->object.uuid));
+                        talloc_free(o);
+                        return NULL;
+                }
+        }
+
+        if (!GUID_all_zero(&b->object)) {
+                o = s;
+                s = talloc_asprintf_append_buffer(s, "%s@",
+                                    GUID_string(mem_ctx, &b->object));
+                if (s == NULL) {
+                        talloc_free(o);
+                        return NULL;
+                }
         }
 
         if (t_name != NULL) {
+                o = s;
                 s = talloc_asprintf_append_buffer(s, "%s:", t_name);
                 if (s == NULL) {
+                        talloc_free(o);
                         return NULL;
                 }
@@ -202 +245 @@
 
         if (b->host) {
+                o = s;
                 s = talloc_asprintf_append_buffer(s, "%s", b->host);
-        }
-
-        if (!b->endpoint && !b->options && !b->flags) {
+                if (s == NULL) {
+                        talloc_free(o);
+                        return NULL;
+                }
+        }
+
+        target_hostname = b->target_hostname;
+        if (target_hostname != NULL && b->host != NULL) {
+                if (strcmp(target_hostname, b->host) == 0) {
+                        target_hostname = NULL;
+                }
+        }
+
+        if (b->endpoint) {
+                option_section = true;
+        } else if (target_hostname) {
+                option_section = true;
+        } else if (b->target_principal) {
+                option_section = true;
+        } else if (b->assoc_group_id != 0) {
+                option_section = true;
+        } else if (b->options) {
+                option_section = true;
+        } else if (b->flags) {
+                option_section = true;
+        }
+
+        if (!option_section) {
                 return s;
         }
 
+        o = s;
         s = talloc_asprintf_append_buffer(s, "[");
+        if (s == NULL) {
+                talloc_free(o);
+                return NULL;
+        }
 
         if (b->endpoint) {
+                o = s;
                 s = talloc_asprintf_append_buffer(s, "%s", b->endpoint);
-        }
-
-        /* this is a *really* inefficent way of dealing with strings,
-           but this is rarely called and the strings are always short,
-           so I don't care */
+                if (s == NULL) {
+                        talloc_free(o);
+                        return NULL;
+                }
+        }
+
+        for (i=0;i<ARRAY_SIZE(ncacn_options);i++) {
+                if (!(b->flags & ncacn_options[i].flag)) {
+                        continue;
+                }
+
+                o = s;
+                s = talloc_asprintf_append_buffer(s, ",%s", ncacn_options[i].name);
+                if (s == NULL) {
+                        talloc_free(o);
+                        return NULL;
+                }
+        }
+
+        if (target_hostname) {
+                o = s;
+                s = talloc_asprintf_append_buffer(s, ",target_hostname=%s",
+                                                  b->target_hostname);
+                if (s == NULL) {
+                        talloc_free(o);
+                        return NULL;
+                }
+        }
+
+        if (b->target_principal) {
+                o = s;
+                s = talloc_asprintf_append_buffer(s, ",target_principal=%s",
+                                                  b->target_principal);
+                if (s == NULL) {
+                        talloc_free(o);
+                        return NULL;
+                }
+        }
+
+        if (b->assoc_group_id != 0) {
+                o = s;
+                s = talloc_asprintf_append_buffer(s, ",assoc_group_id=0x%08x",
+                                                  b->assoc_group_id);
+                if (s == NULL) {
+                        talloc_free(o);
+                        return NULL;
+                }
+        }
+
         for (i=0;b->options && b->options[i];i++) {
+                o = s;
                 s = talloc_asprintf_append_buffer(s, ",%s", b->options[i]);
-                if (!s) return NULL;
-        }
-
-        for (i=0;i<ARRAY_SIZE(ncacn_options);i++) {
-                if (b->flags & ncacn_options[i].flag) {
-                        if (ncacn_options[i].flag == DCERPC_LOCALADDRESS && b->localaddress) {
-                                s = talloc_asprintf_append_buffer(s, ",%s=%s", ncacn_options[i].name,
-                                                                  b->localaddress);
-                        } else {
-                                s = talloc_asprintf_append_buffer(s, ",%s", ncacn_options[i].name);
-                        }
-                        if (!s) return NULL;
-                }
-        }
-
+                if (s == NULL) {
+                        talloc_free(o);
+                        return NULL;
+                }
+        }
+
+        o = s;
         s = talloc_asprintf_append_buffer(s, "]");
+        if (s == NULL) {
+                talloc_free(o);
+                return NULL;
+        }
 
         return s;
@@ -243 +359 @@
   parse a binding string into a dcerpc_binding structure
 */
-_PUBLIC_ NTSTATUS dcerpc_parse_binding(TALLOC_CTX *mem_ctx, const char *s, struct dcerpc_binding **b_out)
-{
+_PUBLIC_ NTSTATUS dcerpc_parse_binding(TALLOC_CTX *mem_ctx, const char *_s, struct dcerpc_binding **b_out)
+{
+        char *_t;
         struct dcerpc_binding *b;
-        char *options;
+        char *s;
+        char *options = NULL;
         char *p;
-        int i, j, comma_count;
+        size_t i;
+        NTSTATUS status;
 
         b = talloc_zero(mem_ctx, struct dcerpc_binding);
@@ -255 +374 @@
         }
 
+        _t = talloc_strdup(b, _s);
+        if (_t == NULL) {
+                talloc_free(b);
+                return NT_STATUS_NO_MEMORY;
+        }
+
+        s = _t;
+
+        p = strchr(s, '[');
+        if (p) {
+                *p = '\0';
+                options = p + 1;
+                if (options[strlen(options)-1] != ']') {
+                        talloc_free(b);
+                        return NT_STATUS_INVALID_PARAMETER_MIX;
+                }
+                options[strlen(options)-1] = 0;
+        }
+
         p = strchr(s, '@');
 
         if (p && PTR_DIFF(p, s) == 36) { /* 36 is the length of a UUID */
-                NTSTATUS status;
-                DATA_BLOB blob = data_blob(s, 36);
-                status = GUID_from_data_blob(&blob, &b->object.uuid);
-
-                if (NT_STATUS_IS_ERR(status)) {
-                        DEBUG(0, ("Failed parsing UUID\n"));
+                *p = '\0';
+
+                status = dcerpc_binding_set_string_option(b, "object", s);
+                if (!NT_STATUS_IS_OK(status)) {
+                        talloc_free(b);
                         return status;
                 }
 
                 s = p + 1;
-        } else {
-                ZERO_STRUCT(b->object);
-        }
-
-        b->object.if_version = 0;
+        }
 
         p = strchr(s, ':');
@@ -278 +411 @@
         if (p == NULL) {
                 b->transport = NCA_UNKNOWN;
+        } else if (is_ipaddress_v6(s)) {
+                b->transport = NCA_UNKNOWN;
         } else {
-                char *type = talloc_strndup(mem_ctx, s, PTR_DIFF(p, s));
-                if (!type) {
+                *p = '\0';
+
+                status = dcerpc_binding_set_string_option(b, "transport", s);
+                if (!NT_STATUS_IS_OK(status)) {
+                        talloc_free(b);
+                        return status;
+                }
+
+                s = p + 1;
+        }
+
+        if (strlen(s) > 0) {
+                status = dcerpc_binding_set_string_option(b, "host", s);
+                if (!NT_STATUS_IS_OK(status)) {
+                        talloc_free(b);
+                        return status;
+                }
+
+                b->target_hostname = talloc_strdup(b, b->host);
+                if (b->target_hostname == NULL) {
+                        talloc_free(b);
                         return NT_STATUS_NO_MEMORY;
                 }
-
-                for (i=0;i<ARRAY_SIZE(transports);i++) {
-                        if (strcasecmp(type, transports[i].name) == 0) {
-                                b->transport = transports[i].transport;
-                                break;
+        }
+
+        for (i=0; options != NULL; i++) {
+                const char *name = options;
+                const char *value = NULL;
+
+                p = strchr(options, ',');
+                if (p != NULL) {
+                        *p = '\0';
+                        options = p+1;
+                } else {
+                        options = NULL;
+                }
+
+                p = strchr(name, '=');
+                if (p != NULL) {
+                        *p = '\0';
+                        value = p + 1;
+                }
+
+                if (value == NULL) {
+                        /*
+                         * If it's not a key=value pair
+                         * it might be a ncacn_option
+                         * or if it's the first option
+                         * it's the endpoint.
+                         */
+                        const struct ncacn_option *no = NULL;
+
+                        value = name;
+
+                        no = ncacn_option_by_name(name);
+                        if (no == NULL) {
+                                if (i > 0) {
+                                        /*
+                                         * we don't allow unknown options
+                                         */
+                                        return NT_STATUS_INVALID_PARAMETER_MIX;
+                                }
+
+                                /*
+                                 * This is the endpoint
+                                 */
+                                name = "endpoint";
+                                if (strlen(value) == 0) {
+                                        value = NULL;
+                                }
                         }
                 }
 
-                if (i==ARRAY_SIZE(transports)) {
-                        DEBUG(0,("Unknown dcerpc transport '%s'\n", type));
-                        return NT_STATUS_INVALID_PARAMETER;
-                }
-
-                talloc_free(type);
-
-                s = p+1;
-        }
-
-        p = strchr(s, '[');
-        if (p) {
-                b->host = talloc_strndup(b, s, PTR_DIFF(p, s));
-                options = talloc_strdup(mem_ctx, p+1);
-                if (options[strlen(options)-1] != ']') {
-                        return NT_STATUS_INVALID_PARAMETER;
-                }
-                options[strlen(options)-1] = 0;
+                status = dcerpc_binding_set_string_option(b, name, value);
+                if (!NT_STATUS_IS_OK(status)) {
+                        talloc_free(b);
+                        return status;
+                }
+        }
+
+        talloc_free(_t);
+        *b_out = b;
+        return NT_STATUS_OK;
+}
+
+_PUBLIC_ struct GUID dcerpc_binding_get_object(const struct dcerpc_binding *b)
+{
+        return b->object;
+}
+
+_PUBLIC_ NTSTATUS dcerpc_binding_set_object(struct dcerpc_binding *b,
+                                            struct GUID object)
+{
+        char *tmp = discard_const_p(char, b->object_string);
+
+        if (GUID_all_zero(&object)) {
+                talloc_free(tmp);
+                b->object_string = NULL;
+                ZERO_STRUCT(b->object);
+                return NT_STATUS_OK;
+        }
+
+        b->object_string = GUID_string(b, &object);
+        if (b->object_string == NULL) {
+                b->object_string = tmp;
+                return NT_STATUS_NO_MEMORY;
+        }
+        talloc_free(tmp);
+
+        b->object = object;
+        return NT_STATUS_OK;
+}
+
+_PUBLIC_ enum dcerpc_transport_t dcerpc_binding_get_transport(const struct dcerpc_binding *b)
+{
+        return b->transport;
+}
+
+_PUBLIC_ NTSTATUS dcerpc_binding_set_transport(struct dcerpc_binding *b,
+                                               enum dcerpc_transport_t transport)
+{
+        NTSTATUS status;
+
+        /*
+         * TODO: we may want to check the transport value is
+         * wellknown.
+         */
+        if (b->transport == transport) {
+                return NT_STATUS_OK;
+        }
+
+        /*
+         * This implicitly resets the endpoint
+         * as the endpoint is transport specific.
+         *
+         * It also resets the assoc group as it's
+         * also endpoint specific.
+         *
+         * TODO: in future we may reset more options
+         * here.
+         */
+        status = dcerpc_binding_set_string_option(b, "endpoint", NULL);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+
+        b->assoc_group_id = 0;
+
+        b->transport = transport;
+        return NT_STATUS_OK;
+}
+
+_PUBLIC_ void dcerpc_binding_get_auth_info(const struct dcerpc_binding *b,
+                                           enum dcerpc_AuthType *_auth_type,
+                                           enum dcerpc_AuthLevel *_auth_level)
+{
+        enum dcerpc_AuthType auth_type;
+        enum dcerpc_AuthLevel auth_level;
+
+        if (b->flags & DCERPC_AUTH_SPNEGO) {
+                auth_type = DCERPC_AUTH_TYPE_SPNEGO;
+        } else if (b->flags & DCERPC_AUTH_KRB5) {
+                auth_type = DCERPC_AUTH_TYPE_KRB5;
+        } else if (b->flags & DCERPC_SCHANNEL) {
+                auth_type = DCERPC_AUTH_TYPE_SCHANNEL;
+        } else if (b->flags & DCERPC_AUTH_NTLM) {
+                auth_type = DCERPC_AUTH_TYPE_NTLMSSP;
         } else {
-                b->host = talloc_strdup(b, s);
-                options = NULL;
-        }
-        if (!b->host) {
+                auth_type = DCERPC_AUTH_TYPE_NONE;
+        }
+
+        if (b->flags & DCERPC_SEAL) {
+                auth_level = DCERPC_AUTH_LEVEL_PRIVACY;
+        } else if (b->flags & DCERPC_SIGN) {
+                auth_level = DCERPC_AUTH_LEVEL_INTEGRITY;
+        } else if (b->flags & DCERPC_CONNECT) {
+                auth_level = DCERPC_AUTH_LEVEL_CONNECT;
+        } else if (auth_type != DCERPC_AUTH_TYPE_NONE) {
+                auth_level = DCERPC_AUTH_LEVEL_INTEGRITY;
+        } else {
+                auth_level = DCERPC_AUTH_LEVEL_NONE;
+        }
+
+        if (_auth_type != NULL) {
+                *_auth_type = auth_type;
+        }
+
+        if (_auth_level != NULL) {
+                *_auth_level = auth_level;
+        }
+}
+
+_PUBLIC_ uint32_t dcerpc_binding_get_assoc_group_id(const struct dcerpc_binding *b)
+{
+        return b->assoc_group_id;
+}
+
+_PUBLIC_ NTSTATUS dcerpc_binding_set_assoc_group_id(struct dcerpc_binding *b,
+                                                    uint32_t assoc_group_id)
+{
+        b->assoc_group_id = assoc_group_id;
+        return NT_STATUS_OK;
+}
+
+_PUBLIC_ struct ndr_syntax_id dcerpc_binding_get_abstract_syntax(const struct dcerpc_binding *b)
+{
+        const char *s = dcerpc_binding_get_string_option(b, "abstract_syntax");
+        bool ok;
+        struct ndr_syntax_id id;
+
+        if (s == NULL) {
+                return ndr_syntax_id_null;
+        }
+
+        ok = ndr_syntax_id_from_string(s, &id);
+        if (!ok) {
+                return ndr_syntax_id_null;
+        }
+
+        return id;
+}
+
+_PUBLIC_ NTSTATUS dcerpc_binding_set_abstract_syntax(struct dcerpc_binding *b,
+                                                     const struct ndr_syntax_id *syntax)
+{
+        NTSTATUS status;
+        char *s = NULL;
+
+        if (syntax == NULL) {
+                status = dcerpc_binding_set_string_option(b, "abstract_syntax", NULL);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return status;
+                }
+
+                return NT_STATUS_OK;
+        }
+
+        if (ndr_syntax_id_equal(&ndr_syntax_id_null, syntax)) {
+                status = dcerpc_binding_set_string_option(b, "abstract_syntax", NULL);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return status;
+                }
+
+                return NT_STATUS_OK;
+        }
+
+        s = ndr_syntax_id_to_string(b, syntax);
+        if (s == NULL) {
                 return NT_STATUS_NO_MEMORY;
         }
 
-        b->target_hostname = b->host;
-
-        b->options = NULL;
-        b->flags = 0;
-        b->assoc_group_id = 0;
-        b->endpoint = NULL;
-        b->localaddress = NULL;
-
-        if (!options) {
-                *b_out = b;
-                return NT_STATUS_OK;
-        }
-
-        comma_count = count_chars(options, ',');
-
-        b->options = talloc_array(b, const char *, comma_count+2);
-        if (!b->options) {
+        status = dcerpc_binding_set_string_option(b, "abstract_syntax", s);
+        TALLOC_FREE(s);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+
+        return NT_STATUS_OK;
+}
+
+_PUBLIC_ const char *dcerpc_binding_get_string_option(const struct dcerpc_binding *b,
+                                                      const char *name)
+{
+        struct {
+                const char *name;
+                const char *value;
+#define _SPECIAL(x) { .name = #x, .value = b->x, }
+        } specials[] = {
+                { .name = "object", .value = b->object_string, },
+                _SPECIAL(host),
+                _SPECIAL(endpoint),
+                _SPECIAL(target_hostname),
+                _SPECIAL(target_principal),
+#undef _SPECIAL
+        };
+        const struct ncacn_option *no = NULL;
+        size_t name_len = strlen(name);
+        size_t i;
+        int ret;
+
+        ret = strcmp(name, "transport");
+        if (ret == 0) {
+                return derpc_transport_string_by_transport(b->transport);
+        }
+
+        ret = strcmp(name, "assoc_group_id");
+        if (ret == 0) {
+                char *tmp = discard_const_p(char, b->assoc_group_string);
+
+                if (b->assoc_group_id == 0) {
+                        return NULL;
+                }
+
+                snprintf(tmp, sizeof(b->assoc_group_string),
+                         "0x%08x", b->assoc_group_id);
+                return (const char *)b->assoc_group_string;
+        }
+
+        for (i=0; i < ARRAY_SIZE(specials); i++) {
+                ret = strcmp(specials[i].name, name);
+                if (ret != 0) {
+                        continue;
+                }
+
+                return specials[i].value;
+        }
+
+        no = ncacn_option_by_name(name);
+        if (no != NULL) {
+                if (b->flags & no->flag) {
+                        return no->name;
+                }
+
+                return NULL;
+        }
+
+        if (b->options == NULL) {
+                return NULL;
+        }
+
+        for (i=0; b->options[i]; i++) {
+                const char *o = b->options[i];
+                const char *vs = NULL;
+
+                ret = strncmp(name, o, name_len);
+                if (ret != 0) {
+                        continue;
+                }
+
+                if (o[name_len] != '=') {
+                        continue;
+                }
+
+                vs = &o[name_len + 1];
+
+                return vs;
+        }
+
+        return NULL;
+}
+
+_PUBLIC_ char *dcerpc_binding_copy_string_option(TALLOC_CTX *mem_ctx,
+                                                 const struct dcerpc_binding *b,
+                                                 const char *name)
+{
+        const char *c = dcerpc_binding_get_string_option(b, name);
+        char *v;
+
+        if (c == NULL) {
+                errno = ENOENT;
+                return NULL;
+        }
+
+        v = talloc_strdup(mem_ctx, c);
+        if (v == NULL) {
+                errno = ENOMEM;
+                return NULL;
+        }
+
+        return v;
+}
+
+_PUBLIC_ NTSTATUS dcerpc_binding_set_string_option(struct dcerpc_binding *b,
+                                                   const char *name,
+                                                   const char *value)
+{
+        struct {
+                const char *name;
+                const char **ptr;
+#define _SPECIAL(x) { .name = #x, .ptr = &b->x, }
+        } specials[] = {
+                _SPECIAL(host),
+                _SPECIAL(endpoint),
+                _SPECIAL(target_hostname),
+                _SPECIAL(target_principal),
+#undef _SPECIAL
+        };
+        const struct ncacn_option *no = NULL;
+        size_t name_len = strlen(name);
+        const char *opt = NULL;
+        char *tmp;
+        size_t i;
+        int ret;
+
+        /*
+         * Note: value == NULL, means delete it.
+         * value != NULL means add or reset.
+         */
+
+        ret = strcmp(name, "transport");
+        if (ret == 0) {
+                enum dcerpc_transport_t t = dcerpc_transport_by_name(value);
+
+                if (t == NCA_UNKNOWN && value != NULL) {
+                        return NT_STATUS_INVALID_PARAMETER_MIX;
+                }
+
+                return dcerpc_binding_set_transport(b, t);
+        }
+
+        ret = strcmp(name, "object");
+        if (ret == 0) {
+                NTSTATUS status;
+                struct GUID uuid = GUID_zero();
+
+                if (value != NULL) {
+                        DATA_BLOB blob;
+                        blob = data_blob_string_const(value);
+                        if (blob.length != 36) {
+                                return NT_STATUS_INVALID_PARAMETER_MIX;
+                        }
+
+                        status = GUID_from_data_blob(&blob, &uuid);
+                        if (!NT_STATUS_IS_OK(status)) {
+                                return status;
+                        }
+                }
+
+                return dcerpc_binding_set_object(b, uuid);
+        }
+
+        ret = strcmp(name, "assoc_group_id");
+        if (ret == 0) {
+                uint32_t assoc_group_id = 0;
+
+                if (value != NULL) {
+                        char c;
+
+                        ret = sscanf(value, "0x%08x%c", &assoc_group_id, &c);
+                        if (ret != 1) {
+                                return NT_STATUS_INVALID_PARAMETER_MIX;
+                        }
+                }
+
+                return dcerpc_binding_set_assoc_group_id(b, assoc_group_id);
+        }
+
+        for (i=0; i < ARRAY_SIZE(specials); i++) {
+                ret = strcmp(specials[i].name, name);
+                if (ret != 0) {
+                        continue;
+                }
+
+                tmp = discard_const_p(char, *specials[i].ptr);
+
+                if (value == NULL) {
+                        talloc_free(tmp);
+                        *specials[i].ptr = NULL;
+                        return NT_STATUS_OK;
+                }
+
+                if (value[0] == '\0') {
+                        return NT_STATUS_INVALID_PARAMETER_MIX;
+                }
+
+                *specials[i].ptr = talloc_strdup(b, value);
+                if (*specials[i].ptr == NULL) {
+                        *specials[i].ptr = tmp;
+                        return NT_STATUS_NO_MEMORY;
+                }
+                talloc_free(tmp);
+
+                return NT_STATUS_OK;
+        }
+
+        no = ncacn_option_by_name(name);
+        if (no != NULL) {
+                if (value == NULL) {
+                        b->flags &= ~no->flag;
+                        return NT_STATUS_OK;
+                }
+
+                ret = strcasecmp(no->name, value);
+                if (ret != 0) {
+                        return NT_STATUS_INVALID_PARAMETER_MIX;
+                }
+
+                b->flags |= no->flag;
+                return NT_STATUS_OK;
+        }
+
+        for (i=0; b->options && b->options[i]; i++) {
+                const char *o = b->options[i];
+
+                ret = strncmp(name, o, name_len);
+                if (ret != 0) {
+                        continue;
+                }
+
+                if (o[name_len] != '=') {
+                        continue;
+                }
+
+                opt = o;
+                break;
+        }
+
+        if (opt == NULL) {
+                const char **n;
+
+                if (value == NULL) {
+                        return NT_STATUS_OK;
+                }
+
+                n = talloc_realloc(b, b->options, const char *, i + 2);
+                if (n == NULL) {
+                        return NT_STATUS_NO_MEMORY;
+                }
+                n[i] = NULL;
+                n[i + 1] = NULL;
+                b->options = n;
+        }
+
+        tmp = discard_const_p(char, opt);
+
+        if (value == NULL) {
+                for (;b->options[i];i++) {
+                        b->options[i] = b->options[i+1];
+                }
+                talloc_free(tmp);
+                return NT_STATUS_OK;
+        }
+
+        b->options[i] = talloc_asprintf(b->options, "%s=%s",
+                                        name, value);
+        if (b->options[i] == NULL) {
+                b->options[i] = tmp;
                 return NT_STATUS_NO_MEMORY;
         }
 
-        for (i=0; (p = strchr(options, ',')); i++) {
-                b->options[i] = talloc_strndup(b, options, PTR_DIFF(p, options));
-                if (!b->options[i]) {
-                        return NT_STATUS_NO_MEMORY;
-                }
-                options = p+1;
-        }
-        b->options[i] = options;
-        b->options[i+1] = NULL;
-
-        /* some options are pre-parsed for convenience */
-        for (i=0;b->options[i];i++) {
-                for (j=0;j<ARRAY_SIZE(ncacn_options);j++) {
-                        size_t opt_len = strlen(ncacn_options[j].name);
-                        if (strncasecmp(ncacn_options[j].name, b->options[i], opt_len) == 0) {
-                                int k;
-                                char c = b->options[i][opt_len];
-
-                                if (ncacn_options[j].flag == DCERPC_LOCALADDRESS && c == '=') {
-                                        b->localaddress = talloc_strdup(b, &b->options[i][opt_len+1]);
-                                } else if (c != 0) {
-                                        continue;
-                                }
-
-                                b->flags |= ncacn_options[j].flag;
-                                for (k=i;b->options[k];k++) {
-                                        b->options[k] = b->options[k+1];
-                                }
-                                i--;
-                                break;
-                        }
-                }
-        }
-
-        if (b->options[0]) {
-                /* Endpoint is first option */
-                b->endpoint = b->options[0];
-                if (strlen(b->endpoint) == 0) b->endpoint = NULL;
-
-                for (i=0;b->options[i];i++) {
-                        b->options[i] = b->options[i+1];
-                }
-        }
-
-        if (b->options[0] == NULL)
-                b->options = NULL;
-
-        *b_out = b;
+        return NT_STATUS_OK;
+}
+
+_PUBLIC_ uint32_t dcerpc_binding_get_flags(const struct dcerpc_binding *b)
+{
+        return b->flags;
+}
+
+_PUBLIC_ NTSTATUS dcerpc_binding_set_flags(struct dcerpc_binding *b,
+                                           uint32_t additional,
+                                           uint32_t clear)
+{
+        /*
+         * TODO: in future we may want to reject invalid combinations
+         */
+        b->flags &= ~clear;
+        b->flags |= additional;
+
         return NT_STATUS_OK;
 }
@@ -425 +1002 @@
 {
         DATA_BLOB blob;
-        struct ndr_push *ndr = ndr_push_init_ctx(mem_ctx);
+        enum ndr_err_code ndr_err;
+        struct ndr_push *ndr;
+
+        ndr = ndr_push_init_ctx(mem_ctx);
+        if (ndr == NULL) {
+                return data_blob_null;
+        }
 
         ndr->flags |= LIBNDR_FLAG_NOALIGN;
 
-        ndr_push_GUID(ndr, NDR_SCALARS | NDR_BUFFERS, &syntax->uuid);
-        ndr_push_uint16(ndr, NDR_SCALARS, syntax->if_version);
+        ndr_err = ndr_push_GUID(ndr, NDR_SCALARS | NDR_BUFFERS, &syntax->uuid);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                return data_blob_null;
+        }
+        ndr_err = ndr_push_uint16(ndr, NDR_SCALARS, syntax->if_version);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                return data_blob_null;
+        }
 
         blob = ndr_push_blob(ndr);
@@ -464 +1053 @@
 }
 
-const char *dcerpc_floor_get_rhs_data(TALLOC_CTX *mem_ctx, struct epm_floor *epm_floor)
+char *dcerpc_floor_get_rhs_data(TALLOC_CTX *mem_ctx, struct epm_floor *epm_floor)
 {
         switch (epm_floor->lhs.protocol) {
@@ -531 +1120 @@
                                           const char *data)
 {
+        if (data == NULL) {
+                data = "";
+        }
+
         switch (epm_floor->lhs.protocol) {
         case EPM_PROTOCOL_TCP:
@@ -545 +1138 @@
 
         case EPM_PROTOCOL_IP:
+                if (!is_ipaddress_v4(data)) {
+                        data = "0.0.0.0";
+                }
                 epm_floor->rhs.ip.ipaddr = talloc_strdup(mem_ctx, data);
                 NT_STATUS_HAVE_NO_MEMORY(epm_floor->rhs.ip.ipaddr);
@@ -631 +1227 @@
                 }
 
-                for (j = 0; j < transports[i].num_protocols; j++) {
+                for (j = 0; j < transports[i].num_protocols && j < MAX_PROTSEQ; j++) {
                         if (transports[i].protseq[j] != tower->floors[j+2].lhs.protocol) {
                                 break;
@@ -658 +1254 @@
 }
 
+_PUBLIC_ enum dcerpc_transport_t dcerpc_transport_by_name(const char *name)
+{
+        size_t i;
+
+        if (name == NULL) {
+                return NCA_UNKNOWN;
+        }
+
+        for (i=0; i<ARRAY_SIZE(transports);i++) {
+                if (strcasecmp(name, transports[i].name) == 0) {
+                        return transports[i].transport;
+                }
+        }
+
+        return NCA_UNKNOWN;
+}
+
 _PUBLIC_ NTSTATUS dcerpc_binding_from_tower(TALLOC_CTX *mem_ctx,
                                             struct epm_tower *tower,
@@ -663 +1276 @@
 {
         NTSTATUS status;
-        struct dcerpc_binding *binding;
+        struct dcerpc_binding *b;
+        enum dcerpc_transport_t transport;
+        struct ndr_syntax_id abstract_syntax;
+        char *endpoint = NULL;
+        char *host = NULL;
 
         /*
@@ -674 +1291 @@
         }
 
-        binding = talloc_zero(mem_ctx, struct dcerpc_binding);
-        NT_STATUS_HAVE_NO_MEMORY(binding);
-
-        ZERO_STRUCT(binding->object);
-        binding->options = NULL;
-        binding->host = NULL;
-        binding->target_hostname = NULL;
-        binding->flags = 0;
-        binding->assoc_group_id = 0;
-
-        binding->transport = dcerpc_transport_by_tower(tower);
-
-        if (binding->transport == (unsigned int)-1) {
+        status = dcerpc_parse_binding(mem_ctx, "", &b);
+        if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
+
+        transport = dcerpc_transport_by_tower(tower);
+        if (transport == NCA_UNKNOWN) {
+                talloc_free(b);
                 return NT_STATUS_NOT_SUPPORTED;
         }
 
-        /* Set object uuid */
-        status = dcerpc_floor_get_lhs_data(&tower->floors[0], &binding->object);
-
+        status = dcerpc_binding_set_transport(b, transport);
         if (!NT_STATUS_IS_OK(status)) {
-                DEBUG(1, ("Error pulling object uuid and version: %s", nt_errstr(status)));
+                talloc_free(b);
                 return status;
         }
 
+        /* Set abstract syntax */
+        status = dcerpc_floor_get_lhs_data(&tower->floors[0], &abstract_syntax);
+        if (!NT_STATUS_IS_OK(status)) {
+                talloc_free(b);
+                return status;
+        }
+
+        status = dcerpc_binding_set_abstract_syntax(b, &abstract_syntax);
+        if (!NT_STATUS_IS_OK(status)) {
+                talloc_free(b);
+                return status;
+        }
+
         /* Ignore floor 1, it contains the NDR version info */
 
-        binding->options = NULL;
-
         /* Set endpoint */
+        errno = 0;
         if (tower->num_floors >= 4) {
-                binding->endpoint = dcerpc_floor_get_rhs_data(binding, &tower->floors[3]);
-        } else {
-                binding->endpoint = NULL;
-        }
+                endpoint = dcerpc_floor_get_rhs_data(b, &tower->floors[3]);
+        }
+        if (errno != 0) {
+                int saved_errno = errno;
+                talloc_free(b);
+                return map_nt_error_from_unix_common(saved_errno);
+        }
+
+        status = dcerpc_binding_set_string_option(b, "endpoint", endpoint);
+        if (!NT_STATUS_IS_OK(status)) {
+                talloc_free(b);
+                return status;
+        }
+        TALLOC_FREE(endpoint);
 
         /* Set network address */
+        errno = 0;
         if (tower->num_floors >= 5) {
-                binding->host = dcerpc_floor_get_rhs_data(binding, &tower->floors[4]);
-                NT_STATUS_HAVE_NO_MEMORY(binding->host);
-                binding->target_hostname = binding->host;
-        }
-        *b_out = binding;
+                host = dcerpc_floor_get_rhs_data(b, &tower->floors[4]);
+        }
+        if (errno != 0) {
+                int saved_errno = errno;
+                talloc_free(b);
+                return map_nt_error_from_unix_common(saved_errno);
+        }
+
+        status = dcerpc_binding_set_string_option(b, "host", host);
+        if (!NT_STATUS_IS_OK(status)) {
+                talloc_free(b);
+                return status;
+        }
+        status = dcerpc_binding_set_string_option(b, "target_hostname", host);
+        if (!NT_STATUS_IS_OK(status)) {
+                talloc_free(b);
+                return status;
+        }
+        TALLOC_FREE(host);
+
+        *b_out = b;
         return NT_STATUS_OK;
 }
@@ -735 +1384 @@
         n->assoc_group_id = b->assoc_group_id;
 
+        if (b->object_string != NULL) {
+                n->object_string = talloc_strdup(n, b->object_string);
+                if (n->object_string == NULL) {
+                        talloc_free(n);
+                        return NULL;
+                }
+        }
         if (b->host != NULL) {
                 n->host = talloc_strdup(n, b->host);
@@ -754 +1410 @@
                 n->target_principal = talloc_strdup(n, b->target_principal);
                 if (n->target_principal == NULL) {
-                        talloc_free(n);
-                        return NULL;
-                }
-        }
-
-        if (b->localaddress != NULL) {
-                n->localaddress = talloc_strdup(n, b->localaddress);
-                if (n->localaddress == NULL) {
                         talloc_free(n);
                         return NULL;
@@ -805 +1453 @@
         const enum epm_protocol *protseq = NULL;
         int num_protocols = -1, i;
+        struct ndr_syntax_id abstract_syntax;
         NTSTATUS status;
 
@@ -827 +1476 @@
         tower->floors[0].lhs.protocol = EPM_PROTOCOL_UUID;
 
-        tower->floors[0].lhs.lhs_data = dcerpc_floor_pack_lhs_data(tower->floors, &binding->object);
+        abstract_syntax = dcerpc_binding_get_abstract_syntax(binding);
+        tower->floors[0].lhs.lhs_data = dcerpc_floor_pack_lhs_data(tower->floors,
+                                                                   &abstract_syntax);
 
         if (!dcerpc_floor_pack_rhs_if_version_data(
-                    tower->floors, &binding->object,
+                    tower->floors, &abstract_syntax,
                     &tower->floors[0].rhs.uuid.unknown)) {
                 return NT_STATUS_NO_MEMORY;
@@ -839 +1490 @@
 
         tower->floors[1].lhs.lhs_data = dcerpc_floor_pack_lhs_data(tower->floors, 
-                                                                &ndr_transfer_syntax);
+                                                                &ndr_transfer_syntax_ndr);
 
         tower->floors[1].rhs.uuid.unknown = data_blob_talloc_zero(tower->floors, 2);
@@ -846 +1497 @@
         for (i = 0; i < num_protocols; i++) {
                 tower->floors[2 + i].lhs.protocol = protseq[i];
-                tower->floors[2 + i].lhs.lhs_data = data_blob_talloc(tower->floors, NULL, 0);
+                tower->floors[2 + i].lhs.lhs_data = data_blob_null;
                 ZERO_STRUCT(tower->floors[2 + i].rhs);
-                dcerpc_floor_set_rhs_data(tower->floors, &tower->floors[2 + i], "");
+                status = dcerpc_floor_set_rhs_data(tower->floors,
+                                                   &tower->floors[2 + i],
+                                                   NULL);
+                if (!NT_STATUS_IS_OK(status)) {
+                        return status;
+                }
         }
 
         /* The 4th floor contains the endpoint */
         if (num_protocols >= 2 && binding->endpoint) {
-                status = dcerpc_floor_set_rhs_data(tower->floors, &tower->floors[3], binding->endpoint);
-                if (NT_STATUS_IS_ERR(status)) {
+                status = dcerpc_floor_set_rhs_data(tower->floors,
+                                                   &tower->floors[3],
+                                                   binding->endpoint);
+                if (!NT_STATUS_IS_OK(status)) {
                         return status;
                 }
@@ -861 +1519 @@
         /* The 5th contains the network address */
         if (num_protocols >= 3 && binding->host) {
-                if (is_ipaddress(binding->host) ||
-                    (binding->host[0] == '\\' && binding->host[1] == '\\')) {
-                        status = dcerpc_floor_set_rhs_data(tower->floors, &tower->floors[4], 
-                                                           binding->host);
-                } else {
-                        /* note that we don't attempt to resolve the
-                           name here - when we get a hostname here we
-                           are in the client code, and want to put in
-                           a wildcard all-zeros IP for the server to
-                           fill in */
-                        status = dcerpc_floor_set_rhs_data(tower->floors, &tower->floors[4], 
-                                                           "0.0.0.0");
-                }
-                if (NT_STATUS_IS_ERR(status)) {
+                status = dcerpc_floor_set_rhs_data(tower->floors,
+                                                   &tower->floors[4],
+                                                   binding->host);
+                if (!NT_STATUS_IS_OK(status)) {
                         return status;
                 }

vendor/current/librpc/rpc/binding_handle.c

@@ -99 +99 @@
 }
 
+void dcerpc_binding_handle_auth_info(struct dcerpc_binding_handle *h,
+                                     enum dcerpc_AuthType *auth_type,
+                                     enum dcerpc_AuthLevel *auth_level)
+{
+        enum dcerpc_AuthType _auth_type;
+        enum dcerpc_AuthLevel _auth_level;
+
+        if (auth_type == NULL) {
+                auth_type = &_auth_type;
+        }
+
+        if (auth_level == NULL) {
+                auth_level = &_auth_level;
+        }
+
+        *auth_type = DCERPC_AUTH_TYPE_NONE;
+        *auth_level = DCERPC_AUTH_LEVEL_NONE;
+
+        if (h->ops->auth_info == NULL) {
+                return;
+        }
+
+        h->ops->auth_info(h, auth_type, auth_level);
+}
+
 struct dcerpc_binding_handle_raw_call_state {
         const struct dcerpc_binding_handle_ops *ops;
@@ -156 +181 @@
                                           &state->out_flags);
         TALLOC_FREE(subreq);
-        if (!NT_STATUS_IS_OK(error)) {
-                tevent_req_nterror(req, error);
+        if (tevent_req_nterror(req, error)) {
                 return;
         }
@@ -201 +225 @@
         struct tevent_context *ev;
         struct tevent_req *subreq;
-        NTSTATUS status;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
 
         /*
@@ -210 +234 @@
                 ev = h->sync_ev;
         } else {
-                ev = tevent_context_init(frame);
+                ev = samba_tevent_context_init(frame);
         }
         if (ev == NULL) {
-                talloc_free(frame);
-                return NT_STATUS_NO_MEMORY;
+                goto fail;
         }
 
@@ -223 +246 @@
                                                      in_length);
         if (subreq == NULL) {
-                talloc_free(frame);
-                return NT_STATUS_NO_MEMORY;
-        }
-
-        if (!tevent_req_poll(subreq, ev)) {
-                status = map_nt_error_from_unix(errno);
-                talloc_free(frame);
-                return status;
+                goto fail;
+        }
+
+        if (!tevent_req_poll_ntstatus(subreq, ev, &status)) {
+                goto fail;
         }
 
@@ -238 +258 @@
                                                      out_length,
                                                      out_flags);
-        if (!NT_STATUS_IS_OK(status)) {
-                talloc_free(frame);
-                return status;
-        }
-
+fail:
         TALLOC_FREE(frame);
-        return NT_STATUS_OK;
+        return status;
 }
 
@@ -289 +305 @@
         error = state->ops->disconnect_recv(subreq);
         TALLOC_FREE(subreq);
-        if (!NT_STATUS_IS_OK(error)) {
-                tevent_req_nterror(req, error);
+        if (tevent_req_nterror(req, error)) {
                 return;
         }
@@ -442 +457 @@
                                                     &out_flags);
         TALLOC_FREE(subreq);
-        if (!NT_STATUS_IS_OK(error)) {
-                tevent_req_nterror(req, error);
+        if (tevent_req_nterror(req, error)) {
                 return;
         }
@@ -495 +509 @@
 NTSTATUS dcerpc_binding_handle_call_recv(struct tevent_req *req)
 {
-        NTSTATUS error;
-
-        if (tevent_req_is_nterror(req, &error)) {
-                tevent_req_received(req);
-                return error;
-        }
-
-        tevent_req_received(req);
-        return NT_STATUS_OK;
+        return tevent_req_simple_recv_ntstatus(req);
 }
 
@@ -516 +522 @@
         struct tevent_context *ev;
         struct tevent_req *subreq;
-        NTSTATUS status;
+        NTSTATUS status = NT_STATUS_NO_MEMORY;
 
         /*
@@ -525 +531 @@
                 ev = h->sync_ev;
         } else {
-                ev = tevent_context_init(frame);
+                ev = samba_tevent_context_init(frame);
         }
         if (ev == NULL) {
-                talloc_free(frame);
-                return NT_STATUS_NO_MEMORY;
+                goto fail;
         }
 
@@ -536 +541 @@
                                                  opnum, r_mem, r_ptr);
         if (subreq == NULL) {
-                talloc_free(frame);
-                return NT_STATUS_NO_MEMORY;
-        }
-
-        if (!tevent_req_poll(subreq, ev)) {
-                status = map_nt_error_from_unix(errno);
-                talloc_free(frame);
-                return status;
+                goto fail;
+        }
+
+        if (!tevent_req_poll_ntstatus(subreq, ev, &status)) {
+                goto fail;
         }
 
         status = dcerpc_binding_handle_call_recv(subreq);
-        if (!NT_STATUS_IS_OK(status)) {
-                talloc_free(frame);
-                return status;
-        }
-
+fail:
         TALLOC_FREE(frame);
-        return NT_STATUS_OK;
-}
+        return status;
+}

vendor/current/librpc/rpc/dcerpc_error.c

@@ -27 +27 @@
         const char *errstr;
         uint32_t faultcode;
+        NTSTATUS nt_status;
 };
 
 static const struct dcerpc_fault_table dcerpc_faults[] =
 {
-#define _FAULT_STR(x) { #x , x }
-        _FAULT_STR(DCERPC_NCA_S_COMM_FAILURE),
-        _FAULT_STR(DCERPC_NCA_S_OP_RNG_ERROR),
-        _FAULT_STR(DCERPC_NCA_S_UNKNOWN_IF),
-        _FAULT_STR(DCERPC_NCA_S_WRONG_BOOT_TIME),
-        _FAULT_STR(DCERPC_NCA_S_YOU_CRASHED),
-        _FAULT_STR(DCERPC_NCA_S_PROTO_ERROR),
-        _FAULT_STR(DCERPC_NCA_S_OUT_ARGS_TOO_BIG),
-        _FAULT_STR(DCERPC_NCA_S_SERVER_TOO_BUSY),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_STRING_TOO_LARGE),
-        _FAULT_STR(DCERPC_NCA_S_UNSUPPORTED_TYPE),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_INT_DIV_BY_ZERO),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_ADDR_ERROR),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_FP_DIV_BY_ZERO),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_FP_UNDERFLOW),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_FP_OVERRFLOW),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_INVALID_TAG),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_INVALID_BOUND),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_RPC_VERSION_MISMATCH),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_UNSPEC_REJECT),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_BAD_ACTID),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_WHO_ARE_YOU_FAILED),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_MANAGER_NOT_ENTERED),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_CANCEL),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_ILL_INST),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_FP_ERROR),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_INT_OVERFLOW),
-        _FAULT_STR(DCERPC_NCA_S_UNUSED_1C000011),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_UNSPEC),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_REMOTE_COMM_FAILURE),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_PIPE_EMPTY),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_PIPE_CLOSED),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_PIPE_ORDER),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_PIPE_DISCIPLINE),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_PIPE_COMM_ERROR),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_PIPE_MEMORY),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_CONTEXT_MISMATCH),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY),
-        _FAULT_STR(DCERPC_NCA_S_INVALID_PRES_CONTEXT_ID),
-        _FAULT_STR(DCERPC_NCA_S_UNSUPPORTED_AUTHN_LEVEL),
-        _FAULT_STR(DCERPC_NCA_S_UNUSED_1C00001E),
-        _FAULT_STR(DCERPC_NCA_S_INVALID_CHECKSUM),
-        _FAULT_STR(DCERPC_NCA_S_INVALID_CRC),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_USER_DEFINED),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_TX_OPEN_FAILED),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_CODESET_CONV_ERROR),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_OBJECT_NOT_FOUND),
-        _FAULT_STR(DCERPC_NCA_S_FAULT_NO_CLIENT_STUB),
+#define _FAULT_STR(x, s) { .errstr = #x , .faultcode = x, .nt_status = s }
+#define _FAULT_STR_NO_NT_MAPPING(x) _FAULT_STR(x, NT_STATUS_RPC_NOT_RPC_ERROR)
+        _FAULT_STR(DCERPC_NCA_S_COMM_FAILURE, NT_STATUS_RPC_COMM_FAILURE),
+        _FAULT_STR(DCERPC_NCA_S_OP_RNG_ERROR, NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE),
+        _FAULT_STR(DCERPC_NCA_S_UNKNOWN_IF, NT_STATUS_RPC_UNKNOWN_IF),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_WRONG_BOOT_TIME),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_YOU_CRASHED),
+        _FAULT_STR(DCERPC_NCA_S_PROTO_ERROR, NT_STATUS_RPC_PROTOCOL_ERROR),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_OUT_ARGS_TOO_BIG),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_SERVER_TOO_BUSY),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_STRING_TOO_LARGE),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_UNSUPPORTED_TYPE),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_ADDR_ERROR),
+        _FAULT_STR(DCERPC_NCA_S_FAULT_FP_DIV_BY_ZERO, NT_STATUS_RPC_FP_DIV_ZERO),
+        _FAULT_STR(DCERPC_NCA_S_FAULT_FP_UNDERFLOW, NT_STATUS_RPC_FP_UNDERFLOW),
+        _FAULT_STR(DCERPC_NCA_S_FAULT_FP_OVERRFLOW, NT_STATUS_RPC_FP_OVERFLOW),
+        _FAULT_STR(DCERPC_NCA_S_FAULT_INT_DIV_BY_ZERO, NT_STATUS_RPC_FP_DIV_ZERO),
+        _FAULT_STR(DCERPC_NCA_S_FAULT_INT_OVERFLOW, NT_STATUS_RPC_FP_OVERFLOW),
+        /*
+         * What's the difference between NT_STATUS_RPC_INVALID_TAG
+         * and NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE ???
+         *
+         * Our callers expect NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE.
+         */
+        _FAULT_STR(DCERPC_NCA_S_FAULT_INVALID_TAG, NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE),
+        _FAULT_STR(DCERPC_NCA_S_FAULT_INVALID_TAG, NT_STATUS_RPC_INVALID_TAG),
+        _FAULT_STR(DCERPC_NCA_S_FAULT_INVALID_BOUND, NT_STATUS_RPC_INVALID_BOUND),
+        _FAULT_STR(DCERPC_NCA_S_FAULT_RPC_VERSION_MISMATCH, NT_STATUS_RPC_PROTOCOL_ERROR),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_UNSPEC_REJECT),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_BAD_ACTID),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_WHO_ARE_YOU_FAILED),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_MANAGER_NOT_ENTERED),
+        _FAULT_STR(DCERPC_NCA_S_FAULT_CANCEL, NT_STATUS_RPC_CALL_CANCELLED),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_ILL_INST),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_FP_ERROR),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_UNUSED_1C000011),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_UNSPEC),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_REMOTE_COMM_FAILURE),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_PIPE_EMPTY),
+        _FAULT_STR(DCERPC_NCA_S_FAULT_PIPE_CLOSED, NT_STATUS_RPC_PIPE_CLOSED),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_PIPE_ORDER),
+        _FAULT_STR(DCERPC_NCA_S_FAULT_PIPE_DISCIPLINE, NT_STATUS_RPC_PIPE_DISCIPLINE_ERROR),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_PIPE_COMM_ERROR),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_PIPE_MEMORY),
+        _FAULT_STR(DCERPC_NCA_S_FAULT_CONTEXT_MISMATCH, NT_STATUS_RPC_SS_CONTEXT_MISMATCH),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_REMOTE_NO_MEMORY),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_INVALID_PRES_CONTEXT_ID),
+        _FAULT_STR(DCERPC_NCA_S_UNSUPPORTED_AUTHN_LEVEL, NT_STATUS_RPC_UNSUPPORTED_AUTHN_LEVEL),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_UNUSED_1C00001E),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_INVALID_CHECKSUM),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_INVALID_CRC),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_USER_DEFINED),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_TX_OPEN_FAILED),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_CODESET_CONV_ERROR),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_OBJECT_NOT_FOUND),
+        _FAULT_STR_NO_NT_MAPPING(DCERPC_NCA_S_FAULT_NO_CLIENT_STUB),
+        _FAULT_STR(DCERPC_FAULT_OTHER, NT_STATUS_RPC_CALL_FAILED),
+        _FAULT_STR(DCERPC_FAULT_ACCESS_DENIED, NT_STATUS_ACCESS_DENIED),
+        _FAULT_STR(DCERPC_FAULT_NO_CALL_ACTIVE, NT_STATUS_RPC_NO_CALL_ACTIVE),
+        _FAULT_STR(DCERPC_FAULT_CANT_PERFORM, NT_STATUS_EPT_CANT_PERFORM_OP),
+        _FAULT_STR(DCERPC_FAULT_OUT_OF_RESOURCES, NT_STATUS_RPC_OUT_OF_RESOURCES),
+        _FAULT_STR(DCERPC_FAULT_BAD_STUB_DATA, NT_STATUS_RPC_BAD_STUB_DATA),
+        _FAULT_STR(DCERPC_FAULT_SEC_PKG_ERROR, NT_STATUS_RPC_SEC_PKG_ERROR),
         { NULL, 0 }
 #undef _FAULT_STR
@@ -100 +116 @@
 _PUBLIC_ NTSTATUS dcerpc_fault_to_nt_status(uint32_t fault_code)
 {
-        /* TODO: add more mappings */
-        switch (fault_code) {
-        case DCERPC_FAULT_OP_RNG_ERROR:
-                return NT_STATUS_RPC_PROCNUM_OUT_OF_RANGE;
-        case DCERPC_FAULT_UNK_IF:
-                return NT_STATUS_RPC_UNKNOWN_IF;
-        case DCERPC_FAULT_NDR:
-                return NT_STATUS_RPC_BAD_STUB_DATA;
-        case DCERPC_FAULT_INVALID_TAG:
-                return NT_STATUS_RPC_ENUM_VALUE_OUT_OF_RANGE;
-        case DCERPC_FAULT_CONTEXT_MISMATCH:
-                return NT_STATUS_RPC_SS_CONTEXT_MISMATCH;
-        case DCERPC_FAULT_OTHER:
-                return NT_STATUS_RPC_CALL_FAILED;
-        case DCERPC_FAULT_ACCESS_DENIED:
-                return NT_STATUS_ACCESS_DENIED;
-        case DCERPC_FAULT_SEC_PKG_ERROR:
-                return NT_STATUS_RPC_SEC_PKG_ERROR;
+        int idx = 0;
+        WERROR werr = W_ERROR(fault_code);
+
+        if (fault_code == 0) {
+                return NT_STATUS_RPC_PROTOCOL_ERROR;
         }
 
-        return NT_STATUS_RPC_PROTOCOL_ERROR;
+        while (dcerpc_faults[idx].errstr != NULL) {
+                if (dcerpc_faults[idx].faultcode == fault_code) {
+                        return dcerpc_faults[idx].nt_status;
+                }
+                idx++;
+        }
+
+        return werror_to_ntstatus(werr);
 }
 
+_PUBLIC_ uint32_t dcerpc_fault_from_nt_status(NTSTATUS nt_status)
+{
+        int idx = 0;
+        WERROR werr;
+
+        if (NT_STATUS_IS_OK(nt_status)) {
+                return DCERPC_NCA_S_PROTO_ERROR;
+        }
+
+        while (dcerpc_faults[idx].errstr != NULL) {
+                if (NT_STATUS_EQUAL(dcerpc_faults[idx].nt_status, nt_status)) {
+                        return dcerpc_faults[idx].faultcode;
+                }
+                idx++;
+        }
+
+        werr = ntstatus_to_werror(nt_status);
+
+        return W_ERROR_V(werr);
+}

vendor/current/librpc/rpc/dcerpc_util.c

@@ -47 +47 @@
         } else {
                 return RSVAL(blob->data, DCERPC_FRAG_LEN_OFFSET);
-        }
-}
-
-uint32_t dcerpc_get_call_id(const DATA_BLOB *blob)
-{
-        if (CVAL(blob->data,DCERPC_DREP_OFFSET) & DCERPC_DREP_LE) {
-                return IVAL(blob->data, DCERPC_CALL_ID_OFFSET);
-        } else {
-                return RIVAL(blob->data, DCERPC_CALL_ID_OFFSET);
         }
 }
@@ -329 +320 @@
 
         if (state->buffer.length == 0) {
-                /* first get enough to read the fragment length */
+                /*
+                 * first get enough to read the fragment length
+                 *
+                 * We read the full fixed ncacn_packet header
+                 * in order to make wireshark happy with
+                 * pcap files from socket_wrapper.
+                 */
                 ofs = 0;
-                state->buffer.length = DCERPC_FRAG_LEN_OFFSET + 2;
+                state->buffer.length = DCERPC_NCACN_PAYLOAD_OFFSET;
                 state->buffer.data = talloc_array(state, uint8_t,
                                                   state->buffer.length);
@@ -337 +334 @@
                         return -1;
                 }
-        } else if (state->buffer.length == (DCERPC_FRAG_LEN_OFFSET + 2)) {
+        } else if (state->buffer.length == DCERPC_NCACN_PAYLOAD_OFFSET) {
                 /* now read the fragment length and allocate the full buffer */
                 size_t frag_len = dcerpc_get_frag_length(&state->buffer);
@@ -395 +392 @@
         TALLOC_FREE(subreq);
         if (ret == -1) {
-                status = map_nt_error_from_unix(sys_errno);
+                status = map_nt_error_from_unix_common(sys_errno);
                 tevent_req_nterror(req, status);
                 return;
@@ -451 +448 @@
         tevent_req_received(req);
         return NT_STATUS_OK;
+}
+
+const char *dcerpc_default_transport_endpoint(TALLOC_CTX *mem_ctx,
+                                              enum dcerpc_transport_t transport,
+                                              const struct ndr_interface_table *table)
+{
+        NTSTATUS status;
+        const char *p = NULL;
+        const char *endpoint = NULL;
+        int i;
+        struct dcerpc_binding *default_binding = NULL;
+        TALLOC_CTX *frame = talloc_stackframe();
+
+        /* Find one of the default pipes for this interface */
+
+        for (i = 0; i < table->endpoints->count; i++) {
+                enum dcerpc_transport_t dtransport;
+                const char *dendpoint;
+
+                status = dcerpc_parse_binding(frame, table->endpoints->names[i],
+                                              &default_binding);
+                if (!NT_STATUS_IS_OK(status)) {
+                        continue;
+                }
+
+                dtransport = dcerpc_binding_get_transport(default_binding);
+                dendpoint = dcerpc_binding_get_string_option(default_binding,
+                                                             "endpoint");
+                if (dendpoint == NULL) {
+                        TALLOC_FREE(default_binding);
+                        continue;
+                }
+
+                if (transport == NCA_UNKNOWN) {
+                        transport = dtransport;
+                }
+
+                if (transport != dtransport) {
+                        TALLOC_FREE(default_binding);
+                        continue;
+                }
+
+                p = dendpoint;
+                break;
+        }
+
+        if (p == NULL) {
+                goto done;
+        }
+
+        /*
+         * extract the pipe name without \\pipe from for example
+         * ncacn_np:[\\pipe\\epmapper]
+         */
+        if (transport == NCACN_NP) {
+                if (strncasecmp(p, "\\pipe\\", 6) == 0) {
+                        p += 6;
+                }
+                if (strncmp(p, "\\", 1) == 0) {
+                        p += 1;
+                }
+        }
+
+        endpoint = talloc_strdup(mem_ctx, p);
+
+ done:
+        talloc_free(frame);
+        return endpoint;
 }
 
@@ -558 +623 @@
 }
 
-#define CHECK(msg, ok)                                          \
-do {                                                            \
-        if (!ok) {                                              \
-                DEBUG(10, ("SEC_VT check %s failed\n", msg));   \
-                return false;                                   \
-        }                                                       \
-} while(0)
-
-#define CHECK_SYNTAX(msg, s1, s2)                                       \
-do {                                                            \
-        if (!ndr_syntax_id_equal(&s1, &s2)) {                           \
-                TALLOC_CTX *frame = talloc_stackframe();                \
-                DEBUG(10, ("SEC_VT check %s failed: %s vs. %s\n", msg,  \
-                           ndr_syntax_id_to_string(frame, &s1),         \
-                           ndr_syntax_id_to_string(frame, &s1)));       \
-                TALLOC_FREE(frame);                                     \
-                return false;                                           \
-        }                                                               \
-} while(0)
-
+static bool dcerpc_sec_vt_bitmask_check(const uint32_t *bitmask1,
+                                        struct dcerpc_sec_vt *c)
+{
+        if (bitmask1 == NULL) {
+                if (c->command & DCERPC_SEC_VT_MUST_PROCESS) {
+                        DEBUG(10, ("SEC_VT check Bitmask1 must_process_command "
+                                   "failed\n"));
+                        return false;
+                }
+
+                return true;
+        }
+
+        if ((c->u.bitmask1 & DCERPC_SEC_VT_CLIENT_SUPPORTS_HEADER_SIGNING)
+         && (!(*bitmask1 & DCERPC_SEC_VT_CLIENT_SUPPORTS_HEADER_SIGNING))) {
+                DEBUG(10, ("SEC_VT check Bitmask1 client_header_signing "
+                           "failed\n"));
+                return false;
+        }
+        return true;
+}
+
+static bool dcerpc_sec_vt_pctx_check(const struct dcerpc_sec_vt_pcontext *pcontext,
+                                     struct dcerpc_sec_vt *c)
+{
+        TALLOC_CTX *mem_ctx;
+        bool ok;
+
+        if (pcontext == NULL) {
+                if (c->command & DCERPC_SEC_VT_MUST_PROCESS) {
+                        DEBUG(10, ("SEC_VT check Pcontext must_process_command "
+                                   "failed\n"));
+                        return false;
+                }
+
+                return true;
+        }
+
+        mem_ctx = talloc_stackframe();
+        ok = ndr_syntax_id_equal(&pcontext->abstract_syntax,
+                                 &c->u.pcontext.abstract_syntax);
+        if (!ok) {
+                DEBUG(10, ("SEC_VT check pcontext abstract_syntax failed: "
+                           "%s vs. %s\n",
+                           ndr_syntax_id_to_string(mem_ctx,
+                                        &pcontext->abstract_syntax),
+                           ndr_syntax_id_to_string(mem_ctx,
+                                        &c->u.pcontext.abstract_syntax)));
+                goto err_ctx_free;
+        }
+        ok = ndr_syntax_id_equal(&pcontext->transfer_syntax,
+                                 &c->u.pcontext.transfer_syntax);
+        if (!ok) {
+                DEBUG(10, ("SEC_VT check pcontext transfer_syntax failed: "
+                           "%s vs. %s\n",
+                           ndr_syntax_id_to_string(mem_ctx,
+                                        &pcontext->transfer_syntax),
+                           ndr_syntax_id_to_string(mem_ctx,
+                                        &c->u.pcontext.transfer_syntax)));
+                goto err_ctx_free;
+        }
+
+        ok = true;
+err_ctx_free:
+        talloc_free(mem_ctx);
+        return ok;
+}
+
+static bool dcerpc_sec_vt_hdr2_check(const struct dcerpc_sec_vt_header2 *header2,
+                                     struct dcerpc_sec_vt *c)
+{
+        if (header2 == NULL) {
+                if (c->command & DCERPC_SEC_VT_MUST_PROCESS) {
+                        DEBUG(10, ("SEC_VT check Header2 must_process_command failed\n"));
+                        return false;
+                }
+
+                return true;
+        }
+
+        if (!dcerpc_sec_vt_header2_equal(header2, &c->u.header2)) {
+                DEBUG(10, ("SEC_VT check Header2 failed\n"));
+                return false;
+        }
+
+        return true;
+}
 
 bool dcerpc_sec_verification_trailer_check(
@@ -592 +724 @@
 
         for (i=0; i < vt->count.count; i++) {
+                bool ok;
                 struct dcerpc_sec_vt *c = &vt->commands[i];
 
                 switch (c->command & DCERPC_SEC_VT_COMMAND_ENUM) {
                 case DCERPC_SEC_VT_COMMAND_BITMASK1:
-                        if (bitmask1 == NULL) {
-                                CHECK("Bitmask1 must_process_command",
-                                      !(c->command & DCERPC_SEC_VT_MUST_PROCESS));
-                                break;
-                        }
-
-                        if (c->u.bitmask1 & DCERPC_SEC_VT_CLIENT_SUPPORTS_HEADER_SIGNING) {
-                                CHECK("Bitmask1 client_header_signing",
-                                      *bitmask1 & DCERPC_SEC_VT_CLIENT_SUPPORTS_HEADER_SIGNING);
+                        ok = dcerpc_sec_vt_bitmask_check(bitmask1, c);
+                        if (!ok) {
+                                return false;
                         }
                         break;
 
                 case DCERPC_SEC_VT_COMMAND_PCONTEXT:
-                        if (pcontext == NULL) {
-                                CHECK("Pcontext must_process_command",
-                                      !(c->command & DCERPC_SEC_VT_MUST_PROCESS));
-                                break;
+                        ok = dcerpc_sec_vt_pctx_check(pcontext, c);
+                        if (!ok) {
+                                return false;
                         }
-
-                        CHECK_SYNTAX("Pcontect abstract_syntax",
-                                     pcontext->abstract_syntax,
-                                     c->u.pcontext.abstract_syntax);
-                        CHECK_SYNTAX("Pcontext transfer_syntax",
-                                     pcontext->transfer_syntax,
-                                     c->u.pcontext.transfer_syntax);
                         break;
 
                 case DCERPC_SEC_VT_COMMAND_HEADER2: {
-                        if (header2 == NULL) {
-                                CHECK("Header2 must_process_command",
-                                      !(c->command & DCERPC_SEC_VT_MUST_PROCESS));
-                                break;
+                        ok = dcerpc_sec_vt_hdr2_check(header2, c);
+                        if (!ok) {
+                                return false;
                         }
-
-                        CHECK("Header2", dcerpc_sec_vt_header2_equal(header2, &c->u.header2));
                         break;
                 }
 
                 default:
-                        CHECK("Unknown must_process_command",
-                              !(c->command & DCERPC_SEC_VT_MUST_PROCESS));
+                        if (c->command & DCERPC_SEC_VT_MUST_PROCESS) {
+                                DEBUG(10, ("SEC_VT check Unknown must_process_command failed\n"));
+                                return false;
+                        }
+
                         break;
                 }
@@ -643 +762 @@
         return true;
 }
+
+static const struct ndr_syntax_id dcerpc_bind_time_features_prefix  = {
+        .uuid = {
+                .time_low = 0x6cb71c2c,
+                .time_mid = 0x9812,
+                .time_hi_and_version = 0x4540,
+                .clock_seq = {0x00, 0x00},
+                .node = {0x00,0x00,0x00,0x00,0x00,0x00}
+        },
+        .if_version = 1,
+};
+
+bool dcerpc_extract_bind_time_features(struct ndr_syntax_id s, uint64_t *_features)
+{
+        uint8_t values[8];
+        uint64_t features = 0;
+
+        values[0] = s.uuid.clock_seq[0];
+        values[1] = s.uuid.clock_seq[1];
+        values[2] = s.uuid.node[0];
+        values[3] = s.uuid.node[1];
+        values[4] = s.uuid.node[2];
+        values[5] = s.uuid.node[3];
+        values[6] = s.uuid.node[4];
+        values[7] = s.uuid.node[5];
+
+        ZERO_STRUCT(s.uuid.clock_seq);
+        ZERO_STRUCT(s.uuid.node);
+
+        if (!ndr_syntax_id_equal(&s, &dcerpc_bind_time_features_prefix)) {
+                if (_features != NULL) {
+                        *_features = 0;
+                }
+                return false;
+        }
+
+        features = BVAL(values, 0);
+
+        if (_features != NULL) {
+                *_features = features;
+        }
+
+        return true;
+}
+
+struct ndr_syntax_id dcerpc_construct_bind_time_features(uint64_t features)
+{
+        struct ndr_syntax_id s = dcerpc_bind_time_features_prefix;
+        uint8_t values[8];
+
+        SBVAL(values, 0, features);
+
+        s.uuid.clock_seq[0] = values[0];
+        s.uuid.clock_seq[1] = values[1];
+        s.uuid.node[0]      = values[2];
+        s.uuid.node[1]      = values[3];
+        s.uuid.node[2]      = values[4];
+        s.uuid.node[3]      = values[5];
+        s.uuid.node[4]      = values[6];
+        s.uuid.node[5]      = values[7];
+
+        return s;
+}

vendor/current/librpc/rpc/rpc_common.h

@@ -22 +22 @@
 #ifndef __DEFAULT_LIBRPC_RPCCOMMON_H__
 #define __DEFAULT_LIBRPC_RPCCOMMON_H__
+
+#include "gen_ndr/dcerpc.h"
+#include "lib/util/attr.h"
 
 struct dcerpc_binding_handle;
@@ -41 +44 @@
 
 /** this describes a binding to a particular transport/pipe */
-struct dcerpc_binding {
-        enum dcerpc_transport_t transport;
-        struct ndr_syntax_id object;
-        const char *host;
-        const char *target_hostname;
-        const char *target_principal;
-        const char *endpoint;
-        const char **options;
-        const char *localaddress;
-        uint32_t flags;
-        uint32_t assoc_group_id;
-};
+struct dcerpc_binding;
 
 /* dcerpc pipe flags */
@@ -99 +91 @@
 #define DCERPC_CONCURRENT_MULTIPLEX     (1<<19)
 
-/* this triggers the DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN flag in the bind request */
+/* this indicates DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN flag was negotiated */
 #define DCERPC_HEADER_SIGNING          (1<<20)
 
@@ -105 +97 @@
 #define DCERPC_NDR64                   (1<<21)
 
-/* specify binding interface */
-#define DCERPC_LOCALADDRESS            (1<<22)
+/* handle upgrades or downgrades automatically */
+#define DCERPC_SCHANNEL_AUTO           (1<<23)
+
+/* use aes schannel with hmac-sh256 session key */
+#define DCERPC_SCHANNEL_AES            (1<<24)
+
+/* this triggers the DCERPC_PFC_FLAG_SUPPORT_HEADER_SIGN flag in the bind request */
+#define DCERPC_PROPOSE_HEADER_SIGNING          (1<<25)
 
 /* The following definitions come from ../librpc/rpc/dcerpc_error.c  */
@@ -112 +110 @@
 const char *dcerpc_errstr(TALLOC_CTX *mem_ctx, uint32_t fault_code);
 NTSTATUS dcerpc_fault_to_nt_status(uint32_t fault_code);
+uint32_t dcerpc_fault_from_nt_status(NTSTATUS nt_status);
 
 /* The following definitions come from ../librpc/rpc/binding.c  */
 
 const char *epm_floor_string(TALLOC_CTX *mem_ctx, struct epm_floor *epm_floor);
-const char *dcerpc_floor_get_rhs_data(TALLOC_CTX *mem_ctx, struct epm_floor *epm_floor);
+char *dcerpc_floor_get_rhs_data(TALLOC_CTX *mem_ctx, struct epm_floor *epm_floor);
 enum dcerpc_transport_t dcerpc_transport_by_endpoint_protocol(int prot);
 struct dcerpc_binding *dcerpc_binding_dup(TALLOC_CTX *mem_ctx,
@@ -128 +127 @@
 NTSTATUS dcerpc_parse_binding(TALLOC_CTX *mem_ctx, const char *s, struct dcerpc_binding **b_out);
 char *dcerpc_binding_string(TALLOC_CTX *mem_ctx, const struct dcerpc_binding *b);
+struct GUID dcerpc_binding_get_object(const struct dcerpc_binding *b);
+NTSTATUS dcerpc_binding_set_object(struct dcerpc_binding *b,
+                                   struct GUID object);
+enum dcerpc_transport_t dcerpc_binding_get_transport(const struct dcerpc_binding *b);
+NTSTATUS dcerpc_binding_set_transport(struct dcerpc_binding *b,
+                                      enum dcerpc_transport_t transport);
+void dcerpc_binding_get_auth_info(const struct dcerpc_binding *b,
+                                  enum dcerpc_AuthType *_auth_type,
+                                  enum dcerpc_AuthLevel *_auth_level);
+uint32_t dcerpc_binding_get_assoc_group_id(const struct dcerpc_binding *b);
+NTSTATUS dcerpc_binding_set_assoc_group_id(struct dcerpc_binding *b,
+                                           uint32_t assoc_group_id);
+struct ndr_syntax_id dcerpc_binding_get_abstract_syntax(const struct dcerpc_binding *b);
+NTSTATUS dcerpc_binding_set_abstract_syntax(struct dcerpc_binding *b,
+                                            const struct ndr_syntax_id *syntax);
+const char *dcerpc_binding_get_string_option(const struct dcerpc_binding *b,
+                                             const char *name);
+char *dcerpc_binding_copy_string_option(TALLOC_CTX *mem_ctx,
+                                        const struct dcerpc_binding *b,
+                                        const char *name);
+NTSTATUS dcerpc_binding_set_string_option(struct dcerpc_binding *b,
+                                          const char *name,
+                                          const char *value);
+uint32_t dcerpc_binding_get_flags(const struct dcerpc_binding *b);
+NTSTATUS dcerpc_binding_set_flags(struct dcerpc_binding *b,
+                                  uint32_t additional,
+                                  uint32_t clear);
 NTSTATUS dcerpc_floor_get_lhs_data(const struct epm_floor *epm_floor, struct ndr_syntax_id *syntax);
 const char *derpc_transport_string_by_transport(enum dcerpc_transport_t t);
+enum dcerpc_transport_t dcerpc_transport_by_name(const char *name);
 enum dcerpc_transport_t dcerpc_transport_by_tower(const struct epm_tower *tower);
 
@@ -136 +163 @@
 void dcerpc_set_frag_length(DATA_BLOB *blob, uint16_t v);
 uint16_t dcerpc_get_frag_length(const DATA_BLOB *blob);
-uint32_t dcerpc_get_call_id(const DATA_BLOB *blob);
 void dcerpc_set_auth_length(DATA_BLOB *blob, uint16_t v);
 uint8_t dcerpc_get_endian_flag(DATA_BLOB *blob);
+const char *dcerpc_default_transport_endpoint(TALLOC_CTX *mem_ctx,
+                                              enum dcerpc_transport_t transport,
+                                              const struct ndr_interface_table *table);
 
 /**
@@ -187 +216 @@
                                 uint32_t timeout);
 
+        void (*auth_info)(struct dcerpc_binding_handle *h,
+                          enum dcerpc_AuthType *auth_type,
+                          enum dcerpc_AuthLevel *auth_level);
+
         struct tevent_req *(*raw_call_send)(TALLOC_CTX *mem_ctx,
                                             struct tevent_context *ev,
@@ -257 +290 @@
                                            uint32_t timeout);
 
+void dcerpc_binding_handle_auth_info(struct dcerpc_binding_handle *h,
+                                     enum dcerpc_AuthType *auth_type,
+                                     enum dcerpc_AuthLevel *auth_level);
+
 struct tevent_req *dcerpc_binding_handle_raw_call_send(TALLOC_CTX *mem_ctx,
                                                 struct tevent_context *ev,
@@ -343 +380 @@
                 const struct dcerpc_sec_vt_header2 *header2);
 
+/**
+ * @brief check and optionally extract the Bind Time Features from
+ * the given ndr_syntax_id.
+ *
+ * <a href="http://msdn.microsoft.com/en-us/library/cc243715.aspx">MS-RPCE 3.3.1.5.3 Bind Time Feature Negotiation</a>.
+ *
+ * @param[in]  s the syntax that should be checked.
+ *
+ * @param[out] features This is optional, it will be filled with the extracted
+ *                      features the on success, otherwise it's filled with 0.
+ *
+ * @return true if the syntax matches the 6CB71C2C-9812-4540 prefix with version 1, false otherwise.
+ *
+ * @see dcerpc_construct_bind_time_features
+ */
+bool dcerpc_extract_bind_time_features(struct ndr_syntax_id syntax, uint64_t *features);
+
+/**
+ * @brief Construct a ndr_syntax_id used for Bind Time Features Negotiation.
+ *
+ * <a href="http://msdn.microsoft.com/en-us/library/cc243715.aspx">MS-RPCE 3.3.1.5.3 Bind Time Feature Negotiation</a>.
+ *
+ * @param[in] features The supported features.
+ *
+ * @return The ndr_syntax_id with the given features.
+ *
+ * @see dcerpc_extract_bind_time_features
+ */
+struct ndr_syntax_id dcerpc_construct_bind_time_features(uint64_t features);
+
+#define DCERPC_AUTH_PAD_LENGTH(stub_length) (\
+        (((stub_length) % DCERPC_AUTH_PAD_ALIGNMENT) > 0)?\
+        (DCERPC_AUTH_PAD_ALIGNMENT - (stub_length) % DCERPC_AUTH_PAD_ALIGNMENT):\
+        0)
+
 #endif /* __DEFAULT_LIBRPC_RPCCOMMON_H__ */