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