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