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