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