This document last updated: 07/28/08 03:07pm

Print Release Notes

What's New

What's new in Splunk 3.2

Transaction search

Many data sources generate multiple, related log entries for a single observable event. For example, an order transaction generates log entries on multiple servers: on the Web front end, the application server, and the back-end database. Splunk now provides a way to reference these events as one unit - as a transaction. This enables various types of new and improved analysis. You can now see transactions as one unit on screen. No need for you to have to stitch individual events together manually. You can do statistical analysis and queries on entire transactions such as: What is the average transaction execution time? Did all transactions complete? These queries are now simple to write.

For more information, refer to Use transaction search in the User Guide.

Filesystem change monitoring

Splunk's filesystem change monitoring opens up vast new possibilities to capture one of the most important vectors in IT Compliance and IT Operations: change. Identify configuration changes in real time, monitor live IT data feeds, and specify alerting to pinpoint availability problems in your infrastructure like never before. Report on change to your compliance auditors as well, all without additional agents or complex software.

For more information, refer to How the file system change monitor works in the Administration Guide.

REST API

The Splunk Platform is built on Splunk's new REST API. Developers can integrate with and build applications for Splunk more quickly and easily than ever before with an API that supports Splunk SDKs for .NET, Python and other languages. Simple, easy to use API calls inside a programmatic REST structure with Atom syndication encourage rapid development and place the power of IT data inside your applications.

For more information, refer to Splunk's REST API in the Developer Guide.

Windows platform support

Splunk now supports installation on the majority of Windows operating systems currently deployed today with all of the great Splunk features offered on other platforms, including native support for the Windows event log. Windows administrators and those who have standardized on Microsoft technologies can now harness the power of Splunk!

To get started with Splunk on Windows, refer to the Windows installation in the Installation Guide.

Interactive event type learning

The power of event type learning is put into your hands. Based on a specific search result, you can tell Splunk to learn new event types and store them in the system with the appropriate tags.

For more information, refer to Event type discovery in the Administration Guide.

Interactive field extraction

You can now use Splunk Web to define new field extractions as soon as you see an event that needs them. Define your fields as you need them!

For more information, refer to Create extracted fields in the Administration Guide

Increased storage efficiency

Splunk 3.2 delivers significant increases in storage efficiency over previous releases. With standard syslog, Splunk offers 15% greater efficiency in its indexed datastore, making syslog data consume just 25% of raw data size. Save space and money while unlocking the power of your IT data!

Flexible roles

Flexible roles provide streamlined management of user permissions, personalization and content in large environments with hundreds of users and via integration with LDAP meet corporate standards for central management of users and permissions.

Administrators can define new roles that control data access and user capbilities in one location and then map them into role contexts in external authentication systems.

For more information, refer to Configure roles in the Administration Guide.

Auditing & signing

Auditing and signing make it easy to demonstrate the integrity of IT data for compliance purposes and to present IT data as legally admissible evidence. Splunk can automatically determine the integrity of any IT data and its own configuration through cryptographic signing and granular auditing of user and administrator activity.

For more information, refer to Audit event signing in the Administration Guide.

Transaction typing

Transaction typing lets you name specific patterns of events. You can express patterns of events by either defining sequence in which the individual events making up a transaction have to happen, or by using the transaction discoverer (transaction command) to discover transactions automatically. An example of a transaction could be: an attack detected by an intrusion detection system, followed by a specific event, recorded in the operating system log file on the targeted machine. Together, these events make up a "transaction". Once you define a transaction, you can then search it and do operations on it as if it were a single event.

For more information, refer to How transaction types work in the Administration Guide.

New search features

Splunk's new search features greatly improve the overall capabilities of Splunk:

Role-based search sharing

Extend the power of IT search within your team. Share your searches with different roles inside Splunk to deliver senior analyst troubleshooting knowledge into the hands of junior administrators. Reduce MTTR and empower your whole team to collaborate on new ways to pinpoint problems.

For more information, refer to Set up saved searches in the Administration Guide.

Live Tail

View live log data from multiple, distributed servers and applications from a central location. You don't need to log into multiple servers, know where the servers live, how to access them, or what log files to look at. Splunk's new Live Tail provides one interface to all the data.

For more information, refer to Use Live Tail in the User Guide.

Dynamic event rendering

Tell Splunk how to display events based on each event's properties. Event rendering lets you specify coloring and additional text labels for Splunk to show for specific events.

For more information, refer to Dynamic event rendering in the Administration Guide.

Universal field tagging

Define tags for any field in Splunk. In addition to letting you tag the core fields (source, sourcetype, eventtypes, and hosts), you can tag any other extracted or indexed fields.

For more information, refer to Tag fields in the User Guide.

Pluggable authentication API

Integrate Splunk with your existing authentication systems. By using the new pluggable authentication API, it's simple to integrate with a wide variety of external authentication solutions. This will enable integration with virtually any existing authentication method including PAM and kerberos. Leverage existing role contexts inside Splunk for both data access and administrative control and enhance the security of your Splunk deployment.

Event type templates

Event type templates provide the ability to specify fields within a given event pattern that Splunk will automatically use to generate new event types. For example, for Windows events, you can specify that Splunk use the event ID field to generate a unique event type for each event ID seen, without needing to specify a separate event type manually for each event ID.

For more information, refer to Event type templates in the Administration Guide.

Known Issues

Known Issues for release 3.2.2

This page contains known issues and workarounds for this release of Splunk.

General issues and considerations

This section contains general considerations, issues and workarounds for this release of Splunk.

Security issues

Splunk is currently working to resolve a recently discovered security issue affecting all users of Splunk Web on all versions of Splunk. This issue involves potential execution of unauthorized configuration changes. To exploit the vulnerability, a number of parameters have to be known to the adversary. Splunk will send a notification when a fix is available for this issue. For more information, contact support@splunk.com. (SPL-13318)

Windows-specific considerations and known issues

As a result of porting Splunk to the Windows platform, some functionality is not available or works differently due to platform differences or limitations:

Search issues, including deprecated commands

Distributed search issues and considerations

Splunk Web issues and considerations

Configuration considerations and issues

Splunk Toolbar considerations and issues

Workaround for SSL configuration for users of Firefox 3

Caution: The workaround described in this topic is not to be used in high-security environments, or any install that uses custom SSL certs. Custom SSL certificates are the only way to solve this issue in a security-conscious manner.

Background

Firefox 3 tightened its security defaults to deny any SSL certificates that are mismatched. By default, Splunk uses a self-signed SSL certificate with the following details:

Since SplunkCommonCA is not a trusted CA (like Verisign, Thawte, etc.) and 'SplunkCerverDefaultCert' does not equal 'localhost', this is enough to trigger the security exception.

By adding the Splunk certificate to your browser's exception list, you are asserting that you trust this certificate/hostname combination.

Symptoms

This applies to environments that satisfy all of the following prerequisites:

1. Browsing via Firefox 3
2. Accessing Splunk version 3.2+
3. splunkd is set in server.conf to have enableSplunkdSSL=true
4. Hitting the splunkd management port directly from the browser, i.e. https://localhost:8089/services

- OR -

1. Browsing via Firefox 3
2. Accessing Splunk version 3.0+
3. splunkweb is set in web.conf to have enableSplunkWebSSL=true
4. Hitting Splunk Web from the browser, for example: https://localhost:8000

When accessing the splunkd REST endpoints or SSL-enabled Splunk Web via Firefox 3, the browser returns with an 'invalid security exception' message. There are 2 manifestations of this error message:

Message A:

http://www.splunk.com/assets/doc-images/SSLConfigWorkaround/Picture9.png

Message B:

