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