b6cd1b673946b997e8cc94b9281b14633b429b19
[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.47 2006/01/07 08:16:24 kattemat 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   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->index = cnf->ifcnt++;
161       in->configured = OLSR_FALSE;
162       in->interf = NULL;
163       in->host_emul = OLSR_FALSE;
164       in = in->next;
165     }
166
167
168   return cnf;
169 }
170
171
172 int
173 olsrd_sanity_check_cnf(struct olsrd_config *cnf)
174 {
175   struct olsr_if           *in = cnf->interfaces;
176   struct if_config_options *io;
177
178   /* Debug level */
179   if(cnf->debug_level < MIN_DEBUGLVL ||
180      cnf->debug_level > MAX_DEBUGLVL)
181     {
182       fprintf(stderr, "Debuglevel %d is not allowed\n", cnf->debug_level);
183       return -1;
184     }
185
186   /* IP version */
187   if(cnf->ip_version != AF_INET &&
188      cnf->ip_version != AF_INET6)
189     {
190       fprintf(stderr, "Ipversion %d not allowed!\n", cnf->ip_version);
191       return -1;
192     }
193
194   /* TOS */
195   if(//cnf->tos < MIN_TOS ||
196      cnf->tos > MAX_TOS)
197     {
198       fprintf(stderr, "TOS %d is not allowed\n", cnf->tos);
199       return -1;
200     }
201
202   if(cnf->willingness_auto == OLSR_FALSE &&
203      (cnf->willingness > MAX_WILLINGNESS))
204     {
205       fprintf(stderr, "Willingness %d is not allowed\n", cnf->willingness);
206       return -1;
207     }
208
209   /* Hysteresis */
210   if(cnf->use_hysteresis == OLSR_TRUE)
211     {
212       if(cnf->hysteresis_param.scaling < MIN_HYST_PARAM ||
213          cnf->hysteresis_param.scaling > MAX_HYST_PARAM)
214         {
215           fprintf(stderr, "Hyst scaling %0.2f is not allowed\n", cnf->hysteresis_param.scaling);
216           return -1;
217         }
218
219       if(cnf->hysteresis_param.thr_high <= cnf->hysteresis_param.thr_low)
220         {
221           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);
222           return -1;
223         }
224
225       if(cnf->hysteresis_param.thr_high < MIN_HYST_PARAM ||
226          cnf->hysteresis_param.thr_high > MAX_HYST_PARAM)
227         {
228           fprintf(stderr, "Hyst upper thr %0.2f is not allowed\n", cnf->hysteresis_param.thr_high);
229           return -1;
230         }
231
232       if(cnf->hysteresis_param.thr_low < MIN_HYST_PARAM ||
233          cnf->hysteresis_param.thr_low > MAX_HYST_PARAM)
234         {
235           fprintf(stderr, "Hyst lower thr %0.2f is not allowed\n", cnf->hysteresis_param.thr_low);
236           return -1;
237         }
238     }
239
240   /* Pollrate */
241
242   if(cnf->pollrate < MIN_POLLRATE ||
243      cnf->pollrate > MAX_POLLRATE)
244     {
245       fprintf(stderr, "Pollrate %0.2f is not allowed\n", cnf->pollrate);
246       return -1;
247     }
248
249   /* TC redundancy */
250
251   if(//cnf->tc_redundancy < MIN_TC_REDUNDANCY ||
252      cnf->tc_redundancy > MAX_TC_REDUNDANCY)
253     {
254       fprintf(stderr, "TC redundancy %d is not allowed\n", cnf->tc_redundancy);
255       return -1;
256     }
257
258   /* MPR coverage */
259   if(cnf->mpr_coverage < MIN_MPR_COVERAGE ||
260      cnf->mpr_coverage > MAX_MPR_COVERAGE)
261     {
262       fprintf(stderr, "MPR coverage %d is not allowed\n", cnf->mpr_coverage);
263       return -1;
264     }
265
266   /* Link Q and hysteresis cannot be activated at the same time */
267   if(cnf->use_hysteresis == OLSR_TRUE && cnf->lq_level)
268     {
269       fprintf(stderr, "Hysteresis and LinkQuality cannot both be active! Deactivate one of them.\n");
270       return -1;
271     }
272
273   /* Link quality level */
274
275   if(cnf->lq_level > MAX_LQ_LEVEL)
276     {
277       fprintf(stderr, "LQ level %d is not allowed\n", cnf->lq_level);
278       return -1;
279     }
280
281   /* Link quality window size */
282   if(cnf->lq_level && (cnf->lq_wsize < MIN_LQ_WSIZE || cnf->lq_wsize > MAX_LQ_WSIZE))
283     {
284       fprintf(stderr, "LQ window size %d is not allowed\n", cnf->lq_wsize);
285       return -1;
286     }
287
288   if(in == NULL)
289     {
290       fprintf(stderr, "No interfaces configured!\n");
291       return -1;
292     }
293
294   /* Interfaces */
295   while(in)
296     {
297       io = in->cnf;
298
299       if(in->name == NULL || !strlen(in->name))
300         {
301           fprintf(stderr, "Interface has no name!\n");
302           return -1;
303         }
304
305       if(io == NULL)
306         {
307           fprintf(stderr, "Interface %s has no configuration!\n", in->name);
308           return -1;
309         }
310         
311       /* HELLO interval */
312
313       if (io->hello_params.validity_time < 0.0)
314       {
315         if (cnf->lq_level == 0)
316           io->hello_params.validity_time = NEIGHB_HOLD_TIME;
317
318         else
319           io->hello_params.validity_time = cnf->lq_wsize * io->hello_params.emission_interval;
320       }
321
322       if(io->hello_params.emission_interval < cnf->pollrate ||
323          io->hello_params.emission_interval > io->hello_params.validity_time)
324         {
325           fprintf(stderr, "Bad HELLO parameters! (em: %0.2f, vt: %0.2f)\n", io->hello_params.emission_interval, io->hello_params.validity_time);
326           return -1;
327         }
328
329       /* TC interval */
330       if(io->tc_params.emission_interval < cnf->pollrate ||
331          io->tc_params.emission_interval > io->tc_params.validity_time)
332         {
333           fprintf(stderr, "Bad TC parameters! (em: %0.2f, vt: %0.2f)\n", io->tc_params.emission_interval, io->tc_params.validity_time);
334           return -1;
335         }
336
337       /* MID interval */
338       if(io->mid_params.emission_interval < cnf->pollrate ||
339          io->mid_params.emission_interval > io->mid_params.validity_time)
340         {
341           fprintf(stderr, "Bad MID parameters! (em: %0.2f, vt: %0.2f)\n", io->mid_params.emission_interval, io->mid_params.validity_time);
342           return -1;
343         }
344
345       /* HNA interval */
346       if(io->hna_params.emission_interval < cnf->pollrate ||
347          io->hna_params.emission_interval > io->hna_params.validity_time)
348         {
349           fprintf(stderr, "Bad HNA parameters! (em: %0.2f, vt: %0.2f)\n", io->hna_params.emission_interval, io->hna_params.validity_time);
350           return -1;
351         }
352
353       in = in->next;
354     }
355
356   return 0;
357 }
358
359
360 void
361 olsrd_free_cnf(struct olsrd_config *cnf)
362 {
363   struct hna4_entry        *h4d, *h4 = cnf->hna4_entries;
364   struct hna6_entry        *h6d, *h6 = cnf->hna6_entries;
365   struct olsr_if           *ind, *in = cnf->interfaces;
366   struct plugin_entry      *ped, *pe = cnf->plugins;
367   struct olsr_lq_mult      *mult, *next_mult;
368   
369   while(h4)
370     {
371       h4d = h4;
372       h4 = h4->next;
373       free(h4d);
374     }
375
376   while(h6)
377     {
378       h6d = h6;
379       h6 = h6->next;
380       free(h6d);
381     }
382
383   while(in)
384     {
385       for (mult = in->cnf->lq_mult; mult != NULL; mult = next_mult)
386       {
387         next_mult = mult->next;
388         free(mult);
389       }
390
391       free(in->cnf);
392       ind = in;
393       in = in->next;
394       free(ind->name);
395       free(ind->config);
396       free(ind);
397     }
398
399   while(pe)
400     {
401       ped = pe;
402       pe = pe->next;
403       free(ped->name);
404       free(ped);
405     }
406
407   return;
408 }
409
410
411
412 struct olsrd_config *
413 olsrd_get_default_cnf()
414 {
415   cnf = malloc(sizeof(struct olsrd_config));
416   if (cnf == NULL)
417     {
418       fprintf(stderr, "Out of memory %s\n", __func__);
419       return NULL;
420   }
421
422   set_default_cnf(cnf);
423
424   return cnf;
425 }
426
427
428
429
430 void
431 set_default_cnf(struct olsrd_config *cnf)
432 {
433     memset(cnf, 0, sizeof(struct olsrd_config));
434     
435     cnf->debug_level = DEF_DEBUGLVL;
436     cnf->no_fork = OLSR_FALSE;
437     cnf->host_emul = OLSR_FALSE;
438     cnf->ip_version  = AF_INET;
439     cnf->allow_no_interfaces = DEF_ALLOW_NO_INTS;
440     cnf->tos = DEF_TOS;
441     cnf->willingness_auto = DEF_WILL_AUTO;
442     cnf->ipc_connections = DEF_IPC_CONNECTIONS;
443     cnf->open_ipc = cnf->ipc_connections ? OLSR_TRUE : OLSR_FALSE;
444
445     cnf->use_hysteresis = DEF_USE_HYST;
446     cnf->hysteresis_param.scaling = HYST_SCALING;
447     cnf->hysteresis_param.thr_high = HYST_THRESHOLD_HIGH;
448     cnf->hysteresis_param.thr_low = HYST_THRESHOLD_LOW;
449
450     cnf->pollrate = DEF_POLLRATE;
451
452     cnf->tc_redundancy = TC_REDUNDANCY;
453     cnf->mpr_coverage = MPR_COVERAGE;
454     cnf->lq_level = DEF_LQ_LEVEL;
455     cnf->lq_fish = DEF_LQ_FISH;
456     cnf->lq_dlimit = DEF_LQ_DIJK_LIMIT;
457     cnf->lq_dinter = DEF_LQ_DIJK_INTER;
458     cnf->lq_wsize = DEF_LQ_WSIZE;
459     cnf->clear_screen = DEF_CLEAR_SCREEN;
460
461     cnf->del_gws = OLSR_FALSE;
462     cnf->will_int = 10 * HELLO_INTERVAL;
463     cnf->max_jitter = 0.0;
464     cnf->exit_value = EXIT_SUCCESS;
465     cnf->max_tc_vtime = 0.0;
466     cnf->ioctl_s = 0;
467     cnf->rts = 0;
468 }
469
470
471
472
473 struct if_config_options *
474 get_default_if_config()
475 {
476   struct if_config_options *io = malloc(sizeof(struct if_config_options));
477   struct in6_addr in6;
478  
479   memset(io, 0, sizeof(struct if_config_options));
480
481   io->ipv6_addrtype = 1; /* XXX - FixMe */
482
483   if(inet_pton(AF_INET6, OLSR_IPV6_MCAST_SITE_LOCAL, &in6) < 0)
484     {
485       fprintf(stderr, "Failed converting IP address %s\n", OLSR_IPV6_MCAST_SITE_LOCAL);
486       return NULL;
487     }
488   memcpy(&io->ipv6_multi_site.v6, &in6, sizeof(struct in6_addr));
489
490   if(inet_pton(AF_INET6, OLSR_IPV6_MCAST_GLOBAL, &in6) < 0)
491     {
492       fprintf(stderr, "Failed converting IP address %s\n", OLSR_IPV6_MCAST_GLOBAL);
493       return NULL;
494     }
495   memcpy(&io->ipv6_multi_glbl.v6, &in6, sizeof(struct in6_addr));
496
497   io->lq_mult = NULL;
498
499   io->weight.fixed = OLSR_FALSE;
500   io->weight.value = 0;
501
502   io->ipv6_addrtype = 0; /* global */
503
504   io->hello_params.emission_interval = HELLO_INTERVAL;
505   io->hello_params.validity_time = -1.0;
506   io->tc_params.emission_interval = TC_INTERVAL;
507   io->tc_params.validity_time = TOP_HOLD_TIME;
508   io->mid_params.emission_interval = MID_INTERVAL;
509   io->mid_params.validity_time = MID_HOLD_TIME;
510   io->hna_params.emission_interval = HNA_INTERVAL;
511   io->hna_params.validity_time = HNA_HOLD_TIME;
512
513   return io;
514
515 }
516
517
518
519 void
520 olsrd_print_cnf(struct olsrd_config *cnf)
521 {
522   struct hna4_entry        *h4 = cnf->hna4_entries;
523   struct hna6_entry        *h6 = cnf->hna6_entries;
524   struct olsr_if           *in = cnf->interfaces;
525   struct plugin_entry      *pe = cnf->plugins;
526   struct ipc_host          *ih = cnf->ipc_hosts;
527   struct ipc_net           *ie = cnf->ipc_nets;
528   struct olsr_lq_mult      *mult;
529   char ipv6_buf[100];             /* buffer for IPv6 inet_htop */
530   struct in_addr in4;
531
532   printf(" *** olsrd configuration ***\n");
533
534   printf("Debug Level      : %d\n", cnf->debug_level);
535   if(cnf->ip_version == AF_INET6)
536     printf("IpVersion        : 6\n");
537   else
538     printf("IpVersion        : 4\n");
539   if(cnf->allow_no_interfaces)
540     printf("No interfaces    : ALLOWED\n");
541   else
542     printf("No interfaces    : NOT ALLOWED\n");
543   printf("TOS              : 0x%02x\n", cnf->tos);
544   if(cnf->willingness_auto)
545     printf("Willingness      : AUTO\n");
546   else
547     printf("Willingness      : %d\n", cnf->willingness);
548
549   printf("IPC connections  : %d\n", cnf->ipc_connections);
550
551   while(ih)
552     {
553       in4.s_addr = ih->host.v4;
554       printf("\tHost %s\n", inet_ntoa(in4));
555       ih = ih->next;
556     }
557   
558   while(ie)
559     {
560       in4.s_addr = ie->net.v4;
561       printf("\tNet %s/", inet_ntoa(in4));
562       in4.s_addr = ie->mask.v4;
563       printf("%s\n", inet_ntoa(in4));
564       ie = ie->next;
565     }
566
567
568   printf("Pollrate         : %0.2f\n", cnf->pollrate);
569
570   printf("TC redundancy    : %d\n", cnf->tc_redundancy);
571
572   printf("MPR coverage     : %d\n", cnf->mpr_coverage);
573    
574   printf("LQ level         : %d\n", cnf->lq_level);
575
576   printf("LQ fish eye      : %d\n", cnf->lq_fish);
577
578   printf("LQ Dijkstra limit: %d, %0.2f\n", cnf->lq_dlimit, cnf->lq_dinter);
579
580   printf("LQ window size   : %d\n", cnf->lq_wsize);
581
582   printf("Clear screen     : %s\n", cnf->clear_screen ? "yes" : "no");
583
584   /* Interfaces */
585   if(in)
586     {
587       printf("Interfaces:\n");
588       while(in)
589         {
590           printf(" dev: \"%s\"\n", in->name);
591           
592           if(in->cnf->ipv4_broadcast.v4)
593             {
594               in4.s_addr = in->cnf->ipv4_broadcast.v4;
595               printf("\tIPv4 broadcast           : %s\n", inet_ntoa(in4));
596             }
597           else
598             {
599               printf("\tIPv4 broadcast           : AUTO\n");
600             }
601           
602           printf("\tIPv6 addrtype            : %s\n", in->cnf->ipv6_addrtype ? "site-local" : "global");
603           
604           //union olsr_ip_addr       ipv6_multi_site;
605           //union olsr_ip_addr       ipv6_multi_glbl;
606           printf("\tIPv6 multicast site/glbl : %s", (char *)inet_ntop(AF_INET6, &in->cnf->ipv6_multi_site.v6, ipv6_buf, sizeof(ipv6_buf)));
607           printf("/%s\n", (char *)inet_ntop(AF_INET6, &in->cnf->ipv6_multi_glbl.v6, ipv6_buf, sizeof(ipv6_buf)));
608           
609           printf("\tHELLO emission/validity  : %0.2f/%0.2f\n", in->cnf->hello_params.emission_interval, in->cnf->hello_params.validity_time);
610           printf("\tTC emission/validity     : %0.2f/%0.2f\n", in->cnf->tc_params.emission_interval, in->cnf->tc_params.validity_time);
611           printf("\tMID emission/validity    : %0.2f/%0.2f\n", in->cnf->mid_params.emission_interval, in->cnf->mid_params.validity_time);
612           printf("\tHNA emission/validity    : %0.2f/%0.2f\n", in->cnf->hna_params.emission_interval, in->cnf->hna_params.validity_time);
613           
614           for (mult = in->cnf->lq_mult; mult != NULL; mult = mult->next)
615           {
616             inet_ntop(cnf->ip_version, &mult->addr, ipv6_buf,
617                       sizeof (ipv6_buf));
618
619             printf("\tLinkQualityMult          : %s %0.2f\n",
620                    ipv6_buf, mult->val);
621           }
622           
623           in = in->next;
624         }
625     }
626
627
628
629
630   /* Plugins */
631   if(pe)
632     {
633       printf("Plugins:\n");
634
635       while(pe)
636         {
637           printf("\tName: \"%s\"\n", pe->name);
638           pe = pe->next;
639         }
640     }
641
642   /* Hysteresis */
643   if(cnf->use_hysteresis)
644     {
645       printf("Using hysteresis:\n");
646       printf("\tScaling      : %0.2f\n", cnf->hysteresis_param.scaling);
647       printf("\tThr high/low : %0.2f/%0.2f\n", cnf->hysteresis_param.thr_high, cnf->hysteresis_param.thr_low);
648     }
649   else
650     printf("Not using hysteresis\n");
651
652   /* HNA IPv4 */
653   if(h4)
654     {
655
656       printf("HNA4 entries:\n");
657       while(h4)
658         {
659           in4.s_addr = h4->net.v4;
660           printf("\t%s/", inet_ntoa(in4));
661           in4.s_addr = h4->netmask.v4;
662           printf("%s\n", inet_ntoa(in4));
663
664           h4 = h4->next;
665         }
666     }
667
668   /* HNA IPv6 */
669   if(h6)
670     {
671       printf("HNA6 entries:\n");
672       while(h6)
673         {
674           printf("\t%s/%d\n", (char *)inet_ntop(AF_INET6, &h6->net.v6, ipv6_buf, sizeof(ipv6_buf)), h6->prefix_len);
675           h6 = h6->next;
676         }
677     }
678 }
679
680 void *olsrd_cnf_malloc(unsigned int len)
681 {
682   return malloc(len);
683 }
684
685 void olsrd_cnf_free(void *addr)
686 {
687   free(addr);
688 }
689
690 #if defined WIN32_STDIO_HACK
691 struct ioinfo
692 {
693         unsigned int handle;
694         unsigned char attr;
695         char buff;
696         int flag;
697         CRITICAL_SECTION lock;
698 };
699
700 void win32_stdio_hack(unsigned int handle)
701 {
702   HMODULE lib;
703   struct ioinfo **info;
704
705   lib = LoadLibrary("msvcrt.dll");
706
707   info = (struct ioinfo **)GetProcAddress(lib, "__pioinfo");
708
709   // (*info)[1].handle = handle;
710   // (*info)[1].attr = 0x89; // FOPEN | FTEXT | FPIPE;
711
712   (*info)[2].handle = handle;
713   (*info)[2].attr = 0x89;
714
715   // stdout->_file = 1;
716   stderr->_file = 2;
717
718   // setbuf(stdout, NULL);
719   setbuf(stderr, NULL);
720 }
721 #else
722 void win32_stdio_hack(unsigned int handle) {}
723 #endif