[SCM] Samba Shared Repository - branch master updated

Martin Schwenke martins at samba.org
Wed Jun 7 18:20:03 UTC 2017


The branch, master has been updated
       via  a884d68 ctdb-client: Document ctdb client API
       via  509afd4 ctdb-client: Move eventd API to a separate header
       via  8ee7cc6 ctdb-client: Move sync API to a separate header
       via  be0a8d6 ctdb-client: Move ctdb_ctrl_modflags() to ctdb tool
       via  8e3ed87 ctdb-client: Add async api for detaching a database
       via  1469cfb ctdb-client: Create sync wrappers for managing message handlers
       via  025ebc0 ctdb-tools: Use traverse api to re-implement ctdb catdb command
       via  da9e019 ctdb-client: Refactor cluster-wide database traverse api
       via  7630e00 ctdb-protocol: Allocate SRVID range for ctdb client
       via  6894158 ctdb-client: Rename ctdb_db_travese to ctdb_db_traverse_local
      from  103f3a3 Log the actual error returned when creating a pipe for client logging in CTDB fails. Helps with debugging issues.

https://git.samba.org/?p=samba.git;a=shortlog;h=master


- Log -----------------------------------------------------------------
commit a884d68e00766028c812976bd3f2ed52110603ff
Author: Amitay Isaacs <amitay at gmail.com>
Date:   Thu Jun 1 16:03:43 2017 +1000

    ctdb-client: Document ctdb client API
    
    Signed-off-by: Amitay Isaacs <amitay at gmail.com>
    Reviewed-by: Martin Schwenke <martin at meltin.net>
    
    Autobuild-User(master): Martin Schwenke <martins at samba.org>
    Autobuild-Date(master): Wed Jun  7 20:19:06 CEST 2017 on sn-devel-144

commit 509afd4855ce679aa56f9927f80bbd302be38a55
Author: Amitay Isaacs <amitay at gmail.com>
Date:   Thu Jun 1 14:22:03 2017 +1000

    ctdb-client: Move eventd API to a separate header
    
    Signed-off-by: Amitay Isaacs <amitay at gmail.com>
    Reviewed-by: Martin Schwenke <martin at meltin.net>

commit 8ee7cc6bdbe822e644e42f9f4eaed5e725a67ec5
Author: Amitay Isaacs <amitay at gmail.com>
Date:   Sat May 6 20:01:30 2017 +1000

    ctdb-client: Move sync API to a separate header
    
    Signed-off-by: Amitay Isaacs <amitay at gmail.com>
    Reviewed-by: Martin Schwenke <martin at meltin.net>

commit be0a8d6c5fcd4c31224d38523d8d4c03138a9793
Author: Amitay Isaacs <amitay at gmail.com>
Date:   Wed Apr 19 11:46:48 2017 +1000

    ctdb-client: Move ctdb_ctrl_modflags() to ctdb tool
    
    This function is only required by the tool.
    
    Signed-off-by: Amitay Isaacs <amitay at gmail.com>
    Reviewed-by: Martin Schwenke <martin at meltin.net>

commit 8e3ed87cacca41f113072d9b8eb6ff328ee73ba1
Author: Amitay Isaacs <amitay at gmail.com>
Date:   Tue Apr 18 16:44:29 2017 +1000

    ctdb-client: Add async api for detaching a database
    
    Signed-off-by: Amitay Isaacs <amitay at gmail.com>
    Reviewed-by: Martin Schwenke <martin at meltin.net>

commit 1469cfb0bebb4a8f89f02b30a7d6ecd53e4a88da
Author: Amitay Isaacs <amitay at gmail.com>
Date:   Tue Apr 18 16:22:12 2017 +1000

    ctdb-client: Create sync wrappers for managing message handlers
    
    This wraps the entire async computation for setting and removing message
    handlers instead of calling multiple sync calls.
    
    Signed-off-by: Amitay Isaacs <amitay at gmail.com>
    Reviewed-by: Martin Schwenke <martin at meltin.net>

commit 025ebc0fc8785242192d24dfc2e680e0d621f468
Author: Amitay Isaacs <amitay at gmail.com>
Date:   Tue Apr 4 18:30:01 2017 +1000

    ctdb-tools: Use traverse api to re-implement ctdb catdb command
    
    Signed-off-by: Amitay Isaacs <amitay at gmail.com>
    Reviewed-by: Martin Schwenke <martin at meltin.net>

