The Discover Hardware Detection System
G. Branden Robinson
John R. Daily
Copyright © 2002 Progeny Linux Systems, Inc.
Copyright © 2002 Hewlett-Packard Company
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- Table of Contents
- What Is Discover?
- I. Data Structure
- 1. Overview of the Discover Data Format
- 2. Master List
- 3. Busclass Lists
- 3.1. The
busclass_listelement - 3.1.1. The
busattribute
- 3.1.1. The
- 3.2. The
busclasselement - 3.2.1. The
idattribute - 3.2.2. The
nameattribute
- 3.2.1. The
- 3.1. The
- 4. Vendor Lists
- 4.1. The
vendor_listelement - 4.1.1. The
busattribute
- 4.1.1. The
- 4.2. The
vendorelement - 4.2.1. The
idattribute - 4.2.2. The
nameattribute
- 4.2.1. The
- 4.1. The
- 5. Device Lists
- 5.1. The
device_listelement - 5.1.1. The
busattribute
- 5.1.1. The
- 5.2. The
deviceelement - 5.3. The
dataelement - 5.3.1. The
classattribute - 5.3.2. The
versionattribute
- 5.3.1. The
- 5.4. Accessing the Device Data
- 5.1. The
- II. Recommended Data Content Conventions
- III. Command-Line Tools
- 9. discover Manual Page
- discover -- hardware detection utility
- 10. discover.conf Manual Page
- discover.conf -- configuration file format for discover(1)
- 11. discover-modprobe Manual Page
- discover-modprobe -- kernel module loading using discover(1)
- 12. discover-modprobe.conf Manual Page
- discover-modprobe.conf -- configuration file for discover-modprobe(5)
- IV. Library
- 13. The Discover Library
- 13.1. Library Design Principles
- 13.2. Discover Data Sources
- 13.3. The Bus Map
- 13.4. Scanning the System
- 13.5. Using discover_device_t Structures
- 14. System Dependencies
- 14.1. API
- A. Discover API Reference
- B. Discover DTD
- C. Discover Configuration File DTD
- D. Licensing Issue on the Linux Sysdeps
- List of Figures
- 6-1. Linux interface
- 6-2. XFree86 interface
- List of Examples
- 3-1. The
busclass_listelement - 4-1. The
vendor_listelement - 5-1. Sample device data
- 6-1. Defining an interface
- 6-2. Using the
linuxinterface - 6-3. Using the
xfree86interface - 7-1. Matching
deviceelements - 8-1. Using the
versionattribute of thedataelement - 9-1. Scan the local buses
- 9-2. View PCI video cards
- 9-3. Query for the driver module for XFree86 server version 4.2.0
- 9-4. Get model and vendor information by type
- 10-1. Establishing default buses to scan
- 10-2. A more complex example
- 14-1. Linux PCI sysdep code
What Is Discover?
Discover is a tool that reports information about a system's hardware. It uses operating system-dependent modules (selected at build time) to detect what hardware is actually on the system and provides system-independent interfaces for querying XML data sources about this hardware. These data sources contain specific information required to enable support for various devices via defined software interfaces. The tool can be accessed by linking to the Discover library or by calling discover (which itself links to the Discover library) and parsing its output. In the future, other interfaces (for example, modules for interpreted languages such as Perl and Python) may be included.
Why use Discover? There are at least a few reasons:
Flexibility. Discover is designed from the ground up to be flexible. It is portable to a variety of operating environments, and its modular design supports the addition of arbitrary methods for querying the host operating system (OS) about installed devices. Discover is also designed to be flexible in terms of the types of data that can be retrieved. Discover does not tie the user to retrieving only one type of information, such as the name of the Linux kernel module that should be loaded to support a given device. Instead, Discover supports the association of arbitrary data with hardware devices, typically through specification of an interface to the hardware in question, such as a Linux kernel module or an XFree86 server driver module.
Updatability. Many hardware-autodetection programs suffer from an inherent limitation in that they are restricted to reading hardware lists or databases that are stored on the local filesystem. This is not an efficient approach in the fast-moving world of consumer computer hardware, with new devices constantly being introduced. A couple of months after the latest version of your OS of choice is released, it may fail to recognize that the latest revision of, for instance, a video chipset is compatible with an older one, and can use the same software interfaces. Discover overcomes this problem by supporting the retrieval of hardware information via HTTP[1] ("over the web"). When HTTP access is impossible, Discover falls back to locally stored hardware lists.
Portability. On top of its flexibility in terms of system interfaces to hardware, Discover has been written to be broadly portable to all of today's popular POSIX-compliant systems. Discover is not a Linux-only solution. Discover is intended to provide operating system vendors, computer manufacturers, and third-party vendors of software and peripherals with a powerful tool for describing the hardware they support to the interfaces they care about. Because Discover's data sources can be anywhere on the Internet, the OS vendor need not be the sole provider of hardware catalogs.
Usability. Discover is not an in-house tool designed to solve a narrow class of problems. Discover is designed to be easy to use from the perspectives of the individual system administrator, the applications programmer, and the hardware manufacturer or support staff. Discover's XML database structure, its command-line tools, and its library API are well documented and support extensions to meet diverse demands.
Freely licensed. Discover has a copyright license that is highly adaptable to the needs of the varied audiences to which Discover is targeted. Under the so-called "UCB/BSD" or "MIT/X Consortium" terms, after the names of American universities and some very well known software projects that used these terms, anyone is free to copy, modify, and distribute the software, and to extend (or not) these same freedoms to those who receive the software. Progeny would like to see Discover adopted by a wide variety of existing software products, such the various GNU/Linux distributions; the FreeBSD, NetBSD, and OpenBSD projects; the GNU Project of the Free Software Foundation; the XFree86 Project; system integrators; and the designers and manufacturers of computer hardware. We believe that Discover's design empowers those with the greatest knowledge of hardware and the software interfaces to that hardware to express that knowledge and make it available to the world, thereby ameliorating an entire class of computer configuration problems. Progeny does not want Discover's licensing to stand in the way of realizing that dream, which is why we have chosen these license terms.
We must take a moment to explain what Discover is not: Discover is not a replacement for the service — usually provided by the underlying operating system kernel or a user-space program that interfaces with it — of simply translating bus-specific vendor and model identifiers to human-readable names. Discover performs its own translations of this data as a convenience for generating human-readable reports, but it does not attempt to enumerate all hardware devices that exist for a particular bus architecture. Rather, Discover is intended only to catalog data for which there is some useful information to impart regarding software interfaces. Facilities already exist in modern operating systems for answering the questions "What is the name of this device?" and "Who manufactured it?" Discover's role is to answer questions like "What Linux kernel module do I need to load for this device to work?" More importantly, Discover will enable you to provide answers in the future to questions you don't even expect to ask today.
Discover is not intended to be a comprehensive hardware-management tool. It is an enabling technology, designed to provide data that a tool layered above it can use. Two applications are provided with Discover to demonstrate how the library can be leveraged: the command-line utility discover, and a Linux kernel module loading script, discover-modprobe, designed to be invoked at system boot time.
This manual is divided into four parts. First, we examine the Discover XML data file format, exploring the elements and attributes used to describe hardware and various interfaces to it. This part will enable you to read and understand a Discover XML file. Next, we offer some recommendations for writing your own Discover XML data. Knowing the syntax is valuable, but knowing how best to take advantage of it is even more useful. We then present the reference pages describing Progeny's Discover-based command-line tools and the configuration files used to control their behavior. You may want to use these references as a guide when implementing your own Discover-based applications. The final part describes the Discover library API so that you can develop your own solutions based on Discover. Appendices offer references to the formal descriptions of the Discover API and XML DTDs.
I. Data Structure
- Table of Contents
- 1. Overview of the Discover Data Format
- 2. Master List
- 3. Busclass Lists
- 3.1. The
busclass_listelement - 3.1.1. The
busattribute
- 3.1.1. The
- 3.2. The
busclasselement - 3.2.1. The
idattribute - 3.2.2. The
nameattribute
- 3.2.1. The
- 3.1. The
- 4. Vendor Lists
- 4.1. The
vendor_listelement - 4.1.1. The
busattribute
- 4.1.1. The
- 4.2. The
vendorelement - 4.2.1. The
idattribute - 4.2.2. The
nameattribute
- 4.2.1. The
- 4.1. The
- 5. Device Lists
- 5.1. The
device_listelement - 5.1.1. The
busattribute
- 5.1.1. The
- 5.2. The
deviceelement - 5.3. The
dataelement - 5.3.1. The
classattribute - 5.3.2. The
versionattribute
- 5.3.1. The
- 5.4. Accessing the Device Data
- 5.1. The
Chapter 1. Overview of the Discover Data Format
Most modern computer peripherals contain self-identifying information in a format standardized for the hardware interface (bus). This enables the OS on the host system to query or scan a bus and catalog the devices. In general, the OS stores this information in the same basic format in which it is returned, without translating it more times than necessary for device drivers to communicate with the peripheral. However, this information varies by bus type and is often insufficiently clear for human consumption. Furthermore, many operating systems do not contain a comprehensive database that maps each peripheral to every subsystem running on the OS that may want to communicate with that peripheral. Discover addresses these issues by providing flexible databases stored in XML format.
Extensible Markup Language (XML) is a highly flexible hypertext format. Discover uses XML exclusively to store hardware information externally. Some familiarity with XML syntax is therefore assumed. For more information, see the W3C's XML website.
For a formal description of Discover's XML data format, see the Discover Document Type Definition (DTD) document. The purpose of this document is to present the information in a form digestible by the novice.
Because each hardware bus type, such as PCI or USB, communicates different details about the connected devices (essentially, each one solves the same problem in a different way), Discover has a different set of lists for each bus type. For each bus, up to three lists are stored: a bus class list maps the bus specification's notion of a device type (hereinafter referred to as a "device class" to reduce confusion) to Discover's device types, which are used for running selective queries; a vendor list associates bus-specific vendor identification data with natural-language names for hardware vendors; and a device list contains information specific to individual devices.
Chapter 2. Master List
When Discover is provided with a URL for the retrieval of hardware information, the data retrieved is expected to be in XML format and to contain further URLs for retrieval.
The root element must be discover-data, which has no attributes,
and can only contain location
elements.
The location element is
always empty, and has three required attributes: bus, type, and url.
location
Attributes
typeThis attribute can have one of these values:
busclass,device, orvendor. See Chapter 3, Chapter 4, and Chapter 5.urlThis must be a valid URL containing one of the three types of data lists.
busThis is the bus to which the URL applies. See Section 3.2.2 for a list of valid bus names.
Chapter 3. Busclass Lists
As noted in the previous chapter, a busclass list provides a mapping between device classes recognized by the hardware bus and the device type names used by Discover. Because every bus is different, sometimes there is no perfect, one-to-one correspondence between Discover device types and the device classes recognized by a particular bus. This is one reason that the busclass lists, like other types of Discover data lists, are updatable. Revisions in a bus specification may demand updates to the mapping.
The device classes recognized by a bus are typically determined by the specification for the bus as determined by a standards committee or other technical body, and do not change frequently (if at all).
Example 3-1. The
busclass_list element
<?xml version="1.0"?> <busclass_list bus="usb"> <busclass id="0202" name="modem"/> <busclass id="1030" name="broadband"/> <busclass id="0101" name="printer"/> <busclass id="ffff" name="imaging"/> <busclass id="0206" name="network"/> <busclass id="0300" name="humaninput"/> <busclass id="ff00" name="video"/> <busclass id="0000" name="unknown"/> <busclass id="0804" name="removabledisk"/> </busclass_list> |
In the foregoing example, we can see one possible mapping of the USB bus's numeric device class IDs to Discover's device type names (see Section 3.2.2). The file begins by declaring the version of the XML standard to which it conforms, and then presents data. The format should be fairly familiar to those accustomed to HTML-style structured markup languages.
Not all of Discover's supported device types are listed in the example; for example, display is missing. This is not a problem, since not all buses are used for all hardware applications. USB 1.1 would be a poor choice of bus for VGA-compatible display controllers, for instance, because the available bandwidth on the USB 1.1 bus is insufficient to handle typical data loads for such devices.
Another infelicity in the above example is the association of the ffff device class ID with the Discover device type imaging. In actuality, a device type class of ffff in the USB specification indicates a device of an unknown classification. In practice, most consumer-level devices with this device class are scanners, one of the first applications of USB technology in the consumer marketplace. It is possible that in certain deployments, the association of USB's unknown device class ID with Discover's imaging device type is suboptimal — another reason the busclass lists are not hard-coded into the library.
3.1. The
busclass_list element
A busclass_list element possesses a
bus attribute and contains one or more
busclass elements.
3.1.1. The
bus attribute
The bus attribute of the
busclass_list element is set to the name of
the bus being described by the busclass list.
The bus attribute
presently supports the following values:
ata
pci
pcmcia
scsi
usb
We expect to support more buses in the future; ieee1394 and sbus are possible candidates.
3.2. The
busclass element
A busclass element possesses two
attributes, id and name, and
contains no elements.
3.2.2. The
name attribute
The name attribute is set to a
Discover device type. Discover's device types are an effort
to balance a few criteria:
Device types ("bus classes" in Discover terminology) defined by the PCI specification
Bus classes defined by the USB specification
Bus classes defined by the SCSI specification
Device types commonly conceived of by the personal computer user
Discover's definitions of device types will not meet with universal agreement; as happens in most categorization problems, some decisions had to be made arbitrarily. Discover does not attempt to solve the general problem of grouping various peripherals into categories; rather, Discover solves the problem for itself and uses bus-specific mappings to translate a device's own notion of its type to Discover's device type.
audio
A device capable of producing an analog or digital sound signal is an audio device. Typically, any device commonly referred to as a "sound card" is classified by Discover as an audio device.
bridge
A device that provides access to devices of a different type, commonly on a different bus, is a bridge device. For instance, consumer PCI chipsets often feature a bridge to ATA (also known as IDE) devices.
broadband
An interface device to a computer communications network implemented on top of a technology not explicitly designed for that purpose is a broadband device. Examples include ISDN terminal adapters as well as DSL and cable "modems"; analog phone-line modems are not included in this classification (see "modem" below).
display
A device controlled by the host machine's CPU and capable of producing an analog or digital video signal for output purposes is a display device. Typically, any device commonly referred to as a "video card" is classified by Discover as a display device.
fixeddisk
A high-speed, fixed magnetic storage device such as a hard disk drive is a fixeddisk device. Removable media devices such as floppy disk drives, CD-ROM drives, magneto-optical devices, tape drives, and Compact Flash card readers are not included in this classification.
humaninput
A device that receives tactile input from a person for the purpose of directing a computer's activity is a humaninput device. Examples include keyboards, mice, trackballs, joysticks, gamepads, digital tablets manipulated with a stylus or finger, and so forth. Input devices that rely upon non-tactile means of determining a person's intent, such as speech-recognition devices or cameras, are not included in this classification.
imaging
A device that captures still images for input purposes is an imaging device. Scanners and digital cameras are examples of imaging devices. Motion-capture devices such as television tuner cards, webcams, and digital video cameras are not included in this classification.
miscellaneous
Any device that cannot logically be classified as another device type is a miscellaneous device.
modem
An analog phone-line modulator/demodulator (modem) is classified by Discover as a modem device. No other kind of device is so classified.
network
An interface device to a conventional computer data communications network that does not require the use of a terminal adapter is a network device. For example, Ethernet and Token Ring network interface cards are network devices. Analog phone-line modems; terminal adapters for technologies such as ISDN and DSL; and "cable modems" are not "network" devices.
optical
An optical-technology storage device, often using read-only media, is an optical device. By far the most common examples of these devices are CD-ROM and DVD-ROM drives, including versions of these drives that can "burn" (write to) optical discs.
printer
A device that renders visual output in a permanent or semi-permanent manner to a physical medium is a printer. Typically, any device colloquially referred to as a "printer" is also classified by Discover as a printer.
removabledisk
Storage devices that feature removable media using just about any technology except that of magnetic tape, CD-ROM, and DVD-ROM drives are removabledisk devices. Examples include floppy disk drives, magneto-optical drives, and Compact Flash card readers.
tape
A sequential-access mass storage device using magnetic tape is a tape device. Commonly used for archival and backup purposes, DAT drives are examples of tape devices.
video
A device that produces a real-time digital video signal for input purposes is a video device. Webcams, digital video cameras, and television tuners are examples of video devices. Note that still digital cameras with "movie" capability are not considered video devices unless they can transmit the live video signal to the host in real time.
Chapter 4. Vendor Lists
Many buses have vendor identification numbers that are registered with that bus's standardization body and programmed into the devices when they are manufactured. These numbers generally are assigned arbitrarily, and typically have little meaning to the end user; therefore, most hardware detection tools provide a way to translate these numeric vendor IDs to human-readable strings. Thus, instead of knowing that your PCI or AGP video card was manufactured by "1002," you can determine that it was manufactured by "ATI Technologies, Inc."
Example 4-1. The vendor_list
element
<?xml version="1.0"?> <vendor_list bus="pci"> <vendor id="0675" name="Dynalink"/> <vendor id="0e11" name="Compaq Computer Corporation"/> <vendor id="1004" name="VLSI Technology Inc"/> <vendor id="1025" name="Acer Incorporated [ALI]"/> <vendor id="102b" name="Matrox Graphics, Inc."/> <vendor id="109e" name="Brooktree Corporation"/> </vendor_list> |
The foregoing example is similar in structure to the busclass list example; a numeric vendor ID maps to a vendor name, which can be used by Discover for queries or reports generated for the user's benefit.
4.1. The
vendor_list element
A vendor_list element possesses a
bus attribute and contains one or more
vendor elements.
4.1.1. The
bus attribute
The bus attribute of the
vendor_list element is set to the name of
the bus being described by the vendor list.
The following bus attributes are supported:
ata
pci
pcmcia
scsi
usb
4.2. The vendor element
A vendor element possesses two
attributes, id and name, and
contains no elements.
4.2.2. The name attribute
The name attribute is set to a
human-readable vendor identifier, typically the official name of
the corporation or other business entity that designed or
manufactured that peripheral.
Chapter 5. Device Lists
The device lists are the heart of Discover's functionality. They are the most frequently updated lists and contain the information of greatest value.
Discover's device lists not only provide a way to identify individual peripherals by name, but also permit the specification of an arbitrary quantity of organized data for each device, supporting an arbitrary number of software interfaces.
 | The following is a fictitious example. The information within it is for illustrative purposes only. See Part II in The Discover Hardware Detection System for a discussion of the "real" hardware data as provided by Progeny, and for some suggested conventions on organizing the data namespace. |
Example 5-1. Sample device data
<?xml version="1.0"?>
<device_list bus="pci">
<device busclass="1984" model="0101" model_name="Cerebral Reprogrammer" vendor="B16B">
<data class="linux">
<data class="module">
<data class="name">winston</data>
<data class="options">base_address=0x300 manual_override=0</data>
</data>
</data>
<data class="win2k">
<data class="hal_driver">
<data class="StrUglyHungarianNotatedDriverName">settlement</data>
<data class="flags">NSA_KEY=96b5f3e3283a62c85f6cb6f4017135c2</data>
</data>
</data>
</device>
</device_list> |
The example above includes a device_list
element containing device elements, and a
device element that defines the device itself,
but reserves any software- or interface-specific details to the
data elements it contains.
The actual data provided in the example is accessed by means of data paths; see Section 5.4 for further information.
5.1. The
device_list element
A device_list element possesses a
bus attribute and contains one or more
device elements.
5.1.1. The
bus attribute
The bus attribute of the
device_list element is set to the name of
the bus described by the device list.
The following bus attributes are supported:
ata
pci
pcmcia
scsi
usb
5.2. The device element
A device element possesses four attributes:
busclassvendormodelmodel_name
All of these attributes must be specified for each
device element. The busclass
attribute is set to a busclass
identifier, vendor to a vendor
identifier, model to a bus-specific
model identifier, and model_name to a
human-readable vendor identifier, typically the name of the product
under which the device reporting the model
identifier is sold or otherwise distributed.
A device element contains zero or more
data elements.
5.3. The data element
A data element possesses a mandatory
class attribute, an optional
version attribute, and zero or more
data elements.
The ability to nest data elements inside
other data elements affords interface designers
and device driver authors the ability to specify a hierarchy of
data, instead of being compelled to encapsulate only one piece of
data per device for their interface.
5.3.1. The class attribute
A class attribute is set to an arbitrary
value determined by an interface designer. For
data elements whose parent element is a
device element, this should be the name of
the interface being described, such as
freebsd, linux, or
xfree86.
A data element whose parent element is a
data element should set this attribute to a
term reflecting the interface designer's intended data hierarchy.
Discover does not mandate any particular hierarchy for
interface designers.
5.3.2. The version attribute
Data elements have an optional attribute named version. This indicates a version
range applicable to the data contained
within the element. The purpose of this attribute is to permit
the specification of data that is valid only for a range of
versions of the given interface. For example, the Linux kernel
changed some of the names of its modules between the 2.2 and 2.4
series.
Discover's range syntax, common in mathematical writings, is expressed as an interval; that is, it consists of a pair of endpoints with a comma between them, and brackets or parentheses as qualifiers for inclusion or exclusion of the endpoints' exact values. For example, the version specification [1.0, 2.0) matches any version less than 2.0 and greater than or equal to 1.0. It is the responsibility of the calling environment to specify the version of the interface actually in use. In other words, the Discover library does not take it upon itself to determine the currently running version of the Linux kernel, XFree86 X server, CUPS printing daemon, and so forth.
Due to the lack of consistent standards for version numbers
(in fact, some version numbers aren't numbers at all),
Discover requires simplifications for the version attribute. The versions that
express the range must be in dotted-decimal form, such as
7.1.0. The version that is supplied to the
Discover library as part of a query (for example, via the
--data-version argument to discover)
may or may not comply with this requirement, but should
be expressed such that it compares in a desirable way against
version strings that do.
In place of the upper end of the range, inf (infinity) can be used if the information is still relevant and should be for forseeable versions.
5.4. Accessing the Device Data
Discover data is grouped into hierarchical data elements. This data can be accessed
via its data path. The data path is the concatenation of the class
attribute values of a data
element and all its parents, separated by slash
(/) characters. In the following example,
quux is accessed via the data path
"foo/bar":
In Example 5-1 above, we would determine the name of the Linux kernel module ("winston") for the "Cerebral Reprogrammer" device by referencing the data path linux/module/name; similarly, the data path win2k/hal_driver/flags returns NSA_KEY=96b5f3e3283a62c85f6cb6f4017135c2.
II. Recommended Data Content Conventions
As discussed in the preface, Discover is not
intended to be a replacement for system utilities such as
lspci on Linux. A
device element should exist
for a piece of hardware only if there is some interface information
to communicate about the hardware; that is, some
data elements to house within the
device element. This part of the
manual contains Progeny's recommendations on how to organize that
information for maximum utility.
- Table of Contents
- 6. Data Hierarchy
- 7. Why Order Matters
- 8. Using Data Versioning
Chapter 6. Data Hierarchy
As discussed in Section 5.4, the XML structure around the data allows for a hierarchical view.
While Discover does not mandate any particular hierarchy or
namespace organization for data
elements, the XML files provided by Progeny express — and
some applications based on Discover (such as
discover-modprobe) expect — a certain
structure for Linux kernel module and XFree86 configuration
information.
At Progeny, we have often found it convenient to refer to a
top-level data element's class attribute value as an
"interface" (see the following example).
Example 6-1. Defining an interface
<device busclass="0300" vendor="de8d" model="90a9" model_name="Stingray">
<data class="xfree86">
<data class="server" version="[3, 4)">
<data class="name">XF86_SVGA</data>
</data>
</data>
<data class="openbsd">
<data class="security_level">untrusted</data>
</data>
</device> |
In Example 6-1, two interfaces have been defined for the "Stingray" device: xfree86 and openbsd.
6.1. Linux Kernel Modules
A hardware device that requires a particular Linux kernel
module should have nested data
elements to describe that module. The top-level data element should have a class attribute with a value of
linux. Underneath that should
be a data element with a
class of module.
Within that data element,
there should be one or two more, one with a class of name, and an optional one with a
class of options. The former has as content the
name of the module; the latter, options to be passed to
modprobe.
In Figure 6-1, each component of
the tree represents a data
element; the label is the value of its class attribute.
If the kernel version affects the choice of module name or
options, the top-level linux
data element should have a
version range attribute; see Section 5.3.2.
Example 6-2. Using the linux interface
<device busclass="0204" model="1702" model_name="IS64PH ISDN Adapter" vendor="0675">
<data class="linux">
<data class="module">
<data class="name">hisax</data>
<data class="options">io=0x300 irq=11</data>
</data>
</data>
</device> |
See Example 8-1 for guidance on how to specify different Linux kernel modules for the same device, depending on the version of the Linux kernel in use.
6.2. XFree86 X Servers
The data hierarchy of a video card device (Discover's
display type) should include a top-level
data element with a class attribute of xfree86 (the interface)
and likely with a version
attribute as well; nested within that element will be a server data element containing a name data element identifying the name of the
server executable. For XFree86 version 4.0 or greater, the
name will always be XFree86, and the server data element will also contain a device data element, which contains one or more
data elements communicating
information to be stored in the XF86Config
file. The children of the device data element are named in correspondence
with the syntax of the XF86Config file's
Device section; see the XF86Config
manual page for further information. In particular, note
that in many cases only a
driver data element is necessary.
Figure 6-2. XFree86 interface
/xfree86
|
|-/server
|
|-/name
|
|-/device
|
|-/driver
|
|-/chipid
|
|-/chipset
|
|-/ramdac
|
|-/dacspeed
|
|-/videoram
|
|-/options
|
|-... |
Figure 6-2 illustrates the
xfree86
interface. Example 6-3 shows
how you might write xfree86
interface information for a Discover display device.
Example 6-3. Using the xfree86 interface
<device busclass="0300" vendor="1002" model="4654" model_name="Mach64 VT [264VT FT]">
<data class="xfree86">
<data class="server" version="[4, inf)">
<data class="name">XFree86</data>
<data class="device">
<data class="driver">ati</data>
</data>
</data>
<data class="server" version="(0, 4)">
<data class="name">XF86_Mach64</data>
</data>
</data>
</device> |
6.3. Locally-Defined Interfaces
Progeny recommends that publicly distributed Discover
XML files avoid using the interface name
local; that is, a
class attribute value of
local in a top-level
data element. This
means that data paths such as local/foo/bar
should not be defined in a public Discover XML file, but
both foo/bar/local and
foo/local/bar are okay.
The intention is to reserve this part of the namespace for users' experiments with defining their own — and possibly future, widely adopted — interface definitions for Discover data. An interface definition could thus be "beta tested" by a person or organization to ensure that it is efficiently structured before it is unleashed upon the world elsewhere in the namespace, where people may write tools that expect to be able to resolve the interface definition's data paths.
Likewise, Progeny recommends that authors of applications
that use Discover avoid traversing into a top-level
local data
element, which may impose an undesirable support burden on
the designers of the interface while they are still working out
their design. (The application also may not find the data it
desires, or may not get back what it expects.)
Chapter 7. Why Order Matters
When searching device elements, the first exact match will be selected. Subsequent matches are ignored.
Specifically, three comparisons are made:
The hardware must provide identification that matches attributes of the
deviceelement. As an example, a PCI device supplies numeric vendor and model identifiers, which are used to match themodelandvendorattributes.The
classattributes of childdataelements must match the data path as given to the library for searching.The first version range, if any, associated with the nested
dataelements must encompass any version provided by the client.
Example 7-1. Matching device elements
Assume that the path linux/module/name is
provided, along with a version of 2.4.2. The following is sample
data; the device elements may be from the same
or different data files.
<device busclass="0000" vendor="102f" model="5555" model_name="100VG ethernet"> <data class="linux" version="[2.4, inf)"> |
- This item is the first one scanned, and would match, except that the requested data path includes "module" as a component, not "modules" as specified here.
- This item doesn't match because the provided range is outside the limits defined by the element. (2.4.2 is not greater than or equal to 2.0 and less than 2.2.)
- This item matches because no range is given, so "vg100new" is the value returned.
- This is the nearest match, but the Discover library will never select it because its previous sibling has no version range, and thus will catch any version provided.
Chapter 8. Using Data Versioning
8.1. Specifying a Range
Because multiple versions of a software interface often are
in simultaneous deployment, Progeny recommendeds that the upper
bound of a data element's
version attribute be defined
as the first version that is inconsistent with the information
provided within it, and that the upper end of the interval be open
(terminated with a parenthesis). As an example, suppose we know
that the name of the Linux kernel module to drive the RealTek
RTL-8139 Ethernet device was rtl8139 in the 2.2
kernel series and 8139too in the 2.4 series. To
express this, we would say the following:
Example 8-1. Using the
version attribute of the
data element
<device_list bus="pci">
<device busclass="0200" model="8139" model_name="RTL-8139" vendor="10ec">
<data class="linux" version="[2.4,inf)">
<data class="module">
<data class="name">8139too</data>
</data>
</data>
<data class="linux" version="[2.2,2.4)">
<data class="module">
<data class="name">rtl8139</data>
</data>
</data>
</device>
</device_list> |
In the first data element, for instance, we would not use a version attribute of [2.2.0,2.2.19] because it is needlessly specific. What happens if the Linux kernel developers release Linux kernel 2.2.20? By saying [2.2,2.4), we "catch" everything in the kernel 2.2 series[2] — past, present, and future.
8.2. How the Discover Library Matches a Range
The data files will be searched in order; the first data path that matches the version range or doesn't have a version range will be returned.
Recalling the discussion in Section 5.3.2, if you want the first data element matching the requested data path to also be the "fallback" element if no version range applies, you can duplicate that data element and place it at the end. However, a better practice is to make certain that all reasonable versions will match one of the ranges, and that the first range listed has an open-ended high end, such as [2.4, inf) for Linux kernel modules in Example 8-1. This will have the effect of "assuming" that all unversioned requests for linux data will be for Linux kernel 2.4 or later.
III. Command-Line Tools
- Table of Contents
- 9. discover Manual Page
- discover -- hardware detection utility
- 10. discover.conf Manual Page
- discover.conf -- configuration file format for discover(1)
- 11. discover-modprobe Manual Page
- discover-modprobe -- kernel module loading using discover(1)
- 12. discover-modprobe.conf Manual Page
- discover-modprobe.conf -- configuration file for discover-modprobe(5)
Chapter 9. discover Manual Page
discover
Synopsis
discover [DATA_OPTIONS] [DISPLAY_OPTIONS] [--bus-summary] [bus...]
discover [DATA_OPTIONS] [DISPLAY_OPTIONS] --type-summary [type...]
discover [DATA_OPTIONS] --data-path=path/to/data... [--data-version=version] [--normalize-whitespace] [--format=format string] [type | id...]
- DATA_OPTIONS
-d | --disable-bus=bus-e | --enable-bus=bus--insert-url=url--append-url=url-v | --verbose
- DISPLAY_OPTIONS
--model | --no-model--model-id | --no-model-id--vendor | --no-vendor--vendor-id | --no-vendor-id
Description
discover provides an extensible hardware detection and reporting interface. Hardware information is stored in an XML data format and can be retrieved across the network.
Fundamental modes of operation:
Display a list of hardware devices based on type of device or system bus on which the devices reside, via
--type-summaryor--bus-summary(the latter of which is the default behavior).Query specified data for attached hardware, via
--data-path.
Options
-h | --helpDisplay a simple help message.
-v | --verboseInstruct the tool to provide feedback as it operates. This will affect the output as discover parses certain arguments, so this should appear early in the command line.
-V | --versionDisplay the tool name and version.
-b | --bus-summaryThis is the default behavior: Display basic information regarding all devices on the appropriate buses. See Selecting Buses.
-t | --type-summarySummarize devices by class of hardware. Examples of valid device types include broadband, fixeddisk, display, and network. See Device Types.
--data-path=path/to/dataQuery matching devices for detailed information. Device-specific data is stored in a hierarchical fashion, and the query argument comprises strings naming each level in that hierarchy.
Typically, the top-level component of the data path will be the "platform" that will need the information, such as linux or xfree86. For example, to retrieve the Linux kernel module name for a piece of hardware, the
--data-pathargument would be linux/module/name.If multiple
--data-patharguments are given and no format string (see--format) is provided, only the last path is used.See also the
--data-versionargument.--data-version=versionSpecify a version string for the platform that will use the information specified by the argument to
--data-path.This string must be in dotted-decimal notation in order to be matched against a range of values, and thus may be shorter than the real version.
--format=format stringDictate the output of the results of the queries specified by
--data-patharguments. This format string should followprintf(3)specifications, although only %s and appropriate flags, precision, and width values are supported (or make sense); literal text and %% can also be used. The behavior when the string is poorly formatted is undefined. See also--normalize-whitespace.-d | --disable-bus=busUse this option to override the list of buses to scan by default as defined in discover.conf. Use all as an argument to disable all buses; this is useful only if followed by
--enable-bus(or-e) arguments.-e | --enable-bus=busSpecify a bus to be scanned.
--insert-url=urlInsert a URL at the head of the list of network resources to include in the search for hardware information. Earlier data overrides later data; to override the local data sources, insert URLs into the list. See also
--append-url.--append-url=urlAppend a URL to the end of the list of network resources to search for hardware information. See also
--insert-url.--modelInclude the model description in summary information. This is enabled by default.
--model-idInclude the numeric model identifier in summary information.
--no-modelDo not include the model description in summary information.
--no-model-idDo not include the numeric model identifier in summary information. This is the default.
--vendorInclude the vendor description in summary information. This is enabled by default.
--vendor-idInclude the numeric vendor identifier in summary information.
--no-vendorDo not include the vendor description in summary information.
--no-vendor-idDo not include the numeric vendor identifier in summary information. This is the default.
--normalize-whitespaceConsolidate whitespace in the results of a
--data-pathquery. The default is not to do so, which faithfully reproduces all text in the raw XML data.With this option enabled, leading and trailing whitespace is removed, and any consecutive internal whitespaces are compressed to a single space character.
Selecting Buses
discover.conf defines two lists of system buses: one to scan by default (used by the discover command), and one never to scan (used by the Discover library).
You can override and/or extend the list of default buses with
--disable-bus and --enable-bus.
The list of buses not to scan cannot be overridden
without changing discover.conf, so that list
should be used only for buses that may be dangerous to probe.
Both arguments take the string "all" as a value.
If a bus summary is being performed, which is indicated
either by the presence of --bus-summary or
the absence of --type-summary and
--data-path, any unattached arguments on the
command line will be interpreted as the only buses to scan.
This is equivalent to using --disable-bus
all before invoking --enable-bus
for the buses of interest.
The following buses are currently supported by Discover:
ata
pci
pcmcia
scsi
usb
Device Types
Discover defines its own device types, to which the device types used by each bus are mapped. Discover currently recognizes the following device types:
audio
A device capable of producing an analog or digital sound signal is an audio device. Typically, any device commonly referred to as a "sound card" is classified by Discover as an audio device.
bridge
A device that provides access to devices of a different type, commonly on a different bus, is a bridge device. For instance, consumer PCI chipsets often feature a bridge to ATA (also known as IDE) devices.
broadband
An interface device to a computer communications network implemented on top of a technology not explicitly designed for that purpose is a broadband device. Examples include ISDN terminal adapters as well as DSL and cable "modems"; analog phone-line modems are not included in this classification (see "modem" below).
display
A device controlled by the host machine's CPU and capable of producing an analog or digital video signal for output purposes is a display device. Typically, any device commonly referred to as a "video card" is classified by Discover as a display device.
fixeddisk
A high-speed, fixed magnetic storage device such as a hard disk drive is a fixeddisk device. Removable media devices such as floppy disk drives, CD-ROM drives, magneto-optical devices, tape drives, and Compact Flash card readers are not included in this classification.
humaninput
A device that receives tactile input from a person for the purpose of directing a computer's activity is a humaninput device. Examples include keyboards, mice, trackballs, joysticks, gamepads, digital tablets manipulated with a stylus or finger, and so forth. Input devices that rely upon non-tactile means of determining a person's intent, such as speech-recognition devices or cameras, are not included in this classification.
imaging
A device that captures still images for input purposes is an imaging device. Scanners and digital cameras are examples of imaging devices. Motion-capture devices such as television tuner cards, webcams, and digital video cameras are not included in this classification.
miscellaneous
Any device that cannot logically be classified as another device type is a miscellaneous device.
modem
An analog phone-line modulator/demodulator (modem) is classified by Discover as a modem device. No other kind of device is so classified.
network
An interface device to a conventional computer data communications network that does not require the use of a terminal adapter is a network device. For example, Ethernet and Token Ring network interface cards are network devices. Analog phone-line modems; terminal adapters for technologies such as ISDN and DSL; and "cable modems" are not "network" devices.
optical
An optical-technology storage device, often using read-only media, is an optical device. By far the most common examples of these devices are CD-ROM and DVD-ROM drives, including versions of these drives that can "burn" (write to) optical discs.
printer
A device that renders visual output in a permanent or semi-permanent manner to a physical medium is a printer. Typically, any device colloquially referred to as a "printer" is also classified by Discover as a printer.
removabledisk
Storage devices that feature removable media using just about any technology except that of magnetic tape, CD-ROM, and DVD-ROM drives are removabledisk devices. Examples include floppy disk drives, magneto-optical drives, and Compact Flash card readers.
tape
A sequential-access mass storage device using magnetic tape is a tape device. Commonly used for archival and backup purposes, DAT drives are examples of tape devices.
video
A device that produces a real-time digital video signal for input purposes is a video device. Webcams, digital video cameras, and television tuners are examples of video devices. Note that still digital cameras with "movie" capability are not considered video devices unless they can transmit the live video signal to the host in real time.
Examples
Example 9-1. Scan the local buses
# discover Intel Corporation 82815 Chipset Host Bridge and Memory Controller Hub unknown unknown unknown unknown unknown unknown Intel Corporation 82815 Chipset IDE controller Intel Corporation 82815 Chipset USB (A) Intel Corporation 82815 System Management bus controller ATI Technologies, Inc. Rage 128 Pro GL [PF] 3Com Corporation 3c905C-TX [Fast Etherlink] Ensoniq ES1371 [AudioPCI-97] unknown unknown |
Example 9-2. View PCI video cards
# discover -v --type-summary --disable-bus all --enable-bus pci display Disabled pci Disabled pcmcia Disabled scsi Disabled usb Enabled pci Loading XML data... pci Done Scanning buses... pci Done ATI Technologies, Inc. Rage 128 Pro GL [PF] |
Files
- /etc/discover.conf.d
The directory containing configuration files that control the default behavior for both the discover tool and the Discover library.
- /discover/list.xml
An XML file containing URLs with hardware information. This list can be extended with
--append-urland--extend-url.
Chapter 10. discover.conf Manual Page
discover.conf
Description
Discover looks for configuration files in a configuration directory, containing a number of files. These define the system buses that should be scanned by default, those that should never be scanned, and the URLs for hardware data files beyond the local copy provided with the software.
The file format is XML; the DTD is provided with the Discover software, and can be used for informational or validation purposes.
Examples
Example 10-1. Establishing default buses to scan
<?xml version="1.0"?>
<!DOCTYPE conffile SYSTEM "conffile.dtd">
<conffile>
<busscan scan="default">
<bus name="ata"/>
<bus name="pci"/>
<bus name="pcmcia"/>
<bus name="scsi"/>
<bus name="usb"/>
</busscan>
</conffile>
|
Example 10-2. A more complex example
<?xml version="1.0"?>
<!DOCTYPE conffile SYSTEM "conffile.dtd">
<conffile>
<busscan scan="default">
<bus name="ata"/>
<bus name="pci"/>
<bus name="pcmcia"/>
<bus name="usb"/>
</busscan>
<!-- My ancient SCSI card locks up when probed -->
<busscan scan="never">
<bus name="scsi"/>
</busscan>
<data-sources>
<data-source url="http://www.example.com/discover/xfree86.xml"
label="Updated XFree86 hardware information">
</data-sources>
</conffile>
|
Chapter 11. discover-modprobe Manual Page
discover-modprobe
Description
discover-modprobe loads kernel modules identified by discover. It will typically be invoked automatically at boot time.
Files
- /etc/discover-modprobe.conf
This configuration file defines the types of modules to load by default, and specific modules not to load.
- /var/lib/discover/crash
A crash file written and erased each time discover-modprobe attempts to load a module. If the file lingers, the computer is assumed to have crashed while loading that module, and the module name is added to discover-modprobe.conf as a module to skip in the future.
Chapter 12. discover-modprobe.conf Manual Page
discover-modprobe.conf
Description
discover-modprobe.conf is the configuration file for discover-modprobe, which is responsible for retrieving and loading kernel modules.
 | This file is a shell script, and as such is subject to a string variable assignment syntax. No space is allowed between the variable name, the equal (=) sign, and the value(s) assigned. If multiple values are to be assigned, the list must be space-delimited with surrounding quotes. |
Two directives can be used in this file: types and skip. Both can be defined multiple times.
- types
This describes the classes of hardware that should be scanned and queried.
- skip
These modules should never be loaded. See the "Files" section for details on the mechanism for generating these entries automatically.
IV. Library
- Table of Contents
- 13. The Discover Library
- 13.1. Library Design Principles
- 13.2. Discover Data Sources
- 13.3. The Bus Map
- 13.4. Scanning the System
- 13.5. Using discover_device_t Structures
- 14. System Dependencies
- 14.1. API
Chapter 13. The Discover Library
13.1. Library Design Principles
Lazy allocation is used throughout Discover. This means that there are no "init" functions, and no functions to scan the bus. Instead, retrieval functions scan or initialize as necessary. Each of these retrieval functions has an equivalent function for freeing the allocated memory. This is valuable to long-lived processes to aid in memory management, but even short-lived processes may want to use them to force reloading of the information.
13.2. Discover Data Sources
Discover knows about one data source by default: the local
data from the discover-data package. Additional
sources can be added with the
discover_conf_append_url and
discover_conf_insert_url functions. As their
names suggest, they append or insert URLs on the data source
list. Earlier data overrides later data; to override
the local data sources, insert URLs.
13.3. The Bus Map
Most high-level operations begin at the bus map. Bus maps
(discover_bus_map_t)
are retrieved with calls to
discover_conf_get_bus_map or
discover_conf_get_bus_map_by_name.
discover_conf_get_bus_map returns an array of
maps, one for each supported bus, with the last element being all
0s. discover_conf_get_bus_map_by_name returns
the map for the named bus. The map contains pointers to all the
functions that operate on the bus, as well as the
scan_default variable, which determines whether
the bus is scanned by default. There is also a
scan_never variable, but it is for internal use
only. The name of the bus is stored in the
name variable.
The following functions are available in the bus map. The "get" functions take a single discover_error_t argument and return a list of discover_device_t structures, while the "free" functions take no arguments and return no value.
get_devicesRetrieve the list of devices found on this bus. Returns NULL if the bus is not present on the system, or if no devices are attached to it.
xml_get_busclassesRetrieve the list of busclasses for this bus (from the XML data sources).
xml_get_devicesRetrieve the list of devices for this bus (from the XML data sources). Note that this is the list of devices that Discover knows about, not the list of devices present on the system.
xml_get_vendorsRetrieve the list of vendors for this bus (from the XML data sources).
xml_get_busclass_urlsRetrieve the list of URLs from which busclass data is retrieved. This function is probably not useful to most clients.
xml_get_device_urlsRetrieve the list of URLs from which device data is retrieved. This function is probably not useful to most clients.
xml_get_vendor_urlsRetrieve the list of URLs from which vendor data is retrieved. This function is probably not useful to most clients.
free_devicesFree the list of devices.
xml_free_busclassesFree the list of busclasses.
xml_free_devicesFree the list of devices (the XML data, not the list of devices found on the system).
xml_free_vendorsFree the list of vendors.
xml_free_busclass_urlsFree the list of busclass URLs.
xml_free_device_urlsFree the list of device URLs.
xml_free_vendor_urlsFree the list of vendor URLs.
13.4. Scanning the System
Discover provides a few ways to scan the system for information.
You can walk the bus map:
for (i = 0; busmap[i].name; i++) {
if (busmap[i].scan == DISCOVER_SCAN_DEFAULT) {
devices = busmap[i].get_devices(&status);
check_status(status);
do_something_cool(devices);
}
} |
You can scan a specific bus:
Perhaps most usefully, you can scan for devices of a specific type:
13.5. Using discover_device_t Structures
Now that you have some device structures, what can you
do with them? The most interesting operation is retrieving
data with discover_device_get_data. Also
available are
discover_device_get_vendor_name,
discover_device_get_model_name,
discover_device_get_model_id, and
discover_device_get_vendor_id.
discover_device_get_data takes a
data path and a
version
number and searches for the first data structure that
matches.
discover_device_get_vendor_name
returns the human-readable name for the device's
vendor.
discover_device_get_model_name
returns the human-readable name for the device's model.
discover_device_get_model_id
returns the bus-specific ID for the device model.
discover_device_get_vendor_id
returns the bus-specific ID for the device vendor.
Chapter 14. System Dependencies
14.1. API
The system-dependent code (sysdeps)
that must be custom-written for each operating system conforms to a
very simple API. Discover invokes
_discover_get_busname_raw()
with no arguments, and expects a linked list of
discover_sysdep_data_t structures in return.
The discover_sysdep_data_t structures should contain as much descriptive information as they can regarding the devices discovered. Specifically, the three pieces of information desired are the busclass (device type), vendor identifier, and model identifier, which is a unique identification string that the vendor has provided for the given piece of hardware.
Example 14-1. Linux PCI sysdep code
#include <config.h>
#include <stdio.h>
#include <stdlib.h>
#include <sysdep.h>
discover_sysdep_data_t *
_discover_get_pci_raw(void)
{
FILE *f;
char *line = NULL;
size_t len = 0;
discover_sysdep_data_t *head = NULL, *node, *last = NULL;
unsigned int id;
if ((f = fopen(PATH_PROC_PCI, "r"))) {
while (getline(&line, &len, f) >= 0) {
if (line[0] == '\n' || line[0] == '#') {
continue;
}
node = _discover_sysdep_data_new();
sscanf(line, "%*04x\t%08x", &id);
node->vendor = (id >> 16);
node->model = id & 0xffff;
if (head == NULL) {
head = node;
last = head;
} else {
last->next = node;
last = node;
}
}
free(line);
fclose(f);
}
return head;
}
|
Appendix B. Discover DTD
<!-- $Progeny$ -->
<!ELEMENT discover-data (location)*>
<!ELEMENT location EMPTY>
<!ATTLIST location bus NMTOKEN #REQUIRED
type NMTOKEN #REQUIRED
url CDATA #REQUIRED>
<!ELEMENT busclass_list (busclass)*>
<!ATTLIST busclass_list bus NMTOKEN #REQUIRED>
<!ELEMENT busclass EMPTY>
<!ATTLIST busclass id NMTOKEN #REQUIRED
name NMTOKEN #REQUIRED>
<!ELEMENT vendor_list (vendor)*>
<!ATTLIST vendor_list bus NMTOKEN #REQUIRED>
<!ELEMENT vendor EMPTY>
<!ATTLIST vendor id CDATA #REQUIRED
name CDATA #REQUIRED>
<!ELEMENT device_list (device)*>
<!ATTLIST device_list bus NMTOKEN #REQUIRED>
<!ELEMENT device (data)*>
<!ATTLIST device busclass NMTOKEN #REQUIRED
model CDATA #DEFAULT default
model_name CDATA #REQUIRED
vendor CDATA #REQUIRED>
<!ELEMENT data (#PCDATA|data)*>
<!ATTLIST data class NMTOKEN #REQUIRED
version CDATA #IMPLIED>
<!-- vim:set ai et sts=8 sw=8 tw=0: -->
|
Appendix C. Discover Configuration File DTD
<!-- $Progeny$ -->
<!ELEMENT conffile (busscan*,data-sources?)>
<!ELEMENT data-sources (data-source)*>
<!ELEMENT data-source EMPTY>
<!ATTLIST data-source url CDATA #REQUIRED
label CDATA #IMPLIED
place NMTOKEN #IMPLIED>
<!ELEMENT busscan (bus)*>
<!-- The attributes will likely be handled by different parts of -->
<!-- Discover. If there is a list of buses never to scan, the library -->
<!-- should be aware of it. If there is a list of buses to scan by -->
<!-- default, that will be of interest to the client tool. -->
<!ATTLIST busscan scan (default|never) #REQUIRED>
<!ELEMENT bus EMPTY>
<!ATTLIST bus name NMTOKEN #REQUIRED>
|
Appendix D. Licensing Issue on the Linux Sysdeps
It should be noted that the Linux-specific files in the sysdeps/linux directory of the source distribution are derived from code written for the Detect library by MandrakeSoft SA, and are licensed under the GNU Project's General Public License (GPL).
Note that section 2 of the GPL places requirements on derived works that prevent licensees from exercising some of the permissions granted under the license on the rest of Discover. However, not everyone who modifies or distributes Discover will necessarily be subject to the terms of the GPL. If you do not compile, use, or distribute the Linux sysdeps (for instance, if you are building Discover for FreeBSD), then the license terms on them do not attach.
We realize, however, that it is desirable that all of Discover be under the the same license terms. There are a few possible solutions to this problem:
If you do not need the Linux sysdeps, you can delete them from your copy of Discover.
You can rewrite the Linux sysdeps. The resulting code will be your work, so the only limitations on you will be those imposed by Discover's license. If you do so, we encourage you to license your rewrite under the same terms as the rest of Discover — in that event, Progeny will be happy to incorporate your code into a future release of Discover.
You can contact MandrakeSoft SA and negotiate a different license to their code that is used in the Linux sysdeps.
You can contact MandrakeSoft SA and attempt to persuade them to relicense their code that is used in the Linux sydeps under the terms used by the rest of Discover. (MandrakeSoft SA would not have to abandon or assign their copyright.) If you succeed in this effort, please let Progeny know and we will update the license terms on our copy of the MandrakeSoft SA code.
You can wait; eventually Progeny employees, or some volunteer, will rewrite the Linux sysdeps and license them under the terms that the rest of Discover uses.
| The foregoing discussing is not legal advice and makes no claim to be such. It is a layperson's understanding of the licensing issues from a software developer's perspective. Progeny makes no warranties or guarantees as to the accuracy of the above analysis in a legal context. If you require a professional legal opinion, consult attorneys specializing in copyright and licensed to practice in the jurisdictions of interest to you or to your organization. |
Notes
| [1] | Other protocols such as FTP are available but deprecated; Discover uses integrity verification mechanisms such as MD5 checksums in the HTTP protocol. |
| [2] | We would say [2.2,2.3) instead, but, like many Free Software projects, the Linux kernel uses odd minor version numbers to denote unstable, development series of the software, and even minor version numbers to denote stable, production series of the software. In the example, then, we arbitrarily treat all 2.3 series kernels the same as 2.2 kernels. |
over the web). When &http; access is impossible, &discover; falls back to locally stored hardware lists.
UCB/BSDor
MIT/X Consortiumterms, after the names of American universities and some very well known software projects that used these terms, anyone is free to copy, modify, and distribute the software, and to extend (or not) these same freedoms to those who receive the software. Progeny would like to see &discover; adopted by a wide variety of existing software products, such the various GNU/Linux distributions; the FreeBSD, NetBSD, and OpenBSD projects; the GNU Project of the Free Software Foundation; the XFree86 Project; system integrators; and the designers and manufacturers of computer hardware. We believe that &discover;'s design empowers those with the greatest knowledge of hardware and the software interfaces to that hardware to express that knowledge and make it available to the world, thereby ameliorating an entire class of computer configuration problems. Progeny does not want &discover;'s licensing to stand in the way of realizing that dream, which is why we have chosen these license terms.
What is the name of this device?and
Who manufactured it?&discover;'s role is to answer questions like
What Linux kernel module do I need to load for this device to work?More importantly, &discover; will enable you to provide answers in the future to questions you don't even expect to ask today.
device classto reduce confusion) to &discover;'s device types, which are used for running selective queries; a vendor list associates bus-specific vendor identification data with natural-language names for hardware vendors; and a device list contains information specific to individual devices.
bus classesin &discover; terminology) defined by the &pci; specification
1002,you can determine that it was manufactured by
ATI Technologies, Inc.
realhardware data as provided by Progeny, and for some suggested conventions on organizing the data namespace.
foo/bar:
winston) for the
Cerebral Reprogrammerdevice by referencing the data path
interface(see the following example).
Stingraydevice:
beta testedby a person or organization to ensure that it is efficiently structured before it is unleashed upon the world elsewhere in the namespace, where people may write tools that expect to be able to resolve the interface definition's data paths.
moduleas a component, not
modulesas specified here.
vg100newis the value returned.
catcheverything in the kernel 2.2 series
fallbackelement if no version range applies, you can duplicate that data element and place it at the end. However, a better practice is to make certain that all reasonable versions will match one of the ranges, and that the first range listed has an open-ended high end, such as
assumingthat all unversioned requests for
initfunctions, and no functions to scan the bus. Instead, retrieval functions scan or initialize as necessary. Each of these retrieval functions has an equivalent function for freeing the allocated memory. This is valuable to long-lived processes to aid in memory management, but even short-lived processes may want to use them to force reloading of the information.
getfunctions take a single
freefunctions take no arguments and return no value.
sysdep.h
Go to the documentation of this file.00001 00006 /* $Progeny$ 00007 * 00008 * AUTHOR: John R. Daily <jdaily@progeny.com> 00009 * 00010 * Copyright 2002 Progeny Linux Systems, Inc. 00011 * 00012 * Permission is hereby granted, free of charge, to any person obtaining a 00013 * copy of this software and associated documentation files (the "Software"), 00014 * to deal in the Software without restriction, including without limitation 00015 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00016 * and/or sell copies of the Software, and to permit persons to whom the 00017 * Software is furnished to do so, subject to the following conditions: 00018 * 00019 * The above copyright notice and this permission notice shall be included in 00020 * all copies or substantial portions of the Software. 00021 * 00022 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00023 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00024 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00025 * THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00026 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 00027 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 00028 * DEALINGS IN THE SOFTWARE. 00029 */ 00030 00031 #ifndef SYSDEP_H 00032 #define SYSDEP_H 00033 00034 #ifdef __cplusplus 00035 extern "C" { 00036 #endif 00037 00043 typedef struct discover_sysdep_device_data { 00045 char *path; 00047 char *value; 00049 struct discover_sysdep_device_data *next; 00050 } discover_sysdep_device_data_t; 00051 00056 typedef struct discover_sysdep_data { 00058 char *busclass; 00060 char *vendor; 00062 char *model; 00064 discover_sysdep_device_data_t *data; 00066 struct discover_sysdep_data *next; 00067 } discover_sysdep_data_t; 00068 00069 discover_sysdep_data_t *_discover_sysdep_data_new(void); 00070 discover_sysdep_device_data_t *_discover_sysdep_device_data_new(void); 00071 void _discover_free_sysdep_data(discover_sysdep_data_t *); 00072 void _discover_free_sysdep_device_data(discover_sysdep_device_data_t *); 00073 00074 discover_sysdep_data_t *_discover_get_ata_raw(void); 00075 discover_sysdep_data_t *_discover_get_pci_raw(void); 00076 discover_sysdep_data_t *_discover_get_usb_raw(void); 00077 discover_sysdep_data_t *_discover_get_pcmcia_raw(void); 00078 discover_sysdep_data_t *_discover_get_scsi_raw(void); 00079 00080 #ifdef __cplusplus 00081 } 00082 #endif 00083 00084 #endif 00085 00086 /* 00087 * Local variables: 00088 * c-file-style: "progeny" 00089 * indent-tabs-mode: nil 00090 * End: 00091 */ 00092 /* vim: set cin fo=tcroq sw=4 et sts=4 tw=75: */
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/busclass-xml_8c.html 0000644 0023421 0023421 00000013040 10655642004 022113 0 ustar pere pere
busclass-xml.c File Reference
Busclass XML data file parsing. More...
#include "config.h"
#include <sys/types.h>
#include <assert.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <expat.h>
#include <discover/discover.h>
#include <discover/discover-xml.h>
#include <discover/load-url.h>
#include <discover/utils.h>
Go to the source code of this file.
Functions | |
| void | discover_xml_merge_busclass_url (discover_xml_busclass_t **blist, char *url, discover_error_t *status) |
| discover_xml_busclass_t * | discover_xml_get_busclasses (discover_bus_t bus, discover_error_t *status) |
| void | discover_xml_free_busclasses (void) |
| char * | discover_xml_busclass_to_class (char *busclass, discover_xml_busclass_t *busclasses) |
| int | discover_xml_busclass_cmp (char *busclass, char *discover_class, discover_xml_busclass_t *busclasses) |
| char * | discover_xml_busclass_get_id (discover_xml_busclass_t *busclass) |
| char * | discover_xml_busclass_get_name (discover_xml_busclass_t *busclass) |
| discover_xml_busclass_t * | discover_xml_busclass_get_next (discover_xml_busclass_t *busclass) |
| discover_xml_busclass_t * | discover_xml_busclass_new (void) |
| void | discover_xml_busclass_free (discover_xml_busclass_t *busclasses) |
Detailed Description
Busclass XML data file parsing.This file contains the routines needed to properly process the busclass XML data. This file is responsible for handling URLs and actually storing the XML data during the parsing process.
Definition in file busclass-xml.c.
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/device-xml_8c-source.html 0000644 0023421 0023421 00000104345 10655642004 023042 0 ustar pere pere
device-xml.c
Go to the documentation of this file.00001 00010 /* $Progeny$ 00011 * 00012 * AUTHOR: John R. Daily <jdaily@progeny.com> 00013 * 00014 * Copyright 2002 Progeny Linux Systems, Inc. 00015 * Copyright 2002 Hewlett-Packard Company 00016 * 00017 * Permission is hereby granted, free of charge, to any person obtaining a 00018 * copy of this software and associated documentation files (the "Software"), 00019 * to deal in the Software without restriction, including without limitation 00020 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00021 * and/or sell copies of the Software, and to permit persons to whom the 00022 * Software is furnished to do so, subject to the following conditions: 00023 * 00024 * The above copyright notice and this permission notice shall be included in 00025 * all copies or substantial portions of the Software. 00026 * 00027 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00028 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00029 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00030 * THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00031 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 00032 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 00033 * DEALINGS IN THE SOFTWARE. 00034 */ 00035 00036 /* 00037 * This is slightly different than busclass-xml.c and vendor-xml.c. 00038 * With those, the data that interests us is actually in the 00039 * XML files, so the structures built by those modules are the final 00040 * structures. 00041 00042 * With the devices, the list we build here is only an intermediate 00043 * place to store the discover_device structures. When we probe the 00044 * bus, we will move the discover_device structures for which 00045 * we have found corresponding hardware from this list to the final 00046 * one. (That action happens in the modules for the individual buses, 00047 * such as pci.c.) 00048 00049 * Whereas busclass-xml.c and vendor-xml.c create pci_busclasses and 00050 * pci_vendors lists, respectively, this module creates 00051 * pci_devices_xml. Objects are moved from this list to the 00052 * pci_devices list in pci.c, and the rest are freed. 00053 */ 00054 00055 #include "config.h" 00056 00057 #include <sys/types.h> 00058 00059 #include <assert.h> 00060 #include <ctype.h> 00061 #include <limits.h> 00062 #include <stdbool.h> 00063 #include <string.h> 00064 #include <errno.h> 00065 00066 #include <expat.h> 00067 00068 #include <discover/discover.h> 00069 #include <discover/discover-xml.h> 00070 00071 #include <discover/load-url.h> 00072 #include <discover/device.h> 00073 #include <discover/utils.h> 00074 #include <discover/stack.h> 00075 00077 #define IDLEN 5 00078 00079 static discover_device_t *devices_xml[BUS_COUNT]; 00080 00082 enum state { START, FINISH, DEVICE, DATA }; 00083 struct context { 00084 enum state state; 00085 00086 discover_xml_busclass_t *busclasses; 00087 discover_xml_vendor_t *vendors; 00088 00089 /* Device stuff */ 00090 discover_device_t **dhead; 00091 discover_device_t *dtail; 00092 00093 /* data stuff */ 00094 discover_xml_stack *stack; 00095 /* 00096 discover_data_t *data_current; 00097 discover_data_t *data_parent; 00098 */ 00099 int nesting; 00100 int last_nesting; 00101 00102 int unknown_level; /* How deep are we into unknown XML tags? */ 00103 }; 00104 00105 static char *known_device_elements[] = { 00106 "data", 00107 "device", 00108 "device_list", 00109 NULL 00110 }; 00111 00112 static void 00113 get_data_failure_handler(discover_error_t **status, char *url) 00114 { 00115 char *errmsg; 00116 static int maxurlsize = 1024; /* If your URL is longer than this, 00117 you've got problems */ 00118 00119 if((*status)->code == DISCOVER_EIO) { 00120 errmsg = _discover_xmalloc(maxurlsize + 1); 00121 snprintf(errmsg, maxurlsize, "Resource not found: %s", url); 00122 (*status)->create_message(status, errmsg); 00123 free(errmsg); 00124 } else { 00125 if (errno) { 00126 errmsg = _discover_xmalloc(maxurlsize + 1); 00127 snprintf(errmsg, maxurlsize, "Problem loading resource: %s: %s", 00128 strerror(errno), url); 00129 (*status)->create_message(status, errmsg); 00130 free(errmsg); 00131 } else { 00132 (*status)->create_message(status, 00133 "Unknown failure from system-dependent libraries"); 00134 } 00135 } 00136 } 00137 00138 static bool 00139 unknown_device_element(const XML_Char * const tag) 00140 { 00141 int i; 00142 for (i = 0; known_device_elements[i] != NULL; i++) { 00143 if (strcmp(tag, known_device_elements[i]) == 0) 00144 return false; 00145 } 00146 return true; 00147 } 00148 00149 static void 00150 create_device(struct context *context, const XML_Char *attrs[]) 00151 { 00152 int i; 00153 char *busclass, *model_id, *model_name, *vendor_id, *vendor_name; 00154 discover_device_t *new_device; 00155 00156 assert(context != NULL); 00157 assert(attrs != NULL); 00158 00159 busclass = model_id = model_name = vendor_id = NULL; 00160 for (i = 0; attrs[i]; i += 2) { 00161 if (strcmp(attrs[i], "busclass") == 0) { 00162 busclass = (char *)attrs[i + 1]; 00163 00164 } else if (strcmp(attrs[i], "model") == 0) { 00165 model_id = (char *)attrs[i + 1]; 00166 00167 } else if (strcmp(attrs[i], "model_name") == 0) { 00168 model_name = (char *)attrs[i + 1]; 00169 00170 } else if (strcmp(attrs[i], "vendor") == 0) { 00171 vendor_id = (char *)attrs[i + 1]; 00172 } 00173 } 00174 00175 assert(model_id != NULL); 00176 assert(model_name != NULL); 00177 assert(vendor_id != NULL); 00178 00179 vendor_name = discover_xml_vendor_id2name(context->vendors, vendor_id); 00180 assert(vendor_name != NULL); 00181 00182 context->stack = discover_xml_stack_new(); 00183 00184 new_device = discover_device_new(); 00185 new_device->busclasses = context->busclasses; 00186 new_device->vendors = context->vendors; 00187 if (busclass) { 00188 new_device->busclass = _discover_xstrdup(busclass); 00189 } else { 00190 new_device->busclass = NULL; 00191 } 00192 new_device->model_id = _discover_xstrdup(model_id); 00193 new_device->model_name = _discover_xstrdup(model_name); 00194 new_device->vendor_id = _discover_xstrdup(vendor_id); 00195 new_device->vendor_name = _discover_xstrdup(vendor_name); 00196 new_device->data = NULL; 00197 new_device->next = NULL; 00198 00199 if (*(context->dhead)) { 00200 context->dtail->next = new_device; 00201 context->dtail = new_device; 00202 } else { 00203 *(context->dhead) = new_device; 00204 context->dtail = new_device; 00205 } 00206 } 00207 00208 static void 00209 create_data(struct context *context, const XML_Char *attrs[]) 00210 { 00211 discover_data_t *new_data, *current_data; 00212 discover_xml_stack *stack; 00213 int i; 00214 char *discover_class, *version; 00215 00216 assert(context != NULL); 00217 assert(attrs != NULL); 00218 00219 new_data = discover_data_new(); 00220 new_data->text = NULL; 00221 new_data->next = new_data->prev = new_data->child = NULL; 00222 00223 00224 discover_class = version = NULL; 00225 for (i = 0; attrs[i]; i += 2) { 00226 if (strcmp(attrs[i], "class") == 0) { 00227 discover_class = (char *)attrs[i + 1]; 00228 } else if (strcmp(attrs[i], "version") == 0) { 00229 version = (char *)attrs[i + 1]; 00230 } 00231 } 00232 00233 assert(discover_class != NULL); 00234 00235 new_data->discover_class = _discover_xstrdup(discover_class); 00236 if (version) { 00237 new_data->version = _discover_xstrdup(version); 00238 } 00239 00240 stack = context->stack; 00241 00242 assert(stack != NULL); 00243 00244 current_data = discover_xml_stack_get(stack); 00245 00246 if(current_data) { /* The first time through this, we have no data. */ 00247 /* First element of the list */ 00248 if(stack->depth > context->nesting) { 00249 discover_xml_stack_pop(&stack); 00250 //current_data = discover_xml_stack_pop(&stack); 00251 new_data->prev = current_data; 00252 new_data->prev->next = new_data; 00253 if(context->nesting) { 00254 new_data->parent = 00255 discover_xml_stack_getbynum(stack, context->nesting); 00256 } 00257 } else { 00258 /* Brand new child */ 00259 new_data->parent = current_data; 00260 new_data->parent->child = new_data; 00261 } 00262 } 00263 00264 discover_xml_stack_push(&stack, new_data); 00265 context->stack = stack; 00266 } 00267 00268 static void 00269 start_element(void *ctx, const XML_Char *name, const XML_Char *attrs[]) 00270 { 00271 struct context *context = ctx; 00272 00273 assert(context != NULL); 00274 assert(name != NULL); 00275 assert(attrs != NULL); 00276 00277 00278 if (unknown_device_element(name)) { 00279 context->unknown_level++; 00280 return; 00281 } 00282 00283 if (context->unknown_level > 0) { 00284 return; 00285 } 00286 00287 switch (context->state) { 00288 case FINISH: 00289 return; 00290 00291 case START: 00292 if (strcmp(name, "device") == 0) { 00293 context->state = DEVICE; 00294 create_device(context, attrs); 00295 } 00296 break; 00297 00298 case DEVICE: 00299 if (strcmp(name, "data") == 0) { 00300 context->nesting = context->last_nesting = 0; 00301 context->state = DATA; 00302 } 00303 /* Falls through */ 00304 00305 case DATA: 00306 if (strcmp(name, "data") == 0) { 00307 create_data(context, attrs); 00308 context->last_nesting = context->nesting; 00309 context->nesting++; 00310 } 00311 break; 00312 } 00313 } 00314 00315 static void 00316 end_element(void *ctx, const XML_Char *name) 00317 { 00318 struct context *context = ctx; 00319 discover_device_t *device; 00320 discover_data_t *current_data; 00321 discover_xml_stack *stack; 00322 00323 00324 assert(context != NULL); 00325 assert(name != NULL); 00326 00327 00328 if (unknown_device_element(name)) { 00329 context->unknown_level--; 00330 return; 00331 } 00332 00333 if (context->unknown_level > 0) { 00334 return; 00335 } 00336 00337 switch (context->state) { 00338 case FINISH: 00339 case START: 00340 break; 00341 00342 case DEVICE: 00343 context->state = START; 00344 device = context->dtail; 00345 stack = context->stack; 00346 current_data = discover_xml_stack_get(stack); 00347 device->data = discover_data_get_first(current_data); 00348 00349 while (discover_xml_stack_pop(&(context->stack))) ; 00350 discover_xml_stack_destroy(context->stack); 00351 context->stack = NULL; 00352 00353 break; 00354 00355 case DATA: 00356 context->nesting--; 00357 stack = context->stack; 00358 if((context->nesting + 2) <= stack->depth) { 00359 while((context->nesting + 1 < stack->depth) && 00360 stack->depth > 1) { 00361 discover_xml_stack_pop(&stack); 00362 } 00363 context->stack = stack; 00364 } 00365 00366 if (context->nesting == 0) { 00367 context->state = DEVICE; 00368 } 00369 } 00370 } 00371 00372 static void 00373 cdata(void *ctx, const XML_Char *data, int len) 00374 { 00375 struct context *context = ctx; 00376 size_t old_len; 00377 discover_data_t *current_data; 00378 00379 assert(context != NULL); 00380 assert(data != NULL); 00381 00382 if (context->state == DATA 00383 && context->nesting > context->last_nesting) { 00384 assert(context->stack != NULL); 00385 current_data = context->stack->data; 00386 assert(current_data != NULL); 00387 00388 if (!current_data->text) { 00389 old_len = 0; 00390 current_data->text = _discover_xmalloc(1); 00391 current_data->text[0] = '\0'; 00392 } else { 00393 old_len = strlen(current_data->text); 00394 } 00395 current_data->text 00396 = _discover_xrealloc(current_data->text, 00397 old_len + len + 1); 00398 strncat(current_data->text, 00399 (const char *)data, 00400 (unsigned int)len); 00401 } 00402 } 00403 00418 /* Sshh! Don't tell, but this doesn't actually do any merging at all. 00419 * Instead, it simply inserts newer entries at the front of the list, 00420 * meaning that device info found later supersedes info found earlier. 00421 * This gives the illusion of merging, but potentially wastes memory 00422 * with duplicates. 00423 */ 00424 void 00425 discover_xml_merge_device_url(discover_device_t **dlist, char *url, 00426 discover_xml_busclass_t *busclasses, 00427 discover_xml_vendor_t *vendors, 00428 discover_error_t *status) 00429 { 00430 XML_Parser parser; 00431 struct context context; 00432 00433 assert(url != NULL); 00434 assert(busclasses != NULL); 00435 assert(vendors != NULL); 00436 assert(status != NULL); 00437 00438 context.state = START; 00439 context.dhead = dlist; 00440 if (*(context.dhead)) { 00441 discover_device_t *next = *(context.dhead); 00442 while(next->next != NULL) { 00443 next = next->next; 00444 } 00445 context.dtail = next; 00446 } else { 00447 context.dtail = NULL; 00448 } 00449 00450 context.busclasses = busclasses; 00451 context.vendors = vendors; 00452 context.unknown_level = 0; 00453 context.stack = NULL; 00454 00455 parser = XML_ParserCreate(NULL); 00456 XML_SetElementHandler(parser, start_element, end_element); 00457 XML_SetCharacterDataHandler(parser, cdata); 00458 XML_SetUserData(parser, &context); 00459 00460 if (!_discover_load_url(url, parser)) { 00461 XML_ParserFree(parser); 00462 status->code = DISCOVER_EIO; 00463 return; 00464 } 00465 00466 if (!XML_Parse(parser, "", 0, 1)) { 00467 XML_ParserFree(parser); 00468 status->code = DISCOVER_EXML; 00469 return; 00470 } 00471 00472 XML_ParserFree(parser); 00473 00474 return; 00475 } 00476 00483 discover_device_t * 00484 discover_xml_get_devices(discover_bus_t bus, discover_error_t *status) 00485 { 00486 discover_xml_url_t *urls, *i; 00487 char *url; 00488 discover_xml_busclass_t *busclasses; 00489 discover_xml_vendor_t *vendors; 00490 00491 assert(status != NULL); 00492 00493 status->code = 0; 00494 00495 if (!devices_xml[bus]) { 00496 urls = discover_xml_get_data_urls(bus, DEVICE, status); 00497 if (status->code != 0) { 00498 return NULL; 00499 } 00500 00501 busclasses = discover_xml_get_busclasses(bus, status); 00502 if (status->code != 0) { 00503 return NULL; 00504 } 00505 00506 vendors = discover_xml_get_vendors(bus, status); 00507 if (status->code != 0) { 00508 return NULL; 00509 } 00510 00511 for (i = urls; 00512 i; 00513 i = discover_xml_url_get_next(i)) { 00514 url = discover_xml_url_get_url(i); 00515 discover_xml_merge_device_url(&(devices_xml[bus]), url, 00516 busclasses, vendors, status); 00517 if (status->code != 0) { 00518 get_data_failure_handler(&status, url); 00519 } 00520 } 00521 } 00522 00523 00524 return devices_xml[bus]; 00525 } 00526 00530 void 00531 discover_xml_free_devices(void) 00532 { 00533 int i; 00534 for (i = 0; i < BUS_COUNT; i++) { 00535 discover_device_free(devices_xml[i], 1); 00536 devices_xml[i] = NULL; 00537 } 00538 } 00539 00549 discover_device_t * 00550 discover_xml_find_device(discover_device_t *xml_devices, 00551 char *target_vendor, char *target_model, 00552 discover_error_t *status) 00553 { 00554 discover_device_t *device; 00555 00556 assert(target_vendor || target_model); 00557 00558 for (device = xml_devices; 00559 device; 00560 device = device->next) { 00561 if (target_vendor && target_model) { 00562 if (strcmp(device->model_id, target_model) == 0 00563 && strcmp(device->vendor_id, target_vendor) == 0) { 00564 break; 00565 } 00566 } else if (target_vendor) { 00567 if (strcmp(device->vendor_id, target_vendor) == 0) { 00568 break; 00569 } 00570 } else { 00571 /* We only have target_model. */ 00572 if (strcmp(device->model_id, target_model) == 0) { 00573 break; 00574 } 00575 } 00576 } 00577 00578 return device; 00579 } 00580 00593 discover_device_t * 00594 discover_xml_find_next_device(discover_device_t *xml_devices, 00595 char *target_vendor, char *target_model, 00596 discover_error_t *status) 00597 { 00598 return discover_xml_find_device(xml_devices->next, 00599 target_vendor, target_model, 00600 status); 00601 } 00602 00603 00613 discover_device_t * 00614 discover_xml_get_matching_devices(discover_device_t *xml_devices, 00615 char *target_vendor, char *target_model, 00616 discover_error_t *status) 00617 { 00618 discover_device_t *device, *last, *copy; 00619 discover_device_t *head_device = NULL; 00620 00621 device = discover_xml_find_device(xml_devices, target_vendor, 00622 target_model, status); 00623 last = NULL; 00624 00625 while(device) { 00626 copy = discover_device_new(); 00627 discover_device_copy(device, copy); 00628 copy->next = NULL; 00629 copy->extra = NULL; 00630 00631 if (last) { 00632 last->extra = copy; 00633 } else { 00634 head_device = copy; 00635 } 00636 00637 last = copy; 00638 00639 device = discover_xml_find_next_device(device, target_vendor, 00640 target_model, status); 00641 } 00642 00643 return head_device; 00644 } 00645 00648 /* 00649 * Local variables: 00650 * c-file-style: "progeny" 00651 * indent-tabs-mode: nil 00652 * End: 00653 */ 00654 /* vim: set cin fo=tcroq sw=4 et sts=4 tw=75: */
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/group__url__xml.html 0000644 0023421 0023421 00000056504 10655642004 022314 0 ustar pere pere
URL list XML parsing
Functions | |
| discover_xml_url_t * | discover_xml_get_urls (discover_error_t *status) |
| void | discover_xml_free_urls (void) |
| discover_xml_url_t * | discover_xml_get_data_urls (discover_bus_t bus, discover_filetype_t filetype, discover_error_t *status) |
| void | discover_xml_free_data_urls (void) |
| discover_xml_url_t * | discover_xml_url_new (void) |
| void | discover_xml_url_copy (discover_xml_url_t *src, discover_xml_url_t *dst) |
| char * | discover_xml_url_get_url (discover_xml_url_t *url) |
| char * | discover_xml_url_get_label (discover_xml_url_t *url) |
| char * | discover_xml_url_get_bus (discover_xml_url_t *url) |
| char * | discover_xml_url_get_type (discover_xml_url_t *url) |
| discover_xml_url_t * | discover_xml_url_get_next (discover_xml_url_t *url) |
| discover_xml_url_t * | discover_xml_url_get_last (discover_xml_url_t *url) |
| void | discover_xml_url_free (discover_xml_url_t *urls) |
Function Documentation
|
|
Free the list of data URLs. Definition at line 310 of file url-xml.c. References BUS_COUNT, and discover_xml_url_free(). |
|
|
Free the list of URLs. Definition at line 244 of file url-xml.c. References discover_xml_url_free(). |
|
||||||||||||||||
|
Get the list of data URLs, based on the bus type and type of data required.
Definition at line 261 of file url-xml.c. References discover_error::code, discover_conf_get_bus_name(), discover_conf_get_filetype_name(), DISCOVER_EDATANOTFOUND, discover_xml_get_urls(), discover_xml_url_copy(), and discover_xml_url_new(). Referenced by discover_xml_get_busclasses(), discover_xml_get_devices(), and discover_xml_get_vendors(). |
|
|
Get the list of URLs from which bus and device data will be retrieved.
Definition at line 182 of file url-xml.c. References discover_error::code, discover_conf_get_urls(), DISCOVER_EIO, DISCOVER_EXML, and discover_xml_url_free(). Referenced by discover_xml_get_data_urls(). |
|
||||||||||||
|
Copy a URL structure.
Definition at line 349 of file url-xml.c. Referenced by discover_xml_get_data_urls(). |
|
|
Free the URL or list of URLs.
Definition at line 444 of file url-xml.c. Referenced by discover_conf_free(), discover_xml_free_data_urls(), discover_xml_free_urls(), and discover_xml_get_urls(). |
|
|
Get the bus member of URL. |
|
|
Get the label member of url. |
|
|
Get the last member of url. |
|
|
Get the next member of url. Definition at line 420 of file url-xml.c. Referenced by discover_xml_get_busclasses(), discover_xml_get_devices(), and discover_xml_get_vendors(). |
|
|
Get the type member of url. |
|
|
Get the url member of url. Definition at line 376 of file url-xml.c. Referenced by discover_xml_get_busclasses(), discover_xml_get_devices(), and discover_xml_get_vendors(). |
|
|
Create and initialize a new (empty) URL structure. Definition at line 326 of file url-xml.c. Referenced by discover_conf_get_urls(), and discover_xml_get_data_urls(). |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/dir_000001.html 0000644 0023421 0023421 00000005361 10655642004 020471 0 ustar pere pere
discover Directory Reference
Files | |
| file | discover-conf.h [code] |
| Public interface for reading Discover configuration data. | |
| file | discover-xml.h [code] |
| Public interface to Discover's XML handling. | |
| file | discover.h [code] |
| Public interface for Discover library. | |
| file | sysdep.h [code] |
| Private interface for system dependencies. | |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/conf_8c-source.html 0000644 0023421 0023421 00000105444 10655642004 021733 0 ustar pere pere
conf.c
Go to the documentation of this file.00001 00012 /* $Progeny$ 00013 * 00014 * Copyright 2002-2005 Progeny Linux Systems, Inc. 00015 * Copyright 2002 Hewlett-Packard Company 00016 * 00017 * Permission is hereby granted, free of charge, to any person obtaining a 00018 * copy of this software and associated documentation files (the "Software"), 00019 * to deal in the Software without restriction, including without limitation 00020 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00021 * and/or sell copies of the Software, and to permit persons to whom the 00022 * Software is furnished to do so, subject to the following conditions: 00023 * 00024 * The above copyright notice and this permission notice shall be included in 00025 * all copies or substantial portions of the Software. 00026 * 00027 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00028 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00029 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00030 * THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00031 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 00032 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 00033 * DEALINGS IN THE SOFTWARE. 00034 */ 00035 00036 #include "config.h" 00037 00038 #if HAVE_DIRENT_H 00039 #include <dirent.h> 00040 #define NAMLEN(d) strlen((d)->d_name) 00041 #else 00042 #define dirent direct 00043 #define NAMLEN(d) (d)->d_namlen 00044 #if HAVE_SYS_NDIR_H 00045 #include <sys/ndir.h> 00046 #endif 00047 #if HAVE_SYS_DIR_H 00048 #include <sys/dir.h> 00049 #endif 00050 #if HAVE_NDIR_H 00051 #include <ndir.h> 00052 #endif 00053 #endif 00054 00055 #include <assert.h> 00056 #include <string.h> 00057 00058 #include <expat.h> 00059 00060 #include <discover/discover.h> 00061 #include <discover/discover-conf.h> 00062 #include <discover/discover-xml.h> 00063 00064 #include <discover/load-url.h> 00065 #include <discover/url-xml.h> 00066 #include <discover/utils.h> 00067 00068 /*Busmaps we understand 00069 */ 00070 static discover_bus_map_t bus_map[] = { 00071 { "ata", 0, 0, NULL }, 00072 { "pci", 0, 0, NULL }, 00073 { "pcmcia", 0, 0, NULL }, 00074 { "scsi", 0, 0, NULL }, 00075 { "usb", 0, 0, NULL }, 00076 { NULL } 00077 }; 00078 00079 static char * filetype_map[] = { 00080 "vendor", "busclass", "device" 00081 }; 00082 00083 static int conf_loaded = 0; 00084 00085 static discover_xml_url_t *pre_urls = NULL; 00086 static discover_xml_url_t *post_urls = NULL; 00087 static discover_xml_url_t *urls = NULL; 00088 00090 enum state { START, BUSSCAN, DATA_SOURCES }; 00091 00093 enum scan_flag { SCAN_NEVER, SCAN_DEFAULT }; 00094 00095 struct context { 00096 enum state state; 00097 enum scan_flag scan; 00098 discover_error_t *status; 00099 00100 int unknown_level; 00101 }; 00102 00103 static char *known_conf_elements[] = { 00104 "bus", 00105 "data-source", 00106 "busscan", 00107 "data-sources", 00108 "conffile", 00109 NULL 00110 }; 00111 00112 00113 static bool 00114 unknown_conf_element(const XML_Char * const tag) 00115 { 00116 int i; 00117 for (i = 0; known_conf_elements[i] != NULL; i++) { 00118 if (strcmp(tag, known_conf_elements[i]) == 0) 00119 return false; 00120 } 00121 return true; 00122 } 00123 00124 static enum scan_flag 00125 get_scan_flag(const XML_Char *attrs[]) 00126 { 00127 int i; 00128 char *scan; 00129 00130 assert(attrs != NULL); 00131 00132 scan = NULL; 00133 for (i = 0; attrs[i]; i+= 2) { 00134 if (strcmp(attrs[i], "scan") == 0) { 00135 scan = (char *)attrs[i + 1]; 00136 } 00137 } 00138 00139 assert(scan != NULL); 00140 00141 if (strcmp(scan, "default") == 0) { 00142 return SCAN_DEFAULT; 00143 } else { 00144 return SCAN_NEVER; 00145 } 00146 } 00147 00153 discover_bus_map_t * 00154 _real_discover_conf_get_bus_map(discover_bus_t bus, discover_error_t *status) 00155 { 00156 assert(status != NULL); 00157 assert(bus >= 0); 00158 00159 if (bus >= BUS_COUNT) { 00160 status->code = DISCOVER_EBUSNOTFOUND; 00161 } 00162 00163 return (discover_bus_map_t *)(bus_map + bus); 00164 } 00165 00167 discover_bus_map_t * 00168 _real_discover_conf_get_bus_map_by_name(char *name, discover_error_t *status) 00169 { 00170 discover_bus_t bus; 00171 00172 assert(status != NULL); 00173 00174 bus = discover_conf_name_to_bus(name, status); 00175 00176 if (status->code != 0) { 00177 return NULL; 00178 } 00179 00180 return _real_discover_conf_get_bus_map(bus, status); 00181 } 00182 00183 static void 00184 _real_discover_conf_insert_url(char *url, discover_error_t *status) 00185 { 00186 discover_xml_url_t *new; 00187 00188 assert(url != NULL); 00189 assert(status != NULL); 00190 00191 status->code = 0; 00192 00193 new = discover_xml_url_new(); 00194 new->url = _discover_xstrdup(url); 00195 00196 new->next = pre_urls; 00197 if (pre_urls) { 00198 if (pre_urls->last) { 00199 new->last = pre_urls->last; 00200 } else { 00201 new->last = pre_urls; 00202 } 00203 } else { 00204 new->last = NULL; 00205 } 00206 00207 pre_urls = new; 00208 } 00209 00210 static void 00211 _real_discover_conf_append_url(char *url, discover_error_t *status) 00212 { 00213 discover_xml_url_t *new; 00214 00215 assert(url != NULL); 00216 assert(status != NULL); 00217 00218 status->code = 0; 00219 00220 new = discover_xml_url_new(); 00221 new->url = _discover_xstrdup(url); 00222 00223 if (post_urls) { 00224 if (post_urls->last) { 00225 post_urls->last->next = new; 00226 } else { 00227 post_urls->next = new; 00228 } 00229 post_urls->last = new; 00230 } else { 00231 post_urls = new; 00232 post_urls->next = NULL; 00233 post_urls->last = NULL; 00234 } 00235 } 00236 00237 static void 00238 start_element(void *ctx, const XML_Char *name, const XML_Char *attrs[]) 00239 { 00240 struct context *context = ctx; 00241 discover_bus_map_t *busmap; 00242 discover_error_t *status; 00243 char *busname; 00244 char *found_url; 00245 int prepend_url; 00246 int i; 00247 00248 assert(context != NULL); 00249 assert(name != NULL); 00250 00251 if (unknown_conf_element(name)) { 00252 context->unknown_level++; 00253 return; 00254 } 00255 00256 if (context->unknown_level > 0) { 00257 return; 00258 } 00259 00260 status = context->status; 00261 00262 switch (context->state) { 00263 case START: 00264 if (strcmp(name, "busscan") == 0) { 00265 context->state = BUSSCAN; 00266 context->scan = get_scan_flag(attrs); 00267 } else if (strcmp(name, "data-sources") == 0) { 00268 context->state = DATA_SOURCES; 00269 } 00270 break; 00271 00272 case BUSSCAN: 00273 if (strcmp(name, "bus") == 0) { 00274 assert(attrs != NULL); 00275 00276 for (i = 0; attrs[i]; i += 2) { 00277 if (strcmp(attrs[i], "name") == 0) { 00278 busname = (char *)attrs[i + 1]; 00279 busmap = _real_discover_conf_get_bus_map_by_name(busname, status); 00280 if (status->code != 0) { 00281 return; 00282 } 00283 if (context->scan == SCAN_DEFAULT) { 00284 busmap->scan_default = 1; 00285 } else { 00286 busmap->scan_never = 1; 00287 } 00288 } 00289 } 00290 } 00291 break; 00292 00293 case DATA_SOURCES: 00294 if (strcmp(name, "data-source") == 0) { 00295 found_url = NULL; 00296 prepend_url = 0; 00297 for (i = 0; attrs[i]; i += 2) { 00298 if (strcmp(attrs[i], "url") == 0) { 00299 found_url = (char *)attrs[i + 1]; 00300 } 00301 else if ((strcmp(attrs[i], "place") == 0) && 00302 (strcmp(attrs[i + 1], "before") == 0)) { 00303 prepend_url = 1; 00304 } 00305 } 00306 if (found_url != NULL) { 00307 if (prepend_url != 0) { 00308 _real_discover_conf_insert_url(found_url, status); 00309 } else { 00310 _real_discover_conf_append_url(found_url, status); 00311 } 00312 if (status->code != 0) { 00313 return; 00314 } 00315 } 00316 } 00317 break; 00318 } 00319 } 00320 00321 static void 00322 end_element(void *ctx, const XML_Char *name) 00323 { 00324 struct context *context = ctx; 00325 00326 assert(context != NULL); 00327 assert(name != NULL); 00328 00329 if (unknown_conf_element(name)) { 00330 context->unknown_level--; 00331 return; 00332 } 00333 00334 if (context->unknown_level > 0) { 00335 return; 00336 } 00337 00338 switch (context->state) { 00339 case START: 00340 break; 00341 00342 case BUSSCAN: 00343 if (strcmp(name, "busscan") == 0) { 00344 context->state = START; 00345 } 00346 break; 00347 00348 case DATA_SOURCES: 00349 if (strcmp(name, "data-sources") == 0) { 00350 context->state = START; 00351 } 00352 break; 00353 } 00354 } 00355 00377 void 00378 discover_conf_load(discover_error_t *status) 00379 { 00380 XML_Parser parser; 00381 struct context context; 00382 int load_url_status; 00383 int conf_load_error = 0; 00384 int conf_parse_error = 0; 00385 DIR *confdir; 00386 struct dirent *confent; 00387 char buf[512]; 00388 00389 assert(status != NULL); 00390 00391 status->code = 0; 00392 00393 if (conf_loaded) { 00394 return; 00395 } 00396 00397 confdir = opendir(SYSCONFDIR "/discover.conf.d"); 00398 if (confdir != NULL) { 00399 while ((confent = readdir(confdir)) != NULL) { 00400 if (strchr(confent->d_name, '.') != NULL) { 00401 continue; 00402 } 00403 00404 context.state = START; 00405 context.status = status; 00406 context.unknown_level = 0; 00407 00408 parser = XML_ParserCreate(NULL); 00409 XML_SetElementHandler(parser, start_element, end_element); 00410 XML_SetUserData(parser, &context); 00411 00412 strcpy(buf, "file:///" SYSCONFDIR "/discover.conf.d/"); 00413 strncat(buf, confent->d_name, sizeof(buf)); 00414 buf[sizeof(buf) - 1] = '\0'; 00415 00416 load_url_status = _discover_load_url(buf, parser); 00417 00418 /* start_element may change status. */ 00419 if (status->code != 0) { 00420 char *message = _discover_xmalloc(256); 00421 snprintf(message, 256, "Error parsing configuration file %s", 00422 buf); 00423 status->create_message(&status, message); 00424 XML_ParserFree(parser); 00425 conf_parse_error = 1; 00426 break; 00427 } 00428 00429 /* Ignore URL load errors; the conf file is not mandatory. */ 00430 if (!load_url_status) { 00431 conf_load_error = 1; 00432 XML_ParserFree(parser); 00433 continue; 00434 } 00435 00436 if (!XML_Parse(parser, "", 0, 1)) { 00437 char *message = _discover_xmalloc(256); 00438 snprintf(message, 256, "Error parsing configuration file %s", 00439 buf); 00440 status->create_message(&status, message); 00441 status->code = DISCOVER_EXML; 00442 XML_ParserFree(parser); 00443 conf_parse_error = 1; 00444 break; 00445 } 00446 00447 00448 XML_ParserFree(parser); 00449 } 00450 00451 closedir(confdir); 00452 00453 if (conf_parse_error) { 00454 return; 00455 } 00456 } 00457 00458 if (conf_load_error) { 00459 char *message = _discover_xmalloc(256); 00460 snprintf(message, 256, 00461 "Failed loading one or more configuration files"); 00462 status->create_message(&status, message); 00463 } 00464 00465 conf_loaded = 1; 00466 00467 return; 00468 } 00469 00476 int 00477 discover_conf_name_to_bus(char *name, discover_error_t *status) 00478 { 00479 int i; 00480 for (i = 0; bus_map[i].name; i++) { 00481 if (strcmp(bus_map[i].name, name) == 0) { 00482 return i; 00483 } 00484 } 00485 00486 status->code = DISCOVER_EBUSNOTFOUND; 00487 return -1; 00488 } 00489 00495 discover_bus_map_t * 00496 discover_conf_get_full_bus_map(discover_error_t *status) 00497 { 00498 discover_conf_load(status); 00499 return bus_map; 00500 } 00501 00508 discover_bus_map_t * 00509 discover_conf_get_bus_map_by_name(char *name, discover_error_t *status) 00510 { 00511 assert(status != NULL); 00512 00513 discover_conf_load(status); 00514 if (status->code != 0) { 00515 return NULL; 00516 } 00517 00518 /* 00519 * The "real" one won't call conf_load(), which will be useful 00520 * elsewhere. 00521 */ 00522 return _real_discover_conf_get_bus_map_by_name(name, status); 00523 } 00524 00531 discover_bus_map_t * 00532 discover_conf_get_bus_map(discover_bus_t bus, discover_error_t *status) 00533 { 00534 assert(status != NULL); 00535 assert(bus >= 0); 00536 00537 if (bus >= BUS_COUNT) { 00538 status->code = DISCOVER_EBUSNOTFOUND; 00539 } 00540 00541 discover_conf_load(status); 00542 if (status->code != 0) { 00543 return NULL; 00544 } 00545 00546 return (discover_bus_map_t *)(bus_map + bus); 00547 } 00548 00556 void 00557 discover_conf_insert_url(char *url, discover_error_t *status) 00558 { 00559 assert(status != NULL); 00560 00561 discover_conf_load(status); 00562 if (status->code != 0) { 00563 return; 00564 } 00565 00566 _real_discover_conf_insert_url(url, status); 00567 00568 return; 00569 } 00570 00578 void 00579 discover_conf_append_url(char *url, discover_error_t *status) 00580 { 00581 assert(status != NULL); 00582 00583 discover_conf_load(status); 00584 if (status->code != 0) { 00585 return; 00586 } 00587 00588 _real_discover_conf_append_url(url, status); 00589 00590 return; 00591 } 00592 00598 discover_xml_url_t * 00599 discover_conf_get_urls(discover_error_t *status) 00600 { 00601 discover_xml_url_t *new; 00602 00603 assert(status != NULL); 00604 00605 status->code = 0; 00606 00607 if (!urls) { 00608 discover_conf_load(status); 00609 00610 new = discover_xml_url_new(); 00611 new->url = _discover_xstrdup(DISCOVER_DEFAULT_URL); 00612 00613 if (pre_urls) { 00614 urls = pre_urls; 00615 if (urls->last) { 00616 urls->last->next = new; 00617 } else { 00618 urls->next = new; 00619 } 00620 urls->last = new; 00621 } else { 00622 urls = new; 00623 } 00624 00625 if (post_urls) { 00626 if (urls->last) { 00627 urls->last->next = post_urls; 00628 } else { 00629 urls->next = post_urls; 00630 } 00631 00632 if (post_urls->last) { 00633 urls->last = post_urls->last; 00634 } else { 00635 urls->last = post_urls; 00636 } 00637 } 00638 00639 post_urls = pre_urls = NULL; 00640 } 00641 00642 return urls; 00643 } 00644 00649 void 00650 discover_conf_free(void) 00651 { 00652 conf_loaded = 0; 00653 00654 if (urls) { 00655 discover_xml_url_free(urls); 00656 urls = NULL; 00657 } 00658 } 00659 00665 char * 00666 discover_conf_get_bus_name(discover_bus_t bus) 00667 { 00668 assert(bus >= 0); 00669 if (bus >= BUS_COUNT) { 00670 return NULL; 00671 } 00672 00673 return bus_map[bus].name; 00674 } 00675 00681 char * 00682 discover_conf_get_filetype_name(discover_filetype_t filetype) 00683 { 00684 if (filetype >= 3) { 00685 return NULL; 00686 } 00687 00688 return filetype_map[filetype]; 00689 } 00690 00693 /* 00694 * Local variables: 00695 * c-file-style: "progeny" 00696 * indent-tabs-mode: nil 00697 * End: 00698 */ 00699 /* vim: set cin fo=tcroq sw=4 et sts=4 tw=75: */
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/discover-conf_8h-source.html 0000644 0023421 0023421 00000015174 10655642004 023554 0 ustar pere pere
discover-conf.h
Go to the documentation of this file.00001 00010 /* $Progeny$ 00011 * 00012 * Copyright 2002 Hewlett-Packard Company 00013 * 00014 * Permission is hereby granted, free of charge, to any person obtaining a 00015 * copy of this software and associated documentation files (the "Software"), 00016 * to deal in the Software without restriction, including without limitation 00017 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00018 * and/or sell copies of the Software, and to permit persons to whom the 00019 * Software is furnished to do so, subject to the following conditions: 00020 * 00021 * The above copyright notice and this permission notice shall be included in 00022 * all copies or substantial portions of the Software. 00023 * 00024 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00025 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00026 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00027 * THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00028 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 00029 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 00030 * DEALINGS IN THE SOFTWARE. 00031 */ 00032 00033 #ifndef DISCOVER_CONF_H 00034 #define DISCOVER_CONF_H 00035 00036 #include <discover/discover.h> 00037 00038 #ifdef __cplusplus 00039 extern "C" { 00040 #endif 00041 00042 void discover_conf_load(discover_error_t *status); 00043 discover_bus_map_t *discover_conf_get_full_bus_map(discover_error_t *status); 00044 discover_bus_map_t *discover_conf_get_bus_map(discover_bus_t bus, 00045 discover_error_t *status); 00046 discover_bus_map_t *discover_conf_get_bus_map_by_name(char *name, 00047 discover_error_t *status); 00048 00049 void discover_conf_insert_url(char *url, discover_error_t *status); 00050 void discover_conf_append_url(char *url, discover_error_t *status); 00051 discover_xml_url_t *discover_conf_get_urls(discover_error_t *status); 00052 void discover_conf_free(void); 00053 00054 char *discover_conf_get_bus_name(discover_bus_t bus); 00055 char *discover_conf_get_filetype_name(discover_filetype_t filetype); 00056 int discover_conf_name_to_bus(char *name, discover_error_t *status); 00057 00058 #ifdef __cplusplus 00059 } 00060 #endif 00061 00062 #endif
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/structdiscover__bus__map.html 0000644 0023421 0023421 00000014430 10655642004 024177 0 ustar pere pere
discover_bus_map Struct Reference
[Types]
#include <discover.h>
Data Fields | |
| char * | name |
| int | scan_default |
| int | scan_never |
| discover_sysdep_raw_func_t * | get_raw |
Detailed Description
Bus scanning information is loaded from the config file. The scan_default member may be set to 0 to avoid scanning a specified bus. If the scan_never flag is set, the bus will never be scanned; this behavior is controlled from the config file.The function pointer exists to allow client code to override the sysdeps; it is used by the unit tests provided with Discover.
Definition at line 178 of file discover.h.
Field Documentation
|
|
Function pointer that will acquire data Definition at line 186 of file discover.h. Referenced by discover_get_devices(). |
|
|
Human-readable name Definition at line 180 of file discover.h. Referenced by discover_conf_get_bus_name(). |
|
|
Boolean (sort of) defining the bus's default behavior Definition at line 182 of file discover.h. |
|
|
Never scan this bus if true Definition at line 184 of file discover.h. Referenced by discover_get_devices(). |
The documentation for this struct was generated from the following file:
- /home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/discover.h
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/discover-conf_8h.html 0000644 0023421 0023421 00000012511 10655642004 022246 0 ustar pere pere
discover-conf.h File Reference
Public interface for reading Discover configuration data. More...
#include <discover/discover.h>
Go to the source code of this file.
Functions | |
| void | discover_conf_load (discover_error_t *status) |
| discover_bus_map_t * | discover_conf_get_full_bus_map (discover_error_t *status) |
| discover_bus_map_t * | discover_conf_get_bus_map (discover_bus_t bus, discover_error_t *status) |
| discover_bus_map_t * | discover_conf_get_bus_map_by_name (char *name, discover_error_t *status) |
| void | discover_conf_insert_url (char *url, discover_error_t *status) |
| void | discover_conf_append_url (char *url, discover_error_t *status) |
| discover_xml_url_t * | discover_conf_get_urls (discover_error_t *status) |
| void | discover_conf_free (void) |
| char * | discover_conf_get_bus_name (discover_bus_t bus) |
| char * | discover_conf_get_filetype_name (discover_filetype_t filetype) |
| int | discover_conf_name_to_bus (char *name, discover_error_t *status) |
Detailed Description
Public interface for reading Discover configuration data.These routines are the public interface used to read the configuration data from the desired source. These interfaces are also used to alter the URLs searched for configuration data.
Definition in file discover-conf.h.
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/structdiscover__sysdep__device__data.html 0000644 0023421 0023421 00000013411 10655642004 026525 0 ustar pere pere
discover_sysdep_device_data Struct Reference
#include <sysdep.h>
Data Fields | |
| char * | path |
| char * | value |
| discover_sysdep_device_data * | next |
Detailed Description
Linked list node, used to return data specific to the sysdep/device in question, to be passed to the user under the "device" data path.
Definition at line 43 of file sysdep.h.
Field Documentation
|
|
Pointer to the next data node Definition at line 49 of file sysdep.h. Referenced by _discover_convert_device_data(), _discover_free_sysdep_device_data(), and _discover_sysdep_device_data_new(). |
|
|
String giving the path for the data (not including "device" Definition at line 45 of file sysdep.h. Referenced by _discover_convert_device_data(), _discover_free_sysdep_device_data(), and _discover_sysdep_device_data_new(). |
|
|
String with the data's value Definition at line 47 of file sysdep.h. Referenced by _discover_convert_device_data(), _discover_free_sysdep_device_data(), and _discover_sysdep_device_data_new(). |
The documentation for this struct was generated from the following file:
- /home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/sysdep.h
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/discover_8h.html 0000644 0023421 0023421 00000046513 10655642004 021334 0 ustar pere pere
discover.h File Reference
Public interface for Discover library. More...
#include <stdbool.h>
#include <discover/sysdep.h>
Go to the source code of this file.
Detailed Description
Public interface for Discover library.
Definition in file discover.h.
Function Documentation
|
|
Free the currently allocated memory holding the device information. Definition at line 301 of file sysdep.c. References BUS_COUNT, and discover_device_free(). |
|
||||||||||||
|
Function responsible for returning a devicelist of current devices Definition at line 206 of file sysdep.c. References _discover_convert_device_data(), _discover_free_sysdep_data(), discover_error::code, discover_conf_get_bus_map(), discover_device_new(), DISCOVER_EBUSDISABLED, DISCOVER_SUCCESS, discover_xml_get_devices(), discover_xml_get_matching_devices(), discover_bus_map::get_raw, and discover_bus_map::scan_never. Referenced by discover_device_find(). |
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/doxygen.png 0000644 0023421 0023421 00000002401 10655642004 020400 0 ustar pere pere ‰PNG
IHDR d - ok> gAMA ÖØÔOX2 tEXtSoftware Adobe ImageReadyqÉe< ]PLTE ǾÏ"&©ÈÎﶻÖÓÚú“¢Þ ¬à¶Âõ‡§ÕÙêÉÊÎáâæ{ŽÔ¡ëˆ™× ²ø§¬¹ÀÀ±ÝÝÎùùéõõçëëåED9×ÖËhg] _X<@:#mhUÿÿÿÝÀ1 tRNSÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ Ív ÿIDATxÚbC £: d#„„………h` @ ¡X",***LK ˆ.– ], ºX@t± €èb @ ÑÅ€ BµD„6– š%""´° € ˜% ˆ™B:H¢ˆ²Áf@• ˆRPy"K`\PbC(!II!h©…ëƒ(ñ„Ä!ꈬC„Ä…àl!0[X\J\$TMˆ(’>a$S„ Ù@ Ш@R.$‚¬LJBR¢‰AÌG1
¬ Â(Fȃ ÔPhhÁTÀ¢„%! `€&q°%u P ¹¢ ¬ € ¹CT$B¢à|‚ºW„¤Àl £!B`R$( …Ĉ‘’ž @ AÅ%ĤÄ%@,(—Ê‚Ú±%$ÁââRPmB U`1IˆYB 99€ \1 yCCCÿf"[N ' Ü=TGÈ’øl8˜^Kû5<êSæRɤ”%î@@ à›Ê
b1 qÅAXHˆ¸&ØB’R y n˜P„Ìã– 4A €€j¹€€ >Ü ˜ t!˜+(.ÈÅWQ±A2ÜÜMUÜ‚’’‚‚â `1 %`19€ F< 3cZÄ`óe!\ˆ DÈ+. 83‹³Àä¸!lYYA -6‚EJŠ¢V €@©žXXX 4„å
Ê@86Ð`RdB´€4I "Ý "–@xr ÊŒ‚ H€AÊ`—f ÉÈ°CŒ"X V0ɲ³C b@2…¬H
¬È“ p)!( ì‚ 0Ž4ˆ)(%RÁÎ ¶$€T Ê€¥Àþb‡b,sä Ð@7 À üÑ°‚Òî?f¥Ö—\PIx!I´¦"”Ȉ’3¨
QY˜ÿt^^ÛØgv- }>W JOAV`$&#”¦8ùøø8€\FF ›SFJ$ÂÆ€ÐÆŠÐ¡ä ˆ‰ÀÀ 4ª…Èäå -Á§‡ €H²…—ŸŸŸf ? ðâ5„ €k1 d‰,ŒÃ ³ƒ“€.€ "F™ËË€àñ‚½ÁIÈ€ "±Ù 4ÉH gx|‚f ©m)))9´.
aM Dƒ& ºX@t± €èb @ ÑÅ€ ¢‹% DK ˆ.– ], ºX@t± €èb @€ d`‚ɽSµO IEND®B`‚ discover-2.1.2/doc/api-reference/html/group__vendor__xml.html 0000644 0023421 0023421 00000041760 10655642004 023005 0 ustar pere pere
Vendor list XML parsing
Functions | |
| void | discover_xml_merge_vendor_url (discover_xml_vendor_t **vlist, char *url, discover_error_t *status) |
| discover_xml_vendor_t * | discover_xml_get_vendors (discover_bus_t bus, discover_error_t *status) |
| void | discover_xml_free_vendors (void) |
| char * | discover_xml_vendor_id2name (discover_xml_vendor_t *vendors, char *id) |
| char * | discover_xml_vendor_get_id (discover_xml_vendor_t *vendor) |
| char * | discover_xml_vendor_get_name (discover_xml_vendor_t *vendor) |
| discover_xml_vendor_t * | discover_xml_vendor_get_next (discover_xml_vendor_t *vendor) |
| discover_xml_vendor_t * | discover_xml_vendor_new (void) |
| void | discover_xml_vendor_free (discover_xml_vendor_t *vendors) |
Function Documentation
|
|
Free the list of vendors. Definition at line 248 of file vendor-xml.c. References BUS_COUNT, and discover_xml_vendor_free(). |
|
||||||||||||
|
Get the list of vendors by bus type.
Definition at line 215 of file vendor-xml.c. References discover_error::code, discover_xml_get_data_urls(), discover_xml_merge_vendor_url(), discover_xml_url_get_next(), and discover_xml_url_get_url(). Referenced by discover_xml_get_devices(). |
|
||||||||||||||||
|
Merge new vendors into a list.
Definition at line 173 of file vendor-xml.c. References discover_error::code, DISCOVER_EIO, and DISCOVER_EXML. Referenced by discover_xml_get_vendors(). |
|
|
Free the vendor or list of vendors.
Definition at line 342 of file vendor-xml.c. Referenced by discover_xml_free_vendors(). |
|
|
Get the id member of vendor. Definition at line 290 of file vendor-xml.c. |
|
|
Get the name member of vendor. Definition at line 301 of file vendor-xml.c. |
|
|
Get the next member of vendor. Definition at line 312 of file vendor-xml.c. |
|
||||||||||||
|
Convert a vendor ID to a human-readable string naming the vendor.
Definition at line 264 of file vendor-xml.c. |
|
|
Create and initialize a new discover_xml_vendor_t structure. Definition at line 323 of file vendor-xml.c. |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/group__sysdeps.html 0000644 0023421 0023421 00000017430 10655642004 022160 0 ustar pere pere
System-dependent interfaces
Functions | |
| discover_sysdep_data_t * | _discover_get_ata_raw (void) |
| discover_sysdep_data_t * | _discover_get_pci_raw (void) |
| discover_sysdep_data_t * | _discover_get_pcmcia_raw (void) |
| discover_sysdep_data_t * | _discover_get_scsi_raw (void) |
| discover_sysdep_data_t * | _discover_get_usb_raw (void) |
Function Documentation
|
|
Get the list of ATA devices, scanning the bus if necessary. |
|
|
Get the list of PCI devices, scanning the bus if necessary. |
|
|
Get the list of PCMCIA devices, scanning the bus if necessary. |
|
|
Get the list of SCSI devices, scanning the bus if necessary. |
|
|
Get the list of USB devices, scanning the bus if necessary. |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/group__version__cmp.html 0000644 0023421 0023421 00000007261 10655642004 023152 0 ustar pere pere
Version comparison
Functions | |
| int | discover_xml_version_cmp (char *range, char *version, discover_error_t *status) |
Function Documentation
|
||||||||||||||||
|
Compare a version number against a version range, returning 1 if the number matches the range or 0 if not.
Definition at line 438 of file version-cmp.c. References discover_error::code, and DISCOVER_EBADVERSION. |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/stubs_8c-source.html 0000644 0023421 0023421 00000013423 10655642004 022141 0 ustar pere pere
stubs.c
Go to the documentation of this file.00001 /* $Progeny$ */ 00002 00012 /* stubs.c -- Stubs for Discover device scan routines 00013 * 00014 * Copyright 2002 Progeny Linux Systems, Inc. 00015 * Copyright 2002 Hewlett-Packard Company 00016 * 00017 * Permission is hereby granted, free of charge, to any person obtaining a 00018 * copy of this software and associated documentation files (the "Software"), 00019 * to deal in the Software without restriction, including without limitation 00020 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00021 * and/or sell copies of the Software, and to permit persons to whom the 00022 * Software is furnished to do so, subject to the following conditions: 00023 * 00024 * The above copyright notice and this permission notice shall be included in 00025 * all copies or substantial portions of the Software. 00026 * 00027 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00028 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00029 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00030 * THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00031 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 00032 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 00033 * DEALINGS IN THE SOFTWARE. 00034 */ 00035 00036 #include <config.h> 00037 00038 #include <sysdep.h> 00039 00040 #include <stdio.h> /* For NULL */ 00041 00050 discover_sysdep_data_t * 00051 _discover_get_ata_raw(void) 00052 { 00053 return NULL; 00054 } 00055 00059 discover_sysdep_data_t * 00060 _discover_get_pci_raw(void) 00061 { 00062 return NULL; 00063 } 00064 00068 discover_sysdep_data_t * 00069 _discover_get_pcmcia_raw(void) 00070 { 00071 return NULL; 00072 } 00073 00077 discover_sysdep_data_t * 00078 _discover_get_scsi_raw(void) 00079 { 00080 return NULL; 00081 } 00082 00086 discover_sysdep_data_t * 00087 _discover_get_usb_raw(void) 00088 { 00089 return NULL; 00090 } 00091 00094 /* 00095 * Local variables: 00096 * c-file-style: "progeny" 00097 * indent-tabs-mode: nil 00098 * End: 00099 */ 00100 /* vim: set cin fo=tcroq sw=4 et sts=4 tw=75: */
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/doxygen.css 0000644 0023421 0023421 00000016045 10655642004 020415 0 ustar pere pere BODY,H1,H2,H3,H4,H5,H6,P,CENTER,TD,TH,UL,DL,DIV {
font-family: Geneva, Arial, Helvetica, sans-serif;
}
BODY,TD {
font-size: 90%;
}
H1 {
text-align: center;
font-size: 160%;
}
H2 {
font-size: 120%;
}
H3 {
font-size: 100%;
}
CAPTION { font-weight: bold }
DIV.qindex {
width: 100%;
background-color: #eeeeff;
border: 1px solid #b0b0b0;
text-align: center;
margin: 2px;
padding: 2px;
line-height: 140%;
}
DIV.nav {
width: 100%;
background-color: #eeeeff;
border: 1px solid #b0b0b0;
text-align: center;
margin: 2px;
padding: 2px;
line-height: 140%;
}
DIV.navtab {
background-color: #eeeeff;
border: 1px solid #b0b0b0;
text-align: center;
margin: 2px;
margin-right: 15px;
padding: 2px;
}
TD.navtab {
font-size: 70%;
}
A.qindex {
text-decoration: none;
font-weight: bold;
color: #1A419D;
}
A.qindex:visited {
text-decoration: none;
font-weight: bold;
color: #1A419D
}
A.qindex:hover {
text-decoration: none;
background-color: #ddddff;
}
A.qindexHL {
text-decoration: none;
font-weight: bold;
background-color: #6666cc;
color: #ffffff;
border: 1px double #9295C2;
}
A.qindexHL:hover {
text-decoration: none;
background-color: #6666cc;
color: #ffffff;
}
A.qindexHL:visited { text-decoration: none; background-color: #6666cc; color: #ffffff }
A.el { text-decoration: none; font-weight: bold }
A.elRef { font-weight: bold }
A.code:link { text-decoration: none; font-weight: normal; color: #0000FF}
A.code:visited { text-decoration: none; font-weight: normal; color: #0000FF}
A.codeRef:link { font-weight: normal; color: #0000FF}
A.codeRef:visited { font-weight: normal; color: #0000FF}
A:hover { text-decoration: none; background-color: #f2f2ff }
DL.el { margin-left: -1cm }
.fragment {
font-family: Fixed, monospace;
font-size: 95%;
}
PRE.fragment {
border: 1px solid #CCCCCC;
background-color: #f5f5f5;
margin-top: 4px;
margin-bottom: 4px;
margin-left: 2px;
margin-right: 8px;
padding-left: 6px;
padding-right: 6px;
padding-top: 4px;
padding-bottom: 4px;
}
DIV.ah { background-color: black; font-weight: bold; color: #ffffff; margin-bottom: 3px; margin-top: 3px }
TD.md { background-color: #F4F4FB; font-weight: bold; }
TD.mdPrefix {
background-color: #F4F4FB;
color: #606060;
font-size: 80%;
}
TD.mdname1 { background-color: #F4F4FB; font-weight: bold; color: #602020; }
TD.mdname { background-color: #F4F4FB; font-weight: bold; color: #602020; width: 600px; }
DIV.groupHeader {
margin-left: 16px;
margin-top: 12px;
margin-bottom: 6px;
font-weight: bold;
}
DIV.groupText { margin-left: 16px; font-style: italic; font-size: 90% }
BODY {
background: white;
color: black;
margin-right: 20px;
margin-left: 20px;
}
TD.indexkey {
background-color: #eeeeff;
font-weight: bold;
padding-right : 10px;
padding-top : 2px;
padding-left : 10px;
padding-bottom : 2px;
margin-left : 0px;
margin-right : 0px;
margin-top : 2px;
margin-bottom : 2px;
border: 1px solid #CCCCCC;
}
TD.indexvalue {
background-color: #eeeeff;
font-style: italic;
padding-right : 10px;
padding-top : 2px;
padding-left : 10px;
padding-bottom : 2px;
margin-left : 0px;
margin-right : 0px;
margin-top : 2px;
margin-bottom : 2px;
border: 1px solid #CCCCCC;
}
TR.memlist {
background-color: #f0f0f0;
}
P.formulaDsp { text-align: center; }
IMG.formulaDsp { }
IMG.formulaInl { vertical-align: middle; }
SPAN.keyword { color: #008000 }
SPAN.keywordtype { color: #604020 }
SPAN.keywordflow { color: #e08000 }
SPAN.comment { color: #800000 }
SPAN.preprocessor { color: #806020 }
SPAN.stringliteral { color: #002080 }
SPAN.charliteral { color: #008080 }
.mdTable {
border: 1px solid #868686;
background-color: #F4F4FB;
}
.mdRow {
padding: 8px 10px;
}
.mdescLeft {
padding: 0px 8px 4px 8px;
font-size: 80%;
font-style: italic;
background-color: #FAFAFA;
border-top: 1px none #E0E0E0;
border-right: 1px none #E0E0E0;
border-bottom: 1px none #E0E0E0;
border-left: 1px none #E0E0E0;
margin: 0px;
}
.mdescRight {
padding: 0px 8px 4px 8px;
font-size: 80%;
font-style: italic;
background-color: #FAFAFA;
border-top: 1px none #E0E0E0;
border-right: 1px none #E0E0E0;
border-bottom: 1px none #E0E0E0;
border-left: 1px none #E0E0E0;
margin: 0px;
}
.memItemLeft {
padding: 1px 0px 0px 8px;
margin: 4px;
border-top-width: 1px;
border-right-width: 1px;
border-bottom-width: 1px;
border-left-width: 1px;
border-top-color: #E0E0E0;
border-right-color: #E0E0E0;
border-bottom-color: #E0E0E0;
border-left-color: #E0E0E0;
border-top-style: solid;
border-right-style: none;
border-bottom-style: none;
border-left-style: none;
background-color: #FAFAFA;
font-size: 80%;
}
.memItemRight {
padding: 1px 8px 0px 8px;
margin: 4px;
border-top-width: 1px;
border-right-width: 1px;
border-bottom-width: 1px;
border-left-width: 1px;
border-top-color: #E0E0E0;
border-right-color: #E0E0E0;
border-bottom-color: #E0E0E0;
border-left-color: #E0E0E0;
border-top-style: solid;
border-right-style: none;
border-bottom-style: none;
border-left-style: none;
background-color: #FAFAFA;
font-size: 80%;
}
.memTemplItemLeft {
padding: 1px 0px 0px 8px;
margin: 4px;
border-top-width: 1px;
border-right-width: 1px;
border-bottom-width: 1px;
border-left-width: 1px;
border-top-color: #E0E0E0;
border-right-color: #E0E0E0;
border-bottom-color: #E0E0E0;
border-left-color: #E0E0E0;
border-top-style: none;
border-right-style: none;
border-bottom-style: none;
border-left-style: none;
background-color: #FAFAFA;
font-size: 80%;
}
.memTemplItemRight {
padding: 1px 8px 0px 8px;
margin: 4px;
border-top-width: 1px;
border-right-width: 1px;
border-bottom-width: 1px;
border-left-width: 1px;
border-top-color: #E0E0E0;
border-right-color: #E0E0E0;
border-bottom-color: #E0E0E0;
border-left-color: #E0E0E0;
border-top-style: none;
border-right-style: none;
border-bottom-style: none;
border-left-style: none;
background-color: #FAFAFA;
font-size: 80%;
}
.memTemplParams {
padding: 1px 0px 0px 8px;
margin: 4px;
border-top-width: 1px;
border-right-width: 1px;
border-bottom-width: 1px;
border-left-width: 1px;
border-top-color: #E0E0E0;
border-right-color: #E0E0E0;
border-bottom-color: #E0E0E0;
border-left-color: #E0E0E0;
border-top-style: solid;
border-right-style: none;
border-bottom-style: none;
border-left-style: none;
color: #606060;
background-color: #FAFAFA;
font-size: 80%;
}
.search { color: #003399;
font-weight: bold;
}
FORM.search {
margin-bottom: 0px;
margin-top: 0px;
}
INPUT.search { font-size: 75%;
color: #000080;
font-weight: normal;
background-color: #eeeeff;
}
TD.tiny { font-size: 75%;
}
a {
color: #252E78;
}
a:visited {
color: #3D2185;
}
.dirtab { padding: 4px;
border-collapse: collapse;
border: 1px solid #b0b0b0;
}
TH.dirtab { background: #eeeeff;
font-weight: bold;
}
HR { height: 1px;
border: none;
border-top: 1px solid black;
}
discover-2.1.2/doc/api-reference/html/sysdep_8h.html 0000644 0023421 0023421 00000030630 10655642004 021016 0 ustar pere pere
sysdep.h File Reference
Private interface for system dependencies. More...
Go to the source code of this file.
Typedefs | |
| typedef discover_sysdep_device_data | discover_sysdep_device_data_t |
| typedef discover_sysdep_data | discover_sysdep_data_t |
Functions | |
| discover_sysdep_data_t * | _discover_sysdep_data_new (void) |
| discover_sysdep_device_data_t * | _discover_sysdep_device_data_new (void) |
| void | _discover_free_sysdep_data (discover_sysdep_data_t *) |
| void | _discover_free_sysdep_device_data (discover_sysdep_device_data_t *) |
| discover_sysdep_data_t * | _discover_get_ata_raw (void) |
| discover_sysdep_data_t * | _discover_get_pci_raw (void) |
| discover_sysdep_data_t * | _discover_get_usb_raw (void) |
| discover_sysdep_data_t * | _discover_get_pcmcia_raw (void) |
| discover_sysdep_data_t * | _discover_get_scsi_raw (void) |
Detailed Description
Private interface for system dependencies.
Definition in file sysdep.h.
Typedef Documentation
|
|
Linked list node, used to return hardware-identification information discovered by the system-dependent interface |
|
|
Linked list node, used to return data specific to the sysdep/device in question, to be passed to the user under the "device" data path. |
Function Documentation
|
|
Release the memory that the sysdep data was holding. Definition at line 92 of file sysdep.c. References _discover_free_sysdep_device_data(), discover_sysdep_data::busclass, discover_sysdep_data::data, discover_sysdep_data::model, discover_sysdep_data::next, and discover_sysdep_data::vendor. Referenced by discover_get_devices(). |
|
|
Release memory being held by device-specific data. Definition at line 117 of file sysdep.c. References discover_sysdep_device_data::next, discover_sysdep_device_data::path, and discover_sysdep_device_data::value. Referenced by _discover_free_sysdep_data(). |
|
|
Create a new instance of sysdep data. Definition at line 66 of file sysdep.c. References discover_sysdep_data::busclass, discover_sysdep_data::data, discover_sysdep_data::model, discover_sysdep_data::next, and discover_sysdep_data::vendor. |
|
|
Create a new instance of sysdep device data. Definition at line 80 of file sysdep.c. References discover_sysdep_device_data::next, discover_sysdep_device_data::path, and discover_sysdep_device_data::value. |
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/functions_rela.html 0000644 0023421 0023421 00000002703 10655642004 022123 0 ustar pere pere
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/core_8c-source.html 0000644 0023421 0023421 00000020424 10655642004 021730 0 ustar pere pere
core.c
Go to the documentation of this file.00001 00011 /* $Progeny$ 00012 * 00013 * Copyright 2002 Progeny Linux Systems, Inc. 00014 * Copyright 2002 Hewlett-Packard Company 00015 * 00016 * Permission is hereby granted, free of charge, to any person obtaining a 00017 * copy of this software and associated documentation files (the "Software"), 00018 * to deal in the Software without restriction, including without limitation 00019 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00020 * and/or sell copies of the Software, and to permit persons to whom the 00021 * Software is furnished to do so, subject to the following conditions: 00022 * 00023 * The above copyright notice and this permission notice shall be included in 00024 * all copies or substantial portions of the Software. 00025 * 00026 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00027 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00028 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00029 * THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00030 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 00031 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 00032 * DEALINGS IN THE SOFTWARE. 00033 */ 00034 00035 #include "config.h" 00036 00037 #include <assert.h> 00038 00039 #include <discover/discover.h> 00040 #include <discover/discover-xml.h> 00041 00042 #include <discover/utils.h> 00043 00044 static char *discover_errlist[] = { 00045 N_("Success."), 00046 N_("Input/output error."), 00047 N_("XML parsing error."), 00048 N_("System error."), 00049 N_("Disabled bus."), 00050 N_("Bus not found."), 00051 N_("Data source not found."), 00052 N_("Device not found."), 00053 N_("Invalid version range."), 00054 N_("Not implemented.") 00055 }; 00056 static int 00057 discover_nerr = sizeof(discover_errlist) / sizeof(discover_errlist[0]); 00058 00067 discover_error_t * 00068 discover_error_new(void) 00069 { 00070 discover_error_t *status = _discover_xmalloc(sizeof(discover_error_t)); 00071 status->code = 0; 00072 status->message = NULL; 00073 status->create_message = _discover_create_message; 00074 return status; 00075 } 00076 00081 void * 00082 _discover_create_message(discover_error_t **status, char *message) 00083 { 00084 if((*status)->message) { 00085 free((*status)->message); 00086 } 00087 (*status)->message = _discover_xmalloc(strlen(message) + 1); 00088 strcpy((*status)->message, message); 00089 } 00090 00094 void 00095 discover_error_free(discover_error_t *status) 00096 { 00097 assert(status != NULL); 00098 if (status->message != NULL) { 00099 free(status->message); 00100 } 00101 free(status); 00102 } 00103 00110 char * 00111 discover_strerror(discover_error_t *err) 00112 { 00113 assert(err != NULL); 00114 assert(err->code >= 0); 00115 assert(err->code < discover_nerr); 00116 00117 return _(discover_errlist[err->code]); 00118 } 00119 00123 int 00124 discover_major_version(void) 00125 { 00126 return PACKAGE_MAJOR; 00127 } 00128 00132 int 00133 discover_minor_version(void) 00134 { 00135 return PACKAGE_MINOR; 00136 } 00137 00141 int 00142 discover_micro_version(void) 00143 { 00144 return PACKAGE_MICRO; 00145 } 00146
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/load-url_8c-source.html 0000644 0023421 0023421 00000016125 10655642004 022522 0 ustar pere pere
load-url.c
Go to the documentation of this file.00001 00006 /* $Progeny$ 00007 * 00008 * Copyright 2003 Hewlett-Packard Company 00009 * 00010 * Permission is hereby granted, free of charge, to any person obtaining a 00011 * copy of this software and associated documentation files (the "Software"), 00012 * to deal in the Software without restriction, including without limitation 00013 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00014 * and/or sell copies of the Software, and to permit persons to whom the 00015 * Software is furnished to do so, subject to the following conditions: 00016 * 00017 * The above copyright notice and this permission notice shall be included in 00018 * all copies or substantial portions of the Software. 00019 * 00020 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00021 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00022 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00023 * THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00024 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 00025 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 00026 * DEALINGS IN THE SOFTWARE. 00027 */ 00028 00029 #include "config.h" 00030 00031 #ifndef HAVE_LIBCURL 00032 00033 #include <assert.h> 00034 #include <expat.h> 00035 00036 #include <discover/load-url.h> 00037 00038 #ifdef HAVE_ZLIB 00039 #include <zlib.h> 00040 #define stdio_file gzFile 00041 #define fopen gzopen 00042 #define STDIO_READ fread 00043 #define fclose gzclose 00044 #else 00045 #include <stdio.h> 00046 typedef FILE *stdio_file; 00047 #define STDIO_READ(f, buf, len) fread(buf, 1, len, f) 00048 #endif 00049 00050 #include <string.h> 00051 00052 int 00053 _discover_load_url(const char *url, XML_Parser parser) 00054 { 00055 const char *file_path; 00056 stdio_file url_file; 00057 char buf[4096]; 00058 char *tmp; 00059 size_t len; 00060 int parse_result; 00061 00062 assert(url != NULL); 00063 00064 if (strncmp(url, "file:", 5)) 00065 return 0; 00066 00067 /* We have three accepted formats for the url: file://host/path, 00068 * file:///path, and file://path. The third is not actually 00069 * legal, but curl allows it to refer to a file in the current 00070 * directory. Since we use that format in the test suite, we need 00071 * to support it here. 00072 * 00073 * For file://host/path and file:///path, the strchr call takes us 00074 * directly to the correct absolute path. For file://path, url + 00075 * 7 is just "path" so we use that relative path. */ 00076 file_path = strchr(url + 7, '/'); 00077 if (!file_path) { 00078 file_path = url + 7; 00079 } 00080 00081 if (*file_path == '\0') 00082 return 0; 00083 00084 url_file = fopen(file_path, "r"); 00085 if (url_file == NULL) 00086 return 0; 00087 00088 do 00089 { 00090 len = STDIO_READ(url_file, buf, sizeof(buf)); 00091 if (len > 0) 00092 parse_result = XML_Parse(parser, buf, len, 0); 00093 } while ((len > 0) && (parse_result != 0)); 00094 00095 fclose(url_file); 00096 00097 return (parse_result != 0); 00098 } 00099 00100 #endif
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/annotated.html 0000644 0023421 0023421 00000003203 10655642004 021061 0 ustar pere pere
discover Data Structures
Here are the data structures with brief descriptions:| discover_bus_map | |
| discover_error | |
| discover_sysdep_data | |
| discover_sysdep_device_data |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/group__device__xml.html 0000644 0023421 0023421 00000046130 10655642004 022743 0 ustar pere pere
Device list XML parsing
Functions | |
| void | discover_xml_merge_device_url (discover_device_t **dlist, char *url, discover_xml_busclass_t *busclasses, discover_xml_vendor_t *vendors, discover_error_t *status) |
| discover_device_t * | discover_xml_get_devices (discover_bus_t bus, discover_error_t *status) |
| void | discover_xml_free_devices (void) |
| discover_device_t * | discover_xml_find_device (discover_device_t *xml_devices, char *target_vendor, char *target_model, discover_error_t *status) |
| discover_device_t * | discover_xml_find_next_device (discover_device_t *xml_devices, char *target_vendor, char *target_model, discover_error_t *status) |
| discover_device_t * | discover_xml_get_matching_devices (discover_device_t *xml_devices, char *target_vendor, char *target_model, discover_error_t *status) |
Function Documentation
|
||||||||||||||||||||
|
Find the first device in xml_devices matching target_vendor and/or target_model. (One or both can be specified, but not zero.)
Definition at line 550 of file device-xml.c. Referenced by discover_xml_find_next_device(), and discover_xml_get_matching_devices(). |
|
||||||||||||||||||||
|
Find the next device in xml_devices matching target_vendor and/or target_model. (One or both can be specified, but not zero.) The first device in the list is assumed to have been processed, so we simply call discover_xml_find_device() on the next pointer.
Definition at line 594 of file device-xml.c. References discover_xml_find_device(). Referenced by discover_xml_get_matching_devices(). |
|
|
Free the list of XML devices. Definition at line 531 of file device-xml.c. References BUS_COUNT, and discover_device_free(). |
|
||||||||||||
|
Get the list of devices for the required bus.
Definition at line 484 of file device-xml.c. References discover_error::code, discover_xml_get_busclasses(), discover_xml_get_data_urls(), discover_xml_get_vendors(), discover_xml_merge_device_url(), discover_xml_url_get_next(), and discover_xml_url_get_url(). Referenced by discover_get_devices(). |
|
||||||||||||||||||||
|
Find and duplicate all devices in xml_devices matching target_vendor and/or target_model. (One or both can be specified, but not zero.)
Definition at line 614 of file device-xml.c. References discover_device_copy(), discover_device_new(), discover_xml_find_device(), and discover_xml_find_next_device(). Referenced by discover_get_devices(). |
|
||||||||||||||||||||||||
|
Merge new busclasses into a list.
Definition at line 425 of file device-xml.c. References discover_error::code, DISCOVER_EIO, and DISCOVER_EXML. Referenced by discover_xml_get_devices(). |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/group__core.html 0000644 0023421 0023421 00000025570 10655642004 021422 0 ustar pere pere
Core functionality
Functions | |
| discover_error_t * | discover_error_new (void) |
| void * | _discover_create_message (discover_error_t **status, char *message) |
| void | discover_error_free (discover_error_t *status) |
| char * | discover_strerror (discover_error_t *err) |
| int | discover_major_version (void) |
| int | discover_minor_version (void) |
| int | discover_micro_version (void) |
Function Documentation
|
||||||||||||
|
Allocate memory for a char * variable. This routine was written for discover_error_t struct. Definition at line 82 of file core.c. Referenced by discover_error_new(). |
|
|
Free a discover_error_t structure. Definition at line 95 of file core.c. References discover_error::message. |
|
|
Allocate and initialize a discover_error_t structure. Definition at line 68 of file core.c. References _discover_create_message(), discover_error::code, discover_error::create_message, and discover_error::message. |
|
|
Get the major version number. |
|
|
Get the micro version number. |
|
|
Get the minor version number. |
|
|
Convert an error code to a human-readable string localized according to the current locale (XXX: no i18n yet).
Definition at line 111 of file core.c. References discover_error::code. |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/conf_8c.html 0000644 0023421 0023421 00000031126 10655642004 020430 0 ustar pere pere
conf.c File Reference
Configuration handling (including XML parsing). More...
#include "config.h"
#include <assert.h>
#include <string.h>
#include <expat.h>
#include <discover/discover.h>
#include <discover/discover-conf.h>
#include <discover/discover-xml.h>
#include <discover/load-url.h>
#include <discover/url-xml.h>
#include <discover/utils.h>
Go to the source code of this file.
Detailed Description
Configuration handling (including XML parsing).Configuration-related data is handled here. This file is responsible for loading and parsing the XML data read from the configuration file. This file also holds the routines that are responsible for altering the URL list as requested by the caller.
Definition in file conf.c.
Enumeration Type Documentation
|
|
Define the values for a scannable bus. |
|
|
Describe the current state within the XML structure. |
Function Documentation
|
||||||||||||
|
Function that loads the bus map The "real" get_bus_map functions don't call conf_load(), which is important to avoid infinite loops. Definition at line 154 of file conf.c. References BUS_COUNT, discover_error::code, and DISCOVER_EBUSNOTFOUND. Referenced by _real_discover_conf_get_bus_map_by_name(). |
|
||||||||||||
|
Internal function that really loads the bus map Definition at line 168 of file conf.c. References _real_discover_conf_get_bus_map(), discover_error::code, and discover_conf_name_to_bus(). Referenced by discover_conf_get_bus_map_by_name(). |
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/globals_type.html 0000644 0023421 0023421 00000005534 10655642004 021601 0 ustar pere pere
- discover_bus_map_t : discover.h
- discover_create_message_t : discover.h
- discover_data_t : discover.h
- discover_device_func_t : discover.h
- discover_device_t : discover.h
- discover_error_t : discover.h
- discover_free_func_t : discover.h
- discover_sysdep_data_t : sysdep.h
- discover_sysdep_device_data_t : sysdep.h
- discover_sysdep_raw_func_t : discover.h
- discover_xml_busclass_func_t : discover.h
- discover_xml_busclass_t : discover.h
- discover_xml_url_func_t : discover.h
- discover_xml_url_t : discover.h
- discover_xml_vendor_func_t : discover.h
- discover_xml_vendor_t : discover.h
- range_state : version-cmp.c
- raw_sysdep_function_t : sysdep.c
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/discover-xml_8h-source.html 0000644 0023421 0023421 00000037532 10655642004 023431 0 ustar pere pere
discover-xml.h
Go to the documentation of this file.00001 00010 /* $Progeny$ 00011 * 00012 * AUTHOR: John R. Daily <jdaily@progeny.com> 00013 * 00014 * Copyright 2002 Hewlett-Packard Company 00015 * Copyright 2002 Progeny Linux Systems, Inc. 00016 * 00017 * Permission is hereby granted, free of charge, to any person obtaining a 00018 * copy of this software and associated documentation files (the "Software"), 00019 * to deal in the Software without restriction, including without limitation 00020 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00021 * and/or sell copies of the Software, and to permit persons to whom the 00022 * Software is furnished to do so, subject to the following conditions: 00023 * 00024 * The above copyright notice and this permission notice shall be included in 00025 * all copies or substantial portions of the Software. 00026 * 00027 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00028 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00029 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00030 * THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00031 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 00032 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 00033 * DEALINGS IN THE SOFTWARE. 00034 */ 00035 00036 #ifndef DISCOVER_XML_H 00037 #define DISCOVER_XML_H 00038 00039 #include <discover/discover.h> 00040 00041 #ifdef __cplusplus 00042 extern "C" { 00043 #endif 00044 00045 discover_device_t * 00046 discover_xml_find_device(discover_device_t *xml_devices, 00047 char *target_vendor, char *target_model, 00048 discover_error_t *status); 00049 discover_device_t * 00050 discover_xml_find_next_device(discover_device_t *xml_devices, 00051 char *target_vendor, char *target_model, 00052 discover_error_t *status); 00053 00054 discover_device_t * 00055 discover_xml_get_matching_devices(discover_device_t *xml_devices, 00056 char *target_vendor, char *target_model, 00057 discover_error_t *status); 00058 00059 int discover_xml_version_cmp(char *range, char *version, 00060 discover_error_t *status); 00061 00062 /****************************************************************************** 00063 * url 00064 */ 00065 00066 discover_xml_url_t *discover_xml_url_new(void); 00067 void discover_xml_url_copy(discover_xml_url_t *src, discover_xml_url_t *dst); 00068 void discover_xml_url_free(discover_xml_url_t *urls); 00069 00070 char * 00071 discover_xml_url_get_url(discover_xml_url_t *url); 00072 00073 char * 00074 discover_xml_url_get_bus(discover_xml_url_t *url); 00075 00076 char * 00077 discover_xml_url_get_type(discover_xml_url_t *url); 00078 00079 discover_xml_url_t * 00080 discover_xml_url_get_next(discover_xml_url_t *url); 00081 00082 discover_xml_url_t * 00083 discover_xml_url_get_last(discover_xml_url_t *url); 00084 00085 char * 00086 discover_xml_url_get_label(discover_xml_url_t *url); 00087 00088 discover_xml_url_t *discover_xml_get_urls(discover_error_t *status); 00089 void discover_xml_free_urls(void); 00090 00091 discover_xml_url_t *discover_xml_get_data_urls(discover_bus_t bus, 00092 discover_filetype_t filetype, 00093 discover_error_t *status); 00094 void discover_xml_free_data_urls(void); 00095 00096 /****************************************************************************** 00097 * busclass 00098 */ 00099 00100 discover_xml_busclass_t *discover_xml_busclass_new(void); 00101 00102 discover_xml_busclass_t *discover_xml_get_busclasses(discover_bus_t bus, 00103 discover_error_t *status); 00104 00105 void discover_xml_free_busclasses(void); 00106 00107 void 00108 discover_xml_merge_busclass_url(discover_xml_busclass_t **blist, 00109 char *filename, discover_error_t *status); 00110 00111 char *discover_xml_busclass_to_class(char *busclass, 00112 discover_xml_busclass_t *busclasses); 00113 int discover_xml_busclass_cmp(char *busclass, char *discover_class, 00114 discover_xml_busclass_t *busclasses); 00115 char *discover_xml_busclass_get_id(discover_xml_busclass_t *busclass); 00116 00117 char *discover_xml_busclass_get_name(discover_xml_busclass_t *busclass); 00118 discover_xml_busclass_t * 00119 discover_xml_busclass_get_next(discover_xml_busclass_t *busclass); 00120 00121 void discover_xml_busclass_free(discover_xml_busclass_t *busclasses); 00122 00123 /****************************************************************************** 00124 * device 00125 */ 00126 00127 discover_device_t * 00128 discover_xml_get_devices(discover_bus_t bus, discover_error_t *status); 00129 00130 void discover_xml_free_devices(void); 00131 00132 void 00133 discover_xml_merge_device_url(discover_device_t **dlist, char *url, 00134 discover_xml_busclass_t *busclasses, 00135 discover_xml_vendor_t *vendors, 00136 discover_error_t *status); 00137 00138 /****************************************************************************** 00139 * vendor 00140 */ 00141 00142 discover_xml_vendor_t *discover_xml_vendor_new(void); 00143 00144 void 00145 discover_xml_merge_vendor_url(discover_xml_vendor_t **vlist, char *filename, 00146 discover_error_t *status); 00147 discover_xml_vendor_t *discover_xml_get_vendors(discover_bus_t bus, 00148 discover_error_t *status); 00149 void discover_xml_free_vendors(void); 00150 00151 char *discover_xml_vendor_id2name(discover_xml_vendor_t *vendors, char *id); 00152 char *discover_xml_vendor_get_id(discover_xml_vendor_t *vendor); 00153 char *discover_xml_vendor_get_name(discover_xml_vendor_t *vendor); 00154 discover_xml_vendor_t * 00155 discover_xml_vendor_get_next(discover_xml_vendor_t *vendor); 00156 00157 void discover_xml_vendor_free(discover_xml_vendor_t *vendors); 00158 00159 #ifdef __cplusplus 00160 } 00161 #endif 00162 00163 #endif
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/stubs_8c.html 0000644 0023421 0023421 00000006575 10655642004 020655 0 ustar pere pere
stubs.c File Reference
Stub system-dependent code. More...
#include <config.h>
#include <sysdep.h>
#include <stdio.h>
Go to the source code of this file.
Functions | |
| discover_sysdep_data_t * | _discover_get_ata_raw (void) |
| discover_sysdep_data_t * | _discover_get_pci_raw (void) |
| discover_sysdep_data_t * | _discover_get_pcmcia_raw (void) |
| discover_sysdep_data_t * | _discover_get_scsi_raw (void) |
| discover_sysdep_data_t * | _discover_get_usb_raw (void) |
Detailed Description
Stub system-dependent code.This file represents a dummy OS-dependent hardware interface. These routines are the skeleton structure that must be followed to allow Discover to operate on multiple architectures.
Definition in file stubs.c.
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/globals_func.html 0000644 0023421 0023421 00000037506 10655642004 021557 0 ustar pere pere
- _ -
- _discover_convert_device_data() : sysdep.c
- _discover_create_message() : core.c
- _discover_free_sysdep_data() : sysdep.h, sysdep.c
- _discover_free_sysdep_device_data() : sysdep.h, sysdep.c
- _discover_get_ata_raw() : sysdep.h, stubs.c
- _discover_get_pci_raw() : sysdep.h, stubs.c
- _discover_get_pcmcia_raw() : sysdep.h, stubs.c
- _discover_get_scsi_raw() : sysdep.h, stubs.c
- _discover_get_usb_raw() : sysdep.h, stubs.c
- _discover_sysdep_data_new() : sysdep.h, sysdep.c
- _discover_sysdep_device_data_new() : sysdep.h, sysdep.c
- _real_discover_conf_get_bus_map() : conf.c
- _real_discover_conf_get_bus_map_by_name() : conf.c
- d -
- discover_conf_append_url() : discover-conf.h, conf.c
- discover_conf_free() : discover-conf.h, conf.c
- discover_conf_get_bus_map() : discover-conf.h, conf.c
- discover_conf_get_bus_map_by_name() : discover-conf.h, conf.c
- discover_conf_get_bus_name() : discover-conf.h, conf.c
- discover_conf_get_filetype_name() : discover-conf.h, conf.c
- discover_conf_get_full_bus_map() : discover-conf.h, conf.c
- discover_conf_get_urls() : discover-conf.h, conf.c
- discover_conf_insert_url() : discover-conf.h, conf.c
- discover_conf_load() : discover-conf.h, conf.c
- discover_conf_name_to_bus() : discover-conf.h, conf.c
- discover_data_free() : discover.h, device.c
- discover_data_get_child() : discover.h, device.c
- discover_data_get_class() : discover.h, device.c
- discover_data_get_first() : discover.h, device.c
- discover_data_get_next() : discover.h, device.c
- discover_data_get_parent() : discover.h, device.c
- discover_data_get_prev() : discover.h, device.c
- discover_data_get_text() : discover.h, device.c
- discover_data_new() : discover.h, device.c
- discover_device_copy() : discover.h, device.c
- discover_device_find() : discover.h, device.c
- discover_device_free() : discover.h, device.c
- discover_device_get_busclass() : discover.h, device.c
- discover_device_get_data() : discover.h, device.c
- discover_device_get_data_struct() : discover.h, device.c
- discover_device_get_model_id() : discover.h, device.c
- discover_device_get_model_name() : discover.h, device.c
- discover_device_get_next() : discover.h, device.c
- discover_device_get_vendor_id() : discover.h, device.c
- discover_device_get_vendor_name() : discover.h, device.c
- discover_device_new() : discover.h, device.c
- discover_error_free() : discover.h, core.c
- discover_error_new() : discover.h, core.c
- discover_free_devices() : discover.h, sysdep.c
- discover_get_devices() : discover.h, sysdep.c
- discover_major_version() : discover.h, core.c
- discover_micro_version() : discover.h, core.c
- discover_minor_version() : discover.h, core.c
- discover_strerror() : discover.h, core.c
- discover_xml_busclass_cmp() : discover-xml.h, busclass-xml.c
- discover_xml_busclass_free() : discover-xml.h, busclass-xml.c
- discover_xml_busclass_get_id() : discover-xml.h, busclass-xml.c
- discover_xml_busclass_get_name() : discover-xml.h, busclass-xml.c
- discover_xml_busclass_get_next() : discover-xml.h, busclass-xml.c
- discover_xml_busclass_new() : discover-xml.h, busclass-xml.c
- discover_xml_busclass_to_class() : discover-xml.h, busclass-xml.c
- discover_xml_find_device() : discover-xml.h, device-xml.c
- discover_xml_find_next_device() : discover-xml.h, device-xml.c
- discover_xml_free_busclasses() : discover-xml.h, busclass-xml.c
- discover_xml_free_data_urls() : discover-xml.h, url-xml.c
- discover_xml_free_devices() : discover-xml.h, device-xml.c
- discover_xml_free_urls() : discover-xml.h, url-xml.c
- discover_xml_free_vendors() : discover-xml.h, vendor-xml.c
- discover_xml_get_busclasses() : discover-xml.h, busclass-xml.c
- discover_xml_get_data_urls() : discover-xml.h, url-xml.c
- discover_xml_get_devices() : discover-xml.h, device-xml.c
- discover_xml_get_matching_devices() : discover-xml.h, device-xml.c
- discover_xml_get_urls() : discover-xml.h, url-xml.c
- discover_xml_get_vendors() : discover-xml.h, vendor-xml.c
- discover_xml_merge_busclass_url() : discover-xml.h, busclass-xml.c
- discover_xml_merge_device_url() : discover-xml.h, device-xml.c
- discover_xml_merge_vendor_url() : discover-xml.h, vendor-xml.c
- discover_xml_stack_destroy() : stack.c
- discover_xml_stack_get() : stack.c
- discover_xml_stack_getbynum() : stack.c
- discover_xml_stack_new() : stack.c
- discover_xml_stack_pop() : stack.c
- discover_xml_stack_push() : stack.c
- discover_xml_url_copy() : discover-xml.h, url-xml.c
- discover_xml_url_free() : discover-xml.h, url-xml.c
- discover_xml_url_get_bus() : discover-xml.h, url-xml.c
- discover_xml_url_get_label() : discover-xml.h, url-xml.c
- discover_xml_url_get_last() : discover-xml.h, url-xml.c
- discover_xml_url_get_next() : discover-xml.h, url-xml.c
- discover_xml_url_get_type() : discover-xml.h, url-xml.c
- discover_xml_url_get_url() : discover-xml.h, url-xml.c
- discover_xml_url_new() : discover-xml.h, url-xml.c
- discover_xml_vendor_free() : discover-xml.h, vendor-xml.c
- discover_xml_vendor_get_id() : discover-xml.h, vendor-xml.c
- discover_xml_vendor_get_name() : discover-xml.h, vendor-xml.c
- discover_xml_vendor_get_next() : discover-xml.h, vendor-xml.c
- discover_xml_vendor_id2name() : discover-xml.h, vendor-xml.c
- discover_xml_vendor_new() : discover-xml.h, vendor-xml.c
- discover_xml_version_cmp() : discover-xml.h, version-cmp.c
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/vendor-xml_8c.html 0000644 0023421 0023421 00000012160 10655642004 021573 0 ustar pere pere
vendor-xml.c File Reference
Vendor XML data file parsing. More...
#include "config.h"
#include <sys/types.h>
#include <assert.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <expat.h>
#include <discover/discover.h>
#include <discover/discover-xml.h>
#include <discover/load-url.h>
#include <discover/utils.h>
Go to the source code of this file.
Functions | |
| void | discover_xml_merge_vendor_url (discover_xml_vendor_t **vlist, char *url, discover_error_t *status) |
| discover_xml_vendor_t * | discover_xml_get_vendors (discover_bus_t bus, discover_error_t *status) |
| void | discover_xml_free_vendors (void) |
| char * | discover_xml_vendor_id2name (discover_xml_vendor_t *vendors, char *id) |
| char * | discover_xml_vendor_get_id (discover_xml_vendor_t *vendor) |
| char * | discover_xml_vendor_get_name (discover_xml_vendor_t *vendor) |
| discover_xml_vendor_t * | discover_xml_vendor_get_next (discover_xml_vendor_t *vendor) |
| discover_xml_vendor_t * | discover_xml_vendor_new (void) |
| void | discover_xml_vendor_free (discover_xml_vendor_t *vendors) |
Detailed Description
Vendor XML data file parsing.This file contains the routines needed to properly process the vendor XML data. This file is responsible for handling URLs and storing the XML data during the parsing process.
Definition in file vendor-xml.c.
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/vendor-xml_8c-source.html 0000644 0023421 0023421 00000044346 10655642004 023104 0 ustar pere pere
vendor-xml.c
Go to the documentation of this file.00001 00011 /* $Progeny$ 00012 * 00013 * AUTHOR: John R. Daily <jdaily@progeny.com> 00014 * 00015 * Copyright 2002 Progeny Linux Systems, Inc. 00016 * Copyright 2002 Hewlett-Packard Company 00017 * 00018 * Permission is hereby granted, free of charge, to any person obtaining a 00019 * copy of this software and associated documentation files (the "Software"), 00020 * to deal in the Software without restriction, including without limitation 00021 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00022 * and/or sell copies of the Software, and to permit persons to whom the 00023 * Software is furnished to do so, subject to the following conditions: 00024 * 00025 * The above copyright notice and this permission notice shall be included in 00026 * all copies or substantial portions of the Software. 00027 * 00028 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00029 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00030 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00031 * THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00032 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 00033 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 00034 * DEALINGS IN THE SOFTWARE. 00035 */ 00036 00037 #include "config.h" 00038 00039 #include <sys/types.h> 00040 00041 #include <assert.h> 00042 #include <limits.h> 00043 #include <stdio.h> 00044 #include <string.h> 00045 00046 #include <expat.h> 00047 00048 #include <discover/discover.h> 00049 #include <discover/discover-xml.h> 00050 00051 #include <discover/load-url.h> 00052 #include <discover/utils.h> 00053 00055 struct discover_xml_vendor { 00056 char *id; 00057 char *name; 00058 discover_xml_vendor_t *next; 00059 }; 00060 00061 static discover_xml_vendor_t *vendors[BUS_COUNT]; 00062 00064 struct context { 00065 discover_xml_vendor_t **vlist; 00066 00067 int unknown_level; /* How deep are we into unknown XML tags? */ 00068 }; 00069 00070 static char *known_vendor_elements[] = { 00071 "vendor", 00072 "vendor_list", 00073 NULL 00074 }; 00075 00076 00077 static bool 00078 unknown_vendor_element(const XML_Char * const tag) 00079 { 00080 int i; 00081 for (i = 0; known_vendor_elements[i] != NULL; i++) { 00082 if (strcmp(tag, known_vendor_elements[i]) == 0) 00083 return false; 00084 } 00085 return true; 00086 } 00087 00088 static void 00089 start_element(void *ctx, const XML_Char *name, const XML_Char *attrs[]) 00090 { 00091 struct context *context = ctx; 00092 int i; 00093 char *vid, *vname; 00094 discover_xml_vendor_t *next, **vlist; 00095 00096 assert(context != NULL); 00097 assert(name != NULL); 00098 assert(attrs != NULL); 00099 00100 if (unknown_vendor_element(name)) { 00101 context->unknown_level++; 00102 return; 00103 } 00104 00105 if (context->unknown_level > 0) { 00106 return; 00107 } 00108 00109 if (strcmp(name, "vendor") == 0) { 00110 vid = vname = NULL; 00111 for (i = 0; attrs[i]; i += 2) { 00112 if (strcmp(attrs[i], "id") == 0) { 00113 vid = (char *) attrs[i + 1]; 00114 } else if (strcmp(attrs[i], "name") == 0) { 00115 vname = (char *) attrs[i + 1]; 00116 } 00117 } 00118 00119 assert(vid != NULL); 00120 assert(vname != NULL); 00121 00122 vlist = context->vlist; 00123 next = *vlist; 00124 *vlist = discover_xml_vendor_new(); 00125 (*vlist)->id = _discover_xstrdup(vid); 00126 (*vlist)->name = _discover_xstrdup(vname); 00127 (*vlist)->next = next; 00128 } 00129 } 00130 00131 static void 00132 end_element(void *ctx, const XML_Char *name) 00133 { 00134 struct context *context = ctx; 00135 00136 assert(context != NULL); 00137 assert(name != NULL); 00138 00139 if (unknown_vendor_element(name)) { 00140 context->unknown_level--; 00141 return; 00142 } 00143 00144 if (context->unknown_level > 0) { 00145 return; 00146 } 00147 00148 /* 00149 * We don't have any end tags to worry about, but if we did, they 00150 * would be handled here. 00151 */ 00152 } 00153 00166 /* Sshh! Don't tell, but this doesn't actually do any merging at all. 00167 * Instead, it simply inserts newer entries at the front of the list, 00168 * meaning that vendor info found later supersedes info found earlier. 00169 * This gives the illusion of merging, but potentially wastes memory 00170 * with duplicates. 00171 */ 00172 void 00173 discover_xml_merge_vendor_url(discover_xml_vendor_t **vlist, 00174 char *url, discover_error_t *status) 00175 { 00176 XML_Parser parser; 00177 struct context context; 00178 00179 assert(url != NULL); 00180 assert(status != NULL); 00181 00182 status->code = 0; 00183 00184 context.vlist = vlist; 00185 context.unknown_level = 0; 00186 00187 parser = XML_ParserCreate(NULL); 00188 XML_SetElementHandler(parser, start_element, end_element); 00189 XML_SetUserData(parser, &context); 00190 00191 if (!_discover_load_url(url, parser)) { 00192 XML_ParserFree(parser); 00193 status->code = DISCOVER_EIO; 00194 return; 00195 } 00196 00197 if (!XML_Parse(parser, "", 0, 1)) { 00198 XML_ParserFree(parser); 00199 status->code = DISCOVER_EXML; 00200 return; 00201 } 00202 00203 XML_ParserFree(parser); 00204 00205 return; 00206 } 00207 00214 discover_xml_vendor_t * 00215 discover_xml_get_vendors(discover_bus_t bus, discover_error_t *status) 00216 { 00217 discover_xml_url_t *urls, *i; 00218 char *url; 00219 00220 assert(status != NULL); 00221 00222 status->code = 0; 00223 00224 if (!vendors[bus]) { 00225 urls = discover_xml_get_data_urls(bus, VENDOR_TYPE, status); 00226 if (status->code != 0) { 00227 return NULL; 00228 } 00229 00230 for (i = urls; 00231 i; 00232 i = discover_xml_url_get_next(i)) { 00233 url = discover_xml_url_get_url(i); 00234 discover_xml_merge_vendor_url(&(vendors[bus]), url, status); 00235 if (status->code != 0) { 00236 return NULL; 00237 } 00238 } 00239 } 00240 00241 return vendors[bus]; 00242 } 00243 00247 void 00248 discover_xml_free_vendors(void) 00249 { 00250 int i; 00251 for (i = 0; i < BUS_COUNT; i++) { 00252 discover_xml_vendor_free(vendors[i]); 00253 vendors[i] = NULL; 00254 } 00255 } 00256 00263 char * 00264 discover_xml_vendor_id2name(discover_xml_vendor_t *vendors, char *id) 00265 { 00266 discover_xml_vendor_t *vendor; 00267 char *name; 00268 00269 assert(vendors != NULL); 00270 assert(id != NULL); 00271 00272 name = NULL; 00273 00274 for (vendor = vendors; 00275 vendor; 00276 vendor = vendor->next) { 00277 if (strcmp(id, vendor->id) == 0) { 00278 name = vendor->name; 00279 break; 00280 } 00281 } 00282 00283 return name; 00284 } 00285 00289 char * 00290 discover_xml_vendor_get_id(discover_xml_vendor_t *vendor) 00291 { 00292 assert(vendor != NULL); 00293 00294 return vendor->id; 00295 } 00296 00300 char * 00301 discover_xml_vendor_get_name(discover_xml_vendor_t *vendor) 00302 { 00303 assert(vendor != NULL); 00304 00305 return vendor->name; 00306 } 00307 00311 discover_xml_vendor_t * 00312 discover_xml_vendor_get_next(discover_xml_vendor_t *vendor) 00313 { 00314 assert(vendor != NULL); 00315 00316 return vendor->next; 00317 } 00318 00322 discover_xml_vendor_t * 00323 discover_xml_vendor_new(void) 00324 { 00325 discover_xml_vendor_t *new; 00326 00327 new = _discover_xmalloc(sizeof(discover_xml_vendor_t)); 00328 00329 new->id = NULL; 00330 new->name = NULL; 00331 new->next = NULL; 00332 00333 return new; 00334 } 00335 00341 void 00342 discover_xml_vendor_free(discover_xml_vendor_t *vendors) 00343 { 00344 discover_xml_vendor_t *vendor, *last; 00345 00346 last = NULL; 00347 00348 for (vendor = vendors; 00349 vendor; 00350 vendor = vendor->next) { 00351 if (vendor->id) { 00352 free(vendor->id); 00353 } 00354 00355 if (vendor->name) { 00356 free(vendor->name); 00357 } 00358 00359 if (last) { 00360 free(last); 00361 } 00362 last = vendor; 00363 } 00364 00365 if (last) { 00366 free(last); 00367 } 00368 } 00369 00372 /* 00373 * Local variables: 00374 * c-file-style: "progeny" 00375 * indent-tabs-mode: nil 00376 * End: 00377 */ 00378 /* vim: set cin fo=tcroq sw=4 et sts=4 tw=75: */
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/index.html 0000644 0023421 0023421 00000003764 10655642004 020227 0 ustar pere pere
Discover API Reference
This is the Discover application programming interface (API) reference. If you have not already read The Discover Hardware Detection System, you should do so now. The following list describes the contents of the links at the top of the page:
- Main page -- This page
- Modules -- List of top-level modules; you probably want to start here, where navigation is fastest
- Data Structures -- List of data structures used by Discover
- File List -- List of files comprising Discover's external interface, with links to documentation and source code
- Data Fields -- List of fields used in Discover's structs and unions
- Globals -- List of global symbols, with links to file summaries
The Discover library was written by Eric Gillespie, John R. Daily, and Josh Bressers, with design input from Branden Robinson.
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/globals.html 0000644 0023421 0023421 00000047063 10655642004 020543 0 ustar pere pere
Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:
- _ -
- _discover_convert_device_data() : sysdep.c
- _discover_create_message() : core.c
- _discover_free_sysdep_data() : sysdep.h, sysdep.c
- _discover_free_sysdep_device_data() : sysdep.h, sysdep.c
- _discover_get_ata_raw() : sysdep.h, stubs.c
- _discover_get_pci_raw() : sysdep.h, stubs.c
- _discover_get_pcmcia_raw() : sysdep.h, stubs.c
- _discover_get_scsi_raw() : sysdep.h, stubs.c
- _discover_get_usb_raw() : sysdep.h, stubs.c
- _discover_sysdep_data_new() : sysdep.h, sysdep.c
- _discover_sysdep_device_data_new() : sysdep.h, sysdep.c
- _real_discover_conf_get_bus_map() : conf.c
- _real_discover_conf_get_bus_map_by_name() : conf.c
- b -
- BUS_COUNT : discover.h
- d -
- discover_bus_map_t : discover.h
- discover_bus_t : discover.h
- discover_conf_append_url() : discover-conf.h, conf.c
- discover_conf_free() : discover-conf.h, conf.c
- discover_conf_get_bus_map() : discover-conf.h, conf.c
- discover_conf_get_bus_map_by_name() : discover-conf.h, conf.c
- discover_conf_get_bus_name() : discover-conf.h, conf.c
- discover_conf_get_filetype_name() : discover-conf.h, conf.c
- discover_conf_get_full_bus_map() : discover-conf.h, conf.c
- discover_conf_get_urls() : discover-conf.h, conf.c
- discover_conf_insert_url() : discover-conf.h, conf.c
- discover_conf_load() : discover-conf.h, conf.c
- discover_conf_name_to_bus() : discover-conf.h, conf.c
- discover_create_message_t : discover.h
- discover_data_free() : discover.h, device.c
- discover_data_get_child() : discover.h, device.c
- discover_data_get_class() : discover.h, device.c
- discover_data_get_first() : discover.h, device.c
- discover_data_get_next() : discover.h, device.c
- discover_data_get_parent() : discover.h, device.c
- discover_data_get_prev() : discover.h, device.c
- discover_data_get_text() : discover.h, device.c
- discover_data_new() : discover.h, device.c
- discover_data_t : discover.h
- discover_device_copy() : discover.h, device.c
- discover_device_find() : discover.h, device.c
- discover_device_free() : discover.h, device.c
- discover_device_func_t : discover.h
- discover_device_get_busclass() : discover.h, device.c
- discover_device_get_data() : discover.h, device.c
- discover_device_get_data_struct() : discover.h, device.c
- discover_device_get_model_id() : discover.h, device.c
- discover_device_get_model_name() : discover.h, device.c
- discover_device_get_next() : discover.h, device.c
- discover_device_get_vendor_id() : discover.h, device.c
- discover_device_get_vendor_name() : discover.h, device.c
- discover_device_new() : discover.h, device.c
- discover_device_t : discover.h
- DISCOVER_EBADVERSION : discover.h
- DISCOVER_EBUSDISABLED : discover.h
- DISCOVER_EBUSNOTFOUND : discover.h
- DISCOVER_EDATANOTFOUND : discover.h
- DISCOVER_EDEVICENOTFOUND : discover.h
- DISCOVER_EIO : discover.h
- DISCOVER_ENOIMPL : discover.h
- discover_error_code_t : discover.h
- discover_error_free() : discover.h, core.c
- discover_error_new() : discover.h, core.c
- discover_error_t : discover.h
- DISCOVER_ESYS : discover.h
- DISCOVER_EXML : discover.h
- discover_filetype_t : discover.h
- discover_free_devices() : discover.h, sysdep.c
- discover_free_func_t : discover.h
- discover_get_devices() : discover.h, sysdep.c
- discover_major_version() : discover.h, core.c
- discover_micro_version() : discover.h, core.c
- discover_minor_version() : discover.h, core.c
- discover_strerror() : discover.h, core.c
- DISCOVER_SUCCESS : discover.h
- discover_sysdep_data_t : sysdep.h
- discover_sysdep_device_data_t : sysdep.h
- discover_sysdep_raw_func_t : discover.h
- discover_xml_busclass_cmp() : discover-xml.h, busclass-xml.c
- discover_xml_busclass_free() : discover-xml.h, busclass-xml.c
- discover_xml_busclass_func_t : discover.h
- discover_xml_busclass_get_id() : discover-xml.h, busclass-xml.c
- discover_xml_busclass_get_name() : discover-xml.h, busclass-xml.c
- discover_xml_busclass_get_next() : discover-xml.h, busclass-xml.c
- discover_xml_busclass_new() : discover-xml.h, busclass-xml.c
- discover_xml_busclass_t : discover.h
- discover_xml_busclass_to_class() : discover-xml.h, busclass-xml.c
- discover_xml_find_device() : discover-xml.h, device-xml.c
- discover_xml_find_next_device() : discover-xml.h, device-xml.c
- discover_xml_free_busclasses() : discover-xml.h, busclass-xml.c
- discover_xml_free_data_urls() : discover-xml.h, url-xml.c
- discover_xml_free_devices() : discover-xml.h, device-xml.c
- discover_xml_free_urls() : discover-xml.h, url-xml.c
- discover_xml_free_vendors() : discover-xml.h, vendor-xml.c
- discover_xml_get_busclasses() : discover-xml.h, busclass-xml.c
- discover_xml_get_data_urls() : discover-xml.h, url-xml.c
- discover_xml_get_devices() : discover-xml.h, device-xml.c
- discover_xml_get_matching_devices() : discover-xml.h, device-xml.c
- discover_xml_get_urls() : discover-xml.h, url-xml.c
- discover_xml_get_vendors() : discover-xml.h, vendor-xml.c
- discover_xml_merge_busclass_url() : discover-xml.h, busclass-xml.c
- discover_xml_merge_device_url() : discover-xml.h, device-xml.c
- discover_xml_merge_vendor_url() : discover-xml.h, vendor-xml.c
- discover_xml_stack_destroy() : stack.c
- discover_xml_stack_get() : stack.c
- discover_xml_stack_getbynum() : stack.c
- discover_xml_stack_new() : stack.c
- discover_xml_stack_pop() : stack.c
- discover_xml_stack_push() : stack.c
- discover_xml_url_copy() : discover-xml.h, url-xml.c
- discover_xml_url_free() : discover-xml.h, url-xml.c
- discover_xml_url_func_t : discover.h
- discover_xml_url_get_bus() : discover-xml.h, url-xml.c
- discover_xml_url_get_label() : discover-xml.h, url-xml.c
- discover_xml_url_get_last() : discover-xml.h, url-xml.c
- discover_xml_url_get_next() : discover-xml.h, url-xml.c
- discover_xml_url_get_type() : discover-xml.h, url-xml.c
- discover_xml_url_get_url() : discover-xml.h, url-xml.c
- discover_xml_url_new() : discover-xml.h, url-xml.c
- discover_xml_url_t : discover.h
- discover_xml_vendor_free() : discover-xml.h, vendor-xml.c
- discover_xml_vendor_func_t : discover.h
- discover_xml_vendor_get_id() : discover-xml.h, vendor-xml.c
- discover_xml_vendor_get_name() : discover-xml.h, vendor-xml.c
- discover_xml_vendor_get_next() : discover-xml.h, vendor-xml.c
- discover_xml_vendor_id2name() : discover-xml.h, vendor-xml.c
- discover_xml_vendor_new() : discover-xml.h, vendor-xml.c
- discover_xml_vendor_t : discover.h
- discover_xml_version_cmp() : discover-xml.h, version-cmp.c
- i -
- IDLEN : device-xml.c
- m -
- MAXBUFLEN : version-cmp.c
- r -
- range_state : version-cmp.c
- range_states : version-cmp.c
- raw_sysdep_function_t : sysdep.c
- s -
- scan_flag : conf.c
- state : url-xml.c, device-xml.c, conf.c
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/stack_8c.html 0000644 0023421 0023421 00000024171 10655642004 020612 0 ustar pere pere
stack.c File Reference
Stack routines for Discover. More...
#include <stdio.h>
#include <assert.h>
#include <stdbool.h>
#include <stdlib.h>
#include <discover/utils.h>
#include <discover/stack.h>
Go to the source code of this file.
Functions | |
| discover_xml_stack * | discover_xml_stack_new () |
| void | discover_xml_stack_destroy (discover_xml_stack *stack) |
| void | discover_xml_stack_push (discover_xml_stack **stack, void *data) |
| void * | discover_xml_stack_pop (discover_xml_stack **stack) |
| void * | discover_xml_stack_get (discover_xml_stack *stack) |
| void * | discover_xml_stack_getbynum (discover_xml_stack *stack, int i) |
Detailed Description
Stack routines for Discover.This is a generic stack routine that Discover uses. The stack is needed because there wasn't a good way to track the traversal depth through the XML data. These routines brought much sanity to the XML parsing process. They are generic enough that they can be used for any number of applications.
Definition in file stack.c.
Function Documentation
|
|
Routine responsible for destroying the stack base once we're done Definition at line 62 of file stack.c. Referenced by discover_xml_stack_pop(). |
|
|
Return the top item without popping it. |
|
||||||||||||
|
Return the item at depth i on the stack. |
|
|
Routine responsible for creating the base of the stack Definition at line 48 of file stack.c. Referenced by discover_xml_stack_push(). |
|
|
Pop an item from the stack. Definition at line 83 of file stack.c. References discover_xml_stack_destroy(). |
|
||||||||||||
|
Push an item onto the stack. Definition at line 69 of file stack.c. References discover_xml_stack_new(). |
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/version-cmp_8c.html 0000644 0023421 0023421 00000013436 10655642004 021751 0 ustar pere pere
version-cmp.c File Reference
Version comparison functions. More...
#include "config.h"
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <discover/discover.h>
#include <discover/utils.h>
Go to the source code of this file.
Defines | |
| #define | MAXBUFLEN 256 |
Typedefs | |
| typedef enum range_states | range_state |
Enumerations | |
| enum | range_states { START, OPEN, VERSION1, VERSEP1, PAUSE1, SEPARATOR, I, N, F, VERSION2, VERSEP2, PAUSE2, CLOSE, ERROR } |
Functions | |
| int | discover_xml_version_cmp (char *range, char *version, discover_error_t *status) |
Detailed Description
Version comparison functions.This file holds the routines needed to process version data in the XML file. This version data is used to look for information pertaining to a particular version of the OS/software requiring that information.
Definition in file version-cmp.c.
Define Documentation
|
|
This probably shouldn't be here; it's bad practice (3.0, right). Definition at line 55 of file version-cmp.c. |
Typedef Documentation
|
|
This is used as a placeholder while comparing versions of modules. |
Enumeration Type Documentation
|
|
Version placeholders Definition at line 58 of file version-cmp.c. |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/group__conf.html 0000644 0023421 0023421 00000057557 10655642004 021431 0 ustar pere pere
Configuration handling
Functions | |
| void | discover_conf_load (discover_error_t *status) |
| int | discover_conf_name_to_bus (char *name, discover_error_t *status) |
| discover_bus_map_t * | discover_conf_get_full_bus_map (discover_error_t *status) |
| discover_bus_map_t * | discover_conf_get_bus_map_by_name (char *name, discover_error_t *status) |
| discover_bus_map_t * | discover_conf_get_bus_map (discover_bus_t bus, discover_error_t *status) |
| void | discover_conf_insert_url (char *url, discover_error_t *status) |
| void | discover_conf_append_url (char *url, discover_error_t *status) |
| discover_xml_url_t * | discover_conf_get_urls (discover_error_t *status) |
| void | discover_conf_free (void) |
| char * | discover_conf_get_bus_name (discover_bus_t bus) |
| char * | discover_conf_get_filetype_name (discover_filetype_t filetype) |
Function Documentation
|
||||||||||||
|
Append the URL specified in url at the tail of the list of URLs where Discover data will be retrieved.
Definition at line 579 of file conf.c. References discover_error::code, and discover_conf_load(). |
|
|
Free configuration data. This is mainly useful so that the next call to discover_conf_load will reload the configuration data. Definition at line 650 of file conf.c. References discover_xml_url_free(). |
|
||||||||||||
|
Get the bus map for a single bus.
Definition at line 532 of file conf.c. References BUS_COUNT, discover_error::code, discover_conf_load(), and DISCOVER_EBUSNOTFOUND. Referenced by discover_get_devices(). |
|
||||||||||||
|
Get the bus map by name for a single bus.
Definition at line 509 of file conf.c. References _real_discover_conf_get_bus_map_by_name(), discover_error::code, and discover_conf_load(). |
|
|
Translate an enum bus value into a string.
Definition at line 666 of file conf.c. References BUS_COUNT, and discover_bus_map::name. Referenced by discover_xml_get_data_urls(). |
|
|
Translate an enum filetype value into a string.
Definition at line 682 of file conf.c. Referenced by discover_xml_get_data_urls(). |
|
|
Get the full bus map, listing all buses.
Definition at line 496 of file conf.c. References discover_conf_load(). Referenced by discover_device_find(). |
|
|
Get the list of URLs from which XML data will be retrieved.
Definition at line 599 of file conf.c. References discover_error::code, discover_conf_load(), and discover_xml_url_new(). Referenced by discover_xml_get_urls(). |
|
||||||||||||
|
Insert the URL specified in url at the head of the list of URLs where Discover data will be retrieved.
Definition at line 557 of file conf.c. References discover_error::code, and discover_conf_load(). |
|
|
Ensure that the configuration file is loaded. Repeated calls to this function will not change anything, unless you call discover_conf_free. Technically, this function will lie to you if there is no conf file. Even though no configuration was loaded, repeated calls still will not change anything. However, if we don't do this and a config file is created between the time some long-lived caller first calls discover_conf_load and the time it calls it again, it will be loaded. This doesn't strike me as idempotent behavior. So, repeated calls even in this case will not change anything unless you call discover_conf_free.
Definition at line 378 of file conf.c. References discover_error::code, discover_error::create_message, and DISCOVER_EXML. Referenced by discover_conf_append_url(), discover_conf_get_bus_map(), discover_conf_get_bus_map_by_name(), discover_conf_get_full_bus_map(), discover_conf_get_urls(), and discover_conf_insert_url(). |
|
||||||||||||
|
Get the bus enumeration for a bus name.
Definition at line 477 of file conf.c. References discover_error::code, and DISCOVER_EBUSNOTFOUND. Referenced by _real_discover_conf_get_bus_map_by_name(). |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/group__busclass__xml.html 0000644 0023421 0023421 00000051056 10655642004 023326 0 ustar pere pere
Busclass list XML parsing
Functions | |
| void | discover_xml_merge_busclass_url (discover_xml_busclass_t **blist, char *url, discover_error_t *status) |
| discover_xml_busclass_t * | discover_xml_get_busclasses (discover_bus_t bus, discover_error_t *status) |
| void | discover_xml_free_busclasses (void) |
| char * | discover_xml_busclass_to_class (char *busclass, discover_xml_busclass_t *busclasses) |
| int | discover_xml_busclass_cmp (char *busclass, char *discover_class, discover_xml_busclass_t *busclasses) |
| char * | discover_xml_busclass_get_id (discover_xml_busclass_t *busclass) |
| char * | discover_xml_busclass_get_name (discover_xml_busclass_t *busclass) |
| discover_xml_busclass_t * | discover_xml_busclass_get_next (discover_xml_busclass_t *busclass) |
| discover_xml_busclass_t * | discover_xml_busclass_new (void) |
| void | discover_xml_busclass_free (discover_xml_busclass_t *busclasses) |
Function Documentation
|
||||||||||||||||
|
Compare a busclass to a device class, returning the same kind of value returned by strcmp(3). Note that this function has a special case for the class 'all'; it is considered equal to all busclasses.
Definition at line 295 of file busclass-xml.c. References discover_xml_busclass_to_class(). Referenced by discover_device_find(). |
|
|
Free the busclass or list of busclasses.
Definition at line 382 of file busclass-xml.c. Referenced by discover_xml_free_busclasses(). |
|
|
Get the id member of busclass.
Definition at line 327 of file busclass-xml.c. |
|
|
Get the name member of busclass.
Definition at line 340 of file busclass-xml.c. |
|
|
Get the next member of busclass (used for traversing lists of busclasses). Definition at line 352 of file busclass-xml.c. |
|
|
Create and initialize a new discover_xml_busclass_t object. Definition at line 363 of file busclass-xml.c. |
|
||||||||||||
|
Return the device class corresponding to a busclass.
Definition at line 263 of file busclass-xml.c. Referenced by discover_xml_busclass_cmp(). |
|
|
Free the list of busclasses. Definition at line 247 of file busclass-xml.c. References BUS_COUNT, and discover_xml_busclass_free(). |
|
||||||||||||
|
Get the list of busclasses by bus type.
Definition at line 213 of file busclass-xml.c. References discover_error::code, discover_xml_get_data_urls(), discover_xml_merge_busclass_url(), discover_xml_url_get_next(), and discover_xml_url_get_url(). Referenced by discover_device_find(), and discover_xml_get_devices(). |
|
||||||||||||||||
|
Merge new busclasses into a list.
Definition at line 171 of file busclass-xml.c. References discover_error::code, DISCOVER_EIO, and DISCOVER_EXML. Referenced by discover_xml_get_busclasses(). |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/files.html 0000644 0023421 0023421 00000012156 10655642004 020215 0 ustar pere pere
discover File List
Here is a list of all documented files with brief descriptions:| /home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/discover-conf.h [code] | Public interface for reading Discover configuration data |
| /home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/discover-xml.h [code] | Public interface to Discover's XML handling |
| /home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/discover.h [code] | Public interface for Discover library |
| /home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/sysdep.h [code] | Private interface for system dependencies |
| /home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/busclass-xml.c [code] | Busclass XML data file parsing |
| /home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/conf.c [code] | Configuration handling (including XML parsing) |
| /home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/core.c [code] | Core and miscellaneous routines |
| /home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/device-xml.c [code] | Device XML data file parsing |
| /home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/device.c [code] | Device enumeration and information management |
| /home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/load-url.c [code] | File loading helper functions |
| /home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/stack.c [code] | Stack routines for Discover |
| /home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/sysdep.c [code] | Interact with system dependencies |
| /home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/url-xml.c [code] | XML URL handling |
| /home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/vendor-xml.c [code] | Vendor XML data file parsing |
| /home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/version-cmp.c [code] | Version comparison functions |
| /home/pere/src/debiancvs/pkg-discover/discover/trunk/sysdeps/stub/stubs.c [code] | Stub system-dependent code |
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/device_8c.html 0000644 0023421 0023421 00000021463 10655642004 020745 0 ustar pere pere
device.c File Reference
Device enumeration and information management. More...
#include "config.h"
#include <sys/types.h>
#include <assert.h>
#include <stdbool.h>
#include <string.h>
#include <discover/discover.h>
#include <discover/discover-conf.h>
#include <discover/discover-xml.h>
#include <discover/device.h>
#include <discover/utils.h>
Go to the source code of this file.
Detailed Description
Device enumeration and information management.This file contains many device-related routines. Most of these routines are used to alter or access data pertaining to a device. These routines will likely be most interesting to people writing code against the Discover API.
Definition in file device.c.
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/discover_8h-source.html 0000644 0023421 0023421 00000041517 10655642004 022631 0 ustar pere pere
discover.h
Go to the documentation of this file.00001 00006 /* $Progeny$ 00007 * 00008 * Copyright 2001, 2002 Progeny Linux Systems, Inc. 00009 * Copyright 2002 Hewlett-Packard Company 00010 * 00011 * Permission is hereby granted, free of charge, to any person obtaining a 00012 * copy of this software and associated documentation files (the "Software"), 00013 * to deal in the Software without restriction, including without limitation 00014 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00015 * and/or sell copies of the Software, and to permit persons to whom the 00016 * Software is furnished to do so, subject to the following conditions: 00017 * 00018 * The above copyright notice and this permission notice shall be included in 00019 * all copies or substantial portions of the Software. 00020 * 00021 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00022 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00023 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00024 * THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00025 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 00026 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 00027 * DEALINGS IN THE SOFTWARE. 00028 */ 00029 00030 #ifndef DISCOVER_H 00031 #define DISCOVER_H 00032 00033 #include <stdbool.h> 00034 00035 #ifdef __cplusplus 00036 extern "C" { 00037 #endif 00038 00073 typedef enum { 00075 DISCOVER_SUCCESS, 00077 DISCOVER_EIO, 00079 DISCOVER_EXML, 00081 DISCOVER_ESYS, 00083 DISCOVER_EBUSDISABLED, 00085 DISCOVER_EBUSNOTFOUND, 00087 DISCOVER_EDATANOTFOUND, 00089 DISCOVER_EDEVICENOTFOUND, 00091 DISCOVER_EBADVERSION, 00093 DISCOVER_ENOIMPL 00094 } discover_error_code_t; 00095 00096 struct discover_error; 00097 00099 typedef void *(discover_create_message_t)(struct discover_error **, char *); 00100 00106 typedef struct discover_error { 00108 discover_error_code_t code; 00110 char *message; 00112 discover_create_message_t *create_message; 00113 } discover_error_t; 00114 00116 typedef struct discover_bus_map discover_bus_map_t; 00118 typedef struct discover_device discover_device_t; 00120 typedef struct discover_data discover_data_t; 00122 typedef struct discover_xml_busclass discover_xml_busclass_t; 00124 typedef struct discover_xml_vendor discover_xml_vendor_t; 00126 typedef struct discover_xml_url discover_xml_url_t; 00127 00129 typedef discover_device_t *(discover_device_func_t)(discover_error_t *); 00131 typedef discover_xml_busclass_t *(discover_xml_busclass_func_t)(discover_error_t *); 00133 typedef discover_xml_vendor_t *(discover_xml_vendor_func_t)(discover_error_t *); 00135 typedef discover_xml_url_t *(discover_xml_url_func_t)(discover_error_t *); 00137 typedef void (discover_free_func_t)(void); 00138 00139 #include <discover/sysdep.h> 00141 typedef discover_sysdep_data_t *(discover_sysdep_raw_func_t)(void); 00142 00146 typedef enum { 00147 ATA, 00148 PCI, 00149 PCMCIA, 00150 SCSI, 00151 USB 00152 } discover_bus_t; 00153 00157 #define BUS_COUNT 5 00158 00162 typedef enum { 00163 VENDOR_TYPE, 00164 BUSCLASS_TYPE, 00165 DEVICE_TYPE 00166 } discover_filetype_t; 00167 00168 00178 struct discover_bus_map { 00180 char *name; 00182 int scan_default; 00184 int scan_never; 00186 discover_sysdep_raw_func_t *get_raw; 00187 }; 00188 00192 discover_device_t *discover_get_devices(discover_bus_t bus, discover_error_t *status); 00193 00195 void discover_free_devices(void); 00196 00197 discover_error_t *discover_error_new(void); 00198 void discover_error_free(discover_error_t *status); 00199 char *discover_strerror(discover_error_t *err); 00200 int discover_major_version(void); 00201 int discover_minor_version(void); 00202 int discover_micro_version(void); 00203 00204 /****************************************************************************** 00205 * discover_device 00206 */ 00207 00208 discover_device_t *discover_device_new(void); 00209 00210 /* Class is "video", "sound", etc. */ 00211 discover_device_t *discover_device_find(char *discover_class, 00212 discover_error_t *status); 00213 00214 char *discover_device_get_data(discover_device_t *device, 00215 char *path, char *version, 00216 discover_error_t *status); 00217 00218 void 00219 discover_device_copy(discover_device_t *src, discover_device_t *dst); 00220 00221 char *discover_device_get_busclass(discover_device_t *device); 00222 char *discover_device_get_model_id(discover_device_t *device); 00223 char *discover_device_get_model_name(discover_device_t *device); 00224 char *discover_device_get_vendor_id(discover_device_t *device); 00225 char *discover_device_get_vendor_name(discover_device_t *device); 00226 00227 discover_data_t * 00228 discover_device_get_data_struct(discover_device_t *device); 00229 00230 discover_device_t * 00231 discover_device_get_next(discover_device_t *device); 00232 00233 void discover_device_free(discover_device_t *devices, int free_data); 00234 00235 /****************************************************************************** 00236 * discover_data 00237 */ 00238 00239 discover_data_t *discover_data_new(void); 00240 00241 char *discover_data_get_class(discover_data_t *data); 00242 char *discover_data_get_text(discover_data_t *data); 00243 discover_data_t *discover_data_get_parent(discover_data_t *data); 00244 discover_data_t *discover_data_get_child(discover_data_t *data); 00245 discover_data_t *discover_data_get_next(discover_data_t *data); 00246 discover_data_t *discover_data_get_prev(discover_data_t *prev); 00247 discover_data_t *discover_data_get_first(discover_data_t *data); 00248 void discover_data_free(discover_data_t *data_tree); 00249 00250 #ifdef __cplusplus 00251 } 00252 #endif 00253 00254 #endif 00255 00256 /* 00257 * Local variables: 00258 * c-file-style: "progeny" 00259 * indent-tabs-mode: nil 00260 * End: 00261 */ 00262 /* vim: set cin fo=tcroq sw=4 et sts=4 tw=75: */
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/version-cmp_8c-source.html 0000644 0023421 0023421 00000062406 10655642004 023250 0 ustar pere pere
version-cmp.c
Go to the documentation of this file.00001 00011 /* $Progeny$ 00012 * 00013 * AUTHOR: John R. Daily <jdaily@progeny.com> 00014 * 00015 * Copyright 2002 Progeny Linux Systems, Inc. 00016 * Copyright 2002 Hewlett-Packard Company 00017 * 00018 * Permission is hereby granted, free of charge, to any person obtaining a 00019 * copy of this software and associated documentation files (the "Software"), 00020 * to deal in the Software without restriction, including without limitation 00021 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00022 * and/or sell copies of the Software, and to permit persons to whom the 00023 * Software is furnished to do so, subject to the following conditions: 00024 * 00025 * The above copyright notice and this permission notice shall be included in 00026 * all copies or substantial portions of the Software. 00027 * 00028 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00029 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00030 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00031 * THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00032 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 00033 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 00034 * DEALINGS IN THE SOFTWARE. 00035 */ 00036 00037 /* 00038 * This package should include a state machine diagram that 00039 * is important to understanding this code. 00040 */ 00041 00042 #include "config.h" 00043 00044 #include <assert.h> 00045 #include <ctype.h> 00046 #include <stdio.h> 00047 #include <stdlib.h> 00048 #include <string.h> 00049 00050 #include <discover/discover.h> 00051 00052 #include <discover/utils.h> 00053 00055 #define MAXBUFLEN 256 00056 00058 typedef enum range_states { 00059 START, 00060 OPEN, 00061 VERSION1, 00062 VERSEP1, 00063 PAUSE1, 00064 SEPARATOR, 00065 I, N, F, 00066 VERSION2, 00067 VERSEP2, 00068 PAUSE2, 00069 CLOSE, 00070 ERROR 00071 } 00073 range_state; 00074 00075 /* 00076 * For now, we only understand '.' as a separator, but that could 00077 * change. 00078 */ 00079 static int 00080 is_versep_char(char c) 00081 { 00082 return c == '.'; 00083 } 00084 00085 /* 00086 * Wrapper for isdigit(), in case we want to add more legitimate 00087 * version characters later. 00088 */ 00089 static int 00090 is_version_char(char c) 00091 { 00092 return isdigit(c); 00093 } 00094 00095 /* 00096 * We only handle dot-separated integers. Anything else becomes 00097 * subject to interpretation. 00098 * 00099 * Return values: 00100 * 1 - v1 is higher 00101 * 0 - v2 is higher 00102 * -1 - v1, v2 are equivalent 00103 * 00104 * The string "inf" represents an undefined upper bound; the equivalent on 00105 * the lower bound should be 0. 00106 */ 00107 static int 00108 version_compare(const char *const v1, const char *const v2) 00109 { 00110 int int1, int2; 00111 char *word1, *word2; 00112 char *version1, *version2; 00113 char *buffer1; 00114 char *buffer2; 00115 00116 if (strcmp(v1, v2) == 0) { 00117 return -1; 00118 } 00119 00120 if (strcmp(v1, "inf") == 0) { 00121 return 1; 00122 } 00123 00124 if (strcmp(v2, "inf") == 0) { 00125 return 0; 00126 } 00127 00128 buffer1 = _discover_xmalloc(MAXBUFLEN); 00129 buffer2 = _discover_xmalloc(MAXBUFLEN); 00130 00131 version1 = _discover_xstrdup(v1); 00132 version2 = _discover_xstrdup(v2); 00133 00134 word1 = strtok_r(version1, ".", &buffer1); 00135 word2 = strtok_r(version2, ".", &buffer2); 00136 00137 do { 00138 sscanf(word1, "%d", &int1); 00139 sscanf(word2, "%d", &int2); 00140 00141 if (int1 != int2) { 00142 return int1 > int2; 00143 } 00144 00145 word1 = strtok_r(NULL, ".", &buffer1); 00146 word2 = strtok_r(NULL, ".", &buffer2); 00147 00148 } while(word1 != NULL && word2 != NULL); 00149 00150 free(version1); 00151 free(version2); 00152 00153 if (word2 == NULL && word1 == NULL) { 00154 return -1; 00155 } 00156 if (word2 == NULL) { 00157 return 1; 00158 } 00159 return -0; 00160 } 00161 00162 00163 static int 00164 determine_range(char * range_text, char **upper, 00165 int *upper_inclusive, char **lower, int *lower_inclusive, 00166 char **next) 00167 { 00168 char *current = range_text; 00169 char c; 00170 char last_char = '\0'; 00171 00172 char buffer1[MAXBUFLEN]; 00173 char *bufptr1 = buffer1; 00174 00175 char buffer2[MAXBUFLEN]; 00176 char *bufptr2 = buffer2; 00177 00178 range_state state = START; 00179 range_state last_good_state = START; 00180 int first_inclusive = -1, second_inclusive = -1; 00181 00182 while(1) { 00183 c = *current; 00184 00185 switch(state) { 00186 case START: 00187 if (isspace(c)) { 00188 state = START; 00189 } else if (c == '(' || c == '[') { 00190 state = OPEN; 00191 } else { 00192 last_good_state = state; 00193 state = ERROR; 00194 } 00195 break; 00196 00197 case OPEN: 00198 if (last_char == '[') { 00199 first_inclusive = 1; 00200 } else { 00201 first_inclusive = 0; 00202 } 00203 00204 if (isspace(c)) { 00205 state = OPEN; 00206 } else if (is_version_char(c)) { 00207 state = VERSION1; 00208 } else { 00209 last_good_state = state; 00210 state = ERROR; 00211 } 00212 break; 00213 00214 case VERSION1: 00215 if (bufptr1 - buffer1 > 254) { 00216 last_good_state = state; 00217 state = ERROR; 00218 break; 00219 } 00220 00221 *bufptr1 = last_char; 00222 bufptr1++; 00223 00224 if (isspace(c) || c == ',') { 00225 *bufptr1 = '\0'; 00226 00227 if (c == ',') { 00228 state = SEPARATOR; 00229 } else { 00230 state = PAUSE1; 00231 } 00232 } else if (is_version_char(c)) { 00233 state = VERSION1; 00234 } else if (is_versep_char(c)) { 00235 state = VERSEP1; 00236 } else { 00237 last_good_state = VERSION1; 00238 state = ERROR; 00239 } 00240 break; 00241 00242 case VERSEP1: 00243 if (bufptr1 - buffer1 > 254) { 00244 last_good_state = state; 00245 state = ERROR; 00246 break; 00247 } 00248 00249 *bufptr1 = last_char; 00250 bufptr1++; 00251 00252 if (is_version_char(c)) { 00253 state = VERSION1; 00254 } else { 00255 last_good_state = VERSION1; 00256 state = ERROR; 00257 } 00258 break; 00259 00260 case PAUSE1: 00261 if (isspace(c)) { 00262 state = PAUSE1; 00263 } else if (c == ',') { 00264 state = SEPARATOR; 00265 } else { 00266 last_good_state = PAUSE1; 00267 state = ERROR; 00268 } 00269 break; 00270 00271 case SEPARATOR: 00272 if (isspace(c)) { 00273 state = SEPARATOR; 00274 } else if (is_version_char(c)) { 00275 state = VERSION2; 00276 } else if (c == 'i') { 00277 state = I; 00278 } else { 00279 last_good_state = SEPARATOR; 00280 state = ERROR; 00281 } 00282 break; 00283 00284 case I: 00285 if (c == 'n') { 00286 state = N; 00287 } else { 00288 last_good_state = state; 00289 state = ERROR; 00290 } 00291 break; 00292 00293 case N: 00294 if (c == 'f') { 00295 state = F; 00296 } else { 00297 last_good_state = state; 00298 state = ERROR; 00299 } 00300 break; 00301 00302 case F: 00303 strcpy(bufptr2, "inf"); 00304 if (isspace(c)) { 00305 state = PAUSE2; 00306 } else if (c == ')' || c == ']') { 00307 state = CLOSE; 00308 } else { 00309 last_good_state = state; 00310 state = ERROR; 00311 } 00312 break; 00313 00314 case VERSION2: 00315 if (bufptr2 - buffer2 > 254) { 00316 last_good_state = state; 00317 state = ERROR; 00318 break; 00319 } 00320 00321 *bufptr2 = last_char; 00322 bufptr2++; 00323 00324 if (isspace(c) || c == ')' || c == ']') { 00325 *bufptr2 = '\0'; 00326 00327 if (c == ')' || c == ']') { 00328 state = CLOSE; 00329 } else { 00330 state = PAUSE2; 00331 } 00332 } else if (is_version_char(c)) { 00333 state = VERSION2; 00334 } else if (is_versep_char(c)) { 00335 state = VERSEP2; 00336 } else { 00337 last_good_state = VERSION2; 00338 state = ERROR; 00339 } 00340 break; 00341 00342 case VERSEP2: 00343 if (bufptr2 - buffer2 > 254) { 00344 last_good_state = state; 00345 state = ERROR; 00346 break; 00347 } 00348 00349 *bufptr2 = last_char; 00350 bufptr2++; 00351 00352 if (is_version_char(c)) { 00353 state = VERSION2; 00354 } else { 00355 last_good_state = VERSION2; 00356 state = ERROR; 00357 } 00358 break; 00359 00360 case PAUSE2: 00361 if (isspace(c)) { 00362 state = PAUSE2; 00363 } else if (c == ')' || c == ']') { 00364 state = CLOSE; 00365 } else { 00366 last_good_state = PAUSE2; 00367 state = ERROR; 00368 } 00369 break; 00370 00371 case CLOSE: 00372 *next = current; 00373 00374 if (last_char == ')') { 00375 second_inclusive = 0; 00376 } else if (last_char == ']') { 00377 second_inclusive = 1; 00378 } 00379 00380 if (version_compare(buffer1, buffer2) == 1) { 00381 *upper = _discover_xmalloc(bufptr1 - buffer1 + 1); 00382 strcpy(*upper, buffer1); 00383 *upper_inclusive = first_inclusive; 00384 00385 *lower = _discover_xmalloc(bufptr2 - buffer2 + 1); 00386 strcpy(*lower, buffer2); 00387 *lower_inclusive = second_inclusive; 00388 } else { 00389 *lower = _discover_xmalloc(bufptr1 - buffer1 + 1); 00390 strcpy(*lower, buffer1); 00391 *lower_inclusive = first_inclusive; 00392 00393 *upper = _discover_xmalloc(bufptr2 - buffer2 + 1); 00394 strcpy(*upper, buffer2); 00395 *upper_inclusive = second_inclusive; 00396 } 00397 00398 /* EXIT POINT */ 00399 return 1; 00400 00401 default: 00402 state = ERROR; 00403 last_good_state = -1; 00404 break; 00405 } 00406 00407 if (state == ERROR) { 00408 /* Do something. */ 00409 return 0; 00410 } 00411 00412 /* 00413 * We don't care about recording spaces; let's simplify by not 00414 * doing so, in case we'd be missing something valuable. 00415 */ 00416 if (!isspace(*current)) { 00417 last_char = *current; 00418 } 00419 00420 current++; 00421 } 00422 } 00423 00437 int 00438 discover_xml_version_cmp(char *range, char *version, discover_error_t *status) 00439 { 00440 char *upper, *lower; 00441 int upper_inclusive, lower_inclusive; 00442 char *next_range; 00443 int range_count = 0; 00444 00445 assert(range != NULL); 00446 assert(version != NULL); 00447 assert(status != NULL); 00448 00449 next_range = range; 00450 00451 while(*next_range != '\0') { 00452 range_count++; 00453 if (determine_range(next_range, &upper, &upper_inclusive, 00454 &lower, &lower_inclusive, &next_range)) { 00455 /* 00456 * First test: Does this version match the upper end of the 00457 * range exactly? If so, is the upper end of the range 00458 * inclusive? 00459 * 00460 * Second test: Does this version match the lower end of the 00461 * range? If so, is the lower end inclusive? 00462 * 00463 * Finally, is the version higher than the lower end, and lower 00464 * then the upper end? 00465 */ 00466 if (version_compare(version, upper) == -1 00467 && upper_inclusive) { 00468 return range_count; 00469 } else if (version_compare(version, lower) == -1 00470 && lower_inclusive) { 00471 return range_count; 00472 } else if (version_compare(version, lower) > 0 && 00473 version_compare(upper, version) > 0) { 00474 return range_count; 00475 } 00476 00477 } else { 00478 status->code = DISCOVER_EBADVERSION; 00479 return -1; 00480 } 00481 } 00482 00483 return 0; 00484 } 00485
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/busclass-xml_8c-source.html 0000644 0023421 0023421 00000047410 10655642004 023421 0 ustar pere pere
busclass-xml.c
Go to the documentation of this file.00001 00010 /* $Progeny$ 00011 * 00012 * AUTHOR: John R. Daily <jdaily@progeny.com> 00013 * 00014 * Copyright 2002 Progeny Linux Systems, Inc. 00015 * Copyright 2002 Hewlett-Packard Company 00016 * 00017 * Permission is hereby granted, free of charge, to any person obtaining a 00018 * copy of this software and associated documentation files (the "Software"), 00019 * to deal in the Software without restriction, including without limitation 00020 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00021 * and/or sell copies of the Software, and to permit persons to whom the 00022 * Software is furnished to do so, subject to the following conditions: 00023 * 00024 * The above copyright notice and this permission notice shall be included in 00025 * all copies or substantial portions of the Software. 00026 * 00027 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00028 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00029 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00030 * THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00031 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 00032 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 00033 * DEALINGS IN THE SOFTWARE. 00034 */ 00035 00036 #include "config.h" 00037 00038 #include <sys/types.h> 00039 00040 #include <assert.h> 00041 #include <limits.h> 00042 #include <stdio.h> 00043 #include <string.h> 00044 00045 #include <expat.h> 00046 00047 #include <discover/discover.h> 00048 #include <discover/discover-xml.h> 00049 00050 #include <discover/load-url.h> 00051 #include <discover/utils.h> 00052 00054 struct discover_xml_busclass { 00055 char *id; 00056 char *name; 00057 discover_xml_busclass_t *next; 00058 }; 00059 00060 static discover_xml_busclass_t *busclasses[BUS_COUNT]; 00061 00062 struct context { 00063 discover_xml_busclass_t **blist; 00064 00065 int unknown_level; /* How deep are we into unknown XML tags? */ 00066 }; 00067 00068 static char *known_bus_elements[] = { 00069 "busclass", 00070 "busclass_list", 00071 NULL 00072 }; 00073 00074 static bool 00075 unknown_bus_element(const XML_Char * const tag) 00076 { 00077 int i; 00078 for (i = 0; known_bus_elements[i] != NULL; i++) { 00079 if (strcmp(tag, known_bus_elements[i]) == 0) 00080 return false; 00081 } 00082 return true; 00083 } 00084 00085 static void 00086 start_element(void *ctx, const XML_Char *name, const XML_Char *attrs[]) 00087 { 00088 struct context *context = ctx; 00089 int i; 00090 char *vid, *vname; 00091 discover_xml_busclass_t *next, **blist; 00092 00093 assert(context != NULL); 00094 assert(name != NULL); 00095 assert(attrs != NULL); 00096 00097 if (unknown_bus_element(name)) { 00098 context->unknown_level++; 00099 return; 00100 } 00101 00102 if (context->unknown_level > 0) { 00103 return; 00104 } 00105 00106 if (strcmp(name, "busclass") == 0) { 00107 vid = vname = NULL; 00108 for (i = 0; attrs[i]; i += 2) { 00109 if (strcmp(attrs[i], "id") == 0) { 00110 vid = (char *) attrs[i + 1]; 00111 } else if (strcmp(attrs[i], "name") == 0) { 00112 vname = (char *) attrs[i + 1]; 00113 } 00114 } 00115 00116 assert(vid != NULL); 00117 assert(vname != NULL); 00118 00119 blist = context->blist; 00120 next = *blist; 00121 *blist = discover_xml_busclass_new(); 00122 (*blist)->id = _discover_xstrdup(vid); 00123 (*blist)->name = _discover_xstrdup(vname); 00124 (*blist)->next = next; 00125 } 00126 } 00127 00128 static void 00129 end_element(void *ctx, const XML_Char *name) 00130 { 00131 struct context *context = ctx; 00132 00133 assert(context != NULL); 00134 assert(name != NULL); 00135 00136 if (unknown_bus_element(name)) { 00137 context->unknown_level--; 00138 return; 00139 } 00140 00141 if (context->unknown_level > 0) { 00142 return; 00143 } 00144 00145 /* 00146 * We don't have any end tags to worry about, but if we did, they 00147 * would be handled here. 00148 */ 00149 } 00150 00151 00164 /* Sshh! Don't tell, but this doesn't actually do any merging at all. 00165 * Instead, it simply inserts newer entries at the front of the list, 00166 * meaning that busclass info found later supersedes info found earlier. 00167 * This gives the illusion of merging, but potentially wastes memory 00168 * with duplicates. 00169 */ 00170 void 00171 discover_xml_merge_busclass_url(discover_xml_busclass_t **blist, 00172 char *url, discover_error_t *status) 00173 { 00174 XML_Parser parser; 00175 struct context context; 00176 00177 assert(url != NULL); 00178 assert(status != NULL); 00179 00180 status->code = 0; 00181 00182 context.blist = blist; 00183 context.unknown_level = 0; 00184 00185 parser = XML_ParserCreate(NULL); 00186 XML_SetElementHandler(parser, start_element, end_element); 00187 XML_SetUserData(parser, &context); 00188 00189 if (!_discover_load_url(url, parser)) { 00190 XML_ParserFree(parser); 00191 status->code = DISCOVER_EIO; 00192 return; 00193 } 00194 00195 if (!XML_Parse(parser, "", 0, 1)) { 00196 XML_ParserFree(parser); 00197 status->code = DISCOVER_EXML; 00198 return; 00199 } 00200 00201 XML_ParserFree(parser); 00202 00203 return; 00204 } 00205 00212 discover_xml_busclass_t * 00213 discover_xml_get_busclasses(discover_bus_t bus, discover_error_t *status) 00214 { 00215 discover_xml_url_t *urls, *i; 00216 char *url; 00217 00218 assert(status != NULL); 00219 00220 status->code = 0; 00221 00222 if (!busclasses[bus]) { 00223 urls = discover_xml_get_data_urls(bus, BUSCLASS_TYPE, status); 00224 if (status->code != 0) { 00225 return NULL; 00226 } 00227 00228 for (i = urls; 00229 i; 00230 i = discover_xml_url_get_next(i)) { 00231 url = discover_xml_url_get_url(i); 00232 discover_xml_merge_busclass_url(&(busclasses[bus]), url, status); 00233 if (status->code != 0) { 00234 return NULL; 00235 } 00236 } 00237 } 00238 00239 return busclasses[bus]; 00240 } 00241 00242 00246 void 00247 discover_xml_free_busclasses(void) 00248 { 00249 int i; 00250 for (i = 0; i < BUS_COUNT; i++) { 00251 discover_xml_busclass_free(busclasses[i]); 00252 busclasses[i] = NULL; 00253 } 00254 } 00255 00262 char * 00263 discover_xml_busclass_to_class(char *busclass, 00264 discover_xml_busclass_t *busclasses) 00265 { 00266 char *result; 00267 00268 assert(busclass != NULL); 00269 assert(busclasses != NULL); 00270 00271 result = NULL; 00272 00273 for (; 00274 busclasses; 00275 busclasses = busclasses->next) { 00276 if (strcmp(busclass, busclasses->id) == 0) { 00277 result = busclasses->name; 00278 break; 00279 } 00280 } 00281 00282 return result; 00283 } 00284 00294 int 00295 discover_xml_busclass_cmp(char *busclass, char *discover_class, 00296 discover_xml_busclass_t *busclasses) 00297 { 00298 char *found_class_name = NULL; 00299 00300 assert(busclass != NULL); 00301 assert(discover_class != NULL); 00302 assert(busclasses != NULL); 00303 00304 if (strcmp(discover_class, "all") == 0) { 00305 return 0; 00306 } 00307 00308 found_class_name = discover_xml_busclass_to_class(busclass, busclasses); 00309 00310 /* 00311 * If the busclass database doesn't know about this device class, we 00312 * can't make any valid comparison. 00313 */ 00314 if (found_class_name == NULL) { 00315 return -1; 00316 } 00317 00318 return strcmp(found_class_name, discover_class); 00319 } 00320 00326 char * 00327 discover_xml_busclass_get_id(discover_xml_busclass_t *busclass) 00328 { 00329 assert(busclass != NULL); 00330 00331 return busclass->id; 00332 } 00333 00339 char * 00340 discover_xml_busclass_get_name(discover_xml_busclass_t *busclass) 00341 { 00342 assert(busclass != NULL); 00343 00344 return busclass->name; 00345 } 00346 00351 discover_xml_busclass_t * 00352 discover_xml_busclass_get_next(discover_xml_busclass_t *busclass) 00353 { 00354 assert(busclass != NULL); 00355 00356 return busclass->next; 00357 } 00358 00362 discover_xml_busclass_t * 00363 discover_xml_busclass_new(void) 00364 { 00365 discover_xml_busclass_t *new; 00366 00367 new = _discover_xmalloc(sizeof(discover_xml_busclass_t)); 00368 00369 new->id = NULL; 00370 new->name = NULL; 00371 new->next = NULL; 00372 00373 return new; 00374 } 00375 00381 void 00382 discover_xml_busclass_free(discover_xml_busclass_t *busclasses) 00383 { 00384 discover_xml_busclass_t *busclass, *last; 00385 00386 last = NULL; 00387 00388 for (busclass = busclasses; 00389 busclass; 00390 busclass = busclass->next) { 00391 if (busclass->id) { 00392 free(busclass->id); 00393 } 00394 00395 if (busclass->name) { 00396 free(busclass->name); 00397 } 00398 00399 if (last) { 00400 free(last); 00401 } 00402 last = busclass; 00403 } 00404 00405 if (last) { 00406 free(last); 00407 } 00408 } 00409 00412 /* 00413 * Local variables: 00414 * c-file-style: "progeny" 00415 * indent-tabs-mode: nil 00416 * End: 00417 */ 00418 /* vim: set cin fo=tcroq sw=4 et sts=4 tw=75: */
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/dir_000000.html 0000644 0023421 0023421 00000002712 10655642004 020465 0 ustar pere pere
include Directory Reference
Directories | |
| directory | discover |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/dir_000003.html 0000644 0023421 0023421 00000002706 10655642004 020473 0 ustar pere pere
sysdeps Directory Reference
Directories | |
| directory | stub |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/sysdep_8c-source.html 0000644 0023421 0023421 00000050077 10655642004 022316 0 ustar pere pere
sysdep.c
Go to the documentation of this file.00001 00010 /* $Progeny$ 00011 * 00012 * AUTHOR: John R. Daily <jdaily@progeny.com> 00013 * 00014 * Copyright 2002 Progeny Linux Systems, Inc. 00015 * 00016 * Permission is hereby granted, free of charge, to any person obtaining a 00017 * copy of this software and associated documentation files (the "Software"), 00018 * to deal in the Software without restriction, including without limitation 00019 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00020 * and/or sell copies of the Software, and to permit persons to whom the 00021 * Software is furnished to do so, subject to the following conditions: 00022 * 00023 * The above copyright notice and this permission notice shall be included in 00024 * all copies or substantial portions of the Software. 00025 * 00026 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00027 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00028 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00029 * THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00030 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 00031 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 00032 * DEALINGS IN THE SOFTWARE. 00033 */ 00034 #include <assert.h> 00035 00036 #include <stdio.h> 00037 #include <string.h> 00038 00039 #include <discover/discover.h> 00040 #include <discover/discover-conf.h> 00041 #include <discover/discover-xml.h> 00042 #include <discover/sysdep.h> 00043 00044 #include <discover/device.h> 00045 #include <discover/utils.h> 00046 00047 00049 typedef discover_sysdep_data_t *(raw_sysdep_function_t)(void); 00050 00051 static raw_sysdep_function_t *raw_map[] = { 00052 _discover_get_ata_raw, 00053 _discover_get_pci_raw, 00054 _discover_get_pcmcia_raw, 00055 _discover_get_scsi_raw, 00056 _discover_get_usb_raw 00057 }; 00058 00059 00060 /* 00061 * Utility functions 00062 */ 00063 00065 discover_sysdep_data_t * 00066 _discover_sysdep_data_new(void) 00067 { 00068 discover_sysdep_data_t *node = 00069 _discover_xmalloc(sizeof(discover_sysdep_data_t)); 00070 node->busclass = NULL; 00071 node->vendor = NULL; 00072 node->model = NULL; 00073 node->data = NULL; 00074 node->next = NULL; 00075 return node; 00076 } 00077 00079 discover_sysdep_device_data_t * 00080 _discover_sysdep_device_data_new(void) 00081 { 00082 discover_sysdep_device_data_t *node = 00083 _discover_xmalloc(sizeof(discover_sysdep_device_data_t)); 00084 node->path = NULL; 00085 node->value = NULL; 00086 node->next = NULL; 00087 return node; 00088 } 00089 00091 void 00092 _discover_free_sysdep_data(discover_sysdep_data_t *head) 00093 { 00094 discover_sysdep_data_t *node; 00095 00096 while (head) { 00097 node = head->next; 00098 if (head->vendor) { 00099 free(head->vendor); 00100 } 00101 if (head->model) { 00102 free(head->model); 00103 } 00104 if (head->busclass) { 00105 free(head->busclass); 00106 } 00107 if (head->data) { 00108 _discover_free_sysdep_device_data(head->data); 00109 } 00110 free(head); 00111 head = node; 00112 } 00113 } 00114 00116 void 00117 _discover_free_sysdep_device_data(discover_sysdep_device_data_t *head) 00118 { 00119 discover_sysdep_device_data_t *node; 00120 while (head) { 00121 node = head->next; 00122 if (head->path) { 00123 free(head->path); 00124 } 00125 if (head->value) { 00126 free(head->value); 00127 } 00128 free(head); 00129 head = node; 00130 } 00131 } 00132 00134 discover_data_t * 00135 _discover_convert_device_data(discover_sysdep_device_data_t *head) 00136 { 00137 discover_data_t *data_head, *data_current, *data_new; 00138 discover_sysdep_device_data_t *node; 00139 char *buffer, *path, *token; 00140 00142 data_head = discover_data_new(); 00143 data_head->discover_class = _discover_xstrdup("device"); 00144 00145 /* 00146 * Step through the device data nodes returned by the sysdeps. 00147 * Each node will have a path relative to the "device" toplevel, 00148 * separated by slashes, as well as a value. We need to set 00149 * each one up to look like it came from the XML data. 00150 */ 00151 for (node = head; node; node = head->next) { 00153 data_current = NULL; 00154 00156 path = _discover_xstrdup(node->path); 00157 buffer = _discover_xstrdup(node->path); 00158 00160 for (token = strtok_r(path, "/", &buffer); token; 00161 token = strtok_r(NULL, "/", &buffer)) { 00163 data_new = discover_data_new(); 00164 data_new->discover_class = _discover_xstrdup(token); 00165 00167 if (data_current == NULL) { 00169 if (data_head->child == NULL) { 00170 data_head->child = data_new; 00171 } else { 00172 data_current = data_head->child; 00173 while (data_current->next) 00174 data_current = data_current->next; 00175 data_current->next = data_new; 00176 } 00177 } else { 00179 data_current->child = data_new; 00180 data_new->parent = data_current; 00181 } 00182 00183 data_current = data_new; 00184 } 00185 00186 /* 00187 * We've gotten to the very last path element; set the 00188 * node's value here. 00189 */ 00190 data_current->text = _discover_xstrdup(node->value); 00191 00193 free(path); 00194 free(buffer); 00195 } 00196 00197 return data_head; 00198 } 00199 00200 /* 00201 * Functions that access the sysdeps 00202 */ 00203 static discover_device_t *devices[BUS_COUNT]; 00204 00205 discover_device_t * 00206 discover_get_devices(discover_bus_t bus, discover_error_t *status) 00207 { 00208 discover_device_t *device, *last; 00209 discover_device_t *xml_devices; 00210 discover_bus_map_t *busmap; 00211 discover_sysdep_data_t *head, *node; 00212 discover_data_t *data_head, *data_node; 00213 00214 assert(status); 00215 00216 status->code = DISCOVER_SUCCESS; 00217 device = last = NULL; 00218 00219 busmap = discover_conf_get_bus_map(bus, status); 00220 if (status->code != 0) { 00221 return NULL; 00222 } 00223 00224 if (busmap->scan_never) { 00225 status->code = DISCOVER_EBUSDISABLED; 00226 return NULL; 00227 } 00228 00229 if (devices[bus]) { 00230 return devices[bus]; 00231 } 00232 00233 xml_devices = discover_xml_get_devices(bus, status); 00234 if (!xml_devices) { 00235 return NULL; 00236 } 00237 00238 /* 00239 * Allow overrides of this function. 00240 */ 00241 if (busmap->get_raw) { 00242 head = node = busmap->get_raw(); 00243 } else { 00244 head = node = raw_map[bus](); 00245 } 00246 00247 while (node) { 00248 /* 00249 * The variable names are ambiguous: 00250 * node - Hardware data retrieved from the OS 00251 * device - Matching hardware data from our database 00252 */ 00253 device = 00254 discover_xml_get_matching_devices(xml_devices, node->vendor, 00255 node->model, status); 00256 00257 if (!device) { 00258 device = discover_device_new(); 00259 device->model_id = strdup(node->model); 00260 device->vendor_id = strdup(node->vendor); 00261 } 00262 00263 /* 00264 * If we get a busclass from the hardware, treat it as 00265 * canonical. 00266 */ 00267 if (node->busclass != NULL) { 00268 if (device->busclass != NULL) { 00269 free(device->busclass); 00270 } 00271 device->busclass = strdup(node->busclass); 00272 } 00273 00274 /* Add sysdep data to the data nodes. */ 00275 if (node->data != NULL) { 00276 data_head = _discover_convert_device_data(node->data); 00277 if (data_head != NULL) { 00278 for (data_node = data_head; data_node->next != NULL; 00279 data_node = data_node->next) ; 00280 data_node->next = device->data; 00281 device->data = data_head; 00282 } 00283 } 00284 00285 if (last) { 00286 last->next = device; 00287 last = device; 00288 } else { 00289 devices[bus] = last = device; 00290 } 00291 00292 node = node->next; 00293 } 00294 00295 _discover_free_sysdep_data(head); 00296 00297 return devices[bus]; 00298 } 00299 00300 void 00301 discover_free_devices(void) 00302 { 00303 int i; 00304 00305 for (i = 0; i < BUS_COUNT; i++) { 00306 discover_device_free(devices[i], 0); 00307 devices[i] = NULL; 00308 } 00309 } 00310 00311 /* 00312 * Local variables: 00313 * c-file-style: "progeny" 00314 * indent-tabs-mode: nil 00315 * End: 00316 */ 00317 /* vim: set cin fo=tcroq sw=4 et sts=4 tw=75: */
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/dir_000002.html 0000644 0023421 0023421 00000011627 10655642004 020474 0 ustar pere pere
lib Directory Reference
Files | |
| file | busclass-xml.c [code] |
| Busclass XML data file parsing. | |
| file | conf.c [code] |
| Configuration handling (including XML parsing). | |
| file | core.c [code] |
| Core and miscellaneous routines. | |
| file | device-xml.c [code] |
| Device XML data file parsing. | |
| file | device.c [code] |
| Device enumeration and information management. | |
| file | load-url.c [code] |
| File loading helper functions. | |
| file | stack.c [code] |
| Stack routines for Discover. | |
| file | sysdep.c [code] |
| Interact with system dependencies. | |
| file | url-xml.c [code] |
| XML URL handling. | |
| file | vendor-xml.c [code] |
| Vendor XML data file parsing. | |
| file | version-cmp.c [code] |
| Version comparison functions. | |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/globals_defs.html 0000644 0023421 0023421 00000003107 10655642004 021533 0 ustar pere pere
- BUS_COUNT : discover.h
- IDLEN : device-xml.c
- MAXBUFLEN : version-cmp.c
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/load-url_8c.html 0000644 0023421 0023421 00000005254 10655642004 021225 0 ustar pere pere
load-url.c File Reference
File loading helper functions. More...
#include "config.h"
#include <assert.h>
#include <expat.h>
#include <discover/load-url.h>
#include <stdio.h>
#include <string.h>
Go to the source code of this file.
Defines | |
| #define | STDIO_READ(f, buf, len) fread(buf, 1, len, f) |
Typedefs | |
| typedef FILE * | stdio_file |
Functions | |
| int | _discover_load_url (const char *url, XML_Parser parser) |
Detailed Description
File loading helper functions.
Definition in file load-url.c.
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/dir_000004.html 0000644 0023421 0023421 00000003216 10655642004 020471 0 ustar pere pere
stub Directory Reference
Files | |
| file | stubs.c [code] |
| Stub system-dependent code. | |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/group__device.html 0000644 0023421 0023421 00000110075 10655642004 021724 0 ustar pere pere
Devices
Function Documentation
|
|
Free the data tree. Note that unlike the other free functions in Discover, this one does not free data_tree itself. This is a side-effect of how it is implemented. It frees all children and siblings of data_tree as well as the data. After calling discover_data_free, you have to call free(3) on data_tree itself.
Definition at line 436 of file device.c. References discover_data_free(). Referenced by discover_data_free(), and discover_device_free(). |
|
|
Get the child member of data. |
|
|
Get the class member of data. |
|
|
Get the first member of data. |
|
|
Get the next member of data. |
|
|
Get the parent member of data. |
|
|
Get the prev member of data. |
|
|
Get the text member of data. |
|
|
Create and initialize a new discover_data_t structure. Definition at line 409 of file device.c. Referenced by _discover_convert_device_data(). |
|
||||||||||||
|
Copy a device structure.
Definition at line 268 of file device.c. Referenced by discover_device_find(), and discover_xml_get_matching_devices(). |
|
||||||||||||
|
Get a list of devices of a specified class on all buses scanned by default.
Definition at line 63 of file device.c. References discover_error::code, discover_error::create_message, discover_conf_get_full_bus_map(), discover_device_copy(), discover_device_get_next(), discover_device_new(), DISCOVER_EDEVICENOTFOUND, discover_get_devices(), DISCOVER_SUCCESS, discover_xml_busclass_cmp(), and discover_xml_get_busclasses(). |
|
||||||||||||
|
Free the device or list of devices. Pass 1 as the second argument to free the data structure for this device, 0 to leave it. It is necessary to specify 0 when one structure was copied from another with discover_device_copy. Otherwise, you must pass 1.
Definition at line 592 of file device.c. References discover_data_free(). Referenced by discover_free_devices(), and discover_xml_free_devices(). |
|
|
Get the busclass member of device. |
|
||||||||||||||||||||
|
Get the data matching the class path and version number (optional) from the device structure. The class parameter requires further explanation. The XML data sources have hierarchical data elements for each device. You access the data in an element by specifying the path along the data elements to it. For example, device elements for video cards usually have a data element of class "xfree86" containing data related to the XFree86 package; that element itself usually contains a data element of class "server" that specifies which server to use for this video card. You access this data by passing the string "xfree86/server" to this function.
Definition at line 204 of file device.c. References discover_error::code. |
|
|
Get the data member of device. |
|
|
Get the model_id member of device. |
|
|
Get the model_name member of device. |
|
|
Get the next member of device. Definition at line 551 of file device.c. Referenced by discover_device_find(). |
|
|
Get the vendor_id member of device. |
|
|
Get the vendor_name member of device. |
|
|
Create and initialize a new discover_device_t structure. Definition at line 562 of file device.c. Referenced by discover_device_find(), discover_get_devices(), and discover_xml_get_matching_devices(). |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/functions_vars.html 0000644 0023421 0023421 00000004765 10655642004 022165 0 ustar pere pere
- busclass : discover_sysdep_data
- code : discover_error
- create_message : discover_error
- data : discover_sysdep_data
- get_raw : discover_bus_map
- message : discover_error
- model : discover_sysdep_data
- name : discover_bus_map
- next : discover_sysdep_data, discover_sysdep_device_data
- path : discover_sysdep_device_data
- scan_default : discover_bus_map
- scan_never : discover_bus_map
- value : discover_sysdep_device_data
- vendor : discover_sysdep_data
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/modules.html 0000644 0023421 0023421 00000003330 10655642004 020555 0 ustar pere pere
discover Modules
Here is a list of all modules:- Busclass list XML parsing
- Configuration handling
- Core functionality
- Device list XML parsing
- Devices
- URL list XML parsing
- Vendor list XML parsing
- Version comparison
- System-dependent interfaces
- Types
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/core_8c.html 0000644 0023421 0023421 00000007330 10655642004 020433 0 ustar pere pere
core.c File Reference
Core and miscellaneous routines. More...
#include "config.h"
#include <assert.h>
#include <discover/discover.h>
#include <discover/discover-xml.h>
#include <discover/utils.h>
Go to the source code of this file.
Functions | |
| discover_error_t * | discover_error_new (void) |
| void * | _discover_create_message (discover_error_t **status, char *message) |
| void | discover_error_free (discover_error_t *status) |
| char * | discover_strerror (discover_error_t *err) |
| int | discover_major_version (void) |
| int | discover_minor_version (void) |
| int | discover_micro_version (void) |
Detailed Description
Core and miscellaneous routines.This file provides core routines that don't really fit anyplace else. There are likely some other routines that really should be in here.
Definition in file core.c.
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/globals_enum.html 0000644 0023421 0023421 00000003645 10655642004 021565 0 ustar pere pere
- discover_bus_t : discover.h
- discover_error_code_t : discover.h
- discover_filetype_t : discover.h
- range_states : version-cmp.c
- scan_flag : conf.c
- state : url-xml.c, device-xml.c, conf.c
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/sysdep_8c.html 0000644 0023421 0023421 00000042151 10655642004 021012 0 ustar pere pere
sysdep.c File Reference
Interact with system dependencies. More...
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <discover/discover.h>
#include <discover/discover-conf.h>
#include <discover/discover-xml.h>
#include <discover/sysdep.h>
#include <discover/device.h>
#include <discover/utils.h>
Go to the source code of this file.
Typedefs | |
| typedef discover_sysdep_data_t *( | raw_sysdep_function_t )(void) |
Functions | |
| discover_sysdep_data_t * | _discover_sysdep_data_new (void) |
| discover_sysdep_device_data_t * | _discover_sysdep_device_data_new (void) |
| void | _discover_free_sysdep_data (discover_sysdep_data_t *head) |
| void | _discover_free_sysdep_device_data (discover_sysdep_device_data_t *head) |
| discover_data_t * | _discover_convert_device_data (discover_sysdep_device_data_t *head) |
| discover_device_t * | discover_get_devices (discover_bus_t bus, discover_error_t *status) |
| void | discover_free_devices (void) |
Detailed Description
Interact with system dependencies.This file holds the routines that interact with the system-dependent interface. This file essentially bridges the gap between the XML data and the hardware contained within the machine.
Definition in file sysdep.c.
Typedef Documentation
|
|
Function pointers |
Function Documentation
|
|
Convert sysdep device data into discover data under the "device" node. Set up the toplevel data node. Set up the first parent below "device" for this node. Set up the token parser. Split the node path by the path separator. Set up the new data node. Does this node have a predecessor in the path? No; make it a child of the "device" node. Yes; make it a child of the previous. Clean up after the token parser. Definition at line 135 of file sysdep.c. References discover_data_new(), discover_sysdep_device_data::next, discover_sysdep_device_data::path, and discover_sysdep_device_data::value. Referenced by discover_get_devices(). |
|
|
Release the memory that the sysdep data was holding. Definition at line 92 of file sysdep.c. References _discover_free_sysdep_device_data(), discover_sysdep_data::busclass, discover_sysdep_data::data, discover_sysdep_data::model, discover_sysdep_data::next, and discover_sysdep_data::vendor. Referenced by discover_get_devices(). |
|
|
Release memory being held by device-specific data. Definition at line 117 of file sysdep.c. References discover_sysdep_device_data::next, discover_sysdep_device_data::path, and discover_sysdep_device_data::value. Referenced by _discover_free_sysdep_data(). |
|
|
Create a new instance of sysdep data. Definition at line 66 of file sysdep.c. References discover_sysdep_data::busclass, discover_sysdep_data::data, discover_sysdep_data::model, discover_sysdep_data::next, and discover_sysdep_data::vendor. |
|
|
Create a new instance of sysdep device data. Definition at line 80 of file sysdep.c. References discover_sysdep_device_data::next, discover_sysdep_device_data::path, and discover_sysdep_device_data::value. |
|
|
Free the currently allocated memory holding the device information. Definition at line 301 of file sysdep.c. References BUS_COUNT, and discover_device_free(). |
|
||||||||||||
|
Function responsible for returning a devicelist of current devices Definition at line 206 of file sysdep.c. References _discover_convert_device_data(), _discover_free_sysdep_data(), discover_error::code, discover_conf_get_bus_map(), discover_device_new(), DISCOVER_EBUSDISABLED, DISCOVER_SUCCESS, discover_xml_get_devices(), discover_xml_get_matching_devices(), discover_bus_map::get_raw, and discover_bus_map::scan_never. Referenced by discover_device_find(). |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/structdiscover__sysdep__data.html 0000644 0023421 0023421 00000017422 10655642004 025055 0 ustar pere pere
discover_sysdep_data Struct Reference
#include <sysdep.h>
Data Fields | |
| char * | busclass |
| char * | vendor |
| char * | model |
| discover_sysdep_device_data_t * | data |
| discover_sysdep_data * | next |
Detailed Description
Linked list node, used to return hardware-identification information discovered by the system-dependent interface
Definition at line 56 of file sysdep.h.
Field Documentation
|
|
String describing the general device class Definition at line 58 of file sysdep.h. Referenced by _discover_free_sysdep_data(), and _discover_sysdep_data_new(). |
|
|
Pointer to any sysdep/device specific data to be returned Definition at line 64 of file sysdep.h. Referenced by _discover_free_sysdep_data(), and _discover_sysdep_data_new(). |
|
|
String identifying the model Definition at line 62 of file sysdep.h. Referenced by _discover_free_sysdep_data(), and _discover_sysdep_data_new(). |
|
|
Pointer to the next hardware device discovered Definition at line 66 of file sysdep.h. Referenced by _discover_free_sysdep_data(), and _discover_sysdep_data_new(). |
|
|
String describing the manufacturer or distributor Definition at line 60 of file sysdep.h. Referenced by _discover_free_sysdep_data(), and _discover_sysdep_data_new(). |
The documentation for this struct was generated from the following file:
- /home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/sysdep.h
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/functions.html 0000644 0023421 0023421 00000005136 10655642004 021123 0 ustar pere pere
- busclass : discover_sysdep_data
- code : discover_error
- create_message : discover_error
- data : discover_sysdep_data
- get_raw : discover_bus_map
- message : discover_error
- model : discover_sysdep_data
- name : discover_bus_map
- next : discover_sysdep_data, discover_sysdep_device_data
- path : discover_sysdep_device_data
- scan_default : discover_bus_map
- scan_never : discover_bus_map
- value : discover_sysdep_device_data
- vendor : discover_sysdep_data
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/stack_8c-source.html 0000644 0023421 0023421 00000015711 10655642004 022110 0 ustar pere pere
stack.c
Go to the documentation of this file.00001 /* $Progeny$ */ 00002 00014 /* 00015 * AUTHOR: Josh Bressers <bressers@progeny.com> 00016 * 00017 * Copyright 2002 Progeny Linux Systems, Inc. 00018 * 00019 * Permission is hereby granted, free of charge, to any person obtaining a 00020 * copy of this software and associated documentation files (the "Software"), 00021 * to deal in the Software without restriction, including without limitation 00022 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00023 * and/or sell copies of the Software, and to permit persons to whom the 00024 * Software is furnished to do so, subject to the following conditions: 00025 * 00026 * The above copyright notice and this permission notice shall be included in 00027 * all copies or substantial portions of the Software. 00028 * 00029 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00030 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00031 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00032 * THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00033 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 00034 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 00035 * DEALINGS IN THE SOFTWARE. 00036 */ 00037 00038 #include <stdio.h> 00039 #include <assert.h> 00040 #include <stdbool.h> 00041 #include <stdlib.h> 00042 00043 #include <discover/utils.h> 00044 #include <discover/stack.h> 00045 00046 00048 discover_xml_stack * discover_xml_stack_new() 00049 { 00050 discover_xml_stack *stack; 00051 stack = (discover_xml_stack *) _discover_xmalloc(sizeof(discover_xml_stack)); 00052 assert(stack != NULL); 00053 00054 stack->prev = NULL; 00055 stack->data = NULL; 00056 stack->depth = 0; 00057 00058 return stack; 00059 } 00060 00062 void discover_xml_stack_destroy(discover_xml_stack *stack) 00063 { 00064 free(stack); 00065 } 00066 00068 void 00069 discover_xml_stack_push(discover_xml_stack **stack, void *data) 00070 { 00071 discover_xml_stack *new_stack; 00072 00073 new_stack = discover_xml_stack_new(); 00074 00075 00076 new_stack->prev = *stack; 00077 new_stack->data = data; 00078 new_stack->depth = (*stack)->depth + 1; 00079 *stack = new_stack; 00080 } 00081 00083 void * discover_xml_stack_pop(discover_xml_stack **stack) 00084 { 00085 void *ctx; 00086 discover_xml_stack *oldstack; 00087 00088 if((*stack)->prev == 0) { 00089 return NULL; 00090 } 00091 00092 oldstack = *stack; 00093 ctx = (*stack)->data; 00094 00095 *stack = (*stack)->prev; 00096 (*stack)->depth = oldstack->depth - 1; 00097 discover_xml_stack_destroy(oldstack); 00098 00099 return ctx; 00100 } 00101 00103 void * discover_xml_stack_get(discover_xml_stack *stack) 00104 { 00105 return stack->data; 00106 } 00107 00109 void * discover_xml_stack_getbynum(discover_xml_stack *stack, int i) 00110 { 00111 discover_xml_stack *S; 00112 00113 S = stack; 00114 while(S->depth < i) { 00115 S = stack->prev; 00116 } 00117 return S->data; 00118 } 00119 00120 /* 00121 * Local variables: 00122 * c-file-style: "progeny" 00123 * indent-tabs-mode: nil 00124 * End: 00125 */ 00126 /* vim: set cin fo=tcroq sw=4 et sts=4 tw=75: */
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/dirs.html 0000644 0023421 0023421 00000002562 10655642004 020054 0 ustar pere pere
discover Directories
This directory hierarchy is sorted roughly, but not completely, alphabetically:Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/url-xml_8c.html 0000644 0023421 0023421 00000016356 10655642004 021113 0 ustar pere pere
url-xml.c File Reference
XML URL handling. More...
#include "config.h"
#include <assert.h>
#include <string.h>
#include <expat.h>
#include <discover/discover.h>
#include <discover/discover-conf.h>
#include <discover/discover-xml.h>
#include <discover/load-url.h>
#include <discover/url-xml.h>
#include <discover/utils.h>
Go to the source code of this file.
Enumerations | |
| enum | state { START, DISCOVER_DATA } |
Functions | |
| discover_xml_url_t * | discover_xml_get_urls (discover_error_t *status) |
| void | discover_xml_free_urls (void) |
| discover_xml_url_t * | discover_xml_get_data_urls (discover_bus_t bus, discover_filetype_t filetype, discover_error_t *status) |
| void | discover_xml_free_data_urls (void) |
| discover_xml_url_t * | discover_xml_url_new (void) |
| void | discover_xml_url_copy (discover_xml_url_t *src, discover_xml_url_t *dst) |
| char * | discover_xml_url_get_url (discover_xml_url_t *url) |
| char * | discover_xml_url_get_label (discover_xml_url_t *url) |
| char * | discover_xml_url_get_bus (discover_xml_url_t *url) |
| char * | discover_xml_url_get_type (discover_xml_url_t *url) |
| discover_xml_url_t * | discover_xml_url_get_next (discover_xml_url_t *url) |
| discover_xml_url_t * | discover_xml_url_get_last (discover_xml_url_t *url) |
| void | discover_xml_url_free (discover_xml_url_t *urls) |
Detailed Description
XML URL handling.This file is used when loading data about the URLs to be parsed. This data will be read from a file, either specified from the configuration file or passed in as an append or insert.
Definition in file url-xml.c.
Enumeration Type Documentation
|
|
Define possible states within the XML data. |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/globals_eval.html 0000644 0023421 0023421 00000004315 10655642004 021543 0 ustar pere pere
- DISCOVER_EBADVERSION : discover.h
- DISCOVER_EBUSDISABLED : discover.h
- DISCOVER_EBUSNOTFOUND : discover.h
- DISCOVER_EDATANOTFOUND : discover.h
- DISCOVER_EDEVICENOTFOUND : discover.h
- DISCOVER_EIO : discover.h
- DISCOVER_ENOIMPL : discover.h
- DISCOVER_ESYS : discover.h
- DISCOVER_EXML : discover.h
- DISCOVER_SUCCESS : discover.h
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/structdiscover__error.html 0000644 0023421 0023421 00000016531 10655642004 023547 0 ustar pere pere
discover_error Struct Reference
[Types]
#include <discover.h>
Data Fields | |
| discover_error_code_t | code |
| char * | message |
| discover_create_message_t * | create_message |
Detailed Description
All functions that perform some action (as opposed to returning a member of a structure, for example) take an argument of this type. It is used to report that the action succeeded, or why it failed.
Definition at line 106 of file discover.h.
Field Documentation
|
|
|
Function pointer into a routine to create a message for us Definition at line 112 of file discover.h. Referenced by discover_conf_load(), discover_device_find(), and discover_error_new(). |
|
|
String containing the message from the last error Definition at line 110 of file discover.h. Referenced by discover_error_free(), and discover_error_new(). |
The documentation for this struct was generated from the following file:
- /home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/discover.h
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/device_8c-source.html 0000644 0023421 0023421 00000071517 10655642004 022250 0 ustar pere pere
device.c
Go to the documentation of this file.00001 00011 /* $Progeny$ 00012 * 00013 * Copyright 2001, 2002 Progeny Linux Systems, Inc. 00014 * Copyright 2002 Hewlett-Packard Company 00015 * 00016 * Permission is hereby granted, free of charge, to any person obtaining a 00017 * copy of this software and associated documentation files (the "Software"), 00018 * to deal in the Software without restriction, including without limitation 00019 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00020 * and/or sell copies of the Software, and to permit persons to whom the 00021 * Software is furnished to do so, subject to the following conditions: 00022 * 00023 * The above copyright notice and this permission notice shall be included in 00024 * all copies or substantial portions of the Software. 00025 * 00026 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00027 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00028 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00029 * THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00030 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 00031 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 00032 * DEALINGS IN THE SOFTWARE. 00033 */ 00034 00035 #include "config.h" 00036 00037 #include <sys/types.h> 00038 00039 #include <assert.h> 00040 #include <stdbool.h> 00041 #include <string.h> 00042 00043 #include <discover/discover.h> 00044 #include <discover/discover-conf.h> 00045 #include <discover/discover-xml.h> 00046 00047 #include <discover/device.h> 00048 #include <discover/utils.h> 00049 00062 discover_device_t * 00063 discover_device_find(char *discover_class, discover_error_t *status) 00064 { 00065 discover_device_t *result, *device, *last, *new_device; 00066 discover_xml_busclass_t *busclasses; 00067 discover_bus_map_t *busmap; 00068 int i; 00069 00070 assert(discover_class); 00071 00072 result = last = NULL; 00073 00074 busmap = discover_conf_get_full_bus_map(status); 00075 if (status->code != 0) { 00076 return NULL; 00077 } 00078 00079 for (i = 0; busmap[i].name; i++) { 00080 if (!busmap[i].scan_default) { 00081 continue; 00082 } 00083 00084 busclasses = discover_xml_get_busclasses(i, status); 00085 if (status->code != 0) { 00086 return result; 00087 } 00088 for (device = discover_get_devices(i, status); 00089 device; 00090 device = discover_device_get_next(device)) { 00091 if (!device->busclass) { 00092 /* This is a device about which we know nothing. */ 00093 continue; 00094 } 00095 if (discover_xml_busclass_cmp(device->busclass, discover_class, 00096 busclasses) == 0) { 00097 new_device = discover_device_new(); 00098 discover_device_copy(device, new_device); 00099 new_device->next = NULL; 00100 00101 if (last) { 00102 last->next = new_device; 00103 last = new_device; 00104 } else { 00105 result = last = new_device; 00106 } 00107 } 00108 } 00109 00110 if (status->code != 0) { 00111 return result; 00112 } 00113 } 00114 00115 if (result) { 00116 status->code = DISCOVER_SUCCESS; 00117 } else { 00118 char *message = _discover_xmalloc(100); 00119 snprintf(message, 100, "Device \"%s\" not found", 00120 discover_class); 00121 status->code = DISCOVER_EDEVICENOTFOUND; 00122 status->create_message(&status, message); 00123 } 00124 00125 return result; 00126 } 00127 00128 static discover_data_t * 00129 scan_data_list(discover_data_t *node, char *discover_class, char **version, 00130 discover_error_t *status) 00131 { 00132 discover_data_t *result = NULL; 00133 int cmp; 00134 00135 for ( ; node != NULL; node = node->next) { 00136 if (strcmp(node->discover_class, discover_class) == 0) { 00137 if (*version && node->version) { 00138 cmp = discover_xml_version_cmp(node->version, 00139 *version, status); 00140 00141 if (status->code != 0) { 00142 return result; 00143 } 00144 if (cmp) { 00145 result = node; 00146 /* The version is no longer relevant for nested data 00147 * elements. 00148 */ 00149 *version = NULL; 00150 break; 00151 } 00152 } else { 00153 result = node; 00154 break; 00155 } 00156 } 00157 } 00158 return result; 00159 } 00160 00161 00162 static discover_data_t * 00163 get_data(discover_device_t *device, char *discover_class, char **version, 00164 discover_error_t *status) 00165 { 00166 assert(device != NULL); 00167 assert(discover_class != NULL); 00168 00169 return scan_data_list(device->data, discover_class, version, status); 00170 } 00171 00172 static discover_data_t * 00173 get_child_data(discover_data_t *data, char *discover_class, char **version, 00174 discover_error_t *status) 00175 { 00176 assert(data != NULL); 00177 assert(discover_class != NULL); 00178 00179 return scan_data_list(data->child, discover_class, version, status); 00180 } 00181 00203 char * 00204 discover_device_get_data(discover_device_t *device, char *discover_class, 00205 char *version, discover_error_t *status) 00206 { 00207 discover_data_t *data; 00208 char *result, *tmp, *tmp_orig, **argv, *block; 00209 size_t argv_len; 00210 int i; 00211 00212 assert(device != NULL); 00213 assert(discover_class != NULL); 00214 assert(status != NULL); 00215 00216 status->code = 0; 00217 00218 data = NULL; 00219 result = NULL; 00220 tmp_orig = tmp = _discover_xstrdup(discover_class); 00221 argv = NULL; 00222 argv_len = 0; 00223 00224 while ((block = strsep(&tmp, "/"))) { 00225 argv_len++; 00226 argv = _discover_xrealloc(argv, sizeof(char *) * argv_len); 00227 argv[argv_len - 1] = block; 00228 } 00229 00230 00231 while(!data && device) { 00232 data = get_data(device, argv[0], &version, status); 00233 00234 if (data) { 00235 for (i = 1; i < argv_len; i++) { 00236 data = get_child_data(data, argv[i], &version, status); 00237 if (status->code != 0) { 00238 goto out; 00239 } 00240 if (!data) { 00241 break; 00242 } 00243 } 00244 } 00245 00246 device = device->extra; 00247 } 00248 00249 if (data) { 00250 result = data->text; 00251 } 00252 00253 out: 00254 00255 free(tmp_orig); 00256 free(argv); 00257 00258 return result; 00259 } 00260 00267 void 00268 discover_device_copy(discover_device_t *src, discover_device_t *dst) 00269 { 00270 assert(src != NULL); 00271 assert(dst != NULL); 00272 00273 if (src->busclass) { 00274 dst->busclass = _discover_xstrdup(src->busclass); 00275 } 00276 00277 if (src->model_id) { 00278 dst->model_id = _discover_xstrdup(src->model_id); 00279 } 00280 00281 if (src->model_name) { 00282 dst->model_name = _discover_xstrdup(src->model_name); 00283 } 00284 00285 if (src->vendor_id) { 00286 dst->vendor_id = _discover_xstrdup(src->vendor_id); 00287 } 00288 00289 if (src->vendor_name) { 00290 dst->vendor_name = _discover_xstrdup(src->vendor_name); 00291 } 00292 00293 dst->busclasses = src->busclasses; 00294 dst->vendors = src->vendors; 00295 dst->data = src->data; 00296 dst->extra = src->extra; 00297 dst->next = src->next; 00298 } 00299 00300 /****************************************************************************** 00301 * Data accessors 00302 */ 00303 00307 char * 00308 discover_data_get_class(discover_data_t *data) 00309 { 00310 assert(data != NULL); 00311 00312 return data->discover_class; 00313 } 00314 00318 char * 00319 discover_data_get_text(discover_data_t *data) 00320 { 00321 assert(data != NULL); 00322 00323 return data->text; 00324 } 00325 00329 discover_data_t * 00330 discover_data_get_parent(discover_data_t *data) 00331 { 00332 assert(data != NULL); 00333 00334 return data->parent; 00335 } 00336 00340 discover_data_t * 00341 discover_data_get_child(discover_data_t *data) 00342 { 00343 assert(data != NULL); 00344 00345 return data->child; 00346 } 00347 00351 discover_data_t * 00352 discover_data_get_next(discover_data_t *data) 00353 { 00354 assert(data != NULL); 00355 00356 return data->next; 00357 } 00358 00362 discover_data_t * 00363 discover_data_get_prev(discover_data_t *data) 00364 { 00365 assert(data != NULL); 00366 00367 return data->prev; 00368 } 00369 00373 discover_data_t * 00374 discover_data_get_first(discover_data_t *data) 00375 { 00376 int i = 1; 00377 00378 if (data == NULL) { 00379 return NULL; 00380 } 00381 00382 while(i) { 00383 if(data->prev) { 00384 data = data->prev; 00385 } else if(data->parent) { 00386 data = data->parent; 00387 } else { 00388 i = 0; 00389 } 00390 } 00391 /* 00392 00393 for (; 00394 data->prev; 00395 data = data->prev) 00396 ; 00397 for (; 00398 data->parent; 00399 data = data->parent) 00400 ; 00401 */ 00402 return data; 00403 } 00404 00408 discover_data_t * 00409 discover_data_new(void) 00410 { 00411 discover_data_t *new; 00412 00413 new = _discover_xmalloc(sizeof(discover_data_t)); 00414 00415 new->discover_class = NULL; 00416 new->version = NULL; 00417 new->text = NULL; 00418 new->parent = NULL; 00419 new->child = NULL; 00420 new->next = NULL; 00421 new->prev = NULL; 00422 00423 return new; 00424 } 00425 00435 void 00436 discover_data_free(discover_data_t *data_tree) 00437 { 00438 discover_data_t *data, *last; 00439 00440 last = NULL; 00441 00442 if (data_tree) { 00443 for (data = data_tree->next; 00444 data; 00445 data = data->next) { 00446 discover_data_free(data); 00447 00448 if (last) { 00449 free(last); 00450 } 00451 last = data; 00452 } 00453 00454 if (last) { 00455 free(last); 00456 } 00457 00458 if (data_tree->child) { 00459 discover_data_free(data_tree->child); 00460 free(data_tree->child); 00461 } 00462 00463 if (data_tree->discover_class) { 00464 free(data_tree->discover_class); 00465 } 00466 00467 if (data_tree->version) { 00468 free(data_tree->version); 00469 } 00470 00471 if (data_tree->text) { 00472 free(data_tree->text); 00473 } 00474 } 00475 } 00476 00477 /****************************************************************************** 00478 * Device accessors 00479 */ 00480 00484 char * 00485 discover_device_get_busclass(discover_device_t *device) 00486 { 00487 assert(device != NULL); 00488 00489 return device->busclass; 00490 } 00491 00495 char * 00496 discover_device_get_model_id(discover_device_t *device) 00497 { 00498 assert(device != NULL); 00499 00500 return device->model_id; 00501 } 00502 00506 char * 00507 discover_device_get_model_name(discover_device_t *device) 00508 { 00509 assert(device != NULL); 00510 00511 return device->model_name; 00512 } 00513 00517 char * 00518 discover_device_get_vendor_id(discover_device_t *device) 00519 { 00520 assert(device != NULL); 00521 00522 return device->vendor_id; 00523 } 00524 00528 char * 00529 discover_device_get_vendor_name(discover_device_t *device) 00530 { 00531 assert(device != NULL); 00532 00533 return device->vendor_name; 00534 } 00535 00539 discover_data_t * 00540 discover_device_get_data_struct(discover_device_t *device) 00541 { 00542 assert(device != NULL); 00543 00544 return device->data; 00545 } 00546 00550 discover_device_t * 00551 discover_device_get_next(discover_device_t *device) 00552 { 00553 assert(device != NULL); 00554 00555 return device->next; 00556 } 00557 00561 discover_device_t * 00562 discover_device_new(void) 00563 { 00564 discover_device_t *new; 00565 00566 new = _discover_xmalloc(sizeof(discover_device_t)); 00567 00568 new->busclass = NULL; 00569 new->model_id = NULL; 00570 new->model_name = NULL; 00571 new->vendor_id = NULL; 00572 new->vendor_name = NULL; 00573 new->busclasses = NULL; 00574 new->vendors = NULL; 00575 new->data = NULL; 00576 new->next = NULL; 00577 new->extra = NULL; 00578 00579 return new; 00580 } 00581 00591 void 00592 discover_device_free(discover_device_t *devices, int free_data) 00593 { 00594 discover_device_t *device, *last; 00595 00596 last = NULL; 00597 00598 for (device = devices; 00599 device; 00600 device = device->next) { 00601 if (device->busclass) { 00602 free(device->busclass); 00603 } 00604 00605 if (device->model_id) { 00606 free(device->model_id); 00607 } 00608 00609 if (device->model_name) { 00610 free(device->model_name); 00611 } 00612 00613 if (device->vendor_id) { 00614 free(device->vendor_id); 00615 } 00616 00617 if (device->vendor_name) { 00618 free(device->vendor_name); 00619 } 00620 00621 if (free_data && device->data) { 00622 discover_data_free(device->data); 00623 free(device->data); 00624 } 00625 00626 if (last) { 00627 free(last); 00628 } 00629 last = device; 00630 } 00631 00632 if (last) { 00633 free(last); 00634 } 00635 } 00636 00639 /* 00640 * Local variables: 00641 * c-file-style: "progeny" 00642 * indent-tabs-mode: nil 00643 * End: 00644 */ 00645 /* vim: set cin fo=tcroq sw=4 et sts=4 tw=75: */
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/url-xml_8c-source.html 0000644 0023421 0023421 00000055661 10655642004 022413 0 ustar pere pere
url-xml.c
Go to the documentation of this file.00001 00010 /* $Progeny$ 00011 * 00012 * AUTHOR: John R. Daily <jdaily@progeny.com> 00013 * 00014 * Copyright 2002 Progeny Linux Systems, Inc. 00015 * Copyright 2002 Hewlett-Packard Company 00016 * 00017 * Permission is hereby granted, free of charge, to any person obtaining a 00018 * copy of this software and associated documentation files (the "Software"), 00019 * to deal in the Software without restriction, including without limitation 00020 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 00021 * and/or sell copies of the Software, and to permit persons to whom the 00022 * Software is furnished to do so, subject to the following conditions: 00023 * 00024 * The above copyright notice and this permission notice shall be included in 00025 * all copies or substantial portions of the Software. 00026 * 00027 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 00028 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 00029 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 00030 * THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 00031 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 00032 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 00033 * DEALINGS IN THE SOFTWARE. 00034 */ 00035 00036 #include "config.h" 00037 00038 #include <assert.h> 00039 #include <string.h> 00040 00041 #include <expat.h> 00042 00043 #include <discover/discover.h> 00044 #include <discover/discover-conf.h> 00045 #include <discover/discover-xml.h> 00046 00047 #include <discover/load-url.h> 00048 #include <discover/url-xml.h> 00049 #include <discover/utils.h> 00050 00052 enum state { START, DISCOVER_DATA }; 00053 struct context { 00054 enum state state; 00055 00056 discover_xml_url_t *urls; 00057 int unknown_level; /* How deep are we into unknown XML tags? */ 00058 }; 00059 00060 static discover_xml_url_t *xml_urls = NULL; 00061 static discover_xml_url_t *data_urls[BUS_COUNT][3]; 00062 00063 static char *known_url_elements[] = { 00064 "location", 00065 "discover-data", 00066 NULL 00067 }; 00068 00069 00070 static bool 00071 unknown_url_element(const XML_Char * const tag) 00072 { 00073 int i; 00074 for (i = 0; known_url_elements[i] != NULL; i++) { 00075 if (strcmp(tag, known_url_elements[i]) == 0) 00076 return false; 00077 } 00078 return true; 00079 } 00080 00081 static void 00082 add_location(struct context *context, const XML_Char *attrs[]) 00083 { 00084 discover_xml_url_t *new; 00085 int i; 00086 00087 assert(context != NULL); 00088 assert(attrs != NULL); 00089 00090 new = discover_xml_url_new(); 00091 00092 for (i = 0; attrs[i]; i += 2) { 00093 if (strcmp(attrs[i], "url") == 0) { 00094 new->url = _discover_xstrdup(attrs[i + 1]); 00095 } else if (strcmp(attrs[i], "bus") == 0) { 00096 new->bus = _discover_xstrdup(attrs[i + 1]); 00097 } else if (strcmp(attrs[i], "type") == 0) { 00098 new->type = _discover_xstrdup(attrs[i + 1]); 00099 } 00100 } 00101 00102 if (context->urls) { 00103 if (context->urls->last) { 00104 context->urls->last->next = new; 00105 } else { 00106 context->urls->next = new; 00107 } 00108 context->urls->last = new; 00109 } else { 00110 context->urls = new; 00111 context->urls->next = context->urls->last = NULL; 00112 } 00113 } 00114 00115 static void 00116 start_element(void *ctx, const XML_Char *name, const XML_Char *attrs[]) 00117 { 00118 struct context *context = ctx; 00119 00120 assert(context != NULL); 00121 assert(name != NULL); 00122 00123 if (unknown_url_element(name)) { 00124 context->unknown_level++; 00125 return; 00126 } 00127 00128 if (context->unknown_level > 0) { 00129 return; 00130 } 00131 00132 switch (context->state) { 00133 case START: 00134 if (strcmp(name, "discover-data") == 0) { 00135 context->state = DISCOVER_DATA; 00136 } 00137 break; 00138 00139 case DISCOVER_DATA: 00140 if (strcmp(name, "location") == 0) { 00141 add_location(context, attrs); 00142 } 00143 break; 00144 } 00145 } 00146 00147 static void 00148 end_element(void *ctx, const XML_Char *name) 00149 { 00150 struct context *context = ctx; 00151 00152 assert(context != NULL); 00153 assert(name != NULL); 00154 00155 if (unknown_url_element(name)) { 00156 context->unknown_level--; 00157 return; 00158 } 00159 00160 if (context->unknown_level > 0) { 00161 return; 00162 } 00163 00164 /* 00165 * We don't have any end tags to worry about, but if we did, they 00166 * would be handled here. 00167 */ 00168 } 00169 00181 discover_xml_url_t * 00182 discover_xml_get_urls(discover_error_t *status) 00183 { 00184 discover_xml_url_t *urls, *i; 00185 XML_Parser parser; 00186 struct context context; 00187 int loaded_urls = 0; 00188 00189 assert(status != NULL); 00190 00191 status->code = 0; 00192 00193 if (!xml_urls) { 00194 context.state = START; 00195 context.urls = NULL; 00196 context.unknown_level = 0; 00197 00198 urls = discover_conf_get_urls(status); 00199 if (status->code != 0) { 00200 return NULL; 00201 } 00202 00203 for (i = urls; 00204 i; 00205 i = i->next) { 00206 parser = XML_ParserCreate(NULL); 00207 XML_SetElementHandler(parser, start_element, end_element); 00208 XML_SetUserData(parser, &context); 00209 00210 if (_discover_load_url(i->url, parser)) { 00211 loaded_urls++; 00212 } 00213 00214 } 00215 00216 if (loaded_urls == 0) { 00217 discover_xml_url_free(context.urls); 00218 XML_ParserFree(parser); 00219 status->code = DISCOVER_EIO; 00220 return NULL; 00221 } 00222 00223 if (!XML_Parse(parser, "", 0, 1)) { 00224 status->code = DISCOVER_EXML; 00225 } 00226 00227 XML_ParserFree(parser); 00228 xml_urls = context.urls; 00229 00230 /* This must be done here because there could be bogus status left 00231 * over from the XML_Parse check above. (We assume something good 00232 * happened by this point.) 00233 */ 00234 status->code = 0; 00235 } 00236 00237 return xml_urls; 00238 } 00239 00243 void 00244 discover_xml_free_urls(void) 00245 { 00246 if (xml_urls) { 00247 discover_xml_url_free(xml_urls); 00248 xml_urls = NULL; 00249 } 00250 } 00251 00260 discover_xml_url_t * 00261 discover_xml_get_data_urls(discover_bus_t bus, discover_filetype_t filetype, 00262 discover_error_t *status) 00263 { 00264 discover_xml_url_t *urls, *i, *new; 00265 char *busname = discover_conf_get_bus_name(bus); 00266 char *filetypename = discover_conf_get_filetype_name(filetype); 00267 00268 assert(status != NULL); 00269 assert(busname != NULL); 00270 00271 status->code = 0; 00272 00273 if (!data_urls[bus][filetype]) { 00274 urls = discover_xml_get_urls(status); 00275 if (status->code != 0) { 00276 return NULL; 00277 } 00278 00279 status->code = DISCOVER_EDATANOTFOUND; 00280 for (i = urls; 00281 i; 00282 i = i->next) { 00283 if (strcmp(i->bus, busname) == 0 00284 && strcmp(i->type, filetypename) == 0) { 00285 00286 status->code = 0; 00287 00288 new = discover_xml_url_new(); 00289 discover_xml_url_copy(i, new); 00290 00291 if (data_urls[bus][filetype]) { 00292 data_urls[bus][filetype]->last->next = new; 00293 data_urls[bus][filetype]->last = new; 00294 } else { 00295 data_urls[bus][filetype] = new; 00296 data_urls[bus][filetype]->last = new; 00297 data_urls[bus][filetype]->next = NULL; 00298 } 00299 } 00300 } 00301 } 00302 00303 return data_urls[bus][filetype]; 00304 } 00305 00309 void 00310 discover_xml_free_data_urls(void) 00311 { 00312 int b, f; 00313 00314 for(b = 0; b < BUS_COUNT; b++) { 00315 for(f = 0; f < 3; f++) { 00316 discover_xml_url_free(data_urls[b][f]); 00317 data_urls[b][f] = NULL; 00318 } 00319 } 00320 } 00321 00325 discover_xml_url_t * 00326 discover_xml_url_new(void) 00327 { 00328 discover_xml_url_t *new; 00329 00330 new = _discover_xmalloc(sizeof(discover_xml_url_t)); 00331 00332 new->url = NULL; 00333 new->bus = NULL; 00334 new->type = NULL; 00335 new->label = NULL; 00336 new->next = NULL; 00337 new->last = NULL; 00338 00339 return new; 00340 } 00341 00348 void 00349 discover_xml_url_copy(discover_xml_url_t *src, 00350 discover_xml_url_t *dst) 00351 { 00352 assert(src != NULL); 00353 assert(dst != NULL); 00354 00355 if (src->url) { 00356 dst->url = _discover_xstrdup(src->url); 00357 } 00358 00359 if (src->bus) { 00360 dst->bus = _discover_xstrdup(src->bus); 00361 } 00362 00363 if (src->type) { 00364 dst->type = _discover_xstrdup(src->type); 00365 } 00366 00367 if (src->label) { 00368 dst->label = _discover_xstrdup(src->label); 00369 } 00370 } 00371 00375 char * 00376 discover_xml_url_get_url(discover_xml_url_t *url) 00377 { 00378 assert(url != NULL); 00379 00380 return url->url; 00381 } 00382 00386 char * 00387 discover_xml_url_get_label(discover_xml_url_t *url) 00388 { 00389 assert(url != NULL); 00390 00391 return url->label; 00392 } 00393 00397 char * 00398 discover_xml_url_get_bus(discover_xml_url_t *url) 00399 { 00400 assert(url != NULL); 00401 00402 return url->bus; 00403 } 00404 00408 char * 00409 discover_xml_url_get_type(discover_xml_url_t *url) 00410 { 00411 assert(url != NULL); 00412 00413 return url->type; 00414 } 00415 00419 discover_xml_url_t * 00420 discover_xml_url_get_next(discover_xml_url_t *url) 00421 { 00422 assert(url != NULL); 00423 00424 return url->next; 00425 } 00426 00430 discover_xml_url_t * 00431 discover_xml_url_get_last(discover_xml_url_t *url) 00432 { 00433 assert(url != NULL); 00434 00435 return url->last; 00436 } 00437 00443 void 00444 discover_xml_url_free(discover_xml_url_t *urls) 00445 { 00446 discover_xml_url_t *url, *last; 00447 00448 last = NULL; 00449 00450 for (url = urls; 00451 url; 00452 url = url->next) { 00453 if (url->url) { 00454 free(url->url); 00455 } 00456 00457 if (url->bus) { 00458 free(url->bus); 00459 } 00460 00461 if (url->type) { 00462 free(url->type); 00463 } 00464 00465 if (url->label) { 00466 free(url->label); 00467 } 00468 00469 if (last) { 00470 free(last); 00471 } 00472 last = url; 00473 } 00474 00475 if (last) { 00476 free(last); 00477 } 00478 } 00479
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/discover-xml_8h.html 0000644 0023421 0023421 00000035074 10655642004 022132 0 ustar pere pere
discover-xml.h File Reference
Public interface to Discover's XML handling. More...
#include <discover/discover.h>
Go to the source code of this file.
Detailed Description
Public interface to Discover's XML handling.Public interface that exposes Discover's XML routines. These functions are used to read the XML data loaded from the specified configuration file(s).
Definition in file discover-xml.h.
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/device-xml_8c.html 0000644 0023421 0023421 00000016162 10655642004 021543 0 ustar pere pere
device-xml.c File Reference
Device XML data file parsing. More...
#include "config.h"
#include <sys/types.h>
#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <stdbool.h>
#include <string.h>
#include <errno.h>
#include <expat.h>
#include <discover/discover.h>
#include <discover/discover-xml.h>
#include <discover/load-url.h>
#include <discover/device.h>
#include <discover/utils.h>
#include <discover/stack.h>
Go to the source code of this file.
Defines | |
| #define | IDLEN 5 |
Enumerations | |
| enum | state { START, FINISH, DEVICE, DATA } |
Functions | |
| void | discover_xml_merge_device_url (discover_device_t **dlist, char *url, discover_xml_busclass_t *busclasses, discover_xml_vendor_t *vendors, discover_error_t *status) |
| discover_device_t * | discover_xml_get_devices (discover_bus_t bus, discover_error_t *status) |
| void | discover_xml_free_devices (void) |
| discover_device_t * | discover_xml_find_device (discover_device_t *xml_devices, char *target_vendor, char *target_model, discover_error_t *status) |
| discover_device_t * | discover_xml_find_next_device (discover_device_t *xml_devices, char *target_vendor, char *target_model, discover_error_t *status) |
| discover_device_t * | discover_xml_get_matching_devices (discover_device_t *xml_devices, char *target_vendor, char *target_model, discover_error_t *status) |
Detailed Description
Device XML data file parsing.This file contains the routines needed to properly process the device XML data. This file is responsible for handling URLs and storing the XML data during the parsing process.
Definition in file device-xml.c.
Define Documentation
|
|
Length (including terminating null) of model and vendor ID strings Definition at line 77 of file device-xml.c. |
Enumeration Type Documentation
|
|
Representative of the state within the XML data Definition at line 82 of file device-xml.c. |
Generated on Thu Jul 28 03:38:00 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/html/group__types.html 0000644 0023421 0023421 00000057722 10655642004 021642 0 ustar pere pere
Types
Define Documentation
|
|
Number of buses we support Definition at line 157 of file discover.h. Referenced by _real_discover_conf_get_bus_map(), discover_conf_get_bus_map(), discover_conf_get_bus_name(), discover_free_devices(), discover_xml_free_busclasses(), discover_xml_free_data_urls(), discover_xml_free_devices(), and discover_xml_free_vendors(). |
Typedef Documentation
|
|
Mapping of bus names to functions Definition at line 116 of file discover.h. |
|
|
Signature of functions that assist with creating message strings Definition at line 99 of file discover.h. |
|
|
Data element from the device XML files Definition at line 120 of file discover.h. |
|
|
Signature of functions returning discover_device_t structures Definition at line 129 of file discover.h. |
|
|
Structure describing a device Definition at line 118 of file discover.h. |
|
|
All functions that perform some action (as opposed to returning a member of a structure, for example) take an argument of this type. It is used to report that the action succeeded, or why it failed. |
|
|
Signature of functions that free internal lists Definition at line 137 of file discover.h. |
|
|
Signature of functions that return sysdep_data_t lists Definition at line 141 of file discover.h. |
|
|
Signature of functions returning discover_xml_busclass_t structures Definition at line 131 of file discover.h. |
|
|
Structure for mapping Discover device types to bus-specific classes Definition at line 122 of file discover.h. |
|
|
Signature of functions returning discover_xml_url_t structures Definition at line 135 of file discover.h. |
|
|
Structure describing a URL where XML data can be found Definition at line 126 of file discover.h. |
|
|
Signature of functions returning discover_xml_vendor_t structures Definition at line 133 of file discover.h. |
|
|
Structure for mapping vendor names to bus-specific IDs Definition at line 124 of file discover.h. |
Enumeration Type Documentation
|
|
Enumerate the buses. Definition at line 146 of file discover.h. |
|
|
Definition at line 73 of file discover.h. |
|
|
Enumerate the types of data files: vendor, busclass, and device. Definition at line 162 of file discover.h. |
Generated on Thu Jul 28 03:38:01 2005 for discover by
1.4.2
discover-2.1.2/doc/api-reference/latex/ 0002755 0023421 0023421 00000000000 10272033371 016367 5 ustar pere pere discover-2.1.2/doc/api-reference/latex/vendor-xml_8c.tex 0000644 0023421 0023421 00000004246 10655642004 021606 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/vendor-xml.c File Reference}
\label{vendor-xml_8c}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/vendor-xml.c@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/vendor-xml.c}}
Vendor XML data file parsing.
{\tt \#include \char`\"{}config.h\char`\"{}}\par
{\tt \#include $<$sys/types.h$>$}\par
{\tt \#include $<$assert.h$>$}\par
{\tt \#include $<$limits.h$>$}\par
{\tt \#include $<$stdio.h$>$}\par
{\tt \#include $<$string.h$>$}\par
{\tt \#include $<$expat.h$>$}\par
{\tt \#include $<$discover/discover.h$>$}\par
{\tt \#include $<$discover/discover-xml.h$>$}\par
{\tt \#include $<$discover/load-url.h$>$}\par
{\tt \#include $<$discover/utils.h$>$}\par
\subsection*{Functions}
\begin{CompactItemize}
\item
void {\bf discover\_\-xml\_\-merge\_\-vendor\_\-url} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$$\ast$vlist, char $\ast$url, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-xml\_\-vendor\_\-t} $\ast$ {\bf discover\_\-xml\_\-get\_\-vendors} ({\bf discover\_\-bus\_\-t} bus, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-xml\_\-free\_\-vendors} (void)
\item
char $\ast$ {\bf discover\_\-xml\_\-vendor\_\-id2name} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendors, char $\ast$id)
\item
char $\ast$ {\bf discover\_\-xml\_\-vendor\_\-get\_\-id} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendor)
\item
char $\ast$ {\bf discover\_\-xml\_\-vendor\_\-get\_\-name} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendor)
\item
{\bf discover\_\-xml\_\-vendor\_\-t} $\ast$ {\bf discover\_\-xml\_\-vendor\_\-get\_\-next} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendor)
\item
{\bf discover\_\-xml\_\-vendor\_\-t} $\ast$ {\bf discover\_\-xml\_\-vendor\_\-new} (void)
\item
void {\bf discover\_\-xml\_\-vendor\_\-free} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendors)
\end{CompactItemize}
\subsection{Detailed Description}
Vendor XML data file parsing.
This file contains the routines needed to properly process the vendor XML data. This file is responsible for handling URLs and storing the XML data during the parsing process.
Definition in file {\bf vendor-xml.c}. discover-2.1.2/doc/api-reference/latex/group__version__cmp.tex 0000644 0023421 0023421 00000002316 10655642004 023153 0 ustar pere pere \section{Version comparison}
\label{group__version__cmp}\index{Version comparison@{Version comparison}}
\subsection*{Functions}
\begin{CompactItemize}
\item
int {\bf discover\_\-xml\_\-version\_\-cmp} (char $\ast$range, char $\ast$version, {\bf discover\_\-error\_\-t} $\ast$status)
\end{CompactItemize}
\subsection{Function Documentation}
\index{version_cmp@{version\_\-cmp}!discover_xml_version_cmp@{discover\_\-xml\_\-version\_\-cmp}}
\index{discover_xml_version_cmp@{discover\_\-xml\_\-version\_\-cmp}!version_cmp@{version\_\-cmp}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int discover\_\-xml\_\-version\_\-cmp (char $\ast$ {\em range}, char $\ast$ {\em version}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__version__cmp_ga0}
Compare a version number against a version range, returning 1 if the number matches the range or 0 if not.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em range}]Range to compare against version \item[{\em version}]Version to compare against range \item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 438 of file version-cmp.c.
References discover\_\-error::code, and DISCOVER\_\-EBADVERSION. discover-2.1.2/doc/api-reference/latex/version-cmp_8c.tex 0000644 0023421 0023421 00000005352 10655642004 021754 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/version-cmp.c File Reference}
\label{version-cmp_8c}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/version-cmp.c@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/version-cmp.c}}
Version comparison functions.
{\tt \#include \char`\"{}config.h\char`\"{}}\par
{\tt \#include $<$assert.h$>$}\par
{\tt \#include $<$ctype.h$>$}\par
{\tt \#include $<$stdio.h$>$}\par
{\tt \#include $<$stdlib.h$>$}\par
{\tt \#include $<$string.h$>$}\par
{\tt \#include $<$discover/discover.h$>$}\par
{\tt \#include $<$discover/utils.h$>$}\par
\subsection*{Defines}
\begin{CompactItemize}
\item
\#define {\bf MAXBUFLEN}~256
\end{CompactItemize}
\subsection*{Typedefs}
\begin{CompactItemize}
\item
typedef enum {\bf range\_\-states} {\bf range\_\-state}
\end{CompactItemize}
\subsection*{Enumerations}
\begin{CompactItemize}
\item
enum {\bf range\_\-states} \{ \par
{\bf START},
{\bf OPEN},
{\bf VERSION1},
{\bf VERSEP1},
\par
{\bf PAUSE1},
{\bf SEPARATOR},
{\bf I},
{\bf N},
\par
{\bf F},
{\bf VERSION2},
{\bf VERSEP2},
{\bf PAUSE2},
\par
{\bf CLOSE},
{\bf ERROR}
\}
\end{CompactItemize}
\subsection*{Functions}
\begin{CompactItemize}
\item
int {\bf discover\_\-xml\_\-version\_\-cmp} (char $\ast$range, char $\ast$version, {\bf discover\_\-error\_\-t} $\ast$status)
\end{CompactItemize}
\subsection{Detailed Description}
Version comparison functions.
This file holds the routines needed to process version data in the XML file. This version data is used to look for information pertaining to a particular version of the OS/software requiring that information.
Definition in file {\bf version-cmp.c}.
\subsection{Define Documentation}
\index{version-cmp.c@{version-cmp.c}!MAXBUFLEN@{MAXBUFLEN}}
\index{MAXBUFLEN@{MAXBUFLEN}!version-cmp.c@{version-cmp.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\#define MAXBUFLEN~256}\label{version-cmp_8c_a0}
This probably shouldn't be here; it's bad practice (3.0, right).
Definition at line 55 of file version-cmp.c.
\subsection{Typedef Documentation}
\index{version-cmp.c@{version-cmp.c}!range_state@{range\_\-state}}
\index{range_state@{range\_\-state}!version-cmp.c@{version-cmp.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}typedef enum {\bf range\_\-states}
{\bf range\_\-state}}\label{version-cmp_8c_a1}
This is used as a placeholder while comparing versions of modules.
\subsection{Enumeration Type Documentation}
\index{version-cmp.c@{version-cmp.c}!range_states@{range\_\-states}}
\index{range_states@{range\_\-states}!version-cmp.c@{version-cmp.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}enum {\bf range\_\-states}}\label{version-cmp_8c_a21}
Version placeholders
Definition at line 58 of file version-cmp.c. discover-2.1.2/doc/api-reference/latex/index.tex 0000644 0023421 0023421 00000002001 10655642004 020213 0 ustar pere pere This is the Discover application programming interface (API) reference. If you have not already read {\tt The Discover Hardware Detection System}, you should do so now. The following list describes the contents of the links at the top of the page:
\begin{itemize}
\item Main page -- This page\end{itemize}
\begin{itemize}
\item Modules -- List of top-level modules; you probably want to start here, where navigation is fastest\end{itemize}
\begin{itemize}
\item Data Structures -- List of data structures used by Discover\end{itemize}
\begin{itemize}
\item File List -- List of files comprising Discover's external interface, with links to documentation and source code\end{itemize}
\begin{itemize}
\item Data Fields -- List of fields used in Discover's structs and unions\end{itemize}
\begin{itemize}
\item Globals -- List of global symbols, with links to file summaries\end{itemize}
The Discover library was written by Eric Gillespie, John R. Daily, and Josh Bressers, with design input from Branden Robinson. discover-2.1.2/doc/api-reference/latex/doxygen.sty 0000644 0023421 0023421 00000003716 10655642004 020616 0 ustar pere pere \NeedsTeXFormat{LaTeX2e}
\ProvidesPackage{doxygen}
\RequirePackage{calc}
\RequirePackage{array}
\pagestyle{fancyplain}
\newcommand{\clearemptydoublepage}{\newpage{\pagestyle{empty}\cleardoublepage}}
\renewcommand{\chaptermark}[1]{\markboth{#1}{}}
\renewcommand{\sectionmark}[1]{\markright{\thesection\ #1}}
\lhead[\fancyplain{}{\bfseries\thepage}]
{\fancyplain{}{\bfseries\rightmark}}
\rhead[\fancyplain{}{\bfseries\leftmark}]
{\fancyplain{}{\bfseries\thepage}}
\rfoot[\fancyplain{}{\bfseries\scriptsize Generated on Thu Jul 28 03:38:00 2005 for discover by Doxygen }]{}
\lfoot[]{\fancyplain{}{\bfseries\scriptsize Generated on Thu Jul 28 03:38:00 2005 for discover by Doxygen }}
\cfoot{}
\newenvironment{CompactList}
{\begin{list}{}{
\setlength{\leftmargin}{0.5cm}
\setlength{\itemsep}{0pt}
\setlength{\parsep}{0pt}
\setlength{\topsep}{0pt}
\renewcommand{\makelabel}{}}}
{\end{list}}
\newenvironment{CompactItemize}
{
\begin{itemize}
\setlength{\itemsep}{-3pt}
\setlength{\parsep}{0pt}
\setlength{\topsep}{0pt}
\setlength{\partopsep}{0pt}
}
{\end{itemize}}
\newcommand{\PBS}[1]{\let\temp=\\#1\let\\=\temp}
\newlength{\tmplength}
\newenvironment{TabularC}[1]
{
\setlength{\tmplength}
{\linewidth/(#1)-\tabcolsep*2-\arrayrulewidth*(#1+1)/(#1)}
\par\begin{tabular*}{\linewidth}
{*{#1}{|>{\PBS\raggedright\hspace{0pt}}p{\the\tmplength}}|}
}
{\end{tabular*}\par}
\newcommand{\entrylabel}[1]{
{\parbox[b]{\labelwidth-4pt}{\makebox[0pt][l]{\textbf{#1}}\\}}}
\newenvironment{Desc}
{\begin{list}{}
{
\settowidth{\labelwidth}{40pt}
\setlength{\leftmargin}{\labelwidth}
\setlength{\parsep}{0pt}
\setlength{\itemsep}{-4pt}
\renewcommand{\makelabel}{\entrylabel}
}
}
{\end{list}}
\newenvironment{Indent}
{\begin{list}{}{\setlength{\leftmargin}{0.5cm}}
\item[]\ignorespaces}
{\unskip\end{list}}
\setlength{\parindent}{0cm}
\setlength{\parskip}{0.2cm}
\addtocounter{secnumdepth}{1}
\sloppy
\usepackage[T1]{fontenc}
discover-2.1.2/doc/api-reference/latex/group__core.tex 0000644 0023421 0023421 00000007362 10655642004 021426 0 ustar pere pere \section{Core functionality}
\label{group__core}\index{Core functionality@{Core functionality}}
\subsection*{Functions}
\begin{CompactItemize}
\item
{\bf discover\_\-error\_\-t} $\ast$ {\bf discover\_\-error\_\-new} (void)
\item
void $\ast$ {\bf \_\-discover\_\-create\_\-message} ({\bf discover\_\-error\_\-t} $\ast$$\ast$status, char $\ast$message)
\item
void {\bf discover\_\-error\_\-free} ({\bf discover\_\-error\_\-t} $\ast$status)
\item
char $\ast$ {\bf discover\_\-strerror} ({\bf discover\_\-error\_\-t} $\ast$err)
\item
int {\bf discover\_\-major\_\-version} (void)
\item
int {\bf discover\_\-minor\_\-version} (void)
\item
int {\bf discover\_\-micro\_\-version} (void)
\end{CompactItemize}
\subsection{Function Documentation}
\index{core@{core}!_discover_create_message@{\_\-discover\_\-create\_\-message}}
\index{_discover_create_message@{\_\-discover\_\-create\_\-message}!core@{core}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void$\ast$ \_\-discover\_\-create\_\-message ({\bf discover\_\-error\_\-t} $\ast$$\ast$ {\em status}, char $\ast$ {\em message})}\label{group__core_ga1}
Allocate memory for a char $\ast$ variable. This routine was written for discover\_\-error\_\-t struct.
Definition at line 82 of file core.c.
Referenced by discover\_\-error\_\-new().\index{core@{core}!discover_error_free@{discover\_\-error\_\-free}}
\index{discover_error_free@{discover\_\-error\_\-free}!core@{core}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-error\_\-free ({\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__core_ga2}
Free a discover\_\-error\_\-t structure.
Definition at line 95 of file core.c.
References discover\_\-error::message.\index{core@{core}!discover_error_new@{discover\_\-error\_\-new}}
\index{discover_error_new@{discover\_\-error\_\-new}!core@{core}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-error\_\-t}$\ast$ discover\_\-error\_\-new (void)}\label{group__core_ga0}
Allocate and initialize a discover\_\-error\_\-t structure.
Definition at line 68 of file core.c.
References \_\-discover\_\-create\_\-message(), discover\_\-error::code, discover\_\-error::create\_\-message, and discover\_\-error::message.\index{core@{core}!discover_major_version@{discover\_\-major\_\-version}}
\index{discover_major_version@{discover\_\-major\_\-version}!core@{core}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int discover\_\-major\_\-version (void)}\label{group__core_ga4}
Get the major version number.
Definition at line 124 of file core.c.\index{core@{core}!discover_micro_version@{discover\_\-micro\_\-version}}
\index{discover_micro_version@{discover\_\-micro\_\-version}!core@{core}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int discover\_\-micro\_\-version (void)}\label{group__core_ga6}
Get the micro version number.
Definition at line 142 of file core.c.\index{core@{core}!discover_minor_version@{discover\_\-minor\_\-version}}
\index{discover_minor_version@{discover\_\-minor\_\-version}!core@{core}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int discover\_\-minor\_\-version (void)}\label{group__core_ga5}
Get the minor version number.
Definition at line 133 of file core.c.\index{core@{core}!discover_strerror@{discover\_\-strerror}}
\index{discover_strerror@{discover\_\-strerror}!core@{core}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ discover\_\-strerror ({\bf discover\_\-error\_\-t} $\ast$ {\em err})}\label{group__core_ga3}
Convert an error code to a human-readable string localized according to the current locale (XXX: no i18n yet).
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em err}]Error code to convert \end{description}
\end{Desc}
Definition at line 111 of file core.c.
References discover\_\-error::code. discover-2.1.2/doc/api-reference/latex/core_8c.tex 0000644 0023421 0023421 00000002513 10655642004 020436 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/core.c File Reference}
\label{core_8c}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/core.c@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/core.c}}
Core and miscellaneous routines.
{\tt \#include \char`\"{}config.h\char`\"{}}\par
{\tt \#include $<$assert.h$>$}\par
{\tt \#include $<$discover/discover.h$>$}\par
{\tt \#include $<$discover/discover-xml.h$>$}\par
{\tt \#include $<$discover/utils.h$>$}\par
\subsection*{Functions}
\begin{CompactItemize}
\item
{\bf discover\_\-error\_\-t} $\ast$ {\bf discover\_\-error\_\-new} (void)
\item
void $\ast$ {\bf \_\-discover\_\-create\_\-message} ({\bf discover\_\-error\_\-t} $\ast$$\ast$status, char $\ast$message)
\item
void {\bf discover\_\-error\_\-free} ({\bf discover\_\-error\_\-t} $\ast$status)
\item
char $\ast$ {\bf discover\_\-strerror} ({\bf discover\_\-error\_\-t} $\ast$err)
\item
int {\bf discover\_\-major\_\-version} (void)
\item
int {\bf discover\_\-minor\_\-version} (void)
\item
int {\bf discover\_\-micro\_\-version} (void)
\end{CompactItemize}
\subsection{Detailed Description}
Core and miscellaneous routines.
This file provides core routines that don't really fit anyplace else. There are likely some other routines that really should be in here.
Definition in file {\bf core.c}. discover-2.1.2/doc/api-reference/latex/dir_000000.tex 0000644 0023421 0023421 00000000602 10655642004 020466 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/ Directory Reference}
\label{dir_000000}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/ Directory Reference@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/ Directory Reference}}
\subsection*{Directories}
\begin{CompactItemize}
\item
directory {\bf discover}
\end{CompactItemize}
discover-2.1.2/doc/api-reference/latex/group__busclass__xml.tex 0000644 0023421 0023421 00000021352 10655642004 023327 0 ustar pere pere \section{Busclass list XML parsing}
\label{group__busclass__xml}\index{Busclass list XML parsing@{Busclass list XML parsing}}
\subsection*{Functions}
\begin{CompactItemize}
\item
void {\bf discover\_\-xml\_\-merge\_\-busclass\_\-url} ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$$\ast$blist, char $\ast$url, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-xml\_\-busclass\_\-t} $\ast$ {\bf discover\_\-xml\_\-get\_\-busclasses} ({\bf discover\_\-bus\_\-t} bus, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-xml\_\-free\_\-busclasses} (void)
\item
char $\ast$ {\bf discover\_\-xml\_\-busclass\_\-to\_\-class} (char $\ast$busclass, {\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclasses)
\item
int {\bf discover\_\-xml\_\-busclass\_\-cmp} (char $\ast$busclass, char $\ast$discover\_\-class, {\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclasses)
\item
char $\ast$ {\bf discover\_\-xml\_\-busclass\_\-get\_\-id} ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclass)
\item
char $\ast$ {\bf discover\_\-xml\_\-busclass\_\-get\_\-name} ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclass)
\item
{\bf discover\_\-xml\_\-busclass\_\-t} $\ast$ {\bf discover\_\-xml\_\-busclass\_\-get\_\-next} ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclass)
\item
{\bf discover\_\-xml\_\-busclass\_\-t} $\ast$ {\bf discover\_\-xml\_\-busclass\_\-new} (void)
\item
void {\bf discover\_\-xml\_\-busclass\_\-free} ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclasses)
\end{CompactItemize}
\subsection{Function Documentation}
\index{busclass_xml@{busclass\_\-xml}!discover_xml_busclass_cmp@{discover\_\-xml\_\-busclass\_\-cmp}}
\index{discover_xml_busclass_cmp@{discover\_\-xml\_\-busclass\_\-cmp}!busclass_xml@{busclass\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int discover\_\-xml\_\-busclass\_\-cmp (char $\ast$ {\em busclass}, char $\ast$ {\em discover\_\-class}, {\bf discover\_\-xml\_\-busclass\_\-t} $\ast$ {\em busclasses})}\label{group__busclass__xml_ga4}
Compare a busclass to a device class, returning the same kind of value returned by strcmp(3). Note that this function has a special case for the class 'all'; it is considered equal to all busclasses.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em busclass}]Busclass to compare \item[{\em discover\_\-class}]Device class to compare \item[{\em busclasses}]List of busclasses to search \end{description}
\end{Desc}
Definition at line 295 of file busclass-xml.c.
References discover\_\-xml\_\-busclass\_\-to\_\-class().
Referenced by discover\_\-device\_\-find().\index{busclass_xml@{busclass\_\-xml}!discover_xml_busclass_free@{discover\_\-xml\_\-busclass\_\-free}}
\index{discover_xml_busclass_free@{discover\_\-xml\_\-busclass\_\-free}!busclass_xml@{busclass\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-xml\_\-busclass\_\-free ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$ {\em busclasses})}\label{group__busclass__xml_ga9}
Free the busclass or list of busclasses.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em busclasses}]Busclass or list of busclasses to free \end{description}
\end{Desc}
Definition at line 382 of file busclass-xml.c.
Referenced by discover\_\-xml\_\-free\_\-busclasses().\index{busclass_xml@{busclass\_\-xml}!discover_xml_busclass_get_id@{discover\_\-xml\_\-busclass\_\-get\_\-id}}
\index{discover_xml_busclass_get_id@{discover\_\-xml\_\-busclass\_\-get\_\-id}!busclass_xml@{busclass\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ discover\_\-xml\_\-busclass\_\-get\_\-id ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$ {\em busclass})}\label{group__busclass__xml_ga5}
Get the id member of busclass.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em busclass}]\end{description}
\end{Desc}
Definition at line 327 of file busclass-xml.c.\index{busclass_xml@{busclass\_\-xml}!discover_xml_busclass_get_name@{discover\_\-xml\_\-busclass\_\-get\_\-name}}
\index{discover_xml_busclass_get_name@{discover\_\-xml\_\-busclass\_\-get\_\-name}!busclass_xml@{busclass\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ discover\_\-xml\_\-busclass\_\-get\_\-name ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$ {\em busclass})}\label{group__busclass__xml_ga6}
Get the name member of busclass.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em busclass}]\end{description}
\end{Desc}
Definition at line 340 of file busclass-xml.c.\index{busclass_xml@{busclass\_\-xml}!discover_xml_busclass_get_next@{discover\_\-xml\_\-busclass\_\-get\_\-next}}
\index{discover_xml_busclass_get_next@{discover\_\-xml\_\-busclass\_\-get\_\-next}!busclass_xml@{busclass\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-xml\_\-busclass\_\-t}$\ast$ discover\_\-xml\_\-busclass\_\-get\_\-next ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$ {\em busclass})}\label{group__busclass__xml_ga7}
Get the next member of busclass (used for traversing lists of busclasses).
Definition at line 352 of file busclass-xml.c.\index{busclass_xml@{busclass\_\-xml}!discover_xml_busclass_new@{discover\_\-xml\_\-busclass\_\-new}}
\index{discover_xml_busclass_new@{discover\_\-xml\_\-busclass\_\-new}!busclass_xml@{busclass\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-xml\_\-busclass\_\-t}$\ast$ discover\_\-xml\_\-busclass\_\-new (void)}\label{group__busclass__xml_ga8}
Create and initialize a new discover\_\-xml\_\-busclass\_\-t object.
Definition at line 363 of file busclass-xml.c.\index{busclass_xml@{busclass\_\-xml}!discover_xml_busclass_to_class@{discover\_\-xml\_\-busclass\_\-to\_\-class}}
\index{discover_xml_busclass_to_class@{discover\_\-xml\_\-busclass\_\-to\_\-class}!busclass_xml@{busclass\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ discover\_\-xml\_\-busclass\_\-to\_\-class (char $\ast$ {\em busclass}, {\bf discover\_\-xml\_\-busclass\_\-t} $\ast$ {\em busclasses})}\label{group__busclass__xml_ga3}
Return the device class corresponding to a busclass.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em busclass}]Busclass to look up \item[{\em busclasses}]List of busclasses to search \end{description}
\end{Desc}
Definition at line 263 of file busclass-xml.c.
Referenced by discover\_\-xml\_\-busclass\_\-cmp().\index{busclass_xml@{busclass\_\-xml}!discover_xml_free_busclasses@{discover\_\-xml\_\-free\_\-busclasses}}
\index{discover_xml_free_busclasses@{discover\_\-xml\_\-free\_\-busclasses}!busclass_xml@{busclass\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-xml\_\-free\_\-busclasses (void)}\label{group__busclass__xml_ga2}
Free the list of busclasses.
Definition at line 247 of file busclass-xml.c.
References BUS\_\-COUNT, and discover\_\-xml\_\-busclass\_\-free().\index{busclass_xml@{busclass\_\-xml}!discover_xml_get_busclasses@{discover\_\-xml\_\-get\_\-busclasses}}
\index{discover_xml_get_busclasses@{discover\_\-xml\_\-get\_\-busclasses}!busclass_xml@{busclass\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-xml\_\-busclass\_\-t}$\ast$ discover\_\-xml\_\-get\_\-busclasses ({\bf discover\_\-bus\_\-t} {\em bus}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__busclass__xml_ga1}
Get the list of busclasses by bus type.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em bus}]Type of bus for which busclasses are required \item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 213 of file busclass-xml.c.
References discover\_\-error::code, discover\_\-xml\_\-get\_\-data\_\-urls(), discover\_\-xml\_\-merge\_\-busclass\_\-url(), discover\_\-xml\_\-url\_\-get\_\-next(), and discover\_\-xml\_\-url\_\-get\_\-url().
Referenced by discover\_\-device\_\-find(), and discover\_\-xml\_\-get\_\-devices().\index{busclass_xml@{busclass\_\-xml}!discover_xml_merge_busclass_url@{discover\_\-xml\_\-merge\_\-busclass\_\-url}}
\index{discover_xml_merge_busclass_url@{discover\_\-xml\_\-merge\_\-busclass\_\-url}!busclass_xml@{busclass\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-xml\_\-merge\_\-busclass\_\-url ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$$\ast$ {\em blist}, char $\ast$ {\em url}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__busclass__xml_ga0}
Merge new busclasses into a list.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em blist}]Address of the list to merge busclasses into \item[{\em url}]URL of the document defining the busclasses \item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 171 of file busclass-xml.c.
References discover\_\-error::code, DISCOVER\_\-EIO, and DISCOVER\_\-EXML.
Referenced by discover\_\-xml\_\-get\_\-busclasses(). discover-2.1.2/doc/api-reference/latex/dir_000001.tex 0000644 0023421 0023421 00000001623 10655642004 020473 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/ Directory Reference}
\label{dir_000001}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/ Directory Reference@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/ Directory Reference}}
\subsection*{Files}
\begin{CompactItemize}
\item
file {\bf discover-conf.h}
\begin{CompactList}\small\item\em Public interface for reading Discover configuration data. \item\end{CompactList}
\item
file {\bf discover-xml.h}
\begin{CompactList}\small\item\em Public interface to Discover's XML handling. \item\end{CompactList}
\item
file {\bf discover.h}
\begin{CompactList}\small\item\em Public interface for Discover library. \item\end{CompactList}
\item
file {\bf sysdep.h}
\begin{CompactList}\small\item\em Private interface for system dependencies. \item\end{CompactList}
\end{CompactItemize}
discover-2.1.2/doc/api-reference/latex/dir_000004.tex 0000644 0023421 0023421 00000000733 10655642004 020477 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/sysdeps/stub/ Directory Reference}
\label{dir_000004}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/sysdeps/stub/ Directory Reference@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/sysdeps/stub/ Directory Reference}}
\subsection*{Files}
\begin{CompactItemize}
\item
file {\bf stubs.c}
\begin{CompactList}\small\item\em Stub system-dependent code. \item\end{CompactList}
\end{CompactItemize}
discover-2.1.2/doc/api-reference/latex/device-xml_8c.tex 0000644 0023421 0023421 00000006524 10655642004 021551 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/device-xml.c File Reference}
\label{device-xml_8c}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/device-xml.c@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/device-xml.c}}
Device XML data file parsing.
{\tt \#include \char`\"{}config.h\char`\"{}}\par
{\tt \#include $<$sys/types.h$>$}\par
{\tt \#include $<$assert.h$>$}\par
{\tt \#include $<$ctype.h$>$}\par
{\tt \#include $<$limits.h$>$}\par
{\tt \#include $<$stdbool.h$>$}\par
{\tt \#include $<$string.h$>$}\par
{\tt \#include $<$errno.h$>$}\par
{\tt \#include $<$expat.h$>$}\par
{\tt \#include $<$discover/discover.h$>$}\par
{\tt \#include $<$discover/discover-xml.h$>$}\par
{\tt \#include $<$discover/load-url.h$>$}\par
{\tt \#include $<$discover/device.h$>$}\par
{\tt \#include $<$discover/utils.h$>$}\par
{\tt \#include $<$discover/stack.h$>$}\par
\subsection*{Defines}
\begin{CompactItemize}
\item
\#define {\bf IDLEN}~5
\end{CompactItemize}
\subsection*{Enumerations}
\begin{CompactItemize}
\item
enum {\bf state} \{ {\bf START},
{\bf FINISH},
{\bf DEVICE},
{\bf DATA}
\}
\end{CompactItemize}
\subsection*{Functions}
\begin{CompactItemize}
\item
void {\bf discover\_\-xml\_\-merge\_\-device\_\-url} ({\bf discover\_\-device\_\-t} $\ast$$\ast$dlist, char $\ast$url, {\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclasses, {\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendors, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-xml\_\-get\_\-devices} ({\bf discover\_\-bus\_\-t} bus, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-xml\_\-free\_\-devices} (void)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-xml\_\-find\_\-device} ({\bf discover\_\-device\_\-t} $\ast$xml\_\-devices, char $\ast$target\_\-vendor, char $\ast$target\_\-model, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-xml\_\-find\_\-next\_\-device} ({\bf discover\_\-device\_\-t} $\ast$xml\_\-devices, char $\ast$target\_\-vendor, char $\ast$target\_\-model, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-xml\_\-get\_\-matching\_\-devices} ({\bf discover\_\-device\_\-t} $\ast$xml\_\-devices, char $\ast$target\_\-vendor, char $\ast$target\_\-model, {\bf discover\_\-error\_\-t} $\ast$status)
\end{CompactItemize}
\subsection{Detailed Description}
Device XML data file parsing.
This file contains the routines needed to properly process the device XML data. This file is responsible for handling URLs and storing the XML data during the parsing process.
Definition in file {\bf device-xml.c}.
\subsection{Define Documentation}
\index{device-xml.c@{device-xml.c}!IDLEN@{IDLEN}}
\index{IDLEN@{IDLEN}!device-xml.c@{device-xml.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}\#define IDLEN~5}\label{device-xml_8c_a0}
Length (including terminating null) of model and vendor ID strings
Definition at line 77 of file device-xml.c.
\subsection{Enumeration Type Documentation}
\index{device-xml.c@{device-xml.c}!state@{state}}
\index{state@{state}!device-xml.c@{device-xml.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}enum {\bf state}}\label{device-xml_8c_a20}
Representative of the state within the XML data
Definition at line 82 of file device-xml.c. discover-2.1.2/doc/api-reference/latex/dir_000003.tex 0000644 0023421 0023421 00000000576 10655642004 020503 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/sysdeps/ Directory Reference}
\label{dir_000003}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/sysdeps/ Directory Reference@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/sysdeps/ Directory Reference}}
\subsection*{Directories}
\begin{CompactItemize}
\item
directory {\bf stub}
\end{CompactItemize}
discover-2.1.2/doc/api-reference/latex/group__device__xml.tex 0000644 0023421 0023421 00000017336 10655642004 022756 0 ustar pere pere \section{Device list XML parsing}
\label{group__device__xml}\index{Device list XML parsing@{Device list XML parsing}}
\subsection*{Functions}
\begin{CompactItemize}
\item
void {\bf discover\_\-xml\_\-merge\_\-device\_\-url} ({\bf discover\_\-device\_\-t} $\ast$$\ast$dlist, char $\ast$url, {\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclasses, {\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendors, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-xml\_\-get\_\-devices} ({\bf discover\_\-bus\_\-t} bus, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-xml\_\-free\_\-devices} (void)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-xml\_\-find\_\-device} ({\bf discover\_\-device\_\-t} $\ast$xml\_\-devices, char $\ast$target\_\-vendor, char $\ast$target\_\-model, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-xml\_\-find\_\-next\_\-device} ({\bf discover\_\-device\_\-t} $\ast$xml\_\-devices, char $\ast$target\_\-vendor, char $\ast$target\_\-model, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-xml\_\-get\_\-matching\_\-devices} ({\bf discover\_\-device\_\-t} $\ast$xml\_\-devices, char $\ast$target\_\-vendor, char $\ast$target\_\-model, {\bf discover\_\-error\_\-t} $\ast$status)
\end{CompactItemize}
\subsection{Function Documentation}
\index{device_xml@{device\_\-xml}!discover_xml_find_device@{discover\_\-xml\_\-find\_\-device}}
\index{discover_xml_find_device@{discover\_\-xml\_\-find\_\-device}!device_xml@{device\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-device\_\-t}$\ast$ discover\_\-xml\_\-find\_\-device ({\bf discover\_\-device\_\-t} $\ast$ {\em xml\_\-devices}, char $\ast$ {\em target\_\-vendor}, char $\ast$ {\em target\_\-model}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__device__xml_ga3}
Find the first device in xml\_\-devices matching target\_\-vendor and/or target\_\-model. (One or both can be specified, but not zero.)
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em xml\_\-devices}]List of devices to search \item[{\em target\_\-vendor}]Vendor for which to search \item[{\em target\_\-model}]Model for which to search \item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 550 of file device-xml.c.
Referenced by discover\_\-xml\_\-find\_\-next\_\-device(), and discover\_\-xml\_\-get\_\-matching\_\-devices().\index{device_xml@{device\_\-xml}!discover_xml_find_next_device@{discover\_\-xml\_\-find\_\-next\_\-device}}
\index{discover_xml_find_next_device@{discover\_\-xml\_\-find\_\-next\_\-device}!device_xml@{device\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-device\_\-t}$\ast$ discover\_\-xml\_\-find\_\-next\_\-device ({\bf discover\_\-device\_\-t} $\ast$ {\em xml\_\-devices}, char $\ast$ {\em target\_\-vendor}, char $\ast$ {\em target\_\-model}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__device__xml_ga4}
Find the next device in xml\_\-devices matching target\_\-vendor and/or target\_\-model. (One or both can be specified, but not zero.)
The first device in the list is assumed to have been processed, so we simply call {\bf discover\_\-xml\_\-find\_\-device()}{\rm (p.\,\pageref{group__device__xml_ga3})} on the next pointer.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em xml\_\-devices}]List of devices to search \item[{\em target\_\-vendor}]Vendor for which to search \item[{\em target\_\-model}]Model for which to search \item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 594 of file device-xml.c.
References discover\_\-xml\_\-find\_\-device().
Referenced by discover\_\-xml\_\-get\_\-matching\_\-devices().\index{device_xml@{device\_\-xml}!discover_xml_free_devices@{discover\_\-xml\_\-free\_\-devices}}
\index{discover_xml_free_devices@{discover\_\-xml\_\-free\_\-devices}!device_xml@{device\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-xml\_\-free\_\-devices (void)}\label{group__device__xml_ga2}
Free the list of XML devices.
Definition at line 531 of file device-xml.c.
References BUS\_\-COUNT, and discover\_\-device\_\-free().\index{device_xml@{device\_\-xml}!discover_xml_get_devices@{discover\_\-xml\_\-get\_\-devices}}
\index{discover_xml_get_devices@{discover\_\-xml\_\-get\_\-devices}!device_xml@{device\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-device\_\-t}$\ast$ discover\_\-xml\_\-get\_\-devices ({\bf discover\_\-bus\_\-t} {\em bus}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__device__xml_ga1}
Get the list of devices for the required bus.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em bus}]Bus for which the devices are requested \item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 484 of file device-xml.c.
References discover\_\-error::code, discover\_\-xml\_\-get\_\-busclasses(), discover\_\-xml\_\-get\_\-data\_\-urls(), discover\_\-xml\_\-get\_\-vendors(), discover\_\-xml\_\-merge\_\-device\_\-url(), discover\_\-xml\_\-url\_\-get\_\-next(), and discover\_\-xml\_\-url\_\-get\_\-url().
Referenced by discover\_\-get\_\-devices().\index{device_xml@{device\_\-xml}!discover_xml_get_matching_devices@{discover\_\-xml\_\-get\_\-matching\_\-devices}}
\index{discover_xml_get_matching_devices@{discover\_\-xml\_\-get\_\-matching\_\-devices}!device_xml@{device\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-device\_\-t}$\ast$ discover\_\-xml\_\-get\_\-matching\_\-devices ({\bf discover\_\-device\_\-t} $\ast$ {\em xml\_\-devices}, char $\ast$ {\em target\_\-vendor}, char $\ast$ {\em target\_\-model}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__device__xml_ga5}
Find and duplicate all devices in xml\_\-devices matching target\_\-vendor and/or target\_\-model. (One or both can be specified, but not zero.)
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em xml\_\-devices}]List of devices to search \item[{\em target\_\-vendor}]Vendor for which to search \item[{\em target\_\-model}]Model for which to search \item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 614 of file device-xml.c.
References discover\_\-device\_\-copy(), discover\_\-device\_\-new(), discover\_\-xml\_\-find\_\-device(), and discover\_\-xml\_\-find\_\-next\_\-device().
Referenced by discover\_\-get\_\-devices().\index{device_xml@{device\_\-xml}!discover_xml_merge_device_url@{discover\_\-xml\_\-merge\_\-device\_\-url}}
\index{discover_xml_merge_device_url@{discover\_\-xml\_\-merge\_\-device\_\-url}!device_xml@{device\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-xml\_\-merge\_\-device\_\-url ({\bf discover\_\-device\_\-t} $\ast$$\ast$ {\em dlist}, char $\ast$ {\em url}, {\bf discover\_\-xml\_\-busclass\_\-t} $\ast$ {\em busclasses}, {\bf discover\_\-xml\_\-vendor\_\-t} $\ast$ {\em vendors}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__device__xml_ga0}
Merge new busclasses into a list.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em dlist}]Address of the list to merge busclasses into \item[{\em url}]URL of the document defining the busclasses \item[{\em busclasses}]List of busclasses for this bus \item[{\em vendors}]List of vendors for this bus \item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 425 of file device-xml.c.
References discover\_\-error::code, DISCOVER\_\-EIO, and DISCOVER\_\-EXML.
Referenced by discover\_\-xml\_\-get\_\-devices(). discover-2.1.2/doc/api-reference/latex/conf_8c.tex 0000644 0023421 0023421 00000012603 10655642004 020434 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/conf.c File Reference}
\label{conf_8c}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/conf.c@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/conf.c}}
Configuration handling (including XML parsing).
{\tt \#include \char`\"{}config.h\char`\"{}}\par
{\tt \#include $<$assert.h$>$}\par
{\tt \#include $<$string.h$>$}\par
{\tt \#include $<$expat.h$>$}\par
{\tt \#include $<$discover/discover.h$>$}\par
{\tt \#include $<$discover/discover-conf.h$>$}\par
{\tt \#include $<$discover/discover-xml.h$>$}\par
{\tt \#include $<$discover/load-url.h$>$}\par
{\tt \#include $<$discover/url-xml.h$>$}\par
{\tt \#include $<$discover/utils.h$>$}\par
\subsection*{Defines}
\begin{CompactItemize}
\item
\#define {\bf dirent}~direct\label{conf_8c_a0}
\item
\#define {\bf NAMLEN}(d)~(d) $\rightarrow$ d\_\-namlen\label{conf_8c_a1}
\end{CompactItemize}
\subsection*{Enumerations}
\begin{CompactItemize}
\item
enum {\bf state} \{ {\bf START},
{\bf BUSSCAN},
{\bf DATA\_\-SOURCES}
\}
\item
enum {\bf scan\_\-flag} \{ {\bf SCAN\_\-NEVER},
{\bf SCAN\_\-DEFAULT}
\}
\end{CompactItemize}
\subsection*{Functions}
\begin{CompactItemize}
\item
{\bf discover\_\-bus\_\-map\_\-t} $\ast$ {\bf \_\-real\_\-discover\_\-conf\_\-get\_\-bus\_\-map} ({\bf discover\_\-bus\_\-t} bus, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-bus\_\-map\_\-t} $\ast$ {\bf \_\-real\_\-discover\_\-conf\_\-get\_\-bus\_\-map\_\-by\_\-name} (char $\ast$name, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-conf\_\-load} ({\bf discover\_\-error\_\-t} $\ast$status)
\item
int {\bf discover\_\-conf\_\-name\_\-to\_\-bus} (char $\ast$name, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-bus\_\-map\_\-t} $\ast$ {\bf discover\_\-conf\_\-get\_\-full\_\-bus\_\-map} ({\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-bus\_\-map\_\-t} $\ast$ {\bf discover\_\-conf\_\-get\_\-bus\_\-map\_\-by\_\-name} (char $\ast$name, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-bus\_\-map\_\-t} $\ast$ {\bf discover\_\-conf\_\-get\_\-bus\_\-map} ({\bf discover\_\-bus\_\-t} bus, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-conf\_\-insert\_\-url} (char $\ast$url, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-conf\_\-append\_\-url} (char $\ast$url, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-xml\_\-url\_\-t} $\ast$ {\bf discover\_\-conf\_\-get\_\-urls} ({\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-conf\_\-free} (void)
\item
char $\ast$ {\bf discover\_\-conf\_\-get\_\-bus\_\-name} ({\bf discover\_\-bus\_\-t} bus)
\item
char $\ast$ {\bf discover\_\-conf\_\-get\_\-filetype\_\-name} ({\bf discover\_\-filetype\_\-t} filetype)
\end{CompactItemize}
\subsection{Detailed Description}
Configuration handling (including XML parsing).
Configuration-related data is handled here. This file is responsible for loading and parsing the XML data read from the configuration file. This file also holds the routines that are responsible for altering the URL list as requested by the caller.
Definition in file {\bf conf.c}.
\subsection{Enumeration Type Documentation}
\index{conf.c@{conf.c}!scan_flag@{scan\_\-flag}}
\index{scan_flag@{scan\_\-flag}!conf.c@{conf.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}enum {\bf scan\_\-flag}}\label{conf_8c_a34}
Define the values for a scannable bus.
Definition at line 93 of file conf.c.\index{conf.c@{conf.c}!state@{state}}
\index{state@{state}!conf.c@{conf.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}enum {\bf state}}\label{conf_8c_a33}
Describe the current state within the XML structure.
Definition at line 90 of file conf.c.
\subsection{Function Documentation}
\index{conf.c@{conf.c}!_real_discover_conf_get_bus_map@{\_\-real\_\-discover\_\-conf\_\-get\_\-bus\_\-map}}
\index{_real_discover_conf_get_bus_map@{\_\-real\_\-discover\_\-conf\_\-get\_\-bus\_\-map}!conf.c@{conf.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-bus\_\-map\_\-t}$\ast$ \_\-real\_\-discover\_\-conf\_\-get\_\-bus\_\-map ({\bf discover\_\-bus\_\-t} {\em bus}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{conf_8c_a16}
Function that loads the bus map
The \char`\"{}real\char`\"{} get\_\-bus\_\-map functions don't call conf\_\-load(), which is important to avoid infinite loops.
Definition at line 154 of file conf.c.
References BUS\_\-COUNT, discover\_\-error::code, and DISCOVER\_\-EBUSNOTFOUND.
Referenced by \_\-real\_\-discover\_\-conf\_\-get\_\-bus\_\-map\_\-by\_\-name().\index{conf.c@{conf.c}!_real_discover_conf_get_bus_map_by_name@{\_\-real\_\-discover\_\-conf\_\-get\_\-bus\_\-map\_\-by\_\-name}}
\index{_real_discover_conf_get_bus_map_by_name@{\_\-real\_\-discover\_\-conf\_\-get\_\-bus\_\-map\_\-by\_\-name}!conf.c@{conf.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-bus\_\-map\_\-t}$\ast$ \_\-real\_\-discover\_\-conf\_\-get\_\-bus\_\-map\_\-by\_\-name (char $\ast$ {\em name}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{conf_8c_a17}
Internal function that really loads the bus map
Definition at line 168 of file conf.c.
References \_\-real\_\-discover\_\-conf\_\-get\_\-bus\_\-map(), discover\_\-error::code, and discover\_\-conf\_\-name\_\-to\_\-bus().
Referenced by discover\_\-conf\_\-get\_\-bus\_\-map\_\-by\_\-name(). discover-2.1.2/doc/api-reference/latex/Makefile 0000644 0023421 0023421 00000001527 10655642004 020036 0 ustar pere pere all clean: refman.dvi
ps: refman.ps
pdf: refman.pdf
ps_2on1: refman_2on1.ps
pdf_2on1: refman_2on1.pdf
refman.ps: refman.dvi
dvips -o refman.ps refman.dvi
refman.pdf: refman.ps
ps2pdf refman.ps refman.pdf
refman.dvi: refman.tex doxygen.sty
echo "Running latex..."
latex refman.tex
echo "Running makeindex..."
makeindex refman.idx
echo "Rerunning latex...."
latex refman.tex
latex_count=5 ; \
while egrep -s 'Rerun (LaTeX|to get cross-references right)' refman.log && [ $$latex_count -gt 0 ] ;\
do \
echo "Rerunning latex...." ;\
latex refman.tex ;\
latex_count=`expr $$latex_count - 1` ;\
done
refman_2on1.ps: refman.ps
psnup -2 refman.ps >refman_2on1.ps
refman_2on1.pdf: refman_2on1.ps
ps2pdf refman_2on1.ps refman_2on1.pdf
clean:
rm -f *.ps *.dvi *.aux *.toc *.idx *.ind *.ilg *.log *.out refman.pdf
discover-2.1.2/doc/api-reference/latex/refman.tex 0000644 0023421 0023421 00000003640 10655642004 020366 0 ustar pere pere \documentclass[a4paper]{book}
\usepackage{a4wide}
\usepackage{makeidx}
\usepackage{fancyhdr}
\usepackage{graphicx}
\usepackage{multicol}
\usepackage{float}
\usepackage{textcomp}
\usepackage{alltt}
\usepackage{doxygen}
\makeindex
\setcounter{tocdepth}{1}
\renewcommand{\footrulewidth}{0.4pt}
\begin{document}
\begin{titlepage}
\vspace*{7cm}
\begin{center}
{\Large discover Reference Manual}\\
\vspace*{1cm}
{\large Generated by Doxygen 1.4.2}\\
\vspace*{0.5cm}
{\small Thu Jul 28 03:38:00 2005}\\
\end{center}
\end{titlepage}
\clearemptydoublepage
\pagenumbering{roman}
\tableofcontents
\clearemptydoublepage
\pagenumbering{arabic}
\chapter{Discover API Reference }
\label{index}\input{index}
\chapter{discover Module Index}
\input{modules}
\chapter{discover Directory Hierarchy}
\input{dirs}
\chapter{discover Data Structure Index}
\input{annotated}
\chapter{discover File Index}
\input{files}
\chapter{discover Module Documentation}
\input{group__busclass__xml}
\include{group__conf}
\include{group__core}
\include{group__device__xml}
\include{group__device}
\include{group__url__xml}
\include{group__vendor__xml}
\include{group__version__cmp}
\include{group__sysdeps}
\include{group__types}
\chapter{discover Directory Documentation}
\input{dir_000001}
\include{dir_000000}
\include{dir_000002}
\include{dir_000004}
\include{dir_000003}
\chapter{discover Data Structure Documentation}
\input{structdiscover__bus__map}
\include{structdiscover__error}
\include{structdiscover__sysdep__data}
\include{structdiscover__sysdep__device__data}
\chapter{discover File Documentation}
\input{discover-conf_8h}
\include{discover-xml_8h}
\include{discover_8h}
\include{sysdep_8h}
\include{busclass-xml_8c}
\include{conf_8c}
\include{core_8c}
\include{device-xml_8c}
\include{device_8c}
\include{load-url_8c}
\include{stack_8c}
\include{sysdep_8c}
\include{url-xml_8c}
\include{vendor-xml_8c}
\include{version-cmp_8c}
\include{stubs_8c}
\printindex
\end{document}
discover-2.1.2/doc/api-reference/latex/modules.tex 0000644 0023421 0023421 00000001564 10655642004 020571 0 ustar pere pere \section{discover Modules}
Here is a list of all modules:\begin{CompactList}
\item \contentsline{section}{Busclass list XML parsing}{\pageref{group__busclass__xml}}{}
\item \contentsline{section}{Configuration handling}{\pageref{group__conf}}{}
\item \contentsline{section}{Core functionality}{\pageref{group__core}}{}
\item \contentsline{section}{Device list XML parsing}{\pageref{group__device__xml}}{}
\item \contentsline{section}{Devices}{\pageref{group__device}}{}
\item \contentsline{section}{URL list XML parsing}{\pageref{group__url__xml}}{}
\item \contentsline{section}{Vendor list XML parsing}{\pageref{group__vendor__xml}}{}
\item \contentsline{section}{Version comparison}{\pageref{group__version__cmp}}{}
\item \contentsline{section}{System-dependent interfaces}{\pageref{group__sysdeps}}{}
\item \contentsline{section}{Types}{\pageref{group__types}}{}
\end{CompactList}
discover-2.1.2/doc/api-reference/latex/group__device.tex 0000644 0023421 0023421 00000035311 10655642004 021730 0 ustar pere pere \section{Devices}
\label{group__device}\index{Devices@{Devices}}
\subsection*{Functions}
\begin{CompactItemize}
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-device\_\-find} (char $\ast$discover\_\-class, {\bf discover\_\-error\_\-t} $\ast$status)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-data} ({\bf discover\_\-device\_\-t} $\ast$device, char $\ast$discover\_\-class, char $\ast$version, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-device\_\-copy} ({\bf discover\_\-device\_\-t} $\ast$src, {\bf discover\_\-device\_\-t} $\ast$dst)
\item
char $\ast$ {\bf discover\_\-data\_\-get\_\-class} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
char $\ast$ {\bf discover\_\-data\_\-get\_\-text} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-get\_\-parent} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-get\_\-child} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-get\_\-next} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-get\_\-prev} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-get\_\-first} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-new} (void)
\item
void {\bf discover\_\-data\_\-free} ({\bf discover\_\-data\_\-t} $\ast$data\_\-tree)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-busclass} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-model\_\-id} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-model\_\-name} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-vendor\_\-id} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-vendor\_\-name} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-device\_\-get\_\-data\_\-struct} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-device\_\-get\_\-next} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-device\_\-new} (void)
\item
void {\bf discover\_\-device\_\-free} ({\bf discover\_\-device\_\-t} $\ast$devices, int free\_\-data)
\end{CompactItemize}
\subsection{Function Documentation}
\index{device@{device}!discover_data_free@{discover\_\-data\_\-free}}
\index{discover_data_free@{discover\_\-data\_\-free}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-data\_\-free ({\bf discover\_\-data\_\-t} $\ast$ {\em data\_\-tree})}\label{group__device_ga14}
Free the data tree. Note that unlike the other free functions in Discover, this one does not free data\_\-tree itself. This is a side-effect of how it is implemented. It frees all children and siblings of data\_\-tree as well as the data. After calling discover\_\-data\_\-free, you have to call free(3) on data\_\-tree itself.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em data\_\-tree}]Data tree to free \end{description}
\end{Desc}
Definition at line 436 of file device.c.
References discover\_\-data\_\-free().
Referenced by discover\_\-data\_\-free(), and discover\_\-device\_\-free().\index{device@{device}!discover_data_get_child@{discover\_\-data\_\-get\_\-child}}
\index{discover_data_get_child@{discover\_\-data\_\-get\_\-child}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-data\_\-t}$\ast$ discover\_\-data\_\-get\_\-child ({\bf discover\_\-data\_\-t} $\ast$ {\em data})}\label{group__device_ga9}
Get the child member of data.
Definition at line 341 of file device.c.\index{device@{device}!discover_data_get_class@{discover\_\-data\_\-get\_\-class}}
\index{discover_data_get_class@{discover\_\-data\_\-get\_\-class}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ discover\_\-data\_\-get\_\-class ({\bf discover\_\-data\_\-t} $\ast$ {\em data})}\label{group__device_ga6}
Get the class member of data.
Definition at line 308 of file device.c.\index{device@{device}!discover_data_get_first@{discover\_\-data\_\-get\_\-first}}
\index{discover_data_get_first@{discover\_\-data\_\-get\_\-first}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-data\_\-t}$\ast$ discover\_\-data\_\-get\_\-first ({\bf discover\_\-data\_\-t} $\ast$ {\em data})}\label{group__device_ga12}
Get the first member of data.
Definition at line 374 of file device.c.\index{device@{device}!discover_data_get_next@{discover\_\-data\_\-get\_\-next}}
\index{discover_data_get_next@{discover\_\-data\_\-get\_\-next}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-data\_\-t}$\ast$ discover\_\-data\_\-get\_\-next ({\bf discover\_\-data\_\-t} $\ast$ {\em data})}\label{group__device_ga10}
Get the next member of data.
Definition at line 352 of file device.c.\index{device@{device}!discover_data_get_parent@{discover\_\-data\_\-get\_\-parent}}
\index{discover_data_get_parent@{discover\_\-data\_\-get\_\-parent}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-data\_\-t}$\ast$ discover\_\-data\_\-get\_\-parent ({\bf discover\_\-data\_\-t} $\ast$ {\em data})}\label{group__device_ga8}
Get the parent member of data.
Definition at line 330 of file device.c.\index{device@{device}!discover_data_get_prev@{discover\_\-data\_\-get\_\-prev}}
\index{discover_data_get_prev@{discover\_\-data\_\-get\_\-prev}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-data\_\-t}$\ast$ discover\_\-data\_\-get\_\-prev ({\bf discover\_\-data\_\-t} $\ast$ {\em data})}\label{group__device_ga11}
Get the prev member of data.
Definition at line 363 of file device.c.\index{device@{device}!discover_data_get_text@{discover\_\-data\_\-get\_\-text}}
\index{discover_data_get_text@{discover\_\-data\_\-get\_\-text}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ discover\_\-data\_\-get\_\-text ({\bf discover\_\-data\_\-t} $\ast$ {\em data})}\label{group__device_ga7}
Get the text member of data.
Definition at line 319 of file device.c.\index{device@{device}!discover_data_new@{discover\_\-data\_\-new}}
\index{discover_data_new@{discover\_\-data\_\-new}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-data\_\-t}$\ast$ discover\_\-data\_\-new (void)}\label{group__device_ga13}
Create and initialize a new discover\_\-data\_\-t structure.
Definition at line 409 of file device.c.
Referenced by \_\-discover\_\-convert\_\-device\_\-data().\index{device@{device}!discover_device_copy@{discover\_\-device\_\-copy}}
\index{discover_device_copy@{discover\_\-device\_\-copy}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-device\_\-copy ({\bf discover\_\-device\_\-t} $\ast$ {\em src}, {\bf discover\_\-device\_\-t} $\ast$ {\em dst})}\label{group__device_ga5}
Copy a device structure.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em src}]Copy from (source) \item[{\em dst}]Copy to (destination) \end{description}
\end{Desc}
Definition at line 268 of file device.c.
Referenced by discover\_\-device\_\-find(), and discover\_\-xml\_\-get\_\-matching\_\-devices().\index{device@{device}!discover_device_find@{discover\_\-device\_\-find}}
\index{discover_device_find@{discover\_\-device\_\-find}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-device\_\-t}$\ast$ discover\_\-device\_\-find (char $\ast$ {\em discover\_\-class}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__device_ga0}
Get a list of devices of a specified class on all buses scanned by default.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em discover\_\-class}]Class of devices to find \item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 63 of file device.c.
References discover\_\-error::code, discover\_\-error::create\_\-message, discover\_\-conf\_\-get\_\-full\_\-bus\_\-map(), discover\_\-device\_\-copy(), discover\_\-device\_\-get\_\-next(), discover\_\-device\_\-new(), DISCOVER\_\-EDEVICENOTFOUND, discover\_\-get\_\-devices(), DISCOVER\_\-SUCCESS, discover\_\-xml\_\-busclass\_\-cmp(), and discover\_\-xml\_\-get\_\-busclasses().\index{device@{device}!discover_device_free@{discover\_\-device\_\-free}}
\index{discover_device_free@{discover\_\-device\_\-free}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-device\_\-free ({\bf discover\_\-device\_\-t} $\ast$ {\em devices}, int {\em free\_\-data})}\label{group__device_ga23}
Free the device or list of devices. Pass 1 as the second argument to free the data structure for this device, 0 to leave it. It is necessary to specify 0 when one structure was copied from another with discover\_\-device\_\-copy. Otherwise, you must pass 1.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em devices}]Device or list of devices to free \item[{\em free\_\-data}]Whether to free the data structure \end{description}
\end{Desc}
Definition at line 592 of file device.c.
References discover\_\-data\_\-free().
Referenced by discover\_\-free\_\-devices(), and discover\_\-xml\_\-free\_\-devices().\index{device@{device}!discover_device_get_busclass@{discover\_\-device\_\-get\_\-busclass}}
\index{discover_device_get_busclass@{discover\_\-device\_\-get\_\-busclass}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ discover\_\-device\_\-get\_\-busclass ({\bf discover\_\-device\_\-t} $\ast$ {\em device})}\label{group__device_ga15}
Get the busclass member of device.
Definition at line 485 of file device.c.\index{device@{device}!discover_device_get_data@{discover\_\-device\_\-get\_\-data}}
\index{discover_device_get_data@{discover\_\-device\_\-get\_\-data}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ discover\_\-device\_\-get\_\-data ({\bf discover\_\-device\_\-t} $\ast$ {\em device}, char $\ast$ {\em discover\_\-class}, char $\ast$ {\em version}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__device_ga4}
Get the data matching the class path and version number (optional) from the device structure.
The class parameter requires further explanation. The XML data sources have hierarchical data elements for each device. You access the data in an element by specifying the path along the data elements to it.
For example, device elements for video cards usually have a data element of class \char`\"{}xfree86\char`\"{} containing data related to the XFree86 package; that element itself usually contains a data element of class \char`\"{}server\char`\"{} that specifies which server to use for this video card. You access this data by passing the string \char`\"{}xfree86/server\char`\"{} to this function.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em device}]Device from which to get the data \item[{\em discover\_\-class}]Class to search for \item[{\em version}]Version number to require (NULL for unversioned search) \item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 204 of file device.c.
References discover\_\-error::code.\index{device@{device}!discover_device_get_data_struct@{discover\_\-device\_\-get\_\-data\_\-struct}}
\index{discover_device_get_data_struct@{discover\_\-device\_\-get\_\-data\_\-struct}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-data\_\-t}$\ast$ discover\_\-device\_\-get\_\-data\_\-struct ({\bf discover\_\-device\_\-t} $\ast$ {\em device})}\label{group__device_ga20}
Get the data member of device.
Definition at line 540 of file device.c.\index{device@{device}!discover_device_get_model_id@{discover\_\-device\_\-get\_\-model\_\-id}}
\index{discover_device_get_model_id@{discover\_\-device\_\-get\_\-model\_\-id}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ discover\_\-device\_\-get\_\-model\_\-id ({\bf discover\_\-device\_\-t} $\ast$ {\em device})}\label{group__device_ga16}
Get the model\_\-id member of device.
Definition at line 496 of file device.c.\index{device@{device}!discover_device_get_model_name@{discover\_\-device\_\-get\_\-model\_\-name}}
\index{discover_device_get_model_name@{discover\_\-device\_\-get\_\-model\_\-name}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ discover\_\-device\_\-get\_\-model\_\-name ({\bf discover\_\-device\_\-t} $\ast$ {\em device})}\label{group__device_ga17}
Get the model\_\-name member of device.
Definition at line 507 of file device.c.\index{device@{device}!discover_device_get_next@{discover\_\-device\_\-get\_\-next}}
\index{discover_device_get_next@{discover\_\-device\_\-get\_\-next}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-device\_\-t}$\ast$ discover\_\-device\_\-get\_\-next ({\bf discover\_\-device\_\-t} $\ast$ {\em device})}\label{group__device_ga21}
Get the next member of device.
Definition at line 551 of file device.c.
Referenced by discover\_\-device\_\-find().\index{device@{device}!discover_device_get_vendor_id@{discover\_\-device\_\-get\_\-vendor\_\-id}}
\index{discover_device_get_vendor_id@{discover\_\-device\_\-get\_\-vendor\_\-id}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ discover\_\-device\_\-get\_\-vendor\_\-id ({\bf discover\_\-device\_\-t} $\ast$ {\em device})}\label{group__device_ga18}
Get the vendor\_\-id member of device.
Definition at line 518 of file device.c.\index{device@{device}!discover_device_get_vendor_name@{discover\_\-device\_\-get\_\-vendor\_\-name}}
\index{discover_device_get_vendor_name@{discover\_\-device\_\-get\_\-vendor\_\-name}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ discover\_\-device\_\-get\_\-vendor\_\-name ({\bf discover\_\-device\_\-t} $\ast$ {\em device})}\label{group__device_ga19}
Get the vendor\_\-name member of device.
Definition at line 529 of file device.c.\index{device@{device}!discover_device_new@{discover\_\-device\_\-new}}
\index{discover_device_new@{discover\_\-device\_\-new}!device@{device}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-device\_\-t}$\ast$ discover\_\-device\_\-new (void)}\label{group__device_ga22}
Create and initialize a new discover\_\-device\_\-t structure.
Definition at line 562 of file device.c.
Referenced by discover\_\-device\_\-find(), discover\_\-get\_\-devices(), and discover\_\-xml\_\-get\_\-matching\_\-devices(). discover-2.1.2/doc/api-reference/latex/discover-xml_8h.tex 0000644 0023421 0023421 00000013700 10655642004 022127 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/discover-xml.h File Reference}
\label{discover-xml_8h}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/discover-xml.h@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/discover-xml.h}}
Public interface to Discover's XML handling.
{\tt \#include $<$discover/discover.h$>$}\par
\subsection*{Functions}
\begin{CompactItemize}
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-xml\_\-find\_\-device} ({\bf discover\_\-device\_\-t} $\ast$xml\_\-devices, char $\ast$target\_\-vendor, char $\ast$target\_\-model, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-xml\_\-find\_\-next\_\-device} ({\bf discover\_\-device\_\-t} $\ast$xml\_\-devices, char $\ast$target\_\-vendor, char $\ast$target\_\-model, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-xml\_\-get\_\-matching\_\-devices} ({\bf discover\_\-device\_\-t} $\ast$xml\_\-devices, char $\ast$target\_\-vendor, char $\ast$target\_\-model, {\bf discover\_\-error\_\-t} $\ast$status)
\item
int {\bf discover\_\-xml\_\-version\_\-cmp} (char $\ast$range, char $\ast$version, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-xml\_\-url\_\-t} $\ast$ {\bf discover\_\-xml\_\-url\_\-new} (void)
\item
void {\bf discover\_\-xml\_\-url\_\-copy} ({\bf discover\_\-xml\_\-url\_\-t} $\ast$src, {\bf discover\_\-xml\_\-url\_\-t} $\ast$dst)
\item
void {\bf discover\_\-xml\_\-url\_\-free} ({\bf discover\_\-xml\_\-url\_\-t} $\ast$urls)
\item
char $\ast$ {\bf discover\_\-xml\_\-url\_\-get\_\-url} ({\bf discover\_\-xml\_\-url\_\-t} $\ast$url)
\item
char $\ast$ {\bf discover\_\-xml\_\-url\_\-get\_\-bus} ({\bf discover\_\-xml\_\-url\_\-t} $\ast$url)
\item
char $\ast$ {\bf discover\_\-xml\_\-url\_\-get\_\-type} ({\bf discover\_\-xml\_\-url\_\-t} $\ast$url)
\item
{\bf discover\_\-xml\_\-url\_\-t} $\ast$ {\bf discover\_\-xml\_\-url\_\-get\_\-next} ({\bf discover\_\-xml\_\-url\_\-t} $\ast$url)
\item
{\bf discover\_\-xml\_\-url\_\-t} $\ast$ {\bf discover\_\-xml\_\-url\_\-get\_\-last} ({\bf discover\_\-xml\_\-url\_\-t} $\ast$url)
\item
char $\ast$ {\bf discover\_\-xml\_\-url\_\-get\_\-label} ({\bf discover\_\-xml\_\-url\_\-t} $\ast$url)
\item
{\bf discover\_\-xml\_\-url\_\-t} $\ast$ {\bf discover\_\-xml\_\-get\_\-urls} ({\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-xml\_\-free\_\-urls} (void)
\item
{\bf discover\_\-xml\_\-url\_\-t} $\ast$ {\bf discover\_\-xml\_\-get\_\-data\_\-urls} ({\bf discover\_\-bus\_\-t} bus, {\bf discover\_\-filetype\_\-t} filetype, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-xml\_\-free\_\-data\_\-urls} (void)
\item
{\bf discover\_\-xml\_\-busclass\_\-t} $\ast$ {\bf discover\_\-xml\_\-busclass\_\-new} (void)
\item
{\bf discover\_\-xml\_\-busclass\_\-t} $\ast$ {\bf discover\_\-xml\_\-get\_\-busclasses} ({\bf discover\_\-bus\_\-t} bus, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-xml\_\-free\_\-busclasses} (void)
\item
void {\bf discover\_\-xml\_\-merge\_\-busclass\_\-url} ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$$\ast$blist, char $\ast$filename, {\bf discover\_\-error\_\-t} $\ast$status)
\item
char $\ast$ {\bf discover\_\-xml\_\-busclass\_\-to\_\-class} (char $\ast$busclass, {\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclasses)
\item
int {\bf discover\_\-xml\_\-busclass\_\-cmp} (char $\ast$busclass, char $\ast$discover\_\-class, {\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclasses)
\item
char $\ast$ {\bf discover\_\-xml\_\-busclass\_\-get\_\-id} ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclass)
\item
char $\ast$ {\bf discover\_\-xml\_\-busclass\_\-get\_\-name} ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclass)
\item
{\bf discover\_\-xml\_\-busclass\_\-t} $\ast$ {\bf discover\_\-xml\_\-busclass\_\-get\_\-next} ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclass)
\item
void {\bf discover\_\-xml\_\-busclass\_\-free} ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclasses)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-xml\_\-get\_\-devices} ({\bf discover\_\-bus\_\-t} bus, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-xml\_\-free\_\-devices} (void)
\item
void {\bf discover\_\-xml\_\-merge\_\-device\_\-url} ({\bf discover\_\-device\_\-t} $\ast$$\ast$dlist, char $\ast$url, {\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclasses, {\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendors, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-xml\_\-vendor\_\-t} $\ast$ {\bf discover\_\-xml\_\-vendor\_\-new} (void)
\item
void {\bf discover\_\-xml\_\-merge\_\-vendor\_\-url} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$$\ast$vlist, char $\ast$filename, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-xml\_\-vendor\_\-t} $\ast$ {\bf discover\_\-xml\_\-get\_\-vendors} ({\bf discover\_\-bus\_\-t} bus, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-xml\_\-free\_\-vendors} (void)
\item
char $\ast$ {\bf discover\_\-xml\_\-vendor\_\-id2name} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendors, char $\ast$id)
\item
char $\ast$ {\bf discover\_\-xml\_\-vendor\_\-get\_\-id} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendor)
\item
char $\ast$ {\bf discover\_\-xml\_\-vendor\_\-get\_\-name} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendor)
\item
{\bf discover\_\-xml\_\-vendor\_\-t} $\ast$ {\bf discover\_\-xml\_\-vendor\_\-get\_\-next} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendor)
\item
void {\bf discover\_\-xml\_\-vendor\_\-free} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendors)
\end{CompactItemize}
\subsection{Detailed Description}
Public interface to Discover's XML handling.
Public interface that exposes Discover's XML routines. These functions are used to read the XML data loaded from the specified configuration file(s).
Definition in file {\bf discover-xml.h}. discover-2.1.2/doc/api-reference/latex/structdiscover__sysdep__data.tex 0000644 0023421 0023421 00000006471 10655642004 025064 0 ustar pere pere \section{discover\_\-sysdep\_\-data Struct Reference}
\label{structdiscover__sysdep__data}\index{discover_sysdep_data@{discover\_\-sysdep\_\-data}}
{\tt \#include $<$sysdep.h$>$}
\subsection*{Data Fields}
\begin{CompactItemize}
\item
char $\ast$ {\bf busclass}
\item
char $\ast$ {\bf vendor}
\item
char $\ast$ {\bf model}
\item
{\bf discover\_\-sysdep\_\-device\_\-data\_\-t} $\ast$ {\bf data}
\item
{\bf discover\_\-sysdep\_\-data} $\ast$ {\bf next}
\end{CompactItemize}
\subsection{Detailed Description}
Linked list node, used to return hardware-identification information discovered by the system-dependent interface
Definition at line 56 of file sysdep.h.
\subsection{Field Documentation}
\index{discover_sysdep_data@{discover\_\-sysdep\_\-data}!busclass@{busclass}}
\index{busclass@{busclass}!discover_sysdep_data@{discover\_\-sysdep\_\-data}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ {\bf discover\_\-sysdep\_\-data::busclass}}\label{structdiscover__sysdep__data_o0}
String describing the general device class
Definition at line 58 of file sysdep.h.
Referenced by \_\-discover\_\-free\_\-sysdep\_\-data(), and \_\-discover\_\-sysdep\_\-data\_\-new().\index{discover_sysdep_data@{discover\_\-sysdep\_\-data}!data@{data}}
\index{data@{data}!discover_sysdep_data@{discover\_\-sysdep\_\-data}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-sysdep\_\-device\_\-data\_\-t}$\ast$ {\bf discover\_\-sysdep\_\-data::data}}\label{structdiscover__sysdep__data_o3}
Pointer to any sysdep/device specific data to be returned
Definition at line 64 of file sysdep.h.
Referenced by \_\-discover\_\-free\_\-sysdep\_\-data(), and \_\-discover\_\-sysdep\_\-data\_\-new().\index{discover_sysdep_data@{discover\_\-sysdep\_\-data}!model@{model}}
\index{model@{model}!discover_sysdep_data@{discover\_\-sysdep\_\-data}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ {\bf discover\_\-sysdep\_\-data::model}}\label{structdiscover__sysdep__data_o2}
String identifying the model
Definition at line 62 of file sysdep.h.
Referenced by \_\-discover\_\-free\_\-sysdep\_\-data(), and \_\-discover\_\-sysdep\_\-data\_\-new().\index{discover_sysdep_data@{discover\_\-sysdep\_\-data}!next@{next}}
\index{next@{next}!discover_sysdep_data@{discover\_\-sysdep\_\-data}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}struct {\bf discover\_\-sysdep\_\-data}$\ast$ {\bf discover\_\-sysdep\_\-data::next}}\label{structdiscover__sysdep__data_o4}
Pointer to the next hardware device discovered
Definition at line 66 of file sysdep.h.
Referenced by \_\-discover\_\-free\_\-sysdep\_\-data(), and \_\-discover\_\-sysdep\_\-data\_\-new().\index{discover_sysdep_data@{discover\_\-sysdep\_\-data}!vendor@{vendor}}
\index{vendor@{vendor}!discover_sysdep_data@{discover\_\-sysdep\_\-data}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ {\bf discover\_\-sysdep\_\-data::vendor}}\label{structdiscover__sysdep__data_o1}
String describing the manufacturer or distributor
Definition at line 60 of file sysdep.h.
Referenced by \_\-discover\_\-free\_\-sysdep\_\-data(), and \_\-discover\_\-sysdep\_\-data\_\-new().
The documentation for this struct was generated from the following file:\begin{CompactItemize}
\item
/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/{\bf sysdep.h}\end{CompactItemize}
discover-2.1.2/doc/api-reference/latex/device_8c.tex 0000644 0023421 0023421 00000007031 10655642004 020745 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/device.c File Reference}
\label{device_8c}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/device.c@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/device.c}}
Device enumeration and information management.
{\tt \#include \char`\"{}config.h\char`\"{}}\par
{\tt \#include $<$sys/types.h$>$}\par
{\tt \#include $<$assert.h$>$}\par
{\tt \#include $<$stdbool.h$>$}\par
{\tt \#include $<$string.h$>$}\par
{\tt \#include $<$discover/discover.h$>$}\par
{\tt \#include $<$discover/discover-conf.h$>$}\par
{\tt \#include $<$discover/discover-xml.h$>$}\par
{\tt \#include $<$discover/device.h$>$}\par
{\tt \#include $<$discover/utils.h$>$}\par
\subsection*{Functions}
\begin{CompactItemize}
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-device\_\-find} (char $\ast$discover\_\-class, {\bf discover\_\-error\_\-t} $\ast$status)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-data} ({\bf discover\_\-device\_\-t} $\ast$device, char $\ast$discover\_\-class, char $\ast$version, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-device\_\-copy} ({\bf discover\_\-device\_\-t} $\ast$src, {\bf discover\_\-device\_\-t} $\ast$dst)
\item
char $\ast$ {\bf discover\_\-data\_\-get\_\-class} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
char $\ast$ {\bf discover\_\-data\_\-get\_\-text} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-get\_\-parent} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-get\_\-child} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-get\_\-next} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-get\_\-prev} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-get\_\-first} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-new} (void)
\item
void {\bf discover\_\-data\_\-free} ({\bf discover\_\-data\_\-t} $\ast$data\_\-tree)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-busclass} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-model\_\-id} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-model\_\-name} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-vendor\_\-id} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-vendor\_\-name} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-device\_\-get\_\-data\_\-struct} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-device\_\-get\_\-next} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-device\_\-new} (void)
\item
void {\bf discover\_\-device\_\-free} ({\bf discover\_\-device\_\-t} $\ast$devices, int free\_\-data)
\end{CompactItemize}
\subsection{Detailed Description}
Device enumeration and information management.
This file contains many device-related routines. Most of these routines are used to alter or access data pertaining to a device. These routines will likely be most interesting to people writing code against the Discover API.
Definition in file {\bf device.c}. discover-2.1.2/doc/api-reference/latex/stack_8c.tex 0000644 0023421 0023421 00000010353 10655642004 020614 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/stack.c File Reference}
\label{stack_8c}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/stack.c@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/stack.c}}
Stack routines for Discover.
{\tt \#include $<$stdio.h$>$}\par
{\tt \#include $<$assert.h$>$}\par
{\tt \#include $<$stdbool.h$>$}\par
{\tt \#include $<$stdlib.h$>$}\par
{\tt \#include $<$discover/utils.h$>$}\par
{\tt \#include $<$discover/stack.h$>$}\par
\subsection*{Functions}
\begin{CompactItemize}
\item
discover\_\-xml\_\-stack $\ast$ {\bf discover\_\-xml\_\-stack\_\-new} ()
\item
void {\bf discover\_\-xml\_\-stack\_\-destroy} (discover\_\-xml\_\-stack $\ast$stack)
\item
void {\bf discover\_\-xml\_\-stack\_\-push} (discover\_\-xml\_\-stack $\ast$$\ast$stack, void $\ast$data)
\item
void $\ast$ {\bf discover\_\-xml\_\-stack\_\-pop} (discover\_\-xml\_\-stack $\ast$$\ast$stack)
\item
void $\ast$ {\bf discover\_\-xml\_\-stack\_\-get} (discover\_\-xml\_\-stack $\ast$stack)
\item
void $\ast$ {\bf discover\_\-xml\_\-stack\_\-getbynum} (discover\_\-xml\_\-stack $\ast$stack, int i)
\end{CompactItemize}
\subsection{Detailed Description}
Stack routines for Discover.
This is a generic stack routine that Discover uses. The stack is needed because there wasn't a good way to track the traversal depth through the XML data. These routines brought much sanity to the XML parsing process. They are generic enough that they can be used for any number of applications.
Definition in file {\bf stack.c}.
\subsection{Function Documentation}
\index{stack.c@{stack.c}!discover_xml_stack_destroy@{discover\_\-xml\_\-stack\_\-destroy}}
\index{discover_xml_stack_destroy@{discover\_\-xml\_\-stack\_\-destroy}!stack.c@{stack.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-xml\_\-stack\_\-destroy (discover\_\-xml\_\-stack $\ast$ {\em stack})}\label{stack_8c_a1}
Routine responsible for destroying the stack base once we're done
Definition at line 62 of file stack.c.
Referenced by discover\_\-xml\_\-stack\_\-pop().\index{stack.c@{stack.c}!discover_xml_stack_get@{discover\_\-xml\_\-stack\_\-get}}
\index{discover_xml_stack_get@{discover\_\-xml\_\-stack\_\-get}!stack.c@{stack.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void$\ast$ discover\_\-xml\_\-stack\_\-get (discover\_\-xml\_\-stack $\ast$ {\em stack})}\label{stack_8c_a4}
Return the top item without popping it.
Definition at line 103 of file stack.c.\index{stack.c@{stack.c}!discover_xml_stack_getbynum@{discover\_\-xml\_\-stack\_\-getbynum}}
\index{discover_xml_stack_getbynum@{discover\_\-xml\_\-stack\_\-getbynum}!stack.c@{stack.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void$\ast$ discover\_\-xml\_\-stack\_\-getbynum (discover\_\-xml\_\-stack $\ast$ {\em stack}, int {\em i})}\label{stack_8c_a5}
Return the item at depth i on the stack.
Definition at line 109 of file stack.c.\index{stack.c@{stack.c}!discover_xml_stack_new@{discover\_\-xml\_\-stack\_\-new}}
\index{discover_xml_stack_new@{discover\_\-xml\_\-stack\_\-new}!stack.c@{stack.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}discover\_\-xml\_\-stack$\ast$ discover\_\-xml\_\-stack\_\-new ()}\label{stack_8c_a0}
Routine responsible for creating the base of the stack
Definition at line 48 of file stack.c.
Referenced by discover\_\-xml\_\-stack\_\-push().\index{stack.c@{stack.c}!discover_xml_stack_pop@{discover\_\-xml\_\-stack\_\-pop}}
\index{discover_xml_stack_pop@{discover\_\-xml\_\-stack\_\-pop}!stack.c@{stack.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void$\ast$ discover\_\-xml\_\-stack\_\-pop (discover\_\-xml\_\-stack $\ast$$\ast$ {\em stack})}\label{stack_8c_a3}
Pop an item from the stack.
Definition at line 83 of file stack.c.
References discover\_\-xml\_\-stack\_\-destroy().\index{stack.c@{stack.c}!discover_xml_stack_push@{discover\_\-xml\_\-stack\_\-push}}
\index{discover_xml_stack_push@{discover\_\-xml\_\-stack\_\-push}!stack.c@{stack.c}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-xml\_\-stack\_\-push (discover\_\-xml\_\-stack $\ast$$\ast$ {\em stack}, void $\ast$ {\em data})}\label{stack_8c_a2}
Push an item onto the stack.
Definition at line 69 of file stack.c.
References discover\_\-xml\_\-stack\_\-new(). discover-2.1.2/doc/api-reference/latex/stubs_8c.tex 0000644 0023421 0023421 00000002351 10655642004 020646 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/sysdeps/stub/stubs.c File Reference}
\label{stubs_8c}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/sysdeps/stub/stubs.c@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/sysdeps/stub/stubs.c}}
Stub system-dependent code.
{\tt \#include $<$config.h$>$}\par
{\tt \#include $<$sysdep.h$>$}\par
{\tt \#include $<$stdio.h$>$}\par
\subsection*{Functions}
\begin{CompactItemize}
\item
{\bf discover\_\-sysdep\_\-data\_\-t} $\ast$ {\bf \_\-discover\_\-get\_\-ata\_\-raw} (void)
\item
{\bf discover\_\-sysdep\_\-data\_\-t} $\ast$ {\bf \_\-discover\_\-get\_\-pci\_\-raw} (void)
\item
{\bf discover\_\-sysdep\_\-data\_\-t} $\ast$ {\bf \_\-discover\_\-get\_\-pcmcia\_\-raw} (void)
\item
{\bf discover\_\-sysdep\_\-data\_\-t} $\ast$ {\bf \_\-discover\_\-get\_\-scsi\_\-raw} (void)
\item
{\bf discover\_\-sysdep\_\-data\_\-t} $\ast$ {\bf \_\-discover\_\-get\_\-usb\_\-raw} (void)
\end{CompactItemize}
\subsection{Detailed Description}
Stub system-dependent code.
This file represents a dummy OS-dependent hardware interface. These routines are the skeleton structure that must be followed to allow Discover to operate on multiple architectures.
Definition in file {\bf stubs.c}. discover-2.1.2/doc/api-reference/latex/structdiscover__error.tex 0000644 0023421 0023421 00000006122 10655642004 023547 0 ustar pere pere \section{discover\_\-error Struct Reference}
\label{structdiscover__error}\index{discover_error@{discover\_\-error}}
{\tt \#include $<$discover.h$>$}
\subsection*{Data Fields}
\begin{CompactItemize}
\item
{\bf discover\_\-error\_\-code\_\-t} {\bf code}
\item
char $\ast$ {\bf message}
\item
{\bf discover\_\-create\_\-message\_\-t} $\ast$ {\bf create\_\-message}
\end{CompactItemize}
\subsection{Detailed Description}
All functions that perform some action (as opposed to returning a member of a structure, for example) take an argument of this type. It is used to report that the action succeeded, or why it failed.
Definition at line 106 of file discover.h.
\subsection{Field Documentation}
\index{discover_error@{discover\_\-error}!code@{code}}
\index{code@{code}!discover_error@{discover\_\-error}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-error\_\-code\_\-t} {\bf discover\_\-error::code}}\label{structdiscover__error_o0}
Return the error code value that is checked
Definition at line 108 of file discover.h.
Referenced by \_\-real\_\-discover\_\-conf\_\-get\_\-bus\_\-map(), \_\-real\_\-discover\_\-conf\_\-get\_\-bus\_\-map\_\-by\_\-name(), discover\_\-conf\_\-append\_\-url(), discover\_\-conf\_\-get\_\-bus\_\-map(), discover\_\-conf\_\-get\_\-bus\_\-map\_\-by\_\-name(), discover\_\-conf\_\-get\_\-urls(), discover\_\-conf\_\-insert\_\-url(), discover\_\-conf\_\-load(), discover\_\-conf\_\-name\_\-to\_\-bus(), discover\_\-device\_\-find(), discover\_\-device\_\-get\_\-data(), discover\_\-error\_\-new(), discover\_\-get\_\-devices(), discover\_\-strerror(), discover\_\-xml\_\-get\_\-busclasses(), discover\_\-xml\_\-get\_\-data\_\-urls(), discover\_\-xml\_\-get\_\-devices(), discover\_\-xml\_\-get\_\-urls(), discover\_\-xml\_\-get\_\-vendors(), discover\_\-xml\_\-merge\_\-busclass\_\-url(), discover\_\-xml\_\-merge\_\-device\_\-url(), discover\_\-xml\_\-merge\_\-vendor\_\-url(), and discover\_\-xml\_\-version\_\-cmp().\index{discover_error@{discover\_\-error}!create_message@{create\_\-message}}
\index{create_message@{create\_\-message}!discover_error@{discover\_\-error}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-create\_\-message\_\-t}$\ast$ {\bf discover\_\-error::create\_\-message}}\label{structdiscover__error_o2}
Function pointer into a routine to create a message for us
Definition at line 112 of file discover.h.
Referenced by discover\_\-conf\_\-load(), discover\_\-device\_\-find(), and discover\_\-error\_\-new().\index{discover_error@{discover\_\-error}!message@{message}}
\index{message@{message}!discover_error@{discover\_\-error}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ {\bf discover\_\-error::message}}\label{structdiscover__error_o1}
String containing the message from the last error
Definition at line 110 of file discover.h.
Referenced by discover\_\-error\_\-free(), and discover\_\-error\_\-new().
The documentation for this struct was generated from the following file:\begin{CompactItemize}
\item
/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/{\bf discover.h}\end{CompactItemize}
discover-2.1.2/doc/api-reference/latex/group__vendor__xml.tex 0000644 0023421 0023421 00000015574 10655642004 023016 0 ustar pere pere \section{Vendor list XML parsing}
\label{group__vendor__xml}\index{Vendor list XML parsing@{Vendor list XML parsing}}
\subsection*{Functions}
\begin{CompactItemize}
\item
void {\bf discover\_\-xml\_\-merge\_\-vendor\_\-url} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$$\ast$vlist, char $\ast$url, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-xml\_\-vendor\_\-t} $\ast$ {\bf discover\_\-xml\_\-get\_\-vendors} ({\bf discover\_\-bus\_\-t} bus, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-xml\_\-free\_\-vendors} (void)
\item
char $\ast$ {\bf discover\_\-xml\_\-vendor\_\-id2name} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendors, char $\ast$id)
\item
char $\ast$ {\bf discover\_\-xml\_\-vendor\_\-get\_\-id} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendor)
\item
char $\ast$ {\bf discover\_\-xml\_\-vendor\_\-get\_\-name} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendor)
\item
{\bf discover\_\-xml\_\-vendor\_\-t} $\ast$ {\bf discover\_\-xml\_\-vendor\_\-get\_\-next} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendor)
\item
{\bf discover\_\-xml\_\-vendor\_\-t} $\ast$ {\bf discover\_\-xml\_\-vendor\_\-new} (void)
\item
void {\bf discover\_\-xml\_\-vendor\_\-free} ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$vendors)
\end{CompactItemize}
\subsection{Function Documentation}
\index{vendor_xml@{vendor\_\-xml}!discover_xml_free_vendors@{discover\_\-xml\_\-free\_\-vendors}}
\index{discover_xml_free_vendors@{discover\_\-xml\_\-free\_\-vendors}!vendor_xml@{vendor\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-xml\_\-free\_\-vendors (void)}\label{group__vendor__xml_ga2}
Free the list of vendors.
Definition at line 248 of file vendor-xml.c.
References BUS\_\-COUNT, and discover\_\-xml\_\-vendor\_\-free().\index{vendor_xml@{vendor\_\-xml}!discover_xml_get_vendors@{discover\_\-xml\_\-get\_\-vendors}}
\index{discover_xml_get_vendors@{discover\_\-xml\_\-get\_\-vendors}!vendor_xml@{vendor\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-xml\_\-vendor\_\-t}$\ast$ discover\_\-xml\_\-get\_\-vendors ({\bf discover\_\-bus\_\-t} {\em bus}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__vendor__xml_ga1}
Get the list of vendors by bus type.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em bus}]Type of bus for which vendors are required \item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 215 of file vendor-xml.c.
References discover\_\-error::code, discover\_\-xml\_\-get\_\-data\_\-urls(), discover\_\-xml\_\-merge\_\-vendor\_\-url(), discover\_\-xml\_\-url\_\-get\_\-next(), and discover\_\-xml\_\-url\_\-get\_\-url().
Referenced by discover\_\-xml\_\-get\_\-devices().\index{vendor_xml@{vendor\_\-xml}!discover_xml_merge_vendor_url@{discover\_\-xml\_\-merge\_\-vendor\_\-url}}
\index{discover_xml_merge_vendor_url@{discover\_\-xml\_\-merge\_\-vendor\_\-url}!vendor_xml@{vendor\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-xml\_\-merge\_\-vendor\_\-url ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$$\ast$ {\em vlist}, char $\ast$ {\em url}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__vendor__xml_ga0}
Merge new vendors into a list.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em vlist}]Address of the list to merge vendors into \item[{\em url}]URL of the document defining the vendors \item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 173 of file vendor-xml.c.
References discover\_\-error::code, DISCOVER\_\-EIO, and DISCOVER\_\-EXML.
Referenced by discover\_\-xml\_\-get\_\-vendors().\index{vendor_xml@{vendor\_\-xml}!discover_xml_vendor_free@{discover\_\-xml\_\-vendor\_\-free}}
\index{discover_xml_vendor_free@{discover\_\-xml\_\-vendor\_\-free}!vendor_xml@{vendor\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-xml\_\-vendor\_\-free ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$ {\em vendors})}\label{group__vendor__xml_ga8}
Free the vendor or list of vendors.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em vendors}]Vendor or list of vendors to free \end{description}
\end{Desc}
Definition at line 342 of file vendor-xml.c.
Referenced by discover\_\-xml\_\-free\_\-vendors().\index{vendor_xml@{vendor\_\-xml}!discover_xml_vendor_get_id@{discover\_\-xml\_\-vendor\_\-get\_\-id}}
\index{discover_xml_vendor_get_id@{discover\_\-xml\_\-vendor\_\-get\_\-id}!vendor_xml@{vendor\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ discover\_\-xml\_\-vendor\_\-get\_\-id ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$ {\em vendor})}\label{group__vendor__xml_ga4}
Get the id member of vendor.
Definition at line 290 of file vendor-xml.c.\index{vendor_xml@{vendor\_\-xml}!discover_xml_vendor_get_name@{discover\_\-xml\_\-vendor\_\-get\_\-name}}
\index{discover_xml_vendor_get_name@{discover\_\-xml\_\-vendor\_\-get\_\-name}!vendor_xml@{vendor\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ discover\_\-xml\_\-vendor\_\-get\_\-name ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$ {\em vendor})}\label{group__vendor__xml_ga5}
Get the name member of vendor.
Definition at line 301 of file vendor-xml.c.\index{vendor_xml@{vendor\_\-xml}!discover_xml_vendor_get_next@{discover\_\-xml\_\-vendor\_\-get\_\-next}}
\index{discover_xml_vendor_get_next@{discover\_\-xml\_\-vendor\_\-get\_\-next}!vendor_xml@{vendor\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-xml\_\-vendor\_\-t}$\ast$ discover\_\-xml\_\-vendor\_\-get\_\-next ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$ {\em vendor})}\label{group__vendor__xml_ga6}
Get the next member of vendor.
Definition at line 312 of file vendor-xml.c.\index{vendor_xml@{vendor\_\-xml}!discover_xml_vendor_id2name@{discover\_\-xml\_\-vendor\_\-id2name}}
\index{discover_xml_vendor_id2name@{discover\_\-xml\_\-vendor\_\-id2name}!vendor_xml@{vendor\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ discover\_\-xml\_\-vendor\_\-id2name ({\bf discover\_\-xml\_\-vendor\_\-t} $\ast$ {\em vendors}, char $\ast$ {\em id})}\label{group__vendor__xml_ga3}
Convert a vendor ID to a human-readable string naming the vendor.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em vendors}]List of vendors to search \item[{\em id}]Vendor ID to search for \end{description}
\end{Desc}
Definition at line 264 of file vendor-xml.c.\index{vendor_xml@{vendor\_\-xml}!discover_xml_vendor_new@{discover\_\-xml\_\-vendor\_\-new}}
\index{discover_xml_vendor_new@{discover\_\-xml\_\-vendor\_\-new}!vendor_xml@{vendor\_\-xml}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-xml\_\-vendor\_\-t}$\ast$ discover\_\-xml\_\-vendor\_\-new (void)}\label{group__vendor__xml_ga7}
Create and initialize a new discover\_\-xml\_\-vendor\_\-t structure.
Definition at line 323 of file vendor-xml.c. discover-2.1.2/doc/api-reference/latex/dirs.tex 0000644 0023421 0023421 00000001020 10655642004 020045 0 ustar pere pere \section{discover Directories}
This directory hierarchy is sorted roughly, but not completely, alphabetically:\begin{CompactList}
\item \contentsline{section}{include}{\pageref{dir_000000}}{}
\begin{CompactList}
\item \contentsline{section}{discover}{\pageref{dir_000001}}{}
\end{CompactList}
\item \contentsline{section}{lib}{\pageref{dir_000002}}{}
\item \contentsline{section}{sysdeps}{\pageref{dir_000003}}{}
\begin{CompactList}
\item \contentsline{section}{stub}{\pageref{dir_000004}}{}
\end{CompactList}
\end{CompactList}
discover-2.1.2/doc/api-reference/latex/files.tex 0000644 0023421 0023421 00000005435 10655642004 020224 0 ustar pere pere \section{discover File List}
Here is a list of all documented files with brief descriptions:\begin{CompactList}
\item\contentsline{section}{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/{\bf discover-conf.h} (Public interface for reading Discover configuration data )}{\pageref{discover-conf_8h}}{}
\item\contentsline{section}{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/{\bf discover-xml.h} (Public interface to Discover's XML handling )}{\pageref{discover-xml_8h}}{}
\item\contentsline{section}{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/{\bf discover.h} (Public interface for Discover library )}{\pageref{discover_8h}}{}
\item\contentsline{section}{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/{\bf sysdep.h} (Private interface for system dependencies )}{\pageref{sysdep_8h}}{}
\item\contentsline{section}{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/{\bf busclass-xml.c} (Busclass XML data file parsing )}{\pageref{busclass-xml_8c}}{}
\item\contentsline{section}{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/{\bf conf.c} (Configuration handling (including XML parsing) )}{\pageref{conf_8c}}{}
\item\contentsline{section}{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/{\bf core.c} (Core and miscellaneous routines )}{\pageref{core_8c}}{}
\item\contentsline{section}{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/{\bf device-xml.c} (Device XML data file parsing )}{\pageref{device-xml_8c}}{}
\item\contentsline{section}{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/{\bf device.c} (Device enumeration and information management )}{\pageref{device_8c}}{}
\item\contentsline{section}{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/{\bf load-url.c} (File loading helper functions )}{\pageref{load-url_8c}}{}
\item\contentsline{section}{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/{\bf stack.c} (Stack routines for Discover )}{\pageref{stack_8c}}{}
\item\contentsline{section}{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/{\bf sysdep.c} (Interact with system dependencies )}{\pageref{sysdep_8c}}{}
\item\contentsline{section}{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/{\bf url-xml.c} (XML URL handling )}{\pageref{url-xml_8c}}{}
\item\contentsline{section}{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/{\bf vendor-xml.c} (Vendor XML data file parsing )}{\pageref{vendor-xml_8c}}{}
\item\contentsline{section}{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/{\bf version-cmp.c} (Version comparison functions )}{\pageref{version-cmp_8c}}{}
\item\contentsline{section}{/home/pere/src/debiancvs/pkg-discover/discover/trunk/sysdeps/stub/{\bf stubs.c} (Stub system-dependent code )}{\pageref{stubs_8c}}{}
\end{CompactList}
discover-2.1.2/doc/api-reference/latex/group__sysdeps.tex 0000644 0023421 0023421 00000005550 10655642004 022165 0 ustar pere pere \section{System-dependent interfaces}
\label{group__sysdeps}\index{System-dependent interfaces@{System-dependent interfaces}}
\subsection*{Functions}
\begin{CompactItemize}
\item
{\bf discover\_\-sysdep\_\-data\_\-t} $\ast$ {\bf \_\-discover\_\-get\_\-ata\_\-raw} (void)
\item
{\bf discover\_\-sysdep\_\-data\_\-t} $\ast$ {\bf \_\-discover\_\-get\_\-pci\_\-raw} (void)
\item
{\bf discover\_\-sysdep\_\-data\_\-t} $\ast$ {\bf \_\-discover\_\-get\_\-pcmcia\_\-raw} (void)
\item
{\bf discover\_\-sysdep\_\-data\_\-t} $\ast$ {\bf \_\-discover\_\-get\_\-scsi\_\-raw} (void)
\item
{\bf discover\_\-sysdep\_\-data\_\-t} $\ast$ {\bf \_\-discover\_\-get\_\-usb\_\-raw} (void)
\end{CompactItemize}
\subsection{Function Documentation}
\index{sysdeps@{sysdeps}!_discover_get_ata_raw@{\_\-discover\_\-get\_\-ata\_\-raw}}
\index{_discover_get_ata_raw@{\_\-discover\_\-get\_\-ata\_\-raw}!sysdeps@{sysdeps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-sysdep\_\-data\_\-t}$\ast$ \_\-discover\_\-get\_\-ata\_\-raw (void)}\label{group__sysdeps_ga0}
Get the list of ATA devices, scanning the bus if necessary.
Definition at line 51 of file stubs.c.\index{sysdeps@{sysdeps}!_discover_get_pci_raw@{\_\-discover\_\-get\_\-pci\_\-raw}}
\index{_discover_get_pci_raw@{\_\-discover\_\-get\_\-pci\_\-raw}!sysdeps@{sysdeps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-sysdep\_\-data\_\-t}$\ast$ \_\-discover\_\-get\_\-pci\_\-raw (void)}\label{group__sysdeps_ga1}
Get the list of PCI devices, scanning the bus if necessary.
Definition at line 60 of file stubs.c.\index{sysdeps@{sysdeps}!_discover_get_pcmcia_raw@{\_\-discover\_\-get\_\-pcmcia\_\-raw}}
\index{_discover_get_pcmcia_raw@{\_\-discover\_\-get\_\-pcmcia\_\-raw}!sysdeps@{sysdeps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-sysdep\_\-data\_\-t}$\ast$ \_\-discover\_\-get\_\-pcmcia\_\-raw (void)}\label{group__sysdeps_ga2}
Get the list of PCMCIA devices, scanning the bus if necessary.
Definition at line 69 of file stubs.c.\index{sysdeps@{sysdeps}!_discover_get_scsi_raw@{\_\-discover\_\-get\_\-scsi\_\-raw}}
\index{_discover_get_scsi_raw@{\_\-discover\_\-get\_\-scsi\_\-raw}!sysdeps@{sysdeps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-sysdep\_\-data\_\-t}$\ast$ \_\-discover\_\-get\_\-scsi\_\-raw (void)}\label{group__sysdeps_ga3}
Get the list of SCSI devices, scanning the bus if necessary.
Definition at line 78 of file stubs.c.\index{sysdeps@{sysdeps}!_discover_get_usb_raw@{\_\-discover\_\-get\_\-usb\_\-raw}}
\index{_discover_get_usb_raw@{\_\-discover\_\-get\_\-usb\_\-raw}!sysdeps@{sysdeps}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-sysdep\_\-data\_\-t}$\ast$ \_\-discover\_\-get\_\-usb\_\-raw (void)}\label{group__sysdeps_ga4}
Get the list of USB devices, scanning the bus if necessary.
Definition at line 87 of file stubs.c. discover-2.1.2/doc/api-reference/latex/dir_000002.tex 0000644 0023421 0023421 00000003163 10655642004 020475 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/ Directory Reference}
\label{dir_000002}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/ Directory Reference@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/ Directory Reference}}
\subsection*{Files}
\begin{CompactItemize}
\item
file {\bf busclass-xml.c}
\begin{CompactList}\small\item\em Busclass XML data file parsing. \item\end{CompactList}
\item
file {\bf conf.c}
\begin{CompactList}\small\item\em Configuration handling (including XML parsing). \item\end{CompactList}
\item
file {\bf core.c}
\begin{CompactList}\small\item\em Core and miscellaneous routines. \item\end{CompactList}
\item
file {\bf device-xml.c}
\begin{CompactList}\small\item\em Device XML data file parsing. \item\end{CompactList}
\item
file {\bf device.c}
\begin{CompactList}\small\item\em Device enumeration and information management. \item\end{CompactList}
\item
file {\bf load-url.c}
\begin{CompactList}\small\item\em File loading helper functions. \item\end{CompactList}
\item
file {\bf stack.c}
\begin{CompactList}\small\item\em Stack routines for Discover. \item\end{CompactList}
\item
file {\bf sysdep.c}
\begin{CompactList}\small\item\em Interact with system dependencies. \item\end{CompactList}
\item
file {\bf url-xml.c}
\begin{CompactList}\small\item\em XML URL handling. \item\end{CompactList}
\item
file {\bf vendor-xml.c}
\begin{CompactList}\small\item\em Vendor XML data file parsing. \item\end{CompactList}
\item
file {\bf version-cmp.c}
\begin{CompactList}\small\item\em Version comparison functions. \item\end{CompactList}
\end{CompactItemize}
discover-2.1.2/doc/api-reference/latex/discover-conf_8h.tex 0000644 0023421 0023421 00000004074 10655642004 022260 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/discover-conf.h File Reference}
\label{discover-conf_8h}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/discover-conf.h@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/discover-conf.h}}
Public interface for reading Discover configuration data.
{\tt \#include $<$discover/discover.h$>$}\par
\subsection*{Functions}
\begin{CompactItemize}
\item
void {\bf discover\_\-conf\_\-load} ({\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-bus\_\-map\_\-t} $\ast$ {\bf discover\_\-conf\_\-get\_\-full\_\-bus\_\-map} ({\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-bus\_\-map\_\-t} $\ast$ {\bf discover\_\-conf\_\-get\_\-bus\_\-map} ({\bf discover\_\-bus\_\-t} bus, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-bus\_\-map\_\-t} $\ast$ {\bf discover\_\-conf\_\-get\_\-bus\_\-map\_\-by\_\-name} (char $\ast$name, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-conf\_\-insert\_\-url} (char $\ast$url, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-conf\_\-append\_\-url} (char $\ast$url, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-xml\_\-url\_\-t} $\ast$ {\bf discover\_\-conf\_\-get\_\-urls} ({\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-conf\_\-free} (void)
\item
char $\ast$ {\bf discover\_\-conf\_\-get\_\-bus\_\-name} ({\bf discover\_\-bus\_\-t} bus)
\item
char $\ast$ {\bf discover\_\-conf\_\-get\_\-filetype\_\-name} ({\bf discover\_\-filetype\_\-t} filetype)
\item
int {\bf discover\_\-conf\_\-name\_\-to\_\-bus} (char $\ast$name, {\bf discover\_\-error\_\-t} $\ast$status)
\end{CompactItemize}
\subsection{Detailed Description}
Public interface for reading Discover configuration data.
These routines are the public interface used to read the configuration data from the desired source. These interfaces are also used to alter the URLs searched for configuration data.
Definition in file {\bf discover-conf.h}. discover-2.1.2/doc/api-reference/latex/structdiscover__bus__map.tex 0000644 0023421 0023421 00000005277 10655642004 024215 0 ustar pere pere \section{discover\_\-bus\_\-map Struct Reference}
\label{structdiscover__bus__map}\index{discover_bus_map@{discover\_\-bus\_\-map}}
{\tt \#include $<$discover.h$>$}
\subsection*{Data Fields}
\begin{CompactItemize}
\item
char $\ast$ {\bf name}
\item
int {\bf scan\_\-default}
\item
int {\bf scan\_\-never}
\item
{\bf discover\_\-sysdep\_\-raw\_\-func\_\-t} $\ast$ {\bf get\_\-raw}
\end{CompactItemize}
\subsection{Detailed Description}
Bus scanning information is loaded from the config file. The scan\_\-default member may be set to 0 to avoid scanning a specified bus. If the scan\_\-never flag is set, the bus will never be scanned; this behavior is controlled from the config file.
The function pointer exists to allow client code to override the sysdeps; it is used by the unit tests provided with Discover.
Definition at line 178 of file discover.h.
\subsection{Field Documentation}
\index{discover_bus_map@{discover\_\-bus\_\-map}!get_raw@{get\_\-raw}}
\index{get_raw@{get\_\-raw}!discover_bus_map@{discover\_\-bus\_\-map}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-sysdep\_\-raw\_\-func\_\-t}$\ast$ {\bf discover\_\-bus\_\-map::get\_\-raw}}\label{structdiscover__bus__map_o3}
Function pointer that will acquire data
Definition at line 186 of file discover.h.
Referenced by discover\_\-get\_\-devices().\index{discover_bus_map@{discover\_\-bus\_\-map}!name@{name}}
\index{name@{name}!discover_bus_map@{discover\_\-bus\_\-map}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ {\bf discover\_\-bus\_\-map::name}}\label{structdiscover__bus__map_o0}
Human-readable name
Definition at line 180 of file discover.h.
Referenced by discover\_\-conf\_\-get\_\-bus\_\-name().\index{discover_bus_map@{discover\_\-bus\_\-map}!scan_default@{scan\_\-default}}
\index{scan_default@{scan\_\-default}!discover_bus_map@{discover\_\-bus\_\-map}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int {\bf discover\_\-bus\_\-map::scan\_\-default}}\label{structdiscover__bus__map_o1}
Boolean (sort of) defining the bus's default behavior
Definition at line 182 of file discover.h.\index{discover_bus_map@{discover\_\-bus\_\-map}!scan_never@{scan\_\-never}}
\index{scan_never@{scan\_\-never}!discover_bus_map@{discover\_\-bus\_\-map}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int {\bf discover\_\-bus\_\-map::scan\_\-never}}\label{structdiscover__bus__map_o2}
Never scan this bus if true
Definition at line 184 of file discover.h.
Referenced by discover\_\-get\_\-devices().
The documentation for this struct was generated from the following file:\begin{CompactItemize}
\item
/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/{\bf discover.h}\end{CompactItemize}
discover-2.1.2/doc/api-reference/latex/discover_8h.tex 0000644 0023421 0023421 00000016254 10655642004 021340 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/discover.h File Reference}
\label{discover_8h}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/discover.h@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/discover.h}}
Public interface for Discover library.
{\tt \#include $<$stdbool.h$>$}\par
{\tt \#include $<$discover/sysdep.h$>$}\par
\subsection*{Defines}
\begin{CompactItemize}
\item
\#define {\bf BUS\_\-COUNT}~5
\end{CompactItemize}
\subsection*{Typedefs}
\begin{CompactItemize}
\item
typedef void $\ast$( {\bf discover\_\-create\_\-message\_\-t} )(struct {\bf discover\_\-error} $\ast$$\ast$, char $\ast$)
\item
typedef {\bf discover\_\-error} {\bf discover\_\-error\_\-t}
\item
typedef {\bf discover\_\-bus\_\-map} {\bf discover\_\-bus\_\-map\_\-t}
\item
typedef discover\_\-device {\bf discover\_\-device\_\-t}
\item
typedef discover\_\-data {\bf discover\_\-data\_\-t}
\item
typedef discover\_\-xml\_\-busclass {\bf discover\_\-xml\_\-busclass\_\-t}
\item
typedef discover\_\-xml\_\-vendor {\bf discover\_\-xml\_\-vendor\_\-t}
\item
typedef discover\_\-xml\_\-url {\bf discover\_\-xml\_\-url\_\-t}
\item
typedef {\bf discover\_\-device\_\-t} $\ast$( {\bf discover\_\-device\_\-func\_\-t} )({\bf discover\_\-error\_\-t} $\ast$)
\item
typedef {\bf discover\_\-xml\_\-busclass\_\-t} $\ast$( {\bf discover\_\-xml\_\-busclass\_\-func\_\-t} )({\bf discover\_\-error\_\-t} $\ast$)
\item
typedef {\bf discover\_\-xml\_\-vendor\_\-t} $\ast$( {\bf discover\_\-xml\_\-vendor\_\-func\_\-t} )({\bf discover\_\-error\_\-t} $\ast$)
\item
typedef {\bf discover\_\-xml\_\-url\_\-t} $\ast$( {\bf discover\_\-xml\_\-url\_\-func\_\-t} )({\bf discover\_\-error\_\-t} $\ast$)
\item
typedef void( {\bf discover\_\-free\_\-func\_\-t} )(void)
\item
typedef {\bf discover\_\-sysdep\_\-data\_\-t} $\ast$( {\bf discover\_\-sysdep\_\-raw\_\-func\_\-t} )(void)
\end{CompactItemize}
\subsection*{Enumerations}
\begin{CompactItemize}
\item
enum {\bf discover\_\-error\_\-code\_\-t} \{ \par
{\bf DISCOVER\_\-SUCCESS},
{\bf DISCOVER\_\-EIO},
{\bf DISCOVER\_\-EXML},
{\bf DISCOVER\_\-ESYS},
\par
{\bf DISCOVER\_\-EBUSDISABLED},
{\bf DISCOVER\_\-EBUSNOTFOUND},
{\bf DISCOVER\_\-EDATANOTFOUND},
{\bf DISCOVER\_\-EDEVICENOTFOUND},
\par
{\bf DISCOVER\_\-EBADVERSION},
{\bf DISCOVER\_\-ENOIMPL}
\}
\item
enum {\bf discover\_\-bus\_\-t} \{ \par
{\bf ATA},
{\bf PCI},
{\bf PCMCIA},
{\bf SCSI},
\par
{\bf USB}
\}
\item
enum {\bf discover\_\-filetype\_\-t} \{ {\bf VENDOR\_\-TYPE},
{\bf BUSCLASS\_\-TYPE},
{\bf DEVICE\_\-TYPE}
\}
\end{CompactItemize}
\subsection*{Functions}
\begin{CompactItemize}
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-get\_\-devices} ({\bf discover\_\-bus\_\-t} bus, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-free\_\-devices} (void)
\item
{\bf discover\_\-error\_\-t} $\ast$ {\bf discover\_\-error\_\-new} (void)
\item
void {\bf discover\_\-error\_\-free} ({\bf discover\_\-error\_\-t} $\ast$status)
\item
char $\ast$ {\bf discover\_\-strerror} ({\bf discover\_\-error\_\-t} $\ast$err)
\item
int {\bf discover\_\-major\_\-version} (void)
\item
int {\bf discover\_\-minor\_\-version} (void)
\item
int {\bf discover\_\-micro\_\-version} (void)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-device\_\-new} (void)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-device\_\-find} (char $\ast$discover\_\-class, {\bf discover\_\-error\_\-t} $\ast$status)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-data} ({\bf discover\_\-device\_\-t} $\ast$device, char $\ast$path, char $\ast$version, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-device\_\-copy} ({\bf discover\_\-device\_\-t} $\ast$src, {\bf discover\_\-device\_\-t} $\ast$dst)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-busclass} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-model\_\-id} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-model\_\-name} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-vendor\_\-id} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
char $\ast$ {\bf discover\_\-device\_\-get\_\-vendor\_\-name} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-device\_\-get\_\-data\_\-struct} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
{\bf discover\_\-device\_\-t} $\ast$ {\bf discover\_\-device\_\-get\_\-next} ({\bf discover\_\-device\_\-t} $\ast$device)
\item
void {\bf discover\_\-device\_\-free} ({\bf discover\_\-device\_\-t} $\ast$devices, int free\_\-data)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-new} (void)
\item
char $\ast$ {\bf discover\_\-data\_\-get\_\-class} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
char $\ast$ {\bf discover\_\-data\_\-get\_\-text} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-get\_\-parent} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-get\_\-child} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-get\_\-next} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-get\_\-prev} ({\bf discover\_\-data\_\-t} $\ast$prev)
\item
{\bf discover\_\-data\_\-t} $\ast$ {\bf discover\_\-data\_\-get\_\-first} ({\bf discover\_\-data\_\-t} $\ast$data)
\item
void {\bf discover\_\-data\_\-free} ({\bf discover\_\-data\_\-t} $\ast$data\_\-tree)
\end{CompactItemize}
\subsection{Detailed Description}
Public interface for Discover library.
Definition in file {\bf discover.h}.
\subsection{Function Documentation}
\index{discover.h@{discover.h}!discover_free_devices@{discover\_\-free\_\-devices}}
\index{discover_free_devices@{discover\_\-free\_\-devices}!discover.h@{discover.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-free\_\-devices (void)}\label{discover_8h_a34}
Free the currently allocated memory holding the device information.
Definition at line 301 of file sysdep.c.
References BUS\_\-COUNT, and discover\_\-device\_\-free().\index{discover.h@{discover.h}!discover_get_devices@{discover\_\-get\_\-devices}}
\index{discover_get_devices@{discover\_\-get\_\-devices}!discover.h@{discover.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-device\_\-t}$\ast$ discover\_\-get\_\-devices ({\bf discover\_\-bus\_\-t} {\em bus}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{discover_8h_a33}
Function responsible for returning a devicelist of current devices
Definition at line 206 of file sysdep.c.
References \_\-discover\_\-convert\_\-device\_\-data(), \_\-discover\_\-free\_\-sysdep\_\-data(), discover\_\-error::code, discover\_\-conf\_\-get\_\-bus\_\-map(), discover\_\-device\_\-new(), DISCOVER\_\-EBUSDISABLED, DISCOVER\_\-SUCCESS, discover\_\-xml\_\-get\_\-devices(), discover\_\-xml\_\-get\_\-matching\_\-devices(), discover\_\-bus\_\-map::get\_\-raw, and discover\_\-bus\_\-map::scan\_\-never.
Referenced by discover\_\-device\_\-find(). discover-2.1.2/doc/api-reference/latex/busclass-xml_8c.tex 0000644 0023421 0023421 00000004634 10655642004 022131 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/busclass-xml.c File Reference}
\label{busclass-xml_8c}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/busclass-xml.c@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/lib/busclass-xml.c}}
Busclass XML data file parsing.
{\tt \#include \char`\"{}config.h\char`\"{}}\par
{\tt \#include $<$sys/types.h$>$}\par
{\tt \#include $<$assert.h$>$}\par
{\tt \#include $<$limits.h$>$}\par
{\tt \#include $<$stdio.h$>$}\par
{\tt \#include $<$string.h$>$}\par
{\tt \#include $<$expat.h$>$}\par
{\tt \#include $<$discover/discover.h$>$}\par
{\tt \#include $<$discover/discover-xml.h$>$}\par
{\tt \#include $<$discover/load-url.h$>$}\par
{\tt \#include $<$discover/utils.h$>$}\par
\subsection*{Functions}
\begin{CompactItemize}
\item
void {\bf discover\_\-xml\_\-merge\_\-busclass\_\-url} ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$$\ast$blist, char $\ast$url, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-xml\_\-busclass\_\-t} $\ast$ {\bf discover\_\-xml\_\-get\_\-busclasses} ({\bf discover\_\-bus\_\-t} bus, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-xml\_\-free\_\-busclasses} (void)
\item
char $\ast$ {\bf discover\_\-xml\_\-busclass\_\-to\_\-class} (char $\ast$busclass, {\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclasses)
\item
int {\bf discover\_\-xml\_\-busclass\_\-cmp} (char $\ast$busclass, char $\ast$discover\_\-class, {\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclasses)
\item
char $\ast$ {\bf discover\_\-xml\_\-busclass\_\-get\_\-id} ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclass)
\item
char $\ast$ {\bf discover\_\-xml\_\-busclass\_\-get\_\-name} ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclass)
\item
{\bf discover\_\-xml\_\-busclass\_\-t} $\ast$ {\bf discover\_\-xml\_\-busclass\_\-get\_\-next} ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclass)
\item
{\bf discover\_\-xml\_\-busclass\_\-t} $\ast$ {\bf discover\_\-xml\_\-busclass\_\-new} (void)
\item
void {\bf discover\_\-xml\_\-busclass\_\-free} ({\bf discover\_\-xml\_\-busclass\_\-t} $\ast$busclasses)
\end{CompactItemize}
\subsection{Detailed Description}
Busclass XML data file parsing.
This file contains the routines needed to properly process the busclass XML data. This file is responsible for handling URLs and actually storing the XML data during the parsing process.
Definition in file {\bf busclass-xml.c}. discover-2.1.2/doc/api-reference/latex/group__conf.tex 0000644 0023421 0023421 00000023711 10655642004 021417 0 ustar pere pere \section{Configuration handling}
\label{group__conf}\index{Configuration handling@{Configuration handling}}
\subsection*{Functions}
\begin{CompactItemize}
\item
void {\bf discover\_\-conf\_\-load} ({\bf discover\_\-error\_\-t} $\ast$status)
\item
int {\bf discover\_\-conf\_\-name\_\-to\_\-bus} (char $\ast$name, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-bus\_\-map\_\-t} $\ast$ {\bf discover\_\-conf\_\-get\_\-full\_\-bus\_\-map} ({\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-bus\_\-map\_\-t} $\ast$ {\bf discover\_\-conf\_\-get\_\-bus\_\-map\_\-by\_\-name} (char $\ast$name, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-bus\_\-map\_\-t} $\ast$ {\bf discover\_\-conf\_\-get\_\-bus\_\-map} ({\bf discover\_\-bus\_\-t} bus, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-conf\_\-insert\_\-url} (char $\ast$url, {\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-conf\_\-append\_\-url} (char $\ast$url, {\bf discover\_\-error\_\-t} $\ast$status)
\item
{\bf discover\_\-xml\_\-url\_\-t} $\ast$ {\bf discover\_\-conf\_\-get\_\-urls} ({\bf discover\_\-error\_\-t} $\ast$status)
\item
void {\bf discover\_\-conf\_\-free} (void)
\item
char $\ast$ {\bf discover\_\-conf\_\-get\_\-bus\_\-name} ({\bf discover\_\-bus\_\-t} bus)
\item
char $\ast$ {\bf discover\_\-conf\_\-get\_\-filetype\_\-name} ({\bf discover\_\-filetype\_\-t} filetype)
\end{CompactItemize}
\subsection{Function Documentation}
\index{conf@{conf}!discover_conf_append_url@{discover\_\-conf\_\-append\_\-url}}
\index{discover_conf_append_url@{discover\_\-conf\_\-append\_\-url}!conf@{conf}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-conf\_\-append\_\-url (char $\ast$ {\em url}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__conf_ga6}
Append the URL specified in url at the tail of the list of URLs where Discover data will be retrieved.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em url}]URL to append \item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 579 of file conf.c.
References discover\_\-error::code, and discover\_\-conf\_\-load().\index{conf@{conf}!discover_conf_free@{discover\_\-conf\_\-free}}
\index{discover_conf_free@{discover\_\-conf\_\-free}!conf@{conf}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-conf\_\-free (void)}\label{group__conf_ga8}
Free configuration data. This is mainly useful so that the next call to discover\_\-conf\_\-load will reload the configuration data.
Definition at line 650 of file conf.c.
References discover\_\-xml\_\-url\_\-free().\index{conf@{conf}!discover_conf_get_bus_map@{discover\_\-conf\_\-get\_\-bus\_\-map}}
\index{discover_conf_get_bus_map@{discover\_\-conf\_\-get\_\-bus\_\-map}!conf@{conf}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-bus\_\-map\_\-t}$\ast$ discover\_\-conf\_\-get\_\-bus\_\-map ({\bf discover\_\-bus\_\-t} {\em bus}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__conf_ga4}
Get the bus map for a single bus.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em bus}]Name of the bus whose map to get \item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 532 of file conf.c.
References BUS\_\-COUNT, discover\_\-error::code, discover\_\-conf\_\-load(), and DISCOVER\_\-EBUSNOTFOUND.
Referenced by discover\_\-get\_\-devices().\index{conf@{conf}!discover_conf_get_bus_map_by_name@{discover\_\-conf\_\-get\_\-bus\_\-map\_\-by\_\-name}}
\index{discover_conf_get_bus_map_by_name@{discover\_\-conf\_\-get\_\-bus\_\-map\_\-by\_\-name}!conf@{conf}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-bus\_\-map\_\-t}$\ast$ discover\_\-conf\_\-get\_\-bus\_\-map\_\-by\_\-name (char $\ast$ {\em name}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__conf_ga3}
Get the bus map by name for a single bus.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name of the bus whose map to get \item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 509 of file conf.c.
References \_\-real\_\-discover\_\-conf\_\-get\_\-bus\_\-map\_\-by\_\-name(), discover\_\-error::code, and discover\_\-conf\_\-load().\index{conf@{conf}!discover_conf_get_bus_name@{discover\_\-conf\_\-get\_\-bus\_\-name}}
\index{discover_conf_get_bus_name@{discover\_\-conf\_\-get\_\-bus\_\-name}!conf@{conf}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ discover\_\-conf\_\-get\_\-bus\_\-name ({\bf discover\_\-bus\_\-t} {\em bus})}\label{group__conf_ga9}
Translate an enum bus value into a string.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em bus}]Bus type in enumerated form \end{description}
\end{Desc}
Definition at line 666 of file conf.c.
References BUS\_\-COUNT, and discover\_\-bus\_\-map::name.
Referenced by discover\_\-xml\_\-get\_\-data\_\-urls().\index{conf@{conf}!discover_conf_get_filetype_name@{discover\_\-conf\_\-get\_\-filetype\_\-name}}
\index{discover_conf_get_filetype_name@{discover\_\-conf\_\-get\_\-filetype\_\-name}!conf@{conf}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ discover\_\-conf\_\-get\_\-filetype\_\-name ({\bf discover\_\-filetype\_\-t} {\em filetype})}\label{group__conf_ga10}
Translate an enum filetype value into a string.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em filetype}]Filetype in enumerated form \end{description}
\end{Desc}
Definition at line 682 of file conf.c.
Referenced by discover\_\-xml\_\-get\_\-data\_\-urls().\index{conf@{conf}!discover_conf_get_full_bus_map@{discover\_\-conf\_\-get\_\-full\_\-bus\_\-map}}
\index{discover_conf_get_full_bus_map@{discover\_\-conf\_\-get\_\-full\_\-bus\_\-map}!conf@{conf}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-bus\_\-map\_\-t}$\ast$ discover\_\-conf\_\-get\_\-full\_\-bus\_\-map ({\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__conf_ga2}
Get the full bus map, listing all buses.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 496 of file conf.c.
References discover\_\-conf\_\-load().
Referenced by discover\_\-device\_\-find().\index{conf@{conf}!discover_conf_get_urls@{discover\_\-conf\_\-get\_\-urls}}
\index{discover_conf_get_urls@{discover\_\-conf\_\-get\_\-urls}!conf@{conf}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-xml\_\-url\_\-t}$\ast$ discover\_\-conf\_\-get\_\-urls ({\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__conf_ga7}
Get the list of URLs from which XML data will be retrieved.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 599 of file conf.c.
References discover\_\-error::code, discover\_\-conf\_\-load(), and discover\_\-xml\_\-url\_\-new().
Referenced by discover\_\-xml\_\-get\_\-urls().\index{conf@{conf}!discover_conf_insert_url@{discover\_\-conf\_\-insert\_\-url}}
\index{discover_conf_insert_url@{discover\_\-conf\_\-insert\_\-url}!conf@{conf}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-conf\_\-insert\_\-url (char $\ast$ {\em url}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__conf_ga5}
Insert the URL specified in url at the head of the list of URLs where Discover data will be retrieved.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em url}]URL to insert \item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 557 of file conf.c.
References discover\_\-error::code, and discover\_\-conf\_\-load().\index{conf@{conf}!discover_conf_load@{discover\_\-conf\_\-load}}
\index{discover_conf_load@{discover\_\-conf\_\-load}!conf@{conf}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void discover\_\-conf\_\-load ({\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__conf_ga0}
Ensure that the configuration file is loaded. Repeated calls to this function will not change anything, unless you call discover\_\-conf\_\-free.
Technically, this function will lie to you if there is no conf file. Even though no configuration was loaded, repeated calls still will not change anything. However, if we don't do this and a config file is created between the time some long-lived caller first calls discover\_\-conf\_\-load and the time it calls it again, it will be loaded. This doesn't strike me as idempotent behavior. So, repeated calls even in this case will not change anything unless you call discover\_\-conf\_\-free.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 378 of file conf.c.
References discover\_\-error::code, discover\_\-error::create\_\-message, and DISCOVER\_\-EXML.
Referenced by discover\_\-conf\_\-append\_\-url(), discover\_\-conf\_\-get\_\-bus\_\-map(), discover\_\-conf\_\-get\_\-bus\_\-map\_\-by\_\-name(), discover\_\-conf\_\-get\_\-full\_\-bus\_\-map(), discover\_\-conf\_\-get\_\-urls(), and discover\_\-conf\_\-insert\_\-url().\index{conf@{conf}!discover_conf_name_to_bus@{discover\_\-conf\_\-name\_\-to\_\-bus}}
\index{discover_conf_name_to_bus@{discover\_\-conf\_\-name\_\-to\_\-bus}!conf@{conf}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int discover\_\-conf\_\-name\_\-to\_\-bus (char $\ast$ {\em name}, {\bf discover\_\-error\_\-t} $\ast$ {\em status})}\label{group__conf_ga1}
Get the bus enumeration for a bus name.
\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em name}]Name of the bus \item[{\em status}]Address in which to place status report \end{description}
\end{Desc}
Definition at line 477 of file conf.c.
References discover\_\-error::code, and DISCOVER\_\-EBUSNOTFOUND.
Referenced by \_\-real\_\-discover\_\-conf\_\-get\_\-bus\_\-map\_\-by\_\-name(). discover-2.1.2/doc/api-reference/latex/structdiscover__sysdep__device__data.tex 0000644 0023421 0023421 00000005223 10655642004 026534 0 ustar pere pere \section{discover\_\-sysdep\_\-device\_\-data Struct Reference}
\label{structdiscover__sysdep__device__data}\index{discover_sysdep_device_data@{discover\_\-sysdep\_\-device\_\-data}}
{\tt \#include $<$sysdep.h$>$}
\subsection*{Data Fields}
\begin{CompactItemize}
\item
char $\ast$ {\bf path}
\item
char $\ast$ {\bf value}
\item
{\bf discover\_\-sysdep\_\-device\_\-data} $\ast$ {\bf next}
\end{CompactItemize}
\subsection{Detailed Description}
Linked list node, used to return data specific to the sysdep/device in question, to be passed to the user under the \char`\"{}device\char`\"{} data path.
Definition at line 43 of file sysdep.h.
\subsection{Field Documentation}
\index{discover_sysdep_device_data@{discover\_\-sysdep\_\-device\_\-data}!next@{next}}
\index{next@{next}!discover_sysdep_device_data@{discover\_\-sysdep\_\-device\_\-data}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}struct {\bf discover\_\-sysdep\_\-device\_\-data}$\ast$ {\bf discover\_\-sysdep\_\-device\_\-data::next}}\label{structdiscover__sysdep__device__data_o2}
Pointer to the next data node
Definition at line 49 of file sysdep.h.
Referenced by \_\-discover\_\-convert\_\-device\_\-data(), \_\-discover\_\-free\_\-sysdep\_\-device\_\-data(), and \_\-discover\_\-sysdep\_\-device\_\-data\_\-new().\index{discover_sysdep_device_data@{discover\_\-sysdep\_\-device\_\-data}!path@{path}}
\index{path@{path}!discover_sysdep_device_data@{discover\_\-sysdep\_\-device\_\-data}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ {\bf discover\_\-sysdep\_\-device\_\-data::path}}\label{structdiscover__sysdep__device__data_o0}
String giving the path for the data (not including \char`\"{}device\char`\"{}
Definition at line 45 of file sysdep.h.
Referenced by \_\-discover\_\-convert\_\-device\_\-data(), \_\-discover\_\-free\_\-sysdep\_\-device\_\-data(), and \_\-discover\_\-sysdep\_\-device\_\-data\_\-new().\index{discover_sysdep_device_data@{discover\_\-sysdep\_\-device\_\-data}!value@{value}}
\index{value@{value}!discover_sysdep_device_data@{discover\_\-sysdep\_\-device\_\-data}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}char$\ast$ {\bf discover\_\-sysdep\_\-device\_\-data::value}}\label{structdiscover__sysdep__device__data_o1}
String with the data's value
Definition at line 47 of file sysdep.h.
Referenced by \_\-discover\_\-convert\_\-device\_\-data(), \_\-discover\_\-free\_\-sysdep\_\-device\_\-data(), and \_\-discover\_\-sysdep\_\-device\_\-data\_\-new().
The documentation for this struct was generated from the following file:\begin{CompactItemize}
\item
/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/{\bf sysdep.h}\end{CompactItemize}
discover-2.1.2/doc/api-reference/latex/sysdep_8h.tex 0000644 0023421 0023421 00000012626 10655642004 021030 0 ustar pere pere \section{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/sysdep.h File Reference}
\label{sysdep_8h}\index{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/sysdep.h@{/home/pere/src/debiancvs/pkg-discover/discover/trunk/include/discover/sysdep.h}}
Private interface for system dependencies.
\subsection*{Typedefs}
\begin{CompactItemize}
\item
typedef {\bf discover\_\-sysdep\_\-device\_\-data} {\bf discover\_\-sysdep\_\-device\_\-data\_\-t}
\item
typedef {\bf discover\_\-sysdep\_\-data} {\bf discover\_\-sysdep\_\-data\_\-t}
\end{CompactItemize}
\subsection*{Functions}
\begin{CompactItemize}
\item
{\bf discover\_\-sysdep\_\-data\_\-t} $\ast$ {\bf \_\-discover\_\-sysdep\_\-data\_\-new} (void)
\item
{\bf discover\_\-sysdep\_\-device\_\-data\_\-t} $\ast$ {\bf \_\-discover\_\-sysdep\_\-device\_\-data\_\-new} (void)
\item
void {\bf \_\-discover\_\-free\_\-sysdep\_\-data} ({\bf discover\_\-sysdep\_\-data\_\-t} $\ast$)
\item
void {\bf \_\-discover\_\-free\_\-sysdep\_\-device\_\-data} ({\bf discover\_\-sysdep\_\-device\_\-data\_\-t} $\ast$)
\item
{\bf discover\_\-sysdep\_\-data\_\-t} $\ast$ {\bf \_\-discover\_\-get\_\-ata\_\-raw} (void)
\item
{\bf discover\_\-sysdep\_\-data\_\-t} $\ast$ {\bf \_\-discover\_\-get\_\-pci\_\-raw} (void)
\item
{\bf discover\_\-sysdep\_\-data\_\-t} $\ast$ {\bf \_\-discover\_\-get\_\-usb\_\-raw} (void)
\item
{\bf discover\_\-sysdep\_\-data\_\-t} $\ast$ {\bf \_\-discover\_\-get\_\-pcmcia\_\-raw} (void)
\item
{\bf discover\_\-sysdep\_\-data\_\-t} $\ast$ {\bf \_\-discover\_\-get\_\-scsi\_\-raw} (void)
\end{CompactItemize}
\subsection{Detailed Description}
Private interface for system dependencies.
Definition in file {\bf sysdep.h}.
\subsection{Typedef Documentation}
\index{sysdep.h@{sysdep.h}!discover_sysdep_data_t@{discover\_\-sysdep\_\-data\_\-t}}
\index{discover_sysdep_data_t@{discover\_\-sysdep\_\-data\_\-t}!sysdep.h@{sysdep.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}typedef struct {\bf discover\_\-sysdep\_\-data} {\bf discover\_\-sysdep\_\-data\_\-t}}\label{sysdep_8h_a1}
Linked list node, used to return hardware-identification information discovered by the system-dependent interface \index{sysdep.h@{sysdep.h}!discover_sysdep_device_data_t@{discover\_\-sysdep\_\-device\_\-data\_\-t}}
\index{discover_sysdep_device_data_t@{discover\_\-sysdep\_\-device\_\-data\_\-t}!sysdep.h@{sysdep.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}typedef struct {\bf discover\_\-sysdep\_\-device\_\-data} {\bf discover\_\-sysdep\_\-device\_\-data\_\-t}}\label{sysdep_8h_a0}
Linked list node, used to return data specific to the sysdep/device in question, to be passed to the user under the \char`\"{}device\char`\"{} data path.
\subsection{Function Documentation}
\index{sysdep.h@{sysdep.h}!_discover_free_sysdep_data@{\_\-discover\_\-free\_\-sysdep\_\-data}}
\index{_discover_free_sysdep_data@{\_\-discover\_\-free\_\-sysdep\_\-data}!sysdep.h@{sysdep.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void \_\-discover\_\-free\_\-sysdep\_\-data ({\bf discover\_\-sysdep\_\-data\_\-t} $\ast$ {\em head})}\label{sysdep_8h_a4}
Release the memory that the sysdep data was holding.
Definition at line 92 of file sysdep.c.
References \_\-discover\_\-free\_\-sysdep\_\-device\_\-data(), discover\_\-sysdep\_\-data::busclass, discover\_\-sysdep\_\-data::data, discover\_\-sysdep\_\-data::model, discover\_\-sysdep\_\-data::next, and discover\_\-sysdep\_\-data::vendor.
Referenced by discover\_\-get\_\-devices().\index{sysdep.h@{sysdep.h}!_discover_free_sysdep_device_data@{\_\-discover\_\-free\_\-sysdep\_\-device\_\-data}}
\index{_discover_free_sysdep_device_data@{\_\-discover\_\-free\_\-sysdep\_\-device\_\-data}!sysdep.h@{sysdep.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void \_\-discover\_\-free\_\-sysdep\_\-device\_\-data ({\bf discover\_\-sysdep\_\-device\_\-data\_\-t} $\ast$ {\em head})}\label{sysdep_8h_a5}
Release memory being held by device-specific data.
Definition at line 117 of file sysdep.c.
References discover\_\-sysdep\_\-device\_\-data::next, discover\_\-sysdep\_\-device\_\-data::path, and discover\_\-sysdep\_\-device\_\-data::value.
Referenced by \_\-discover\_\-free\_\-sysdep\_\-data().\index{sysdep.h@{sysdep.h}!_discover_sysdep_data_new@{\_\-discover\_\-sysdep\_\-data\_\-new}}
\index{_discover_sysdep_data_new@{\_\-discover\_\-sysdep\_\-data\_\-new}!sysdep.h@{sysdep.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-sysdep\_\-data\_\-t}$\ast$ \_\-discover\_\-sysdep\_\-data\_\-new (void)}\label{sysdep_8h_a2}
Create a new instance of sysdep data.
Definition at line 66 of file sysdep.c.
References discover\_\-sysdep\_\-data::busclass, discover\_\-sysdep\_\-data::data, discover\_\-sysdep\_\-data::model, discover\_\-sysdep\_\-data::next, and discover\_\-sysdep\_\-data::vendor.\index{sysdep.h@{sysdep.h}!_discover_sysdep_device_data_new@{\_\-discover\_\-sysdep\_\-device\_\-data\_\-new}}
\index{_discover_sysdep_device_data_new@{\_\-discover\_\-sysdep\_\-device\_\-data\_\-new}!sysdep.h@{sysdep.h}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf discover\_\-sysdep\_\-device\_\-data\_\-t}$\ast$ \_\-discover\_\-sysdep\_\-device\_\-data\_\-new (void)}\label{sysdep_8h_a3}
Create a new instance of sysdep device data.
Definition at line 80 of file sysdep.c.
References discover\_\-sysdep\_\-device\_\-data::next, discover\_\-sysdep\_\-device\_\-data::path, and discover\_\-sysdep\_\-device\_\-data::value. discover-2.1.2/doc/api-reference/latex/annotated.tex 0000644 0023421 0023421 00000001034 10655642004 021066 0 ustar pere pere \section{discover Data Structures}
Here are the data structures with brief descriptions:\begin{CompactList}
\item\contentsline{section}{{\bf discover\_\-bus\_\-map} }{\pageref{structdiscover__bus__map}}{}
\item\contentsline{section}{{\bf discover\_\-error} }{\pageref{structdiscover__error}}{}
\item\contentsline{section}{{\bf discover\_\-sysdep\_\-data} }{\pageref{structdiscover__sysdep__data}}{}
\item\contentsline{section}{{\bf discover\_\-sysdep\_\-device\_\-data} }{\pageref{structdiscover__sysdep__device__data}}{}
\end{CompactList}
discover-2.1.2/doc/api-reference/latex/Helvetica.ttf 0000644 0023421 0023421 00000077770 10655642004 021036 0 ustar pere pere € pOS/2p2rý ü VcmapÍñ¡ T Jgasp glyfd92 ° b”headRwû eD 6hheaû‰ e| $hmtx˜¸# e ˆloca ,ˆ g( ŒkernÿÕÿE h´ Xmaxpk k nameËà? k, ‚post3; k° ýcvt {$1 l° ˆfpgmw&©õ r8 °prepsÂÖÀ wè ˆ š3 š3 Ñ f MONO @ ÓþQ3>²
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`a 0 ~ ÿÿ ÿÿÿãÿcÿc ÿÿ B´ä¸™@ ä
ä ä¼1 ™. +ö<ýplatformthat will need the information, such as
allas a value.
Filessection for details on the mechanism for generating these entries automatically.
sound cardis classified by &discover; as an audio device.
modems; analog phone-line modems are not included in this classification (see
modembelow).
video cardis classified by &discover; as a display device.
cable modemsare not
networkdevices.
burn(write to) optical discs.
printeris also classified by &discover; as a printer.
moviecapability are