source3/smbd/notifyd/test_notifyd.c

   1 /*
   2  * This program is free software; you can redistribute it and/or modify
   3  * it under the terms of the GNU General Public License as published by
   4  * the Free Software Foundation; either version 3 of the License, or
   5  * (at your option) any later version.
   6  *
   7  * This program is distributed in the hope that it will be useful,
   8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  * GNU General Public License for more details.
  11  *
  12  * You should have received a copy of the GNU General Public License
  13  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  14  */
  15
  16 #include "replace.h"
  17 #include "fcn_wait.h"
  18 #include "notifyd.h"
  19 #include "notifyd_db.h"
  20 #include "messages.h"
  21 #include "lib/util/server_id.h"
  22 #include "lib/util/server_id_db.h"
  23 #include "lib/util/tevent_ntstatus.h"
  24 #include "lib/torture/torture.h"
  25 #include "torture/local/proto.h"
  26 #include "lib/param/loadparm.h"
  27 #include "source3/param/loadparm.h"
  28 #include "source4/torture/smbtorture.h"
  29
  30 struct fcn_test_state {
  31         struct tevent_req *fcn_req;
  32         bool got_trigger;
  33 };
  34
  35 static void fcn_test_done(struct tevent_req *subreq);
  36
  37 static struct tevent_req *fcn_test_send(
  38         TALLOC_CTX *mem_ctx,
  39         struct tevent_context *ev,
  40         struct messaging_context *msg_ctx,
  41         struct server_id notifyd,
  42         const char *fcn_path,
  43         uint32_t fcn_filter,
  44         uint32_t fcn_subdir_filter,
  45         const char *trigger_path,
  46         uint32_t trigger_action,
  47         uint32_t trigger_filter)
  48 {
  49         struct tevent_req *req = NULL;
  50         struct fcn_test_state *state = NULL;
  51         struct notify_trigger_msg msg;
  52         struct iovec iov[2];
  53         NTSTATUS status;
  54
  55         req = tevent_req_create(mem_ctx, &state, struct fcn_test_state);
  56         if (req == NULL) {
  57                 return NULL;
  58         }
  59
  60         state->fcn_req = fcn_wait_send(
  61                 state,
  62                 ev,
  63                 msg_ctx,
  64                 notifyd,
  65                 fcn_path,
  66                 fcn_filter,
  67                 fcn_subdir_filter);
  68         if (tevent_req_nomem(state->fcn_req, req)) {
  69                 return tevent_req_post(req, ev);
  70         }
  71         tevent_req_set_callback(state->fcn_req, fcn_test_done, req);
  72
  73         msg = (struct notify_trigger_msg) {
  74                 .when = timespec_current(),
  75                 .action = trigger_action,
  76                 .filter = trigger_filter,
  77         };
  78         iov[0] = (struct iovec) {
  79                 .iov_base = &msg,
  80                 .iov_len = offsetof(struct notify_trigger_msg, path),
  81         };
  82         iov[1] = (struct iovec) {
  83                 .iov_base = discard_const_p(char, trigger_path),
  84                 .iov_len = strlen(trigger_path)+1,
  85         };
  86
  87         status = messaging_send_iov(
  88                 msg_ctx,
  89                 notifyd,
  90                 MSG_SMB_NOTIFY_TRIGGER,
  91                 iov,
  92                 ARRAY_SIZE(iov),
  93                 NULL,
  94                 0);
  95         if (tevent_req_nterror(req, status)) {
  96                 return tevent_req_post(req, ev);
  97         }
  98
  99         return req;
 100 }
 101
 102 static void fcn_test_done(struct tevent_req *subreq)
 103 {
 104         struct tevent_req *req = tevent_req_callback_data(
 105                 subreq, struct tevent_req);
 106         struct fcn_test_state *state = tevent_req_data(
 107                 req, struct fcn_test_state);
 108         NTSTATUS status;
 109         bool ok;
 110
 111         SMB_ASSERT(subreq == state->fcn_req);
 112
 113         status = fcn_wait_recv(subreq, NULL, NULL, NULL, NULL);
 114
 115         if (NT_STATUS_EQUAL(status, NT_STATUS_CANCELLED)) {
 116                 TALLOC_FREE(subreq);
 117                 state->fcn_req = NULL;
 118                 tevent_req_done(req);
 119                 return;
 120         }
 121
 122         if (tevent_req_nterror(req, status)) {
 123                 TALLOC_FREE(subreq);
 124                 state->fcn_req = NULL;
 125                 return;
 126         }
 127
 128         state->got_trigger = true;
 129
 130         ok = tevent_req_cancel(subreq);
 131         if (!ok) {
 132                 tevent_req_nterror(req, NT_STATUS_INTERNAL_ERROR);
 133                 return;
 134         }
 135 }
 136
 137 static NTSTATUS fcn_test_recv(struct tevent_req *req, bool *got_trigger)
 138 {
 139         struct fcn_test_state *state = tevent_req_data(
 140                 req, struct fcn_test_state);
 141         NTSTATUS status;
 142
 143         if (tevent_req_is_nterror(req, &status)) {
 144                 return status;
 145         }
 146         if (got_trigger != NULL) {
 147                 *got_trigger = state->got_trigger;
 148         }
 149
 150         return NT_STATUS_OK;
 151 }
 152
 153 static NTSTATUS fcn_test(
 154         struct messaging_context *msg_ctx,
 155         struct server_id notifyd,
 156         const char *fcn_path,
 157         uint32_t fcn_filter,
 158         uint32_t fcn_subdir_filter,
 159         const char *trigger_path,
 160         uint32_t trigger_action,
 161         uint32_t trigger_filter,
 162         bool *got_trigger)
 163 {
 164         struct tevent_context *ev = NULL;
 165         struct tevent_req *req = NULL;
 166         NTSTATUS status = NT_STATUS_NO_MEMORY;
 167
 168         ev = samba_tevent_context_init(msg_ctx);
 169         if (ev == NULL) {
 170                 goto fail;
 171         }
 172         req = fcn_test_send(
 173                 ev,
 174                 ev,
 175                 msg_ctx,
 176                 notifyd,
 177                 fcn_path,
 178                 fcn_filter,
 179                 fcn_subdir_filter,
 180                 trigger_path,
 181                 trigger_action,
 182                 trigger_filter);
 183         if (req == NULL) {
 184                 goto fail;
 185         }
 186         if (!tevent_req_poll_ntstatus(req, ev, &status)) {
 187                 goto fail;
 188         }
 189         status = fcn_test_recv(req, got_trigger);
 190 fail:
 191         TALLOC_FREE(ev);
 192         return status;
 193 }
 194
 195 static bool test_notifyd_trigger1(struct torture_context *tctx)
 196 {
 197         struct messaging_context *msg_ctx = NULL;
 198         struct server_id_db *names = NULL;
 199         struct server_id notifyd;
 200         NTSTATUS status;
 201         bool got_trigger = false;
 202         bool ok;
 203
 204         /*
 205          * Basic filechangenotify test: Wait for /home, trigger on
 206          * /home/foo, check an event was received
 207          */
 208
 209         lp_load_global(tctx->lp_ctx->szConfigFile);
 210
 211         msg_ctx = messaging_init(tctx, tctx->ev);
 212         torture_assert_not_null(tctx, msg_ctx, "messaging_init");
 213
 214         names = messaging_names_db(msg_ctx);
 215         ok = server_id_db_lookup_one(names, "notify-daemon", &notifyd);
 216         torture_assert(tctx, ok, "server_id_db_lookup_one");
 217
 218         status = fcn_test(
 219                 msg_ctx,
 220                 notifyd,
 221                 "/home",
 222                 UINT32_MAX,
 223                 UINT32_MAX,
 224                 "/home/foo",
 225                 UINT32_MAX,
 226                 UINT32_MAX,
 227                 &got_trigger);
 228         torture_assert_ntstatus_ok(tctx, status, "fcn_test");
 229         torture_assert(tctx, got_trigger, "got_trigger");
 230
 231         return true;
 232 }
 233
 234 struct notifyd_have_state {
 235         struct server_id self;
 236         bool found;
 237 };
 238
 239 static bool notifyd_have_fn(
 240         const char *path,
 241         struct server_id server,
 242         const struct notify_instance *instance,
 243         void *private_data)
 244 {
 245         struct notifyd_have_state *state = private_data;
 246         state->found |= server_id_equal(&server, &state->self);
 247         return true;
 248 }
 249
 250 static bool notifyd_have_self(struct messaging_context *msg_ctx)
 251 {
 252         struct notifyd_have_state state = {
 253                 .self = messaging_server_id(msg_ctx),
 254         };
 255         NTSTATUS status;
 256
 257         status = notify_walk(msg_ctx, notifyd_have_fn, &state);
 258         if (!NT_STATUS_IS_OK(status)) {
 259                 return false;
 260         }
 261         return state.found;
 262 }
 263
 264 static bool test_notifyd_dbtest1(struct torture_context *tctx)
 265 {
 266         struct tevent_context *ev = tctx->ev;
 267         struct messaging_context *msg_ctx = NULL;
 268         struct tevent_req *req = NULL;
 269         struct server_id_db *names = NULL;
 270         struct server_id notifyd;
 271         NTSTATUS status;
 272         bool ok;
 273
 274         /*
 275          * Make sure fcn_wait_send adds us to the notifyd internal
 276          * database and that cancelling the fcn request removes us
 277          * again.
 278          */
 279
 280         lp_load_global(tctx->lp_ctx->szConfigFile);
 281
 282         msg_ctx = messaging_init(tctx, ev);
 283         torture_assert_not_null(tctx, msg_ctx, "messaging_init");
 284
 285         names = messaging_names_db(msg_ctx);
 286         ok = server_id_db_lookup_one(names, "notify-daemon", &notifyd);
 287         torture_assert(tctx, ok, "server_id_db_lookup_one");
 288
 289         req = fcn_wait_send(
 290                 msg_ctx, ev, msg_ctx, notifyd, "/x", UINT32_MAX, UINT32_MAX);
 291         torture_assert_not_null(tctx, req, "fcn_wait_send");
 292
 293         ok = notifyd_have_self(msg_ctx);
 294         torture_assert(tctx, ok, "notifyd_have_self");
 295
 296         ok = tevent_req_cancel(req);
 297         torture_assert(tctx, ok, "tevent_req_cancel");
 298
 299         ok = tevent_req_poll(req, ev);
 300         torture_assert(tctx, ok, "tevent_req_poll");
 301
 302         status = fcn_wait_recv(req, NULL, NULL, NULL, NULL);
 303         torture_assert_ntstatus_equal(
 304                 tctx, status, NT_STATUS_CANCELLED, "fcn_wait_recv");
 305         TALLOC_FREE(req);
 306
 307         ok = notifyd_have_self(msg_ctx);
 308         torture_assert(tctx, !ok, "tevent_req_poll");
 309         TALLOC_FREE(msg_ctx);
 310
 311         return true;
 312 }
 313
 314 NTSTATUS torture_notifyd_init(TALLOC_CTX *mem_ctx);
 315 NTSTATUS torture_notifyd_init(TALLOC_CTX *mem_ctx)
 316 {
 317         struct torture_suite *suite = NULL;
 318         struct torture_tcase *tcase = NULL;
 319         bool ok;
 320
 321         suite = torture_suite_create(mem_ctx, "notifyd");
 322         if (suite == NULL) {
 323                 goto fail;
 324         }
 325
 326         tcase = torture_suite_add_simple_test(
 327                 suite, "trigger1", test_notifyd_trigger1);
 328         if (tcase == NULL) {
 329                 goto fail;
 330         }
 331
 332         tcase = torture_suite_add_simple_test(
 333                 suite, "dbtest1", test_notifyd_dbtest1);
 334         if (tcase == NULL) {
 335                 goto fail;
 336         }
 337         suite->description = "notifyd unit tests";
 338
 339         ok = torture_register_suite(mem_ctx, suite);
 340         if (!ok) {
 341                 goto fail;
 342         }
 343         return NT_STATUS_OK;
 344 fail:
 345         TALLOC_FREE(suite);
 346         return NT_STATUS_NO_MEMORY;
 347 }