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