Changeset 745 for trunk/server/librpc/rpc

Timestamp:

Nov 27, 2012, 4:43:17 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: updated trunk to 3.6.0

Location:

trunk/server

Files:

• . (modified) (1 prop)
• librpc/rpc/binding.c (modified) (18 diffs)
• librpc/rpc/binding_handle.c (copied) (copied from vendor/current/librpc/rpc/binding_handle.c )
• librpc/rpc/dcerpc_error.c (modified) (4 diffs)
• librpc/rpc/dcerpc_util.c (copied) (copied from vendor/current/librpc/rpc/dcerpc_util.c )
• librpc/rpc/rpc_common.h (copied) (copied from vendor/current/librpc/rpc/rpc_common.h )

trunk/server/librpc/rpc/binding.c

@@ -24 +24 @@
 
 #include "includes.h"
+#include "../../lib/util/util_net.h"
 #include "librpc/gen_ndr/ndr_epmapper.h"
 #include "librpc/gen_ndr/ndr_misc.h"
 #include "librpc/rpc/dcerpc.h"
+#include "rpc_common.h"
+
 #undef strcasecmp
+#undef strncasecmp
 
 #define MAX_PROTSEQ             10
@@ -86 +90 @@
         {"smb2", DCERPC_SMB2},
         {"hdrsign", DCERPC_HEADER_SIGNING},
-        {"ndr64", DCERPC_NDR64}
+        {"ndr64", DCERPC_NDR64},
+        {"localaddress", DCERPC_LOCALADDRESS}
 };
 
@@ -114 +119 @@
                         } else { /* IPX */
                                 return talloc_asprintf(mem_ctx, "IPX:%s", 
-                                                data_blob_hex_string(mem_ctx, &epm_floor->rhs.uuid.unknown));
+                                                data_blob_hex_string_upper(mem_ctx, &epm_floor->rhs.uuid.unknown));
                         }
 
