libcli/smb: use an explicit TALLOC_FREE(subreq) in smb2cli_*
[mat/samba.git] / libcli / smb / smb2cli_set_info.c
1 /*
2    Unix SMB/CIFS implementation.
3    smb2 lib
4    Copyright (C) Stefan Metzmacher 2012
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "system/network.h"
22 #include "lib/util/tevent_ntstatus.h"
23 #include "smb_common.h"
24 #include "smbXcli_base.h"
25
26 struct smb2cli_set_info_state {
27         uint8_t fixed[0x20];
28         uint8_t dyn_pad[1];
29 };
30
31 static void smb2cli_set_info_done(struct tevent_req *subreq);
32
33 struct tevent_req *smb2cli_set_info_send(TALLOC_CTX *mem_ctx,
34                                          struct tevent_context *ev,
35                                          struct smbXcli_conn *conn,
36                                          uint32_t timeout_msec,
37                                          struct smbXcli_session *session,
38                                          struct smbXcli_tcon *tcon,
39                                          uint8_t in_info_type,
40                                          uint8_t in_file_info_class,
41                                          const DATA_BLOB *in_input_buffer,
42                                          uint32_t in_additional_info,
43                                          uint64_t in_fid_persistent,
44                                          uint64_t in_fid_volatile)
45 {
46         struct tevent_req *req, *subreq;
47         struct smb2cli_set_info_state *state;
48         uint8_t *fixed;
49         uint8_t *dyn;
50         size_t dyn_len;
51         uint16_t input_buffer_offset = 0;
52         uint32_t input_buffer_length = 0;
53
54         req = tevent_req_create(mem_ctx, &state,
55                                 struct smb2cli_set_info_state);
56         if (req == NULL) {
57                 return NULL;
58         }
59
60         if (in_input_buffer) {
61                 input_buffer_offset = SMB2_HDR_BODY+0x20;
62                 input_buffer_length = in_input_buffer->length;
63         }
64
65         fixed = state->fixed;
66
67         SSVAL(fixed, 0x00, 0x21);
68         SCVAL(fixed, 0x02, in_info_type);
69         SCVAL(fixed, 0x03, in_file_info_class);
70         SIVAL(fixed, 0x04, input_buffer_length);
71         SSVAL(fixed, 0x08, input_buffer_offset);
72         SSVAL(fixed, 0x0A, 0); /* reserved */
73         SIVAL(fixed, 0x0C, in_additional_info);
74         SBVAL(fixed, 0x10, in_fid_persistent);
75         SBVAL(fixed, 0x18, in_fid_volatile);
76
77         if (input_buffer_length > 0) {
78                 dyn = in_input_buffer->data;
79                 dyn_len = in_input_buffer->length;
80         } else {
81                 dyn = state->dyn_pad;
82                 dyn_len = sizeof(state->dyn_pad);
83         }
84
85         subreq = smb2cli_req_send(state, ev, conn, SMB2_OP_SETINFO,
86                                   0, 0, /* flags */
87                                   timeout_msec,
88                                   tcon,
89                                   session,
90                                   state->fixed, sizeof(state->fixed),
91                                   dyn, dyn_len);
92         if (tevent_req_nomem(subreq, req)) {
93                 return tevent_req_post(req, ev);
94         }
95         tevent_req_set_callback(subreq, smb2cli_set_info_done, req);
96         return req;
97 }
98
99 static void smb2cli_set_info_done(struct tevent_req *subreq)
100 {
101         struct tevent_req *req =
102                 tevent_req_callback_data(subreq,
103                 struct tevent_req);
104         NTSTATUS status;
105         static const struct smb2cli_req_expected_response expected[] = {
106         {
107                 .status = NT_STATUS_OK,
108                 .body_size = 0x02
109         },
110         };
111
112         status = smb2cli_req_recv(subreq, NULL, NULL,
113                                   expected, ARRAY_SIZE(expected));
114         TALLOC_FREE(subreq);
115         if (tevent_req_nterror(req, status)) {
116                 return;
117         }
118
119         tevent_req_done(req);
120 }
121
122 NTSTATUS smb2cli_set_info_recv(struct tevent_req *req)
123 {
124         NTSTATUS status;
125
126         if (tevent_req_is_nterror(req, &status)) {
127                 tevent_req_received(req);
128                 return status;
129         }
130
131         tevent_req_received(req);
132         return NT_STATUS_OK;
133 }
134
135 NTSTATUS smb2cli_set_info(struct smbXcli_conn *conn,
136                           uint32_t timeout_msec,
137                           struct smbXcli_session *session,
138                           struct smbXcli_tcon *tcon,
139                           uint8_t in_info_type,
140                           uint8_t in_file_info_class,
141                           const DATA_BLOB *in_input_buffer,
142                           uint32_t in_additional_info,
143                           uint64_t in_fid_persistent,
144                           uint64_t in_fid_volatile)
145 {
146         TALLOC_CTX *frame = talloc_stackframe();
147         struct tevent_context *ev;
148         struct tevent_req *req;
149         NTSTATUS status = NT_STATUS_NO_MEMORY;
150
151         if (smbXcli_conn_has_async_calls(conn)) {
152                 /*
153                  * Can't use sync call while an async call is in flight
154                  */
155                 status = NT_STATUS_INVALID_PARAMETER_MIX;
156                 goto fail;
157         }
158         ev = tevent_context_init(frame);
159         if (ev == NULL) {
160                 goto fail;
161         }
162         req = smb2cli_set_info_send(frame, ev,
163                                     conn, timeout_msec,
164                                     session, tcon,
165                                     in_info_type,
166                                     in_file_info_class,
167                                     in_input_buffer,
168                                     in_additional_info,
169                                     in_fid_persistent,
170                                     in_fid_volatile);
171         if (req == NULL) {
172                 goto fail;
173         }
174         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
175                 goto fail;
176         }
177         status = smb2cli_set_info_recv(req);
178
179  fail:
180         TALLOC_FREE(frame);
181         return status;
182 }