projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'timers-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[deliverable/linux.git] / fs / cifs / connect.c
1 /*
2 * fs/cifs/connect.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2011
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21 #include <linux/fs.h>
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/slab.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <linux/namei.h>
37 #include <asm/uaccess.h>
38 #include <asm/processor.h>
39 #include <linux/inet.h>
40 #include <linux/module.h>
41 #include <keys/user-type.h>
42 #include <net/ipv6.h>
43 #include <linux/parser.h>
44
45 #include "cifspdu.h"
46 #include "cifsglob.h"
47 #include "cifsproto.h"
48 #include "cifs_unicode.h"
49 #include "cifs_debug.h"
50 #include "cifs_fs_sb.h"
51 #include "ntlmssp.h"
52 #include "nterr.h"
53 #include "rfc1002pdu.h"
54 #include "fscache.h"
55
56 #define CIFS_PORT 445
57 #define RFC1001_PORT 139
58
59 /* 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 /*
3449 * On hosts with high memory, we can't currently support wsize/rsize that are
3450 * larger than we can kmap at once. Cap the rsize/wsize at
3451 * LAST_PKMAP * PAGE_SIZE. We'll never be able to fill a read or write request
3452 * larger than that anyway.
3453 */
3454 #ifdef CONFIG_HIGHMEM
3455 #define CIFS_KMAP_SIZE_LIMIT (LAST_PKMAP * PAGE_CACHE_SIZE)
3456 #else /* CONFIG_HIGHMEM */
3457 #define CIFS_KMAP_SIZE_LIMIT (1<<24)
3458 #endif /* CONFIG_HIGHMEM */
3459
3460 static unsigned int
3461 cifs_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3462 {
3463 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3464 struct TCP_Server_Info *server = tcon->ses->server;
3465 unsigned int wsize;
3466
3467 /* start with specified wsize, or default */
3468 if (pvolume_info->wsize)
3469 wsize = pvolume_info->wsize;
3470 else if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3471 wsize = CIFS_DEFAULT_IOSIZE;
3472 else
3473 wsize = CIFS_DEFAULT_NON_POSIX_WSIZE;
3474
3475 /* can server support 24-bit write sizes? (via UNIX extensions) */
3476 if (!tcon->unix_ext || !(unix_cap & CIFS_UNIX_LARGE_WRITE_CAP))
3477 wsize = min_t(unsigned int, wsize, CIFS_MAX_RFC1002_WSIZE);
3478
3479 /*
3480 * no CAP_LARGE_WRITE_X or is signing enabled without CAP_UNIX set?
3481 * Limit it to max buffer offered by the server, minus the size of the
3482 * WRITEX header, not including the 4 byte RFC1001 length.
3483 */
3484 if (!(server->capabilities & CAP_LARGE_WRITE_X) ||
3485 (!(server->capabilities & CAP_UNIX) &&
3486 (server->sec_mode & (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED))))
3487 wsize = min_t(unsigned int, wsize,
3488 server->maxBuf - sizeof(WRITE_REQ) + 4);
3489
3490 /* limit to the amount that we can kmap at once */
3491 wsize = min_t(unsigned int, wsize, CIFS_KMAP_SIZE_LIMIT);
3492
3493 /* hard limit of CIFS_MAX_WSIZE */
3494 wsize = min_t(unsigned int, wsize, CIFS_MAX_WSIZE);
3495
3496 return wsize;
3497 }
3498
3499 static unsigned int
3500 cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
3501 {
3502 __u64 unix_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3503 struct TCP_Server_Info *server = tcon->ses->server;
3504 unsigned int rsize, defsize;
3505
3506 /*
3507 * Set default value...
3508 *
3509 * HACK alert! Ancient servers have very small buffers. Even though
3510 * MS-CIFS indicates that servers are only limited by the client's
3511 * bufsize for reads, testing against win98se shows that it throws
3512 * INVALID_PARAMETER errors if you try to request too large a read.
3513 * OS/2 just sends back short reads.
3514 *
3515 * If the server doesn't advertise CAP_LARGE_READ_X, then assume that
3516 * it can't handle a read request larger than its MaxBufferSize either.
3517 */
3518 if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
3519 defsize = CIFS_DEFAULT_IOSIZE;
3520 else if (server->capabilities & CAP_LARGE_READ_X)
3521 defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
3522 else
3523 defsize = server->maxBuf - sizeof(READ_RSP);
3524
3525 rsize = pvolume_info->rsize ? pvolume_info->rsize : defsize;
3526
3527 /*
3528 * no CAP_LARGE_READ_X? Then MS-CIFS states that we must limit this to
3529 * the client's MaxBufferSize.
3530 */
3531 if (!(server->capabilities & CAP_LARGE_READ_X))
3532 rsize = min_t(unsigned int, CIFSMaxBufSize, rsize);
3533
3534 /* limit to the amount that we can kmap at once */
3535 rsize = min_t(unsigned int, rsize, CIFS_KMAP_SIZE_LIMIT);
3536
3537 /* hard limit of CIFS_MAX_RSIZE */
3538 rsize = min_t(unsigned int, rsize, CIFS_MAX_RSIZE);
3539
3540 return rsize;
3541 }
3542
3543 static int
3544 is_path_accessible(int xid, struct cifs_tcon *tcon,
3545 struct cifs_sb_info *cifs_sb, const char *full_path)
3546 {
3547 int rc;
3548 FILE_ALL_INFO *pfile_info;
3549
3550 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
3551 if (pfile_info == NULL)
3552 return -ENOMEM;
3553
3554 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
3555 0 /* not legacy */, cifs_sb->local_nls,
3556 cifs_sb->mnt_cifs_flags &
3557 CIFS_MOUNT_MAP_SPECIAL_CHR);
3558
3559 if (rc == -EOPNOTSUPP || rc == -EINVAL)
3560 rc = SMBQueryInformation(xid, tcon, full_path, pfile_info,
3561 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
3562 CIFS_MOUNT_MAP_SPECIAL_CHR);
3563 kfree(pfile_info);
3564 return rc;
3565 }
3566
3567 static void
3568 cleanup_volume_info_contents(struct smb_vol *volume_info)
3569 {
3570 kfree(volume_info->username);
3571 kzfree(volume_info->password);
3572 if (volume_info->UNCip != volume_info->UNC + 2)
3573 kfree(volume_info->UNCip);
3574 kfree(volume_info->UNC);
3575 kfree(volume_info->domainname);
3576 kfree(volume_info->iocharset);
3577 kfree(volume_info->prepath);
3578 }
3579
3580 void
3581 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3582 {
3583 if (!volume_info)
3584 return;
3585 cleanup_volume_info_contents(volume_info);
3586 kfree(volume_info);
3587 }
3588
3589
3590 #ifdef CONFIG_CIFS_DFS_UPCALL
3591 /* build_path_to_root returns full path to root when
3592 * we do not have an exiting connection (tcon) */
3593 static char *
3594 build_unc_path_to_root(const struct smb_vol *vol,
3595 const struct cifs_sb_info *cifs_sb)
3596 {
3597 char *full_path, *pos;
3598 unsigned int pplen = vol->prepath ? strlen(vol->prepath) : 0;
3599 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3600
3601 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3602 if (full_path == NULL)
3603 return ERR_PTR(-ENOMEM);
3604
3605 strncpy(full_path, vol->UNC, unc_len);
3606 pos = full_path + unc_len;
3607
3608 if (pplen) {
3609 strncpy(pos, vol->prepath, pplen);
3610 pos += pplen;
3611 }
3612
3613 *pos = '\0'; /* add trailing null */
3614 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3615 cFYI(1, "%s: full_path=%s", __func__, full_path);
3616 return full_path;
3617 }
3618
3619 /*
3620 * Perform a dfs referral query for a share and (optionally) prefix
3621 *
3622 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3623 * to a string containing updated options for the submount. Otherwise it
3624 * will be left untouched.
3625 *
3626 * Returns the rc from get_dfs_path to the caller, which can be used to
3627 * determine whether there were referrals.
3628 */
3629 static int
3630 expand_dfs_referral(int xid, struct cifs_ses *pSesInfo,
3631 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3632 int check_prefix)
3633 {
3634 int rc;
3635 unsigned int num_referrals = 0;
3636 struct dfs_info3_param *referrals = NULL;
3637 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3638
3639 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3640 if (IS_ERR(full_path))
3641 return PTR_ERR(full_path);
3642
3643 /* For DFS paths, skip the first '\' of the UNC */
3644 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3645
3646 rc = get_dfs_path(xid, pSesInfo , ref_path, cifs_sb->local_nls,
3647 &num_referrals, &referrals,
3648 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3649
3650 if (!rc && num_referrals > 0) {
3651 char *fake_devname = NULL;
3652
3653 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3654 full_path + 1, referrals,
3655 &fake_devname);
3656
3657 free_dfs_info_array(referrals, num_referrals);
3658
3659 if (IS_ERR(mdata)) {
3660 rc = PTR_ERR(mdata);
3661 mdata = NULL;
3662 } else {
3663 cleanup_volume_info_contents(volume_info);
3664 memset(volume_info, '\0', sizeof(*volume_info));
3665 rc = cifs_setup_volume_info(volume_info, mdata,
3666 fake_devname);
3667 }
3668 kfree(fake_devname);
3669 kfree(cifs_sb->mountdata);
3670 cifs_sb->mountdata = mdata;
3671 }
3672 kfree(full_path);
3673 return rc;
3674 }
3675 #endif
3676
3677 static int
3678 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3679 const char *devname)
3680 {
3681 int rc = 0;
3682
3683 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3684 return -EINVAL;
3685
3686
3687 if (volume_info->nullauth) {
3688 cFYI(1, "Anonymous login");
3689 kfree(volume_info->username);
3690 volume_info->username = NULL;
3691 } else if (volume_info->username) {
3692 /* BB fixme parse for domain name here */
3693 cFYI(1, "Username: %s", volume_info->username);
3694 } else {
3695 cifserror("No username specified");
3696 /* In userspace mount helper we can get user name from alternate
3697 locations such as env variables and files on disk */
3698 return -EINVAL;
3699 }
3700
3701 /* this is needed for ASCII cp to Unicode converts */
3702 if (volume_info->iocharset == NULL) {
3703 /* load_nls_default cannot return null */
3704 volume_info->local_nls = load_nls_default();
3705 } else {
3706 volume_info->local_nls = load_nls(volume_info->iocharset);
3707 if (volume_info->local_nls == NULL) {
3708 cERROR(1, "CIFS mount error: iocharset %s not found",
3709 volume_info->iocharset);
3710 return -ELIBACC;
3711 }
3712 }
3713
3714 return rc;
3715 }
3716
3717 struct smb_vol *
3718 cifs_get_volume_info(char *mount_data, const char *devname)
3719 {
3720 int rc;
3721 struct smb_vol *volume_info;
3722
3723 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
3724 if (!volume_info)
3725 return ERR_PTR(-ENOMEM);
3726
3727 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3728 if (rc) {
3729 cifs_cleanup_volume_info(volume_info);
3730 volume_info = ERR_PTR(rc);
3731 }
3732
3733 return volume_info;
3734 }
3735
3736 int
3737 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3738 {
3739 int rc;
3740 int xid;
3741 struct cifs_ses *pSesInfo;
3742 struct cifs_tcon *tcon;
3743 struct TCP_Server_Info *srvTcp;
3744 char *full_path;
3745 struct tcon_link *tlink;
3746 #ifdef CONFIG_CIFS_DFS_UPCALL
3747 int referral_walks_count = 0;
3748 #endif
3749
3750 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3751 if (rc)
3752 return rc;
3753
3754 #ifdef CONFIG_CIFS_DFS_UPCALL
3755 try_mount_again:
3756 /* cleanup activities if we're chasing a referral */
3757 if (referral_walks_count) {
3758 if (tcon)
3759 cifs_put_tcon(tcon);
3760 else if (pSesInfo)
3761 cifs_put_smb_ses(pSesInfo);
3762
3763 FreeXid(xid);
3764 }
3765 #endif
3766 rc = 0;
3767 tcon = NULL;
3768 pSesInfo = NULL;
3769 srvTcp = NULL;
3770 full_path = NULL;
3771 tlink = NULL;
3772
3773 xid = GetXid();
3774
3775 /* get a reference to a tcp session */
3776 srvTcp = cifs_get_tcp_session(volume_info);
3777 if (IS_ERR(srvTcp)) {
3778 rc = PTR_ERR(srvTcp);
3779 bdi_destroy(&cifs_sb->bdi);
3780 goto out;
3781 }
3782
3783 /* get a reference to a SMB session */
3784 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
3785 if (IS_ERR(pSesInfo)) {
3786 rc = PTR_ERR(pSesInfo);
3787 pSesInfo = NULL;
3788 goto mount_fail_check;
3789 }
3790
3791 /* search for existing tcon to this server share */
3792 tcon = cifs_get_tcon(pSesInfo, volume_info);
3793 if (IS_ERR(tcon)) {
3794 rc = PTR_ERR(tcon);
3795 tcon = NULL;
3796 goto remote_path_check;
3797 }
3798
3799 /* tell server which Unix caps we support */
3800 if (tcon->ses->capabilities & CAP_UNIX) {
3801 /* reset of caps checks mount to see if unix extensions
3802 disabled for just this mount */
3803 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3804 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3805 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3806 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3807 rc = -EACCES;
3808 goto mount_fail_check;
3809 }
3810 } else
3811 tcon->unix_ext = 0; /* server does not support them */
3812
3813 /* do not care if following two calls succeed - informational */
3814 if (!tcon->ipc) {
3815 CIFSSMBQFSDeviceInfo(xid, tcon);
3816 CIFSSMBQFSAttributeInfo(xid, tcon);
3817 }
3818
3819 cifs_sb->wsize = cifs_negotiate_wsize(tcon, volume_info);
3820 cifs_sb->rsize = cifs_negotiate_rsize(tcon, volume_info);
3821
3822 /* tune readahead according to rsize */
3823 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3824
3825 remote_path_check:
3826 #ifdef CONFIG_CIFS_DFS_UPCALL
3827 /*
3828 * Perform an unconditional check for whether there are DFS
3829 * referrals for this path without prefix, to provide support
3830 * for DFS referrals from w2k8 servers which don't seem to respond
3831 * with PATH_NOT_COVERED to requests that include the prefix.
3832 * Chase the referral if found, otherwise continue normally.
3833 */
3834 if (referral_walks_count == 0) {
3835 int refrc = expand_dfs_referral(xid, pSesInfo, volume_info,
3836 cifs_sb, false);
3837 if (!refrc) {
3838 referral_walks_count++;
3839 goto try_mount_again;
3840 }
3841 }
3842 #endif
3843
3844 /* check if a whole path is not remote */
3845 if (!rc && tcon) {
3846 /* build_path_to_root works only when we have a valid tcon */
3847 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3848 if (full_path == NULL) {
3849 rc = -ENOMEM;
3850 goto mount_fail_check;
3851 }
3852 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
3853 if (rc != 0 && rc != -EREMOTE) {
3854 kfree(full_path);
3855 goto mount_fail_check;
3856 }
3857 kfree(full_path);
3858 }
3859
3860 /* get referral if needed */
3861 if (rc == -EREMOTE) {
3862 #ifdef CONFIG_CIFS_DFS_UPCALL
3863 if (referral_walks_count > MAX_NESTED_LINKS) {
3864 /*
3865 * BB: when we implement proper loop detection,
3866 * we will remove this check. But now we need it
3867 * to prevent an indefinite loop if 'DFS tree' is
3868 * misconfigured (i.e. has loops).
3869 */
3870 rc = -ELOOP;
3871 goto mount_fail_check;
3872 }
3873
3874 rc = expand_dfs_referral(xid, pSesInfo, volume_info, cifs_sb,
3875 true);
3876
3877 if (!rc) {
3878 referral_walks_count++;
3879 goto try_mount_again;
3880 }
3881 goto mount_fail_check;
3882 #else /* No DFS support, return error on mount */
3883 rc = -EOPNOTSUPP;
3884 #endif
3885 }
3886
3887 if (rc)
3888 goto mount_fail_check;
3889
3890 /* now, hang the tcon off of the superblock */
3891 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3892 if (tlink == NULL) {
3893 rc = -ENOMEM;
3894 goto mount_fail_check;
3895 }
3896
3897 tlink->tl_uid = pSesInfo->linux_uid;
3898 tlink->tl_tcon = tcon;
3899 tlink->tl_time = jiffies;
3900 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3901 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3902
3903 cifs_sb->master_tlink = tlink;
3904 spin_lock(&cifs_sb->tlink_tree_lock);
3905 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3906 spin_unlock(&cifs_sb->tlink_tree_lock);
3907
3908 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3909 TLINK_IDLE_EXPIRE);
3910
3911 mount_fail_check:
3912 /* on error free sesinfo and tcon struct if needed */
3913 if (rc) {
3914 /* If find_unc succeeded then rc == 0 so we can not end */
3915 /* up accidentally freeing someone elses tcon struct */
3916 if (tcon)
3917 cifs_put_tcon(tcon);
3918 else if (pSesInfo)
3919 cifs_put_smb_ses(pSesInfo);
3920 else
3921 cifs_put_tcp_session(srvTcp);
3922 bdi_destroy(&cifs_sb->bdi);
3923 }
3924
3925 out:
3926 FreeXid(xid);
3927 return rc;
3928 }
3929
3930 /*
3931 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3932 * pointer may be NULL.
3933 */
3934 int
3935 CIFSTCon(unsigned int xid, struct cifs_ses *ses,
3936 const char *tree, struct cifs_tcon *tcon,
3937 const struct nls_table *nls_codepage)
3938 {
3939 struct smb_hdr *smb_buffer;
3940 struct smb_hdr *smb_buffer_response;
3941 TCONX_REQ *pSMB;
3942 TCONX_RSP *pSMBr;
3943 unsigned char *bcc_ptr;
3944 int rc = 0;
3945 int length;
3946 __u16 bytes_left, count;
3947
3948 if (ses == NULL)
3949 return -EIO;
3950
3951 smb_buffer = cifs_buf_get();
3952 if (smb_buffer == NULL)
3953 return -ENOMEM;
3954
3955 smb_buffer_response = smb_buffer;
3956
3957 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3958 NULL /*no tid */ , 4 /*wct */ );
3959
3960 smb_buffer->Mid = get_next_mid(ses->server);
3961 smb_buffer->Uid = ses->Suid;
3962 pSMB = (TCONX_REQ *) smb_buffer;
3963 pSMBr = (TCONX_RSP *) smb_buffer_response;
3964
3965 pSMB->AndXCommand = 0xFF;
3966 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3967 bcc_ptr = &pSMB->Password[0];
3968 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3969 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3970 *bcc_ptr = 0; /* password is null byte */
3971 bcc_ptr++; /* skip password */
3972 /* already aligned so no need to do it below */
3973 } else {
3974 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3975 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3976 specified as required (when that support is added to
3977 the vfs in the future) as only NTLM or the much
3978 weaker LANMAN (which we do not send by default) is accepted
3979 by Samba (not sure whether other servers allow
3980 NTLMv2 password here) */
3981 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3982 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3983 (ses->server->secType == LANMAN))
3984 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3985 ses->server->sec_mode &
3986 SECMODE_PW_ENCRYPT ? true : false,
3987 bcc_ptr);
3988 else
3989 #endif /* CIFS_WEAK_PW_HASH */
3990 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3991 bcc_ptr, nls_codepage);
3992
3993 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3994 if (ses->capabilities & CAP_UNICODE) {
3995 /* must align unicode strings */
3996 *bcc_ptr = 0; /* null byte password */
3997 bcc_ptr++;
3998 }
3999 }
4000
4001 if (ses->server->sec_mode &
4002 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
4003 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
4004
4005 if (ses->capabilities & CAP_STATUS32) {
4006 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
4007 }
4008 if (ses->capabilities & CAP_DFS) {
4009 smb_buffer->Flags2 |= SMBFLG2_DFS;
4010 }
4011 if (ses->capabilities & CAP_UNICODE) {
4012 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
4013 length =
4014 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
4015 6 /* max utf8 char length in bytes */ *
4016 (/* server len*/ + 256 /* share len */), nls_codepage);
4017 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
4018 bcc_ptr += 2; /* skip trailing null */
4019 } else { /* ASCII */
4020 strcpy(bcc_ptr, tree);
4021 bcc_ptr += strlen(tree) + 1;
4022 }
4023 strcpy(bcc_ptr, "?????");
4024 bcc_ptr += strlen("?????");
4025 bcc_ptr += 1;
4026 count = bcc_ptr - &pSMB->Password[0];
4027 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
4028 pSMB->hdr.smb_buf_length) + count);
4029 pSMB->ByteCount = cpu_to_le16(count);
4030
4031 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
4032 0);
4033
4034 /* above now done in SendReceive */
4035 if ((rc == 0) && (tcon != NULL)) {
4036 bool is_unicode;
4037
4038 tcon->tidStatus = CifsGood;
4039 tcon->need_reconnect = false;
4040 tcon->tid = smb_buffer_response->Tid;
4041 bcc_ptr = pByteArea(smb_buffer_response);
4042 bytes_left = get_bcc(smb_buffer_response);
4043 length = strnlen(bcc_ptr, bytes_left - 2);
4044 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
4045 is_unicode = true;
4046 else
4047 is_unicode = false;
4048
4049
4050 /* skip service field (NB: this field is always ASCII) */
4051 if (length == 3) {
4052 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
4053 (bcc_ptr[2] == 'C')) {
4054 cFYI(1, "IPC connection");
4055 tcon->ipc = 1;
4056 }
4057 } else if (length == 2) {
4058 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
4059 /* the most common case */
4060 cFYI(1, "disk share connection");
4061 }
4062 }
4063 bcc_ptr += length + 1;
4064 bytes_left -= (length + 1);
4065 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
4066
4067 /* mostly informational -- no need to fail on error here */
4068 kfree(tcon->nativeFileSystem);
4069 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
4070 bytes_left, is_unicode,
4071 nls_codepage);
4072
4073 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
4074
4075 if ((smb_buffer_response->WordCount == 3) ||
4076 (smb_buffer_response->WordCount == 7))
4077 /* field is in same location */
4078 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
4079 else
4080 tcon->Flags = 0;
4081 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
4082 } else if ((rc == 0) && tcon == NULL) {
4083 /* all we need to save for IPC$ connection */
4084 ses->ipc_tid = smb_buffer_response->Tid;
4085 }
4086
4087 cifs_buf_release(smb_buffer);
4088 return rc;
4089 }
4090
4091 void
4092 cifs_umount(struct cifs_sb_info *cifs_sb)
4093 {
4094 struct rb_root *root = &cifs_sb->tlink_tree;
4095 struct rb_node *node;
4096 struct tcon_link *tlink;
4097
4098 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
4099
4100 spin_lock(&cifs_sb->tlink_tree_lock);
4101 while ((node = rb_first(root))) {
4102 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4103 cifs_get_tlink(tlink);
4104 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4105 rb_erase(node, root);
4106
4107 spin_unlock(&cifs_sb->tlink_tree_lock);
4108 cifs_put_tlink(tlink);
4109 spin_lock(&cifs_sb->tlink_tree_lock);
4110 }
4111 spin_unlock(&cifs_sb->tlink_tree_lock);
4112
4113 bdi_destroy(&cifs_sb->bdi);
4114 kfree(cifs_sb->mountdata);
4115 unload_nls(cifs_sb->local_nls);
4116 kfree(cifs_sb);
4117 }
4118
4119 int cifs_negotiate_protocol(unsigned int xid, struct cifs_ses *ses)
4120 {
4121 int rc = 0;
4122 struct TCP_Server_Info *server = ses->server;
4123
4124 /* only send once per connect */
4125 if (server->maxBuf != 0)
4126 return 0;
4127
4128 set_credits(server, 1);
4129 rc = CIFSSMBNegotiate(xid, ses);
4130 if (rc == -EAGAIN) {
4131 /* retry only once on 1st time connection */
4132 set_credits(server, 1);
4133 rc = CIFSSMBNegotiate(xid, ses);
4134 if (rc == -EAGAIN)
4135 rc = -EHOSTDOWN;
4136 }
4137 if (rc == 0) {
4138 spin_lock(&GlobalMid_Lock);
4139 if (server->tcpStatus == CifsNeedNegotiate)
4140 server->tcpStatus = CifsGood;
4141 else
4142 rc = -EHOSTDOWN;
4143 spin_unlock(&GlobalMid_Lock);
4144
4145 }
4146
4147 return rc;
4148 }
4149
4150
4151 int cifs_setup_session(unsigned int xid, struct cifs_ses *ses,
4152 struct nls_table *nls_info)
4153 {
4154 int rc = 0;
4155 struct TCP_Server_Info *server = ses->server;
4156
4157 ses->flags = 0;
4158 ses->capabilities = server->capabilities;
4159 if (linuxExtEnabled == 0)
4160 ses->capabilities &= (~CAP_UNIX);
4161
4162 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
4163 server->sec_mode, server->capabilities, server->timeAdj);
4164
4165 rc = CIFS_SessSetup(xid, ses, nls_info);
4166 if (rc) {
4167 cERROR(1, "Send error in SessSetup = %d", rc);
4168 } else {
4169 mutex_lock(&ses->server->srv_mutex);
4170 if (!server->session_estab) {
4171 server->session_key.response = ses->auth_key.response;
4172 server->session_key.len = ses->auth_key.len;
4173 server->sequence_number = 0x2;
4174 server->session_estab = true;
4175 ses->auth_key.response = NULL;
4176 }
4177 mutex_unlock(&server->srv_mutex);
4178
4179 cFYI(1, "CIFS Session Established successfully");
4180 spin_lock(&GlobalMid_Lock);
4181 ses->status = CifsGood;
4182 ses->need_reconnect = false;
4183 spin_unlock(&GlobalMid_Lock);
4184 }
4185
4186 kfree(ses->auth_key.response);
4187 ses->auth_key.response = NULL;
4188 ses->auth_key.len = 0;
4189 kfree(ses->ntlmssp);
4190 ses->ntlmssp = NULL;
4191
4192 return rc;
4193 }
4194
4195 static int
4196 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
4197 {
4198 switch (ses->server->secType) {
4199 case Kerberos:
4200 vol->secFlg = CIFSSEC_MUST_KRB5;
4201 return 0;
4202 case NTLMv2:
4203 vol->secFlg = CIFSSEC_MUST_NTLMV2;
4204 break;
4205 case NTLM:
4206 vol->secFlg = CIFSSEC_MUST_NTLM;
4207 break;
4208 case RawNTLMSSP:
4209 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
4210 break;
4211 case LANMAN:
4212 vol->secFlg = CIFSSEC_MUST_LANMAN;
4213 break;
4214 }
4215
4216 return cifs_set_cifscreds(vol, ses);
4217 }
4218
4219 static struct cifs_tcon *
4220 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
4221 {
4222 int rc;
4223 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
4224 struct cifs_ses *ses;
4225 struct cifs_tcon *tcon = NULL;
4226 struct smb_vol *vol_info;
4227
4228 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
4229 if (vol_info == NULL)
4230 return ERR_PTR(-ENOMEM);
4231
4232 vol_info->local_nls = cifs_sb->local_nls;
4233 vol_info->linux_uid = fsuid;
4234 vol_info->cred_uid = fsuid;
4235 vol_info->UNC = master_tcon->treeName;
4236 vol_info->retry = master_tcon->retry;
4237 vol_info->nocase = master_tcon->nocase;
4238 vol_info->local_lease = master_tcon->local_lease;
4239 vol_info->no_linux_ext = !master_tcon->unix_ext;
4240
4241 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
4242 if (rc) {
4243 tcon = ERR_PTR(rc);
4244 goto out;
4245 }
4246
4247 /* get a reference for the same TCP session */
4248 spin_lock(&cifs_tcp_ses_lock);
4249 ++master_tcon->ses->server->srv_count;
4250 spin_unlock(&cifs_tcp_ses_lock);
4251
4252 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
4253 if (IS_ERR(ses)) {
4254 tcon = (struct cifs_tcon *)ses;
4255 cifs_put_tcp_session(master_tcon->ses->server);
4256 goto out;
4257 }
4258
4259 tcon = cifs_get_tcon(ses, vol_info);
4260 if (IS_ERR(tcon)) {
4261 cifs_put_smb_ses(ses);
4262 goto out;
4263 }
4264
4265 if (ses->capabilities & CAP_UNIX)
4266 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
4267 out:
4268 kfree(vol_info->username);
4269 kfree(vol_info->password);
4270 kfree(vol_info);
4271
4272 return tcon;
4273 }
4274
4275 struct cifs_tcon *
4276 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
4277 {
4278 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
4279 }
4280
4281 static int
4282 cifs_sb_tcon_pending_wait(void *unused)
4283 {
4284 schedule();
4285 return signal_pending(current) ? -ERESTARTSYS : 0;
4286 }
4287
4288 /* find and return a tlink with given uid */
4289 static struct tcon_link *
4290 tlink_rb_search(struct rb_root *root, uid_t uid)
4291 {
4292 struct rb_node *node = root->rb_node;
4293 struct tcon_link *tlink;
4294
4295 while (node) {
4296 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
4297
4298 if (tlink->tl_uid > uid)
4299 node = node->rb_left;
4300 else if (tlink->tl_uid < uid)
4301 node = node->rb_right;
4302 else
4303 return tlink;
4304 }
4305 return NULL;
4306 }
4307
4308 /* insert a tcon_link into the tree */
4309 static void
4310 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
4311 {
4312 struct rb_node **new = &(root->rb_node), *parent = NULL;
4313 struct tcon_link *tlink;
4314
4315 while (*new) {
4316 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4317 parent = *new;
4318
4319 if (tlink->tl_uid > new_tlink->tl_uid)
4320 new = &((*new)->rb_left);
4321 else
4322 new = &((*new)->rb_right);
4323 }
4324
4325 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4326 rb_insert_color(&new_tlink->tl_rbnode, root);
4327 }
4328
4329 /*
4330 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4331 * current task.
4332 *
4333 * If the superblock doesn't refer to a multiuser mount, then just return
4334 * the master tcon for the mount.
4335 *
4336 * First, search the rbtree for an existing tcon for this fsuid. If one
4337 * exists, then check to see if it's pending construction. If it is then wait
4338 * for construction to complete. Once it's no longer pending, check to see if
4339 * it failed and either return an error or retry construction, depending on
4340 * the timeout.
4341 *
4342 * If one doesn't exist then insert a new tcon_link struct into the tree and
4343 * try to construct a new one.
4344 */
4345 struct tcon_link *
4346 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4347 {
4348 int ret;
4349 uid_t fsuid = current_fsuid();
4350 struct tcon_link *tlink, *newtlink;
4351
4352 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4353 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4354
4355 spin_lock(&cifs_sb->tlink_tree_lock);
4356 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4357 if (tlink)
4358 cifs_get_tlink(tlink);
4359 spin_unlock(&cifs_sb->tlink_tree_lock);
4360
4361 if (tlink == NULL) {
4362 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4363 if (newtlink == NULL)
4364 return ERR_PTR(-ENOMEM);
4365 newtlink->tl_uid = fsuid;
4366 newtlink->tl_tcon = ERR_PTR(-EACCES);
4367 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4368 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4369 cifs_get_tlink(newtlink);
4370
4371 spin_lock(&cifs_sb->tlink_tree_lock);
4372 /* was one inserted after previous search? */
4373 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4374 if (tlink) {
4375 cifs_get_tlink(tlink);
4376 spin_unlock(&cifs_sb->tlink_tree_lock);
4377 kfree(newtlink);
4378 goto wait_for_construction;
4379 }
4380 tlink = newtlink;
4381 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4382 spin_unlock(&cifs_sb->tlink_tree_lock);
4383 } else {
4384 wait_for_construction:
4385 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4386 cifs_sb_tcon_pending_wait,
4387 TASK_INTERRUPTIBLE);
4388 if (ret) {
4389 cifs_put_tlink(tlink);
4390 return ERR_PTR(ret);
4391 }
4392
4393 /* if it's good, return it */
4394 if (!IS_ERR(tlink->tl_tcon))
4395 return tlink;
4396
4397 /* return error if we tried this already recently */
4398 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4399 cifs_put_tlink(tlink);
4400 return ERR_PTR(-EACCES);
4401 }
4402
4403 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4404 goto wait_for_construction;
4405 }
4406
4407 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4408 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4409 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4410
4411 if (IS_ERR(tlink->tl_tcon)) {
4412 cifs_put_tlink(tlink);
4413 return ERR_PTR(-EACCES);
4414 }
4415
4416 return tlink;
4417 }
4418
4419 /*
4420 * periodic workqueue job that scans tcon_tree for a superblock and closes
4421 * out tcons.
4422 */
4423 static void
4424 cifs_prune_tlinks(struct work_struct *work)
4425 {
4426 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4427 prune_tlinks.work);
4428 struct rb_root *root = &cifs_sb->tlink_tree;
4429 struct rb_node *node = rb_first(root);
4430 struct rb_node *tmp;
4431 struct tcon_link *tlink;
4432
4433 /*
4434 * Because we drop the spinlock in the loop in order to put the tlink
4435 * it's not guarded against removal of links from the tree. The only
4436 * places that remove entries from the tree are this function and
4437 * umounts. Because this function is non-reentrant and is canceled
4438 * before umount can proceed, this is safe.
4439 */
4440 spin_lock(&cifs_sb->tlink_tree_lock);
4441 node = rb_first(root);
4442 while (node != NULL) {
4443 tmp = node;
4444 node = rb_next(tmp);
4445 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4446
4447 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4448 atomic_read(&tlink->tl_count) != 0 ||
4449 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4450 continue;
4451
4452 cifs_get_tlink(tlink);
4453 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4454 rb_erase(tmp, root);
4455
4456 spin_unlock(&cifs_sb->tlink_tree_lock);
4457 cifs_put_tlink(tlink);
4458 spin_lock(&cifs_sb->tlink_tree_lock);
4459 }
4460 spin_unlock(&cifs_sb->tlink_tree_lock);
4461
4462 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4463 TLINK_IDLE_EXPIRE);
4464 }
Linux kernel - Deliverables
This page took 0.131456 seconds and 6 git commands to generate.