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