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