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