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