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         const char *domain_name = NULL;
 177         struct wbcDomainInfo *info;
 178         struct wbcInterfaceDetails *details;
 179
 180         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
 181                 "wbcInterfaceDetails failed");
 182
 183         domain_name = talloc_strdup(tctx, details->netbios_domain);
 184         wbcFreeMemory(details);
 185
 186         torture_assert_wbc_ok(tctx, wbcDomainInfo(domain_name, &info),
 187                 "wbcDomainInfo failed");
 188         torture_assert(tctx, info,
 189                 "wbcDomainInfo returned NULL pointer");
 190         wbcFreeMemory(info);
 191
 192         return true;
 193 }
 194
 195 static bool test_wbc_users(struct torture_context *tctx)
 196 {
 197         const char *domain_name = NULL;
 198         uint32_t num_users;
 199         const char **users;
 200         int i;
 201         struct wbcInterfaceDetails *details;
 202
 203         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
 204                 "wbcInterfaceDetails failed");
 205
 206         domain_name = talloc_strdup(tctx, details->netbios_domain);
 207         wbcFreeMemory(details);
 208
 209         torture_assert_wbc_ok(tctx, wbcListUsers(domain_name, &num_users, &users),
 210                 "wbcListUsers failed");
 211         torture_assert(tctx, !(num_users > 0 && !users),
 212                 "wbcListUsers returned invalid results");
 213
 214         for (i=0; i < MIN(num_users,100); i++) {
 215
 216                 struct wbcDomainSid sid, *sids;
 217                 enum wbcSidType name_type;
 218                 char *domain;
 219                 char *name;
 220                 uint32_t num_sids;
 221
 222                 torture_assert_wbc_ok(tctx, wbcLookupName(domain_name, users[i], &sid, &name_type),
 223                         "wbcLookupName failed");
 224                 torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_USER,
 225                         "wbcLookupName expected WBC_SID_NAME_USER");
 226                 torture_assert_wbc_ok(tctx, wbcLookupSid(&sid, &domain, &name, &name_type),
 227                         "wbcLookupSid failed");
 228                 torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_USER,
 229                         "wbcLookupSid expected WBC_SID_NAME_USER");
 230                 torture_assert(tctx, name,
 231                         "wbcLookupSid returned no name");
 232                 wbcFreeMemory(domain);
 233                 wbcFreeMemory(name);
 234                 torture_assert_wbc_ok(tctx, wbcLookupUserSids(&sid, true, &num_sids, &sids),
 235                         "wbcLookupUserSids failed");
 236                 wbcFreeMemory(sids);
 237         }
 238         wbcFreeMemory(users);
 239
 240         return true;
 241 }
 242
 243 static bool test_wbc_users_async(struct torture_context *tctx)
 244 {
 245         struct wb_context *wb_ctx;
 246         struct tevent_req *req;
 247         const char *domain_name = NULL;
 248         uint32_t num_users;
 249         const char **users;
 250         int i;
 251         struct wbcInterfaceDetails *details;
 252
 253         wb_ctx = wb_context_init(tctx, NULL);
 254         wbcSetDebug(wb_ctx, wbc_debug_torture, tctx);
 255
 256         req = wbcInterfaceDetails_send(tctx, tctx->ev, wb_ctx);
 257         torture_assert(tctx, req, "wbcInterfaceDetails_send failed");
 258
 259         if(!tevent_req_poll(req, tctx->ev)) {
 260                 return false;
 261         }
 262         torture_assert_wbc_ok(tctx,
 263                               wbcInterfaceDetails_recv(req, tctx, &details),
 264                               "wbcInterfaceDetails_recv failed");
 265
 266         domain_name = talloc_strdup(tctx, details->netbios_domain);
 267         wbcFreeMemory(details);
 268
 269         /* No async implementation of this yet. */
 270         torture_assert_wbc_ok(tctx, wbcListUsers(domain_name, &num_users, &users),
 271                 "wbcListUsers failed");
 272         torture_assert(tctx, !(num_users > 0 && !users),
 273                 "wbcListUsers returned invalid results");
 274
 275         for (i=0; i < MIN(num_users,100); i++) {
 276
 277                 struct wbcDomainSid sid, *sids;
 278                 enum wbcSidType name_type;
 279                 char *domain;
 280                 char *name;
 281                 uint32_t num_sids;
 282
 283                 req = wbcLookupName_send(tctx, tctx->ev, wb_ctx, domain_name,
 284                                          users[i]);
 285                 torture_assert(tctx, req, "wbcLookupName_send failed");
 286
 287                 if(!tevent_req_poll(req, tctx->ev)) {
 288                         return false;
 289                 }
 290
 291                 torture_assert_wbc_ok(tctx,
 292                                       wbcLookupName_recv(req, &sid, &name_type),
 293                                       "wbcLookupName_recv failed");
 294
 295                 torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_USER,
 296                         "wbcLookupName expected WBC_SID_NAME_USER");
 297                 torture_assert_wbc_ok(tctx, wbcLookupSid(&sid, &domain, &name, &name_type),
 298                         "wbcLookupSid failed");
 299                 torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_USER,
 300                         "wbcLookupSid expected WBC_SID_NAME_USER");
 301                 torture_assert(tctx, name,
 302                         "wbcLookupSid returned no name");
 303                 wbcFreeMemory(domain);
 304                 wbcFreeMemory(name);
 305                 torture_assert_wbc_ok(tctx, wbcLookupUserSids(&sid, true, &num_sids, &sids),
 306                         "wbcLookupUserSids failed");
 307                 wbcFreeMemory(sids);
 308         }
 309         wbcFreeMemory(users);
 310
 311         return true;
 312 }
 313
 314 static bool test_wbc_groups(struct torture_context *tctx)
 315 {
 316         const char *domain_name = NULL;
 317         uint32_t num_groups;
 318         const char **groups;
 319         int i;
 320         struct wbcInterfaceDetails *details;
 321
 322         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
 323                 "wbcInterfaceDetails failed");
 324
 325         domain_name = talloc_strdup(tctx, details->netbios_domain);
 326         wbcFreeMemory(details);
 327
 328         torture_assert_wbc_ok(tctx, wbcListGroups(domain_name, &num_groups, &groups),
 329                 "wbcListGroups failed");
 330         torture_assert(tctx, !(num_groups > 0 && !groups),
 331                 "wbcListGroups returned invalid results");
 332
 333         for (i=0; i < MIN(num_groups,100); i++) {
 334
 335                 struct wbcDomainSid sid;
 336                 enum wbcSidType name_type;
 337                 char *domain;
 338                 char *name;
 339
 340                 torture_assert_wbc_ok(tctx, wbcLookupName(domain_name, groups[i], &sid, &name_type),
 341                         "wbcLookupName failed");
 342                 torture_assert_wbc_ok(tctx, wbcLookupSid(&sid, &domain, &name, &name_type),
 343                         "wbcLookupSid failed");
 344                 torture_assert(tctx, name,
 345                         "wbcLookupSid returned no name");
 346         }
 347         wbcFreeMemory(groups);
 348
 349         return true;
 350 }
 351
 352 static bool test_wbc_trusts(struct torture_context *tctx)
 353 {
 354         struct wbcDomainInfo *domains;
 355         size_t num_domains;
 356         int i;
 357
 358         torture_assert_wbc_ok(tctx, wbcListTrusts(&domains, &num_domains),
 359                 "wbcListTrusts failed");
 360         torture_assert(tctx, !(num_domains > 0 && !domains),
 361                 "wbcListTrusts returned invalid results");
 362
 363         for (i=0; i < MIN(num_domains,100); i++) {
 364
 365                 struct wbcAuthErrorInfo *error;
 366                 /*
 367                 struct wbcDomainSid sid;
 368                 enum wbcSidType name_type;
 369                 char *domain;
 370                 char *name;
 371                 */
 372                 torture_assert_wbc_ok(tctx, wbcCheckTrustCredentials(domains[i].short_name, &error),
 373                         "wbcCheckTrustCredentials failed");
 374                 /*
 375                 torture_assert_wbc_ok(tctx, wbcLookupName(domains[i].short_name, NULL, &sid, &name_type),
 376                         "wbcLookupName failed");
 377                 torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_DOMAIN,
 378                         "wbcLookupName expected WBC_SID_NAME_DOMAIN");
 379                 torture_assert_wbc_ok(tctx, wbcLookupSid(&sid, &domain, &name, &name_type),
 380                         "wbcLookupSid failed");
 381                 torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_DOMAIN,
 382                         "wbcLookupSid expected WBC_SID_NAME_DOMAIN");
 383                 torture_assert(tctx, name,
 384                         "wbcLookupSid returned no name");
 385                 */
 386         }
 387         wbcFreeMemory(domains);
 388
 389         return true;
 390 }
 391
 392 static bool test_wbc_lookupdc(struct torture_context *tctx)
 393 {
 394         const char *domain_name = NULL;
 395         struct wbcInterfaceDetails *details;
 396         struct wbcDomainControllerInfo *dc_info;
 397
 398         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
 399                 "wbcInterfaceDetails failed");
 400
 401         domain_name = talloc_strdup(tctx, details->netbios_domain);
 402         wbcFreeMemory(details);
 403
 404         torture_assert_wbc_ok(tctx, wbcLookupDomainController(domain_name, 0, &dc_info),
 405                 "wbcLookupDomainController failed");
 406         wbcFreeMemory(dc_info);
 407
 408         return true;
 409 }
 410
 411 static bool test_wbc_lookupdcex(struct torture_context *tctx)
 412 {
 413         const char *domain_name = NULL;
 414         struct wbcInterfaceDetails *details;
 415         struct wbcDomainControllerInfoEx *dc_info;
 416
 417         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
 418                 "wbcInterfaceDetails failed");
 419
 420         domain_name = talloc_strdup(tctx, details->netbios_domain);
 421         wbcFreeMemory(details);
 422
 423         torture_assert_wbc_ok(tctx, wbcLookupDomainControllerEx(domain_name, NULL, NULL, 0, &dc_info),
 424                 "wbcLookupDomainControllerEx failed");
 425         wbcFreeMemory(dc_info);
 426
 427         return true;
 428 }
 429
 430 static bool test_wbc_resolve_winsbyname(struct torture_context *tctx)
 431 {
 432         const char *name;
 433         char *ip;
 434         wbcErr ret;
 435
 436         name = torture_setting_string(tctx, "host", NULL);
 437
 438         ret = wbcResolveWinsByName(name, &ip);
 439
 440         if (is_ipaddress(name)) {
 441                 torture_assert_wbc_equal(tctx, ret, WBC_ERR_DOMAIN_NOT_FOUND, "wbcResolveWinsByName failed");
 442         } else {
 443                 torture_assert_wbc_ok(tctx, ret, "wbcResolveWinsByName failed");
 444         }
 445
 446         return true;
 447 }
 448
 449 static bool test_wbc_resolve_winsbyip(struct torture_context *tctx)
 450 {
 451         const char *ip;
 452         char *name;
 453         wbcErr ret;
 454
 455         ip = torture_setting_string(tctx, "host", NULL);
 456
 457         ret = wbcResolveWinsByIP(ip, &name);
 458
 459         torture_assert_wbc_ok(tctx, ret, "wbcResolveWinsByIP failed");
 460
 461         wbcFreeMemory(name);
 462
 463         return true;
 464 }
 465
 466 static bool test_wbc_lookup_rids(struct torture_context *tctx)
 467 {
 468         struct wbcDomainSid builtin;
 469         uint32_t rids[2] = { 544, 545 };
 470         const char *domain_name, **names;
 471         enum wbcSidType *types;
 472         wbcErr ret;
 473
 474         wbcStringToSid("S-1-5-32", &builtin);
 475
 476         ret = wbcLookupRids(&builtin, 2, rids, &domain_name, &names,
 477                             &types);
 478         torture_assert_wbc_ok(tctx, ret, "wbcLookupRids failed");
 479
 480         torture_assert_str_equal(
 481                 tctx, names[0], "Administrators",
 482                 "S-1-5-32-544 not mapped to 'Administrators'");
 483         torture_assert_str_equal(
 484                 tctx, names[1], "Users", "S-1-5-32-545 not mapped to 'Users'");
 485
 486         wbcFreeMemory((char *)domain_name);
 487         wbcFreeMemory(names);
 488         wbcFreeMemory(types);
 489
 490         return true;
 491 }
 492
 493 struct torture_suite *torture_wbclient(void)
 494 {
 495         struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "WBCLIENT");
 496
 497         torture_suite_add_simple_test(suite, "wbcPing", test_wbc_ping);
 498         torture_suite_add_simple_test(suite, "wbcPing_async", test_wbc_ping_async);
 499         torture_suite_add_simple_test(suite, "wbcPingDc", test_wbc_pingdc);
 500         torture_suite_add_simple_test(suite, "wbcLibraryDetails", test_wbc_library_details);
 501         torture_suite_add_simple_test(suite, "wbcInterfaceDetails", test_wbc_interface_details);
 502         torture_suite_add_simple_test(suite, "wbcSidTypeString", test_wbc_sidtypestring);
 503         torture_suite_add_simple_test(suite, "wbcSidToString", test_wbc_sidtostring);
 504         torture_suite_add_simple_test(suite, "wbcGuidToString", test_wbc_guidtostring);
 505         torture_suite_add_simple_test(suite, "wbcDomainInfo", test_wbc_domain_info);
 506         torture_suite_add_simple_test(suite, "wbcListUsers", test_wbc_users);
 507         torture_suite_add_simple_test(suite, "wbcListUsers_async", test_wbc_users_async);
 508         torture_suite_add_simple_test(suite, "wbcListGroups", test_wbc_groups);
 509         torture_suite_add_simple_test(suite, "wbcListTrusts", test_wbc_trusts);
 510         torture_suite_add_simple_test(suite, "wbcLookupDomainController", test_wbc_lookupdc);
 511         torture_suite_add_simple_test(suite, "wbcLookupDomainControllerEx", test_wbc_lookupdcex);
 512         torture_suite_add_simple_test(suite, "wbcResolveWinsByName", test_wbc_resolve_winsbyname);
 513         torture_suite_add_simple_test(suite, "wbcResolveWinsByIP", test_wbc_resolve_winsbyip);
 514         torture_suite_add_simple_test(suite, "wbcLookupRids",
 515                                       test_wbc_lookup_rids);
 516
 517         return suite;
 518 }