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