commit da9e0195a82a82258e80e01a3131160ce7f9e53b
Author: Amitay Isaacs <amitay at gmail.com>
Date:   Tue Apr 4 18:25:28 2017 +1000

    ctdb-client: Refactor cluster-wide database traverse api
    
    This implements the async version of the traverse code in the ctdb tool
    for catdb command.
    
    Signed-off-by: Amitay Isaacs <amitay at gmail.com>
    Reviewed-by: Martin Schwenke <martin at meltin.net>

commit 7630e0088aac608a12014e470dc50709f93b84a3
Author: Amitay Isaacs <amitay at gmail.com>
Date:   Thu Jun 1 16:43:55 2017 +1000

    ctdb-protocol: Allocate SRVID range for ctdb client
    
    Signed-off-by: Amitay Isaacs <amitay at gmail.com>
    Reviewed-by: Martin Schwenke <martin at meltin.net>

commit 6894158103f77d1905edd3ebcc09e00695b12f5d
Author: Amitay Isaacs <amitay at gmail.com>
Date:   Tue Apr 4 17:31:11 2017 +1000

    ctdb-client: Rename ctdb_db_travese to ctdb_db_traverse_local
    
    This function only traverses the database on local node.
    
    Signed-off-by: Amitay Isaacs <amitay at gmail.com>
    Reviewed-by: Martin Schwenke <martin at meltin.net>

-----------------------------------------------------------------------

Summary of changes:
 ctdb/client/client.h                    | 1499 ++++++++++++++++++-------------
 ctdb/client/client_connect.c            |    1 +
 ctdb/client/client_control_sync.c       |    1 +
 ctdb/client/client_db.c                 |  431 ++++++++-
 ctdb/client/client_event.c              |    2 +-
 ctdb/client/client_event.h              |   92 ++
 ctdb/client/client_message.c            |   44 +-
 ctdb/client/client_message_sync.c       |    1 +
 ctdb/client/{client.h => client_sync.h} |  433 +--------
 ctdb/client/client_util.c               |   35 +-
 ctdb/protocol/protocol.h                |    8 +-
 ctdb/tools/ctdb.c                       |  131 +--
 ctdb/tools/ctdb_event.c                 |    2 +-
 ctdb/utils/pmda/pmda_ctdb.c             |    1 +
 14 files changed, 1511 insertions(+), 1170 deletions(-)
 create mode 100644 ctdb/client/client_event.h
 copy ctdb/client/{client.h => client_sync.h} (61%)


Changeset truncated at 500 lines:

diff --git a/ctdb/client/client.h b/ctdb/client/client.h
index 312615e..b7b657c 100644
--- a/ctdb/client/client.h
+++ b/ctdb/client/client.h
@@ -26,58 +26,265 @@
 #include "protocol/protocol.h"
 #include "common/srvid.h"
 
+/**
+ * @file client.h
+ *
+ * @brief Client api to talk to ctdb daemon
+ *
+ * This API allows to connect to ctdb daemon, perform various database
+ * operations, send controls to ctdb daemon and send messages to other ctdb
+ * clients.
+ */
+
+/**
+ * @brief The abstract context that holds client connection to ctdb daemon
+ */
 struct ctdb_client_context;
+
+/**
+ * @brief The abstract context that represents a clustered database
+ */
 struct ctdb_db_context;
+
+/**
+ * @brief The abstract context that represents a record from a distributed
+ * database
+ */
 struct ctdb_record_handle;
 
+/**
+ * @brief The abstract context that represents a transaction on a replicated
+ * database
+ */
+struct ctdb_transaction_handle;
+
+/**
+ * @brief Client callback function
+ *
+ * This function can be registered to be invoked in case of ctdb daemon going
+ * away.
+ */
 typedef void (*ctdb_client_callback_func_t)(void *private_data);
 
