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                                         strlen(volume_info->UNCip),
1547                                         volume_info->port);
1548                 if (!rc) {
1549                         /* we failed translating address */
1550                         rc = -EINVAL;
1551                         goto out_err;
1552                 }
1553         } else if (volume_info->UNCip) {
1554                 /* BB using ip addr as tcp_ses name to connect to the
1555                    DFS root below */
1556                 cERROR(1, "Connecting to DFS root not implemented yet");
1557                 rc = -EINVAL;
1558                 goto out_err;
1559         } else /* which tcp_sess DFS root would we conect to */ {
1560                 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1561                         "unc=//192.168.1.100/public) specified");
1562                 rc = -EINVAL;
1563                 goto out_err;
1564         }
1565
1566         /* see if we already have a matching tcp_ses */
1567         tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
1568         if (tcp_ses)
1569                 return tcp_ses;
1570
1571         tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1572         if (!tcp_ses) {
1573                 rc = -ENOMEM;
1574                 goto out_err;
1575         }
1576
1577         tcp_ses->hostname = extract_hostname(volume_info->UNC);
1578         if (IS_ERR(tcp_ses->hostname)) {
1579                 rc = PTR_ERR(tcp_ses->hostname);
1580                 goto out_err;
1581         }
1582
1583         tcp_ses->noblocksnd = volume_info->noblocksnd;
1584         tcp_ses->noautotune = volume_info->noautotune;
1585         tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
1586         atomic_set(&tcp_ses->inFlight, 0);
1587         init_waitqueue_head(&tcp_ses->response_q);
1588         init_waitqueue_head(&tcp_ses->request_q);
1589         INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1590         mutex_init(&tcp_ses->srv_mutex);
1591         memcpy(tcp_ses->workstation_RFC1001_name,
1592                 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1593         memcpy(tcp_ses->server_RFC1001_name,
1594                 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1595         tcp_ses->sequence_number = 0;
1596         INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1597         INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1598
1599         /*
1600          * at this point we are the only ones with the pointer
1601          * to the struct since the kernel thread not created yet
1602          * no need to spinlock this init of tcpStatus or srv_count
1603          */
1604         tcp_ses->tcpStatus = CifsNew;
1605         ++tcp_ses->srv_count;
1606
1607         if (addr.ss_family == AF_INET6) {
1608                 cFYI(1, "attempting ipv6 connect");
1609                 /* BB should we allow ipv6 on port 139? */
1610                 /* other OS never observed in Wild doing 139 with v6 */
1611                 memcpy(&tcp_ses->addr.sockAddr6, sin_server6,
1612                         sizeof(struct sockaddr_in6));
1613                 rc = ipv6_connect(tcp_ses);
1614         } else {
1615                 memcpy(&tcp_ses->addr.sockAddr, sin_server,
1616                         sizeof(struct sockaddr_in));
1617                 rc = ipv4_connect(tcp_ses);
1618         }
1619         if (rc < 0) {
1620                 cERROR(1, "Error connecting to socket. Aborting operation");
1621                 goto out_err;
1622         }
1623
1624         /*
1625          * since we're in a cifs function already, we know that
1626          * this will succeed. No need for try_module_get().
1627          */
1628         __module_get(THIS_MODULE);
1629         tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1630                                   tcp_ses, "cifsd");
1631         if (IS_ERR(tcp_ses->tsk)) {
1632                 rc = PTR_ERR(tcp_ses->tsk);
1633                 cERROR(1, "error %d create cifsd thread", rc);
1634                 module_put(THIS_MODULE);
1635                 goto out_err;
1636         }
1637
1638         /* thread spawned, put it on the list */
1639         write_lock(&cifs_tcp_ses_lock);
1640         list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1641         write_unlock(&cifs_tcp_ses_lock);
1642
1643         cifs_fscache_get_client_cookie(tcp_ses);
1644
1645         return tcp_ses;
1646
1647 out_err:
1648         if (tcp_ses) {
1649                 if (!IS_ERR(tcp_ses->hostname))
1650                         kfree(tcp_ses->hostname);
1651                 if (tcp_ses->ssocket)
1652                         sock_release(tcp_ses->ssocket);
1653                 kfree(tcp_ses);
1654         }
1655         return ERR_PTR(rc);
1656 }
1657
1658 static struct cifsSesInfo *
1659 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1660 {
1661         struct cifsSesInfo *ses;
1662
1663         write_lock(&cifs_tcp_ses_lock);
1664         list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1665                 switch (server->secType) {
1666                 case Kerberos:
1667                         if (vol->cred_uid != ses->cred_uid)
1668                                 continue;
1669                         break;
1670                 default:
1671                         /* anything else takes username/password */
1672                         if (strncmp(ses->userName, vol->username,
1673                                     MAX_USERNAME_SIZE))
1674                                 continue;
1675                         if (strlen(vol->username) != 0 &&
1676                             strncmp(ses->password, vol->password,
1677                                     MAX_PASSWORD_SIZE))
1678                                 continue;
1679                 }
1680                 ++ses->ses_count;
1681                 write_unlock(&cifs_tcp_ses_lock);
1682                 return ses;
1683         }
1684         write_unlock(&cifs_tcp_ses_lock);
1685         return NULL;
1686 }
1687
1688 static void
1689 cifs_put_smb_ses(struct cifsSesInfo *ses)
1690 {
1691         int xid;
1692         struct TCP_Server_Info *server = ses->server;
1693
1694         cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
1695         write_lock(&cifs_tcp_ses_lock);
1696         if (--ses->ses_count > 0) {
1697                 write_unlock(&cifs_tcp_ses_lock);
1698                 return;
1699         }
1700
1701         list_del_init(&ses->smb_ses_list);
1702         write_unlock(&cifs_tcp_ses_lock);
1703
1704         if (ses->status == CifsGood) {
1705                 xid = GetXid();
1706                 CIFSSMBLogoff(xid, ses);
1707                 _FreeXid(xid);
1708         }
1709         sesInfoFree(ses);
1710         cifs_put_tcp_session(server);
1711 }
1712
1713 static struct cifsSesInfo *
1714 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1715 {
1716         int rc = -ENOMEM, xid;
1717         struct cifsSesInfo *ses;
1718
1719         xid = GetXid();
1720
1721         ses = cifs_find_smb_ses(server, volume_info);
1722         if (ses) {
1723                 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1724
1725                 /* existing SMB ses has a server reference already */
1726                 cifs_put_tcp_session(server);
1727
1728                 mutex_lock(&ses->session_mutex);
1729                 rc = cifs_negotiate_protocol(xid, ses);
1730                 if (rc) {
1731                         mutex_unlock(&ses->session_mutex);
1732                         /* problem -- put our ses reference */
1733                         cifs_put_smb_ses(ses);
1734                         FreeXid(xid);
1735                         return ERR_PTR(rc);
1736                 }
1737                 if (ses->need_reconnect) {
1738                         cFYI(1, "Session needs reconnect");
1739                         rc = cifs_setup_session(xid, ses,
1740                                                 volume_info->local_nls);
1741                         if (rc) {
1742                                 mutex_unlock(&ses->session_mutex);
1743                                 /* problem -- put our reference */
1744                                 cifs_put_smb_ses(ses);
1745                                 FreeXid(xid);
1746                                 return ERR_PTR(rc);
1747                         }
1748                 }
1749                 mutex_unlock(&ses->session_mutex);
1750                 FreeXid(xid);
1751                 return ses;
1752         }
1753
1754         cFYI(1, "Existing smb sess not found");
1755         ses = sesInfoAlloc();
1756         if (ses == NULL)
1757                 goto get_ses_fail;
1758
1759         /* new SMB session uses our server ref */
1760         ses->server = server;
1761         if (server->addr.sockAddr6.sin6_family == AF_INET6)
1762                 sprintf(ses->serverName, "%pI6",
1763                         &server->addr.sockAddr6.sin6_addr);
1764         else
1765                 sprintf(ses->serverName, "%pI4",
1766                         &server->addr.sockAddr.sin_addr.s_addr);
1767
1768         if (volume_info->username)
1769                 strncpy(ses->userName, volume_info->username,
1770                         MAX_USERNAME_SIZE);
1771
1772         /* volume_info->password freed at unmount */
1773         if (volume_info->password) {
1774                 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1775                 if (!ses->password)
1776                         goto get_ses_fail;
1777         }
1778         if (volume_info->domainname) {
1779                 int len = strlen(volume_info->domainname);
1780                 ses->domainName = kmalloc(len + 1, GFP_KERNEL);
1781                 if (ses->domainName)
1782                         strcpy(ses->domainName, volume_info->domainname);
1783         }
1784         ses->cred_uid = volume_info->cred_uid;
1785         ses->linux_uid = volume_info->linux_uid;
1786         ses->overrideSecFlg = volume_info->secFlg;
1787
1788         mutex_lock(&ses->session_mutex);
1789         rc = cifs_negotiate_protocol(xid, ses);
1790         if (!rc)
1791                 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
1792         mutex_unlock(&ses->session_mutex);
1793         if (rc)
1794                 goto get_ses_fail;
1795
1796         /* success, put it on the list */
1797         write_lock(&cifs_tcp_ses_lock);
1798         list_add(&ses->smb_ses_list, &server->smb_ses_list);
1799         write_unlock(&cifs_tcp_ses_lock);
1800
1801         FreeXid(xid);
1802         return ses;
1803
1804 get_ses_fail:
1805         sesInfoFree(ses);
1806         FreeXid(xid);
1807         return ERR_PTR(rc);
1808 }
1809
1810 static struct cifsTconInfo *
1811 cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
1812 {
1813         struct list_head *tmp;
1814         struct cifsTconInfo *tcon;
1815
1816         write_lock(&cifs_tcp_ses_lock);
1817         list_for_each(tmp, &ses->tcon_list) {
1818                 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1819                 if (tcon->tidStatus == CifsExiting)
1820                         continue;
1821                 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
1822                         continue;
1823
1824                 ++tcon->tc_count;
1825                 write_unlock(&cifs_tcp_ses_lock);
1826                 return tcon;
1827         }
1828         write_unlock(&cifs_tcp_ses_lock);
1829         return NULL;
1830 }
1831
1832 static void
1833 cifs_put_tcon(struct cifsTconInfo *tcon)
1834 {
1835         int xid;
1836         struct cifsSesInfo *ses = tcon->ses;
1837
1838         cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
1839         write_lock(&cifs_tcp_ses_lock);
1840         if (--tcon->tc_count > 0) {
1841                 write_unlock(&cifs_tcp_ses_lock);
1842                 return;
1843         }
1844
1845         list_del_init(&tcon->tcon_list);
1846         write_unlock(&cifs_tcp_ses_lock);
1847
1848         xid = GetXid();
1849         CIFSSMBTDis(xid, tcon);
1850         _FreeXid(xid);
1851
1852         cifs_fscache_release_super_cookie(tcon);
1853         tconInfoFree(tcon);
1854         cifs_put_smb_ses(ses);
1855 }
1856
1857 static struct cifsTconInfo *
1858 cifs_get_tcon(struct cifsSesInfo *ses, struct smb_vol *volume_info)
1859 {
1860         int rc, xid;
1861         struct cifsTconInfo *tcon;
1862
1863         tcon = cifs_find_tcon(ses, volume_info->UNC);
1864         if (tcon) {
1865                 cFYI(1, "Found match on UNC path");
1866                 /* existing tcon already has a reference */
1867                 cifs_put_smb_ses(ses);
1868                 if (tcon->seal != volume_info->seal)
1869                         cERROR(1, "transport encryption setting "
1870                                    "conflicts with existing tid");
1871                 return tcon;
1872         }
1873
1874         tcon = tconInfoAlloc();
1875         if (tcon == NULL) {
1876                 rc = -ENOMEM;
1877                 goto out_fail;
1878         }
1879
1880         tcon->ses = ses;
1881         if (volume_info->password) {
1882                 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
1883                 if (!tcon->password) {
1884                         rc = -ENOMEM;
1885                         goto out_fail;
1886                 }
1887         }
1888
1889         if (strchr(volume_info->UNC + 3, '\\') == NULL
1890             && strchr(volume_info->UNC + 3, '/') == NULL) {
1891                 cERROR(1, "Missing share name");
1892                 rc = -ENODEV;
1893                 goto out_fail;
1894         }
1895
1896         /* BB Do we need to wrap session_mutex around
1897          * this TCon call and Unix SetFS as
1898          * we do on SessSetup and reconnect? */
1899         xid = GetXid();
1900         rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
1901         FreeXid(xid);
1902         cFYI(1, "CIFS Tcon rc = %d", rc);
1903         if (rc)
1904                 goto out_fail;
1905
1906         if (volume_info->nodfs) {
1907                 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
1908                 cFYI(1, "DFS disabled (%d)", tcon->Flags);
1909         }
1910         tcon->seal = volume_info->seal;
1911         /* we can have only one retry value for a connection
1912            to a share so for resources mounted more than once
1913            to the same server share the last value passed in
1914            for the retry flag is used */
1915         tcon->retry = volume_info->retry;
1916         tcon->nocase = volume_info->nocase;
1917         tcon->local_lease = volume_info->local_lease;
1918
1919         write_lock(&cifs_tcp_ses_lock);
1920         list_add(&tcon->tcon_list, &ses->tcon_list);
1921         write_unlock(&cifs_tcp_ses_lock);
1922
1923         cifs_fscache_get_super_cookie(tcon);
1924
1925         return tcon;
1926
1927 out_fail:
1928         tconInfoFree(tcon);
1929         return ERR_PTR(rc);
1930 }
1931
1932
1933 int
1934 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1935              const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
1936              struct dfs_info3_param **preferrals, int remap)
1937 {
1938         char *temp_unc;
1939         int rc = 0;
1940
1941         *pnum_referrals = 0;
1942         *preferrals = NULL;
1943
1944         if (pSesInfo->ipc_tid == 0) {
1945                 temp_unc = kmalloc(2 /* for slashes */ +
1946                         strnlen(pSesInfo->serverName,
1947                                 SERVER_NAME_LEN_WITH_NULL * 2)
1948                                  + 1 + 4 /* slash IPC$ */  + 2,
1949                                 GFP_KERNEL);
1950                 if (temp_unc == NULL)
1951                         return -ENOMEM;
1952                 temp_unc[0] = '\\';
1953                 temp_unc[1] = '\\';
1954                 strcpy(temp_unc + 2, pSesInfo->serverName);
1955                 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1956                 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1957                 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
1958                 kfree(temp_unc);
1959         }
1960         if (rc == 0)
1961                 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
1962                                      pnum_referrals, nls_codepage, remap);
1963         /* BB map targetUNCs to dfs_info3 structures, here or
1964                 in CIFSGetDFSRefer BB */
1965
1966         return rc;
1967 }
1968
1969 #ifdef CONFIG_DEBUG_LOCK_ALLOC
1970 static struct lock_class_key cifs_key[2];
1971 static struct lock_class_key cifs_slock_key[2];
1972
1973 static inline void
1974 cifs_reclassify_socket4(struct socket *sock)
1975 {
1976         struct sock *sk = sock->sk;
1977         BUG_ON(sock_owned_by_user(sk));
1978         sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
1979                 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
1980 }
1981
1982 static inline void
1983 cifs_reclassify_socket6(struct socket *sock)
1984 {
1985         struct sock *sk = sock->sk;
1986         BUG_ON(sock_owned_by_user(sk));
1987         sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
1988                 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
1989 }
1990 #else
1991 static inline void
1992 cifs_reclassify_socket4(struct socket *sock)
1993 {
1994 }
1995
1996 static inline void
1997 cifs_reclassify_socket6(struct socket *sock)
1998 {
1999 }
2000 #endif
2001
2002 /* See RFC1001 section 14 on representation of Netbios names */
2003 static void rfc1002mangle(char *target, char *source, unsigned int length)
2004 {
2005         unsigned int i, j;
2006
2007         for (i = 0, j = 0; i < (length); i++) {
2008                 /* mask a nibble at a time and encode */
2009                 target[j] = 'A' + (0x0F & (source[i] >> 4));
2010                 target[j+1] = 'A' + (0x0F & source[i]);
2011                 j += 2;
2012         }
2013
2014 }
2015
2016
2017 static int
2018 ipv4_connect(struct TCP_Server_Info *server)
2019 {
2020         int rc = 0;
2021         int val;
2022         bool connected = false;
2023         __be16 orig_port = 0;
2024         struct socket *socket = server->ssocket;
2025
2026         if (socket == NULL) {
2027                 rc = sock_create_kern(PF_INET, SOCK_STREAM,
2028                                       IPPROTO_TCP, &socket);
2029                 if (rc < 0) {
2030                         cERROR(1, "Error %d creating socket", rc);
2031                         return rc;
2032                 }
2033
2034                 /* BB other socket options to set KEEPALIVE, NODELAY? */
2035                 cFYI(1, "Socket created");
2036                 server->ssocket = socket;
2037                 socket->sk->sk_allocation = GFP_NOFS;
2038                 cifs_reclassify_socket4(socket);
2039         }
2040
2041         /* user overrode default port */
2042         if (server->addr.sockAddr.sin_port) {
2043                 rc = socket->ops->connect(socket, (struct sockaddr *)
2044                                           &server->addr.sockAddr,
2045                                           sizeof(struct sockaddr_in), 0);
2046                 if (rc >= 0)
2047                         connected = true;
2048         }
2049
2050         if (!connected) {
2051                 /* save original port so we can retry user specified port
2052                         later if fall back ports fail this time  */
2053                 orig_port = server->addr.sockAddr.sin_port;
2054
2055                 /* do not retry on the same port we just failed on */
2056                 if (server->addr.sockAddr.sin_port != htons(CIFS_PORT)) {
2057                         server->addr.sockAddr.sin_port = htons(CIFS_PORT);
2058                         rc = socket->ops->connect(socket,
2059                                                 (struct sockaddr *)
2060                                                 &server->addr.sockAddr,
2061                                                 sizeof(struct sockaddr_in), 0);
2062                         if (rc >= 0)
2063                                 connected = true;
2064                 }
2065         }
2066         if (!connected) {
2067                 server->addr.sockAddr.sin_port = htons(RFC1001_PORT);
2068                 rc = socket->ops->connect(socket, (struct sockaddr *)
2069                                               &server->addr.sockAddr,
2070                                               sizeof(struct sockaddr_in), 0);
2071                 if (rc >= 0)
2072                         connected = true;
2073         }
2074
2075         /* give up here - unless we want to retry on different
2076                 protocol families some day */
2077         if (!connected) {
2078                 if (orig_port)
2079                         server->addr.sockAddr.sin_port = orig_port;
2080                 cFYI(1, "Error %d connecting to server via ipv4", rc);
2081                 sock_release(socket);
2082                 server->ssocket = NULL;
2083                 return rc;
2084         }
2085
2086
2087         /*
2088          * Eventually check for other socket options to change from
2089          *  the default. sock_setsockopt not used because it expects
2090          *  user space buffer
2091          */
2092         socket->sk->sk_rcvtimeo = 7 * HZ;
2093         socket->sk->sk_sndtimeo = 5 * HZ;
2094
2095         /* make the bufsizes depend on wsize/rsize and max requests */
2096         if (server->noautotune) {
2097                 if (socket->sk->sk_sndbuf < (200 * 1024))
2098                         socket->sk->sk_sndbuf = 200 * 1024;
2099                 if (socket->sk->sk_rcvbuf < (140 * 1024))
2100                         socket->sk->sk_rcvbuf = 140 * 1024;
2101         }
2102
2103         if (server->tcp_nodelay) {
2104                 val = 1;
2105                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2106                                 (char *)&val, sizeof(val));
2107                 if (rc)
2108                         cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2109         }
2110
2111          cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2112                  socket->sk->sk_sndbuf,
2113                  socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2114
2115         /* send RFC1001 sessinit */
2116         if (server->addr.sockAddr.sin_port == htons(RFC1001_PORT)) {
2117                 /* some servers require RFC1001 sessinit before sending
2118                 negprot - BB check reconnection in case where second
2119                 sessinit is sent but no second negprot */
2120                 struct rfc1002_session_packet *ses_init_buf;
2121                 struct smb_hdr *smb_buf;
2122                 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2123                                        GFP_KERNEL);
2124                 if (ses_init_buf) {
2125                         ses_init_buf->trailer.session_req.called_len = 32;
2126                         if (server->server_RFC1001_name &&
2127                             server->server_RFC1001_name[0] != 0)
2128                                 rfc1002mangle(ses_init_buf->trailer.
2129                                                 session_req.called_name,
2130                                               server->server_RFC1001_name,
2131                                               RFC1001_NAME_LEN_WITH_NULL);
2132                         else
2133                                 rfc1002mangle(ses_init_buf->trailer.
2134                                                 session_req.called_name,
2135                                               DEFAULT_CIFS_CALLED_NAME,
2136                                               RFC1001_NAME_LEN_WITH_NULL);
2137
2138                         ses_init_buf->trailer.session_req.calling_len = 32;
2139
2140                         /* calling name ends in null (byte 16) from old smb
2141                         convention. */
2142                         if (server->workstation_RFC1001_name &&
2143                             server->workstation_RFC1001_name[0] != 0)
2144                                 rfc1002mangle(ses_init_buf->trailer.
2145                                                 session_req.calling_name,
2146                                               server->workstation_RFC1001_name,
2147                                               RFC1001_NAME_LEN_WITH_NULL);
2148                         else
2149                                 rfc1002mangle(ses_init_buf->trailer.
2150                                                 session_req.calling_name,
2151                                               "LINUX_CIFS_CLNT",
2152                                               RFC1001_NAME_LEN_WITH_NULL);
2153
2154                         ses_init_buf->trailer.session_req.scope1 = 0;
2155                         ses_init_buf->trailer.session_req.scope2 = 0;
2156                         smb_buf = (struct smb_hdr *)ses_init_buf;
2157                         /* sizeof RFC1002_SESSION_REQUEST with no scope */
2158                         smb_buf->smb_buf_length = 0x81000044;
2159                         rc = smb_send(server, smb_buf, 0x44);
2160                         kfree(ses_init_buf);
2161                         msleep(1); /* RFC1001 layer in at least one server
2162                                       requires very short break before negprot
2163                                       presumably because not expecting negprot
2164                                       to follow so fast.  This is a simple
2165                                       solution that works without
2166                                       complicating the code and causes no
2167                                       significant slowing down on mount
2168                                       for everyone else */
2169                 }
2170                 /* else the negprot may still work without this
2171                 even though malloc failed */
2172
2173         }
2174
2175         return rc;
2176 }
2177
2178 static int
2179 ipv6_connect(struct TCP_Server_Info *server)
2180 {
2181         int rc = 0;
2182         int val;
2183         bool connected = false;
2184         __be16 orig_port = 0;
2185         struct socket *socket = server->ssocket;
2186
2187         if (socket == NULL) {
2188                 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
2189                                       IPPROTO_TCP, &socket);
2190                 if (rc < 0) {
2191                         cERROR(1, "Error %d creating ipv6 socket", rc);
2192                         socket = NULL;
2193                         return rc;
2194                 }
2195
2196                 /* BB other socket options to set KEEPALIVE, NODELAY? */
2197                 cFYI(1, "ipv6 Socket created");
2198                 server->ssocket = socket;
2199                 socket->sk->sk_allocation = GFP_NOFS;
2200                 cifs_reclassify_socket6(socket);
2201         }
2202
2203         /* user overrode default port */
2204         if (server->addr.sockAddr6.sin6_port) {
2205                 rc = socket->ops->connect(socket,
2206                                 (struct sockaddr *) &server->addr.sockAddr6,
2207                                 sizeof(struct sockaddr_in6), 0);
2208                 if (rc >= 0)
2209                         connected = true;
2210         }
2211
2212         if (!connected) {
2213                 /* save original port so we can retry user specified port
2214                         later if fall back ports fail this time  */
2215
2216                 orig_port = server->addr.sockAddr6.sin6_port;
2217                 /* do not retry on the same port we just failed on */
2218                 if (server->addr.sockAddr6.sin6_port != htons(CIFS_PORT)) {
2219                         server->addr.sockAddr6.sin6_port = htons(CIFS_PORT);
2220                         rc = socket->ops->connect(socket, (struct sockaddr *)
2221                                         &server->addr.sockAddr6,
2222                                         sizeof(struct sockaddr_in6), 0);
2223                         if (rc >= 0)
2224                                 connected = true;
2225                 }
2226         }
2227         if (!connected) {
2228                 server->addr.sockAddr6.sin6_port = htons(RFC1001_PORT);
2229                 rc = socket->ops->connect(socket, (struct sockaddr *)
2230                                 &server->addr.sockAddr6,
2231                                 sizeof(struct sockaddr_in6), 0);
2232                 if (rc >= 0)
2233                         connected = true;
2234         }
2235
2236         /* give up here - unless we want to retry on different
2237                 protocol families some day */
2238         if (!connected) {
2239                 if (orig_port)
2240                         server->addr.sockAddr6.sin6_port = orig_port;
2241                 cFYI(1, "Error %d connecting to server via ipv6", rc);
2242                 sock_release(socket);
2243                 server->ssocket = NULL;
2244                 return rc;
2245         }
2246
2247         /*
2248          * Eventually check for other socket options to change from
2249          * the default. sock_setsockopt not used because it expects
2250          * user space buffer
2251          */
2252         socket->sk->sk_rcvtimeo = 7 * HZ;
2253         socket->sk->sk_sndtimeo = 5 * HZ;
2254
2255         if (server->tcp_nodelay) {
2256                 val = 1;
2257                 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2258                                 (char *)&val, sizeof(val));
2259                 if (rc)
2260                         cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2261         }
2262
2263         server->ssocket = socket;
2264
2265         return rc;
2266 }
2267
2268 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
2269                           struct super_block *sb, struct smb_vol *vol_info)
2270 {
2271         /* if we are reconnecting then should we check to see if
2272          * any requested capabilities changed locally e.g. via
2273          * remount but we can not do much about it here
2274          * if they have (even if we could detect it by the following)
2275          * Perhaps we could add a backpointer to array of sb from tcon
2276          * or if we change to make all sb to same share the same
2277          * sb as NFS - then we only have one backpointer to sb.
2278          * What if we wanted to mount the server share twice once with
2279          * and once without posixacls or posix paths? */
2280         __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2281
2282         if (vol_info && vol_info->no_linux_ext) {
2283                 tcon->fsUnixInfo.Capability = 0;
2284                 tcon->unix_ext = 0; /* Unix Extensions disabled */
2285                 cFYI(1, "Linux protocol extensions disabled");
2286                 return;
2287         } else if (vol_info)
2288                 tcon->unix_ext = 1; /* Unix Extensions supported */
2289
2290         if (tcon->unix_ext == 0) {
2291                 cFYI(1, "Unix extensions disabled so not set on reconnect");
2292                 return;
2293         }
2294
2295         if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2296                 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2297
2298                 /* check for reconnect case in which we do not
2299                    want to change the mount behavior if we can avoid it */
2300                 if (vol_info == NULL) {
2301                         /* turn off POSIX ACL and PATHNAMES if not set
2302                            originally at mount time */
2303                         if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2304                                 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2305                         if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2306                                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2307                                         cERROR(1, "POSIXPATH support change");
2308                                 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2309                         } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2310                                 cERROR(1, "possible reconnect error");
2311                                 cERROR(1, "server disabled POSIX path support");
2312                         }
2313                 }
2314
2315                 cap &= CIFS_UNIX_CAP_MASK;
2316                 if (vol_info && vol_info->no_psx_acl)
2317                         cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2318                 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2319                         cFYI(1, "negotiated posix acl support");
2320                         if (sb)
2321                                 sb->s_flags |= MS_POSIXACL;
2322                 }
2323
2324                 if (vol_info && vol_info->posix_paths == 0)
2325                         cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2326                 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2327                         cFYI(1, "negotiate posix pathnames");
2328                         if (sb)
2329                                 CIFS_SB(sb)->mnt_cifs_flags |=
2330                                         CIFS_MOUNT_POSIX_PATHS;
2331                 }
2332
2333                 /* We might be setting the path sep back to a different
2334                 form if we are reconnecting and the server switched its
2335                 posix path capability for this share */
2336                 if (sb && (CIFS_SB(sb)->prepathlen > 0))
2337                         CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
2338
2339                 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2340                         if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2341                                 CIFS_SB(sb)->rsize = 127 * 1024;
2342                                 cFYI(DBG2, "larger reads not supported by srv");
2343                         }
2344                 }
2345
2346
2347                 cFYI(1, "Negotiate caps 0x%x", (int)cap);
2348 #ifdef CONFIG_CIFS_DEBUG2
2349                 if (cap & CIFS_UNIX_FCNTL_CAP)
2350                         cFYI(1, "FCNTL cap");
2351                 if (cap & CIFS_UNIX_EXTATTR_CAP)
2352                         cFYI(1, "EXTATTR cap");
2353                 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2354                         cFYI(1, "POSIX path cap");
2355                 if (cap & CIFS_UNIX_XATTR_CAP)
2356                         cFYI(1, "XATTR cap");
2357                 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2358                         cFYI(1, "POSIX ACL cap");
2359                 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2360                         cFYI(1, "very large read cap");
2361                 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2362                         cFYI(1, "very large write cap");
2363 #endif /* CIFS_DEBUG2 */
2364                 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2365                         if (vol_info == NULL) {
2366                                 cFYI(1, "resetting capabilities failed");
2367                         } else
2368                                 cERROR(1, "Negotiating Unix capabilities "
2369                                            "with the server failed.  Consider "
2370                                            "mounting with the Unix Extensions\n"
2371                                            "disabled, if problems are found, "
2372                                            "by specifying the nounix mount "
2373                                            "option.");
2374
2375                 }
2376         }
2377 }
2378
2379 static void
2380 convert_delimiter(char *path, char delim)
2381 {
2382         int i;
2383         char old_delim;
2384
2385         if (path == NULL)
2386                 return;
2387
2388         if (delim == '/')
2389                 old_delim = '\\';
2390         else
2391                 old_delim = '/';
2392
2393         for (i = 0; path[i] != '\0'; i++) {
2394                 if (path[i] == old_delim)
2395                         path[i] = delim;
2396         }
2397 }
2398
2399 static void setup_cifs_sb(struct smb_vol *pvolume_info,
2400                           struct cifs_sb_info *cifs_sb)
2401 {
2402         if (pvolume_info->rsize > CIFSMaxBufSize) {
2403                 cERROR(1, "rsize %d too large, using MaxBufSize",
2404                         pvolume_info->rsize);
2405                 cifs_sb->rsize = CIFSMaxBufSize;
2406         } else if ((pvolume_info->rsize) &&
2407                         (pvolume_info->rsize <= CIFSMaxBufSize))
2408                 cifs_sb->rsize = pvolume_info->rsize;
2409         else /* default */
2410                 cifs_sb->rsize = CIFSMaxBufSize;
2411
2412         if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2413                 cERROR(1, "wsize %d too large, using 4096 instead",
2414                           pvolume_info->wsize);
2415                 cifs_sb->wsize = 4096;
2416         } else if (pvolume_info->wsize)
2417                 cifs_sb->wsize = pvolume_info->wsize;
2418         else
2419                 cifs_sb->wsize = min_t(const int,
2420                                         PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2421                                         127*1024);
2422                 /* old default of CIFSMaxBufSize was too small now
2423                    that SMB Write2 can send multiple pages in kvec.
2424                    RFC1001 does not describe what happens when frame
2425                    bigger than 128K is sent so use that as max in
2426                    conjunction with 52K kvec constraint on arch with 4K
2427                    page size  */
2428
2429         if (cifs_sb->rsize < 2048) {
2430                 cifs_sb->rsize = 2048;
2431                 /* Windows ME may prefer this */
2432                 cFYI(1, "readsize set to minimum: 2048");
2433         }
2434         /* calculate prepath */
2435         cifs_sb->prepath = pvolume_info->prepath;
2436         if (cifs_sb->prepath) {
2437                 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2438                 /* we can not convert the / to \ in the path
2439                 separators in the prefixpath yet because we do not
2440                 know (until reset_cifs_unix_caps is called later)
2441                 whether POSIX PATH CAP is available. We normalize
2442                 the / to \ after reset_cifs_unix_caps is called */
2443                 pvolume_info->prepath = NULL;
2444         } else
2445                 cifs_sb->prepathlen = 0;
2446         cifs_sb->mnt_uid = pvolume_info->linux_uid;
2447         cifs_sb->mnt_gid = pvolume_info->linux_gid;
2448         cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2449         cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2450         cFYI(1, "file mode: 0x%x  dir mode: 0x%x",
2451                 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
2452
2453         if (pvolume_info->noperm)
2454                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2455         if (pvolume_info->setuids)
2456                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2457         if (pvolume_info->server_ino)
2458                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2459         if (pvolume_info->remap)
2460                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2461         if (pvolume_info->no_xattr)
2462                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2463         if (pvolume_info->sfu_emul)
2464                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2465         if (pvolume_info->nobrl)
2466                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2467         if (pvolume_info->nostrictsync)
2468                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2469         if (pvolume_info->mand_lock)
2470                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2471         if (pvolume_info->cifs_acl)
2472                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2473         if (pvolume_info->override_uid)
2474                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2475         if (pvolume_info->override_gid)
2476                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2477         if (pvolume_info->dynperm)
2478                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2479         if (pvolume_info->fsc)
2480                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
2481         if (pvolume_info->direct_io) {
2482                 cFYI(1, "mounting share using direct i/o");
2483                 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2484         }
2485
2486         if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2487                 cERROR(1, "mount option dynperm ignored if cifsacl "
2488                            "mount option supported");
2489 }
2490
2491 static int
2492 is_path_accessible(int xid, struct cifsTconInfo *tcon,
2493                    struct cifs_sb_info *cifs_sb, const char *full_path)
2494 {
2495         int rc;
2496         FILE_ALL_INFO *pfile_info;
2497
2498         pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2499         if (pfile_info == NULL)
2500                 return -ENOMEM;
2501
2502         rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2503                               0 /* not legacy */, cifs_sb->local_nls,
2504                               cifs_sb->mnt_cifs_flags &
2505                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
2506         kfree(pfile_info);
2507         return rc;
2508 }
2509
2510 static void
2511 cleanup_volume_info(struct smb_vol **pvolume_info)
2512 {
2513         struct smb_vol *volume_info;
2514
2515         if (!pvolume_info || !*pvolume_info)
2516                 return;
2517
2518         volume_info = *pvolume_info;
2519         kzfree(volume_info->password);
2520         kfree(volume_info->UNC);
2521         kfree(volume_info->prepath);
2522         kfree(volume_info);
2523         *pvolume_info = NULL;
2524         return;
2525 }
2526
2527 #ifdef CONFIG_CIFS_DFS_UPCALL
2528 /* build_path_to_root returns full path to root when
2529  * we do not have an exiting connection (tcon) */
2530 static char *
2531 build_unc_path_to_root(const struct smb_vol *volume_info,
2532                 const struct cifs_sb_info *cifs_sb)
2533 {
2534         char *full_path;
2535
2536         int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2537         full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2538         if (full_path == NULL)
2539                 return ERR_PTR(-ENOMEM);
2540
2541         strncpy(full_path, volume_info->UNC, unc_len);
2542         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2543                 int i;
2544                 for (i = 0; i < unc_len; i++) {
2545                         if (full_path[i] == '\\')
2546                                 full_path[i] = '/';
2547                 }
2548         }
2549
2550         if (cifs_sb->prepathlen)
2551                 strncpy(full_path + unc_len, cifs_sb->prepath,
2552                                 cifs_sb->prepathlen);
2553
2554         full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2555         return full_path;
2556 }
2557 #endif
2558
2559 int
2560 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
2561                 char *mount_data_global, const char *devname)
2562 {
2563         int rc;
2564         int xid;
2565         struct smb_vol *volume_info;
2566         struct cifsSesInfo *pSesInfo;
2567         struct cifsTconInfo *tcon;
2568         struct TCP_Server_Info *srvTcp;
2569         char   *full_path;
2570         char *mount_data = mount_data_global;
2571 #ifdef CONFIG_CIFS_DFS_UPCALL
2572         struct dfs_info3_param *referrals = NULL;
2573         unsigned int num_referrals = 0;
2574         int referral_walks_count = 0;
2575 try_mount_again:
2576 #endif
2577         rc = 0;
2578         tcon = NULL;
2579         pSesInfo = NULL;
2580         srvTcp = NULL;
2581         full_path = NULL;
2582
2583         xid = GetXid();
2584
2585         volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2586         if (!volume_info) {
2587                 rc = -ENOMEM;
2588                 goto out;
2589         }
2590
2591         if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
2592                 rc = -EINVAL;
2593                 goto out;
2594         }
2595
2596         if (volume_info->nullauth) {
2597                 cFYI(1, "null user");
2598                 volume_info->username = "";
2599         } else if (volume_info->username) {
2600                 /* BB fixme parse for domain name here */
2601                 cFYI(1, "Username: %s", volume_info->username);
2602         } else {
2603                 cifserror("No username specified");
2604         /* In userspace mount helper we can get user name from alternate
2605            locations such as env variables and files on disk */
2606                 rc = -EINVAL;
2607                 goto out;
2608         }
2609
2610         /* this is needed for ASCII cp to Unicode converts */
2611         if (volume_info->iocharset == NULL) {
2612                 /* load_nls_default cannot return null */
2613                 volume_info->local_nls = load_nls_default();
2614         } else {
2615                 volume_info->local_nls = load_nls(volume_info->iocharset);
2616                 if (volume_info->local_nls == NULL) {
2617                         cERROR(1, "CIFS mount error: iocharset %s not found",
2618                                  volume_info->iocharset);
2619                         rc = -ELIBACC;
2620                         goto out;
2621                 }
2622         }
2623         cifs_sb->local_nls = volume_info->local_nls;
2624
2625         /* get a reference to a tcp session */
2626         srvTcp = cifs_get_tcp_session(volume_info);
2627         if (IS_ERR(srvTcp)) {
2628                 rc = PTR_ERR(srvTcp);
2629                 goto out;
2630         }
2631
2632         /* get a reference to a SMB session */
2633         pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
2634         if (IS_ERR(pSesInfo)) {
2635                 rc = PTR_ERR(pSesInfo);
2636                 pSesInfo = NULL;
2637                 goto mount_fail_check;
2638         }
2639
2640         setup_cifs_sb(volume_info, cifs_sb);
2641         if (pSesInfo->capabilities & CAP_LARGE_FILES)
2642                 sb->s_maxbytes = MAX_LFS_FILESIZE;
2643         else
2644                 sb->s_maxbytes = MAX_NON_LFS;
2645
2646         /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2647         sb->s_time_gran = 100;
2648
2649         /* search for existing tcon to this server share */
2650         tcon = cifs_get_tcon(pSesInfo, volume_info);
2651         if (IS_ERR(tcon)) {
2652                 rc = PTR_ERR(tcon);
2653                 tcon = NULL;
2654                 goto remote_path_check;
2655         }
2656
2657         cifs_sb->tcon = tcon;
2658
2659         /* do not care if following two calls succeed - informational */
2660         if (!tcon->ipc) {
2661                 CIFSSMBQFSDeviceInfo(xid, tcon);
2662                 CIFSSMBQFSAttributeInfo(xid, tcon);
2663         }
2664
2665         /* tell server which Unix caps we support */
2666         if (tcon->ses->capabilities & CAP_UNIX)
2667                 /* reset of caps checks mount to see if unix extensions
2668                    disabled for just this mount */
2669                 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
2670         else
2671                 tcon->unix_ext = 0; /* server does not support them */
2672
2673         /* convert forward to back slashes in prepath here if needed */
2674         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2675                 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2676
2677         if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2678                 cifs_sb->rsize = 1024 * 127;
2679                 cFYI(DBG2, "no very large read support, rsize now 127K");
2680         }
2681         if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2682                 cifs_sb->wsize = min(cifs_sb->wsize,
2683                                (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2684         if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2685                 cifs_sb->rsize = min(cifs_sb->rsize,
2686                                (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2687
2688 remote_path_check:
2689         /* check if a whole path (including prepath) is not remote */
2690         if (!rc && cifs_sb->prepathlen && tcon) {
2691                 /* build_path_to_root works only when we have a valid tcon */
2692                 full_path = cifs_build_path_to_root(cifs_sb);
2693                 if (full_path == NULL) {
2694                         rc = -ENOMEM;
2695                         goto mount_fail_check;
2696                 }
2697                 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
2698                 if (rc != -EREMOTE) {
2699                         kfree(full_path);
2700                         goto mount_fail_check;
2701                 }
2702                 kfree(full_path);
2703         }
2704
2705         /* get referral if needed */
2706         if (rc == -EREMOTE) {
2707 #ifdef CONFIG_CIFS_DFS_UPCALL
2708                 if (referral_walks_count > MAX_NESTED_LINKS) {
2709                         /*
2710                          * BB: when we implement proper loop detection,
2711                          *     we will remove this check. But now we need it
2712                          *     to prevent an indefinite loop if 'DFS tree' is
2713                          *     misconfigured (i.e. has loops).
2714                          */
2715                         rc = -ELOOP;
2716                         goto mount_fail_check;
2717                 }
2718                 /* convert forward to back slashes in prepath here if needed */
2719                 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2720                         convert_delimiter(cifs_sb->prepath,
2721                                         CIFS_DIR_SEP(cifs_sb));
2722                 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2723                 if (IS_ERR(full_path)) {
2724                         rc = PTR_ERR(full_path);
2725                         goto mount_fail_check;
2726                 }
2727
2728                 cFYI(1, "Getting referral for: %s", full_path);
2729                 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2730                         cifs_sb->local_nls, &num_referrals, &referrals,
2731                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2732                 if (!rc && num_referrals > 0) {
2733                         char *fake_devname = NULL;
2734
2735                         if (mount_data != mount_data_global)
2736                                 kfree(mount_data);
2737
2738                         mount_data = cifs_compose_mount_options(
2739                                         cifs_sb->mountdata, full_path + 1,
2740                                         referrals, &fake_devname);
2741
2742                         free_dfs_info_array(referrals, num_referrals);
2743                         kfree(fake_devname);
2744                         kfree(full_path);
2745
2746                         if (IS_ERR(mount_data)) {
2747                                 rc = PTR_ERR(mount_data);
2748                                 mount_data = NULL;
2749                                 goto mount_fail_check;
2750                         }
2751
2752                         if (tcon)
2753                                 cifs_put_tcon(tcon);
2754                         else if (pSesInfo)
2755                                 cifs_put_smb_ses(pSesInfo);
2756
2757                         cleanup_volume_info(&volume_info);
2758                         referral_walks_count++;
2759                         FreeXid(xid);
2760                         goto try_mount_again;
2761                 }
2762 #else /* No DFS support, return error on mount */
2763                 rc = -EOPNOTSUPP;
2764 #endif
2765         }
2766
2767 mount_fail_check:
2768         /* on error free sesinfo and tcon struct if needed */
2769         if (rc) {
2770                 if (mount_data != mount_data_global)
2771                         kfree(mount_data);
2772                 /* If find_unc succeeded then rc == 0 so we can not end */
2773                 /* up accidently freeing someone elses tcon struct */
2774                 if (tcon)
2775                         cifs_put_tcon(tcon);
2776                 else if (pSesInfo)
2777                         cifs_put_smb_ses(pSesInfo);
2778                 else
2779                         cifs_put_tcp_session(srvTcp);
2780                 goto out;
2781         }
2782
2783         /* volume_info->password is freed above when existing session found
2784         (in which case it is not needed anymore) but when new sesion is created
2785         the password ptr is put in the new session structure (in which case the
2786         password will be freed at unmount time) */
2787 out:
2788         /* zero out password before freeing */
2789         cleanup_volume_info(&volume_info);
2790         FreeXid(xid);
2791         return rc;
2792 }
2793
2794 int
2795 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
2796          const char *tree, struct cifsTconInfo *tcon,
2797          const struct nls_table *nls_codepage)
2798 {
2799         struct smb_hdr *smb_buffer;
2800         struct smb_hdr *smb_buffer_response;
2801         TCONX_REQ *pSMB;
2802         TCONX_RSP *pSMBr;
2803         unsigned char *bcc_ptr;
2804         int rc = 0;
2805         int length, bytes_left;
2806         __u16 count;
2807
2808         if (ses == NULL)
2809                 return -EIO;
2810
2811         smb_buffer = cifs_buf_get();
2812         if (smb_buffer == NULL)
2813                 return -ENOMEM;
2814
2815         smb_buffer_response = smb_buffer;
2816
2817         header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
2818                         NULL /*no tid */ , 4 /*wct */ );
2819
2820         smb_buffer->Mid = GetNextMid(ses->server);
2821         smb_buffer->Uid = ses->Suid;
2822         pSMB = (TCONX_REQ *) smb_buffer;
2823         pSMBr = (TCONX_RSP *) smb_buffer_response;
2824
2825         pSMB->AndXCommand = 0xFF;
2826         pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
2827         bcc_ptr = &pSMB->Password[0];
2828         if ((ses->server->secMode) & SECMODE_USER) {
2829                 pSMB->PasswordLength = cpu_to_le16(1);  /* minimum */
2830                 *bcc_ptr = 0; /* password is null byte */
2831                 bcc_ptr++;              /* skip password */
2832                 /* already aligned so no need to do it below */
2833         } else {
2834                 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
2835                 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
2836                    specified as required (when that support is added to
2837                    the vfs in the future) as only NTLM or the much
2838                    weaker LANMAN (which we do not send by default) is accepted
2839                    by Samba (not sure whether other servers allow
2840                    NTLMv2 password here) */
2841 #ifdef CONFIG_CIFS_WEAK_PW_HASH
2842                 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
2843                     (ses->server->secType == LANMAN))
2844                         calc_lanman_hash(tcon->password, ses->server->cryptKey,
2845                                          ses->server->secMode &
2846                                             SECMODE_PW_ENCRYPT ? true : false,
2847                                          bcc_ptr);
2848                 else
2849 #endif /* CIFS_WEAK_PW_HASH */
2850                 SMBNTencrypt(tcon->password, ses->server->cryptKey,
2851                              bcc_ptr);
2852
2853                 bcc_ptr += CIFS_SESS_KEY_SIZE;
2854                 if (ses->capabilities & CAP_UNICODE) {
2855                         /* must align unicode strings */
2856                         *bcc_ptr = 0; /* null byte password */
2857                         bcc_ptr++;
2858                 }
2859         }
2860
2861         if (ses->server->secMode &
2862                         (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2863                 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2864
2865         if (ses->capabilities & CAP_STATUS32) {
2866                 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2867         }
2868         if (ses->capabilities & CAP_DFS) {
2869                 smb_buffer->Flags2 |= SMBFLG2_DFS;
2870         }
2871         if (ses->capabilities & CAP_UNICODE) {
2872                 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2873                 length =
2874                     cifs_strtoUCS((__le16 *) bcc_ptr, tree,
2875                         6 /* max utf8 char length in bytes */ *
2876                         (/* server len*/ + 256 /* share len */), nls_codepage);
2877                 bcc_ptr += 2 * length;  /* convert num 16 bit words to bytes */
2878                 bcc_ptr += 2;   /* skip trailing null */
2879         } else {                /* ASCII */
2880                 strcpy(bcc_ptr, tree);
2881                 bcc_ptr += strlen(tree) + 1;
2882         }
2883         strcpy(bcc_ptr, "?????");
2884         bcc_ptr += strlen("?????");
2885         bcc_ptr += 1;
2886         count = bcc_ptr - &pSMB->Password[0];
2887         pSMB->hdr.smb_buf_length += count;
2888         pSMB->ByteCount = cpu_to_le16(count);
2889
2890         rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
2891                          CIFS_STD_OP);
2892
2893         /* above now done in SendReceive */
2894         if ((rc == 0) && (tcon != NULL)) {
2895                 bool is_unicode;
2896
2897                 tcon->tidStatus = CifsGood;
2898                 tcon->need_reconnect = false;
2899                 tcon->tid = smb_buffer_response->Tid;
2900                 bcc_ptr = pByteArea(smb_buffer_response);
2901                 bytes_left = BCC(smb_buffer_response);
2902                 length = strnlen(bcc_ptr, bytes_left - 2);
2903                 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
2904                         is_unicode = true;
2905                 else
2906                         is_unicode = false;
2907
2908
2909                 /* skip service field (NB: this field is always ASCII) */
2910                 if (length == 3) {
2911                         if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
2912                             (bcc_ptr[2] == 'C')) {
2913                                 cFYI(1, "IPC connection");
2914                                 tcon->ipc = 1;
2915                         }
2916                 } else if (length == 2) {
2917                         if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
2918                                 /* the most common case */
2919                                 cFYI(1, "disk share connection");
2920                         }
2921                 }
2922                 bcc_ptr += length + 1;
2923                 bytes_left -= (length + 1);
2924                 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
2925
2926                 /* mostly informational -- no need to fail on error here */
2927                 kfree(tcon->nativeFileSystem);
2928                 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
2929                                                       bytes_left, is_unicode,
2930                                                       nls_codepage);
2931
2932                 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
2933
2934                 if ((smb_buffer_response->WordCount == 3) ||
2935                          (smb_buffer_response->WordCount == 7))
2936                         /* field is in same location */
2937                         tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
2938                 else
2939                         tcon->Flags = 0;
2940                 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
2941         } else if ((rc == 0) && tcon == NULL) {
2942                 /* all we need to save for IPC$ connection */
2943                 ses->ipc_tid = smb_buffer_response->Tid;
2944         }
2945
2946         cifs_buf_release(smb_buffer);
2947         return rc;
2948 }
2949
2950 int
2951 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
2952 {
2953         int rc = 0;
2954         char *tmp;
2955
2956         if (cifs_sb->tcon)
2957                 cifs_put_tcon(cifs_sb->tcon);
2958
2959         cifs_sb->tcon = NULL;
2960         tmp = cifs_sb->prepath;
2961         cifs_sb->prepathlen = 0;
2962         cifs_sb->prepath = NULL;
2963         kfree(tmp);
2964
2965         return rc;
2966 }
2967
2968 int cifs_negotiate_protocol(unsigned int xid, struct cifsSesInfo *ses)
2969 {
2970         int rc = 0;
2971         struct TCP_Server_Info *server = ses->server;
2972
2973         /* only send once per connect */
2974         if (server->maxBuf != 0)
2975                 return 0;
2976
2977         rc = CIFSSMBNegotiate(xid, ses);
2978         if (rc == -EAGAIN) {
2979                 /* retry only once on 1st time connection */
2980                 rc = CIFSSMBNegotiate(xid, ses);
2981                 if (rc == -EAGAIN)
2982                         rc = -EHOSTDOWN;
2983         }
2984         if (rc == 0) {
2985                 spin_lock(&GlobalMid_Lock);
2986                 if (server->tcpStatus != CifsExiting)
2987                         server->tcpStatus = CifsGood;
2988                 else
2989                         rc = -EHOSTDOWN;
2990                 spin_unlock(&GlobalMid_Lock);
2991
2992         }
2993
2994         return rc;
2995 }
2996
2997
2998 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *ses,
2999                         struct nls_table *nls_info)
3000 {
3001         int rc = 0;
3002         struct TCP_Server_Info *server = ses->server;
3003
3004         ses->flags = 0;
3005         ses->capabilities = server->capabilities;
3006         if (linuxExtEnabled == 0)
3007                 ses->capabilities &= (~CAP_UNIX);
3008
3009         cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3010                  server->secMode, server->capabilities, server->timeAdj);
3011
3012         rc = CIFS_SessSetup(xid, ses, nls_info);
3013         if (rc) {
3014                 cERROR(1, "Send error in SessSetup = %d", rc);
3015         } else {
3016                 cFYI(1, "CIFS Session Established successfully");
3017                 spin_lock(&GlobalMid_Lock);
3018                 ses->status = CifsGood;
3019                 ses->need_reconnect = false;
3020                 spin_unlock(&GlobalMid_Lock);
3021         }
3022
3023         return rc;
3024 }
3025