]> git.sommitrealweird.co.uk Git - quagga-debian.git/blob - isisd/isis_misc.c
New upstream version 1.2.4
[quagga-debian.git] / isisd / isis_misc.c
1 /*
2  * IS-IS Rout(e)ing protocol - isis_misc.h
3  *                             Miscellanous routines
4  *
5  * Copyright (C) 2001,2002   Sampo Saaristo
6  *                           Tampere University of Technology      
7  *                           Institute of Communications Engineering
8  *
9  * This program is free software; you can redistribute it and/or modify it 
10  * under the terms of the GNU General Public Licenseas published by the Free 
11  * Software Foundation; either version 2 of the License, or (at your option) 
12  * any later version.
13  *
14  * This program is distributed in the hope that it will be useful,but WITHOUT 
15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 
16  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for 
17  * more details.
18
19  * You should have received a copy of the GNU General Public License along 
20  * with this program; if not, write to the Free Software Foundation, Inc., 
21  * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  */
23
24 #include <zebra.h>
25
26 #include "stream.h"
27 #include "vty.h"
28 #include "hash.h"
29 #include "if.h"
30 #include "command.h"
31
32 #include "isisd/dict.h"
33 #include "isisd/isis_constants.h"
34 #include "isisd/isis_common.h"
35 #include "isisd/isis_flags.h"
36 #include "isisd/isis_circuit.h"
37 #include "isisd/isis_csm.h"
38 #include "isisd/isisd.h"
39 #include "isisd/isis_misc.h"
40
41 #include "isisd/isis_tlv.h"
42 #include "isisd/isis_lsp.h"
43 #include "isisd/isis_constants.h"
44 #include "isisd/isis_adjacency.h"
45 #include "isisd/isis_dynhn.h"
46
47 /* staticly assigned vars for printing purposes */
48 struct in_addr new_prefix;
49 /* len of xxxx.xxxx.xxxx + place for #0 termination */
50 char sysid[15];
51 /* len of xxxx.xxxx.xxxx + place for #0 termination */
52 char snpa[15];
53 /* len of xx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.xx */
54 char isonet[51];
55 /* + place for #0 termination */
56 /* len of xxxx.xxxx.xxxx.xx.xx + place for #0 termination */
57 char lspid[21];
58 /* len of xxYxxMxWxdxxhxxmxxs + place for #0 termination */
59 char datestring[20];
60 char nlpidstring[30];
61
62 /*
63  * This converts the isonet to its printable format
64  */
65 const char *
66 isonet_print (const u_char * from, int len)
67 {
68   int i = 0;
69   char *pos = isonet;
70
71   if (!from)
72     return "unknown";
73
74   while (i < len)
75     {
76       if (i & 1)
77         {
78           sprintf (pos, "%02x", *(from + i));
79           pos += 2;
80         }
81       else
82         {
83           if (i == (len - 1))
84             {                   /* No dot at the end of address */
85               sprintf (pos, "%02x", *(from + i));
86               pos += 2;
87             }
88           else
89             {
90               sprintf (pos, "%02x.", *(from + i));
91               pos += 3;
92             }
93         }
94       i++;
95     }
96   *(pos) = '\0';
97   return isonet;
98 }
99
100 /*
101  * Returns 0 on error, length of buff on ok
102  * extract dot from the dotted str, and insert all the number in a buff 
103  */
104 int
105 dotformat2buff (u_char * buff, const char * dotted)
106 {
107   int dotlen, len = 0;
108   const char *pos = dotted;
109   u_char number[3];
110   int nextdotpos = 2;
111
112   number[2] = '\0';
113   dotlen = strlen(dotted);
114   if (dotlen > 50)
115     {
116       /* this can't be an iso net, its too long */
117       return 0;
118     }
119
120   while ((pos - dotted) < dotlen && len < 20)
121     {
122       if (*pos == '.')
123         {
124           /* we expect the . at 2, and than every 5 */
125           if ((pos - dotted) != nextdotpos)
126             {
127               len = 0;
128               break;
129             }
130           nextdotpos += 5;
131           pos++;
132           continue;
133         }
134       /* we must have at least two chars left here */
135       if (dotlen - (pos - dotted) < 2)
136         {
137           len = 0;
138           break;
139         }
140
141       if ((isxdigit ((int) *pos)) && (isxdigit ((int) *(pos + 1))))
142         {
143           memcpy (number, pos, 2);
144           pos += 2;
145         }
146       else
147         {
148           len = 0;
149           break;
150         }
151
152       *(buff + len) = (char) strtol ((char *)number, NULL, 16);
153       len++;
154     }
155
156   return len;
157 }
158
159 /*
160  * conversion of XXXX.XXXX.XXXX to memory
161  */
162 int
163 sysid2buff (u_char * buff, const char * dotted)
164 {
165   int len = 0;
166   const char *pos = dotted;
167   u_char number[3];
168
169   number[2] = '\0';
170   // surely not a sysid_string if not 14 length
171   if (strlen (dotted) != 14)
172     {
173       return 0;
174     }
175
176   while (len < ISIS_SYS_ID_LEN)
177     {
178       if (*pos == '.')
179         {
180           /* the . is not positioned correctly */
181           if (((pos - dotted) != 4) && ((pos - dotted) != 9))
182             {
183               len = 0;
184               break;
185             }
186           pos++;
187           continue;
188         }
189       if ((isxdigit ((int) *pos)) && (isxdigit ((int) *(pos + 1))))
190         {
191           memcpy (number, pos, 2);
192           pos += 2;
193         }
194       else
195         {
196           len = 0;
197           break;
198         }
199
200       *(buff + len) = (char) strtol ((char *)number, NULL, 16);
201       len++;
202     }
203
204   return len;
205
206 }
207
208 /*
209  * converts the nlpids struct (filled by TLV #129)
210  * into a string
211  */
212
213 char *
214 nlpid2string (struct nlpids *nlpids)
215 {
216   char *pos = nlpidstring;
217   int i;
218
219   for (i = 0; i < nlpids->count; i++)
220     {
221       switch (nlpids->nlpids[i])
222         {
223         case NLPID_IP:
224           pos += sprintf (pos, "IPv4");
225           break;
226         case NLPID_IPV6:
227           pos += sprintf (pos, "IPv6");
228           break;
229         case NLPID_SNAP:
230           pos += sprintf (pos, "SNAP");
231           break;
232         case NLPID_CLNP:
233           pos += sprintf (pos, "CLNP");
234           break;
235         case NLPID_ESIS:
236           pos += sprintf (pos, "ES-IS");
237           break;
238         default:
239           pos += sprintf (pos, "unknown");
240           break;
241         }
242       if (nlpids->count - i > 1)
243         pos += sprintf (pos, ", ");
244
245     }
246
247   *(pos) = '\0';
248
249   return nlpidstring;
250 }
251
252 /*
253  *  supports the given af ?
254  */
255 int
256 speaks (struct nlpids *nlpids, int family)
257 {
258   int i, speaks = 0;
259
260   if (nlpids == (struct nlpids *) NULL)
261     return speaks;
262   for (i = 0; i < nlpids->count; i++)
263     {
264       if (family == AF_INET && nlpids->nlpids[i] == NLPID_IP)
265         speaks = 1;
266       if (family == AF_INET6 && nlpids->nlpids[i] == NLPID_IPV6)
267         speaks = 1;
268     }
269
270   return speaks;
271 }
272
273 /*
274  * Returns 0 on error, IS-IS Circuit Type on ok
275  */
276 int
277 string2circuit_t (const char * str)
278 {
279
280   if (!str)
281     return 0;
282
283   if (!strcmp (str, "level-1"))
284     return IS_LEVEL_1;
285
286   if (!strcmp (str, "level-2-only") || !strcmp (str, "level-2"))
287     return IS_LEVEL_2;
288
289   if (!strcmp (str, "level-1-2"))
290     return IS_LEVEL_1_AND_2;
291
292   return 0;
293 }
294
295 const char *
296 circuit_state2string (int state)
297 {
298
299   switch (state)
300     {
301     case C_STATE_INIT:
302       return "Init";
303     case C_STATE_CONF:
304       return "Config";
305     case C_STATE_UP:
306       return "Up";
307     default:
308       return "Unknown";
309     }
310   return NULL;
311 }
312
313 const char *
314 circuit_type2string (int type)
315 {
316
317   switch (type)
318     {
319     case CIRCUIT_T_P2P:
320       return "p2p";
321     case CIRCUIT_T_BROADCAST:
322       return "lan";
323     case CIRCUIT_T_LOOPBACK:
324       return "loopback";
325     default:
326       return "Unknown";
327     }
328   return NULL;
329 }
330
331 const char *
332 circuit_t2string (int circuit_t)
333 {
334   switch (circuit_t)
335     {
336     case IS_LEVEL_1:
337       return "L1";
338     case IS_LEVEL_2:
339       return "L2";
340     case IS_LEVEL_1_AND_2:
341       return "L1L2";
342     default:
343       return "??";
344     }
345
346   return NULL;                  /* not reached */
347 }
348
349 const char *
350 syst2string (int type)
351 {
352   switch (type)
353     {
354     case ISIS_SYSTYPE_ES:
355       return "ES";
356     case ISIS_SYSTYPE_IS:
357       return "IS";
358     case ISIS_SYSTYPE_L1_IS:
359       return "1";
360     case ISIS_SYSTYPE_L2_IS:
361       return "2";
362     default:
363       return "??";
364     }
365
366   return NULL;                  /* not reached */
367 }
368
369 /*
370  * Print functions - we print to static vars
371  */
372 const char *
373 snpa_print (const u_char * from)
374 {
375   int i = 0;
376   u_char *pos = (u_char *)snpa;
377
378   if (!from)
379     return "unknown";
380
381   while (i < ETH_ALEN - 1)
382     {
383       if (i & 1)
384         {
385           sprintf ((char *)pos, "%02x.", *(from + i));
386           pos += 3;
387         }
388       else
389         {
390           sprintf ((char *)pos, "%02x", *(from + i));
391           pos += 2;
392
393         }
394       i++;
395     }
396
397   sprintf ((char *)pos, "%02x", *(from + (ISIS_SYS_ID_LEN - 1)));
398   pos += 2;
399   *(pos) = '\0';
400
401   return snpa;
402 }
403
404 const char *
405 sysid_print (const u_char * from)
406 {
407   int i = 0;
408   char *pos = sysid;
409
410   if (!from)
411     return "unknown";
412
413   while (i < ISIS_SYS_ID_LEN - 1)
414     {
415       if (i & 1)
416         {
417           sprintf (pos, "%02x.", *(from + i));
418           pos += 3;
419         }
420       else
421         {
422           sprintf (pos, "%02x", *(from + i));
423           pos += 2;
424
425         }
426       i++;
427     }
428
429   sprintf (pos, "%02x", *(from + (ISIS_SYS_ID_LEN - 1)));
430   pos += 2;
431   *(pos) = '\0';
432
433   return sysid;
434 }
435
436 const char *
437 rawlspid_print (const u_char * from)
438 {
439   char *pos = lspid;
440   if (!from)
441     return "unknown";
442   memcpy (pos, sysid_print (from), 15);
443   pos += 14;
444   sprintf (pos, ".%02x", LSP_PSEUDO_ID (from));
445   pos += 3;
446   sprintf (pos, "-%02x", LSP_FRAGMENT (from));
447   pos += 3;
448
449   *(pos) = '\0';
450
451   return lspid;
452 }
453
454 const char *
455 time2string (u_int32_t time)
456 {
457   char *pos = datestring;
458   u_int32_t rest;
459
460   if (time == 0)
461     return "-";
462
463   if (time / SECS_PER_YEAR)
464     pos += sprintf (pos, "%uY", time / SECS_PER_YEAR);
465   rest = time % SECS_PER_YEAR;
466   if (rest / SECS_PER_MONTH)
467     pos += sprintf (pos, "%uM", rest / SECS_PER_MONTH);
468   rest = rest % SECS_PER_MONTH;
469   if (rest / SECS_PER_WEEK)
470     pos += sprintf (pos, "%uw", rest / SECS_PER_WEEK);
471   rest = rest % SECS_PER_WEEK;
472   if (rest / SECS_PER_DAY)
473     pos += sprintf (pos, "%ud", rest / SECS_PER_DAY);
474   rest = rest % SECS_PER_DAY;
475   if (rest / SECS_PER_HOUR)
476     pos += sprintf (pos, "%uh", rest / SECS_PER_HOUR);
477   rest = rest % SECS_PER_HOUR;
478   if (rest / SECS_PER_MINUTE)
479     pos += sprintf (pos, "%um", rest / SECS_PER_MINUTE);
480   rest = rest % SECS_PER_MINUTE;
481   if (rest)
482     pos += sprintf (pos, "%us", rest);
483
484   *(pos) = 0;
485
486   return datestring;
487 }
488
489 /*
490  * routine to decrement a timer by a random
491  * number
492  *
493  * first argument is the timer and the second is
494  * the jitter
495  */
496 unsigned long
497 isis_jitter (unsigned long timer, unsigned long jitter)
498 {
499   int j, k;
500
501   if (jitter >= 100)
502     return timer;
503
504   if (timer == 1)
505     return timer;
506   /* 
507    * randomizing just the percent value provides
508    * no good random numbers - hence the spread
509    * to RANDOM_SPREAD (100000), which is ok as
510    * most IS-IS timers are no longer than 16 bit
511    */
512
513   j = 1 + (int) ((RANDOM_SPREAD * random ()) / (RAND_MAX + 1.0));
514
515   k = timer - (timer * (100 - jitter)) / 100;
516
517   timer = timer - (k * j / RANDOM_SPREAD);
518
519   return timer;
520 }
521
522 struct in_addr
523 newprefix2inaddr (u_char * prefix_start, u_char prefix_masklen)
524 {
525   memset (&new_prefix, 0, sizeof (new_prefix));
526   memcpy (&new_prefix, prefix_start, (prefix_masklen & 0x3F) ?
527           ((((prefix_masklen & 0x3F) - 1) >> 3) + 1) : 0);
528   return new_prefix;
529 }
530
531 /*
532  * Returns host.name if any, otherwise
533  * it returns the system hostname.
534  */
535 const char *
536 unix_hostname (void)
537 {
538   static struct utsname names;
539   const char *hostname;
540
541   hostname = host.name;
542   if (!hostname)
543     {
544       uname (&names);
545       hostname = names.nodename;
546     }
547
548   return hostname;
549 }
550
551 /*
552  * Returns the dynamic hostname associated with the passed system ID.
553  * If no dynamic hostname found then returns formatted system ID.
554  */
555 const char *
556 print_sys_hostname (const u_char *sysid)
557 {
558   struct isis_dynhn *dyn;
559
560   if (!sysid)
561     return "nullsysid";
562
563   /* For our system ID return our host name */
564   if (memcmp(sysid, isis->sysid, ISIS_SYS_ID_LEN) == 0)
565     return unix_hostname();
566
567   dyn = dynhn_find_by_id (sysid);
568   if (dyn)
569     return (const char *)dyn->name.name;
570
571   return sysid_print (sysid);
572 }
573
574 /*
575  * This function is a generic utility that logs data of given length.
576  * Move this to a shared lib so that any protocol can use it.
577  */
578 void
579 zlog_dump_data (void *data, int len)
580 {
581   int i;
582   unsigned char *p;
583   unsigned char c;
584   char bytestr[4];
585   char addrstr[10];
586   char hexstr[ 16*3 + 5];
587   char charstr[16*1 + 5];
588
589   p = data;
590   memset (bytestr, 0, sizeof(bytestr));
591   memset (addrstr, 0, sizeof(addrstr));
592   memset (hexstr, 0, sizeof(hexstr));
593   memset (charstr, 0, sizeof(charstr));
594
595   for (i = 1; i <= len; i++)
596   {
597     c = *p;
598     if (isalnum (c) == 0)
599       c = '.';
600
601     /* store address for this line */
602     if ((i % 16) == 1)
603       snprintf (addrstr, sizeof(addrstr), "%p", p);
604
605     /* store hex str (for left side) */
606     snprintf (bytestr, sizeof (bytestr), "%02X ", *p);
607     strncat (hexstr, bytestr, sizeof (hexstr) - strlen (hexstr) - 1);
608
609     /* store char str (for right side) */
610     snprintf (bytestr, sizeof (bytestr), "%c", c);
611     strncat (charstr, bytestr, sizeof (charstr) - strlen (charstr) - 1);
612
613     if ((i % 16) == 0)
614     {
615       /* line completed */
616       zlog_debug ("[%8.8s]   %-50.50s  %s", addrstr, hexstr, charstr);
617       hexstr[0] = 0;
618       charstr[0] = 0;
619     }
620     else if ((i % 8) == 0)
621     {
622       /* half line: add whitespaces */
623       strncat (hexstr, "  ", sizeof (hexstr) - strlen (hexstr) - 1);
624       strncat (charstr, " ", sizeof (charstr) - strlen (charstr) - 1);
625     }
626     p++; /* next byte */
627   }
628
629   /* print rest of buffer if not empty */
630   if (strlen (hexstr) > 0)
631     zlog_debug ("[%8.8s]   %-50.50s  %s", addrstr, hexstr, charstr);
632   return;
633 }