misc.c 22.5 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3
/*
 *   fs/cifs/misc.c
 *
4
 *   Copyright (C) International Business Machines  Corp., 2002,2008
Linus Torvalds's avatar
Linus Torvalds committed
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
Steve French's avatar
Steve French committed
19
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Linus Torvalds's avatar
Linus Torvalds committed
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"
Linus Torvalds's avatar
Linus Torvalds committed
32 33 34

extern mempool_t *cifs_sm_req_poolp;
extern mempool_t *cifs_req_poolp;
Steve French's avatar
Steve French committed
35
extern struct task_struct *oplockThread;
Linus Torvalds's avatar
Linus Torvalds committed
36

Steve French's avatar
Steve French committed
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
Linus Torvalds's avatar
Linus Torvalds committed
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 */
Linus Torvalds's avatar
Linus Torvalds committed
52
	if (GlobalTotalActiveXid > GlobalMaxActiveXid)
53
		GlobalMaxActiveXid = GlobalTotalActiveXid;
54
	if (GlobalTotalActiveXid > 65000)
Steve French's avatar
Steve French committed
55
		cFYI(1, ("warning: more than 65000 requests active"));
Linus Torvalds's avatar
Linus Torvalds committed
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);
65
	/* if (GlobalTotalActiveXid == 0)
Linus Torvalds's avatar
Linus Torvalds committed
66 67 68 69 70 71 72 73 74 75
		BUG(); */
	GlobalTotalActiveXid--;
	spin_unlock(&GlobalMid_Lock);
}

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

Steve French's avatar
Steve French committed
76
	ret_buf = kzalloc(sizeof(struct cifsSesInfo), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
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);
Linus Torvalds's avatar
Linus Torvalds committed
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);
Jesper Juhl's avatar
Jesper Juhl committed
97 98 99
	kfree(buf_to_free->serverOS);
	kfree(buf_to_free->serverDomain);
	kfree(buf_to_free->serverNOS);
100 101 102 103
	if (buf_to_free->password) {
		memset(buf_to_free->password, 0, strlen(buf_to_free->password));
		kfree(buf_to_free->password);
	}
104
	kfree(buf_to_free->domainName);
Linus Torvalds's avatar
Linus Torvalds committed
105 106 107 108 109 110 111
	kfree(buf_to_free);
}

struct cifsTconInfo *
tconInfoAlloc(void)
{
	struct cifsTconInfo *ret_buf;
Steve French's avatar
Steve French committed
112
	ret_buf = kzalloc(sizeof(struct cifsTconInfo), GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
113 114 115
	if (ret_buf) {
		atomic_inc(&tconInfoAllocCount);
		ret_buf->tidStatus = CifsNew;
116
		++ret_buf->tc_count;
Linus Torvalds's avatar
Linus Torvalds committed
117
		INIT_LIST_HEAD(&ret_buf->openFileList);
118
		INIT_LIST_HEAD(&ret_buf->tcon_list);
Linus Torvalds's avatar
Linus Torvalds committed
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
#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);
Jesper Juhl's avatar
Jesper Juhl committed
134
	kfree(buf_to_free->nativeFileSystem);
Jeff Layton's avatar
Jeff Layton committed
135 136 137 138
	if (buf_to_free->password) {
		memset(buf_to_free->password, 0, strlen(buf_to_free->password));
		kfree(buf_to_free->password);
	}
Linus Torvalds's avatar
Linus Torvalds committed
139 140 141 142 143 144 145 146
	kfree(buf_to_free);
}

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

Steve French's avatar
Steve French committed
147 148 149
/* 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
Linus Torvalds's avatar
Linus Torvalds committed
150
   defaults to this and can not be bigger */
151
	ret_buf = mempool_alloc(cifs_req_poolp, GFP_NOFS);
Linus Torvalds's avatar
Linus Torvalds committed
152 153 154 155 156 157

	/* 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);
158 159 160
#ifdef CONFIG_CIFS_STATS2
		atomic_inc(&totBufAllocCount);
#endif /* CONFIG_CIFS_STATS2 */
Linus Torvalds's avatar
Linus Torvalds committed
161 162 163 164 165 166 167 168 169 170 171 172
	}

	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;
	}
