Copyright © 2001-2004 ALFS DTD Development Team
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
Redistributions in any form must retain the above copyright notice, this list of conditions and the following disclaimer.
Neither the name of "Linux From Scratch", "Automated Linux From Scratch" nor the names of its contributors may be used to endorse or promote products derived from this material without specific prior written permission.
Any material derived from Linux From Scratch must contain a reference to the "Linux From Scratch" project.
Any material derived from Automated Linux From Scratch must contain a reference to the "Automated Linux From Scratch" project.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Abstract
This book explains in detail how to use ALFS DTD v3.1.
Table of Contents
3.1-2004-06-05 - Jube 5th, 2004
June 5th, 2004 [jwrober]: Updates from Kevin Fleming.
June 4th, 2004 [jwrober]: Added missing elem_include element.
June 4th, 2004 [jwrober]: Following other suggestions from Richard Downing's proofreading; modified the contruction "this allows one to..." to "this allows you to...".
June 3rd, 2004 [jwrober]: Applied patch with some modifications from Richard Downing's proofreading.
May 31st, 2004 [jwrober]: Removed Unused XML Tags from the source.
May 29th, 2004 [jwrober]: With some help from Manuel Canales Esparcia, modified the no-chunks xsl file to support inline css styling.
May 29th, 2004 [jwrober]: Upgraded to DocBook v4.3 and some other little nagging bugs fixes in the render.
May 28th, 2004 [jwrober]: Updated in elem_patch to include element prefix -- Bug 766.
May 28th, 2004 [jwrober]: Updated in elem_make to include element prefix -- Bug 764.
May 28th, 2004 [jwrober]: Updated in elem_execute to include element prefix -- Bug 762.
May 28th, 2004 [jwrober]: Updated in elem_configure and elem_prefix for correct bash examples -- Bug 757.
May 28th, 2004 [jwrober]: Filled in elem_prefix page -- Bug 802.
May 28th, 2004 [jwrober]: Updated alfs.css the rest of the element files to support better formatting of examples.
May 28th, 2004 [jwrober]: Cleaned up elem_archive, elem_configure, elem_copy, elem_description, elem_destination, elem_digest, elem_download, elem_environment, elem_execute, elem_file, elem_find, elem_item, elem_link, elem_list, elem_make, elem_mkdir, elem_move, elem_name, elem_ownership, elem_package, elem_packageinfo, elem_para, elem_param, elem_patch, elem_permissions, elem_remove, elem_replace, elem_requires, elem_search_replace, elem_source, elem_stage, elem_stageinfo, elem_target, elem_textdump, elem_url, elem_user, elem_utilizes, elem_variable.
April 2nd, 2004 [jwrober]: Cleaned up elem_alfs, elem_archive, elem_base, elem_configure, and part of elem_stageinfo.
April 2nd, 2004 [jwrober]: Added more formatting to the XML DTD intro page to match conventions.
April 2nd, 2004 [jwrober]: Added note to the conventions page.
March 30th, 2004 [jwrober]: Removed the implementation specific information in elem_unpack -- Bug 768.
March 30th, 2004 [jwrober]: Removed the note about elem_digest and elem_reference being deprecated in the DTD -- Bug 767.
March 30th, 2004 [jwrober]: Added info about the parents option to elem_mkdir -- Bug 765.
March 30th, 2004 [jwrober]: Finished the XML and DTD syntax intro -- Bug 784.
March 15th, 2004 [jwrober]: Added more to the XML and DTD syntax intro -- Bug 784.
March 14th, 2004 [jwrober]: Added an initial stab at an XML and DTD syntax intro -- Bug 784.
February 23rd, 2004 [jwrober]: Finished the elem_download description -- Bug 760.
February 23rd, 2004 [jwrober]: Finished the elem_url description -- Bug 769.
February 23rd, 2004 [jwrober]: Finished the elem_digest description -- Bug 759.
February 23rd, 2004 [jwrober]: Fixed elem_copy description -- Bug 758.
February 23rd, 2004 [jwrober]: Fixed wierd character in acknowledgements page -- Bug 755.
February 22nd, 2004 [jwrober]: Finished a first pass over the rest of the elements.
November 5th, 2003 [jwrober]: Added elem_prefix.
November 5th, 2003 [jwrober]: Updated elem_configure, elem_copy, elem_description to match the DTD and standardized to the rest of the doc.
November 4th, 2003 [jwrober]: Updated elem_alfs, elem_archive, elem_base to match the DTD; also began the element standardization with the elem_alfs element's page.
November 3rd, 2003 [jwrober]: Standardized headings.
November 3rd, 2003 [jwrober]: Updated acknowledgements, conventions and general preface pages.
September 30th, 2003 [jwrober]: Added an alfs_dtd intro page.
September 26th, 2003 [jwrober]: Modified the header of each page to conform with the DocBook rules that the LFS and BLFS books use (for consistency).
September 24th, 2003 [jwrober]: Removed all references to nALFS, moved files to the ALFS/docs from the ALFS/nALFS/doc moudule in CVS.
September 22nd, 2003 [jwrober]: Various changes to file locations and began standardizing document look and feel like the LFS and BLFS Books.
September 18th, 2003 [vdzuba]: Reorganized the document, now split into small chunks.
February 20th, 2003 [vdzuba]: Added the elements if, then and else.
February 5th, 2003 [vdzuba]: Added an option to link and added element version.
January 19th, 2003 [vdzuba]: Upgraded to version 3.1 of the DTD.
January 8th, 2003 [vdzuba]: Replaced "option?" by "option*" in copy.
December 5th, 2002 [vdzuba]: Added bash script equivalent to all examples.
October 22nd, 2002 [vdzuba]: Replaced "parent" with "parents" in mkdir.
October 21st, 2002 [vdzuba]: Added element digest.
October 13th, 2002 [vdzuba]: Make attribute append of variable optional.
September 5th, 2002 [vdzuba]: Added chapter with syntax.
May 7th, 2002 [highos]: Initial structure.
This book is mainly aimed at those who want more information on the ALFS DTD. The DTD is designed to be implementation agnostic. This means that you may be reading this book as part of an ALFS implementation source tarball or on the ALFS website.
The ALFS DTD uses two mailing list hosted from the Linux From Scratch servers.
Please direct the majority of your emails to the ALFS mailing list at alfs-discuss@linuxfromscratch.org. This is an excellent place to post questions and bug reports. For complete mailing list information, refer to http://www.linuxfromscratch.org/mailman/listinfo/alfs-discuss.
The second list is really for the development team's use and is available at alfs-log@linuxfromscratch.org. This is an excellent place to see the daily activity of the project. For complete mailing list information, refer to http://www.linuxfromscratch.org/mailman/listinfo/alfs-log.
All the mailing lists hosted at linuxfromscratch.org are also accessible via the NNTP server. All messages posted to a mailing list will be copied to its correspondent newsgroup, and vice versa.
The news server can be reached at news.linuxfromscratch.org.
Some other xrefs that might interest you:
Linux From Scratch:
Automated Linux From Scratch:
The current ALFS DTD documentation maintainer is James Robertson. If you need to reach James, send an email to jwrober@linuxfromscratch.org.
We would like to thank the following people and organizations for their contributions towards the Automated Linux From Scratch project:
Vassili Dzuba <vassili@linuxfromscratch.org> -- for helping to create the DTD and writing the intial version of this book.
Gerard Beekmans <gerard@linuxfromscratch.org> -- for being more then a great help.
James Robertson <jwrober@linuxfromscratch.org> -- Current documentation editor.
Jesse Tien-Ten-Que for helping to create the DTD and writing the initial version of this book.
Countless other people on the ALFS mailing list who are making this project happen by giving their suggestions, testing the tools and submitting bug reports.
To make things easy to follow, there are a number of conventions used throughout the book. Following are some examples :
./configure --prefix=/usr
This form of text is designed to be typed in exactly as seen unless otherwise noted in the surrounding text.
install-info: unknown option '--dir-file=/mnt/lfs/usr/info/dir'
This form of text (fixed width text) is showing screen output, probably as the result of commands issued and is also used to show filenames such as /bin/grep
Emphasis
Bold Emphasis
These forms of text are used for several purposes in the book but mainly to emphasize important points or to give examples as to what to type.
http://www.linuxfromscratch.org/alfs
This form of text is used for hyperxrefs, both within the book and to external pages such as HowTo's, download locations, websites, etc.
cat > $LFS/etc/group <<"EOF" root:x:0: bin:x:1: ...... EOF
This type of section is used mainly when creating configuration files. The first command (in bold) tells the system to create the file $LFS/etc/group from whatever is typed on the following lines until the sequence EOF is encountered. Therefore, this whole section is generally typed as seen.
Sample Note
This type of section is to define a notice of some kind. Mostly to alert you of something to take note of.
ALFS profiles are written using an XML syntax. This chapter describes the various XML elements that can occur in a profile.
For each element, the book describes:
the formal definition of the element, using the exact DTD syntax
a description of the element
one or several examples
an equivalent bash script(s) for the examples (when applicable)
To ensure that all readers of the ALFS DTD Book get as much as possible from its contents, it is necessary to provide a quick introduction to the concepts of XML and DTD syntax.
This introduction provides very few examples. This book is written in an XML DTD called DocBook XML. For an example of XML just look at the book's source. Since this book is documenting an XML DTD, look at the rest of the book's contents for examples of DTD syntax.
To begin, here are some basic rules of XML :
XML documents use a self-describing and simple to use syntax.
All XML elements must have a closing tag. With XML, it is illegal to omit the closing tag.
XML tags are case sensitive.
All XML elements must be properly nested. Improper nesting of tags makes no sense to XML.
All XML documents must have a root element. In other words, all XML documents must contain a single tag pair to define a root element.
Attribute values must always be quoted. With XML, it is illegal to omit quotation marks around attribute values.
XML parsers preserve all whitespace in XML documents, even that which is considered non-significant.
The use of the ampersand [ & ] symbol is reserved. XML uses this to define an entity reference.
As mentioned in the last section, the ampersand symbol cannot be used by itself. There are a set of standard entity references that every DTD file should contain. There are mostly symbols that you would want to place inside the XML file. You define them by using thier decimal value on the ASCII chart. Here is a good list :
Less-Than [ < ] : "<"
Greater-Than [ > ] : ">"
Ampersand [ & ] : "&"
Apostrophe [ ' ] : "'"
Quote [ " ] : """
Non Breaking Space (a forced space) : " "
Emdash [ -- ] : "--"
XML is designed to hold any kind of information. This information is stored in Elements. Elements are the basic building blocks of XML and are represented in a XML document as tag pairs. Attributes provide a mechanism to further define or classify an element. Elements have relationships with other elements in a document. Some are parents and some are children. Using this semantic description, one can see that children elements need parent elements defined and used first. As mentioned in the last section, an XML document must have a root element. Think of this as the ultimate parent element. The root element must be defined and used before all other elements and all sub-elements (children). All elements and sub-elements will reside inside of the root element. An element can have parsed content, mixed content, simple content, empty content or attributes in their definition.
XML elements must follow these naming rules :
Names can contain letters, numbers, and other characters
Names must not start with a number or punctuation character
Names must not start with the letters xml (or XML or Xml ...)
Names cannot contain spaces
Once an XML document is written, it is generally a good idea to validate the elements used in the document against a known DTD. The Document Type Definition is the mechanism with which one validates the content of a well-formed XML document.
XML DTD files contain :
Element declarations and definitions : Elements are declared and defined with their relationships in the DTD file.
Attribute declarations and definitions : Element classes or attributes are declared and defined in the DTD file.
Entities : Entities are the same thing as variables inside a DTD file or XML document. They can hold any kind of data.
PCDATA : PCDATA is Parsed Character DATA. PCDATA is text that will be parsed by a parser. Tags inside the text will be treated as markup and entities will be expanded.
CDATA : CDATA is Character DATA. CDATA is text that will NOT be parsed by a parser. Tags inside the text will NOT be treated as markup and entities will not be expanded.
Elements are declared in the DTD file using a simple, but strict syntax. There are four ways to define an element :
EMPTY : When an element is declared with the EMPTY keyword, it means that the element will not hold any information. This is generally used for special tags like <br>.
ANY : When an element is declared with the ANY keyword, it means that the element can contain any information that the author wants it to. This is generally a special case.
Character Data : When an element is declared with either the PCDATA or CDATA keywords, it will hold one of the two types of information described above.
With Children : When an element is declared with the names of other elements in it, this defines a parent-child relationship. Look in the DTD for the child element names to be further defined with the other three ways.
Mixed : Some combination of the above four. Generally this is character data mixed with children.
When an element is declared with children, it will also define how the children can be used inside an XML document and also in the order that they are allowed to appear in an XML document. There are four ways that children elements can be defined in a DTD file :
One Occurance Only : Example : Element: <search_replace>. The child elements of <search_replace> -- <file>, <find>, and <replace> can only be used once. Notice that there are no symbols after any of the child element names. This is the identifier.
Minimum of One Occurance : Example : Element: <permissions>. One of the child elements of <permissions> -- <name>, must be used a minimum of once, but can also be used many times. Notice the plus [ + ] symbol after the name. This is the identifier.
Zero or More Occurances : Example : Element: <download>. One of the child elements of <download> -- <url>, can be used zero or many times. Notice the asterisk [ * ] symbol after the name. This is the identifier.
Zero or One Occurance : Example : Element: <download>. One of the child elements of <download> -- <digest>, can be used zero or one time only. Notice the question mark [ ? ] symbol after the name. This is the identifier.
Either / Or Occurances : Example : Element: <execute>. One of the two child elements of <execute> -- <param>, or <prefix>, can only be used. Notice the pipe [ | ] symbol in between the two elements. This is the identifier.
As mentioned above, attributes can help to define "classes" of Elements. Attributes are defined with types and values. There are 11 types :
CDATA : The value is Character Data.
(en1|en2|...) : The value is an enumerated list.
ID : The value is a unique id.
IDREF : The value is the id of another element.
IDREFS : The value is a list of other ids,
NMTOKEN : The value is a valid XML name.
NMTOKENS : The value is a list of valid XML names.
ENTITY : The value is an entity.
ENTITIES : The value is a list of entities.
NOTATION : The value is a name of a notation.
xml : The value is a predefined XML value.
There are four value options :
Value : The default value of the attribute surrounded by quotes [ " " ]. Example : Element : <alfs>.
#IMPLIED : The attribute is optional. Example : Element : <alfs>.
#REQUIRED : The attribute is required when the element is used. Example : Element: <execute>.
#FIXED : A fixed value. Used with the Value option. Example : Element : <alfs>.
The DOCTYPE declaration is used in an XML document to define to the XML parser what DTD should be referenced. This declaration is helpful when you have a seperate DTD file outside of the XML document. See Element : <alfs> for an example.
The SYSTEM declaration is used in an XML document to give provide a way to split up a file into smaller chunks. Many XML files can be quite large and having all the information inside one file can be unwieldy. The SYSTEM declaration works just like any ENTITY declaration. See Element : <alfs> for an example.
<!ELEMENT alfs ((configure | copy | download | execute | link | make | mkdir | move | ownership | package | patch | permissions | remove | search_replace | stage | textdump | unpack | include)+)> <!ATTLIST alfs base CDATA #IMPLIED version CDATA #FIXED "3.1" xml:base CDATA #IMPLIED xmlns:xi CDATA #IMPLIED>
See also : Element : <configure> | Element : <copy> | Element: <download> | Element: <execute> | Element: <link> | Element: <make> | Element: <mkdir> | Element: <move> | Element: <ownership> | Element: <package> | Element: <patch> | Element: <permissions> | Element: <remove> | Element: <search_replace> | Element: <stage> | Element: <textdump> | Element: <unpack> | Element: <include>
The element alfs is the root element of an ALFS Profile document. This means that an ALFS profile should contain one and only one alfs element with all the other elements being embedded within this element.
When processing an alfs element, one processes all its embedded children in their order of occurrence.
The attribute base is used to specify the base directory which will be used by all the commands in the element alfs. See Element : <base>.
The attribute version identifies the version of the ALFS profile syntax used; it should be "3.1".
The element include and the attributes xml:base and xmlns:xi allow you to use xi:include directives in your profiles.
Refer to Element: <unpack> for an example.
<!ELEMENT base (#PCDATA)>
This element occurs in : Element: <stageinfo>
This element occurs as an attribute in the elements : Element : <alfs> | Element : <configure> | Element : <copy> | Element: <execute> | Element: <link> | Element: <make> | Element: <mkdir> | Element: <move> | Element: <ownership> | Element: <patch> | Element: <permissions> | Element: <search_replace> | Element: <textdump>
The element base is used to specify the base directory which will be used by all the commands in the stage (inherited), unless another base is specified at the level of the command as an attribute.
<stage name="Install gzip"> <stageinfo> <root>/mnt/lfs</root> <user>lfs</user> <environment> <variable name="PATH">/bin:/sbin</variable> </environment> <base>/usr/src/gzip.1.2.4a</base> </stageinfo> <configure> </configure> <make> </make> <make> <param>install</param> </make> </stage>
The equivalent bash script is :
echo Executing configure su - lfs export PATH=/bin:/sbin cd /usr/src/gzip.1.2.4a ./configure echo Executing make su - lfs export PATH=/bin:/sbin cd /usr/src/gzip.1.2.4a make echo Executing make su - lfs export PATH=/bin:/sbin cd /usr/src/gzip.1.2.4a make install echo Exiting stage
<!ELEMENT configure ((param | prefix)*)> <!ATTLIST configure base CDATA #IMPLIED command CDATA #IMPLIED>
This element occurs in : Element : <alfs> | Element: <stage>
See also : Element: <param> | Element: <prefix>
The element configure is one of the top-level operation elements. The element configure is used to describe the command configure.
When processing the element, one executes the command ./configure with the parameter(s) and prefix(es) specified.
The attribute base allows you to specify the directory in which the command is executed. See Element : <base>.
The attribute command allows you to specify a custom command if you don't want to use the default ./configure. This is extremely useful when running ./configure in a build directory outside the main source directory. The packages gcc and glibc often require this.
This first example calls configure without any parameters :
<configure base="/usr/src/mypackage/"> </configure>
The equivalent bash script is :
echo Executing configure cd /usr/src/mypackage/ ./configure
This second example calls configure with a parameter :
<configure base="/usr/src/mypackage/"> <prefix>CFLAGS="..."<prefix> <prefix>CXXFLAGS="..."<prefix> <param>--prefix=/opt/mypackage</param> </configure>
The equivalent bash script is :
echo Executing configure cd /usr/src/mypackage/ ./configure --prefix=/opt/mypackage
This third example calls configure with a parameter and uses prefix :
<configure base="/usr/src/mypackage/"> <prefix>PATH=/usr/local/bin</prefix> <param>--prefix=/opt/mypackage</param> </configure>
The equivalent bash script is :
echo Executing configure cd /usr/src/mypackage/ PATH=/usr/local/bin ./configure --prefix=/opt/mypackage
This fourth example calls configure with a parameter and an explicit command (same result as example #3) :
<configure base="/usr/src/mypackage/" command="PATH=/usr/local/bin ./configure"> <param>--prefix=/opt/mypackage</param> </configure>
The equivalent bash script is :
echo Executing configure cd /usr/src/mypackage/ PATH=/usr/local/bin ./configure --prefix=/opt/mypackage
The element content is used to specify the content of the file being created when processing a textdump operation.
Of course, it is possible to use XML entity references in the #PCDATA or string of this element.
<textdump base="/etc"> <file>group</file> <content> =root:x:0: =bin:x:1: =sys:x:2: =kmem:x:3: =tty:x:4: =tape:x:5: =daemon:x:6: =floppy:x:7: =disk:x:8: =lp:x:9: =dialout:x:10: =audio:x:11: </content> </textdump>
The equivalent bash script is :
echo Generating file group cd /etc cat > group << 'EOF' root:x:0: bin:x:1: sys:x:2: kmem:x:3: tty:x:4: tape:x:5: daemon:x:6: floppy:x:7: disk:x:8: lp:x:9: dialout:x:10: audio:x:11: EOF
<!ELEMENT copy (option*, source+, destination)> <!ATTLIST copy base CDATA #IMPLIED>
This element occurs in : Element : <alfs> | Element: <stage>
See also : Element: <option> | Element: <source> | Element: <destination>
The element copy is one of the top-level operation elements. It is used to copy a file and/or directory into a destination file or directory.
The sub-element option provides a means to pass an option to the cp command.
Not all of the cp options are in every implementation. Refer to the documentation for your implementation to determine what options are available.
The element source is required and can be used many times to provide multiple source locations for a file.
The element destination is required and can only be used once. A copy can only have one destination.
The attribute base allows you to specify the directory in which the command is executed. See Element : <base>.
<copy base="/usr/src/mypackage"> <option>force</option> <source>config.txt</source> <destination>/opt/mypackage/config.txt</destination> </copy>
The equivalent bash script is :
echo Copying 'config.txt into /opt/mypackage/config.txt' cd /usr/src/mypackage cp -f config.txt /opt/mypackage/config.txt
<!ELEMENT description (para | list)*>
This element occurs in : Element: <packageinfo>
See also : Element: <para> | Element: <list>
The element description contains the description of a package. Its use is for documentation only.
Refer to Element: <packageinfo> for an example.
There is no equivalent Bash script example for this element.
<!ELEMENT destination (#PCDATA)>
This element occurs in : Element : <copy> | Element: <download> | Element: <move> | Element: <unpack> |
The element destination is used to specify the name of the destination file or directory when processing an element in which it occurs
The first example is an unpack command.
<unpack> <archive>/usr/src/lfs-packages/gzip.1.2.4a.tar.gz</archive> <destination>/usr/src</destination> </unpack>
The equivalent bash script is :
echo Unpacking /usr/src/lfs-packages/gzip.1.2.4a.tar.gz into /usr/src cd /usr/src tar -xzvf /usr/src/lfs-packages/gzip.1.2.4a.tar.gz
The second example is a copy command.
<copy base="/usr/src/mypackage"> <option>force</option> <source>config.txt</source> <destination>/opt/mypackage/config.txt</destination> </copy>
The equivalent bash script is :
echo Copying 'config.txt into /opt/mypackage/config.txt' cd /usr/src/mypackage cp -f config.txt /opt/mypackage/config.txt
<!ELEMENT digest (#PCDATA)> <!ATTLIST digest type CDATA "md5">
This element occurs in ; Element: <download> | Element: <unpack>
The element digest is used to specify the MD5 digest hash of the archive file to be unpacked, or of the file to be downloaded.
The attribute type is preset as an MD5 hash.
Refer to Element: <reference> for an example.
There is no equivalent Bash script example for this element.
<!ELEMENT download (file, url*, destination, digest?)>
This element occurs in : Element : <alfs> | Element: <stage>
See also : Element: <file> | Element: <url> | Element: <destination> | Element: <digest>
The element download is one of the top-level operation elements. It is used to specify one or several URLs from which a file can be downloaded, and optionally a digest to check that the file being downloaded is the right one.
The sub-element file contains the name of the file to be downloaded.
The sub-element url contains the url of the directory from which the download is performed. It should be terminated by a slash [ / ]. More precisely, the actual URL used for the download is the catenation of the content of the url element with the content of the file element.
The sub-element destination contains the path of the directory into which the download should be performed.
The sub-element digest contains the value with which the digest computed from the dowloaded file will be compared. See Element: <digest>.
If the file is already present in the destination directory, no download is performed but the digest is checked if present.
<!ELEMENT environment (variable+)> <!ATTLIST environment mode (append | prepend) #IMPLIED>
This element occurs in : Element: <stageinfo>
See also : Element: <variable>
The element environment allows you to define one or more environment variables to be added to the system environment used when calling the commands of the stage to which it applies.
By default, the supplied value replaces any existing value for the specified variable. The attribute mode allows you to specify whether the supplied value should be prepended or appended to the existing value.
<stage> <stageinfo> <base>/usr/src/gzip.1.2.4a</base> <environment> <variable name="GCCFLAGS">-O2</variable> <variable name="PATH" mode="prepend">/usr/src/gzip.1.2.4a:</variable> <variable name="LDFLAGS" mode="append"> -s</variable> </environment> </stageinfo> </stage>
The equivalent bash script is :
echo Stage export GCCFLAGS=-O2 export PATH=/usr/src/gzip.1.2.4a:$PATH export LDFLAGS="$LDFLAGS -s" echo Exiting stage
<!ELEMENT execute ((param | prefix)*)> <!ATTLIST execute base CDATA #IMPLIED command CDATA #REQUIRED>
This element occurs in : Element : <alfs> | Element: <stage>
See also : Element: <param> | Element: <prefix>
The element execute is one of the top-level operation elements. It is used to execute any arbitrary system command.
The sub-element param contains parameters for the command.
The sub-element prefix contains any prefix data for the command to execute.
The attribute base allows you to specify the directory in which the command will be executed. See Element : <base>.
The attribute command contains the text of the command itself.
The first example is an execute command without a parameter.
<execute command="umount">
The equivalent bash script is :
echo Executing 'umount' umount
<!ELEMENT file (#PCDATA)>
This element occurs in : Element: <download> | Element: <search_replace> | Element: <textdump>.
The element file is used to specify the filename for a download, search_replace or textdump operation.
The element find allows you to specify the string to be searched for in a search and replace operation.
Refer to the parent Element: <search_replace> for an example.
<!ELEMENT include EMPTY> <!ATTLIST include href CDATA #REQUIRED>
This element occurs in : Element : <alfs>
The element include contains data necessary to handle the xi:include directive in an alfs element.
Refer to Element : <alfs> for an example.
Refer to Element : <description> for an example.
<!ELEMENT link (option?, target+, name)> <!ATTLIST link base CDATA #IMPLIED type CDATA #IMPLIED>
This element occurs in : Element : <alfs> | Element: <stage>
See also : Element: <option> | Element: <target> | Element: <name>
The element link is one of the top-level operation elements. It allows you to create a hard or symbolic link.
The sub-element target gives the name(s) of the target.
The sub-element option provides a means to pass an option to the ln command.
Not all of the ln options are in every implementation. Refer to the documentation for your implementation to determine what options are available.
The sub-element name gives the name of the link. When there are several targets, this must be the name of a directory, in which the links to the targets will be created.
The attribute base specifies the directory in which the link creation is performed. See Element : <base>.
The attribute type generally can have one of two values: symbolic or hard to go along with how the ln works.
<!ELEMENT list (item | list)+> <!ATTLIST list type (bullet | number) "bullet">
This element occurs in : Element : <description>
See also : Element: <item>
The element list contains a list of items or sub-lists in a description.
The attribute type provides a way to define a numbered or bulleted list
Refer to the parent Element : <description> for an example.
<!ELEMENT make ((param | prefix)*)> <!ATTLIST make base CDATA #IMPLIED>
This element occurs in : Element : <alfs> | Element: <stage>
See also : Element: <param> | Element: <prefix>
The element make is one of the top-level operation elements. It describes the make command.
The sub-element param allows you to specify parameters of the make command.
The sub-element prefix allows you to specify an environment variable or some other prefix to the make command
The attribute base allows you to specify the directory in which the make will be performed. See Element : <base>.
The first example is a make without parameter
<make />
The equivalent bash script is :
echo Executing make make
<!ELEMENT mkdir (option?, name+, permissions?)> <!ATTLIST mkdir base CDATA #IMPLIED>
This element occurs in : Element : <alfs> | Element: <stage>
See also : Element: <option> | Element: <name> | Element: <permissions>
The element mkdir is one of the top-level operation elements. It describes the creation of one (or several) directory(ies).
The sub-element option provides a means to pass an option to the mkdir command.
Not all of the mkdir options are in every implementation. Refer to the documentation for your implementation to determine what options are available.
The sub-element name contains the name(s) of the directory(ies) to be created.
The sub-element permissions assigns permissions to the directories created by the command following the syntax in Element: <permissions>.
The attribute base gives the name of the directory in which the new directory will be created. See Element : <base>.
<!ELEMENT move (option?, source+, destination)> <!ATTLIST move base CDATA #IMPLIED>
This element occurs in : Element : <alfs> | Element: <stage> |
See also : Element: <option> | Element: <source> | Element: <destination>
The element move is one of the top-level operation elements. It is used to move one or several source files and/or directories into a destination file or directory.
The sub-element option provides a means to pass an option to the mv command.
Not all of the mv options are in every implementation. Refer to the documentation for your implementation to determine what options are available.
When processing this element, one moves each source to the destination, using the specified option if present.
The sub-element source contains the name of the source file and its directory.
The sub-element destination contains the name of the destination directory (and, optionally, the filename) for the mv command.
The attribute base gives the name of the directory in which the new directory will be created. See Element : <base>.
<!ELEMENT name (#PCDATA)>
This element occurs in : Element: <link> | Element: <mkdir> | Element: <ownership> | Element: <permissions> | Element: <requires> | Element: <utilizes>
See also (used as an attribute) : Element: <package> | Element: <stage> | Element: <variable>
<!ELEMENT option (#PCDATA)>
This element occurs in : Element : <copy> | Element: <link> | Element: <mkdir> | Element: <move> | Element: <ownership> | Element: <permissions>
<!ELEMENT ownership (option?, name+)> <!ATTLIST ownership base CDATA #IMPLIED user CDATA #IMPLIED group CDATA #IMPLIED>
This element occurs in : Element : <alfs> | Element: <stage>
See also : Element: <option> | Element: <name>
The element ownership is one of the top-level operation elements. It is used to perform a group and/or user ownership change on a file or set of files
The sub-element option provides a means to pass an option to the chown command.
Not all of the chown options are in every implementation. Refer to the documentation for your implementation to determine what options are available.
The sub-element name contains the name of the file (or directory) whose ownership is to be changed.
The attribute base specifies the directory in which the command is performed. See Element : <base>.
The attribute user specifies the name of the user which will own the file or directory. See Element: <user>.
The attribute group specifies the name of the group which will own the file or directory.
The first example uses symbolic names.
<ownership user="root" group="root"> <option>recursive</option> <name>/etc/rc.d</name> <name>/etc/sysconfig</name> </ownership>
The equivalent bash script is :
echo Changing group of /etc/rc.d into root chgrp -R root /etc/rc.d echo Changing owner of /etc/rc.d into root chown -R root /etc/rc.d echo Changing group of /etc/sysconfig into root chgrp -R root /etc/sysconfig echo Changing owner of /etc/sysconfig into root chown -R root /etc/sysconfig
The second example uses numeric values (0 = root).
<ownership user="0" group="0"> <option>recursive</option> <name>/etc/rc.d</name> <name>/etc/sysconfig</name> </ownership>
The equivalent bash script is :
echo Changing group of /etc/rc.d into 0 chgrp -R 0 /etc/rc.d echo Changing owner of /etc/rc.d into 0 chown -R 0 /etc/rc.d echo Changing group of /etc/sysconfig into 0 chgrp -R 0 /etc/sysconfig echo Changing owner of /etc/sysconfig into 0 chown -R 0 /etc/sysconfig
<!ELEMENT package (packageinfo?, stage+)> <!ATTLIST package name CDATA #REQUIRED version CDATA #REQUIRED>
This element occurs in : Element : <alfs> | Element: <stage>
See also : Element: <packageinfo> | Element: <stage>
The element package is one of the top-level operation elements. It describes the build process of a package. The actual build process is described by the stage sub-elements.
The attribute name contains the name of the package. See Element: <name>.
The attribute version contains the version of the package. See Element: <version>.
<package name="zlib" version="1.1.4"> <stage name="Unpacking a package."> <unpack> <archive>/usr/src/lfs-packages/zlib.1.1.4.tar.gz</archive> <destination>/usr/src</destination> </unpack> </stage> ..... </package>
The equivalent bash script is :
echo Generating package zlib 1.1.4 #----------------------------------------- echo Stage "Unpacking a package." echo Unpacking /usr/src/lfs-packages/zlib.1.1.4.tar.gz into /usr/src cd /usr/src [[ $? != 0 ]] && echo Command failed && exit 3 tar xzvf /usr/src/lfs-packages/zlib.1.1.4.tar.gz [[ $? != 0 ]] && echo Command failed && exit 3 echo Exiting stage "Unpacking a package." ..... echo End of generating package zlib 1.1.4
<!ELEMENT packageinfo (description?, requires*, utilizes*)>
This element occurs in : Element: <package>
See also : Element : <description> | Element: <requires> | Element: <utilizes>
The element packageinfo groups elements containing information about the package, namely a description and some dependency relationship(s).
The description sub-element provides for a description of the packge.
The requires sub-element provides for a relationship (dependancy) to other defined packages in the profile.
The utilizes sub-element provdes for a relationship (uses / optional) to other defined packages in the profile.
<package name="gimp" version="1.2.3"> <packageinfo> <description> <para>The gimp package contains the GNU Image Manipulation Program. This is useful for :</para> <list> <item>photo retouching,</item> <item>image composition,</item> <item>image authoring.</item> </list> </description> <requires><name>gtk+</name></requires> <utilizes><name>libtiff</name></utilizes> <utilizes><name>libpng</name></utilizes> <utilizes><name>libjpeg</name></utilizes> <utilizes><name>aalib</name></utilizes> <utilizes><name>mpeg_lib</name></utilizes> <utilizes><name>python</name></utilizes> </packageinfo> .... </package>
There is no equivalent bash script for the element.
Refer to Element: <packageinfo> for an example.
<!ELEMENT param (#PCDATA)>
This element occurs in : Element : <configure> | Element: <execute> | Element: <make> | Element: <patch>
<!ELEMENT patch ((param | prefix)*)> <!ATTLIST patch base CDATA #IMPLIED>
This element occurs : Element : <alfs> | Element: <stage>
See also : Element: <param> | Element: <prefix>
The element patch is one of the top-level operation elements. It is used to execute the patch command.
The sub-element param contain the parameters of the command.
The sub-element prefix provides a means to specify an environment variable or some other prefix to the patch command.
The attribute base specified the directory in which the command will be performed.
<!ELEMENT permissions (option?, name+)> <!ATTLIST permissions base CDATA #IMPLIED mode CDATA #REQUIRED>
See also : Element: <option> | Element: <name>
The element permissions is one of the top-level operation elements. It allows you to change the permissions of a (set of) file(s) or directory(ies).
The sub-element option provides a means to pass an option to the chmod command.
Not all of the chmod options are in every implementation. Refer to the documentation for your implementation to determine what options are available.
The sub-element(s) name contain the name(s) of the files whose permission is to be modified. See Element: <name>.
The attribute base gives the name of the directory in which the command will be performed. See Element : <base>.
The attribute mode gives the new access mode, as used in the command chmod.
The only option supported is "recursive"
<!ELEMENT prefix (#PCDATA)>
This element occurs in : Element : <configure> | Element: <execute> | Element: <make> | Element: <patch>
The element prefix provides a means to specify an environment variable or some other prefix to the parent element.
The element reference is used to specify the URL of the reference archive to download if the local copy is not available.
<unpack> <reference>ftp://ftp.gnu.org/gnu/gzip/gzip.1.2.4a.tar.gz</reference> <archive>/usr/src/lfs-packages/gzip.1.2.4a</archive> <destination>/usr/src</destination> </unpack>
The equivalent bash script is :
echo Unpacking /usr/src/lfs-packages/gzip.1.2.4a.tar.gz into /usr/src [[ ! -f /usr/src/lfs-packages/gzip.1.2.4a.tar.gz ]] && echo Retrieving ftp://ftp.gnu.org/gnu/gzip/gzip.1.2.4a.tar.gz [[ ! -f /usr/src/lfs-packages/gzip.1.2.4a.tar.gz ]] && wget -O /usr/src/lfs-packages/gzip.1.2.4a.tar.gz ftp://ftp.gnu.org/gnu/gzip/gzip.1.2.4a.tar.gz [[ ! -f /usr/src/lfs-packages/gzip.1.2.4a.tar.gz ]] && echo Archive does not exist && exit 3 cd /usr/src tar xzvf /usr/src/lfs-packages/gzip.1.2.4a.tar.gz
The element remove is one of the top-level operation elements. It allows you to remove a file or directory. The content of the element contains the name of the file.
Not all of the rm options are in every implementation. Refer to the documentation for your implementation to determine what options are available.
The element replace allows you to specify the replacement string in a search and replace operation.
Refer to Element: <search_replace> for an example.
<!ELEMENT requires (name, version*)>
This element occurs in : Element: <packageinfo>
See also : Element: <name> | Element: <version>
The element requires denotes a dependency between two packages. The package containing the requires element depends on the package whose name is contained in the name sub-element.
The actual name is put into a name element because we might want to add a version in a future version.
Refer to Element: <packageinfo> for an example.
The element root allow you to specify the name of a directory which will be the root directory for the commands of the stage.
<stage> <stageinfo> <root>/mnt/lfs</root> <base>/usr/src/gzip.1.2.4a</base> </stageinfo> <configure /> <make /> <make> <param>install</param> </make> </stage>
The equivalent bash script is :
echo Creating file /mnt/lfs/_nalfs_tmp.1... cat > /mnt/lfs/_nalfs_tmp.1 << 'EOF1' echo Executing configure cd /usr/src/gzip.1.2.4a ./configure echo Executing make cd /usr/src/gzip.1.2.4a make echo Executing make cd /usr/src/gzip.1.2.4a make install true EOF1 chmod 775 /mnt/lfs/_nalfs_tmp.1 echo Executing in directory /mnt/lfs /usr/sbin/chroot /mnt/lfs /static/bin/env -i \ PATH='/bin:/usr/bin:/sbin:/usr/sbin:/static/bin' \ HOME='/root' /static/bin/bash -c ./_nalfs_tmp.1 echo Exiting stage
<!ELEMENT search_replace (file, find, replace)> <!ATTLIST configure base CDATA #IMPLIED>
This element occurs in : Element : <alfs> | Element: <stage>
See also : Element: <file> | Element: <find> | Element: <replace>
The element search_replace is one of the top-level operation elements. It is used to perform a search and replace operation of a file.
The sub-element file contains the filename
The sub-element find contains the string to be searched
The sub-element replace contains the replacement string.
The attribute base specifies the directory in which the file replacement occurs. See Element : <base>.
<search_replace base="/usr/src/mypackage"> <file>runit.sh</file> <find>BINDIR</find> <replace>/bin</replace> </search_replace>
The equivalent bash script is :
echo Performing substitution in runit.sh cd /usr/src/mypackage cp runit.sh /tmp/foo.$$ sed -e 's/BINDIR/\/bin/' /tmp/foo.$$ > runit.sh
<!ELEMENT stage (stageinfo?, (alfs | configure | copy | download | execute | link | make | mkdir | move | ownership | package | patch | permissions | remove | search_replace | stage | textdump | unpack)*)> <!ATTLIST stage name CDATA #IMPLIED>
This element occurs in : Element : <alfs> | Element: <stage>
See also : Element : <alfs> | Element : <configure> | Element : <copy> | Element: <download> | Element: <execute> | Element: <link> | Element: <make>> | Element: <mkdir> | Element: <move> | Element: <ownership> | Element: <package> | Element: <patch> | Element: <permissions> | Element: <remove> | Element: <search_replace> | Element: <stageinfo> | Element: <textdump> | Element: <unpack>
The element stage is one of the top-level operation elements. It allows you to regroup commands, give a name to this group (through the attribute name) and optionally modify the execution context through the element stageinfo.
<stage> <stageinfo> <base>/usr/src/gzip.1.2.4a</base> </stageinfo> <configure /> <make /> <make> <param>install</param> </make> </stage>
The equivalent bash script is :
echo Executing configure cd /usr/src/gzip.1.2.4a ./configure echo Executing make cd /usr/src/gzip.1.2.4a make echo Executing make cd /usr/src/gzip.1.2.4a make install echo Exiting stage
<!ELEMENT stageinfo (root?, user?, environment?, base?)>
This element occurs in : Element: <stage>
See also : Element: <root> | Element : <base> | Element: <environment> | Element: <user>
The element stageinfo allows you to specify several contexts of information used to process the commands of the stage to which the stageinfo belongs.
The base sub-element specifies a base directory that will be used by all the commands of the stage, unless the command redefines the base locally. See Element : <base>.
The user sub-element specifies a user name that will be used as the effective user ID of the current process for all the commands of the stage. See Element: <user>.
The root sub-element specifies a directory name in which the commands of the stage will be performed (using a chroot command). See Element: <root>.
The environment sub-element allow you to specify an environment variable that will be added to the current environment when processing the commands of the stage. See Element: <environment>.
<stage name="Install gzip"> <stageinfo> <root>/mnt/lfs</root> <user>lfs</user> <environment>PATH=/bin:/sbin</environment> <base>/usr/src/gzip.1.2.4a</base> </stageinfo> <configure> </configure> <make> </make> <make> <param>install</param> </make> </stage>
The equivalent bash script is :
echo Executing configure su - lfs export PATH=/bin:/sbin cd /usr/src/gzip.1.2.4a ./configure echo Executing make su - lfs export PATH=/bin:/sbin cd /usr/src/gzip.1.2.4a make echo Executing make su - lfs export PATH=/bin:/sbin cd /usr/src/gzip.1.2.4a make install echo Exiting stage
Refer to Element: <link> for an example.
<!ELEMENT textdump (file, content)> <!ATTLIST textdump base CDATA #IMPLIED mode CDATA #IMPLIED>
This element occurs in : Element : <alfs> | Element: <stage>
See also : Element: <file> | Element : <content>
The element textdump is one of the top-level operation elements. It allows you to create a text file containing specified text.
The sub-element file contains the name of the file to be created.
The sub-element content is used to specify the content of the file being created when processing a textdump operation. When processing the textual content of this element, one removes the leading blanks up to and including a '=' character.
The attribute base allows you to specify the directory in which the file creation will be perforemd. See Element : <base>.
The attribute mode allows you to specify the append creation mode.
<textdump base="/etc"> <file>group</file> <content> =root:x:0: =bin:x:1: =sys:x:2: =kmem:x:3: =tty:x:4: =tape:x:5: =daemon:x:6: =floppy:x:7: =disk:x:8: =lp:x:9: =dialout:x:10: =audio:x:11: </content> </textdump>
The equivalent bash script is :
cd /etc cat > group << 'EOF' root:x:0: bin:x:1: sys:x:2: kmem:x:3: tty:x:4: tape:x:5: daemon:x:6: floppy:x:7: disk:x:8: lp:x:9: dialout:x:10: audio:x:11: EOF
<textdump mode="append"> <file>/etc/sysconfig/network</file> <content> =GATEWAY=192.168.123.254 =GATEWAY_IF=eth0 </content> </textdump>
The equivalent bash script is :
echo Generating file /etc/sysconfig/network cat >> /etc/sysconfig/network << 'EOF' GATEWAY=192.168.123.254 GATEWAY_IF=eth0 EOF
<!ELEMENT unpack (digest?, reference*, archive, destination)>
This element occurs in : Element : <alfs> | Element: <stage>
See also : Element : <archive> | Element: <destination> | Element: <digest> | Element: <reference>
The element unpack is one of the top-level operation elements. It is used to unpack an archive into a destination directory
The sub-element reference gives the URL of the archive; it is only used if the archive file is not available locally.
The sub-element digest gives the digest of the archive, as computed by openssl, using the digest type specified in the attribute type.
The sub-element archive gives the name of the archive, and the sub-element destination gives the name of the directory in which the archive is unpacked.
<unpack> <digest>cbe9f79450aeecfb06d5e856af16c2cf</digest> <reference>ftp://ftp.gnu.org/gnu/gzip/gzip.1.2.4a.tar.gz</reference> <archive>/usr/src/lfs-packages/gzip.1.2.4a.tar.gz</archive> <destination>/usr/src</destination> </unpack>
The equivalent bash script is :
echo Unpacking /usr/src/lfs-packages/gzip.1.2.4a.tar.gz into /usr/src [[ ! -f /usr/src/lfs-packages/gzip.1.2.4a.tar.gz ]] && echo Retrieving ftp://ftp.gnu.org/gnu/gzip/gzip.1.2.4a.tar.gz [[ ! -f /usr/src/lfs-packages/gzip.1.2.4a.tar.gz ]] && wget -O /usr/src/lfs-packages/gzip.1.2.4a.tar.gz ftp://ftp.gnu.org/gnu/gzip/gzip.1.2.4a.tar.gz [[ ! -f /usr/src/lfs-packages/gzip.1.2.4a.tar.gz ]] && echo Archive does not exist && exit 3 cd /usr/src tar xzvf /usr/src/lfs-packages/gzip.1.2.4a.tar.gz
The element url allows you to specify the Uniform Resource Locator (URL) of the directory containing the file to be downloaded when processing a download element.
Refer to Element: <download> for an example.
There is no equivalent Bash script example for this element.
<!ELEMENT user (#PCDATA)>
This element occurs in : Element: <stageinfo>
See also : Element: <ownership>
The element user allows you to specify a user ID that will be the effective user ID when executing the commands of the stage to which it applies.
Refer to Element: <stageinfo> for an example.
<!ELEMENT utilizes (name, version*)>
This element occurs in : Element: <packageinfo>
See also : Element: <name> | Element: <version>
The element utilizes indicates that the package containing the utilizes element utilizes the package whose name is contained in the name sub-element, but does not depend on it (in which case the element requires should be used).
The actual name is put into a name element because we might want to add a version in a future version.
To work properly, then element name must be defined in the same profile.
<package name="gimp" version="1.2.3"> <packageinfo> <requires><name>gtk+</name></requires> <utilizes><name>libtiff</name></utilizes> <utilizes><name>libpng</name></utilizes> <utilizes><name>libjpeg</name></utilizes> <utilizes><name>aalib</name></utilizes> <utilizes><name>mpeg_lib</name></utilizes> <utilizes><name>python</name></utilizes> </packageinfo> ..... </package>
There is no equivalent Bash script example for this element.
<!ELEMENT variable (#PCDATA)> <!ATTLIST variable name CDATA #REQUIRED mode CDATA #IMPLIED>
This element occurs in : Element: <environment>
The element variable allows you to add a variable definition to the system environment.
The name of the variable is given by the attribute name of the element.
The value of the variable is given by the textual content of the element.
The attribute mode can take the value "append", in which case the content of the element is appended to the value of the environment variable
<stage> <stageinfo> <base>/usr/src/gzip.1.2.4a</base> <environment> <variable name="GCCFLAGS">-O2</variable> <variable name="PATH" mode="append">:/opt/foo</variable> </environment> </stageinfo> <configure /> <make /> <make> <param>install</param> </make> </stage>
The equivalent bash script is :
echo Stage export GCCFLAGS=-O2 export PATH=${PATH}:/opt/foo echo Executing configure cd /usr/src/gzip.1.2.4a ./configure echo Executing make cd /usr/src/gzip.1.2.4a make echo Executing make cd /usr/src/gzip.1.2.4a make install echo Exiting stage
<!ELEMENT version (#PCDATA)> <!ATTLIST version condition (eq | ne | gt | ge | lt | le) #REQUIRED>
This element occurs : Element: <package> | Element: <requires> | Element: <utilizes>
The element version describes a constraint on the version of an utilized or required package.
The condition is satisfied if the comparison specified by the attribute condition applies between the actual version value of the package, and the value specified as the content of the element.
When performing the comparison, the sequences of digits are compared numerically, while all the other characters are compared using their codes. Moreover, any substring is greater than the empty string.
That means, for instance, that 2.0.10 is greater than 2.0.9, 2.0a is greater than 2.0 and 2.10 is greater than 2.1a.
Note that the algorithm fails for reasonable interpretations of version numbers like 3.0 and 3.0beta. Intuitively, 3.0 is greater than 3.0beta, but the algorithm returns the opposite. To indicate for instance that the required package must have a version greater than 3.0, one would need two version elements, to require that the actual version be greater than or equal to 3.0, and that it be different from 3.0beta.