-/* from client/client_connect.c */
-
+/**
+ * @brief Initialize and connect to ctdb daemon
+ *
+ * This returns a ctdb client context.  Freeing this context will free the
+ * connection to ctdb daemon and any memory associated with it.
+ *
+ * If the connection to ctdb daemon is lost, the client will terminate
+ * automatically as the library will call exit().  If the client code
+ * wants to perform cleanup or wants to re-establish a new connection,
+ * the client should register a disconnect callback function.
+ *
+ * @see ctdb_client_set_disconnect_callback
+ *
+ * When a disconnect callback function is registered, client library will
+ * not call exit().  It is the responsibility of the client code to take
+ * appropriate action.
+ *
+ * @param[in] mem_ctx Talloc memory context
+ * @param[in] ev Tevent context
+ * @param[in] sockpath Path to ctdb daemon unix domain socket
+ * @param[out] result The new ctdb client context
+ * @return 0 on succcess, errno on failure
+ */
 int ctdb_client_init(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
-		     const char *sockpath, struct ctdb_client_context **ret);
-
+		     const char *sockpath,
+		     struct ctdb_client_context **result);
+
+/**
+ * @brief Register a callback in case of client disconnection
+ *
+ * This allows client code to know if the connection to ctdb daemon is lost.
+ * This is useful if the client wants to re-establish a new connection to ctdb
+ * daemon.
+ *
+ * @param[in] client Client connection context
+ * @param[in] func Callback function
+ * @param[in] private_data private data for callback function
+ */
 void ctdb_client_set_disconnect_callback(struct ctdb_client_context *client,
 					 ctdb_client_callback_func_t func,
 					 void *private_data);
 
+/**
+ * @brief Get the node number of the current node
+ *
+ * @param[in] client Client connection context
+ * return node number on success, CTDB_UNKNOWN_PNN on error
+ */
 uint32_t ctdb_client_pnn(struct ctdb_client_context *client);
 
+/**
+ * @brief Client event loop waiting for a flag
+ *
+ * This can used to wait for asynchronous comptuations to complete.
+ * When this function is called, it will run tevent event loop and wait
+ * till the done flag is set to true.  This function will block and will
+ * not return as long as the done flag is false.
+ *
+ * @param[in] ev Tevent context
+ * @param[in] done Boolean flag to indicate when to stop waiting
+ */
 void ctdb_client_wait(struct tevent_context *ev, bool *done);
 
+/**
+ * @brief Client event loop waiting for a flag with timeout
+ *
+ * This can be used to wait for asynchronous computations to complete.
+ * When this function is called, it will run tevent event loop and wait
+ * till the done flag is set to true or if the timeout occurs.
+ *
+ * This function will return when either
+ *  - done flag is set to true, or
+ *  - timeout has occurred.
+ *
+ * @param[in] ev Tevent context
+ * @param[in] done Boolean flag to indicate when to stop waiting
+ * @param[in] timeout How long to wait
+ * @return 0 on succes, ETIME on timeout, and errno on failure
+ */
 int ctdb_client_wait_timeout(struct tevent_context *ev, bool *done,
 			     struct timeval timeout);
 
+/**
+ * @brief Async computation start to wait till recovery is completed
+ *
+ * CTDB deamon does not perform many operations while in recovery (specially
+ * database operations).  This computation allows to wait till ctdb daemon has
+ * finished recovery.
+ *
+ * @param[in] mem_ctx Talloc memory context
+ * @param[in] ev Tevent context
+ * @param[in] client Client connection context
+ * @return new tevent request, or NULL on failure
+ */
 struct tevent_req *ctdb_recovery_wait_send(TALLOC_CTX *mem_ctx,
 					   struct tevent_context *ev,
 					   struct ctdb_client_context *client);
 
+/**
+ * @brief Async computation end to wait till recovery is completed
+ *
+ * @param[in] req Tevent request
+ * @param[out] perr errno in case of failure
+ * @return true on success, false on failure
+ */
 bool ctdb_recovery_wait_recv(struct tevent_req *req, int *perr);
 
+/**
+ * @brief Sync wrapper for ctdb_recovery_wait computation
+ *
+ * @param[in] ev Tevent context
+ * @param[in] client Client connection context
+ * @return true on success, false on failure
+ */
 bool ctdb_recovery_wait(struct tevent_context *ev,
 			struct ctdb_client_context *client);
 