Steve French's avatar
Steve French committed
173
	mempool_free(buf_to_free, cifs_req_poolp);
Linus Torvalds's avatar
Linus Torvalds committed
174 175 176 177 178 179 180 181 182 183

	atomic_dec(&bufAllocCount);
	return;
}

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

Steve French's avatar
Steve French committed
184 185 186
/* 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
Linus Torvalds's avatar
Linus Torvalds committed
187
   defaults to this and can not be bigger */
188
	ret_buf = mempool_alloc(cifs_sm_req_poolp, GFP_NOFS);
Linus Torvalds's avatar
Linus Torvalds committed
189 190 191 192
	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);
193 194 195 196
#ifdef CONFIG_CIFS_STATS2
		atomic_inc(&totSmBufAllocCount);
#endif /* CONFIG_CIFS_STATS2 */

Linus Torvalds's avatar
Linus Torvalds committed
197 198 199 200 201 202 203 204 205 206 207 208
	}
	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;
	}
Steve French's avatar
Steve French committed
209
	mempool_free(buf_to_free, cifs_sm_req_poolp);
Linus Torvalds's avatar
Linus Torvalds committed
210 211 212 213 214

	atomic_dec(&smBufAllocCount);
	return;
}

Steve French's avatar
Steve French committed
215
/*
216 217 218 219 220 221
	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
Steve French's avatar
Steve French committed
222
	64K-1 requests can be outstanding at one time.  If no
223 224
	mids are available, return zero.  A future optimization
	could make the combination of mids and uid the key we use
Steve French's avatar
Steve French committed
225
	to demultiplex on (rather than mid alone).
226 227 228 229 230 231
	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)
Steve French's avatar
Steve French committed
232
	we do have to limit the number of outstanding requests
233 234 235 236 237 238 239
	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;
Steve French's avatar
Steve French committed
240
	int   collision;
241

242
	if (server == NULL)
243 244 245 246 247 248
		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.
Steve French's avatar
Steve French committed
249
	In practice the list of pending requests is short,
250 251 252 253 254
	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) */
Steve French's avatar
Steve French committed
255
	while (server->CurrentMid != last_mid) {
256 257 258 259
		struct list_head *tmp;
		struct mid_q_entry *mid_entry;

		collision = 0;
260
		if (server->CurrentMid == 0)
261 262 263 264 265 266 267 268 269 270 271 272
			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;
			}
		}
