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