4 * Copyright (C) International Business Machines Corp., 2002,2011
5 * Author(s): Steve French (sfrench@us.ibm.com)
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.
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.
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
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>
43 #include <linux/parser.h>
47 #include "cifsproto.h"
48 #include "cifs_unicode.h"
49 #include "cifs_debug.h"
50 #include "cifs_fs_sb.h"
53 #include "rfc1002pdu.h"
57 #define RFC1001_PORT 139
59 /* SMB echo "timeout" -- FIXME: tunable? */
60 #define SMB_ECHO_INTERVAL (60 * HZ)
62 extern mempool_t *cifs_req_poolp;
64 /* FIXME: should these be tunable? */
65 #define TLINK_ERROR_EXPIRE (1 * HZ)
66 #define TLINK_IDLE_EXPIRE (600 * HZ)
70 /* Mount options that take no arguments */
71 Opt_user_xattr, Opt_nouser_xattr,
72 Opt_forceuid, Opt_noforceuid,
73 Opt_noblocksend, Opt_noautotune,
74 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
75 Opt_mapchars, Opt_nomapchars, Opt_sfu,
76 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
77 Opt_noposixpaths, Opt_nounix,
80 Opt_forcemandatorylock, Opt_setuids,
81 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
82 Opt_nohard, Opt_nosoft,
84 Opt_nostrictsync, Opt_strictsync,
85 Opt_serverino, Opt_noserverino,
86 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
87 Opt_acl, Opt_noacl, Opt_locallease,
88 Opt_sign, Opt_seal, Opt_direct,
89 Opt_strictcache, Opt_noac,
90 Opt_fsc, Opt_mfsymlinks,
91 Opt_multiuser, Opt_sloppy,
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,
99 /* Mount options which take string value */
100 Opt_user, Opt_pass, Opt_ip,
102 Opt_srcaddr, Opt_prefixpath,
103 Opt_iocharset, Opt_sockopt,
104 Opt_netbiosname, Opt_servern,
105 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
107 /* Mount options to be ignored */
110 /* Options which could be blank */
118 static const match_table_t cifs_mount_option_tokens = {
120 { Opt_user_xattr, "user_xattr" },
121 { Opt_nouser_xattr, "nouser_xattr" },
122 { Opt_forceuid, "forceuid" },
123 { Opt_noforceuid, "noforceuid" },
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" },
131 { Opt_nomapchars, "nomapchars" },
133 { Opt_nosfu, "nosfu" },
134 { Opt_nodfs, "nodfs" },
135 { Opt_posixpaths, "posixpaths" },
136 { Opt_noposixpaths, "noposixpaths" },
137 { Opt_nounix, "nounix" },
138 { Opt_nounix, "nolinux" },
139 { Opt_nocase, "nocase" },
140 { Opt_nocase, "ignorecase" },
142 { Opt_nobrl, "nobrl" },
143 { Opt_nobrl, "nolock" },
144 { Opt_forcemandatorylock, "forcemandatorylock" },
145 { Opt_forcemandatorylock, "forcemand" },
146 { Opt_setuids, "setuids" },
147 { Opt_nosetuids, "nosetuids" },
148 { Opt_dynperm, "dynperm" },
149 { Opt_nodynperm, "nodynperm" },
150 { Opt_nohard, "nohard" },
151 { Opt_nosoft, "nosoft" },
152 { Opt_nointr, "nointr" },
153 { Opt_intr, "intr" },
154 { Opt_nostrictsync, "nostrictsync" },
155 { Opt_strictsync, "strictsync" },
156 { Opt_serverino, "serverino" },
157 { Opt_noserverino, "noserverino" },
158 { Opt_rwpidforward, "rwpidforward" },
159 { Opt_cifsacl, "cifsacl" },
160 { Opt_nocifsacl, "nocifsacl" },
162 { Opt_noacl, "noacl" },
163 { Opt_locallease, "locallease" },
164 { Opt_sign, "sign" },
165 { Opt_seal, "seal" },
166 { Opt_direct, "direct" },
167 { Opt_direct, "directio" },
168 { Opt_direct, "forcedirectio" },
169 { Opt_strictcache, "strictcache" },
170 { Opt_noac, "noac" },
172 { Opt_mfsymlinks, "mfsymlinks" },
173 { Opt_multiuser, "multiuser" },
174 { Opt_sloppy, "sloppy" },
176 { Opt_backupuid, "backupuid=%s" },
177 { Opt_backupgid, "backupgid=%s" },
178 { Opt_uid, "uid=%s" },
179 { Opt_cruid, "cruid=%s" },
180 { Opt_gid, "gid=%s" },
181 { Opt_file_mode, "file_mode=%s" },
182 { Opt_dirmode, "dirmode=%s" },
183 { Opt_dirmode, "dir_mode=%s" },
184 { Opt_port, "port=%s" },
185 { Opt_rsize, "rsize=%s" },
186 { Opt_wsize, "wsize=%s" },
187 { Opt_actimeo, "actimeo=%s" },
189 { Opt_blank_user, "user=" },
190 { Opt_blank_user, "username=" },
191 { Opt_user, "user=%s" },
192 { Opt_user, "username=%s" },
193 { Opt_blank_pass, "pass=" },
194 { Opt_pass, "pass=%s" },
195 { Opt_pass, "password=%s" },
196 { Opt_blank_ip, "ip=" },
197 { Opt_blank_ip, "addr=" },
199 { Opt_ip, "addr=%s" },
200 { Opt_unc, "unc=%s" },
201 { Opt_unc, "target=%s" },
202 { Opt_unc, "path=%s" },
203 { Opt_domain, "dom=%s" },
204 { Opt_domain, "domain=%s" },
205 { Opt_domain, "workgroup=%s" },
206 { Opt_srcaddr, "srcaddr=%s" },
207 { Opt_prefixpath, "prefixpath=%s" },
208 { Opt_iocharset, "iocharset=%s" },
209 { Opt_sockopt, "sockopt=%s" },
210 { Opt_netbiosname, "netbiosname=%s" },
211 { Opt_servern, "servern=%s" },
212 { Opt_ver, "ver=%s" },
213 { Opt_vers, "vers=%s" },
214 { Opt_sec, "sec=%s" },
215 { Opt_cache, "cache=%s" },
217 { Opt_ignore, "cred" },
218 { Opt_ignore, "credentials" },
219 { Opt_ignore, "cred=%s" },
220 { Opt_ignore, "credentials=%s" },
221 { Opt_ignore, "guest" },
222 { Opt_ignore, "rw" },
223 { Opt_ignore, "ro" },
224 { Opt_ignore, "suid" },
225 { Opt_ignore, "nosuid" },
226 { Opt_ignore, "exec" },
227 { Opt_ignore, "noexec" },
228 { Opt_ignore, "nodev" },
229 { Opt_ignore, "noauto" },
230 { Opt_ignore, "dev" },
231 { Opt_ignore, "mand" },
232 { Opt_ignore, "nomand" },
233 { Opt_ignore, "_netdev" },
239 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
240 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
241 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2i,
242 Opt_sec_nontlm, Opt_sec_lanman,
248 static const match_table_t cifs_secflavor_tokens = {
249 { Opt_sec_krb5, "krb5" },
250 { Opt_sec_krb5i, "krb5i" },
251 { Opt_sec_krb5p, "krb5p" },
252 { Opt_sec_ntlmsspi, "ntlmsspi" },
253 { Opt_sec_ntlmssp, "ntlmssp" },
254 { Opt_ntlm, "ntlm" },
255 { Opt_sec_ntlmi, "ntlmi" },
256 { Opt_sec_ntlmv2i, "ntlmv2i" },
257 { Opt_sec_nontlm, "nontlm" },
258 { Opt_sec_lanman, "lanman" },
259 { Opt_sec_none, "none" },
261 { Opt_sec_err, NULL }
272 static const match_table_t cifs_cacheflavor_tokens = {
273 { Opt_cache_loose, "loose" },
274 { Opt_cache_strict, "strict" },
275 { Opt_cache_none, "none" },
276 { Opt_cache_err, NULL }
279 static const match_table_t cifs_smb_version_tokens = {
280 { Smb_1, SMB1_VERSION_STRING },
281 { Smb_21, SMB21_VERSION_STRING },
284 static int ip_connect(struct TCP_Server_Info *server);
285 static int generic_ip_connect(struct TCP_Server_Info *server);
286 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
287 static void cifs_prune_tlinks(struct work_struct *work);
288 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
289 const char *devname);
292 * cifs tcp session reconnection
294 * mark tcp session as reconnecting so temporarily locked
295 * mark all smb sessions as reconnecting for tcp session
296 * reconnect tcp session
297 * wake up waiters on reconnection? - (not needed currently)
300 cifs_reconnect(struct TCP_Server_Info *server)
303 struct list_head *tmp, *tmp2;
304 struct cifs_ses *ses;
305 struct cifs_tcon *tcon;
306 struct mid_q_entry *mid_entry;
307 struct list_head retry_list;
309 spin_lock(&GlobalMid_Lock);
310 if (server->tcpStatus == CifsExiting) {
311 /* the demux thread will exit normally
312 next time through the loop */
313 spin_unlock(&GlobalMid_Lock);
316 server->tcpStatus = CifsNeedReconnect;
317 spin_unlock(&GlobalMid_Lock);
320 cFYI(1, "Reconnecting tcp session");
322 /* before reconnecting the tcp session, mark the smb session (uid)
323 and the tid bad so they are not used until reconnected */
324 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
325 spin_lock(&cifs_tcp_ses_lock);
326 list_for_each(tmp, &server->smb_ses_list) {
327 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
328 ses->need_reconnect = true;
330 list_for_each(tmp2, &ses->tcon_list) {
331 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
332 tcon->need_reconnect = true;
335 spin_unlock(&cifs_tcp_ses_lock);
337 /* do not want to be sending data on a socket we are freeing */
338 cFYI(1, "%s: tearing down socket", __func__);
339 mutex_lock(&server->srv_mutex);
340 if (server->ssocket) {
341 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
342 server->ssocket->flags);
343 kernel_sock_shutdown(server->ssocket, SHUT_WR);
344 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
345 server->ssocket->state,
346 server->ssocket->flags);
347 sock_release(server->ssocket);
348 server->ssocket = NULL;
350 server->sequence_number = 0;
351 server->session_estab = false;
352 kfree(server->session_key.response);
353 server->session_key.response = NULL;
354 server->session_key.len = 0;
355 server->lstrp = jiffies;
356 mutex_unlock(&server->srv_mutex);
358 /* mark submitted MIDs for retry and issue callback */
359 INIT_LIST_HEAD(&retry_list);
360 cFYI(1, "%s: moving mids to private list", __func__);
361 spin_lock(&GlobalMid_Lock);
362 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
363 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
364 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
365 mid_entry->mid_state = MID_RETRY_NEEDED;
366 list_move(&mid_entry->qhead, &retry_list);
368 spin_unlock(&GlobalMid_Lock);
370 cFYI(1, "%s: issuing mid callbacks", __func__);
371 list_for_each_safe(tmp, tmp2, &retry_list) {
372 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
373 list_del_init(&mid_entry->qhead);
374 mid_entry->callback(mid_entry);
380 /* we should try only the port we connected to before */
381 rc = generic_ip_connect(server);
383 cFYI(1, "reconnect error %d", rc);
386 atomic_inc(&tcpSesReconnectCount);
387 spin_lock(&GlobalMid_Lock);
388 if (server->tcpStatus != CifsExiting)
389 server->tcpStatus = CifsNeedNegotiate;
390 spin_unlock(&GlobalMid_Lock);
392 } while (server->tcpStatus == CifsNeedReconnect);
399 0 not a transact2, or all data present
400 >0 transact2 with that much data missing
401 -EINVAL = invalid transact2
404 static int check2ndT2(char *buf)
406 struct smb_hdr *pSMB = (struct smb_hdr *)buf;
407 struct smb_t2_rsp *pSMBt;
409 __u16 total_data_size, data_in_this_rsp;
411 if (pSMB->Command != SMB_COM_TRANSACTION2)
414 /* check for plausible wct, bcc and t2 data and parm sizes */
415 /* check for parm and data offset going beyond end of smb */
416 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
417 cFYI(1, "invalid transact2 word count");
421 pSMBt = (struct smb_t2_rsp *)pSMB;
423 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
424 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
426 if (total_data_size == data_in_this_rsp)
428 else if (total_data_size < data_in_this_rsp) {
429 cFYI(1, "total data %d smaller than data in frame %d",
430 total_data_size, data_in_this_rsp);
434 remaining = total_data_size - data_in_this_rsp;
436 cFYI(1, "missing %d bytes from transact2, check next response",
438 if (total_data_size > CIFSMaxBufSize) {
439 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
440 total_data_size, CIFSMaxBufSize);
446 static int coalesce_t2(char *second_buf, struct smb_hdr *target_hdr)
448 struct smb_t2_rsp *pSMBs = (struct smb_t2_rsp *)second_buf;
449 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)target_hdr;
450 char *data_area_of_tgt;
451 char *data_area_of_src;
453 unsigned int byte_count, total_in_tgt;
454 __u16 tgt_total_cnt, src_total_cnt, total_in_src;
456 src_total_cnt = get_unaligned_le16(&pSMBs->t2_rsp.TotalDataCount);
457 tgt_total_cnt = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
459 if (tgt_total_cnt != src_total_cnt)
460 cFYI(1, "total data count of primary and secondary t2 differ "
461 "source=%hu target=%hu", src_total_cnt, tgt_total_cnt);
463 total_in_tgt = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
465 remaining = tgt_total_cnt - total_in_tgt;
468 cFYI(1, "Server sent too much data. tgt_total_cnt=%hu "
469 "total_in_tgt=%hu", tgt_total_cnt, total_in_tgt);
473 if (remaining == 0) {
474 /* nothing to do, ignore */
475 cFYI(1, "no more data remains");
479 total_in_src = get_unaligned_le16(&pSMBs->t2_rsp.DataCount);
480 if (remaining < total_in_src)
481 cFYI(1, "transact2 2nd response contains too much data");
483 /* find end of first SMB data area */
484 data_area_of_tgt = (char *)&pSMBt->hdr.Protocol +
485 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
487 /* validate target area */
488 data_area_of_src = (char *)&pSMBs->hdr.Protocol +
489 get_unaligned_le16(&pSMBs->t2_rsp.DataOffset);
491 data_area_of_tgt += total_in_tgt;
493 total_in_tgt += total_in_src;
494 /* is the result too big for the field? */
495 if (total_in_tgt > USHRT_MAX) {
496 cFYI(1, "coalesced DataCount too large (%u)", total_in_tgt);
499 put_unaligned_le16(total_in_tgt, &pSMBt->t2_rsp.DataCount);
502 byte_count = get_bcc(target_hdr);
503 byte_count += total_in_src;
504 /* is the result too big for the field? */
505 if (byte_count > USHRT_MAX) {
506 cFYI(1, "coalesced BCC too large (%u)", byte_count);
509 put_bcc(byte_count, target_hdr);
511 byte_count = be32_to_cpu(target_hdr->smb_buf_length);
512 byte_count += total_in_src;
513 /* don't allow buffer to overflow */
514 if (byte_count > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
515 cFYI(1, "coalesced BCC exceeds buffer size (%u)", byte_count);
518 target_hdr->smb_buf_length = cpu_to_be32(byte_count);
520 /* copy second buffer into end of first buffer */
521 memcpy(data_area_of_tgt, data_area_of_src, total_in_src);
523 if (remaining != total_in_src) {
524 /* more responses to go */
525 cFYI(1, "waiting for more secondary responses");
530 cFYI(1, "found the last secondary response");
535 cifs_echo_request(struct work_struct *work)
538 struct TCP_Server_Info *server = container_of(work,
539 struct TCP_Server_Info, echo.work);
542 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
543 * done, which is indicated by maxBuf != 0. Also, no need to ping if
544 * we got a response recently
546 if (server->maxBuf == 0 ||
547 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
550 rc = CIFSSMBEcho(server);
552 cFYI(1, "Unable to send echo request to server: %s",
556 queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
560 allocate_buffers(struct TCP_Server_Info *server)
562 if (!server->bigbuf) {
563 server->bigbuf = (char *)cifs_buf_get();
564 if (!server->bigbuf) {
565 cERROR(1, "No memory for large SMB response");
567 /* retry will check if exiting */
570 } else if (server->large_buf) {
571 /* we are reusing a dirty large buf, clear its start */
572 memset(server->bigbuf, 0, HEADER_SIZE(server));
575 if (!server->smallbuf) {
576 server->smallbuf = (char *)cifs_small_buf_get();
577 if (!server->smallbuf) {
578 cERROR(1, "No memory for SMB response");
580 /* retry will check if exiting */
583 /* beginning of smb buffer is cleared in our buf_get */
585 /* if existing small buf clear beginning */
586 memset(server->smallbuf, 0, HEADER_SIZE(server));
593 server_unresponsive(struct TCP_Server_Info *server)
596 * We need to wait 2 echo intervals to make sure we handle such
598 * 1s client sends a normal SMB request
599 * 2s client gets a response
600 * 30s echo workqueue job pops, and decides we got a response recently
601 * and don't need to send another
603 * 65s kernel_recvmsg times out, and we see that we haven't gotten
604 * a response in >60s.
606 if (server->tcpStatus == CifsGood &&
607 time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
608 cERROR(1, "Server %s has not responded in %d seconds. "
609 "Reconnecting...", server->hostname,
610 (2 * SMB_ECHO_INTERVAL) / HZ);
611 cifs_reconnect(server);
612 wake_up(&server->response_q);
620 * kvec_array_init - clone a kvec array, and advance into it
621 * @new: pointer to memory for cloned array
622 * @iov: pointer to original array
623 * @nr_segs: number of members in original array
624 * @bytes: number of bytes to advance into the cloned array
626 * This function will copy the array provided in iov to a section of memory
627 * and advance the specified number of bytes into the new array. It returns
628 * the number of segments in the new array. "new" must be at least as big as
629 * the original iov array.
632 kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
637 while (bytes || !iov->iov_len) {
638 int copy = min(bytes, iov->iov_len);
642 if (iov->iov_len == base) {
648 memcpy(new, iov, sizeof(*iov) * nr_segs);
649 new->iov_base += base;
650 new->iov_len -= base;
655 get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
657 struct kvec *new_iov;
659 if (server->iov && nr_segs <= server->nr_iov)
662 /* not big enough -- allocate a new one and release the old */
663 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
666 server->iov = new_iov;
667 server->nr_iov = nr_segs;
673 cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
674 unsigned int nr_segs, unsigned int to_read)
679 struct msghdr smb_msg;
682 iov = get_server_iovec(server, nr_segs);
686 smb_msg.msg_control = NULL;
687 smb_msg.msg_controllen = 0;
689 for (total_read = 0; to_read; total_read += length, to_read -= length) {
692 if (server_unresponsive(server)) {
693 total_read = -EAGAIN;
697 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
699 length = kernel_recvmsg(server->ssocket, &smb_msg,
700 iov, segs, to_read, 0);
702 if (server->tcpStatus == CifsExiting) {
703 total_read = -ESHUTDOWN;
705 } else if (server->tcpStatus == CifsNeedReconnect) {
706 cifs_reconnect(server);
707 total_read = -EAGAIN;
709 } else if (length == -ERESTARTSYS ||
713 * Minimum sleep to prevent looping, allowing socket
714 * to clear and app threads to set tcpStatus
715 * CifsNeedReconnect if server hung.
717 usleep_range(1000, 2000);
720 } else if (length <= 0) {
721 cFYI(1, "Received no data or error: expecting %d "
722 "got %d", to_read, length);
723 cifs_reconnect(server);
724 total_read = -EAGAIN;
732 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
733 unsigned int to_read)
738 iov.iov_len = to_read;
740 return cifs_readv_from_socket(server, &iov, 1, to_read);
744 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
747 * The first byte big endian of the length field,
748 * is actually not part of the length but the type
749 * with the most common, zero, as regular data.
752 case RFC1002_SESSION_MESSAGE:
753 /* Regular SMB response */
755 case RFC1002_SESSION_KEEP_ALIVE:
756 cFYI(1, "RFC 1002 session keep alive");
758 case RFC1002_POSITIVE_SESSION_RESPONSE:
759 cFYI(1, "RFC 1002 positive session response");
761 case RFC1002_NEGATIVE_SESSION_RESPONSE:
763 * We get this from Windows 98 instead of an error on
764 * SMB negprot response.
766 cFYI(1, "RFC 1002 negative session response");
767 /* give server a second to clean up */
770 * Always try 445 first on reconnect since we get NACK
771 * on some if we ever connected to port 139 (the NACK
772 * is since we do not begin with RFC1001 session
775 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
776 cifs_reconnect(server);
777 wake_up(&server->response_q);
780 cERROR(1, "RFC 1002 unknown response type 0x%x", type);
781 cifs_reconnect(server);
788 dequeue_mid(struct mid_q_entry *mid, bool malformed)
790 #ifdef CONFIG_CIFS_STATS2
791 mid->when_received = jiffies;
793 spin_lock(&GlobalMid_Lock);
795 mid->mid_state = MID_RESPONSE_RECEIVED;
797 mid->mid_state = MID_RESPONSE_MALFORMED;
798 list_del_init(&mid->qhead);
799 spin_unlock(&GlobalMid_Lock);
803 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
804 char *buf, int malformed)
806 if (malformed == 0 && check2ndT2(buf) > 0) {
807 mid->multiRsp = true;
809 /* merge response - fix up 1st*/
810 malformed = coalesce_t2(buf, mid->resp_buf);
814 /* All parts received or packet is malformed. */
815 mid->multiEnd = true;
816 return dequeue_mid(mid, malformed);
818 if (!server->large_buf) {
819 /*FIXME: switch to already allocated largebuf?*/
820 cERROR(1, "1st trans2 resp needs bigbuf");
822 /* Have first buffer */
824 mid->large_buf = true;
825 server->bigbuf = NULL;
830 mid->large_buf = server->large_buf;
831 /* Was previous buf put in mpx struct for multi-rsp? */
832 if (!mid->multiRsp) {
833 /* smb buffer will be freed by user thread */
834 if (server->large_buf)
835 server->bigbuf = NULL;
837 server->smallbuf = NULL;
839 dequeue_mid(mid, malformed);
842 static void clean_demultiplex_info(struct TCP_Server_Info *server)
846 /* take it off the list, if it's not already */
847 spin_lock(&cifs_tcp_ses_lock);
848 list_del_init(&server->tcp_ses_list);
849 spin_unlock(&cifs_tcp_ses_lock);
851 spin_lock(&GlobalMid_Lock);
852 server->tcpStatus = CifsExiting;
853 spin_unlock(&GlobalMid_Lock);
854 wake_up_all(&server->response_q);
856 /* check if we have blocked requests that need to free */
857 spin_lock(&server->req_lock);
858 if (server->credits <= 0)
860 spin_unlock(&server->req_lock);
862 * Although there should not be any requests blocked on this queue it
863 * can not hurt to be paranoid and try to wake up requests that may
864 * haven been blocked when more than 50 at time were on the wire to the
865 * same server - they now will see the session is in exit state and get
866 * out of SendReceive.
868 wake_up_all(&server->request_q);
869 /* give those requests time to exit */
872 if (server->ssocket) {
873 sock_release(server->ssocket);
874 server->ssocket = NULL;
877 if (!list_empty(&server->pending_mid_q)) {
878 struct list_head dispose_list;
879 struct mid_q_entry *mid_entry;
880 struct list_head *tmp, *tmp2;
882 INIT_LIST_HEAD(&dispose_list);
883 spin_lock(&GlobalMid_Lock);
884 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
885 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
886 cFYI(1, "Clearing mid 0x%llx", mid_entry->mid);
887 mid_entry->mid_state = MID_SHUTDOWN;
888 list_move(&mid_entry->qhead, &dispose_list);
890 spin_unlock(&GlobalMid_Lock);
892 /* now walk dispose list and issue callbacks */
893 list_for_each_safe(tmp, tmp2, &dispose_list) {
894 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
895 cFYI(1, "Callback mid 0x%llx", mid_entry->mid);
896 list_del_init(&mid_entry->qhead);
897 mid_entry->callback(mid_entry);
899 /* 1/8th of sec is more than enough time for them to exit */
903 if (!list_empty(&server->pending_mid_q)) {
905 * mpx threads have not exited yet give them at least the smb
906 * send timeout time for long ops.
908 * Due to delays on oplock break requests, we need to wait at
909 * least 45 seconds before giving up on a request getting a
910 * response and going ahead and killing cifsd.
912 cFYI(1, "Wait for exit from demultiplex thread");
915 * If threads still have not exited they are probably never
916 * coming home not much else we can do but free the memory.
920 kfree(server->hostname);
924 length = atomic_dec_return(&tcpSesAllocCount);
926 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
931 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
934 char *buf = server->smallbuf;
935 unsigned int pdu_length = get_rfc1002_length(buf);
937 /* make sure this will fit in a large buffer */
938 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
939 cERROR(1, "SMB response too long (%u bytes)",
941 cifs_reconnect(server);
942 wake_up(&server->response_q);
946 /* switch to large buffer if too big for a small one */
947 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
948 server->large_buf = true;
949 memcpy(server->bigbuf, buf, server->total_read);
950 buf = server->bigbuf;
953 /* now read the rest */
954 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
955 pdu_length - HEADER_SIZE(server) + 1 + 4);
958 server->total_read += length;
960 dump_smb(buf, server->total_read);
963 * We know that we received enough to get to the MID as we
964 * checked the pdu_length earlier. Now check to see
965 * if the rest of the header is OK. We borrow the length
966 * var for the rest of the loop to avoid a new stack var.
968 * 48 bytes is enough to display the header and a little bit
969 * into the payload for debugging purposes.
971 length = server->ops->check_message(buf, server->total_read);
973 cifs_dump_mem("Bad SMB: ", buf,
974 min_t(unsigned int, server->total_read, 48));
979 handle_mid(mid, server, buf, length);
984 cifs_demultiplex_thread(void *p)
987 struct TCP_Server_Info *server = p;
988 unsigned int pdu_length;
990 struct task_struct *task_to_wake = NULL;
991 struct mid_q_entry *mid_entry;
993 current->flags |= PF_MEMALLOC;
994 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
996 length = atomic_inc_return(&tcpSesAllocCount);
998 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
1002 while (server->tcpStatus != CifsExiting) {
1003 if (try_to_freeze())
1006 if (!allocate_buffers(server))
1009 server->large_buf = false;
1010 buf = server->smallbuf;
1011 pdu_length = 4; /* enough to get RFC1001 header */
1013 length = cifs_read_from_socket(server, buf, pdu_length);
1016 server->total_read = length;
1019 * The right amount was read from socket - 4 bytes,
1020 * so we can now interpret the length field.
1022 pdu_length = get_rfc1002_length(buf);
1024 cFYI(1, "RFC1002 header 0x%x", pdu_length);
1025 if (!is_smb_response(server, buf[0]))
1028 /* make sure we have enough to get to the MID */
1029 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
1030 cERROR(1, "SMB response too short (%u bytes)",
1032 cifs_reconnect(server);
1033 wake_up(&server->response_q);
1037 /* read down to the MID */
1038 length = cifs_read_from_socket(server, buf + 4,
1039 HEADER_SIZE(server) - 1 - 4);
1042 server->total_read += length;
1044 mid_entry = server->ops->find_mid(server, buf);
1046 if (!mid_entry || !mid_entry->receive)
1047 length = standard_receive3(server, mid_entry);
1049 length = mid_entry->receive(server, mid_entry);
1054 if (server->large_buf)
1055 buf = server->bigbuf;
1057 server->lstrp = jiffies;
1058 if (mid_entry != NULL) {
1059 if (!mid_entry->multiRsp || mid_entry->multiEnd)
1060 mid_entry->callback(mid_entry);
1061 } else if (!server->ops->is_oplock_break(buf, server)) {
1062 cERROR(1, "No task to wake, unknown frame received! "
1063 "NumMids %d", atomic_read(&midCount));
1064 cifs_dump_mem("Received Data is: ", buf,
1065 HEADER_SIZE(server));
1066 #ifdef CONFIG_CIFS_DEBUG2
1067 server->ops->dump_detail(buf);
1068 cifs_dump_mids(server);
1069 #endif /* CIFS_DEBUG2 */
1072 } /* end while !EXITING */
1074 /* buffer usually freed in free_mid - need to free it here on exit */
1075 cifs_buf_release(server->bigbuf);
1076 if (server->smallbuf) /* no sense logging a debug message if NULL */
1077 cifs_small_buf_release(server->smallbuf);
1079 task_to_wake = xchg(&server->tsk, NULL);
1080 clean_demultiplex_info(server);
1082 /* if server->tsk was NULL then wait for a signal before exiting */
1083 if (!task_to_wake) {
1084 set_current_state(TASK_INTERRUPTIBLE);
1085 while (!signal_pending(current)) {
1087 set_current_state(TASK_INTERRUPTIBLE);
1089 set_current_state(TASK_RUNNING);
1092 module_put_and_exit(0);
1095 /* extract the host portion of the UNC string */
1097 extract_hostname(const char *unc)
1103 /* skip double chars at beginning of string */
1104 /* BB: check validity of these bytes? */
1107 /* delimiter between hostname and sharename is always '\\' now */
1108 delim = strchr(src, '\\');
1110 return ERR_PTR(-EINVAL);
1113 dst = kmalloc((len + 1), GFP_KERNEL);
1115 return ERR_PTR(-ENOMEM);
1117 memcpy(dst, src, len);
1123 static int get_option_ul(substring_t args[], unsigned long *option)
1128 string = match_strdup(args);
1131 rc = kstrtoul(string, 0, option);
1138 static int cifs_parse_security_flavors(char *value,
1139 struct smb_vol *vol)
1142 substring_t args[MAX_OPT_ARGS];
1144 switch (match_token(value, cifs_secflavor_tokens, args)) {
1146 vol->secFlg |= CIFSSEC_MAY_KRB5;
1149 vol->secFlg |= CIFSSEC_MAY_KRB5 | CIFSSEC_MUST_SIGN;
1152 /* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
1153 cERROR(1, "Krb5 cifs privacy not supported");
1155 case Opt_sec_ntlmssp:
1156 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1158 case Opt_sec_ntlmsspi:
1159 vol->secFlg |= CIFSSEC_MAY_NTLMSSP | CIFSSEC_MUST_SIGN;
1162 /* ntlm is default so can be turned off too */
1163 vol->secFlg |= CIFSSEC_MAY_NTLM;
1166 vol->secFlg |= CIFSSEC_MAY_NTLM | CIFSSEC_MUST_SIGN;
1168 case Opt_sec_nontlm:
1169 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1171 case Opt_sec_ntlmv2i:
1172 vol->secFlg |= CIFSSEC_MAY_NTLMV2 | CIFSSEC_MUST_SIGN;
1174 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1175 case Opt_sec_lanman:
1176 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1183 cERROR(1, "bad security option: %s", value);
1191 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1193 substring_t args[MAX_OPT_ARGS];
1195 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1196 case Opt_cache_loose:
1197 vol->direct_io = false;
1198 vol->strict_io = false;
1200 case Opt_cache_strict:
1201 vol->direct_io = false;
1202 vol->strict_io = true;
1204 case Opt_cache_none:
1205 vol->direct_io = true;
1206 vol->strict_io = false;
1209 cERROR(1, "bad cache= option: %s", value);
1216 cifs_parse_smb_version(char *value, struct smb_vol *vol)
1218 substring_t args[MAX_OPT_ARGS];
1220 switch (match_token(value, cifs_smb_version_tokens, args)) {
1222 vol->ops = &smb1_operations;
1223 vol->vals = &smb1_values;
1225 #ifdef CONFIG_CIFS_SMB2
1227 vol->ops = &smb21_operations;
1228 vol->vals = &smb21_values;
1232 cERROR(1, "Unknown vers= option specified: %s", value);
1239 cifs_parse_mount_options(const char *mountdata, const char *devname,
1240 struct smb_vol *vol)
1243 char *mountdata_copy = NULL, *options;
1244 unsigned int temp_len, i, j;
1246 short int override_uid = -1;
1247 short int override_gid = -1;
1248 bool uid_specified = false;
1249 bool gid_specified = false;
1250 bool sloppy = false;
1251 char *invalid = NULL;
1252 char *nodename = utsname()->nodename;
1253 char *string = NULL;
1254 char *tmp_end, *value;
1256 bool cache_specified = false;
1257 static bool cache_warned = false;
1261 delim = separator[0];
1264 * does not have to be perfect mapping since field is
1265 * informational, only used for servers that do not support
1266 * port 445 and it can be overridden at mount time
1268 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1269 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1270 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1272 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1273 /* null target name indicates to use *SMBSERVR default called name
1274 if we end up sending RFC1001 session initialize */
1275 vol->target_rfc1001_name[0] = 0;
1276 vol->cred_uid = current_uid();
1277 vol->linux_uid = current_uid();
1278 vol->linux_gid = current_gid();
1280 /* default to only allowing write access to owner of the mount */
1281 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1283 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1284 /* default is always to request posix paths. */
1285 vol->posix_paths = 1;
1286 /* default to using server inode numbers where available */
1287 vol->server_ino = 1;
1289 vol->actimeo = CIFS_DEF_ACTIMEO;
1291 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1292 vol->ops = &smb1_operations;
1293 vol->vals = &smb1_values;
1296 goto cifs_parse_mount_err;
1298 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1299 if (!mountdata_copy)
1300 goto cifs_parse_mount_err;
1302 options = mountdata_copy;
1303 end = options + strlen(options);
1305 if (strncmp(options, "sep=", 4) == 0) {
1306 if (options[4] != 0) {
1307 separator[0] = options[4];
1310 cFYI(1, "Null separator not allowed");
1313 vol->backupuid_specified = false; /* no backup intent for a user */
1314 vol->backupgid_specified = false; /* no backup intent for a group */
1316 while ((data = strsep(&options, separator)) != NULL) {
1317 substring_t args[MAX_OPT_ARGS];
1318 unsigned long option;
1324 token = match_token(data, cifs_mount_option_tokens, args);
1328 /* Ingnore the following */
1332 /* Boolean values */
1333 case Opt_user_xattr:
1336 case Opt_nouser_xattr:
1342 case Opt_noforceuid:
1345 case Opt_noblocksend:
1346 vol->noblocksnd = 1;
1348 case Opt_noautotune:
1349 vol->noautotune = 1;
1366 case Opt_nomapchars:
1378 case Opt_posixpaths:
1379 vol->posix_paths = 1;
1381 case Opt_noposixpaths:
1382 vol->posix_paths = 0;
1385 vol->no_linux_ext = 1;
1396 * turn off mandatory locking in mode
1397 * if remote locking is turned off since the
1398 * local vfs will do advisory
1400 if (vol->file_mode ==
1401 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1402 vol->file_mode = S_IALLUGO;
1404 case Opt_forcemandatorylock:
1414 vol->dynperm = true;
1417 vol->dynperm = false;
1431 case Opt_nostrictsync:
1432 vol->nostrictsync = 1;
1434 case Opt_strictsync:
1435 vol->nostrictsync = 0;
1438 vol->server_ino = 1;
1440 case Opt_noserverino:
1441 vol->server_ino = 0;
1443 case Opt_rwpidforward:
1444 vol->rwpidforward = 1;
1453 vol->no_psx_acl = 0;
1456 vol->no_psx_acl = 1;
1458 case Opt_locallease:
1459 vol->local_lease = 1;
1462 vol->secFlg |= CIFSSEC_MUST_SIGN;
1465 /* we do not do the following in secFlags because seal
1466 * is a per tree connection (mount) not a per socket
1467 * or per-smb connection option in the protocol
1468 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1473 cache_specified = true;
1474 vol->direct_io = true;
1475 vol->strict_io = false;
1476 cERROR(1, "The \"directio\" option will be removed in "
1477 "3.7. Please switch to the \"cache=none\" "
1480 case Opt_strictcache:
1481 cache_specified = true;
1482 vol->direct_io = false;
1483 vol->strict_io = true;
1484 cERROR(1, "The \"strictcache\" option will be removed "
1485 "in 3.7. Please switch to the \"cache=strict\" "
1489 printk(KERN_WARNING "CIFS: Mount option noac not "
1490 "supported. Instead set "
1491 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1494 #ifndef CONFIG_CIFS_FSCACHE
1495 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1496 "kernel config option set");
1497 goto cifs_parse_mount_err;
1501 case Opt_mfsymlinks:
1502 vol->mfsymlinks = true;
1505 vol->multiuser = true;
1511 /* Numeric Values */
1513 if (get_option_ul(args, &option)) {
1514 cERROR(1, "%s: Invalid backupuid value",
1516 goto cifs_parse_mount_err;
1518 vol->backupuid = option;
1519 vol->backupuid_specified = true;
1522 if (get_option_ul(args, &option)) {
1523 cERROR(1, "%s: Invalid backupgid value",
1525 goto cifs_parse_mount_err;
1527 vol->backupgid = option;
1528 vol->backupgid_specified = true;
1531 if (get_option_ul(args, &option)) {
1532 cERROR(1, "%s: Invalid uid value",
1534 goto cifs_parse_mount_err;
1536 vol->linux_uid = option;
1537 uid_specified = true;
1540 if (get_option_ul(args, &option)) {
1541 cERROR(1, "%s: Invalid cruid value",
1543 goto cifs_parse_mount_err;
1545 vol->cred_uid = option;
1548 if (get_option_ul(args, &option)) {
1549 cERROR(1, "%s: Invalid gid value",
1551 goto cifs_parse_mount_err;
1553 vol->linux_gid = option;
1554 gid_specified = true;
1557 if (get_option_ul(args, &option)) {
1558 cERROR(1, "%s: Invalid file_mode value",
1560 goto cifs_parse_mount_err;
1562 vol->file_mode = option;
1565 if (get_option_ul(args, &option)) {
1566 cERROR(1, "%s: Invalid dir_mode value",
1568 goto cifs_parse_mount_err;
1570 vol->dir_mode = option;
1573 if (get_option_ul(args, &option)) {
1574 cERROR(1, "%s: Invalid port value",
1576 goto cifs_parse_mount_err;
1581 if (get_option_ul(args, &option)) {
1582 cERROR(1, "%s: Invalid rsize value",
1584 goto cifs_parse_mount_err;
1586 vol->rsize = option;
1589 if (get_option_ul(args, &option)) {
1590 cERROR(1, "%s: Invalid wsize value",
1592 goto cifs_parse_mount_err;
1594 vol->wsize = option;
1597 if (get_option_ul(args, &option)) {
1598 cERROR(1, "%s: Invalid actimeo value",
1600 goto cifs_parse_mount_err;
1602 vol->actimeo = HZ * option;
1603 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1604 cERROR(1, "CIFS: attribute cache"
1605 "timeout too large");
1606 goto cifs_parse_mount_err;
1610 /* String Arguments */
1612 case Opt_blank_user:
1613 /* null user, ie. anonymous authentication */
1615 vol->username = NULL;
1618 string = match_strdup(args);
1622 if (strnlen(string, MAX_USERNAME_SIZE) >
1623 MAX_USERNAME_SIZE) {
1624 printk(KERN_WARNING "CIFS: username too long\n");
1625 goto cifs_parse_mount_err;
1627 vol->username = kstrdup(string, GFP_KERNEL);
1628 if (!vol->username) {
1629 printk(KERN_WARNING "CIFS: no memory "
1631 goto cifs_parse_mount_err;
1634 case Opt_blank_pass:
1635 vol->password = NULL;
1638 /* passwords have to be handled differently
1639 * to allow the character used for deliminator
1640 * to be passed within them
1643 /* Obtain the value string */
1644 value = strchr(data, '=');
1647 /* Set tmp_end to end of the string */
1648 tmp_end = (char *) value + strlen(value);
1650 /* Check if following character is the deliminator
1651 * If yes, we have encountered a double deliminator
1652 * reset the NULL character to the deliminator
1654 if (tmp_end < end && tmp_end[1] == delim)
1657 /* Keep iterating until we get to a single deliminator
1660 while ((tmp_end = strchr(tmp_end, delim)) != NULL &&
1661 (tmp_end[1] == delim)) {
1662 tmp_end = (char *) &tmp_end[2];
1665 /* Reset var options to point to next element */
1668 options = (char *) &tmp_end[1];
1670 /* Reached the end of the mount option string */
1673 /* Now build new password string */
1674 temp_len = strlen(value);
1675 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1676 if (vol->password == NULL) {
1677 printk(KERN_WARNING "CIFS: no memory "
1679 goto cifs_parse_mount_err;
1682 for (i = 0, j = 0; i < temp_len; i++, j++) {
1683 vol->password[j] = value[i];
1684 if ((value[i] == delim) &&
1685 value[i+1] == delim)
1686 /* skip the second deliminator */
1689 vol->password[j] = '\0';
1695 string = match_strdup(args);
1699 if (strnlen(string, INET6_ADDRSTRLEN) >
1701 printk(KERN_WARNING "CIFS: ip address "
1703 goto cifs_parse_mount_err;
1705 vol->UNCip = kstrdup(string, GFP_KERNEL);
1707 printk(KERN_WARNING "CIFS: no memory "
1709 goto cifs_parse_mount_err;
1713 string = match_strdup(args);
1717 temp_len = strnlen(string, 300);
1718 if (temp_len == 300) {
1719 printk(KERN_WARNING "CIFS: UNC name too long\n");
1720 goto cifs_parse_mount_err;
1723 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1724 if (vol->UNC == NULL) {
1725 printk(KERN_WARNING "CIFS: no memory for UNC\n");
1726 goto cifs_parse_mount_err;
1728 strcpy(vol->UNC, string);
1730 if (strncmp(string, "//", 2) == 0) {
1733 } else if (strncmp(string, "\\\\", 2) != 0) {
1734 printk(KERN_WARNING "CIFS: UNC Path does not "
1735 "begin with // or \\\\\n");
1736 goto cifs_parse_mount_err;
1741 string = match_strdup(args);
1745 if (strnlen(string, 256) == 256) {
1746 printk(KERN_WARNING "CIFS: domain name too"
1748 goto cifs_parse_mount_err;
1751 vol->domainname = kstrdup(string, GFP_KERNEL);
1752 if (!vol->domainname) {
1753 printk(KERN_WARNING "CIFS: no memory "
1754 "for domainname\n");
1755 goto cifs_parse_mount_err;
1757 cFYI(1, "Domain name set");
1760 string = match_strdup(args);
1764 if (!cifs_convert_address(
1765 (struct sockaddr *)&vol->srcaddr,
1766 string, strlen(string))) {
1767 printk(KERN_WARNING "CIFS: Could not parse"
1768 " srcaddr: %s\n", string);
1769 goto cifs_parse_mount_err;
1772 case Opt_prefixpath:
1773 string = match_strdup(args);
1777 temp_len = strnlen(string, 1024);
1778 if (string[0] != '/')
1779 temp_len++; /* missing leading slash */
1780 if (temp_len > 1024) {
1781 printk(KERN_WARNING "CIFS: prefix too long\n");
1782 goto cifs_parse_mount_err;
1785 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1786 if (vol->prepath == NULL) {
1787 printk(KERN_WARNING "CIFS: no memory "
1788 "for path prefix\n");
1789 goto cifs_parse_mount_err;
1792 if (string[0] != '/') {
1793 vol->prepath[0] = '/';
1794 strcpy(vol->prepath+1, string);
1796 strcpy(vol->prepath, string);
1800 string = match_strdup(args);
1804 if (strnlen(string, 1024) >= 65) {
1805 printk(KERN_WARNING "CIFS: iocharset name "
1807 goto cifs_parse_mount_err;
1810 if (strnicmp(string, "default", 7) != 0) {
1811 vol->iocharset = kstrdup(string,
1813 if (!vol->iocharset) {
1814 printk(KERN_WARNING "CIFS: no memory"
1816 goto cifs_parse_mount_err;
1819 /* if iocharset not set then load_nls_default
1822 cFYI(1, "iocharset set to %s", string);
1825 string = match_strdup(args);
1829 if (strnicmp(string, "TCP_NODELAY", 11) == 0)
1830 vol->sockopt_tcp_nodelay = 1;
1832 case Opt_netbiosname:
1833 string = match_strdup(args);
1837 memset(vol->source_rfc1001_name, 0x20,
1840 * FIXME: are there cases in which a comma can
1841 * be valid in workstation netbios name (and
1842 * need special handling)?
1844 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1845 /* don't ucase netbiosname for user */
1848 vol->source_rfc1001_name[i] = string[i];
1850 /* The string has 16th byte zero still from
1851 * set at top of the function
1853 if (i == RFC1001_NAME_LEN && string[i] != 0)
1854 printk(KERN_WARNING "CIFS: netbiosname"
1855 " longer than 15 truncated.\n");
1859 /* servernetbiosname specified override *SMBSERVER */
1860 string = match_strdup(args);
1864 /* last byte, type, is 0x20 for servr type */
1865 memset(vol->target_rfc1001_name, 0x20,
1866 RFC1001_NAME_LEN_WITH_NULL);
1868 /* BB are there cases in which a comma can be
1869 valid in this workstation netbios name
1870 (and need special handling)? */
1872 /* user or mount helper must uppercase the
1874 for (i = 0; i < 15; i++) {
1877 vol->target_rfc1001_name[i] = string[i];
1879 /* The string has 16th byte zero still from
1880 set at top of the function */
1881 if (i == RFC1001_NAME_LEN && string[i] != 0)
1882 printk(KERN_WARNING "CIFS: server net"
1883 "biosname longer than 15 truncated.\n");
1886 string = match_strdup(args);
1890 if (strnicmp(string, "1", 1) == 0) {
1891 /* This is the default */
1894 /* For all other value, error */
1895 printk(KERN_WARNING "CIFS: Invalid version"
1897 goto cifs_parse_mount_err;
1899 string = match_strdup(args);
1903 if (cifs_parse_smb_version(string, vol) != 0)
1904 goto cifs_parse_mount_err;
1907 string = match_strdup(args);
1911 if (cifs_parse_security_flavors(string, vol) != 0)
1912 goto cifs_parse_mount_err;
1915 cache_specified = true;
1916 string = match_strdup(args);
1920 if (cifs_parse_cache_flavor(string, vol) != 0)
1921 goto cifs_parse_mount_err;
1925 * An option we don't recognize. Save it off for later
1926 * if we haven't already found one
1932 /* Free up any allocated string */
1937 if (!sloppy && invalid) {
1938 printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
1939 goto cifs_parse_mount_err;
1943 /* Muliuser mounts require CONFIG_KEYS support */
1944 if (vol->multiuser) {
1945 cERROR(1, "Multiuser mounts require kernels with "
1946 "CONFIG_KEYS enabled.");
1947 goto cifs_parse_mount_err;
1951 if (vol->UNCip == NULL)
1952 vol->UNCip = &vol->UNC[2];
1955 vol->override_uid = override_uid;
1956 else if (override_uid == 1)
1957 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1958 "specified with no uid= option.\n");
1961 vol->override_gid = override_gid;
1962 else if (override_gid == 1)
1963 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1964 "specified with no gid= option.\n");
1966 /* FIXME: remove this block in 3.7 */
1967 if (!cache_specified && !cache_warned) {
1968 cache_warned = true;
1969 printk(KERN_NOTICE "CIFS: no cache= option specified, using "
1970 "\"cache=loose\". This default will change "
1971 "to \"cache=strict\" in 3.7.\n");
1974 kfree(mountdata_copy);
1978 printk(KERN_WARNING "Could not allocate temporary buffer\n");
1979 cifs_parse_mount_err:
1981 kfree(mountdata_copy);
1985 /** Returns true if srcaddr isn't specified and rhs isn't
1986 * specified, or if srcaddr is specified and
1987 * matches the IP address of the rhs argument.
1990 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1992 switch (srcaddr->sa_family) {
1994 return (rhs->sa_family == AF_UNSPEC);
1996 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1997 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1998 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
2001 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
2002 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
2003 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
2007 return false; /* don't expect to be here */
2012 * If no port is specified in addr structure, we try to match with 445 port
2013 * and if it fails - with 139 ports. It should be called only if address
2014 * families of server and addr are equal.
2017 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
2019 __be16 port, *sport;
2021 switch (addr->sa_family) {
2023 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
2024 port = ((struct sockaddr_in *) addr)->sin_port;
2027 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
2028 port = ((struct sockaddr_in6 *) addr)->sin6_port;
2036 port = htons(CIFS_PORT);
2040 port = htons(RFC1001_PORT);
2043 return port == *sport;
2047 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
2048 struct sockaddr *srcaddr)
2050 switch (addr->sa_family) {
2052 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
2053 struct sockaddr_in *srv_addr4 =
2054 (struct sockaddr_in *)&server->dstaddr;
2056 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
2061 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
2062 struct sockaddr_in6 *srv_addr6 =
2063 (struct sockaddr_in6 *)&server->dstaddr;
2065 if (!ipv6_addr_equal(&addr6->sin6_addr,
2066 &srv_addr6->sin6_addr))
2068 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
2074 return false; /* don't expect to be here */
2077 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2084 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2086 unsigned int secFlags;
2088 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
2089 secFlags = vol->secFlg;
2091 secFlags = global_secflags | vol->secFlg;
2093 switch (server->secType) {
2095 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
2099 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
2103 if (!(secFlags & CIFSSEC_MAY_NTLM))
2107 if (!(secFlags & CIFSSEC_MAY_KRB5))
2111 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
2115 /* shouldn't happen */
2119 /* now check if signing mode is acceptable */
2120 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
2121 (server->sec_mode & SECMODE_SIGN_REQUIRED))
2123 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
2125 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
2131 static int match_server(struct TCP_Server_Info *server, struct sockaddr *addr,
2132 struct smb_vol *vol)
2134 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2137 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2140 if (!match_address(server, addr,
2141 (struct sockaddr *)&vol->srcaddr))
2144 if (!match_port(server, addr))
2147 if (!match_security(server, vol))
2153 static struct TCP_Server_Info *
2154 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
2156 struct TCP_Server_Info *server;
2158 spin_lock(&cifs_tcp_ses_lock);
2159 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2160 if (!match_server(server, addr, vol))
2163 ++server->srv_count;
2164 spin_unlock(&cifs_tcp_ses_lock);
2165 cFYI(1, "Existing tcp session with server found");
2168 spin_unlock(&cifs_tcp_ses_lock);
2173 cifs_put_tcp_session(struct TCP_Server_Info *server)
2175 struct task_struct *task;
2177 spin_lock(&cifs_tcp_ses_lock);
2178 if (--server->srv_count > 0) {
2179 spin_unlock(&cifs_tcp_ses_lock);
2183 put_net(cifs_net_ns(server));
2185 list_del_init(&server->tcp_ses_list);
2186 spin_unlock(&cifs_tcp_ses_lock);
2188 cancel_delayed_work_sync(&server->echo);
2190 spin_lock(&GlobalMid_Lock);
2191 server->tcpStatus = CifsExiting;
2192 spin_unlock(&GlobalMid_Lock);
2194 cifs_crypto_shash_release(server);
2195 cifs_fscache_release_client_cookie(server);
2197 kfree(server->session_key.response);
2198 server->session_key.response = NULL;
2199 server->session_key.len = 0;
2201 task = xchg(&server->tsk, NULL);
2203 force_sig(SIGKILL, task);
2206 static struct TCP_Server_Info *
2207 cifs_get_tcp_session(struct smb_vol *volume_info)
2209 struct TCP_Server_Info *tcp_ses = NULL;
2210 struct sockaddr_storage addr;
2211 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
2212 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
2215 memset(&addr, 0, sizeof(struct sockaddr_storage));
2217 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
2219 if (volume_info->UNCip && volume_info->UNC) {
2220 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2222 strlen(volume_info->UNCip),
2225 /* we failed translating address */
2229 } else if (volume_info->UNCip) {
2230 /* BB using ip addr as tcp_ses name to connect to the
2232 cERROR(1, "Connecting to DFS root not implemented yet");
2235 } else /* which tcp_sess DFS root would we conect to */ {
2236 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
2237 "unc=//192.168.1.100/public) specified");
2242 /* see if we already have a matching tcp_ses */
2243 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
2247 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2253 rc = cifs_crypto_shash_allocate(tcp_ses);
2255 cERROR(1, "could not setup hash structures rc %d", rc);
2259 tcp_ses->ops = volume_info->ops;
2260 tcp_ses->vals = volume_info->vals;
2261 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2262 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2263 if (IS_ERR(tcp_ses->hostname)) {
2264 rc = PTR_ERR(tcp_ses->hostname);
2265 goto out_err_crypto_release;
2268 tcp_ses->noblocksnd = volume_info->noblocksnd;
2269 tcp_ses->noautotune = volume_info->noautotune;
2270 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2271 tcp_ses->in_flight = 0;
2272 tcp_ses->credits = 1;
2273 init_waitqueue_head(&tcp_ses->response_q);
2274 init_waitqueue_head(&tcp_ses->request_q);
2275 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2276 mutex_init(&tcp_ses->srv_mutex);
2277 memcpy(tcp_ses->workstation_RFC1001_name,
2278 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2279 memcpy(tcp_ses->server_RFC1001_name,
2280 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2281 tcp_ses->session_estab = false;
2282 tcp_ses->sequence_number = 0;
2283 tcp_ses->lstrp = jiffies;
2284 spin_lock_init(&tcp_ses->req_lock);
2285 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2286 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2287 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2290 * at this point we are the only ones with the pointer
2291 * to the struct since the kernel thread not created yet
2292 * no need to spinlock this init of tcpStatus or srv_count
2294 tcp_ses->tcpStatus = CifsNew;
2295 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2296 sizeof(tcp_ses->srcaddr));
2297 ++tcp_ses->srv_count;
2299 if (addr.ss_family == AF_INET6) {
2300 cFYI(1, "attempting ipv6 connect");
2301 /* BB should we allow ipv6 on port 139? */
2302 /* other OS never observed in Wild doing 139 with v6 */
2303 memcpy(&tcp_ses->dstaddr, sin_server6,
2304 sizeof(struct sockaddr_in6));
2306 memcpy(&tcp_ses->dstaddr, sin_server,
2307 sizeof(struct sockaddr_in));
2309 rc = ip_connect(tcp_ses);
2311 cERROR(1, "Error connecting to socket. Aborting operation");
2312 goto out_err_crypto_release;
2316 * since we're in a cifs function already, we know that
2317 * this will succeed. No need for try_module_get().
2319 __module_get(THIS_MODULE);
2320 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2322 if (IS_ERR(tcp_ses->tsk)) {
2323 rc = PTR_ERR(tcp_ses->tsk);
2324 cERROR(1, "error %d create cifsd thread", rc);
2325 module_put(THIS_MODULE);
2326 goto out_err_crypto_release;
2328 tcp_ses->tcpStatus = CifsNeedNegotiate;
2330 /* thread spawned, put it on the list */
2331 spin_lock(&cifs_tcp_ses_lock);
2332 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2333 spin_unlock(&cifs_tcp_ses_lock);
2335 cifs_fscache_get_client_cookie(tcp_ses);
2337 /* queue echo request delayed work */
2338 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2342 out_err_crypto_release:
2343 cifs_crypto_shash_release(tcp_ses);
2345 put_net(cifs_net_ns(tcp_ses));
2349 if (!IS_ERR(tcp_ses->hostname))
2350 kfree(tcp_ses->hostname);
2351 if (tcp_ses->ssocket)
2352 sock_release(tcp_ses->ssocket);
2358 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2360 switch (ses->server->secType) {
2362 if (vol->cred_uid != ses->cred_uid)
2366 /* NULL username means anonymous session */
2367 if (ses->user_name == NULL) {
2373 /* anything else takes username/password */
2374 if (strncmp(ses->user_name,
2375 vol->username ? vol->username : "",
2378 if (strlen(vol->username) != 0 &&
2379 ses->password != NULL &&
2380 strncmp(ses->password,
2381 vol->password ? vol->password : "",
2388 static struct cifs_ses *
2389 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2391 struct cifs_ses *ses;
2393 spin_lock(&cifs_tcp_ses_lock);
2394 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2395 if (!match_session(ses, vol))
2398 spin_unlock(&cifs_tcp_ses_lock);
2401 spin_unlock(&cifs_tcp_ses_lock);
2406 cifs_put_smb_ses(struct cifs_ses *ses)
2409 struct TCP_Server_Info *server = ses->server;
2411 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
2412 spin_lock(&cifs_tcp_ses_lock);
2413 if (--ses->ses_count > 0) {
2414 spin_unlock(&cifs_tcp_ses_lock);
2418 list_del_init(&ses->smb_ses_list);
2419 spin_unlock(&cifs_tcp_ses_lock);
2421 if (ses->status == CifsGood) {
2423 CIFSSMBLogoff(xid, ses);
2427 cifs_put_tcp_session(server);
2432 /* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2433 #define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2435 /* Populate username and pw fields from keyring if possible */
2437 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2440 char *desc, *delim, *payload;
2443 struct TCP_Server_Info *server = ses->server;
2444 struct sockaddr_in *sa;
2445 struct sockaddr_in6 *sa6;
2446 struct user_key_payload *upayload;
2448 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2452 /* try to find an address key first */
2453 switch (server->dstaddr.ss_family) {
2455 sa = (struct sockaddr_in *)&server->dstaddr;
2456 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2459 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2460 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2463 cFYI(1, "Bad ss_family (%hu)", server->dstaddr.ss_family);
2468 cFYI(1, "%s: desc=%s", __func__, desc);
2469 key = request_key(&key_type_logon, desc, "");
2471 if (!ses->domainName) {
2472 cFYI(1, "domainName is NULL");
2477 /* didn't work, try to find a domain key */
2478 sprintf(desc, "cifs:d:%s", ses->domainName);
2479 cFYI(1, "%s: desc=%s", __func__, desc);
2480 key = request_key(&key_type_logon, desc, "");
2487 down_read(&key->sem);
2488 upayload = key->payload.data;
2489 if (IS_ERR_OR_NULL(upayload)) {
2490 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2494 /* find first : in payload */
2495 payload = (char *)upayload->data;
2496 delim = strnchr(payload, upayload->datalen, ':');
2497 cFYI(1, "payload=%s", payload);
2499 cFYI(1, "Unable to find ':' in payload (datalen=%d)",
2505 len = delim - payload;
2506 if (len > MAX_USERNAME_SIZE || len <= 0) {
2507 cFYI(1, "Bad value from username search (len=%zd)", len);
2512 vol->username = kstrndup(payload, len, GFP_KERNEL);
2513 if (!vol->username) {
2514 cFYI(1, "Unable to allocate %zd bytes for username", len);
2518 cFYI(1, "%s: username=%s", __func__, vol->username);
2520 len = key->datalen - (len + 1);
2521 if (len > MAX_PASSWORD_SIZE || len <= 0) {
2522 cFYI(1, "Bad len for password search (len=%zd)", len);
2524 kfree(vol->username);
2525 vol->username = NULL;
2530 vol->password = kstrndup(delim, len, GFP_KERNEL);
2531 if (!vol->password) {
2532 cFYI(1, "Unable to allocate %zd bytes for password", len);
2534 kfree(vol->username);
2535 vol->username = NULL;
2544 cFYI(1, "%s: returning %d", __func__, rc);
2547 #else /* ! CONFIG_KEYS */
2549 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2550 struct cifs_ses *ses __attribute__((unused)))
2554 #endif /* CONFIG_KEYS */
2556 static bool warned_on_ntlm; /* globals init to false automatically */
2558 static struct cifs_ses *
2559 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2561 int rc = -ENOMEM, xid;
2562 struct cifs_ses *ses;
2563 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2564 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2568 ses = cifs_find_smb_ses(server, volume_info);
2570 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2572 mutex_lock(&ses->session_mutex);
2573 rc = cifs_negotiate_protocol(xid, ses);
2575 mutex_unlock(&ses->session_mutex);
2576 /* problem -- put our ses reference */
2577 cifs_put_smb_ses(ses);
2581 if (ses->need_reconnect) {
2582 cFYI(1, "Session needs reconnect");
2583 rc = cifs_setup_session(xid, ses,
2584 volume_info->local_nls);
2586 mutex_unlock(&ses->session_mutex);
2587 /* problem -- put our reference */
2588 cifs_put_smb_ses(ses);
2593 mutex_unlock(&ses->session_mutex);
2595 /* existing SMB ses has a server reference already */
2596 cifs_put_tcp_session(server);
2601 cFYI(1, "Existing smb sess not found");
2602 ses = sesInfoAlloc();
2606 /* new SMB session uses our server ref */
2607 ses->server = server;
2608 if (server->dstaddr.ss_family == AF_INET6)
2609 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2611 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2613 if (volume_info->username) {
2614 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2615 if (!ses->user_name)
2619 /* volume_info->password freed at unmount */
2620 if (volume_info->password) {
2621 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2625 if (volume_info->domainname) {
2626 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2627 if (!ses->domainName)
2630 ses->cred_uid = volume_info->cred_uid;
2631 ses->linux_uid = volume_info->linux_uid;
2633 /* ntlmv2 is much stronger than ntlm security, and has been broadly
2634 supported for many years, time to update default security mechanism */
2635 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
2636 warned_on_ntlm = true;
2637 cERROR(1, "default security mechanism requested. The default "
2638 "security mechanism will be upgraded from ntlm to "
2639 "ntlmv2 in kernel release 3.3");
2641 ses->overrideSecFlg = volume_info->secFlg;
2643 mutex_lock(&ses->session_mutex);
2644 rc = cifs_negotiate_protocol(xid, ses);
2646 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2647 mutex_unlock(&ses->session_mutex);
2651 /* success, put it on the list */
2652 spin_lock(&cifs_tcp_ses_lock);
2653 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2654 spin_unlock(&cifs_tcp_ses_lock);
2665 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2667 if (tcon->tidStatus == CifsExiting)
2669 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2674 static struct cifs_tcon *
2675 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2677 struct list_head *tmp;
2678 struct cifs_tcon *tcon;
2680 spin_lock(&cifs_tcp_ses_lock);
2681 list_for_each(tmp, &ses->tcon_list) {
2682 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2683 if (!match_tcon(tcon, unc))
2686 spin_unlock(&cifs_tcp_ses_lock);
2689 spin_unlock(&cifs_tcp_ses_lock);
2694 cifs_put_tcon(struct cifs_tcon *tcon)
2697 struct cifs_ses *ses = tcon->ses;
2699 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2700 spin_lock(&cifs_tcp_ses_lock);
2701 if (--tcon->tc_count > 0) {
2702 spin_unlock(&cifs_tcp_ses_lock);
2706 list_del_init(&tcon->tcon_list);
2707 spin_unlock(&cifs_tcp_ses_lock);
2710 CIFSSMBTDis(xid, tcon);
2713 cifs_fscache_release_super_cookie(tcon);
2715 cifs_put_smb_ses(ses);
2718 static struct cifs_tcon *
2719 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2722 struct cifs_tcon *tcon;
2724 tcon = cifs_find_tcon(ses, volume_info->UNC);
2726 cFYI(1, "Found match on UNC path");
2727 /* existing tcon already has a reference */
2728 cifs_put_smb_ses(ses);
2729 if (tcon->seal != volume_info->seal)
2730 cERROR(1, "transport encryption setting "
2731 "conflicts with existing tid");
2735 tcon = tconInfoAlloc();
2742 if (volume_info->password) {
2743 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2744 if (!tcon->password) {
2750 if (strchr(volume_info->UNC + 3, '\\') == NULL
2751 && strchr(volume_info->UNC + 3, '/') == NULL) {
2752 cERROR(1, "Missing share name");
2757 /* BB Do we need to wrap session_mutex around
2758 * this TCon call and Unix SetFS as
2759 * we do on SessSetup and reconnect? */
2761 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2763 cFYI(1, "CIFS Tcon rc = %d", rc);
2767 if (volume_info->nodfs) {
2768 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2769 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2771 tcon->seal = volume_info->seal;
2772 /* we can have only one retry value for a connection
2773 to a share so for resources mounted more than once
2774 to the same server share the last value passed in
2775 for the retry flag is used */
2776 tcon->retry = volume_info->retry;
2777 tcon->nocase = volume_info->nocase;
2778 tcon->local_lease = volume_info->local_lease;
2780 spin_lock(&cifs_tcp_ses_lock);
2781 list_add(&tcon->tcon_list, &ses->tcon_list);
2782 spin_unlock(&cifs_tcp_ses_lock);
2784 cifs_fscache_get_super_cookie(tcon);
2794 cifs_put_tlink(struct tcon_link *tlink)
2796 if (!tlink || IS_ERR(tlink))
2799 if (!atomic_dec_and_test(&tlink->tl_count) ||
2800 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2801 tlink->tl_time = jiffies;
2805 if (!IS_ERR(tlink_tcon(tlink)))
2806 cifs_put_tcon(tlink_tcon(tlink));
2811 static inline struct tcon_link *
2812 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2814 return cifs_sb->master_tlink;
2818 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2820 struct cifs_sb_info *old = CIFS_SB(sb);
2821 struct cifs_sb_info *new = mnt_data->cifs_sb;
2823 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2826 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2827 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2831 * We want to share sb only if we don't specify an r/wsize or
2832 * specified r/wsize is greater than or equal to existing one.
2834 if (new->wsize && new->wsize < old->wsize)
2837 if (new->rsize && new->rsize < old->rsize)
2840 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2843 if (old->mnt_file_mode != new->mnt_file_mode ||
2844 old->mnt_dir_mode != new->mnt_dir_mode)
2847 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2850 if (old->actimeo != new->actimeo)
2857 cifs_match_super(struct super_block *sb, void *data)
2859 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2860 struct smb_vol *volume_info;
2861 struct cifs_sb_info *cifs_sb;
2862 struct TCP_Server_Info *tcp_srv;
2863 struct cifs_ses *ses;
2864 struct cifs_tcon *tcon;
2865 struct tcon_link *tlink;
2866 struct sockaddr_storage addr;
2869 memset(&addr, 0, sizeof(struct sockaddr_storage));
2871 spin_lock(&cifs_tcp_ses_lock);
2872 cifs_sb = CIFS_SB(sb);
2873 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2874 if (IS_ERR(tlink)) {
2875 spin_unlock(&cifs_tcp_ses_lock);
2878 tcon = tlink_tcon(tlink);
2880 tcp_srv = ses->server;
2882 volume_info = mnt_data->vol;
2884 if (!volume_info->UNCip || !volume_info->UNC)
2887 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
2889 strlen(volume_info->UNCip),
2894 if (!match_server(tcp_srv, (struct sockaddr *)&addr, volume_info) ||
2895 !match_session(ses, volume_info) ||
2896 !match_tcon(tcon, volume_info->UNC)) {
2901 rc = compare_mount_options(sb, mnt_data);
2903 spin_unlock(&cifs_tcp_ses_lock);
2904 cifs_put_tlink(tlink);
2909 get_dfs_path(int xid, struct cifs_ses *pSesInfo, const char *old_path,
2910 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2911 struct dfs_info3_param **preferrals, int remap)
2916 *pnum_referrals = 0;
2919 if (pSesInfo->ipc_tid == 0) {
2920 temp_unc = kmalloc(2 /* for slashes */ +
2921 strnlen(pSesInfo->serverName,
2922 SERVER_NAME_LEN_WITH_NULL * 2)
2923 + 1 + 4 /* slash IPC$ */ + 2,
2925 if (temp_unc == NULL)
2929 strcpy(temp_unc + 2, pSesInfo->serverName);
2930 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2931 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2932 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2936 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2937 pnum_referrals, nls_codepage, remap);
2938 /* BB map targetUNCs to dfs_info3 structures, here or
2939 in CIFSGetDFSRefer BB */
2944 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2945 static struct lock_class_key cifs_key[2];
2946 static struct lock_class_key cifs_slock_key[2];
2949 cifs_reclassify_socket4(struct socket *sock)
2951 struct sock *sk = sock->sk;
2952 BUG_ON(sock_owned_by_user(sk));
2953 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2954 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2958 cifs_reclassify_socket6(struct socket *sock)
2960 struct sock *sk = sock->sk;
2961 BUG_ON(sock_owned_by_user(sk));
2962 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2963 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2967 cifs_reclassify_socket4(struct socket *sock)
2972 cifs_reclassify_socket6(struct socket *sock)
2977 /* See RFC1001 section 14 on representation of Netbios names */
2978 static void rfc1002mangle(char *target, char *source, unsigned int length)
2982 for (i = 0, j = 0; i < (length); i++) {
2983 /* mask a nibble at a time and encode */
2984 target[j] = 'A' + (0x0F & (source[i] >> 4));
2985 target[j+1] = 'A' + (0x0F & source[i]);
2992 bind_socket(struct TCP_Server_Info *server)
2995 if (server->srcaddr.ss_family != AF_UNSPEC) {
2996 /* Bind to the specified local IP address */
2997 struct socket *socket = server->ssocket;
2998 rc = socket->ops->bind(socket,
2999 (struct sockaddr *) &server->srcaddr,
3000 sizeof(server->srcaddr));
3002 struct sockaddr_in *saddr4;
3003 struct sockaddr_in6 *saddr6;
3004 saddr4 = (struct sockaddr_in *)&server->srcaddr;
3005 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
3006 if (saddr6->sin6_family == AF_INET6)
3008 "Failed to bind to: %pI6c, error: %d\n",
3009 &saddr6->sin6_addr, rc);
3012 "Failed to bind to: %pI4, error: %d\n",
3013 &saddr4->sin_addr.s_addr, rc);
3020 ip_rfc1001_connect(struct TCP_Server_Info *server)
3024 * some servers require RFC1001 sessinit before sending
3025 * negprot - BB check reconnection in case where second
3026 * sessinit is sent but no second negprot
3028 struct rfc1002_session_packet *ses_init_buf;
3029 struct smb_hdr *smb_buf;
3030 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
3033 ses_init_buf->trailer.session_req.called_len = 32;
3035 if (server->server_RFC1001_name &&
3036 server->server_RFC1001_name[0] != 0)
3037 rfc1002mangle(ses_init_buf->trailer.
3038 session_req.called_name,
3039 server->server_RFC1001_name,
3040 RFC1001_NAME_LEN_WITH_NULL);
3042 rfc1002mangle(ses_init_buf->trailer.
3043 session_req.called_name,
3044 DEFAULT_CIFS_CALLED_NAME,
3045 RFC1001_NAME_LEN_WITH_NULL);
3047 ses_init_buf->trailer.session_req.calling_len = 32;
3050 * calling name ends in null (byte 16) from old smb
3053 if (server->workstation_RFC1001_name &&
3054 server->workstation_RFC1001_name[0] != 0)
3055 rfc1002mangle(ses_init_buf->trailer.
3056 session_req.calling_name,
3057 server->workstation_RFC1001_name,
3058 RFC1001_NAME_LEN_WITH_NULL);
3060 rfc1002mangle(ses_init_buf->trailer.
3061 session_req.calling_name,
3063 RFC1001_NAME_LEN_WITH_NULL);
3065 ses_init_buf->trailer.session_req.scope1 = 0;
3066 ses_init_buf->trailer.session_req.scope2 = 0;
3067 smb_buf = (struct smb_hdr *)ses_init_buf;
3069 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3070 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3071 rc = smb_send(server, smb_buf, 0x44);
3072 kfree(ses_init_buf);
3074 * RFC1001 layer in at least one server
3075 * requires very short break before negprot
3076 * presumably because not expecting negprot
3077 * to follow so fast. This is a simple
3078 * solution that works without
3079 * complicating the code and causes no
3080 * significant slowing down on mount
3083 usleep_range(1000, 2000);
3086 * else the negprot may still work without this
3087 * even though malloc failed
3094 generic_ip_connect(struct TCP_Server_Info *server)
3099 struct socket *socket = server->ssocket;
3100 struct sockaddr *saddr;
3102 saddr = (struct sockaddr *) &server->dstaddr;
3104 if (server->dstaddr.ss_family == AF_INET6) {
3105 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3106 slen = sizeof(struct sockaddr_in6);
3109 sport = ((struct sockaddr_in *) saddr)->sin_port;
3110 slen = sizeof(struct sockaddr_in);
3114 if (socket == NULL) {
3115 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3116 IPPROTO_TCP, &socket, 1);
3118 cERROR(1, "Error %d creating socket", rc);
3119 server->ssocket = NULL;
3123 /* BB other socket options to set KEEPALIVE, NODELAY? */
3124 cFYI(1, "Socket created");
3125 server->ssocket = socket;
3126 socket->sk->sk_allocation = GFP_NOFS;
3127 if (sfamily == AF_INET6)
3128 cifs_reclassify_socket6(socket);
3130 cifs_reclassify_socket4(socket);
3133 rc = bind_socket(server);
3138 * Eventually check for other socket options to change from
3139 * the default. sock_setsockopt not used because it expects
3142 socket->sk->sk_rcvtimeo = 7 * HZ;
3143 socket->sk->sk_sndtimeo = 5 * HZ;
3145 /* make the bufsizes depend on wsize/rsize and max requests */
3146 if (server->noautotune) {
3147 if (socket->sk->sk_sndbuf < (200 * 1024))
3148 socket->sk->sk_sndbuf = 200 * 1024;
3149 if (socket->sk->sk_rcvbuf < (140 * 1024))
3150 socket->sk->sk_rcvbuf = 140 * 1024;
3153 if (server->tcp_nodelay) {
3155 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3156 (char *)&val, sizeof(val));
3158 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
3161 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
3162 socket->sk->sk_sndbuf,
3163 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3165 rc = socket->ops->connect(socket, saddr, slen, 0);
3167 cFYI(1, "Error %d connecting to server", rc);
3168 sock_release(socket);
3169 server->ssocket = NULL;
3173 if (sport == htons(RFC1001_PORT))
3174 rc = ip_rfc1001_connect(server);
3180 ip_connect(struct TCP_Server_Info *server)
3183 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3184 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3186 if (server->dstaddr.ss_family == AF_INET6)
3187 sport = &addr6->sin6_port;
3189 sport = &addr->sin_port;
3194 /* try with 445 port at first */
3195 *sport = htons(CIFS_PORT);
3197 rc = generic_ip_connect(server);
3201 /* if it failed, try with 139 port */
3202 *sport = htons(RFC1001_PORT);
3205 return generic_ip_connect(server);
3208 void reset_cifs_unix_caps(int xid, struct cifs_tcon *tcon,
3209 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3211 /* if we are reconnecting then should we check to see if
3212 * any requested capabilities changed locally e.g. via
3213 * remount but we can not do much about it here
3214 * if they have (even if we could detect it by the following)
3215 * Perhaps we could add a backpointer to array of sb from tcon
3216 * or if we change to make all sb to same share the same
3217 * sb as NFS - then we only have one backpointer to sb.
3218 * What if we wanted to mount the server share twice once with
3219 * and once without posixacls or posix paths? */
3220 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3222 if (vol_info && vol_info->no_linux_ext) {
3223 tcon->fsUnixInfo.Capability = 0;
3224 tcon->unix_ext = 0; /* Unix Extensions disabled */
3225 cFYI(1, "Linux protocol extensions disabled");
3227 } else if (vol_info)
3228 tcon->unix_ext = 1; /* Unix Extensions supported */
3230 if (tcon->unix_ext == 0) {
3231 cFYI(1, "Unix extensions disabled so not set on reconnect");
3235 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3236 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3237 cFYI(1, "unix caps which server supports %lld", cap);
3238 /* check for reconnect case in which we do not
3239 want to change the mount behavior if we can avoid it */
3240 if (vol_info == NULL) {
3241 /* turn off POSIX ACL and PATHNAMES if not set
3242 originally at mount time */
3243 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3244 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3245 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3246 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3247 cERROR(1, "POSIXPATH support change");
3248 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3249 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3250 cERROR(1, "possible reconnect error");
3251 cERROR(1, "server disabled POSIX path support");
3255 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3256 cERROR(1, "per-share encryption not supported yet");
3258 cap &= CIFS_UNIX_CAP_MASK;
3259 if (vol_info && vol_info->no_psx_acl)
3260 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3261 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3262 cFYI(1, "negotiated posix acl support");
3264 cifs_sb->mnt_cifs_flags |=
3265 CIFS_MOUNT_POSIXACL;
3268 if (vol_info && vol_info->posix_paths == 0)
3269 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3270 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3271 cFYI(1, "negotiate posix pathnames");
3273 cifs_sb->mnt_cifs_flags |=
3274 CIFS_MOUNT_POSIX_PATHS;
3277 cFYI(1, "Negotiate caps 0x%x", (int)cap);
3278 #ifdef CONFIG_CIFS_DEBUG2
3279 if (cap & CIFS_UNIX_FCNTL_CAP)
3280 cFYI(1, "FCNTL cap");
3281 if (cap & CIFS_UNIX_EXTATTR_CAP)
3282 cFYI(1, "EXTATTR cap");
3283 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3284 cFYI(1, "POSIX path cap");
3285 if (cap & CIFS_UNIX_XATTR_CAP)
3286 cFYI(1, "XATTR cap");
3287 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3288 cFYI(1, "POSIX ACL cap");
3289 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3290 cFYI(1, "very large read cap");
3291 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3292 cFYI(1, "very large write cap");
3293 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3294 cFYI(1, "transport encryption cap");
3295 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3296 cFYI(1, "mandatory transport encryption cap");
3297 #endif /* CIFS_DEBUG2 */
3298 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3299 if (vol_info == NULL) {
3300 cFYI(1, "resetting capabilities failed");
3302 cERROR(1, "Negotiating Unix capabilities "
3303 "with the server failed. Consider "
3304 "mounting with the Unix Extensions\n"
3305 "disabled, if problems are found, "
3306 "by specifying the nounix mount "
3313 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3314 struct cifs_sb_info *cifs_sb)
3316 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3318 spin_lock_init(&cifs_sb->tlink_tree_lock);
3319 cifs_sb->tlink_tree = RB_ROOT;
3322 * Temporarily set r/wsize for matching superblock. If we end up using
3323 * new sb then client will later negotiate it downward if needed.
3325 cifs_sb->rsize = pvolume_info->rsize;
3326 cifs_sb->wsize = pvolume_info->wsize;
3328 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3329 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3330 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3331 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3332 cFYI(1, "file mode: 0x%hx dir mode: 0x%hx",
3333 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3335 cifs_sb->actimeo = pvolume_info->actimeo;
3336 cifs_sb->local_nls = pvolume_info->local_nls;
3338 if (pvolume_info->noperm)
3339 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3340 if (pvolume_info->setuids)
3341 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3342 if (pvolume_info->server_ino)
3343 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3344 if (pvolume_info->remap)
3345 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3346 if (pvolume_info->no_xattr)
3347 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3348 if (pvolume_info->sfu_emul)
3349 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3350 if (pvolume_info->nobrl)
3351 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3352 if (pvolume_info->nostrictsync)
3353 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3354 if (pvolume_info->mand_lock)
3355 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3356 if (pvolume_info->rwpidforward)
3357 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3358 if (pvolume_info->cifs_acl)
3359 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3360 if (pvolume_info->backupuid_specified) {
3361 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3362 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3364 if (pvolume_info->backupgid_specified) {
3365 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3366 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3368 if (pvolume_info->override_uid)
3369 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3370 if (pvolume_info->override_gid)
3371 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3372 if (pvolume_info->dynperm)
3373 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3374 if (pvolume_info->fsc)
3375 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3376 if (pvolume_info->multiuser)
3377 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3378 CIFS_MOUNT_NO_PERM);
3379 if (pvolume_info->strict_io)
3380 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3381 if (pvolume_info->direct_io) {
3382 cFYI(1, "mounting share using direct i/o");
3383 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3385 if (pvolume_info->mfsymlinks) {
3386 if (pvolume_info->sfu_emul) {
3387 cERROR(1, "mount option mfsymlinks ignored if sfu "
3388 "mount option is used");
3390 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3394 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3395 cERROR(1, "mount option dynperm ignored if cifsacl "
3396 "mount option supported");
3400 * When the server supports very large reads and writes via POSIX extensions,
3401 * we can allow up to 2^24-1, minus the size of a READ/WRITE_AND_X header, not
3402 * including the RFC1001 length.
3404 * Note that this might make for "interesting" allocation problems during
3405 * writeback however as we have to allocate an array of pointers for the
3406 * pages. A 16M write means ~32kb page array with PAGE_CACHE_SIZE == 4096.
3408 * For reads, there is a similar problem as we need to allocate an array
3409 * of kvecs to handle the receive, though that should only need to be done
3412 #define CIFS_MAX_WSIZE ((1<<24) - 1 - sizeof(WRITE_REQ) + 4)
3413 #define CIFS_MAX_RSIZE ((1<<24) - sizeof(READ_RSP) + 4)
3416 * When the server doesn't allow large posix writes, only allow a rsize/wsize
3417 * of 2^17-1 minus the size of the call header. That allows for a read or
3418 * write up to the maximum size described by RFC1002.
3420 #define CIFS_MAX_RFC1002_WSIZE ((1<<17) - 1 - sizeof(WRITE_REQ) + 4)
3421 #define CIFS_MAX_RFC1002_RSIZE ((1<<17) - 1 - sizeof(READ_RSP) + 4)
3424 * The default wsize is 1M. find_get_pages seems to return a maximum of 256
3425 * pages in a single call. With PAGE_CACHE_SIZE == 4k, this means we can fill
3426 * a single wsize request with a single call.
3428 #define CIFS_DEFAULT_IOSIZE (1024 * 1024)
3431 * Windows only supports a max of 60kb reads and 65535 byte writes. Default to
3432 * those values when posix extensions aren't in force. In actuality here, we
3433 * use 65536 to allow for a write that is a multiple of 4k. Most servers seem
3434 * to be ok with the extra byte even though Windows doesn't send writes that
3439 * http://blogs.msdn.com/b/openspecification/archive/2009/04/10/smb-maximum-transmit-buffer-size-and-performance-tuning.aspx
3441 #define CIFS_DEFAULT_NON_POSIX_RSIZE (60 * 1024)
3442 #define CIFS_DEFAULT_NON_POSIX_WSIZE (65536)
3445 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3447 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3448 struct TCP_Server_Info *server = tcon->ses->server;
3451 /* start with specified wsize, or default */
3452 if (pvolume_info->wsize)
3453 wsize = pvolume_info->wsize;
3454 else if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3455 wsize = CIFS_DEFAULT_IOSIZE;
3457 wsize = CIFS_DEFAULT_NON_POSIX_WSIZE;
3459 /* can server support 24-bit write sizes? (via UNIX extensions) */
3460 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3461 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
3464 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
3465 * Limit it to max buffer offered by the server, minus the size of the
3466 * WRITEX header, not including the 4 byte RFC1001 length.
3468 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
3469 (!(server->capabilities & CAP_UNIX) &&
3470 (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
3471 wsize = min_t(unsigned int, wsize,
3472 server->maxBuf - sizeof(WRITE_REQ) + 4);
3474 /* hard limit of CIFS_MAX_WSIZE */
3475 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
3481 cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3483 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3484 struct TCP_Server_Info *server = tcon->ses->server;
3485 unsigned int rsize, defsize;
3488 * Set default value...
3490 * HACK alert! Ancient servers have very small buffers. Even though
3491 * MS-CIFS indicates that servers are only limited by the client's
3492 * bufsize for reads, testing against win98se shows that it throws
3493 * INVALID_PARAMETER errors if you try to request too large a read.
3495 * If the server advertises a MaxBufferSize of less than one page,
3496 * assume that it also can't satisfy reads larger than that either.
3498 * FIXME: Is there a better heuristic for this?
3500 if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
3501 defsize = CIFS_DEFAULT_IOSIZE;
3502 else if (server->capabilities & CAP_LARGE_READ_X)
3503 defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
3504 else if (server->maxBuf >= PAGE_CACHE_SIZE)
3505 defsize = CIFSMaxBufSize;
3507 defsize = server->maxBuf - sizeof(READ_RSP);
3509 rsize = pvolume_info->rsize ? pvolume_info->rsize : defsize;
3512 * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
3513 * the client's MaxBufferSize.
3515 if (!(server->capabilities & CAP_LARGE_READ_X))
3516 rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
3518 /* hard limit of CIFS_MAX_RSIZE */
3519 rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
3525 is_path_accessible(int xid, struct cifs_tcon *tcon,
3526 struct cifs_sb_info *cifs_sb, const char *full_path)
3529 FILE_ALL_INFO *pfile_info;
3531 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
3532 if (pfile_info == NULL)
3535 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
3536 0 /* not legacy */, cifs_sb->local_nls,
3537 cifs_sb->mnt_cifs_flags &
3538 CIFS_MOUNT_MAP_SPECIAL_CHR);
3540 if (rc == -EOPNOTSUPP || rc == -EINVAL)
3541 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
3542 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
3543 CIFS_MOUNT_MAP_SPECIAL_CHR);
3549 cleanup_volume_info_contents(struct smb_vol *volume_info)
3551 kfree(volume_info->username);
3552 kzfree(volume_info->password);
3553 if (volume_info->UNCip != volume_info->UNC + 2)
3554 kfree(volume_info->UNCip);
3555 kfree(volume_info->UNC);
3556 kfree(volume_info->domainname);
3557 kfree(volume_info->iocharset);
3558 kfree(volume_info->prepath);
3562 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3566 cleanup_volume_info_contents(volume_info);
3571 #ifdef CONFIG_CIFS_DFS_UPCALL
3572 /* build_path_to_root returns full path to root when
3573 * we do not have an exiting connection (tcon) */
3575 build_unc_path_to_root(const struct smb_vol *vol,
3576 const struct cifs_sb_info *cifs_sb)
3578 char *full_path, *pos;
3579 unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
3580 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3582 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3583 if (full_path == NULL)
3584 return ERR_PTR(-ENOMEM);
3586 strncpy(full_path, vol->UNC, unc_len);
3587 pos = full_path + unc_len;
3590 strncpy(pos, vol->prepath, pplen);
3594 *pos = '\0'; /* add trailing null */
3595 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3596 cFYI(1, "%s: full_path=%s", __func__, full_path);
3601 * Perform a dfs referral query for a share and (optionally) prefix
3603 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3604 * to a string containing updated options for the submount. Otherwise it
3605 * will be left untouched.
3607 * Returns the rc from get_dfs_path to the caller, which can be used to
3608 * determine whether there were referrals.
3611 expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
3612 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3616 unsigned int num_referrals = 0;
3617 struct dfs_info3_param *referrals = NULL;
3618 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3620 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3621 if (IS_ERR(full_path))
3622 return PTR_ERR(full_path);
3624 /* For DFS paths, skip the first '\' of the UNC */
3625 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3627 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
3628 &num_referrals, &referrals,
3629 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3631 if (!rc && num_referrals > 0) {
3632 char *fake_devname = NULL;
3634 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3635 full_path + 1, referrals,
3638 free_dfs_info_array(referrals, num_referrals);
3640 if (IS_ERR(mdata)) {
3641 rc = PTR_ERR(mdata);
3644 cleanup_volume_info_contents(volume_info);
3645 memset(volume_info, '\0', sizeof(*volume_info));
3646 rc = cifs_setup_volume_info(volume_info, mdata,
3649 kfree(fake_devname);
3650 kfree(cifs_sb->mountdata);
3651 cifs_sb->mountdata = mdata;
3659 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3660 const char *devname)
3664 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3668 if (volume_info->nullauth) {
3669 cFYI(1, "Anonymous login");
3670 kfree(volume_info->username);
3671 volume_info->username = NULL;
3672 } else if (volume_info->username) {
3673 /* BB fixme parse for domain name here */
3674 cFYI(1, "Username: %s", volume_info->username);
3676 cifserror("No username specified");
3677 /* In userspace mount helper we can get user name from alternate
3678 locations such as env variables and files on disk */
3682 /* this is needed for ASCII cp to Unicode converts */
3683 if (volume_info->iocharset == NULL) {
3684 /* load_nls_default cannot return null */
3685 volume_info->local_nls = load_nls_default();
3687 volume_info->local_nls = load_nls(volume_info->iocharset);
3688 if (volume_info->local_nls == NULL) {
3689 cERROR(1, "CIFS mount error: iocharset %s not found",
3690 volume_info->iocharset);
3699 cifs_get_volume_info(char *mount_data, const char *devname)
3702 struct smb_vol *volume_info;
3704 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3706 return ERR_PTR(-ENOMEM);
3708 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3710 cifs_cleanup_volume_info(volume_info);
3711 volume_info = ERR_PTR(rc);
3718 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3722 struct cifs_ses *pSesInfo;
3723 struct cifs_tcon *tcon;
3724 struct TCP_Server_Info *srvTcp;
3726 struct tcon_link *tlink;
3727 #ifdef CONFIG_CIFS_DFS_UPCALL
3728 int referral_walks_count = 0;
3731 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3735 #ifdef CONFIG_CIFS_DFS_UPCALL
3737 /* cleanup activities if we're chasing a referral */
3738 if (referral_walks_count) {
3740 cifs_put_tcon(tcon);
3742 cifs_put_smb_ses(pSesInfo);
3756 /* get a reference to a tcp session */
3757 srvTcp = cifs_get_tcp_session(volume_info);
3758 if (IS_ERR(srvTcp)) {
3759 rc = PTR_ERR(srvTcp);
3760 bdi_destroy(&cifs_sb->bdi);
3764 /* get a reference to a SMB session */
3765 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3766 if (IS_ERR(pSesInfo)) {
3767 rc = PTR_ERR(pSesInfo);
3769 goto mount_fail_check;
3772 /* search for existing tcon to this server share */
3773 tcon = cifs_get_tcon(pSesInfo, volume_info);
3777 goto remote_path_check;
3780 /* tell server which Unix caps we support */
3781 if (tcon->ses->capabilities & CAP_UNIX) {
3782 /* reset of caps checks mount to see if unix extensions
3783 disabled for just this mount */
3784 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3785 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3786 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3787 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3789 goto mount_fail_check;
3792 tcon->unix_ext = 0; /* server does not support them */
3794 /* do not care if following two calls succeed - informational */
3796 CIFSSMBQFSDeviceInfo(xid, tcon);
3797 CIFSSMBQFSAttributeInfo(xid, tcon);
3800 cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
3801 cifs_sb->rsize = cifs_negotiate_rsize(tcon, volume_info);
3803 /* tune readahead according to rsize */
3804 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3807 #ifdef CONFIG_CIFS_DFS_UPCALL
3809 * Perform an unconditional check for whether there are DFS
3810 * referrals for this path without prefix, to provide support
3811 * for DFS referrals from w2k8 servers which don't seem to respond
3812 * with PATH_NOT_COVERED to requests that include the prefix.
3813 * Chase the referral if found, otherwise continue normally.
3815 if (referral_walks_count == 0) {
3816 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3819 referral_walks_count++;
3820 goto try_mount_again;
3825 /* check if a whole path is not remote */
3827 /* build_path_to_root works only when we have a valid tcon */
3828 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3829 if (full_path == NULL) {
3831 goto mount_fail_check;
3833 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3834 if (rc != 0 && rc != -EREMOTE) {
3836 goto mount_fail_check;
3841 /* get referral if needed */
3842 if (rc == -EREMOTE) {
3843 #ifdef CONFIG_CIFS_DFS_UPCALL
3844 if (referral_walks_count > MAX_NESTED_LINKS) {
3846 * BB: when we implement proper loop detection,
3847 * we will remove this check. But now we need it
3848 * to prevent an indefinite loop if 'DFS tree' is
3849 * misconfigured (i.e. has loops).
3852 goto mount_fail_check;
3855 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
3859 referral_walks_count++;
3860 goto try_mount_again;
3862 goto mount_fail_check;
3863 #else /* No DFS support, return error on mount */
3869 goto mount_fail_check;
3871 /* now, hang the tcon off of the superblock */
3872 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3873 if (tlink == NULL) {
3875 goto mount_fail_check;
3878 tlink->tl_uid = pSesInfo->linux_uid;
3879 tlink->tl_tcon = tcon;
3880 tlink->tl_time = jiffies;
3881 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3882 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3884 cifs_sb->master_tlink = tlink;
3885 spin_lock(&cifs_sb->tlink_tree_lock);
3886 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3887 spin_unlock(&cifs_sb->tlink_tree_lock);
3889 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3893 /* on error free sesinfo and tcon struct if needed */
3895 /* If find_unc succeeded then rc == 0 so we can not end */
3896 /* up accidentally freeing someone elses tcon struct */
3898 cifs_put_tcon(tcon);
3900 cifs_put_smb_ses(pSesInfo);
3902 cifs_put_tcp_session(srvTcp);
3903 bdi_destroy(&cifs_sb->bdi);
3912 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3913 * pointer may be NULL.
3916 CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3917 const char *tree, struct cifs_tcon *tcon,
3918 const struct nls_table *nls_codepage)
3920 struct smb_hdr *smb_buffer;
3921 struct smb_hdr *smb_buffer_response;
3924 unsigned char *bcc_ptr;
3927 __u16 bytes_left, count;
3932 smb_buffer = cifs_buf_get();
3933 if (smb_buffer == NULL)
3936 smb_buffer_response = smb_buffer;
3938 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3939 NULL /*no tid */ , 4 /*wct */ );
3941 smb_buffer->Mid = GetNextMid(ses->server);
3942 smb_buffer->Uid = ses->Suid;
3943 pSMB = (TCONX_REQ *) smb_buffer;
3944 pSMBr = (TCONX_RSP *) smb_buffer_response;
3946 pSMB->AndXCommand = 0xFF;
3947 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3948 bcc_ptr = &pSMB->Password[0];
3949 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3950 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3951 *bcc_ptr = 0; /* password is null byte */
3952 bcc_ptr++; /* skip password */
3953 /* already aligned so no need to do it below */
3955 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3956 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3957 specified as required (when that support is added to
3958 the vfs in the future) as only NTLM or the much
3959 weaker LANMAN (which we do not send by default) is accepted
3960 by Samba (not sure whether other servers allow
3961 NTLMv2 password here) */
3962 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3963 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3964 (ses->server->secType == LANMAN))
3965 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3966 ses->server->sec_mode &
3967 SECMODE_PW_ENCRYPT ? true : false,
3970 #endif /* CIFS_WEAK_PW_HASH */
3971 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3972 bcc_ptr, nls_codepage);
3974 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3975 if (ses->capabilities & CAP_UNICODE) {
3976 /* must align unicode strings */
3977 *bcc_ptr = 0; /* null byte password */
3982 if (ses->server->sec_mode &
3983 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3984 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3986 if (ses->capabilities & CAP_STATUS32) {
3987 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3989 if (ses->capabilities & CAP_DFS) {
3990 smb_buffer->Flags2 |= SMBFLG2_DFS;
3992 if (ses->capabilities & CAP_UNICODE) {
3993 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3995 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3996 6 /* max utf8 char length in bytes */ *
3997 (/* server len*/ + 256 /* share len */), nls_codepage);
3998 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3999 bcc_ptr += 2; /* skip trailing null */
4000 } else { /* ASCII */
4001 strcpy(bcc_ptr, tree);
4002 bcc_ptr += strlen(tree) + 1;
4004 strcpy(bcc_ptr, "?????");
4005 bcc_ptr += strlen("?????");
4007 count = bcc_ptr - &pSMB->Password[0];
4008 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
4009 pSMB->hdr.smb_buf_length) + count);
4010 pSMB->ByteCount = cpu_to_le16(count);
4012 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
4015 /* above now done in SendReceive */
4016 if ((rc == 0) && (tcon != NULL)) {
4019 tcon->tidStatus = CifsGood;
4020 tcon->need_reconnect = false;
4021 tcon->tid = smb_buffer_response->Tid;
4022 bcc_ptr = pByteArea(smb_buffer_response);
4023 bytes_left = get_bcc(smb_buffer_response);
4024 length = strnlen(bcc_ptr, bytes_left - 2);
4025 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4031 /* skip service field (NB: this field is always ASCII) */
4033 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4034 (bcc_ptr[2] == 'C')) {
4035 cFYI(1, "IPC connection");
4038 } else if (length == 2) {
4039 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4040 /* the most common case */
4041 cFYI(1, "disk share connection");
4044 bcc_ptr += length + 1;
4045 bytes_left -= (length + 1);
4046 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
4048 /* mostly informational -- no need to fail on error here */
4049 kfree(tcon->nativeFileSystem);
4050 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4051 bytes_left, is_unicode,
4054 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
4056 if ((smb_buffer_response->WordCount == 3) ||
4057 (smb_buffer_response->WordCount == 7))
4058 /* field is in same location */
4059 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4062 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
4063 } else if ((rc == 0) && tcon == NULL) {
4064 /* all we need to save for IPC$ connection */
4065 ses->ipc_tid = smb_buffer_response->Tid;
4068 cifs_buf_release(smb_buffer);
4073 cifs_umount(struct cifs_sb_info *cifs_sb)
4075 struct rb_root *root = &cifs_sb->tlink_tree;
4076 struct rb_node *node;
4077 struct tcon_link *tlink;
4079 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4081 spin_lock(&cifs_sb->tlink_tree_lock);
4082 while ((node = rb_first(root))) {
4083 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4084 cifs_get_tlink(tlink);
4085 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4086 rb_erase(node, root);
4088 spin_unlock(&cifs_sb->tlink_tree_lock);
4089 cifs_put_tlink(tlink);
4090 spin_lock(&cifs_sb->tlink_tree_lock);
4092 spin_unlock(&cifs_sb->tlink_tree_lock);
4094 bdi_destroy(&cifs_sb->bdi);
4095 kfree(cifs_sb->mountdata);
4096 unload_nls(cifs_sb->local_nls);
4100 int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
4103 struct TCP_Server_Info *server = ses->server;
4105 /* only send once per connect */
4106 if (server->maxBuf != 0)
4109 set_credits(server, 1);
4110 rc = CIFSSMBNegotiate(xid, ses);
4111 if (rc == -EAGAIN) {
4112 /* retry only once on 1st time connection */
4113 set_credits(server, 1);
4114 rc = CIFSSMBNegotiate(xid, ses);
4119 spin_lock(&GlobalMid_Lock);
4120 if (server->tcpStatus == CifsNeedNegotiate)
4121 server->tcpStatus = CifsGood;
4124 spin_unlock(&GlobalMid_Lock);
4132 int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
4133 struct nls_table *nls_info)
4136 struct TCP_Server_Info *server = ses->server;
4139 ses->capabilities = server->capabilities;
4140 if (linuxExtEnabled == 0)
4141 ses->capabilities &= (~CAP_UNIX);
4143 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
4144 server->sec_mode, server->capabilities, server->timeAdj);
4146 rc = CIFS_SessSetup(xid, ses, nls_info);
4148 cERROR(1, "Send error in SessSetup = %d", rc);
4150 mutex_lock(&ses->server->srv_mutex);
4151 if (!server->session_estab) {
4152 server->session_key.response = ses->auth_key.response;
4153 server->session_key.len = ses->auth_key.len;
4154 server->sequence_number = 0x2;
4155 server->session_estab = true;
4156 ses->auth_key.response = NULL;
4158 mutex_unlock(&server->srv_mutex);
4160 cFYI(1, "CIFS Session Established successfully");
4161 spin_lock(&GlobalMid_Lock);
4162 ses->status = CifsGood;
4163 ses->need_reconnect = false;
4164 spin_unlock(&GlobalMid_Lock);
4167 kfree(ses->auth_key.response);
4168 ses->auth_key.response = NULL;
4169 ses->auth_key.len = 0;
4170 kfree(ses->ntlmssp);
4171 ses->ntlmssp = NULL;
4177 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4179 switch (ses->server->secType) {
4181 vol->secFlg = CIFSSEC_MUST_KRB5;
4184 vol->secFlg = CIFSSEC_MUST_NTLMV2;
4187 vol->secFlg = CIFSSEC_MUST_NTLM;
4190 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
4193 vol->secFlg = CIFSSEC_MUST_LANMAN;
4197 return cifs_set_cifscreds(vol, ses);
4200 static struct cifs_tcon *
4201 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
4204 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4205 struct cifs_ses *ses;
4206 struct cifs_tcon *tcon = NULL;
4207 struct smb_vol *vol_info;
4209 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4210 if (vol_info == NULL)
4211 return ERR_PTR(-ENOMEM);
4213 vol_info->local_nls = cifs_sb->local_nls;
4214 vol_info->linux_uid = fsuid;
4215 vol_info->cred_uid = fsuid;
4216 vol_info->UNC = master_tcon->treeName;
4217 vol_info->retry = master_tcon->retry;
4218 vol_info->nocase = master_tcon->nocase;
4219 vol_info->local_lease = master_tcon->local_lease;
4220 vol_info->no_linux_ext = !master_tcon->unix_ext;
4222 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4228 /* get a reference for the same TCP session */
4229 spin_lock(&cifs_tcp_ses_lock);
4230 ++master_tcon->ses->server->srv_count;
4231 spin_unlock(&cifs_tcp_ses_lock);
4233 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4235 tcon = (struct cifs_tcon *)ses;
4236 cifs_put_tcp_session(master_tcon->ses->server);
4240 tcon = cifs_get_tcon(ses, vol_info);
4242 cifs_put_smb_ses(ses);
4246 if (ses->capabilities & CAP_UNIX)
4247 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4249 kfree(vol_info->username);
4250 kfree(vol_info->password);
4257 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4259 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4263 cifs_sb_tcon_pending_wait(void *unused)
4266 return signal_pending(current) ? -ERESTARTSYS : 0;
4269 /* find and return a tlink with given uid */
4270 static struct tcon_link *
4271 tlink_rb_search(struct rb_root *root, uid_t uid)
4273 struct rb_node *node = root->rb_node;
4274 struct tcon_link *tlink;
4277 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4279 if (tlink->tl_uid > uid)
4280 node = node->rb_left;
4281 else if (tlink->tl_uid < uid)
4282 node = node->rb_right;
4289 /* insert a tcon_link into the tree */
4291 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4293 struct rb_node **new = &(root->rb_node), *parent = NULL;
4294 struct tcon_link *tlink;
4297 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4300 if (tlink->tl_uid > new_tlink->tl_uid)
4301 new = &((*new)->rb_left);
4303 new = &((*new)->rb_right);
4306 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4307 rb_insert_color(&new_tlink->tl_rbnode, root);
4311 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4314 * If the superblock doesn't refer to a multiuser mount, then just return
4315 * the master tcon for the mount.
4317 * First, search the rbtree for an existing tcon for this fsuid. If one
4318 * exists, then check to see if it's pending construction. If it is then wait
4319 * for construction to complete. Once it's no longer pending, check to see if
4320 * it failed and either return an error or retry construction, depending on
4323 * If one doesn't exist then insert a new tcon_link struct into the tree and
4324 * try to construct a new one.
4327 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4330 uid_t fsuid = current_fsuid();
4331 struct tcon_link *tlink, *newtlink;
4333 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4334 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4336 spin_lock(&cifs_sb->tlink_tree_lock);
4337 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4339 cifs_get_tlink(tlink);
4340 spin_unlock(&cifs_sb->tlink_tree_lock);
4342 if (tlink == NULL) {
4343 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4344 if (newtlink == NULL)
4345 return ERR_PTR(-ENOMEM);
4346 newtlink->tl_uid = fsuid;
4347 newtlink->tl_tcon = ERR_PTR(-EACCES);
4348 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4349 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4350 cifs_get_tlink(newtlink);
4352 spin_lock(&cifs_sb->tlink_tree_lock);
4353 /* was one inserted after previous search? */
4354 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4356 cifs_get_tlink(tlink);
4357 spin_unlock(&cifs_sb->tlink_tree_lock);
4359 goto wait_for_construction;
4362 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4363 spin_unlock(&cifs_sb->tlink_tree_lock);
4365 wait_for_construction:
4366 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4367 cifs_sb_tcon_pending_wait,
4368 TASK_INTERRUPTIBLE);
4370 cifs_put_tlink(tlink);
4371 return ERR_PTR(ret);
4374 /* if it's good, return it */
4375 if (!IS_ERR(tlink->tl_tcon))
4378 /* return error if we tried this already recently */
4379 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4380 cifs_put_tlink(tlink);
4381 return ERR_PTR(-EACCES);
4384 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4385 goto wait_for_construction;
4388 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4389 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4390 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4392 if (IS_ERR(tlink->tl_tcon)) {
4393 cifs_put_tlink(tlink);
4394 return ERR_PTR(-EACCES);
4401 * periodic workqueue job that scans tcon_tree for a superblock and closes
4405 cifs_prune_tlinks(struct work_struct *work)
4407 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4409 struct rb_root *root = &cifs_sb->tlink_tree;
4410 struct rb_node *node = rb_first(root);
4411 struct rb_node *tmp;
4412 struct tcon_link *tlink;
4415 * Because we drop the spinlock in the loop in order to put the tlink
4416 * it's not guarded against removal of links from the tree. The only
4417 * places that remove entries from the tree are this function and
4418 * umounts. Because this function is non-reentrant and is canceled
4419 * before umount can proceed, this is safe.
4421 spin_lock(&cifs_sb->tlink_tree_lock);
4422 node = rb_first(root);
4423 while (node != NULL) {
4425 node = rb_next(tmp);
4426 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4428 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4429 atomic_read(&tlink->tl_count) != 0 ||
4430 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4433 cifs_get_tlink(tlink);
4434 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4435 rb_erase(tmp, root);
4437 spin_unlock(&cifs_sb->tlink_tree_lock);
4438 cifs_put_tlink(tlink);
4439 spin_lock(&cifs_sb->tlink_tree_lock);
4441 spin_unlock(&cifs_sb->tlink_tree_lock);
4443 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,