http://www.splunk.com/assets/doc-images/SSLConfigWorkaround/Picture8.png

Workaround

Caution: This workaround is not to be used in high-security environments, or any install that uses custom SSL certs. Custom SSL certificates are the only way to solve this issue in a security-conscious manner.

If your error message is like Message B, then you can skip to step 2.

1. Open the Certificate Manager

2. Add your splunkd certificate to the certificate exceptions

Changelogs by Version

3.2

This page contains a list of resolved issues from the last release of Splunk.

Resolved issues from 3.1.5

3.2.1

This page contains a list of issues resolved in this release of Splunk.

Resolved issues from 3.2

3.2.2

This page contains a list of issues resolved in this release of Splunk.

Resolved issues from 3.2.1

Credits

Credits

Splunk contains some libraries that were written by others, and are being redistributed as part of Splunk under their respective open source licenses. We wish to thank the contributors to these projects.

Licenses can be viewed by selecting a library name on the left.

APSW

- Another Python SQLite Wrapper

apsw-3.2.2-r1 7th July 2005

APSW provides an SQLite 3 wrapper that provides the thinnest layer over SQLite 3 possible. Everything you can do from the C API to SQLite 3, you can do from Python. Although APSW looks vaguely similar to the DBAPI, it is not compliant with that API and instead works the way SQLite 3 does. (pysqlite is DBAPI compliant - differences between apsw and pysqlite 2).
Table of contents

* Download
* Example
* Building
* API Reference
o Module methods
o Connection class
o Cursor class
* Exceptions
* Types
* Unicode
* Multi-threading and re-entrancy
* Tracing
o Execution Tracer
o Row Tracer
* Execution model

* DBAPI notes
o Module Interface
o Connection Objects
o Cursor Objects
o Type objects
o Optional DB API Extensions
* pysqlite differences
* Copyright and License
* Version History
o 3.2.2-r1
o 3.2.1-r1
o 3.1.3-r1
o 3.0.8-r3
o 3.0.8-r2
o 3.0.8-r1

Download

You can download APSW from SourceForge. Debian users can grab the package python-apsw
Example

This is an example of how to use apsw, and also demonstrates all the features.

import apsw

