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