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