3"):˙773˙ pass˙1067˙˙1068˙Row: (4, 'five')˙774˙ Row: (7, 'eight')˙1069˙˙1070˙###˙775˙ ### executemany˙776˙ ###˙1071˙˙1072˙# (This will work correctly with multiple statements, as well as statements that˙777˙ # return data. The second argument can be anything that is iterable.)˙778˙ cursor.executemany("insert into foo (x) values(?)", ( [1], [2], [3] ) )˙1073˙˙1074˙# You can also use it for statements that return data˙779˙ for row in cursor.executemany("select * from foo where x=?", ( [1], [2], [3] ) ):˙780˙ print row˙1075˙˙1076˙###˙781˙ ### defining your own functions˙782˙ ###˙1077˙˙1078˙def ilove7(*args):˙783˙ "a scalar function"˙784˙ print "ilove7 got",args,"but I love 7"˙785˙ return 7˙1079˙˙1080˙connection.createscalarfunction("seven", ilove7)˙1081˙˙1082˙for row in cursor.execute("select seven(x,y) from foo"):˙786˙ print row˙1083˙˙1084˙###˙787˙ ### aggregate functions are more complex˙788˙ ###˙1085˙˙1086˙# here we return the longest item when represented as a string˙1087˙˙1088˙def longeststep(context, *args):˙789˙ "are any of the arguments longer than our current candidate"˙790˙ for arg in args:˙791˙ if len( str(arg) ) > len( context['longest'] ):˙792˙ context['longest']=str(arg)˙1089˙˙1090˙def longestfinal(context):˙793˙ "return the winner"˙794˙ return context['longest']˙1091˙˙1092˙def longestfactory():˙795˙ """called for a new query. The first item returned can be˙796˙ anything and is passed as the context to the step˙797˙ and final methods. We use a dict."""˙798˙ return ( { 'longest': '' }, longeststep, longestfinal)˙1093˙˙1094˙connection.createaggregatefunction("longest", longestfactory)˙1095˙˙1096˙for row in cursor.execute("select longest(x) from foo"):˙799˙ print row˙1097˙˙1098˙###˙800˙ ### Defining collations. ˙801˙ ###˙1099˙˙1100˙# The default sorting mechanisms don't understand numbers at the end of strings˙802˙ # so here we define a collation that does˙1101˙˙1102˙cursor.execute("create table s(str)")˙803˙ cursor.executemany("insert into s values(?)",˙804˙ ( ["file1"], ["file7"], ["file17"], ["file20"], ["file3"] ) )˙1103˙˙1104˙for row in cursor.execute("select * from s order by str"):˙805˙ print row˙1105˙˙1106˙('file1',)˙806˙ ('file17',)˙807˙ ('file20',)˙808˙ ('file3',)˙809˙ ('file7',)˙1107˙˙1108˙def strnumcollate(s1, s2):˙810˙ # return -1 if s1s2 else 0˙1109˙˙1110˙# split values into two parts - the head and the numeric tail˙811˙ values=[s1, s2]˙812˙ for vn,v in enumerate(values):˙813˙ for i in range(len(v), 0, -1):˙814˙ if v[i-1] not in "01234567890":˙815˙ break˙816˙ try:˙817˙ v=( v[:i], int(v[i:]) )˙818˙ except ValueError:˙819˙ v=( v[:i], None )˙820˙ values[vn]=v˙821˙ # compare˙822˙ if values[0]values[1]:˙825˙ return 1˙826˙ return 0˙1111˙˙1112˙connection.createcollation("strnum", strnumcollate)˙1113˙˙1114˙for row in cursor.execute("select * from s order by str collate strnum"):˙827˙ print row˙1115˙˙1116˙('file1',)˙828˙ ('file3',)˙829˙ ('file7',)˙830˙ ('file17',)˙831˙ ('file20',)˙1117˙˙1118˙###˙832˙ ### Authorizer (eg if you want to control what user supplied SQL can do)˙833˙ ###˙1119˙˙1120˙def authorizer(operation, paramone, paramtwo, databasename, triggerorview):˙834˙ """Called when each operation is prepared. We can return SQLITE_OK, SQLITE_DENY or˙835˙ SQLITE_IGNORE"""˙836˙ # find the operation name˙837˙ ign=["SQLITE_OK", "SQLITE_DENY", "SQLITE_IGNORE"] # not operation names but have same values˙838˙ print "AUTHORIZER:",˙839˙ for i in dir(apsw):˙840˙ if getattr(apsw,i)==operation:˙841˙ print i,˙842˙ break˙843˙ print paramone, paramtwo, databasename, triggerorview˙844˙ if operation==apsw.SQLITE_CREATE_TABLE and paramone.startswith("private"):˙845˙ return apsw.SQLITE_DENY # not allowed to create tables whose names start with private˙1121˙˙1122˙return apsw.SQLITE_OK # always allow˙1123˙˙1124˙connection.setauthorizer(authorizer)˙1125˙˙1126˙###˙846˙ ### progress handler (SQLite 3 experimental feature)˙847˙ ###˙1127˙˙1128˙# something to give us large numbers of random numbers˙848˙ import random˙849˙ def randomintegers(howmany):˙850˙ for i in xrange(howmany):˙851˙ yield (random.randint(0,9999999999),)˙1129˙˙1130˙# create a table with 10,000 random numbers˙852˙ cursor.execute("begin ; create table bigone(x)")˙853˙ cursor.executemany("insert into bigone values(?)", randomintegers(10000))˙854˙ cursor.execute("commit")˙1131˙˙1132˙# display an ascii spinner˙855˙ _phcount=0˙856˙ _phspinner=";">/-\\"
def progresshandler():
global _phcount
sys.stdout.write(_phspinner[_phcount%len(_phspinner)]+chr(8)) # chr(8) is backspace
sys.stdout.flush()
_phcount+=1
time.sleep(0.1) # deliberate delay so we can see the spinner (SQLite is too fast otherwise!)
return 0 # returning non-zero aborts

# register progresshandler every 20 instructions
connection.setprogresshandler(progresshandler, 20)

# see it in action
print "spinny thing -> ",
for i in cursor.execute("select max(x) from bigone"):
print # newline
print i # and the maximum number

#
### commit hook (SQLite3 experimental feature)
###

def mycommithook():
print "in commit hook"
hour=time.localtime()[3]
if hour<8 or hour>17:
print "no commits our of hours"
return 1 # abort commits outside of 8am through 6pm
print "commits okay at this time"
return 0 # let commit go ahead

connection.setcommithook(mycommithook)
cursor.execute("begin; create table example(x,y,z); insert into example values (3,4,5) ; commit")

Building

The simple way is:

python setup.py install

On Windows the above command uses Visual C++. You can use MinGW with the command below. (If MinGW complains about missing Python functions starting with _imp__Py_ then run mingwsetup.bat which will ensure your Python distribution is initialized for MinGW compilation).

python setup.py build --compile=mingw32 install

By default whatever SQLite 3 you already have on your system is used. If you place a copy of the headers and library in a sqlite3 subdirectory then that will be used instead. Here is a quick and easy way of doing everything on Linux/Mac or Windows with MinGW, including the SQLite library statically into the extension (ie no external DLLs/shared libraries will needed at runtime).

Download the SQLite 3 code. Use the version that has already been preprocessed. (It will compile fine on Windows, Linux and Mac). In the example I assume you got sqlite-source-3.2.2.zip

$ mkdir sqlite3
$ cd sqlite3
$ unzip sqlite-source-3.2.2.zip
$ rm tclsqlite.c # Linux/Mac
$ del tclsqlite.c # Windows
$ gcc -DTHREADSAFE -O3 -c *.c # Adding -DNDEBUG will turn off assertion checking and
# improve performance (about 25%) at the expense of safety
$ ar r libsqlite3.a *.o
$ ranlib libsqlite3.a
$ cd ..
$ python setup.py install # Linux/Mac
$ python setup.py build --compile=mingw32 install # Windows

The extension just turns into a single file apsw.so (Linux/Mac) or apsw.pyd (Windows). You don't need to install it and can drop it into any directory that is more convenient for you and that your code can reach. To just do the build and not install, leave out install from the lines above and add build if it isn't already there.
API Reference

Everything you can do from the SQLite 3 C API you can do from Python. The documentation below notes which C API functions are called where you can get further details on what happens. The only C function not implemented is sqlite3_collation_needed. (You can still add collations, you just can't use this function to find out about them on-demand.) Additionally sqlite3_trace is not wrapped but instead tracers are provided that have more functionality.

Some functions are marked experimental in the SQLite API. These have also been made available, but as the SQLite documentation notes these functions may change form or disappear in future versions of SQLite. You can exclude these functions by commenting out the relevant line in the setup.py when building aspw.

Various methods create functions, collations and set various hooks and handlers. To remove the relevant function/collation/hook/handler, pass in None as the callable method.
Module methods

sqlitelibversion()

Returns the version of the SQLite library as a string. This function calls sqlite3_libversion.

Connection class

The connection class wraps a sqlite3 pointer.

Connection(filename)

Opens an SQLite database named filename. (This calls sqlite3_open behind the scenes and sqlite3_close when no longer in use.)
cursor()

Creates a new cursor object on this database.
changes()

This function returns the number of database rows that were changed (or inserted or deleted) by the most recently completed INSERT, UPDATE, or DELETE statement. (This calls sqlite3_changes. Read that link for some additional notes.)
totalchanges()

This function returns the total number of database rows that have be modified, inserted, or deleted since the database connection was opened. (This calls sqlite3_total_changes. Read that link for some additional notes.)
last_insert_rowid()

Returns the integer key of the most recent insert in the database. (This calls sqlite3_last_insert_rowid.)
complete(statement)

Calls sqlite3_complete which tells you if the input string comprises one or more complete SQL statements.
setbusytimeout(milliseconds)

Sets the busy timeout. (This calls sqlite3_busy_timeout).
setbusyhandler(callable)

Sets the busy handler to callable. callable will be called with one integer argument which is the number of prior calls to the busy callback for the same lock. If the busy callback returns something that evaluates to False, then SQLite returns SQLITE_BUSY to the calling code.. If the callback returns something that evaluates to True, then SQLite tries to open the table again and the cycle repeats. (This calls sqlite3_busy_handler).
interrupt()

Causes any pending operations on the database to abort at the earliest opportunity. (This calls sqlite3_interrupt).
createscalarfunction(name, callable, numargs=-1)

Registers a scalar function. The callable will be called. You can specify how many arguments your function takes as the numargs parameter or supply -1 to take any amount. (This calls sqlite3_create_function).
createaggregatefunction(name, factorycallback, numargs=-1)

Registers an aggregate function. (This calls sqlite3_create_function.) You can specify how many arguments your function takes as the numargs parameter or supply -1 to take any amount. When the function is called by an SQL query, the factorycallback is called without any arguments. The factorycallback needs to return a tuple consisting of three 3 items.

*

a context object (of any type)
*

a step function which is called for each row. The context object will be the first parameter, and the remaining parameters will be from the SQL statement. The return value is ignored - you supply it in final.
*

a final function which is called at the end. The only parameter will be the context object. The value returned is set as the return for the function. It must be a valid SQLite type. Note that the final function is always called even if an exception was raised by the step function. This allows you to ensure any resources are cleaned up.

createcollation(name, callable)

Creates a collation with the specified name and callable. The callable will be passed two string arguments. It should return -1 if the first is less than the second, 0 if they are equal and 1 and if the first is greater than the second. Note that this controls sorting (ORDER BY in SQL) so your comparisons don't affect other SQL operations. Read more about SQLite's handling of collations. (This calls sqlite3_create_collation.) If there is an error in your Python code then 0 (ie items are equal) is returned.
setauthorizer(callable)

The callable is invoked while SQL statements are being prepared. The intent is to allow applications to safely execute user entered SQL. The callable is called with 5 parameters:

*

an integer representing the operation (the constants are available on the apsw module - eg apsw.SQLITE_CREATE_TABLE.
*

A string (or None) dependent on the operation
*

Another string (or None) dependent on the operation
*

The string name of the database (or None)
*

Name of the innermost trigger or view doing the access (or None)

You should return apsw.SQLITE_OK to allow the operation or apsw.SQLITE_DENY or apsw.SQLITE_IGNORE as applicable. (SQLITE_DENY is returned if there is an error in your Python code).

This calls sqlite3_set_authorizer which contains more detailed documentation.
setcommithook(callable) (SQLite 3 experimental feature)

Sets a callable which is invoked just before a commit. It should return zero for the commit to go ahead and non-zero for it to be turned into a rollback. In the case of an exception in your callable, a non-zero (ie rollback) value is returned. (This calls sqlite3_commit_hook.)
setprogresshandler(callable, nsteps=20) (SQLite 3 experimental feature)

Sets a callable which is invoked every nsteps SQLite inststructions. The callable should return a non-zero value to abort or zero to continue. (If there is an error in your Python callable then non-zero will be returned). (This calls sqlite3_progress_handler which has more detailed documentation).

Cursor class

The Cursor class creates and executes SQLite prepared statements.

Cursor()

You cannot create cursors directly. The are created by calling Connection.cursor().
getconnection()

Returns the Connection object to which this cursor belongs.
execute(statements, bindings=())

Executes the statements using the supplied bindings. The bindings can be supplied as a tuple or as a dict. Execution returns when the first row is available or all statements have completed. The cursor object is returned which you can use as an iterator. (See execution model for more details. This function wraps sqlite3_prepare and sqlite3_step.)
executemany(statements, sequenceofbindings=())

Repeatedly executes statements using each element of sequenceofbindings for the bindings each time. Execution returns when the first row is available or all statements have completed. The cursor object is returned which you can use as an iterator. (See execution model for more details. This function runs in a loop on each member of sequenceofbindings and wraps sqlite3_prepare and sqlite3_step .)
next()

The Cursor object is an iterator, and so you can use it in a for loop or similar situations. You can also explicitly call the next() method. This method returns a tuple of the contents of a returned row or raises StopIteration after all returned rows have been seen.
getdescription()

Returns a list describing each column in the current result set. Each item is a tuple of (column name, declared column type). You should only call this function while data is being returned such as when next() returns a row. This function calls sqlite3_column_name and sqlite3_column_decltype.
setexectrace(callable)
setrowtrace(callable)
getexectrace()
getrowtrace()

Sets or gets the tracers.

Exceptions

All exception types have apsw.Error as a parent. The following exceptions can happen:

ThreadingViolationError

You have used an object allocated in one thread in a different thread. All objects (Connection, Cursor) must be used in the same thread they were allocated in.
IncompleteExecutionError

You have tried to start a new SQL execute call before executing all the previous ones. See the execution model for more details.
BindingsError

There is an incorrect number of bindings when using tuples. Or you supplied a dictionary of bindings and not all bindings were named in the SQL statement. For example select * from foo where x=:name and y=?. You should either use colon name style or question mark style in a query but not both.
ExecutionCompleteError

A statement is complete but you try to run it more anyway!
ExecTraceAbort

The execution tracer returned False so execution was aborted.

The following Exception classes correspond to SQLite error codes.

General Errors
SQLITE_ERROR SQLError
SQLITE_MISMATCH MismatchError

Internal Errors
SQLITE_INTERNAL InternalError
SQLITE_PROTOCOL ProtocolError
SQLITE_MISUSE MisuseError
SQLITE_RANGE RangeError

Permissions etc
SQLITE_PERM PermissionsError
SQLITE_READONLY ReadOnlyError
SQLITE_CANTOPEN CantOpenError
SQLITE_AUTH AuthError

Abort/Busy/etc
SQLITE_ABORT AbortError
SQLITE_BUSY BusyError
SQLITE_LOCKED LockedError
SQLITE_INTERRUPT InterruptError
SQLITE_SCHEMA SchemaChangeError
SQLITE_CONSTRAINT ConstraintError

Memory/Disk/etc
SQLITE_NOMEM NoMemError
SQLITE_IOERR IOError
SQLITE_CORRUPT CorruptError
SQLITE_FULL FullError
SQLITE_TOOBIG TooBigError
SQLITE_NOLFS NoLFSError
SQLITE_EMPTY EmptyError
SQLITE_FORMAT FormatError
SQLITE_NOTADB NotADBError

Types

Read about SQLite 3 types. ASPW always maintains the correct type for values, and never converts them to something else. Note however that SQLite may convert types based on column affinity as described in that link. ASPW requires that all values supplied are one of the corresponding Python/SQLite types (or a subclass).

*

None in Python is NULL in SQLite
*

Python int or long is INTEGER in SQLite. The value represented must fit within a 64 bit signed quantity (long long at the C level) or an exception is generated. (Don't worry - aspw only uses the long type when values are too large to fit in ints).
*

Python's float type is used for REAL in SQLite. (At the C level they are both 8 byte quantities and there is no loss of precision).
*

Python's string or unicode is used for TEXT in SQLite. (ASPW automatically uses Python's string type for ASCII text and Unicode for other text.)
*

Python's buffer class is used for BLOB in SQLite.

Unicode

All SQLite strings are Unicode. The actual binary representations can be UTF8, or UTF16 in either byte order. ASPW uses the UTF8 interface to SQLite which results in the binary string representation in your database defaulting to UTF8 as well. All this is totally transparent to your Python code.

Everywhere strings are used (eg as database values, SQL statements, bindings names, user defined functions) you can use Unicode strings. You can also use the bare Python string class, and ASPW will automatically call the unicode converter if any non-ascii characters are present.

When reading values from SQLite, ASPW uses the Python string class for any pure ASCII text, else it uses the Python unicode class.
Multi-threading and re-entrancy

ASPW lets you use SQLite in multi-threaded programs and will let other threads execute while SQLite is working. (Technically the GIL is released when sqlite3_step or sqlite3_open are running. The GIL is re-acquired while user defined functions, collations and the various hooks/handlers run.)

Note that you cannot use the same Connection object in mulitple threads. You must allocate a new Connection object per thread. (This is a requirement of SQLite). A cursor object can only be used in the same thread as it was allocated. (Also an SQLite requirement). Fortunately ASPW will check this for you and throw a ThreadingViolationError if you try to use objects in the wrong thread. Note that your destructors also need to run in the creation thread.

If you have multiple threads and/or multiple programs accessing the same database then there may be contention for the file. SQLite will return SQLITE_BUSY which will be raised as BusyError. You can call the Cursor.next() method to resume execution. Alternately you can call Connection.setbusytimeout to set how long SQLite will retry for or Connection.setbusyhandler to install your own busy handler. SQLite's locking and concurrency is described here

A cursor object can only be executing one query at a time. You cannot issue a new query from inside a trace function or from a user defined function or collation since these are called while executing a query. You can however make new cursors and use those without issue. You may want to remember the Connection object when you set your trace or user defined functions.
Tracing

You can install tracers on a cursor as an easy way of seeing exactly what gets executed and what is returned. The tracers can also abort execution and cause different values to be returned. This is very useful for diagnostics and testing without having to modify your main code.

Note: You cannot issue new execute statements against the cursor your tracer was called from. If you would like to make more queries in the tracer then do them from a new cursor object.
Execution Tracer

The execution tracer is called after an SQL statement has been prepared. (ie syntax errors will have caused an exception during preparation so you won't see them with a tracer). It is called with two arguments. The first is a string which is the SQL statement about to be executed, and the second is the bindings used for that statement (and can be None). If the return value evaluates to False/None then execution is aborted with an ExecTraceAbort exception. See the example above.
Row Tracer

The row tracer is called before each row is returned. The arguments are the items about to be returned. Whatever you return from the tracer is what is actually returned. If you return None then the whole row is skipped. See the example above.
Execution model

This section only matters if you give multiple SQL statements in one go to cursor.execute(). (Statements are seperated by semi-colons.)

SQLite does execution in two steps. First a statement is prepared, which verifies the syntax, tables and fields and converts the statement into an internal representation. The prepared statement is then run. Execution stops when a row is available, there is an error or the statement is complete.

The cursor.execute() method automatically does the preparing and starts execution. If none of the statements return rows then execution will go to the end. If a row is returned then you need to call cursor.next() to get the row values. Execution will resume as necessary to satisfy next() calls.

However this means that if you don't read the rows returned then the rest of your statements won't be executed. APSW will detect unexecuted previous statements and generate an exception. For example:

>>> cursor.execute("select * from foo ; create table bar(x,y,z)")
>>> cursor.execute("create table bam(x,y,z)")
Traceback (most recent call last):
File "<stdin>", line 1, in ?
apsw.IncompleteExecutionError: Error: there are still remaining sql statements to execute

Because I didn't read the results of select * from foo then the following create table command didn't have a chance to get executed. On the next execute that condition is detected and an exception raised.
DBAPI notes

DBAPI is defined in PEP 249. This section describes how APSW complies or differs from it.
Module Interface

There is no connect method. Use the Connection constructor instead, which only takes one parameter - the name of the database.

The Connection object and any cursors must all be used in the same thread they were allocated from. You cannot use them in different threads even if you protect them with mutexes.

Three different paramstyles are supported. You can use qmark ('... WHERE name=?'), numeric ('... WHERE name=?4') and named ('... WHERE name=:name'). Note that SQLite numbers parameters from one not zero.

The DBAPI exceptions are not used.
Connection Objects

There is no close method

There are no commit or rollback methods. You should use cursor.execute("COMMIT") etc. The SQLite documentation has more details.

Several methods that are defined in DBAPI to be on the cursor are instead on the Connection object, since this is where SQLite actually stores the information. Doing operations in any other cursor attached to the same Connection object does update their values, and this makes you aware of that.
Cursor Objects

Use getdescription() instead of description. This information is only obtained on request.

There is no rowcount.

callproc is not implemented as SQLite doesn't support stored procedures.

There is no close method.

execute returns the Cursor object and you can use it as an iterator to get the results (if any).

executemany returns the Cursor object and you can use it as an iterator to get the results (if any).

fetchone is not available. Use the cursor as an iterator, or call next() which raises StopIteration when there are no more results.

fetchmany is not available. Call next() for however many results you want.

fetchall is not available. Call next() or use a list comprehension such as [row for row in cursor.execute("....")].

nextset is not applicable or implemented.

arraysize is not available as fetchmany isn't.

Neither setinputsizes or setoutputsize are applicable or implemented.
Type objects

None of the date or time methods are available since SQLite 3 does not have a native date or time type.

Use the standard Python buffer class for BLOBs.
Optional DB API Extensions

rownumber is not available.

Exception classes are not available as attributes of Connection.

Use Cursor.getconnection() to get the associated Connection object.

scroll and messages are not available.

The Cursor object supports the iterator protocol and this is the only way of getting information back.

To get the last inserted row id, call Connection.last_insert_rowid(). That stores the id from the last insert on any Cursor associated with the the Connection. You can also add select last_insert_rowid() to the end of your execute statements.

There is no errorhandler attribute.
pysqlite differences

pysqlite already provides a DBAPI compliant wrapper over SQLite 2 and 3. APSW only wraps SQLite 3 has the following enhancements/differences over pysqlite 3:

*

*Nothing* happens behind your back (such as pysqlite trying to manage transactions for you)
*

Blobs are supported - the standard Python buffer class is used. (pysqlite 2 appears to support Blobs but I can't figure out how).
*

SQLite's Manifest typing is used, which limits values to being supplied as integer (32/64 bit), string (utf8/unicode), double, null/None and BLOB. (An exception happens if you don't supply values in one of the supported types.) APSW doesn't do any type conversion or co-ercion. Note that SQLite will under some circumstances.
*

Strings are handled correctly (pysqlite has some issues with Unicode strings).
*

apsw ensures that precision is maintained for integers. This means that 64 bit integers don't get arbitrarily truncated to 32 bits.
*

A threading safety check is used - an exception happens if an sqlite object is used in a thread outside of the one it was allocated in. (That is a requirement of the SQLite API which this enforces for you).
*

While SQLite is executing the Python Global Interpretter Lock is released so other threads can also run.
*

SQLITE_BUSY is handled well. Although it is returned as an exception, you can call cursor.next() to continue from where the execution left off.
*

You can use semi-colons at the end of commands and you can have multiple commands in the execute string
*

The cursor object is an iterator and returns itself from execute.
*

No information is fetched that wasn't requested (eg there is no 'description' field that is filled in for every row whether requested or not. You can call Cursor.getdescription() if you need the information.)
*

You can have bindings supplied as a sequence type (tuple/list etc) for replacing ? in sql commands). The number of binding items supplied is checked and an exception raised if you supply too many or too few. (pysqlite doesn't check).
*

You can have bindings supplied as a dictionary type.
*

cursor.executemany() also works with statements that return data such as selects, and you can have multiple statements.
*

You can set the busy timeout by calling Connection.setbusytimeout with the amount of time to wait in milliseconds.
*

You can define your own SQL functions in Python.
*

You can define your own collations in Python.
*

You can implement tracers, authorizers and various hooks in Python.

Copyright and License

Copyright (C) 2004-2005 Roger Binns rogerb@rogerbinns.com

This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software.

Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions:

1.

The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2.

Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3.

This notice may not be removed or altered from any source distribution.

Version History
3.2.2-r1

You can use this release against any release of SQLite 3.

SQLite 3.2.2 API removed sqlite3_global_recover. That function was not wrapped in APSW. Note that SQLite 3.2.2 contains a bug fix that applies when you use 64 bit integer primary keys (32 bit ints are fine).
3.2.1-r1

You can use this release against any release of SQLite 3.

* There are no changes in APSW except to correct an error in the example code (collations are registered against the connection not the cursor)

SQLite 3.2.1 had one addition in the stable C API, which was a new function named sqlite3_global_recover. That function is not applicable for wrapping in APSW.
3.1.3-r1

You can use this release against any release of SQLite 3.

* The text string returned by apsw.Error used to say "apsw.APSWException" and has been changed to "apsw.Error". This is purely cosmetic and helps make clear what the class is. (The old string was what the original class name was in an earlier version of the code.)
* Added SQLITE_ALTER_TABLE and SQLITE_REINDEX constants for the authorizer function. (These constants were introduced in SQLite 3.1.3).
* Changed various C++-isms into standard C (eg // comments and the placing of some CHECK_THREAD macro calls)
* Added module level function apswversion which returns the version of APSW.

SQLite 3.1.3 had no changes in the stable C API other than what is mentioned above. There were some new experimental functions added which are not currently documented on the SQLite website, which are not wrapped by APSW. Please contact me if you believe they will remain in SQLite and you would like them wrapped:

* sqlite3_sleep An alternative function which sleeps for a specified number of milliseconds can be provided. By default SQLite just uses the standard operating system call.
* sqlite3_expired This function is internal to statement execution. It would apply to the implementation of Cursor.executemany and could in theory provide a marginal improvement in performance.
* A global variable sqlite3_temp_directory can be used before any databases are opened to set where temporary files are created. By default SQLite just uses the standard operating system mechanisms.

3.0.8-r3

There are no functional changes. The only changes were to correct some variable names in the example code (they were cut and pasted from the test code which used different names) and to make the source zip file extract its contents into a sub-directory which is the more typical way of packaging that sort of thing.
3.0.8-r2

All remaining functionality in the C API for SQLite 3.0.8 is now available.

Finished this documentation.
3.0.8-r1

Initial release
Last modified: Thu Jul 07 21:47:50 Pacific Standard Time 2005

boost

Boost Software License - Version 1.0 - August 17th, 2003

Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:

The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.

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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.

elementree

$Id: README 2326 2005-03-17 07:45:21Z fredrik $

=======================
The elementtree library
=======================

This kit contains the ElementTree library, a light-weight toolkit for
XML processing in Python.

For more information on this library, see:

docs/index.html
http://effbot.org/zone/element.htm

The modules are designed to work with Python 2.1 and newer. The core
ElementTree module and the SimpleXMLTreeBuilder class also works under
1.5.2 and 2.0.

Enjoy /F

fredrik@pythonware.com
http://www.pythonware.com


The ElementTree Library is

Copyright (c) 1999-2005 by Secret Labs AB
Copyright (c) 1999-2005 by Fredrik Lundh

By obtaining, using, and/or copying this software and/or its
associated documentation, you agree that you have read, understood,
and will comply with the following terms and conditions:

Permission to use, copy, modify, and distribute this software and its
associated documentation for any purpose and without fee is hereby
granted, provided that the above copyright notice appears in all
copies, and that both that copyright notice and this permission notice
appear in supporting documentation, and that the name of Secret Labs
AB or the author not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission.

SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS. IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR BE LIABLE FOR
ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

release info

This is release 1.2.6 of the ElementTree library.

For a list of changes in this release, see the CHANGES document.

The latest version of this library can be downloaded from:

http://effbot.org/downloads

Comments, bug reports, and patches are welcome. Send them to
fredrik@pythonware.com.

Note that this is free software, with limited support. If you need
commercial support on this module, contact fredrik@pythonware.com.


contents

README This file

CHANGES List of changes in this release.

elementtree/

ElementTree.py Element tree implementation. For a minimal
install, this file is all you need.

ElementPath.py Element path support module. Adds limited
XPath support to find/findtext/findall.

ElementInclude.py Element include support module. Adds limited
XInclude support.

HTMLTreeBuilder.py Element tree builder for HTML. This only
works for mostly well-formed HTML; if you
need something that can parse arbitrary
HTML at least as good as your browser, use
TidyHTMLTreeBuilder or TidyTools (see below).

XMLTreeBuilder.py Element tree builder for XML (compatibility;
new code should use the tree builder in the
ElementTree module).

TidyHTMLTreeBuilder.py Element tree builder for HTML, based on the
tidylib library. This tree builder requires
the _elementtidy extension module (available
from http://effbot.org/downloads).

SimpleXMLTreeBuilder.py Old element tree builder for XML, based on
xmllib, for Python versions where "expat" is
not available. Due to bugs in xmllib, the
namespace support is not reliable (run the
module as a script to find out exactly how
unreliable it is on your Python version...)

SgmlopXMLTreeBuilder.py Simple element tree builder based on the
SGMLOP parser. Note: The current version
does not support namespaces.

SimpleXMLWriter.py Simple XML writer

TidyTools.py Build element trees from HTML, using the
external 'tidy' utility.

setup.py Build/installation script

docs/index.html API reference pages.
docs/*

demo*.py Sample scripts
samples/* Sample data

selftest.py Selftest (requires Python 2.1 or later)
tidytest.py Selftest for TidyHTMLTreeBuilder components.

benchmark.py Benchmark script (usage: benchmark.py file)

expat

Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
and Clark Cooper
Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006 Expat maintainers.

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 AUTHORS OR COPYRIGHT HOLDERS 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.

fpconst

Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

1. Definitions.

"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.

"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.

"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.

"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.

"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.

"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.

"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).

"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.

"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."

"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.

2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.

3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.

4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:

(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and

(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and

(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and

(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.

You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.

5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.

6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.

7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.

8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.

9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.

END OF TERMS AND CONDITIONS

APPENDIX: How to apply the Apache License to your work.

To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.

Copyright [yyyy] [name of copyright owner]

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

+gSOAP

gSOAP Public License
Version 1.3a
The gSOAP public license is derived from the Mozilla Public License (MPL1.1). The sections that were deleted from the original MPL1.1 text are 1.0.1, 2.1.(c),(d), 2.2.(c),(d), 8.2.(b), 10, and 11. Section 3.8 was added. The modified sections are 2.1.(b), 2.2.(b), 3.2 (simplified), 3.5 (deleted the last sentence), and 3.6 (simplified).
1 DEFINITIONS.

sep 0mm
1.0.1.
1.1. "Contributor"
means each entity that creates or contributes to the creation of Modifications.
1.2. "Contributor Version"
means the combination of the Original Code, prior Modifications used by a Contributor, and the Modifications made by that particular Contributor.
1.3. "Covered Code"
means the Original Code, or Modifications or the combination of the Original Code, and Modifications, in each case including portions thereof.
1.4. "Electronic Distribution Mechanism"
means a mechanism generally accepted in the software development community for the electronic transfer of data.
1.5. "Executable"
means Covered Code in any form other than Source Code.
1.6. "Initial Developer"
means the individual or entity identified as the Initial Developer in the Source Code notice required by Exhibit A.
1.7. "Larger Work"
means a work which combines Covered Code or portions thereof with code not governed by the terms of this License.
1.8. "License"
means this document.
1.8.1. "Licensable"
means having the right to grant, to the maximum extent possible, whether at the time of the initial grant or subsequently acquired, any and all of the rights conveyed herein.
1.9. "Modifications"
means any addition to or deletion from the substance or structure of either the Original Code or any previous Modifications. When Covered Code is released as a series of files, a Modification is:

sep 0mm
A.
Any addition to or deletion from the contents of a file containing Original Code or previous Modifications.
B.
Any new file that contains any part of the Original Code, or previous Modifications.

1.10. "Original Code"
means Source Code of computer software code which is described in the Source Code notice required by Exhibit A as Original Code, and which, at the time of its release under this License is not already Covered Code governed by this License.
1.10.1. "Patent Claims"
means any patent claim(s), now owned or hereafter acquired, including without limitation, method, process, and apparatus claims, in any patent Licensable by grantor.
1.11. "Source Code"
means the preferred form of the Covered Code for making modifications to it, including all modules it contains, plus any associated interface definition files, scripts used to control compilation and installation of an Executable, or source code differential comparisons against either the Original Code or another well known, available Covered Code of the Contributor's choice. The Source Code can be in a compressed or archival form, provided the appropriate decompression or de-archiving software is widely available for no charge.
1.12. "You" (or "Your")
means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License or a future version of this License issued under Section 6.1. For legal entities, "You" includes any entity which controls, is controlled by, or is under common control with You. For purposes of this definition, "control" means (a) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (b) ownership of more than fifty percent (50%) of the outstanding shares or beneficial ownership of such entity.

2 SOURCE CODE LICENSE.

sep 0mm
2.1. The Initial Developer Grant.

The Initial Developer hereby grants You a world-wide, royalty-free, non-exclusive license, subject to third party intellectual property claims:

sep 0mm
(a)
under intellectual property rights (other than patent or trademark) Licensable by Initial Developer to use, reproduce, modify, display, perform, sublicense and distribute the Original Code (or portions thereof) with or without Modifications, and/or as part of a Larger Work; and
(b)
under patents now or hereafter owned or controlled by Initial Developer, to make, have made, use and sell ("offer to sell and import") the Original Code, Modifications, or portions thereof, but solely to the extent that any such patent is reasonably necessary to enable You to utilize, alone or in combination with other software, the Original Code, Modifications, or any combination or portions thereof.
(c)
(d)

2.2. Contributor Grant.

Subject to third party intellectual property claims, each Contributor hereby grants You a world-wide, royalty-free, non-exclusive license

sep 0mm
(a)
under intellectual property rights (other than patent or trademark) Licensable by Contributor, to use, reproduce, modify, display, perform, sublicense and distribute the Modifications created by such Contributor (or portions thereof) either on an unmodified basis, with other Modifications, as Covered Code and/or as part of a Larger Work; and
(b)
under patents now or hereafter owned or controlled by Contributor, to make, have made, use and sell ("offer to sell and import") the Contributor Version (or portions thereof), but solely to the extent that any such patent is reasonably necessary to enable You to utilize, alone or in combination with other software, the Contributor Version (or portions thereof).
(c)
(d)

3 DISTRIBUTION OBLIGATIONS.

sep 0mm
3.1. Application of License.

The Modifications which You create or to which You contribute are governed by the terms of this License, including without limitation Section 2.2. The Source Code version of Covered Code may be distributed only under the terms of this License or a future version of this License released under Section 6.1, and You must include a copy of this License with every copy of the Source Code You distribute. You may not offer or impose any terms on any Source Code version that alters or restricts the applicable version of this License or the recipients' rights hereunder. However, You may include an additional document offering the additional rights described in Section 3.5.
3.2. Availability of Source Code.

Any Modification created by You will be provided to the Initial Developer in Source Code form and are subject to the terms of the License.
3.3. Description of Modifications.

You must cause all Covered Code to which You contribute to contain a file documenting the changes You made to create that Covered Code and the date of any change. You must include a prominent statement that the Modification is derived, directly or indirectly, from Original Code provided by the Initial Developer and including the name of the Initial Developer in (a) the Source Code, and (b) in any notice in an Executable version or related documentation in which You describe the origin or ownership of the Covered Code.
3.4. Intellectual Property Matters.

sep 0mm
(a) Third Party Claims.
If Contributor has knowledge that a license under a third party's intellectual property rights is required to exercise the rights granted by such Contributor under Sections 2.1 or 2.2, Contributor must include a text file with the Source Code distribution titled "LEGAL" which describes the claim and the party making the claim in sufficient detail that a recipient will know whom to contact. If Contributor obtains such knowledge after the Modification is made available as described in Section 3.2, Contributor shall promptly modify the LEGAL file in all copies Contributor makes available thereafter and shall take other steps (such as notifying appropriate mailing lists or newsgroups) reasonably calculated to inform those who received the Covered Code that new knowledge has been obtained.
(b) Contributor APIs.
If Contributor's Modifications include an application programming interface and Contributor has knowledge of patent licenses which are reasonably necessary to implement that API, Contributor must also include this information in the LEGAL file.
(c) Representations.
Contributor represents that, except as disclosed pursuant to Section 3.4(a) above, Contributor believes that Contributor's Modifications are Contributor's original creation(s) and/or Contributor has sufficient rights to grant the rights conveyed by this License.

3.5. Required Notices.

You must duplicate the notice in Exhibit A in each file of the Source Code. If it is not possible to put such notice in a particular Source Code file due to its structure, then You must include such notice in a location (such as a relevant directory) where a user would be likely to look for such a notice. If You created one or more Modification(s) You may add your name as a Contributor to the notice described in Exhibit A. You must also duplicate this License in any documentation for the Source Code where You describe recipients' rights or ownership rights relating to Covered Code. You may choose to offer, and to charge a fee for, warranty, support, indemnity or liability obligations to one or more recipients of Covered Code. However, You may do so only on Your own behalf, and not on behalf of the Initial Developer or any Contributor.
3.6. Distribution of Executable Versions.

You may distribute Covered Code in Executable form only if the requirements of Section 3.1-3.5 have been met for that Covered Code. You may distribute the Executable version of Covered Code or ownership rights under a license of Your choice, which may contain terms different from this License, provided that You are in compliance with the terms of this License and that the license for the Executable version does not attempt to limit or alter the recipient's rights in the Source Code version from the rights set forth in this License. If You distribute the Executable version under a different license You must make it absolutely clear that any terms which differ from this License are offered by You alone, not by the Initial Developer or any Contributor. If you distribute executable versions containing Covered Code as part of a product, you must reproduce the notice in Exhibit B in the documentation and/or other materials provided with the product.
3.7. Larger Works.

You may create a Larger Work by combining Covered Code with other code not governed by the terms of this License and distribute the Larger Work as a single product. In such a case, You must make sure the requirements of this License are fulfilled for the Covered Code.
3.8. Restrictions.

You may not remove any product identification, copyright, proprietary notices or labels from gSOAP.

4 INABILITY TO COMPLY DUE TO STATUTE OR REGULATION.
If it is impossible for You to comply with any of the terms of this License with respect to some or all of the Covered Code due to statute, judicial order, or regulation then You must: (a) comply with the terms of this License to the maximum extent possible; and (b) describe the limitations and the code they affect. Such description must be included in the LEGAL file described in Section 3.4 and must be included with all distributions of the Source Code. Except to the extent prohibited by statute or regulation, such description must be sufficiently detailed for a recipient of ordinary skill to be able to understand it.
5 APPLICATION OF THIS LICENSE.
This License applies to code to which the Initial Developer has attached the notice in Exhibit A and to related Covered Code.
6 VERSIONS OF THE LICENSE.

sep 0mm
6.1. New Versions.

Grantor may publish revised and/or new versions of the License from time to time. Each version will be given a distinguishing version number.
6.2. Effect of New Versions.

Once Covered Code has been published under a particular version of the License, You may always continue to use it under the terms of that version. You may also choose to use such Covered Code under the terms of any subsequent version of the License.
6.3. Derivative Works.

If You create or use a modified version of this License (which you may only do in order to apply it to code which is not already Covered Code governed by this License), You must (a) rename Your license so that the phrase "gSOAP" or any confusingly similar phrase do not appear in your license (except to note that your license differs from this License) and (b) otherwise make it clear that Your version of the license contains terms which differ from the gSOAP Public License. (Filling in the name of the Initial Developer, Original Code or Contributor in the notice described in Exhibit A shall not of themselves be deemed to be modifications of this License.)

7 DISCLAIMER OF WARRANTY.
COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY OF ANY KIND, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY, OF FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY RIGHTS, AND ANY WARRANTY THAT MAY ARISE BY REASON OF TRADE USAGE, CUSTOM, OR COURSE OF DEALING. WITHOUT LIMITING THE FOREGOING, YOU ACKNOWLEDGE THAT THE SOFTWARE IS PROVIDED "AS IS" AND THAT THE AUTHORS DO NOT WARRANT THE SOFTWARE WILL RUN UNINTERRUPTED OR ERROR FREE. LIMITED LIABILITY THE ENTIRE RISK AS TO RESULTS AND PERFORMANCE OF THE SOFTWARE IS ASSUMED BY YOU. UNDER NO CIRCUMSTANCES WILL THE AUTHORS BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES OF ANY KIND OR NATURE WHATSOEVER, WHETHER BASED ON CONTRACT, WARRANTY, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, ARISING OUT OF OR IN ANY WAY RELATED TO THE SOFTWARE, EVEN IF THE AUTHORS HAVE BEEN ADVISED ON THE POSSIBILITY OF SUCH DAMAGE OR IF SUCH DAMAGE COULD HAVE BEEN REASONABLY FORESEEN, AND NOTWITHSTANDING ANY FAILURE OF ESSENTIAL PURPOSE OF ANY EXCLUSIVE REMEDY PROVIDED. SUCH LIMITATION ON DAMAGES INCLUDES, BUT IS NOT LIMITED TO, DAMAGES FOR LOSS OF GOODWILL, LOST PROFITS, LOSS OF DATA OR SOFTWARE, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION OR IMPAIRMENT OF OTHER GOODS. IN NO EVENT WILL THE AUTHORS BE LIABLE FOR THE COSTS OF PROCUREMENT OF SUBSTITUTE SOFTWARE OR SERVICES. YOU ACKNOWLEDGE THAT THIS SOFTWARE IS NOT DESIGNED FOR USE IN ON-LINE EQUIPMENT IN HAZARDOUS ENVIRONMENTS SUCH AS OPERATION OF NUCLEAR FACILITIES, AIRCRAFT NAVIGATION OR CONTROL, OR LIFE-CRITICAL APPLICATIONS. THE AUTHORS EXPRESSLY DISCLAIM ANY LIABILITY RESULTING FROM USE OF THE SOFTWARE IN ANY SUCH ON-LINE EQUIPMENT IN HAZARDOUS ENVIRONMENTS AND ACCEPTS NO LIABILITY IN RESPECT OF ANY ACTIONS OR CLAIMS BASED ON THE USE OF THE SOFTWARE IN ANY SUCH ON-LINE EQUIPMENT IN HAZARDOUS ENVIRONMENTS BY YOU. FOR PURPOSES OF THIS PARAGRAPH, THE TERM "LIFE-CRITICAL APPLICATION" MEANS AN APPLICATION IN WHICH THE FUNCTIONING OR MALFUNCTIONING OF THE SOFTWARE MAY RESULT DIRECTLY OR INDIRECTLY IN PHYSICAL INJURY OR LOSS OF HUMAN LIFE. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS DISCLAIMER.
8 TERMINATION.

sep 0mm
8.1.
This License and the rights granted hereunder will terminate automatically if You fail to comply with terms herein and fail to cure such breach within 30 days of becoming aware of the breach. All sublicenses to the Covered Code which are properly granted shall survive any termination of this License. Provisions which, by their nature, must remain in effect beyond the termination of this License shall survive.
8.2.
8.3.
If You assert a patent infringement claim against Participant alleging that such Participant's Contributor Version directly or indirectly infringes any patent where such claim is resolved (such as by license or settlement) prior to the initiation of patent infringement litigation, then the reasonable value of the licenses granted by such Participant under Sections 2.1 or 2.2 shall be taken into account in determining the amount or value of any payment or license.
8.4.
In the event of termination under Sections 8.1 or 8.2 above, all end user license agreements (excluding distributors and resellers) which have been validly granted by You or any distributor hereunder prior to termination shall survive termination.

9 LIMITATION OF LIABILITY.
UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL DEVELOPER, ANY OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND LIMITATION MAY NOT APPLY TO YOU.
10 U.S. GOVERNMENT END USERS.
11 MISCELLANEOUS.
12 RESPONSIBILITY FOR CLAIMS.
As between Initial Developer and the Contributors, each party is responsible for claims and damages arising, directly or indirectly, out of its utilization of rights under this License and You agree to work with Initial Developer and Contributors to distribute such responsibility on an equitable basis. Nothing herein is intended or shall be deemed to constitute any admission of liability.
EXHIBIT A.
"The contents of this file are subject to the gSOAP Public License Version 1.3 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.cs.fsu.edu/~engelen/soaplicense.html

Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for the specific language governing rights and limitations under the License.
The Original Code of the gSOAP Software is: stdsoap.h, stdsoap2.h, stdsoap.c, stdsoap2.c, stdsoap.cpp, stdsoap2.cpp, soapcpp2.h, soapcpp2.c, soapcpp2_lex.l, soapcpp2_yacc.y, error2.h, error2.c, symbol2.c, init2.c, soapdoc2.html, and soapdoc2.pdf, httpget.h, httpget.c, stl.h, stldeque.h, stllist.h, stlvector.h, stlset.h.
The Initial Developer of the Original Code is Robert A. van Engelen. Portions created by Robert A. van Engelen are Copyright (C) 2001-2004 Robert A. van Engelen, Genivia inc. All Rights Reserved.
Contributor(s):

"."

[Note: The text of this Exhibit A may differ slightly form the text of the notices in the Source Code files of the Original code. You should use the text of this Exhibit A rather than the text found in the Original Code Source Code for Your Modifications.]
EXHIBIT B.
"Part of the software embedded in this product is gSOAP software.
Portions created by gSOAP are Copyright (C) 2001-2004 Robert A. van Engelen, Genivia inc. All Rights Reserved.
THE SOFTWARE IN THIS PRODUCT WAS IN PART PROVIDED BY GENIVIA INC AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."

gadfly

The following copyright is modified from the python copyright.

Copyright Notice

The gadfly and kjbuckets source is copyrighted, but you can freely use and
copy it as long as you don't change or remove the copyright:

Copyright Aaron Robert Watters, 1994

All Rights Reserved

Permission to use, copy, modify, and distribute this software and its
documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appears in all copies and that
both that copyright notice and this permission notice appear in
supporting documentation.

AARON ROBERT WATTERS DISCLAIMS ALL WARRANTIES WITH REGARD TO
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS, IN NO EVENT SHALL AARON ROBERT WATTERS BE LIABLE
FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

Signature (obsolete)

Aaron Robert Watters
Department of Computer and Information Sciences
New Jersey Institute of Technology
University Heights
Newark, NJ 07102
phone (201)596-2666
fax (201)596-5777
home phone (908)545-3367
email: aaron@vienna.njit.edu

libarchive

All of the C source code and documentation in this package is subject
to the following:

Copyright (c) 2003-2006 Tim Kientzle
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer
in this position and unchanged.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

libiconv

GNU LIBRARY GENERAL PUBLIC LICENSE
Version 2, June 1991

Copyright (C) 1991 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.

[This is the first released version of the library GPL. It is
numbered 2 because it goes with version 2 of the ordinary GPL.]

Preamble

The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.

This license, the Library General Public License, applies to some
specially designated Free Software Foundation software, and to any
other libraries whose authors decide to use it. You can use it for
your libraries, too.

When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.

To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if
you distribute copies of the library, or if you modify it.

For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link a program with the library, you must provide
complete object files to the recipients so that they can relink them
with the library, after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.

Our method of protecting your rights has two steps: (1) copyright
the library, and (2) offer you this license which gives you legal
permission to copy, distribute and/or modify the library.

Also, for each distributor's protection, we want to make certain
that everyone understands that there is no warranty for this free
library. If the library is modified by someone else and passed on, we
want its recipients to know that what they have is not the original
version, so that any problems introduced by others will not reflect on
the original authors' reputations.

Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that companies distributing free
software will individually obtain patent licenses, thus in effect
transforming the program into proprietary software. To prevent this,
we have made it clear that any patent must be licensed for everyone's
free use or not licensed at all.

Most GNU software, including some libraries, is covered by the ordinary
GNU General Public License, which was designed for utility programs. This
license, the GNU Library General Public License, applies to certain
designated libraries. This license is quite different from the ordinary
one; be sure to read it in full, and don't assume that anything in it is
the same as in the ordinary license.

The reason we have a separate public license for some libraries is that
they blur the distinction we usually make between modifying or adding to a
program and simply using it. Linking a program with a library, without
changing the library, is in some sense simply using the library, and is
analogous to running a utility program or application program. However, in
a textual and legal sense, the linked executable is a combined work, a
derivative of the original library, and the ordinary General Public License
treats it as such.

Because of this blurred distinction, using the ordinary General
Public License for libraries did not effectively promote software
sharing, because most developers did not use the libraries. We
concluded that weaker conditions might promote sharing better.

However, unrestricted linking of non-free programs would deprive the
users of those programs of all benefit from the free status of the
libraries themselves. This Library General Public License is intended to
permit developers of non-free programs to use free libraries, while
preserving your freedom as a user of such programs to change the free
libraries that are incorporated in them. (We have not seen how to achieve
this as regards changes in header files, but we have achieved it as regards
changes in the actual functions of the Library.) The hope is that this
will lead to faster development of free libraries.

The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, while the latter only
works together with the library.

Note that it is possible for a library to be covered by the ordinary
General Public License rather than by this special one.

GNU LIBRARY GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. This License Agreement applies to any software library which
contains a notice placed by the copyright holder or other authorized
party saying it may be distributed under the terms of this Library
General Public License (also called "this License"). Each licensee is
addressed as "you".

A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.

The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)

"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.

1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.

You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.

2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute suc