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