1 | <?php // -*- Mode: PHP; -*-
|
---|
2 |
|
---|
3 | /**
|
---|
4 | * Copyright (C) 2009 Marty Connor <mdc@etherboot.org>.
|
---|
5 | * Copyright (C) 2009 Entity Cyber, Inc.
|
---|
6 | *
|
---|
7 | * This program is free software; you can redistribute it and/or
|
---|
8 | * modify it under the terms of the GNU General Public License as
|
---|
9 | * published by the Free Software Foundation; either version 2 of the
|
---|
10 | * License, or any later version.
|
---|
11 | *
|
---|
12 | * This program is distributed in the hope that it will be useful, but
|
---|
13 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
15 | * General Public License for more details.
|
---|
16 | *
|
---|
17 | * You should have received a copy of the GNU General Public License
|
---|
18 | * along with this program; if not, write to the Free Software
|
---|
19 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
---|
20 | */
|
---|
21 |
|
---|
22 | // Include table of user-configurable iPXE options
|
---|
23 | require_once "flag-table.php";
|
---|
24 |
|
---|
25 | // Include user-shadowable globals
|
---|
26 | require_once "globals.php";
|
---|
27 |
|
---|
28 | // Allow user to shadow globals
|
---|
29 | if ( is_file ( 'local-config.php' ) ) {
|
---|
30 | include_once "local-config.php";
|
---|
31 | }
|
---|
32 |
|
---|
33 | ////
|
---|
34 | // General utility functions
|
---|
35 | ////
|
---|
36 |
|
---|
37 | /**
|
---|
38 | * Remove undesirable characters from a given string
|
---|
39 | *
|
---|
40 | * Certain characters have the potential to be used for
|
---|
41 | * malicious purposes by web-based attackers. This routine
|
---|
42 | * filters out such characters.
|
---|
43 | *
|
---|
44 | * @param string $s supplied string
|
---|
45 | *
|
---|
46 | * @return string returned string with unwanted characters
|
---|
47 | * removed
|
---|
48 | */
|
---|
49 | function cleanstring ( $s )
|
---|
50 | {
|
---|
51 | $len = strlen ( $s );
|
---|
52 | if ( $len > 80 ) {
|
---|
53 | $s = substr ( $s, 0, 80 );
|
---|
54 | }
|
---|
55 |
|
---|
56 | $s = trim ( $s );
|
---|
57 | $pos = 0;
|
---|
58 | $result = "";
|
---|
59 |
|
---|
60 | while ( $pos < $len ) {
|
---|
61 | $ltr = ord ( ucfirst ( $s[$pos] ) );
|
---|
62 | if ( ( $ltr >= ord ( "A" ) ) && ( $ltr <= ord ( "Z" ) ) ||
|
---|
63 | ( $ltr >= ord ( "0" ) ) && ( $ltr <= ord ( "9" ) ) ||
|
---|
64 | ( $ltr == ord ( "." ) ) && ( strlen ( $result ) > 0 ) ||
|
---|
65 | ( $ltr == ord ( "_" ) ) ||
|
---|
66 | ( $ltr == ord ( "+" ) ) ||
|
---|
67 | ( $ltr == ord ( ":" ) ) ||
|
---|
68 | ( $ltr == ord ( "/" ) ) ||
|
---|
69 | ( $ltr == ord ( "-" ) ) ) {
|
---|
70 | $result .= $s[$pos];
|
---|
71 | }
|
---|
72 | $pos++;
|
---|
73 | }
|
---|
74 | return $result;
|
---|
75 | }
|
---|
76 |
|
---|
77 | /**
|
---|
78 | * Return URL of the currently running script, minus the filename
|
---|
79 | *
|
---|
80 | * @return string the URL of the currently running script, minus the filename
|
---|
81 | */
|
---|
82 | function curDirURL ()
|
---|
83 | {
|
---|
84 | $dir = dirname ( $_SERVER['PHP_SELF'] );
|
---|
85 |
|
---|
86 | if ( $dir == "." || $dir == "/" ) {
|
---|
87 | $dir = "";
|
---|
88 | }
|
---|
89 |
|
---|
90 | $isHTTPS = ( isset ( $_SERVER["HTTPS"] ) && $_SERVER["HTTPS"] == "on" );
|
---|
91 | $port = ( isset($_SERVER["SERVER_PORT"] ) &&
|
---|
92 | ( ( !$isHTTPS && $_SERVER["SERVER_PORT"] != "80" ) ||
|
---|
93 | ( $isHTTPS && $_SERVER["SERVER_PORT"] != "443" ) ) );
|
---|
94 |
|
---|
95 | $port = ( $port ) ? ':' . $_SERVER["SERVER_PORT"] : '';
|
---|
96 |
|
---|
97 | $dest = ( $isHTTPS ? 'https://' : 'http://' ) .
|
---|
98 | $_SERVER["SERVER_NAME"] . $dir . "/";
|
---|
99 |
|
---|
100 | return $dest;
|
---|
101 | }
|
---|
102 |
|
---|
103 | /**
|
---|
104 | * Extract NIC families and associated ROM PCI IDs from the src/bin/NIC file.
|
---|
105 | *
|
---|
106 | * $src_dir must contain the path of the iPXE src directory for this build
|
---|
107 | *
|
---|
108 | * @return array[0] array $new_nics
|
---|
109 | * @return array[1] array $roms
|
---|
110 | */
|
---|
111 | function parse_nic_file ()
|
---|
112 | {
|
---|
113 | global $src_dir;
|
---|
114 |
|
---|
115 | $fd = fopen ( "$src_dir/bin/NIC", "r" );
|
---|
116 | if ( ! $fd ) {
|
---|
117 | die ( "Missing src/bin/NIC file. 'make bin/NIC'" );
|
---|
118 | }
|
---|
119 |
|
---|
120 | $nics = array ();
|
---|
121 | $roms = array ();
|
---|
122 | $nic = "";
|
---|
123 |
|
---|
124 | while ( !feof ( $fd ) ) {
|
---|
125 |
|
---|
126 | $line = trim ( fgets ( $fd, 200 ) );
|
---|
127 |
|
---|
128 | $first_eight_chars = substr ( $line, 0, 8 );
|
---|
129 | settype ( $first_eight_chars, "string" );
|
---|
130 |
|
---|
131 | if ( strpos ( $first_eight_chars, "family" ) === 0 ) {
|
---|
132 |
|
---|
133 | // get pathname of NIC driver
|
---|
134 | #list ( $dummy, $nic ) = split( "[ \t]+", $line );
|
---|
135 | list ( $dummy, $nic ) = explode("\t", $line);
|
---|
136 | settype ( $nic, "string" );
|
---|
137 |
|
---|
138 | // extract filename name of driver from pathname
|
---|
139 | $nic = substr ( $nic, strrpos ( $nic, "/" ) + 1,
|
---|
140 | strlen ( $nic ) - strrpos ( $nic, "/" ) + 1 );
|
---|
141 |
|
---|
142 | $nics[$nic] = $nic;
|
---|
143 |
|
---|
144 | // For each ISA NIC, there can only be one ROM variant
|
---|
145 | $roms[$nic] = $nic;
|
---|
146 | }
|
---|
147 |
|
---|
148 | // If the first 8 digits of the line are hex digits
|
---|
149 | // add this rom to the current nic family.
|
---|
150 |
|
---|
151 | if ( ( strlen ( $first_eight_chars ) == 8 )
|
---|
152 | && ( ctype_xdigit ( $first_eight_chars ) )
|
---|
153 | && ( $nic != "" ) ) {
|
---|
154 |
|
---|
155 | $roms[$first_eight_chars] = $nic;
|
---|
156 | }
|
---|
157 | }
|
---|
158 | fclose ( $fd );
|
---|
159 |
|
---|
160 | // put most NICs in nice alpha order for menu
|
---|
161 | ksort ( $nics );
|
---|
162 |
|
---|
163 | // add special cases to the top
|
---|
164 |
|
---|
165 | $new_nics = array ( "all-drivers" => "ipxe",
|
---|
166 | "undionly" => "undionly",
|
---|
167 | "undi" => "undi",
|
---|
168 | );
|
---|
169 |
|
---|
170 | foreach ( $nics as $key => $value ) {
|
---|
171 | // skip the undi driver
|
---|
172 | if ( $key != "undi" ) {
|
---|
173 | $new_nics[$key] = $value;
|
---|
174 | }
|
---|
175 | }
|
---|
176 |
|
---|
177 | return array ( $new_nics, $roms );
|
---|
178 | }
|
---|
179 |
|
---|
180 | ////
|
---|
181 | // HTML form utility functions
|
---|
182 | ////
|
---|
183 |
|
---|
184 | /**
|
---|
185 | * Return html code to create hidden form input fields
|
---|
186 | *
|
---|
187 | * @param string $flag name of form variable to set
|
---|
188 | * @param string $value value to give form variable
|
---|
189 | *
|
---|
190 | * @return string html code for given hidden form input field
|
---|
191 | */
|
---|
192 | function hidden ( $flag, $value )
|
---|
193 | {
|
---|
194 | $value = htmlentities ( $value );
|
---|
195 | return "<input type=\"hidden\" value=\"$value\" name=\"$flag\"></input>";
|
---|
196 | }
|
---|
197 |
|
---|
198 | /**
|
---|
199 | * Return html code to create checkbox form input fields
|
---|
200 | *
|
---|
201 | * @param string $flag name of form variable to set
|
---|
202 | * @param string $value "on" means box should be checked
|
---|
203 | *
|
---|
204 | * @return string html code for given hidden form input field
|
---|
205 | */
|
---|
206 | function checkbox ( $flag, $value )
|
---|
207 | {
|
---|
208 | return "<input type=\"checkbox\" value=\"on\" name=\"$flag\"" .
|
---|
209 | ($value == "on" ? " checked>" : ">" );
|
---|
210 | }
|
---|
211 |
|
---|
212 | /**
|
---|
213 | * Return html code to create text form input fields
|
---|
214 | *
|
---|
215 | * @param string $flag name of form variable to set
|
---|
216 | * @param string $value initial contents of field
|
---|
217 | * @param string $size size in characters of text box
|
---|
218 | *
|
---|
219 | * @return string html code for given text input field
|
---|
220 | */
|
---|
221 | function textbox ( $flag, $value, $size )
|
---|
222 | {
|
---|
223 | $value = htmlentities ( $value );
|
---|
224 | return "<input type=\"text\" size=\"$size\" value=\"$value\" name=\"$flag\">";
|
---|
225 | }
|
---|
226 |
|
---|
227 | /**
|
---|
228 | * Return html code to create textarea form fields
|
---|
229 | *
|
---|
230 | * @param string $flag name of form variable to set
|
---|
231 | * @param string $value initial contents of textarea
|
---|
232 | * @param string $rows height of text area in rows
|
---|
233 | * @param string $cols width of text area in columns
|
---|
234 | *
|
---|
235 | * @return string html code for given textarea input field
|
---|
236 | */
|
---|
237 | function textarea ( $flag, $value, $rows, $cols )
|
---|
238 | {
|
---|
239 | $value = htmlentities ( $value );
|
---|
240 | return "<textarea name=\"$flag\" rows=\"$rows\" cols=\"$cols\">"
|
---|
241 | . $value . "</textarea>";
|
---|
242 | }
|
---|
243 |
|
---|
244 | /**
|
---|
245 | * Return html code to create select (menu) form fields
|
---|
246 | *
|
---|
247 | * Use array of strings as menu choices
|
---|
248 | *
|
---|
249 | * @param string $flag name of form variable to set
|
---|
250 | * @param array $options array of strings representing choices
|
---|
251 | * @param string $value value of choice to select in menu
|
---|
252 | *
|
---|
253 | * @return string html code for given select (menu) input field
|
---|
254 | */
|
---|
255 | function menubox ( $name, $options, $value )
|
---|
256 | {
|
---|
257 | $s="<select name=\"$name\">";
|
---|
258 |
|
---|
259 | foreach ( $options as $ignore => $option ) {
|
---|
260 | if ( !$value ) $value = $option;
|
---|
261 | $s .= "<option" . ( $option == $value ? " selected>" : ">" ) .
|
---|
262 | htmlentities ( $option ) . "</option>";
|
---|
263 | }
|
---|
264 | return $s . "</select>";
|
---|
265 | }
|
---|
266 |
|
---|
267 | /**
|
---|
268 | * Return html code to create select (menu) form fields
|
---|
269 | *
|
---|
270 | * Use indices of array of strings as menu choices rather than
|
---|
271 | * the values pointed to by the indicies.
|
---|
272 | *
|
---|
273 | * @param string $flag name of form variable to set
|
---|
274 | * @param array $options array of strings representing choices
|
---|
275 | * @param string $value value of choice to select in menu
|
---|
276 | *
|
---|
277 | * @return string html code for given select (menu) input field
|
---|
278 | */
|
---|
279 | function keys_menubox ( $name, $options, $value )
|
---|
280 | {
|
---|
281 | $s="<select name=\"$name\">";
|
---|
282 |
|
---|
283 | foreach ( $options as $option => $ignore ) {
|
---|
284 | if ( !$value ) $value = $option;
|
---|
285 | $s .= "<option" . ( $option == $value ? " selected>" : ">" ) .
|
---|
286 | htmlentities ( $option ) . "</option>";
|
---|
287 | }
|
---|
288 | return $s . "</select>";
|
---|
289 | }
|
---|
290 |
|
---|
291 | ////
|
---|
292 | // Flag (compile option) handling functions
|
---|
293 | ////
|
---|
294 |
|
---|
295 | /**
|
---|
296 | * Return default compile options (flags)
|
---|
297 | *
|
---|
298 | * Initial compile options are in a global called $flag_table.
|
---|
299 | * Create and return an array containing the ones we want.
|
---|
300 | *
|
---|
301 | * @return array default compile options (flags)
|
---|
302 | */
|
---|
303 | function default_flags ()
|
---|
304 | {
|
---|
305 | global $flag_table;
|
---|
306 |
|
---|
307 | $flags = array ();
|
---|
308 |
|
---|
309 | foreach ( $flag_table as $key => $props ) {
|
---|
310 |
|
---|
311 | $flag = $props["flag"];
|
---|
312 | $type = $props["type"];
|
---|
313 |
|
---|
314 | // Fields like headers have no "value" property
|
---|
315 | if ( isset ( $props["value"] ) ) {
|
---|
316 | $flags[$flag] = $props["value"];
|
---|
317 | }
|
---|
318 | }
|
---|
319 | return $flags;
|
---|
320 | }
|
---|
321 |
|
---|
322 | /**
|
---|
323 | * Return combination of default and user compile options (flags)
|
---|
324 | *
|
---|
325 | * Initial compile options are in a global called $flag_table.
|
---|
326 | * Compile options may have been changed via form input. We return
|
---|
327 | * an array with either the default value of each option or a user
|
---|
328 | * supplied value from form input.
|
---|
329 | *
|
---|
330 | * @return array combined default and user supplied compile options (flags)
|
---|
331 | */
|
---|
332 | function get_flags ()
|
---|
333 | {
|
---|
334 | global $flag_table;
|
---|
335 |
|
---|
336 | $flags = default_flags ();
|
---|
337 |
|
---|
338 | if ( ! isset ( $_POST["use_flags"] ) )
|
---|
339 | return $flags;
|
---|
340 |
|
---|
341 | foreach ( $flag_table as $key => $props ) {
|
---|
342 |
|
---|
343 | $flag = $props["flag"];
|
---|
344 | $type = $props["type"];
|
---|
345 |
|
---|
346 | if ( isset ( $_POST["$flag"] ) ) {
|
---|
347 | $flags[$flag] = $_POST["$flag"];
|
---|
348 | if ( $type == "integer-hex" ) {
|
---|
349 | if ( strtolower ( substr ( $flags[$flag], 0, 2 ) ) != "0x" ) {
|
---|
350 | $flags[$flag] = "0x" . $flags[$flag];
|
---|
351 | }
|
---|
352 | }
|
---|
353 | } else if ( $type == "on/off" ) {
|
---|
354 | // Unchecked checkboxes don't pass any POST value
|
---|
355 | // so we must check for them specially. At this
|
---|
356 | // point we know that there is no $_POST value set
|
---|
357 | // for this option. If it is a checkbox, this means
|
---|
358 | // it is unchecked, so record that in $flags so we
|
---|
359 | // can later generate an #undef for this option.
|
---|
360 | $flags[$flag] = "off";
|
---|
361 | }
|
---|
362 | }
|
---|
363 | return $flags;
|
---|
364 | }
|
---|
365 |
|
---|
366 | /**
|
---|
367 | * Output given value in appropriate format for iPXE config file
|
---|
368 | *
|
---|
369 | * iPXE config/*.h files use C pre-processor syntax. Output the given
|
---|
370 | * compile option in a format appropriate to its type
|
---|
371 | *
|
---|
372 | * @param string $key index into $flag_table for given compile option
|
---|
373 | * @param string $value value we wish to set compile option to
|
---|
374 | *
|
---|
375 | * @return string code to set compile option to given value
|
---|
376 | */
|
---|
377 | function pprint_flag ( $key, $value )
|
---|
378 | {
|
---|
379 | global $flag_table;
|
---|
380 |
|
---|
381 | // Determine type of given compile option (flag)
|
---|
382 | $type = $flag_table[$key]["type"];
|
---|
383 | $s = "";
|
---|
384 |
|
---|
385 | if ( $type == "on/off" && $value == "on" ) {
|
---|
386 | $s = "#define $key";
|
---|
387 | } else if ( $type == "on/off" && $value != "on" ) {
|
---|
388 | $s = "#undef $key";
|
---|
389 | } else if ( $type == "string" ) {
|
---|
390 | $s = ( "#define $key \"" . cleanstring ( $value ) . "\"" );
|
---|
391 | } else if ($type == "qstring" ) {
|
---|
392 | $s = ( "#define $key \\\"" . cleanstring ( $value ) . "\\\"" );
|
---|
393 | } else {
|
---|
394 | $s = "#define $key " . cleanstring ( $value );
|
---|
395 | }
|
---|
396 |
|
---|
397 | return $s;
|
---|
398 | }
|
---|
399 |
|
---|
400 | /**
|
---|
401 | * Output html code to display all compile options as a table
|
---|
402 | *
|
---|
403 | * @param array $flags array of compile options
|
---|
404 | *
|
---|
405 | * @return void
|
---|
406 | */
|
---|
407 | function echo_flags ( $flags )
|
---|
408 | {
|
---|
409 | global $flag_table;
|
---|
410 |
|
---|
411 | echo "<table>\n";
|
---|
412 |
|
---|
413 | foreach ( $flag_table as $key => $props ) {
|
---|
414 |
|
---|
415 | // Hide parameters from users that should not be changed.
|
---|
416 | $hide_from_user = isset ( $props["hide_from_user"] ) ? $props["hide_from_user"] : "no";
|
---|
417 |
|
---|
418 | $flag = $props["flag"];
|
---|
419 | $type = $props["type"];
|
---|
420 |
|
---|
421 | $value = isset ( $flags[$flag] ) ? $flags[$flag] : '';
|
---|
422 |
|
---|
423 | if ( $hide_from_user == "yes" ) {
|
---|
424 |
|
---|
425 | // Hidden flags cannot not be set by the user. We use hidden form
|
---|
426 | // fields to keep them at their default values.
|
---|
427 | if ( $type != "header" ) {
|
---|
428 | echo hidden ( $flag, $value );
|
---|
429 | }
|
---|
430 |
|
---|
431 | } else {
|
---|
432 |
|
---|
433 | // Flag (iPXE compile option) should be displayed to user
|
---|
434 |
|
---|
435 | if ( $type == "header" ) {
|
---|
436 |
|
---|
437 | $label = $props["label"];
|
---|
438 | echo "<td colspan=2><hr><h3>$label</h3><hr></td>";
|
---|
439 |
|
---|
440 | } else if ($type == "on/off" ) {
|
---|
441 |
|
---|
442 | echo "<td>", checkbox ( $flag, $value ), "</td><td><strong>$flag</strong></td>";
|
---|
443 |
|
---|
444 | } else { // don't display checkbox for non-on/off flags
|
---|
445 |
|
---|
446 | echo "<td> </td><td><strong>$flag: </strong>";
|
---|
447 |
|
---|
448 | if ($type == "choice" ) {
|
---|
449 | $options = $props["options"];
|
---|
450 | echo menubox($flag, $options, $value);
|
---|
451 |
|
---|
452 | } else {
|
---|
453 |
|
---|
454 | echo textbox($flag, $value, ($type == "integer" ||
|
---|
455 | $type == "integer-hex"
|
---|
456 | ? 7 : 25));
|
---|
457 | }
|
---|
458 | echo "</td>";
|
---|
459 | }
|
---|
460 | echo "</tr>\n";
|
---|
461 |
|
---|
462 | if ( $type != "header" ) {
|
---|
463 | echo "<tr><td> </td>";
|
---|
464 | echo "<td>\n";
|
---|
465 | if ( is_file ( "doc/$flag.html" ) ) {
|
---|
466 | include_once "doc/$flag.html";
|
---|
467 | }
|
---|
468 | echo "\n</td></tr>\n";
|
---|
469 | }
|
---|
470 | }
|
---|
471 | }
|
---|
472 | echo "</table>";
|
---|
473 | }
|
---|
474 |
|
---|
475 | /**
|
---|
476 | * Return an array of configuration sections used in all compile options
|
---|
477 | *
|
---|
478 | * $flag_table, the global list of compile options contains a 'cfgsec'
|
---|
479 | * property for each flag we are interested in. We return a list of
|
---|
480 | * all the unique cfgsec options we find in $flag_table.
|
---|
481 | *
|
---|
482 | * @return array an array of strings representing all unique cfgsec values
|
---|
483 | * found in $flag_table
|
---|
484 | */
|
---|
485 | function get_flag_cfgsecs ()
|
---|
486 | {
|
---|
487 | global $flag_table;
|
---|
488 | $cfgsecs = array ();
|
---|
489 |
|
---|
490 | foreach ( $flag_table as $key => $props ) {
|
---|
491 | if ( isset ( $props['cfgsec'] ) ) {
|
---|
492 | $cfgsec = $props["cfgsec"];
|
---|
493 | $cfgsecs[$cfgsec] = $cfgsec;
|
---|
494 | }
|
---|
495 | }
|
---|
496 | return $cfgsecs;
|
---|
497 | }
|
---|
498 |
|
---|
499 | ////
|
---|
500 | // File and directory handling functions
|
---|
501 | ////
|
---|
502 |
|
---|
503 | /**
|
---|
504 | * Create a copy of a given source directory to a given destination
|
---|
505 | *
|
---|
506 | * Since we are going to modify the source directory, we create a copy
|
---|
507 | * of the directory with a unique name in the given destination directory.
|
---|
508 | * We supply a prefix for the tempnam call to prepend to the random filename
|
---|
509 | * it generates.
|
---|
510 | *
|
---|
511 | * @param string $src source directory
|
---|
512 | * @param string $dst destination directory
|
---|
513 | * @param string $prefix string to append to directory created
|
---|
514 | *
|
---|
515 | * @return string absolute path to destination directory
|
---|
516 | */
|
---|
517 | function mktempcopy ( $src, $dst, $prefix )
|
---|
518 | {
|
---|
519 | if ( $src[0] != "/" ) {
|
---|
520 | $src = dirname ( $_SERVER['SCRIPT_FILENAME'] ) . "/" . $src;
|
---|
521 | }
|
---|
522 |
|
---|
523 | // Create a file in the given destination directory with a unique name
|
---|
524 | $dir = tempnam ( $dst, $prefix );
|
---|
525 |
|
---|
526 | // Delete the file just created, since it would interfere with the copy we
|
---|
527 | // are about to do. We only care that the dir name we copy to is unique.
|
---|
528 | unlink ( $dir );
|
---|
529 |
|
---|
530 | exec ( "/bin/cp -a '$src' '$dir' 2>&1", $cpytxt, $status );
|
---|
531 |
|
---|
532 | if ( $status != 0 ) {
|
---|
533 | die ( "src directory copy failed!" );
|
---|
534 | }
|
---|
535 | return $dir;
|
---|
536 | }
|
---|
537 |
|
---|
538 | /**
|
---|
539 | * Write iPXE config files based on value of given flags
|
---|
540 | *
|
---|
541 | * iPXE compile options are stored in src/config/*.h .
|
---|
542 | * We write out a config file for each set of options.
|
---|
543 | *
|
---|
544 | * @param string $config_dir directory to write .h files to
|
---|
545 | * @param array $flags array of compile options for this build
|
---|
546 | *
|
---|
547 | * @return void
|
---|
548 | */
|
---|
549 | function write_ipxe_config_files ( $config_dir, $flags )
|
---|
550 | {
|
---|
551 | global $flag_table;
|
---|
552 |
|
---|
553 | $cfgsecs = get_flag_cfgsecs ();
|
---|
554 |
|
---|
555 | foreach ( $cfgsecs as $cfgsec ) {
|
---|
556 |
|
---|
557 | $fname = $config_dir . "/" . $cfgsec . ".h";
|
---|
558 |
|
---|
559 | $fp = fopen ( $fname, "wb" );
|
---|
560 | if ( $fp <= 0 ) {
|
---|
561 | die ( "Unable to open $fname file for output!" );
|
---|
562 | }
|
---|
563 |
|
---|
564 | $ifdef_secname = "CONFIG_" . strtoupper ( $cfgsec ) . "_H";
|
---|
565 |
|
---|
566 | fwrite ( $fp, "#ifndef ${ifdef_secname}\n" );
|
---|
567 | fwrite ( $fp, "#define ${ifdef_secname}\n" );
|
---|
568 | fwrite ( $fp, "#include <config/defaults.h>\n" );
|
---|
569 |
|
---|
570 | foreach ( $flags as $key => $value ) {
|
---|
571 | // When the flag matches this section name, write it out
|
---|
572 | if ( $flag_table[$key]["cfgsec"] == $cfgsec ) {
|
---|
573 | fwrite ( $fp, pprint_flag ( $key, $value ) . "\n" );
|
---|
574 | }
|
---|
575 | }
|
---|
576 | fwrite ( $fp, "#endif /* ${ifdef_secname} */\n" );
|
---|
577 | fclose ( $fp );
|
---|
578 | }
|
---|
579 | }
|
---|
580 |
|
---|
581 | /**
|
---|
582 | * Output a string to a file
|
---|
583 | *
|
---|
584 | * Output a given string to a given pathname. The file will be created if
|
---|
585 | * necessary, and the string will replace the file's contents in all cases.
|
---|
586 | *
|
---|
587 | * @param string $fname pathname of file to output string to
|
---|
588 | * @param string $ftext text to output to file
|
---|
589 | *
|
---|
590 | * @return void
|
---|
591 | */
|
---|
592 | function write_file_from_string ( $fname, $ftext )
|
---|
593 | {
|
---|
594 | $fp = fopen ( $fname, "wb" );
|
---|
595 | if ( ! $fp ) {
|
---|
596 | die ( "Unable to open $fname file for output!" );
|
---|
597 | }
|
---|
598 | fwrite ( $fp, $ftext );
|
---|
599 | fclose ( $fp );
|
---|
600 | }
|
---|
601 |
|
---|
602 | /**
|
---|
603 | * Delete a file or recursively delete a directory tree
|
---|
604 | *
|
---|
605 | * @param string $file_or_dir_name name of file or directory to delete
|
---|
606 | * @return bool Returns TRUE on success, FALSE on failure
|
---|
607 | */
|
---|
608 | function rm_file_or_dir ( $file_or_dir_name )
|
---|
609 | {
|
---|
610 | if ( ! file_exists ( $file_or_dir_name ) ) {
|
---|
611 | return false;
|
---|
612 | }
|
---|
613 |
|
---|
614 | if ( is_file ( $file_or_dir_name ) || is_link ( $file_or_dir_name ) ) {
|
---|
615 | return unlink ( $file_or_dir_name );
|
---|
616 | }
|
---|
617 |
|
---|
618 | $dir = dir ( $file_or_dir_name );
|
---|
619 | while ( ( $dir_entry = $dir->read () ) !== false ) {
|
---|
620 |
|
---|
621 | if ( $dir_entry == '.' || $dir_entry == '..') {
|
---|
622 | continue;
|
---|
623 | }
|
---|
624 | rm_file_or_dir ( $file_or_dir_name . '/' . $dir_entry );
|
---|
625 | }
|
---|
626 | $dir->close();
|
---|
627 |
|
---|
628 | return rmdir ( $file_or_dir_name );
|
---|
629 | }
|
---|
630 |
|
---|
631 | ////
|
---|
632 | // Debugging functions
|
---|
633 | ////
|
---|
634 |
|
---|
635 | /**
|
---|
636 | * Emit html code to display given array of compile options (flags)
|
---|
637 | *
|
---|
638 | * @param array $flags array of compile options for this build
|
---|
639 | *
|
---|
640 | * @return void
|
---|
641 | */
|
---|
642 | function show_flags ( $flags )
|
---|
643 | {
|
---|
644 | echo ( "\$flags contains " . count ( $flags ) . " elements:" . "<br>" );
|
---|
645 |
|
---|
646 | foreach ( $flags as $key => $flag ) {
|
---|
647 | echo ( "\$flags[" . $key . "]=" . "\"$flag\"" . "<br>" );
|
---|
648 | }
|
---|
649 | }
|
---|
650 |
|
---|
651 | /**
|
---|
652 | * Emit HTML code to display default array of compile options (flags)
|
---|
653 | *
|
---|
654 | * $flag_table contains default compile options and properties. This
|
---|
655 | * routine outputs HTML code to display all properties of $flag_table.
|
---|
656 | *
|
---|
657 | * @return void
|
---|
658 | */
|
---|
659 | function dump_flag_table ()
|
---|
660 | {
|
---|
661 | global $flag_table;
|
---|
662 |
|
---|
663 | echo ( "\$flag_table contains " . count ( $flag_table ) . " elements:" . "<br>" );
|
---|
664 |
|
---|
665 | foreach ( $flag_table as $key => $props ) {
|
---|
666 | print ( "flag_table[" . $key . "] = " . "<br>" );
|
---|
667 |
|
---|
668 | foreach ( $props as $key2 => $props2 ) {
|
---|
669 | print ( " " . $key2 . " = " . $props2 . "<br>" );
|
---|
670 | }
|
---|
671 | }
|
---|
672 | }
|
---|
673 |
|
---|
674 | // Parse src/bin/NIC file
|
---|
675 | list ( $nics, $roms ) = parse_nic_file ();
|
---|
676 |
|
---|
677 | // For emacs:
|
---|
678 | // Local variables:
|
---|
679 | // c-basic-offset: 4
|
---|
680 | // c-indent-level: 4
|
---|
681 | // tab-width: 4
|
---|
682 | // End:
|
---|
683 |
|
---|
684 | ?>
|
---|