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