nsswitch/libwbclient/tests/wbclient.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    SMB torture tester
   4    Copyright (C) Guenther Deschner 2009-2010
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "includes.h"
  21 #include "nsswitch/libwbclient/wbclient.h"
  22 #include "nsswitch/libwbclient/wbc_async.h"
  23 #include "torture/smbtorture.h"
  24 #include "torture/winbind/proto.h"
  25 #include "lib/util/util_net.h"
  26
  27 #define WBC_ERROR_EQUAL(x,y) (x == y)
  28
  29 #define torture_assert_wbc_equal(torture_ctx, got, expected, cmt) \
  30         do { wbcErr __got = got, __expected = expected; \
  31         if (!WBC_ERROR_EQUAL(__got, __expected)) { \
  32                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: %s", wbcErrorString(__got), wbcErrorString(__expected), cmt); \
  33                 return false; \
  34         } \
  35         } while (0)
  36
  37 #define torture_assert_wbc_ok(torture_ctx,expr,cmt) \
  38                 torture_assert_wbc_equal(torture_ctx,expr,WBC_ERR_SUCCESS,cmt)
  39
  40
  41 static void wbc_debug_torture(void *private_data, enum wbcDebugLevel level,
  42                               const char *fmt, va_list ap) PRINTF_ATTRIBUTE(3,0);
  43 static void wbc_debug_torture(void *private_data, enum wbcDebugLevel level,
  44                               const char *fmt, va_list ap)
  45 {
  46         struct torture_context *tctx = talloc_get_type_abort(private_data,
  47                                         struct torture_context);
  48         torture_comment(tctx, "%s", talloc_vasprintf(tctx, fmt, ap));
  49 }
  50
  51 static bool test_wbc_ping(struct torture_context *tctx)
  52 {
  53         torture_assert_wbc_ok(tctx, wbcPing(),
  54                 "wbcPing failed");
  55
  56         return true;
  57 }
  58
  59 static bool test_wbc_ping_async(struct torture_context *tctx)
  60 {
  61         struct wb_context *wb_ctx;
  62         struct tevent_req *req;
  63
  64         wb_ctx = wb_context_init(tctx, NULL);
  65
  66         req = wbcPing_send(tctx, tctx->ev, wb_ctx);
  67         torture_assert(tctx, req, "wbcPing_send failed");
  68
  69         if(!tevent_req_poll(req, tctx->ev)) {
  70                 return false;
  71         }
  72         torture_assert_wbc_ok(tctx, wbcPing_recv(req), "wbcPing_recv failed");
  73         return true;
  74 }
  75
  76
  77 static bool test_wbc_pingdc(struct torture_context *tctx)
  78 {
  79         torture_assert_wbc_equal(tctx, wbcPingDc("random_string", NULL), WBC_ERR_NOT_IMPLEMENTED,
  80                 "wbcPingDc failed");
  81         torture_assert_wbc_ok(tctx, wbcPingDc(NULL, NULL),
  82                 "wbcPingDc failed");
  83
  84         return true;
  85 }
  86
  87 static bool test_wbc_library_details(struct torture_context *tctx)
  88 {
  89         struct wbcLibraryDetails *details;
  90
  91         torture_assert_wbc_ok(tctx, wbcLibraryDetails(&details),
  92                 "wbcLibraryDetails failed");
  93         torture_assert(tctx, details,
  94                 "wbcLibraryDetails returned NULL pointer");
  95
  96         wbcFreeMemory(details);
  97
  98         return true;
  99 }
 100
 101 static bool test_wbc_interface_details(struct torture_context *tctx)
 102 {
 103         struct wbcInterfaceDetails *details;
 104
 105         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
 106                 "wbcInterfaceDetails failed");
 107         torture_assert(tctx, details,
 108                 "wbcInterfaceDetails returned NULL pointer");
 109
 110         wbcFreeMemory(details);
 111
 112         return true;
 113 }
 114
 115 static bool test_wbc_sidtypestring(struct torture_context *tctx)
 116 {
 117         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_USE_NONE),
 118                                  "SID_NONE", "SID_NONE failed");
 119         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_USER),
 120                                  "SID_USER", "SID_USER failed");
 121         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_DOM_GRP),
 122                                  "SID_DOM_GROUP", "SID_DOM_GROUP failed");
 123         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_DOMAIN),
 124                                  "SID_DOMAIN", "SID_DOMAIN failed");
 125         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_ALIAS),
 126                                  "SID_ALIAS", "SID_ALIAS failed");
 127         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_WKN_GRP),
 128                                  "SID_WKN_GROUP", "SID_WKN_GROUP failed");
 129         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_DELETED),
 130                                  "SID_DELETED", "SID_DELETED failed");
 131         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_INVALID),
 132                                  "SID_INVALID", "SID_INVALID failed");
 133         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_UNKNOWN),
 134                                  "SID_UNKNOWN", "SID_UNKNOWN failed");
 135         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_COMPUTER),
 136                                  "SID_COMPUTER", "SID_COMPUTER failed");
 137         return true;
 138 }
 139
 140 static bool test_wbc_sidtostring(struct torture_context *tctx)
 141 {
 142         struct wbcDomainSid sid;
 143         const char *sid_string = "S-1-5-32";
 144         char *sid_string2;
 145
 146         torture_assert_wbc_ok(tctx, wbcStringToSid(sid_string, &sid),
 147                 "wbcStringToSid failed");
 148         torture_assert_wbc_ok(tctx, wbcSidToString(&sid, &sid_string2),
 149                 "wbcSidToString failed");
 150         torture_assert_str_equal(tctx, sid_string, sid_string2,
 151                 "sid strings differ");
 152         wbcFreeMemory(sid_string2);
 153
 154         return true;
 155 }
 156
 157 static bool test_wbc_guidtostring(struct torture_context *tctx)
 158 {
 159         struct wbcGuid guid;
 160         const char *guid_string = "f7cf07b4-1487-45c7-824d-8b18cc580811";
 161         char *guid_string2;
 162
 163         torture_assert_wbc_ok(tctx, wbcStringToGuid(guid_string, &guid),
 164                 "wbcStringToGuid failed");
 165         torture_assert_wbc_ok(tctx, wbcGuidToString(&guid, &guid_string2),
 166                 "wbcGuidToString failed");
 167         torture_assert_str_equal(tctx, guid_string, guid_string2,
 168                 "guid strings differ");
 169         wbcFreeMemory(guid_string2);
 170
 171         return true;
 172 }
 173
 174 static bool test_wbc_domain_info(struct torture_context *tctx)
 175 {
 176         struct wbcDomainInfo *info;
 177         struct wbcInterfaceDetails *details;
 178
 179         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
 180                 "wbcInterfaceDetails failed");
 181         torture_assert_wbc_ok(
 182                 tctx, wbcDomainInfo(details->netbios_domain, &info),
 183                 "wbcDomainInfo failed");
 184         wbcFreeMemory(details);
 185
 186         torture_assert(tctx, info,
 187                 "wbcDomainInfo returned NULL pointer");
 188         wbcFreeMemory(info);
 189
 190         return true;
 191 }
 192
 193 static bool test_wbc_users(struct torture_context *tctx)
 194 {
 195         const char *domain_name = NULL;
 196         uint32_t num_users;
 197         const char **users;
 198         int i;
 199         struct wbcInterfaceDetails *details;
 200
 201         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
 202                 "wbcInterfaceDetails failed");
 203
 204         domain_name = talloc_strdup(tctx, details->netbios_domain);
 205         wbcFreeMemory(details);
 206
 207         torture_assert_wbc_ok(tctx, wbcListUsers(domain_name, &num_users, &users),
 208                 "wbcListUsers failed");
 209         torture_assert(tctx, !(num_users > 0 && !users),
 210                 "wbcListUsers returned invalid results");
 211
 212         for (i=0; i < MIN(num_users,100); i++) {
 213
 214                 struct wbcDomainSid sid, *sids;
 215                 enum wbcSidType name_type;
 216                 char *domain;
 217                 char *name;
 218                 uint32_t num_sids;
 219
 220                 torture_assert_wbc_ok(tctx, wbcLookupName(domain_name, users[i], &sid, &name_type),
 221                         "wbcLookupName failed");
 222                 torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_USER,
 223                         "wbcLookupName expected WBC_SID_NAME_USER");
 224                 torture_assert_wbc_ok(tctx, wbcLookupSid(&sid, &domain, &name, &name_type),
 225                         "wbcLookupSid failed");
 226                 torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_USER,
 227                         "wbcLookupSid expected WBC_SID_NAME_USER");
 228                 torture_assert(tctx, name,
 229                         "wbcLookupSid returned no name");
 230                 wbcFreeMemory(domain);
 231                 wbcFreeMemory(name);
 232                 torture_assert_wbc_ok(tctx, wbcLookupUserSids(&sid, true, &num_sids, &sids),
 233                         "wbcLookupUserSids failed");
 234                 torture_assert_wbc_ok(
 235                         tctx, wbcGetDisplayName(&sid, &domain, &name,
 236                                                 &name_type),
 237                         "wbcGetDisplayName failed");
 238                 wbcFreeMemory(domain);
 239                 wbcFreeMemory(name);
 240                 wbcFreeMemory(sids);
 241         }
 242         wbcFreeMemory(users);
 243
 244         return true;
 245 }
 246
 247 static bool test_wbc_users_async(struct torture_context *tctx)
 248 {
 249         struct wb_context *wb_ctx;
 250         struct tevent_req *req;
 251         const char *domain_name = NULL;
 252         uint32_t num_users;
 253         const char **users;
 254         int i;
 255         struct wbcInterfaceDetails *details;
 256
 257         wb_ctx = wb_context_init(tctx, NULL);
 258         wbcSetDebug(wb_ctx, wbc_debug_torture, tctx);
 259
 260         req = wbcInterfaceDetails_send(tctx, tctx->ev, wb_ctx);
 261         torture_assert(tctx, req, "wbcInterfaceDetails_send failed");
 262
 263         if(!tevent_req_poll(req, tctx->ev)) {
 264                 return false;
 265         }
 266         torture_assert_wbc_ok(tctx,
 267                               wbcInterfaceDetails_recv(req, tctx, &details),
 268                               "wbcInterfaceDetails_recv failed");
 269
 270         domain_name = talloc_strdup(tctx, details->netbios_domain);
 271         wbcFreeMemory(details);
 272
 273         /* No async implementation of this yet. */
 274         torture_assert_wbc_ok(tctx, wbcListUsers(domain_name, &num_users, &users),
 275                 "wbcListUsers failed");
 276         torture_assert(tctx, !(num_users > 0 && !users),
 277                 "wbcListUsers returned invalid results");
 278
 279         for (i=0; i < MIN(num_users,100); i++) {
 280
 281                 struct wbcDomainSid sid, *sids;
 282                 enum wbcSidType name_type;
 283                 char *domain;
 284                 char *name;
 285                 uint32_t num_sids;
 286
 287                 req = wbcLookupName_send(tctx, tctx->ev, wb_ctx, domain_name,
 288                                          users[i]);
 289                 torture_assert(tctx, req, "wbcLookupName_send failed");
 290
 291                 if(!tevent_req_poll(req, tctx->ev)) {
 292                         return false;
 293                 }
 294
 295                 torture_assert_wbc_ok(tctx,
 296                                       wbcLookupName_recv(req, &sid, &name_type),
 297                                       "wbcLookupName_recv failed");
 298
 299                 torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_USER,
 300                         "wbcLookupName expected WBC_SID_NAME_USER");
 301                 torture_assert_wbc_ok(tctx, wbcLookupSid(&sid, &domain, &name, &name_type),
 302                         "wbcLookupSid failed");
 303                 torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_USER,
 304                         "wbcLookupSid expected WBC_SID_NAME_USER");
 305                 torture_assert(tctx, name,
 306                         "wbcLookupSid returned no name");
 307                 wbcFreeMemory(domain);
 308                 wbcFreeMemory(name);
 309                 torture_assert_wbc_ok(tctx, wbcLookupUserSids(&sid, true, &num_sids, &sids),
 310                         "wbcLookupUserSids failed");
 311                 wbcFreeMemory(sids);
 312         }
 313         wbcFreeMemory(users);
 314
 315         return true;
 316 }
 317
 318 static bool test_wbc_groups(struct torture_context *tctx)
 319 {
 320         const char *domain_name = NULL;
 321         uint32_t num_groups;
 322         const char **groups;
 323         int i;
 324         struct wbcInterfaceDetails *details;
 325
 326         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
 327                 "wbcInterfaceDetails failed");
 328
 329         domain_name = talloc_strdup(tctx, details->netbios_domain);
 330         wbcFreeMemory(details);
 331
 332         torture_assert_wbc_ok(tctx, wbcListGroups(domain_name, &num_groups, &groups),
 333                 "wbcListGroups failed");
 334         torture_assert(tctx, !(num_groups > 0 && !groups),
 335                 "wbcListGroups returned invalid results");
 336
 337         for (i=0; i < MIN(num_groups,100); i++) {
 338
 339                 struct wbcDomainSid sid;
 340                 enum wbcSidType name_type;
 341                 char *domain;
 342                 char *name;
 343
 344                 torture_assert_wbc_ok(tctx, wbcLookupName(domain_name, groups[i], &sid, &name_type),
 345                         "wbcLookupName failed");
 346                 torture_assert_wbc_ok(tctx, wbcLookupSid(&sid, &domain, &name, &name_type),
 347                         "wbcLookupSid failed");
 348                 torture_assert(tctx, name,
 349                         "wbcLookupSid returned no name");
 350         }
 351         wbcFreeMemory(groups);
 352
 353         return true;
 354 }
 355
 356 static bool test_wbc_trusts(struct torture_context *tctx)
 357 {
 358         struct wbcDomainInfo *domains;
 359         size_t num_domains;
 360         int i;
 361
 362         torture_assert_wbc_ok(tctx, wbcListTrusts(&domains, &num_domains),
 363                 "wbcListTrusts failed");
 364         torture_assert(tctx, !(num_domains > 0 && !domains),
 365                 "wbcListTrusts returned invalid results");
 366
 367         for (i=0; i < MIN(num_domains,100); i++) {
 368
 369                 struct wbcAuthErrorInfo *error;
 370                 /*
 371                 struct wbcDomainSid sid;
 372                 enum wbcSidType name_type;
 373                 char *domain;
 374                 char *name;
 375                 */
 376                 torture_assert_wbc_ok(tctx, wbcCheckTrustCredentials(domains[i].short_name, &error),
 377                         "wbcCheckTrustCredentials failed");
 378                 /*
 379                 torture_assert_wbc_ok(tctx, wbcLookupName(domains[i].short_name, NULL, &sid, &name_type),
 380                         "wbcLookupName failed");
 381                 torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_DOMAIN,
 382                         "wbcLookupName expected WBC_SID_NAME_DOMAIN");
 383                 torture_assert_wbc_ok(tctx, wbcLookupSid(&sid, &domain, &name, &name_type),
 384                         "wbcLookupSid failed");
 385                 torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_DOMAIN,
 386                         "wbcLookupSid expected WBC_SID_NAME_DOMAIN");
 387                 torture_assert(tctx, name,
 388                         "wbcLookupSid returned no name");
 389                 */
 390         }
 391         wbcFreeMemory(domains);
 392
 393         return true;
 394 }
 395
 396 static bool test_wbc_lookupdc(struct torture_context *tctx)
 397 {
 398         const char *domain_name = NULL;
 399         struct wbcInterfaceDetails *details;
 400         struct wbcDomainControllerInfo *dc_info;
 401
 402         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
 403                 "wbcInterfaceDetails failed");
 404
 405         domain_name = talloc_strdup(tctx, details->netbios_domain);
 406         wbcFreeMemory(details);
 407
 408         torture_assert_wbc_ok(tctx, wbcLookupDomainController(domain_name, 0, &dc_info),
 409                 "wbcLookupDomainController failed");
 410         wbcFreeMemory(dc_info);
 411
 412         return true;
 413 }
 414
 415 static bool test_wbc_lookupdcex(struct torture_context *tctx)
 416 {
 417         const char *domain_name = NULL;
 418         struct wbcInterfaceDetails *details;
 419         struct wbcDomainControllerInfoEx *dc_info;
 420
 421         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
 422                 "wbcInterfaceDetails failed");
 423
 424         domain_name = talloc_strdup(tctx, details->netbios_domain);
 425         wbcFreeMemory(details);
 426
 427         torture_assert_wbc_ok(tctx, wbcLookupDomainControllerEx(domain_name, NULL, NULL, 0, &dc_info),
 428                 "wbcLookupDomainControllerEx failed");
 429         wbcFreeMemory(dc_info);
 430
 431         return true;
 432 }
 433
 434 static bool test_wbc_resolve_winsbyname(struct torture_context *tctx)
 435 {
 436         const char *name;
 437         char *ip;
 438         wbcErr ret;
 439
 440         name = torture_setting_string(tctx, "host", NULL);
 441
 442         ret = wbcResolveWinsByName(name, &ip);
 443
 444         if (is_ipaddress(name)) {
 445                 torture_assert_wbc_equal(tctx, ret, WBC_ERR_DOMAIN_NOT_FOUND, "wbcResolveWinsByName failed");
 446         } else {
 447                 torture_assert_wbc_ok(tctx, ret, "wbcResolveWinsByName failed");
 448         }
 449
 450         return true;
 451 }
 452
 453 static bool test_wbc_resolve_winsbyip(struct torture_context *tctx)
 454 {
 455         const char *ip;
 456         char *name;
 457         wbcErr ret;
 458
 459         ip = torture_setting_string(tctx, "host", NULL);
 460
 461         ret = wbcResolveWinsByIP(ip, &name);
 462
 463         torture_assert_wbc_ok(tctx, ret, "wbcResolveWinsByIP failed");
 464
 465         wbcFreeMemory(name);
 466
 467         return true;
 468 }
 469
 470 static bool test_wbc_lookup_rids(struct torture_context *tctx)
 471 {
 472         struct wbcDomainSid builtin;
 473         uint32_t rids[2] = { 544, 545 };
 474         const char *domain_name, **names;
 475         enum wbcSidType *types;
 476         wbcErr ret;
 477
 478         wbcStringToSid("S-1-5-32", &builtin);
 479
 480         ret = wbcLookupRids(&builtin, 2, rids, &domain_name, &names,
 481                             &types);
 482         torture_assert_wbc_ok(tctx, ret, "wbcLookupRids failed");
 483
 484         torture_assert_str_equal(
 485                 tctx, names[0], "Administrators",
 486                 "S-1-5-32-544 not mapped to 'Administrators'");
 487         torture_assert_str_equal(
 488                 tctx, names[1], "Users", "S-1-5-32-545 not mapped to 'Users'");
 489
 490         wbcFreeMemory((char *)domain_name);
 491         wbcFreeMemory(names);
 492         wbcFreeMemory(types);
 493
 494         return true;
 495 }
 496
 497 static bool test_wbc_get_sidaliases(struct torture_context *tctx)
 498 {
 499         struct wbcDomainSid builtin;
 500         struct wbcDomainInfo *info;
 501         struct wbcInterfaceDetails *details;
 502         struct wbcDomainSid sids[2];
 503         uint32_t *rids;
 504         uint32_t num_rids;
 505         wbcErr ret;
 506
 507         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
 508                 "wbcInterfaceDetails failed");
 509         torture_assert_wbc_ok(
 510                 tctx, wbcDomainInfo(details->netbios_domain, &info),
 511                 "wbcDomainInfo failed");
 512         wbcFreeMemory(details);
 513
 514         sids[0] = info->sid;
 515         sids[0].sub_auths[sids[0].num_auths++] = 500;
 516         sids[1] = info->sid;
 517         sids[1].sub_auths[sids[1].num_auths++] = 512;
 518         wbcFreeMemory(info);
 519
 520         torture_assert_wbc_ok(
 521                 tctx, wbcStringToSid("S-1-5-32", &builtin),
 522                 "wbcStringToSid failed");
 523
 524         ret = wbcGetSidAliases(&builtin, sids, 2, &rids, &num_rids);
 525         torture_assert_wbc_ok(tctx, ret, "wbcGetSidAliases failed");
 526
 527         wbcFreeMemory(rids);
 528
 529         return true;
 530 }
 531
 532 static bool test_wbc_authenticate_user(struct torture_context *tctx)
 533 {
 534         struct wbcAuthUserParams params;
 535         struct wbcAuthUserInfo *info = NULL;
 536         struct wbcAuthErrorInfo *error = NULL;
 537         wbcErr ret;
 538
 539         ret = wbcAuthenticateUser(getenv("USERNAME"), getenv("PASSWORD"));
 540         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
 541                                  "wbcAuthenticateUser failed");
 542
 543         ZERO_STRUCT(params);
 544         params.account_name             = getenv("USERNAME");
 545         params.level                    = WBC_AUTH_USER_LEVEL_PLAIN;
 546         params.password.plaintext       = getenv("PASSWORD");
 547
 548         ret = wbcAuthenticateUserEx(&params, &info, &error);
 549         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
 550                                  "wbcAuthenticateUserEx failed");
 551         wbcFreeMemory(info);
 552         info = NULL;
 553
 554         wbcFreeMemory(error);
 555         error = NULL;
 556
 557         params.password.plaintext       = "wrong";
 558         ret = wbcAuthenticateUserEx(&params, &info, &error);
 559         torture_assert_wbc_equal(tctx, ret, WBC_ERR_AUTH_ERROR,
 560                                  "wbcAuthenticateUserEx succeeded where it "
 561                                  "should have failed");
 562         wbcFreeMemory(info);
 563         info = NULL;
 564
 565         wbcFreeMemory(error);
 566         error = NULL;
 567
 568         return true;
 569 }
 570
 571 static bool test_wbc_logon_user(struct torture_context *tctx)
 572 {
 573         struct wbcLogonUserParams params;
 574         struct wbcLogonUserInfo *info = NULL;
 575         struct wbcAuthErrorInfo *error = NULL;
 576         struct wbcUserPasswordPolicyInfo *policy = NULL;
 577         struct wbcInterfaceDetails *iface;
 578         struct wbcDomainSid sid;
 579         enum wbcSidType sidtype;
 580         char *sidstr;
 581         wbcErr ret;
 582
 583         ZERO_STRUCT(params);
 584
 585         ret = wbcLogonUser(&params, &info, &error, &policy);
 586         torture_assert_wbc_equal(tctx, ret, WBC_ERR_INVALID_PARAM,
 587                                  "wbcLogonUser succeeded where it should "
 588                                  "have failed");
 589
 590         params.username = getenv("USERNAME");
 591         params.password = getenv("PASSWORD");
 592
 593         ret = wbcAddNamedBlob(&params.num_blobs, &params.blobs,
 594                               "foo", 0, discard_const_p(uint8_t, "bar"), 4);
 595         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
 596                                  "wbcAddNamedBlob failed");
 597
 598         ret = wbcLogonUser(&params, &info, &error, &policy);
 599         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
 600                                  "wbcLogonUser failed");
 601         wbcFreeMemory(info); info = NULL;
 602         wbcFreeMemory(error); error = NULL;
 603         wbcFreeMemory(policy); policy = NULL;
 604
 605         params.password = "wrong";
 606
 607         ret = wbcLogonUser(&params, &info, &error, &policy);
 608         torture_assert_wbc_equal(tctx, ret, WBC_ERR_AUTH_ERROR,
 609                                  "wbcLogonUser should have failed with "
 610                                  "WBC_ERR_AUTH_ERROR");
 611         wbcFreeMemory(info); info = NULL;
 612         wbcFreeMemory(error); error = NULL;
 613         wbcFreeMemory(policy); policy = NULL;
 614
 615         ret = wbcAddNamedBlob(&params.num_blobs, &params.blobs,
 616                               "membership_of", 0,
 617                               discard_const_p(uint8_t, "S-1-2-3-4"),
 618                               strlen("S-1-2-3-4")+1);
 619         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
 620                                  "wbcAddNamedBlob failed");
 621         params.password = getenv("PASSWORD");
 622         ret = wbcLogonUser(&params, &info, &error, &policy);
 623         torture_assert_wbc_equal(tctx, ret, WBC_ERR_AUTH_ERROR,
 624                                  "wbcLogonUser should have failed with "
 625                                  "WBC_ERR_AUTH_ERROR");
 626         wbcFreeMemory(info); info = NULL;
 627         wbcFreeMemory(error); error = NULL;
 628         wbcFreeMemory(policy); policy = NULL;
 629         wbcFreeMemory(params.blobs);
 630         params.blobs = NULL; params.num_blobs = 0;
 631
 632         ret = wbcInterfaceDetails(&iface);
 633         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
 634                                  "wbcInterfaceDetails failed");
 635
 636         ret = wbcLookupName(iface->netbios_domain, getenv("USERNAME"), &sid,
 637                             &sidtype);
 638         wbcFreeMemory(iface);
 639         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
 640                                  "wbcLookupName failed");
 641
 642         ret = wbcSidToString(&sid, &sidstr);
 643         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
 644                                  "wbcSidToString failed");
 645
 646         ret = wbcAddNamedBlob(&params.num_blobs, &params.blobs,
 647                               "membership_of", 0,
 648                               (uint8_t *)sidstr, strlen(sidstr)+1);
 649         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
 650                                  "wbcAddNamedBlob failed");
 651         wbcFreeMemory(sidstr);
 652         params.password = getenv("PASSWORD");
 653         ret = wbcLogonUser(&params, &info, &error, &policy);
 654         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
 655                                  "wbcLogonUser failed");
 656         wbcFreeMemory(info); info = NULL;
 657         wbcFreeMemory(error); error = NULL;
 658         wbcFreeMemory(policy); policy = NULL;
 659         wbcFreeMemory(params.blobs);
 660         params.blobs = NULL; params.num_blobs = 0;
 661
 662         return true;
 663 }
 664
 665 struct torture_suite *torture_wbclient(void)
 666 {
 667         struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "WBCLIENT");
 668
 669         torture_suite_add_simple_test(suite, "wbcPing", test_wbc_ping);
 670         torture_suite_add_simple_test(suite, "wbcPing_async", test_wbc_ping_async);
 671         torture_suite_add_simple_test(suite, "wbcPingDc", test_wbc_pingdc);
 672         torture_suite_add_simple_test(suite, "wbcLibraryDetails", test_wbc_library_details);
 673         torture_suite_add_simple_test(suite, "wbcInterfaceDetails", test_wbc_interface_details);
 674         torture_suite_add_simple_test(suite, "wbcSidTypeString", test_wbc_sidtypestring);
 675         torture_suite_add_simple_test(suite, "wbcSidToString", test_wbc_sidtostring);
 676         torture_suite_add_simple_test(suite, "wbcGuidToString", test_wbc_guidtostring);
 677         torture_suite_add_simple_test(suite, "wbcDomainInfo", test_wbc_domain_info);
 678         torture_suite_add_simple_test(suite, "wbcListUsers", test_wbc_users);
 679         torture_suite_add_simple_test(suite, "wbcListUsers_async", test_wbc_users_async);
 680         torture_suite_add_simple_test(suite, "wbcListGroups", test_wbc_groups);
 681         torture_suite_add_simple_test(suite, "wbcListTrusts", test_wbc_trusts);
 682         torture_suite_add_simple_test(suite, "wbcLookupDomainController", test_wbc_lookupdc);
 683         torture_suite_add_simple_test(suite, "wbcLookupDomainControllerEx", test_wbc_lookupdcex);
 684         torture_suite_add_simple_test(suite, "wbcResolveWinsByName", test_wbc_resolve_winsbyname);
 685         torture_suite_add_simple_test(suite, "wbcResolveWinsByIP", test_wbc_resolve_winsbyip);
 686         torture_suite_add_simple_test(suite, "wbcLookupRids",
 687                                       test_wbc_lookup_rids);
 688         torture_suite_add_simple_test(suite, "wbcGetSidAliases",
 689                                       test_wbc_get_sidaliases);
 690         torture_suite_add_simple_test(suite, "wbcAuthenticateUser",
 691                                       test_wbc_authenticate_user);
 692         torture_suite_add_simple_test(suite, "wbcLogonUser",
 693                                       test_wbc_logon_user);
 694
 695         return suite;
 696 }