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