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