273
		if (collision == 0) {
274 275 276 277 278 279 280 281 282 283 284
			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 */
Linus Torvalds's avatar
Linus Torvalds committed
285 286 287 288 289
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  */)
{
Steve French's avatar
Steve French committed
290 291
	struct list_head *temp_item;
	struct cifsSesInfo *ses;
Linus Torvalds's avatar
Linus Torvalds committed
292 293
	char *temp = (char *) buffer;

Steve French's avatar
Steve French committed
294
	memset(temp, 0, 256); /* bigger than MAX_CIFS_HDR_SIZE */
Linus Torvalds's avatar
Linus Torvalds committed
295 296

	buffer->smb_buf_length =
Steve French's avatar
Steve French committed
297
	    (2 * word_count) + sizeof(struct smb_hdr) -
Linus Torvalds's avatar
Linus Torvalds committed
298 299
	    4 /*  RFC 1001 length field does not count */  +
	    2 /* for bcc field itself */ ;
300 301
	/* 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 */
Linus Torvalds's avatar
Linus Torvalds committed
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316

	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;
317
			if (treeCon->ses->capabilities & CAP_STATUS32)
Linus Torvalds's avatar
Linus Torvalds committed
318
				buffer->Flags2 |= SMBFLG2_ERR_STATUS;
319

320 321 322
			/* Uid is not converted */
			buffer->Uid = treeCon->ses->Suid;
			buffer->Mid = GetNextMid(treeCon->ses->server);
323
			if (multiuser_mount != 0) {
Linus Torvalds's avatar
Linus Torvalds committed
324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
		/* 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  */
Steve French's avatar
Steve French committed
346
		/*      with userid/password pairs found on the smb session   */
Linus Torvalds's avatar
Linus Torvalds committed
347
		/*	for other target tcp/ip addresses 		BB    */
348
				if (current_fsuid() != treeCon->ses->linux_uid) {
349 350
					cFYI(1, ("Multiuser mode and UID "
						 "did not match tcon uid"));
351 352 353
					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);
354
						if (ses->linux_uid == current_fsuid()) {
355
							if (ses->server == treeCon->ses->server) {
Steve French's avatar
Steve French committed
356
								cFYI(1, ("found matching uid substitute right smb_uid"));
Linus Torvalds's avatar
Linus Torvalds committed
357 358 359
								buffer->Uid = ses->Suid;
								break;
							} else {
Steve French's avatar
Steve French committed
360 361
				/* BB eventually call cifs_setup_session here */
								cFYI(1, ("local UID found but no smb sess with this server exists"));
Linus Torvalds's avatar
Linus Torvalds committed
362 363 364
							}
						}
					}
365
					read_unlock(&cifs_tcp_ses_lock);
Linus Torvalds's avatar
Linus Torvalds committed
366 367 368 369 370
				}
			}
		}
		if (treeCon->Flags & SMB_SHARE_IS_IN_DFS)
			buffer->Flags2 |= SMBFLG2_DFS;
371 372
		if (treeCon->nocase)
			buffer->Flags  |= SMBFLG_CASELESS;
