?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cifs: sanitize length checking in coalesce_t2 (try #3)
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / fs / cifs / connect.c
blob8b75a8ec90b4a6fedd6a3deab3c807293c944d70
1 /*
2 * fs/cifs/connect.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2009
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 <net/ipv6.h>
41 #include "cifspdu.h"
42 #include "cifsglob.h"
43 #include "cifsproto.h"
44 #include "cifs_unicode.h"
45 #include "cifs_debug.h"
46 #include "cifs_fs_sb.h"
47 #include "ntlmssp.h"
48 #include "nterr.h"
49 #include "rfc1002pdu.h"
50 #include "fscache.h"
51
52 #define CIFS_PORT 445
53 #define RFC1001_PORT 139
54
55 /* SMB echo "timeout" -- FIXME: tunable? */
56 #define SMB_ECHO_INTERVAL (60 * HZ)
57
58 extern mempool_t *cifs_req_poolp;
59
60 struct smb_vol {
61 char *username;
62 char *password;
63 char *domainname;
64 char *UNC;
65 char *UNCip;
66 char *iocharset; /* local code page for mapping to and from Unicode */
67 char source_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* clnt nb name */
68 char target_rfc1001_name[RFC1001_NAME_LEN_WITH_NULL]; /* srvr nb name */
69 uid_t cred_uid;
70 uid_t linux_uid;
71 gid_t linux_gid;
72 mode_t file_mode;
73 mode_t dir_mode;
74 unsigned secFlg;
75 bool retry:1;
76 bool intr:1;
77 bool setuids:1;
78 bool override_uid:1;
79 bool override_gid:1;
80 bool dynperm:1;
81 bool noperm:1;
82 bool no_psx_acl:1; /* set if posix acl support should be disabled */
83 bool cifs_acl:1;
84 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
85 bool server_ino:1; /* use inode numbers from server ie UniqueId */
86 bool direct_io:1;
87 bool strict_io:1; /* strict cache behavior */
88 bool remap:1; /* set to remap seven reserved chars in filenames */
89 bool posix_paths:1; /* unset to not ask for posix pathnames. */
90 bool no_linux_ext:1;
91 bool sfu_emul:1;
92 bool nullauth:1; /* attempt to authenticate with null user */
93 bool nocase:1; /* request case insensitive filenames */
94 bool nobrl:1; /* disable sending byte range locks to srv */
95 bool mand_lock:1; /* send mandatory not posix byte range lock reqs */
96 bool seal:1; /* request transport encryption on share */
97 bool nodfs:1; /* Do not request DFS, even if available */
98 bool local_lease:1; /* check leases only on local system, not remote */
99 bool noblocksnd:1;
100 bool noautotune:1;
101 bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
102 bool fsc:1; /* enable fscache */
103 bool mfsymlinks:1; /* use Minshall+French Symlinks */
104 bool multiuser:1;
105 unsigned int rsize;
106 unsigned int wsize;
107 bool sockopt_tcp_nodelay:1;
108 unsigned short int port;
109 unsigned long actimeo; /* attribute cache timeout (jiffies) */
110 char *prepath;
111 struct sockaddr_storage srcaddr; /* allow binding to a local IP */
112 struct nls_table *local_nls;
113 };
114
115 /* FIXME: should these be tunable? */
116 #define TLINK_ERROR_EXPIRE (1 * HZ)
117 #define TLINK_IDLE_EXPIRE (600 * HZ)
118
119 static int ip_connect(struct TCP_Server_Info *server);
120 static int generic_ip_connect(struct TCP_Server_Info *server);
121 static void tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink);
122 static void cifs_prune_tlinks(struct work_struct *work);
123
124 /*
125 * cifs tcp session reconnection
126 *
127 * mark tcp session as reconnecting so temporarily locked
128 * mark all smb sessions as reconnecting for tcp session
129 * reconnect tcp session
130 * wake up waiters on reconnection? - (not needed currently)
131 */
132 static int
133 cifs_reconnect(struct TCP_Server_Info *server)
134 {
135 int rc = 0;
136 struct list_head *tmp, *tmp2;
137 struct cifsSesInfo *ses;
138 struct cifsTconInfo *tcon;
139 struct mid_q_entry *mid_entry;
140
141 spin_lock(&GlobalMid_Lock);
142 if (server->tcpStatus == CifsExiting) {
143 /* the demux thread will exit normally
144 next time through the loop */
145 spin_unlock(&GlobalMid_Lock);
146 return rc;
147 } else
148 server->tcpStatus = CifsNeedReconnect;
149 spin_unlock(&GlobalMid_Lock);
150 server->maxBuf = 0;
151
152 cFYI(1, "Reconnecting tcp session");
153
154 /* before reconnecting the tcp session, mark the smb session (uid)
155 and the tid bad so they are not used until reconnected */
156 cFYI(1, "%s: marking sessions and tcons for reconnect", __func__);
157 spin_lock(&cifs_tcp_ses_lock);
158 list_for_each(tmp, &server->smb_ses_list) {
159 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
160 ses->need_reconnect = true;
161 ses->ipc_tid = 0;
162 list_for_each(tmp2, &ses->tcon_list) {
163 tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
164 tcon->need_reconnect = true;
165 }
166 }
167 spin_unlock(&cifs_tcp_ses_lock);
168
169 /* do not want to be sending data on a socket we are freeing */
170 cFYI(1, "%s: tearing down socket", __func__);
171 mutex_lock(&server->srv_mutex);
172 if (server->ssocket) {
173 cFYI(1, "State: 0x%x Flags: 0x%lx", server->ssocket->state,
174 server->ssocket->flags);
175 kernel_sock_shutdown(server->ssocket, SHUT_WR);
176 cFYI(1, "Post shutdown state: 0x%x Flags: 0x%lx",
177 server->ssocket->state,
178 server->ssocket->flags);
179 sock_release(server->ssocket);
180 server->ssocket = NULL;
181 }
182 server->sequence_number = 0;
183 server->session_estab = false;
184 kfree(server->session_key.response);
185 server->session_key.response = NULL;
186 server->session_key.len = 0;
187 server->lstrp = jiffies;
188 mutex_unlock(&server->srv_mutex);
189
190 /* mark submitted MIDs for retry and issue callback */
191 cFYI(1, "%s: issuing mid callbacks", __func__);
192 spin_lock(&GlobalMid_Lock);
193 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
194 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
195 if (mid_entry->midState == MID_REQUEST_SUBMITTED)
196 mid_entry->midState = MID_RETRY_NEEDED;
197 list_del_init(&mid_entry->qhead);
198 mid_entry->callback(mid_entry);
199 }
200 spin_unlock(&GlobalMid_Lock);
201
202 while (server->tcpStatus == CifsNeedReconnect) {
203 try_to_freeze();
204
205 /* we should try only the port we connected to before */
206 rc = generic_ip_connect(server);
207 if (rc) {
208 cFYI(1, "reconnect error %d", rc);
209 msleep(3000);
210 } else {
211 atomic_inc(&tcpSesReconnectCount);
212 spin_lock(&GlobalMid_Lock);
213 if (server->tcpStatus != CifsExiting)
214 server->tcpStatus = CifsNeedNegotiate;
215 spin_unlock(&GlobalMid_Lock);
216 }
217 }
218
219 return rc;
220 }
221
222 /*
223 return codes:
224 0 not a transact2, or all data present
225 >0 transact2 with that much data missing
226 -EINVAL = invalid transact2
227
228 */
229 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
230 {
231 struct smb_t2_rsp *pSMBt;
232 int remaining;
233 __u16 total_data_size, data_in_this_rsp;
234
235 if (pSMB->Command != SMB_COM_TRANSACTION2)
236 return 0;
237
238 /* check for plausible wct, bcc and t2 data and parm sizes */
239 /* check for parm and data offset going beyond end of smb */
240 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
241 cFYI(1, "invalid transact2 word count");
242 return -EINVAL;
243 }
244
245 pSMBt = (struct smb_t2_rsp *)pSMB;
246
247 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
248 data_in_this_rsp = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
249
250 if (total_data_size == data_in_this_rsp)
251 return 0;
252 else if (total_data_size < data_in_this_rsp) {
253 cFYI(1, "total data %d smaller than data in frame %d",
254 total_data_size, data_in_this_rsp);
255 return -EINVAL;
256 }
257
258 remaining = total_data_size - data_in_this_rsp;
259
260 cFYI(1, "missing %d bytes from transact2, check next response",
261 remaining);
262 if (total_data_size > maxBufSize) {
263 cERROR(1, "TotalDataSize %d is over maximum buffer %d",
264 total_data_size, maxBufSize);
265 return -EINVAL;
266 }
267 return remaining;
268 }
269
270 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
271 {
272 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
273 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
274 char *data_area_of_target;
275 char *data_area_of_buf2;
276 int remaining;
277 unsigned int byte_count, total_in_buf;
278 __u16 total_data_size, total_in_buf2;
279
280 total_data_size = get_unaligned_le16(&pSMBt->t2_rsp.TotalDataCount);
281
282 if (total_data_size !=
283 get_unaligned_le16(&pSMB2->t2_rsp.TotalDataCount))
284 cFYI(1, "total data size of primary and secondary t2 differ");
285
286 total_in_buf = get_unaligned_le16(&pSMBt->t2_rsp.DataCount);
287
288 remaining = total_data_size - total_in_buf;
289
290 if (remaining < 0)
291 return -EPROTO;
292
293 if (remaining == 0) /* nothing to do, ignore */
294 return 0;
295
296 total_in_buf2 = get_unaligned_le16(&pSMB2->t2_rsp.DataCount);
297 if (remaining < total_in_buf2) {
298 cFYI(1, "transact2 2nd response contains too much data");
299 }
300
301 /* find end of first SMB data area */
302 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
303 get_unaligned_le16(&pSMBt->t2_rsp.DataOffset);
304 /* validate target area */
305
306 data_area_of_buf2 = (char *)&pSMB2->hdr.Protocol +
307 get_unaligned_le16(&pSMB2->t2_rsp.DataOffset);
308
309 data_area_of_target += total_in_buf;
310
311 /* copy second buffer into end of first buffer */
312 total_in_buf += total_in_buf2;
313 /* is the result too big for the field? */
314 if (total_in_buf > USHRT_MAX)
315 return -EPROTO;
316 put_unaligned_le16(total_in_buf, &pSMBt->t2_rsp.DataCount);
317
318 /* fix up the BCC */
319 byte_count = get_bcc_le(pTargetSMB);
320 byte_count += total_in_buf2;
321 /* is the result too big for the field? */
322 if (byte_count > USHRT_MAX)
323 return -EPROTO;
324 put_bcc_le(byte_count, pTargetSMB);
325
326 byte_count = pTargetSMB->smb_buf_length;
327 byte_count += total_in_buf2;
328 /* don't allow buffer to overflow */
329 if (byte_count > CIFSMaxBufSize)
330 return -ENOBUFS;
331 pTargetSMB->smb_buf_length = byte_count;
332
333 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
334
335 if (remaining == total_in_buf2) {
336 cFYI(1, "found the last secondary response");
337 return 0; /* we are done */
338 } else /* more responses to go */
339 return 1;
340 }
341
342 static void
343 cifs_echo_request(struct work_struct *work)
344 {
345 int rc;
346 struct TCP_Server_Info *server = container_of(work,
347 struct TCP_Server_Info, echo.work);
348
349 /*
350 * We cannot send an echo until the NEGOTIATE_PROTOCOL request is
351 * done, which is indicated by maxBuf != 0. Also, no need to ping if
352 * we got a response recently
353 */
354 if (server->maxBuf == 0 ||
355 time_before(jiffies, server->lstrp + SMB_ECHO_INTERVAL - HZ))
356 goto requeue_echo;
357
358 rc = CIFSSMBEcho(server);
359 if (rc)
360 cFYI(1, "Unable to send echo request to server: %s",
361 server->hostname);
362
363 requeue_echo:
364 queue_delayed_work(system_nrt_wq, &server->echo, SMB_ECHO_INTERVAL);
365 }
366
367 static int
368 cifs_demultiplex_thread(struct TCP_Server_Info *server)
369 {
370 int length;
371 unsigned int pdu_length, total_read;
372 struct smb_hdr *smb_buffer = NULL;
373 struct smb_hdr *bigbuf = NULL;
374 struct smb_hdr *smallbuf = NULL;
375 struct msghdr smb_msg;
376 struct kvec iov;
377 struct socket *csocket = server->ssocket;
378 struct list_head *tmp, *tmp2;
379 struct task_struct *task_to_wake = NULL;
380 struct mid_q_entry *mid_entry;
381 char temp;
382 bool isLargeBuf = false;
383 bool isMultiRsp;
384 int reconnect;
385
386 current->flags |= PF_MEMALLOC;
387 cFYI(1, "Demultiplex PID: %d", task_pid_nr(current));
388
389 length = atomic_inc_return(&tcpSesAllocCount);
390 if (length > 1)
391 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
392 GFP_KERNEL);
393
394 set_freezable();
395 while (server->tcpStatus != CifsExiting) {
396 if (try_to_freeze())
397 continue;
398 if (bigbuf == NULL) {
399 bigbuf = cifs_buf_get();
400 if (!bigbuf) {
401 cERROR(1, "No memory for large SMB response");
402 msleep(3000);
403 /* retry will check if exiting */
404 continue;
405 }
406 } else if (isLargeBuf) {
407 /* we are reusing a dirty large buf, clear its start */
408 memset(bigbuf, 0, sizeof(struct smb_hdr));
409 }
410
411 if (smallbuf == NULL) {
412 smallbuf = cifs_small_buf_get();
413 if (!smallbuf) {
414 cERROR(1, "No memory for SMB response");
415 msleep(1000);
416 /* retry will check if exiting */
417 continue;
418 }
419 /* beginning of smb buffer is cleared in our buf_get */
420 } else /* if existing small buf clear beginning */
421 memset(smallbuf, 0, sizeof(struct smb_hdr));
422
423 isLargeBuf = false;
424 isMultiRsp = false;
425 smb_buffer = smallbuf;
426 iov.iov_base = smb_buffer;
427 iov.iov_len = 4;
428 smb_msg.msg_control = NULL;
429 smb_msg.msg_controllen = 0;
430 pdu_length = 4; /* enough to get RFC1001 header */
431
432 incomplete_rcv:
433 if (echo_retries > 0 && server->tcpStatus == CifsGood &&
434 time_after(jiffies, server->lstrp +
435 (echo_retries * SMB_ECHO_INTERVAL))) {
436 cERROR(1, "Server %s has not responded in %d seconds. "
437 "Reconnecting...", server->hostname,
438 (echo_retries * SMB_ECHO_INTERVAL / HZ));
439 cifs_reconnect(server);
440 csocket = server->ssocket;
441 wake_up(&server->response_q);
442 continue;
443 }
444
445 length =
446 kernel_recvmsg(csocket, &smb_msg,
447 &iov, 1, pdu_length, 0 /* BB other flags? */);
448
449 if (server->tcpStatus == CifsExiting) {
450 break;
451 } else if (server->tcpStatus == CifsNeedReconnect) {
452 cFYI(1, "Reconnect after server stopped responding");
453 cifs_reconnect(server);
454 cFYI(1, "call to reconnect done");
455 csocket = server->ssocket;
456 continue;
457 } else if (length == -ERESTARTSYS ||
458 length == -EAGAIN ||
459 length == -EINTR) {
460 msleep(1); /* minimum sleep to prevent looping
461 allowing socket to clear and app threads to set
462 tcpStatus CifsNeedReconnect if server hung */
463 if (pdu_length < 4) {
464 iov.iov_base = (4 - pdu_length) +
465 (char *)smb_buffer;
466 iov.iov_len = pdu_length;
467 smb_msg.msg_control = NULL;
468 smb_msg.msg_controllen = 0;
469 goto incomplete_rcv;
470 } else
471 continue;
472 } else if (length <= 0) {
473 cFYI(1, "Reconnect after unexpected peek error %d",
474 length);
475 cifs_reconnect(server);
476 csocket = server->ssocket;
477 wake_up(&server->response_q);
478 continue;
479 } else if (length < pdu_length) {
480 cFYI(1, "requested %d bytes but only got %d bytes",
481 pdu_length, length);
482 pdu_length -= length;
483 msleep(1);
484 goto incomplete_rcv;
485 }
486
487 /* The right amount was read from socket - 4 bytes */
488 /* so we can now interpret the length field */
489
490 /* the first byte big endian of the length field,
491 is actually not part of the length but the type
492 with the most common, zero, as regular data */
493 temp = *((char *) smb_buffer);
494
495 /* Note that FC 1001 length is big endian on the wire,
496 but we convert it here so it is always manipulated
497 as host byte order */
498 pdu_length = be32_to_cpu((__force __be32)smb_buffer->smb_buf_length);
499 smb_buffer->smb_buf_length = pdu_length;
500
501 cFYI(1, "rfc1002 length 0x%x", pdu_length+4);
502
503 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
504 continue;
505 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
506 cFYI(1, "Good RFC 1002 session rsp");
507 continue;
508 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
509 /* we get this from Windows 98 instead of
510 an error on SMB negprot response */
511 cFYI(1, "Negative RFC1002 Session Response Error 0x%x)",
512 pdu_length);
513 /* give server a second to clean up */
514 msleep(1000);
515 /* always try 445 first on reconnect since we get NACK
516 * on some if we ever connected to port 139 (the NACK
517 * is since we do not begin with RFC1001 session
518 * initialize frame)
519 */
520 cifs_set_port((struct sockaddr *)
521 &server->dstaddr, CIFS_PORT);
522 cifs_reconnect(server);
523 csocket = server->ssocket;
524 wake_up(&server->response_q);
525 continue;
526 } else if (temp != (char) 0) {
527 cERROR(1, "Unknown RFC 1002 frame");
528 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
529 length);
530 cifs_reconnect(server);
531 csocket = server->ssocket;
532 continue;
533 }
534
535 /* else we have an SMB response */
536 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
537 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
538 cERROR(1, "Invalid size SMB length %d pdu_length %d",
539 length, pdu_length+4);
540 cifs_reconnect(server);
541 csocket = server->ssocket;
542 wake_up(&server->response_q);
543 continue;
544 }
545
546 /* else length ok */
547 reconnect = 0;
548
549 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
550 isLargeBuf = true;
551 memcpy(bigbuf, smallbuf, 4);
552 smb_buffer = bigbuf;
553 }
554 length = 0;
555 iov.iov_base = 4 + (char *)smb_buffer;
556 iov.iov_len = pdu_length;
557 for (total_read = 0; total_read < pdu_length;
558 total_read += length) {
559 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
560 pdu_length - total_read, 0);
561 if (server->tcpStatus == CifsExiting) {
562 /* then will exit */
563 reconnect = 2;
564 break;
565 } else if (server->tcpStatus == CifsNeedReconnect) {
566 cifs_reconnect(server);
567 csocket = server->ssocket;
568 /* Reconnect wakes up rspns q */
569 /* Now we will reread sock */
570 reconnect = 1;
571 break;
572 } else if (length == -ERESTARTSYS ||
573 length == -EAGAIN ||
574 length == -EINTR) {
575 msleep(1); /* minimum sleep to prevent looping,
576 allowing socket to clear and app
577 threads to set tcpStatus
578 CifsNeedReconnect if server hung*/
579 length = 0;
580 continue;
581 } else if (length <= 0) {
582 cERROR(1, "Received no data, expecting %d",
583 pdu_length - total_read);
584 cifs_reconnect(server);
585 csocket = server->ssocket;
586 reconnect = 1;
587 break;
588 }
589 }
590 if (reconnect == 2)
591 break;
592 else if (reconnect == 1)
593 continue;
594
595 total_read += 4; /* account for rfc1002 hdr */
596
597 dump_smb(smb_buffer, total_read);
598
599 /*
600 * We know that we received enough to get to the MID as we
601 * checked the pdu_length earlier. Now check to see
602 * if the rest of the header is OK. We borrow the length
603 * var for the rest of the loop to avoid a new stack var.
604 *
605 * 48 bytes is enough to display the header and a little bit
606 * into the payload for debugging purposes.
607 */
608 length = checkSMB(smb_buffer, smb_buffer->Mid, total_read);
609 if (length != 0)
610 cifs_dump_mem("Bad SMB: ", smb_buffer,
611 min_t(unsigned int, total_read, 48));
612
613 mid_entry = NULL;
614 server->lstrp = jiffies;
615
616 spin_lock(&GlobalMid_Lock);
617 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
618 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
619
620 if ((mid_entry->mid == smb_buffer->Mid) &&
621 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
622 (mid_entry->command == smb_buffer->Command)) {
623 if (length == 0 &&
624 check2ndT2(smb_buffer, server->maxBuf) > 0) {
625 /* We have a multipart transact2 resp */
626 isMultiRsp = true;
627 if (mid_entry->resp_buf) {
628 /* merge response - fix up 1st*/
629 if (coalesce_t2(smb_buffer,
630 mid_entry->resp_buf)) {
631 mid_entry->multiRsp =
632 true;
633 break;
634 } else {
635 /* all parts received */
636 mid_entry->multiEnd =
637 true;
638 goto multi_t2_fnd;
639 }
640 } else {
641 if (!isLargeBuf) {
642 cERROR(1, "1st trans2 resp needs bigbuf");
643 /* BB maybe we can fix this up, switch
644 to already allocated large buffer? */
645 } else {
646 /* Have first buffer */
647 mid_entry->resp_buf =
648 smb_buffer;
649 mid_entry->largeBuf =
650 true;
651 bigbuf = NULL;
652 }
653 }
654 break;
655 }
656 mid_entry->resp_buf = smb_buffer;
657 mid_entry->largeBuf = isLargeBuf;
658 multi_t2_fnd:
659 if (length == 0)
660 mid_entry->midState =
661 MID_RESPONSE_RECEIVED;
662 else
663 mid_entry->midState =
664 MID_RESPONSE_MALFORMED;
665 #ifdef CONFIG_CIFS_STATS2
666 mid_entry->when_received = jiffies;
667 #endif
668 list_del_init(&mid_entry->qhead);
669 mid_entry->callback(mid_entry);
670 break;
671 }
672 mid_entry = NULL;
673 }
674 spin_unlock(&GlobalMid_Lock);
675
676 if (mid_entry != NULL) {
677 /* Was previous buf put in mpx struct for multi-rsp? */
678 if (!isMultiRsp) {
679 /* smb buffer will be freed by user thread */
680 if (isLargeBuf)
681 bigbuf = NULL;
682 else
683 smallbuf = NULL;
684 }
685 } else if (length != 0) {
686 /* response sanity checks failed */
687 continue;
688 } else if (!is_valid_oplock_break(smb_buffer, server) &&
689 !isMultiRsp) {
690 cERROR(1, "No task to wake, unknown frame received! "
691 "NumMids %d", atomic_read(&midCount));
692 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
693 sizeof(struct smb_hdr));
694 #ifdef CONFIG_CIFS_DEBUG2
695 cifs_dump_detail(smb_buffer);
696 cifs_dump_mids(server);
697 #endif /* CIFS_DEBUG2 */
698
699 }
700 } /* end while !EXITING */
701
702 /* take it off the list, if it's not already */
703 spin_lock(&cifs_tcp_ses_lock);
704 list_del_init(&server->tcp_ses_list);
705 spin_unlock(&cifs_tcp_ses_lock);
706
707 spin_lock(&GlobalMid_Lock);
708 server->tcpStatus = CifsExiting;
709 spin_unlock(&GlobalMid_Lock);
710 wake_up_all(&server->response_q);
711
712 /* check if we have blocked requests that need to free */
713 /* Note that cifs_max_pending is normally 50, but
714 can be set at module install time to as little as two */
715 spin_lock(&GlobalMid_Lock);
716 if (atomic_read(&server->inFlight) >= cifs_max_pending)
717 atomic_set(&server->inFlight, cifs_max_pending - 1);
718 /* We do not want to set the max_pending too low or we
719 could end up with the counter going negative */
720 spin_unlock(&GlobalMid_Lock);
721 /* Although there should not be any requests blocked on
722 this queue it can not hurt to be paranoid and try to wake up requests
723 that may haven been blocked when more than 50 at time were on the wire
724 to the same server - they now will see the session is in exit state
725 and get out of SendReceive. */
726 wake_up_all(&server->request_q);
727 /* give those requests time to exit */
728 msleep(125);
729
730 if (server->ssocket) {
731 sock_release(csocket);
732 server->ssocket = NULL;
733 }
734 /* buffer usuallly freed in free_mid - need to free it here on exit */
735 cifs_buf_release(bigbuf);
736 if (smallbuf) /* no sense logging a debug message if NULL */
737 cifs_small_buf_release(smallbuf);
738
739 if (!list_empty(&server->pending_mid_q)) {
740 spin_lock(&GlobalMid_Lock);
741 list_for_each_safe(tmp, tmp2, &server->pending_mid_q) {
742 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
743 cFYI(1, "Clearing Mid 0x%x - issuing callback",
744 mid_entry->mid);
745 list_del_init(&mid_entry->qhead);
746 mid_entry->callback(mid_entry);
747 }
748 spin_unlock(&GlobalMid_Lock);
749 /* 1/8th of sec is more than enough time for them to exit */
750 msleep(125);
751 }
752
753 if (!list_empty(&server->pending_mid_q)) {
754 /* mpx threads have not exited yet give them
755 at least the smb send timeout time for long ops */
756 /* due to delays on oplock break requests, we need
757 to wait at least 45 seconds before giving up
758 on a request getting a response and going ahead
759 and killing cifsd */
760 cFYI(1, "Wait for exit from demultiplex thread");
761 msleep(46000);
762 /* if threads still have not exited they are probably never
763 coming home not much else we can do but free the memory */
764 }
765
766 kfree(server->hostname);
767 task_to_wake = xchg(&server->tsk, NULL);
768 kfree(server);
769
770 length = atomic_dec_return(&tcpSesAllocCount);
771 if (length > 0)
772 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
773 GFP_KERNEL);
774
775 /* if server->tsk was NULL then wait for a signal before exiting */
776 if (!task_to_wake) {
777 set_current_state(TASK_INTERRUPTIBLE);
778 while (!signal_pending(current)) {
779 schedule();
780 set_current_state(TASK_INTERRUPTIBLE);
781 }
782 set_current_state(TASK_RUNNING);
783 }
784
785 module_put_and_exit(0);
786 }
787
788 /* extract the host portion of the UNC string */
789 static char *
790 extract_hostname(const char *unc)
791 {
792 const char *src;
793 char *dst, *delim;
794 unsigned int len;
795
796 /* skip double chars at beginning of string */
797 /* BB: check validity of these bytes? */
798 src = unc + 2;
799
800 /* delimiter between hostname and sharename is always '\\' now */
801 delim = strchr(src, '\\');
802 if (!delim)
803 return ERR_PTR(-EINVAL);
804
805 len = delim - src;
806 dst = kmalloc((len + 1), GFP_KERNEL);
807 if (dst == NULL)
808 return ERR_PTR(-ENOMEM);
809
810 memcpy(dst, src, len);
811 dst[len] = '\0';
812
813 return dst;
814 }
815
816 static int
817 cifs_parse_mount_options(char *options, const char *devname,
818 struct smb_vol *vol)
819 {
820 char *value, *data, *end;
821 unsigned int temp_len, i, j;
822 char separator[2];
823 short int override_uid = -1;
824 short int override_gid = -1;
825 bool uid_specified = false;
826 bool gid_specified = false;
827 char *nodename = utsname()->nodename;
828
829 separator[0] = ',';
830 separator[1] = 0;
831
832 /*
833 * does not have to be perfect mapping since field is
834 * informational, only used for servers that do not support
835 * port 445 and it can be overridden at mount time
836 */
837 memset(vol->source_rfc1001_name, 0x20, RFC1001_NAME_LEN);
838 for (i = 0; i < strnlen(nodename, RFC1001_NAME_LEN); i++)
839 vol->source_rfc1001_name[i] = toupper(nodename[i]);
840
841 vol->source_rfc1001_name[RFC1001_NAME_LEN] = 0;
842 /* null target name indicates to use *SMBSERVR default called name
843 if we end up sending RFC1001 session initialize */
844 vol->target_rfc1001_name[0] = 0;
845 vol->cred_uid = current_uid();
846 vol->linux_uid = current_uid();
847 vol->linux_gid = current_gid();
848
849 /* default to only allowing write access to owner of the mount */
850 vol->dir_mode = vol->file_mode = S_IRUGO | S_IXUGO | S_IWUSR;
851
852 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
853 /* default is always to request posix paths. */
854 vol->posix_paths = 1;
855 /* default to using server inode numbers where available */
856 vol->server_ino = 1;
857
858 vol->actimeo = CIFS_DEF_ACTIMEO;
859
860 if (!options)
861 return 1;
862
863 end = options + strlen(options);
864 if (strncmp(options, "sep=", 4) == 0) {
865 if (options[4] != 0) {
866 separator[0] = options[4];
867 options += 5;
868 } else {
869 cFYI(1, "Null separator not allowed");
870 }
871 }
872
873 while ((data = strsep(&options, separator)) != NULL) {
874 if (!*data)
875 continue;
876 if ((value = strchr(data, '=')) != NULL)
877 *value++ = '\0';
878
879 /* Have to parse this before we parse for "user" */
880 if (strnicmp(data, "user_xattr", 10) == 0) {
881 vol->no_xattr = 0;
882 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
883 vol->no_xattr = 1;
884 } else if (strnicmp(data, "user", 4) == 0) {
885 if (!value) {
886 printk(KERN_WARNING
887 "CIFS: invalid or missing username\n");
888 return 1; /* needs_arg; */
889 } else if (!*value) {
890 /* null user, ie anonymous, authentication */
891 vol->nullauth = 1;
892 }
893 if (strnlen(value, MAX_USERNAME_SIZE) <
894 MAX_USERNAME_SIZE) {
895 vol->username = value;
896 } else {
897 printk(KERN_WARNING "CIFS: username too long\n");
898 return 1;
899 }
900 } else if (strnicmp(data, "pass", 4) == 0) {
901 if (!value) {
902 vol->password = NULL;
903 continue;
904 } else if (value[0] == 0) {
905 /* check if string begins with double comma
906 since that would mean the password really
907 does start with a comma, and would not
908 indicate an empty string */
909 if (value[1] != separator[0]) {
910 vol->password = NULL;
911 continue;
912 }
913 }
914 temp_len = strlen(value);
915 /* removed password length check, NTLM passwords
916 can be arbitrarily long */
917
918 /* if comma in password, the string will be
919 prematurely null terminated. Commas in password are
920 specified across the cifs mount interface by a double
921 comma ie ,, and a comma used as in other cases ie ','
922 as a parameter delimiter/separator is single and due
923 to the strsep above is temporarily zeroed. */
924
925 /* NB: password legally can have multiple commas and
926 the only illegal character in a password is null */
927
928 if ((value[temp_len] == 0) &&
929 (value + temp_len < end) &&
930 (value[temp_len+1] == separator[0])) {
931 /* reinsert comma */
932 value[temp_len] = separator[0];
933 temp_len += 2; /* move after second comma */
934 while (value[temp_len] != 0) {
935 if (value[temp_len] == separator[0]) {
936 if (value[temp_len+1] ==
937 separator[0]) {
938 /* skip second comma */
939 temp_len++;
940 } else {
941 /* single comma indicating start
942 of next parm */
943 break;
944 }
945 }
946 temp_len++;
947 }
948 if (value[temp_len] == 0) {
949 options = NULL;
950 } else {
951 value[temp_len] = 0;
952 /* point option to start of next parm */
953 options = value + temp_len + 1;
954 }
955 /* go from value to value + temp_len condensing
956 double commas to singles. Note that this ends up
957 allocating a few bytes too many, which is ok */
958 vol->password = kzalloc(temp_len, GFP_KERNEL);
959 if (vol->password == NULL) {
960 printk(KERN_WARNING "CIFS: no memory "
961 "for password\n");
962 return 1;
963 }
964 for (i = 0, j = 0; i < temp_len; i++, j++) {
965 vol->password[j] = value[i];
966 if (value[i] == separator[0]
967 && value[i+1] == separator[0]) {
968 /* skip second comma */
969 i++;
970 }
971 }
972 vol->password[j] = 0;
973 } else {
974 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
975 if (vol->password == NULL) {
976 printk(KERN_WARNING "CIFS: no memory "
977 "for password\n");
978 return 1;
979 }
980 strcpy(vol->password, value);
981 }
982 } else if (!strnicmp(data, "ip", 2) ||
983 !strnicmp(data, "addr", 4)) {
984 if (!value || !*value) {
985 vol->UNCip = NULL;
986 } else if (strnlen(value, INET6_ADDRSTRLEN) <
987 INET6_ADDRSTRLEN) {
988 vol->UNCip = value;
989 } else {
990 printk(KERN_WARNING "CIFS: ip address "
991 "too long\n");
992 return 1;
993 }
994 } else if (strnicmp(data, "sec", 3) == 0) {
995 if (!value || !*value) {
996 cERROR(1, "no security value specified");
997 continue;
998 } else if (strnicmp(value, "krb5i", 5) == 0) {
999 vol->secFlg |= CIFSSEC_MAY_KRB5 |
1000 CIFSSEC_MUST_SIGN;
1001 } else if (strnicmp(value, "krb5p", 5) == 0) {
1002 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
1003 CIFSSEC_MAY_KRB5; */
1004 cERROR(1, "Krb5 cifs privacy not supported");
1005 return 1;
1006 } else if (strnicmp(value, "krb5", 4) == 0) {
1007 vol->secFlg |= CIFSSEC_MAY_KRB5;
1008 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
1009 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
1010 CIFSSEC_MUST_SIGN;
1011 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
1012 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
1013 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
1014 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
1015 CIFSSEC_MUST_SIGN;
1016 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
1017 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1018 } else if (strnicmp(value, "ntlmi", 5) == 0) {
1019 vol->secFlg |= CIFSSEC_MAY_NTLM |
1020 CIFSSEC_MUST_SIGN;
1021 } else if (strnicmp(value, "ntlm", 4) == 0) {
1022 /* ntlm is default so can be turned off too */
1023 vol->secFlg |= CIFSSEC_MAY_NTLM;
1024 } else if (strnicmp(value, "nontlm", 6) == 0) {
1025 /* BB is there a better way to do this? */
1026 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1027 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1028 } else if (strnicmp(value, "lanman", 6) == 0) {
1029 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1030 #endif
1031 } else if (strnicmp(value, "none", 4) == 0) {
1032 vol->nullauth = 1;
1033 } else {
1034 cERROR(1, "bad security option: %s", value);
1035 return 1;
1036 }
1037 } else if ((strnicmp(data, "unc", 3) == 0)
1038 || (strnicmp(data, "target", 6) == 0)
1039 || (strnicmp(data, "path", 4) == 0)) {
1040 if (!value || !*value) {
1041 printk(KERN_WARNING "CIFS: invalid path to "
1042 "network resource\n");
1043 return 1; /* needs_arg; */
1044 }
1045 if ((temp_len = strnlen(value, 300)) < 300) {
1046 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1047 if (vol->UNC == NULL)
1048 return 1;
1049 strcpy(vol->UNC, value);
1050 if (strncmp(vol->UNC, "//", 2) == 0) {
1051 vol->UNC[0] = '\\';
1052 vol->UNC[1] = '\\';
1053 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1054 printk(KERN_WARNING
1055 "CIFS: UNC Path does not begin "
1056 "with // or \\\\ \n");
1057 return 1;
1058 }
1059 } else {
1060 printk(KERN_WARNING "CIFS: UNC name too long\n");
1061 return 1;
1062 }
1063 } else if ((strnicmp(data, "domain", 3) == 0)
1064 || (strnicmp(data, "workgroup", 5) == 0)) {
1065 if (!value || !*value) {
1066 printk(KERN_WARNING "CIFS: invalid domain name\n");
1067 return 1; /* needs_arg; */
1068 }
1069 /* BB are there cases in which a comma can be valid in
1070 a domain name and need special handling? */
1071 if (strnlen(value, 256) < 256) {
1072 vol->domainname = value;
1073 cFYI(1, "Domain name set");
1074 } else {
1075 printk(KERN_WARNING "CIFS: domain name too "
1076 "long\n");
1077 return 1;
1078 }
1079 } else if (strnicmp(data, "srcaddr", 7) == 0) {
1080 vol->srcaddr.ss_family = AF_UNSPEC;
1081
1082 if (!value || !*value) {
1083 printk(KERN_WARNING "CIFS: srcaddr value"
1084 " not specified.\n");
1085 return 1; /* needs_arg; */
1086 }
1087 i = cifs_convert_address((struct sockaddr *)&vol->srcaddr,
1088 value, strlen(value));
1089 if (i == 0) {
1090 printk(KERN_WARNING "CIFS: Could not parse"
1091 " srcaddr: %s\n",
1092 value);
1093 return 1;
1094 }
1095 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1096 if (!value || !*value) {
1097 printk(KERN_WARNING
1098 "CIFS: invalid path prefix\n");
1099 return 1; /* needs_argument */
1100 }
1101 if ((temp_len = strnlen(value, 1024)) < 1024) {
1102 if (value[0] != '/')
1103 temp_len++; /* missing leading slash */
1104 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1105 if (vol->prepath == NULL)
1106 return 1;
1107 if (value[0] != '/') {
1108 vol->prepath[0] = '/';
1109 strcpy(vol->prepath+1, value);
1110 } else
1111 strcpy(vol->prepath, value);
1112 cFYI(1, "prefix path %s", vol->prepath);
1113 } else {
1114 printk(KERN_WARNING "CIFS: prefix too long\n");
1115 return 1;
1116 }
1117 } else if (strnicmp(data, "iocharset", 9) == 0) {
1118 if (!value || !*value) {
1119 printk(KERN_WARNING "CIFS: invalid iocharset "
1120 "specified\n");
1121 return 1; /* needs_arg; */
1122 }
1123 if (strnlen(value, 65) < 65) {
1124 if (strnicmp(value, "default", 7))
1125 vol->iocharset = value;
1126 /* if iocharset not set then load_nls_default
1127 is used by caller */
1128 cFYI(1, "iocharset set to %s", value);
1129 } else {
1130 printk(KERN_WARNING "CIFS: iocharset name "
1131 "too long.\n");
1132 return 1;
1133 }
1134 } else if (!strnicmp(data, "uid", 3) && value && *value) {
1135 vol->linux_uid = simple_strtoul(value, &value, 0);
1136 uid_specified = true;
1137 } else if (!strnicmp(data, "cruid", 5) && value && *value) {
1138 vol->cred_uid = simple_strtoul(value, &value, 0);
1139 } else if (!strnicmp(data, "forceuid", 8)) {
1140 override_uid = 1;
1141 } else if (!strnicmp(data, "noforceuid", 10)) {
1142 override_uid = 0;
1143 } else if (!strnicmp(data, "gid", 3) && value && *value) {
1144 vol->linux_gid = simple_strtoul(value, &value, 0);
1145 gid_specified = true;
1146 } else if (!strnicmp(data, "forcegid", 8)) {
1147 override_gid = 1;
1148 } else if (!strnicmp(data, "noforcegid", 10)) {
1149 override_gid = 0;
1150 } else if (strnicmp(data, "file_mode", 4) == 0) {
1151 if (value && *value) {
1152 vol->file_mode =
1153 simple_strtoul(value, &value, 0);
1154 }
1155 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1156 if (value && *value) {
1157 vol->dir_mode =
1158 simple_strtoul(value, &value, 0);
1159 }
1160 } else if (strnicmp(data, "dirmode", 4) == 0) {
1161 if (value && *value) {
1162 vol->dir_mode =
1163 simple_strtoul(value, &value, 0);
1164 }
1165 } else if (strnicmp(data, "port", 4) == 0) {
1166 if (value && *value) {
1167 vol->port =
1168 simple_strtoul(value, &value, 0);
1169 }
1170 } else if (strnicmp(data, "rsize", 5) == 0) {
1171 if (value && *value) {
1172 vol->rsize =
1173 simple_strtoul(value, &value, 0);
1174 }
1175 } else if (strnicmp(data, "wsize", 5) == 0) {
1176 if (value && *value) {
1177 vol->wsize =
1178 simple_strtoul(value, &value, 0);
1179 }
1180 } else if (strnicmp(data, "sockopt", 5) == 0) {
1181 if (!value || !*value) {
1182 cERROR(1, "no socket option specified");
1183 continue;
1184 } else if (strnicmp(value, "TCP_NODELAY", 11) == 0) {
1185 vol->sockopt_tcp_nodelay = 1;
1186 }
1187 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1188 if (!value || !*value || (*value == ' ')) {
1189 cFYI(1, "invalid (empty) netbiosname");
1190 } else {
1191 memset(vol->source_rfc1001_name, 0x20,
1192 RFC1001_NAME_LEN);
1193 /*
1194 * FIXME: are there cases in which a comma can
1195 * be valid in workstation netbios name (and
1196 * need special handling)?
1197 */
1198 for (i = 0; i < RFC1001_NAME_LEN; i++) {
1199 /* don't ucase netbiosname for user */
1200 if (value[i] == 0)
1201 break;
1202 vol->source_rfc1001_name[i] = value[i];
1203 }
1204 /* The string has 16th byte zero still from
1205 set at top of the function */
1206 if (i == RFC1001_NAME_LEN && value[i] != 0)
1207 printk(KERN_WARNING "CIFS: netbiosname"
1208 " longer than 15 truncated.\n");
1209 }
1210 } else if (strnicmp(data, "servern", 7) == 0) {
1211 /* servernetbiosname specified override *SMBSERVER */
1212 if (!value || !*value || (*value == ' ')) {
1213 cFYI(1, "empty server netbiosname specified");
1214 } else {
1215 /* last byte, type, is 0x20 for servr type */
1216 memset(vol->target_rfc1001_name, 0x20,
1217 RFC1001_NAME_LEN_WITH_NULL);
1218
1219 for (i = 0; i < 15; i++) {
1220 /* BB are there cases in which a comma can be
1221 valid in this workstation netbios name
1222 (and need special handling)? */
1223
1224 /* user or mount helper must uppercase
1225 the netbiosname */
1226 if (value[i] == 0)
1227 break;
1228 else
1229 vol->target_rfc1001_name[i] =
1230 value[i];
1231 }
1232 /* The string has 16th byte zero still from
1233 set at top of the function */
1234 if (i == RFC1001_NAME_LEN && value[i] != 0)
1235 printk(KERN_WARNING "CIFS: server net"
1236 "biosname longer than 15 truncated.\n");
1237 }
1238 } else if (strnicmp(data, "actimeo", 7) == 0) {
1239 if (value && *value) {
1240 vol->actimeo = HZ * simple_strtoul(value,
1241 &value, 0);
1242 if (vol->actimeo > CIFS_MAX_ACTIMEO) {
1243 cERROR(1, "CIFS: attribute cache"
1244 "timeout too large");
1245 return 1;
1246 }
1247 }
1248 } else if (strnicmp(data, "credentials", 4) == 0) {
1249 /* ignore */
1250 } else if (strnicmp(data, "version", 3) == 0) {
1251 /* ignore */
1252 } else if (strnicmp(data, "guest", 5) == 0) {
1253 /* ignore */
1254 } else if (strnicmp(data, "rw", 2) == 0) {
1255 /* ignore */
1256 } else if (strnicmp(data, "ro", 2) == 0) {
1257 /* ignore */
1258 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1259 vol->noblocksnd = 1;
1260 } else if (strnicmp(data, "noautotune", 10) == 0) {
1261 vol->noautotune = 1;
1262 } else if ((strnicmp(data, "suid", 4) == 0) ||
1263 (strnicmp(data, "nosuid", 6) == 0) ||
1264 (strnicmp(data, "exec", 4) == 0) ||
1265 (strnicmp(data, "noexec", 6) == 0) ||
1266 (strnicmp(data, "nodev", 5) == 0) ||
1267 (strnicmp(data, "noauto", 6) == 0) ||
1268 (strnicmp(data, "dev", 3) == 0)) {
1269 /* The mount tool or mount.cifs helper (if present)
1270 uses these opts to set flags, and the flags are read
1271 by the kernel vfs layer before we get here (ie
1272 before read super) so there is no point trying to
1273 parse these options again and set anything and it
1274 is ok to just ignore them */
1275 continue;
1276 } else if (strnicmp(data, "hard", 4) == 0) {
1277 vol->retry = 1;
1278 } else if (strnicmp(data, "soft", 4) == 0) {
1279 vol->retry = 0;
1280 } else if (strnicmp(data, "perm", 4) == 0) {
1281 vol->noperm = 0;
1282 } else if (strnicmp(data, "noperm", 6) == 0) {
1283 vol->noperm = 1;
1284 } else if (strnicmp(data, "mapchars", 8) == 0) {
1285 vol->remap = 1;
1286 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1287 vol->remap = 0;
1288 } else if (strnicmp(data, "sfu", 3) == 0) {
1289 vol->sfu_emul = 1;
1290 } else if (strnicmp(data, "nosfu", 5) == 0) {
1291 vol->sfu_emul = 0;
1292 } else if (strnicmp(data, "nodfs", 5) == 0) {
1293 vol->nodfs = 1;
1294 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1295 vol->posix_paths = 1;
1296 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1297 vol->posix_paths = 0;
1298 } else if (strnicmp(data, "nounix", 6) == 0) {
1299 vol->no_linux_ext = 1;
1300 } else if (strnicmp(data, "nolinux", 7) == 0) {
1301 vol->no_linux_ext = 1;
1302 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1303 (strnicmp(data, "ignorecase", 10) == 0)) {
1304 vol->nocase = 1;
1305 } else if (strnicmp(data, "mand", 4) == 0) {
1306 /* ignore */
1307 } else if (strnicmp(data, "nomand", 6) == 0) {
1308 /* ignore */
1309 } else if (strnicmp(data, "_netdev", 7) == 0) {
1310 /* ignore */
1311 } else if (strnicmp(data, "brl", 3) == 0) {
1312 vol->nobrl = 0;
1313 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1314 (strnicmp(data, "nolock", 6) == 0)) {
1315 vol->nobrl = 1;
1316 /* turn off mandatory locking in mode
1317 if remote locking is turned off since the
1318 local vfs will do advisory */
1319 if (vol->file_mode ==
1320 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1321 vol->file_mode = S_IALLUGO;
1322 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1323 /* will take the shorter form "forcemand" as well */
1324 /* This mount option will force use of mandatory
1325 (DOS/Windows style) byte range locks, instead of
1326 using posix advisory byte range locks, even if the
1327 Unix extensions are available and posix locks would
1328 be supported otherwise. If Unix extensions are not
1329 negotiated this has no effect since mandatory locks
1330 would be used (mandatory locks is all that those
1331 those servers support) */
1332 vol->mand_lock = 1;
1333 } else if (strnicmp(data, "setuids", 7) == 0) {
1334 vol->setuids = 1;
1335 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1336 vol->setuids = 0;
1337 } else if (strnicmp(data, "dynperm", 7) == 0) {
1338 vol->dynperm = true;
1339 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1340 vol->dynperm = false;
1341 } else if (strnicmp(data, "nohard", 6) == 0) {
1342 vol->retry = 0;
1343 } else if (strnicmp(data, "nosoft", 6) == 0) {
1344 vol->retry = 1;
1345 } else if (strnicmp(data, "nointr", 6) == 0) {
1346 vol->intr = 0;
1347 } else if (strnicmp(data, "intr", 4) == 0) {
1348 vol->intr = 1;
1349 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1350 vol->nostrictsync = 1;
1351 } else if (strnicmp(data, "strictsync", 10) == 0) {
1352 vol->nostrictsync = 0;
1353 } else if (strnicmp(data, "serverino", 7) == 0) {
1354 vol->server_ino = 1;
1355 } else if (strnicmp(data, "noserverino", 9) == 0) {
1356 vol->server_ino = 0;
1357 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1358 vol->cifs_acl = 1;
1359 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1360 vol->cifs_acl = 0;
1361 } else if (strnicmp(data, "acl", 3) == 0) {
1362 vol->no_psx_acl = 0;
1363 } else if (strnicmp(data, "noacl", 5) == 0) {
1364 vol->no_psx_acl = 1;
1365 } else if (strnicmp(data, "locallease", 6) == 0) {
1366 vol->local_lease = 1;
1367 } else if (strnicmp(data, "sign", 4) == 0) {
1368 vol->secFlg |= CIFSSEC_MUST_SIGN;
1369 } else if (strnicmp(data, "seal", 4) == 0) {
1370 /* we do not do the following in secFlags because seal
1371 is a per tree connection (mount) not a per socket
1372 or per-smb connection option in the protocol */
1373 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1374 vol->seal = 1;
1375 } else if (strnicmp(data, "direct", 6) == 0) {
1376 vol->direct_io = 1;
1377 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1378 vol->direct_io = 1;
1379 } else if (strnicmp(data, "strictcache", 11) == 0) {
1380 vol->strict_io = 1;
1381 } else if (strnicmp(data, "noac", 4) == 0) {
1382 printk(KERN_WARNING "CIFS: Mount option noac not "
1383 "supported. Instead set "
1384 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1385 } else if (strnicmp(data, "fsc", 3) == 0) {
1386 #ifndef CONFIG_CIFS_FSCACHE
1387 cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE"
1388 "kernel config option set");
1389 return 1;
1390 #endif
1391 vol->fsc = true;
1392 } else if (strnicmp(data, "mfsymlinks", 10) == 0) {
1393 vol->mfsymlinks = true;
1394 } else if (strnicmp(data, "multiuser", 8) == 0) {
1395 vol->multiuser = true;
1396 } else
1397 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1398 data);
1399 }
1400 if (vol->UNC == NULL) {
1401 if (devname == NULL) {
1402 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1403 "target\n");
1404 return 1;
1405 }
1406 if ((temp_len = strnlen(devname, 300)) < 300) {
1407 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1408 if (vol->UNC == NULL)
1409 return 1;
1410 strcpy(vol->UNC, devname);
1411 if (strncmp(vol->UNC, "//", 2) == 0) {
1412 vol->UNC[0] = '\\';
1413 vol->UNC[1] = '\\';
1414 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1415 printk(KERN_WARNING "CIFS: UNC Path does not "
1416 "begin with // or \\\\ \n");
1417 return 1;
1418 }
1419 value = strpbrk(vol->UNC+2, "/\\");
1420 if (value)
1421 *value = '\\';
1422 } else {
1423 printk(KERN_WARNING "CIFS: UNC name too long\n");
1424 return 1;
1425 }
1426 }
1427
1428 if (vol->multiuser && !(vol->secFlg & CIFSSEC_MAY_KRB5)) {
1429 cERROR(1, "Multiuser mounts currently require krb5 "
1430 "authentication!");
1431 return 1;
1432 }
1433
1434 if (vol->UNCip == NULL)
1435 vol->UNCip = &vol->UNC[2];
1436
1437 if (uid_specified)
1438 vol->override_uid = override_uid;
1439 else if (override_uid == 1)
1440 printk(KERN_NOTICE "CIFS: ignoring forceuid mount option "
1441 "specified with no uid= option.\n");
1442
1443 if (gid_specified)
1444 vol->override_gid = override_gid;
1445 else if (override_gid == 1)
1446 printk(KERN_NOTICE "CIFS: ignoring forcegid mount option "
1447 "specified with no gid= option.\n");
1448
1449 return 0;
1450 }
1451
1452 /** Returns true if srcaddr isn't specified and rhs isn't
1453 * specified, or if srcaddr is specified and
1454 * matches the IP address of the rhs argument.
1455 */
1456 static bool
1457 srcip_matches(struct sockaddr *srcaddr, struct sockaddr *rhs)
1458 {
1459 switch (srcaddr->sa_family) {
1460 case AF_UNSPEC:
1461 return (rhs->sa_family == AF_UNSPEC);
1462 case AF_INET: {
1463 struct sockaddr_in *saddr4 = (struct sockaddr_in *)srcaddr;
1464 struct sockaddr_in *vaddr4 = (struct sockaddr_in *)rhs;
1465 return (saddr4->sin_addr.s_addr == vaddr4->sin_addr.s_addr);
1466 }
1467 case AF_INET6: {
1468 struct sockaddr_in6 *saddr6 = (struct sockaddr_in6 *)srcaddr;
1469 struct sockaddr_in6 *vaddr6 = (struct sockaddr_in6 *)&rhs;
1470 return ipv6_addr_equal(&saddr6->sin6_addr, &vaddr6->sin6_addr);
1471 }
1472 default:
1473 WARN_ON(1);
1474 return false; /* don't expect to be here */
1475 }
1476 }
1477
1478 /*
1479 * If no port is specified in addr structure, we try to match with 445 port
1480 * and if it fails - with 139 ports. It should be called only if address
1481 * families of server and addr are equal.
1482 */
1483 static bool
1484 match_port(struct TCP_Server_Info *server, struct sockaddr *addr)
1485 {
1486 __be16 port, *sport;
1487
1488 switch (addr->sa_family) {
1489 case AF_INET:
1490 sport = &((struct sockaddr_in *) &server->dstaddr)->sin_port;
1491 port = ((struct sockaddr_in *) addr)->sin_port;
1492 break;
1493 case AF_INET6:
1494 sport = &((struct sockaddr_in6 *) &server->dstaddr)->sin6_port;
1495 port = ((struct sockaddr_in6 *) addr)->sin6_port;
1496 break;
1497 default:
1498 WARN_ON(1);
1499 return false;
1500 }
1501
1502 if (!port) {
1503 port = htons(CIFS_PORT);
1504 if (port == *sport)
1505 return true;
1506
1507 port = htons(RFC1001_PORT);
1508 }
1509
1510 return port == *sport;
1511 }
1512
1513 static bool
1514 match_address(struct TCP_Server_Info *server, struct sockaddr *addr,
1515 struct sockaddr *srcaddr)
1516 {
1517 switch (addr->sa_family) {
1518 case AF_INET: {
1519 struct sockaddr_in *addr4 = (struct sockaddr_in *)addr;
1520 struct sockaddr_in *srv_addr4 =
1521 (struct sockaddr_in *)&server->dstaddr;
1522
1523 if (addr4->sin_addr.s_addr != srv_addr4->sin_addr.s_addr)
1524 return false;
1525 break;
1526 }
1527 case AF_INET6: {
1528 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)addr;
1529 struct sockaddr_in6 *srv_addr6 =
1530 (struct sockaddr_in6 *)&server->dstaddr;
1531
1532 if (!ipv6_addr_equal(&addr6->sin6_addr,
1533 &srv_addr6->sin6_addr))
1534 return false;
1535 if (addr6->sin6_scope_id != srv_addr6->sin6_scope_id)
1536 return false;
1537 break;
1538 }
1539 default:
1540 WARN_ON(1);
1541 return false; /* don't expect to be here */
1542 }
1543
1544 if (!srcip_matches(srcaddr, (struct sockaddr *)&server->srcaddr))
1545 return false;
1546
1547 return true;
1548 }
1549
1550 static bool
1551 match_security(struct TCP_Server_Info *server, struct smb_vol *vol)
1552 {
1553 unsigned int secFlags;
1554
1555 if (vol->secFlg & (~(CIFSSEC_MUST_SIGN | CIFSSEC_MUST_SEAL)))
1556 secFlags = vol->secFlg;
1557 else
1558 secFlags = global_secflags | vol->secFlg;
1559
1560 switch (server->secType) {
1561 case LANMAN:
1562 if (!(secFlags & (CIFSSEC_MAY_LANMAN|CIFSSEC_MAY_PLNTXT)))
1563 return false;
1564 break;
1565 case NTLMv2:
1566 if (!(secFlags & CIFSSEC_MAY_NTLMV2))
1567 return false;
1568 break;
1569 case NTLM:
1570 if (!(secFlags & CIFSSEC_MAY_NTLM))
1571 return false;
1572 break;
1573 case Kerberos:
1574 if (!(secFlags & CIFSSEC_MAY_KRB5))
1575 return false;
1576 break;
1577 case RawNTLMSSP:
1578 if (!(secFlags & CIFSSEC_MAY_NTLMSSP))
1579 return false;
1580 break;
1581 default:
1582 /* shouldn't happen */
1583 return false;
1584 }
1585
1586 /* now check if signing mode is acceptable */
1587 if ((secFlags & CIFSSEC_MAY_SIGN) == 0 &&
1588 (server->secMode & SECMODE_SIGN_REQUIRED))
1589 return false;
1590 else if (((secFlags & CIFSSEC_MUST_SIGN) == CIFSSEC_MUST_SIGN) &&
1591 (server->secMode &
1592 (SECMODE_SIGN_ENABLED|SECMODE_SIGN_REQUIRED)) == 0)
1593 return false;
1594
1595 return true;
1596 }
1597
1598 static struct TCP_Server_Info *
1599 cifs_find_tcp_session(struct sockaddr *addr, struct smb_vol *vol)
1600 {
1601 struct TCP_Server_Info *server;
1602
1603 spin_lock(&cifs_tcp_ses_lock);
1604 list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {
1605 if (!net_eq(cifs_net_ns(server), current->nsproxy->net_ns))
1606 continue;
1607
1608 if (!match_address(server, addr,
1609 (struct sockaddr *)&vol->srcaddr))
1610 continue;
1611
1612 if (!match_port(server, addr))
1613 continue;
1614
1615 if (!match_security(server, vol))
1616 continue;
1617
1618 ++server->srv_count;
1619 spin_unlock(&cifs_tcp_ses_lock);
1620 cFYI(1, "Existing tcp session with server found");
1621 return server;
1622 }
1623 spin_unlock(&cifs_tcp_ses_lock);
1624 return NULL;
1625 }
1626
1627 static void
1628 cifs_put_tcp_session(struct TCP_Server_Info *server)
1629 {
1630 struct task_struct *task;
1631
1632 spin_lock(&cifs_tcp_ses_lock);
1633 if (--server->srv_count > 0) {
1634 spin_unlock(&cifs_tcp_ses_lock);
1635 return;
1636 }
1637
1638 put_net(cifs_net_ns(server));
1639
1640 list_del_init(&server->tcp_ses_list);
1641 spin_unlock(&cifs_tcp_ses_lock);
1642
1643 cancel_delayed_work_sync(&server->echo);
1644
1645 spin_lock(&GlobalMid_Lock);
1646 server->tcpStatus = CifsExiting;
1647 spin_unlock(&GlobalMid_Lock);
1648
1649 cifs_crypto_shash_release(server);
1650 cifs_fscache_release_client_cookie(server);
1651
1652 kfree(server->session_key.response);
1653 server->session_key.response = NULL;
1654 server->session_key.len = 0;
1655
1656 task = xchg(&server->tsk, NULL);
1657 if (task)
1658 force_sig(SIGKILL, task);
1659 }
1660
1661 static struct TCP_Server_Info *
1662 cifs_get_tcp_session(struct smb_vol *volume_info)
1663 {
1664 struct TCP_Server_Info *tcp_ses = NULL;
1665 struct sockaddr_storage addr;
1666 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1667 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1668 int rc;
1669
1670 memset(&addr, 0, sizeof(struct sockaddr_storage));
1671
1672 cFYI(1, "UNC: %s ip: %s", volume_info->UNC, volume_info->UNCip);
1673
1674 if (volume_info->UNCip && volume_info->UNC) {
1675 rc = cifs_fill_sockaddr((struct sockaddr *)&addr,
1676 volume_info->UNCip,
1677 strlen(volume_info->UNCip),
1678 volume_info->port);
1679 if (!rc) {
1680 /* we failed translating address */
1681 rc = -EINVAL;
1682 goto out_err;
1683 }
1684 } else if (volume_info->UNCip) {
1685 /* BB using ip addr as tcp_ses name to connect to the
1686 DFS root below */
1687 cERROR(1, "Connecting to DFS root not implemented yet");
1688 rc = -EINVAL;
1689 goto out_err;
1690 } else /* which tcp_sess DFS root would we conect to */ {
1691 cERROR(1, "CIFS mount error: No UNC path (e.g. -o "
1692 "unc=//192.168.1.100/public) specified");
1693 rc = -EINVAL;
1694 goto out_err;
1695 }
1696
1697 /* see if we already have a matching tcp_ses */
1698 tcp_ses = cifs_find_tcp_session((struct sockaddr *)&addr, volume_info);
1699 if (tcp_ses)
1700 return tcp_ses;
1701
1702 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1703 if (!tcp_ses) {
1704 rc = -ENOMEM;
1705 goto out_err;
1706 }
1707
1708 rc = cifs_crypto_shash_allocate(tcp_ses);
1709 if (rc) {
1710 cERROR(1, "could not setup hash structures rc %d", rc);
1711 goto out_err;
1712 }
1713
1714 cifs_set_net_ns(tcp_ses, get_net(current->nsproxy->net_ns));
1715 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1716 if (IS_ERR(tcp_ses->hostname)) {
1717 rc = PTR_ERR(tcp_ses->hostname);
1718 goto out_err_crypto_release;
1719 }
1720
1721 tcp_ses->noblocksnd = volume_info->noblocksnd;
1722 tcp_ses->noautotune = volume_info->noautotune;
1723 tcp_ses->tcp_nodelay = volume_info->sockopt_tcp_nodelay;
1724 atomic_set(&tcp_ses->inFlight, 0);
1725 init_waitqueue_head(&tcp_ses->response_q);
1726 init_waitqueue_head(&tcp_ses->request_q);
1727 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1728 mutex_init(&tcp_ses->srv_mutex);
1729 memcpy(tcp_ses->workstation_RFC1001_name,
1730 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1731 memcpy(tcp_ses->server_RFC1001_name,
1732 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1733 tcp_ses->session_estab = false;
1734 tcp_ses->sequence_number = 0;
1735 tcp_ses->lstrp = jiffies;
1736 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1737 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1738 INIT_DELAYED_WORK(&tcp_ses->echo, cifs_echo_request);
1739
1740 /*
1741 * at this point we are the only ones with the pointer
1742 * to the struct since the kernel thread not created yet
1743 * no need to spinlock this init of tcpStatus or srv_count
1744 */
1745 tcp_ses->tcpStatus = CifsNew;
1746 memcpy(&tcp_ses->srcaddr, &volume_info->srcaddr,
1747 sizeof(tcp_ses->srcaddr));
1748 ++tcp_ses->srv_count;
1749
1750 if (addr.ss_family == AF_INET6) {
1751 cFYI(1, "attempting ipv6 connect");
1752 /* BB should we allow ipv6 on port 139? */
1753 /* other OS never observed in Wild doing 139 with v6 */
1754 memcpy(&tcp_ses->dstaddr, sin_server6,
1755 sizeof(struct sockaddr_in6));
1756 } else
1757 memcpy(&tcp_ses->dstaddr, sin_server,
1758 sizeof(struct sockaddr_in));
1759
1760 rc = ip_connect(tcp_ses);
1761 if (rc < 0) {
1762 cERROR(1, "Error connecting to socket. Aborting operation");
1763 goto out_err_crypto_release;
1764 }
1765
1766 /*
1767 * since we're in a cifs function already, we know that
1768 * this will succeed. No need for try_module_get().
1769 */
1770 __module_get(THIS_MODULE);
1771 tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1772 tcp_ses, "cifsd");
1773 if (IS_ERR(tcp_ses->tsk)) {
1774 rc = PTR_ERR(tcp_ses->tsk);
1775 cERROR(1, "error %d create cifsd thread", rc);
1776 module_put(THIS_MODULE);
1777 goto out_err_crypto_release;
1778 }
1779 tcp_ses->tcpStatus = CifsNeedNegotiate;
1780
1781 /* thread spawned, put it on the list */
1782 spin_lock(&cifs_tcp_ses_lock);
1783 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1784 spin_unlock(&cifs_tcp_ses_lock);
1785
1786 cifs_fscache_get_client_cookie(tcp_ses);
1787
1788 /* queue echo request delayed work */
1789 queue_delayed_work(system_nrt_wq, &tcp_ses->echo, SMB_ECHO_INTERVAL);
1790
1791 return tcp_ses;
1792
1793 out_err_crypto_release:
1794 cifs_crypto_shash_release(tcp_ses);
1795
1796 put_net(cifs_net_ns(tcp_ses));
1797
1798 out_err:
1799 if (tcp_ses) {
1800 if (!IS_ERR(tcp_ses->hostname))
1801 kfree(tcp_ses->hostname);
1802 if (tcp_ses->ssocket)
1803 sock_release(tcp_ses->ssocket);
1804 kfree(tcp_ses);
1805 }
1806 return ERR_PTR(rc);
1807 }
1808
1809 static struct cifsSesInfo *
1810 cifs_find_smb_ses(struct TCP_Server_Info *server, struct smb_vol *vol)
1811 {
1812 struct cifsSesInfo *ses;
1813
1814 spin_lock(&cifs_tcp_ses_lock);
1815 list_for_each_entry(ses, &server->smb_ses_list, smb_ses_list) {
1816 switch (server->secType) {
1817 case Kerberos:
1818 if (vol->cred_uid != ses->cred_uid)
1819 continue;
1820 break;
1821 default:
1822 /* anything else takes username/password */
1823 if (ses->user_name == NULL)
1824 continue;
1825 if (strncmp(ses->user_name, vol->username,
1826 MAX_USERNAME_SIZE))
1827 continue;
1828 if (strlen(vol->username) != 0 &&
1829 ses->password != NULL &&
1830 strncmp(ses->password,
1831 vol->password ? vol->password : "",
1832 MAX_PASSWORD_SIZE))
1833 continue;
1834 }
1835 ++ses->ses_count;
1836 spin_unlock(&cifs_tcp_ses_lock);
1837 return ses;
1838 }
1839 spin_unlock(&cifs_tcp_ses_lock);
1840 return NULL;
1841 }
1842
1843 static void
1844 cifs_put_smb_ses(struct cifsSesInfo *ses)
1845 {
1846 int xid;
1847 struct TCP_Server_Info *server = ses->server;
1848
1849 cFYI(1, "%s: ses_count=%d\n", __func__, ses->ses_count);
1850 spin_lock(&cifs_tcp_ses_lock);
1851 if (--ses->ses_count > 0) {
1852 spin_unlock(&cifs_tcp_ses_lock);
1853 return;
1854 }
1855
1856 list_del_init(&ses->smb_ses_list);
1857 spin_unlock(&cifs_tcp_ses_lock);
1858
1859 if (ses->status == CifsGood) {
1860 xid = GetXid();
1861 CIFSSMBLogoff(xid, ses);
1862 _FreeXid(xid);
1863 }
1864 sesInfoFree(ses);
1865 cifs_put_tcp_session(server);
1866 }
1867
1868 static bool warned_on_ntlm; /* globals init to false automatically */
1869
1870 static struct cifsSesInfo *
1871 cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
1872 {
1873 int rc = -ENOMEM, xid;
1874 struct cifsSesInfo *ses;
1875 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
1876 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
1877
1878 xid = GetXid();
1879
1880 ses = cifs_find_smb_ses(server, volume_info);
1881 if (ses) {
1882 cFYI(1, "Existing smb sess found (status=%d)", ses->status);
1883
1884 mutex_lock(&ses->session_mutex);
1885 rc = cifs_negotiate_protocol(xid, ses);
1886 if (rc) {
1887 mutex_unlock(&ses->session_mutex);
1888 /* problem -- put our ses reference */
1889 cifs_put_smb_ses(ses);
1890 FreeXid(xid);
1891 return ERR_PTR(rc);
1892 }
1893 if (ses->need_reconnect) {
1894 cFYI(1, "Session needs reconnect");
1895 rc = cifs_setup_session(xid, ses,
1896 volume_info->local_nls);
1897 if (rc) {
1898 mutex_unlock(&ses->session_mutex);
1899 /* problem -- put our reference */
1900 cifs_put_smb_ses(ses);
1901 FreeXid(xid);
1902 return ERR_PTR(rc);
1903 }
1904 }
1905 mutex_unlock(&ses->session_mutex);
1906
1907 /* existing SMB ses has a server reference already */
1908 cifs_put_tcp_session(server);
1909 FreeXid(xid);
1910 return ses;
1911 }
1912
1913 cFYI(1, "Existing smb sess not found");
1914 ses = sesInfoAlloc();
1915 if (ses == NULL)
1916 goto get_ses_fail;
1917
1918 /* new SMB session uses our server ref */
1919 ses->server = server;
1920 if (server->dstaddr.ss_family == AF_INET6)
1921 sprintf(ses->serverName, "%pI6", &addr6->sin6_addr);
1922 else
1923 sprintf(ses->serverName, "%pI4", &addr->sin_addr);
1924
1925 if (volume_info->username) {
1926 ses->user_name = kstrdup(volume_info->username, GFP_KERNEL);
1927 if (!ses->user_name)
1928 goto get_ses_fail;
1929 }
1930
1931 /* volume_info->password freed at unmount */
1932 if (volume_info->password) {
1933 ses->password = kstrdup(volume_info->password, GFP_KERNEL);
1934 if (!ses->password)
1935 goto get_ses_fail;
1936 }
1937 if (volume_info->domainname) {
1938 ses->domainName = kstrdup(volume_info->domainname, GFP_KERNEL);
1939 if (!ses->domainName)
1940 goto get_ses_fail;
1941 }
1942 ses->cred_uid = volume_info->cred_uid;
1943 ses->linux_uid = volume_info->linux_uid;
1944
1945 /* ntlmv2 is much stronger than ntlm security, and has been broadly
1946 supported for many years, time to update default security mechanism */
1947 if ((volume_info->secFlg == 0) && warned_on_ntlm == false) {
1948 warned_on_ntlm = true;
1949 cERROR(1, "default security mechanism requested. The default "
1950 "security mechanism will be upgraded from ntlm to "
1951 "ntlmv2 in kernel release 2.6.41");
1952 }
1953 ses->overrideSecFlg = volume_info->secFlg;
1954
1955 mutex_lock(&ses->session_mutex);
1956 rc = cifs_negotiate_protocol(xid, ses);
1957 if (!rc)
1958 rc = cifs_setup_session(xid, ses, volume_info->local_nls);
1959 mutex_unlock(&ses->session_mutex);
1960 if (rc)
1961 goto get_ses_fail;
1962
1963 /* success, put it on the list */
1964 spin_lock(&cifs_tcp_ses_lock);
1965 list_add(&ses->smb_ses_list, &server->smb_ses_list);
1966 spin_unlock(&cifs_tcp_ses_lock);
1967
1968 FreeXid(xid);
1969 return ses;
1970
1971 get_ses_fail:
1972 sesInfoFree(ses);
1973 FreeXid(xid);
1974 return ERR_PTR(rc);
1975 }
1976
1977 static struct cifsTconInfo *
1978 cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
1979 {
1980 struct list_head *tmp;
1981 struct cifsTconInfo *tcon;
1982
1983 spin_lock(&cifs_tcp_ses_lock);
1984 list_for_each(tmp, &ses->tcon_list) {
1985 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1986 if (tcon->tidStatus == CifsExiting)
1987 continue;
1988 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
1989 continue;
1990
1991 ++tcon->tc_count;
1992 spin_unlock(&cifs_tcp_ses_lock);
1993 return tcon;
1994 }
1995 spin_unlock(&cifs_tcp_ses_lock);
1996 return NULL;
1997 }
1998
1999 static void
2000 cifs_put_tcon(struct cifsTconInfo *tcon)
2001 {
2002 int xid;
2003 struct cifsSesInfo *ses = tcon->ses;
2004
2005 cFYI(1, "%s: tc_count=%d\n", __func__, tcon->tc_count);
2006 spin_lock(&cifs_tcp_ses_lock);
2007 if (--tcon->tc_count > 0) {
2008 spin_unlock(&cifs_tcp_ses_lock);
2009 return;
2010 }
2011
2012 list_del_init(&tcon->tcon_list);
2013 spin_unlock(&cifs_tcp_ses_lock);
2014
2015 xid = GetXid();
2016 CIFSSMBTDis(xid, tcon);
2017 _FreeXid(xid);
2018
2019 cifs_fscache_release_super_cookie(tcon);
2020 tconInfoFree(tcon);
2021 cifs_put_smb_ses(ses);
2022 }
2023
2024 static struct cifsTconInfo *
2025 cifs_get_tcon(struct cifsSesInfo *ses, struct smb_vol *volume_info)
2026 {
2027 int rc, xid;
2028 struct cifsTconInfo *tcon;
2029
2030 tcon = cifs_find_tcon(ses, volume_info->UNC);
2031 if (tcon) {
2032 cFYI(1, "Found match on UNC path");
2033 /* existing tcon already has a reference */
2034 cifs_put_smb_ses(ses);
2035 if (tcon->seal != volume_info->seal)
2036 cERROR(1, "transport encryption setting "
2037 "conflicts with existing tid");
2038 return tcon;
2039 }
2040
2041 tcon = tconInfoAlloc();
2042 if (tcon == NULL) {
2043 rc = -ENOMEM;
2044 goto out_fail;
2045 }
2046
2047 tcon->ses = ses;
2048 if (volume_info->password) {
2049 tcon->password = kstrdup(volume_info->password, GFP_KERNEL);
2050 if (!tcon->password) {
2051 rc = -ENOMEM;
2052 goto out_fail;
2053 }
2054 }
2055
2056 if (strchr(volume_info->UNC + 3, '\\') == NULL
2057 && strchr(volume_info->UNC + 3, '/') == NULL) {
2058 cERROR(1, "Missing share name");
2059 rc = -ENODEV;
2060 goto out_fail;
2061 }
2062
2063 /* BB Do we need to wrap session_mutex around
2064 * this TCon call and Unix SetFS as
2065 * we do on SessSetup and reconnect? */
2066 xid = GetXid();
2067 rc = CIFSTCon(xid, ses, volume_info->UNC, tcon, volume_info->local_nls);
2068 FreeXid(xid);
2069 cFYI(1, "CIFS Tcon rc = %d", rc);
2070 if (rc)
2071 goto out_fail;
2072
2073 if (volume_info->nodfs) {
2074 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2075 cFYI(1, "DFS disabled (%d)", tcon->Flags);
2076 }
2077 tcon->seal = volume_info->seal;
2078 /* we can have only one retry value for a connection
2079 to a share so for resources mounted more than once
2080 to the same server share the last value passed in
2081 for the retry flag is used */
2082 tcon->retry = volume_info->retry;
2083 tcon->nocase = volume_info->nocase;
2084 tcon->local_lease = volume_info->local_lease;
2085
2086 spin_lock(&cifs_tcp_ses_lock);
2087 list_add(&tcon->tcon_list, &ses->tcon_list);
2088 spin_unlock(&cifs_tcp_ses_lock);
2089
2090 cifs_fscache_get_super_cookie(tcon);
2091
2092 return tcon;
2093
2094 out_fail:
2095 tconInfoFree(tcon);
2096 return ERR_PTR(rc);
2097 }
2098
2099 void
2100 cifs_put_tlink(struct tcon_link *tlink)
2101 {
2102 if (!tlink || IS_ERR(tlink))
2103 return;
2104
2105 if (!atomic_dec_and_test(&tlink->tl_count) ||
2106 test_bit(TCON_LINK_IN_TREE, &tlink->tl_flags)) {
2107 tlink->tl_time = jiffies;
2108 return;
2109 }
2110
2111 if (!IS_ERR(tlink_tcon(tlink)))
2112 cifs_put_tcon(tlink_tcon(tlink));
2113 kfree(tlink);
2114 return;
2115 }
2116
2117 int
2118 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
2119 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
2120 struct dfs_info3_param **preferrals, int remap)
2121 {
2122 char *temp_unc;
2123 int rc = 0;
2124
2125 *pnum_referrals = 0;
2126 *preferrals = NULL;
2127
2128 if (pSesInfo->ipc_tid == 0) {
2129 temp_unc = kmalloc(2 /* for slashes */ +
2130 strnlen(pSesInfo->serverName,
2131 SERVER_NAME_LEN_WITH_NULL * 2)
2132 + 1 + 4 /* slash IPC$ */ + 2,
2133 GFP_KERNEL);
2134 if (temp_unc == NULL)
2135 return -ENOMEM;
2136 temp_unc[0] = '\\';
2137 temp_unc[1] = '\\';
2138 strcpy(temp_unc + 2, pSesInfo->serverName);
2139 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
2140 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
2141 cFYI(1, "CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid);
2142 kfree(temp_unc);
2143 }
2144 if (rc == 0)
2145 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
2146 pnum_referrals, nls_codepage, remap);
2147 /* BB map targetUNCs to dfs_info3 structures, here or
2148 in CIFSGetDFSRefer BB */
2149
2150 return rc;
2151 }
2152
2153 #ifdef CONFIG_DEBUG_LOCK_ALLOC
2154 static struct lock_class_key cifs_key[2];
2155 static struct lock_class_key cifs_slock_key[2];
2156
2157 static inline void
2158 cifs_reclassify_socket4(struct socket *sock)
2159 {
2160 struct sock *sk = sock->sk;
2161 BUG_ON(sock_owned_by_user(sk));
2162 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
2163 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
2164 }
2165
2166 static inline void
2167 cifs_reclassify_socket6(struct socket *sock)
2168 {
2169 struct sock *sk = sock->sk;
2170 BUG_ON(sock_owned_by_user(sk));
2171 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
2172 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
2173 }
2174 #else
2175 static inline void
2176 cifs_reclassify_socket4(struct socket *sock)
2177 {
2178 }
2179
2180 static inline void
2181 cifs_reclassify_socket6(struct socket *sock)
2182 {
2183 }
2184 #endif
2185
2186 /* See RFC1001 section 14 on representation of Netbios names */
2187 static void rfc1002mangle(char *target, char *source, unsigned int length)
2188 {
2189 unsigned int i, j;
2190
2191 for (i = 0, j = 0; i < (length); i++) {
2192 /* mask a nibble at a time and encode */
2193 target[j] = 'A' + (0x0F & (source[i] >> 4));
2194 target[j+1] = 'A' + (0x0F & source[i]);
2195 j += 2;
2196 }
2197
2198 }
2199
2200 static int
2201 bind_socket(struct TCP_Server_Info *server)
2202 {
2203 int rc = 0;
2204 if (server->srcaddr.ss_family != AF_UNSPEC) {
2205 /* Bind to the specified local IP address */
2206 struct socket *socket = server->ssocket;
2207 rc = socket->ops->bind(socket,
2208 (struct sockaddr *) &server->srcaddr,
2209 sizeof(server->srcaddr));
2210 if (rc < 0) {
2211 struct sockaddr_in *saddr4;
2212 struct sockaddr_in6 *saddr6;
2213 saddr4 = (struct sockaddr_in *)&server->srcaddr;
2214 saddr6 = (struct sockaddr_in6 *)&server->srcaddr;
2215 if (saddr6->sin6_family == AF_INET6)
2216 cERROR(1, "cifs: "
2217 "Failed to bind to: %pI6c, error: %d\n",
2218 &saddr6->sin6_addr, rc);
2219 else
2220 cERROR(1, "cifs: "
2221 "Failed to bind to: %pI4, error: %d\n",
2222 &saddr4->sin_addr.s_addr, rc);
2223 }
2224 }
2225 return rc;
2226 }
2227
2228 static int
2229 ip_rfc1001_connect(struct TCP_Server_Info *server)
2230 {
2231 int rc = 0;
2232 /*
2233 * some servers require RFC1001 sessinit before sending
2234 * negprot - BB check reconnection in case where second
2235 * sessinit is sent but no second negprot
2236 */
2237 struct rfc1002_session_packet *ses_init_buf;
2238 struct smb_hdr *smb_buf;
2239 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
2240 GFP_KERNEL);
2241 if (ses_init_buf) {
2242 ses_init_buf->trailer.session_req.called_len = 32;
2243
2244 if (server->server_RFC1001_name &&
2245 server->server_RFC1001_name[0] != 0)
2246 rfc1002mangle(ses_init_buf->trailer.
2247 session_req.called_name,
2248 server->server_RFC1001_name,
2249 RFC1001_NAME_LEN_WITH_NULL);
2250 else
2251 rfc1002mangle(ses_init_buf->trailer.
2252 session_req.called_name,
2253 DEFAULT_CIFS_CALLED_NAME,
2254 RFC1001_NAME_LEN_WITH_NULL);
2255
2256 ses_init_buf->trailer.session_req.calling_len = 32;
2257
2258 /*
2259 * calling name ends in null (byte 16) from old smb
2260 * convention.
2261 */
2262 if (server->workstation_RFC1001_name &&
2263 server->workstation_RFC1001_name[0] != 0)
2264 rfc1002mangle(ses_init_buf->trailer.
2265 session_req.calling_name,
2266 server->workstation_RFC1001_name,
2267 RFC1001_NAME_LEN_WITH_NULL);
2268 else
2269 rfc1002mangle(ses_init_buf->trailer.
2270 session_req.calling_name,
2271 "LINUX_CIFS_CLNT",
2272 RFC1001_NAME_LEN_WITH_NULL);
2273
2274 ses_init_buf->trailer.session_req.scope1 = 0;
2275 ses_init_buf->trailer.session_req.scope2 = 0;
2276 smb_buf = (struct smb_hdr *)ses_init_buf;
2277
2278 /* sizeof RFC1002_SESSION_REQUEST with no scope */
2279 smb_buf->smb_buf_length = 0x81000044;
2280 rc = smb_send(server, smb_buf, 0x44);
2281 kfree(ses_init_buf);
2282 /*
2283 * RFC1001 layer in at least one server
2284 * requires very short break before negprot
2285 * presumably because not expecting negprot
2286 * to follow so fast. This is a simple
2287 * solution that works without
2288 * complicating the code and causes no
2289 * significant slowing down on mount
2290 * for everyone else
2291 */
2292 usleep_range(1000, 2000);
2293 }
2294 /*
2295 * else the negprot may still work without this
2296 * even though malloc failed
2297 */
2298
2299 return rc;
2300 }
2301
2302 static int
2303 generic_ip_connect(struct TCP_Server_Info *server)
2304 {
2305 int rc = 0;
2306 __be16 sport;
2307 int slen, sfamily;
2308 struct socket *socket = server->ssocket;
2309 struct sockaddr *saddr;
2310
2311 saddr = (struct sockaddr *) &server->dstaddr;
2312
2313 if (server->dstaddr.ss_family == AF_INET6) {
2314 sport = ((struct sockaddr_in6 *) saddr)->sin6_port;
2315 slen = sizeof(struct sockaddr_in6);
2316 sfamily = AF_INET6;
2317 } else {
2318 sport = ((struct sockaddr_in *) saddr)->sin_port;
2319 slen = sizeof(struct sockaddr_in);
2320 sfamily = AF_INET;
2321 }
2322
2323 if (socket == NULL) {
2324 rc = __sock_create(cifs_net_ns(server), sfamily, SOCK_STREAM,
2325 IPPROTO_TCP, &socket, 1);
2326 if (rc < 0) {
2327 cERROR(1, "Error %d creating socket", rc);
2328 server->ssocket = NULL;
2329 return rc;
2330 }
2331
2332 /* BB other socket options to set KEEPALIVE, NODELAY? */
2333 cFYI(1, "Socket created");
2334 server->ssocket = socket;
2335 socket->sk->sk_allocation = GFP_NOFS;
2336 if (sfamily == AF_INET6)
2337 cifs_reclassify_socket6(socket);
2338 else
2339 cifs_reclassify_socket4(socket);
2340 }
2341
2342 rc = bind_socket(server);
2343 if (rc < 0)
2344 return rc;
2345
2346 rc = socket->ops->connect(socket, saddr, slen, 0);
2347 if (rc < 0) {
2348 cFYI(1, "Error %d connecting to server", rc);
2349 sock_release(socket);
2350 server->ssocket = NULL;
2351 return rc;
2352 }
2353
2354 /*
2355 * Eventually check for other socket options to change from
2356 * the default. sock_setsockopt not used because it expects
2357 * user space buffer
2358 */
2359 socket->sk->sk_rcvtimeo = 7 * HZ;
2360 socket->sk->sk_sndtimeo = 5 * HZ;
2361
2362 /* make the bufsizes depend on wsize/rsize and max requests */
2363 if (server->noautotune) {
2364 if (socket->sk->sk_sndbuf < (200 * 1024))
2365 socket->sk->sk_sndbuf = 200 * 1024;
2366 if (socket->sk->sk_rcvbuf < (140 * 1024))
2367 socket->sk->sk_rcvbuf = 140 * 1024;
2368 }
2369
2370 if (server->tcp_nodelay) {
2371 int val = 1;
2372 rc = kernel_setsockopt(socket, SOL_TCP, TCP_NODELAY,
2373 (char *)&val, sizeof(val));
2374 if (rc)
2375 cFYI(1, "set TCP_NODELAY socket option error %d", rc);
2376 }
2377
2378 cFYI(1, "sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
2379 socket->sk->sk_sndbuf,
2380 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo);
2381
2382 if (sport == htons(RFC1001_PORT))
2383 rc = ip_rfc1001_connect(server);
2384
2385 return rc;
2386 }
2387
2388 static int
2389 ip_connect(struct TCP_Server_Info *server)
2390 {
2391 __be16 *sport;
2392 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&server->dstaddr;
2393 struct sockaddr_in *addr = (struct sockaddr_in *)&server->dstaddr;
2394
2395 if (server->dstaddr.ss_family == AF_INET6)
2396 sport = &addr6->sin6_port;
2397 else
2398 sport = &addr->sin_port;
2399
2400 if (*sport == 0) {
2401 int rc;
2402
2403 /* try with 445 port at first */
2404 *sport = htons(CIFS_PORT);
2405
2406 rc = generic_ip_connect(server);
2407 if (rc >= 0)
2408 return rc;
2409
2410 /* if it failed, try with 139 port */
2411 *sport = htons(RFC1001_PORT);
2412 }
2413
2414 return generic_ip_connect(server);
2415 }
2416
2417 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
2418 struct super_block *sb, struct smb_vol *vol_info)
2419 {
2420 /* if we are reconnecting then should we check to see if
2421 * any requested capabilities changed locally e.g. via
2422 * remount but we can not do much about it here
2423 * if they have (even if we could detect it by the following)
2424 * Perhaps we could add a backpointer to array of sb from tcon
2425 * or if we change to make all sb to same share the same
2426 * sb as NFS - then we only have one backpointer to sb.
2427 * What if we wanted to mount the server share twice once with
2428 * and once without posixacls or posix paths? */
2429 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2430
2431 if (vol_info && vol_info->no_linux_ext) {
2432 tcon->fsUnixInfo.Capability = 0;
2433 tcon->unix_ext = 0; /* Unix Extensions disabled */
2434 cFYI(1, "Linux protocol extensions disabled");
2435 return;
2436 } else if (vol_info)
2437 tcon->unix_ext = 1; /* Unix Extensions supported */
2438
2439 if (tcon->unix_ext == 0) {
2440 cFYI(1, "Unix extensions disabled so not set on reconnect");
2441 return;
2442 }
2443
2444 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2445 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2446
2447 /* check for reconnect case in which we do not
2448 want to change the mount behavior if we can avoid it */
2449 if (vol_info == NULL) {
2450 /* turn off POSIX ACL and PATHNAMES if not set
2451 originally at mount time */
2452 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2453 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2454 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2455 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2456 cERROR(1, "POSIXPATH support change");
2457 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2458 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2459 cERROR(1, "possible reconnect error");
2460 cERROR(1, "server disabled POSIX path support");
2461 }
2462 }
2463
2464 cap &= CIFS_UNIX_CAP_MASK;
2465 if (vol_info && vol_info->no_psx_acl)
2466 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2467 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2468 cFYI(1, "negotiated posix acl support");
2469 if (sb)
2470 sb->s_flags |= MS_POSIXACL;
2471 }
2472
2473 if (vol_info && vol_info->posix_paths == 0)
2474 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2475 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2476 cFYI(1, "negotiate posix pathnames");
2477 if (sb)
2478 CIFS_SB(sb)->mnt_cifs_flags |=
2479 CIFS_MOUNT_POSIX_PATHS;
2480 }
2481
2482 /* We might be setting the path sep back to a different
2483 form if we are reconnecting and the server switched its
2484 posix path capability for this share */
2485 if (sb && (CIFS_SB(sb)->prepathlen > 0))
2486 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
2487
2488 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2489 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2490 CIFS_SB(sb)->rsize = 127 * 1024;
2491 cFYI(DBG2, "larger reads not supported by srv");
2492 }
2493 }
2494
2495
2496 cFYI(1, "Negotiate caps 0x%x", (int)cap);
2497 #ifdef CONFIG_CIFS_DEBUG2
2498 if (cap & CIFS_UNIX_FCNTL_CAP)
2499 cFYI(1, "FCNTL cap");
2500 if (cap & CIFS_UNIX_EXTATTR_CAP)
2501 cFYI(1, "EXTATTR cap");
2502 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2503 cFYI(1, "POSIX path cap");
2504 if (cap & CIFS_UNIX_XATTR_CAP)
2505 cFYI(1, "XATTR cap");
2506 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2507 cFYI(1, "POSIX ACL cap");
2508 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2509 cFYI(1, "very large read cap");
2510 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2511 cFYI(1, "very large write cap");
2512 #endif /* CIFS_DEBUG2 */
2513 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2514 if (vol_info == NULL) {
2515 cFYI(1, "resetting capabilities failed");
2516 } else
2517 cERROR(1, "Negotiating Unix capabilities "
2518 "with the server failed. Consider "
2519 "mounting with the Unix Extensions\n"
2520 "disabled, if problems are found, "
2521 "by specifying the nounix mount "
2522 "option.");
2523
2524 }
2525 }
2526 }
2527
2528 static void
2529 convert_delimiter(char *path, char delim)
2530 {
2531 int i;
2532 char old_delim;
2533
2534 if (path == NULL)
2535 return;
2536
2537 if (delim == '/')
2538 old_delim = '\\';
2539 else
2540 old_delim = '/';
2541
2542 for (i = 0; path[i] != '\0'; i++) {
2543 if (path[i] == old_delim)
2544 path[i] = delim;
2545 }
2546 }
2547
2548 static void setup_cifs_sb(struct smb_vol *pvolume_info,
2549 struct cifs_sb_info *cifs_sb)
2550 {
2551 INIT_DELAYED_WORK(&cifs_sb->prune_tlinks, cifs_prune_tlinks);
2552
2553 if (pvolume_info->rsize > CIFSMaxBufSize) {
2554 cERROR(1, "rsize %d too large, using MaxBufSize",
2555 pvolume_info->rsize);
2556 cifs_sb->rsize = CIFSMaxBufSize;
2557 } else if ((pvolume_info->rsize) &&
2558 (pvolume_info->rsize <= CIFSMaxBufSize))
2559 cifs_sb->rsize = pvolume_info->rsize;
2560 else /* default */
2561 cifs_sb->rsize = CIFSMaxBufSize;
2562
2563 if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2564 cERROR(1, "wsize %d too large, using 4096 instead",
2565 pvolume_info->wsize);
2566 cifs_sb->wsize = 4096;
2567 } else if (pvolume_info->wsize)
2568 cifs_sb->wsize = pvolume_info->wsize;
2569 else
2570 cifs_sb->wsize = min_t(const int,
2571 PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2572 127*1024);
2573 /* old default of CIFSMaxBufSize was too small now
2574 that SMB Write2 can send multiple pages in kvec.
2575 RFC1001 does not describe what happens when frame
2576 bigger than 128K is sent so use that as max in
2577 conjunction with 52K kvec constraint on arch with 4K
2578 page size */
2579
2580 if (cifs_sb->rsize < 2048) {
2581 cifs_sb->rsize = 2048;
2582 /* Windows ME may prefer this */
2583 cFYI(1, "readsize set to minimum: 2048");
2584 }
2585 /* calculate prepath */
2586 cifs_sb->prepath = pvolume_info->prepath;
2587 if (cifs_sb->prepath) {
2588 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2589 /* we can not convert the / to \ in the path
2590 separators in the prefixpath yet because we do not
2591 know (until reset_cifs_unix_caps is called later)
2592 whether POSIX PATH CAP is available. We normalize
2593 the / to \ after reset_cifs_unix_caps is called */
2594 pvolume_info->prepath = NULL;
2595 } else
2596 cifs_sb->prepathlen = 0;
2597 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2598 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2599 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2600 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2601 cFYI(1, "file mode: 0x%x dir mode: 0x%x",
2602 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode);
2603
2604 cifs_sb->actimeo = pvolume_info->actimeo;
2605
2606 if (pvolume_info->noperm)
2607 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2608 if (pvolume_info->setuids)
2609 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2610 if (pvolume_info->server_ino)
2611 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2612 if (pvolume_info->remap)
2613 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2614 if (pvolume_info->no_xattr)
2615 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2616 if (pvolume_info->sfu_emul)
2617 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2618 if (pvolume_info->nobrl)
2619 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2620 if (pvolume_info->nostrictsync)
2621 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2622 if (pvolume_info->mand_lock)
2623 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2624 if (pvolume_info->cifs_acl)
2625 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2626 if (pvolume_info->override_uid)
2627 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2628 if (pvolume_info->override_gid)
2629 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2630 if (pvolume_info->dynperm)
2631 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2632 if (pvolume_info->fsc)
2633 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_FSCACHE;
2634 if (pvolume_info->multiuser)
2635 cifs_sb->mnt_cifs_flags |= (CIFS_MOUNT_MULTIUSER |
2636 CIFS_MOUNT_NO_PERM);
2637 if (pvolume_info->strict_io)
2638 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_STRICT_IO;
2639 if (pvolume_info->direct_io) {
2640 cFYI(1, "mounting share using direct i/o");
2641 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2642 }
2643 if (pvolume_info->mfsymlinks) {
2644 if (pvolume_info->sfu_emul) {
2645 cERROR(1, "mount option mfsymlinks ignored if sfu "
2646 "mount option is used");
2647 } else {
2648 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MF_SYMLINKS;
2649 }
2650 }
2651
2652 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2653 cERROR(1, "mount option dynperm ignored if cifsacl "
2654 "mount option supported");
2655 }
2656
2657 static int
2658 is_path_accessible(int xid, struct cifsTconInfo *tcon,
2659 struct cifs_sb_info *cifs_sb, const char *full_path)
2660 {
2661 int rc;
2662 FILE_ALL_INFO *pfile_info;
2663
2664 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2665 if (pfile_info == NULL)
2666 return -ENOMEM;
2667
2668 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2669 0 /* not legacy */, cifs_sb->local_nls,
2670 cifs_sb->mnt_cifs_flags &
2671 CIFS_MOUNT_MAP_SPECIAL_CHR);
2672 kfree(pfile_info);
2673 return rc;
2674 }
2675
2676 static void
2677 cleanup_volume_info(struct smb_vol **pvolume_info)
2678 {
2679 struct smb_vol *volume_info;
2680
2681 if (!pvolume_info || !*pvolume_info)
2682 return;
2683
2684 volume_info = *pvolume_info;
2685 kzfree(volume_info->password);
2686 kfree(volume_info->UNC);
2687 kfree(volume_info->prepath);
2688 kfree(volume_info);
2689 *pvolume_info = NULL;
2690 return;
2691 }
2692
2693 #ifdef CONFIG_CIFS_DFS_UPCALL
2694 /* build_path_to_root returns full path to root when
2695 * we do not have an exiting connection (tcon) */
2696 static char *
2697 build_unc_path_to_root(const struct smb_vol *volume_info,
2698 const struct cifs_sb_info *cifs_sb)
2699 {
2700 char *full_path;
2701
2702 int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2703 full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2704 if (full_path == NULL)
2705 return ERR_PTR(-ENOMEM);
2706
2707 strncpy(full_path, volume_info->UNC, unc_len);
2708 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2709 int i;
2710 for (i = 0; i < unc_len; i++) {
2711 if (full_path[i] == '\\')
2712 full_path[i] = '/';
2713 }
2714 }
2715
2716 if (cifs_sb->prepathlen)
2717 strncpy(full_path + unc_len, cifs_sb->prepath,
2718 cifs_sb->prepathlen);
2719
2720 full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2721 return full_path;
2722 }
2723 #endif
2724
2725 int
2726 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
2727 char *mount_data_global, const char *devname)
2728 {
2729 int rc;
2730 int xid;
2731 struct smb_vol *volume_info;
2732 struct cifsSesInfo *pSesInfo;
2733 struct cifsTconInfo *tcon;
2734 struct TCP_Server_Info *srvTcp;
2735 char *full_path;
2736 char *mount_data = mount_data_global;
2737 struct tcon_link *tlink;
2738 #ifdef CONFIG_CIFS_DFS_UPCALL
2739 struct dfs_info3_param *referrals = NULL;
2740 unsigned int num_referrals = 0;
2741 int referral_walks_count = 0;
2742 try_mount_again:
2743 #endif
2744 rc = 0;
2745 tcon = NULL;
2746 pSesInfo = NULL;
2747 srvTcp = NULL;
2748 full_path = NULL;
2749 tlink = NULL;
2750
2751 xid = GetXid();
2752
2753 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2754 if (!volume_info) {
2755 rc = -ENOMEM;
2756 goto out;
2757 }
2758
2759 if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
2760 rc = -EINVAL;
2761 goto out;
2762 }
2763
2764 if (volume_info->nullauth) {
2765 cFYI(1, "null user");
2766 volume_info->username = "";
2767 } else if (volume_info->username) {
2768 /* BB fixme parse for domain name here */
2769 cFYI(1, "Username: %s", volume_info->username);
2770 } else {
2771 cifserror("No username specified");
2772 /* In userspace mount helper we can get user name from alternate
2773 locations such as env variables and files on disk */
2774 rc = -EINVAL;
2775 goto out;
2776 }
2777
2778 /* this is needed for ASCII cp to Unicode converts */
2779 if (volume_info->iocharset == NULL) {
2780 /* load_nls_default cannot return null */
2781 volume_info->local_nls = load_nls_default();
2782 } else {
2783 volume_info->local_nls = load_nls(volume_info->iocharset);
2784 if (volume_info->local_nls == NULL) {
2785 cERROR(1, "CIFS mount error: iocharset %s not found",
2786 volume_info->iocharset);
2787 rc = -ELIBACC;
2788 goto out;
2789 }
2790 }
2791 cifs_sb->local_nls = volume_info->local_nls;
2792
2793 /* get a reference to a tcp session */
2794 srvTcp = cifs_get_tcp_session(volume_info);
2795 if (IS_ERR(srvTcp)) {
2796 rc = PTR_ERR(srvTcp);
2797 goto out;
2798 }
2799
2800 /* get a reference to a SMB session */
2801 pSesInfo = cifs_get_smb_ses(srvTcp, volume_info);
2802 if (IS_ERR(pSesInfo)) {
2803 rc = PTR_ERR(pSesInfo);
2804 pSesInfo = NULL;
2805 goto mount_fail_check;
2806 }
2807
2808 setup_cifs_sb(volume_info, cifs_sb);
2809 if (pSesInfo->capabilities & CAP_LARGE_FILES)
2810 sb->s_maxbytes = MAX_LFS_FILESIZE;
2811 else
2812 sb->s_maxbytes = MAX_NON_LFS;
2813
2814 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2815 sb->s_time_gran = 100;
2816
2817 /* search for existing tcon to this server share */
2818 tcon = cifs_get_tcon(pSesInfo, volume_info);
2819 if (IS_ERR(tcon)) {
2820 rc = PTR_ERR(tcon);
2821 tcon = NULL;
2822 goto remote_path_check;
2823 }
2824
2825 /* do not care if following two calls succeed - informational */
2826 if (!tcon->ipc) {
2827 CIFSSMBQFSDeviceInfo(xid, tcon);
2828 CIFSSMBQFSAttributeInfo(xid, tcon);
2829 }
2830
2831 /* tell server which Unix caps we support */
2832 if (tcon->ses->capabilities & CAP_UNIX)
2833 /* reset of caps checks mount to see if unix extensions
2834 disabled for just this mount */
2835 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
2836 else
2837 tcon->unix_ext = 0; /* server does not support them */
2838
2839 /* convert forward to back slashes in prepath here if needed */
2840 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2841 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2842
2843 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2844 cifs_sb->rsize = 1024 * 127;
2845 cFYI(DBG2, "no very large read support, rsize now 127K");
2846 }
2847 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2848 cifs_sb->wsize = min(cifs_sb->wsize,
2849 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2850 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2851 cifs_sb->rsize = min(cifs_sb->rsize,
2852 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2853
2854 remote_path_check:
2855 /* check if a whole path (including prepath) is not remote */
2856 if (!rc && tcon) {
2857 /* build_path_to_root works only when we have a valid tcon */
2858 full_path = cifs_build_path_to_root(cifs_sb, tcon);
2859 if (full_path == NULL) {
2860 rc = -ENOMEM;
2861 goto mount_fail_check;
2862 }
2863 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
2864 if (rc != 0 && rc != -EREMOTE) {
2865 kfree(full_path);
2866 goto mount_fail_check;
2867 }
2868 kfree(full_path);
2869 }
2870
2871 /* get referral if needed */
2872 if (rc == -EREMOTE) {
2873 #ifdef CONFIG_CIFS_DFS_UPCALL
2874 if (referral_walks_count > MAX_NESTED_LINKS) {
2875 /*
2876 * BB: when we implement proper loop detection,
2877 * we will remove this check. But now we need it
2878 * to prevent an indefinite loop if 'DFS tree' is
2879 * misconfigured (i.e. has loops).
2880 */
2881 rc = -ELOOP;
2882 goto mount_fail_check;
2883 }
2884 /* convert forward to back slashes in prepath here if needed */
2885 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2886 convert_delimiter(cifs_sb->prepath,
2887 CIFS_DIR_SEP(cifs_sb));
2888 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2889 if (IS_ERR(full_path)) {
2890 rc = PTR_ERR(full_path);
2891 goto mount_fail_check;
2892 }
2893
2894 cFYI(1, "Getting referral for: %s", full_path);
2895 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2896 cifs_sb->local_nls, &num_referrals, &referrals,
2897 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2898 if (!rc && num_referrals > 0) {
2899 char *fake_devname = NULL;
2900
2901 if (mount_data != mount_data_global)
2902 kfree(mount_data);
2903
2904 mount_data = cifs_compose_mount_options(
2905 cifs_sb->mountdata, full_path + 1,
2906 referrals, &fake_devname);
2907
2908 free_dfs_info_array(referrals, num_referrals);
2909 kfree(fake_devname);
2910 kfree(full_path);
2911
2912 if (IS_ERR(mount_data)) {
2913 rc = PTR_ERR(mount_data);
2914 mount_data = NULL;
2915 goto mount_fail_check;
2916 }
2917
2918 if (tcon)
2919 cifs_put_tcon(tcon);
2920 else if (pSesInfo)
2921 cifs_put_smb_ses(pSesInfo);
2922
2923 cleanup_volume_info(&volume_info);
2924 referral_walks_count++;
2925 FreeXid(xid);
2926 goto try_mount_again;
2927 }
2928 #else /* No DFS support, return error on mount */
2929 rc = -EOPNOTSUPP;
2930 #endif
2931 }
2932
2933 if (rc)
2934 goto mount_fail_check;
2935
2936 /* now, hang the tcon off of the superblock */
2937 tlink = kzalloc(sizeof *tlink, GFP_KERNEL);
2938 if (tlink == NULL) {
2939 rc = -ENOMEM;
2940 goto mount_fail_check;
2941 }
2942
2943 tlink->tl_uid = pSesInfo->linux_uid;
2944 tlink->tl_tcon = tcon;
2945 tlink->tl_time = jiffies;
2946 set_bit(TCON_LINK_MASTER, &tlink->tl_flags);
2947 set_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
2948
2949 cifs_sb->master_tlink = tlink;
2950 spin_lock(&cifs_sb->tlink_tree_lock);
2951 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
2952 spin_unlock(&cifs_sb->tlink_tree_lock);
2953
2954 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
2955 TLINK_IDLE_EXPIRE);
2956
2957 mount_fail_check:
2958 /* on error free sesinfo and tcon struct if needed */
2959 if (rc) {
2960 if (mount_data != mount_data_global)
2961 kfree(mount_data);
2962 /* If find_unc succeeded then rc == 0 so we can not end */
2963 /* up accidentally freeing someone elses tcon struct */
2964 if (tcon)
2965 cifs_put_tcon(tcon);
2966 else if (pSesInfo)
2967 cifs_put_smb_ses(pSesInfo);
2968 else
2969 cifs_put_tcp_session(srvTcp);
2970 goto out;
2971 }
2972
2973 /* volume_info->password is freed above when existing session found
2974 (in which case it is not needed anymore) but when new sesion is created
2975 the password ptr is put in the new session structure (in which case the
2976 password will be freed at unmount time) */
2977 out:
2978 /* zero out password before freeing */
2979 cleanup_volume_info(&volume_info);
2980 FreeXid(xid);
2981 return rc;
2982 }
2983
2984 int
2985 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
2986 const char *tree, struct cifsTconInfo *tcon,
2987 const struct nls_table *nls_codepage)
2988 {
2989 struct smb_hdr *smb_buffer;
2990 struct smb_hdr *smb_buffer_response;
2991 TCONX_REQ *pSMB;
2992 TCONX_RSP *pSMBr;
2993 unsigned char *bcc_ptr;
2994 int rc = 0;
2995 int length;
2996 __u16 bytes_left, count;
2997
2998 if (ses == NULL)
2999 return -EIO;
3000
3001 smb_buffer = cifs_buf_get();
3002 if (smb_buffer == NULL)
3003 return -ENOMEM;
3004
3005 smb_buffer_response = smb_buffer;
3006
3007 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
3008 NULL /*no tid */ , 4 /*wct */ );
3009
3010 smb_buffer->Mid = GetNextMid(ses->server);
3011 smb_buffer->Uid = ses->Suid;
3012 pSMB = (TCONX_REQ *) smb_buffer;
3013 pSMBr = (TCONX_RSP *) smb_buffer_response;
3014
3015 pSMB->AndXCommand = 0xFF;
3016 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
3017 bcc_ptr = &pSMB->Password[0];
3018 if ((ses->server->secMode) & SECMODE_USER) {
3019 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
3020 *bcc_ptr = 0; /* password is null byte */
3021 bcc_ptr++; /* skip password */
3022 /* already aligned so no need to do it below */
3023 } else {
3024 pSMB->PasswordLength = cpu_to_le16(CIFS_AUTH_RESP_SIZE);
3025 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
3026 specified as required (when that support is added to
3027 the vfs in the future) as only NTLM or the much
3028 weaker LANMAN (which we do not send by default) is accepted
3029 by Samba (not sure whether other servers allow
3030 NTLMv2 password here) */
3031 #ifdef CONFIG_CIFS_WEAK_PW_HASH
3032 if ((global_secflags & CIFSSEC_MAY_LANMAN) &&
3033 (ses->server->secType == LANMAN))
3034 calc_lanman_hash(tcon->password, ses->server->cryptkey,
3035 ses->server->secMode &
3036 SECMODE_PW_ENCRYPT ? true : false,
3037 bcc_ptr);
3038 else
3039 #endif /* CIFS_WEAK_PW_HASH */
3040 rc = SMBNTencrypt(tcon->password, ses->server->cryptkey,
3041 bcc_ptr);
3042
3043 bcc_ptr += CIFS_AUTH_RESP_SIZE;
3044 if (ses->capabilities & CAP_UNICODE) {
3045 /* must align unicode strings */
3046 *bcc_ptr = 0; /* null byte password */
3047 bcc_ptr++;
3048 }
3049 }
3050
3051 if (ses->server->secMode &
3052 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
3053 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
3054
3055 if (ses->capabilities & CAP_STATUS32) {
3056 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
3057 }
3058 if (ses->capabilities & CAP_DFS) {
3059 smb_buffer->Flags2 |= SMBFLG2_DFS;
3060 }
3061 if (ses->capabilities & CAP_UNICODE) {
3062 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
3063 length =
3064 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
3065 6 /* max utf8 char length in bytes */ *
3066 (/* server len*/ + 256 /* share len */), nls_codepage);
3067 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
3068 bcc_ptr += 2; /* skip trailing null */
3069 } else { /* ASCII */
3070 strcpy(bcc_ptr, tree);
3071 bcc_ptr += strlen(tree) + 1;
3072 }
3073 strcpy(bcc_ptr, "?????");
3074 bcc_ptr += strlen("?????");
3075 bcc_ptr += 1;
3076 count = bcc_ptr - &pSMB->Password[0];
3077 pSMB->hdr.smb_buf_length += count;
3078 pSMB->ByteCount = cpu_to_le16(count);
3079
3080 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
3081 0);
3082
3083 /* above now done in SendReceive */
3084 if ((rc == 0) && (tcon != NULL)) {
3085 bool is_unicode;
3086
3087 tcon->tidStatus = CifsGood;
3088 tcon->need_reconnect = false;
3089 tcon->tid = smb_buffer_response->Tid;
3090 bcc_ptr = pByteArea(smb_buffer_response);
3091 bytes_left = get_bcc(smb_buffer_response);
3092 length = strnlen(bcc_ptr, bytes_left - 2);
3093 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
3094 is_unicode = true;
3095 else
3096 is_unicode = false;
3097
3098
3099 /* skip service field (NB: this field is always ASCII) */
3100 if (length == 3) {
3101 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
3102 (bcc_ptr[2] == 'C')) {
3103 cFYI(1, "IPC connection");
3104 tcon->ipc = 1;
3105 }
3106 } else if (length == 2) {
3107 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
3108 /* the most common case */
3109 cFYI(1, "disk share connection");
3110 }
3111 }
3112 bcc_ptr += length + 1;
3113 bytes_left -= (length + 1);
3114 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
3115
3116 /* mostly informational -- no need to fail on error here */
3117 kfree(tcon->nativeFileSystem);
3118 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
3119 bytes_left, is_unicode,
3120 nls_codepage);
3121
3122 cFYI(1, "nativeFileSystem=%s", tcon->nativeFileSystem);
3123
3124 if ((smb_buffer_response->WordCount == 3) ||
3125 (smb_buffer_response->WordCount == 7))
3126 /* field is in same location */
3127 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
3128 else
3129 tcon->Flags = 0;
3130 cFYI(1, "Tcon flags: 0x%x ", tcon->Flags);
3131 } else if ((rc == 0) && tcon == NULL) {
3132 /* all we need to save for IPC$ connection */
3133 ses->ipc_tid = smb_buffer_response->Tid;
3134 }
3135
3136 cifs_buf_release(smb_buffer);
3137 return rc;
3138 }
3139
3140 int
3141 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
3142 {
3143 struct rb_root *root = &cifs_sb->tlink_tree;
3144 struct rb_node *node;
3145 struct tcon_link *tlink;
3146 char *tmp;
3147
3148 cancel_delayed_work_sync(&cifs_sb->prune_tlinks);
3149
3150 spin_lock(&cifs_sb->tlink_tree_lock);
3151 while ((node = rb_first(root))) {
3152 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3153 cifs_get_tlink(tlink);
3154 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3155 rb_erase(node, root);
3156
3157 spin_unlock(&cifs_sb->tlink_tree_lock);
3158 cifs_put_tlink(tlink);
3159 spin_lock(&cifs_sb->tlink_tree_lock);
3160 }
3161 spin_unlock(&cifs_sb->tlink_tree_lock);
3162
3163 tmp = cifs_sb->prepath;
3164 cifs_sb->prepathlen = 0;
3165 cifs_sb->prepath = NULL;
3166 kfree(tmp);
3167
3168 return 0;
3169 }
3170
3171 int cifs_negotiate_protocol(unsigned int xid, struct cifsSesInfo *ses)
3172 {
3173 int rc = 0;
3174 struct TCP_Server_Info *server = ses->server;
3175
3176 /* only send once per connect */
3177 if (server->maxBuf != 0)
3178 return 0;
3179
3180 rc = CIFSSMBNegotiate(xid, ses);
3181 if (rc == -EAGAIN) {
3182 /* retry only once on 1st time connection */
3183 rc = CIFSSMBNegotiate(xid, ses);
3184 if (rc == -EAGAIN)
3185 rc = -EHOSTDOWN;
3186 }
3187 if (rc == 0) {
3188 spin_lock(&GlobalMid_Lock);
3189 if (server->tcpStatus != CifsExiting)
3190 server->tcpStatus = CifsGood;
3191 else
3192 rc = -EHOSTDOWN;
3193 spin_unlock(&GlobalMid_Lock);
3194
3195 }
3196
3197 return rc;
3198 }
3199
3200
3201 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *ses,
3202 struct nls_table *nls_info)
3203 {
3204 int rc = 0;
3205 struct TCP_Server_Info *server = ses->server;
3206
3207 ses->flags = 0;
3208 ses->capabilities = server->capabilities;
3209 if (linuxExtEnabled == 0)
3210 ses->capabilities &= (~CAP_UNIX);
3211
3212 cFYI(1, "Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
3213 server->secMode, server->capabilities, server->timeAdj);
3214
3215 rc = CIFS_SessSetup(xid, ses, nls_info);
3216 if (rc) {
3217 cERROR(1, "Send error in SessSetup = %d", rc);
3218 } else {
3219 mutex_lock(&ses->server->srv_mutex);
3220 if (!server->session_estab) {
3221 server->session_key.response = ses->auth_key.response;
3222 server->session_key.len = ses->auth_key.len;
3223 server->sequence_number = 0x2;
3224 server->session_estab = true;
3225 ses->auth_key.response = NULL;
3226 }
3227 mutex_unlock(&server->srv_mutex);
3228
3229 cFYI(1, "CIFS Session Established successfully");
3230 spin_lock(&GlobalMid_Lock);
3231 ses->status = CifsGood;
3232 ses->need_reconnect = false;
3233 spin_unlock(&GlobalMid_Lock);
3234 }
3235
3236 kfree(ses->auth_key.response);
3237 ses->auth_key.response = NULL;
3238 ses->auth_key.len = 0;
3239 kfree(ses->ntlmssp);
3240 ses->ntlmssp = NULL;
3241
3242 return rc;
3243 }
3244
3245 static struct cifsTconInfo *
3246 cifs_construct_tcon(struct cifs_sb_info *cifs_sb, uid_t fsuid)
3247 {
3248 struct cifsTconInfo *master_tcon = cifs_sb_master_tcon(cifs_sb);
3249 struct cifsSesInfo *ses;
3250 struct cifsTconInfo *tcon = NULL;
3251 struct smb_vol *vol_info;
3252 char username[MAX_USERNAME_SIZE + 1];
3253
3254 vol_info = kzalloc(sizeof(*vol_info), GFP_KERNEL);
3255 if (vol_info == NULL) {
3256 tcon = ERR_PTR(-ENOMEM);
3257 goto out;
3258 }
3259
3260 snprintf(username, MAX_USERNAME_SIZE, "krb50x%x", fsuid);
3261 vol_info->username = username;
3262 vol_info->local_nls = cifs_sb->local_nls;
3263 vol_info->linux_uid = fsuid;
3264 vol_info->cred_uid = fsuid;
3265 vol_info->UNC = master_tcon->treeName;
3266 vol_info->retry = master_tcon->retry;
3267 vol_info->nocase = master_tcon->nocase;
3268 vol_info->local_lease = master_tcon->local_lease;
3269 vol_info->no_linux_ext = !master_tcon->unix_ext;
3270
3271 /* FIXME: allow for other secFlg settings */
3272 vol_info->secFlg = CIFSSEC_MUST_KRB5;
3273
3274 /* get a reference for the same TCP session */
3275 spin_lock(&cifs_tcp_ses_lock);
3276 ++master_tcon->ses->server->srv_count;
3277 spin_unlock(&cifs_tcp_ses_lock);
3278
3279 ses = cifs_get_smb_ses(master_tcon->ses->server, vol_info);
3280 if (IS_ERR(ses)) {
3281 tcon = (struct cifsTconInfo *)ses;
3282 cifs_put_tcp_session(master_tcon->ses->server);
3283 goto out;
3284 }
3285
3286 tcon = cifs_get_tcon(ses, vol_info);
3287 if (IS_ERR(tcon)) {
3288 cifs_put_smb_ses(ses);
3289 goto out;
3290 }
3291
3292 if (ses->capabilities & CAP_UNIX)
3293 reset_cifs_unix_caps(0, tcon, NULL, vol_info);
3294 out:
3295 kfree(vol_info);
3296
3297 return tcon;
3298 }
3299
3300 static inline struct tcon_link *
3301 cifs_sb_master_tlink(struct cifs_sb_info *cifs_sb)
3302 {
3303 return cifs_sb->master_tlink;
3304 }
3305
3306 struct cifsTconInfo *
3307 cifs_sb_master_tcon(struct cifs_sb_info *cifs_sb)
3308 {
3309 return tlink_tcon(cifs_sb_master_tlink(cifs_sb));
3310 }
3311
3312 static int
3313 cifs_sb_tcon_pending_wait(void *unused)
3314 {
3315 schedule();
3316 return signal_pending(current) ? -ERESTARTSYS : 0;
3317 }
3318
3319 /* find and return a tlink with given uid */
3320 static struct tcon_link *
3321 tlink_rb_search(struct rb_root *root, uid_t uid)
3322 {
3323 struct rb_node *node = root->rb_node;
3324 struct tcon_link *tlink;
3325
3326 while (node) {
3327 tlink = rb_entry(node, struct tcon_link, tl_rbnode);
3328
3329 if (tlink->tl_uid > uid)
3330 node = node->rb_left;
3331 else if (tlink->tl_uid < uid)
3332 node = node->rb_right;
3333 else
3334 return tlink;
3335 }
3336 return NULL;
3337 }
3338
3339 /* insert a tcon_link into the tree */
3340 static void
3341 tlink_rb_insert(struct rb_root *root, struct tcon_link *new_tlink)
3342 {
3343 struct rb_node **new = &(root->rb_node), *parent = NULL;
3344 struct tcon_link *tlink;
3345
3346 while (*new) {
3347 tlink = rb_entry(*new, struct tcon_link, tl_rbnode);
3348 parent = *new;
3349
3350 if (tlink->tl_uid > new_tlink->tl_uid)
3351 new = &((*new)->rb_left);
3352 else
3353 new = &((*new)->rb_right);
3354 }
3355
3356 rb_link_node(&new_tlink->tl_rbnode, parent, new);
3357 rb_insert_color(&new_tlink->tl_rbnode, root);
3358 }
3359
3360 /*
3361 * Find or construct an appropriate tcon given a cifs_sb and the fsuid of the
3362 * current task.
3363 *
3364 * If the superblock doesn't refer to a multiuser mount, then just return
3365 * the master tcon for the mount.
3366 *
3367 * First, search the rbtree for an existing tcon for this fsuid. If one
3368 * exists, then check to see if it's pending construction. If it is then wait
3369 * for construction to complete. Once it's no longer pending, check to see if
3370 * it failed and either return an error or retry construction, depending on
3371 * the timeout.
3372 *
3373 * If one doesn't exist then insert a new tcon_link struct into the tree and
3374 * try to construct a new one.
3375 */
3376 struct tcon_link *
3377 cifs_sb_tlink(struct cifs_sb_info *cifs_sb)
3378 {
3379 int ret;
3380 uid_t fsuid = current_fsuid();
3381 struct tcon_link *tlink, *newtlink;
3382
3383 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
3384 return cifs_get_tlink(cifs_sb_master_tlink(cifs_sb));
3385
3386 spin_lock(&cifs_sb->tlink_tree_lock);
3387 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3388 if (tlink)
3389 cifs_get_tlink(tlink);
3390 spin_unlock(&cifs_sb->tlink_tree_lock);
3391
3392 if (tlink == NULL) {
3393 newtlink = kzalloc(sizeof(*tlink), GFP_KERNEL);
3394 if (newtlink == NULL)
3395 return ERR_PTR(-ENOMEM);
3396 newtlink->tl_uid = fsuid;
3397 newtlink->tl_tcon = ERR_PTR(-EACCES);
3398 set_bit(TCON_LINK_PENDING, &newtlink->tl_flags);
3399 set_bit(TCON_LINK_IN_TREE, &newtlink->tl_flags);
3400 cifs_get_tlink(newtlink);
3401
3402 spin_lock(&cifs_sb->tlink_tree_lock);
3403 /* was one inserted after previous search? */
3404 tlink = tlink_rb_search(&cifs_sb->tlink_tree, fsuid);
3405 if (tlink) {
3406 cifs_get_tlink(tlink);
3407 spin_unlock(&cifs_sb->tlink_tree_lock);
3408 kfree(newtlink);
3409 goto wait_for_construction;
3410 }
3411 tlink = newtlink;
3412 tlink_rb_insert(&cifs_sb->tlink_tree, tlink);
3413 spin_unlock(&cifs_sb->tlink_tree_lock);
3414 } else {
3415 wait_for_construction:
3416 ret = wait_on_bit(&tlink->tl_flags, TCON_LINK_PENDING,
3417 cifs_sb_tcon_pending_wait,
3418 TASK_INTERRUPTIBLE);
3419 if (ret) {
3420 cifs_put_tlink(tlink);
3421 return ERR_PTR(ret);
3422 }
3423
3424 /* if it's good, return it */
3425 if (!IS_ERR(tlink->tl_tcon))
3426 return tlink;
3427
3428 /* return error if we tried this already recently */
3429 if (time_before(jiffies, tlink->tl_time + TLINK_ERROR_EXPIRE)) {
3430 cifs_put_tlink(tlink);
3431 return ERR_PTR(-EACCES);
3432 }
3433
3434 if (test_and_set_bit(TCON_LINK_PENDING, &tlink->tl_flags))
3435 goto wait_for_construction;
3436 }
3437
3438 tlink->tl_tcon = cifs_construct_tcon(cifs_sb, fsuid);
3439 clear_bit(TCON_LINK_PENDING, &tlink->tl_flags);
3440 wake_up_bit(&tlink->tl_flags, TCON_LINK_PENDING);
3441
3442 if (IS_ERR(tlink->tl_tcon)) {
3443 cifs_put_tlink(tlink);
3444 return ERR_PTR(-EACCES);
3445 }
3446
3447 return tlink;
3448 }
3449
3450 /*
3451 * periodic workqueue job that scans tcon_tree for a superblock and closes
3452 * out tcons.
3453 */
3454 static void
3455 cifs_prune_tlinks(struct work_struct *work)
3456 {
3457 struct cifs_sb_info *cifs_sb = container_of(work, struct cifs_sb_info,
3458 prune_tlinks.work);
3459 struct rb_root *root = &cifs_sb->tlink_tree;
3460 struct rb_node *node = rb_first(root);
3461 struct rb_node *tmp;
3462 struct tcon_link *tlink;
3463
3464 /*
3465 * Because we drop the spinlock in the loop in order to put the tlink
3466 * it's not guarded against removal of links from the tree. The only
3467 * places that remove entries from the tree are this function and
3468 * umounts. Because this function is non-reentrant and is canceled
3469 * before umount can proceed, this is safe.
3470 */
3471 spin_lock(&cifs_sb->tlink_tree_lock);
3472 node = rb_first(root);
3473 while (node != NULL) {
3474 tmp = node;
3475 node = rb_next(tmp);
3476 tlink = rb_entry(tmp, struct tcon_link, tl_rbnode);
3477
3478 if (test_bit(TCON_LINK_MASTER, &tlink->tl_flags) ||
3479 atomic_read(&tlink->tl_count) != 0 ||
3480 time_after(tlink->tl_time + TLINK_IDLE_EXPIRE, jiffies))
3481 continue;
3482
3483 cifs_get_tlink(tlink);
3484 clear_bit(TCON_LINK_IN_TREE, &tlink->tl_flags);
3485 rb_erase(tmp, root);
3486
3487 spin_unlock(&cifs_sb->tlink_tree_lock);
3488 cifs_put_tlink(tlink);
3489 spin_lock(&cifs_sb->tlink_tree_lock);
3490 }
3491 spin_unlock(&cifs_sb->tlink_tree_lock);
3492
3493 queue_delayed_work(system_nrt_wq, &cifs_sb->prune_tlinks,
3494 TLINK_IDLE_EXPIRE);
3495 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree