projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
cifs: extend the buffer length enought for sprintf() using
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / cifs / connect.c
1 /*
2 * fs/cifs/connect.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2011
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21 #include <linux/fs.h>
22 #include <linux/net.h>
23 #include <linux/string.h>
24 #include <linux/list.h>
25 #include <linux/wait.h>
26 #include <linux/slab.h>
27 #include <linux/pagemap.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/mempool.h>
31 #include <linux/delay.h>
32 #include <linux/completion.h>
33 #include <linux/kthread.h>
34 #include <linux/pagevec.h>
35 #include <linux/freezer.h>
36 #include <linux/namei.h>
37 #include <asm/uaccess.h>
38 #include <asm/processor.h>
39 #include <linux/inet.h>
40 #include <linux/module.h>
41 #include <keys/user-type.h>
42 #include <net/ipv6.h>
43 #include <linux/parser.h>
44
45 #include "cifspdu.h"
46 #include "cifsglob.h"
47 #include "cifsproto.h"
48 #include "cifs_unicode.h"
49 #include "cifs_debug.h"
50 #include "cifs_fs_sb.h"
51 #include "ntlmssp.h"
52 #include "nterr.h"
53 #include "rfc1002pdu.h"
54 #include "fscache.h"
55
56 #define CIFS_PORT 445
57 #define RFC1001_PORT 139
58
59 extern mempool_t *cifs_req_poolp;
60
61 /* FIXME: should these be tunable? */
62 #define TLINK_ERROR_EXPIRE (1 * HZ)
63 #define TLINK_IDLE_EXPIRE (600 * HZ)
64
65 enum {
66
67 /* Mount options that take no arguments */
68 Opt_user_xattr, Opt_nouser_xattr,
69 Opt_forceuid, Opt_noforceuid,
70 Opt_forcegid, Opt_noforcegid,
71 Opt_noblocksend, Opt_noautotune,
72 Opt_hard, Opt_soft, Opt_perm, Opt_noperm,
73 Opt_mapchars, Opt_nomapchars, Opt_sfu,
74 Opt_nosfu, Opt_nodfs, Opt_posixpaths,
75 Opt_noposixpaths, Opt_nounix,
76 Opt_nocase,
77 Opt_brl, Opt_nobrl,
78 Opt_forcemandatorylock, Opt_setuids,
79 Opt_nosetuids, Opt_dynperm, Opt_nodynperm,
80 Opt_nohard, Opt_nosoft,
81 Opt_nointr, Opt_intr,
82 Opt_nostrictsync, Opt_strictsync,
83 Opt_serverino, Opt_noserverino,
84 Opt_rwpidforward, Opt_cifsacl, Opt_nocifsacl,
85 Opt_acl, Opt_noacl, Opt_locallease,
86 Opt_sign, Opt_seal, Opt_noac,
87 Opt_fsc, Opt_mfsymlinks,
88 Opt_multiuser, Opt_sloppy,
89
90 /* Mount options which take numeric value */
91 Opt_backupuid, Opt_backupgid, Opt_uid,
92 Opt_cruid, Opt_gid, Opt_file_mode,
93 Opt_dirmode, Opt_port,
94 Opt_rsize, Opt_wsize, Opt_actimeo,
95
96 /* Mount options which take string value */
97 Opt_user, Opt_pass, Opt_ip,
98 Opt_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, CIFS_MAX_DOMAINNAME_LEN)
1666 == CIFS_MAX_DOMAINNAME_LEN) {
1667 printk(KERN_WARNING "CIFS: domain name too"
1668 " long\n");
1669 goto cifs_parse_mount_err;
1670 }
1671
1672 vol->domainname = kstrdup(string, GFP_KERNEL);
1673 if (!vol->domainname) {
1674 printk(KERN_WARNING "CIFS: no memory "
1675 "for domainname\n");
1676 goto cifs_parse_mount_err;
1677 }
1678 cifs_dbg(FYI, "Domain name set\n");
1679 break;
1680 case Opt_srcaddr:
1681 string = match_strdup(args);
1682 if (string == NULL)
1683 goto out_nomem;
1684
1685 if (!cifs_convert_address(
1686 (struct sockaddr *)&vol->srcaddr,
1687 string, strlen(string))) {
1688 printk(KERN_WARNING "CIFS: Could not parse"
1689 " srcaddr: %s\n", string);
1690 goto cifs_parse_mount_err;
1691 }
1692 break;
1693 case Opt_iocharset:
1694 string = match_strdup(args);
1695 if (string == NULL)
1696 goto out_nomem;
1697
1698 if (strnlen(string, 1024) >= 65) {
1699 printk(KERN_WARNING "CIFS: iocharset name "
1700 "too long.\n");
1701 goto cifs_parse_mount_err;
1702 }
1703
1704 if (strnicmp(string, "default", 7) != 0) {
1705 vol->iocharset = kstrdup(string,
1706 GFP_KERNEL);
1707 if (!vol->iocharset) {
1708 printk(KERN_WARNING "CIFS: no memory"
1709 "for charset\n");
1710 goto cifs_parse_mount_err;
1711 }
1712 }
1713 /* if iocharset not set then load_nls_default
1714 * is used by caller
1715 */
1716 cifs_dbg(FYI, "iocharset set to %s\n", string);
1717 break;
1718 case Opt_netbiosname:
1719 string = match_strdup(args);
1720 if (string == NULL)
1721 goto out_nomem;
1722
1723 memset(vol->source_rfc1001_name, 0x20,
1724 RFC1001_NAME_LEN);
1725 /*
1726 * FIXME: are there cases in which a comma can
1727 * be valid in workstation netbios name (and
1728 * need special handling)?
1729 */
1730 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1731 /* don't ucase netbiosname for user */
1732 if (string[i] == 0)
1733 break;
1734 vol->source_rfc1001_name[i] = string[i];
1735 }
1736 /* The string has 16th byte zero still from
1737 * set at top of the function
1738 */
1739 if (i == RFC1001_NAME_LEN && string[i] != 0)
1740 printk(KERN_WARNING "CIFS: netbiosname"
1741 " longer than 15 truncated.\n");
1742
1743 break;
1744 case Opt_servern:
1745 /* servernetbiosname specified override *SMBSERVER */
1746 string = match_strdup(args);
1747 if (string == NULL)
1748 goto out_nomem;
1749
1750 /* last byte, type, is 0x20 for servr type */
1751 memset(vol->target_rfc1001_name, 0x20,
1752 RFC1001_NAME_LEN_WITH_NULL);
1753
1754 /* BB are there cases in which a comma can be
1755 valid in this workstation netbios name
1756 (and need special handling)? */
1757
1758 /* user or mount helper must uppercase the
1759 netbios name */
1760 for (i = 0; i < 15; i++) {
1761 if (string[i] == 0)
1762 break;
1763 vol->target_rfc1001_name[i] = string[i];
1764 }
1765 /* The string has 16th byte zero still from
1766 set at top of the function */
1767 if (i == RFC1001_NAME_LEN && string[i] != 0)
1768 printk(KERN_WARNING "CIFS: server net"
1769 "biosname longer than 15 truncated.\n");
1770 break;
1771 case Opt_ver:
1772 string = match_strdup(args);
1773 if (string == NULL)
1774 goto out_nomem;
1775
1776 if (strnicmp(string, "1", 1) == 0) {
1777 /* This is the default */
1778 break;
1779 }
1780 /* For all other value, error */
1781 printk(KERN_WARNING "CIFS: Invalid version"
1782 " specified\n");
1783 goto cifs_parse_mount_err;
1784 case Opt_vers:
1785 string = match_strdup(args);
1786 if (string == NULL)
1787 goto out_nomem;
1788
1789 if (cifs_parse_smb_version(string, vol) != 0)
1790 goto cifs_parse_mount_err;
1791 break;
1792 case Opt_sec:
1793 string = match_strdup(args);
1794 if (string == NULL)
1795 goto out_nomem;
1796
1797 if (cifs_parse_security_flavors(string, vol) != 0)
1798 goto cifs_parse_mount_err;
1799 break;
1800 case Opt_cache:
1801 string = match_strdup(args);
1802 if (string == NULL)
1803 goto out_nomem;
1804
1805 if (cifs_parse_cache_flavor(string, vol) != 0)
1806 goto cifs_parse_mount_err;
1807 break;
1808 default:
1809 /*
1810 * An option we don't recognize. Save it off for later
1811 * if we haven't already found one
1812 */
1813 if (!invalid)
1814 invalid = data;
1815 break;
1816 }
1817 /* Free up any allocated string */
1818 kfree(string);
1819 string = NULL;
1820 }
1821
1822 if (!sloppy && invalid) {
1823 printk(KERN_ERR "CIFS: Unknown mount option \"%s\"\n", invalid);
1824 goto cifs_parse_mount_err;
1825 }
1826
1827 #ifndef CONFIG_KEYS
1828 /* Muliuser mounts require CONFIG_KEYS support */
1829 if (vol->multiuser) {
1830 cifs_dbg(VFS, "Multiuser mounts require kernels with CONFIG_KEYS enabled\n");
1831 goto cifs_parse_mount_err;
1832 }
1833 #endif
1834 if (!vol->UNC) {
1835 cifs_dbg(VFS, "CIFS mount error: No usable UNC path provided in device string!\n");
1836 goto cifs_parse_mount_err;
1837 }
1838
1839 /* make sure UNC has a share name */
1840 if (!strchr(vol->UNC + 3, '\\')) {
1841 cifs_dbg(VFS, "Malformed UNC. Unable to find share name.\n");
1842 goto cifs_parse_mount_err;
1843 }
1844
1845 if (!got_ip) {
1846 /* No ip= option specified? Try to get it from UNC */
1847 if (!cifs_convert_address(dstaddr, &vol->UNC[2],
1848 strlen(&vol->UNC[2]))) {
1849 printk(KERN_ERR "Unable to determine destination "
1850 "address.\n");
1851 goto cifs_parse_mount_err;
1852 }
1853 }
1854
1855 /* set the port that we got earlier */
1856 cifs_set_port(dstaddr, port);
1857
1858 if (uid_specified)
1859 vol->override_uid = override_uid;
1860 else if (override_uid == 1)
1861 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1862 "specified with no uid= option.\n");
1863
1864 if (gid_specified)
1865 vol->override_gid = override_gid;
1866 else if (override_gid == 1)
1867 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1868 "specified with no gid= option.\n");
1869
1870 kfree(mountdata_copy);
1871 return 0;
1872
1873 out_nomem:
1874 printk(KERN_WARNING "Could not allocate temporary buffer\n");
1875 cifs_parse_mount_err:
1876 kfree(string);
1877 kfree(mountdata_copy);
1878 return 1;
1879 }
1880
1881 /** Returns true if srcaddr isn't specified and rhs isn't
1882 * specified, or if srcaddr is specified and
1883 * matches the IP address of the rhs argument.
1884 */
1885 static bool
1886 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1887 {
1888 switch (srcaddr->sa_family) {
1889 case AF_UNSPEC:
1890 return (rhs->sa_family == AF_UNSPEC);
1891 case AF_INET: {
1892 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1893 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1894 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1895 }
1896 case AF_INET6: {
1897 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1898 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)rhs;
1899 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1900 }
1901 default:
1902 WARN_ON(1);
1903 return false; /* don't expect to be here */
1904 }
1905 }
1906
1907 /*
1908 * If no port is specified in addr structure, we try to match with 445 port
1909 * and if it fails - with 139 ports. It should be called only if address
1910 * families of server and addr are equal.
1911 */
1912 static bool
1913 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1914 {
1915 __be16 port, *sport;
1916
1917 switch (addr->sa_family) {
1918 case AF_INET:
1919 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1920 port = ((struct sockaddr_in *) addr)->sin_port;
1921 break;
1922 case AF_INET6:
1923 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1924 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1925 break;
1926 default:
1927 WARN_ON(1);
1928 return false;
1929 }
1930
1931 if (!port) {
1932 port = htons(CIFS_PORT);
1933 if (port == *sport)
1934 return true;
1935
1936 port = htons(RFC1001_PORT);
1937 }
1938
1939 return port == *sport;
1940 }
1941
1942 static bool
1943 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1944 struct sockaddr *srcaddr)
1945 {
1946 switch (addr->sa_family) {
1947 case AF_INET: {
1948 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1949 struct sockaddr_in *srv_addr4 =
1950 (struct sockaddr_in *)&server->dstaddr;
1951
1952 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1953 return false;
1954 break;
1955 }
1956 case AF_INET6: {
1957 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1958 struct sockaddr_in6 *srv_addr6 =
1959 (struct sockaddr_in6 *)&server->dstaddr;
1960
1961 if (!ipv6_addr_equal(&addr6->sin6_addr,
1962 &srv_addr6->sin6_addr))
1963 return false;
1964 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1965 return false;
1966 break;
1967 }
1968 default:
1969 WARN_ON(1);
1970 return false; /* don't expect to be here */
1971 }
1972
1973 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1974 return false;
1975
1976 return true;
1977 }
1978
1979 static bool
1980 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1981 {
1982 unsigned int secFlags;
1983
1984 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1985 secFlags = vol->secFlg;
1986 else
1987 secFlags = global_secflags | vol->secFlg;
1988
1989 switch (server->secType) {
1990 case LANMAN:
1991 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1992 return false;
1993 break;
1994 case NTLMv2:
1995 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1996 return false;
1997 break;
1998 case NTLM:
1999 if (!(secFlags & CIFSSEC_MAY_NTLM))
2000 return false;
2001 break;
2002 case Kerberos:
2003 if (!(secFlags & CIFSSEC_MAY_KRB5))
2004 return false;
2005 break;
2006 case RawNTLMSSP:
2007 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
2008 return false;
2009 break;
2010 default:
2011 /* shouldn't happen */
2012 return false;
2013 }
2014
2015 /* now check if signing mode is acceptable */
2016 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
2017 (server->sec_mode & SECMODE_SIGN_REQUIRED))
2018 return false;
2019 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
2020 (server->sec_mode &
2021 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
2022 return false;
2023
2024 return true;
2025 }
2026
2027 static int match_server(struct TCP_Server_Info *server, struct smb_vol *vol)
2028 {
2029 struct sockaddr *addr = (struct sockaddr *)&vol->dstaddr;
2030
2031 if ((server->vals != vol->vals) || (server->ops != vol->ops))
2032 return 0;
2033
2034 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
2035 return 0;
2036
2037 if (!match_address(server, addr,
2038 (struct sockaddr *)&vol->srcaddr))
2039 return 0;
2040
2041 if (!match_port(server, addr))
2042 return 0;
2043
2044 if (!match_security(server, vol))
2045 return 0;
2046
2047 return 1;
2048 }
2049
2050 static struct TCP_Server_Info *
2051 cifs_find_tcp_session(struct smb_vol *vol)
2052 {
2053 struct TCP_Server_Info *server;
2054
2055 spin_lock(&cifs_tcp_ses_lock);
2056 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
2057 if (!match_server(server, vol))
2058 continue;
2059
2060 ++server->srv_count;
2061 spin_unlock(&cifs_tcp_ses_lock);
2062 cifs_dbg(FYI, "Existing tcp session with server found\n");
2063 return server;
2064 }
2065 spin_unlock(&cifs_tcp_ses_lock);
2066 return NULL;
2067 }
2068
2069 static void
2070 cifs_put_tcp_session(struct TCP_Server_Info *server)
2071 {
2072 struct task_struct *task;
2073
2074 spin_lock(&cifs_tcp_ses_lock);
2075 if (--server->srv_count > 0) {
2076 spin_unlock(&cifs_tcp_ses_lock);
2077 return;
2078 }
2079
2080 put_net(cifs_net_ns(server));
2081
2082 list_del_init(&server->tcp_ses_list);
2083 spin_unlock(&cifs_tcp_ses_lock);
2084
2085 cancel_delayed_work_sync(&server->echo);
2086
2087 spin_lock(&GlobalMid_Lock);
2088 server->tcpStatus = CifsExiting;
2089 spin_unlock(&GlobalMid_Lock);
2090
2091 cifs_crypto_shash_release(server);
2092 cifs_fscache_release_client_cookie(server);
2093
2094 kfree(server->session_key.response);
2095 server->session_key.response = NULL;
2096 server->session_key.len = 0;
2097
2098 task = xchg(&server->tsk, NULL);
2099 if (task)
2100 force_sig(SIGKILL, task);
2101 }
2102
2103 static struct TCP_Server_Info *
2104 cifs_get_tcp_session(struct smb_vol *volume_info)
2105 {
2106 struct TCP_Server_Info *tcp_ses = NULL;
2107 int rc;
2108
2109 cifs_dbg(FYI, "UNC: %s\n", volume_info->UNC);
2110
2111 /* see if we already have a matching tcp_ses */
2112 tcp_ses = cifs_find_tcp_session(volume_info);
2113 if (tcp_ses)
2114 return tcp_ses;
2115
2116 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
2117 if (!tcp_ses) {
2118 rc = -ENOMEM;
2119 goto out_err;
2120 }
2121
2122 rc = cifs_crypto_shash_allocate(tcp_ses);
2123 if (rc) {
2124 cifs_dbg(VFS, "could not setup hash structures rc %d\n", rc);
2125 goto out_err;
2126 }
2127
2128 tcp_ses->ops = volume_info->ops;
2129 tcp_ses->vals = volume_info->vals;
2130 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
2131 tcp_ses->hostname = extract_hostname(volume_info->UNC);
2132 if (IS_ERR(tcp_ses->hostname)) {
2133 rc = PTR_ERR(tcp_ses->hostname);
2134 goto out_err_crypto_release;
2135 }
2136
2137 tcp_ses->noblocksnd = volume_info->noblocksnd;
2138 tcp_ses->noautotune = volume_info->noautotune;
2139 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
2140 tcp_ses->in_flight = 0;
2141 tcp_ses->credits = 1;
2142 init_waitqueue_head(&tcp_ses->response_q);
2143 init_waitqueue_head(&tcp_ses->request_q);
2144 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
2145 mutex_init(&tcp_ses->srv_mutex);
2146 memcpy(tcp_ses->workstation_RFC1001_name,
2147 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2148 memcpy(tcp_ses->server_RFC1001_name,
2149 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
2150 tcp_ses->session_estab = false;
2151 tcp_ses->sequence_number = 0;
2152 tcp_ses->lstrp = jiffies;
2153 spin_lock_init(&tcp_ses->req_lock);
2154 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
2155 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
2156 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
2157 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
2158 sizeof(tcp_ses->srcaddr));
2159 memcpy(&tcp_ses->dstaddr, &volume_info->dstaddr,
2160 sizeof(tcp_ses->dstaddr));
2161 /*
2162 * at this point we are the only ones with the pointer
2163 * to the struct since the kernel thread not created yet
2164 * no need to spinlock this init of tcpStatus or srv_count
2165 */
2166 tcp_ses->tcpStatus = CifsNew;
2167 ++tcp_ses->srv_count;
2168
2169 rc = ip_connect(tcp_ses);
2170 if (rc < 0) {
2171 cifs_dbg(VFS, "Error connecting to socket. Aborting operation.\n");
2172 goto out_err_crypto_release;
2173 }
2174
2175 /*
2176 * since we're in a cifs function already, we know that
2177 * this will succeed. No need for try_module_get().
2178 */
2179 __module_get(THIS_MODULE);
2180 tcp_ses->tsk = kthread_run(cifs_demultiplex_thread,
2181 tcp_ses, "cifsd");
2182 if (IS_ERR(tcp_ses->tsk)) {
2183 rc = PTR_ERR(tcp_ses->tsk);
2184 cifs_dbg(VFS, "error %d create cifsd thread\n", rc);
2185 module_put(THIS_MODULE);
2186 goto out_err_crypto_release;
2187 }
2188 tcp_ses->tcpStatus = CifsNeedNegotiate;
2189
2190 /* thread spawned, put it on the list */
2191 spin_lock(&cifs_tcp_ses_lock);
2192 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
2193 spin_unlock(&cifs_tcp_ses_lock);
2194
2195 cifs_fscache_get_client_cookie(tcp_ses);
2196
2197 /* queue echo request delayed work */
2198 queue_delayed_work(cifsiod_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
2199
2200 return tcp_ses;
2201
2202 out_err_crypto_release:
2203 cifs_crypto_shash_release(tcp_ses);
2204
2205 put_net(cifs_net_ns(tcp_ses));
2206
2207 out_err:
2208 if (tcp_ses) {
2209 if (!IS_ERR(tcp_ses->hostname))
2210 kfree(tcp_ses->hostname);
2211 if (tcp_ses->ssocket)
2212 sock_release(tcp_ses->ssocket);
2213 kfree(tcp_ses);
2214 }
2215 return ERR_PTR(rc);
2216 }
2217
2218 static int match_session(struct cifs_ses *ses, struct smb_vol *vol)
2219 {
2220 switch (ses->server->secType) {
2221 case Kerberos:
2222 if (!uid_eq(vol->cred_uid, ses->cred_uid))
2223 return 0;
2224 break;
2225 default:
2226 /* NULL username means anonymous session */
2227 if (ses->user_name == NULL) {
2228 if (!vol->nullauth)
2229 return 0;
2230 break;
2231 }
2232
2233 /* anything else takes username/password */
2234 if (strncmp(ses->user_name,
2235 vol->username ? vol->username : "",
2236 MAX_USERNAME_SIZE))
2237 return 0;
2238 if (strlen(vol->username) != 0 &&
2239 ses->password != NULL &&
2240 strncmp(ses->password,
2241 vol->password ? vol->password : "",
2242 MAX_PASSWORD_SIZE))
2243 return 0;
2244 }
2245 return 1;
2246 }
2247
2248 static struct cifs_ses *
2249 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
2250 {
2251 struct cifs_ses *ses;
2252
2253 spin_lock(&cifs_tcp_ses_lock);
2254 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
2255 if (!match_session(ses, vol))
2256 continue;
2257 ++ses->ses_count;
2258 spin_unlock(&cifs_tcp_ses_lock);
2259 return ses;
2260 }
2261 spin_unlock(&cifs_tcp_ses_lock);
2262 return NULL;
2263 }
2264
2265 static void
2266 cifs_put_smb_ses(struct cifs_ses *ses)
2267 {
2268 unsigned int xid;
2269 struct TCP_Server_Info *server = ses->server;
2270
2271 cifs_dbg(FYI, "%s: ses_count=%d\n", __func__, ses->ses_count);
2272 spin_lock(&cifs_tcp_ses_lock);
2273 if (--ses->ses_count > 0) {
2274 spin_unlock(&cifs_tcp_ses_lock);
2275 return;
2276 }
2277
2278 list_del_init(&ses->smb_ses_list);
2279 spin_unlock(&cifs_tcp_ses_lock);
2280
2281 if (ses->status == CifsGood && server->ops->logoff) {
2282 xid = get_xid();
2283 server->ops->logoff(xid, ses);
2284 _free_xid(xid);
2285 }
2286 sesInfoFree(ses);
2287 cifs_put_tcp_session(server);
2288 }
2289
2290 #ifdef CONFIG_KEYS
2291
2292 /* strlen("cifs:a:") + CIFS_MAX_DOMAINNAME_LEN + 1 */
2293 #define CIFSCREDS_DESC_SIZE (7 + CIFS_MAX_DOMAINNAME_LEN + 1)
2294
2295 /* Populate username and pw fields from keyring if possible */
2296 static int
2297 cifs_set_cifscreds(struct smb_vol *vol, struct cifs_ses *ses)
2298 {
2299 int rc = 0;
2300 char *desc, *delim, *payload;
2301 ssize_t len;
2302 struct key *key;
2303 struct TCP_Server_Info *server = ses->server;
2304 struct sockaddr_in *sa;
2305 struct sockaddr_in6 *sa6;
2306 struct user_key_payload *upayload;
2307
2308 desc = kmalloc(CIFSCREDS_DESC_SIZE, GFP_KERNEL);
2309 if (!desc)
2310 return -ENOMEM;
2311
2312 /* try to find an address key first */
2313 switch (server->dstaddr.ss_family) {
2314 case AF_INET:
2315 sa = (struct sockaddr_in *)&server->dstaddr;
2316 sprintf(desc, "cifs:a:%pI4", &sa->sin_addr.s_addr);
2317 break;
2318 case AF_INET6:
2319 sa6 = (struct sockaddr_in6 *)&server->dstaddr;
2320 sprintf(desc, "cifs:a:%pI6c", &sa6->sin6_addr.s6_addr);
2321 break;
2322 default:
2323 cifs_dbg(FYI, "Bad ss_family (%hu)\n",
2324 server->dstaddr.ss_family);
2325 rc = -EINVAL;
2326 goto out_err;
2327 }
2328
2329 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2330 key = request_key(&key_type_logon, desc, "");
2331 if (IS_ERR(key)) {
2332 if (!ses->domainName) {
2333 cifs_dbg(FYI, "domainName is NULL\n");
2334 rc = PTR_ERR(key);
2335 goto out_err;
2336 }
2337
2338 /* didn't work, try to find a domain key */
2339 sprintf(desc, "cifs:d:%s", ses->domainName);
2340 cifs_dbg(FYI, "%s: desc=%s\n", __func__, desc);
2341 key = request_key(&key_type_logon, desc, "");
2342 if (IS_ERR(key)) {
2343 rc = PTR_ERR(key);
2344 goto out_err;
2345 }
2346 }
2347
2348 down_read(&key->sem);
2349 upayload = key->payload.data;
2350 if (IS_ERR_OR_NULL(upayload)) {
2351 rc = upayload ? PTR_ERR(upayload) : -EINVAL;
2352 goto out_key_put;
2353 }
2354
2355 /* find first : in payload */
2356 payload = (char *)upayload->data;
2357 delim = strnchr(payload, upayload->datalen, ':');
2358 cifs_dbg(FYI, "payload=%s\n", payload);
2359 if (!delim) {
2360 cifs_dbg(FYI, "Unable to find ':' in payload (datalen=%d)\n",
2361 upayload->datalen);
2362 rc = -EINVAL;
2363 goto out_key_put;
2364 }
2365
2366 len = delim - payload;
2367 if (len > MAX_USERNAME_SIZE || len <= 0) {
2368 cifs_dbg(FYI, "Bad value from username search (len=%zd)\n",
2369 len);
2370 rc = -EINVAL;
2371 goto out_key_put;
2372 }
2373
2374 vol->username = kstrndup(payload, len, GFP_KERNEL);
2375 if (!vol->username) {
2376 cifs_dbg(FYI, "Unable to allocate %zd bytes for username\n",
2377 len);
2378 rc = -ENOMEM;
2379 goto out_key_put;
2380 }
2381 cifs_dbg(FYI, "%s: username=%s\n", __func__, vol->username);
2382
2383 len = key->datalen - (len + 1);
2384 if (len > MAX_PASSWORD_SIZE || len <= 0) {
2385 cifs_dbg(FYI, "Bad len for password search (len=%zd)\n", len);
2386 rc = -EINVAL;
2387 kfree(vol->username);
2388 vol->username = NULL;
2389 goto out_key_put;
2390 }
2391
2392 ++delim;
2393 vol->password = kstrndup(delim, len, GFP_KERNEL);
2394 if (!vol->password) {
2395 cifs_dbg(FYI, "Unable to allocate %zd bytes for password\n",
2396 len);
2397 rc = -ENOMEM;
2398 kfree(vol->username);
2399 vol->username = NULL;
2400 goto out_key_put;
2401 }
2402
2403 out_key_put:
2404 up_read(&key->sem);
2405 key_put(key);
2406 out_err:
2407 kfree(desc);
2408 cifs_dbg(FYI, "%s: returning %d\n", __func__, rc);
2409 return rc;
2410 }
2411 #else /* ! CONFIG_KEYS */
2412 static inline int
2413 cifs_set_cifscreds(struct smb_vol *vol __attribute__((unused)),
2414 struct cifs_ses *ses __attribute__((unused)))
2415 {
2416 return -ENOSYS;
2417 }
2418 #endif /* CONFIG_KEYS */
2419
2420 static struct cifs_ses *
2421 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
2422 {
2423 int rc = -ENOMEM;
2424 unsigned int xid;
2425 struct cifs_ses *ses;
2426 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2427 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2428
2429 xid = get_xid();
2430
2431 ses = cifs_find_smb_ses(server, volume_info);
2432 if (ses) {
2433 cifs_dbg(FYI, "Existing smb sess found (status=%d)\n",
2434 ses->status);
2435
2436 mutex_lock(&ses->session_mutex);
2437 rc = cifs_negotiate_protocol(xid, ses);
2438 if (rc) {
2439 mutex_unlock(&ses->session_mutex);
2440 /* problem -- put our ses reference */
2441 cifs_put_smb_ses(ses);
2442 free_xid(xid);
2443 return ERR_PTR(rc);
2444 }
2445 if (ses->need_reconnect) {
2446 cifs_dbg(FYI, "Session needs reconnect\n");
2447 rc = cifs_setup_session(xid, ses,
2448 volume_info->local_nls);
2449 if (rc) {
2450 mutex_unlock(&ses->session_mutex);
2451 /* problem -- put our reference */
2452 cifs_put_smb_ses(ses);
2453 free_xid(xid);
2454 return ERR_PTR(rc);
2455 }
2456 }
2457 mutex_unlock(&ses->session_mutex);
2458
2459 /* existing SMB ses has a server reference already */
2460 cifs_put_tcp_session(server);
2461 free_xid(xid);
2462 return ses;
2463 }
2464
2465 cifs_dbg(FYI, "Existing smb sess not found\n");
2466 ses = sesInfoAlloc();
2467 if (ses == NULL)
2468 goto get_ses_fail;
2469
2470 /* new SMB session uses our server ref */
2471 ses->server = server;
2472 if (server->dstaddr.ss_family == AF_INET6)
2473 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
2474 else
2475 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
2476
2477 if (volume_info->username) {
2478 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
2479 if (!ses->user_name)
2480 goto get_ses_fail;
2481 }
2482
2483 /* volume_info->password freed at unmount */
2484 if (volume_info->password) {
2485 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
2486 if (!ses->password)
2487 goto get_ses_fail;
2488 }
2489 if (volume_info->domainname) {
2490 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
2491 if (!ses->domainName)
2492 goto get_ses_fail;
2493 }
2494 ses->cred_uid = volume_info->cred_uid;
2495 ses->linux_uid = volume_info->linux_uid;
2496
2497 ses->overrideSecFlg = volume_info->secFlg;
2498
2499 mutex_lock(&ses->session_mutex);
2500 rc = cifs_negotiate_protocol(xid, ses);
2501 if (!rc)
2502 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
2503 mutex_unlock(&ses->session_mutex);
2504 if (rc)
2505 goto get_ses_fail;
2506
2507 /* success, put it on the list */
2508 spin_lock(&cifs_tcp_ses_lock);
2509 list_add(&ses->smb_ses_list, &server->smb_ses_list);
2510 spin_unlock(&cifs_tcp_ses_lock);
2511
2512 free_xid(xid);
2513 return ses;
2514
2515 get_ses_fail:
2516 sesInfoFree(ses);
2517 free_xid(xid);
2518 return ERR_PTR(rc);
2519 }
2520
2521 static int match_tcon(struct cifs_tcon *tcon, const char *unc)
2522 {
2523 if (tcon->tidStatus == CifsExiting)
2524 return 0;
2525 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
2526 return 0;
2527 return 1;
2528 }
2529
2530 static struct cifs_tcon *
2531 cifs_find_tcon(struct cifs_ses *ses, const char *unc)
2532 {
2533 struct list_head *tmp;
2534 struct cifs_tcon *tcon;
2535
2536 spin_lock(&cifs_tcp_ses_lock);
2537 list_for_each(tmp, &ses->tcon_list) {
2538 tcon = list_entry(tmp, struct cifs_tcon, tcon_list);
2539 if (!match_tcon(tcon, unc))
2540 continue;
2541 ++tcon->tc_count;
2542 spin_unlock(&cifs_tcp_ses_lock);
2543 return tcon;
2544 }
2545 spin_unlock(&cifs_tcp_ses_lock);
2546 return NULL;
2547 }
2548
2549 static void
2550 cifs_put_tcon(struct cifs_tcon *tcon)
2551 {
2552 unsigned int xid;
2553 struct cifs_ses *ses = tcon->ses;
2554
2555 cifs_dbg(FYI, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2556 spin_lock(&cifs_tcp_ses_lock);
2557 if (--tcon->tc_count > 0) {
2558 spin_unlock(&cifs_tcp_ses_lock);
2559 return;
2560 }
2561
2562 list_del_init(&tcon->tcon_list);
2563 spin_unlock(&cifs_tcp_ses_lock);
2564
2565 xid = get_xid();
2566 if (ses->server->ops->tree_disconnect)
2567 ses->server->ops->tree_disconnect(xid, tcon);
2568 _free_xid(xid);
2569
2570 cifs_fscache_release_super_cookie(tcon);
2571 tconInfoFree(tcon);
2572 cifs_put_smb_ses(ses);
2573 }
2574
2575 static struct cifs_tcon *
2576 cifs_get_tcon(struct cifs_ses *ses, struct smb_vol *volume_info)
2577 {
2578 int rc, xid;
2579 struct cifs_tcon *tcon;
2580
2581 tcon = cifs_find_tcon(ses, volume_info->UNC);
2582 if (tcon) {
2583 cifs_dbg(FYI, "Found match on UNC path\n");
2584 /* existing tcon already has a reference */
2585 cifs_put_smb_ses(ses);
2586 if (tcon->seal != volume_info->seal)
2587 cifs_dbg(VFS, "transport encryption setting conflicts with existing tid\n");
2588 return tcon;
2589 }
2590
2591 if (!ses->server->ops->tree_connect) {
2592 rc = -ENOSYS;
2593 goto out_fail;
2594 }
2595
2596 tcon = tconInfoAlloc();
2597 if (tcon == NULL) {
2598 rc = -ENOMEM;
2599 goto out_fail;
2600 }
2601
2602 tcon->ses = ses;
2603 if (volume_info->password) {
2604 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2605 if (!tcon->password) {
2606 rc = -ENOMEM;
2607 goto out_fail;
2608 }
2609 }
2610
2611 /*
2612 * BB Do we need to wrap session_mutex around this TCon call and Unix
2613 * SetFS as we do on SessSetup and reconnect?
2614 */
2615 xid = get_xid();
2616 rc = ses->server->ops->tree_connect(xid, ses, volume_info->UNC, tcon,
2617 volume_info->local_nls);
2618 free_xid(xid);
2619 cifs_dbg(FYI, "Tcon rc = %d\n", rc);
2620 if (rc)
2621 goto out_fail;
2622
2623 if (volume_info->nodfs) {
2624 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2625 cifs_dbg(FYI, "DFS disabled (%d)\n", tcon->Flags);
2626 }
2627 tcon->seal = volume_info->seal;
2628 /*
2629 * We can have only one retry value for a connection to a share so for
2630 * resources mounted more than once to the same server share the last
2631 * value passed in for the retry flag is used.
2632 */
2633 tcon->retry = volume_info->retry;
2634 tcon->nocase = volume_info->nocase;
2635 tcon->local_lease = volume_info->local_lease;
2636 INIT_LIST_HEAD(&tcon->pending_opens);
2637
2638 spin_lock(&cifs_tcp_ses_lock);
2639 list_add(&tcon->tcon_list, &ses->tcon_list);
2640 spin_unlock(&cifs_tcp_ses_lock);
2641
2642 cifs_fscache_get_super_cookie(tcon);
2643
2644 return tcon;
2645
2646 out_fail:
2647 tconInfoFree(tcon);
2648 return ERR_PTR(rc);
2649 }
2650
2651 void
2652 cifs_put_tlink(struct tcon_link *tlink)
2653 {
2654 if (!tlink || IS_ERR(tlink))
2655 return;
2656
2657 if (!atomic_dec_and_test(&tlink->tl_count) ||
2658 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2659 tlink->tl_time = jiffies;
2660 return;
2661 }
2662
2663 if (!IS_ERR(tlink_tcon(tlink)))
2664 cifs_put_tcon(tlink_tcon(tlink));
2665 kfree(tlink);
2666 return;
2667 }
2668
2669 static inline struct tcon_link *
2670 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
2671 {
2672 return cifs_sb->master_tlink;
2673 }
2674
2675 static int
2676 compare_mount_options(struct super_block *sb, struct cifs_mnt_data *mnt_data)
2677 {
2678 struct cifs_sb_info *old = CIFS_SB(sb);
2679 struct cifs_sb_info *new = mnt_data->cifs_sb;
2680
2681 if ((sb->s_flags & CIFS_MS_MASK) != (mnt_data->flags & CIFS_MS_MASK))
2682 return 0;
2683
2684 if ((old->mnt_cifs_flags & CIFS_MOUNT_MASK) !=
2685 (new->mnt_cifs_flags & CIFS_MOUNT_MASK))
2686 return 0;
2687
2688 /*
2689 * We want to share sb only if we don't specify an r/wsize or
2690 * specified r/wsize is greater than or equal to existing one.
2691 */
2692 if (new->wsize && new->wsize < old->wsize)
2693 return 0;
2694
2695 if (new->rsize && new->rsize < old->rsize)
2696 return 0;
2697
2698 if (!uid_eq(old->mnt_uid, new->mnt_uid) || !gid_eq(old->mnt_gid, new->mnt_gid))
2699 return 0;
2700
2701 if (old->mnt_file_mode != new->mnt_file_mode ||
2702 old->mnt_dir_mode != new->mnt_dir_mode)
2703 return 0;
2704
2705 if (strcmp(old->local_nls->charset, new->local_nls->charset))
2706 return 0;
2707
2708 if (old->actimeo != new->actimeo)
2709 return 0;
2710
2711 return 1;
2712 }
2713
2714 int
2715 cifs_match_super(struct super_block *sb, void *data)
2716 {
2717 struct cifs_mnt_data *mnt_data = (struct cifs_mnt_data *)data;
2718 struct smb_vol *volume_info;
2719 struct cifs_sb_info *cifs_sb;
2720 struct TCP_Server_Info *tcp_srv;
2721 struct cifs_ses *ses;
2722 struct cifs_tcon *tcon;
2723 struct tcon_link *tlink;
2724 int rc = 0;
2725
2726 spin_lock(&cifs_tcp_ses_lock);
2727 cifs_sb = CIFS_SB(sb);
2728 tlink = cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
2729 if (IS_ERR(tlink)) {
2730 spin_unlock(&cifs_tcp_ses_lock);
2731 return rc;
2732 }
2733 tcon = tlink_tcon(tlink);
2734 ses = tcon->ses;
2735 tcp_srv = ses->server;
2736
2737 volume_info = mnt_data->vol;
2738
2739 if (!match_server(tcp_srv, volume_info) ||
2740 !match_session(ses, volume_info) ||
2741 !match_tcon(tcon, volume_info->UNC)) {
2742 rc = 0;
2743 goto out;
2744 }
2745
2746 rc = compare_mount_options(sb, mnt_data);
2747 out:
2748 spin_unlock(&cifs_tcp_ses_lock);
2749 cifs_put_tlink(tlink);
2750 return rc;
2751 }
2752
2753 int
2754 get_dfs_path(const unsigned int xid, struct cifs_ses *ses, const char *old_path,
2755 const struct nls_table *nls_codepage, unsigned int *num_referrals,
2756 struct dfs_info3_param **referrals, int remap)
2757 {
2758 char *temp_unc;
2759 int rc = 0;
2760
2761 if (!ses->server->ops->tree_connect || !ses->server->ops->get_dfs_refer)
2762 return -ENOSYS;
2763
2764 *num_referrals = 0;
2765 *referrals = NULL;
2766
2767 if (ses->ipc_tid == 0) {
2768 temp_unc = kmalloc(2 /* for slashes */ +
2769 strnlen(ses->serverName, SERVER_NAME_LEN_WITH_NULL * 2)
2770 + 1 + 4 /* slash IPC$ */ + 2, GFP_KERNEL);
2771 if (temp_unc == NULL)
2772 return -ENOMEM;
2773 temp_unc[0] = '\\';
2774 temp_unc[1] = '\\';
2775 strcpy(temp_unc + 2, ses->serverName);
2776 strcpy(temp_unc + 2 + strlen(ses->serverName), "\\IPC$");
2777 rc = ses->server->ops->tree_connect(xid, ses, temp_unc, NULL,
2778 nls_codepage);
2779 cifs_dbg(FYI, "Tcon rc = %d ipc_tid = %d\n", rc, ses->ipc_tid);
2780 kfree(temp_unc);
2781 }
2782 if (rc == 0)
2783 rc = ses->server->ops->get_dfs_refer(xid, ses, old_path,
2784 referrals, num_referrals,
2785 nls_codepage, remap);
2786 /*
2787 * BB - map targetUNCs to dfs_info3 structures, here or in
2788 * ses->server->ops->get_dfs_refer.
2789 */
2790
2791 return rc;
2792 }
2793
2794 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2795 static struct lock_class_key cifs_key[2];
2796 static struct lock_class_key cifs_slock_key[2];
2797
2798 static inline void
2799 cifs_reclassify_socket4(struct socket *sock)
2800 {
2801 struct sock *sk = sock->sk;
2802 BUG_ON(sock_owned_by_user(sk));
2803 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2804 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2805 }
2806
2807 static inline void
2808 cifs_reclassify_socket6(struct socket *sock)
2809 {
2810 struct sock *sk = sock->sk;
2811 BUG_ON(sock_owned_by_user(sk));
2812 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2813 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2814 }
2815 #else
2816 static inline void
2817 cifs_reclassify_socket4(struct socket *sock)
2818 {
2819 }
2820
2821 static inline void
2822 cifs_reclassify_socket6(struct socket *sock)
2823 {
2824 }
2825 #endif
2826
2827 /* See RFC1001 section 14 on representation of Netbios names */
2828 static void rfc1002mangle(char *target, char *source, unsigned int length)
2829 {
2830 unsigned int i, j;
2831
2832 for (i = 0, j = 0; i < (length); i++) {
2833 /* mask a nibble at a time and encode */
2834 target[j] = 'A' + (0x0F & (source[i] >> 4));
2835 target[j+1] = 'A' + (0x0F & source[i]);
2836 j += 2;
2837 }
2838
2839 }
2840
2841 static int
2842 bind_socket(struct TCP_Server_Info *server)
2843 {
2844 int rc = 0;
2845 if (server->srcaddr.ss_family != AF_UNSPEC) {
2846 /* Bind to the specified local IP address */
2847 struct socket *socket = server->ssocket;
2848 rc = socket->ops->bind(socket,
2849 (struct sockaddr *) &server->srcaddr,
2850 sizeof(server->srcaddr));
2851 if (rc < 0) {
2852 struct sockaddr_in *saddr4;
2853 struct sockaddr_in6 *saddr6;
2854 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2855 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2856 if (saddr6->sin6_family == AF_INET6)
2857 cifs_dbg(VFS, "Failed to bind to: %pI6c, error: %d\n",
2858 &saddr6->sin6_addr, rc);
2859 else
2860 cifs_dbg(VFS, "Failed to bind to: %pI4, error: %d\n",
2861 &saddr4->sin_addr.s_addr, rc);
2862 }
2863 }
2864 return rc;
2865 }
2866
2867 static int
2868 ip_rfc1001_connect(struct TCP_Server_Info *server)
2869 {
2870 int rc = 0;
2871 /*
2872 * some servers require RFC1001 sessinit before sending
2873 * negprot - BB check reconnection in case where second
2874 * sessinit is sent but no second negprot
2875 */
2876 struct rfc1002_session_packet *ses_init_buf;
2877 struct smb_hdr *smb_buf;
2878 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2879 GFP_KERNEL);
2880 if (ses_init_buf) {
2881 ses_init_buf->trailer.session_req.called_len = 32;
2882
2883 if (server->server_RFC1001_name &&
2884 server->server_RFC1001_name[0] != 0)
2885 rfc1002mangle(ses_init_buf->trailer.
2886 session_req.called_name,
2887 server->server_RFC1001_name,
2888 RFC1001_NAME_LEN_WITH_NULL);
2889 else
2890 rfc1002mangle(ses_init_buf->trailer.
2891 session_req.called_name,
2892 DEFAULT_CIFS_CALLED_NAME,
2893 RFC1001_NAME_LEN_WITH_NULL);
2894
2895 ses_init_buf->trailer.session_req.calling_len = 32;
2896
2897 /*
2898 * calling name ends in null (byte 16) from old smb
2899 * convention.
2900 */
2901 if (server->workstation_RFC1001_name &&
2902 server->workstation_RFC1001_name[0] != 0)
2903 rfc1002mangle(ses_init_buf->trailer.
2904 session_req.calling_name,
2905 server->workstation_RFC1001_name,
2906 RFC1001_NAME_LEN_WITH_NULL);
2907 else
2908 rfc1002mangle(ses_init_buf->trailer.
2909 session_req.calling_name,
2910 "LINUX_CIFS_CLNT",
2911 RFC1001_NAME_LEN_WITH_NULL);
2912
2913 ses_init_buf->trailer.session_req.scope1 = 0;
2914 ses_init_buf->trailer.session_req.scope2 = 0;
2915 smb_buf = (struct smb_hdr *)ses_init_buf;
2916
2917 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2918 smb_buf->smb_buf_length = cpu_to_be32(0x81000044);
2919 rc = smb_send(server, smb_buf, 0x44);
2920 kfree(ses_init_buf);
2921 /*
2922 * RFC1001 layer in at least one server
2923 * requires very short break before negprot
2924 * presumably because not expecting negprot
2925 * to follow so fast. This is a simple
2926 * solution that works without
2927 * complicating the code and causes no
2928 * significant slowing down on mount
2929 * for everyone else
2930 */
2931 usleep_range(1000, 2000);
2932 }
2933 /*
2934 * else the negprot may still work without this
2935 * even though malloc failed
2936 */
2937
2938 return rc;
2939 }
2940
2941 static int
2942 generic_ip_connect(struct TCP_Server_Info *server)
2943 {
2944 int rc = 0;
2945 __be16 sport;
2946 int slen, sfamily;
2947 struct socket *socket = server->ssocket;
2948 struct sockaddr *saddr;
2949
2950 saddr = (struct sockaddr *) &server->dstaddr;
2951
2952 if (server->dstaddr.ss_family == AF_INET6) {
2953 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2954 slen = sizeof(struct sockaddr_in6);
2955 sfamily = AF_INET6;
2956 } else {
2957 sport = ((struct sockaddr_in *) saddr)->sin_port;
2958 slen = sizeof(struct sockaddr_in);
2959 sfamily = AF_INET;
2960 }
2961
2962 if (socket == NULL) {
2963 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2964 IPPROTO_TCP, &socket, 1);
2965 if (rc < 0) {
2966 cifs_dbg(VFS, "Error %d creating socket\n", rc);
2967 server->ssocket = NULL;
2968 return rc;
2969 }
2970
2971 /* BB other socket options to set KEEPALIVE, NODELAY? */
2972 cifs_dbg(FYI, "Socket created\n");
2973 server->ssocket = socket;
2974 socket->sk->sk_allocation = GFP_NOFS;
2975 if (sfamily == AF_INET6)
2976 cifs_reclassify_socket6(socket);
2977 else
2978 cifs_reclassify_socket4(socket);
2979 }
2980
2981 rc = bind_socket(server);
2982 if (rc < 0)
2983 return rc;
2984
2985 /*
2986 * Eventually check for other socket options to change from
2987 * the default. sock_setsockopt not used because it expects
2988 * user space buffer
2989 */
2990 socket->sk->sk_rcvtimeo = 7 * HZ;
2991 socket->sk->sk_sndtimeo = 5 * HZ;
2992
2993 /* make the bufsizes depend on wsize/rsize and max requests */
2994 if (server->noautotune) {
2995 if (socket->sk->sk_sndbuf < (200 * 1024))
2996 socket->sk->sk_sndbuf = 200 * 1024;
2997 if (socket->sk->sk_rcvbuf < (140 * 1024))
2998 socket->sk->sk_rcvbuf = 140 * 1024;
2999 }
3000
3001 if (server->tcp_nodelay) {
3002 int val = 1;
3003 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
3004 (char *)&val, sizeof(val));
3005 if (rc)
3006 cifs_dbg(FYI, "set TCP_NODELAY socket option error %d\n",
3007 rc);
3008 }
3009
3010 cifs_dbg(FYI, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx\n",
3011 socket->sk->sk_sndbuf,
3012 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
3013
3014 rc = socket->ops->connect(socket, saddr, slen, 0);
3015 if (rc < 0) {
3016 cifs_dbg(FYI, "Error %d connecting to server\n", rc);
3017 sock_release(socket);
3018 server->ssocket = NULL;
3019 return rc;
3020 }
3021
3022 if (sport == htons(RFC1001_PORT))
3023 rc = ip_rfc1001_connect(server);
3024
3025 return rc;
3026 }
3027
3028 static int
3029 ip_connect(struct TCP_Server_Info *server)
3030 {
3031 __be16 *sport;
3032 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
3033 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
3034
3035 if (server->dstaddr.ss_family == AF_INET6)
3036 sport = &addr6->sin6_port;
3037 else
3038 sport = &addr->sin_port;
3039
3040 if (*sport == 0) {
3041 int rc;
3042
3043 /* try with 445 port at first */
3044 *sport = htons(CIFS_PORT);
3045
3046 rc = generic_ip_connect(server);
3047 if (rc >= 0)
3048 return rc;
3049
3050 /* if it failed, try with 139 port */
3051 *sport = htons(RFC1001_PORT);
3052 }
3053
3054 return generic_ip_connect(server);
3055 }
3056
3057 void reset_cifs_unix_caps(unsigned int xid, struct cifs_tcon *tcon,
3058 struct cifs_sb_info *cifs_sb, struct smb_vol *vol_info)
3059 {
3060 /* if we are reconnecting then should we check to see if
3061 * any requested capabilities changed locally e.g. via
3062 * remount but we can not do much about it here
3063 * if they have (even if we could detect it by the following)
3064 * Perhaps we could add a backpointer to array of sb from tcon
3065 * or if we change to make all sb to same share the same
3066 * sb as NFS - then we only have one backpointer to sb.
3067 * What if we wanted to mount the server share twice once with
3068 * and once without posixacls or posix paths? */
3069 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3070
3071 if (vol_info && vol_info->no_linux_ext) {
3072 tcon->fsUnixInfo.Capability = 0;
3073 tcon->unix_ext = 0; /* Unix Extensions disabled */
3074 cifs_dbg(FYI, "Linux protocol extensions disabled\n");
3075 return;
3076 } else if (vol_info)
3077 tcon->unix_ext = 1; /* Unix Extensions supported */
3078
3079 if (tcon->unix_ext == 0) {
3080 cifs_dbg(FYI, "Unix extensions disabled so not set on reconnect\n");
3081 return;
3082 }
3083
3084 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
3085 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
3086 cifs_dbg(FYI, "unix caps which server supports %lld\n", cap);
3087 /* check for reconnect case in which we do not
3088 want to change the mount behavior if we can avoid it */
3089 if (vol_info == NULL) {
3090 /* turn off POSIX ACL and PATHNAMES if not set
3091 originally at mount time */
3092 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
3093 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3094 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3095 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3096 cifs_dbg(VFS, "POSIXPATH support change\n");
3097 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3098 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
3099 cifs_dbg(VFS, "possible reconnect error\n");
3100 cifs_dbg(VFS, "server disabled POSIX path support\n");
3101 }
3102 }
3103
3104 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3105 cifs_dbg(VFS, "per-share encryption not supported yet\n");
3106
3107 cap &= CIFS_UNIX_CAP_MASK;
3108 if (vol_info && vol_info->no_psx_acl)
3109 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
3110 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
3111 cifs_dbg(FYI, "negotiated posix acl support\n");
3112 if (cifs_sb)
3113 cifs_sb->mnt_cifs_flags |=
3114 CIFS_MOUNT_POSIXACL;
3115 }
3116
3117 if (vol_info && vol_info->posix_paths == 0)
3118 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
3119 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
3120 cifs_dbg(FYI, "negotiate posix pathnames\n");
3121 if (cifs_sb)
3122 cifs_sb->mnt_cifs_flags |=
3123 CIFS_MOUNT_POSIX_PATHS;
3124 }
3125
3126 cifs_dbg(FYI, "Negotiate caps 0x%x\n", (int)cap);
3127 #ifdef CONFIG_CIFS_DEBUG2
3128 if (cap & CIFS_UNIX_FCNTL_CAP)
3129 cifs_dbg(FYI, "FCNTL cap\n");
3130 if (cap & CIFS_UNIX_EXTATTR_CAP)
3131 cifs_dbg(FYI, "EXTATTR cap\n");
3132 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
3133 cifs_dbg(FYI, "POSIX path cap\n");
3134 if (cap & CIFS_UNIX_XATTR_CAP)
3135 cifs_dbg(FYI, "XATTR cap\n");
3136 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
3137 cifs_dbg(FYI, "POSIX ACL cap\n");
3138 if (cap & CIFS_UNIX_LARGE_READ_CAP)
3139 cifs_dbg(FYI, "very large read cap\n");
3140 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
3141 cifs_dbg(FYI, "very large write cap\n");
3142 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_CAP)
3143 cifs_dbg(FYI, "transport encryption cap\n");
3144 if (cap & CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)
3145 cifs_dbg(FYI, "mandatory transport encryption cap\n");
3146 #endif /* CIFS_DEBUG2 */
3147 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
3148 if (vol_info == NULL) {
3149 cifs_dbg(FYI, "resetting capabilities failed\n");
3150 } else
3151 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");
3152
3153 }
3154 }
3155 }
3156
3157 void cifs_setup_cifs_sb(struct smb_vol *pvolume_info,
3158 struct cifs_sb_info *cifs_sb)
3159 {
3160 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
3161
3162 spin_lock_init(&cifs_sb->tlink_tree_lock);
3163 cifs_sb->tlink_tree = RB_ROOT;
3164
3165 /*
3166 * Temporarily set r/wsize for matching superblock. If we end up using
3167 * new sb then client will later negotiate it downward if needed.
3168 */
3169 cifs_sb->rsize = pvolume_info->rsize;
3170 cifs_sb->wsize = pvolume_info->wsize;
3171
3172 cifs_sb->mnt_uid = pvolume_info->linux_uid;
3173 cifs_sb->mnt_gid = pvolume_info->linux_gid;
3174 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
3175 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
3176 cifs_dbg(FYI, "file mode: 0x%hx dir mode: 0x%hx\n",
3177 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
3178
3179 cifs_sb->actimeo = pvolume_info->actimeo;
3180 cifs_sb->local_nls = pvolume_info->local_nls;
3181
3182 if (pvolume_info->noperm)
3183 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
3184 if (pvolume_info->setuids)
3185 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
3186 if (pvolume_info->server_ino)
3187 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
3188 if (pvolume_info->remap)
3189 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
3190 if (pvolume_info->no_xattr)
3191 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
3192 if (pvolume_info->sfu_emul)
3193 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
3194 if (pvolume_info->nobrl)
3195 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
3196 if (pvolume_info->nostrictsync)
3197 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
3198 if (pvolume_info->mand_lock)
3199 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
3200 if (pvolume_info->rwpidforward)
3201 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_RWPIDFORWARD;
3202 if (pvolume_info->cifs_acl)
3203 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
3204 if (pvolume_info->backupuid_specified) {
3205 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPUID;
3206 cifs_sb->mnt_backupuid = pvolume_info->backupuid;
3207 }
3208 if (pvolume_info->backupgid_specified) {
3209 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_BACKUPGID;
3210 cifs_sb->mnt_backupgid = pvolume_info->backupgid;
3211 }
3212 if (pvolume_info->override_uid)
3213 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
3214 if (pvolume_info->override_gid)
3215 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
3216 if (pvolume_info->dynperm)
3217 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
3218 if (pvolume_info->fsc)
3219 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
3220 if (pvolume_info->multiuser)
3221 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
3222 CIFS_MOUNT_NO_PERM);
3223 if (pvolume_info->strict_io)
3224 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
3225 if (pvolume_info->direct_io) {
3226 cifs_dbg(FYI, "mounting share using direct i/o\n");
3227 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
3228 }
3229 if (pvolume_info->mfsymlinks) {
3230 if (pvolume_info->sfu_emul) {
3231 cifs_dbg(VFS, "mount option mfsymlinks ignored if sfu mount option is used\n");
3232 } else {
3233 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
3234 }
3235 }
3236
3237 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
3238 cifs_dbg(VFS, "mount option dynperm ignored if cifsacl mount option supported\n");
3239 }
3240
3241 static void
3242 cleanup_volume_info_contents(struct smb_vol *volume_info)
3243 {
3244 kfree(volume_info->username);
3245 kzfree(volume_info->password);
3246 kfree(volume_info->UNC);
3247 kfree(volume_info->domainname);
3248 kfree(volume_info->iocharset);
3249 kfree(volume_info->prepath);
3250 }
3251
3252 void
3253 cifs_cleanup_volume_info(struct smb_vol *volume_info)
3254 {
3255 if (!volume_info)
3256 return;
3257 cleanup_volume_info_contents(volume_info);
3258 kfree(volume_info);
3259 }
3260
3261
3262 #ifdef CONFIG_CIFS_DFS_UPCALL
3263 /*
3264 * cifs_build_path_to_root returns full path to root when we do not have an
3265 * exiting connection (tcon)
3266 */
3267 static char *
3268 build_unc_path_to_root(const struct smb_vol *vol,
3269 const struct cifs_sb_info *cifs_sb)
3270 {
3271 char *full_path, *pos;
3272 unsigned int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
3273 unsigned int unc_len = strnlen(vol->UNC, MAX_TREE_SIZE + 1);
3274
3275 full_path = kmalloc(unc_len + pplen + 1, GFP_KERNEL);
3276 if (full_path == NULL)
3277 return ERR_PTR(-ENOMEM);
3278
3279 strncpy(full_path, vol->UNC, unc_len);
3280 pos = full_path + unc_len;
3281
3282 if (pplen) {
3283 *pos = CIFS_DIR_SEP(cifs_sb);
3284 strncpy(pos + 1, vol->prepath, pplen);
3285 pos += pplen;
3286 }
3287
3288 *pos = '\0'; /* add trailing null */
3289 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
3290 cifs_dbg(FYI, "%s: full_path=%s\n", __func__, full_path);
3291 return full_path;
3292 }
3293
3294 /*
3295 * Perform a dfs referral query for a share and (optionally) prefix
3296 *
3297 * If a referral is found, cifs_sb->mountdata will be (re-)allocated
3298 * to a string containing updated options for the submount. Otherwise it
3299 * will be left untouched.
3300 *
3301 * Returns the rc from get_dfs_path to the caller, which can be used to
3302 * determine whether there were referrals.
3303 */
3304 static int
3305 expand_dfs_referral(const unsigned int xid, struct cifs_ses *ses,
3306 struct smb_vol *volume_info, struct cifs_sb_info *cifs_sb,
3307 int check_prefix)
3308 {
3309 int rc;
3310 unsigned int num_referrals = 0;
3311 struct dfs_info3_param *referrals = NULL;
3312 char *full_path = NULL, *ref_path = NULL, *mdata = NULL;
3313
3314 full_path = build_unc_path_to_root(volume_info, cifs_sb);
3315 if (IS_ERR(full_path))
3316 return PTR_ERR(full_path);
3317
3318 /* For DFS paths, skip the first '\' of the UNC */
3319 ref_path = check_prefix ? full_path + 1 : volume_info->UNC + 1;
3320
3321 rc = get_dfs_path(xid, ses, ref_path, cifs_sb->local_nls,
3322 &num_referrals, &referrals,
3323 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
3324
3325 if (!rc && num_referrals > 0) {
3326 char *fake_devname = NULL;
3327
3328 mdata = cifs_compose_mount_options(cifs_sb->mountdata,
3329 full_path + 1, referrals,
3330 &fake_devname);
3331
3332 free_dfs_info_array(referrals, num_referrals);
3333
3334 if (IS_ERR(mdata)) {
3335 rc = PTR_ERR(mdata);
3336 mdata = NULL;
3337 } else {
3338 cleanup_volume_info_contents(volume_info);
3339 rc = cifs_setup_volume_info(volume_info, mdata,
3340 fake_devname);
3341 }
3342 kfree(fake_devname);
3343 kfree(cifs_sb->mountdata);
3344 cifs_sb->mountdata = mdata;
3345 }
3346 kfree(full_path);
3347 return rc;
3348 }
3349 #endif
3350
3351 static int
3352 cifs_setup_volume_info(struct smb_vol *volume_info, char *mount_data,
3353 const char *devname)
3354 {
3355 int rc = 0;
3356
3357 if (cifs_parse_mount_options(mount_data, devname, volume_info))
3358 return -EINVAL;
3359
3360 if (volume_info->nullauth) {
3361 cifs_dbg(FYI, "Anonymous login\n");
3362 kfree(volume_info->username);
3363 volume_info->username = NULL;
3364 } else if (volume_info->username) {
3365 /* BB fixme parse for domain name here */
3366 cifs_dbg(FYI, "Username: %s\n", volume_info->username);
3367 } else {
3368 cifs_dbg(VFS, "No username specified\n");
3369 /* In userspace mount helper we can get user name from alternate
3370 locations such as env variables and files on disk */
3371 return -EINVAL;
3372 }
3373
3374 /* this is needed for ASCII cp to Unicode converts */
3375 if (volume_info->iocharset == NULL) {
3376 /* load_nls_default cannot return null */
3377 volume_info->local_nls = load_nls_default();
3378 } else {
3379 volume_info->local_nls = load_nls(volume_info->iocharset);
3380 if (volume_info->local_nls == NULL) {
3381 cifs_dbg(VFS, "CIFS mount error: iocharset %s not found\n",
3382 volume_info->iocharset);
3383 return -ELIBACC;
3384 }
3385 }
3386
3387 return rc;
3388 }
3389
3390 struct smb_vol *
3391 cifs_get_volume_info(char *mount_data, const char *devname)
3392 {
3393 int rc;
3394 struct smb_vol *volume_info;
3395
3396 volume_info = kmalloc(sizeof(struct smb_vol), GFP_KERNEL);
3397 if (!volume_info)
3398 return ERR_PTR(-ENOMEM);
3399
3400 rc = cifs_setup_volume_info(volume_info, mount_data, devname);
3401 if (rc) {
3402 cifs_cleanup_volume_info(volume_info);
3403 volume_info = ERR_PTR(rc);
3404 }
3405
3406 return volume_info;
3407 }
3408
3409 int
3410 cifs_mount(struct cifs_sb_info *cifs_sb, struct smb_vol *volume_info)
3411 {
3412 int rc;
3413 unsigned int xid;
3414 struct cifs_ses *ses;
3415 struct cifs_tcon *tcon;
3416 struct TCP_Server_Info *server;
3417 char *full_path;
3418 struct tcon_link *tlink;
3419 #ifdef CONFIG_CIFS_DFS_UPCALL
3420 int referral_walks_count = 0;
3421 #endif
3422
3423 rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
3424 if (rc)
3425 return rc;
3426
3427 #ifdef CONFIG_CIFS_DFS_UPCALL
3428 try_mount_again:
3429 /* cleanup activities if we're chasing a referral */
3430 if (referral_walks_count) {
3431 if (tcon)
3432 cifs_put_tcon(tcon);
3433 else if (ses)
3434 cifs_put_smb_ses(ses);
3435
3436 free_xid(xid);
3437 }
3438 #endif
3439 rc = 0;
3440 tcon = NULL;
3441 ses = NULL;
3442 server = NULL;
3443 full_path = NULL;
3444 tlink = NULL;
3445
3446 xid = get_xid();
3447
3448 /* get a reference to a tcp session */
3449 server = cifs_get_tcp_session(volume_info);
3450 if (IS_ERR(server)) {
3451 rc = PTR_ERR(server);
3452 bdi_destroy(&cifs_sb->bdi);
3453 goto out;
3454 }
3455
3456 /* get a reference to a SMB session */
3457 ses = cifs_get_smb_ses(server, volume_info);
3458 if (IS_ERR(ses)) {
3459 rc = PTR_ERR(ses);
3460 ses = NULL;
3461 goto mount_fail_check;
3462 }
3463
3464 /* search for existing tcon to this server share */
3465 tcon = cifs_get_tcon(ses, volume_info);
3466 if (IS_ERR(tcon)) {
3467 rc = PTR_ERR(tcon);
3468 tcon = NULL;
3469 goto remote_path_check;
3470 }
3471
3472 /* tell server which Unix caps we support */
3473 if (cap_unix(tcon->ses)) {
3474 /* reset of caps checks mount to see if unix extensions
3475 disabled for just this mount */
3476 reset_cifs_unix_caps(xid, tcon, cifs_sb, volume_info);
3477 if ((tcon->ses->server->tcpStatus == CifsNeedReconnect) &&
3478 (le64_to_cpu(tcon->fsUnixInfo.Capability) &
3479 CIFS_UNIX_TRANSPORT_ENCRYPTION_MANDATORY_CAP)) {
3480 rc = -EACCES;
3481 goto mount_fail_check;
3482 }
3483 } else
3484 tcon->unix_ext = 0; /* server does not support them */
3485
3486 /* do not care if a following call succeed - informational */
3487 if (!tcon->ipc && server->ops->qfs_tcon)
3488 server->ops->qfs_tcon(xid, tcon);
3489
3490 cifs_sb->wsize = server->ops->negotiate_wsize(tcon, volume_info);
3491 cifs_sb->rsize = server->ops->negotiate_rsize(tcon, volume_info);
3492
3493 /* tune readahead according to rsize */
3494 cifs_sb->bdi.ra_pages = cifs_sb->rsize / PAGE_CACHE_SIZE;
3495
3496 remote_path_check:
3497 #ifdef CONFIG_CIFS_DFS_UPCALL
3498 /*
3499 * Perform an unconditional check for whether there are DFS
3500 * referrals for this path without prefix, to provide support
3501 * for DFS referrals from w2k8 servers which don't seem to respond
3502 * with PATH_NOT_COVERED to requests that include the prefix.
3503 * Chase the referral if found, otherwise continue normally.
3504 */
3505 if (referral_walks_count == 0) {
3506 int refrc = expand_dfs_referral(xid, ses, volume_info, cifs_sb,
3507 false);
3508 if (!refrc) {
3509 referral_walks_count++;
3510 goto try_mount_again;
3511 }
3512 }
3513 #endif
3514
3515 /* check if a whole path is not remote */
3516 if (!rc && tcon) {
3517 if (!server->ops->is_path_accessible) {
3518 rc = -ENOSYS;
3519 goto mount_fail_check;
3520 }
3521 /*
3522 * cifs_build_path_to_root works only when we have a valid tcon
3523 */
3524 full_path = cifs_build_path_to_root(volume_info, cifs_sb, tcon);
3525 if (full_path == NULL) {
3526 rc = -ENOMEM;
3527 goto mount_fail_check;
3528 }
3529 rc = server->ops->is_path_accessible(xid, tcon, cifs_sb,
3530 full_path);
3531 if (rc != 0 && rc != -EREMOTE) {
3532 kfree(full_path);
3533 goto mount_fail_check;
3534 }
3535 kfree(full_path);
3536 }
3537
3538 /* get referral if needed */
3539 if (rc == -EREMOTE) {
3540 #ifdef CONFIG_CIFS_DFS_UPCALL
3541 if (referral_walks_count > MAX_NESTED_LINKS) {
3542 /*
3543 * BB: when we implement proper loop detection,
3544 * we will remove this check. But now we need it
3545 * to prevent an indefinite loop if 'DFS tree' is
3546 * misconfigured (i.e. has loops).
3547 */
3548 rc = -ELOOP;
3549 goto mount_fail_check;
3550 }
3551
3552 rc = expand_dfs_referral(xid, ses, volume_info, cifs_sb, true);
3553
3554 if (!rc) {
3555 referral_walks_count++;
3556 goto try_mount_again;
3557 }
3558 goto mount_fail_check;
3559 #else /* No DFS support, return error on mount */
3560 rc = -EOPNOTSUPP;
3561 #endif
3562 }
3563
3564 if (rc)
3565 goto mount_fail_check;
3566
3567 /* now, hang the tcon off of the superblock */
3568 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
3569 if (tlink == NULL) {
3570 rc = -ENOMEM;
3571 goto mount_fail_check;
3572 }
3573
3574 tlink->tl_uid = ses->linux_uid;
3575 tlink->tl_tcon = tcon;
3576 tlink->tl_time = jiffies;
3577 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
3578 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3579
3580 cifs_sb->master_tlink = tlink;
3581 spin_lock(&cifs_sb->tlink_tree_lock);
3582 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3583 spin_unlock(&cifs_sb->tlink_tree_lock);
3584
3585 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
3586 TLINK_IDLE_EXPIRE);
3587
3588 mount_fail_check:
3589 /* on error free sesinfo and tcon struct if needed */
3590 if (rc) {
3591 /* If find_unc succeeded then rc == 0 so we can not end */
3592 /* up accidentally freeing someone elses tcon struct */
3593 if (tcon)
3594 cifs_put_tcon(tcon);
3595 else if (ses)
3596 cifs_put_smb_ses(ses);
3597 else
3598 cifs_put_tcp_session(server);
3599 bdi_destroy(&cifs_sb->bdi);
3600 }
3601
3602 out:
3603 free_xid(xid);
3604 return rc;
3605 }
3606
3607 /*
3608 * Issue a TREE_CONNECT request. Note that for IPC$ shares, that the tcon
3609 * pointer may be NULL.
3610 */
3611 int
3612 CIFSTCon(const unsigned int xid, struct cifs_ses *ses,
3613 const char *tree, struct cifs_tcon *tcon,
3614 const struct nls_table *nls_codepage)
3615 {
3616 struct smb_hdr *smb_buffer;
3617 struct smb_hdr *smb_buffer_response;
3618 TCONX_REQ *pSMB;
3619 TCONX_RSP *pSMBr;
3620 unsigned char *bcc_ptr;
3621 int rc = 0;
3622 int length;
3623 __u16 bytes_left, count;
3624
3625 if (ses == NULL)
3626 return -EIO;
3627
3628 smb_buffer = cifs_buf_get();
3629 if (smb_buffer == NULL)
3630 return -ENOMEM;
3631
3632 smb_buffer_response = smb_buffer;
3633
3634 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3635 NULL /*no tid */ , 4 /*wct */ );
3636
3637 smb_buffer->Mid = get_next_mid(ses->server);
3638 smb_buffer->Uid = ses->Suid;
3639 pSMB = (TCONX_REQ *) smb_buffer;
3640 pSMBr = (TCONX_RSP *) smb_buffer_response;
3641
3642 pSMB->AndXCommand = 0xFF;
3643 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3644 bcc_ptr = &pSMB->Password[0];
3645 if (!tcon || (ses->server->sec_mode & SECMODE_USER)) {
3646 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3647 *bcc_ptr = 0; /* password is null byte */
3648 bcc_ptr++; /* skip password */
3649 /* already aligned so no need to do it below */
3650 } else {
3651 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3652 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3653 specified as required (when that support is added to
3654 the vfs in the future) as only NTLM or the much
3655 weaker LANMAN (which we do not send by default) is accepted
3656 by Samba (not sure whether other servers allow
3657 NTLMv2 password here) */
3658 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3659 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3660 (ses->server->secType == LANMAN))
3661 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3662 ses->server->sec_mode &
3663 SECMODE_PW_ENCRYPT ? true : false,
3664 bcc_ptr);
3665 else
3666 #endif /* CIFS_WEAK_PW_HASH */
3667 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3668 bcc_ptr, nls_codepage);
3669
3670 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3671 if (ses->capabilities & CAP_UNICODE) {
3672 /* must align unicode strings */
3673 *bcc_ptr = 0; /* null byte password */
3674 bcc_ptr++;
3675 }
3676 }
3677
3678 if (ses->server->sec_mode &
3679 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3680 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3681
3682 if (ses->capabilities & CAP_STATUS32) {
3683 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3684 }
3685 if (ses->capabilities & CAP_DFS) {
3686 smb_buffer->Flags2 |= SMBFLG2_DFS;
3687 }
3688 if (ses->capabilities & CAP_UNICODE) {
3689 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3690 length =
3691 cifs_strtoUTF16((__le16 *) bcc_ptr, tree,
3692 6 /* max utf8 char length in bytes */ *
3693 (/* server len*/ + 256 /* share len */), nls_codepage);
3694 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3695 bcc_ptr += 2; /* skip trailing null */
3696 } else { /* ASCII */
3697 strcpy(bcc_ptr, tree);
3698 bcc_ptr += strlen(tree) + 1;
3699 }
3700 strcpy(bcc_ptr, "?????");
3701 bcc_ptr += strlen("?????");
3702 bcc_ptr += 1;
3703 count = bcc_ptr - &pSMB->Password[0];
3704 pSMB->hdr.smb_buf_length = cpu_to_be32(be32_to_cpu(
3705 pSMB->hdr.smb_buf_length) + count);
3706 pSMB->ByteCount = cpu_to_le16(count);
3707
3708 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3709 0);
3710
3711 /* above now done in SendReceive */
3712 if ((rc == 0) && (tcon != NULL)) {
3713 bool is_unicode;
3714
3715 tcon->tidStatus = CifsGood;
3716 tcon->need_reconnect = false;
3717 tcon->tid = smb_buffer_response->Tid;
3718 bcc_ptr = pByteArea(smb_buffer_response);
3719 bytes_left = get_bcc(smb_buffer_response);
3720 length = strnlen(bcc_ptr, bytes_left - 2);
3721 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3722 is_unicode = true;
3723 else
3724 is_unicode = false;
3725
3726
3727 /* skip service field (NB: this field is always ASCII) */
3728 if (length == 3) {
3729 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3730 (bcc_ptr[2] == 'C')) {
3731 cifs_dbg(FYI, "IPC connection\n");
3732 tcon->ipc = 1;
3733 }
3734 } else if (length == 2) {
3735 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3736 /* the most common case */
3737 cifs_dbg(FYI, "disk share connection\n");
3738 }
3739 }
3740 bcc_ptr += length + 1;
3741 bytes_left -= (length + 1);
3742 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3743
3744 /* mostly informational -- no need to fail on error here */
3745 kfree(tcon->nativeFileSystem);
3746 tcon->nativeFileSystem = cifs_strndup_from_utf16(bcc_ptr,
3747 bytes_left, is_unicode,
3748 nls_codepage);
3749
3750 cifs_dbg(FYI, "nativeFileSystem=%s\n", tcon->nativeFileSystem);
3751
3752 if ((smb_buffer_response->WordCount == 3) ||
3753 (smb_buffer_response->WordCount == 7))
3754 /* field is in same location */
3755 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3756 else
3757 tcon->Flags = 0;
3758 cifs_dbg(FYI, "Tcon flags: 0x%x\n", tcon->Flags);
3759 } else if ((rc == 0) && tcon == NULL) {
3760 /* all we need to save for IPC$ connection */
3761 ses->ipc_tid = smb_buffer_response->Tid;
3762 }
3763
3764 cifs_buf_release(smb_buffer);
3765 return rc;
3766 }
3767
3768 void
3769 cifs_umount(struct cifs_sb_info *cifs_sb)
3770 {
3771 struct rb_root *root = &cifs_sb->tlink_tree;
3772 struct rb_node *node;
3773 struct tcon_link *tlink;
3774
3775 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3776
3777 spin_lock(&cifs_sb->tlink_tree_lock);
3778 while ((node = rb_first(root))) {
3779 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3780 cifs_get_tlink(tlink);
3781 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3782 rb_erase(node, root);
3783
3784 spin_unlock(&cifs_sb->tlink_tree_lock);
3785 cifs_put_tlink(tlink);
3786 spin_lock(&cifs_sb->tlink_tree_lock);
3787 }
3788 spin_unlock(&cifs_sb->tlink_tree_lock);
3789
3790 bdi_destroy(&cifs_sb->bdi);
3791 kfree(cifs_sb->mountdata);
3792 unload_nls(cifs_sb->local_nls);
3793 kfree(cifs_sb);
3794 }
3795
3796 int
3797 cifs_negotiate_protocol(const unsigned int xid, struct cifs_ses *ses)
3798 {
3799 int rc = 0;
3800 struct TCP_Server_Info *server = ses->server;
3801
3802 if (!server->ops->need_neg || !server->ops->negotiate)
3803 return -ENOSYS;
3804
3805 /* only send once per connect */
3806 if (!server->ops->need_neg(server))
3807 return 0;
3808
3809 set_credits(server, 1);
3810
3811 rc = server->ops->negotiate(xid, ses);
3812 if (rc == 0) {
3813 spin_lock(&GlobalMid_Lock);
3814 if (server->tcpStatus == CifsNeedNegotiate)
3815 server->tcpStatus = CifsGood;
3816 else
3817 rc = -EHOSTDOWN;
3818 spin_unlock(&GlobalMid_Lock);
3819 }
3820
3821 return rc;
3822 }
3823
3824 int
3825 cifs_setup_session(const unsigned int xid, struct cifs_ses *ses,
3826 struct nls_table *nls_info)
3827 {
3828 int rc = -ENOSYS;
3829 struct TCP_Server_Info *server = ses->server;
3830
3831 ses->flags = 0;
3832 ses->capabilities = server->capabilities;
3833 if (linuxExtEnabled == 0)
3834 ses->capabilities &= (~server->vals->cap_unix);
3835
3836 cifs_dbg(FYI, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d\n",
3837 server->sec_mode, server->capabilities, server->timeAdj);
3838
3839 if (server->ops->sess_setup)
3840 rc = server->ops->sess_setup(xid, ses, nls_info);
3841
3842 if (rc) {
3843 cifs_dbg(VFS, "Send error in SessSetup = %d\n", rc);
3844 } else {
3845 mutex_lock(&server->srv_mutex);
3846 if (!server->session_estab) {
3847 server->session_key.response = ses->auth_key.response;
3848 server->session_key.len = ses->auth_key.len;
3849 server->sequence_number = 0x2;
3850 server->session_estab = true;
3851 ses->auth_key.response = NULL;
3852 }
3853 mutex_unlock(&server->srv_mutex);
3854
3855 cifs_dbg(FYI, "CIFS Session Established successfully\n");
3856 spin_lock(&GlobalMid_Lock);
3857 ses->status = CifsGood;
3858 ses->need_reconnect = false;
3859 spin_unlock(&GlobalMid_Lock);
3860 }
3861
3862 kfree(ses->auth_key.response);
3863 ses->auth_key.response = NULL;
3864 ses->auth_key.len = 0;
3865 kfree(ses->ntlmssp);
3866 ses->ntlmssp = NULL;
3867
3868 return rc;
3869 }
3870
3871 static int
3872 cifs_set_vol_auth(struct smb_vol *vol, struct cifs_ses *ses)
3873 {
3874 switch (ses->server->secType) {
3875 case Kerberos:
3876 vol->secFlg = CIFSSEC_MUST_KRB5;
3877 return 0;
3878 case NTLMv2:
3879 vol->secFlg = CIFSSEC_MUST_NTLMV2;
3880 break;
3881 case NTLM:
3882 vol->secFlg = CIFSSEC_MUST_NTLM;
3883 break;
3884 case RawNTLMSSP:
3885 vol->secFlg = CIFSSEC_MUST_NTLMSSP;
3886 break;
3887 case LANMAN:
3888 vol->secFlg = CIFSSEC_MUST_LANMAN;
3889 break;
3890 }
3891
3892 return cifs_set_cifscreds(vol, ses);
3893 }
3894
3895 static struct cifs_tcon *
3896 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, kuid_t fsuid)
3897 {
3898 int rc;
3899 struct cifs_tcon *master_tcon = cifs_sb_master_tcon(cifs_sb);
3900 struct cifs_ses *ses;
3901 struct cifs_tcon *tcon = NULL;
3902 struct smb_vol *vol_info;
3903
3904 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3905 if (vol_info == NULL)
3906 return ERR_PTR(-ENOMEM);
3907
3908 vol_info->local_nls = cifs_sb->local_nls;
3909 vol_info->linux_uid = fsuid;
3910 vol_info->cred_uid = fsuid;
3911 vol_info->UNC = master_tcon->treeName;
3912 vol_info->retry = master_tcon->retry;
3913 vol_info->nocase = master_tcon->nocase;
3914 vol_info->local_lease = master_tcon->local_lease;
3915 vol_info->no_linux_ext = !master_tcon->unix_ext;
3916
3917 rc = cifs_set_vol_auth(vol_info, master_tcon->ses);
3918 if (rc) {
3919 tcon = ERR_PTR(rc);
3920 goto out;
3921 }
3922
3923 /* get a reference for the same TCP session */
3924 spin_lock(&cifs_tcp_ses_lock);
3925 ++master_tcon->ses->server->srv_count;
3926 spin_unlock(&cifs_tcp_ses_lock);
3927
3928 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3929 if (IS_ERR(ses)) {
3930 tcon = (struct cifs_tcon *)ses;
3931 cifs_put_tcp_session(master_tcon->ses->server);
3932 goto out;
3933 }
3934
3935 tcon = cifs_get_tcon(ses, vol_info);
3936 if (IS_ERR(tcon)) {
3937 cifs_put_smb_ses(ses);
3938 goto out;
3939 }
3940
3941 if (cap_unix(ses))
3942 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3943 out:
3944 kfree(vol_info->username);
3945 kfree(vol_info->password);
3946 kfree(vol_info);
3947
3948 return tcon;
3949 }
3950
3951 struct cifs_tcon *
3952 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3953 {
3954 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3955 }
3956
3957 static int
3958 cifs_sb_tcon_pending_wait(void *unused)
3959 {
3960 schedule();
3961 return signal_pending(current) ? -ERESTARTSYS : 0;
3962 }
3963
3964 /* find and return a tlink with given uid */
3965 static struct tcon_link *
3966 tlink_rb_search(struct rb_root *root, kuid_t uid)
3967 {
3968 struct rb_node *node = root->rb_node;
3969 struct tcon_link *tlink;
3970
3971 while (node) {
3972 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3973
3974 if (uid_gt(tlink->tl_uid, uid))
3975 node = node->rb_left;
3976 else if (uid_lt(tlink->tl_uid, uid))
3977 node = node->rb_right;
3978 else
3979 return tlink;
3980 }
3981 return NULL;
3982 }
3983
3984 /* insert a tcon_link into the tree */
3985 static void
3986 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3987 {
3988 struct rb_node **new = &(root->rb_node), *parent = NULL;
3989 struct tcon_link *tlink;
3990
3991 while (*new) {
3992 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3993 parent = *new;
3994
3995 if (uid_gt(tlink->tl_uid, new_tlink->tl_uid))
3996 new = &((*new)->rb_left);
3997 else
3998 new = &((*new)->rb_right);
3999 }
4000
4001 rb_link_node(&new_tlink->tl_rbnode, parent, new);
4002 rb_insert_color(&new_tlink->tl_rbnode, root);
4003 }
4004
4005 /*
4006 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
4007 * current task.
4008 *
4009 * If the superblock doesn't refer to a multiuser mount, then just return
4010 * the master tcon for the mount.
4011 *
4012 * First, search the rbtree for an existing tcon for this fsuid. If one
4013 * exists, then check to see if it's pending construction. If it is then wait
4014 * for construction to complete. Once it's no longer pending, check to see if
4015 * it failed and either return an error or retry construction, depending on
4016 * the timeout.
4017 *
4018 * If one doesn't exist then insert a new tcon_link struct into the tree and
4019 * try to construct a new one.
4020 */
4021 struct tcon_link *
4022 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
4023 {
4024 int ret;
4025 kuid_t fsuid = current_fsuid();
4026 struct tcon_link *tlink, *newtlink;
4027
4028 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
4029 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
4030
4031 spin_lock(&cifs_sb->tlink_tree_lock);
4032 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4033 if (tlink)
4034 cifs_get_tlink(tlink);
4035 spin_unlock(&cifs_sb->tlink_tree_lock);
4036
4037 if (tlink == NULL) {
4038 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
4039 if (newtlink == NULL)
4040 return ERR_PTR(-ENOMEM);
4041 newtlink->tl_uid = fsuid;
4042 newtlink->tl_tcon = ERR_PTR(-EACCES);
4043 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
4044 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
4045 cifs_get_tlink(newtlink);
4046
4047 spin_lock(&cifs_sb->tlink_tree_lock);
4048 /* was one inserted after previous search? */
4049 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
4050 if (tlink) {
4051 cifs_get_tlink(tlink);
4052 spin_unlock(&cifs_sb->tlink_tree_lock);
4053 kfree(newtlink);
4054 goto wait_for_construction;
4055 }
4056 tlink = newtlink;
4057 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
4058 spin_unlock(&cifs_sb->tlink_tree_lock);
4059 } else {
4060 wait_for_construction:
4061 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
4062 cifs_sb_tcon_pending_wait,
4063 TASK_INTERRUPTIBLE);
4064 if (ret) {
4065 cifs_put_tlink(tlink);
4066 return ERR_PTR(ret);
4067 }
4068
4069 /* if it's good, return it */
4070 if (!IS_ERR(tlink->tl_tcon))
4071 return tlink;
4072
4073 /* return error if we tried this already recently */
4074 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
4075 cifs_put_tlink(tlink);
4076 return ERR_PTR(-EACCES);
4077 }
4078
4079 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
4080 goto wait_for_construction;
4081 }
4082
4083 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
4084 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
4085 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
4086
4087 if (IS_ERR(tlink->tl_tcon)) {
4088 cifs_put_tlink(tlink);
4089 return ERR_PTR(-EACCES);
4090 }
4091
4092 return tlink;
4093 }
4094
4095 /*
4096 * periodic workqueue job that scans tcon_tree for a superblock and closes
4097 * out tcons.
4098 */
4099 static void
4100 cifs_prune_tlinks(struct work_struct *work)
4101 {
4102 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
4103 prune_tlinks.work);
4104 struct rb_root *root = &cifs_sb->tlink_tree;
4105 struct rb_node *node = rb_first(root);
4106 struct rb_node *tmp;
4107 struct tcon_link *tlink;
4108
4109 /*
4110 * Because we drop the spinlock in the loop in order to put the tlink
4111 * it's not guarded against removal of links from the tree. The only
4112 * places that remove entries from the tree are this function and
4113 * umounts. Because this function is non-reentrant and is canceled
4114 * before umount can proceed, this is safe.
4115 */
4116 spin_lock(&cifs_sb->tlink_tree_lock);
4117 node = rb_first(root);
4118 while (node != NULL) {
4119 tmp = node;
4120 node = rb_next(tmp);
4121 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
4122
4123 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
4124 atomic_read(&tlink->tl_count) != 0 ||
4125 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
4126 continue;
4127
4128 cifs_get_tlink(tlink);
4129 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
4130 rb_erase(tmp, root);
4131
4132 spin_unlock(&cifs_sb->tlink_tree_lock);
4133 cifs_put_tlink(tlink);
4134 spin_lock(&cifs_sb->tlink_tree_lock);
4135 }
4136 spin_unlock(&cifs_sb->tlink_tree_lock);
4137
4138 queue_delayed_work(cifsiod_wq, &cifs_sb->prune_tlinks,
4139 TLINK_IDLE_EXPIRE);
4140 }
kernel source for telekom puls (alcatel/mediatek)