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