s3: Explicitly handle inbuf in cli_dskattr_done
[samba.git] / source3 / libsmb / climessage.c
1 /*
2    Unix SMB/CIFS implementation.
3    client message handling routines
4    Copyright (C) Andrew Tridgell 1994-1998
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
22 struct cli_message_start_state {
23         uint16_t grp;
24 };
25
26 static void cli_message_start_done(struct tevent_req *subreq);
27
28 static struct tevent_req *cli_message_start_send(TALLOC_CTX *mem_ctx,
29                                                  struct tevent_context *ev,
30                                                  struct cli_state *cli,
31                                                  const char *host,
32                                                  const char *username)
33 {
34         struct tevent_req *req, *subreq;
35         struct cli_message_start_state *state;
36         char *htmp = NULL;
37         char *utmp = NULL;
38         size_t hlen, ulen;
39         uint8_t *bytes, *p;
40
41         req = tevent_req_create(mem_ctx, &state,
42                                 struct cli_message_start_state);
43         if (req == NULL) {
44                 return NULL;
45         }
46
47         if (!convert_string_talloc(talloc_tos(), CH_UNIX, CH_DOS,
48                                    username, strlen(username)+1,
49                                    &utmp, &ulen, true)) {
50                 goto fail;
51         }
52         if (!convert_string_talloc(talloc_tos(), CH_UNIX, CH_DOS,
53                                    host, strlen(host)+1,
54                                    &htmp, &hlen, true)) {
55                 goto fail;
56         }
57
58         bytes = talloc_array(state, uint8_t, ulen+hlen+2);
59         if (bytes == NULL) {
60                 goto fail;
61         }
62         p = bytes;
63
64         *p++ = 4;
65         memcpy(p, utmp, ulen);
66         *p++ = 4;
67         memcpy(p, htmp, hlen);
68         TALLOC_FREE(htmp);
69         TALLOC_FREE(utmp);
70
71         subreq = cli_smb_send(state, ev, cli, SMBsendstrt, 0, 0, NULL,
72                               talloc_get_size(bytes), bytes);
73         if (tevent_req_nomem(subreq, req)) {
74                 return tevent_req_post(req, ev);
75         }
76         tevent_req_set_callback(subreq, cli_message_start_done, req);
77         return req;
78 fail:
79         TALLOC_FREE(htmp);
80         TALLOC_FREE(utmp);
81         tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
82         return tevent_req_post(req, ev);
83 }
84
85 static void cli_message_start_done(struct tevent_req *subreq)
86 {
87         struct tevent_req *req = tevent_req_callback_data(
88                 subreq, struct tevent_req);
89         struct cli_message_start_state *state = tevent_req_data(
90                 req, struct cli_message_start_state);
91         NTSTATUS status;
92         uint8_t wct;
93         uint16_t *vwv;
94
95         status = cli_smb_recv(subreq, NULL, NULL, 0, &wct, &vwv, NULL, NULL);
96         if (!NT_STATUS_IS_OK(status)) {
97                 TALLOC_FREE(subreq);
98                 tevent_req_nterror(req, status);
99                 return;
100         }
101         if (wct >= 1) {
102                 state->grp = SVAL(vwv+0, 0);
103         } else {
104                 state->grp = 0;
105         }
106         TALLOC_FREE(subreq);
107         tevent_req_done(req);
108 }
109
110 static NTSTATUS cli_message_start_recv(struct tevent_req *req,
111                                        uint16_t *pgrp)
112 {
113         struct cli_message_start_state *state = tevent_req_data(
114                 req, struct cli_message_start_state);
115         NTSTATUS status;
116
117         if (tevent_req_is_nterror(req, &status)) {
118                 return status;
119         }
120         *pgrp = state->grp;
121         return NT_STATUS_OK;
122 }
123
124 struct cli_message_text_state {
125         uint16_t vwv;
126 };
127
128 static void cli_message_text_done(struct tevent_req *subreq);
129
130 static struct tevent_req *cli_message_text_send(TALLOC_CTX *mem_ctx,
131                                                 struct tevent_context *ev,
132                                                 struct cli_state *cli,
133                                                 uint16_t grp,
134                                                 const char *msg,
135                                                 int msglen)
136 {
137         struct tevent_req *req, *subreq;
138         struct cli_message_text_state *state;
139         char *tmp;
140         size_t tmplen;
141         uint8_t *bytes;
142
143         req = tevent_req_create(mem_ctx, &state,
144                                 struct cli_message_text_state);
145         if (req == NULL) {
146                 return NULL;
147         }
148
149         SSVAL(&state->vwv, 0, grp);
150
151         if (convert_string_talloc(talloc_tos(), CH_UNIX, CH_DOS, msg, msglen,
152                                   &tmp, &tmplen, true)) {
153                 msg = tmp;
154                 msglen = tmplen;
155         } else {
156                 DEBUG(3, ("Conversion failed, sending message in UNIX "
157                           "charset\n"));
158                 tmp = NULL;
159         }
160
161         bytes = talloc_array(state, uint8_t, msglen+3);
162         if (tevent_req_nomem(bytes, req)) {
163                 TALLOC_FREE(tmp);
164                 return tevent_req_post(req, ev);
165         }
166         SCVAL(bytes, 0, 0);     /* pad */
167         SSVAL(bytes, 1, msglen);
168         memcpy(bytes+3, msg, msglen);
169         TALLOC_FREE(tmp);
170
171         subreq = cli_smb_send(state, ev, cli, SMBsendtxt, 0, 1, &state->vwv,
172                               talloc_get_size(bytes), bytes);
173         if (tevent_req_nomem(subreq, req)) {
174                 return tevent_req_post(req, ev);
175         }
176         tevent_req_set_callback(subreq, cli_message_text_done, req);
177         return req;
178 }
179
180 static void cli_message_text_done(struct tevent_req *subreq)
181 {
182         struct tevent_req *req = tevent_req_callback_data(
183                 subreq, struct tevent_req);
184         NTSTATUS status;
185
186         status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
187         TALLOC_FREE(subreq);
188         if (!NT_STATUS_IS_OK(status)) {
189                 tevent_req_nterror(req, status);
190                 return;
191         }
192         tevent_req_done(req);
193 }
194
195 static NTSTATUS cli_message_text_recv(struct tevent_req *req)
196 {
197         return tevent_req_simple_recv_ntstatus(req);
198 }
199
200 struct cli_message_end_state {
201         uint16_t vwv;
202 };
203
204 static void cli_message_end_done(struct tevent_req *subreq);
205
206 static struct tevent_req *cli_message_end_send(TALLOC_CTX *mem_ctx,
207                                                 struct tevent_context *ev,
208                                                 struct cli_state *cli,
209                                                 uint16_t grp)
210 {
211         struct tevent_req *req, *subreq;
212         struct cli_message_end_state *state;
213
214         req = tevent_req_create(mem_ctx, &state,
215                                 struct cli_message_end_state);
216         if (req == NULL) {
217                 return NULL;
218         }
219
220         SSVAL(&state->vwv, 0, grp);
221
222         subreq = cli_smb_send(state, ev, cli, SMBsendend, 0, 1, &state->vwv,
223                               0, NULL);
224         if (tevent_req_nomem(subreq, req)) {
225                 return tevent_req_post(req, ev);
226         }
227         tevent_req_set_callback(subreq, cli_message_end_done, req);
228         return req;
229 }
230
231 static void cli_message_end_done(struct tevent_req *subreq)
232 {
233         struct tevent_req *req = tevent_req_callback_data(
234                 subreq, struct tevent_req);
235         NTSTATUS status;
236
237         status = cli_smb_recv(subreq, NULL, NULL, 0, NULL, NULL, NULL, NULL);
238         TALLOC_FREE(subreq);
239         if (!NT_STATUS_IS_OK(status)) {
240                 tevent_req_nterror(req, status);
241                 return;
242         }
243         tevent_req_done(req);
244 }
245
246 static NTSTATUS cli_message_end_recv(struct tevent_req *req)
247 {
248         return tevent_req_simple_recv_ntstatus(req);
249 }
250
251 struct cli_message_state {
252         struct tevent_context *ev;
253         struct cli_state *cli;
254         size_t sent;
255         const char *message;
256         uint16_t grp;
257 };
258
259 static void cli_message_started(struct tevent_req *subreq);
260 static void cli_message_sent(struct tevent_req *subreq);
261 static void cli_message_done(struct tevent_req *subreq);
262
263 struct tevent_req *cli_message_send(TALLOC_CTX *mem_ctx,
264                                     struct tevent_context *ev,
265                                     struct cli_state *cli,
266                                     const char *host, const char *username,
267                                     const char *message)
268 {
269         struct tevent_req *req, *subreq;
270         struct cli_message_state *state;
271
272         req = tevent_req_create(mem_ctx, &state, struct cli_message_state);
273         if (req == NULL) {
274                 return NULL;
275         }
276         state->ev = ev;
277         state->cli = cli;
278         state->sent = 0;
279         state->message = message;
280
281         subreq = cli_message_start_send(state, ev, cli, host, username);
282         if (tevent_req_nomem(subreq, req)) {
283                 return tevent_req_post(req, ev);
284         }
285         tevent_req_set_callback(subreq, cli_message_started, req);
286         return req;
287 }
288
289 static void cli_message_started(struct tevent_req *subreq)
290 {
291         struct tevent_req *req = tevent_req_callback_data(
292                 subreq, struct tevent_req);
293         struct cli_message_state *state = tevent_req_data(
294                 req, struct cli_message_state);
295         NTSTATUS status;
296         size_t thistime;
297
298         status = cli_message_start_recv(subreq, &state->grp);
299         TALLOC_FREE(subreq);
300         if (!NT_STATUS_IS_OK(status)) {
301                 tevent_req_nterror(req, status);
302                 return;
303         }
304
305         thistime = MIN(127, strlen(state->message));
306
307         subreq = cli_message_text_send(state, state->ev, state->cli,
308                                        state->grp, state->message, thistime);
309         if (tevent_req_nomem(subreq, req)) {
310                 return;
311         }
312         state->sent += thistime;
313         tevent_req_set_callback(subreq, cli_message_sent, req);
314 }
315
316 static void cli_message_sent(struct tevent_req *subreq)
317 {
318         struct tevent_req *req = tevent_req_callback_data(
319                 subreq, struct tevent_req);
320         struct cli_message_state *state = tevent_req_data(
321                 req, struct cli_message_state);
322         NTSTATUS status;
323         size_t left, thistime;
324
325         status = cli_message_text_recv(subreq);
326         TALLOC_FREE(subreq);
327         if (!NT_STATUS_IS_OK(status)) {
328                 tevent_req_nterror(req, status);
329                 return;
330         }
331
332         if (state->sent >= strlen(state->message)) {
333                 subreq = cli_message_end_send(state, state->ev, state->cli,
334                                               state->grp);
335                 if (tevent_req_nomem(subreq, req)) {
336                         return;
337                 }
338                 tevent_req_set_callback(subreq, cli_message_done, req);
339                 return;
340         }
341
342         left = strlen(state->message) - state->sent;
343         thistime = MIN(127, left);
344
345         subreq = cli_message_text_send(state, state->ev, state->cli,
346                                        state->grp,
347                                        state->message + state->sent,
348                                        thistime);
349         if (tevent_req_nomem(subreq, req)) {
350                 return;
351         }
352         state->sent += thistime;
353         tevent_req_set_callback(subreq, cli_message_sent, req);
354 }
355
356 static void cli_message_done(struct tevent_req *subreq)
357 {
358         struct tevent_req *req = tevent_req_callback_data(
359                 subreq, struct tevent_req);
360         NTSTATUS status;
361
362         status = cli_message_end_recv(subreq);
363         TALLOC_FREE(subreq);
364         if (!NT_STATUS_IS_OK(status)) {
365                 tevent_req_nterror(req, status);
366                 return;
367         }
368         tevent_req_done(req);
369 }
370
371 NTSTATUS cli_message_recv(struct tevent_req *req)
372 {
373         return tevent_req_simple_recv_ntstatus(req);
374 }
375
376 NTSTATUS cli_message(struct cli_state *cli, const char *host,
377                      const char *username, const char *message)
378 {
379         TALLOC_CTX *frame = talloc_stackframe();
380         struct event_context *ev;
381         struct tevent_req *req;
382         NTSTATUS status = NT_STATUS_OK;
383
384         if (cli_has_async_calls(cli)) {
385                 /*
386                  * Can't use sync call while an async call is in flight
387                  */
388                 status = NT_STATUS_INVALID_PARAMETER;
389                 goto fail;
390         }
391
392         ev = event_context_init(frame);
393         if (ev == NULL) {
394                 status = NT_STATUS_NO_MEMORY;
395                 goto fail;
396         }
397
398         req = cli_message_send(frame, ev, cli, host, username, message);
399         if (req == NULL) {
400                 status = NT_STATUS_NO_MEMORY;
401                 goto fail;
402         }
403
404         if (!tevent_req_poll(req, ev)) {
405                 status = map_nt_error_from_unix(errno);
406                 goto fail;
407         }
408
409         status = cli_message_recv(req);
410  fail:
411         TALLOC_FREE(frame);
412         return status;
413 }