63b08e126203148718bd3552f9a82b797ba26566
[nivanova/samba-autobuild/.git] / source3 / smbd / message.c
1 /* 
2    Unix SMB/CIFS implementation.
3    SMB messaging
4    Copyright (C) Andrew Tridgell 1992-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    This file handles the messaging system calls for winpopup style
21    messages
22 */
23
24
25 #include "includes.h"
26 #include "smbd/smbd.h"
27 #include "smbd/globals.h"
28 #include "smbprofile.h"
29
30 extern userdom_struct current_user_info;
31
32 struct msg_state {
33         char *from;
34         char *to;
35         char *msg;
36 };
37
38 /****************************************************************************
39  Deliver the message.
40 ****************************************************************************/
41
42 static void msg_deliver(struct msg_state *state)
43 {
44         TALLOC_CTX *frame = talloc_stackframe();
45         char *name = NULL;
46         int i;
47         int fd;
48         char *msg;
49         size_t len;
50         ssize_t sz;
51         fstring alpha_buf;
52         char *s;
53
54         if (! (*lp_msg_command())) {
55                 DEBUG(1,("no messaging command specified\n"));
56                 goto done;
57         }
58
59         /* put it in a temporary file */
60         name = talloc_asprintf(talloc_tos(), "%s/msg.XXXXXX", tmpdir());
61         if (!name) {
62                 goto done;
63         }
64         fd = mkstemp(name);
65
66         if (fd == -1) {
67                 DEBUG(1, ("can't open message file %s: %s\n", name,
68                           strerror(errno)));
69                 goto done;
70         }
71
72         /*
73          * Incoming message is in DOS codepage format. Convert to UNIX.
74          */
75
76         if (!convert_string_talloc(talloc_tos(), CH_DOS, CH_UNIX, state->msg,
77                                    talloc_get_size(state->msg), (void *)&msg,
78                                    &len)) {
79                 DEBUG(3, ("Conversion failed, delivering message in DOS "
80                           "codepage format\n"));
81                 msg = state->msg;
82         }
83
84         for (i = 0; i < len; i++) {
85                 if ((msg[i] == '\r') &&
86                     (i < (len-1)) && (msg[i+1] == '\n')) {
87                         continue;
88                 }
89                 sz = write(fd, &msg[i], 1);
90                 if ( sz != 1 ) {
91                         DEBUG(0, ("Write error to fd %d: %ld(%s)\n", fd,
92                                   (long)sz, strerror(errno)));
93                 }
94         }
95
96         close(fd);
97
98         /* run the command */
99         s = talloc_strdup(talloc_tos(), lp_msg_command());
100         if (s == NULL) {
101                 goto done;
102         }
103
104         alpha_strcpy(alpha_buf, state->from, NULL, sizeof(alpha_buf));
105
106         s = talloc_string_sub(talloc_tos(), s, "%f", alpha_buf);
107         if (s == NULL) {
108                 goto done;
109         }
110
111         alpha_strcpy(alpha_buf, state->to, NULL, sizeof(alpha_buf));
112
113         s = talloc_string_sub(talloc_tos(), s, "%t", alpha_buf);
114         if (s == NULL) {
115                 goto done;
116         }
117
118         s = talloc_sub_basic(talloc_tos(), current_user_info.smb_name,
119                              current_user_info.domain, s);
120         if (s == NULL) {
121                 goto done;
122         }
123
124         s = talloc_string_sub(talloc_tos(), s, "%s", name);
125         if (s == NULL) {
126                 goto done;
127         }
128         smbrun(s,NULL);
129
130  done:
131         TALLOC_FREE(frame);
132         return;
133 }
134
135 /****************************************************************************
136  Reply to a sends.
137  conn POINTER CAN BE NULL HERE !
138 ****************************************************************************/
139
140 void reply_sends(struct smb_request *req)
141 {
142         struct msg_state *state;
143         int len;
144         const char *msg;
145         const char *p;
146
147         START_PROFILE(SMBsends);
148
149         if (!(*lp_msg_command())) {
150                 reply_nterror(req, NT_STATUS_REQUEST_NOT_ACCEPTED);
151                 END_PROFILE(SMBsends);
152                 return;
153         }
154
155         state = talloc(talloc_tos(), struct msg_state);
156
157         p = (const char *)req->buf + 1;
158         p += srvstr_pull_req_talloc(
159                 state, req, &state->from, p, STR_ASCII|STR_TERMINATE) + 1;
160         p += srvstr_pull_req_talloc(
161                 state, req, &state->to, p, STR_ASCII|STR_TERMINATE) + 1;
162
163         msg = p;
164
165         len = SVAL(msg,0);
166         len = MIN(len, smbreq_bufrem(req, msg+2));
167
168         state->msg = talloc_array(state, char, len);
169
170         if (state->msg == NULL) {
171                 reply_nterror(req, NT_STATUS_NO_MEMORY);
172                 END_PROFILE(SMBsends);
173                 return;
174         }
175
176         memcpy(state->msg, msg+2, len);
177
178         msg_deliver(state);
179
180         reply_outbuf(req, 0, 0);
181
182         END_PROFILE(SMBsends);
183         return;
184 }
185
186 /****************************************************************************
187  Reply to a sendstrt.
188  conn POINTER CAN BE NULL HERE !
189 ****************************************************************************/
190
191 void reply_sendstrt(struct smb_request *req)
192 {
193         const char *p;
194
195         START_PROFILE(SMBsendstrt);
196
197         if (!(*lp_msg_command())) {
198                 reply_nterror(req, NT_STATUS_REQUEST_NOT_ACCEPTED);
199                 END_PROFILE(SMBsendstrt);
200                 return;
201         }
202
203         TALLOC_FREE(smbd_msg_state);
204
205         smbd_msg_state = talloc_zero(NULL, struct msg_state);
206
207         if (smbd_msg_state == NULL) {
208                 reply_nterror(req, NT_STATUS_NO_MEMORY);
209                 END_PROFILE(SMBsendstrt);
210                 return;
211         }
212
213         p = (const char *)req->buf+1;
214         p += srvstr_pull_req_talloc(
215                 smbd_msg_state, req, &smbd_msg_state->from, p,
216                 STR_ASCII|STR_TERMINATE) + 1;
217         p += srvstr_pull_req_talloc(
218                 smbd_msg_state, req, &smbd_msg_state->to, p,
219                 STR_ASCII|STR_TERMINATE) + 1;
220
221         DEBUG( 3, ( "SMBsendstrt (from %s to %s)\n", smbd_msg_state->from,
222                     smbd_msg_state->to ) );
223
224         reply_outbuf(req, 0, 0);
225
226         END_PROFILE(SMBsendstrt);
227         return;
228 }
229
230 /****************************************************************************
231  Reply to a sendtxt.
232  conn POINTER CAN BE NULL HERE !
233 ****************************************************************************/
234
235 void reply_sendtxt(struct smb_request *req)
236 {
237         int len;
238         const char *msg;
239         char *tmp;
240         size_t old_len;
241
242         START_PROFILE(SMBsendtxt);
243
244         if (! (*lp_msg_command())) {
245                 reply_nterror(req, NT_STATUS_REQUEST_NOT_ACCEPTED);
246                 END_PROFILE(SMBsendtxt);
247                 return;
248         }
249
250         if ((smbd_msg_state == NULL) || (req->buflen < 3)) {
251                 reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
252                 END_PROFILE(SMBsendtxt);
253                 return;
254         }
255
256         msg = (const char *)req->buf + 1;
257
258         old_len = talloc_get_size(smbd_msg_state->msg);
259
260         len = MIN(SVAL(msg, 0), smbreq_bufrem(req, msg+2));
261
262         tmp = talloc_realloc(smbd_msg_state, smbd_msg_state->msg,
263                                    char, old_len + len);
264
265         if (tmp == NULL) {
266                 reply_nterror(req, NT_STATUS_NO_MEMORY);
267                 END_PROFILE(SMBsendtxt);
268                 return;
269         }
270
271         smbd_msg_state->msg = tmp;
272
273         memcpy(&smbd_msg_state->msg[old_len], msg+2, len);
274
275         DEBUG( 3, ( "SMBsendtxt\n" ) );
276
277         reply_outbuf(req, 0, 0);
278
279         END_PROFILE(SMBsendtxt);
280         return;
281 }
282
283 /****************************************************************************
284  Reply to a sendend.
285  conn POINTER CAN BE NULL HERE !
286 ****************************************************************************/
287
288 void reply_sendend(struct smb_request *req)
289 {
290         START_PROFILE(SMBsendend);
291
292         if (! (*lp_msg_command())) {
293                 reply_nterror(req, NT_STATUS_REQUEST_NOT_ACCEPTED);
294                 END_PROFILE(SMBsendend);
295                 return;
296         }
297
298         DEBUG(3,("SMBsendend\n"));
299
300         msg_deliver(smbd_msg_state);
301
302         TALLOC_FREE(smbd_msg_state);
303
304         reply_outbuf(req, 0, 0);
305
306         END_PROFILE(SMBsendend);
307         return;
308 }