Added support for embedded scripts into rom-o-matic.net
[people/pravin/rom-o-matic-BKO.git] / configinfo.php
1 <? // -*- Mode: PHP; -*-
2 include "setup.php" ;
3 $version = $gpxe_source_type;
4 $src_dir = "$gpxe_source_location/src"; // TODO temporary hack to work around symlink git
5
6 include ( "flag_table.php" );
7
8 $top_inc = "top.php";
9 $bottom_inc = "bottom.php";
10
11 $flag_codes = array ();
12
13 reset($flag_table);
14 $i = 1;
15
16 while ( list ( $key, $props ) = each ( $flag_table ) ) {
17   $is = (string) $i;
18   if ( $i < 10 ) {
19     $is = "0" . $is;
20   }
21
22   $props["code"] = $is;
23   $props["flag"] = $key;
24
25   $flag_table[$key] = $props;
26   $flag_codes[$is] = $props;
27   $i = $i + 1;
28 }
29
30 // dump_flag_table();
31 // dump_flag_codes();
32 // dump_flag_table_keys_sorted();
33 // exit ();
34
35 $ofmts = array (
36   "Floppy bootable ROM Image (.dsk)" => "dsk",
37   "Binary ROM Image(.rom)" => "rom",
38   "ISO bootable image (.iso)" => "iso",
39   "ISO bootable image with legacy floppy emulation (.liso)" => "liso",
40   "LILO/GRUB/SYSLINUX loadable Linux kernel format (.lkrn)" => "lkrn",
41   "PXE bootstrap loader format ROM Image (.pxe)" => "pxe",
42   "USB Keychain Disk Image / bootable HD image (.usb)" => "usb",
43 // "HD Disk Partition Image (.hd)" => "hd",
44 );
45
46 function value_key ($ofmt) 
47 {
48   // No LinuxBIOS support in gpxe right now
49   //  return (strpos ($ofmt, "LinuxBIOS" ) === false ? "value" : "valuelnx" );
50   return ( "value" );
51 }
52
53 function snarf_file ( $fname ) 
54 {
55   $len = filesize ( $fname );
56   if ( $len > 0 ) {
57     $fp = fopen ( $fname, "rb" );
58     if ( $fp > 0 ) {
59       $buf = fread ( $fp, $len );
60       fclose ( $fp );
61       if ( $buf ) 
62         return ($buf);
63     }
64   }
65   die ( "Unable to get $fname" );
66   return 0;
67 }
68
69 function get_nics () 
70 {
71   global $version, $src_dir;
72   $nic = ( isset ( $_GET['nic'] ) ? $_GET['nic'] : '' );
73
74   $fd = fopen( "$src_dir/bin/NIC", "r" );
75   if ( $fd < 1 ) {
76     trigger_error ( "Missing NIC Config Info" );
77     exit ();
78   }
79   $nics = array ();
80   $family = "";
81   while ( !feof ( $fd ) ) {
82     $line = trim ( fgets ( $fd, 200 ) );
83     if ( strpos ( $line, "family" ) === 0 ) {
84       list ( $dummy, $family ) = split( "[ \t]+", $line );
85       settype ( $family, "string" );
86     } elseif ( $line != "" && $line[0] != '#' ) {
87       list ( $rom, $pci_ids ) = split ( "[ \t]+", $line );
88       settype ( $rom, "string" );
89       if ( $pci_ids == "-" ) $pci_ids = "";
90       $fam_name = substr ( $family, strrpos ( $family, "/" ) + 1, 
91                            strlen ( $family ) - strrpos ( $family, "/" ) + 1 );
92       $option = ( $pci_ids ? "$fam_name:$rom -- [$pci_ids]" : "$fam_name:$rom" );
93       // * Kludge - fix incoming $nic if any.
94       if ( $nic == $rom ) $nic = $option;
95       // ISA drivers are per-family, PCI are per-ROM. If ever decide
96       // to cache the drivers, can use this key.
97       $nics[$option] = ( $pci_ids ? "PCI:" . $rom : "ISA:" . $family );
98       // echo $nics array for debugging
99       //      echo "\$nics[$option] "." -> ".$nics[$option]."<br>";
100     }
101   }
102   $nics["gpxe:all-drivers"] = "PCI:gpxe";
103   fclose ( $fd );
104   ksort ( $nics );
105   return( $nics );
106 }
107
108 function get_nicfile () 
109 {
110   global $ofmts;
111
112   $nic = $_GET['nic'];
113   $ofmt = $_GET['ofmt'];
114
115   $n = strpos ( $nic, " " );
116   $family = substr ( $nic, 0, strpos ( $nic,":" ) );
117
118   $rom = ( $n > 0 ? 
119            substr ( $nic, strpos ( $nic, ":" ) + 1, 
120                     $n - ( strlen ( $family ) + 1 ) ) :  
121            $family );
122
123   $ftype = $ofmts[$ofmt];
124   if ( $ftype == "" ) $ftype = "dsk"; 
125
126   // if .rom format is requested, return rom name,
127   //   since .rom images are PCI ID specific, and 
128   //   rules only exist to build bin/$rom for Binary
129   //    ROM images types
130   if ( $ftype == "rom" )
131     $retval = cleanstring ( $rom . "." . $ftype );
132   else
133     $retval = cleanstring ( $family . "." . $ftype );
134
135   // Let's take a look at what was chosen.
136   //  echo "strpos ( \$nic, \":\" ) ->" . strpos ( $nic, ":" ) . "<br>";
137   //  echo "\$n ->" . "$n" . "<br>";
138   //  echo "\$nic ->" . "|$nic|" . "<br>";
139   //  echo "\$rom ->" . "|$rom|" . "<br>";
140   //  echo "\$family ->" . "|$family|" . "<br>";
141   //  echo "\$ftype ->" . "|$ftype|" . "<br>";
142   //  echo "\$retval ->" . "|$retval|" . "<br>";
143   //  exit();
144
145   return ( $retval );
146 }
147
148 function hidden ( $flag, $value ) {
149   $value = htmlentities ( $value );
150   return "<input type=\"hidden\" value=\"$value\" name=\"$flag\"></input>";
151 }
152
153 function checkbox ( $flag, $value ) {
154   return "<input type=\"checkbox\" value=\"on\" name=\"$flag\"" .
155     ($value == "on" ? " checked>" : ">" );
156 }
157
158 function textbox ( $flag, $value, $size ) {
159   $value = htmlentities ( $value );
160   return "<input type=\"text\" size=\"$size\" value=\"$value\" name=\"$flag\">";
161 }
162  
163 function menubox ( $name, $options, $value ) {
164   $s="<select name=\"$name\">";
165   reset ( $options );
166   while ( list ( $ignore, $option ) = each ( $options ) ) {
167     $s .= "<option" . ( $option == $value ? " selected>" : ">" ) .
168       htmlentities ( $option ) . "</option>";
169   }
170   return $s . "</select>";
171 }
172
173 function keys_menubox ( $name, $options, $value ) 
174 {
175   $s="<select name=\"$name\">";
176   reset ( $options );
177   while ( list ( $option, $ignore ) = each ( $options ) ) {
178     if ( !$value ) $value = $option;
179     $s .= "<option" . ( $option == $value ? " selected>" : ">" ) .
180       htmlentities ( $option ) . "</option>";
181   }
182   return $s . "</select>";
183 }  
184
185 // Encode flags to keep size down, so can use GET's instead of POST's...
186 // Note that the value may need to be urlencoded.
187 function encode_flags ( $flags ) 
188 {
189   global $flag_table;
190
191   $s = "";
192   reset ( $flags );
193   while ( list ( $flag, $value ) = each ( $flags ) ) {
194     $prop = $flag_table[$flag];
195     $type = $prop["type"];
196     $s .= $prop["code"];
197     if ( $type != "on/off" ) {
198       $n = strlen ( $value );
199       $nstr = strval ( $n );
200       if ( $n < 10 ) $nstr = "0" . $nstr;
201       if ( $n >= 80 ) die ( "Value too long!" );
202       $s .= $nstr . $value;
203     }
204   }
205   return $s;
206 }
207
208 function decode_flags_into ( $s, $flags ) 
209 {
210   global $flag_codes;
211   $len = strlen ( $s );
212
213   $pos = 0;
214   while ( $pos < $len ) {
215     $code = substr ( $s, $pos, 2 );
216     $pos += 2;
217     $prop = $flag_codes[$code];
218     $flag = $prop["flag"];
219     $value = "on";
220     $type = $prop["type"];
221     if ( $prop["type"] != "on/off" ) {
222       $n = intval ( substr ( $s, $pos, 2 ) );
223       $pos += 2;
224       $value = substr ( $s, $pos, $n );
225       $pos += $n;
226     }
227     $flags[$flag] = $value;
228   }
229   return $flags;
230 }
231
232 function default_flags () 
233 {
234   global $flag_table;
235
236   if ( isset ( $_GET["F"] ) )
237     $F = $_GET["F"];
238   if ( isset ( $_GET["nic"] ) )
239     $nic = $_GET["nic"];
240   if ( isset ( $_GET["nicfile"] ) )
241     $nicfile = $_GET["nicfile"];
242   if ( isset ( $_GET["ofmt"] ) )
243     $ofmt = $_GET["ofmt"];
244   if ( isset ( $_GET["arch"] ) )
245     $arch = $_GET["arch"];
246
247   $flags = array ();
248   if ( isset ( $F ) && $F != "ignore" && isset ( $arch ) &&
249        ( ( isset ( $nic ) && isset ( $ofmt ) ) || isset ( $nicfile ) ) ) {
250     $vkey = value_key($ofmt);
251
252     reset($flag_table);
253     while ( list ( $key, $props ) = each ( $flag_table ) ) {
254
255       $farch = isset ( $props["arch"] ) ? $props["arch"] : "";
256
257       if ( isset ( $arch ) && ( $farch == "all" || $farch == $arch ) ) {
258         $flag = $props["flag"];
259         $type = $props["type"];
260         $value = ( isset ( $props[$vkey] ) ? $props[$vkey] : $props["value"] );
261         if ( $type != "on/off" || $value == "on" ) {
262           $flags[$flag] = $value;
263         }
264       }
265     }
266     $flags = decode_flags_into ( $F, $flags );
267   }
268   return $flags;
269 }
270
271 function get_flags () 
272 {
273   global $flag_table;
274   $flags = default_flags();
275
276   // echo "<p>Flags in get_flags(): </p>";
277   // show_flags($flags);
278
279   reset ( $flag_table );
280   while ( list ( $key, $props ) = each ( $flag_table ) ) {
281     $flag = $props["flag"];
282     if ( isset ( $_GET["$flag"] ) ) {
283       $flags[$flag] = $_GET["$flag"];
284     }
285   }
286   return $flags;
287 }
288
289 function echo_flags ( $flags ) {
290
291   global $version;
292   global $flag_table;
293
294   $arch = isset ( $_GET['arch'] ) ? $_GET['arch'] : '';
295
296   echo "<table>\n";
297
298   reset($flag_table);
299   while ( list ( $index, $props ) = each ( $flag_table ) ) {
300
301     $farch = isset ( $props["arch"] ) ? $props["arch"] : "";
302
303     // Hide parameters from users that should not be changed.
304
305     $hide_from_user = isset ( $props["hide_from_user"] ) ? $props["hide_from_user"] : "no";
306
307     $flag = $props["flag"];
308     $type = $props["type"];
309
310     $value = isset ( $flags[$flag] ) ? $flags[$flag] : '';
311
312     if ( $hide_from_user == "yes" ) {
313       // Hidden flags cannot not be set by the user.  We use hidden form
314       // fields to keep them at their default values.
315       if ( $type != "header" && ( $farch == "all" || $farch == $arch ) ) {
316         echo hidden ( $flag, $value );
317       }
318     } else {
319       if ( $type == "header" || $farch == "all" || $farch == $arch ) {
320       
321         if ( $type == "header" ) {
322   
323           $label = $props["label"];
324         echo "<td colspan=2><hr><h3>$label</h3><hr></td>";
325   
326         } elseif ($type == "on/off" ) {
327   
328         echo "<td>", checkbox($flag, $value), "</td><td><b>$flag</b></td>";
329   
330         } else {        // no checkbox
331   
332         echo "<td>&nbsp;</td><td><b>$flag: </b>";
333   
334         if ($type == "choice" ) {
335           $options = $props["options"];
336           echo menubox($flag, $options, $value);
337         }
338   
339         else {
340           echo textbox($flag, $value, ($type == "integer" ? 5 : 25));
341         }
342   
343         echo "</td>";
344   
345         }
346   
347         echo "</tr>\n";
348   
349         if ( $type != "header" ) {
350         echo "<tr><td>&nbsp;</td>";
351         echo "<td>\n";
352         include "doc-$version/$flag.html";
353         echo "\n</td></tr>\n";
354         }
355       }
356     }
357   }
358   echo "</table>";
359 }
360
361 function pprint_flag ( $key, $value ) {
362
363   global $flag_table;
364
365   $type = $flag_table[$key]["type"];
366   $s = "";
367
368   if ( $type == "on/off" && $value == "on" ) {
369     $s = "#define $key";
370   } elseif ( $type == "on/off" && $value != "on" ) {
371     $s = "#undef $key";
372   } elseif ( $type == "string" ) {
373     if ( $value != "" ) $s = ( "#define $key \"" . cleanstring($value) . "\"" );
374   } elseif ($type == "qstring" ) {
375     if ( $value != "" ) $s = ( "#define $key \\\"" . cleanstring($value) . "\\\"" );
376   } else {
377     $s = "#define $key " . cleanstring($value);
378   }
379   //  print ($s . "<br>" );
380
381   return $s;
382 }
383
384 function pprint_flags ( $flags ) 
385 {
386   $s = "";
387   reset ($flags);
388
389   while (list($key, $value) = each($flags)) {
390     $f = pprint_flag($key, $value);
391     if ($f != "" )
392       $s .= $f . " ";
393   }
394   return $s;
395 }
396
397 function get_cfgsecs ()
398 {
399   global $flag_table;
400   $cfgsecs = array ();
401
402   foreach ( $flag_table as $key => $props ) {
403     if ( isset ( $props['cfgsec'] ) ) {
404       $cfgsec = $props["cfgsec"];
405       $cfgsecs[$cfgsec] = $cfgsec;
406     }
407   }
408   return ( $cfgsecs );
409 }
410
411
412 function write_file ($fname, $filedata) {
413         
414         $fp = fopen ( $fname, "wb" );
415         if ( $fp <= 0 ) {
416                 die ( "Unable to open $fname file for output!" );
417         }
418         
419     fwrite ( $fp, $filedata );
420         fclose($fp);
421 }
422
423
424 function write_gpxe_dhcp_config_file ($fname) {
425         
426   $fp = fopen ( $fname, "wb" );
427   if ( $fp <= 0 ) {
428     die ( "Unable to open $fname file for output!" );
429   }
430         
431     fwrite ( $fp, "#!gpxe\n");
432     fwrite ( $fp, "echo \"Hi, We will be using PXEKnife from URL http://localhost/pxeknife\"\n");
433     fwrite ( $fp, "echo \"It is assumed that you have dhcp networking\"\n");
434     fwrite ( $fp, "imgload pxeSTATIC.gpxe\n");
435     fwrite ( $fp, "imgstat\n");
436     fwrite ( $fp, "ifopen net0\n");
437     fwrite ( $fp, "echo \"Hit Control+C to cancel DHCP\"\n");
438     fwrite ( $fp, "echo \"You may want to do this if you want to use static-IP\"\n");
439     fwrite ( $fp, "echo \"Otherwise, it will try DHCP, and then anyway go to static-IP\"\n");
440     fwrite ( $fp, "sleep 4\n");
441     fwrite ( $fp, "dhcp net0\n");
442     fwrite ( $fp, "set 209:string pxelinux.cfg/default\n");
443     fwrite ( $fp, "set 210:string http://192.168.0.1/pxeknife/\n");
444     fwrite ( $fp, "echo \"Here we go\"\n");
445     fwrite ( $fp, "chain http://192.168.0.1/pxeknife/pxelinux.0\n");
446     fwrite ( $fp, "echo \"PxeKnife booting cancelled, using local disk instead..\"\n");
447     
448         fclose($fp);    
449 }
450
451 function write_gpxe_config_file ( $fname, $IP, $NetMask, $GateWay, $DNS) 
452 {
453  
454  
455   $fp = fopen ( $fname, "wb" );
456   if ( $fp <= 0 ) {
457     die ( "Unable to open $fname file for output!" );
458   }
459
460     fwrite ( $fp, "#!gpxe\n" );
461     fwrite ( $fp, "echo \"Hi, We will be using PXEKnife from URL $PXELINUX_PATH\"\n");
462         fwrite ( $fp, "echo \"It is assumed that you have Static networking\" \n");
463     fwrite ( $fp, "echo \"Using net0 card\" \n");
464         fwrite ( $fp, "echo \"Using net0/ip = $IP \" \n" ); 
465         fwrite ( $fp, "echo \"Using net0/netmask = $NetMask \" \n" );
466         fwrite ( $fp, "echo \"Using net0/gateway = $GateWay \" \n" );
467         fwrite ( $fp, "echo \"Using net0/dns = $DNS \" \n" );
468         
469         
470         fwrite ( $fp, "set net0/ip $IP\n" ); 
471         fwrite ( $fp, "set net0/netmask $NetMask\n" );
472         fwrite ( $fp, "set net0/gateway $GateWay\n" );
473         fwrite ( $fp, "set net0/dns $DNS\n" );
474         fwrite ( $fp, "set 209:string /pxeknife.cfg/default \n");
475         fwrite ( $fp, "set 210:string http://www.alien.doesntexist.org/pxeknife/ \n");
476         fwrite ( $fp, "echo \"Here we go\" \n" );
477         fwrite ( $fp, "chain http://www.alien.doesntexist.org/pxeknife/pxelinux.0 \n" );
478         
479         fclose($fp);
480 }
481
482 function write_config_file ( $fname, $arch, $flags ) 
483 {
484   global $flag_table;
485
486   $cfgsecs = get_cfgsecs ();
487
488   $fp = fopen ( $fname, "wb" );
489   if ( $fp <= 0 ) {
490     die ( "Unable to open $fname file for output!" );
491   }
492
493   foreach ( $cfgsecs as $cfgsec ) {
494
495     fwrite ( $fp, "/* @BEGIN ${cfgsec}.h \n*/ \n\n" );
496
497     foreach ( $flags as $key => $value ) {
498
499       // When the flag matches this section name, write it out
500       if ( $flag_table[$key]["cfgsec"] == $cfgsec ) {
501         fwrite ( $fp, pprint_flag ( $key, $value ) . "\n" );
502       } 
503
504     }
505     fwrite ( $fp, "\n/* @END ${cfgsec}.h \n*/ \n\n" );
506   }
507   fclose($fp);
508 }
509
510 function cleanstring ($s) {
511   $len = strlen($s);
512   if ($len > 80) {
513     $s = substr ($s, 0, 80);
514   }
515   $s = trim($s);
516   $pos = 0;
517   $result = "";
518   while($pos < $len) {
519     $ltr = ord( ucfirst( $s[$pos]));
520     if ( ($ltr >= ord( "A" )) && ($ltr <= ord( "Z" )) || 
521          ($ltr >= ord( "0" )) && ($ltr <= ord( "9" )) || 
522          ($ltr == ord( "." )) && (strlen($result) > 0) ||
523          ($ltr == ord( "_" )) ||
524          ($ltr == ord( "+" )) ||
525          ($ltr == ord( ":" )) ||
526          ($ltr == ord( "/" )) ||
527          ($ltr == ord( "-" )) ) {
528       $result .= $s[$pos];
529     }
530     $pos++;
531   }
532   return $result;
533 }
534
535 function copydir ( $src, $dst ) 
536 {
537   if ( !mkdir ( $dst, 0700 ) ) {
538     die ( "mkdir failed" );
539   }
540
541   $dp = opendir ( $src );
542   if ( $dp < 1 ) {
543     die ( "opendir failed" );
544   }
545
546   while ( $file = readdir ( $dp ) ) {
547     if ( is_dir ( "$src/$file" ) ) {
548       if ($file[0] != "." ) {
549         copydir ( "$src/$file", "$dst/$file" );
550       }
551     } else {
552       copy ( "$src/$file", "$dst/$file" );
553     }
554   }
555   closedir ( $dp );
556 }
557
558 function mktempcopy ( $src, $dst ) 
559 {
560   if ( $src[0] != "/" ) {
561     $src = dirname($_SERVER['SCRIPT_FILENAME']) . "/" . $src;
562   }
563
564   $dir = tempnam ( $dst, "ROM" );
565   unlink( $dir );
566
567   //  copydir ( $src, $dir );
568
569   exec ( "/bin/cp -a '$src' '$dir' 2>&1", $cpytxt, $status );  
570
571   if ( $status != 0 ) {
572     die ( "src directory copy failed!" );
573   }
574
575   return ( $dir );
576 }
577
578 function deltempdir ($dir) 
579 {
580   $dp = opendir ( $dir );
581   if ($dp < 1) {
582     die ( "opendir failed" );
583   }
584
585   while ( $file = readdir ( $dp ) ) {
586
587     if ( is_dir ( "$dir/$file" ) ) {
588       if ($file[0] != "." ) {
589         deltempdir ( "$dir/$file" );
590       }
591     } else {
592       unlink( "$dir/$file" );
593     }
594   }
595   closedir ( $dp );
596
597   if ( !rmdir ( "$dir" ) ) {
598     die ( "rmdir failed" );
599   }
600 }
601
602 function debug_info () 
603 {
604
605   $F = $_GET['F'];
606   $nic = $_GET['nic'];
607   $ofmt = $_GET['ofmt'];
608
609   $s = "F=\"" . htmlentities($F) . "\"<br>\n";
610   $s .= "nic=\"" . htmlentities($nic) . "\"<br>\n";
611   $s .= "ofmt=\"" . htmlentities($ofmt) . "\"<br>\n";
612
613   return $s;
614 }
615
616 function showflags ($flags) 
617 {
618    reset($flags);
619    while (list ($key, $flag) = each ($flags)) {
620      print ( "flag[".$key."]="."\"$flag\""."<br>" );
621    }
622 }
623
624 function dump_flag_table () 
625 {
626   global $flag_table;
627   reset ( $flag_table );
628
629   while ( list ( $key, $props ) = each ( $flag_table ) ) {
630     print ( "flag_table[" . $key . "] = " . "<br>" );
631
632     while ( list ( $key2, $props2 ) = each ( $props ) ) {
633       print ( "&nbsp;&nbsp;&nbsp;" . $key2 . " = " . $props2 . "<br>" );
634     }
635
636   }
637 }
638
639 function dump_flag_table_keys_sorted () 
640 {
641   global $flag_table;
642   reset ( $flag_table );
643   ksort ( $flag_table );
644
645   while ( list ( $key, $props ) = each ( $flag_table ) ) {
646     print ( $key . ".html<br>" );
647   }
648 }
649
650 function dump_flag_codes () 
651 {
652   global $flag_codes;
653   reset ( $flag_codes );
654
655   while ( list ( $key, $props ) = each ( $flag_codes ) ) {
656     print ( "flag_codes[" . $key . "] = " . "<br>" );
657
658     while ( list ( $key2, $props2 ) = each ( $props ) ) {
659       print ( "&nbsp;&nbsp;&nbsp;" . $key2 . " = " . $props2 . "<br>" );
660     }
661   }
662 }
663
664 function curPageURL () 
665 {
666   $isHTTPS = ( isset ( $_SERVER["HTTPS"] ) && $_SERVER["HTTPS"] == "on" );
667
668   $port = ( isset($_SERVER["SERVER_PORT"] ) && 
669             ( ( !$isHTTPS && $_SERVER["SERVER_PORT"] != "80" ) || 
670               ( $isHTTPS  && $_SERVER["SERVER_PORT"] != "443" ) ) );
671
672   $port = ( $port ) ? ':' . $_SERVER["SERVER_PORT"] : '';
673
674   $url = ( $isHTTPS ? 'https://' : 'http://' ) .
675          $_SERVER["SERVER_NAME"] . $port.$_SERVER["REQUEST_URI"];
676
677   return $url;
678 }
679
680 ?>