fs/cifs/connect.c

   1 /*
   2  *   fs/cifs/connect.c
   3  *
   4  *   Copyright (C) International Business Machines  Corp., 2002,2009
   5  *   Author(s): Steve French (sfrench@us.ibm.com)
   6  *
   7  *   This library is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU Lesser General Public License as published
   9  *   by the Free Software Foundation; either version 2.1 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This library is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15  *   the GNU Lesser General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU Lesser General Public License
  18  *   along with this library; if not, write to the Free Software
  19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  20  */
  21 #include <linux/fs.h>
  22 #include <linux/net.h>
  23 #include <linux/string.h>
  24 #include <linux/list.h>
  25 #include <linux/wait.h>
  26 #include <linux/slab.h>
  27 #include <linux/pagemap.h>
  28 #include <linux/ctype.h>
  29 #include <linux/utsname.h>
  30 #include <linux/mempool.h>
  31 #include <linux/delay.h>
  32 #include <linux/completion.h>
  33 #include <linux/kthread.h>
  34 #include <linux/pagevec.h>
  35 #include <linux/freezer.h>
  36 #include <linux/namei.h>
  37 #include <asm/uaccess.h>
  38 #include <asm/processor.h>
  39 #include <linux/inet.h>
  40 #include <net/ipv6.h>
  41 #include "cifspdu.h"
  42 #include "cifsglob.h"
  43 #include "cifsproto.h"
  44 #include "cifs_unicode.h"
  45 #include "cifs_debug.h"
  46 #include "cifs_fs_sb.h"
  47 #include "ntlmssp.h"
  48 #include "nterr.h"
  49 #include "rfc1002pdu.h"
  50 #include "fscache.h"
  51
  52 #define CIFS_PORT 445
  53 #define RFC1001_PORT 139
  54
  55 /* SMB echo "timeout" -- FIXME: tunable? */
  56 #define SMB_ECHO_INTERVAL (60 * HZ)
  57
  58 extern mempool_t *cifs_req_poolp;
  59
  60 struct smb_vol {
  61         char *username;
  62         char *password;
  63         char *domainname;
  64         char *UNC;
  65         char *UNCip;
  66         char *iocharset;  /* local code page for mapping to and from Unicode */
  67         char source_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* clnt nb name */
  68         char target_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* srvr nb name */
  69         uid_t cred_uid;
  70         uid_t linux_uid;
  71         gid_t linux_gid;
  72         mode_t file_mode;
  73         mode_t dir_mode;
  74         unsigned secFlg;
  75         bool retry:1;
  76         bool intr:1;
  77         bool setuids:1;
  78         bool override_uid:1;
  79         bool override_gid:1;
  80         bool dynperm:1;
  81         bool noperm:1;
  82         bool no_psx_acl:1; /* set if posix acl support should be disabled */
  83         bool cifs_acl:1;
  84         bool no_xattr:1;   /* set if xattr (EA) support should be disabled*/
  85         bool server_ino:1; /* use inode numbers from server ie UniqueId */
  86         bool direct_io:1;
  87         bool strict_io:1; /* strict cache behavior */
  88         bool remap:1;      /* set to remap seven reserved chars in filenames */
  89         bool posix_paths:1; /* unset to not ask for posix pathnames. */
  90         bool no_linux_ext:1;
  91         bool sfu_emul:1;
  92         bool nullauth:1;   /* attempt to authenticate with null user */
  93         bool nocase:1;     /* request case insensitive filenames */
  94         bool nobrl:1;      /* disable sending byte range locks to srv */
  95         bool mand_lock:1;  /* send mandatory not posix byte range lock reqs */
  96         bool seal:1;       /* request transport encryption on share */
  97         bool nodfs:1;      /* Do not request DFS, even if available */
  98         bool local_lease:1; /* check leases only on local system, not remote */
  99         bool noblocksnd:1;
 100         bool noautotune:1;
 101         bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
 102         bool fsc:1;     /* enable fscache */
 103         bool mfsymlinks:1; /* use Minshall+French Symlinks */
 104         bool multiuser:1;
 105         unsigned int rsize;
 106         unsigned int wsize;
 107         bool sockopt_tcp_nodelay:1;
 108         unsigned short int port;
 109         unsigned long actimeo; /* attribute cache timeout (jiffies) */
 110         char *prepath;
 111         struct sockaddr_storage srcaddr; /* allow binding to a local IP */
 112         struct nls_table *local_nls;
 113 };
 114
 115 /* FIXME: should these be tunable? */
 116 #define TLINK_ERROR_EXPIRE      (1 * HZ)
 117 #define TLINK_IDLE_EXPIRE       (600 * HZ)
 118
 119 static int ip_connect(struct TCP_Server_Info *server);
 120 static int generic_ip_connect(struct TCP_Server_Info *server);
 121 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
 122 static void cifs_prune_tlinks(struct work_struct *work);
 123
 124 /*
 125  * cifs tcp session reconnection
 126  *
 127  * mark tcp session as reconnecting so temporarily locked
 128  * mark all smb sessions as reconnecting for tcp session
 129  * reconnect tcp session
 130  * wake up waiters on reconnection? - (not needed currently)
 131  */
 132 static int
 133 cifs_reconnect(struct TCP_Server_Info *server)
 134 {
 135         int rc = 0;
 136         struct list_head *tmp, *tmp2;
 137         struct cifsSesInfo *ses;
 138         struct cifsTconInfo *tcon;
 139         struct mid_q_entry *mid_entry;
 140
 141         spin_lock(&GlobalMid_Lock);
 142         if (server->tcpStatus == CifsExiting) {
 143                 /* the demux thread will exit normally
 144                 next time through the loop */
 145                 spin_unlock(&GlobalMid_Lock);
 146                 return rc;
 147         } else
 148                 server->tcpStatus = CifsNeedReconnect;
 149         spin_unlock(&GlobalMid_Lock);
 150         server->maxBuf = 0;
 151
 152         cFYI(1, "Reconnecting tcp session");
 153
 154         /* before reconnecting the tcp session, mark the smb session (uid)
 155                 and the tid bad so they are not used until reconnected */
 156         cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
 157         spin_lock(&cifs_tcp_ses_lock);
 158         list_for_each(tmp, &server->smb_ses_list) {
 159                 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
 160                 ses->need_reconnect = true;
 161                 ses->ipc_tid = 0;
 162                 list_for_each(tmp2, &ses->tcon_list) {
 163                         tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
 164                         tcon->need_reconnect = true;
 165                 }
 166         }
 167         spin_unlock(&cifs_tcp_ses_lock);
 168
 169         /* do not want to be sending data on a socket we are freeing */
 170         cFYI(1, "%s: tearing down socket", __func__);
 171         mutex_lock(&server->srv_mutex);
 172         if (server->ssocket) {
 173                 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
 174                         server->ssocket->flags);
 175                 kernel_sock_shutdown(server->ssocket, SHUT_WR);
 176                 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
 177                         server->ssocket->state,
 178                         server->ssocket->flags);
 179                 sock_release(server->ssocket);
 180                 server->ssocket = NULL;
 181         }
 182         server->sequence_number = 0;
 183         server->session_estab = false;
 184         kfree(server->session_key.response);
 185         server->session_key.response = NULL;
 186         server->session_key.len = 0;
 187         server->lstrp = jiffies;
 188         mutex_unlock(&server->srv_mutex);
 189
 190         /* mark submitted MIDs for retry and issue callback */
 191         cFYI(1, "%s: issuing mid callbacks", __func__);
 192         spin_lock(&GlobalMid_Lock);
 193         list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 194                 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 195                 if (mid_entry->midState == MID_REQUEST_SUBMITTED)
 196                         mid_entry->midState = MID_RETRY_NEEDED;
 197                 list_del_init(&mid_entry->qhead);
 198                 mid_entry->callback(mid_entry);
 199         }
 200         spin_unlock(&GlobalMid_Lock);
 201
 202         while ((server->tcpStatus != CifsExiting) &&
 203                (server->tcpStatus != CifsGood)) {
 204                 try_to_freeze();
 205
 206                 /* we should try only the port we connected to before */
 207                 rc = generic_ip_connect(server);
 208                 if (rc) {
 209                         cFYI(1, "reconnect error %d", rc);
 210                         msleep(3000);
 211                 } else {
 212                         atomic_inc(&tcpSesReconnectCount);
 213                         spin_lock(&GlobalMid_Lock);
 214                         if (server->tcpStatus != CifsExiting)
 215                                 server->tcpStatus = CifsGood;
 216                         spin_unlock(&GlobalMid_Lock);
 217                 }
 218         }
 219
 220         return rc;
 221 }
 222
 223 /*
 224         return codes:
 225                 0       not a transact2, or all data present
 226                 >0      transact2 with that much data missing
 227                 -EINVAL = invalid transact2
 228
 229  */
 230 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
 231 {
 232         struct smb_t2_rsp *pSMBt;
 233         int remaining;
 234         __u16 total_data_size, data_in_this_rsp;
 235
 236         if (pSMB->Command != SMB_COM_TRANSACTION2)
 237                 return 0;
 238
 239         /* check for plausible wct, bcc and t2 data and parm sizes */
 240         /* check for parm and data offset going beyond end of smb */
 241         if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
 242                 cFYI(1, "invalid transact2 word count");
 243                 return -EINVAL;
 244         }
 245
 246         pSMBt = (struct smb_t2_rsp *)pSMB;
 247
 248         total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
 249         data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
 250
 251         if (total_data_size == data_in_this_rsp)
 252                 return 0;
 253         else if (total_data_size < data_in_this_rsp) {
 254                 cFYI(1, "total data %d smaller than data in frame %d",
 255                         total_data_size, data_in_this_rsp);
 256                 return -EINVAL;
 257         }
 258
 259         remaining = total_data_size - data_in_this_rsp;
 260
 261         cFYI(1, "missing %d bytes from transact2, check next response",
 262                 remaining);
 263         if (total_data_size > maxBufSize) {
 264                 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
 265                         total_data_size, maxBufSize);
 266                 return -EINVAL;
 267         }
 268         return remaining;
 269 }
 270
 271 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
 272 {
 273         struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
 274         struct smb_t2_rsp *pSMBt  = (struct smb_t2_rsp *)pTargetSMB;
 275         char *data_area_of_target;
 276         char *data_area_of_buf2;
 277         int remaining;
 278         __u16 byte_count, total_data_size, total_in_buf, total_in_buf2;
 279
 280         total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
 281
 282         if (total_data_size !=
 283             get_unaligned_le16(&pSMB2->t2_rsp.TotalDataCount))
 284                 cFYI(1, "total data size of primary and secondary t2 differ");
 285
 286         total_in_buf = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
 287
 288         remaining = total_data_size - total_in_buf;
 289
 290         if (remaining < 0)
 291                 return -EINVAL;
 292
 293         if (remaining == 0) /* nothing to do, ignore */
 294                 return 0;
 295
 296         total_in_buf2 = get_unaligned_le16(&pSMB2->t2_rsp.DataCount);
 297         if (remaining < total_in_buf2) {
 298                 cFYI(1, "transact2 2nd response contains too much data");
 299         }
 300
 301         /* find end of first SMB data area */
 302         data_area_of_target = (char *)&pSMBt->hdr.Protocol +
 303                                 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
 304         /* validate target area */
 305
 306         data_area_of_buf2 = (char *)&pSMB2->hdr.Protocol +
 307                                 get_unaligned_le16(&pSMB2->t2_rsp.DataOffset);
 308
 309         data_area_of_target += total_in_buf;
 310
 311         /* copy second buffer into end of first buffer */
 312         memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
 313         total_in_buf += total_in_buf2;
 314         put_unaligned_le16(total_in_buf, &pSMBt->t2_rsp.DataCount);
 315         byte_count = get_bcc_le(pTargetSMB);
 316         byte_count += total_in_buf2;
 317         put_bcc_le(byte_count, pTargetSMB);
 318
 319         byte_count = pTargetSMB->smb_buf_length;
 320         byte_count += total_in_buf2;
 321
 322         /* BB also add check that we are not beyond maximum buffer size */
 323
 324         pTargetSMB->smb_buf_length = byte_count;
 325
 326         if (remaining == total_in_buf2) {
 327                 cFYI(1, "found the last secondary response");
 328                 return 0; /* we are done */
 329         } else /* more responses to go */
 330                 return 1;
 331 }
 332
 333 static void
 334 cifs_echo_request(struct work_struct *work)
 335 {
 336         int rc;
 337         struct TCP_Server_Info *server = container_of(work,
 338                                         struct TCP_Server_Info, echo.work);
 339
 340         /*
 341          * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
 342          * done, which is indicated by maxBuf != 0. Also, no need to ping if
 343          * we got a response recently
 344          */
 345         if (server->maxBuf == 0 ||
 346             time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
 347                 goto requeue_echo;
 348
 349         rc = CIFSSMBEcho(server);
 350         if (rc)
 351                 cFYI(1, "Unable to send echo request to server: %s",
 352                         server->hostname);
 353
 354 requeue_echo:
 355         queue_delayed_work(system_nrt_wq, &server->echo, SMB_ECHO_INTERVAL);
 356 }
 357
 358 static int
 359 cifs_demultiplex_thread(struct TCP_Server_Info *server)
 360 {
 361         int length;
 362         unsigned int pdu_length, total_read;
 363         struct smb_hdr *smb_buffer = NULL;
 364         struct smb_hdr *bigbuf = NULL;
 365         struct smb_hdr *smallbuf = NULL;
 366         struct msghdr smb_msg;
 367         struct kvec iov;
 368         struct socket *csocket = server->ssocket;
 369         struct list_head *tmp, *tmp2;
 370         struct task_struct *task_to_wake = NULL;
 371         struct mid_q_entry *mid_entry;
 372         char temp;
 373         bool isLargeBuf = false;
 374         bool isMultiRsp;
 375         int reconnect;
 376
 377         current->flags |= PF_MEMALLOC;
 378         cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
 379
 380         length = atomic_inc_return(&tcpSesAllocCount);
 381         if (length > 1)
 382                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
 383                                 GFP_KERNEL);
 384
 385         set_freezable();
 386         while (server->tcpStatus != CifsExiting) {
 387                 if (try_to_freeze())
 388                         continue;
 389                 if (bigbuf == NULL) {
 390                         bigbuf = cifs_buf_get();
 391                         if (!bigbuf) {
 392                                 cERROR(1, "No memory for large SMB response");
 393                                 msleep(3000);
 394                                 /* retry will check if exiting */
 395                                 continue;
 396                         }
 397                 } else if (isLargeBuf) {
 398                         /* we are reusing a dirty large buf, clear its start */
 399                         memset(bigbuf, 0, sizeof(struct smb_hdr));
 400                 }
 401
 402                 if (smallbuf == NULL) {
 403                         smallbuf = cifs_small_buf_get();
 404                         if (!smallbuf) {
 405                                 cERROR(1, "No memory for SMB response");
 406                                 msleep(1000);
 407                                 /* retry will check if exiting */
 408                                 continue;
 409                         }
 410                         /* beginning of smb buffer is cleared in our buf_get */
 411                 } else /* if existing small buf clear beginning */
 412                         memset(smallbuf, 0, sizeof(struct smb_hdr));
 413
 414                 isLargeBuf = false;
 415                 isMultiRsp = false;
 416                 smb_buffer = smallbuf;
 417                 iov.iov_base = smb_buffer;
 418                 iov.iov_len = 4;
 419                 smb_msg.msg_control = NULL;
 420                 smb_msg.msg_controllen = 0;
 421                 pdu_length = 4; /* enough to get RFC1001 header */
 422
 423 incomplete_rcv:
 424                 if (echo_retries > 0 &&
 425                     time_after(jiffies, server->lstrp +
 426                                         (echo_retries * SMB_ECHO_INTERVAL))) {
 427                         cERROR(1, "Server %s has not responded in %d seconds. "
 428                                   "Reconnecting...", server->hostname,
 429                                   (echo_retries * SMB_ECHO_INTERVAL / HZ));
 430                         cifs_reconnect(server);
 431                         csocket = server->ssocket;
 432                         wake_up(&server->response_q);
 433                         continue;
 434                 }
 435
 436                 length =
 437                     kernel_recvmsg(csocket, &smb_msg,
 438                                 &iov, 1, pdu_length, 0 /* BB other flags? */);
 439
 440                 if (server->tcpStatus == CifsExiting) {
 441                         break;
 442                 } else if (server->tcpStatus == CifsNeedReconnect) {
 443                         cFYI(1, "Reconnect after server stopped responding");
 444                         cifs_reconnect(server);
 445                         cFYI(1, "call to reconnect done");
 446                         csocket = server->ssocket;
 447                         continue;
 448                 } else if (length == -ERESTARTSYS ||
 449                            length == -EAGAIN ||
 450                            length == -EINTR) {
 451                         msleep(1); /* minimum sleep to prevent looping
 452                                 allowing socket to clear and app threads to set
 453                                 tcpStatus CifsNeedReconnect if server hung */
 454                         if (pdu_length < 4) {
 455                                 iov.iov_base = (4 - pdu_length) +
 456                                                         (char *)smb_buffer;
 457                                 iov.iov_len = pdu_length;
 458                                 smb_msg.msg_control = NULL;
 459                                 smb_msg.msg_controllen = 0;
 460                                 goto incomplete_rcv;
 461                         } else
 462                                 continue;
 463                 } else if (length <= 0) {
 464                         cFYI(1, "Reconnect after unexpected peek error %d",
 465                                 length);
 466                         cifs_reconnect(server);
 467                         csocket = server->ssocket;
 468                         wake_up(&server->response_q);
 469                         continue;
 470                 } else if (length < pdu_length) {
 471                         cFYI(1, "requested %d bytes but only got %d bytes",
 472                                   pdu_length, length);
 473                         pdu_length -= length;
 474                         msleep(1);
 475                         goto incomplete_rcv;
 476                 }
 477
 478                 /* The right amount was read from socket - 4 bytes */
 479                 /* so we can now interpret the length field */
 480
 481                 /* the first byte big endian of the length field,
 482                 is actually not part of the length but the type
 483                 with the most common, zero, as regular data */
 484                 temp = *((char *) smb_buffer);
 485
 486                 /* Note that FC 1001 length is big endian on the wire,
 487                 but we convert it here so it is always manipulated
 488                 as host byte order */
 489                 pdu_length = be32_to_cpu((__force __be32)smb_buffer->smb_buf_length);
 490                 smb_buffer->smb_buf_length = pdu_length;
 491
 492                 cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
 493
 494                 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
 495                         continue;
 496                 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
 497                         cFYI(1, "Good RFC 1002 session rsp");
 498                         continue;
 499                 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
 500                         /* we get this from Windows 98 instead of
 501                            an error on SMB negprot response */
 502                         cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
 503                                 pdu_length);
 504                         /* give server a second to clean up  */
 505                         msleep(1000);
 506                         /* always try 445 first on reconnect since we get NACK
 507                          * on some if we ever connected to port 139 (the NACK
 508                          * is since we do not begin with RFC1001 session
 509                          * initialize frame)
 510                          */
 511                         cifs_set_port((struct sockaddr *)
 512                                         &server->dstaddr, CIFS_PORT);
 513                         cifs_reconnect(server);
 514                         csocket = server->ssocket;
 515                         wake_up(&server->response_q);
 516                         continue;
 517                 } else if (temp != (char) 0) {
 518                         cERROR(1, "Unknown RFC 1002 frame");
 519                         cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
 520                                       length);
 521                         cifs_reconnect(server);
 522                         csocket = server->ssocket;
 523                         continue;
 524                 }
 525
 526                 /* else we have an SMB response */
 527                 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
 528                             (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
 529                         cERROR(1, "Invalid size SMB length %d pdu_length %d",
 530                                         length, pdu_length+4);
 531                         cifs_reconnect(server);
 532                         csocket = server->ssocket;
 533                         wake_up(&server->response_q);
 534                         continue;
 535                 }
 536
 537                 /* else length ok */
 538                 reconnect = 0;
 539
 540                 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
 541                         isLargeBuf = true;
 542                         memcpy(bigbuf, smallbuf, 4);
 543                         smb_buffer = bigbuf;
 544                 }
 545                 length = 0;
 546                 iov.iov_base = 4 + (char *)smb_buffer;
 547                 iov.iov_len = pdu_length;
 548                 for (total_read = 0; total_read < pdu_length;
 549                      total_read += length) {
 550                         length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
 551                                                 pdu_length - total_read, 0);
 552                         if (server->tcpStatus == CifsExiting) {
 553                                 /* then will exit */
 554                                 reconnect = 2;
 555                                 break;
 556                         } else if (server->tcpStatus == CifsNeedReconnect) {
 557                                 cifs_reconnect(server);
 558                                 csocket = server->ssocket;
 559                                 /* Reconnect wakes up rspns q */
 560                                 /* Now we will reread sock */
 561                                 reconnect = 1;
 562                                 break;
 563                         } else if (length == -ERESTARTSYS ||
 564                                    length == -EAGAIN ||
 565                                    length == -EINTR) {
 566                                 msleep(1); /* minimum sleep to prevent looping,
 567                                               allowing socket to clear and app
 568                                               threads to set tcpStatus
 569                                               CifsNeedReconnect if server hung*/
 570                                 length = 0;
 571                                 continue;
 572                         } else if (length <= 0) {
 573                                 cERROR(1, "Received no data, expecting %d",
 574                                               pdu_length - total_read);
 575                                 cifs_reconnect(server);
 576                                 csocket = server->ssocket;
 577                                 reconnect = 1;
 578                                 break;
 579                         }
 580                 }
 581                 if (reconnect == 2)
 582                         break;
 583                 else if (reconnect == 1)
 584                         continue;
 585
 586                 total_read += 4; /* account for rfc1002 hdr */
 587
 588                 dump_smb(smb_buffer, total_read);
 589
 590                 /*
 591                  * We know that we received enough to get to the MID as we
 592                  * checked the pdu_length earlier. Now check to see
 593                  * if the rest of the header is OK. We borrow the length
 594                  * var for the rest of the loop to avoid a new stack var.
 595                  *
 596                  * 48 bytes is enough to display the header and a little bit
 597                  * into the payload for debugging purposes.
 598                  */
 599                 length = checkSMB(smb_buffer, smb_buffer->Mid, total_read);
 600                 if (length != 0)
 601                         cifs_dump_mem("Bad SMB: ", smb_buffer,
 602                                         min_t(unsigned int, total_read, 48));
 603
 604                 mid_entry = NULL;
 605                 server->lstrp = jiffies;
 606
 607                 spin_lock(&GlobalMid_Lock);
 608                 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 609                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 610
 611                         if ((mid_entry->mid == smb_buffer->Mid) &&
 612                             (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
 613                             (mid_entry->command == smb_buffer->Command)) {
 614                                 if (length == 0 &&
 615                                    check2ndT2(smb_buffer, server->maxBuf) > 0) {
 616                                         /* We have a multipart transact2 resp */
 617                                         isMultiRsp = true;
 618                                         if (mid_entry->resp_buf) {
 619                                                 /* merge response - fix up 1st*/
 620                                                 if (coalesce_t2(smb_buffer,
 621                                                         mid_entry->resp_buf)) {
 622                                                         mid_entry->multiRsp =
 623                                                                  true;
 624                                                         break;
 625                                                 } else {
 626                                                         /* all parts received */
 627                                                         mid_entry->multiEnd =
 628                                                                  true;
 629                                                         goto multi_t2_fnd;
 630                                                 }
 631                                         } else {
 632                                                 if (!isLargeBuf) {
 633                                                         cERROR(1, "1st trans2 resp needs bigbuf");
 634                                         /* BB maybe we can fix this up,  switch
 635                                            to already allocated large buffer? */
 636                                                 } else {
 637                                                         /* Have first buffer */
 638                                                         mid_entry->resp_buf =
 639                                                                  smb_buffer;
 640                                                         mid_entry->largeBuf =
 641                                                                  true;
 642                                                         bigbuf = NULL;
 643                                                 }
 644                                         }
 645                                         break;
 646                                 }
 647                                 mid_entry->resp_buf = smb_buffer;
 648                                 mid_entry->largeBuf = isLargeBuf;
 649 multi_t2_fnd:
 650                                 if (length == 0)
 651                                         mid_entry->midState =
 652                                                         MID_RESPONSE_RECEIVED;
 653                                 else
 654                                         mid_entry->midState =
 655                                                         MID_RESPONSE_MALFORMED;
 656 #ifdef CONFIG_CIFS_STATS2
 657                                 mid_entry->when_received = jiffies;
 658 #endif
 659                                 list_del_init(&mid_entry->qhead);
 660                                 mid_entry->callback(mid_entry);
 661                                 break;
 662                         }
 663                         mid_entry = NULL;
 664                 }
 665                 spin_unlock(&GlobalMid_Lock);
 666
 667                 if (mid_entry != NULL) {
 668                         /* Was previous buf put in mpx struct for multi-rsp? */
 669                         if (!isMultiRsp) {
 670                                 /* smb buffer will be freed by user thread */
 671                                 if (isLargeBuf)
 672                                         bigbuf = NULL;
 673                                 else
 674                                         smallbuf = NULL;
 675                         }
 676                 } else if (length != 0) {
 677                         /* response sanity checks failed */
 678                         continue;
 679                 } else if (!is_valid_oplock_break(smb_buffer, server) &&
 680                            !isMultiRsp) {
 681                         cERROR(1, "No task to wake, unknown frame received! "
 682                                    "NumMids %d", atomic_read(&midCount));
 683                         cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
 684                                       sizeof(struct smb_hdr));
 685 #ifdef CONFIG_CIFS_DEBUG2
 686                         cifs_dump_detail(smb_buffer);
 687                         cifs_dump_mids(server);
 688 #endif /* CIFS_DEBUG2 */
 689
 690                 }
 691         } /* end while !EXITING */
 692
 693         /* take it off the list, if it's not already */
 694         spin_lock(&cifs_tcp_ses_lock);
 695         list_del_init(&server->tcp_ses_list);
 696         spin_unlock(&cifs_tcp_ses_lock);
 697
 698         spin_lock(&GlobalMid_Lock);
 699         server->tcpStatus = CifsExiting;
 700         spin_unlock(&GlobalMid_Lock);
 701         wake_up_all(&server->response_q);
 702
 703         /* check if we have blocked requests that need to free */
 704         /* Note that cifs_max_pending is normally 50, but
 705         can be set at module install time to as little as two */
 706         spin_lock(&GlobalMid_Lock);
 707         if (atomic_read(&server->inFlight) >= cifs_max_pending)
 708                 atomic_set(&server->inFlight, cifs_max_pending - 1);
 709         /* We do not want to set the max_pending too low or we
 710         could end up with the counter going negative */
 711         spin_unlock(&GlobalMid_Lock);
 712         /* Although there should not be any requests blocked on
 713         this queue it can not hurt to be paranoid and try to wake up requests
 714         that may haven been blocked when more than 50 at time were on the wire
 715         to the same server - they now will see the session is in exit state
 716         and get out of SendReceive.  */
 717         wake_up_all(&server->request_q);
 718         /* give those requests time to exit */
 719         msleep(125);
 720
 721         if (server->ssocket) {
 722                 sock_release(csocket);
 723                 server->ssocket = NULL;
 724         }
 725         /* buffer usuallly freed in free_mid - need to free it here on exit */
 726         cifs_buf_release(bigbuf);
 727         if (smallbuf) /* no sense logging a debug message if NULL */
 728                 cifs_small_buf_release(smallbuf);
 729
 730         if (!list_empty(&server->pending_mid_q)) {
 731                 spin_lock(&GlobalMid_Lock);
 732                 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
 733                         mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
 734                         cFYI(1, "Clearing Mid 0x%x - issuing callback",
 735                                          mid_entry->mid);
 736                         list_del_init(&mid_entry->qhead);
 737                         mid_entry->callback(mid_entry);
 738                 }
 739                 spin_unlock(&GlobalMid_Lock);
 740                 /* 1/8th of sec is more than enough time for them to exit */
 741                 msleep(125);
 742         }
 743
 744         if (!list_empty(&server->pending_mid_q)) {
 745                 /* mpx threads have not exited yet give them
 746                 at least the smb send timeout time for long ops */
 747                 /* due to delays on oplock break requests, we need
 748                 to wait at least 45 seconds before giving up
 749                 on a request getting a response and going ahead
 750                 and killing cifsd */
 751                 cFYI(1, "Wait for exit from demultiplex thread");
 752                 msleep(46000);
 753                 /* if threads still have not exited they are probably never
 754                 coming home not much else we can do but free the memory */
 755         }
 756
 757         kfree(server->hostname);
 758         task_to_wake = xchg(&server->tsk, NULL);
 759         kfree(server);
 760
 761         length = atomic_dec_return(&tcpSesAllocCount);
 762         if (length  > 0)
 763                 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
 764                                 GFP_KERNEL);
 765
 766         /* if server->tsk was NULL then wait for a signal before exiting */
 767         if (!task_to_wake) {
 768                 set_current_state(TASK_INTERRUPTIBLE);
 769                 while (!signal_pending(current)) {
 770                         schedule();
 771                         set_current_state(TASK_INTERRUPTIBLE);
 772                 }
 773                 set_current_state(TASK_RUNNING);
 774         }
 775
 776         module_put_and_exit(0);
 777 }
 778
 779 /* extract the host portion of the UNC string */
 780 static char *
 781 extract_hostname(const char *unc)
 782 {
 783         const char *src;
 784         char *dst, *delim;
 785         unsigned int len;
 786
 787         /* skip double chars at beginning of string */
 788         /* BB: check validity of these bytes? */
 789         src = unc + 2;
 790
 791         /* delimiter between hostname and sharename is always '\\' now */
 792         delim = strchr(src, '\\');
 793         if (!delim)
 794                 return ERR_PTR(-EINVAL);
 795
 796         len = delim - src;
 797         dst = kmalloc((len + 1), GFP_KERNEL);
 798         if (dst == NULL)
 799                 return ERR_PTR(-ENOMEM);
 800
 801         memcpy(dst, src, len);
 802         dst[len] = '\0';
 803
 804         return dst;
 805 }
 806
 807 static int
 808 cifs_parse_mount_options(char *options, const char *devname,
 809                          struct smb_vol *vol)
 810 {
 811         char *value;
 812         char *data;
 813         unsigned int  temp_len, i, j;
 814         char separator[2];
 815         short int override_uid = -1;
 816         short int override_gid = -1;
 817         bool uid_specified = false;
 818         bool gid_specified = false;
 819         char *nodename = utsname()->nodename;
 820
 821         separator[0] = ',';
 822         separator[1] = 0;
 823
 824         /*
 825          * does not have to be perfect mapping since field is
 826          * informational, only used for servers that do not support
 827          * port 445 and it can be overridden at mount time
 828          */
 829         memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
 830         for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
 831                 vol->source_rfc1001_name[i] = toupper(nodename[i]);
 832
 833         vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
 834         /* null target name indicates to use *SMBSERVR default called name
 835            if we end up sending RFC1001 session initialize */
 836         vol->target_rfc1001_name[0] = 0;
 837         vol->cred_uid = current_uid();
 838         vol->linux_uid = current_uid();
 839         vol->linux_gid = current_gid();
 840
 841         /* default to only allowing write access to owner of the mount */
 842         vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
 843
 844         /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
 845         /* default is always to request posix paths. */
 846         vol->posix_paths = 1;
 847         /* default to using server inode numbers where available */
 848         vol->server_ino = 1;
 849
 850         vol->actimeo = CIFS_DEF_ACTIMEO;
 851
 852         if (!options)
 853                 return 1;
 854
 855         if (strncmp(options, "sep=", 4) == 0) {
 856                 if (options[4] != 0) {
 857                         separator[0] = options[4];
 858                         options += 5;
 859                 } else {
 860                         cFYI(1, "Null separator not allowed");
 861                 }
 862         }
 863
 864         while ((data = strsep(&options, separator)) != NULL) {
 865                 if (!*data)
 866                         continue;
 867                 if ((value = strchr(data, '=')) != NULL)
 868                         *value++ = '\0';
 869
 870                 /* Have to parse this before we parse for "user" */
 871                 if (strnicmp(data, "user_xattr", 10) == 0) {
 872                         vol->no_xattr = 0;
 873                 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
 874                         vol->no_xattr = 1;
 875                 } else if (strnicmp(data, "user", 4) == 0) {
 876                         if (!value) {
 877                                 printk(KERN_WARNING
 878                                        "CIFS: invalid or missing username\n");
 879                                 return 1;       /* needs_arg; */
 880                         } else if (!*value) {
 881                                 /* null user, ie anonymous, authentication */
 882                                 vol->nullauth = 1;
 883                         }
 884                         if (strnlen(value, MAX_USERNAME_SIZE) <
 885                                                 MAX_USERNAME_SIZE) {
 886                                 vol->username = value;
 887                         } else {
 888                                 printk(KERN_WARNING "CIFS: username too long\n");
 889                                 return 1;
 890                         }
 891                 } else if (strnicmp(data, "pass", 4) == 0) {
 892                         if (!value) {
 893                                 vol->password = NULL;
 894                                 continue;
 895                         } else if (value[0] == 0) {
 896                                 /* check if string begins with double comma
 897                                    since that would mean the password really
 898                                    does start with a comma, and would not
 899                                    indicate an empty string */
 900                                 if (value[1] != separator[0]) {
 901                                         vol->password = NULL;
 902                                         continue;
 903                                 }
 904                         }
 905                         temp_len = strlen(value);
 906                         /* removed password length check, NTLM passwords
 907                                 can be arbitrarily long */
 908
 909                         /* if comma in password, the string will be
 910                         prematurely null terminated.  Commas in password are
 911                         specified across the cifs mount interface by a double
 912                         comma ie ,, and a comma used as in other cases ie ','
 913                         as a parameter delimiter/separator is single and due
 914                         to the strsep above is temporarily zeroed. */
 915
 916                         /* NB: password legally can have multiple commas and
 917                         the only illegal character in a password is null */
 918
 919                         if ((value[temp_len] == 0) &&
 920                             (value[temp_len+1] == separator[0])) {
 921                                 /* reinsert comma */
 922                                 value[temp_len] = separator[0];
 923                                 temp_len += 2;  /* move after second comma */
 924                                 while (value[temp_len] != 0)  {
 925                                         if (value[temp_len] == separator[0]) {
 926                                                 if (value[temp_len+1] ==
 927                                                      separator[0]) {
 928                                                 /* skip second comma */
 929                                                         temp_len++;
 930                                                 } else {
 931                                                 /* single comma indicating start
 932                                                          of next parm */
 933                                                         break;
 934                                                 }
 935                                         }
 936                                         temp_len++;
 937                                 }
 938                                 if (value[temp_len] == 0) {
 939                                         options = NULL;
 940                                 } else {
 941                                         value[temp_len] = 0;
 942                                         /* point option to start of next parm */
 943                                         options = value + temp_len + 1;
 944                                 }
 945                                 /* go from value to value + temp_len condensing
 946                                 double commas to singles. Note that this ends up
 947                                 allocating a few bytes too many, which is ok */
 948                                 vol->password = kzalloc(temp_len, GFP_KERNEL);
 949                                 if (vol->password == NULL) {
 950                                         printk(KERN_WARNING "CIFS: no memory "
 951                                                             "for password\n");
 952                                         return 1;
 953                                 }
 954                                 for (i = 0, j = 0; i < temp_len; i++, j++) {
 955                                         vol->password[j] = value[i];
 956                                         if (value[i] == separator[0]
 957                                                 && value[i+1] == separator[0]) {
 958                                                 /* skip second comma */
 959                                                 i++;
 960                                         }
 961                                 }
 962                                 vol->password[j] = 0;
 963                         } else {
 964                                 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
 965                                 if (vol->password == NULL) {
 966                                         printk(KERN_WARNING "CIFS: no memory "
 967                                                             "for password\n");
 968                                         return 1;
 969                                 }
 970                                 strcpy(vol->password, value);
 971                         }
 972                 } else if (!strnicmp(data, "ip", 2) ||
 973                            !strnicmp(data, "addr", 4)) {
 974                         if (!value || !*value) {
 975                                 vol->UNCip = NULL;
 976                         } else if (strnlen(value, INET6_ADDRSTRLEN) <
 977                                                         INET6_ADDRSTRLEN) {
 978                                 vol->UNCip = value;
 979                         } else {
 980                                 printk(KERN_WARNING "CIFS: ip address "
 981                                                     "too long\n");
 982                                 return 1;
 983                         }
 984                 } else if (strnicmp(data, "sec", 3) == 0) {
 985                         if (!value || !*value) {
 986                                 cERROR(1, "no security value specified");
 987                                 continue;
 988                         } else if (strnicmp(value, "krb5i", 5) == 0) {
 989                                 vol->secFlg |= CIFSSEC_MAY_KRB5 |
 990                                         CIFSSEC_MUST_SIGN;
 991                         } else if (strnicmp(value, "krb5p", 5) == 0) {
 992                                 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
 993                                         CIFSSEC_MAY_KRB5; */
 994                                 cERROR(1, "Krb5 cifs privacy not supported");
 995                                 return 1;
 996                         } else if (strnicmp(value, "krb5", 4) == 0) {
 997                                 vol->secFlg |= CIFSSEC_MAY_KRB5;
 998                         } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
 999                                 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
1000                                         CIFSSEC_MUST_SIGN;
1001                         } else if (strnicmp(value, "ntlmssp", 7) == 0) {
1002                                 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1003                         } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
1004                                 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
1005                                         CIFSSEC_MUST_SIGN;
1006                         } else if (strnicmp(value, "ntlmv2", 6) == 0) {
1007                                 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1008                         } else if (strnicmp(value, "ntlmi", 5) == 0) {
1009                                 vol->secFlg |= CIFSSEC_MAY_NTLM |
1010                                         CIFSSEC_MUST_SIGN;
1011                         } else if (strnicmp(value, "ntlm", 4) == 0) {
1012                                 /* ntlm is default so can be turned off too */
1013                                 vol->secFlg |= CIFSSEC_MAY_NTLM;
1014                         } else if (strnicmp(value, "nontlm", 6) == 0) {
1015                                 /* BB is there a better way to do this? */
1016                                 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1017 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1018                         } else if (strnicmp(value, "lanman", 6) == 0) {
1019                                 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1020 #endif
1021                         } else if (strnicmp(value, "none", 4) == 0) {
1022                                 vol->nullauth = 1;
1023                         } else {
1024                                 cERROR(1, "bad security option: %s", value);
1025                                 return 1;
1026                         }
1027                 } else if ((strnicmp(data, "unc", 3) == 0)
1028                            || (strnicmp(data, "target", 6) == 0)
1029                            || (strnicmp(data, "path", 4) == 0)) {
1030                         if (!value || !*value) {
1031                                 printk(KERN_WARNING "CIFS: invalid path to "
1032                                                     "network resource\n");
1033                                 return 1;       /* needs_arg; */
1034                         }
1035                         if ((temp_len = strnlen(value, 300)) < 300) {
1036                                 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1037                                 if (vol->UNC == NULL)
1038                                         return 1;
1039                                 strcpy(vol->UNC, value);
1040                                 if (strncmp(vol->UNC, "//", 2) == 0) {
1041                                         vol->UNC[0] = '\\';
1042                                         vol->UNC[1] = '\\';
1043                                 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1044                                         printk(KERN_WARNING
1045                                                "CIFS: UNC Path does not begin "
1046                                                "with // or \\\\ \n");
1047                                         return 1;
1048                                 }
1049                         } else {
1050                                 printk(KERN_WARNING "CIFS: UNC name too long\n");
1051                                 return 1;
1052                         }
1053                 } else if ((strnicmp(data, "domain", 3) == 0)
1054                            || (strnicmp(data, "workgroup", 5) == 0)) {
1055                         if (!value || !*value) {
1056                                 printk(KERN_WARNING "CIFS: invalid domain name\n");
1057                                 return 1;       /* needs_arg; */
1058                         }
1059                         /* BB are there cases in which a comma can be valid in
1060                         a domain name and need special handling? */
1061                         if (strnlen(value, 256) < 256) {
1062                                 vol->domainname = value;
1063                                 cFYI(1, "Domain name set");
1064                         } else {
1065                                 printk(KERN_WARNING "CIFS: domain name too "
1066                                                     "long\n");
1067                                 return 1;
1068                         }
1069                 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1070                         vol->srcaddr.ss_family = AF_UNSPEC;
1071
1072                         if (!value || !*value) {
1073                                 printk(KERN_WARNING "CIFS: srcaddr value"
1074                                        " not specified.\n");
1075                                 return 1;       /* needs_arg; */
1076                         }
1077                         i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1078                                                  value, strlen(value));
1079                         if (i == 0) {
1080                                 printk(KERN_WARNING "CIFS:  Could not parse"
1081                                        " srcaddr: %s\n",
1082                                        value);
1083                                 return 1;
1084                         }
1085                 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1086                         if (!value || !*value) {
1087                                 printk(KERN_WARNING
1088                                         "CIFS: invalid path prefix\n");
1089                                 return 1;       /* needs_argument */
1090                         }
1091                         if ((temp_len = strnlen(value, 1024)) < 1024) {
1092                                 if (value[0] != '/')
1093                                         temp_len++;  /* missing leading slash */
1094                                 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1095                                 if (vol->prepath == NULL)
1096                                         return 1;
1097                                 if (value[0] != '/') {
1098                                         vol->prepath[0] = '/';
1099                                         strcpy(vol->prepath+1, value);
1100                                 } else
1101                                         strcpy(vol->prepath, value);
1102                                 cFYI(1, "prefix path %s", vol->prepath);
1103                         } else {
1104                                 printk(KERN_WARNING "CIFS: prefix too long\n");
1105                                 return 1;
1106                         }
1107                 } else if (strnicmp(data, "iocharset", 9) == 0) {
1108                         if (!value || !*value) {
1109                                 printk(KERN_WARNING "CIFS: invalid iocharset "
1110                                                     "specified\n");
1111                                 return 1;       /* needs_arg; */
1112                         }
1113                         if (strnlen(value, 65) < 65) {
1114                                 if (strnicmp(value, "default", 7))
1115                                         vol->iocharset = value;
1116                                 /* if iocharset not set then load_nls_default
1117                                    is used by caller */
1118                                 cFYI(1, "iocharset set to %s", value);
1119                         } else {
1120                                 printk(KERN_WARNING "CIFS: iocharset name "
1121                                                     "too long.\n");
1122                                 return 1;
1123                         }
1124                 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1125                         vol->linux_uid = simple_strtoul(value, &value, 0);
1126                         uid_specified = true;
1127                 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1128                         vol->cred_uid = simple_strtoul(value, &value, 0);
1129                 } else if (!strnicmp(data, "forceuid", 8)) {
1130                         override_uid = 1;
1131                 } else if (!strnicmp(data, "noforceuid", 10)) {
1132                         override_uid = 0;
1133                 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1134                         vol->linux_gid = simple_strtoul(value, &value, 0);
1135                         gid_specified = true;
1136                 } else if (!strnicmp(data, "forcegid", 8)) {
1137                         override_gid = 1;
1138                 } else if (!strnicmp(data, "noforcegid", 10)) {
1139                         override_gid = 0;
1140                 } else if (strnicmp(data, "file_mode", 4) == 0) {
1141                         if (value && *value) {
1142                                 vol->file_mode =
1143                                         simple_strtoul(value, &value, 0);
1144                         }
1145                 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1146                         if (value && *value) {
1147                                 vol->dir_mode =
1148                                         simple_strtoul(value, &value, 0);
1149                         }
1150                 } else if (strnicmp(data, "dirmode", 4) == 0) {
1151                         if (value && *value) {
1152                                 vol->dir_mode =
1153                                         simple_strtoul(value, &value, 0);
1154                         }
1155                 } else if (strnicmp(data, "port", 4) == 0) {
1156                         if (value && *value) {
1157                                 vol->port =
1158                                         simple_strtoul(value, &value, 0);
1159                         }
1160                 } else if (strnicmp(data, "rsize", 5) == 0) {
1161                         if (value && *value) {
1162                                 vol->rsize =
1163                                         simple_strtoul(value, &value, 0);
1164                         }
1165                 } else if (strnicmp(data, "wsize", 5) == 0) {
1166                         if (value && *value) {
1167                                 vol->wsize =
1168                                         simple_strtoul(value, &value, 0);
1169                         }
1170                 } else if (strnicmp(data, "sockopt", 5) == 0) {
1171                         if (!value || !*value) {
1172                                 cERROR(1, "no socket option specified");
1173                                 continue;
1174                         } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1175                                 vol->sockopt_tcp_nodelay = 1;
1176                         }
1177                 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1178                         if (!value || !*value || (*value == ' ')) {
1179                                 cFYI(1, "invalid (empty) netbiosname");
1180                         } else {
1181                                 memset(vol->source_rfc1001_name, 0x20,
1182                                         RFC1001_NAME_LEN);
1183                                 /*
1184                                  * FIXME: are there cases in which a comma can
1185                                  * be valid in workstation netbios name (and
1186                                  * need special handling)?
1187                                  */
1188                                 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1189                                         /* don't ucase netbiosname for user */
1190                                         if (value[i] == 0)
1191                                                 break;
1192                                         vol->source_rfc1001_name[i] = value[i];
1193                                 }
1194                                 /* The string has 16th byte zero still from
1195                                 set at top of the function  */
1196                                 if (i == RFC1001_NAME_LEN && value[i] != 0)
1197                                         printk(KERN_WARNING "CIFS: netbiosname"
1198                                                 " longer than 15 truncated.\n");
1199                         }
1200                 } else if (strnicmp(data, "servern", 7) == 0) {
1201                         /* servernetbiosname specified override *SMBSERVER */
1202                         if (!value || !*value || (*value == ' ')) {
1203                                 cFYI(1, "empty server netbiosname specified");
1204                         } else {
1205                                 /* last byte, type, is 0x20 for servr type */
1206                                 memset(vol->target_rfc1001_name, 0x20,
1207                                         RFC1001_NAME_LEN_WITH_NULL);
1208
1209                                 for (i = 0; i < 15; i++) {
1210                                 /* BB are there cases in which a comma can be
1211                                    valid in this workstation netbios name
1212                                    (and need special handling)? */
1213
1214                                 /* user or mount helper must uppercase
1215                                    the netbiosname */
1216                                         if (value[i] == 0)
1217                                                 break;
1218                                         else
1219                                                 vol->target_rfc1001_name[i] =
1220                                                                 value[i];
1221                                 }
1222                                 /* The string has 16th byte zero still from
1223                                    set at top of the function  */
1224                                 if (i == RFC1001_NAME_LEN && value[i] != 0)
1225                                         printk(KERN_WARNING "CIFS: server net"
1226                                         "biosname longer than 15 truncated.\n");
1227                         }
1228                 } else if (strnicmp(data, "actimeo", 7) == 0) {
1229                         if (value && *value) {
1230                                 vol->actimeo = HZ * simple_strtoul(value,
1231                                                                    &value, 0);
1232                                 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1233                                         cERROR(1, "CIFS: attribute cache"
1234                                                         "timeout too large");
1235                                         return 1;
1236                                 }
1237                         }
1238                 } else if (strnicmp(data, "credentials", 4) == 0) {
1239                         /* ignore */
1240                 } else if (strnicmp(data, "version", 3) == 0) {
1241                         /* ignore */
1242                 } else if (strnicmp(data, "guest", 5) == 0) {
1243                         /* ignore */
1244                 } else if (strnicmp(data, "rw", 2) == 0) {
1245                         /* ignore */
1246                 } else if (strnicmp(data, "ro", 2) == 0) {
1247                         /* ignore */
1248                 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1249                         vol->noblocksnd = 1;
1250                 } else if (strnicmp(data, "noautotune", 10) == 0) {
1251                         vol->noautotune = 1;
1252                 } else if ((strnicmp(data, "suid", 4) == 0) ||
1253                                    (strnicmp(data, "nosuid", 6) == 0) ||
1254                                    (strnicmp(data, "exec", 4) == 0) ||
1255                                    (strnicmp(data, "noexec", 6) == 0) ||
1256                                    (strnicmp(data, "nodev", 5) == 0) ||
1257                                    (strnicmp(data, "noauto", 6) == 0) ||
1258                                    (strnicmp(data, "dev", 3) == 0)) {
1259                         /*  The mount tool or mount.cifs helper (if present)
1260                             uses these opts to set flags, and the flags are read
1261                             by the kernel vfs layer before we get here (ie
1262                             before read super) so there is no point trying to
1263                             parse these options again and set anything and it
1264                             is ok to just ignore them */
1265                         continue;
1266                 } else if (strnicmp(data, "hard", 4) == 0) {
1267                         vol->retry = 1;
1268                 } else if (strnicmp(data, "soft", 4) == 0) {
1269                         vol->retry = 0;
1270                 } else if (strnicmp(data, "perm", 4) == 0) {
1271                         vol->noperm = 0;
1272                 } else if (strnicmp(data, "noperm", 6) == 0) {
1273                         vol->noperm = 1;
1274                 } else if (strnicmp(data, "mapchars", 8) == 0) {
1275                         vol->remap = 1;
1276                 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1277                         vol->remap = 0;
1278                 } else if (strnicmp(data, "sfu", 3) == 0) {
1279                         vol->sfu_emul = 1;
1280                 } else if (strnicmp(data, "nosfu", 5) == 0) {
1281                         vol->sfu_emul = 0;
1282                 } else if (strnicmp(data, "nodfs", 5) == 0) {
1283                         vol->nodfs = 1;
1284                 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1285                         vol->posix_paths = 1;
1286                 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1287                         vol->posix_paths = 0;
1288                 } else if (strnicmp(data, "nounix", 6) == 0) {
1289                         vol->no_linux_ext = 1;
1290                 } else if (strnicmp(data, "nolinux", 7) == 0) {
1291                         vol->no_linux_ext = 1;
1292                 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1293                            (strnicmp(data, "ignorecase", 10)  == 0)) {
1294                         vol->nocase = 1;
1295                 } else if (strnicmp(data, "mand", 4) == 0) {
1296                         /* ignore */
1297                 } else if (strnicmp(data, "nomand", 6) == 0) {
1298                         /* ignore */
1299                 } else if (strnicmp(data, "_netdev", 7) == 0) {
1300                         /* ignore */
1301                 } else if (strnicmp(data, "brl", 3) == 0) {
1302                         vol->nobrl =  0;
1303                 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1304                            (strnicmp(data, "nolock", 6) == 0)) {
1305                         vol->nobrl =  1;
1306                         /* turn off mandatory locking in mode
1307                         if remote locking is turned off since the
1308                         local vfs will do advisory */
1309                         if (vol->file_mode ==
1310                                 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1311                                 vol->file_mode = S_IALLUGO;
1312                 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1313                         /* will take the shorter form "forcemand" as well */
1314                         /* This mount option will force use of mandatory
1315                           (DOS/Windows style) byte range locks, instead of
1316                           using posix advisory byte range locks, even if the
1317                           Unix extensions are available and posix locks would
1318                           be supported otherwise. If Unix extensions are not
1319                           negotiated this has no effect since mandatory locks
1320                           would be used (mandatory locks is all that those
1321                           those servers support) */
1322                         vol->mand_lock = 1;
1323                 } else if (strnicmp(data, "setuids", 7) == 0) {
1324                         vol->setuids = 1;
1325                 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1326                         vol->setuids = 0;
1327                 } else if (strnicmp(data, "dynperm", 7) == 0) {
1328                         vol->dynperm = true;
1329                 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1330                         vol->dynperm = false;
1331                 } else if (strnicmp(data, "nohard", 6) == 0) {
1332                         vol->retry = 0;
1333                 } else if (strnicmp(data, "nosoft", 6) == 0) {
1334                         vol->retry = 1;
1335                 } else if (strnicmp(data, "nointr", 6) == 0) {
1336                         vol->intr = 0;
1337                 } else if (strnicmp(data, "intr", 4) == 0) {
1338                         vol->intr = 1;
1339                 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1340                         vol->nostrictsync = 1;
1341                 } else if (strnicmp(data, "strictsync", 10) == 0) {
1342                         vol->nostrictsync = 0;
1343                 } else if (strnicmp(data, "serverino", 7) == 0) {
1344                         vol->server_ino = 1;
1345                 } else if (strnicmp(data, "noserverino", 9) == 0) {
1346                         vol->server_ino = 0;
1347                 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1348                         vol->cifs_acl = 1;
1349                 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1350                         vol->cifs_acl = 0;
1351                 } else if (strnicmp(data, "acl", 3) == 0) {
1352                         vol->no_psx_acl = 0;
1353                 } else if (strnicmp(data, "noacl", 5) == 0) {
1354                         vol->no_psx_acl = 1;
1355                 } else if (strnicmp(data, "locallease", 6) == 0) {
1356                         vol->local_lease = 1;
1357                 } else if (strnicmp(data, "sign", 4) == 0) {
1358                         vol->secFlg |= CIFSSEC_MUST_SIGN;
1359                 } else if (strnicmp(data, "seal", 4) == 0) {
1360                         /* we do not do the following in secFlags because seal
1361                            is a per tree connection (mount) not a per socket
1362                            or per-smb connection option in the protocol */
1363                         /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1364                         vol->seal = 1;
1365                 } else if (strnicmp(data, "direct", 6) == 0) {
1366                         vol->direct_io = 1;
1367                 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1368                         vol->direct_io = 1;
1369                 } else if (strnicmp(data, "strictcache", 11) == 0) {
1370                         vol->strict_io = 1;
1371                 } else if (strnicmp(data, "noac", 4) == 0) {
1372                         printk(KERN_WARNING "CIFS: Mount option noac not "
1373                                 "supported. Instead set "
1374                                 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1375                 } else if (strnicmp(data, "fsc", 3) == 0) {
1376 #ifndef CONFIG_CIFS_FSCACHE
1377                         cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE"
1378                                   "kernel config option set");
1379                         return 1;
1380 #endif
1381                         vol->fsc = true;
1382                 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1383                         vol->mfsymlinks = true;
1384                 } else if (strnicmp(data, "multiuser", 8) == 0) {
1385                         vol->multiuser = true;
1386                 } else
1387                         printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1388                                                 data);
1389         }
1390         if (vol->UNC == NULL) {
1391                 if (devname == NULL) {
1392                         printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1393                                                 "target\n");
1394                         return 1;
1395                 }
1396                 if ((temp_len = strnlen(devname, 300)) < 300) {
1397                         vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1398                         if (vol->UNC == NULL)
1399                                 return 1;
1400                         strcpy(vol->UNC, devname);
1401                         if (strncmp(vol->UNC, "//", 2) == 0) {
1402                                 vol->UNC[0] = '\\';
1403                                 vol->UNC[1] = '\\';
1404                         } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1405                                 printk(KERN_WARNING "CIFS: UNC Path does not "
1406                                                     "begin with // or \\\\ \n");
1407                                 return 1;
1408                         }
1409                         value = strpbrk(vol->UNC+2, "/\\");
1410                         if (value)
1411                                 *value = '\\';
1412                 } else {
1413                         printk(KERN_WARNING "CIFS: UNC name too long\n");
1414                         return 1;
1415                 }
1416         }
1417
1418         if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1419                 cERROR(1, "Multiuser mounts currently require krb5 "
1420                           "authentication!");
1421                 return 1;
1422         }
1423
1424         if (vol->UNCip == NULL)
1425                 vol->UNCip = &vol->UNC[2];
1426
1427         if (uid_specified)
1428                 vol->override_uid = override_uid;
1429         else if (override_uid == 1)
1430                 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1431                                    "specified with no uid= option.\n");
1432
1433         if (gid_specified)
1434                 vol->override_gid = override_gid;
1435         else if (override_gid == 1)
1436                 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1437                                    "specified with no gid= option.\n");
1438
1439         return 0;
1440 }
1441
1442 /** Returns true if srcaddr isn't specified and rhs isn't
1443  * specified, or if srcaddr is specified and
1444  * matches the IP address of the rhs argument.
1445  */
1446 static bool
1447 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1448 {
1449         switch (srcaddr->sa_family) {
1450         case AF_UNSPEC:
1451                 return (rhs->sa_family == AF_UNSPEC);
1452         case AF_INET: {
1453                 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1454                 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1455                 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1456         }
1457         case AF_INET6: {
1458                 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1459                 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1460                 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1461         }
1462         default:
1463                 WARN_ON(1);
1464                 return false; /* don't expect to be here */
1465         }
1466 }
1467
1468 /*
1469  * If no port is specified in addr structure, we try to match with 445 port
1470  * and if it fails - with 139 ports. It should be called only if address
1471  * families of server and addr are equal.
1472  */
1473 static bool
1474 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1475 {
1476         __be16 port, *sport;
1477
1478         switch (addr->sa_family) {
1479         case AF_INET:
1480                 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1481                 port = ((struct sockaddr_in *) addr)->sin_port;
1482                 break;
1483         case AF_INET6:
1484                 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1485                 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1486                 break;
1487         default:
1488                 WARN_ON(1);
1489                 return false;
1490         }
1491
1492         if (!port) {
1493                 port = htons(CIFS_PORT);
1494                 if (port == *sport)
1495                         return true;
1496
1497                 port = htons(RFC1001_PORT);
1498         }
1499
1500         return port == *sport;
1501 }
1502
1503 static bool
1504 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1505               struct sockaddr *srcaddr)
1506 {
1507         switch (addr->sa_family) {
1508         case AF_INET: {
1509                 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1510                 struct sockaddr_in *srv_addr4 =
1511                                         (struct sockaddr_in *)&server->dstaddr;
1512
1513                 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1514                         return false;
1515                 break;
1516         }
1517         case AF_INET6: {
1518                 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1519                 struct sockaddr_in6 *srv_addr6 =
1520                                         (struct sockaddr_in6 *)&server->dstaddr;
1521
1522                 if (!ipv6_addr_equal(&addr6->sin6_addr,
1523                                      &srv_addr6->sin6_addr))
1524                         return false;
1525                 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1526                         return false;
1527                 break;
1528         }
1529         default:
1530                 WARN_ON(1);
1531                 return false; /* don't expect to be here */
1532         }
1533
1534         if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1535                 return false;
1536
1537         return true;
1538 }
1539
1540 static bool
1541 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1542 {
1543         unsigned int secFlags;
1544
1545         if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1546                 secFlags = vol->secFlg;
1547         else
1548                 secFlags = global_secflags | vol->secFlg;
1549
1550         switch (server->secType) {
1551         case LANMAN:
1552                 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1553                         return false;
1554                 break;
1555         case NTLMv2:
1556                 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1557                         return false;
1558                 break;
1559         case NTLM:
1560                 if (!(secFlags & CIFSSEC_MAY_NTLM))
1561                         return false;
1562                 break;
1563         case Kerberos:
1564                 if (!(secFlags & CIFSSEC_MAY_KRB5))
1565                         return false;
1566                 break;
1567         case RawNTLMSSP:
1568                 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1569                         return false;
1570                 break;
1571         default:
1572                 /* shouldn't happen */
1573                 return false;
1574         }
1575
1576         /* now check if signing mode is acceptable */
1577         if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1578             (server->secMode & SECMODE_SIGN_REQUIRED))
1579                         return false;
1580         else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1581                  (server->secMode &
1582                   (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1583                         return false;
1584
1585         return true;
1586 }
1587
1588 static struct TCP_Server_Info *
1589 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1590 {
1591         struct TCP_Server_Info *server;
1592
1593         spin_lock(&cifs_tcp_ses_lock);
1594         list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1595                 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1596                         continue;
1597
1598                 if (!match_address(server, addr,
1599                                    (struct sockaddr *)&vol->srcaddr))
1600                         continue;
1601
1602                 if (!match_port(server, addr))
1603                         continue;
1604
1605                 if (!match_security(server, vol))
1606                         continue;
1607
1608                 ++server->srv_count;
1609                 spin_unlock(&cifs_tcp_ses_lock);
1610                 cFYI(1, "Existing tcp session with server found");
1611                 return server;
1612         }
1613         spin_unlock(&cifs_tcp_ses_lock);
1614         return NULL;
1615 }
1616
1617 static void
1618 cifs_put_tcp_session(struct TCP_Server_Info *server)
1619 {
1620         struct task_struct *task;
1621
1622         spin_lock(&cifs_tcp_ses_lock);
1623         if (--server->srv_count > 0) {
1624                 spin_unlock(&cifs_tcp_ses_lock);
1625                 return;
1626         }
1627
1628         put_net(cifs_net_ns(server));
1629
1630         list_del_init(&server->tcp_ses_list);
1631         spin_unlock(&cifs_tcp_ses_lock);
1632
1633         cancel_delayed_work_sync(&server->echo);
1634
1635         spin_lock(&GlobalMid_Lock);
1636         server->tcpStatus = CifsExiting;
1637         spin_unlock(&GlobalMid_Lock);
1638
1639         cifs_crypto_shash_release(server);
1640         cifs_fscache_release_client_cookie(server);
1641
1642         kfree(server->session_key.response);
1643         server->session_key.response = NULL;
1644         server->session_key.len = 0;
1645
1646         task = xchg(&server->tsk, NULL);
1647         if (task)
1648                 force_sig(SIGKILL, task);
1649 }
1650
1651 static struct TCP_Server_Info *
1652 cifs_get_tcp_session(struct smb_vol *volume_info)
1653 {
1654         struct TCP_Server_Info *tcp_ses = NULL;
1655         struct sockaddr_storage addr;
1656         struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1657         struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1658         int rc;
1659
1660         memset(&addr, 0, sizeof(struct sockaddr_storage));
1661
1662         cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
1663
1664         if (volume_info->UNCip && volume_info->UNC) {
1665                 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1666                                         volume_info->UNCip,
1667                                         strlen(volume_info->UNCip),
1668                                         volume_info->port);
1669                 if (!rc) {
1670                         /* we failed translating address */
1671                         rc = -EINVAL;
1672                         goto out_err;
1673                 }
1674         } else if (volume_info->UNCip) {
1675                 /* BB using ip addr as tcp_ses name to connect to the
1676                    DFS root below */
1677                 cERROR(1, "Connecting to DFS root not implemented yet");
1678                 rc = -EINVAL;
1679                 goto out_err;
1680         } else /* which tcp_sess DFS root would we conect to */ {
1681                 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1682                         "unc=//192.168.1.100/public) specified");
1683                 rc = -EINVAL;
1684                 goto out_err;
1685         }
1686
1687         /* see if we already have a matching tcp_ses */
1688         tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
1689         if (tcp_ses)
1690                 return tcp_ses;
1691
1692         tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1693         if (!tcp_ses) {
1694                 rc = -ENOMEM;
1695                 goto out_err;
1696         }
1697
1698         rc = cifs_crypto_shash_allocate(tcp_ses);
1699         if (rc) {
1700                 cERROR(1, "could not setup hash structures rc %d", rc);
1701                 goto out_err;
1702         }
1703
1704         cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
1705         tcp_ses->hostname = extract_hostname(volume_info->UNC);
1706         if (IS_ERR(tcp_ses->hostname)) {
1707                 rc = PTR_ERR(tcp_ses->hostname);
1708                 goto out_err_crypto_release;
1709         }
1710
1711         tcp_ses->noblocksnd = volume_info->noblocksnd;
1712         tcp_ses->noautotune = volume_info->noautotune;
1713         tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
1714         atomic_set(&tcp_ses->inFlight, 0);
1715         init_waitqueue_head(&tcp_ses->response_q);
1716         init_waitqueue_head(&tcp_ses->request_q);
1717         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1718         mutex_init(&tcp_ses->srv_mutex);
1719         memcpy(tcp_ses->workstation_RFC1001_name,
1720                 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1721         memcpy(tcp_ses->server_RFC1001_name,
1722                 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1723         tcp_ses->session_estab = false;
1724         tcp_ses->sequence_number = 0;
1725         tcp_ses->lstrp = jiffies;
1726         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1727         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1728         INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1729
1730         /*
1731          * at this point we are the only ones with the pointer
1732          * to the struct since the kernel thread not created yet
1733          * no need to spinlock this init of tcpStatus or srv_count
1734          */
1735         tcp_ses->tcpStatus = CifsNew;
1736         memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1737                sizeof(tcp_ses->srcaddr));
1738         ++tcp_ses->srv_count;
1739
1740         if (addr.ss_family == AF_INET6) {
1741                 cFYI(1, "attempting ipv6 connect");
1742                 /* BB should we allow ipv6 on port 139? */
1743                 /* other OS never observed in Wild doing 139 with v6 */
1744                 memcpy(&tcp_ses->dstaddr, sin_server6,
1745                        sizeof(struct sockaddr_in6));
1746         } else
1747                 memcpy(&tcp_ses->dstaddr, sin_server,
1748                        sizeof(struct sockaddr_in));
1749
1750         rc = ip_connect(tcp_ses);
1751         if (rc < 0) {
1752                 cERROR(1, "Error connecting to socket. Aborting operation");
1753                 goto out_err_crypto_release;
1754         }
1755
1756         /*
1757          * since we're in a cifs function already, we know that
1758          * this will succeed. No need for try_module_get().
1759          */
1760         __module_get(THIS_MODULE);
1761         tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1762                                   tcp_ses, "cifsd");
1763         if (IS_ERR(tcp_ses->tsk)) {
1764                 rc = PTR_ERR(tcp_ses->tsk);
1765                 cERROR(1, "error %d create cifsd thread", rc);
1766                 module_put(THIS_MODULE);
1767                 goto out_err_crypto_release;
1768         }
1769
1770         /* thread spawned, put it on the list */
1771         spin_lock(&cifs_tcp_ses_lock);
1772         list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1773         spin_unlock(&cifs_tcp_ses_lock);
1774
1775         cifs_fscache_get_client_cookie(tcp_ses);
1776
1777         /* queue echo request delayed work */
1778         queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
1779
1780         return tcp_ses;
1781
1782 out_err_crypto_release:
1783         cifs_crypto_shash_release(tcp_ses);
1784
1785         put_net(cifs_net_ns(tcp_ses));
1786
1787 out_err:
1788         if (tcp_ses) {
1789                 if (!IS_ERR(tcp_ses->hostname))
1790                         kfree(tcp_ses->hostname);
1791                 if (tcp_ses->ssocket)
1792                         sock_release(tcp_ses->ssocket);
1793                 kfree(tcp_ses);
1794         }
1795         return ERR_PTR(rc);
1796 }
1797
1798 static struct cifsSesInfo *
1799 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1800 {
1801         struct cifsSesInfo *ses;
1802
1803         spin_lock(&cifs_tcp_ses_lock);
1804         list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1805                 switch (server->secType) {
1806                 case Kerberos:
1807                         if (vol->cred_uid != ses->cred_uid)
1808                                 continue;
1809                         break;
1810                 default:
1811                         /* anything else takes username/password */
1812                         if (ses->user_name == NULL)
1813                                 continue;
1814                         if (strncmp(ses->user_name, vol->username,
1815                                     MAX_USERNAME_SIZE))
1816                                 continue;
1817                         if (strlen(vol->username) != 0 &&
1818                             ses->password != NULL &&
1819                             strncmp(ses->password,
1820                                     vol->password ? vol->password : "",
1821                                     MAX_PASSWORD_SIZE))
1822                                 continue;
1823                 }
1824                 ++ses->ses_count;
1825                 spin_unlock(&cifs_tcp_ses_lock);
1826                 return ses;
1827         }
1828         spin_unlock(&cifs_tcp_ses_lock);
1829         return NULL;
1830 }
1831
1832 static void
1833 cifs_put_smb_ses(struct cifsSesInfo *ses)
1834 {
1835         int xid;
1836         struct TCP_Server_Info *server = ses->server;
1837
1838         cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
1839         spin_lock(&cifs_tcp_ses_lock);
1840         if (--ses->ses_count > 0) {
1841                 spin_unlock(&cifs_tcp_ses_lock);
1842                 return;
1843         }
1844
1845         list_del_init(&ses->smb_ses_list);
1846         spin_unlock(&cifs_tcp_ses_lock);
1847
1848         if (ses->status == CifsGood) {
1849                 xid = GetXid();
1850                 CIFSSMBLogoff(xid, ses);
1851                 _FreeXid(xid);
1852         }
1853         sesInfoFree(ses);
1854         cifs_put_tcp_session(server);
1855 }
1856
1857 static struct cifsSesInfo *
1858 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1859 {
1860         int rc = -ENOMEM, xid;
1861         struct cifsSesInfo *ses;
1862         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1863         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
1864
1865         xid = GetXid();
1866
1867         ses = cifs_find_smb_ses(server, volume_info);
1868         if (ses) {
1869                 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1870
1871                 mutex_lock(&ses->session_mutex);
1872                 rc = cifs_negotiate_protocol(xid, ses);
1873                 if (rc) {
1874                         mutex_unlock(&ses->session_mutex);
1875                         /* problem -- put our ses reference */
1876                         cifs_put_smb_ses(ses);
1877                         FreeXid(xid);
1878                         return ERR_PTR(rc);
1879                 }
1880                 if (ses->need_reconnect) {
1881                         cFYI(1, "Session needs reconnect");
1882                         rc = cifs_setup_session(xid, ses,
1883                                                 volume_info->local_nls);
1884                         if (rc) {
1885                                 mutex_unlock(&ses->session_mutex);
1886                                 /* problem -- put our reference */
1887                                 cifs_put_smb_ses(ses);
1888                                 FreeXid(xid);
1889                                 return ERR_PTR(rc);
1890                         }
1891                 }
1892                 mutex_unlock(&ses->session_mutex);
1893
1894                 /* existing SMB ses has a server reference already */
1895                 cifs_put_tcp_session(server);
1896                 FreeXid(xid);
1897                 return ses;
1898         }
1899
1900         cFYI(1, "Existing smb sess not found");
1901         ses = sesInfoAlloc();
1902         if (ses == NULL)
1903                 goto get_ses_fail;
1904
1905         /* new SMB session uses our server ref */
1906         ses->server = server;
1907         if (server->dstaddr.ss_family == AF_INET6)
1908                 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
1909         else
1910                 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
1911
1912         if (volume_info->username) {
1913                 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
1914                 if (!ses->user_name)
1915                         goto get_ses_fail;
1916         }
1917
1918         /* volume_info->password freed at unmount */
1919         if (volume_info->password) {
1920                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1921                 if (!ses->password)
1922                         goto get_ses_fail;
1923         }
1924         if (volume_info->domainname) {
1925                 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
1926                 if (!ses->domainName)
1927                         goto get_ses_fail;
1928         }
1929         ses->cred_uid = volume_info->cred_uid;
1930         ses->linux_uid = volume_info->linux_uid;
1931         ses->overrideSecFlg = volume_info->secFlg;
1932
1933         mutex_lock(&ses->session_mutex);
1934         rc = cifs_negotiate_protocol(xid, ses);
1935         if (!rc)
1936                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
1937         mutex_unlock(&ses->session_mutex);
1938         if (rc)
1939                 goto get_ses_fail;
1940
1941         /* success, put it on the list */
1942         spin_lock(&cifs_tcp_ses_lock);
1943         list_add(&ses->smb_ses_list, &server->smb_ses_list);
1944         spin_unlock(&cifs_tcp_ses_lock);
1945
1946         FreeXid(xid);
1947         return ses;
1948
1949 get_ses_fail:
1950         sesInfoFree(ses);
1951         FreeXid(xid);
1952         return ERR_PTR(rc);
1953 }
1954
1955 static struct cifsTconInfo *
1956 cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
1957 {
1958         struct list_head *tmp;
1959         struct cifsTconInfo *tcon;
1960
1961         spin_lock(&cifs_tcp_ses_lock);
1962         list_for_each(tmp, &ses->tcon_list) {
1963                 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1964                 if (tcon->tidStatus == CifsExiting)
1965                         continue;
1966                 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
1967                         continue;
1968
1969                 ++tcon->tc_count;
1970                 spin_unlock(&cifs_tcp_ses_lock);
1971                 return tcon;
1972         }
1973         spin_unlock(&cifs_tcp_ses_lock);
1974         return NULL;
1975 }
1976
1977 static void
1978 cifs_put_tcon(struct cifsTconInfo *tcon)
1979 {
1980         int xid;
1981         struct cifsSesInfo *ses = tcon->ses;
1982
1983         cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
1984         spin_lock(&cifs_tcp_ses_lock);
1985         if (--tcon->tc_count > 0) {
1986                 spin_unlock(&cifs_tcp_ses_lock);
1987                 return;
1988         }
1989
1990         list_del_init(&tcon->tcon_list);
1991         spin_unlock(&cifs_tcp_ses_lock);
1992
1993         xid = GetXid();
1994         CIFSSMBTDis(xid, tcon);
1995         _FreeXid(xid);
1996
1997         cifs_fscache_release_super_cookie(tcon);
1998         tconInfoFree(tcon);
1999         cifs_put_smb_ses(ses);
2000 }
2001
2002 static struct cifsTconInfo *
2003 cifs_get_tcon(struct cifsSesInfo *ses, struct smb_vol *volume_info)
2004 {
2005         int rc, xid;
2006         struct cifsTconInfo *tcon;
2007
2008         tcon = cifs_find_tcon(ses, volume_info->UNC);
2009         if (tcon) {
2010                 cFYI(1, "Found match on UNC path");
2011                 /* existing tcon already has a reference */
2012                 cifs_put_smb_ses(ses);
2013                 if (tcon->seal != volume_info->seal)
2014                         cERROR(1, "transport encryption setting "
2015                                    "conflicts with existing tid");
2016                 return tcon;
2017         }
2018
2019         tcon = tconInfoAlloc();
2020         if (tcon == NULL) {
2021                 rc = -ENOMEM;
2022                 goto out_fail;
2023         }
2024
2025         tcon->ses = ses;
2026         if (volume_info->password) {
2027                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2028                 if (!tcon->password) {
2029                         rc = -ENOMEM;
2030                         goto out_fail;
2031                 }
2032         }
2033
2034         if (strchr(volume_info->UNC + 3, '\\') == NULL
2035             && strchr(volume_info->UNC + 3, '/') == NULL) {
2036                 cERROR(1, "Missing share name");
2037                 rc = -ENODEV;
2038                 goto out_fail;
2039         }
2040
2041         /* BB Do we need to wrap session_mutex around
2042          * this TCon call and Unix SetFS as
2043          * we do on SessSetup and reconnect? */
2044         xid = GetXid();
2045         rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2046         FreeXid(xid);
2047         cFYI(1, "CIFS Tcon rc = %d", rc);
2048         if (rc)
2049                 goto out_fail;
2050
2051         if (volume_info->nodfs) {
2052                 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2053                 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2054         }
2055         tcon->seal = volume_info->seal;
2056         /* we can have only one retry value for a connection
2057            to a share so for resources mounted more than once
2058            to the same server share the last value passed in
2059            for the retry flag is used */
2060         tcon->retry = volume_info->retry;
2061         tcon->nocase = volume_info->nocase;
2062         tcon->local_lease = volume_info->local_lease;
2063
2064         spin_lock(&cifs_tcp_ses_lock);
2065         list_add(&tcon->tcon_list, &ses->tcon_list);
2066         spin_unlock(&cifs_tcp_ses_lock);
2067
2068         cifs_fscache_get_super_cookie(tcon);
2069
2070         return tcon;
2071
2072 out_fail:
2073         tconInfoFree(tcon);
2074         return ERR_PTR(rc);
2075 }
2076
2077 void
2078 cifs_put_tlink(struct tcon_link *tlink)
2079 {
2080         if (!tlink || IS_ERR(tlink))
2081                 return;
2082
2083         if (!atomic_dec_and_test(&tlink->tl_count) ||
2084             test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2085                 tlink->tl_time = jiffies;
2086                 return;
2087         }
2088
2089         if (!IS_ERR(tlink_tcon(tlink)))
2090                 cifs_put_tcon(tlink_tcon(tlink));
2091         kfree(tlink);
2092         return;
2093 }
2094
2095 int
2096 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
2097              const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2098              struct dfs_info3_param **preferrals, int remap)
2099 {
2100         char *temp_unc;
2101         int rc = 0;
2102
2103         *pnum_referrals = 0;
2104         *preferrals = NULL;
2105
2106         if (pSesInfo->ipc_tid == 0) {
2107                 temp_unc = kmalloc(2 /* for slashes */ +
2108                         strnlen(pSesInfo->serverName,
2109                                 SERVER_NAME_LEN_WITH_NULL * 2)
2110                                  + 1 + 4 /* slash IPC$ */  + 2,
2111                                 GFP_KERNEL);
2112                 if (temp_unc == NULL)
2113                         return -ENOMEM;
2114                 temp_unc[0] = '\\';
2115                 temp_unc[1] = '\\';
2116                 strcpy(temp_unc + 2, pSesInfo->serverName);
2117                 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2118                 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2119                 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2120                 kfree(temp_unc);
2121         }
2122         if (rc == 0)
2123                 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2124                                      pnum_referrals, nls_codepage, remap);
2125         /* BB map targetUNCs to dfs_info3 structures, here or
2126                 in CIFSGetDFSRefer BB */
2127
2128         return rc;
2129 }
2130
2131 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2132 static struct lock_class_key cifs_key[2];
2133 static struct lock_class_key cifs_slock_key[2];
2134
2135 static inline void
2136 cifs_reclassify_socket4(struct socket *sock)
2137 {
2138         struct sock *sk = sock->sk;
2139         BUG_ON(sock_owned_by_user(sk));
2140         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2141                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2142 }
2143
2144 static inline void
2145 cifs_reclassify_socket6(struct socket *sock)
2146 {
2147         struct sock *sk = sock->sk;
2148         BUG_ON(sock_owned_by_user(sk));
2149         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2150                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2151 }
2152 #else
2153 static inline void
2154 cifs_reclassify_socket4(struct socket *sock)
2155 {
2156 }
2157
2158 static inline void
2159 cifs_reclassify_socket6(struct socket *sock)
2160 {
2161 }
2162 #endif
2163
2164 /* See RFC1001 section 14 on representation of Netbios names */
2165 static void rfc1002mangle(char *target, char *source, unsigned int length)
2166 {
2167         unsigned int i, j;
2168
2169         for (i = 0, j = 0; i < (length); i++) {
2170                 /* mask a nibble at a time and encode */
2171                 target[j] = 'A' + (0x0F & (source[i] >> 4));
2172                 target[j+1] = 'A' + (0x0F & source[i]);
2173                 j += 2;
2174         }
2175
2176 }
2177
2178 static int
2179 bind_socket(struct TCP_Server_Info *server)
2180 {
2181         int rc = 0;
2182         if (server->srcaddr.ss_family != AF_UNSPEC) {
2183                 /* Bind to the specified local IP address */
2184                 struct socket *socket = server->ssocket;
2185                 rc = socket->ops->bind(socket,
2186                                        (struct sockaddr *) &server->srcaddr,
2187                                        sizeof(server->srcaddr));
2188                 if (rc < 0) {
2189                         struct sockaddr_in *saddr4;
2190                         struct sockaddr_in6 *saddr6;
2191                         saddr4 = (struct sockaddr_in *)&server->srcaddr;
2192                         saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2193                         if (saddr6->sin6_family == AF_INET6)
2194                                 cERROR(1, "cifs: "
2195                                        "Failed to bind to: %pI6c, error: %d\n",
2196                                        &saddr6->sin6_addr, rc);
2197                         else
2198                                 cERROR(1, "cifs: "
2199                                        "Failed to bind to: %pI4, error: %d\n",
2200                                        &saddr4->sin_addr.s_addr, rc);
2201                 }
2202         }
2203         return rc;
2204 }
2205
2206 static int
2207 ip_rfc1001_connect(struct TCP_Server_Info *server)
2208 {
2209         int rc = 0;
2210         /*
2211          * some servers require RFC1001 sessinit before sending
2212          * negprot - BB check reconnection in case where second
2213          * sessinit is sent but no second negprot
2214          */
2215         struct rfc1002_session_packet *ses_init_buf;
2216         struct smb_hdr *smb_buf;
2217         ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2218                                GFP_KERNEL);
2219         if (ses_init_buf) {
2220                 ses_init_buf->trailer.session_req.called_len = 32;
2221
2222                 if (server->server_RFC1001_name &&
2223                     server->server_RFC1001_name[0] != 0)
2224                         rfc1002mangle(ses_init_buf->trailer.
2225                                       session_req.called_name,
2226                                       server->server_RFC1001_name,
2227                                       RFC1001_NAME_LEN_WITH_NULL);
2228                 else
2229                         rfc1002mangle(ses_init_buf->trailer.
2230                                       session_req.called_name,
2231                                       DEFAULT_CIFS_CALLED_NAME,
2232                                       RFC1001_NAME_LEN_WITH_NULL);
2233
2234                 ses_init_buf->trailer.session_req.calling_len = 32;
2235
2236                 /*
2237                  * calling name ends in null (byte 16) from old smb
2238                  * convention.
2239                  */
2240                 if (server->workstation_RFC1001_name &&
2241                     server->workstation_RFC1001_name[0] != 0)
2242                         rfc1002mangle(ses_init_buf->trailer.
2243                                       session_req.calling_name,
2244                                       server->workstation_RFC1001_name,
2245                                       RFC1001_NAME_LEN_WITH_NULL);
2246                 else
2247                         rfc1002mangle(ses_init_buf->trailer.
2248                                       session_req.calling_name,
2249                                       "LINUX_CIFS_CLNT",
2250                                       RFC1001_NAME_LEN_WITH_NULL);
2251
2252                 ses_init_buf->trailer.session_req.scope1 = 0;
2253                 ses_init_buf->trailer.session_req.scope2 = 0;
2254                 smb_buf = (struct smb_hdr *)ses_init_buf;
2255
2256                 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2257                 smb_buf->smb_buf_length = 0x81000044;
2258                 rc = smb_send(server, smb_buf, 0x44);
2259                 kfree(ses_init_buf);
2260                 /*
2261                  * RFC1001 layer in at least one server
2262                  * requires very short break before negprot
2263                  * presumably because not expecting negprot
2264                  * to follow so fast.  This is a simple
2265                  * solution that works without
2266                  * complicating the code and causes no
2267                  * significant slowing down on mount
2268                  * for everyone else
2269                  */
2270                 usleep_range(1000, 2000);
2271         }
2272         /*
2273          * else the negprot may still work without this
2274          * even though malloc failed
2275          */
2276
2277         return rc;
2278 }
2279
2280 static int
2281 generic_ip_connect(struct TCP_Server_Info *server)
2282 {
2283         int rc = 0;
2284         __be16 sport;
2285         int slen, sfamily;
2286         struct socket *socket = server->ssocket;
2287         struct sockaddr *saddr;
2288
2289         saddr = (struct sockaddr *) &server->dstaddr;
2290
2291         if (server->dstaddr.ss_family == AF_INET6) {
2292                 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2293                 slen = sizeof(struct sockaddr_in6);
2294                 sfamily = AF_INET6;
2295         } else {
2296                 sport = ((struct sockaddr_in *) saddr)->sin_port;
2297                 slen = sizeof(struct sockaddr_in);
2298                 sfamily = AF_INET;
2299         }
2300
2301         if (socket == NULL) {
2302                 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2303                                    IPPROTO_TCP, &socket, 1);
2304                 if (rc < 0) {
2305                         cERROR(1, "Error %d creating socket", rc);
2306                         server->ssocket = NULL;
2307                         return rc;
2308                 }
2309
2310                 /* BB other socket options to set KEEPALIVE, NODELAY? */
2311                 cFYI(1, "Socket created");
2312                 server->ssocket = socket;
2313                 socket->sk->sk_allocation = GFP_NOFS;
2314                 if (sfamily == AF_INET6)
2315                         cifs_reclassify_socket6(socket);
2316                 else
2317                         cifs_reclassify_socket4(socket);
2318         }
2319
2320         rc = bind_socket(server);
2321         if (rc < 0)
2322                 return rc;
2323
2324         rc = socket->ops->connect(socket, saddr, slen, 0);
2325         if (rc < 0) {
2326                 cFYI(1, "Error %d connecting to server", rc);
2327                 sock_release(socket);
2328                 server->ssocket = NULL;
2329                 return rc;
2330         }
2331
2332         /*
2333          * Eventually check for other socket options to change from
2334          * the default. sock_setsockopt not used because it expects
2335          * user space buffer
2336          */
2337         socket->sk->sk_rcvtimeo = 7 * HZ;
2338         socket->sk->sk_sndtimeo = 5 * HZ;
2339
2340         /* make the bufsizes depend on wsize/rsize and max requests */
2341         if (server->noautotune) {
2342                 if (socket->sk->sk_sndbuf < (200 * 1024))
2343                         socket->sk->sk_sndbuf = 200 * 1024;
2344                 if (socket->sk->sk_rcvbuf < (140 * 1024))
2345                         socket->sk->sk_rcvbuf = 140 * 1024;
2346         }
2347
2348         if (server->tcp_nodelay) {
2349                 int val = 1;
2350                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2351                                 (char *)&val, sizeof(val));
2352                 if (rc)
2353                         cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2354         }
2355
2356          cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2357                  socket->sk->sk_sndbuf,
2358                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2359
2360         if (sport == htons(RFC1001_PORT))
2361                 rc = ip_rfc1001_connect(server);
2362
2363         return rc;
2364 }
2365
2366 static int
2367 ip_connect(struct TCP_Server_Info *server)
2368 {
2369         __be16 *sport;
2370         struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2371         struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2372
2373         if (server->dstaddr.ss_family == AF_INET6)
2374                 sport = &addr6->sin6_port;
2375         else
2376                 sport = &addr->sin_port;
2377
2378         if (*sport == 0) {
2379                 int rc;
2380
2381                 /* try with 445 port at first */
2382                 *sport = htons(CIFS_PORT);
2383
2384                 rc = generic_ip_connect(server);
2385                 if (rc >= 0)
2386                         return rc;
2387
2388                 /* if it failed, try with 139 port */
2389                 *sport = htons(RFC1001_PORT);
2390         }
2391
2392         return generic_ip_connect(server);
2393 }
2394
2395 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
2396                           struct super_block *sb, struct smb_vol *vol_info)
2397 {
2398         /* if we are reconnecting then should we check to see if
2399          * any requested capabilities changed locally e.g. via
2400          * remount but we can not do much about it here
2401          * if they have (even if we could detect it by the following)
2402          * Perhaps we could add a backpointer to array of sb from tcon
2403          * or if we change to make all sb to same share the same
2404          * sb as NFS - then we only have one backpointer to sb.
2405          * What if we wanted to mount the server share twice once with
2406          * and once without posixacls or posix paths? */
2407         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2408
2409         if (vol_info && vol_info->no_linux_ext) {
2410                 tcon->fsUnixInfo.Capability = 0;
2411                 tcon->unix_ext = 0; /* Unix Extensions disabled */
2412                 cFYI(1, "Linux protocol extensions disabled");
2413                 return;
2414         } else if (vol_info)
2415                 tcon->unix_ext = 1; /* Unix Extensions supported */
2416
2417         if (tcon->unix_ext == 0) {
2418                 cFYI(1, "Unix extensions disabled so not set on reconnect");
2419                 return;
2420         }
2421
2422         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2423                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2424
2425                 /* check for reconnect case in which we do not
2426                    want to change the mount behavior if we can avoid it */
2427                 if (vol_info == NULL) {
2428                         /* turn off POSIX ACL and PATHNAMES if not set
2429                            originally at mount time */
2430                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2431                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2432                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2433                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2434                                         cERROR(1, "POSIXPATH support change");
2435                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2436                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2437                                 cERROR(1, "possible reconnect error");
2438                                 cERROR(1, "server disabled POSIX path support");
2439                         }
2440                 }
2441
2442                 cap &= CIFS_UNIX_CAP_MASK;
2443                 if (vol_info && vol_info->no_psx_acl)
2444                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2445                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2446                         cFYI(1, "negotiated posix acl support");
2447                         if (sb)
2448                                 sb->s_flags |= MS_POSIXACL;
2449                 }
2450
2451                 if (vol_info && vol_info->posix_paths == 0)
2452                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2453                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2454                         cFYI(1, "negotiate posix pathnames");
2455                         if (sb)
2456                                 CIFS_SB(sb)->mnt_cifs_flags |=
2457                                         CIFS_MOUNT_POSIX_PATHS;
2458                 }
2459
2460                 /* We might be setting the path sep back to a different
2461                 form if we are reconnecting and the server switched its
2462                 posix path capability for this share */
2463                 if (sb && (CIFS_SB(sb)->prepathlen > 0))
2464                         CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
2465
2466                 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2467                         if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2468                                 CIFS_SB(sb)->rsize = 127 * 1024;
2469                                 cFYI(DBG2, "larger reads not supported by srv");
2470                         }
2471                 }
2472
2473
2474                 cFYI(1, "Negotiate caps 0x%x", (int)cap);
2475 #ifdef CONFIG_CIFS_DEBUG2
2476                 if (cap & CIFS_UNIX_FCNTL_CAP)
2477                         cFYI(1, "FCNTL cap");
2478                 if (cap & CIFS_UNIX_EXTATTR_CAP)
2479                         cFYI(1, "EXTATTR cap");
2480                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2481                         cFYI(1, "POSIX path cap");
2482                 if (cap & CIFS_UNIX_XATTR_CAP)
2483                         cFYI(1, "XATTR cap");
2484                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2485                         cFYI(1, "POSIX ACL cap");
2486                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2487                         cFYI(1, "very large read cap");
2488                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2489                         cFYI(1, "very large write cap");
2490 #endif /* CIFS_DEBUG2 */
2491                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2492                         if (vol_info == NULL) {
2493                                 cFYI(1, "resetting capabilities failed");
2494                         } else
2495                                 cERROR(1, "Negotiating Unix capabilities "
2496                                            "with the server failed.  Consider "
2497                                            "mounting with the Unix Extensions\n"
2498                                            "disabled, if problems are found, "
2499                                            "by specifying the nounix mount "
2500                                            "option.");
2501
2502                 }
2503         }
2504 }
2505
2506 static void
2507 convert_delimiter(char *path, char delim)
2508 {
2509         int i;
2510         char old_delim;
2511
2512         if (path == NULL)
2513                 return;
2514
2515         if (delim == '/')
2516                 old_delim = '\\';
2517         else
2518                 old_delim = '/';
2519
2520         for (i = 0; path[i] != '\0'; i++) {
2521                 if (path[i] == old_delim)
2522                         path[i] = delim;
2523         }
2524 }
2525
2526 static void setup_cifs_sb(struct smb_vol *pvolume_info,
2527                           struct cifs_sb_info *cifs_sb)
2528 {
2529         INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2530
2531         if (pvolume_info->rsize > CIFSMaxBufSize) {
2532                 cERROR(1, "rsize %d too large, using MaxBufSize",
2533                         pvolume_info->rsize);
2534                 cifs_sb->rsize = CIFSMaxBufSize;
2535         } else if ((pvolume_info->rsize) &&
2536                         (pvolume_info->rsize <= CIFSMaxBufSize))
2537                 cifs_sb->rsize = pvolume_info->rsize;
2538         else /* default */
2539                 cifs_sb->rsize = CIFSMaxBufSize;
2540
2541         if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2542                 cERROR(1, "wsize %d too large, using 4096 instead",
2543                           pvolume_info->wsize);
2544                 cifs_sb->wsize = 4096;
2545         } else if (pvolume_info->wsize)
2546                 cifs_sb->wsize = pvolume_info->wsize;
2547         else
2548                 cifs_sb->wsize = min_t(const int,
2549                                         PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2550                                         127*1024);
2551                 /* old default of CIFSMaxBufSize was too small now
2552                    that SMB Write2 can send multiple pages in kvec.
2553                    RFC1001 does not describe what happens when frame
2554                    bigger than 128K is sent so use that as max in
2555                    conjunction with 52K kvec constraint on arch with 4K
2556                    page size  */
2557
2558         if (cifs_sb->rsize < 2048) {
2559                 cifs_sb->rsize = 2048;
2560                 /* Windows ME may prefer this */
2561                 cFYI(1, "readsize set to minimum: 2048");
2562         }
2563         /* calculate prepath */
2564         cifs_sb->prepath = pvolume_info->prepath;
2565         if (cifs_sb->prepath) {
2566                 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2567                 /* we can not convert the / to \ in the path
2568                 separators in the prefixpath yet because we do not
2569                 know (until reset_cifs_unix_caps is called later)
2570                 whether POSIX PATH CAP is available. We normalize
2571                 the / to \ after reset_cifs_unix_caps is called */
2572                 pvolume_info->prepath = NULL;
2573         } else
2574                 cifs_sb->prepathlen = 0;
2575         cifs_sb->mnt_uid = pvolume_info->linux_uid;
2576         cifs_sb->mnt_gid = pvolume_info->linux_gid;
2577         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2578         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2579         cFYI(1, "file mode: 0x%x  dir mode: 0x%x",
2580                 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
2581
2582         cifs_sb->actimeo = pvolume_info->actimeo;
2583
2584         if (pvolume_info->noperm)
2585                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2586         if (pvolume_info->setuids)
2587                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2588         if (pvolume_info->server_ino)
2589                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2590         if (pvolume_info->remap)
2591                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2592         if (pvolume_info->no_xattr)
2593                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2594         if (pvolume_info->sfu_emul)
2595                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2596         if (pvolume_info->nobrl)
2597                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2598         if (pvolume_info->nostrictsync)
2599                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2600         if (pvolume_info->mand_lock)
2601                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2602         if (pvolume_info->cifs_acl)
2603                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2604         if (pvolume_info->override_uid)
2605                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2606         if (pvolume_info->override_gid)
2607                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2608         if (pvolume_info->dynperm)
2609                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2610         if (pvolume_info->fsc)
2611                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
2612         if (pvolume_info->multiuser)
2613                 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2614                                             CIFS_MOUNT_NO_PERM);
2615         if (pvolume_info->strict_io)
2616                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
2617         if (pvolume_info->direct_io) {
2618                 cFYI(1, "mounting share using direct i/o");
2619                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2620         }
2621         if (pvolume_info->mfsymlinks) {
2622                 if (pvolume_info->sfu_emul) {
2623                         cERROR(1,  "mount option mfsymlinks ignored if sfu "
2624                                    "mount option is used");
2625                 } else {
2626                         cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2627                 }
2628         }
2629
2630         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2631                 cERROR(1, "mount option dynperm ignored if cifsacl "
2632                            "mount option supported");
2633 }
2634
2635 static int
2636 is_path_accessible(int xid, struct cifsTconInfo *tcon,
2637                    struct cifs_sb_info *cifs_sb, const char *full_path)
2638 {
2639         int rc;
2640         FILE_ALL_INFO *pfile_info;
2641
2642         pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2643         if (pfile_info == NULL)
2644                 return -ENOMEM;
2645
2646         rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2647                               0 /* not legacy */, cifs_sb->local_nls,
2648                               cifs_sb->mnt_cifs_flags &
2649                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
2650         kfree(pfile_info);
2651         return rc;
2652 }
2653
2654 static void
2655 cleanup_volume_info(struct smb_vol **pvolume_info)
2656 {
2657         struct smb_vol *volume_info;
2658
2659         if (!pvolume_info || !*pvolume_info)
2660                 return;
2661
2662         volume_info = *pvolume_info;
2663         kzfree(volume_info->password);
2664         kfree(volume_info->UNC);
2665         kfree(volume_info->prepath);
2666         kfree(volume_info);
2667         *pvolume_info = NULL;
2668         return;
2669 }
2670
2671 #ifdef CONFIG_CIFS_DFS_UPCALL
2672 /* build_path_to_root returns full path to root when
2673  * we do not have an exiting connection (tcon) */
2674 static char *
2675 build_unc_path_to_root(const struct smb_vol *volume_info,
2676                 const struct cifs_sb_info *cifs_sb)
2677 {
2678         char *full_path;
2679
2680         int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2681         full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2682         if (full_path == NULL)
2683                 return ERR_PTR(-ENOMEM);
2684
2685         strncpy(full_path, volume_info->UNC, unc_len);
2686         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2687                 int i;
2688                 for (i = 0; i < unc_len; i++) {
2689                         if (full_path[i] == '\\')
2690                                 full_path[i] = '/';
2691                 }
2692         }
2693
2694         if (cifs_sb->prepathlen)
2695                 strncpy(full_path + unc_len, cifs_sb->prepath,
2696                                 cifs_sb->prepathlen);
2697
2698         full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2699         return full_path;
2700 }
2701 #endif
2702
2703 int
2704 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
2705                 char *mount_data_global, const char *devname)
2706 {
2707         int rc;
2708         int xid;
2709         struct smb_vol *volume_info;
2710         struct cifsSesInfo *pSesInfo;
2711         struct cifsTconInfo *tcon;
2712         struct TCP_Server_Info *srvTcp;
2713         char   *full_path;
2714         char *mount_data = mount_data_global;
2715         struct tcon_link *tlink;
2716 #ifdef CONFIG_CIFS_DFS_UPCALL
2717         struct dfs_info3_param *referrals = NULL;
2718         unsigned int num_referrals = 0;
2719         int referral_walks_count = 0;
2720 try_mount_again:
2721 #endif
2722         rc = 0;
2723         tcon = NULL;
2724         pSesInfo = NULL;
2725         srvTcp = NULL;
2726         full_path = NULL;
2727         tlink = NULL;
2728
2729         xid = GetXid();
2730
2731         volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2732         if (!volume_info) {
2733                 rc = -ENOMEM;
2734                 goto out;
2735         }
2736
2737         if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
2738                 rc = -EINVAL;
2739                 goto out;
2740         }
2741
2742         if (volume_info->nullauth) {
2743                 cFYI(1, "null user");
2744                 volume_info->username = "";
2745         } else if (volume_info->username) {
2746                 /* BB fixme parse for domain name here */
2747                 cFYI(1, "Username: %s", volume_info->username);
2748         } else {
2749                 cifserror("No username specified");
2750         /* In userspace mount helper we can get user name from alternate
2751            locations such as env variables and files on disk */
2752                 rc = -EINVAL;
2753                 goto out;
2754         }
2755
2756         /* this is needed for ASCII cp to Unicode converts */
2757         if (volume_info->iocharset == NULL) {
2758                 /* load_nls_default cannot return null */
2759                 volume_info->local_nls = load_nls_default();
2760         } else {
2761                 volume_info->local_nls = load_nls(volume_info->iocharset);
2762                 if (volume_info->local_nls == NULL) {
2763                         cERROR(1, "CIFS mount error: iocharset %s not found",
2764                                  volume_info->iocharset);
2765                         rc = -ELIBACC;
2766                         goto out;
2767                 }
2768         }
2769         cifs_sb->local_nls = volume_info->local_nls;
2770
2771         /* get a reference to a tcp session */
2772         srvTcp = cifs_get_tcp_session(volume_info);
2773         if (IS_ERR(srvTcp)) {
2774                 rc = PTR_ERR(srvTcp);
2775                 goto out;
2776         }
2777
2778         /* get a reference to a SMB session */
2779         pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
2780         if (IS_ERR(pSesInfo)) {
2781                 rc = PTR_ERR(pSesInfo);
2782                 pSesInfo = NULL;
2783                 goto mount_fail_check;
2784         }
2785
2786         setup_cifs_sb(volume_info, cifs_sb);
2787         if (pSesInfo->capabilities & CAP_LARGE_FILES)
2788                 sb->s_maxbytes = MAX_LFS_FILESIZE;
2789         else
2790                 sb->s_maxbytes = MAX_NON_LFS;
2791
2792         /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2793         sb->s_time_gran = 100;
2794
2795         /* search for existing tcon to this server share */
2796         tcon = cifs_get_tcon(pSesInfo, volume_info);
2797         if (IS_ERR(tcon)) {
2798                 rc = PTR_ERR(tcon);
2799                 tcon = NULL;
2800                 goto remote_path_check;
2801         }
2802
2803         /* do not care if following two calls succeed - informational */
2804         if (!tcon->ipc) {
2805                 CIFSSMBQFSDeviceInfo(xid, tcon);
2806                 CIFSSMBQFSAttributeInfo(xid, tcon);
2807         }
2808
2809         /* tell server which Unix caps we support */
2810         if (tcon->ses->capabilities & CAP_UNIX)
2811                 /* reset of caps checks mount to see if unix extensions
2812                    disabled for just this mount */
2813                 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
2814         else
2815                 tcon->unix_ext = 0; /* server does not support them */
2816
2817         /* convert forward to back slashes in prepath here if needed */
2818         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2819                 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2820
2821         if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2822                 cifs_sb->rsize = 1024 * 127;
2823                 cFYI(DBG2, "no very large read support, rsize now 127K");
2824         }
2825         if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2826                 cifs_sb->wsize = min(cifs_sb->wsize,
2827                                (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2828         if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2829                 cifs_sb->rsize = min(cifs_sb->rsize,
2830                                (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2831
2832 remote_path_check:
2833         /* check if a whole path (including prepath) is not remote */
2834         if (!rc && tcon) {
2835                 /* build_path_to_root works only when we have a valid tcon */
2836                 full_path = cifs_build_path_to_root(cifs_sb, tcon);
2837                 if (full_path == NULL) {
2838                         rc = -ENOMEM;
2839                         goto mount_fail_check;
2840                 }
2841                 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
2842                 if (rc != 0 && rc != -EREMOTE) {
2843                         kfree(full_path);
2844                         goto mount_fail_check;
2845                 }
2846                 kfree(full_path);
2847         }
2848
2849         /* get referral if needed */
2850         if (rc == -EREMOTE) {
2851 #ifdef CONFIG_CIFS_DFS_UPCALL
2852                 if (referral_walks_count > MAX_NESTED_LINKS) {
2853                         /*
2854                          * BB: when we implement proper loop detection,
2855                          *     we will remove this check. But now we need it
2856                          *     to prevent an indefinite loop if 'DFS tree' is
2857                          *     misconfigured (i.e. has loops).
2858                          */
2859                         rc = -ELOOP;
2860                         goto mount_fail_check;
2861                 }
2862                 /* convert forward to back slashes in prepath here if needed */
2863                 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2864                         convert_delimiter(cifs_sb->prepath,
2865                                         CIFS_DIR_SEP(cifs_sb));
2866                 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2867                 if (IS_ERR(full_path)) {
2868                         rc = PTR_ERR(full_path);
2869                         goto mount_fail_check;
2870                 }
2871
2872                 cFYI(1, "Getting referral for: %s", full_path);
2873                 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2874                         cifs_sb->local_nls, &num_referrals, &referrals,
2875                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2876                 if (!rc && num_referrals > 0) {
2877                         char *fake_devname = NULL;
2878
2879                         if (mount_data != mount_data_global)
2880                                 kfree(mount_data);
2881
2882                         mount_data = cifs_compose_mount_options(
2883                                         cifs_sb->mountdata, full_path + 1,
2884                                         referrals, &fake_devname);
2885
2886                         free_dfs_info_array(referrals, num_referrals);
2887                         kfree(fake_devname);
2888                         kfree(full_path);
2889
2890                         if (IS_ERR(mount_data)) {
2891                                 rc = PTR_ERR(mount_data);
2892                                 mount_data = NULL;
2893                                 goto mount_fail_check;
2894                         }
2895
2896                         if (tcon)
2897                                 cifs_put_tcon(tcon);
2898                         else if (pSesInfo)
2899                                 cifs_put_smb_ses(pSesInfo);
2900
2901                         cleanup_volume_info(&volume_info);
2902                         referral_walks_count++;
2903                         FreeXid(xid);
2904                         goto try_mount_again;
2905                 }
2906 #else /* No DFS support, return error on mount */
2907                 rc = -EOPNOTSUPP;
2908 #endif
2909         }
2910
2911         if (rc)
2912                 goto mount_fail_check;
2913
2914         /* now, hang the tcon off of the superblock */
2915         tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
2916         if (tlink == NULL) {
2917                 rc = -ENOMEM;
2918                 goto mount_fail_check;
2919         }
2920
2921         tlink->tl_uid = pSesInfo->linux_uid;
2922         tlink->tl_tcon = tcon;
2923         tlink->tl_time = jiffies;
2924         set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
2925         set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
2926
2927         cifs_sb->master_tlink = tlink;
2928         spin_lock(&cifs_sb->tlink_tree_lock);
2929         tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
2930         spin_unlock(&cifs_sb->tlink_tree_lock);
2931
2932         queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
2933                                 TLINK_IDLE_EXPIRE);
2934
2935 mount_fail_check:
2936         /* on error free sesinfo and tcon struct if needed */
2937         if (rc) {
2938                 if (mount_data != mount_data_global)
2939                         kfree(mount_data);
2940                 /* If find_unc succeeded then rc == 0 so we can not end */
2941                 /* up accidentally freeing someone elses tcon struct */
2942                 if (tcon)
2943                         cifs_put_tcon(tcon);
2944                 else if (pSesInfo)
2945                         cifs_put_smb_ses(pSesInfo);
2946                 else
2947                         cifs_put_tcp_session(srvTcp);
2948                 goto out;
2949         }
2950
2951         /* volume_info->password is freed above when existing session found
2952         (in which case it is not needed anymore) but when new sesion is created
2953         the password ptr is put in the new session structure (in which case the
2954         password will be freed at unmount time) */
2955 out:
2956         /* zero out password before freeing */
2957         cleanup_volume_info(&volume_info);
2958         FreeXid(xid);
2959         return rc;
2960 }
2961
2962 int
2963 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
2964          const char *tree, struct cifsTconInfo *tcon,
2965          const struct nls_table *nls_codepage)
2966 {
2967         struct smb_hdr *smb_buffer;
2968         struct smb_hdr *smb_buffer_response;
2969         TCONX_REQ *pSMB;
2970         TCONX_RSP *pSMBr;
2971         unsigned char *bcc_ptr;
2972         int rc = 0;
2973         int length;
2974         __u16 bytes_left, count;
2975
2976         if (ses == NULL)
2977                 return -EIO;
2978
2979         smb_buffer = cifs_buf_get();
2980         if (smb_buffer == NULL)
2981                 return -ENOMEM;
2982
2983         smb_buffer_response = smb_buffer;
2984
2985         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
2986                         NULL /*no tid */ , 4 /*wct */ );
2987
2988         smb_buffer->Mid = GetNextMid(ses->server);
2989         smb_buffer->Uid = ses->Suid;
2990         pSMB = (TCONX_REQ *) smb_buffer;
2991         pSMBr = (TCONX_RSP *) smb_buffer_response;
2992
2993         pSMB->AndXCommand = 0xFF;
2994         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
2995         bcc_ptr = &pSMB->Password[0];
2996         if ((ses->server->secMode) & SECMODE_USER) {
2997                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
2998                 *bcc_ptr = 0; /* password is null byte */
2999                 bcc_ptr++;              /* skip password */
3000                 /* already aligned so no need to do it below */
3001         } else {
3002                 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3003                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3004                    specified as required (when that support is added to
3005                    the vfs in the future) as only NTLM or the much
3006                    weaker LANMAN (which we do not send by default) is accepted
3007                    by Samba (not sure whether other servers allow
3008                    NTLMv2 password here) */
3009 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3010                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3011                     (ses->server->secType == LANMAN))
3012                         calc_lanman_hash(tcon->password, ses->server->cryptkey,
3013                                          ses->server->secMode &
3014                                             SECMODE_PW_ENCRYPT ? true : false,
3015                                          bcc_ptr);
3016                 else
3017 #endif /* CIFS_WEAK_PW_HASH */
3018                 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3019                                         bcc_ptr);
3020
3021                 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3022                 if (ses->capabilities & CAP_UNICODE) {
3023                         /* must align unicode strings */
3024                         *bcc_ptr = 0; /* null byte password */
3025                         bcc_ptr++;
3026                 }
3027         }
3028
3029         if (ses->server->secMode &
3030                         (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3031                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3032
3033         if (ses->capabilities & CAP_STATUS32) {
3034                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3035         }
3036         if (ses->capabilities & CAP_DFS) {
3037                 smb_buffer->Flags2 |= SMBFLG2_DFS;
3038         }
3039         if (ses->capabilities & CAP_UNICODE) {
3040                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3041                 length =
3042                     cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3043                         6 /* max utf8 char length in bytes */ *
3044                         (/* server len*/ + 256 /* share len */), nls_codepage);
3045                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
3046                 bcc_ptr += 2;   /* skip trailing null */
3047         } else {                /* ASCII */
3048                 strcpy(bcc_ptr, tree);
3049                 bcc_ptr += strlen(tree) + 1;
3050         }
3051         strcpy(bcc_ptr, "?????");
3052         bcc_ptr += strlen("?????");
3053         bcc_ptr += 1;
3054         count = bcc_ptr - &pSMB->Password[0];
3055         pSMB->hdr.smb_buf_length += count;
3056         pSMB->ByteCount = cpu_to_le16(count);
3057
3058         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3059                          0);
3060
3061         /* above now done in SendReceive */
3062         if ((rc == 0) && (tcon != NULL)) {
3063                 bool is_unicode;
3064
3065                 tcon->tidStatus = CifsGood;
3066                 tcon->need_reconnect = false;
3067                 tcon->tid = smb_buffer_response->Tid;
3068                 bcc_ptr = pByteArea(smb_buffer_response);
3069                 bytes_left = get_bcc(smb_buffer_response);
3070                 length = strnlen(bcc_ptr, bytes_left - 2);
3071                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3072                         is_unicode = true;
3073                 else
3074                         is_unicode = false;
3075
3076
3077                 /* skip service field (NB: this field is always ASCII) */
3078                 if (length == 3) {
3079                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3080                             (bcc_ptr[2] == 'C')) {
3081                                 cFYI(1, "IPC connection");
3082                                 tcon->ipc = 1;
3083                         }
3084                 } else if (length == 2) {
3085                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3086                                 /* the most common case */
3087                                 cFYI(1, "disk share connection");
3088                         }
3089                 }
3090                 bcc_ptr += length + 1;
3091                 bytes_left -= (length + 1);
3092                 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3093
3094                 /* mostly informational -- no need to fail on error here */
3095                 kfree(tcon->nativeFileSystem);
3096                 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
3097                                                       bytes_left, is_unicode,
3098                                                       nls_codepage);
3099
3100                 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3101
3102                 if ((smb_buffer_response->WordCount == 3) ||
3103                          (smb_buffer_response->WordCount == 7))
3104                         /* field is in same location */
3105                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3106                 else
3107                         tcon->Flags = 0;
3108                 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3109         } else if ((rc == 0) && tcon == NULL) {
3110                 /* all we need to save for IPC$ connection */
3111                 ses->ipc_tid = smb_buffer_response->Tid;
3112         }
3113
3114         cifs_buf_release(smb_buffer);
3115         return rc;
3116 }
3117
3118 int
3119 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3120 {
3121         struct rb_root *root = &cifs_sb->tlink_tree;
3122         struct rb_node *node;
3123         struct tcon_link *tlink;
3124         char *tmp;
3125
3126         cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3127
3128         spin_lock(&cifs_sb->tlink_tree_lock);
3129         while ((node = rb_first(root))) {
3130                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3131                 cifs_get_tlink(tlink);
3132                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3133                 rb_erase(node, root);
3134
3135                 spin_unlock(&cifs_sb->tlink_tree_lock);
3136                 cifs_put_tlink(tlink);
3137                 spin_lock(&cifs_sb->tlink_tree_lock);
3138         }
3139         spin_unlock(&cifs_sb->tlink_tree_lock);
3140
3141         tmp = cifs_sb->prepath;
3142         cifs_sb->prepathlen = 0;
3143         cifs_sb->prepath = NULL;
3144         kfree(tmp);
3145
3146         return 0;
3147 }
3148
3149 int cifs_negotiate_protocol(unsigned int xid, struct cifsSesInfo *ses)
3150 {
3151         int rc = 0;
3152         struct TCP_Server_Info *server = ses->server;
3153
3154         /* only send once per connect */
3155         if (server->maxBuf != 0)
3156                 return 0;
3157
3158         rc = CIFSSMBNegotiate(xid, ses);
3159         if (rc == -EAGAIN) {
3160                 /* retry only once on 1st time connection */
3161                 rc = CIFSSMBNegotiate(xid, ses);
3162                 if (rc == -EAGAIN)
3163                         rc = -EHOSTDOWN;
3164         }
3165         if (rc == 0) {
3166                 spin_lock(&GlobalMid_Lock);
3167                 if (server->tcpStatus != CifsExiting)
3168                         server->tcpStatus = CifsGood;
3169                 else
3170                         rc = -EHOSTDOWN;
3171                 spin_unlock(&GlobalMid_Lock);
3172
3173         }
3174
3175         return rc;
3176 }
3177
3178
3179 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *ses,
3180                         struct nls_table *nls_info)
3181 {
3182         int rc = 0;
3183         struct TCP_Server_Info *server = ses->server;
3184
3185         ses->flags = 0;
3186         ses->capabilities = server->capabilities;
3187         if (linuxExtEnabled == 0)
3188                 ses->capabilities &= (~CAP_UNIX);
3189
3190         cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3191                  server->secMode, server->capabilities, server->timeAdj);
3192
3193         rc = CIFS_SessSetup(xid, ses, nls_info);
3194         if (rc) {
3195                 cERROR(1, "Send error in SessSetup = %d", rc);
3196         } else {
3197                 mutex_lock(&ses->server->srv_mutex);
3198                 if (!server->session_estab) {
3199                         server->session_key.response = ses->auth_key.response;
3200                         server->session_key.len = ses->auth_key.len;
3201                         server->sequence_number = 0x2;
3202                         server->session_estab = true;
3203                         ses->auth_key.response = NULL;
3204                 }
3205                 mutex_unlock(&server->srv_mutex);
3206
3207                 cFYI(1, "CIFS Session Established successfully");
3208                 spin_lock(&GlobalMid_Lock);
3209                 ses->status = CifsGood;
3210                 ses->need_reconnect = false;
3211                 spin_unlock(&GlobalMid_Lock);
3212         }
3213
3214         kfree(ses->auth_key.response);
3215         ses->auth_key.response = NULL;
3216         ses->auth_key.len = 0;
3217         kfree(ses->ntlmssp);
3218         ses->ntlmssp = NULL;
3219
3220         return rc;
3221 }
3222
3223 static struct cifsTconInfo *
3224 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3225 {
3226         struct cifsTconInfo *master_tcon = cifs_sb_master_tcon(cifs_sb);
3227         struct cifsSesInfo *ses;
3228         struct cifsTconInfo *tcon = NULL;
3229         struct smb_vol *vol_info;
3230         char username[MAX_USERNAME_SIZE + 1];
3231
3232         vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3233         if (vol_info == NULL) {
3234                 tcon = ERR_PTR(-ENOMEM);
3235                 goto out;
3236         }
3237
3238         snprintf(username, MAX_USERNAME_SIZE, "krb50x%x", fsuid);
3239         vol_info->username = username;
3240         vol_info->local_nls = cifs_sb->local_nls;
3241         vol_info->linux_uid = fsuid;
3242         vol_info->cred_uid = fsuid;
3243         vol_info->UNC = master_tcon->treeName;
3244         vol_info->retry = master_tcon->retry;
3245         vol_info->nocase = master_tcon->nocase;
3246         vol_info->local_lease = master_tcon->local_lease;
3247         vol_info->no_linux_ext = !master_tcon->unix_ext;
3248
3249         /* FIXME: allow for other secFlg settings */
3250         vol_info->secFlg = CIFSSEC_MUST_KRB5;
3251
3252         /* get a reference for the same TCP session */
3253         spin_lock(&cifs_tcp_ses_lock);
3254         ++master_tcon->ses->server->srv_count;
3255         spin_unlock(&cifs_tcp_ses_lock);
3256
3257         ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3258         if (IS_ERR(ses)) {
3259                 tcon = (struct cifsTconInfo *)ses;
3260                 cifs_put_tcp_session(master_tcon->ses->server);
3261                 goto out;
3262         }
3263
3264         tcon = cifs_get_tcon(ses, vol_info);
3265         if (IS_ERR(tcon)) {
3266                 cifs_put_smb_ses(ses);
3267                 goto out;
3268         }
3269
3270         if (ses->capabilities & CAP_UNIX)
3271                 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3272 out:
3273         kfree(vol_info);
3274
3275         return tcon;
3276 }
3277
3278 static inline struct tcon_link *
3279 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
3280 {
3281         return cifs_sb->master_tlink;
3282 }
3283
3284 struct cifsTconInfo *
3285 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3286 {
3287         return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3288 }
3289
3290 static int
3291 cifs_sb_tcon_pending_wait(void *unused)
3292 {
3293         schedule();
3294         return signal_pending(current) ? -ERESTARTSYS : 0;
3295 }
3296
3297 /* find and return a tlink with given uid */
3298 static struct tcon_link *
3299 tlink_rb_search(struct rb_root *root, uid_t uid)
3300 {
3301         struct rb_node *node = root->rb_node;
3302         struct tcon_link *tlink;
3303
3304         while (node) {
3305                 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3306
3307                 if (tlink->tl_uid > uid)
3308                         node = node->rb_left;
3309                 else if (tlink->tl_uid < uid)
3310                         node = node->rb_right;
3311                 else
3312                         return tlink;
3313         }
3314         return NULL;
3315 }
3316
3317 /* insert a tcon_link into the tree */
3318 static void
3319 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3320 {
3321         struct rb_node **new = &(root->rb_node), *parent = NULL;
3322         struct tcon_link *tlink;
3323
3324         while (*new) {
3325                 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3326                 parent = *new;
3327
3328                 if (tlink->tl_uid > new_tlink->tl_uid)
3329                         new = &((*new)->rb_left);
3330                 else
3331                         new = &((*new)->rb_right);
3332         }
3333
3334         rb_link_node(&new_tlink->tl_rbnode, parent, new);
3335         rb_insert_color(&new_tlink->tl_rbnode, root);
3336 }
3337
3338 /*
3339  * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3340  * current task.
3341  *
3342  * If the superblock doesn't refer to a multiuser mount, then just return
3343  * the master tcon for the mount.
3344  *
3345  * First, search the rbtree for an existing tcon for this fsuid. If one
3346  * exists, then check to see if it's pending construction. If it is then wait
3347  * for construction to complete. Once it's no longer pending, check to see if
3348  * it failed and either return an error or retry construction, depending on
3349  * the timeout.
3350  *
3351  * If one doesn't exist then insert a new tcon_link struct into the tree and
3352  * try to construct a new one.
3353  */
3354 struct tcon_link *
3355 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3356 {
3357         int ret;
3358         uid_t fsuid = current_fsuid();
3359         struct tcon_link *tlink, *newtlink;
3360
3361         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3362                 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3363
3364         spin_lock(&cifs_sb->tlink_tree_lock);
3365         tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3366         if (tlink)
3367                 cifs_get_tlink(tlink);
3368         spin_unlock(&cifs_sb->tlink_tree_lock);
3369
3370         if (tlink == NULL) {
3371                 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3372                 if (newtlink == NULL)
3373                         return ERR_PTR(-ENOMEM);
3374                 newtlink->tl_uid = fsuid;
3375                 newtlink->tl_tcon = ERR_PTR(-EACCES);
3376                 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3377                 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3378                 cifs_get_tlink(newtlink);
3379
3380                 spin_lock(&cifs_sb->tlink_tree_lock);
3381                 /* was one inserted after previous search? */
3382                 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3383                 if (tlink) {
3384                         cifs_get_tlink(tlink);
3385                         spin_unlock(&cifs_sb->tlink_tree_lock);
3386                         kfree(newtlink);
3387                         goto wait_for_construction;
3388                 }
3389                 tlink = newtlink;
3390                 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3391                 spin_unlock(&cifs_sb->tlink_tree_lock);
3392         } else {
3393 wait_for_construction:
3394                 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3395                                   cifs_sb_tcon_pending_wait,
3396                                   TASK_INTERRUPTIBLE);
3397                 if (ret) {
3398                         cifs_put_tlink(tlink);
3399                         return ERR_PTR(ret);
3400                 }
3401
3402                 /* if it's good, return it */
3403                 if (!IS_ERR(tlink->tl_tcon))
3404                         return tlink;
3405
3406                 /* return error if we tried this already recently */
3407                 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3408                         cifs_put_tlink(tlink);
3409                         return ERR_PTR(-EACCES);
3410                 }
3411
3412                 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3413                         goto wait_for_construction;
3414         }
3415
3416         tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3417         clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3418         wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3419
3420         if (IS_ERR(tlink->tl_tcon)) {
3421                 cifs_put_tlink(tlink);
3422                 return ERR_PTR(-EACCES);
3423         }
3424
3425         return tlink;
3426 }
3427
3428 /*
3429  * periodic workqueue job that scans tcon_tree for a superblock and closes
3430  * out tcons.
3431  */
3432 static void
3433 cifs_prune_tlinks(struct work_struct *work)
3434 {
3435         struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3436                                                     prune_tlinks.work);
3437         struct rb_root *root = &cifs_sb->tlink_tree;
3438         struct rb_node *node = rb_first(root);
3439         struct rb_node *tmp;
3440         struct tcon_link *tlink;
3441
3442         /*
3443          * Because we drop the spinlock in the loop in order to put the tlink
3444          * it's not guarded against removal of links from the tree. The only
3445          * places that remove entries from the tree are this function and
3446          * umounts. Because this function is non-reentrant and is canceled
3447          * before umount can proceed, this is safe.
3448          */
3449         spin_lock(&cifs_sb->tlink_tree_lock);
3450         node = rb_first(root);
3451         while (node != NULL) {
3452                 tmp = node;
3453                 node = rb_next(tmp);
3454                 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3455
3456                 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3457                     atomic_read(&tlink->tl_count) != 0 ||
3458                     time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3459                         continue;
3460
3461                 cifs_get_tlink(tlink);
3462                 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3463                 rb_erase(tmp, root);
3464
3465                 spin_unlock(&cifs_sb->tlink_tree_lock);
3466                 cifs_put_tlink(tlink);
3467                 spin_lock(&cifs_sb->tlink_tree_lock);
3468         }
3469         spin_unlock(&cifs_sb->tlink_tree_lock);
3470
3471         queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3472                                 TLINK_IDLE_EXPIRE);
3473 }