You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@qpid.apache.org by ro...@apache.org on 2017/01/10 15:58:32 UTC
[11/55] [partial] qpid-proton-j git commit: PROTON-1385: retain
proton-j content only, the rest remains in the other repo at:
https://git-wip-us.apache.org/repos/asf/qpid-proton.git
http://git-wip-us.apache.org/repos/asf/qpid-proton-j/blob/2f85988e/proton-c/include/proton/messenger.h
----------------------------------------------------------------------
diff --git a/proton-c/include/proton/messenger.h b/proton-c/include/proton/messenger.h
deleted file mode 100644
index 74c3fc6..0000000
--- a/proton-c/include/proton/messenger.h
+++ /dev/null
@@ -1,1060 +0,0 @@
-#ifndef PROTON_MESSENGER_H
-#define PROTON_MESSENGER_H 1
-
-/*
- *
- * 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 <proton/import_export.h>
-#include <proton/message.h>
-#include <proton/selectable.h>
-#include <proton/link.h>
-#include <proton/transport.h>
-#include <proton/ssl.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @file
- *
- * @copybrief messenger
- *
- * @deprecated
- *
- * @addtogroup messenger
- * @{
- */
-
-/**
- * A ::pn_messenger_t provides a high level interface for sending and
- * receiving messages (See ::pn_message_t).
- *
- * Every messenger contains a single logical queue of incoming
- * messages and a single logical queue of outgoing messages. The
- * messages in these queues may be destined for, or originate from, a
- * variety of addresses.
- *
- * The messenger interface is single-threaded. All methods except one
- * (::pn_messenger_interrupt()) are intended to be used by one thread
- * at a time.
- *
- *
- * Address Syntax
- * ==============
- *
- * An address has the following form::
- *
- * [ amqp[s]:// ] [user[:password]@] domain [/[name]]
- *
- * Where domain can be one of::
- *
- * host | host:port | ip | ip:port | name
- *
- * The following are valid examples of addresses:
- *
- * - example.org
- * - example.org:1234
- * - amqp://example.org
- * - amqps://example.org
- * - example.org/incoming
- * - amqps://example.org/outgoing
- * - amqps://fred:trustno1@example.org
- * - 127.0.0.1:1234
- * - amqps://127.0.0.1:1234
- *
- * Sending & Receiving Messages
- * ============================
- *
- * The messenger API works in conjuction with the ::pn_message_t API.
- * A ::pn_message_t is a mutable holder of message content.
- *
- * The ::pn_messenger_put() operation copies content from the supplied
- * ::pn_message_t to the outgoing queue, and may send queued messages
- * if it can do so without blocking. The ::pn_messenger_send()
- * operation blocks until it has sent the requested number of
- * messages, or until a timeout interrupts the attempt.
- *
- *
- * pn_messenger_t *messenger = pn_messenger(NULL);
- * pn_message_t *message = pn_message();
- * char subject[1024];
- * for (int i = 0; i < 3; i++) {
- * pn_message_set_address(message, "amqp://host/queue");
- * sprintf(subject, "Hello World! %i", i);
- * pn_message_set_subject(message, subject);
- * pn_messenger_put(messenger, message)
- * pn_messenger_send(messenger);
- *
- * Similarly, the ::pn_messenger_recv() method receives messages into
- * the incoming queue, and may block as it attempts to receive up to
- * the requested number of messages, or until the timeout is reached.
- * It may receive fewer than the requested number. The
- * ::pn_messenger_get() method pops the eldest message off the
- * incoming queue and copies its content into the supplied
- * ::pn_message_t object. It will not block.
- *
- *
- * pn_messenger_t *messenger = pn_messenger(NULL);
- * pn_message_t *message = pn_message()
- * pn_messenger_recv(messenger):
- * while (pn_messenger_incoming(messenger) > 0) {
- * pn_messenger_get(messenger, message);
- * printf("%s", message.subject);
- * }
- *
- * Output:
- * Hello World 0
- * Hello World 1
- * Hello World 2
- *
- * The blocking flag allows you to turn off blocking behavior
- * entirely, in which case ::pn_messenger_send() and
- * ::pn_messenger_recv() will do whatever they can without blocking,
- * and then return. You can then look at the number of incoming and
- * outgoing messages to see how much outstanding work still remains.
- *
- * Authentication Mechanims
- * ========================
- *
- * The messenger API authenticates using some specific mechanisms. In prior versions
- * of Proton the only authentication mechanism available was the PLAIN mechanism
- * which transports the user's password over the network unencrypted. The Proton versions
- * 0.10 and newer support other more secure mechanisms which avoid sending the users's
- * password over the network unencrypted. For backwards compatibility the 0.10 version
- * of the messenger API will also allow the use of the unencrypted PLAIN mechanism. From the
- * 0.11 version and onwards you will need to set the flag PN_FLAGS_ALLOW_INSECURE_MECHS to
- * carry on using the unencrypted PLAIN mechanism.
- *
- * The code for this looks like:
- *
- * ...
- * pn_messenger_set_flags(messenger, PN_FLAGS_ALLOW_INSECURE_MECHS);
- * ...
- *
- * Note that the use of the PLAIN mechanism over an SSL connection is allowed as the
- * password is not sent unencrypted.
- */
-typedef struct pn_messenger_t pn_messenger_t;
-
-/**
- * A subscription is a request for incoming messages.
- *
- * @todo currently the subscription API is under developed, this
- * should allow more explicit control over subscription properties and
- * behaviour
- */
-typedef struct pn_subscription_t pn_subscription_t;
-
-/**
- * Trackers provide a lightweight handle used to track the status of
- * incoming and outgoing deliveries.
- */
-typedef int64_t pn_tracker_t;
-
-/**
- * Describes all the possible states for a message associated with a
- * given tracker.
- */
-typedef enum {
- PN_STATUS_UNKNOWN = 0, /**< The tracker is unknown. */
- PN_STATUS_PENDING = 1, /**< The message is in flight. For outgoing
- messages, use ::pn_messenger_buffered to
- see if it has been sent or not. */
- PN_STATUS_ACCEPTED = 2, /**< The message was accepted. */
- PN_STATUS_REJECTED = 3, /**< The message was rejected. */
- PN_STATUS_RELEASED = 4, /**< The message was released. */
- PN_STATUS_MODIFIED = 5, /**< The message was modified. */
- PN_STATUS_ABORTED = 6, /**< The message was aborted. */
- PN_STATUS_SETTLED = 7 /**< The remote party has settled the message. */
-} pn_status_t;
-
-/**
- * Construct a new ::pn_messenger_t with the given name. The name is
- * global. If a NULL name is supplied, a UUID based name will be
- * chosen.
- *
- * @param[in] name the name of the messenger or NULL
- *
- * @return pointer to a new ::pn_messenger_t
- */
-PNX_EXTERN pn_messenger_t *pn_messenger(const char *name);
-
-/**
- * Get the name of a messenger.
- *
- * @param[in] messenger a messenger object
- * @return the name of the messenger
- */
-PNX_EXTERN const char *pn_messenger_name(pn_messenger_t *messenger);
-
-/**
- * Sets the path that will be used to get the certificate that will be
- * used to identify this messenger to its peers. The validity of the
- * path is not checked by this function.
- *
- * @param[in] messenger the messenger
- * @param[in] certificate a path to a certificate file
- * @return an error code of zero if there is no error
- */
-PNX_EXTERN int pn_messenger_set_certificate(pn_messenger_t *messenger, const char *certificate);
-
-/**
- * Get the certificate path. This value may be set by
- * pn_messenger_set_certificate. The default certificate path is null.
- *
- * @param[in] messenger the messenger
- * @return the certificate file path
- */
-PNX_EXTERN const char *pn_messenger_get_certificate(pn_messenger_t *messenger);
-
-/**
- * Set path to the private key that was used to sign the certificate.
- * See ::pn_messenger_set_certificate
- *
- * @param[in] messenger a messenger object
- * @param[in] private_key a path to a private key file
- * @return an error code of zero if there is no error
- */
-PNX_EXTERN int pn_messenger_set_private_key(pn_messenger_t *messenger, const char *private_key);
-
-/**
- * Gets the private key file for a messenger.
- *
- * @param[in] messenger a messenger object
- * @return the messenger's private key file path
- */
-PNX_EXTERN const char *pn_messenger_get_private_key(pn_messenger_t *messenger);
-
-/**
- * Sets the private key password for a messenger.
- *
- * @param[in] messenger a messenger object
- * @param[in] password the password for the private key file
- *
- * @return an error code of zero if there is no error
- */
-PNX_EXTERN int pn_messenger_set_password(pn_messenger_t *messenger, const char *password);
-
-/**
- * Gets the private key file password for a messenger.
- *
- * @param[in] messenger a messenger object
- * @return password for the private key file
- */
-PNX_EXTERN const char *pn_messenger_get_password(pn_messenger_t *messenger);
-
-/**
- * Sets the trusted certificates database for a messenger.
- *
- * The messenger will use this database to validate the certificate
- * provided by the peer.
- *
- * @param[in] messenger a messenger object
- * @param[in] cert_db a path to the certificates database
- *
- * @return an error code of zero if there is no error
- */
-PNX_EXTERN int pn_messenger_set_trusted_certificates(pn_messenger_t *messenger, const char *cert_db);
-
-/**
- * Gets the trusted certificates database for a messenger.
- *
- * @param[in] messenger a messenger object
- * @return path to the trusted certificates database
- */
-PNX_EXTERN const char *pn_messenger_get_trusted_certificates(pn_messenger_t *messenger);
-
-/**
- * Set the default timeout for a messenger.
- *
- * Any messenger call that blocks during execution will stop blocking
- * and return control when this timeout is reached, if you have set it
- * to a value greater than zero. The timeout is expressed in
- * milliseconds.
- *
- * @param[in] messenger a messenger object
- * @param[in] timeout a new timeout for the messenger, in milliseconds
- * @return an error code or zero if there is no error
- */
-PNX_EXTERN int pn_messenger_set_timeout(pn_messenger_t *messenger, int timeout);
-
-/**
- * Gets the timeout for a messenger object.
- *
- * See ::pn_messenger_set_timeout() for details.
- *
- * @param[in] messenger a messenger object
- * @return the timeout for the messenger, in milliseconds
- */
-PNX_EXTERN int pn_messenger_get_timeout(pn_messenger_t *messenger);
-
-/**
- * Check if a messenger is in blocking mode.
- *
- * @param[in] messenger a messenger object
- * @return true if blocking has been enabled, false otherwise
- */
-PNX_EXTERN bool pn_messenger_is_blocking(pn_messenger_t *messenger);
-
-/**
- * Enable or disable blocking behavior for a messenger during calls to
- * ::pn_messenger_send and ::pn_messenger_recv.
- *
- * @param[in] messenger a messenger object
- * @param[in] blocking the value of the blocking flag
- * @return an error code or zero if there is no error
- */
-PNX_EXTERN int pn_messenger_set_blocking(pn_messenger_t *messenger, bool blocking);
-
-/**
- * Check if a messenger is in passive mode.
- *
- * A messenger that is in passive mode will never attempt to perform
- * I/O internally, but instead will make all internal file descriptors
- * accessible through ::pn_messenger_selectable() to be serviced
- * externally. This can be useful for integrating messenger into an
- * external event loop.
- *
- * @param[in] messenger a messenger object
- * @return true if the messenger is in passive mode, false otherwise
- */
-PNX_EXTERN bool pn_messenger_is_passive(pn_messenger_t *messenger);
-
-/**
- * Set the passive mode for a messenger.
- *
- * See ::pn_messenger_is_passive() for details on passive mode.
- *
- * @param[in] messenger a messenger object
- * @param[in] passive true to enable passive mode, false to disable
- * passive mode
- * @return an error code or zero on success
- */
-PNX_EXTERN int pn_messenger_set_passive(pn_messenger_t *messenger, bool passive);
-
-/** Frees a Messenger.
- *
- * @param[in] messenger the messenger to free (or NULL), no longer
- * valid on return
- */
-PNX_EXTERN void pn_messenger_free(pn_messenger_t *messenger);
-
-/**
- * Get the code for a messenger's most recent error.
- *
- * The error code is initialized to zero at messenger creation. The
- * error number is "sticky" i.e. error codes are not reset to 0 at the
- * end of successful API calls. You can use ::pn_messenger_error to
- * access the messenger's error object and clear explicitly if
- * desired.
- *
- * @param[in] messenger the messenger to check for errors
- * @return an error code or zero if there is no error
- * @see error.h
- */
-PNX_EXTERN int pn_messenger_errno(pn_messenger_t *messenger);
-
-/**
- * Get a messenger's error object.
- *
- * Returns a pointer to a pn_error_t that is valid until the messenger
- * is freed. The pn_error_* API allows you to access the text, error
- * number, and lets you set or clear the error code explicitly.
- *
- * @param[in] messenger the messenger to check for errors
- * @return a pointer to the messenger's error descriptor
- * @see error.h
- */
-PNX_EXTERN pn_error_t *pn_messenger_error(pn_messenger_t *messenger);
-
-/**
- * Get the size of a messenger's outgoing window.
- *
- * The size of the outgoing window limits the number of messages whose
- * status you can check with a tracker. A message enters this window
- * when you call pn_messenger_put on the message. For example, if your
- * outgoing window size is 10, and you call pn_messenger_put 12 times,
- * new status information will no longer be available for the first 2
- * messages.
- *
- * The default outgoing window size is 0.
- *
- * @param[in] messenger a messenger object
- * @return the outgoing window for the messenger
- */
-PNX_EXTERN int pn_messenger_get_outgoing_window(pn_messenger_t *messenger);
-
-/**
- * Set the size of a messenger's outgoing window.
- *
- * See ::pn_messenger_get_outgoing_window() for details.
- *
- * @param[in] messenger a messenger object
- * @param[in] window the number of deliveries to track
- * @return an error or zero on success
- * @see error.h
- */
-PNX_EXTERN int pn_messenger_set_outgoing_window(pn_messenger_t *messenger, int window);
-
-/**
- * Get the size of a messenger's incoming window.
- *
- * The size of a messenger's incoming window limits the number of
- * messages that can be accepted or rejected using trackers. Messages
- * *do not* enter this window when they have been received
- * (::pn_messenger_recv) onto you incoming queue. Messages only enter
- * this window only when you access them using pn_messenger_get. If
- * your incoming window size is N, and you get N+1 messages without
- * explicitly accepting or rejecting the oldest message, then it will
- * be implicitly accepted when it falls off the edge of the incoming
- * window.
- *
- * The default incoming window size is 0.
- *
- * @param[in] messenger a messenger object
- * @return the incoming window for the messenger
- */
-PNX_EXTERN int pn_messenger_get_incoming_window(pn_messenger_t *messenger);
-
-/**
- * Set the size of a messenger's incoming window.
- *
- * See ::pn_messenger_get_incoming_window() for details.
- *
- * @param[in] messenger a messenger object
- * @param[in] window the number of deliveries to track
- * @return an error or zero on success
- * @see error.h
- */
-PNX_EXTERN int pn_messenger_set_incoming_window(pn_messenger_t *messenger,
- int window);
-
-/**
- * Currently a no-op placeholder. For future compatibility, do not
- * send or receive messages before starting the messenger.
- *
- * @param[in] messenger the messenger to start
- * @return an error code or zero on success
- * @see error.h
- */
-PNX_EXTERN int pn_messenger_start(pn_messenger_t *messenger);
-
-/**
- * Stops a messenger.
- *
- * Stopping a messenger will perform an orderly shutdown of all
- * underlying connections. This may require some time. If the
- * messenger is in non blocking mode (see ::pn_messenger_is_blocking),
- * this operation will return PN_INPROGRESS if it cannot finish
- * immediately. In that case, you can use ::pn_messenger_stopped() to
- * determine when the messenger has finished stopping.
- *
- * @param[in] messenger the messenger to stop
- * @return an error code or zero on success
- * @see error.h
- */
-PNX_EXTERN int pn_messenger_stop(pn_messenger_t *messenger);
-
-/**
- * Returns true if a messenger is in the stopped state. This function
- * does not block.
- *
- * @param[in] messenger the messenger to stop
- *
- */
-PNX_EXTERN bool pn_messenger_stopped(pn_messenger_t *messenger);
-
-/**
- * Subscribes a messenger to messages from the specified source.
- *
- * @param[in] messenger the messenger to subscribe
- * @param[in] source
- * @return a subscription
- */
-PNX_EXTERN pn_subscription_t *pn_messenger_subscribe(pn_messenger_t *messenger, const char *source);
-
-/**
- * Subscribes a messenger to messages from the specified source with the given
- * timeout for the subscription's lifetime.
- *
- * @param[in] messenger the messenger to subscribe
- * @param[in] source
- * @param[in] timeout the maximum time to keep the subscription alive once the
- * link is closed.
- * @return a subscription
- */
-PNX_EXTERN pn_subscription_t *
-pn_messenger_subscribe_ttl(pn_messenger_t *messenger, const char *source,
- pn_seconds_t timeout);
-
-/**
- * Get a link based on link name and whether the link is a sender or receiver
- *
- * @param[in] messenger the messenger to get the link from
- * @param[in] address the link address that identifies the link to receive
- * @param[in] sender true if the link is a sender, false if the link is a
- * receiver
- * @return a link, or NULL if no link matches the address / sender parameters
- */
-PNX_EXTERN pn_link_t *pn_messenger_get_link(pn_messenger_t *messenger,
- const char *address, bool sender);
-
-/**
- * Get a subscription's application context.
- *
- * See ::pn_subscription_set_context().
- *
- * @param[in] sub a subscription object
- * @return the subscription's application context
- */
-PNX_EXTERN void *pn_subscription_get_context(pn_subscription_t *sub);
-
-/**
- * Set an application context for a subscription.
- *
- * @param[in] sub a subscription object
- * @param[in] context the application context for the subscription
- */
-PNX_EXTERN void pn_subscription_set_context(pn_subscription_t *sub, void *context);
-
-/**
- * Get the source address of a subscription.
- *
- * @param[in] sub a subscription object
- * @return the subscription's source address
- */
-PNX_EXTERN const char *pn_subscription_address(pn_subscription_t *sub);
-
-/**
- * Puts a message onto the messenger's outgoing queue. The message may
- * also be sent if transmission would not cause blocking. This call
- * will not block.
- *
- * @param[in] messenger a messenger object
- * @param[in] msg a message to put on the messenger's outgoing queue
- * @return an error code or zero on success
- * @see error.h
- */
-PNX_EXTERN int pn_messenger_put(pn_messenger_t *messenger, pn_message_t *msg);
-
-/**
- * Track the status of a delivery.
- *
- * Get the current status of the delivery associated with the supplied
- * tracker. This may return PN_STATUS_UNKOWN if the tracker has fallen
- * outside the incoming/outgoing tracking windows of the messenger.
- *
- * @param[in] messenger the messenger
- * @param[in] tracker the tracker identifying the delivery
- * @return a status code for the delivery
- */
-PNX_EXTERN pn_status_t pn_messenger_status(pn_messenger_t *messenger, pn_tracker_t tracker);
-
-/**
- * Get delivery information about a delivery.
- *
- * Returns the delivery information associated with the supplied tracker.
- * This may return NULL if the tracker has fallen outside the
- * incoming/outgoing tracking windows of the messenger.
- *
- * @param[in] messenger the messenger
- * @param[in] tracker the tracker identifying the delivery
- * @return a pn_delivery_t representing the delivery.
- */
-PNX_EXTERN pn_delivery_t *pn_messenger_delivery(pn_messenger_t *messenger,
- pn_tracker_t tracker);
-
-/**
- * Check if the delivery associated with a given tracker is still
- * waiting to be sent.
- *
- * Note that returning false does not imply that the delivery was
- * actually sent over the wire.
- *
- * @param[in] messenger the messenger
- * @param[in] tracker the tracker identifying the delivery
- *
- * @return true if the delivery is still buffered
- */
-PNX_EXTERN bool pn_messenger_buffered(pn_messenger_t *messenger, pn_tracker_t tracker);
-
-/**
- * Frees a Messenger from tracking the status associated with a given
- * tracker. Use the PN_CUMULATIVE flag to indicate everything up to
- * (and including) the given tracker.
- *
- * @param[in] messenger the Messenger
- * @param[in] tracker identifies a delivery
- * @param[in] flags 0 or PN_CUMULATIVE
- *
- * @return an error code or zero on success
- * @see error.h
- */
-PNX_EXTERN int pn_messenger_settle(pn_messenger_t *messenger, pn_tracker_t tracker, int flags);
-
-/**
- * Get a tracker for the outgoing message most recently given to
- * pn_messenger_put.
- *
- * This tracker may be used with pn_messenger_status to determine the
- * delivery status of the message, as long as the message is still
- * within your outgoing window.
- *
- * @param[in] messenger the messenger
- *
- * @return a pn_tracker_t or an undefined value if pn_messenger_get
- * has never been called for the given messenger
- */
-PNX_EXTERN pn_tracker_t pn_messenger_outgoing_tracker(pn_messenger_t *messenger);
-
-/**
- * Sends or receives any outstanding messages queued for a messenger.
- * This will block for the indicated timeout.
- *
- * @param[in] messenger the Messenger
- * @param[in] timeout the maximum time to block in milliseconds, -1 ==
- * forever, 0 == do not block
- *
- * @return 0 if no work to do, < 0 if error, or 1 if work was done.
- */
-PNX_EXTERN int pn_messenger_work(pn_messenger_t *messenger, int timeout);
-
-/**
- * Interrupt a messenger object that may be blocking in another
- * thread.
- *
- * The messenger interface is single-threaded. This is the only
- * messenger function intended to be concurrently called from another
- * thread. It will interrupt any messenger function which is currently
- * blocking and cause it to return with a status of ::PN_INTR.
- *
- * @param[in] messenger the Messenger to interrupt
- */
-PNX_EXTERN int pn_messenger_interrupt(pn_messenger_t *messenger);
-
-/**
- * Send messages from a messenger's outgoing queue.
- *
- * If a messenger is in blocking mode (see
- * ::pn_messenger_is_blocking()), this operation will block until N
- * messages have been sent from the outgoing queue. A value of -1 for
- * N means "all messages in the outgoing queue". See below for a full
- * definition of what sent from the outgoing queue means.
- *
- * Any blocking will end once the messenger's configured timeout (if
- * any) has been reached. When this happens an error code of
- * ::PN_TIMEOUT is returned.
- *
- * If the messenger is in non blocking mode, this call will return an
- * error code of ::PN_INPROGRESS if it is unable to send the requested
- * number of messages without blocking.
- *
- * A message is considered to be sent from the outgoing queue when its
- * status has been fully determined. This does not necessarily mean
- * the message was successfully sent to the final recipient though,
- * for example of the receiver rejects the message, the final status
- * will be ::PN_STATUS_REJECTED. Similarly, if a message is sent to an
- * invalid address, it may be removed from the outgoing queue without
- * ever even being transmitted. In this case the final status will be
- * ::PN_STATUS_ABORTED.
- *
- * @param[in] messenger a messenger object
- * @param[in] n the number of messages to send
- *
- * @return an error code or zero on success
- * @see error.h
- */
-PNX_EXTERN int pn_messenger_send(pn_messenger_t *messenger, int n);
-
-/**
- * Retrieve messages into a messenger's incoming queue.
- *
- * Instructs a messenger to receive up to @c limit messages into the
- * incoming message queue of a messenger. If @c limit is -1, the
- * messenger will receive as many messages as it can buffer
- * internally. If the messenger is in blocking mode, this call will
- * block until at least one message is available in the incoming
- * queue.
- *
- * Each call to pn_messenger_recv replaces the previous receive
- * operation, so pn_messenger_recv(messenger, 0) will cancel any
- * outstanding receive.
- *
- * After receiving messages onto your incoming queue use
- * ::pn_messenger_get() to access message content.
- *
- * @param[in] messenger the messenger
- * @param[in] limit the maximum number of messages to receive or -1 to
- * to receive as many messages as it can buffer
- * internally.
- * @return an error code or zero on success
- * @see error.h
- */
-PNX_EXTERN int pn_messenger_recv(pn_messenger_t *messenger, int limit);
-
-/**
- * Get the capacity of the incoming message queue of a messenger.
- *
- * Note this count does not include those messages already available
- * on the incoming queue (@see pn_messenger_incoming()). Rather it
- * returns the number of incoming queue entries available for
- * receiving messages.
- *
- * @param[in] messenger the messenger
- */
-PNX_EXTERN int pn_messenger_receiving(pn_messenger_t *messenger);
-
-/**
- * Get the next message from the head of a messenger's incoming queue.
- *
- * The get operation copies the message data from the head of the
- * messenger's incoming queue into the provided ::pn_message_t object.
- * If provided ::pn_message_t pointer is NULL, the head essage will be
- * discarded. This operation will return ::PN_EOS if there are no
- * messages left on the incoming queue.
- *
- * @param[in] messenger a messenger object
- * @param[out] message upon return contains the message from the head of the queue
- * @return an error code or zero on success
- * @see error.h
- */
-PNX_EXTERN int pn_messenger_get(pn_messenger_t *messenger, pn_message_t *message);
-
-/**
- * Get a tracker for the message most recently retrieved by
- * ::pn_messenger_get().
- *
- * A tracker for an incoming message allows you to accept or reject
- * the associated message. It can also be used for cumulative
- * accept/reject operations for the associated message and all prior
- * messages as well.
- *
- * @param[in] messenger a messenger object
- * @return a pn_tracker_t or an undefined value if pn_messenger_get
- * has never been called for the given messenger
- */
-PNX_EXTERN pn_tracker_t pn_messenger_incoming_tracker(pn_messenger_t *messenger);
-
-/**
- * Get the subscription of the message most recently retrieved by ::pn_messenger_get().
- *
- * This operation will return NULL if ::pn_messenger_get() has never
- * been succesfully called.
- *
- * @param[in] messenger a messenger object
- * @return a pn_subscription_t or NULL
- */
-PNX_EXTERN pn_subscription_t *pn_messenger_incoming_subscription(pn_messenger_t *messenger);
-
-/**
- * Indicates that an accept or reject should operate cumulatively.
- */
-#define PN_CUMULATIVE (0x1)
-
-/**
- * Signal successful processing of message(s).
- *
- * With no flags this operation will signal the sender that the
- * message referenced by the tracker was accepted. If the
- * PN_CUMULATIVE flag is set, this operation will also reject all
- * pending messages prior to the message indicated by the tracker.
- *
- * Note that when a message is accepted or rejected multiple times,
- * either explicitly, or implicitly through use of the ::PN_CUMULATIVE
- * flag, only the first outcome applies. For example if a sequence of
- * three messages are received: M1, M2, M3, and M2 is rejected, and M3
- * is cumulatively accepted, M2 will remain rejected and only M1 and
- * M3 will be considered accepted.
- *
- * @param[in] messenger a messenger object
- * @param[in] tracker an incoming tracker
- * @param[in] flags 0 or PN_CUMULATIVE
- * @return an error code or zero on success
- * @see error.h
- */
-PNX_EXTERN int pn_messenger_accept(pn_messenger_t *messenger, pn_tracker_t tracker, int flags);
-
-/**
- * Signal unsuccessful processing of message(s).
- *
- * With no flags this operation will signal the sender that the
- * message indicated by the tracker was rejected. If the PN_CUMULATIVE
- * flag is used this operation will also reject all pending messages
- * prior to the message indicated by the tracker.
- *
- * Note that when a message is accepted or rejected multiple times,
- * either explicitly, or implicitly through use of the ::PN_CUMULATIVE
- * flag, only the first outcome applies. For example if a sequence of
- * three messages are received: M1, M2, M3, and M2 is accepted, and M3
- * is cumulatively rejected, M2 will remain accepted and only M1 and
- * M3 will be considered rejected.
- *
- * @param[in] messenger a messenger object
- * @param[in] tracker an incoming tracker
- * @param[in] flags 0 or PN_CUMULATIVE
- * @return an error code or zero on success
- * @see error.h
- */
-PNX_EXTERN int pn_messenger_reject(pn_messenger_t *messenger, pn_tracker_t tracker, int flags);
-
-/**
- * Get link for the message referenced by the given tracker.
- *
- * @param[in] messenger a messenger object
- * @param[in] tracker a tracker object
- * @return a pn_link_t or NULL if the link could not be determined.
- */
-PNX_EXTERN pn_link_t *pn_messenger_tracker_link(pn_messenger_t *messenger,
- pn_tracker_t tracker);
-
-/**
- * Get the number of messages in the outgoing message queue of a
- * messenger.
- *
- * @param[in] messenger a messenger object
- * @return the outgoing queue depth
- */
-PNX_EXTERN int pn_messenger_outgoing(pn_messenger_t *messenger);
-
-/**
- * Get the number of messages in the incoming message queue of a messenger.
- *
- * @param[in] messenger a messenger object
- * @return the incoming queue depth
- */
-PNX_EXTERN int pn_messenger_incoming(pn_messenger_t *messenger);
-
-//! Adds a routing rule to a Messenger's internal routing table.
-//!
-//! The route procedure may be used to influence how a messenger will
-//! internally treat a given address or class of addresses. Every call
-//! to the route procedure will result in messenger appending a routing
-//! rule to its internal routing table.
-//!
-//! Whenever a message is presented to a messenger for delivery, it
-//! will match the address of this message against the set of routing
-//! rules in order. The first rule to match will be triggered, and
-//! instead of routing based on the address presented in the message,
-//! the messenger will route based on the address supplied in the rule.
-//!
-//! The pattern matching syntax supports two types of matches, a '%'
-//! will match any character except a '/', and a '*' will match any
-//! character including a '/'.
-//!
-//! A routing address is specified as a normal AMQP address, however it
-//! may additionally use substitution variables from the pattern match
-//! that triggered the rule.
-//!
-//! Any message sent to "foo" will be routed to "amqp://foo.com":
-//!
-//! pn_messenger_route("foo", "amqp://foo.com");
-//!
-//! Any message sent to "foobar" will be routed to
-//! "amqp://foo.com/bar":
-//!
-//! pn_messenger_route("foobar", "amqp://foo.com/bar");
-//!
-//! Any message sent to bar/<path> will be routed to the corresponding
-//! path within the amqp://bar.com domain:
-//!
-//! pn_messenger_route("bar/*", "amqp://bar.com/$1");
-//!
-//! Route all messages over TLS:
-//!
-//! pn_messenger_route("amqp:*", "amqps:$1")
-//!
-//! Supply credentials for foo.com:
-//!
-//! pn_messenger_route("amqp://foo.com/*", "amqp://user:password@foo.com/$1");
-//!
-//! Supply credentials for all domains:
-//!
-//! pn_messenger_route("amqp://*", "amqp://user:password@$1");
-//!
-//! Route all addresses through a single proxy while preserving the
-//! original destination:
-//!
-//! pn_messenger_route("amqp://%/*", "amqp://user:password@proxy/$1/$2");
-//!
-//! Route any address through a single broker:
-//!
-//! pn_messenger_route("*", "amqp://user:password@broker/$1");
-//!
-//! @param[in] messenger the Messenger
-//! @param[in] pattern a glob pattern
-//! @param[in] address an address indicating alternative routing
-//!
-//! @return an error code or zero on success
-//! @see error.h
-PNX_EXTERN int pn_messenger_route(pn_messenger_t *messenger, const char *pattern,
- const char *address);
-
-/**
- * Rewrite message addresses prior to transmission.
- *
- * This operation is similar to pn_messenger_route, except that the
- * destination of the message is determined before the message address
- * is rewritten.
- *
- * The outgoing address is only rewritten after routing has been
- * finalized. If a message has an outgoing address of
- * "amqp://0.0.0.0:5678", and a rewriting rule that changes its
- * outgoing address to "foo", it will still arrive at the peer that
- * is listening on "amqp://0.0.0.0:5678", but when it arrives there,
- * the receiver will see its outgoing address as "foo".
- *
- * The default rewrite rule removes username and password from
- * addresses before they are transmitted.
- *
- * @param[in] messenger a messenger object
- * @param[in] pattern a glob pattern to select messages
- * @param[in] address an address indicating outgoing address rewrite
- * @return an error code or zero on success
- */
-PNX_EXTERN int pn_messenger_rewrite(pn_messenger_t *messenger, const char *pattern,
- const char *address);
-
-/**
- * Extract selectables from a passive messenger.
- *
- * A messenger that is in passive mode (see
- * ::pn_messenger_is_passive()) will never attempt to perform any I/O
- * internally, but instead make its internal file descriptors
- * available for external processing via the
- * ::pn_messenger_selectable() operation.
- *
- * An application wishing to perform I/O on behalf of a passive
- * messenger must extract all available selectables by calling this
- * operation until it returns NULL. The selectable interface may then
- * be used by the application to perform I/O outside the messenger.
- *
- * All selectables returned by this operation must be serviced until
- * they reach a terminal state and then freed. See
- * `pn_selectable_is_terminal()` for more details.
- *
- * By default any given selectable will only ever be returned once by
- * this operation, however if the selectable's registered flag is set
- * to true (see `pn_selectable_set_registered()`), then the selectable
- * will be returned whenever its interest set may have changed.
- *
- * @param[in] messenger a messenger object
- * @return the next selectable, or NULL if there are none left
- */
-PNX_EXTERN pn_selectable_t *pn_messenger_selectable(pn_messenger_t *messenger);
-
-/**
- * Get the nearest deadline for selectables associated with a messenger.
- *
- * @param[in] messenger a messenger object
- * @return the nearest deadline
- */
-PNX_EXTERN pn_timestamp_t pn_messenger_deadline(pn_messenger_t *messenger);
-
-#define PN_FLAGS_CHECK_ROUTES \
- (0x1) /**< Messenger flag to indicate that a call \
- to pn_messenger_start should check that \
- any defined routes are valid */
-
-#define PN_FLAGS_ALLOW_INSECURE_MECHS \
- (0x2) /**< Messenger flag to indicate that the PLAIN \
- mechanism is allowed on an unencrypted \
- connection */
-
-/**
- * Sets control flags to enable additional function for the Messenger.
- *
- * @param[in] messenger the messenger
- * @param[in] flags 0 or PN_FLAGS_CHECK_ROUTES
- *
- * @return an error code of zero if there is no error
- */
-PNX_EXTERN int pn_messenger_set_flags(pn_messenger_t *messenger,
- const int flags);
-
-/**
- * Gets the flags for a Messenger.
- *
- * @param[in] messenger the messenger
- * @return The flags set for the messenger
- */
-PNX_EXTERN int pn_messenger_get_flags(pn_messenger_t *messenger);
-
-/**
- * Set the local sender settle mode for the underlying link.
- *
- * @param[in] messenger the messenger
- * @param[in] mode the sender settle mode
- */
-PNX_EXTERN int pn_messenger_set_snd_settle_mode(pn_messenger_t *messenger,
- const pn_snd_settle_mode_t mode);
-
-/**
- * Set the local receiver settle mode for the underlying link.
- *
- * @param[in] messenger the messenger
- * @param[in] mode the receiver settle mode
- */
-PNX_EXTERN int pn_messenger_set_rcv_settle_mode(pn_messenger_t *messenger,
- const pn_rcv_settle_mode_t mode);
-
-/**
- * Set the tracer associated with a messenger.
- *
- * @param[in] messenger a messenger object
- * @param[in] tracer the tracer callback
- */
-PNX_EXTERN void pn_messenger_set_tracer(pn_messenger_t *messenger,
- pn_tracer_t tracer);
-
-/**
- * Gets the remote idle timeout for the specified remote service address
- *
- * @param[in] messenger a messenger object
- * @param[in] address of remote service whose idle timeout is required
- * @return the timeout in milliseconds or -1 if an error occurs
- */
-PNX_EXTERN pn_millis_t
- pn_messenger_get_remote_idle_timeout(pn_messenger_t *messenger,
- const char *address);
-
-/**
- * Sets the SSL peer authentiacation mode required when a trust
- * certificate is used.
- *
- * @param[in] messenger a messenger object
- * @param[in] mode the mode required (see pn_ssl_verify_mode_t
- * enum for valid values)
- * @return 0 if successful or -1 if an error occurs
- */
-PNX_EXTERN int
-pn_messenger_set_ssl_peer_authentication_mode(pn_messenger_t *messenger,
- const pn_ssl_verify_mode_t mode);
-
-/**
- * @}
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* messenger.h */
http://git-wip-us.apache.org/repos/asf/qpid-proton-j/blob/2f85988e/proton-c/include/proton/object.h
----------------------------------------------------------------------
diff --git a/proton-c/include/proton/object.h b/proton-c/include/proton/object.h
deleted file mode 100644
index e7efd94..0000000
--- a/proton-c/include/proton/object.h
+++ /dev/null
@@ -1,345 +0,0 @@
-#ifndef PROTON_OBJECT_H
-#define PROTON_OBJECT_H 1
-
-/*
- *
- * 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 <proton/cid.h>
-#include <proton/types.h>
-#include <stdarg.h>
-#include <proton/type_compat.h>
-#include <stddef.h>
-#include <proton/import_export.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @cond INTERNAL
- */
-
-typedef void* pn_handle_t;
-typedef intptr_t pn_shandle_t;
-
-typedef struct pn_class_t pn_class_t;
-typedef struct pn_string_t pn_string_t;
-typedef struct pn_list_t pn_list_t;
-typedef struct pn_map_t pn_map_t;
-typedef struct pn_hash_t pn_hash_t;
-typedef void *(*pn_iterator_next_t)(void *state);
-typedef struct pn_iterator_t pn_iterator_t;
-typedef struct pn_record_t pn_record_t;
-
-struct pn_class_t {
- const char *name;
- const pn_cid_t cid;
- void *(*newinst)(const pn_class_t *, size_t);
- void (*initialize)(void *);
- void (*incref)(void *);
- void (*decref)(void *);
- int (*refcount)(void *);
- void (*finalize)(void *);
- void (*free)(void *);
- const pn_class_t *(*reify)(void *);
- uintptr_t (*hashcode)(void *);
- intptr_t (*compare)(void *, void *);
- int (*inspect)(void *, pn_string_t *);
-};
-
-// Hack alert: Declare these as arrays so we can treat the name
-// of the single object as the address
-PN_EXTERN extern const pn_class_t PN_OBJECT[];
-PN_EXTERN extern const pn_class_t PN_VOID[];
-PN_EXTERN extern const pn_class_t PN_WEAKREF[];
-
-#define PN_CLASSDEF(PREFIX) \
-static void PREFIX ## _initialize_cast(void *object) { \
- PREFIX ## _initialize((PREFIX ## _t *) object); \
-} \
- \
-static void PREFIX ## _finalize_cast(void *object) { \
- PREFIX ## _finalize((PREFIX ## _t *) object); \
-} \
- \
-static uintptr_t PREFIX ## _hashcode_cast(void *object) { \
- uintptr_t (*fp)(PREFIX ## _t *) = PREFIX ## _hashcode; \
- if (fp) { \
- return fp((PREFIX ## _t *) object); \
- } else { \
- return (uintptr_t) object; \
- } \
-} \
- \
-static intptr_t PREFIX ## _compare_cast(void *a, void *b) { \
- intptr_t (*fp)(PREFIX ## _t *, PREFIX ## _t *) = PREFIX ## _compare; \
- if (fp) { \
- return fp((PREFIX ## _t *) a, (PREFIX ## _t *) b); \
- } else { \
- return (intptr_t) a - (intptr_t) b; \
- } \
-} \
- \
-static int PREFIX ## _inspect_cast(void *object, pn_string_t *str) { \
- int (*fp)(PREFIX ## _t *, pn_string_t *) = PREFIX ## _inspect; \
- if (fp) { \
- return fp((PREFIX ## _t *) object, str); \
- } else { \
- return pn_string_addf(str, "%s<%p>", #PREFIX, object); \
- } \
-} \
- \
-const pn_class_t *PREFIX ## __class(void) { \
- static const pn_class_t clazz = { \
- #PREFIX, \
- CID_ ## PREFIX, \
- pn_object_new, \
- PREFIX ## _initialize_cast, \
- pn_object_incref, \
- pn_object_decref, \
- pn_object_refcount, \
- PREFIX ## _finalize_cast, \
- pn_object_free, \
- pn_object_reify, \
- PREFIX ## _hashcode_cast, \
- PREFIX ## _compare_cast, \
- PREFIX ## _inspect_cast \
- }; \
- return &clazz; \
-} \
- \
-PREFIX ## _t *PREFIX ## _new(void) { \
- return (PREFIX ## _t *) pn_class_new(PREFIX ## __class(), \
- sizeof(PREFIX ## _t)); \
-}
-
-#define PN_CLASS(PREFIX) { \
- #PREFIX, \
- CID_ ## PREFIX, \
- pn_object_new, \
- PREFIX ## _initialize, \
- pn_object_incref, \
- pn_object_decref, \
- pn_object_refcount, \
- PREFIX ## _finalize, \
- pn_object_free, \
- pn_object_reify, \
- PREFIX ## _hashcode, \
- PREFIX ## _compare, \
- PREFIX ## _inspect \
-}
-
-#define PN_METACLASS(PREFIX) { \
- #PREFIX, \
- CID_ ## PREFIX, \
- PREFIX ## _new, \
- PREFIX ## _initialize, \
- PREFIX ## _incref, \
- PREFIX ## _decref, \
- PREFIX ## _refcount, \
- PREFIX ## _finalize, \
- PREFIX ## _free, \
- PREFIX ## _reify, \
- PREFIX ## _hashcode, \
- PREFIX ## _compare, \
- PREFIX ## _inspect \
-}
-
-/* Class to identify a plain C struct in a pn_event_t. No refcounting or memory management. */
-#define PN_STRUCT_CLASSDEF(PREFIX, CID) \
- const pn_class_t *PREFIX ## __class(void); \
- static const pn_class_t *PREFIX ## _reify(void *p) { return PREFIX ## __class(); } \
- const pn_class_t *PREFIX ## __class(void) { \
- static const pn_class_t clazz = { \
- #PREFIX, \
- CID, \
- NULL, /*_new*/ \
- NULL, /*_initialize*/ \
- pn_void_incref, \
- pn_void_decref, \
- pn_void_refcount, \
- NULL, /* _finalize */ \
- NULL, /* _free */ \
- PREFIX ## _reify, \
- pn_void_hashcode, \
- pn_void_compare, \
- pn_void_inspect \
- }; \
- return &clazz; \
- }
-
-PN_EXTERN pn_cid_t pn_class_id(const pn_class_t *clazz);
-PN_EXTERN const char *pn_class_name(const pn_class_t *clazz);
-PN_EXTERN void *pn_class_new(const pn_class_t *clazz, size_t size);
-
-/* pn_incref, pn_decref and pn_refcount are for internal use by the proton
- library, the should not be called by application code. Application code
- should use the appropriate pn_*_free function (pn_link_free, pn_session_free
- etc.) when it is finished with a proton value. Proton values should only be
- used when handling a pn_event_t that refers to them.
-*/
-PN_EXTERN void *pn_class_incref(const pn_class_t *clazz, void *object);
-PN_EXTERN int pn_class_refcount(const pn_class_t *clazz, void *object);
-PN_EXTERN int pn_class_decref(const pn_class_t *clazz, void *object);
-
-PN_EXTERN void pn_class_free(const pn_class_t *clazz, void *object);
-
-PN_EXTERN const pn_class_t *pn_class_reify(const pn_class_t *clazz, void *object);
-PN_EXTERN uintptr_t pn_class_hashcode(const pn_class_t *clazz, void *object);
-PN_EXTERN intptr_t pn_class_compare(const pn_class_t *clazz, void *a, void *b);
-PN_EXTERN bool pn_class_equals(const pn_class_t *clazz, void *a, void *b);
-PN_EXTERN int pn_class_inspect(const pn_class_t *clazz, void *object, pn_string_t *dst);
-
-PN_EXTERN void *pn_void_new(const pn_class_t *clazz, size_t size);
-PN_EXTERN void pn_void_incref(void *object);
-PN_EXTERN void pn_void_decref(void *object);
-PN_EXTERN int pn_void_refcount(void *object);
-PN_EXTERN uintptr_t pn_void_hashcode(void *object);
-PN_EXTERN intptr_t pn_void_compare(void *a, void *b);
-PN_EXTERN int pn_void_inspect(void *object, pn_string_t *dst);
-
-PN_EXTERN void *pn_object_new(const pn_class_t *clazz, size_t size);
-PN_EXTERN const pn_class_t *pn_object_reify(void *object);
-PN_EXTERN void pn_object_incref(void *object);
-PN_EXTERN int pn_object_refcount(void *object);
-PN_EXTERN void pn_object_decref(void *object);
-PN_EXTERN void pn_object_free(void *object);
-
-PN_EXTERN void *pn_incref(void *object);
-PN_EXTERN int pn_decref(void *object);
-PN_EXTERN int pn_refcount(void *object);
-PN_EXTERN void pn_free(void *object);
-PN_EXTERN const pn_class_t *pn_class(void* object);
-PN_EXTERN uintptr_t pn_hashcode(void *object);
-PN_EXTERN intptr_t pn_compare(void *a, void *b);
-PN_EXTERN bool pn_equals(void *a, void *b);
-PN_EXTERN int pn_inspect(void *object, pn_string_t *dst);
-
-#define PN_REFCOUNT (0x1)
-
-PN_EXTERN pn_list_t *pn_list(const pn_class_t *clazz, size_t capacity);
-PN_EXTERN size_t pn_list_size(pn_list_t *list);
-PN_EXTERN void *pn_list_get(pn_list_t *list, int index);
-PN_EXTERN void pn_list_set(pn_list_t *list, int index, void *value);
-PN_EXTERN int pn_list_add(pn_list_t *list, void *value);
-PN_EXTERN void *pn_list_pop(pn_list_t *list);
-PN_EXTERN ssize_t pn_list_index(pn_list_t *list, void *value);
-PN_EXTERN bool pn_list_remove(pn_list_t *list, void *value);
-PN_EXTERN void pn_list_del(pn_list_t *list, int index, int n);
-PN_EXTERN void pn_list_clear(pn_list_t *list);
-PN_EXTERN void pn_list_iterator(pn_list_t *list, pn_iterator_t *iter);
-PN_EXTERN void pn_list_minpush(pn_list_t *list, void *value);
-PN_EXTERN void *pn_list_minpop(pn_list_t *list);
-
-#define PN_REFCOUNT_KEY (0x2)
-#define PN_REFCOUNT_VALUE (0x4)
-
-PN_EXTERN pn_map_t *pn_map(const pn_class_t *key, const pn_class_t *value,
- size_t capacity, float load_factor);
-PN_EXTERN size_t pn_map_size(pn_map_t *map);
-PN_EXTERN int pn_map_put(pn_map_t *map, void *key, void *value);
-PN_EXTERN void *pn_map_get(pn_map_t *map, void *key);
-PN_EXTERN void pn_map_del(pn_map_t *map, void *key);
-PN_EXTERN pn_handle_t pn_map_head(pn_map_t *map);
-PN_EXTERN pn_handle_t pn_map_next(pn_map_t *map, pn_handle_t entry);
-PN_EXTERN void *pn_map_key(pn_map_t *map, pn_handle_t entry);
-PN_EXTERN void *pn_map_value(pn_map_t *map, pn_handle_t entry);
-
-PN_EXTERN pn_hash_t *pn_hash(const pn_class_t *clazz, size_t capacity, float load_factor);
-PN_EXTERN size_t pn_hash_size(pn_hash_t *hash);
-PN_EXTERN int pn_hash_put(pn_hash_t *hash, uintptr_t key, void *value);
-PN_EXTERN void *pn_hash_get(pn_hash_t *hash, uintptr_t key);
-PN_EXTERN void pn_hash_del(pn_hash_t *hash, uintptr_t key);
-PN_EXTERN pn_handle_t pn_hash_head(pn_hash_t *hash);
-PN_EXTERN pn_handle_t pn_hash_next(pn_hash_t *hash, pn_handle_t entry);
-PN_EXTERN uintptr_t pn_hash_key(pn_hash_t *hash, pn_handle_t entry);
-PN_EXTERN void *pn_hash_value(pn_hash_t *hash, pn_handle_t entry);
-
-PN_EXTERN pn_string_t *pn_string(const char *bytes);
-PN_EXTERN pn_string_t *pn_stringn(const char *bytes, size_t n);
-PN_EXTERN const char *pn_string_get(pn_string_t *string);
-PN_EXTERN size_t pn_string_size(pn_string_t *string);
-PN_EXTERN int pn_string_set(pn_string_t *string, const char *bytes);
-PN_EXTERN int pn_string_setn(pn_string_t *string, const char *bytes, size_t n);
-PN_EXTERN ssize_t pn_string_put(pn_string_t *string, char *dst);
-PN_EXTERN void pn_string_clear(pn_string_t *string);
-PN_EXTERN int pn_string_format(pn_string_t *string, const char *format, ...)
-#ifdef __GNUC__
- __attribute__ ((format (printf, 2, 3)))
-#endif
- ;
-PN_EXTERN int pn_string_vformat(pn_string_t *string, const char *format, va_list ap);
-PN_EXTERN int pn_string_addf(pn_string_t *string, const char *format, ...)
-#ifdef __GNUC__
- __attribute__ ((format (printf, 2, 3)))
-#endif
- ;
-PN_EXTERN int pn_string_vaddf(pn_string_t *string, const char *format, va_list ap);
-PN_EXTERN int pn_string_grow(pn_string_t *string, size_t capacity);
-PN_EXTERN char *pn_string_buffer(pn_string_t *string);
-PN_EXTERN size_t pn_string_capacity(pn_string_t *string);
-PN_EXTERN int pn_string_resize(pn_string_t *string, size_t size);
-PN_EXTERN int pn_string_copy(pn_string_t *string, pn_string_t *src);
-
-PN_EXTERN pn_iterator_t *pn_iterator(void);
-PN_EXTERN void *pn_iterator_start(pn_iterator_t *iterator,
- pn_iterator_next_t next, size_t size);
-PN_EXTERN void *pn_iterator_next(pn_iterator_t *iterator);
-
-#define PN_LEGCTX ((pn_handle_t) 0)
-
-/**
- PN_HANDLE is a trick to define a unique identifier by using the address of a static variable.
- You MUST NOT use it in a .h file, since it must be defined uniquely in one compilation unit.
- Your .h file can provide access to the handle (if needed) via a function. For example:
-
- /// my_thing.h
- pn_handle_t get_my_thing(void);
-
- /// my_thing.c
- PN_HANDLE(MY_THING);
- pn_handle_t get_my_thing(void) { return MY_THING; }
-
- Note that the name "MY_THING" is not exported and is not required to be
- unique except in the .c file. The linker will guarantee that the *address* of
- MY_THING, as returned by get_my_thing() *is* unique across the entire linked
- executable.
- */
-#define PN_HANDLE(name) \
- static const char _PN_HANDLE_ ## name = 0; \
- static const pn_handle_t name = ((pn_handle_t) &_PN_HANDLE_ ## name);
-
-PN_EXTERN pn_record_t *pn_record(void);
-PN_EXTERN void pn_record_def(pn_record_t *record, pn_handle_t key, const pn_class_t *clazz);
-PN_EXTERN bool pn_record_has(pn_record_t *record, pn_handle_t key);
-PN_EXTERN void *pn_record_get(pn_record_t *record, pn_handle_t key);
-PN_EXTERN void pn_record_set(pn_record_t *record, pn_handle_t key, void *value);
-PN_EXTERN void pn_record_clear(pn_record_t *record);
-
-/**
- * @endcond
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* object.h */
http://git-wip-us.apache.org/repos/asf/qpid-proton-j/blob/2f85988e/proton-c/include/proton/parser.h
----------------------------------------------------------------------
diff --git a/proton-c/include/proton/parser.h b/proton-c/include/proton/parser.h
deleted file mode 100644
index a95ca86..0000000
--- a/proton-c/include/proton/parser.h
+++ /dev/null
@@ -1,52 +0,0 @@
-#ifndef PROTON_PARSER_H
-#define PROTON_PARSER_H 1
-
-/*
- *
- * 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 <proton/import_export.h>
-#include <proton/codec.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @cond INTERNAL
- */
-
-typedef struct pn_parser_t pn_parser_t;
-
-PN_EXTERN pn_parser_t *pn_parser(void);
-PN_EXTERN int pn_parser_parse(pn_parser_t *parser, const char *str, pn_data_t *data);
-PN_EXTERN int pn_parser_errno(pn_parser_t *parser);
-PN_EXTERN const char *pn_parser_error(pn_parser_t *parser);
-PN_EXTERN void pn_parser_free(pn_parser_t *parser);
-
-/**
- * @endcond
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* parser.h */
http://git-wip-us.apache.org/repos/asf/qpid-proton-j/blob/2f85988e/proton-c/include/proton/proactor.h
----------------------------------------------------------------------
diff --git a/proton-c/include/proton/proactor.h b/proton-c/include/proton/proactor.h
deleted file mode 100644
index b8fb16a..0000000
--- a/proton-c/include/proton/proactor.h
+++ /dev/null
@@ -1,200 +0,0 @@
-#ifndef PROTON_PROACTOR_H
-#define PROTON_PROACTOR_H 1
-
-/*
- * 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 <proton/types.h>
-#include <proton/import_export.h>
-#include <proton/listener.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @cond INTERNAL
- */
-typedef struct pn_condition_t pn_condition_t;
-/**
- * @endcond
- */
-
-/**
- * @file
- *
- * **Experimental** - Multithreaded IO
- *
- * The proactor associates a @ref connection with a @ref transport,
- * either by making an outgoing connection or accepting an incoming
- * one. It delivers @ref event "events" to application threads for
- * handling.
- *
- * ## Multi-threading
- *
- * The @ref proactor is thread-safe, but the protocol engine is not.
- * The proactor ensures that each @ref connection and its associated
- * values (@ref session, @ref link etc.) is handle sequentially, even
- * if there are multiple application threads. See pn_proactor_wait().
- *
- * @addtogroup proactor
- * @{
- */
-
-/**
- * The proactor, see pn_proactor()
- */
-typedef struct pn_proactor_t pn_proactor_t;
-
-/**
- * Create a proactor. Must be freed with pn_proactor_free()
- */
-pn_proactor_t *pn_proactor(void);
-
-/**
- * Free the proactor. Abort any open network connections and clean up all
- * associated resources.
- */
-void pn_proactor_free(pn_proactor_t *proactor);
-
-/**
- * Connect connection to host/port. Connection and transport events will be
- * returned by pn_proactor_wait()
- *
- * @param[in] proactor the proactor object
- * @param[in] connection the proactor takes ownership, do not free
- * @param[in] host address to connect on
- * @param[in] port port to connect to
- *
- * @return error on immediate error, e.g. an allocation failure.
- * Other errors are indicated by connection or transport events via
- * pn_proactor_wait()
- */
-int pn_proactor_connect(pn_proactor_t *proactor, pn_connection_t *connection,
- const char *host, const char *port);
-
-/**
- * Start listening with listener. pn_proactor_wait() will return a
- * PN_LISTENER_ACCEPT event when a connection can be accepted.
- *
- * @param[in] proactor the proactor object
- * @param[in] listener proactor takes ownership of listener, do not free
- * @param[in] host address to listen on
- * @param[in] port port to listen on
- * @param[in] backlog number of connection requests to queue
- *
- * @return error on immediate error, e.g. an allocation failure.
- * Other errors are indicated by pn_listener_condition() on the
- * PN_LISTENER_CLOSE event.
- */
-int pn_proactor_listen(pn_proactor_t *proactor, pn_listener_t *listener,
- const char *host, const char *port, int backlog);
-
-/**
- * Wait for events to handle.
- *
- * Handle events in the returned batch by calling
- * pn_event_batch_next() until it returns NULL. You must call
- * pn_proactor_done() when you are finished with the batch.
- *
- * If you call pn_proactor_done() before finishing the batch, the
- * remaining events will be returned again by another call
- * pn_proactor_wait(). This is less efficient, but allows you to
- * handle part of a batch and then hand off the rest to another
- * thread.
- *
- * @note Thread-safe: can be called concurrently. Events in a single
- * batch must be handled in sequence, but batches returned by separate
- * calls to pn_proactor_wait() can be handled concurrently.
- */
-pn_event_batch_t *pn_proactor_wait(pn_proactor_t *proactor);
-
-/**
- * Call when done handling a batch of events.
- *
- * Must be called exactly once to match each call to
- * pn_proactor_wait().
- *
- * @note Thread-safe: may be called from any thread provided the
- * exactly once rule is respected.
- */
-void pn_proactor_done(pn_proactor_t *proactor, pn_event_batch_t *events);
-
-/**
- * Cause PN_PROACTOR_INTERRUPT to be returned to exactly one call of
- * pn_proactor_wait().
- *
- * If threads are blocked in pn_proactor_wait(), one of them will be
- * interrupted, otherwise the interrupt will be returned by a future
- * call to pn_proactor_wait(). Calling pn_proactor_interrupt() N times
- * will return PN_PROACTOR_INTERRUPT to N current or future calls of
- * pn_proactor_wait()
- *
- * @note Thread-safe.
- */
-void pn_proactor_interrupt(pn_proactor_t *proactor);
-
-/**
- * Cause PN_PROACTOR_TIMEOUT to be returned to a thread calling wait()
- * after timeout milliseconds. Thread-safe.
- *
- * Note that calling pn_proactor_set_timeout() again before the
- * PN_PROACTOR_TIMEOUT is delivered will cancel the previous timeout
- * and deliver an event only after the new
- * timeout. `pn_proactor_set_timeout(0)` will cancel the timeout
- * without setting a new one.
- */
-void pn_proactor_set_timeout(pn_proactor_t *proactor, pn_millis_t timeout);
-
-/**
- * Cause a PN_CONNECTION_WAKE event to be returned by the proactor, even if
- * there are no IO events pending for the connection.
- *
- * @note Thread-safe: this is the only pn_connection_ function that
- * can be called concurrently.
- *
- * Wakes can be "coalesced" - if several pn_connection_wake() calls happen
- * concurrently, there may be only one PN_CONNECTION_WAKE event.
- */
-void pn_connection_wake(pn_connection_t *connection);
-
-/**
- * Return the proactor associated with a connection or NULL.
- */
-pn_proactor_t *pn_connection_proactor(pn_connection_t *connection);
-
-/**
- * Return the proactor associated with an event or NULL.
- */
-pn_proactor_t *pn_event_proactor(pn_event_t *event);
-
-/**
- * Return the listener associated with an event or NULL.
- */
-pn_listener_t *pn_event_listener(pn_event_t *event);
-
-/**
- * @}
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* proactor.h */
http://git-wip-us.apache.org/repos/asf/qpid-proton-j/blob/2f85988e/proton-c/include/proton/reactor.h
----------------------------------------------------------------------
diff --git a/proton-c/include/proton/reactor.h b/proton-c/include/proton/reactor.h
deleted file mode 100644
index 8d229ab..0000000
--- a/proton-c/include/proton/reactor.h
+++ /dev/null
@@ -1,188 +0,0 @@
-#ifndef PROTON_REACTOR_H
-#define PROTON_REACTOR_H 1
-
-/*
- *
- * 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 <proton/import_export.h>
-#include <proton/type_compat.h>
-#include <proton/error.h>
-#include <proton/event.h>
-#include <proton/selectable.h>
-#include <proton/ssl.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @cond INTERNAL
- */
-
-typedef struct pn_reactor_t pn_reactor_t;
-typedef struct pn_acceptor_t pn_acceptor_t;
-typedef struct pn_timer_t pn_timer_t;
-typedef struct pn_task_t pn_task_t;
-
-PNX_EXTERN pn_handler_t *pn_handler(void (*dispatch)(pn_handler_t *, pn_event_t *, pn_event_type_t));
-PNX_EXTERN pn_handler_t *pn_handler_new(void (*dispatch)(pn_handler_t *, pn_event_t *, pn_event_type_t), size_t size,
- void (*finalize)(pn_handler_t *));
-PNX_EXTERN void pn_handler_free(pn_handler_t *handler);
-PNX_EXTERN void *pn_handler_mem(pn_handler_t *handler);
-PNX_EXTERN void pn_handler_add(pn_handler_t *handler, pn_handler_t *child);
-PNX_EXTERN void pn_handler_clear(pn_handler_t *handler);
-PNX_EXTERN void pn_handler_dispatch(pn_handler_t *handler, pn_event_t *event, pn_event_type_t type);
-
-PNX_EXTERN pn_reactor_t *pn_reactor(void);
-PNX_EXTERN pn_record_t *pn_reactor_attachments(pn_reactor_t *reactor);
-PNX_EXTERN pn_millis_t pn_reactor_get_timeout(pn_reactor_t *reactor);
-PNX_EXTERN void pn_reactor_set_timeout(pn_reactor_t *reactor, pn_millis_t timeout);
-PNX_EXTERN pn_timestamp_t pn_reactor_mark(pn_reactor_t *reactor);
-PNX_EXTERN pn_timestamp_t pn_reactor_now(pn_reactor_t *reactor);
-PNX_EXTERN void pn_reactor_yield(pn_reactor_t *reactor);
-PNX_EXTERN void pn_reactor_free(pn_reactor_t *reactor);
-PNX_EXTERN pn_collector_t *pn_reactor_collector(pn_reactor_t *reactor);
-PNX_EXTERN pn_handler_t *pn_reactor_get_global_handler(pn_reactor_t *reactor);
-PNX_EXTERN void pn_reactor_set_global_handler(pn_reactor_t *reactor, pn_handler_t *handler);
-PNX_EXTERN pn_handler_t *pn_reactor_get_handler(pn_reactor_t *reactor);
-PNX_EXTERN void pn_reactor_set_handler(pn_reactor_t *reactor, pn_handler_t *handler);
-PNX_EXTERN pn_list_t *pn_reactor_children(pn_reactor_t *reactor);
-PNX_EXTERN pn_selectable_t *pn_reactor_selectable(pn_reactor_t *reactor);
-PNX_EXTERN void pn_reactor_update(pn_reactor_t *reactor, pn_selectable_t *selectable);
-PNX_EXTERN pn_acceptor_t *pn_reactor_acceptor(pn_reactor_t *reactor, const char *host, const char *port,
- pn_handler_t *handler);
-PNX_EXTERN pn_error_t *pn_reactor_error(pn_reactor_t *reactor);
-
-/**
- * Create an outgoing connection that will be managed by the reactor.
- *
- * The reator's pn_iohandler will create a socket connection to the host
- * once the connection is opened.
- *
- * @param[in] reactor the reactor that will own the connection.
- * @param[in] host the address of the remote host. e.g. "localhost"
- * @param[in] port the port to connect to. e.g. "5672"
- * @param[in] handler the handler that will process all events generated by
- * this connection.
- * @return a connection object
- */
-PNX_EXTERN pn_connection_t *pn_reactor_connection_to_host(pn_reactor_t *reactor,
- const char *host,
- const char *port,
- pn_handler_t *handler);
-
-/**
- * Create an outgoing connection that will be managed by the reactor.
- *
- * The host address for the connection must be set via
- * ::pn_reactor_set_connection_host() prior to opening the connection.
- * Typically this can be done by the handler when processing the
- * ::PN_CONNECTION_INIT event.
- *
- * @param[in] reactor the reactor that will own the connection.
- * @param[in] handler the handler that will process all events generated by
- * this connection.
- * @return a connection object
- * @deprecated Use ::pn_reactor_connection_to_host() instead.
- */
-PNX_EXTERN pn_connection_t *pn_reactor_connection(pn_reactor_t *reactor,
- pn_handler_t *handler);
-
-/**
- * Change the host address used by an outgoing reactor connection.
- *
- * The address is used by the reactor's iohandler to create an outgoing socket
- * connection. This must be set prior to (re)opening the connection.
- *
- * @param[in] reactor the reactor that owns the connection.
- * @param[in] connection the connection created by the reactor.
- * @param[in] host the network address or DNS name of the host to connect to.
- * @param[in] port the network port to use. Optional - default is "5672"
- */
-PNX_EXTERN void pn_reactor_set_connection_host(pn_reactor_t *reactor,
- pn_connection_t *connection,
- const char *host,
- const char *port);
-/**
- * Retrieve the peer host address for a reactor connection.
- *
- * This may be used to retrieve the host address used by the reactor to
- * establish the outgoing socket connection. In the case of an accepted
- * connection the returned value is the address of the remote.
- *
- * @note Note that the returned address may be in numeric IP format.
- *
- * The pointer returned by this operation is valid until either the address is
- * changed via ::pn_reactor_set_connection_host() or the connection object
- * is freed.
- *
- * @param[in] reactor the reactor that owns the connection.
- * @param[in] connection the reactor connection
- * @return a C string containing the address in URL format or NULL if no
- * address available. ::pn_url_parse() may be used to create a Proton pn_url_t
- * instance from the returned value.
- */
-PNX_EXTERN const char *pn_reactor_get_connection_address(pn_reactor_t *reactor,
- pn_connection_t *connection);
-
-PNX_EXTERN int pn_reactor_wakeup(pn_reactor_t *reactor);
-PNX_EXTERN void pn_reactor_start(pn_reactor_t *reactor);
-PNX_EXTERN bool pn_reactor_quiesced(pn_reactor_t *reactor);
-PNX_EXTERN bool pn_reactor_process(pn_reactor_t *reactor);
-PNX_EXTERN void pn_reactor_stop(pn_reactor_t *reactor);
-PNX_EXTERN void pn_reactor_run(pn_reactor_t *reactor);
-PNX_EXTERN pn_task_t *pn_reactor_schedule(pn_reactor_t *reactor, int delay, pn_handler_t *handler);
-
-
-PNX_EXTERN void pn_acceptor_set_ssl_domain(pn_acceptor_t *acceptor, pn_ssl_domain_t *domain);
-PNX_EXTERN void pn_acceptor_close(pn_acceptor_t *acceptor);
-PNX_EXTERN pn_acceptor_t *pn_connection_acceptor(pn_connection_t *connection);
-
-PNX_EXTERN pn_timer_t *pn_timer(pn_collector_t *collector);
-PNX_EXTERN pn_timestamp_t pn_timer_deadline(pn_timer_t *timer);
-PNX_EXTERN void pn_timer_tick(pn_timer_t *timer, pn_timestamp_t now);
-PNX_EXTERN pn_task_t *pn_timer_schedule(pn_timer_t *timer, pn_timestamp_t deadline);
-PNX_EXTERN int pn_timer_tasks(pn_timer_t *timer);
-
-PNX_EXTERN pn_record_t *pn_task_attachments(pn_task_t *task);
-PNX_EXTERN void pn_task_cancel(pn_task_t *task);
-
-PNX_EXTERN pn_reactor_t *pn_class_reactor(const pn_class_t *clazz, void *object);
-PNX_EXTERN pn_reactor_t *pn_object_reactor(void *object);
-PNX_EXTERN pn_reactor_t *pn_event_reactor(pn_event_t *event);
-
-PNX_EXTERN pn_handler_t *pn_record_get_handler(pn_record_t *record);
-PNX_EXTERN void pn_record_set_handler(pn_record_t *record, pn_handler_t *handler);
-
-/**
- * Get the root handler the current event was dispatched to.
- */
-PNX_EXTERN pn_handler_t *pn_event_root(pn_event_t *event);
-
-/**
- * @endcond
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* reactor.h */
http://git-wip-us.apache.org/repos/asf/qpid-proton-j/blob/2f85988e/proton-c/include/proton/sasl.h
----------------------------------------------------------------------
diff --git a/proton-c/include/proton/sasl.h b/proton-c/include/proton/sasl.h
deleted file mode 100644
index 671ffec..0000000
--- a/proton-c/include/proton/sasl.h
+++ /dev/null
@@ -1,212 +0,0 @@
-#ifndef PROTON_SASL_H
-#define PROTON_SASL_H 1
-
-/*
- *
- * 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 <proton/import_export.h>
-#include <proton/type_compat.h>
-#include <proton/types.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @file
- *
- * @copybrief sasl
- *
- * @addtogroup sasl
- * @{
- */
-
-/**
- * The SASL layer is responsible for establishing an authenticated
- * and/or encrypted tunnel over which AMQP frames are passed between
- * peers. The peer acting as the SASL Client must provide
- * authentication credentials. The peer acting as the SASL Server must
- * provide authentication against the received credentials.
- */
-typedef struct pn_sasl_t pn_sasl_t;
-
-/**
- * The result of the SASL negotiation.
- */
-typedef enum {
- PN_SASL_NONE = -1, /** negotiation not completed */
- PN_SASL_OK = 0, /** authentication succeeded */
- PN_SASL_AUTH = 1, /** failed due to bad credentials */
- PN_SASL_SYS = 2, /** failed due to a system error */
- PN_SASL_PERM = 3, /** failed due to unrecoverable error */
- PN_SASL_TEMP = 4 /** failed due to transient error */
-} pn_sasl_outcome_t;
-
-/**
- * Construct an Authentication and Security Layer object.
- *
- * This will return the SASL layer object for the supplied transport
- * object. If there is currently no SASL layer one will be created.
- *
- * On the client side of an AMQP connection this will have the effect
- * of ensuring that the AMQP SASL layer is used for that connection.
- *
- * @return an object representing the SASL layer.
- */
-PN_EXTERN pn_sasl_t *pn_sasl(pn_transport_t *transport);
-
-/**
- * Do we support extended SASL negotiation
- *
- * Do we support extended SASL negotiation?
- * All implementations of Proton support ANONYMOUS and EXTERNAL on both
- * client and server sides and PLAIN on the client side.
- *
- * Extended SASL implememtations use an external library (Cyrus SASL)
- * to support other mechanisms beyond these basic ones.
- *
- * @return true if we support extended SASL negotiation, false if we only support basic negotiation.
- */
-PN_EXTERN bool pn_sasl_extended(void);
-
-/**
- * Set the outcome of SASL negotiation
- *
- * Used by the server to set the result of the negotiation process.
- *
- * @todo
- */
-PN_EXTERN void pn_sasl_done(pn_sasl_t *sasl, pn_sasl_outcome_t outcome);
-
-/**
- * Retrieve the outcome of SASL negotiation.
- *
- * @todo
- */
-PN_EXTERN pn_sasl_outcome_t pn_sasl_outcome(pn_sasl_t *sasl);
-
-/**
- * Retrieve the authenticated user
- *
- * This is usually used at the the server end to find the name of the authenticated user.
- * On the client it will merely return whatever user was passed in to the
- * pn_transport_set_user_password() API.
- *
- * If pn_sasl_outcome() returns a value other than PN_SASL_OK, then there will be no user to return.
- * The returned value is only reliable after the PN_TRANSPORT_AUTHENTICATED event has been received.
- *
- * @param[in] sasl the sasl layer
- *
- * @return
- * If the SASL layer was not negotiated then 0 is returned
- * If the ANONYMOUS mechanism is used then the user will be "anonymous"
- * Otherwise a string containing the user is returned.
- */
-PN_EXTERN const char *pn_sasl_get_user(pn_sasl_t *sasl);
-
-/**
- * Return the selected SASL mechanism
- *
- * The returned value is only reliable after the PN_TRANSPORT_AUTHENTICATED event has been received.
- *
- * @param[in] sasl the SASL layer
- *
- * @return The authentication mechanism selected by the SASL layer
- */
-PN_EXTERN const char *pn_sasl_get_mech(pn_sasl_t *sasl);
-
-/**
- * SASL mechanisms that are to be considered for authentication
- *
- * This can be used on either the client or the server to restrict the SASL
- * mechanisms that may be used to the mechanisms on the list.
- *
- * @param[in] sasl the SASL layer
- * @param[in] mechs space separated list of mechanisms that are allowed for authentication
- */
-PN_EXTERN void pn_sasl_allowed_mechs(pn_sasl_t *sasl, const char *mechs);
-
-/**
- * Boolean to allow use of clear text authentication mechanisms
- *
- * By default the SASL layer is configured not to allow mechanisms that disclose
- * the clear text of the password over an unencrypted AMQP connection. This specifically
- * will disallow the use of the PLAIN mechanism without using SSL encryption.
- *
- * This default is to avoid disclosing password information accidentally over an
- * insecure network.
- *
- * If you actually wish to use a clear text password unencrypted then you can use this
- * API to set allow_insecure_mechs to true.
- *
- * @param[in] sasl the SASL layer
- * @param[in] insecure set this to true to allow unencrypted PLAIN authentication.
- *
- */
-PN_EXTERN void pn_sasl_set_allow_insecure_mechs(pn_sasl_t *sasl, bool insecure);
-
-/**
- * Return the current value for allow_insecure_mechs
- *
- * @param[in] sasl the SASL layer
- */
-PN_EXTERN bool pn_sasl_get_allow_insecure_mechs(pn_sasl_t *sasl);
-
-/**
- * Set the sasl configuration name
- *
- * This is used to construct the SASL configuration filename. In the current implementation
- * it ".conf" is added to the name and the file is looked for in the configuration directory.
- *
- * If not set it will default to "proton-server" for a sasl server and "proton-client"
- * for a client.
- *
- * @param[in] sasl the SASL layer
- * @param[in] name the configuration name
- */
-PN_EXTERN void pn_sasl_config_name(pn_sasl_t *sasl, const char *name);
-
-/**
- * Set the sasl configuration path
- *
- * This is used to tell SASL where to look for the configuration file.
- * In the current implementation it can be a colon separated list of directories.
- *
- * The environment variable PN_SASL_CONFIG_PATH can also be used to set this path,
- * but if both methods are used then this pn_sasl_config_path() will take precedence.
- *
- * If not set the underlying implementation default will be used.
- * for a client.
- *
- * @param[in] sasl the SASL layer
- * @param[in] path the configuration path
- */
-PN_EXTERN void pn_sasl_config_path(pn_sasl_t *sasl, const char *path);
-
-/**
- * @}
- */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* sasl.h */
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@qpid.apache.org
For additional commands, e-mail: commits-help@qpid.apache.org