-/* from client/client_call.c */
-
+/**
+ * @brief Async computation start to migrate a database record
+ *
+ * This sends a request to ctdb daemon to migrate a database record to
+ * the local node.  CTDB daemon will locate the data master for the record
+ * and will migrate record (and the data master) to the current node.
+ *
+ * @see ctdb_fetch_lock_send
+ *
+ * @param[in] mem_ctx Talloc memory context
+ * @param[in] ev  Tevent context
+ * @param[in] client Client connection context
+ * @param[in] request CTDB request data
+ * @return a new tevent req, or NULL on failure
+ */
 struct tevent_req *ctdb_client_call_send(TALLOC_CTX *mem_ctx,
 					 struct tevent_context *ev,
 					 struct ctdb_client_context *client,
 					 struct ctdb_req_call *request);
 
+/**
+ * @brief Async computation end to migrate a database record
+ *
+ * @param[in] req Tevent request
+ * @param[in] mem_ctx Talloc memory context
+ * @param[out] reply CTDB reply data
+ * @param[out] perr errno in case of failure
+ * @return true on success, false on failure
+ */
 bool ctdb_client_call_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
 			   struct ctdb_reply_call **reply, int *perr);
 
 
-/* from client/client_message.c */
-
+/**
+ * @brief Async computation start to send a message to remote client(s)
+ *
+ * This sends a message to ctdb clients on a remote node.  All the
+ * messages are associated with a specific SRVID.  All the clients on the
+ * remote node listening to that SRVID, will get the message.
+ *
+ * Clients can register and deregister for messages for a SRVID using
+ * ctdb_client_set_message_handler() and ctdb_client_remove_message_handler().
+ *
+ * @see ctdb_client_set_message_handler_send,
+ *      ctdb_client_remove_message_handler_send
+ *
+ * @param[in] mem_ctx Talloc memory context
+ * @param[in] ev Tevent context
+ * @param[in] client Client connection context
+ * @param[in] destnode Remote node id
+ * @param[in] message Message to send
+ * @return a new tevent req on success, NULL on failure
+ */
 struct tevent_req *ctdb_client_message_send(TALLOC_CTX *mem_ctx,
 					    struct tevent_context *ev,
 					    struct ctdb_client_context *client,
 					    uint32_t destnode,
 					    struct ctdb_req_message *message);
 
+/**
+ * @brief Async computation end to send a message to remote client(s)
+ *
+ * @param[in] req Tevent request
+ * @param[out] perr errno in case of failure
+ * @return true on success, false on failure
+ */
 bool ctdb_client_message_recv(struct tevent_req *req, int *perr);
 
