s3:smbd: simplify the notify code a bit and always reply via change_notify_reply...
[nivanova/samba-autobuild/.git] / source3 / smbd / notify.c
1 /*
2    Unix SMB/CIFS implementation.
3    change notify handling
4    Copyright (C) Andrew Tridgell 2000
5    Copyright (C) Jeremy Allison 1994-1998
6    Copyright (C) Volker Lendecke 2007
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "smbd/globals.h"
24
25 struct notify_change_request {
26         struct notify_change_request *prev, *next;
27         struct files_struct *fsp;       /* backpointer for cancel by mid */
28         struct smb_request *req;
29         uint32 filter;
30         uint32 max_param;
31         struct notify_mid_map *mid_map;
32         void *backend_data;
33 };
34
35 static void notify_fsp(files_struct *fsp, uint32 action, const char *name);
36
37 /*
38  * For NTCancel, we need to find the notify_change_request indexed by
39  * mid. Separate list here.
40  */
41
42 struct notify_mid_map {
43         struct notify_mid_map *prev, *next;
44         struct notify_change_request *req;
45         uint16 mid;
46 };
47
48 static bool notify_change_record_identical(struct notify_change *c1,
49                                         struct notify_change *c2)
50 {
51         /* Note this is deliberately case sensitive. */
52         if (c1->action == c2->action &&
53                         strcmp(c1->name, c2->name) == 0) {
54                 return True;
55         }
56         return False;
57 }
58
59 static bool notify_marshall_changes(int num_changes,
60                                 uint32 max_offset,
61                                 struct notify_change *changes,
62                                 prs_struct *ps)
63 {
64         int i;
65         UNISTR uni_name;
66
67         if (num_changes == -1) {
68                 return false;
69         }
70
71         uni_name.buffer = NULL;
72
73         for (i=0; i<num_changes; i++) {
74                 struct notify_change *c;
75                 size_t namelen;
76                 uint32 u32_tmp; /* Temp arg to prs_uint32 to avoid
77                                  * signed/unsigned issues */
78
79                 /* Coalesce any identical records. */
80                 while (i+1 < num_changes &&
81                         notify_change_record_identical(&changes[i],
82                                                 &changes[i+1])) {
83                         i++;
84                 }
85
86                 c = &changes[i];
87
88                 if (!convert_string_talloc(talloc_tos(), CH_UNIX, CH_UTF16LE,
89                         c->name, strlen(c->name)+1, &uni_name.buffer,
90                         &namelen, True) || (uni_name.buffer == NULL)) {
91                         goto fail;
92                 }
93
94                 namelen -= 2;   /* Dump NULL termination */
95
96                 /*
97                  * Offset to next entry, only if there is one
98                  */
99
100                 u32_tmp = (i == num_changes-1) ? 0 : namelen + 12;
101                 if (!prs_uint32("offset", ps, 1, &u32_tmp)) goto fail;
102
103                 u32_tmp = c->action;
104                 if (!prs_uint32("action", ps, 1, &u32_tmp)) goto fail;
105
106                 u32_tmp = namelen;
107                 if (!prs_uint32("namelen", ps, 1, &u32_tmp)) goto fail;
108
109                 if (!prs_unistr("name", ps, 1, &uni_name)) goto fail;
110
111                 /*
112                  * Not NULL terminated, decrease by the 2 UCS2 \0 chars
113                  */
114                 prs_set_offset(ps, prs_offset(ps)-2);
115
116                 TALLOC_FREE(uni_name.buffer);
117
118                 if (prs_offset(ps) > max_offset) {
119                         /* Too much data for client. */
120                         DEBUG(10, ("Client only wanted %d bytes, trying to "
121                                    "marshall %d bytes\n", (int)max_offset,
122                                    (int)prs_offset(ps)));
123                         return False;
124                 }
125         }
126
127         return True;
128
129  fail:
130         TALLOC_FREE(uni_name.buffer);
131         return False;
132 }
133
134 /****************************************************************************
135  Setup the common parts of the return packet and send it.
136 *****************************************************************************/
137
138 void change_notify_reply(connection_struct *conn,
139                          struct smb_request *req,
140                          NTSTATUS error_code,
141                          uint32_t max_param,
142                          struct notify_change_buf *notify_buf)
143 {
144         prs_struct ps;
145
146         if (!NT_STATUS_IS_OK(error_code)) {
147                 send_nt_replies(conn, req, error_code,
148                                 NULL, 0, NULL, 0);
149                 return;
150         }
151
152         if (max_param == 0 || notify_buf == NULL) {
153                 send_nt_replies(conn, req, NT_STATUS_OK,
154                                 NULL, 0, NULL, 0);
155                 return;
156         }
157
158         prs_init_empty(&ps, NULL, MARSHALL);
159
160         if (!notify_marshall_changes(notify_buf->num_changes, max_param,
161                                         notify_buf->changes, &ps)) {
162                 /*
163                  * We exceed what the client is willing to accept. Send
164                  * nothing.
165                  */
166                 prs_mem_free(&ps);
167                 prs_init_empty(&ps, NULL, MARSHALL);
168         }
169
170         send_nt_replies(conn, req, NT_STATUS_OK, prs_data_p(&ps),
171                         prs_offset(&ps), NULL, 0);
172
173         prs_mem_free(&ps);
174
175         TALLOC_FREE(notify_buf->changes);
176         notify_buf->num_changes = 0;
177 }
178
179 static void notify_callback(void *private_data, const struct notify_event *e)
180 {
181         files_struct *fsp = (files_struct *)private_data;
182         DEBUG(10, ("notify_callback called for %s\n", fsp->fsp_name));
183         notify_fsp(fsp, e->action, e->path);
184 }
185
186 NTSTATUS change_notify_create(struct files_struct *fsp, uint32 filter,
187                               bool recursive)
188 {
189         char *fullpath;
190         struct notify_entry e;
191         NTSTATUS status;
192
193         SMB_ASSERT(fsp->notify == NULL);
194
195         if (!(fsp->notify = TALLOC_ZERO_P(NULL, struct notify_change_buf))) {
196                 DEBUG(0, ("talloc failed\n"));
197                 return NT_STATUS_NO_MEMORY;
198         }
199
200         if (asprintf(&fullpath, "%s/%s", fsp->conn->connectpath,
201                      fsp->fsp_name) == -1) {
202                 DEBUG(0, ("asprintf failed\n"));
203                 TALLOC_FREE(fsp->notify);
204                 return NT_STATUS_NO_MEMORY;
205         }
206
207         ZERO_STRUCT(e);
208         e.path = fullpath;
209         e.dir_fd = fsp->fh->fd;
210         e.dir_id = fsp->file_id;
211         e.filter = filter;
212         e.subdir_filter = 0;
213         if (recursive) {
214                 e.subdir_filter = filter;
215         }
216
217         status = notify_add(fsp->conn->notify_ctx, &e, notify_callback, fsp);
218         SAFE_FREE(fullpath);
219
220         return status;
221 }
222
223 NTSTATUS change_notify_add_request(struct smb_request *req,
224                                 uint32 max_param,
225                                 uint32 filter, bool recursive,
226                                 struct files_struct *fsp)
227 {
228         struct notify_change_request *request = NULL;
229         struct notify_mid_map *map = NULL;
230         struct smbd_server_connection *sconn = smbd_server_conn;
231
232         DEBUG(10, ("change_notify_add_request: Adding request for %s: "
233                    "max_param = %d\n", fsp->fsp_name, (int)max_param));
234
235         if (!(request = talloc(NULL, struct notify_change_request))
236             || !(map = talloc(request, struct notify_mid_map))) {
237                 TALLOC_FREE(request);
238                 return NT_STATUS_NO_MEMORY;
239         }
240
241         request->mid_map = map;
242         map->req = request;
243
244         request->req = talloc_move(request, &req);
245         request->max_param = max_param;
246         request->filter = filter;
247         request->fsp = fsp;
248         request->backend_data = NULL;
249
250         DLIST_ADD_END(fsp->notify->requests, request,
251                       struct notify_change_request *);
252
253         map->mid = request->req->mid;
254         DLIST_ADD(sconn->smb1.notify_mid_maps, map);
255
256         return NT_STATUS_OK;
257 }
258
259 static void change_notify_remove_request(struct notify_change_request *remove_req)
260 {
261         files_struct *fsp;
262         struct notify_change_request *req;
263         struct smbd_server_connection *sconn = smbd_server_conn;
264
265         /*
266          * Paranoia checks, the fsp referenced must must have the request in
267          * its list of pending requests
268          */
269
270         fsp = remove_req->fsp;
271         SMB_ASSERT(fsp->notify != NULL);
272
273         for (req = fsp->notify->requests; req; req = req->next) {
274                 if (req == remove_req) {
275                         break;
276                 }
277         }
278
279         if (req == NULL) {
280                 smb_panic("notify_req not found in fsp's requests");
281         }
282
283         DLIST_REMOVE(fsp->notify->requests, req);
284         DLIST_REMOVE(sconn->smb1.notify_mid_maps, req->mid_map);
285         TALLOC_FREE(req);
286 }
287
288 /****************************************************************************
289  Delete entries by mid from the change notify pending queue. Always send reply.
290 *****************************************************************************/
291
292 void remove_pending_change_notify_requests_by_mid(uint16 mid)
293 {
294         struct notify_mid_map *map;
295         struct smbd_server_connection *sconn = smbd_server_conn;
296
297         for (map = sconn->smb1.notify_mid_maps; map; map = map->next) {
298                 if (map->mid == mid) {
299                         break;
300                 }
301         }
302
303         if (map == NULL) {
304                 return;
305         }
306
307         change_notify_reply(map->req->fsp->conn, map->req->req,
308                             NT_STATUS_CANCELLED, 0, NULL);
309         change_notify_remove_request(map->req);
310 }
311
312 /****************************************************************************
313  Delete entries by fnum from the change notify pending queue.
314 *****************************************************************************/
315
316 void remove_pending_change_notify_requests_by_fid(files_struct *fsp,
317                                                   NTSTATUS status)
318 {
319         if (fsp->notify == NULL) {
320                 return;
321         }
322
323         while (fsp->notify->requests != NULL) {
324                 change_notify_reply(fsp->conn, fsp->notify->requests->req,
325                                     status, 0, NULL);
326                 change_notify_remove_request(fsp->notify->requests);
327         }
328 }
329
330 void notify_fname(connection_struct *conn, uint32 action, uint32 filter,
331                   const char *path)
332 {
333         char *fullpath;
334         char *parent;
335         const char *name;
336
337         if (path[0] == '.' && path[1] == '/') {
338                 path += 2;
339         }
340         if (parent_dirname(talloc_tos(), path, &parent, &name)) {
341                 struct smb_filename *smb_fname_parent = NULL;
342                 NTSTATUS status;
343
344                 status = create_synthetic_smb_fname(talloc_tos(), parent, NULL,
345                                                     NULL, &smb_fname_parent);
346                 if (!NT_STATUS_IS_OK(status)) {
347                         return;
348                 }
349                 if (SMB_VFS_STAT(conn, smb_fname_parent) != -1) {
350                         notify_onelevel(conn->notify_ctx, action, filter,
351                             SMB_VFS_FILE_ID_CREATE(conn, &smb_fname_parent->st),
352                             name);
353                 }
354                 TALLOC_FREE(smb_fname_parent);
355         }
356
357         fullpath = talloc_asprintf(talloc_tos(), "%s/%s", conn->connectpath,
358                                    path);
359         if (fullpath == NULL) {
360                 DEBUG(0, ("asprintf failed\n"));
361                 return;
362         }
363         notify_trigger(conn->notify_ctx, action, filter, fullpath);
364         TALLOC_FREE(fullpath);
365 }
366
367 static void notify_fsp(files_struct *fsp, uint32 action, const char *name)
368 {
369         struct notify_change *change, *changes;
370         char *tmp;
371
372         if (fsp->notify == NULL) {
373                 /*
374                  * Nobody is waiting, don't queue
375                  */
376                 return;
377         }
378
379         /*
380          * Someone has triggered a notify previously, queue the change for
381          * later.
382          */
383
384         if ((fsp->notify->num_changes > 1000) || (name == NULL)) {
385                 /*
386                  * The real number depends on the client buf, just provide a
387                  * guard against a DoS here.  If name == NULL the CN backend is
388                  * alerting us to a problem.  Possibly dropped events.  Clear
389                  * queued changes and send the catch-all response to the client
390                  * if a request is pending.
391                  */
392                 TALLOC_FREE(fsp->notify->changes);
393                 fsp->notify->num_changes = -1;
394                 if (fsp->notify->requests != NULL) {
395                         change_notify_reply(fsp->conn,
396                                             fsp->notify->requests->req,
397                                             NT_STATUS_OK,
398                                             fsp->notify->requests->max_param,
399                                             fsp->notify);
400                         change_notify_remove_request(fsp->notify->requests);
401                 }
402                 return;
403         }
404
405         /* If we've exceeded the server side queue or received a NULL name
406          * from the underlying CN implementation, don't queue up any more
407          * requests until we can send a catch-all response to the client */
408         if (fsp->notify->num_changes == -1) {
409                 return;
410         }
411
412         if (!(changes = TALLOC_REALLOC_ARRAY(
413                       fsp->notify, fsp->notify->changes,
414                       struct notify_change, fsp->notify->num_changes+1))) {
415                 DEBUG(0, ("talloc_realloc failed\n"));
416                 return;
417         }
418
419         fsp->notify->changes = changes;
420
421         change = &(fsp->notify->changes[fsp->notify->num_changes]);
422
423         if (!(tmp = talloc_strdup(changes, name))) {
424                 DEBUG(0, ("talloc_strdup failed\n"));
425                 return;
426         }
427
428         string_replace(tmp, '/', '\\');
429         change->name = tmp;     
430
431         change->action = action;
432         fsp->notify->num_changes += 1;
433
434         if (fsp->notify->requests == NULL) {
435                 /*
436                  * Nobody is waiting, so don't send anything. The ot
437                  */
438                 return;
439         }
440
441         if (action == NOTIFY_ACTION_OLD_NAME) {
442                 /*
443                  * We have to send the two rename events in one reply. So hold
444                  * the first part back.
445                  */
446                 return;
447         }
448
449         /*
450          * Someone is waiting for the change, trigger the reply immediately.
451          *
452          * TODO: do we have to walk the lists of requests pending?
453          */
454
455         change_notify_reply(fsp->conn,
456                             fsp->notify->requests->req,
457                             NT_STATUS_OK,
458                             fsp->notify->requests->max_param,
459                             fsp->notify);
460
461         change_notify_remove_request(fsp->notify->requests);
462 }
463
464 char *notify_filter_string(TALLOC_CTX *mem_ctx, uint32 filter)
465 {
466         char *result = NULL;
467
468         result = talloc_strdup(mem_ctx, "");
469
470         if (filter & FILE_NOTIFY_CHANGE_FILE_NAME)
471                 result = talloc_asprintf_append(result, "FILE_NAME|");
472         if (filter & FILE_NOTIFY_CHANGE_DIR_NAME)
473                 result = talloc_asprintf_append(result, "DIR_NAME|");
474         if (filter & FILE_NOTIFY_CHANGE_ATTRIBUTES)
475                 result = talloc_asprintf_append(result, "ATTRIBUTES|");
476         if (filter & FILE_NOTIFY_CHANGE_SIZE)
477                 result = talloc_asprintf_append(result, "SIZE|");
478         if (filter & FILE_NOTIFY_CHANGE_LAST_WRITE)
479                 result = talloc_asprintf_append(result, "LAST_WRITE|");
480         if (filter & FILE_NOTIFY_CHANGE_LAST_ACCESS)
481                 result = talloc_asprintf_append(result, "LAST_ACCESS|");
482         if (filter & FILE_NOTIFY_CHANGE_CREATION)
483                 result = talloc_asprintf_append(result, "CREATION|");
484         if (filter & FILE_NOTIFY_CHANGE_EA)
485                 result = talloc_asprintf_append(result, "EA|");
486         if (filter & FILE_NOTIFY_CHANGE_SECURITY)
487                 result = talloc_asprintf_append(result, "SECURITY|");
488         if (filter & FILE_NOTIFY_CHANGE_STREAM_NAME)
489                 result = talloc_asprintf_append(result, "STREAM_NAME|");
490         if (filter & FILE_NOTIFY_CHANGE_STREAM_SIZE)
491                 result = talloc_asprintf_append(result, "STREAM_SIZE|");
492         if (filter & FILE_NOTIFY_CHANGE_STREAM_WRITE)
493                 result = talloc_asprintf_append(result, "STREAM_WRITE|");
494
495         if (result == NULL) return NULL;
496         if (*result == '\0') return result;
497
498         result[strlen(result)-1] = '\0';
499         return result;
500 }
501
502 struct sys_notify_context *sys_notify_context_create(connection_struct *conn,
503                                                      TALLOC_CTX *mem_ctx, 
504                                                      struct event_context *ev)
505 {
506         struct sys_notify_context *ctx;
507
508         if (!(ctx = TALLOC_P(mem_ctx, struct sys_notify_context))) {
509                 DEBUG(0, ("talloc failed\n"));
510                 return NULL;
511         }
512
513         ctx->ev = ev;
514         ctx->conn = conn;
515         ctx->private_data = NULL;
516         return ctx;
517 }
518
519 NTSTATUS sys_notify_watch(struct sys_notify_context *ctx,
520                           struct notify_entry *e,
521                           void (*callback)(struct sys_notify_context *ctx, 
522                                            void *private_data,
523                                            struct notify_event *ev),
524                           void *private_data, void *handle)
525 {
526         return SMB_VFS_NOTIFY_WATCH(ctx->conn, ctx, e, callback, private_data,
527                                     handle);
528 }
529