misc.c 22.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/*
 *   fs/cifs/misc.c
 *
S
Steve French 已提交
4
 *   Copyright (C) International Business Machines  Corp., 2002,2008
L
Linus Torvalds 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17 18
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
 *   This library is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Lesser General Public License as published
 *   by the Free Software Foundation; either version 2.1 of the License, or
 *   (at your option) any later version.
 *
 *   This library is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 *   the GNU Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public License
 *   along with this library; if not, write to the Free Software
S
Steve French 已提交
19
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
L
Linus Torvalds 已提交
20 21 22 23 24 25 26 27 28 29 30
 */

#include <linux/slab.h>
#include <linux/ctype.h>
#include <linux/mempool.h>
#include "cifspdu.h"
#include "cifsglob.h"
#include "cifsproto.h"
#include "cifs_debug.h"
#include "smberr.h"
#include "nterr.h"
31
#include "cifs_unicode.h"
L
Linus Torvalds 已提交
32 33 34

extern mempool_t *cifs_sm_req_poolp;
extern mempool_t *cifs_req_poolp;
S
Steve French 已提交
35
extern struct task_struct *oplockThread;
L
Linus Torvalds 已提交
36

S
Steve French 已提交
37 38 39 40
/* The xid serves as a useful identifier for each incoming vfs request,
   in a similar way to the mid which is useful to track each sent smb,
   and CurrentXid can also provide a running counter (although it
   will eventually wrap past zero) of the total vfs operations handled
L
Linus Torvalds 已提交
41 42 43 44 45 46 47 48 49
   since the cifs fs was mounted */

unsigned int
_GetXid(void)
{
	unsigned int xid;

	spin_lock(&GlobalMid_Lock);
	GlobalTotalActiveXid++;
50 51

	/* keep high water mark for number of simultaneous ops in filesystem */
L
Linus Torvalds 已提交
52
	if (GlobalTotalActiveXid > GlobalMaxActiveXid)
53
		GlobalMaxActiveXid = GlobalTotalActiveXid;
S
Steve French 已提交
54
	if (GlobalTotalActiveXid > 65000)
S
Steve French 已提交
55
		cFYI(1, ("warning: more than 65000 requests active"));
L
Linus Torvalds 已提交
56 57 58 59 60 61 62 63 64
	xid = GlobalCurrentXid++;
	spin_unlock(&GlobalMid_Lock);
	return xid;
}

void
_FreeXid(unsigned int xid)
{
	spin_lock(&GlobalMid_Lock);
S
Steve French 已提交
65
	/* if (GlobalTotalActiveXid == 0)
L
Linus Torvalds 已提交
66 67 68 69 70 71 72 73 74 75
		BUG(); */
	GlobalTotalActiveXid--;
	spin_unlock(&GlobalMid_Lock);
}

struct cifsSesInfo *
sesInfoAlloc(void)
{
	struct cifsSesInfo *ret_buf;

S
Steve French 已提交
76
	ret_buf = kzalloc(sizeof(struct cifsSesInfo), GFP_KERNEL);
L
Linus Torvalds 已提交
77 78 79
	if (ret_buf) {
		atomic_inc(&sesInfoAllocCount);
		ret_buf->status = CifsNew;
80 81
		++ret_buf->ses_count;
		INIT_LIST_HEAD(&ret_buf->smb_ses_list);
82
		INIT_LIST_HEAD(&ret_buf->tcon_list);
L
Linus Torvalds 已提交
83 84 85 86 87 88 89 90 91 92 93 94 95 96
		init_MUTEX(&ret_buf->sesSem);
	}
	return ret_buf;
}

void
sesInfoFree(struct cifsSesInfo *buf_to_free)
{
	if (buf_to_free == NULL) {
		cFYI(1, ("Null buffer passed to sesInfoFree"));
		return;
	}

	atomic_dec(&sesInfoAllocCount);
J
Jesper Juhl 已提交
97 98 99 100
	kfree(buf_to_free->serverOS);
	kfree(buf_to_free->serverDomain);
	kfree(buf_to_free->serverNOS);
	kfree(buf_to_free->password);
101
	kfree(buf_to_free->domainName);
L
Linus Torvalds 已提交
102 103 104 105 106 107 108
	kfree(buf_to_free);
}

