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