* The legacy style, an application wishing to receive events from ZooKeeper must
* first implement a function with this signature and pass a pointer to the function
* to \ref zookeeper_init. Next, the application sets a watch by calling one of
* the getter API that accept the watch integer flag (for example, \ref zoo_aexists,
* \ref zoo_get, etc).
*
* The watcher object style uses an instance of a "watcher object" which in
* the C world is represented by a pair: a pointer to a function implementing this
* signature and a pointer to watcher context -- handback user-specific data.
* When a watch is triggered this function will be called along with
* the watcher context. An application wishing to use this style must use
* the getter API functions with the "w" prefix in their names (for example, \ref
* zoo_awexists, \ref zoo_wget, etc).
*
* \param zh zookeeper handle
* \param type event type. This is one of the *_EVENT constants.
* \param state connection state. The state value will be one of the *_STATE constants.
* \param path znode path for which the watcher is triggered. NULL if the event
* type is ZOO_SESSION_EVENT
* \param watcherCtx watcher context.
*/
typedef void (*watcher_fn)(zhandle_t *zh, int type,
int state, const char *path,void *watcherCtx);
/**
* \brief typedef for setting the log callback. It's a function pointer which
* returns void and accepts a const char* as its only argument.
*
* \param message message to be passed to the callback function.
*/
typedef void (*log_callback_fn)(const char *message);
/**
* \brief create a handle to used communicate with zookeeper.
*
* This method creates a new handle and a zookeeper session that corresponds
* to that handle. Session establishment is asynchronous, meaning that the
* session should not be considered established until (and unless) an
* event of state ZOO_CONNECTED_STATE is received.
* \param host comma separated host:port pairs, each corresponding to a zk
* server. e.g. "127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002"
* \param fn the global watcher callback function. When notifications are
* triggered this function will be invoked.
* \param clientid the id of a previously established session that this
* client will be reconnecting to. Pass 0 if not reconnecting to a previous
* session. Clients can access the session id of an established, valid,
* connection by calling \ref zoo_client_id. If the session corresponding to
* the specified clientid has expired, or if the clientid is invalid for
* any reason, the returned zhandle_t will be invalid -- the zhandle_t
* state will indicate the reason for failure (typically
* ZOO_EXPIRED_SESSION_STATE).
* \param context the handback object that will be associated with this instance
* of zhandle_t. Application can access it (for example, in the watcher
* callback) using \ref zoo_get_context. The object is not used by zookeeper
* internally and can be null.
* \param flags reserved for future use. Should be set to zero.
* \return a pointer to the opaque zhandle structure. If it fails to create
* a new zhandle the function returns NULL and the errno variable
* indicates the reason.
*/
ZOOAPI zhandle_t *zookeeper_init(const char *host, watcher_fn fn,
int recv_timeout, const clientid_t *clientid, void *context, int flags);
#ifdef HAVE_OPENSSL_H
ZOOAPI zhandle_t *zookeeper_init_ssl(const char *host, const char *cert, watcher_fn fn,
int recv_timeout, const clientid_t *clientid, void *context, int flags);
#endif
ZOOAPI void close_zsock(zsock_t *zsock);
/**
* \brief create a handle to communicate with zookeeper.
*
* This function is identical to \ref zookeeper_init except it allows one
* to specify an additional callback to be used for all logging for that
* specific connection. For more details on the logging callback see
* \ref zoo_get_log_callback and \ref zoo_set_log_callback.
*
* This method creates a new handle and a zookeeper session that corresponds
* to that handle. Session establishment is asynchronous, meaning that the
* session should not be considered established until (and unless) an
* event of state ZOO_CONNECTED_STATE is received.
* \param host comma separated host:port pairs, each corresponding to a zk
* server. e.g. "127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002"
* \param fn the global watcher callback function. When notifications are
* triggered this function will be invoked.
* \param clientid the id of a previously established session that this
* client will be reconnecting to. Pass 0 if not reconnecting to a previous
* session. Clients can access the session id of an established, valid,
* connection by calling \ref zoo_client_id. If the session corresponding to
* the specified clientid has expired, or if the clientid is invalid for
* any reason, the returned zhandle_t will be invalid -- the zhandle_t
* state will indicate the reason for failure (typically
* ZOO_EXPIRED_SESSION_STATE).
* \param context the handback object that will be associated with this instance
* of zhandle_t. Application can access it (for example, in the watcher
* callback) using \ref zoo_get_context. The object is not used by zookeeper
* internally and can be null.
* \param flags reserved for future use. Should be set to zero.
* \param log_callback All log messages will be passed to this callback function.
* For more details see \ref zoo_get_log_callback and \ref zoo_set_log_callback.
* \return a pointer to the opaque zhandle structure. If it fails to create
* a new zhandle the function returns NULL and the errno variable
* indicates the reason.
*/
ZOOAPI zhandle_t *zookeeper_init2(const char *host, watcher_fn fn,
int recv_timeout, const clientid_t *clientid, void *context, int flags,
log_callback_fn log_callback);
#ifdef HAVE_CYRUS_SASL_H
/**
* \brief zoo_sasl_params structure.
*
* This structure holds the SASL parameters for the connection.
*
* Its \c service, \c host and \c callbacks fields are used with Cyrus
* SASL's \c sasl_client_new; its \c mechlist field with \c
* sasl_client_start. Please refer to these functions for precise
* semantics.
*
* Note while "string" parameters are copied into the ZooKeeper
* client, the callbacks array is simply referenced: its lifetime must
* therefore cover that of the handle.
*/
typedef struct zoo_sasl_params {
const char *service; /*!< The service name, usually "zookeeper" */
const char *host; /*!< The server name, e.g. "zk-sasl-md5" */
const char *mechlist; /*!< Mechanisms to try, e.g. "DIGEST-MD5" */
const sasl_callback_t *callbacks; /*!< List of callbacks */
} zoo_sasl_params_t;
/**
* \brief create a handle to communicate with zookeeper.
*
* This function is identical to \ref zookeeper_init2 except that it
* allows specifying optional SASL connection parameters. It is only
* available if the client library was configured to link against the
* Cyrus SASL library, and only visible when \c HAVE_CYRUS_SASL_H is defined.
*
* This method creates a new handle and a zookeeper session that corresponds
* to that handle. Session establishment is asynchronous, meaning that the
* session should not be considered established until (and unless) an
* event of state ZOO_CONNECTED_STATE is received.
* \param host comma separated host:port pairs, each corresponding to a zk
* server. e.g. "127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002"
* \param fn the global watcher callback function. When notifications are
* triggered this function will be invoked.
* \param clientid the id of a previously established session that this
* client will be reconnecting to. Pass 0 if not reconnecting to a previous
* session. Clients can access the session id of an established, valid,
* connection by calling \ref zoo_client_id. If the session corresponding to
* the specified clientid has expired, or if the clientid is invalid for
* any reason, the returned zhandle_t will be invalid -- the zhandle_t
* state will indicate the reason for failure (typically
* ZOO_EXPIRED_SESSION_STATE).
* \param context the handback object that will be associated with this instance
* of zhandle_t. Application can access it (for example, in the watcher
* callback) using \ref zoo_get_context. The object is not used by zookeeper
* internally and can be null.
* \param flags reserved for future use. Should be set to zero.
* \param log_callback All log messages will be passed to this callback function.
* For more details see \ref zoo_get_log_callback and \ref zoo_set_log_callback.
* \param sasl_params a pointer to a \ref zoo_sasl_params_t structure
* specifying SASL connection parameters, or NULL to skip SASL
* authentication
* \return a pointer to the opaque zhandle structure. If it fails to create
* a new zhandle the function returns NULL and the errno variable
* indicates the reason.
*/
ZOOAPI zhandle_t *zookeeper_init_sasl(const char *host, watcher_fn fn,
int recv_timeout, const clientid_t *clientid, void *context, int flags,
log_callback_fn log_callback, zoo_sasl_params_t *sasl_params);
/**
* \brief allocates and initializes a basic array of Cyrus SASL callbacks.
*
* This small helper function makes it easy to pass "static"
* parameters to Cyrus SASL's underlying callback-based API. Its use
* is not mandatory; you can still implement interactive dialogs by
* defining your own callbacks.
*
* \param user the "canned" response to \c SASL_CB_USER and \c SASL_CB_AUTHNAME,
* or NULL for none
* \param realm the "canned" response to \c SASL_CB_GETREALM, or NULL for none
* \param password_file the name of a file whose first line is read in
* response to \c SASL_CB_PASS, or NULL for none
* \return the freshly-malloc()ed callbacks array, or NULL if allocation
* failed. Deallocate with free(), but only after the corresponding
* ZooKeeper handle is closed.
*/
ZOOAPI sasl_callback_t *zoo_sasl_make_basic_callbacks(const char *user,
const char *realm, const char* password_file);
#endif /* HAVE_CYRUS_SASL_H */
/**
* \brief update the list of servers this client will connect to.
*
* This method allows a client to update the connection string by providing
* a new comma separated list of host:port pairs, each corresponding to a
* ZooKeeper server.
*
* This function invokes a probabilistic load-balancing algorithm which may cause
* the client to disconnect from its current host to achieve expected uniform
* connections per server in the new list. In case the current host to which the
* client is connected is not in the new list this call will always cause the
* connection to be dropped. Otherwise, the decision is based on whether the
* number of servers has increased or decreased and by how much.
*
* If the connection is dropped, the client moves to a special "reconfig" mode
* where he chooses a new server to connect to using the probabilistic algorithm.
* After finding a server or exhaustively trying all the servers in the new list,
* the client moves back to the normal mode of operation where it will pick an
* arbitrary server from the 'host' string.
*
* See {@link https://issues.apache.org/jira/browse/ZOOKEEPER-1355} for the
* protocol and its evaluation,
*
* \param host comma separated host:port pairs, each corresponding to a zk
* server. e.g. "127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002"
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZSYSTEMERROR -- a system (OS) error occured; it's worth checking errno to get details
*/
ZOOAPI int zoo_set_servers(zhandle_t *zh, const char *hosts);
/**
* \brief sets a minimum delay to observe between "routine" host name
* resolutions.
*
* The client performs regular resolutions of the list of servers
* passed to \ref zookeeper_init or set with \ref zoo_set_servers in
* order to detect changes at the DNS level.
*
* By default, it does so every time it checks for socket readiness.
* This results in low latency in the detection of changes, but can
* lead to heavy DNS traffic when the local cache is not effective.
*
* This method allows an application to influence the rate of polling.
* When delay_ms is set to a value greater than zero, the client skips
* most "routine" resolutions which would have happened in a window of
* that many milliseconds since the last successful one.
*
* Setting delay_ms to 0 disables this logic, reverting to the default
* behavior. Setting it to -1 disables network resolutions during
* normal operation (but not, e.g., on connection loss).
*
* \param delay_ms 0, -1, or the window size in milliseconds
* \return ZOK on success or ZBADARGUMENTS for invalid input parameters
*/
ZOOAPI int zoo_set_servers_resolution_delay(zhandle_t *zh, int delay_ms);
/**
* \brief cycle to the next server on the next connection attempt.
*
* Note: typically this method should NOT be used outside of testing.
*
* This method allows a client to cycle through the list of servers in it's
* connection pool to be used on the next connection attempt. This function does
* not actually trigger a connection or state change in any way. Its purpose is
* to allow testing changing servers on the fly and the probabilistic load
* balancing algorithm.
*/
ZOOAPI void zoo_cycle_next_server(zhandle_t *zh);
/**
* \brief get current host:port this client is connecting/connected to.
*
* Note: typically this method should NOT be used outside of testing.
*
* This method allows a client to get the current host:port that this client
* is either in the process of connecting to or is currently connected to. This
* is mainly used for testing purposes but might also come in handy as a general
* purpose tool to be used by other clients.
*/
ZOOAPI const char* zoo_get_current_server(zhandle_t* zh);
/**
* \brief close the zookeeper handle and free up any resources.
*
* After this call, the client session will no longer be valid. The function
* will flush any outstanding send requests before return. As a result it may
* block.
*
* This method should only be called only once on a zookeeper handle. Calling
* twice will cause undefined (and probably undesirable behavior). Calling any other
* zookeeper method after calling close is undefined behaviour and should be avoided.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \return a result code. Regardless of the error code returned, the zhandle
* will be destroyed and all resources freed.
*
* ZOK - success
* ZBADARGUMENTS - invalid input parameters
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
* ZOPERATIONTIMEOUT - failed to flush the buffers within the specified timeout.
* ZCONNECTIONLOSS - a network error occurred while attempting to send request to server
* ZSYSTEMERROR -- a system (OS) error occurred; it's worth checking errno to get details
*/
ZOOAPI int zookeeper_close(zhandle_t *zh);
/**
* \brief return the client session id, only valid if the connections
* is currently connected (ie. last watcher state is ZOO_CONNECTED_STATE)
*/
ZOOAPI const clientid_t *zoo_client_id(zhandle_t *zh);
/**
* \brief return the timeout for this session, only valid if the connections
* is currently connected (ie. last watcher state is ZOO_CONNECTED_STATE). This
* value may change after a server re-connect.
*/
ZOOAPI int zoo_recv_timeout(zhandle_t *zh);
/**
* \brief return the context for this handle.
*/
ZOOAPI const void *zoo_get_context(zhandle_t *zh);
/**
* \brief set the context for this handle.
*/
ZOOAPI void zoo_set_context(zhandle_t *zh, void *context);
/**
* \brief set a watcher function
* \return previous watcher function
*/
ZOOAPI watcher_fn zoo_set_watcher(zhandle_t *zh,watcher_fn newFn);
/**
* \brief returns the socket address for the current connection
* \return socket address of the connected host or NULL on failure, only valid if the
* connection is current connected
*/
ZOOAPI struct sockaddr* zookeeper_get_connected_host(zhandle_t *zh,
struct sockaddr *addr, socklen_t *addr_len);
#ifndef THREADED
/**
* \brief Returns the events that zookeeper is interested in.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param fd is the file descriptor of interest
* \param interest is an or of the ZOOKEEPER_WRITE and ZOOKEEPER_READ flags to
* indicate the I/O of interest on fd.
* \param tv a timeout value to be used with select/poll system call
* \return a result code.
* ZOK - success
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZCONNECTIONLOSS - a network error occurred while attempting to establish
* a connection to the server
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
* ZOPERATIONTIMEOUT - hasn't received anything from the server for 2/3 of the
* timeout value specified in zookeeper_init()
* ZSYSTEMERROR -- a system (OS) error occurred; it's worth checking errno to get details
*/
#ifdef WIN32
ZOOAPI int zookeeper_interest(zhandle_t *zh, SOCKET *fd, int *interest,
struct timeval *tv);
#else
ZOOAPI int zookeeper_interest(zhandle_t *zh, int *fd, int *interest,
struct timeval *tv);
#endif
/**
* \brief Notifies zookeeper that an event of interest has happened.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param events will be an OR of the ZOOKEEPER_WRITE and ZOOKEEPER_READ flags.
* \return a result code.
* ZOK - success
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZCONNECTIONLOSS - a network error occurred while attempting to send request to server
* ZSESSIONEXPIRED - connection attempt failed -- the session's expired
* ZAUTHFAILED - authentication request failed, e.i. invalid credentials
* ZRUNTIMEINCONSISTENCY - a server response came out of order
* ZSYSTEMERROR -- a system (OS) error occurred; it's worth checking errno to get details
* ZNOTHING -- not an error; simply indicates that there no more data from the server
* to be processed (when called with ZOOKEEPER_READ flag).
*/
ZOOAPI int zookeeper_process(zhandle_t *zh, int events);
#endif
/**
* \brief signature of a completion function for a call that returns void.
*
* This method will be invoked at the end of a asynchronous call and also as
* a result of connection loss or timeout.
* \param rc the error code of the call. Connection loss/timeout triggers
* the completion with one of the following error codes:
* ZCONNECTIONLOSS -- lost connection to the server
* ZOPERATIONTIMEOUT -- connection timed out
* Data related events trigger the completion with error codes listed the
* Exceptions section of the documentation of the function that initiated the
* call. (Zero indicates call was successful.)
* \param data the pointer that was passed by the caller when the function
* that this completion corresponds to was invoked. The programmer
* is responsible for any memory freeing associated with the data
* pointer.
*/
typedef void (*void_completion_t)(int rc, const void *data);
/**
* \brief signature of a completion function that returns a Stat structure.
*
* This method will be invoked at the end of a asynchronous call and also as
* a result of connection loss or timeout.
* \param rc the error code of the call. Connection loss/timeout triggers
* the completion with one of the following error codes:
* ZCONNECTIONLOSS -- lost connection to the server
* ZOPERATIONTIMEOUT -- connection timed out
* Data related events trigger the completion with error codes listed the
* Exceptions section of the documentation of the function that initiated the
* call. (Zero indicates call was successful.)
* \param stat a pointer to the stat information for the node involved in
* this function. If a non zero error code is returned, the content of
* stat is undefined. The programmer is NOT responsible for freeing stat.
* \param data the pointer that was passed by the caller when the function
* that this completion corresponds to was invoked. The programmer
* is responsible for any memory freeing associated with the data
* pointer.
*/
typedef void (*stat_completion_t)(int rc, const struct Stat *stat,
const void *data);
/**
* \brief signature of a completion function that returns data.
*
* This method will be invoked at the end of a asynchronous call and also as
* a result of connection loss or timeout.
* \param rc the error code of the call. Connection loss/timeout triggers
* the completion with one of the following error codes:
* ZCONNECTIONLOSS -- lost connection to the server
* ZOPERATIONTIMEOUT -- connection timed out
* Data related events trigger the completion with error codes listed the
* Exceptions section of the documentation of the function that initiated the
* call. (Zero indicates call was successful.)
* \param value the value of the information returned by the asynchronous call.
* If a non zero error code is returned, the content of value is undefined.
* The programmer is NOT responsible for freeing value.
* \param value_len the number of bytes in value.
* \param stat a pointer to the stat information for the node involved in
* this function. If a non zero error code is returned, the content of
* stat is undefined. The programmer is NOT responsible for freeing stat.
* \param data the pointer that was passed by the caller when the function
* that this completion corresponds to was invoked. The programmer
* is responsible for any memory freeing associated with the data
* pointer.
*/
typedef void (*data_completion_t)(int rc, const char *value, int value_len,
const struct Stat *stat, const void *data);
/**
* \brief signature of a completion function that returns a list of strings.
*
* This method will be invoked at the end of a asynchronous call and also as
* a result of connection loss or timeout.
* \param rc the error code of the call. Connection loss/timeout triggers
* the completion with one of the following error codes:
* ZCONNECTIONLOSS -- lost connection to the server
* ZOPERATIONTIMEOUT -- connection timed out
* Data related events trigger the completion with error codes listed the
* Exceptions section of the documentation of the function that initiated the
* call. (Zero indicates call was successful.)
* \param strings a pointer to the structure containng the list of strings of the
* names of the children of a node. If a non zero error code is returned,
* the content of strings is undefined. The programmer is NOT responsible
* for freeing strings.
* \param data the pointer that was passed by the caller when the function
* that this completion corresponds to was invoked. The programmer
* is responsible for any memory freeing associated with the data
* pointer.
*/
typedef void (*strings_completion_t)(int rc,
const struct String_vector *strings, const void *data);
/**
* \brief signature of a completion function that returns a string and stat.
* .
*
* This method will be invoked at the end of a asynchronous call and also as
* a result of connection loss or timeout.
* \param rc the error code of the call. Connection loss/timeout triggers
* the completion with one of the following error codes:
* ZCONNECTIONLOSS -- lost connection to the server
* ZOPERATIONTIMEOUT -- connection timed out
* Data related events trigger the completion with error codes listed the
* Exceptions section of the documentation of the function that initiated the
* call. (Zero indicates call was successful.)
* \param value the value of the string returned.
* \param stat a pointer to the stat information for the node involved in
* this function. If a non zero error code is returned, the content of
* stat is undefined. The programmer is NOT responsible for freeing stat.
* \param data the pointer that was passed by the caller when the function
* that this completion corresponds to was invoked. The programmer
* is responsible for any memory freeing associated with the data
* pointer.
*/
typedef void (*string_stat_completion_t)(int rc,
const char *string, const struct Stat *stat, const void *data);
/**
* \brief signature of a completion function that returns a list of strings and stat.
* .
*
* This method will be invoked at the end of a asynchronous call and also as
* a result of connection loss or timeout.
* \param rc the error code of the call. Connection loss/timeout triggers
* the completion with one of the following error codes:
* ZCONNECTIONLOSS -- lost connection to the server
* ZOPERATIONTIMEOUT -- connection timed out
* Data related events trigger the completion with error codes listed the
* Exceptions section of the documentation of the function that initiated the
* call. (Zero indicates call was successful.)
* \param strings a pointer to the structure containng the list of strings of the
* names of the children of a node. If a non zero error code is returned,
* the content of strings is undefined. The programmer is NOT responsible
* for freeing strings.
* \param stat a pointer to the stat information for the node involved in
* this function. If a non zero error code is returned, the content of
* stat is undefined. The programmer is NOT responsible for freeing stat.
* \param data the pointer that was passed by the caller when the function
* that this completion corresponds to was invoked. The programmer
* is responsible for any memory freeing associated with the data
* pointer.
*/
typedef void (*strings_stat_completion_t)(int rc,
const struct String_vector *strings, const struct Stat *stat,
const void *data);
/**
* \brief signature of a completion function that returns a list of strings.
*
* This method will be invoked at the end of a asynchronous call and also as
* a result of connection loss or timeout.
* \param rc the error code of the call. Connection loss/timeout triggers
* the completion with one of the following error codes:
* ZCONNECTIONLOSS -- lost connection to the server
* ZOPERATIONTIMEOUT -- connection timed out
* Data related events trigger the completion with error codes listed the
* Exceptions section of the documentation of the function that initiated the
* call. (Zero indicates call was successful.)
* \param value the value of the string returned.
* \param data the pointer that was passed by the caller when the function
* that this completion corresponds to was invoked. The programmer
* is responsible for any memory freeing associated with the data
* pointer.
*/
typedef void
(*string_completion_t)(int rc, const char *value, const void *data);
/**
* \brief signature of a completion function that returns an ACL.
*
* This method will be invoked at the end of a asynchronous call and also as
* a result of connection loss or timeout.
* \param rc the error code of the call. Connection loss/timeout triggers
* the completion with one of the following error codes:
* ZCONNECTIONLOSS -- lost connection to the server
* ZOPERATIONTIMEOUT -- connection timed out
* Data related events trigger the completion with error codes listed the
* Exceptions section of the documentation of the function that initiated the
* call. (Zero indicates call was successful.)
* \param acl a pointer to the structure containng the ACL of a node. If a non
* zero error code is returned, the content of strings is undefined. The
* programmer is NOT responsible for freeing acl.
* \param stat a pointer to the stat information for the node involved in
* this function. If a non zero error code is returned, the content of
* stat is undefined. The programmer is NOT responsible for freeing stat.
* \param data the pointer that was passed by the caller when the function
* that this completion corresponds to was invoked. The programmer
* is responsible for any memory freeing associated with the data
* pointer.
*/
typedef void (*acl_completion_t)(int rc, struct ACL_vector *acl,
struct Stat *stat, const void *data);
/**
* \brief get the state of the zookeeper connection.
*
* The return value will be one of the \ref State Consts.
*/
ZOOAPI int zoo_state(zhandle_t *zh);
/**
* \brief create a node.
*
* This method will create a node in ZooKeeper. A node can only be created if
* it does not already exist. The Create Mode affects the creation of nodes.
* If ZOO_EPHEMERAL mode is chosen, the node will automatically get removed if the
* client session goes away. If ZOO_CONTAINER flag is set, a container node will be
* created. For ZOO_*_SEQUENTIAL modes, a unique monotonically increasing
* sequence number is appended to the path name. The sequence number is always fixed
* length of 10 digits, 0 padded.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path The name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param value The data to be stored in the node.
* \param valuelen The number of bytes in data.
* \param acl The initial ACL of the node. The ACL must not be null or empty.
* \param mode this parameter should be one of the Create Modes.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the parent node does not exist.
* ZNODEEXISTS the node already exists
* ZNOAUTH the client does not have permission.
* ZNOCHILDRENFOREPHEMERALS cannot create children of ephemeral nodes.
* \param data The data that will be passed to the completion routine when the
* function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_acreate(zhandle_t *zh, const char *path, const char *value,
int valuelen, const struct ACL_vector *acl, int mode,
string_completion_t completion, const void *data);
/**
* \brief create a node.
*
* This method will create a node in ZooKeeper. A node can only be created if
* it does not already exist. The Create Mode affects the creation of nodes.
* If ZOO_EPHEMERAL mode is chosen, the node will automatically get removed if the
* client session goes away. If ZOO_CONTAINER flag is set, a container node will be
* created. For ZOO_*_SEQUENTIAL modes, a unique monotonically increasing
* sequence number is appended to the path name. The sequence number is always fixed
* length of 10 digits, 0 padded. When ZOO_*_WITH_TTL is selected, a ttl node will be
* created.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path The name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param value The data to be stored in the node.
* \param valuelen The number of bytes in data.
* \param acl The initial ACL of the node. The ACL must not be null or empty.
* \param mode this parameter should be one of the Create Modes.
* \param ttl the value of ttl in milliseconds. It must be positive for ZOO_*_WITH_TTL
* Create modes, otherwise it must be -1.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the parent node does not exist.
* ZNODEEXISTS the node already exists
* ZNOAUTH the client does not have permission.
* ZNOCHILDRENFOREPHEMERALS cannot create children of ephemeral nodes.
* \param data The data that will be passed to the completion routine when the
* function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_acreate_ttl(zhandle_t *zh, const char *path, const char *value,
int valuelen, const struct ACL_vector *acl, int mode, int64_t ttl,
string_completion_t completion, const void *data);
/**
* \brief create a node asynchronously and returns stat details.
*
* This method will create a node in ZooKeeper. A node can only be created if
* it does not already exist. The Create Mode affects the creation of nodes.
* If ZOO_EPHEMERAL mode is chosen, the node will automatically get removed if the
* client session goes away. If ZOO_CONTAINER flag is set, a container node will be
* created. For ZOO_*_SEQUENTIAL modes, a unique monotonically increasing
* sequence number is appended to the path name. The sequence number is always fixed
* length of 10 digits, 0 padded.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path The name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param value The data to be stored in the node.
* \param valuelen The number of bytes in data.
* \param acl The initial ACL of the node. The ACL must not be null or empty.
* \param mode this parameter should be one of the Create Modes.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the parent node does not exist.
* ZNODEEXISTS the node already exists
* ZNOAUTH the client does not have permission.
* ZNOCHILDRENFOREPHEMERALS cannot create children of ephemeral nodes.
* \param data The data that will be passed to the completion routine when the
* function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_acreate2(zhandle_t *zh, const char *path, const char *value,
int valuelen, const struct ACL_vector *acl, int mode,
string_stat_completion_t completion, const void *data);
/**
* \brief create a node asynchronously and returns stat details.
*
* This method will create a node in ZooKeeper. A node can only be created if
* it does not already exist. The Create Mode affects the creation of nodes.
* If ZOO_EPHEMERAL mode is chosen, the node will automatically get removed if the
* client session goes away. If ZOO_CONTAINER flag is set, a container node will be
* created. For ZOO_*_SEQUENTIAL modes, a unique monotonically increasing
* sequence number is appended to the path name. The sequence number is always fixed
* length of 10 digits, 0 padded. When ZOO_*_WITH_TTL is selected, a ttl node will be
* created.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path The name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param value The data to be stored in the node.
* \param valuelen The number of bytes in data.
* \param acl The initial ACL of the node. The ACL must not be null or empty.
* \param mode this parameter should be one of the Create Modes.
* \param ttl the value of ttl in milliseconds. It must be positive for ZOO_*_WITH_TTL
* Create modes, otherwise it must be -1.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the parent node does not exist.
* ZNODEEXISTS the node already exists
* ZNOAUTH the client does not have permission.
* ZNOCHILDRENFOREPHEMERALS cannot create children of ephemeral nodes.
* \param data The data that will be passed to the completion routine when the
* function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_acreate2_ttl(zhandle_t *zh, const char *path, const char *value,
int valuelen, const struct ACL_vector *acl, int mode, int64_t ttl,
string_stat_completion_t completion, const void *data);
/**
* \brief delete a node in zookeeper.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param version the expected version of the node. The function will fail if the
* actual version of the node does not match the expected version.
* If -1 is used the version check will not take place.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* ZBADVERSION expected version does not match actual version.
* ZNOTEMPTY children are present; node cannot be deleted.
* \param data the data that will be passed to the completion routine when
* the function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_adelete(zhandle_t *zh, const char *path, int version,
void_completion_t completion, const void *data);
/**
* \brief checks the existence of a node in zookeeper.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param watch if nonzero, a watch will be set at the server to notify the
* client if the node changes. The watch will be set even if the node does not
* exist. This allows clients to watch for nodes to appear.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* \param data the data that will be passed to the completion routine when the
* function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_aexists(zhandle_t *zh, const char *path, int watch,
stat_completion_t completion, const void *data);
/**
* \brief checks the existence of a node in zookeeper.
*
* This function is similar to \ref zoo_axists except it allows one specify
* a watcher object - a function pointer and associated context. The function
* will be called once the watch has fired. The associated context data will be
* passed to the function as the watcher context parameter.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param watcher if non-null a watch will set on the specified znode on the server.
* The watch will be set even if the node does not exist. This allows clients
* to watch for nodes to appear.
* \param watcherCtx user specific data, will be passed to the watcher callback.
* Unlike the global context set by \ref zookeeper_init, this watcher context
* is associated with the given instance of the watcher only.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* \param data the data that will be passed to the completion routine when the
* function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_awexists(zhandle_t *zh, const char *path,
watcher_fn watcher, void* watcherCtx,
stat_completion_t completion, const void *data);
/**
* \brief gets the data associated with a node.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param watch if nonzero, a watch will be set at the server to notify
* the client if the node changes.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* \param data the data that will be passed to the completion routine when
* the function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either in ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_aget(zhandle_t *zh, const char *path, int watch,
data_completion_t completion, const void *data);
/**
* \brief gets the data associated with a node.
*
* This function is similar to \ref zoo_aget except it allows one specify
* a watcher object rather than a boolean watch flag.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param watcher if non-null, a watch will be set at the server to notify
* the client if the node changes.
* \param watcherCtx user specific data, will be passed to the watcher callback.
* Unlike the global context set by \ref zookeeper_init, this watcher context
* is associated with the given instance of the watcher only.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* \param data the data that will be passed to the completion routine when
* the function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either in ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_awget(zhandle_t *zh, const char *path,
watcher_fn watcher, void* watcherCtx,
data_completion_t completion, const void *data);
/**
* \brief gets the last committed configuration of the ZooKeeper cluster as it is known to
* the server to which the client is connected.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param watch if nonzero, a watch will be set at the server to notify
* the client if the configuration changes.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the configuration node (/zookeeper/config) does not exist.
* ZNOAUTH the client does not have permission to access the configuration node.
* \param data the configuration data that will be passed to the completion routine when
* the function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either in ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_agetconfig(zhandle_t *zh, int watch,
data_completion_t completion, const void *data);
/**
* \brief gets the last committed configuration of the ZooKeeper cluster as it is known to
* the server to which the client is connected.
*
* This function is similar to \ref zoo_agetconfig except it allows one specify
* a watcher object rather than a boolean watch flag.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param watcher if non-null, a watch will be set at the server to notify
* the client if the node changes.
* \param watcherCtx user specific data, will be passed to the watcher callback.
* Unlike the global context set by \ref zookeeper_init, this watcher context
* is associated with the given instance of the watcher only.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the configuration node (/zookeeper/config) does not exist.
* ZNOAUTH the client does not have permission to access the configuration node.
* \param data the configuration data that will be passed to the completion routine when
* the function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either in ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_awgetconfig(zhandle_t *zh, watcher_fn watcher, void* watcherCtx,
data_completion_t completion, const void *data);
/**
* \brief asynchronous reconfiguration interface - allows changing ZK cluster
* ensemble membership and roles of ensemble peers.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param joining - comma separated list of servers to be added to the ensemble.
* Each has a configuration line for a server to be added (as would appear in a
* configuration file), only for maj. quorums. NULL for non-incremental reconfiguration.
* \param leaving - comma separated list of server IDs to be removed from the ensemble.
* Each has an id of a server to be removed, only for maj. quorums. NULL for
* non-incremental reconfiguration.
* \param members - comma separated list of new membership (e.g., contents of a
* membership configuration file) - for use only with a non-incremental
* reconfiguration. NULL for incremental reconfiguration.
* \param version - version of config from which we want to reconfigure - if
* current config is different reconfiguration will fail. Should be -1 to disable
* this option.
* \param completion - the routine to invoke when the request completes. The
* completion will be triggered with one of the following codes passed in as the
* rc argument:
* ZOK operation completed successfully
* \param data the configuration data that will be passed to the completion routine
* when the function completes.
* \return return value of the function call.
* ZOK operation completed successfully
* ZBADARGUMENTS - invalid input parameters (one case when this is returned is
* when the new config has less than 2 servers)
* ZINVALIDSTATE - zhandle state is either in ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
* ZNEWCONFIGNOQUORUM - no quorum of new config is connected and up-to-date with
* the leader of last committed config - try invoking reconfiguration after new servers are connected and synced
* ZRECONFIGINPROGRESS - another reconfig is currently in progress
*/
ZOOAPI int zoo_areconfig(zhandle_t *zh, const char *joining, const char *leaving,
const char *members, int64_t version, data_completion_t dc, const void *data);
/**
* \brief sets the data associated with a node.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param buffer the buffer holding data to be written to the node.
* \param buflen the number of bytes from buffer to write.
* \param version the expected version of the node. The function will fail if
* the actual version of the node does not match the expected version. If -1 is
* used the version check will not take place. * completion: If null,
* the function will execute synchronously. Otherwise, the function will return
* immediately and invoke the completion routine when the request completes.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* ZBADVERSION expected version does not match actual version.
* \param data the data that will be passed to the completion routine when
* the function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_aset(zhandle_t *zh, const char *path, const char *buffer, int buflen,
int version, stat_completion_t completion, const void *data);
/**
* \brief lists the children of a node.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param watch if nonzero, a watch will be set at the server to notify
* the client if the node changes.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* \param data the data that will be passed to the completion routine when
* the function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_aget_children(zhandle_t *zh, const char *path, int watch,
strings_completion_t completion, const void *data);
/**
* \brief lists the children of a node.
*
* This function is similar to \ref zoo_aget_children except it allows one specify
* a watcher object rather than a boolean watch flag.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param watcher if non-null, a watch will be set at the server to notify
* the client if the node changes.
* \param watcherCtx user specific data, will be passed to the watcher callback.
* Unlike the global context set by \ref zookeeper_init, this watcher context
* is associated with the given instance of the watcher only.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* \param data the data that will be passed to the completion routine when
* the function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_awget_children(zhandle_t *zh, const char *path,
watcher_fn watcher, void* watcherCtx,
strings_completion_t completion, const void *data);
/**
* \brief lists the children of a node, and get the parent stat.
*
* This function is new in version 3.3.0
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param watch if nonzero, a watch will be set at the server to notify
* the client if the node changes.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* \param data the data that will be passed to the completion routine when
* the function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_aget_children2(zhandle_t *zh, const char *path, int watch,
strings_stat_completion_t completion, const void *data);
/**
* \brief lists the children of a node, and get the parent stat.
*
* This function is similar to \ref zoo_aget_children2 except it allows one specify
* a watcher object rather than a boolean watch flag.
*
* This function is new in version 3.3.0
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param watcher if non-null, a watch will be set at the server to notify
* the client if the node changes.
* \param watcherCtx user specific data, will be passed to the watcher callback.
* Unlike the global context set by \ref zookeeper_init, this watcher context
* is associated with the given instance of the watcher only.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* \param data the data that will be passed to the completion routine when
* the function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_awget_children2(zhandle_t *zh, const char *path,
watcher_fn watcher, void* watcherCtx,
strings_stat_completion_t completion, const void *data);
/**
* \brief Flush leader channel.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* \param data the data that will be passed to the completion routine when
* the function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_async(zhandle_t *zh, const char *path,
string_completion_t completion, const void *data);
/**
* \brief gets the acl associated with a node.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* \param data the data that will be passed to the completion routine when
* the function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_aget_acl(zhandle_t *zh, const char *path, acl_completion_t completion,
const void *data);
/**
* \brief sets the acl associated with a node.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param buffer the buffer holding the acls to be written to the node.
* \param buflen the number of bytes from buffer to write.
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with one of the following codes passed in as the rc argument:
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* ZINVALIDACL invalid ACL specified
* ZBADVERSION expected version does not match actual version.
* \param data the data that will be passed to the completion routine when
* the function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_aset_acl(zhandle_t *zh, const char *path, int version,
struct ACL_vector *acl, void_completion_t, const void *data);
/**
* \brief atomically commits multiple zookeeper operations.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param count the number of operations
* \param ops an array of operations to commit
* \param results an array to hold the results of the operations
* \param completion the routine to invoke when the request completes. The completion
* will be triggered with any of the error codes that can that can be returned by the
* ops supported by a multi op (see \ref zoo_acreate, \ref zoo_adelete, \ref zoo_aset).
* \param data the data that will be passed to the completion routine when
* the function completes.
* \return the return code for the function call. This can be any of the
* values that can be returned by the ops supported by a multi op (see
* \ref zoo_acreate, \ref zoo_adelete, \ref zoo_aset).
*/
ZOOAPI int zoo_amulti(zhandle_t *zh, int count, const zoo_op_t *ops,
zoo_op_result_t *results, void_completion_t, const void *data);
/**
* \brief return an error string.
*
* \param return code
* \return string corresponding to the return code
*/
ZOOAPI const char* zerror(int c);
/**
* \brief specify application credentials.
*
* The application calls this function to specify its credentials for purposes
* of authentication. The server will use the security provider specified by
* the scheme parameter to authenticate the client connection. If the
* authentication request has failed:
* - the server connection is dropped
* - the watcher is called with the ZOO_AUTH_FAILED_STATE value as the state
* parameter.
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param scheme the id of authentication scheme. Natively supported:
* "digest" password-based authentication
* \param cert application credentials. The actual value depends on the scheme.
* \param certLen the length of the data parameter
* \param completion the routine to invoke when the request completes. One of
* the following result codes may be passed into the completion callback:
* ZOK operation completed successfully
* ZAUTHFAILED authentication failed
* \param data the data that will be passed to the completion routine when the
* function completes.
* \return ZOK on success or one of the following errcodes on failure:
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
* ZSYSTEMERROR - a system error occurred
*/
ZOOAPI int zoo_add_auth(zhandle_t *zh,const char* scheme,const char* cert,
int certLen, void_completion_t completion, const void *data);
/**
* \brief checks if the current zookeeper connection state can't be recovered.
*
* The application must close the zhandle and try to reconnect.
*
* \param zh the zookeeper handle (see \ref zookeeper_init)
* \return ZINVALIDSTATE if connection is unrecoverable
*/
ZOOAPI int is_unrecoverable(zhandle_t *zh);
/**
* \brief sets the debugging level for the library
*/
ZOOAPI void zoo_set_debug_level(ZooLogLevel logLevel);
/**
* \brief sets the stream to be used by the library for logging
*
* The zookeeper library uses stderr as its default log stream. Application
* must make sure the stream is writable. Passing in NULL resets the stream
* to its default value (stderr).
*/
ZOOAPI void zoo_set_log_stream(FILE* logStream);
/**
* \brief gets the callback to be used by this connection for logging.
*
* This is a per-connection logging mechanism that will take priority over
* the library-wide default log stream. That is, zookeeper library will first
* try to use a per-connection callback if available and if not, will fallback
* to using the logging stream. Passing in NULL resets the callback and will
* cause it to then fallback to using the logging stream as described in \ref
* zoo_set_log_stream.
*/
ZOOAPI log_callback_fn zoo_get_log_callback(const zhandle_t *zh);
/**
* \brief sets the callback to be used by the library for logging
*
* Setting this callback has the effect of overriding the default log stream.
* Zookeeper will first try to use a per-connection callback if available
* and if not, will fallback to using the logging stream. Passing in NULL
* resets the callback and will cause it to then fallback to using the logging
* stream as described in \ref zoo_set_log_stream.
*
* Note: The provided callback will be invoked by multiple threads and therefore
* it needs to be thread-safe.
*/
ZOOAPI void zoo_set_log_callback(zhandle_t *zh, log_callback_fn callback);
/**
* \brief enable/disable quorum endpoint order randomization
*
* Note: typically this method should NOT be used outside of testing.
*
* If passed a non-zero value, will make the client connect to quorum peers
* in the order as specified in the zookeeper_init() call.
* A zero value causes zookeeper_init() to permute the peer endpoints
* which is good for more even client connection distribution among the
* quorum peers.
*/
ZOOAPI void zoo_deterministic_conn_order(int yesOrNo);
/**
* Type of watches: used to select which type of watches should be removed
*/
typedef enum {
ZWATCHTYPE_CHILD = 1,
ZWATCHTYPE_DATA = 2,
ZWATCHTYPE_ANY = 3
} ZooWatcherType;
/**
* \brief removes the watches for the given path and watcher type.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the path for which watches will be removed
* \param wtype the watcher type to be removed
* \param watcher the watcher to be removed, if null all watches for that
* path (and watcher type) will be removed
* \param watcherCtx the contex associated with the watcher to be removed
* \param local whether the watches will be removed locally even if there is
* no server connection
* \return the return code for the function call.
* ZOK - operation completed successfully
* ZNOWATCHER - the watcher couldn't be found.
* ZINVALIDSTATE - if !local, zhandle state is either ZOO_SESSION_EXPIRED_STATE
* or ZOO_AUTH_FAILED_STATE
* ZBADARGUMENTS - invalid input parameters
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
* ZSYSTEMERROR - a system error occured
*/
ZOOAPI int zoo_aremove_watches(zhandle_t *zh, const char *path,
ZooWatcherType wtype, watcher_fn watcher, void *watcherCtx, int local,
void_completion_t *completion, const void *data);
/**
* \brief removes all the watches for the given path and watcher type.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the path for which watches will be removed
* \param wtype the watcher type to be removed
* \param local whether the watches will be removed locally even if there is
* no server connection
* \return the return code for the function call.
* ZOK - operation completed successfully
* ZNOWATCHER - the watcher couldn't be found.
* ZINVALIDSTATE - if !local, zhandle state is either ZOO_SESSION_EXPIRED_STATE
* or ZOO_AUTH_FAILED_STATE
* ZBADARGUMENTS - invalid input parameters
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
* ZSYSTEMERROR - a system error occured
*/
ZOOAPI int zoo_remove_all_watches(zhandle_t *zh, const char *path,
ZooWatcherType wtype, int local);
/**
* \brief removes all the watches for the given path and watcher type.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the path for which watches will be removed
* \param wtype the watcher type to be removed
* \param local whether the watches will be removed locally even if there is
* no server connection
* \return the return code for the function call.
* ZOK - operation completed successfully
* ZNOWATCHER - the watcher couldn't be found.
* ZINVALIDSTATE - if !local, zhandle state is either ZOO_SESSION_EXPIRED_STATE
* or ZOO_AUTH_FAILED_STATE
* ZBADARGUMENTS - invalid input parameters
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
* ZSYSTEMERROR - a system error occured
*/
ZOOAPI int zoo_aremove_all_watches(zhandle_t *zh, const char *path,
ZooWatcherType wtype, int local, void_completion_t *completion,
const void *data);
#ifdef THREADED
/**
* \brief create a node synchronously.
*
* This method will create a node in ZooKeeper. A node can only be created if
* it does not already exist. The Create Mode affects the creation of nodes.
* If ZOO_EPHEMERAL mode is chosen, the node will automatically get removed if the
* client session goes away. If ZOO_CONTAINER flag is set, a container node will be
* created. For ZOO_*_SEQUENTIAL modes, a unique monotonically increasing
* sequence number is appended to the path name. The sequence number is always fixed
* length of 10 digits, 0 padded.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path The name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param value The data to be stored in the node.
* \param valuelen The number of bytes in data. To set the data to be NULL use
* value as NULL and valuelen as -1.
* \param acl The initial ACL of the node. The ACL must not be null or empty.
* \param mode this parameter should be one of the Create Modes.
* \param path_buffer Buffer which will be filled with the path of the
* new node (this might be different than the supplied path
* because of the ZOO_SEQUENCE flag). The path string will always be
* null-terminated. This parameter may be NULL if path_buffer_len = 0.
* \param path_buffer_len Size of path buffer; if the path of the new
* node (including space for the null terminator) exceeds the buffer size,
* the path string will be truncated to fit. The actual path of the
* new node in the server will not be affected by the truncation.
* The path string will always be null-terminated.
* \return one of the following codes are returned:
* ZOK operation completed successfully
* ZNONODE the parent node does not exist.
* ZNODEEXISTS the node already exists
* ZNOAUTH the client does not have permission.
* ZNOCHILDRENFOREPHEMERALS cannot create children of ephemeral nodes.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_create(zhandle_t *zh, const char *path, const char *value,
int valuelen, const struct ACL_vector *acl, int mode,
char *path_buffer, int path_buffer_len);
/**
* \brief create a node synchronously.
*
* This method will create a node in ZooKeeper. A node can only be created if
* it does not already exist. The Create Mode affects the creation of nodes.
* If ZOO_EPHEMERAL mode is chosen, the node will automatically get removed if the
* client session goes away. If ZOO_CONTAINER flag is set, a container node will be
* created. For ZOO_*_SEQUENTIAL modes, a unique monotonically increasing
* sequence number is appended to the path name. The sequence number is always fixed
* length of 10 digits, 0 padded. When ZOO_*_WITH_TTL is selected, a ttl node will be
* created.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path The name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param value The data to be stored in the node.
* \param valuelen The number of bytes in data. To set the data to be NULL use
* value as NULL and valuelen as -1.
* \param acl The initial ACL of the node. The ACL must not be null or empty.
* \param mode this parameter should be one of the Create Modes.
* \param ttl the value of ttl in milliseconds. It must be positive for ZOO_*_WITH_TTL
* Create modes, otherwise it must be -1.
* \param path_buffer Buffer which will be filled with the path of the
* new node (this might be different than the supplied path
* because of the ZOO_SEQUENCE flag). The path string will always be
* null-terminated. This parameter may be NULL if path_buffer_len = 0.
* \param path_buffer_len Size of path buffer; if the path of the new
* node (including space for the null terminator) exceeds the buffer size,
* the path string will be truncated to fit. The actual path of the
* new node in the server will not be affected by the truncation.
* The path string will always be null-terminated.
* \return one of the following codes are returned:
* ZOK operation completed successfully
* ZNONODE the parent node does not exist.
* ZNODEEXISTS the node already exists
* ZNOAUTH the client does not have permission.
* ZNOCHILDRENFOREPHEMERALS cannot create children of ephemeral nodes.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_create_ttl(zhandle_t *zh, const char *path, const char *value,
int valuelen, const struct ACL_vector *acl, int mode, int64_t ttl,
char *path_buffer, int path_buffer_len);
/**
* \brief create a node synchronously and collect stat details.
*
* This method will create a node in ZooKeeper. A node can only be created if
* it does not already exist. The Create Mode affects the creation of nodes.
* If ZOO_EPHEMERAL mode is chosen, the node will automatically get removed if the
* client session goes away. If ZOO_CONTAINER flag is set, a container node will be
* created. For ZOO_*_SEQUENTIAL modes, a unique monotonically increasing
* sequence number is appended to the path name. The sequence number is always fixed
* length of 10 digits, 0 padded.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path The name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param value The data to be stored in the node.
* \param valuelen The number of bytes in data. To set the data to be NULL use
* value as NULL and valuelen as -1.
* \param acl The initial ACL of the node. The ACL must not be null or empty.
* \param mode this parameter should be one of the Create Modes.
* \param path_buffer Buffer which will be filled with the path of the
* new node (this might be different than the supplied path
* because of the ZOO_SEQUENCE flag). The path string will always be
* null-terminated. This parameter may be NULL if path_buffer_len = 0.
* \param path_buffer_len Size of path buffer; if the path of the new
* node (including space for the null terminator) exceeds the buffer size,
* the path string will be truncated to fit. The actual path of the
* new node in the server will not be affected by the truncation.
* The path string will always be null-terminated.
* \param stat The Stat struct to store Stat info into.
* \return one of the following codes are returned:
* ZOK operation completed successfully
* ZNONODE the parent node does not exist.
* ZNODEEXISTS the node already exists
* ZNOAUTH the client does not have permission.
* ZNOCHILDRENFOREPHEMERALS cannot create children of ephemeral nodes.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_create2(zhandle_t *zh, const char *path, const char *value,
int valuelen, const struct ACL_vector *acl, int mode,
char *path_buffer, int path_buffer_len, struct Stat *stat);
/**
* \brief create a node synchronously and collect stat details.
*
* This method will create a node in ZooKeeper. A node can only be created if
* it does not already exist. The Create Mode affects the creation of nodes.
* If ZOO_EPHEMERAL mode is chosen, the node will automatically get removed if the
* client session goes away. If ZOO_CONTAINER flag is set, a container node will be
* created. For ZOO_*_SEQUENTIAL modes, a unique monotonically increasing
* sequence number is appended to the path name. The sequence number is always fixed
* length of 10 digits, 0 padded. When ZOO_*_WITH_TTL is selected, a ttl node will be
* created.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path The name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param value The data to be stored in the node.
* \param valuelen The number of bytes in data. To set the data to be NULL use
* value as NULL and valuelen as -1.
* \param acl The initial ACL of the node. The ACL must not be null or empty.
* \param mode this parameter should be one of the Create Modes.
* \param ttl the value of ttl in milliseconds. It must be positive for ZOO_*_WITH_TTL
* Create modes, otherwise it must be -1.
* \param path_buffer Buffer which will be filled with the path of the
* new node (this might be different than the supplied path
* because of the ZOO_SEQUENCE flag). The path string will always be
* null-terminated. This parameter may be NULL if path_buffer_len = 0.
* \param path_buffer_len Size of path buffer; if the path of the new
* node (including space for the null terminator) exceeds the buffer size,
* the path string will be truncated to fit. The actual path of the
* new node in the server will not be affected by the truncation.
* The path string will always be null-terminated.
* \param stat The Stat struct to store Stat info into.
* \return one of the following codes are returned:
* ZOK operation completed successfully
* ZNONODE the parent node does not exist.
* ZNODEEXISTS the node already exists
* ZNOAUTH the client does not have permission.
* ZNOCHILDRENFOREPHEMERALS cannot create children of ephemeral nodes.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_create2_ttl(zhandle_t *zh, const char *path, const char *value,
int valuelen, const struct ACL_vector *acl, int mode, int64_t ttl,
char *path_buffer, int path_buffer_len, struct Stat *stat);
/**
* \brief delete a node in zookeeper synchronously.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param version the expected version of the node. The function will fail if the
* actual version of the node does not match the expected version.
* If -1 is used the version check will not take place.
* \return one of the following values is returned.
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* ZBADVERSION expected version does not match actual version.
* ZNOTEMPTY children are present; node cannot be deleted.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_delete(zhandle_t *zh, const char *path, int version);
/**
* \brief checks the existence of a node in zookeeper synchronously.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param watch if nonzero, a watch will be set at the server to notify the
* client if the node changes. The watch will be set even if the node does not
* exist. This allows clients to watch for nodes to appear.
* \param the return stat value of the node.
* \return return code of the function call.
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_exists(zhandle_t *zh, const char *path, int watch, struct Stat *stat);
/**
* \brief checks the existence of a node in zookeeper synchronously.
*
* This function is similar to \ref zoo_exists except it allows one specify
* a watcher object rather than a boolean watch flag.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param watcher if non-null a watch will set on the specified znode on the server.
* The watch will be set even if the node does not exist. This allows clients
* to watch for nodes to appear.
* \param watcherCtx user specific data, will be passed to the watcher callback.
* Unlike the global context set by \ref zookeeper_init, this watcher context
* is associated with the given instance of the watcher only.
* \param the return stat value of the node.
* \return return code of the function call.
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_wexists(zhandle_t *zh, const char *path,
watcher_fn watcher, void* watcherCtx, struct Stat *stat);
/**
* \brief gets the data associated with a node synchronously.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param watch if nonzero, a watch will be set at the server to notify
* the client if the node changes.
* \param buffer the buffer holding the node data returned by the server
* \param buffer_len is the size of the buffer pointed to by the buffer parameter.
* It'll be set to the actual data length upon return. If the data is NULL, length is -1.
* \param stat if not NULL, will hold the value of stat for the path on return.
* \return return value of the function call.
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either in ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_get(zhandle_t *zh, const char *path, int watch, char *buffer,
int* buffer_len, struct Stat *stat);
/**
* \brief gets the data associated with a node synchronously.
*
* This function is similar to \ref zoo_get except it allows one specify
* a watcher object rather than a boolean watch flag.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param watcher if non-null, a watch will be set at the server to notify
* the client if the node changes.
* \param watcherCtx user specific data, will be passed to the watcher callback.
* Unlike the global context set by \ref zookeeper_init, this watcher context
* is associated with the given instance of the watcher only.
* \param buffer the buffer holding the node data returned by the server
* \param buffer_len is the size of the buffer pointed to by the buffer parameter.
* It'll be set to the actual data length upon return. If the data is NULL, length is -1.
* \param stat if not NULL, will hold the value of stat for the path on return.
* \return return value of the function call.
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either in ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_wget(zhandle_t *zh, const char *path,
watcher_fn watcher, void* watcherCtx,
char *buffer, int* buffer_len, struct Stat *stat);
/**
* \brief gets the last committed configuration of the ZooKeeper cluster as it is known to
* the server to which the client is connected, synchronously.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param watch if nonzero, a watch will be set at the server to notify
* the client if the node changes.
* \param buffer the buffer holding the configuration data returned by the server
* \param buffer_len is the size of the buffer pointed to by the buffer parameter.
* It'll be set to the actual data length upon return. If the data is NULL, length is -1.
* \param stat if not NULL, will hold the value of stat for the path on return.
* \return return value of the function call.
* ZOK operation completed successfully
* ZNONODE the configuration node (/zookeeper/config) does not exist.
* ZNOAUTH the client does not have permission to access the configuration node.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either in ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_getconfig(zhandle_t *zh, int watch, char *buffer,
int* buffer_len, struct Stat *stat);
/**
* \brief gets the last committed configuration of the ZooKeeper cluster as it is known to
* the server to which the client is connected, synchronously.
*
* This function is similar to \ref zoo_getconfig except it allows one specify
* a watcher object rather than a boolean watch flag.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param watcher if non-null, a watch will be set at the server to notify
* the client if the node changes.
* \param watcherCtx user specific data, will be passed to the watcher callback.
* Unlike the global context set by \ref zookeeper_init, this watcher context
* is associated with the given instance of the watcher only.
* \param buffer the buffer holding the configuration data returned by the server
* \param buffer_len is the size of the buffer pointed to by the buffer parameter.
* It'll be set to the actual data length upon return. If the data is NULL, length is -1.
* \param stat if not NULL, will hold the value of stat for the path on return.
* \return return value of the function call.
* ZOK operation completed successfully
* ZNONODE the configuration node (/zookeeper/config) does not exist.
* ZNOAUTH the client does not have permission to access the configuration node.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either in ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_wgetconfig(zhandle_t *zh, watcher_fn watcher, void* watcherCtx,
char *buffer, int* buffer_len, struct Stat *stat);
/**
* \brief synchronous reconfiguration interface - allows changing ZK cluster
* ensemble membership and roles of ensemble peers.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param joining - comma separated list of servers to be added to the ensemble.
* Each has a configuration line for a server to be added (as would appear in a
* configuration file), only for maj. quorums. NULL for non-incremental reconfiguration.
* \param leaving - comma separated list of server IDs to be removed from the ensemble.
* Each has an id of a server to be removed, only for maj. quorums. NULL for
* non-incremental reconfiguration.
* \param members - comma separated list of new membership (e.g., contents of a
* membership configuration file) - for use only with a non-incremental
* reconfiguration. NULL for incremental reconfiguration.
* \param version - zxid of config from which we want to reconfigure - if
* current config is different reconfiguration will fail. Should be -1 to
* disable this option.
* \param buffer the buffer holding the configuration data returned by the server
* \param buffer_len is the size of the buffer pointed to by the buffer parameter.
* It'll be set to the actual data length upon return. If the data is NULL, length
* is -1.
* \param stat if not NULL, will hold the value of stat for the path on return.
* \return return value of the function call.
* ZOK operation completed successfully
* ZBADARGUMENTS - invalid input parameters (one case when this is returned is
* when the new config has less than 2 servers)
* ZINVALIDSTATE - zhandle state is either in ZOO_SESSION_EXPIRED_STATE or
* ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
* ZNEWCONFIGNOQUORUM - no quorum of new config is connected and up-to-date with
* the leader of last committed config - try invoking reconfiguration after new
* servers are connected and synced
* ZRECONFIGINPROGRESS - another reconfig is currently in progress
*/
ZOOAPI int zoo_reconfig(zhandle_t *zh, const char *joining, const char *leaving,
const char *members, int64_t version, char *buffer, int* buffer_len,
struct Stat *stat);
/**
* \brief sets the data associated with a node. See zoo_set2 function if
* you require access to the stat information associated with the znode.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param buffer the buffer holding data to be written to the node.
* \param buflen the number of bytes from buffer to write. To set NULL as data
* use buffer as NULL and buflen as -1.
* \param version the expected version of the node. The function will fail if
* the actual version of the node does not match the expected version. If -1 is
* used the version check will not take place.
* \return the return code for the function call.
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* ZBADVERSION expected version does not match actual version.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_set(zhandle_t *zh, const char *path, const char *buffer,
int buflen, int version);
/**
* \brief sets the data associated with a node. This function is the same
* as zoo_set except that it also provides access to stat information
* associated with the znode.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param buffer the buffer holding data to be written to the node.
* \param buflen the number of bytes from buffer to write. To set NULL as data
* use buffer as NULL and buflen as -1.
* \param version the expected version of the node. The function will fail if
* the actual version of the node does not match the expected version. If -1 is
* used the version check will not take place.
* \param stat if not NULL, will hold the value of stat for the path on return.
* \return the return code for the function call.
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* ZBADVERSION expected version does not match actual version.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_set2(zhandle_t *zh, const char *path, const char *buffer,
int buflen, int version, struct Stat *stat);
/**
* \brief lists the children of a node synchronously.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param watch if nonzero, a watch will be set at the server to notify
* the client if the node changes.
* \param strings return value of children paths.
* \return the return code of the function.
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_get_children(zhandle_t *zh, const char *path, int watch,
struct String_vector *strings);
/**
* \brief lists the children of a node synchronously.
*
* This function is similar to \ref zoo_get_children except it allows one specify
* a watcher object rather than a boolean watch flag.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param watcher if non-null, a watch will be set at the server to notify
* the client if the node changes.
* \param watcherCtx user specific data, will be passed to the watcher callback.
* Unlike the global context set by \ref zookeeper_init, this watcher context
* is associated with the given instance of the watcher only.
* \param strings return value of children paths.
* \return the return code of the function.
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_wget_children(zhandle_t *zh, const char *path,
watcher_fn watcher, void* watcherCtx,
struct String_vector *strings);
/**
* \brief lists the children of a node and get its stat synchronously.
*
* This function is new in version 3.3.0
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param watch if nonzero, a watch will be set at the server to notify
* the client if the node changes.
* \param strings return value of children paths.
* \param stat return value of node stat.
* \return the return code of the function.
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_get_children2(zhandle_t *zh, const char *path, int watch,
struct String_vector *strings, struct Stat *stat);
/**
* \brief lists the children of a node and get its stat synchronously.
*
* This function is similar to \ref zoo_get_children except it allows one specify
* a watcher object rather than a boolean watch flag.
*
* This function is new in version 3.3.0
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param watcher if non-null, a watch will be set at the server to notify
* the client if the node changes.
* \param watcherCtx user specific data, will be passed to the watcher callback.
* Unlike the global context set by \ref zookeeper_init, this watcher context
* is associated with the given instance of the watcher only.
* \param strings return value of children paths.
* \param stat return value of node stat.
* \return the return code of the function.
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_wget_children2(zhandle_t *zh, const char *path,
watcher_fn watcher, void* watcherCtx,
struct String_vector *strings, struct Stat *stat);
/**
* \brief gets the acl associated with a node synchronously.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param acl the return value of acls on the path.
* \param stat returns the stat of the path specified.
* \return the return code for the function call.
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_get_acl(zhandle_t *zh, const char *path, struct ACL_vector *acl,
struct Stat *stat);
/**
* \brief sets the acl associated with a node synchronously.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the name of the node. Expressed as a file name with slashes
* separating ancestors of the node.
* \param version the expected version of the path.
* \param acl the acl to be set on the path.
* \return the return code for the function call.
* ZOK operation completed successfully
* ZNONODE the node does not exist.
* ZNOAUTH the client does not have permission.
* ZINVALIDACL invalid ACL specified
* ZBADVERSION expected version does not match actual version.
* ZBADARGUMENTS - invalid input parameters
* ZINVALIDSTATE - zhandle state is either ZOO_SESSION_EXPIRED_STATE or ZOO_AUTH_FAILED_STATE
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
ZOOAPI int zoo_set_acl(zhandle_t *zh, const char *path, int version,
const struct ACL_vector *acl);
/**
* \brief atomically commits multiple zookeeper operations synchronously.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param count the number of operations
* \param ops an array of operations to commit
* \param results an array to hold the results of the operations
* \return the return code for the function call. This can be any of the
* values that can be returned by the ops supported by a multi op (see
* \ref zoo_acreate, \ref zoo_adelete, \ref zoo_aset).
*/
ZOOAPI int zoo_multi(zhandle_t *zh, int count, const zoo_op_t *ops, zoo_op_result_t *results);
/**
* \brief removes the watches for the given path and watcher type.
*
* \param zh the zookeeper handle obtained by a call to \ref zookeeper_init
* \param path the path for which watches will be removed
* \param wtype the watcher type to be removed
* \param watcher the watcher to be removed, if null all watches for that
* path (and watcher type) will be removed
* \param watcherCtx the contex associated with the watcher to be removed
* \param local whether the watches will be removed locally even if there is
* no server connection
* \return the return code for the function call.
* ZOK - operation completed successfully
* ZNOWATCHER - the watcher couldn't be found.
* ZINVALIDSTATE - if !local, zhandle state is either ZOO_SESSION_EXPIRED_STATE
* or ZOO_AUTH_FAILED_STATE
* ZBADARGUMENTS - invalid input parameters
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
* ZSYSTEMERROR - a system error occured
*/
ZOOAPI int zoo_remove_watches(zhandle_t *zh, const char *path,
ZooWatcherType wtype, watcher_fn watcher, void *watcherCtx, int local);
#endif
#ifdef __cplusplus
}
#endif
#endif /*ZOOKEEPER_H_*/
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/include/zookeeper_log.h 0100644 0000000 0000000 00000003371 14704315305 030733 0 ustar 00root root 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ZK_LOG_H_
#define ZK_LOG_H_
#include
#ifdef __cplusplus
extern "C" {
#endif
extern ZOOAPI ZooLogLevel logLevel;
#define LOGCALLBACK(_zh) zoo_get_log_callback(_zh)
#define LOGSTREAM NULL
#define LOG_ERROR(_cb, ...) if(logLevel>=ZOO_LOG_LEVEL_ERROR) \
log_message(_cb, ZOO_LOG_LEVEL_ERROR, __LINE__, __func__, __VA_ARGS__)
#define LOG_WARN(_cb, ...) if(logLevel>=ZOO_LOG_LEVEL_WARN) \
log_message(_cb, ZOO_LOG_LEVEL_WARN, __LINE__, __func__, __VA_ARGS__)
#define LOG_INFO(_cb, ...) if(logLevel>=ZOO_LOG_LEVEL_INFO) \
log_message(_cb, ZOO_LOG_LEVEL_INFO, __LINE__, __func__, __VA_ARGS__)
#define LOG_DEBUG(_cb, ...) if(logLevel==ZOO_LOG_LEVEL_DEBUG) \
log_message(_cb, ZOO_LOG_LEVEL_DEBUG, __LINE__, __func__, __VA_ARGS__)
ZOOAPI void log_message(log_callback_fn callback, ZooLogLevel curLevel,
int line, const char* funcName, const char* format, ...);
FILE* zoo_get_log_stream();
#ifdef __cplusplus
}
#endif
#endif /*ZK_LOG_H_*/
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/include/zookeeper_version.h 0100644 0000000 0000000 00000001746 14704315305 031643 0 ustar 00root root 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ZOOKEEPER_VERSION_H_
#define ZOOKEEPER_VERSION_H_
#ifdef __cplusplus
extern "C" {
#endif
#define ZOO_VERSION "3.9.3"
#ifdef __cplusplus
}
#endif
#endif /* ZOOKEEPER_VERSION_H_ */
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/pom.xml 0100755 0000000 0000000 00000017034 14704315305 025614 0 ustar 00root root 0000000 0000000
4.0.0
org.apache.zookeeper
zookeeper-client
3.9.3
zookeeper-client-c
pom
Apache ZooKeeper - Client - C
ZooKeeper c client
org.codehaus.mojo
exec-maven-plugin
autoreconf
process-sources
exec
${project.basedir}
autoreconf
aclocal -I /usr/share/aclocal
-if
configure
process-sources
exec
${project.build.directory}/c
${project.basedir}/configure
${project.basedir}/../..
ANT
--with-openssl=${c-client-openssl}
--with-sasl=${c-client-sasl}
--prefix=${project.build.directory}/c
${c-test-coverage-arg}
org.apache.maven.plugins
maven-antrun-plugin
generate-sources
generate-sources
run
build-c-client
compile
run
replace-cclient-files-during-release
none
run
-SNAPSHOT
-SNAPSHOT
-SNAPSHOT
c-test-coverage
--enable-gcov
cppunit
!skipCppUnit
org.apache.maven.plugins
maven-antrun-plugin
test-cppunit
test
${skipTests}
run
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/addrvec.c 0100644 0000000 0000000 00000013462 14704315305 026640 0 ustar 00root root 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include
#include
#include
#include
#ifdef WIN32
#define random rand /* replace POSIX random with Windows rand */
#include /* must always be included before ws2tcpip.h */
#include /* for sockaddr_storage */
#include "winport.h"
#endif
#include "addrvec.h"
#define ADDRVEC_DEFAULT_GROW_AMOUNT 16
void addrvec_init(addrvec_t *avec)
{
assert(avec);
avec->next = 0;
avec->count = 0;
avec->capacity = 0;
avec->data = NULL;
}
void addrvec_free(addrvec_t *avec)
{
if (avec == NULL)
{
return;
}
avec->next = 0;
avec->count = 0;
avec->capacity = 0;
if (avec->data) {
free(avec->data);
avec->data = NULL;
}
}
int addrvec_alloc(addrvec_t *avec)
{
addrvec_init(avec);
return addrvec_grow_default(avec);
}
int addrvec_alloc_capacity(addrvec_t* avec, uint32_t capacity)
{
addrvec_init(avec);
return addrvec_grow(avec, capacity);
}
int addrvec_grow(addrvec_t *avec, uint32_t grow_amount)
{
unsigned int old_capacity = 0;
struct sockaddr_storage *old_data = NULL;
assert(avec);
if (grow_amount == 0)
{
return 0;
}
// Save off old data and capacity in case there is a realloc failure
old_capacity = avec->capacity;
old_data = avec->data;
avec->capacity += grow_amount;
avec->data = realloc(avec->data, sizeof(*avec->data) * avec->capacity);
if (avec->data == NULL)
{
avec->capacity = old_capacity;
avec->data = old_data;
errno = ENOMEM;
return 1;
}
return 0;
}
int addrvec_grow_default(addrvec_t *avec)
{
return addrvec_grow(avec, ADDRVEC_DEFAULT_GROW_AMOUNT);
}
static int addrvec_grow_if_full(addrvec_t *avec)
{
assert(avec);
if (avec->count == avec->capacity)
{
int rc = addrvec_grow_default(avec);
if (rc != 0)
{
return rc;
}
}
return 0;
}
int addrvec_contains(const addrvec_t *avec, const struct sockaddr_storage *addr)
{
uint32_t i = 0;
if (!avec || !addr)
{
return 0;
}
for (i = 0; i < avec->count; i++)
{
if (avec->data[i].ss_family != addr->ss_family)
continue;
switch (addr->ss_family) {
case AF_INET:
if (memcmp(&((struct sockaddr_in*)&avec->data[i])->sin_addr,
&((struct sockaddr_in*)addr)->sin_addr,
sizeof(struct in_addr)) == 0)
return 1;
break;
#ifdef AF_INET6
case AF_INET6:
if (memcmp(&((struct sockaddr_in6*)&avec->data[i])->sin6_addr,
&((struct sockaddr_in6*)addr)->sin6_addr,
sizeof(struct in6_addr)) == 0)
return 1;
break;
#endif
default:
break;
}
}
return 0;
}
int addrvec_append(addrvec_t *avec, const struct sockaddr_storage *addr)
{
int rc = 0;
assert(avec);
assert(addr);
rc = addrvec_grow_if_full(avec);
if (rc != 0)
{
return rc;
}
// Copy addrinfo into address list
memcpy(avec->data + avec->count, addr, sizeof(*addr));
++avec->count;
return 0;
}
int addrvec_append_addrinfo(addrvec_t *avec, const struct addrinfo *addrinfo)
{
int rc = 0;
assert(avec);
assert(addrinfo);
rc = addrvec_grow_if_full(avec);
if (rc != 0)
{
return rc;
}
// Copy addrinfo into address list
memcpy(avec->data + avec->count, addrinfo->ai_addr, addrinfo->ai_addrlen);
++avec->count;
return 0;
}
void addrvec_shuffle(addrvec_t *avec)
{
int i = 0;
for (i = avec->count - 1; i > 0; --i) {
long int j = random()%(i+1);
if (i != j) {
struct sockaddr_storage t = avec->data[i];
avec->data[i] = avec->data[j];
avec->data[j] = t;
}
}
}
int addrvec_hasnext(const addrvec_t *avec)
{
return avec->count > 0 && (avec->next < avec->count);
}
int addrvec_atend(const addrvec_t *avec)
{
return avec->count > 0 && avec->next >= avec->count;
}
void addrvec_next(addrvec_t *avec, struct sockaddr_storage *next)
{
int index;
// If we're at the end of the list, then reset index to start
if (addrvec_atend(avec)) {
avec->next = 0;
}
if (!addrvec_hasnext(avec)) {
if (next) {
memset(next, 0, sizeof(*next));
}
return;
}
index = avec->next++;
if (next) {
*next = avec->data[index];
}
}
void addrvec_peek(addrvec_t *avec, struct sockaddr_storage *next)
{
int index = avec->next;
if (avec->count == 0) {
memset(next, 0, sizeof(*next));
return;
}
if (addrvec_atend(avec)) {
index = 0;
}
*next = avec->data[index];
}
int addrvec_eq(const addrvec_t *a1, const addrvec_t *a2)
{
uint32_t i = 0;
if (a1->count != a2->count)
{
return 0;
}
for (i = 0; i < a1->count; ++i)
{
if (!addrvec_contains(a2, &a1->data[i]))
return 0;
}
return 1;
}
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/addrvec.h 0100644 0000000 0000000 00000010356 14704315305 026644 0 ustar 00root root 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ADDRVEC_H_
#define ADDRVEC_H_
#ifndef WIN32
#include
#include
#include
#include
#else
#include
#include
#endif
/**
* This structure represents a list of addresses. It stores the count of the
* number of elements that have been inserted via calls to addrvec_append and
* addrvec_append_addrinfo. It also has a capacity field for the number of
* addresses it has the ability to hold without needing to be enlarged.
*/
typedef struct _addrvec {
unsigned int next; // next index to use
unsigned int count; // number of addresses in this list
unsigned int capacity; // number of address this list can hold
struct sockaddr_storage *data; // list of addresses
} addrvec_t;
/**
* Initialize an addrvec by clearing out all its state.
*/
void addrvec_init(addrvec_t *avec);
/**
* Free any memory used internally by an addrvec
*/
void addrvec_free(addrvec_t *avec);
/**
* Allocate an addrvec with a default capacity (16)
*/
int addrvec_alloc(addrvec_t *avec);
/**
* Allocates an addrvec with a specified capacity
*/
int addrvec_alloc_capacity(addrvec_t *avec, uint32_t capacity);
/**
* Grow an addrvec by the specified amount. This will increase the capacity
* of the vector and not the contents.
*/
int addrvec_grow(addrvec_t *avec, uint32_t grow_amount);
/**
* Similar to addrvec_grow but uses a default growth amount of 16.
*/
int addrvec_grow_default(addrvec_t *avec);
/**
* Check if an addrvec contains the specificed sockaddr_storage value.
* \returns 1 if it contains the value and 0 otherwise.
*/
int addrvec_contains(const addrvec_t *avec, const struct sockaddr_storage *addr);
/**
* Append the given sockaddr_storage pointer into the addrvec. The contents of
* the given 'addr' are copied into the addrvec via memcpy.
*/
int addrvec_append(addrvec_t *avec, const struct sockaddr_storage *addr);
/**
* Append the given addrinfo pointer into the addrvec. The contents of the given
* 'addrinfo' are copied into the addrvec via memcpy.
*/
int addrvec_append_addrinfo(addrvec_t *avec, const struct addrinfo *addrinfo);
/**
* Shuffle the addrvec so that it's internal list of addresses are randomized.
* Uses random() and assumes it has been properly seeded.
*/
void addrvec_shuffle(addrvec_t *avec);
/**
* Determine if the addrvec has a next element (e.g. it's safe to call addrvec_next)
*
* \returns 1 if it has a next element and 0 otherwise
*/
int addrvec_hasnext(const addrvec_t *avec);
/**
* Determine if the addrvec is at the end or not. Specifically, this means a
* subsequent call to addrvec_next will loop around to the start again.
*/
int addrvec_atend(const addrvec_t *avec);
/**
* Get the next entry from the addrvec and update the associated index.
*
* If next is NULL, the index will still be updated.
*
* If the current index points at (or after) the last element in the vector then
* it will loop back around and start at the beginning of the list.
*/
void addrvec_next(addrvec_t *avec, struct sockaddr_storage *next);
/**
* Retrieves the next entry from the addrvec but doesn't update the index.
*/
void addrvec_peek(addrvec_t *avec, struct sockaddr_storage *next);
/**
* Compare two addrvecs for equality.
*
* \returns 1 if the contents of the two lists are identical and and 0 otherwise.
*/
int addrvec_eq(const addrvec_t *a1, const addrvec_t *a2);
#endif // ADDRVEC_H
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/cli.c 0100644 0000000 0000000 00000111146 14704315305 025775 0 ustar 00root root 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* cli.c is a example/sample C client shell for ZooKeeper. It contains
* basic shell functionality which exercises some of the features of
* the ZooKeeper C client API. It is not a full fledged client and is
* not meant for production usage - see the Java client shell for a
* fully featured shell.
*/
#include
#include
#include
#include
#include
#ifndef WIN32
#include
#include
#include
#include
#else
#include "winport.h"
//#include <-- can't include, conflicting definitions of close()
int read(int _FileHandle, void * _DstBuf, unsigned int _MaxCharCount);
int write(int _Filehandle, const void * _Buf, unsigned int _MaxCharCount);
#define ctime_r(tctime, buffer) ctime_s (buffer, 40, tctime)
#include "win_getopt.h" // VisualStudio doesn't contain 'getopt'
#endif
#include
#include
#include
#ifdef YCA
#include
#endif
#define _LL_CAST_ (long long)
static zhandle_t *zh;
static clientid_t myid;
static const char *clientIdFile = 0;
struct timeval startTime;
static const char *cmd;
static const char *cert;
static int batchMode=0;
static int to_send=0;
static int sent=0;
static int recvd=0;
static int shutdownThisThing=0;
static __attribute__ ((unused)) void
printProfileInfo(struct timeval start, struct timeval end, int thres,
const char* msg)
{
int delay=(end.tv_sec*1000+end.tv_usec/1000)-
(start.tv_sec*1000+start.tv_usec/1000);
if(delay>thres)
fprintf(stderr,"%s: execution time=%dms\n",msg,delay);
}
static const char* state2String(int state){
if (state == 0)
return "CLOSED_STATE";
if (state == ZOO_CONNECTING_STATE)
return "CONNECTING_STATE";
if (state == ZOO_ASSOCIATING_STATE)
return "ASSOCIATING_STATE";
if (state == ZOO_CONNECTED_STATE)
return "CONNECTED_STATE";
if (state == ZOO_READONLY_STATE)
return "READONLY_STATE";
if (state == ZOO_EXPIRED_SESSION_STATE)
return "EXPIRED_SESSION_STATE";
if (state == ZOO_AUTH_FAILED_STATE)
return "AUTH_FAILED_STATE";
return "INVALID_STATE";
}
static const char* type2String(int state){
if (state == ZOO_CREATED_EVENT)
return "CREATED_EVENT";
if (state == ZOO_DELETED_EVENT)
return "DELETED_EVENT";
if (state == ZOO_CHANGED_EVENT)
return "CHANGED_EVENT";
if (state == ZOO_CHILD_EVENT)
return "CHILD_EVENT";
if (state == ZOO_SESSION_EVENT)
return "SESSION_EVENT";
if (state == ZOO_NOTWATCHING_EVENT)
return "NOTWATCHING_EVENT";
return "UNKNOWN_EVENT_TYPE";
}
void watcher(zhandle_t *zzh, int type, int state, const char *path,
void* context)
{
/* Be careful using zh here rather than zzh - as this may be mt code
* the client lib may call the watcher before zookeeper_init returns */
fprintf(stderr, "Watcher %s state = %s", type2String(type), state2String(state));
if (path && strlen(path) > 0) {
fprintf(stderr, " for path %s", path);
}
fprintf(stderr, "\n");
if (type == ZOO_SESSION_EVENT) {
if (state == ZOO_CONNECTED_STATE) {
const clientid_t *id = zoo_client_id(zzh);
if (myid.client_id == 0 || myid.client_id != id->client_id) {
myid = *id;
fprintf(stderr, "Got a new session id: 0x%llx\n",
_LL_CAST_ myid.client_id);
if (clientIdFile) {
FILE *fh = fopen(clientIdFile, "w");
if (!fh) {
perror(clientIdFile);
} else {
int rc = fwrite(&myid, sizeof(myid), 1, fh);
if (rc != sizeof(myid)) {
perror("writing client id");
}
fclose(fh);
}
}
}
} else if (state == ZOO_AUTH_FAILED_STATE) {
fprintf(stderr, "Authentication failure. Shutting down...\n");
zookeeper_close(zzh);
shutdownThisThing=1;
zh=0;
} else if (state == ZOO_EXPIRED_SESSION_STATE) {
fprintf(stderr, "Session expired. Shutting down...\n");
zookeeper_close(zzh);
shutdownThisThing=1;
zh=0;
}
}
}
void dumpStat(const struct Stat *stat) {
char tctimes[40];
char tmtimes[40];
time_t tctime;
time_t tmtime;
if (!stat) {
fprintf(stderr,"null\n");
return;
}
tctime = stat->ctime/1000;
tmtime = stat->mtime/1000;
ctime_r(&tmtime, tmtimes);
ctime_r(&tctime, tctimes);
fprintf(stderr, "\tctime = %s\tczxid=%llx\n"
"\tmtime=%s\tmzxid=%llx\n"
"\tversion=%x\taversion=%x\n"
"\tephemeralOwner = %llx\n",
tctimes, _LL_CAST_ stat->czxid, tmtimes,
_LL_CAST_ stat->mzxid,
(unsigned int)stat->version, (unsigned int)stat->aversion,
_LL_CAST_ stat->ephemeralOwner);
}
void my_string_completion(int rc, const char *name, const void *data) {
fprintf(stderr, "[%s]: rc = %d\n", (char*)(data==0?"null":data), rc);
if (!rc) {
fprintf(stderr, "\tname = %s\n", name);
}
if(batchMode)
shutdownThisThing=1;
}
void my_string_completion_free_data(int rc, const char *name, const void *data) {
my_string_completion(rc, name, data);
free((void*)data);
}
void my_string_stat_completion(int rc, const char *name, const struct Stat *stat,
const void *data) {
my_string_completion(rc, name, data);
dumpStat(stat);
}
void my_string_stat_completion_free_data(int rc, const char *name,
const struct Stat *stat, const void *data) {
my_string_stat_completion(rc, name, stat, data);
free((void*)data);
}
void my_data_completion(int rc, const char *value, int value_len,
const struct Stat *stat, const void *data) {
struct timeval tv;
int sec;
int usec;
gettimeofday(&tv, 0);
sec = tv.tv_sec - startTime.tv_sec;
usec = tv.tv_usec - startTime.tv_usec;
fprintf(stderr, "time = %d msec\n", sec*1000 + usec/1000);
fprintf(stderr, "%s: rc = %d\n", (char*)data, rc);
if (value) {
fprintf(stderr, " value_len = %d\n", value_len);
assert(write(2, value, value_len) == value_len);
}
fprintf(stderr, "\nStat:\n");
dumpStat(stat);
free((void*)data);
if(batchMode)
shutdownThisThing=1;
}
void my_silent_data_completion(int rc, const char *value, int value_len,
const struct Stat *stat, const void *data) {
recvd++;
fprintf(stderr, "Data completion %s rc = %d\n",(char*)data,rc);
free((void*)data);
if (recvd==to_send) {
fprintf(stderr,"Recvd %d responses for %d requests sent\n",recvd,to_send);
if(batchMode)
shutdownThisThing=1;
}
}
void my_strings_completion(int rc, const struct String_vector *strings,
const void *data) {
struct timeval tv;
int sec;
int usec;
int i;
gettimeofday(&tv, 0);
sec = tv.tv_sec - startTime.tv_sec;
usec = tv.tv_usec - startTime.tv_usec;
fprintf(stderr, "time = %d msec\n", sec*1000 + usec/1000);
fprintf(stderr, "%s: rc = %d\n", (char*)data, rc);
if (strings)
for (i=0; i < strings->count; i++) {
fprintf(stderr, "\t%s\n", strings->data[i]);
}
free((void*)data);
gettimeofday(&tv, 0);
sec = tv.tv_sec - startTime.tv_sec;
usec = tv.tv_usec - startTime.tv_usec;
fprintf(stderr, "time = %d msec\n", sec*1000 + usec/1000);
if(batchMode)
shutdownThisThing=1;
}
void my_strings_stat_completion(int rc, const struct String_vector *strings,
const struct Stat *stat, const void *data) {
my_strings_completion(rc, strings, data);
dumpStat(stat);
if(batchMode)
shutdownThisThing=1;
}
void my_void_completion(int rc, const void *data) {
fprintf(stderr, "%s: rc = %d\n", (char*)data, rc);
free((void*)data);
if(batchMode)
shutdownThisThing=1;
}
void my_stat_completion(int rc, const struct Stat *stat, const void *data) {
fprintf(stderr, "%s: rc = %d Stat:\n", (char*)data, rc);
dumpStat(stat);
free((void*)data);
if(batchMode)
shutdownThisThing=1;
}
void my_silent_stat_completion(int rc, const struct Stat *stat,
const void *data) {
// fprintf(stderr, "State completion: [%s] rc = %d\n", (char*)data, rc);
sent++;
free((void*)data);
}
static void sendRequest(const char* data) {
zoo_aset(zh, "/od", data, strlen(data), -1, my_silent_stat_completion,
strdup("/od"));
zoo_aget(zh, "/od", 1, my_silent_data_completion, strdup("/od"));
}
void od_completion(int rc, const struct Stat *stat, const void *data) {
int i;
fprintf(stderr, "od command response: rc = %d Stat:\n", rc);
dumpStat(stat);
// send a whole bunch of requests
recvd=0;
sent=0;
to_send=200;
for (i=0; i\n");
fprintf(stderr, " create2 [+[e|s|c|t=ttl]] \n");
fprintf(stderr, " delete \n");
fprintf(stderr, " set \n");
fprintf(stderr, " get \n");
fprintf(stderr, " ls \n");
fprintf(stderr, " ls2 \n");
fprintf(stderr, " sync \n");
fprintf(stderr, " exists \n");
fprintf(stderr, " wexists \n");
fprintf(stderr, " myid\n");
fprintf(stderr, " verbose\n");
fprintf(stderr, " addauth \n");
fprintf(stderr, " config\n");
fprintf(stderr, " reconfig [-file | -members ,... | "
" -add ,... | -remove ,...] [-version ]\n");
fprintf(stderr, " quit\n");
fprintf(stderr, "\n");
fprintf(stderr, " prefix the command with the character 'a' to run the command asynchronously.\n");
fprintf(stderr, " run the 'verbose' command to toggle verbose logging.\n");
fprintf(stderr, " i.e. 'aget /foo' to get /foo asynchronously\n");
} else if (startsWith(line, "verbose")) {
if (verbose) {
verbose = 0;
zoo_set_debug_level(ZOO_LOG_LEVEL_WARN);
fprintf(stderr, "logging level set to WARN\n");
} else {
verbose = 1;
zoo_set_debug_level(ZOO_LOG_LEVEL_DEBUG);
fprintf(stderr, "logging level set to DEBUG\n");
}
} else if (startsWith(line, "get ")) {
line += 4;
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
rc = zoo_aget(zh, line, 1, my_data_completion, strdup(line));
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (strcmp(line, "config") == 0) {
gettimeofday(&startTime, 0);
rc = zoo_agetconfig(zh, 1, my_data_completion, strdup(ZOO_CONFIG_NODE));
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "reconfig ")) {
int syntaxError = 0;
char* p = NULL;
char* joining = NULL;
char* leaving = NULL;
char* members = NULL;
size_t members_size = 0;
int mode = 0; // 0 = not set, 1 = incremental, 2 = non-incremental
int64_t version = -1;
line += 9;
p = strtok (strdup(line)," ");
while (p != NULL) {
if (strcmp(p, "-add")==0) {
p = strtok (NULL," ");
if (mode == 2 || p == NULL) {
syntaxError = 1;
break;
}
mode = 1;
joining = strdup(p);
} else if (strcmp(p, "-remove")==0){
p = strtok (NULL," ");
if (mode == 2 || p == NULL) {
syntaxError = 1;
break;
}
mode = 1;
leaving = strdup(p);
} else if (strcmp(p, "-members")==0) {
p = strtok (NULL," ");
if (mode == 1 || p == NULL) {
syntaxError = 1;
break;
}
mode = 2;
members = strdup(p);
} else if (strcmp(p, "-file")==0){
FILE *fp = NULL;
p = strtok (NULL," ");
if (mode == 1 || p == NULL) {
syntaxError = 1;
break;
}
mode = 2;
fp = fopen(p, "r");
if (fp == NULL) {
fprintf(stderr, "Error reading file: %s\n", p);
syntaxError = 1;
break;
}
fseek(fp, 0L, SEEK_END); /* Position to end of file */
members_size = ftell(fp); /* Get file length */
rewind(fp); /* Back to start of file */
members = calloc(members_size + 1, sizeof(char));
if(members == NULL )
{
fprintf(stderr, "\nInsufficient memory to read file: %s\n", p);
syntaxError = 1;
fclose(fp);
break;
}
/* Read the entire file into members
* NOTE: -- fread returns number of items successfully read
* not the number of bytes. We're requesting one item of
* members_size bytes. So we expect the return value here
* to be 1.
*/
if (fread(members, members_size, 1, fp) != 1){
fprintf(stderr, "Error reading file: %s\n", p);
syntaxError = 1;
fclose(fp);
break;
}
fclose(fp);
} else if (strcmp(p, "-version")==0){
p = strtok (NULL," ");
if (version != -1 || p == NULL){
syntaxError = 1;
break;
}
#ifdef WIN32
version = _strtoui64(p, NULL, 16);
#else
version = strtoull(p, NULL, 16);
#endif
if (version < 0) {
syntaxError = 1;
break;
}
} else {
syntaxError = 1;
break;
}
p = strtok (NULL," ");
}
if (syntaxError) return;
rc = zoo_areconfig(zh, joining, leaving, members, version, my_data_completion, strdup(line));
free(joining);
free(leaving);
free(members);
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "set ")) {
char *ptr;
line += 4;
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
ptr = strchr(line, ' ');
if (!ptr) {
fprintf(stderr, "No data found after path\n");
return;
}
*ptr = '\0';
ptr++;
rc = zoo_aset(zh, line, ptr, strlen(ptr), -1, my_stat_completion,
strdup(line));
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "ls ")) {
line += 3;
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
gettimeofday(&startTime, 0);
rc= zoo_aget_children(zh, line, 1, my_strings_completion, strdup(line));
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "ls2 ")) {
line += 4;
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
gettimeofday(&startTime, 0);
rc= zoo_aget_children2(zh, line, 1, my_strings_stat_completion, strdup(line));
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "create ") || startsWith(line, "create2 ")) {
int mode = 0;
int64_t ttl_value = -1;
int is_create2 = startsWith(line, "create2 ");
line += is_create2 ? 8 : 7;
if (line[0] == '+') {
int ephemeral = 0;
int sequential = 0;
int container = 0;
int ttl = 0;
char *p = NULL;
line++;
while (*line != ' ' && *line != '\0') {
switch (*line) {
case 'e':
ephemeral = 1;
break;
case 's':
sequential = 1;
break;
case 'c':
container = 1;
break;
case 't':
ttl = 1;
line++;
if (*line != '=') {
fprintf(stderr, "Missing ttl value after +t\n");
return;
}
line++;
ttl_value = strtol(line, &p, 10);
if (ttl_value <= 0) {
fprintf(stderr, "ttl value must be a positive integer\n");
return;
}
// move back line pointer to the last digit
line = p - 1;
break;
default:
fprintf(stderr, "Unknown option: %c\n", *line);
return;
}
line++;
}
if (ephemeral != 0 && sequential == 0 && container == 0 && ttl == 0) {
mode = ZOO_EPHEMERAL;
} else if (ephemeral == 0 && sequential != 0 && container == 0 && ttl == 0) {
mode = ZOO_PERSISTENT_SEQUENTIAL;
} else if (ephemeral != 0 && sequential != 0 && container == 0 && ttl == 0) {
mode = ZOO_EPHEMERAL_SEQUENTIAL;
} else if (ephemeral == 0 && sequential == 0 && container != 0 && ttl == 0) {
mode = ZOO_CONTAINER;
} else if (ephemeral == 0 && sequential == 0 && container == 0 && ttl != 0) {
mode = ZOO_PERSISTENT_WITH_TTL;
} else if (ephemeral == 0 && sequential != 0 && container == 0 && ttl != 0) {
mode = ZOO_PERSISTENT_SEQUENTIAL_WITH_TTL;
} else {
fprintf(stderr, "Invalid mode.\n");
return;
}
if (*line == ' ') {
line++;
}
}
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
fprintf(stderr, "Creating [%s] node (mode: %d)\n", line, mode);
// {
// struct ACL _CREATE_ONLY_ACL_ACL[] = {{ZOO_PERM_CREATE, ZOO_ANYONE_ID_UNSAFE}};
// struct ACL_vector CREATE_ONLY_ACL = {1,_CREATE_ONLY_ACL_ACL};
// rc = zoo_acreate(zh, line, "new", 3, &CREATE_ONLY_ACL, flags,
// my_string_completion, strdup(line));
// }
if (is_create2) {
rc = zoo_acreate2_ttl(zh, line, "new", 3, &ZOO_OPEN_ACL_UNSAFE, mode, ttl_value,
my_string_stat_completion_free_data, strdup(line));
} else {
rc = zoo_acreate_ttl(zh, line, "new", 3, &ZOO_OPEN_ACL_UNSAFE, mode, ttl_value,
my_string_completion_free_data, strdup(line));
}
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "delete ")) {
line += 7;
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
rc = zoo_adelete(zh, line, -1, my_void_completion, strdup(line));
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "sync ")) {
line += 5;
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
rc = zoo_async(zh, line, my_string_completion_free_data, strdup(line));
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "wexists ")) {
#ifdef THREADED
struct Stat stat;
#endif
line += 8;
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
#ifndef THREADED
rc = zoo_awexists(zh, line, watcher, (void*) 0, my_stat_completion, strdup(line));
#else
rc = zoo_wexists(zh, line, watcher, (void*) 0, &stat);
#endif
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (startsWith(line, "exists ")) {
#ifdef THREADED
struct Stat stat;
#endif
line += 7;
if (line[0] != '/') {
fprintf(stderr, "Path must start with /, found: %s\n", line);
return;
}
#ifndef THREADED
rc = zoo_aexists(zh, line, 1, my_stat_completion, strdup(line));
#else
rc = zoo_exists(zh, line, 1, &stat);
#endif
if (rc) {
fprintf(stderr, "Error %d for %s\n", rc, line);
}
} else if (strcmp(line, "myid") == 0) {
printf("session Id = %llx\n", _LL_CAST_ zoo_client_id(zh)->client_id);
} else if (strcmp(line, "reinit") == 0) {
zookeeper_close(zh);
// we can't send myid to the server here -- zookeeper_close() removes
// the session on the server. We must start anew.
zh = zookeeper_init(hostPort, watcher, 30000, 0, 0, 0);
} else if (startsWith(line, "quit")) {
fprintf(stderr, "Quitting...\n");
shutdownThisThing=1;
} else if (startsWith(line, "od")) {
const char val[]="fire off";
fprintf(stderr, "Overdosing...\n");
rc = zoo_aset(zh, "/od", val, sizeof(val)-1, -1, od_completion, 0);
if (rc)
fprintf(stderr, "od command failed: %d\n", rc);
} else if (startsWith(line, "addauth ")) {
char *ptr;
line += 8;
ptr = strchr(line, ' ');
if (ptr) {
*ptr = '\0';
ptr++;
}
zoo_add_auth(zh, line, ptr, ptr ? strlen(ptr) : 0, NULL, NULL);
}
}
/*
* Look for a command in the form 'cmd:command', and store a pointer
* to the command (without its prefix) into *buf if found.
*
* Returns 0 if the argument does not start with the prefix.
* Returns 1 in case of success.
*/
int handleBatchMode(const char* arg, const char** buf) {
size_t cmdlen = strlen(arg);
if (cmdlen < 4) {
// too short
return 0;
}
cmdlen -= 4;
if(strncmp("cmd:", arg, 4) != 0){
return 0;
}
*buf = arg + 4;
return 1;
}
#ifdef THREADED
static void millisleep(int ms) {
#ifdef WIN32
Sleep(ms);
#else /* !WIN32 */
struct timespec ts;
ts.tv_sec = ms / 1000;
ts.tv_nsec = (ms % 1000) * 1000000; // to nanoseconds
nanosleep(&ts, NULL);
#endif /* WIN32 */
}
#endif /* THREADED */
int main(int argc, char **argv) {
static struct option long_options[] = {
{"host", required_argument, NULL, 'h'}, //hostPort
{"ssl", required_argument, NULL, 's'}, //certificate files
{"myid", required_argument, NULL, 'm'}, //myId file
{"cmd", required_argument, NULL, 'c'}, //cmd
{"readonly", no_argument, NULL, 'r'}, //read-only
{"debug", no_argument, NULL, 'd'}, //set log level to DEBUG from the beginning
#ifdef HAVE_CYRUS_SASL_H
// Parameters for SASL authentication.
{"service", required_argument, NULL, 'z'},
{"server-fqdn", required_argument, NULL, 'o'}, //Host used for SASL auth
{"mechlist", required_argument, NULL, 'n'}, //SASL mechanism list
{"user", required_argument, NULL, 'u'}, //SASL user
{"realm", required_argument, NULL, 'l'}, //SASL realm
{"password-file", required_argument, NULL, 'p'},
#endif /* HAVE_CYRUS_SASL_H */
{NULL, 0, NULL, 0},
};
#ifndef THREADED
fd_set rfds, wfds, efds;
int processed=0;
#endif
char buffer[4096];
char p[2048];
#ifdef YCA
char *cert=0;
char appId[64];
#endif
int bufoff = 0;
int flags;
FILE *fh;
#ifdef HAVE_CYRUS_SASL_H
char *service = "zookeeper";
char *serverFQDN = NULL;
char *mechlist = NULL;
char *user = NULL;
char *realm = NULL;
char *passwordFile = NULL;
#endif /* HAVE_CYRUS_SASL_H */
int opt;
int option_index = 0;
verbose = 0;
zoo_set_debug_level(ZOO_LOG_LEVEL_WARN);
flags = 0;
while ((opt = getopt_long(argc, argv, "h:s:m:c:rdz:o:n:u:l:p:", long_options, &option_index)) != -1) {
switch (opt) {
case 'h':
hostPort = optarg;
break;
case 'm':
clientIdFile = optarg;
break;
case 'r':
flags = ZOO_READONLY;
break;
case 'c':
cmd = optarg;
batchMode = 1;
fprintf(stderr,"Batch mode: %s\n",cmd);
break;
case 's':
cert = optarg;
break;
case 'd':
verbose = 1;
zoo_set_debug_level(ZOO_LOG_LEVEL_DEBUG);
fprintf(stderr, "logging level set to DEBUG\n");
break;
#ifdef HAVE_CYRUS_SASL_H
case 'z':
service = optarg;
break;
case 'o':
serverFQDN = optarg;
break;
case 'n':
mechlist = optarg;
break;
case 'u':
user = optarg;
break;
case 'l':
realm = optarg;
break;
case 'p':
passwordFile = optarg;
break;
#endif /* HAVE_CYRUS_SASL_H */
case '?':
if (optopt == 'h') {
fprintf (stderr, "Option -%c requires host list.\n", optopt);
} else if (isprint (optopt)) {
fprintf (stderr, "Unknown option `-%c'.\n", optopt);
} else {
fprintf (stderr,
"Unknown option character `\\x%x'.\n",
optopt);
return 1;
}
}
}
if (!hostPort && optind < argc) {
/*
* getopt_long did not find a '-h ' option.
*
* The invoker may be using using the "old-style" command
* syntax, with positional parameters and "magical" prefixes
* such as 'cmd:'; let's see if we can make sense of it.
*/
hostPort = argv[optind++];
if (optind < argc && !cmd && !clientIdFile) {
int batchModeRes = handleBatchMode(argv[optind], &cmd);
if (batchModeRes == 1) {
batchMode=1;
fprintf(stderr, "Batch mode: '%s'\n", cmd);
} else {
clientIdFile = argv[optind];
}
optind++;
}
}
if (!hostPort || optind < argc) {
fprintf(stderr,
"\nUSAGE: %s -h zk_host_1:port_1,zk_host_2:port_2,... [OPTIONAL ARGS]\n\n"
"MANDATORY ARGS:\n"
"-h, --host Comma separated list of ZooKeeper host:port pairs\n\n"
"OPTIONAL ARGS:\n"
"-m, --myid Path to the file contains the client ID\n"
"-c, --cmd Command to execute, e.g. ls|ls2|create|create2|od|...\n"
#ifdef HAVE_OPENSSL_H
"-s, --ssl Comma separated parameters to initiate SSL connection\n"
" e.g.: server_cert.crt,client_cert.crt,client_priv_key.pem,passwd\n"
#endif
#ifdef HAVE_CYRUS_SASL_H
"-u, --user SASL user name\n"
"-n, --mechlist Comma separated list of SASL mechanisms (GSSAPI and/or DIGEST-MD5)\n"
"-o, --server-fqdn SASL server name ('zk-sasl-md5' for DIGEST-MD5; default: reverse DNS lookup)\n"
"-p, --password-file File containing the password (recommended for SASL/DIGEST-MD5)\n"
"-l, --realm Realm (for SASL/GSSAPI)\n"
"-z, --service SASL service parameter (default: 'zookeeper')\n"
#endif /* HAVE_CYRUS_SASL_H */
"-r, --readonly Connect in read-only mode\n"
"-d, --debug Activate debug logs right from the beginning (you can also use the \n"
" command 'verbose' later to activate debug logs in the cli shell)\n\n",
argv[0]);
#ifdef HAVE_CYRUS_SASL_H
fprintf(stderr,
"SASL EXAMPLES:\n"
"$ %s --mechlist DIGEST-MD5 --user bob --password-file bob.secret --server-fqdn zk-sasl-md5 -h ...\n"
"$ %s --mechlist GSSAPI --user bob --realm BOBINC.COM -h ...\n"
"Notes:\n"
" * SASL and SSL support are currently incompatible (ZOOKEEPER-3482);\n"
" * SASL parameters map to Cyrus SASL's _new/_start APIs and callbacks;\n"
" * DIGEST-MD5 requires '--server-fqdn zk-sasl-md5' for historical reasons.\n"
" * Passwords are obtained via the obsolete 'getpass()' if not provided via '--password-file'.\n"
"\n",
argv[0], argv[0]);
#endif /* HAVE_CYRUS_SASL_H */
fprintf(stderr,
"Version: ZooKeeper cli (c client) version %s\n",
ZOO_VERSION);
return 2;
}
if (clientIdFile) {
fh = fopen(clientIdFile, "r");
if (fh) {
if (fread(&myid, sizeof(myid), 1, fh) != sizeof(myid)) {
memset(&myid, 0, sizeof(myid));
}
fclose(fh);
}
}
#ifdef YCA
strcpy(appId,"yahoo.example.yca_test");
cert = yca_get_cert_once(appId);
if(cert!=0) {
fprintf(stderr,"Certificate for appid [%s] is [%s]\n",appId,cert);
strncpy(p,cert,sizeof(p)-1);
free(cert);
} else {
fprintf(stderr,"Certificate for appid [%s] not found\n",appId);
strcpy(p,"dummy");
}
#else
strcpy(p, "dummy");
#endif
zoo_deterministic_conn_order(1); // enable deterministic order
#ifdef HAVE_CYRUS_SASL_H
/*
* We need to disable the deprecation warnings as Apple has
* decided to deprecate all of CyrusSASL's functions with OS 10.11
* (see MESOS-3030, ZOOKEEPER-4201). We are using GCC pragmas also
* for covering clang.
*/
#ifdef __APPLE__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
if (mechlist) {
zoo_sasl_params_t sasl_params = { 0 };
int sr;
if (cert) {
fprintf(stderr, "SASL and SSL support are currently incompatible (ZOOKEEPER-3482); exiting.\n");
return 1;
}
sr = sasl_client_init(NULL);
if (sr != SASL_OK) {
fprintf(stderr, "Unable to initialize SASL library: %s\n",
sasl_errstring(sr, NULL, NULL));
return 1;
}
sasl_params.service = service;
sasl_params.host = serverFQDN;
sasl_params.mechlist = mechlist;
sasl_params.callbacks = zoo_sasl_make_basic_callbacks(user, realm,
passwordFile);
zh = zookeeper_init_sasl(hostPort, watcher, 30000, &myid, NULL, flags,
NULL, &sasl_params);
if (!zh) {
return errno;
}
}
#ifdef __APPLE__
#pragma GCC diagnostic pop
#endif
#endif /* HAVE_CYRUS_SASL_H */
if (!zh) {
#ifdef HAVE_OPENSSL_H
if (!cert) {
zh = zookeeper_init(hostPort, watcher, 30000, &myid, NULL, flags);
} else {
zh = zookeeper_init_ssl(hostPort, cert, watcher, 30000, &myid, NULL, flags);
}
#else
zh = zookeeper_init(hostPort, watcher, 30000, &myid, NULL, flags);
#endif
if (!zh) {
return errno;
}
}
#ifdef YCA
if(zoo_add_auth(zh,"yca",p,strlen(p),0,0)!=ZOK)
return 2;
#endif
#ifdef THREADED
if (batchMode) {
processline(cmd);
}
while(!shutdownThisThing) {
int rc, len;
if (batchMode) {
// We are just waiting for the asynchronous command to complete.
millisleep(10);
continue;
}
len = sizeof(buffer) - bufoff -1;
if (len <= 0) {
fprintf(stderr, "Can't handle lines that long!\n");
exit(2);
}
rc = read(0, buffer+bufoff, len);
if (rc <= 0) {
fprintf(stderr, "bye\n");
shutdownThisThing=1;
break;
}
bufoff += rc;
buffer[bufoff] = '\0';
while (strchr(buffer, '\n')) {
char *ptr = strchr(buffer, '\n');
*ptr = '\0';
processline(buffer);
ptr++;
memmove(buffer, ptr, strlen(ptr)+1);
bufoff = 0;
}
}
#else
FD_ZERO(&rfds);
FD_ZERO(&wfds);
FD_ZERO(&efds);
while (!shutdownThisThing) {
int fd;
int interest;
int events;
struct timeval tv;
int rc;
zookeeper_interest(zh, &fd, &interest, &tv);
if (fd != -1) {
if (interest&ZOOKEEPER_READ) {
FD_SET(fd, &rfds);
} else {
FD_CLR(fd, &rfds);
}
if (interest&ZOOKEEPER_WRITE) {
FD_SET(fd, &wfds);
} else {
FD_CLR(fd, &wfds);
}
} else {
fd = 0;
}
FD_SET(0, &rfds);
rc = select(fd+1, &rfds, &wfds, &efds, &tv);
events = 0;
if (rc > 0) {
if (FD_ISSET(fd, &rfds)) {
events |= ZOOKEEPER_READ;
}
if (FD_ISSET(fd, &wfds)) {
events |= ZOOKEEPER_WRITE;
}
}
if(batchMode && processed==0){
//batch mode
processline(cmd);
processed=1;
}
if (!processed && FD_ISSET(0, &rfds)) {
int rc;
int len = sizeof(buffer) - bufoff -1;
if (len <= 0) {
fprintf(stderr, "Can't handle lines that long!\n");
exit(2);
}
rc = read(0, buffer+bufoff, len);
if (rc <= 0) {
fprintf(stderr, "bye\n");
break;
}
bufoff += rc;
buffer[bufoff] = '\0';
while (strchr(buffer, '\n')) {
char *ptr = strchr(buffer, '\n');
*ptr = '\0';
processline(buffer);
ptr++;
memmove(buffer, ptr, strlen(ptr)+1);
bufoff = 0;
}
}
zookeeper_process(zh, events);
}
#endif
if (to_send!=0)
fprintf(stderr,"Recvd %d responses for %d requests sent\n",recvd,sent);
zookeeper_close(zh);
return 0;
}
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/hashtable/LICENSE.txt 0100644 0000000 0000000 00000002727 14704315305 030644 0 ustar 00root root 0000000 0000000 Copyright (c) 2002, 2004, Christopher Clark
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
* Neither the name of the original author; nor the names of any contributors
may be used to endorse or promote products derived from this software
without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/hashtable/hashtable.c 0100644 0000000 0000000 00000021510 14704315305 031107 0 ustar 00root root 0000000 0000000 /* Copyright (C) 2004 Christopher Clark */
#include "hashtable.h"
#include "hashtable_private.h"
#include
#include
#include
#include
/*
Credit for primes table: Aaron Krowne
http://br.endernet.org/~akrowne/
http://planetmath.org/encyclopedia/GoodHashTablePrimes.html
*/
static const unsigned int primes[] = {
53, 97, 193, 389,
769, 1543, 3079, 6151,
12289, 24593, 49157, 98317,
196613, 393241, 786433, 1572869,
3145739, 6291469, 12582917, 25165843,
50331653, 100663319, 201326611, 402653189,
805306457, 1610612741
};
const unsigned int prime_table_length = sizeof(primes)/sizeof(primes[0]);
const float max_load_factor = 0.65;
/*****************************************************************************/
struct hashtable *
create_hashtable(unsigned int minsize,
unsigned int (*hashf) (void*),
int (*eqf) (void*,void*))
{
struct hashtable *h;
unsigned int pindex, size = primes[0];
/* Check requested hashtable isn't too large */
if (minsize > (1u << 30)) return NULL;
/* Enforce size as prime */
for (pindex=0; pindex < prime_table_length; pindex++) {
if (primes[pindex] > minsize) { size = primes[pindex]; break; }
}
h = (struct hashtable *)malloc(sizeof(struct hashtable));
if (NULL == h) return NULL; /*oom*/
h->table = (struct entry **)malloc(sizeof(struct entry*) * size);
if (NULL == h->table) { free(h); return NULL; } /*oom*/
memset(h->table, 0, size * sizeof(struct entry *));
h->tablelength = size;
h->primeindex = pindex;
h->entrycount = 0;
h->hashfn = hashf;
h->eqfn = eqf;
h->loadlimit = (unsigned int) ceil(size * max_load_factor);
return h;
}
/*****************************************************************************/
unsigned int
hash(struct hashtable *h, void *k)
{
/* Aim to protect against poor hash functions by adding logic here
* - logic taken from java 1.4 hashtable source */
unsigned int i = h->hashfn(k);
i += ~(i << 9);
i ^= ((i >> 14) | (i << 18)); /* >>> */
i += (i << 4);
i ^= ((i >> 10) | (i << 22)); /* >>> */
return i;
}
/*****************************************************************************/
static int
hashtable_expand(struct hashtable *h)
{
/* Double the size of the table to accomodate more entries */
struct entry **newtable;
struct entry *e;
struct entry **pE;
unsigned int newsize, i, index;
/* Check we're not hitting max capacity */
if (h->primeindex == (prime_table_length - 1)) return 0;
newsize = primes[++(h->primeindex)];
newtable = (struct entry **)malloc(sizeof(struct entry*) * newsize);
if (NULL != newtable)
{
memset(newtable, 0, newsize * sizeof(struct entry *));
/* This algorithm is not 'stable'. ie. it reverses the list
* when it transfers entries between the tables */
for (i = 0; i < h->tablelength; i++) {
while (NULL != (e = h->table[i])) {
h->table[i] = e->next;
index = indexFor(newsize,e->h);
e->next = newtable[index];
newtable[index] = e;
}
}
free(h->table);
h->table = newtable;
}
/* Plan B: realloc instead */
else
{
newtable = (struct entry **)
realloc(h->table, newsize * sizeof(struct entry *));
if (NULL == newtable) { (h->primeindex)--; return 0; }
h->table = newtable;
memset(newtable[h->tablelength], 0, newsize - h->tablelength);
for (i = 0; i < h->tablelength; i++) {
for (pE = &(newtable[i]), e = *pE; e != NULL; e = *pE) {
index = indexFor(newsize,e->h);
if (index == i)
{
pE = &(e->next);
}
else
{
*pE = e->next;
e->next = newtable[index];
newtable[index] = e;
}
}
}
}
h->tablelength = newsize;
h->loadlimit = (unsigned int) ceil(newsize * max_load_factor);
return -1;
}
/*****************************************************************************/
unsigned int
hashtable_count(struct hashtable *h)
{
return h->entrycount;
}
/*****************************************************************************/
int
hashtable_insert(struct hashtable *h, void *k, void *v)
{
/* This method allows duplicate keys - but they shouldn't be used */
unsigned int index;
struct entry *e;
if (++(h->entrycount) > h->loadlimit)
{
/* Ignore the return value. If expand fails, we should
* still try cramming just this value into the existing table
* -- we may not have memory for a larger table, but one more
* element may be ok. Next time we insert, we'll try expanding again.*/
hashtable_expand(h);
}
e = (struct entry *)malloc(sizeof(struct entry));
if (NULL == e) { --(h->entrycount); return 0; } /*oom*/
e->h = hash(h,k);
index = indexFor(h->tablelength,e->h);
e->k = k;
e->v = v;
e->next = h->table[index];
h->table[index] = e;
return -1;
}
/*****************************************************************************/
void * /* returns value associated with key */
hashtable_search(struct hashtable *h, void *k)
{
struct entry *e;
unsigned int hashvalue, index;
hashvalue = hash(h,k);
index = indexFor(h->tablelength,hashvalue);
e = h->table[index];
while (NULL != e)
{
/* Check hash value to short circuit heavier comparison */
if ((hashvalue == e->h) && (h->eqfn(k, e->k))) return e->v;
e = e->next;
}
return NULL;
}
/*****************************************************************************/
void * /* returns value associated with key */
hashtable_remove(struct hashtable *h, void *k)
{
/* TODO: consider compacting the table when the load factor drops enough,
* or provide a 'compact' method. */
struct entry *e;
struct entry **pE;
void *v;
unsigned int hashvalue, index;
hashvalue = hash(h,k);
index = indexFor(h->tablelength, hashvalue);
pE = &(h->table[index]);
e = *pE;
while (NULL != e)
{
/* Check hash value to short circuit heavier comparison */
if ((hashvalue == e->h) && (h->eqfn(k, e->k)))
{
*pE = e->next;
h->entrycount--;
v = e->v;
freekey(e->k);
free(e);
return v;
}
pE = &(e->next);
e = e->next;
}
return NULL;
}
/*****************************************************************************/
/* destroy */
void
hashtable_destroy(struct hashtable *h, int free_values)
{
unsigned int i;
struct entry *e, *f;
struct entry **table = h->table;
if (free_values)
{
for (i = 0; i < h->tablelength; i++)
{
e = table[i];
while (NULL != e)
{ f = e; e = e->next; freekey(f->k); free(f->v); free(f); }
}
}
else
{
for (i = 0; i < h->tablelength; i++)
{
e = table[i];
while (NULL != e)
{ f = e; e = e->next; freekey(f->k); free(f); }
}
}
free(h->table);
free(h);
}
/*
* Copyright (c) 2002, Christopher Clark
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of the original author; nor the names of any contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/hashtable/hashtable.h 0100644 0000000 0000000 00000016530 14704315305 031122 0 ustar 00root root 0000000 0000000 /* Copyright (C) 2002 Christopher Clark */
#ifndef __HASHTABLE_CWC22_H__
#define __HASHTABLE_CWC22_H__
#ifdef WIN32
#include "winconfig.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif
struct hashtable;
/* Example of use:
*
* struct hashtable *h;
* struct some_key *k;
* struct some_value *v;
*
* static unsigned int hash_from_key_fn( void *k );
* static int keys_equal_fn ( void *key1, void *key2 );
*
* h = create_hashtable(16, hash_from_key_fn, keys_equal_fn);
* k = (struct some_key *) malloc(sizeof(struct some_key));
* v = (struct some_value *) malloc(sizeof(struct some_value));
*
* (initialise k and v to suitable values)
*
* if (! hashtable_insert(h,k,v) )
* { exit(-1); }
*
* if (NULL == (found = hashtable_search(h,k) ))
* { printf("not found!"); }
*
* if (NULL == (found = hashtable_remove(h,k) ))
* { printf("Not found\n"); }
*
*/
/* Macros may be used to define type-safe(r) hashtable access functions, with
* methods specialized to take known key and value types as parameters.
*
* Example:
*
* Insert this at the start of your file:
*
* DEFINE_HASHTABLE_INSERT(insert_some, struct some_key, struct some_value);
* DEFINE_HASHTABLE_SEARCH(search_some, struct some_key, struct some_value);
* DEFINE_HASHTABLE_REMOVE(remove_some, struct some_key, struct some_value);
*
* This defines the functions 'insert_some', 'search_some' and 'remove_some'.
* These operate just like hashtable_insert etc., with the same parameters,
* but their function signatures have 'struct some_key *' rather than
* 'void *', and hence can generate compile time errors if your program is
* supplying incorrect data as a key (and similarly for value).
*
* Note that the hash and key equality functions passed to create_hashtable
* still take 'void *' parameters instead of 'some key *'. This shouldn't be
* a difficult issue as they're only defined and passed once, and the other
* functions will ensure that only valid keys are supplied to them.
*
* The cost for this checking is increased code size and runtime overhead
* - if performance is important, it may be worth switching back to the
* unsafe methods once your program has been debugged with the safe methods.
* This just requires switching to some simple alternative defines - eg:
* #define insert_some hashtable_insert
*
*/
/*****************************************************************************
* create_hashtable
* @name create_hashtable
* @param minsize minimum initial size of hashtable
* @param hashfunction function for hashing keys
* @param key_eq_fn function for determining key equality
* @return newly created hashtable or NULL on failure
*/
struct hashtable *
create_hashtable(unsigned int minsize,
unsigned int (*hashfunction) (void*),
int (*key_eq_fn) (void*,void*));
/*****************************************************************************
* hashtable_insert
* @name hashtable_insert
* @param h the hashtable to insert into
* @param k the key - hashtable claims ownership and will free on removal
* @param v the value - does not claim ownership
* @return non-zero for successful insertion
*
* This function will cause the table to expand if the insertion would take
* the ratio of entries to table size over the maximum load factor.
*
* This function does not check for repeated insertions with a duplicate key.
* The value returned when using a duplicate key is undefined -- when
* the hashtable changes size, the order of retrieval of duplicate key
* entries is reversed.
* If in doubt, remove before insert.
*/
int
hashtable_insert(struct hashtable *h, void *k, void *v);
#define DEFINE_HASHTABLE_INSERT(fnname, keytype, valuetype) \
int fnname (struct hashtable *h, keytype *k, valuetype *v) \
{ \
return hashtable_insert(h,k,v); \
}
/*****************************************************************************
* hashtable_search
* @name hashtable_search
* @param h the hashtable to search
* @param k the key to search for - does not claim ownership
* @return the value associated with the key, or NULL if none found
*/
void *
hashtable_search(struct hashtable *h, void *k);
#define DEFINE_HASHTABLE_SEARCH(fnname, keytype, valuetype) \
valuetype * fnname (struct hashtable *h, keytype *k) \
{ \
return (valuetype *) (hashtable_search(h,k)); \
}
/*****************************************************************************
* hashtable_remove
* @name hashtable_remove
* @param h the hashtable to remove the item from
* @param k the key to search for - does not claim ownership
* @return the value associated with the key, or NULL if none found
*/
void * /* returns value */
hashtable_remove(struct hashtable *h, void *k);
#define DEFINE_HASHTABLE_REMOVE(fnname, keytype, valuetype) \
valuetype * fnname (struct hashtable *h, keytype *k) \
{ \
return (valuetype *) (hashtable_remove(h,k)); \
}
/*****************************************************************************
* hashtable_count
* @name hashtable_count
* @param h the hashtable
* @return the number of items stored in the hashtable
*/
unsigned int
hashtable_count(struct hashtable *h);
/*****************************************************************************
* hashtable_destroy
* @name hashtable_destroy
* @param h the hashtable
* @param free_values whether to call 'free' on the remaining values
*/
void
hashtable_destroy(struct hashtable *h, int free_values);
#ifdef __cplusplus
}
#endif
#endif /* __HASHTABLE_CWC22_H__ */
/*
* Copyright (c) 2002, Christopher Clark
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of the original author; nor the names of any contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/hashtable/hashtable_itr.c 0100644 0000000 0000000 00000012420 14704315305 031765 0 ustar 00root root 0000000 0000000 /* Copyright (C) 2002, 2004 Christopher Clark */
#include "hashtable.h"
#include "hashtable_private.h"
#include "hashtable_itr.h"
#include /* defines NULL */
/*****************************************************************************/
/* hashtable_iterator - iterator constructor */
struct hashtable_itr *
hashtable_iterator(struct hashtable *h)
{
unsigned int i, tablelength;
struct hashtable_itr *itr = (struct hashtable_itr *)
malloc(sizeof(struct hashtable_itr));
if (NULL == itr) return NULL;
itr->h = h;
itr->e = NULL;
itr->parent = NULL;
tablelength = h->tablelength;
itr->index = tablelength;
if (0 == h->entrycount) return itr;
for (i = 0; i < tablelength; i++)
{
if (NULL != h->table[i])
{
itr->e = h->table[i];
itr->index = i;
break;
}
}
return itr;
}
/*****************************************************************************/
/* advance - advance the iterator to the next element
* returns zero if advanced to end of table */
int
hashtable_iterator_advance(struct hashtable_itr *itr)
{
unsigned int j,tablelength;
struct entry **table;
struct entry *next;
if (NULL == itr->e) return 0; /* stupidity check */
next = itr->e->next;
if (NULL != next)
{
itr->parent = itr->e;
itr->e = next;
return -1;
}
tablelength = itr->h->tablelength;
itr->parent = NULL;
if (tablelength <= (j = ++(itr->index)))
{
itr->e = NULL;
return 0;
}
table = itr->h->table;
while (NULL == (next = table[j]))
{
if (++j >= tablelength)
{
itr->index = tablelength;
itr->e = NULL;
return 0;
}
}
itr->index = j;
itr->e = next;
return -1;
}
/*****************************************************************************/
/* remove - remove the entry at the current iterator position
* and advance the iterator, if there is a successive
* element.
* If you want the value, read it before you remove:
* beware memory leaks if you don't.
* Returns zero if end of iteration. */
int
hashtable_iterator_remove(struct hashtable_itr *itr)
{
struct entry *remember_e, *remember_parent;
int ret;
/* Do the removal */
if (NULL == (itr->parent))
{
/* element is head of a chain */
itr->h->table[itr->index] = itr->e->next;
} else {
/* element is mid-chain */
itr->parent->next = itr->e->next;
}
/* itr->e is now outside the hashtable */
remember_e = itr->e;
itr->h->entrycount--;
freekey(remember_e->k);
/* Advance the iterator, correcting the parent */
remember_parent = itr->parent;
ret = hashtable_iterator_advance(itr);
if (itr->parent == remember_e) { itr->parent = remember_parent; }
free(remember_e);
return ret;
}
/*****************************************************************************/
int /* returns zero if not found */
hashtable_iterator_search(struct hashtable_itr *itr,
struct hashtable *h, void *k)
{
struct entry *e, *parent;
unsigned int hashvalue, index;
hashvalue = hash(h,k);
index = indexFor(h->tablelength,hashvalue);
e = h->table[index];
parent = NULL;
while (NULL != e)
{
/* Check hash value to short circuit heavier comparison */
if ((hashvalue == e->h) && (h->eqfn(k, e->k)))
{
itr->index = index;
itr->e = e;
itr->parent = parent;
itr->h = h;
return -1;
}
parent = e;
e = e->next;
}
return 0;
}
/*
* Copyright (c) 2002, 2004, Christopher Clark
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of the original author; nor the names of any contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/hashtable/hashtable_itr.h 0100644 0000000 0000000 00000010100 14704315305 031763 0 ustar 00root root 0000000 0000000 /* Copyright (C) 2002, 2004 Christopher Clark */
#ifndef __HASHTABLE_ITR_CWC22__
#define __HASHTABLE_ITR_CWC22__
#include "hashtable.h"
#include "hashtable_private.h" /* needed to enable inlining */
#ifdef __cplusplus
extern "C" {
#endif
/*****************************************************************************/
/* This struct is only concrete here to allow the inlining of two of the
* accessor functions. */
struct hashtable_itr
{
struct hashtable *h;
struct entry *e;
struct entry *parent;
unsigned int index;
};
/*****************************************************************************/
/* hashtable_iterator
*/
struct hashtable_itr *
hashtable_iterator(struct hashtable *h);
/*****************************************************************************/
/* hashtable_iterator_key
* - return the value of the (key,value) pair at the current position */
static inline void *
hashtable_iterator_key(struct hashtable_itr *i)
{
return i->e->k;
}
/*****************************************************************************/
/* value - return the value of the (key,value) pair at the current position */
static inline void *
hashtable_iterator_value(struct hashtable_itr *i)
{
return i->e->v;
}
/*****************************************************************************/
/* advance - advance the iterator to the next element
* returns zero if advanced to end of table */
int
hashtable_iterator_advance(struct hashtable_itr *itr);
/*****************************************************************************/
/* remove - remove current element and advance the iterator to the next element
* NB: if you need the value to free it, read it before
* removing. ie: beware memory leaks!
* returns zero if advanced to end of table */
int
hashtable_iterator_remove(struct hashtable_itr *itr);
/*****************************************************************************/
/* search - overwrite the supplied iterator, to point to the entry
* matching the supplied key.
h points to the hashtable to be searched.
* returns zero if not found. */
int
hashtable_iterator_search(struct hashtable_itr *itr,
struct hashtable *h, void *k);
#define DEFINE_HASHTABLE_ITERATOR_SEARCH(fnname, keytype) \
int fnname (struct hashtable_itr *i, struct hashtable *h, keytype *k) \
{ \
return (hashtable_iterator_search(i,h,k)); \
}
#ifdef __cplusplus
}
#endif
#endif /* __HASHTABLE_ITR_CWC22__*/
/*
* Copyright (c) 2002, 2004, Christopher Clark
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of the original author; nor the names of any contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/hashtable/hashtable_private.h 0100644 0000000 0000000 00000005621 14704315305 032653 0 ustar 00root root 0000000 0000000 /* Copyright (C) 2002, 2004 Christopher Clark */
#ifndef __HASHTABLE_PRIVATE_CWC22_H__
#define __HASHTABLE_PRIVATE_CWC22_H__
#include "hashtable.h"
/*****************************************************************************/
struct entry
{
void *k, *v;
unsigned int h;
struct entry *next;
};
struct hashtable {
unsigned int tablelength;
struct entry **table;
unsigned int entrycount;
unsigned int loadlimit;
unsigned int primeindex;
unsigned int (*hashfn) (void *k);
int (*eqfn) (void *k1, void *k2);
};
/*****************************************************************************/
unsigned int
hash(struct hashtable *h, void *k);
/*****************************************************************************/
/* indexFor */
static inline unsigned int
indexFor(unsigned int tablelength, unsigned int hashvalue) {
return (hashvalue % tablelength);
};
/* Only works if tablelength == 2^N */
/*static inline unsigned int
indexFor(unsigned int tablelength, unsigned int hashvalue)
{
return (hashvalue & (tablelength - 1u));
}
*/
/*****************************************************************************/
#define freekey(X) free(X)
/*define freekey(X) ; */
/*****************************************************************************/
#endif /* __HASHTABLE_PRIVATE_CWC22_H__*/
/*
* Copyright (c) 2002, Christopher Clark
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* * Neither the name of the original author; nor the names of any contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/load_gen.c 0100644 0000000 0000000 00000017367 14704315305 027010 0 ustar 00root root 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include
#include "zookeeper_log.h"
#include
#ifdef THREADED
#include
#endif
#include
#include
static zhandle_t *zh;
// *****************************************************************************
//
static pthread_cond_t cond=PTHREAD_COND_INITIALIZER;
static pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t counterCond=PTHREAD_COND_INITIALIZER;
static pthread_mutex_t counterLock=PTHREAD_MUTEX_INITIALIZER;
static int counter;
void ensureConnected(){
pthread_mutex_lock(&lock);
while (zoo_state(zh)!=ZOO_CONNECTED_STATE) {
pthread_cond_wait(&cond,&lock);
}
pthread_mutex_unlock(&lock);
}
void incCounter(int delta){
pthread_mutex_lock(&counterLock);
counter+=delta;
pthread_cond_broadcast(&counterCond);
pthread_mutex_unlock(&counterLock);
}
void setCounter(int cnt){
pthread_mutex_lock(&counterLock);
counter=cnt;
pthread_cond_broadcast(&counterCond);
pthread_mutex_unlock(&counterLock);
}
void waitCounter(){
pthread_mutex_lock(&counterLock);
while (counter>0) {
pthread_cond_wait(&counterCond,&counterLock);
}
pthread_mutex_unlock(&counterLock);
}
void listener(zhandle_t *zzh, int type, int state, const char *path,void* ctx) {
if (type == ZOO_SESSION_EVENT) {
if (state == ZOO_CONNECTED_STATE || state == ZOO_READONLY_STATE) {
pthread_mutex_lock(&lock);
pthread_cond_broadcast(&cond);
pthread_mutex_unlock(&lock);
}
setCounter(0);
}
}
void create_completion(int rc, const char *name, const void *data) {
incCounter(-1);
if(rc!=ZOK){
LOG_ERROR(LOGSTREAM, "Failed to create a node rc=%d",rc);
}
}
int doCreateNodes(const char* root, int count){
char nodeName[1024];
int i;
for(i=0; idata) {
int32_t i;
for(i=0;icount; i++) {
free(v->data[i]);
}
free(v->data);
v->data = 0;
}
return 0;
}
static int deletedCounter;
int recursiveDelete(const char* root){
struct String_vector children;
int i;
int rc=zoo_get_children(zh,root,0,&children);
if(rc!=ZNONODE){
if(rc!=ZOK){
LOG_ERROR(LOGSTREAM, "Failed to get children of %s, rc=%d",root,rc);
return rc;
}
for(i=0;i
#include
#include
#include
#include
#include
#ifndef WIN32
#include
#include
#include
#include
#endif
int zoo_lock_auth(zhandle_t *zh)
{
return pthread_mutex_lock(&zh->auth_h.lock);
}
int zoo_unlock_auth(zhandle_t *zh)
{
return pthread_mutex_unlock(&zh->auth_h.lock);
}
int lock_buffer_list(buffer_head_t *l)
{
return pthread_mutex_lock(&l->lock);
}
int unlock_buffer_list(buffer_head_t *l)
{
return pthread_mutex_unlock(&l->lock);
}
int lock_completion_list(completion_head_t *l)
{
return pthread_mutex_lock(&l->lock);
}
int unlock_completion_list(completion_head_t *l)
{
pthread_cond_broadcast(&l->cond);
return pthread_mutex_unlock(&l->lock);
}
struct sync_completion *alloc_sync_completion(void)
{
struct sync_completion *sc = (struct sync_completion*)calloc(1, sizeof(struct sync_completion));
if (sc) {
pthread_cond_init(&sc->cond, 0);
pthread_mutex_init(&sc->lock, 0);
}
return sc;
}
int wait_sync_completion(struct sync_completion *sc)
{
pthread_mutex_lock(&sc->lock);
while (!sc->complete) {
pthread_cond_wait(&sc->cond, &sc->lock);
}
pthread_mutex_unlock(&sc->lock);
return 0;
}
void free_sync_completion(struct sync_completion *sc)
{
if (sc) {
pthread_mutex_destroy(&sc->lock);
pthread_cond_destroy(&sc->cond);
free(sc);
}
}
void notify_sync_completion(struct sync_completion *sc)
{
pthread_mutex_lock(&sc->lock);
sc->complete = 1;
pthread_cond_broadcast(&sc->cond);
pthread_mutex_unlock(&sc->lock);
}
int process_async(int outstanding_sync)
{
return 0;
}
#ifdef WIN32
unsigned __stdcall do_io( void * );
unsigned __stdcall do_completion( void * );
int handle_error(zhandle_t* zh, SOCKET sock, char* message)
{
LOG_ERROR(LOGCALLBACK(zh), "%s. %d",message, WSAGetLastError());
closesocket (sock);
return -1;
}
//--create socket pair for interupting selects.
int create_socket_pair(zhandle_t* zh, SOCKET fds[2])
{
struct sockaddr_in inaddr;
struct sockaddr addr;
int yes=1;
int len=0;
SOCKET lst=socket(AF_INET, SOCK_STREAM,IPPROTO_TCP);
if (lst == INVALID_SOCKET ){
LOG_ERROR(LOGCALLBACK(zh), "Error creating socket. %d",WSAGetLastError());
return -1;
}
memset(&inaddr, 0, sizeof(inaddr));
memset(&addr, 0, sizeof(addr));
inaddr.sin_family = AF_INET;
inaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
inaddr.sin_port = 0; //--system assigns the port
if ( setsockopt(lst,SOL_SOCKET,SO_REUSEADDR,(char*)&yes,sizeof(yes)) == SOCKET_ERROR ) {
return handle_error(zh, lst,"Error trying to set socket option.");
}
if (bind(lst,(struct sockaddr *)&inaddr,sizeof(inaddr)) == SOCKET_ERROR){
return handle_error(zh, lst,"Error trying to bind socket.");
}
if (listen(lst,1) == SOCKET_ERROR){
return handle_error(zh, lst,"Error trying to listen on socket.");
}
len=sizeof(inaddr);
getsockname(lst, &addr,&len);
fds[0]=socket(AF_INET, SOCK_STREAM,0);
if (connect(fds[0],&addr,len) == SOCKET_ERROR){
return handle_error(zh, lst, "Error while connecting to socket.");
}
if ((fds[1]=accept(lst,0,0)) == INVALID_SOCKET){
closesocket(fds[0]);
return handle_error(zh, lst, "Error while accepting socket connection.");
}
closesocket(lst);
return 0;
}
#else
void *do_io(void *);
void *do_completion(void *);
#endif
int wakeup_io_thread(zhandle_t *zh);
#ifdef WIN32
static int set_nonblock(SOCKET fd){
ULONG nonblocking_flag = 1;
if (ioctlsocket(fd, FIONBIO, &nonblocking_flag) == 0)
return 1;
else
return -1;
}
#else
static int set_nonblock(int fd){
long l = fcntl(fd, F_GETFL);
if(l & O_NONBLOCK) return 0;
return fcntl(fd, F_SETFL, l | O_NONBLOCK);
}
#endif
void wait_for_others(zhandle_t* zh)
{
struct adaptor_threads* adaptor=zh->adaptor_priv;
pthread_mutex_lock(&adaptor->lock);
while(adaptor->threadsToWait>0)
pthread_cond_wait(&adaptor->cond,&adaptor->lock);
pthread_mutex_unlock(&adaptor->lock);
}
void notify_thread_ready(zhandle_t* zh)
{
struct adaptor_threads* adaptor=zh->adaptor_priv;
pthread_mutex_lock(&adaptor->lock);
adaptor->threadsToWait--;
pthread_cond_broadcast(&adaptor->cond);
while(adaptor->threadsToWait>0)
pthread_cond_wait(&adaptor->cond,&adaptor->lock);
pthread_mutex_unlock(&adaptor->lock);
}
void start_threads(zhandle_t* zh)
{
int rc = 0;
struct adaptor_threads* adaptor=zh->adaptor_priv;
pthread_cond_init(&adaptor->cond,0);
pthread_mutex_init(&adaptor->lock,0);
adaptor->threadsToWait=2; // wait for 2 threads before opening the barrier
// use api_prolog() to make sure zhandle doesn't get destroyed
// while initialization is in progress
api_prolog(zh);
LOG_DEBUG(LOGCALLBACK(zh), "starting threads...");
rc=pthread_create(&adaptor->io, 0, do_io, zh);
assert("pthread_create() failed for the IO thread"&&!rc);
rc=pthread_create(&adaptor->completion, 0, do_completion, zh);
assert("pthread_create() failed for the completion thread"&&!rc);
wait_for_others(zh);
api_epilog(zh, 0);
}
int adaptor_init(zhandle_t *zh)
{
pthread_mutexattr_t recursive_mx_attr;
struct adaptor_threads *adaptor_threads = calloc(1, sizeof(*adaptor_threads));
if (!adaptor_threads) {
LOG_ERROR(LOGCALLBACK(zh), "Out of memory");
return -1;
}
/* We use a pipe for interrupting select() in unix/sol and socketpair in windows. */
#ifdef WIN32
if (create_socket_pair(zh, adaptor_threads->self_pipe) == -1){
LOG_ERROR(LOGCALLBACK(zh), "Can't make a socket.");
#else
if(pipe(adaptor_threads->self_pipe)==-1) {
LOG_ERROR(LOGCALLBACK(zh), "Can't make a pipe %d",errno);
#endif
free(adaptor_threads);
return -1;
}
set_nonblock(adaptor_threads->self_pipe[1]);
set_nonblock(adaptor_threads->self_pipe[0]);
pthread_mutex_init(&zh->auth_h.lock,0);
zh->adaptor_priv = adaptor_threads;
pthread_mutex_init(&zh->to_process.lock,0);
pthread_mutex_init(&adaptor_threads->zh_lock,0);
pthread_mutex_init(&adaptor_threads->reconfig_lock,0);
pthread_mutex_init(&adaptor_threads->watchers_lock,0);
// to_send must be recursive mutex
pthread_mutexattr_init(&recursive_mx_attr);
pthread_mutexattr_settype(&recursive_mx_attr, PTHREAD_MUTEX_RECURSIVE);
pthread_mutex_init(&zh->to_send.lock,&recursive_mx_attr);
pthread_mutexattr_destroy(&recursive_mx_attr);
pthread_mutex_init(&zh->sent_requests.lock,0);
pthread_cond_init(&zh->sent_requests.cond,0);
pthread_mutex_init(&zh->completions_to_process.lock,0);
pthread_cond_init(&zh->completions_to_process.cond,0);
start_threads(zh);
return 0;
}
void adaptor_finish(zhandle_t *zh)
{
struct adaptor_threads *adaptor_threads;
// make sure zh doesn't get destroyed until after we're done here
api_prolog(zh);
adaptor_threads = zh->adaptor_priv;
if(adaptor_threads==0) {
api_epilog(zh,0);
return;
}
if(!pthread_equal(adaptor_threads->io,pthread_self())){
wakeup_io_thread(zh);
pthread_join(adaptor_threads->io, 0);
}else
pthread_detach(adaptor_threads->io);
if(!pthread_equal(adaptor_threads->completion,pthread_self())){
pthread_mutex_lock(&zh->completions_to_process.lock);
pthread_cond_broadcast(&zh->completions_to_process.cond);
pthread_mutex_unlock(&zh->completions_to_process.lock);
pthread_join(adaptor_threads->completion, 0);
}else
pthread_detach(adaptor_threads->completion);
api_epilog(zh,0);
}
void adaptor_destroy(zhandle_t *zh)
{
struct adaptor_threads *adaptor = zh->adaptor_priv;
if(adaptor==0) return;
pthread_cond_destroy(&adaptor->cond);
pthread_mutex_destroy(&adaptor->lock);
pthread_mutex_destroy(&zh->to_process.lock);
pthread_mutex_destroy(&zh->to_send.lock);
pthread_mutex_destroy(&zh->sent_requests.lock);
pthread_cond_destroy(&zh->sent_requests.cond);
pthread_mutex_destroy(&zh->completions_to_process.lock);
pthread_cond_destroy(&zh->completions_to_process.cond);
pthread_mutex_destroy(&adaptor->zh_lock);
pthread_mutex_destroy(&zh->auth_h.lock);
close(adaptor->self_pipe[0]);
close(adaptor->self_pipe[1]);
free(adaptor);
zh->adaptor_priv=0;
}
int wakeup_io_thread(zhandle_t *zh)
{
struct adaptor_threads *adaptor_threads = zh->adaptor_priv;
char c=0;
#ifndef WIN32
return write(adaptor_threads->self_pipe[1],&c,1)==1? ZOK: ZSYSTEMERROR;
#else
return send(adaptor_threads->self_pipe[1], &c, 1, 0)==1? ZOK: ZSYSTEMERROR;
#endif
}
int adaptor_send_queue(zhandle_t *zh, int timeout)
{
if(!zh->close_requested)
return wakeup_io_thread(zh);
// don't rely on the IO thread to send the messages if the app has
// requested to close
return flush_send_queue(zh, timeout);
}
/* These two are declared here because we will run the event loop
* and not the client */
#ifdef WIN32
int zookeeper_interest(zhandle_t *zh, SOCKET *fd, int *interest,
struct timeval *tv);
#else
int zookeeper_interest(zhandle_t *zh, int *fd, int *interest,
struct timeval *tv);
#endif
int zookeeper_process(zhandle_t *zh, int events);
#ifdef WIN32
unsigned __stdcall do_io( void * v)
#else
void *do_io(void *v)
#endif
{
zhandle_t *zh = (zhandle_t*)v;
#ifndef WIN32
struct pollfd fds[2];
struct adaptor_threads *adaptor_threads = zh->adaptor_priv;
api_prolog(zh);
notify_thread_ready(zh);
LOG_DEBUG(LOGCALLBACK(zh), "started IO thread");
fds[0].fd=adaptor_threads->self_pipe[0];
fds[0].events=POLLIN;
while(!zh->close_requested) {
struct timeval tv;
int fd;
int interest;
int timeout;
int maxfd=1;
zh->io_count++;
zookeeper_interest(zh, &fd, &interest, &tv);
if (fd != -1) {
fds[1].fd=fd;
fds[1].events=(interest&ZOOKEEPER_READ)?POLLIN:0;
fds[1].events|=(interest&ZOOKEEPER_WRITE)?POLLOUT:0;
maxfd=2;
}
timeout=tv.tv_sec * 1000 + (tv.tv_usec/1000);
poll(fds,maxfd,timeout);
if (fd != -1) {
interest=(fds[1].revents&POLLIN)?ZOOKEEPER_READ:0;
interest|=((fds[1].revents&POLLOUT)||(fds[1].revents&POLLHUP))?ZOOKEEPER_WRITE:0;
}
if(fds[0].revents&POLLIN){
// flush the pipe
char b[128];
while(read(adaptor_threads->self_pipe[0],b,sizeof(b))==sizeof(b)){}
}
#else
fd_set rfds, wfds;
struct adaptor_threads *adaptor_threads = zh->adaptor_priv;
api_prolog(zh);
notify_thread_ready(zh);
LOG_DEBUG(LOGCALLBACK(zh), "started IO thread");
while(!zh->close_requested) {
struct timeval tv;
SOCKET fd;
int interest;
int rc;
zookeeper_interest(zh, &fd, &interest, &tv);
// FD_ZERO is cheap on Win32, it just sets count of elements to zero.
// It needs to be done to ensure no stale entries.
FD_ZERO(&rfds);
FD_ZERO(&wfds);
if (fd != -1) {
if (interest&ZOOKEEPER_READ) {
FD_SET(fd, &rfds);
}
if (interest&ZOOKEEPER_WRITE) {
FD_SET(fd, &wfds);
}
}
// Always interested in self_pipe.
FD_SET(adaptor_threads->self_pipe[0], &rfds);
rc = select(/* unused */0, &rfds, &wfds, NULL, &tv);
if (rc > 0) {
interest=(FD_ISSET(fd, &rfds))? ZOOKEEPER_READ: 0;
interest|=(FD_ISSET(fd, &wfds))? ZOOKEEPER_WRITE: 0;
if (FD_ISSET(adaptor_threads->self_pipe[0], &rfds)){
// flush the pipe/socket
char b[128];
while(recv(adaptor_threads->self_pipe[0],b,sizeof(b), 0)==sizeof(b)){}
}
}
else if (rc < 0) {
LOG_ERROR(LOGCALLBACK(zh), ("select() failed %d [%d].", rc, WSAGetLastError()));
// Clear interest events for zookeeper_process if select() fails.
interest = 0;
}
#endif
// dispatch zookeeper events
zookeeper_process(zh, interest);
// check the current state of the zhandle and terminate
// if it is_unrecoverable()
if(is_unrecoverable(zh))
break;
}
api_epilog(zh, 0);
LOG_DEBUG(LOGCALLBACK(zh), "IO thread terminated");
return 0;
}
#ifdef WIN32
unsigned __stdcall do_completion( void * v)
#else
void *do_completion(void *v)
#endif
{
zhandle_t *zh = v;
api_prolog(zh);
notify_thread_ready(zh);
LOG_DEBUG(LOGCALLBACK(zh), "started completion thread");
while(!zh->close_requested) {
pthread_mutex_lock(&zh->completions_to_process.lock);
while(!zh->completions_to_process.head && !zh->close_requested) {
pthread_cond_wait(&zh->completions_to_process.cond, &zh->completions_to_process.lock);
}
pthread_mutex_unlock(&zh->completions_to_process.lock);
process_completions(zh);
}
api_epilog(zh, 0);
LOG_DEBUG(LOGCALLBACK(zh), "completion thread terminated");
return 0;
}
int32_t inc_ref_counter(zhandle_t* zh,int i)
{
int incr=(i<0?-1:(i>0?1:0));
// fetch_and_add implements atomic post-increment
int v=fetch_and_add(&zh->ref_counter,incr);
// inc_ref_counter wants pre-increment
v+=incr; // simulate pre-increment
return v;
}
int32_t fetch_and_add(volatile int32_t* operand, int incr)
{
#ifndef WIN32
return __sync_fetch_and_add(operand, incr);
#else
return InterlockedExchangeAdd(operand, incr);
#endif
}
// make sure the static xid is initialized before any threads started
__attribute__((constructor)) int32_t get_xid()
{
static int32_t xid = -1;
if (xid == -1) {
xid = time(0);
}
return fetch_and_add(&xid,1);
}
int lock_reconfig(struct _zhandle *zh)
{
struct adaptor_threads *adaptor = zh->adaptor_priv;
if (adaptor) {
return pthread_mutex_lock(&adaptor->reconfig_lock);
} else {
return 0;
}
}
int unlock_reconfig(struct _zhandle *zh)
{
struct adaptor_threads *adaptor = zh->adaptor_priv;
if (adaptor) {
return pthread_mutex_unlock(&adaptor->reconfig_lock);
} else {
return 0;
}
}
int lock_watchers(struct _zhandle *zh)
{
struct adaptor_threads *adaptor = zh->adaptor_priv;
if (adaptor) {
return pthread_mutex_lock(&adaptor->watchers_lock);
} else {
return 0;
}
}
int unlock_watchers(struct _zhandle *zh)
{
struct adaptor_threads *adaptor = zh->adaptor_priv;
if (adaptor) {
return pthread_mutex_unlock(&adaptor->watchers_lock);
} else {
return 0;
}
}
int enter_critical(zhandle_t* zh)
{
struct adaptor_threads *adaptor = zh->adaptor_priv;
if (adaptor) {
return pthread_mutex_lock(&adaptor->zh_lock);
} else {
return 0;
}
}
int leave_critical(zhandle_t* zh)
{
struct adaptor_threads *adaptor = zh->adaptor_priv;
if (adaptor) {
return pthread_mutex_unlock(&adaptor->zh_lock);
} else {
return 0;
}
}
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/recordio.c 0100644 0000000 0000000 00000022007 14704315305 027031 0 ustar 00root root 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include
#include
#include
#include
#include
#ifndef WIN32
#include
#else
#include /* for _htonl and _ntohl */
#endif
void deallocate_String(char **s)
{
if (*s)
free(*s);
*s = 0;
}
void deallocate_Buffer(struct buffer *b)
{
if (b->buff)
free(b->buff);
b->buff = 0;
}
struct buff_struct {
int32_t len;
int32_t off;
char *buffer;
};
static int resize_buffer(struct buff_struct *s, int newlen)
{
char *buffer= NULL;
while (s->len < newlen) {
s->len *= 2;
}
buffer = (char*)realloc(s->buffer, s->len);
if (!buffer) {
s->buffer = 0;
return -ENOMEM;
}
s->buffer = buffer;
return 0;
}
int oa_start_record(struct oarchive *oa, const char *tag)
{
return 0;
}
int oa_end_record(struct oarchive *oa, const char *tag)
{
return 0;
}
int oa_serialize_int(struct oarchive *oa, const char *tag, const int32_t *d)
{
struct buff_struct *priv = oa->priv;
int32_t i = htonl(*d);
if ((priv->len - priv->off) < sizeof(i)) {
int rc = resize_buffer(priv, priv->len + sizeof(i));
if (rc < 0) return rc;
}
memcpy(priv->buffer+priv->off, &i, sizeof(i));
priv->off+=sizeof(i);
return 0;
}
int64_t zoo_htonll(int64_t v)
{
int i = 0;
char *s = (char *)&v;
if (htonl(1) == 1) {
return v;
}
for (i = 0; i < 4; i++) {
int tmp = s[i];
s[i] = s[8-i-1];
s[8-i-1] = tmp;
}
return v;
}
int oa_serialize_long(struct oarchive *oa, const char *tag, const int64_t *d)
{
const int64_t i = zoo_htonll(*d);
struct buff_struct *priv = oa->priv;
if ((priv->len - priv->off) < sizeof(i)) {
int rc = resize_buffer(priv, priv->len + sizeof(i));
if (rc < 0) return rc;
}
memcpy(priv->buffer+priv->off, &i, sizeof(i));
priv->off+=sizeof(i);
return 0;
}
int oa_start_vector(struct oarchive *oa, const char *tag, const int32_t *count)
{
return oa_serialize_int(oa, tag, count);
}
int oa_end_vector(struct oarchive *oa, const char *tag)
{
return 0;
}
int oa_serialize_bool(struct oarchive *oa, const char *name, const int32_t *i)
{
//return oa_serialize_int(oa, name, i);
struct buff_struct *priv = oa->priv;
if ((priv->len - priv->off) < 1) {
int rc = resize_buffer(priv, priv->len + 1);
if (rc < 0)
return rc;
}
priv->buffer[priv->off] = (*i == 0 ? '\0' : '\1');
priv->off++;
return 0;
}
static const int32_t negone = -1;
int oa_serialize_buffer(struct oarchive *oa, const char *name,
const struct buffer *b)
{
struct buff_struct *priv = oa->priv;
int rc;
if (!b) {
return oa_serialize_int(oa, "len", &negone);
}
rc = oa_serialize_int(oa, "len", &b->len);
if (rc < 0)
return rc;
// this means a buffer of NUll
// with size of -1. This is
// waht we use in java serialization for NULL
if (b->len == -1) {
return rc;
}
if ((priv->len - priv->off) < b->len) {
rc = resize_buffer(priv, priv->len + b->len);
if (rc < 0)
return rc;
}
memcpy(priv->buffer+priv->off, b->buff, b->len);
priv->off += b->len;
return 0;
}
int oa_serialize_string(struct oarchive *oa, const char *name, char **s)
{
struct buff_struct *priv = oa->priv;
int32_t len;
int rc;
if (!*s) {
oa_serialize_int(oa, "len", &negone);
return 0;
}
len = strlen(*s);
rc = oa_serialize_int(oa, "len", &len);
if (rc < 0)
return rc;
if ((priv->len - priv->off) < len) {
rc = resize_buffer(priv, priv->len + len);
if (rc < 0)
return rc;
}
memcpy(priv->buffer+priv->off, *s, len);
priv->off += len;
return 0;
}
int ia_start_record(struct iarchive *ia, const char *tag)
{
return 0;
}
int ia_end_record(struct iarchive *ia, const char *tag)
{
return 0;
}
int ia_deserialize_int(struct iarchive *ia, const char *tag, int32_t *count)
{
struct buff_struct *priv = ia->priv;
if ((priv->len - priv->off) < sizeof(*count)) {
return -E2BIG;
}
memcpy(count, priv->buffer+priv->off, sizeof(*count));
priv->off+=sizeof(*count);
*count = ntohl(*count);
return 0;
}
int ia_deserialize_long(struct iarchive *ia, const char *tag, int64_t *count)
{
struct buff_struct *priv = ia->priv;
int64_t v = 0;
if ((priv->len - priv->off) < sizeof(*count)) {
return -E2BIG;
}
memcpy(count, priv->buffer+priv->off, sizeof(*count));
priv->off+=sizeof(*count);
v = zoo_htonll(*count); // htonll and ntohll do the same
*count = v;
return 0;
}
int ia_start_vector(struct iarchive *ia, const char *tag, int32_t *count)
{
return ia_deserialize_int(ia, tag, count);
}
int ia_end_vector(struct iarchive *ia, const char *tag)
{
return 0;
}
int ia_deserialize_bool(struct iarchive *ia, const char *name, int32_t *v)
{
struct buff_struct *priv = ia->priv;
//fprintf(stderr, "Deserializing bool %d\n", priv->off);
//return ia_deserialize_int(ia, name, v);
if ((priv->len - priv->off) < 1) {
return -E2BIG;
}
*v = priv->buffer[priv->off];
priv->off+=1;
//fprintf(stderr, "Deserializing bool end %d\n", priv->off);
return 0;
}
int ia_deserialize_buffer(struct iarchive *ia, const char *name,
struct buffer *b)
{
struct buff_struct *priv = ia->priv;
int rc = ia_deserialize_int(ia, "len", &b->len);
if (rc < 0)
return rc;
if ((priv->len - priv->off) < b->len) {
return -E2BIG;
}
// set the buffer to null
if (b->len == -1) {
b->buff = NULL;
return rc;
}
b->buff = malloc(b->len);
if (!b->buff) {
return -ENOMEM;
}
memcpy(b->buff, priv->buffer+priv->off, b->len);
priv->off += b->len;
return 0;
}
int ia_deserialize_string(struct iarchive *ia, const char *name, char **s)
{
struct buff_struct *priv = ia->priv;
int32_t len;
int rc = ia_deserialize_int(ia, "len", &len);
if (rc < 0)
return rc;
if ((priv->len - priv->off) < len) {
return -E2BIG;
}
if (len < 0) {
return -EINVAL;
}
*s = malloc(len+1);
if (!*s) {
return -ENOMEM;
}
memcpy(*s, priv->buffer+priv->off, len);
(*s)[len] = '\0';
priv->off += len;
return 0;
}
static struct iarchive ia_default = {
ia_start_record,
ia_end_record,
ia_start_vector,
ia_end_vector,
ia_deserialize_bool,
ia_deserialize_int,
ia_deserialize_long ,
ia_deserialize_buffer,
ia_deserialize_string};
static struct oarchive oa_default = {
oa_start_record,
oa_end_record,
oa_start_vector,
oa_end_vector,
oa_serialize_bool,
oa_serialize_int,
oa_serialize_long ,
oa_serialize_buffer,
oa_serialize_string};
struct iarchive *create_buffer_iarchive(char *buffer, int len)
{
struct iarchive *ia;
struct buff_struct *buff;
ia = malloc(sizeof(*ia));
if (!ia) return 0;
buff = malloc(sizeof(struct buff_struct));
if (!buff) {
free(ia);
return 0;
}
*ia = ia_default;
buff->off = 0;
buff->buffer = buffer;
buff->len = len;
ia->priv = buff;
return ia;
}
struct oarchive *create_buffer_oarchive()
{
struct oarchive *oa;
struct buff_struct *buff;
oa = malloc(sizeof(*oa));
if (!oa) return 0;
buff = malloc(sizeof(struct buff_struct));
if (!buff) {
free(oa);
return 0;
}
*oa = oa_default;
buff->off = 0;
buff->buffer = malloc(128);
buff->len = 128;
oa->priv = buff;
return oa;
}
void close_buffer_iarchive(struct iarchive **ia)
{
free((*ia)->priv);
free(*ia);
*ia = 0;
}
void close_buffer_oarchive(struct oarchive **oa, int free_buffer)
{
if (free_buffer) {
struct buff_struct *buff = (struct buff_struct *)(*oa)->priv;
if (buff->buffer) {
free(buff->buffer);
}
}
free((*oa)->priv);
free(*oa);
*oa = 0;
}
char *get_buffer(struct oarchive *oa)
{
struct buff_struct *buff = oa->priv;
return buff->buffer;
}
int get_buffer_len(struct oarchive *oa)
{
struct buff_struct *buff = oa->priv;
return buff->off;
}
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/st_adaptor.c 0100644 0000000 0000000 00000004273 14704315305 027370 0 ustar 00root root 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if !defined(DLL_EXPORT) && !defined(USE_STATIC_LIB)
# define USE_STATIC_LIB
#endif
#include "zk_adaptor.h"
#include
#include
int zoo_lock_auth(zhandle_t *zh)
{
return 0;
}
int zoo_unlock_auth(zhandle_t *zh)
{
return 0;
}
int lock_buffer_list(buffer_head_t *l)
{
return 0;
}
int unlock_buffer_list(buffer_head_t *l)
{
return 0;
}
int lock_completion_list(completion_head_t *l)
{
return 0;
}
int unlock_completion_list(completion_head_t *l)
{
return 0;
}
int process_async(int outstanding_sync)
{
return outstanding_sync == 0;
}
int adaptor_init(zhandle_t *zh)
{
return 0;
}
void adaptor_finish(zhandle_t *zh){}
void adaptor_destroy(zhandle_t *zh){}
int flush_send_queue(zhandle_t *, int);
int adaptor_send_queue(zhandle_t *zh, int timeout)
{
return flush_send_queue(zh, timeout);
}
int32_t inc_ref_counter(zhandle_t* zh,int i)
{
zh->ref_counter+=(i<0?-1:(i>0?1:0));
return zh->ref_counter;
}
int32_t get_xid()
{
static int32_t xid = -1;
if (xid == -1) {
xid = time(0);
}
return xid++;
}
int lock_reconfig(struct _zhandle *zh)
{
return 0;
}
int unlock_reconfig(struct _zhandle *zh)
{
return 0;
}
int lock_watchers(struct _zhandle *zh)
{
return 0;
}
int unlock_watchers(struct _zhandle *zh)
{
return 0;
}
int enter_critical(zhandle_t* zh)
{
return 0;
}
int leave_critical(zhandle_t* zh)
{
return 0;
}
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/winport.c 0100644 0000000 0000000 00000022431 14704315305 026726 0 ustar 00root root 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifdef WIN32
#include "winport.h"
#include
#include /* for int64_t */
#include /* must always be included before ws2tcpip.h */
#include /* for SOCKET */
int pthread_mutex_lock(pthread_mutex_t* _mutex ){
int rc = WaitForSingleObject( *_mutex, // handle to mutex
INFINITE); // no time-out interval
return ((rc == WAIT_OBJECT_0) ? 0: rc);
}
int pthread_mutex_unlock( pthread_mutex_t* _mutex ){
int rc = ReleaseMutex(*_mutex);
return ((rc != 0)? 0: GetLastError());
}
int pthread_mutex_init(pthread_mutex_t* _mutex, void* ignoredAttr){
//use CreateMutex as we are using the HANDLES in pthread_cond
*_mutex = CreateMutex(
NULL, // default security attributes
FALSE, // initially not owned
NULL); // unnamed mutex
return ((*_mutex == NULL) ? GetLastError() : 0);
}
int pthread_mutex_destroy(pthread_mutex_t* _mutex)
{
int rc = CloseHandle(*_mutex);
return ((rc != 0)? 0: GetLastError());
}
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, unsigned (__stdcall* start_routine)(void* a), void *arg)
{
int _intThreadId;
(*thread).thread_handle = (HANDLE)_beginthreadex( NULL, 0, start_routine , arg, 0, (unsigned int*)&_intThreadId );
(*thread).thread_id = _intThreadId;
return (((*thread).thread_handle == 0 ) ? errno : 0 );
}
int pthread_equal(pthread_t t1, pthread_t t2){
//Is there a better way to do this? GetThreadId(handle) is only supported Windows 2003 n above.
return ((t1.thread_id == t2.thread_id) ? 1:0);
}
pthread_t pthread_self(){
pthread_t thread_self;
thread_self.thread_handle = GetCurrentThread();
thread_self.thread_id = GetCurrentThreadId();
return thread_self;
}
int pthread_join(pthread_t _thread, void** ignore)
{
int rc = WaitForSingleObject( _thread.thread_handle, INFINITE );
return ((rc == WAIT_OBJECT_0) ? 0: rc);
}
int pthread_detach(pthread_t _thread)
{
int rc = CloseHandle(_thread.thread_handle) ;
return (rc != 0) ? 0: GetLastError();
}
void pthread_mutexattr_init(pthread_mutexattr_t* ignore){}
void pthread_mutexattr_settype(pthread_mutexattr_t* ingore_attr, int ignore){}
void pthread_mutexattr_destroy(pthread_mutexattr_t* ignore_attr){}
int
pthread_cond_init (pthread_cond_t *cv,
const pthread_condattr_t * ignore)
{
cv->waiters_count_ = 0;
cv->was_broadcast_ = 0;
cv->sema_ = CreateSemaphore (NULL, // no security
0, // initially 0
0x7fffffff, // max count
NULL); // unnamed
if (cv->sema_ == NULL )
return GetLastError();
InitializeCriticalSection (&cv->waiters_count_lock_);
cv->waiters_done_ = CreateEvent (NULL, // no security
FALSE, // auto-reset
FALSE, // non-signaled initially
NULL); // unnamed
return (cv->waiters_done_ == NULL) ? GetLastError() : 0;
}
int pthread_cond_destroy(pthread_cond_t *cond)
{
CloseHandle( cond->sema_);
DeleteCriticalSection(&cond->waiters_count_lock_);
return (CloseHandle( cond->waiters_done_ ) == 0)? GetLastError(): 0 ;
}
int
pthread_cond_signal (pthread_cond_t *cv)
{
int have_waiters;
EnterCriticalSection (& (cv->waiters_count_lock_));
have_waiters = cv->waiters_count_ > 0;
LeaveCriticalSection (&cv->waiters_count_lock_);
// If there aren't any waiters, then this is a no-op.
if (have_waiters){
return (ReleaseSemaphore (cv->sema_, 1, 0) == 0 ) ? GetLastError() : 0 ;
}else
return 0;
}
int
pthread_cond_broadcast (pthread_cond_t *cv)
{
// This is needed to ensure that and are
// consistent relative to each other.
int have_waiters = 0;
EnterCriticalSection (&cv->waiters_count_lock_);
if (cv->waiters_count_ > 0) {
// We are broadcasting, even if there is just one waiter...
// Record that we are broadcasting, which helps optimize
// for the non-broadcast case.
cv->was_broadcast_ = 1;
have_waiters = 1;
}
if (have_waiters) {
// Wake up all the waiters atomically.
ReleaseSemaphore (cv->sema_, cv->waiters_count_, 0);
LeaveCriticalSection (&cv->waiters_count_lock_);
// Wait for all the awakened threads to acquire the counting
// semaphore.
WaitForSingleObject (cv->waiters_done_, INFINITE);
// This assignment is okay, even without the held
// because no other waiter threads can wake up to access it.
cv->was_broadcast_ = 0;
}
else
LeaveCriticalSection (&cv->waiters_count_lock_);
}
int
pthread_cond_wait (pthread_cond_t *cv,
pthread_mutex_t *external_mutex)
{
int last_waiter;
// Avoid race conditions.
EnterCriticalSection (&cv->waiters_count_lock_);
cv->waiters_count_++;
LeaveCriticalSection (&cv->waiters_count_lock_);
// This call atomically releases the mutex and waits on the
// semaphore until or
// are called by another thread.
SignalObjectAndWait (*external_mutex, cv->sema_, INFINITE, FALSE);
// Reacquire lock to avoid race conditions.
EnterCriticalSection (&cv->waiters_count_lock_);
// We're no longer waiting...
cv->waiters_count_--;
// Check to see if we're the last waiter after .
last_waiter = cv->was_broadcast_ && cv->waiters_count_ == 0;
LeaveCriticalSection (&cv->waiters_count_lock_);
// If we're the last waiter thread during this particular broadcast
// then let all the other threads proceed.
if (last_waiter)
// This call atomically signals the event and waits until
// it can acquire the . This is required to ensure fairness.
SignalObjectAndWait (cv->waiters_done_, *external_mutex, INFINITE, FALSE);
else
// Always regain the external mutex since that's the guarantee we
// give to our callers.
WaitForSingleObject (*external_mutex, INFINITE);
}
int pthread_key_create(pthread_key_t *key, void (*destructor)(void *) )
{
int result = 0;
pthread_key_t* newkey;
if ((newkey = (pthread_key_t*) calloc (1, sizeof (pthread_key_t))) == NULL)
{
result = ENOMEM;
}
else if ((newkey->key = TlsAlloc ()) == TLS_OUT_OF_INDEXES)
{
result = EAGAIN;
free (newkey);
newkey = NULL;
}
else if (destructor != NULL)
{
//--we have to store the function pointer for destructor, so that we can call it
//--to free up the user allocated storage--
newkey->destructor = destructor;
}
key = newkey;
return (result);
}
int pthread_key_delete(pthread_key_t key)
{
int rc = 0;
LPVOID lpvData = TlsGetValue(key.key);
rc = TlsFree (key.key);
rc = (rc != 0 ) ? 0 : GetLastError();
if (key.destructor != NULL && lpvData != 0){
key.destructor(lpvData); //we take control of calling destructor, instead of calling it on thread exit.
}
free (&key);
return (rc);
}
void *pthread_getspecific(pthread_key_t key)
{
LPVOID lpvData = TlsGetValue(key.key);
if ((lpvData == 0) && (GetLastError() != ERROR_SUCCESS))
return NULL;
else
return lpvData;
}
int pthread_setspecific(pthread_key_t key, const void *value)
{
int rc = TlsSetValue (key.key, value);
return ((rc != 0 ) ? 0 : GetLastError());
}
int gettimeofday(struct timeval *tp, void *tzp) {
int64_t now = 0;
if (tzp != 0) { errno = EINVAL; return -1; }
GetSystemTimeAsFileTime( (LPFILETIME)&now );
tp->tv_sec = (long)(now / 10000000 - 11644473600LL);
tp->tv_usec = (now / 10) % 1000000;
return 0;
}
int close(SOCKET fd) {
return closesocket(fd);
}
int Win32WSAStartup()
{
WORD wVersionRq;
WSADATA wsaData;
int err;
wVersionRq = MAKEWORD(2,0);
err = WSAStartup(wVersionRq, &wsaData);
if (err != 0)
return 1;
// confirm the version information
if ((LOBYTE(wsaData.wVersion) != 2) ||
(HIBYTE(wsaData.wVersion) != 0))
{
Win32WSACleanup();
return 1;
}
return 0;
}
void Win32WSACleanup()
{
WSACleanup();
}
double drand48(void)
{
return (double)(rand()) / RAND_MAX;
}
#endif //WIN32
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/winport.h 0100644 0000000 0000000 00000010520 14704315305 026727 0 ustar 00root root 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* This header file is to port pthread lib , sockets and other utility methods on windows.
* Specifically the threads function, mutexes, keys, and socket initialization.
*/
#ifndef WINPORT_H_
#define WINPORT_H_
#ifdef WIN32
#include "winconfig.h"
#define _WINSOCK_DEPRECATED_NO_WARNINGS
#include /* must always be included before ws2tcpip.h */
#include /* for struct sock_addr used in zookeeper.h */
/* POSIX names are deprecated, use ISO conformant names instead. */
#define strdup _strdup
#define getcwd _getcwd
#define getpid _getpid
/* Windows "secure" versions of POSIX reentrant functions */
#define strtok_r strtok_s
#define localtime_r(a,b) localtime_s(b,a)
/* After this version of MSVC, snprintf became a defined function,
and so cannot be redefined, nor can #ifndef be used to guard it. */
#if ((defined(_MSC_VER) && _MSC_VER < 1900) || !defined(_MSC_VER))
#define snprintf _snprintf
#endif
#include
#include
#include /* for int64_t */
#include
#include
typedef int ssize_t;
typedef HANDLE pthread_mutex_t;
struct pthread_t_
{
HANDLE thread_handle;
DWORD thread_id;
};
typedef struct pthread_t_ pthread_t;
typedef int pthread_mutexattr_t;
typedef int pthread_condattr_t;
typedef int pthread_attr_t;
#define PTHREAD_MUTEX_RECURSIVE 0
int pthread_mutex_lock(pthread_mutex_t* _mutex );
int pthread_mutex_unlock( pthread_mutex_t* _mutex );
int pthread_mutex_init(pthread_mutex_t* _mutex, void* ignoredAttr);
int pthread_mutex_destroy(pthread_mutex_t* _mutex);
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, unsigned (__stdcall* start_routine)(void* a), void *arg);
int pthread_equal(pthread_t t1, pthread_t t2);
pthread_t pthread_self();
int pthread_join(pthread_t _thread, void** ignore);
int pthread_detach(pthread_t _thread);
void pthread_mutexattr_init(pthread_mutexattr_t* ignore);
void pthread_mutexattr_settype(pthread_mutexattr_t* ingore_attr, int ignore);
void pthread_mutexattr_destroy(pthread_mutexattr_t* ignore_attr);
// http://www.cs.wustl.edu/~schmidt/win32-cv-1.html
typedef struct
{
int waiters_count_;
// Number of waiting threads.
CRITICAL_SECTION waiters_count_lock_;
// Serialize access to .
HANDLE sema_;
// Semaphore used to queue up threads waiting for the condition to
// become signaled.
HANDLE waiters_done_;
// An auto-reset event used by the broadcast/signal thread to wait
// for all the waiting thread(s) to wake up and be released from the
// semaphore.
size_t was_broadcast_;
// Keeps track of whether we were broadcasting or signaling. This
// allows us to optimize the code if we're just signaling.
}pthread_cond_t;
int pthread_cond_init (pthread_cond_t *cv,const pthread_condattr_t * ignore);
int pthread_cond_destroy(pthread_cond_t *cond);
int pthread_cond_signal (pthread_cond_t *cv);
int pthread_cond_broadcast (pthread_cond_t *cv);
int pthread_cond_wait (pthread_cond_t *cv, pthread_mutex_t *external_mutex);
struct pthread_key_t_
{
DWORD key;
void (*destructor) (void *);
};
typedef struct pthread_key_t_ pthread_key_t;
int pthread_key_create(pthread_key_t *key, void (*destructor)(void *) );
int pthread_key_delete(pthread_key_t key);
void *pthread_getspecific(pthread_key_t key);
int pthread_setspecific(pthread_key_t key, const void *value);
int gettimeofday(struct timeval *tp, void *tzp);
int close(SOCKET fd);
int Win32WSAStartup();
void Win32WSACleanup();
double drand48(void);
#endif //WIN32
#endif //WINPORT_H_
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/zk_adaptor.h 0100644 0000000 0000000 00000025773 14704315305 027403 0 ustar 00root root 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ZK_ADAPTOR_H_
#define ZK_ADAPTOR_H_
#include
#ifdef THREADED
#ifndef WIN32
#include
#else
#include "winport.h"
#endif
#endif
#include "zookeeper.h"
#include "zk_hashtable.h"
#include "addrvec.h"
/* predefined xid's values recognized as special by the server */
#define WATCHER_EVENT_XID -1
#define PING_XID -2
#define AUTH_XID -4
#define SET_WATCHES_XID -8
/* zookeeper state constants */
#define EXPIRED_SESSION_STATE_DEF -112
#define AUTH_FAILED_STATE_DEF -113
#define CONNECTING_STATE_DEF 1
#define ASSOCIATING_STATE_DEF 2
#define CONNECTED_STATE_DEF 3
#define READONLY_STATE_DEF 5
#define SSL_CONNECTING_STATE_DEF 7
#define NOTCONNECTED_STATE_DEF 999
/* zookeeper event type constants */
#define CREATED_EVENT_DEF 1
#define DELETED_EVENT_DEF 2
#define CHANGED_EVENT_DEF 3
#define CHILD_EVENT_DEF 4
#define SESSION_EVENT_DEF -1
#define NOTWATCHING_EVENT_DEF -2
#ifdef __cplusplus
extern "C" {
#endif
struct _buffer_list;
struct _completion_list;
typedef struct _buffer_head {
struct _buffer_list *volatile head;
struct _buffer_list *last;
#ifdef THREADED
pthread_mutex_t lock;
#endif
} buffer_head_t;
typedef struct _completion_head {
struct _completion_list *volatile head;
struct _completion_list *last;
#ifdef THREADED
pthread_cond_t cond;
pthread_mutex_t lock;
#endif
} completion_head_t;
int lock_buffer_list(buffer_head_t *l);
int unlock_buffer_list(buffer_head_t *l);
int lock_completion_list(completion_head_t *l);
int unlock_completion_list(completion_head_t *l);
struct sync_completion {
int rc;
union {
struct {
char *str;
int str_len;
} str;
struct Stat stat;
struct {
char *buffer;
int buff_len;
struct Stat stat;
} data;
struct {
struct ACL_vector acl;
struct Stat stat;
} acl;
struct String_vector strs2;
struct {
struct String_vector strs2;
struct Stat stat2;
} strs_stat;
} u;
int complete;
#ifdef THREADED
pthread_cond_t cond;
pthread_mutex_t lock;
#endif
};
typedef struct _auth_info {
int state; /* 0=>inactive, >0 => active */
char* scheme;
struct buffer auth;
void_completion_t completion;
const char* data;
struct _auth_info *next;
} auth_info;
/**
* This structure represents a packet being read or written.
*/
typedef struct _buffer_list {
char *buffer;
int len; /* This represents the length of sizeof(header) + length of buffer */
int curr_offset; /* This is the offset into the header followed by offset into the buffer */
struct _buffer_list *next;
} buffer_list_t;
/* the size of connect request */
#define HANDSHAKE_REQ_SIZE 45
/* connect request */
struct connect_req {
int32_t protocolVersion;
int64_t lastZxidSeen;
int32_t timeOut;
int64_t sessionId;
int32_t passwd_len;
char passwd[16];
char readOnly;
};
/* the connect response */
struct prime_struct {
int32_t len;
int32_t protocolVersion;
int32_t timeOut;
int64_t sessionId;
int32_t passwd_len;
char passwd[16];
char readOnly;
};
#ifdef THREADED
/* this is used by mt_adaptor internally for thread management */
struct adaptor_threads {
pthread_t io;
pthread_t completion;
int threadsToWait; // barrier
pthread_cond_t cond; // barrier's conditional
pthread_mutex_t lock; // ... and a lock
pthread_mutex_t zh_lock; // critical section lock
pthread_mutex_t reconfig_lock; // lock for reconfiguring cluster's ensemble
pthread_mutex_t watchers_lock; // lock for watcher operations
#ifdef WIN32
SOCKET self_pipe[2];
#else
int self_pipe[2];
#endif
};
#endif
/** the auth list for adding auth */
typedef struct _auth_list_head {
auth_info *auth;
#ifdef THREADED
pthread_mutex_t lock;
#endif
} auth_list_head_t;
typedef struct _zoo_sasl_client zoo_sasl_client_t;
/**
* This structure represents the connection to zookeeper.
*/
struct _zhandle {
zsock_t *fd;
// Hostlist and list of addresses
char *hostname; // hostname contains list of zookeeper servers to connect to
struct sockaddr_storage addr_cur; // address of server we're currently connecting/connected to
struct sockaddr_storage addr_rw_server; // address of last known read/write server found.
addrvec_t addrs; // current list of addresses we're connected to
addrvec_t addrs_old; // old list of addresses that we are no longer connected to
addrvec_t addrs_new; // new list of addresses to connect to if we're reconfiguring
struct timeval last_resolve; // time of last hostname resolution
int resolve_delay_ms; // see zoo_set_servers_resolution_delay
int reconfig; // Are we in the process of reconfiguring cluster's ensemble
double pOld, pNew; // Probability for selecting between 'addrs_old' and 'addrs_new'
int delay;
int disable_reconnection_attempt; // When set, client will not try reconnect to a different server in
// server list. This makes a sticky server for client, and is useful
// for testing if a sticky server is required, or if client wants to
// explicitly shuffle server by calling zoo_cycle_next_server.
// The default value is 0.
watcher_fn watcher; // the registered watcher
// Message timings
struct timeval last_recv; // time last message was received
struct timeval last_send; // time last message was sent
struct timeval last_ping; // time last PING was sent
struct timeval next_deadline; // time of the next deadline
int recv_timeout; // max receive timeout for messages from server
// Buffers
buffer_list_t *input_buffer; // current buffer being read in
buffer_head_t to_process; // buffers that have been read and ready to be processed
buffer_head_t to_send; // packets queued to send
completion_head_t sent_requests; // outstanding requests
completion_head_t completions_to_process; // completions that are ready to run
int outstanding_sync; // number of outstanding synchronous requests
/* read-only mode specific fields */
struct timeval last_ping_rw; /* The last time we checked server for being r/w */
int ping_rw_timeout; /* The time that can go by before checking next server */
// State info
volatile int state; // Current zookeeper state
void *context; // client-side provided context
clientid_t client_id; // client-id
long long last_zxid; // last zookeeper ID
auth_list_head_t auth_h; // authentication data list
log_callback_fn log_callback; // Callback for logging (falls back to logging to stderr)
int io_count; // counts the number of iterations of do_io
// Primer storage
struct _buffer_list primer_buffer; // The buffer used for the handshake at the start of a connection
struct prime_struct primer_storage; // the connect response
char primer_storage_buffer[41]; // the true size of primer_storage
/* zookeeper_close is not reentrant because it de-allocates the zhandler.
* This guard variable is used to defer the destruction of zhandle till
* right before top-level API call returns to the caller */
int32_t ref_counter;
volatile int close_requested;
void *adaptor_priv;
/* Used for debugging only: non-zero value indicates the time when the zookeeper_process
* call returned while there was at least one unprocessed server response
* available in the socket recv buffer */
struct timeval socket_readable;
// Watchers
zk_hashtable* active_node_watchers;
zk_hashtable* active_exist_watchers;
zk_hashtable* active_child_watchers;
/** used for chroot path at the client side **/
char *chroot;
#ifdef HAVE_CYRUS_SASL_H
zoo_sasl_client_t *sasl_client;
#endif /* HAVE_CYRUS_SASL_H */
/** Indicates if this client is allowed to go to r/o mode */
char allow_read_only;
/** Indicates if we connected to a majority server before */
char seen_rw_server_before;
};
int adaptor_init(zhandle_t *zh);
void adaptor_finish(zhandle_t *zh);
void adaptor_destroy(zhandle_t *zh);
#if THREADED
struct sync_completion *alloc_sync_completion(void);
int wait_sync_completion(struct sync_completion *sc);
void free_sync_completion(struct sync_completion *sc);
void notify_sync_completion(struct sync_completion *sc);
#endif
int adaptor_send_queue(zhandle_t *zh, int timeout);
int process_async(int outstanding_sync);
void process_completions(zhandle_t *zh);
int flush_send_queue(zhandle_t*zh, int timeout);
char* sub_string(zhandle_t *zh, const char* server_path);
void free_duplicate_path(const char* free_path, const char* path);
int zoo_lock_auth(zhandle_t *zh);
int zoo_unlock_auth(zhandle_t *zh);
// ensemble reconfigure access guards
int lock_reconfig(struct _zhandle *zh);
int unlock_reconfig(struct _zhandle *zh);
// watchers hashtable lock
int lock_watchers(struct _zhandle *zh);
int unlock_watchers(struct _zhandle *zh);
// critical section guards
int enter_critical(zhandle_t* zh);
int leave_critical(zhandle_t* zh);
// zhandle object reference counting
void api_prolog(zhandle_t* zh);
int api_epilog(zhandle_t *zh, int rc);
int32_t get_xid();
// returns the new value of the ref counter
int32_t inc_ref_counter(zhandle_t* zh,int i);
#ifdef THREADED
// atomic post-increment
int32_t fetch_and_add(volatile int32_t* operand, int incr);
// in mt mode process session event asynchronously by the completion thread
#define PROCESS_SESSION_EVENT(zh,newstate) queue_session_event(zh,newstate)
#else
// in single-threaded mode process session event immediately
//#define PROCESS_SESSION_EVENT(zh,newstate) deliverWatchers(zh,ZOO_SESSION_EVENT,newstate,0)
#define PROCESS_SESSION_EVENT(zh,newstate) queue_session_event(zh,newstate)
#endif
#ifdef __cplusplus
}
#endif
#endif /*ZK_ADAPTOR_H_*/
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/zk_hashtable.c 0100644 0000000 0000000 00000032504 14704315305 027665 0 ustar 00root root 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "zk_hashtable.h"
#include "zk_adaptor.h"
#include "hashtable/hashtable.h"
#include "hashtable/hashtable_itr.h"
#include
#include
#include
typedef struct _watcher_object {
watcher_fn watcher;
void* context;
struct _watcher_object* next;
} watcher_object_t;
struct _zk_hashtable {
struct hashtable* ht;
};
struct watcher_object_list {
watcher_object_t* head;
};
/* the following functions are for testing only */
typedef struct hashtable hashtable_impl;
hashtable_impl* getImpl(zk_hashtable* ht){
return ht->ht;
}
watcher_object_t* getFirstWatcher(zk_hashtable* ht,const char* path)
{
watcher_object_list_t* wl=hashtable_search(ht->ht,(void*)path);
if(wl!=0)
return wl->head;
return 0;
}
/* end of testing functions */
watcher_object_t* clone_watcher_object(watcher_object_t* wo)
{
watcher_object_t* res=calloc(1,sizeof(watcher_object_t));
assert(res);
res->watcher=wo->watcher;
res->context=wo->context;
return res;
}
static unsigned int string_hash_djb2(void *str)
{
unsigned int hash = 5381;
int c;
const char* cstr = (const char*)str;
while ((c = *cstr++))
hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
return hash;
}
static int string_equal(void *key1,void *key2)
{
return strcmp((const char*)key1,(const char*)key2)==0;
}
static watcher_object_t* create_watcher_object(watcher_fn watcher,void* ctx)
{
watcher_object_t* wo=calloc(1,sizeof(watcher_object_t));
assert(wo);
wo->watcher=watcher;
wo->context=ctx;
return wo;
}
static watcher_object_list_t* create_watcher_object_list(watcher_object_t* head)
{
watcher_object_list_t* wl=calloc(1,sizeof(watcher_object_list_t));
assert(wl);
wl->head=head;
return wl;
}
static void destroy_watcher_object_list(watcher_object_list_t* list)
{
watcher_object_t* e = NULL;
if(list==0)
return;
e=list->head;
while(e!=0){
watcher_object_t* this=e;
e=e->next;
free(this);
}
free(list);
}
zk_hashtable* create_zk_hashtable()
{
struct _zk_hashtable *ht=calloc(1,sizeof(struct _zk_hashtable));
assert(ht);
ht->ht=create_hashtable(32,string_hash_djb2,string_equal);
return ht;
}
static void do_clean_hashtable(zk_hashtable* ht)
{
struct hashtable_itr *it;
int hasMore;
if(hashtable_count(ht->ht)==0)
return;
it=hashtable_iterator(ht->ht);
do {
watcher_object_list_t* w=hashtable_iterator_value(it);
destroy_watcher_object_list(w);
hasMore=hashtable_iterator_remove(it);
} while(hasMore);
free(it);
}
void destroy_zk_hashtable(zk_hashtable* ht)
{
if(ht!=0){
do_clean_hashtable(ht);
hashtable_destroy(ht->ht,0);
free(ht);
}
}
// searches for a watcher object instance in a watcher object list;
// two watcher objects are equal if their watcher function and context pointers
// are equal
static watcher_object_t* search_watcher(watcher_object_list_t** wl,watcher_object_t* wo)
{
watcher_object_t* wobj=(*wl)->head;
while(wobj!=0){
if(wobj->watcher==wo->watcher && wobj->context==wo->context)
return wobj;
wobj=wobj->next;
}
return 0;
}
static int add_to_list(watcher_object_list_t **wl, watcher_object_t *wo,
int clone)
{
if (search_watcher(wl, wo)==0) {
watcher_object_t* cloned=wo;
if (clone) {
cloned = clone_watcher_object(wo);
assert(cloned);
}
cloned->next = (*wl)->head;
(*wl)->head = cloned;
return 1;
} else if (!clone) {
// If it's here and we aren't supposed to clone, we must destroy
free(wo);
}
return 0;
}
static int do_insert_watcher_object(zk_hashtable *ht, const char *path, watcher_object_t* wo)
{
int res=1;
watcher_object_list_t* wl;
wl=hashtable_search(ht->ht,(void*)path);
if(wl==0){
int res;
/* inserting a new path element */
res=hashtable_insert(ht->ht,strdup(path),create_watcher_object_list(wo));
assert(res);
}else{
/*
* Path already exists; check if the watcher already exists.
* Don't clone the watcher since it's allocated on the heap --- avoids
* a memory leak and saves a clone operation (calloc + copy).
*/
res = add_to_list(&wl, wo, 0);
}
return res;
}
char **collect_keys(zk_hashtable *ht, int *count)
{
char **list;
struct hashtable_itr *it;
int i;
*count = hashtable_count(ht->ht);
list = calloc(*count, sizeof(char*));
it=hashtable_iterator(ht->ht);
for(i = 0; i < *count; i++) {
list[i] = strdup(hashtable_iterator_key(it));
hashtable_iterator_advance(it);
}
free(it);
return list;
}
static int insert_watcher_object(zk_hashtable *ht, const char *path,
watcher_object_t* wo)
{
int res;
res=do_insert_watcher_object(ht,path,wo);
return res;
}
static void copy_watchers(watcher_object_list_t *from, watcher_object_list_t *to, int clone)
{
watcher_object_t* wo=from->head;
while(wo){
watcher_object_t *next = wo->next;
add_to_list(&to, wo, clone);
wo=next;
}
}
static void copy_table(zk_hashtable *from, watcher_object_list_t *to) {
struct hashtable_itr *it;
int hasMore;
if(hashtable_count(from->ht)==0)
return;
it=hashtable_iterator(from->ht);
do {
watcher_object_list_t *w = hashtable_iterator_value(it);
copy_watchers(w, to, 1);
hasMore=hashtable_iterator_advance(it);
} while(hasMore);
free(it);
}
static void collect_session_watchers(zhandle_t *zh,
watcher_object_list_t **list)
{
copy_table(zh->active_node_watchers, *list);
copy_table(zh->active_exist_watchers, *list);
copy_table(zh->active_child_watchers, *list);
}
static void add_for_event(zk_hashtable *ht, char *path, watcher_object_list_t **list)
{
watcher_object_list_t* wl;
wl = (watcher_object_list_t*)hashtable_remove(ht->ht, path);
if (wl) {
copy_watchers(wl, *list, 0);
// Since we move, not clone the watch_objects, we just need to free the
// head pointer
free(wl);
}
}
static void do_foreach_watcher(watcher_object_t* wo,zhandle_t* zh,
const char* path,int type,int state)
{
// session event's don't have paths
const char *client_path =
(type != ZOO_SESSION_EVENT ? sub_string(zh, path) : path);
while(wo!=0){
wo->watcher(zh,type,state,client_path,wo->context);
wo=wo->next;
}
free_duplicate_path(client_path, path);
}
watcher_object_list_t *collectWatchers(zhandle_t *zh,int type, char *path)
{
struct watcher_object_list *list = create_watcher_object_list(0);
if(type==ZOO_SESSION_EVENT){
watcher_object_t defWatcher;
defWatcher.watcher=zh->watcher;
defWatcher.context=zh->context;
add_to_list(&list, &defWatcher, 1);
collect_session_watchers(zh, &list);
return list;
}
switch(type){
case CREATED_EVENT_DEF:
case CHANGED_EVENT_DEF:
// look up the watchers for the path and move them to a delivery list
add_for_event(zh->active_node_watchers,path,&list);
add_for_event(zh->active_exist_watchers,path,&list);
break;
case CHILD_EVENT_DEF:
// look up the watchers for the path and move them to a delivery list
add_for_event(zh->active_child_watchers,path,&list);
break;
case DELETED_EVENT_DEF:
// look up the watchers for the path and move them to a delivery list
add_for_event(zh->active_node_watchers,path,&list);
add_for_event(zh->active_exist_watchers,path,&list);
add_for_event(zh->active_child_watchers,path,&list);
break;
}
return list;
}
void deliverWatchers(zhandle_t *zh, int type,int state, char *path, watcher_object_list_t **list)
{
if (!list || !(*list)) return;
do_foreach_watcher((*list)->head, zh, path, type, state);
destroy_watcher_object_list(*list);
*list = 0;
}
void activateWatcher(zhandle_t *zh, watcher_registration_t* reg, int rc)
{
if(reg){
/* in multithreaded lib, this code is executed
* by the IO thread */
zk_hashtable *ht = reg->checker(zh, rc);
if(ht){
insert_watcher_object(ht,reg->path,
create_watcher_object(reg->watcher, reg->context));
}
}
}
/* If watcher is NULL, we return TRUE since we consider it a match */
static int containsWatcher(zk_hashtable *watchers, const char *path,
watcher_fn watcher, void *watcherCtx)
{
watcher_object_list_t *wl;
watcher_object_t e;
if (!watcher)
return 1;
wl = hashtable_search(watchers->ht, (void *)path);
if (!wl)
return 0;
e.watcher = watcher;
e.context = watcherCtx;
return search_watcher(&wl, &e) ? 1 : 0;
}
/**
* remove any watcher_object that has a matching (watcher, watcherCtx)
*/
static void removeWatcherFromList(watcher_object_list_t *wl, watcher_fn watcher,
void *watcherCtx)
{
watcher_object_t *e = NULL;
if (!wl || (wl && !wl->head))
return;
e = wl->head;
while (e){
if (e->next &&
e->next->watcher == watcher &&
e->next->context == watcherCtx) {
watcher_object_t *this = e->next;
e->next = e->next->next;
free(this);
break;
}
e = e->next;
}
if (wl->head &&
wl->head->watcher == watcher && wl->head->context == watcherCtx) {
watcher_object_t *this = wl->head;
wl->head = wl->head->next;
free(this);
}
}
static void removeWatcher(zk_hashtable *watchers, const char *path,
watcher_fn watcher, void *watcherCtx)
{
watcher_object_list_t *wl = hashtable_search(watchers->ht, (void *)path);
if (!wl)
return;
if (!watcher) {
wl = (watcher_object_list_t *) hashtable_remove(watchers->ht,
(void *)path);
destroy_watcher_object_list(wl);
return;
}
removeWatcherFromList(wl, watcher, watcherCtx);
if (!wl->head) {
wl = (watcher_object_list_t *) hashtable_remove(watchers->ht,
(void *)path);
destroy_watcher_object_list(wl);
}
}
void deactivateWatcher(zhandle_t *zh, watcher_deregistration_t *dereg, int rc)
{
if (rc != ZOK || !dereg)
return;
removeWatchers(zh, dereg->path, dereg->type, dereg->watcher,
dereg->context);
}
void removeWatchers(zhandle_t *zh, const char* path, ZooWatcherType type,
watcher_fn watcher, void *watcherCtx)
{
switch (type) {
case ZWATCHTYPE_CHILD:
removeWatcher(zh->active_child_watchers, path, watcher, watcherCtx);
break;
case ZWATCHTYPE_DATA:
removeWatcher(zh->active_node_watchers, path, watcher, watcherCtx);
removeWatcher(zh->active_exist_watchers, path, watcher, watcherCtx);
break;
case ZWATCHTYPE_ANY:
removeWatcher(zh->active_child_watchers, path, watcher, watcherCtx);
removeWatcher(zh->active_node_watchers, path, watcher, watcherCtx);
removeWatcher(zh->active_exist_watchers, path, watcher, watcherCtx);
break;
}
}
int pathHasWatcher(zhandle_t *zh, const char *path, int wtype,
watcher_fn watcher, void *watcherCtx)
{
int watcher_found = 0;
switch (wtype) {
case ZWATCHTYPE_CHILD:
watcher_found = containsWatcher(zh->active_child_watchers,
path, watcher, watcherCtx);
break;
case ZWATCHTYPE_DATA:
watcher_found = containsWatcher(zh->active_node_watchers, path,
watcher, watcherCtx);
if (!watcher_found) {
watcher_found = containsWatcher(zh->active_exist_watchers, path,
watcher, watcherCtx);
}
break;
case ZWATCHTYPE_ANY:
watcher_found = containsWatcher(zh->active_child_watchers, path,
watcher, watcherCtx);
if (!watcher_found) {
watcher_found = containsWatcher(zh->active_node_watchers, path,
watcher, watcherCtx);
}
if (!watcher_found) {
watcher_found = containsWatcher(zh->active_exist_watchers, path,
watcher, watcherCtx);
}
break;
}
return watcher_found;
}
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/zk_hashtable.h 0100644 0000000 0000000 00000006103 14704315305 027666 0 ustar 00root root 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ZK_HASHTABLE_H_
#define ZK_HASHTABLE_H_
#include
#ifdef __cplusplus
extern "C" {
#endif
typedef struct watcher_object_list watcher_object_list_t;
typedef struct _zk_hashtable zk_hashtable;
/**
* The function must return a non-zero value if the watcher object can be activated
* as a result of the server response. Normally, a watch can only be activated
* if the server returns a success code (ZOK). However in the case when zoo_exists()
* returns a ZNONODE code the watcher should be activated nevertheless.
*/
typedef zk_hashtable *(*result_checker_fn)(zhandle_t *, int rc);
/**
* A watcher object gets temporarily stored with the completion entry until
* the server response comes back at which moment the watcher object is moved
* to the active watchers map.
*/
typedef struct _watcher_registration {
watcher_fn watcher;
void* context;
result_checker_fn checker;
const char* path;
} watcher_registration_t;
/**
* A watcher deregistration gets temporarily stored with the completion entry until
* the server response comes back at which moment we can remove the watchers from
* the active watchers map.
*/
typedef struct _watcher_deregistration {
watcher_fn watcher;
void* context;
ZooWatcherType type;
const char* path;
} watcher_deregistration_t;
zk_hashtable* create_zk_hashtable();
void destroy_zk_hashtable(zk_hashtable* ht);
char **collect_keys(zk_hashtable *ht, int *count);
/**
* check if the completion has a watcher object associated
* with it. If it does, move the watcher object to the map of
* active watchers (only if the checker allows to do so)
*/
void activateWatcher(zhandle_t *zh, watcher_registration_t* reg, int rc);
void deactivateWatcher(zhandle_t *zh, watcher_deregistration_t *dereg, int rc);
watcher_object_list_t *collectWatchers(zhandle_t *zh,int type, char *path);
void deliverWatchers(zhandle_t *zh, int type, int state, char *path, struct watcher_object_list **list);
void removeWatchers(zhandle_t *zh, const char* path, ZooWatcherType type,
watcher_fn watcher, void *watcherCtx);
int pathHasWatcher(zhandle_t *zh, const char *path, int wtype,
watcher_fn watcher, void *watcherCtx);
#ifdef __cplusplus
}
#endif
#endif /*ZK_HASHTABLE_H_*/
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/zk_log.c 0100644 0000000 0000000 00000011532 14704315305 026511 0 ustar 00root root 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if !defined(DLL_EXPORT) && !defined(USE_STATIC_LIB)
# define USE_STATIC_LIB
#endif
#include "zookeeper_log.h"
#ifndef WIN32
#include
#else
typedef DWORD pid_t;
#include /* for getpid */
#endif
#include
#include
#define TIME_NOW_BUF_SIZE 1024
#define FORMAT_LOG_BUF_SIZE 4096
#ifdef THREADED
#ifndef WIN32
#include
#else
#include "winport.h"
#endif
static pthread_key_t time_now_buffer;
static pthread_key_t format_log_msg_buffer;
void freeBuffer(void* p){
if(p) free(p);
}
__attribute__((constructor)) void prepareTSDKeys() {
pthread_key_create (&time_now_buffer, freeBuffer);
pthread_key_create (&format_log_msg_buffer, freeBuffer);
}
char* getTSData(pthread_key_t key,int size){
char* p=pthread_getspecific(key);
if(p==0){
int res;
p=calloc(1,size);
res=pthread_setspecific(key,p);
if(res!=0){
fprintf(stderr,"Failed to set TSD key: %d",res);
}
}
return p;
}
char* get_time_buffer(){
return getTSData(time_now_buffer,TIME_NOW_BUF_SIZE);
}
char* get_format_log_buffer(){
return getTSData(format_log_msg_buffer,FORMAT_LOG_BUF_SIZE);
}
#else
char* get_time_buffer(){
static char buf[TIME_NOW_BUF_SIZE];
return buf;
}
char* get_format_log_buffer(){
static char buf[FORMAT_LOG_BUF_SIZE];
return buf;
}
#endif
ZooLogLevel logLevel=ZOO_LOG_LEVEL_INFO;
static FILE* logStream=0;
FILE* zoo_get_log_stream(){
if(logStream==0)
logStream=stderr;
return logStream;
}
void zoo_set_log_stream(FILE* stream){
logStream=stream;
}
static const char* time_now(char* now_str){
struct timeval tv;
struct tm lt;
time_t now = 0;
size_t len = 0;
gettimeofday(&tv,0);
now = tv.tv_sec;
localtime_r(&now, <);
// clone the format used by logback ISO8601DateFormat
// specifically: "yyyy-MM-dd HH:mm:ss,SSS"
len = strftime(now_str, TIME_NOW_BUF_SIZE,
"%Y-%m-%d %H:%M:%S",
<);
len += snprintf(now_str + len,
TIME_NOW_BUF_SIZE - len,
",%03d",
(int)(tv.tv_usec/1000));
return now_str;
}
void log_message(log_callback_fn callback, ZooLogLevel curLevel,
int line, const char* funcName, const char* format, ...)
{
static const char* dbgLevelStr[]={"ZOO_INVALID","ZOO_ERROR","ZOO_WARN",
"ZOO_INFO","ZOO_DEBUG"};
static pid_t pid=0;
va_list va;
int ofs = 0;
#ifdef THREADED
unsigned long int tid = 0;
#endif
#ifdef WIN32
char timebuf [TIME_NOW_BUF_SIZE];
const char* time = time_now(timebuf);
#else
const char* time = time_now(get_time_buffer());
#endif
char* buf = get_format_log_buffer();
if(!buf)
{
fprintf(stderr, "log_message: Unable to allocate memory buffer");
return;
}
if(pid==0)
{
pid=getpid();
}
#ifndef THREADED
// pid_t is long on Solaris
ofs = snprintf(buf, FORMAT_LOG_BUF_SIZE,
"%s:%ld:%s@%s@%d: ", time, (long)pid,
dbgLevelStr[curLevel], funcName, line);
#else
#ifdef WIN32
tid = (unsigned long int)(pthread_self().thread_id);
#else
tid = (unsigned long int)(pthread_self());
#endif
ofs = snprintf(buf, FORMAT_LOG_BUF_SIZE-1,
"%s:%ld(0x%lx):%s@%s@%d: ", time, (long)pid, tid,
dbgLevelStr[curLevel], funcName, line);
#endif
// Now grab the actual message out of the variadic arg list
va_start(va, format);
vsnprintf(buf+ofs, FORMAT_LOG_BUF_SIZE-1-ofs, format, va);
va_end(va);
if (callback)
{
callback(buf);
} else {
fprintf(zoo_get_log_stream(), "%s\n", buf);
fflush(zoo_get_log_stream());
}
}
void zoo_set_debug_level(ZooLogLevel level)
{
if(level==0){
// disable logging (unit tests do this)
logLevel=(ZooLogLevel)0;
return;
}
if(levelZOO_LOG_LEVEL_DEBUG)level=ZOO_LOG_LEVEL_DEBUG;
logLevel=level;
}
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/zk_sasl.c 0100644 0000000 0000000 00000034601 14704315305 026674 0 ustar 00root root 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "config.h"
#ifdef HAVE_SYS_SOCKET_H
#include
#endif
#ifdef HAVE_NETINET_IN_H
#include
#endif
#ifdef HAVE_ARPA_INET_H
#include
#endif
#ifdef HAVE_NETDB_H
#include
#endif
#ifdef HAVE_STRING_H
#include
#endif
#ifdef HAVE_UNISTD_H
#include
#endif
#include
#include "zk_sasl.h"
#include "zk_adaptor.h"
#include "zookeeper_log.h"
/*
* We need to disable the deprecation warnings as Apple has decided to
* deprecate all of CyrusSASL's functions with OS 10.11 (see
* MESOS-3030, ZOOKEEPER-4201). We are using GCC pragmas also for
* covering clang.
*/
#ifdef __APPLE__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
#endif
/*
* Store a duplicate of src, or NULL, into *target. Returns
* ZSYSTEMERROR if no memory could be allocated, ZOK otherwise.
*/
static int _zsasl_strdup(const char **target, const char *src)
{
if (src) {
*target = strdup(src);
if (!*target) {
return ZSYSTEMERROR;
}
}
return ZOK;
}
/*
* Free the malloc'ed memory referenced by *location, setting
* *location to NULL.
*/
static void _zsasl_free(const char **location)
{
if (*location) {
free((void*)*location);
*location = NULL;
}
}
zoo_sasl_client_t *zoo_sasl_client_create(zoo_sasl_params_t *sasl_params)
{
zoo_sasl_client_t *sc = calloc(1, sizeof(*sc));
int rc = ZOK;
if (!sc) {
return NULL;
}
sc->state = ZOO_SASL_INITIAL;
rc = rc < 0 ? rc : _zsasl_strdup(&sc->params.service, sasl_params->service);
rc = rc < 0 ? rc : _zsasl_strdup(&sc->params.host, sasl_params->host);
rc = rc < 0 ? rc : _zsasl_strdup(&sc->params.mechlist, sasl_params->mechlist);
sc->params.callbacks = sasl_params->callbacks;
if (rc != ZOK) {
zoo_sasl_client_destroy(sc);
return NULL;
}
return sc;
}
void zoo_sasl_client_destroy(zoo_sasl_client_t *sc)
{
if (!sc) {
return;
}
if (sc->conn) {
sasl_dispose(&sc->conn);
}
sc->params.callbacks = NULL;
_zsasl_free(&sc->params.service);
_zsasl_free(&sc->params.host);
_zsasl_free(&sc->params.mechlist);
sc->state = ZOO_SASL_FAILED;
}
void zoo_sasl_mark_failed(zhandle_t *zh)
{
if (zh->sasl_client) {
zh->sasl_client->state = ZOO_SASL_FAILED;
}
zh->state = ZOO_AUTH_FAILED_STATE;
}
/*
* Put the handle and SASL client in failed state if rc is not ZOK.
* Returns rc.
*/
static int _zsasl_fail(zhandle_t *zh, int rc)
{
if (rc != ZOK) {
zoo_sasl_mark_failed(zh);
LOG_ERROR(LOGCALLBACK(zh), "SASL authentication failed. rc=%d", rc);
}
return rc;
}
/*
* Get and format the host and port associated with a socket address
* into Cyrus SASL format. Optionally also store the host name in
* provided buffer.
*
* \param addr the socket address
* \param salen the length of addr
* \param ipport_buf the formatted output buffer, of size
* NI_MAXHOST + NI_MAXSERV
* \param opt_host_buf the host name buffer, of size NI_MAXHOST, or
* NULL for none
* \return ZOK if successful
*/
static int _zsasl_getipport(zhandle_t *zh,
const struct sockaddr *addr, socklen_t salen,
char *ipport_buf, char *opt_host_buf)
{
char hbuf[NI_MAXHOST], pbuf[NI_MAXSERV];
int niflags, error, written;
niflags = (NI_NUMERICHOST | NI_NUMERICSERV);
#ifdef NI_WITHSCOPEID
if (addr->sa_family == AF_INET6) {
niflags |= NI_WITHSCOPEID;
}
#endif
error = getnameinfo(addr, salen, hbuf, sizeof(hbuf), pbuf, sizeof(pbuf),
niflags);
if (error != 0) {
LOG_ERROR(LOGCALLBACK(zh), "getnameinfo: %s\n", gai_strerror(error));
return ZSYSTEMERROR;
}
written = sprintf(ipport_buf, "%s;%s", hbuf, pbuf);
if (written < 0) {
return ZSYSTEMERROR;
}
if (opt_host_buf) {
memcpy(opt_host_buf, hbuf, sizeof(hbuf));
}
return ZOK;
}
int zoo_sasl_connect(zhandle_t *zh)
{
zoo_sasl_client_t *sc = zh->sasl_client;
char iplocalport[NI_MAXHOST + NI_MAXSERV];
char ipremoteport[NI_MAXHOST + NI_MAXSERV];
char host[NI_MAXHOST];
int rc, sr;
socklen_t salen;
struct sockaddr_storage local_ip, remote_ip;
if (!sc) {
return _zsasl_fail(zh, ZINVALIDSTATE);
}
if (sc->conn) {
sasl_dispose(&sc->conn);
}
sc->state = ZOO_SASL_INITIAL;
/* set ip addresses */
salen = sizeof(local_ip);
if (getsockname(zh->fd->sock, (struct sockaddr *)&local_ip, &salen) < 0) {
LOG_ERROR(LOGCALLBACK(zh), "getsockname");
return _zsasl_fail(zh, ZSYSTEMERROR);
}
rc = _zsasl_getipport(zh, (const struct sockaddr *)&local_ip, salen,
iplocalport, NULL);
if (rc < 0) {
return _zsasl_fail(zh, rc);
}
salen = sizeof(remote_ip);
if (getpeername(zh->fd->sock, (struct sockaddr *)&remote_ip, &salen) < 0) {
LOG_ERROR(LOGCALLBACK(zh), "getpeername");
return _zsasl_fail(zh, ZSYSTEMERROR);
}
rc = _zsasl_getipport(zh, (const struct sockaddr *)&remote_ip, salen,
ipremoteport, host);
if (rc < 0) {
return _zsasl_fail(zh, rc);
}
LOG_DEBUG(LOGCALLBACK(zh),
"Zookeeper Host: %s %s", iplocalport, ipremoteport);
/* client new connection */
sr = sasl_client_new(
sc->params.service,
sc->params.host ? sc->params.host : host,
iplocalport,
ipremoteport,
sc->params.callbacks,
/*secflags*/0,
&sc->conn);
if (sr != SASL_OK) {
LOG_ERROR(LOGCALLBACK(zh),
"allocating SASL connection state: %s",
sasl_errstring(sr, NULL, NULL));
return _zsasl_fail(zh, ZSYSTEMERROR);
}
return ZOK;
}
int zoo_sasl_client_start(zhandle_t *zh)
{
zoo_sasl_client_t *sc = zh->sasl_client;
const char *chosenmech;
const char *client_data;
unsigned client_data_len;
int sr, rc = ZOK;
if (!sc || sc->state != ZOO_SASL_INITIAL) {
return _zsasl_fail(zh, ZINVALIDSTATE);
}
sc->state = ZOO_SASL_INTERMEDIATE;
sr = sasl_client_start(sc->conn, sc->params.mechlist,
NULL, &client_data, &client_data_len, &chosenmech);
if (sr != SASL_OK && sr != SASL_CONTINUE) {
LOG_ERROR(LOGCALLBACK(zh),
"Starting SASL negotiation: %s %s",
sasl_errstring(sr, NULL, NULL),
sasl_errdetail(sc->conn));
return _zsasl_fail(zh, ZSYSTEMERROR);
}
LOG_DEBUG(LOGCALLBACK(zh),
"SASL start sr:%d mech:%s client_data_len:%d",
sr, chosenmech, (int)client_data_len);
/*
* HACK: Without this, the SASL client is unable to reauthenticate
* with the ZooKeeper ensemble after a disconnect. This is due to
* a bug in the JDK's implementation of SASL DIGEST-MD5; the
* upstream issue is:
*
* JDK-6682540, Incorrect SASL DIGEST-MD5 behavior
* https://bugs.openjdk.java.net/browse/JDK-6682540
*
* A patch has been committed to the JDK in May 2019, but it will
* take a while to appear in production:
*
* http://hg.openjdk.java.net/jdk/jdk/rev/0627b8ad33c1
*
* As a workaround, we just "empty" the client start in DIGEST-MD5
* mode, forcing the server to proceed with initial (re)authentication.
*/
if (client_data_len > 0 && strcmp(chosenmech, "DIGEST-MD5") == 0) {
LOG_DEBUG(LOGCALLBACK(zh),
"SASL start %s: refusing reauthenticate",
chosenmech);
client_data = NULL;
client_data_len = 0;
}
/*
* ZooKeeperSaslClient.java:285 says:
*
* GSSAPI: server sends a final packet after authentication
* succeeds or fails.
*
* so we need to keep track of that.
*/
if (strcmp(chosenmech, "GSSAPI") == 0) {
sc->is_gssapi = 1;
}
if (sr == SASL_CONTINUE || client_data_len > 0) {
rc = queue_sasl_request(zh, client_data, client_data_len);
if (rc < 0) {
return _zsasl_fail(zh, rc);
}
}
return rc;
}
int zoo_sasl_client_step(zhandle_t *zh, const char *server_data,
int server_data_len)
{
zoo_sasl_client_t *sc = zh->sasl_client;
const char *client_data;
unsigned client_data_len;
int sr, rc = ZOK;
if (!sc || sc->state != ZOO_SASL_INTERMEDIATE) {
return _zsasl_fail(zh, ZINVALIDSTATE);
}
LOG_DEBUG(LOGCALLBACK(zh),
"SASL intermediate server_data_len:%d", server_data_len);
if (sc->is_gssapi && sc->is_last_packet) {
/* See note in zoo_sasl_client_start. */
sc->is_last_packet = 0;
sc->state = ZOO_SASL_COMPLETE;
return rc;
}
sr = sasl_client_step(sc->conn, server_data, server_data_len,
NULL, &client_data, &client_data_len);
LOG_DEBUG(LOGCALLBACK(zh),
"SASL intermediate sr:%d client_data_len:%d",
sr, (int)client_data_len);
if (sr != SASL_OK && sr != SASL_CONTINUE) {
LOG_ERROR(LOGCALLBACK(zh),
"During SASL negotiation: %s %s",
sasl_errstring(sr, NULL, NULL),
sasl_errdetail(sc->conn));
return _zsasl_fail(zh, ZSYSTEMERROR);
}
if (sr == SASL_CONTINUE || client_data_len > 0) {
rc = queue_sasl_request(zh, client_data, client_data_len);
if (rc < 0) {
return _zsasl_fail(zh, rc);
}
}
if (sr != SASL_CONTINUE) {
if (sc->is_gssapi) {
/* See note in zoo_sasl_client_start. */
sc->is_last_packet = 1;
} else {
sc->state = ZOO_SASL_COMPLETE;
}
}
return rc;
}
/*
* Cyrus SASL callback for SASL_CB_GETREALM
*/
static int _zsasl_getrealm(void *context, int id, const char **availrealms,
const char **result)
{
const char *realm = (const char*)context;
*result = realm;
return SASL_OK;
}
/*
* Cyrus SASL callback for SASL_CB_USER or SASL_CB_AUTHNAME
*/
static int _zsasl_simple(void *context, int id, const char **result,
unsigned *len)
{
const char *user = (const char*)context;
/* paranoia check */
if (!result)
return SASL_BADPARAM;
switch (id) {
case SASL_CB_USER:
*result = user;
break;
case SASL_CB_AUTHNAME:
*result = user;
break;
default:
return SASL_BADPARAM;
}
return SASL_OK;
}
#ifndef HAVE_GETPASSPHRASE
static char *
getpassphrase(const char *prompt) {
return getpass(prompt);
}
#endif /* ! HAVE_GETPASSPHRASE */
struct zsasl_secret_ctx {
const char *password_file;
sasl_secret_t *secret;
};
/*
* Cyrus SASL callback for SASL_CB_PASS
*/
static int _zsasl_getsecret(sasl_conn_t *conn, void *context, int id,
sasl_secret_t **psecret)
{
struct zsasl_secret_ctx *secret_ctx = (struct zsasl_secret_ctx *)context;
char buf[1024];
char *password;
size_t len;
sasl_secret_t *x;
/* paranoia check */
if (!conn || !psecret || id != SASL_CB_PASS)
return SASL_BADPARAM;
if (secret_ctx->password_file) {
char *p;
FILE *fh = fopen(secret_ctx->password_file, "rt");
if (!fh)
return SASL_FAIL;
if (!fgets(buf, sizeof(buf), fh)) {
fclose(fh);
return SASL_FAIL;
}
fclose(fh);
p = strrchr(buf, '\n');
if (p)
*p = '\0';
password = buf;
} else {
password = getpassphrase("Password: ");
if (!password)
return SASL_FAIL;
}
len = strlen(password);
x = secret_ctx->secret = (sasl_secret_t *)realloc(
secret_ctx->secret, sizeof(sasl_secret_t) + len);
if (!x) {
memset(password, 0, len);
return SASL_NOMEM;
}
x->len = len;
strcpy((char *) x->data, password);
memset(password, 0, len);
*psecret = x;
return SASL_OK;
}
typedef int (* sasl_callback_fn_t)(void);
sasl_callback_t *zoo_sasl_make_basic_callbacks(const char *user,
const char *realm,
const char* password_file)
{
struct zsasl_secret_ctx *secret_ctx;
const char *user_ctx = NULL;
const char *realm_ctx = NULL;
int rc;
secret_ctx = (struct zsasl_secret_ctx *)calloc(
1, sizeof(struct zsasl_secret_ctx));
rc = secret_ctx ? ZOK : ZSYSTEMERROR;
rc = rc < 0 ? rc : _zsasl_strdup(&user_ctx, user);
rc = rc < 0 ? rc : _zsasl_strdup(&realm_ctx, realm);
rc = rc < 0 ? rc : _zsasl_strdup(&secret_ctx->password_file, password_file);
{
sasl_callback_t callbacks[] = {
{ SASL_CB_GETREALM, (sasl_callback_fn_t)&_zsasl_getrealm, (void*)realm_ctx },
{ SASL_CB_USER, (sasl_callback_fn_t)&_zsasl_simple, (void*)user_ctx },
{ SASL_CB_AUTHNAME, (sasl_callback_fn_t)&_zsasl_simple, (void*)user_ctx },
{ SASL_CB_PASS, (sasl_callback_fn_t)&_zsasl_getsecret, (void*)secret_ctx },
{ SASL_CB_LIST_END, NULL, NULL }
};
sasl_callback_t *xcallbacks = rc < 0 ? NULL : malloc(sizeof(callbacks));
if (rc < 0 || !xcallbacks) {
if (secret_ctx) {
_zsasl_free(&secret_ctx->password_file);
free(secret_ctx);
secret_ctx = NULL;
}
_zsasl_free(&realm_ctx);
_zsasl_free(&user_ctx);
return NULL;
}
memcpy(xcallbacks, callbacks, sizeof(callbacks));
return xcallbacks;
}
}
#ifdef __APPLE__
#pragma GCC diagnostic pop
#endif
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/zk_sasl.h 0100644 0000000 0000000 00000012010 14704315305 026667 0 ustar 00root root 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ZK_SASL_H_
#define ZK_SASL_H_
#ifdef __cplusplus
extern "C" {
#endif
/**
* \brief enumerates SASL authentication states. Corresponds to
* org.apache.zookeeper.client.ZooKeeperSaslClient.SaslState.
*/
typedef enum {
ZOO_SASL_INITIAL,
ZOO_SASL_INTERMEDIATE,
ZOO_SASL_COMPLETE,
ZOO_SASL_FAILED
} ZooSaslState;
/**
* \brief zoo_sasl_client_t structure.
*
* This structure holds (a copy of) the original SASL parameters, the
* Cyrus SASL client "object," and the current authentication state.
*
* See \ref zoo_sasl_client_create and \ref zoo_sasl_client_destroy.
*/
typedef struct _zoo_sasl_client {
zoo_sasl_params_t params;
sasl_conn_t *conn;
ZooSaslState state;
unsigned char is_gssapi;
unsigned char is_last_packet;
} zoo_sasl_client_t;
/**
* \brief allocates a \ref zoo_sasl_client_t "object."
*
* \param sasl_params The SASL parameters to use. Note while "string"
* parameters are copied, the callbacks array is simply referenced:
* its lifetime must therefore cover that of the handle.
* \return the client object, or NULL on failure
*/
zoo_sasl_client_t *zoo_sasl_client_create(zoo_sasl_params_t *sasl_params);
/**
* \brief "destroys" a \ref zoo_sasl_client_t "object" allocated by
* \ref zoo_sasl_client_create.
*
* \param sasl_client the client "object"
*/
void zoo_sasl_client_destroy(zoo_sasl_client_t *sasl_client);
/**
* \brief put the handle and SASL client in failed state.
*
* This sets the SASL client in \ref ZOO_SASL_FAILED state and the
* ZooKeeper handle in \ref ZOO_AUTH_FAILED_STATE state.
*
* \param zh the ZooKeeper handle to mark
*/
void zoo_sasl_mark_failed(zhandle_t *zh);
/**
* \brief prepares the SASL connection object for the (connecting)
* ZooKeeper handle.
*
* The client is switched to \ref ZOO_SASL_INITIAL state, or \ref
* ZOO_SASL_FAILED in case of error.
*
* \param zh the ZooKeeper handle in \ref ZOO_CONNECTING_STATE state
* \return ZOK on success, or one of the following on failure:
* ZINVALIDSTATE - no SASL client present
* ZSYSTEMERROR - SASL library error
*/
int zoo_sasl_connect(zhandle_t *zh);
/**
* \brief queues an encoded SASL request to ZooKeeper.
*
* Note that such packets are added to the front of the queue,
* pre-empting "normal" communications.
*
* \param zh the ZooKeeper handle
* \param client_data the encoded SASL data, ready to send
* \param client_data_len the length of \c client_data
* \return ZOK on success, or ZMARSHALLINGERROR if something went wrong
*/
int queue_sasl_request(zhandle_t *zh, const char *client_data,
int client_data_len);
/**
* \brief starts a new SASL authentication session using the
* parameters provided to \ref zoo_sasl_client_create
*
* On entry, the client must be in \ref ZOO_SASL_INITIAL state; this
* call switches it to \ref ZOO_SASL_INTERMEDIATE state or \ref
* ZOO_SASL_FAILED in case of error.
*
* Note that this is not a "normal" ZK client function; the
* corresponding packets are added to the front of the queue,
* pre-empting other requests.
*
* \param zh the ZooKeeper handle, with the SASL client in
* \ref ZOO_SASL_INITIAL state
* \return ZOK on success, or one of the following on failure:
* ZINVALIDSTATE - client not in expected state
* ZSYSTEMERROR - SASL library error
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
int zoo_sasl_client_start(zhandle_t *zh);
/**
* \brief performs a step in the SASL authentication process.
*
* On entry, the client must be in \ref ZOO_SASL_INTERMEDIATE
* state. This call switches it to \ref ZOO_SASL_COMPLETE state if
* (and only if) the process is complete--or to \ref ZOO_SASL_FAILED
* in case of error.
*
* \param zh the ZooKeeper handle, with the SASL client in
* \ref ZOO_SASL_INTERMEDIATE state
* \param server_data SASL data from the ZooKeeper server
* \param server_data_len length of \c server_data
* \return ZOK on success, or one of the following on failure:
* ZINVALIDSTATE - client not in expected state
* ZSYSTEMERROR - SASL library error
* ZMARSHALLINGERROR - failed to marshall a request; possibly, out of memory
*/
int zoo_sasl_client_step(zhandle_t *zh, const char *server_data,
int server_data_len);
#ifdef __cplusplus
}
#endif
#endif /*ZK_SASL_H_*/
apache-zookeeper-3.9.3/zookeeper-client/zookeeper-client-c/src/zookeeper.c 0100644 0000000 0000000 00000540356 14704315305 027242 0 ustar 00root root 0000000 0000000 /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#if !defined(DLL_EXPORT) && !defined(USE_STATIC_LIB)
# define USE_STATIC_LIB
#endif
#if defined(__CYGWIN__)
#define USE_IPV6
#endif
#include "config.h"
#include
#include
#include
#include "zk_adaptor.h"
#include "zookeeper_log.h"
#include "zk_hashtable.h"
#ifdef HAVE_CYRUS_SASL_H
#include "zk_sasl.h"
#endif /* HAVE_CYRUS_SASL_H */
#include
#include
#include
#include
#include
#include
#include
#include
#include
#ifdef HAVE_SYS_TIME_H
#include
#endif
#ifdef HAVE_SYS_SOCKET_H
#include
#endif
#ifdef HAVE_POLL
#include
#endif
#ifdef HAVE_NETINET_IN_H
#include
#include
#endif
#ifdef HAVE_ARPA_INET_H
#include
#endif
#ifdef HAVE_NETDB_H
#include
#endif
#ifdef HAVE_UNISTD_H
#include // needed for _POSIX_MONOTONIC_CLOCK
#endif
#ifdef HAVE_SYS_UTSNAME_H
#include
#endif
#ifdef HAVE_GETPWUID_R
#include
#endif
#ifdef HAVE_OPENSSL_H
#include
#include
#endif
#ifdef __MACH__ // OS X
#include
#include
#include
#endif
#ifdef WIN32
#include /* for getpid */
#include /* for getcwd */
#define EAI_ADDRFAMILY WSAEINVAL /* is this still needed? */
#define EHOSTDOWN EPIPE
#define ESTALE ENODEV
#endif
#define IF_DEBUG(x) if(logLevel==ZOO_LOG_LEVEL_DEBUG) {x;}
const int ZOOKEEPER_WRITE = 1 << 0;
const int ZOOKEEPER_READ = 1 << 1;
const int ZOO_PERSISTENT = 0;
const int ZOO_EPHEMERAL = 1;
const int ZOO_PERSISTENT_SEQUENTIAL = 2;
const int ZOO_EPHEMERAL_SEQUENTIAL = 3;
const int ZOO_CONTAINER = 4;
const int ZOO_PERSISTENT_WITH_TTL = 5;
const int ZOO_PERSISTENT_SEQUENTIAL_WITH_TTL = 6;
#define ZOOKEEPER_IS_SEQUENCE(mode) \
((mode) == ZOO_PERSISTENT_SEQUENTIAL || \
(mode) == ZOO_EPHEMERAL_SEQUENTIAL || \
(mode) == ZOO_PERSISTENT_SEQUENTIAL_WITH_TTL)
#define ZOOKEEPER_IS_TTL(mode) \
((mode) == ZOO_PERSISTENT_WITH_TTL || \
(mode) == ZOO_PERSISTENT_SEQUENTIAL_WITH_TTL)
// keep ZOO_SEQUENCE as a bitmask for compatibility reasons
const int ZOO_SEQUENCE = 1 << 1;
#define ZOO_MAX_TTL 0xFFFFFFFFFFLL
const int ZOO_EXPIRED_SESSION_STATE = EXPIRED_SESSION_STATE_DEF;
const int ZOO_AUTH_FAILED_STATE = AUTH_FAILED_STATE_DEF;
const int ZOO_CONNECTING_STATE = CONNECTING_STATE_DEF;
const int ZOO_ASSOCIATING_STATE = ASSOCIATING_STATE_DEF;
const int ZOO_CONNECTED_STATE = CONNECTED_STATE_DEF;
const int ZOO_READONLY_STATE = READONLY_STATE_DEF;
const int ZOO_SSL_CONNECTING_STATE = SSL_CONNECTING_STATE_DEF;
const int ZOO_NOTCONNECTED_STATE = NOTCONNECTED_STATE_DEF;
static __attribute__ ((unused)) const char* state2String(int state){
switch(state){
case 0:
return "ZOO_CLOSED_STATE";
case CONNECTING_STATE_DEF:
return "ZOO_CONNECTING_STATE";
case SSL_CONNECTING_STATE_DEF:
return "ZOO_SSL_CONNECTING_STATE";
case ASSOCIATING_STATE_DEF:
return "ZOO_ASSOCIATING_STATE";
case CONNECTED_STATE_DEF:
return "ZOO_CONNECTED_STATE";
case READONLY_STATE_DEF:
return "ZOO_READONLY_STATE";
case EXPIRED_SESSION_STATE_DEF:
return "ZOO_EXPIRED_SESSION_STATE";
case AUTH_FAILED_STATE_DEF:
return "ZOO_AUTH_FAILED_STATE";
}
return "INVALID_STATE";
}
const int ZOO_CREATED_EVENT = CREATED_EVENT_DEF;
const int ZOO_DELETED_EVENT = DELETED_EVENT_DEF;
const int ZOO_CHANGED_EVENT = CHANGED_EVENT_DEF;
const int ZOO_CHILD_EVENT = CHILD_EVENT_DEF;
const int ZOO_SESSION_EVENT = SESSION_EVENT_DEF;
const int ZOO_NOTWATCHING_EVENT = NOTWATCHING_EVENT_DEF;
static __attribute__ ((unused)) const char* watcherEvent2String(int ev){
switch(ev){
case 0:
return "ZOO_ERROR_EVENT";
case CREATED_EVENT_DEF:
return "ZOO_CREATED_EVENT";
case DELETED_EVENT_DEF:
return "ZOO_DELETED_EVENT";
case CHANGED_EVENT_DEF:
return "ZOO_CHANGED_EVENT";
case CHILD_EVENT_DEF:
return "ZOO_CHILD_EVENT";
case SESSION_EVENT_DEF:
return "ZOO_SESSION_EVENT";
case NOTWATCHING_EVENT_DEF:
return "ZOO_NOTWATCHING_EVENT";
}
return "INVALID_EVENT";
}
const int ZOO_PERM_READ = 1 << 0;
const int ZOO_PERM_WRITE = 1 << 1;
const int ZOO_PERM_CREATE = 1 << 2;
const int ZOO_PERM_DELETE = 1 << 3;
const int ZOO_PERM_ADMIN = 1 << 4;
const int ZOO_PERM_ALL = 0x1f;
struct Id ZOO_ANYONE_ID_UNSAFE = {"world", "anyone"};
struct Id ZOO_AUTH_IDS = {"auth", ""};
static struct ACL _OPEN_ACL_UNSAFE_ACL[] = {{0x1f, {"world", "anyone"}}};
static struct ACL _READ_ACL_UNSAFE_ACL[] = {{0x01, {"world", "anyone"}}};
static struct ACL _CREATOR_ALL_ACL_ACL[] = {{0x1f, {"auth", ""}}};
struct ACL_vector ZOO_OPEN_ACL_UNSAFE = { 1, _OPEN_ACL_UNSAFE_ACL};
struct ACL_vector ZOO_READ_ACL_UNSAFE = { 1, _READ_ACL_UNSAFE_ACL};
struct ACL_vector ZOO_CREATOR_ALL_ACL = { 1, _CREATOR_ALL_ACL_ACL};
#define COMPLETION_WATCH -1
#define COMPLETION_VOID 0
#define COMPLETION_STAT 1
#define COMPLETION_DATA 2
#define COMPLETION_STRINGLIST 3
#define COMPLETION_STRINGLIST_STAT 4
#define COMPLETION_ACLLIST 5
#define COMPLETION_STRING 6
#define COMPLETION_MULTI 7
#define COMPLETION_STRING_STAT 8
typedef struct _auth_completion_list {
void_completion_t completion;
const char *auth_data;
struct _auth_completion_list *next;
} auth_completion_list_t;
typedef struct completion {
int type; /* one of COMPLETION_* values above */
union {
void_completion_t void_result;
stat_completion_t stat_result;
data_completion_t data_result;
strings_completion_t strings_result;
strings_stat_completion_t strings_stat_result;
acl_completion_t acl_result;
string_completion_t string_result;
string_stat_completion_t string_stat_result;
struct watcher_object_list *watcher_result;
};
completion_head_t clist; /* For multi-op */
} completion_t;
typedef struct _completion_list {
int xid;
completion_t c;
const void *data;
buffer_list_t *buffer;
struct _completion_list *next;
watcher_registration_t* watcher;
watcher_deregistration_t* watcher_deregistration;
} completion_list_t;
const char*err2string(int err);
static inline int calculate_interval(const struct timeval *start,
const struct timeval *end);
static int queue_session_event(zhandle_t *zh, int state);
static const char* format_endpoint_info(const struct sockaddr_storage* ep);
/* deserialize forward declarations */
static void deserialize_response(zhandle_t *zh, int type, int xid, int failed, int rc, completion_list_t *cptr, struct iarchive *ia);
static int deserialize_multi(zhandle_t *zh, int xid, completion_list_t *cptr, struct iarchive *ia);
/* completion routine forward declarations */
static int add_completion(zhandle_t *zh, int xid, int completion_type,
const void *dc, const void *data, int add_to_front,
watcher_registration_t* wo, completion_head_t *clist);
static int add_completion_deregistration(zhandle_t *zh, int xid,
int completion_type, const void *dc, const void *data,
int add_to_front, watcher_deregistration_t* wo,
completion_head_t *clist);
static int do_add_completion(zhandle_t *zh, const void *dc, completion_list_t *c,
int add_to_front);
static completion_list_t* create_completion_entry(zhandle_t *zh, int xid, int completion_type,
const void *dc, const void *data, watcher_registration_t* wo,
completion_head_t *clist);
static completion_list_t* create_completion_entry_deregistration(zhandle_t *zh,
int xid, int completion_type, const void *dc, const void *data,
watcher_deregistration_t* wo, completion_head_t *clist);
static completion_list_t* do_create_completion_entry(zhandle_t *zh,
int xid, int completion_type, const void *dc, const void *data,
watcher_registration_t* wo, completion_head_t *clist,
watcher_deregistration_t* wdo);
static void destroy_completion_entry(completion_list_t* c);
static void queue_completion_nolock(completion_head_t *list, completion_list_t *c,
int add_to_front);
static void queue_completion(completion_head_t *list, completion_list_t *c,
int add_to_front);
static int handle_socket_error_msg(zhandle_t *zh, int line, const char *func, int rc,
const char* format,...);
static void cleanup_bufs(zhandle_t *zh,int callCompletion,int rc);
static int disable_conn_permute=0; // permute enabled by default
static struct sockaddr_storage *addr_rw_server = 0;
static void *SYNCHRONOUS_MARKER = (void*)&SYNCHRONOUS_MARKER;
static int isValidPath(const char* path, const int mode);
#ifdef HAVE_OPENSSL_H
static int init_ssl_for_handler(zhandle_t *zh);
static int init_ssl_for_socket(zsock_t *fd, zhandle_t *zh, int fail_on_error);
#endif
static int aremove_watches(
zhandle_t *zh, const char *path, ZooWatcherType wtype,
watcher_fn watcher, void *watcherCtx, int local,
void_completion_t *completion, const void *data, int all);
#ifdef THREADED
static void process_sync_completion(zhandle_t *zh,
completion_list_t *cptr,
struct sync_completion *sc,
struct iarchive *ia);
static int remove_watches(
zhandle_t *zh, const char *path, ZooWatcherType wtype,
watcher_fn watcher, void *watcherCtx, int local, int all);
#endif
#ifdef _WIN32
typedef SOCKET socket_t;
typedef int sendsize_t;
#define SEND_FLAGS 0
#else
#ifdef __APPLE__
#define SEND_FLAGS SO_NOSIGPIPE
#endif
#ifdef __linux__
#define SEND_FLAGS MSG_NOSIGNAL
#endif
#ifndef SEND_FLAGS
#define SEND_FLAGS 0
#endif
typedef int socket_t;
typedef ssize_t sendsize_t;
#endif
static void zookeeper_set_sock_nodelay(zhandle_t *, socket_t);
static void zookeeper_set_sock_noblock(zhandle_t *, socket_t);
static void zookeeper_set_sock_timeout(zhandle_t *, socket_t, int);
static socket_t zookeeper_connect(zhandle_t *, struct sockaddr_storage *, socket_t);
/*
* return 1 if zh has a SASL client configured, 0 otherwise.
*/
static int has_sasl_client(zhandle_t* zh)
{
#ifdef HAVE_CYRUS_SASL_H
return zh->sasl_client != NULL;
#else /* !HAVE_CYRUS_SASL_H */
return 0;
#endif /* HAVE_CYRUS_SASL_H */
}
/*
* return 1 if zh has a SASL client performing authentication, 0 otherwise.
*/
static int is_sasl_auth_in_progress(zhandle_t* zh)
{
#ifdef HAVE_CYRUS_SASL_H
return zh->sasl_client && zh->sasl_client->state == ZOO_SASL_INTERMEDIATE;
#else /* !HAVE_CYRUS_SASL_H */
return 0;
#endif /* HAVE_CYRUS_SASL_H */
}
/*
* Extract the type field (ZOO_*_OP) of a serialized RequestHeader.
*
* (This is not the most efficient way of fetching 4 bytes, but it is
* currently only used during SASL negotiation.)
*
* \param buffer the buffer to extract the request type from. Must
* start with a serialized RequestHeader;
* \param len the buffer length. Must be positive.
* \param out_type out parameter; pointer to the location where the
* extracted type is to be stored. Cannot be NULL.
* \return ZOK on success, or < 0 if something went wrong
*/
static int extract_request_type(char *buffer, int len, int32_t *out_type)
{
struct iarchive *ia;
struct RequestHeader h;
int rc;
ia = create_buffer_iarchive(buffer, len);
rc = ia ? ZOK : ZSYSTEMERROR;
rc = rc < 0 ? rc : deserialize_RequestHeader(ia, "header", &h);
deallocate_RequestHeader(&h);
if (ia) {
close_buffer_iarchive(&ia);
}
*out_type = h.type;
return rc;
}
#ifndef THREADED
/*
* abort due to the use of a sync api in a singlethreaded environment
*/
static void abort_singlethreaded(zhandle_t *zh)
{
LOG_ERROR(LOGCALLBACK(zh), "Sync completion used without threads");
abort();
}
#endif /* THREADED */
static ssize_t zookeeper_send(zsock_t *fd, const void* buf, size_t len)
{
#ifdef HAVE_OPENSSL_H
if (fd->ssl_sock)
return (ssize_t)SSL_write(fd->ssl_sock, buf, (int)len);
#endif
return send(fd->sock, buf, len, SEND_FLAGS);
}
static ssize_t zookeeper_recv(zsock_t *fd, void *buf, size_t len, int flags)
{
#ifdef HAVE_OPENSSL_H
if (fd->ssl_sock)
return (ssize_t)SSL_read(fd->ssl_sock, buf, (int)len);
#endif
return recv(fd->sock, buf, len, flags);
}
/**
* Get the system time.
*
* If the monotonic clock is available, we use that. The monotonic clock does
* not change when the wall-clock time is adjusted by NTP or the system
* administrator. The monotonic clock returns a value which is monotonically
* increasing.
*
* If POSIX monotonic clocks are not available, we fall back on the wall-clock.
*
* @param tv (out param) The time.
*/
void get_system_time(struct timeval *tv)
{
int ret;
#ifdef __MACH__ // OS X
clock_serv_t cclock;
mach_timespec_t mts;
ret = host_get_clock_service(mach_host_self(), SYSTEM_CLOCK, &cclock);
if (!ret) {
ret += clock_get_time(cclock, &mts);
ret += mach_port_deallocate(mach_task_self(), cclock);
if (!ret) {
tv->tv_sec = mts.tv_sec;
tv->tv_usec = mts.tv_nsec / 1000;
}
}
if (ret) {
// Default to gettimeofday in case of failure.
ret = gettimeofday(tv, NULL);
}
#elif defined CLOCK_MONOTONIC_RAW
// On Linux, CLOCK_MONOTONIC is affected by ntp slew but CLOCK_MONOTONIC_RAW
// is not. We want the non-slewed (constant rate) CLOCK_MONOTONIC_RAW if it
// is available.
struct timespec ts = { 0 };
ret = clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
tv->tv_sec = ts.tv_sec;
tv->tv_usec = ts.tv_nsec / 1000;
#elif _POSIX_MONOTONIC_CLOCK
struct timespec ts = { 0 };
ret = clock_gettime(CLOCK_MONOTONIC, &ts);
tv->tv_sec = ts.tv_sec;
tv->tv_usec = ts.tv_nsec / 1000;
#elif _WIN32
LARGE_INTEGER counts, countsPerSecond, countsPerMicrosecond;
if (QueryPerformanceFrequency(&countsPerSecond) &&
QueryPerformanceCounter(&counts)) {
countsPerMicrosecond.QuadPart = countsPerSecond.QuadPart / 1000000;
tv->tv_sec = (long)(counts.QuadPart / countsPerSecond.QuadPart);
tv->tv_usec = (long)((counts.QuadPart % countsPerSecond.QuadPart) /
countsPerMicrosecond.QuadPart);
ret = 0;
} else {
ret = gettimeofday(tv, NULL);
}
#else
ret = gettimeofday(tv, NULL);
#endif
if (ret) {
abort();
}
}
const void *zoo_get_context(zhandle_t *zh)
{
return zh->context;
}
void zoo_set_context(zhandle_t *zh, void *context)
{
if (zh != NULL) {
zh->context = context;
}
}
int zoo_recv_timeout(zhandle_t *zh)
{
return zh->recv_timeout;
}
/** these functions are thread unsafe, so make sure that
zoo_lock_auth is called before you access them **/
static auth_info* get_last_auth(auth_list_head_t *auth_list) {
auth_info *element;
element = auth_list->auth;
if (element == NULL) {
return NULL;
}
while (element->next != NULL) {
element = element->next;
}
return element;
}
static void free_auth_completion(auth_completion_list_t *a_list) {
auth_completion_list_t *tmp, *ftmp;
if (a_list == NULL) {
return;
}
tmp = a_list->next;
while (tmp != NULL) {
ftmp = tmp;
tmp = tmp->next;
ftmp->completion = NULL;
ftmp->auth_data = NULL;
free(ftmp);
}
a_list->completion = NULL;
a_list->auth_data = NULL;
a_list->next = NULL;
return;
}
static void add_auth_completion(auth_completion_list_t* a_list, void_completion_t* completion,
const char *data) {
auth_completion_list_t *element;
auth_completion_list_t *n_element;
element = a_list;
if (a_list->completion == NULL) {
//this is the first element
a_list->completion = *completion;
a_list->next = NULL;
a_list->auth_data = data;
return;
}
while (element->next != NULL) {
element = element->next;
}
n_element = (auth_completion_list_t*) malloc(sizeof(auth_completion_list_t));
n_element->next = NULL;
n_element->completion = *completion;
n_element->auth_data = data;
element->next = n_element;
return;
}
static void get_auth_completions(auth_list_head_t *auth_list, auth_completion_list_t *a_list) {
auth_info *element;
element = auth_list->auth;
if (element == NULL) {
return;
}
while (element) {
if (element->completion) {
add_auth_completion(a_list, &element->completion, element->data);
}
element->completion = NULL;
element = element->next;
}
return;
}
static void add_last_auth(auth_list_head_t *auth_list, auth_info *add_el) {
auth_info *element;
element = auth_list->auth;
if (element == NULL) {
//first element in the list
auth_list->auth = add_el;
return;
}
while (element->next != NULL) {
element = element->next;
}
element->next = add_el;
return;
}
static void init_auth_info(auth_list_head_t *auth_list)
{
auth_list->auth = NULL;
}
static void mark_active_auth(zhandle_t *zh) {
auth_list_head_t auth_h = zh->auth_h;
auth_info *element;
if (auth_h.auth == NULL) {
return;
}
element = auth_h.auth;
while (element != NULL) {
element->state = 1;
element = element->next;
}
}
static void free_auth_info(auth_list_head_t *auth_list)
{
auth_info *auth = auth_list->auth;
while (auth != NULL) {
auth_info* old_auth = NULL;
if(auth->scheme!=NULL)
free(auth->scheme);
deallocate_Buffer(&auth->auth);
old_auth = auth;
auth = auth->next;
free(old_auth);
}
init_auth_info(auth_list);
}
int is_unrecoverable(zhandle_t *zh)
{
return (zh->state<0)? ZINVALIDSTATE: ZOK;
}
zk_hashtable *exists_result_checker(zhandle_t *zh, int rc)
{
if (rc == ZOK) {
return zh->active_node_watchers;
} else if (rc == ZNONODE) {
return zh->active_exist_watchers;
}
return 0;
}
zk_hashtable *data_result_checker(zhandle_t *zh, int rc)
{
return rc==ZOK ? zh->active_node_watchers : 0;
}
zk_hashtable *child_result_checker(zhandle_t *zh, int rc)
{
return rc==ZOK ? zh->active_child_watchers : 0;
}
void close_zsock(zsock_t *fd)
{
if (fd->sock != -1) {
#ifdef HAVE_OPENSSL_H
if (fd->ssl_sock) {
SSL_free(fd->ssl_sock);
fd->ssl_sock = NULL;
SSL_CTX_free(fd->ssl_ctx);
fd->ssl_ctx = NULL;
}
#endif
close(fd->sock);
fd->sock = -1;
}
}
/**
* Frees and closes everything associated with a handle,
* including the handle itself.
*/
static void destroy(zhandle_t *zh)
{
if (zh == NULL) {
return;
}
/* call any outstanding completions with a special error code */
cleanup_bufs(zh,1,ZCLOSING);
if (process_async(zh->outstanding_sync)) {
process_completions(zh);
}
if (zh->hostname != 0) {
free(zh->hostname);
zh->hostname = NULL;
}
if (zh->fd->sock != -1) {
close_zsock(zh->fd);
memset(&zh->addr_cur, 0, sizeof(zh->addr_cur));
zh->state = 0;
}
addrvec_free(&zh->addrs);
if (zh->chroot != NULL) {
free(zh->chroot);
zh->chroot = NULL;
}
#ifdef HAVE_OPENSSL_H
if (zh->fd->cert) {
free(zh->fd->cert->certstr);
free(zh->fd->cert);
zh->fd->cert = NULL;
}
#endif
free_auth_info(&zh->auth_h);
destroy_zk_hashtable(zh->active_node_watchers);
destroy_zk_hashtable(zh->active_exist_watchers);
destroy_zk_hashtable(zh->active_child_watchers);
addrvec_free(&zh->addrs_old);
addrvec_free(&zh->addrs_new);
#ifdef HAVE_CYRUS_SASL_H
if (zh->sasl_client) {
zoo_sasl_client_destroy(zh->sasl_client);
free(zh->sasl_client);
zh->sasl_client = NULL;
}
#endif /* HAVE_CYRUS_SASL_H */
}
static void setup_random()
{
#ifndef _WIN32 // TODO: better seed
int seed;
int fd = open("/dev/urandom", O_RDONLY);
if (fd == -1) {
seed = getpid();
} else {
int seed_len = 0;
/* Enter a loop to fill in seed with random data from /dev/urandom.
* This is done in a loop so that we can safely handle short reads
* which can happen due to signal interruptions.
*/
while (seed_len < sizeof(seed)) {
/* Assert we either read something or we were interrupted due to a
* signal (errno == EINTR) in which case we need to retry.
*/
int rc = read(fd, &seed + seed_len, sizeof(seed) - seed_len);
assert(rc > 0 || errno == EINTR);
if (rc > 0) {
seed_len += rc;
}
}
close(fd);
}
srandom(seed);
srand48(seed);
#endif
}
#ifndef __CYGWIN__
/**
* get the errno from the return code
* of get addrinfo. Errno is not set
* with the call to getaddrinfo, so thats
* why we have to do this.
*/
static int getaddrinfo_errno(int rc) {
switch(rc) {
case EAI_NONAME:
// ZOOKEEPER-1323 EAI_NODATA and EAI_ADDRFAMILY are deprecated in FreeBSD.
#if defined EAI_NODATA && EAI_NODATA != EAI_NONAME
case EAI_NODATA:
#endif
return ENOENT;
case EAI_MEMORY:
return ENOMEM;
default:
return EINVAL;
}
}
#endif
/**
* Count the number of hosts in the connection host string. This assumes it's
* a well-formed connection string whereby each host is separated by a comma.
*/
static int count_hosts(char *hosts)
{
uint32_t count = 0;
char *loc = hosts;
if (!hosts || strlen(hosts) == 0) {
return 0;
}
while ((loc = strchr(loc, ','))) {
count++;
loc+=1;
}
return count+1;
}
/**
* Resolve hosts and populate provided address vector with shuffled results.
* The contents of the provided address vector will be initialized to an
* empty state.
*/
static int resolve_hosts(const zhandle_t *zh, const char *hosts_in, addrvec_t *avec)
{
int rc = ZOK;
char *host = NULL;
char *hosts = NULL;
int num_hosts = 0;
char *strtok_last = NULL;
if (zh == NULL || hosts_in == NULL || avec == NULL) {
return ZBADARGUMENTS;
}
// initialize address vector
addrvec_init(avec);
hosts = strdup(hosts_in);
if (hosts == NULL) {
LOG_ERROR(LOGCALLBACK(zh), "out of memory");
errno=ENOMEM;
rc=ZSYSTEMERROR;
goto fail;
}
num_hosts = count_hosts(hosts);
if (num_hosts == 0) {
free(hosts);
return ZOK;
}
// Allocate list inside avec
rc = addrvec_alloc_capacity(avec, num_hosts);
if (rc != 0) {
LOG_ERROR(LOGCALLBACK(zh), "out of memory");
errno=ENOMEM;
rc=ZSYSTEMERROR;
goto fail;
}
host = strtok_r(hosts, ",", &strtok_last);
while(host) {
char *port_spec = strrchr(host, ':');
char *end_port_spec;
int port;
if (!port_spec) {
LOG_ERROR(LOGCALLBACK(zh), "no port in %s", host);
errno=EINVAL;
rc=ZBADARGUMENTS;
goto fail;
}
*port_spec = '\0';
port_spec++;
port = strtol(port_spec, &end_port_spec, 0);
if (!*port_spec || *end_port_spec || port == 0) {
LOG_ERROR(LOGCALLBACK(zh), "invalid port in %s", host);
errno=EINVAL;
rc=ZBADARGUMENTS;
goto fail;
}
#if defined(__CYGWIN__)
// sadly CYGWIN doesn't have getaddrinfo
// but happily gethostbyname is threadsafe in windows
{
struct hostent *he;
char **ptr;
struct sockaddr_in *addr4;
he = gethostbyname(host);
if (!he) {
LOG_ERROR(LOGCALLBACK(zh), "could not resolve %s", host);
errno=ENOENT;
rc=ZBADARGUMENTS;
goto fail;
}
// Setup the address array
for(ptr = he->h_addr_list;*ptr != 0; ptr++) {
if (addrs->count == addrs->capacity) {
rc = addrvec_grow_default(addrs);
if (rc != 0) {
LOG_ERROR(LOGCALLBACK(zh), "out of memory");
errno=ENOMEM;
rc=ZSYSTEMERROR;
goto fail;
}
}
addr = &addrs->list[addrs->count];
addr4 = (struct sockaddr_in*)addr;
addr->ss_family = he->h_addrtype;
if (addr->ss_family == AF_INET) {
addr4->sin_port = htons(port);
memset(&addr4->sin_zero, 0, sizeof(addr4->sin_zero));
memcpy(&addr4->sin_addr, *ptr, he->h_length);
zh->addrs.count++;
}
#if defined(AF_INET6)
else if (addr->ss_family == AF_INET6) {
struct sockaddr_in6 *addr6;
addr6 = (struct sockaddr_in6*)addr;
addr6->sin6_port = htons(port);
addr6->sin6_scope_id = 0;
addr6->sin6_flowinfo = 0;
memcpy(&addr6->sin6_addr, *ptr, he->h_length);
zh->addrs.count++;
}
#endif
else {
LOG_WARN(LOGCALLBACK(zh), "skipping unknown address family %x for %s",
addr->ss_family, hosts_in);
}
}
host = strtok_r(0, ",", &strtok_last);
}
#else
{
struct addrinfo hints, *res, *res0;
memset(&hints, 0, sizeof(hints));
#ifdef AI_ADDRCONFIG
hints.ai_flags = AI_ADDRCONFIG;
#else
hints.ai_flags = 0;
#endif
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
while(isspace(*host) && host != strtok_last)
host++;
if ((rc = getaddrinfo(host, port_spec, &hints, &res0)) != 0) {
//bug in getaddrinfo implementation when it returns
//EAI_BADFLAGS or EAI_ADDRFAMILY with AF_UNSPEC and
// ai_flags as AI_ADDRCONFIG
#ifdef AI_ADDRCONFIG
if ((hints.ai_flags == AI_ADDRCONFIG) &&
// ZOOKEEPER-1323 EAI_NODATA and EAI_ADDRFAMILY are deprecated in FreeBSD.
#ifdef EAI_ADDRFAMILY
((rc ==EAI_BADFLAGS) || (rc == EAI_ADDRFAMILY))) {
#else
(rc == EAI_BADFLAGS)) {
#endif
//reset ai_flags to null
hints.ai_flags = 0;
//retry getaddrinfo
rc = getaddrinfo(host, port_spec, &hints, &res0);
}
#endif
if (rc != 0) {
errno = getaddrinfo_errno(rc);
#ifdef _WIN32
LOG_ERROR(LOGCALLBACK(zh), "Win32 message: %s\n", gai_strerror(rc));
#elif __linux__ && __GNUC__
LOG_ERROR(LOGCALLBACK(zh), "getaddrinfo: %s\n", gai_strerror(rc));
#else
LOG_ERROR(LOGCALLBACK(zh), "getaddrinfo: %s\n", strerror(errno));
#endif
rc=ZSYSTEMERROR;
goto next;
}
}
for (res = res0; res; res = res->ai_next) {
// Expand address list if needed
if (avec->count == avec->capacity) {
rc = addrvec_grow_default(avec);
if (rc != 0) {
LOG_ERROR(LOGCALLBACK(zh), "out of memory");
errno=ENOMEM;
rc=ZSYSTEMERROR;
goto fail;
}
}
// Copy addrinfo into address list
switch (res->ai_family) {
case AF_INET:
#if defined(AF_INET6)
case AF_INET6:
#endif
addrvec_append_addrinfo(avec, res);
break;
default:
LOG_WARN(LOGCALLBACK(zh), "skipping unknown address family %x for %s",
res->ai_family, hosts_in);
break;
}
}
freeaddrinfo(res0);
next:
host = strtok_r(0, ",", &strtok_last);
}
#endif
}
if (avec->count == 0) {
rc = ZSYSTEMERROR; // not a single host resolved
goto fail;
}
free(hosts);
if(!disable_conn_permute){
setup_random();
addrvec_shuffle(avec);
}
return ZOK;
fail:
addrvec_free(avec);
if (hosts) {
free(hosts);
hosts = NULL;
}
return rc;
}
/**
* Updates the list of servers and determine if changing connections is necessary.
* Permutes server list for proper load balancing.
*
* Changing connections is necessary if one of the following holds:
* a) the server this client is currently connected is not in new address list.
* Otherwise (if currentHost is in the new list):
* b) the number of servers in the cluster is increasing - in this case the load
* on currentHost should decrease, which means that SOME of the clients
* connected to it will migrate to the new servers. The decision whether this
* client migrates or not is probabilistic so that the expected number of
* clients connected to each server is the same.
*
* If reconfig is set to true, the function sets pOld and pNew that correspond
* to the probability to migrate to ones of the new servers or one of the old
* servers (migrating to one of the old servers is done only if our client's
* currentHost is not in new list).
*
* See zoo_cycle_next_server for the selection logic.
*
* \param ref_time an optional "reference time," used to determine if
* resolution can be skipped in accordance to the delay set by \ref
* zoo_set_servers_resolution_delay. Passing NULL prevents skipping.
*
* See {@link https://issues.apache.org/jira/browse/ZOOKEEPER-1355} for the
* protocol and its evaluation,
*/
int update_addrs(zhandle_t *zh, const struct timeval *ref_time)
{
int rc = ZOK;
char *hosts = NULL;
uint32_t num_old = 0;
uint32_t num_new = 0;
uint32_t i = 0;
int found_current = 0;
addrvec_t resolved = { 0 };
// Verify we have a valid handle
if (zh == NULL) {
return ZBADARGUMENTS;
}
// zh->hostname should always be set
if (zh->hostname == NULL)
{
return ZSYSTEMERROR;
}
// NOTE: guard access to {hostname, addr_cur, addrs, addrs_old, addrs_new, last_resolve, resolve_delay_ms}
lock_reconfig(zh);
// Check if we are due for a host name resolution. (See
// zoo_set_servers_resolution_delay. The answer is always "yes"
// if no reference is provided or the file descriptor is invalid.)
if (ref_time && zh->fd->sock != -1) {
int do_resolve;
if (zh->resolve_delay_ms <= 0) {
// -1 disables, 0 means unconditional. Fail safe.
do_resolve = zh->resolve_delay_ms != -1;
} else {
int elapsed_ms = calculate_interval(&zh->last_resolve, ref_time);
// Include < 0 in case of overflow, or if we are not
// backed by a monotonic clock.
do_resolve = elapsed_ms > zh->resolve_delay_ms || elapsed_ms < 0;
}
if (!do_resolve) {
goto finish;
}
}
// Copy zh->hostname for local use
hosts = strdup(zh->hostname);
if (hosts == NULL) {
rc = ZSYSTEMERROR;
goto finish;
}
rc = resolve_hosts(zh, hosts, &resolved);
if (rc != ZOK)
{
goto finish;
}
// Unconditionally note last resolution time.
if (ref_time) {
zh->last_resolve = *ref_time;
} else {
get_system_time(&zh->last_resolve);
}
// If the addrvec list is identical to last time we ran don't do anything
if (addrvec_eq(&zh->addrs, &resolved))
{
goto finish;
}
// Is the server we're connected to in the new resolved list?
found_current = addrvec_contains(&resolved, &zh->addr_cur);
// Clear out old and new address lists
zh->reconfig = 1;
addrvec_free(&zh->addrs_old);
addrvec_free(&zh->addrs_new);
// Divide server list into addrs_old if in previous list and addrs_new if not
for (i = 0; i < resolved.count; i++)
{
struct sockaddr_storage *resolved_address = &resolved.data[i];
if (addrvec_contains(&zh->addrs, resolved_address))
{
rc = addrvec_append(&zh->addrs_old, resolved_address);
if (rc != ZOK)
{
goto finish;
}
}
else {
rc = addrvec_append(&zh->addrs_new, resolved_address);
if (rc != ZOK)
{
goto finish;
}
}
}
num_old = zh->addrs_old.count;
num_new = zh->addrs_new.count;
// Number of servers increased
if (num_old + num_new > zh->addrs.count)
{
if (found_current) {
// my server is in the new config, but load should be decreased.
// Need to decide if the client is moving to one of the new servers
if (drand48() <= (1 - ((double)zh->addrs.count) / (num_old + num_new))) {
zh->pNew = 1;
zh->pOld = 0;
} else {
// do nothing special -- stay with the current server
zh->reconfig = 0;
}
} else {
// my server is not in the new config, and load on old servers must
// be decreased, so connect to one of the new servers
zh->pNew = 1;
zh->pOld = 0;
}
}
// Number of servers stayed the same or decreased
else {
if (found_current) {
// my server is in the new config, and load should be increased, so
// stay with this server and do nothing special
zh->reconfig = 0;
} else {
zh->pOld = ((double) (num_old * (zh->addrs.count - (num_old + num_new)))) / ((num_old + num_new) * (zh->addrs.count - num_old));
zh->pNew = 1 - zh->pOld;
}
}
addrvec_free(&zh->addrs);
zh->addrs = resolved;
// If we need to do a reconfig and we're currently connected to a server,
// then force close that connection so on next interest() call we'll make a
// new connection
if (zh->reconfig == 1 && zh->fd->sock != -1)
{
close_zsock(zh->fd);
zh->state = ZOO_NOTCONNECTED_STATE;
}
finish:
unlock_reconfig(zh);
// If we short-circuited out and never assigned resolved to zh->addrs then we
// need to free resolved to avoid a memleak.
if (resolved.data && zh->addrs.data != resolved.data)
{
addrvec_free(&resolved);
}
if (hosts) {
free(hosts);
hosts = NULL;
}
return rc;
}
const clientid_t *zoo_client_id(zhandle_t *zh)
{
return &zh->client_id;
}
static void null_watcher_fn(zhandle_t* p1, int p2, int p3,const char* p4,void*p5){}
watcher_fn zoo_set_watcher(zhandle_t *zh,watcher_fn newFn)
{
watcher_fn oldWatcher=zh->watcher;
if (newFn) {
zh->watcher = newFn;
} else {
zh->watcher = null_watcher_fn;
}
return oldWatcher;
}
struct sockaddr* zookeeper_get_connected_host(zhandle_t *zh,
struct sockaddr *addr, socklen_t *addr_len)
{
if (zh->state!=ZOO_CONNECTED_STATE) {
return NULL;
}
if (getpeername(zh->fd->sock, addr, addr_len)==-1) {
return NULL;
}
return addr;
}
static void log_env(zhandle_t *zh) {
char buf[2048];
#ifdef HAVE_SYS_UTSNAME_H
struct utsname utsname;
#endif
#if defined(HAVE_GETUID) && defined(HAVE_GETPWUID_R)
struct passwd pw;
struct passwd *pwp = NULL;
uid_t uid = 0;
#endif
LOG_INFO(LOGCALLBACK(zh), "Client environment:zookeeper.version=%s", PACKAGE_STRING);
#ifdef HAVE_GETHOSTNAME
gethostname(buf, sizeof(buf));
LOG_INFO(LOGCALLBACK(zh), "Client environment:host.name=%s", buf);
#else
LOG_INFO(LOGCALLBACK(zh), "Client environment:host.name=");
#endif
#ifdef HAVE_SYS_UTSNAME_H
uname(&utsname);
LOG_INFO(LOGCALLBACK(zh), "Client environment:os.name=%s", utsname.sysname);
LOG_INFO(LOGCALLBACK(zh), "Client environment:os.arch=%s", utsname.release);
LOG_INFO(LOGCALLBACK(zh), "Client environment:os.version=%s", utsname.version);
#else
LOG_INFO(LOGCALLBACK(zh), "Client environment:os.name=");
LOG_INFO(LOGCALLBACK(zh), "Client environment:os.arch=");
LOG_INFO(LOGCALLBACK(zh), "Client environment:os.version=");
#endif
#ifdef HAVE_GETLOGIN
LOG_INFO(LOGCALLBACK(zh), "Client environment:user.name=%s", getlogin());
#else
LOG_INFO(LOGCALLBACK(zh), "Client environment:user.name=");
#endif
#if defined(HAVE_GETUID) && defined(HAVE_GETPWUID_R)
uid = getuid();
if (!getpwuid_r(uid, &pw, buf, sizeof(buf), &pwp) && pwp) {
LOG_INFO(LOGCALLBACK(zh), "Client environment:user.home=%s", pw.pw_dir);
} else {
LOG_INFO(LOGCALLBACK(zh), "Client environment:user.home=");
}
#else
LOG_INFO(LOGCALLBACK(zh), "Client environment:user.home=");
#endif
#ifdef HAVE_GETCWD
if (!getcwd(buf, sizeof(buf))) {
LOG_INFO(LOGCALLBACK(zh), "Client environment:user.dir=
