--
-
-
-Name: Plain vanilla
-Link:
-
-
--
-
-
-Name: Ignore tags in the namespace
-Link*:
-
-
-
-
-
-
-
-
-Name: Short link tag
-Link:
-
-
-
-
-
-
-Name: Spaces in the HTML tag
-Link:
-
-
-
-
-
-
-Name: Spaces in the head tag
-Link:
-
-
-
-
-
-
-Name: Spaces in the link tag
-Link:
-
-
-
-
-
-
-Name: No whitespace
-Link:
-
-
-
-
-Name: Closed head tag
-Link:
-
-
-
-
-
-
-
-Name: One good, one bad (after close head)
-Link:
-
-
-
-
-
-
-
-
-Name: One good, one bad (after open body)
-Link:
-
-
-
-
-
This class represents an association between a server and a consumer. In general, users of this library will never see instances of this object. The only exception is if you implement a custom Auth_OpenID_OpenIDStore.
-
If you do implement such a store, it will need to store the values of the handle, secret, issued, lifetime, and assoc_type instance variables.
- Auth_OpenID_OpenIDStore
- $store: This must be an object that implements the interface in Auth_OpenID_OpenIDStore. Several concrete implementations are provided, to cover most common use cases. For stores backed by MySQL, PostgreSQL, or SQLite, see the Auth_OpenID_SQLStore class and its sublcasses. For a filesystem-backed store, see the Auth_OpenID_FileStore module. As a last resort, if it isn't possible for the server to store state at all, an instance of Auth_OpenID_DumbStore can be used.
-
- mixed
- $session: session An object which implements the interface of the Services_Yadis_Session class. Particularly, this object is expected to have these methods: get($key), set($key, $value), and del($key). This defaults to a session object which wraps PHP's native session machinery. You should only need to pass something here if you have your own sessioning implementation.
-
-
- &$store
-
-
-
-
-
-
-
-
- begin (line 287)
-
-
-
-
Start the OpenID authentication process. See steps 1-2 in the overview at the top of this file.
-
-
return: An object containing the discovered information will be returned, with a method for building a redirect URL to the server, as described in step 3 of the overview. This object may also be used to add extension arguments to the request, using its 'addExtensionArg' method.
- User_url:
- $user_url: Identity URL given by the user. This method performs a textual transformation of the URL to try and make sure it is normalized. For example, a user_url of example.com will be normalized to http://example.com/ normalizing and resolving any redirects the server might issue.
-
-
-
-
-
-
-
-
- beginWithoutDiscovery (line 350)
-
-
-
-
Start OpenID verification without doing OpenID server
-
discovery. This method is used internally by Consumer.begin after discovery is performed, and exists to provide an interface for library users needing to perform their own discovery.
- Auth_OpenID_ServiceEndpoint
- $endpoint: an OpenID service endpoint descriptor.
-
-
-
-
-
-
-
-
- complete (line 372)
-
-
-
-
Called to interpret the server's response to an OpenID request. It is called in step 4 of the flow described in the consumer overview.
-
-
return: A instance of an Auth_OpenID_ConsumerResponse subclass. The type of response is indicated by the status attribute, which will be one of SUCCESS, CANCEL, FAILURE, or SETUP_NEEDED.
- A response with a status of Auth_OpenID_FAILURE. Indicates that the OpenID protocol has failed. This could be locally or remotely triggered. This has three relevant attributes:
-
- A response with a status of Auth_OpenID_CANCEL. Indicates that the user cancelled the OpenID authentication request. This has two relevant attributes:
-
- A response with a status of Auth_OpenID_SETUP_NEEDED. Indicates that the request was in immediate mode, and the server is unable to authenticate the user without further interaction.
-
An empty base class intended to emulate PEAR connection
-
functionality in applications that supply their own database abstraction mechanisms. See Auth_OpenID_SQLStore for more information. You should subclass this class if you need to create an SQL store that needs to access its database using an application's database abstraction layer instead of a PEAR database connection. Any subclass of Auth_OpenID_DatabaseConnection MUST adhere to the interface specified here.
- string
- $sql: An SQL string with placeholders. The placeholders are assumed to be specific to the database engine for this connection.
-
- array
- $params: An array of parameters to insert into the SQL string using this connection's escaping mechanism.
-
-
-
-
-
-
-
-
- query (line 51)
-
-
-
-
Run an SQL query with the specified parameters, if any.
-
-
return: The result of calling this connection's internal query function. The type of result depends on the underlying database engine. This method is usually used when the result of a query is not important, like a DDL query.
This is a store for use in the worst case, when you have no way of saving state on the consumer site. Using this store makes the consumer vulnerable to replay attacks, as it's unable to use nonces. Avoid using this store if it is at all possible.
-
Most of the methods of this class are implementation details. Users of this class need to worry only about the constructor.
Creates a new Auth_OpenID_DumbStore instance. For the security of the tokens generated by the library, this class attempts to at least have a secure implementation of getAuthKey.
-
When you create an instance of this class, pass in a secret phrase. The phrase is hashed with sha1 to make it the correct length and form for an auth key. That allows you to use a long string as the secret phrase, which means you can make it very difficult to guess.
Each Auth_OpenID_DumbStore instance that is created for use by your consumer site needs to use the same $secret_phrase.
This method returns an Association object from storage that matches the server URL and, if specified, handle. It returns null if no such association is found or if the matching association is expired.
-
-
-
-
-
-
-
- getAuthKey (line 101)
-
-
-
-
This method returns the auth key generated by the constructor.
This method returns a key used to sign the tokens, to ensure that they haven't been tampered with in transit. It should return the same key every time it is called. The key returned should be AUTH_KEY_LEN bytes long.
-
-
-
-
-
-
-
- isDumb (line 110)
-
-
-
-
This store is a dumb mode store, so this method is overridden to return true.
This method must return true if the store is a dumb-mode-style store. Unlike all other methods in this class, this one provides a default implementation, which returns false.
This method is called when the library is attempting to use a nonce. If the nonce is in the store, this method removes it and returns a value which evaluates as true. Otherwise it returns a value which evaluates as false.
A response with a status of Auth_OpenID_FAILURE. Indicates that the OpenID protocol has failed. This could be locally or remotely triggered. This has three relevant attributes:
-
identity_url - The identity URL for which authentication was attempted, if it can be determined. Otherwise, null.
message - A message indicating why the request failed, if one is supplied. Otherwise, null.
This is a filesystem-based store for OpenID associations and
-
nonces. This store should be safe for use in concurrent systems on both windows and unix (excluding NFS filesystems). There are a couple race conditions in the system, but those failure cases have been set up in such a way that the worst-case behavior is someone having to try to log in a second time.
Most of the methods of this class are implementation details. People wishing to just use this store need only pay attention to the constructor.
This method returns an Association object from storage that matches the server URL and, if specified, handle. It returns null if no such association is found or if the matching association is expired.
-
-
-
-
-
-
-
- getAssociationFilename (line 224)
-
-
-
-
Create a unique filename for a given server url and
-
handle. This implementation does not assume anything about the format of the handle. The filename that is returned will contain the domain name from the server URL for ease of human inspection of the data directory.
This method returns a key used to sign the tokens, to ensure that they haven't been tampered with in transit. It should return the same key every time it is called. The key returned should be AUTH_KEY_LEN bytes long.
-
-
-
-
-
-
-
- readAuthKey (line 128)
-
-
-
-
Read the auth key from the auth key file. Will return None if there is currently no key.
-
-
- mixed
-
- readAuthKey
-
- ()
-
-
-
-
-
-
-
-
-
- removeAssociation (line 413)
-
-
-
-
Remove an association if it exists. Do nothing if it does not.
This method is called when the library is attempting to use a nonce. If the nonce is in the store, this method removes it and returns a value which evaluates as true. Otherwise it returns a value which evaluates as false.
This is the interface for the store objects the OpenID library
-
uses. It is a single class that provides all of the persistence mechanisms that the OpenID library needs, for both servers and consumers. If you want to create an SQL-driven store, please see then Auth_OpenID_SQLStore class.
- This is a store for use in the worst case, when you have no way of saving state on the consumer site. Using this store makes the consumer vulnerable to replay attacks, as it's unable to use nonces. Avoid using this store if it is at all possible.
-
This method returns an Association object from storage that matches the server URL and, if specified, handle. It returns null if no such association is found or if the matching association is expired.
-
If no handle is specified, the store may return any association which matches the server URL. If multiple associations are valid, the recommended return value for this method is the one that will remain valid for the longest duration.
This method is allowed (and encouraged) to garbage collect expired associations when found. This method must not return expired associations.
-
-
return: The Association for the given identity server.
- string
- $server_url: The URL of the identity server to get the association for. Because of the way the server portion of the library uses this interface, don't assume there are any limitations on the character set of the input string. In particular, expect to see unescaped non-url-safe characters in the server_url field.
-
- mixed
- $handle: This optional parameter is the handle of the specific association to get. If no specific handle is provided, any valid association matching the server URL is returned.
This method returns a key used to sign the tokens, to ensure that they haven't been tampered with in transit. It should return the same key every time it is called. The key returned should be AUTH_KEY_LEN bytes long.
-
-
return: The key. It should be AUTH_KEY_LEN bytes in length, and use the full range of byte values. That is, it should be treated as a lump of binary data stored in a string.
This method must return true if the store is a dumb-mode-style store. Unlike all other methods in this class, this one provides a default implementation, which returns false.
-
In general, any custom subclass of Auth_OpenID_OpenIDStore won't override this method, as custom subclasses are only likely to be created when the store is fully functional.
-
-
return: true if the store works fully, false if the consumer will have to use dumb mode to use this store.
- string
- $server_url: The URL of the identity server the association to remove belongs to. Because of the way the server portion of the library uses this interface, don't assume there are any limitations on the character set of the input string. In particular, expect to see unescaped non-url-safe characters in the server_url field.
-
- string
- $handle: This is the handle of the association to remove. If there isn't an association found that matches both the given URL and handle, then there was no matching handle found.
- string
- $server_url: The URL of the identity server that this association is with. Because of the way the server portion of the library uses this interface, don't assume there are any limitations on the character set of the input string. In particular, expect to see unescaped non-url-safe characters in the server_url field.
-
- Association
- $association: The Association to store.
This method is called when the library is attempting to use a nonce. If the nonce is in the store, this method removes it and returns a value which evaluates as true. Otherwise it returns a value which evaluates as false.
-
This method is allowed and encouraged to treat nonces older than some period (a very conservative window would be 6 hours, for example) as no longer existing, and return False and remove them.
-
-
return: Whether or not the nonce was valid.
-
-
-
- bool
-
- useNonce
-
- (string$nonce)
-
-
-
-
- string
- $nonce: The nonce to use.
-
-
-
-
-
Redefined in descendants as:
-
-
- Auth_OpenID_DumbStore::useNonce()
- : In a system truly limited to dumb mode, nonces must all be accepted. This therefore always returns true, which makes replay attacks feasible.
-
This is the parent class for the SQL stores, which contains the logic common to all of the SQL stores.
-
The table names used are determined by the class variables settings_table_name, associations_table_name, and nonces_table_name. To change the name of the tables used, pass new table names into the constructor.
To create the tables with the proper schema, see the createTables method.
This class shouldn't be used directly. Use one of its subclasses instead, as those contain the code necessary to use a specific database. If you're an OpenID integrator and you'd like to create an SQL-driven store that wraps an application's database abstraction, be sure to create a subclass of Auth_OpenID_DatabaseConnection that calls the application's database abstraction calls. Then, pass an instance of your new database connection class to your SQLStore subclass constructor.
All methods other than the constructor and createTables should be considered implementation details.
- connection
- $connection: This must be an established connection to a database of the correct type for the SQLStore subclass you're using. This must either be an PEAR DB connection handle or an instance of a subclass of Auth_OpenID_DatabaseConnection.
-
- string
- $settings_table: This is an optional parameter to specify the name of the table used for this store's settings. The default value is 'oid_settings'.
-
- associations_table:
- $associations_table: This is an optional parameter to specify the name of the table used for storing associations. The default value is 'oid_associations'.
-
- nonces_table:
- $nonces_table: This is an optional parameter to specify the name of the table used for storing nonces. The default value is 'oid_nonces'.
This method returns an Association object from storage that matches the server URL and, if specified, handle. It returns null if no such association is found or if the matching association is expired.
This method returns a key used to sign the tokens, to ensure that they haven't been tampered with in transit. It should return the same key every time it is called. The key returned should be AUTH_KEY_LEN bytes long.
-
-
-
-
-
-
-
- isError (line 177)
-
-
-
-
Returns true if $value constitutes a database error; returns false otherwise.
Removes all entries from the store; implementation is optional.
-
-
-
-
-
-
-
- resultToBool (line 187)
-
-
-
-
Converts a query result to a boolean. If the result is a database error according to $this->isError(), this returns false; otherwise, this returns true.
-
-
- void
-
- resultToBool
-
- ( $obj)
-
-
-
-
-
- $obj
-
-
-
-
-
-
-
-
- setSQL (line 201)
-
-
-
-
This method should be overridden by subclasses. This method is called by the constructor to set values in $this->sql, which is an array keyed on sql name.
This method is called when the library is attempting to use a nonce. If the nonce is in the store, this method removes it and returns a value which evaluates as true. Otherwise it returns a value which evaluates as false.
This method should be overridden by subclasses. This method is called by the constructor to set values in $this->sql, which is an array keyed on sql name.
An error class which gets instantiated and returned whenever an OpenID protocol error occurs. Be prepared to use this in place of an ordinary server response.
Encodes the response to key-value form. This is a machine-readable format used to respond to messages which came directly from the consumer and not through the user-agent. See the OpenID specification.
-
-
- void
-
- encodeToKVForm
-
- ()
-
-
-
-
-
-
-
-
-
- encodeToURL (line 178)
-
-
-
-
Encodes this error's response as a URL suitable for redirection. If the response has no return_to, another Auth_OpenID_ServerError is returned.
-
-
- void
-
- encodeToURL
-
- ()
-
-
-
-
-
-
-
-
-
- hasReturnTo (line 162)
-
-
-
-
Returns the return_to URL for the request which caused this error.
A response with a status of Auth_OpenID_SETUP_NEEDED. Indicates that the request was in immediate mode, and the server is unable to authenticate the user without further interaction.
-
identity_url - The identity URL for which authentication was attempted.
setup_url - A URL that can be used to send the user to the server to set up for authentication. The user should be redirected in to the setup_url, either in the current window or in a new browser window.
A response with a status of Auth_OpenID_SUCCESS. Indicates that
-
this request is a successful acknowledgement from the OpenID server that the supplied URL is, indeed controlled by the requesting agent. This has three relevant attributes:
identity_url - The identity URL that has been authenticated
signed_args - The arguments in the server's response that were signed and verified.
- This class represents an association between a server and a consumer. In general, users of this library will never see instances of this object. The only exception is if you implement a custom Auth_OpenID_OpenIDStore.
-
-
-
-
-
-
-
-
-
-
-
- Documentation generated on Mon, 10 Sep 2007 13:29:27 -0700 by phpDocumentor 1.3.2
-
-
-
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/doc/OpenID/_Auth---OpenID---Consumer.php.html b/modules/member/php-openid-1.2.3/doc/OpenID/_Auth---OpenID---Consumer.php.html
deleted file mode 100644
index a746d889a..000000000
--- a/modules/member/php-openid-1.2.3/doc/OpenID/_Auth---OpenID---Consumer.php.html
+++ /dev/null
@@ -1,382 +0,0 @@
-
-
-
-
-
- Docs for page Consumer.php
-
-
-
-
-
This module documents the main interface with the OpenID consumer
-
library. The only part of the library which has to be used and isn't documented in full here is the store required to create an Auth_OpenID_Consumer instance. More on the abstract store type and concrete implementations of it that are provided in the documentation for the Auth_OpenID_Consumer constructor.
OVERVIEW
The OpenID identity verification process most commonly uses the following steps, as visible to the user of this library:
The user enters their OpenID into a field on the consumer's
- site, and hits a login button.
The consumer site discovers the user's OpenID server using the
- YADIS protocol.
The consumer site sends the browser a redirect to the identity
- server. This is the authentication request as described in
- the OpenID specification.
The identity server's site sends the browser a redirect back
- to the consumer site. This redirect contains the server's
- response to the authentication request.
The most important part of the flow to note is the consumer's site must handle two separate HTTP requests in order to perform the full identity check.
LIBRARY DESIGN
This consumer library is designed with that flow in mind. The goal is to make it as easy as possible to perform the above steps securely.
At a high level, there are two important parts in the consumer library. The first important part is this module, which contains the interface to actually use this library. The second is the Auth_OpenID_Interface class, which describes the interface to use if you need to create a custom method for storing the state this library needs to maintain between requests.
In general, the second part is less important for users of the library to know about, as several implementations are provided which cover a wide variety of situations in which consumers may use the library.
This module contains a class, Auth_OpenID_Consumer, with methods corresponding to the actions necessary in each of steps 2, 3, and 4 described in the overview. Use of this library should be as easy as creating an Auth_OpenID_Consumer instance and calling the methods appropriate for the action the site wants to take.
STORES AND DUMB MODE
OpenID is a protocol that works best when the consumer site is able to store some state. This is the normal mode of operation for the protocol, and is sometimes referred to as smart mode. There is also a fallback mode, known as dumb mode, which is available when the consumer site is not able to store state. This mode should be avoided when possible, as it leaves the implementation more vulnerable to replay attacks.
The mode the library works in for normal operation is determined by the store that it is given. The store is an abstraction that handles the data that the consumer needs to manage between http requests in order to operate efficiently and securely.
Several store implementation are provided, and the interface is fully documented so that custom stores can be used as well. See the documentation for the Auth_OpenID_Consumer class for more information on the interface for stores. The implementations that are provided allow the consumer site to store the necessary data in several different ways, including several SQL databases and normal files on disk.
There is an additional concrete store provided that puts the system in dumb mode. This is not recommended, as it removes the library's ability to stop replay attacks reliably. It still uses time-based checking to make replay attacks only possible within a small window, but they remain possible within that window. This store should only be used if the consumer site has no way to retain data between requests at all.
IMMEDIATE MODE
In the flow described above, the user may need to confirm to the lidentity server that it's ok to authorize his or her identity. The server may draw pages asking for information from the user before it redirects the browser back to the consumer's site. This is generally transparent to the consumer site, so it is typically ignored as an implementation detail.
There can be times, however, where the consumer site wants to get a response immediately. When this is the case, the consumer can put the library in immediate mode. In immediate mode, there is an extra response possible from the server, which is essentially the server reporting that it doesn't have enough information to answer the question yet. In addition to saying that, the identity server provides a URL to which the user can be sent to provide the needed information and let the server finish handling the original request.
USING THIS LIBRARY
Integrating this library into an application is usually a relatively straightforward process. The process should basically follow this plan:
Add an OpenID login field somewhere on your site. When an OpenID is entered in that field and the form is submitted, it should make a request to the your site which includes that OpenID URL.
First, the application should instantiate the Auth_OpenID_Consumer class using the store of choice (Auth_OpenID_FileStore or one of the SQL-based stores). If the application has any sort of session framework that provides per-client state management, a dict-like object to access the session should be passed as the optional second parameter. (The default behavior is to use PHP's standard session machinery.)
Next, the application should call the Auth_OpenID_Consumer object's 'begin' method. This method takes the OpenID URL. The 'begin' method returns an Auth_OpenID_AuthRequest object.
Next, the application should call the 'redirectURL' method of the Auth_OpenID_AuthRequest object. The 'return_to' URL parameter is the URL that the OpenID server will send the user back to after attempting to verify his or her identity. The 'trust_root' is the URL (or URL pattern) that identifies your web site to the user when he or she is authorizing it. Send a redirect to the resulting URL to the user's browser.
That's the first half of the authentication process. The second half of the process is done after the user's ID server sends the user's browser a redirect back to your site to complete their login.
When that happens, the user will contact your site at the URL given as the 'return_to' URL to the Auth_OpenID_AuthRequest::redirectURL call made above. The request will have several query parameters added to the URL by the identity server as the information necessary to finish the request.
Lastly, instantiate an Auth_OpenID_Consumer instance as above and call its 'complete' method, passing in all the received query arguments.
There are multiple possible return types possible from that method. These indicate the whether or not the login was successful, and include any additional information appropriate for their type.
PHP versions 4 and 5
LICENSE: See the COPYING file included in this distribution.
- An OpenID consumer implementation that performs discovery and does session management. See the Consumer.php file documentation for more information.
-
- A response with a status of Auth_OpenID_FAILURE. Indicates that the OpenID protocol has failed. This could be locally or remotely triggered. This has three relevant attributes:
-
- A response with a status of Auth_OpenID_CANCEL. Indicates that the user cancelled the OpenID authentication request. This has two relevant attributes:
-
- A response with a status of Auth_OpenID_SETUP_NEEDED. Indicates that the request was in immediate mode, and the server is unable to authenticate the user without further interaction.
-
This is the status code beginAuth returns when the page fetched from the entered OpenID URL doesn't contain the necessary link tags to function as an identity page.
This is the status code completeAuth returns when the Auth_OpenID_Consumer instance is in immediate mode, and the identity server sends back a URL to send the user to to complete his or her login.
- This is a store for use in the worst case, when you have no way of saving state on the consumer site. Using this store makes the consumer vulnerable to replay attacks, as it's unable to use nonces. Avoid using this store if it is at all possible.
-
Require the PEAR DB module because we'll need it for the SQL-based
-
stores implemented here. We silence any errors from the inclusion because it might not be present, and a user of the SQL stores may supply an Auth_OpenID_DatabaseConnection instance that implements its own storage.
-
-
-
-
-
-
-
-
-
- Documentation generated on Mon, 10 Sep 2007 13:29:30 -0700 by phpDocumentor 1.3.2
-
-
-
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/doc/OpenID/_Auth---OpenID---SQLiteStore.php.html b/modules/member/php-openid-1.2.3/doc/OpenID/_Auth---OpenID---SQLiteStore.php.html
deleted file mode 100644
index 6f6c02310..000000000
--- a/modules/member/php-openid-1.2.3/doc/OpenID/_Auth---OpenID---SQLiteStore.php.html
+++ /dev/null
@@ -1,89 +0,0 @@
-
-
-
-
-
- Docs for page SQLiteStore.php
-
-
-
-
-
Examine the incoming request to determine its nature and validity.
Make a decision about how to respond to this request.
Format the response according to the protocol.
The first and last of these tasks may performed by the 'decodeRequest' and 'encodeResponse' methods of the Auth_OpenID_Server object. Who gets to do the intermediate task -- deciding how to respond to the request -- will depend on what type of request it is.
If it's a request to authenticate a user (a 'checkid_setup' or 'checkid_immediate' request), you need to decide if you will assert that this user may claim the identity in question. Exactly how you do that is a matter of application policy, but it generally involves making sure the user has an account with your system and is logged in, checking to see if that identity is hers to claim, and verifying with the user that she does consent to releasing that information to the party making the request.
Examine the properties of the Auth_OpenID_CheckIDRequest object, and if and when you've come to a decision, form a response by calling Auth_OpenID_CheckIDRequest::answer.
Other types of requests relate to establishing associations between client and server and verifing the authenticity of previous communications. Auth_OpenID_Server contains all the logic and data necessary to respond to such requests; just pass it to Auth_OpenID_Server::handleRequest.
OpenID Extensions
Do you want to provide other information for your users in addition to authentication? Version 1.2 of the OpenID protocol allows consumers to add extensions to their requests. For example, with sites using the Simple Registration Extension (http://www.openidenabled.com/openid/simple-registration-extension/), a user can agree to have their nickname and e-mail address sent to a site when they sign up.
Since extensions do not change the way OpenID authentication works, code to handle extension requests may be completely separate from the Auth_OpenID_Request class here. But you'll likely want data sent back by your extension to be signed. Auth_OpenID_Response provides methods with which you can add data to it which can be signed with the other data in the OpenID signature.
For example:
// when request is a checkid_* request response = request.answer(True) // this will a signed 'openid.sreg.timezone' parameter to the response response.addField('sreg', 'timezone', 'America/Los_Angeles')
Stores
The OpenID server needs to maintain state between requests in order to function. Its mechanism for doing this is called a store. The store interface is defined in Interface.php. Additionally, several concrete store implementations are provided, so that most sites won't need to implement a custom store. For a store backed by flat files on disk, see Auth_OpenID_FileStore. For stores based on MySQL, SQLite, or PostgreSQL, see the Auth_OpenID_SQLStore subclasses.
Upgrading
The keys by which a server looks up associations in its store have changed in version 1.2 of this library. If your store has entries created from version 1.0 code, you should empty it.
PHP versions 4 and 5
LICENSE: See the COPYING file included in this distribution.
- An error class which gets instantiated and returned whenever an OpenID protocol error occurs. Be prepared to use this in place of an ordinary server response.
-
Status code returned when there were no OpenID arguments passed. This code indicates that the caller should return a 200 OK response and display an HTML page that says that this is an OpenID server endpoint.
Status code returned when the caller needs to authenticate the
-
user. The associated value is a Auth_OpenID_ServerRequest object that can be used to complete the authentication. If the user has taken some authentication action, use the retry() method of the Auth_OpenID_ServerRequest object to complete the request.
Status code returned by the server when the only option is to show an error page, since we do not have enough information to redirect back to the consumer. The associated value is an error message that should be displayed on an HTML error page.
Status code returned when there is a redirect back to the consumer. The value is the URL to redirect back to. The caller should return a 302 Found redirect with a Location: header containing the URL.
Status code returned when there is an error to return in key-value form to the consumer. The caller should return a 400 Bad Request response with content-type text/plain and the value as the body.
Status code returned when there is a key-value form OK response to the consumer. The value associated with this code is the response. The caller should return a 200 OK response with content-type text/plain and the value as the body.
This is a complete implementation of the OpenID authentication
- protocol. This package contains:
-
-
An OpenID server
-
An OpenID consumer
-
Stores for MySQL, PostgreSQL, SQLite, and filesystem-based OpenID data storage
-
PHPUnit unit tests
-
An example server and consumer
-
-
For Package Users
To install this package, copy the Auth/
- directory in this package to a directory in your PHP include path.
- Alternatively, modify your PHP include path to include the
- directory that contains Auth/. Any
- applications that need this package will then be able to use it.
-
-
For Developers
See the server and consumer examples in the
- examples/ directory of the package. For
- details on how to run the examples, see
- examples/README. If you want to create your
- own OpenID data storage class, please see the Auth_OpenID_OpenIDStore
- class.
A session helper class designed to translate between arrays and
-
objects. Note that the class used must have a constructor that takes no parameters. This is not a general solution, but it works for dumb objects that just need to have attributes set. The idea is that you'll subclass this and override $this->check($data) -> bool to implement your own session data validation.
Returns a new instance of this loader's class, using the session data to construct it if necessary. The object need only be created; $this->fromSession() will take care of setting the object's attributes.
High-level usage pattern is to call .getNextService(discover) in order to find the next available service for this user for this session. Once a request completes, call .finish() to clean up the session state.
The Yadis service manager which stores state in a session and iterates over <Service> elements in a Yadis XRDS document and lets a caller attempt to use each one. This is used by the Yadis library internally.
A session helper class designed to translate between arrays and
-
objects. Note that the class used must have a constructor that takes no parameters. This is not a general solution, but it works for dumb objects that just need to have attributes set. The idea is that you'll subclass this and override $this->check($data) -> bool to implement your own session data validation.
Returns a new instance of this loader's class, using the session data to construct it if necessary. The object need only be created; $this->fromSession() will take care of setting the object's attributes.
The base session class used by the Services_Yadis_Manager. This class wraps the default PHP session machinery and should be subclassed if your application doesn't use PHP sessioning.
This class represents a <Service> element in an XRDS document.
-
Objects of this type are returned by Services_Yadis_XRDS::services() and Services_Yadis_Yadis::services(). Each object corresponds directly to a <Service> element in the XRDS and supplies a getElements($name) method which you should use to inspect the element's contents. See Services_Yadis_Yadis for more information on the role this class plays in Yadis discovery.
Used to get XML elements from this object's <Service> element.
-
This is what you should use to get all custom information out of this element. This is used by service filter functions to determine whether a service element contains specific tags, etc. NOTE: this only considers elements which are direct children of the <Service> element for this object.
-
-
return: An array of elements with the specified name which are direct children of the <Service> element. The nodes returned by this function can be passed to $this->parser methods (see Services_Yadis_XMLParser).
-
-
-
- array
-
- getElements
-
- (string$name)
-
-
-
-
- string
- $name: The name of the element to look for
-
-
-
-
-
-
-
-
- getPriority (line 152)
-
-
-
-
Returns the "priority" attribute value of this <Service> element, if the attribute is present. Returns null if not.
-
-
return: Null or integer, depending on whether this Service element has a 'priority' attribute.
-
-
-
- mixed
-
- getPriority
-
- ()
-
-
-
-
-
-
-
-
-
- getTypes (line 90)
-
-
-
-
Return the URIs in the "Type" elements, if any, of this Service element.
-
-
return: An array of Type URI strings.
-
-
-
- array
-
- getTypes
-
- ()
-
-
-
-
-
-
-
-
-
- getURIs (line 108)
-
-
-
-
Return the URIs in the "URI" elements, if any, of this Service element. The URIs are returned sorted in priority order.
-
-
return: An array of URI strings.
-
-
-
- array
-
- getURIs
-
- ()
-
-
-
-
-
-
-
-
-
-
-
- Documentation generated on Mon, 10 Sep 2007 13:29:31 -0700 by phpDocumentor 1.3.2
-
-
-
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/doc/Yadis/Services_Yadis_SessionLoader.html b/modules/member/php-openid-1.2.3/doc/Yadis/Services_Yadis_SessionLoader.html
deleted file mode 100644
index 18c2c4f23..000000000
--- a/modules/member/php-openid-1.2.3/doc/Yadis/Services_Yadis_SessionLoader.html
+++ /dev/null
@@ -1,333 +0,0 @@
-
-
-
-
-
- Docs For Class Services_Yadis_SessionLoader
-
-
-
-
-
A session helper class designed to translate between arrays and
-
objects. Note that the class used must have a constructor that takes no parameters. This is not a general solution, but it works for dumb objects that just need to have attributes set. The idea is that you'll subclass this and override $this->check($data) -> bool to implement your own session data validation.
Given a session data value (an array), this creates an object
-
(returned by $this->newObject()) whose attributes and values are those in $data. Returns null if $data lacks keys found in $this->requiredKeys(). Returns null if $this->check($data) evaluates to false. Returns null if $this->newObject() evaluates to false.
-
-
- void
-
- fromSession
-
- ( $data)
-
-
-
-
-
- $data
-
-
-
-
-
-
-
-
- newObject (line 139)
-
-
-
-
Returns a new instance of this loader's class, using the session data to construct it if necessary. The object need only be created; $this->fromSession() will take care of setting the object's attributes.
Returns an array of keys and values built from the attributes of $obj. If $this->prepareForSave($obj) returns an array, its keys and values are used to update the $data array of attributes from $obj.
-
-
- void
-
- toSession
-
- ( $obj)
-
-
-
-
-
- $obj
-
-
-
-
-
-
-
-
-
-
- Documentation generated on Mon, 10 Sep 2007 13:29:29 -0700 by phpDocumentor 1.3.2
-
-
-
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/doc/Yadis/Services_Yadis_XMLParser.html b/modules/member/php-openid-1.2.3/doc/Yadis/Services_Yadis_XMLParser.html
deleted file mode 100644
index 6e1411660..000000000
--- a/modules/member/php-openid-1.2.3/doc/Yadis/Services_Yadis_XMLParser.html
+++ /dev/null
@@ -1,374 +0,0 @@
-
-
-
-
-
- Docs For Class Services_Yadis_XMLParser
-
-
-
-
-
The base class for wrappers for available PHP XML-parsing
-
extensions. To work with this Yadis library, subclasses of this class MUST implement the API as defined in the remarks for this class. Subclasses of Services_Yadis_XMLParser are used to wrap particular PHP XML extensions such as 'domxml'. These are used internally by the library depending on the availability of supported PHP XML extensions.
- string
- $xpath: The XPath expression to be evaluated.
-
- mixed
- $node: A node object resulting from a previous evalXPath call. This node, if specified, provides the context for the evaluation of this xpath expression.
If the XRDS can be parsed and is valid, an instance of Services_Yadis_XRDS will be returned. Otherwise, null will be returned. This class is used by the Services_Yadis_Yadis::discover method.
Returns a list of service objects which correspond to <Service> elements in the XRDS XML document for this object.
-
Optionally, an array of filter callbacks may be given to limit the list of returned service objects. Furthermore, the default mode is to return all service objects which match ANY of the specified filters, but $filter_mode may be SERVICES_YADIS_MATCH_ALL if you want to be sure that the returned services match all the given filters. See Services_Yadis_Yadis for detailed usage information on filter functions.
-
-
return: An array of Services_Yadis_Service objects if $filter_mode is a valid mode; null if $filter_mode is an invalid mode (i.e., not SERVICES_YADIS_MATCH_ANY or SERVICES_YADIS_MATCH_ALL).
- mixed
- $filters: An array of callbacks to filter the returned services, or null if all services are to be returned.
-
- integer
- $filter_mode: SERVICES_YADIS_MATCH_ALL or SERVICES_YADIS_MATCH_ANY, depending on whether the returned services should match ALL or ANY of the specified filters, respectively.
-
-
-
-
-
-
-
-
-
-
- Documentation generated on Mon, 10 Sep 2007 13:29:31 -0700 by phpDocumentor 1.3.2
-
-
-
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/doc/Yadis/Services_Yadis_Yadis.html b/modules/member/php-openid-1.2.3/doc/Yadis/Services_Yadis_Yadis.html
deleted file mode 100644
index a6aef8c86..000000000
--- a/modules/member/php-openid-1.2.3/doc/Yadis/Services_Yadis_Yadis.html
+++ /dev/null
@@ -1,258 +0,0 @@
-
-
-
-
-
- Docs For Class Services_Yadis_Yadis
-
-
-
-
-
This is the core of the PHP Yadis library. This is the only class a user needs to use to perform Yadis discovery. This class performs the discovery AND stores the result of the discovery.
-
First, require this library into your program source:
require_once "Services/Yadis/Yadis.php";
To perform Yadis discovery, first call the "discover" method statically with a URI parameter:
If the discovery succeeds, $yadis_object will be an instance of Services_Yadis_Yadis. If not, it will be null. The XRDS document found during discovery should have service descriptions, which can be accessed by calling
$service_list = $yadis_object->services();
which returns an array of objects which describe each service. These objects are instances of Services_Yadis_Service. Each object describes exactly one whole Service element, complete with all of its Types and URIs (no expansion is performed). The common use case for using the service objects returned by services() is to write one or more filter functions and pass those to services():
The filter functions (whose names appear in the array passed to services()) take the following form:
function myFilter(&$service) {
- // Query $service object here. Return true if the service
- // matches your query; false if not.
- }
This is an example of a filter which uses a regular expression to match the content of URI tags (note that the Services_Yadis_Service class provides a getURIs() method which you should use instead of this contrived example):
function URIMatcher(&$service) {
- foreach ($service->getElements('xrd:URI') as $uri) {
- if (preg_match("/some_pattern/",
- $service->parser->content($uri))) {
- return true;
- }
- }
- return false;
- }
The filter functions you pass will be called for each service object to determine which ones match the criteria your filters specify. The default behavior is that if a given service object matches ANY of the filters specified in the services() call, it will be returned. You can specify that a given service object will be returned ONLY if it matches ALL specified filters by changing the match mode of services():
Services described in an XRDS should have a library which you'll probably be using. Those libraries are responsible for defining filters that can be used with the "services()" call. If you need to write your own filter, see the documentation for Services_Yadis_Service.
Instantiates an empty Services_Yadis_Yadis object. This constructor should not be used by any user of the library.
-
This constructor results in a completely useless object which must be populated with valid discovery information. Instead of using this constructor, call Services_Yadis_Yadis::discover($uri).
This should be called statically and will build a Yadis instance if the discovery process succeeds. This implements Yadis discovery as specified in the Yadis specification.
-
-
return: Either null or an instance of Services_Yadis_Yadis, depending on whether the discovery succeeded.
- string
- $uri: The URI on which to perform Yadis discovery.
-
- array
- $http_response: An array reference where the HTTP response object will be stored (see Services_Yadis_HTTPResponse.
-
- Services_Yadis_HTTPFetcher
- $fetcher: An instance of a Services_Yadis_HTTPFetcher subclass.
-
- array
- $extra_ns_map: An array which maps namespace names to namespace URIs to be used when parsing the Yadis XRDS document.
-
- integer
- $timeout: An optional fetcher timeout, in seconds.
-
-
- &$http_response
-
-
- &$fetcher
-
-
-
-
-
-
-
-
- getHTTPFetcher (line 122)
-
-
-
-
Returns an HTTP fetcher object. If the CURL extension is present, an instance of Services_Yadis_ParanoidHTTPFetcher is returned. If not, an instance of Services_Yadis_PlainHTTPFetcher is returned.
This concrete implementation of Services_Yadis_XMLParser implements
-
the appropriate API for the 'dom' extension which is typically packaged with PHP 5. This class will be used whenever the 'dom' extension is detected. See the Services_Yadis_XMLParser class for details on this class's methods.
This concrete implementation of Services_Yadis_XMLParser implements
-
the appropriate API for the 'domxml' extension which is typically packaged with PHP 4. This class will be used whenever the 'domxml' extension is detected. See the Services_Yadis_XMLParser class for details on this class's methods.
- The base session class used by the Services_Yadis_Manager. This class wraps the default PHP session machinery and should be subclassed if your application doesn't use PHP sessioning.
-
- The Yadis service manager which stores state in a session and iterates over <Service> elements in a Yadis XRDS document and lets a caller attempt to use each one. This is used by the Yadis library internally.
-
Returns an instance of a Services_Yadis_XMLParser subclass based on the availability of PHP extensions for XML parsing. If Services_Yadis_setDefaultParser has been called, the parser used in that call will be returned instead.
-
-
- void
-
- &Services_Yadis_getXMLParser
-
- ()
-
-
-
-
-
-
-
-
-
- Services_Yadis_setDefaultParser (line 304)
-
-
-
-
Set a default parser to override the extension-driven selection of available parser classes. This is helpful in a test environment or one in which multiple parsers can be used but one is more desirable.
- This is the core of the PHP Yadis library. This is the only class a user needs to use to perform Yadis discovery. This class performs the discovery AND stores the result of the discovery.
-
This class represents an association between a server and a consumer. In general, users of this library will never see instances of this object. The only exception is if you implement a custom Auth_OpenID_OpenIDStore.
Status code returned when there were no OpenID arguments passed. This code indicates that the caller should return a 200 OK response and display an HTML page that says that this is an OpenID server endpoint.
This is a store for use in the worst case, when you have no way of saving state on the consumer site. Using this store makes the consumer vulnerable to replay attacks, as it's unable to use nonces. Avoid using this store if it is at all possible.
Creates a new Auth_OpenID_DumbStore instance. For the security of the tokens generated by the library, this class attempts to at least have a secure implementation of getAuthKey.
A response with a status of Auth_OpenID_FAILURE. Indicates that the OpenID protocol has failed. This could be locally or remotely triggered. This has three relevant attributes:
Status code returned by the server when the only option is to show an error page, since we do not have enough information to redirect back to the consumer. The associated value is an error message that should be displayed on an HTML error page.
This is the status code beginAuth returns when the page fetched from the entered OpenID URL doesn't contain the necessary link tags to function as an identity page.
Status code returned when there is a redirect back to the consumer. The value is the URL to redirect back to. The caller should return a 302 Found redirect with a Location: header containing the URL.
Status code returned when there is an error to return in key-value form to the consumer. The caller should return a 400 Bad Request response with content-type text/plain and the value as the body.
Status code returned when there is a key-value form OK response to the consumer. The value associated with this code is the response. The caller should return a 200 OK response with content-type text/plain and the value as the body.
An error class which gets instantiated and returned whenever an OpenID protocol error occurs. Be prepared to use this in place of an ordinary server response.
A response with a status of Auth_OpenID_SETUP_NEEDED. Indicates that the request was in immediate mode, and the server is unable to authenticate the user without further interaction.
This is the status code completeAuth returns when the Auth_OpenID_Consumer instance is in immediate mode, and the identity server sends back a URL to send the user to to complete his or her login.
This should be called statically and will build a Yadis instance if the discovery process succeeds. This implements Yadis discovery as specified in the Yadis specification.
Encodes the response to key-value form. This is a machine-readable format used to respond to messages which came directly from the consumer and not through the user-agent. See the OpenID specification.
This method returns an Association object from storage that matches the server URL and, if specified, handle. It returns null if no such association is found or if the matching association is expired.
This method returns a key used to sign the tokens, to ensure that they haven't been tampered with in transit. It should return the same key every time it is called. The key returned should be AUTH_KEY_LEN bytes long.
Returns an HTTP fetcher object. If the CURL extension is present, an instance of Services_Yadis_ParanoidHTTPFetcher is returned. If not, an instance of Services_Yadis_PlainHTTPFetcher is returned.
This method must return true if the store is a dumb-mode-style store. Unlike all other methods in this class, this one provides a default implementation, which returns false.
Returns a new instance of this loader's class, using the session data to construct it if necessary. The object need only be created; $this->fromSession() will take care of setting the object's attributes.
Converts a query result to a boolean. If the result is a database error according to $this->isError(), this returns false; otherwise, this returns true.
Returns an instance of a Services_Yadis_XMLParser subclass based on the availability of PHP extensions for XML parsing. If Services_Yadis_setDefaultParser has been called, the parser used in that call will be returned instead.
The Yadis service manager which stores state in a session and iterates over <Service> elements in a Yadis XRDS document and lets a caller attempt to use each one. This is used by the Yadis library internally.
The base session class used by the Services_Yadis_Manager. This class wraps the default PHP session machinery and should be subclassed if your application doesn't use PHP sessioning.
Set a default parser to override the extension-driven selection of available parser classes. This is helpful in a test environment or one in which multiple parsers can be used but one is more desirable.
This is the core of the PHP Yadis library. This is the only class a user needs to use to perform Yadis discovery. This class performs the discovery AND stores the result of the discovery.
This method should be overridden by subclasses. This method is called by the constructor to set values in $this->sql, which is an array keyed on sql name.
Returns an array of keys and values built from the attributes of $obj. If $this->prepareForSave($obj) returns an array, its keys and values are used to update the $data array of attributes from $obj.
This method is called when the library is attempting to use a nonce. If the nonce is in the store, this method removes it and returns a value which evaluates as true. Otherwise it returns a value which evaluates as false.
This class represents an association between a server and a consumer. In general, users of this library will never see instances of this object. The only exception is if you implement a custom Auth_OpenID_OpenIDStore.
Status code returned when there were no OpenID arguments passed. This code indicates that the caller should return a 200 OK response and display an HTML page that says that this is an OpenID server endpoint.
Creates a new Auth_OpenID_DumbStore instance. For the security of the tokens generated by the library, this class attempts to at least have a secure implementation of getAuthKey.
This is a store for use in the worst case, when you have no way of saving state on the consumer site. Using this store makes the consumer vulnerable to replay attacks, as it's unable to use nonces. Avoid using this store if it is at all possible.
A response with a status of Auth_OpenID_FAILURE. Indicates that the OpenID protocol has failed. This could be locally or remotely triggered. This has three relevant attributes:
Status code returned by the server when the only option is to show an error page, since we do not have enough information to redirect back to the consumer. The associated value is an error message that should be displayed on an HTML error page.
This is the status code beginAuth returns when the page fetched from the entered OpenID URL doesn't contain the necessary link tags to function as an identity page.
Status code returned when there is a redirect back to the consumer. The value is the URL to redirect back to. The caller should return a 302 Found redirect with a Location: header containing the URL.
Status code returned when there is an error to return in key-value form to the consumer. The caller should return a 400 Bad Request response with content-type text/plain and the value as the body.
Status code returned when there is a key-value form OK response to the consumer. The value associated with this code is the response. The caller should return a 200 OK response with content-type text/plain and the value as the body.
An error class which gets instantiated and returned whenever an OpenID protocol error occurs. Be prepared to use this in place of an ordinary server response.
A response with a status of Auth_OpenID_SETUP_NEEDED. Indicates that the request was in immediate mode, and the server is unable to authenticate the user without further interaction.
This is the status code completeAuth returns when the Auth_OpenID_Consumer instance is in immediate mode, and the identity server sends back a URL to send the user to to complete his or her login.
Encodes the response to key-value form. This is a machine-readable format used to respond to messages which came directly from the consumer and not through the user-agent. See the OpenID specification.
This method returns an Association object from storage that matches the server URL and, if specified, handle. It returns null if no such association is found or if the matching association is expired.
This method returns a key used to sign the tokens, to ensure that they haven't been tampered with in transit. It should return the same key every time it is called. The key returned should be AUTH_KEY_LEN bytes long.
This method must return true if the store is a dumb-mode-style store. Unlike all other methods in this class, this one provides a default implementation, which returns false.
Converts a query result to a boolean. If the result is a database error according to $this->isError(), this returns false; otherwise, this returns true.
This method should be overridden by subclasses. This method is called by the constructor to set values in $this->sql, which is an array keyed on sql name.
This method is called when the library is attempting to use a nonce. If the nonce is in the store, this method removes it and returns a value which evaluates as true. Otherwise it returns a value which evaluates as false.
This should be called statically and will build a Yadis instance if the discovery process succeeds. This implements Yadis discovery as specified in the Yadis specification.
Returns an HTTP fetcher object. If the CURL extension is present, an instance of Services_Yadis_ParanoidHTTPFetcher is returned. If not, an instance of Services_Yadis_PlainHTTPFetcher is returned.
Returns a new instance of this loader's class, using the session data to construct it if necessary. The object need only be created; $this->fromSession() will take care of setting the object's attributes.
Returns an instance of a Services_Yadis_XMLParser subclass based on the availability of PHP extensions for XML parsing. If Services_Yadis_setDefaultParser has been called, the parser used in that call will be returned instead.
The Yadis service manager which stores state in a session and iterates over <Service> elements in a Yadis XRDS document and lets a caller attempt to use each one. This is used by the Yadis library internally.
The base session class used by the Services_Yadis_Manager. This class wraps the default PHP session machinery and should be subclassed if your application doesn't use PHP sessioning.
Set a default parser to override the extension-driven selection of available parser classes. This is helpful in a test environment or one in which multiple parsers can be used but one is more desirable.
This is the core of the PHP Yadis library. This is the only class a user needs to use to perform Yadis discovery. This class performs the discovery AND stores the result of the discovery.
Returns an array of keys and values built from the attributes of $obj. If $this->prepareForSave($obj) returns an array, its keys and values are used to update the $data array of attributes from $obj.
- a
- c
- d
- e
- f
- g
- i
- m
- n
- p
- r
- s
- t
- x
- y
-
-
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/doc/errors.html b/modules/member/php-openid-1.2.3/doc/errors.html
deleted file mode 100644
index a6162df2a..000000000
--- a/modules/member/php-openid-1.2.3/doc/errors.html
+++ /dev/null
@@ -1,35 +0,0 @@
-
-
-
-
-
- phpDocumentor Parser Errors and Warnings
-
-
-
-
-
Post-parsing
-Manager.php
-Server.php
-
-
Consumer.php
-
Warnings:
-Warning on line 402 - no @package tag was used in a DocBlock for class Auth_OpenID_DiffieHellmanConsumerSession
-Warning on line 451 - no @package tag was used in a DocBlock for class Auth_OpenID_PlainTextConsumerSession
-Warning on line 874 - method "Auth_OpenID_GenericConsumer::_createAssociateRequest()" is assumed to be @access private because its name starts with _, but has no @access tag
-
-
Manager.php
-
Warnings:
-Warning on line 73 - no @package tag was used in a DocBlock for class Services_Yadis_SessionLoader
-Warning on line 176 - no @package tag was used in a DocBlock for class Auth_OpenID_ServiceEndpointLoader
-Warning on line 198 - no @package tag was used in a DocBlock for class Services_Yadis_ManagerLoader
-
-
Server.php
-
Warnings:
-Warning on line 372 - no @package tag was used in a DocBlock for class Auth_OpenID_PlainTextServerSession
-Warning on line 390 - no @package tag was used in a DocBlock for class Auth_OpenID_DiffieHellmanServerSession
-
- Documentation generated on Mon, 10 Sep 2007 13:29:31 -0700 by phpDocumentor 1.3.2
-
-
-
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/doc/index.html b/modules/member/php-openid-1.2.3/doc/index.html
deleted file mode 100644
index 8361d1f57..000000000
--- a/modules/member/php-openid-1.2.3/doc/index.html
+++ /dev/null
@@ -1,24 +0,0 @@
-
-
-
-
-
- JanRain OpenID Library
-
-
-
-
-
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/doc/li_OpenID.html b/modules/member/php-openid-1.2.3/doc/li_OpenID.html
deleted file mode 100644
index 4ac40e0a0..000000000
--- a/modules/member/php-openid-1.2.3/doc/li_OpenID.html
+++ /dev/null
@@ -1,90 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/examples/README b/modules/member/php-openid-1.2.3/examples/README
deleted file mode 100644
index b6cbb67be..000000000
--- a/modules/member/php-openid-1.2.3/examples/README
+++ /dev/null
@@ -1,122 +0,0 @@
-OpenID Example Code
--------------------
-
-After you've installed this package (see ../README), you can use these
-example packages to get started. They'll show you what this package
-can do, and you can use them as the basis for your own OpenID support.
-
-consumer/: OpenID Example Consumer
-==================================
-
-NOTE: If you want to try the example consumer without installing this
-package, just make sure you add the package's 'Auth' directory to your
-PHP include path.
-
-To try the example consumer implementation, just copy the consumer/
-directory into a place on your web server and point your browser at
-the new directory.
-
-1. Check to be sure that /tmp is in your "open_basedir" configuration,
- if open_basedir is being used to restrict PHP's file I/O. See
- http://us2.php.net/features.safe-mode for more information. For
- example, in your php.ini, change
-
- open_basedir = "..."
-
- to
-
- open_basedir = "/tmp:..."
-
- (If you really don't want to add /tmp to your open_basedir, you can
- modify consumer/common.php and change $store_path so it doesn't
- create the store directory in /tmp.)
-
-2. Copy or symlink the consumer/ directory into a part of your
- webserver's docroot. For example, if your DocumentRoot is
- /var/www/, do this:
-
- # cd /var/www
- # ln -s /path/to/PHP-OpenID-X.Y.Z/examples/consumer
-
-3. Navigate to http://www.example.com/consumer and enter an OpenID
- into the form presented there and click "Verify".
-
-consumer/ Files
-===============
-
-The 'index.php' file will render a form and get you started. These
-are the example consumer files:
-
- consumer/index.php - Renders a form so you can begin the OpenID auth
-process. The form submits the OpenID to try_auth.php.
-
- consumer/try_auth.php - Starts the authentication with the OpenID
-server that manages your OpenID and redirects your browser to the
-server's login page. Instructs the server to return to
-finish_auth.php when you're done authenticating.
-
- consumer/finish_auth.php - Finishes the authentication by checking
-the server's response. Tells you if the authentication was
-successful.
-
- consumer/common.php - Includes the setup code you'll need to create
-a Consumer object and participate in an OpenID authentication.
-
-server/: OpenID Example Server
-==============================
-
-To try the example server, follow these steps:
-
-1. Customize server/config.php based on what your PHP installation
- supports. The documentation in the file describes what each value
- is for.
-
-2. Copy or symlink the server/ directory into a part of your
- webserver's docroot. For example, if your DocumentRoot is
- /var/www/, do this:
-
- # cd /var/www
- # ln -s /path/to/PHP-OpenID-X.Y.Z/examples/server
-
-3. For each of the identity URLs you added to the $openid_users array
- in config.php, add the following to the tag of the pages at
- those URLs:
-
-
-
- Where "www.example.com/server" is the path to the server symlink
- that you created in step (2).
-
-4. Navigate to http://www.example.com/server and click the "Log In"
- link to test the OpenID(s) entered into the config file.
-
-5. Use the OpenID checkup tool to try authenticating with your OpenID:
-
- http://www.openidenabled.com/resources/openid-test/checkup
-
- If your OpenID server isn't on the public internet, you can use the
- example consumer packaged with this library. See the consumer
- section above.
-
-server/ Files
-=============
-
-These files make up the server example code:
-
- config.php - The configuration file you'll need to customize to run
-the example server.
-
- server.php - The PHP rendering script that takes care of handling
-server requests from both regular user agents and consumers.
-
- lib/actions.php - Handles the various types of requests that the
-server supports.
-
- lib/common.php - Supplies functions that wrap the OpenID API calls
-to make them easier to use.
-
- lib/render.php - Miscellaneous page rendering code.
-
- lib/session.php - Code to handle session data for user settings.
-
- lib/render/*.php - Files for each page presented by the server.
diff --git a/modules/member/php-openid-1.2.3/examples/consumer/common.php b/modules/member/php-openid-1.2.3/examples/consumer/common.php
deleted file mode 100644
index cecf8d757..000000000
--- a/modules/member/php-openid-1.2.3/examples/consumer/common.php
+++ /dev/null
@@ -1,41 +0,0 @@
-
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/examples/consumer/finish_auth.php b/modules/member/php-openid-1.2.3/examples/consumer/finish_auth.php
deleted file mode 100644
index bee574361..000000000
--- a/modules/member/php-openid-1.2.3/examples/consumer/finish_auth.php
+++ /dev/null
@@ -1,38 +0,0 @@
-complete($_GET);
-
-if ($response->status == Auth_OpenID_CANCEL) {
- // This means the authentication was cancelled.
- $msg = 'Verification cancelled.';
-} else if ($response->status == Auth_OpenID_FAILURE) {
- $msg = "OpenID authentication failed: " . $response->message;
-} else if ($response->status == Auth_OpenID_SUCCESS) {
- // This means the authentication succeeded.
- $openid = $response->identity_url;
- $esc_identity = htmlspecialchars($openid, ENT_QUOTES);
- $success = sprintf('You have successfully verified ' .
- '%s as your identity.',
- $esc_identity, $esc_identity);
-
- if ($response->endpoint->canonicalID) {
- $success .= ' (XRI CanonicalID: '.$response->endpoint->canonicalID.') ';
- }
-
- $sreg = $response->extensionResponse('sreg');
-
- if (@$sreg['email']) {
- $success .= " You also returned '".$sreg['email']."' as your email.";
- }
- if (@$sreg['postcode']) {
- $success .= " Your postal code is '".$sreg['postcode']."'";
- }
-}
-
-include 'index.php';
-
-?>
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/examples/consumer/index.php b/modules/member/php-openid-1.2.3/examples/consumer/index.php
deleted file mode 100644
index 4096dedeb..000000000
--- a/modules/member/php-openid-1.2.3/examples/consumer/index.php
+++ /dev/null
@@ -1,59 +0,0 @@
-
- PHP OpenID Authentication Example
-
-
-
PHP OpenID Authentication Example
-
- This example consumer uses the PHP
- OpenID library. It just verifies that the URL that you enter
- is your identity URL.
-
\n";
- }
- $out .= "\n";
- return $out;
- }
-
- function h($text, $n)
- {
- return "$text\n";
- }
-
- function h2($text)
- {
- return $this->h($text, 2);
- }
-
- function h1($text)
- {
- return $this->h($text, 1);
- }
-
- function link($href, $text=null)
- {
- return '' . ($text ? $text : $href) . '';
- }
-
- function end()
- {
- return "\n\n";
- }
-}
-
-if (isset($_SERVER['REQUEST_METHOD'])) {
- $r = new HTML();
-} else {
- $r = new PlainText();
-}
-
-function detect_math($r, &$out)
-{
- global $_Auth_OpenID_math_extensions;
- $out .= $r->h2('Math support');
- $ext = Auth_OpenID_detectMathLibrary($_Auth_OpenID_math_extensions);
- if (!isset($ext['extension']) || !isset($ext['class'])) {
- $out .= $r->p(
- 'Your PHP installation does not include big integer math ' .
- 'support. This support is required if you wish to run a ' .
- 'secure OpenID server without using SSL.');
- $out .= $r->p('To use this library, you have a few options:');
-
- $gmp_lnk = $r->link('http://www.php.net/manual/en/ref.gmp.php', 'GMP');
- $bc_lnk = $r->link('http://www.php.net/manual/en/ref.bc.php', 'bcmath');
- $out .= $r->ol(array(
- 'Install the ' . $gmp_lnk . ' PHP extension',
- 'Install the ' . $bc_lnk . ' PHP extension',
- 'If your site is low-security, define ' .
- 'Auth_OpenID_NO_MATH_SUPPORT. The library will function, but ' .
- 'the security of your OpenID server will depend on the ' .
- 'security of the network links involved. If you are only ' .
- 'using consumer support, you should still be able to operate ' .
- 'securely when the users are communicating with a ' .
- 'well-implemented server.'));
- return false;
- } else {
- switch ($ext['extension']) {
- case 'bcmath':
- $out .= $r->p('Your PHP installation has bcmath support. This is ' .
- 'adequate for small-scale use, but can be CPU-intensive. ' .
- 'You may want to look into installing the GMP extension.');
- $lnk = $r->link('http://www.php.net/manual/en/ref.gmp.php');
- $out .= $r->p('See ' . $lnk .' for more information ' .
- 'about the GMP extension.');
- break;
- case 'gmp':
- $out .= $r->p('Your PHP installation has gmp support. Good.');
- break;
- default:
- $class = $ext['class'];
- $lib = new $class();
- $one = $lib->init(1);
- $two = $lib->add($one, $one);
- $t = $lib->toString($two);
- $out .= $r->p('Uh-oh. I do not know about the ' .
- $ext['extension'] . ' extension!');
- if ($t != '2') {
- $out .= $r->p('It looks like it is broken. 1 + 1 = ' .
- var_export($t, false));
- return false;
- } else {
- $out .= $r->p('But it seems to be able to add one and one.');
- }
- }
- return true; // Math library is OK
- }
-}
-
-function detect_random($r, &$out)
-{
- $out .= $r->h2('Cryptographic-quality randomness source');
- if (Auth_OpenID_RAND_SOURCE === null) {
- $out .= $r->p('Using (insecure) pseudorandom number source, because ' .
- 'Auth_OpenID_RAND_SOURCE has been defined as null.');
- return false;
- }
-
- $msg = 'The library will try to access ' . Auth_OpenID_RAND_SOURCE
- . ' as a source of random data. ';
-
- $numbytes = 6;
-
- $f = @fopen(Auth_OpenID_RAND_SOURCE, 'r');
- if ($f !== false) {
- $data = fread($f, $numbytes);
- $stat = fstat($f);
- $size = $stat['size'];
- fclose($f);
- } else {
- $data = null;
- $size = true;
- }
-
- if ($f !== false) {
- $dataok = (strlen($data) == $numbytes);
- $ok = $dataok && !$size;
- $msg .= 'It seems to exist ';
- if ($dataok) {
- $msg .= 'and be readable. Here is some hex data: ' .
- bin2hex($data) . '.';
- } else {
- $msg .= 'but reading data failed.';
- }
- if ($size) {
- $msg .= ' This is a ' . $size . ' byte file. Unless you know ' .
- 'what you are doing, it is likely that you are making a ' .
- 'mistake by using a regular file as a randomness source.';
- }
- } else {
- $msg .= Auth_OpenID_RAND_SOURCE .
- ' could not be opened. This could be because of restrictions on' .
- ' your PHP environment or that randomness source may not exist' .
- ' on this platform.';
- if (IS_WINDOWS) {
- $msg .= ' You seem to be running Windows. This library does not' .
- ' have access to a good source of randomness on Windows.';
- }
- $ok = false;
- }
-
- $out .= $r->p($msg);
-
- if (!$ok) {
- $out .= $r->p(
- 'To set a source of randomness, define Auth_OpenID_RAND_SOURCE ' .
- 'to the path to the randomness source. If your platform does ' .
- 'not provide a secure randomness source, the library can' .
- 'operate in pseudorandom mode, but it is then vulnerable to ' .
- 'theoretical attacks. If you wish to operate in pseudorandom ' .
- 'mode, define Auth_OpenID_RAND_SOURCE to null.');
- $out .= $r->p('You are running on:');
- $out .= $r->pre(php_uname());
- $out .= $r->p('There does not seem to be an available source ' .
- 'of randomness. On a Unix-like platform ' .
- '(including MacOS X), try /dev/random and ' .
- '/dev/urandom.');
- }
- return $ok;
-}
-
-function detect_stores($r, &$out)
-{
- $out .= $r->h2('Data storage');
-
- $found = array();
- foreach (array('sqlite', 'mysql', 'pgsql') as $dbext) {
- if (extension_loaded($dbext) || @dl($dbext . '.' . PHP_SHLIB_SUFFIX)) {
- $found[] = $dbext;
- }
- }
- if (count($found) == 0) {
- $text = 'No SQL database support was found in this PHP ' .
- 'installation. See the PHP manual if you need to ' .
- 'use an SQL database.';
- } else {
- $text = 'Support was found for ';
- if (count($found) == 1) {
- $text .= $found[0] . '.';
- } else {
- $last = array_pop($found);
- $text .= implode(', ', $found) . ' and ' . $last . '.';
- }
- $text = $r->b($text);
- }
- $text .= ' The library supports the MySQL, PostgreSQL, and SQLite ' .
- 'database engines, as well as filesystem-based storage.';
- $out .= $r->p($text);
-
- if (function_exists('posix_getpwuid') &&
- function_exists('posix_geteuid')) {
- $processUser = posix_getpwuid(posix_geteuid());
- $web_user = $r->b($r->tt($processUser['name']));
- } else {
- $web_user = 'the PHP process';
- }
-
- if (in_array('sqlite', $found)) {
- $out .= $r->p('If you are using SQLite, your database must be ' .
- 'writable by ' . $web_user . ' and not available over' .
- ' the web.');
- }
-
- $basedir_str = ini_get('open_basedir');
- if (gettype($basedir_str) == 'string') {
- $url = 'http://www.php.net/manual/en/features.safe-mode.php' .
- '#ini.open-basedir';
- $lnk = $r->link($url, 'open_basedir');
- $out .= $r->p('If you are using a filesystem-based store or SQLite, ' .
- 'be aware that ' . $lnk . ' is in effect. This means ' .
- 'that your data will have to be stored in one of the ' .
- 'following locations:');
- $out .= $r->pre(var_export($basedir_str, true));
- } else {
- $out .= $r->p('The ' . $r->b($r->tt('open_basedir')) . ' configuration restriction ' .
- 'is not in effect.');
- }
-
- $out .= $r->p('If you are using the filesystem store, your ' .
- 'data directory must be readable and writable by ' .
- $web_user . ' and not availabe over the Web.');
- return true;
-}
-
-function detect_xml($r, &$out)
-{
- global $__Services_Yadis_xml_extensions;
-
- $out .= $r->h2('XML Support');
-
- // Try to get an XML extension.
- $ext = Services_Yadis_getXMLParser();
-
- if ($ext !== null) {
- $out .= $r->p('XML parsing support is present using the '.
- $r->b(get_class($ext)).' interface.');
- return true;
- } else {
- $out .= $r->p('XML parsing support is absent; please install one '.
- 'of the following PHP extensions:');
- foreach ($__Services_Yadis_xml_extensions as $name => $cls) {
- $out .= "
" . $r->b($name) . "
";
- }
- return false;
- }
-}
-
-function detect_fetcher($r, &$out)
-{
- $out .= $r->h2('HTTP Fetching');
-
- $result = @include 'Services/Yadis/Yadis.php';
-
- if (!$result) {
- $out .= $r->p('Yadis code unavailable; could not test fetcher support.');
- return false;
- }
-
- if (Services_Yadis_Yadis::curlPresent()) {
- $out .= $r->p('This PHP installation has support for libcurl. Good.');
- } else {
- $out .= $r->p('This PHP installation does not have support for ' .
- 'libcurl. CURL is not required, but some functionality, ' .
- 'such as fetching HTTPS URLs, will be missing and ' .
- ' performance will not be as good.');
- $lnk = $r->link('http://us3.php.net/manual/en/ref.curl.php');
- $out .= $r->p('See ' . $lnk . ' about enabling the libcurl support ' .
- 'for PHP.');
- }
-
- $ok = true;
- $fetcher = Services_Yadis_Yadis::getHTTPFetcher();
- $fetch_url = 'http://www.openidenabled.com/resources/php-fetch-test';
- $expected_url = $fetch_url . '.txt';
- $result = $fetcher->get($fetch_url);
-
- if (isset($result)) {
- $parts = array('An HTTP request was completed.');
- // list ($code, $url, $data) = $result;
- if ($result->status != '200') {
- $ok = false;
- $parts[] = $r->b(
- sprintf('Got %s instead of the expected HTTP status code ' .
- '(200).', $result->status));
- }
-
- $url = $result->final_url;
- if ($url != $expected_url) {
- $ok = false;
- if ($url == $fetch_url) {
- $msg = 'The redirected URL was not returned.';
- } else {
- $msg = 'An unexpected URL was returned: <' . $url . '>.';
- }
- $parts[] = $r->b($msg);
- }
-
- $data = $result->body;
- if ($data != 'Hello World!') {
- $ok = false;
- $parts[] = $r->b('Unexpected data was returned.');
- }
- $out .= $r->p(implode(' ', $parts));
- } else {
- $ok = false;
- $out .= $r->p('Fetching URL ' . $lnk . ' failed!');
- }
- return $ok;
-}
-
-header('Content-Type: ' . $r->contentType() . '; charset=us-ascii');
-
-$title = 'OpenID Library Support Report';
-$out = $r->start($title) .
- $r->h1($title) .
- $r->p('This script checks your PHP installation to determine if you ' .
- 'are set up to use the JanRain PHP OpenID library.');
-
-$body = '';
-
-$_include = include 'Auth/OpenID.php';
-
-if (!$_include) {
- $path = ini_get('include_path');
- $body .= $r->p(
- 'Cannot find the OpenID library. It must be in your PHP include ' .
- 'path. Your PHP include path is currently:');
- $body .= $r->pre($path);
-} else {
- $status = array();
-
- $status[] = detect_math($r, $body);
- $status[] = detect_random($r, $body);
- $status[] = detect_stores($r, $body);
- $status[] = detect_fetcher($r, $body);
- $status[] = detect_xml($r, $body);
-
- $result = true;
-
- foreach ($status as $v) {
- if (!$v) {
- $result = false;
- break;
- }
- }
-
- if ($result) {
- $out .= $r->h2('Setup Complete!');
- $out .= $r->p('Your system should be ready to run the OpenID library.');
- } else {
- $out .= $r->h2('Setup Incomplete');
- $out .= $r->p('Your system needs a few changes before it will be ready to run the OpenID library.');
- }
-}
-
-$out .= $body . $r->end();
-print $out;
-?>
diff --git a/modules/member/php-openid-1.2.3/examples/server/index.php b/modules/member/php-openid-1.2.3/examples/server/index.php
deleted file mode 100644
index 7a9506458..000000000
--- a/modules/member/php-openid-1.2.3/examples/server/index.php
+++ /dev/null
@@ -1,5 +0,0 @@
-
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/examples/server/lib/actions.php b/modules/member/php-openid-1.2.3/examples/server/lib/actions.php
deleted file mode 100644
index 5e255e2d8..000000000
--- a/modules/member/php-openid-1.2.3/examples/server/lib/actions.php
+++ /dev/null
@@ -1,169 +0,0 @@
-decodeRequest($request);
-
- if (!$request) {
- return about_render();
- }
-
- setRequestInfo($request);
-
- if (in_array($request->mode,
- array('checkid_immediate', 'checkid_setup'))) {
-
- if (isTrusted($request->identity, $request->trust_root)) {
- $response =& $request->answer(true);
- $sreg = getSreg($request->identity);
- if (is_array($sreg)) {
- foreach ($sreg as $k => $v) {
- $response->addField('sreg', $k,
- $v);
- }
- }
- } else if ($request->immediate) {
- $response =& $request->answer(false, getServerURL());
- } else {
- if (!getLoggedInUser()) {
- return login_render();
- }
- return trust_render($request);
- }
- } else {
- $response =& $server->handleRequest($request);
- }
-
- $webresponse =& $server->encodeResponse($response);
-
- foreach ($webresponse->headers as $k => $v) {
- header("$k: $v");
- }
-
- header(header_connection_close);
- print $webresponse->body;
- exit(0);
-}
-
-/**
- * Log out the currently logged in user
- */
-function action_logout()
-{
- setLoggedInUser(null);
- setRequestInfo(null);
- return authCancel(null);
-}
-
-/**
- * Check the input values for a login request
- */
-function login_checkInput($input)
-{
- $openid_url = false;
- $errors = array();
-
- if (!isset($input['openid_url'])) {
- $errors[] = 'Enter an OpenID URL to continue';
- }
- if (!isset($input['password'])) {
- $errors[] = 'Enter a password to continue';
- }
- if (count($errors) == 0) {
- $openid_url = $input['openid_url'];
- $openid_url = Auth_OpenID::normalizeUrl($openid_url);
- $password = $input['password'];
- if (!checkLogin($openid_url, $password)) {
- $errors[] = 'The entered password does not match the ' .
- 'entered identity URL.';
- }
- }
- return array($errors, $openid_url);
-}
-
-/**
- * Log in a user and potentially continue the requested identity approval
- */
-function action_login()
-{
- $method = $_SERVER['REQUEST_METHOD'];
- switch ($method) {
- case 'GET':
- return login_render();
- case 'POST':
- $info = getRequestInfo();
- $fields = $_POST;
- if (isset($fields['cancel'])) {
- return authCancel($info);
- }
-
- list ($errors, $openid_url) = login_checkInput($fields);
- if (count($errors) || !$openid_url) {
- $needed = $info ? $info->identity : false;
- return login_render($errors, @$fields['openid_url'], $needed);
- } else {
- setLoggedInUser($openid_url);
- return doAuth($info);
- }
- default:
- return login_render(array('Unsupported HTTP method: $method'));
- }
-}
-
-/**
- * Ask the user whether he wants to trust this site
- */
-function action_trust()
-{
- $info = getRequestInfo();
- $trusted = isset($_POST['trust']);
- if ($info && isset($_POST['remember'])) {
- $sites = getSessionSites();
- $sites[$info->trust_root] = $trusted;
- setSessionSites($sites);
- }
- return doAuth($info, $trusted, true);
-}
-
-function action_sites()
-{
- $sites = getSessionSites();
- if ($_SERVER['REQUEST_METHOD'] == 'POST') {
- if (isset($_POST['forget'])) {
- $sites = null;
- setSessionSites($sites);
- } elseif (isset($_POST['remove'])) {
- foreach ($_POST as $k => $v) {
- if (preg_match('/^site[0-9]+$/', $k) && isset($sites[$v])) {
- unset($sites[$v]);
- }
- }
- setSessionSites($sites);
- }
- }
- return sites_render($sites);
-}
-
-?>
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/examples/server/lib/common.php b/modules/member/php-openid-1.2.3/examples/server/lib/common.php
deleted file mode 100644
index 4bc1dac77..000000000
--- a/modules/member/php-openid-1.2.3/examples/server/lib/common.php
+++ /dev/null
@@ -1,63 +0,0 @@
-getCancelURL();
- } else {
- $url = getServerURL();
- }
- return redirect_render($url);
-}
-
-function doAuth($info, $trusted=null, $fail_cancels=false)
-{
- if (!$info) {
- // There is no authentication information, so bail
- return authCancel(null);
- }
-
- $req_url = $info->identity;
- $user = getLoggedInUser();
- setRequestInfo($info);
-
- if ($req_url != $user) {
- return login_render(array(), $req_url, $req_url);
- }
-
- $sites = getSessionSites();
- $trust_root = $info->trust_root;
- $fail_cancels = $fail_cancels || isset($sites[$trust_root]);
- $trusted = isset($trusted) ? $trusted : isTrusted($req_url, $trust_root);
- if ($trusted) {
- setRequestInfo();
- $server =& getServer();
- $response =& $info->answer(true);
- $webresponse =& $server->encodeResponse($response);
-
- $new_headers = array();
-
- foreach ($webresponse->headers as $k => $v) {
- $new_headers[] = $k.": ".$v;
- }
-
- return array($new_headers, $webresponse->body);
- } elseif ($fail_cancels) {
- return authCancel($info);
- } else {
- return trust_render($info);
- }
-}
-
-?>
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/examples/server/lib/render.php b/modules/member/php-openid-1.2.3/examples/server/lib/render.php
deleted file mode 100644
index f607f90aa..000000000
--- a/modules/member/php-openid-1.2.3/examples/server/lib/render.php
+++ /dev/null
@@ -1,112 +0,0 @@
-
-
- %s
-%s
-
-
- %s
-
-
%s
- %s
-
-
-');
-
-define('logged_in_pat', 'You are logged in as %s.');
-
-/**
- * HTTP response line contstants
- */
-define('http_bad_request', 'HTTP/1.1 400 Bad Request');
-define('http_found', 'HTTP/1.1 302 Found');
-define('http_ok', 'HTTP/1.1 200 OK');
-define('http_internal_error', 'HTTP/1.1 500 Internal Error');
-
-/**
- * HTTP header constants
- */
-define('header_connection_close', 'Connection: close');
-define('header_content_text', 'Content-Type: text/plain; charset=us-ascii');
-
-define('redirect_message',
- 'Please wait; you are being redirected to <%s>');
-
-
-/**
- * Return a string containing an anchor tag containing the given URL
- *
- * The URL does not need to be quoted, but if text is passed in, then
- * it does.
- */
-function link_render($url, $text=null) {
- $esc_url = htmlspecialchars($url, ENT_QUOTES);
- $text = ($text === null) ? $esc_url : $text;
- return sprintf('%s', $esc_url, $text);
-}
-
-/**
- * Return an HTTP redirect response
- */
-function redirect_render($redir_url)
-{
- $headers = array(http_found,
- header_content_text,
- header_connection_close,
- 'Location: ' . $redir_url,
- );
- $body = sprintf(redirect_message, $redir_url);
- return array($headers, $body);
-}
-
-function navigation_render($msg, $items)
-{
- $what = link_render(buildURL(), 'PHP OpenID Server');
- if ($msg) {
- $what .= ' — ' . $msg;
- }
- if ($items) {
- $s = '
- This is an OpenID server
- endpoint. This server is built on the JanRain PHP OpenID
- library. Since OpenID consumer sites will need to directly contact this
- server, it must be accessible over the Internet (not behind a firewall).
-
-
- To use this server, you will have to set up a URL to use as an identifier.
- Insert the following markup into the <head> of the HTML
- document at that URL:
-
-
<link rel="openid.server" href="%s" />
-
- Then configure this server so that you can log in with that URL. Once you
- have configured the server, and marked up your identity URL, you can verify
- that it is working by using the openidenabled.com
- OpenID
- Checkup tool:
-
-
-');
-
-/**
- * Render the about page, potentially with an error message
- */
-function about_render($error=false, $internal=true)
-{
- $headers = array();
- $body = sprintf(about_body, buildURL());
- if ($error) {
- $headers[] = $internal ? http_internal_error : http_bad_request;
- $body .= sprintf(about_error_template, htmlspecialchars($error));
- }
- $current_user = getLoggedInUser();
- return page_render($body, $current_user, 'OpenID Server Endpoint');
-}
-
-?>
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/examples/server/lib/render/login.php b/modules/member/php-openid-1.2.3/examples/server/lib/render/login.php
deleted file mode 100644
index 9e8f37072..000000000
--- a/modules/member/php-openid-1.2.3/examples/server/lib/render/login.php
+++ /dev/null
@@ -1,65 +0,0 @@
-
-
- Enter your identity URL and password into this form to log in to
- this server. This server must be configured to accept your identity URL.
-
\n", $text);
-}
-?>
\ No newline at end of file
diff --git a/modules/member/php-openid-1.2.3/examples/server/lib/render/sites.php b/modules/member/php-openid-1.2.3/examples/server/lib/render/sites.php
deleted file mode 100644
index 90b557f97..000000000
--- a/modules/member/php-openid-1.2.3/examples/server/lib/render/sites.php
+++ /dev/null
@@ -1,83 +0,0 @@
-These decisions have been remembered for this session. All decisions
-will be forgotten when the session ends.
-
-
-
-');
-
-define('sites_empty_message',
- '
- No sites are remembered for this session. When you authenticate with a site,
- you can choose to add it to this list by choosing Remember this
- decision.
-
-Your browser has been redirected to this page so you can configure the
-server example. This form will auto-generate an OpenID example server
-configuration for use with the OpenID server example.
-
-
-
-/**
- * Set any extra include paths needed to use the library
- */
-set_include_path(get_include_path() . PATH_SEPARATOR . "");
-
-
-/**
- * The URL for the server.
- *
- * This is the location of server.php. For example:
- *
- * $server_url = 'http://example.com/~user/server.php';
- *
- * This must be a full URL.
- */
-$server_url = "";
-
-/**
- * Initialize an OpenID store
- *
- * @return object $store an instance of OpenID store (see the
- * documentation for how to create one)
- */
-function getOpenIDStore()
-{
- require_once 'Auth/OpenID/MySQLStore.php';
- require_once 'DB.php';
-
- $dsn = array(
- 'phptype' => 'mysql',
- 'username' => '',
- 'password' => '',
- 'hostspec' => ''
- );
-
- $db =& DB::connect($dsn);
-
- if (PEAR::isError($db)) {
- return null;
- }
-
- $db->query("USE ");
-
- return new Auth_OpenID_MySQLStore($db);
-require_once 'Auth/OpenID/PostgreSQLStore.php';
- require_once 'DB.php';
-
- $dsn = array(
- 'phptype' => 'pgsql',
- 'username' => '',
- 'password' => '',
- 'hostspec' => '',
- 'database' => ''
- );
-
- $db =& DB::connect($dsn);
-
- if (PEAR::isError($db)) {
- return null;
- }
-
- return new Auth_OpenID_PostgreSQLStore($db);
-
-}
-
-/**
- * Users who are allowed to log in to this OpenID server.
- *
- * This is an array from URL to password hash. The URL must include
- * the proper OpenID server information in order to work with this
- * server.
- *
- * This must be set for the server to be usable. If it is not set, no
- * users will be able to log in.
- *
- * Example:
- * $openid_users = array(
- * 'http://joe.example.com/' => sha1('foo')
- * )
- */
-$openid_users = array( $hash) {
- $i++;
- print "\n '$url' => '$hash'";
- if ($i < count($_SESSION['users'])) {
- print ",";
- }
-}
-?>
-
-);
-
-/**
- * Trusted sites is an array of trust roots.
- *
- * Sites in this list will not have to be approved by the user in
- * order to be used. It is OK to leave this value as-is.
- *
- * In a more robust server, this should be a per-user setting.
- */
-$trusted_sites = array(
-
-);
-
-