1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
/*******************************************************************************
* 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 */
|
