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