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