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