]> git.ipfire.org Git - thirdparty/linux.git/blob - fs/cifs/connect.c
projects / thirdparty / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
SMB3: GUIDs should be constructed as random but valid uuids
[thirdparty/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 vol->echo_interval = SMB_ECHO_INTERVAL_DEFAULT;
1232
1233 if (!mountdata)
1234 goto cifs_parse_mount_err;
1235
1236 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1237 if (!mountdata_copy)
1238 goto cifs_parse_mount_err;
1239
1240 options = mountdata_copy;
1241 end = options + strlen(options);
1242
1243 if (strncmp(options, "sep=", 4) == 0) {
1244 if (options[4] != 0) {
1245 separator[0] = options[4];
1246 options += 5;
1247 } else {
1248 cifs_dbg(FYI, "Null separator not allowed\n");
1249 }
1250 }
1251 vol->backupuid_specified = false; /* no backup intent for a user */
1252 vol->backupgid_specified = false; /* no backup intent for a group */
1253
1254 switch (cifs_parse_devname(devname, vol)) {
1255 case 0:
1256 break;
1257 case -ENOMEM:
1258 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1259 goto cifs_parse_mount_err;
1260 case -EINVAL:
1261 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1262 goto cifs_parse_mount_err;
1263 default:
1264 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1265 goto cifs_parse_mount_err;
1266 }
1267
1268 while ((data = strsep(&options, separator)) != NULL) {
1269 substring_t args[MAX_OPT_ARGS];
1270 unsigned long option;
1271 int token;
1272
1273 if (!*data)
1274 continue;
1275
1276 token = match_token(data, cifs_mount_option_tokens, args);
1277
1278 switch (token) {
1279
1280 /* Ingnore the following */
1281 case Opt_ignore:
1282 break;
1283
1284 /* Boolean values */
1285 case Opt_user_xattr:
1286 vol->no_xattr = 0;
1287 break;
1288 case Opt_nouser_xattr:
1289 vol->no_xattr = 1;
1290 break;
1291 case Opt_forceuid:
1292 override_uid = 1;
1293 break;
1294 case Opt_noforceuid:
1295 override_uid = 0;
1296 break;
1297 case Opt_forcegid:
1298 override_gid = 1;
1299 break;
1300 case Opt_noforcegid:
1301 override_gid = 0;
1302 break;
1303 case Opt_noblocksend:
1304 vol->noblocksnd = 1;
1305 break;
1306 case Opt_noautotune:
1307 vol->noautotune = 1;
1308 break;
1309 case Opt_hard:
1310 vol->retry = 1;
1311 break;
1312 case Opt_soft:
1313 vol->retry = 0;
1314 break;
1315 case Opt_perm:
1316 vol->noperm = 0;
1317 break;
1318 case Opt_noperm:
1319 vol->noperm = 1;
1320 break;
1321 case Opt_mapchars:
1322 vol->sfu_remap = true;
1323 vol->remap = false; /* disable SFM mapping */
1324 break;
1325 case Opt_nomapchars:
1326 vol->sfu_remap = false;
1327 break;
1328 case Opt_mapposix:
1329 vol->remap = true;
1330 vol->sfu_remap = false; /* disable SFU mapping */
1331 break;
1332 case Opt_nomapposix:
1333 vol->remap = false;
1334 break;
1335 case Opt_sfu:
1336 vol->sfu_emul = 1;
1337 break;
1338 case Opt_nosfu:
1339 vol->sfu_emul = 0;
1340 break;
1341 case Opt_nodfs:
1342 vol->nodfs = 1;
1343 break;
1344 case Opt_posixpaths:
1345 vol->posix_paths = 1;
1346 break;
1347 case Opt_noposixpaths:
1348 vol->posix_paths = 0;
1349 break;
1350 case Opt_nounix:
1351 vol->no_linux_ext = 1;
1352 break;
1353 case Opt_nocase:
1354 vol->nocase = 1;
1355 break;
1356 case Opt_brl:
1357 vol->nobrl = 0;
1358 break;
1359 case Opt_nobrl:
1360 vol->nobrl = 1;
1361 /*
1362 * turn off mandatory locking in mode
1363 * if remote locking is turned off since the
1364 * local vfs will do advisory
1365 */
1366 if (vol->file_mode ==
1367 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1368 vol->file_mode = S_IALLUGO;
1369 break;
1370 case Opt_forcemandatorylock:
1371 vol->mand_lock = 1;
1372 break;
1373 case Opt_setuids:
1374 vol->setuids = 1;
1375 break;
1376 case Opt_nosetuids:
1377 vol->setuids = 0;
1378 break;
1379 case Opt_dynperm:
1380 vol->dynperm = true;
1381 break;
1382 case Opt_nodynperm:
1383 vol->dynperm = false;
1384 break;
1385 case Opt_nohard:
1386 vol->retry = 0;
1387 break;
1388 case Opt_nosoft:
1389 vol->retry = 1;
1390 break;
1391 case Opt_nointr:
1392 vol->intr = 0;
1393 break;
1394 case Opt_intr:
1395 vol->intr = 1;
1396 break;
1397 case Opt_nostrictsync:
1398 vol->nostrictsync = 1;
1399 break;
1400 case Opt_strictsync:
1401 vol->nostrictsync = 0;
1402 break;
1403 case Opt_serverino:
1404 vol->server_ino = 1;
1405 break;
1406 case Opt_noserverino:
1407 vol->server_ino = 0;
1408 break;
1409 case Opt_rwpidforward:
1410 vol->rwpidforward = 1;
1411 break;
1412 case Opt_cifsacl:
1413 vol->cifs_acl = 1;
1414 break;
1415 case Opt_nocifsacl:
1416 vol->cifs_acl = 0;
1417 break;
1418 case Opt_acl:
1419 vol->no_psx_acl = 0;
1420 break;
1421 case Opt_noacl:
1422 vol->no_psx_acl = 1;
1423 break;
1424 case Opt_locallease:
1425 vol->local_lease = 1;
1426 break;
1427 case Opt_sign:
1428 vol->sign = true;
1429 break;
1430 case Opt_seal:
1431 /* we do not do the following in secFlags because seal
1432 * is a per tree connection (mount) not a per socket
1433 * or per-smb connection option in the protocol
1434 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1435 */
1436 vol->seal = 1;
1437 break;
1438 case Opt_noac:
1439 pr_warn("CIFS: Mount option noac not supported. Instead set /proc/fs/cifs/LookupCacheEnabled to 0\n");
1440 break;
1441 case Opt_fsc:
1442 #ifndef CONFIG_CIFS_FSCACHE
1443 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1444 goto cifs_parse_mount_err;
1445 #endif
1446 vol->fsc = true;
1447 break;
1448 case Opt_mfsymlinks:
1449 vol->mfsymlinks = true;
1450 break;
1451 case Opt_multiuser:
1452 vol->multiuser = true;
1453 break;
1454 case Opt_sloppy:
1455 sloppy = true;
1456 break;
1457 case Opt_nosharesock:
1458 vol->nosharesock = true;
1459 break;
1460 case Opt_nopersistent:
1461 vol->nopersistent = true;
1462 if (vol->persistent) {
1463 cifs_dbg(VFS,
1464 "persistenthandles mount options conflict\n");
1465 goto cifs_parse_mount_err;
1466 }
1467 break;
1468 case Opt_persistent:
1469 vol->persistent = true;
1470 if ((vol->nopersistent) || (vol->resilient)) {
1471 cifs_dbg(VFS,
1472 "persistenthandles mount options conflict\n");
1473 goto cifs_parse_mount_err;
1474 }
1475 break;
1476 case Opt_resilient:
1477 vol->resilient = true;
1478 if (vol->persistent) {
1479 cifs_dbg(VFS,
1480 "persistenthandles mount options conflict\n");
1481 goto cifs_parse_mount_err;
1482 }
1483 break;
1484 case Opt_noresilient:
1485 vol->resilient = false; /* already the default */
1486 break;
1487
1488 /* Numeric Values */
1489 case Opt_backupuid:
1490 if (get_option_uid(args, &vol->backupuid)) {
1491 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1492 __func__);
1493 goto cifs_parse_mount_err;
1494 }
1495 vol->backupuid_specified = true;
1496 break;
1497 case Opt_backupgid:
1498 if (get_option_gid(args, &vol->backupgid)) {
1499 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1500 __func__);
1501 goto cifs_parse_mount_err;
1502 }
1503 vol->backupgid_specified = true;
1504 break;
1505 case Opt_uid:
1506 if (get_option_uid(args, &vol->linux_uid)) {
1507 cifs_dbg(VFS, "%s: Invalid uid value\n",
1508 __func__);
1509 goto cifs_parse_mount_err;
1510 }
1511 uid_specified = true;
1512 break;
1513 case Opt_cruid:
1514 if (get_option_uid(args, &vol->cred_uid)) {
1515 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1516 __func__);
1517 goto cifs_parse_mount_err;
1518 }
1519 break;
1520 case Opt_gid:
1521 if (get_option_gid(args, &vol->linux_gid)) {
1522 cifs_dbg(VFS, "%s: Invalid gid value\n",
1523 __func__);
1524 goto cifs_parse_mount_err;
1525 }
1526 gid_specified = true;
1527 break;
1528 case Opt_file_mode:
1529 if (get_option_ul(args, &option)) {
1530 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1531 __func__);
1532 goto cifs_parse_mount_err;
1533 }
1534 vol->file_mode = option;
1535 break;
1536 case Opt_dirmode:
1537 if (get_option_ul(args, &option)) {
1538 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1539 __func__);
1540 goto cifs_parse_mount_err;
1541 }
1542 vol->dir_mode = option;
1543 break;
1544 case Opt_port:
1545 if (get_option_ul(args, &option) ||
1546 option > USHRT_MAX) {
1547 cifs_dbg(VFS, "%s: Invalid port value\n",
1548 __func__);
1549 goto cifs_parse_mount_err;
1550 }
1551 port = (unsigned short)option;
1552 break;
1553 case Opt_rsize:
1554 if (get_option_ul(args, &option)) {
1555 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1556 __func__);
1557 goto cifs_parse_mount_err;
1558 }
1559 vol->rsize = option;
1560 break;
1561 case Opt_wsize:
1562 if (get_option_ul(args, &option)) {
1563 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1564 __func__);
1565 goto cifs_parse_mount_err;
1566 }
1567 vol->wsize = option;
1568 break;
1569 case Opt_actimeo:
1570 if (get_option_ul(args, &option)) {
1571 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1572 __func__);
1573 goto cifs_parse_mount_err;
1574 }
1575 vol->actimeo = HZ * option;
1576 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1577 cifs_dbg(VFS, "attribute cache timeout too large\n");
1578 goto cifs_parse_mount_err;
1579 }
1580 break;
1581 case Opt_echo_interval:
1582 if (get_option_ul(args, &option)) {
1583 cifs_dbg(VFS, "%s: Invalid echo interval value\n",
1584 __func__);
1585 goto cifs_parse_mount_err;
1586 }
1587 vol->echo_interval = option;
1588 break;
1589
1590 /* String Arguments */
1591
1592 case Opt_blank_user:
1593 /* null user, ie. anonymous authentication */
1594 vol->nullauth = 1;
1595 vol->username = NULL;
1596 break;
1597 case Opt_user:
1598 string = match_strdup(args);
1599 if (string == NULL)
1600 goto out_nomem;
1601
1602 if (strnlen(string, CIFS_MAX_USERNAME_LEN) >
1603 CIFS_MAX_USERNAME_LEN) {
1604 pr_warn("CIFS: username too long\n");
1605 goto cifs_parse_mount_err;
1606 }
1607
1608 kfree(vol->username);
1609 vol->username = kstrdup(string, GFP_KERNEL);
1610 if (!vol->username)
1611 goto cifs_parse_mount_err;
1612 break;
1613 case Opt_blank_pass:
1614 /* passwords have to be handled differently
1615 * to allow the character used for deliminator
1616 * to be passed within them
1617 */
1618
1619 /*
1620 * Check if this is a case where the password
1621 * starts with a delimiter
1622 */
1623 tmp_end = strchr(data, '=');
1624 tmp_end++;
1625 if (!(tmp_end < end && tmp_end[1] == delim)) {
1626 /* No it is not. Set the password to NULL */
1627 kfree(vol->password);
1628 vol->password = NULL;
1629 break;
1630 }
1631 /* Yes it is. Drop down to Opt_pass below.*/
1632 case Opt_pass:
1633 /* Obtain the value string */
1634 value = strchr(data, '=');
1635 value++;
1636
1637 /* Set tmp_end to end of the string */
1638 tmp_end = (char *) value + strlen(value);
1639
1640 /* Check if following character is the deliminator
1641 * If yes, we have encountered a double deliminator
1642 * reset the NULL character to the deliminator
1643 */
1644 if (tmp_end < end && tmp_end[1] == delim) {
1645 tmp_end[0] = delim;
1646
1647 /* Keep iterating until we get to a single
1648 * deliminator OR the end
1649 */
1650 while ((tmp_end = strchr(tmp_end, delim))
1651 != NULL && (tmp_end[1] == delim)) {
1652 tmp_end = (char *) &tmp_end[2];
1653 }
1654
1655 /* Reset var options to point to next element */
1656 if (tmp_end) {
1657 tmp_end[0] = '\0';
1658 options = (char *) &tmp_end[1];
1659 } else
1660 /* Reached the end of the mount option
1661 * string */
1662 options = end;
1663 }
1664
1665 kfree(vol->password);
1666 /* Now build new password string */
1667 temp_len = strlen(value);
1668 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1669 if (vol->password == NULL) {
1670 pr_warn("CIFS: no memory for password\n");
1671 goto cifs_parse_mount_err;
1672 }
1673
1674 for (i = 0, j = 0; i < temp_len; i++, j++) {
1675 vol->password[j] = value[i];
1676 if ((value[i] == delim) &&
1677 value[i+1] == delim)
1678 /* skip the second deliminator */
1679 i++;
1680 }
1681 vol->password[j] = '\0';
1682 break;
1683 case Opt_blank_ip:
1684 /* FIXME: should this be an error instead? */
1685 got_ip = false;
1686 break;
1687 case Opt_ip:
1688 string = match_strdup(args);
1689 if (string == NULL)
1690 goto out_nomem;
1691
1692 if (!cifs_convert_address(dstaddr, string,
1693 strlen(string))) {
1694 pr_err("CIFS: bad ip= option (%s).\n", string);
1695 goto cifs_parse_mount_err;
1696 }
1697 got_ip = true;
1698 break;
1699 case Opt_domain:
1700 string = match_strdup(args);
1701 if (string == NULL)
1702 goto out_nomem;
1703
1704 if (strnlen(string, CIFS_MAX_DOMAINNAME_LEN)
1705 == CIFS_MAX_DOMAINNAME_LEN) {
1706 pr_warn("CIFS: domain name too long\n");
1707 goto cifs_parse_mount_err;
1708 }
1709
1710 kfree(vol->domainname);
1711 vol->domainname = kstrdup(string, GFP_KERNEL);
1712 if (!vol->domainname) {
1713 pr_warn("CIFS: no memory for domainname\n");
1714 goto cifs_parse_mount_err;
1715 }
1716 cifs_dbg(FYI, "Domain name set\n");
1717 break;
1718 case Opt_srcaddr:
1719 string = match_strdup(args);
1720 if (string == NULL)
1721 goto out_nomem;
1722
1723 if (!cifs_convert_address(
1724 (struct sockaddr *)&vol->srcaddr,
1725 string, strlen(string))) {
1726 pr_warn("CIFS: Could not parse srcaddr: %s\n",
1727 string);
1728 goto cifs_parse_mount_err;
1729 }
1730 break;
1731 case Opt_iocharset:
1732 string = match_strdup(args);
1733 if (string == NULL)
1734 goto out_nomem;
1735
1736 if (strnlen(string, 1024) >= 65) {
1737 pr_warn("CIFS: iocharset name too long.\n");
1738 goto cifs_parse_mount_err;
1739 }
1740
1741 if (strncasecmp(string, "default", 7) != 0) {
1742 kfree(vol->iocharset);
1743 vol->iocharset = kstrdup(string,
1744 GFP_KERNEL);
1745 if (!vol->iocharset) {
1746 pr_warn("CIFS: no memory for charset\n");
1747 goto cifs_parse_mount_err;
1748 }
1749 }
1750 /* if iocharset not set then load_nls_default
1751 * is used by caller
1752 */
1753 cifs_dbg(FYI, "iocharset set to %s\n", string);
1754 break;
1755 case Opt_netbiosname:
1756 string = match_strdup(args);
1757 if (string == NULL)
1758 goto out_nomem;
1759
1760 memset(vol->source_rfc1001_name, 0x20,
1761 RFC1001_NAME_LEN);
1762 /*
1763 * FIXME: are there cases in which a comma can
1764 * be valid in workstation netbios name (and
1765 * need special handling)?
1766 */
1767 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1768 /* don't ucase netbiosname for user */
1769 if (string[i] == 0)
1770 break;
1771 vol->source_rfc1001_name[i] = string[i];
1772 }
1773 /* The string has 16th byte zero still from
1774 * set at top of the function
1775 */
1776 if (i == RFC1001_NAME_LEN && string[i] != 0)
1777 pr_warn("CIFS: netbiosname longer than 15 truncated.\n");
1778 break;
1779 case Opt_servern:
1780 /* servernetbiosname specified override *SMBSERVER */
1781 string = match_strdup(args);
1782 if (string == NULL)
1783 goto out_nomem;
1784
1785 /* last byte, type, is 0x20 for servr type */
1786 memset(vol->target_rfc1001_name, 0x20,
1787 RFC1001_NAME_LEN_WITH_NULL);
1788
1789 /* BB are there cases in which a comma can be
1790 valid in this workstation netbios name
1791 (and need special handling)? */
1792
1793 /* user or mount helper must uppercase the
1794 netbios name */
1795 for (i = 0; i < 15; i++) {
1796 if (string[i] == 0)
1797 break;
1798 vol->target_rfc1001_name[i] = string[i];
1799 }
1800 /* The string has 16th byte zero still from
1801 set at top of the function */
1802 if (i == RFC1001_NAME_LEN && string[i] != 0)
1803 pr_warn("CIFS: server netbiosname longer than 15 truncated.\n");
1804 break;
1805 case Opt_ver:
1806 string = match_strdup(args);
1807 if (string == NULL)
1808 goto out_nomem;
1809
1810 if (strncasecmp(string, "1", 1) == 0) {
1811 /* This is the default */
1812 break;
1813 }
1814 /* For all other value, error */
1815 pr_warn("CIFS: Invalid version specified\n");
1816 goto cifs_parse_mount_err;
1817 case Opt_vers:
1818 string = match_strdup(args);
1819 if (string == NULL)
1820 goto out_nomem;
1821
1822 if (cifs_parse_smb_version(string, vol) != 0)
1823 goto cifs_parse_mount_err;
1824 break;
1825 case Opt_sec:
1826 string = match_strdup(args);
1827 if (string == NULL)
1828 goto out_nomem;
1829
1830 if (cifs_parse_security_flavors(string, vol) != 0)
1831 goto cifs_parse_mount_err;
1832 break;
1833 case Opt_cache:
1834 string = match_strdup(args);
1835 if (string == NULL)
1836 goto out_nomem;
1837
1838 if (cifs_parse_cache_flavor(string, vol) != 0)
1839 goto cifs_parse_mount_err;
1840 break;
1841 default:
1842 /*
1843 * An option we don't recognize. Save it off for later
1844 * if we haven't already found one
1845 */
1846 if (!invalid)
1847 invalid = data;
1848 break;
1849 }
1850 /* Free up any allocated string */
1851 kfree(string);
1852 string = NULL;
1853 }
1854
1855 if (!sloppy && invalid) {
1856 pr_err("CIFS: Unknown mount option \"%s\"\n", invalid);
1857 goto cifs_parse_mount_err;
1858 }
1859
1860 #ifndef CONFIG_KEYS
1861 /* Muliuser mounts require CONFIG_KEYS support */
1862 if (vol->multiuser) {
1863 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1864 goto cifs_parse_mount_err;
1865 }
1866 #endif
1867 if (!vol->UNC) {
1868 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
1869 goto cifs_parse_mount_err;
1870 }
1871
1872 /* make sure UNC has a share name */
1873 if (!strchr(vol->UNC + 3, '\\')) {
1874 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
1875 goto cifs_parse_mount_err;
1876 }
1877
1878 if (!got_ip) {
1879 /* No ip= option specified? Try to get it from UNC */
1880 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1881 strlen(&vol->UNC[2]))) {
1882 pr_err("Unable to determine destination address.\n");
1883 goto cifs_parse_mount_err;
1884 }
1885 }
1886
1887 /* set the port that we got earlier */
1888 cifs_set_port(dstaddr, port);
1889
1890 if (uid_specified)
1891 vol->override_uid = override_uid;
1892 else if (override_uid == 1)
1893 pr_notice("CIFS: ignoring forceuid mount option specified with no uid= option.\n");
1894
1895 if (gid_specified)
1896 vol->override_gid = override_gid;
1897 else if (override_gid == 1)
1898 pr_notice("CIFS: ignoring forcegid mount option specified with no gid= option.\n");
1899
1900 kfree(mountdata_copy);
1901 return 0;
1902
1903 out_nomem:
1904 pr_warn("Could not allocate temporary buffer\n");
1905 cifs_parse_mount_err:
1906 kfree(string);
1907 kfree(mountdata_copy);
1908 return 1;
1909 }
1910
1911 /** Returns true if srcaddr isn't specified and rhs isn't
1912 * specified, or if srcaddr is specified and
1913 * matches the IP address of the rhs argument.
1914 */
1915 static bool
1916 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1917 {
1918 switch (srcaddr->sa_family) {
1919 case AF_UNSPEC:
1920 return (rhs->sa_family == AF_UNSPEC);
1921 case AF_INET: {
1922 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1923 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1924 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1925 }
1926 case AF_INET6: {
1927 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1928 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1929 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1930 }
1931 default:
1932 WARN_ON(1);
1933 return false; /* don't expect to be here */
1934 }
1935 }
1936
1937 /*
1938 * If no port is specified in addr structure, we try to match with 445 port
1939 * and if it fails - with 139 ports. It should be called only if address
1940 * families of server and addr are equal.
1941 */
1942 static bool
1943 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1944 {
1945 __be16 port, *sport;
1946
1947 switch (addr->sa_family) {
1948 case AF_INET:
1949 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1950 port = ((struct sockaddr_in *) addr)->sin_port;
1951 break;
1952 case AF_INET6:
1953 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1954 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1955 break;
1956 default:
1957 WARN_ON(1);
1958 return false;
1959 }
1960
1961 if (!port) {
1962 port = htons(CIFS_PORT);
1963 if (port == *sport)
1964 return true;
1965
1966 port = htons(RFC1001_PORT);
1967 }
1968
1969 return port == *sport;
1970 }
1971
1972 static bool
1973 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1974 struct sockaddr *srcaddr)
1975 {
1976 switch (addr->sa_family) {
1977 case AF_INET: {
1978 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1979 struct sockaddr_in *srv_addr4 =
1980 (struct sockaddr_in *)&server->dstaddr;
1981
1982 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1983 return false;
1984 break;
1985 }
1986 case AF_INET6: {
1987 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1988 struct sockaddr_in6 *srv_addr6 =
1989 (struct sockaddr_in6 *)&server->dstaddr;
1990
1991 if (!ipv6_addr_equal(&addr6->sin6_addr,
1992 &srv_addr6->sin6_addr))
1993 return false;
1994 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1995 return false;
1996 break;
1997 }
1998 default:
1999 WARN_ON(1);
2000 return false; /* don't expect to be here */
2001 }
2002
2003 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
2004 return false;
2005
2006 return true;
2007 }
2008
2009 static bool
2010 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
2011 {
2012 /*
2013 * The select_sectype function should either return the vol->sectype
2014 * that was specified, or "Unspecified" if that sectype was not
2015 * compatible with the given NEGOTIATE request.
2016 */
2017 if (select_sectype(server, vol->sectype) == Unspecified)
2018 return false;
2019
2020 /*
2021 * Now check if signing mode is acceptable. No need to check
2022 * global_secflags at this point since if MUST_SIGN is set then
2023 * the server->sign had better be too.
2024 */
2025 if (vol->sign && !server->sign)
2026 return false;
2027
2028 return true;
2029 }
2030
2031 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2032 {
2033 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2034
2035 if (vol->nosharesock)
2036 return 0;
2037
2038 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2039 return 0;
2040
2041 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2042 return 0;
2043
2044 if (!match_address(server, addr,
2045 (struct sockaddr *)&vol->srcaddr))
2046 return 0;
2047
2048 if (!match_port(server, addr))
2049 return 0;
2050
2051 if (!match_security(server, vol))
2052 return 0;
2053
2054 if (server->echo_interval != vol->echo_interval * HZ)
2055 return 0;
2056
2057 return 1;
2058 }
2059
2060 static struct TCP_Server_Info *
2061 cifs_find_tcp_session(struct smb_vol *vol)
2062 {
2063 struct TCP_Server_Info *server;
2064
2065 spin_lock(&cifs_tcp_ses_lock);
2066 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2067 if (!match_server(server, vol))
2068 continue;
2069
2070 ++server->srv_count;
2071 spin_unlock(&cifs_tcp_ses_lock);
2072 cifs_dbg(FYI, "Existing tcp session with server found\n");
2073 return server;
2074 }
2075 spin_unlock(&cifs_tcp_ses_lock);
2076 return NULL;
2077 }
2078
2079 static void
2080 cifs_put_tcp_session(struct TCP_Server_Info *server)
2081 {
2082 struct task_struct *task;
2083
2084 spin_lock(&cifs_tcp_ses_lock);
2085 if (--server->srv_count > 0) {
2086 spin_unlock(&cifs_tcp_ses_lock);
2087 return;
2088 }
2089
2090 put_net(cifs_net_ns(server));
2091
2092 list_del_init(&server->tcp_ses_list);
2093 spin_unlock(&cifs_tcp_ses_lock);
2094
2095 cancel_delayed_work_sync(&server->echo);
2096
2097 spin_lock(&GlobalMid_Lock);
2098 server->tcpStatus = CifsExiting;
2099 spin_unlock(&GlobalMid_Lock);
2100
2101 cifs_crypto_shash_release(server);
2102 cifs_fscache_release_client_cookie(server);
2103
2104 kfree(server->session_key.response);
2105 server->session_key.response = NULL;
2106 server->session_key.len = 0;
2107
2108 task = xchg(&server->tsk, NULL);
2109 if (task)
2110 force_sig(SIGKILL, task);
2111 }
2112
2113 static struct TCP_Server_Info *
2114 cifs_get_tcp_session(struct smb_vol *volume_info)
2115 {
2116 struct TCP_Server_Info *tcp_ses = NULL;
2117 int rc;
2118
2119 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2120
2121 /* see if we already have a matching tcp_ses */
2122 tcp_ses = cifs_find_tcp_session(volume_info);
2123 if (tcp_ses)
2124 return tcp_ses;
2125
2126 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2127 if (!tcp_ses) {
2128 rc = -ENOMEM;
2129 goto out_err;
2130 }
2131
2132 tcp_ses->ops = volume_info->ops;
2133 tcp_ses->vals = volume_info->vals;
2134 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2135 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2136 if (IS_ERR(tcp_ses->hostname)) {
2137 rc = PTR_ERR(tcp_ses->hostname);
2138 goto out_err_crypto_release;
2139 }
2140
2141 tcp_ses->noblocksnd = volume_info->noblocksnd;
2142 tcp_ses->noautotune = volume_info->noautotune;
2143 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2144 tcp_ses->in_flight = 0;
2145 tcp_ses->credits = 1;
2146 init_waitqueue_head(&tcp_ses->response_q);
2147 init_waitqueue_head(&tcp_ses->request_q);
2148 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2149 mutex_init(&tcp_ses->srv_mutex);
2150 memcpy(tcp_ses->workstation_RFC1001_name,
2151 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2152 memcpy(tcp_ses->server_RFC1001_name,
2153 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2154 tcp_ses->session_estab = false;
2155 tcp_ses->sequence_number = 0;
2156 tcp_ses->lstrp = jiffies;
2157 spin_lock_init(&tcp_ses->req_lock);
2158 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2159 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2160 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2161 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2162 sizeof(tcp_ses->srcaddr));
2163 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2164 sizeof(tcp_ses->dstaddr));
2165 #ifdef CONFIG_CIFS_SMB2
2166 generate_random_uuid(tcp_ses->client_guid);
2167 #endif
2168 /*
2169 * at this point we are the only ones with the pointer
2170 * to the struct since the kernel thread not created yet
2171 * no need to spinlock this init of tcpStatus or srv_count
2172 */
2173 tcp_ses->tcpStatus = CifsNew;
2174 ++tcp_ses->srv_count;
2175
2176 if (volume_info->echo_interval >= SMB_ECHO_INTERVAL_MIN &&
2177 volume_info->echo_interval <= SMB_ECHO_INTERVAL_MAX)
2178 tcp_ses->echo_interval = volume_info->echo_interval * HZ;
2179 else
2180 tcp_ses->echo_interval = SMB_ECHO_INTERVAL_DEFAULT * HZ;
2181
2182 rc = ip_connect(tcp_ses);
2183 if (rc < 0) {
2184 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2185 goto out_err_crypto_release;
2186 }
2187
2188 /*
2189 * since we're in a cifs function already, we know that
2190 * this will succeed. No need for try_module_get().
2191 */
2192 __module_get(THIS_MODULE);
2193 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2194 tcp_ses, "cifsd");
2195 if (IS_ERR(tcp_ses->tsk)) {
2196 rc = PTR_ERR(tcp_ses->tsk);
2197 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2198 module_put(THIS_MODULE);
2199 goto out_err_crypto_release;
2200 }
2201 tcp_ses->tcpStatus = CifsNeedNegotiate;
2202
2203 /* thread spawned, put it on the list */
2204 spin_lock(&cifs_tcp_ses_lock);
2205 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2206 spin_unlock(&cifs_tcp_ses_lock);
2207
2208 cifs_fscache_get_client_cookie(tcp_ses);
2209
2210 /* queue echo request delayed work */
2211 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
2212
2213 return tcp_ses;
2214
2215 out_err_crypto_release:
2216 cifs_crypto_shash_release(tcp_ses);
2217
2218 put_net(cifs_net_ns(tcp_ses));
2219
2220 out_err:
2221 if (tcp_ses) {
2222 if (!IS_ERR(tcp_ses->hostname))
2223 kfree(tcp_ses->hostname);
2224 if (tcp_ses->ssocket)
2225 sock_release(tcp_ses->ssocket);
2226 kfree(tcp_ses);
2227 }
2228 return ERR_PTR(rc);
2229 }
2230
2231 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2232 {
2233 if (vol->sectype != Unspecified &&
2234 vol->sectype != ses->sectype)
2235 return 0;
2236
2237 switch (ses->sectype) {
2238 case Kerberos:
2239 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2240 return 0;
2241 break;
2242 default:
2243 /* NULL username means anonymous session */
2244 if (ses->user_name == NULL) {
2245 if (!vol->nullauth)
2246 return 0;
2247 break;
2248 }
2249
2250 /* anything else takes username/password */
2251 if (strncmp(ses->user_name,
2252 vol->username ? vol->username : "",
2253 CIFS_MAX_USERNAME_LEN))
2254 return 0;
2255 if ((vol->username && strlen(vol->username) != 0) &&
2256 ses->password != NULL &&
2257 strncmp(ses->password,
2258 vol->password ? vol->password : "",
2259 CIFS_MAX_PASSWORD_LEN))
2260 return 0;
2261 }
2262 return 1;
2263 }
2264
2265 static struct cifs_ses *
2266 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2267 {
2268 struct cifs_ses *ses;
2269
2270 spin_lock(&cifs_tcp_ses_lock);
2271 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2272 if (ses->status == CifsExiting)
2273 continue;
2274 if (!match_session(ses, vol))
2275 continue;
2276 ++ses->ses_count;
2277 spin_unlock(&cifs_tcp_ses_lock);
2278 return ses;
2279 }
2280 spin_unlock(&cifs_tcp_ses_lock);
2281 return NULL;
2282 }
2283
2284 static void
2285 cifs_put_smb_ses(struct cifs_ses *ses)
2286 {
2287 unsigned int rc, xid;
2288 struct TCP_Server_Info *server = ses->server;
2289
2290 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2291
2292 spin_lock(&cifs_tcp_ses_lock);
2293 if (ses->status == CifsExiting) {
2294 spin_unlock(&cifs_tcp_ses_lock);
2295 return;
2296 }
2297 if (--ses->ses_count > 0) {
2298 spin_unlock(&cifs_tcp_ses_lock);
2299 return;
2300 }
2301 if (ses->status == CifsGood)
2302 ses->status = CifsExiting;
2303 spin_unlock(&cifs_tcp_ses_lock);
2304
2305 if (ses->status == CifsExiting && server->ops->logoff) {
2306 xid = get_xid();
2307 rc = server->ops->logoff(xid, ses);
2308 if (rc)
2309 cifs_dbg(VFS, "%s: Session Logoff failure rc=%d\n",
2310 __func__, rc);
2311 _free_xid(xid);
2312 }
2313
2314 spin_lock(&cifs_tcp_ses_lock);
2315 list_del_init(&ses->smb_ses_list);
2316 spin_unlock(&cifs_tcp_ses_lock);
2317
2318 sesInfoFree(ses);
2319 cifs_put_tcp_session(server);
2320 }
2321
2322 #ifdef CONFIG_KEYS
2323
2324 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2325 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2326
2327 /* Populate username and pw fields from keyring if possible */
2328 static int
2329 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2330 {
2331 int rc = 0;
2332 const char *delim, *payload;
2333 char *desc;
2334 ssize_t len;
2335 struct key *key;
2336 struct TCP_Server_Info *server = ses->server;
2337 struct sockaddr_in *sa;
2338 struct sockaddr_in6 *sa6;
2339 const struct user_key_payload *upayload;
2340
2341 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2342 if (!desc)
2343 return -ENOMEM;
2344
2345 /* try to find an address key first */
2346 switch (server->dstaddr.ss_family) {
2347 case AF_INET:
2348 sa = (struct sockaddr_in *)&server->dstaddr;
2349 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2350 break;
2351 case AF_INET6:
2352 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2353 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2354 break;
2355 default:
2356 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2357 server->dstaddr.ss_family);
2358 rc = -EINVAL;
2359 goto out_err;
2360 }
2361
2362 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2363 key = request_key(&key_type_logon, desc, "");
2364 if (IS_ERR(key)) {
2365 if (!ses->domainName) {
2366 cifs_dbg(FYI, "domainName is NULL\n");
2367 rc = PTR_ERR(key);
2368 goto out_err;
2369 }
2370
2371 /* didn't work, try to find a domain key */
2372 sprintf(desc, "cifs:d:%s", ses->domainName);
2373 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2374 key = request_key(&key_type_logon, desc, "");
2375 if (IS_ERR(key)) {
2376 rc = PTR_ERR(key);
2377 goto out_err;
2378 }
2379 }
2380
2381 down_read(&key->sem);
2382 upayload = user_key_payload(key);
2383 if (IS_ERR_OR_NULL(upayload)) {
2384 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2385 goto out_key_put;
2386 }
2387
2388 /* find first : in payload */
2389 payload = upayload->data;
2390 delim = strnchr(payload, upayload->datalen, ':');
2391 cifs_dbg(FYI, "payload=%s\n", payload);
2392 if (!delim) {
2393 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2394 upayload->datalen);
2395 rc = -EINVAL;
2396 goto out_key_put;
2397 }
2398
2399 len = delim - payload;
2400 if (len > CIFS_MAX_USERNAME_LEN || len <= 0) {
2401 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2402 len);
2403 rc = -EINVAL;
2404 goto out_key_put;
2405 }
2406
2407 vol->username = kstrndup(payload, len, GFP_KERNEL);
2408 if (!vol->username) {
2409 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2410 len);
2411 rc = -ENOMEM;
2412 goto out_key_put;
2413 }
2414 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2415
2416 len = key->datalen - (len + 1);
2417 if (len > CIFS_MAX_PASSWORD_LEN || len <= 0) {
2418 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2419 rc = -EINVAL;
2420 kfree(vol->username);
2421 vol->username = NULL;
2422 goto out_key_put;
2423 }
2424
2425 ++delim;
2426 vol->password = kstrndup(delim, len, GFP_KERNEL);
2427 if (!vol->password) {
2428 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2429 len);
2430 rc = -ENOMEM;
2431 kfree(vol->username);
2432 vol->username = NULL;
2433 goto out_key_put;
2434 }
2435
2436 out_key_put:
2437 up_read(&key->sem);
2438 key_put(key);
2439 out_err:
2440 kfree(desc);
2441 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2442 return rc;
2443 }
2444 #else /* ! CONFIG_KEYS */
2445 static inline int
2446 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2447 struct cifs_ses *ses __attribute__((unused)))
2448 {
2449 return -ENOSYS;
2450 }
2451 #endif /* CONFIG_KEYS */
2452
2453 static struct cifs_ses *
2454 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2455 {
2456 int rc = -ENOMEM;
2457 unsigned int xid;
2458 struct cifs_ses *ses;
2459 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2460 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2461
2462 xid = get_xid();
2463
2464 ses = cifs_find_smb_ses(server, volume_info);
2465 if (ses) {
2466 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2467 ses->status);
2468
2469 mutex_lock(&ses->session_mutex);
2470 rc = cifs_negotiate_protocol(xid, ses);
2471 if (rc) {
2472 mutex_unlock(&ses->session_mutex);
2473 /* problem -- put our ses reference */
2474 cifs_put_smb_ses(ses);
2475 free_xid(xid);
2476 return ERR_PTR(rc);
2477 }
2478 if (ses->need_reconnect) {
2479 cifs_dbg(FYI, "Session needs reconnect\n");
2480 rc = cifs_setup_session(xid, ses,
2481 volume_info->local_nls);
2482 if (rc) {
2483 mutex_unlock(&ses->session_mutex);
2484 /* problem -- put our reference */
2485 cifs_put_smb_ses(ses);
2486 free_xid(xid);
2487 return ERR_PTR(rc);
2488 }
2489 }
2490 mutex_unlock(&ses->session_mutex);
2491
2492 /* existing SMB ses has a server reference already */
2493 cifs_put_tcp_session(server);
2494 free_xid(xid);
2495 return ses;
2496 }
2497
2498 cifs_dbg(FYI, "Existing smb sess not found\n");
2499 ses = sesInfoAlloc();
2500 if (ses == NULL)
2501 goto get_ses_fail;
2502
2503 /* new SMB session uses our server ref */
2504 ses->server = server;
2505 if (server->dstaddr.ss_family == AF_INET6)
2506 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2507 else
2508 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2509
2510 if (volume_info->username) {
2511 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2512 if (!ses->user_name)
2513 goto get_ses_fail;
2514 }
2515
2516 /* volume_info->password freed at unmount */
2517 if (volume_info->password) {
2518 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2519 if (!ses->password)
2520 goto get_ses_fail;
2521 }
2522 if (volume_info->domainname) {
2523 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2524 if (!ses->domainName)
2525 goto get_ses_fail;
2526 }
2527 ses->cred_uid = volume_info->cred_uid;
2528 ses->linux_uid = volume_info->linux_uid;
2529
2530 ses->sectype = volume_info->sectype;
2531 ses->sign = volume_info->sign;
2532
2533 mutex_lock(&ses->session_mutex);
2534 rc = cifs_negotiate_protocol(xid, ses);
2535 if (!rc)
2536 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2537 mutex_unlock(&ses->session_mutex);
2538 if (rc)
2539 goto get_ses_fail;
2540
2541 /* success, put it on the list */
2542 spin_lock(&cifs_tcp_ses_lock);
2543 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2544 spin_unlock(&cifs_tcp_ses_lock);
2545
2546 free_xid(xid);
2547 return ses;
2548
2549 get_ses_fail:
2550 sesInfoFree(ses);
2551 free_xid(xid);
2552 return ERR_PTR(rc);
2553 }
2554
2555 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2556 {
2557 if (tcon->tidStatus == CifsExiting)
2558 return 0;
2559 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2560 return 0;
2561 return 1;
2562 }
2563
2564 static struct cifs_tcon *
2565 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2566 {
2567 struct list_head *tmp;
2568 struct cifs_tcon *tcon;
2569
2570 spin_lock(&cifs_tcp_ses_lock);
2571 list_for_each(tmp, &ses->tcon_list) {
2572 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2573 if (!match_tcon(tcon, unc))
2574 continue;
2575 ++tcon->tc_count;
2576 spin_unlock(&cifs_tcp_ses_lock);
2577 return tcon;
2578 }
2579 spin_unlock(&cifs_tcp_ses_lock);
2580 return NULL;
2581 }
2582
2583 static void
2584 cifs_put_tcon(struct cifs_tcon *tcon)
2585 {
2586 unsigned int xid;
2587 struct cifs_ses *ses = tcon->ses;
2588
2589 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2590 spin_lock(&cifs_tcp_ses_lock);
2591 if (--tcon->tc_count > 0) {
2592 spin_unlock(&cifs_tcp_ses_lock);
2593 return;
2594 }
2595
2596 list_del_init(&tcon->tcon_list);
2597 spin_unlock(&cifs_tcp_ses_lock);
2598
2599 xid = get_xid();
2600 if (ses->server->ops->tree_disconnect)
2601 ses->server->ops->tree_disconnect(xid, tcon);
2602 _free_xid(xid);
2603
2604 cifs_fscache_release_super_cookie(tcon);
2605 tconInfoFree(tcon);
2606 cifs_put_smb_ses(ses);
2607 }
2608
2609 static struct cifs_tcon *
2610 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2611 {
2612 int rc, xid;
2613 struct cifs_tcon *tcon;
2614
2615 tcon = cifs_find_tcon(ses, volume_info->UNC);
2616 if (tcon) {
2617 cifs_dbg(FYI, "Found match on UNC path\n");
2618 /* existing tcon already has a reference */
2619 cifs_put_smb_ses(ses);
2620 if (tcon->seal != volume_info->seal)
2621 cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
2622 return tcon;
2623 }
2624
2625 if (!ses->server->ops->tree_connect) {
2626 rc = -ENOSYS;
2627 goto out_fail;
2628 }
2629
2630 tcon = tconInfoAlloc();
2631 if (tcon == NULL) {
2632 rc = -ENOMEM;
2633 goto out_fail;
2634 }
2635
2636 tcon->ses = ses;
2637 if (volume_info->password) {
2638 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2639 if (!tcon->password) {
2640 rc = -ENOMEM;
2641 goto out_fail;
2642 }
2643 }
2644
2645 /*
2646 * BB Do we need to wrap session_mutex around this TCon call and Unix
2647 * SetFS as we do on SessSetup and reconnect?
2648 */
2649 xid = get_xid();
2650 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2651 volume_info->local_nls);
2652 free_xid(xid);
2653 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2654 if (rc)
2655 goto out_fail;
2656
2657 if (volume_info->nodfs) {
2658 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2659 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2660 }
2661 tcon->seal = volume_info->seal;
2662 tcon->use_persistent = false;
2663 /* check if SMB2 or later, CIFS does not support persistent handles */
2664 if (volume_info->persistent) {
2665 if (ses->server->vals->protocol_id == 0) {
2666 cifs_dbg(VFS,
2667 "SMB3 or later required for persistent handles\n");
2668 rc = -EOPNOTSUPP;
2669 goto out_fail;
2670 #ifdef CONFIG_CIFS_SMB2
2671 } else if (ses->server->capabilities &
2672 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2673 tcon->use_persistent = true;
2674 else /* persistent handles requested but not supported */ {
2675 cifs_dbg(VFS,
2676 "Persistent handles not supported on share\n");
2677 rc = -EOPNOTSUPP;
2678 goto out_fail;
2679 #endif /* CONFIG_CIFS_SMB2 */
2680 }
2681 #ifdef CONFIG_CIFS_SMB2
2682 } else if ((tcon->capabilities & SMB2_SHARE_CAP_CONTINUOUS_AVAILABILITY)
2683 && (ses->server->capabilities & SMB2_GLOBAL_CAP_PERSISTENT_HANDLES)
2684 && (volume_info->nopersistent == false)) {
2685 cifs_dbg(FYI, "enabling persistent handles\n");
2686 tcon->use_persistent = true;
2687 #endif /* CONFIG_CIFS_SMB2 */
2688 } else if (volume_info->resilient) {
2689 if (ses->server->vals->protocol_id == 0) {
2690 cifs_dbg(VFS,
2691 "SMB2.1 or later required for resilient handles\n");
2692 rc = -EOPNOTSUPP;
2693 goto out_fail;
2694 }
2695 tcon->use_resilient = true;
2696 }
2697
2698 /*
2699 * We can have only one retry value for a connection to a share so for
2700 * resources mounted more than once to the same server share the last
2701 * value passed in for the retry flag is used.
2702 */
2703 tcon->retry = volume_info->retry;
2704 tcon->nocase = volume_info->nocase;
2705 tcon->local_lease = volume_info->local_lease;
2706 INIT_LIST_HEAD(&tcon->pending_opens);
2707
2708 spin_lock(&cifs_tcp_ses_lock);
2709 list_add(&tcon->tcon_list, &ses->tcon_list);
2710 spin_unlock(&cifs_tcp_ses_lock);
2711
2712 cifs_fscache_get_super_cookie(tcon);
2713
2714 return tcon;
2715
2716 out_fail:
2717 tconInfoFree(tcon);
2718 return ERR_PTR(rc);
2719 }
2720
2721 void
2722 cifs_put_tlink(struct tcon_link *tlink)
2723 {
2724 if (!tlink || IS_ERR(tlink))
2725 return;
2726
2727 if (!atomic_dec_and_test(&tlink->tl_count) ||
2728 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2729 tlink->tl_time = jiffies;
2730 return;
2731 }
2732
2733 if (!IS_ERR(tlink_tcon(tlink)))
2734 cifs_put_tcon(tlink_tcon(tlink));
2735 kfree(tlink);
2736 return;
2737 }
2738
2739 static inline struct tcon_link *
2740 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2741 {
2742 return cifs_sb->master_tlink;
2743 }
2744
2745 static int
2746 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2747 {
2748 struct cifs_sb_info *old = CIFS_SB(sb);
2749 struct cifs_sb_info *new = mnt_data->cifs_sb;
2750
2751 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2752 return 0;
2753
2754 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2755 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2756 return 0;
2757
2758 /*
2759 * We want to share sb only if we don't specify an r/wsize or
2760 * specified r/wsize is greater than or equal to existing one.
2761 */
2762 if (new->wsize && new->wsize < old->wsize)
2763 return 0;
2764
2765 if (new->rsize && new->rsize < old->rsize)
2766 return 0;
2767
2768 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2769 return 0;
2770
2771 if (old->mnt_file_mode != new->mnt_file_mode ||
2772 old->mnt_dir_mode != new->mnt_dir_mode)
2773 return 0;
2774
2775 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2776 return 0;
2777
2778 if (old->actimeo != new->actimeo)
2779 return 0;
2780
2781 return 1;
2782 }
2783
2784 static int
2785 match_prepath(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2786 {
2787 struct cifs_sb_info *old = CIFS_SB(sb);
2788 struct cifs_sb_info *new = mnt_data->cifs_sb;
2789
2790 if (old->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH) {
2791 if (!(new->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH))
2792 return 0;
2793 /* The prepath should be null terminated strings */
2794 if (strcmp(new->prepath, old->prepath))
2795 return 0;
2796
2797 return 1;
2798 }
2799 return 0;
2800 }
2801
2802 int
2803 cifs_match_super(struct super_block *sb, void *data)
2804 {
2805 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2806 struct smb_vol *volume_info;
2807 struct cifs_sb_info *cifs_sb;
2808 struct TCP_Server_Info *tcp_srv;
2809 struct cifs_ses *ses;
2810 struct cifs_tcon *tcon;
2811 struct tcon_link *tlink;
2812 int rc = 0;
2813
2814 spin_lock(&cifs_tcp_ses_lock);
2815 cifs_sb = CIFS_SB(sb);
2816 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2817 if (IS_ERR(tlink)) {
2818 spin_unlock(&cifs_tcp_ses_lock);
2819 return rc;
2820 }
2821 tcon = tlink_tcon(tlink);
2822 ses = tcon->ses;
2823 tcp_srv = ses->server;
2824
2825 volume_info = mnt_data->vol;
2826
2827 if (!match_server(tcp_srv, volume_info) ||
2828 !match_session(ses, volume_info) ||
2829 !match_tcon(tcon, volume_info->UNC) ||
2830 !match_prepath(sb, mnt_data)) {
2831 rc = 0;
2832 goto out;
2833 }
2834
2835 rc = compare_mount_options(sb, mnt_data);
2836 out:
2837 spin_unlock(&cifs_tcp_ses_lock);
2838 cifs_put_tlink(tlink);
2839 return rc;
2840 }
2841
2842 int
2843 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2844 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2845 struct dfs_info3_param **referrals, int remap)
2846 {
2847 char *temp_unc;
2848 int rc = 0;
2849
2850 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2851 return -ENOSYS;
2852
2853 *num_referrals = 0;
2854 *referrals = NULL;
2855
2856 if (ses->ipc_tid == 0) {
2857 temp_unc = kmalloc(2 /* for slashes */ +
2858 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2859 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2860 if (temp_unc == NULL)
2861 return -ENOMEM;
2862 temp_unc[0] = '\\';
2863 temp_unc[1] = '\\';
2864 strcpy(temp_unc + 2, ses->serverName);
2865 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2866 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2867 nls_codepage);
2868 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
2869 kfree(temp_unc);
2870 }
2871 if (rc == 0)
2872 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2873 referrals, num_referrals,
2874 nls_codepage, remap);
2875 /*
2876 * BB - map targetUNCs to dfs_info3 structures, here or in
2877 * ses->server->ops->get_dfs_refer.
2878 */
2879
2880 return rc;
2881 }
2882
2883 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2884 static struct lock_class_key cifs_key[2];
2885 static struct lock_class_key cifs_slock_key[2];
2886
2887 static inline void
2888 cifs_reclassify_socket4(struct socket *sock)
2889 {
2890 struct sock *sk = sock->sk;
2891 BUG_ON(!sock_allow_reclassification(sk));
2892 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2893 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2894 }
2895
2896 static inline void
2897 cifs_reclassify_socket6(struct socket *sock)
2898 {
2899 struct sock *sk = sock->sk;
2900 BUG_ON(!sock_allow_reclassification(sk));
2901 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2902 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2903 }
2904 #else
2905 static inline void
2906 cifs_reclassify_socket4(struct socket *sock)
2907 {
2908 }
2909
2910 static inline void
2911 cifs_reclassify_socket6(struct socket *sock)
2912 {
2913 }
2914 #endif
2915
2916 /* See RFC1001 section 14 on representation of Netbios names */
2917 static void rfc1002mangle(char *target, char *source, unsigned int length)
2918 {
2919 unsigned int i, j;
2920
2921 for (i = 0, j = 0; i < (length); i++) {
2922 /* mask a nibble at a time and encode */
2923 target[j] = 'A' + (0x0F & (source[i] >> 4));
2924 target[j+1] = 'A' + (0x0F & source[i]);
2925 j += 2;
2926 }
2927
2928 }
2929
2930 static int
2931 bind_socket(struct TCP_Server_Info *server)
2932 {
2933 int rc = 0;
2934 if (server->srcaddr.ss_family != AF_UNSPEC) {
2935 /* Bind to the specified local IP address */
2936 struct socket *socket = server->ssocket;
2937 rc = socket->ops->bind(socket,
2938 (struct sockaddr *) &server->srcaddr,
2939 sizeof(server->srcaddr));
2940 if (rc < 0) {
2941 struct sockaddr_in *saddr4;
2942 struct sockaddr_in6 *saddr6;
2943 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2944 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2945 if (saddr6->sin6_family == AF_INET6)
2946 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2947 &saddr6->sin6_addr, rc);
2948 else
2949 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2950 &saddr4->sin_addr.s_addr, rc);
2951 }
2952 }
2953 return rc;
2954 }
2955
2956 static int
2957 ip_rfc1001_connect(struct TCP_Server_Info *server)
2958 {
2959 int rc = 0;
2960 /*
2961 * some servers require RFC1001 sessinit before sending
2962 * negprot - BB check reconnection in case where second
2963 * sessinit is sent but no second negprot
2964 */
2965 struct rfc1002_session_packet *ses_init_buf;
2966 struct smb_hdr *smb_buf;
2967 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2968 GFP_KERNEL);
2969 if (ses_init_buf) {
2970 ses_init_buf->trailer.session_req.called_len = 32;
2971
2972 if (server->server_RFC1001_name[0] != 0)
2973 rfc1002mangle(ses_init_buf->trailer.
2974 session_req.called_name,
2975 server->server_RFC1001_name,
2976 RFC1001_NAME_LEN_WITH_NULL);
2977 else
2978 rfc1002mangle(ses_init_buf->trailer.
2979 session_req.called_name,
2980 DEFAULT_CIFS_CALLED_NAME,
2981 RFC1001_NAME_LEN_WITH_NULL);
2982
2983 ses_init_buf->trailer.session_req.calling_len = 32;
2984
2985 /*
2986 * calling name ends in null (byte 16) from old smb
2987 * convention.
2988 */
2989 if (server->workstation_RFC1001_name[0] != 0)
2990 rfc1002mangle(ses_init_buf->trailer.
2991 session_req.calling_name,
2992 server->workstation_RFC1001_name,
2993 RFC1001_NAME_LEN_WITH_NULL);
2994 else
2995 rfc1002mangle(ses_init_buf->trailer.
2996 session_req.calling_name,
2997 "LINUX_CIFS_CLNT",
2998 RFC1001_NAME_LEN_WITH_NULL);
2999
3000 ses_init_buf->trailer.session_req.scope1 = 0;
3001 ses_init_buf->trailer.session_req.scope2 = 0;
3002 smb_buf = (struct smb_hdr *)ses_init_buf;
3003
3004 /* sizeof RFC1002_SESSION_REQUEST with no scope */
3005 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
3006 rc = smb_send(server, smb_buf, 0x44);
3007 kfree(ses_init_buf);
3008 /*
3009 * RFC1001 layer in at least one server
3010 * requires very short break before negprot
3011 * presumably because not expecting negprot
3012 * to follow so fast. This is a simple
3013 * solution that works without
3014 * complicating the code and causes no
3015 * significant slowing down on mount
3016 * for everyone else
3017 */
3018 usleep_range(1000, 2000);
3019 }
3020 /*
3021 * else the negprot may still work without this
3022 * even though malloc failed
3023 */
3024
3025 return rc;
3026 }
3027
3028 static int
3029 generic_ip_connect(struct TCP_Server_Info *server)
3030 {
3031 int rc = 0;
3032 __be16 sport;
3033 int slen, sfamily;
3034 struct socket *socket = server->ssocket;
3035 struct sockaddr *saddr;
3036
3037 saddr = (struct sockaddr *) &server->dstaddr;
3038
3039 if (server->dstaddr.ss_family == AF_INET6) {
3040 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
3041 slen = sizeof(struct sockaddr_in6);
3042 sfamily = AF_INET6;
3043 } else {
3044 sport = ((struct sockaddr_in *) saddr)->sin_port;
3045 slen = sizeof(struct sockaddr_in);
3046 sfamily = AF_INET;
3047 }
3048
3049 if (socket == NULL) {
3050 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
3051 IPPROTO_TCP, &socket, 1);
3052 if (rc < 0) {
3053 cifs_dbg(VFS, "Error %d creating socket\n", rc);
3054 server->ssocket = NULL;
3055 return rc;
3056 }
3057
3058 /* BB other socket options to set KEEPALIVE, NODELAY? */
3059 cifs_dbg(FYI, "Socket created\n");
3060 server->ssocket = socket;
3061 socket->sk->sk_allocation = GFP_NOFS;
3062 if (sfamily == AF_INET6)
3063 cifs_reclassify_socket6(socket);
3064 else
3065 cifs_reclassify_socket4(socket);
3066 }
3067
3068 rc = bind_socket(server);
3069 if (rc < 0)
3070 return rc;
3071
3072 /*
3073 * Eventually check for other socket options to change from
3074 * the default. sock_setsockopt not used because it expects
3075 * user space buffer
3076 */
3077 socket->sk->sk_rcvtimeo = 7 * HZ;
3078 socket->sk->sk_sndtimeo = 5 * HZ;
3079
3080 /* make the bufsizes depend on wsize/rsize and max requests */
3081 if (server->noautotune) {
3082 if (socket->sk->sk_sndbuf < (200 * 1024))
3083 socket->sk->sk_sndbuf = 200 * 1024;
3084 if (socket->sk->sk_rcvbuf < (140 * 1024))
3085 socket->sk->sk_rcvbuf = 140 * 1024;
3086 }
3087
3088 if (server->tcp_nodelay) {
3089 int val = 1;
3090 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3091 (char *)&val, sizeof(val));
3092 if (rc)
3093 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3094 rc);
3095 }
3096
3097 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3098 socket->sk->sk_sndbuf,
3099 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3100
3101 rc = socket->ops->connect(socket, saddr, slen, 0);
3102 if (rc < 0) {
3103 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3104 sock_release(socket);
3105 server->ssocket = NULL;
3106 return rc;
3107 }
3108
3109 if (sport == htons(RFC1001_PORT))
3110 rc = ip_rfc1001_connect(server);
3111
3112 return rc;
3113 }
3114
3115 static int
3116 ip_connect(struct TCP_Server_Info *server)
3117 {
3118 __be16 *sport;
3119 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3120 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3121
3122 if (server->dstaddr.ss_family == AF_INET6)
3123 sport = &addr6->sin6_port;
3124 else
3125 sport = &addr->sin_port;
3126
3127 if (*sport == 0) {
3128 int rc;
3129
3130 /* try with 445 port at first */
3131 *sport = htons(CIFS_PORT);
3132
3133 rc = generic_ip_connect(server);
3134 if (rc >= 0)
3135 return rc;
3136
3137 /* if it failed, try with 139 port */
3138 *sport = htons(RFC1001_PORT);
3139 }
3140
3141 return generic_ip_connect(server);
3142 }
3143
3144 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3145 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3146 {
3147 /* if we are reconnecting then should we check to see if
3148 * any requested capabilities changed locally e.g. via
3149 * remount but we can not do much about it here
3150 * if they have (even if we could detect it by the following)
3151 * Perhaps we could add a backpointer to array of sb from tcon
3152 * or if we change to make all sb to same share the same
3153 * sb as NFS - then we only have one backpointer to sb.
3154 * What if we wanted to mount the server share twice once with
3155 * and once without posixacls or posix paths? */
3156 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3157
3158 if (vol_info && vol_info->no_linux_ext) {
3159 tcon->fsUnixInfo.Capability = 0;
3160 tcon->unix_ext = 0; /* Unix Extensions disabled */
3161 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3162 return;
3163 } else if (vol_info)
3164 tcon->unix_ext = 1; /* Unix Extensions supported */
3165
3166 if (tcon->unix_ext == 0) {
3167 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3168 return;
3169 }
3170
3171 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3172 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3173 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3174 /* check for reconnect case in which we do not
3175 want to change the mount behavior if we can avoid it */
3176 if (vol_info == NULL) {
3177 /* turn off POSIX ACL and PATHNAMES if not set
3178 originally at mount time */
3179 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3180 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3181 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3182 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3183 cifs_dbg(VFS, "POSIXPATH support change\n");
3184 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3185 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3186 cifs_dbg(VFS, "possible reconnect error\n");
3187 cifs_dbg(VFS, "server disabled POSIX path support\n");
3188 }
3189 }
3190
3191 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3192 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3193
3194 cap &= CIFS_UNIX_CAP_MASK;
3195 if (vol_info && vol_info->no_psx_acl)
3196 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3197 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3198 cifs_dbg(FYI, "negotiated posix acl support\n");
3199 if (cifs_sb)
3200 cifs_sb->mnt_cifs_flags |=
3201 CIFS_MOUNT_POSIXACL;
3202 }
3203
3204 if (vol_info && vol_info->posix_paths == 0)
3205 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3206 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3207 cifs_dbg(FYI, "negotiate posix pathnames\n");
3208 if (cifs_sb)
3209 cifs_sb->mnt_cifs_flags |=
3210 CIFS_MOUNT_POSIX_PATHS;
3211 }
3212
3213 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3214 #ifdef CONFIG_CIFS_DEBUG2
3215 if (cap & CIFS_UNIX_FCNTL_CAP)
3216 cifs_dbg(FYI, "FCNTL cap\n");
3217 if (cap & CIFS_UNIX_EXTATTR_CAP)
3218 cifs_dbg(FYI, "EXTATTR cap\n");
3219 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3220 cifs_dbg(FYI, "POSIX path cap\n");
3221 if (cap & CIFS_UNIX_XATTR_CAP)
3222 cifs_dbg(FYI, "XATTR cap\n");
3223 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3224 cifs_dbg(FYI, "POSIX ACL cap\n");
3225 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3226 cifs_dbg(FYI, "very large read cap\n");
3227 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3228 cifs_dbg(FYI, "very large write cap\n");
3229 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3230 cifs_dbg(FYI, "transport encryption cap\n");
3231 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3232 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3233 #endif /* CIFS_DEBUG2 */
3234 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3235 if (vol_info == NULL) {
3236 cifs_dbg(FYI, "resetting capabilities failed\n");
3237 } else
3238 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");
3239
3240 }
3241 }
3242 }
3243
3244 int cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3245 struct cifs_sb_info *cifs_sb)
3246 {
3247 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3248
3249 spin_lock_init(&cifs_sb->tlink_tree_lock);
3250 cifs_sb->tlink_tree = RB_ROOT;
3251
3252 /*
3253 * Temporarily set r/wsize for matching superblock. If we end up using
3254 * new sb then client will later negotiate it downward if needed.
3255 */
3256 cifs_sb->rsize = pvolume_info->rsize;
3257 cifs_sb->wsize = pvolume_info->wsize;
3258
3259 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3260 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3261 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3262 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3263 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3264 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3265
3266 cifs_sb->actimeo = pvolume_info->actimeo;
3267 cifs_sb->local_nls = pvolume_info->local_nls;
3268
3269 if (pvolume_info->noperm)
3270 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3271 if (pvolume_info->setuids)
3272 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3273 if (pvolume_info->server_ino)
3274 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3275 if (pvolume_info->remap)
3276 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SFM_CHR;
3277 if (pvolume_info->sfu_remap)
3278 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3279 if (pvolume_info->no_xattr)
3280 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3281 if (pvolume_info->sfu_emul)
3282 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3283 if (pvolume_info->nobrl)
3284 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3285 if (pvolume_info->nostrictsync)
3286 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3287 if (pvolume_info->mand_lock)
3288 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3289 if (pvolume_info->rwpidforward)
3290 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3291 if (pvolume_info->cifs_acl)
3292 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3293 if (pvolume_info->backupuid_specified) {
3294 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3295 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3296 }
3297 if (pvolume_info->backupgid_specified) {
3298 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3299 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3300 }
3301 if (pvolume_info->override_uid)
3302 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3303 if (pvolume_info->override_gid)
3304 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3305 if (pvolume_info->dynperm)
3306 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3307 if (pvolume_info->fsc)
3308 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3309 if (pvolume_info->multiuser)
3310 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3311 CIFS_MOUNT_NO_PERM);
3312 if (pvolume_info->strict_io)
3313 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3314 if (pvolume_info->direct_io) {
3315 cifs_dbg(FYI, "mounting share using direct i/o\n");
3316 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3317 }
3318 if (pvolume_info->mfsymlinks) {
3319 if (pvolume_info->sfu_emul) {
3320 /*
3321 * Our SFU ("Services for Unix" emulation does not allow
3322 * creating symlinks but does allow reading existing SFU
3323 * symlinks (it does allow both creating and reading SFU
3324 * style mknod and FIFOs though). When "mfsymlinks" and
3325 * "sfu" are both enabled at the same time, it allows
3326 * reading both types of symlinks, but will only create
3327 * them with mfsymlinks format. This allows better
3328 * Apple compatibility (probably better for Samba too)
3329 * while still recognizing old Windows style symlinks.
3330 */
3331 cifs_dbg(VFS, "mount options mfsymlinks and sfu both enabled\n");
3332 }
3333 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3334 }
3335
3336 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3337 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3338
3339 if (pvolume_info->prepath) {
3340 cifs_sb->prepath = kstrdup(pvolume_info->prepath, GFP_KERNEL);
3341 if (cifs_sb->prepath == NULL)
3342 return -ENOMEM;
3343 }
3344
3345 return 0;
3346 }
3347
3348 static void
3349 cleanup_volume_info_contents(struct smb_vol *volume_info)
3350 {
3351 kfree(volume_info->username);
3352 kzfree(volume_info->password);
3353 kfree(volume_info->UNC);
3354 kfree(volume_info->domainname);
3355 kfree(volume_info->iocharset);
3356 kfree(volume_info->prepath);
3357 }
3358
3359 void
3360 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3361 {
3362 if (!volume_info)
3363 return;
3364 cleanup_volume_info_contents(volume_info);
3365 kfree(volume_info);
3366 }
3367
3368
3369 #ifdef CONFIG_CIFS_DFS_UPCALL
3370 /*
3371 * cifs_build_path_to_root returns full path to root when we do not have an
3372 * exiting connection (tcon)
3373 */
3374 static char *
3375 build_unc_path_to_root(const struct smb_vol *vol,
3376 const struct cifs_sb_info *cifs_sb)
3377 {
3378 char *full_path, *pos;
3379 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3380 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3381
3382 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3383 if (full_path == NULL)
3384 return ERR_PTR(-ENOMEM);
3385
3386 strncpy(full_path, vol->UNC, unc_len);
3387 pos = full_path + unc_len;
3388
3389 if (pplen) {
3390 *pos = CIFS_DIR_SEP(cifs_sb);
3391 strncpy(pos + 1, vol->prepath, pplen);
3392 pos += pplen;
3393 }
3394
3395 *pos = '\0'; /* add trailing null */
3396 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3397 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3398 return full_path;
3399 }
3400
3401 /*
3402 * Perform a dfs referral query for a share and (optionally) prefix
3403 *
3404 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3405 * to a string containing updated options for the submount. Otherwise it
3406 * will be left untouched.
3407 *
3408 * Returns the rc from get_dfs_path to the caller, which can be used to
3409 * determine whether there were referrals.
3410 */
3411 static int
3412 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3413 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3414 int check_prefix)
3415 {
3416 int rc;
3417 unsigned int num_referrals = 0;
3418 struct dfs_info3_param *referrals = NULL;
3419 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3420
3421 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3422 if (IS_ERR(full_path))
3423 return PTR_ERR(full_path);
3424
3425 /* For DFS paths, skip the first '\' of the UNC */
3426 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3427
3428 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3429 &num_referrals, &referrals, cifs_remap(cifs_sb));
3430
3431 if (!rc && num_referrals > 0) {
3432 char *fake_devname = NULL;
3433
3434 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3435 full_path + 1, referrals,
3436 &fake_devname);
3437
3438 free_dfs_info_array(referrals, num_referrals);
3439
3440 if (IS_ERR(mdata)) {
3441 rc = PTR_ERR(mdata);
3442 mdata = NULL;
3443 } else {
3444 cleanup_volume_info_contents(volume_info);
3445 rc = cifs_setup_volume_info(volume_info, mdata,
3446 fake_devname);
3447 }
3448 kfree(fake_devname);
3449 kfree(cifs_sb->mountdata);
3450 cifs_sb->mountdata = mdata;
3451 }
3452 kfree(full_path);
3453 return rc;
3454 }
3455 #endif
3456
3457 static int
3458 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3459 const char *devname)
3460 {
3461 int rc = 0;
3462
3463 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3464 return -EINVAL;
3465
3466 if (volume_info->nullauth) {
3467 cifs_dbg(FYI, "Anonymous login\n");
3468 kfree(volume_info->username);
3469 volume_info->username = NULL;
3470 } else if (volume_info->username) {
3471 /* BB fixme parse for domain name here */
3472 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3473 } else {
3474 cifs_dbg(VFS, "No username specified\n");
3475 /* In userspace mount helper we can get user name from alternate
3476 locations such as env variables and files on disk */
3477 return -EINVAL;
3478 }
3479
3480 /* this is needed for ASCII cp to Unicode converts */
3481 if (volume_info->iocharset == NULL) {
3482 /* load_nls_default cannot return null */
3483 volume_info->local_nls = load_nls_default();
3484 } else {
3485 volume_info->local_nls = load_nls(volume_info->iocharset);
3486 if (volume_info->local_nls == NULL) {
3487 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3488 volume_info->iocharset);
3489 return -ELIBACC;
3490 }
3491 }
3492
3493 return rc;
3494 }
3495
3496 struct smb_vol *
3497 cifs_get_volume_info(char *mount_data, const char *devname)
3498 {
3499 int rc;
3500 struct smb_vol *volume_info;
3501
3502 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3503 if (!volume_info)
3504 return ERR_PTR(-ENOMEM);
3505
3506 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3507 if (rc) {
3508 cifs_cleanup_volume_info(volume_info);
3509 volume_info = ERR_PTR(rc);
3510 }
3511
3512 return volume_info;
3513 }
3514
3515 static int
3516 cifs_are_all_path_components_accessible(struct TCP_Server_Info *server,
3517 unsigned int xid,
3518 struct cifs_tcon *tcon,
3519 struct cifs_sb_info *cifs_sb,
3520 char *full_path)
3521 {
3522 int rc;
3523 char *s;
3524 char sep, tmp;
3525
3526 sep = CIFS_DIR_SEP(cifs_sb);
3527 s = full_path;
3528
3529 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb, "");
3530 while (rc == 0) {
3531 /* skip separators */
3532 while (*s == sep)
3533 s++;
3534 if (!*s)
3535 break;
3536 /* next separator */
3537 while (*s && *s != sep)
3538 s++;
3539
3540 /*
3541 * temporarily null-terminate the path at the end of
3542 * the current component
3543 */
3544 tmp = *s;
3545 *s = 0;
3546 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3547 full_path);
3548 *s = tmp;
3549 }
3550 return rc;
3551 }
3552
3553 int
3554 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3555 {
3556 int rc;
3557 unsigned int xid;
3558 struct cifs_ses *ses;
3559 struct cifs_tcon *tcon;
3560 struct TCP_Server_Info *server;
3561 char *full_path;
3562 struct tcon_link *tlink;
3563 #ifdef CONFIG_CIFS_DFS_UPCALL
3564 int referral_walks_count = 0;
3565 #endif
3566
3567 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs");
3568 if (rc)
3569 return rc;
3570
3571 #ifdef CONFIG_CIFS_DFS_UPCALL
3572 try_mount_again:
3573 /* cleanup activities if we're chasing a referral */
3574 if (referral_walks_count) {
3575 if (tcon)
3576 cifs_put_tcon(tcon);
3577 else if (ses)
3578 cifs_put_smb_ses(ses);
3579
3580 cifs_sb->mnt_cifs_flags &= ~CIFS_MOUNT_POSIX_PATHS;
3581
3582 free_xid(xid);
3583 }
3584 #endif
3585 rc = 0;
3586 tcon = NULL;
3587 ses = NULL;
3588 server = NULL;
3589 full_path = NULL;
3590 tlink = NULL;
3591
3592 xid = get_xid();
3593
3594 /* get a reference to a tcp session */
3595 server = cifs_get_tcp_session(volume_info);
3596 if (IS_ERR(server)) {
3597 rc = PTR_ERR(server);
3598 bdi_destroy(&cifs_sb->bdi);
3599 goto out;
3600 }
3601
3602 /* get a reference to a SMB session */
3603 ses = cifs_get_smb_ses(server, volume_info);
3604 if (IS_ERR(ses)) {
3605 rc = PTR_ERR(ses);
3606 ses = NULL;
3607 goto mount_fail_check;
3608 }
3609
3610 #ifdef CONFIG_CIFS_SMB2
3611 if ((volume_info->persistent == true) && ((ses->server->capabilities &
3612 SMB2_GLOBAL_CAP_PERSISTENT_HANDLES) == 0)) {
3613 cifs_dbg(VFS, "persistent handles not supported by server\n");
3614 rc = -EOPNOTSUPP;
3615 goto mount_fail_check;
3616 }
3617 #endif /* CONFIG_CIFS_SMB2*/
3618
3619 /* search for existing tcon to this server share */
3620 tcon = cifs_get_tcon(ses, volume_info);
3621 if (IS_ERR(tcon)) {
3622 rc = PTR_ERR(tcon);
3623 tcon = NULL;
3624 goto remote_path_check;
3625 }
3626
3627 /* tell server which Unix caps we support */
3628 if (cap_unix(tcon->ses)) {
3629 /* reset of caps checks mount to see if unix extensions
3630 disabled for just this mount */
3631 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3632 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3633 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3634 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3635 rc = -EACCES;
3636 goto mount_fail_check;
3637 }
3638 } else
3639 tcon->unix_ext = 0; /* server does not support them */
3640
3641 /* do not care if a following call succeed - informational */
3642 if (!tcon->ipc && server->ops->qfs_tcon)
3643 server->ops->qfs_tcon(xid, tcon);
3644
3645 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3646 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3647
3648 /* tune readahead according to rsize */
3649 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_SIZE;
3650
3651 remote_path_check:
3652 #ifdef CONFIG_CIFS_DFS_UPCALL
3653 /*
3654 * Perform an unconditional check for whether there are DFS
3655 * referrals for this path without prefix, to provide support
3656 * for DFS referrals from w2k8 servers which don't seem to respond
3657 * with PATH_NOT_COVERED to requests that include the prefix.
3658 * Chase the referral if found, otherwise continue normally.
3659 */
3660 if (referral_walks_count == 0) {
3661 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3662 false);
3663 if (!refrc) {
3664 referral_walks_count++;
3665 goto try_mount_again;
3666 }
3667 }
3668 #endif
3669
3670 /* check if a whole path is not remote */
3671 if (!rc && tcon) {
3672 if (!server->ops->is_path_accessible) {
3673 rc = -ENOSYS;
3674 goto mount_fail_check;
3675 }
3676 /*
3677 * cifs_build_path_to_root works only when we have a valid tcon
3678 */
3679 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3680 if (full_path == NULL) {
3681 rc = -ENOMEM;
3682 goto mount_fail_check;
3683 }
3684 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3685 full_path);
3686 if (rc != 0 && rc != -EREMOTE) {
3687 kfree(full_path);
3688 goto mount_fail_check;
3689 }
3690
3691 rc = cifs_are_all_path_components_accessible(server,
3692 xid, tcon, cifs_sb,
3693 full_path);
3694 if (rc != 0) {
3695 cifs_dbg(VFS, "cannot query dirs between root and final path, "
3696 "enabling CIFS_MOUNT_USE_PREFIX_PATH\n");
3697 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_USE_PREFIX_PATH;
3698 rc = 0;
3699 }
3700 kfree(full_path);
3701 }
3702
3703 /* get referral if needed */
3704 if (rc == -EREMOTE) {
3705 #ifdef CONFIG_CIFS_DFS_UPCALL
3706 if (referral_walks_count > MAX_NESTED_LINKS) {
3707 /*
3708 * BB: when we implement proper loop detection,
3709 * we will remove this check. But now we need it
3710 * to prevent an indefinite loop if 'DFS tree' is
3711 * misconfigured (i.e. has loops).
3712 */
3713 rc = -ELOOP;
3714 goto mount_fail_check;
3715 }
3716
3717 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3718
3719 if (!rc) {
3720 referral_walks_count++;
3721 goto try_mount_again;
3722 }
3723 goto mount_fail_check;
3724 #else /* No DFS support, return error on mount */
3725 rc = -EOPNOTSUPP;
3726 #endif
3727 }
3728
3729 if (rc)
3730 goto mount_fail_check;
3731
3732 /* now, hang the tcon off of the superblock */
3733 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3734 if (tlink == NULL) {
3735 rc = -ENOMEM;
3736 goto mount_fail_check;
3737 }
3738
3739 tlink->tl_uid = ses->linux_uid;
3740 tlink->tl_tcon = tcon;
3741 tlink->tl_time = jiffies;
3742 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3743 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3744
3745 cifs_sb->master_tlink = tlink;
3746 spin_lock(&cifs_sb->tlink_tree_lock);
3747 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3748 spin_unlock(&cifs_sb->tlink_tree_lock);
3749
3750 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3751 TLINK_IDLE_EXPIRE);
3752
3753 mount_fail_check:
3754 /* on error free sesinfo and tcon struct if needed */
3755 if (rc) {
3756 /* If find_unc succeeded then rc == 0 so we can not end */
3757 /* up accidentally freeing someone elses tcon struct */
3758 if (tcon)
3759 cifs_put_tcon(tcon);
3760 else if (ses)
3761 cifs_put_smb_ses(ses);
3762 else
3763 cifs_put_tcp_session(server);
3764 bdi_destroy(&cifs_sb->bdi);
3765 }
3766
3767 out:
3768 free_xid(xid);
3769 return rc;
3770 }
3771
3772 /*
3773 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3774 * pointer may be NULL.
3775 */
3776 int
3777 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3778 const char *tree, struct cifs_tcon *tcon,
3779 const struct nls_table *nls_codepage)
3780 {
3781 struct smb_hdr *smb_buffer;
3782 struct smb_hdr *smb_buffer_response;
3783 TCONX_REQ *pSMB;
3784 TCONX_RSP *pSMBr;
3785 unsigned char *bcc_ptr;
3786 int rc = 0;
3787 int length;
3788 __u16 bytes_left, count;
3789
3790 if (ses == NULL)
3791 return -EIO;
3792
3793 smb_buffer = cifs_buf_get();
3794 if (smb_buffer == NULL)
3795 return -ENOMEM;
3796
3797 smb_buffer_response = smb_buffer;
3798
3799 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3800 NULL /*no tid */ , 4 /*wct */ );
3801
3802 smb_buffer->Mid = get_next_mid(ses->server);
3803 smb_buffer->Uid = ses->Suid;
3804 pSMB = (TCONX_REQ *) smb_buffer;
3805 pSMBr = (TCONX_RSP *) smb_buffer_response;
3806
3807 pSMB->AndXCommand = 0xFF;
3808 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3809 bcc_ptr = &pSMB->Password[0];
3810 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3811 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3812 *bcc_ptr = 0; /* password is null byte */
3813 bcc_ptr++; /* skip password */
3814 /* already aligned so no need to do it below */
3815 } else {
3816 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3817 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3818 specified as required (when that support is added to
3819 the vfs in the future) as only NTLM or the much
3820 weaker LANMAN (which we do not send by default) is accepted
3821 by Samba (not sure whether other servers allow
3822 NTLMv2 password here) */
3823 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3824 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3825 (ses->sectype == LANMAN))
3826 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3827 ses->server->sec_mode &
3828 SECMODE_PW_ENCRYPT ? true : false,
3829 bcc_ptr);
3830 else
3831 #endif /* CIFS_WEAK_PW_HASH */
3832 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3833 bcc_ptr, nls_codepage);
3834 if (rc) {
3835 cifs_dbg(FYI, "%s Can't generate NTLM rsp. Error: %d\n",
3836 __func__, rc);
3837 cifs_buf_release(smb_buffer);
3838 return rc;
3839 }
3840
3841 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3842 if (ses->capabilities & CAP_UNICODE) {
3843 /* must align unicode strings */
3844 *bcc_ptr = 0; /* null byte password */
3845 bcc_ptr++;
3846 }
3847 }
3848
3849 if (ses->server->sign)
3850 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3851
3852 if (ses->capabilities & CAP_STATUS32) {
3853 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3854 }
3855 if (ses->capabilities & CAP_DFS) {
3856 smb_buffer->Flags2 |= SMBFLG2_DFS;
3857 }
3858 if (ses->capabilities & CAP_UNICODE) {
3859 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3860 length =
3861 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3862 6 /* max utf8 char length in bytes */ *
3863 (/* server len*/ + 256 /* share len */), nls_codepage);
3864 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3865 bcc_ptr += 2; /* skip trailing null */
3866 } else { /* ASCII */
3867 strcpy(bcc_ptr, tree);
3868 bcc_ptr += strlen(tree) + 1;
3869 }
3870 strcpy(bcc_ptr, "?????");
3871 bcc_ptr += strlen("?????");
3872 bcc_ptr += 1;
3873 count = bcc_ptr - &pSMB->Password[0];
3874 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3875 pSMB->hdr.smb_buf_length) + count);
3876 pSMB->ByteCount = cpu_to_le16(count);
3877
3878 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3879 0);
3880
3881 /* above now done in SendReceive */
3882 if ((rc == 0) && (tcon != NULL)) {
3883 bool is_unicode;
3884
3885 tcon->tidStatus = CifsGood;
3886 tcon->need_reconnect = false;
3887 tcon->tid = smb_buffer_response->Tid;
3888 bcc_ptr = pByteArea(smb_buffer_response);
3889 bytes_left = get_bcc(smb_buffer_response);
3890 length = strnlen(bcc_ptr, bytes_left - 2);
3891 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3892 is_unicode = true;
3893 else
3894 is_unicode = false;
3895
3896
3897 /* skip service field (NB: this field is always ASCII) */
3898 if (length == 3) {
3899 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3900 (bcc_ptr[2] == 'C')) {
3901 cifs_dbg(FYI, "IPC connection\n");
3902 tcon->ipc = 1;
3903 }
3904 } else if (length == 2) {
3905 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3906 /* the most common case */
3907 cifs_dbg(FYI, "disk share connection\n");
3908 }
3909 }
3910 bcc_ptr += length + 1;
3911 bytes_left -= (length + 1);
3912 strlcpy(tcon->treeName, tree, sizeof(tcon->treeName));
3913
3914 /* mostly informational -- no need to fail on error here */
3915 kfree(tcon->nativeFileSystem);
3916 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3917 bytes_left, is_unicode,
3918 nls_codepage);
3919
3920 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
3921
3922 if ((smb_buffer_response->WordCount == 3) ||
3923 (smb_buffer_response->WordCount == 7))
3924 /* field is in same location */
3925 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3926 else
3927 tcon->Flags = 0;
3928 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
3929 } else if ((rc == 0) && tcon == NULL) {
3930 /* all we need to save for IPC$ connection */
3931 ses->ipc_tid = smb_buffer_response->Tid;
3932 }
3933
3934 cifs_buf_release(smb_buffer);
3935 return rc;
3936 }
3937
3938 static void delayed_free(struct rcu_head *p)
3939 {
3940 struct cifs_sb_info *sbi = container_of(p, struct cifs_sb_info, rcu);
3941 unload_nls(sbi->local_nls);
3942 kfree(sbi);
3943 }
3944
3945 void
3946 cifs_umount(struct cifs_sb_info *cifs_sb)
3947 {
3948 struct rb_root *root = &cifs_sb->tlink_tree;
3949 struct rb_node *node;
3950 struct tcon_link *tlink;
3951
3952 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3953
3954 spin_lock(&cifs_sb->tlink_tree_lock);
3955 while ((node = rb_first(root))) {
3956 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3957 cifs_get_tlink(tlink);
3958 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3959 rb_erase(node, root);
3960
3961 spin_unlock(&cifs_sb->tlink_tree_lock);
3962 cifs_put_tlink(tlink);
3963 spin_lock(&cifs_sb->tlink_tree_lock);
3964 }
3965 spin_unlock(&cifs_sb->tlink_tree_lock);
3966
3967 bdi_destroy(&cifs_sb->bdi);
3968 kfree(cifs_sb->mountdata);
3969 kfree(cifs_sb->prepath);
3970 call_rcu(&cifs_sb->rcu, delayed_free);
3971 }
3972
3973 int
3974 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3975 {
3976 int rc = 0;
3977 struct TCP_Server_Info *server = ses->server;
3978
3979 if (!server->ops->need_neg || !server->ops->negotiate)
3980 return -ENOSYS;
3981
3982 /* only send once per connect */
3983 if (!server->ops->need_neg(server))
3984 return 0;
3985
3986 set_credits(server, 1);
3987
3988 rc = server->ops->negotiate(xid, ses);
3989 if (rc == 0) {
3990 spin_lock(&GlobalMid_Lock);
3991 if (server->tcpStatus == CifsNeedNegotiate)
3992 server->tcpStatus = CifsGood;
3993 else
3994 rc = -EHOSTDOWN;
3995 spin_unlock(&GlobalMid_Lock);
3996 }
3997
3998 return rc;
3999 }
4000
4001 int
4002 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
4003 struct nls_table *nls_info)
4004 {
4005 int rc = -ENOSYS;
4006 struct TCP_Server_Info *server = ses->server;
4007
4008 ses->capabilities = server->capabilities;
4009 if (linuxExtEnabled == 0)
4010 ses->capabilities &= (~server->vals->cap_unix);
4011
4012 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
4013 server->sec_mode, server->capabilities, server->timeAdj);
4014
4015 if (server->ops->sess_setup)
4016 rc = server->ops->sess_setup(xid, ses, nls_info);
4017
4018 if (rc)
4019 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
4020
4021 return rc;
4022 }
4023
4024 static int
4025 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4026 {
4027 vol->sectype = ses->sectype;
4028
4029 /* krb5 is special, since we don't need username or pw */
4030 if (vol->sectype == Kerberos)
4031 return 0;
4032
4033 return cifs_set_cifscreds(vol, ses);
4034 }
4035
4036 static struct cifs_tcon *
4037 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
4038 {
4039 int rc;
4040 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4041 struct cifs_ses *ses;
4042 struct cifs_tcon *tcon = NULL;
4043 struct smb_vol *vol_info;
4044
4045 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4046 if (vol_info == NULL)
4047 return ERR_PTR(-ENOMEM);
4048
4049 vol_info->local_nls = cifs_sb->local_nls;
4050 vol_info->linux_uid = fsuid;
4051 vol_info->cred_uid = fsuid;
4052 vol_info->UNC = master_tcon->treeName;
4053 vol_info->retry = master_tcon->retry;
4054 vol_info->nocase = master_tcon->nocase;
4055 vol_info->local_lease = master_tcon->local_lease;
4056 vol_info->no_linux_ext = !master_tcon->unix_ext;
4057 vol_info->sectype = master_tcon->ses->sectype;
4058 vol_info->sign = master_tcon->ses->sign;
4059
4060 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4061 if (rc) {
4062 tcon = ERR_PTR(rc);
4063 goto out;
4064 }
4065
4066 /* get a reference for the same TCP session */
4067 spin_lock(&cifs_tcp_ses_lock);
4068 ++master_tcon->ses->server->srv_count;
4069 spin_unlock(&cifs_tcp_ses_lock);
4070
4071 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4072 if (IS_ERR(ses)) {
4073 tcon = (struct cifs_tcon *)ses;
4074 cifs_put_tcp_session(master_tcon->ses->server);
4075 goto out;
4076 }
4077
4078 tcon = cifs_get_tcon(ses, vol_info);
4079 if (IS_ERR(tcon)) {
4080 cifs_put_smb_ses(ses);
4081 goto out;
4082 }
4083
4084 if (cap_unix(ses))
4085 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4086 out:
4087 kfree(vol_info->username);
4088 kfree(vol_info->password);
4089 kfree(vol_info);
4090
4091 return tcon;
4092 }
4093
4094 struct cifs_tcon *
4095 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4096 {
4097 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4098 }
4099
4100 /* find and return a tlink with given uid */
4101 static struct tcon_link *
4102 tlink_rb_search(struct rb_root *root, kuid_t uid)
4103 {
4104 struct rb_node *node = root->rb_node;
4105 struct tcon_link *tlink;
4106
4107 while (node) {
4108 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4109
4110 if (uid_gt(tlink->tl_uid, uid))
4111 node = node->rb_left;
4112 else if (uid_lt(tlink->tl_uid, uid))
4113 node = node->rb_right;
4114 else
4115 return tlink;
4116 }
4117 return NULL;
4118 }
4119
4120 /* insert a tcon_link into the tree */
4121 static void
4122 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4123 {
4124 struct rb_node **new = &(root->rb_node), *parent = NULL;
4125 struct tcon_link *tlink;
4126
4127 while (*new) {
4128 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4129 parent = *new;
4130
4131 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4132 new = &((*new)->rb_left);
4133 else
4134 new = &((*new)->rb_right);
4135 }
4136
4137 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4138 rb_insert_color(&new_tlink->tl_rbnode, root);
4139 }
4140
4141 /*
4142 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4143 * current task.
4144 *
4145 * If the superblock doesn't refer to a multiuser mount, then just return
4146 * the master tcon for the mount.
4147 *
4148 * First, search the rbtree for an existing tcon for this fsuid. If one
4149 * exists, then check to see if it's pending construction. If it is then wait
4150 * for construction to complete. Once it's no longer pending, check to see if
4151 * it failed and either return an error or retry construction, depending on
4152 * the timeout.
4153 *
4154 * If one doesn't exist then insert a new tcon_link struct into the tree and
4155 * try to construct a new one.
4156 */
4157 struct tcon_link *
4158 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4159 {
4160 int ret;
4161 kuid_t fsuid = current_fsuid();
4162 struct tcon_link *tlink, *newtlink;
4163
4164 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4165 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4166
4167 spin_lock(&cifs_sb->tlink_tree_lock);
4168 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4169 if (tlink)
4170 cifs_get_tlink(tlink);
4171 spin_unlock(&cifs_sb->tlink_tree_lock);
4172
4173 if (tlink == NULL) {
4174 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4175 if (newtlink == NULL)
4176 return ERR_PTR(-ENOMEM);
4177 newtlink->tl_uid = fsuid;
4178 newtlink->tl_tcon = ERR_PTR(-EACCES);
4179 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4180 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4181 cifs_get_tlink(newtlink);
4182
4183 spin_lock(&cifs_sb->tlink_tree_lock);
4184 /* was one inserted after previous search? */
4185 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4186 if (tlink) {
4187 cifs_get_tlink(tlink);
4188 spin_unlock(&cifs_sb->tlink_tree_lock);
4189 kfree(newtlink);
4190 goto wait_for_construction;
4191 }
4192 tlink = newtlink;
4193 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4194 spin_unlock(&cifs_sb->tlink_tree_lock);
4195 } else {
4196 wait_for_construction:
4197 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4198 TASK_INTERRUPTIBLE);
4199 if (ret) {
4200 cifs_put_tlink(tlink);
4201 return ERR_PTR(-ERESTARTSYS);
4202 }
4203
4204 /* if it's good, return it */
4205 if (!IS_ERR(tlink->tl_tcon))
4206 return tlink;
4207
4208 /* return error if we tried this already recently */
4209 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4210 cifs_put_tlink(tlink);
4211 return ERR_PTR(-EACCES);
4212 }
4213
4214 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4215 goto wait_for_construction;
4216 }
4217
4218 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4219 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4220 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4221
4222 if (IS_ERR(tlink->tl_tcon)) {
4223 cifs_put_tlink(tlink);
4224 return ERR_PTR(-EACCES);
4225 }
4226
4227 return tlink;
4228 }
4229
4230 /*
4231 * periodic workqueue job that scans tcon_tree for a superblock and closes
4232 * out tcons.
4233 */
4234 static void
4235 cifs_prune_tlinks(struct work_struct *work)
4236 {
4237 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4238 prune_tlinks.work);
4239 struct rb_root *root = &cifs_sb->tlink_tree;
4240 struct rb_node *node = rb_first(root);
4241 struct rb_node *tmp;
4242 struct tcon_link *tlink;
4243
4244 /*
4245 * Because we drop the spinlock in the loop in order to put the tlink
4246 * it's not guarded against removal of links from the tree. The only
4247 * places that remove entries from the tree are this function and
4248 * umounts. Because this function is non-reentrant and is canceled
4249 * before umount can proceed, this is safe.
4250 */
4251 spin_lock(&cifs_sb->tlink_tree_lock);
4252 node = rb_first(root);
4253 while (node != NULL) {
4254 tmp = node;
4255 node = rb_next(tmp);
4256 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4257
4258 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4259 atomic_read(&tlink->tl_count) != 0 ||
4260 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4261 continue;
4262
4263 cifs_get_tlink(tlink);
4264 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4265 rb_erase(tmp, root);
4266
4267 spin_unlock(&cifs_sb->tlink_tree_lock);
4268 cifs_put_tlink(tlink);
4269 spin_lock(&cifs_sb->tlink_tree_lock);
4270 }
4271 spin_unlock(&cifs_sb->tlink_tree_lock);
4272
4273 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4274 TLINK_IDLE_EXPIRE);
4275 }
A mirror of Linus' kernel repository