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