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