/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2009 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* * SMB: locking_andx * * SMB_COM_LOCKING_ANDX allows both locking and/or unlocking of file range(s). * * Client Request Description * ================================== ================================= * * UCHAR WordCount; Count of parameter words = 8 * UCHAR AndXCommand; Secondary (X) command; 0xFF = none * UCHAR AndXReserved; Reserved (must be 0) * USHORT AndXOffset; Offset to next command WordCount * USHORT Fid; File handle * UCHAR LockType; See LockType table below * UCHAR OplockLevel; The new oplock level * ULONG Timeout; Milliseconds to wait for unlock * USHORT NumberOfUnlocks; Num. unlock range structs following * USHORT NumberOfLocks; Num. lock range structs following * USHORT ByteCount; Count of data bytes * LOCKING_ANDX_RANGE Unlocks[]; Unlock ranges * LOCKING_ANDX_RANGE Locks[]; Lock ranges * * LockType Flag Name Value Description * ============================ ===== ================================ * * LOCKING_ANDX_SHARED_LOCK 0x01 Read-only lock * LOCKING_ANDX_OPLOCK_RELEASE 0x02 Oplock break notification * LOCKING_ANDX_CHANGE_LOCKTYPE 0x04 Change lock type * LOCKING_ANDX_CANCEL_LOCK 0x08 Cancel outstanding request * LOCKING_ANDX_LARGE_FILES 0x10 Large file locking format * * LOCKING_ANDX_RANGE Format * ===================================================================== * * USHORT Pid; PID of process "owning" lock * ULONG Offset; Offset to bytes to [un]lock * ULONG Length; Number of bytes to [un]lock * * Large File LOCKING_ANDX_RANGE Format * ===================================================================== * * USHORT Pid; PID of process "owning" lock * USHORT Pad; Pad to DWORD align (mbz) * ULONG OffsetHigh; Offset to bytes to [un]lock * (high) * ULONG OffsetLow; Offset to bytes to [un]lock (low) * ULONG LengthHigh; Number of bytes to [un]lock * (high) * ULONG LengthLow; Number of bytes to [un]lock (low) * * Server Response Description * ================================== ================================= * * UCHAR WordCount; Count of parameter words = 2 * UCHAR AndXCommand; Secondary (X) command; 0xFF = * none * UCHAR AndXReserved; Reserved (must be 0) * USHORT AndXOffset; Offset to next command WordCount * USHORT ByteCount; Count of data bytes = 0 * * Locking is a simple mechanism for excluding other processes read/write * access to regions of a file. The locked regions can be anywhere in the * logical file. Locking beyond end-of-file is permitted. Any process * using the Fid specified in this request's Fid has access to the locked * bytes, other processes will be denied the locking of the same bytes. * * The proper method for using locks is not to rely on being denied read or * write access on any of the read/write protocols but rather to attempt * the locking protocol and proceed with the read/write only if the locks * succeeded. * * Locking a range of bytes will fail if any subranges or overlapping * ranges are locked. In other words, if any of the specified bytes are * already locked, the lock will fail. * * If NumberOfUnlocks is non-zero, the Unlocks vector contains * NumberOfUnlocks elements. Each element requests that a lock at Offset * of Length be released. If NumberOfLocks is nonzero, the Locks vector * contains NumberOfLocks elements. Each element requests the acquisition * of a lock at Offset of Length. * * Timeout is the maximum amount of time to wait for the byte range(s) * specified to become unlocked. A timeout value of 0 indicates that the * server should fail immediately if any lock range specified is locked. A * * timeout value of -1 indicates that the server should wait as long as it * takes for each byte range specified to become unlocked so that it may be * again locked by this protocol. Any other value of smb_timeout specifies * the maximum number of milliseconds to wait for all lock range(s) * specified to become available. * * If any of the lock ranges timeout because of the area to be locked is * already locked (or the lock fails), the other ranges in the protocol * request which were successfully locked as a result of this protocol will * be unlocked (either all requested ranges will be locked when this * protocol returns to the client or none). * * If LockType has the LOCKING_ANDX_SHARED_LOCK flag set, the lock is * specified as a shared lock. Locks for both read and write (where * LOCKING_ANDX_SHARED_LOCK is clear) should be prohibited, but other * shared locks should be permitted. If shared locks can not be supported * by a server, the server should map the lock to a lock for both read and * write. Closing a file with locks still in force causes the locks to be * released in no defined order. * * If LockType has the LOCKING_ANDX_LARGE_FILES flag set and if the * negotiated protocol is NT LM 0.12 or later, then the Locks and Unlocks * vectors are in the Large File LOCKING_ANDX_RANGE format. This allows * specification of 64 bit offsets for very large files. * * If the one and only member of the Locks vector has the * LOCKING_ANDX_CANCEL_LOCK flag set in the LockType field, the client is * requesting the server to cancel a previously requested, but not yet * responded to, lock. * * If LockType has the LOCKING_ANDX_CHANGE_LOCKTYPE flag set, the client is * requesting that the server atomically change the lock type from a shared * lock to an exclusive lock or vice versa. If the server can not do this * in an atomic fashion, the server must reject this request. NT and W95 * servers do not support this capability. * * Oplocks are described in the "Opportunistic Locks" section elsewhere in * this document. A client requests an oplock by setting the appropriate * bit in the SMB_COM_OPEN_ANDX request when the file is being opened in a * mode which is not exclusive. The server responds by setting the * appropriate bit in the response SMB indicating whether or not the oplock * was granted. By granting the oplock, the server tells the client the * file is currently only being used by this one client process at the * current time. The client can therefore safely do read ahead and write * behind as well as local caching of file locks knowing that the file will * not be accessed/changed in any way by another process while the oplock * is in effect. The client will be notified when any other process * attempts to open or modify the oplocked file. * * When another user attempts to open or otherwise modify the file which a * client has oplocked, the server delays the second attempt and notifies * the client via an SMB_LOCKING_ANDX SMB asynchronously sent from the * server to the client. This message has the LOCKING_ANDX_OPLOCK_RELEASE * flag set indicating to the client that the oplock is being broken. * * OplockLevel indicates the type of oplock the client now owns. If * OplockLevel is 0, the client possesses no oplocks on the file at all, if * OplockLevel is 1 the client possesses a Level II oplock. The client is * expected to flush any dirty buffers to the server, submit any file locks * and respond to the server with either an SMB_LOCKING_ANDX SMB having the * LOCKING_ANDX_OPLOCK_RELEASE flag set, or with a file close if the file * is no longer in use by the client. If the client sends an * SMB_LOCKING_ANDX SMB with the LOCKING_ANDX_OPLOCK_RELEASE flag set and * NumberOfLocks is zero, the server does not send a response. Since a * close being sent to the server and break oplock notification from the * server could cross on the wire, if the client gets an oplock * notification on a file which it does not have open, that notification * should be ignored. * * Due to timing, the client could get an "oplock broken" notification in a * user's data buffer as a result of this notification crossing on the wire * with a SMB_COM_READ_RAW request. The client must detect this (use * length of msg, "FFSMB", MID of -1 and Command of SMB_COM_LOCKING_ANDX) * and honor the "oplock broken" notification as usual. The server must * also note on receipt of an SMB_COM_READ_RAW request that there is an * outstanding (unanswered) "oplock broken" notification to the client and * return a zero length response denoting failure of the read raw request. * The client should (after responding to the "oplock broken" * notification), use a standard read protocol to redo the read request. * This allows a file to actually contain data matching an "oplock broken" * notification and still be read correctly. * * The entire message sent and received including the optional second * protocol must fit in the negotiated maximum transfer size. The * following are the only valid SMB commands for AndXCommand for * SMB_COM_LOCKING_ANDX: * * SMB_COM_READ SMB_COM_READ_ANDX * SMB_COM_WRITE SMB_COM_WRITE_ANDX * SMB_COM_FLUSH * * 4.2.6.1 Errors * * ERRDOS/ERRbadfile * ERRDOS/ERRbadfid * ERRDOS/ERRlock * ERRDOS/ERRinvdevice * ERRSRV/ERRinvid * ERRSRV/ERRbaduid */ #include smb_sdrc_t smb_pre_locking_andx(smb_request_t *sr) { DTRACE_SMB_1(op__LockingX__start, smb_request_t *, sr); return (SDRC_SUCCESS); } void smb_post_locking_andx(smb_request_t *sr) { DTRACE_SMB_1(op__LockingX__done, smb_request_t *, sr); } smb_sdrc_t smb_com_locking_andx(smb_request_t *sr) { unsigned short i; unsigned char lock_type; /* See lock_type table above */ unsigned char oplock_level; /* The new oplock level */ uint32_t timeout; /* Milliseconds to wait for lock */ unsigned short unlock_num; /* # unlock range structs */ unsigned short lock_num; /* # lock range structs */ unsigned short pid; /* Process Id of owner */ uint32_t offset32, length32; uint64_t offset64; uint64_t length64; DWORD result; int rc; uint32_t ltype; rc = smbsr_decode_vwv(sr, "4.wbblww", &sr->smb_fid, &lock_type, &oplock_level, &timeout, &unlock_num, &lock_num); if (rc != 0) return (SDRC_ERROR); smbsr_lookup_file(sr); if (sr->fid_ofile == NULL) { smbsr_error(sr, NT_STATUS_INVALID_HANDLE, ERRDOS, ERRbadfid); return (SDRC_ERROR); } if (lock_type & LOCKING_ANDX_SHARED_LOCK) ltype = SMB_LOCK_TYPE_READONLY; else ltype = SMB_LOCK_TYPE_READWRITE; pid = sr->smb_pid; /* Save the original pid */ if (lock_type & LOCKING_ANDX_OPLOCK_RELEASE) { smb_oplock_release(sr->fid_ofile->f_node, sr->fid_ofile); /* * According to the protocol: * * If the client sends an SMB_LOCKING_ANDX request with the * LOCKING_ANDX_OPLOCK_RELEASE flag set * and NumberOfLocks is zero, * the server does not send a response. * * I'm not sure if it's going to break anything if I change * it according to the protocol. So, I leave it unchanged * for now. */ if (unlock_num == 0 && lock_num == 0) return (SDRC_NO_REPLY); } /* * No support for changing locktype (although we could probably * implement this) */ if (lock_type & LOCKING_ANDX_CHANGE_LOCK_TYPE) { smbsr_error(sr, 0, ERRDOS, ERRnoatomiclocks); return (SDRC_ERROR); } /* * No support for cancel lock (smbtorture expects this) */ if (lock_type & LOCKING_ANDX_CANCEL_LOCK) { smbsr_error(sr, NT_STATUS_INVALID_PARAMETER, ERRDOS, ERROR_INVALID_PARAMETER); return (SDRC_ERROR); } if (lock_type & LOCKING_ANDX_LARGE_FILES) { /* * negotiated protocol should be NT LM 0.12 or later */ if (sr->session->dialect < NT_LM_0_12) { smbsr_error(sr, NT_STATUS_INVALID_PARAMETER, ERRDOS, ERROR_INVALID_PARAMETER); return (SDRC_ERROR); } for (i = 0; i < unlock_num; i++) { rc = smb_mbc_decodef(&sr->smb_data, "w2.QQ", &sr->smb_pid, &offset64, &length64); if (rc) { /* * This is the error returned by Windows 2000 * even when STATUS32 has been negotiated. */ smbsr_error(sr, 0, ERRSRV, ERRerror); return (SDRC_ERROR); } result = smb_unlock_range(sr, sr->fid_ofile->f_node, offset64, length64); if (result != NT_STATUS_SUCCESS) { smbsr_error(sr, NT_STATUS_RANGE_NOT_LOCKED, ERRDOS, ERRnotlocked); return (SDRC_ERROR); } } for (i = 0; i < lock_num; i++) { rc = smb_mbc_decodef(&sr->smb_data, "w2.QQ", &sr->smb_pid, &offset64, &length64); if (rc) { smbsr_error(sr, 0, ERRSRV, ERRerror); return (SDRC_ERROR); } result = smb_lock_range(sr, offset64, length64, timeout, ltype); if (result != NT_STATUS_SUCCESS) { smb_lock_range_error(sr, result); return (SDRC_ERROR); } } } else { for (i = 0; i < unlock_num; i++) { rc = smb_mbc_decodef(&sr->smb_data, "wll", &sr->smb_pid, &offset32, &length32); if (rc) { smbsr_error(sr, 0, ERRSRV, ERRerror); return (SDRC_ERROR); } result = smb_unlock_range(sr, sr->fid_ofile->f_node, (uint64_t)offset32, (uint64_t)length32); if (result != NT_STATUS_SUCCESS) { smbsr_error(sr, NT_STATUS_RANGE_NOT_LOCKED, ERRDOS, ERRnotlocked); return (SDRC_ERROR); } } for (i = 0; i < lock_num; i++) { rc = smb_mbc_decodef(&sr->smb_data, "wll", &sr->smb_pid, &offset32, &length32); if (rc) { smbsr_error(sr, 0, ERRSRV, ERRerror); return (SDRC_ERROR); } result = smb_lock_range(sr, (uint64_t)offset32, (uint64_t)length32, timeout, ltype); if (result != NT_STATUS_SUCCESS) { smb_lock_range_error(sr, result); return (SDRC_ERROR); } } } sr->smb_pid = pid; if (smbsr_encode_result(sr, 2, 0, "bb.ww", 2, sr->andx_com, 7, 0)) return (SDRC_ERROR); return (SDRC_SUCCESS); }