Major Changes:
[olsrd.git] / src / rebuild_packet.c
1 /*
2  * The olsr.org Optimized Link-State Routing daemon(olsrd)
3  * Copyright (c) 2004, Andreas T√łnnesen(andreto@olsr.org)
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without 
7  * modification, are permitted provided that the following conditions 
8  * are met:
9  *
10  * * Redistributions of source code must retain the above copyright 
11  *   notice, this list of conditions and the following disclaimer.
12  * * Redistributions in binary form must reproduce the above copyright 
13  *   notice, this list of conditions and the following disclaimer in 
14  *   the documentation and/or other materials provided with the 
15  *   distribution.
16  * * Neither the name of olsr.org, olsrd nor the names of its 
17  *   contributors may be used to endorse or promote products derived 
18  *   from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
21  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
22  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
23  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 
24  * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
26  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
27  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 
28  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN 
30  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
31  * POSSIBILITY OF SUCH DAMAGE.
32  *
33  * Visit http://www.olsr.org for more information.
34  *
35  * If you find this software useful feel free to make a donation
36  * to the project. For more information see the website or contact
37  * the copyright holders.
38  *
39  * $Id: rebuild_packet.c,v 1.26 2007/11/29 00:49:39 bernd67 Exp $
40  */
41
42
43 #include "rebuild_packet.h"
44 #include "ipcalc.h"
45 #include "defs.h"
46 #include "olsr.h"
47 #include "mid_set.h"
48 #include "mantissa.h"
49 #include "net_olsr.h"
50
51 /**
52  *Process/rebuild HNA message. Converts the OLSR
53  *packet to the internal hna_message format.
54  *@param hmsg the hna_message struct in wich infomation
55  *is to be put.
56  *@param m the entire OLSR message revieved.
57  *@return negative on error
58  */
59
60 void
61 hna_chgestruct(struct hna_message *hmsg, const union olsr_message *m)
62 {
63   struct hna_net_addr *hna_pairs, *tmp_pairs;
64   int no_pairs, i;
65
66   /*Check if everyting is ok*/
67   if ((!m) || (m->v4.olsr_msgtype != HNA_MESSAGE))
68     return;
69   
70
71   if(olsr_cnf->ip_version == AF_INET)
72     {
73       /* IPv4 */
74       const struct hnapair *haddr = m->v4.message.hna.hna_net;
75
76       /*
77        * How many HNA pairs?
78        * nextmsg contains size of
79        * the addresses + 12 bytes(nextmessage, from address and the header)
80        */
81       no_pairs = (ntohs(m->v4.olsr_msgsize) - 12) / 8;
82       
83       //COPY_IP(&hmsg->originator, &m->v4.originator);
84       hmsg->originator.v4.s_addr = m->v4.originator;
85
86       hmsg->packet_seq_number = ntohs(m->v4.seqno);
87       hmsg->hop_count =  m->v4.hopcnt;
88
89       //printf("HNA from %s\n\n", olsr_ip_to_string(&buf, (union olsr_ip_addr *)&hmsg->originator));
90
91       /* Get vtime */
92       hmsg->vtime = me_to_double(m->v4.olsr_vtime);
93
94       tmp_pairs = NULL;
95       hna_pairs = NULL;
96
97       for(i = 0; i < no_pairs; i++) {     
98           hna_pairs = olsr_malloc(sizeof(struct hna_net_addr), "HNA chgestruct");
99           
100           //COPY_IP(&hna_pairs->net, &haddr->addr);
101           hna_pairs->net.v4.s_addr = haddr->addr;
102           //COPY_IP(&hna_pairs->netmask, &haddr->netmask);
103           hna_pairs->prefixlen = olsr_netmask4_to_prefix(&haddr->netmask);
104
105           hna_pairs->next = tmp_pairs;    
106           tmp_pairs = hna_pairs;
107           haddr++;
108         }
109     }
110   else
111     {
112       /* IPv6 */
113       const struct hnapair6 *haddr6 = m->v6.message.hna.hna_net;
114
115       /*
116        * How many HNA pairs?
117        * nextmsg contains size of
118        * the addresses + 12 bytes(nextmessage, from address and the header)
119        */
120       no_pairs = (ntohs(m->v6.olsr_msgsize) - 24) / 32; /* NB 32 not 8 */
121       
122       //COPY_IP(&hmsg->originator, &m->v6.originator);
123       hmsg->originator.v6 = m->v6.originator;
124       hmsg->packet_seq_number = ntohs(m->v6.seqno);
125       hmsg->hop_count =  m->v6.hopcnt;
126       
127       /* Get vtime */
128       hmsg->vtime = me_to_double(m->v6.olsr_vtime);
129       
130       tmp_pairs = NULL;
131       hna_pairs = NULL;
132       
133       for(i = 0; i < no_pairs; i++)
134         {
135           
136           hna_pairs = olsr_malloc(sizeof(struct hna_net_addr), "HNA chgestruct 2");       
137           
138           //COPY_IP(&hna_pairs->net, &haddr6->addr);
139           hna_pairs->net.v6 = haddr6->addr;
140           hna_pairs->prefixlen = olsr_netmask6_to_prefix(&haddr6->netmask);
141
142           hna_pairs->next = tmp_pairs;
143           
144           tmp_pairs = hna_pairs;
145           haddr6++;       
146         }
147     }      
148
149   /* 
150      tmp_pairs = hna_pairs;
151          
152      while(tmp_pairs)
153      {
154      printf("\t net: %s ", ip_to_string(&tmp_pairs->net));
155      printf("\t mask: %s\n", ip_to_string(&tmp_pairs->netmask));
156      tmp_pairs = tmp_pairs->next;
157      }
158      printf("\n");
159   */
160
161
162
163   hmsg->hna_net = hna_pairs;
164  
165 }
166
167
168 /**
169  *Process/rebuild MID message. Converts the OLSR
170  *packet to the internal mid_message format.
171  *@param mmsg the mid_message struct in wich infomation
172  *is to be put.
173  *@param m the entire OLSR message revieved.
174  *@return negative on error
175  */
176
177 void
178 mid_chgestruct(struct mid_message *mmsg, const union olsr_message *m)
179 {
180   int i;
181   struct mid_alias *alias, *alias_tmp;
182   int no_aliases;
183
184   /* Checking if everything is ok */
185   if ((!m) || (m->v4.olsr_msgtype != MID_MESSAGE))
186     return;
187
188   alias = NULL;
189
190   if(olsr_cnf->ip_version == AF_INET)
191     {
192       /* IPv4 */
193       const struct midaddr *maddr = m->v4.message.mid.mid_addr;
194       /*
195        * How many aliases?
196        * nextmsg contains size of
197        * the addresses + 12 bytes(nextmessage, from address and the header)
198        */
199       no_aliases =  ((ntohs(m->v4.olsr_msgsize) - 12) / 4);
200
201       //printf("Aliases: %d\n", no_aliases);
202       //COPY_IP(&mmsg->mid_origaddr, &m->v4.originator);
203       mmsg->mid_origaddr.v4.s_addr = m->v4.originator;
204       //COPY_IP(&mmsg->addr, &m->v4.originator);
205       mmsg->addr.v4.s_addr = m->v4.originator;
206       /*seq number*/
207       mmsg->mid_seqno = ntohs(m->v4.seqno);
208       mmsg->mid_addr = NULL;
209
210       /* Get vtime */
211       mmsg->vtime = me_to_double(m->v4.olsr_vtime);
212
213       //printf("Sequencenuber of MID from %s is %d\n", ip_to_string(&mmsg->addr), mmsg->mid_seqno);
214
215
216       for(i = 0; i < no_aliases; i++)
217         {
218           alias = olsr_malloc(sizeof(struct mid_alias), "MID chgestruct");
219           
220           //COPY_IP(&alias->alias_addr, &maddr->addr);
221           alias->alias_addr.v4.s_addr = maddr->addr;
222           alias->next = mmsg->mid_addr;
223           mmsg->mid_addr = alias;
224           maddr++;
225         }
226       
227       
228       if(olsr_cnf->debug_level > 1)
229         {
230 #ifndef NODEBUG
231           struct ipaddr_str buf;
232 #endif
233           OLSR_PRINTF(3, "Alias list for %s: ", olsr_ip_to_string(&buf, &mmsg->mid_origaddr));
234           OLSR_PRINTF(3, "%s", olsr_ip_to_string(&buf, &mmsg->addr));
235           alias_tmp = mmsg->mid_addr;
236           while(alias_tmp)
237             {
238               OLSR_PRINTF(3, " - %s", olsr_ip_to_string(&buf, &alias_tmp->alias_addr));
239               alias_tmp = alias_tmp->next;
240             }
241           OLSR_PRINTF(3, "\n");
242         }
243     }
244   else
245     {
246       /* IPv6 */
247       const struct midaddr6 *maddr6 = m->v6.message.mid.mid_addr;
248       /*
249        * How many aliases?
250        * nextmsg contains size of
251        * the addresses + 12 bytes(nextmessage, from address and the header)
252        */
253       no_aliases =  ((ntohs(m->v6.olsr_msgsize) - 12) / 16); /* NB 16 */
254
255       //printf("Aliases: %d\n", no_aliases);
256       //COPY_IP(&mmsg->mid_origaddr, &m->v6.originator);
257       mmsg->mid_origaddr.v6 = m->v6.originator;
258       //COPY_IP(&mmsg->addr, &m->v6.originator);
259       mmsg->addr.v6 = m->v6.originator;
260       /*seq number*/
261       mmsg->mid_seqno = ntohs(m->v6.seqno);
262       mmsg->mid_addr = NULL;
263
264       /* Get vtime */
265       mmsg->vtime = me_to_double(m->v6.olsr_vtime);
266
267       //printf("Sequencenuber of MID from %s is %d\n", ip_to_string(&mmsg->addr), mmsg->mid_seqno);
268
269       for(i = 0; i < no_aliases; i++)
270         {
271           alias = olsr_malloc(sizeof(struct mid_alias), "MID chgestruct 2");
272           
273           //printf("Adding alias: %s\n", olsr_ip_to_string(&buf, (union olsr_ip_addr *)&maddr6->addr));
274           //COPY_IP(&alias->alias_addr, &maddr6->addr);
275           alias->alias_addr.v6 = maddr6->addr;
276           alias->next = mmsg->mid_addr;
277           mmsg->mid_addr = alias;
278            
279           maddr6++;
280         }
281
282
283       if(olsr_cnf->debug_level > 1)
284         {
285 #ifndef NODEBUG
286           struct ipaddr_str buf;
287 #endif
288           OLSR_PRINTF(3, "Alias list for %s", ip6_to_string(&buf, &mmsg->mid_origaddr.v6));
289           OLSR_PRINTF(3, "%s", ip6_to_string(&buf, &mmsg->addr.v6));
290
291           alias_tmp = mmsg->mid_addr;
292           while(alias_tmp)
293             {
294               OLSR_PRINTF(3, " - %s", ip6_to_string(&buf, &alias_tmp->alias_addr.v6));
295               alias_tmp = alias_tmp->next;
296             }
297           OLSR_PRINTF(3, "\n");
298         }
299     }
300
301 }
302
303
304
305
306 /**
307  *Process/rebuild a message of unknown type. Converts the OLSR
308  *packet to the internal unknown_message format.
309  *@param umsg the unknown_message struct in wich infomation
310  *is to be put.
311  *@param m the entire OLSR message revieved.
312  *@return negative on error
313  */
314
315 void
316 unk_chgestruct(struct unknown_message *umsg, const union olsr_message *m)
317 {
318
319   /* Checking if everything is ok */
320   if (!m)
321     return;
322
323
324   if(olsr_cnf->ip_version == AF_INET)
325     {
326       /* IPv4 */
327       /* address */
328       //COPY_IP(&umsg->originator, &m->v4.originator);
329       umsg->originator.v4.s_addr = m->v4.originator;
330       /*seq number*/
331       umsg->seqno = ntohs(m->v4.seqno);
332       /* type */
333       umsg->type = m->v4.olsr_msgtype;
334     }
335   else
336     {
337       /* IPv6 */
338       /* address */
339       //COPY_IP(&umsg->originator, &m->v6.originator);
340       umsg->originator.v6 = m->v6.originator;
341       /*seq number*/
342       umsg->seqno = ntohs(m->v6.seqno);
343       /* type */
344       umsg->type = m->v4.olsr_msgtype;
345     }
346   
347 }
348
349
350
351 /**
352  *Process/rebuild HELLO message. Converts the OLSR
353  *packet to the internal hello_message format.
354  *@param hmsg the hello_message struct in wich infomation
355  *is to be put.
356  *@param m the entire OLSR message revieved.
357  *@return negative on error
358  */
359
360 void
361 hello_chgestruct(struct hello_message *hmsg, const union olsr_message *m)
362 {
363   const union olsr_ip_addr *hadr;
364   struct hello_neighbor *nb;
365   
366   hmsg->neighbors = NULL;
367
368   if ((!m) || (m->v4.olsr_msgtype != HELLO_MESSAGE))
369     return;
370
371   if(olsr_cnf->ip_version == AF_INET)
372     {
373       const struct hellinfo *hinf;
374
375       /* IPv4 */
376       //COPY_IP(&hmsg->source_addr, &m->v4.originator);
377       hmsg->source_addr.v4.s_addr = m->v4.originator;
378       hmsg->packet_seq_number = ntohs(m->v4.seqno);
379
380
381       /* Get vtime */
382       hmsg->vtime = me_to_double(m->v4.olsr_vtime);
383
384       /* Get htime */
385       hmsg->htime = me_to_double(m->v4.message.hello.htime);
386
387       /* Willingness */
388       hmsg->willingness = m->v4.message.hello.willingness;
389
390       OLSR_PRINTF(3, "Got HELLO vtime: %f htime: %f\n", hmsg->vtime, hmsg->htime);
391
392       for (hinf = m->v4.message.hello.hell_info; 
393            (const char *)hinf < ((const char *)m + (ntohs(m->v4.olsr_msgsize))); 
394            hinf = (const struct hellinfo *)((const char *)hinf + ntohs(hinf->size)))
395         {
396           
397           for (hadr = (const union olsr_ip_addr  *)&hinf->neigh_addr; 
398                (const char *)hadr < (const char *)hinf + ntohs(hinf->size); 
399                hadr = (const union olsr_ip_addr *)&hadr->v6.s6_addr[4])
400             {
401               nb = olsr_malloc(sizeof (struct hello_neighbor), "HELLO chgestruct");
402
403               //COPY_IP(&nb->address, hadr);
404               nb->address = *hadr;
405
406               /* Fetch link and status */
407               nb->link = EXTRACT_LINK(hinf->link_code);
408               nb->status = EXTRACT_STATUS(hinf->link_code);
409
410               nb->next = hmsg->neighbors;
411               hmsg->neighbors = nb;
412             }
413         }
414
415       
416     }
417   else
418     {
419       const struct hellinfo6 *hinf6;
420
421       /* IPv6 */
422       //COPY_IP(&hmsg->source_addr, &m->v6.originator);
423       hmsg->source_addr.v6 = m->v6.originator;
424       //printf("parsing HELLO from %s\n", olsr_ip_to_string(&buf, &hmsg->source_addr));
425       hmsg->packet_seq_number = ntohs(m->v6.seqno);
426
427       /* Get vtime */
428       hmsg->vtime = me_to_double(m->v6.olsr_vtime);
429
430       /* Get htime */
431       hmsg->htime = me_to_double(m->v6.message.hello.htime);
432
433       /* Willingness */
434       hmsg->willingness = m->v6.message.hello.willingness;
435
436       OLSR_PRINTF(3, "Got HELLO vtime: %f htime: %f\n", hmsg->vtime, hmsg->htime);
437
438
439       for (hinf6 = m->v6.message.hello.hell_info; 
440            (const char *)hinf6 < ((const char *)m + (ntohs(m->v6.olsr_msgsize))); 
441            hinf6 = (const struct hellinfo6 *)((const char *)hinf6 + ntohs(hinf6->size)))
442         {
443
444           for (hadr = (const union olsr_ip_addr *)hinf6->neigh_addr; 
445                (const char *)hadr < (const char *)hinf6 + ntohs(hinf6->size); 
446                hadr++)
447             {
448               nb = olsr_malloc(sizeof (struct hello_neighbor), "OLSR chgestruct 2");
449
450               //COPY_IP(&nb->address, hadr);
451               nb->address = *hadr;
452
453               /* Fetch link and status */
454               nb->link = EXTRACT_LINK(hinf6->link_code);
455               nb->status = EXTRACT_STATUS(hinf6->link_code);
456
457               nb->next = hmsg->neighbors;
458               hmsg->neighbors = nb;
459             }
460         }
461
462     }
463
464 }