2 * Unix SMB/CIFS implementation.
3 * Samba internal messaging functions
4 * Copyright (C) 2017 by Volker Lendecke
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.
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.
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/>.
21 #include "lib/messages_ctdb.h"
22 #include "lib/util/server_id.h"
25 #include "lib/util/iov_buf.h"
26 #include "lib/messages_util.h"
27 #include "ctdbd_conn.h"
28 #include "lib/cluster_support.h"
29 #include "ctdb_srvids.h"
31 struct messaging_ctdb_context;
34 * We can only have one tevent_fd per ctdb_context and per
35 * tevent_context. Maintain a list of registered tevent_contexts per
38 struct messaging_ctdb_fde_ev {
39 struct messaging_ctdb_fde_ev *prev, *next;
42 * Backreference to enable DLIST_REMOVE from our
43 * destructor. Also, set to NULL when the ctdb_context dies
44 * before the messaging_ctdb_fde_ev.
46 struct messaging_ctdb_context *ctx;
48 struct tevent_context *ev;
49 struct tevent_fd *fde;
52 struct messaging_ctdb_context {
53 struct ctdbd_connection *conn;
55 void (*recv_cb)(struct tevent_context *ev,
56 const uint8_t *msg, size_t msg_len,
57 int *fds, size_t num_fds,
59 void *recv_cb_private_data;
61 struct messaging_ctdb_fde_ev *fde_evs;
64 static int messaging_ctdb_recv(
65 struct tevent_context *ev,
66 uint32_t src_vnn, uint32_t dst_vnn, uint64_t dst_srvid,
67 const uint8_t *msg, size_t msg_len, void *private_data)
69 struct messaging_ctdb_context *state = talloc_get_type_abort(
70 private_data, struct messaging_ctdb_context);
72 state->recv_cb(ev, msg, msg_len, NULL, 0, state->recv_cb_private_data);
77 struct messaging_ctdb_context *global_ctdb_context;
79 int messaging_ctdb_init(const char *sockname, int timeout, uint64_t unique_id,
80 void (*recv_cb)(struct tevent_context *ev,
81 const uint8_t *msg, size_t msg_len,
82 int *fds, size_t num_fds,
86 struct messaging_ctdb_context *ctx;
89 if (global_ctdb_context != NULL) {
93 ctx = talloc_zero(NULL, struct messaging_ctdb_context);
97 ctx->recv_cb = recv_cb;
98 ctx->recv_cb_private_data = private_data;
100 ret = ctdbd_init_connection(ctx, sockname, timeout, &ctx->conn);
102 DBG_DEBUG("ctdbd_init_connection returned %s\n",
107 ret = register_with_ctdbd(ctx->conn, getpid(), messaging_ctdb_recv,
110 DBG_DEBUG("register_with_ctdbd returned %s (%d)\n",
115 ret = register_with_ctdbd(ctx->conn, CTDB_SRVID_SAMBA_PROCESS,
116 messaging_ctdb_recv, ctx);
118 DBG_DEBUG("register_with_ctdbd returned %s (%d)\n",
123 ret = register_with_ctdbd(ctx->conn, unique_id, NULL, NULL);
125 DBG_DEBUG("register_with_ctdbd returned %s (%d)\n",
130 set_my_vnn(ctdbd_vnn(ctx->conn));
132 global_ctdb_context = ctx;
139 void messaging_ctdb_destroy(void)
141 TALLOC_FREE(global_ctdb_context);
144 int messaging_ctdb_send(uint32_t dst_vnn, uint64_t dst_srvid,
145 const struct iovec *iov, int iovlen)
147 struct messaging_ctdb_context *ctx = global_ctdb_context;
154 ret = ctdbd_messaging_send_iov(ctx->conn, dst_vnn, dst_srvid,
159 static void messaging_ctdb_read_handler(struct tevent_context *ev,
160 struct tevent_fd *fde,
164 struct messaging_ctdb_context *ctx = talloc_get_type_abort(
165 private_data, struct messaging_ctdb_context);
167 if ((flags & TEVENT_FD_READ) == 0) {
170 ctdbd_socket_readable(ev, ctx->conn);
173 struct messaging_ctdb_fde {
174 struct tevent_fd *fde;
177 static int messaging_ctdb_fde_ev_destructor(
178 struct messaging_ctdb_fde_ev *fde_ev)
180 if (fde_ev->ctx != NULL) {
181 DLIST_REMOVE(fde_ev->ctx->fde_evs, fde_ev);
188 * Reference counter for a struct tevent_fd messaging read event
189 * (with callback function) on a struct tevent_context registered
190 * on a messaging context.
192 * If we've already registered this struct tevent_context before
193 * (so already have a read event), just increase the reference count.
195 * Otherwise create a new struct tevent_fd messaging read event on the
196 * previously unseen struct tevent_context - this is what drives
197 * the message receive processing.
201 struct messaging_ctdb_fde *messaging_ctdb_register_tevent_context(
202 TALLOC_CTX *mem_ctx, struct tevent_context *ev)
204 struct messaging_ctdb_context *ctx = global_ctdb_context;
205 struct messaging_ctdb_fde_ev *fde_ev;
206 struct messaging_ctdb_fde *fde;
212 fde = talloc(mem_ctx, struct messaging_ctdb_fde);
217 for (fde_ev = ctx->fde_evs; fde_ev != NULL; fde_ev = fde_ev->next) {
218 if (tevent_fd_get_flags(fde_ev->fde) == 0) {
220 * If the event context got deleted,
221 * tevent_fd_get_flags() will return 0
224 * In that case we should not
225 * use fde_ev->ev anymore.
229 if (fde_ev->ev == ev) {
234 if (fde_ev == NULL) {
235 int sock = ctdbd_conn_get_fd(ctx->conn);
237 fde_ev = talloc(fde, struct messaging_ctdb_fde_ev);
238 if (fde_ev == NULL) {
241 fde_ev->fde = tevent_add_fd(
242 ev, fde_ev, sock, TEVENT_FD_READ,
243 messaging_ctdb_read_handler, ctx);
244 if (fde_ev->fde == NULL) {
250 DLIST_ADD(ctx->fde_evs, fde_ev);
251 talloc_set_destructor(
252 fde_ev, messaging_ctdb_fde_ev_destructor);
255 * Same trick as with tdb_wrap: The caller will never
256 * see the talloc_referenced object, the
257 * messaging_ctdb_fde_ev, so problems with
258 * talloc_unlink will not happen.
260 if (talloc_reference(fde, fde_ev) == NULL) {
266 fde->fde = fde_ev->fde;
270 bool messaging_ctdb_fde_active(struct messaging_ctdb_fde *fde)
277 flags = tevent_fd_get_flags(fde->fde);
281 struct ctdbd_connection *messaging_ctdb_connection(void)
283 if (global_ctdb_context == NULL) {
284 smb_panic("messaging not initialized\n");
286 return global_ctdb_context->conn;