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