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)
67 /* Mount options that take no arguments */
68 Opt_user_xattr, Opt_nouser_xattr,
69 Opt_forceuid, Opt_noforceuid,
70 Opt_forcegid, Opt_noforcegid,
71 Opt_noblocksend, Opt_noautotune,
72 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
73 Opt_mapchars, Opt_nomapchars, Opt_sfu,
74 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
75 Opt_noposixpaths, Opt_nounix,
78 Opt_forcemandatorylock, 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,
90 /* Mount options which take numeric value */
91 Opt_backupuid, Opt_backupgid, Opt_uid,
92 Opt_cruid, Opt_gid, Opt_file_mode,
93 Opt_dirmode, Opt_port,
94 Opt_rsize, Opt_wsize, Opt_actimeo,
96 /* Mount options which take string value */
97 Opt_user, Opt_pass, Opt_ip,
99 Opt_srcaddr, Opt_prefixpath,
100 Opt_iocharset, Opt_sockopt,
101 Opt_netbiosname, Opt_servern,
102 Opt_ver, Opt_vers, Opt_sec, Opt_cache,
104 /* Mount options to be ignored */
107 /* Options which could be blank */
115 static const match_table_t cifs_mount_option_tokens = {
117 { Opt_user_xattr, "user_xattr" },
118 { Opt_nouser_xattr, "nouser_xattr" },
119 { Opt_forceuid, "forceuid" },
120 { Opt_noforceuid, "noforceuid" },
121 { Opt_forcegid, "forcegid" },
122 { Opt_noforcegid, "noforcegid" },
123 { Opt_noblocksend, "noblocksend" },
124 { Opt_noautotune, "noautotune" },
125 { Opt_hard, "hard" },
126 { Opt_soft, "soft" },
127 { Opt_perm, "perm" },
128 { Opt_noperm, "noperm" },
129 { Opt_mapchars, "mapchars" },
130 { Opt_nomapchars, "nomapchars" },
132 { Opt_nosfu, "nosfu" },
133 { Opt_nodfs, "nodfs" },
134 { Opt_posixpaths, "posixpaths" },
135 { Opt_noposixpaths, "noposixpaths" },
136 { Opt_nounix, "nounix" },
137 { Opt_nounix, "nolinux" },
138 { Opt_nocase, "nocase" },
139 { Opt_nocase, "ignorecase" },
141 { Opt_nobrl, "nobrl" },
142 { Opt_nobrl, "nolock" },
143 { Opt_forcemandatorylock, "forcemandatorylock" },
144 { Opt_forcemandatorylock, "forcemand" },
145 { Opt_setuids, "setuids" },
146 { Opt_nosetuids, "nosetuids" },
147 { Opt_dynperm, "dynperm" },
148 { Opt_nodynperm, "nodynperm" },
149 { Opt_nohard, "nohard" },
150 { Opt_nosoft, "nosoft" },
151 { Opt_nointr, "nointr" },
152 { Opt_intr, "intr" },
153 { Opt_nostrictsync, "nostrictsync" },
154 { Opt_strictsync, "strictsync" },
155 { Opt_serverino, "serverino" },
156 { Opt_noserverino, "noserverino" },
157 { Opt_rwpidforward, "rwpidforward" },
158 { Opt_cifsacl, "cifsacl" },
159 { Opt_nocifsacl, "nocifsacl" },
161 { Opt_noacl, "noacl" },
162 { Opt_locallease, "locallease" },
163 { Opt_sign, "sign" },
164 { Opt_seal, "seal" },
165 { Opt_noac, "noac" },
167 { Opt_mfsymlinks, "mfsymlinks" },
168 { Opt_multiuser, "multiuser" },
169 { Opt_sloppy, "sloppy" },
171 { Opt_backupuid, "backupuid=%s" },
172 { Opt_backupgid, "backupgid=%s" },
173 { Opt_uid, "uid=%s" },
174 { Opt_cruid, "cruid=%s" },
175 { Opt_gid, "gid=%s" },
176 { Opt_file_mode, "file_mode=%s" },
177 { Opt_dirmode, "dirmode=%s" },
178 { Opt_dirmode, "dir_mode=%s" },
179 { Opt_port, "port=%s" },
180 { Opt_rsize, "rsize=%s" },
181 { Opt_wsize, "wsize=%s" },
182 { Opt_actimeo, "actimeo=%s" },
184 { Opt_blank_user, "user=" },
185 { Opt_blank_user, "username=" },
186 { Opt_user, "user=%s" },
187 { Opt_user, "username=%s" },
188 { Opt_blank_pass, "pass=" },
189 { Opt_blank_pass, "password=" },
190 { Opt_pass, "pass=%s" },
191 { Opt_pass, "password=%s" },
192 { Opt_blank_ip, "ip=" },
193 { Opt_blank_ip, "addr=" },
195 { Opt_ip, "addr=%s" },
196 { Opt_unc, "unc=%s" },
197 { Opt_unc, "target=%s" },
198 { Opt_unc, "path=%s" },
199 { Opt_domain, "dom=%s" },
200 { Opt_domain, "domain=%s" },
201 { Opt_domain, "workgroup=%s" },
202 { Opt_srcaddr, "srcaddr=%s" },
203 { Opt_prefixpath, "prefixpath=%s" },
204 { Opt_iocharset, "iocharset=%s" },
205 { Opt_sockopt, "sockopt=%s" },
206 { Opt_netbiosname, "netbiosname=%s" },
207 { Opt_servern, "servern=%s" },
208 { Opt_ver, "ver=%s" },
209 { Opt_vers, "vers=%s" },
210 { Opt_sec, "sec=%s" },
211 { Opt_cache, "cache=%s" },
213 { Opt_ignore, "cred" },
214 { Opt_ignore, "credentials" },
215 { Opt_ignore, "cred=%s" },
216 { Opt_ignore, "credentials=%s" },
217 { Opt_ignore, "guest" },
218 { Opt_ignore, "rw" },
219 { Opt_ignore, "ro" },
220 { Opt_ignore, "suid" },
221 { Opt_ignore, "nosuid" },
222 { Opt_ignore, "exec" },
223 { Opt_ignore, "noexec" },
224 { Opt_ignore, "nodev" },
225 { Opt_ignore, "noauto" },
226 { Opt_ignore, "dev" },
227 { Opt_ignore, "mand" },
228 { Opt_ignore, "nomand" },
229 { Opt_ignore, "_netdev" },
235 Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
236 Opt_sec_ntlmsspi, Opt_sec_ntlmssp,
237 Opt_ntlm, Opt_sec_ntlmi, Opt_sec_ntlmv2,
238 Opt_sec_ntlmv2i, Opt_sec_lanman,
244 static const match_table_t cifs_secflavor_tokens = {
245 { Opt_sec_krb5, "krb5" },
246 { Opt_sec_krb5i, "krb5i" },
247 { Opt_sec_krb5p, "krb5p" },
248 { Opt_sec_ntlmsspi, "ntlmsspi" },
249 { Opt_sec_ntlmssp, "ntlmssp" },
250 { Opt_ntlm, "ntlm" },
251 { Opt_sec_ntlmi, "ntlmi" },
252 { Opt_sec_ntlmv2, "nontlm" },
253 { Opt_sec_ntlmv2, "ntlmv2" },
254 { Opt_sec_ntlmv2i, "ntlmv2i" },
255 { Opt_sec_lanman, "lanman" },
256 { Opt_sec_none, "none" },
258 { Opt_sec_err, NULL }
269 static const match_table_t cifs_cacheflavor_tokens = {
270 { Opt_cache_loose, "loose" },
271 { Opt_cache_strict, "strict" },
272 { Opt_cache_none, "none" },
273 { Opt_cache_err, NULL }
276 static const match_table_t cifs_smb_version_tokens = {
277 { Smb_1, SMB1_VERSION_STRING },
278 { Smb_20, SMB20_VERSION_STRING},
279 { Smb_21, SMB21_VERSION_STRING },
280 { Smb_30, SMB30_VERSION_STRING },
283 static int ip_connect(struct TCP_Server_Info *server);
284 static int generic_ip_connect(struct TCP_Server_Info *server);
285 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
286 static void cifs_prune_tlinks(struct work_struct *work);
287 static int cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
288 const char *devname);
291 * cifs tcp session reconnection
293 * mark tcp session as reconnecting so temporarily locked
294 * mark all smb sessions as reconnecting for tcp session
295 * reconnect tcp session
296 * wake up waiters on reconnection? - (not needed currently)
299 cifs_reconnect(struct TCP_Server_Info *server)
302 struct list_head *tmp, *tmp2;
303 struct cifs_ses *ses;
304 struct cifs_tcon *tcon;
305 struct mid_q_entry *mid_entry;
306 struct list_head retry_list;
308 spin_lock(&GlobalMid_Lock);
309 if (server->tcpStatus == CifsExiting) {
310 /* the demux thread will exit normally
311 next time through the loop */
312 spin_unlock(&GlobalMid_Lock);
315 server->tcpStatus = CifsNeedReconnect;
316 spin_unlock(&GlobalMid_Lock);
318 #ifdef CONFIG_CIFS_SMB2
319 server->max_read = 0;
322 cFYI(1, "Reconnecting tcp session");
324 /* before reconnecting the tcp session, mark the smb session (uid)
325 and the tid bad so they are not used until reconnected */
326 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
327 spin_lock(&cifs_tcp_ses_lock);
328 list_for_each(tmp, &server->smb_ses_list) {
329 ses = list_entry(tmp, struct cifs_ses, smb_ses_list);
330 ses->need_reconnect = true;
332 list_for_each(tmp2, &ses->tcon_list) {
333 tcon = list_entry(tmp2, struct cifs_tcon, tcon_list);
334 tcon->need_reconnect = true;
337 spin_unlock(&cifs_tcp_ses_lock);
339 /* do not want to be sending data on a socket we are freeing */
340 cFYI(1, "%s: tearing down socket", __func__);
341 mutex_lock(&server->srv_mutex);
342 if (server->ssocket) {
343 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
344 server->ssocket->flags);
345 kernel_sock_shutdown(server->ssocket, SHUT_WR);
346 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
347 server->ssocket->state,
348 server->ssocket->flags);
349 sock_release(server->ssocket);
350 server->ssocket = NULL;
352 server->sequence_number = 0;
353 server->session_estab = false;
354 kfree(server->session_key.response);
355 server->session_key.response = NULL;
356 server->session_key.len = 0;
357 server->lstrp = jiffies;
358 mutex_unlock(&server->srv_mutex);
360 /* mark submitted MIDs for retry and issue callback */
361 INIT_LIST_HEAD(&retry_list);
362 cFYI(1, "%s: moving mids to private list", __func__);
363 spin_lock(&GlobalMid_Lock);
364 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
365 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
366 if (mid_entry->mid_state == MID_REQUEST_SUBMITTED)
367 mid_entry->mid_state = MID_RETRY_NEEDED;
368 list_move(&mid_entry->qhead, &retry_list);
370 spin_unlock(&GlobalMid_Lock);
372 cFYI(1, "%s: issuing mid callbacks", __func__);
373 list_for_each_safe(tmp, tmp2, &retry_list) {
374 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
375 list_del_init(&mid_entry->qhead);
376 mid_entry->callback(mid_entry);
382 /* we should try only the port we connected to before */
383 rc = generic_ip_connect(server);
385 cFYI(1, "reconnect error %d", rc);
388 atomic_inc(&tcpSesReconnectCount);
389 spin_lock(&GlobalMid_Lock);
390 if (server->tcpStatus != CifsExiting)
391 server->tcpStatus = CifsNeedNegotiate;
392 spin_unlock(&GlobalMid_Lock);
394 } while (server->tcpStatus == CifsNeedReconnect);
400 cifs_echo_request(struct work_struct *work)
403 struct TCP_Server_Info *server = container_of(work,
404 struct TCP_Server_Info, echo.work);
407 * We cannot send an echo if it is disabled or until the
408 * NEGOTIATE_PROTOCOL request is done, which is indicated by
409 * server->ops->need_neg() == true. Also, no need to ping if
410 * we got a response recently.
412 if (!server->ops->need_neg || server->ops->need_neg(server) ||
413 (server->ops->can_echo && !server->ops->can_echo(server)) ||
414 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
417 rc = server->ops->echo ? server->ops->echo(server) : -ENOSYS;
419 cFYI(1, "Unable to send echo request to server: %s",
423 queue_delayed_work(cifsiod_wq, &server->echo, SMB_ECHO_INTERVAL);
427 allocate_buffers(struct TCP_Server_Info *server)
429 if (!server->bigbuf) {
430 server->bigbuf = (char *)cifs_buf_get();
431 if (!server->bigbuf) {
432 cERROR(1, "No memory for large SMB response");
434 /* retry will check if exiting */
437 } else if (server->large_buf) {
438 /* we are reusing a dirty large buf, clear its start */
439 memset(server->bigbuf, 0, HEADER_SIZE(server));
442 if (!server->smallbuf) {
443 server->smallbuf = (char *)cifs_small_buf_get();
444 if (!server->smallbuf) {
445 cERROR(1, "No memory for SMB response");
447 /* retry will check if exiting */
450 /* beginning of smb buffer is cleared in our buf_get */
452 /* if existing small buf clear beginning */
453 memset(server->smallbuf, 0, HEADER_SIZE(server));
460 server_unresponsive(struct TCP_Server_Info *server)
463 * We need to wait 2 echo intervals to make sure we handle such
465 * 1s client sends a normal SMB request
466 * 2s client gets a response
467 * 30s echo workqueue job pops, and decides we got a response recently
468 * and don't need to send another
470 * 65s kernel_recvmsg times out, and we see that we haven't gotten
471 * a response in >60s.
473 if (server->tcpStatus == CifsGood &&
474 time_after(jiffies, server->lstrp + 2 * SMB_ECHO_INTERVAL)) {
475 cERROR(1, "Server %s has not responded in %d seconds. "
476 "Reconnecting...", server->hostname,
477 (2 * SMB_ECHO_INTERVAL) / HZ);
478 cifs_reconnect(server);
479 wake_up(&server->response_q);
487 * kvec_array_init - clone a kvec array, and advance into it
488 * @new: pointer to memory for cloned array
489 * @iov: pointer to original array
490 * @nr_segs: number of members in original array
491 * @bytes: number of bytes to advance into the cloned array
493 * This function will copy the array provided in iov to a section of memory
494 * and advance the specified number of bytes into the new array. It returns
495 * the number of segments in the new array. "new" must be at least as big as
496 * the original iov array.
499 kvec_array_init(struct kvec *new, struct kvec *iov, unsigned int nr_segs,
504 while (bytes || !iov->iov_len) {
505 int copy = min(bytes, iov->iov_len);
509 if (iov->iov_len == base) {
515 memcpy(new, iov, sizeof(*iov) * nr_segs);
516 new->iov_base += base;
517 new->iov_len -= base;
522 get_server_iovec(struct TCP_Server_Info *server, unsigned int nr_segs)
524 struct kvec *new_iov;
526 if (server->iov && nr_segs <= server->nr_iov)
529 /* not big enough -- allocate a new one and release the old */
530 new_iov = kmalloc(sizeof(*new_iov) * nr_segs, GFP_NOFS);
533 server->iov = new_iov;
534 server->nr_iov = nr_segs;
540 cifs_readv_from_socket(struct TCP_Server_Info *server, struct kvec *iov_orig,
541 unsigned int nr_segs, unsigned int to_read)
546 struct msghdr smb_msg;
549 iov = get_server_iovec(server, nr_segs);
553 smb_msg.msg_control = NULL;
554 smb_msg.msg_controllen = 0;
556 for (total_read = 0; to_read; total_read += length, to_read -= length) {
559 if (server_unresponsive(server)) {
560 total_read = -EAGAIN;
564 segs = kvec_array_init(iov, iov_orig, nr_segs, total_read);
566 length = kernel_recvmsg(server->ssocket, &smb_msg,
567 iov, segs, to_read, 0);
569 if (server->tcpStatus == CifsExiting) {
570 total_read = -ESHUTDOWN;
572 } else if (server->tcpStatus == CifsNeedReconnect) {
573 cifs_reconnect(server);
574 total_read = -EAGAIN;
576 } else if (length == -ERESTARTSYS ||
580 * Minimum sleep to prevent looping, allowing socket
581 * to clear and app threads to set tcpStatus
582 * CifsNeedReconnect if server hung.
584 usleep_range(1000, 2000);
587 } else if (length <= 0) {
588 cFYI(1, "Received no data or error: expecting %d "
589 "got %d", to_read, length);
590 cifs_reconnect(server);
591 total_read = -EAGAIN;
599 cifs_read_from_socket(struct TCP_Server_Info *server, char *buf,
600 unsigned int to_read)
605 iov.iov_len = to_read;
607 return cifs_readv_from_socket(server, &iov, 1, to_read);
611 is_smb_response(struct TCP_Server_Info *server, unsigned char type)
614 * The first byte big endian of the length field,
615 * is actually not part of the length but the type
616 * with the most common, zero, as regular data.
619 case RFC1002_SESSION_MESSAGE:
620 /* Regular SMB response */
622 case RFC1002_SESSION_KEEP_ALIVE:
623 cFYI(1, "RFC 1002 session keep alive");
625 case RFC1002_POSITIVE_SESSION_RESPONSE:
626 cFYI(1, "RFC 1002 positive session response");
628 case RFC1002_NEGATIVE_SESSION_RESPONSE:
630 * We get this from Windows 98 instead of an error on
631 * SMB negprot response.
633 cFYI(1, "RFC 1002 negative session response");
634 /* give server a second to clean up */
637 * Always try 445 first on reconnect since we get NACK
638 * on some if we ever connected to port 139 (the NACK
639 * is since we do not begin with RFC1001 session
642 cifs_set_port((struct sockaddr *)&server->dstaddr, CIFS_PORT);
643 cifs_reconnect(server);
644 wake_up(&server->response_q);
647 cERROR(1, "RFC 1002 unknown response type 0x%x", type);
648 cifs_reconnect(server);
655 dequeue_mid(struct mid_q_entry *mid, bool malformed)
657 #ifdef CONFIG_CIFS_STATS2
658 mid->when_received = jiffies;
660 spin_lock(&GlobalMid_Lock);
662 mid->mid_state = MID_RESPONSE_RECEIVED;
664 mid->mid_state = MID_RESPONSE_MALFORMED;
665 list_del_init(&mid->qhead);
666 spin_unlock(&GlobalMid_Lock);
670 handle_mid(struct mid_q_entry *mid, struct TCP_Server_Info *server,
671 char *buf, int malformed)
673 if (server->ops->check_trans2 &&
674 server->ops->check_trans2(mid, server, buf, malformed))
677 mid->large_buf = server->large_buf;
678 /* Was previous buf put in mpx struct for multi-rsp? */
679 if (!mid->multiRsp) {
680 /* smb buffer will be freed by user thread */
681 if (server->large_buf)
682 server->bigbuf = NULL;
684 server->smallbuf = NULL;
686 dequeue_mid(mid, malformed);
689 static void clean_demultiplex_info(struct TCP_Server_Info *server)
693 /* take it off the list, if it's not already */
694 spin_lock(&cifs_tcp_ses_lock);
695 list_del_init(&server->tcp_ses_list);
696 spin_unlock(&cifs_tcp_ses_lock);
698 spin_lock(&GlobalMid_Lock);
699 server->tcpStatus = CifsExiting;
700 spin_unlock(&GlobalMid_Lock);
701 wake_up_all(&server->response_q);
703 /* check if we have blocked requests that need to free */
704 spin_lock(&server->req_lock);
705 if (server->credits <= 0)
707 spin_unlock(&server->req_lock);
709 * Although there should not be any requests blocked on this queue it
710 * can not hurt to be paranoid and try to wake up requests that may
711 * haven been blocked when more than 50 at time were on the wire to the
712 * same server - they now will see the session is in exit state and get
713 * out of SendReceive.
715 wake_up_all(&server->request_q);
716 /* give those requests time to exit */
719 if (server->ssocket) {
720 sock_release(server->ssocket);
721 server->ssocket = NULL;
724 if (!list_empty(&server->pending_mid_q)) {
725 struct list_head dispose_list;
726 struct mid_q_entry *mid_entry;
727 struct list_head *tmp, *tmp2;
729 INIT_LIST_HEAD(&dispose_list);
730 spin_lock(&GlobalMid_Lock);
731 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
732 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
733 cFYI(1, "Clearing mid 0x%llx", mid_entry->mid);
734 mid_entry->mid_state = MID_SHUTDOWN;
735 list_move(&mid_entry->qhead, &dispose_list);
737 spin_unlock(&GlobalMid_Lock);
739 /* now walk dispose list and issue callbacks */
740 list_for_each_safe(tmp, tmp2, &dispose_list) {
741 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
742 cFYI(1, "Callback mid 0x%llx", mid_entry->mid);
743 list_del_init(&mid_entry->qhead);
744 mid_entry->callback(mid_entry);
746 /* 1/8th of sec is more than enough time for them to exit */
750 if (!list_empty(&server->pending_mid_q)) {
752 * mpx threads have not exited yet give them at least the smb
753 * send timeout time for long ops.
755 * Due to delays on oplock break requests, we need to wait at
756 * least 45 seconds before giving up on a request getting a
757 * response and going ahead and killing cifsd.
759 cFYI(1, "Wait for exit from demultiplex thread");
762 * If threads still have not exited they are probably never
763 * coming home not much else we can do but free the memory.
767 kfree(server->hostname);
771 length = atomic_dec_return(&tcpSesAllocCount);
773 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
778 standard_receive3(struct TCP_Server_Info *server, struct mid_q_entry *mid)
781 char *buf = server->smallbuf;
782 unsigned int pdu_length = get_rfc1002_length(buf);
784 /* make sure this will fit in a large buffer */
785 if (pdu_length > CIFSMaxBufSize + MAX_HEADER_SIZE(server) - 4) {
786 cERROR(1, "SMB response too long (%u bytes)",
788 cifs_reconnect(server);
789 wake_up(&server->response_q);
793 /* switch to large buffer if too big for a small one */
794 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
795 server->large_buf = true;
796 memcpy(server->bigbuf, buf, server->total_read);
797 buf = server->bigbuf;
800 /* now read the rest */
801 length = cifs_read_from_socket(server, buf + HEADER_SIZE(server) - 1,
802 pdu_length - HEADER_SIZE(server) + 1 + 4);
805 server->total_read += length;
807 dump_smb(buf, server->total_read);
810 * We know that we received enough to get to the MID as we
811 * checked the pdu_length earlier. Now check to see
812 * if the rest of the header is OK. We borrow the length
813 * var for the rest of the loop to avoid a new stack var.
815 * 48 bytes is enough to display the header and a little bit
816 * into the payload for debugging purposes.
818 length = server->ops->check_message(buf, server->total_read);
820 cifs_dump_mem("Bad SMB: ", buf,
821 min_t(unsigned int, server->total_read, 48));
823 if (server->ops->is_status_pending &&
824 server->ops->is_status_pending(buf, server, length))
830 handle_mid(mid, server, buf, length);
835 cifs_demultiplex_thread(void *p)
838 struct TCP_Server_Info *server = p;
839 unsigned int pdu_length;
841 struct task_struct *task_to_wake = NULL;
842 struct mid_q_entry *mid_entry;
844 current->flags |= PF_MEMALLOC;
845 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
847 length = atomic_inc_return(&tcpSesAllocCount);
849 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
853 while (server->tcpStatus != CifsExiting) {
857 if (!allocate_buffers(server))
860 server->large_buf = false;
861 buf = server->smallbuf;
862 pdu_length = 4; /* enough to get RFC1001 header */
864 length = cifs_read_from_socket(server, buf, pdu_length);
867 server->total_read = length;
870 * The right amount was read from socket - 4 bytes,
871 * so we can now interpret the length field.
873 pdu_length = get_rfc1002_length(buf);
875 cFYI(1, "RFC1002 header 0x%x", pdu_length);
876 if (!is_smb_response(server, buf[0]))
879 /* make sure we have enough to get to the MID */
880 if (pdu_length < HEADER_SIZE(server) - 1 - 4) {
881 cERROR(1, "SMB response too short (%u bytes)",
883 cifs_reconnect(server);
884 wake_up(&server->response_q);
888 /* read down to the MID */
889 length = cifs_read_from_socket(server, buf + 4,
890 HEADER_SIZE(server) - 1 - 4);
893 server->total_read += length;
895 mid_entry = server->ops->find_mid(server, buf);
897 if (!mid_entry || !mid_entry->receive)
898 length = standard_receive3(server, mid_entry);
900 length = mid_entry->receive(server, mid_entry);
905 if (server->large_buf)
906 buf = server->bigbuf;
908 server->lstrp = jiffies;
909 if (mid_entry != NULL) {
910 if (!mid_entry->multiRsp || mid_entry->multiEnd)
911 mid_entry->callback(mid_entry);
912 } else if (!server->ops->is_oplock_break ||
913 !server->ops->is_oplock_break(buf, server)) {
914 cERROR(1, "No task to wake, unknown frame received! "
915 "NumMids %d", atomic_read(&midCount));
916 cifs_dump_mem("Received Data is: ", buf,
917 HEADER_SIZE(server));
918 #ifdef CONFIG_CIFS_DEBUG2
919 if (server->ops->dump_detail)
920 server->ops->dump_detail(buf);
921 cifs_dump_mids(server);
922 #endif /* CIFS_DEBUG2 */
925 } /* end while !EXITING */
927 /* buffer usually freed in free_mid - need to free it here on exit */
928 cifs_buf_release(server->bigbuf);
929 if (server->smallbuf) /* no sense logging a debug message if NULL */
930 cifs_small_buf_release(server->smallbuf);
932 task_to_wake = xchg(&server->tsk, NULL);
933 clean_demultiplex_info(server);
935 /* if server->tsk was NULL then wait for a signal before exiting */
937 set_current_state(TASK_INTERRUPTIBLE);
938 while (!signal_pending(current)) {
940 set_current_state(TASK_INTERRUPTIBLE);
942 set_current_state(TASK_RUNNING);
945 module_put_and_exit(0);
948 /* extract the host portion of the UNC string */
950 extract_hostname(const char *unc)
956 /* skip double chars at beginning of string */
957 /* BB: check validity of these bytes? */
960 /* delimiter between hostname and sharename is always '\\' now */
961 delim = strchr(src, '\\');
963 return ERR_PTR(-EINVAL);
966 dst = kmalloc((len + 1), GFP_KERNEL);
968 return ERR_PTR(-ENOMEM);
970 memcpy(dst, src, len);
976 static int get_option_ul(substring_t args[], unsigned long *option)
981 string = match_strdup(args);
984 rc = kstrtoul(string, 0, option);
991 static int cifs_parse_security_flavors(char *value,
995 substring_t args[MAX_OPT_ARGS];
997 switch (match_token(value, cifs_secflavor_tokens, args)) {
999 vol->secFlg |= CIFSSEC_MAY_KRB5;
1002 vol->secFlg |= CIFSSEC_MAY_KRB5 | CIFSSEC_MUST_SIGN;
1005 /* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
1006 cERROR(1, "Krb5 cifs privacy not supported");
1008 case Opt_sec_ntlmssp:
1009 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1011 case Opt_sec_ntlmsspi:
1012 vol->secFlg |= CIFSSEC_MAY_NTLMSSP | CIFSSEC_MUST_SIGN;
1015 /* ntlm is default so can be turned off too */
1016 vol->secFlg |= CIFSSEC_MAY_NTLM;
1019 vol->secFlg |= CIFSSEC_MAY_NTLM | CIFSSEC_MUST_SIGN;
1021 case Opt_sec_ntlmv2:
1022 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1024 case Opt_sec_ntlmv2i:
1025 vol->secFlg |= CIFSSEC_MAY_NTLMV2 | CIFSSEC_MUST_SIGN;
1027 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1028 case Opt_sec_lanman:
1029 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1036 cERROR(1, "bad security option: %s", value);
1044 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1046 substring_t args[MAX_OPT_ARGS];
1048 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1049 case Opt_cache_loose:
1050 vol->direct_io = false;
1051 vol->strict_io = false;
1053 case Opt_cache_strict:
1054 vol->direct_io = false;
1055 vol->strict_io = true;
1057 case Opt_cache_none:
1058 vol->direct_io = true;
1059 vol->strict_io = false;
1062 cERROR(1, "bad cache= option: %s", value);
1069 cifs_parse_smb_version(char *value, struct smb_vol *vol)
1071 substring_t args[MAX_OPT_ARGS];
1073 switch (match_token(value, cifs_smb_version_tokens, args)) {
1075 vol->ops = &smb1_operations;
1076 vol->vals = &smb1_values;
1078 #ifdef CONFIG_CIFS_SMB2
1080 vol->ops = &smb21_operations; /* currently identical with 2.1 */
1081 vol->vals = &smb20_values;
1084 vol->ops = &smb21_operations;
1085 vol->vals = &smb21_values;
1088 vol->ops = &smb30_operations;
1089 vol->vals = &smb30_values;
1093 cERROR(1, "Unknown vers= option specified: %s", value);
1100 cifs_parse_mount_options(const char *mountdata, const char *devname,
1101 struct smb_vol *vol)
1104 char *mountdata_copy = NULL, *options;
1105 unsigned int temp_len, i, j;
1107 short int override_uid = -1;
1108 short int override_gid = -1;
1109 bool uid_specified = false;
1110 bool gid_specified = false;
1111 bool sloppy = false;
1112 char *invalid = NULL;
1113 char *nodename = utsname()->nodename;
1114 char *string = NULL;
1115 char *tmp_end, *value;
1117 bool got_ip = false;
1118 unsigned short port = 0;
1119 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1123 delim = separator[0];
1125 /* ensure we always start with zeroed-out smb_vol */
1126 memset(vol, 0, sizeof(*vol));
1129 * does not have to be perfect mapping since field is
1130 * informational, only used for servers that do not support
1131 * port 445 and it can be overridden at mount time
1133 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1134 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1135 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1137 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1138 /* null target name indicates to use *SMBSERVR default called name
1139 if we end up sending RFC1001 session initialize */
1140 vol->target_rfc1001_name[0] = 0;
1141 vol->cred_uid = current_uid();
1142 vol->linux_uid = current_uid();
1143 vol->linux_gid = current_gid();
1145 /* default to only allowing write access to owner of the mount */
1146 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1148 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1149 /* default is always to request posix paths. */
1150 vol->posix_paths = 1;
1151 /* default to using server inode numbers where available */
1152 vol->server_ino = 1;
1154 /* default is to use strict cifs caching semantics */
1155 vol->strict_io = true;
1157 vol->actimeo = CIFS_DEF_ACTIMEO;
1159 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1160 vol->ops = &smb1_operations;
1161 vol->vals = &smb1_values;
1164 goto cifs_parse_mount_err;
1166 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1167 if (!mountdata_copy)
1168 goto cifs_parse_mount_err;
1170 options = mountdata_copy;
1171 end = options + strlen(options);
1173 if (strncmp(options, "sep=", 4) == 0) {
1174 if (options[4] != 0) {
1175 separator[0] = options[4];
1178 cFYI(1, "Null separator not allowed");
1181 vol->backupuid_specified = false; /* no backup intent for a user */
1182 vol->backupgid_specified = false; /* no backup intent for a group */
1184 while ((data = strsep(&options, separator)) != NULL) {
1185 substring_t args[MAX_OPT_ARGS];
1186 unsigned long option;
1192 token = match_token(data, cifs_mount_option_tokens, args);
1196 /* Ingnore the following */
1200 /* Boolean values */
1201 case Opt_user_xattr:
1204 case Opt_nouser_xattr:
1210 case Opt_noforceuid:
1216 case Opt_noforcegid:
1219 case Opt_noblocksend:
1220 vol->noblocksnd = 1;
1222 case Opt_noautotune:
1223 vol->noautotune = 1;
1240 case Opt_nomapchars:
1252 case Opt_posixpaths:
1253 vol->posix_paths = 1;
1255 case Opt_noposixpaths:
1256 vol->posix_paths = 0;
1259 vol->no_linux_ext = 1;
1270 * turn off mandatory locking in mode
1271 * if remote locking is turned off since the
1272 * local vfs will do advisory
1274 if (vol->file_mode ==
1275 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1276 vol->file_mode = S_IALLUGO;
1278 case Opt_forcemandatorylock:
1288 vol->dynperm = true;
1291 vol->dynperm = false;
1305 case Opt_nostrictsync:
1306 vol->nostrictsync = 1;
1308 case Opt_strictsync:
1309 vol->nostrictsync = 0;
1312 vol->server_ino = 1;
1314 case Opt_noserverino:
1315 vol->server_ino = 0;
1317 case Opt_rwpidforward:
1318 vol->rwpidforward = 1;
1327 vol->no_psx_acl = 0;
1330 vol->no_psx_acl = 1;
1332 case Opt_locallease:
1333 vol->local_lease = 1;
1336 vol->secFlg |= CIFSSEC_MUST_SIGN;
1339 /* we do not do the following in secFlags because seal
1340 * is a per tree connection (mount) not a per socket
1341 * or per-smb connection option in the protocol
1342 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1347 printk(KERN_WARNING "CIFS: Mount option noac not "
1348 "supported. Instead set "
1349 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1352 #ifndef CONFIG_CIFS_FSCACHE
1353 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
1354 "kernel config option set");
1355 goto cifs_parse_mount_err;
1359 case Opt_mfsymlinks:
1360 vol->mfsymlinks = true;
1363 vol->multiuser = true;
1369 /* Numeric Values */
1371 if (get_option_ul(args, &option)) {
1372 cERROR(1, "%s: Invalid backupuid value",
1374 goto cifs_parse_mount_err;
1376 vol->backupuid = option;
1377 vol->backupuid_specified = true;
1380 if (get_option_ul(args, &option)) {
1381 cERROR(1, "%s: Invalid backupgid value",
1383 goto cifs_parse_mount_err;
1385 vol->backupgid = option;
1386 vol->backupgid_specified = true;
1389 if (get_option_ul(args, &option)) {
1390 cERROR(1, "%s: Invalid uid value",
1392 goto cifs_parse_mount_err;
1394 vol->linux_uid = option;
1395 uid_specified = true;
1398 if (get_option_ul(args, &option)) {
1399 cERROR(1, "%s: Invalid cruid value",
1401 goto cifs_parse_mount_err;
1403 vol->cred_uid = option;
1406 if (get_option_ul(args, &option)) {
1407 cERROR(1, "%s: Invalid gid value",
1409 goto cifs_parse_mount_err;
1411 vol->linux_gid = option;
1412 gid_specified = true;
1415 if (get_option_ul(args, &option)) {
1416 cERROR(1, "%s: Invalid file_mode value",
1418 goto cifs_parse_mount_err;
1420 vol->file_mode = option;
1423 if (get_option_ul(args, &option)) {
1424 cERROR(1, "%s: Invalid dir_mode value",
1426 goto cifs_parse_mount_err;
1428 vol->dir_mode = option;
1431 if (get_option_ul(args, &option) ||
1432 option > USHRT_MAX) {
1433 cERROR(1, "%s: Invalid port value", __func__);
1434 goto cifs_parse_mount_err;
1436 port = (unsigned short)option;
1439 if (get_option_ul(args, &option)) {
1440 cERROR(1, "%s: Invalid rsize value",
1442 goto cifs_parse_mount_err;
1444 vol->rsize = option;
1447 if (get_option_ul(args, &option)) {
1448 cERROR(1, "%s: Invalid wsize value",
1450 goto cifs_parse_mount_err;
1452 vol->wsize = option;
1455 if (get_option_ul(args, &option)) {
1456 cERROR(1, "%s: Invalid actimeo value",
1458 goto cifs_parse_mount_err;
1460 vol->actimeo = HZ * option;
1461 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1462 cERROR(1, "CIFS: attribute cache"
1463 "timeout too large");
1464 goto cifs_parse_mount_err;
1468 /* String Arguments */
1470 case Opt_blank_user:
1471 /* null user, ie. anonymous authentication */
1473 vol->username = NULL;
1476 string = match_strdup(args);
1480 if (strnlen(string, MAX_USERNAME_SIZE) >
1481 MAX_USERNAME_SIZE) {
1482 printk(KERN_WARNING "CIFS: username too long\n");
1483 goto cifs_parse_mount_err;
1485 vol->username = kstrdup(string, GFP_KERNEL);
1486 if (!vol->username) {
1487 printk(KERN_WARNING "CIFS: no memory "
1489 goto cifs_parse_mount_err;
1492 case Opt_blank_pass:
1493 vol->password = NULL;
1496 /* passwords have to be handled differently
1497 * to allow the character used for deliminator
1498 * to be passed within them
1501 /* Obtain the value string */
1502 value = strchr(data, '=');
1505 /* Set tmp_end to end of the string */
1506 tmp_end = (char *) value + strlen(value);
1508 /* Check if following character is the deliminator
1509 * If yes, we have encountered a double deliminator
1510 * reset the NULL character to the deliminator
1512 if (tmp_end < end && tmp_end[1] == delim) {
1515 /* Keep iterating until we get to a single
1516 * deliminator OR the end
1518 while ((tmp_end = strchr(tmp_end, delim))
1519 != NULL && (tmp_end[1] == delim)) {
1520 tmp_end = (char *) &tmp_end[2];
1523 /* Reset var options to point to next element */
1526 options = (char *) &tmp_end[1];
1528 /* Reached the end of the mount option
1533 /* Now build new password string */
1534 temp_len = strlen(value);
1535 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1536 if (vol->password == NULL) {
1537 printk(KERN_WARNING "CIFS: no memory "
1539 goto cifs_parse_mount_err;
1542 for (i = 0, j = 0; i < temp_len; i++, j++) {
1543 vol->password[j] = value[i];
1544 if ((value[i] == delim) &&
1545 value[i+1] == delim)
1546 /* skip the second deliminator */
1549 vol->password[j] = '\0';
1552 /* FIXME: should this be an error instead? */
1556 string = match_strdup(args);
1560 if (!cifs_convert_address(dstaddr, string,
1562 printk(KERN_ERR "CIFS: bad ip= option (%s).\n",
1564 goto cifs_parse_mount_err;
1569 string = match_strdup(args);
1573 temp_len = strnlen(string, 300);
1574 if (temp_len == 300) {
1575 printk(KERN_WARNING "CIFS: UNC name too long\n");
1576 goto cifs_parse_mount_err;
1579 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1580 if (vol->UNC == NULL) {
1581 printk(KERN_WARNING "CIFS: no memory for UNC\n");
1582 goto cifs_parse_mount_err;
1584 strcpy(vol->UNC, string);
1586 if (strncmp(string, "//", 2) == 0) {
1589 } else if (strncmp(string, "\\\\", 2) != 0) {
1590 printk(KERN_WARNING "CIFS: UNC Path does not "
1591 "begin with // or \\\\\n");
1592 goto cifs_parse_mount_err;
1597 string = match_strdup(args);
1601 if (strnlen(string, 256) == 256) {
1602 printk(KERN_WARNING "CIFS: domain name too"
1604 goto cifs_parse_mount_err;
1607 vol->domainname = kstrdup(string, GFP_KERNEL);
1608 if (!vol->domainname) {
1609 printk(KERN_WARNING "CIFS: no memory "
1610 "for domainname\n");
1611 goto cifs_parse_mount_err;
1613 cFYI(1, "Domain name set");
1616 string = match_strdup(args);
1620 if (!cifs_convert_address(
1621 (struct sockaddr *)&vol->srcaddr,
1622 string, strlen(string))) {
1623 printk(KERN_WARNING "CIFS: Could not parse"
1624 " srcaddr: %s\n", string);
1625 goto cifs_parse_mount_err;
1628 case Opt_prefixpath:
1629 string = match_strdup(args);
1633 temp_len = strnlen(string, 1024);
1634 if (string[0] != '/')
1635 temp_len++; /* missing leading slash */
1636 if (temp_len > 1024) {
1637 printk(KERN_WARNING "CIFS: prefix too long\n");
1638 goto cifs_parse_mount_err;
1641 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1642 if (vol->prepath == NULL) {
1643 printk(KERN_WARNING "CIFS: no memory "
1644 "for path prefix\n");
1645 goto cifs_parse_mount_err;
1648 if (string[0] != '/') {
1649 vol->prepath[0] = '/';
1650 strcpy(vol->prepath+1, string);
1652 strcpy(vol->prepath, string);
1656 string = match_strdup(args);
1660 if (strnlen(string, 1024) >= 65) {
1661 printk(KERN_WARNING "CIFS: iocharset name "
1663 goto cifs_parse_mount_err;
1666 if (strnicmp(string, "default", 7) != 0) {
1667 vol->iocharset = kstrdup(string,
1669 if (!vol->iocharset) {
1670 printk(KERN_WARNING "CIFS: no memory"
1672 goto cifs_parse_mount_err;
1675 /* if iocharset not set then load_nls_default
1678 cFYI(1, "iocharset set to %s", string);
1681 string = match_strdup(args);
1685 if (strnicmp(string, "TCP_NODELAY", 11) == 0) {
1686 printk(KERN_WARNING "CIFS: the "
1687 "sockopt=TCP_NODELAY option has been "
1688 "deprecated and will be removed "
1690 vol->sockopt_tcp_nodelay = 1;
1693 case Opt_netbiosname:
1694 string = match_strdup(args);
1698 memset(vol->source_rfc1001_name, 0x20,
1701 * FIXME: are there cases in which a comma can
1702 * be valid in workstation netbios name (and
1703 * need special handling)?
1705 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1706 /* don't ucase netbiosname for user */
1709 vol->source_rfc1001_name[i] = string[i];
1711 /* The string has 16th byte zero still from
1712 * set at top of the function
1714 if (i == RFC1001_NAME_LEN && string[i] != 0)
1715 printk(KERN_WARNING "CIFS: netbiosname"
1716 " longer than 15 truncated.\n");
1720 /* servernetbiosname specified override *SMBSERVER */
1721 string = match_strdup(args);
1725 /* last byte, type, is 0x20 for servr type */
1726 memset(vol->target_rfc1001_name, 0x20,
1727 RFC1001_NAME_LEN_WITH_NULL);
1729 /* BB are there cases in which a comma can be
1730 valid in this workstation netbios name
1731 (and need special handling)? */
1733 /* user or mount helper must uppercase the
1735 for (i = 0; i < 15; i++) {
1738 vol->target_rfc1001_name[i] = string[i];
1740 /* The string has 16th byte zero still from
1741 set at top of the function */
1742 if (i == RFC1001_NAME_LEN && string[i] != 0)
1743 printk(KERN_WARNING "CIFS: server net"
1744 "biosname longer than 15 truncated.\n");
1747 string = match_strdup(args);
1751 if (strnicmp(string, "1", 1) == 0) {
1752 /* This is the default */
1755 /* For all other value, error */
1756 printk(KERN_WARNING "CIFS: Invalid version"
1758 goto cifs_parse_mount_err;
1760 string = match_strdup(args);
1764 if (cifs_parse_smb_version(string, vol) != 0)
1765 goto cifs_parse_mount_err;
1768 string = match_strdup(args);
1772 if (cifs_parse_security_flavors(string, vol) != 0)
1773 goto cifs_parse_mount_err;
1776 string = match_strdup(args);
1780 if (cifs_parse_cache_flavor(string, vol) != 0)
1781 goto cifs_parse_mount_err;
1785 * An option we don't recognize. Save it off for later
1786 * if we haven't already found one
1792 /* Free up any allocated string */
1797 if (!sloppy && invalid) {
1798 printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
1799 goto cifs_parse_mount_err;
1803 /* Muliuser mounts require CONFIG_KEYS support */
1804 if (vol->multiuser) {
1805 cERROR(1, "Multiuser mounts require kernels with "
1806 "CONFIG_KEYS enabled.");
1807 goto cifs_parse_mount_err;
1811 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1812 "unc=\\\\192.168.1.100\\public) specified");
1813 goto cifs_parse_mount_err;
1817 /* No ip= option specified? Try to get it from UNC */
1818 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1819 strlen(&vol->UNC[2]))) {
1820 printk(KERN_ERR "Unable to determine destination "
1822 goto cifs_parse_mount_err;
1826 /* set the port that we got earlier */
1827 cifs_set_port(dstaddr, port);
1830 vol->override_uid = override_uid;
1831 else if (override_uid == 1)
1832 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1833 "specified with no uid= option.\n");
1836 vol->override_gid = override_gid;
1837 else if (override_gid == 1)
1838 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1839 "specified with no gid= option.\n");
1841 kfree(mountdata_copy);
1845 printk(KERN_WARNING "Could not allocate temporary buffer\n");
1846 cifs_parse_mount_err:
1848 kfree(mountdata_copy);
1852 /** Returns true if srcaddr isn't specified and rhs isn't
1853 * specified, or if srcaddr is specified and
1854 * matches the IP address of the rhs argument.
1857 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1859 switch (srcaddr->sa_family) {
1861 return (rhs->sa_family == AF_UNSPEC);
1863 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1864 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1865 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1868 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1869 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1870 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1874 return false; /* don't expect to be here */
1879 * If no port is specified in addr structure, we try to match with 445 port
1880 * and if it fails - with 139 ports. It should be called only if address
1881 * families of server and addr are equal.
1884 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1886 __be16 port, *sport;
1888 switch (addr->sa_family) {
1890 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1891 port = ((struct sockaddr_in *) addr)->sin_port;
1894 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1895 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1903 port = htons(CIFS_PORT);
1907 port = htons(RFC1001_PORT);
1910 return port == *sport;
1914 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1915 struct sockaddr *srcaddr)
1917 switch (addr->sa_family) {
1919 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1920 struct sockaddr_in *srv_addr4 =
1921 (struct sockaddr_in *)&server->dstaddr;
1923 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1928 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1929 struct sockaddr_in6 *srv_addr6 =
1930 (struct sockaddr_in6 *)&server->dstaddr;
1932 if (!ipv6_addr_equal(&addr6->sin6_addr,
1933 &srv_addr6->sin6_addr))
1935 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1941 return false; /* don't expect to be here */
1944 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1951 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1953 unsigned int secFlags;
1955 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1956 secFlags = vol->secFlg;
1958 secFlags = global_secflags | vol->secFlg;
1960 switch (server->secType) {
1962 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1966 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1970 if (!(secFlags & CIFSSEC_MAY_NTLM))
1974 if (!(secFlags & CIFSSEC_MAY_KRB5))
1978 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1982 /* shouldn't happen */
1986 /* now check if signing mode is acceptable */
1987 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1988 (server->sec_mode & SECMODE_SIGN_REQUIRED))
1990 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1992 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1998 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2000 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2002 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2005 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2008 if (!match_address(server, addr,
2009 (struct sockaddr *)&vol->srcaddr))
2012 if (!match_port(server, addr))
2015 if (!match_security(server, vol))
2021 static struct TCP_Server_Info *
2022 cifs_find_tcp_session(struct smb_vol *vol)
2024 struct TCP_Server_Info *server;
2026 spin_lock(&cifs_tcp_ses_lock);
2027 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2028 if (!match_server(server, vol))
2031 ++server->srv_count;
2032 spin_unlock(&cifs_tcp_ses_lock);
2033 cFYI(1, "Existing tcp session with server found");
2036 spin_unlock(&cifs_tcp_ses_lock);
2041 cifs_put_tcp_session(struct TCP_Server_Info *server)
2043 struct task_struct *task;
2045 spin_lock(&cifs_tcp_ses_lock);
2046 if (--server->srv_count > 0) {
2047 spin_unlock(&cifs_tcp_ses_lock);
2051 put_net(cifs_net_ns(server));
2053 list_del_init(&server->tcp_ses_list);
2054 spin_unlock(&cifs_tcp_ses_lock);
2056 cancel_delayed_work_sync(&server->echo);
2058 spin_lock(&GlobalMid_Lock);
2059 server->tcpStatus = CifsExiting;
2060 spin_unlock(&GlobalMid_Lock);
2062 cifs_crypto_shash_release(server);
2063 cifs_fscache_release_client_cookie(server);
2065 kfree(server->session_key.response);
2066 server->session_key.response = NULL;
2067 server->session_key.len = 0;
2069 task = xchg(&server->tsk, NULL);
2071 force_sig(SIGKILL, task);
2074 static struct TCP_Server_Info *
2075 cifs_get_tcp_session(struct smb_vol *volume_info)
2077 struct TCP_Server_Info *tcp_ses = NULL;
2080 cFYI(1, "UNC: %s", volume_info->UNC);
2082 /* see if we already have a matching tcp_ses */
2083 tcp_ses = cifs_find_tcp_session(volume_info);
2087 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2093 rc = cifs_crypto_shash_allocate(tcp_ses);
2095 cERROR(1, "could not setup hash structures rc %d", rc);
2099 tcp_ses->ops = volume_info->ops;
2100 tcp_ses->vals = volume_info->vals;
2101 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2102 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2103 if (IS_ERR(tcp_ses->hostname)) {
2104 rc = PTR_ERR(tcp_ses->hostname);
2105 goto out_err_crypto_release;
2108 tcp_ses->noblocksnd = volume_info->noblocksnd;
2109 tcp_ses->noautotune = volume_info->noautotune;
2110 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2111 tcp_ses->in_flight = 0;
2112 tcp_ses->credits = 1;
2113 init_waitqueue_head(&tcp_ses->response_q);
2114 init_waitqueue_head(&tcp_ses->request_q);
2115 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2116 mutex_init(&tcp_ses->srv_mutex);
2117 memcpy(tcp_ses->workstation_RFC1001_name,
2118 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2119 memcpy(tcp_ses->server_RFC1001_name,
2120 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2121 tcp_ses->session_estab = false;
2122 tcp_ses->sequence_number = 0;
2123 tcp_ses->lstrp = jiffies;
2124 spin_lock_init(&tcp_ses->req_lock);
2125 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2126 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2127 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2128 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2129 sizeof(tcp_ses->srcaddr));
2130 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2131 sizeof(tcp_ses->dstaddr));
2133 * at this point we are the only ones with the pointer
2134 * to the struct since the kernel thread not created yet
2135 * no need to spinlock this init of tcpStatus or srv_count
2137 tcp_ses->tcpStatus = CifsNew;
2138 ++tcp_ses->srv_count;
2140 rc = ip_connect(tcp_ses);
2142 cERROR(1, "Error connecting to socket. Aborting operation");
2143 goto out_err_crypto_release;
2147 * since we're in a cifs function already, we know that
2148 * this will succeed. No need for try_module_get().
2150 __module_get(THIS_MODULE);
2151 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2153 if (IS_ERR(tcp_ses->tsk)) {
2154 rc = PTR_ERR(tcp_ses->tsk);
2155 cERROR(1, "error %d create cifsd thread", rc);
2156 module_put(THIS_MODULE);
2157 goto out_err_crypto_release;
2159 tcp_ses->tcpStatus = CifsNeedNegotiate;
2161 /* thread spawned, put it on the list */
2162 spin_lock(&cifs_tcp_ses_lock);
2163 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2164 spin_unlock(&cifs_tcp_ses_lock);
2166 cifs_fscache_get_client_cookie(tcp_ses);
2168 /* queue echo request delayed work */
2169 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2173 out_err_crypto_release:
2174 cifs_crypto_shash_release(tcp_ses);
2176 put_net(cifs_net_ns(tcp_ses));
2180 if (!IS_ERR(tcp_ses->hostname))
2181 kfree(tcp_ses->hostname);
2182 if (tcp_ses->ssocket)
2183 sock_release(tcp_ses->ssocket);
2189 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2191 switch (ses->server->secType) {
2193 if (vol->cred_uid != ses->cred_uid)
2197 /* NULL username means anonymous session */
2198 if (ses->user_name == NULL) {
2204 /* anything else takes username/password */
2205 if (strncmp(ses->user_name,
2206 vol->username ? vol->username : "",
2209 if (strlen(vol->username) != 0 &&
2210 ses->password != NULL &&
2211 strncmp(ses->password,
2212 vol->password ? vol->password : "",
2219 static struct cifs_ses *
2220 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2222 struct cifs_ses *ses;
2224 spin_lock(&cifs_tcp_ses_lock);
2225 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2226 if (!match_session(ses, vol))
2229 spin_unlock(&cifs_tcp_ses_lock);
2232 spin_unlock(&cifs_tcp_ses_lock);
2237 cifs_put_smb_ses(struct cifs_ses *ses)
2240 struct TCP_Server_Info *server = ses->server;
2242 cFYI(1, "%s: ses_count=%d", __func__, ses->ses_count);
2243 spin_lock(&cifs_tcp_ses_lock);
2244 if (--ses->ses_count > 0) {
2245 spin_unlock(&cifs_tcp_ses_lock);
2249 list_del_init(&ses->smb_ses_list);
2250 spin_unlock(&cifs_tcp_ses_lock);
2252 if (ses->status == CifsGood && server->ops->logoff) {
2254 server->ops->logoff(xid, ses);
2258 cifs_put_tcp_session(server);
2263 /* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2264 #define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2266 /* Populate username and pw fields from keyring if possible */
2268 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2271 char *desc, *delim, *payload;
2274 struct TCP_Server_Info *server = ses->server;
2275 struct sockaddr_in *sa;
2276 struct sockaddr_in6 *sa6;
2277 struct user_key_payload *upayload;
2279 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2283 /* try to find an address key first */
2284 switch (server->dstaddr.ss_family) {
2286 sa = (struct sockaddr_in *)&server->dstaddr;
2287 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2290 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2291 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2294 cFYI(1, "Bad ss_family (%hu)", server->dstaddr.ss_family);
2299 cFYI(1, "%s: desc=%s", __func__, desc);
2300 key = request_key(&key_type_logon, desc, "");
2302 if (!ses->domainName) {
2303 cFYI(1, "domainName is NULL");
2308 /* didn't work, try to find a domain key */
2309 sprintf(desc, "cifs:d:%s", ses->domainName);
2310 cFYI(1, "%s: desc=%s", __func__, desc);
2311 key = request_key(&key_type_logon, desc, "");
2318 down_read(&key->sem);
2319 upayload = key->payload.data;
2320 if (IS_ERR_OR_NULL(upayload)) {
2321 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2325 /* find first : in payload */
2326 payload = (char *)upayload->data;
2327 delim = strnchr(payload, upayload->datalen, ':');
2328 cFYI(1, "payload=%s", payload);
2330 cFYI(1, "Unable to find ':' in payload (datalen=%d)",
2336 len = delim - payload;
2337 if (len > MAX_USERNAME_SIZE || len <= 0) {
2338 cFYI(1, "Bad value from username search (len=%zd)", len);
2343 vol->username = kstrndup(payload, len, GFP_KERNEL);
2344 if (!vol->username) {
2345 cFYI(1, "Unable to allocate %zd bytes for username", len);
2349 cFYI(1, "%s: username=%s", __func__, vol->username);
2351 len = key->datalen - (len + 1);
2352 if (len > MAX_PASSWORD_SIZE || len <= 0) {
2353 cFYI(1, "Bad len for password search (len=%zd)", len);
2355 kfree(vol->username);
2356 vol->username = NULL;
2361 vol->password = kstrndup(delim, len, GFP_KERNEL);
2362 if (!vol->password) {
2363 cFYI(1, "Unable to allocate %zd bytes for password", len);
2365 kfree(vol->username);
2366 vol->username = NULL;
2375 cFYI(1, "%s: returning %d", __func__, rc);
2378 #else /* ! CONFIG_KEYS */
2380 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2381 struct cifs_ses *ses __attribute__((unused)))
2385 #endif /* CONFIG_KEYS */
2387 static struct cifs_ses *
2388 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2392 struct cifs_ses *ses;
2393 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2394 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2398 ses = cifs_find_smb_ses(server, volume_info);
2400 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
2402 mutex_lock(&ses->session_mutex);
2403 rc = cifs_negotiate_protocol(xid, ses);
2405 mutex_unlock(&ses->session_mutex);
2406 /* problem -- put our ses reference */
2407 cifs_put_smb_ses(ses);
2411 if (ses->need_reconnect) {
2412 cFYI(1, "Session needs reconnect");
2413 rc = cifs_setup_session(xid, ses,
2414 volume_info->local_nls);
2416 mutex_unlock(&ses->session_mutex);
2417 /* problem -- put our reference */
2418 cifs_put_smb_ses(ses);
2423 mutex_unlock(&ses->session_mutex);
2425 /* existing SMB ses has a server reference already */
2426 cifs_put_tcp_session(server);
2431 cFYI(1, "Existing smb sess not found");
2432 ses = sesInfoAlloc();
2436 /* new SMB session uses our server ref */
2437 ses->server = server;
2438 if (server->dstaddr.ss_family == AF_INET6)
2439 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2441 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2443 if (volume_info->username) {
2444 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2445 if (!ses->user_name)
2449 /* volume_info->password freed at unmount */
2450 if (volume_info->password) {
2451 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2455 if (volume_info->domainname) {
2456 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2457 if (!ses->domainName)
2460 ses->cred_uid = volume_info->cred_uid;
2461 ses->linux_uid = volume_info->linux_uid;
2463 ses->overrideSecFlg = volume_info->secFlg;
2465 mutex_lock(&ses->session_mutex);
2466 rc = cifs_negotiate_protocol(xid, ses);
2468 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2469 mutex_unlock(&ses->session_mutex);
2473 /* success, put it on the list */
2474 spin_lock(&cifs_tcp_ses_lock);
2475 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2476 spin_unlock(&cifs_tcp_ses_lock);
2487 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2489 if (tcon->tidStatus == CifsExiting)
2491 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2496 static struct cifs_tcon *
2497 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2499 struct list_head *tmp;
2500 struct cifs_tcon *tcon;
2502 spin_lock(&cifs_tcp_ses_lock);
2503 list_for_each(tmp, &ses->tcon_list) {
2504 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2505 if (!match_tcon(tcon, unc))
2508 spin_unlock(&cifs_tcp_ses_lock);
2511 spin_unlock(&cifs_tcp_ses_lock);
2516 cifs_put_tcon(struct cifs_tcon *tcon)
2519 struct cifs_ses *ses = tcon->ses;
2521 cFYI(1, "%s: tc_count=%d", __func__, tcon->tc_count);
2522 spin_lock(&cifs_tcp_ses_lock);
2523 if (--tcon->tc_count > 0) {
2524 spin_unlock(&cifs_tcp_ses_lock);
2528 list_del_init(&tcon->tcon_list);
2529 spin_unlock(&cifs_tcp_ses_lock);
2532 if (ses->server->ops->tree_disconnect)
2533 ses->server->ops->tree_disconnect(xid, tcon);
2536 cifs_fscache_release_super_cookie(tcon);
2538 cifs_put_smb_ses(ses);
2541 static struct cifs_tcon *
2542 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2545 struct cifs_tcon *tcon;
2547 tcon = cifs_find_tcon(ses, volume_info->UNC);
2549 cFYI(1, "Found match on UNC path");
2550 /* existing tcon already has a reference */
2551 cifs_put_smb_ses(ses);
2552 if (tcon->seal != volume_info->seal)
2553 cERROR(1, "transport encryption setting "
2554 "conflicts with existing tid");
2558 if (!ses->server->ops->tree_connect) {
2563 tcon = tconInfoAlloc();
2570 if (volume_info->password) {
2571 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2572 if (!tcon->password) {
2578 if (strchr(volume_info->UNC + 3, '\\') == NULL
2579 && strchr(volume_info->UNC + 3, '/') == NULL) {
2580 cERROR(1, "Missing share name");
2586 * BB Do we need to wrap session_mutex around this TCon call and Unix
2587 * SetFS as we do on SessSetup and reconnect?
2590 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2591 volume_info->local_nls);
2593 cFYI(1, "Tcon rc = %d", rc);
2597 if (volume_info->nodfs) {
2598 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2599 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2601 tcon->seal = volume_info->seal;
2603 * We can have only one retry value for a connection to a share so for
2604 * resources mounted more than once to the same server share the last
2605 * value passed in for the retry flag is used.
2607 tcon->retry = volume_info->retry;
2608 tcon->nocase = volume_info->nocase;
2609 tcon->local_lease = volume_info->local_lease;
2610 INIT_LIST_HEAD(&tcon->pending_opens);
2612 spin_lock(&cifs_tcp_ses_lock);
2613 list_add(&tcon->tcon_list, &ses->tcon_list);
2614 spin_unlock(&cifs_tcp_ses_lock);
2616 cifs_fscache_get_super_cookie(tcon);
2626 cifs_put_tlink(struct tcon_link *tlink)
2628 if (!tlink || IS_ERR(tlink))
2631 if (!atomic_dec_and_test(&tlink->tl_count) ||
2632 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2633 tlink->tl_time = jiffies;
2637 if (!IS_ERR(tlink_tcon(tlink)))
2638 cifs_put_tcon(tlink_tcon(tlink));
2643 static inline struct tcon_link *
2644 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2646 return cifs_sb->master_tlink;
2650 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2652 struct cifs_sb_info *old = CIFS_SB(sb);
2653 struct cifs_sb_info *new = mnt_data->cifs_sb;
2655 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2658 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2659 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2663 * We want to share sb only if we don't specify an r/wsize or
2664 * specified r/wsize is greater than or equal to existing one.
2666 if (new->wsize && new->wsize < old->wsize)
2669 if (new->rsize && new->rsize < old->rsize)
2672 if (old->mnt_uid != new->mnt_uid || old->mnt_gid != new->mnt_gid)
2675 if (old->mnt_file_mode != new->mnt_file_mode ||
2676 old->mnt_dir_mode != new->mnt_dir_mode)
2679 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2682 if (old->actimeo != new->actimeo)
2689 cifs_match_super(struct super_block *sb, void *data)
2691 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2692 struct smb_vol *volume_info;
2693 struct cifs_sb_info *cifs_sb;
2694 struct TCP_Server_Info *tcp_srv;
2695 struct cifs_ses *ses;
2696 struct cifs_tcon *tcon;
2697 struct tcon_link *tlink;
2700 spin_lock(&cifs_tcp_ses_lock);
2701 cifs_sb = CIFS_SB(sb);
2702 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2703 if (IS_ERR(tlink)) {
2704 spin_unlock(&cifs_tcp_ses_lock);
2707 tcon = tlink_tcon(tlink);
2709 tcp_srv = ses->server;
2711 volume_info = mnt_data->vol;
2713 if (!match_server(tcp_srv, volume_info) ||
2714 !match_session(ses, volume_info) ||
2715 !match_tcon(tcon, volume_info->UNC)) {
2720 rc = compare_mount_options(sb, mnt_data);
2722 spin_unlock(&cifs_tcp_ses_lock);
2723 cifs_put_tlink(tlink);
2728 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2729 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2730 struct dfs_info3_param **referrals, int remap)
2735 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2741 if (ses->ipc_tid == 0) {
2742 temp_unc = kmalloc(2 /* for slashes */ +
2743 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2744 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2745 if (temp_unc == NULL)
2749 strcpy(temp_unc + 2, ses->serverName);
2750 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2751 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2753 cFYI(1, "Tcon rc = %d ipc_tid = %d", rc, ses->ipc_tid);
2757 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2758 referrals, num_referrals,
2759 nls_codepage, remap);
2761 * BB - map targetUNCs to dfs_info3 structures, here or in
2762 * ses->server->ops->get_dfs_refer.
2768 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2769 static struct lock_class_key cifs_key[2];
2770 static struct lock_class_key cifs_slock_key[2];
2773 cifs_reclassify_socket4(struct socket *sock)
2775 struct sock *sk = sock->sk;
2776 BUG_ON(sock_owned_by_user(sk));
2777 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2778 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2782 cifs_reclassify_socket6(struct socket *sock)
2784 struct sock *sk = sock->sk;
2785 BUG_ON(sock_owned_by_user(sk));
2786 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2787 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2791 cifs_reclassify_socket4(struct socket *sock)
2796 cifs_reclassify_socket6(struct socket *sock)
2801 /* See RFC1001 section 14 on representation of Netbios names */
2802 static void rfc1002mangle(char *target, char *source, unsigned int length)
2806 for (i = 0, j = 0; i < (length); i++) {
2807 /* mask a nibble at a time and encode */
2808 target[j] = 'A' + (0x0F & (source[i] >> 4));
2809 target[j+1] = 'A' + (0x0F & source[i]);
2816 bind_socket(struct TCP_Server_Info *server)
2819 if (server->srcaddr.ss_family != AF_UNSPEC) {
2820 /* Bind to the specified local IP address */
2821 struct socket *socket = server->ssocket;
2822 rc = socket->ops->bind(socket,
2823 (struct sockaddr *) &server->srcaddr,
2824 sizeof(server->srcaddr));
2826 struct sockaddr_in *saddr4;
2827 struct sockaddr_in6 *saddr6;
2828 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2829 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2830 if (saddr6->sin6_family == AF_INET6)
2832 "Failed to bind to: %pI6c, error: %d",
2833 &saddr6->sin6_addr, rc);
2836 "Failed to bind to: %pI4, error: %d",
2837 &saddr4->sin_addr.s_addr, rc);
2844 ip_rfc1001_connect(struct TCP_Server_Info *server)
2848 * some servers require RFC1001 sessinit before sending
2849 * negprot - BB check reconnection in case where second
2850 * sessinit is sent but no second negprot
2852 struct rfc1002_session_packet *ses_init_buf;
2853 struct smb_hdr *smb_buf;
2854 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2857 ses_init_buf->trailer.session_req.called_len = 32;
2859 if (server->server_RFC1001_name &&
2860 server->server_RFC1001_name[0] != 0)
2861 rfc1002mangle(ses_init_buf->trailer.
2862 session_req.called_name,
2863 server->server_RFC1001_name,
2864 RFC1001_NAME_LEN_WITH_NULL);
2866 rfc1002mangle(ses_init_buf->trailer.
2867 session_req.called_name,
2868 DEFAULT_CIFS_CALLED_NAME,
2869 RFC1001_NAME_LEN_WITH_NULL);
2871 ses_init_buf->trailer.session_req.calling_len = 32;
2874 * calling name ends in null (byte 16) from old smb
2877 if (server->workstation_RFC1001_name &&
2878 server->workstation_RFC1001_name[0] != 0)
2879 rfc1002mangle(ses_init_buf->trailer.
2880 session_req.calling_name,
2881 server->workstation_RFC1001_name,
2882 RFC1001_NAME_LEN_WITH_NULL);
2884 rfc1002mangle(ses_init_buf->trailer.
2885 session_req.calling_name,
2887 RFC1001_NAME_LEN_WITH_NULL);
2889 ses_init_buf->trailer.session_req.scope1 = 0;
2890 ses_init_buf->trailer.session_req.scope2 = 0;
2891 smb_buf = (struct smb_hdr *)ses_init_buf;
2893 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2894 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2895 rc = smb_send(server, smb_buf, 0x44);
2896 kfree(ses_init_buf);
2898 * RFC1001 layer in at least one server
2899 * requires very short break before negprot
2900 * presumably because not expecting negprot
2901 * to follow so fast. This is a simple
2902 * solution that works without
2903 * complicating the code and causes no
2904 * significant slowing down on mount
2907 usleep_range(1000, 2000);
2910 * else the negprot may still work without this
2911 * even though malloc failed
2918 generic_ip_connect(struct TCP_Server_Info *server)
2923 struct socket *socket = server->ssocket;
2924 struct sockaddr *saddr;
2926 saddr = (struct sockaddr *) &server->dstaddr;
2928 if (server->dstaddr.ss_family == AF_INET6) {
2929 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2930 slen = sizeof(struct sockaddr_in6);
2933 sport = ((struct sockaddr_in *) saddr)->sin_port;
2934 slen = sizeof(struct sockaddr_in);
2938 if (socket == NULL) {
2939 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2940 IPPROTO_TCP, &socket, 1);
2942 cERROR(1, "Error %d creating socket", rc);
2943 server->ssocket = NULL;
2947 /* BB other socket options to set KEEPALIVE, NODELAY? */
2948 cFYI(1, "Socket created");
2949 server->ssocket = socket;
2950 socket->sk->sk_allocation = GFP_NOFS;
2951 if (sfamily == AF_INET6)
2952 cifs_reclassify_socket6(socket);
2954 cifs_reclassify_socket4(socket);
2957 rc = bind_socket(server);
2962 * Eventually check for other socket options to change from
2963 * the default. sock_setsockopt not used because it expects
2966 socket->sk->sk_rcvtimeo = 7 * HZ;
2967 socket->sk->sk_sndtimeo = 5 * HZ;
2969 /* make the bufsizes depend on wsize/rsize and max requests */
2970 if (server->noautotune) {
2971 if (socket->sk->sk_sndbuf < (200 * 1024))
2972 socket->sk->sk_sndbuf = 200 * 1024;
2973 if (socket->sk->sk_rcvbuf < (140 * 1024))
2974 socket->sk->sk_rcvbuf = 140 * 1024;
2977 if (server->tcp_nodelay) {
2979 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2980 (char *)&val, sizeof(val));
2982 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2985 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2986 socket->sk->sk_sndbuf,
2987 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2989 rc = socket->ops->connect(socket, saddr, slen, 0);
2991 cFYI(1, "Error %d connecting to server", rc);
2992 sock_release(socket);
2993 server->ssocket = NULL;
2997 if (sport == htons(RFC1001_PORT))
2998 rc = ip_rfc1001_connect(server);
3004 ip_connect(struct TCP_Server_Info *server)
3007 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3008 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3010 if (server->dstaddr.ss_family == AF_INET6)
3011 sport = &addr6->sin6_port;
3013 sport = &addr->sin_port;
3018 /* try with 445 port at first */
3019 *sport = htons(CIFS_PORT);
3021 rc = generic_ip_connect(server);
3025 /* if it failed, try with 139 port */
3026 *sport = htons(RFC1001_PORT);
3029 return generic_ip_connect(server);
3032 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3033 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3035 /* if we are reconnecting then should we check to see if
3036 * any requested capabilities changed locally e.g. via
3037 * remount but we can not do much about it here
3038 * if they have (even if we could detect it by the following)
3039 * Perhaps we could add a backpointer to array of sb from tcon
3040 * or if we change to make all sb to same share the same
3041 * sb as NFS - then we only have one backpointer to sb.
3042 * What if we wanted to mount the server share twice once with
3043 * and once without posixacls or posix paths? */
3044 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3046 if (vol_info && vol_info->no_linux_ext) {
3047 tcon->fsUnixInfo.Capability = 0;
3048 tcon->unix_ext = 0; /* Unix Extensions disabled */
3049 cFYI(1, "Linux protocol extensions disabled");
3051 } else if (vol_info)
3052 tcon->unix_ext = 1; /* Unix Extensions supported */
3054 if (tcon->unix_ext == 0) {
3055 cFYI(1, "Unix extensions disabled so not set on reconnect");
3059 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3060 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3061 cFYI(1, "unix caps which server supports %lld", cap);
3062 /* check for reconnect case in which we do not
3063 want to change the mount behavior if we can avoid it */
3064 if (vol_info == NULL) {
3065 /* turn off POSIX ACL and PATHNAMES if not set
3066 originally at mount time */
3067 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3068 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3069 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3070 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3071 cERROR(1, "POSIXPATH support change");
3072 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3073 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3074 cERROR(1, "possible reconnect error");
3075 cERROR(1, "server disabled POSIX path support");
3079 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3080 cERROR(1, "per-share encryption not supported yet");
3082 cap &= CIFS_UNIX_CAP_MASK;
3083 if (vol_info && vol_info->no_psx_acl)
3084 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3085 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3086 cFYI(1, "negotiated posix acl support");
3088 cifs_sb->mnt_cifs_flags |=
3089 CIFS_MOUNT_POSIXACL;
3092 if (vol_info && vol_info->posix_paths == 0)
3093 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3094 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3095 cFYI(1, "negotiate posix pathnames");
3097 cifs_sb->mnt_cifs_flags |=
3098 CIFS_MOUNT_POSIX_PATHS;
3101 cFYI(1, "Negotiate caps 0x%x", (int)cap);
3102 #ifdef CONFIG_CIFS_DEBUG2
3103 if (cap & CIFS_UNIX_FCNTL_CAP)
3104 cFYI(1, "FCNTL cap");
3105 if (cap & CIFS_UNIX_EXTATTR_CAP)
3106 cFYI(1, "EXTATTR cap");
3107 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3108 cFYI(1, "POSIX path cap");
3109 if (cap & CIFS_UNIX_XATTR_CAP)
3110 cFYI(1, "XATTR cap");
3111 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3112 cFYI(1, "POSIX ACL cap");
3113 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3114 cFYI(1, "very large read cap");
3115 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3116 cFYI(1, "very large write cap");
3117 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3118 cFYI(1, "transport encryption cap");
3119 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3120 cFYI(1, "mandatory transport encryption cap");
3121 #endif /* CIFS_DEBUG2 */
3122 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3123 if (vol_info == NULL) {
3124 cFYI(1, "resetting capabilities failed");
3126 cERROR(1, "Negotiating Unix capabilities "
3127 "with the server failed. Consider "
3128 "mounting with the Unix Extensions "
3129 "disabled if problems are found "
3130 "by specifying the nounix mount "
3137 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3138 struct cifs_sb_info *cifs_sb)
3140 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3142 spin_lock_init(&cifs_sb->tlink_tree_lock);
3143 cifs_sb->tlink_tree = RB_ROOT;
3146 * Temporarily set r/wsize for matching superblock. If we end up using
3147 * new sb then client will later negotiate it downward if needed.
3149 cifs_sb->rsize = pvolume_info->rsize;
3150 cifs_sb->wsize = pvolume_info->wsize;
3152 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3153 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3154 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3155 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3156 cFYI(1, "file mode: 0x%hx dir mode: 0x%hx",
3157 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3159 cifs_sb->actimeo = pvolume_info->actimeo;
3160 cifs_sb->local_nls = pvolume_info->local_nls;
3162 if (pvolume_info->noperm)
3163 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3164 if (pvolume_info->setuids)
3165 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3166 if (pvolume_info->server_ino)
3167 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3168 if (pvolume_info->remap)
3169 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3170 if (pvolume_info->no_xattr)
3171 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3172 if (pvolume_info->sfu_emul)
3173 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3174 if (pvolume_info->nobrl)
3175 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3176 if (pvolume_info->nostrictsync)
3177 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3178 if (pvolume_info->mand_lock)
3179 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3180 if (pvolume_info->rwpidforward)
3181 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3182 if (pvolume_info->cifs_acl)
3183 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3184 if (pvolume_info->backupuid_specified) {
3185 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3186 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3188 if (pvolume_info->backupgid_specified) {
3189 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3190 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3192 if (pvolume_info->override_uid)
3193 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3194 if (pvolume_info->override_gid)
3195 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3196 if (pvolume_info->dynperm)
3197 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3198 if (pvolume_info->fsc)
3199 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3200 if (pvolume_info->multiuser)
3201 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3202 CIFS_MOUNT_NO_PERM);
3203 if (pvolume_info->strict_io)
3204 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3205 if (pvolume_info->direct_io) {
3206 cFYI(1, "mounting share using direct i/o");
3207 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3209 if (pvolume_info->mfsymlinks) {
3210 if (pvolume_info->sfu_emul) {
3211 cERROR(1, "mount option mfsymlinks ignored if sfu "
3212 "mount option is used");
3214 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3218 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3219 cERROR(1, "mount option dynperm ignored if cifsacl "
3220 "mount option supported");
3224 cleanup_volume_info_contents(struct smb_vol *volume_info)
3226 kfree(volume_info->username);
3227 kzfree(volume_info->password);
3228 kfree(volume_info->UNC);
3229 kfree(volume_info->domainname);
3230 kfree(volume_info->iocharset);
3231 kfree(volume_info->prepath);
3235 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3239 cleanup_volume_info_contents(volume_info);
3244 #ifdef CONFIG_CIFS_DFS_UPCALL
3246 * cifs_build_path_to_root returns full path to root when we do not have an
3247 * exiting connection (tcon)
3250 build_unc_path_to_root(const struct smb_vol *vol,
3251 const struct cifs_sb_info *cifs_sb)
3253 char *full_path, *pos;
3254 unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
3255 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3257 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3258 if (full_path == NULL)
3259 return ERR_PTR(-ENOMEM);
3261 strncpy(full_path, vol->UNC, unc_len);
3262 pos = full_path + unc_len;
3265 strncpy(pos, vol->prepath, pplen);
3269 *pos = '\0'; /* add trailing null */
3270 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3271 cFYI(1, "%s: full_path=%s", __func__, full_path);
3276 * Perform a dfs referral query for a share and (optionally) prefix
3278 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3279 * to a string containing updated options for the submount. Otherwise it
3280 * will be left untouched.
3282 * Returns the rc from get_dfs_path to the caller, which can be used to
3283 * determine whether there were referrals.
3286 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3287 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3291 unsigned int num_referrals = 0;
3292 struct dfs_info3_param *referrals = NULL;
3293 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3295 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3296 if (IS_ERR(full_path))
3297 return PTR_ERR(full_path);
3299 /* For DFS paths, skip the first '\' of the UNC */
3300 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3302 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3303 &num_referrals, &referrals,
3304 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3306 if (!rc && num_referrals > 0) {
3307 char *fake_devname = NULL;
3309 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3310 full_path + 1, referrals,
3313 free_dfs_info_array(referrals, num_referrals);
3315 if (IS_ERR(mdata)) {
3316 rc = PTR_ERR(mdata);
3319 cleanup_volume_info_contents(volume_info);
3320 rc = cifs_setup_volume_info(volume_info, mdata,
3323 kfree(fake_devname);
3324 kfree(cifs_sb->mountdata);
3325 cifs_sb->mountdata = mdata;
3333 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3334 const char *devname)
3338 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3341 if (volume_info->nullauth) {
3342 cFYI(1, "Anonymous login");
3343 kfree(volume_info->username);
3344 volume_info->username = NULL;
3345 } else if (volume_info->username) {
3346 /* BB fixme parse for domain name here */
3347 cFYI(1, "Username: %s", volume_info->username);
3349 cifserror("No username specified");
3350 /* In userspace mount helper we can get user name from alternate
3351 locations such as env variables and files on disk */
3355 /* this is needed for ASCII cp to Unicode converts */
3356 if (volume_info->iocharset == NULL) {
3357 /* load_nls_default cannot return null */
3358 volume_info->local_nls = load_nls_default();
3360 volume_info->local_nls = load_nls(volume_info->iocharset);
3361 if (volume_info->local_nls == NULL) {
3362 cERROR(1, "CIFS mount error: iocharset %s not found",
3363 volume_info->iocharset);
3372 cifs_get_volume_info(char *mount_data, const char *devname)
3375 struct smb_vol *volume_info;
3377 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3379 return ERR_PTR(-ENOMEM);
3381 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3383 cifs_cleanup_volume_info(volume_info);
3384 volume_info = ERR_PTR(rc);
3391 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3395 struct cifs_ses *ses;
3396 struct cifs_tcon *tcon;
3397 struct TCP_Server_Info *server;
3399 struct tcon_link *tlink;
3400 #ifdef CONFIG_CIFS_DFS_UPCALL
3401 int referral_walks_count = 0;
3404 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3408 #ifdef CONFIG_CIFS_DFS_UPCALL
3410 /* cleanup activities if we're chasing a referral */
3411 if (referral_walks_count) {
3413 cifs_put_tcon(tcon);
3415 cifs_put_smb_ses(ses);
3429 /* get a reference to a tcp session */
3430 server = cifs_get_tcp_session(volume_info);
3431 if (IS_ERR(server)) {
3432 rc = PTR_ERR(server);
3433 bdi_destroy(&cifs_sb->bdi);
3437 /* get a reference to a SMB session */
3438 ses = cifs_get_smb_ses(server, volume_info);
3442 goto mount_fail_check;
3445 /* search for existing tcon to this server share */
3446 tcon = cifs_get_tcon(ses, volume_info);
3450 goto remote_path_check;
3453 /* tell server which Unix caps we support */
3454 if (cap_unix(tcon->ses)) {
3455 /* reset of caps checks mount to see if unix extensions
3456 disabled for just this mount */
3457 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3458 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3459 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3460 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3462 goto mount_fail_check;
3465 tcon->unix_ext = 0; /* server does not support them */
3467 /* do not care if a following call succeed - informational */
3468 if (!tcon->ipc && server->ops->qfs_tcon)
3469 server->ops->qfs_tcon(xid, tcon);
3471 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3472 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3474 /* tune readahead according to rsize */
3475 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3478 #ifdef CONFIG_CIFS_DFS_UPCALL
3480 * Perform an unconditional check for whether there are DFS
3481 * referrals for this path without prefix, to provide support
3482 * for DFS referrals from w2k8 servers which don't seem to respond
3483 * with PATH_NOT_COVERED to requests that include the prefix.
3484 * Chase the referral if found, otherwise continue normally.
3486 if (referral_walks_count == 0) {
3487 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3490 referral_walks_count++;
3491 goto try_mount_again;
3496 /* check if a whole path is not remote */
3498 if (!server->ops->is_path_accessible) {
3500 goto mount_fail_check;
3503 * cifs_build_path_to_root works only when we have a valid tcon
3505 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3506 if (full_path == NULL) {
3508 goto mount_fail_check;
3510 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3512 if (rc != 0 && rc != -EREMOTE) {
3514 goto mount_fail_check;
3519 /* get referral if needed */
3520 if (rc == -EREMOTE) {
3521 #ifdef CONFIG_CIFS_DFS_UPCALL
3522 if (referral_walks_count > MAX_NESTED_LINKS) {
3524 * BB: when we implement proper loop detection,
3525 * we will remove this check. But now we need it
3526 * to prevent an indefinite loop if 'DFS tree' is
3527 * misconfigured (i.e. has loops).
3530 goto mount_fail_check;
3533 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3536 referral_walks_count++;
3537 goto try_mount_again;
3539 goto mount_fail_check;
3540 #else /* No DFS support, return error on mount */
3546 goto mount_fail_check;
3548 /* now, hang the tcon off of the superblock */
3549 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3550 if (tlink == NULL) {
3552 goto mount_fail_check;
3555 tlink->tl_uid = ses->linux_uid;
3556 tlink->tl_tcon = tcon;
3557 tlink->tl_time = jiffies;
3558 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3559 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3561 cifs_sb->master_tlink = tlink;
3562 spin_lock(&cifs_sb->tlink_tree_lock);
3563 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3564 spin_unlock(&cifs_sb->tlink_tree_lock);
3566 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3570 /* on error free sesinfo and tcon struct if needed */
3572 /* If find_unc succeeded then rc == 0 so we can not end */
3573 /* up accidentally freeing someone elses tcon struct */
3575 cifs_put_tcon(tcon);
3577 cifs_put_smb_ses(ses);
3579 cifs_put_tcp_session(server);
3580 bdi_destroy(&cifs_sb->bdi);
3589 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3590 * pointer may be NULL.
3593 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3594 const char *tree, struct cifs_tcon *tcon,
3595 const struct nls_table *nls_codepage)
3597 struct smb_hdr *smb_buffer;
3598 struct smb_hdr *smb_buffer_response;
3601 unsigned char *bcc_ptr;
3604 __u16 bytes_left, count;
3609 smb_buffer = cifs_buf_get();
3610 if (smb_buffer == NULL)
3613 smb_buffer_response = smb_buffer;
3615 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3616 NULL /*no tid */ , 4 /*wct */ );
3618 smb_buffer->Mid = get_next_mid(ses->server);
3619 smb_buffer->Uid = ses->Suid;
3620 pSMB = (TCONX_REQ *) smb_buffer;
3621 pSMBr = (TCONX_RSP *) smb_buffer_response;
3623 pSMB->AndXCommand = 0xFF;
3624 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3625 bcc_ptr = &pSMB->Password[0];
3626 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3627 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3628 *bcc_ptr = 0; /* password is null byte */
3629 bcc_ptr++; /* skip password */
3630 /* already aligned so no need to do it below */
3632 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3633 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3634 specified as required (when that support is added to
3635 the vfs in the future) as only NTLM or the much
3636 weaker LANMAN (which we do not send by default) is accepted
3637 by Samba (not sure whether other servers allow
3638 NTLMv2 password here) */
3639 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3640 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3641 (ses->server->secType == LANMAN))
3642 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3643 ses->server->sec_mode &
3644 SECMODE_PW_ENCRYPT ? true : false,
3647 #endif /* CIFS_WEAK_PW_HASH */
3648 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3649 bcc_ptr, nls_codepage);
3651 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3652 if (ses->capabilities & CAP_UNICODE) {
3653 /* must align unicode strings */
3654 *bcc_ptr = 0; /* null byte password */
3659 if (ses->server->sec_mode &
3660 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3661 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3663 if (ses->capabilities & CAP_STATUS32) {
3664 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3666 if (ses->capabilities & CAP_DFS) {
3667 smb_buffer->Flags2 |= SMBFLG2_DFS;
3669 if (ses->capabilities & CAP_UNICODE) {
3670 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3672 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3673 6 /* max utf8 char length in bytes */ *
3674 (/* server len*/ + 256 /* share len */), nls_codepage);
3675 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3676 bcc_ptr += 2; /* skip trailing null */
3677 } else { /* ASCII */
3678 strcpy(bcc_ptr, tree);
3679 bcc_ptr += strlen(tree) + 1;
3681 strcpy(bcc_ptr, "?????");
3682 bcc_ptr += strlen("?????");
3684 count = bcc_ptr - &pSMB->Password[0];
3685 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3686 pSMB->hdr.smb_buf_length) + count);
3687 pSMB->ByteCount = cpu_to_le16(count);
3689 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3692 /* above now done in SendReceive */
3693 if ((rc == 0) && (tcon != NULL)) {
3696 tcon->tidStatus = CifsGood;
3697 tcon->need_reconnect = false;
3698 tcon->tid = smb_buffer_response->Tid;
3699 bcc_ptr = pByteArea(smb_buffer_response);
3700 bytes_left = get_bcc(smb_buffer_response);
3701 length = strnlen(bcc_ptr, bytes_left - 2);
3702 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3708 /* skip service field (NB: this field is always ASCII) */
3710 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3711 (bcc_ptr[2] == 'C')) {
3712 cFYI(1, "IPC connection");
3715 } else if (length == 2) {
3716 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3717 /* the most common case */
3718 cFYI(1, "disk share connection");
3721 bcc_ptr += length + 1;
3722 bytes_left -= (length + 1);
3723 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3725 /* mostly informational -- no need to fail on error here */
3726 kfree(tcon->nativeFileSystem);
3727 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3728 bytes_left, is_unicode,
3731 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3733 if ((smb_buffer_response->WordCount == 3) ||
3734 (smb_buffer_response->WordCount == 7))
3735 /* field is in same location */
3736 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3739 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3740 } else if ((rc == 0) && tcon == NULL) {
3741 /* all we need to save for IPC$ connection */
3742 ses->ipc_tid = smb_buffer_response->Tid;
3745 cifs_buf_release(smb_buffer);
3750 cifs_umount(struct cifs_sb_info *cifs_sb)
3752 struct rb_root *root = &cifs_sb->tlink_tree;
3753 struct rb_node *node;
3754 struct tcon_link *tlink;
3756 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3758 spin_lock(&cifs_sb->tlink_tree_lock);
3759 while ((node = rb_first(root))) {
3760 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3761 cifs_get_tlink(tlink);
3762 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3763 rb_erase(node, root);
3765 spin_unlock(&cifs_sb->tlink_tree_lock);
3766 cifs_put_tlink(tlink);
3767 spin_lock(&cifs_sb->tlink_tree_lock);
3769 spin_unlock(&cifs_sb->tlink_tree_lock);
3771 bdi_destroy(&cifs_sb->bdi);
3772 kfree(cifs_sb->mountdata);
3773 unload_nls(cifs_sb->local_nls);
3778 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3781 struct TCP_Server_Info *server = ses->server;
3783 if (!server->ops->need_neg || !server->ops->negotiate)
3786 /* only send once per connect */
3787 if (!server->ops->need_neg(server))
3790 set_credits(server, 1);
3792 rc = server->ops->negotiate(xid, ses);
3794 spin_lock(&GlobalMid_Lock);
3795 if (server->tcpStatus == CifsNeedNegotiate)
3796 server->tcpStatus = CifsGood;
3799 spin_unlock(&GlobalMid_Lock);
3806 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3807 struct nls_table *nls_info)
3810 struct TCP_Server_Info *server = ses->server;
3813 ses->capabilities = server->capabilities;
3814 if (linuxExtEnabled == 0)
3815 ses->capabilities &= (~server->vals->cap_unix);
3817 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3818 server->sec_mode, server->capabilities, server->timeAdj);
3820 if (server->ops->sess_setup)
3821 rc = server->ops->sess_setup(xid, ses, nls_info);
3824 cERROR(1, "Send error in SessSetup = %d", rc);
3826 mutex_lock(&ses->server->srv_mutex);
3827 if (!server->session_estab) {
3828 server->session_key.response = ses->auth_key.response;
3829 server->session_key.len = ses->auth_key.len;
3830 server->sequence_number = 0x2;
3831 server->session_estab = true;
3832 ses->auth_key.response = NULL;
3834 mutex_unlock(&server->srv_mutex);
3836 cFYI(1, "CIFS Session Established successfully");
3837 spin_lock(&GlobalMid_Lock);
3838 ses->status = CifsGood;
3839 ses->need_reconnect = false;
3840 spin_unlock(&GlobalMid_Lock);
3843 kfree(ses->auth_key.response);
3844 ses->auth_key.response = NULL;
3845 ses->auth_key.len = 0;
3846 kfree(ses->ntlmssp);
3847 ses->ntlmssp = NULL;
3853 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3855 switch (ses->server->secType) {
3857 vol->secFlg = CIFSSEC_MUST_KRB5;
3860 vol->secFlg = CIFSSEC_MUST_NTLMV2;
3863 vol->secFlg = CIFSSEC_MUST_NTLM;
3866 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
3869 vol->secFlg = CIFSSEC_MUST_LANMAN;
3873 return cifs_set_cifscreds(vol, ses);
3876 static struct cifs_tcon *
3877 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3880 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3881 struct cifs_ses *ses;
3882 struct cifs_tcon *tcon = NULL;
3883 struct smb_vol *vol_info;
3885 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3886 if (vol_info == NULL)
3887 return ERR_PTR(-ENOMEM);
3889 vol_info->local_nls = cifs_sb->local_nls;
3890 vol_info->linux_uid = fsuid;
3891 vol_info->cred_uid = fsuid;
3892 vol_info->UNC = master_tcon->treeName;
3893 vol_info->retry = master_tcon->retry;
3894 vol_info->nocase = master_tcon->nocase;
3895 vol_info->local_lease = master_tcon->local_lease;
3896 vol_info->no_linux_ext = !master_tcon->unix_ext;
3898 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
3904 /* get a reference for the same TCP session */
3905 spin_lock(&cifs_tcp_ses_lock);
3906 ++master_tcon->ses->server->srv_count;
3907 spin_unlock(&cifs_tcp_ses_lock);
3909 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3911 tcon = (struct cifs_tcon *)ses;
3912 cifs_put_tcp_session(master_tcon->ses->server);
3916 tcon = cifs_get_tcon(ses, vol_info);
3918 cifs_put_smb_ses(ses);
3923 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3925 kfree(vol_info->username);
3926 kfree(vol_info->password);
3933 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3935 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3939 cifs_sb_tcon_pending_wait(void *unused)
3942 return signal_pending(current) ? -ERESTARTSYS : 0;
3945 /* find and return a tlink with given uid */
3946 static struct tcon_link *
3947 tlink_rb_search(struct rb_root *root, uid_t uid)
3949 struct rb_node *node = root->rb_node;
3950 struct tcon_link *tlink;
3953 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3955 if (tlink->tl_uid > uid)
3956 node = node->rb_left;
3957 else if (tlink->tl_uid < uid)
3958 node = node->rb_right;
3965 /* insert a tcon_link into the tree */
3967 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3969 struct rb_node **new = &(root->rb_node), *parent = NULL;
3970 struct tcon_link *tlink;
3973 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3976 if (tlink->tl_uid > new_tlink->tl_uid)
3977 new = &((*new)->rb_left);
3979 new = &((*new)->rb_right);
3982 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3983 rb_insert_color(&new_tlink->tl_rbnode, root);
3987 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3990 * If the superblock doesn't refer to a multiuser mount, then just return
3991 * the master tcon for the mount.
3993 * First, search the rbtree for an existing tcon for this fsuid. If one
3994 * exists, then check to see if it's pending construction. If it is then wait
3995 * for construction to complete. Once it's no longer pending, check to see if
3996 * it failed and either return an error or retry construction, depending on
3999 * If one doesn't exist then insert a new tcon_link struct into the tree and
4000 * try to construct a new one.
4003 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4006 uid_t fsuid = current_fsuid();
4007 struct tcon_link *tlink, *newtlink;
4009 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4010 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4012 spin_lock(&cifs_sb->tlink_tree_lock);
4013 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4015 cifs_get_tlink(tlink);
4016 spin_unlock(&cifs_sb->tlink_tree_lock);
4018 if (tlink == NULL) {
4019 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4020 if (newtlink == NULL)
4021 return ERR_PTR(-ENOMEM);
4022 newtlink->tl_uid = fsuid;
4023 newtlink->tl_tcon = ERR_PTR(-EACCES);
4024 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4025 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4026 cifs_get_tlink(newtlink);
4028 spin_lock(&cifs_sb->tlink_tree_lock);
4029 /* was one inserted after previous search? */
4030 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4032 cifs_get_tlink(tlink);
4033 spin_unlock(&cifs_sb->tlink_tree_lock);
4035 goto wait_for_construction;
4038 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4039 spin_unlock(&cifs_sb->tlink_tree_lock);
4041 wait_for_construction:
4042 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4043 cifs_sb_tcon_pending_wait,
4044 TASK_INTERRUPTIBLE);
4046 cifs_put_tlink(tlink);
4047 return ERR_PTR(ret);
4050 /* if it's good, return it */
4051 if (!IS_ERR(tlink->tl_tcon))
4054 /* return error if we tried this already recently */
4055 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4056 cifs_put_tlink(tlink);
4057 return ERR_PTR(-EACCES);
4060 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4061 goto wait_for_construction;
4064 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4065 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4066 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4068 if (IS_ERR(tlink->tl_tcon)) {
4069 cifs_put_tlink(tlink);
4070 return ERR_PTR(-EACCES);
4077 * periodic workqueue job that scans tcon_tree for a superblock and closes
4081 cifs_prune_tlinks(struct work_struct *work)
4083 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4085 struct rb_root *root = &cifs_sb->tlink_tree;
4086 struct rb_node *node = rb_first(root);
4087 struct rb_node *tmp;
4088 struct tcon_link *tlink;
4091 * Because we drop the spinlock in the loop in order to put the tlink
4092 * it's not guarded against removal of links from the tree. The only
4093 * places that remove entries from the tree are this function and
4094 * umounts. Because this function is non-reentrant and is canceled
4095 * before umount can proceed, this is safe.
4097 spin_lock(&cifs_sb->tlink_tree_lock);
4098 node = rb_first(root);
4099 while (node != NULL) {
4101 node = rb_next(tmp);
4102 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4104 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4105 atomic_read(&tlink->tl_count) != 0 ||
4106 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4109 cifs_get_tlink(tlink);
4110 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4111 rb_erase(tmp, root);
4113 spin_unlock(&cifs_sb->tlink_tree_lock);
4114 cifs_put_tlink(tlink);
4115 spin_lock(&cifs_sb->tlink_tree_lock);
4117 spin_unlock(&cifs_sb->tlink_tree_lock);
4119 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,