1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright 2015 Nexenta Systems, Inc. All rights reserved. 25 */ 26 27 /* 28 * Server Service (srvsvc) client side RPC library interface. The 29 * srvsvc interface allows a client to query a server for information 30 * on shares, sessions, connections and files on the server. Some 31 * functions are available via anonymous IPC while others require 32 * administrator privilege. Also, some functions return NT status 33 * values while others return Win32 errors codes. 34 */ 35 36 #include <sys/errno.h> 37 #include <stdio.h> 38 #include <time.h> 39 #include <strings.h> 40 41 #include <smbsrv/libsmb.h> 42 #include <smbsrv/libmlsvc.h> 43 #include <smbsrv/smbinfo.h> 44 #include <smbsrv/ndl/srvsvc.ndl> 45 46 /* 47 * Information level for NetShareGetInfo. 48 */ 49 DWORD srvsvc_info_level = 1; 50 51 /* 52 * Bind to the the SRVSVC. 53 * 54 * If username argument is NULL, an anonymous connection will be established. 55 * Otherwise, an authenticated connection will be established. 56 */ 57 static int 58 srvsvc_open(char *server, char *domain, char *username, mlsvc_handle_t *handle) 59 { 60 smb_domainex_t di; 61 62 if (server == NULL || domain == NULL) { 63 if (!smb_domain_getinfo(&di)) 64 return (-1); 65 66 server = di.d_dci.dc_name; 67 domain = di.d_primary.di_nbname; 68 } 69 70 if (username == NULL) 71 username = MLSVC_ANON_USER; 72 73 if (ndr_rpc_bind(handle, server, domain, username, "SRVSVC") != 0) 74 return (-1); 75 76 return (0); 77 } 78 79 /* 80 * Unbind the SRVSVC connection. 81 */ 82 static void 83 srvsvc_close(mlsvc_handle_t *handle) 84 { 85 ndr_rpc_unbind(handle); 86 } 87 88 /* 89 * This is a client side routine for NetShareGetInfo. 90 * Levels 0 and 1 work with an anonymous connection but 91 * level 2 requires administrator access. 92 */ 93 int 94 srvsvc_net_share_get_info(char *server, char *domain, char *netname) 95 { 96 struct mlsm_NetShareGetInfo arg; 97 mlsvc_handle_t handle; 98 int rc; 99 int opnum; 100 struct mslm_NetShareInfo_0 *info0; 101 struct mslm_NetShareInfo_1 *info1; 102 struct mslm_NetShareInfo_2 *info2; 103 int len; 104 char user[SMB_USERNAME_MAXLEN]; 105 106 if (netname == NULL) 107 return (-1); 108 109 if (srvsvc_info_level == 2) 110 smb_ipc_get_user(user, SMB_USERNAME_MAXLEN); 111 112 if (srvsvc_open(server, domain, user, &handle) != 0) 113 return (-1); 114 115 opnum = SRVSVC_OPNUM_NetShareGetInfo; 116 bzero(&arg, sizeof (struct mlsm_NetShareGetInfo)); 117 118 len = strlen(server) + 4; 119 arg.servername = ndr_rpc_malloc(&handle, len); 120 if (arg.servername == NULL) { 121 srvsvc_close(&handle); 122 return (-1); 123 } 124 125 (void) snprintf((char *)arg.servername, len, "\\\\%s", server); 126 arg.netname = (LPTSTR)netname; 127 arg.level = srvsvc_info_level; /* share information level */ 128 129 rc = ndr_rpc_call(&handle, opnum, &arg); 130 if ((rc != 0) || (arg.status != 0)) { 131 srvsvc_close(&handle); 132 return (-1); 133 } 134 135 switch (arg.result.switch_value) { 136 case 0: 137 info0 = arg.result.ru.info0; 138 smb_tracef("srvsvc shi0_netname=%s", info0->shi0_netname); 139 break; 140 141 case 1: 142 info1 = arg.result.ru.info1; 143 smb_tracef("srvsvc shi1_netname=%s", info1->shi1_netname); 144 smb_tracef("srvsvc shi1_type=%u", info1->shi1_type); 145 146 if (info1->shi1_comment) 147 smb_tracef("srvsvc shi1_comment=%s", 148 info1->shi1_comment); 149 break; 150 151 case 2: 152 info2 = arg.result.ru.info2; 153 smb_tracef("srvsvc shi2_netname=%s", info2->shi2_netname); 154 smb_tracef("srvsvc shi2_type=%u", info2->shi2_type); 155 156 if (info2->shi2_comment) 157 smb_tracef("srvsvc shi2_comment=%s", 158 info2->shi2_comment); 159 160 smb_tracef("srvsvc shi2_perms=%d", info2->shi2_permissions); 161 smb_tracef("srvsvc shi2_max_use=%d", info2->shi2_max_uses); 162 smb_tracef("srvsvc shi2_cur_use=%d", info2->shi2_current_uses); 163 164 if (info2->shi2_path) 165 smb_tracef("srvsvc shi2_path=%s", info2->shi2_path); 166 167 if (info2->shi2_passwd) 168 smb_tracef("srvsvc shi2_passwd=%s", info2->shi2_passwd); 169 break; 170 171 default: 172 smb_tracef("srvsvc: unknown level"); 173 break; 174 } 175 176 srvsvc_close(&handle); 177 return (0); 178 } 179 180 /* 181 * This is a client side routine for NetSessionEnum. 182 * NetSessionEnum requires administrator rights. 183 */ 184 int 185 srvsvc_net_session_enum(char *server, char *domain, char *netname) 186 { 187 struct mslm_NetSessionEnum arg; 188 mlsvc_handle_t handle; 189 int rc; 190 int opnum; 191 struct mslm_infonres infonres; 192 struct mslm_SESSION_INFO_1 *nsi1; 193 int len; 194 char user[SMB_USERNAME_MAXLEN]; 195 196 if (netname == NULL) 197 return (-1); 198 199 smb_ipc_get_user(user, SMB_USERNAME_MAXLEN); 200 201 rc = srvsvc_open(server, domain, user, &handle); 202 if (rc != 0) 203 return (-1); 204 205 opnum = SRVSVC_OPNUM_NetSessionEnum; 206 bzero(&arg, sizeof (struct mslm_NetSessionEnum)); 207 208 len = strlen(server) + 4; 209 arg.servername = ndr_rpc_malloc(&handle, len); 210 if (arg.servername == NULL) { 211 srvsvc_close(&handle); 212 return (-1); 213 } 214 215 (void) snprintf((char *)arg.servername, len, "\\\\%s", server); 216 infonres.entriesread = 0; 217 infonres.entries = 0; 218 arg.level = 1; 219 arg.result.level = 1; 220 arg.result.bufptr.p = &infonres; 221 arg.resume_handle = 0; 222 arg.pref_max_len = 0xFFFFFFFF; 223 224 rc = ndr_rpc_call(&handle, opnum, &arg); 225 if ((rc != 0) || (arg.status != 0)) { 226 srvsvc_close(&handle); 227 return (-1); 228 } 229 230 /* Only the first session info is dereferenced. */ 231 nsi1 = ((struct mslm_infonres *)arg.result.bufptr.p)->entries; 232 233 smb_tracef("srvsvc switch_value=%d", arg.level); 234 smb_tracef("srvsvc sesi1_cname=%s", nsi1->sesi1_cname); 235 smb_tracef("srvsvc sesi1_uname=%s", nsi1->sesi1_uname); 236 smb_tracef("srvsvc sesi1_nopens=%u", nsi1->sesi1_nopens); 237 smb_tracef("srvsvc sesi1_time=%u", nsi1->sesi1_time); 238 smb_tracef("srvsvc sesi1_itime=%u", nsi1->sesi1_itime); 239 smb_tracef("srvsvc sesi1_uflags=%u", nsi1->sesi1_uflags); 240 241 srvsvc_close(&handle); 242 return (0); 243 } 244 245 /* 246 * This is a client side routine for NetConnectEnum. 247 * NetConnectEnum requires administrator rights. 248 * Level 0 and level 1 requests are supported. 249 */ 250 int 251 srvsvc_net_connect_enum(char *server, char *domain, char *netname, int level) 252 { 253 struct mslm_NetConnectEnum arg; 254 mlsvc_handle_t handle; 255 int rc; 256 int opnum; 257 struct mslm_NetConnectInfo1 info1; 258 struct mslm_NetConnectInfo0 info0; 259 struct mslm_NetConnectInfoBuf1 *cib1; 260 int len; 261 char user[SMB_USERNAME_MAXLEN]; 262 263 if (netname == NULL) 264 return (-1); 265 266 smb_ipc_get_user(user, SMB_USERNAME_MAXLEN); 267 268 rc = srvsvc_open(server, domain, user, &handle); 269 if (rc != 0) 270 return (-1); 271 272 opnum = SRVSVC_OPNUM_NetConnectEnum; 273 bzero(&arg, sizeof (struct mslm_NetConnectEnum)); 274 275 len = strlen(server) + 4; 276 arg.servername = ndr_rpc_malloc(&handle, len); 277 if (arg.servername == NULL) { 278 srvsvc_close(&handle); 279 return (-1); 280 } 281 282 (void) snprintf((char *)arg.servername, len, "\\\\%s", server); 283 arg.qualifier = (LPTSTR)netname; 284 285 switch (level) { 286 case 0: 287 arg.info.level = 0; 288 arg.info.switch_value = 0; 289 arg.info.ru.info0 = &info0; 290 info0.entries_read = 0; 291 info0.ci0 = 0; 292 break; 293 case 1: 294 arg.info.level = 1; 295 arg.info.switch_value = 1; 296 arg.info.ru.info1 = &info1; 297 info1.entries_read = 0; 298 info1.ci1 = 0; 299 break; 300 default: 301 srvsvc_close(&handle); 302 return (-1); 303 } 304 305 arg.resume_handle = 0; 306 arg.pref_max_len = 0xFFFFFFFF; 307 308 rc = ndr_rpc_call(&handle, opnum, &arg); 309 if ((rc != 0) || (arg.status != 0)) { 310 srvsvc_close(&handle); 311 return (-1); 312 } 313 314 smb_tracef("srvsvc switch_value=%d", arg.info.switch_value); 315 316 switch (level) { 317 case 0: 318 if (arg.info.ru.info0 && arg.info.ru.info0->ci0) { 319 smb_tracef("srvsvc coni0_id=%x", 320 arg.info.ru.info0->ci0->coni0_id); 321 } 322 break; 323 case 1: 324 if (arg.info.ru.info1 && arg.info.ru.info1->ci1) { 325 cib1 = arg.info.ru.info1->ci1; 326 327 smb_tracef("srvsvc coni_uname=%s", 328 cib1->coni1_username ? 329 (char *)cib1->coni1_username : "(null)"); 330 smb_tracef("srvsvc coni1_netname=%s", 331 cib1->coni1_netname ? 332 (char *)cib1->coni1_netname : "(null)"); 333 smb_tracef("srvsvc coni1_nopens=%u", 334 cib1->coni1_num_opens); 335 smb_tracef("srvsvc coni1_time=%u", cib1->coni1_time); 336 smb_tracef("srvsvc coni1_num_users=%u", 337 cib1->coni1_num_users); 338 } 339 break; 340 341 default: 342 smb_tracef("srvsvc: unknown level"); 343 break; 344 } 345 346 srvsvc_close(&handle); 347 return (0); 348 } 349 350 /* 351 * Windows 95+ and Windows NT4.0 both report the version as 4.0. 352 * Windows 2000+ reports the version as 5.x. 353 */ 354 int 355 srvsvc_net_server_getinfo(char *server, char *domain, 356 srvsvc_server_info_t *svinfo) 357 { 358 mlsvc_handle_t handle; 359 struct mslm_NetServerGetInfo arg; 360 struct mslm_SERVER_INFO_101 *sv101; 361 int len, opnum, rc; 362 char user[SMB_USERNAME_MAXLEN]; 363 364 smb_ipc_get_user(user, SMB_USERNAME_MAXLEN); 365 366 if (srvsvc_open(server, domain, user, &handle) != 0) 367 return (-1); 368 369 opnum = SRVSVC_OPNUM_NetServerGetInfo; 370 bzero(&arg, sizeof (arg)); 371 372 len = strlen(server) + 4; 373 arg.servername = ndr_rpc_malloc(&handle, len); 374 if (arg.servername == NULL) 375 return (-1); 376 377 (void) snprintf((char *)arg.servername, len, "\\\\%s", server); 378 arg.level = 101; 379 380 rc = ndr_rpc_call(&handle, opnum, &arg); 381 if ((rc != 0) || (arg.status != 0)) { 382 srvsvc_close(&handle); 383 return (-1); 384 } 385 386 sv101 = arg.result.bufptr.bufptr101; 387 388 bzero(svinfo, sizeof (srvsvc_server_info_t)); 389 svinfo->sv_platform_id = sv101->sv101_platform_id; 390 svinfo->sv_version_major = sv101->sv101_version_major; 391 svinfo->sv_version_minor = sv101->sv101_version_minor; 392 svinfo->sv_type = sv101->sv101_type; 393 if (sv101->sv101_name) 394 svinfo->sv_name = strdup((char *)sv101->sv101_name); 395 if (sv101->sv101_comment) 396 svinfo->sv_comment = strdup((char *)sv101->sv101_comment); 397 398 if (svinfo->sv_type & SV_TYPE_WFW) 399 svinfo->sv_os = NATIVE_OS_WIN95; 400 if (svinfo->sv_type & SV_TYPE_WINDOWS) 401 svinfo->sv_os = NATIVE_OS_WIN95; 402 if ((svinfo->sv_type & SV_TYPE_NT) || 403 (svinfo->sv_type & SV_TYPE_SERVER_NT)) 404 svinfo->sv_os = NATIVE_OS_WINNT; 405 if (svinfo->sv_version_major > 4) 406 svinfo->sv_os = NATIVE_OS_WIN2000; 407 408 srvsvc_close(&handle); 409 return (0); 410 } 411 412 /* 413 * Synchronize the local system clock with the domain controller. 414 */ 415 void 416 srvsvc_timesync(void) 417 { 418 smb_domainex_t di; 419 struct timeval tv; 420 struct tm tm; 421 time_t tsecs; 422 423 if (!smb_domain_getinfo(&di)) 424 return; 425 426 if (srvsvc_net_remote_tod(di.d_dci.dc_name, di.d_primary.di_nbname, 427 &tv, &tm) != 0) 428 return; 429 430 if (settimeofday(&tv, 0)) 431 smb_tracef("unable to set system time"); 432 433 tsecs = time(0); 434 (void) localtime_r(&tsecs, &tm); 435 smb_tracef("SrvsvcTimeSync %s", ctime((time_t *)&tv.tv_sec)); 436 } 437 438 /* 439 * NetRemoteTOD to get the current GMT time from a Windows NT server. 440 */ 441 int 442 srvsvc_gettime(unsigned long *t) 443 { 444 smb_domainex_t di; 445 struct timeval tv; 446 struct tm tm; 447 448 if (!smb_domain_getinfo(&di)) 449 return (-1); 450 451 if (srvsvc_net_remote_tod(di.d_dci.dc_name, di.d_primary.di_nbname, 452 &tv, &tm) != 0) 453 return (-1); 454 455 *t = tv.tv_sec; 456 return (0); 457 } 458 459 /* 460 * This is a client side routine for NetRemoteTOD, which gets the time 461 * and date from a remote system. The time information is returned in 462 * the timeval and tm. 463 * 464 * typedef struct _TIME_OF_DAY_INFO { 465 * DWORD tod_elapsedt; // seconds since 00:00:00 January 1 1970 GMT 466 * DWORD tod_msecs; // arbitrary milliseconds (since reset) 467 * DWORD tod_hours; // current hour [0-23] 468 * DWORD tod_mins; // current minute [0-59] 469 * DWORD tod_secs; // current second [0-59] 470 * DWORD tod_hunds; // current hundredth (0.01) second [0-99] 471 * LONG tod_timezone; // time zone of the server 472 * DWORD tod_tinterval; // clock tick time interval 473 * DWORD tod_day; // day of the month [1-31] 474 * DWORD tod_month; // month of the year [1-12] 475 * DWORD tod_year; // current year 476 * DWORD tod_weekday; // day of the week since sunday [0-6] 477 * } TIME_OF_DAY_INFO; 478 * 479 * The time zone of the server is calculated in minutes from Greenwich 480 * Mean Time (GMT). For time zones west of Greenwich, the value is 481 * positive; for time zones east of Greenwich, the value is negative. 482 * A value of -1 indicates that the time zone is undefined. 483 * 484 * The clock tick value represents a resolution of one ten-thousandth 485 * (0.0001) second. 486 */ 487 int 488 srvsvc_net_remote_tod(char *server, char *domain, struct timeval *tv, 489 struct tm *tm) 490 { 491 struct mslm_NetRemoteTOD arg; 492 struct mslm_TIME_OF_DAY_INFO *tod; 493 mlsvc_handle_t handle; 494 int rc; 495 int opnum; 496 int len; 497 char user[SMB_USERNAME_MAXLEN]; 498 499 smb_ipc_get_user(user, SMB_USERNAME_MAXLEN); 500 501 rc = srvsvc_open(server, domain, user, &handle); 502 if (rc != 0) 503 return (-1); 504 505 opnum = SRVSVC_OPNUM_NetRemoteTOD; 506 bzero(&arg, sizeof (struct mslm_NetRemoteTOD)); 507 508 len = strlen(server) + 4; 509 arg.servername = ndr_rpc_malloc(&handle, len); 510 if (arg.servername == NULL) { 511 srvsvc_close(&handle); 512 return (-1); 513 } 514 515 (void) snprintf((char *)arg.servername, len, "\\\\%s", server); 516 517 rc = ndr_rpc_call(&handle, opnum, &arg); 518 if ((rc != 0) || (arg.status != 0)) { 519 srvsvc_close(&handle); 520 return (-1); 521 } 522 523 /* 524 * We're assigning milliseconds to microseconds 525 * here but the value's not really relevant. 526 */ 527 tod = arg.bufptr; 528 529 if (tv) { 530 tv->tv_sec = tod->tod_elapsedt; 531 tv->tv_usec = tod->tod_msecs; 532 } 533 534 if (tm) { 535 tm->tm_sec = tod->tod_secs; 536 tm->tm_min = tod->tod_mins; 537 tm->tm_hour = tod->tod_hours; 538 tm->tm_mday = tod->tod_day; 539 tm->tm_mon = tod->tod_month - 1; 540 tm->tm_year = tod->tod_year - 1900; 541 tm->tm_wday = tod->tod_weekday; 542 } 543 544 srvsvc_close(&handle); 545 return (0); 546 } 547 548 void 549 srvsvc_net_test(char *server, char *domain, char *netname) 550 { 551 smb_domainex_t di; 552 srvsvc_server_info_t svinfo; 553 554 (void) smb_tracef("%s %s %s", server, domain, netname); 555 556 if (smb_domain_getinfo(&di)) { 557 server = di.d_dci.dc_name; 558 domain = di.d_primary.di_nbname; 559 } 560 561 if (srvsvc_net_server_getinfo(server, domain, &svinfo) == 0) { 562 smb_tracef("NetServerGetInfo: %s %s (%d.%d) id=%d type=0x%08x", 563 svinfo.sv_name ? svinfo.sv_name : "NULL", 564 svinfo.sv_comment ? svinfo.sv_comment : "NULL", 565 svinfo.sv_version_major, svinfo.sv_version_minor, 566 svinfo.sv_platform_id, svinfo.sv_type); 567 568 free(svinfo.sv_name); 569 free(svinfo.sv_comment); 570 } 571 572 (void) srvsvc_net_share_get_info(server, domain, netname); 573 #if 0 574 /* 575 * The NetSessionEnum server-side definition was updated. 576 * Disabled until the client-side has been updated. 577 */ 578 (void) srvsvc_net_session_enum(server, domain, netname); 579 #endif 580 (void) srvsvc_net_connect_enum(server, domain, netname, 0); 581 (void) srvsvc_net_connect_enum(server, domain, netname, 1); 582 } 583