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