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