fs/cifs/connect.c

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