← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to fs/cifs/connect.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

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