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