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