?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm/i915: NOMEM->NOSPC
[linux-2.6/mini2440.git] / fs / cifs / connect.c
blob4aa81a507b741110657eeb1e7899235296d829d8
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/pagemap.h>
27 #include <linux/ctype.h>
28 #include <linux/utsname.h>
29 #include <linux/mempool.h>
30 #include <linux/delay.h>
31 #include <linux/completion.h>
32 #include <linux/kthread.h>
33 #include <linux/pagevec.h>
34 #include <linux/freezer.h>
35 #include <linux/namei.h>
36 #include <asm/uaccess.h>
37 #include <asm/processor.h>
38 #include <net/ipv6.h>
39 #include "cifspdu.h"
40 #include "cifsglob.h"
41 #include "cifsproto.h"
42 #include "cifs_unicode.h"
43 #include "cifs_debug.h"
44 #include "cifs_fs_sb.h"
45 #include "ntlmssp.h"
46 #include "nterr.h"
47 #include "rfc1002pdu.h"
48 #include "cn_cifs.h"
49
50 #define CIFS_PORT 445
51 #define RFC1001_PORT 139
52
53 extern void SMBNTencrypt(unsigned char *passwd, unsigned char *c8,
54 unsigned char *p24);
55
56 extern mempool_t *cifs_req_poolp;
57
58 struct smb_vol {
59 char *username;
60 char *password;
61 char *domainname;
62 char *UNC;
63 char *UNCip;
64 char *in6_addr; /* ipv6 address as human readable form of in6_addr */
65 char *iocharset; /* local code page for mapping to and from Unicode */
66 char source_rfc1001_name[16]; /* netbios name of client */
67 char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
68 uid_t linux_uid;
69 gid_t linux_gid;
70 mode_t file_mode;
71 mode_t dir_mode;
72 unsigned secFlg;
73 bool rw:1;
74 bool retry:1;
75 bool intr:1;
76 bool setuids:1;
77 bool override_uid:1;
78 bool override_gid:1;
79 bool dynperm:1;
80 bool noperm:1;
81 bool no_psx_acl:1; /* set if posix acl support should be disabled */
82 bool cifs_acl:1;
83 bool no_xattr:1; /* set if xattr (EA) support should be disabled*/
84 bool server_ino:1; /* use inode numbers from server ie UniqueId */
85 bool direct_io:1;
86 bool remap:1; /* set to remap seven reserved chars in filenames */
87 bool posix_paths:1; /* unset to not ask for posix pathnames. */
88 bool no_linux_ext:1;
89 bool sfu_emul:1;
90 bool nullauth:1; /* attempt to authenticate with null user */
91 bool nocase:1; /* request case insensitive filenames */
92 bool nobrl:1; /* disable sending byte range locks to srv */
93 bool mand_lock:1; /* send mandatory not posix byte range lock reqs */
94 bool seal:1; /* request transport encryption on share */
95 bool nodfs:1; /* Do not request DFS, even if available */
96 bool local_lease:1; /* check leases only on local system, not remote */
97 bool noblocksnd:1;
98 bool noautotune:1;
99 bool nostrictsync:1; /* do not force expensive SMBflush on every sync */
100 unsigned int rsize;
101 unsigned int wsize;
102 unsigned int sockopt;
103 unsigned short int port;
104 char *prepath;
105 };
106
107 static int ipv4_connect(struct TCP_Server_Info *server);
108 static int ipv6_connect(struct TCP_Server_Info *server);
109
110 /*
111 * cifs tcp session reconnection
112 *
113 * mark tcp session as reconnecting so temporarily locked
114 * mark all smb sessions as reconnecting for tcp session
115 * reconnect tcp session
116 * wake up waiters on reconnection? - (not needed currently)
117 */
118 static int
119 cifs_reconnect(struct TCP_Server_Info *server)
120 {
121 int rc = 0;
122 struct list_head *tmp, *tmp2;
123 struct cifsSesInfo *ses;
124 struct cifsTconInfo *tcon;
125 struct mid_q_entry *mid_entry;
126
127 spin_lock(&GlobalMid_Lock);
128 if (server->tcpStatus == CifsExiting) {
129 /* the demux thread will exit normally
130 next time through the loop */
131 spin_unlock(&GlobalMid_Lock);
132 return rc;
133 } else
134 server->tcpStatus = CifsNeedReconnect;
135 spin_unlock(&GlobalMid_Lock);
136 server->maxBuf = 0;
137
138 cFYI(1, ("Reconnecting tcp session"));
139
140 /* before reconnecting the tcp session, mark the smb session (uid)
141 and the tid bad so they are not used until reconnected */
142 read_lock(&cifs_tcp_ses_lock);
143 list_for_each(tmp, &server->smb_ses_list) {
144 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
145 ses->need_reconnect = true;
146 ses->ipc_tid = 0;
147 list_for_each(tmp2, &ses->tcon_list) {
148 tcon = list_entry(tmp2, struct cifsTconInfo, tcon_list);
149 tcon->need_reconnect = true;
150 }
151 }
152 read_unlock(&cifs_tcp_ses_lock);
153 /* do not want to be sending data on a socket we are freeing */
154 mutex_lock(&server->srv_mutex);
155 if (server->ssocket) {
156 cFYI(1, ("State: 0x%x Flags: 0x%lx", server->ssocket->state,
157 server->ssocket->flags));
158 kernel_sock_shutdown(server->ssocket, SHUT_WR);
159 cFYI(1, ("Post shutdown state: 0x%x Flags: 0x%lx",
160 server->ssocket->state,
161 server->ssocket->flags));
162 sock_release(server->ssocket);
163 server->ssocket = NULL;
164 }
165
166 spin_lock(&GlobalMid_Lock);
167 list_for_each(tmp, &server->pending_mid_q) {
168 mid_entry = list_entry(tmp, struct
169 mid_q_entry,
170 qhead);
171 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
172 /* Mark other intransit requests as needing
173 retry so we do not immediately mark the
174 session bad again (ie after we reconnect
175 below) as they timeout too */
176 mid_entry->midState = MID_RETRY_NEEDED;
177 }
178 }
179 spin_unlock(&GlobalMid_Lock);
180 mutex_unlock(&server->srv_mutex);
181
182 while ((server->tcpStatus != CifsExiting) &&
183 (server->tcpStatus != CifsGood)) {
184 try_to_freeze();
185 if (server->addr.sockAddr6.sin6_family == AF_INET6)
186 rc = ipv6_connect(server);
187 else
188 rc = ipv4_connect(server);
189 if (rc) {
190 cFYI(1, ("reconnect error %d", rc));
191 msleep(3000);
192 } else {
193 atomic_inc(&tcpSesReconnectCount);
194 spin_lock(&GlobalMid_Lock);
195 if (server->tcpStatus != CifsExiting)
196 server->tcpStatus = CifsGood;
197 server->sequence_number = 0;
198 spin_unlock(&GlobalMid_Lock);
199 /* atomic_set(&server->inFlight,0);*/
200 wake_up(&server->response_q);
201 }
202 }
203 return rc;
204 }
205
206 /*
207 return codes:
208 0 not a transact2, or all data present
209 >0 transact2 with that much data missing
210 -EINVAL = invalid transact2
211
212 */
213 static int check2ndT2(struct smb_hdr *pSMB, unsigned int maxBufSize)
214 {
215 struct smb_t2_rsp *pSMBt;
216 int total_data_size;
217 int data_in_this_rsp;
218 int remaining;
219
220 if (pSMB->Command != SMB_COM_TRANSACTION2)
221 return 0;
222
223 /* check for plausible wct, bcc and t2 data and parm sizes */
224 /* check for parm and data offset going beyond end of smb */
225 if (pSMB->WordCount != 10) { /* coalesce_t2 depends on this */
226 cFYI(1, ("invalid transact2 word count"));
227 return -EINVAL;
228 }
229
230 pSMBt = (struct smb_t2_rsp *)pSMB;
231
232 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
233 data_in_this_rsp = le16_to_cpu(pSMBt->t2_rsp.DataCount);
234
235 remaining = total_data_size - data_in_this_rsp;
236
237 if (remaining == 0)
238 return 0;
239 else if (remaining < 0) {
240 cFYI(1, ("total data %d smaller than data in frame %d",
241 total_data_size, data_in_this_rsp));
242 return -EINVAL;
243 } else {
244 cFYI(1, ("missing %d bytes from transact2, check next response",
245 remaining));
246 if (total_data_size > maxBufSize) {
247 cERROR(1, ("TotalDataSize %d is over maximum buffer %d",
248 total_data_size, maxBufSize));
249 return -EINVAL;
250 }
251 return remaining;
252 }
253 }
254
255 static int coalesce_t2(struct smb_hdr *psecond, struct smb_hdr *pTargetSMB)
256 {
257 struct smb_t2_rsp *pSMB2 = (struct smb_t2_rsp *)psecond;
258 struct smb_t2_rsp *pSMBt = (struct smb_t2_rsp *)pTargetSMB;
259 int total_data_size;
260 int total_in_buf;
261 int remaining;
262 int total_in_buf2;
263 char *data_area_of_target;
264 char *data_area_of_buf2;
265 __u16 byte_count;
266
267 total_data_size = le16_to_cpu(pSMBt->t2_rsp.TotalDataCount);
268
269 if (total_data_size != le16_to_cpu(pSMB2->t2_rsp.TotalDataCount)) {
270 cFYI(1, ("total data size of primary and secondary t2 differ"));
271 }
272
273 total_in_buf = le16_to_cpu(pSMBt->t2_rsp.DataCount);
274
275 remaining = total_data_size - total_in_buf;
276
277 if (remaining < 0)
278 return -EINVAL;
279
280 if (remaining == 0) /* nothing to do, ignore */
281 return 0;
282
283 total_in_buf2 = le16_to_cpu(pSMB2->t2_rsp.DataCount);
284 if (remaining < total_in_buf2) {
285 cFYI(1, ("transact2 2nd response contains too much data"));
286 }
287
288 /* find end of first SMB data area */
289 data_area_of_target = (char *)&pSMBt->hdr.Protocol +
290 le16_to_cpu(pSMBt->t2_rsp.DataOffset);
291 /* validate target area */
292
293 data_area_of_buf2 = (char *) &pSMB2->hdr.Protocol +
294 le16_to_cpu(pSMB2->t2_rsp.DataOffset);
295
296 data_area_of_target += total_in_buf;
297
298 /* copy second buffer into end of first buffer */
299 memcpy(data_area_of_target, data_area_of_buf2, total_in_buf2);
300 total_in_buf += total_in_buf2;
301 pSMBt->t2_rsp.DataCount = cpu_to_le16(total_in_buf);
302 byte_count = le16_to_cpu(BCC_LE(pTargetSMB));
303 byte_count += total_in_buf2;
304 BCC_LE(pTargetSMB) = cpu_to_le16(byte_count);
305
306 byte_count = pTargetSMB->smb_buf_length;
307 byte_count += total_in_buf2;
308
309 /* BB also add check that we are not beyond maximum buffer size */
310
311 pTargetSMB->smb_buf_length = byte_count;
312
313 if (remaining == total_in_buf2) {
314 cFYI(1, ("found the last secondary response"));
315 return 0; /* we are done */
316 } else /* more responses to go */
317 return 1;
318
319 }
320
321 static int
322 cifs_demultiplex_thread(struct TCP_Server_Info *server)
323 {
324 int length;
325 unsigned int pdu_length, total_read;
326 struct smb_hdr *smb_buffer = NULL;
327 struct smb_hdr *bigbuf = NULL;
328 struct smb_hdr *smallbuf = NULL;
329 struct msghdr smb_msg;
330 struct kvec iov;
331 struct socket *csocket = server->ssocket;
332 struct list_head *tmp;
333 struct cifsSesInfo *ses;
334 struct task_struct *task_to_wake = NULL;
335 struct mid_q_entry *mid_entry;
336 char temp;
337 bool isLargeBuf = false;
338 bool isMultiRsp;
339 int reconnect;
340
341 current->flags |= PF_MEMALLOC;
342 cFYI(1, ("Demultiplex PID: %d", task_pid_nr(current)));
343
344 length = atomic_inc_return(&tcpSesAllocCount);
345 if (length > 1)
346 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
347 GFP_KERNEL);
348
349 set_freezable();
350 while (server->tcpStatus != CifsExiting) {
351 if (try_to_freeze())
352 continue;
353 if (bigbuf == NULL) {
354 bigbuf = cifs_buf_get();
355 if (!bigbuf) {
356 cERROR(1, ("No memory for large SMB response"));
357 msleep(3000);
358 /* retry will check if exiting */
359 continue;
360 }
361 } else if (isLargeBuf) {
362 /* we are reusing a dirty large buf, clear its start */
363 memset(bigbuf, 0, sizeof(struct smb_hdr));
364 }
365
366 if (smallbuf == NULL) {
367 smallbuf = cifs_small_buf_get();
368 if (!smallbuf) {
369 cERROR(1, ("No memory for SMB response"));
370 msleep(1000);
371 /* retry will check if exiting */
372 continue;
373 }
374 /* beginning of smb buffer is cleared in our buf_get */
375 } else /* if existing small buf clear beginning */
376 memset(smallbuf, 0, sizeof(struct smb_hdr));
377
378 isLargeBuf = false;
379 isMultiRsp = false;
380 smb_buffer = smallbuf;
381 iov.iov_base = smb_buffer;
382 iov.iov_len = 4;
383 smb_msg.msg_control = NULL;
384 smb_msg.msg_controllen = 0;
385 pdu_length = 4; /* enough to get RFC1001 header */
386 incomplete_rcv:
387 length =
388 kernel_recvmsg(csocket, &smb_msg,
389 &iov, 1, pdu_length, 0 /* BB other flags? */);
390
391 if (server->tcpStatus == CifsExiting) {
392 break;
393 } else if (server->tcpStatus == CifsNeedReconnect) {
394 cFYI(1, ("Reconnect after server stopped responding"));
395 cifs_reconnect(server);
396 cFYI(1, ("call to reconnect done"));
397 csocket = server->ssocket;
398 continue;
399 } else if ((length == -ERESTARTSYS) || (length == -EAGAIN)) {
400 msleep(1); /* minimum sleep to prevent looping
401 allowing socket to clear and app threads to set
402 tcpStatus CifsNeedReconnect if server hung */
403 if (pdu_length < 4) {
404 iov.iov_base = (4 - pdu_length) +
405 (char *)smb_buffer;
406 iov.iov_len = pdu_length;
407 smb_msg.msg_control = NULL;
408 smb_msg.msg_controllen = 0;
409 goto incomplete_rcv;
410 } else
411 continue;
412 } else if (length <= 0) {
413 if (server->tcpStatus == CifsNew) {
414 cFYI(1, ("tcp session abend after SMBnegprot"));
415 /* some servers kill the TCP session rather than
416 returning an SMB negprot error, in which
417 case reconnecting here is not going to help,
418 and so simply return error to mount */
419 break;
420 }
421 if (!try_to_freeze() && (length == -EINTR)) {
422 cFYI(1, ("cifsd thread killed"));
423 break;
424 }
425 cFYI(1, ("Reconnect after unexpected peek error %d",
426 length));
427 cifs_reconnect(server);
428 csocket = server->ssocket;
429 wake_up(&server->response_q);
430 continue;
431 } else if (length < pdu_length) {
432 cFYI(1, ("requested %d bytes but only got %d bytes",
433 pdu_length, length));
434 pdu_length -= length;
435 msleep(1);
436 goto incomplete_rcv;
437 }
438
439 /* The right amount was read from socket - 4 bytes */
440 /* so we can now interpret the length field */
441
442 /* the first byte big endian of the length field,
443 is actually not part of the length but the type
444 with the most common, zero, as regular data */
445 temp = *((char *) smb_buffer);
446
447 /* Note that FC 1001 length is big endian on the wire,
448 but we convert it here so it is always manipulated
449 as host byte order */
450 pdu_length = be32_to_cpu((__force __be32)smb_buffer->smb_buf_length);
451 smb_buffer->smb_buf_length = pdu_length;
452
453 cFYI(1, ("rfc1002 length 0x%x", pdu_length+4));
454
455 if (temp == (char) RFC1002_SESSION_KEEP_ALIVE) {
456 continue;
457 } else if (temp == (char)RFC1002_POSITIVE_SESSION_RESPONSE) {
458 cFYI(1, ("Good RFC 1002 session rsp"));
459 continue;
460 } else if (temp == (char)RFC1002_NEGATIVE_SESSION_RESPONSE) {
461 /* we get this from Windows 98 instead of
462 an error on SMB negprot response */
463 cFYI(1, ("Negative RFC1002 Session Response Error 0x%x)",
464 pdu_length));
465 if (server->tcpStatus == CifsNew) {
466 /* if nack on negprot (rather than
467 ret of smb negprot error) reconnecting
468 not going to help, ret error to mount */
469 break;
470 } else {
471 /* give server a second to
472 clean up before reconnect attempt */
473 msleep(1000);
474 /* always try 445 first on reconnect
475 since we get NACK on some if we ever
476 connected to port 139 (the NACK is
477 since we do not begin with RFC1001
478 session initialize frame) */
479 server->addr.sockAddr.sin_port =
480 htons(CIFS_PORT);
481 cifs_reconnect(server);
482 csocket = server->ssocket;
483 wake_up(&server->response_q);
484 continue;
485 }
486 } else if (temp != (char) 0) {
487 cERROR(1, ("Unknown RFC 1002 frame"));
488 cifs_dump_mem(" Received Data: ", (char *)smb_buffer,
489 length);
490 cifs_reconnect(server);
491 csocket = server->ssocket;
492 continue;
493 }
494
495 /* else we have an SMB response */
496 if ((pdu_length > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) ||
497 (pdu_length < sizeof(struct smb_hdr) - 1 - 4)) {
498 cERROR(1, ("Invalid size SMB length %d pdu_length %d",
499 length, pdu_length+4));
500 cifs_reconnect(server);
501 csocket = server->ssocket;
502 wake_up(&server->response_q);
503 continue;
504 }
505
506 /* else length ok */
507 reconnect = 0;
508
509 if (pdu_length > MAX_CIFS_SMALL_BUFFER_SIZE - 4) {
510 isLargeBuf = true;
511 memcpy(bigbuf, smallbuf, 4);
512 smb_buffer = bigbuf;
513 }
514 length = 0;
515 iov.iov_base = 4 + (char *)smb_buffer;
516 iov.iov_len = pdu_length;
517 for (total_read = 0; total_read < pdu_length;
518 total_read += length) {
519 length = kernel_recvmsg(csocket, &smb_msg, &iov, 1,
520 pdu_length - total_read, 0);
521 if ((server->tcpStatus == CifsExiting) ||
522 (length == -EINTR)) {
523 /* then will exit */
524 reconnect = 2;
525 break;
526 } else if (server->tcpStatus == CifsNeedReconnect) {
527 cifs_reconnect(server);
528 csocket = server->ssocket;
529 /* Reconnect wakes up rspns q */
530 /* Now we will reread sock */
531 reconnect = 1;
532 break;
533 } else if ((length == -ERESTARTSYS) ||
534 (length == -EAGAIN)) {
535 msleep(1); /* minimum sleep to prevent looping,
536 allowing socket to clear and app
537 threads to set tcpStatus
538 CifsNeedReconnect if server hung*/
539 length = 0;
540 continue;
541 } else if (length <= 0) {
542 cERROR(1, ("Received no data, expecting %d",
543 pdu_length - total_read));
544 cifs_reconnect(server);
545 csocket = server->ssocket;
546 reconnect = 1;
547 break;
548 }
549 }
550 if (reconnect == 2)
551 break;
552 else if (reconnect == 1)
553 continue;
554
555 length += 4; /* account for rfc1002 hdr */
556
557
558 dump_smb(smb_buffer, length);
559 if (checkSMB(smb_buffer, smb_buffer->Mid, total_read+4)) {
560 cifs_dump_mem("Bad SMB: ", smb_buffer, 48);
561 continue;
562 }
563
564
565 task_to_wake = NULL;
566 spin_lock(&GlobalMid_Lock);
567 list_for_each(tmp, &server->pending_mid_q) {
568 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
569
570 if ((mid_entry->mid == smb_buffer->Mid) &&
571 (mid_entry->midState == MID_REQUEST_SUBMITTED) &&
572 (mid_entry->command == smb_buffer->Command)) {
573 if (check2ndT2(smb_buffer,server->maxBuf) > 0) {
574 /* We have a multipart transact2 resp */
575 isMultiRsp = true;
576 if (mid_entry->resp_buf) {
577 /* merge response - fix up 1st*/
578 if (coalesce_t2(smb_buffer,
579 mid_entry->resp_buf)) {
580 mid_entry->multiRsp =
581 true;
582 break;
583 } else {
584 /* all parts received */
585 mid_entry->multiEnd =
586 true;
587 goto multi_t2_fnd;
588 }
589 } else {
590 if (!isLargeBuf) {
591 cERROR(1,("1st trans2 resp needs bigbuf"));
592 /* BB maybe we can fix this up, switch
593 to already allocated large buffer? */
594 } else {
595 /* Have first buffer */
596 mid_entry->resp_buf =
597 smb_buffer;
598 mid_entry->largeBuf =
599 true;
600 bigbuf = NULL;
601 }
602 }
603 break;
604 }
605 mid_entry->resp_buf = smb_buffer;
606 mid_entry->largeBuf = isLargeBuf;
607 multi_t2_fnd:
608 task_to_wake = mid_entry->tsk;
609 mid_entry->midState = MID_RESPONSE_RECEIVED;
610 #ifdef CONFIG_CIFS_STATS2
611 mid_entry->when_received = jiffies;
612 #endif
613 /* so we do not time out requests to server
614 which is still responding (since server could
615 be busy but not dead) */
616 server->lstrp = jiffies;
617 break;
618 }
619 }
620 spin_unlock(&GlobalMid_Lock);
621 if (task_to_wake) {
622 /* Was previous buf put in mpx struct for multi-rsp? */
623 if (!isMultiRsp) {
624 /* smb buffer will be freed by user thread */
625 if (isLargeBuf)
626 bigbuf = NULL;
627 else
628 smallbuf = NULL;
629 }
630 wake_up_process(task_to_wake);
631 } else if (!is_valid_oplock_break(smb_buffer, server) &&
632 !isMultiRsp) {
633 cERROR(1, ("No task to wake, unknown frame received! "
634 "NumMids %d", midCount.counter));
635 cifs_dump_mem("Received Data is: ", (char *)smb_buffer,
636 sizeof(struct smb_hdr));
637 #ifdef CONFIG_CIFS_DEBUG2
638 cifs_dump_detail(smb_buffer);
639 cifs_dump_mids(server);
640 #endif /* CIFS_DEBUG2 */
641
642 }
643 } /* end while !EXITING */
644
645 /* take it off the list, if it's not already */
646 write_lock(&cifs_tcp_ses_lock);
647 list_del_init(&server->tcp_ses_list);
648 write_unlock(&cifs_tcp_ses_lock);
649
650 spin_lock(&GlobalMid_Lock);
651 server->tcpStatus = CifsExiting;
652 spin_unlock(&GlobalMid_Lock);
653 wake_up_all(&server->response_q);
654
655 /* check if we have blocked requests that need to free */
656 /* Note that cifs_max_pending is normally 50, but
657 can be set at module install time to as little as two */
658 spin_lock(&GlobalMid_Lock);
659 if (atomic_read(&server->inFlight) >= cifs_max_pending)
660 atomic_set(&server->inFlight, cifs_max_pending - 1);
661 /* We do not want to set the max_pending too low or we
662 could end up with the counter going negative */
663 spin_unlock(&GlobalMid_Lock);
664 /* Although there should not be any requests blocked on
665 this queue it can not hurt to be paranoid and try to wake up requests
666 that may haven been blocked when more than 50 at time were on the wire
667 to the same server - they now will see the session is in exit state
668 and get out of SendReceive. */
669 wake_up_all(&server->request_q);
670 /* give those requests time to exit */
671 msleep(125);
672
673 if (server->ssocket) {
674 sock_release(csocket);
675 server->ssocket = NULL;
676 }
677 /* buffer usuallly freed in free_mid - need to free it here on exit */
678 cifs_buf_release(bigbuf);
679 if (smallbuf) /* no sense logging a debug message if NULL */
680 cifs_small_buf_release(smallbuf);
681
682 /*
683 * BB: we shouldn't have to do any of this. It shouldn't be
684 * possible to exit from the thread with active SMB sessions
685 */
686 read_lock(&cifs_tcp_ses_lock);
687 if (list_empty(&server->pending_mid_q)) {
688 /* loop through server session structures attached to this and
689 mark them dead */
690 list_for_each(tmp, &server->smb_ses_list) {
691 ses = list_entry(tmp, struct cifsSesInfo,
692 smb_ses_list);
693 ses->status = CifsExiting;
694 ses->server = NULL;
695 }
696 read_unlock(&cifs_tcp_ses_lock);
697 } else {
698 /* although we can not zero the server struct pointer yet,
699 since there are active requests which may depnd on them,
700 mark the corresponding SMB sessions as exiting too */
701 list_for_each(tmp, &server->smb_ses_list) {
702 ses = list_entry(tmp, struct cifsSesInfo,
703 smb_ses_list);
704 ses->status = CifsExiting;
705 }
706
707 spin_lock(&GlobalMid_Lock);
708 list_for_each(tmp, &server->pending_mid_q) {
709 mid_entry = list_entry(tmp, struct mid_q_entry, qhead);
710 if (mid_entry->midState == MID_REQUEST_SUBMITTED) {
711 cFYI(1, ("Clearing Mid 0x%x - waking up ",
712 mid_entry->mid));
713 task_to_wake = mid_entry->tsk;
714 if (task_to_wake)
715 wake_up_process(task_to_wake);
716 }
717 }
718 spin_unlock(&GlobalMid_Lock);
719 read_unlock(&cifs_tcp_ses_lock);
720 /* 1/8th of sec is more than enough time for them to exit */
721 msleep(125);
722 }
723
724 if (!list_empty(&server->pending_mid_q)) {
725 /* mpx threads have not exited yet give them
726 at least the smb send timeout time for long ops */
727 /* due to delays on oplock break requests, we need
728 to wait at least 45 seconds before giving up
729 on a request getting a response and going ahead
730 and killing cifsd */
731 cFYI(1, ("Wait for exit from demultiplex thread"));
732 msleep(46000);
733 /* if threads still have not exited they are probably never
734 coming home not much else we can do but free the memory */
735 }
736
737 /* last chance to mark ses pointers invalid
738 if there are any pointing to this (e.g
739 if a crazy root user tried to kill cifsd
740 kernel thread explicitly this might happen) */
741 /* BB: This shouldn't be necessary, see above */
742 read_lock(&cifs_tcp_ses_lock);
743 list_for_each(tmp, &server->smb_ses_list) {
744 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
745 ses->server = NULL;
746 }
747 read_unlock(&cifs_tcp_ses_lock);
748
749 kfree(server->hostname);
750 task_to_wake = xchg(&server->tsk, NULL);
751 kfree(server);
752
753 length = atomic_dec_return(&tcpSesAllocCount);
754 if (length > 0)
755 mempool_resize(cifs_req_poolp, length + cifs_min_rcv,
756 GFP_KERNEL);
757
758 /* if server->tsk was NULL then wait for a signal before exiting */
759 if (!task_to_wake) {
760 set_current_state(TASK_INTERRUPTIBLE);
761 while (!signal_pending(current)) {
762 schedule();
763 set_current_state(TASK_INTERRUPTIBLE);
764 }
765 set_current_state(TASK_RUNNING);
766 }
767
768 module_put_and_exit(0);
769 }
770
771 /* extract the host portion of the UNC string */
772 static char *
773 extract_hostname(const char *unc)
774 {
775 const char *src;
776 char *dst, *delim;
777 unsigned int len;
778
779 /* skip double chars at beginning of string */
780 /* BB: check validity of these bytes? */
781 src = unc + 2;
782
783 /* delimiter between hostname and sharename is always '\\' now */
784 delim = strchr(src, '\\');
785 if (!delim)
786 return ERR_PTR(-EINVAL);
787
788 len = delim - src;
789 dst = kmalloc((len + 1), GFP_KERNEL);
790 if (dst == NULL)
791 return ERR_PTR(-ENOMEM);
792
793 memcpy(dst, src, len);
794 dst[len] = '\0';
795
796 return dst;
797 }
798
799 static int
800 cifs_parse_mount_options(char *options, const char *devname,
801 struct smb_vol *vol)
802 {
803 char *value;
804 char *data;
805 unsigned int temp_len, i, j;
806 char separator[2];
807
808 separator[0] = ',';
809 separator[1] = 0;
810
811 if (Local_System_Name[0] != 0)
812 memcpy(vol->source_rfc1001_name, Local_System_Name, 15);
813 else {
814 char *nodename = utsname()->nodename;
815 int n = strnlen(nodename, 15);
816 memset(vol->source_rfc1001_name, 0x20, 15);
817 for (i = 0; i < n; i++) {
818 /* does not have to be perfect mapping since field is
819 informational, only used for servers that do not support
820 port 445 and it can be overridden at mount time */
821 vol->source_rfc1001_name[i] = toupper(nodename[i]);
822 }
823 }
824 vol->source_rfc1001_name[15] = 0;
825 /* null target name indicates to use *SMBSERVR default called name
826 if we end up sending RFC1001 session initialize */
827 vol->target_rfc1001_name[0] = 0;
828 vol->linux_uid = current_uid(); /* use current_euid() instead? */
829 vol->linux_gid = current_gid();
830 vol->dir_mode = S_IRWXUGO;
831 /* 2767 perms indicate mandatory locking support */
832 vol->file_mode = (S_IRWXUGO | S_ISGID) & (~S_IXGRP);
833
834 /* vol->retry default is 0 (i.e. "soft" limited retry not hard retry) */
835 vol->rw = true;
836 /* default is always to request posix paths. */
837 vol->posix_paths = 1;
838
839 if (!options)
840 return 1;
841
842 if (strncmp(options, "sep=", 4) == 0) {
843 if (options[4] != 0) {
844 separator[0] = options[4];
845 options += 5;
846 } else {
847 cFYI(1, ("Null separator not allowed"));
848 }
849 }
850
851 while ((data = strsep(&options, separator)) != NULL) {
852 if (!*data)
853 continue;
854 if ((value = strchr(data, '=')) != NULL)
855 *value++ = '\0';
856
857 /* Have to parse this before we parse for "user" */
858 if (strnicmp(data, "user_xattr", 10) == 0) {
859 vol->no_xattr = 0;
860 } else if (strnicmp(data, "nouser_xattr", 12) == 0) {
861 vol->no_xattr = 1;
862 } else if (strnicmp(data, "user", 4) == 0) {
863 if (!value) {
864 printk(KERN_WARNING
865 "CIFS: invalid or missing username\n");
866 return 1; /* needs_arg; */
867 } else if (!*value) {
868 /* null user, ie anonymous, authentication */
869 vol->nullauth = 1;
870 }
871 if (strnlen(value, 200) < 200) {
872 vol->username = value;
873 } else {
874 printk(KERN_WARNING "CIFS: username too long\n");
875 return 1;
876 }
877 } else if (strnicmp(data, "pass", 4) == 0) {
878 if (!value) {
879 vol->password = NULL;
880 continue;
881 } else if (value[0] == 0) {
882 /* check if string begins with double comma
883 since that would mean the password really
884 does start with a comma, and would not
885 indicate an empty string */
886 if (value[1] != separator[0]) {
887 vol->password = NULL;
888 continue;
889 }
890 }
891 temp_len = strlen(value);
892 /* removed password length check, NTLM passwords
893 can be arbitrarily long */
894
895 /* if comma in password, the string will be
896 prematurely null terminated. Commas in password are
897 specified across the cifs mount interface by a double
898 comma ie ,, and a comma used as in other cases ie ','
899 as a parameter delimiter/separator is single and due
900 to the strsep above is temporarily zeroed. */
901
902 /* NB: password legally can have multiple commas and
903 the only illegal character in a password is null */
904
905 if ((value[temp_len] == 0) &&
906 (value[temp_len+1] == separator[0])) {
907 /* reinsert comma */
908 value[temp_len] = separator[0];
909 temp_len += 2; /* move after second comma */
910 while (value[temp_len] != 0) {
911 if (value[temp_len] == separator[0]) {
912 if (value[temp_len+1] ==
913 separator[0]) {
914 /* skip second comma */
915 temp_len++;
916 } else {
917 /* single comma indicating start
918 of next parm */
919 break;
920 }
921 }
922 temp_len++;
923 }
924 if (value[temp_len] == 0) {
925 options = NULL;
926 } else {
927 value[temp_len] = 0;
928 /* point option to start of next parm */
929 options = value + temp_len + 1;
930 }
931 /* go from value to value + temp_len condensing
932 double commas to singles. Note that this ends up
933 allocating a few bytes too many, which is ok */
934 vol->password = kzalloc(temp_len, GFP_KERNEL);
935 if (vol->password == NULL) {
936 printk(KERN_WARNING "CIFS: no memory "
937 "for password\n");
938 return 1;
939 }
940 for (i = 0, j = 0; i < temp_len; i++, j++) {
941 vol->password[j] = value[i];
942 if (value[i] == separator[0]
943 && value[i+1] == separator[0]) {
944 /* skip second comma */
945 i++;
946 }
947 }
948 vol->password[j] = 0;
949 } else {
950 vol->password = kzalloc(temp_len+1, GFP_KERNEL);
951 if (vol->password == NULL) {
952 printk(KERN_WARNING "CIFS: no memory "
953 "for password\n");
954 return 1;
955 }
956 strcpy(vol->password, value);
957 }
958 } else if (strnicmp(data, "ip", 2) == 0) {
959 if (!value || !*value) {
960 vol->UNCip = NULL;
961 } else if (strnlen(value, 35) < 35) {
962 vol->UNCip = value;
963 } else {
964 printk(KERN_WARNING "CIFS: ip address "
965 "too long\n");
966 return 1;
967 }
968 } else if (strnicmp(data, "sec", 3) == 0) {
969 if (!value || !*value) {
970 cERROR(1, ("no security value specified"));
971 continue;
972 } else if (strnicmp(value, "krb5i", 5) == 0) {
973 vol->secFlg |= CIFSSEC_MAY_KRB5 |
974 CIFSSEC_MUST_SIGN;
975 } else if (strnicmp(value, "krb5p", 5) == 0) {
976 /* vol->secFlg |= CIFSSEC_MUST_SEAL |
977 CIFSSEC_MAY_KRB5; */
978 cERROR(1, ("Krb5 cifs privacy not supported"));
979 return 1;
980 } else if (strnicmp(value, "krb5", 4) == 0) {
981 vol->secFlg |= CIFSSEC_MAY_KRB5;
982 #ifdef CONFIG_CIFS_EXPERIMENTAL
983 } else if (strnicmp(value, "ntlmsspi", 8) == 0) {
984 vol->secFlg |= CIFSSEC_MAY_NTLMSSP |
985 CIFSSEC_MUST_SIGN;
986 } else if (strnicmp(value, "ntlmssp", 7) == 0) {
987 vol->secFlg |= CIFSSEC_MAY_NTLMSSP;
988 #endif
989 } else if (strnicmp(value, "ntlmv2i", 7) == 0) {
990 vol->secFlg |= CIFSSEC_MAY_NTLMV2 |
991 CIFSSEC_MUST_SIGN;
992 } else if (strnicmp(value, "ntlmv2", 6) == 0) {
993 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
994 } else if (strnicmp(value, "ntlmi", 5) == 0) {
995 vol->secFlg |= CIFSSEC_MAY_NTLM |
996 CIFSSEC_MUST_SIGN;
997 } else if (strnicmp(value, "ntlm", 4) == 0) {
998 /* ntlm is default so can be turned off too */
999 vol->secFlg |= CIFSSEC_MAY_NTLM;
1000 } else if (strnicmp(value, "nontlm", 6) == 0) {
1001 /* BB is there a better way to do this? */
1002 vol->secFlg |= CIFSSEC_MAY_NTLMV2;
1003 #ifdef CONFIG_CIFS_WEAK_PW_HASH
1004 } else if (strnicmp(value, "lanman", 6) == 0) {
1005 vol->secFlg |= CIFSSEC_MAY_LANMAN;
1006 #endif
1007 } else if (strnicmp(value, "none", 4) == 0) {
1008 vol->nullauth = 1;
1009 } else {
1010 cERROR(1, ("bad security option: %s", value));
1011 return 1;
1012 }
1013 } else if ((strnicmp(data, "unc", 3) == 0)
1014 || (strnicmp(data, "target", 6) == 0)
1015 || (strnicmp(data, "path", 4) == 0)) {
1016 if (!value || !*value) {
1017 printk(KERN_WARNING "CIFS: invalid path to "
1018 "network resource\n");
1019 return 1; /* needs_arg; */
1020 }
1021 if ((temp_len = strnlen(value, 300)) < 300) {
1022 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1023 if (vol->UNC == NULL)
1024 return 1;
1025 strcpy(vol->UNC, value);
1026 if (strncmp(vol->UNC, "//", 2) == 0) {
1027 vol->UNC[0] = '\\';
1028 vol->UNC[1] = '\\';
1029 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1030 printk(KERN_WARNING
1031 "CIFS: UNC Path does not begin "
1032 "with // or \\\\ \n");
1033 return 1;
1034 }
1035 } else {
1036 printk(KERN_WARNING "CIFS: UNC name too long\n");
1037 return 1;
1038 }
1039 } else if ((strnicmp(data, "domain", 3) == 0)
1040 || (strnicmp(data, "workgroup", 5) == 0)) {
1041 if (!value || !*value) {
1042 printk(KERN_WARNING "CIFS: invalid domain name\n");
1043 return 1; /* needs_arg; */
1044 }
1045 /* BB are there cases in which a comma can be valid in
1046 a domain name and need special handling? */
1047 if (strnlen(value, 256) < 256) {
1048 vol->domainname = value;
1049 cFYI(1, ("Domain name set"));
1050 } else {
1051 printk(KERN_WARNING "CIFS: domain name too "
1052 "long\n");
1053 return 1;
1054 }
1055 } else if (strnicmp(data, "prefixpath", 10) == 0) {
1056 if (!value || !*value) {
1057 printk(KERN_WARNING
1058 "CIFS: invalid path prefix\n");
1059 return 1; /* needs_argument */
1060 }
1061 if ((temp_len = strnlen(value, 1024)) < 1024) {
1062 if (value[0] != '/')
1063 temp_len++; /* missing leading slash */
1064 vol->prepath = kmalloc(temp_len+1, GFP_KERNEL);
1065 if (vol->prepath == NULL)
1066 return 1;
1067 if (value[0] != '/') {
1068 vol->prepath[0] = '/';
1069 strcpy(vol->prepath+1, value);
1070 } else
1071 strcpy(vol->prepath, value);
1072 cFYI(1, ("prefix path %s", vol->prepath));
1073 } else {
1074 printk(KERN_WARNING "CIFS: prefix too long\n");
1075 return 1;
1076 }
1077 } else if (strnicmp(data, "iocharset", 9) == 0) {
1078 if (!value || !*value) {
1079 printk(KERN_WARNING "CIFS: invalid iocharset "
1080 "specified\n");
1081 return 1; /* needs_arg; */
1082 }
1083 if (strnlen(value, 65) < 65) {
1084 if (strnicmp(value, "default", 7))
1085 vol->iocharset = value;
1086 /* if iocharset not set then load_nls_default
1087 is used by caller */
1088 cFYI(1, ("iocharset set to %s", value));
1089 } else {
1090 printk(KERN_WARNING "CIFS: iocharset name "
1091 "too long.\n");
1092 return 1;
1093 }
1094 } else if (strnicmp(data, "uid", 3) == 0) {
1095 if (value && *value) {
1096 vol->linux_uid =
1097 simple_strtoul(value, &value, 0);
1098 vol->override_uid = 1;
1099 }
1100 } else if (strnicmp(data, "gid", 3) == 0) {
1101 if (value && *value) {
1102 vol->linux_gid =
1103 simple_strtoul(value, &value, 0);
1104 vol->override_gid = 1;
1105 }
1106 } else if (strnicmp(data, "file_mode", 4) == 0) {
1107 if (value && *value) {
1108 vol->file_mode =
1109 simple_strtoul(value, &value, 0);
1110 }
1111 } else if (strnicmp(data, "dir_mode", 4) == 0) {
1112 if (value && *value) {
1113 vol->dir_mode =
1114 simple_strtoul(value, &value, 0);
1115 }
1116 } else if (strnicmp(data, "dirmode", 4) == 0) {
1117 if (value && *value) {
1118 vol->dir_mode =
1119 simple_strtoul(value, &value, 0);
1120 }
1121 } else if (strnicmp(data, "port", 4) == 0) {
1122 if (value && *value) {
1123 vol->port =
1124 simple_strtoul(value, &value, 0);
1125 }
1126 } else if (strnicmp(data, "rsize", 5) == 0) {
1127 if (value && *value) {
1128 vol->rsize =
1129 simple_strtoul(value, &value, 0);
1130 }
1131 } else if (strnicmp(data, "wsize", 5) == 0) {
1132 if (value && *value) {
1133 vol->wsize =
1134 simple_strtoul(value, &value, 0);
1135 }
1136 } else if (strnicmp(data, "sockopt", 5) == 0) {
1137 if (value && *value) {
1138 vol->sockopt =
1139 simple_strtoul(value, &value, 0);
1140 }
1141 } else if (strnicmp(data, "netbiosname", 4) == 0) {
1142 if (!value || !*value || (*value == ' ')) {
1143 cFYI(1, ("invalid (empty) netbiosname"));
1144 } else {
1145 memset(vol->source_rfc1001_name, 0x20, 15);
1146 for (i = 0; i < 15; i++) {
1147 /* BB are there cases in which a comma can be
1148 valid in this workstation netbios name (and need
1149 special handling)? */
1150
1151 /* We do not uppercase netbiosname for user */
1152 if (value[i] == 0)
1153 break;
1154 else
1155 vol->source_rfc1001_name[i] =
1156 value[i];
1157 }
1158 /* The string has 16th byte zero still from
1159 set at top of the function */
1160 if ((i == 15) && (value[i] != 0))
1161 printk(KERN_WARNING "CIFS: netbiosname"
1162 " longer than 15 truncated.\n");
1163 }
1164 } else if (strnicmp(data, "servern", 7) == 0) {
1165 /* servernetbiosname specified override *SMBSERVER */
1166 if (!value || !*value || (*value == ' ')) {
1167 cFYI(1, ("empty server netbiosname specified"));
1168 } else {
1169 /* last byte, type, is 0x20 for servr type */
1170 memset(vol->target_rfc1001_name, 0x20, 16);
1171
1172 for (i = 0; i < 15; i++) {
1173 /* BB are there cases in which a comma can be
1174 valid in this workstation netbios name
1175 (and need special handling)? */
1176
1177 /* user or mount helper must uppercase
1178 the netbiosname */
1179 if (value[i] == 0)
1180 break;
1181 else
1182 vol->target_rfc1001_name[i] =
1183 value[i];
1184 }
1185 /* The string has 16th byte zero still from
1186 set at top of the function */
1187 if ((i == 15) && (value[i] != 0))
1188 printk(KERN_WARNING "CIFS: server net"
1189 "biosname longer than 15 truncated.\n");
1190 }
1191 } else if (strnicmp(data, "credentials", 4) == 0) {
1192 /* ignore */
1193 } else if (strnicmp(data, "version", 3) == 0) {
1194 /* ignore */
1195 } else if (strnicmp(data, "guest", 5) == 0) {
1196 /* ignore */
1197 } else if (strnicmp(data, "rw", 2) == 0) {
1198 vol->rw = true;
1199 } else if (strnicmp(data, "noblocksend", 11) == 0) {
1200 vol->noblocksnd = 1;
1201 } else if (strnicmp(data, "noautotune", 10) == 0) {
1202 vol->noautotune = 1;
1203 } else if ((strnicmp(data, "suid", 4) == 0) ||
1204 (strnicmp(data, "nosuid", 6) == 0) ||
1205 (strnicmp(data, "exec", 4) == 0) ||
1206 (strnicmp(data, "noexec", 6) == 0) ||
1207 (strnicmp(data, "nodev", 5) == 0) ||
1208 (strnicmp(data, "noauto", 6) == 0) ||
1209 (strnicmp(data, "dev", 3) == 0)) {
1210 /* The mount tool or mount.cifs helper (if present)
1211 uses these opts to set flags, and the flags are read
1212 by the kernel vfs layer before we get here (ie
1213 before read super) so there is no point trying to
1214 parse these options again and set anything and it
1215 is ok to just ignore them */
1216 continue;
1217 } else if (strnicmp(data, "ro", 2) == 0) {
1218 vol->rw = false;
1219 } else if (strnicmp(data, "hard", 4) == 0) {
1220 vol->retry = 1;
1221 } else if (strnicmp(data, "soft", 4) == 0) {
1222 vol->retry = 0;
1223 } else if (strnicmp(data, "perm", 4) == 0) {
1224 vol->noperm = 0;
1225 } else if (strnicmp(data, "noperm", 6) == 0) {
1226 vol->noperm = 1;
1227 } else if (strnicmp(data, "mapchars", 8) == 0) {
1228 vol->remap = 1;
1229 } else if (strnicmp(data, "nomapchars", 10) == 0) {
1230 vol->remap = 0;
1231 } else if (strnicmp(data, "sfu", 3) == 0) {
1232 vol->sfu_emul = 1;
1233 } else if (strnicmp(data, "nosfu", 5) == 0) {
1234 vol->sfu_emul = 0;
1235 } else if (strnicmp(data, "nodfs", 5) == 0) {
1236 vol->nodfs = 1;
1237 } else if (strnicmp(data, "posixpaths", 10) == 0) {
1238 vol->posix_paths = 1;
1239 } else if (strnicmp(data, "noposixpaths", 12) == 0) {
1240 vol->posix_paths = 0;
1241 } else if (strnicmp(data, "nounix", 6) == 0) {
1242 vol->no_linux_ext = 1;
1243 } else if (strnicmp(data, "nolinux", 7) == 0) {
1244 vol->no_linux_ext = 1;
1245 } else if ((strnicmp(data, "nocase", 6) == 0) ||
1246 (strnicmp(data, "ignorecase", 10) == 0)) {
1247 vol->nocase = 1;
1248 } else if (strnicmp(data, "brl", 3) == 0) {
1249 vol->nobrl = 0;
1250 } else if ((strnicmp(data, "nobrl", 5) == 0) ||
1251 (strnicmp(data, "nolock", 6) == 0)) {
1252 vol->nobrl = 1;
1253 /* turn off mandatory locking in mode
1254 if remote locking is turned off since the
1255 local vfs will do advisory */
1256 if (vol->file_mode ==
1257 (S_IALLUGO & ~(S_ISUID | S_IXGRP)))
1258 vol->file_mode = S_IALLUGO;
1259 } else if (strnicmp(data, "forcemandatorylock", 9) == 0) {
1260 /* will take the shorter form "forcemand" as well */
1261 /* This mount option will force use of mandatory
1262 (DOS/Windows style) byte range locks, instead of
1263 using posix advisory byte range locks, even if the
1264 Unix extensions are available and posix locks would
1265 be supported otherwise. If Unix extensions are not
1266 negotiated this has no effect since mandatory locks
1267 would be used (mandatory locks is all that those
1268 those servers support) */
1269 vol->mand_lock = 1;
1270 } else if (strnicmp(data, "setuids", 7) == 0) {
1271 vol->setuids = 1;
1272 } else if (strnicmp(data, "nosetuids", 9) == 0) {
1273 vol->setuids = 0;
1274 } else if (strnicmp(data, "dynperm", 7) == 0) {
1275 vol->dynperm = true;
1276 } else if (strnicmp(data, "nodynperm", 9) == 0) {
1277 vol->dynperm = false;
1278 } else if (strnicmp(data, "nohard", 6) == 0) {
1279 vol->retry = 0;
1280 } else if (strnicmp(data, "nosoft", 6) == 0) {
1281 vol->retry = 1;
1282 } else if (strnicmp(data, "nointr", 6) == 0) {
1283 vol->intr = 0;
1284 } else if (strnicmp(data, "intr", 4) == 0) {
1285 vol->intr = 1;
1286 } else if (strnicmp(data, "nostrictsync", 12) == 0) {
1287 vol->nostrictsync = 1;
1288 } else if (strnicmp(data, "strictsync", 10) == 0) {
1289 vol->nostrictsync = 0;
1290 } else if (strnicmp(data, "serverino", 7) == 0) {
1291 vol->server_ino = 1;
1292 } else if (strnicmp(data, "noserverino", 9) == 0) {
1293 vol->server_ino = 0;
1294 } else if (strnicmp(data, "cifsacl", 7) == 0) {
1295 vol->cifs_acl = 1;
1296 } else if (strnicmp(data, "nocifsacl", 9) == 0) {
1297 vol->cifs_acl = 0;
1298 } else if (strnicmp(data, "acl", 3) == 0) {
1299 vol->no_psx_acl = 0;
1300 } else if (strnicmp(data, "noacl", 5) == 0) {
1301 vol->no_psx_acl = 1;
1302 #ifdef CONFIG_CIFS_EXPERIMENTAL
1303 } else if (strnicmp(data, "locallease", 6) == 0) {
1304 vol->local_lease = 1;
1305 #endif
1306 } else if (strnicmp(data, "sign", 4) == 0) {
1307 vol->secFlg |= CIFSSEC_MUST_SIGN;
1308 } else if (strnicmp(data, "seal", 4) == 0) {
1309 /* we do not do the following in secFlags because seal
1310 is a per tree connection (mount) not a per socket
1311 or per-smb connection option in the protocol */
1312 /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
1313 vol->seal = 1;
1314 } else if (strnicmp(data, "direct", 6) == 0) {
1315 vol->direct_io = 1;
1316 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
1317 vol->direct_io = 1;
1318 } else if (strnicmp(data, "in6_addr", 8) == 0) {
1319 if (!value || !*value) {
1320 vol->in6_addr = NULL;
1321 } else if (strnlen(value, 49) == 48) {
1322 vol->in6_addr = value;
1323 } else {
1324 printk(KERN_WARNING "CIFS: ip v6 address not "
1325 "48 characters long\n");
1326 return 1;
1327 }
1328 } else if (strnicmp(data, "noac", 4) == 0) {
1329 printk(KERN_WARNING "CIFS: Mount option noac not "
1330 "supported. Instead set "
1331 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
1332 } else
1333 printk(KERN_WARNING "CIFS: Unknown mount option %s\n",
1334 data);
1335 }
1336 if (vol->UNC == NULL) {
1337 if (devname == NULL) {
1338 printk(KERN_WARNING "CIFS: Missing UNC name for mount "
1339 "target\n");
1340 return 1;
1341 }
1342 if ((temp_len = strnlen(devname, 300)) < 300) {
1343 vol->UNC = kmalloc(temp_len+1, GFP_KERNEL);
1344 if (vol->UNC == NULL)
1345 return 1;
1346 strcpy(vol->UNC, devname);
1347 if (strncmp(vol->UNC, "//", 2) == 0) {
1348 vol->UNC[0] = '\\';
1349 vol->UNC[1] = '\\';
1350 } else if (strncmp(vol->UNC, "\\\\", 2) != 0) {
1351 printk(KERN_WARNING "CIFS: UNC Path does not "
1352 "begin with // or \\\\ \n");
1353 return 1;
1354 }
1355 value = strpbrk(vol->UNC+2, "/\\");
1356 if (value)
1357 *value = '\\';
1358 } else {
1359 printk(KERN_WARNING "CIFS: UNC name too long\n");
1360 return 1;
1361 }
1362 }
1363 if (vol->UNCip == NULL)
1364 vol->UNCip = &vol->UNC[2];
1365
1366 return 0;
1367 }
1368
1369 static struct TCP_Server_Info *
1370 cifs_find_tcp_session(struct sockaddr_storage *addr)
1371 {
1372 struct list_head *tmp;
1373 struct TCP_Server_Info *server;
1374 struct sockaddr_in *addr4 = (struct sockaddr_in *) addr;
1375 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *) addr;
1376
1377 write_lock(&cifs_tcp_ses_lock);
1378 list_for_each(tmp, &cifs_tcp_ses_list) {
1379 server = list_entry(tmp, struct TCP_Server_Info,
1380 tcp_ses_list);
1381 /*
1382 * the demux thread can exit on its own while still in CifsNew
1383 * so don't accept any sockets in that state. Since the
1384 * tcpStatus never changes back to CifsNew it's safe to check
1385 * for this without a lock.
1386 */
1387 if (server->tcpStatus == CifsNew)
1388 continue;
1389
1390 if (addr->ss_family == AF_INET &&
1391 (addr4->sin_addr.s_addr !=
1392 server->addr.sockAddr.sin_addr.s_addr))
1393 continue;
1394 else if (addr->ss_family == AF_INET6 &&
1395 !ipv6_addr_equal(&server->addr.sockAddr6.sin6_addr,
1396 &addr6->sin6_addr))
1397 continue;
1398
1399 ++server->srv_count;
1400 write_unlock(&cifs_tcp_ses_lock);
1401 cFYI(1, ("Existing tcp session with server found"));
1402 return server;
1403 }
1404 write_unlock(&cifs_tcp_ses_lock);
1405 return NULL;
1406 }
1407
1408 static void
1409 cifs_put_tcp_session(struct TCP_Server_Info *server)
1410 {
1411 struct task_struct *task;
1412
1413 write_lock(&cifs_tcp_ses_lock);
1414 if (--server->srv_count > 0) {
1415 write_unlock(&cifs_tcp_ses_lock);
1416 return;
1417 }
1418
1419 list_del_init(&server->tcp_ses_list);
1420 write_unlock(&cifs_tcp_ses_lock);
1421
1422 spin_lock(&GlobalMid_Lock);
1423 server->tcpStatus = CifsExiting;
1424 spin_unlock(&GlobalMid_Lock);
1425
1426 task = xchg(&server->tsk, NULL);
1427 if (task)
1428 force_sig(SIGKILL, task);
1429 }
1430
1431 static struct TCP_Server_Info *
1432 cifs_get_tcp_session(struct smb_vol *volume_info)
1433 {
1434 struct TCP_Server_Info *tcp_ses = NULL;
1435 struct sockaddr_storage addr;
1436 struct sockaddr_in *sin_server = (struct sockaddr_in *) &addr;
1437 struct sockaddr_in6 *sin_server6 = (struct sockaddr_in6 *) &addr;
1438 int rc;
1439
1440 memset(&addr, 0, sizeof(struct sockaddr_storage));
1441
1442 if (volume_info->UNCip && volume_info->UNC) {
1443 rc = cifs_inet_pton(AF_INET, volume_info->UNCip,
1444 &sin_server->sin_addr.s_addr);
1445
1446 if (rc <= 0) {
1447 /* not ipv4 address, try ipv6 */
1448 rc = cifs_inet_pton(AF_INET6, volume_info->UNCip,
1449 &sin_server6->sin6_addr.in6_u);
1450 if (rc > 0)
1451 addr.ss_family = AF_INET6;
1452 } else {
1453 addr.ss_family = AF_INET;
1454 }
1455
1456 if (rc <= 0) {
1457 /* we failed translating address */
1458 rc = -EINVAL;
1459 goto out_err;
1460 }
1461
1462 cFYI(1, ("UNC: %s ip: %s", volume_info->UNC,
1463 volume_info->UNCip));
1464 } else if (volume_info->UNCip) {
1465 /* BB using ip addr as tcp_ses name to connect to the
1466 DFS root below */
1467 cERROR(1, ("Connecting to DFS root not implemented yet"));
1468 rc = -EINVAL;
1469 goto out_err;
1470 } else /* which tcp_sess DFS root would we conect to */ {
1471 cERROR(1,
1472 ("CIFS mount error: No UNC path (e.g. -o "
1473 "unc=//192.168.1.100/public) specified"));
1474 rc = -EINVAL;
1475 goto out_err;
1476 }
1477
1478 /* see if we already have a matching tcp_ses */
1479 tcp_ses = cifs_find_tcp_session(&addr);
1480 if (tcp_ses)
1481 return tcp_ses;
1482
1483 tcp_ses = kzalloc(sizeof(struct TCP_Server_Info), GFP_KERNEL);
1484 if (!tcp_ses) {
1485 rc = -ENOMEM;
1486 goto out_err;
1487 }
1488
1489 tcp_ses->hostname = extract_hostname(volume_info->UNC);
1490 if (IS_ERR(tcp_ses->hostname)) {
1491 rc = PTR_ERR(tcp_ses->hostname);
1492 goto out_err;
1493 }
1494
1495 tcp_ses->noblocksnd = volume_info->noblocksnd;
1496 tcp_ses->noautotune = volume_info->noautotune;
1497 atomic_set(&tcp_ses->inFlight, 0);
1498 init_waitqueue_head(&tcp_ses->response_q);
1499 init_waitqueue_head(&tcp_ses->request_q);
1500 INIT_LIST_HEAD(&tcp_ses->pending_mid_q);
1501 mutex_init(&tcp_ses->srv_mutex);
1502 memcpy(tcp_ses->workstation_RFC1001_name,
1503 volume_info->source_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1504 memcpy(tcp_ses->server_RFC1001_name,
1505 volume_info->target_rfc1001_name, RFC1001_NAME_LEN_WITH_NULL);
1506 tcp_ses->sequence_number = 0;
1507 INIT_LIST_HEAD(&tcp_ses->tcp_ses_list);
1508 INIT_LIST_HEAD(&tcp_ses->smb_ses_list);
1509
1510 /*
1511 * at this point we are the only ones with the pointer
1512 * to the struct since the kernel thread not created yet
1513 * no need to spinlock this init of tcpStatus or srv_count
1514 */
1515 tcp_ses->tcpStatus = CifsNew;
1516 ++tcp_ses->srv_count;
1517
1518 if (addr.ss_family == AF_INET6) {
1519 cFYI(1, ("attempting ipv6 connect"));
1520 /* BB should we allow ipv6 on port 139? */
1521 /* other OS never observed in Wild doing 139 with v6 */
1522 memcpy(&tcp_ses->addr.sockAddr6, sin_server6,
1523 sizeof(struct sockaddr_in6));
1524 sin_server6->sin6_port = htons(volume_info->port);
1525 rc = ipv6_connect(tcp_ses);
1526 } else {
1527 memcpy(&tcp_ses->addr.sockAddr, sin_server,
1528 sizeof(struct sockaddr_in));
1529 sin_server->sin_port = htons(volume_info->port);
1530 rc = ipv4_connect(tcp_ses);
1531 }
1532 if (rc < 0) {
1533 cERROR(1, ("Error connecting to socket. Aborting operation"));
1534 goto out_err;
1535 }
1536
1537 /*
1538 * since we're in a cifs function already, we know that
1539 * this will succeed. No need for try_module_get().
1540 */
1541 __module_get(THIS_MODULE);
1542 tcp_ses->tsk = kthread_run((void *)(void *)cifs_demultiplex_thread,
1543 tcp_ses, "cifsd");
1544 if (IS_ERR(tcp_ses->tsk)) {
1545 rc = PTR_ERR(tcp_ses->tsk);
1546 cERROR(1, ("error %d create cifsd thread", rc));
1547 module_put(THIS_MODULE);
1548 goto out_err;
1549 }
1550
1551 /* thread spawned, put it on the list */
1552 write_lock(&cifs_tcp_ses_lock);
1553 list_add(&tcp_ses->tcp_ses_list, &cifs_tcp_ses_list);
1554 write_unlock(&cifs_tcp_ses_lock);
1555
1556 return tcp_ses;
1557
1558 out_err:
1559 if (tcp_ses) {
1560 kfree(tcp_ses->hostname);
1561 if (tcp_ses->ssocket)
1562 sock_release(tcp_ses->ssocket);
1563 kfree(tcp_ses);
1564 }
1565 return ERR_PTR(rc);
1566 }
1567
1568 static struct cifsSesInfo *
1569 cifs_find_smb_ses(struct TCP_Server_Info *server, char *username)
1570 {
1571 struct list_head *tmp;
1572 struct cifsSesInfo *ses;
1573
1574 write_lock(&cifs_tcp_ses_lock);
1575 list_for_each(tmp, &server->smb_ses_list) {
1576 ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
1577 if (strncmp(ses->userName, username, MAX_USERNAME_SIZE))
1578 continue;
1579
1580 ++ses->ses_count;
1581 write_unlock(&cifs_tcp_ses_lock);
1582 return ses;
1583 }
1584 write_unlock(&cifs_tcp_ses_lock);
1585 return NULL;
1586 }
1587
1588 static void
1589 cifs_put_smb_ses(struct cifsSesInfo *ses)
1590 {
1591 int xid;
1592 struct TCP_Server_Info *server = ses->server;
1593
1594 write_lock(&cifs_tcp_ses_lock);
1595 if (--ses->ses_count > 0) {
1596 write_unlock(&cifs_tcp_ses_lock);
1597 return;
1598 }
1599
1600 list_del_init(&ses->smb_ses_list);
1601 write_unlock(&cifs_tcp_ses_lock);
1602
1603 if (ses->status == CifsGood) {
1604 xid = GetXid();
1605 CIFSSMBLogoff(xid, ses);
1606 _FreeXid(xid);
1607 }
1608 sesInfoFree(ses);
1609 cifs_put_tcp_session(server);
1610 }
1611
1612 static struct cifsTconInfo *
1613 cifs_find_tcon(struct cifsSesInfo *ses, const char *unc)
1614 {
1615 struct list_head *tmp;
1616 struct cifsTconInfo *tcon;
1617
1618 write_lock(&cifs_tcp_ses_lock);
1619 list_for_each(tmp, &ses->tcon_list) {
1620 tcon = list_entry(tmp, struct cifsTconInfo, tcon_list);
1621 if (tcon->tidStatus == CifsExiting)
1622 continue;
1623 if (strncmp(tcon->treeName, unc, MAX_TREE_SIZE))
1624 continue;
1625
1626 ++tcon->tc_count;
1627 write_unlock(&cifs_tcp_ses_lock);
1628 return tcon;
1629 }
1630 write_unlock(&cifs_tcp_ses_lock);
1631 return NULL;
1632 }
1633
1634 static void
1635 cifs_put_tcon(struct cifsTconInfo *tcon)
1636 {
1637 int xid;
1638 struct cifsSesInfo *ses = tcon->ses;
1639
1640 write_lock(&cifs_tcp_ses_lock);
1641 if (--tcon->tc_count > 0) {
1642 write_unlock(&cifs_tcp_ses_lock);
1643 return;
1644 }
1645
1646 list_del_init(&tcon->tcon_list);
1647 write_unlock(&cifs_tcp_ses_lock);
1648
1649 xid = GetXid();
1650 CIFSSMBTDis(xid, tcon);
1651 _FreeXid(xid);
1652
1653 DeleteTconOplockQEntries(tcon);
1654 tconInfoFree(tcon);
1655 cifs_put_smb_ses(ses);
1656 }
1657
1658 int
1659 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
1660 const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
1661 struct dfs_info3_param **preferrals, int remap)
1662 {
1663 char *temp_unc;
1664 int rc = 0;
1665
1666 *pnum_referrals = 0;
1667 *preferrals = NULL;
1668
1669 if (pSesInfo->ipc_tid == 0) {
1670 temp_unc = kmalloc(2 /* for slashes */ +
1671 strnlen(pSesInfo->serverName,
1672 SERVER_NAME_LEN_WITH_NULL * 2)
1673 + 1 + 4 /* slash IPC$ */ + 2,
1674 GFP_KERNEL);
1675 if (temp_unc == NULL)
1676 return -ENOMEM;
1677 temp_unc[0] = '\\';
1678 temp_unc[1] = '\\';
1679 strcpy(temp_unc + 2, pSesInfo->serverName);
1680 strcpy(temp_unc + 2 + strlen(pSesInfo->serverName), "\\IPC$");
1681 rc = CIFSTCon(xid, pSesInfo, temp_unc, NULL, nls_codepage);
1682 cFYI(1,
1683 ("CIFS Tcon rc = %d ipc_tid = %d", rc, pSesInfo->ipc_tid));
1684 kfree(temp_unc);
1685 }
1686 if (rc == 0)
1687 rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
1688 pnum_referrals, nls_codepage, remap);
1689 /* BB map targetUNCs to dfs_info3 structures, here or
1690 in CIFSGetDFSRefer BB */
1691
1692 return rc;
1693 }
1694
1695 #ifdef CONFIG_DEBUG_LOCK_ALLOC
1696 static struct lock_class_key cifs_key[2];
1697 static struct lock_class_key cifs_slock_key[2];
1698
1699 static inline void
1700 cifs_reclassify_socket4(struct socket *sock)
1701 {
1702 struct sock *sk = sock->sk;
1703 BUG_ON(sock_owned_by_user(sk));
1704 sock_lock_init_class_and_name(sk, "slock-AF_INET-CIFS",
1705 &cifs_slock_key[0], "sk_lock-AF_INET-CIFS", &cifs_key[0]);
1706 }
1707
1708 static inline void
1709 cifs_reclassify_socket6(struct socket *sock)
1710 {
1711 struct sock *sk = sock->sk;
1712 BUG_ON(sock_owned_by_user(sk));
1713 sock_lock_init_class_and_name(sk, "slock-AF_INET6-CIFS",
1714 &cifs_slock_key[1], "sk_lock-AF_INET6-CIFS", &cifs_key[1]);
1715 }
1716 #else
1717 static inline void
1718 cifs_reclassify_socket4(struct socket *sock)
1719 {
1720 }
1721
1722 static inline void
1723 cifs_reclassify_socket6(struct socket *sock)
1724 {
1725 }
1726 #endif
1727
1728 /* See RFC1001 section 14 on representation of Netbios names */
1729 static void rfc1002mangle(char *target, char *source, unsigned int length)
1730 {
1731 unsigned int i, j;
1732
1733 for (i = 0, j = 0; i < (length); i++) {
1734 /* mask a nibble at a time and encode */
1735 target[j] = 'A' + (0x0F & (source[i] >> 4));
1736 target[j+1] = 'A' + (0x0F & source[i]);
1737 j += 2;
1738 }
1739
1740 }
1741
1742
1743 static int
1744 ipv4_connect(struct TCP_Server_Info *server)
1745 {
1746 int rc = 0;
1747 bool connected = false;
1748 __be16 orig_port = 0;
1749 struct socket *socket = server->ssocket;
1750
1751 if (socket == NULL) {
1752 rc = sock_create_kern(PF_INET, SOCK_STREAM,
1753 IPPROTO_TCP, &socket);
1754 if (rc < 0) {
1755 cERROR(1, ("Error %d creating socket", rc));
1756 return rc;
1757 }
1758
1759 /* BB other socket options to set KEEPALIVE, NODELAY? */
1760 cFYI(1, ("Socket created"));
1761 server->ssocket = socket;
1762 socket->sk->sk_allocation = GFP_NOFS;
1763 cifs_reclassify_socket4(socket);
1764 }
1765
1766 /* user overrode default port */
1767 if (server->addr.sockAddr.sin_port) {
1768 rc = socket->ops->connect(socket, (struct sockaddr *)
1769 &server->addr.sockAddr,
1770 sizeof(struct sockaddr_in), 0);
1771 if (rc >= 0)
1772 connected = true;
1773 }
1774
1775 if (!connected) {
1776 /* save original port so we can retry user specified port
1777 later if fall back ports fail this time */
1778 orig_port = server->addr.sockAddr.sin_port;
1779
1780 /* do not retry on the same port we just failed on */
1781 if (server->addr.sockAddr.sin_port != htons(CIFS_PORT)) {
1782 server->addr.sockAddr.sin_port = htons(CIFS_PORT);
1783 rc = socket->ops->connect(socket,
1784 (struct sockaddr *)
1785 &server->addr.sockAddr,
1786 sizeof(struct sockaddr_in), 0);
1787 if (rc >= 0)
1788 connected = true;
1789 }
1790 }
1791 if (!connected) {
1792 server->addr.sockAddr.sin_port = htons(RFC1001_PORT);
1793 rc = socket->ops->connect(socket, (struct sockaddr *)
1794 &server->addr.sockAddr,
1795 sizeof(struct sockaddr_in), 0);
1796 if (rc >= 0)
1797 connected = true;
1798 }
1799
1800 /* give up here - unless we want to retry on different
1801 protocol families some day */
1802 if (!connected) {
1803 if (orig_port)
1804 server->addr.sockAddr.sin_port = orig_port;
1805 cFYI(1, ("Error %d connecting to server via ipv4", rc));
1806 sock_release(socket);
1807 server->ssocket = NULL;
1808 return rc;
1809 }
1810
1811
1812 /*
1813 * Eventually check for other socket options to change from
1814 * the default. sock_setsockopt not used because it expects
1815 * user space buffer
1816 */
1817 socket->sk->sk_rcvtimeo = 7 * HZ;
1818 socket->sk->sk_sndtimeo = 5 * HZ;
1819
1820 /* make the bufsizes depend on wsize/rsize and max requests */
1821 if (server->noautotune) {
1822 if (socket->sk->sk_sndbuf < (200 * 1024))
1823 socket->sk->sk_sndbuf = 200 * 1024;
1824 if (socket->sk->sk_rcvbuf < (140 * 1024))
1825 socket->sk->sk_rcvbuf = 140 * 1024;
1826 }
1827
1828 cFYI(1, ("sndbuf %d rcvbuf %d rcvtimeo 0x%lx",
1829 socket->sk->sk_sndbuf,
1830 socket->sk->sk_rcvbuf, socket->sk->sk_rcvtimeo));
1831
1832 /* send RFC1001 sessinit */
1833 if (server->addr.sockAddr.sin_port == htons(RFC1001_PORT)) {
1834 /* some servers require RFC1001 sessinit before sending
1835 negprot - BB check reconnection in case where second
1836 sessinit is sent but no second negprot */
1837 struct rfc1002_session_packet *ses_init_buf;
1838 struct smb_hdr *smb_buf;
1839 ses_init_buf = kzalloc(sizeof(struct rfc1002_session_packet),
1840 GFP_KERNEL);
1841 if (ses_init_buf) {
1842 ses_init_buf->trailer.session_req.called_len = 32;
1843 if (server->server_RFC1001_name &&
1844 server->server_RFC1001_name[0] != 0)
1845 rfc1002mangle(ses_init_buf->trailer.
1846 session_req.called_name,
1847 server->server_RFC1001_name,
1848 RFC1001_NAME_LEN_WITH_NULL);
1849 else
1850 rfc1002mangle(ses_init_buf->trailer.
1851 session_req.called_name,
1852 DEFAULT_CIFS_CALLED_NAME,
1853 RFC1001_NAME_LEN_WITH_NULL);
1854
1855 ses_init_buf->trailer.session_req.calling_len = 32;
1856
1857 /* calling name ends in null (byte 16) from old smb
1858 convention. */
1859 if (server->workstation_RFC1001_name &&
1860 server->workstation_RFC1001_name[0] != 0)
1861 rfc1002mangle(ses_init_buf->trailer.
1862 session_req.calling_name,
1863 server->workstation_RFC1001_name,
1864 RFC1001_NAME_LEN_WITH_NULL);
1865 else
1866 rfc1002mangle(ses_init_buf->trailer.
1867 session_req.calling_name,
1868 "LINUX_CIFS_CLNT",
1869 RFC1001_NAME_LEN_WITH_NULL);
1870
1871 ses_init_buf->trailer.session_req.scope1 = 0;
1872 ses_init_buf->trailer.session_req.scope2 = 0;
1873 smb_buf = (struct smb_hdr *)ses_init_buf;
1874 /* sizeof RFC1002_SESSION_REQUEST with no scope */
1875 smb_buf->smb_buf_length = 0x81000044;
1876 rc = smb_send(server, smb_buf, 0x44);
1877 kfree(ses_init_buf);
1878 msleep(1); /* RFC1001 layer in at least one server
1879 requires very short break before negprot
1880 presumably because not expecting negprot
1881 to follow so fast. This is a simple
1882 solution that works without
1883 complicating the code and causes no
1884 significant slowing down on mount
1885 for everyone else */
1886 }
1887 /* else the negprot may still work without this
1888 even though malloc failed */
1889
1890 }
1891
1892 return rc;
1893 }
1894
1895 static int
1896 ipv6_connect(struct TCP_Server_Info *server)
1897 {
1898 int rc = 0;
1899 bool connected = false;
1900 __be16 orig_port = 0;
1901 struct socket *socket = server->ssocket;
1902
1903 if (socket == NULL) {
1904 rc = sock_create_kern(PF_INET6, SOCK_STREAM,
1905 IPPROTO_TCP, &socket);
1906 if (rc < 0) {
1907 cERROR(1, ("Error %d creating ipv6 socket", rc));
1908 socket = NULL;
1909 return rc;
1910 }
1911
1912 /* BB other socket options to set KEEPALIVE, NODELAY? */
1913 cFYI(1, ("ipv6 Socket created"));
1914 server->ssocket = socket;
1915 socket->sk->sk_allocation = GFP_NOFS;
1916 cifs_reclassify_socket6(socket);
1917 }
1918
1919 /* user overrode default port */
1920 if (server->addr.sockAddr6.sin6_port) {
1921 rc = socket->ops->connect(socket,
1922 (struct sockaddr *) &server->addr.sockAddr6,
1923 sizeof(struct sockaddr_in6), 0);
1924 if (rc >= 0)
1925 connected = true;
1926 }
1927
1928 if (!connected) {
1929 /* save original port so we can retry user specified port
1930 later if fall back ports fail this time */
1931
1932 orig_port = server->addr.sockAddr6.sin6_port;
1933 /* do not retry on the same port we just failed on */
1934 if (server->addr.sockAddr6.sin6_port != htons(CIFS_PORT)) {
1935 server->addr.sockAddr6.sin6_port = htons(CIFS_PORT);
1936 rc = socket->ops->connect(socket, (struct sockaddr *)
1937 &server->addr.sockAddr6,
1938 sizeof(struct sockaddr_in6), 0);
1939 if (rc >= 0)
1940 connected = true;
1941 }
1942 }
1943 if (!connected) {
1944 server->addr.sockAddr6.sin6_port = htons(RFC1001_PORT);
1945 rc = socket->ops->connect(socket, (struct sockaddr *)
1946 &server->addr.sockAddr6,
1947 sizeof(struct sockaddr_in6), 0);
1948 if (rc >= 0)
1949 connected = true;
1950 }
1951
1952 /* give up here - unless we want to retry on different
1953 protocol families some day */
1954 if (!connected) {
1955 if (orig_port)
1956 server->addr.sockAddr6.sin6_port = orig_port;
1957 cFYI(1, ("Error %d connecting to server via ipv6", rc));
1958 sock_release(socket);
1959 server->ssocket = NULL;
1960 return rc;
1961 }
1962
1963 /*
1964 * Eventually check for other socket options to change from
1965 * the default. sock_setsockopt not used because it expects
1966 * user space buffer
1967 */
1968 socket->sk->sk_rcvtimeo = 7 * HZ;
1969 socket->sk->sk_sndtimeo = 5 * HZ;
1970 server->ssocket = socket;
1971
1972 return rc;
1973 }
1974
1975 void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
1976 struct super_block *sb, struct smb_vol *vol_info)
1977 {
1978 /* if we are reconnecting then should we check to see if
1979 * any requested capabilities changed locally e.g. via
1980 * remount but we can not do much about it here
1981 * if they have (even if we could detect it by the following)
1982 * Perhaps we could add a backpointer to array of sb from tcon
1983 * or if we change to make all sb to same share the same
1984 * sb as NFS - then we only have one backpointer to sb.
1985 * What if we wanted to mount the server share twice once with
1986 * and once without posixacls or posix paths? */
1987 __u64 saved_cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
1988
1989 if (vol_info && vol_info->no_linux_ext) {
1990 tcon->fsUnixInfo.Capability = 0;
1991 tcon->unix_ext = 0; /* Unix Extensions disabled */
1992 cFYI(1, ("Linux protocol extensions disabled"));
1993 return;
1994 } else if (vol_info)
1995 tcon->unix_ext = 1; /* Unix Extensions supported */
1996
1997 if (tcon->unix_ext == 0) {
1998 cFYI(1, ("Unix extensions disabled so not set on reconnect"));
1999 return;
2000 }
2001
2002 if (!CIFSSMBQFSUnixInfo(xid, tcon)) {
2003 __u64 cap = le64_to_cpu(tcon->fsUnixInfo.Capability);
2004
2005 /* check for reconnect case in which we do not
2006 want to change the mount behavior if we can avoid it */
2007 if (vol_info == NULL) {
2008 /* turn off POSIX ACL and PATHNAMES if not set
2009 originally at mount time */
2010 if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
2011 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2012 if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2013 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2014 cERROR(1, ("POSIXPATH support change"));
2015 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2016 } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
2017 cERROR(1, ("possible reconnect error"));
2018 cERROR(1,
2019 ("server disabled POSIX path support"));
2020 }
2021 }
2022
2023 cap &= CIFS_UNIX_CAP_MASK;
2024 if (vol_info && vol_info->no_psx_acl)
2025 cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
2026 else if (CIFS_UNIX_POSIX_ACL_CAP & cap) {
2027 cFYI(1, ("negotiated posix acl support"));
2028 if (sb)
2029 sb->s_flags |= MS_POSIXACL;
2030 }
2031
2032 if (vol_info && vol_info->posix_paths == 0)
2033 cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
2034 else if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) {
2035 cFYI(1, ("negotiate posix pathnames"));
2036 if (sb)
2037 CIFS_SB(sb)->mnt_cifs_flags |=
2038 CIFS_MOUNT_POSIX_PATHS;
2039 }
2040
2041 /* We might be setting the path sep back to a different
2042 form if we are reconnecting and the server switched its
2043 posix path capability for this share */
2044 if (sb && (CIFS_SB(sb)->prepathlen > 0))
2045 CIFS_SB(sb)->prepath[0] = CIFS_DIR_SEP(CIFS_SB(sb));
2046
2047 if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
2048 if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
2049 CIFS_SB(sb)->rsize = 127 * 1024;
2050 cFYI(DBG2,
2051 ("larger reads not supported by srv"));
2052 }
2053 }
2054
2055
2056 cFYI(1, ("Negotiate caps 0x%x", (int)cap));
2057 #ifdef CONFIG_CIFS_DEBUG2
2058 if (cap & CIFS_UNIX_FCNTL_CAP)
2059 cFYI(1, ("FCNTL cap"));
2060 if (cap & CIFS_UNIX_EXTATTR_CAP)
2061 cFYI(1, ("EXTATTR cap"));
2062 if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
2063 cFYI(1, ("POSIX path cap"));
2064 if (cap & CIFS_UNIX_XATTR_CAP)
2065 cFYI(1, ("XATTR cap"));
2066 if (cap & CIFS_UNIX_POSIX_ACL_CAP)
2067 cFYI(1, ("POSIX ACL cap"));
2068 if (cap & CIFS_UNIX_LARGE_READ_CAP)
2069 cFYI(1, ("very large read cap"));
2070 if (cap & CIFS_UNIX_LARGE_WRITE_CAP)
2071 cFYI(1, ("very large write cap"));
2072 #endif /* CIFS_DEBUG2 */
2073 if (CIFSSMBSetFSUnixInfo(xid, tcon, cap)) {
2074 if (vol_info == NULL) {
2075 cFYI(1, ("resetting capabilities failed"));
2076 } else
2077 cERROR(1, ("Negotiating Unix capabilities "
2078 "with the server failed. Consider "
2079 "mounting with the Unix Extensions\n"
2080 "disabled, if problems are found, "
2081 "by specifying the nounix mount "
2082 "option."));
2083
2084 }
2085 }
2086 }
2087
2088 static void
2089 convert_delimiter(char *path, char delim)
2090 {
2091 int i;
2092 char old_delim;
2093
2094 if (path == NULL)
2095 return;
2096
2097 if (delim == '/')
2098 old_delim = '\\';
2099 else
2100 old_delim = '/';
2101
2102 for (i = 0; path[i] != '\0'; i++) {
2103 if (path[i] == old_delim)
2104 path[i] = delim;
2105 }
2106 }
2107
2108 static void setup_cifs_sb(struct smb_vol *pvolume_info,
2109 struct cifs_sb_info *cifs_sb)
2110 {
2111 if (pvolume_info->rsize > CIFSMaxBufSize) {
2112 cERROR(1, ("rsize %d too large, using MaxBufSize",
2113 pvolume_info->rsize));
2114 cifs_sb->rsize = CIFSMaxBufSize;
2115 } else if ((pvolume_info->rsize) &&
2116 (pvolume_info->rsize <= CIFSMaxBufSize))
2117 cifs_sb->rsize = pvolume_info->rsize;
2118 else /* default */
2119 cifs_sb->rsize = CIFSMaxBufSize;
2120
2121 if (pvolume_info->wsize > PAGEVEC_SIZE * PAGE_CACHE_SIZE) {
2122 cERROR(1, ("wsize %d too large, using 4096 instead",
2123 pvolume_info->wsize));
2124 cifs_sb->wsize = 4096;
2125 } else if (pvolume_info->wsize)
2126 cifs_sb->wsize = pvolume_info->wsize;
2127 else
2128 cifs_sb->wsize = min_t(const int,
2129 PAGEVEC_SIZE * PAGE_CACHE_SIZE,
2130 127*1024);
2131 /* old default of CIFSMaxBufSize was too small now
2132 that SMB Write2 can send multiple pages in kvec.
2133 RFC1001 does not describe what happens when frame
2134 bigger than 128K is sent so use that as max in
2135 conjunction with 52K kvec constraint on arch with 4K
2136 page size */
2137
2138 if (cifs_sb->rsize < 2048) {
2139 cifs_sb->rsize = 2048;
2140 /* Windows ME may prefer this */
2141 cFYI(1, ("readsize set to minimum: 2048"));
2142 }
2143 /* calculate prepath */
2144 cifs_sb->prepath = pvolume_info->prepath;
2145 if (cifs_sb->prepath) {
2146 cifs_sb->prepathlen = strlen(cifs_sb->prepath);
2147 /* we can not convert the / to \ in the path
2148 separators in the prefixpath yet because we do not
2149 know (until reset_cifs_unix_caps is called later)
2150 whether POSIX PATH CAP is available. We normalize
2151 the / to \ after reset_cifs_unix_caps is called */
2152 pvolume_info->prepath = NULL;
2153 } else
2154 cifs_sb->prepathlen = 0;
2155 cifs_sb->mnt_uid = pvolume_info->linux_uid;
2156 cifs_sb->mnt_gid = pvolume_info->linux_gid;
2157 cifs_sb->mnt_file_mode = pvolume_info->file_mode;
2158 cifs_sb->mnt_dir_mode = pvolume_info->dir_mode;
2159 cFYI(1, ("file mode: 0x%x dir mode: 0x%x",
2160 cifs_sb->mnt_file_mode, cifs_sb->mnt_dir_mode));
2161
2162 if (pvolume_info->noperm)
2163 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_PERM;
2164 if (pvolume_info->setuids)
2165 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SET_UID;
2166 if (pvolume_info->server_ino)
2167 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_SERVER_INUM;
2168 if (pvolume_info->remap)
2169 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_MAP_SPECIAL_CHR;
2170 if (pvolume_info->no_xattr)
2171 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_XATTR;
2172 if (pvolume_info->sfu_emul)
2173 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_UNX_EMUL;
2174 if (pvolume_info->nobrl)
2175 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NO_BRL;
2176 if (pvolume_info->nostrictsync)
2177 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOSSYNC;
2178 if (pvolume_info->mand_lock)
2179 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_NOPOSIXBRL;
2180 if (pvolume_info->cifs_acl)
2181 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_CIFS_ACL;
2182 if (pvolume_info->override_uid)
2183 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
2184 if (pvolume_info->override_gid)
2185 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
2186 if (pvolume_info->dynperm)
2187 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
2188 if (pvolume_info->direct_io) {
2189 cFYI(1, ("mounting share using direct i/o"));
2190 cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
2191 }
2192
2193 if ((pvolume_info->cifs_acl) && (pvolume_info->dynperm))
2194 cERROR(1, ("mount option dynperm ignored if cifsacl "
2195 "mount option supported"));
2196 }
2197
2198 static int
2199 is_path_accessible(int xid, struct cifsTconInfo *tcon,
2200 struct cifs_sb_info *cifs_sb, const char *full_path)
2201 {
2202 int rc;
2203 __u64 inode_num;
2204 FILE_ALL_INFO *pfile_info;
2205
2206 rc = CIFSGetSrvInodeNumber(xid, tcon, full_path, &inode_num,
2207 cifs_sb->local_nls,
2208 cifs_sb->mnt_cifs_flags &
2209 CIFS_MOUNT_MAP_SPECIAL_CHR);
2210 if (rc != -EOPNOTSUPP)
2211 return rc;
2212
2213 pfile_info = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
2214 if (pfile_info == NULL)
2215 return -ENOMEM;
2216
2217 rc = CIFSSMBQPathInfo(xid, tcon, full_path, pfile_info,
2218 0 /* not legacy */, cifs_sb->local_nls,
2219 cifs_sb->mnt_cifs_flags &
2220 CIFS_MOUNT_MAP_SPECIAL_CHR);
2221 kfree(pfile_info);
2222 return rc;
2223 }
2224
2225 static void
2226 cleanup_volume_info(struct smb_vol **pvolume_info)
2227 {
2228 struct smb_vol *volume_info;
2229
2230 if (!pvolume_info && !*pvolume_info)
2231 return;
2232
2233 volume_info = *pvolume_info;
2234 kzfree(volume_info->password);
2235 kfree(volume_info->UNC);
2236 kfree(volume_info->prepath);
2237 kfree(volume_info);
2238 *pvolume_info = NULL;
2239 return;
2240 }
2241
2242 #ifdef CONFIG_CIFS_DFS_UPCALL
2243 /* build_path_to_root returns full path to root when
2244 * we do not have an exiting connection (tcon) */
2245 static char *
2246 build_unc_path_to_root(const struct smb_vol *volume_info,
2247 const struct cifs_sb_info *cifs_sb)
2248 {
2249 char *full_path;
2250
2251 int unc_len = strnlen(volume_info->UNC, MAX_TREE_SIZE + 1);
2252 full_path = kmalloc(unc_len + cifs_sb->prepathlen + 1, GFP_KERNEL);
2253 if (full_path == NULL)
2254 return ERR_PTR(-ENOMEM);
2255
2256 strncpy(full_path, volume_info->UNC, unc_len);
2257 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
2258 int i;
2259 for (i = 0; i < unc_len; i++) {
2260 if (full_path[i] == '\\')
2261 full_path[i] = '/';
2262 }
2263 }
2264
2265 if (cifs_sb->prepathlen)
2266 strncpy(full_path + unc_len, cifs_sb->prepath,
2267 cifs_sb->prepathlen);
2268
2269 full_path[unc_len + cifs_sb->prepathlen] = 0; /* add trailing null */
2270 return full_path;
2271 }
2272 #endif
2273
2274 int
2275 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
2276 char *mount_data_global, const char *devname)
2277 {
2278 int rc = 0;
2279 int xid;
2280 struct smb_vol *volume_info;
2281 struct cifsSesInfo *pSesInfo = NULL;
2282 struct cifsTconInfo *tcon = NULL;
2283 struct TCP_Server_Info *srvTcp = NULL;
2284 char *full_path;
2285 char *mount_data = mount_data_global;
2286 #ifdef CONFIG_CIFS_DFS_UPCALL
2287 struct dfs_info3_param *referrals = NULL;
2288 unsigned int num_referrals = 0;
2289 int referral_walks_count = 0;
2290 try_mount_again:
2291 #endif
2292 full_path = NULL;
2293
2294 xid = GetXid();
2295
2296 volume_info = kzalloc(sizeof(struct smb_vol), GFP_KERNEL);
2297 if (!volume_info) {
2298 rc = -ENOMEM;
2299 goto out;
2300 }
2301
2302 if (cifs_parse_mount_options(mount_data, devname, volume_info)) {
2303 rc = -EINVAL;
2304 goto out;
2305 }
2306
2307 if (volume_info->nullauth) {
2308 cFYI(1, ("null user"));
2309 volume_info->username = "";
2310 } else if (volume_info->username) {
2311 /* BB fixme parse for domain name here */
2312 cFYI(1, ("Username: %s", volume_info->username));
2313 } else {
2314 cifserror("No username specified");
2315 /* In userspace mount helper we can get user name from alternate
2316 locations such as env variables and files on disk */
2317 rc = -EINVAL;
2318 goto out;
2319 }
2320
2321
2322 /* this is needed for ASCII cp to Unicode converts */
2323 if (volume_info->iocharset == NULL) {
2324 cifs_sb->local_nls = load_nls_default();
2325 /* load_nls_default can not return null */
2326 } else {
2327 cifs_sb->local_nls = load_nls(volume_info->iocharset);
2328 if (cifs_sb->local_nls == NULL) {
2329 cERROR(1, ("CIFS mount error: iocharset %s not found",
2330 volume_info->iocharset));
2331 rc = -ELIBACC;
2332 goto out;
2333 }
2334 }
2335
2336 /* get a reference to a tcp session */
2337 srvTcp = cifs_get_tcp_session(volume_info);
2338 if (IS_ERR(srvTcp)) {
2339 rc = PTR_ERR(srvTcp);
2340 goto out;
2341 }
2342
2343 pSesInfo = cifs_find_smb_ses(srvTcp, volume_info->username);
2344 if (pSesInfo) {
2345 cFYI(1, ("Existing smb sess found (status=%d)",
2346 pSesInfo->status));
2347 /*
2348 * The existing SMB session already has a reference to srvTcp,
2349 * so we can put back the extra one we got before
2350 */
2351 cifs_put_tcp_session(srvTcp);
2352
2353 down(&pSesInfo->sesSem);
2354 if (pSesInfo->need_reconnect) {
2355 cFYI(1, ("Session needs reconnect"));
2356 rc = cifs_setup_session(xid, pSesInfo,
2357 cifs_sb->local_nls);
2358 }
2359 up(&pSesInfo->sesSem);
2360 } else if (!rc) {
2361 cFYI(1, ("Existing smb sess not found"));
2362 pSesInfo = sesInfoAlloc();
2363 if (pSesInfo == NULL) {
2364 rc = -ENOMEM;
2365 goto mount_fail_check;
2366 }
2367
2368 /* new SMB session uses our srvTcp ref */
2369 pSesInfo->server = srvTcp;
2370 if (srvTcp->addr.sockAddr6.sin6_family == AF_INET6)
2371 sprintf(pSesInfo->serverName, "%pI6",
2372 &srvTcp->addr.sockAddr6.sin6_addr);
2373 else
2374 sprintf(pSesInfo->serverName, "%pI4",
2375 &srvTcp->addr.sockAddr.sin_addr.s_addr);
2376
2377 write_lock(&cifs_tcp_ses_lock);
2378 list_add(&pSesInfo->smb_ses_list, &srvTcp->smb_ses_list);
2379 write_unlock(&cifs_tcp_ses_lock);
2380
2381 /* volume_info->password freed at unmount */
2382 if (volume_info->password) {
2383 pSesInfo->password = kstrdup(volume_info->password,
2384 GFP_KERNEL);
2385 if (!pSesInfo->password) {
2386 rc = -ENOMEM;
2387 goto mount_fail_check;
2388 }
2389 }
2390 if (volume_info->username)
2391 strncpy(pSesInfo->userName, volume_info->username,
2392 MAX_USERNAME_SIZE);
2393 if (volume_info->domainname) {
2394 int len = strlen(volume_info->domainname);
2395 pSesInfo->domainName = kmalloc(len + 1, GFP_KERNEL);
2396 if (pSesInfo->domainName)
2397 strcpy(pSesInfo->domainName,
2398 volume_info->domainname);
2399 }
2400 pSesInfo->linux_uid = volume_info->linux_uid;
2401 pSesInfo->overrideSecFlg = volume_info->secFlg;
2402 down(&pSesInfo->sesSem);
2403
2404 /* BB FIXME need to pass vol->secFlgs BB */
2405 rc = cifs_setup_session(xid, pSesInfo,
2406 cifs_sb->local_nls);
2407 up(&pSesInfo->sesSem);
2408 }
2409
2410 /* search for existing tcon to this server share */
2411 if (!rc) {
2412 setup_cifs_sb(volume_info, cifs_sb);
2413
2414 tcon = cifs_find_tcon(pSesInfo, volume_info->UNC);
2415 if (tcon) {
2416 cFYI(1, ("Found match on UNC path"));
2417 /* existing tcon already has a reference */
2418 cifs_put_smb_ses(pSesInfo);
2419 if (tcon->seal != volume_info->seal)
2420 cERROR(1, ("transport encryption setting "
2421 "conflicts with existing tid"));
2422 } else {
2423 tcon = tconInfoAlloc();
2424 if (tcon == NULL) {
2425 rc = -ENOMEM;
2426 goto mount_fail_check;
2427 }
2428
2429 tcon->ses = pSesInfo;
2430 if (volume_info->password) {
2431 tcon->password = kstrdup(volume_info->password,
2432 GFP_KERNEL);
2433 if (!tcon->password) {
2434 rc = -ENOMEM;
2435 goto mount_fail_check;
2436 }
2437 }
2438
2439 if ((strchr(volume_info->UNC + 3, '\\') == NULL)
2440 && (strchr(volume_info->UNC + 3, '/') == NULL)) {
2441 cERROR(1, ("Missing share name"));
2442 rc = -ENODEV;
2443 goto mount_fail_check;
2444 } else {
2445 /* BB Do we need to wrap sesSem around
2446 * this TCon call and Unix SetFS as
2447 * we do on SessSetup and reconnect? */
2448 rc = CIFSTCon(xid, pSesInfo, volume_info->UNC,
2449 tcon, cifs_sb->local_nls);
2450 cFYI(1, ("CIFS Tcon rc = %d", rc));
2451 if (volume_info->nodfs) {
2452 tcon->Flags &= ~SMB_SHARE_IS_IN_DFS;
2453 cFYI(1, ("DFS disabled (%d)",
2454 tcon->Flags));
2455 }
2456 }
2457 if (rc)
2458 goto remote_path_check;
2459 tcon->seal = volume_info->seal;
2460 write_lock(&cifs_tcp_ses_lock);
2461 list_add(&tcon->tcon_list, &pSesInfo->tcon_list);
2462 write_unlock(&cifs_tcp_ses_lock);
2463 }
2464
2465 /* we can have only one retry value for a connection
2466 to a share so for resources mounted more than once
2467 to the same server share the last value passed in
2468 for the retry flag is used */
2469 tcon->retry = volume_info->retry;
2470 tcon->nocase = volume_info->nocase;
2471 tcon->local_lease = volume_info->local_lease;
2472 }
2473 if (pSesInfo) {
2474 if (pSesInfo->capabilities & CAP_LARGE_FILES) {
2475 sb->s_maxbytes = (u64) 1 << 63;
2476 } else
2477 sb->s_maxbytes = (u64) 1 << 31; /* 2 GB */
2478 }
2479
2480 /* BB FIXME fix time_gran to be larger for LANMAN sessions */
2481 sb->s_time_gran = 100;
2482
2483 if (rc)
2484 goto remote_path_check;
2485
2486 cifs_sb->tcon = tcon;
2487
2488 /* do not care if following two calls succeed - informational */
2489 if (!tcon->ipc) {
2490 CIFSSMBQFSDeviceInfo(xid, tcon);
2491 CIFSSMBQFSAttributeInfo(xid, tcon);
2492 }
2493
2494 /* tell server which Unix caps we support */
2495 if (tcon->ses->capabilities & CAP_UNIX)
2496 /* reset of caps checks mount to see if unix extensions
2497 disabled for just this mount */
2498 reset_cifs_unix_caps(xid, tcon, sb, volume_info);
2499 else
2500 tcon->unix_ext = 0; /* server does not support them */
2501
2502 /* convert forward to back slashes in prepath here if needed */
2503 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2504 convert_delimiter(cifs_sb->prepath, CIFS_DIR_SEP(cifs_sb));
2505
2506 if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
2507 cifs_sb->rsize = 1024 * 127;
2508 cFYI(DBG2, ("no very large read support, rsize now 127K"));
2509 }
2510 if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
2511 cifs_sb->wsize = min(cifs_sb->wsize,
2512 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2513 if (!(tcon->ses->capabilities & CAP_LARGE_READ_X))
2514 cifs_sb->rsize = min(cifs_sb->rsize,
2515 (tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE));
2516
2517 remote_path_check:
2518 /* check if a whole path (including prepath) is not remote */
2519 if (!rc && cifs_sb->prepathlen && tcon) {
2520 /* build_path_to_root works only when we have a valid tcon */
2521 full_path = cifs_build_path_to_root(cifs_sb);
2522 if (full_path == NULL) {
2523 rc = -ENOMEM;
2524 goto mount_fail_check;
2525 }
2526 rc = is_path_accessible(xid, tcon, cifs_sb, full_path);
2527 if (rc != -EREMOTE) {
2528 kfree(full_path);
2529 goto mount_fail_check;
2530 }
2531 kfree(full_path);
2532 }
2533
2534 /* get referral if needed */
2535 if (rc == -EREMOTE) {
2536 #ifdef CONFIG_CIFS_DFS_UPCALL
2537 if (referral_walks_count > MAX_NESTED_LINKS) {
2538 /*
2539 * BB: when we implement proper loop detection,
2540 * we will remove this check. But now we need it
2541 * to prevent an indefinite loop if 'DFS tree' is
2542 * misconfigured (i.e. has loops).
2543 */
2544 rc = -ELOOP;
2545 goto mount_fail_check;
2546 }
2547 /* convert forward to back slashes in prepath here if needed */
2548 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
2549 convert_delimiter(cifs_sb->prepath,
2550 CIFS_DIR_SEP(cifs_sb));
2551 full_path = build_unc_path_to_root(volume_info, cifs_sb);
2552 if (IS_ERR(full_path)) {
2553 rc = PTR_ERR(full_path);
2554 goto mount_fail_check;
2555 }
2556
2557 cFYI(1, ("Getting referral for: %s", full_path));
2558 rc = get_dfs_path(xid, pSesInfo , full_path + 1,
2559 cifs_sb->local_nls, &num_referrals, &referrals,
2560 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
2561 if (!rc && num_referrals > 0) {
2562 char *fake_devname = NULL;
2563
2564 if (mount_data != mount_data_global)
2565 kfree(mount_data);
2566 mount_data = cifs_compose_mount_options(
2567 cifs_sb->mountdata, full_path + 1,
2568 referrals, &fake_devname);
2569 kfree(fake_devname);
2570 free_dfs_info_array(referrals, num_referrals);
2571
2572 if (tcon)
2573 cifs_put_tcon(tcon);
2574 else if (pSesInfo)
2575 cifs_put_smb_ses(pSesInfo);
2576
2577 cleanup_volume_info(&volume_info);
2578 FreeXid(xid);
2579 kfree(full_path);
2580 referral_walks_count++;
2581 goto try_mount_again;
2582 }
2583 #else /* No DFS support, return error on mount */
2584 rc = -EOPNOTSUPP;
2585 #endif
2586 }
2587
2588 mount_fail_check:
2589 /* on error free sesinfo and tcon struct if needed */
2590 if (rc) {
2591 if (mount_data != mount_data_global)
2592 kfree(mount_data);
2593 /* If find_unc succeeded then rc == 0 so we can not end */
2594 /* up accidently freeing someone elses tcon struct */
2595 if (tcon)
2596 cifs_put_tcon(tcon);
2597 else if (pSesInfo)
2598 cifs_put_smb_ses(pSesInfo);
2599 else
2600 cifs_put_tcp_session(srvTcp);
2601 goto out;
2602 }
2603
2604 /* volume_info->password is freed above when existing session found
2605 (in which case it is not needed anymore) but when new sesion is created
2606 the password ptr is put in the new session structure (in which case the
2607 password will be freed at unmount time) */
2608 out:
2609 /* zero out password before freeing */
2610 cleanup_volume_info(&volume_info);
2611 FreeXid(xid);
2612 return rc;
2613 }
2614
2615 int
2616 CIFSTCon(unsigned int xid, struct cifsSesInfo *ses,
2617 const char *tree, struct cifsTconInfo *tcon,
2618 const struct nls_table *nls_codepage)
2619 {
2620 struct smb_hdr *smb_buffer;
2621 struct smb_hdr *smb_buffer_response;
2622 TCONX_REQ *pSMB;
2623 TCONX_RSP *pSMBr;
2624 unsigned char *bcc_ptr;
2625 int rc = 0;
2626 int length, bytes_left;
2627 __u16 count;
2628
2629 if (ses == NULL)
2630 return -EIO;
2631
2632 smb_buffer = cifs_buf_get();
2633 if (smb_buffer == NULL) {
2634 return -ENOMEM;
2635 }
2636 smb_buffer_response = smb_buffer;
2637
2638 header_assemble(smb_buffer, SMB_COM_TREE_CONNECT_ANDX,
2639 NULL /*no tid */ , 4 /*wct */ );
2640
2641 smb_buffer->Mid = GetNextMid(ses->server);
2642 smb_buffer->Uid = ses->Suid;
2643 pSMB = (TCONX_REQ *) smb_buffer;
2644 pSMBr = (TCONX_RSP *) smb_buffer_response;
2645
2646 pSMB->AndXCommand = 0xFF;
2647 pSMB->Flags = cpu_to_le16(TCON_EXTENDED_SECINFO);
2648 bcc_ptr = &pSMB->Password[0];
2649 if ((ses->server->secMode) & SECMODE_USER) {
2650 pSMB->PasswordLength = cpu_to_le16(1); /* minimum */
2651 *bcc_ptr = 0; /* password is null byte */
2652 bcc_ptr++; /* skip password */
2653 /* already aligned so no need to do it below */
2654 } else {
2655 pSMB->PasswordLength = cpu_to_le16(CIFS_SESS_KEY_SIZE);
2656 /* BB FIXME add code to fail this if NTLMv2 or Kerberos
2657 specified as required (when that support is added to
2658 the vfs in the future) as only NTLM or the much
2659 weaker LANMAN (which we do not send by default) is accepted
2660 by Samba (not sure whether other servers allow
2661 NTLMv2 password here) */
2662 #ifdef CONFIG_CIFS_WEAK_PW_HASH
2663 if ((extended_security & CIFSSEC_MAY_LANMAN) &&
2664 (ses->server->secType == LANMAN))
2665 calc_lanman_hash(tcon->password, ses->server->cryptKey,
2666 ses->server->secMode &
2667 SECMODE_PW_ENCRYPT ? true : false,
2668 bcc_ptr);
2669 else
2670 #endif /* CIFS_WEAK_PW_HASH */
2671 SMBNTencrypt(tcon->password, ses->server->cryptKey,
2672 bcc_ptr);
2673
2674 bcc_ptr += CIFS_SESS_KEY_SIZE;
2675 if (ses->capabilities & CAP_UNICODE) {
2676 /* must align unicode strings */
2677 *bcc_ptr = 0; /* null byte password */
2678 bcc_ptr++;
2679 }
2680 }
2681
2682 if (ses->server->secMode &
2683 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
2684 smb_buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
2685
2686 if (ses->capabilities & CAP_STATUS32) {
2687 smb_buffer->Flags2 |= SMBFLG2_ERR_STATUS;
2688 }
2689 if (ses->capabilities & CAP_DFS) {
2690 smb_buffer->Flags2 |= SMBFLG2_DFS;
2691 }
2692 if (ses->capabilities & CAP_UNICODE) {
2693 smb_buffer->Flags2 |= SMBFLG2_UNICODE;
2694 length =
2695 cifs_strtoUCS((__le16 *) bcc_ptr, tree,
2696 6 /* max utf8 char length in bytes */ *
2697 (/* server len*/ + 256 /* share len */), nls_codepage);
2698 bcc_ptr += 2 * length; /* convert num 16 bit words to bytes */
2699 bcc_ptr += 2; /* skip trailing null */
2700 } else { /* ASCII */
2701 strcpy(bcc_ptr, tree);
2702 bcc_ptr += strlen(tree) + 1;
2703 }
2704 strcpy(bcc_ptr, "?????");
2705 bcc_ptr += strlen("?????");
2706 bcc_ptr += 1;
2707 count = bcc_ptr - &pSMB->Password[0];
2708 pSMB->hdr.smb_buf_length += count;
2709 pSMB->ByteCount = cpu_to_le16(count);
2710
2711 rc = SendReceive(xid, ses, smb_buffer, smb_buffer_response, &length,
2712 CIFS_STD_OP);
2713
2714 /* above now done in SendReceive */
2715 if ((rc == 0) && (tcon != NULL)) {
2716 bool is_unicode;
2717
2718 tcon->tidStatus = CifsGood;
2719 tcon->need_reconnect = false;
2720 tcon->tid = smb_buffer_response->Tid;
2721 bcc_ptr = pByteArea(smb_buffer_response);
2722 bytes_left = BCC(smb_buffer_response);
2723 length = strnlen(bcc_ptr, bytes_left - 2);
2724 if (smb_buffer->Flags2 & SMBFLG2_UNICODE)
2725 is_unicode = true;
2726 else
2727 is_unicode = false;
2728
2729
2730 /* skip service field (NB: this field is always ASCII) */
2731 if (length == 3) {
2732 if ((bcc_ptr[0] == 'I') && (bcc_ptr[1] == 'P') &&
2733 (bcc_ptr[2] == 'C')) {
2734 cFYI(1, ("IPC connection"));
2735 tcon->ipc = 1;
2736 }
2737 } else if (length == 2) {
2738 if ((bcc_ptr[0] == 'A') && (bcc_ptr[1] == ':')) {
2739 /* the most common case */
2740 cFYI(1, ("disk share connection"));
2741 }
2742 }
2743 bcc_ptr += length + 1;
2744 bytes_left -= (length + 1);
2745 strncpy(tcon->treeName, tree, MAX_TREE_SIZE);
2746
2747 /* mostly informational -- no need to fail on error here */
2748 tcon->nativeFileSystem = cifs_strndup_from_ucs(bcc_ptr,
2749 bytes_left, is_unicode,
2750 nls_codepage);
2751
2752 cFYI(1, ("nativeFileSystem=%s", tcon->nativeFileSystem));
2753
2754 if ((smb_buffer_response->WordCount == 3) ||
2755 (smb_buffer_response->WordCount == 7))
2756 /* field is in same location */
2757 tcon->Flags = le16_to_cpu(pSMBr->OptionalSupport);
2758 else
2759 tcon->Flags = 0;
2760 cFYI(1, ("Tcon flags: 0x%x ", tcon->Flags));
2761 } else if ((rc == 0) && tcon == NULL) {
2762 /* all we need to save for IPC$ connection */
2763 ses->ipc_tid = smb_buffer_response->Tid;
2764 }
2765
2766 cifs_buf_release(smb_buffer);
2767 return rc;
2768 }
2769
2770 int
2771 cifs_umount(struct super_block *sb, struct cifs_sb_info *cifs_sb)
2772 {
2773 int rc = 0;
2774 char *tmp;
2775
2776 if (cifs_sb->tcon)
2777 cifs_put_tcon(cifs_sb->tcon);
2778
2779 cifs_sb->tcon = NULL;
2780 tmp = cifs_sb->prepath;
2781 cifs_sb->prepathlen = 0;
2782 cifs_sb->prepath = NULL;
2783 kfree(tmp);
2784
2785 return rc;
2786 }
2787
2788 int cifs_setup_session(unsigned int xid, struct cifsSesInfo *pSesInfo,
2789 struct nls_table *nls_info)
2790 {
2791 int rc = 0;
2792 int first_time = 0;
2793 struct TCP_Server_Info *server = pSesInfo->server;
2794
2795 /* what if server changes its buffer size after dropping the session? */
2796 if (server->maxBuf == 0) /* no need to send on reconnect */ {
2797 rc = CIFSSMBNegotiate(xid, pSesInfo);
2798 if (rc == -EAGAIN) {
2799 /* retry only once on 1st time connection */
2800 rc = CIFSSMBNegotiate(xid, pSesInfo);
2801 if (rc == -EAGAIN)
2802 rc = -EHOSTDOWN;
2803 }
2804 if (rc == 0) {
2805 spin_lock(&GlobalMid_Lock);
2806 if (server->tcpStatus != CifsExiting)
2807 server->tcpStatus = CifsGood;
2808 else
2809 rc = -EHOSTDOWN;
2810 spin_unlock(&GlobalMid_Lock);
2811
2812 }
2813 first_time = 1;
2814 }
2815
2816 if (rc)
2817 goto ss_err_exit;
2818
2819 pSesInfo->flags = 0;
2820 pSesInfo->capabilities = server->capabilities;
2821 if (linuxExtEnabled == 0)
2822 pSesInfo->capabilities &= (~CAP_UNIX);
2823
2824 cFYI(1, ("Security Mode: 0x%x Capabilities: 0x%x TimeAdjust: %d",
2825 server->secMode, server->capabilities, server->timeAdj));
2826
2827 rc = CIFS_SessSetup(xid, pSesInfo, first_time, nls_info);
2828 if (rc) {
2829 cERROR(1, ("Send error in SessSetup = %d", rc));
2830 } else {
2831 cFYI(1, ("CIFS Session Established successfully"));
2832 spin_lock(&GlobalMid_Lock);
2833 pSesInfo->status = CifsGood;
2834 pSesInfo->need_reconnect = false;
2835 spin_unlock(&GlobalMid_Lock);
2836 }
2837
2838 ss_err_exit:
2839 return rc;
2840 }
2841
Support for the Chinese Samsung S3C2440 based development boards