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