source: branches/samba-3.2.x/source/lib/ctdbd_conn.c@ 228

Last change on this file since 228 was 133, checked in by Paul Smedley, 18 years ago

Update trunk to 3.2.0pre3
File size: 29.4 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 Samba internal messaging functions
4 Copyright (C) 2007 by Volker Lendecke
5 Copyright (C) 2007 by Andrew Tridgell
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19*/
20
21#include "includes.h"
22
23#ifdef CLUSTER_SUPPORT
24
25#include "librpc/gen_ndr/messaging.h"
26#include "librpc/gen_ndr/ndr_messaging.h"
27
28/* paths to these include files come from --with-ctdb= in configure */
29#include "ctdb.h"
30#include "ctdb_private.h"
31
32struct ctdbd_connection {
33 struct messaging_context *msg_ctx;
34 uint32 reqid;
35 uint32 our_vnn;
36 uint64 rand_srvid;
37 struct packet_context *pkt;
38 struct fd_event *fde;
39
40 void (*release_ip_handler)(const char *ip_addr, void *private_data);
41 void *release_ip_priv;
42};
43
44static NTSTATUS ctdbd_control(struct ctdbd_connection *conn,
45 uint32_t vnn, uint32 opcode,
46 uint64_t srvid, TDB_DATA data,
47 TALLOC_CTX *mem_ctx, TDB_DATA *outdata,
48 int *cstatus);
49
50/*
51 * exit on fatal communications errors with the ctdbd daemon
52 */
53static void cluster_fatal(const char *why)
54{
55 DEBUG(0,("cluster fatal event: %s - exiting immediately\n", why));
56 /* we don't use smb_panic() as we don't want to delay to write
57 a core file. We need to release this process id immediately
58 so that someone else can take over without getting sharing
59 violations */
60 _exit(0);
61}
62
63/*
64 *
65 */
66static void ctdb_packet_dump(struct ctdb_req_header *hdr)
67{
68 if (DEBUGLEVEL < 10) {
69 return;
70 }
71 DEBUGADD(10, ("len=%d, magic=%x, vers=%d, gen=%d, op=%d, reqid=%d\n",
72 (int)hdr->length, (int)hdr->ctdb_magic,
73 (int)hdr->ctdb_version, (int)hdr->generation,
74 (int)hdr->operation, (int)hdr->reqid));
75}
76
77/*
78 * Register a srvid with ctdbd
79 */
80static NTSTATUS register_with_ctdbd(struct ctdbd_connection *conn,
81 uint64_t srvid)
82{
83
84 int cstatus;
85 return ctdbd_control(conn, CTDB_CURRENT_NODE,
86 CTDB_CONTROL_REGISTER_SRVID, srvid,
87 tdb_null, NULL, NULL, &cstatus);
88}
89
90/*
91 * get our vnn from the cluster
92 */
93static NTSTATUS get_cluster_vnn(struct ctdbd_connection *conn, uint32 *vnn)
94{
95 int32_t cstatus=-1;
96 NTSTATUS status;
97 status = ctdbd_control(conn,
98 CTDB_CURRENT_NODE, CTDB_CONTROL_GET_PNN, 0,
99 tdb_null, NULL, NULL, &cstatus);
100 if (!NT_STATUS_IS_OK(status)) {
101 cluster_fatal("ctdbd_control failed\n");
102 }
103 *vnn = (uint32_t)cstatus;
104 return status;
105}
106
107uint32 ctdbd_vnn(const struct ctdbd_connection *conn)
108{
109 return conn->our_vnn;
110}
111
112/*
113 * Get us a ctdb connection
114 */
115
116static NTSTATUS ctdbd_connect(TALLOC_CTX *mem_ctx,
117 struct packet_context **presult)
118{
119 struct packet_context *result;
120 const char *sockname = lp_ctdbd_socket();
121 struct sockaddr_un addr;
122 int fd;
123
124 if (!sockname || !*sockname) {
125 sockname = CTDB_PATH;
126 }
127
128 fd = socket(AF_UNIX, SOCK_STREAM, 0);
129 if (fd == -1) {
130 DEBUG(3, ("Could not create socket: %s\n", strerror(errno)));
131 return map_nt_error_from_unix(errno);
132 }
133
134 ZERO_STRUCT(addr);
135 addr.sun_family = AF_UNIX;
136 strncpy(addr.sun_path, sockname, sizeof(addr.sun_path));
137
138 if (sys_connect(fd, (struct sockaddr *)&addr) == -1) {
139 DEBUG(0, ("connect(%s) failed: %s\n", sockname,
140 strerror(errno)));
141 close(fd);
142 return map_nt_error_from_unix(errno);
143 }
144
145 if (!(result = packet_init(mem_ctx, fd))) {
146 close(fd);
147 return NT_STATUS_NO_MEMORY;
148 }
149
150 *presult = result;
151 return NT_STATUS_OK;
152}
153
154/*
155 * Do we have a complete ctdb packet in the queue?
156 */
157
158static bool ctdb_req_complete(const struct data_blob *data,
159 size_t *length,
160 void *private_data)
161{
162 uint32 msglen;
163
164 if (data->length < sizeof(msglen)) {
165 return False;
166 }
167
168 msglen = *((uint32 *)data->data);
169
170 DEBUG(10, ("msglen = %d\n", msglen));
171
172 if (msglen < sizeof(struct ctdb_req_header)) {
173 DEBUG(0, ("Got invalid msglen: %d, expected at least %d for "
174 "the req_header\n", (int)msglen,
175 (int)sizeof(struct ctdb_req_header)));
176 cluster_fatal("ctdbd protocol error\n");
177 }
178
179 if (data->length >= msglen) {
180 *length = msglen;
181 return True;
182 }
183
184 return False;
185}
186
187/*
188 * State necessary to defer an incoming message while we are waiting for a
189 * ctdb reply.
190 */
191
192struct deferred_msg_state {
193 struct messaging_context *msg_ctx;
194 struct messaging_rec *rec;
195};
196
197/*
198 * Timed event handler for the deferred message
199 */
200
201static void deferred_message_dispatch(struct event_context *event_ctx,
202 struct timed_event *te,
203 const struct timeval *now,
204 void *private_data)
205{
206 struct deferred_msg_state *state = talloc_get_type_abort(
207 private_data, struct deferred_msg_state);
208
209 messaging_dispatch_rec(state->msg_ctx, state->rec);
210 TALLOC_FREE(state);
211 TALLOC_FREE(te);
212}
213
214struct req_pull_state {
215 TALLOC_CTX *mem_ctx;
216 DATA_BLOB req;
217};
218
219/*
220 * Pull a ctdb request out of the incoming packet queue
221 */
222
223static NTSTATUS ctdb_req_pull(const struct data_blob *data,
224 void *private_data)
225{
226 struct req_pull_state *state = (struct req_pull_state *)private_data;
227
228 state->req = data_blob_talloc(state->mem_ctx, data->data,
229 data->length);
230 if (state->req.data == NULL) {
231 return NT_STATUS_NO_MEMORY;
232 }
233 return NT_STATUS_OK;
234}
235
236/*
237 * Fetch a messaging_rec from an incoming ctdb style message
238 */
239
240static struct messaging_rec *ctdb_pull_messaging_rec(TALLOC_CTX *mem_ctx,
241 size_t overall_length,
242 struct ctdb_req_message *msg)
243{
244 struct messaging_rec *result;
245 DATA_BLOB blob;
246 enum ndr_err_code ndr_err;
247
248 if ((overall_length < offsetof(struct ctdb_req_message, data))
249 || (overall_length
250 < offsetof(struct ctdb_req_message, data) + msg->datalen)) {
251
252 cluster_fatal("got invalid msg length");
253 }
254
255 if (!(result = TALLOC_P(mem_ctx, struct messaging_rec))) {
256 DEBUG(0, ("talloc failed\n"));
257 return NULL;
258 }
259
260 blob = data_blob_const(msg->data, msg->datalen);
261
262 ndr_err = ndr_pull_struct_blob(
263 &blob, result, result,
264 (ndr_pull_flags_fn_t)ndr_pull_messaging_rec);
265
266 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
267 DEBUG(0, ("ndr_pull_struct_blob failed: %s\n",
268 ndr_errstr(ndr_err)));
269 TALLOC_FREE(result);
270 return NULL;
271 }
272
273 if (DEBUGLEVEL >= 10) {
274 DEBUG(10, ("ctdb_pull_messaging_rec:\n"));
275 NDR_PRINT_DEBUG(messaging_rec, result);
276 }
277
278 return result;
279}
280
281/*
282 * Read a full ctdbd request. If we have a messaging context, defer incoming
283 * messages that might come in between.
284 */
285
286static NTSTATUS ctdb_read_req(struct ctdbd_connection *conn, uint32 reqid,
287 TALLOC_CTX *mem_ctx, void *result)
288{
289 struct ctdb_req_header *hdr;
290 struct req_pull_state state;
291 NTSTATUS status;
292
293 again:
294
295 status = packet_fd_read_sync(conn->pkt);
296
297 if (NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_BUSY)) {
298 /* EAGAIN */
299 goto again;
300 } else if (NT_STATUS_EQUAL(status, NT_STATUS_RETRY)) {
301 /* EAGAIN */
302 goto again;
303 }
304
305 if (!NT_STATUS_IS_OK(status)) {
306 DEBUG(0, ("packet_fd_read failed: %s\n", nt_errstr(status)));
307 cluster_fatal("ctdbd died\n");
308 }
309
310 next_pkt:
311
312 ZERO_STRUCT(state);
313 state.mem_ctx = mem_ctx;
314
315 if (!packet_handler(conn->pkt, ctdb_req_complete, ctdb_req_pull,
316 &state, &status)) {
317 /*
318 * Not enough data
319 */
320 DEBUG(10, ("not enough data from ctdb socket, retrying\n"));
321 goto again;
322 }
323
324 if (!NT_STATUS_IS_OK(status)) {
325 DEBUG(0, ("Could not read packet: %s\n", nt_errstr(status)));
326 cluster_fatal("ctdbd died\n");
327 }
328
329 hdr = (struct ctdb_req_header *)state.req.data;
330
331 DEBUG(10, ("Received ctdb packet\n"));
332 ctdb_packet_dump(hdr);
333
334 if (hdr->operation == CTDB_REQ_MESSAGE) {
335 struct timed_event *evt;
336 struct deferred_msg_state *msg_state;
337 struct ctdb_req_message *msg = (struct ctdb_req_message *)hdr;
338
339 if (conn->msg_ctx == NULL) {
340 DEBUG(1, ("Got a message without having a msg ctx, "
341 "dropping msg %llu\n",
342 (long long unsigned)msg->srvid));
343 goto next_pkt;
344 }
345
346 if ((conn->release_ip_handler != NULL)
347 && (msg->srvid == CTDB_SRVID_RELEASE_IP)) {
348 /* must be dispatched immediately */
349 DEBUG(10, ("received CTDB_SRVID_RELEASE_IP\n"));
350 conn->release_ip_handler((const char *)msg->data,
351 conn->release_ip_priv);
352 TALLOC_FREE(hdr);
353 goto next_pkt;
354 }
355
356 if (!(msg_state = TALLOC_P(NULL, struct deferred_msg_state))) {
357 DEBUG(0, ("talloc failed\n"));
358 TALLOC_FREE(hdr);
359 goto next_pkt;
360 }
361
362 if (!(msg_state->rec = ctdb_pull_messaging_rec(
363 msg_state, state.req.length, msg))) {
364 DEBUG(0, ("ctdbd_pull_messaging_rec failed\n"));
365 TALLOC_FREE(msg_state);
366 TALLOC_FREE(hdr);
367 goto next_pkt;
368 }
369
370 TALLOC_FREE(hdr);
371
372 msg_state->msg_ctx = conn->msg_ctx;
373
374 /*
375 * We're waiting for a call reply, but an async message has
376 * crossed. Defer dispatching to the toplevel event loop.
377 */
378 evt = event_add_timed(conn->msg_ctx->event_ctx,
379 conn->msg_ctx->event_ctx,
380 timeval_zero(),
381 "deferred_message_dispatch",
382 deferred_message_dispatch,
383 msg_state);
384 if (evt == NULL) {
385 DEBUG(0, ("event_add_timed failed\n"));
386 TALLOC_FREE(msg_state);
387 TALLOC_FREE(hdr);
388 goto next_pkt;
389 }
390
391 goto next_pkt;
392 }
393
394 if (hdr->reqid != reqid) {
395 /* we got the wrong reply */
396 DEBUG(0,("Discarding mismatched ctdb reqid %u should have "
397 "been %u\n", hdr->reqid, reqid));
398 TALLOC_FREE(hdr);
399 goto again;
400 }
401
402 *((void **)result) = talloc_move(mem_ctx, &hdr);
403
404 return NT_STATUS_OK;
405}
406
407/*
408 * Get us a ctdbd connection
409 */
410
411NTSTATUS ctdbd_init_connection(TALLOC_CTX *mem_ctx,
412 struct ctdbd_connection **pconn)
413{
414 struct ctdbd_connection *conn;
415 NTSTATUS status;
416
417 if (!(conn = TALLOC_ZERO_P(mem_ctx, struct ctdbd_connection))) {
418 DEBUG(0, ("talloc failed\n"));
419 return NT_STATUS_NO_MEMORY;
420 }
421
422 status = ctdbd_connect(conn, &conn->pkt);
423
424 if (!NT_STATUS_IS_OK(status)) {
425 DEBUG(10, ("ctdbd_connect failed: %s\n", nt_errstr(status)));
426 goto fail;
427 }
428
429 status = get_cluster_vnn(conn, &conn->our_vnn);
430
431 if (!NT_STATUS_IS_OK(status)) {
432 DEBUG(10, ("get_cluster_vnn failed: %s\n", nt_errstr(status)));
433 goto fail;
434 }
435
436 generate_random_buffer((unsigned char *)&conn->rand_srvid,
437 sizeof(conn->rand_srvid));
438
439 status = register_with_ctdbd(conn, conn->rand_srvid);
440
441 if (!NT_STATUS_IS_OK(status)) {
442 DEBUG(5, ("Could not register random srvid: %s\n",
443 nt_errstr(status)));
444 goto fail;
445 }
446
447 *pconn = conn;
448 return NT_STATUS_OK;
449
450 fail:
451 TALLOC_FREE(conn);
452 return status;
453}
454
455/*
456 * Get us a ctdbd connection and register us as a process
457 */
458
459NTSTATUS ctdbd_messaging_connection(TALLOC_CTX *mem_ctx,
460 struct ctdbd_connection **pconn)
461{
462 struct ctdbd_connection *conn;
463 NTSTATUS status;
464
465 status = ctdbd_init_connection(mem_ctx, &conn);
466
467 if (!NT_STATUS_IS_OK(status)) {
468 return status;
469 }
470
471 status = register_with_ctdbd(conn, (uint64_t)sys_getpid());
472 if (!NT_STATUS_IS_OK(status)) {
473 goto fail;
474 }
475
476 status = register_with_ctdbd(conn, MSG_SRVID_SAMBA);
477 if (!NT_STATUS_IS_OK(status)) {
478 goto fail;
479 }
480
481 *pconn = conn;
482 return NT_STATUS_OK;
483
484 fail:
485 TALLOC_FREE(conn);
486 return status;
487}
488
489/*
490 * Packet handler to receive and handle a ctdb message
491 */
492static NTSTATUS ctdb_handle_message(const struct data_blob *data,
493 void *private_data)
494{
495 struct ctdbd_connection *conn = talloc_get_type_abort(
496 private_data, struct ctdbd_connection);
497 struct ctdb_req_message *msg;
498 struct messaging_rec *msg_rec;
499
500 msg = (struct ctdb_req_message *)data->data;
501
502 if (msg->hdr.operation != CTDB_REQ_MESSAGE) {
503 DEBUG(0, ("Received async msg of type %u, discarding\n",
504 msg->hdr.operation));
505 return NT_STATUS_INVALID_PARAMETER;
506 }
507
508 if ((conn->release_ip_handler != NULL)
509 && (msg->srvid == CTDB_SRVID_RELEASE_IP)) {
510 /* must be dispatched immediately */
511 DEBUG(10, ("received CTDB_SRVID_RELEASE_IP\n"));
512 conn->release_ip_handler((const char *)msg->data,
513 conn->release_ip_priv);
514 return NT_STATUS_OK;
515 }
516
517 SMB_ASSERT(conn->msg_ctx != NULL);
518
519 if (msg->srvid == CTDB_SRVID_RECONFIGURE) {
520 DEBUG(0,("Got cluster reconfigure message\n"));
521 /*
522 * when the cluster is reconfigured, we need to clean the brl
523 * database
524 */
525 messaging_send(conn->msg_ctx, procid_self(),
526 MSG_SMB_BRL_VALIDATE, &data_blob_null);
527
528 /*
529 * it's possible that we have just rejoined the cluster after
530 * an outage. In that case our pending locks could have been
531 * removed from the lockdb, so retry them once more
532 */
533 message_send_all(conn->msg_ctx, MSG_SMB_UNLOCK, NULL, 0, NULL);
534
535 return NT_STATUS_OK;
536
537 }
538
539 /* only messages to our pid or the broadcast are valid here */
540 if (msg->srvid != sys_getpid() && msg->srvid != MSG_SRVID_SAMBA) {
541 DEBUG(0,("Got unexpected message with srvid=%llu\n",
542 (unsigned long long)msg->srvid));
543 return NT_STATUS_OK;
544 }
545
546 if (!(msg_rec = ctdb_pull_messaging_rec(NULL, data->length, msg))) {
547 DEBUG(10, ("ctdb_pull_messaging_rec failed\n"));
548 return NT_STATUS_NO_MEMORY;
549 }
550
551 messaging_dispatch_rec(conn->msg_ctx, msg_rec);
552
553 TALLOC_FREE(msg_rec);
554 return NT_STATUS_OK;
555}
556
557/*
558 * The ctdbd socket is readable asynchronuously
559 */
560
561static void ctdbd_socket_handler(struct event_context *event_ctx,
562 struct fd_event *event,
563 uint16 flags,
564 void *private_data)
565{
566 struct ctdbd_connection *conn = talloc_get_type_abort(
567 private_data, struct ctdbd_connection);
568
569 NTSTATUS status;
570
571 status = packet_fd_read(conn->pkt);
572
573 if (!NT_STATUS_IS_OK(status)) {
574 DEBUG(0, ("packet_fd_read failed: %s\n", nt_errstr(status)));
575 cluster_fatal("ctdbd died\n");
576 }
577
578 while (packet_handler(conn->pkt, ctdb_req_complete,
579 ctdb_handle_message, conn, &status)) {
580 if (!NT_STATUS_IS_OK(status)) {
581 DEBUG(10, ("could not handle incoming message: %s\n",
582 nt_errstr(status)));
583 }
584 }
585}
586
587/*
588 * Prepare a ctdbd connection to receive messages
589 */
590
591NTSTATUS ctdbd_register_msg_ctx(struct ctdbd_connection *conn,
592 struct messaging_context *msg_ctx)
593{
594 SMB_ASSERT(conn->msg_ctx == NULL);
595 SMB_ASSERT(conn->fde == NULL);
596
597 if (!(conn->fde = event_add_fd(msg_ctx->event_ctx, conn,
598 packet_get_fd(conn->pkt),
599 EVENT_FD_READ,
600 ctdbd_socket_handler,
601 conn))) {
602 DEBUG(0, ("event_add_fd failed\n"));
603 return NT_STATUS_NO_MEMORY;
604 }
605
606 conn->msg_ctx = msg_ctx;
607
608 return NT_STATUS_OK;
609}
610
611/*
612 * Send a messaging message across a ctdbd
613 */
614
615NTSTATUS ctdbd_messaging_send(struct ctdbd_connection *conn,
616 uint32 dst_vnn, uint64 dst_srvid,
617 struct messaging_rec *msg)
618{
619 struct ctdb_req_message r;
620 TALLOC_CTX *mem_ctx;
621 DATA_BLOB blob;
622 NTSTATUS status;
623 enum ndr_err_code ndr_err;
624
625 if (!(mem_ctx = talloc_init("ctdbd_messaging_send"))) {
626 DEBUG(0, ("talloc failed\n"));
627 return NT_STATUS_NO_MEMORY;
628 }
629
630 ndr_err = ndr_push_struct_blob(
631 &blob, mem_ctx, msg,
632 (ndr_push_flags_fn_t)ndr_push_messaging_rec);
633
634 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
635 DEBUG(0, ("ndr_push_struct_blob failed: %s\n",
636 ndr_errstr(ndr_err)));
637 status = ndr_map_error2ntstatus(ndr_err);
638 goto fail;
639 }
640
641 r.hdr.length = offsetof(struct ctdb_req_message, data) + blob.length;
642 r.hdr.ctdb_magic = CTDB_MAGIC;
643 r.hdr.ctdb_version = CTDB_VERSION;
644 r.hdr.generation = 1;
645 r.hdr.operation = CTDB_REQ_MESSAGE;
646 r.hdr.destnode = dst_vnn;
647 r.hdr.srcnode = conn->our_vnn;
648 r.hdr.reqid = 0;
649 r.srvid = dst_srvid;
650 r.datalen = blob.length;
651
652 DEBUG(10, ("ctdbd_messaging_send: Sending ctdb packet\n"));
653 ctdb_packet_dump(&r.hdr);
654
655 status = packet_send(
656 conn->pkt, 2,
657 data_blob_const(&r, offsetof(struct ctdb_req_message, data)),
658 blob);
659
660 if (!NT_STATUS_IS_OK(status)) {
661 DEBUG(0, ("packet_send failed: %s\n", nt_errstr(status)));
662 goto fail;
663 }
664
665 status = packet_flush(conn->pkt);
666
667 if (!NT_STATUS_IS_OK(status)) {
668 DEBUG(3, ("write to ctdbd failed: %s\n", nt_errstr(status)));
669 cluster_fatal("cluster dispatch daemon msg write error\n");
670 }
671
672 status = NT_STATUS_OK;
673 fail:
674 TALLOC_FREE(mem_ctx);
675 return status;
676}
677
678/*
679 * send/recv a generic ctdb control message
680 */
681static NTSTATUS ctdbd_control(struct ctdbd_connection *conn,
682 uint32_t vnn, uint32 opcode,
683 uint64_t srvid, TDB_DATA data,
684 TALLOC_CTX *mem_ctx, TDB_DATA *outdata,
685 int *cstatus)
686{
687 struct ctdb_req_control req;
688 struct ctdb_reply_control *reply = NULL;
689 struct ctdbd_connection *new_conn = NULL;
690 NTSTATUS status;
691
692 if (conn == NULL) {
693 status = ctdbd_init_connection(NULL, &new_conn);
694
695 if (!NT_STATUS_IS_OK(status)) {
696 DEBUG(10, ("Could not init temp connection: %s\n",
697 nt_errstr(status)));
698 goto fail;
699 }
700
701 conn = new_conn;
702 }
703
704 ZERO_STRUCT(req);
705 req.hdr.length = offsetof(struct ctdb_req_control, data) + data.dsize;
706 req.hdr.ctdb_magic = CTDB_MAGIC;
707 req.hdr.ctdb_version = CTDB_VERSION;
708 req.hdr.operation = CTDB_REQ_CONTROL;
709 req.hdr.reqid = ++conn->reqid;
710 req.hdr.destnode = vnn;
711 req.opcode = opcode;
712 req.srvid = srvid;
713 req.datalen = data.dsize;
714
715 DEBUG(10, ("ctdbd_control: Sending ctdb packet\n"));
716 ctdb_packet_dump(&req.hdr);
717
718 status = packet_send(
719 conn->pkt, 2,
720 data_blob_const(&req, offsetof(struct ctdb_req_control, data)),
721 data_blob_const(data.dptr, data.dsize));
722
723 if (!NT_STATUS_IS_OK(status)) {
724 DEBUG(3, ("packet_send failed: %s\n", nt_errstr(status)));
725 goto fail;
726 }
727
728 status = packet_flush(conn->pkt);
729
730 if (!NT_STATUS_IS_OK(status)) {
731 DEBUG(3, ("write to ctdbd failed: %s\n", nt_errstr(status)));
732 cluster_fatal("cluster dispatch daemon control write error\n");
733 }
734
735 status = ctdb_read_req(conn, req.hdr.reqid, NULL, (void *)&reply);
736
737 if (!NT_STATUS_IS_OK(status)) {
738 DEBUG(10, ("ctdb_read_req failed: %s\n", nt_errstr(status)));
739 goto fail;
740 }
741
742 if (reply->hdr.operation != CTDB_REPLY_CONTROL) {
743 DEBUG(0, ("received invalid reply\n"));
744 goto fail;
745 }
746
747 if (outdata) {
748 if (!(outdata->dptr = (uint8 *)talloc_memdup(
749 mem_ctx, reply->data, reply->datalen))) {
750 TALLOC_FREE(reply);
751 return NT_STATUS_NO_MEMORY;
752 }
753 outdata->dsize = reply->datalen;
754 }
755 if (cstatus) {
756 (*cstatus) = reply->status;
757 }
758
759 status = NT_STATUS_OK;
760
761 fail:
762 TALLOC_FREE(new_conn);
763 TALLOC_FREE(reply);
764 return status;
765}
766
767/*
768 * see if a remote process exists
769 */
770bool ctdbd_process_exists(struct ctdbd_connection *conn, uint32 vnn, pid_t pid)
771{
772 NTSTATUS status;
773 TDB_DATA data;
774 int32_t cstatus;
775