static bool
serialize_mid6(struct interface *ifp)
{
uint16_t remainsize, curr_size, needsize;
/* preserve existing data in output buffer */
union olsr_message *m;
struct midaddr6 *addrs6;
struct interface *ifs;
//printf("\t\tGenerating mid on %s\n", ifn->int_name);
if ((olsr_cnf->ip_version != AF_INET6) || (!ifp) || (ifnet == NULL) || ((ifnet->int_next == NULL) && (ipequal(&olsr_cnf->main_addr, &ifnet->ip_addr))))
return false;
remainsize = net_outbuffer_bytes_left(ifp);
curr_size = OLSR_MID_IPV6_HDRSIZE;
/* calculate size needed for HNA */
needsize = curr_size;
for (ifs = ifnet; ifs != NULL; ifs = ifs->int_next) {
needsize += olsr_cnf->ipsize*2;
}
/* Send pending packet if not room in buffer */
if (needsize > remainsize) {
net_output(ifp);
remainsize = net_outbuffer_bytes_left(ifp);
}
check_buffspace(curr_size, remainsize, "MID");
m = (union olsr_message *)msg_buffer;
/* Build header */
m->v6.hopcnt = 0;
m->v6.ttl = MAX_TTL;
m->v6.olsr_msgtype = MID_MESSAGE;
m->v6.olsr_vtime = ifp->valtimes.mid;
/* Set main(first) address */
m->v6.originator = olsr_cnf->main_addr.v6;
addrs6 = m->v6.message.mid.mid_addr;
/* Don't add the main address... it's already there */
for (ifs = ifnet; ifs != NULL; ifs = ifs->int_next) {
if (!ipequal(&olsr_cnf->main_addr, &ifs->ip_addr)) {
#ifdef DEBUG
struct ipaddr_str buf;
#endif
if ((curr_size + olsr_cnf->ipsize) > remainsize) {
/* Only add MID message if it contains data */
if (curr_size > OLSR_MID_IPV6_HDRSIZE) {
#ifdef DEBUG
OLSR_PRINTF(BMSG_DBGLVL, "Sending partial(size: %d, buff left:%d)\n", curr_size, remainsize);
#endif
/* set size */
m->v6.olsr_msgsize = htons(curr_size);
m->v6.seqno = htons(get_msg_seqno()); /* seqnumber */
net_outbuffer_push(ifp, msg_buffer, curr_size);
curr_size = OLSR_MID_IPV6_HDRSIZE;
addrs6 = m->v6.message.mid.mid_addr;
}
net_output(ifp);
remainsize = net_outbuffer_bytes_left(ifp);
check_buffspace(curr_size + olsr_cnf->ipsize, remainsize, "MID2");
}
#ifdef DEBUG
OLSR_PRINTF(BMSG_DBGLVL, "\t%s(%s)\n", olsr_ip_to_string(&buf, &ifs->ip_addr), ifs->int_name);
#endif
addrs6->addr = ifs->ip_addr.v6;
addrs6++;
curr_size += olsr_cnf->ipsize;
}
}
m->v6.olsr_msgsize = htons(curr_size);
m->v6.seqno = htons(get_msg_seqno()); /* seqnumber */
//printf("Sending MID (%d bytes)...\n", outputsize);
if (curr_size > OLSR_MID_IPV6_HDRSIZE)
net_outbuffer_push(ifp, msg_buffer, curr_size);
return true;
}
/**
*IP version 4
*
*@param ifp the interface to send on
*@return nada
*/
static bool
serialize_hna4(struct interface *ifp)
{
uint16_t remainsize, curr_size, needsize;
/* preserve existing data in output buffer */
union olsr_message *m;
struct hnapair *pair;
struct ip_prefix_list *h;
/* No hna nets */
if (ifp == NULL) {
return false;
}
if (olsr_cnf->ip_version != AF_INET) {
return false;
}
h = olsr_cnf->hna_entries;
if (h == NULL) {
return false;
}
remainsize = net_outbuffer_bytes_left(ifp);
curr_size = OLSR_HNA_IPV4_HDRSIZE;
/* calculate size needed for HNA */
needsize = curr_size;
while (h) {
needsize += olsr_cnf->ipsize*2;
h = h->next;
}
h = olsr_cnf->hna_entries;
/* Send pending packet if not room in buffer */
if (needsize > remainsize) {
net_output(ifp);
remainsize = net_outbuffer_bytes_left(ifp);
}
check_buffspace(curr_size, remainsize, "HNA");
m = (union olsr_message *)msg_buffer;
/* Fill header */
m->v4.originator = olsr_cnf->main_addr.v4.s_addr;
m->v4.hopcnt = 0;
m->v4.ttl = MAX_TTL;
m->v4.olsr_msgtype = HNA_MESSAGE;
m->v4.olsr_vtime = ifp->valtimes.hna;
pair = m->v4.message.hna.hna_net;
for (; h != NULL; h = h->next) {
union olsr_ip_addr ip_addr;
if ((curr_size + (2 * olsr_cnf->ipsize)) > remainsize) {
/* Only add HNA message if it contains data */
if (curr_size > OLSR_HNA_IPV4_HDRSIZE) {
#ifdef DEBUG
OLSR_PRINTF(BMSG_DBGLVL, "Sending partial(size: %d, buff left:%d)\n", curr_size, remainsize);
#endif
m->v4.seqno = htons(get_msg_seqno());
m->v4.olsr_msgsize = htons(curr_size);
net_outbuffer_push(ifp, msg_buffer, curr_size);
curr_size = OLSR_HNA_IPV4_HDRSIZE;
pair = m->v4.message.hna.hna_net;
}
net_output(ifp);
remainsize = net_outbuffer_bytes_left(ifp);
check_buffspace(curr_size + (2 * olsr_cnf->ipsize), remainsize, "HNA2");
}
#ifdef DEBUG
OLSR_PRINTF(BMSG_DBGLVL, "\tNet: %s\n", olsr_ip_prefix_to_string(&h->net));
#endif
olsr_prefix_to_netmask(&ip_addr, h->net.prefix_len);
#ifdef linux
if (olsr_cnf->smart_gw_active && is_prefix_inetgw(&h->net)) {
/* this is the default route, overwrite it with the smart gateway */
olsr_modifiy_inetgw_netmask(&ip_addr, h->net.prefix_len);
}
#endif
pair->addr = h->net.prefix.v4.s_addr;
pair->netmask = ip_addr.v4.s_addr;
pair++;
curr_size += (2 * olsr_cnf->ipsize);
}
m->v4.seqno = htons(get_msg_seqno());
m->v4.olsr_msgsize = htons(curr_size);
net_outbuffer_push(ifp, msg_buffer, curr_size);
//printf("Sending HNA (%d bytes)...\n", outputsize);
return false;
}
static bool
serialize_tc6(struct tc_message *message, struct interface *ifp)
{
#ifdef DEBUG
struct ipaddr_str buf;
#endif
uint16_t remainsize, curr_size;
struct tc_mpr_addr *mprs;
union olsr_message *m;
struct olsr_tcmsg6 *tc6;
struct neigh_info6 *mprsaddr6;
bool found = false, partial_sent = false;
if ((!message) || (!ifp) || (olsr_cnf->ip_version != AF_INET6))
return false;
remainsize = net_outbuffer_bytes_left(ifp);
m = (union olsr_message *)msg_buffer;
tc6 = &m->v6.message.tc;
mprsaddr6 = tc6->neigh;
curr_size = OLSR_TC_IPV6_HDRSIZE;
/* Send pending packet if not room in buffer */
if (curr_size > remainsize) {
net_output(ifp);
remainsize = net_outbuffer_bytes_left(ifp);
}
check_buffspace(curr_size, remainsize, "TC");
/* Fill header */
m->v6.olsr_vtime = ifp->valtimes.tc;
m->v6.olsr_msgtype = TC_MESSAGE;
m->v6.hopcnt = message->hop_count;
m->v6.ttl = message->ttl;
m->v6.originator = message->originator.v6;
/* Fill TC header */
tc6->ansn = htons(message->ansn);
tc6->reserved = 0;
/*Looping trough MPR selectors */
for (mprs = message->multipoint_relay_selector_address; mprs != NULL; mprs = mprs->next) {
/*If packet is to be chomped */
if ((curr_size + olsr_cnf->ipsize) > remainsize) {
/* Only add TC message if it contains data */
if (curr_size > OLSR_TC_IPV6_HDRSIZE) {
#ifdef DEBUG
OLSR_PRINTF(BMSG_DBGLVL, "Sending partial(size: %d, buff left:%d)\n", curr_size, remainsize);
#endif
m->v6.olsr_msgsize = htons(curr_size);
m->v6.seqno = htons(get_msg_seqno());
net_outbuffer_push(ifp, msg_buffer, curr_size);
mprsaddr6 = tc6->neigh;
curr_size = OLSR_TC_IPV6_HDRSIZE;
found = false;
partial_sent = true;
}
net_output(ifp);
remainsize = net_outbuffer_bytes_left(ifp);
check_buffspace(curr_size + olsr_cnf->ipsize, remainsize, "TC2");
}
found = true;
#ifdef DEBUG
OLSR_PRINTF(BMSG_DBGLVL, "\t%s\n", olsr_ip_to_string(&buf, &mprs->address));
#endif
mprsaddr6->addr = mprs->address.v6;
curr_size += olsr_cnf->ipsize;
mprsaddr6++;
}
if (found) {
m->v6.olsr_msgsize = htons(curr_size);
m->v6.seqno = htons(get_msg_seqno());
net_outbuffer_push(ifp, msg_buffer, curr_size);
} else {
if ((!partial_sent) && (!TIMED_OUT(send_empty_tc))) {
OLSR_PRINTF(1, "TC: Sending empty package\n");
m->v6.olsr_msgsize = htons(curr_size);
m->v6.seqno = htons(get_msg_seqno());
net_outbuffer_push(ifp, msg_buffer, curr_size);
found = true;
}
}
return found;
}
static bool
serialize_hello6(struct hello_message *message, struct interface *ifp)
{
uint16_t remainsize, curr_size;
struct hello_neighbor *nb;
union olsr_message *m;
struct hellomsg6 *h6;
struct hellinfo6 *hinfo6;
union olsr_ip_addr *haddr;
int i, j;
bool first_entry;
if ((!message) || (!ifp) || (olsr_cnf->ip_version != AF_INET6))
return false;
remainsize = net_outbuffer_bytes_left(ifp);
m = (union olsr_message *)msg_buffer;
curr_size = OLSR_HELLO_IPV6_HDRSIZE; /* OLSR message header */
/* Send pending packet if not room in buffer */
if (curr_size > remainsize) {
net_output(ifp);
remainsize = net_outbuffer_bytes_left(ifp);
}
check_buffspace(curr_size + olsr_cnf->ipsize + 4, remainsize, "HELLO");
h6 = &m->v6.message.hello;
hinfo6 = h6->hell_info;
haddr = (union olsr_ip_addr *)hinfo6->neigh_addr;
/* Fill message header */
m->v6.ttl = message->ttl;
m->v6.hopcnt = 0;
/* Set source(main) addr */
m->v6.originator = olsr_cnf->main_addr.v6;
m->v6.olsr_msgtype = HELLO_MESSAGE;
m->v6.olsr_vtime = ifp->valtimes.hello;
/* Fill packet header */
h6->willingness = message->willingness;
h6->htime = reltime_to_me(ifp->hello_etime);
memset(&h6->reserved, 0, sizeof(uint16_t));
/*
*Loops trough all possible neighbor statuses
*The negbor list is grouped by status
*/
for (i = 0; i <= MAX_NEIGH; i++) {
for (j = 0; j <= MAX_LINK; j++) {
#ifdef DEBUG
struct ipaddr_str buf;
#endif
first_entry = true;
/*
*Looping trough neighbors
*/
for (nb = message->neighbors; nb != NULL; nb = nb->next) {
if ((nb->status != i) || (nb->link != j))
continue;
#ifdef DEBUG
OLSR_PRINTF(BMSG_DBGLVL, "\t%s - ", olsr_ip_to_string(&buf, &nb->address));
OLSR_PRINTF(BMSG_DBGLVL, "L:%d N:%d\n", j, i);
#endif
/*
* If there is not enough room left
* for the data in the outputbuffer
* we must send a partial HELLO and
* continue building the rest of the
* data in a new HELLO message
*
* If this is the first neighbor in
* a group, we must check for an extra
* 4 bytes
*/
if ((curr_size + olsr_cnf->ipsize + (first_entry ? 4 : 0)) > remainsize) {
/* Only send partial HELLO if it contains data */
if (curr_size > OLSR_HELLO_IPV6_HDRSIZE) {
#ifdef DEBUG
OLSR_PRINTF(BMSG_DBGLVL, "Sending partial(size: %d, buff left:%d)\n", curr_size, remainsize);
#endif
/* Complete the headers */
m->v6.seqno = htons(get_msg_seqno());
m->v6.olsr_msgsize = htons(curr_size);
hinfo6->size = (char *)haddr - (char *)hinfo6;
hinfo6->size = htons(hinfo6->size);
/* Send partial packet */
net_outbuffer_push(ifp, msg_buffer, curr_size);
curr_size = OLSR_HELLO_IPV6_HDRSIZE;
h6 = &m->v6.message.hello;
hinfo6 = h6->hell_info;
haddr = (union olsr_ip_addr *)hinfo6->neigh_addr;
/* Make sure typeheader is added */
first_entry = true;
}
net_output(ifp);
/* Reset size and pointers */
remainsize = net_outbuffer_bytes_left(ifp);
check_buffspace(curr_size + olsr_cnf->ipsize + 4, remainsize, "HELLO2");
}
if (first_entry) {
memset(&hinfo6->reserved, 0, sizeof(uint8_t));
/* Set link and status for this group of neighbors (this is the first) */
hinfo6->link_code = CREATE_LINK_CODE(i, j);
curr_size += 4; /* HELLO type section header */
}
*haddr = nb->address;
/* Point to next address */
haddr++;
curr_size += olsr_cnf->ipsize; /* IP address added */
first_entry = false;
} /* looping trough neighbors */
if (!first_entry) {
hinfo6->size = htons((char *)haddr - (char *)hinfo6);
hinfo6 = (struct hellinfo6 *)((char *)haddr);
haddr = (union olsr_ip_addr *)&hinfo6->neigh_addr;
}
} /* for j */
} /* for i */
m->v6.seqno = htons(get_msg_seqno());
m->v6.olsr_msgsize = htons(curr_size);
net_outbuffer_push(ifp, msg_buffer, curr_size);
/* HELLO is always buildt */
return true;
}
/**
Convert a nmeaINFO structure into an OLSR message.
@param nmeaInfo
A pointer to a nmeaINFO structure
@param olsrMessage
A pointer to an OLSR message in which to place the converted information
@param olsrMessageSize
The maximum number of bytes available for the olsrMessage
@param validityTime
the validity time of the message in seconds
@return
- the aligned size of the converted information
- 0 (zero) in case of an error
*/
unsigned int gpsToOlsr(nmeaINFO *nmeaInfo, union olsr_message *olsrMessage,
unsigned int olsrMessageSize, unsigned long long validityTime) {
unsigned int aligned_size;
unsigned int aligned_size_remainder;
size_t nodeLength;
nodeIdBinaryType * nodeIdBinary = NULL;
PudOlsrPositionUpdate * olsrGpsMessage =
getOlsrMessagePayload(olsr_cnf->ip_version, olsrMessage);
/*
* Compose message contents
*/
memset(olsrGpsMessage, 0, sizeof (PudOlsrPositionUpdate));
setPositionUpdateVersion(olsrGpsMessage, PUD_WIRE_FORMAT_VERSION);
setValidityTime(&olsrGpsMessage->validityTime, validityTime);
setPositionUpdatePresent(olsrGpsMessage, nmeaInfo->present & ~PUD_PRESENT_GATEWAY);
/* utc is always present, we make sure of that elsewhere, so just use it */
setPositionUpdateTime(olsrGpsMessage, nmeaInfo->utc.hour, nmeaInfo->utc.min,
nmeaInfo->utc.sec);
if (likely(nmea_INFO_is_present(nmeaInfo->present, LAT))) {
setPositionUpdateLatitude(olsrGpsMessage, nmeaInfo->lat);
} else {
setPositionUpdateLatitude(olsrGpsMessage, 0.0);
}
if (likely(nmea_INFO_is_present(nmeaInfo->present, LON))) {
setPositionUpdateLongitude(olsrGpsMessage, nmeaInfo->lon);
} else {
setPositionUpdateLongitude(olsrGpsMessage, 0.0);
}
if (likely(nmea_INFO_is_present(nmeaInfo->present, ELV))) {
setPositionUpdateAltitude(olsrGpsMessage, nmeaInfo->elv);
} else {
setPositionUpdateAltitude(olsrGpsMessage, 0.0);
}
if (likely(nmea_INFO_is_present(nmeaInfo->present, SPEED))) {
setPositionUpdateSpeed(olsrGpsMessage, nmeaInfo->speed);
} else {
setPositionUpdateSpeed(olsrGpsMessage, 0.0);
}
if (likely(nmea_INFO_is_present(nmeaInfo->present, TRACK))) {
setPositionUpdateTrack(olsrGpsMessage, nmeaInfo->track);
} else {
setPositionUpdateTrack(olsrGpsMessage, 0);
}
if (likely(nmea_INFO_is_present(nmeaInfo->present, HDOP))) {
setPositionUpdateHdop(olsrGpsMessage, nmeaInfo->HDOP);
} else {
setPositionUpdateHdop(olsrGpsMessage, PUD_HDOP_MAX);
}
nodeIdBinary = getNodeIdBinary();
nodeLength = setPositionUpdateNodeInfo(olsr_cnf->ip_version, olsrGpsMessage,
olsrMessageSize, getNodeIdTypeNumber(),
(unsigned char *) &nodeIdBinary->buffer, nodeIdBinary->length);
/*
* Messages in OLSR are 4-byte aligned: align
*/
/* size = type, string, string terminator */
aligned_size = PUD_OLSRWIREFORMATSIZE + nodeLength;
aligned_size_remainder = (aligned_size % 4);
if (aligned_size_remainder != 0) {
aligned_size += (4 - aligned_size_remainder);
}
/*
* Fill message headers (fill ALL fields, except message)
* Note: olsr_vtime is currently unused, we use it for our validity time.
*/
if (olsr_cnf->ip_version == AF_INET) {
/* IPv4 */
olsrMessage->v4.olsr_msgtype = PUD_OLSR_MSG_TYPE;
olsrMessage->v4.olsr_vtime = reltime_to_me(validityTime * 1000);
/* message->v4.olsr_msgsize at the end */
olsrMessage->v4.originator = olsr_cnf->main_addr.v4.s_addr;
olsrMessage->v4.ttl = getOlsrTtl();
olsrMessage->v4.hopcnt = 0;
olsrMessage->v4.seqno = htons(get_msg_seqno());
/* add length of message->v4 fields */
aligned_size += (sizeof(olsrMessage->v4)
- sizeof(olsrMessage->v4.message));
olsrMessage->v4.olsr_msgsize = htons(aligned_size);
} else {
/* IPv6 */
olsrMessage->v6.olsr_msgtype = PUD_OLSR_MSG_TYPE;
olsrMessage->v6.olsr_vtime = reltime_to_me(validityTime * 1000);
/* message->v6.olsr_msgsize at the end */
olsrMessage->v6.originator = olsr_cnf->main_addr.v6;
olsrMessage->v6.ttl = getOlsrTtl();
olsrMessage->v6.hopcnt = 0;
olsrMessage->v6.seqno = htons(get_msg_seqno());
/* add length of message->v6 fields */
aligned_size += (sizeof(olsrMessage->v6)
- sizeof(olsrMessage->v6.message));
olsrMessage->v6.olsr_msgsize = htons(aligned_size);
}
/* pad with zeroes */
if (aligned_size_remainder != 0) {
memset(&(((char *) &olsrGpsMessage->nodeInfo.nodeIdType)[nodeLength]),
0, (4 - aligned_size_remainder));
}
return aligned_size;
}
void
build_hello_msg(struct olsrv2 *olsr, olsr_pktbuf_t *pktbuf,
union olsr_ip_addr *local_iface_addr
)
{
//olsr_u8_t *msg, *msg_head;
//struct packet_header *p_header;
//static olsr_pktbuf_t *msg_tlv_buf = NULL;
//static olsr_pktbuf_t *addr_block_buf = NULL;
//static olsr_pktbuf_t *local_addr_block_buf = NULL;
olsr_pktbuf_t *msg_tlv_buf = NULL;
olsr_pktbuf_t *addr_block_buf = NULL;
olsr_pktbuf_t *local_addr_block_buf = NULL;
// initialize buffers
if (!msg_tlv_buf)
msg_tlv_buf = olsr_pktbuf_alloc_with_capa(64);
olsr_pktbuf_clear(msg_tlv_buf);
if (!addr_block_buf)
addr_block_buf = olsr_pktbuf_alloc_with_capa(64);
olsr_pktbuf_clear(addr_block_buf);
if(!local_addr_block_buf)
local_addr_block_buf = olsr_pktbuf_alloc_with_capa(64);
olsr_pktbuf_clear(local_addr_block_buf);
if(DEBUG_OLSRV2)
{
olsr_printf("Building TLV for Validity Time.\n");
}
// build message TLVs
build_message_tlv_validity_time(msg_tlv_buf,
double_to_me((double)olsr->qual_cnf->neighbor_hold_time));
if(DEBUG_OLSRV2)
{
olsr_printf("Building TLV for Interval Time.\n");
}
build_message_tlv_interval_time(msg_tlv_buf,
double_to_me((double)olsr->qual_cnf->hello_interval));
if(DEBUG_OLSRV2)
{
olsr_printf("Building TLV for Willingness.\n");
}
build_message_tlv_willingness(msg_tlv_buf, WILL_DEFAULT);
//codexxx
if(DEBUG_OLSRV2)
{
olsr_printf("Building TLV for queue length info.\n");
}
build_message_tlv_queue(msg_tlv_buf, olsr->localqueuelen);
// end codexxx
if(DEBUG_OLSRV2)
{
olsr_printf("Building local interface address block.\n");
}
//build local interface address block
build_local_addr_block(olsr, local_addr_block_buf,
local_iface_addr);
if(DEBUG_OLSRV2)
{
olsr_printf("Building {<addr-block> <tlv-block>}*.\n");
}
// build {<addr-block> <tlv-block>}*
address_compress(olsr, addr_block_buf, HELLO_MESSAGE, SIMPLE_COMPRESS,
local_iface_addr);
if(DEBUG_OLSRV2)
{
olsr_printf("Append <msg-header> and <msg-header-info>.\n");
}
// append <msg-header> and <msg-header-info>
build_message_header(olsr,
pktbuf,
(olsr_u16_t)(2 + msg_tlv_buf->len +
local_addr_block_buf->len +
addr_block_buf->len),// 2 is <tlv-length>
HELLO_MESSAGE,
local_iface_addr,
1, 0, get_msg_seqno(olsr)); // wiss: TTL=1 hopcount=0
if(DEBUG_OLSRV2)
{
olsr_printf("Append <tlv-block>.\n");
}
// append msg <tlv-block> wiss: to pkt buf ( to header and header info ya3ni)
olsr_pktbuf_append_u16(pktbuf, (olsr_u16_t)msg_tlv_buf->len);
olsr_pktbuf_append_pktbuf(pktbuf, msg_tlv_buf);
if(DEBUG_OLSRV2)
{
olsr_printf("Append local interface address block.\n");
}
// append local interface address block
olsr_pktbuf_append_pktbuf(pktbuf, local_addr_block_buf);
if(DEBUG_OLSRV2)
{
olsr_printf("Append {<addr-block> <tlv-block>}*.\n");
}
// append {<addr-block> <tlv-block>}*
if(addr_block_buf != NULL)
olsr_pktbuf_append_pktbuf(pktbuf, addr_block_buf);
free(msg_tlv_buf->data);
free(msg_tlv_buf);
free(addr_block_buf->data);
free(addr_block_buf);
free(local_addr_block_buf->data);
free(local_addr_block_buf);
}
void
build_tc_msg(struct olsrv2 *olsr, olsr_pktbuf_t *pktbuf,
union olsr_ip_addr *local_iface_addr
)
{
//olsr_u8_t *msg, *msg_head;
//struct packet_header *p_header;
//static olsr_pktbuf_t *msg_tlv_buf = NULL;
//static olsr_pktbuf_t *addr_block_buf = NULL;
//static olsr_pktbuf_t *local_addr_block_buf = NULL;
olsr_pktbuf_t *msg_tlv_buf = NULL;
olsr_pktbuf_t *addr_block_buf = NULL;
olsr_pktbuf_t *local_addr_block_buf = NULL;
// initialize buffers
if (!msg_tlv_buf)
msg_tlv_buf = olsr_pktbuf_alloc_with_capa(64);
olsr_pktbuf_clear(msg_tlv_buf);
if (!addr_block_buf)
addr_block_buf = olsr_pktbuf_alloc_with_capa(64);
olsr_pktbuf_clear(addr_block_buf);
if(!local_addr_block_buf)
local_addr_block_buf = olsr_pktbuf_alloc_with_capa(64);
olsr_pktbuf_clear(local_addr_block_buf);
if(DEBUG_OLSRV2)
{
olsr_printf("Building TLV for Validity Time.\n");
}
// build message TLVs
build_message_tlv_validity_time(msg_tlv_buf,
double_to_me((double)olsr->qual_cnf->topology_hold_time));
if(DEBUG_OLSRV2)
{
olsr_printf("Building TLV for Interval Time.\n");
}
build_message_tlv_interval_time(msg_tlv_buf,
double_to_me((double)olsr->qual_cnf->tc_interval));
if(DEBUG_OLSRV2)
{
olsr_printf("Building TLV for Content Sequence Number.\n");
}
build_message_tlv_content_seq_num(msg_tlv_buf, get_local_assn(olsr));
/*//codexxx'
if(DEBUG_OLSRV2)
{
olsr_printf("Building TLV for queue length info.\n");
}
build_message_tlv_queue(msg_tlv_buf, olsr->localqueuelen);
// end codexxx'
*/
if(DEBUG_OLSRV2)
{
olsr_printf("Building local interface address block.\n");
}
//build local interface address block
build_local_addr_block(olsr, local_addr_block_buf,
NULL);
if(DEBUG_OLSRV2)
{
olsr_printf("Advertize attached network address.\n");
}
//advertize attached network address //wiss: bass haydi el partie jdide bel TC
create_attached_network_address_block(olsr, addr_block_buf, TC_MESSAGE,
SIMPLE_COMPRESS,
local_iface_addr
);
if(DEBUG_OLSRV2)
{
olsr_printf("Building {<addr-block> <tlv-block>}*.\n");
}
// build {<addr-block> <tlv-block>}*
address_compress(olsr, addr_block_buf, TC_MESSAGE, SIMPLE_COMPRESS,
local_iface_addr
);
/* build message header */ //wiss: append <msg-header> and <msg-header-info>
build_message_header(olsr,
pktbuf,
(olsr_u16_t)(2 + msg_tlv_buf->len +
local_addr_block_buf->len +
addr_block_buf->len), // 2 is <tlv-length>
TC_MESSAGE,
local_iface_addr,
MAX_TTL, 0, get_msg_seqno(olsr)); //wiss: TTL bten2as kell ma yente2el men hop lal teni
if(DEBUG_OLSRV2)
{
olsr_printf("Append <tlv-block>.\n");
}
// append <tlv-block>
olsr_pktbuf_append_u16(pktbuf, (olsr_u16_t)msg_tlv_buf->len);
olsr_pktbuf_append_pktbuf(pktbuf, msg_tlv_buf);
if(DEBUG_OLSRV2)
{
olsr_printf("Append local interface address block.\n");
}
// append local interface address block
olsr_pktbuf_append_pktbuf(pktbuf, local_addr_block_buf);
if(DEBUG_OLSRV2)
{
olsr_printf("Append {<addr-block> <tlv-block>}*.\n");
}
// append {<addr-block> <tlv-block>}*
olsr_pktbuf_append_pktbuf(pktbuf, addr_block_buf);
free(msg_tlv_buf->data);
free(msg_tlv_buf);
free(addr_block_buf->data);
free(addr_block_buf);
free(local_addr_block_buf->data);
free(local_addr_block_buf);
}
