* killed unused functions
[olsrd.git] / src / cfgparser / olsrd_conf.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: olsrd_conf.c,v 1.56 2007/10/22 21:02:49 bernd67 Exp $
40  */
41
42
43 #include <stdio.h>
44 #include <string.h>
45 #include <errno.h>
46 #include <stdlib.h>
47 #include <sys/types.h>
48 #include <sys/socket.h>
49 #include <netinet/in.h>
50 #include <arpa/inet.h>
51
52 #include "olsrd_conf.h"
53
54
55 extern FILE *yyin;
56 extern int yyparse(void);
57
58 static char copyright_string[] = "The olsr.org Optimized Link-State Routing daemon(olsrd) Copyright (c) 2004, Andreas T√łnnesen(andreto@olsr.org) All rights reserved.";
59
60 #ifdef MAKEBIN
61
62 /* Build as standalone binary */
63 int 
64 main(int argc, char *argv[])
65 {
66   struct olsrd_config *cnf;
67
68   if(argc == 1)
69     {
70       fprintf(stderr, "Usage: olsrd_cfgparser [filename] -print\n\n");
71       exit(EXIT_FAILURE);
72     }
73
74   if((cnf = olsrd_parse_cnf(argv[1])) != NULL)
75     {
76       if((argc > 2) && (!strcmp(argv[2], "-print")))
77         {
78           olsrd_print_cnf(cnf);  
79           olsrd_write_cnf(cnf, "./out.conf");
80         }
81       else
82         printf("Use -print to view parsed values\n");
83       printf("Configfile parsed OK\n");
84     }
85   else
86     {
87       printf("Failed parsing \"%s\"\n", argv[1]);
88     }
89
90   return 0;
91 }
92
93 #else
94
95 /* Build as part of olsrd */
96
97
98 #endif
99
100 struct olsrd_config *
101 olsrd_parse_cnf(const char *filename)
102 {
103   struct olsr_if *in, *new_ifqueue, *in_tmp;
104
105   /* Stop the compiler from complaining */
106   (void)strlen(copyright_string);
107
108   cnf = malloc(sizeof(struct olsrd_config));
109   if (cnf == NULL)
110     {
111       fprintf(stderr, "Out of memory %s\n", __func__);
112       return NULL;
113     }
114
115   set_default_cnf(cnf);
116
117   printf("Parsing file: \"%s\"\n", filename);
118
119   yyin = fopen(filename, "r");
120   
121   if (yyin == NULL)
122     {
123       fprintf(stderr, "Cannot open configuration file '%s': %s.\n",
124               filename, strerror(errno));
125       free(cnf);
126       return NULL;
127     }
128
129   current_line = 1;
130
131   if (yyparse() != 0)
132     {
133       fclose(yyin);
134       olsrd_free_cnf(cnf);
135       return NULL;
136     }
137   
138   fclose(yyin);
139
140   /* Reverse the queue (added by user request) */
141   in = cnf->interfaces;
142   new_ifqueue = NULL;
143
144   while(in)
145     {
146       in_tmp = in; 
147       in = in->next;
148
149       in_tmp->next = new_ifqueue;
150       new_ifqueue = in_tmp;
151     }
152
153   cnf->interfaces = new_ifqueue;
154
155   in = cnf->interfaces;
156
157   while(in)
158     {
159       /* set various stuff */
160       in->configured = OLSR_FALSE;
161       in->interf = NULL;
162       in->host_emul = OLSR_FALSE;
163       in = in->next;
164     }
165
166
167   return cnf;
168 }
169
170
171 int
172 olsrd_sanity_check_cnf(struct olsrd_config *cnf)
173 {
174   struct olsr_if           *in = cnf->interfaces;
175   struct if_config_options *io;
176
177   /* Debug level */
178   if(cnf->debug_level < MIN_DEBUGLVL ||
179      cnf->debug_level > MAX_DEBUGLVL)
180     {
181       fprintf(stderr, "Debuglevel %d is not allowed\n", cnf->debug_level);
182       return -1;
183     }
184
185   /* IP version */
186   if(cnf->ip_version != AF_INET &&
187      cnf->ip_version != AF_INET6)
188     {
189       fprintf(stderr, "Ipversion %d not allowed!\n", cnf->ip_version);
190       return -1;
191     }
192
193   /* TOS */
194   if(//cnf->tos < MIN_TOS ||
195      cnf->tos > MAX_TOS)
196     {
197       fprintf(stderr, "TOS %d is not allowed\n", cnf->tos);
198       return -1;
199     }
200
201   if(cnf->willingness_auto == OLSR_FALSE &&
202      (cnf->willingness > MAX_WILLINGNESS))
203     {
204       fprintf(stderr, "Willingness %d is not allowed\n", cnf->willingness);
205       return -1;
206     }
207
208   /* Hysteresis */
209   if(cnf->use_hysteresis == OLSR_TRUE)
210     {
211       if(cnf->hysteresis_param.scaling < MIN_HYST_PARAM ||
212          cnf->hysteresis_param.scaling > MAX_HYST_PARAM)
213         {
214           fprintf(stderr, "Hyst scaling %0.2f is not allowed\n", cnf->hysteresis_param.scaling);
215           return -1;
216         }
217
218       if(cnf->hysteresis_param.thr_high <= cnf->hysteresis_param.thr_low)
219         {
220           fprintf(stderr, "Hyst upper(%0.2f) thr must be bigger than lower(%0.2f) threshold!\n", cnf->hysteresis_param.thr_high, cnf->hysteresis_param.thr_low);
221           return -1;
222         }
223
224       if(cnf->hysteresis_param.thr_high < MIN_HYST_PARAM ||
225          cnf->hysteresis_param.thr_high > MAX_HYST_PARAM)
226         {
227           fprintf(stderr, "Hyst upper thr %0.2f is not allowed\n", cnf->hysteresis_param.thr_high);
228           return -1;
229         }
230
231       if(cnf->hysteresis_param.thr_low < MIN_HYST_PARAM ||
232          cnf->hysteresis_param.thr_low > MAX_HYST_PARAM)
233         {
234           fprintf(stderr, "Hyst lower thr %0.2f is not allowed\n", cnf->hysteresis_param.thr_low);
235           return -1;
236         }
237     }
238
239   /* Pollrate */
240
241   if(cnf->pollrate < MIN_POLLRATE ||
242      cnf->pollrate > MAX_POLLRATE)
243     {
244       fprintf(stderr, "Pollrate %0.2f is not allowed\n", cnf->pollrate);
245       return -1;
246     }
247
248   /* NIC Changes Pollrate */
249
250   if(cnf->nic_chgs_pollrate < MIN_NICCHGPOLLRT ||
251      cnf->nic_chgs_pollrate > MAX_NICCHGPOLLRT)
252     {
253       fprintf(stderr, "NIC Changes Pollrate %0.2f is not allowed\n", cnf->nic_chgs_pollrate);
254       return -1;
255     }
256
257   /* TC redundancy */
258
259   if(//cnf->tc_redundancy < MIN_TC_REDUNDANCY ||
260      cnf->tc_redundancy > MAX_TC_REDUNDANCY)
261     {
262       fprintf(stderr, "TC redundancy %d is not allowed\n", cnf->tc_redundancy);
263       return -1;
264     }
265
266   /* MPR coverage */
267   if(cnf->mpr_coverage < MIN_MPR_COVERAGE ||
268      cnf->mpr_coverage > MAX_MPR_COVERAGE)
269     {
270       fprintf(stderr, "MPR coverage %d is not allowed\n", cnf->mpr_coverage);
271       return -1;
272     }
273
274   /* Link Q and hysteresis cannot be activated at the same time */
275   if(cnf->use_hysteresis == OLSR_TRUE && cnf->lq_level)
276     {
277       fprintf(stderr, "Hysteresis and LinkQuality cannot both be active! Deactivate one of them.\n");
278       return -1;
279     }
280
281   /* Link quality level */
282
283   if(cnf->lq_level > MAX_LQ_LEVEL)
284     {
285       fprintf(stderr, "LQ level %d is not allowed\n", cnf->lq_level);
286       return -1;
287     }
288
289   /* Link quality window size */
290   if(cnf->lq_level && (cnf->lq_wsize < MIN_LQ_WSIZE || cnf->lq_wsize > MAX_LQ_WSIZE))
291     {
292       fprintf(stderr, "LQ window size %d is not allowed\n", cnf->lq_wsize);
293       return -1;
294     }
295
296   if(in == NULL)
297     {
298       fprintf(stderr, "No interfaces configured!\n");
299       return -1;
300     }
301
302   /* Interfaces */
303   while(in)
304     {
305       io = in->cnf;
306
307       if(in->name == NULL || !strlen(in->name))
308         {
309           fprintf(stderr, "Interface has no name!\n");
310           return -1;
311         }
312
313       if(io == NULL)
314         {
315           fprintf(stderr, "Interface %s has no configuration!\n", in->name);
316           return -1;
317         }
318         
319       /* HELLO interval */
320
321       if (io->hello_params.validity_time < 0.0)
322       {
323         if (cnf->lq_level == 0)
324           io->hello_params.validity_time = NEIGHB_HOLD_TIME;
325
326         else
327           io->hello_params.validity_time = cnf->lq_wsize * io->hello_params.emission_interval;
328       }
329
330       if(io->hello_params.emission_interval < cnf->pollrate ||
331          io->hello_params.emission_interval > io->hello_params.validity_time)
332         {
333           fprintf(stderr, "Bad HELLO parameters! (em: %0.2f, vt: %0.2f)\n", io->hello_params.emission_interval, io->hello_params.validity_time);
334           return -1;
335         }
336
337       /* TC interval */
338       if(io->tc_params.emission_interval < cnf->pollrate ||
339          io->tc_params.emission_interval > io->tc_params.validity_time)
340         {
341           fprintf(stderr, "Bad TC parameters! (em: %0.2f, vt: %0.2f)\n", io->tc_params.emission_interval, io->tc_params.validity_time);
342           return -1;
343         }
344
345       /* MID interval */
346       if(io->mid_params.emission_interval < cnf->pollrate ||
347          io->mid_params.emission_interval > io->mid_params.validity_time)
348         {
349           fprintf(stderr, "Bad MID parameters! (em: %0.2f, vt: %0.2f)\n", io->mid_params.emission_interval, io->mid_params.validity_time);
350           return -1;
351         }
352
353       /* HNA interval */
354       if(io->hna_params.emission_interval < cnf->pollrate ||
355          io->hna_params.emission_interval > io->hna_params.validity_time)
356         {
357           fprintf(stderr, "Bad HNA parameters! (em: %0.2f, vt: %0.2f)\n", io->hna_params.emission_interval, io->hna_params.validity_time);
358           return -1;
359         }
360
361       in = in->next;
362     }
363
364   return 0;
365 }
366
367
368 void
369 olsrd_free_cnf(struct olsrd_config *cnf)
370 {
371   struct hna4_entry        *h4d, *h4 = cnf->hna4_entries;
372   struct hna6_entry        *h6d, *h6 = cnf->hna6_entries;
373   struct olsr_if           *ind, *in = cnf->interfaces;
374   struct plugin_entry      *ped, *pe = cnf->plugins;
375   struct olsr_lq_mult      *mult, *next_mult;
376   
377   while(h4)
378     {
379       h4d = h4;
380       h4 = h4->next;
381       free(h4d);
382     }
383
384   while(h6)
385     {
386       h6d = h6;
387       h6 = h6->next;
388       free(h6d);
389     }
390
391   while(in)
392     {
393       for (mult = in->cnf->lq_mult; mult != NULL; mult = next_mult)
394       {
395         next_mult = mult->next;
396         free(mult);
397       }
398
399       free(in->cnf);
400       ind = in;
401       in = in->next;
402       free(ind->name);
403       free(ind->config);
404       free(ind);
405     }
406
407   while(pe)
408     {
409       ped = pe;
410       pe = pe->next;
411       free(ped->name);
412       free(ped);
413     }
414
415   return;
416 }
417
418
419
420 struct olsrd_config *
421 olsrd_get_default_cnf(void)
422 {
423   cnf = malloc(sizeof(struct olsrd_config));
424   if (cnf == NULL)
425     {
426       fprintf(stderr, "Out of memory %s\n", __func__);
427       return NULL;
428     }
429
430   set_default_cnf(cnf);
431
432   return cnf;
433 }
434
435
436
437
438 void
439 set_default_cnf(struct olsrd_config *cnf)
440 {
441     memset(cnf, 0, sizeof(struct olsrd_config));
442     
443     cnf->debug_level = DEF_DEBUGLVL;
444     cnf->no_fork = OLSR_FALSE;
445     cnf->host_emul = OLSR_FALSE;
446     cnf->ip_version  = AF_INET;
447     cnf->allow_no_interfaces = DEF_ALLOW_NO_INTS;
448     cnf->tos = DEF_TOS;
449     cnf->rttable = 254;
450     cnf->willingness_auto = DEF_WILL_AUTO;
451     cnf->ipc_connections = DEF_IPC_CONNECTIONS;
452     cnf->open_ipc = cnf->ipc_connections ? OLSR_TRUE : OLSR_FALSE;
453
454     cnf->use_hysteresis = DEF_USE_HYST;
455     cnf->hysteresis_param.scaling = HYST_SCALING;
456     cnf->hysteresis_param.thr_high = HYST_THRESHOLD_HIGH;
457     cnf->hysteresis_param.thr_low = HYST_THRESHOLD_LOW;
458
459     cnf->pollrate = DEF_POLLRATE;
460     cnf->nic_chgs_pollrate = DEF_NICCHGPOLLRT;
461
462     cnf->tc_redundancy = TC_REDUNDANCY;
463     cnf->mpr_coverage = MPR_COVERAGE;
464     cnf->lq_level = DEF_LQ_LEVEL;
465     cnf->lq_fish = DEF_LQ_FISH;
466     cnf->lq_dlimit = DEF_LQ_DIJK_LIMIT;
467     cnf->lq_dinter = DEF_LQ_DIJK_INTER;
468     cnf->lq_wsize = DEF_LQ_WSIZE;
469     cnf->clear_screen = DEF_CLEAR_SCREEN;
470
471     cnf->del_gws = OLSR_FALSE;
472     cnf->will_int = 10 * HELLO_INTERVAL;
473     cnf->max_jitter = 0.0;
474     cnf->exit_value = EXIT_SUCCESS;
475     cnf->max_tc_vtime = 0.0;
476     cnf->ioctl_s = 0;
477 #if LINUX_POLICY_ROUTING
478     cnf->rtnl_s = 0;
479 #else
480     cnf->rts = 0;
481 #endif
482 }
483
484
485
486
487 struct if_config_options *
488 get_default_if_config(void)
489 {
490   struct if_config_options *io = malloc(sizeof(struct if_config_options));
491   struct in6_addr in6;
492
493   if(io == NULL)
494     {
495       fprintf(stderr, "Out of memory %s\n", __func__);
496       return NULL;
497     }
498
499   memset(io, 0, sizeof(struct if_config_options));
500
501   io->ipv6_addrtype = 1; /* XXX - FixMe */
502
503   inet_pton(AF_INET6, OLSR_IPV6_MCAST_SITE_LOCAL, &in6);
504   memcpy(&io->ipv6_multi_site.v6, &in6, sizeof(struct in6_addr));
505
506   inet_pton(AF_INET6, OLSR_IPV6_MCAST_GLOBAL, &in6);
507   memcpy(&io->ipv6_multi_glbl.v6, &in6, sizeof(struct in6_addr));
508
509   io->lq_mult = NULL;
510
511   io->weight.fixed = OLSR_FALSE;
512   io->weight.value = 0;
513
514   io->ipv6_addrtype = 0; /* global */
515
516   io->hello_params.emission_interval = HELLO_INTERVAL;
517   io->hello_params.validity_time = -1.0;
518   io->tc_params.emission_interval = TC_INTERVAL;
519   io->tc_params.validity_time = TOP_HOLD_TIME;
520   io->mid_params.emission_interval = MID_INTERVAL;
521   io->mid_params.validity_time = MID_HOLD_TIME;
522   io->hna_params.emission_interval = HNA_INTERVAL;
523   io->hna_params.validity_time = HNA_HOLD_TIME;
524   io->autodetect_chg = OLSR_TRUE;
525
526   return io;
527
528 }
529
530
531
532 void
533 olsrd_print_cnf(struct olsrd_config *cnf)
534 {
535   struct hna4_entry        *h4 = cnf->hna4_entries;
536   struct hna6_entry        *h6 = cnf->hna6_entries;
537   struct olsr_if           *in = cnf->interfaces;
538   struct plugin_entry      *pe = cnf->plugins;
539   struct ipc_host          *ih = cnf->ipc_hosts;
540   struct ipc_net           *ie = cnf->ipc_nets;
541   struct olsr_lq_mult      *mult;
542   char ipv6_buf[100];             /* buffer for IPv6 inet_htop */
543   struct in_addr in4;
544
545   printf(" *** olsrd configuration ***\n");
546
547   printf("Debug Level      : %d\n", cnf->debug_level);
548   if(cnf->ip_version == AF_INET6)
549     printf("IpVersion        : 6\n");
550   else
551     printf("IpVersion        : 4\n");
552   if(cnf->allow_no_interfaces)
553     printf("No interfaces    : ALLOWED\n");
554   else
555     printf("No interfaces    : NOT ALLOWED\n");
556   printf("TOS              : 0x%02x\n", cnf->tos);
557   printf("RtTable          : 0x%02x\n", cnf->rttable);
558   if(cnf->willingness_auto)
559     printf("Willingness      : AUTO\n");
560   else
561     printf("Willingness      : %d\n", cnf->willingness);
562
563   printf("IPC connections  : %d\n", cnf->ipc_connections);
564
565   while(ih)
566     {
567       in4.s_addr = ih->host.v4;
568       printf("\tHost %s\n", inet_ntoa(in4));
569       ih = ih->next;
570     }
571   
572   while(ie)
573     {
574       in4.s_addr = ie->net.v4;
575       printf("\tNet %s/", inet_ntoa(in4));
576       in4.s_addr = ie->mask.v4;
577       printf("%s\n", inet_ntoa(in4));
578       ie = ie->next;
579     }
580
581
582   printf("Pollrate         : %0.2f\n", cnf->pollrate);
583
584   printf("NIC ChangPollrate: %0.2f\n", cnf->nic_chgs_pollrate);
585
586   printf("TC redundancy    : %d\n", cnf->tc_redundancy);
587
588   printf("MPR coverage     : %d\n", cnf->mpr_coverage);
589    
590   printf("LQ level         : %d\n", cnf->lq_level);
591
592   printf("LQ fish eye      : %d\n", cnf->lq_fish);
593
594   printf("LQ Dijkstra limit: %d, %0.2f\n", cnf->lq_dlimit, cnf->lq_dinter);
595
596   printf("LQ window size   : %d\n", cnf->lq_wsize);
597
598   printf("Clear screen     : %s\n", cnf->clear_screen ? "yes" : "no");
599
600   /* Interfaces */
601   if(in)
602     {
603       printf("Interfaces:\n");
604       while(in)
605         {
606           printf(" dev: \"%s\"\n", in->name);
607           
608           if(in->cnf->ipv4_broadcast.v4)
609             {
610               in4.s_addr = in->cnf->ipv4_broadcast.v4;
611               printf("\tIPv4 broadcast           : %s\n", inet_ntoa(in4));
612             }
613           else
614             {
615               printf("\tIPv4 broadcast           : AUTO\n");
616             }
617           
618           printf("\tIPv6 addrtype            : %s\n", in->cnf->ipv6_addrtype ? "site-local" : "global");
619           
620           //union olsr_ip_addr       ipv6_multi_site;
621           //union olsr_ip_addr       ipv6_multi_glbl;
622           printf("\tIPv6 multicast site/glbl : %s", (char *)inet_ntop(AF_INET6, &in->cnf->ipv6_multi_site.v6, ipv6_buf, sizeof(ipv6_buf)));
623           printf("/%s\n", (char *)inet_ntop(AF_INET6, &in->cnf->ipv6_multi_glbl.v6, ipv6_buf, sizeof(ipv6_buf)));
624           
625           printf("\tHELLO emission/validity  : %0.2f/%0.2f\n", in->cnf->hello_params.emission_interval, in->cnf->hello_params.validity_time);
626           printf("\tTC emission/validity     : %0.2f/%0.2f\n", in->cnf->tc_params.emission_interval, in->cnf->tc_params.validity_time);
627           printf("\tMID emission/validity    : %0.2f/%0.2f\n", in->cnf->mid_params.emission_interval, in->cnf->mid_params.validity_time);
628           printf("\tHNA emission/validity    : %0.2f/%0.2f\n", in->cnf->hna_params.emission_interval, in->cnf->hna_params.validity_time);
629           
630           for (mult = in->cnf->lq_mult; mult != NULL; mult = mult->next)
631           {
632             inet_ntop(cnf->ip_version, &mult->addr, ipv6_buf,
633                       sizeof (ipv6_buf));
634
635             printf("\tLinkQualityMult          : %s %0.2f\n",
636                    ipv6_buf, mult->val);
637           }
638
639           printf("\tAutodetetc changes       : %s\n", in->cnf->autodetect_chg ? "yes" : "no");
640
641           in = in->next;
642         }
643     }
644
645
646
647
648   /* Plugins */
649   if(pe)
650     {
651       printf("Plugins:\n");
652
653       while(pe)
654         {
655           printf("\tName: \"%s\"\n", pe->name);
656           pe = pe->next;
657         }
658     }
659
660   /* Hysteresis */
661   if(cnf->use_hysteresis)
662     {
663       printf("Using hysteresis:\n");
664       printf("\tScaling      : %0.2f\n", cnf->hysteresis_param.scaling);
665       printf("\tThr high/low : %0.2f/%0.2f\n", cnf->hysteresis_param.thr_high, cnf->hysteresis_param.thr_low);
666     }
667   else
668     printf("Not using hysteresis\n");
669
670   /* HNA IPv4 */
671   if(h4)
672     {
673
674       printf("HNA4 entries:\n");
675       while(h4)
676         {
677           in4.s_addr = h4->net.v4;
678           printf("\t%s/", inet_ntoa(in4));
679           in4.s_addr = h4->netmask.v4;
680           printf("%s\n", inet_ntoa(in4));
681
682           h4 = h4->next;
683         }
684     }
685
686   /* HNA IPv6 */
687   if(h6)
688     {
689       printf("HNA6 entries:\n");
690       while(h6)
691         {
692           printf("\t%s/%d\n", (char *)inet_ntop(AF_INET6, &h6->net.v6, ipv6_buf, sizeof(ipv6_buf)), h6->prefix_len);
693           h6 = h6->next;
694         }
695     }
696 }
697
698 #if defined WIN32_STDIO_HACK
699 struct ioinfo
700 {
701         unsigned int handle;
702         unsigned char attr;
703         char buff;
704         int flag;
705         CRITICAL_SECTION lock;
706 };
707
708 void win32_stdio_hack(unsigned int handle)
709 {
710   HMODULE lib;
711   struct ioinfo **info;
712
713   lib = LoadLibrary("msvcrt.dll");
714
715   info = (struct ioinfo **)GetProcAddress(lib, "__pioinfo");
716
717   // (*info)[1].handle = handle;
718   // (*info)[1].attr = 0x89; // FOPEN | FTEXT | FPIPE;
719
720   (*info)[2].handle = handle;
721   (*info)[2].attr = 0x89;
722
723   // stdout->_file = 1;
724   stderr->_file = 2;
725
726   // setbuf(stdout, NULL);
727   setbuf(stderr, NULL);
728 }
729 #endif