@@ -220 +225 @@
         for (i=0;i<ARRAY_SIZE(ncacn_options);i++) {
                 if (b->flags & ncacn_options[i].flag) {
-                        s = talloc_asprintf_append_buffer(s, ",%s", ncacn_options[i].name);
+                        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;
                 }
@@ -240 +250 @@
         int i, j, comma_count;
 
-        b = talloc(mem_ctx, struct dcerpc_binding);
+        b = talloc_zero(mem_ctx, struct dcerpc_binding);
         if (!b) {
                 return NT_STATUS_NO_MEMORY;
@@ -313 +323 @@
         b->assoc_group_id = 0;
         b->endpoint = NULL;
+        b->localaddress = NULL;
 
         if (!options) {
@@ -339 +350 @@
         for (i=0;b->options[i];i++) {
                 for (j=0;j<ARRAY_SIZE(ncacn_options);j++) {
-                        if (strcasecmp(ncacn_options[j].name, b->options[i]) == 0) {
+                        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++) {
@@ -376 +396 @@
         uint16_t if_version=0;
 
-        ndr = ndr_pull_init_blob(&epm_floor->lhs.lhs_data, mem_ctx, NULL);
+        ndr = ndr_pull_init_blob(&epm_floor->lhs.lhs_data, mem_ctx);
         if (ndr == NULL) {
                 talloc_free(mem_ctx);
@@ -404 +424 @@
 static DATA_BLOB dcerpc_floor_pack_lhs_data(TALLOC_CTX *mem_ctx, const struct ndr_syntax_id *syntax)
 {
-        struct ndr_push *ndr = ndr_push_init_ctx(mem_ctx, NULL);
+        DATA_BLOB blob;
+        struct ndr_push *ndr = ndr_push_init_ctx(mem_ctx);
 
         ndr->flags |= LIBNDR_FLAG_NOALIGN;
@@ -411 +432 @@
         ndr_push_uint16(ndr, NDR_SCALARS, syntax->if_version);
 
-        return ndr_push_blob(ndr);
+        blob = ndr_push_blob(ndr);
+        talloc_steal(mem_ctx, blob.data);
+        talloc_free(ndr);
+        return blob;
+}
+
+static bool dcerpc_floor_pack_rhs_if_version_data(
+        TALLOC_CTX *mem_ctx, const struct ndr_syntax_id *syntax,
+        DATA_BLOB *pblob)
+{
+        DATA_BLOB blob;
+        struct ndr_push *ndr = ndr_push_init_ctx(mem_ctx);
+        enum ndr_err_code ndr_err;
+
+        if (ndr == NULL) {
+                return false;
+        }
+
+        ndr->flags |= LIBNDR_FLAG_NOALIGN;
+
+        ndr_err = ndr_push_uint16(ndr, NDR_SCALARS, syntax->if_version >> 16);
+        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+                return false;
+        }
+
+        blob = ndr_push_blob(ndr);
+        talloc_steal(mem_ctx, blob.data);
+        talloc_free(ndr);
+        *pblob = blob;
+        return true;
 }
 
@@ -608 +658 @@
 }
 
-_PUBLIC_ NTSTATUS dcerpc_binding_from_tower(TALLOC_CTX *mem_ctx, 
-                                   struct epm_tower *tower, 
-                                   struct dcerpc_binding **b_out)
+_PUBLIC_ NTSTATUS dcerpc_binding_from_tower(TALLOC_CTX *mem_ctx,
+                                            struct epm_tower *tower,
+                                            struct dcerpc_binding **b_out)
 {
         NTSTATUS status;
         struct dcerpc_binding *binding;
 
-        binding = talloc(mem_ctx, struct dcerpc_binding);
+        /*
+         * A tower needs to have at least 4 floors to carry useful
+         * information. Floor 3 is the transport identifier which defines
+         * how many floors are required at least.
+         */
+        if (tower->num_floors < 4) {
+                return NT_STATUS_INVALID_PARAMETER;
+        }
+
+        binding = talloc_zero(mem_ctx, struct dcerpc_binding);
         NT_STATUS_HAVE_NO_MEMORY(binding);
 
@@ -631 +690 @@
         }
 
-        if (tower->num_floors < 1) {
-                return NT_STATUS_OK;
-        }
-
         /* Set object uuid */
         status = dcerpc_floor_get_lhs_data(&tower->floors[0], &binding->object);
 
         if (!NT_STATUS_IS_OK(status)) {
-                DEBUG(1, ("Error pulling object uuid and version: %s", nt_errstr(status)));     
+                DEBUG(1, ("Error pulling object uuid and version: %s", nt_errstr(status)));
                 return status;
         }
@@ -649 +704 @@
         /* Set endpoint */
         if (tower->num_floors >= 4) {
-                binding->endpoint = dcerpc_floor_get_rhs_data(mem_ctx, &tower->floors[3]);
+                binding->endpoint = dcerpc_floor_get_rhs_data(binding, &tower->floors[3]);
         } else {
                 binding->endpoint = NULL;
@@ -656 +711 @@
         /* Set network address */
         if (tower->num_floors >= 5) {
-                binding->host = dcerpc_floor_get_rhs_data(mem_ctx, &tower->floors[4]);
+                binding->host = dcerpc_floor_get_rhs_data(binding, &tower->floors[4]);
                 NT_STATUS_HAVE_NO_MEMORY(binding->host);
                 binding->target_hostname = binding->host;
@@ -662 +717 @@
         *b_out = binding;
         return NT_STATUS_OK;
+}
+
+_PUBLIC_ struct dcerpc_binding *dcerpc_binding_dup(TALLOC_CTX *mem_ctx,
+                                                   const struct dcerpc_binding *b)
+{
+        struct dcerpc_binding *n;
+        uint32_t count;
+
+        n = talloc_zero(mem_ctx, struct dcerpc_binding);
+        if (n == NULL) {
+                return NULL;
+        }
+
+        n->transport = b->transport;
+        n->object = b->object;
+        n->flags = b->flags;
+        n->assoc_group_id = b->assoc_group_id;
+
+        if (b->host != NULL) {
+                n->host = talloc_strdup(n, b->host);
+                if (n->host == NULL) {
+                        talloc_free(n);
+                        return NULL;
+                }
+        }
+
+        if (b->target_hostname != NULL) {
+                n->target_hostname = talloc_strdup(n, b->target_hostname);
+                if (n->target_hostname == NULL) {
+                        talloc_free(n);
+                        return NULL;
+                }
+        }
+
+        if (b->target_principal != NULL) {
+                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;
+                }
+        }
+
+        if (b->endpoint != NULL) {
+                n->endpoint = talloc_strdup(n, b->endpoint);
+                if (n->endpoint == NULL) {
+                        talloc_free(n);
+                        return NULL;
+                }
+        }
+
+        for (count = 0; b->options && b->options[count]; count++);
+
+        if (count > 0) {
+                uint32_t i;
+
+                n->options = talloc_array(n, const char *, count + 1);
+                if (n->options == NULL) {
+                        talloc_free(n);
+                        return NULL;
+                }
+
+                for (i = 0; i < count; i++) {
+                        n->options[i] = talloc_strdup(n->options, b->options[i]);
+                        if (n->options[i] == NULL) {
+                                talloc_free(n);
+                                return NULL;
+                        }
+                }
+                n->options[count] = NULL;
+        }
+
+        return n;
 }
 
@@ -692 +827 @@
         tower->floors[0].lhs.protocol = EPM_PROTOCOL_UUID;
 
-        tower->floors[0].lhs.lhs_data = dcerpc_floor_pack_lhs_data(mem_ctx, &binding->object);
-
-        tower->floors[0].rhs.uuid.unknown = data_blob_talloc_zero(mem_ctx, 2);
+        tower->floors[0].lhs.lhs_data = dcerpc_floor_pack_lhs_data(tower->floors, &binding->object);
+
+        if (!dcerpc_floor_pack_rhs_if_version_data(
+                    tower->floors, &binding->object,
+                    &tower->floors[0].rhs.uuid.unknown)) {
+                return NT_STATUS_NO_MEMORY;
+        }
 
         /* Floor 1 */
         tower->floors[1].lhs.protocol = EPM_PROTOCOL_UUID;
 
-        tower->floors[1].lhs.lhs_data = dcerpc_floor_pack_lhs_data(mem_ctx, 
+        tower->floors[1].lhs.lhs_data = dcerpc_floor_pack_lhs_data(tower->floors, 
                                                                 &ndr_transfer_syntax);
 
-        tower->floors[1].rhs.uuid.unknown = data_blob_talloc_zero(mem_ctx, 2);
+        tower->floors[1].rhs.uuid.unknown = data_blob_talloc_zero(tower->floors, 2);
 
         /* Floor 2 to num_protocols */
         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(mem_ctx, NULL, 0);
+                tower->floors[2 + i].lhs.lhs_data = data_blob_talloc(tower->floors, NULL, 0);
                 ZERO_STRUCT(tower->floors[2 + i].rhs);
-                dcerpc_floor_set_rhs_data(mem_ctx, &tower->floors[2 + i], "");
+                dcerpc_floor_set_rhs_data(tower->floors, &tower->floors[2 + i], "");
         }
 
         /* The 4th floor contains the endpoint */
         if (num_protocols >= 2 && binding->endpoint) {
-                status = dcerpc_floor_set_rhs_data(mem_ctx, &tower->floors[3], binding->endpoint);
+                status = dcerpc_floor_set_rhs_data(tower->floors, &tower->floors[3], binding->endpoint);
                 if (NT_STATUS_IS_ERR(status)) {
                         return status;
@@ -722 +861 @@
         /* The 5th contains the network address */
         if (num_protocols >= 3 && binding->host) {
-                if (is_ipaddress(binding->host)) {
-                        status = dcerpc_floor_set_rhs_data(mem_ctx, &tower->floors[4], 
+                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 {
@@ -731 +871 @@
                            a wildcard all-zeros IP for the server to
                            fill in */
-                        status = dcerpc_floor_set_rhs_data(mem_ctx, &tower->floors[4], 
+                        status = dcerpc_floor_set_rhs_data(tower->floors, &tower->floors[4], 
                                                            "0.0.0.0");
                 }

trunk/server/librpc/rpc/dcerpc_error.c

@@ -22 +22 @@
 #include "includes.h"
 #include "librpc/rpc/dcerpc.h"
+#include "rpc_common.h"
 
 struct dcerpc_fault_table {
@@ -30 +31 @@
 static const struct dcerpc_fault_table dcerpc_faults[] =
 {
-        { "DCERPC_FAULT_OP_RNG_ERROR",          DCERPC_FAULT_OP_RNG_ERROR },
-        { "DCERPC_FAULT_UNK_IF",                DCERPC_FAULT_UNK_IF },
-        { "DCERPC_FAULT_NDR",                   DCERPC_FAULT_NDR },
-        { "DCERPC_FAULT_INVALID_TAG",           DCERPC_FAULT_INVALID_TAG },
-        { "DCERPC_FAULT_CONTEXT_MISMATCH",      DCERPC_FAULT_CONTEXT_MISMATCH },
-        { "DCERPC_FAULT_OTHER",                 DCERPC_FAULT_OTHER },
-        { "DCERPC_FAULT_ACCESS_DENIED",         DCERPC_FAULT_ACCESS_DENIED },
-        { "DCERPC_FAULT_SEC_PKG_ERROR",         DCERPC_FAULT_SEC_PKG_ERROR },
-
-        { NULL,                                 0}
+#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),
+        { NULL, 0 }
+#undef _FAULT_STR
 };
 
@@ -45 +86 @@
 {
         int idx = 0;
+        WERROR werr = W_ERROR(fault_code);
 
         while (dcerpc_faults[idx].errstr != NULL) {
@@ -53 +95 @@
         }
 
-        return talloc_asprintf(mem_ctx, "DCERPC fault 0x%08x", fault_code);
+        return win_errstr(werr);
 }
+
+_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;
+        }
+
+        return NT_STATUS_RPC_PROTOCOL_ERROR;
+}
+