]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - fs/cifs/connect.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:


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