]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - fs/cifs/connect.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:


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