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