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