/**
* Global channel number ( < GNUNET_CADET_LOCAL_CHANNEL_ID_CLI)
*/
- struct GNUNET_CADET_ChannelNumber gid;
+ struct GNUNET_CADET_ChannelTunnelNumber gid;
/**
* Local tunnel number for root (owner) client.
}
/* Assign local id as destination */
- ch->lid_dest = GML_get_next_chid (c);
+ ch->lid_dest = GML_get_next_ccn (c);
/* Store in client's hashmap */
GML_channel_add (c, ch->lid_dest, ch);
msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY);
msg.header.size = htons (sizeof (msg));
- msg.chid = ch->gid;
+ msg.ctn = ch->gid;
/* If root is not NULL, notify.
* If it's NULL, check lid_root. When a local destroy comes in, root
msgcc.header.size = htons (sizeof (msgcc));
msgcc.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN);
- msgcc.chid = ch->gid;
+ msgcc.ctn = ch->gid;
msgcc.port = ch->port;
msgcc.opt = htonl (channel_get_options (ch));
" sending channel %s ack for channel %s\n",
GC_f2s (fwd), GCCH_2s (ch));
- msg.chid =ch->gid;
+ msg.ctn =ch->gid;
GCCH_send_prebuilt_message (&msg.header, ch, !fwd, NULL);
}
" sending channel NACK for channel %s\n",
GCCH_2s (ch));
- msg.chid = ch->gid;
+ msg.ctn = ch->gid;
GCCH_send_prebuilt_message (&msg.header, ch, GNUNET_NO, NULL);
}
if (NULL != owner)
{
- ch->gid = GCT_get_next_chid (t);
+ ch->gid = GCT_get_next_ctn (t);
GML_channel_add (owner, lid_root, ch);
}
GCT_add_channel (t, ch);
break;
case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA_ACK:
- GCCH_handle_data_ack (ch, (struct GNUNET_CADET_ChannelDataAckMessage *) msgh, fwd);
+ GCCH_handle_data_ack (ch,
+ (const struct GNUNET_CADET_ChannelDataAckMessage *) msgh, fwd);
break;
case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN:
GCCH_handle_create (ch->t,
- (struct GNUNET_CADET_ChannelOpenMessage *) msgh);
+ (const struct GNUNET_CADET_ChannelOpenMessage *) msgh);
break;
case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK:
GCCH_handle_ack (ch,
- (struct GNUNET_CADET_ChannelManageMessage *) msgh,
+ (const struct GNUNET_CADET_ChannelManageMessage *) msgh,
fwd);
break;
case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_DESTROY:
GCCH_handle_destroy (ch,
- (struct GNUNET_CADET_ChannelManageMessage *) msgh,
+ (const struct GNUNET_CADET_ChannelManageMessage *) msgh,
fwd);
break;
*
* @return ID used to identify the channel with the remote peer.
*/
-struct GNUNET_CADET_ChannelNumber
+struct GNUNET_CADET_ChannelTunnelNumber
GCCH_get_id (const struct CadetChannel *ch)
{
return ch->gid;
msg.header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA_ACK);
msg.header.size = htons (sizeof (msg));
- msg.chid = ch->gid;
+ msg.ctn = ch->gid;
msg.mid = htonl (ack);
msg.futures = 0LL;
GNUNET_memcpy (&payload[1], message, size);
payload->header.size = htons (p2p_size);
payload->header.type = htons (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_APP_DATA);
- payload->chid = ch->gid;
+ payload->ctn = ch->gid;
LOG (GNUNET_ERROR_TYPE_DEBUG, " sending on channel...\n");
GCCH_send_prebuilt_message (&payload->header, ch, fwd, NULL);
* @param c Client that requested the creation (will be the root).
* @param msg Create Channel message.
*
- * @return GNUNET_OK if everything went fine, GNUNET_SYSERR otherwise.
+ * @return #GNUNET_OK if everything went fine, #GNUNET_SYSERR otherwise.
*/
int
GCCH_handle_local_create (struct CadetClient *c,
- struct GNUNET_CADET_ChannelOpenMessageMessage *msg)
+ struct GNUNET_CADET_LocalChannelCreateMessage *msg)
{
struct CadetChannel *ch;
struct CadetTunnel *t;
struct CadetPeer *peer;
- struct GNUNET_CADET_ClientChannelNumber chid;
+ struct GNUNET_CADET_ClientChannelNumber ccn;
LOG (GNUNET_ERROR_TYPE_DEBUG, " towards %s:%u\n",
GNUNET_i2s (&msg->peer), GNUNET_h2s (&msg->port));
- chid = msg->channel_id;
+ ccn = msg->ccn;
/* Sanity check for duplicate channel IDs */
- if (NULL != GML_channel_get (c, chid))
+ if (NULL != GML_channel_get (c, ccn))
{
GNUNET_break (0);
return GNUNET_SYSERR;
}
/* Create channel */
- ch = channel_new (t, c, chid);
+ ch = channel_new (t, c, ccn);
if (NULL == ch)
{
GNUNET_break (0);
GCCH_handle_create (struct CadetTunnel *t,
const struct GNUNET_CADET_ChannelOpenMessage *msg)
{
- struct GNUNET_CADET_ClientChannelNumber chid;
- struct GNUNET_CADET_ChannelNumber gid;
+ struct GNUNET_CADET_ClientChannelNumber ccn;
+ struct GNUNET_CADET_ChannelTunnelNumber gid;
struct CadetChannel *ch;
struct CadetClient *c;
int new_channel;
const struct GNUNET_HashCode *port;
- gid = msg->chid;
+ gid = msg->ctn;
ch = GCT_get_channel (t, gid);
if (NULL == ch)
{
/* Create channel */
- chid.channel_of_client = htonl (0);
- ch = channel_new (t, NULL, chid);
+ ccn.channel_of_client = htonl (0);
+ ch = channel_new (t, NULL, ccn);
ch->gid = gid;
channel_set_options (ch, ntohl (msg->opt));
new_channel = GNUNET_YES;
LOG (GNUNET_ERROR_TYPE_INFO,
"<== %s ( 0x%08X %4u) on chan %s (%p) %s [%5u]\n",
- GC_m2s (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN), chid, port,
+ GC_m2s (GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN), ccn, port,
GCCH_2s (ch), ch, GC_f2s (GNUNET_YES), ntohs (msg->header.size));
if (GNUNET_YES == new_channel || GCT_is_loopback (t))
{
struct GNUNET_CADET_ChannelOpenMessage *cc_msg;
cc_msg = (struct GNUNET_CADET_ChannelOpenMessage *) message;
- SPRINTF (info, " 0x%08X", ntohl (cc_msg->chid.cn));
+ SPRINTF (info, " 0x%08X", ntohl (cc_msg->ctn.cn));
break;
}
case GNUNET_MESSAGE_TYPE_CADET_CHANNEL_OPEN_ACK:
{
struct GNUNET_CADET_ChannelManageMessage *m_msg;
m_msg = (struct GNUNET_CADET_ChannelManageMessage *) message;
- SPRINTF (info, " 0x%08X", ntohl (m_msg->chid.cn));
+ SPRINTF (info, " 0x%08X", ntohl (m_msg->ctn.cn));
break;
}
default: