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