+/**
+ * @brief Sync wrapper to send a message to client(s) on remote node
+ *
+ * @param[in] mem_ctx Talloc memory context
+ * @param[in] ev Tevent context
+ * @param[in] client Client connection context
+ * @param[in] destnode Node id
+ * @param[in] message Message to send
+ */
+int ctdb_client_message(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
+			struct ctdb_client_context *client,
+			uint32_t destnode, struct ctdb_req_message *message);
+
+/**
+ * @brief Async computation start to send a message to multiple nodes
+ *
+ * This sends a message to ctdb clients on multiple remote nodes.  All the
+ * messages are associated with a specific SRVID.  All the clients on remote
+ * nodes listening to that SRVID, will get the message.
+ *
+ * Clients can register and deregister for messages for a SRVID using
+ * ctdb_client_set_message_handler() and ctdb_client_remove_message_handler().
+ *
+ * @see ctdb_client_set_message_handler_send,
+ *      ctdb_client_remove_message_handler_send
+ *
+ * @param[in] mem_ctx Talloc memory context
+ * @param[in] ev Tevent context
+ * @param[in] client Client connection context
+ * @param[in] pnn_list List of node ids
+ * @param[in] count Number of node ids
+ * @param[in] message Message to send
+ * @return a new tevent req on success, NULL on failure
+ */
 struct tevent_req *ctdb_client_message_multi_send(
 				TALLOC_CTX *mem_ctx,
 				struct tevent_context *ev,
@@ -85,13 +292,34 @@ struct tevent_req *ctdb_client_message_multi_send(
 				uint32_t *pnn_list, int count,
 				struct ctdb_req_message *message);
 
+/**
+ * @brief Async computation end to send a message to multiple nodes
+ *
+ * @param[in] req Tevent request
+ * @param[out] perr errno in case of failure
+ * @param[in] mem_ctx Talloc memory context
+ * @param[out] perr_list The status from each node id
+ * @return true on success, false on failure
+ *
+ * If perr_list is not NULL, then the status (0 on success, errno on failure)
+ * of sending message to each of the node in the specified node list.  The
+ * perr_list is an array of the same size as of pnn_list.
+ */
 bool ctdb_client_message_multi_recv(struct tevent_req *req, int *perr,
 				    TALLOC_CTX *mem_ctx, int **perr_list);
 
-int ctdb_client_message(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
-			struct ctdb_client_context *client,
-			uint32_t destnode, struct ctdb_req_message *message);
-
+/**
+ * @brief Sync wrapper to send a message to multiple nodes
+ *
+ * @param[in] mem_ctx Talloc memory context
+ * @param[in] ev Tevent context
+ * @param[in] client Client connection context
+ * @param[in] pnn_list List of node ids
+ * @param[in] count Number of node ids
+ * @param[in] message Message to send
+ * @param[out] perr_list The status from each node id
+ * @return 0 on success, errno on failure
+ */
 int ctdb_client_message_multi(TALLOC_CTX *mem_ctx,
 			      struct tevent_context *ev,
 			      struct ctdb_client_context *client,
@@ -99,6 +327,20 @@ int ctdb_client_message_multi(TALLOC_CTX *mem_ctx,
 			      struct ctdb_req_message *message,
 			      int **perr_list);
 
+/**
+ * @brief Async computation start to receive messages for a SRVID
+ *
+ * This computation informs ctdb that the client is interested in all messages
+ * for a specific SRVID.
+ *
+ * @param[in] mem_ctx Talloc memory context
+ * @param[in] ev Tevent context
+ * @param[in] client Client connection context
+ * @param[in] srvid SRVID
+ * @param[in] handler Callback function to call when a message is received
+ * @param[in] private_data Private data for callback
+ * @return a new tevent req on success, NULL on failure
+ */
 struct tevent_req *ctdb_client_set_message_handler_send(
 					TALLOC_CTX *mem_ctx,
 					struct tevent_context *ev,
@@ -106,67 +348,85 @@ struct tevent_req *ctdb_client_set_message_handler_send(
 					uint64_t srvid,
 					srvid_handler_fn handler,
 					void *private_data);
+
+/**
+ * @brief Async computation end to receive messages for a SRVID
+ *
+ * @param[in] req Tevent request
+ * @param[out] perr errno in case of failure
+ * @return true on success, false on failure
+ */
 bool ctdb_client_set_message_handler_recv(struct tevent_req *req, int *perr);
 
+/**
+ * Sync wrapper to receive messages for a SRVID
+ *
+ * @param[in] ev Tevent context
+ * @param[in] client Client connection context
+ * @param[in] srvid SRVID
+ * @param[in] handler Callback function to call when a message is received
+ * @param[in] private_data Private data for callback
+ * @return 0 on success, errno on failure
+ */
+int ctdb_client_set_message_handler(struct tevent_context *ev,
+				    struct ctdb_client_context *client,
+				    uint64_t srvid, srvid_handler_fn handler,
+				    void *private_data);
+
+/**
+ * @brief Async computation start to stop receiving messages for a SRVID
+ *
+ * This computation informs ctdb that the client is no longer interested in
+ * messages for a specific SRVID.
+ *
+ * @param[in] mem_ctx Talloc memory context
+ * @param[in] ev Tevent context
+ * @param[in] client Client connection context
+ * @param[in] srvid SRVID
+ * @param[in] private_data Private data used to register callback
+ * @return a new tevent req on success, NULL on failure
+ */
 struct tevent_req *ctdb_client_remove_message_handler_send(
 					TALLOC_CTX *mem_ctx,
 					struct tevent_context *ev,
 					struct ctdb_client_context *client,
 					uint64_t srvid,
 					void *private_data);
+
+/**
+ * @brief Async computation end to stop receiving messages for a SRVID
+ *
+ * @param[in] req Tevent request
+ * @param[out] perr errno in case of failure
+ * @return true on success, false on failure
+ */
 bool ctdb_client_remove_message_handler_recv(struct tevent_req *req,
 					     int *perr);
 
-int ctdb_client_set_message_handler(struct tevent_context *ev,
-				    struct ctdb_client_context *client,
-				    uint64_t srvid, srvid_handler_fn handler,
-				    void *private_data);
-
+/**
+ * Sync wrapper to stop receiving messages for a SRVID
+ *
+ * @param[in] ev Tevent context
+ * @param[in] client Client connection context
+ * @param[in] srvid SRVID
+ * @param[in] private_data Private data used to register callback
+ * @return 0 on success, errno on failure
+ */
 int ctdb_client_remove_message_handler(struct tevent_context *ev,
 				       struct ctdb_client_context *client,
 				       uint64_t srvid, void *private_data);
 
-/* from client/client_message_sync.c */
-
-int ctdb_message_recd_update_ip(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
-				struct ctdb_client_context *client,
-				int destnode, struct ctdb_public_ip *pubip);
-
-int ctdb_message_mem_dump(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
-			  struct ctdb_client_context *client,
-			  int destnode, struct ctdb_srvid_message *msg);
-
-int ctdb_message_reload_nodes(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
-			      struct ctdb_client_context *client,
-			      int destnode);
-
-int ctdb_message_takeover_run(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
-			      struct ctdb_client_context *client,
-			      int destnode, struct ctdb_srvid_message *msg);
-
-int ctdb_message_rebalance_node(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
-				struct ctdb_client_context *client,
-				int destnode, uint32_t pnn);
-
-int ctdb_message_disable_takeover_runs(TALLOC_CTX *mem_ctx,
-				       struct tevent_context *ev,
-				       struct ctdb_client_context *client,
-				       int destnode,
-				       struct ctdb_disable_message *disable);
-
-int ctdb_message_disable_recoveries(TALLOC_CTX *mem_ctx,
-				    struct tevent_context *ev,
-				    struct ctdb_client_context *client,
-				    int destnode,
-				    struct ctdb_disable_message *disable);
-
-int ctdb_message_disable_ip_check(TALLOC_CTX *mem_ctx,
-				  struct tevent_context *ev,
-				  struct ctdb_client_context *client,
-				  int destnode, uint32_t timeout);
-
-/* from client/client_control.c */
-
+/**
+ * @brief Async computation start to send a control to ctdb daemon
+ *
+ * @param[in] mem_ctx Talloc memory context
+ * @param[in] ev Tevent context
+ * @param[in] client Client connection context
+ * @param[in] destnode Node id
+ * @param[in] timeout How long to wait
+ * @param[in] request Control request
+ * @return a new tevent req on success, NULL on failure
+ */
 struct tevent_req *ctdb_client_control_send(TALLOC_CTX *mem_ctx,
 					    struct tevent_context *ev,
 					    struct ctdb_client_context *client,
@@ -174,10 +434,51 @@ struct tevent_req *ctdb_client_control_send(TALLOC_CTX *mem_ctx,
 					    struct timeval timeout,
 					    struct ctdb_req_control *request);
 
+/**
+ * @brief Async computation end to send a control to ctdb daemon
+ *
+ * @param[in] req Tevent request
+ * @param[out] perr errno in case of failure
+ * @param[in] mem_ctx Talloc memory context
+ * @param[out] preply Control reply
+ * @return true on success, false on failure
+ */
 bool ctdb_client_control_recv(struct tevent_req *req, int *perr,
 			      TALLOC_CTX *mem_ctx,
 			      struct ctdb_reply_control **preply);
 
+/**
+ * @brief Sync wrapper to send a control to ctdb daemon
+ *
+ * @param[in] mem_ctx Talloc memory context
+ * @param[in] ev Tevent context
+ * @param[in] client Client connection context
+ * @param[in] destnode Node id
+ * @param[in] timeout How long to wait
+ * @param[in] request Control request
+ * @param[out] preply Control reply
+ * @return 0 on success, errno on failure
+ */
+int ctdb_client_control(TALLOC_CTX *mem_ctx,


-- 
Samba Shared Repository



More information about the samba-cvs mailing list