source3/smbd/service.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    service (connection) opening and closing
   4    Copyright (C) Andrew Tridgell 1992-1998
   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 "system/filesys.h"
  22 #include "system/passwd.h" /* uid_wrapper */
  23 #include "../lib/tsocket/tsocket.h"
  24 #include "smbd/smbd.h"
  25 #include "smbd/globals.h"
  26 #include "../librpc/gen_ndr/netlogon.h"
  27 #include "../libcli/security/security.h"
  28 #include "printing/pcap.h"
  29 #include "passdb/lookup_sid.h"
  30 #include "auth.h"
  31 #include "lib/param/loadparm.h"
  32 #include "messages.h"
  33
  34 static bool canonicalize_connect_path(connection_struct *conn)
  35 {
  36         bool ret;
  37         char *resolved_name = SMB_VFS_REALPATH(conn,conn->connectpath);
  38         if (!resolved_name) {
  39                 return false;
  40         }
  41         ret = set_conn_connectpath(conn,resolved_name);
  42         SAFE_FREE(resolved_name);
  43         return ret;
  44 }
  45
  46 /****************************************************************************
  47  Ensure when setting connectpath it is a canonicalized (no ./ // or ../)
  48  absolute path stating in / and not ending in /.
  49  Observent people will notice a similarity between this and check_path_syntax :-).
  50 ****************************************************************************/
  51
  52 bool set_conn_connectpath(connection_struct *conn, const char *connectpath)
  53 {
  54         char *destname;
  55         char *d;
  56         const char *s = connectpath;
  57         bool start_of_name_component = true;
  58
  59         if (connectpath == NULL || connectpath[0] == '\0') {
  60                 return false;
  61         }
  62
  63         /* Allocate for strlen + '\0' + possible leading '/' */
  64         destname = (char *)talloc_size(conn, strlen(connectpath) + 2);
  65         if (!destname) {
  66                 return false;
  67         }
  68         d = destname;
  69
  70         *d++ = '/'; /* Always start with root. */
  71
  72         while (*s) {
  73                 if (*s == '/') {
  74                         /* Eat multiple '/' */
  75                         while (*s == '/') {
  76                                 s++;
  77                         }
  78                         if ((d > destname + 1) && (*s != '\0')) {
  79                                 *d++ = '/';
  80                         }
  81                         start_of_name_component = True;
  82                         continue;
  83                 }
  84
  85                 if (start_of_name_component) {
  86                         if ((s[0] == '.') && (s[1] == '.') && (s[2] == '/' || s[2] == '\0')) {
  87                                 /* Uh oh - "/../" or "/..\0" ! */
  88
  89                                 /* Go past the ../ or .. */
  90                                 if (s[2] == '/') {
  91                                         s += 3;
  92                                 } else {
  93                                         s += 2; /* Go past the .. */
  94                                 }
  95
  96                                 /* If  we just added a '/' - delete it */
  97                                 if ((d > destname) && (*(d-1) == '/')) {
  98                                         *(d-1) = '\0';
  99                                         d--;
 100                                 }
 101
 102                                 /* Are we at the start ? Can't go back further if so. */
 103                                 if (d <= destname) {
 104                                         *d++ = '/'; /* Can't delete root */
 105                                         continue;
 106                                 }
 107                                 /* Go back one level... */
 108                                 /* Decrement d first as d points to the *next* char to write into. */
 109                                 for (d--; d > destname; d--) {
 110                                         if (*d == '/') {
 111                                                 break;
 112                                         }
 113                                 }
 114                                 /* We're still at the start of a name component, just the previous one. */
 115                                 continue;
 116                         } else if ((s[0] == '.') && ((s[1] == '\0') || s[1] == '/')) {
 117                                 /* Component of pathname can't be "." only - skip the '.' . */
 118                                 if (s[1] == '/') {
 119                                         s += 2;
 120                                 } else {
 121                                         s++;
 122                                 }
 123                                 continue;
 124                         }
 125                 }
 126
 127                 if (!(*s & 0x80)) {
 128                         *d++ = *s++;
 129                 } else {
 130                         size_t siz;
 131                         /* Get the size of the next MB character. */
 132                         next_codepoint(s,&siz);
 133                         switch(siz) {
 134                                 case 5:
 135                                         *d++ = *s++;
 136                                         /*fall through*/
 137                                 case 4:
 138                                         *d++ = *s++;
 139                                         /*fall through*/
 140                                 case 3:
 141                                         *d++ = *s++;
 142                                         /*fall through*/
 143                                 case 2:
 144                                         *d++ = *s++;
 145                                         /*fall through*/
 146                                 case 1:
 147                                         *d++ = *s++;
 148                                         break;
 149                                 default:
 150                                         break;
 151                         }
 152                 }
 153                 start_of_name_component = false;
 154         }
 155         *d = '\0';
 156
 157         /* And must not end in '/' */
 158         if (d > destname + 1 && (*(d-1) == '/')) {
 159                 *(d-1) = '\0';
 160         }
 161
 162         DEBUG(10,("set_conn_connectpath: service %s, connectpath = %s\n",
 163                 lp_servicename(talloc_tos(), SNUM(conn)), destname ));
 164
 165         talloc_free(conn->connectpath);
 166         conn->connectpath = destname;
 167         /* Ensure conn->cwd is initialized - start as conn->connectpath. */
 168         TALLOC_FREE(conn->cwd);
 169         conn->cwd = talloc_strdup(conn, conn->connectpath);
 170         if (!conn->cwd) {
 171                 return false;
 172         }
 173         return true;
 174 }
 175
 176 /****************************************************************************
 177  Load parameters specific to a connection/service.
 178 ****************************************************************************/
 179
 180 bool set_current_service(connection_struct *conn, uint16 flags, bool do_chdir)
 181 {
 182         int snum;
 183
 184         if (!conn)  {
 185                 last_conn = NULL;
 186                 return(False);
 187         }
 188
 189         conn->lastused_count++;
 190
 191         snum = SNUM(conn);
 192
 193         if (do_chdir &&
 194             vfs_ChDir(conn,conn->connectpath) != 0 &&
 195             vfs_ChDir(conn,conn->origpath) != 0) {
 196                 DEBUG(((errno!=EACCES)?0:3),("chdir (%s) failed, reason: %s\n",
 197                          conn->connectpath, strerror(errno)));
 198                 return(False);
 199         }
 200
 201         if ((conn == last_conn) && (last_flags == flags)) {
 202                 return(True);
 203         }
 204
 205         last_conn = conn;
 206         last_flags = flags;
 207
 208         /* Obey the client case sensitivity requests - only for clients that support it. */
 209         switch (lp_casesensitive(snum)) {
 210                 case Auto:
 211                         {
 212                                 /* We need this uglyness due to DOS/Win9x clients that lie about case insensitivity. */
 213                                 enum remote_arch_types ra_type = get_remote_arch();
 214                                 if ((ra_type != RA_SAMBA) && (ra_type != RA_CIFSFS)) {
 215                                         /* Client can't support per-packet case sensitive pathnames. */
 216                                         conn->case_sensitive = False;
 217                                 } else {
 218                                         conn->case_sensitive = !(flags & FLAG_CASELESS_PATHNAMES);
 219                                 }
 220                         }
 221                         break;
 222                 case True:
 223                         conn->case_sensitive = True;
 224                         break;
 225                 default:
 226                         conn->case_sensitive = False;
 227                         break;
 228         }
 229         return(True);
 230 }
 231
 232 /****************************************************************************
 233  do some basic sainity checks on the share.
 234  This function modifies dev, ecode.
 235 ****************************************************************************/
 236
 237 static NTSTATUS share_sanity_checks(const struct tsocket_address *remote_address,
 238                                     const char *rhost,
 239                                     int snum,
 240                                     fstring dev)
 241 {
 242         char *raddr;
 243
 244         raddr = tsocket_address_inet_addr_string(remote_address,
 245                                                  talloc_tos());
 246         if (raddr == NULL) {
 247                 return NT_STATUS_NO_MEMORY;
 248         }
 249
 250         if (!lp_snum_ok(snum) ||
 251             !allow_access(lp_hostsdeny(snum), lp_hostsallow(snum),
 252                           rhost, raddr)) {
 253                 return NT_STATUS_ACCESS_DENIED;
 254         }
 255
 256         if (dev[0] == '?' || !dev[0]) {
 257                 if (lp_print_ok(snum)) {
 258                         fstrcpy(dev,"LPT1:");
 259                 } else if (strequal(lp_fstype(talloc_tos(), snum), "IPC")) {
 260                         fstrcpy(dev, "IPC");
 261                 } else {
 262                         fstrcpy(dev,"A:");
 263                 }
 264         }
 265
 266         if (!strupper_m(dev)) {
 267                 DEBUG(2,("strupper_m %s failed\n", dev));
 268                 return NT_STATUS_INVALID_PARAMETER;
 269         }
 270
 271         if (lp_print_ok(snum)) {
 272                 if (!strequal(dev, "LPT1:")) {
 273                         return NT_STATUS_BAD_DEVICE_TYPE;
 274                 }
 275         } else if (strequal(lp_fstype(talloc_tos(), snum), "IPC")) {
 276                 if (!strequal(dev, "IPC")) {
 277                         return NT_STATUS_BAD_DEVICE_TYPE;
 278                 }
 279         } else if (!strequal(dev, "A:")) {
 280                 return NT_STATUS_BAD_DEVICE_TYPE;
 281         }
 282
 283         /* Behave as a printer if we are supposed to */
 284         if (lp_print_ok(snum) && (strcmp(dev, "A:") == 0)) {
 285                 fstrcpy(dev, "LPT1:");
 286         }
 287
 288         return NT_STATUS_OK;
 289 }
 290
 291 /*
 292  * Go through lookup_name etc to find the force'd group.
 293  *
 294  * Create a new token from src_token, replacing the primary group sid with the
 295  * one found.
 296  */
 297
 298 static NTSTATUS find_forced_group(bool force_user,
 299                                   int snum, const char *username,
 300                                   struct dom_sid *pgroup_sid,
 301                                   gid_t *pgid)
 302 {
 303         NTSTATUS result = NT_STATUS_NO_SUCH_GROUP;
 304         TALLOC_CTX *frame = talloc_stackframe();
 305         struct dom_sid group_sid;
 306         enum lsa_SidType type;
 307         char *groupname;
 308         bool user_must_be_member = False;
 309         gid_t gid;
 310
 311         groupname = lp_force_group(talloc_tos(), snum);
 312         if (groupname == NULL) {
 313                 DEBUG(1, ("talloc_strdup failed\n"));
 314                 result = NT_STATUS_NO_MEMORY;
 315                 goto done;
 316         }
 317
 318         if (groupname[0] == '+') {
 319                 user_must_be_member = True;
 320                 groupname += 1;
 321         }
 322
 323         groupname = talloc_string_sub(talloc_tos(), groupname,
 324                                       "%S", lp_servicename(talloc_tos(), snum));
 325         if (groupname == NULL) {
 326                 DEBUG(1, ("talloc_string_sub failed\n"));
 327                 result = NT_STATUS_NO_MEMORY;
 328                 goto done;
 329         }
 330
 331         if (!lookup_name_smbconf(talloc_tos(), groupname,
 332                          LOOKUP_NAME_ALL|LOOKUP_NAME_GROUP,
 333                          NULL, NULL, &group_sid, &type)) {
 334                 DEBUG(10, ("lookup_name_smbconf(%s) failed\n",
 335                            groupname));
 336                 goto done;
 337         }
 338
 339         if ((type != SID_NAME_DOM_GRP) && (type != SID_NAME_ALIAS) &&
 340             (type != SID_NAME_WKN_GRP)) {
 341                 DEBUG(10, ("%s is a %s, not a group\n", groupname,
 342                            sid_type_lookup(type)));
 343                 goto done;
 344         }
 345
 346         if (!sid_to_gid(&group_sid, &gid)) {
 347                 DEBUG(10, ("sid_to_gid(%s) for %s failed\n",
 348                            sid_string_dbg(&group_sid), groupname));
 349                 goto done;
 350         }
 351
 352         /*
 353          * If the user has been forced and the forced group starts with a '+',
 354          * then we only set the group to be the forced group if the forced
 355          * user is a member of that group.  Otherwise, the meaning of the '+'
 356          * would be ignored.
 357          */
 358
 359         if (force_user && user_must_be_member) {
 360                 if (user_in_group_sid(username, &group_sid)) {
 361                         sid_copy(pgroup_sid, &group_sid);
 362                         *pgid = gid;
 363                         DEBUG(3,("Forced group %s for member %s\n",
 364                                  groupname, username));
 365                 } else {
 366                         DEBUG(0,("find_forced_group: forced user %s is not a member "
 367                                 "of forced group %s. Disallowing access.\n",
 368                                 username, groupname ));
 369                         result = NT_STATUS_MEMBER_NOT_IN_GROUP;
 370                         goto done;
 371                 }
 372         } else {
 373                 sid_copy(pgroup_sid, &group_sid);
 374                 *pgid = gid;
 375                 DEBUG(3,("Forced group %s\n", groupname));
 376         }
 377
 378         result = NT_STATUS_OK;
 379  done:
 380         TALLOC_FREE(frame);
 381         return result;
 382 }
 383
 384 /****************************************************************************
 385   Create an auth_session_info structure for a connection_struct
 386 ****************************************************************************/
 387
 388 static NTSTATUS create_connection_session_info(struct smbd_server_connection *sconn,
 389                                               TALLOC_CTX *mem_ctx, int snum,
 390                                               struct auth_session_info *session_info,
 391                                               struct auth_session_info **presult)
 392 {
 393         struct auth_session_info *result;
 394
 395         if (lp_guest_only(snum)) {
 396                 return make_session_info_guest(mem_ctx, presult);
 397         }
 398
 399         /*
 400          * This is the normal security != share case where we have a
 401          * valid vuid from the session setup.                 */
 402
 403         if (security_session_user_level(session_info, NULL) < SECURITY_USER) {
 404                 if (!lp_guest_ok(snum)) {
 405                         DEBUG(2, ("guest user (from session setup) "
 406                                   "not permitted to access this share "
 407                                   "(%s)\n", lp_servicename(talloc_tos(), snum)));
 408                         return NT_STATUS_ACCESS_DENIED;
 409                 }
 410         } else {
 411                 if (!user_ok_token(session_info->unix_info->unix_name,
 412                                    session_info->info->domain_name,
 413                                    session_info->security_token, snum)) {
 414                         DEBUG(2, ("user '%s' (from session setup) not "
 415                                   "permitted to access this share "
 416                                   "(%s)\n",
 417                                   session_info->unix_info->unix_name,
 418                                   lp_servicename(talloc_tos(), snum)));
 419                         return NT_STATUS_ACCESS_DENIED;
 420                 }
 421         }
 422
 423         result = copy_session_info(mem_ctx, session_info);
 424         if (result == NULL) {
 425                 return NT_STATUS_NO_MEMORY;
 426         }
 427
 428         *presult = result;
 429         return NT_STATUS_OK;
 430 }
 431
 432 /****************************************************************************
 433   set relavent user and group settings corresponding to force user/group
 434   configuration for the given snum.
 435 ****************************************************************************/
 436
 437 NTSTATUS set_conn_force_user_group(connection_struct *conn, int snum)
 438 {
 439         NTSTATUS status;
 440
 441         if (*lp_force_user(talloc_tos(), snum)) {
 442
 443                 /*
 444                  * Replace conn->session_info with a completely faked up one
 445                  * from the username we are forced into :-)
 446                  */
 447
 448                 char *fuser;
 449                 char *sanitized_username;
 450                 struct auth_session_info *forced_serverinfo;
 451                 bool guest;
 452
 453                 fuser = talloc_string_sub(conn, lp_force_user(talloc_tos(), snum), "%S",
 454                                           lp_const_servicename(snum));
 455                 if (fuser == NULL) {
 456                         return NT_STATUS_NO_MEMORY;
 457                 }
 458
 459                 guest = security_session_user_level(conn->session_info, NULL) < SECURITY_USER;
 460
 461                 status = make_session_info_from_username(
 462                         conn, fuser,
 463                         guest,
 464                         &forced_serverinfo);
 465                 if (!NT_STATUS_IS_OK(status)) {
 466                         return status;
 467                 }
 468
 469                 /* We don't want to replace the original sanitized_username
 470                    as it is the original user given in the connect attempt.
 471                    This is used in '%U' substitutions. */
 472                 sanitized_username = discard_const_p(char,
 473                         forced_serverinfo->unix_info->sanitized_username);
 474                 TALLOC_FREE(sanitized_username);
 475                 forced_serverinfo->unix_info->sanitized_username =
 476                         talloc_move(forced_serverinfo->unix_info,
 477                                 &conn->session_info->unix_info->sanitized_username);
 478
 479                 TALLOC_FREE(conn->session_info);
 480                 conn->session_info = forced_serverinfo;
 481
 482                 conn->force_user = true;
 483                 DEBUG(3,("Forced user %s\n", fuser));
 484         }
 485
 486         /*
 487          * If force group is true, then override
 488          * any groupid stored for the connecting user.
 489          */
 490
 491         if (*lp_force_group(talloc_tos(), snum)) {
 492
 493                 status = find_forced_group(
 494                         conn->force_user, snum, conn->session_info->unix_info->unix_name,
 495                         &conn->session_info->security_token->sids[1],
 496                         &conn->session_info->unix_token->gid);
 497
 498                 if (!NT_STATUS_IS_OK(status)) {
 499                         return status;
 500                 }
 501
 502                 /*
 503                  * We need to cache this gid, to use within
 504                  * change_to_user() separately from the conn->session_info
 505                  * struct. We only use conn->session_info directly if
 506                  * "force_user" was set.
 507                  */
 508                 conn->force_group_gid = conn->session_info->unix_token->gid;
 509         }
 510
 511         return NT_STATUS_OK;
 512 }
 513
 514 /****************************************************************************
 515   Setup the share access mask for a connection.
 516 ****************************************************************************/
 517
 518 static void create_share_access_mask(connection_struct *conn, int snum)
 519 {
 520         const struct security_token *token = conn->session_info->security_token;
 521
 522         share_access_check(token,
 523                         lp_servicename(talloc_tos(), snum),
 524                         MAXIMUM_ALLOWED_ACCESS,
 525                         &conn->share_access);
 526
 527         if (!CAN_WRITE(conn)) {
 528                 conn->share_access &=
 529                         ~(SEC_FILE_WRITE_DATA | SEC_FILE_APPEND_DATA |
 530                           SEC_FILE_WRITE_EA | SEC_FILE_WRITE_ATTRIBUTE |
 531                           SEC_DIR_DELETE_CHILD );
 532         }
 533
 534         if (security_token_has_privilege(token, SEC_PRIV_SECURITY)) {
 535                 conn->share_access |= SEC_FLAG_SYSTEM_SECURITY;
 536         }
 537         if (security_token_has_privilege(token, SEC_PRIV_RESTORE)) {
 538                 conn->share_access |= (SEC_RIGHTS_PRIV_RESTORE);
 539         }
 540         if (security_token_has_privilege(token, SEC_PRIV_BACKUP)) {
 541                 conn->share_access |= (SEC_RIGHTS_PRIV_BACKUP);
 542         }
 543         if (security_token_has_privilege(token, SEC_PRIV_TAKE_OWNERSHIP)) {
 544                 conn->share_access |= (SEC_STD_WRITE_OWNER);
 545         }
 546 }
 547
 548 /****************************************************************************
 549   Make a connection, given the snum to connect to, and the vuser of the
 550   connecting user if appropriate.
 551 ****************************************************************************/
 552
 553 static NTSTATUS make_connection_snum(struct smbd_server_connection *sconn,
 554                                         connection_struct *conn,
 555                                         int snum, struct user_struct *vuser,
 556                                         const char *pdev)
 557 {
 558         struct smb_filename *smb_fname_cpath = NULL;
 559         fstring dev;
 560         int ret;
 561         bool on_err_call_dis_hook = false;
 562         bool claimed_connection = false;
 563         uid_t effuid;
 564         gid_t effgid;
 565         NTSTATUS status;
 566
 567         fstrcpy(dev, pdev);
 568
 569         status = share_sanity_checks(sconn->remote_address,
 570                                        sconn->remote_hostname,
 571                                        snum,
 572                                        dev);
 573         if (NT_STATUS_IS_ERR(status)) {
 574                 goto err_root_exit;
 575         }
 576
 577         conn->params->service = snum;
 578
 579         status = create_connection_session_info(sconn,
 580                 conn, snum, vuser->session_info,
 581                 &conn->session_info);
 582
 583         if (!NT_STATUS_IS_OK(status)) {
 584                 DEBUG(1, ("create_connection_session_info failed: %s\n",
 585                           nt_errstr(status)));
 586                 goto err_root_exit;
 587         }
 588
 589         if (lp_guest_only(snum)) {
 590                 conn->force_user = true;
 591         }
 592
 593         conn->num_files_open = 0;
 594         conn->lastused = conn->lastused_count = time(NULL);
 595         conn->printer = (strncmp(dev,"LPT",3) == 0);
 596         conn->ipc = ( (strncmp(dev,"IPC",3) == 0) ||
 597                       ( lp_enable_asu_support() && strequal(dev,"ADMIN$")) );
 598
 599         /* Case options for the share. */
 600         if (lp_casesensitive(snum) == Auto) {
 601                 /* We will be setting this per packet. Set to be case
 602                  * insensitive for now. */
 603                 conn->case_sensitive = False;
 604         } else {
 605                 conn->case_sensitive = (bool)lp_casesensitive(snum);
 606         }
 607
 608         conn->case_preserve = lp_preservecase(snum);
 609         conn->short_case_preserve = lp_shortpreservecase(snum);
 610
 611         conn->encrypt_level = lp_smb_encrypt(snum);
 612
 613         conn->veto_list = NULL;
 614         conn->hide_list = NULL;
 615         conn->veto_oplock_list = NULL;
 616         conn->aio_write_behind_list = NULL;
 617
 618         conn->read_only = lp_readonly(SNUM(conn));
 619
 620         status = set_conn_force_user_group(conn, snum);
 621         if (!NT_STATUS_IS_OK(status)) {
 622                 goto err_root_exit;
 623         }
 624
 625         conn->vuid = vuser->vuid;
 626
 627         {
 628                 char *s = talloc_sub_advanced(talloc_tos(),
 629                                         lp_servicename(talloc_tos(), SNUM(conn)),
 630                                         conn->session_info->unix_info->unix_name,
 631                                         conn->connectpath,
 632                                         conn->session_info->unix_token->gid,
 633                                         conn->session_info->unix_info->sanitized_username,
 634                                         conn->session_info->info->domain_name,
 635                                         lp_pathname(talloc_tos(), snum));
 636                 if (!s) {
 637                         status = NT_STATUS_NO_MEMORY;
 638                         goto err_root_exit;
 639                 }
 640
 641                 if (!set_conn_connectpath(conn,s)) {
 642                         TALLOC_FREE(s);
 643                         status = NT_STATUS_NO_MEMORY;
 644                         goto err_root_exit;
 645                 }
 646                 DEBUG(3,("Connect path is '%s' for service [%s]\n",s,
 647                          lp_servicename(talloc_tos(), snum)));
 648                 TALLOC_FREE(s);
 649         }
 650
 651         /*
 652          * New code to check if there's a share security descripter
 653          * added from NT server manager. This is done after the
 654          * smb.conf checks are done as we need a uid and token. JRA.
 655          *
 656          */
 657
 658         create_share_access_mask(conn, snum);
 659
 660         if ((conn->share_access & FILE_WRITE_DATA) == 0) {
 661                 if ((conn->share_access & FILE_READ_DATA) == 0) {
 662                         /* No access, read or write. */
 663                         DEBUG(0,("make_connection: connection to %s "
 664                                  "denied due to security "
 665                                  "descriptor.\n",
 666                                  lp_servicename(talloc_tos(), snum)));
 667                         status = NT_STATUS_ACCESS_DENIED;
 668                         goto err_root_exit;
 669                 } else {
 670                         conn->read_only = True;
 671                 }
 672         }
 673         /* Initialise VFS function pointers */
 674
 675         if (!smbd_vfs_init(conn)) {
 676                 DEBUG(0, ("vfs_init failed for service %s\n",
 677                           lp_servicename(talloc_tos(), snum)));
 678                 status = NT_STATUS_BAD_NETWORK_NAME;
 679                 goto err_root_exit;
 680         }
 681
 682 /* ROOT Activities: */
 683         /* explicitly check widelinks here so that we can correctly warn
 684          * in the logs. */
 685         widelinks_warning(snum);
 686
 687         /*
 688          * Enforce the max connections parameter.
 689          */
 690
 691         if ((lp_max_connections(snum) > 0)
 692             && (count_current_connections(lp_servicename(talloc_tos(), SNUM(conn)), True) >=
 693                 lp_max_connections(snum))) {
 694
 695                 DEBUG(1, ("Max connections (%d) exceeded for %s\n",
 696                           lp_max_connections(snum),
 697                           lp_servicename(talloc_tos(), snum)));
 698                 status = NT_STATUS_INSUFFICIENT_RESOURCES;
 699                 goto err_root_exit;
 700         }
 701
 702         /*
 703          * Get us an entry in the connections db
 704          */
 705         if (!claim_connection(conn, lp_servicename(talloc_tos(), snum))) {
 706                 DEBUG(1, ("Could not store connections entry\n"));
 707                 status = NT_STATUS_INTERNAL_DB_ERROR;
 708                 goto err_root_exit;
 709         }
 710         claimed_connection = true;
 711
 712         /* Invoke VFS make connection hook - this must be the first
 713            filesystem operation that we do. */
 714
 715         if (SMB_VFS_CONNECT(conn, lp_servicename(talloc_tos(), snum),
 716                             conn->session_info->unix_info->unix_name) < 0) {
 717                 DEBUG(0,("make_connection: VFS make connection failed!\n"));
 718                 status = NT_STATUS_UNSUCCESSFUL;
 719                 goto err_root_exit;
 720         }
 721
 722         /* Any error exit after here needs to call the disconnect hook. */
 723         on_err_call_dis_hook = true;
 724
 725         if ((!conn->printer) && (!conn->ipc) &&
 726             lp_change_notify(conn->params)) {
 727                 if (sconn->notify_ctx == NULL) {
 728                         sconn->notify_ctx = notify_init(
 729                                 sconn, sconn->msg_ctx, sconn->ev_ctx);
 730                 }
 731                 if (sconn->sys_notify_ctx == NULL) {
 732                         sconn->sys_notify_ctx = sys_notify_context_create(
 733                                 sconn, sconn->ev_ctx);
 734                 }
 735         }
 736
 737         if (lp_kernel_oplocks(snum)) {
 738                 init_kernel_oplocks(conn->sconn);
 739         }
 740
 741         /*
 742          * Fix compatibility issue pointed out by Volker.
 743          * We pass the conn->connectpath to the preexec
 744          * scripts as a parameter, so attempt to canonicalize
 745          * it here before calling the preexec scripts.
 746          * We ignore errors here, as it is possible that
 747          * the conn->connectpath doesn't exist yet and
 748          * the preexec scripts will create them.
 749          */
 750
 751         (void)canonicalize_connect_path(conn);
 752
 753         /* Preexecs are done here as they might make the dir we are to ChDir
 754          * to below */
 755         /* execute any "root preexec = " line */
 756         if (*lp_rootpreexec(talloc_tos(), snum)) {
 757                 char *cmd = talloc_sub_advanced(talloc_tos(),
 758                                         lp_servicename(talloc_tos(), SNUM(conn)),
 759                                         conn->session_info->unix_info->unix_name,
 760                                         conn->connectpath,
 761                                         conn->session_info->unix_token->gid,
 762                                         conn->session_info->unix_info->sanitized_username,
 763                                         conn->session_info->info->domain_name,
 764                                         lp_rootpreexec(talloc_tos(), snum));
 765                 DEBUG(5,("cmd=%s\n",cmd));
 766                 ret = smbrun(cmd,NULL);
 767                 TALLOC_FREE(cmd);
 768                 if (ret != 0 && lp_rootpreexec_close(snum)) {
 769                         DEBUG(1,("root preexec gave %d - failing "
 770                                  "connection\n", ret));
 771                         status = NT_STATUS_ACCESS_DENIED;
 772                         goto err_root_exit;
 773                 }
 774         }
 775
 776 /* USER Activites: */
 777         if (!change_to_user(conn, conn->vuid)) {
 778                 /* No point continuing if they fail the basic checks */
 779                 DEBUG(0,("Can't become connected user!\n"));
 780                 status = NT_STATUS_LOGON_FAILURE;
 781                 goto err_root_exit;
 782         }
 783
 784         effuid = geteuid();
 785         effgid = getegid();
 786
 787         /* Remember that a different vuid can connect later without these
 788          * checks... */
 789
 790         /* Preexecs are done here as they might make the dir we are to ChDir
 791          * to below */
 792
 793         /* execute any "preexec = " line */
 794         if (*lp_preexec(talloc_tos(), snum)) {
 795                 char *cmd = talloc_sub_advanced(talloc_tos(),
 796                                         lp_servicename(talloc_tos(), SNUM(conn)),
 797                                         conn->session_info->unix_info->unix_name,
 798                                         conn->connectpath,
 799                                         conn->session_info->unix_token->gid,
 800                                         conn->session_info->unix_info->sanitized_username,
 801                                         conn->session_info->info->domain_name,
 802                                         lp_preexec(talloc_tos(), snum));
 803                 ret = smbrun(cmd,NULL);
 804                 TALLOC_FREE(cmd);
 805                 if (ret != 0 && lp_preexec_close(snum)) {
 806                         DEBUG(1,("preexec gave %d - failing connection\n",
 807                                  ret));
 808                         status = NT_STATUS_ACCESS_DENIED;
 809                         goto err_root_exit;
 810                 }
 811         }
 812
 813 #ifdef WITH_FAKE_KASERVER
 814         if (lp_afs_share(snum)) {
 815                 afs_login(conn);
 816         }
 817 #endif
 818
 819         /*
 820          * we've finished with the user stuff - go back to root
 821          * so the SMB_VFS_STAT call will only fail on path errors,
 822          * not permission problems.
 823          */
 824         change_to_root_user();
 825 /* ROOT Activites: */
 826
 827         /*
 828          * If widelinks are disallowed we need to canonicalise the connect
 829          * path here to ensure we don't have any symlinks in the
 830          * connectpath. We will be checking all paths on this connection are
 831          * below this directory. We must do this after the VFS init as we
 832          * depend on the realpath() pointer in the vfs table. JRA.
 833          */
 834         if (!lp_widelinks(snum)) {
 835                 if (!canonicalize_connect_path(conn)) {
 836                         DEBUG(0, ("canonicalize_connect_path failed "
 837                         "for service %s, path %s\n",
 838                                 lp_servicename(talloc_tos(), snum),
 839                                 conn->connectpath));
 840                         status = NT_STATUS_BAD_NETWORK_NAME;
 841                         goto err_root_exit;
 842                 }
 843         }
 844
 845         /* Add veto/hide lists */
 846         if (!IS_IPC(conn) && !IS_PRINT(conn)) {
 847                 set_namearray( &conn->veto_list,
 848                                lp_veto_files(talloc_tos(), snum));
 849                 set_namearray( &conn->hide_list,
 850                                lp_hide_files(talloc_tos(), snum));
 851                 set_namearray( &conn->veto_oplock_list,
 852                                lp_veto_oplocks(talloc_tos(), snum));
 853                 set_namearray( &conn->aio_write_behind_list,
 854                                 lp_aio_write_behind(talloc_tos(), snum));
 855         }
 856         status = create_synthetic_smb_fname(talloc_tos(), conn->connectpath,
 857                                             NULL, NULL, &smb_fname_cpath);
 858         if (!NT_STATUS_IS_OK(status)) {
 859                 goto err_root_exit;
 860         }
 861
 862         /* win2000 does not check the permissions on the directory
 863            during the tree connect, instead relying on permission
 864            check during individual operations. To match this behaviour
 865            I have disabled this chdir check (tridge) */
 866         /* the alternative is just to check the directory exists */
 867
 868         if ((ret = SMB_VFS_STAT(conn, smb_fname_cpath)) != 0 ||
 869             !S_ISDIR(smb_fname_cpath->st.st_ex_mode)) {
 870                 if (ret == 0 && !S_ISDIR(smb_fname_cpath->st.st_ex_mode)) {
 871                         DEBUG(0,("'%s' is not a directory, when connecting to "
 872                                  "[%s]\n", conn->connectpath,
 873                                  lp_servicename(talloc_tos(), snum)));
 874                 } else {
 875                         DEBUG(0,("'%s' does not exist or permission denied "
 876                                  "when connecting to [%s] Error was %s\n",
 877                                  conn->connectpath,
 878                                  lp_servicename(talloc_tos(), snum),
 879                                  strerror(errno) ));
 880                 }
 881                 status = NT_STATUS_BAD_NETWORK_NAME;
 882                 goto err_root_exit;
 883         }
 884         conn->base_share_dev = smb_fname_cpath->st.st_ex_dev;
 885
 886         talloc_free(conn->origpath);
 887         conn->origpath = talloc_strdup(conn, conn->connectpath);
 888
 889         /* Figure out the characteristics of the underlying filesystem. This
 890          * assumes that all the filesystem mounted withing a share path have
 891          * the same characteristics, which is likely but not guaranteed.
 892          */
 893
 894         conn->fs_capabilities = SMB_VFS_FS_CAPABILITIES(conn, &conn->ts_res);
 895
 896         /*
 897          * Print out the 'connected as' stuff here as we need
 898          * to know the effective uid and gid we will be using
 899          * (at least initially).
 900          */
 901
 902         if( DEBUGLVL( IS_IPC(conn) ? 3 : 1 ) ) {
 903                 dbgtext( "%s (%s) ", get_remote_machine_name(),
 904                          tsocket_address_string(conn->sconn->remote_address,
 905                                                 talloc_tos()) );
 906                 dbgtext( "%s", srv_is_signing_active(sconn) ? "signed " : "");
 907                 dbgtext( "connect to service %s ",
 908                          lp_servicename(talloc_tos(), snum) );
 909                 dbgtext( "initially as user %s ",
 910                          conn->session_info->unix_info->unix_name );
 911                 dbgtext( "(uid=%d, gid=%d) ", (int)effuid, (int)effgid );
 912                 dbgtext( "(pid %d)\n", (int)getpid() );
 913         }
 914
 915         return status;
 916
 917   err_root_exit:
 918
 919         TALLOC_FREE(smb_fname_cpath);
 920         /* We must exit this function as root. */
 921         if (geteuid() != 0) {
 922                 change_to_root_user();
 923         }
 924         if (on_err_call_dis_hook) {
 925                 /* Call VFS disconnect hook */
 926                 SMB_VFS_DISCONNECT(conn);
 927         }
 928         if (claimed_connection) {
 929                 yield_connection(conn, lp_servicename(talloc_tos(), snum));
 930         }
 931         return status;
 932 }
 933
 934 /****************************************************************************
 935  Make a connection to a service from SMB1. Internal interface.
 936 ****************************************************************************/
 937
 938 static connection_struct *make_connection_smb1(struct smbd_server_connection *sconn,
 939                                         int snum, struct user_struct *vuser,
 940                                         const char *pdev,
 941                                         NTSTATUS *pstatus)
 942 {
 943         struct smbXsrv_tcon *tcon;
 944         NTSTATUS status;
 945         NTTIME now = 0;
 946         struct connection_struct *conn;
 947
 948         status = smb1srv_tcon_create(sconn->conn, now, &tcon);
 949         if (!NT_STATUS_IS_OK(status)) {
 950                 DEBUG(0,("make_connection_smb1: Couldn't find free tcon %s.\n",
 951                          nt_errstr(status)));
 952                 *pstatus = status;
 953                 return NULL;
 954         }
 955
 956         conn = conn_new(sconn);
 957         if (!conn) {
 958                 TALLOC_FREE(tcon);
 959
 960                 DEBUG(0,("make_connection_smb1: Couldn't find free connection.\n"));
 961                 *pstatus = NT_STATUS_INSUFFICIENT_RESOURCES;
 962                 return NULL;
 963         }
 964
 965         conn->cnum = tcon->global->tcon_wire_id;
 966         conn->tcon = tcon;
 967
 968         *pstatus = make_connection_snum(sconn,
 969                                         conn,
 970                                         snum,
 971                                         vuser,
 972                                         pdev);
 973         if (!NT_STATUS_IS_OK(*pstatus)) {
 974                 conn_free(conn);
 975                 TALLOC_FREE(tcon);
 976                 return NULL;
 977         }
 978
 979         tcon->global->share_name = lp_servicename(tcon->global, SNUM(conn));
 980         if (tcon->global->share_name == NULL) {
 981                 conn_free(conn);
 982                 TALLOC_FREE(tcon);
 983                 *pstatus = NT_STATUS_NO_MEMORY;
 984                 return NULL;
 985         }
 986
 987         tcon->compat = talloc_move(tcon, &conn);
 988         tcon->status = NT_STATUS_OK;
 989
 990         *pstatus = smbXsrv_tcon_update(tcon);
 991         if (!NT_STATUS_IS_OK(*pstatus)) {
 992                 TALLOC_FREE(tcon);
 993                 return NULL;
 994         }
 995
 996         return tcon->compat;
 997 }
 998
 999 /****************************************************************************
1000  Make a connection to a service from SMB2. External SMB2 interface.
1001  We must set cnum before claiming connection.
1002 ****************************************************************************/
1003
1004 connection_struct *make_connection_smb2(struct smbd_server_connection *sconn,
1005                                         struct smbXsrv_tcon *tcon,
1006                                         int snum,
1007                                         struct user_struct *vuser,
1008                                         const char *pdev,
1009                                         NTSTATUS *pstatus)
1010 {
1011         connection_struct *conn = conn_new(sconn);
1012         if (!conn) {
1013                 DEBUG(0,("make_connection_smb2: Couldn't find free connection.\n"));
1014                 *pstatus = NT_STATUS_INSUFFICIENT_RESOURCES;
1015                 return NULL;
1016         }
1017
1018         conn->cnum = tcon->global->tcon_wire_id;
1019         conn->tcon = tcon;
1020
1021         *pstatus = make_connection_snum(sconn,
1022                                         conn,
1023                                         snum,
1024                                         vuser,
1025                                         pdev);
1026         if (!NT_STATUS_IS_OK(*pstatus)) {
1027                 conn_free(conn);
1028                 return NULL;
1029         }
1030         return conn;
1031 }
1032
1033 /****************************************************************************
1034  Make a connection to a service. External SMB1 interface.
1035  *
1036  * @param service
1037 ****************************************************************************/
1038
1039 connection_struct *make_connection(struct smbd_server_connection *sconn,
1040                                    const char *service_in,
1041                                    const char *pdev, uint64_t vuid,
1042                                    NTSTATUS *status)
1043 {
1044         uid_t euid;
1045         struct user_struct *vuser = NULL;
1046         char *service = NULL;
1047         fstring dev;
1048         int snum = -1;
1049
1050         fstrcpy(dev, pdev);
1051
1052         /* This must ONLY BE CALLED AS ROOT. As it exits this function as
1053          * root. */
1054         if (!non_root_mode() && (euid = geteuid()) != 0) {
1055                 DEBUG(0,("make_connection: PANIC ERROR. Called as nonroot "
1056                          "(%u)\n", (unsigned int)euid ));
1057                 smb_panic("make_connection: PANIC ERROR. Called as nonroot\n");
1058         }
1059
1060         if (conn_num_open(sconn) > 2047) {
1061                 *status = NT_STATUS_INSUFF_SERVER_RESOURCES;
1062                 return NULL;
1063         }
1064
1065         vuser = get_valid_user_struct(sconn, vuid);
1066         if (!vuser) {
1067                 DEBUG(1,("make_connection: refusing to connect with "
1068                          "no session setup\n"));
1069                 *status = NT_STATUS_ACCESS_DENIED;
1070                 return NULL;
1071         }
1072
1073         /* Logic to try and connect to the correct [homes] share, preferably
1074            without too many getpwnam() lookups.  This is particulary nasty for
1075            winbind usernames, where the share name isn't the same as unix
1076            username.
1077
1078            The snum of the homes share is stored on the vuser at session setup
1079            time.
1080         */
1081
1082         if (strequal(service_in,HOMES_NAME)) {
1083                 if (vuser->homes_snum == -1) {
1084                         DEBUG(2, ("[homes] share not available for "
1085                                   "this user because it was not found "
1086                                   "or created at session setup "
1087                                   "time\n"));
1088                         *status = NT_STATUS_BAD_NETWORK_NAME;
1089                         return NULL;
1090                 }
1091                 DEBUG(5, ("making a connection to [homes] service "
1092                           "created at session setup time\n"));
1093                 return make_connection_smb1(sconn,
1094                                             vuser->homes_snum,
1095                                             vuser,
1096                                             dev, status);
1097         } else if ((vuser->homes_snum != -1)
1098                    && strequal(service_in,
1099                                lp_servicename(talloc_tos(), vuser->homes_snum))) {
1100                 DEBUG(5, ("making a connection to 'homes' service [%s] "
1101                           "created at session setup time\n", service_in));
1102                 return make_connection_smb1(sconn,
1103                                             vuser->homes_snum,
1104                                             vuser,
1105                                             dev, status);
1106         }
1107
1108         service = talloc_strdup(talloc_tos(), service_in);
1109         if (!service) {
1110                 *status = NT_STATUS_NO_MEMORY;
1111                 return NULL;
1112         }
1113
1114         if (!strlower_m(service)) {
1115                 DEBUG(2, ("strlower_m %s failed\n", service));
1116                 *status = NT_STATUS_INVALID_PARAMETER;
1117                 return NULL;
1118         }
1119
1120         snum = find_service(talloc_tos(), service, &service);
1121         if (!service) {
1122                 *status = NT_STATUS_NO_MEMORY;
1123                 return NULL;
1124         }
1125
1126         if (snum < 0) {
1127                 if (strequal(service,"IPC$") ||
1128                     (lp_enable_asu_support() && strequal(service,"ADMIN$"))) {
1129                         DEBUG(3,("refusing IPC connection to %s\n", service));
1130                         *status = NT_STATUS_ACCESS_DENIED;
1131                         return NULL;
1132                 }
1133
1134                 DEBUG(3,("%s (%s) couldn't find service %s\n",
1135                         get_remote_machine_name(),
1136                         tsocket_address_string(
1137                                 sconn->remote_address, talloc_tos()),
1138                         service));
1139                 *status = NT_STATUS_BAD_NETWORK_NAME;
1140                 return NULL;
1141         }
1142
1143         /* Handle non-Dfs clients attempting connections to msdfs proxy */
1144         if (lp_host_msdfs() && (*lp_msdfs_proxy(talloc_tos(), snum) != '\0'))  {
1145                 DEBUG(3, ("refusing connection to dfs proxy share '%s' "
1146                           "(pointing to %s)\n",
1147                         service, lp_msdfs_proxy(talloc_tos(), snum)));
1148                 *status = NT_STATUS_BAD_NETWORK_NAME;
1149                 return NULL;
1150         }
1151
1152         DEBUG(5, ("making a connection to 'normal' service %s\n", service));
1153
1154         return make_connection_smb1(sconn, snum, vuser,
1155                                     dev, status);
1156 }
1157
1158 /****************************************************************************
1159  Close a cnum.
1160 ****************************************************************************/
1161
1162 void close_cnum(connection_struct *conn, uint64_t vuid)
1163 {
1164         file_close_conn(conn);
1165
1166         if (!IS_IPC(conn)) {
1167                 dptr_closecnum(conn);
1168         }
1169
1170         change_to_root_user();
1171
1172         DEBUG(IS_IPC(conn)?3:1, ("%s (%s) closed connection to service %s\n",
1173                                  get_remote_machine_name(),
1174                                  tsocket_address_string(conn->sconn->remote_address,
1175                                                         talloc_tos()),
1176                                  lp_servicename(talloc_tos(), SNUM(conn))));
1177
1178         /* Call VFS disconnect hook */
1179         SMB_VFS_DISCONNECT(conn);
1180
1181         yield_connection(conn, lp_servicename(talloc_tos(), SNUM(conn)));
1182
1183         /* make sure we leave the directory available for unmount */
1184         vfs_ChDir(conn, "/");
1185
1186         /* execute any "postexec = " line */
1187         if (*lp_postexec(talloc_tos(), SNUM(conn)) &&
1188             change_to_user(conn, vuid))  {
1189                 char *cmd = talloc_sub_advanced(talloc_tos(),
1190                                         lp_servicename(talloc_tos(), SNUM(conn)),
1191                                         conn->session_info->unix_info->unix_name,
1192                                         conn->connectpath,
1193                                         conn->session_info->unix_token->gid,
1194                                         conn->session_info->unix_info->sanitized_username,
1195                                         conn->session_info->info->domain_name,
1196                                         lp_postexec(talloc_tos(), SNUM(conn)));
1197                 smbrun(cmd,NULL);
1198                 TALLOC_FREE(cmd);
1199                 change_to_root_user();
1200         }
1201
1202         change_to_root_user();
1203         /* execute any "root postexec = " line */
1204         if (*lp_rootpostexec(talloc_tos(), SNUM(conn)))  {
1205                 char *cmd = talloc_sub_advanced(talloc_tos(),
1206                                         lp_servicename(talloc_tos(), SNUM(conn)),
1207                                         conn->session_info->unix_info->unix_name,
1208                                         conn->connectpath,
1209                                         conn->session_info->unix_token->gid,
1210                                         conn->session_info->unix_info->sanitized_username,
1211                                         conn->session_info->info->domain_name,
1212                                         lp_rootpostexec(talloc_tos(), SNUM(conn)));
1213                 smbrun(cmd,NULL);
1214                 TALLOC_FREE(cmd);
1215         }
1216
1217         conn_free(conn);
1218 }