projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
cifs: add new fields to cifs_ses to track requested security flavor
[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 switch (match_token(value, cifs_secflavor_tokens, args)) {
1029 case Opt_sec_krb5:
1030 vol->secFlg |= CIFSSEC_MAY_KRB5 | CIFSSEC_MAY_SIGN;
1031 break;
1032 case Opt_sec_krb5i:
1033 vol->secFlg |= CIFSSEC_MAY_KRB5 | CIFSSEC_MUST_SIGN;
1034 break;
1035 case Opt_sec_krb5p:
1036 /* vol->secFlg |= CIFSSEC_MUST_SEAL | CIFSSEC_MAY_KRB5; */
1037 cifs_dbg(VFS, "Krb5 cifs privacy not supported\n");
1038 break;
1039 case Opt_sec_ntlmssp:
1040 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1041 break;
1042 case Opt_sec_ntlmsspi:
1043 vol->secFlg |= CIFSSEC_MAY_NTLMSSP | CIFSSEC_MUST_SIGN;
1044 break;
1045 case Opt_ntlm:
1046 /* ntlm is default so can be turned off too */
1047 vol->secFlg |= CIFSSEC_MAY_NTLM;
1048 break;
1049 case Opt_sec_ntlmi:
1050 vol->secFlg |= CIFSSEC_MAY_NTLM | CIFSSEC_MUST_SIGN;
1051 break;
1052 case Opt_sec_ntlmv2:
1053 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1054 break;
1055 case Opt_sec_ntlmv2i:
1056 vol->secFlg |= CIFSSEC_MAY_NTLMV2 | CIFSSEC_MUST_SIGN;
1057 break;
1058 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1059 case Opt_sec_lanman:
1060 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1061 break;
1062 #endif
1063 case Opt_sec_none:
1064 vol->nullauth = 1;
1065 vol->secFlg |= CIFSSEC_MAY_NTLM;
1066 break;
1067 default:
1068 cifs_dbg(VFS, "bad security option: %s\n", value);
1069 return 1;
1070 }
1071
1072 return 0;
1073 }
1074
1075 static int
1076 cifs_parse_cache_flavor(char *value, struct smb_vol *vol)
1077 {
1078 substring_t args[MAX_OPT_ARGS];
1079
1080 switch (match_token(value, cifs_cacheflavor_tokens, args)) {
1081 case Opt_cache_loose:
1082 vol->direct_io = false;
1083 vol->strict_io = false;
1084 break;
1085 case Opt_cache_strict:
1086 vol->direct_io = false;
1087 vol->strict_io = true;
1088 break;
1089 case Opt_cache_none:
1090 vol->direct_io = true;
1091 vol->strict_io = false;
1092 break;
1093 default:
1094 cifs_dbg(VFS, "bad cache= option: %s\n", value);
1095 return 1;
1096 }
1097 return 0;
1098 }
1099
1100 static int
1101 cifs_parse_smb_version(char *value, struct smb_vol *vol)
1102 {
1103 substring_t args[MAX_OPT_ARGS];
1104
1105 switch (match_token(value, cifs_smb_version_tokens, args)) {
1106 case Smb_1:
1107 vol->ops = &smb1_operations;
1108 vol->vals = &smb1_values;
1109 break;
1110 #ifdef CONFIG_CIFS_SMB2
1111 case Smb_20:
1112 vol->ops = &smb21_operations; /* currently identical with 2.1 */
1113 vol->vals = &smb20_values;
1114 break;
1115 case Smb_21:
1116 vol->ops = &smb21_operations;
1117 vol->vals = &smb21_values;
1118 break;
1119 case Smb_30:
1120 vol->ops = &smb30_operations;
1121 vol->vals = &smb30_values;
1122 break;
1123 #endif
1124 default:
1125 cifs_dbg(VFS, "Unknown vers= option specified: %s\n", value);
1126 return 1;
1127 }
1128 return 0;
1129 }
1130
1131 /*
1132 * Parse a devname into substrings and populate the vol->UNC and vol->prepath
1133 * fields with the result. Returns 0 on success and an error otherwise.
1134 */
1135 static int
1136 cifs_parse_devname(const char *devname, struct smb_vol *vol)
1137 {
1138 char *pos;
1139 const char *delims = "/\\";
1140 size_t len;
1141
1142 /* make sure we have a valid UNC double delimiter prefix */
1143 len = strspn(devname, delims);
1144 if (len != 2)
1145 return -EINVAL;
1146
1147 /* find delimiter between host and sharename */
1148 pos = strpbrk(devname + 2, delims);
1149 if (!pos)
1150 return -EINVAL;
1151
1152 /* skip past delimiter */
1153 ++pos;
1154
1155 /* now go until next delimiter or end of string */
1156 len = strcspn(pos, delims);
1157
1158 /* move "pos" up to delimiter or NULL */
1159 pos += len;
1160 vol->UNC = kstrndup(devname, pos - devname, GFP_KERNEL);
1161 if (!vol->UNC)
1162 return -ENOMEM;
1163
1164 convert_delimiter(vol->UNC, '\\');
1165
1166 /* If pos is NULL, or is a bogus trailing delimiter then no prepath */
1167 if (!*pos++ || !*pos)
1168 return 0;
1169
1170 vol->prepath = kstrdup(pos, GFP_KERNEL);
1171 if (!vol->prepath)
1172 return -ENOMEM;
1173
1174 return 0;
1175 }
1176
1177 static int
1178 cifs_parse_mount_options(const char *mountdata, const char *devname,
1179 struct smb_vol *vol)
1180 {
1181 char *data, *end;
1182 char *mountdata_copy = NULL, *options;
1183 unsigned int temp_len, i, j;
1184 char separator[2];
1185 short int override_uid = -1;
1186 short int override_gid = -1;
1187 bool uid_specified = false;
1188 bool gid_specified = false;
1189 bool sloppy = false;
1190 char *invalid = NULL;
1191 char *nodename = utsname()->nodename;
1192 char *string = NULL;
1193 char *tmp_end, *value;
1194 char delim;
1195 bool got_ip = false;
1196 unsigned short port = 0;
1197 struct sockaddr *dstaddr = (struct sockaddr *)&vol->dstaddr;
1198
1199 separator[0] = ',';
1200 separator[1] = 0;
1201 delim = separator[0];
1202
1203 /* ensure we always start with zeroed-out smb_vol */
1204 memset(vol, 0, sizeof(*vol));
1205
1206 /*
1207 * does not have to be perfect mapping since field is
1208 * informational, only used for servers that do not support
1209 * port 445 and it can be overridden at mount time
1210 */
1211 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
1212 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
1213 vol->source_rfc1001_name[i] = toupper(nodename[i]);
1214
1215 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
1216 /* null target name indicates to use *SMBSERVR default called name
1217 if we end up sending RFC1001 session initialize */
1218 vol->target_rfc1001_name[0] = 0;
1219 vol->cred_uid = current_uid();
1220 vol->linux_uid = current_uid();
1221 vol->linux_gid = current_gid();
1222
1223 /* default to only allowing write access to owner of the mount */
1224 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
1225
1226 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
1227 /* default is always to request posix paths. */
1228 vol->posix_paths = 1;
1229 /* default to using server inode numbers where available */
1230 vol->server_ino = 1;
1231
1232 /* default is to use strict cifs caching semantics */
1233 vol->strict_io = true;
1234
1235 vol->actimeo = CIFS_DEF_ACTIMEO;
1236
1237 /* FIXME: add autonegotiation -- for now, SMB1 is default */
1238 vol->ops = &smb1_operations;
1239 vol->vals = &smb1_values;
1240
1241 if (!mountdata)
1242 goto cifs_parse_mount_err;
1243
1244 mountdata_copy = kstrndup(mountdata, PAGE_SIZE, GFP_KERNEL);
1245 if (!mountdata_copy)
1246 goto cifs_parse_mount_err;
1247
1248 options = mountdata_copy;
1249 end = options + strlen(options);
1250
1251 if (strncmp(options, "sep=", 4) == 0) {
1252 if (options[4] != 0) {
1253 separator[0] = options[4];
1254 options += 5;
1255 } else {
1256 cifs_dbg(FYI, "Null separator not allowed\n");
1257 }
1258 }
1259 vol->backupuid_specified = false; /* no backup intent for a user */
1260 vol->backupgid_specified = false; /* no backup intent for a group */
1261
1262 switch (cifs_parse_devname(devname, vol)) {
1263 case 0:
1264 break;
1265 case -ENOMEM:
1266 cifs_dbg(VFS, "Unable to allocate memory for devname.\n");
1267 goto cifs_parse_mount_err;
1268 case -EINVAL:
1269 cifs_dbg(VFS, "Malformed UNC in devname.\n");
1270 goto cifs_parse_mount_err;
1271 default:
1272 cifs_dbg(VFS, "Unknown error parsing devname.\n");
1273 goto cifs_parse_mount_err;
1274 }
1275
1276 while ((data = strsep(&options, separator)) != NULL) {
1277 substring_t args[MAX_OPT_ARGS];
1278 unsigned long option;
1279 int token;
1280
1281 if (!*data)
1282 continue;
1283
1284 token = match_token(data, cifs_mount_option_tokens, args);
1285
1286 switch (token) {
1287
1288 /* Ingnore the following */
1289 case Opt_ignore:
1290 break;
1291
1292 /* Boolean values */
1293 case Opt_user_xattr:
1294 vol->no_xattr = 0;
1295 break;
1296 case Opt_nouser_xattr:
1297 vol->no_xattr = 1;
1298 break;
1299 case Opt_forceuid:
1300 override_uid = 1;
1301 break;
1302 case Opt_noforceuid:
1303 override_uid = 0;
1304 break;
1305 case Opt_forcegid:
1306 override_gid = 1;
1307 break;
1308 case Opt_noforcegid:
1309 override_gid = 0;
1310 break;
1311 case Opt_noblocksend:
1312 vol->noblocksnd = 1;
1313 break;
1314 case Opt_noautotune:
1315 vol->noautotune = 1;
1316 break;
1317 case Opt_hard:
1318 vol->retry = 1;
1319 break;
1320 case Opt_soft:
1321 vol->retry = 0;
1322 break;
1323 case Opt_perm:
1324 vol->noperm = 0;
1325 break;
1326 case Opt_noperm:
1327 vol->noperm = 1;
1328 break;
1329 case Opt_mapchars:
1330 vol->remap = 1;
1331 break;
1332 case Opt_nomapchars:
1333 vol->remap = 0;
1334 break;
1335 case Opt_sfu:
1336 vol->sfu_emul = 1;
1337 break;
1338 case Opt_nosfu:
1339 vol->sfu_emul = 0;
1340 break;
1341 case Opt_nodfs:
1342 vol->nodfs = 1;
1343 break;
1344 case Opt_posixpaths:
1345 vol->posix_paths = 1;
1346 break;
1347 case Opt_noposixpaths:
1348 vol->posix_paths = 0;
1349 break;
1350 case Opt_nounix:
1351 vol->no_linux_ext = 1;
1352 break;
1353 case Opt_nocase:
1354 vol->nocase = 1;
1355 break;
1356 case Opt_brl:
1357 vol->nobrl = 0;
1358 break;
1359 case Opt_nobrl:
1360 vol->nobrl = 1;
1361 /*
1362 * turn off mandatory locking in mode
1363 * if remote locking is turned off since the
1364 * local vfs will do advisory
1365 */
1366 if (vol->file_mode ==
1367 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1368 vol->file_mode = S_IALLUGO;
1369 break;
1370 case Opt_forcemandatorylock:
1371 vol->mand_lock = 1;
1372 break;
1373 case Opt_setuids:
1374 vol->setuids = 1;
1375 break;
1376 case Opt_nosetuids:
1377 vol->setuids = 0;
1378 break;
1379 case Opt_dynperm:
1380 vol->dynperm = true;
1381 break;
1382 case Opt_nodynperm:
1383 vol->dynperm = false;
1384 break;
1385 case Opt_nohard:
1386 vol->retry = 0;
1387 break;
1388 case Opt_nosoft:
1389 vol->retry = 1;
1390 break;
1391 case Opt_nointr:
1392 vol->intr = 0;
1393 break;
1394 case Opt_intr:
1395 vol->intr = 1;
1396 break;
1397 case Opt_nostrictsync:
1398 vol->nostrictsync = 1;
1399 break;
1400 case Opt_strictsync:
1401 vol->nostrictsync = 0;
1402 break;
1403 case Opt_serverino:
1404 vol->server_ino = 1;
1405 break;
1406 case Opt_noserverino:
1407 vol->server_ino = 0;
1408 break;
1409 case Opt_rwpidforward:
1410 vol->rwpidforward = 1;
1411 break;
1412 case Opt_cifsacl:
1413 vol->cifs_acl = 1;
1414 break;
1415 case Opt_nocifsacl:
1416 vol->cifs_acl = 0;
1417 break;
1418 case Opt_acl:
1419 vol->no_psx_acl = 0;
1420 break;
1421 case Opt_noacl:
1422 vol->no_psx_acl = 1;
1423 break;
1424 case Opt_locallease:
1425 vol->local_lease = 1;
1426 break;
1427 case Opt_sign:
1428 vol->secFlg |= CIFSSEC_MUST_SIGN;
1429 break;
1430 case Opt_seal:
1431 /* we do not do the following in secFlags because seal
1432 * is a per tree connection (mount) not a per socket
1433 * or per-smb connection option in the protocol
1434 * vol->secFlg |= CIFSSEC_MUST_SEAL;
1435 */
1436 vol->seal = 1;
1437 break;
1438 case Opt_noac:
1439 printk(KERN_WARNING "CIFS: Mount option noac not "
1440 "supported. Instead set "
1441 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1442 break;
1443 case Opt_fsc:
1444 #ifndef CONFIG_CIFS_FSCACHE
1445 cifs_dbg(VFS, "FS-Cache support needs CONFIG_CIFS_FSCACHE kernel config option set\n");
1446 goto cifs_parse_mount_err;
1447 #endif
1448 vol->fsc = true;
1449 break;
1450 case Opt_mfsymlinks:
1451 vol->mfsymlinks = true;
1452 break;
1453 case Opt_multiuser:
1454 vol->multiuser = true;
1455 break;
1456 case Opt_sloppy:
1457 sloppy = true;
1458 break;
1459 case Opt_nosharesock:
1460 vol->nosharesock = true;
1461 break;
1462
1463 /* Numeric Values */
1464 case Opt_backupuid:
1465 if (get_option_uid(args, &vol->backupuid)) {
1466 cifs_dbg(VFS, "%s: Invalid backupuid value\n",
1467 __func__);
1468 goto cifs_parse_mount_err;
1469 }
1470 vol->backupuid_specified = true;
1471 break;
1472 case Opt_backupgid:
1473 if (get_option_gid(args, &vol->backupgid)) {
1474 cifs_dbg(VFS, "%s: Invalid backupgid value\n",
1475 __func__);
1476 goto cifs_parse_mount_err;
1477 }
1478 vol->backupgid_specified = true;
1479 break;
1480 case Opt_uid:
1481 if (get_option_uid(args, &vol->linux_uid)) {
1482 cifs_dbg(VFS, "%s: Invalid uid value\n",
1483 __func__);
1484 goto cifs_parse_mount_err;
1485 }
1486 uid_specified = true;
1487 break;
1488 case Opt_cruid:
1489 if (get_option_uid(args, &vol->cred_uid)) {
1490 cifs_dbg(VFS, "%s: Invalid cruid value\n",
1491 __func__);
1492 goto cifs_parse_mount_err;
1493 }
1494 break;
1495 case Opt_gid:
1496 if (get_option_gid(args, &vol->linux_gid)) {
1497 cifs_dbg(VFS, "%s: Invalid gid value\n",
1498 __func__);
1499 goto cifs_parse_mount_err;
1500 }
1501 gid_specified = true;
1502 break;
1503 case Opt_file_mode:
1504 if (get_option_ul(args, &option)) {
1505 cifs_dbg(VFS, "%s: Invalid file_mode value\n",
1506 __func__);
1507 goto cifs_parse_mount_err;
1508 }
1509 vol->file_mode = option;
1510 break;
1511 case Opt_dirmode:
1512 if (get_option_ul(args, &option)) {
1513 cifs_dbg(VFS, "%s: Invalid dir_mode value\n",
1514 __func__);
1515 goto cifs_parse_mount_err;
1516 }
1517 vol->dir_mode = option;
1518 break;
1519 case Opt_port:
1520 if (get_option_ul(args, &option) ||
1521 option > USHRT_MAX) {
1522 cifs_dbg(VFS, "%s: Invalid port value\n",
1523 __func__);
1524 goto cifs_parse_mount_err;
1525 }
1526 port = (unsigned short)option;
1527 break;
1528 case Opt_rsize:
1529 if (get_option_ul(args, &option)) {
1530 cifs_dbg(VFS, "%s: Invalid rsize value\n",
1531 __func__);
1532 goto cifs_parse_mount_err;
1533 }
1534 vol->rsize = option;
1535 break;
1536 case Opt_wsize:
1537 if (get_option_ul(args, &option)) {
1538 cifs_dbg(VFS, "%s: Invalid wsize value\n",
1539 __func__);
1540 goto cifs_parse_mount_err;
1541 }
1542 vol->wsize = option;
1543 break;
1544 case Opt_actimeo:
1545 if (get_option_ul(args, &option)) {
1546 cifs_dbg(VFS, "%s: Invalid actimeo value\n",
1547 __func__);
1548 goto cifs_parse_mount_err;
1549 }
1550 vol->actimeo = HZ * option;
1551 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1552 cifs_dbg(VFS, "attribute cache timeout too large\n");
1553 goto cifs_parse_mount_err;
1554 }
1555 break;
1556
1557 /* String Arguments */
1558
1559 case Opt_blank_user:
1560 /* null user, ie. anonymous authentication */
1561 vol->nullauth = 1;
1562 vol->username = NULL;
1563 break;
1564 case Opt_user:
1565 string = match_strdup(args);
1566 if (string == NULL)
1567 goto out_nomem;
1568
1569 if (strnlen(string, MAX_USERNAME_SIZE) >
1570 MAX_USERNAME_SIZE) {
1571 printk(KERN_WARNING "CIFS: username too long\n");
1572 goto cifs_parse_mount_err;
1573 }
1574 vol->username = kstrdup(string, GFP_KERNEL);
1575 if (!vol->username)
1576 goto cifs_parse_mount_err;
1577 break;
1578 case Opt_blank_pass:
1579 /* passwords have to be handled differently
1580 * to allow the character used for deliminator
1581 * to be passed within them
1582 */
1583
1584 /*
1585 * Check if this is a case where the password
1586 * starts with a delimiter
1587 */
1588 tmp_end = strchr(data, '=');
1589 tmp_end++;
1590 if (!(tmp_end < end && tmp_end[1] == delim)) {
1591 /* No it is not. Set the password to NULL */
1592 vol->password = NULL;
1593 break;
1594 }
1595 /* Yes it is. Drop down to Opt_pass below.*/
1596 case Opt_pass:
1597 /* Obtain the value string */
1598 value = strchr(data, '=');
1599 value++;
1600
1601 /* Set tmp_end to end of the string */
1602 tmp_end = (char *) value + strlen(value);
1603
1604 /* Check if following character is the deliminator
1605 * If yes, we have encountered a double deliminator
1606 * reset the NULL character to the deliminator
1607 */
1608 if (tmp_end < end && tmp_end[1] == delim) {
1609 tmp_end[0] = delim;
1610
1611 /* Keep iterating until we get to a single
1612 * deliminator OR the end
1613 */
1614 while ((tmp_end = strchr(tmp_end, delim))
1615 != NULL && (tmp_end[1] == delim)) {
1616 tmp_end = (char *) &tmp_end[2];
1617 }
1618
1619 /* Reset var options to point to next element */
1620 if (tmp_end) {
1621 tmp_end[0] = '\0';
1622 options = (char *) &tmp_end[1];
1623 } else
1624 /* Reached the end of the mount option
1625 * string */
1626 options = end;
1627 }
1628
1629 /* Now build new password string */
1630 temp_len = strlen(value);
1631 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
1632 if (vol->password == NULL) {
1633 printk(KERN_WARNING "CIFS: no memory "
1634 "for password\n");
1635 goto cifs_parse_mount_err;
1636 }
1637
1638 for (i = 0, j = 0; i < temp_len; i++, j++) {
1639 vol->password[j] = value[i];
1640 if ((value[i] == delim) &&
1641 value[i+1] == delim)
1642 /* skip the second deliminator */
1643 i++;
1644 }
1645 vol->password[j] = '\0';
1646 break;
1647 case Opt_blank_ip:
1648 /* FIXME: should this be an error instead? */
1649 got_ip = false;
1650 break;
1651 case Opt_ip:
1652 string = match_strdup(args);
1653 if (string == NULL)
1654 goto out_nomem;
1655
1656 if (!cifs_convert_address(dstaddr, string,
1657 strlen(string))) {
1658 printk(KERN_ERR "CIFS: bad ip= option (%s).\n",
1659 string);
1660 goto cifs_parse_mount_err;
1661 }
1662 got_ip = true;
1663 break;
1664 case Opt_domain:
1665 string = match_strdup(args);
1666 if (string == NULL)
1667 goto out_nomem;
1668
1669 if (strnlen(string, 256) == 256) {
1670 printk(KERN_WARNING "CIFS: domain name too"
1671 " long\n");
1672 goto cifs_parse_mount_err;
1673 }
1674
1675 vol->domainname = kstrdup(string, GFP_KERNEL);
1676 if (!vol->domainname) {
1677 printk(KERN_WARNING "CIFS: no memory "
1678 "for domainname\n");
1679 goto cifs_parse_mount_err;
1680 }
1681 cifs_dbg(FYI, "Domain name set\n");
1682 break;
1683 case Opt_srcaddr:
1684 string = match_strdup(args);
1685 if (string == NULL)
1686 goto out_nomem;
1687
1688 if (!cifs_convert_address(
1689 (struct sockaddr *)&vol->srcaddr,
1690 string, strlen(string))) {
1691 printk(KERN_WARNING "CIFS: Could not parse"
1692 " srcaddr: %s\n", string);
1693 goto cifs_parse_mount_err;
1694 }
1695 break;
1696 case Opt_iocharset:
1697 string = match_strdup(args);
1698 if (string == NULL)
1699 goto out_nomem;
1700
1701 if (strnlen(string, 1024) >= 65) {
1702 printk(KERN_WARNING "CIFS: iocharset name "
1703 "too long.\n");
1704 goto cifs_parse_mount_err;
1705 }
1706
1707 if (strnicmp(string, "default", 7) != 0) {
1708 vol->iocharset = kstrdup(string,
1709 GFP_KERNEL);
1710 if (!vol->iocharset) {
1711 printk(KERN_WARNING "CIFS: no memory"
1712 "for charset\n");
1713 goto cifs_parse_mount_err;
1714 }
1715 }
1716 /* if iocharset not set then load_nls_default
1717 * is used by caller
1718 */
1719 cifs_dbg(FYI, "iocharset set to %s\n", string);
1720 break;
1721 case Opt_netbiosname:
1722 string = match_strdup(args);
1723 if (string == NULL)
1724 goto out_nomem;
1725
1726 memset(vol->source_rfc1001_name, 0x20,
1727 RFC1001_NAME_LEN);
1728 /*
1729 * FIXME: are there cases in which a comma can
1730 * be valid in workstation netbios name (and
1731 * need special handling)?
1732 */
1733 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1734 /* don't ucase netbiosname for user */
1735 if (string[i] == 0)
1736 break;
1737 vol->source_rfc1001_name[i] = string[i];
1738 }
1739 /* The string has 16th byte zero still from
1740 * set at top of the function
1741 */
1742 if (i == RFC1001_NAME_LEN && string[i] != 0)
1743 printk(KERN_WARNING "CIFS: netbiosname"
1744 " longer than 15 truncated.\n");
1745
1746 break;
1747 case Opt_servern:
1748 /* servernetbiosname specified override *SMBSERVER */
1749 string = match_strdup(args);
1750 if (string == NULL)
1751 goto out_nomem;
1752
1753 /* last byte, type, is 0x20 for servr type */
1754 memset(vol->target_rfc1001_name, 0x20,
1755 RFC1001_NAME_LEN_WITH_NULL);
1756
1757 /* BB are there cases in which a comma can be
1758 valid in this workstation netbios name
1759 (and need special handling)? */
1760
1761 /* user or mount helper must uppercase the
1762 netbios name */
1763 for (i = 0; i < 15; i++) {
1764 if (string[i] == 0)
1765 break;
1766 vol->target_rfc1001_name[i] = string[i];
1767 }
1768 /* The string has 16th byte zero still from
1769 set at top of the function */
1770 if (i == RFC1001_NAME_LEN && string[i] != 0)
1771 printk(KERN_WARNING "CIFS: server net"
1772 "biosname longer than 15 truncated.\n");
1773 break;
1774 case Opt_ver:
1775 string = match_strdup(args);
1776 if (string == NULL)
1777 goto out_nomem;
1778
1779 if (strnicmp(string, "1", 1) == 0) {
1780 /* This is the default */
1781 break;
1782 }
1783 /* For all other value, error */
1784 printk(KERN_WARNING "CIFS: Invalid version"
1785 " specified\n");
1786 goto cifs_parse_mount_err;
1787 case Opt_vers:
1788 string = match_strdup(args);
1789 if (string == NULL)
1790 goto out_nomem;
1791
1792 if (cifs_parse_smb_version(string, vol) != 0)
1793 goto cifs_parse_mount_err;
1794 break;
1795 case Opt_sec:
1796 string = match_strdup(args);
1797 if (string == NULL)
1798 goto out_nomem;
1799
1800 if (cifs_parse_security_flavors(string, vol) != 0)
1801 goto cifs_parse_mount_err;
1802 break;
1803 case Opt_cache:
1804 string = match_strdup(args);
1805 if (string == NULL)
1806 goto out_nomem;
1807
1808 if (cifs_parse_cache_flavor(string, vol) != 0)
1809 goto cifs_parse_mount_err;
1810 break;
1811 default:
1812 /*
1813 * An option we don't recognize. Save it off for later
1814 * if we haven't already found one
1815 */
1816 if (!invalid)
1817 invalid = data;
1818 break;
1819 }
1820 /* Free up any allocated string */
1821 kfree(string);
1822 string = NULL;
1823 }
1824
1825 if (!sloppy && invalid) {
1826 printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
1827 goto cifs_parse_mount_err;
1828 }
1829
1830 #ifndef CONFIG_KEYS
1831 /* Muliuser mounts require CONFIG_KEYS support */
1832 if (vol->multiuser) {
1833 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1834 goto cifs_parse_mount_err;
1835 }
1836 #endif
1837 if (!vol->UNC) {
1838 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
1839 goto cifs_parse_mount_err;
1840 }
1841
1842 /* make sure UNC has a share name */
1843 if (!strchr(vol->UNC + 3, '\\')) {
1844 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
1845 goto cifs_parse_mount_err;
1846 }
1847
1848 if (!got_ip) {
1849 /* No ip= option specified? Try to get it from UNC */
1850 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1851 strlen(&vol->UNC[2]))) {
1852 printk(KERN_ERR "Unable to determine destination "
1853 "address.\n");
1854 goto cifs_parse_mount_err;
1855 }
1856 }
1857
1858 /* set the port that we got earlier */
1859 cifs_set_port(dstaddr, port);
1860
1861 if (uid_specified)
1862 vol->override_uid = override_uid;
1863 else if (override_uid == 1)
1864 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1865 "specified with no uid= option.\n");
1866
1867 if (gid_specified)
1868 vol->override_gid = override_gid;
1869 else if (override_gid == 1)
1870 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1871 "specified with no gid= option.\n");
1872
1873 kfree(mountdata_copy);
1874 return 0;
1875
1876 out_nomem:
1877 printk(KERN_WARNING "Could not allocate temporary buffer\n");
1878 cifs_parse_mount_err:
1879 kfree(string);
1880 kfree(mountdata_copy);
1881 return 1;
1882 }
1883
1884 /** Returns true if srcaddr isn't specified and rhs isn't
1885 * specified, or if srcaddr is specified and
1886 * matches the IP address of the rhs argument.
1887 */
1888 static bool
1889 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1890 {
1891 switch (srcaddr->sa_family) {
1892 case AF_UNSPEC:
1893 return (rhs->sa_family == AF_UNSPEC);
1894 case AF_INET: {
1895 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1896 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1897 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1898 }
1899 case AF_INET6: {
1900 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1901 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1902 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1903 }
1904 default:
1905 WARN_ON(1);
1906 return false; /* don't expect to be here */
1907 }
1908 }
1909
1910 /*
1911 * If no port is specified in addr structure, we try to match with 445 port
1912 * and if it fails - with 139 ports. It should be called only if address
1913 * families of server and addr are equal.
1914 */
1915 static bool
1916 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1917 {
1918 __be16 port, *sport;
1919
1920 switch (addr->sa_family) {
1921 case AF_INET:
1922 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1923 port = ((struct sockaddr_in *) addr)->sin_port;
1924 break;
1925 case AF_INET6:
1926 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1927 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1928 break;
1929 default:
1930 WARN_ON(1);
1931 return false;
1932 }
1933
1934 if (!port) {
1935 port = htons(CIFS_PORT);
1936 if (port == *sport)
1937 return true;
1938
1939 port = htons(RFC1001_PORT);
1940 }
1941
1942 return port == *sport;
1943 }
1944
1945 static bool
1946 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1947 struct sockaddr *srcaddr)
1948 {
1949 switch (addr->sa_family) {
1950 case AF_INET: {
1951 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1952 struct sockaddr_in *srv_addr4 =
1953 (struct sockaddr_in *)&server->dstaddr;
1954
1955 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1956 return false;
1957 break;
1958 }
1959 case AF_INET6: {
1960 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1961 struct sockaddr_in6 *srv_addr6 =
1962 (struct sockaddr_in6 *)&server->dstaddr;
1963
1964 if (!ipv6_addr_equal(&addr6->sin6_addr,
1965 &srv_addr6->sin6_addr))
1966 return false;
1967 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1968 return false;
1969 break;
1970 }
1971 default:
1972 WARN_ON(1);
1973 return false; /* don't expect to be here */
1974 }
1975
1976 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1977 return false;
1978
1979 return true;
1980 }
1981
1982 static bool
1983 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1984 {
1985 unsigned int secFlags;
1986
1987 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1988 secFlags = vol->secFlg;
1989 else
1990 secFlags = global_secflags | vol->secFlg;
1991
1992 switch (server->secType) {
1993 case LANMAN:
1994 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1995 return false;
1996 break;
1997 case NTLMv2:
1998 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1999 return false;
2000 break;
2001 case NTLM:
2002 if (!(secFlags & CIFSSEC_MAY_NTLM))
2003 return false;
2004 break;
2005 case Kerberos:
2006 if (!(secFlags & CIFSSEC_MAY_KRB5))
2007 return false;
2008 break;
2009 case RawNTLMSSP:
2010 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
2011 return false;
2012 break;
2013 default:
2014 /* shouldn't happen */
2015 return false;
2016 }
2017
2018 /* now check if signing mode is acceptable */
2019 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
2020 (server->sec_mode & SECMODE_SIGN_REQUIRED))
2021 return false;
2022 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
2023 (server->sec_mode &
2024 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
2025 return false;
2026
2027 return true;
2028 }
2029
2030 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2031 {
2032 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2033
2034 if (vol->nosharesock)
2035 return 0;
2036
2037 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2038 return 0;
2039
2040 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2041 return 0;
2042
2043 if (!match_address(server, addr,
2044 (struct sockaddr *)&vol->srcaddr))
2045 return 0;
2046
2047 if (!match_port(server, addr))
2048 return 0;
2049
2050 if (!match_security(server, vol))
2051 return 0;
2052
2053 return 1;
2054 }
2055
2056 static struct TCP_Server_Info *
2057 cifs_find_tcp_session(struct smb_vol *vol)
2058 {
2059 struct TCP_Server_Info *server;
2060
2061 spin_lock(&cifs_tcp_ses_lock);
2062 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2063 if (!match_server(server, vol))
2064 continue;
2065
2066 ++server->srv_count;
2067 spin_unlock(&cifs_tcp_ses_lock);
2068 cifs_dbg(FYI, "Existing tcp session with server found\n");
2069 return server;
2070 }
2071 spin_unlock(&cifs_tcp_ses_lock);
2072 return NULL;
2073 }
2074
2075 static void
2076 cifs_put_tcp_session(struct TCP_Server_Info *server)
2077 {
2078 struct task_struct *task;
2079
2080 spin_lock(&cifs_tcp_ses_lock);
2081 if (--server->srv_count > 0) {
2082 spin_unlock(&cifs_tcp_ses_lock);
2083 return;
2084 }
2085
2086 put_net(cifs_net_ns(server));
2087
2088 list_del_init(&server->tcp_ses_list);
2089 spin_unlock(&cifs_tcp_ses_lock);
2090
2091 cancel_delayed_work_sync(&server->echo);
2092
2093 spin_lock(&GlobalMid_Lock);
2094 server->tcpStatus = CifsExiting;
2095 spin_unlock(&GlobalMid_Lock);
2096
2097 cifs_crypto_shash_release(server);
2098 cifs_fscache_release_client_cookie(server);
2099
2100 kfree(server->session_key.response);
2101 server->session_key.response = NULL;
2102 server->session_key.len = 0;
2103
2104 task = xchg(&server->tsk, NULL);
2105 if (task)
2106 force_sig(SIGKILL, task);
2107 }
2108
2109 static struct TCP_Server_Info *
2110 cifs_get_tcp_session(struct smb_vol *volume_info)
2111 {
2112 struct TCP_Server_Info *tcp_ses = NULL;
2113 int rc;
2114
2115 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2116
2117 /* see if we already have a matching tcp_ses */
2118 tcp_ses = cifs_find_tcp_session(volume_info);
2119 if (tcp_ses)
2120 return tcp_ses;
2121
2122 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2123 if (!tcp_ses) {
2124 rc = -ENOMEM;
2125 goto out_err;
2126 }
2127
2128 rc = cifs_crypto_shash_allocate(tcp_ses);
2129 if (rc) {
2130 cifs_dbg(VFS, "could not setup hash structures rc %d\n", rc);
2131 goto out_err;
2132 }
2133
2134 tcp_ses->ops = volume_info->ops;
2135 tcp_ses->vals = volume_info->vals;
2136 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2137 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2138 if (IS_ERR(tcp_ses->hostname)) {
2139 rc = PTR_ERR(tcp_ses->hostname);
2140 goto out_err_crypto_release;
2141 }
2142
2143 tcp_ses->noblocksnd = volume_info->noblocksnd;
2144 tcp_ses->noautotune = volume_info->noautotune;
2145 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2146 tcp_ses->in_flight = 0;
2147 tcp_ses->credits = 1;
2148 init_waitqueue_head(&tcp_ses->response_q);
2149 init_waitqueue_head(&tcp_ses->request_q);
2150 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2151 mutex_init(&tcp_ses->srv_mutex);
2152 memcpy(tcp_ses->workstation_RFC1001_name,
2153 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2154 memcpy(tcp_ses->server_RFC1001_name,
2155 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2156 tcp_ses->session_estab = false;
2157 tcp_ses->sequence_number = 0;
2158 tcp_ses->lstrp = jiffies;
2159 spin_lock_init(&tcp_ses->req_lock);
2160 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2161 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2162 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2163 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2164 sizeof(tcp_ses->srcaddr));
2165 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2166 sizeof(tcp_ses->dstaddr));
2167 /*
2168 * at this point we are the only ones with the pointer
2169 * to the struct since the kernel thread not created yet
2170 * no need to spinlock this init of tcpStatus or srv_count
2171 */
2172 tcp_ses->tcpStatus = CifsNew;
2173 ++tcp_ses->srv_count;
2174
2175 rc = ip_connect(tcp_ses);
2176 if (rc < 0) {
2177 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2178 goto out_err_crypto_release;
2179 }
2180
2181 /*
2182 * since we're in a cifs function already, we know that
2183 * this will succeed. No need for try_module_get().
2184 */
2185 __module_get(THIS_MODULE);
2186 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2187 tcp_ses, "cifsd");
2188 if (IS_ERR(tcp_ses->tsk)) {
2189 rc = PTR_ERR(tcp_ses->tsk);
2190 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2191 module_put(THIS_MODULE);
2192 goto out_err_crypto_release;
2193 }
2194 tcp_ses->tcpStatus = CifsNeedNegotiate;
2195
2196 /* thread spawned, put it on the list */
2197 spin_lock(&cifs_tcp_ses_lock);
2198 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2199 spin_unlock(&cifs_tcp_ses_lock);
2200
2201 cifs_fscache_get_client_cookie(tcp_ses);
2202
2203 /* queue echo request delayed work */
2204 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2205
2206 return tcp_ses;
2207
2208 out_err_crypto_release:
2209 cifs_crypto_shash_release(tcp_ses);
2210
2211 put_net(cifs_net_ns(tcp_ses));
2212
2213 out_err:
2214 if (tcp_ses) {
2215 if (!IS_ERR(tcp_ses->hostname))
2216 kfree(tcp_ses->hostname);
2217 if (tcp_ses->ssocket)
2218 sock_release(tcp_ses->ssocket);
2219 kfree(tcp_ses);
2220 }
2221 return ERR_PTR(rc);
2222 }
2223
2224 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2225 {
2226 switch (ses->server->secType) {
2227 case Kerberos:
2228 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2229 return 0;
2230 break;
2231 default:
2232 /* NULL username means anonymous session */
2233 if (ses->user_name == NULL) {
2234 if (!vol->nullauth)
2235 return 0;
2236 break;
2237 }
2238
2239 /* anything else takes username/password */
2240 if (strncmp(ses->user_name,
2241 vol->username ? vol->username : "",
2242 MAX_USERNAME_SIZE))
2243 return 0;
2244 if (strlen(vol->username) != 0 &&
2245 ses->password != NULL &&
2246 strncmp(ses->password,
2247 vol->password ? vol->password : "",
2248 MAX_PASSWORD_SIZE))
2249 return 0;
2250 }
2251 return 1;
2252 }
2253
2254 static struct cifs_ses *
2255 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2256 {
2257 struct cifs_ses *ses;
2258
2259 spin_lock(&cifs_tcp_ses_lock);
2260 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2261 if (!match_session(ses, vol))
2262 continue;
2263 ++ses->ses_count;
2264 spin_unlock(&cifs_tcp_ses_lock);
2265 return ses;
2266 }
2267 spin_unlock(&cifs_tcp_ses_lock);
2268 return NULL;
2269 }
2270
2271 static void
2272 cifs_put_smb_ses(struct cifs_ses *ses)
2273 {
2274 unsigned int xid;
2275 struct TCP_Server_Info *server = ses->server;
2276
2277 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2278 spin_lock(&cifs_tcp_ses_lock);
2279 if (--ses->ses_count > 0) {
2280 spin_unlock(&cifs_tcp_ses_lock);
2281 return;
2282 }
2283
2284 list_del_init(&ses->smb_ses_list);
2285 spin_unlock(&cifs_tcp_ses_lock);
2286
2287 if (ses->status == CifsGood && server->ops->logoff) {
2288 xid = get_xid();
2289 server->ops->logoff(xid, ses);
2290 _free_xid(xid);
2291 }
2292 sesInfoFree(ses);
2293 cifs_put_tcp_session(server);
2294 }
2295
2296 #ifdef CONFIG_KEYS
2297
2298 /* strlen("cifs:a:") + INET6_ADDRSTRLEN + 1 */
2299 #define CIFSCREDS_DESC_SIZE (7 + INET6_ADDRSTRLEN + 1)
2300
2301 /* Populate username and pw fields from keyring if possible */
2302 static int
2303 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2304 {
2305 int rc = 0;
2306 char *desc, *delim, *payload;
2307 ssize_t len;
2308 struct key *key;
2309 struct TCP_Server_Info *server = ses->server;
2310 struct sockaddr_in *sa;
2311 struct sockaddr_in6 *sa6;
2312 struct user_key_payload *upayload;
2313
2314 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2315 if (!desc)
2316 return -ENOMEM;
2317
2318 /* try to find an address key first */
2319 switch (server->dstaddr.ss_family) {
2320 case AF_INET:
2321 sa = (struct sockaddr_in *)&server->dstaddr;
2322 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2323 break;
2324 case AF_INET6:
2325 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2326 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2327 break;
2328 default:
2329 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2330 server->dstaddr.ss_family);
2331 rc = -EINVAL;
2332 goto out_err;
2333 }
2334
2335 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2336 key = request_key(&key_type_logon, desc, "");
2337 if (IS_ERR(key)) {
2338 if (!ses->domainName) {
2339 cifs_dbg(FYI, "domainName is NULL\n");
2340 rc = PTR_ERR(key);
2341 goto out_err;
2342 }
2343
2344 /* didn't work, try to find a domain key */
2345 sprintf(desc, "cifs:d:%s", ses->domainName);
2346 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2347 key = request_key(&key_type_logon, desc, "");
2348 if (IS_ERR(key)) {
2349 rc = PTR_ERR(key);
2350 goto out_err;
2351 }
2352 }
2353
2354 down_read(&key->sem);
2355 upayload = key->payload.data;
2356 if (IS_ERR_OR_NULL(upayload)) {
2357 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2358 goto out_key_put;
2359 }
2360
2361 /* find first : in payload */
2362 payload = (char *)upayload->data;
2363 delim = strnchr(payload, upayload->datalen, ':');
2364 cifs_dbg(FYI, "payload=%s\n", payload);
2365 if (!delim) {
2366 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2367 upayload->datalen);
2368 rc = -EINVAL;
2369 goto out_key_put;
2370 }
2371
2372 len = delim - payload;
2373 if (len > MAX_USERNAME_SIZE || len <= 0) {
2374 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2375 len);
2376 rc = -EINVAL;
2377 goto out_key_put;
2378 }
2379
2380 vol->username = kstrndup(payload, len, GFP_KERNEL);
2381 if (!vol->username) {
2382 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2383 len);
2384 rc = -ENOMEM;
2385 goto out_key_put;
2386 }
2387 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2388
2389 len = key->datalen - (len + 1);
2390 if (len > MAX_PASSWORD_SIZE || len <= 0) {
2391 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2392 rc = -EINVAL;
2393 kfree(vol->username);
2394 vol->username = NULL;
2395 goto out_key_put;
2396 }
2397
2398 ++delim;
2399 vol->password = kstrndup(delim, len, GFP_KERNEL);
2400 if (!vol->password) {
2401 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2402 len);
2403 rc = -ENOMEM;
2404 kfree(vol->username);
2405 vol->username = NULL;
2406 goto out_key_put;
2407 }
2408
2409 out_key_put:
2410 up_read(&key->sem);
2411 key_put(key);
2412 out_err:
2413 kfree(desc);
2414 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2415 return rc;
2416 }
2417 #else /* ! CONFIG_KEYS */
2418 static inline int
2419 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2420 struct cifs_ses *ses __attribute__((unused)))
2421 {
2422 return -ENOSYS;
2423 }
2424 #endif /* CONFIG_KEYS */
2425
2426 static struct cifs_ses *
2427 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2428 {
2429 int rc = -ENOMEM;
2430 unsigned int xid;
2431 struct cifs_ses *ses;
2432 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2433 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2434
2435 xid = get_xid();
2436
2437 ses = cifs_find_smb_ses(server, volume_info);
2438 if (ses) {
2439 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2440 ses->status);
2441
2442 mutex_lock(&ses->session_mutex);
2443 rc = cifs_negotiate_protocol(xid, ses);
2444 if (rc) {
2445 mutex_unlock(&ses->session_mutex);
2446 /* problem -- put our ses reference */
2447 cifs_put_smb_ses(ses);
2448 free_xid(xid);
2449 return ERR_PTR(rc);
2450 }
2451 if (ses->need_reconnect) {
2452 cifs_dbg(FYI, "Session needs reconnect\n");
2453 rc = cifs_setup_session(xid, ses,
2454 volume_info->local_nls);
2455 if (rc) {
2456 mutex_unlock(&ses->session_mutex);
2457 /* problem -- put our reference */
2458 cifs_put_smb_ses(ses);
2459 free_xid(xid);
2460 return ERR_PTR(rc);
2461 }
2462 }
2463 mutex_unlock(&ses->session_mutex);
2464
2465 /* existing SMB ses has a server reference already */
2466 cifs_put_tcp_session(server);
2467 free_xid(xid);
2468 return ses;
2469 }
2470
2471 cifs_dbg(FYI, "Existing smb sess not found\n");
2472 ses = sesInfoAlloc();
2473 if (ses == NULL)
2474 goto get_ses_fail;
2475
2476 /* new SMB session uses our server ref */
2477 ses->server = server;
2478 if (server->dstaddr.ss_family == AF_INET6)
2479 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2480 else
2481 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2482
2483 if (volume_info->username) {
2484 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2485 if (!ses->user_name)
2486 goto get_ses_fail;
2487 }
2488
2489 /* volume_info->password freed at unmount */
2490 if (volume_info->password) {
2491 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2492 if (!ses->password)
2493 goto get_ses_fail;
2494 }
2495 if (volume_info->domainname) {
2496 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2497 if (!ses->domainName)
2498 goto get_ses_fail;
2499 }
2500 ses->cred_uid = volume_info->cred_uid;
2501 ses->linux_uid = volume_info->linux_uid;
2502
2503 ses->overrideSecFlg = volume_info->secFlg;
2504 ses->sectype = volume_info->sectype;
2505 ses->sign = volume_info->sign;
2506
2507 mutex_lock(&ses->session_mutex);
2508 rc = cifs_negotiate_protocol(xid, ses);
2509 if (!rc)
2510 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2511 mutex_unlock(&ses->session_mutex);
2512 if (rc)
2513 goto get_ses_fail;
2514
2515 /* success, put it on the list */
2516 spin_lock(&cifs_tcp_ses_lock);
2517 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2518 spin_unlock(&cifs_tcp_ses_lock);
2519
2520 free_xid(xid);
2521 return ses;
2522
2523 get_ses_fail:
2524 sesInfoFree(ses);
2525 free_xid(xid);
2526 return ERR_PTR(rc);
2527 }
2528
2529 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2530 {
2531 if (tcon->tidStatus == CifsExiting)
2532 return 0;
2533 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2534 return 0;
2535 return 1;
2536 }
2537
2538 static struct cifs_tcon *
2539 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2540 {
2541 struct list_head *tmp;
2542 struct cifs_tcon *tcon;
2543
2544 spin_lock(&cifs_tcp_ses_lock);
2545 list_for_each(tmp, &ses->tcon_list) {
2546 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2547 if (!match_tcon(tcon, unc))
2548 continue;
2549 ++tcon->tc_count;
2550 spin_unlock(&cifs_tcp_ses_lock);
2551 return tcon;
2552 }
2553 spin_unlock(&cifs_tcp_ses_lock);
2554 return NULL;
2555 }
2556
2557 static void
2558 cifs_put_tcon(struct cifs_tcon *tcon)
2559 {
2560 unsigned int xid;
2561 struct cifs_ses *ses = tcon->ses;
2562
2563 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2564 spin_lock(&cifs_tcp_ses_lock);
2565 if (--tcon->tc_count > 0) {
2566 spin_unlock(&cifs_tcp_ses_lock);
2567 return;
2568 }
2569
2570 list_del_init(&tcon->tcon_list);
2571 spin_unlock(&cifs_tcp_ses_lock);
2572
2573 xid = get_xid();
2574 if (ses->server->ops->tree_disconnect)
2575 ses->server->ops->tree_disconnect(xid, tcon);
2576 _free_xid(xid);
2577
2578 cifs_fscache_release_super_cookie(tcon);
2579 tconInfoFree(tcon);
2580 cifs_put_smb_ses(ses);
2581 }
2582
2583 static struct cifs_tcon *
2584 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2585 {
2586 int rc, xid;
2587 struct cifs_tcon *tcon;
2588
2589 tcon = cifs_find_tcon(ses, volume_info->UNC);
2590 if (tcon) {
2591 cifs_dbg(FYI, "Found match on UNC path\n");
2592 /* existing tcon already has a reference */
2593 cifs_put_smb_ses(ses);
2594 if (tcon->seal != volume_info->seal)
2595 cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
2596 return tcon;
2597 }
2598
2599 if (!ses->server->ops->tree_connect) {
2600 rc = -ENOSYS;
2601 goto out_fail;
2602 }
2603
2604 tcon = tconInfoAlloc();
2605 if (tcon == NULL) {
2606 rc = -ENOMEM;
2607 goto out_fail;
2608 }
2609
2610 tcon->ses = ses;
2611 if (volume_info->password) {
2612 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2613 if (!tcon->password) {
2614 rc = -ENOMEM;
2615 goto out_fail;
2616 }
2617 }
2618
2619 /*
2620 * BB Do we need to wrap session_mutex around this TCon call and Unix
2621 * SetFS as we do on SessSetup and reconnect?
2622 */
2623 xid = get_xid();
2624 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2625 volume_info->local_nls);
2626 free_xid(xid);
2627 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2628 if (rc)
2629 goto out_fail;
2630
2631 if (volume_info->nodfs) {
2632 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2633 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2634 }
2635 tcon->seal = volume_info->seal;
2636 /*
2637 * We can have only one retry value for a connection to a share so for
2638 * resources mounted more than once to the same server share the last
2639 * value passed in for the retry flag is used.
2640 */
2641 tcon->retry = volume_info->retry;
2642 tcon->nocase = volume_info->nocase;
2643 tcon->local_lease = volume_info->local_lease;
2644 INIT_LIST_HEAD(&tcon->pending_opens);
2645
2646 spin_lock(&cifs_tcp_ses_lock);
2647 list_add(&tcon->tcon_list, &ses->tcon_list);
2648 spin_unlock(&cifs_tcp_ses_lock);
2649
2650 cifs_fscache_get_super_cookie(tcon);
2651
2652 return tcon;
2653
2654 out_fail:
2655 tconInfoFree(tcon);
2656 return ERR_PTR(rc);
2657 }
2658
2659 void
2660 cifs_put_tlink(struct tcon_link *tlink)
2661 {
2662 if (!tlink || IS_ERR(tlink))
2663 return;
2664
2665 if (!atomic_dec_and_test(&tlink->tl_count) ||
2666 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2667 tlink->tl_time = jiffies;
2668 return;
2669 }
2670
2671 if (!IS_ERR(tlink_tcon(tlink)))
2672 cifs_put_tcon(tlink_tcon(tlink));
2673 kfree(tlink);
2674 return;
2675 }
2676
2677 static inline struct tcon_link *
2678 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2679 {
2680 return cifs_sb->master_tlink;
2681 }
2682
2683 static int
2684 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2685 {
2686 struct cifs_sb_info *old = CIFS_SB(sb);
2687 struct cifs_sb_info *new = mnt_data->cifs_sb;
2688
2689 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2690 return 0;
2691
2692 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2693 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2694 return 0;
2695
2696 /*
2697 * We want to share sb only if we don't specify an r/wsize or
2698 * specified r/wsize is greater than or equal to existing one.
2699 */
2700 if (new->wsize && new->wsize < old->wsize)
2701 return 0;
2702
2703 if (new->rsize && new->rsize < old->rsize)
2704 return 0;
2705
2706 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2707 return 0;
2708
2709 if (old->mnt_file_mode != new->mnt_file_mode ||
2710 old->mnt_dir_mode != new->mnt_dir_mode)
2711 return 0;
2712
2713 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2714 return 0;
2715
2716 if (old->actimeo != new->actimeo)
2717 return 0;
2718
2719 return 1;
2720 }
2721
2722 int
2723 cifs_match_super(struct super_block *sb, void *data)
2724 {
2725 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2726 struct smb_vol *volume_info;
2727 struct cifs_sb_info *cifs_sb;
2728 struct TCP_Server_Info *tcp_srv;
2729 struct cifs_ses *ses;
2730 struct cifs_tcon *tcon;
2731 struct tcon_link *tlink;
2732 int rc = 0;
2733
2734 spin_lock(&cifs_tcp_ses_lock);
2735 cifs_sb = CIFS_SB(sb);
2736 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2737 if (IS_ERR(tlink)) {
2738 spin_unlock(&cifs_tcp_ses_lock);
2739 return rc;
2740 }
2741 tcon = tlink_tcon(tlink);
2742 ses = tcon->ses;
2743 tcp_srv = ses->server;
2744
2745 volume_info = mnt_data->vol;
2746
2747 if (!match_server(tcp_srv, volume_info) ||
2748 !match_session(ses, volume_info) ||
2749 !match_tcon(tcon, volume_info->UNC)) {
2750 rc = 0;
2751 goto out;
2752 }
2753
2754 rc = compare_mount_options(sb, mnt_data);
2755 out:
2756 spin_unlock(&cifs_tcp_ses_lock);
2757 cifs_put_tlink(tlink);
2758 return rc;
2759 }
2760
2761 int
2762 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2763 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2764 struct dfs_info3_param **referrals, int remap)
2765 {
2766 char *temp_unc;
2767 int rc = 0;
2768
2769 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2770 return -ENOSYS;
2771
2772 *num_referrals = 0;
2773 *referrals = NULL;
2774
2775 if (ses->ipc_tid == 0) {
2776 temp_unc = kmalloc(2 /* for slashes */ +
2777 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2778 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2779 if (temp_unc == NULL)
2780 return -ENOMEM;
2781 temp_unc[0] = '\\';
2782 temp_unc[1] = '\\';
2783 strcpy(temp_unc + 2, ses->serverName);
2784 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2785 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2786 nls_codepage);
2787 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
2788 kfree(temp_unc);
2789 }
2790 if (rc == 0)
2791 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2792 referrals, num_referrals,
2793 nls_codepage, remap);
2794 /*
2795 * BB - map targetUNCs to dfs_info3 structures, here or in
2796 * ses->server->ops->get_dfs_refer.
2797 */
2798
2799 return rc;
2800 }
2801
2802 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2803 static struct lock_class_key cifs_key[2];
2804 static struct lock_class_key cifs_slock_key[2];
2805
2806 static inline void
2807 cifs_reclassify_socket4(struct socket *sock)
2808 {
2809 struct sock *sk = sock->sk;
2810 BUG_ON(sock_owned_by_user(sk));
2811 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2812 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2813 }
2814
2815 static inline void
2816 cifs_reclassify_socket6(struct socket *sock)
2817 {
2818 struct sock *sk = sock->sk;
2819 BUG_ON(sock_owned_by_user(sk));
2820 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2821 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2822 }
2823 #else
2824 static inline void
2825 cifs_reclassify_socket4(struct socket *sock)
2826 {
2827 }
2828
2829 static inline void
2830 cifs_reclassify_socket6(struct socket *sock)
2831 {
2832 }
2833 #endif
2834
2835 /* See RFC1001 section 14 on representation of Netbios names */
2836 static void rfc1002mangle(char *target, char *source, unsigned int length)
2837 {
2838 unsigned int i, j;
2839
2840 for (i = 0, j = 0; i < (length); i++) {
2841 /* mask a nibble at a time and encode */
2842 target[j] = 'A' + (0x0F & (source[i] >> 4));
2843 target[j+1] = 'A' + (0x0F & source[i]);
2844 j += 2;
2845 }
2846
2847 }
2848
2849 static int
2850 bind_socket(struct TCP_Server_Info *server)
2851 {
2852 int rc = 0;
2853 if (server->srcaddr.ss_family != AF_UNSPEC) {
2854 /* Bind to the specified local IP address */
2855 struct socket *socket = server->ssocket;
2856 rc = socket->ops->bind(socket,
2857 (struct sockaddr *) &server->srcaddr,
2858 sizeof(server->srcaddr));
2859 if (rc < 0) {
2860 struct sockaddr_in *saddr4;
2861 struct sockaddr_in6 *saddr6;
2862 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2863 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2864 if (saddr6->sin6_family == AF_INET6)
2865 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2866 &saddr6->sin6_addr, rc);
2867 else
2868 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2869 &saddr4->sin_addr.s_addr, rc);
2870 }
2871 }
2872 return rc;
2873 }
2874
2875 static int
2876 ip_rfc1001_connect(struct TCP_Server_Info *server)
2877 {
2878 int rc = 0;
2879 /*
2880 * some servers require RFC1001 sessinit before sending
2881 * negprot - BB check reconnection in case where second
2882 * sessinit is sent but no second negprot
2883 */
2884 struct rfc1002_session_packet *ses_init_buf;
2885 struct smb_hdr *smb_buf;
2886 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2887 GFP_KERNEL);
2888 if (ses_init_buf) {
2889 ses_init_buf->trailer.session_req.called_len = 32;
2890
2891 if (server->server_RFC1001_name &&
2892 server->server_RFC1001_name[0] != 0)
2893 rfc1002mangle(ses_init_buf->trailer.
2894 session_req.called_name,
2895 server->server_RFC1001_name,
2896 RFC1001_NAME_LEN_WITH_NULL);
2897 else
2898 rfc1002mangle(ses_init_buf->trailer.
2899 session_req.called_name,
2900 DEFAULT_CIFS_CALLED_NAME,
2901 RFC1001_NAME_LEN_WITH_NULL);
2902
2903 ses_init_buf->trailer.session_req.calling_len = 32;
2904
2905 /*
2906 * calling name ends in null (byte 16) from old smb
2907 * convention.
2908 */
2909 if (server->workstation_RFC1001_name &&
2910 server->workstation_RFC1001_name[0] != 0)
2911 rfc1002mangle(ses_init_buf->trailer.
2912 session_req.calling_name,
2913 server->workstation_RFC1001_name,
2914 RFC1001_NAME_LEN_WITH_NULL);
2915 else
2916 rfc1002mangle(ses_init_buf->trailer.
2917 session_req.calling_name,
2918 "LINUX_CIFS_CLNT",
2919 RFC1001_NAME_LEN_WITH_NULL);
2920
2921 ses_init_buf->trailer.session_req.scope1 = 0;
2922 ses_init_buf->trailer.session_req.scope2 = 0;
2923 smb_buf = (struct smb_hdr *)ses_init_buf;
2924
2925 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2926 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2927 rc = smb_send(server, smb_buf, 0x44);
2928 kfree(ses_init_buf);
2929 /*
2930 * RFC1001 layer in at least one server
2931 * requires very short break before negprot
2932 * presumably because not expecting negprot
2933 * to follow so fast. This is a simple
2934 * solution that works without
2935 * complicating the code and causes no
2936 * significant slowing down on mount
2937 * for everyone else
2938 */
2939 usleep_range(1000, 2000);
2940 }
2941 /*
2942 * else the negprot may still work without this
2943 * even though malloc failed
2944 */
2945
2946 return rc;
2947 }
2948
2949 static int
2950 generic_ip_connect(struct TCP_Server_Info *server)
2951 {
2952 int rc = 0;
2953 __be16 sport;
2954 int slen, sfamily;
2955 struct socket *socket = server->ssocket;
2956 struct sockaddr *saddr;
2957
2958 saddr = (struct sockaddr *) &server->dstaddr;
2959
2960 if (server->dstaddr.ss_family == AF_INET6) {
2961 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2962 slen = sizeof(struct sockaddr_in6);
2963 sfamily = AF_INET6;
2964 } else {
2965 sport = ((struct sockaddr_in *) saddr)->sin_port;
2966 slen = sizeof(struct sockaddr_in);
2967 sfamily = AF_INET;
2968 }
2969
2970 if (socket == NULL) {
2971 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2972 IPPROTO_TCP, &socket, 1);
2973 if (rc < 0) {
2974 cifs_dbg(VFS, "Error %d creating socket\n", rc);
2975 server->ssocket = NULL;
2976 return rc;
2977 }
2978
2979 /* BB other socket options to set KEEPALIVE, NODELAY? */
2980 cifs_dbg(FYI, "Socket created\n");
2981 server->ssocket = socket;
2982 socket->sk->sk_allocation = GFP_NOFS;
2983 if (sfamily == AF_INET6)
2984 cifs_reclassify_socket6(socket);
2985 else
2986 cifs_reclassify_socket4(socket);
2987 }
2988
2989 rc = bind_socket(server);
2990 if (rc < 0)
2991 return rc;
2992
2993 /*
2994 * Eventually check for other socket options to change from
2995 * the default. sock_setsockopt not used because it expects
2996 * user space buffer
2997 */
2998 socket->sk->sk_rcvtimeo = 7 * HZ;
2999 socket->sk->sk_sndtimeo = 5 * HZ;
3000
3001 /* make the bufsizes depend on wsize/rsize and max requests */
3002 if (server->noautotune) {
3003 if (socket->sk->sk_sndbuf < (200 * 1024))
3004 socket->sk->sk_sndbuf = 200 * 1024;
3005 if (socket->sk->sk_rcvbuf < (140 * 1024))
3006 socket->sk->sk_rcvbuf = 140 * 1024;
3007 }
3008
3009 if (server->tcp_nodelay) {
3010 int val = 1;
3011 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3012 (char *)&val, sizeof(val));
3013 if (rc)
3014 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3015 rc);
3016 }
3017
3018 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3019 socket->sk->sk_sndbuf,
3020 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3021
3022 rc = socket->ops->connect(socket, saddr, slen, 0);
3023 if (rc < 0) {
3024 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3025 sock_release(socket);
3026 server->ssocket = NULL;
3027 return rc;
3028 }
3029
3030 if (sport == htons(RFC1001_PORT))
3031 rc = ip_rfc1001_connect(server);
3032
3033 return rc;
3034 }
3035
3036 static int
3037 ip_connect(struct TCP_Server_Info *server)
3038 {
3039 __be16 *sport;
3040 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3041 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3042
3043 if (server->dstaddr.ss_family == AF_INET6)
3044 sport = &addr6->sin6_port;
3045 else
3046 sport = &addr->sin_port;
3047
3048 if (*sport == 0) {
3049 int rc;
3050
3051 /* try with 445 port at first */
3052 *sport = htons(CIFS_PORT);
3053
3054 rc = generic_ip_connect(server);
3055 if (rc >= 0)
3056 return rc;
3057
3058 /* if it failed, try with 139 port */
3059 *sport = htons(RFC1001_PORT);
3060 }
3061
3062 return generic_ip_connect(server);
3063 }
3064
3065 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3066 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3067 {
3068 /* if we are reconnecting then should we check to see if
3069 * any requested capabilities changed locally e.g. via
3070 * remount but we can not do much about it here
3071 * if they have (even if we could detect it by the following)
3072 * Perhaps we could add a backpointer to array of sb from tcon
3073 * or if we change to make all sb to same share the same
3074 * sb as NFS - then we only have one backpointer to sb.
3075 * What if we wanted to mount the server share twice once with
3076 * and once without posixacls or posix paths? */
3077 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3078
3079 if (vol_info && vol_info->no_linux_ext) {
3080 tcon->fsUnixInfo.Capability = 0;
3081 tcon->unix_ext = 0; /* Unix Extensions disabled */
3082 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3083 return;
3084 } else if (vol_info)
3085 tcon->unix_ext = 1; /* Unix Extensions supported */
3086
3087 if (tcon->unix_ext == 0) {
3088 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3089 return;
3090 }
3091
3092 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3093 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3094 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3095 /* check for reconnect case in which we do not
3096 want to change the mount behavior if we can avoid it */
3097 if (vol_info == NULL) {
3098 /* turn off POSIX ACL and PATHNAMES if not set
3099 originally at mount time */
3100 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3101 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3102 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3103 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3104 cifs_dbg(VFS, "POSIXPATH support change\n");
3105 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3106 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3107 cifs_dbg(VFS, "possible reconnect error\n");
3108 cifs_dbg(VFS, "server disabled POSIX path support\n");
3109 }
3110 }
3111
3112 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3113 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3114
3115 cap &= CIFS_UNIX_CAP_MASK;
3116 if (vol_info && vol_info->no_psx_acl)
3117 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3118 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3119 cifs_dbg(FYI, "negotiated posix acl support\n");
3120 if (cifs_sb)
3121 cifs_sb->mnt_cifs_flags |=
3122 CIFS_MOUNT_POSIXACL;
3123 }
3124
3125 if (vol_info && vol_info->posix_paths == 0)
3126 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3127 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3128 cifs_dbg(FYI, "negotiate posix pathnames\n");
3129 if (cifs_sb)
3130 cifs_sb->mnt_cifs_flags |=
3131 CIFS_MOUNT_POSIX_PATHS;
3132 }
3133
3134 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3135 #ifdef CONFIG_CIFS_DEBUG2
3136 if (cap & CIFS_UNIX_FCNTL_CAP)
3137 cifs_dbg(FYI, "FCNTL cap\n");
3138 if (cap & CIFS_UNIX_EXTATTR_CAP)
3139 cifs_dbg(FYI, "EXTATTR cap\n");
3140 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3141 cifs_dbg(FYI, "POSIX path cap\n");
3142 if (cap & CIFS_UNIX_XATTR_CAP)
3143 cifs_dbg(FYI, "XATTR cap\n");
3144 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3145 cifs_dbg(FYI, "POSIX ACL cap\n");
3146 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3147 cifs_dbg(FYI, "very large read cap\n");
3148 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3149 cifs_dbg(FYI, "very large write cap\n");
3150 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3151 cifs_dbg(FYI, "transport encryption cap\n");
3152 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3153 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3154 #endif /* CIFS_DEBUG2 */
3155 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3156 if (vol_info == NULL) {
3157 cifs_dbg(FYI, "resetting capabilities failed\n");
3158 } else
3159 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");
3160
3161 }
3162 }
3163 }
3164
3165 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3166 struct cifs_sb_info *cifs_sb)
3167 {
3168 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3169
3170 spin_lock_init(&cifs_sb->tlink_tree_lock);
3171 cifs_sb->tlink_tree = RB_ROOT;
3172
3173 /*
3174 * Temporarily set r/wsize for matching superblock. If we end up using
3175 * new sb then client will later negotiate it downward if needed.
3176 */
3177 cifs_sb->rsize = pvolume_info->rsize;
3178 cifs_sb->wsize = pvolume_info->wsize;
3179
3180 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3181 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3182 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3183 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3184 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3185 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3186
3187 cifs_sb->actimeo = pvolume_info->actimeo;
3188 cifs_sb->local_nls = pvolume_info->local_nls;
3189
3190 if (pvolume_info->noperm)
3191 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3192 if (pvolume_info->setuids)
3193 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3194 if (pvolume_info->server_ino)
3195 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3196 if (pvolume_info->remap)
3197 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3198 if (pvolume_info->no_xattr)
3199 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3200 if (pvolume_info->sfu_emul)
3201 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3202 if (pvolume_info->nobrl)
3203 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3204 if (pvolume_info->nostrictsync)
3205 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3206 if (pvolume_info->mand_lock)
3207 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3208 if (pvolume_info->rwpidforward)
3209 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3210 if (pvolume_info->cifs_acl)
3211 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3212 if (pvolume_info->backupuid_specified) {
3213 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3214 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3215 }
3216 if (pvolume_info->backupgid_specified) {
3217 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3218 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3219 }
3220 if (pvolume_info->override_uid)
3221 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3222 if (pvolume_info->override_gid)
3223 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3224 if (pvolume_info->dynperm)
3225 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3226 if (pvolume_info->fsc)
3227 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3228 if (pvolume_info->multiuser)
3229 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3230 CIFS_MOUNT_NO_PERM);
3231 if (pvolume_info->strict_io)
3232 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3233 if (pvolume_info->direct_io) {
3234 cifs_dbg(FYI, "mounting share using direct i/o\n");
3235 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3236 }
3237 if (pvolume_info->mfsymlinks) {
3238 if (pvolume_info->sfu_emul) {
3239 cifs_dbg(VFS, "mount option mfsymlinks ignored if sfu mount option is used\n");
3240 } else {
3241 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3242 }
3243 }
3244
3245 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3246 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3247 }
3248
3249 static void
3250 cleanup_volume_info_contents(struct smb_vol *volume_info)
3251 {
3252 kfree(volume_info->username);
3253 kzfree(volume_info->password);
3254 kfree(volume_info->UNC);
3255 kfree(volume_info->domainname);
3256 kfree(volume_info->iocharset);
3257 kfree(volume_info->prepath);
3258 }
3259
3260 void
3261 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3262 {
3263 if (!volume_info)
3264 return;
3265 cleanup_volume_info_contents(volume_info);
3266 kfree(volume_info);
3267 }
3268
3269
3270 #ifdef CONFIG_CIFS_DFS_UPCALL
3271 /*
3272 * cifs_build_path_to_root returns full path to root when we do not have an
3273 * exiting connection (tcon)
3274 */
3275 static char *
3276 build_unc_path_to_root(const struct smb_vol *vol,
3277 const struct cifs_sb_info *cifs_sb)
3278 {
3279 char *full_path, *pos;
3280 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3281 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3282
3283 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3284 if (full_path == NULL)
3285 return ERR_PTR(-ENOMEM);
3286
3287 strncpy(full_path, vol->UNC, unc_len);
3288 pos = full_path + unc_len;
3289
3290 if (pplen) {
3291 *pos = CIFS_DIR_SEP(cifs_sb);
3292 strncpy(pos + 1, vol->prepath, pplen);
3293 pos += pplen;
3294 }
3295
3296 *pos = '\0'; /* add trailing null */
3297 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3298 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3299 return full_path;
3300 }
3301
3302 /*
3303 * Perform a dfs referral query for a share and (optionally) prefix
3304 *
3305 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3306 * to a string containing updated options for the submount. Otherwise it
3307 * will be left untouched.
3308 *
3309 * Returns the rc from get_dfs_path to the caller, which can be used to
3310 * determine whether there were referrals.
3311 */
3312 static int
3313 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3314 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3315 int check_prefix)
3316 {
3317 int rc;
3318 unsigned int num_referrals = 0;
3319 struct dfs_info3_param *referrals = NULL;
3320 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3321
3322 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3323 if (IS_ERR(full_path))
3324 return PTR_ERR(full_path);
3325
3326 /* For DFS paths, skip the first '\' of the UNC */
3327 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3328
3329 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3330 &num_referrals, &referrals,
3331 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3332
3333 if (!rc && num_referrals > 0) {
3334 char *fake_devname = NULL;
3335
3336 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3337 full_path + 1, referrals,
3338 &fake_devname);
3339
3340 free_dfs_info_array(referrals, num_referrals);
3341
3342 if (IS_ERR(mdata)) {
3343 rc = PTR_ERR(mdata);
3344 mdata = NULL;
3345 } else {
3346 cleanup_volume_info_contents(volume_info);
3347 rc = cifs_setup_volume_info(volume_info, mdata,
3348 fake_devname);
3349 }
3350 kfree(fake_devname);
3351 kfree(cifs_sb->mountdata);
3352 cifs_sb->mountdata = mdata;
3353 }
3354 kfree(full_path);
3355 return rc;
3356 }
3357 #endif
3358
3359 static int
3360 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3361 const char *devname)
3362 {
3363 int rc = 0;
3364
3365 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3366 return -EINVAL;
3367
3368 if (volume_info->nullauth) {
3369 cifs_dbg(FYI, "Anonymous login\n");
3370 kfree(volume_info->username);
3371 volume_info->username = NULL;
3372 } else if (volume_info->username) {
3373 /* BB fixme parse for domain name here */
3374 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3375 } else {
3376 cifs_dbg(VFS, "No username specified\n");
3377 /* In userspace mount helper we can get user name from alternate
3378 locations such as env variables and files on disk */
3379 return -EINVAL;
3380 }
3381
3382 /* this is needed for ASCII cp to Unicode converts */
3383 if (volume_info->iocharset == NULL) {
3384 /* load_nls_default cannot return null */
3385 volume_info->local_nls = load_nls_default();
3386 } else {
3387 volume_info->local_nls = load_nls(volume_info->iocharset);
3388 if (volume_info->local_nls == NULL) {
3389 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3390 volume_info->iocharset);
3391 return -ELIBACC;
3392 }
3393 }
3394
3395 return rc;
3396 }
3397
3398 struct smb_vol *
3399 cifs_get_volume_info(char *mount_data, const char *devname)
3400 {
3401 int rc;
3402 struct smb_vol *volume_info;
3403
3404 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3405 if (!volume_info)
3406 return ERR_PTR(-ENOMEM);
3407
3408 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3409 if (rc) {
3410 cifs_cleanup_volume_info(volume_info);
3411 volume_info = ERR_PTR(rc);
3412 }
3413
3414 return volume_info;
3415 }
3416
3417 int
3418 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3419 {
3420 int rc;
3421 unsigned int xid;
3422 struct cifs_ses *ses;
3423 struct cifs_tcon *tcon;
3424 struct TCP_Server_Info *server;
3425 char *full_path;
3426 struct tcon_link *tlink;
3427 #ifdef CONFIG_CIFS_DFS_UPCALL
3428 int referral_walks_count = 0;
3429 #endif
3430
3431 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3432 if (rc)
3433 return rc;
3434
3435 #ifdef CONFIG_CIFS_DFS_UPCALL
3436 try_mount_again:
3437 /* cleanup activities if we're chasing a referral */
3438 if (referral_walks_count) {
3439 if (tcon)
3440 cifs_put_tcon(tcon);
3441 else if (ses)
3442 cifs_put_smb_ses(ses);
3443
3444 free_xid(xid);
3445 }
3446 #endif
3447 rc = 0;
3448 tcon = NULL;
3449 ses = NULL;
3450 server = NULL;
3451 full_path = NULL;
3452 tlink = NULL;
3453
3454 xid = get_xid();
3455
3456 /* get a reference to a tcp session */
3457 server = cifs_get_tcp_session(volume_info);
3458 if (IS_ERR(server)) {
3459 rc = PTR_ERR(server);
3460 bdi_destroy(&cifs_sb->bdi);
3461 goto out;
3462 }
3463
3464 /* get a reference to a SMB session */
3465 ses = cifs_get_smb_ses(server, volume_info);
3466 if (IS_ERR(ses)) {
3467 rc = PTR_ERR(ses);
3468 ses = NULL;
3469 goto mount_fail_check;
3470 }
3471
3472 /* search for existing tcon to this server share */
3473 tcon = cifs_get_tcon(ses, volume_info);
3474 if (IS_ERR(tcon)) {
3475 rc = PTR_ERR(tcon);
3476 tcon = NULL;
3477 goto remote_path_check;
3478 }
3479
3480 /* tell server which Unix caps we support */
3481 if (cap_unix(tcon->ses)) {
3482 /* reset of caps checks mount to see if unix extensions
3483 disabled for just this mount */
3484 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3485 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3486 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3487 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3488 rc = -EACCES;
3489 goto mount_fail_check;
3490 }
3491 } else
3492 tcon->unix_ext = 0; /* server does not support them */
3493
3494 /* do not care if a following call succeed - informational */
3495 if (!tcon->ipc && server->ops->qfs_tcon)
3496 server->ops->qfs_tcon(xid, tcon);
3497
3498 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3499 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3500
3501 /* tune readahead according to rsize */
3502 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3503
3504 remote_path_check:
3505 #ifdef CONFIG_CIFS_DFS_UPCALL
3506 /*
3507 * Perform an unconditional check for whether there are DFS
3508 * referrals for this path without prefix, to provide support
3509 * for DFS referrals from w2k8 servers which don't seem to respond
3510 * with PATH_NOT_COVERED to requests that include the prefix.
3511 * Chase the referral if found, otherwise continue normally.
3512 */
3513 if (referral_walks_count == 0) {
3514 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3515 false);
3516 if (!refrc) {
3517 referral_walks_count++;
3518 goto try_mount_again;
3519 }
3520 }
3521 #endif
3522
3523 /* check if a whole path is not remote */
3524 if (!rc && tcon) {
3525 if (!server->ops->is_path_accessible) {
3526 rc = -ENOSYS;
3527 goto mount_fail_check;
3528 }
3529 /*
3530 * cifs_build_path_to_root works only when we have a valid tcon
3531 */
3532 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3533 if (full_path == NULL) {
3534 rc = -ENOMEM;
3535 goto mount_fail_check;
3536 }
3537 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3538 full_path);
3539 if (rc != 0 && rc != -EREMOTE) {
3540 kfree(full_path);
3541 goto mount_fail_check;
3542 }
3543 kfree(full_path);
3544 }
3545
3546 /* get referral if needed */
3547 if (rc == -EREMOTE) {
3548 #ifdef CONFIG_CIFS_DFS_UPCALL
3549 if (referral_walks_count > MAX_NESTED_LINKS) {
3550 /*
3551 * BB: when we implement proper loop detection,
3552 * we will remove this check. But now we need it
3553 * to prevent an indefinite loop if 'DFS tree' is
3554 * misconfigured (i.e. has loops).
3555 */
3556 rc = -ELOOP;
3557 goto mount_fail_check;
3558 }
3559
3560 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3561
3562 if (!rc) {
3563 referral_walks_count++;
3564 goto try_mount_again;
3565 }
3566 goto mount_fail_check;
3567 #else /* No DFS support, return error on mount */
3568 rc = -EOPNOTSUPP;
3569 #endif
3570 }
3571
3572 if (rc)
3573 goto mount_fail_check;
3574
3575 /* now, hang the tcon off of the superblock */
3576 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3577 if (tlink == NULL) {
3578 rc = -ENOMEM;
3579 goto mount_fail_check;
3580 }
3581
3582 tlink->tl_uid = ses->linux_uid;
3583 tlink->tl_tcon = tcon;
3584 tlink->tl_time = jiffies;
3585 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3586 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3587
3588 cifs_sb->master_tlink = tlink;
3589 spin_lock(&cifs_sb->tlink_tree_lock);
3590 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3591 spin_unlock(&cifs_sb->tlink_tree_lock);
3592
3593 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3594 TLINK_IDLE_EXPIRE);
3595
3596 mount_fail_check:
3597 /* on error free sesinfo and tcon struct if needed */
3598 if (rc) {
3599 /* If find_unc succeeded then rc == 0 so we can not end */
3600 /* up accidentally freeing someone elses tcon struct */
3601 if (tcon)
3602 cifs_put_tcon(tcon);
3603 else if (ses)
3604 cifs_put_smb_ses(ses);
3605 else
3606 cifs_put_tcp_session(server);
3607 bdi_destroy(&cifs_sb->bdi);
3608 }
3609
3610 out:
3611 free_xid(xid);
3612 return rc;
3613 }
3614
3615 /*
3616 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3617 * pointer may be NULL.
3618 */
3619 int
3620 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3621 const char *tree, struct cifs_tcon *tcon,
3622 const struct nls_table *nls_codepage)
3623 {
3624 struct smb_hdr *smb_buffer;
3625 struct smb_hdr *smb_buffer_response;
3626 TCONX_REQ *pSMB;
3627 TCONX_RSP *pSMBr;
3628 unsigned char *bcc_ptr;
3629 int rc = 0;
3630 int length;
3631 __u16 bytes_left, count;
3632
3633 if (ses == NULL)
3634 return -EIO;
3635
3636 smb_buffer = cifs_buf_get();
3637 if (smb_buffer == NULL)
3638 return -ENOMEM;
3639
3640 smb_buffer_response = smb_buffer;
3641
3642 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3643 NULL /*no tid */ , 4 /*wct */ );
3644
3645 smb_buffer->Mid = get_next_mid(ses->server);
3646 smb_buffer->Uid = ses->Suid;
3647 pSMB = (TCONX_REQ *) smb_buffer;
3648 pSMBr = (TCONX_RSP *) smb_buffer_response;
3649
3650 pSMB->AndXCommand = 0xFF;
3651 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3652 bcc_ptr = &pSMB->Password[0];
3653 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3654 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3655 *bcc_ptr = 0; /* password is null byte */
3656 bcc_ptr++; /* skip password */
3657 /* already aligned so no need to do it below */
3658 } else {
3659 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3660 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3661 specified as required (when that support is added to
3662 the vfs in the future) as only NTLM or the much
3663 weaker LANMAN (which we do not send by default) is accepted
3664 by Samba (not sure whether other servers allow
3665 NTLMv2 password here) */
3666 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3667 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3668 (ses->server->secType == LANMAN))
3669 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3670 ses->server->sec_mode &
3671 SECMODE_PW_ENCRYPT ? true : false,
3672 bcc_ptr);
3673 else
3674 #endif /* CIFS_WEAK_PW_HASH */
3675 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3676 bcc_ptr, nls_codepage);
3677
3678 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3679 if (ses->capabilities & CAP_UNICODE) {
3680 /* must align unicode strings */
3681 *bcc_ptr = 0; /* null byte password */
3682 bcc_ptr++;
3683 }
3684 }
3685
3686 if (ses->server->sec_mode &
3687 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3688 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3689
3690 if (ses->capabilities & CAP_STATUS32) {
3691 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3692 }
3693 if (ses->capabilities & CAP_DFS) {
3694 smb_buffer->Flags2 |= SMBFLG2_DFS;
3695 }
3696 if (ses->capabilities & CAP_UNICODE) {
3697 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3698 length =
3699 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3700 6 /* max utf8 char length in bytes */ *
3701 (/* server len*/ + 256 /* share len */), nls_codepage);
3702 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3703 bcc_ptr += 2; /* skip trailing null */
3704 } else { /* ASCII */
3705 strcpy(bcc_ptr, tree);
3706 bcc_ptr += strlen(tree) + 1;
3707 }
3708 strcpy(bcc_ptr, "?????");
3709 bcc_ptr += strlen("?????");
3710 bcc_ptr += 1;
3711 count = bcc_ptr - &pSMB->Password[0];
3712 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3713 pSMB->hdr.smb_buf_length) + count);
3714 pSMB->ByteCount = cpu_to_le16(count);
3715
3716 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3717 0);
3718
3719 /* above now done in SendReceive */
3720 if ((rc == 0) && (tcon != NULL)) {
3721 bool is_unicode;
3722
3723 tcon->tidStatus = CifsGood;
3724 tcon->need_reconnect = false;
3725 tcon->tid = smb_buffer_response->Tid;
3726 bcc_ptr = pByteArea(smb_buffer_response);
3727 bytes_left = get_bcc(smb_buffer_response);
3728 length = strnlen(bcc_ptr, bytes_left - 2);
3729 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3730 is_unicode = true;
3731 else
3732 is_unicode = false;
3733
3734
3735 /* skip service field (NB: this field is always ASCII) */
3736 if (length == 3) {
3737 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3738 (bcc_ptr[2] == 'C')) {
3739 cifs_dbg(FYI, "IPC connection\n");
3740 tcon->ipc = 1;
3741 }
3742 } else if (length == 2) {
3743 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3744 /* the most common case */
3745 cifs_dbg(FYI, "disk share connection\n");
3746 }
3747 }
3748 bcc_ptr += length + 1;
3749 bytes_left -= (length + 1);
3750 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3751
3752 /* mostly informational -- no need to fail on error here */
3753 kfree(tcon->nativeFileSystem);
3754 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3755 bytes_left, is_unicode,
3756 nls_codepage);
3757
3758 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
3759
3760 if ((smb_buffer_response->WordCount == 3) ||
3761 (smb_buffer_response->WordCount == 7))
3762 /* field is in same location */
3763 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3764 else
3765 tcon->Flags = 0;
3766 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
3767 } else if ((rc == 0) && tcon == NULL) {
3768 /* all we need to save for IPC$ connection */
3769 ses->ipc_tid = smb_buffer_response->Tid;
3770 }
3771
3772 cifs_buf_release(smb_buffer);
3773 return rc;
3774 }
3775
3776 void
3777 cifs_umount(struct cifs_sb_info *cifs_sb)
3778 {
3779 struct rb_root *root = &cifs_sb->tlink_tree;
3780 struct rb_node *node;
3781 struct tcon_link *tlink;
3782
3783 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3784
3785 spin_lock(&cifs_sb->tlink_tree_lock);
3786 while ((node = rb_first(root))) {
3787 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3788 cifs_get_tlink(tlink);
3789 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3790 rb_erase(node, root);
3791
3792 spin_unlock(&cifs_sb->tlink_tree_lock);
3793 cifs_put_tlink(tlink);
3794 spin_lock(&cifs_sb->tlink_tree_lock);
3795 }
3796 spin_unlock(&cifs_sb->tlink_tree_lock);
3797
3798 bdi_destroy(&cifs_sb->bdi);
3799 kfree(cifs_sb->mountdata);
3800 unload_nls(cifs_sb->local_nls);
3801 kfree(cifs_sb);
3802 }
3803
3804 int
3805 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3806 {
3807 int rc = 0;
3808 struct TCP_Server_Info *server = ses->server;
3809
3810 if (!server->ops->need_neg || !server->ops->negotiate)
3811 return -ENOSYS;
3812
3813 /* only send once per connect */
3814 if (!server->ops->need_neg(server))
3815 return 0;
3816
3817 set_credits(server, 1);
3818
3819 rc = server->ops->negotiate(xid, ses);
3820 if (rc == 0) {
3821 spin_lock(&GlobalMid_Lock);
3822 if (server->tcpStatus == CifsNeedNegotiate)
3823 server->tcpStatus = CifsGood;
3824 else
3825 rc = -EHOSTDOWN;
3826 spin_unlock(&GlobalMid_Lock);
3827 }
3828
3829 return rc;
3830 }
3831
3832 int
3833 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3834 struct nls_table *nls_info)
3835 {
3836 int rc = -ENOSYS;
3837 struct TCP_Server_Info *server = ses->server;
3838
3839 ses->capabilities = server->capabilities;
3840 if (linuxExtEnabled == 0)
3841 ses->capabilities &= (~server->vals->cap_unix);
3842
3843 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
3844 server->sec_mode, server->capabilities, server->timeAdj);
3845
3846 if (server->ops->sess_setup)
3847 rc = server->ops->sess_setup(xid, ses, nls_info);
3848
3849 if (rc) {
3850 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
3851 } else {
3852 mutex_lock(&server->srv_mutex);
3853 if (!server->session_estab) {
3854 server->session_key.response = ses->auth_key.response;
3855 server->session_key.len = ses->auth_key.len;
3856 server->sequence_number = 0x2;
3857 server->session_estab = true;
3858 ses->auth_key.response = NULL;
3859 }
3860 mutex_unlock(&server->srv_mutex);
3861
3862 cifs_dbg(FYI, "CIFS Session Established successfully\n");
3863 spin_lock(&GlobalMid_Lock);
3864 ses->status = CifsGood;
3865 ses->need_reconnect = false;
3866 spin_unlock(&GlobalMid_Lock);
3867 }
3868
3869 kfree(ses->auth_key.response);
3870 ses->auth_key.response = NULL;
3871 ses->auth_key.len = 0;
3872 kfree(ses->ntlmssp);
3873 ses->ntlmssp = NULL;
3874
3875 return rc;
3876 }
3877
3878 static int
3879 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3880 {
3881 switch (ses->server->secType) {
3882 case Kerberos:
3883 vol->secFlg = CIFSSEC_MUST_KRB5;
3884 return 0;
3885 case NTLMv2:
3886 vol->secFlg = CIFSSEC_MUST_NTLMV2;
3887 break;
3888 case NTLM:
3889 vol->secFlg = CIFSSEC_MUST_NTLM;
3890 break;
3891 case RawNTLMSSP:
3892 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
3893 break;
3894 case LANMAN:
3895 vol->secFlg = CIFSSEC_MUST_LANMAN;
3896 break;
3897 }
3898
3899 return cifs_set_cifscreds(vol, ses);
3900 }
3901
3902 static struct cifs_tcon *
3903 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
3904 {
3905 int rc;
3906 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3907 struct cifs_ses *ses;
3908 struct cifs_tcon *tcon = NULL;
3909 struct smb_vol *vol_info;
3910
3911 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3912 if (vol_info == NULL)
3913 return ERR_PTR(-ENOMEM);
3914
3915 vol_info->local_nls = cifs_sb->local_nls;
3916 vol_info->linux_uid = fsuid;
3917 vol_info->cred_uid = fsuid;
3918 vol_info->UNC = master_tcon->treeName;
3919 vol_info->retry = master_tcon->retry;
3920 vol_info->nocase = master_tcon->nocase;
3921 vol_info->local_lease = master_tcon->local_lease;
3922 vol_info->no_linux_ext = !master_tcon->unix_ext;
3923 vol_info->sectype = master_tcon->ses->sectype;
3924 vol_info->sign = master_tcon->ses->sign;
3925
3926 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
3927 if (rc) {
3928 tcon = ERR_PTR(rc);
3929 goto out;
3930 }
3931
3932 /* get a reference for the same TCP session */
3933 spin_lock(&cifs_tcp_ses_lock);
3934 ++master_tcon->ses->server->srv_count;
3935 spin_unlock(&cifs_tcp_ses_lock);
3936
3937 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3938 if (IS_ERR(ses)) {
3939 tcon = (struct cifs_tcon *)ses;
3940 cifs_put_tcp_session(master_tcon->ses->server);
3941 goto out;
3942 }
3943
3944 tcon = cifs_get_tcon(ses, vol_info);
3945 if (IS_ERR(tcon)) {
3946 cifs_put_smb_ses(ses);
3947 goto out;
3948 }
3949
3950 if (cap_unix(ses))
3951 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3952 out:
3953 kfree(vol_info->username);
3954 kfree(vol_info->password);
3955 kfree(vol_info);
3956
3957 return tcon;
3958 }
3959
3960 struct cifs_tcon *
3961 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3962 {
3963 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3964 }
3965
3966 static int
3967 cifs_sb_tcon_pending_wait(void *unused)
3968 {
3969 schedule();
3970 return signal_pending(current) ? -ERESTARTSYS : 0;
3971 }
3972
3973 /* find and return a tlink with given uid */
3974 static struct tcon_link *
3975 tlink_rb_search(struct rb_root *root, kuid_t uid)
3976 {
3977 struct rb_node *node = root->rb_node;
3978 struct tcon_link *tlink;
3979
3980 while (node) {
3981 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3982
3983 if (uid_gt(tlink->tl_uid, uid))
3984 node = node->rb_left;
3985 else if (uid_lt(tlink->tl_uid, uid))
3986 node = node->rb_right;
3987 else
3988 return tlink;
3989 }
3990 return NULL;
3991 }
3992
3993 /* insert a tcon_link into the tree */
3994 static void
3995 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3996 {
3997 struct rb_node **new = &(root->rb_node), *parent = NULL;
3998 struct tcon_link *tlink;
3999
4000 while (*new) {
4001 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
4002 parent = *new;
4003
4004 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
4005 new = &((*new)->rb_left);
4006 else
4007 new = &((*new)->rb_right);
4008 }
4009
4010 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4011 rb_insert_color(&new_tlink->tl_rbnode, root);
4012 }
4013
4014 /*
4015 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4016 * current task.
4017 *
4018 * If the superblock doesn't refer to a multiuser mount, then just return
4019 * the master tcon for the mount.
4020 *
4021 * First, search the rbtree for an existing tcon for this fsuid. If one
4022 * exists, then check to see if it's pending construction. If it is then wait
4023 * for construction to complete. Once it's no longer pending, check to see if
4024 * it failed and either return an error or retry construction, depending on
4025 * the timeout.
4026 *
4027 * If one doesn't exist then insert a new tcon_link struct into the tree and
4028 * try to construct a new one.
4029 */
4030 struct tcon_link *
4031 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4032 {
4033 int ret;
4034 kuid_t fsuid = current_fsuid();
4035 struct tcon_link *tlink, *newtlink;
4036
4037 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4038 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4039
4040 spin_lock(&cifs_sb->tlink_tree_lock);
4041 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4042 if (tlink)
4043 cifs_get_tlink(tlink);
4044 spin_unlock(&cifs_sb->tlink_tree_lock);
4045
4046 if (tlink == NULL) {
4047 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4048 if (newtlink == NULL)
4049 return ERR_PTR(-ENOMEM);
4050 newtlink->tl_uid = fsuid;
4051 newtlink->tl_tcon = ERR_PTR(-EACCES);
4052 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4053 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4054 cifs_get_tlink(newtlink);
4055
4056 spin_lock(&cifs_sb->tlink_tree_lock);
4057 /* was one inserted after previous search? */
4058 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4059 if (tlink) {
4060 cifs_get_tlink(tlink);
4061 spin_unlock(&cifs_sb->tlink_tree_lock);
4062 kfree(newtlink);
4063 goto wait_for_construction;
4064 }
4065 tlink = newtlink;
4066 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4067 spin_unlock(&cifs_sb->tlink_tree_lock);
4068 } else {
4069 wait_for_construction:
4070 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4071 cifs_sb_tcon_pending_wait,
4072 TASK_INTERRUPTIBLE);
4073 if (ret) {
4074 cifs_put_tlink(tlink);
4075 return ERR_PTR(ret);
4076 }
4077
4078 /* if it's good, return it */
4079 if (!IS_ERR(tlink->tl_tcon))
4080 return tlink;
4081
4082 /* return error if we tried this already recently */
4083 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4084 cifs_put_tlink(tlink);
4085 return ERR_PTR(-EACCES);
4086 }
4087
4088 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4089 goto wait_for_construction;
4090 }
4091
4092 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4093 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4094 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4095
4096 if (IS_ERR(tlink->tl_tcon)) {
4097 cifs_put_tlink(tlink);
4098 return ERR_PTR(-EACCES);
4099 }
4100
4101 return tlink;
4102 }
4103
4104 /*
4105 * periodic workqueue job that scans tcon_tree for a superblock and closes
4106 * out tcons.
4107 */
4108 static void
4109 cifs_prune_tlinks(struct work_struct *work)
4110 {
4111 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4112 prune_tlinks.work);
4113 struct rb_root *root = &cifs_sb->tlink_tree;
4114 struct rb_node *node = rb_first(root);
4115 struct rb_node *tmp;
4116 struct tcon_link *tlink;
4117
4118 /*
4119 * Because we drop the spinlock in the loop in order to put the tlink
4120 * it's not guarded against removal of links from the tree. The only
4121 * places that remove entries from the tree are this function and
4122 * umounts. Because this function is non-reentrant and is canceled
4123 * before umount can proceed, this is safe.
4124 */
4125 spin_lock(&cifs_sb->tlink_tree_lock);
4126 node = rb_first(root);
4127 while (node != NULL) {
4128 tmp = node;
4129 node = rb_next(tmp);
4130 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4131
4132 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4133 atomic_read(&tlink->tl_count) != 0 ||
4134 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4135 continue;
4136
4137 cifs_get_tlink(tlink);
4138 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4139 rb_erase(tmp, root);
4140
4141 spin_unlock(&cifs_sb->tlink_tree_lock);
4142 cifs_put_tlink(tlink);
4143 spin_lock(&cifs_sb->tlink_tree_lock);
4144 }
4145 spin_unlock(&cifs_sb->tlink_tree_lock);
4146
4147 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4148 TLINK_IDLE_EXPIRE);
4149 }
Linux kernel - Deliverables
This page took 0.118654 seconds and 6 git commands to generate.