fixed SMB2 locking

- SMB2 locking is different in several ways from SMB locking. To fix
  it properly we will need a new generic mapping structure for
  locking, but for now do a best effort mapping

- added locking to gentest_smb2
(This used to be commit ea6d9cf602302adafe0f9d5f5f90a9b26d1ead6f)

2 files changed, 31 insertions, 21 deletions

diff --git a/source4/libcli/raw/interfaces.h b/source4/libcli/raw/interfaces.h
index 871bab01db..149b91916a 100644
--- a/source4/libcli/raw/interfaces.h
+++ b/source4/libcli/raw/interfaces.h
@@ -1866,13 +1866,12 @@ enum smb_lock_level {
 	RAW_LOCK_SMB2_BREAK
 };
 
-/* the generic interface is defined to be equal to the lockingX interface */
-#define RAW_LOCK_GENERIC RAW_LOCK_LOCKX
+#define	RAW_LOCK_GENERIC RAW_LOCK_LOCKX
 
 /* union for lock() backend call 
 */
 union smb_lock {
-	/* SMBlockingX (and generic) interface */
+	/* SMBlockingX and generic interface */
 	struct {
 		enum smb_lock_level level;
 		struct {
@@ -1887,7 +1886,7 @@ union smb_lock {
 				uint64_t count;
 			} *locks; /* unlocks are first in the arrray */
 		} in;
-	} lockx, generic;
+	} generic, lockx;
 
 	/* SMBlock and SMBunlock interface */
 	struct {
@@ -1907,23 +1906,26 @@ union smb_lock {
 
 			/* static body buffer 48 (0x30) bytes */
 			/* uint16_t buffer_code;  0x30 */
-			uint16_t unknown1; /* must be 0x0001 */
-			uint32_t unknown2;
+			uint16_t lock_count;
+			uint32_t reserved;
 			/* struct smb2_handle handle; */
-			uint64_t offset;
-			uint64_t count;
-			uint32_t unknown5;
+			struct smb2_lock_element {
+				uint64_t offset;
+				uint64_t length;
+/* these flags are the same as the SMB2 lock flags */
 #define SMB2_LOCK_FLAG_NONE		0x00000000
 #define SMB2_LOCK_FLAG_SHARED		0x00000001
-#define SMB2_LOCK_FLAG_EXCLUSIV		0x00000002
+#define SMB2_LOCK_FLAG_EXCLUSIVE	0x00000002
 #define SMB2_LOCK_FLAG_UNLOCK		0x00000004
-#define SMB2_LOCK_FLAG_NO_PENDING	0x00000010
-			uint32_t flags;
+#define SMB2_LOCK_FLAG_FAIL_IMMEDIATELY	0x00000010
+				uint32_t flags;
+				uint32_t reserved;
+			} *locks;
 		} in;
 		struct {
 			/* static body buffer 4 (0x04) bytes */
 			/* uint16_t buffer_code;  0x04 */
-			uint16_t unknown1;
+			uint16_t reserved;
 		} out;
 	} smb2;
 
diff --git a/source4/libcli/smb2/lock.c b/source4/libcli/smb2/lock.c
index d71a337d56..62c6e5dba7 100644
--- a/source4/libcli/smb2/lock.c
+++ b/source4/libcli/smb2/lock.c
@@ -29,17 +29,25 @@
 struct smb2_request *smb2_lock_send(struct smb2_tree *tree, struct smb2_lock *io)
 {
 	struct smb2_request *req;
+	int i;
 
-	req = smb2_request_init_tree(tree, SMB2_OP_LOCK, 0x30, false, 0);
+	req = smb2_request_init_tree(tree, SMB2_OP_LOCK, 
+				     24 + io->in.lock_count*24, false, 0);
 	if (req == NULL) return NULL;
 
-	SSVAL(req->out.body, 0x02, io->in.unknown1);
-	SIVAL(req->out.body, 0x04, io->in.unknown2);
+	/* this is quite bizarre - the spec says we must lie about the length! */
+	SSVAL(req->out.body, 0, 0x30);
+
+	SSVAL(req->out.body, 0x02, io->in.lock_count);
+	SIVAL(req->out.body, 0x04, io->in.reserved);
 	smb2_push_handle(req->out.body+0x08, &io->in.file.handle);
-	SBVAL(req->out.body, 0x18, io->in.offset);
-	SBVAL(req->out.body, 0x20, io->in.count);
-	SIVAL(req->out.body, 0x24, io->in.unknown5);
-	SIVAL(req->out.body, 0x28, io->in.flags);
+
+	for (i=0;i<io->in.lock_count;i++) {
+		SBVAL(req->out.body, 0x18 + i*24, io->in.locks[i].offset);
+		SBVAL(req->out.body, 0x20 + i*24, io->in.locks[i].length);
+		SIVAL(req->out.body, 0x28 + i*24, io->in.locks[i].flags);
+		SIVAL(req->out.body, 0x2C + i*24, io->in.locks[i].reserved);
+	}
 
 	smb2_transport_send(req);
 
@@ -59,7 +67,7 @@ NTSTATUS smb2_lock_recv(struct smb2_request *req, struct smb2_lock *io)
 
 	SMB2_CHECK_PACKET_RECV(req, 0x04, false);
 
-	io->out.unknown1 = SVAL(req->in.body, 0x02);
+	io->out.reserved = SVAL(req->in.body, 0x02);
 
 	return smb2_request_destroy(req);
 }