1/* 2 * fs/cifs/connect.c 3 * 4 * Copyright (C) International Business Machines Corp., 2002,2011 5 * Author(s): Steve French (sfrench@us.ibm.com) 6 * 7 * This library is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU Lesser General Public License as published 9 * by the Free Software Foundation; either version 2.1 of the License, or 10 * (at your option) any later version. 11 * 12 * This library is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 15 * the GNU Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public License 18 * along with this library; if not, write to the Free Software 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 20 */ 21#include <linux/fs.h> 22#include <linux/net.h> 23#include <linux/string.h> 24#include <linux/list.h> 25#include <linux/wait.h> 26#include <linux/slab.h> 27#include <linux/pagemap.h> 28#include <linux/ctype.h> 29#include <linux/utsname.h> 30#include <linux/mempool.h> 31#include <linux/delay.h> 32#include <linux/completion.h> 33#include <linux/kthread.h> 34#include <linux/pagevec.h> 35#include <linux/freezer.h> 36#include <linux/namei.h> 37#include <asm/uaccess.h> 38#include <asm/processor.h> 39#include <linux/inet.h> 40#include <linux/module.h> 41#include <keys/user-type.h> 42#include <net/ipv6.h> 43#include <linux/parser.h> 44 45#include "cifspdu.h" 46#include "cifsglob.h" 47#include "cifsproto.h" 48#include "cifs_unicode.h" 49#include "cifs_debug.h" 50#include "cifs_fs_sb.h" 51#include "ntlmssp.h" 52#include "nterr.h" 53#include "rfc1002pdu.h" 54#include "fscache.h" 55 56#define CIFS_PORT 445 57#define RFC1001_PORT 139 58 59extern mempool_t *cifs_req_poolp; 60 61/* FIXME: should these be tunable? */ 62#define TLINK_ERROR_EXPIRE (1 * HZ) 63#define TLINK_IDLE_EXPIRE (600 * HZ) 64 65enum { 66 67 /* Mount options that take no arguments */ 68 Opt_user_xattr, Opt_nouser_xattr, 69 Opt_forceuid, Opt_noforceuid, 70 Opt_forcegid, Opt_noforcegid, 71 Opt_noblocksend, Opt_noautotune, 72 Opt_hard, Opt_soft, Opt_perm, Opt_noperm, 73 Opt_mapposix, Opt_nomapposix, 74 Opt_mapchars, Opt_nomapchars, Opt_sfu, 75 Opt_nosfu, Opt_nodfs, Opt_posixpaths, 76 Opt_noposixpaths, Opt_nounix, 77 Opt_nocase, 78 Opt_brl, Opt_nobrl, 79 Opt_forcemandatorylock, Opt_setuids, 80 Opt_nosetuids, Opt_dynperm, Opt_nodynperm, 81 Opt_nohard, Opt_nosoft, 82 Opt_nointr, Opt_intr, 83 Opt_nostrictsync, Opt_strictsync, 84 Opt_serverino, Opt_noserverino, 85 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl, 86 Opt_acl, Opt_noacl, Opt_locallease, 87 Opt_sign, Opt_seal, Opt_noac, 88 Opt_fsc, Opt_mfsymlinks, 89 Opt_multiuser, Opt_sloppy, Opt_nosharesock, 90 Opt_persistent, Opt_nopersistent, 91 Opt_resilient, Opt_noresilient, 92 93 /* Mount options which take numeric value */ 94 Opt_backupuid, Opt_backupgid, Opt_uid, 95 Opt_cruid, Opt_gid, Opt_file_mode, 96 Opt_dirmode, Opt_port, 97 Opt_rsize, Opt_wsize, Opt_actimeo, 98 99 /* Mount options which take string value */ 100 Opt_user, Opt_pass, Opt_ip, 101 Opt_domain, Opt_srcaddr, Opt_iocharset, 102 Opt_netbiosname, Opt_servern, 103 Opt_ver, Opt_vers, Opt_sec, Opt_cache, 104 105 /* Mount options to be ignored */ 106 Opt_ignore, 107 108 /* Options which could be blank */ 109 Opt_blank_pass, 110 Opt_blank_user, 111 Opt_blank_ip, 112 113 Opt_err 114}; 115 116static const match_table_t cifs_mount_option_tokens = { 117 118 { Opt_user_xattr, "user_xattr" }, 119 { Opt_nouser_xattr, "nouser_xattr" }, 120 { Opt_forceuid, "forceuid" }, 121 { Opt_noforceuid, "noforceuid" }, 122 { Opt_forcegid, "forcegid" }, 123 { Opt_noforcegid, "noforcegid" }, 124 { Opt_noblocksend, "noblocksend" }, 125 { Opt_noautotune, "noautotune" }, 126 { Opt_hard, "hard" }, 127 { Opt_soft, "soft" }, 128 { Opt_perm, "perm" }, 129 { Opt_noperm, "noperm" }, 130 { Opt_mapchars, "mapchars" }, /* SFU style */ 131 { Opt_nomapchars, "nomapchars" }, 132 { Opt_mapposix, "mapposix" }, /* SFM style */ 133 { Opt_nomapposix, "nomapposix" }, 134 { Opt_sfu, "sfu" }, 135 { Opt_nosfu, "nosfu" }, 136 { Opt_nodfs, "nodfs" }, 137 { Opt_posixpaths, "posixpaths" }, 138 { Opt_noposixpaths, "noposixpaths" }, 139 { Opt_nounix, "nounix" }, 140 { Opt_nounix, "nolinux" }, 141 { Opt_nocase, "nocase" }, 142 { Opt_nocase, "ignorecase" }, 143 { Opt_brl, "brl" }, 144 { Opt_nobrl, "nobrl" }, 145 { Opt_nobrl, "nolock" }, 146 { Opt_forcemandatorylock, "forcemandatorylock" }, 147 { Opt_forcemandatorylock, "forcemand" }, 148 { Opt_setuids, "setuids" }, 149 { Opt_nosetuids, "nosetuids" }, 150 { Opt_dynperm, "dynperm" }, 151 { Opt_nodynperm, "nodynperm" }, 152 { Opt_nohard, "nohard" }, 153 { Opt_nosoft, "nosoft" }, 154 { Opt_nointr, "nointr" }, 155 { Opt_intr, "intr" }, 156 { Opt_nostrictsync, "nostrictsync" }, 157 { Opt_strictsync, "strictsync" }, 158 { Opt_serverino, "serverino" }, 159 { Opt_noserverino, "noserverino" }, 160 { Opt_rwpidforward, "rwpidforward" }, 161 { Opt_cifsacl, "cifsacl" }, 162 { Opt_nocifsacl, "nocifsacl" }, 163 { Opt_acl, "acl" }, 164 { Opt_noacl, "noacl" }, 165 { Opt_locallease, "locallease" }, 166 { Opt_sign, "sign" }, 167 { Opt_seal, "seal" }, 168 { Opt_noac, "noac" }, 169 { Opt_fsc, "fsc" }, 170 { Opt_mfsymlinks, "mfsymlinks" }, 171 { Opt_multiuser, "multiuser" }, 172 { Opt_sloppy, "sloppy" }, 173 { Opt_nosharesock, "nosharesock" }, 174 { Opt_persistent, "persistenthandles"}, 175 { Opt_nopersistent, "nopersistenthandles"}, 176 { Opt_resilient, "resilienthandles"}, 177 { Opt_noresilient, "noresilienthandles"}, 178 179 { Opt_backupuid, "backupuid=%s" }, 180 { Opt_backupgid, "backupgid=%s" }, 181 { Opt_uid, "uid=%s" }, 182 { Opt_cruid, "cruid=%s" }, 183 { Opt_gid, "gid=%s" }, 184 { Opt_file_mode, "file_mode=%s" }, 185 { Opt_dirmode, "dirmode=%s" }, 186 { Opt_dirmode, "dir_mode=%s" }, 187 { Opt_port, "port=%s" }, 188 { Opt_rsize, "rsize=%s" }, 189 { Opt_wsize, "wsize=%s" }, 190 { Opt_actimeo, "actimeo=%s" }, 191 192 { Opt_blank_user, "user=" }, 193 { Opt_blank_user, "username=" }, 194 { Opt_user, "user=%s" }, 195 { Opt_user, "username=%s" }, 196 { Opt_blank_pass, "pass=" }, 197 { Opt_blank_pass, "password=" }, 198 { Opt_pass, "pass=%s" }, 199 { Opt_pass, "password=%s" }, 200 { Opt_blank_ip, "ip=" }, 201 { Opt_blank_ip, "addr=" }, 202 { Opt_ip, "ip=%s" }, 203 { Opt_ip, "addr=%s" }, 204 { Opt_ignore, "unc=%s" }, 205 { Opt_ignore, "target=%s" }, 206 { Opt_ignore, "path=%s" }, 207 { Opt_domain, "dom=%s" }, 208 { Opt_domain, "domain=%s" }, 209 { Opt_domain, "workgroup=%s" }, 210 { Opt_srcaddr, "srcaddr=%s" }, 211 { Opt_ignore, "prefixpath=%s" }, 212 { Opt_iocharset, "iocharset=%s" }, 213 { Opt_netbiosname, "netbiosname=%s" }, 214 { Opt_servern, "servern=%s" }, 215 { Opt_ver, "ver=%s" }, 216 { Opt_vers, "vers=%s" }, 217 { Opt_sec, "sec=%s" }, 218 { Opt_cache, "cache=%s" }, 219 220 { Opt_ignore, "cred" }, 221 { Opt_ignore, "credentials" }, 222 { Opt_ignore, "cred=%s" }, 223 { Opt_ignore, "credentials=%s" }, 224 { Opt_ignore, "guest" }, 225 { Opt_ignore, "rw" }, 226 { Opt_ignore, "ro" }, 227 { Opt_ignore, "suid" }, 228 { Opt_ignore, "nosuid" }, 229 { Opt_ignore, "exec" }, 230 { Opt_ignore, "noexec" }, 231 { Opt_ignore, "nodev" }, 232 { Opt_ignore, "noauto" }, 233 { Opt_ignore, "dev" }, 234 { Opt_ignore, "mand" }, 235 { Opt_ignore, "nomand" }, 236 { Opt_ignore, "_netdev" }, 237 238 { Opt_err, NULL } 239}; 240 241enum { 242 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p, 243 Opt_sec_ntlmsspi, Opt_sec_ntlmssp, 244 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2, 245 Opt_sec_ntlmv2i, Opt_sec_lanman, 246 Opt_sec_none, 247 248 Opt_sec_err 249}; 250 251static const match_table_t cifs_secflavor_tokens = { 252 { Opt_sec_krb5, "krb5" }, 253 { Opt_sec_krb5i, "krb5i" }, 254 { Opt_sec_krb5p, "krb5p" }, 255 { Opt_sec_ntlmsspi, "ntlmsspi" }, 256 { Opt_sec_ntlmssp, "ntlmssp" }, 257 { Opt_ntlm, "ntlm" }, 258 { Opt_sec_ntlmi, "ntlmi" }, 259 { Opt_sec_ntlmv2, "nontlm" }, 260 { Opt_sec_ntlmv2, "ntlmv2" }, 261 { Opt_sec_ntlmv2i, "ntlmv2i" }, 262 { Opt_sec_lanman, "lanman" }, 263 { Opt_sec_none, "none" }, 264 265 { Opt_sec_err, NULL } 266}; 267 268/* cache flavors */ 269enum { 270 Opt_cache_loose, 271 Opt_cache_strict, 272 Opt_cache_none, 273 Opt_cache_err 274}; 275 276static const match_table_t cifs_cacheflavor_tokens = { 277 { Opt_cache_loose, "loose" }, 278 { Opt_cache_strict, "strict" }, 279 { Opt_cache_none, "none" }, 280 { Opt_cache_err, NULL } 281}; 282 283static const match_table_t cifs_smb_version_tokens = { 284 { Smb_1, SMB1_VERSION_STRING }, 285 { Smb_20, SMB20_VERSION_STRING}, 286 { Smb_21, SMB21_VERSION_STRING }, 287 { Smb_30, SMB30_VERSION_STRING }, 288 { Smb_302, SMB302_VERSION_STRING }, 289#ifdef CONFIG_CIFS_SMB311 290 { Smb_311, SMB311_VERSION_STRING }, 291 { Smb_311, ALT_SMB311_VERSION_STRING }, 292#endif /* SMB311 */ 293 { Smb_version_err, NULL } 294}; 295 296static int ip_connect(struct TCP_Server_Info *server); 297static int generic_ip_connect(struct TCP_Server_Info *server); 298static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink); 299static void cifs_prune_tlinks(struct work_struct *work); 300static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data, 301 const char *devname); 302 303/* 304 * cifs tcp session reconnection 305 * 306 * mark tcp session as reconnecting so temporarily locked 307 * mark all smb sessions as reconnecting for tcp session 308 * reconnect tcp session 309 * wake up waiters on reconnection? - (not needed currently) 310 */ 311int 312cifs_reconnect(struct TCP_Server_Info *server) 313{ 314 int rc = 0; 315 struct list_head *tmp, *tmp2; 316 struct cifs_ses *ses; 317 struct cifs_tcon *tcon; 318 struct mid_q_entry *mid_entry; 319 struct list_head retry_list; 320 321 spin_lock(&GlobalMid_Lock); 322 if (server->tcpStatus == CifsExiting) { 323 /* the demux thread will exit normally 324 next time through the loop */ 325 spin_unlock(&GlobalMid_Lock); 326 return rc; 327 } else 328 server->tcpStatus = CifsNeedReconnect; 329 spin_unlock(&GlobalMid_Lock); 330 server->maxBuf = 0; 331#ifdef CONFIG_CIFS_SMB2 332 server->max_read = 0; 333#endif 334 335 cifs_dbg(FYI, "Reconnecting tcp session\n"); 336 337 /* before reconnecting the tcp session, mark the smb session (uid) 338 and the tid bad so they are not used until reconnected */ 339 cifs_dbg(FYI, "%s: marking sessions and tcons for reconnect\n", 340 __func__); 341 spin_lock(&cifs_tcp_ses_lock); 342 list_for_each(tmp, &server->smb_ses_list) { 343 ses = list_entry(tmp, struct cifs_ses, smb_ses_list); 344 ses->need_reconnect = true; 345 ses->ipc_tid = 0; 346 list_for_each(tmp2, &ses->tcon_list) { 347 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list); 348 tcon->need_reconnect = true; 349 } 350 } 351 spin_unlock(&cifs_tcp_ses_lock); 352 353 /* do not want to be sending data on a socket we are freeing */ 354 cifs_dbg(FYI, "%s: tearing down socket\n", __func__); 355 mutex_lock(&server->srv_mutex); 356 if (server->ssocket) { 357 cifs_dbg(FYI, "State: 0x%x Flags: 0x%lx\n", 358 server->ssocket->state, server->ssocket->flags); 359 kernel_sock_shutdown(server->ssocket, SHUT_WR); 360 cifs_dbg(FYI, "Post shutdown state: 0x%x Flags: 0x%lx\n", 361 server->ssocket->state, server->ssocket->flags); 362 sock_release(server->ssocket); 363 server->ssocket = NULL; 364 } 365 server->sequence_number = 0; 366 server->session_estab = false; 367 kfree(server->session_key.response); 368 server->session_key.response = NULL; 369 server->session_key.len = 0; 370 server->lstrp = jiffies; 371 372 /* mark submitted MIDs for retry and issue callback */ 373 INIT_LIST_HEAD(&retry_list); 374 cifs_dbg(FYI, "%s: moving mids to private list\n", __func__); 375 spin_lock(&GlobalMid_Lock); 376 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) { 377 mid_entry = list_entry(tmp, struct mid_q_entry, qhead); 378 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED) 379 mid_entry->mid_state = MID_RETRY_NEEDED; 380 list_move(&mid_entry->qhead, &retry_list); 381 } 382 spin_unlock(&GlobalMid_Lock); 383 mutex_unlock(&server->srv_mutex); 384 385 cifs_dbg(FYI, "%s: issuing mid callbacks\n", __func__); 386 list_for_each_safe(tmp, tmp2, &retry_list) { 387 mid_entry = list_entry(tmp, struct mid_q_entry, qhead); 388 list_del_init(&mid_entry->qhead); 389 mid_entry->callback(mid_entry); 390 } 391 392 do { 393 try_to_freeze(); 394 395 /* we should try only the port we connected to before */ 396 mutex_lock(&server->srv_mutex); 397 rc = generic_ip_connect(server); 398 if (rc) { 399 cifs_dbg(FYI, "reconnect error %d\n", rc); 400 mutex_unlock(&server->srv_mutex); 401 msleep(3000); 402 } else { 403 atomic_inc(&tcpSesReconnectCount); 404 spin_lock(&GlobalMid_Lock); 405 if (server->tcpStatus != CifsExiting) 406 server->tcpStatus = CifsNeedNegotiate; 407 spin_unlock(&GlobalMid_Lock); 408 mutex_unlock(&server->srv_mutex); 409 } 410 } while (server->tcpStatus == CifsNeedReconnect); 411 412 return rc; 413} 414 415static void 416cifs_echo_request(struct work_struct *work) 417{ 418 int rc; 419 struct TCP_Server_Info *server = container_of(work, 420 struct TCP_Server_Info, echo.work); 421 422 /* 423 * We cannot send an echo if it is disabled or until the 424 * NEGOTIATE_PROTOCOL request is done, which is indicated by 425 * server->ops->need_neg() == true. Also, no need to ping if 426 * we got a response recently. 427 */ 428 if (!server->ops->need_neg || server->ops->need_neg(server) || 429 (server->ops->can_echo && !server->ops->can_echo(server)) || 430 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ)) 431 goto requeue_echo; 432 433 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS; 434 if (rc) 435 cifs_dbg(FYI, "Unable to send echo request to server: %s\n", 436 server->hostname); 437 438requeue_echo: 439 queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL); 440} 441 442static bool 443allocate_buffers(struct TCP_Server_Info *server) 444{ 445 if (!server->bigbuf) { 446 server->bigbuf = (char *)cifs_buf_get(); 447 if (!server->bigbuf) { 448 cifs_dbg(VFS, "No memory for large SMB response\n"); 449 msleep(3000); 450 /* retry will check if exiting */ 451 return false; 452 } 453 } else if (server->large_buf) { 454 /* we are reusing a dirty large buf, clear its start */ 455 memset(server->bigbuf, 0, HEADER_SIZE(server)); 456 } 457 458 if (!server->smallbuf) { 459 server->smallbuf = (char *)cifs_small_buf_get(); 460 if (!server->smallbuf) { 461 cifs_dbg(VFS, "No memory for SMB response\n"); 462 msleep(1000); 463 /* retry will check if exiting */ 464 return false; 465 } 466 /* beginning of smb buffer is cleared in our buf_get */ 467 } else { 468 /* if existing small buf clear beginning */ 469 memset(server->smallbuf, 0, HEADER_SIZE(server)); 470 } 471 472 return true; 473} 474 475static bool 476server_unresponsive(struct TCP_Server_Info *server) 477{ 478 /* 479 * We need to wait 2 echo intervals to make sure we handle such 480 * situations right: 481 * 1s client sends a normal SMB request 482 * 2s client gets a response 483 * 30s echo workqueue job pops, and decides we got a response recently 484 * and don't need to send another 485 * ... 486 * 65s kernel_recvmsg times out, and we see that we haven't gotten 487 * a response in >60s. 488 */ 489 if (server->tcpStatus == CifsGood && 490 time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) { 491 cifs_dbg(VFS, "Server %s has not responded in %d seconds. Reconnecting...\n", 492 server->hostname, (2 * SMB_ECHO_INTERVAL) / HZ); 493 cifs_reconnect(server); 494 wake_up(&server->response_q); 495 return true; 496 } 497 498 return false; 499} 500 501/* 502 * kvec_array_init - clone a kvec array, and advance into it 503 * @new: pointer to memory for cloned array 504 * @iov: pointer to original array 505 * @nr_segs: number of members in original array 506 * @bytes: number of bytes to advance into the cloned array 507 * 508 * This function will copy the array provided in iov to a section of memory 509 * and advance the specified number of bytes into the new array. It returns 510 * the number of segments in the new array. "new" must be at least as big as 511 * the original iov array. 512 */ 513static unsigned int 514kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs, 515 size_t bytes) 516{ 517 size_t base = 0; 518 519 while (bytes || !iov->iov_len) { 520 int copy = min(bytes, iov->iov_len); 521 522 bytes -= copy; 523 base += copy; 524 if (iov->iov_len == base) { 525 iov++; 526 nr_segs--; 527 base = 0; 528 } 529 } 530 memcpy(new, iov, sizeof(*iov) * nr_segs); 531 new->iov_base += base; 532 new->iov_len -= base; 533 return nr_segs; 534} 535 536static struct kvec * 537get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs) 538{ 539 struct kvec *new_iov; 540 541 if (server->iov && nr_segs <= server->nr_iov) 542 return server->iov; 543 544 /* not big enough -- allocate a new one and release the old */ 545 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS); 546 if (new_iov) { 547 kfree(server->iov); 548 server->iov = new_iov; 549 server->nr_iov = nr_segs; 550 } 551 return new_iov; 552} 553 554int 555cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig, 556 unsigned int nr_segs, unsigned int to_read) 557{ 558 int length = 0; 559 int total_read; 560 unsigned int segs; 561 struct msghdr smb_msg; 562 struct kvec *iov; 563 564 iov = get_server_iovec(server, nr_segs); 565 if (!iov) 566 return -ENOMEM; 567 568 smb_msg.msg_control = NULL; 569 smb_msg.msg_controllen = 0; 570 571 for (total_read = 0; to_read; total_read += length, to_read -= length) { 572 try_to_freeze(); 573 574 if (server_unresponsive(server)) { 575 total_read = -ECONNABORTED; 576 break; 577 } 578 579 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read); 580 581 length = kernel_recvmsg(server->ssocket, &smb_msg, 582 iov, segs, to_read, 0); 583 584 if (server->tcpStatus == CifsExiting) { 585 total_read = -ESHUTDOWN; 586 break; 587 } else if (server->tcpStatus == CifsNeedReconnect) { 588 cifs_reconnect(server); 589 total_read = -ECONNABORTED; 590 break; 591 } else if (length == -ERESTARTSYS || 592 length == -EAGAIN || 593 length == -EINTR) { 594 /* 595 * Minimum sleep to prevent looping, allowing socket 596 * to clear and app threads to set tcpStatus 597 * CifsNeedReconnect if server hung. 598 */ 599 usleep_range(1000, 2000); 600 length = 0; 601 continue; 602 } else if (length <= 0) { 603 cifs_dbg(FYI, "Received no data or error: expecting %d\n" 604 "got %d", to_read, length); 605 cifs_reconnect(server); 606 total_read = -ECONNABORTED; 607 break; 608 } 609 } 610 return total_read; 611} 612 613int 614cifs_read_from_socket(struct TCP_Server_Info *server, char *buf, 615 unsigned int to_read) 616{ 617 struct kvec iov; 618 619 iov.iov_base = buf; 620 iov.iov_len = to_read; 621 622 return cifs_readv_from_socket(server, &iov, 1, to_read); 623} 624 625static bool 626is_smb_response(struct TCP_Server_Info *server, unsigned char type) 627{ 628 /* 629 * The first byte big endian of the length field, 630 * is actually not part of the length but the type 631 * with the most common, zero, as regular data. 632 */ 633 switch (type) { 634 case RFC1002_SESSION_MESSAGE: 635 /* Regular SMB response */ 636 return true; 637 case RFC1002_SESSION_KEEP_ALIVE: 638 cifs_dbg(FYI, "RFC 1002 session keep alive\n"); 639 break; 640 case RFC1002_POSITIVE_SESSION_RESPONSE: 641 cifs_dbg(FYI, "RFC 1002 positive session response\n"); 642 break; 643 case RFC1002_NEGATIVE_SESSION_RESPONSE: 644 /* 645 * We get this from Windows 98 instead of an error on 646 * SMB negprot response. 647 */ 648 cifs_dbg(FYI, "RFC 1002 negative session response\n"); 649 /* give server a second to clean up */ 650 msleep(1000); 651 /* 652 * Always try 445 first on reconnect since we get NACK 653 * on some if we ever connected to port 139 (the NACK 654 * is since we do not begin with RFC1001 session 655 * initialize frame). 656 */ 657 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT); 658 cifs_reconnect(server); 659 wake_up(&server->response_q); 660 break; 661 default: 662 cifs_dbg(VFS, "RFC 1002 unknown response type 0x%x\n", type); 663 cifs_reconnect(server); 664 } 665 666 return false; 667} 668 669void 670dequeue_mid(struct mid_q_entry *mid, bool malformed) 671{ 672#ifdef CONFIG_CIFS_STATS2 673 mid->when_received = jiffies; 674#endif 675 spin_lock(&GlobalMid_Lock); 676 if (!malformed) 677 mid->mid_state = MID_RESPONSE_RECEIVED; 678 else 679 mid->mid_state = MID_RESPONSE_MALFORMED; 680 list_del_init(&mid->qhead); 681 spin_unlock(&GlobalMid_Lock); 682} 683 684static void 685handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server, 686 char *buf, int malformed) 687{ 688 if (server->ops->check_trans2 && 689 server->ops->check_trans2(mid, server, buf, malformed)) 690 return; 691 mid->resp_buf = buf; 692 mid->large_buf = server->large_buf; 693 /* Was previous buf put in mpx struct for multi-rsp? */ 694 if (!mid->multiRsp) { 695 /* smb buffer will be freed by user thread */ 696 if (server->large_buf) 697 server->bigbuf = NULL; 698 else 699 server->smallbuf = NULL; 700 } 701 dequeue_mid(mid, malformed); 702} 703 704static void clean_demultiplex_info(struct TCP_Server_Info *server) 705{ 706 int length; 707 708 /* take it off the list, if it's not already */ 709 spin_lock(&cifs_tcp_ses_lock); 710 list_del_init(&server->tcp_ses_list); 711 spin_unlock(&cifs_tcp_ses_lock); 712 713 spin_lock(&GlobalMid_Lock); 714 server->tcpStatus = CifsExiting; 715 spin_unlock(&GlobalMid_Lock); 716 wake_up_all(&server->response_q); 717 718 /* check if we have blocked requests that need to free */ 719 spin_lock(&server->req_lock); 720 if (server->credits <= 0) 721 server->credits = 1; 722 spin_unlock(&server->req_lock); 723 /* 724 * Although there should not be any requests blocked on this queue it 725 * can not hurt to be paranoid and try to wake up requests that may 726 * haven been blocked when more than 50 at time were on the wire to the 727 * same server - they now will see the session is in exit state and get 728 * out of SendReceive. 729 */ 730 wake_up_all(&server->request_q); 731 /* give those requests time to exit */ 732 msleep(125); 733 734 if (server->ssocket) { 735 sock_release(server->ssocket); 736 server->ssocket = NULL; 737 } 738 739 if (!list_empty(&server->pending_mid_q)) { 740 struct list_head dispose_list; 741 struct mid_q_entry *mid_entry; 742 struct list_head *tmp, *tmp2; 743 744 INIT_LIST_HEAD(&dispose_list); 745 spin_lock(&GlobalMid_Lock); 746 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) { 747 mid_entry = list_entry(tmp, struct mid_q_entry, qhead); 748 cifs_dbg(FYI, "Clearing mid 0x%llx\n", mid_entry->mid); 749 mid_entry->mid_state = MID_SHUTDOWN; 750 list_move(&mid_entry->qhead, &dispose_list); 751 } 752 spin_unlock(&GlobalMid_Lock); 753 754 /* now walk dispose list and issue callbacks */ 755 list_for_each_safe(tmp, tmp2, &dispose_list) { 756 mid_entry = list_entry(tmp, struct mid_q_entry, qhead); 757 cifs_dbg(FYI, "Callback mid 0x%llx\n", mid_entry->mid); 758 list_del_init(&mid_entry->qhead); 759 mid_entry->callback(mid_entry); 760 } 761 /* 1/8th of sec is more than enough time for them to exit */ 762 msleep(125); 763 } 764 765 if (!list_empty(&server->pending_mid_q)) { 766 /* 767 * mpx threads have not exited yet give them at least the smb 768 * send timeout time for long ops. 769 * 770 * Due to delays on oplock break requests, we need to wait at 771 * least 45 seconds before giving up on a request getting a 772 * response and going ahead and killing cifsd. 773 */ 774 cifs_dbg(FYI, "Wait for exit from demultiplex thread\n"); 775 msleep(46000); 776 /* 777 * If threads still have not exited they are probably never 778 * coming home not much else we can do but free the memory. 779 */ 780 } 781 782 kfree(server->hostname); 783 kfree(server->iov); 784 kfree(server); 785 786 length = atomic_dec_return(&tcpSesAllocCount); 787 if (length > 0) 788 mempool_resize(cifs_req_poolp, length + cifs_min_rcv); 789} 790 791static int 792standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid) 793{ 794 int length; 795 char *buf = server->smallbuf; 796 unsigned int pdu_length = get_rfc1002_length(buf); 797 798 /* make sure this will fit in a large buffer */ 799 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) { 800 cifs_dbg(VFS, "SMB response too long (%u bytes)\n", pdu_length); 801 cifs_reconnect(server); 802 wake_up(&server->response_q); 803 return -ECONNABORTED; 804 } 805 806 /* switch to large buffer if too big for a small one */ 807 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) { 808 server->large_buf = true; 809 memcpy(server->bigbuf, buf, server->total_read); 810 buf = server->bigbuf; 811 } 812 813 /* now read the rest */ 814 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1, 815 pdu_length - HEADER_SIZE(server) + 1 + 4); 816 if (length < 0) 817 return length; 818 server->total_read += length; 819 820 dump_smb(buf, server->total_read); 821 822 /* 823 * We know that we received enough to get to the MID as we 824 * checked the pdu_length earlier. Now check to see 825 * if the rest of the header is OK. We borrow the length 826 * var for the rest of the loop to avoid a new stack var. 827 * 828 * 48 bytes is enough to display the header and a little bit 829 * into the payload for debugging purposes. 830 */ 831 length = server->ops->check_message(buf, server->total_read); 832 if (length != 0) 833 cifs_dump_mem("Bad SMB: ", buf, 834 min_t(unsigned int, server->total_read, 48)); 835 836 if (server->ops->is_status_pending && 837 server->ops->is_status_pending(buf, server, length)) 838 return -1; 839 840 if (!mid) 841 return length; 842 843 handle_mid(mid, server, buf, length); 844 return 0; 845} 846 847static int 848cifs_demultiplex_thread(void *p) 849{ 850 int length; 851 struct TCP_Server_Info *server = p; 852 unsigned int pdu_length; 853 char *buf = NULL; 854 struct task_struct *task_to_wake = NULL; 855 struct mid_q_entry *mid_entry; 856 857 current->flags |= PF_MEMALLOC; 858 cifs_dbg(FYI, "Demultiplex PID: %d\n", task_pid_nr(current)); 859 860 length = atomic_inc_return(&tcpSesAllocCount); 861 if (length > 1) 862 mempool_resize(cifs_req_poolp, length + cifs_min_rcv); 863 864 set_freezable(); 865 while (server->tcpStatus != CifsExiting) { 866 if (try_to_freeze()) 867 continue; 868 869 if (!allocate_buffers(server)) 870 continue; 871 872 server->large_buf = false; 873 buf = server->smallbuf; 874 pdu_length = 4; /* enough to get RFC1001 header */ 875 876 length = cifs_read_from_socket(server, buf, pdu_length); 877 if (length < 0) 878 continue; 879 server->total_read = length; 880 881 /* 882 * The right amount was read from socket - 4 bytes, 883 * so we can now interpret the length field. 884 */ 885 pdu_length = get_rfc1002_length(buf); 886 887 cifs_dbg(FYI, "RFC1002 header 0x%x\n", pdu_length); 888 if (!is_smb_response(server, buf[0])) 889 continue; 890 891 /* make sure we have enough to get to the MID */ 892 if (pdu_length < HEADER_SIZE(server) - 1 - 4) { 893 cifs_dbg(VFS, "SMB response too short (%u bytes)\n", 894 pdu_length); 895 cifs_reconnect(server); 896 wake_up(&server->response_q); 897 continue; 898 } 899 900 /* read down to the MID */ 901 length = cifs_read_from_socket(server, buf + 4, 902 HEADER_SIZE(server) - 1 - 4); 903 if (length < 0) 904 continue; 905 server->total_read += length; 906 907 mid_entry = server->ops->find_mid(server, buf); 908 909 if (!mid_entry || !mid_entry->receive) 910 length = standard_receive3(server, mid_entry); 911 else 912 length = mid_entry->receive(server, mid_entry); 913 914 if (length < 0) 915 continue; 916 917 if (server->large_buf) 918 buf = server->bigbuf; 919 920 server->lstrp = jiffies; 921 if (mid_entry != NULL) { 922 if (!mid_entry->multiRsp || mid_entry->multiEnd) 923 mid_entry->callback(mid_entry); 924 } else if (!server->ops->is_oplock_break || 925 !server->ops->is_oplock_break(buf, server)) { 926 cifs_dbg(VFS, "No task to wake, unknown frame received! NumMids %d\n", 927 atomic_read(&midCount)); 928 cifs_dump_mem("Received Data is: ", buf, 929 HEADER_SIZE(server)); 930#ifdef CONFIG_CIFS_DEBUG2 931 if (server->ops->dump_detail) 932 server->ops->dump_detail(buf); 933 cifs_dump_mids(server); 934#endif /* CIFS_DEBUG2 */ 935 936 } 937 } /* end while !EXITING */ 938 939 /* buffer usually freed in free_mid - need to free it here on exit */ 940 cifs_buf_release(server->bigbuf); 941 if (server->smallbuf) /* no sense logging a debug message if NULL */ 942 cifs_small_buf_release(server->smallbuf); 943 944 task_to_wake = xchg(&server->tsk, NULL); 945 clean_demultiplex_info(server); 946 947 /* if server->tsk was NULL then wait for a signal before exiting */ 948 if (!task_to_wake) { 949 set_current_state(TASK_INTERRUPTIBLE); 950 while (!signal_pending(current)) { 951 schedule(); 952 set_current_state(TASK_INTERRUPTIBLE); 953 } 954 set_current_state(TASK_RUNNING); 955 } 956 957 module_put_and_exit(0); 958} 959 960/* extract the host portion of the UNC string */ 961static char * 962extract_hostname(const char *unc) 963{ 964 const char *src; 965 char *dst, *delim; 966 unsigned int len; 967 968 /* skip double chars at beginning of string */ 969 /* BB: check validity of these bytes? */ 970 src = unc + 2; 971 972 /* delimiter between hostname and sharename is always '\\' now */ 973 delim = strchr(src, '\\'); 974 if (!delim) 975 return ERR_PTR(-EINVAL); 976 977 len = delim - src; 978 dst = kmalloc((len + 1), GFP_KERNEL); 979 if (dst == NULL) 980 return ERR_PTR(-ENOMEM); 981 982 memcpy(dst, src, len); 983 dst[len] = '\0'; 984 985 return dst; 986} 987 988static int get_option_ul(substring_t args[], unsigned long *option) 989{ 990 int rc; 991 char *string; 992 993 string = match_strdup(args); 994 if (string == NULL) 995 return -ENOMEM; 996 rc = kstrtoul(string, 0, option); 997 kfree(string); 998 999 return rc; 1000} 1001 1002static int get_option_uid(substring_t args[], kuid_t *result) 1003{ 1004 unsigned long value; 1005 kuid_t uid; 1006 int rc; 1007 1008 rc = get_option_ul(args, &value); 1009 if (rc) 1010 return rc; 1011 1012 uid = make_kuid(current_user_ns(), value); 1013 if (!uid_valid(uid)) 1014 return -EINVAL; 1015 1016 *result = uid; 1017 return 0; 1018} 1019 1020static int get_option_gid(substring_t args[], kgid_t *result) 1021{ 1022 unsigned long value; 1023 kgid_t gid; 1024 int rc; 1025 1026 rc = get_option_ul(args, &value); 1027 if (rc) 1028 return rc; 1029 1030 gid = make_kgid(current_user_ns(), value); 1031 if (!gid_valid(gid)) 1032 return -EINVAL; 1033 1034 *result = gid; 1035 return 0; 1036} 1037 1038static int cifs_parse_security_flavors(char *value, 1039 struct smb_vol *vol) 1040{ 1041 1042 substring_t args[MAX_OPT_ARGS]; 1043 1044 /* 1045 * With mount options, the last one should win. Reset any existing 1046 * settings back to default. 1047 */ 1048 vol->sectype = Unspecified; 1049 vol->sign = false; 1050 1051 switch (match_token(value, cifs_secflavor_tokens, args)) { 1052 case Opt_sec_krb5p: 1053 cifs_dbg(VFS, "sec=krb5p is not supported!\n"); 1054 return 1; 1055 case Opt_sec_krb5i: 1056 vol->sign = true; 1057 /* Fallthrough */ 1058 case Opt_sec_krb5: 1059 vol->sectype = Kerberos; 1060 break; 1061 case Opt_sec_ntlmsspi: 1062 vol->sign = true; 1063 /* Fallthrough */ 1064 case Opt_sec_ntlmssp: 1065 vol->sectype = RawNTLMSSP; 1066 break; 1067 case Opt_sec_ntlmi: 1068 vol->sign = true; 1069 /* Fallthrough */ 1070 case Opt_ntlm: 1071 vol->sectype = NTLM; 1072 break; 1073 case Opt_sec_ntlmv2i: 1074 vol->sign = true; 1075 /* Fallthrough */ 1076 case Opt_sec_ntlmv2: 1077 vol->sectype = NTLMv2; 1078 break; 1079#ifdef CONFIG_CIFS_WEAK_PW_HASH 1080 case Opt_sec_lanman: 1081 vol->sectype = LANMAN; 1082 break; 1083#endif 1084 case Opt_sec_none: 1085 vol->nullauth = 1; 1086 break; 1087 default: 1088 cifs_dbg(VFS, "bad security option: %s\n", value); 1089 return 1; 1090 } 1091 1092 return 0; 1093} 1094 1095static int 1096cifs_parse_cache_flavor(char *value, struct smb_vol *vol) 1097{ 1098 substring_t args[MAX_OPT_ARGS]; 1099 1100 switch (match_token(value, cifs_cacheflavor_tokens, args)) { 1101 case Opt_cache_loose: 1102 vol->direct_io = false; 1103 vol->strict_io = false; 1104 break; 1105 case Opt_cache_strict: 1106 vol->direct_io = false; 1107 vol->strict_io = true; 1108 break; 1109 case Opt_cache_none: 1110 vol->direct_io = true; 1111 vol->strict_io = false; 1112 break; 1113 default: 1114 cifs_dbg(VFS, "bad cache= option: %s\n", value); 1115 return 1; 1116 } 1117 return 0; 1118} 1119 1120static int 1121cifs_parse_smb_version(char *value, struct smb_vol *vol) 1122{ 1123 substring_t args[MAX_OPT_ARGS]; 1124 1125 switch (match_token(value, cifs_smb_version_tokens, args)) { 1126 case Smb_1: 1127 vol->ops = &smb1_operations; 1128 vol->vals = &smb1_values; 1129 break; 1130#ifdef CONFIG_CIFS_SMB2 1131 case Smb_20: 1132 vol->ops = &smb20_operations; 1133 vol->vals = &smb20_values; 1134 break; 1135 case Smb_21: 1136 vol->ops = &smb21_operations; 1137 vol->vals = &smb21_values; 1138 break; 1139 case Smb_30: 1140 vol->ops = &smb30_operations; 1141 vol->vals = &smb30_values; 1142 break; 1143 case Smb_302: 1144 vol->ops = &smb30_operations; /* currently identical with 3.0 */ 1145 vol->vals = &smb302_values; 1146 break; 1147#ifdef CONFIG_CIFS_SMB311 1148 case Smb_311: 1149 vol->ops = &smb311_operations; 1150 vol->vals = &smb311_values; 1151 break; 1152#endif /* SMB311 */ 1153#endif 1154 default: 1155 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value); 1156 return 1; 1157 } 1158 return 0; 1159} 1160 1161/* 1162 * Parse a devname into substrings and populate the vol->UNC and vol->prepath 1163 * fields with the result. Returns 0 on success and an error otherwise. 1164 */ 1165static int 1166cifs_parse_devname(const char *devname, struct smb_vol *vol) 1167{ 1168 char *pos; 1169 const char *delims = "/\\"; 1170 size_t len; 1171 1172 /* make sure we have a valid UNC double delimiter prefix */ 1173 len = strspn(devname, delims); 1174 if (len != 2) 1175 return -EINVAL; 1176 1177 /* find delimiter between host and sharename */ 1178 pos = strpbrk(devname + 2, delims); 1179 if (!pos) 1180 return -EINVAL; 1181 1182 /* skip past delimiter */ 1183 ++pos; 1184 1185 /* now go until next delimiter or end of string */ 1186 len = strcspn(pos, delims); 1187 1188 /* move "pos" up to delimiter or NULL */ 1189 pos += len; 1190 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL); 1191 if (!vol->UNC) 1192 return -ENOMEM; 1193 1194 convert_delimiter(vol->UNC, '\\'); 1195 1196 /* If pos is NULL, or is a bogus trailing delimiter then no prepath */ 1197 if (!*pos++ || !*pos) 1198 return 0; 1199 1200 vol->prepath = kstrdup(pos, GFP_KERNEL); 1201 if (!vol->prepath) 1202 return -ENOMEM; 1203 1204 return 0; 1205} 1206 1207static int 1208cifs_parse_mount_options(const char *mountdata, const char *devname, 1209 struct smb_vol *vol) 1210{ 1211 char *data, *end; 1212 char *mountdata_copy = NULL, *options; 1213 unsigned int temp_len, i, j; 1214 char separator[2]; 1215 short int override_uid = -1; 1216 short int override_gid = -1; 1217 bool uid_specified = false; 1218 bool gid_specified = false; 1219 bool sloppy = false; 1220 char *invalid = NULL; 1221 char *nodename = utsname()->nodename; 1222 char *string = NULL; 1223 char *tmp_end, *value; 1224 char delim; 1225 bool got_ip = false; 1226 unsigned short port = 0; 1227 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr; 1228 1229 separator[0] = ','; 1230 separator[1] = 0; 1231 delim = separator[0]; 1232 1233 /* ensure we always start with zeroed-out smb_vol */ 1234 memset(vol, 0, sizeof(*vol)); 1235 1236 /* 1237 * does not have to be perfect mapping since field is 1238 * informational, only used for servers that do not support 1239 * port 445 and it can be overridden at mount time 1240 */ 1241 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN); 1242 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++) 1243 vol->source_rfc1001_name[i] = toupper(nodename[i]); 1244 1245 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0; 1246 /* null target name indicates to use *SMBSERVR default called name 1247 if we end up sending RFC1001 session initialize */ 1248 vol->target_rfc1001_name[0] = 0; 1249 vol->cred_uid = current_uid(); 1250 vol->linux_uid = current_uid(); 1251 vol->linux_gid = current_gid(); 1252 1253 /* 1254 * default to SFM style remapping of seven reserved characters 1255 * unless user overrides it or we negotiate CIFS POSIX where 1256 * it is unnecessary. Can not simultaneously use more than one mapping 1257 * since then readdir could list files that open could not open 1258 */ 1259 vol->remap = true; 1260 1261 /* default to only allowing write access to owner of the mount */ 1262 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR; 1263 1264 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */ 1265 /* default is always to request posix paths. */ 1266 vol->posix_paths = 1; 1267 /* default to using server inode numbers where available */ 1268 vol->server_ino = 1; 1269 1270 /* default is to use strict cifs caching semantics */ 1271 vol->strict_io = true; 1272 1273 vol->actimeo = CIFS_DEF_ACTIMEO; 1274 1275 /* FIXME: add autonegotiation -- for now, SMB1 is default */ 1276 vol->ops = &smb1_operations; 1277 vol->vals = &smb1_values; 1278 1279 if (!mountdata) 1280 goto cifs_parse_mount_err; 1281 1282 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL); 1283 if (!mountdata_copy) 1284 goto cifs_parse_mount_err; 1285 1286 options = mountdata_copy; 1287 end = options + strlen(options); 1288 1289 if (strncmp(options, "sep=", 4) == 0) { 1290 if (options[4] != 0) { 1291 separator[0] = options[4]; 1292 options += 5; 1293 } else { 1294 cifs_dbg(FYI, "Null separator not allowed\n"); 1295 } 1296 } 1297 vol->backupuid_specified = false; /* no backup intent for a user */ 1298 vol->backupgid_specified = false; /* no backup intent for a group */ 1299 1300 switch (cifs_parse_devname(devname, vol)) { 1301 case 0: 1302 break; 1303 case -ENOMEM: 1304 cifs_dbg(VFS, "Unable to allocate memory for devname.\n"); 1305 goto cifs_parse_mount_err; 1306 case -EINVAL: 1307 cifs_dbg(VFS, "Malformed UNC in devname.\n"); 1308 goto cifs_parse_mount_err; 1309 default: 1310 cifs_dbg(VFS, "Unknown error parsing devname.\n"); 1311 goto cifs_parse_mount_err; 1312 } 1313 1314 while ((data = strsep(&options, separator)) != NULL) { 1315 substring_t args[MAX_OPT_ARGS]; 1316 unsigned long option; 1317 int token; 1318 1319 if (!*data) 1320 continue; 1321 1322 token = match_token(data, cifs_mount_option_tokens, args); 1323 1324 switch (token) { 1325 1326 /* Ingnore the following */ 1327 case Opt_ignore: 1328 break; 1329 1330 /* Boolean values */ 1331 case Opt_user_xattr: 1332 vol->no_xattr = 0; 1333 break; 1334 case Opt_nouser_xattr: 1335 vol->no_xattr = 1; 1336 break; 1337 case Opt_forceuid: 1338 override_uid = 1; 1339 break; 1340 case Opt_noforceuid: 1341 override_uid = 0; 1342 break; 1343 case Opt_forcegid: 1344 override_gid = 1; 1345 break; 1346 case Opt_noforcegid: 1347 override_gid = 0; 1348 break; 1349 case Opt_noblocksend: 1350 vol->noblocksnd = 1; 1351 break; 1352 case Opt_noautotune: 1353 vol->noautotune = 1; 1354 break; 1355 case Opt_hard: 1356 vol->retry = 1; 1357 break; 1358 case Opt_soft: 1359 vol->retry = 0; 1360 break; 1361 case Opt_perm: 1362 vol->noperm = 0; 1363 break; 1364 case Opt_noperm: 1365 vol->noperm = 1; 1366 break; 1367 case Opt_mapchars: 1368 vol->sfu_remap = true; 1369 vol->remap = false; /* disable SFM mapping */ 1370 break; 1371 case Opt_nomapchars: 1372 vol->sfu_remap = false; 1373 break; 1374 case Opt_mapposix: 1375 vol->remap = true; 1376 vol->sfu_remap = false; /* disable SFU mapping */ 1377 break; 1378 case Opt_nomapposix: 1379 vol->remap = false; 1380 break; 1381 case Opt_sfu: 1382 vol->sfu_emul = 1; 1383 break; 1384 case Opt_nosfu: 1385 vol->sfu_emul = 0; 1386 break; 1387 case Opt_nodfs: 1388 vol->nodfs = 1; 1389 break; 1390 case Opt_posixpaths: 1391 vol->posix_paths = 1; 1392 break; 1393 case Opt_noposixpaths: 1394 vol->posix_paths = 0; 1395 break; 1396 case Opt_nounix: 1397 vol->no_linux_ext = 1; 1398 break; 1399 case Opt_nocase: 1400 vol->nocase = 1; 1401 break; 1402 case Opt_brl: 1403 vol->nobrl = 0; 1404 break; 1405 case Opt_nobrl: 1406 vol->nobrl = 1; 1407 /* 1408 * turn off mandatory locking in mode 1409 * if remote locking is turned off since the 1410 * local vfs will do advisory 1411 */ 1412 if (vol->file_mode == 1413 (S_IALLUGO & ~(S_ISUID | S_IXGRP))) 1414 vol->file_mode = S_IALLUGO; 1415 break; 1416 case Opt_forcemandatorylock: 1417 vol->mand_lock = 1; 1418 break; 1419 case Opt_setuids: 1420 vol->setuids = 1; 1421 break; 1422 case Opt_nosetuids: 1423 vol->setuids = 0; 1424 break; 1425 case Opt_dynperm: 1426 vol->dynperm = true; 1427 break; 1428 case Opt_nodynperm: 1429 vol->dynperm = false; 1430 break; 1431 case Opt_nohard: 1432 vol->retry = 0; 1433 break; 1434 case Opt_nosoft: 1435 vol->retry = 1; 1436 break; 1437 case Opt_nointr: 1438 vol->intr = 0; 1439 break; 1440 case Opt_intr: 1441 vol->intr = 1; 1442 break; 1443 case Opt_nostrictsync: 1444 vol->nostrictsync = 1; 1445 break; 1446 case Opt_strictsync: 1447 vol->nostrictsync = 0; 1448 break; 1449 case Opt_serverino: 1450 vol->server_ino = 1; 1451 break; 1452 case Opt_noserverino: 1453 vol->server_ino = 0; 1454 break; 1455 case Opt_rwpidforward: 1456 vol->rwpidforward = 1; 1457 break; 1458 case Opt_cifsacl: 1459 vol->cifs_acl = 1; 1460 break; 1461 case Opt_nocifsacl: 1462 vol->cifs_acl = 0; 1463 break; 1464 case Opt_acl: 1465 vol->no_psx_acl = 0; 1466 break; 1467 case Opt_noacl: 1468 vol->no_psx_acl = 1; 1469 break; 1470 case Opt_locallease: 1471 vol->local_lease = 1; 1472 break; 1473 case Opt_sign: 1474 vol->sign = true; 1475 break; 1476 case Opt_seal: 1477 /* we do not do the following in secFlags because seal 1478 * is a per tree connection (mount) not a per socket 1479 * or per-smb connection option in the protocol 1480 * vol->secFlg |= CIFSSEC_MUST_SEAL; 1481 */ 1482 vol->seal = 1; 1483 break; 1484 case Opt_noac: 1485 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n"); 1486 break; 1487 case Opt_fsc: 1488#ifndef CONFIG_CIFS_FSCACHE 1489 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n"); 1490 goto cifs_parse_mount_err; 1491#endif 1492 vol->fsc = true; 1493 break; 1494 case Opt_mfsymlinks: 1495 vol->mfsymlinks = true; 1496 break; 1497 case Opt_multiuser: 1498 vol->multiuser = true; 1499 break; 1500 case Opt_sloppy: 1501 sloppy = true; 1502 break; 1503 case Opt_nosharesock: 1504 vol->nosharesock = true; 1505 break; 1506 case Opt_nopersistent: 1507 vol->nopersistent = true; 1508 if (vol->persistent) { 1509 cifs_dbg(VFS, 1510 "persistenthandles mount options conflict\n"); 1511 goto cifs_parse_mount_err; 1512 } 1513 break; 1514 case Opt_persistent: 1515 vol->persistent = true; 1516 if ((vol->nopersistent) || (vol->resilient)) { 1517 cifs_dbg(VFS, 1518 "persistenthandles mount options conflict\n"); 1519 goto cifs_parse_mount_err; 1520 } 1521 break; 1522 case Opt_resilient: 1523 vol->resilient = true; 1524 if (vol->persistent) { 1525 cifs_dbg(VFS, 1526 "persistenthandles mount options conflict\n"); 1527 goto cifs_parse_mount_err; 1528 } 1529 break; 1530 case Opt_noresilient: 1531 vol->resilient = false; /* already the default */ 1532 break; 1533 1534 /* Numeric Values */ 1535 case Opt_backupuid: 1536 if (get_option_uid(args, &vol->backupuid)) { 1537 cifs_dbg(VFS, "%s: Invalid backupuid value\n", 1538 __func__); 1539 goto cifs_parse_mount_err; 1540 } 1541 vol->backupuid_specified = true; 1542 break; 1543 case Opt_backupgid: 1544 if (get_option_gid(args, &vol->backupgid)) { 1545 cifs_dbg(VFS, "%s: Invalid backupgid value\n", 1546 __func__); 1547 goto cifs_parse_mount_err; 1548 } 1549 vol->backupgid_specified = true; 1550 break; 1551 case Opt_uid: 1552 if (get_option_uid(args, &vol->linux_uid)) { 1553 cifs_dbg(VFS, "%s: Invalid uid value\n", 1554 __func__); 1555 goto cifs_parse_mount_err; 1556 } 1557 uid_specified = true; 1558 break; 1559 case Opt_cruid: 1560 if (get_option_uid(args, &vol->cred_uid)) { 1561 cifs_dbg(VFS, "%s: Invalid cruid value\n", 1562 __func__); 1563 goto cifs_parse_mount_err; 1564 } 1565 break; 1566 case Opt_gid: 1567 if (get_option_gid(args, &vol->linux_gid)) { 1568 cifs_dbg(VFS, "%s: Invalid gid value\n", 1569 __func__); 1570 goto cifs_parse_mount_err; 1571 } 1572 gid_specified = true; 1573 break; 1574 case Opt_file_mode: 1575 if (get_option_ul(args, &option)) { 1576 cifs_dbg(VFS, "%s: Invalid file_mode value\n", 1577 __func__); 1578 goto cifs_parse_mount_err; 1579 } 1580 vol->file_mode = option; 1581 break; 1582 case Opt_dirmode: 1583 if (get_option_ul(args, &option)) { 1584 cifs_dbg(VFS, "%s: Invalid dir_mode value\n", 1585 __func__); 1586 goto cifs_parse_mount_err; 1587 } 1588 vol->dir_mode = option; 1589 break; 1590 case Opt_port: 1591 if (get_option_ul(args, &option) || 1592 option > USHRT_MAX) { 1593 cifs_dbg(VFS, "%s: Invalid port value\n", 1594 __func__); 1595 goto cifs_parse_mount_err; 1596 } 1597 port = (unsigned short)option; 1598 break; 1599 case Opt_rsize: 1600 if (get_option_ul(args, &option)) { 1601 cifs_dbg(VFS, "%s: Invalid rsize value\n", 1602 __func__); 1603 goto cifs_parse_mount_err; 1604 } 1605 vol->rsize = option; 1606 break; 1607 case Opt_wsize: 1608 if (get_option_ul(args, &option)) { 1609 cifs_dbg(VFS, "%s: Invalid wsize value\n", 1610 __func__); 1611 goto cifs_parse_mount_err; 1612 } 1613 vol->wsize = option; 1614 break; 1615 case Opt_actimeo: 1616 if (get_option_ul(args, &option)) { 1617 cifs_dbg(VFS, "%s: Invalid actimeo value\n", 1618 __func__); 1619 goto cifs_parse_mount_err; 1620 } 1621 vol->actimeo = HZ * option; 1622 if (vol->actimeo > CIFS_MAX_ACTIMEO) { 1623 cifs_dbg(VFS, "attribute cache timeout too large\n"); 1624 goto cifs_parse_mount_err; 1625 } 1626 break; 1627 1628 /* String Arguments */ 1629 1630 case Opt_blank_user: 1631 /* null user, ie. anonymous authentication */ 1632 vol->nullauth = 1; 1633 vol->username = NULL; 1634 break; 1635 case Opt_user: 1636 string = match_strdup(args); 1637 if (string == NULL) 1638 goto out_nomem; 1639 1640 if (strnlen(string, CIFS_MAX_USERNAME_LEN) > 1641 CIFS_MAX_USERNAME_LEN) { 1642 pr_warn("CIFS: username too long\n"); 1643 goto cifs_parse_mount_err; 1644 } 1645 1646 kfree(vol->username); 1647 vol->username = kstrdup(string, GFP_KERNEL); 1648 if (!vol->username) 1649 goto cifs_parse_mount_err; 1650 break; 1651 case Opt_blank_pass: 1652 /* passwords have to be handled differently 1653 * to allow the character used for deliminator 1654 * to be passed within them 1655 */ 1656 1657 /* 1658 * Check if this is a case where the password 1659 * starts with a delimiter 1660 */ 1661 tmp_end = strchr(data, '='); 1662 tmp_end++; 1663 if (!(tmp_end < end && tmp_end[1] == delim)) { 1664 /* No it is not. Set the password to NULL */ 1665 kfree(vol->password); 1666 vol->password = NULL; 1667 break; 1668 } 1669 /* Yes it is. Drop down to Opt_pass below.*/ 1670 case Opt_pass: 1671 /* Obtain the value string */ 1672 value = strchr(data, '='); 1673 value++; 1674 1675 /* Set tmp_end to end of the string */ 1676 tmp_end = (char *) value + strlen(value); 1677 1678 /* Check if following character is the deliminator 1679 * If yes, we have encountered a double deliminator 1680 * reset the NULL character to the deliminator 1681 */ 1682 if (tmp_end < end && tmp_end[1] == delim) { 1683 tmp_end[0] = delim; 1684 1685 /* Keep iterating until we get to a single 1686 * deliminator OR the end 1687 */ 1688 while ((tmp_end = strchr(tmp_end, delim)) 1689 != NULL && (tmp_end[1] == delim)) { 1690 tmp_end = (char *) &tmp_end[2]; 1691 } 1692 1693 /* Reset var options to point to next element */ 1694 if (tmp_end) { 1695 tmp_end[0] = '\0'; 1696 options = (char *) &tmp_end[1]; 1697 } else 1698 /* Reached the end of the mount option 1699 * string */ 1700 options = end; 1701 } 1702 1703 kfree(vol->password); 1704 /* Now build new password string */ 1705 temp_len = strlen(value); 1706 vol->password = kzalloc(temp_len+1, GFP_KERNEL); 1707 if (vol->password == NULL) { 1708 pr_warn("CIFS: no memory for password\n"); 1709 goto cifs_parse_mount_err; 1710 } 1711 1712 for (i = 0, j = 0; i < temp_len; i++, j++) { 1713 vol->password[j] = value[i]; 1714 if ((value[i] == delim) && 1715 value[i+1] == delim) 1716 /* skip the second deliminator */ 1717 i++; 1718 } 1719 vol->password[j] = '\0'; 1720 break; 1721 case Opt_blank_ip: 1722 /* FIXME: should this be an error instead? */ 1723 got_ip = false; 1724 break; 1725 case Opt_ip: 1726 string = match_strdup(args); 1727 if (string == NULL) 1728 goto out_nomem; 1729 1730 if (!cifs_convert_address(dstaddr, string, 1731 strlen(string))) { 1732 pr_err("CIFS: bad ip= option (%s).\n", string); 1733 goto cifs_parse_mount_err; 1734 } 1735 got_ip = true; 1736 break; 1737 case Opt_domain: 1738 string = match_strdup(args); 1739 if (string == NULL) 1740 goto out_nomem; 1741 1742 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN) 1743 == CIFS_MAX_DOMAINNAME_LEN) { 1744 pr_warn("CIFS: domain name too long\n"); 1745 goto cifs_parse_mount_err; 1746 } 1747 1748 kfree(vol->domainname); 1749 vol->domainname = kstrdup(string, GFP_KERNEL); 1750 if (!vol->domainname) { 1751 pr_warn("CIFS: no memory for domainname\n"); 1752 goto cifs_parse_mount_err; 1753 } 1754 cifs_dbg(FYI, "Domain name set\n"); 1755 break; 1756 case Opt_srcaddr: 1757 string = match_strdup(args); 1758 if (string == NULL) 1759 goto out_nomem; 1760 1761 if (!cifs_convert_address( 1762 (struct sockaddr *)&vol->srcaddr, 1763 string, strlen(string))) { 1764 pr_warn("CIFS: Could not parse srcaddr: %s\n", 1765 string); 1766 goto cifs_parse_mount_err; 1767 } 1768 break; 1769 case Opt_iocharset: 1770 string = match_strdup(args); 1771 if (string == NULL) 1772 goto out_nomem; 1773 1774 if (strnlen(string, 1024) >= 65) { 1775 pr_warn("CIFS: iocharset name too long.\n"); 1776 goto cifs_parse_mount_err; 1777 } 1778 1779 if (strncasecmp(string, "default", 7) != 0) { 1780 kfree(vol->iocharset); 1781 vol->iocharset = kstrdup(string, 1782 GFP_KERNEL); 1783 if (!vol->iocharset) { 1784 pr_warn("CIFS: no memory for charset\n"); 1785 goto cifs_parse_mount_err; 1786 } 1787 } 1788 /* if iocharset not set then load_nls_default 1789 * is used by caller 1790 */ 1791 cifs_dbg(FYI, "iocharset set to %s\n", string); 1792 break; 1793 case Opt_netbiosname: 1794 string = match_strdup(args); 1795 if (string == NULL) 1796 goto out_nomem; 1797 1798 memset(vol->source_rfc1001_name, 0x20, 1799 RFC1001_NAME_LEN); 1800 /* 1801 * FIXME: are there cases in which a comma can 1802 * be valid in workstation netbios name (and 1803 * need special handling)? 1804 */ 1805 for (i = 0; i < RFC1001_NAME_LEN; i++) { 1806 /* don't ucase netbiosname for user */ 1807 if (string[i] == 0) 1808 break; 1809 vol->source_rfc1001_name[i] = string[i]; 1810 } 1811 /* The string has 16th byte zero still from 1812 * set at top of the function 1813 */ 1814 if (i == RFC1001_NAME_LEN && string[i] != 0) 1815 pr_warn("CIFS: netbiosname longer than 15 truncated.\n"); 1816 break; 1817 case Opt_servern: 1818 /* servernetbiosname specified override *SMBSERVER */ 1819 string = match_strdup(args); 1820 if (string == NULL) 1821 goto out_nomem; 1822 1823 /* last byte, type, is 0x20 for servr type */ 1824 memset(vol->target_rfc1001_name, 0x20, 1825 RFC1001_NAME_LEN_WITH_NULL); 1826 1827 /* BB are there cases in which a comma can be 1828 valid in this workstation netbios name 1829 (and need special handling)? */ 1830 1831 /* user or mount helper must uppercase the 1832 netbios name */ 1833 for (i = 0; i < 15; i++) { 1834 if (string[i] == 0) 1835 break; 1836 vol->target_rfc1001_name[i] = string[i]; 1837 } 1838 /* The string has 16th byte zero still from 1839 set at top of the function */ 1840 if (i == RFC1001_NAME_LEN && string[i] != 0) 1841 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n"); 1842 break; 1843 case Opt_ver: 1844 string = match_strdup(args); 1845 if (string == NULL) 1846 goto out_nomem; 1847 1848 if (strncasecmp(string, "1", 1) == 0) { 1849 /* This is the default */ 1850 break; 1851 } 1852 /* For all other value, error */ 1853 pr_warn("CIFS: Invalid version specified\n"); 1854 goto cifs_parse_mount_err; 1855 case Opt_vers: 1856 string = match_strdup(args); 1857 if (string == NULL) 1858 goto out_nomem; 1859 1860 if (cifs_parse_smb_version(string, vol) != 0) 1861 goto cifs_parse_mount_err; 1862 break; 1863 case Opt_sec: 1864 string = match_strdup(args); 1865 if (string == NULL) 1866 goto out_nomem; 1867 1868 if (cifs_parse_security_flavors(string, vol) != 0) 1869 goto cifs_parse_mount_err; 1870 break; 1871 case Opt_cache: 1872 string = match_strdup(args); 1873 if (string == NULL) 1874 goto out_nomem; 1875 1876 if (cifs_parse_cache_flavor(string, vol) != 0) 1877 goto cifs_parse_mount_err; 1878 break; 1879 default: 1880 /* 1881 * An option we don't recognize. Save it off for later 1882 * if we haven't already found one 1883 */ 1884 if (!invalid) 1885 invalid = data; 1886 break; 1887 } 1888 /* Free up any allocated string */ 1889 kfree(string); 1890 string = NULL; 1891 } 1892 1893 if (!sloppy && invalid) { 1894 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid); 1895 goto cifs_parse_mount_err; 1896 } 1897 1898#ifndef CONFIG_KEYS 1899 /* Muliuser mounts require CONFIG_KEYS support */ 1900 if (vol->multiuser) { 1901 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n"); 1902 goto cifs_parse_mount_err; 1903 } 1904#endif 1905 if (!vol->UNC) { 1906 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n"); 1907 goto cifs_parse_mount_err; 1908 } 1909 1910 /* make sure UNC has a share name */ 1911 if (!strchr(vol->UNC + 3, '\\')) { 1912 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n"); 1913 goto cifs_parse_mount_err; 1914 } 1915 1916 if (!got_ip) { 1917 /* No ip= option specified? Try to get it from UNC */ 1918 if (!cifs_convert_address(dstaddr, &vol->UNC[2], 1919 strlen(&vol->UNC[2]))) { 1920 pr_err("Unable to determine destination address.\n"); 1921 goto cifs_parse_mount_err; 1922 } 1923 } 1924 1925 /* set the port that we got earlier */ 1926 cifs_set_port(dstaddr, port); 1927 1928 if (uid_specified) 1929 vol->override_uid = override_uid; 1930 else if (override_uid == 1) 1931 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n"); 1932 1933 if (gid_specified) 1934 vol->override_gid = override_gid; 1935 else if (override_gid == 1) 1936 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n"); 1937 1938 kfree(mountdata_copy); 1939 return 0; 1940 1941out_nomem: 1942 pr_warn("Could not allocate temporary buffer\n"); 1943cifs_parse_mount_err: 1944 kfree(string); 1945 kfree(mountdata_copy); 1946 return 1; 1947} 1948 1949/** Returns true if srcaddr isn't specified and rhs isn't 1950 * specified, or if srcaddr is specified and 1951 * matches the IP address of the rhs argument. 1952 */ 1953static bool 1954srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs) 1955{ 1956 switch (srcaddr->sa_family) { 1957 case AF_UNSPEC: 1958 return (rhs->sa_family == AF_UNSPEC); 1959 case AF_INET: { 1960 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr; 1961 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs; 1962 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr); 1963 } 1964 case AF_INET6: { 1965 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr; 1966 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs; 1967 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr); 1968 } 1969 default: 1970 WARN_ON(1); 1971 return false; /* don't expect to be here */ 1972 } 1973} 1974 1975/* 1976 * If no port is specified in addr structure, we try to match with 445 port 1977 * and if it fails - with 139 ports. It should be called only if address 1978 * families of server and addr are equal. 1979 */ 1980static bool 1981match_port(struct TCP_Server_Info *server, struct sockaddr *addr) 1982{ 1983 __be16 port, *sport; 1984 1985 switch (addr->sa_family) { 1986 case AF_INET: 1987 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port; 1988 port = ((struct sockaddr_in *) addr)->sin_port; 1989 break; 1990 case AF_INET6: 1991 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port; 1992 port = ((struct sockaddr_in6 *) addr)->sin6_port; 1993 break; 1994 default: 1995 WARN_ON(1); 1996 return false; 1997 } 1998 1999 if (!port) { 2000 port = htons(CIFS_PORT); 2001 if (port == *sport) 2002 return true; 2003 2004 port = htons(RFC1001_PORT); 2005 } 2006 2007 return port == *sport; 2008} 2009 2010static bool 2011match_address(struct TCP_Server_Info *server, struct sockaddr *addr, 2012 struct sockaddr *srcaddr) 2013{ 2014 switch (addr->sa_family) { 2015 case AF_INET: { 2016 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr; 2017 struct sockaddr_in *srv_addr4 = 2018 (struct sockaddr_in *)&server->dstaddr; 2019 2020 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr) 2021 return false; 2022 break; 2023 } 2024 case AF_INET6: { 2025 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr; 2026 struct sockaddr_in6 *srv_addr6 = 2027 (struct sockaddr_in6 *)&server->dstaddr; 2028 2029 if (!ipv6_addr_equal(&addr6->sin6_addr, 2030 &srv_addr6->sin6_addr)) 2031 return false; 2032 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id) 2033 return false; 2034 break; 2035 } 2036 default: 2037 WARN_ON(1); 2038 return false; /* don't expect to be here */ 2039 } 2040 2041 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr)) 2042 return false; 2043 2044 return true; 2045} 2046 2047static bool 2048match_security(struct TCP_Server_Info *server, struct smb_vol *vol) 2049{ 2050 /* 2051 * The select_sectype function should either return the vol->sectype 2052 * that was specified, or "Unspecified" if that sectype was not 2053 * compatible with the given NEGOTIATE request. 2054 */ 2055 if (select_sectype(server, vol->sectype) == Unspecified) 2056 return false; 2057 2058 /* 2059 * Now check if signing mode is acceptable. No need to check 2060 * global_secflags at this point since if MUST_SIGN is set then 2061 * the server->sign had better be too. 2062 */ 2063 if (vol->sign && !server->sign) 2064 return false; 2065 2066 return true; 2067} 2068 2069static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol) 2070{ 2071 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr; 2072 2073 if (vol->nosharesock) 2074 return 0; 2075 2076 if ((server->vals != vol->vals) || (server->ops != vol->ops)) 2077 return 0; 2078 2079 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns)) 2080 return 0; 2081 2082 if (!match_address(server, addr, 2083 (struct sockaddr *)&vol->srcaddr)) 2084 return 0; 2085 2086 if (!match_port(server, addr)) 2087 return 0; 2088 2089 if (!match_security(server, vol)) 2090 return 0; 2091 2092 return 1; 2093} 2094 2095static struct TCP_Server_Info * 2096cifs_find_tcp_session(struct smb_vol *vol) 2097{ 2098 struct TCP_Server_Info *server; 2099 2100 spin_lock(&cifs_tcp_ses_lock); 2101 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) { 2102 if (!match_server(server, vol)) 2103 continue; 2104 2105 ++server->srv_count; 2106 spin_unlock(&cifs_tcp_ses_lock); 2107 cifs_dbg(FYI, "Existing tcp session with server found\n"); 2108 return server; 2109 } 2110 spin_unlock(&cifs_tcp_ses_lock); 2111 return NULL; 2112} 2113 2114static void 2115cifs_put_tcp_session(struct TCP_Server_Info *server) 2116{ 2117 struct task_struct *task; 2118 2119 spin_lock(&cifs_tcp_ses_lock); 2120 if (--server->srv_count > 0) { 2121 spin_unlock(&cifs_tcp_ses_lock); 2122 return; 2123 } 2124 2125 put_net(cifs_net_ns(server)); 2126 2127 list_del_init(&server->tcp_ses_list); 2128 spin_unlock(&cifs_tcp_ses_lock); 2129 2130 cancel_delayed_work_sync(&server->echo); 2131 2132 spin_lock(&GlobalMid_Lock); 2133 server->tcpStatus = CifsExiting; 2134 spin_unlock(&GlobalMid_Lock); 2135 2136 cifs_crypto_shash_release(server); 2137 cifs_fscache_release_client_cookie(server); 2138 2139 kfree(server->session_key.response); 2140 server->session_key.response = NULL; 2141 server->session_key.len = 0; 2142 2143 task = xchg(&server->tsk, NULL); 2144 if (task) 2145 force_sig(SIGKILL, task); 2146} 2147 2148static struct TCP_Server_Info * 2149cifs_get_tcp_session(struct smb_vol *volume_info) 2150{ 2151 struct TCP_Server_Info *tcp_ses = NULL; 2152 int rc; 2153 2154 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC); 2155 2156 /* see if we already have a matching tcp_ses */ 2157 tcp_ses = cifs_find_tcp_session(volume_info); 2158 if (tcp_ses) 2159 return tcp_ses; 2160 2161 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL); 2162 if (!tcp_ses) { 2163 rc = -ENOMEM; 2164 goto out_err; 2165 } 2166 2167 tcp_ses->ops = volume_info->ops; 2168 tcp_ses->vals = volume_info->vals; 2169 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns)); 2170 tcp_ses->hostname = extract_hostname(volume_info->UNC); 2171 if (IS_ERR(tcp_ses->hostname)) { 2172 rc = PTR_ERR(tcp_ses->hostname); 2173 goto out_err_crypto_release; 2174 } 2175 2176 tcp_ses->noblocksnd = volume_info->noblocksnd; 2177 tcp_ses->noautotune = volume_info->noautotune; 2178 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay; 2179 tcp_ses->in_flight = 0; 2180 tcp_ses->credits = 1; 2181 init_waitqueue_head(&tcp_ses->response_q); 2182 init_waitqueue_head(&tcp_ses->request_q); 2183 INIT_LIST_HEAD(&tcp_ses->pending_mid_q); 2184 mutex_init(&tcp_ses->srv_mutex); 2185 memcpy(tcp_ses->workstation_RFC1001_name, 2186 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL); 2187 memcpy(tcp_ses->server_RFC1001_name, 2188 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL); 2189 tcp_ses->session_estab = false; 2190 tcp_ses->sequence_number = 0; 2191 tcp_ses->lstrp = jiffies; 2192 spin_lock_init(&tcp_ses->req_lock); 2193 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list); 2194 INIT_LIST_HEAD(&tcp_ses->smb_ses_list); 2195 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request); 2196 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr, 2197 sizeof(tcp_ses->srcaddr)); 2198 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr, 2199 sizeof(tcp_ses->dstaddr)); 2200#ifdef CONFIG_CIFS_SMB2 2201 get_random_bytes(tcp_ses->client_guid, SMB2_CLIENT_GUID_SIZE); 2202#endif 2203 /* 2204 * at this point we are the only ones with the pointer 2205 * to the struct since the kernel thread not created yet 2206 * no need to spinlock this init of tcpStatus or srv_count 2207 */ 2208 tcp_ses->tcpStatus = CifsNew; 2209 ++tcp_ses->srv_count; 2210 2211 rc = ip_connect(tcp_ses); 2212 if (rc < 0) { 2213 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n"); 2214 goto out_err_crypto_release; 2215 } 2216 2217 /* 2218 * since we're in a cifs function already, we know that 2219 * this will succeed. No need for try_module_get(). 2220 */ 2221 __module_get(THIS_MODULE); 2222 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread, 2223 tcp_ses, "cifsd"); 2224 if (IS_ERR(tcp_ses->tsk)) { 2225 rc = PTR_ERR(tcp_ses->tsk); 2226 cifs_dbg(VFS, "error %d create cifsd thread\n", rc); 2227 module_put(THIS_MODULE); 2228 goto out_err_crypto_release; 2229 } 2230 tcp_ses->tcpStatus = CifsNeedNegotiate; 2231 2232 /* thread spawned, put it on the list */ 2233 spin_lock(&cifs_tcp_ses_lock); 2234 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list); 2235 spin_unlock(&cifs_tcp_ses_lock); 2236 2237 cifs_fscache_get_client_cookie(tcp_ses); 2238 2239 /* queue echo request delayed work */ 2240 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL); 2241 2242 return tcp_ses; 2243 2244out_err_crypto_release: 2245 cifs_crypto_shash_release(tcp_ses); 2246 2247 put_net(cifs_net_ns(tcp_ses)); 2248 2249out_err: 2250 if (tcp_ses) { 2251 if (!IS_ERR(tcp_ses->hostname)) 2252 kfree(tcp_ses->hostname); 2253 if (tcp_ses->ssocket) 2254 sock_release(tcp_ses->ssocket); 2255 kfree(tcp_ses); 2256 } 2257 return ERR_PTR(rc); 2258} 2259 2260static int match_session(struct cifs_ses *ses, struct smb_vol *vol) 2261{ 2262 if (vol->sectype != Unspecified && 2263 vol->sectype != ses->sectype) 2264 return 0; 2265 2266 switch (ses->sectype) { 2267 case Kerberos: 2268 if (!uid_eq(vol->cred_uid, ses->cred_uid)) 2269 return 0; 2270 break; 2271 default: 2272 /* NULL username means anonymous session */ 2273 if (ses->user_name == NULL) { 2274 if (!vol->nullauth) 2275 return 0; 2276 break; 2277 } 2278 2279 /* anything else takes username/password */ 2280 if (strncmp(ses->user_name, 2281 vol->username ? vol->username : "", 2282 CIFS_MAX_USERNAME_LEN)) 2283 return 0; 2284 if ((vol->username && strlen(vol->username) != 0) && 2285 ses->password != NULL && 2286 strncmp(ses->password, 2287 vol->password ? vol->password : "", 2288 CIFS_MAX_PASSWORD_LEN)) 2289 return 0; 2290 } 2291 return 1; 2292} 2293 2294static struct cifs_ses * 2295cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol) 2296{ 2297 struct cifs_ses *ses; 2298 2299 spin_lock(&cifs_tcp_ses_lock); 2300 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) { 2301 if (ses->status == CifsExiting) 2302 continue; 2303 if (!match_session(ses, vol)) 2304 continue; 2305 ++ses->ses_count; 2306 spin_unlock(&cifs_tcp_ses_lock); 2307 return ses; 2308 } 2309 spin_unlock(&cifs_tcp_ses_lock); 2310 return NULL; 2311} 2312 2313static void 2314cifs_put_smb_ses(struct cifs_ses *ses) 2315{ 2316 unsigned int rc, xid; 2317 struct TCP_Server_Info *server = ses->server; 2318 2319 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count); 2320 2321 spin_lock(&cifs_tcp_ses_lock); 2322 if (ses->status == CifsExiting) { 2323 spin_unlock(&cifs_tcp_ses_lock); 2324 return; 2325 } 2326 if (--ses->ses_count > 0) { 2327 spin_unlock(&cifs_tcp_ses_lock); 2328 return; 2329 } 2330 if (ses->status == CifsGood) 2331 ses->status = CifsExiting; 2332 spin_unlock(&cifs_tcp_ses_lock); 2333 2334 if (ses->status == CifsExiting && server->ops->logoff) { 2335 xid = get_xid(); 2336 rc = server->ops->logoff(xid, ses); 2337 if (rc) 2338 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n", 2339 __func__, rc); 2340 _free_xid(xid); 2341 } 2342 2343 spin_lock(&cifs_tcp_ses_lock); 2344 list_del_init(&ses->smb_ses_list); 2345 spin_unlock(&cifs_tcp_ses_lock); 2346 2347 sesInfoFree(ses); 2348 cifs_put_tcp_session(server); 2349} 2350 2351#ifdef CONFIG_KEYS 2352 2353/* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */ 2354#define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1) 2355 2356/* Populate username and pw fields from keyring if possible */ 2357static int 2358cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses) 2359{ 2360 int rc = 0; 2361 const char *delim, *payload; 2362 char *desc; 2363 ssize_t len; 2364 struct key *key; 2365 struct TCP_Server_Info *server = ses->server; 2366 struct sockaddr_in *sa; 2367 struct sockaddr_in6 *sa6; 2368 const struct user_key_payload *upayload; 2369 2370 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL); 2371 if (!desc) 2372 return -ENOMEM; 2373 2374 /* try to find an address key first */ 2375 switch (server->dstaddr.ss_family) { 2376 case AF_INET: 2377 sa = (struct sockaddr_in *)&server->dstaddr; 2378 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr); 2379 break; 2380 case AF_INET6: 2381 sa6 = (struct sockaddr_in6 *)&server->dstaddr; 2382 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr); 2383 break; 2384 default: 2385 cifs_dbg(FYI, "Bad ss_family (%hu)\n", 2386 server->dstaddr.ss_family); 2387 rc = -EINVAL; 2388 goto out_err; 2389 } 2390 2391 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc); 2392 key = request_key(&key_type_logon, desc, ""); 2393 if (IS_ERR(key)) { 2394 if (!ses->domainName) { 2395 cifs_dbg(FYI, "domainName is NULL\n"); 2396 rc = PTR_ERR(key); 2397 goto out_err; 2398 } 2399 2400 /* didn't work, try to find a domain key */ 2401 sprintf(desc, "cifs:d:%s", ses->domainName); 2402 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc); 2403 key = request_key(&key_type_logon, desc, ""); 2404 if (IS_ERR(key)) { 2405 rc = PTR_ERR(key); 2406 goto out_err; 2407 } 2408 } 2409 2410 down_read(&key->sem); 2411 upayload = user_key_payload(key); 2412 if (IS_ERR_OR_NULL(upayload)) { 2413 rc = upayload ? PTR_ERR(upayload) : -EINVAL; 2414 goto out_key_put; 2415 } 2416 2417 /* find first : in payload */ 2418 payload = upayload->data; 2419 delim = strnchr(payload, upayload->datalen, ':'); 2420 cifs_dbg(FYI, "payload=%s\n", payload); 2421 if (!delim) { 2422 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n", 2423 upayload->datalen); 2424 rc = -EINVAL; 2425 goto out_key_put; 2426 } 2427 2428 len = delim - payload; 2429 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) { 2430 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n", 2431 len); 2432 rc = -EINVAL; 2433 goto out_key_put; 2434 } 2435 2436 vol->username = kstrndup(payload, len, GFP_KERNEL); 2437 if (!vol->username) { 2438 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n", 2439 len); 2440 rc = -ENOMEM; 2441 goto out_key_put; 2442 } 2443 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username); 2444 2445 len = key->datalen - (len + 1); 2446 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) { 2447 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len); 2448 rc = -EINVAL; 2449 kfree(vol->username); 2450 vol->username = NULL; 2451 goto out_key_put; 2452 } 2453 2454 ++delim; 2455 vol->password = kstrndup(delim, len, GFP_KERNEL); 2456 if (!vol->password) { 2457 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n", 2458 len); 2459 rc = -ENOMEM; 2460 kfree(vol->username); 2461 vol->username = NULL; 2462 goto out_key_put; 2463 } 2464 2465out_key_put: 2466 up_read(&key->sem); 2467 key_put(key); 2468out_err: 2469 kfree(desc); 2470 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc); 2471 return rc; 2472} 2473#else /* ! CONFIG_KEYS */ 2474static inline int 2475cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)), 2476 struct cifs_ses *ses __attribute__((unused))) 2477{ 2478 return -ENOSYS; 2479} 2480#endif /* CONFIG_KEYS */ 2481 2482static struct cifs_ses * 2483cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info) 2484{ 2485 int rc = -ENOMEM; 2486 unsigned int xid; 2487 struct cifs_ses *ses; 2488 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr; 2489 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr; 2490 2491 xid = get_xid(); 2492 2493 ses = cifs_find_smb_ses(server, volume_info); 2494 if (ses) { 2495 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n", 2496 ses->status); 2497 2498 mutex_lock(&ses->session_mutex); 2499 rc = cifs_negotiate_protocol(xid, ses); 2500 if (rc) { 2501 mutex_unlock(&ses->session_mutex); 2502 /* problem -- put our ses reference */ 2503 cifs_put_smb_ses(ses); 2504 free_xid(xid); 2505 return ERR_PTR(rc); 2506 } 2507 if (ses->need_reconnect) { 2508 cifs_dbg(FYI, "Session needs reconnect\n"); 2509 rc = cifs_setup_session(xid, ses, 2510 volume_info->local_nls); 2511 if (rc) { 2512 mutex_unlock(&ses->session_mutex); 2513 /* problem -- put our reference */ 2514 cifs_put_smb_ses(ses); 2515 free_xid(xid); 2516 return ERR_PTR(rc); 2517 } 2518 } 2519 mutex_unlock(&ses->session_mutex); 2520 2521 /* existing SMB ses has a server reference already */ 2522 cifs_put_tcp_session(server); 2523 free_xid(xid); 2524 return ses; 2525 } 2526 2527 cifs_dbg(FYI, "Existing smb sess not found\n"); 2528 ses = sesInfoAlloc(); 2529 if (ses == NULL) 2530 goto get_ses_fail; 2531 2532 /* new SMB session uses our server ref */ 2533 ses->server = server; 2534 if (server->dstaddr.ss_family == AF_INET6) 2535 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr); 2536 else 2537 sprintf(ses->serverName, "%pI4", &addr->sin_addr); 2538 2539 if (volume_info->username) { 2540 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL); 2541 if (!ses->user_name) 2542 goto get_ses_fail; 2543 } 2544 2545 /* volume_info->password freed at unmount */ 2546 if (volume_info->password) { 2547 ses->password = kstrdup(volume_info->password, GFP_KERNEL); 2548 if (!ses->password) 2549 goto get_ses_fail; 2550 } 2551 if (volume_info->domainname) { 2552 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL); 2553 if (!ses->domainName) 2554 goto get_ses_fail; 2555 } 2556 ses->cred_uid = volume_info->cred_uid; 2557 ses->linux_uid = volume_info->linux_uid; 2558 2559 ses->sectype = volume_info->sectype; 2560 ses->sign = volume_info->sign; 2561 2562 mutex_lock(&ses->session_mutex); 2563 rc = cifs_negotiate_protocol(xid, ses); 2564 if (!rc) 2565 rc = cifs_setup_session(xid, ses, volume_info->local_nls); 2566 mutex_unlock(&ses->session_mutex); 2567 if (rc) 2568 goto get_ses_fail; 2569 2570 /* success, put it on the list */ 2571 spin_lock(&cifs_tcp_ses_lock); 2572 list_add(&ses->smb_ses_list, &server->smb_ses_list); 2573 spin_unlock(&cifs_tcp_ses_lock); 2574 2575 free_xid(xid); 2576 return ses; 2577 2578get_ses_fail: 2579 sesInfoFree(ses); 2580 free_xid(xid); 2581 return ERR_PTR(rc); 2582} 2583 2584static int match_tcon(struct cifs_tcon *tcon, const char *unc) 2585{ 2586 if (tcon->tidStatus == CifsExiting) 2587 return 0; 2588 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE)) 2589 return 0; 2590 return 1; 2591} 2592 2593static struct cifs_tcon * 2594cifs_find_tcon(struct cifs_ses *ses, const char *unc) 2595{ 2596 struct list_head *tmp; 2597 struct cifs_tcon *tcon; 2598 2599 spin_lock(&cifs_tcp_ses_lock); 2600 list_for_each(tmp, &ses->tcon_list) { 2601 tcon = list_entry(tmp, struct cifs_tcon, tcon_list); 2602 if (!match_tcon(tcon, unc)) 2603 continue; 2604 ++tcon->tc_count; 2605 spin_unlock(&cifs_tcp_ses_lock); 2606 return tcon; 2607 } 2608 spin_unlock(&cifs_tcp_ses_lock); 2609 return NULL; 2610} 2611 2612static void 2613cifs_put_tcon(struct cifs_tcon *tcon) 2614{ 2615 unsigned int xid; 2616 struct cifs_ses *ses = tcon->ses; 2617 2618 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count); 2619 spin_lock(&cifs_tcp_ses_lock); 2620 if (--tcon->tc_count > 0) { 2621 spin_unlock(&cifs_tcp_ses_lock); 2622 return; 2623 } 2624 2625 list_del_init(&tcon->tcon_list); 2626 spin_unlock(&cifs_tcp_ses_lock); 2627 2628 xid = get_xid(); 2629 if (ses->server->ops->tree_disconnect) 2630 ses->server->ops->tree_disconnect(xid, tcon); 2631 _free_xid(xid); 2632 2633 cifs_fscache_release_super_cookie(tcon); 2634 tconInfoFree(tcon); 2635 cifs_put_smb_ses(ses); 2636} 2637 2638static struct cifs_tcon * 2639cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info) 2640{ 2641 int rc, xid; 2642 struct cifs_tcon *tcon; 2643 2644 tcon = cifs_find_tcon(ses, volume_info->UNC); 2645 if (tcon) { 2646 cifs_dbg(FYI, "Found match on UNC path\n"); 2647 /* existing tcon already has a reference */ 2648 cifs_put_smb_ses(ses); 2649 if (tcon->seal != volume_info->seal) 2650 cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n"); 2651 return tcon; 2652 } 2653 2654 if (!ses->server->ops->tree_connect) { 2655 rc = -ENOSYS; 2656 goto out_fail; 2657 } 2658 2659 tcon = tconInfoAlloc(); 2660 if (tcon == NULL) { 2661 rc = -ENOMEM; 2662 goto out_fail; 2663 } 2664 2665 tcon->ses = ses; 2666 if (volume_info->password) { 2667 tcon->password = kstrdup(volume_info->password, GFP_KERNEL); 2668 if (!tcon->password) { 2669 rc = -ENOMEM; 2670 goto out_fail; 2671 } 2672 } 2673 2674 /* 2675 * BB Do we need to wrap session_mutex around this TCon call and Unix 2676 * SetFS as we do on SessSetup and reconnect? 2677 */ 2678 xid = get_xid(); 2679 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon, 2680 volume_info->local_nls); 2681 free_xid(xid); 2682 cifs_dbg(FYI, "Tcon rc = %d\n", rc); 2683 if (rc) 2684 goto out_fail; 2685 2686 if (volume_info->nodfs) { 2687 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS; 2688 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags); 2689 } 2690 tcon->seal = volume_info->seal; 2691 tcon->use_persistent = false; 2692 /* check if SMB2 or later, CIFS does not support persistent handles */ 2693 if (volume_info->persistent) { 2694 if (ses->server->vals->protocol_id == 0) { 2695 cifs_dbg(VFS, 2696 "SMB3 or later required for persistent handles\n"); 2697 rc = -EOPNOTSUPP; 2698 goto out_fail; 2699#ifdef CONFIG_CIFS_SMB2 2700 } else if (ses->server->capabilities & 2701 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) 2702 tcon->use_persistent = true; 2703 else /* persistent handles requested but not supported */ { 2704 cifs_dbg(VFS, 2705 "Persistent handles not supported on share\n"); 2706 rc = -EOPNOTSUPP; 2707 goto out_fail; 2708#endif /* CONFIG_CIFS_SMB2 */ 2709 } 2710#ifdef CONFIG_CIFS_SMB2 2711 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY) 2712 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) 2713 && (volume_info->nopersistent == false)) { 2714 cifs_dbg(FYI, "enabling persistent handles\n"); 2715 tcon->use_persistent = true; 2716#endif /* CONFIG_CIFS_SMB2 */ 2717 } else if (volume_info->resilient) { 2718 if (ses->server->vals->protocol_id == 0) { 2719 cifs_dbg(VFS, 2720 "SMB2.1 or later required for resilient handles\n"); 2721 rc = -EOPNOTSUPP; 2722 goto out_fail; 2723 } 2724 tcon->use_resilient = true; 2725 } 2726 2727 /* 2728 * We can have only one retry value for a connection to a share so for 2729 * resources mounted more than once to the same server share the last 2730 * value passed in for the retry flag is used. 2731 */ 2732 tcon->retry = volume_info->retry; 2733 tcon->nocase = volume_info->nocase; 2734 tcon->local_lease = volume_info->local_lease; 2735 INIT_LIST_HEAD(&tcon->pending_opens); 2736 2737 spin_lock(&cifs_tcp_ses_lock); 2738 list_add(&tcon->tcon_list, &ses->tcon_list); 2739 spin_unlock(&cifs_tcp_ses_lock); 2740 2741 cifs_fscache_get_super_cookie(tcon); 2742 2743 return tcon; 2744 2745out_fail: 2746 tconInfoFree(tcon); 2747 return ERR_PTR(rc); 2748} 2749 2750void 2751cifs_put_tlink(struct tcon_link *tlink) 2752{ 2753 if (!tlink || IS_ERR(tlink)) 2754 return; 2755 2756 if (!atomic_dec_and_test(&tlink->tl_count) || 2757 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) { 2758 tlink->tl_time = jiffies; 2759 return; 2760 } 2761 2762 if (!IS_ERR(tlink_tcon(tlink))) 2763 cifs_put_tcon(tlink_tcon(tlink)); 2764 kfree(tlink); 2765 return; 2766} 2767 2768static inline struct tcon_link * 2769cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb) 2770{ 2771 return cifs_sb->master_tlink; 2772} 2773 2774static int 2775compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data) 2776{ 2777 struct cifs_sb_info *old = CIFS_SB(sb); 2778 struct cifs_sb_info *new = mnt_data->cifs_sb; 2779 2780 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK)) 2781 return 0; 2782 2783 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) != 2784 (new->mnt_cifs_flags & CIFS_MOUNT_MASK)) 2785 return 0; 2786 2787 /* 2788 * We want to share sb only if we don't specify an r/wsize or 2789 * specified r/wsize is greater than or equal to existing one. 2790 */ 2791 if (new->wsize && new->wsize < old->wsize) 2792 return 0; 2793 2794 if (new->rsize && new->rsize < old->rsize) 2795 return 0; 2796 2797 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid)) 2798 return 0; 2799 2800 if (old->mnt_file_mode != new->mnt_file_mode || 2801 old->mnt_dir_mode != new->mnt_dir_mode) 2802 return 0; 2803 2804 if (strcmp(old->local_nls->charset, new->local_nls->charset)) 2805 return 0; 2806 2807 if (old->actimeo != new->actimeo) 2808 return 0; 2809 2810 return 1; 2811} 2812 2813int 2814cifs_match_super(struct super_block *sb, void *data) 2815{ 2816 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data; 2817 struct smb_vol *volume_info; 2818 struct cifs_sb_info *cifs_sb; 2819 struct TCP_Server_Info *tcp_srv; 2820 struct cifs_ses *ses; 2821 struct cifs_tcon *tcon; 2822 struct tcon_link *tlink; 2823 int rc = 0; 2824 2825 spin_lock(&cifs_tcp_ses_lock); 2826 cifs_sb = CIFS_SB(sb); 2827 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb)); 2828 if (IS_ERR(tlink)) { 2829 spin_unlock(&cifs_tcp_ses_lock); 2830 return rc; 2831 } 2832 tcon = tlink_tcon(tlink); 2833 ses = tcon->ses; 2834 tcp_srv = ses->server; 2835 2836 volume_info = mnt_data->vol; 2837 2838 if (!match_server(tcp_srv, volume_info) || 2839 !match_session(ses, volume_info) || 2840 !match_tcon(tcon, volume_info->UNC)) { 2841 rc = 0; 2842 goto out; 2843 } 2844 2845 rc = compare_mount_options(sb, mnt_data); 2846out: 2847 spin_unlock(&cifs_tcp_ses_lock); 2848 cifs_put_tlink(tlink); 2849 return rc; 2850} 2851 2852int 2853get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path, 2854 const struct nls_table *nls_codepage, unsigned int *num_referrals, 2855 struct dfs_info3_param **referrals, int remap) 2856{ 2857 char *temp_unc; 2858 int rc = 0; 2859 2860 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer) 2861 return -ENOSYS; 2862 2863 *num_referrals = 0; 2864 *referrals = NULL; 2865 2866 if (ses->ipc_tid == 0) { 2867 temp_unc = kmalloc(2 /* for slashes */ + 2868 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2) 2869 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL); 2870 if (temp_unc == NULL) 2871 return -ENOMEM; 2872 temp_unc[0] = '\\'; 2873 temp_unc[1] = '\\'; 2874 strcpy(temp_unc + 2, ses->serverName); 2875 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$"); 2876 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL, 2877 nls_codepage); 2878 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid); 2879 kfree(temp_unc); 2880 } 2881 if (rc == 0) 2882 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path, 2883 referrals, num_referrals, 2884 nls_codepage, remap); 2885 /* 2886 * BB - map targetUNCs to dfs_info3 structures, here or in 2887 * ses->server->ops->get_dfs_refer. 2888 */ 2889 2890 return rc; 2891} 2892 2893#ifdef CONFIG_DEBUG_LOCK_ALLOC 2894static struct lock_class_key cifs_key[2]; 2895static struct lock_class_key cifs_slock_key[2]; 2896 2897static inline void 2898cifs_reclassify_socket4(struct socket *sock) 2899{ 2900 struct sock *sk = sock->sk; 2901 BUG_ON(sock_owned_by_user(sk)); 2902 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS", 2903 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]); 2904} 2905 2906static inline void 2907cifs_reclassify_socket6(struct socket *sock) 2908{ 2909 struct sock *sk = sock->sk; 2910 BUG_ON(sock_owned_by_user(sk)); 2911 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS", 2912 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]); 2913} 2914#else 2915static inline void 2916cifs_reclassify_socket4(struct socket *sock) 2917{ 2918} 2919 2920static inline void 2921cifs_reclassify_socket6(struct socket *sock) 2922{ 2923} 2924#endif 2925 2926/* See RFC1001 section 14 on representation of Netbios names */ 2927static void rfc1002mangle(char *target, char *source, unsigned int length) 2928{ 2929 unsigned int i, j; 2930 2931 for (i = 0, j = 0; i < (length); i++) { 2932 /* mask a nibble at a time and encode */ 2933 target[j] = 'A' + (0x0F & (source[i] >> 4)); 2934 target[j+1] = 'A' + (0x0F & source[i]); 2935 j += 2; 2936 } 2937 2938} 2939 2940static int 2941bind_socket(struct TCP_Server_Info *server) 2942{ 2943 int rc = 0; 2944 if (server->srcaddr.ss_family != AF_UNSPEC) { 2945 /* Bind to the specified local IP address */ 2946 struct socket *socket = server->ssocket; 2947 rc = socket->ops->bind(socket, 2948 (struct sockaddr *) &server->srcaddr, 2949 sizeof(server->srcaddr)); 2950 if (rc < 0) { 2951 struct sockaddr_in *saddr4; 2952 struct sockaddr_in6 *saddr6; 2953 saddr4 = (struct sockaddr_in *)&server->srcaddr; 2954 saddr6 = (struct sockaddr_in6 *)&server->srcaddr; 2955 if (saddr6->sin6_family == AF_INET6) 2956 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n", 2957 &saddr6->sin6_addr, rc); 2958 else 2959 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n", 2960 &saddr4->sin_addr.s_addr, rc); 2961 } 2962 } 2963 return rc; 2964} 2965 2966static int 2967ip_rfc1001_connect(struct TCP_Server_Info *server) 2968{ 2969 int rc = 0; 2970 /* 2971 * some servers require RFC1001 sessinit before sending 2972 * negprot - BB check reconnection in case where second 2973 * sessinit is sent but no second negprot 2974 */ 2975 struct rfc1002_session_packet *ses_init_buf; 2976 struct smb_hdr *smb_buf; 2977 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet), 2978 GFP_KERNEL); 2979 if (ses_init_buf) { 2980 ses_init_buf->trailer.session_req.called_len = 32; 2981 2982 if (server->server_RFC1001_name && 2983 server->server_RFC1001_name[0] != 0) 2984 rfc1002mangle(ses_init_buf->trailer. 2985 session_req.called_name, 2986 server->server_RFC1001_name, 2987 RFC1001_NAME_LEN_WITH_NULL); 2988 else 2989 rfc1002mangle(ses_init_buf->trailer. 2990 session_req.called_name, 2991 DEFAULT_CIFS_CALLED_NAME, 2992 RFC1001_NAME_LEN_WITH_NULL); 2993 2994 ses_init_buf->trailer.session_req.calling_len = 32; 2995 2996 /* 2997 * calling name ends in null (byte 16) from old smb 2998 * convention. 2999 */ 3000 if (server->workstation_RFC1001_name[0] != 0) 3001 rfc1002mangle(ses_init_buf->trailer. 3002 session_req.calling_name, 3003 server->workstation_RFC1001_name, 3004 RFC1001_NAME_LEN_WITH_NULL); 3005 else 3006 rfc1002mangle(ses_init_buf->trailer. 3007 session_req.calling_name, 3008 "LINUX_CIFS_CLNT", 3009 RFC1001_NAME_LEN_WITH_NULL); 3010 3011 ses_init_buf->trailer.session_req.scope1 = 0; 3012 ses_init_buf->trailer.session_req.scope2 = 0; 3013 smb_buf = (struct smb_hdr *)ses_init_buf; 3014 3015 /* sizeof RFC1002_SESSION_REQUEST with no scope */ 3016 smb_buf->smb_buf_length = cpu_to_be32(0x81000044); 3017 rc = smb_send(server, smb_buf, 0x44); 3018 kfree(ses_init_buf); 3019 /* 3020 * RFC1001 layer in at least one server 3021 * requires very short break before negprot 3022 * presumably because not expecting negprot 3023 * to follow so fast. This is a simple 3024 * solution that works without 3025 * complicating the code and causes no 3026 * significant slowing down on mount 3027 * for everyone else 3028 */ 3029 usleep_range(1000, 2000); 3030 } 3031 /* 3032 * else the negprot may still work without this 3033 * even though malloc failed 3034 */ 3035 3036 return rc; 3037} 3038 3039static int 3040generic_ip_connect(struct TCP_Server_Info *server) 3041{ 3042 int rc = 0; 3043 __be16 sport; 3044 int slen, sfamily; 3045 struct socket *socket = server->ssocket; 3046 struct sockaddr *saddr; 3047 3048 saddr = (struct sockaddr *) &server->dstaddr; 3049 3050 if (server->dstaddr.ss_family == AF_INET6) { 3051 sport = ((struct sockaddr_in6 *) saddr)->sin6_port; 3052 slen = sizeof(struct sockaddr_in6); 3053 sfamily = AF_INET6; 3054 } else { 3055 sport = ((struct sockaddr_in *) saddr)->sin_port; 3056 slen = sizeof(struct sockaddr_in); 3057 sfamily = AF_INET; 3058 } 3059 3060 if (socket == NULL) { 3061 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM, 3062 IPPROTO_TCP, &socket, 1); 3063 if (rc < 0) { 3064 cifs_dbg(VFS, "Error %d creating socket\n", rc); 3065 server->ssocket = NULL; 3066 return rc; 3067 } 3068 3069 /* BB other socket options to set KEEPALIVE, NODELAY? */ 3070 cifs_dbg(FYI, "Socket created\n"); 3071 server->ssocket = socket; 3072 socket->sk->sk_allocation = GFP_NOFS; 3073 if (sfamily == AF_INET6) 3074 cifs_reclassify_socket6(socket); 3075 else 3076 cifs_reclassify_socket4(socket); 3077 } 3078 3079 rc = bind_socket(server); 3080 if (rc < 0) 3081 return rc; 3082 3083 /* 3084 * Eventually check for other socket options to change from 3085 * the default. sock_setsockopt not used because it expects 3086 * user space buffer 3087 */ 3088 socket->sk->sk_rcvtimeo = 7 * HZ; 3089 socket->sk->sk_sndtimeo = 5 * HZ; 3090 3091 /* make the bufsizes depend on wsize/rsize and max requests */ 3092 if (server->noautotune) { 3093 if (socket->sk->sk_sndbuf < (200 * 1024)) 3094 socket->sk->sk_sndbuf = 200 * 1024; 3095 if (socket->sk->sk_rcvbuf < (140 * 1024)) 3096 socket->sk->sk_rcvbuf = 140 * 1024; 3097 } 3098 3099 if (server->tcp_nodelay) { 3100 int val = 1; 3101 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY, 3102 (char *)&val, sizeof(val)); 3103 if (rc) 3104 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n", 3105 rc); 3106 } 3107 3108 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n", 3109 socket->sk->sk_sndbuf, 3110 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo); 3111 3112 rc = socket->ops->connect(socket, saddr, slen, 0); 3113 if (rc < 0) { 3114 cifs_dbg(FYI, "Error %d connecting to server\n", rc); 3115 sock_release(socket); 3116 server->ssocket = NULL; 3117 return rc; 3118 } 3119 3120 if (sport == htons(RFC1001_PORT)) 3121 rc = ip_rfc1001_connect(server); 3122 3123 return rc; 3124} 3125 3126static int 3127ip_connect(struct TCP_Server_Info *server) 3128{ 3129 __be16 *sport; 3130 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr; 3131 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr; 3132 3133 if (server->dstaddr.ss_family == AF_INET6) 3134 sport = &addr6->sin6_port; 3135 else 3136 sport = &addr->sin_port; 3137 3138 if (*sport == 0) { 3139 int rc; 3140 3141 /* try with 445 port at first */ 3142 *sport = htons(CIFS_PORT); 3143 3144 rc = generic_ip_connect(server); 3145 if (rc >= 0) 3146 return rc; 3147 3148 /* if it failed, try with 139 port */ 3149 *sport = htons(RFC1001_PORT); 3150 } 3151 3152 return generic_ip_connect(server); 3153} 3154 3155void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon, 3156 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info) 3157{ 3158 /* if we are reconnecting then should we check to see if 3159 * any requested capabilities changed locally e.g. via 3160 * remount but we can not do much about it here 3161 * if they have (even if we could detect it by the following) 3162 * Perhaps we could add a backpointer to array of sb from tcon 3163 * or if we change to make all sb to same share the same 3164 * sb as NFS - then we only have one backpointer to sb. 3165 * What if we wanted to mount the server share twice once with 3166 * and once without posixacls or posix paths? */ 3167 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability); 3168 3169 if (vol_info && vol_info->no_linux_ext) { 3170 tcon->fsUnixInfo.Capability = 0; 3171 tcon->unix_ext = 0; /* Unix Extensions disabled */ 3172 cifs_dbg(FYI, "Linux protocol extensions disabled\n"); 3173 return; 3174 } else if (vol_info) 3175 tcon->unix_ext = 1; /* Unix Extensions supported */ 3176 3177 if (tcon->unix_ext == 0) { 3178 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n"); 3179 return; 3180 } 3181 3182 if (!CIFSSMBQFSUnixInfo(xid, tcon)) { 3183 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability); 3184 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap); 3185 /* check for reconnect case in which we do not 3186 want to change the mount behavior if we can avoid it */ 3187 if (vol_info == NULL) { 3188 /* turn off POSIX ACL and PATHNAMES if not set 3189 originally at mount time */ 3190 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0) 3191 cap &= ~CIFS_UNIX_POSIX_ACL_CAP; 3192 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) { 3193 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) 3194 cifs_dbg(VFS, "POSIXPATH support change\n"); 3195 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP; 3196 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) { 3197 cifs_dbg(VFS, "possible reconnect error\n"); 3198 cifs_dbg(VFS, "server disabled POSIX path support\n"); 3199 } 3200 } 3201 3202 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP) 3203 cifs_dbg(VFS, "per-share encryption not supported yet\n"); 3204 3205 cap &= CIFS_UNIX_CAP_MASK; 3206 if (vol_info && vol_info->no_psx_acl) 3207 cap &= ~CIFS_UNIX_POSIX_ACL_CAP; 3208 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) { 3209 cifs_dbg(FYI, "negotiated posix acl support\n"); 3210 if (cifs_sb) 3211 cifs_sb->mnt_cifs_flags |= 3212 CIFS_MOUNT_POSIXACL; 3213 } 3214 3215 if (vol_info && vol_info->posix_paths == 0) 3216 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP; 3217 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) { 3218 cifs_dbg(FYI, "negotiate posix pathnames\n"); 3219 if (cifs_sb) 3220 cifs_sb->mnt_cifs_flags |= 3221 CIFS_MOUNT_POSIX_PATHS; 3222 } 3223 3224 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap); 3225#ifdef CONFIG_CIFS_DEBUG2 3226 if (cap & CIFS_UNIX_FCNTL_CAP) 3227 cifs_dbg(FYI, "FCNTL cap\n"); 3228 if (cap & CIFS_UNIX_EXTATTR_CAP) 3229 cifs_dbg(FYI, "EXTATTR cap\n"); 3230 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) 3231 cifs_dbg(FYI, "POSIX path cap\n"); 3232 if (cap & CIFS_UNIX_XATTR_CAP) 3233 cifs_dbg(FYI, "XATTR cap\n"); 3234 if (cap & CIFS_UNIX_POSIX_ACL_CAP) 3235 cifs_dbg(FYI, "POSIX ACL cap\n"); 3236 if (cap & CIFS_UNIX_LARGE_READ_CAP) 3237 cifs_dbg(FYI, "very large read cap\n"); 3238 if (cap & CIFS_UNIX_LARGE_WRITE_CAP) 3239 cifs_dbg(FYI, "very large write cap\n"); 3240 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP) 3241 cifs_dbg(FYI, "transport encryption cap\n"); 3242 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP) 3243 cifs_dbg(FYI, "mandatory transport encryption cap\n"); 3244#endif /* CIFS_DEBUG2 */ 3245 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) { 3246 if (vol_info == NULL) { 3247 cifs_dbg(FYI, "resetting capabilities failed\n"); 3248 } else 3249 cifs_dbg(VFS, "Negotiating Unix capabilities with the server failed. Consider mounting with the Unix Extensions disabled if problems are found by specifying the nounix mount option.\n"); 3250 3251 } 3252 } 3253} 3254 3255void cifs_setup_cifs_sb(struct smb_vol *pvolume_info, 3256 struct cifs_sb_info *cifs_sb) 3257{ 3258 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks); 3259 3260 spin_lock_init(&cifs_sb->tlink_tree_lock); 3261 cifs_sb->tlink_tree = RB_ROOT; 3262 3263 /* 3264 * Temporarily set r/wsize for matching superblock. If we end up using 3265 * new sb then client will later negotiate it downward if needed. 3266 */ 3267 cifs_sb->rsize = pvolume_info->rsize; 3268 cifs_sb->wsize = pvolume_info->wsize; 3269 3270 cifs_sb->mnt_uid = pvolume_info->linux_uid; 3271 cifs_sb->mnt_gid = pvolume_info->linux_gid; 3272 cifs_sb->mnt_file_mode = pvolume_info->file_mode; 3273 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode; 3274 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n", 3275 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode); 3276 3277 cifs_sb->actimeo = pvolume_info->actimeo; 3278 cifs_sb->local_nls = pvolume_info->local_nls; 3279 3280 if (pvolume_info->noperm) 3281 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM; 3282 if (pvolume_info->setuids) 3283 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID; 3284 if (pvolume_info->server_ino) 3285 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM; 3286 if (pvolume_info->remap) 3287 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR; 3288 if (pvolume_info->sfu_remap) 3289 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR; 3290 if (pvolume_info->no_xattr) 3291 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR; 3292 if (pvolume_info->sfu_emul) 3293 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL; 3294 if (pvolume_info->nobrl) 3295 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL; 3296 if (pvolume_info->nostrictsync) 3297 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC; 3298 if (pvolume_info->mand_lock) 3299 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL; 3300 if (pvolume_info->rwpidforward) 3301 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD; 3302 if (pvolume_info->cifs_acl) 3303 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL; 3304 if (pvolume_info->backupuid_specified) { 3305 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID; 3306 cifs_sb->mnt_backupuid = pvolume_info->backupuid; 3307 } 3308 if (pvolume_info->backupgid_specified) { 3309 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID; 3310 cifs_sb->mnt_backupgid = pvolume_info->backupgid; 3311 } 3312 if (pvolume_info->override_uid) 3313 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID; 3314 if (pvolume_info->override_gid) 3315 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID; 3316 if (pvolume_info->dynperm) 3317 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM; 3318 if (pvolume_info->fsc) 3319 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE; 3320 if (pvolume_info->multiuser) 3321 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER | 3322 CIFS_MOUNT_NO_PERM); 3323 if (pvolume_info->strict_io) 3324 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO; 3325 if (pvolume_info->direct_io) { 3326 cifs_dbg(FYI, "mounting share using direct i/o\n"); 3327 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO; 3328 } 3329 if (pvolume_info->mfsymlinks) { 3330 if (pvolume_info->sfu_emul) { 3331 /* 3332 * Our SFU ("Services for Unix" emulation does not allow 3333 * creating symlinks but does allow reading existing SFU 3334 * symlinks (it does allow both creating and reading SFU 3335 * style mknod and FIFOs though). When "mfsymlinks" and 3336 * "sfu" are both enabled at the same time, it allows 3337 * reading both types of symlinks, but will only create 3338 * them with mfsymlinks format. This allows better 3339 * Apple compatibility (probably better for Samba too) 3340 * while still recognizing old Windows style symlinks. 3341 */ 3342 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n"); 3343 } 3344 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS; 3345 } 3346 3347 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm)) 3348 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n"); 3349} 3350 3351static void 3352cleanup_volume_info_contents(struct smb_vol *volume_info) 3353{ 3354 kfree(volume_info->username); 3355 kzfree(volume_info->password); 3356 kfree(volume_info->UNC); 3357 kfree(volume_info->domainname); 3358 kfree(volume_info->iocharset); 3359 kfree(volume_info->prepath); 3360} 3361 3362void 3363cifs_cleanup_volume_info(struct smb_vol *volume_info) 3364{ 3365 if (!volume_info) 3366 return; 3367 cleanup_volume_info_contents(volume_info); 3368 kfree(volume_info); 3369} 3370 3371 3372#ifdef CONFIG_CIFS_DFS_UPCALL 3373/* 3374 * cifs_build_path_to_root returns full path to root when we do not have an 3375 * exiting connection (tcon) 3376 */ 3377static char * 3378build_unc_path_to_root(const struct smb_vol *vol, 3379 const struct cifs_sb_info *cifs_sb) 3380{ 3381 char *full_path, *pos; 3382 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0; 3383 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1); 3384 3385 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL); 3386 if (full_path == NULL) 3387 return ERR_PTR(-ENOMEM); 3388 3389 strncpy(full_path, vol->UNC, unc_len); 3390 pos = full_path + unc_len; 3391 3392 if (pplen) { 3393 *pos = CIFS_DIR_SEP(cifs_sb); 3394 strncpy(pos + 1, vol->prepath, pplen); 3395 pos += pplen; 3396 } 3397 3398 *pos = '\0'; /* add trailing null */ 3399 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb)); 3400 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path); 3401 return full_path; 3402} 3403 3404/* 3405 * Perform a dfs referral query for a share and (optionally) prefix 3406 * 3407 * If a referral is found, cifs_sb->mountdata will be (re-)allocated 3408 * to a string containing updated options for the submount. Otherwise it 3409 * will be left untouched. 3410 * 3411 * Returns the rc from get_dfs_path to the caller, which can be used to 3412 * determine whether there were referrals. 3413 */ 3414static int 3415expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses, 3416 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb, 3417 int check_prefix) 3418{ 3419 int rc; 3420 unsigned int num_referrals = 0; 3421 struct dfs_info3_param *referrals = NULL; 3422 char *full_path = NULL, *ref_path = NULL, *mdata = NULL; 3423 3424 full_path = build_unc_path_to_root(volume_info, cifs_sb); 3425 if (IS_ERR(full_path)) 3426 return PTR_ERR(full_path); 3427 3428 /* For DFS paths, skip the first '\' of the UNC */ 3429 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1; 3430 3431 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls, 3432 &num_referrals, &referrals, cifs_remap(cifs_sb)); 3433 3434 if (!rc && num_referrals > 0) { 3435 char *fake_devname = NULL; 3436 3437 mdata = cifs_compose_mount_options(cifs_sb->mountdata, 3438 full_path + 1, referrals, 3439 &fake_devname); 3440 3441 free_dfs_info_array(referrals, num_referrals); 3442 3443 if (IS_ERR(mdata)) { 3444 rc = PTR_ERR(mdata); 3445 mdata = NULL; 3446 } else { 3447 cleanup_volume_info_contents(volume_info); 3448 rc = cifs_setup_volume_info(volume_info, mdata, 3449 fake_devname); 3450 } 3451 kfree(fake_devname); 3452 kfree(cifs_sb->mountdata); 3453 cifs_sb->mountdata = mdata; 3454 } 3455 kfree(full_path); 3456 return rc; 3457} 3458#endif 3459 3460static int 3461cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data, 3462 const char *devname) 3463{ 3464 int rc = 0; 3465 3466 if (cifs_parse_mount_options(mount_data, devname, volume_info)) 3467 return -EINVAL; 3468 3469 if (volume_info->nullauth) { 3470 cifs_dbg(FYI, "Anonymous login\n"); 3471 kfree(volume_info->username); 3472 volume_info->username = NULL; 3473 } else if (volume_info->username) { 3474 /* BB fixme parse for domain name here */ 3475 cifs_dbg(FYI, "Username: %s\n", volume_info->username); 3476 } else { 3477 cifs_dbg(VFS, "No username specified\n"); 3478 /* In userspace mount helper we can get user name from alternate 3479 locations such as env variables and files on disk */ 3480 return -EINVAL; 3481 } 3482 3483 /* this is needed for ASCII cp to Unicode converts */ 3484 if (volume_info->iocharset == NULL) { 3485 /* load_nls_default cannot return null */ 3486 volume_info->local_nls = load_nls_default(); 3487 } else { 3488 volume_info->local_nls = load_nls(volume_info->iocharset); 3489 if (volume_info->local_nls == NULL) { 3490 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n", 3491 volume_info->iocharset); 3492 return -ELIBACC; 3493 } 3494 } 3495 3496 return rc; 3497} 3498 3499struct smb_vol * 3500cifs_get_volume_info(char *mount_data, const char *devname) 3501{ 3502 int rc; 3503 struct smb_vol *volume_info; 3504 3505 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL); 3506 if (!volume_info) 3507 return ERR_PTR(-ENOMEM); 3508 3509 rc = cifs_setup_volume_info(volume_info, mount_data, devname); 3510 if (rc) { 3511 cifs_cleanup_volume_info(volume_info); 3512 volume_info = ERR_PTR(rc); 3513 } 3514 3515 return volume_info; 3516} 3517 3518int 3519cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info) 3520{ 3521 int rc; 3522 unsigned int xid; 3523 struct cifs_ses *ses; 3524 struct cifs_tcon *tcon; 3525 struct TCP_Server_Info *server; 3526 char *full_path; 3527 struct tcon_link *tlink; 3528#ifdef CONFIG_CIFS_DFS_UPCALL 3529 int referral_walks_count = 0; 3530#endif 3531 3532 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs"); 3533 if (rc) 3534 return rc; 3535 3536#ifdef CONFIG_CIFS_DFS_UPCALL 3537try_mount_again: 3538 /* cleanup activities if we're chasing a referral */ 3539 if (referral_walks_count) { 3540 if (tcon) 3541 cifs_put_tcon(tcon); 3542 else if (ses) 3543 cifs_put_smb_ses(ses); 3544 3545 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS; 3546 3547 free_xid(xid); 3548 } 3549#endif 3550 rc = 0; 3551 tcon = NULL; 3552 ses = NULL; 3553 server = NULL; 3554 full_path = NULL; 3555 tlink = NULL; 3556 3557 xid = get_xid(); 3558 3559 /* get a reference to a tcp session */ 3560 server = cifs_get_tcp_session(volume_info); 3561 if (IS_ERR(server)) { 3562 rc = PTR_ERR(server); 3563 bdi_destroy(&cifs_sb->bdi); 3564 goto out; 3565 } 3566 3567 /* get a reference to a SMB session */ 3568 ses = cifs_get_smb_ses(server, volume_info); 3569 if (IS_ERR(ses)) { 3570 rc = PTR_ERR(ses); 3571 ses = NULL; 3572 goto mount_fail_check; 3573 } 3574 3575#ifdef CONFIG_CIFS_SMB2 3576 if ((volume_info->persistent == true) && ((ses->server->capabilities & 3577 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) { 3578 cifs_dbg(VFS, "persistent handles not supported by server\n"); 3579 rc = -EOPNOTSUPP; 3580 goto mount_fail_check; 3581 } 3582#endif /* CONFIG_CIFS_SMB2*/ 3583 3584 /* search for existing tcon to this server share */ 3585 tcon = cifs_get_tcon(ses, volume_info); 3586 if (IS_ERR(tcon)) { 3587 rc = PTR_ERR(tcon); 3588 tcon = NULL; 3589 goto remote_path_check; 3590 } 3591 3592 /* tell server which Unix caps we support */ 3593 if (cap_unix(tcon->ses)) { 3594 /* reset of caps checks mount to see if unix extensions 3595 disabled for just this mount */ 3596 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info); 3597 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) && 3598 (le64_to_cpu(tcon->fsUnixInfo.Capability) & 3599 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) { 3600 rc = -EACCES; 3601 goto mount_fail_check; 3602 } 3603 } else 3604 tcon->unix_ext = 0; /* server does not support them */ 3605 3606 /* do not care if a following call succeed - informational */ 3607 if (!tcon->ipc && server->ops->qfs_tcon) 3608 server->ops->qfs_tcon(xid, tcon); 3609 3610 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info); 3611 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info); 3612 3613 /* tune readahead according to rsize */ 3614 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE; 3615 3616remote_path_check: 3617#ifdef CONFIG_CIFS_DFS_UPCALL 3618 /* 3619 * Perform an unconditional check for whether there are DFS 3620 * referrals for this path without prefix, to provide support 3621 * for DFS referrals from w2k8 servers which don't seem to respond 3622 * with PATH_NOT_COVERED to requests that include the prefix. 3623 * Chase the referral if found, otherwise continue normally. 3624 */ 3625 if (referral_walks_count == 0) { 3626 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, 3627 false); 3628 if (!refrc) { 3629 referral_walks_count++; 3630 goto try_mount_again; 3631 } 3632 } 3633#endif 3634 3635 /* check if a whole path is not remote */ 3636 if (!rc && tcon) { 3637 if (!server->ops->is_path_accessible) { 3638 rc = -ENOSYS; 3639 goto mount_fail_check; 3640 } 3641 /* 3642 * cifs_build_path_to_root works only when we have a valid tcon 3643 */ 3644 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon); 3645 if (full_path == NULL) { 3646 rc = -ENOMEM; 3647 goto mount_fail_check; 3648 } 3649 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, 3650 full_path); 3651 if (rc != 0 && rc != -EREMOTE) { 3652 kfree(full_path); 3653 goto mount_fail_check; 3654 } 3655 kfree(full_path); 3656 } 3657 3658 /* get referral if needed */ 3659 if (rc == -EREMOTE) { 3660#ifdef CONFIG_CIFS_DFS_UPCALL 3661 if (referral_walks_count > MAX_NESTED_LINKS) { 3662 /* 3663 * BB: when we implement proper loop detection, 3664 * we will remove this check. But now we need it 3665 * to prevent an indefinite loop if 'DFS tree' is 3666 * misconfigured (i.e. has loops). 3667 */ 3668 rc = -ELOOP; 3669 goto mount_fail_check; 3670 } 3671 3672 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true); 3673 3674 if (!rc) { 3675 referral_walks_count++; 3676 goto try_mount_again; 3677 } 3678 goto mount_fail_check; 3679#else /* No DFS support, return error on mount */ 3680 rc = -EOPNOTSUPP; 3681#endif 3682 } 3683 3684 if (rc) 3685 goto mount_fail_check; 3686 3687 /* now, hang the tcon off of the superblock */ 3688 tlink = kzalloc(sizeof *tlink, GFP_KERNEL); 3689 if (tlink == NULL) { 3690 rc = -ENOMEM; 3691 goto mount_fail_check; 3692 } 3693 3694 tlink->tl_uid = ses->linux_uid; 3695 tlink->tl_tcon = tcon; 3696 tlink->tl_time = jiffies; 3697 set_bit(TCON_LINK_MASTER, &tlink->tl_flags); 3698 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags); 3699 3700 cifs_sb->master_tlink = tlink; 3701 spin_lock(&cifs_sb->tlink_tree_lock); 3702 tlink_rb_insert(&cifs_sb->tlink_tree, tlink); 3703 spin_unlock(&cifs_sb->tlink_tree_lock); 3704 3705 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks, 3706 TLINK_IDLE_EXPIRE); 3707 3708mount_fail_check: 3709 /* on error free sesinfo and tcon struct if needed */ 3710 if (rc) { 3711 /* If find_unc succeeded then rc == 0 so we can not end */ 3712 /* up accidentally freeing someone elses tcon struct */ 3713 if (tcon) 3714 cifs_put_tcon(tcon); 3715 else if (ses) 3716 cifs_put_smb_ses(ses); 3717 else 3718 cifs_put_tcp_session(server); 3719 bdi_destroy(&cifs_sb->bdi); 3720 } 3721 3722out: 3723 free_xid(xid); 3724 return rc; 3725} 3726 3727/* 3728 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon 3729 * pointer may be NULL. 3730 */ 3731int 3732CIFSTCon(const unsigned int xid, struct cifs_ses *ses, 3733 const char *tree, struct cifs_tcon *tcon, 3734 const struct nls_table *nls_codepage) 3735{ 3736 struct smb_hdr *smb_buffer; 3737 struct smb_hdr *smb_buffer_response; 3738 TCONX_REQ *pSMB; 3739 TCONX_RSP *pSMBr; 3740 unsigned char *bcc_ptr; 3741 int rc = 0; 3742 int length; 3743 __u16 bytes_left, count; 3744 3745 if (ses == NULL) 3746 return -EIO; 3747 3748 smb_buffer = cifs_buf_get(); 3749 if (smb_buffer == NULL) 3750 return -ENOMEM; 3751 3752 smb_buffer_response = smb_buffer; 3753 3754 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX, 3755 NULL /*no tid */ , 4 /*wct */ ); 3756 3757 smb_buffer->Mid = get_next_mid(ses->server); 3758 smb_buffer->Uid = ses->Suid; 3759 pSMB = (TCONX_REQ *) smb_buffer; 3760 pSMBr = (TCONX_RSP *) smb_buffer_response; 3761 3762 pSMB->AndXCommand = 0xFF; 3763 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO); 3764 bcc_ptr = &pSMB->Password[0]; 3765 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) { 3766 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */ 3767 *bcc_ptr = 0; /* password is null byte */ 3768 bcc_ptr++; /* skip password */ 3769 /* already aligned so no need to do it below */ 3770 } else { 3771 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE); 3772 /* BB FIXME add code to fail this if NTLMv2 or Kerberos 3773 specified as required (when that support is added to 3774 the vfs in the future) as only NTLM or the much 3775 weaker LANMAN (which we do not send by default) is accepted 3776 by Samba (not sure whether other servers allow 3777 NTLMv2 password here) */ 3778#ifdef CONFIG_CIFS_WEAK_PW_HASH 3779 if ((global_secflags & CIFSSEC_MAY_LANMAN) && 3780 (ses->sectype == LANMAN)) 3781 calc_lanman_hash(tcon->password, ses->server->cryptkey, 3782 ses->server->sec_mode & 3783 SECMODE_PW_ENCRYPT ? true : false, 3784 bcc_ptr); 3785 else 3786#endif /* CIFS_WEAK_PW_HASH */ 3787 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey, 3788 bcc_ptr, nls_codepage); 3789 if (rc) { 3790 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n", 3791 __func__, rc); 3792 cifs_buf_release(smb_buffer); 3793 return rc; 3794 } 3795 3796 bcc_ptr += CIFS_AUTH_RESP_SIZE; 3797 if (ses->capabilities & CAP_UNICODE) { 3798 /* must align unicode strings */ 3799 *bcc_ptr = 0; /* null byte password */ 3800 bcc_ptr++; 3801 } 3802 } 3803 3804 if (ses->server->sign) 3805 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE; 3806 3807 if (ses->capabilities & CAP_STATUS32) { 3808 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS; 3809 } 3810 if (ses->capabilities & CAP_DFS) { 3811 smb_buffer->Flags2 |= SMBFLG2_DFS; 3812 } 3813 if (ses->capabilities & CAP_UNICODE) { 3814 smb_buffer->Flags2 |= SMBFLG2_UNICODE; 3815 length = 3816 cifs_strtoUTF16((__le16 *) bcc_ptr, tree, 3817 6 /* max utf8 char length in bytes */ * 3818 (/* server len*/ + 256 /* share len */), nls_codepage); 3819 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */ 3820 bcc_ptr += 2; /* skip trailing null */ 3821 } else { /* ASCII */ 3822 strcpy(bcc_ptr, tree); 3823 bcc_ptr += strlen(tree) + 1; 3824 } 3825 strcpy(bcc_ptr, "?????"); 3826 bcc_ptr += strlen("?????"); 3827 bcc_ptr += 1; 3828 count = bcc_ptr - &pSMB->Password[0]; 3829 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu( 3830 pSMB->hdr.smb_buf_length) + count); 3831 pSMB->ByteCount = cpu_to_le16(count); 3832 3833 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length, 3834 0); 3835 3836 /* above now done in SendReceive */ 3837 if ((rc == 0) && (tcon != NULL)) { 3838 bool is_unicode; 3839 3840 tcon->tidStatus = CifsGood; 3841 tcon->need_reconnect = false; 3842 tcon->tid = smb_buffer_response->Tid; 3843 bcc_ptr = pByteArea(smb_buffer_response); 3844 bytes_left = get_bcc(smb_buffer_response); 3845 length = strnlen(bcc_ptr, bytes_left - 2); 3846 if (smb_buffer->Flags2 & SMBFLG2_UNICODE) 3847 is_unicode = true; 3848 else 3849 is_unicode = false; 3850 3851 3852 /* skip service field (NB: this field is always ASCII) */ 3853 if (length == 3) { 3854 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') && 3855 (bcc_ptr[2] == 'C')) { 3856 cifs_dbg(FYI, "IPC connection\n"); 3857 tcon->ipc = 1; 3858 } 3859 } else if (length == 2) { 3860 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) { 3861 /* the most common case */ 3862 cifs_dbg(FYI, "disk share connection\n"); 3863 } 3864 } 3865 bcc_ptr += length + 1; 3866 bytes_left -= (length + 1); 3867 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName)); 3868 3869 /* mostly informational -- no need to fail on error here */ 3870 kfree(tcon->nativeFileSystem); 3871 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr, 3872 bytes_left, is_unicode, 3873 nls_codepage); 3874 3875 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem); 3876 3877 if ((smb_buffer_response->WordCount == 3) || 3878 (smb_buffer_response->WordCount == 7)) 3879 /* field is in same location */ 3880 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport); 3881 else 3882 tcon->Flags = 0; 3883 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags); 3884 } else if ((rc == 0) && tcon == NULL) { 3885 /* all we need to save for IPC$ connection */ 3886 ses->ipc_tid = smb_buffer_response->Tid; 3887 } 3888 3889 cifs_buf_release(smb_buffer); 3890 return rc; 3891} 3892 3893static void delayed_free(struct rcu_head *p) 3894{ 3895 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu); 3896 unload_nls(sbi->local_nls); 3897 kfree(sbi); 3898} 3899 3900void 3901cifs_umount(struct cifs_sb_info *cifs_sb) 3902{ 3903 struct rb_root *root = &cifs_sb->tlink_tree; 3904 struct rb_node *node; 3905 struct tcon_link *tlink; 3906 3907 cancel_delayed_work_sync(&cifs_sb->prune_tlinks); 3908 3909 spin_lock(&cifs_sb->tlink_tree_lock); 3910 while ((node = rb_first(root))) { 3911 tlink = rb_entry(node, struct tcon_link, tl_rbnode); 3912 cifs_get_tlink(tlink); 3913 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags); 3914 rb_erase(node, root); 3915 3916 spin_unlock(&cifs_sb->tlink_tree_lock); 3917 cifs_put_tlink(tlink); 3918 spin_lock(&cifs_sb->tlink_tree_lock); 3919 } 3920 spin_unlock(&cifs_sb->tlink_tree_lock); 3921 3922 bdi_destroy(&cifs_sb->bdi); 3923 kfree(cifs_sb->mountdata); 3924 call_rcu(&cifs_sb->rcu, delayed_free); 3925} 3926 3927int 3928cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses) 3929{ 3930 int rc = 0; 3931 struct TCP_Server_Info *server = ses->server; 3932 3933 if (!server->ops->need_neg || !server->ops->negotiate) 3934 return -ENOSYS; 3935 3936 /* only send once per connect */ 3937 if (!server->ops->need_neg(server)) 3938 return 0; 3939 3940 set_credits(server, 1); 3941 3942 rc = server->ops->negotiate(xid, ses); 3943 if (rc == 0) { 3944 spin_lock(&GlobalMid_Lock); 3945 if (server->tcpStatus == CifsNeedNegotiate) 3946 server->tcpStatus = CifsGood; 3947 else 3948 rc = -EHOSTDOWN; 3949 spin_unlock(&GlobalMid_Lock); 3950 } 3951 3952 return rc; 3953} 3954 3955int 3956cifs_setup_session(const unsigned int xid, struct cifs_ses *ses, 3957 struct nls_table *nls_info) 3958{ 3959 int rc = -ENOSYS; 3960 struct TCP_Server_Info *server = ses->server; 3961 3962 ses->capabilities = server->capabilities; 3963 if (linuxExtEnabled == 0) 3964 ses->capabilities &= (~server->vals->cap_unix); 3965 3966 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n", 3967 server->sec_mode, server->capabilities, server->timeAdj); 3968 3969 if (server->ops->sess_setup) 3970 rc = server->ops->sess_setup(xid, ses, nls_info); 3971 3972 if (rc) 3973 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc); 3974 3975 return rc; 3976} 3977 3978static int 3979cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses) 3980{ 3981 vol->sectype = ses->sectype; 3982 3983 /* krb5 is special, since we don't need username or pw */ 3984 if (vol->sectype == Kerberos) 3985 return 0; 3986 3987 return cifs_set_cifscreds(vol, ses); 3988} 3989 3990static struct cifs_tcon * 3991cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid) 3992{ 3993 int rc; 3994 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb); 3995 struct cifs_ses *ses; 3996 struct cifs_tcon *tcon = NULL; 3997 struct smb_vol *vol_info; 3998 3999 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL); 4000 if (vol_info == NULL) 4001 return ERR_PTR(-ENOMEM); 4002 4003 vol_info->local_nls = cifs_sb->local_nls; 4004 vol_info->linux_uid = fsuid; 4005 vol_info->cred_uid = fsuid; 4006 vol_info->UNC = master_tcon->treeName; 4007 vol_info->retry = master_tcon->retry; 4008 vol_info->nocase = master_tcon->nocase; 4009 vol_info->local_lease = master_tcon->local_lease; 4010 vol_info->no_linux_ext = !master_tcon->unix_ext; 4011 vol_info->sectype = master_tcon->ses->sectype; 4012 vol_info->sign = master_tcon->ses->sign; 4013 4014 rc = cifs_set_vol_auth(vol_info, master_tcon->ses); 4015 if (rc) { 4016 tcon = ERR_PTR(rc); 4017 goto out; 4018 } 4019 4020 /* get a reference for the same TCP session */ 4021 spin_lock(&cifs_tcp_ses_lock); 4022 ++master_tcon->ses->server->srv_count; 4023 spin_unlock(&cifs_tcp_ses_lock); 4024 4025 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info); 4026 if (IS_ERR(ses)) { 4027 tcon = (struct cifs_tcon *)ses; 4028 cifs_put_tcp_session(master_tcon->ses->server); 4029 goto out; 4030 } 4031 4032 tcon = cifs_get_tcon(ses, vol_info); 4033 if (IS_ERR(tcon)) { 4034 cifs_put_smb_ses(ses); 4035 goto out; 4036 } 4037 4038 if (cap_unix(ses)) 4039 reset_cifs_unix_caps(0, tcon, NULL, vol_info); 4040out: 4041 kfree(vol_info->username); 4042 kfree(vol_info->password); 4043 kfree(vol_info); 4044 4045 return tcon; 4046} 4047 4048struct cifs_tcon * 4049cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb) 4050{ 4051 return tlink_tcon(cifs_sb_master_tlink(cifs_sb)); 4052} 4053 4054/* find and return a tlink with given uid */ 4055static struct tcon_link * 4056tlink_rb_search(struct rb_root *root, kuid_t uid) 4057{ 4058 struct rb_node *node = root->rb_node; 4059 struct tcon_link *tlink; 4060 4061 while (node) { 4062 tlink = rb_entry(node, struct tcon_link, tl_rbnode); 4063 4064 if (uid_gt(tlink->tl_uid, uid)) 4065 node = node->rb_left; 4066 else if (uid_lt(tlink->tl_uid, uid)) 4067 node = node->rb_right; 4068 else 4069 return tlink; 4070 } 4071 return NULL; 4072} 4073 4074/* insert a tcon_link into the tree */ 4075static void 4076tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink) 4077{ 4078 struct rb_node **new = &(root->rb_node), *parent = NULL; 4079 struct tcon_link *tlink; 4080 4081 while (*new) { 4082 tlink = rb_entry(*new, struct tcon_link, tl_rbnode); 4083 parent = *new; 4084 4085 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid)) 4086 new = &((*new)->rb_left); 4087 else 4088 new = &((*new)->rb_right); 4089 } 4090 4091 rb_link_node(&new_tlink->tl_rbnode, parent, new); 4092 rb_insert_color(&new_tlink->tl_rbnode, root); 4093} 4094 4095/* 4096 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the 4097 * current task. 4098 * 4099 * If the superblock doesn't refer to a multiuser mount, then just return 4100 * the master tcon for the mount. 4101 * 4102 * First, search the rbtree for an existing tcon for this fsuid. If one 4103 * exists, then check to see if it's pending construction. If it is then wait 4104 * for construction to complete. Once it's no longer pending, check to see if 4105 * it failed and either return an error or retry construction, depending on 4106 * the timeout. 4107 * 4108 * If one doesn't exist then insert a new tcon_link struct into the tree and 4109 * try to construct a new one. 4110 */ 4111struct tcon_link * 4112cifs_sb_tlink(struct cifs_sb_info *cifs_sb) 4113{ 4114 int ret; 4115 kuid_t fsuid = current_fsuid(); 4116 struct tcon_link *tlink, *newtlink; 4117 4118 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)) 4119 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb)); 4120 4121 spin_lock(&cifs_sb->tlink_tree_lock); 4122 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid); 4123 if (tlink) 4124 cifs_get_tlink(tlink); 4125 spin_unlock(&cifs_sb->tlink_tree_lock); 4126 4127 if (tlink == NULL) { 4128 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL); 4129 if (newtlink == NULL) 4130 return ERR_PTR(-ENOMEM); 4131 newtlink->tl_uid = fsuid; 4132 newtlink->tl_tcon = ERR_PTR(-EACCES); 4133 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags); 4134 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags); 4135 cifs_get_tlink(newtlink); 4136 4137 spin_lock(&cifs_sb->tlink_tree_lock); 4138 /* was one inserted after previous search? */ 4139 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid); 4140 if (tlink) { 4141 cifs_get_tlink(tlink); 4142 spin_unlock(&cifs_sb->tlink_tree_lock); 4143 kfree(newtlink); 4144 goto wait_for_construction; 4145 } 4146 tlink = newtlink; 4147 tlink_rb_insert(&cifs_sb->tlink_tree, tlink); 4148 spin_unlock(&cifs_sb->tlink_tree_lock); 4149 } else { 4150wait_for_construction: 4151 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING, 4152 TASK_INTERRUPTIBLE); 4153 if (ret) { 4154 cifs_put_tlink(tlink); 4155 return ERR_PTR(-ERESTARTSYS); 4156 } 4157 4158 /* if it's good, return it */ 4159 if (!IS_ERR(tlink->tl_tcon)) 4160 return tlink; 4161 4162 /* return error if we tried this already recently */ 4163 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) { 4164 cifs_put_tlink(tlink); 4165 return ERR_PTR(-EACCES); 4166 } 4167 4168 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags)) 4169 goto wait_for_construction; 4170 } 4171 4172 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid); 4173 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags); 4174 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING); 4175 4176 if (IS_ERR(tlink->tl_tcon)) { 4177 cifs_put_tlink(tlink); 4178 return ERR_PTR(-EACCES); 4179 } 4180 4181 return tlink; 4182} 4183 4184/* 4185 * periodic workqueue job that scans tcon_tree for a superblock and closes 4186 * out tcons. 4187 */ 4188static void 4189cifs_prune_tlinks(struct work_struct *work) 4190{ 4191 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info, 4192 prune_tlinks.work); 4193 struct rb_root *root = &cifs_sb->tlink_tree; 4194 struct rb_node *node = rb_first(root); 4195 struct rb_node *tmp; 4196 struct tcon_link *tlink; 4197 4198 /* 4199 * Because we drop the spinlock in the loop in order to put the tlink 4200 * it's not guarded against removal of links from the tree. The only 4201 * places that remove entries from the tree are this function and 4202 * umounts. Because this function is non-reentrant and is canceled 4203 * before umount can proceed, this is safe. 4204 */ 4205 spin_lock(&cifs_sb->tlink_tree_lock); 4206 node = rb_first(root); 4207 while (node != NULL) { 4208 tmp = node; 4209 node = rb_next(tmp); 4210 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode); 4211 4212 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) || 4213 atomic_read(&tlink->tl_count) != 0 || 4214 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies)) 4215 continue; 4216 4217 cifs_get_tlink(tlink); 4218 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags); 4219 rb_erase(tmp, root); 4220 4221 spin_unlock(&cifs_sb->tlink_tree_lock); 4222 cifs_put_tlink(tlink); 4223 spin_lock(&cifs_sb->tlink_tree_lock); 4224 } 4225 spin_unlock(&cifs_sb->tlink_tree_lock); 4226 4227 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks, 4228 TLINK_IDLE_EXPIRE); 4229} 4230