Merge pull request #3075 from sebastiendu/16484-Cassification-de-Chamilo
Add better CAS connector and scripts - refs BT#16484pull/3090/head
Yannick Warnier
6 years ago
committed by
GitHub
commit
0ff80c0525
@ -0,0 +1,331 @@ |
||||
<?php |
||||
/* For licensing terms, see /license.txt */ |
||||
/* |
||||
User account CASification interactive script |
||||
|
||||
to move user accounts from LDAP authentication to CAS authentication |
||||
|
||||
Creates the "cas_user" extra field if missing, then for each registred user: |
||||
- copies over the right CAS identifier to the "cas_user" extra field |
||||
- ensures the "username" is spelled right |
||||
- updates the "auth_source". |
||||
|
||||
This script should be run from a terminal. |
||||
It does not read any parameter from the command line, but uses the global configuration arrays |
||||
$extldap_config |
||||
and |
||||
$extldap_user_correspondance |
||||
defined in app/config/auth.conf.php. |
||||
|
||||
The username is used to search the LDAP directory, in both attributes |
||||
$extldap_user_correspondance['username'] |
||||
and |
||||
$extldap_user_correspondance['extra']['cas_user']. |
||||
|
||||
Any user account with no match or more than one matches in the LDAP directory is skipped. |
||||
|
||||
All the corrections are only applied in phase 2, and take time. |
||||
|
||||
Phase 1 only builds a TO-DO list. |
||||
|
||||
Phase 2 starts with the script asking the operator confirmation for each modification category: |
||||
- fix usernames |
||||
- add missing CAS identifiers |
||||
- fix wrong CAS identifiers |
||||
- fix auth source |
||||
|
||||
Planned modifications and progress are displayed. |
||||
|
||||
Diagnostics and modifications can be saved using command script(1). |
||||
|
||||
This script does not need to be run more than once, |
||||
but can be run several times. |
||||
In case phase 2 is stopped before the end, one should run this script again. |
||||
If this script is run after all user accounts were CASified, it just stops after Phase 1. |
||||
This can be used to check whether no work is left to do. |
||||
*/ |
||||
if (php_sapi_name() !== 'cli') { |
||||
die("this script is supposed to be run from the command-line\n"); |
||||
} |
||||
require __DIR__.'/../../cli-config.php'; |
||||
require_once __DIR__.'/../../app/config/auth.conf.php'; |
||||
require_once __DIR__.'/../../main/inc/lib/api.lib.php'; |
||||
require_once __DIR__.'/../../main/inc/lib/database.constants.inc.php'; |
||||
require_once __DIR__.'/../../main/inc/lib/internationalization.lib.php'; |
||||
require_once __DIR__.'/../../main/inc/lib/text.lib.php'; |
||||
|
||||
|
||||
// Bind to LDAP server |
||||
|
||||
$ldap = false; |
||||
foreach ($extldap_config['host'] as $ldapHost) { |
||||
$ldap = array_key_exists('port', $extldap_config) |
||||
? ldap_connect($ldapHost, $extldap_config['port']) |
||||
: ldap_connect($ldapHost); |
||||
if (false !== $ldap) { |
||||
break; |
||||
} |
||||
} |
||||
if (false === $ldap) { |
||||
die("ldap_connect() failed\n"); |
||||
} |
||||
print "Connected to LDAP server $ldapHost.\n"; |
||||
|
||||
ldap_set_option( |
||||
$ldap, |
||||
LDAP_OPT_PROTOCOL_VERSION, |
||||
array_key_exists('protocol_version', $extldap_config) ? $extldap_config['protocol_version'] : 2 |
||||
); |
||||
|
||||
ldap_set_option( |
||||
$ldap, |
||||
LDAP_OPT_REFERRALS, |
||||
array_key_exists('referrals', $extldap_config) ? $extldap_config['referrals'] : false |
||||
); |
||||
|
||||
ldap_bind($ldap, $extldap_config['admin_dn'], $extldap_config['admin_password']) |
||||
or die('ldap_bind() failed: '.ldap_error($ldap)."\n"); |
||||
print "Bound to LDAP server as ${extldap_config['admin_dn']}.\n"; |
||||
|
||||
|
||||
// set a few variables for LDAP search |
||||
|
||||
$baseDn = $extldap_config['base_dn'] |
||||
or die("cannot read the LDAP directory base DN where to search for user entries\n"); |
||||
print "Base DN is '$baseDn'.\n"; |
||||
|
||||
$ldapCASUserAttribute = $extldap_user_correspondance['extra']['cas_user'] |
||||
or die("cannot read the name of the LDAP attribute where to find the CAS user code\n"); |
||||
print "LDAP CAS user code attribute is '$ldapCASUserAttribute'.\n"; |
||||
|
||||
$ldapUsernameAttribute = $extldap_user_correspondance['username'] |
||||
or die("cannot read the name of the LDAP attribute where to find the username\n"); |
||||
print "LDAP username attribute is '$ldapUsernameAttribute'.\n"; |
||||
|
||||
$filters = [ |
||||
"$ldapCASUserAttribute=*", |
||||
"$ldapUsernameAttribute=*", |
||||
]; |
||||
if (array_key_exists('filter', $extldap_config)) { |
||||
$filters[] = $extldap_config['filter']; |
||||
} |
||||
|
||||
|
||||
// read 'cas_user' extra field id from internal database |
||||
|
||||
$extraField = new ExtraField('user'); |
||||
$extraFieldData = $extraField->get_handler_field_info_by_field_variable('cas_user'); |
||||
if (empty($extraFieldData)) { |
||||
if ('y' === readline("Create missing 'cas_user' extra field ? (type 'y' to confirm) ")) { |
||||
$fieldId = $extraField->save( |
||||
[ |
||||
'variable' => 'cas_user', |
||||
'field_type' => ExtraField::FIELD_TYPE_TEXT, |
||||
'visible_to_self' => true, |
||||
'filter' => true, |
||||
'display_text' => get_lang('CAS User Identifier'), |
||||
] |
||||
); |
||||
if (false === $fieldId) { |
||||
die("failed to create extra field\n"); |
||||
} |
||||
} else { |
||||
die("Required extra field is missing\n"); |
||||
} |
||||
} else { |
||||
$fieldId = $extraFieldData['id']; |
||||
} |
||||
print "'cas_user' extra field id is $fieldId.\n"; |
||||
|
||||
|
||||
// read cas_user extra field existing values as an associative array ( user id => CAS code ) |
||||
|
||||
$extraFieldValueModel = new ExtraFieldValue('user'); |
||||
$recordList = $extraFieldValueModel->getValuesByFieldId($fieldId); |
||||
$existingCasUserValues = []; |
||||
if (false !== $recordList) { |
||||
foreach ($recordList as $value) { |
||||
$existingCasUserValues[$value['item_id']] = $value['value']; |
||||
} |
||||
} |
||||
print count($existingCasUserValues)." users have their cas_user value set already.\n"; |
||||
|
||||
|
||||
// read all users from the internal database and check their LDAP CAS code to build a to-do list |
||||
|
||||
$userRepository = Database::getManager()->getRepository('ChamiloUserBundle:User'); |
||||
$databaseUsers = $userRepository->findAll(); |
||||
$count = count($databaseUsers); |
||||
print "$count users are registered in the internal database.\n"; |
||||
|
||||
$userNamesInUse = []; |
||||
foreach ($databaseUsers as $user) { |
||||
$userNamesInUse[$user->getUsername()] = $user->getId(); |
||||
} |
||||
|
||||
$missingCASCodes = []; |
||||
$wrongCASCodes = []; |
||||
$wrongUserNames = []; |
||||
$wrongAuthSources = []; |
||||
|
||||
$checked = 0; |
||||
foreach ($databaseUsers as $user) { |
||||
$username = $user->getUsername(); |
||||
print "Checked $checked / $count users - now checking '$username'…\r"; |
||||
$filter = '(&(' |
||||
.join( |
||||
')(', |
||||
array_merge($filters, ["|($ldapUsernameAttribute=$username)($ldapCASUserAttribute=$username)"]) |
||||
) |
||||
.'))'; |
||||
$searchResult = ldap_search($ldap, $baseDn, $filter, [$ldapCASUserAttribute, $ldapUsernameAttribute]); |
||||
if (false === $searchResult) { |
||||
die('ldap_search() failed: ' . ldap_error($ldap) . "\n"); |
||||
} |
||||
$userId = $user->getId(); |
||||
print "$username ($userId): "; |
||||
switch (ldap_count_entries($ldap, $searchResult)) { |
||||
case 0: |
||||
print "does not exist in the LDAP directory, skipping.\n"; |
||||
break; |
||||
case 1: |
||||
$entry = ldap_first_entry($ldap, $searchResult); |
||||
if (false === $entry) { |
||||
die('ldap_first_entry() failed: ' . ldap_error($ldap) . "\n"); |
||||
} |
||||
$ldapCASUser = ldap_get_values($ldap, $entry, $ldapCASUserAttribute)[0]; |
||||
if (false === $ldapCASUser) { |
||||
die('cannot read CAS user code from LDAP entry: ' . ldap_error($ldap) . "\n"); |
||||
} |
||||
$ldapUsername = ldap_get_values($ldap, $entry, $ldapUsernameAttribute)[0]; |
||||
if (false === $ldapUsername) { |
||||
die('cannot read username from LDAP entry: ' . ldap_error($ldap) . "\n"); |
||||
} |
||||
print "\033[2K\r$ldapUsernameAttribute: $ldapUsername, $ldapCASUserAttribute: $ldapCASUser, "; |
||||
$problems = []; |
||||
if ($username === $ldapUsername) { |
||||
true; // fine |
||||
} elseif (in_array( |
||||
strtolower(trim($username)), |
||||
[ strtolower(trim($ldapUsername)), strtolower(trim($ldapCASUser)) ] |
||||
)) { |
||||
if (array_key_exists($ldapUsername, $userNamesInUse)) { |
||||
print "wrong username but '$ldapUsername' is already taken, skipping.\n"; |
||||
break; |
||||
} else { |
||||
$problems[] = "wrong username"; |
||||
$wrongUserNames[$userId] = $ldapUsername; |
||||
$userNamesInUse[$ldapUsername] = $userId; |
||||
} |
||||
} else { |
||||
die("LDAP search result does not match username; our filter is wrong: $filter\n"); |
||||
} |
||||
if (array_key_exists($userId, $existingCasUserValues)) { |
||||
$currentValue = $existingCasUserValues[$userId]; |
||||
if ($currentValue !== $ldapCASUser) { |
||||
$problems[] = "wrong current CAS user code '$currentValue'"; |
||||
$wrongCASCodes[$userId] = $ldapCASUser; |
||||
} |
||||
} else { |
||||
$problems[] = "CAS user code missing in database"; |
||||
$missingCASCodes[$userId] = $ldapCASUser; |
||||
} |
||||
$currentAuthSource = $user->getAuthSource(); |
||||
if (CAS_AUTH_SOURCE !== $currentAuthSource) { |
||||
$problems[] = "wrong auth source '$currentAuthSource'"; |
||||
$wrongAuthSources[$userId] = true; |
||||
} |
||||
print (empty($problems) ? "ok\r" : (join(', ', $problems)."\n")); |
||||
break; |
||||
default: |
||||
print "more than 1 entries for username '$username' in the LDAP directory for user id=$userId, skipping.\n"; |
||||
} |
||||
$checked ++; |
||||
} |
||||
print "\033[2K\r"; |
||||
|
||||
|
||||
// ask for confirmation and write changes to the database |
||||
|
||||
$fixUsernames = ( |
||||
!empty($wrongUserNames) |
||||
&& |
||||
('y' === readline("Fix wrong user names for ".count($wrongUserNames)." users ? (type 'y' to confirm) ")) |
||||
); |
||||
if ($fixUsernames) { |
||||
print "I will fix user names.\n"; |
||||
} |
||||
|
||||
$fixMissingCASCodes = ( |
||||
!empty($missingCASCodes) |
||||
&& |
||||
('y' === readline("Fix missing CAS codes for ".count($missingCASCodes)." users ? (type 'y' to confirm) ")) |
||||
); |
||||
if ($fixMissingCASCodes) { |
||||
print "I will fix missing CAS codes.\n"; |
||||
} |
||||
|
||||
$fixWrongCASCodes = ( |
||||
!empty($wrongCASCodes) |
||||
&& |
||||
('y' === readline("Fix wrong CAS codes for ".count($wrongCASCodes)." users ? (type 'y' to confirm) ")) |
||||
); |
||||
if ($fixWrongCASCodes) { |
||||
print "I will fix wrong CAS codes.\n"; |
||||
} |
||||
|
||||
$fixWrongAuthSources = ( |
||||
!empty($wrongAuthSources) |
||||
&& |
||||
('y' === readline("Fix auth source for ".count($wrongAuthSources)." users ? (type 'y' to confirm) ")) |
||||
); |
||||
if ($fixWrongAuthSources) { |
||||
print "I will fix wrong authentication sources.\n"; |
||||
} |
||||
|
||||
if ($fixUsernames || $fixWrongAuthSources || $fixWrongCASCodes || $fixMissingCASCodes) { |
||||
$usersToFix = []; |
||||
foreach ($databaseUsers as $user) { |
||||
$userId = $user->getId(); |
||||
if ($fixUsernames && array_key_exists($userId, $wrongUserNames) |
||||
|| $fixWrongAuthSources && array_key_exists($userId, $wrongAuthSources) |
||||
|| $fixMissingCASCodes && array_key_exists($userId, $missingCASCodes) |
||||
|| $fixWrongCASCodes && array_key_exists($userId, $wrongCASCodes) |
||||
) { |
||||
$usersToFix[] = $user; |
||||
} |
||||
} |
||||
$fixCount = count($usersToFix); |
||||
print "Now fixing $fixCount out of $count database users…\n"; |
||||
$done = 0; |
||||
foreach ($usersToFix as $user) { |
||||
$userId = $user->getId(); |
||||
$dirty = false; |
||||
if ($fixUsernames && array_key_exists($userId, $wrongUserNames)) { |
||||
$user->setUsername($wrongUserNames[$userId]); |
||||
$dirty = true; |
||||
} |
||||
if ($fixWrongAuthSources && array_key_exists($userId, $wrongAuthSources)) { |
||||
$user->setAuthSource(CAS_AUTH_SOURCE); |
||||
$dirty = true; |
||||
} |
||||
if ($dirty) { |
||||
try { |
||||
UserManager::getManager()->save($user); |
||||
} catch (Exception $exception) { |
||||
print $exception->getMessage()."\n"; |
||||
die("Script stopped before the end.\n"); |
||||
} |
||||
} |
||||
if ($fixMissingCASCodes && array_key_exists($userId, $missingCASCodes)) { |
||||
UserManager::update_extra_field_value($userId, 'cas_user', $missingCASCodes[$userId]); |
||||
} elseif ($fixWrongCASCodes && array_key_exists($userId, $wrongCASCodes)) { |
||||
UserManager::update_extra_field_value($userId, 'cas_user', $wrongCASCodes[$userId]); |
||||
} |
||||
$done ++; |
||||
print "Fixed $done / $fixCount users\r"; |
||||
} |
||||
print "\n"; |
||||
} |
||||
|
||||
print "End of script.\n"; |
||||
@ -1,228 +0,0 @@ |
||||
<?php |
||||
/* Written by Noel Dieschburg <noel@cblue.be> for the paris5 university |
||||
|
||||
* Checks if the user is already logged in via the cas system |
||||
* Gets all the info via the ldap module (ldap has to work) |
||||
|
||||
*/ |
||||
require_once api_get_path(SYS_PATH).'main/auth/cas/cas_var.inc.php'; |
||||
require_once api_get_path(SYS_PATH).'main/auth/external_login/ldap.inc.php'; |
||||
require_once api_get_path(SYS_PATH).'main/auth/external_login/functions.inc.php'; |
||||
|
||||
/** |
||||
* @return true if cas is configured |
||||
*/ |
||||
function cas_configured() |
||||
{ |
||||
global $cas_auth_ver, $cas_auth_server, $cas_auth_port, $cas_auth_uri; |
||||
$res = false; |
||||
if (!empty($cas_auth_ver) && !empty($cas_auth_server) && !empty($cas_auth_port)) { |
||||
$res = true; |
||||
} |
||||
|
||||
return $res; |
||||
} |
||||
|
||||
/** |
||||
* checks if the user already get a session. |
||||
* |
||||
* @return the user login if the user already has a session ,false otherwise |
||||
*/ |
||||
function cas_is_authenticated() |
||||
{ |
||||
global $cas_auth_ver, $cas_auth_server, $cas_auth_port, $cas_auth_uri; |
||||
global $PHPCAS_CLIENT; |
||||
global $logout; |
||||
|
||||
if (!cas_configured()) { |
||||
return; |
||||
} |
||||
|
||||
if (!is_object($PHPCAS_CLIENT)) { |
||||
phpCAS::client($cas_auth_ver, $cas_auth_server, $cas_auth_port, $cas_auth_uri); |
||||
phpCAS::setNoCasServerValidation(); |
||||
} |
||||
$auth = phpCAS::checkAuthentication(); |
||||
|
||||
if ($auth) { |
||||
$login = trim(phpCAS::getUser()); |
||||
/* |
||||
Get user attributes. Here are the attributes for crdp platform |
||||
sn => name |
||||
ENTPersonMailInterne => mail |
||||
ENTPersonAlias => login |
||||
ENTPersonProfils => profil |
||||
givenName => first name |
||||
*/ |
||||
/*$user=phpCAS::getAttributes(); |
||||
$firstName = trim($user['givenName']); |
||||
$lastName = trim($user['sn']); |
||||
$login = trim($user['ENTPersonAlias']); |
||||
$profil = trim($user['ENTPersonProfils']); |
||||
$email = trim($user['ENTPersonMailInterne']); |
||||
$satus=5; |
||||
switch ($profil){ |
||||
case 'admin_etab': |
||||
$status=3; //Session admin |
||||
break; |
||||
case 'admin_sie': |
||||
$status=3; //Session admin |
||||
break; |
||||
case 'National_3': |
||||
$status=1; // Teacher |
||||
break; |
||||
case 'National_1': |
||||
$status=5; // Student |
||||
break; |
||||
default: |
||||
$status=5; // Student |
||||
}*/ |
||||
if (!$logout) { |
||||
// get user info from username |
||||
$tab_user_info = api_get_user_info($login); |
||||
|
||||
// user found in the chamilo database |
||||
if (is_array($tab_user_info)) { |
||||
// if option is on we update user automatically from ldap server |
||||
if (api_get_setting("update_user_info_cas_with_ldap") == "true") { |
||||
$ldapuser = extldap_authenticate($login, 'nopass', true); |
||||
if ($ldapuser !== false) { |
||||
$chamilo_user = extldap_get_chamilo_user($ldapuser); |
||||
$chamilo_user['user_id'] = $tab_user_info['user_id']; |
||||
$chamilo_user['status'] = $tab_user_info['status']; |
||||
UserManager::update_user( |
||||
$chamilo_user["user_id"], |
||||
$chamilo_user["firstname"], |
||||
$chamilo_user["lastname"], |
||||
$login, |
||||
null, |
||||
null, |
||||
$chamilo_user["email"], |
||||
$chamilo_user["status"], |
||||
'', |
||||
'', |
||||
'', |
||||
'', |
||||
1, |
||||
null, |
||||
0, |
||||
null, |
||||
'' |
||||
); |
||||
} |
||||
} |
||||
|
||||
return $login; |
||||
} // user not found |
||||
else { |
||||
// if option is on we can ADD user automatically from ldap server or by modify own profil |
||||
$user_added = false; |
||||
switch (api_get_setting("cas_add_user_activate")) { |
||||
case PLATFORM_AUTH_SOURCE: |
||||
// user will have to modify firstname, lastname, email in chamilo profil edit |
||||
$userdata = get_lang("EditInProfil"); |
||||
UserManager::create_user( |
||||
$userdata, |
||||
$userdata, |
||||
'5', |
||||
$userdata, |
||||
$login, |
||||
'casplaceholder', |
||||
'', |
||||
'', |
||||
'', |
||||
'', |
||||
CAS_AUTH_SOURCE |
||||
); |
||||
$user_added = $login; |
||||
break; |
||||
case LDAP_AUTH_SOURCE: |
||||
// user info are read from ldap connexion |
||||
// get user info from ldap server |
||||
// user has already been authenticated by CAS |
||||
// If user not found in LDAP, user not created |
||||
$ldapuser = extldap_authenticate($login, 'nopass', true); |
||||
if ($ldapuser !== false) { |
||||
$chamilo_user = extldap_get_chamilo_user($ldapuser); |
||||
$chamilo_user['username'] = $login; |
||||
$chamilo_user['auth_source'] = CAS_AUTH_SOURCE; |
||||
$chamilo_uid = external_add_user($chamilo_user); |
||||
$user_added = $login; |
||||
} |
||||
break; |
||||
default: |
||||
break; |
||||
} |
||||
|
||||
return $user_added; |
||||
} |
||||
} |
||||
// //If the user is in the dokeos database and we are ,not in a logout request, we upgrade his infomration by ldap |
||||
// if (! $logout){ |
||||
// $user_table = Database::get_main_table(TABLE_MAIN_USER); |
||||
// $sql = "SELECT user_id, username, password, auth_source, active, expiration_date ". |
||||
// "FROM $user_table ". |
||||
// "WHERE username = '$login' "; |
||||
// |
||||
// $result = Database::query($sql,__FILE__,__LINE__); |
||||
// if(mysql_num_rows($result) == 0) { |
||||
// require_once(api_get_path(SYS_PATH).'main/inc/lib/usermanager.lib.php'); |
||||
// $rnumber=rand(0,256000); |
||||
// UserManager::create_user($firstName, $lastName, $status, $email, $login, md5('casplaceholder'.$rnumber), $official_code='',$language='',$phone='',$picture_uri='',$auth_source = PLATFORM_AUTH_SOURCE); |
||||
// } |
||||
// else { |
||||
// $user = mysql_fetch_assoc($result); |
||||
// $user_id = intval($user['user_id']); |
||||
// //echo "deb : $status"; |
||||
// UserManager::update_user ($user_id, $firstname, $lastname, $login, null, null, $email, $status, '', '', '', '', 1, null, 0, null,'') ; |
||||
// |
||||
// } |
||||
// } |
||||
return $login; |
||||
} else { |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Logs out the user of the cas |
||||
* The user MUST be logged in with cas to use this function. |
||||
* |
||||
* @param $uinfo array user info (not needed) |
||||
* @param $location string redirect url |
||||
* |
||||
* @see online_logout() |
||||
*/ |
||||
function cas_logout($uinfo = null, $location = null) |
||||
{ |
||||
global $cas_auth_ver, $cas_auth_server, $cas_auth_port, $cas_auth_uri; |
||||
global $PHPCAS_CLIENT; |
||||
if (!is_object($PHPCAS_CLIENT)) { |
||||
phpCAS::client($cas_auth_ver, $cas_auth_server, $cas_auth_port, $cas_auth_uri); |
||||
phpCAS::setNoCasServerValidation(); |
||||
} |
||||
|
||||
if (!isset($location)) { |
||||
$location = api_get_path(WEB_PATH); |
||||
} |
||||
|
||||
phpCAS::logoutWithRedirectService($location); |
||||
} |
||||
|
||||
/* |
||||
* Return the direct URL to a course code with CAS login |
||||
*/ |
||||
function get_cas_direct_URL($in_course_code) |
||||
{ |
||||
return api_get_path(WEB_PATH).'main/auth/cas/logincas.php?firstpage='.$in_course_code; |
||||
} |
||||
|
||||
function getCASLogoHTML() |
||||
{ |
||||
$out_res = ""; |
||||
if (api_get_setting("casLogoURL") != "") { |
||||
$out_res = "<img src='".api_get_setting("casLogoURL")."' alt='CAS Logo' />"; |
||||
} |
||||
|
||||
return $out_res; |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -1,219 +0,0 @@ |
||||
<?php |
||||
/* |
||||
* Copyright © 2003-2010, The ESUP-Portail consortium & the JA-SIG Collaborative. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright notice, |
||||
* this list of conditions and the following disclaimer. |
||||
* * 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. |
||||
* * Neither the name of the ESUP-Portail consortium & the JA-SIG |
||||
* Collaborative nor the names of its contributors may be used to endorse or |
||||
* promote products derived from this software without specific prior |
||||
* written permission. |
||||
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
||||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
||||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR |
||||
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON |
||||
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
*/ |
||||
|
||||
/** |
||||
* @file CAS/PGTStorage/pgt-db.php |
||||
* Basic class for PGT database storage |
||||
*/ |
||||
|
||||
/** |
||||
* @class PGTStorageDB |
||||
* The PGTStorageDB class is a class for PGT database storage. An instance of |
||||
* this class is returned by CASClient::SetPGTStorageDB(). |
||||
* |
||||
* @author Pascal Aubry <pascal.aubry at univ-rennes1.fr> |
||||
* |
||||
* @ingroup internalPGTStorageDB |
||||
*/ |
||||
|
||||
class PGTStorageDB extends PGTStorage |
||||
{ |
||||
/** |
||||
* @addtogroup internalPGTStorageDB |
||||
* @{ |
||||
*/ |
||||
|
||||
/** |
||||
* a string representing a PEAR DB URL to connect to the database. Written by |
||||
* PGTStorageDB::PGTStorageDB(), read by getURL(). |
||||
* |
||||
* @hideinitializer |
||||
* @private |
||||
*/ |
||||
var $_url=''; |
||||
|
||||
/** |
||||
* This method returns the PEAR DB URL to use to connect to the database. |
||||
* |
||||
* @return string PEAR DB URL |
||||
* |
||||
* @private |
||||
*/ |
||||
function getURL() |
||||
{ |
||||
return $this->_url; |
||||
} |
||||
|
||||
/** |
||||
* The handle of the connection to the database where PGT's are stored. Written by |
||||
* PGTStorageDB::init(), read by getLink(). |
||||
* |
||||
* @hideinitializer |
||||
* @private |
||||
*/ |
||||
var $_link = null; |
||||
|
||||
/** |
||||
* This method returns the handle of the connection to the database where PGT's are |
||||
* stored. |
||||
* |
||||
* @return a handle of connection. |
||||
* |
||||
* @private |
||||
*/ |
||||
function getLink() |
||||
{ |
||||
return $this->_link; |
||||
} |
||||
|
||||
/** |
||||
* The name of the table where PGT's are stored. Written by |
||||
* PGTStorageDB::PGTStorageDB(), read by getTable(). |
||||
* |
||||
* @hideinitializer |
||||
* @private |
||||
*/ |
||||
var $_table = ''; |
||||
|
||||
/** |
||||
* This method returns the name of the table where PGT's are stored. |
||||
* |
||||
* @return string name of a table. |
||||
* |
||||
* @private |
||||
*/ |
||||
function getTable() |
||||
{ |
||||
return $this->_table; |
||||
} |
||||
|
||||
// ######################################################################## |
||||
// DEBUGGING |
||||
// ######################################################################## |
||||
|
||||
/** |
||||
* This method returns an informational string giving the type of storage |
||||
* used by the object (used for debugging purposes). |
||||
* |
||||
* @return string informational string. |
||||
* @public |
||||
*/ |
||||
function getStorageType() |
||||
{ |
||||
return "database"; |
||||
} |
||||
|
||||
/** |
||||
* This method returns an informational string giving informations on the |
||||
* parameters of the storage.(used for debugging purposes). |
||||
* |
||||
* @public |
||||
*/ |
||||
function getStorageInfo() |
||||
{ |
||||
return 'url=`'.$this->getURL().'\', table=`'.$this->getTable().'\''; |
||||
} |
||||
|
||||
// ######################################################################## |
||||
// CONSTRUCTOR |
||||
// ######################################################################## |
||||
|
||||
/** |
||||
* The class constructor, called by CASClient::SetPGTStorageDB(). |
||||
* |
||||
* @param CASClient $cas_parent the CASClient instance that creates the object. |
||||
* @param $user the user to access the data with |
||||
* @param $password the user's password |
||||
* @param $database_type the type of the database hosting the data |
||||
* @param $hostname the server hosting the database |
||||
* @param $port the port the server is listening on |
||||
* @param $database the name of the database |
||||
* @param $table the name of the table storing the data |
||||
* |
||||
* @public |
||||
*/ |
||||
function PGTStorageDB($cas_parent,$user,$password,$database_type,$hostname,$port,$database,$table) |
||||
{ |
||||
phpCAS::traceBegin(); |
||||
|
||||
// call the ancestor's constructor |
||||
$this->PGTStorage($cas_parent); |
||||
|
||||
if ( empty($database_type) ) $database_type = CAS_PGT_STORAGE_DB_DEFAULT_DATABASE_TYPE; |
||||
if ( empty($hostname) ) $hostname = CAS_PGT_STORAGE_DB_DEFAULT_HOSTNAME; |
||||
if ( $port==0 ) $port = CAS_PGT_STORAGE_DB_DEFAULT_PORT; |
||||
if ( empty($database) ) $database = CAS_PGT_STORAGE_DB_DEFAULT_DATABASE; |
||||
if ( empty($table) ) $table = CAS_PGT_STORAGE_DB_DEFAULT_TABLE; |
||||
|
||||
// build and store the PEAR DB URL |
||||
$this->_url = $database_type.':'.'//'.$user.':'.$password.'@'.$hostname.':'.$port.'/'.$database; |
||||
|
||||
// XXX should use setURL and setTable |
||||
phpCAS::traceEnd(); |
||||
} |
||||
|
||||
// ######################################################################## |
||||
// INITIALIZATION |
||||
// ######################################################################## |
||||
|
||||
/** |
||||
* This method is used to initialize the storage. Halts on error. |
||||
* |
||||
* @public |
||||
*/ |
||||
function init() |
||||
{ |
||||
phpCAS::traceBegin(); |
||||
// if the storage has already been initialized, return immediatly |
||||
if ( $this->isInitialized() ) |
||||
return; |
||||
// call the ancestor's method (mark as initialized) |
||||
parent::init(); |
||||
|
||||
//include phpDB library (the test was introduced in release 0.4.8 for |
||||
//the integration into Tikiwiki). |
||||
if (!class_exists('DB')) { |
||||
include_once('DB.php'); |
||||
} |
||||
|
||||
// try to connect to the database |
||||
$this->_link = DB::connect($this->getURL()); |
||||
if ( DB::isError($this->_link) ) { |
||||
phpCAS::error('could not connect to database ('.DB::errorMessage($this->_link).')'); |
||||
} |
||||
// Dump into trace |
||||
var_dump($this->_link); |
||||
phpCAS::traceBEnd(); |
||||
} |
||||
|
||||
/** @} */ |
||||
} |
||||
|
||||
?> |
||||
@ -1,276 +0,0 @@ |
||||
<?php |
||||
/* |
||||
* Copyright © 2003-2010, The ESUP-Portail consortium & the JA-SIG Collaborative. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright notice, |
||||
* this list of conditions and the following disclaimer. |
||||
* * 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. |
||||
* * Neither the name of the ESUP-Portail consortium & the JA-SIG |
||||
* Collaborative nor the names of its contributors may be used to endorse or |
||||
* promote products derived from this software without specific prior |
||||
* written permission. |
||||
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
||||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
||||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR |
||||
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON |
||||
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
*/ |
||||
/** |
||||
* @file CAS/PGTStorage/pgt-file.php |
||||
* Basic class for PGT file storage |
||||
*/ |
||||
|
||||
/** |
||||
* @class PGTStorageFile |
||||
* The PGTStorageFile class is a class for PGT file storage. An instance of |
||||
* this class is returned by CASClient::SetPGTStorageFile(). |
||||
* |
||||
* @author Pascal Aubry <pascal.aubry at univ-rennes1.fr> |
||||
* |
||||
* @ingroup internalPGTStorageFile |
||||
*/ |
||||
|
||||
class PGTStorageFile extends PGTStorage |
||||
{ |
||||
/** |
||||
* @addtogroup internalPGTStorageFile |
||||
* @{ |
||||
*/ |
||||
|
||||
/** |
||||
* a string telling where PGT's should be stored on the filesystem. Written by |
||||
* PGTStorageFile::PGTStorageFile(), read by getPath(). |
||||
* |
||||
* @private |
||||
*/ |
||||
var $_path; |
||||
|
||||
/** |
||||
* This method returns the name of the directory where PGT's should be stored |
||||
* on the filesystem. |
||||
* |
||||
* @return the name of a directory (with leading and trailing '/') |
||||
* |
||||
* @private |
||||
*/ |
||||
function getPath() |
||||
{ |
||||
return $this->_path; |
||||
} |
||||
|
||||
/** |
||||
* a string telling the format to use to store PGT's (plain or xml). Written by |
||||
* PGTStorageFile::PGTStorageFile(), read by getFormat(). |
||||
* |
||||
* @private |
||||
*/ |
||||
var $_format; |
||||
|
||||
/** |
||||
* This method returns the format to use when storing PGT's on the filesystem. |
||||
* |
||||
* @return a string corresponding to the format used (plain or xml). |
||||
* |
||||
* @private |
||||
*/ |
||||
function getFormat() |
||||
{ |
||||
return $this->_format; |
||||
} |
||||
|
||||
// ######################################################################## |
||||
// DEBUGGING |
||||
// ######################################################################## |
||||
|
||||
/** |
||||
* This method returns an informational string giving the type of storage |
||||
* used by the object (used for debugging purposes). |
||||
* |
||||
* @return string informational string. |
||||
* @public |
||||
*/ |
||||
function getStorageType() |
||||
{ |
||||
return "file"; |
||||
} |
||||
|
||||
/** |
||||
* This method returns an informational string giving informations on the |
||||
* parameters of the storage.(used for debugging purposes). |
||||
* |
||||
* @return string informational string. |
||||
* @public |
||||
*/ |
||||
function getStorageInfo() |
||||
{ |
||||
return 'path=`'.$this->getPath().'\', format=`'.$this->getFormat().'\''; |
||||
} |
||||
|
||||
// ######################################################################## |
||||
// CONSTRUCTOR |
||||
// ######################################################################## |
||||
|
||||
/** |
||||
* The class constructor, called by CASClient::SetPGTStorageFile(). |
||||
* |
||||
* @param CASClient $cas_parent the CASClient instance that creates the object. |
||||
* @param string $format the format used to store the PGT's (`plain' and `xml' allowed). |
||||
* @param string $path the path where the PGT's should be stored |
||||
* |
||||
* @public |
||||
*/ |
||||
function PGTStorageFile($cas_parent,$format,$path) |
||||
{ |
||||
phpCAS::traceBegin(); |
||||
// call the ancestor's constructor |
||||
$this->PGTStorage($cas_parent); |
||||
|
||||
if (empty($format) ) $format = CAS_PGT_STORAGE_FILE_DEFAULT_FORMAT; |
||||
if (empty($path) ) $path = CAS_PGT_STORAGE_FILE_DEFAULT_PATH; |
||||
|
||||
// check that the path is an absolute path |
||||
if (getenv("OS")=="Windows_NT"){ |
||||
|
||||
if (!preg_match('`^[a-zA-Z]:`', $path)) { |
||||
phpCAS::error('an absolute path is needed for PGT storage to file'); |
||||
} |
||||
|
||||
} |
||||
else |
||||
{ |
||||
|
||||
if ( $path[0] != '/' ) { |
||||
phpCAS::error('an absolute path is needed for PGT storage to file'); |
||||
} |
||||
|
||||
// store the path (with a leading and trailing '/') |
||||
$path = preg_replace('|[/]*$|','/',$path); |
||||
$path = preg_replace('|^[/]*|','/',$path); |
||||
} |
||||
|
||||
$this->_path = $path; |
||||
// check the format and store it |
||||
switch ($format) { |
||||
case CAS_PGT_STORAGE_FILE_FORMAT_PLAIN: |
||||
case CAS_PGT_STORAGE_FILE_FORMAT_XML: |
||||
$this->_format = $format; |
||||
break; |
||||
default: |
||||
phpCAS::error('unknown PGT file storage format (`'.CAS_PGT_STORAGE_FILE_FORMAT_PLAIN.'\' and `'.CAS_PGT_STORAGE_FILE_FORMAT_XML.'\' allowed)'); |
||||
} |
||||
phpCAS::traceEnd(); |
||||
} |
||||
|
||||
// ######################################################################## |
||||
// INITIALIZATION |
||||
// ######################################################################## |
||||
|
||||
/** |
||||
* This method is used to initialize the storage. Halts on error. |
||||
* |
||||
* @public |
||||
*/ |
||||
function init() |
||||
{ |
||||
phpCAS::traceBegin(); |
||||
// if the storage has already been initialized, return immediatly |
||||
if ( $this->isInitialized() ) |
||||
return; |
||||
// call the ancestor's method (mark as initialized) |
||||
parent::init(); |
||||
phpCAS::traceEnd(); |
||||
} |
||||
|
||||
// ######################################################################## |
||||
// PGT I/O |
||||
// ######################################################################## |
||||
|
||||
/** |
||||
* This method returns the filename corresponding to a PGT Iou. |
||||
* |
||||
* @param $pgt_iou the PGT iou. |
||||
* |
||||
* @return string filename |
||||
* @private |
||||
*/ |
||||
function getPGTIouFilename($pgt_iou) |
||||
{ |
||||
phpCAS::traceBegin(); |
||||
$filename = $this->getPath().$pgt_iou.'.'.$this->getFormat(); |
||||
phpCAS::traceEnd($filename); |
||||
return $filename; |
||||
} |
||||
|
||||
/** |
||||
* This method stores a PGT and its corresponding PGT Iou into a file. Echoes a |
||||
* warning on error. |
||||
* |
||||
* @param $pgt the PGT |
||||
* @param $pgt_iou the PGT iou |
||||
* |
||||
* @public |
||||
*/ |
||||
function write($pgt,$pgt_iou) |
||||
{ |
||||
phpCAS::traceBegin(); |
||||
$fname = $this->getPGTIouFilename($pgt_iou); |
||||
if ( $f=fopen($fname,"w") ) { |
||||
if ( fputs($f,$pgt) === FALSE ) { |
||||
phpCAS::error('could not write PGT to `'.$fname.'\''); |
||||
} |
||||
fclose($f); |
||||
} else { |
||||
phpCAS::error('could not open `'.$fname.'\''); |
||||
} |
||||
phpCAS::traceEnd(); |
||||
} |
||||
|
||||
/** |
||||
* This method reads a PGT corresponding to a PGT Iou and deletes the |
||||
* corresponding file. |
||||
* |
||||
* @param $pgt_iou the PGT iou |
||||
* |
||||
* @return false|string corresponding PGT, or FALSE on error |
||||
* |
||||
* @public |
||||
*/ |
||||
function read($pgt_iou) |
||||
{ |
||||
phpCAS::traceBegin(); |
||||
$pgt = FALSE; |
||||
$fname = $this->getPGTIouFilename($pgt_iou); |
||||
if ( !($f=fopen($fname,"r")) ) { |
||||
phpCAS::trace('could not open `'.$fname.'\''); |
||||
} else { |
||||
if ( ($pgt=fgets($f)) === FALSE ) { |
||||
phpCAS::trace('could not read PGT from `'.$fname.'\''); |
||||
} |
||||
fclose($f); |
||||
} |
||||
|
||||
// delete the PGT file |
||||
@unlink($fname); |
||||
|
||||
phpCAS::traceEnd($pgt); |
||||
return $pgt; |
||||
} |
||||
|
||||
/** @} */ |
||||
|
||||
} |
||||
|
||||
|
||||
?> |
||||
@ -1,215 +0,0 @@ |
||||
<?php |
||||
/* |
||||
* Copyright © 2003-2010, The ESUP-Portail consortium & the JA-SIG Collaborative. |
||||
* All rights reserved. |
||||
* |
||||
* Redistribution and use in source and binary forms, with or without |
||||
* modification, are permitted provided that the following conditions are met: |
||||
* |
||||
* * Redistributions of source code must retain the above copyright notice, |
||||
* this list of conditions and the following disclaimer. |
||||
* * 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. |
||||
* * Neither the name of the ESUP-Portail consortium & the JA-SIG |
||||
* Collaborative nor the names of its contributors may be used to endorse or |
||||
* promote products derived from this software without specific prior |
||||
* written permission. |
||||
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
||||
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
||||
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR |
||||
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
||||
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
||||
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON |
||||
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
||||
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||||
*/ |
||||
/** |
||||
* @file CAS/PGTStorage/pgt-main.php |
||||
* Basic class for PGT storage |
||||
*/ |
||||
|
||||
/** |
||||
* @class PGTStorage |
||||
* The PGTStorage class is a generic class for PGT storage. This class should |
||||
* not be instanciated itself but inherited by specific PGT storage classes. |
||||
* |
||||
* @author Pascal Aubry <pascal.aubry at univ-rennes1.fr> |
||||
* |
||||
* @ingroup internalPGTStorage |
||||
*/ |
||||
|
||||
class PGTStorage |
||||
{ |
||||
/** |
||||
* @addtogroup internalPGTStorage |
||||
* @{ |
||||
*/ |
||||
|
||||
// ######################################################################## |
||||
// CONSTRUCTOR |
||||
// ######################################################################## |
||||
|
||||
/** |
||||
* The constructor of the class, should be called only by inherited classes. |
||||
* |
||||
* @param $cas_parent the CASclient instance that creates the current object. |
||||
* |
||||
* @protected |
||||
*/ |
||||
function PGTStorage($cas_parent) |
||||
{ |
||||
phpCAS::traceBegin(); |
||||
if ( !$cas_parent->isProxy() ) { |
||||
phpCAS::error('defining PGT storage makes no sense when not using a CAS proxy'); |
||||
} |
||||
phpCAS::traceEnd(); |
||||
} |
||||
|
||||
// ######################################################################## |
||||
// DEBUGGING |
||||
// ######################################################################## |
||||
|
||||
/** |
||||
* This virtual method returns an informational string giving the type of storage |
||||
* used by the object (used for debugging purposes). |
||||
* |
||||
* @public |
||||
*/ |
||||
function getStorageType() |
||||
{ |
||||
phpCAS::error(__CLASS__.'::'.__FUNCTION__.'() should never be called'); |
||||
} |
||||
|
||||
/** |
||||
* This virtual method returns an informational string giving informations on the |
||||
* parameters of the storage.(used for debugging purposes). |
||||
* |
||||
* @public |
||||
*/ |
||||
function getStorageInfo() |
||||
{ |
||||
phpCAS::error(__CLASS__.'::'.__FUNCTION__.'() should never be called'); |
||||
} |
||||
|
||||
// ######################################################################## |
||||
// ERROR HANDLING |
||||
// ######################################################################## |
||||
|
||||
/** |
||||
* string used to store an error message. Written by PGTStorage::setErrorMessage(), |
||||
* read by PGTStorage::getErrorMessage(). |
||||
* |
||||
* @hideinitializer |
||||
* @private |
||||
* @deprecated not used. |
||||
*/ |
||||
var $_error_message=FALSE; |
||||
|
||||
/** |
||||
* This method sets en error message, which can be read later by |
||||
* PGTStorage::getErrorMessage(). |
||||
* |
||||
* @param $error_message an error message |
||||
* |
||||
* @protected |
||||
* @deprecated not used. |
||||
*/ |
||||
function setErrorMessage($error_message) |
||||
{ |
||||
$this->_error_message = $error_message; |
||||
} |
||||
|
||||
/** |
||||
* This method returns an error message set by PGTStorage::setErrorMessage(). |
||||
* |
||||
* @return boolean error message when set by PGTStorage::setErrorMessage(), FALSE |
||||
* otherwise. |
||||
* |
||||
* @public |
||||
* @deprecated not used. |
||||
*/ |
||||
function getErrorMessage() |
||||
{ |
||||
return $this->_error_message; |
||||
} |
||||
|
||||
// ######################################################################## |
||||
// INITIALIZATION |
||||
// ######################################################################## |
||||
|
||||
/** |
||||
* a boolean telling if the storage has already been initialized. Written by |
||||
* PGTStorage::init(), read by PGTStorage::isInitialized(). |
||||
* |
||||
* @hideinitializer |
||||
* @private |
||||
*/ |
||||
var $_initialized = FALSE; |
||||
|
||||
/** |
||||
* This method tells if the storage has already been intialized. |
||||
* |
||||
* @return boolean boolean |
||||
* |
||||
* @protected |
||||
*/ |
||||
function isInitialized() |
||||
{ |
||||
return $this->_initialized; |
||||
} |
||||
|
||||
/** |
||||
* This virtual method initializes the object. |
||||
* |
||||
* @protected |
||||
*/ |
||||
function init() |
||||
{ |
||||
$this->_initialized = TRUE; |
||||
} |
||||
|
||||
// ######################################################################## |
||||
// PGT I/O |
||||
// ######################################################################## |
||||
|
||||
/** |
||||
* This virtual method stores a PGT and its corresponding PGT Iuo. |
||||
* @note Should never be called. |
||||
* |
||||
* @param $pgt the PGT |
||||
* @param $pgt_iou the PGT iou |
||||
* |
||||
* @protected |
||||
*/ |
||||
function write($pgt,$pgt_iou) |
||||
{ |
||||
phpCAS::error(__CLASS__.'::'.__FUNCTION__.'() should never be called'); |
||||
} |
||||
|
||||
/** |
||||
* This virtual method reads a PGT corresponding to a PGT Iou and deletes |
||||
* the corresponding storage entry. |
||||
* @note Should never be called. |
||||
* |
||||
* @param $pgt_iou the PGT iou |
||||
* |
||||
* @protected |
||||
*/ |
||||
function read($pgt_iou) |
||||
{ |
||||
phpCAS::error(__CLASS__.'::'.__FUNCTION__.'() should never be called'); |
||||
} |
||||
|
||||
/** @} */ |
||||
|
||||
} |
||||
|
||||
// include specific PGT storage classes |
||||
include_once __DIR__.'/pgt-file.php'; |
||||
include_once __DIR__.'/pgt-db.php'; |
||||
|
||||
?> |
||||
File diff suppressed because it is too large
Load Diff
@ -1,881 +0,0 @@ |
||||
<?php |
||||
/* |
||||
Requires PHP5, uses built-in DOM extension. |
||||
To be used in PHP4 scripts using DOMXML extension: allows PHP4/DOMXML scripts to run on PHP5/DOM. |
||||
(Optional: requires PHP5/XSL extension for domxml_xslt functions, PHP>=5.1 for XPath evaluation functions, and PHP>=5.1/libxml for DOMXML error reports) |
||||
|
||||
Typical use: |
||||
{ |
||||
if (PHP_VERSION>='5') |
||||
require_once('domxml-php4-to-php5.php'); |
||||
} |
||||
|
||||
Version 1.21, 2008-12-05, http://alexandre.alapetite.net/doc-alex/domxml-php4-php5/ |
||||
|
||||
------------------------------------------------------------------ |
||||
Written by Alexandre Alapetite, http://alexandre.alapetite.net/cv/ |
||||
|
||||
Copyright 2004-2008, GNU Lesser General Public License, |
||||
http://www.gnu.org/licenses/lgpl.html |
||||
|
||||
This program is free software: you can redistribute it and/or modify |
||||
it under the terms of the GNU Lesser General Public License as published by |
||||
the Free Software Foundation, either version 3 of the License, or |
||||
(at your option) any later version. |
||||
This program is distributed in the hope that it will be useful, |
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
GNU Lesser General Public License for more details. |
||||
You should have received a copy of the GNU Lesser General Public License |
||||
along with this program. If not, see <http://www.gnu.org/licenses/lgpl.html> |
||||
|
||||
== Rights and obligations == |
||||
- Attribution: You must give the original author credit. |
||||
- Share Alike: If you alter or transform this library, |
||||
you may distribute the resulting library only under the same license GNU/LGPL. |
||||
- In case of jurisdiction dispute, the French law is authoritative. |
||||
- Any of these conditions can be waived if you get permission from Alexandre Alapetite. |
||||
- Not required, but please send to Alexandre Alapetite the modifications you make, |
||||
in order to improve this file for the benefit of everybody. |
||||
|
||||
If you want to distribute this code, please do it as a link to: |
||||
http://alexandre.alapetite.net/doc-alex/domxml-php4-php5/ |
||||
*/ |
||||
|
||||
define('DOMXML_LOAD_PARSING', 0); |
||||
define('DOMXML_LOAD_VALIDATING', 1); |
||||
define('DOMXML_LOAD_RECOVERING', 2); |
||||
define('DOMXML_LOAD_SUBSTITUTE_ENTITIES', 4); |
||||
//define('DOMXML_LOAD_COMPLETE_ATTRS',8); |
||||
define('DOMXML_LOAD_DONT_KEEP_BLANKS', 16); |
||||
|
||||
function domxml_new_doc($version) |
||||
{ |
||||
return new php4DOMDocument(); |
||||
} |
||||
|
||||
function domxml_new_xmldoc($version) |
||||
{ |
||||
return new php4DOMDocument(); |
||||
} |
||||
|
||||
function domxml_open_file($filename, $mode = DOMXML_LOAD_PARSING, &$error = null) |
||||
{ |
||||
$dom = new php4DOMDocument($mode); |
||||
$errorMode = (func_num_args() > 2) && defined('LIBXML_VERSION'); |
||||
if ($errorMode) { |
||||
libxml_use_internal_errors(true); |
||||
} |
||||
if (!$dom->myDOMNode->load($filename)) { |
||||
$dom = null; |
||||
} |
||||
if ($errorMode) { |
||||
$error = array_map('_error_report', libxml_get_errors()); |
||||
libxml_clear_errors(); |
||||
} |
||||
return $dom; |
||||
} |
||||
|
||||
function domxml_open_mem($str, $mode = DOMXML_LOAD_PARSING, &$error = null) |
||||
{ |
||||
$dom = new php4DOMDocument($mode); |
||||
$errorMode = (func_num_args() > 2) && defined('LIBXML_VERSION'); |
||||
if ($errorMode) { |
||||
libxml_use_internal_errors(true); |
||||
} |
||||
if (!$dom->myDOMNode->loadXML($str)) { |
||||
$dom = null; |
||||
} |
||||
if ($errorMode) { |
||||
$error = array_map('_error_report', libxml_get_errors()); |
||||
libxml_clear_errors(); |
||||
} |
||||
return $dom; |
||||
} |
||||
|
||||
function html_doc($html_doc, $from_file = false) |
||||
{ |
||||
$dom = new php4DOMDocument(); |
||||
if ($from_file) { |
||||
$result = $dom->myDOMNode->loadHTMLFile($html_doc); |
||||
} else { |
||||
$result = $dom->myDOMNode->loadHTML($html_doc); |
||||
} |
||||
return $result ? $dom : null; |
||||
} |
||||
|
||||
function html_doc_file($filename) |
||||
{ |
||||
return html_doc($filename, true); |
||||
} |
||||
|
||||
function xmldoc($str) |
||||
{ |
||||
return domxml_open_mem($str); |
||||
} |
||||
|
||||
function xmldocfile($filename) |
||||
{ |
||||
return domxml_open_file($filename); |
||||
} |
||||
|
||||
function xpath_eval($xpath_context, $eval_str, $contextnode = null) |
||||
{ |
||||
return $xpath_context->xpath_eval($eval_str, $contextnode); |
||||
} |
||||
|
||||
function xpath_new_context($dom_document) |
||||
{ |
||||
return new php4DOMXPath($dom_document); |
||||
} |
||||
|
||||
function xpath_register_ns($xpath_context, $prefix, $namespaceURI) |
||||
{ |
||||
return $xpath_context->myDOMXPath->registerNamespace($prefix, $namespaceURI); |
||||
} |
||||
|
||||
function _entityDecode($text) |
||||
{ |
||||
return html_entity_decode(strtr($text, array(''' => '\'')), ENT_QUOTES, 'UTF-8'); |
||||
} |
||||
|
||||
function _error_report($error) |
||||
{ |
||||
return array( |
||||
'errormessage' => $error->message, |
||||
'nodename' => '', |
||||
'line' => $error->line, |
||||
'col' => $error->column |
||||
) + ($error->file == '' ? array() : array('directory' => dirname($error->file), 'file' => basename($error->file))); |
||||
} |
||||
|
||||
class php4DOMAttr extends php4DOMNode |
||||
{ |
||||
function __get($name) |
||||
{ |
||||
if ($name === 'name') { |
||||
return $this->myDOMNode->name; |
||||
} else { |
||||
return parent::__get($name); |
||||
} |
||||
} |
||||
|
||||
function name() |
||||
{ |
||||
return $this->myDOMNode->name; |
||||
} |
||||
|
||||
function set_content($text) |
||||
{ |
||||
} |
||||
|
||||
//function set_value($content) {return $this->myDOMNode->value=htmlspecialchars($content,ENT_QUOTES);} |
||||
function specified() |
||||
{ |
||||
return $this->myDOMNode->specified; |
||||
} |
||||
|
||||
function value() |
||||
{ |
||||
return $this->myDOMNode->value; |
||||
} |
||||
} |
||||
|
||||
class php4DOMDocument extends php4DOMNode |
||||
{ |
||||
function php4DOMDocument($mode = DOMXML_LOAD_PARSING) |
||||
{ |
||||
$this->myDOMNode = new DOMDocument(); |
||||
$this->myOwnerDocument = $this; |
||||
if ($mode & DOMXML_LOAD_VALIDATING) { |
||||
$this->myDOMNode->validateOnParse = true; |
||||
} |
||||
if ($mode & DOMXML_LOAD_RECOVERING) { |
||||
$this->myDOMNode->recover = true; |
||||
} |
||||
if ($mode & DOMXML_LOAD_SUBSTITUTE_ENTITIES) { |
||||
$this->myDOMNode->substituteEntities = true; |
||||
} |
||||
if ($mode & DOMXML_LOAD_DONT_KEEP_BLANKS) { |
||||
$this->myDOMNode->preserveWhiteSpace = false; |
||||
} |
||||
} |
||||
|
||||
function add_root($name) |
||||
{ |
||||
if ($this->myDOMNode->hasChildNodes()) { |
||||
$this->myDOMNode->removeChild($this->myDOMNode->firstChild); |
||||
} |
||||
return new php4DOMElement($this->myDOMNode->appendChild($this->myDOMNode->createElement($name)), |
||||
$this->myOwnerDocument); |
||||
} |
||||
|
||||
function create_attribute($name, $value) |
||||
{ |
||||
$myAttr = $this->myDOMNode->createAttribute($name); |
||||
$myAttr->value = htmlspecialchars($value, ENT_QUOTES); |
||||
return new php4DOMAttr($myAttr, $this); |
||||
} |
||||
|
||||
function create_cdata_section($content) |
||||
{ |
||||
return new php4DOMNode($this->myDOMNode->createCDATASection($content), $this); |
||||
} |
||||
|
||||
function create_comment($data) |
||||
{ |
||||
return new php4DOMNode($this->myDOMNode->createComment($data), $this); |
||||
} |
||||
|
||||
function create_element($name) |
||||
{ |
||||
return new php4DOMElement($this->myDOMNode->createElement($name), $this); |
||||
} |
||||
|
||||
function create_element_ns($uri, $name, $prefix = null) |
||||
{ |
||||
if ($prefix == null) { |
||||
$prefix = $this->myDOMNode->lookupPrefix($uri); |
||||
} |
||||
if (($prefix == null) && (($this->myDOMNode->documentElement == null) || (!$this->myDOMNode->documentElement->isDefaultNamespace($uri)))) { |
||||
$prefix = 'a' . sprintf('%u', crc32($uri)); |
||||
} |
||||
return new php4DOMElement($this->myDOMNode->createElementNS($uri, |
||||
$prefix == null ? $name : $prefix . ':' . $name), $this); |
||||
} |
||||
|
||||
function create_entity_reference($content) |
||||
{ |
||||
return new php4DOMNode($this->myDOMNode->createEntityReference($content), $this); |
||||
} //By Walter Ebert 2007-01-22 |
||||
|
||||
function create_processing_instruction($target, $data = '') |
||||
{ |
||||
return new php4DomProcessingInstruction($this->myDOMNode->createProcessingInstruction($target, $data), $this); |
||||
} |
||||
|
||||
function create_text_node($content) |
||||
{ |
||||
return new php4DOMText($this->myDOMNode->createTextNode($content), $this); |
||||
} |
||||
|
||||
function document_element() |
||||
{ |
||||
return parent::_newDOMElement($this->myDOMNode->documentElement, $this); |
||||
} |
||||
|
||||
function dump_file($filename, $compressionmode = false, $format = false) |
||||
{ |
||||
$format0 = $this->myDOMNode->formatOutput; |
||||
$this->myDOMNode->formatOutput = $format; |
||||
$res = $this->myDOMNode->save($filename); |
||||
$this->myDOMNode->formatOutput = $format0; |
||||
return $res; |
||||
} |
||||
|
||||
function dump_mem($format = false, $encoding = false) |
||||
{ |
||||
$format0 = $this->myDOMNode->formatOutput; |
||||
$this->myDOMNode->formatOutput = $format; |
||||
$encoding0 = $this->myDOMNode->encoding; |
||||
if ($encoding) { |
||||
$this->myDOMNode->encoding = $encoding; |
||||
} |
||||
$dump = $this->myDOMNode->saveXML(); |
||||
$this->myDOMNode->formatOutput = $format0; |
||||
if ($encoding) { |
||||
$this->myDOMNode->encoding = $encoding0 == '' ? 'UTF-8' : $encoding0; |
||||
} //UTF-8 is XML default encoding |
||||
return $dump; |
||||
} |
||||
|
||||
function free() |
||||
{ |
||||
if ($this->myDOMNode->hasChildNodes()) { |
||||
$this->myDOMNode->removeChild($this->myDOMNode->firstChild); |
||||
} |
||||
$this->myDOMNode = null; |
||||
$this->myOwnerDocument = null; |
||||
} |
||||
|
||||
function get_element_by_id($id) |
||||
{ |
||||
return parent::_newDOMElement($this->myDOMNode->getElementById($id), $this); |
||||
} |
||||
|
||||
function get_elements_by_tagname($name) |
||||
{ |
||||
$myDOMNodeList = $this->myDOMNode->getElementsByTagName($name); |
||||
$nodeSet = array(); |
||||
$i = 0; |
||||
if (isset($myDOMNodeList)) { |
||||
while ($node = $myDOMNodeList->item($i++)) { |
||||
$nodeSet[] = new php4DOMElement($node, $this); |
||||
} |
||||
} |
||||
return $nodeSet; |
||||
} |
||||
|
||||
function html_dump_mem() |
||||
{ |
||||
return $this->myDOMNode->saveHTML(); |
||||
} |
||||
|
||||
function root() |
||||
{ |
||||
return parent::_newDOMElement($this->myDOMNode->documentElement, $this); |
||||
} |
||||
|
||||
function xinclude() |
||||
{ |
||||
return $this->myDOMNode->xinclude(); |
||||
} |
||||
|
||||
function xpath_new_context() |
||||
{ |
||||
return new php4DOMXPath($this); |
||||
} |
||||
} |
||||
|
||||
class php4DOMElement extends php4DOMNode |
||||
{ |
||||
function add_namespace($uri, $prefix) |
||||
{ |
||||
if ($this->myDOMNode->hasAttributeNS('http://www.w3.org/2000/xmlns/', $prefix)) { |
||||
return false; |
||||
} else { |
||||
$this->myDOMNode->setAttributeNS('http://www.w3.org/2000/xmlns/', 'xmlns:' . $prefix, |
||||
$uri); //By Daniel Walker 2006-09-08 |
||||
return true; |
||||
} |
||||
} |
||||
|
||||
function get_attribute($name) |
||||
{ |
||||
return $this->myDOMNode->getAttribute($name); |
||||
} |
||||
|
||||
function get_attribute_node($name) |
||||
{ |
||||
return parent::_newDOMElement($this->myDOMNode->getAttributeNode($name), $this->myOwnerDocument); |
||||
} |
||||
|
||||
function get_elements_by_tagname($name) |
||||
{ |
||||
$myDOMNodeList = $this->myDOMNode->getElementsByTagName($name); |
||||
$nodeSet = array(); |
||||
$i = 0; |
||||
if (isset($myDOMNodeList)) { |
||||
while ($node = $myDOMNodeList->item($i++)) { |
||||
$nodeSet[] = new php4DOMElement($node, $this->myOwnerDocument); |
||||
} |
||||
} |
||||
return $nodeSet; |
||||
} |
||||
|
||||
function has_attribute($name) |
||||
{ |
||||
return $this->myDOMNode->hasAttribute($name); |
||||
} |
||||
|
||||
function remove_attribute($name) |
||||
{ |
||||
return $this->myDOMNode->removeAttribute($name); |
||||
} |
||||
|
||||
function set_attribute($name, $value) |
||||
{ |
||||
//return $this->myDOMNode->setAttribute($name,$value); //Does not return a DomAttr |
||||
$myAttr = $this->myDOMNode->ownerDocument->createAttribute($name); |
||||
$myAttr->value = htmlspecialchars($value, ENT_QUOTES); //Entity problem reported by AL-DesignWorks 2007-09-07 |
||||
$this->myDOMNode->setAttributeNode($myAttr); |
||||
return new php4DOMAttr($myAttr, $this->myOwnerDocument); |
||||
} |
||||
|
||||
/*function set_attribute_node($attr) |
||||
{ |
||||
$this->myDOMNode->setAttributeNode($this->_importNode($attr)); |
||||
return $attr; |
||||
}*/ |
||||
function set_name($name) |
||||
{ |
||||
if ($this->myDOMNode->prefix == '') { |
||||
$newNode = $this->myDOMNode->ownerDocument->createElement($name); |
||||
} else { |
||||
$newNode = $this->myDOMNode->ownerDocument->createElementNS($this->myDOMNode->namespaceURI, |
||||
$this->myDOMNode->prefix . ':' . $name); |
||||
} |
||||
$myDOMNodeList = $this->myDOMNode->attributes; |
||||
$i = 0; |
||||
if (isset($myDOMNodeList)) { |
||||
while ($node = $myDOMNodeList->item($i++)) { |
||||
if ($node->namespaceURI == '') { |
||||
$newNode->setAttribute($node->name, $node->value); |
||||
} else { |
||||
$newNode->setAttributeNS($node->namespaceURI, $node->nodeName, $node->value); |
||||
} |
||||
} |
||||
} |
||||
$myDOMNodeList = $this->myDOMNode->childNodes; |
||||
if (isset($myDOMNodeList)) { |
||||
while ($node = $myDOMNodeList->item(0)) { |
||||
$newNode->appendChild($node); |
||||
} |
||||
} |
||||
$this->myDOMNode->parentNode->replaceChild($newNode, $this->myDOMNode); |
||||
$this->myDOMNode = $newNode; |
||||
return true; |
||||
} |
||||
|
||||
function tagname() |
||||
{ |
||||
return $this->tagname; |
||||
} |
||||
} |
||||
|
||||
class php4DOMNode |
||||
{ |
||||
public $myDOMNode; |
||||
public $myOwnerDocument; |
||||
|
||||
function php4DOMNode($aDomNode, $aOwnerDocument) |
||||
{ |
||||
$this->myDOMNode = $aDomNode; |
||||
$this->myOwnerDocument = $aOwnerDocument; |
||||
} |
||||
|
||||
function __get($name) |
||||
{ |
||||
switch ($name) { |
||||
case 'type': |
||||
return $this->myDOMNode->nodeType; |
||||
case 'tagname': |
||||
return ($this->myDOMNode->nodeType === XML_ELEMENT_NODE) ? $this->myDOMNode->localName : $this->myDOMNode->tagName; //Avoid namespace prefix for DOMElement |
||||
case 'content': |
||||
return $this->myDOMNode->textContent; |
||||
case 'value': |
||||
return $this->myDOMNode->value; |
||||
default: |
||||
$myErrors = debug_backtrace(); |
||||
trigger_error('Undefined property: ' . get_class($this) . '::$' . $name . ' [' . $myErrors[0]['file'] . ':' . $myErrors[0]['line'] . ']', |
||||
E_USER_NOTICE); |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
function add_child($newnode) |
||||
{ |
||||
return append_child($newnode); |
||||
} |
||||
|
||||
function add_namespace($uri, $prefix) |
||||
{ |
||||
return false; |
||||
} |
||||
|
||||
function append_child($newnode) |
||||
{ |
||||
return self::_newDOMElement($this->myDOMNode->appendChild($this->_importNode($newnode)), |
||||
$this->myOwnerDocument); |
||||
} |
||||
|
||||
function append_sibling($newnode) |
||||
{ |
||||
return self::_newDOMElement($this->myDOMNode->parentNode->appendChild($this->_importNode($newnode)), |
||||
$this->myOwnerDocument); |
||||
} |
||||
|
||||
function attributes() |
||||
{ |
||||
$myDOMNodeList = $this->myDOMNode->attributes; |
||||
if (!(isset($myDOMNodeList) && $this->myDOMNode->hasAttributes())) { |
||||
return null; |
||||
} |
||||
$nodeSet = array(); |
||||
$i = 0; |
||||
while ($node = $myDOMNodeList->item($i++)) { |
||||
$nodeSet[] = new php4DOMAttr($node, $this->myOwnerDocument); |
||||
} |
||||
return $nodeSet; |
||||
} |
||||
|
||||
function child_nodes() |
||||
{ |
||||
$myDOMNodeList = $this->myDOMNode->childNodes; |
||||
$nodeSet = array(); |
||||
$i = 0; |
||||
if (isset($myDOMNodeList)) { |
||||
while ($node = $myDOMNodeList->item($i++)) { |
||||
$nodeSet[] = self::_newDOMElement($node, $this->myOwnerDocument); |
||||
} |
||||
} |
||||
return $nodeSet; |
||||
} |
||||
|
||||
function children() |
||||
{ |
||||
return $this->child_nodes(); |
||||
} |
||||
|
||||
function clone_node($deep = false) |
||||
{ |
||||
return self::_newDOMElement($this->myDOMNode->cloneNode($deep), $this->myOwnerDocument); |
||||
} |
||||
|
||||
//dump_node($node) should only be called on php4DOMDocument |
||||
function dump_node($node = null) |
||||
{ |
||||
return $node == null ? $this->myOwnerDocument->myDOMNode->saveXML($this->myDOMNode) : $this->myOwnerDocument->myDOMNode->saveXML($node->myDOMNode); |
||||
} |
||||
|
||||
function first_child() |
||||
{ |
||||
return self::_newDOMElement($this->myDOMNode->firstChild, $this->myOwnerDocument); |
||||
} |
||||
|
||||
function get_content() |
||||
{ |
||||
return $this->myDOMNode->textContent; |
||||
} |
||||
|
||||
function has_attributes() |
||||
{ |
||||
return $this->myDOMNode->hasAttributes(); |
||||
} |
||||
|
||||
function has_child_nodes() |
||||
{ |
||||
return $this->myDOMNode->hasChildNodes(); |
||||
} |
||||
|
||||
function insert_before($newnode, $refnode) |
||||
{ |
||||
return self::_newDOMElement($this->myDOMNode->insertBefore($this->_importNode($newnode), |
||||
$refnode == null ? null : $refnode->myDOMNode), $this->myOwnerDocument); |
||||
} |
||||
|
||||
function is_blank_node() |
||||
{ |
||||
return ($this->myDOMNode->nodeType === XML_TEXT_NODE) && preg_match('%^\s*$%', $this->myDOMNode->nodeValue); |
||||
} |
||||
|
||||
function last_child() |
||||
{ |
||||
return self::_newDOMElement($this->myDOMNode->lastChild, $this->myOwnerDocument); |
||||
} |
||||
|
||||
function new_child($name, $content) |
||||
{ |
||||
$mySubNode = $this->myDOMNode->ownerDocument->createElement($name); |
||||
$mySubNode->appendChild($this->myDOMNode->ownerDocument->createTextNode(_entityDecode($content))); |
||||
$this->myDOMNode->appendChild($mySubNode); |
||||
return new php4DOMElement($mySubNode, $this->myOwnerDocument); |
||||
} |
||||
|
||||
function next_sibling() |
||||
{ |
||||
return self::_newDOMElement($this->myDOMNode->nextSibling, $this->myOwnerDocument); |
||||
} |
||||
|
||||
function node_name() |
||||
{ |
||||
return ($this->myDOMNode->nodeType === XML_ELEMENT_NODE) ? $this->myDOMNode->localName : $this->myDOMNode->nodeName; |
||||
} //Avoid namespace prefix for DOMElement |
||||
|
||||
function node_type() |
||||
{ |
||||
return $this->myDOMNode->nodeType; |
||||
} |
||||
|
||||
function node_value() |
||||
{ |
||||
return $this->myDOMNode->nodeValue; |
||||
} |
||||
|
||||
function owner_document() |
||||
{ |
||||
return $this->myOwnerDocument; |
||||
} |
||||
|
||||
function parent_node() |
||||
{ |
||||
return self::_newDOMElement($this->myDOMNode->parentNode, $this->myOwnerDocument); |
||||
} |
||||
|
||||
function prefix() |
||||
{ |
||||
return $this->myDOMNode->prefix; |
||||
} |
||||
|
||||
function previous_sibling() |
||||
{ |
||||
return self::_newDOMElement($this->myDOMNode->previousSibling, $this->myOwnerDocument); |
||||
} |
||||
|
||||
function remove_child($oldchild) |
||||
{ |
||||
return self::_newDOMElement($this->myDOMNode->removeChild($oldchild->myDOMNode), $this->myOwnerDocument); |
||||
} |
||||
|
||||
function replace_child($newnode, $oldnode) |
||||
{ |
||||
return self::_newDOMElement($this->myDOMNode->replaceChild($this->_importNode($newnode), $oldnode->myDOMNode), |
||||
$this->myOwnerDocument); |
||||
} |
||||
|
||||
function replace_node($newnode) |
||||
{ |
||||
return self::_newDOMElement($this->myDOMNode->parentNode->replaceChild($this->_importNode($newnode), |
||||
$this->myDOMNode), $this->myOwnerDocument); |
||||
} |
||||
|
||||
function set_content($text) |
||||
{ |
||||
return $this->myDOMNode->appendChild($this->myDOMNode->ownerDocument->createTextNode(_entityDecode($text))); |
||||
} //Entity problem reported by AL-DesignWorks 2007-09-07 |
||||
|
||||
//function set_name($name) {return $this->myOwnerDocument->renameNode($this->myDOMNode,$this->myDOMNode->namespaceURI,$name);} |
||||
function set_namespace($uri, $prefix = null) |
||||
{//Contributions by Daniel Walker 2006-09-08 |
||||
$nsprefix = $this->myDOMNode->lookupPrefix($uri); |
||||
if ($nsprefix == null) { |
||||
$nsprefix = $prefix == null ? $nsprefix = 'a' . sprintf('%u', crc32($uri)) : $prefix; |
||||
if ($this->myDOMNode->nodeType === XML_ATTRIBUTE_NODE) { |
||||
if (($prefix != null) && $this->myDOMNode->ownerElement->hasAttributeNS('http://www.w3.org/2000/xmlns/', |
||||
$nsprefix) && |
||||
($this->myDOMNode->ownerElement->getAttributeNS('http://www.w3.org/2000/xmlns/', $nsprefix) != $uri) |
||||
) {//Remove namespace |
||||
$parent = $this->myDOMNode->ownerElement; |
||||
$parent->removeAttributeNode($this->myDOMNode); |
||||
$parent->setAttribute($this->myDOMNode->localName, $this->myDOMNode->nodeValue); |
||||
$this->myDOMNode = $parent->getAttributeNode($this->myDOMNode->localName); |
||||
return; |
||||
} |
||||
$this->myDOMNode->ownerElement->setAttributeNS('http://www.w3.org/2000/xmlns/', 'xmlns:' . $nsprefix, |
||||
$uri); |
||||
} |
||||
} |
||||
if ($this->myDOMNode->nodeType === XML_ATTRIBUTE_NODE) { |
||||
$parent = $this->myDOMNode->ownerElement; |
||||
$parent->removeAttributeNode($this->myDOMNode); |
||||
$parent->setAttributeNS($uri, $nsprefix . ':' . $this->myDOMNode->localName, $this->myDOMNode->nodeValue); |
||||
$this->myDOMNode = $parent->getAttributeNodeNS($uri, $this->myDOMNode->localName); |
||||
} elseif ($this->myDOMNode->nodeType === XML_ELEMENT_NODE) { |
||||
$NewNode = $this->myDOMNode->ownerDocument->createElementNS($uri, |
||||
$nsprefix . ':' . $this->myDOMNode->localName); |
||||
foreach ($this->myDOMNode->attributes as $n) { |
||||
$NewNode->appendChild($n->cloneNode(true)); |
||||
} |
||||
foreach ($this->myDOMNode->childNodes as $n) { |
||||
$NewNode->appendChild($n->cloneNode(true)); |
||||
} |
||||
$xpath = new DOMXPath($this->myDOMNode->ownerDocument); |
||||
$myDOMNodeList = $xpath->query('namespace::*[name()!="xml"]', $this->myDOMNode); //Add old namespaces |
||||
foreach ($myDOMNodeList as $n) { |
||||
$NewNode->setAttributeNS('http://www.w3.org/2000/xmlns/', $n->nodeName, $n->nodeValue); |
||||
} |
||||
$this->myDOMNode->parentNode->replaceChild($NewNode, $this->myDOMNode); |
||||
$this->myDOMNode = $NewNode; |
||||
} |
||||
} |
||||
|
||||
function unlink_node() |
||||
{ |
||||
if ($this->myDOMNode->parentNode != null) { |
||||
if ($this->myDOMNode->nodeType === XML_ATTRIBUTE_NODE) { |
||||
$this->myDOMNode->parentNode->removeAttributeNode($this->myDOMNode); |
||||
} else { |
||||
$this->myDOMNode->parentNode->removeChild($this->myDOMNode); |
||||
} |
||||
} |
||||
} |
||||
|
||||
protected function _importNode($newnode) |
||||
{ |
||||
return $this->myOwnerDocument === $newnode->myOwnerDocument ? $newnode->myDOMNode : $this->myOwnerDocument->myDOMNode->importNode($newnode->myDOMNode, |
||||
true); |
||||
} //To import DOMNode from another DOMDocument |
||||
|
||||
static function _newDOMElement($aDOMNode, $aOwnerDocument) |
||||
{//Check the PHP5 DOMNode before creating a new associated PHP4 DOMNode wrapper |
||||
if ($aDOMNode == null) { |
||||
return null; |
||||
} |
||||
switch ($aDOMNode->nodeType) { |
||||
case XML_ELEMENT_NODE: |
||||
return new php4DOMElement($aDOMNode, $aOwnerDocument); |
||||
case XML_TEXT_NODE: |
||||
return new php4DOMText($aDOMNode, $aOwnerDocument); |
||||
case XML_ATTRIBUTE_NODE: |
||||
return new php4DOMAttr($aDOMNode, $aOwnerDocument); |
||||
case XML_PI_NODE: |
||||
return new php4DomProcessingInstruction($aDOMNode, $aOwnerDocument); |
||||
default: |
||||
return new php4DOMNode($aDOMNode, $aOwnerDocument); |
||||
} |
||||
} |
||||
} |
||||
|
||||
class php4DomProcessingInstruction extends php4DOMNode |
||||
{ |
||||
function data() |
||||
{ |
||||
return $this->myDOMNode->data; |
||||
} |
||||
|
||||
function target() |
||||
{ |
||||
return $this->myDOMNode->target; |
||||
} |
||||
} |
||||
|
||||
class php4DOMText extends php4DOMNode |
||||
{ |
||||
function __get($name) |
||||
{ |
||||
if ($name === 'tagname') { |
||||
return '#text'; |
||||
} else { |
||||
return parent::__get($name); |
||||
} |
||||
} |
||||
|
||||
function tagname() |
||||
{ |
||||
return '#text'; |
||||
} |
||||
|
||||
function set_content($text) |
||||
{ |
||||
$this->myDOMNode->nodeValue = $text; |
||||
return true; |
||||
} |
||||
} |
||||
|
||||
if (!defined('XPATH_NODESET')) { |
||||
define('XPATH_UNDEFINED', 0); |
||||
define('XPATH_NODESET', 1); |
||||
define('XPATH_BOOLEAN', 2); |
||||
define('XPATH_NUMBER', 3); |
||||
define('XPATH_STRING', 4); |
||||
/*define('XPATH_POINT',5); |
||||
define('XPATH_RANGE',6); |
||||
define('XPATH_LOCATIONSET',7); |
||||
define('XPATH_USERS',8); |
||||
define('XPATH_XSLT_TREE',9);*/ |
||||
} |
||||
|
||||
class php4DOMNodelist |
||||
{ |
||||
private $myDOMNodelist; |
||||
public $nodeset; |
||||
public $type = XPATH_UNDEFINED; |
||||
public $value; |
||||
|
||||
function php4DOMNodelist($aDOMNodelist, $aOwnerDocument) |
||||
{ |
||||
if (!isset($aDOMNodelist)) { |
||||
return; |
||||
} elseif (is_object($aDOMNodelist) || is_array($aDOMNodelist)) { |
||||
if ($aDOMNodelist->length > 0) { |
||||
$this->myDOMNodelist = $aDOMNodelist; |
||||
$this->nodeset = array(); |
||||
$this->type = XPATH_NODESET; |
||||
$i = 0; |
||||
while ($node = $this->myDOMNodelist->item($i++)) { |
||||
$this->nodeset[] = php4DOMNode::_newDOMElement($node, $aOwnerDocument); |
||||
} |
||||
} |
||||
} elseif (is_int($aDOMNodelist) || is_float($aDOMNodelist)) { |
||||
$this->type = XPATH_NUMBER; |
||||
$this->value = $aDOMNodelist; |
||||
} elseif (is_bool($aDOMNodelist)) { |
||||
$this->type = XPATH_BOOLEAN; |
||||
$this->value = $aDOMNodelist; |
||||
} elseif (is_string($aDOMNodelist)) { |
||||
$this->type = XPATH_STRING; |
||||
$this->value = $aDOMNodelist; |
||||
} |
||||
} |
||||
} |
||||
|
||||
class php4DOMXPath |
||||
{ |
||||
public $myDOMXPath; |
||||
private $myOwnerDocument; |
||||
|
||||
function php4DOMXPath($dom_document) |
||||
{ |
||||
//TODO: If $dom_document is a DomElement, make that default $contextnode and modify XPath. Ex: '/test' |
||||
$this->myOwnerDocument = $dom_document->myOwnerDocument; |
||||
$this->myDOMXPath = new DOMXPath($this->myOwnerDocument->myDOMNode); |
||||
} |
||||
|
||||
function xpath_eval($eval_str, $contextnode = null) |
||||
{ |
||||
if (method_exists($this->myDOMXPath, 'evaluate')) { |
||||
$xp = isset($contextnode) ? $this->myDOMXPath->evaluate($eval_str, |
||||
$contextnode->myDOMNode) : $this->myDOMXPath->evaluate($eval_str); |
||||
} else { |
||||
$xp = isset($contextnode) ? $this->myDOMXPath->query($eval_str, |
||||
$contextnode->myDOMNode) : $this->myDOMXPath->query($eval_str); |
||||
} |
||||
$xp = new php4DOMNodelist($xp, $this->myOwnerDocument); |
||||
return ($xp->type === XPATH_UNDEFINED) ? false : $xp; |
||||
} |
||||
|
||||
function xpath_register_ns($prefix, $namespaceURI) |
||||
{ |
||||
return $this->myDOMXPath->registerNamespace($prefix, $namespaceURI); |
||||
} |
||||
} |
||||
|
||||
if (extension_loaded('xsl')) {//See also: http://alexandre.alapetite.net/doc-alex/xslt-php4-php5/ |
||||
function domxml_xslt_stylesheet($xslstring) |
||||
{ |
||||
return new php4DomXsltStylesheet(DOMDocument::loadXML($xslstring)); |
||||
} |
||||
|
||||
function domxml_xslt_stylesheet_doc($dom_document) |
||||
{ |
||||
return new php4DomXsltStylesheet($dom_document); |
||||
} |
||||
|
||||
function domxml_xslt_stylesheet_file($xslfile) |
||||
{ |
||||
return new php4DomXsltStylesheet(DOMDocument::load($xslfile)); |
||||
} |
||||
|
||||
class php4DomXsltStylesheet |
||||
{ |
||||
private $myxsltProcessor; |
||||
|
||||
function php4DomXsltStylesheet($dom_document) |
||||
{ |
||||
$this->myxsltProcessor = new xsltProcessor(); |
||||
$this->myxsltProcessor->importStyleSheet($dom_document); |
||||
} |
||||
|
||||
function process($dom_document, $xslt_parameters = array(), $param_is_xpath = false) |
||||
{ |
||||
foreach ($xslt_parameters as $param => $value) { |
||||
$this->myxsltProcessor->setParameter('', $param, $value); |
||||
} |
||||
$myphp4DOMDocument = new php4DOMDocument(); |
||||
$myphp4DOMDocument->myDOMNode = $this->myxsltProcessor->transformToDoc($dom_document->myDOMNode); |
||||
return $myphp4DOMDocument; |
||||
} |
||||
|
||||
function result_dump_file($dom_document, $filename) |
||||
{ |
||||
$html = $dom_document->myDOMNode->saveHTML(); |
||||
file_put_contents($filename, $html); |
||||
return $html; |
||||
} |
||||
|
||||
function result_dump_mem($dom_document) |
||||
{ |
||||
return $dom_document->myDOMNode->saveHTML(); |
||||
} |
||||
} |
||||
} |
||||
@ -1,27 +0,0 @@ |
||||
<?php |
||||
|
||||
/** |
||||
* @file languages/spanish.php |
||||
* @author Iván-Benjamín García Torà <ivaniclixx AT gmail DOT com> |
||||
* @sa @link internalLang Internationalization @endlink |
||||
* @ingroup internalLang |
||||
*/ |
||||
|
||||
$this->_strings = array( |
||||
CAS_STR_USING_SERVER |
||||
=> 'usant servidor', |
||||
CAS_STR_AUTHENTICATION_WANTED |
||||
=> 'Autentificació CAS necessària!', |
||||
CAS_STR_LOGOUT |
||||
=> 'Sortida de CAS necessària!', |
||||
CAS_STR_SHOULD_HAVE_BEEN_REDIRECTED |
||||
=> 'Ja hauria d\ haver estat redireccionat al servidor CAS. Feu click <a href="%s">aquí</a> per a continuar.', |
||||
CAS_STR_AUTHENTICATION_FAILED |
||||
=> 'Autentificació CAS fallida!', |
||||
CAS_STR_YOU_WERE_NOT_AUTHENTICATED |
||||
=> '<p>No estàs autentificat.</p><p>Pots tornar a intentar-ho fent click <a href="%s">aquí</a>.</p><p>Si el problema persisteix hauría de contactar amb l\'<a href="mailto:%s">administrador d\'aquest llocc</a>.</p>', |
||||
CAS_STR_SERVICE_UNAVAILABLE |
||||
=> 'El servei `<b>%s</b>\' no està disponible (<b>%s</b>).' |
||||
); |
||||
|
||||
?> |
||||
@ -1,27 +0,0 @@ |
||||
<?php |
||||
|
||||
/** |
||||
* @file languages/english.php |
||||
* @author Pascal Aubry <pascal.aubry at univ-rennes1.fr> |
||||
* @sa @link internalLang Internationalization @endlink |
||||
* @ingroup internalLang |
||||
*/ |
||||
|
||||
$this->_strings = array( |
||||
CAS_STR_USING_SERVER |
||||
=> 'using server', |
||||
CAS_STR_AUTHENTICATION_WANTED |
||||
=> 'CAS Authentication wanted!', |
||||
CAS_STR_LOGOUT |
||||
=> 'CAS logout wanted!', |
||||
CAS_STR_SHOULD_HAVE_BEEN_REDIRECTED |
||||
=> 'You should already have been redirected to the CAS server. Click <a href="%s">here</a> to continue.', |
||||
CAS_STR_AUTHENTICATION_FAILED |
||||
=> 'CAS Authentication failed!', |
||||
CAS_STR_YOU_WERE_NOT_AUTHENTICATED |
||||
=> '<p>You were not authenticated.</p><p>You may submit your request again by clicking <a href="%s">here</a>.</p><p>If the problem persists, you may contact <a href="mailto:%s">the administrator of this site</a>.</p>', |
||||
CAS_STR_SERVICE_UNAVAILABLE |
||||
=> 'The service `<b>%s</b>\' is not available (<b>%s</b>).' |
||||
); |
||||
|
||||
?> |
||||
@ -1,27 +0,0 @@ |
||||
<?php |
||||
|
||||
/** |
||||
* @file languages/german.php |
||||
* @author Henrik Genssen <hg at mediafactory.de> |
||||
* @sa @link internalLang Internationalization @endlink |
||||
* @ingroup internalLang |
||||
*/ |
||||
|
||||
$this->_strings = array( |
||||
CAS_STR_USING_SERVER |
||||
=> 'via Server', |
||||
CAS_STR_AUTHENTICATION_WANTED |
||||
=> 'CAS Authentifizierung erforderlich!', |
||||
CAS_STR_LOGOUT |
||||
=> 'CAS Abmeldung!', |
||||
CAS_STR_SHOULD_HAVE_BEEN_REDIRECTED |
||||
=> 'eigentlich häten Sie zum CAS Server weitergeleitet werden sollen. Drücken Sie <a href="%s">hier</a> um fortzufahren.', |
||||
CAS_STR_AUTHENTICATION_FAILED |
||||
=> 'CAS Anmeldung fehlgeschlagen!', |
||||
CAS_STR_YOU_WERE_NOT_AUTHENTICATED |
||||
=> '<p>Sie wurden nicht angemeldet.</p><p>Um es erneut zu versuchen klicken Sie <a href="%s">hier</a>.</p><p>Wenn das Problem bestehen bleibt, kontkatieren Sie den <a href="mailto:%s">Administrator</a> dieser Seite.</p>', |
||||
CAS_STR_SERVICE_UNAVAILABLE |
||||
=> 'Der Dienst `<b>%s</b>\' ist nicht verfügbar (<b>%s</b>).' |
||||
); |
||||
|
||||
?> |
||||
@ -1,24 +0,0 @@ |
||||
<?php |
||||
|
||||
/** |
||||
* @file languages/languages.php |
||||
* Internationalization constants |
||||
* @author Pascal Aubry <pascal.aubry at univ-rennes1.fr> |
||||
* @sa @link internalLang Internationalization @endlink |
||||
* @ingroup internalLang |
||||
*/ |
||||
|
||||
//@{ |
||||
/** |
||||
* a phpCAS string index |
||||
*/ |
||||
define("CAS_STR_USING_SERVER", 1); |
||||
define("CAS_STR_AUTHENTICATION_WANTED", 2); |
||||
define("CAS_STR_LOGOUT", 3); |
||||
define("CAS_STR_SHOULD_HAVE_BEEN_REDIRECTED", 4); |
||||
define("CAS_STR_AUTHENTICATION_FAILED", 5); |
||||
define("CAS_STR_YOU_WERE_NOT_AUTHENTICATED", 6); |
||||
define("CAS_STR_SERVICE_UNAVAILABLE", 7); |
||||
//@} |
||||
|
||||
?> |
||||
@ -1,27 +0,0 @@ |
||||
<?php |
||||
|
||||
/** |
||||
* @file languages/spanish.php |
||||
* @author Iván-Benjamín García Torà <ivaniclixx AT gmail DOT com> |
||||
* @sa @link internalLang Internationalization @endlink |
||||
* @ingroup internalLang |
||||
*/ |
||||
|
||||
$this->_strings = array( |
||||
CAS_STR_USING_SERVER |
||||
=> 'usando servidor', |
||||
CAS_STR_AUTHENTICATION_WANTED |
||||
=> '¡Autentificación CAS necesaria!', |
||||
CAS_STR_LOGOUT |
||||
=> '¡Salida CAS necesaria!', |
||||
CAS_STR_SHOULD_HAVE_BEEN_REDIRECTED |
||||
=> 'Ya debería haber sido redireccionado al servidor CAS. Haga click <a href="%s">aquí</a> para continuar.', |
||||
CAS_STR_AUTHENTICATION_FAILED |
||||
=> '¡Autentificación CAS fallida!', |
||||
CAS_STR_YOU_WERE_NOT_AUTHENTICATED |
||||
=> '<p>No estás autentificado.</p><p>Puedes volver a intentarlo haciendo click <a href="%s">aquí</a>.</p><p>Si el problema persiste debería contactar con el <a href="mailto:%s">administrador de este sitio</a>.</p>', |
||||
CAS_STR_SERVICE_UNAVAILABLE |
||||
=> 'El servicio `<b>%s</b>\' no está disponible (<b>%s</b>).' |
||||
); |
||||
|
||||
?> |
||||
@ -1,56 +0,0 @@ |
||||
<?php |
||||
//---------------------------------------------------------------------- |
||||
// CAS PLUGIN |
||||
//---------------------------------------------------------------------- |
||||
// Copyright (c) 2006-2007 University Marc Bloch (UMB) |
||||
//---------------------------------------------------------------------- |
||||
// This program is under the terms of the GENERAL PUBLIC LICENSE (GPL) |
||||
// as published by the FREE SOFTWARE FOUNDATION. The GPL is available |
||||
// through the world-wide-web at http://www.gnu.org/copyleft/gpl.html |
||||
//---------------------------------------------------------------------- |
||||
// Authors: Pierre Cahard |
||||
//---------------------------------------------------------------------- |
||||
// Load required |
||||
require '../../inc/global.inc.php'; |
||||
|
||||
require_once 'authcas.php'; |
||||
use ChamiloSession as Session; |
||||
|
||||
global $cas_auth_ver, $cas_auth_server, $cas_auth_port, $cas_auth_uri; |
||||
// phpCAS |
||||
|
||||
/* |
||||
If we are not logged and in our browser enter an URL with a name of a course |
||||
e.g. http://www.chamilo.fr/chamilo/courses/COURSTESTOSETE/?id_session=0 |
||||
We go to page api_not_allowed : |
||||
> You are not allowed to see this page. |
||||
> Sorry, you are not allowed to access this page, or maybe your connection has expired. |
||||
> Please click your browser's \"Back\" button or follow the link below to return to the previous page |
||||
If we click on the link to go to homepage, some datas are entered in $_SESSION and if we enter our CAS login, |
||||
we go to api_not_allowad_page again and again |
||||
As a result, if we are not logged on, we have to destroy the session variables, before calling CAS page |
||||
*/ |
||||
if (api_is_anonymous()) { |
||||
Session::destroy(); |
||||
} |
||||
|
||||
if (cas_configured()) { |
||||
$firstpage = ""; |
||||
if (isset($_GET['firstpage'])) { |
||||
$firstpage = $_GET['firstpage']; |
||||
setcookie("GotoCourse", $firstpage); |
||||
} |
||||
if (!is_object($PHPCAS_CLIENT)) { |
||||
phpCAS::client( |
||||
$cas_auth_ver, |
||||
$cas_auth_server, |
||||
$cas_auth_port, |
||||
$cas_auth_uri |
||||
); |
||||
phpCAS::setNoCasServerValidation(); |
||||
} |
||||
phpCAS::forceAuthentication(); |
||||
header('Location: '.api_get_path(WEB_PATH).api_get_setting('page_after_login')); |
||||
} else { |
||||
header('Location: '.api_get_path(WEB_PATH)); |
||||
} |
||||
@ -1,13 +0,0 @@ |
||||
<?php |
||||
/* For licensing terms, see /license.txt */ |
||||
/* |
||||
Call this file to disconnect from CAS session. |
||||
logoutWithUrl() not used because with CAS v3 you cannot redirect your logout to a specific URL |
||||
because of security reason. |
||||
*/ |
||||
require '../..//inc/global.inc.php'; |
||||
require_once 'authcas.php'; |
||||
global $cas_auth_ver, $cas_auth_server, $cas_auth_port, $cas_auth_uri; |
||||
|
||||
phpCAS::client($cas_auth_ver, $cas_auth_server, $cas_auth_port, $cas_auth_uri); |
||||
phpCAS::logout(); |
||||
Loading…
Reference in new issue