373 374
		if ((treeCon->ses) && (treeCon->ses->server))
			if (treeCon->ses->server->secMode &
Linus Torvalds's avatar
Linus Torvalds committed
375 376 377 378 379 380 381 382 383
			  (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;
}

384
static int
Linus Torvalds's avatar
Linus Torvalds committed
385 386
checkSMBhdr(struct smb_hdr *smb, __u16 mid)
{
Steve French's avatar
Steve French committed
387
	/* Make sure that this really is an SMB, that it is a response,
Linus Torvalds's avatar
Linus Torvalds committed
388
	   and that the message ids match */
Steve French's avatar
Steve French committed
389 390
	if ((*(__le32 *) smb->Protocol == cpu_to_le32(0x424d53ff)) &&
		(mid == smb->Mid)) {
391
		if (smb->Flags & SMBFLG_RESPONSE)
Steve French's avatar
Steve French committed
392 393
			return 0;
		else {
Linus Torvalds's avatar
Linus Torvalds committed
394
		/* only one valid case where server sends us request */
395
			if (smb->Command == SMB_COM_LOCKING_ANDX)
Linus Torvalds's avatar
Linus Torvalds committed
396 397
				return 0;
			else
Steve French's avatar
Steve French committed
398
				cERROR(1, ("Received Request not response"));
Linus Torvalds's avatar
Linus Torvalds committed
399 400 401 402
		}
	} else { /* bad signature or mid */
		if (*(__le32 *) smb->Protocol != cpu_to_le32(0x424d53ff))
			cERROR(1,
403
			       ("Bad protocol string signature header %x",
Linus Torvalds's avatar
Linus Torvalds committed
404 405 406 407 408 409 410 411 412
				*(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
413
checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length)
Linus Torvalds's avatar
Linus Torvalds committed
414
{
415
	__u32 len = smb->smb_buf_length;
416
	__u32 clc_len;  /* calculated length */
417
	cFYI(0, ("checkSMB Length: 0x%x, smb_buf_length: 0x%x", length, len));
418

Steve French's avatar
Steve French committed
419 420
	if (length < 2 + sizeof(struct smb_hdr)) {
		if ((length >= sizeof(struct smb_hdr) - 1)
Linus Torvalds's avatar
Linus Torvalds committed
421
			    && (smb->Status.CifsError != 0)) {
422 423 424
			smb->WordCount = 0;
			/* some error cases do not return wct and bcc */
			return 0;
Steve French's avatar
Steve French committed
425
		} else if ((length == sizeof(struct smb_hdr) + 1) &&
426
				(smb->WordCount == 0)) {
Steve French's avatar
Steve French committed
427
			char *tmp = (char *)smb;
428 429 430 431 432 433 434 435 436 437 438
			/* 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;
439
				return 0;
Linus Torvalds's avatar
Linus Torvalds committed
440
			}
Steve French's avatar
Steve French committed
441
			cERROR(1, ("rcvd invalid byte count (bcc)"));
442 443
		} else {
			cERROR(1, ("Length less than smb header size"));
Linus Torvalds's avatar
Linus Torvalds committed
444
		}
445 446 447 448
		return 1;
	}
	if (len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) {
		cERROR(1, ("smb length greater than MaxBufSize, mid=%d",
449
				   smb->Mid));
Linus Torvalds's avatar
Linus Torvalds committed
450 451 452 453 454
		return 1;
	}

	if (checkSMBhdr(smb, mid))
		return 1;
455
	clc_len = smbCalcSize_LE(smb);
456

457
	if (4 + len != length) {
458 459
		cERROR(1, ("Length read does not match RFC1001 length %d",
			   len));
460 461 462 463 464
		return 1;
	}

	if (4 + len != clc_len) {
		/* check if bcc wrapped around for large read responses */
465
		if ((len > 64 * 1024) && (len > clc_len)) {
466
			/* check if lengths match mod 64K */
467
			if (((4 + len) & 0xFFFF) == (clc_len & 0xFFFF))
Steve French's avatar
Steve French committed
468
				return 0; /* bcc wrapped */
469
		}
470 471
		cFYI(1, ("Calculated size %d vs length %d mismatch for mid %d",
				clc_len, 4 + len, smb->Mid));
472
		/* Windows XP can return a few bytes too much, presumably
Steve French's avatar
Steve French committed
473
		an illegal pad, at the end of byte range lock responses
474
		so we allow for that three byte pad, as long as actual
475
		received length is as long or longer than calculated length */
Steve French's avatar
Steve French committed
476
		/* We have now had to extend this more, since there is a
477 478 479 480 481 482
		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 */
483
		if ((4+len > clc_len) && (len <= clc_len + 512))
484
			return 0;
485 486 487
		else {
			cERROR(1, ("RFC1001 size %d bigger than SMB for Mid=%d",
					len, smb->Mid));
488
			return 1;
489
		}
Linus Torvalds's avatar
Linus Torvalds committed
490
	}
491
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
492
}
493 494

bool
495
is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
Steve French's avatar
Steve French committed
496 497
{
	struct smb_com_lock_req *pSMB = (struct smb_com_lock_req *)buf;
498 499
	struct list_head *tmp, *tmp1, *tmp2;
	struct cifsSesInfo *ses;
Linus Torvalds's avatar
Linus Torvalds committed
500
	struct cifsTconInfo *tcon;
501
	struct cifsInodeInfo *pCifsInode;
Linus Torvalds's avatar
Linus Torvalds committed
502 503
	struct cifsFileInfo *netfile;

Steve French's avatar
Steve French committed
504
	cFYI(1, ("Checking for oplock break or dnotify response"));
505
	if ((pSMB->hdr.Command == SMB_COM_NT_TRANSACT) &&
Linus Torvalds's avatar
Linus Torvalds committed
506
	   (pSMB->hdr.Flags & SMBFLG_RESPONSE)) {
Steve French's avatar
Steve French committed
507
		struct smb_com_transaction_change_notify_rsp *pSMBr =
Linus Torvalds's avatar
Linus Torvalds committed
508
			(struct smb_com_transaction_change_notify_rsp *)buf;
Steve French's avatar
Steve French committed
509
		struct file_notify_information *pnotify;
Linus Torvalds's avatar
Linus Torvalds committed
510
		__u32 data_offset = 0;
511
		if (pSMBr->ByteCount > sizeof(struct file_notify_information)) {
Linus Torvalds's avatar
Linus Torvalds committed
512 513
			data_offset = le32_to_cpu(pSMBr->DataOffset);

514 515
			pnotify = (struct file_notify_information *)
				((char *)&pSMBr->hdr.Protocol + data_offset);
516
			cFYI(1, ("dnotify on %s Action: 0x%x",
517
				 pnotify->FileName, pnotify->Action));
Steve French's avatar
Steve French committed
518
			/*   cifs_dump_mem("Rcvd notify Data: ",buf,
519
				sizeof(struct smb_hdr)+60); */
520
			return true;
Linus Torvalds's avatar
Linus Torvalds committed
521
		}
522
		if (pSMBr->hdr.Status.CifsError) {
Steve French's avatar
Steve French committed
523 524
			cFYI(1, ("notify err 0x%d",
				pSMBr->hdr.Status.CifsError));
525
			return true;
Linus Torvalds's avatar
Linus Torvalds committed
526
		}
527
		return false;
Steve French's avatar
Steve French committed
528
	}
529
	if (pSMB->hdr.Command != SMB_COM_LOCKING_ANDX)
530
		return false;
531
	if (pSMB->hdr.Flags & SMBFLG_RESPONSE) {
Linus Torvalds's avatar
Linus Torvalds committed
532 533 534 535
		/* 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 */
Steve French's avatar
Steve French committed
536 537 538
		if ((NT_STATUS_INVALID_HANDLE) ==
		   le32_to_cpu(pSMB->hdr.Status.CifsError)) {
			cFYI(1, ("invalid handle on oplock break"));
539
			return true;
Steve French's avatar
Steve French committed
540
		} else if (ERRbadfid ==
Linus Torvalds's avatar
Linus Torvalds committed
541
		   le16_to_cpu(pSMB->hdr.Status.DosError.Error)) {
542
			return true;
Linus Torvalds's avatar
Linus Torvalds committed
543
		} else {
544
			return false; /* on valid oplock brk we get "request" */
Linus Torvalds's avatar
Linus Torvalds committed
545 546
		}
	}
547
	if (pSMB->hdr.WordCount != 8)
548
		return false;
Linus Torvalds's avatar
Linus Torvalds committed
549

Steve French's avatar
Steve French committed
550 551
	cFYI(1, ("oplock type 0x%d level 0x%d",
		 pSMB->LockType, pSMB->OplockLevel));
552
	if (!(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE))
553
		return false;
Linus Torvalds's avatar
Linus Torvalds committed
554 555

	/* look up tcon based on tid & uid */
556 557 558 559 560 561 562 563
	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;

564
			cifs_stats_inc(&tcon->num_oplock_brks);
565
			write_lock(&GlobalSMBSeslock);
566 567
			list_for_each(tmp2, &tcon->openFileList) {
				netfile = list_entry(tmp2, struct cifsFileInfo,
568
						     tlist);
569 570 571
				if (pSMB->Fid != netfile->netfid)
					continue;

572
				write_unlock(&GlobalSMBSeslock);
573 574 575 576 577 578 579 580 581 582 583 584 585 586
				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;
Linus Torvalds's avatar
Linus Torvalds committed
587
			}
588
			write_unlock(&GlobalSMBSeslock);
589
			read_unlock(&cifs_tcp_ses_lock);
Steve French's avatar
Steve French committed
590
			cFYI(1, ("No matching file for oplock break"));
591
			return true;
Linus Torvalds's avatar
Linus Torvalds committed
592 593
		}
	}
594
	read_unlock(&cifs_tcp_ses_lock);
Steve French's avatar
Steve French committed
595
	cFYI(1, ("Can not process oplock break for non-existent connection"));
596
	return true;
Linus Torvalds's avatar
Linus Torvalds committed
597 598 599 600 601 602 603 604 605 606 607 608 609 610
}

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++) {
611 612
		if (i % 8 == 0) {
			/* have reached the beginning of line */
Linus Torvalds's avatar
Linus Torvalds committed
613 614 615 616 617 618 619 620 621 622
			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)] = '_';

623 624
		if (i % 8 == 7) {
			/* reached end of line, time to print ascii */
Linus Torvalds's avatar
Linus Torvalds committed
625 626 627 628 629 630 631 632 633
			debug_line[16] = 0;
			printk(" | %s\n", debug_line);
		}
	}
	for (; j < 8; j++) {
		printk("     ");
		debug_line[2 * j] = ' ';
		debug_line[1 + (2 * j)] = ' ';
	}
634
	printk(" | %s\n", debug_line);
Linus Torvalds's avatar
Linus Torvalds committed
635 636
	return;
}
637 638 639 640 641 642

/* 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
Steve French's avatar
Steve French committed
643 644
cifs_convertUCSpath(char *target, const __le16 *source, int maxlen,
		    const struct nls_table *cp)
645
{
Steve French's avatar
Steve French committed
646
	int i, j, len;
647
	__u16 src_char;
648

Steve French's avatar
Steve French committed
649
	for (i = 0, j = 0; i < maxlen; i++) {
650 651 652 653 654 655 656 657 658 659 660 661 662
		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;
663 664 665 666 667 668
			/* 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;*/
669 670 671 672 673 674 675 676
			case UNI_PIPE:
				target[j] = '|';
				break;
			case UNI_GRTRTHAN:
				target[j] = '>';
				break;
			case UNI_LESSTHAN:
				target[j] = '<';
677
				break;
Steve French's avatar
Steve French committed
678 679
			default:
				len = cp->uni2char(src_char, &target[j],
680
						NLS_MAX_CHARSET_SIZE);
681
				if (len > 0) {
682 683 684 685 686 687 688
					j += len;
					continue;
				} else {
					target[j] = '?';
				}
		}
		j++;
