1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
/*
* Unix SMB/CIFS implementation.
*
* test suite for SMB2 replay
*
* Copyright (C) Anubhav Rakshit 2014
* Copyright (C) Stefan Metzmacher 2014
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "includes.h"
#include "libcli/smb2/smb2.h"
#include "libcli/smb2/smb2_calls.h"
#include "torture/torture.h"
#include "torture/smb2/proto.h"
#include "../libcli/smb/smbXcli_base.h"
#include "oplock_break_handler.h"
#include "lib/events/events.h"
struct break_info break_info;
static void torture_oplock_ack_callback(struct smb2_request *req)
{
NTSTATUS status;
status = smb2_break_recv(req, &break_info.br);
if (!NT_STATUS_IS_OK(status)) {
break_info.failures++;
break_info.failure_status = status;
}
}
/**
* A general oplock break notification handler. This should be used when a
* test expects to break from batch or exclusive to a lower level.
*/
bool torture_oplock_ack_handler(struct smb2_transport *transport,
const struct smb2_handle *handle,
uint8_t level,
void *private_data)
{
struct smb2_tree *tree = private_data;
const char *name;
struct smb2_request *req;
ZERO_STRUCT(break_info.br);
break_info.handle = *handle;
break_info.level = level;
break_info.count++;
switch (level) {
case SMB2_OPLOCK_LEVEL_II:
name = "level II";
break;
case SMB2_OPLOCK_LEVEL_NONE:
name = "none";
break;
default:
name = "unknown";
break_info.failures++;
}
break_info.br.in.file.handle = *handle;
break_info.br.in.oplock_level = level;
break_info.br.in.reserved = 0;
break_info.br.in.reserved2 = 0;
break_info.received_transport = tree->session->transport;
SMB_ASSERT(tree->session->transport == transport);
if (break_info.oplock_skip_ack) {
torture_comment(break_info.tctx,
"transport[%p] skip acking to %s [0x%02X] in oplock handler\n",
transport, name, level);
return true;
}
torture_comment(break_info.tctx,
"transport[%p] Acking to %s [0x%02X] in oplock handler\n",
transport, name, level);
req = smb2_break_send(tree, &break_info.br);
req->async.fn = torture_oplock_ack_callback;
req->async.private_data = NULL;
return true;
}
/**
* A oplock break handler designed to ignore incoming break requests.
* This is used when incoming oplock break requests need to be ignored
*/
bool torture_oplock_ignore_handler(struct smb2_transport *transport,
const struct smb2_handle *handle,
uint8_t level, void *private_data)
{
return true;
}
/*
* Timer handler function notifies the registering function that time is up
*/
static void timeout_cb(struct tevent_context *ev,
struct tevent_timer *te,
struct timeval current_time,
void *private_data)
{
bool *timesup = (bool *)private_data;
*timesup = true;
}
/*
* Wait a short period of time to receive a single oplock break request
*/
void torture_wait_for_oplock_break(struct torture_context *tctx)
{
TALLOC_CTX *tmp_ctx = talloc_new(NULL);
struct tevent_timer *te = NULL;
struct timeval ne;
bool timesup = false;
int old_count = break_info.count;
/* Wait 1 second for an oplock break */
ne = tevent_timeval_current_ofs(0, 1000000);
te = tevent_add_timer(tctx->ev, tmp_ctx, ne, timeout_cb, ×up);
if (te == NULL) {
torture_comment(tctx, "Failed to wait for an oplock break. "
"test results may not be accurate.\n");
goto done;
}
torture_comment(tctx, "Waiting for a potential oplock break...\n");
while (!timesup && break_info.count < old_count + 1) {
if (tevent_loop_once(tctx->ev) != 0) {
torture_comment(tctx, "Failed to wait for an oplock "
"break. test results may not be "
"accurate\n.");
goto done;
}
}
if (timesup) {
torture_comment(tctx, "... waiting for an oplock break timed out\n");
} else {
torture_comment(tctx, "Got %u oplock breaks\n",
break_info.count - old_count);
}
done:
/* We don't know if the timed event fired and was freed, we received
* our oplock break, or some other event triggered the loop. Thus,
* we create a tmp_ctx to be able to safely free/remove the timed
* event in all 3 cases.
*/
talloc_free(tmp_ctx);
}
|
