2 * Unix SMB/CIFS implementation.
3 * Samba internal messaging functions
4 * Copyright (C) 2013 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/util/data_blob.h"
22 #include "lib/util/debug.h"
23 #include "lib/unix_msg/unix_msg.h"
24 #include "system/filesys.h"
25 #include "lib/messages_dgm.h"
26 #include "lib/param/param.h"
27 #include "poll_funcs/poll_funcs_tevent.h"
28 #include "unix_msg/unix_msg.h"
30 struct messaging_dgm_context
{
32 struct poll_funcs
*msg_callbacks
;
34 struct unix_msg_ctx
*dgm_ctx
;
38 void (*recv_cb
)(const uint8_t *msg
,
41 void *recv_cb_private_data
;
43 bool *have_dgm_context
;
46 static void messaging_dgm_recv(struct unix_msg_ctx
*ctx
,
47 uint8_t *msg
, size_t msg_len
,
50 static char *messaging_dgm_lockfile_name(TALLOC_CTX
*mem_ctx
,
51 const char *cache_dir
,
54 return talloc_asprintf(mem_ctx
, "%s/lck/%u", cache_dir
,
58 static int messaging_dgm_context_destructor(struct messaging_dgm_context
*c
);
60 static int messaging_dgm_lockfile_create(TALLOC_CTX
*tmp_ctx
,
61 const char *cache_dir
,
62 uid_t dir_owner
, pid_t pid
,
63 int *plockfile_fd
, uint64_t unique
)
74 dir
= talloc_asprintf(tmp_ctx
, "%s/lck", cache_dir
);
79 ok
= directory_create_or_exist_strict(dir
, dir_owner
, 0755);
83 DEBUG(1, ("%s: Could not create lock directory: %s\n",
84 __func__
, strerror(ret
)));
88 lockfile_name
= messaging_dgm_lockfile_name(tmp_ctx
, cache_dir
,
90 if (lockfile_name
== NULL
) {
94 /* no O_EXCL, existence check is via the fcntl lock */
96 lockfile_fd
= open(lockfile_name
, O_NONBLOCK
|O_CREAT
|O_WRONLY
, 0644);
97 if (lockfile_fd
== -1) {
99 DEBUG(1, ("%s: open failed: %s\n", __func__
, strerror(errno
)));
103 lck
= (struct flock
) {
108 ret
= fcntl(lockfile_fd
, F_SETLK
, &lck
);
111 DEBUG(1, ("%s: fcntl failed: %s\n", __func__
, strerror(ret
)));
115 unique_len
= snprintf(buf
, sizeof(buf
), "%ju\n", (uintmax_t)unique
);
117 /* shorten a potentially preexisting file */
119 ret
= ftruncate(lockfile_fd
, unique_len
);
122 DEBUG(1, ("%s: ftruncate failed: %s\n", __func__
,
127 written
= write(lockfile_fd
, buf
, unique_len
);
128 if (written
!= unique_len
) {
130 DEBUG(1, ("%s: write failed: %s\n", __func__
, strerror(ret
)));
134 TALLOC_FREE(lockfile_name
);
135 *plockfile_fd
= lockfile_fd
;
139 unlink(lockfile_name
);
143 TALLOC_FREE(lockfile_name
);
147 static int messaging_dgm_lockfile_remove(TALLOC_CTX
*tmp_ctx
,
148 const char *cache_dir
, pid_t pid
)
153 lockfile_name
= messaging_dgm_lockfile_name(
154 tmp_ctx
, cache_dir
, pid
);
155 if (lockfile_name
== NULL
) {
159 ret
= unlink(lockfile_name
);
162 DEBUG(10, ("%s: unlink(%s) failed: %s\n", __func__
,
163 lockfile_name
, strerror(ret
)));
166 TALLOC_FREE(lockfile_name
);
170 int messaging_dgm_init(TALLOC_CTX
*mem_ctx
,
171 struct tevent_context
*ev
,
172 struct server_id pid
,
173 const char *cache_dir
,
175 void (*recv_cb
)(const uint8_t *msg
,
178 void *recv_cb_private_data
,
179 struct messaging_dgm_context
**pctx
)
181 struct messaging_dgm_context
*ctx
;
185 struct sockaddr_un socket_address
;
188 static bool have_dgm_context
= false;
190 if (have_dgm_context
) {
194 ctx
= talloc_zero(mem_ctx
, struct messaging_dgm_context
);
199 ctx
->recv_cb
= recv_cb
;
200 ctx
->recv_cb_private_data
= recv_cb_private_data
;
202 ctx
->cache_dir
= talloc_strdup(ctx
, cache_dir
);
203 if (ctx
->cache_dir
== NULL
) {
206 socket_dir
= talloc_asprintf(ctx
, "%s/msg", cache_dir
);
207 if (socket_dir
== NULL
) {
211 socket_address
= (struct sockaddr_un
) { .sun_family
= AF_UNIX
};
212 sockname_len
= snprintf(socket_address
.sun_path
,
213 sizeof(socket_address
.sun_path
),
214 "%s/%u", socket_dir
, (unsigned)pid
.pid
);
215 if (sockname_len
>= sizeof(socket_address
.sun_path
)) {
220 ret
= messaging_dgm_lockfile_create(ctx
, cache_dir
, dir_owner
, pid
.pid
,
221 &ctx
->lockfile_fd
, pid
.unique_id
);
223 DEBUG(1, ("%s: messaging_dgm_create_lockfile failed: %s\n",
224 __func__
, strerror(ret
)));
229 ctx
->msg_callbacks
= poll_funcs_init_tevent(ctx
);
230 if (ctx
->msg_callbacks
== NULL
) {
234 ctx
->tevent_handle
= poll_funcs_tevent_register(
235 ctx
, ctx
->msg_callbacks
, ev
);
236 if (ctx
->tevent_handle
== NULL
) {
240 ok
= directory_create_or_exist_strict(socket_dir
, dir_owner
, 0700);
242 DEBUG(1, ("Could not create socket directory\n"));
246 TALLOC_FREE(socket_dir
);
248 unlink(socket_address
.sun_path
);
250 generate_random_buffer((uint8_t *)&cookie
, sizeof(cookie
));
252 ret
= unix_msg_init(&socket_address
, ctx
->msg_callbacks
, 1024, cookie
,
253 messaging_dgm_recv
, ctx
, &ctx
->dgm_ctx
);
255 DEBUG(1, ("unix_msg_init failed: %s\n", strerror(ret
)));
259 talloc_set_destructor(ctx
, messaging_dgm_context_destructor
);
261 ctx
->have_dgm_context
= &have_dgm_context
;
271 static int messaging_dgm_context_destructor(struct messaging_dgm_context
*c
)
274 * First delete the socket to avoid races. The lockfile is the
275 * indicator that we're still around.
277 unix_msg_free(c
->dgm_ctx
);
279 if (getpid() == c
->pid
) {
280 (void)messaging_dgm_lockfile_remove(c
, c
->cache_dir
, c
->pid
);
282 close(c
->lockfile_fd
);
284 if (c
->have_dgm_context
!= NULL
) {
285 *c
->have_dgm_context
= false;
291 int messaging_dgm_send(struct messaging_dgm_context
*ctx
, pid_t pid
,
292 const struct iovec
*iov
, int iovlen
)
294 struct sockaddr_un dst
;
298 dst
= (struct sockaddr_un
) { .sun_family
= AF_UNIX
};
300 dst_pathlen
= snprintf(dst
.sun_path
, sizeof(dst
.sun_path
),
301 "%s/msg/%u", ctx
->cache_dir
, (unsigned)pid
);
302 if (dst_pathlen
>= sizeof(dst
.sun_path
)) {
306 DEBUG(10, ("%s: Sending message to %u\n", __func__
, (unsigned)pid
));
308 ret
= unix_msg_send(ctx
->dgm_ctx
, &dst
, iov
, iovlen
);
313 static void messaging_dgm_recv(struct unix_msg_ctx
*ctx
,
314 uint8_t *msg
, size_t msg_len
,
317 struct messaging_dgm_context
*dgm_ctx
= talloc_get_type_abort(
318 private_data
, struct messaging_dgm_context
);
320 dgm_ctx
->recv_cb(msg
, msg_len
, dgm_ctx
->recv_cb_private_data
);
323 int messaging_dgm_cleanup(struct messaging_dgm_context
*ctx
, pid_t pid
)
325 char *lockfile_name
, *socket_name
;
327 struct flock lck
= {};
329 lockfile_name
= messaging_dgm_lockfile_name(
330 talloc_tos(), ctx
->cache_dir
, pid
);
331 if (lockfile_name
== NULL
) {
334 socket_name
= talloc_asprintf(lockfile_name
, "%s/msg/%u",
335 ctx
->cache_dir
, (unsigned)pid
);
336 if (socket_name
== NULL
) {
337 TALLOC_FREE(lockfile_name
);
341 fd
= open(lockfile_name
, O_NONBLOCK
|O_WRONLY
, 0);
345 DEBUG(10, ("%s: open(%s) failed: %s\n", __func__
,
346 lockfile_name
, strerror(ret
)));
348 TALLOC_FREE(lockfile_name
);
352 lck
.l_type
= F_WRLCK
;
353 lck
.l_whence
= SEEK_SET
;
357 ret
= fcntl(fd
, F_SETLK
, &lck
);
360 DEBUG(10, ("%s: Could not get lock: %s\n", __func__
,
362 TALLOC_FREE(lockfile_name
);
367 (void)unlink(socket_name
);
368 (void)unlink(lockfile_name
);
371 TALLOC_FREE(lockfile_name
);
375 int messaging_dgm_wipe(struct messaging_dgm_context
*ctx
)
380 pid_t our_pid
= getpid();
384 * We scan the socket directory and not the lock directory. Otherwise
385 * we would race against messaging_dgm_lockfile_create's open(O_CREAT)
389 msgdir_name
= talloc_asprintf(talloc_tos(), "%s/msg", ctx
->cache_dir
);
390 if (msgdir_name
== NULL
) {
394 msgdir
= opendir(msgdir_name
);
395 if (msgdir
== NULL
) {
397 TALLOC_FREE(msgdir_name
);
400 TALLOC_FREE(msgdir_name
);
402 while ((dp
= readdir(msgdir
)) != NULL
) {
405 pid
= strtoul(dp
->d_name
, NULL
, 10);
408 * . and .. and other malformed entries
412 if (pid
== our_pid
) {
414 * fcntl(F_GETLK) will succeed for ourselves, we hold
415 * that lock ourselves.
420 ret
= messaging_dgm_cleanup(ctx
, pid
);
421 DEBUG(10, ("messaging_dgm_cleanup(%lu) returned %s\n",
422 pid
, ret
? strerror(ret
) : "ok"));
429 void *messaging_dgm_register_tevent_context(TALLOC_CTX
*mem_ctx
,
430 struct messaging_dgm_context
*ctx
,
431 struct tevent_context
*ev
)
433 return poll_funcs_tevent_register(mem_ctx
, ctx
->msg_callbacks
, ev
);