689
		/* make sure we do not overrun callers allocated temp buffer */
690
		if (j >= (2 * NAME_MAX))
691 692 693 694 695 696
			break;
	}
cUCS_out:
	target[j] = 0;
	return j;
}
697 698 699 700 701 702

/* 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
Steve French's avatar
Steve French committed
703 704
cifsConvertToUCS(__le16 *target, const char *source, int maxlen,
		 const struct nls_table *cp, int mapChars)
705
{
Steve French's avatar
Steve French committed
706
	int i, j, charlen;
707 708
	int len_remaining = maxlen;
	char src_char;
709
	__u16 temp;
710

711
	if (!mapChars)
712
		return cifs_strtoUCS(target, source, PATH_MAX, cp);
713

Steve French's avatar
Steve French committed
714
	for (i = 0, j = 0; i < maxlen; j++) {
715 716 717
		src_char = source[i];
		switch (src_char) {
			case 0:
718
				target[j] = 0;
719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736
				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);
Steve French's avatar
Steve French committed
737
				break;
738 739 740 741 742 743 744 745
			/* 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,
746
					len_remaining, &temp);
747 748
				/* if no match, use question mark, which
				at least in some cases servers as wild card */
749
				if (charlen < 1) {
750 751
					target[j] = cpu_to_le16(0x003f);
					charlen = 1;
752 753
				} else
					target[j] = cpu_to_le16(temp);
754 755 756 757
				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 */
Steve French's avatar
Steve French committed
758
				i += charlen;
759 760 761 762 763 764 765 766 767
				continue;
		}
		i++; /* move to next char in source string */
		len_remaining--;
	}

ctoUCS_out:
	return i;
}