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