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