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