fs/cifs/connect.c

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