/*******************************************************************************
* Copyright (c) 2007, 2010 Wind River Systems, Inc. and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v1.0 which accompany this distribution.
* The Eclipse Public License is available at
* http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
* You may elect to redistribute this code under either of these licenses.
*
* Contributors:
* Wind River Systems - initial API and implementation
*******************************************************************************/
/*
* Transport agnostic TCF communication channel interface.
*/
#ifndef D_channel
#define D_channel
#include <tcf/framework/streams.h>
#include <tcf/framework/link.h>
#include <tcf/framework/peer.h>
struct Protocol;
typedef struct TCFBroadcastGroup TCFBroadcastGroup;
typedef struct ChannelServer ChannelServer;
typedef struct Channel Channel;
struct TCFBroadcastGroup {
int magic;
OutputStream out; /* Broadcast stream */
LINK channels; /* Channels in group */
};
enum {
ChannelStateStartWait,
ChannelStateStarted,
ChannelStateHelloSent,
ChannelStateHelloReceived,
ChannelStateConnected,
ChannelStateRedirectSent,
ChannelStateRedirectReceived,
ChannelStateDisconnected
};
struct Channel {
InputStream inp; /* Input stream */
OutputStream out; /* Output stream */
TCFBroadcastGroup * bcg; /* Broadcast group */
void * client_data; /* Client data */
struct Protocol * protocol; /* Channel protocol */
char * peer_name; /* A human readable remote peer name */
int peer_service_cnt; /* Number of remote peer service names */
char ** peer_service_list; /* List of remote peer service names */
LINK bclink; /* Broadcast list */
LINK susplink; /* Suspend list */
int congestion_level; /* Congestion level */
int state; /* Current state */
int disable_zero_copy; /* Don't send ZeroCopy in Hello message even if we support it */
/* Populated by channel implementation */
void (*start_comm)(Channel *); /* Start communication */
void (*check_pending)(Channel *); /* Check for pending messages */
int (*message_count)(Channel *); /* Return number of pending messages */
void (*lock)(Channel *); /* Lock channel from deletion */
void (*unlock)(Channel *); /* Unlock channel */
int (*is_closed)(Channel *); /* Return true if channel is closed */
void (*close)(Channel *, int); /* Close channel */
/* Populated by channel client, NULL values mean default handling */
void (*connecting)(Channel *); /* Called when channel is ready for transmit */
void (*connected)(Channel *); /* Called when channel negotiation is complete */
void (*receive)(Channel *); /* Called when messages has been received */
void (*disconnected)(Channel *); /* Called when channel is disconnected */
};
struct ChannelServer {
void * client_data; /* Client data */
void (*new_conn)(ChannelServer *, Channel *); /* New connection call back */
void (*close)(ChannelServer *); /* Close channel server */
};
/*
* Register channel close callback.
* Service implementation can use the callback to deallocate resources
* after a client disconnects.
*/
typedef void (*ChannelCloseListener)(Channel *);
extern void add_channel_close_listener(ChannelCloseListener listener);
/*
* Notify listeners about channel being closed.
* The function is called from channel implementation code,
* it is not intended to be called by clients.
*/
extern void notify_channel_closed(Channel *);
/*
* Start TCF channel server.
* On error returns NULL and sets errno.
*/
extern ChannelServer * channel_server(PeerServer *);
/*
* Connect to TCF channel server.
* On error returns NULL and sets errno.
*/
typedef void (*ChannelConnectCallBack)(void * /* callback_args */, int /* error */, Channel *);
extern void channel_connect(PeerServer * server, ChannelConnectCallBack callback, void * callback_args);
/*
* Start communication of a newly created channel.
*/
extern void channel_start(Channel *);
/*
* Close communication channel.
*/
extern void channel_close(Channel *);
/*
* Allocate and return new "Broadcast Group" object.
* Broadcast Group is collection of channels that participate together in broadcasting a message.
*/
extern TCFBroadcastGroup * broadcast_group_alloc(void);
/*
* Remove channels from Broadcast Group and deallocate the group object.
*/
extern void broadcast_group_free(TCFBroadcastGroup *);
/*
* Add a channel to a Broadcast Group.
* If the channel is already in a group, it is removed from it first.
*/
extern void channel_set_broadcast_group(Channel *, TCFBroadcastGroup *);
/*
* Remove channel from Suspend Group. Does nothing if the channel is not a member of a group.
*/
extern void channel_clear_broadcast_group(Channel *);
/*
* Lock a channel. A closed channel will not be deallocated until it is unlocked.
* Each call of this function incremnets the channel reference counter.
*/
extern void channel_lock(Channel *);
/*
* Unlock a channel.
* Each call of this function decremnets the channel reference counter.
* If channel is closed and reference count is zero, then the channel object is deallocated.
*/
extern void channel_unlock(Channel *);
/*
* Return 1 if channel is closed, otherwise return 0.
*/
extern int is_channel_closed(Channel *);
/* Deprecated function names are kept for backward compatibility */
#define stream_lock(channel) channel_lock(channel)
#define stream_unlock(channel) channel_unlock(channel)
#define is_stream_closed(channel) is_channel_closed(channel)
/*
* Create and return PeerServer object with attribute values taken fron given URL.
*/
extern PeerServer * channel_peer_from_url(const char *);
#endif /* D_channel */
