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