struct cifsTconInfo *
tconInfoAlloc(void)
{
	struct cifsTconInfo *ret_buf;
S
Steve French 已提交
109
	ret_buf = kzalloc(sizeof(struct cifsTconInfo), GFP_KERNEL);
L
Linus Torvalds 已提交
110 111 112
	if (ret_buf) {
		atomic_inc(&tconInfoAllocCount);
		ret_buf->tidStatus = CifsNew;
113
		++ret_buf->tc_count;
L
Linus Torvalds 已提交
114
		INIT_LIST_HEAD(&ret_buf->openFileList);
115
		INIT_LIST_HEAD(&ret_buf->tcon_list);
L
Linus Torvalds 已提交
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
#ifdef CONFIG_CIFS_STATS
		spin_lock_init(&ret_buf->stat_lock);
#endif
	}
	return ret_buf;
}

void
tconInfoFree(struct cifsTconInfo *buf_to_free)
{
	if (buf_to_free == NULL) {
		cFYI(1, ("Null buffer passed to tconInfoFree"));
		return;
	}
	atomic_dec(&tconInfoAllocCount);
J
Jesper Juhl 已提交
131
	kfree(buf_to_free->nativeFileSystem);
L
Linus Torvalds 已提交
132 133 134 135 136 137 138 139
	kfree(buf_to_free);
}

struct smb_hdr *
cifs_buf_get(void)
{
	struct smb_hdr *ret_buf = NULL;

S
Steve French 已提交
140 141 142
/* We could use negotiated size instead of max_msgsize -
   but it may be more efficient to always alloc same size
   albeit slightly larger than necessary and maxbuffersize
L
Linus Torvalds 已提交
143
   defaults to this and can not be bigger */
144
	ret_buf = mempool_alloc(cifs_req_poolp, GFP_NOFS);
L
Linus Torvalds 已提交
145 146 147 148 149 150

	/* clear the first few header bytes */
	/* for most paths, more is cleared in header_assemble */
	if (ret_buf) {
		memset(ret_buf, 0, sizeof(struct smb_hdr) + 3);
		atomic_inc(&bufAllocCount);
151 152 153
#ifdef CONFIG_CIFS_STATS2
		atomic_inc(&totBufAllocCount);
#endif /* CONFIG_CIFS_STATS2 */
L
Linus Torvalds 已提交
154 155 156 157 158 159 160 161 162 163 164 165
	}

	return ret_buf;
}

void
cifs_buf_release(void *buf_to_free)
{
	if (buf_to_free == NULL) {
		/* cFYI(1, ("Null buffer passed to cifs_buf_release"));*/
		return;
	}
S
Steve French 已提交
166
	mempool_free(buf_to_free, cifs_req_poolp);
L
Linus Torvalds 已提交
167 168 169 170 171 172 173 174 175 176

	atomic_dec(&bufAllocCount);
	return;
}

struct smb_hdr *
cifs_small_buf_get(void)
{
	struct smb_hdr *ret_buf = NULL;

S
Steve French 已提交
177 178 179
/* We could use negotiated size instead of max_msgsize -
   but it may be more efficient to always alloc same size
   albeit slightly larger than necessary and maxbuffersize
L
Linus Torvalds 已提交
180
   defaults to this and can not be bigger */
181
	ret_buf = mempool_alloc(cifs_sm_req_poolp, GFP_NOFS);
L
Linus Torvalds 已提交
182 183 184 185
	if (ret_buf) {
	/* No need to clear memory here, cleared in header assemble */
	/*	memset(ret_buf, 0, sizeof(struct smb_hdr) + 27);*/
		atomic_inc(&smBufAllocCount);
186 187 188 189
#ifdef CONFIG_CIFS_STATS2
		atomic_inc(&totSmBufAllocCount);
#endif /* CONFIG_CIFS_STATS2 */

L
Linus Torvalds 已提交
190 191 192 193 194 195 196 197 198 199 200 201
	}
	return ret_buf;
}

void
cifs_small_buf_release(void *buf_to_free)
{

	if (buf_to_free == NULL) {
		cFYI(1, ("Null buffer passed to cifs_small_buf_release"));
		return;
	}
S
Steve French 已提交
202
	mempool_free(buf_to_free, cifs_sm_req_poolp);
L
Linus Torvalds 已提交
203 204 205 206 207

	atomic_dec(&smBufAllocCount);
	return;
}

