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 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright 2014 Nexenta Systems, Inc. All rights reserved. 24 */ 25 26 #include <sys/list.h> 27 #include <assert.h> 28 #include <alloca.h> 29 #include <door.h> 30 #include <errno.h> 31 #include <syslog.h> 32 #include <unistd.h> 33 #include <stdio.h> 34 #include <synch.h> 35 #include <string.h> 36 #include <stdlib.h> 37 #include <sys/stat.h> 38 #include <fcntl.h> 39 #include <pthread.h> 40 #include <strings.h> 41 #include <note.h> 42 #include <smbsrv/smb_door.h> 43 #include <smbsrv/smb_xdr.h> 44 #include <smbsrv/smb_token.h> 45 #include <smbsrv/libmlsvc.h> 46 #include <smbsrv/libsmbns.h> 47 #include "smbd.h" 48 49 /* 50 * The list contains asynchronous requests that have been initiated 51 * but have not yet been collected (via smbd_dop_async_response). 52 */ 53 typedef struct smbd_doorsvc { 54 mutex_t sd_mutex; 55 cond_t sd_cv; 56 list_t sd_async_list; 57 uint32_t sd_async_count; 58 } smbd_doorsvc_t; 59 60 static int smbd_dop_null(smbd_arg_t *); 61 static int smbd_dop_async_response(smbd_arg_t *); 62 static int smbd_dop_user_auth_logon(smbd_arg_t *); 63 static int smbd_dop_user_nonauth_logon(smbd_arg_t *); 64 static int smbd_dop_user_auth_logoff(smbd_arg_t *); 65 static int smbd_dop_lookup_sid(smbd_arg_t *); 66 static int smbd_dop_lookup_name(smbd_arg_t *); 67 static int smbd_dop_join(smbd_arg_t *); 68 static int smbd_dop_get_dcinfo(smbd_arg_t *); 69 static int smbd_dop_vss_get_count(smbd_arg_t *); 70 static int smbd_dop_vss_get_snapshots(smbd_arg_t *); 71 static int smbd_dop_vss_map_gmttoken(smbd_arg_t *); 72 static int smbd_dop_ads_find_host(smbd_arg_t *); 73 static int smbd_dop_quota_query(smbd_arg_t *); 74 static int smbd_dop_quota_set(smbd_arg_t *); 75 static int smbd_dop_dfs_get_referrals(smbd_arg_t *); 76 static int smbd_dop_shr_hostaccess(smbd_arg_t *); 77 static int smbd_dop_shr_exec(smbd_arg_t *); 78 static int smbd_dop_notify_dc_changed(smbd_arg_t *); 79 80 typedef int (*smbd_dop_t)(smbd_arg_t *); 81 82 typedef struct smbd_doorop { 83 smb_dopcode_t opcode; 84 smbd_dop_t op; 85 } smbd_doorop_t; 86 87 smbd_doorop_t smbd_doorops[] = { 88 { SMB_DR_NULL, smbd_dop_null }, 89 { SMB_DR_ASYNC_RESPONSE, smbd_dop_async_response }, 90 { SMB_DR_USER_AUTH_LOGON, smbd_dop_user_auth_logon }, 91 { SMB_DR_USER_NONAUTH_LOGON, smbd_dop_user_nonauth_logon }, 92 { SMB_DR_USER_AUTH_LOGOFF, smbd_dop_user_auth_logoff }, 93 { SMB_DR_LOOKUP_SID, smbd_dop_lookup_sid }, 94 { SMB_DR_LOOKUP_NAME, smbd_dop_lookup_name }, 95 { SMB_DR_JOIN, smbd_dop_join }, 96 { SMB_DR_GET_DCINFO, smbd_dop_get_dcinfo }, 97 { SMB_DR_VSS_GET_COUNT, smbd_dop_vss_get_count }, 98 { SMB_DR_VSS_GET_SNAPSHOTS, smbd_dop_vss_get_snapshots }, 99 { SMB_DR_VSS_MAP_GMTTOKEN, smbd_dop_vss_map_gmttoken }, 100 { SMB_DR_ADS_FIND_HOST, smbd_dop_ads_find_host }, 101 { SMB_DR_QUOTA_QUERY, smbd_dop_quota_query }, 102 { SMB_DR_QUOTA_SET, smbd_dop_quota_set }, 103 { SMB_DR_DFS_GET_REFERRALS, smbd_dop_dfs_get_referrals }, 104 { SMB_DR_SHR_HOSTACCESS, smbd_dop_shr_hostaccess }, 105 { SMB_DR_SHR_EXEC, smbd_dop_shr_exec }, 106 { SMB_DR_NOTIFY_DC_CHANGED, smbd_dop_notify_dc_changed } 107 }; 108 109 static int smbd_ndoorop = (sizeof (smbd_doorops) / sizeof (smbd_doorops[0])); 110 111 static smbd_doorsvc_t smbd_doorsvc; 112 static int smbd_door_fd = -1; 113 static int smbd_door_cookie = 0x534D4244; /* SMBD */ 114 static smbd_door_t smbd_door_sdh; 115 static char *smbd_door_name = NULL; 116 117 static void smbd_door_dispatch(void *, char *, size_t, door_desc_t *, uint_t); 118 static int smbd_door_dispatch_async(smbd_arg_t *); 119 static void smbd_door_release_async(smbd_arg_t *); 120 121 /* 122 * Start the smbd door service. Create and bind to a door. 123 * Returns 0 on success. Otherwise, -1. 124 */ 125 int 126 smbd_door_start(void) 127 { 128 int newfd; 129 130 (void) mutex_lock(&smbd_doorsvc.sd_mutex); 131 132 if (smbd_door_fd != -1) { 133 (void) fprintf(stderr, "smb_doorsrv_start: already started"); 134 (void) mutex_unlock(&smbd_doorsvc.sd_mutex); 135 return (-1); 136 } 137 138 smbd_door_name = getenv("SMBD_DOOR_NAME"); 139 if (smbd_door_name == NULL) 140 smbd_door_name = SMBD_DOOR_NAME; 141 142 smbd_door_init(&smbd_door_sdh, "doorsrv"); 143 144 list_create(&smbd_doorsvc.sd_async_list, sizeof (smbd_arg_t), 145 offsetof(smbd_arg_t, lnd)); 146 smbd_doorsvc.sd_async_count = 0; 147 148 if ((smbd_door_fd = door_create(smbd_door_dispatch, 149 &smbd_door_cookie, DOOR_UNREF)) < 0) { 150 (void) fprintf(stderr, "smb_doorsrv_start: door_create: %s", 151 strerror(errno)); 152 smbd_door_fd = -1; 153 (void) mutex_unlock(&smbd_doorsvc.sd_mutex); 154 return (-1); 155 } 156 157 (void) unlink(smbd_door_name); 158 159 if ((newfd = creat(smbd_door_name, 0644)) < 0) { 160 (void) fprintf(stderr, "smb_doorsrv_start: open: %s", 161 strerror(errno)); 162 (void) door_revoke(smbd_door_fd); 163 smbd_door_fd = -1; 164 (void) mutex_unlock(&smbd_doorsvc.sd_mutex); 165 return (-1); 166 } 167 168 (void) close(newfd); 169 (void) fdetach(smbd_door_name); 170 171 if (fattach(smbd_door_fd, smbd_door_name) < 0) { 172 (void) fprintf(stderr, "smb_doorsrv_start: fattach: %s", 173 strerror(errno)); 174 (void) door_revoke(smbd_door_fd); 175 smbd_door_fd = -1; 176 (void) mutex_unlock(&smbd_doorsvc.sd_mutex); 177 return (-1); 178 } 179 180 (void) mutex_unlock(&smbd_doorsvc.sd_mutex); 181 return (smbd_door_fd); 182 } 183 184 /* 185 * Stop the smbd door service. 186 */ 187 void 188 smbd_door_stop(void) 189 { 190 (void) mutex_lock(&smbd_doorsvc.sd_mutex); 191 192 smbd_door_fini(&smbd_door_sdh); 193 194 if (smbd_door_name) 195 (void) fdetach(smbd_door_name); 196 197 if (smbd_door_fd != -1) { 198 (void) door_revoke(smbd_door_fd); 199 smbd_door_fd = -1; 200 } 201 202 (void) mutex_unlock(&smbd_doorsvc.sd_mutex); 203 } 204 205 /*ARGSUSED*/ 206 static void 207 smbd_door_dispatch(void *cookie, char *argp, size_t arg_size, door_desc_t *dp, 208 uint_t n_desc) 209 { 210 smbd_arg_t dop_arg; 211 smb_doorhdr_t *hdr; 212 size_t hdr_size; 213 char *rbuf = NULL; 214 215 smbd_door_enter(&smbd_door_sdh); 216 217 if (!smbd_online()) 218 smbd_door_return(&smbd_door_sdh, NULL, 0, NULL, 0); 219 220 bzero(&dop_arg, sizeof (smbd_arg_t)); 221 hdr = &dop_arg.hdr; 222 hdr_size = xdr_sizeof(smb_doorhdr_xdr, hdr); 223 224 if ((cookie != &smbd_door_cookie) || (argp == NULL) || 225 (arg_size < hdr_size)) { 226 smbd_door_return(&smbd_door_sdh, NULL, 0, NULL, 0); 227 } 228 229 if (smb_doorhdr_decode(hdr, (uint8_t *)argp, hdr_size) == -1) { 230 syslog(LOG_DEBUG, "smbd_door_dispatch: header decode failed"); 231 smbd_door_return(&smbd_door_sdh, NULL, 0, NULL, 0); 232 } 233 234 if ((hdr->dh_magic != SMB_DOOR_HDR_MAGIC) || (hdr->dh_txid == 0)) { 235 syslog(LOG_DEBUG, "smbd_door_dispatch: invalid header"); 236 smbd_door_return(&smbd_door_sdh, NULL, 0, NULL, 0); 237 } 238 239 dop_arg.opname = smb_doorhdr_opname(hdr->dh_op); 240 dop_arg.data = argp + hdr_size; 241 dop_arg.datalen = hdr->dh_datalen; 242 243 if (hdr->dh_op == SMB_DR_ASYNC_RESPONSE) { 244 /* 245 * ASYNC_RESPONSE is used to collect the response 246 * to an async call; it cannot be an async call. 247 */ 248 hdr->dh_flags &= ~SMB_DF_ASYNC; 249 } 250 251 if (hdr->dh_flags & SMB_DF_ASYNC) { 252 if (smbd_door_dispatch_async(&dop_arg) == 0) 253 hdr->dh_door_rc = SMB_DOP_SUCCESS; 254 else 255 hdr->dh_door_rc = SMB_DOP_NOT_CALLED; 256 } else { 257 (void) smbd_door_dispatch_op(&dop_arg); 258 } 259 260 if ((rbuf = (char *)alloca(dop_arg.rsize + hdr_size)) == NULL) { 261 errno = ENOMEM; 262 syslog(LOG_DEBUG, "smbd_door_dispatch[%s]: alloca %m", 263 dop_arg.opname); 264 smbd_door_return(&smbd_door_sdh, NULL, 0, NULL, 0); 265 } 266 267 if (dop_arg.rbuf != NULL) { 268 (void) memcpy(rbuf + hdr_size, dop_arg.rbuf, dop_arg.rsize); 269 free(dop_arg.rbuf); 270 } 271 272 hdr->dh_datalen = dop_arg.rsize; 273 (void) smb_doorhdr_encode(hdr, (uint8_t *)rbuf, hdr_size); 274 dop_arg.rsize += hdr_size; 275 276 smbd_door_return(&smbd_door_sdh, rbuf, dop_arg.rsize, NULL, 0); 277 /*NOTREACHED*/ 278 } 279 280 /* 281 * Launch a thread to process an asynchronous door call. 282 */ 283 static int 284 smbd_door_dispatch_async(smbd_arg_t *req_arg) 285 { 286 smbd_arg_t *arg = NULL; 287 char *data = NULL; 288 pthread_attr_t attr; 289 pthread_t tid; 290 int rc; 291 292 if ((req_arg->hdr.dh_flags & SMB_DF_ASYNC) == 0) { 293 errno = EINVAL; 294 return (-1); 295 } 296 297 if ((arg = malloc(sizeof (smbd_arg_t))) == NULL) { 298 syslog(LOG_DEBUG, "smbd_door_dispatch_async[%s]: %m", 299 req_arg->opname); 300 return (-1); 301 } 302 303 (void) memcpy(arg, req_arg, sizeof (smbd_arg_t)); 304 arg->data = NULL; 305 306 if (req_arg->datalen != 0) { 307 if ((data = malloc(req_arg->datalen)) == NULL) { 308 free(arg); 309 syslog(LOG_DEBUG, "smbd_door_dispatch_async[%s]: %m", 310 req_arg->opname); 311 return (-1); 312 } 313 314 (void) memcpy(data, req_arg->data, req_arg->datalen); 315 arg->data = data; 316 } 317 318 (void) mutex_lock(&smbd_doorsvc.sd_mutex); 319 arg->magic = SMBD_ARG_MAGIC; 320 list_insert_tail(&smbd_doorsvc.sd_async_list, arg); 321 ++smbd_doorsvc.sd_async_count; 322 (void) mutex_unlock(&smbd_doorsvc.sd_mutex); 323 324 (void) pthread_attr_init(&attr); 325 (void) pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); 326 rc = pthread_create(&tid, &attr, smbd_door_dispatch_op, arg); 327 (void) pthread_attr_destroy(&attr); 328 329 if (rc != 0) { 330 (void) mutex_lock(&smbd_doorsvc.sd_mutex); 331 smbd_door_release_async(arg); 332 (void) mutex_unlock(&smbd_doorsvc.sd_mutex); 333 } 334 335 return (rc); 336 } 337 338 /* 339 * Remove an entry from the async response pending list and free 340 * the arg and associated data. 341 * 342 * Must only be called while holding the smbd_doorsvc mutex. 343 */ 344 static void 345 smbd_door_release_async(smbd_arg_t *arg) 346 { 347 if (arg != NULL) { 348 assert(arg->magic == SMBD_ARG_MAGIC); 349 arg->magic = (uint32_t)~SMBD_ARG_MAGIC; 350 351 list_remove(&smbd_doorsvc.sd_async_list, arg); 352 --smbd_doorsvc.sd_async_count; 353 free(arg->data); 354 arg->data = NULL; 355 free(arg); 356 } 357 } 358 359 /* 360 * All door calls are processed here: synchronous or asynchronous: 361 * - synchronous calls are invoked by direct function call 362 * - asynchronous calls are invoked from a launched thread 363 * 364 * If the kernel has attempted to collect a response before the op 365 * has completed, the arg will have been marked as response_abort 366 * and we can discard the response data and release the arg. 367 * 368 * We send a notification when asynchronous (ASYNC) door calls 369 * from the kernel (SYSSPACE) have completed. 370 */ 371 void * 372 smbd_door_dispatch_op(void *thread_arg) 373 { 374 smbd_arg_t *arg = (smbd_arg_t *)thread_arg; 375 smbd_doorop_t *doorop; 376 smb_doorhdr_t *hdr; 377 int i; 378 379 if ((!smbd_online()) || arg == NULL) 380 return (NULL); 381 382 hdr = &arg->hdr; 383 arg->opname = smb_doorhdr_opname(hdr->dh_op); 384 385 for (i = 0; i < smbd_ndoorop; ++i) { 386 doorop = &smbd_doorops[i]; 387 388 if (hdr->dh_op == doorop->opcode) { 389 hdr->dh_door_rc = doorop->op(arg); 390 hdr->dh_status = arg->status; 391 392 if ((hdr->dh_flags & SMB_DF_SYSSPACE) && 393 (hdr->dh_flags & SMB_DF_ASYNC)) { 394 assert(hdr->dh_op != SMB_DR_ASYNC_RESPONSE); 395 396 (void) mutex_lock(&smbd_doorsvc.sd_mutex); 397 if (arg->response_abort) { 398 free(arg->rbuf); 399 arg->rbuf = NULL; 400 smbd_door_release_async(arg); 401 } else { 402 arg->response_ready = B_TRUE; 403 } 404 (void) mutex_unlock(&smbd_doorsvc.sd_mutex); 405 406 (void) smb_kmod_event_notify(hdr->dh_txid); 407 } 408 409 return (NULL); 410 } 411 } 412 413 syslog(LOG_ERR, "smbd_door_dispatch_op[%s]: invalid op %u", 414 arg->opname, hdr->dh_op); 415 return (NULL); 416 } 417 418 /* 419 * Wrapper for door_return. smbd_door_enter() increments a reference count 420 * when a door call is dispatched and smbd_door_return() decrements the 421 * reference count when it completes. 422 * 423 * The reference counting is used in smbd_door_fini() to wait for active 424 * calls to complete before closing the door. 425 */ 426 void 427 smbd_door_init(smbd_door_t *sdh, const char *name) 428 { 429 (void) strlcpy(sdh->sd_name, name, sizeof (sdh->sd_name)); 430 } 431 432 void 433 smbd_door_enter(smbd_door_t *sdh) 434 { 435 (void) mutex_lock(&sdh->sd_mutex); 436 ++sdh->sd_ncalls; 437 (void) mutex_unlock(&sdh->sd_mutex); 438 } 439 440 /* 441 * We have two calls to door_return because the first call (with data) 442 * can fail, which can leave the door call blocked here. The second 443 * call (with NULL) is guaranteed to unblock and return to the caller. 444 */ 445 void 446 smbd_door_return(smbd_door_t *sdh, char *data_ptr, size_t data_size, 447 door_desc_t *desc_ptr, uint_t num_desc) 448 { 449 (void) mutex_lock(&sdh->sd_mutex); 450 451 if (sdh->sd_ncalls == 0) 452 syslog(LOG_ERR, "smbd_door_return[%s]: unexpected count=0", 453 sdh->sd_name); 454 else 455 --sdh->sd_ncalls; 456 457 (void) cond_broadcast(&sdh->sd_cv); 458 (void) mutex_unlock(&sdh->sd_mutex); 459 460 (void) door_return(data_ptr, data_size, desc_ptr, num_desc); 461 (void) door_return(NULL, 0, NULL, 0); 462 /* NOTREACHED */ 463 } 464 465 /* 466 * A door service is about to terminate. 467 * Give active requests a small grace period to complete. 468 */ 469 void 470 smbd_door_fini(smbd_door_t *sdh) 471 { 472 timestruc_t delay; 473 int rc = 0; 474 475 (void) mutex_lock(&sdh->sd_mutex); 476 477 while (rc != ETIME && sdh->sd_ncalls != 0) { 478 delay.tv_sec = 1; 479 delay.tv_nsec = 0; 480 rc = cond_reltimedwait(&sdh->sd_cv, &sdh->sd_mutex, &delay); 481 } 482 483 if (sdh->sd_ncalls != 0) 484 syslog(LOG_NOTICE, "smbd_door_fini[%s]: %d remaining", 485 sdh->sd_name, sdh->sd_ncalls); 486 487 (void) mutex_unlock(&sdh->sd_mutex); 488 } 489 490 /* 491 * Null door operation: always returns success. 492 * Assumes no request or response data. 493 */ 494 /*ARGSUSED*/ 495 static int 496 smbd_dop_null(smbd_arg_t *arg) 497 { 498 return (SMB_DOP_SUCCESS); 499 } 500 501 /* 502 * Async response handler: setup the rbuf and rsize for the specified 503 * transaction. This function is used by the kernel to collect the 504 * response half of an asynchronous door call. 505 * 506 * If a door client attempts to collect a response before the op has 507 * completed (!response_ready), mark the arg as response_abort and 508 * set an error. The response will be discarded when the op completes. 509 */ 510 static int 511 smbd_dop_async_response(smbd_arg_t *rsp_arg) 512 { 513 list_t *arg_list = &smbd_doorsvc.sd_async_list; 514 smbd_arg_t *arg; 515 516 (void) mutex_lock(&smbd_doorsvc.sd_mutex); 517 arg = list_head(arg_list); 518 519 while (arg != NULL) { 520 assert(arg->magic == SMBD_ARG_MAGIC); 521 522 if (arg->hdr.dh_txid == rsp_arg->hdr.dh_txid) { 523 if (!arg->response_ready) { 524 arg->response_abort = B_TRUE; 525 rsp_arg->hdr.dh_door_rc = SMB_DOP_NOT_CALLED; 526 syslog(LOG_NOTICE, "doorsvc[%s]: %u not ready", 527 arg->opname, arg->hdr.dh_txid); 528 break; 529 } 530 531 rsp_arg->rbuf = arg->rbuf; 532 rsp_arg->rsize = arg->rsize; 533 arg->rbuf = NULL; 534 arg->rsize = 0; 535 smbd_door_release_async(arg); 536 break; 537 } 538 539 arg = list_next(arg_list, arg); 540 } 541 542 (void) mutex_unlock(&smbd_doorsvc.sd_mutex); 543 return (SMB_DOP_SUCCESS); 544 } 545 546 static int 547 smbd_dop_user_nonauth_logon(smbd_arg_t *arg) 548 { 549 uint32_t sid = 0; 550 551 if (smb_common_decode(arg->data, arg->datalen, 552 xdr_uint32_t, &sid) != 0) 553 return (SMB_DOP_DECODE_ERROR); 554 555 smbd_user_nonauth_logon(sid); 556 return (SMB_DOP_SUCCESS); 557 } 558 559 static int 560 smbd_dop_user_auth_logoff(smbd_arg_t *arg) 561 { 562 uint32_t sid = 0; 563 564 if (smb_common_decode(arg->data, arg->datalen, 565 xdr_uint32_t, &sid) != 0) 566 return (SMB_DOP_DECODE_ERROR); 567 568 smbd_user_auth_logoff(sid); 569 return (SMB_DOP_SUCCESS); 570 } 571 572 /* 573 * Obtains an access token on successful user authentication. 574 */ 575 static int 576 smbd_dop_user_auth_logon(smbd_arg_t *arg) 577 { 578 _NOTE(ARGUNUSED(arg)) 579 580 /* No longer used */ 581 return (SMB_DOP_EMPTYBUF); 582 } 583 584 static int 585 smbd_dop_lookup_name(smbd_arg_t *arg) 586 { 587 smb_domain_t dinfo; 588 smb_account_t ainfo; 589 lsa_account_t acct; 590 char buf[MAXNAMELEN]; 591 592 bzero(&acct, sizeof (lsa_account_t)); 593 594 if (smb_common_decode(arg->data, arg->datalen, 595 lsa_account_xdr, &acct) != 0) 596 return (SMB_DOP_DECODE_ERROR); 597 598 if (*acct.a_domain == '\0') 599 (void) snprintf(buf, MAXNAMELEN, "%s", acct.a_name); 600 else if (strchr(acct.a_domain, '.') != NULL) 601 (void) snprintf(buf, MAXNAMELEN, "%s@%s", acct.a_name, 602 acct.a_domain); 603 else 604 (void) snprintf(buf, MAXNAMELEN, "%s\\%s", acct.a_domain, 605 acct.a_name); 606 607 acct.a_status = lsa_lookup_name(buf, acct.a_sidtype, &ainfo); 608 if (acct.a_status == NT_STATUS_SUCCESS) { 609 acct.a_sidtype = ainfo.a_type; 610 smb_sid_tostr(ainfo.a_sid, acct.a_sid); 611 (void) strlcpy(acct.a_name, ainfo.a_name, MAXNAMELEN); 612 613 if (smb_domain_lookup_name(ainfo.a_domain, &dinfo)) 614 (void) strlcpy(acct.a_domain, dinfo.di_fqname, 615 MAXNAMELEN); 616 else 617 (void) strlcpy(acct.a_domain, ainfo.a_domain, 618 MAXNAMELEN); 619 smb_account_free(&ainfo); 620 } 621 622 arg->rbuf = smb_common_encode(&acct, lsa_account_xdr, &arg->rsize); 623 624 if (arg->rbuf == NULL) 625 return (SMB_DOP_ENCODE_ERROR); 626 return (SMB_DOP_SUCCESS); 627 } 628 629 static int 630 smbd_dop_lookup_sid(smbd_arg_t *arg) 631 { 632 smb_domain_t dinfo; 633 smb_account_t ainfo; 634 lsa_account_t acct; 635 smb_sid_t *sid; 636 637 bzero(&acct, sizeof (lsa_account_t)); 638 639 if (smb_common_decode(arg->data, arg->datalen, 640 lsa_account_xdr, &acct) != 0) 641 return (SMB_DOP_DECODE_ERROR); 642 643 sid = smb_sid_fromstr(acct.a_sid); 644 acct.a_status = lsa_lookup_sid(sid, &ainfo); 645 smb_sid_free(sid); 646 647 if (acct.a_status == NT_STATUS_SUCCESS) { 648 acct.a_sidtype = ainfo.a_type; 649 smb_sid_tostr(ainfo.a_sid, acct.a_sid); 650 (void) strlcpy(acct.a_name, ainfo.a_name, MAXNAMELEN); 651 652 if (smb_domain_lookup_name(ainfo.a_domain, &dinfo)) 653 (void) strlcpy(acct.a_domain, dinfo.di_fqname, 654 MAXNAMELEN); 655 else 656 (void) strlcpy(acct.a_domain, ainfo.a_domain, 657 MAXNAMELEN); 658 659 smb_account_free(&ainfo); 660 } 661 662 arg->rbuf = smb_common_encode(&acct, lsa_account_xdr, &arg->rsize); 663 664 if (arg->rbuf == NULL) 665 return (SMB_DOP_ENCODE_ERROR); 666 return (SMB_DOP_SUCCESS); 667 } 668 669 static int 670 smbd_dop_join(smbd_arg_t *arg) 671 { 672 smb_joininfo_t jdi; 673 smb_joinres_t jdres; 674 675 bzero(&jdi, sizeof (smb_joininfo_t)); 676 bzero(&jdres, sizeof (smb_joinres_t)); 677 678 if (smb_common_decode(arg->data, arg->datalen, 679 smb_joininfo_xdr, &jdi) != 0) 680 return (SMB_DOP_DECODE_ERROR); 681 682 smbd_join(&jdi, &jdres); 683 684 arg->rbuf = smb_common_encode(&jdres, smb_joinres_xdr, &arg->rsize); 685 686 if (arg->rbuf == NULL) 687 return (SMB_DOP_ENCODE_ERROR); 688 return (SMB_DOP_SUCCESS); 689 } 690 691 static int 692 smbd_dop_get_dcinfo(smbd_arg_t *arg) 693 { 694 smb_domainex_t dxi; 695 696 if (!smb_domain_getinfo(&dxi)) 697 return (SMB_DOP_EMPTYBUF); 698 699 arg->rbuf = smb_string_encode(dxi.d_dci.dc_name, &arg->rsize); 700 701 if (arg->rbuf == NULL) 702 return (SMB_DOP_ENCODE_ERROR); 703 return (SMB_DOP_SUCCESS); 704 } 705 706 /* 707 * Return the number of snapshots for a dataset 708 */ 709 static int 710 smbd_dop_vss_get_count(smbd_arg_t *arg) 711 { 712 smb_string_t path; 713 uint32_t count; 714 715 bzero(&path, sizeof (smb_string_t)); 716 arg->rbuf = NULL; 717 718 if (smb_string_decode(&path, arg->data, arg->datalen) != 0) 719 return (SMB_DOP_DECODE_ERROR); 720 721 if (smbd_vss_get_count(path.buf, &count) == 0) 722 arg->rbuf = smb_common_encode(&count, xdr_uint32_t, 723 &arg->rsize); 724 725 xdr_free(smb_string_xdr, (char *)&path); 726 727 if (arg->rbuf == NULL) 728 return (SMB_DOP_ENCODE_ERROR); 729 return (SMB_DOP_SUCCESS); 730 } 731 732 /* 733 * Return the count and list of snapshots. 734 * The list is in @GMT token format. 735 */ 736 static int 737 smbd_dop_vss_get_snapshots(smbd_arg_t *arg) 738 { 739 char **gmtp; 740 smb_gmttoken_query_t request; 741 smb_gmttoken_response_t reply; 742 uint_t i; 743 744 bzero(&request, sizeof (smb_gmttoken_query_t)); 745 bzero(&reply, sizeof (smb_gmttoken_response_t)); 746 747 if (smb_common_decode(arg->data, arg->datalen, 748 smb_gmttoken_query_xdr, &request) != 0) 749 return (SMB_DOP_DECODE_ERROR); 750 751 reply.gtr_gmttokens.gtr_gmttokens_val = malloc(request.gtq_count * 752 sizeof (char *)); 753 bzero(reply.gtr_gmttokens.gtr_gmttokens_val, request.gtq_count * 754 sizeof (char *)); 755 756 if (reply.gtr_gmttokens.gtr_gmttokens_val == NULL) { 757 xdr_free(smb_gmttoken_query_xdr, (char *)&request); 758 return (SMB_DOP_EMPTYBUF); 759 } 760 761 smbd_vss_get_snapshots(request.gtq_path, request.gtq_count, 762 &reply.gtr_count, 763 &reply.gtr_gmttokens.gtr_gmttokens_len, 764 reply.gtr_gmttokens.gtr_gmttokens_val); 765 766 arg->rbuf = smb_common_encode(&reply, smb_gmttoken_response_xdr, 767 &arg->rsize); 768 if (arg->rbuf == NULL) { 769 xdr_free(smb_gmttoken_query_xdr, (char *)&request); 770 return (SMB_DOP_ENCODE_ERROR); 771 } 772 773 for (i = 0, gmtp = reply.gtr_gmttokens.gtr_gmttokens_val; 774 (i < request.gtq_count); i++) { 775 if (*gmtp) 776 free(*gmtp); 777 gmtp++; 778 } 779 780 free(reply.gtr_gmttokens.gtr_gmttokens_val); 781 xdr_free(smb_gmttoken_query_xdr, (char *)&request); 782 return (SMB_DOP_SUCCESS); 783 } 784 785 /* 786 * Return the name of the snapshot that matches the dataset path 787 * and @GMT token. 788 */ 789 static int 790 smbd_dop_vss_map_gmttoken(smbd_arg_t *arg) 791 { 792 char *snapname; 793 smb_gmttoken_snapname_t request; 794 795 bzero(&request, sizeof (smb_gmttoken_snapname_t)); 796 797 if (smb_common_decode(arg->data, arg->datalen, 798 smb_gmttoken_snapname_xdr, &request) != 0) { 799 xdr_free(smb_gmttoken_snapname_xdr, (char *)&request); 800 return (SMB_DOP_DECODE_ERROR); 801 } 802 803 if ((snapname = malloc(MAXPATHLEN)) == NULL) { 804 xdr_free(smb_gmttoken_snapname_xdr, (char *)&request); 805 return (NULL); 806 } 807 808 if ((smbd_vss_map_gmttoken(request.gts_path, request.gts_gmttoken, 809 request.gts_toktime, snapname) != 0)) { 810 *snapname = '\0'; 811 } 812 813 arg->rbuf = smb_string_encode(snapname, &arg->rsize); 814 xdr_free(smb_gmttoken_snapname_xdr, (char *)&request); 815 free(snapname); 816 817 if (arg->rbuf == NULL) 818 return (SMB_DOP_ENCODE_ERROR); 819 return (SMB_DOP_SUCCESS); 820 } 821 822 static int 823 smbd_dop_ads_find_host(smbd_arg_t *arg) 824 { 825 smb_ads_host_info_t *hinfo = NULL; 826 char *hostname = ""; 827 smb_string_t fqdn; 828 829 bzero(&fqdn, sizeof (smb_string_t)); 830 831 if (smb_string_decode(&fqdn, arg->data, arg->datalen) != 0) 832 return (SMB_DOP_DECODE_ERROR); 833 834 if ((hinfo = smb_ads_find_host(fqdn.buf)) != NULL) 835 hostname = hinfo->name; 836 837 xdr_free(smb_string_xdr, (char *)&fqdn); 838 839 arg->rbuf = smb_string_encode(hostname, &arg->rsize); 840 free(hinfo); 841 842 if (arg->rbuf == NULL) 843 return (SMB_DOP_ENCODE_ERROR); 844 return (SMB_DOP_SUCCESS); 845 } 846 847 /* 848 * Query the list of user/group quota entries for a given filesystem. 849 */ 850 static int 851 smbd_dop_quota_query(smbd_arg_t *arg) 852 { 853 smb_quota_query_t request; 854 smb_quota_response_t reply; 855 uint32_t status; 856 857 bzero(&request, sizeof (smb_quota_query_t)); 858 bzero(&reply, sizeof (smb_quota_response_t)); 859 860 if (smb_common_decode(arg->data, arg->datalen, 861 smb_quota_query_xdr, &request) != 0) 862 return (SMB_DOP_DECODE_ERROR); 863 864 status = smb_quota_query(&request, &reply); 865 reply.qr_status = status; 866 867 arg->rbuf = smb_common_encode(&reply, smb_quota_response_xdr, 868 &arg->rsize); 869 870 xdr_free(smb_quota_query_xdr, (char *)&request); 871 smb_quota_free(&reply); 872 873 if (arg->rbuf == NULL) 874 return (SMB_DOP_ENCODE_ERROR); 875 return (SMB_DOP_SUCCESS); 876 } 877 878 /* 879 * Set a list of user/group quota entries for a given filesystem. 880 */ 881 static int 882 smbd_dop_quota_set(smbd_arg_t *arg) 883 { 884 smb_quota_set_t request; 885 uint32_t status = 0; 886 887 bzero(&request, sizeof (smb_quota_set_t)); 888 889 if (smb_common_decode(arg->data, arg->datalen, 890 smb_quota_set_xdr, &request) != 0) 891 return (SMB_DOP_DECODE_ERROR); 892 893 status = smb_quota_set(&request); 894 895 arg->rbuf = smb_common_encode(&status, xdr_uint32_t, &arg->rsize); 896 xdr_free(smb_quota_set_xdr, (char *)&request); 897 898 if (arg->rbuf == NULL) 899 return (SMB_DOP_ENCODE_ERROR); 900 return (SMB_DOP_SUCCESS); 901 } 902 903 static int 904 smbd_dop_dfs_get_referrals(smbd_arg_t *arg) 905 { 906 dfs_referral_query_t request; 907 dfs_referral_response_t reply; 908 909 bzero(&request, sizeof (request)); 910 bzero(&reply, sizeof (reply)); 911 912 if (smb_common_decode(arg->data, arg->datalen, 913 dfs_referral_query_xdr, &request) != 0) 914 return (SMB_DOP_DECODE_ERROR); 915 916 reply.rp_status = dfs_get_referrals((const char *)request.rq_path, 917 request.rq_type, &reply.rp_referrals); 918 919 if (reply.rp_status != ERROR_SUCCESS) 920 bzero(&reply.rp_referrals, sizeof (dfs_info_t)); 921 922 arg->rbuf = smb_common_encode(&reply, dfs_referral_response_xdr, 923 &arg->rsize); 924 925 if (reply.rp_status == ERROR_SUCCESS) 926 dfs_info_free(&reply.rp_referrals); 927 928 xdr_free(dfs_referral_query_xdr, (char *)&request); 929 930 if (arg->rbuf == NULL) 931 return (SMB_DOP_ENCODE_ERROR); 932 return (SMB_DOP_SUCCESS); 933 } 934 935 static int 936 smbd_dop_shr_hostaccess(smbd_arg_t *arg) 937 { 938 smb_shr_hostaccess_query_t request; 939 uint32_t reply; 940 941 bzero(&request, sizeof (request)); 942 bzero(&reply, sizeof (reply)); 943 944 if (smb_common_decode(arg->data, arg->datalen, 945 smb_shr_hostaccess_query_xdr, &request) != 0) 946 return (SMB_DOP_DECODE_ERROR); 947 948 reply = smb_shr_hostaccess(&request.shq_ipaddr, request.shq_none, 949 request.shq_ro, request.shq_rw, request.shq_flag); 950 951 arg->rbuf = smb_common_encode(&reply, xdr_uint32_t, &arg->rsize); 952 953 xdr_free(smb_shr_hostaccess_query_xdr, (char *)&request); 954 955 if (arg->rbuf == NULL) 956 return (SMB_DOP_ENCODE_ERROR); 957 return (SMB_DOP_SUCCESS); 958 } 959 960 static int 961 smbd_dop_shr_exec(smbd_arg_t *arg) 962 { 963 smb_shr_execinfo_t request; 964 int reply; 965 966 bzero(&request, sizeof (request)); 967 bzero(&reply, sizeof (reply)); 968 969 if (smb_common_decode(arg->data, arg->datalen, 970 smb_shr_execinfo_xdr, &request) != 0) 971 return (SMB_DOP_DECODE_ERROR); 972 973 reply = smb_shr_exec(&request); 974 975 if (reply != 0) 976 syslog(LOG_NOTICE, "Failed to execute %s command", 977 (request.e_type == SMB_EXEC_MAP) ? "map" : "unmap"); 978 979 arg->rbuf = smb_common_encode(&reply, xdr_int, &arg->rsize); 980 981 xdr_free(smb_shr_execinfo_xdr, (char *)&request); 982 983 if (arg->rbuf == NULL) 984 return (SMB_DOP_ENCODE_ERROR); 985 return (SMB_DOP_SUCCESS); 986 } 987 988 /* ARGSUSED */ 989 static int 990 smbd_dop_notify_dc_changed(smbd_arg_t *arg) 991 { 992 993 smbd_dc_monitor_refresh(); 994 995 return (SMB_DOP_SUCCESS); 996 } 997