source4/torture/rpc/dsgetinfo.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    DsGetReplInfo test. Based on code from dssync.c
   5
   6    Copyright (C) Erick Nogueira do Nascimento 2009
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "lib/cmdline/popt_common.h"
  24 #include "librpc/gen_ndr/ndr_drsuapi_c.h"
  25 #include "librpc/gen_ndr/ndr_drsblobs.h"
  26 #include "libcli/cldap/cldap.h"
  27 #include "torture/torture.h"
  28 #include "../libcli/drsuapi/drsuapi.h"
  29 #include "auth/gensec/gensec.h"
  30 #include "param/param.h"
  31 #include "dsdb/samdb/samdb.h"
  32 #include "lib/ldb_wrap.h"
  33 #include "torture/rpc/rpc.h"
  34 #include "torture/drs/proto.h"
  35
  36
  37 struct DsGetinfoBindInfo {
  38         struct dcerpc_pipe *drs_pipe;
  39         struct drsuapi_DsBind req;
  40         struct GUID bind_guid;
  41         struct drsuapi_DsBindInfoCtr our_bind_info_ctr;
  42         struct drsuapi_DsBindInfo28 our_bind_info28;
  43         struct drsuapi_DsBindInfo28 peer_bind_info28;
  44         struct policy_handle bind_handle;
  45 };
  46
  47 struct DsGetinfoTest {
  48         struct dcerpc_binding *drsuapi_binding;
  49
  50         const char *ldap_url;
  51         const char *site_name;
  52
  53         const char *domain_dn;
  54
  55         /* what we need to do as 'Administrator' */
  56         struct {
  57                 struct cli_credentials *credentials;
  58                 struct DsGetinfoBindInfo drsuapi;
  59         } admin;
  60 };
  61
  62 static struct DsGetinfoTest *test_create_context(struct torture_context *tctx)
  63 {
  64         NTSTATUS status;
  65         struct DsGetinfoTest *ctx;
  66         struct drsuapi_DsBindInfo28 *our_bind_info28;
  67         struct drsuapi_DsBindInfoCtr *our_bind_info_ctr;
  68         const char *binding = torture_setting_string(tctx, "binding", NULL);
  69         ctx = talloc_zero(tctx, struct DsGetinfoTest);
  70         if (!ctx) return NULL;
  71
  72         status = dcerpc_parse_binding(ctx, binding, &ctx->drsuapi_binding);
  73         if (!NT_STATUS_IS_OK(status)) {
  74                 printf("Bad binding string %s\n", binding);
  75                 return NULL;
  76         }
  77         ctx->drsuapi_binding->flags |= DCERPC_SIGN | DCERPC_SEAL;
  78
  79         /* ctx->admin ...*/
  80         ctx->admin.credentials                          = cmdline_credentials;
  81
  82         our_bind_info28                         = &ctx->admin.drsuapi.our_bind_info28;
  83         our_bind_info28->supported_extensions   = 0xFFFFFFFF;
  84         our_bind_info28->supported_extensions   |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3;
  85         our_bind_info28->site_guid              = GUID_zero();
  86         our_bind_info28->pid                    = 0;
  87         our_bind_info28->repl_epoch             = 1;
  88
  89         our_bind_info_ctr                       = &ctx->admin.drsuapi.our_bind_info_ctr;
  90         our_bind_info_ctr->length               = 28;
  91         our_bind_info_ctr->info.info28          = *our_bind_info28;
  92
  93         GUID_from_string(DRSUAPI_DS_BIND_GUID, &ctx->admin.drsuapi.bind_guid);
  94
  95         ctx->admin.drsuapi.req.in.bind_guid             = &ctx->admin.drsuapi.bind_guid;
  96         ctx->admin.drsuapi.req.in.bind_info             = our_bind_info_ctr;
  97         ctx->admin.drsuapi.req.out.bind_handle          = &ctx->admin.drsuapi.bind_handle;
  98
  99         return ctx;
 100 }
 101
 102 static bool _test_DsBind(struct torture_context *tctx,
 103                          struct DsGetinfoTest *ctx, struct cli_credentials *credentials, struct DsGetinfoBindInfo *b)
 104 {
 105         NTSTATUS status;
 106         bool ret = true;
 107
 108         status = dcerpc_pipe_connect_b(ctx,
 109                                        &b->drs_pipe, ctx->drsuapi_binding,
 110                                        &ndr_table_drsuapi,
 111                                        credentials, tctx->ev, tctx->lp_ctx);
 112
 113         if (!NT_STATUS_IS_OK(status)) {
 114                 printf("Failed to connect to server as a BDC: %s\n", nt_errstr(status));
 115                 return false;
 116         }
 117
 118         status = dcerpc_drsuapi_DsBind(b->drs_pipe, ctx, &b->req);
 119         if (!NT_STATUS_IS_OK(status)) {
 120                 const char *errstr = nt_errstr(status);
 121                 if (NT_STATUS_EQUAL(status, NT_STATUS_NET_WRITE_FAULT)) {
 122                         errstr = dcerpc_errstr(ctx, b->drs_pipe->last_fault_code);
 123                 }
 124                 printf("dcerpc_drsuapi_DsBind failed - %s\n", errstr);
 125                 ret = false;
 126         } else if (!W_ERROR_IS_OK(b->req.out.result)) {
 127                 printf("DsBind failed - %s\n", win_errstr(b->req.out.result));
 128                 ret = false;
 129         }
 130
 131         ZERO_STRUCT(b->peer_bind_info28);
 132         if (b->req.out.bind_info) {
 133                 switch (b->req.out.bind_info->length) {
 134                 case 24: {
 135                         struct drsuapi_DsBindInfo24 *info24;
 136                         info24 = &b->req.out.bind_info->info.info24;
 137                         b->peer_bind_info28.supported_extensions= info24->supported_extensions;
 138                         b->peer_bind_info28.site_guid           = info24->site_guid;
 139                         b->peer_bind_info28.pid                 = info24->pid;
 140                         b->peer_bind_info28.repl_epoch          = 0;
 141                         break;
 142                 }
 143                 case 48: {
 144                         struct drsuapi_DsBindInfo48 *info48;
 145                         info48 = &b->req.out.bind_info->info.info48;
 146                         b->peer_bind_info28.supported_extensions= info48->supported_extensions;
 147                         b->peer_bind_info28.site_guid           = info48->site_guid;
 148                         b->peer_bind_info28.pid                 = info48->pid;
 149                         b->peer_bind_info28.repl_epoch          = info48->repl_epoch;
 150                         break;
 151                 }
 152                 case 28:
 153                         b->peer_bind_info28 = b->req.out.bind_info->info.info28;
 154                         break;
 155                 default:
 156                         printf("DsBind - warning: unknown BindInfo length: %u\n",
 157                                b->req.out.bind_info->length);
 158                 }
 159         }
 160
 161         return ret;
 162 }
 163
 164
 165 static bool test_getinfo(struct torture_context *tctx,
 166                          struct DsGetinfoTest *ctx)
 167 {
 168         NTSTATUS status;
 169         struct dcerpc_pipe *p = ctx->admin.drsuapi.drs_pipe;
 170         struct drsuapi_DsReplicaGetInfo r;
 171         union drsuapi_DsReplicaGetInfoRequest req;
 172         union drsuapi_DsReplicaInfo info;
 173         enum drsuapi_DsReplicaInfoType info_type;
 174         int i;
 175         int invalid_levels = 0;
 176         struct {
 177                 int32_t level;
 178                 int32_t infotype;
 179                 const char *obj_dn;
 180         } array[] = {
 181                 {
 182                         DRSUAPI_DS_REPLICA_GET_INFO,
 183                         DRSUAPI_DS_REPLICA_INFO_NEIGHBORS,
 184                         NULL
 185                 },{
 186                         DRSUAPI_DS_REPLICA_GET_INFO,
 187                         DRSUAPI_DS_REPLICA_INFO_CURSORS,
 188                         NULL
 189                 },{
 190                         DRSUAPI_DS_REPLICA_GET_INFO,
 191                         DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA,
 192                         NULL
 193                 },{
 194                         DRSUAPI_DS_REPLICA_GET_INFO,
 195                         DRSUAPI_DS_REPLICA_INFO_KCC_DSA_CONNECT_FAILURES,
 196                         NULL
 197                 },{
 198                         DRSUAPI_DS_REPLICA_GET_INFO,
 199                         DRSUAPI_DS_REPLICA_INFO_KCC_DSA_LINK_FAILURES,
 200                         NULL
 201                 },{
 202                         DRSUAPI_DS_REPLICA_GET_INFO,
 203                         DRSUAPI_DS_REPLICA_INFO_PENDING_OPS,
 204                         NULL
 205                 },{
 206                         DRSUAPI_DS_REPLICA_GET_INFO2,
 207                         DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA,
 208                         NULL
 209                 },{
 210                         DRSUAPI_DS_REPLICA_GET_INFO2,
 211                         DRSUAPI_DS_REPLICA_INFO_CURSORS2,
 212                         NULL
 213                 },{
 214                         DRSUAPI_DS_REPLICA_GET_INFO2,
 215                         DRSUAPI_DS_REPLICA_INFO_CURSORS3,
 216                         NULL
 217                 },{
 218                         DRSUAPI_DS_REPLICA_GET_INFO2,
 219                         DRSUAPI_DS_REPLICA_INFO_OBJ_METADATA2,
 220                         NULL
 221                 },{
 222                         DRSUAPI_DS_REPLICA_GET_INFO2,
 223                         DRSUAPI_DS_REPLICA_INFO_ATTRIBUTE_VALUE_METADATA2,
 224                         NULL
 225                 },{
 226                         DRSUAPI_DS_REPLICA_GET_INFO2,
 227                         DRSUAPI_DS_REPLICA_INFO_REPSTO,
 228                         NULL
 229                 },{
 230                         DRSUAPI_DS_REPLICA_GET_INFO2,
 231                         DRSUAPI_DS_REPLICA_INFO_CLIENT_CONTEXTS,
 232                         "__IGNORED__"
 233                 },{
 234                         DRSUAPI_DS_REPLICA_GET_INFO2,
 235                         DRSUAPI_DS_REPLICA_INFO_UPTODATE_VECTOR_V1,
 236                         NULL
 237                 },{
 238                         DRSUAPI_DS_REPLICA_GET_INFO2,
 239                         DRSUAPI_DS_REPLICA_INFO_SERVER_OUTGOING_CALLS,
 240                         NULL
 241                 }
 242         };
 243
 244         if (torture_setting_bool(tctx, "samba4", false)) {
 245                 torture_comment(tctx, "skipping DsReplicaGetInfo test against Samba4\n");
 246                 return true;
 247         }
 248
 249         r.in.bind_handle        = &ctx->admin.drsuapi.bind_handle;
 250         r.in.req                = &req;
 251
 252         for (i=0; i < ARRAY_SIZE(array); i++) {
 253                 const char *object_dn;
 254
 255                 torture_comment(tctx, "testing DsReplicaGetInfo level %d infotype %d\n",
 256                                 array[i].level, array[i].infotype);
 257
 258                 object_dn = (array[i].obj_dn ? array[i].obj_dn : ctx->domain_dn);
 259
 260                 r.in.level = array[i].level;
 261                 switch(r.in.level) {
 262                 case DRSUAPI_DS_REPLICA_GET_INFO:
 263                         r.in.req->req1.info_type        = array[i].infotype;
 264                         r.in.req->req1.object_dn        = object_dn;
 265                         ZERO_STRUCT(r.in.req->req1.source_dsa_guid);
 266                         break;
 267                 case DRSUAPI_DS_REPLICA_GET_INFO2:
 268                         r.in.req->req2.info_type        = array[i].infotype;
 269                         r.in.req->req2.object_dn        = object_dn;
 270                         ZERO_STRUCT(r.in.req->req2.source_dsa_guid);
 271                         r.in.req->req2.flags    = 0;
 272                         r.in.req->req2.string1  = NULL;
 273                         r.in.req->req2.string2  = NULL;
 274                         r.in.req->req2.enumeration_context = 0;
 275                         break;
 276                 }
 277
 278                 r.out.info              = &info;
 279                 r.out.info_type         = &info_type;
 280
 281                 status = dcerpc_drsuapi_DsReplicaGetInfo(p, tctx, &r);
 282
 283                 if (W_ERROR_EQUAL(r.out.result, WERR_INVALID_LEVEL)) {
 284                         /* this is a not yet supported level */
 285                         torture_comment(tctx,
 286                                         "DsReplicaGetInfo level %d and/or infotype %d not yet supported by server\n",
 287                                         array[i].level, array[i].infotype);
 288                         invalid_levels++;
 289                 } else if (!NT_STATUS_IS_OK(status) && p->last_fault_code == DCERPC_FAULT_INVALID_TAG) {
 290                         torture_comment(tctx,
 291                                         "DsReplicaGetInfo level %d and/or infotype %d not supported by server\n",
 292                                         array[i].level, array[i].infotype);
 293                 }/* else {
 294                         torture_drsuapi_assert_call(tctx, p, status, &r, "dcerpc_drsuapi_DsReplicaGetInfo");
 295                 }*/
 296         }
 297
 298         if (invalid_levels > 0) {
 299                 return false;
 300         }
 301
 302         return true;
 303 }
 304
 305 /**
 306  * DSGETINFO test case setup
 307  */
 308 static bool torture_dsgetinfo_tcase_setup(struct torture_context *tctx, void **data)
 309 {
 310         bool bret;
 311         struct DsGetinfoTest *ctx;
 312
 313         *data = ctx = test_create_context(tctx);
 314         torture_assert(tctx, ctx, "test_create_context() failed");
 315
 316         bret = _test_DsBind(tctx, ctx, ctx->admin.credentials, &ctx->admin.drsuapi);
 317         torture_assert(tctx, bret, "_test_DsBind() failed");
 318
 319         return true;
 320 }
 321
 322 /**
 323  * DSGETINFO test case cleanup
 324  */
 325 static bool torture_dsgetinfo_tcase_teardown(struct torture_context *tctx, void *data)
 326 {
 327         struct DsGetinfoTest *ctx;
 328         struct drsuapi_DsUnbind r;
 329         struct policy_handle bind_handle;
 330
 331         ctx = talloc_get_type(data, struct DsGetinfoTest);
 332
 333         ZERO_STRUCT(r);
 334         r.out.bind_handle = &bind_handle;
 335
 336         /* Unbing admin handle */
 337         r.in.bind_handle = &ctx->admin.drsuapi.bind_handle;
 338         dcerpc_drsuapi_DsUnbind(ctx->admin.drsuapi.drs_pipe, ctx, &r);
 339
 340         talloc_free(ctx);
 341
 342         return true;
 343 }
 344
 345 /**
 346  * DSGETINFO test case implementation
 347  */
 348 void torture_drs_rpc_dsgetinfo_tcase(struct torture_suite *suite)
 349 {
 350         typedef bool (*run_func) (struct torture_context *test, void *tcase_data);
 351
 352         struct torture_test *test;
 353         struct torture_tcase *tcase = torture_suite_add_tcase(suite, "DSGETINFO");
 354
 355         torture_tcase_set_fixture(tcase,
 356                                   torture_dsgetinfo_tcase_setup,
 357                                   torture_dsgetinfo_tcase_teardown);
 358
 359         test = torture_tcase_add_simple_test(tcase, "DsGetReplicaInfo", (run_func)test_getinfo);
 360 }
 361