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