S
Steve French 已提交
208
/*
209 210 211 212 213 214
	Find a free multiplex id (SMB mid). Otherwise there could be
	mid collisions which might cause problems, demultiplexing the
	wrong response to this request. Multiplex ids could collide if
	one of a series requests takes much longer than the others, or
	if a very large number of long lived requests (byte range
	locks or FindNotify requests) are pending.  No more than
S
Steve French 已提交
215
	64K-1 requests can be outstanding at one time.  If no
216 217
	mids are available, return zero.  A future optimization
	could make the combination of mids and uid the key we use
S
Steve French 已提交
218
	to demultiplex on (rather than mid alone).
219 220 221 222 223 224
	In addition to the above check, the cifs demultiplex
	code already used the command code as a secondary
	check of the frame and if signing is negotiated the
	response would be discarded if the mid were the same
	but the signature was wrong.  Since the mid is not put in the
	pending queue until later (when it is about to be dispatched)
S
Steve French 已提交
225
	we do have to limit the number of outstanding requests
226 227 228 229 230 231 232
	to somewhat less than 64K-1 although it is hard to imagine
	so many threads being in the vfs at one time.
*/
__u16 GetNextMid(struct TCP_Server_Info *server)
{
	__u16 mid = 0;
	__u16 last_mid;
S
Steve French 已提交
233
	int   collision;
234

S
Steve French 已提交
235
	if (server == NULL)
236 237 238 239 240 241
		return mid;

	spin_lock(&GlobalMid_Lock);
	last_mid = server->CurrentMid; /* we do not want to loop forever */
	server->CurrentMid++;
	/* This nested loop looks more expensive than it is.
S
Steve French 已提交
242
	In practice the list of pending requests is short,
243 244 245 246 247
	fewer than 50, and the mids are likely to be unique
	on the first pass through the loop unless some request
	takes longer than the 64 thousand requests before it
	(and it would also have to have been a request that
	 did not time out) */
S
Steve French 已提交
248
	while (server->CurrentMid != last_mid) {
249 250 251 252
		struct list_head *tmp;
		struct mid_q_entry *mid_entry;

		collision = 0;
S
Steve French 已提交
253
		if (server->CurrentMid == 0)
254 255 256 257 258 259 260 261 262 263 264 265
			server->CurrentMid++;

		list_for_each(tmp, &server->pending_mid_q) {
			mid_entry = list_entry(tmp, struct mid_q_entry, qhead);

			if ((mid_entry->mid == server->CurrentMid) &&
			    (mid_entry->midState == MID_REQUEST_SUBMITTED)) {
				/* This mid is in use, try a different one */
				collision = 1;
				break;
			}
		}
S
Steve French 已提交
266
		if (collision == 0) {
267 268 269 270 271 272 273 274 275 276 277
			mid = server->CurrentMid;
			break;
		}
		server->CurrentMid++;
	}
	spin_unlock(&GlobalMid_Lock);
	return mid;
}

/* NB: MID can not be set if treeCon not passed in, in that
   case it is responsbility of caller to set the mid */
