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