Ignore:
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:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/server

  • trunk/server/librpc/ndr/ndr_drsuapi.c

    r414 r745  
    6767}
    6868
    69 #define _OID_PUSH_CHECK(call) do { \
    70         bool _status; \
    71         _status = call; \
    72         if (_status != true) { \
    73                 return ndr_push_error(ndr, NDR_ERR_SUBCONTEXT, "OID Conversion Error: %s\n", __location__); \
    74         } \
    75 } while (0)
    76 
    77 #define _OID_PULL_CHECK(call) do { \
    78         bool _status; \
    79         _status = call; \
    80         if (_status != true) { \
    81                 return ndr_pull_error(ndr, NDR_ERR_SUBCONTEXT, "OID Conversion Error: %s\n", __location__); \
    82         } \
    83 } while (0)
    84 
    85 enum ndr_err_code ndr_push_drsuapi_DsReplicaOID(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaOID *r)
    86 {
    87         if (ndr_flags & NDR_SCALARS) {
    88                 NDR_CHECK(ndr_push_align(ndr, 4));
    89                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_drsuapi_DsReplicaOID_oid(r->oid, 0)));
    90                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->oid));
    91         }
    92         if (ndr_flags & NDR_BUFFERS) {
    93                 if (r->oid) {
    94                         DATA_BLOB blob;
    95 
    96                         if (strncasecmp("ff", r->oid, 2) == 0) {
    97                                 blob = strhex_to_data_blob(ndr, r->oid);
    98                                 if (!blob.data) {
    99                                         return ndr_push_error(ndr, NDR_ERR_SUBCONTEXT,
    100                                                               "HEX String Conversion Error: %s\n",
    101                                                               __location__);
    102                                 }
    103                         } else {
    104                                 _OID_PUSH_CHECK(ber_write_OID_String(&blob, r->oid));
    105                                 talloc_steal(ndr, blob.data);
    106                         }
    107 
    108                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, blob.length));
    109                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, blob.data, blob.length));
    110                 }
    111         }
    112         return NDR_ERR_SUCCESS;
    113 }
    114 
    115 enum ndr_err_code ndr_pull_drsuapi_DsReplicaOID(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaOID *r)
    116 {
    117         uint32_t _ptr_oid;
    118         TALLOC_CTX *_mem_save_oid_0;
    119         if (ndr_flags & NDR_SCALARS) {
    120                 NDR_CHECK(ndr_pull_align(ndr, 4));
    121                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->__ndr_size));
    122                 if (r->__ndr_size < 0 || r->__ndr_size > 10000) {
    123                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
    124                 }
    125                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_oid));
    126                 if (_ptr_oid) {
    127                         NDR_PULL_ALLOC(ndr, r->oid);
    128                 } else {
    129                         r->oid = NULL;
    130                 }
    131         }
    132         if (ndr_flags & NDR_BUFFERS) {
    133                 if (r->oid) {
    134                         DATA_BLOB _oid_array;
    135                         const char *_oid;
    136 
    137                         _mem_save_oid_0 = NDR_PULL_GET_MEM_CTX(ndr);
    138                         NDR_PULL_SET_MEM_CTX(ndr, ndr, 0);
    139                         NDR_CHECK(ndr_pull_array_size(ndr, &r->oid));
    140                         _oid_array.length = ndr_get_array_size(ndr, &r->oid);
    141                         NDR_PULL_ALLOC_N(ndr, _oid_array.data, _oid_array.length);
    142                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, _oid_array.data, _oid_array.length));
    143                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_oid_0, 0);
    144 
    145                         if (_oid_array.length && _oid_array.data[0] == 0xFF) {
    146                                 _oid = data_blob_hex_string(ndr, &_oid_array);
    147                                 NDR_ERR_HAVE_NO_MEMORY(_oid);
    148                         } else {
    149                                 _OID_PULL_CHECK(ber_read_OID_String(ndr, _oid_array, &_oid));
    150                         }
    151                         data_blob_free(&_oid_array);
    152                         talloc_steal(r->oid, _oid);
    153                         r->oid = _oid;
    154                 }
    155                 if (r->oid) {
    156                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->oid, r->__ndr_size));
    157                 }
    158         }
    159         return NDR_ERR_SUCCESS;
    160 }
    161 
    162 size_t ndr_size_drsuapi_DsReplicaOID_oid(const char *oid, int flags)
    163 {
    164         DATA_BLOB _blob;
    165         size_t ret = 0;
    166 
    167         if (!oid) return 0;
    168 
    169         if (strncasecmp("ff", oid, 2) == 0) {
    170                 _blob = strhex_to_data_blob(NULL, oid);
    171                 if (_blob.data) {
    172                         ret = _blob.length;
    173                 }
     69_PUBLIC_ void ndr_print_drsuapi_DsReplicaOID(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaOID *r)
     70{
     71        ndr_print_struct(ndr, name, "drsuapi_DsReplicaOID");
     72        ndr->depth++;
     73        ndr_print_uint32(ndr, "length", r->length);
     74        ndr->print(ndr, "%-25s: length=%u", "oid", r->length);
     75        if (r->binary_oid) {
     76                char *partial_oid = NULL;
     77                DATA_BLOB oid_blob = data_blob_const(r->binary_oid, r->length);
     78                char *hex_str = data_blob_hex_string_upper(ndr, &oid_blob);
     79                ber_read_partial_OID_String(ndr, oid_blob, &partial_oid);
     80                ndr->depth++;
     81                ndr->print(ndr, "%-25s: 0x%s (%s)", "binary_oid", hex_str, partial_oid);
     82                ndr->depth--;
     83                talloc_free(hex_str);
     84                talloc_free(partial_oid);
     85        }
     86        ndr->depth--;
     87}
     88
     89static void _print_drsuapi_DsAttributeValue_attid(struct ndr_print *ndr, const char *name,
     90                                                  const struct drsuapi_DsAttributeValue *r)
     91{
     92        uint32_t v;
     93
     94        ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
     95        ndr->depth++;
     96        v = IVAL(r->blob->data, 0);
     97        ndr_print_uint32(ndr, "attid", v);
     98        ndr->depth--;
     99}
     100
     101static void _print_drsuapi_DsAttributeValue_str(struct ndr_print *ndr, const char *name,
     102                                                const struct drsuapi_DsAttributeValue *r)
     103{
     104        char *str;
     105
     106        ndr_print_struct(ndr, name, "drsuapi_DsAttributeValue");
     107        ndr->depth++;
     108        if (!convert_string_talloc(ndr,
     109                                   CH_UTF16, CH_UNIX,
     110                                   r->blob->data,
     111                                   r->blob->length,
     112                                   (void **)&str, NULL, false)) {
     113                ndr_print_string(ndr, "string", "INVALID CONVERSION");
    174114        } else {
    175                 if (ber_write_OID_String(&_blob, oid)) {
    176                         ret = _blob.length;
    177                 }
    178         }
    179         data_blob_free(&_blob);
    180         return ret;
     115                ndr_print_string(ndr, "string", str);
     116                talloc_free(str);
     117        }
     118        ndr->depth--;
     119}
     120
     121static void _print_drsuapi_DsAttributeValueCtr(struct ndr_print *ndr,
     122                                               const char *name,
     123                                               const struct drsuapi_DsAttributeValueCtr *r,
     124                                               void (*print_val_fn)(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAttributeValue *r))
     125{
     126        uint32_t cntr_values_1;
     127        ndr_print_struct(ndr, name, "drsuapi_DsAttributeValueCtr");
     128        ndr->depth++;
     129        ndr_print_uint32(ndr, "num_values", r->num_values);
     130        ndr_print_ptr(ndr, "values", r->values);
     131        ndr->depth++;
     132        if (r->values) {
     133                ndr->print(ndr, "%s: ARRAY(%d)", "values", (int)r->num_values);
     134                ndr->depth++;
     135                for (cntr_values_1=0;cntr_values_1<r->num_values;cntr_values_1++) {
     136                        char *idx_1=NULL;
     137                        if (asprintf(&idx_1, "[%d]", cntr_values_1) != -1) {
     138                                //ndr_print_drsuapi_DsAttributeValue(ndr, "values", &r->values[cntr_values_1]);
     139                                print_val_fn(ndr, "values", &r->values[cntr_values_1]);
     140                                free(idx_1);
     141                        }
     142                }
     143                ndr->depth--;
     144        }
     145        ndr->depth--;
     146        ndr->depth--;
     147}
     148
     149_PUBLIC_ void ndr_print_drsuapi_DsReplicaAttribute(struct ndr_print *ndr,
     150                                                   const char *name,
     151                                                   const struct drsuapi_DsReplicaAttribute *r)
     152{
     153        ndr_print_struct(ndr, name, "drsuapi_DsReplicaAttribute");
     154        ndr->depth++;
     155        ndr_print_drsuapi_DsAttributeId(ndr, "attid", r->attid);
     156        switch (r->attid) {
     157        case DRSUAPI_ATTID_objectClass:
     158        case DRSUAPI_ATTID_possSuperiors:
     159        case DRSUAPI_ATTID_subClassOf:
     160        case DRSUAPI_ATTID_governsID:
     161        case DRSUAPI_ATTID_mustContain:
     162        case DRSUAPI_ATTID_mayContain:
     163        case DRSUAPI_ATTID_rDNAttId:
     164        case DRSUAPI_ATTID_attributeID:
     165        case DRSUAPI_ATTID_attributeSyntax:
     166        case DRSUAPI_ATTID_auxiliaryClass:
     167        case DRSUAPI_ATTID_systemPossSuperiors:
     168        case DRSUAPI_ATTID_systemMayContain:
     169        case DRSUAPI_ATTID_systemMustContain:
     170        case DRSUAPI_ATTID_systemAuxiliaryClass:
     171        case DRSUAPI_ATTID_transportAddressAttribute:
     172                /* ATTIDs for classSchema and attributeSchema */
     173                _print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr,
     174                                                   _print_drsuapi_DsAttributeValue_attid);
     175                break;
     176        case DRSUAPI_ATTID_cn:
     177        case DRSUAPI_ATTID_ou:
     178        case DRSUAPI_ATTID_description:
     179        case DRSUAPI_ATTID_displayName:
     180        case DRSUAPI_ATTID_dMDLocation:
     181        case DRSUAPI_ATTID_adminDisplayName:
     182        case DRSUAPI_ATTID_adminDescription:
     183        case DRSUAPI_ATTID_lDAPDisplayName:
     184        case DRSUAPI_ATTID_name:
     185                _print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr,
     186                                                   _print_drsuapi_DsAttributeValue_str);
     187                break;
     188        default:
     189                _print_drsuapi_DsAttributeValueCtr(ndr, "value_ctr", &r->value_ctr,
     190                                                   ndr_print_drsuapi_DsAttributeValue);
     191                break;
     192        }
     193        ndr->depth--;
    181194}
    182195
    … …  
    353366}
    354367
    355 _PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(const struct drsuapi_DsReplicaObjectIdentifier3Binary *r, struct smb_iconv_convenience *ic, int flags)
    356 {
    357         return ndr_size_struct((const struct drsuapi_DsReplicaObjectIdentifier3 *)r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3, ic);
    358 }
    359 
     368_PUBLIC_ size_t ndr_size_drsuapi_DsReplicaObjectIdentifier3Binary_without_Binary(const struct drsuapi_DsReplicaObjectIdentifier3Binary *r, int flags)
     369{
     370        return ndr_size_struct((const struct drsuapi_DsReplicaObjectIdentifier3 *)r, flags, (ndr_push_flags_fn_t)ndr_push_drsuapi_DsReplicaObjectIdentifier3);
     371}
     372
     373_PUBLIC_ void ndr_print_drsuapi_SecBufferType(struct ndr_print *ndr, const char *name, enum drsuapi_SecBufferType r)
     374{
     375        const char *val = NULL;
     376
     377        switch (r & 0x00000007) {
     378                case DRSUAPI_SECBUFFER_EMPTY: val = "DRSUAPI_SECBUFFER_EMPTY"; break;
     379                case DRSUAPI_SECBUFFER_DATA: val = "DRSUAPI_SECBUFFER_DATA"; break;
     380                case DRSUAPI_SECBUFFER_TOKEN: val = "DRSUAPI_SECBUFFER_TOKEN"; break;
     381                case DRSUAPI_SECBUFFER_PKG_PARAMS: val = "DRSUAPI_SECBUFFER_PKG_PARAMS"; break;
     382                case DRSUAPI_SECBUFFER_MISSING: val = "DRSUAPI_SECBUFFER_MISSING"; break;
     383                case DRSUAPI_SECBUFFER_EXTRA: val = "DRSUAPI_SECBUFFER_EXTRA"; break;
     384                case DRSUAPI_SECBUFFER_STREAM_TRAILER: val = "DRSUAPI_SECBUFFER_STREAM_TRAILER"; break;
     385                case DRSUAPI_SECBUFFER_STREAM_HEADER: val = "DRSUAPI_SECBUFFER_STREAM_HEADER"; break;
     386        }
     387
     388        if (r & DRSUAPI_SECBUFFER_READONLY) {
     389                char *v = talloc_asprintf(ndr, "DRSUAPI_SECBUFFER_READONLY | %s", val);
     390                ndr_print_enum(ndr, name, "ENUM", v, r);
     391        } else {
     392                ndr_print_enum(ndr, name, "ENUM", val, r);
     393        }
     394}
     395
     396_PUBLIC_ void ndr_print_drsuapi_DsAddEntry_AttrErrListItem_V1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsAddEntry_AttrErrListItem_V1 *r)
     397{
     398        ndr_print_struct(ndr, name, "drsuapi_DsAddEntry_AttrErrListItem_V1");
     399        ndr->depth++;
     400        ndr_print_ptr(ndr, "next", r->next);
     401        ndr_print_drsuapi_DsAddEntry_AttrErr_V1(ndr, "err_data", &r->err_data);
     402        ndr->depth--;
     403        if (r->next) {
     404                ndr_print_drsuapi_DsAddEntry_AttrErrListItem_V1(ndr, "next", r->next);
     405        }
     406}
Note: See TracChangeset for help on using the changeset viewer.