L
Linus Torvalds 已提交
278 279 280 281 282
void
header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
		const struct cifsTconInfo *treeCon, int word_count
		/* length of fixed section (word count) in two byte units  */)
{
S
Steve French 已提交
283 284
	struct list_head *temp_item;
	struct cifsSesInfo *ses;
L
Linus Torvalds 已提交
285 286
	char *temp = (char *) buffer;

S
Steve French 已提交
287
	memset(temp, 0, 256); /* bigger than MAX_CIFS_HDR_SIZE */
L
Linus Torvalds 已提交
288 289

	buffer->smb_buf_length =
S
Steve French 已提交
290
	    (2 * word_count) + sizeof(struct smb_hdr) -
L
Linus Torvalds 已提交
291 292
	    4 /*  RFC 1001 length field does not count */  +
	    2 /* for bcc field itself */ ;
293 294
	/* Note that this is the only network field that has to be converted
	   to big endian and it is done just before we send it */
L
Linus Torvalds 已提交
295 296 297 298 299 300 301 302 303 304 305 306 307 308 309

	buffer->Protocol[0] = 0xFF;
	buffer->Protocol[1] = 'S';
	buffer->Protocol[2] = 'M';
	buffer->Protocol[3] = 'B';
	buffer->Command = smb_command;
	buffer->Flags = 0x00;	/* case sensitive */
	buffer->Flags2 = SMBFLG2_KNOWS_LONG_NAMES;
	buffer->Pid = cpu_to_le16((__u16)current->tgid);
	buffer->PidHigh = cpu_to_le16((__u16)(current->tgid >> 16));
	if (treeCon) {
		buffer->Tid = treeCon->tid;
		if (treeCon->ses) {
			if (treeCon->ses->capabilities & CAP_UNICODE)
				buffer->Flags2 |= SMBFLG2_UNICODE;
S
Steve French 已提交
310
			if (treeCon->ses->capabilities & CAP_STATUS32)
L
Linus Torvalds 已提交
311
				buffer->Flags2 |= SMBFLG2_ERR_STATUS;
S
Steve French 已提交
312

313 314 315
			/* Uid is not converted */
			buffer->Uid = treeCon->ses->Suid;
			buffer->Mid = GetNextMid(treeCon->ses->server);
S
Steve French 已提交
316
			if (multiuser_mount != 0) {
L
Linus Torvalds 已提交
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338
		/* For the multiuser case, there are few obvious technically  */
		/* possible mechanisms to match the local linux user (uid)    */
		/* to a valid remote smb user (smb_uid):		      */
		/* 	1) Query Winbind (or other local pam/nss daemon       */
		/* 	  for userid/password/logon_domain or credential      */
		/*      2) Query Winbind for uid to sid to username mapping   */
		/* 	   and see if we have a matching password for existing*/
		/*         session for that user perhas getting password by   */
		/*         adding a new pam_cifs module that stores passwords */
		/*         so that the cifs vfs can get at that for all logged*/
		/*	   on users					      */
		/*	3) (Which is the mechanism we have chosen)	      */
		/*	   Search through sessions to the same server for a   */
		/*	   a match on the uid that was passed in on mount     */
		/*         with the current processes uid (or euid?) and use  */
		/* 	   that smb uid.   If no existing smb session for     */
		/* 	   that uid found, use the default smb session ie     */
		/*         the smb session for the volume mounted which is    */
		/* 	   the same as would be used if the multiuser mount   */
		/* 	   flag were disabled.  */

		/*  BB Add support for establishing new tCon and SMB Session  */
S
Steve French 已提交
339
		/*      with userid/password pairs found on the smb session   */
L
Linus Torvalds 已提交
340
		/*	for other target tcp/ip addresses 		BB    */
S
Steve French 已提交
341
				if (current->fsuid != treeCon->ses->linux_uid) {
342 343
					cFYI(1, ("Multiuser mode and UID "
						 "did not match tcon uid"));
344 345 346
					read_lock(&cifs_tcp_ses_lock);
					list_for_each(temp_item, &treeCon->ses->server->smb_ses_list) {
						ses = list_entry(temp_item, struct cifsSesInfo, smb_ses_list);
S
Steve French 已提交
347 348
						if (ses->linux_uid == current->fsuid) {
							if (ses->server == treeCon->ses->server) {
S
Steve French 已提交
349
								cFYI(1, ("found matching uid substitute right smb_uid"));
L
Linus Torvalds 已提交
350 351 352
								buffer->Uid = ses->Suid;
								break;
							} else {
S
Steve French 已提交
353 354
				/* BB eventually call cifs_setup_session here */
								cFYI(1, ("local UID found but no smb sess with this server exists"));
L
Linus Torvalds 已提交
355 356 357
							}
						}
					}
358
					read_unlock(&cifs_tcp_ses_lock);
L
Linus Torvalds 已提交
359 360 361 362 363
				}
			}
		}
		if (treeCon->Flags & SMB_SHARE_IS_IN_DFS)
			buffer->Flags2 |= SMBFLG2_DFS;
364 365
		if (treeCon->nocase)
			buffer->Flags  |= SMBFLG_CASELESS;
S
Steve French 已提交
366 367
		if ((treeCon->ses) && (treeCon->ses->server))
			if (treeCon->ses->server->secMode &
L
Linus Torvalds 已提交
368 369 370 371 372 373 374 375 376
			  (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
				buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE;
	}

/*  endian conversion of flags is now done just before sending */
	buffer->WordCount = (char) word_count;
	return;
}

377
static int
L
Linus Torvalds 已提交
378 379
checkSMBhdr(struct smb_hdr *smb, __u16 mid)
{
S
Steve French 已提交
380
	/* Make sure that this really is an SMB, that it is a response,
L
Linus Torvalds 已提交
381
	   and that the message ids match */
S
Steve French 已提交
382 383
	if ((*(__le32 *) smb->Protocol == cpu_to_le32(0x424d53ff)) &&
		(mid == smb->Mid)) {
S
Steve French 已提交
384
		if (smb->Flags & SMBFLG_RESPONSE)
S
Steve French 已提交
385 386
			return 0;
		else {
L
Linus Torvalds 已提交
387
		/* only one valid case where server sends us request */
S
Steve French 已提交
388
			if (smb->Command == SMB_COM_LOCKING_ANDX)
L
Linus Torvalds 已提交
389 390
				return 0;
			else
S
Steve French 已提交
391
				cERROR(1, ("Received Request not response"));
L
Linus Torvalds 已提交
392 393 394 395
		}
	} else { /* bad signature or mid */
		if (*(__le32 *) smb->Protocol != cpu_to_le32(0x424d53ff))
			cERROR(1,
396
			       ("Bad protocol string signature header %x",
L
Linus Torvalds 已提交
397 398 399 400 401 402 403 404 405
				*(unsigned int *) smb->Protocol));
		if (mid != smb->Mid)
			cERROR(1, ("Mids do not match"));
	}
	cERROR(1, ("bad smb detected. The Mid=%d", smb->Mid));
	return 1;
}

int
406
checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
L
Linus Torvalds 已提交
407
{
408
	__u32 len = smb->smb_buf_length;
409
	__u32 clc_len;  /* calculated length */
410
	cFYI(0, ("checkSMB Length: 0x%x, smb_buf_length: 0x%x", length, len));
411

S
Steve French 已提交
412 413
	if (length < 2 + sizeof(struct smb_hdr)) {
		if ((length >= sizeof(struct smb_hdr) - 1)
L
Linus Torvalds 已提交
414
			    && (smb->Status.CifsError != 0)) {
415 416 417
			smb->WordCount = 0;
			/* some error cases do not return wct and bcc */
			return 0;
S
Steve French 已提交
418
		} else if ((length == sizeof(struct smb_hdr) + 1) &&
419
				(smb->WordCount == 0)) {
S
Steve French 已提交
420
			char *tmp = (char *)smb;
421 422 423 424 425 426 427 428 429 430 431
			/* Need to work around a bug in two servers here */
			/* First, check if the part of bcc they sent was zero */
			if (tmp[sizeof(struct smb_hdr)] == 0) {
				/* some servers return only half of bcc
				 * on simple responses (wct, bcc both zero)
				 * in particular have seen this on
				 * ulogoffX and FindClose. This leaves
				 * one byte of bcc potentially unitialized
				 */
				/* zero rest of bcc */
				tmp[sizeof(struct smb_hdr)+1] = 0;
432
				return 0;
L
Linus Torvalds 已提交
433
			}
S
Steve French 已提交
434
			cERROR(1, ("rcvd invalid byte count (bcc)"));
435 436
		} else {
			cERROR(1, ("Length less than smb header size"));
L
Linus Torvalds 已提交
437
		}
438 439 440 441
		return 1;
	}
	if (len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
		cERROR(1, ("smb length greater than MaxBufSize, mid=%d",
442
				   smb->Mid));
L
Linus Torvalds 已提交
443 444 445 446 447
		return 1;
	}

	if (checkSMBhdr(smb, mid))
		return 1;
448
	clc_len = smbCalcSize_LE(smb);
449

S
Steve French 已提交
450
	if (4 + len != length) {
451 452
		cERROR(1, ("Length read does not match RFC1001 length %d",
			   len));
453 454 455 456 457
		return 1;
	}

	if (4 + len != clc_len) {
		/* check if bcc wrapped around for large read responses */
S
Steve French 已提交
458
		if ((len > 64 * 1024) && (len > clc_len)) {
459
			/* check if lengths match mod 64K */
S
Steve French 已提交
460
			if (((4 + len) & 0xFFFF) == (clc_len & 0xFFFF))
S
Steve French 已提交
461
				return 0; /* bcc wrapped */
462
		}
463 464
		cFYI(1, ("Calculated size %d vs length %d mismatch for mid %d",
				clc_len, 4 + len, smb->Mid));
465
		/* Windows XP can return a few bytes too much, presumably
S
Steve French 已提交
466
		an illegal pad, at the end of byte range lock responses
467
		so we allow for that three byte pad, as long as actual
468
		received length is as long or longer than calculated length */
S
Steve French 已提交
469
		/* We have now had to extend this more, since there is a
470 471 472 473 474 475
		case in which it needs to be bigger still to handle a
		malformed response to transact2 findfirst from WinXP when
		access denied is returned and thus bcc and wct are zero
		but server says length is 0x21 bytes too long as if the server
		forget to reset the smb rfc1001 length when it reset the
		wct and bcc to minimum size and drop the t2 parms and data */
S
Steve French 已提交
476
		if ((4+len > clc_len) && (len <= clc_len + 512))
477
			return 0;
478 479 480
		else {
			cERROR(1, ("RFC1001 size %d bigger than SMB for Mid=%d",
					len, smb->Mid));
481
			return 1;
482
		}
L
Linus Torvalds 已提交
483
	}
484
	return 0;
L
Linus Torvalds 已提交
485
}
486 487

bool
488
is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
S
Steve French 已提交
489 490
{
	struct smb_com_lock_req *pSMB = (struct smb_com_lock_req *)buf;
491 492
	struct list_head *tmp, *tmp1, *tmp2;
	struct cifsSesInfo *ses;
L
Linus Torvalds 已提交
493
	struct cifsTconInfo *tcon;
494
	struct cifsInodeInfo *pCifsInode;
L
Linus Torvalds 已提交
495 496
	struct cifsFileInfo *netfile;

S
Steve French 已提交
497
	cFYI(1, ("Checking for oplock break or dnotify response"));
S
Steve French 已提交
498
	if ((pSMB->hdr.Command == SMB_COM_NT_TRANSACT) &&
L
Linus Torvalds 已提交
499
	   (pSMB->hdr.Flags & SMBFLG_RESPONSE)) {
S
Steve French 已提交
500
		struct smb_com_transaction_change_notify_rsp *pSMBr =
L
Linus Torvalds 已提交
501
			(struct smb_com_transaction_change_notify_rsp *)buf;
S
Steve French 已提交
502
		struct file_notify_information *pnotify;
L
Linus Torvalds 已提交
503
		__u32 data_offset = 0;
S
Steve French 已提交
504
		if (pSMBr->ByteCount > sizeof(struct file_notify_information)) {
L
Linus Torvalds 已提交
505 506
			data_offset = le32_to_cpu(pSMBr->DataOffset);

507 508
			pnotify = (struct file_notify_information *)
				((char *)&pSMBr->hdr.Protocol + data_offset);
509
			cFYI(1, ("dnotify on %s Action: 0x%x",
S
Steve French 已提交
510
				 pnotify->FileName, pnotify->Action));
S
Steve French 已提交
511
			/*   cifs_dump_mem("Rcvd notify Data: ",buf,
512
				sizeof(struct smb_hdr)+60); */
513
			return true;
L
Linus Torvalds 已提交
514
		}
S
Steve French 已提交
515
		if (pSMBr->hdr.Status.CifsError) {
S
Steve French 已提交
516 517
			cFYI(1, ("notify err 0x%d",
				pSMBr->hdr.Status.CifsError));
518
			return true;
L
Linus Torvalds 已提交
519
		}
520
		return false;
S
Steve French 已提交
521
	}
S
Steve French 已提交
522
	if (pSMB->hdr.Command != SMB_COM_LOCKING_ANDX)
523
		return false;
S
Steve French 已提交
524
	if (pSMB->hdr.Flags & SMBFLG_RESPONSE) {
L
Linus Torvalds 已提交
525 526 527 528
		/* no sense logging error on invalid handle on oplock
		   break - harmless race between close request and oplock
		   break response is expected from time to time writing out
		   large dirty files cached on the client */
S
Steve French 已提交
529 530 531
		if ((NT_STATUS_INVALID_HANDLE) ==
		   le32_to_cpu(pSMB->hdr.Status.CifsError)) {
			cFYI(1, ("invalid handle on oplock break"));
532
			return true;
S
Steve French 已提交
533
		} else if (ERRbadfid ==
L
Linus Torvalds 已提交
534
		   le16_to_cpu(pSMB->hdr.Status.DosError.Error)) {
535
			return true;
L
Linus Torvalds 已提交
536
		} else {
537
			return false; /* on valid oplock brk we get "request" */
L
Linus Torvalds 已提交
538 539
		}
	}
S
Steve French 已提交
540
	if (pSMB->hdr.WordCount != 8)
541
		return false;
L
Linus Torvalds 已提交
542

S
Steve French 已提交
543 544
	cFYI(1, ("oplock type 0x%d level 0x%d",
		 pSMB->LockType, pSMB->OplockLevel));
S
Steve French 已提交
545
	if (!(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE))
546
		return false;
L
Linus Torvalds 已提交
547 548

	/* look up tcon based on tid & uid */
549 550 551 552 553 554 555 556
	read_lock(&cifs_tcp_ses_lock);
	list_for_each(tmp, &srv->smb_ses_list) {
		ses = list_entry(tmp, struct cifsSesInfo, smb_ses_list);
		list_for_each(tmp1, &ses->tcon_list) {
			tcon = list_entry(tmp1, struct cifsTconInfo, tcon_list);
			if (tcon->tid != buf->Tid)
				continue;

557
			cifs_stats_inc(&tcon->num_oplock_brks);
558
			write_lock(&GlobalSMBSeslock);
559 560
			list_for_each(tmp2, &tcon->openFileList) {
				netfile = list_entry(tmp2, struct cifsFileInfo,
561
						     tlist);
562 563 564
				if (pSMB->Fid != netfile->netfid)
					continue;

565
				write_unlock(&GlobalSMBSeslock);
566 567 568 569 570 571 572 573 574 575 576 577 578 579
				read_unlock(&cifs_tcp_ses_lock);
				cFYI(1, ("file id match, oplock break"));
				pCifsInode = CIFS_I(netfile->pInode);
				pCifsInode->clientCanCacheAll = false;
				if (pSMB->OplockLevel == 0)
					pCifsInode->clientCanCacheRead = false;
				pCifsInode->oplockPending = true;
				AllocOplockQEntry(netfile->pInode,
						  netfile->netfid, tcon);
				cFYI(1, ("about to wake up oplock thread"));
				if (oplockThread)
					wake_up_process(oplockThread);

				return true;
L
Linus Torvalds 已提交
580
			}
581
			write_unlock(&GlobalSMBSeslock);
582
			read_unlock(&cifs_tcp_ses_lock);
S
Steve French 已提交
583
			cFYI(1, ("No matching file for oplock break"));
584
			return true;
L
Linus Torvalds 已提交
585 586
		}
	}
587
	read_unlock(&cifs_tcp_ses_lock);
S
Steve French 已提交
588
	cFYI(1, ("Can not process oplock break for non-existent connection"));
589
	return true;
L
Linus Torvalds 已提交
590 591 592 593 594 595 596 597 598 599 600 601 602 603
}

void
dump_smb(struct smb_hdr *smb_buf, int smb_buf_length)
{
	int i, j;
	char debug_line[17];
	unsigned char *buffer;

	if (traceSMB == 0)
		return;

	buffer = (unsigned char *) smb_buf;
	for (i = 0, j = 0; i < smb_buf_length; i++, j++) {
S
Steve French 已提交
604 605
		if (i % 8 == 0) {
			/* have reached the beginning of line */
L
Linus Torvalds 已提交
606 607 608 609 610 611 612 613 614 615
			printk(KERN_DEBUG "| ");
			j = 0;
		}
		printk("%0#4x ", buffer[i]);
		debug_line[2 * j] = ' ';
		if (isprint(buffer[i]))
			debug_line[1 + (2 * j)] = buffer[i];
		else
			debug_line[1 + (2 * j)] = '_';

S
Steve French 已提交
616 617
		if (i % 8 == 7) {
			/* reached end of line, time to print ascii */
L
Linus Torvalds 已提交
618 619 620 621 622 623 624 625 626
			debug_line[16] = 0;
			printk(" | %s\n", debug_line);
		}
	}
	for (; j < 8; j++) {
		printk("     ");
		debug_line[2 * j] = ' ';
		debug_line[1 + (2 * j)] = ' ';
	}
S
Steve French 已提交
627
	printk(" | %s\n", debug_line);
L
Linus Torvalds 已提交
628 629
	return;
}
630 631 632 633

/* Windows maps these to the user defined 16 bit Unicode range since they are
   reserved symbols (along with \ and /), otherwise illegal to store
   in filenames in NTFS */
634 635 636 637 638 639 640
#define UNI_ASTERIK     (__u16) ('*' + 0xF000)
#define UNI_QUESTION    (__u16) ('?' + 0xF000)
#define UNI_COLON       (__u16) (':' + 0xF000)
#define UNI_GRTRTHAN    (__u16) ('>' + 0xF000)
#define UNI_LESSTHAN    (__u16) ('<' + 0xF000)
#define UNI_PIPE        (__u16) ('|' + 0xF000)
#define UNI_SLASH       (__u16) ('\\' + 0xF000)
641 642 643 644 645 646

/* Convert 16 bit Unicode pathname from wire format to string in current code
   page.  Conversion may involve remapping up the seven characters that are
   only legal in POSIX-like OS (if they are present in the string). Path
   names are little endian 16 bit Unicode on the wire */
int
S
Steve French 已提交
647 648
cifs_convertUCSpath(char *target, const __le16 *source, int maxlen,
		    const struct nls_table *cp)
649
{
S
Steve French 已提交
650
	int i, j, len;
651
	__u16 src_char;
652

S
Steve French 已提交
653
	for (i = 0, j = 0; i < maxlen; i++) {
654 655 656 657 658 659 660 661 662 663 664 665 666
		src_char = le16_to_cpu(source[i]);
		switch (src_char) {
			case 0:
				goto cUCS_out; /* BB check this BB */
			case UNI_COLON:
				target[j] = ':';
				break;
			case UNI_ASTERIK:
				target[j] = '*';
				break;
			case UNI_QUESTION:
				target[j] = '?';
				break;
667 668 669 670 671 672
			/* BB We can not handle remapping slash until
			   all the calls to build_path_from_dentry
			   are modified, as they use slash as separator BB */
			/* case UNI_SLASH:
				target[j] = '\\';
				break;*/
673 674 675 676 677 678 679 680
			case UNI_PIPE:
				target[j] = '|';
				break;
			case UNI_GRTRTHAN:
				target[j] = '>';
				break;
			case UNI_LESSTHAN:
				target[j] = '<';
681
				break;
S
Steve French 已提交
682 683
			default:
				len = cp->uni2char(src_char, &target[j],
684
						NLS_MAX_CHARSET_SIZE);
S
Steve French 已提交
685
				if (len > 0) {
686 687 688 689 690 691 692
					j += len;
					continue;
				} else {
					target[j] = '?';
				}
		}
		j++;
693
		/* make sure we do not overrun callers allocated temp buffer */
S
Steve French 已提交
694
		if (j >= (2 * NAME_MAX))
695 696 697 698 699 700
			break;
	}
cUCS_out:
	target[j] = 0;
	return j;
}
701 702 703 704 705 706

/* Convert 16 bit Unicode pathname to wire format from string in current code
   page.  Conversion may involve remapping up the seven characters that are
   only legal in POSIX-like OS (if they are present in the string). Path
   names are little endian 16 bit Unicode on the wire */
int
S
Steve French 已提交
707 708
cifsConvertToUCS(__le16 *target, const char *source, int maxlen,
		 const struct nls_table *cp, int mapChars)
709
{
S
Steve French 已提交
710
	int i, j, charlen;
711 712
	int len_remaining = maxlen;
	char src_char;
713
	__u16 temp;
714

S
Steve French 已提交
715
	if (!mapChars)
716
		return cifs_strtoUCS(target, source, PATH_MAX, cp);
717

S
Steve French 已提交
718
	for (i = 0, j = 0; i < maxlen; j++) {
719 720 721
		src_char = source[i];
		switch (src_char) {
			case 0:
722
				target[j] = 0;
723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740
				goto ctoUCS_out;
			case ':':
				target[j] = cpu_to_le16(UNI_COLON);
				break;
			case '*':
				target[j] = cpu_to_le16(UNI_ASTERIK);
				break;
			case '?':
				target[j] = cpu_to_le16(UNI_QUESTION);
				break;
			case '<':
				target[j] = cpu_to_le16(UNI_LESSTHAN);
				break;
			case '>':
				target[j] = cpu_to_le16(UNI_GRTRTHAN);
				break;
			case '|':
				target[j] = cpu_to_le16(UNI_PIPE);
S
Steve French 已提交
741
				break;
742 743 744 745 746 747 748 749
			/* BB We can not handle remapping slash until
			   all the calls to build_path_from_dentry
			   are modified, as they use slash as separator BB */
			/* case '\\':
				target[j] = cpu_to_le16(UNI_SLASH);
				break;*/
			default:
				charlen = cp->char2uni(source+i,
750
					len_remaining, &temp);
751 752
				/* if no match, use question mark, which
				at least in some cases servers as wild card */
S
Steve French 已提交
753
				if (charlen < 1) {
754 755
					target[j] = cpu_to_le16(0x003f);
					charlen = 1;
756 757
				} else
					target[j] = cpu_to_le16(temp);
758 759 760 761
				len_remaining -= charlen;
				/* character may take more than one byte in the
				   the source string, but will take exactly two
				   bytes in the target string */
S
Steve French 已提交
762
				i += charlen;
763 764 765 766 767 768 769 770 771
				continue;
		}
		i++; /* move to next char in source string */
		len_remaining--;
	}

ctoUCS_out:
	return i;
}