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 extern mempool_t
*cifs_req_poolp
;
61 /* FIXME: should these be tunable? */
62 #define TLINK_ERROR_EXPIRE (1 * HZ)
63 #define TLINK_IDLE_EXPIRE (600 * HZ)
66 /* Mount options that take no arguments */
67 Opt_user_xattr
, Opt_nouser_xattr
,
68 Opt_forceuid
, Opt_noforceuid
,
69 Opt_forcegid
, Opt_noforcegid
,
70 Opt_noblocksend
, Opt_noautotune
,
71 Opt_hard
, Opt_soft
, Opt_perm
, Opt_noperm
,
72 Opt_mapposix
, Opt_nomapposix
,
73 Opt_mapchars
, Opt_nomapchars
, Opt_sfu
,
74 Opt_nosfu
, Opt_nodfs
, Opt_posixpaths
,
75 Opt_noposixpaths
, Opt_nounix
,
78 Opt_forcemandatorylock
, Opt_setuidfromacl
, Opt_setuids
,
79 Opt_nosetuids
, Opt_dynperm
, Opt_nodynperm
,
80 Opt_nohard
, Opt_nosoft
,
82 Opt_nostrictsync
, Opt_strictsync
,
83 Opt_serverino
, Opt_noserverino
,
84 Opt_rwpidforward
, Opt_cifsacl
, Opt_nocifsacl
,
85 Opt_acl
, Opt_noacl
, Opt_locallease
,
86 Opt_sign
, Opt_seal
, Opt_noac
,
87 Opt_fsc
, Opt_mfsymlinks
,
88 Opt_multiuser
, Opt_sloppy
, Opt_nosharesock
,
89 Opt_persistent
, Opt_nopersistent
,
90 Opt_resilient
, Opt_noresilient
,
92 /* Mount options which take numeric value */
93 Opt_backupuid
, Opt_backupgid
, Opt_uid
,
94 Opt_cruid
, Opt_gid
, Opt_file_mode
,
95 Opt_dirmode
, Opt_port
,
96 Opt_rsize
, Opt_wsize
, Opt_actimeo
,
97 Opt_echo_interval
, Opt_max_credits
,
99 /* Mount options which take string value */
100 Opt_user
, Opt_pass
, Opt_ip
,
101 Opt_domain
, Opt_srcaddr
, Opt_iocharset
,
102 Opt_netbiosname
, Opt_servern
,
103 Opt_ver
, Opt_vers
, Opt_sec
, Opt_cache
,
105 /* Mount options to be ignored */
108 /* Options which could be blank */
116 static const match_table_t cifs_mount_option_tokens
= {
118 { Opt_user_xattr
, "user_xattr" },
119 { Opt_nouser_xattr
, "nouser_xattr" },
120 { Opt_forceuid
, "forceuid" },
121 { Opt_noforceuid
, "noforceuid" },
122 { Opt_forcegid
, "forcegid" },
123 { Opt_noforcegid
, "noforcegid" },
124 { Opt_noblocksend
, "noblocksend" },
125 { Opt_noautotune
, "noautotune" },
126 { Opt_hard
, "hard" },
127 { Opt_soft
, "soft" },
128 { Opt_perm
, "perm" },
129 { Opt_noperm
, "noperm" },
130 { Opt_mapchars
, "mapchars" }, /* SFU style */
131 { Opt_nomapchars
, "nomapchars" },
132 { Opt_mapposix
, "mapposix" }, /* SFM style */
133 { Opt_nomapposix
, "nomapposix" },
135 { Opt_nosfu
, "nosfu" },
136 { Opt_nodfs
, "nodfs" },
137 { Opt_posixpaths
, "posixpaths" },
138 { Opt_noposixpaths
, "noposixpaths" },
139 { Opt_nounix
, "nounix" },
140 { Opt_nounix
, "nolinux" },
141 { Opt_nocase
, "nocase" },
142 { Opt_nocase
, "ignorecase" },
144 { Opt_nobrl
, "nobrl" },
145 { Opt_nobrl
, "nolock" },
146 { Opt_forcemandatorylock
, "forcemandatorylock" },
147 { Opt_forcemandatorylock
, "forcemand" },
148 { Opt_setuids
, "setuids" },
149 { Opt_nosetuids
, "nosetuids" },
150 { Opt_setuidfromacl
, "idsfromsid" },
151 { Opt_dynperm
, "dynperm" },
152 { Opt_nodynperm
, "nodynperm" },
153 { Opt_nohard
, "nohard" },
154 { Opt_nosoft
, "nosoft" },
155 { Opt_nointr
, "nointr" },
156 { Opt_intr
, "intr" },
157 { Opt_nostrictsync
, "nostrictsync" },
158 { Opt_strictsync
, "strictsync" },
159 { Opt_serverino
, "serverino" },
160 { Opt_noserverino
, "noserverino" },
161 { Opt_rwpidforward
, "rwpidforward" },
162 { Opt_cifsacl
, "cifsacl" },
163 { Opt_nocifsacl
, "nocifsacl" },
165 { Opt_noacl
, "noacl" },
166 { Opt_locallease
, "locallease" },
167 { Opt_sign
, "sign" },
168 { Opt_seal
, "seal" },
169 { Opt_noac
, "noac" },
171 { Opt_mfsymlinks
, "mfsymlinks" },
172 { Opt_multiuser
, "multiuser" },
173 { Opt_sloppy
, "sloppy" },
174 { Opt_nosharesock
, "nosharesock" },
175 { Opt_persistent
, "persistenthandles"},
176 { Opt_nopersistent
, "nopersistenthandles"},
177 { Opt_resilient
, "resilienthandles"},
178 { Opt_noresilient
, "noresilienthandles"},
180 { Opt_backupuid
, "backupuid=%s" },
181 { Opt_backupgid
, "backupgid=%s" },
182 { Opt_uid
, "uid=%s" },
183 { Opt_cruid
, "cruid=%s" },
184 { Opt_gid
, "gid=%s" },
185 { Opt_file_mode
, "file_mode=%s" },
186 { Opt_dirmode
, "dirmode=%s" },
187 { Opt_dirmode
, "dir_mode=%s" },
188 { Opt_port
, "port=%s" },
189 { Opt_rsize
, "rsize=%s" },
190 { Opt_wsize
, "wsize=%s" },
191 { Opt_actimeo
, "actimeo=%s" },
192 { Opt_echo_interval
, "echo_interval=%s" },
193 { Opt_max_credits
, "max_credits=%s" },
195 { Opt_blank_user
, "user=" },
196 { Opt_blank_user
, "username=" },
197 { Opt_user
, "user=%s" },
198 { Opt_user
, "username=%s" },
199 { Opt_blank_pass
, "pass=" },
200 { Opt_blank_pass
, "password=" },
201 { Opt_pass
, "pass=%s" },
202 { Opt_pass
, "password=%s" },
203 { Opt_blank_ip
, "ip=" },
204 { Opt_blank_ip
, "addr=" },
206 { Opt_ip
, "addr=%s" },
207 { Opt_ignore
, "unc=%s" },
208 { Opt_ignore
, "target=%s" },
209 { Opt_ignore
, "path=%s" },
210 { Opt_domain
, "dom=%s" },
211 { Opt_domain
, "domain=%s" },
212 { Opt_domain
, "workgroup=%s" },
213 { Opt_srcaddr
, "srcaddr=%s" },
214 { Opt_ignore
, "prefixpath=%s" },
215 { Opt_iocharset
, "iocharset=%s" },
216 { Opt_netbiosname
, "netbiosname=%s" },
217 { Opt_servern
, "servern=%s" },
218 { Opt_ver
, "ver=%s" },
219 { Opt_vers
, "vers=%s" },
220 { Opt_sec
, "sec=%s" },
221 { Opt_cache
, "cache=%s" },
223 { Opt_ignore
, "cred" },
224 { Opt_ignore
, "credentials" },
225 { Opt_ignore
, "cred=%s" },
226 { Opt_ignore
, "credentials=%s" },
227 { Opt_ignore
, "guest" },
228 { Opt_ignore
, "rw" },
229 { Opt_ignore
, "ro" },
230 { Opt_ignore
, "suid" },
231 { Opt_ignore
, "nosuid" },
232 { Opt_ignore
, "exec" },
233 { Opt_ignore
, "noexec" },
234 { Opt_ignore
, "nodev" },
235 { Opt_ignore
, "noauto" },
236 { Opt_ignore
, "dev" },
237 { Opt_ignore
, "mand" },
238 { Opt_ignore
, "nomand" },
239 { Opt_ignore
, "_netdev" },
245 Opt_sec_krb5
, Opt_sec_krb5i
, Opt_sec_krb5p
,
246 Opt_sec_ntlmsspi
, Opt_sec_ntlmssp
,
247 Opt_ntlm
, Opt_sec_ntlmi
, Opt_sec_ntlmv2
,
248 Opt_sec_ntlmv2i
, Opt_sec_lanman
,
254 static const match_table_t cifs_secflavor_tokens
= {
255 { Opt_sec_krb5
, "krb5" },
256 { Opt_sec_krb5i
, "krb5i" },
257 { Opt_sec_krb5p
, "krb5p" },
258 { Opt_sec_ntlmsspi
, "ntlmsspi" },
259 { Opt_sec_ntlmssp
, "ntlmssp" },
260 { Opt_ntlm
, "ntlm" },
261 { Opt_sec_ntlmi
, "ntlmi" },
262 { Opt_sec_ntlmv2
, "nontlm" },
263 { Opt_sec_ntlmv2
, "ntlmv2" },
264 { Opt_sec_ntlmv2i
, "ntlmv2i" },
265 { Opt_sec_lanman
, "lanman" },
266 { Opt_sec_none
, "none" },
268 { Opt_sec_err
, NULL
}
279 static const match_table_t cifs_cacheflavor_tokens
= {
280 { Opt_cache_loose
, "loose" },
281 { Opt_cache_strict
, "strict" },
282 { Opt_cache_none
, "none" },
283 { Opt_cache_err
, NULL
}
286 static const match_table_t cifs_smb_version_tokens
= {
287 { Smb_1
, SMB1_VERSION_STRING
},
288 { Smb_20
, SMB20_VERSION_STRING
},
289 { Smb_21
, SMB21_VERSION_STRING
},
290 { Smb_30
, SMB30_VERSION_STRING
},
291 { Smb_302
, SMB302_VERSION_STRING
},
292 #ifdef CONFIG_CIFS_SMB311
293 { Smb_311
, SMB311_VERSION_STRING
},
294 { Smb_311
, ALT_SMB311_VERSION_STRING
},
296 { Smb_version_err
, NULL
}
299 static int ip_connect(struct TCP_Server_Info
*server
);
300 static int generic_ip_connect(struct TCP_Server_Info
*server
);
301 static void tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
);
302 static void cifs_prune_tlinks(struct work_struct
*work
);
303 static int cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
304 const char *devname
);
307 * cifs tcp session reconnection
309 * mark tcp session as reconnecting so temporarily locked
310 * mark all smb sessions as reconnecting for tcp session
311 * reconnect tcp session
312 * wake up waiters on reconnection? - (not needed currently)
315 cifs_reconnect(struct TCP_Server_Info
*server
)
318 struct list_head
*tmp
, *tmp2
;
319 struct cifs_ses
*ses
;
320 struct cifs_tcon
*tcon
;
321 struct mid_q_entry
*mid_entry
;
322 struct list_head retry_list
;
324 spin_lock(&GlobalMid_Lock
);
325 if (server
->tcpStatus
== CifsExiting
) {
326 /* the demux thread will exit normally
327 next time through the loop */
328 spin_unlock(&GlobalMid_Lock
);
331 server
->tcpStatus
= CifsNeedReconnect
;
332 spin_unlock(&GlobalMid_Lock
);
334 #ifdef CONFIG_CIFS_SMB2
335 server
->max_read
= 0;
338 cifs_dbg(FYI
, "Reconnecting tcp session\n");
340 /* before reconnecting the tcp session, mark the smb session (uid)
341 and the tid bad so they are not used until reconnected */
342 cifs_dbg(FYI
, "%s: marking sessions and tcons for reconnect\n",
344 spin_lock(&cifs_tcp_ses_lock
);
345 list_for_each(tmp
, &server
->smb_ses_list
) {
346 ses
= list_entry(tmp
, struct cifs_ses
, smb_ses_list
);
347 ses
->need_reconnect
= true;
349 list_for_each(tmp2
, &ses
->tcon_list
) {
350 tcon
= list_entry(tmp2
, struct cifs_tcon
, tcon_list
);
351 tcon
->need_reconnect
= true;
354 spin_unlock(&cifs_tcp_ses_lock
);
356 /* do not want to be sending data on a socket we are freeing */
357 cifs_dbg(FYI
, "%s: tearing down socket\n", __func__
);
358 mutex_lock(&server
->srv_mutex
);
359 if (server
->ssocket
) {
360 cifs_dbg(FYI
, "State: 0x%x Flags: 0x%lx\n",
361 server
->ssocket
->state
, server
->ssocket
->flags
);
362 kernel_sock_shutdown(server
->ssocket
, SHUT_WR
);
363 cifs_dbg(FYI
, "Post shutdown state: 0x%x Flags: 0x%lx\n",
364 server
->ssocket
->state
, server
->ssocket
->flags
);
365 sock_release(server
->ssocket
);
366 server
->ssocket
= NULL
;
368 server
->sequence_number
= 0;
369 server
->session_estab
= false;
370 kfree(server
->session_key
.response
);
371 server
->session_key
.response
= NULL
;
372 server
->session_key
.len
= 0;
373 server
->lstrp
= jiffies
;
375 /* mark submitted MIDs for retry and issue callback */
376 INIT_LIST_HEAD(&retry_list
);
377 cifs_dbg(FYI
, "%s: moving mids to private list\n", __func__
);
378 spin_lock(&GlobalMid_Lock
);
379 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
380 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
381 if (mid_entry
->mid_state
== MID_REQUEST_SUBMITTED
)
382 mid_entry
->mid_state
= MID_RETRY_NEEDED
;
383 list_move(&mid_entry
->qhead
, &retry_list
);
385 spin_unlock(&GlobalMid_Lock
);
386 mutex_unlock(&server
->srv_mutex
);
388 cifs_dbg(FYI
, "%s: issuing mid callbacks\n", __func__
);
389 list_for_each_safe(tmp
, tmp2
, &retry_list
) {
390 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
391 list_del_init(&mid_entry
->qhead
);
392 mid_entry
->callback(mid_entry
);
398 /* we should try only the port we connected to before */
399 mutex_lock(&server
->srv_mutex
);
400 rc
= generic_ip_connect(server
);
402 cifs_dbg(FYI
, "reconnect error %d\n", rc
);
403 mutex_unlock(&server
->srv_mutex
);
406 atomic_inc(&tcpSesReconnectCount
);
407 spin_lock(&GlobalMid_Lock
);
408 if (server
->tcpStatus
!= CifsExiting
)
409 server
->tcpStatus
= CifsNeedNegotiate
;
410 spin_unlock(&GlobalMid_Lock
);
411 mutex_unlock(&server
->srv_mutex
);
413 } while (server
->tcpStatus
== CifsNeedReconnect
);
415 if (server
->tcpStatus
== CifsNeedNegotiate
)
416 mod_delayed_work(cifsiod_wq
, &server
->echo
, 0);
422 cifs_echo_request(struct work_struct
*work
)
425 struct TCP_Server_Info
*server
= container_of(work
,
426 struct TCP_Server_Info
, echo
.work
);
427 unsigned long echo_interval
;
430 * If we need to renegotiate, set echo interval to zero to
431 * immediately call echo service where we can renegotiate.
433 if (server
->tcpStatus
== CifsNeedNegotiate
)
436 echo_interval
= server
->echo_interval
;
439 * We cannot send an echo if it is disabled.
440 * Also, no need to ping if we got a response recently.
443 if (server
->tcpStatus
== CifsNeedReconnect
||
444 server
->tcpStatus
== CifsExiting
||
445 server
->tcpStatus
== CifsNew
||
446 (server
->ops
->can_echo
&& !server
->ops
->can_echo(server
)) ||
447 time_before(jiffies
, server
->lstrp
+ echo_interval
- HZ
))
450 rc
= server
->ops
->echo
? server
->ops
->echo(server
) : -ENOSYS
;
452 cifs_dbg(FYI
, "Unable to send echo request to server: %s\n",
456 queue_delayed_work(cifsiod_wq
, &server
->echo
, server
->echo_interval
);
460 allocate_buffers(struct TCP_Server_Info
*server
)
462 if (!server
->bigbuf
) {
463 server
->bigbuf
= (char *)cifs_buf_get();
464 if (!server
->bigbuf
) {
465 cifs_dbg(VFS
, "No memory for large SMB response\n");
467 /* retry will check if exiting */
470 } else if (server
->large_buf
) {
471 /* we are reusing a dirty large buf, clear its start */
472 memset(server
->bigbuf
, 0, HEADER_SIZE(server
));
475 if (!server
->smallbuf
) {
476 server
->smallbuf
= (char *)cifs_small_buf_get();
477 if (!server
->smallbuf
) {
478 cifs_dbg(VFS
, "No memory for SMB response\n");
480 /* retry will check if exiting */
483 /* beginning of smb buffer is cleared in our buf_get */
485 /* if existing small buf clear beginning */
486 memset(server
->smallbuf
, 0, HEADER_SIZE(server
));
493 server_unresponsive(struct TCP_Server_Info
*server
)
496 * We need to wait 2 echo intervals to make sure we handle such
498 * 1s client sends a normal SMB request
499 * 2s client gets a response
500 * 30s echo workqueue job pops, and decides we got a response recently
501 * and don't need to send another
503 * 65s kernel_recvmsg times out, and we see that we haven't gotten
504 * a response in >60s.
506 if (server
->tcpStatus
== CifsGood
&&
507 time_after(jiffies
, server
->lstrp
+ 2 * server
->echo_interval
)) {
508 cifs_dbg(VFS
, "Server %s has not responded in %lu seconds. Reconnecting...\n",
509 server
->hostname
, (2 * server
->echo_interval
) / HZ
);
510 cifs_reconnect(server
);
511 wake_up(&server
->response_q
);
519 cifs_readv_from_socket(struct TCP_Server_Info
*server
, struct msghdr
*smb_msg
)
524 smb_msg
->msg_control
= NULL
;
525 smb_msg
->msg_controllen
= 0;
527 for (total_read
= 0; msg_data_left(smb_msg
); total_read
+= length
) {
530 if (server_unresponsive(server
))
531 return -ECONNABORTED
;
533 length
= sock_recvmsg(server
->ssocket
, smb_msg
, 0);
535 if (server
->tcpStatus
== CifsExiting
)
538 if (server
->tcpStatus
== CifsNeedReconnect
) {
539 cifs_reconnect(server
);
540 return -ECONNABORTED
;
543 if (length
== -ERESTARTSYS
||
547 * Minimum sleep to prevent looping, allowing socket
548 * to clear and app threads to set tcpStatus
549 * CifsNeedReconnect if server hung.
551 usleep_range(1000, 2000);
557 cifs_dbg(FYI
, "Received no data or error: %d\n", length
);
558 cifs_reconnect(server
);
559 return -ECONNABORTED
;
566 cifs_read_from_socket(struct TCP_Server_Info
*server
, char *buf
,
567 unsigned int to_read
)
569 struct msghdr smb_msg
;
570 struct kvec iov
= {.iov_base
= buf
, .iov_len
= to_read
};
571 iov_iter_kvec(&smb_msg
.msg_iter
, READ
| ITER_KVEC
, &iov
, 1, to_read
);
573 return cifs_readv_from_socket(server
, &smb_msg
);
577 cifs_read_page_from_socket(struct TCP_Server_Info
*server
, struct page
*page
,
578 unsigned int to_read
)
580 struct msghdr smb_msg
;
581 struct bio_vec bv
= {.bv_page
= page
, .bv_len
= to_read
};
582 iov_iter_bvec(&smb_msg
.msg_iter
, READ
| ITER_BVEC
, &bv
, 1, to_read
);
583 return cifs_readv_from_socket(server
, &smb_msg
);
587 is_smb_response(struct TCP_Server_Info
*server
, unsigned char type
)
590 * The first byte big endian of the length field,
591 * is actually not part of the length but the type
592 * with the most common, zero, as regular data.
595 case RFC1002_SESSION_MESSAGE
:
596 /* Regular SMB response */
598 case RFC1002_SESSION_KEEP_ALIVE
:
599 cifs_dbg(FYI
, "RFC 1002 session keep alive\n");
601 case RFC1002_POSITIVE_SESSION_RESPONSE
:
602 cifs_dbg(FYI
, "RFC 1002 positive session response\n");
604 case RFC1002_NEGATIVE_SESSION_RESPONSE
:
606 * We get this from Windows 98 instead of an error on
607 * SMB negprot response.
609 cifs_dbg(FYI
, "RFC 1002 negative session response\n");
610 /* give server a second to clean up */
613 * Always try 445 first on reconnect since we get NACK
614 * on some if we ever connected to port 139 (the NACK
615 * is since we do not begin with RFC1001 session
618 cifs_set_port((struct sockaddr
*)&server
->dstaddr
, CIFS_PORT
);
619 cifs_reconnect(server
);
620 wake_up(&server
->response_q
);
623 cifs_dbg(VFS
, "RFC 1002 unknown response type 0x%x\n", type
);
624 cifs_reconnect(server
);
631 dequeue_mid(struct mid_q_entry
*mid
, bool malformed
)
633 #ifdef CONFIG_CIFS_STATS2
634 mid
->when_received
= jiffies
;
636 spin_lock(&GlobalMid_Lock
);
638 mid
->mid_state
= MID_RESPONSE_RECEIVED
;
640 mid
->mid_state
= MID_RESPONSE_MALFORMED
;
641 list_del_init(&mid
->qhead
);
642 spin_unlock(&GlobalMid_Lock
);
646 handle_mid(struct mid_q_entry
*mid
, struct TCP_Server_Info
*server
,
647 char *buf
, int malformed
)
649 if (server
->ops
->check_trans2
&&
650 server
->ops
->check_trans2(mid
, server
, buf
, malformed
))
653 mid
->large_buf
= server
->large_buf
;
654 /* Was previous buf put in mpx struct for multi-rsp? */
655 if (!mid
->multiRsp
) {
656 /* smb buffer will be freed by user thread */
657 if (server
->large_buf
)
658 server
->bigbuf
= NULL
;
660 server
->smallbuf
= NULL
;
662 dequeue_mid(mid
, malformed
);
665 static void clean_demultiplex_info(struct TCP_Server_Info
*server
)
669 /* take it off the list, if it's not already */
670 spin_lock(&cifs_tcp_ses_lock
);
671 list_del_init(&server
->tcp_ses_list
);
672 spin_unlock(&cifs_tcp_ses_lock
);
674 spin_lock(&GlobalMid_Lock
);
675 server
->tcpStatus
= CifsExiting
;
676 spin_unlock(&GlobalMid_Lock
);
677 wake_up_all(&server
->response_q
);
679 /* check if we have blocked requests that need to free */
680 spin_lock(&server
->req_lock
);
681 if (server
->credits
<= 0)
683 spin_unlock(&server
->req_lock
);
685 * Although there should not be any requests blocked on this queue it
686 * can not hurt to be paranoid and try to wake up requests that may
687 * haven been blocked when more than 50 at time were on the wire to the
688 * same server - they now will see the session is in exit state and get
689 * out of SendReceive.
691 wake_up_all(&server
->request_q
);
692 /* give those requests time to exit */
695 if (server
->ssocket
) {
696 sock_release(server
->ssocket
);
697 server
->ssocket
= NULL
;
700 if (!list_empty(&server
->pending_mid_q
)) {
701 struct list_head dispose_list
;
702 struct mid_q_entry
*mid_entry
;
703 struct list_head
*tmp
, *tmp2
;
705 INIT_LIST_HEAD(&dispose_list
);
706 spin_lock(&GlobalMid_Lock
);
707 list_for_each_safe(tmp
, tmp2
, &server
->pending_mid_q
) {
708 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
709 cifs_dbg(FYI
, "Clearing mid 0x%llx\n", mid_entry
->mid
);
710 mid_entry
->mid_state
= MID_SHUTDOWN
;
711 list_move(&mid_entry
->qhead
, &dispose_list
);
713 spin_unlock(&GlobalMid_Lock
);
715 /* now walk dispose list and issue callbacks */
716 list_for_each_safe(tmp
, tmp2
, &dispose_list
) {
717 mid_entry
= list_entry(tmp
, struct mid_q_entry
, qhead
);
718 cifs_dbg(FYI
, "Callback mid 0x%llx\n", mid_entry
->mid
);
719 list_del_init(&mid_entry
->qhead
);
720 mid_entry
->callback(mid_entry
);
722 /* 1/8th of sec is more than enough time for them to exit */
726 if (!list_empty(&server
->pending_mid_q
)) {
728 * mpx threads have not exited yet give them at least the smb
729 * send timeout time for long ops.
731 * Due to delays on oplock break requests, we need to wait at
732 * least 45 seconds before giving up on a request getting a
733 * response and going ahead and killing cifsd.
735 cifs_dbg(FYI
, "Wait for exit from demultiplex thread\n");
738 * If threads still have not exited they are probably never
739 * coming home not much else we can do but free the memory.
743 kfree(server
->hostname
);
746 length
= atomic_dec_return(&tcpSesAllocCount
);
748 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
);
752 standard_receive3(struct TCP_Server_Info
*server
, struct mid_q_entry
*mid
)
755 char *buf
= server
->smallbuf
;
756 unsigned int pdu_length
= get_rfc1002_length(buf
);
758 /* make sure this will fit in a large buffer */
759 if (pdu_length
> CIFSMaxBufSize
+ MAX_HEADER_SIZE(server
) - 4) {
760 cifs_dbg(VFS
, "SMB response too long (%u bytes)\n", pdu_length
);
761 cifs_reconnect(server
);
762 wake_up(&server
->response_q
);
763 return -ECONNABORTED
;
766 /* switch to large buffer if too big for a small one */
767 if (pdu_length
> MAX_CIFS_SMALL_BUFFER_SIZE
- 4) {
768 server
->large_buf
= true;
769 memcpy(server
->bigbuf
, buf
, server
->total_read
);
770 buf
= server
->bigbuf
;
773 /* now read the rest */
774 length
= cifs_read_from_socket(server
, buf
+ HEADER_SIZE(server
) - 1,
775 pdu_length
- HEADER_SIZE(server
) + 1 + 4);
778 server
->total_read
+= length
;
780 dump_smb(buf
, server
->total_read
);
783 * We know that we received enough to get to the MID as we
784 * checked the pdu_length earlier. Now check to see
785 * if the rest of the header is OK. We borrow the length
786 * var for the rest of the loop to avoid a new stack var.
788 * 48 bytes is enough to display the header and a little bit
789 * into the payload for debugging purposes.
791 length
= server
->ops
->check_message(buf
, server
->total_read
, server
);
793 cifs_dump_mem("Bad SMB: ", buf
,
794 min_t(unsigned int, server
->total_read
, 48));
796 if (server
->ops
->is_status_pending
&&
797 server
->ops
->is_status_pending(buf
, server
, length
))
803 handle_mid(mid
, server
, buf
, length
);
808 cifs_demultiplex_thread(void *p
)
811 struct TCP_Server_Info
*server
= p
;
812 unsigned int pdu_length
;
814 struct task_struct
*task_to_wake
= NULL
;
815 struct mid_q_entry
*mid_entry
;
817 current
->flags
|= PF_MEMALLOC
;
818 cifs_dbg(FYI
, "Demultiplex PID: %d\n", task_pid_nr(current
));
820 length
= atomic_inc_return(&tcpSesAllocCount
);
822 mempool_resize(cifs_req_poolp
, length
+ cifs_min_rcv
);
825 while (server
->tcpStatus
!= CifsExiting
) {
829 if (!allocate_buffers(server
))
832 server
->large_buf
= false;
833 buf
= server
->smallbuf
;
834 pdu_length
= 4; /* enough to get RFC1001 header */
836 length
= cifs_read_from_socket(server
, buf
, pdu_length
);
839 server
->total_read
= length
;
842 * The right amount was read from socket - 4 bytes,
843 * so we can now interpret the length field.
845 pdu_length
= get_rfc1002_length(buf
);
847 cifs_dbg(FYI
, "RFC1002 header 0x%x\n", pdu_length
);
848 if (!is_smb_response(server
, buf
[0]))
851 /* make sure we have enough to get to the MID */
852 if (pdu_length
< HEADER_SIZE(server
) - 1 - 4) {
853 cifs_dbg(VFS
, "SMB response too short (%u bytes)\n",
855 cifs_reconnect(server
);
856 wake_up(&server
->response_q
);
860 /* read down to the MID */
861 length
= cifs_read_from_socket(server
, buf
+ 4,
862 HEADER_SIZE(server
) - 1 - 4);
865 server
->total_read
+= length
;
867 mid_entry
= server
->ops
->find_mid(server
, buf
);
869 if (!mid_entry
|| !mid_entry
->receive
)
870 length
= standard_receive3(server
, mid_entry
);
872 length
= mid_entry
->receive(server
, mid_entry
);
877 if (server
->large_buf
)
878 buf
= server
->bigbuf
;
880 server
->lstrp
= jiffies
;
881 if (mid_entry
!= NULL
) {
882 if (!mid_entry
->multiRsp
|| mid_entry
->multiEnd
)
883 mid_entry
->callback(mid_entry
);
884 } else if (!server
->ops
->is_oplock_break
||
885 !server
->ops
->is_oplock_break(buf
, server
)) {
886 cifs_dbg(VFS
, "No task to wake, unknown frame received! NumMids %d\n",
887 atomic_read(&midCount
));
888 cifs_dump_mem("Received Data is: ", buf
,
889 HEADER_SIZE(server
));
890 #ifdef CONFIG_CIFS_DEBUG2
891 if (server
->ops
->dump_detail
)
892 server
->ops
->dump_detail(buf
);
893 cifs_dump_mids(server
);
894 #endif /* CIFS_DEBUG2 */
897 } /* end while !EXITING */
899 /* buffer usually freed in free_mid - need to free it here on exit */
900 cifs_buf_release(server
->bigbuf
);
901 if (server
->smallbuf
) /* no sense logging a debug message if NULL */
902 cifs_small_buf_release(server
->smallbuf
);
904 task_to_wake
= xchg(&server
->tsk
, NULL
);
905 clean_demultiplex_info(server
);
907 /* if server->tsk was NULL then wait for a signal before exiting */
909 set_current_state(TASK_INTERRUPTIBLE
);
910 while (!signal_pending(current
)) {
912 set_current_state(TASK_INTERRUPTIBLE
);
914 set_current_state(TASK_RUNNING
);
917 module_put_and_exit(0);
920 /* extract the host portion of the UNC string */
922 extract_hostname(const char *unc
)
928 /* skip double chars at beginning of string */
929 /* BB: check validity of these bytes? */
932 /* delimiter between hostname and sharename is always '\\' now */
933 delim
= strchr(src
, '\\');
935 return ERR_PTR(-EINVAL
);
938 dst
= kmalloc((len
+ 1), GFP_KERNEL
);
940 return ERR_PTR(-ENOMEM
);
942 memcpy(dst
, src
, len
);
948 static int get_option_ul(substring_t args
[], unsigned long *option
)
953 string
= match_strdup(args
);
956 rc
= kstrtoul(string
, 0, option
);
962 static int get_option_uid(substring_t args
[], kuid_t
*result
)
968 rc
= get_option_ul(args
, &value
);
972 uid
= make_kuid(current_user_ns(), value
);
980 static int get_option_gid(substring_t args
[], kgid_t
*result
)
986 rc
= get_option_ul(args
, &value
);
990 gid
= make_kgid(current_user_ns(), value
);
998 static int cifs_parse_security_flavors(char *value
,
1002 substring_t args
[MAX_OPT_ARGS
];
1005 * With mount options, the last one should win. Reset any existing
1006 * settings back to default.
1008 vol
->sectype
= Unspecified
;
1011 switch (match_token(value
, cifs_secflavor_tokens
, args
)) {
1013 cifs_dbg(VFS
, "sec=krb5p is not supported!\n");
1019 vol
->sectype
= Kerberos
;
1021 case Opt_sec_ntlmsspi
:
1024 case Opt_sec_ntlmssp
:
1025 vol
->sectype
= RawNTLMSSP
;
1031 vol
->sectype
= NTLM
;
1033 case Opt_sec_ntlmv2i
:
1036 case Opt_sec_ntlmv2
:
1037 vol
->sectype
= NTLMv2
;
1039 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1040 case Opt_sec_lanman
:
1041 vol
->sectype
= LANMAN
;
1048 cifs_dbg(VFS
, "bad security option: %s\n", value
);
1056 cifs_parse_cache_flavor(char *value
, struct smb_vol
*vol
)
1058 substring_t args
[MAX_OPT_ARGS
];
1060 switch (match_token(value
, cifs_cacheflavor_tokens
, args
)) {
1061 case Opt_cache_loose
:
1062 vol
->direct_io
= false;
1063 vol
->strict_io
= false;
1065 case Opt_cache_strict
:
1066 vol
->direct_io
= false;
1067 vol
->strict_io
= true;
1069 case Opt_cache_none
:
1070 vol
->direct_io
= true;
1071 vol
->strict_io
= false;
1074 cifs_dbg(VFS
, "bad cache= option: %s\n", value
);
1081 cifs_parse_smb_version(char *value
, struct smb_vol
*vol
)
1083 substring_t args
[MAX_OPT_ARGS
];
1085 switch (match_token(value
, cifs_smb_version_tokens
, args
)) {
1087 vol
->ops
= &smb1_operations
;
1088 vol
->vals
= &smb1_values
;
1090 #ifdef CONFIG_CIFS_SMB2
1092 vol
->ops
= &smb20_operations
;
1093 vol
->vals
= &smb20_values
;
1096 vol
->ops
= &smb21_operations
;
1097 vol
->vals
= &smb21_values
;
1100 vol
->ops
= &smb30_operations
;
1101 vol
->vals
= &smb30_values
;
1104 vol
->ops
= &smb30_operations
; /* currently identical with 3.0 */
1105 vol
->vals
= &smb302_values
;
1107 #ifdef CONFIG_CIFS_SMB311
1109 vol
->ops
= &smb311_operations
;
1110 vol
->vals
= &smb311_values
;
1115 cifs_dbg(VFS
, "Unknown vers= option specified: %s\n", value
);
1122 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1123 * fields with the result. Returns 0 on success and an error otherwise.
1126 cifs_parse_devname(const char *devname
, struct smb_vol
*vol
)
1129 const char *delims
= "/\\";
1132 /* make sure we have a valid UNC double delimiter prefix */
1133 len
= strspn(devname
, delims
);
1137 /* find delimiter between host and sharename */
1138 pos
= strpbrk(devname
+ 2, delims
);
1142 /* skip past delimiter */
1145 /* now go until next delimiter or end of string */
1146 len
= strcspn(pos
, delims
);
1148 /* move "pos" up to delimiter or NULL */
1150 vol
->UNC
= kstrndup(devname
, pos
- devname
, GFP_KERNEL
);
1154 convert_delimiter(vol
->UNC
, '\\');
1156 /* skip any delimiter */
1157 if (*pos
== '/' || *pos
== '\\')
1160 /* If pos is NULL then no prepath */
1164 vol
->prepath
= kstrdup(pos
, GFP_KERNEL
);
1172 cifs_parse_mount_options(const char *mountdata
, const char *devname
,
1173 struct smb_vol
*vol
)
1176 char *mountdata_copy
= NULL
, *options
;
1177 unsigned int temp_len
, i
, j
;
1179 short int override_uid
= -1;
1180 short int override_gid
= -1;
1181 bool uid_specified
= false;
1182 bool gid_specified
= false;
1183 bool sloppy
= false;
1184 char *invalid
= NULL
;
1185 char *nodename
= utsname()->nodename
;
1186 char *string
= NULL
;
1187 char *tmp_end
, *value
;
1189 bool got_ip
= false;
1190 unsigned short port
= 0;
1191 struct sockaddr
*dstaddr
= (struct sockaddr
*)&vol
->dstaddr
;
1195 delim
= separator
[0];
1197 /* ensure we always start with zeroed-out smb_vol */
1198 memset(vol
, 0, sizeof(*vol
));
1201 * does not have to be perfect mapping since field is
1202 * informational, only used for servers that do not support
1203 * port 445 and it can be overridden at mount time
1205 memset(vol
->source_rfc1001_name
, 0x20, RFC1001_NAME_LEN
);
1206 for (i
= 0; i
< strnlen(nodename
, RFC1001_NAME_LEN
); i
++)
1207 vol
->source_rfc1001_name
[i
] = toupper(nodename
[i
]);
1209 vol
->source_rfc1001_name
[RFC1001_NAME_LEN
] = 0;
1210 /* null target name indicates to use *SMBSERVR default called name
1211 if we end up sending RFC1001 session initialize */
1212 vol
->target_rfc1001_name
[0] = 0;
1213 vol
->cred_uid
= current_uid();
1214 vol
->linux_uid
= current_uid();
1215 vol
->linux_gid
= current_gid();
1218 * default to SFM style remapping of seven reserved characters
1219 * unless user overrides it or we negotiate CIFS POSIX where
1220 * it is unnecessary. Can not simultaneously use more than one mapping
1221 * since then readdir could list files that open could not open
1225 /* default to only allowing write access to owner of the mount */
1226 vol
->dir_mode
= vol
->file_mode
= S_IRUGO
| S_IXUGO
| S_IWUSR
;
1228 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1229 /* default is always to request posix paths. */
1230 vol
->posix_paths
= 1;
1231 /* default to using server inode numbers where available */
1232 vol
->server_ino
= 1;
1234 /* default is to use strict cifs caching semantics */
1235 vol
->strict_io
= true;
1237 vol
->actimeo
= CIFS_DEF_ACTIMEO
;
1239 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1240 vol
->ops
= &smb1_operations
;
1241 vol
->vals
= &smb1_values
;
1243 vol
->echo_interval
= SMB_ECHO_INTERVAL_DEFAULT
;
1246 goto cifs_parse_mount_err
;
1248 mountdata_copy
= kstrndup(mountdata
, PAGE_SIZE
, GFP_KERNEL
);
1249 if (!mountdata_copy
)
1250 goto cifs_parse_mount_err
;
1252 options
= mountdata_copy
;
1253 end
= options
+ strlen(options
);
1255 if (strncmp(options
, "sep=", 4) == 0) {
1256 if (options
[4] != 0) {
1257 separator
[0] = options
[4];
1260 cifs_dbg(FYI
, "Null separator not allowed\n");
1263 vol
->backupuid_specified
= false; /* no backup intent for a user */
1264 vol
->backupgid_specified
= false; /* no backup intent for a group */
1266 switch (cifs_parse_devname(devname
, vol
)) {
1270 cifs_dbg(VFS
, "Unable to allocate memory for devname.\n");
1271 goto cifs_parse_mount_err
;
1273 cifs_dbg(VFS
, "Malformed UNC in devname.\n");
1274 goto cifs_parse_mount_err
;
1276 cifs_dbg(VFS
, "Unknown error parsing devname.\n");
1277 goto cifs_parse_mount_err
;
1280 while ((data
= strsep(&options
, separator
)) != NULL
) {
1281 substring_t args
[MAX_OPT_ARGS
];
1282 unsigned long option
;
1288 token
= match_token(data
, cifs_mount_option_tokens
, args
);
1292 /* Ingnore the following */
1296 /* Boolean values */
1297 case Opt_user_xattr
:
1300 case Opt_nouser_xattr
:
1306 case Opt_noforceuid
:
1312 case Opt_noforcegid
:
1315 case Opt_noblocksend
:
1316 vol
->noblocksnd
= 1;
1318 case Opt_noautotune
:
1319 vol
->noautotune
= 1;
1334 vol
->sfu_remap
= true;
1335 vol
->remap
= false; /* disable SFM mapping */
1337 case Opt_nomapchars
:
1338 vol
->sfu_remap
= false;
1342 vol
->sfu_remap
= false; /* disable SFU mapping */
1344 case Opt_nomapposix
:
1356 case Opt_posixpaths
:
1357 vol
->posix_paths
= 1;
1359 case Opt_noposixpaths
:
1360 vol
->posix_paths
= 0;
1363 vol
->no_linux_ext
= 1;
1374 * turn off mandatory locking in mode
1375 * if remote locking is turned off since the
1376 * local vfs will do advisory
1378 if (vol
->file_mode
==
1379 (S_IALLUGO
& ~(S_ISUID
| S_IXGRP
)))
1380 vol
->file_mode
= S_IALLUGO
;
1382 case Opt_forcemandatorylock
:
1391 case Opt_setuidfromacl
:
1392 vol
->setuidfromacl
= 1;
1395 vol
->dynperm
= true;
1398 vol
->dynperm
= false;
1412 case Opt_nostrictsync
:
1413 vol
->nostrictsync
= 1;
1415 case Opt_strictsync
:
1416 vol
->nostrictsync
= 0;
1419 vol
->server_ino
= 1;
1421 case Opt_noserverino
:
1422 vol
->server_ino
= 0;
1424 case Opt_rwpidforward
:
1425 vol
->rwpidforward
= 1;
1434 vol
->no_psx_acl
= 0;
1437 vol
->no_psx_acl
= 1;
1439 case Opt_locallease
:
1440 vol
->local_lease
= 1;
1446 /* we do not do the following in secFlags because seal
1447 * is a per tree connection (mount) not a per socket
1448 * or per-smb connection option in the protocol
1449 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1454 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1457 #ifndef CONFIG_CIFS_FSCACHE
1458 cifs_dbg(VFS
, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1459 goto cifs_parse_mount_err
;
1463 case Opt_mfsymlinks
:
1464 vol
->mfsymlinks
= true;
1467 vol
->multiuser
= true;
1472 case Opt_nosharesock
:
1473 vol
->nosharesock
= true;
1475 case Opt_nopersistent
:
1476 vol
->nopersistent
= true;
1477 if (vol
->persistent
) {
1479 "persistenthandles mount options conflict\n");
1480 goto cifs_parse_mount_err
;
1483 case Opt_persistent
:
1484 vol
->persistent
= true;
1485 if ((vol
->nopersistent
) || (vol
->resilient
)) {
1487 "persistenthandles mount options conflict\n");
1488 goto cifs_parse_mount_err
;
1492 vol
->resilient
= true;
1493 if (vol
->persistent
) {
1495 "persistenthandles mount options conflict\n");
1496 goto cifs_parse_mount_err
;
1499 case Opt_noresilient
:
1500 vol
->resilient
= false; /* already the default */
1503 /* Numeric Values */
1505 if (get_option_uid(args
, &vol
->backupuid
)) {
1506 cifs_dbg(VFS
, "%s: Invalid backupuid value\n",
1508 goto cifs_parse_mount_err
;
1510 vol
->backupuid_specified
= true;
1513 if (get_option_gid(args
, &vol
->backupgid
)) {
1514 cifs_dbg(VFS
, "%s: Invalid backupgid value\n",
1516 goto cifs_parse_mount_err
;
1518 vol
->backupgid_specified
= true;
1521 if (get_option_uid(args
, &vol
->linux_uid
)) {
1522 cifs_dbg(VFS
, "%s: Invalid uid value\n",
1524 goto cifs_parse_mount_err
;
1526 uid_specified
= true;
1529 if (get_option_uid(args
, &vol
->cred_uid
)) {
1530 cifs_dbg(VFS
, "%s: Invalid cruid value\n",
1532 goto cifs_parse_mount_err
;
1536 if (get_option_gid(args
, &vol
->linux_gid
)) {
1537 cifs_dbg(VFS
, "%s: Invalid gid value\n",
1539 goto cifs_parse_mount_err
;
1541 gid_specified
= true;
1544 if (get_option_ul(args
, &option
)) {
1545 cifs_dbg(VFS
, "%s: Invalid file_mode value\n",
1547 goto cifs_parse_mount_err
;
1549 vol
->file_mode
= option
;
1552 if (get_option_ul(args
, &option
)) {
1553 cifs_dbg(VFS
, "%s: Invalid dir_mode value\n",
1555 goto cifs_parse_mount_err
;
1557 vol
->dir_mode
= option
;
1560 if (get_option_ul(args
, &option
) ||
1561 option
> USHRT_MAX
) {
1562 cifs_dbg(VFS
, "%s: Invalid port value\n",
1564 goto cifs_parse_mount_err
;
1566 port
= (unsigned short)option
;
1569 if (get_option_ul(args
, &option
)) {
1570 cifs_dbg(VFS
, "%s: Invalid rsize value\n",
1572 goto cifs_parse_mount_err
;
1574 vol
->rsize
= option
;
1577 if (get_option_ul(args
, &option
)) {
1578 cifs_dbg(VFS
, "%s: Invalid wsize value\n",
1580 goto cifs_parse_mount_err
;
1582 vol
->wsize
= option
;
1585 if (get_option_ul(args
, &option
)) {
1586 cifs_dbg(VFS
, "%s: Invalid actimeo value\n",
1588 goto cifs_parse_mount_err
;
1590 vol
->actimeo
= HZ
* option
;
1591 if (vol
->actimeo
> CIFS_MAX_ACTIMEO
) {
1592 cifs_dbg(VFS
, "attribute cache timeout too large\n");
1593 goto cifs_parse_mount_err
;
1596 case Opt_echo_interval
:
1597 if (get_option_ul(args
, &option
)) {
1598 cifs_dbg(VFS
, "%s: Invalid echo interval value\n",
1600 goto cifs_parse_mount_err
;
1602 vol
->echo_interval
= option
;
1604 case Opt_max_credits
:
1605 if (get_option_ul(args
, &option
) || (option
< 20) ||
1607 cifs_dbg(VFS
, "%s: Invalid max_credits value\n",
1609 goto cifs_parse_mount_err
;
1611 vol
->max_credits
= option
;
1614 /* String Arguments */
1616 case Opt_blank_user
:
1617 /* null user, ie. anonymous authentication */
1619 vol
->username
= NULL
;
1622 string
= match_strdup(args
);
1626 if (strnlen(string
, CIFS_MAX_USERNAME_LEN
) >
1627 CIFS_MAX_USERNAME_LEN
) {
1628 pr_warn("CIFS: username too long\n");
1629 goto cifs_parse_mount_err
;
1632 kfree(vol
->username
);
1633 vol
->username
= kstrdup(string
, GFP_KERNEL
);
1635 goto cifs_parse_mount_err
;
1637 case Opt_blank_pass
:
1638 /* passwords have to be handled differently
1639 * to allow the character used for deliminator
1640 * to be passed within them
1644 * Check if this is a case where the password
1645 * starts with a delimiter
1647 tmp_end
= strchr(data
, '=');
1649 if (!(tmp_end
< end
&& tmp_end
[1] == delim
)) {
1650 /* No it is not. Set the password to NULL */
1651 kfree(vol
->password
);
1652 vol
->password
= NULL
;
1655 /* Yes it is. Drop down to Opt_pass below.*/
1657 /* Obtain the value string */
1658 value
= strchr(data
, '=');
1661 /* Set tmp_end to end of the string */
1662 tmp_end
= (char *) value
+ strlen(value
);
1664 /* Check if following character is the deliminator
1665 * If yes, we have encountered a double deliminator
1666 * reset the NULL character to the deliminator
1668 if (tmp_end
< end
&& tmp_end
[1] == delim
) {
1671 /* Keep iterating until we get to a single
1672 * deliminator OR the end
1674 while ((tmp_end
= strchr(tmp_end
, delim
))
1675 != NULL
&& (tmp_end
[1] == delim
)) {
1676 tmp_end
= (char *) &tmp_end
[2];
1679 /* Reset var options to point to next element */
1682 options
= (char *) &tmp_end
[1];
1684 /* Reached the end of the mount option
1689 kfree(vol
->password
);
1690 /* Now build new password string */
1691 temp_len
= strlen(value
);
1692 vol
->password
= kzalloc(temp_len
+1, GFP_KERNEL
);
1693 if (vol
->password
== NULL
) {
1694 pr_warn("CIFS: no memory for password\n");
1695 goto cifs_parse_mount_err
;
1698 for (i
= 0, j
= 0; i
< temp_len
; i
++, j
++) {
1699 vol
->password
[j
] = value
[i
];
1700 if ((value
[i
] == delim
) &&
1701 value
[i
+1] == delim
)
1702 /* skip the second deliminator */
1705 vol
->password
[j
] = '\0';
1708 /* FIXME: should this be an error instead? */
1712 string
= match_strdup(args
);
1716 if (!cifs_convert_address(dstaddr
, string
,
1718 pr_err("CIFS: bad ip= option (%s).\n", string
);
1719 goto cifs_parse_mount_err
;
1724 string
= match_strdup(args
);
1728 if (strnlen(string
, CIFS_MAX_DOMAINNAME_LEN
)
1729 == CIFS_MAX_DOMAINNAME_LEN
) {
1730 pr_warn("CIFS: domain name too long\n");
1731 goto cifs_parse_mount_err
;
1734 kfree(vol
->domainname
);
1735 vol
->domainname
= kstrdup(string
, GFP_KERNEL
);
1736 if (!vol
->domainname
) {
1737 pr_warn("CIFS: no memory for domainname\n");
1738 goto cifs_parse_mount_err
;
1740 cifs_dbg(FYI
, "Domain name set\n");
1743 string
= match_strdup(args
);
1747 if (!cifs_convert_address(
1748 (struct sockaddr
*)&vol
->srcaddr
,
1749 string
, strlen(string
))) {
1750 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1752 goto cifs_parse_mount_err
;
1756 string
= match_strdup(args
);
1760 if (strnlen(string
, 1024) >= 65) {
1761 pr_warn("CIFS: iocharset name too long.\n");
1762 goto cifs_parse_mount_err
;
1765 if (strncasecmp(string
, "default", 7) != 0) {
1766 kfree(vol
->iocharset
);
1767 vol
->iocharset
= kstrdup(string
,
1769 if (!vol
->iocharset
) {
1770 pr_warn("CIFS: no memory for charset\n");
1771 goto cifs_parse_mount_err
;
1774 /* if iocharset not set then load_nls_default
1777 cifs_dbg(FYI
, "iocharset set to %s\n", string
);
1779 case Opt_netbiosname
:
1780 string
= match_strdup(args
);
1784 memset(vol
->source_rfc1001_name
, 0x20,
1787 * FIXME: are there cases in which a comma can
1788 * be valid in workstation netbios name (and
1789 * need special handling)?
1791 for (i
= 0; i
< RFC1001_NAME_LEN
; i
++) {
1792 /* don't ucase netbiosname for user */
1795 vol
->source_rfc1001_name
[i
] = string
[i
];
1797 /* The string has 16th byte zero still from
1798 * set at top of the function
1800 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
1801 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1804 /* servernetbiosname specified override *SMBSERVER */
1805 string
= match_strdup(args
);
1809 /* last byte, type, is 0x20 for servr type */
1810 memset(vol
->target_rfc1001_name
, 0x20,
1811 RFC1001_NAME_LEN_WITH_NULL
);
1813 /* BB are there cases in which a comma can be
1814 valid in this workstation netbios name
1815 (and need special handling)? */
1817 /* user or mount helper must uppercase the
1819 for (i
= 0; i
< 15; i
++) {
1822 vol
->target_rfc1001_name
[i
] = string
[i
];
1824 /* The string has 16th byte zero still from
1825 set at top of the function */
1826 if (i
== RFC1001_NAME_LEN
&& string
[i
] != 0)
1827 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1830 string
= match_strdup(args
);
1834 if (strncasecmp(string
, "1", 1) == 0) {
1835 /* This is the default */
1838 /* For all other value, error */
1839 pr_warn("CIFS: Invalid version specified\n");
1840 goto cifs_parse_mount_err
;
1842 string
= match_strdup(args
);
1846 if (cifs_parse_smb_version(string
, vol
) != 0)
1847 goto cifs_parse_mount_err
;
1850 string
= match_strdup(args
);
1854 if (cifs_parse_security_flavors(string
, vol
) != 0)
1855 goto cifs_parse_mount_err
;
1858 string
= match_strdup(args
);
1862 if (cifs_parse_cache_flavor(string
, vol
) != 0)
1863 goto cifs_parse_mount_err
;
1867 * An option we don't recognize. Save it off for later
1868 * if we haven't already found one
1874 /* Free up any allocated string */
1879 if (!sloppy
&& invalid
) {
1880 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid
);
1881 goto cifs_parse_mount_err
;
1885 /* Muliuser mounts require CONFIG_KEYS support */
1886 if (vol
->multiuser
) {
1887 cifs_dbg(VFS
, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1888 goto cifs_parse_mount_err
;
1892 cifs_dbg(VFS
, "CIFS mount error: No usable UNC path provided in device string!\n");
1893 goto cifs_parse_mount_err
;
1896 /* make sure UNC has a share name */
1897 if (!strchr(vol
->UNC
+ 3, '\\')) {
1898 cifs_dbg(VFS
, "Malformed UNC. Unable to find share name.\n");
1899 goto cifs_parse_mount_err
;
1903 /* No ip= option specified? Try to get it from UNC */
1904 if (!cifs_convert_address(dstaddr
, &vol
->UNC
[2],
1905 strlen(&vol
->UNC
[2]))) {
1906 pr_err("Unable to determine destination address.\n");
1907 goto cifs_parse_mount_err
;
1911 /* set the port that we got earlier */
1912 cifs_set_port(dstaddr
, port
);
1915 vol
->override_uid
= override_uid
;
1916 else if (override_uid
== 1)
1917 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
1920 vol
->override_gid
= override_gid
;
1921 else if (override_gid
== 1)
1922 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
1924 kfree(mountdata_copy
);
1928 pr_warn("Could not allocate temporary buffer\n");
1929 cifs_parse_mount_err
:
1931 kfree(mountdata_copy
);
1935 /** Returns true if srcaddr isn't specified and rhs isn't
1936 * specified, or if srcaddr is specified and
1937 * matches the IP address of the rhs argument.
1940 srcip_matches(struct sockaddr
*srcaddr
, struct sockaddr
*rhs
)
1942 switch (srcaddr
->sa_family
) {
1944 return (rhs
->sa_family
== AF_UNSPEC
);
1946 struct sockaddr_in
*saddr4
= (struct sockaddr_in
*)srcaddr
;
1947 struct sockaddr_in
*vaddr4
= (struct sockaddr_in
*)rhs
;
1948 return (saddr4
->sin_addr
.s_addr
== vaddr4
->sin_addr
.s_addr
);
1951 struct sockaddr_in6
*saddr6
= (struct sockaddr_in6
*)srcaddr
;
1952 struct sockaddr_in6
*vaddr6
= (struct sockaddr_in6
*)rhs
;
1953 return ipv6_addr_equal(&saddr6
->sin6_addr
, &vaddr6
->sin6_addr
);
1957 return false; /* don't expect to be here */
1962 * If no port is specified in addr structure, we try to match with 445 port
1963 * and if it fails - with 139 ports. It should be called only if address
1964 * families of server and addr are equal.
1967 match_port(struct TCP_Server_Info
*server
, struct sockaddr
*addr
)
1969 __be16 port
, *sport
;
1971 switch (addr
->sa_family
) {
1973 sport
= &((struct sockaddr_in
*) &server
->dstaddr
)->sin_port
;
1974 port
= ((struct sockaddr_in
*) addr
)->sin_port
;
1977 sport
= &((struct sockaddr_in6
*) &server
->dstaddr
)->sin6_port
;
1978 port
= ((struct sockaddr_in6
*) addr
)->sin6_port
;
1986 port
= htons(CIFS_PORT
);
1990 port
= htons(RFC1001_PORT
);
1993 return port
== *sport
;
1997 match_address(struct TCP_Server_Info
*server
, struct sockaddr
*addr
,
1998 struct sockaddr
*srcaddr
)
2000 switch (addr
->sa_family
) {
2002 struct sockaddr_in
*addr4
= (struct sockaddr_in
*)addr
;
2003 struct sockaddr_in
*srv_addr4
=
2004 (struct sockaddr_in
*)&server
->dstaddr
;
2006 if (addr4
->sin_addr
.s_addr
!= srv_addr4
->sin_addr
.s_addr
)
2011 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)addr
;
2012 struct sockaddr_in6
*srv_addr6
=
2013 (struct sockaddr_in6
*)&server
->dstaddr
;
2015 if (!ipv6_addr_equal(&addr6
->sin6_addr
,
2016 &srv_addr6
->sin6_addr
))
2018 if (addr6
->sin6_scope_id
!= srv_addr6
->sin6_scope_id
)
2024 return false; /* don't expect to be here */
2027 if (!srcip_matches(srcaddr
, (struct sockaddr
*)&server
->srcaddr
))
2034 match_security(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2037 * The select_sectype function should either return the vol->sectype
2038 * that was specified, or "Unspecified" if that sectype was not
2039 * compatible with the given NEGOTIATE request.
2041 if (select_sectype(server
, vol
->sectype
) == Unspecified
)
2045 * Now check if signing mode is acceptable. No need to check
2046 * global_secflags at this point since if MUST_SIGN is set then
2047 * the server->sign had better be too.
2049 if (vol
->sign
&& !server
->sign
)
2055 static int match_server(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2057 struct sockaddr
*addr
= (struct sockaddr
*)&vol
->dstaddr
;
2059 if (vol
->nosharesock
)
2062 if ((server
->vals
!= vol
->vals
) || (server
->ops
!= vol
->ops
))
2065 if (!net_eq(cifs_net_ns(server
), current
->nsproxy
->net_ns
))
2068 if (!match_address(server
, addr
,
2069 (struct sockaddr
*)&vol
->srcaddr
))
2072 if (!match_port(server
, addr
))
2075 if (!match_security(server
, vol
))
2078 if (server
->echo_interval
!= vol
->echo_interval
* HZ
)
2084 static struct TCP_Server_Info
*
2085 cifs_find_tcp_session(struct smb_vol
*vol
)
2087 struct TCP_Server_Info
*server
;
2089 spin_lock(&cifs_tcp_ses_lock
);
2090 list_for_each_entry(server
, &cifs_tcp_ses_list
, tcp_ses_list
) {
2091 if (!match_server(server
, vol
))
2094 ++server
->srv_count
;
2095 spin_unlock(&cifs_tcp_ses_lock
);
2096 cifs_dbg(FYI
, "Existing tcp session with server found\n");
2099 spin_unlock(&cifs_tcp_ses_lock
);
2104 cifs_put_tcp_session(struct TCP_Server_Info
*server
)
2106 struct task_struct
*task
;
2108 spin_lock(&cifs_tcp_ses_lock
);
2109 if (--server
->srv_count
> 0) {
2110 spin_unlock(&cifs_tcp_ses_lock
);
2114 put_net(cifs_net_ns(server
));
2116 list_del_init(&server
->tcp_ses_list
);
2117 spin_unlock(&cifs_tcp_ses_lock
);
2119 cancel_delayed_work_sync(&server
->echo
);
2121 spin_lock(&GlobalMid_Lock
);
2122 server
->tcpStatus
= CifsExiting
;
2123 spin_unlock(&GlobalMid_Lock
);
2125 cifs_crypto_shash_release(server
);
2126 cifs_fscache_release_client_cookie(server
);
2128 kfree(server
->session_key
.response
);
2129 server
->session_key
.response
= NULL
;
2130 server
->session_key
.len
= 0;
2132 task
= xchg(&server
->tsk
, NULL
);
2134 force_sig(SIGKILL
, task
);
2137 static struct TCP_Server_Info
*
2138 cifs_get_tcp_session(struct smb_vol
*volume_info
)
2140 struct TCP_Server_Info
*tcp_ses
= NULL
;
2143 cifs_dbg(FYI
, "UNC: %s\n", volume_info
->UNC
);
2145 /* see if we already have a matching tcp_ses */
2146 tcp_ses
= cifs_find_tcp_session(volume_info
);
2150 tcp_ses
= kzalloc(sizeof(struct TCP_Server_Info
), GFP_KERNEL
);
2156 tcp_ses
->ops
= volume_info
->ops
;
2157 tcp_ses
->vals
= volume_info
->vals
;
2158 cifs_set_net_ns(tcp_ses
, get_net(current
->nsproxy
->net_ns
));
2159 tcp_ses
->hostname
= extract_hostname(volume_info
->UNC
);
2160 if (IS_ERR(tcp_ses
->hostname
)) {
2161 rc
= PTR_ERR(tcp_ses
->hostname
);
2162 goto out_err_crypto_release
;
2165 tcp_ses
->noblocksnd
= volume_info
->noblocksnd
;
2166 tcp_ses
->noautotune
= volume_info
->noautotune
;
2167 tcp_ses
->tcp_nodelay
= volume_info
->sockopt_tcp_nodelay
;
2168 tcp_ses
->in_flight
= 0;
2169 tcp_ses
->credits
= 1;
2170 init_waitqueue_head(&tcp_ses
->response_q
);
2171 init_waitqueue_head(&tcp_ses
->request_q
);
2172 INIT_LIST_HEAD(&tcp_ses
->pending_mid_q
);
2173 mutex_init(&tcp_ses
->srv_mutex
);
2174 memcpy(tcp_ses
->workstation_RFC1001_name
,
2175 volume_info
->source_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2176 memcpy(tcp_ses
->server_RFC1001_name
,
2177 volume_info
->target_rfc1001_name
, RFC1001_NAME_LEN_WITH_NULL
);
2178 tcp_ses
->session_estab
= false;
2179 tcp_ses
->sequence_number
= 0;
2180 tcp_ses
->lstrp
= jiffies
;
2181 spin_lock_init(&tcp_ses
->req_lock
);
2182 INIT_LIST_HEAD(&tcp_ses
->tcp_ses_list
);
2183 INIT_LIST_HEAD(&tcp_ses
->smb_ses_list
);
2184 INIT_DELAYED_WORK(&tcp_ses
->echo
, cifs_echo_request
);
2185 memcpy(&tcp_ses
->srcaddr
, &volume_info
->srcaddr
,
2186 sizeof(tcp_ses
->srcaddr
));
2187 memcpy(&tcp_ses
->dstaddr
, &volume_info
->dstaddr
,
2188 sizeof(tcp_ses
->dstaddr
));
2189 #ifdef CONFIG_CIFS_SMB2
2190 generate_random_uuid(tcp_ses
->client_guid
);
2193 * at this point we are the only ones with the pointer
2194 * to the struct since the kernel thread not created yet
2195 * no need to spinlock this init of tcpStatus or srv_count
2197 tcp_ses
->tcpStatus
= CifsNew
;
2198 ++tcp_ses
->srv_count
;
2200 if (volume_info
->echo_interval
>= SMB_ECHO_INTERVAL_MIN
&&
2201 volume_info
->echo_interval
<= SMB_ECHO_INTERVAL_MAX
)
2202 tcp_ses
->echo_interval
= volume_info
->echo_interval
* HZ
;
2204 tcp_ses
->echo_interval
= SMB_ECHO_INTERVAL_DEFAULT
* HZ
;
2206 rc
= ip_connect(tcp_ses
);
2208 cifs_dbg(VFS
, "Error connecting to socket. Aborting operation.\n");
2209 goto out_err_crypto_release
;
2213 * since we're in a cifs function already, we know that
2214 * this will succeed. No need for try_module_get().
2216 __module_get(THIS_MODULE
);
2217 tcp_ses
->tsk
= kthread_run(cifs_demultiplex_thread
,
2219 if (IS_ERR(tcp_ses
->tsk
)) {
2220 rc
= PTR_ERR(tcp_ses
->tsk
);
2221 cifs_dbg(VFS
, "error %d create cifsd thread\n", rc
);
2222 module_put(THIS_MODULE
);
2223 goto out_err_crypto_release
;
2225 tcp_ses
->tcpStatus
= CifsNeedNegotiate
;
2227 /* thread spawned, put it on the list */
2228 spin_lock(&cifs_tcp_ses_lock
);
2229 list_add(&tcp_ses
->tcp_ses_list
, &cifs_tcp_ses_list
);
2230 spin_unlock(&cifs_tcp_ses_lock
);
2232 cifs_fscache_get_client_cookie(tcp_ses
);
2234 /* queue echo request delayed work */
2235 queue_delayed_work(cifsiod_wq
, &tcp_ses
->echo
, tcp_ses
->echo_interval
);
2239 out_err_crypto_release
:
2240 cifs_crypto_shash_release(tcp_ses
);
2242 put_net(cifs_net_ns(tcp_ses
));
2246 if (!IS_ERR(tcp_ses
->hostname
))
2247 kfree(tcp_ses
->hostname
);
2248 if (tcp_ses
->ssocket
)
2249 sock_release(tcp_ses
->ssocket
);
2255 static int match_session(struct cifs_ses
*ses
, struct smb_vol
*vol
)
2257 if (vol
->sectype
!= Unspecified
&&
2258 vol
->sectype
!= ses
->sectype
)
2261 switch (ses
->sectype
) {
2263 if (!uid_eq(vol
->cred_uid
, ses
->cred_uid
))
2267 /* NULL username means anonymous session */
2268 if (ses
->user_name
== NULL
) {
2274 /* anything else takes username/password */
2275 if (strncmp(ses
->user_name
,
2276 vol
->username
? vol
->username
: "",
2277 CIFS_MAX_USERNAME_LEN
))
2279 if ((vol
->username
&& strlen(vol
->username
) != 0) &&
2280 ses
->password
!= NULL
&&
2281 strncmp(ses
->password
,
2282 vol
->password
? vol
->password
: "",
2283 CIFS_MAX_PASSWORD_LEN
))
2289 static struct cifs_ses
*
2290 cifs_find_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*vol
)
2292 struct cifs_ses
*ses
;
2294 spin_lock(&cifs_tcp_ses_lock
);
2295 list_for_each_entry(ses
, &server
->smb_ses_list
, smb_ses_list
) {
2296 if (ses
->status
== CifsExiting
)
2298 if (!match_session(ses
, vol
))
2301 spin_unlock(&cifs_tcp_ses_lock
);
2304 spin_unlock(&cifs_tcp_ses_lock
);
2309 cifs_put_smb_ses(struct cifs_ses
*ses
)
2311 unsigned int rc
, xid
;
2312 struct TCP_Server_Info
*server
= ses
->server
;
2314 cifs_dbg(FYI
, "%s: ses_count=%d\n", __func__
, ses
->ses_count
);
2316 spin_lock(&cifs_tcp_ses_lock
);
2317 if (ses
->status
== CifsExiting
) {
2318 spin_unlock(&cifs_tcp_ses_lock
);
2321 if (--ses
->ses_count
> 0) {
2322 spin_unlock(&cifs_tcp_ses_lock
);
2325 if (ses
->status
== CifsGood
)
2326 ses
->status
= CifsExiting
;
2327 spin_unlock(&cifs_tcp_ses_lock
);
2329 if (ses
->status
== CifsExiting
&& server
->ops
->logoff
) {
2331 rc
= server
->ops
->logoff(xid
, ses
);
2333 cifs_dbg(VFS
, "%s: Session Logoff failure rc=%d\n",
2338 spin_lock(&cifs_tcp_ses_lock
);
2339 list_del_init(&ses
->smb_ses_list
);
2340 spin_unlock(&cifs_tcp_ses_lock
);
2343 cifs_put_tcp_session(server
);
2348 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2349 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2351 /* Populate username and pw fields from keyring if possible */
2353 cifs_set_cifscreds(struct smb_vol
*vol
, struct cifs_ses
*ses
)
2356 const char *delim
, *payload
;
2360 struct TCP_Server_Info
*server
= ses
->server
;
2361 struct sockaddr_in
*sa
;
2362 struct sockaddr_in6
*sa6
;
2363 const struct user_key_payload
*upayload
;
2365 desc
= kmalloc(CIFSCREDS_DESC_SIZE
, GFP_KERNEL
);
2369 /* try to find an address key first */
2370 switch (server
->dstaddr
.ss_family
) {
2372 sa
= (struct sockaddr_in
*)&server
->dstaddr
;
2373 sprintf(desc
, "cifs:a:%pI4", &sa
->sin_addr
.s_addr
);
2376 sa6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2377 sprintf(desc
, "cifs:a:%pI6c", &sa6
->sin6_addr
.s6_addr
);
2380 cifs_dbg(FYI
, "Bad ss_family (%hu)\n",
2381 server
->dstaddr
.ss_family
);
2386 cifs_dbg(FYI
, "%s: desc=%s\n", __func__
, desc
);
2387 key
= request_key(&key_type_logon
, desc
, "");
2389 if (!ses
->domainName
) {
2390 cifs_dbg(FYI
, "domainName is NULL\n");
2395 /* didn't work, try to find a domain key */
2396 sprintf(desc
, "cifs:d:%s", ses
->domainName
);
2397 cifs_dbg(FYI
, "%s: desc=%s\n", __func__
, desc
);
2398 key
= request_key(&key_type_logon
, desc
, "");
2405 down_read(&key
->sem
);
2406 upayload
= user_key_payload(key
);
2407 if (IS_ERR_OR_NULL(upayload
)) {
2408 rc
= upayload
? PTR_ERR(upayload
) : -EINVAL
;
2412 /* find first : in payload */
2413 payload
= upayload
->data
;
2414 delim
= strnchr(payload
, upayload
->datalen
, ':');
2415 cifs_dbg(FYI
, "payload=%s\n", payload
);
2417 cifs_dbg(FYI
, "Unable to find ':' in payload (datalen=%d)\n",
2423 len
= delim
- payload
;
2424 if (len
> CIFS_MAX_USERNAME_LEN
|| len
<= 0) {
2425 cifs_dbg(FYI
, "Bad value from username search (len=%zd)\n",
2431 vol
->username
= kstrndup(payload
, len
, GFP_KERNEL
);
2432 if (!vol
->username
) {
2433 cifs_dbg(FYI
, "Unable to allocate %zd bytes for username\n",
2438 cifs_dbg(FYI
, "%s: username=%s\n", __func__
, vol
->username
);
2440 len
= key
->datalen
- (len
+ 1);
2441 if (len
> CIFS_MAX_PASSWORD_LEN
|| len
<= 0) {
2442 cifs_dbg(FYI
, "Bad len for password search (len=%zd)\n", len
);
2444 kfree(vol
->username
);
2445 vol
->username
= NULL
;
2450 vol
->password
= kstrndup(delim
, len
, GFP_KERNEL
);
2451 if (!vol
->password
) {
2452 cifs_dbg(FYI
, "Unable to allocate %zd bytes for password\n",
2455 kfree(vol
->username
);
2456 vol
->username
= NULL
;
2465 cifs_dbg(FYI
, "%s: returning %d\n", __func__
, rc
);
2468 #else /* ! CONFIG_KEYS */
2470 cifs_set_cifscreds(struct smb_vol
*vol
__attribute__((unused
)),
2471 struct cifs_ses
*ses
__attribute__((unused
)))
2475 #endif /* CONFIG_KEYS */
2477 static struct cifs_ses
*
2478 cifs_get_smb_ses(struct TCP_Server_Info
*server
, struct smb_vol
*volume_info
)
2482 struct cifs_ses
*ses
;
2483 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
2484 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
2488 ses
= cifs_find_smb_ses(server
, volume_info
);
2490 cifs_dbg(FYI
, "Existing smb sess found (status=%d)\n",
2493 mutex_lock(&ses
->session_mutex
);
2494 rc
= cifs_negotiate_protocol(xid
, ses
);
2496 mutex_unlock(&ses
->session_mutex
);
2497 /* problem -- put our ses reference */
2498 cifs_put_smb_ses(ses
);
2502 if (ses
->need_reconnect
) {
2503 cifs_dbg(FYI
, "Session needs reconnect\n");
2504 rc
= cifs_setup_session(xid
, ses
,
2505 volume_info
->local_nls
);
2507 mutex_unlock(&ses
->session_mutex
);
2508 /* problem -- put our reference */
2509 cifs_put_smb_ses(ses
);
2514 mutex_unlock(&ses
->session_mutex
);
2516 /* existing SMB ses has a server reference already */
2517 cifs_put_tcp_session(server
);
2522 cifs_dbg(FYI
, "Existing smb sess not found\n");
2523 ses
= sesInfoAlloc();
2527 /* new SMB session uses our server ref */
2528 ses
->server
= server
;
2529 if (server
->dstaddr
.ss_family
== AF_INET6
)
2530 sprintf(ses
->serverName
, "%pI6", &addr6
->sin6_addr
);
2532 sprintf(ses
->serverName
, "%pI4", &addr
->sin_addr
);
2534 if (volume_info
->username
) {
2535 ses
->user_name
= kstrdup(volume_info
->username
, GFP_KERNEL
);
2536 if (!ses
->user_name
)
2540 /* volume_info->password freed at unmount */
2541 if (volume_info
->password
) {
2542 ses
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2546 if (volume_info
->domainname
) {
2547 ses
->domainName
= kstrdup(volume_info
->domainname
, GFP_KERNEL
);
2548 if (!ses
->domainName
)
2551 ses
->cred_uid
= volume_info
->cred_uid
;
2552 ses
->linux_uid
= volume_info
->linux_uid
;
2554 ses
->sectype
= volume_info
->sectype
;
2555 ses
->sign
= volume_info
->sign
;
2557 mutex_lock(&ses
->session_mutex
);
2558 rc
= cifs_negotiate_protocol(xid
, ses
);
2560 rc
= cifs_setup_session(xid
, ses
, volume_info
->local_nls
);
2561 mutex_unlock(&ses
->session_mutex
);
2565 /* success, put it on the list */
2566 spin_lock(&cifs_tcp_ses_lock
);
2567 list_add(&ses
->smb_ses_list
, &server
->smb_ses_list
);
2568 spin_unlock(&cifs_tcp_ses_lock
);
2579 static int match_tcon(struct cifs_tcon
*tcon
, const char *unc
)
2581 if (tcon
->tidStatus
== CifsExiting
)
2583 if (strncmp(tcon
->treeName
, unc
, MAX_TREE_SIZE
))
2588 static struct cifs_tcon
*
2589 cifs_find_tcon(struct cifs_ses
*ses
, const char *unc
)
2591 struct list_head
*tmp
;
2592 struct cifs_tcon
*tcon
;
2594 spin_lock(&cifs_tcp_ses_lock
);
2595 list_for_each(tmp
, &ses
->tcon_list
) {
2596 tcon
= list_entry(tmp
, struct cifs_tcon
, tcon_list
);
2597 if (!match_tcon(tcon
, unc
))
2600 spin_unlock(&cifs_tcp_ses_lock
);
2603 spin_unlock(&cifs_tcp_ses_lock
);
2608 cifs_put_tcon(struct cifs_tcon
*tcon
)
2611 struct cifs_ses
*ses
= tcon
->ses
;
2613 cifs_dbg(FYI
, "%s: tc_count=%d\n", __func__
, tcon
->tc_count
);
2614 spin_lock(&cifs_tcp_ses_lock
);
2615 if (--tcon
->tc_count
> 0) {
2616 spin_unlock(&cifs_tcp_ses_lock
);
2620 list_del_init(&tcon
->tcon_list
);
2621 spin_unlock(&cifs_tcp_ses_lock
);
2624 if (ses
->server
->ops
->tree_disconnect
)
2625 ses
->server
->ops
->tree_disconnect(xid
, tcon
);
2628 cifs_fscache_release_super_cookie(tcon
);
2630 cifs_put_smb_ses(ses
);
2633 static struct cifs_tcon
*
2634 cifs_get_tcon(struct cifs_ses
*ses
, struct smb_vol
*volume_info
)
2637 struct cifs_tcon
*tcon
;
2639 tcon
= cifs_find_tcon(ses
, volume_info
->UNC
);
2641 cifs_dbg(FYI
, "Found match on UNC path\n");
2642 /* existing tcon already has a reference */
2643 cifs_put_smb_ses(ses
);
2644 if (tcon
->seal
!= volume_info
->seal
)
2645 cifs_dbg(VFS
, "transport encryption setting conflicts with existing tid\n");
2649 if (!ses
->server
->ops
->tree_connect
) {
2654 tcon
= tconInfoAlloc();
2661 if (volume_info
->password
) {
2662 tcon
->password
= kstrdup(volume_info
->password
, GFP_KERNEL
);
2663 if (!tcon
->password
) {
2670 * BB Do we need to wrap session_mutex around this TCon call and Unix
2671 * SetFS as we do on SessSetup and reconnect?
2674 rc
= ses
->server
->ops
->tree_connect(xid
, ses
, volume_info
->UNC
, tcon
,
2675 volume_info
->local_nls
);
2677 cifs_dbg(FYI
, "Tcon rc = %d\n", rc
);
2681 if (volume_info
->nodfs
) {
2682 tcon
->Flags
&= ~SMB_SHARE_IS_IN_DFS
;
2683 cifs_dbg(FYI
, "DFS disabled (%d)\n", tcon
->Flags
);
2685 tcon
->seal
= volume_info
->seal
;
2686 tcon
->use_persistent
= false;
2687 /* check if SMB2 or later, CIFS does not support persistent handles */
2688 if (volume_info
->persistent
) {
2689 if (ses
->server
->vals
->protocol_id
== 0) {
2691 "SMB3 or later required for persistent handles\n");
2694 #ifdef CONFIG_CIFS_SMB2
2695 } else if (ses
->server
->capabilities
&
2696 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
)
2697 tcon
->use_persistent
= true;
2698 else /* persistent handles requested but not supported */ {
2700 "Persistent handles not supported on share\n");
2703 #endif /* CONFIG_CIFS_SMB2 */
2705 #ifdef CONFIG_CIFS_SMB2
2706 } else if ((tcon
->capabilities
& SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY
)
2707 && (ses
->server
->capabilities
& SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
)
2708 && (volume_info
->nopersistent
== false)) {
2709 cifs_dbg(FYI
, "enabling persistent handles\n");
2710 tcon
->use_persistent
= true;
2711 #endif /* CONFIG_CIFS_SMB2 */
2712 } else if (volume_info
->resilient
) {
2713 if (ses
->server
->vals
->protocol_id
== 0) {
2715 "SMB2.1 or later required for resilient handles\n");
2719 tcon
->use_resilient
= true;
2723 * We can have only one retry value for a connection to a share so for
2724 * resources mounted more than once to the same server share the last
2725 * value passed in for the retry flag is used.
2727 tcon
->retry
= volume_info
->retry
;
2728 tcon
->nocase
= volume_info
->nocase
;
2729 tcon
->local_lease
= volume_info
->local_lease
;
2730 INIT_LIST_HEAD(&tcon
->pending_opens
);
2732 spin_lock(&cifs_tcp_ses_lock
);
2733 list_add(&tcon
->tcon_list
, &ses
->tcon_list
);
2734 spin_unlock(&cifs_tcp_ses_lock
);
2736 cifs_fscache_get_super_cookie(tcon
);
2746 cifs_put_tlink(struct tcon_link
*tlink
)
2748 if (!tlink
|| IS_ERR(tlink
))
2751 if (!atomic_dec_and_test(&tlink
->tl_count
) ||
2752 test_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
)) {
2753 tlink
->tl_time
= jiffies
;
2757 if (!IS_ERR(tlink_tcon(tlink
)))
2758 cifs_put_tcon(tlink_tcon(tlink
));
2763 static inline struct tcon_link
*
2764 cifs_sb_master_tlink(struct cifs_sb_info
*cifs_sb
)
2766 return cifs_sb
->master_tlink
;
2770 compare_mount_options(struct super_block
*sb
, struct cifs_mnt_data
*mnt_data
)
2772 struct cifs_sb_info
*old
= CIFS_SB(sb
);
2773 struct cifs_sb_info
*new = mnt_data
->cifs_sb
;
2775 if ((sb
->s_flags
& CIFS_MS_MASK
) != (mnt_data
->flags
& CIFS_MS_MASK
))
2778 if ((old
->mnt_cifs_flags
& CIFS_MOUNT_MASK
) !=
2779 (new->mnt_cifs_flags
& CIFS_MOUNT_MASK
))
2783 * We want to share sb only if we don't specify an r/wsize or
2784 * specified r/wsize is greater than or equal to existing one.
2786 if (new->wsize
&& new->wsize
< old
->wsize
)
2789 if (new->rsize
&& new->rsize
< old
->rsize
)
2792 if (!uid_eq(old
->mnt_uid
, new->mnt_uid
) || !gid_eq(old
->mnt_gid
, new->mnt_gid
))
2795 if (old
->mnt_file_mode
!= new->mnt_file_mode
||
2796 old
->mnt_dir_mode
!= new->mnt_dir_mode
)
2799 if (strcmp(old
->local_nls
->charset
, new->local_nls
->charset
))
2802 if (old
->actimeo
!= new->actimeo
)
2809 match_prepath(struct super_block
*sb
, struct cifs_mnt_data
*mnt_data
)
2811 struct cifs_sb_info
*old
= CIFS_SB(sb
);
2812 struct cifs_sb_info
*new = mnt_data
->cifs_sb
;
2814 if (old
->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
) {
2815 if (!(new->mnt_cifs_flags
& CIFS_MOUNT_USE_PREFIX_PATH
))
2817 /* The prepath should be null terminated strings */
2818 if (strcmp(new->prepath
, old
->prepath
))
2827 cifs_match_super(struct super_block
*sb
, void *data
)
2829 struct cifs_mnt_data
*mnt_data
= (struct cifs_mnt_data
*)data
;
2830 struct smb_vol
*volume_info
;
2831 struct cifs_sb_info
*cifs_sb
;
2832 struct TCP_Server_Info
*tcp_srv
;
2833 struct cifs_ses
*ses
;
2834 struct cifs_tcon
*tcon
;
2835 struct tcon_link
*tlink
;
2838 spin_lock(&cifs_tcp_ses_lock
);
2839 cifs_sb
= CIFS_SB(sb
);
2840 tlink
= cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
2841 if (IS_ERR(tlink
)) {
2842 spin_unlock(&cifs_tcp_ses_lock
);
2845 tcon
= tlink_tcon(tlink
);
2847 tcp_srv
= ses
->server
;
2849 volume_info
= mnt_data
->vol
;
2851 if (!match_server(tcp_srv
, volume_info
) ||
2852 !match_session(ses
, volume_info
) ||
2853 !match_tcon(tcon
, volume_info
->UNC
) ||
2854 !match_prepath(sb
, mnt_data
)) {
2859 rc
= compare_mount_options(sb
, mnt_data
);
2861 spin_unlock(&cifs_tcp_ses_lock
);
2862 cifs_put_tlink(tlink
);
2867 get_dfs_path(const unsigned int xid
, struct cifs_ses
*ses
, const char *old_path
,
2868 const struct nls_table
*nls_codepage
, unsigned int *num_referrals
,
2869 struct dfs_info3_param
**referrals
, int remap
)
2874 if (!ses
->server
->ops
->tree_connect
|| !ses
->server
->ops
->get_dfs_refer
)
2880 if (ses
->ipc_tid
== 0) {
2881 temp_unc
= kmalloc(2 /* for slashes */ +
2882 strnlen(ses
->serverName
, SERVER_NAME_LEN_WITH_NULL
* 2)
2883 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL
);
2884 if (temp_unc
== NULL
)
2888 strcpy(temp_unc
+ 2, ses
->serverName
);
2889 strcpy(temp_unc
+ 2 + strlen(ses
->serverName
), "\\IPC$");
2890 rc
= ses
->server
->ops
->tree_connect(xid
, ses
, temp_unc
, NULL
,
2892 cifs_dbg(FYI
, "Tcon rc = %d ipc_tid = %d\n", rc
, ses
->ipc_tid
);
2896 rc
= ses
->server
->ops
->get_dfs_refer(xid
, ses
, old_path
,
2897 referrals
, num_referrals
,
2898 nls_codepage
, remap
);
2900 * BB - map targetUNCs to dfs_info3 structures, here or in
2901 * ses->server->ops->get_dfs_refer.
2907 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2908 static struct lock_class_key cifs_key
[2];
2909 static struct lock_class_key cifs_slock_key
[2];
2912 cifs_reclassify_socket4(struct socket
*sock
)
2914 struct sock
*sk
= sock
->sk
;
2915 BUG_ON(!sock_allow_reclassification(sk
));
2916 sock_lock_init_class_and_name(sk
, "slock-AF_INET-CIFS",
2917 &cifs_slock_key
[0], "sk_lock-AF_INET-CIFS", &cifs_key
[0]);
2921 cifs_reclassify_socket6(struct socket
*sock
)
2923 struct sock
*sk
= sock
->sk
;
2924 BUG_ON(!sock_allow_reclassification(sk
));
2925 sock_lock_init_class_and_name(sk
, "slock-AF_INET6-CIFS",
2926 &cifs_slock_key
[1], "sk_lock-AF_INET6-CIFS", &cifs_key
[1]);
2930 cifs_reclassify_socket4(struct socket
*sock
)
2935 cifs_reclassify_socket6(struct socket
*sock
)
2940 /* See RFC1001 section 14 on representation of Netbios names */
2941 static void rfc1002mangle(char *target
, char *source
, unsigned int length
)
2945 for (i
= 0, j
= 0; i
< (length
); i
++) {
2946 /* mask a nibble at a time and encode */
2947 target
[j
] = 'A' + (0x0F & (source
[i
] >> 4));
2948 target
[j
+1] = 'A' + (0x0F & source
[i
]);
2955 bind_socket(struct TCP_Server_Info
*server
)
2958 if (server
->srcaddr
.ss_family
!= AF_UNSPEC
) {
2959 /* Bind to the specified local IP address */
2960 struct socket
*socket
= server
->ssocket
;
2961 rc
= socket
->ops
->bind(socket
,
2962 (struct sockaddr
*) &server
->srcaddr
,
2963 sizeof(server
->srcaddr
));
2965 struct sockaddr_in
*saddr4
;
2966 struct sockaddr_in6
*saddr6
;
2967 saddr4
= (struct sockaddr_in
*)&server
->srcaddr
;
2968 saddr6
= (struct sockaddr_in6
*)&server
->srcaddr
;
2969 if (saddr6
->sin6_family
== AF_INET6
)
2970 cifs_dbg(VFS
, "Failed to bind to: %pI6c, error: %d\n",
2971 &saddr6
->sin6_addr
, rc
);
2973 cifs_dbg(VFS
, "Failed to bind to: %pI4, error: %d\n",
2974 &saddr4
->sin_addr
.s_addr
, rc
);
2981 ip_rfc1001_connect(struct TCP_Server_Info
*server
)
2985 * some servers require RFC1001 sessinit before sending
2986 * negprot - BB check reconnection in case where second
2987 * sessinit is sent but no second negprot
2989 struct rfc1002_session_packet
*ses_init_buf
;
2990 struct smb_hdr
*smb_buf
;
2991 ses_init_buf
= kzalloc(sizeof(struct rfc1002_session_packet
),
2994 ses_init_buf
->trailer
.session_req
.called_len
= 32;
2996 if (server
->server_RFC1001_name
[0] != 0)
2997 rfc1002mangle(ses_init_buf
->trailer
.
2998 session_req
.called_name
,
2999 server
->server_RFC1001_name
,
3000 RFC1001_NAME_LEN_WITH_NULL
);
3002 rfc1002mangle(ses_init_buf
->trailer
.
3003 session_req
.called_name
,
3004 DEFAULT_CIFS_CALLED_NAME
,
3005 RFC1001_NAME_LEN_WITH_NULL
);
3007 ses_init_buf
->trailer
.session_req
.calling_len
= 32;
3010 * calling name ends in null (byte 16) from old smb
3013 if (server
->workstation_RFC1001_name
[0] != 0)
3014 rfc1002mangle(ses_init_buf
->trailer
.
3015 session_req
.calling_name
,
3016 server
->workstation_RFC1001_name
,
3017 RFC1001_NAME_LEN_WITH_NULL
);
3019 rfc1002mangle(ses_init_buf
->trailer
.
3020 session_req
.calling_name
,
3022 RFC1001_NAME_LEN_WITH_NULL
);
3024 ses_init_buf
->trailer
.session_req
.scope1
= 0;
3025 ses_init_buf
->trailer
.session_req
.scope2
= 0;
3026 smb_buf
= (struct smb_hdr
*)ses_init_buf
;
3028 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3029 smb_buf
->smb_buf_length
= cpu_to_be32(0x81000044);
3030 rc
= smb_send(server
, smb_buf
, 0x44);
3031 kfree(ses_init_buf
);
3033 * RFC1001 layer in at least one server
3034 * requires very short break before negprot
3035 * presumably because not expecting negprot
3036 * to follow so fast. This is a simple
3037 * solution that works without
3038 * complicating the code and causes no
3039 * significant slowing down on mount
3042 usleep_range(1000, 2000);
3045 * else the negprot may still work without this
3046 * even though malloc failed
3053 generic_ip_connect(struct TCP_Server_Info
*server
)
3058 struct socket
*socket
= server
->ssocket
;
3059 struct sockaddr
*saddr
;
3061 saddr
= (struct sockaddr
*) &server
->dstaddr
;
3063 if (server
->dstaddr
.ss_family
== AF_INET6
) {
3064 sport
= ((struct sockaddr_in6
*) saddr
)->sin6_port
;
3065 slen
= sizeof(struct sockaddr_in6
);
3068 sport
= ((struct sockaddr_in
*) saddr
)->sin_port
;
3069 slen
= sizeof(struct sockaddr_in
);
3073 if (socket
== NULL
) {
3074 rc
= __sock_create(cifs_net_ns(server
), sfamily
, SOCK_STREAM
,
3075 IPPROTO_TCP
, &socket
, 1);
3077 cifs_dbg(VFS
, "Error %d creating socket\n", rc
);
3078 server
->ssocket
= NULL
;
3082 /* BB other socket options to set KEEPALIVE, NODELAY? */
3083 cifs_dbg(FYI
, "Socket created\n");
3084 server
->ssocket
= socket
;
3085 socket
->sk
->sk_allocation
= GFP_NOFS
;
3086 if (sfamily
== AF_INET6
)
3087 cifs_reclassify_socket6(socket
);
3089 cifs_reclassify_socket4(socket
);
3092 rc
= bind_socket(server
);
3097 * Eventually check for other socket options to change from
3098 * the default. sock_setsockopt not used because it expects
3101 socket
->sk
->sk_rcvtimeo
= 7 * HZ
;
3102 socket
->sk
->sk_sndtimeo
= 5 * HZ
;
3104 /* make the bufsizes depend on wsize/rsize and max requests */
3105 if (server
->noautotune
) {
3106 if (socket
->sk
->sk_sndbuf
< (200 * 1024))
3107 socket
->sk
->sk_sndbuf
= 200 * 1024;
3108 if (socket
->sk
->sk_rcvbuf
< (140 * 1024))
3109 socket
->sk
->sk_rcvbuf
= 140 * 1024;
3112 if (server
->tcp_nodelay
) {
3114 rc
= kernel_setsockopt(socket
, SOL_TCP
, TCP_NODELAY
,
3115 (char *)&val
, sizeof(val
));
3117 cifs_dbg(FYI
, "set TCP_NODELAY socket option error %d\n",
3121 cifs_dbg(FYI
, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3122 socket
->sk
->sk_sndbuf
,
3123 socket
->sk
->sk_rcvbuf
, socket
->sk
->sk_rcvtimeo
);
3125 rc
= socket
->ops
->connect(socket
, saddr
, slen
, 0);
3127 cifs_dbg(FYI
, "Error %d connecting to server\n", rc
);
3128 sock_release(socket
);
3129 server
->ssocket
= NULL
;
3133 if (sport
== htons(RFC1001_PORT
))
3134 rc
= ip_rfc1001_connect(server
);
3140 ip_connect(struct TCP_Server_Info
*server
)
3143 struct sockaddr_in6
*addr6
= (struct sockaddr_in6
*)&server
->dstaddr
;
3144 struct sockaddr_in
*addr
= (struct sockaddr_in
*)&server
->dstaddr
;
3146 if (server
->dstaddr
.ss_family
== AF_INET6
)
3147 sport
= &addr6
->sin6_port
;
3149 sport
= &addr
->sin_port
;
3154 /* try with 445 port at first */
3155 *sport
= htons(CIFS_PORT
);
3157 rc
= generic_ip_connect(server
);
3161 /* if it failed, try with 139 port */
3162 *sport
= htons(RFC1001_PORT
);
3165 return generic_ip_connect(server
);
3168 void reset_cifs_unix_caps(unsigned int xid
, struct cifs_tcon
*tcon
,
3169 struct cifs_sb_info
*cifs_sb
, struct smb_vol
*vol_info
)
3171 /* if we are reconnecting then should we check to see if
3172 * any requested capabilities changed locally e.g. via
3173 * remount but we can not do much about it here
3174 * if they have (even if we could detect it by the following)
3175 * Perhaps we could add a backpointer to array of sb from tcon
3176 * or if we change to make all sb to same share the same
3177 * sb as NFS - then we only have one backpointer to sb.
3178 * What if we wanted to mount the server share twice once with
3179 * and once without posixacls or posix paths? */
3180 __u64 saved_cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3182 if (vol_info
&& vol_info
->no_linux_ext
) {
3183 tcon
->fsUnixInfo
.Capability
= 0;
3184 tcon
->unix_ext
= 0; /* Unix Extensions disabled */
3185 cifs_dbg(FYI
, "Linux protocol extensions disabled\n");
3187 } else if (vol_info
)
3188 tcon
->unix_ext
= 1; /* Unix Extensions supported */
3190 if (tcon
->unix_ext
== 0) {
3191 cifs_dbg(FYI
, "Unix extensions disabled so not set on reconnect\n");
3195 if (!CIFSSMBQFSUnixInfo(xid
, tcon
)) {
3196 __u64 cap
= le64_to_cpu(tcon
->fsUnixInfo
.Capability
);
3197 cifs_dbg(FYI
, "unix caps which server supports %lld\n", cap
);
3198 /* check for reconnect case in which we do not
3199 want to change the mount behavior if we can avoid it */
3200 if (vol_info
== NULL
) {
3201 /* turn off POSIX ACL and PATHNAMES if not set
3202 originally at mount time */
3203 if ((saved_cap
& CIFS_UNIX_POSIX_ACL_CAP
) == 0)
3204 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
3205 if ((saved_cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
3206 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
3207 cifs_dbg(VFS
, "POSIXPATH support change\n");
3208 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
3209 } else if ((cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) == 0) {
3210 cifs_dbg(VFS
, "possible reconnect error\n");
3211 cifs_dbg(VFS
, "server disabled POSIX path support\n");
3215 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
3216 cifs_dbg(VFS
, "per-share encryption not supported yet\n");
3218 cap
&= CIFS_UNIX_CAP_MASK
;
3219 if (vol_info
&& vol_info
->no_psx_acl
)
3220 cap
&= ~CIFS_UNIX_POSIX_ACL_CAP
;
3221 else if (CIFS_UNIX_POSIX_ACL_CAP
& cap
) {
3222 cifs_dbg(FYI
, "negotiated posix acl support\n");
3224 cifs_sb
->mnt_cifs_flags
|=
3225 CIFS_MOUNT_POSIXACL
;
3228 if (vol_info
&& vol_info
->posix_paths
== 0)
3229 cap
&= ~CIFS_UNIX_POSIX_PATHNAMES_CAP
;
3230 else if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
) {
3231 cifs_dbg(FYI
, "negotiate posix pathnames\n");
3233 cifs_sb
->mnt_cifs_flags
|=
3234 CIFS_MOUNT_POSIX_PATHS
;
3237 cifs_dbg(FYI
, "Negotiate caps 0x%x\n", (int)cap
);
3238 #ifdef CONFIG_CIFS_DEBUG2
3239 if (cap
& CIFS_UNIX_FCNTL_CAP
)
3240 cifs_dbg(FYI
, "FCNTL cap\n");
3241 if (cap
& CIFS_UNIX_EXTATTR_CAP
)
3242 cifs_dbg(FYI
, "EXTATTR cap\n");
3243 if (cap
& CIFS_UNIX_POSIX_PATHNAMES_CAP
)
3244 cifs_dbg(FYI
, "POSIX path cap\n");
3245 if (cap
& CIFS_UNIX_XATTR_CAP
)
3246 cifs_dbg(FYI
, "XATTR cap\n");
3247 if (cap
& CIFS_UNIX_POSIX_ACL_CAP
)
3248 cifs_dbg(FYI
, "POSIX ACL cap\n");
3249 if (cap
& CIFS_UNIX_LARGE_READ_CAP
)
3250 cifs_dbg(FYI
, "very large read cap\n");
3251 if (cap
& CIFS_UNIX_LARGE_WRITE_CAP
)
3252 cifs_dbg(FYI
, "very large write cap\n");
3253 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP
)
3254 cifs_dbg(FYI
, "transport encryption cap\n");
3255 if (cap
& CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)
3256 cifs_dbg(FYI
, "mandatory transport encryption cap\n");
3257 #endif /* CIFS_DEBUG2 */
3258 if (CIFSSMBSetFSUnixInfo(xid
, tcon
, cap
)) {
3259 if (vol_info
== NULL
) {
3260 cifs_dbg(FYI
, "resetting capabilities failed\n");
3262 cifs_dbg(VFS
, "Negotiating Unix capabilities with the server failed. Consider mounting with the Unix Extensions disabled if problems are found by specifying the nounix mount option.\n");
3268 int cifs_setup_cifs_sb(struct smb_vol
*pvolume_info
,
3269 struct cifs_sb_info
*cifs_sb
)
3271 INIT_DELAYED_WORK(&cifs_sb
->prune_tlinks
, cifs_prune_tlinks
);
3273 spin_lock_init(&cifs_sb
->tlink_tree_lock
);
3274 cifs_sb
->tlink_tree
= RB_ROOT
;
3277 * Temporarily set r/wsize for matching superblock. If we end up using
3278 * new sb then client will later negotiate it downward if needed.
3280 cifs_sb
->rsize
= pvolume_info
->rsize
;
3281 cifs_sb
->wsize
= pvolume_info
->wsize
;
3283 cifs_sb
->mnt_uid
= pvolume_info
->linux_uid
;
3284 cifs_sb
->mnt_gid
= pvolume_info
->linux_gid
;
3285 cifs_sb
->mnt_file_mode
= pvolume_info
->file_mode
;
3286 cifs_sb
->mnt_dir_mode
= pvolume_info
->dir_mode
;
3287 cifs_dbg(FYI
, "file mode: 0x%hx dir mode: 0x%hx\n",
3288 cifs_sb
->mnt_file_mode
, cifs_sb
->mnt_dir_mode
);
3290 cifs_sb
->actimeo
= pvolume_info
->actimeo
;
3291 cifs_sb
->local_nls
= pvolume_info
->local_nls
;
3293 if (pvolume_info
->noperm
)
3294 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_PERM
;
3295 if (pvolume_info
->setuids
)
3296 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SET_UID
;
3297 if (pvolume_info
->setuidfromacl
)
3298 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UID_FROM_ACL
;
3299 if (pvolume_info
->server_ino
)
3300 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_SERVER_INUM
;
3301 if (pvolume_info
->remap
)
3302 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SFM_CHR
;
3303 if (pvolume_info
->sfu_remap
)
3304 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MAP_SPECIAL_CHR
;
3305 if (pvolume_info
->no_xattr
)
3306 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_XATTR
;
3307 if (pvolume_info
->sfu_emul
)
3308 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_UNX_EMUL
;
3309 if (pvolume_info
->nobrl
)
3310 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NO_BRL
;
3311 if (pvolume_info
->nostrictsync
)
3312 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOSSYNC
;
3313 if (pvolume_info
->mand_lock
)
3314 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_NOPOSIXBRL
;
3315 if (pvolume_info
->rwpidforward
)
3316 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_RWPIDFORWARD
;
3317 if (pvolume_info
->cifs_acl
)
3318 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_ACL
;
3319 if (pvolume_info
->backupuid_specified
) {
3320 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPUID
;
3321 cifs_sb
->mnt_backupuid
= pvolume_info
->backupuid
;
3323 if (pvolume_info
->backupgid_specified
) {
3324 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_CIFS_BACKUPGID
;
3325 cifs_sb
->mnt_backupgid
= pvolume_info
->backupgid
;
3327 if (pvolume_info
->override_uid
)
3328 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_UID
;
3329 if (pvolume_info
->override_gid
)
3330 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_OVERR_GID
;
3331 if (pvolume_info
->dynperm
)
3332 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DYNPERM
;
3333 if (pvolume_info
->fsc
)
3334 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_FSCACHE
;
3335 if (pvolume_info
->multiuser
)
3336 cifs_sb
->mnt_cifs_flags
|= (CIFS_MOUNT_MULTIUSER
|
3337 CIFS_MOUNT_NO_PERM
);
3338 if (pvolume_info
->strict_io
)
3339 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_STRICT_IO
;
3340 if (pvolume_info
->direct_io
) {
3341 cifs_dbg(FYI
, "mounting share using direct i/o\n");
3342 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_DIRECT_IO
;
3344 if (pvolume_info
->mfsymlinks
) {
3345 if (pvolume_info
->sfu_emul
) {
3347 * Our SFU ("Services for Unix" emulation does not allow
3348 * creating symlinks but does allow reading existing SFU
3349 * symlinks (it does allow both creating and reading SFU
3350 * style mknod and FIFOs though). When "mfsymlinks" and
3351 * "sfu" are both enabled at the same time, it allows
3352 * reading both types of symlinks, but will only create
3353 * them with mfsymlinks format. This allows better
3354 * Apple compatibility (probably better for Samba too)
3355 * while still recognizing old Windows style symlinks.
3357 cifs_dbg(VFS
, "mount options mfsymlinks and sfu both enabled\n");
3359 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_MF_SYMLINKS
;
3362 if ((pvolume_info
->cifs_acl
) && (pvolume_info
->dynperm
))
3363 cifs_dbg(VFS
, "mount option dynperm ignored if cifsacl mount option supported\n");
3365 if (pvolume_info
->prepath
) {
3366 cifs_sb
->prepath
= kstrdup(pvolume_info
->prepath
, GFP_KERNEL
);
3367 if (cifs_sb
->prepath
== NULL
)
3375 cleanup_volume_info_contents(struct smb_vol
*volume_info
)
3377 kfree(volume_info
->username
);
3378 kzfree(volume_info
->password
);
3379 kfree(volume_info
->UNC
);
3380 kfree(volume_info
->domainname
);
3381 kfree(volume_info
->iocharset
);
3382 kfree(volume_info
->prepath
);
3386 cifs_cleanup_volume_info(struct smb_vol
*volume_info
)
3390 cleanup_volume_info_contents(volume_info
);
3395 #ifdef CONFIG_CIFS_DFS_UPCALL
3397 * cifs_build_path_to_root returns full path to root when we do not have an
3398 * exiting connection (tcon)
3401 build_unc_path_to_root(const struct smb_vol
*vol
,
3402 const struct cifs_sb_info
*cifs_sb
)
3404 char *full_path
, *pos
;
3405 unsigned int pplen
= vol
->prepath
? strlen(vol
->prepath
) + 1 : 0;
3406 unsigned int unc_len
= strnlen(vol
->UNC
, MAX_TREE_SIZE
+ 1);
3408 full_path
= kmalloc(unc_len
+ pplen
+ 1, GFP_KERNEL
);
3409 if (full_path
== NULL
)
3410 return ERR_PTR(-ENOMEM
);
3412 strncpy(full_path
, vol
->UNC
, unc_len
);
3413 pos
= full_path
+ unc_len
;
3416 *pos
= CIFS_DIR_SEP(cifs_sb
);
3417 strncpy(pos
+ 1, vol
->prepath
, pplen
);
3421 *pos
= '\0'; /* add trailing null */
3422 convert_delimiter(full_path
, CIFS_DIR_SEP(cifs_sb
));
3423 cifs_dbg(FYI
, "%s: full_path=%s\n", __func__
, full_path
);
3428 * Perform a dfs referral query for a share and (optionally) prefix
3430 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3431 * to a string containing updated options for the submount. Otherwise it
3432 * will be left untouched.
3434 * Returns the rc from get_dfs_path to the caller, which can be used to
3435 * determine whether there were referrals.
3438 expand_dfs_referral(const unsigned int xid
, struct cifs_ses
*ses
,
3439 struct smb_vol
*volume_info
, struct cifs_sb_info
*cifs_sb
,
3443 unsigned int num_referrals
= 0;
3444 struct dfs_info3_param
*referrals
= NULL
;
3445 char *full_path
= NULL
, *ref_path
= NULL
, *mdata
= NULL
;
3447 full_path
= build_unc_path_to_root(volume_info
, cifs_sb
);
3448 if (IS_ERR(full_path
))
3449 return PTR_ERR(full_path
);
3451 /* For DFS paths, skip the first '\' of the UNC */
3452 ref_path
= check_prefix
? full_path
+ 1 : volume_info
->UNC
+ 1;
3454 rc
= get_dfs_path(xid
, ses
, ref_path
, cifs_sb
->local_nls
,
3455 &num_referrals
, &referrals
, cifs_remap(cifs_sb
));
3457 if (!rc
&& num_referrals
> 0) {
3458 char *fake_devname
= NULL
;
3460 mdata
= cifs_compose_mount_options(cifs_sb
->mountdata
,
3461 full_path
+ 1, referrals
,
3464 free_dfs_info_array(referrals
, num_referrals
);
3466 if (IS_ERR(mdata
)) {
3467 rc
= PTR_ERR(mdata
);
3470 cleanup_volume_info_contents(volume_info
);
3471 rc
= cifs_setup_volume_info(volume_info
, mdata
,
3474 kfree(fake_devname
);
3475 kfree(cifs_sb
->mountdata
);
3476 cifs_sb
->mountdata
= mdata
;
3484 cifs_setup_volume_info(struct smb_vol
*volume_info
, char *mount_data
,
3485 const char *devname
)
3489 if (cifs_parse_mount_options(mount_data
, devname
, volume_info
))
3492 if (volume_info
->nullauth
) {
3493 cifs_dbg(FYI
, "Anonymous login\n");
3494 kfree(volume_info
->username
);
3495 volume_info
->username
= NULL
;
3496 } else if (volume_info
->username
) {
3497 /* BB fixme parse for domain name here */
3498 cifs_dbg(FYI
, "Username: %s\n", volume_info
->username
);
3500 cifs_dbg(VFS
, "No username specified\n");
3501 /* In userspace mount helper we can get user name from alternate
3502 locations such as env variables and files on disk */
3506 /* this is needed for ASCII cp to Unicode converts */
3507 if (volume_info
->iocharset
== NULL
) {
3508 /* load_nls_default cannot return null */
3509 volume_info
->local_nls
= load_nls_default();
3511 volume_info
->local_nls
= load_nls(volume_info
->iocharset
);
3512 if (volume_info
->local_nls
== NULL
) {
3513 cifs_dbg(VFS
, "CIFS mount error: iocharset %s not found\n",
3514 volume_info
->iocharset
);
3523 cifs_get_volume_info(char *mount_data
, const char *devname
)
3526 struct smb_vol
*volume_info
;
3528 volume_info
= kmalloc(sizeof(struct smb_vol
), GFP_KERNEL
);
3530 return ERR_PTR(-ENOMEM
);
3532 rc
= cifs_setup_volume_info(volume_info
, mount_data
, devname
);
3534 cifs_cleanup_volume_info(volume_info
);
3535 volume_info
= ERR_PTR(rc
);
3542 cifs_are_all_path_components_accessible(struct TCP_Server_Info
*server
,
3544 struct cifs_tcon
*tcon
,
3545 struct cifs_sb_info
*cifs_sb
,
3552 sep
= CIFS_DIR_SEP(cifs_sb
);
3555 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
, "");
3557 /* skip separators */
3562 /* next separator */
3563 while (*s
&& *s
!= sep
)
3567 * temporarily null-terminate the path at the end of
3568 * the current component
3572 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
,
3580 cifs_mount(struct cifs_sb_info
*cifs_sb
, struct smb_vol
*volume_info
)
3584 struct cifs_ses
*ses
;
3585 struct cifs_tcon
*tcon
;
3586 struct TCP_Server_Info
*server
;
3588 struct tcon_link
*tlink
;
3589 #ifdef CONFIG_CIFS_DFS_UPCALL
3590 int referral_walks_count
= 0;
3593 rc
= bdi_setup_and_register(&cifs_sb
->bdi
, "cifs");
3597 #ifdef CONFIG_CIFS_DFS_UPCALL
3599 /* cleanup activities if we're chasing a referral */
3600 if (referral_walks_count
) {
3602 cifs_put_tcon(tcon
);
3604 cifs_put_smb_ses(ses
);
3606 cifs_sb
->mnt_cifs_flags
&= ~CIFS_MOUNT_POSIX_PATHS
;
3620 /* get a reference to a tcp session */
3621 server
= cifs_get_tcp_session(volume_info
);
3622 if (IS_ERR(server
)) {
3623 rc
= PTR_ERR(server
);
3624 bdi_destroy(&cifs_sb
->bdi
);
3627 if ((volume_info
->max_credits
< 20) ||
3628 (volume_info
->max_credits
> 60000))
3629 server
->max_credits
= SMB2_MAX_CREDITS_AVAILABLE
;
3631 server
->max_credits
= volume_info
->max_credits
;
3632 /* get a reference to a SMB session */
3633 ses
= cifs_get_smb_ses(server
, volume_info
);
3637 goto mount_fail_check
;
3640 #ifdef CONFIG_CIFS_SMB2
3641 if ((volume_info
->persistent
== true) && ((ses
->server
->capabilities
&
3642 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES
) == 0)) {
3643 cifs_dbg(VFS
, "persistent handles not supported by server\n");
3645 goto mount_fail_check
;
3647 #endif /* CONFIG_CIFS_SMB2*/
3649 /* search for existing tcon to this server share */
3650 tcon
= cifs_get_tcon(ses
, volume_info
);
3654 goto remote_path_check
;
3657 /* tell server which Unix caps we support */
3658 if (cap_unix(tcon
->ses
)) {
3659 /* reset of caps checks mount to see if unix extensions
3660 disabled for just this mount */
3661 reset_cifs_unix_caps(xid
, tcon
, cifs_sb
, volume_info
);
3662 if ((tcon
->ses
->server
->tcpStatus
== CifsNeedReconnect
) &&
3663 (le64_to_cpu(tcon
->fsUnixInfo
.Capability
) &
3664 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP
)) {
3666 goto mount_fail_check
;
3669 tcon
->unix_ext
= 0; /* server does not support them */
3671 /* do not care if a following call succeed - informational */
3672 if (!tcon
->ipc
&& server
->ops
->qfs_tcon
)
3673 server
->ops
->qfs_tcon(xid
, tcon
);
3675 cifs_sb
->wsize
= server
->ops
->negotiate_wsize(tcon
, volume_info
);
3676 cifs_sb
->rsize
= server
->ops
->negotiate_rsize(tcon
, volume_info
);
3678 /* tune readahead according to rsize */
3679 cifs_sb
->bdi
.ra_pages
= cifs_sb
->rsize
/ PAGE_SIZE
;
3682 #ifdef CONFIG_CIFS_DFS_UPCALL
3684 * Perform an unconditional check for whether there are DFS
3685 * referrals for this path without prefix, to provide support
3686 * for DFS referrals from w2k8 servers which don't seem to respond
3687 * with PATH_NOT_COVERED to requests that include the prefix.
3688 * Chase the referral if found, otherwise continue normally.
3690 if (referral_walks_count
== 0) {
3691 int refrc
= expand_dfs_referral(xid
, ses
, volume_info
, cifs_sb
,
3694 referral_walks_count
++;
3695 goto try_mount_again
;
3700 /* check if a whole path is not remote */
3702 if (!server
->ops
->is_path_accessible
) {
3704 goto mount_fail_check
;
3707 * cifs_build_path_to_root works only when we have a valid tcon
3709 full_path
= cifs_build_path_to_root(volume_info
, cifs_sb
, tcon
);
3710 if (full_path
== NULL
) {
3712 goto mount_fail_check
;
3714 rc
= server
->ops
->is_path_accessible(xid
, tcon
, cifs_sb
,
3716 if (rc
!= 0 && rc
!= -EREMOTE
) {
3718 goto mount_fail_check
;
3721 if (rc
!= -EREMOTE
) {
3722 rc
= cifs_are_all_path_components_accessible(server
,
3726 cifs_dbg(VFS
, "cannot query dirs between root and final path, "
3727 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3728 cifs_sb
->mnt_cifs_flags
|= CIFS_MOUNT_USE_PREFIX_PATH
;
3735 /* get referral if needed */
3736 if (rc
== -EREMOTE
) {
3737 #ifdef CONFIG_CIFS_DFS_UPCALL
3738 if (referral_walks_count
> MAX_NESTED_LINKS
) {
3740 * BB: when we implement proper loop detection,
3741 * we will remove this check. But now we need it
3742 * to prevent an indefinite loop if 'DFS tree' is
3743 * misconfigured (i.e. has loops).
3746 goto mount_fail_check
;
3749 rc
= expand_dfs_referral(xid
, ses
, volume_info
, cifs_sb
, true);
3752 referral_walks_count
++;
3753 goto try_mount_again
;
3755 goto mount_fail_check
;
3756 #else /* No DFS support, return error on mount */
3762 goto mount_fail_check
;
3764 /* now, hang the tcon off of the superblock */
3765 tlink
= kzalloc(sizeof *tlink
, GFP_KERNEL
);
3766 if (tlink
== NULL
) {
3768 goto mount_fail_check
;
3771 tlink
->tl_uid
= ses
->linux_uid
;
3772 tlink
->tl_tcon
= tcon
;
3773 tlink
->tl_time
= jiffies
;
3774 set_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
);
3775 set_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3777 cifs_sb
->master_tlink
= tlink
;
3778 spin_lock(&cifs_sb
->tlink_tree_lock
);
3779 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
3780 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3782 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,
3786 /* on error free sesinfo and tcon struct if needed */
3788 /* If find_unc succeeded then rc == 0 so we can not end */
3789 /* up accidentally freeing someone elses tcon struct */
3791 cifs_put_tcon(tcon
);
3793 cifs_put_smb_ses(ses
);
3795 cifs_put_tcp_session(server
);
3796 bdi_destroy(&cifs_sb
->bdi
);
3805 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3806 * pointer may be NULL.
3809 CIFSTCon(const unsigned int xid
, struct cifs_ses
*ses
,
3810 const char *tree
, struct cifs_tcon
*tcon
,
3811 const struct nls_table
*nls_codepage
)
3813 struct smb_hdr
*smb_buffer
;
3814 struct smb_hdr
*smb_buffer_response
;
3817 unsigned char *bcc_ptr
;
3820 __u16 bytes_left
, count
;
3825 smb_buffer
= cifs_buf_get();
3826 if (smb_buffer
== NULL
)
3829 smb_buffer_response
= smb_buffer
;
3831 header_assemble(smb_buffer
, SMB_COM_TREE_CONNECT_ANDX
,
3832 NULL
/*no tid */ , 4 /*wct */ );
3834 smb_buffer
->Mid
= get_next_mid(ses
->server
);
3835 smb_buffer
->Uid
= ses
->Suid
;
3836 pSMB
= (TCONX_REQ
*) smb_buffer
;
3837 pSMBr
= (TCONX_RSP
*) smb_buffer_response
;
3839 pSMB
->AndXCommand
= 0xFF;
3840 pSMB
->Flags
= cpu_to_le16(TCON_EXTENDED_SECINFO
);
3841 bcc_ptr
= &pSMB
->Password
[0];
3842 if (!tcon
|| (ses
->server
->sec_mode
& SECMODE_USER
)) {
3843 pSMB
->PasswordLength
= cpu_to_le16(1); /* minimum */
3844 *bcc_ptr
= 0; /* password is null byte */
3845 bcc_ptr
++; /* skip password */
3846 /* already aligned so no need to do it below */
3848 pSMB
->PasswordLength
= cpu_to_le16(CIFS_AUTH_RESP_SIZE
);
3849 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3850 specified as required (when that support is added to
3851 the vfs in the future) as only NTLM or the much
3852 weaker LANMAN (which we do not send by default) is accepted
3853 by Samba (not sure whether other servers allow
3854 NTLMv2 password here) */
3855 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3856 if ((global_secflags
& CIFSSEC_MAY_LANMAN
) &&
3857 (ses
->sectype
== LANMAN
))
3858 calc_lanman_hash(tcon
->password
, ses
->server
->cryptkey
,
3859 ses
->server
->sec_mode
&
3860 SECMODE_PW_ENCRYPT
? true : false,
3863 #endif /* CIFS_WEAK_PW_HASH */
3864 rc
= SMBNTencrypt(tcon
->password
, ses
->server
->cryptkey
,
3865 bcc_ptr
, nls_codepage
);
3867 cifs_dbg(FYI
, "%s Can't generate NTLM rsp. Error: %d\n",
3869 cifs_buf_release(smb_buffer
);
3873 bcc_ptr
+= CIFS_AUTH_RESP_SIZE
;
3874 if (ses
->capabilities
& CAP_UNICODE
) {
3875 /* must align unicode strings */
3876 *bcc_ptr
= 0; /* null byte password */
3881 if (ses
->server
->sign
)
3882 smb_buffer
->Flags2
|= SMBFLG2_SECURITY_SIGNATURE
;
3884 if (ses
->capabilities
& CAP_STATUS32
) {
3885 smb_buffer
->Flags2
|= SMBFLG2_ERR_STATUS
;
3887 if (ses
->capabilities
& CAP_DFS
) {
3888 smb_buffer
->Flags2
|= SMBFLG2_DFS
;
3890 if (ses
->capabilities
& CAP_UNICODE
) {
3891 smb_buffer
->Flags2
|= SMBFLG2_UNICODE
;
3893 cifs_strtoUTF16((__le16
*) bcc_ptr
, tree
,
3894 6 /* max utf8 char length in bytes */ *
3895 (/* server len*/ + 256 /* share len */), nls_codepage
);
3896 bcc_ptr
+= 2 * length
; /* convert num 16 bit words to bytes */
3897 bcc_ptr
+= 2; /* skip trailing null */
3898 } else { /* ASCII */
3899 strcpy(bcc_ptr
, tree
);
3900 bcc_ptr
+= strlen(tree
) + 1;
3902 strcpy(bcc_ptr
, "?????");
3903 bcc_ptr
+= strlen("?????");
3905 count
= bcc_ptr
- &pSMB
->Password
[0];
3906 pSMB
->hdr
.smb_buf_length
= cpu_to_be32(be32_to_cpu(
3907 pSMB
->hdr
.smb_buf_length
) + count
);
3908 pSMB
->ByteCount
= cpu_to_le16(count
);
3910 rc
= SendReceive(xid
, ses
, smb_buffer
, smb_buffer_response
, &length
,
3913 /* above now done in SendReceive */
3914 if ((rc
== 0) && (tcon
!= NULL
)) {
3917 tcon
->tidStatus
= CifsGood
;
3918 tcon
->need_reconnect
= false;
3919 tcon
->tid
= smb_buffer_response
->Tid
;
3920 bcc_ptr
= pByteArea(smb_buffer_response
);
3921 bytes_left
= get_bcc(smb_buffer_response
);
3922 length
= strnlen(bcc_ptr
, bytes_left
- 2);
3923 if (smb_buffer
->Flags2
& SMBFLG2_UNICODE
)
3929 /* skip service field (NB: this field is always ASCII) */
3931 if ((bcc_ptr
[0] == 'I') && (bcc_ptr
[1] == 'P') &&
3932 (bcc_ptr
[2] == 'C')) {
3933 cifs_dbg(FYI
, "IPC connection\n");
3936 } else if (length
== 2) {
3937 if ((bcc_ptr
[0] == 'A') && (bcc_ptr
[1] == ':')) {
3938 /* the most common case */
3939 cifs_dbg(FYI
, "disk share connection\n");
3942 bcc_ptr
+= length
+ 1;
3943 bytes_left
-= (length
+ 1);
3944 strlcpy(tcon
->treeName
, tree
, sizeof(tcon
->treeName
));
3946 /* mostly informational -- no need to fail on error here */
3947 kfree(tcon
->nativeFileSystem
);
3948 tcon
->nativeFileSystem
= cifs_strndup_from_utf16(bcc_ptr
,
3949 bytes_left
, is_unicode
,
3952 cifs_dbg(FYI
, "nativeFileSystem=%s\n", tcon
->nativeFileSystem
);
3954 if ((smb_buffer_response
->WordCount
== 3) ||
3955 (smb_buffer_response
->WordCount
== 7))
3956 /* field is in same location */
3957 tcon
->Flags
= le16_to_cpu(pSMBr
->OptionalSupport
);
3960 cifs_dbg(FYI
, "Tcon flags: 0x%x\n", tcon
->Flags
);
3961 } else if ((rc
== 0) && tcon
== NULL
) {
3962 /* all we need to save for IPC$ connection */
3963 ses
->ipc_tid
= smb_buffer_response
->Tid
;
3966 cifs_buf_release(smb_buffer
);
3970 static void delayed_free(struct rcu_head
*p
)
3972 struct cifs_sb_info
*sbi
= container_of(p
, struct cifs_sb_info
, rcu
);
3973 unload_nls(sbi
->local_nls
);
3978 cifs_umount(struct cifs_sb_info
*cifs_sb
)
3980 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
3981 struct rb_node
*node
;
3982 struct tcon_link
*tlink
;
3984 cancel_delayed_work_sync(&cifs_sb
->prune_tlinks
);
3986 spin_lock(&cifs_sb
->tlink_tree_lock
);
3987 while ((node
= rb_first(root
))) {
3988 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
3989 cifs_get_tlink(tlink
);
3990 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
3991 rb_erase(node
, root
);
3993 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3994 cifs_put_tlink(tlink
);
3995 spin_lock(&cifs_sb
->tlink_tree_lock
);
3997 spin_unlock(&cifs_sb
->tlink_tree_lock
);
3999 bdi_destroy(&cifs_sb
->bdi
);
4000 kfree(cifs_sb
->mountdata
);
4001 kfree(cifs_sb
->prepath
);
4002 call_rcu(&cifs_sb
->rcu
, delayed_free
);
4006 cifs_negotiate_protocol(const unsigned int xid
, struct cifs_ses
*ses
)
4009 struct TCP_Server_Info
*server
= ses
->server
;
4011 if (!server
->ops
->need_neg
|| !server
->ops
->negotiate
)
4014 /* only send once per connect */
4015 if (!server
->ops
->need_neg(server
))
4018 set_credits(server
, 1);
4020 rc
= server
->ops
->negotiate(xid
, ses
);
4022 spin_lock(&GlobalMid_Lock
);
4023 if (server
->tcpStatus
== CifsNeedNegotiate
)
4024 server
->tcpStatus
= CifsGood
;
4027 spin_unlock(&GlobalMid_Lock
);
4034 cifs_setup_session(const unsigned int xid
, struct cifs_ses
*ses
,
4035 struct nls_table
*nls_info
)
4038 struct TCP_Server_Info
*server
= ses
->server
;
4040 ses
->capabilities
= server
->capabilities
;
4041 if (linuxExtEnabled
== 0)
4042 ses
->capabilities
&= (~server
->vals
->cap_unix
);
4044 cifs_dbg(FYI
, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
4045 server
->sec_mode
, server
->capabilities
, server
->timeAdj
);
4047 if (server
->ops
->sess_setup
)
4048 rc
= server
->ops
->sess_setup(xid
, ses
, nls_info
);
4051 cifs_dbg(VFS
, "Send error in SessSetup = %d\n", rc
);
4057 cifs_set_vol_auth(struct smb_vol
*vol
, struct cifs_ses
*ses
)
4059 vol
->sectype
= ses
->sectype
;
4061 /* krb5 is special, since we don't need username or pw */
4062 if (vol
->sectype
== Kerberos
)
4065 return cifs_set_cifscreds(vol
, ses
);
4068 static struct cifs_tcon
*
4069 cifs_construct_tcon(struct cifs_sb_info
*cifs_sb
, kuid_t fsuid
)
4072 struct cifs_tcon
*master_tcon
= cifs_sb_master_tcon(cifs_sb
);
4073 struct cifs_ses
*ses
;
4074 struct cifs_tcon
*tcon
= NULL
;
4075 struct smb_vol
*vol_info
;
4077 vol_info
= kzalloc(sizeof(*vol_info
), GFP_KERNEL
);
4078 if (vol_info
== NULL
)
4079 return ERR_PTR(-ENOMEM
);
4081 vol_info
->local_nls
= cifs_sb
->local_nls
;
4082 vol_info
->linux_uid
= fsuid
;
4083 vol_info
->cred_uid
= fsuid
;
4084 vol_info
->UNC
= master_tcon
->treeName
;
4085 vol_info
->retry
= master_tcon
->retry
;
4086 vol_info
->nocase
= master_tcon
->nocase
;
4087 vol_info
->local_lease
= master_tcon
->local_lease
;
4088 vol_info
->no_linux_ext
= !master_tcon
->unix_ext
;
4089 vol_info
->sectype
= master_tcon
->ses
->sectype
;
4090 vol_info
->sign
= master_tcon
->ses
->sign
;
4092 rc
= cifs_set_vol_auth(vol_info
, master_tcon
->ses
);
4098 /* get a reference for the same TCP session */
4099 spin_lock(&cifs_tcp_ses_lock
);
4100 ++master_tcon
->ses
->server
->srv_count
;
4101 spin_unlock(&cifs_tcp_ses_lock
);
4103 ses
= cifs_get_smb_ses(master_tcon
->ses
->server
, vol_info
);
4105 tcon
= (struct cifs_tcon
*)ses
;
4106 cifs_put_tcp_session(master_tcon
->ses
->server
);
4110 tcon
= cifs_get_tcon(ses
, vol_info
);
4112 cifs_put_smb_ses(ses
);
4117 reset_cifs_unix_caps(0, tcon
, NULL
, vol_info
);
4119 kfree(vol_info
->username
);
4120 kfree(vol_info
->password
);
4127 cifs_sb_master_tcon(struct cifs_sb_info
*cifs_sb
)
4129 return tlink_tcon(cifs_sb_master_tlink(cifs_sb
));
4132 /* find and return a tlink with given uid */
4133 static struct tcon_link
*
4134 tlink_rb_search(struct rb_root
*root
, kuid_t uid
)
4136 struct rb_node
*node
= root
->rb_node
;
4137 struct tcon_link
*tlink
;
4140 tlink
= rb_entry(node
, struct tcon_link
, tl_rbnode
);
4142 if (uid_gt(tlink
->tl_uid
, uid
))
4143 node
= node
->rb_left
;
4144 else if (uid_lt(tlink
->tl_uid
, uid
))
4145 node
= node
->rb_right
;
4152 /* insert a tcon_link into the tree */
4154 tlink_rb_insert(struct rb_root
*root
, struct tcon_link
*new_tlink
)
4156 struct rb_node
**new = &(root
->rb_node
), *parent
= NULL
;
4157 struct tcon_link
*tlink
;
4160 tlink
= rb_entry(*new, struct tcon_link
, tl_rbnode
);
4163 if (uid_gt(tlink
->tl_uid
, new_tlink
->tl_uid
))
4164 new = &((*new)->rb_left
);
4166 new = &((*new)->rb_right
);
4169 rb_link_node(&new_tlink
->tl_rbnode
, parent
, new);
4170 rb_insert_color(&new_tlink
->tl_rbnode
, root
);
4174 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4177 * If the superblock doesn't refer to a multiuser mount, then just return
4178 * the master tcon for the mount.
4180 * First, search the rbtree for an existing tcon for this fsuid. If one
4181 * exists, then check to see if it's pending construction. If it is then wait
4182 * for construction to complete. Once it's no longer pending, check to see if
4183 * it failed and either return an error or retry construction, depending on
4186 * If one doesn't exist then insert a new tcon_link struct into the tree and
4187 * try to construct a new one.
4190 cifs_sb_tlink(struct cifs_sb_info
*cifs_sb
)
4193 kuid_t fsuid
= current_fsuid();
4194 struct tcon_link
*tlink
, *newtlink
;
4196 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
4197 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb
));
4199 spin_lock(&cifs_sb
->tlink_tree_lock
);
4200 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
4202 cifs_get_tlink(tlink
);
4203 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4205 if (tlink
== NULL
) {
4206 newtlink
= kzalloc(sizeof(*tlink
), GFP_KERNEL
);
4207 if (newtlink
== NULL
)
4208 return ERR_PTR(-ENOMEM
);
4209 newtlink
->tl_uid
= fsuid
;
4210 newtlink
->tl_tcon
= ERR_PTR(-EACCES
);
4211 set_bit(TCON_LINK_PENDING
, &newtlink
->tl_flags
);
4212 set_bit(TCON_LINK_IN_TREE
, &newtlink
->tl_flags
);
4213 cifs_get_tlink(newtlink
);
4215 spin_lock(&cifs_sb
->tlink_tree_lock
);
4216 /* was one inserted after previous search? */
4217 tlink
= tlink_rb_search(&cifs_sb
->tlink_tree
, fsuid
);
4219 cifs_get_tlink(tlink
);
4220 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4222 goto wait_for_construction
;
4225 tlink_rb_insert(&cifs_sb
->tlink_tree
, tlink
);
4226 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4228 wait_for_construction
:
4229 ret
= wait_on_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
,
4230 TASK_INTERRUPTIBLE
);
4232 cifs_put_tlink(tlink
);
4233 return ERR_PTR(-ERESTARTSYS
);
4236 /* if it's good, return it */
4237 if (!IS_ERR(tlink
->tl_tcon
))
4240 /* return error if we tried this already recently */
4241 if (time_before(jiffies
, tlink
->tl_time
+ TLINK_ERROR_EXPIRE
)) {
4242 cifs_put_tlink(tlink
);
4243 return ERR_PTR(-EACCES
);
4246 if (test_and_set_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
))
4247 goto wait_for_construction
;
4250 tlink
->tl_tcon
= cifs_construct_tcon(cifs_sb
, fsuid
);
4251 clear_bit(TCON_LINK_PENDING
, &tlink
->tl_flags
);
4252 wake_up_bit(&tlink
->tl_flags
, TCON_LINK_PENDING
);
4254 if (IS_ERR(tlink
->tl_tcon
)) {
4255 cifs_put_tlink(tlink
);
4256 return ERR_PTR(-EACCES
);
4263 * periodic workqueue job that scans tcon_tree for a superblock and closes
4267 cifs_prune_tlinks(struct work_struct
*work
)
4269 struct cifs_sb_info
*cifs_sb
= container_of(work
, struct cifs_sb_info
,
4271 struct rb_root
*root
= &cifs_sb
->tlink_tree
;
4272 struct rb_node
*node
= rb_first(root
);
4273 struct rb_node
*tmp
;
4274 struct tcon_link
*tlink
;
4277 * Because we drop the spinlock in the loop in order to put the tlink
4278 * it's not guarded against removal of links from the tree. The only
4279 * places that remove entries from the tree are this function and
4280 * umounts. Because this function is non-reentrant and is canceled
4281 * before umount can proceed, this is safe.
4283 spin_lock(&cifs_sb
->tlink_tree_lock
);
4284 node
= rb_first(root
);
4285 while (node
!= NULL
) {
4287 node
= rb_next(tmp
);
4288 tlink
= rb_entry(tmp
, struct tcon_link
, tl_rbnode
);
4290 if (test_bit(TCON_LINK_MASTER
, &tlink
->tl_flags
) ||
4291 atomic_read(&tlink
->tl_count
) != 0 ||
4292 time_after(tlink
->tl_time
+ TLINK_IDLE_EXPIRE
, jiffies
))
4295 cifs_get_tlink(tlink
);
4296 clear_bit(TCON_LINK_IN_TREE
, &tlink
->tl_flags
);
4297 rb_erase(tmp
, root
);
4299 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4300 cifs_put_tlink(tlink
);
4301 spin_lock(&cifs_sb
->tlink_tree_lock
);
4303 spin_unlock(&cifs_sb
->tlink_tree_lock
);
4305 queue_delayed_work(cifsiod_wq
, &cifs_sb
->prune_tlinks
,