df/d1d/client4_8php_source.html

 <?php

 // include internationalization stuff
 include_once(dirname(__FILE__).'/languages/languages.php');

 // include PGT storage classes
 include_once(dirname(__FILE__).'/PGTStorage/pgt-main.php');

 // handle node name
 function hnodename($name)
 {
         if ($i = is_int(strpos($name, ":")))
         {
                 return substr($name, $i);
         }
         else
         {
                 return $name;
         }
 }

 class CASClient
 {

   // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   // XX                                                                    XX
   // XX                          CONFIGURATION                             XX
   // XX                                                                    XX
   // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

   // ########################################################################
   //  HTML OUTPUT
   // ########################################################################
   function HTMLFilterOutput($str)
     {
       $str = str_replace('__CAS_VERSION__',$this->getServerVersion(),$str);
       $str = str_replace('__PHPCAS_VERSION__',phpCAS::getVersion(),$str);
       $str = str_replace('__SERVER_BASE_URL__',$this->getServerBaseURL(),$str);
       echo $str;
     }

   var $_output_header = '';

   function printHTMLHeader($title)
     {
       $this->HTMLFilterOutput(str_replace('__TITLE__',
                                           $title,
                                           (empty($this->_output_header)
                                            ? '<html><head><title>__TITLE__</title></head><body><h1>__TITLE__</h1>'
                                            : $this->output_header)
                                           )
                               );
     }

   var $_output_footer = '';

   function printHTMLFooter()
     {
       $this->HTMLFilterOutput(empty($this->_output_footer)
                               ?('<hr><address>phpCAS __PHPCAS_VERSION__ '.$this->getString(CAS_STR_USING_SERVER).' <a href="__SERVER_BASE_URL__">__SERVER_BASE_URL__</a> (CAS __CAS_VERSION__)</a></address></body></html>')
                               :$this->_output_footer);
     }

   function setHTMLHeader($header)
     {
       $this->_output_header = $header;
     }

   function setHTMLFooter($footer)
     {
       $this->_output_footer = $footer;
     }

   // ########################################################################
   //  INTERNATIONALIZATION
   // ########################################################################
   var $_lang = '';

   function getLang()
     {
       if ( empty($this->_lang) )
         $this->setLang(PHPCAS_LANG_DEFAULT);
       return $this->_lang;
     }

   var $_strings;

   function getString($str)
     {
       // call CASclient::getLang() to be sure the language is initialized
       $this->getLang();

       if ( !isset($this->_strings[$str]) ) {
         trigger_error('string `'.$str.'\' not defined for language `'.$this->getLang().'\'',E_USER_ERROR);
       }
       return $this->_strings[$str];
     }

   function setLang($lang)
     {
       // include the corresponding language file
       include_once(dirname(__FILE__).'/languages/'.$lang.'.php');

       if ( !is_array($this->_strings) ) {
         trigger_error('language `'.$lang.'\' is not implemented',E_USER_ERROR);
       }
       $this->_lang = $lang;
     }

   // ########################################################################
   //  CAS SERVER CONFIG
   // ########################################################################
   var $_server = array(
                        'version' => -1,
                        'hostname' => 'none',
                        'port' => -1,
                        'uri' => 'none'
                        );

   function getServerVersion()
     {
       return $this->_server['version'];
     }

   function getServerHostname()
     { return $this->_server['hostname']; }

   function getServerPort()
     { return $this->_server['port']; }

   function getServerURI()
     { return $this->_server['uri']; }

   function getServerBaseURL()
     {
       // the URL is build only when needed
       if ( empty($this->_server['base_url']) ) {
         $this->_server['base_url'] = 'https://'
           .$this->getServerHostname()
           .':'
           .$this->getServerPort()
           .$this->getServerURI();
       }
       return $this->_server['base_url'];
     }

   function getServerLoginURL($gateway)
     {
       phpCAS::traceBegin();
       // the URL is build only when needed
       if ( empty($this->_server['login_url']) ) {
         $this->_server['login_url'] = $this->getServerBaseURL();
         $this->_server['login_url'] .= 'login?service=';
         $this->_server['login_url'] .= preg_replace('/&/','%26',$this->getURL());
         if ($gateway) {
           $this->_server['login_url'] .= '&gateway=true';
         }
       }
       phpCAS::traceEnd($this->_server['login_url']);
       return $this->_server['login_url'];
     }

   function getServerServiceValidateURL()
     {
       // the URL is build only when needed
       if ( empty($this->_server['service_validate_url']) ) {
         switch ($this->getServerVersion()) {
         case CAS_VERSION_1_0:
           $this->_server['service_validate_url'] = $this->getServerBaseURL().'validate';
           break;
         case CAS_VERSION_2_0:
           $this->_server['service_validate_url'] = $this->getServerBaseURL().'serviceValidate';
           break;
         }
       }
       return $this->_server['service_validate_url'].'?service='.preg_replace('/&/','%26',$this->getURL());
     }

   function getServerProxyValidateURL()
     {
       // the URL is build only when needed
       if ( empty($this->_server['proxy_validate_url']) ) {
         switch ($this->getServerVersion()) {
         case CAS_VERSION_1_0:
           $this->_server['proxy_validate_url'] = '';
           break;
         case CAS_VERSION_2_0:
           $this->_server['proxy_validate_url'] = $this->getServerBaseURL().'proxyValidate';
           break;
         }
       }
       return $this->_server['proxy_validate_url'].'?service='.preg_replace('/&/','%26',$this->getURL());
     }

   function getServerProxyURL()
     {
       // the URL is build only when needed
       if ( empty($this->_server['proxy_url']) ) {
         switch ($this->getServerVersion()) {
         case CAS_VERSION_1_0:
           $this->_server['proxy_url'] = '';
           break;
         case CAS_VERSION_2_0:
           $this->_server['proxy_url'] = $this->getServerBaseURL().'proxy';
           break;
         }
       }
       return $this->_server['proxy_url'];
     }

   function getServerLogoutURL()
     {
       // the URL is build only when needed
       if ( empty($this->_server['logout_url']) ) {
         $this->_server['logout_url'] = $this->getServerBaseURL().'logout';
       }
       return $this->_server['logout_url'];
     }

   // ########################################################################
   //  CONSTRUCTOR
   // ########################################################################
   function CASClient($server_version,
                      $proxy,
                      $server_hostname,
                      $server_port,
                      $server_uri,
                      $start_session = true)
     {
       phpCAS::traceBegin();

       // activate session mechanism if desired
       if ($start_session) {
            session_start();
       }

       $this->_proxy = $proxy;

       // check version
       switch ($server_version) {
       case CAS_VERSION_1_0:
         if ( $this->isProxy() )
           phpCAS::error('CAS proxies are not supported in CAS '
                         .$server_version);
         break;
       case CAS_VERSION_2_0:
         break;
       default:
         phpCAS::error('this version of CAS (`'
                       .$server_version
                       .'\') is not supported by phpCAS '
                         .phpCAS::getVersion());
       }
       $this->_server['version'] = $server_version;

       // check hostname
       if ( empty($server_hostname)
            || !preg_match('/[\.\d\-abcdefghijklmnopqrstuvwxyz]*/',$server_hostname) ) {
         phpCAS::error('bad CAS server hostname (`'.$server_hostname.'\')');
       }
       $this->_server['hostname'] = $server_hostname;

       // check port
       if ( $server_port == 0
            || !is_int($server_port) ) {
         phpCAS::error('bad CAS server port (`'.$server_hostname.'\')');
       }
       $this->_server['port'] = $server_port;

       // check URI
       if ( !preg_match('/[\.\d\-_abcdefghijklmnopqrstuvwxyz\/]*/',$server_uri) ) {
         phpCAS::error('bad CAS server URI (`'.$server_uri.'\')');
       }
       // add leading and trailing `/' and remove doubles
       $server_uri = preg_replace('/\/\//','/','/'.$server_uri.'/');
       $this->_server['uri'] = $server_uri;

       // set to callback mode if PgtIou and PgtId CGI GET parameters are provided
       if ( $this->isProxy() ) {
         $this->setCallbackMode(!empty($_GET['pgtIou'])&&!empty($_GET['pgtId']));
       }

       if ( $this->isCallbackMode() ) {
         // callback mode: check that phpCAS is secured
         if ( $_SERVER['HTTPS'] != 'on' ) {
           phpCAS::error('CAS proxies must be secured to use phpCAS; PGT\'s will not be received from the CAS server');
         }
       } else {
         // normal mode: get ticket and remove it from CGI parameters for developpers
         $ticket = $_GET['ticket'];
         // at first check for a Service Ticket
         if( preg_match('/^ST-/',$ticket)) {
           phpCAS::trace('ST \''.$ticket.'\' found');
           // ST present
           $this->setST($ticket);
         }
         // in a second time check for a Proxy Ticket (CAS >= 2.0)
         else if( ($this->getServerVersion()!=CAS_VERSION_1_0) && preg_match('/^PT-/',$ticket) ) {
           phpCAS::trace('PT \''.$ticket.'\' found');
           $this->setPT($ticket);
         }
         // ill-formed ticket, halt
         else if ( !empty($ticket) ) {
           phpCAS::error('ill-formed ticket found in the URL (ticket=`'.htmlentities($ticket).'\')');
         }
         // ticket has been taken into account, unset it to hide it to applications
         unset($_GET['ticket']);
       }
       phpCAS::traceEnd();
     }

   // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   // XX                                                                    XX
   // XX                           AUTHENTICATION                           XX
   // XX                                                                    XX
   // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

   var $_user = '';

   function setUser($user)
     {
       $this->_user = $user;
     }

   function getUser()
     {
       if ( empty($this->_user) ) {
         phpCAS::error('this method should be used only after '.__CLASS__.'::forceAuthentication() or '.__CLASS__.'::isAuthenticated()');
       }
       return $this->_user;
     }

   function forceAuthentication()
     {
       phpCAS::traceBegin();

       if ( $this->isAuthenticated() ) {
         // the user is authenticated, nothing to be done.
             phpCAS::trace('no need to authenticate');
             $res = TRUE;
       } else {
             // the user is not authenticated, redirect to the CAS server
         unset($_SESSION['phpCAS']['auth_checked']);
             $this->redirectToCas(FALSE/* no gateway */);
             // never reached
             $res = FALSE;
       }
       phpCAS::traceEnd($res);
       return $res;
     }

   function checkAuthentication()
     {
       phpCAS::traceBegin();

       if ( $this->isAuthenticated() ) {
             phpCAS::trace('user is authenticated');
             $res = TRUE;
       } else if (isset($_SESSION['phpCAS']['auth_checked'])) {
         // the previous request has redirected the client to the CAS server with gateway=true
         unset($_SESSION['phpCAS']['auth_checked']);
         $res = FALSE;
       } else {
         $_SESSION['phpCAS']['auth_checked'] = true;
             $this->redirectToCas(TRUE/* gateway */);
             // never reached
             $res = FALSE;
       }
       phpCAS::traceEnd($res);
       return $res;
     }

   function isAuthenticated()
     {
       phpCAS::traceBegin();
       $res = FALSE;
       $validate_url = '';

       if ( $this->wasPreviouslyAuthenticated() ) {
         // the user has already (previously during the session) been
         // authenticated, nothing to be done.
         phpCAS::trace('user was already authenticated, no need to look for tickets');
         $res = TRUE;
       } elseif ( $this->hasST() ) {
         // if a Service Ticket was given, validate it
         phpCAS::trace('ST `'.$this->getST().'\' is present');
         $this->validateST($validate_url,$text_response,$tree_response); // if it fails, it halts
         phpCAS::trace('ST `'.$this->getST().'\' was validated');
         if ( $this->isProxy() ) {
           $this->validatePGT($validate_url,$text_response,$tree_response); // idem
           phpCAS::trace('PGT `'.$this->getPGT().'\' was validated');
           $_SESSION['phpCAS']['pgt'] = $this->getPGT();
         }
         $_SESSION['phpCAS']['user'] = $this->getUser();
         $res = TRUE;
       } elseif ( $this->hasPT() ) {
         // if a Proxy Ticket was given, validate it
         phpCAS::trace('PT `'.$this->getPT().'\' is present');
         $this->validatePT($validate_url,$text_response,$tree_response); // note: if it fails, it halts
         phpCAS::trace('PT `'.$this->getPT().'\' was validated');
         if ( $this->isProxy() ) {
           $this->validatePGT($validate_url,$text_response,$tree_response); // idem
           phpCAS::trace('PGT `'.$this->getPGT().'\' was validated');
           $_SESSION['phpCAS']['pgt'] = $this->getPGT();
         }
         $_SESSION['phpCAS']['user'] = $this->getUser();
         $res = TRUE;
       } else {
         // no ticket given, not authenticated
         phpCAS::trace('no ticket found');
       }

       phpCAS::traceEnd($res);
       return $res;
     }

   function wasPreviouslyAuthenticated()
     {
       phpCAS::traceBegin();

       if ( $this->isCallbackMode() ) {
         $this->callback();
       }

       $auth = FALSE;

       if ( $this->isProxy() ) {
         // CAS proxy: username and PGT must be present
         if ( !empty($_SESSION['phpCAS']['user']) && !empty($_SESSION['phpCAS']['pgt']) ) {
           // authentication already done
           $this->setUser($_SESSION['phpCAS']['user']);
           $this->setPGT($_SESSION['phpCAS']['pgt']);
           phpCAS::trace('user = `'.$_SESSION['phpCAS']['user'].'\', PGT = `'.$_SESSION['phpCAS']['pgt'].'\'');
           $auth = TRUE;
         } elseif ( !empty($_SESSION['phpCAS']['user']) && empty($_SESSION['phpCAS']['pgt']) ) {
           // these two variables should be empty or not empty at the same time
           phpCAS::trace('username found (`'.$_SESSION['phpCAS']['user'].'\') but PGT is empty');
           // unset all tickets to enforce authentication
           unset($_SESSION['phpCAS']);
           $this->setST('');
           $this->setPT('');
         } elseif ( empty($_SESSION['phpCAS']['user']) && !empty($_SESSION['phpCAS']['pgt']) ) {
           // these two variables should be empty or not empty at the same time
           phpCAS::trace('PGT found (`'.$_SESSION['phpCAS']['pgt'].'\') but username is empty');
           // unset all tickets to enforce authentication
           unset($_SESSION['phpCAS']);
           $this->setST('');
           $this->setPT('');
         } else {
           phpCAS::trace('neither user not PGT found');
         }
       } else {
         // `simple' CAS client (not a proxy): username must be present
         if ( !empty($_SESSION['phpCAS']['user']) ) {
           // authentication already done
           $this->setUser($_SESSION['phpCAS']['user']);
           phpCAS::trace('user = `'.$_SESSION['phpCAS']['user'].'\'');
           $auth = TRUE;
         } else {
           phpCAS::trace('no user found');
         }
       }

       phpCAS::traceEnd($auth);
       return $auth;
     }

   function redirectToCas($gateway)
     {
       phpCAS::traceBegin();
       $cas_url = $this->getServerLoginURL($gateway);
       header('Location: '.$cas_url);
       $this->printHTMLHeader($this->getString(CAS_STR_AUTHENTICATION_WANTED));
       printf('<p>'.$this->getString(CAS_STR_SHOULD_HAVE_BEEN_REDIRECTED).'</p>',$cas_url);
       $this->printHTMLFooter();
       phpCAS::traceExit();
       exit();
     }

   function logout($url = "")
     {
       phpCAS::traceBegin();
       $cas_url = $this->getServerLogoutURL();
       // v0.4.14 sebastien.gougeon at univ-rennes1.fr
       // header('Location: '.$cas_url);
       if ( $url != "" ) {
         $url = '?service=' . $url;
       }
       header('Location: '.$cas_url . $url);
       session_unset();
       session_destroy();
       $this->printHTMLHeader($this->getString(CAS_STR_LOGOUT));
       printf('<p>'.$this->getString(CAS_STR_SHOULD_HAVE_BEEN_REDIRECTED).'</p>',$cas_url);
       $this->printHTMLFooter();
       phpCAS::traceExit();
       exit();
     }

   // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   // XX                                                                    XX
   // XX                  BASIC CLIENT FEATURES (CAS 1.0)                   XX
   // XX                                                                    XX
   // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

   // ########################################################################
   //  ST
   // ########################################################################
   var $_st = '';

   function getST()
     { return $this->_st; }

   function setST($st)
     { $this->_st = $st; }

   function hasST()
     { return !empty($this->_st); }

   // ########################################################################
   //  ST VALIDATION
   // ########################################################################
   function validateST($validate_url,&$text_response,&$tree_response)
     {
       phpCAS::traceBegin();
       // build the URL to validate the ticket
       $validate_url = $this->getServerServiceValidateURL().'&ticket='.$this->getST();
       if ( $this->isProxy() ) {
         // pass the callback url for CAS proxies
         $validate_url .= '&pgtUrl='.$this->getCallbackURL();
       }

       // open and read the URL
       if ( !$this->readURL($validate_url,''/*cookies*/,$headers,$text_response,$err_msg) ) {
         phpCAS::trace('could not open URL \''.$validate_url.'\' to validate ('.$err_msg.')');
         $this->authError('ST not validated (1)',
                          $validate_url,
                          TRUE/*$no_response*/);
       }

       // analyze the result depending on the version
       switch ($this->getServerVersion()) {
       case CAS_VERSION_1_0:
         if (preg_match('/^no\n/',$text_response)) {
           phpCAS::trace('ST has not been validated');
           $this->authError('ST not validated (2)',
                        $validate_url,
                        FALSE/*$no_response*/,
                        FALSE/*$bad_response*/,
                        $text_response);
         }
         if (!preg_match('/^yes\n/',$text_response)) {
           phpCAS::trace('ill-formed response');
           $this->authError('ST not validated (3)',
                        $validate_url,
                        FALSE/*$no_response*/,
                        TRUE/*$bad_response*/,
                        $text_response);
         }
         // ST has been validated, extract the user name
         $arr = preg_split('/\n/',$text_response);
         $this->setUser(trim($arr[1]));
         break;
       case CAS_VERSION_2_0:
         // read the response of the CAS server into a DOM object
         if ( !($dom = domxml_open_mem($text_response))) {
           phpCAS::trace('domxml_open_mem() failed');
           $this->authError('ST not validated (4)',
                        $validate_url,
                        FALSE/*$no_response*/,
                        TRUE/*$bad_response*/,
                        $text_response);
         }
         // read the root node of the XML tree
         if ( !($tree_response = $dom->document_element()) ) {
           phpCAS::trace('document_element() failed');
           $this->authError('ST not validated (5)',
                        $validate_url,
                        FALSE/*$no_response*/,
                        TRUE/*$bad_response*/,
                        $text_response);
         }
         // insure that tag name is 'serviceResponse'
         if ( hnodename($tree_response->node_name()) != 'serviceResponse' ) {
           phpCAS::trace('bad XML root node (should be `serviceResponse\' instead of `'.hnodename($tree_response->node_name()).'\'');
           $this->authError('ST not validated (6)',
                        $validate_url,
                        FALSE/*$no_response*/,
                        TRUE/*$bad_response*/,
                        $text_response);
         }
         if ( sizeof($success_elements = $tree_response->get_elements_by_tagname("authenticationSuccess")) != 0) {
           // authentication succeded, extract the user name
           if ( sizeof($user_elements = $success_elements[0]->get_elements_by_tagname("user")) == 0) {
             phpCAS::trace('<authenticationSuccess> found, but no <user>');
             $this->authError('ST not validated (7)',
                          $validate_url,
                          FALSE/*$no_response*/,
                          TRUE/*$bad_response*/,
                          $text_response);
           }
           $user = trim($user_elements[0]->get_content());
           phpCAS::trace('user = `'.$user);
           $this->setUser($user);

         } else if ( sizeof($failure_elements = $tree_response->get_elements_by_tagname("authenticationFailure")) != 0) {
           phpCAS::trace('<authenticationFailure> found');
           // authentication failed, extract the error code and message
           $this->authError('ST not validated (8)',
                        $validate_url,
                        FALSE/*$no_response*/,
                        FALSE/*$bad_response*/,
                        $text_response,
                        $failure_elements[0]->get_attribute('code')/*$err_code*/,
                        trim($failure_elements[0]->get_content())/*$err_msg*/);
         } else {
           phpCAS::trace('neither <authenticationSuccess> nor <authenticationFailure> found');
           $this->authError('ST not validated (9)',
                        $validate_url,
                        FALSE/*$no_response*/,
                        TRUE/*$bad_response*/,
                        $text_response);
         }
         break;
       }

       // at this step, ST has been validated and $this->_user has been set,
       phpCAS::traceEnd(TRUE);
       return TRUE;
     }

   // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   // XX                                                                    XX
   // XX                     PROXY FEATURES (CAS 2.0)                       XX
   // XX                                                                    XX
   // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

   // ########################################################################
   //  PROXYING
   // ########################################################################
   var $_proxy;

   function isProxy()
     {
       return $this->_proxy;
     }

   // ########################################################################
   //  PGT
   // ########################################################################
   var $_pgt = '';

   function getPGT()
     { return $this->_pgt; }

   function setPGT($pgt)
     { $this->_pgt = $pgt; }

   function hasPGT()
     { return !empty($this->_pgt); }

   // ########################################################################
   //  CALLBACK MODE
   // ########################################################################
   var $_callback_mode = FALSE;

   function setCallbackMode($callback_mode)
     {
       $this->_callback_mode = $callback_mode;
     }

   function isCallbackMode()
     {
       return $this->_callback_mode;
     }

   var $_callback_url = '';

   function getCallbackURL()
     {
       // the URL is built when needed only
       if ( empty($this->_callback_url) ) {
         $final_uri = '';
             // remove the ticket if present in the URL
             $final_uri = 'https://';
             /* replaced by Julien Marchal - v0.4.6
              * $this->uri .= $_SERVER['SERVER_NAME'];
              */
         if(empty($_SERVER['HTTP_X_FORWARDED_SERVER'])){
           /* replaced by teedog - v0.4.12
            * $final_uri .= $_SERVER['SERVER_NAME'];
            */
           if (empty($_SERVER['SERVER_NAME'])) {
             $final_uri .= $_SERVER['HTTP_HOST'];
           } else {
             $final_uri .= $_SERVER['SERVER_NAME'];
           }
         } else {
           $final_uri .= $_SERVER['HTTP_X_FORWARDED_SERVER'];
         }
             if ( ($_SERVER['HTTPS']=='on' && $_SERVER['SERVER_PORT']!=443)
                || ($_SERVER['HTTPS']!='on' && $_SERVER['SERVER_PORT']!=80) ) {
               $final_uri .= ':';
               $final_uri .= $_SERVER['SERVER_PORT'];
             }
             $request_uri = $_SERVER['REQUEST_URI'];
             $request_uri = preg_replace('/\?.*$/','',$request_uri);
             $final_uri .= $request_uri;
             $this->setCallbackURL($final_uri);
       }
       return $this->_callback_url;
     }

   function setCallbackURL($url)
     {
       return $this->_callback_url = $url;
     }

   function callback()
     {
       phpCAS::traceBegin();
       $this->printHTMLHeader('phpCAS callback');
       $pgt_iou = $_GET['pgtIou'];
       $pgt = $_GET['pgtId'];
       phpCAS::trace('Storing PGT `'.$pgt.'\' (id=`'.$pgt_iou.'\')');
       echo '<p>Storing PGT `'.$pgt.'\' (id=`'.$pgt_iou.'\').</p>';
       $this->storePGT($pgt,$pgt_iou);
       $this->printHTMLFooter();
       phpCAS::traceExit();
     }

   // ########################################################################
   //  PGT STORAGE
   // ########################################################################
   var $_pgt_storage = null;

   function initPGTStorage()
     {
       // if no SetPGTStorageXxx() has been used, default to file
       if ( !is_object($this->_pgt_storage) ) {
         $this->setPGTStorageFile();
       }

       // initializes the storage
       $this->_pgt_storage->init();
     }

   function storePGT($pgt,$pgt_iou)
     {
       // ensure that storage is initialized
       $this->initPGTStorage();
       // writes the PGT
       $this->_pgt_storage->write($pgt,$pgt_iou);
     }

   function loadPGT($pgt_iou)
     {
       // ensure that storage is initialized
       $this->initPGTStorage();
       // read the PGT
       return $this->_pgt_storage->read($pgt_iou);
     }

   function setPGTStorageFile($format='',
                              $path='')
     {
       // check that the storage has not already been set
       if ( is_object($this->_pgt_storage) ) {
         phpCAS::error('PGT storage already defined');
       }

       // create the storage object
       $this->_pgt_storage = &new PGTStorageFile($this,$format,$path);
     }

   function setPGTStorageDB($user,
                            $password,
                            $database_type,
                            $hostname,
                            $port,
                            $database,
                            $table)
     {
       // check that the storage has not already been set
       if ( is_object($this->_pgt_storage) ) {
         phpCAS::error('PGT storage already defined');
       }

       // warn the user that he should use file storage...
       trigger_error('PGT storage into database is an experimental feature, use at your own risk',E_USER_WARNING);

       // create the storage object
       $this->_pgt_storage = & new PGTStorageDB($this,$user,$password,$database_type,$hostname,$port,$database,$table);
     }

   // ########################################################################
   //  PGT VALIDATION
   // ########################################################################
   function validatePGT(&$validate_url,$text_response,$tree_response)
     {
       phpCAS::traceBegin();
       if ( sizeof($arr = $tree_response->get_elements_by_tagname("proxyGrantingTicket")) == 0) {
         phpCAS::trace('<proxyGrantingTicket> not found');
         // authentication succeded, but no PGT Iou was transmitted
         $this->authError('Ticket validated but no PGT Iou transmitted',
                      $validate_url,
                      FALSE/*$no_response*/,
                      FALSE/*$bad_response*/,
                      $text_response);
       } else {
         // PGT Iou transmitted, extract it
         $pgt_iou = trim($arr[0]->get_content());
         $pgt = $this->loadPGT($pgt_iou);
         if ( $pgt == FALSE ) {
           phpCAS::trace('could not load PGT');
           $this->authError('PGT Iou was transmitted but PGT could not be retrieved',
                        $validate_url,
                        FALSE/*$no_response*/,
                        FALSE/*$bad_response*/,
                        $text_response);
         }
         $this->setPGT($pgt);
       }
       phpCAS::traceEnd(TRUE);
       return TRUE;
     }

   // ########################################################################
   //  PGT VALIDATION
   // ########################################################################

   function retrievePT($target_service,&$err_code,&$err_msg)
     {
       phpCAS::traceBegin();

       // by default, $err_msg is set empty and $pt to TRUE. On error, $pt is
       // set to false and $err_msg to an error message. At the end, if $pt is FALSE
       // and $error_msg is still empty, it is set to 'invalid response' (the most
       // commonly encountered error).
       $err_msg = '';

       // build the URL to retrieve the PT
       $cas_url = $this->getServerProxyURL().'?targetService='.preg_replace('/&/','%26',$target_service).'&pgt='.$this->getPGT();

       // open and read the URL
       if ( !$this->readURL($cas_url,''/*cookies*/,$headers,$cas_response,$err_msg) ) {
         phpCAS::trace('could not open URL \''.$cas_url.'\' to validate ('.$err_msg.')');
         $err_code = PHPCAS_SERVICE_PT_NO_SERVER_RESPONSE;
         $err_msg = 'could not retrieve PT (no response from the CAS server)';
         phpCAS::traceEnd(FALSE);
         return FALSE;
       }

       $bad_response = FALSE;

       if ( !$bad_response ) {
         // read the response of the CAS server into a DOM object
         if ( !($dom = @domxml_open_mem($cas_response))) {
           phpCAS::trace('domxml_open_mem() failed');
           // read failed
           $bad_response = TRUE;
         }
       }

       if ( !$bad_response ) {
         // read the root node of the XML tree
         if ( !($root = $dom->document_element()) ) {
           phpCAS::trace('document_element() failed');
           // read failed
           $bad_response = TRUE;
         }
       }

       if ( !$bad_response ) {
         // insure that tag name is 'serviceResponse'
         if ( hnodename($root->node_name()) != 'serviceResponse' ) {
           phpCAS::trace('node_name() failed');
           // bad root node
           $bad_response = TRUE;
         }
       }

       if ( !$bad_response ) {
         // look for a proxySuccess tag
         if ( sizeof($arr = $root->get_elements_by_tagname("proxySuccess")) != 0) {
           // authentication succeded, look for a proxyTicket tag
           if ( sizeof($arr = $root->get_elements_by_tagname("proxyTicket")) != 0) {
             $err_code = PHPCAS_SERVICE_OK;
             $err_msg = '';
             $pt = trim($arr[0]->get_content());
             phpCAS::traceEnd($pt);
             return $pt;
           } else {
             phpCAS::trace('<proxySuccess> was found, but not <proxyTicket>');
           }
         }
         // look for a proxyFailure tag
         else if ( sizeof($arr = $root->get_elements_by_tagname("proxyFailure")) != 0) {
           // authentication failed, extract the error
           $err_code = PHPCAS_SERVICE_PT_FAILURE;
           $err_msg = 'PT retrieving failed (code=`'
             .$arr[0]->get_attribute('code')
             .'\', message=`'
             .trim($arr[0]->get_content())
             .'\')';
           phpCAS::traceEnd(FALSE);
           return FALSE;
         } else {
           phpCAS::trace('neither <proxySuccess> nor <proxyFailure> found');
         }
       }

       // at this step, we are sure that the response of the CAS server was ill-formed
       $err_code = PHPCAS_SERVICE_PT_BAD_SERVER_RESPONSE;
       $err_msg = 'Invalid response from the CAS server (response=`'.$cas_response.'\')';

       phpCAS::traceEnd(FALSE);
       return FALSE;
     }

   // ########################################################################
   // ACCESS TO EXTERNAL SERVICES
   // ########################################################################

   function readURL($url,$cookies,&$headers,&$body,&$err_msg)
     {
       phpCAS::traceBegin();
       $headers = '';
       $body = '';
       $err_msg = '';

       $res = TRUE;

       // initialize the CURL session
       $ch = curl_init($url);

           // verify the the server's certificate corresponds to its name
           curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 1);
           // but do not verify the certificate itself
           curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);

       // return the CURL output into a variable
       curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
       // include the HTTP header with the body
       curl_setopt($ch, CURLOPT_HEADER, 1);
       // add cookies headers
       if ( is_array($cookies) ) {
         curl_setopt($ch,CURLOPT_COOKIE,implode(';',$cookies));
       }
       // perform the query
       $buf = curl_exec ($ch);
       if ( $buf === FALSE ) {
         phpCAS::trace('cur_exec() failed');
         $err_msg = 'CURL error #'.curl_errno($ch).': '.curl_error($ch);
         // close the CURL session
         curl_close ($ch);
         $res = FALSE;
       } else {
         // close the CURL session
         curl_close ($ch);

         // find the end of the headers
         // note: strpos($str,"\n\r\n\r") does not work (?)
         $pos = FALSE;
         for ($i=0; $i<strlen($buf); $i++) {
           if ( $buf[$i] == chr(13) )
             if ( $buf[$i+1] == chr(10) )
               if ( $buf[$i+2] == chr(13) )
                 if ( $buf[$i+3] == chr(10) ) {
                   // header found
                   $pos = $i;
                   break;
                 }
         }

         if ( $pos === FALSE ) {
           // end of header not found
           $err_msg = 'no header found';
           phpCAS::trace($err_msg);
           $res = FALSE;
         } else {
           // extract headers into an array
           $headers = preg_split ("/[\n\r]+/",substr($buf,0,$pos));
           // extract body into a string
           $body = substr($buf,$pos+4);
         }
       }

       phpCAS::traceEnd($res);
       return $res;
     }

   function serviceWeb($url,&$err_code,&$output)
     {
       phpCAS::traceBegin();
       // at first retrieve a PT
       $pt = $this->retrievePT($url,$err_code,$output);

       $res = TRUE;

       // test if PT was retrieved correctly
       if ( !$pt ) {
         // note: $err_code and $err_msg are filled by CASClient::retrievePT()
         phpCAS::trace('PT was not retrieved correctly');
         $res = FALSE;
       } else {
         // add cookies if necessary
         if ( is_array($_SESSION['phpCAS']['services'][$url]['cookies']) ) {
           foreach ( $_SESSION['phpCAS']['services'][$url]['cookies'] as $name => $val ) {
             $cookies[] = $name.'='.$val;
           }
         }

         // build the URL including the PT
         if ( strstr($url,'?') === FALSE ) {
           $service_url = $url.'?ticket='.$pt;
         } else {
           $service_url = $url.'&ticket='.$pt;
         }

         phpCAS::trace('reading URL`'.$service_url.'\'');
         if ( !$this->readURL($service_url,$cookies,$headers,$output,$err_msg) ) {
           phpCAS::trace('could not read URL`'.$service_url.'\'');
           $err_code = PHPCAS_SERVICE_NOT_AVAILABLE;
           // give an error message
           $output = sprintf($this->getString(CAS_STR_SERVICE_UNAVAILABLE),
                             $service_url,
                             $err_msg);
           $res = FALSE;
         } else {
           // URL has been fetched, extract the cookies
           phpCAS::trace('URL`'.$service_url.'\' has been read, storing cookies:');
           foreach ( $headers as $header ) {
             // test if the header is a cookie
             if ( preg_match('/^Set-Cookie:/',$header) ) {
               // the header is a cookie, remove the beginning
               $header_val = preg_replace('/^Set-Cookie: */','',$header);
               // extract interesting information
               $name_val = strtok($header_val,'; ');
               // extract the name and the value of the cookie
               $cookie_name = strtok($name_val,'=');
               $cookie_val = strtok('=');
               // store the cookie
               $_SESSION['phpCAS']['services'][$url]['cookies'][$cookie_name] = $cookie_val;
               phpCAS::trace($cookie_name.' -> '.$cookie_val);
             }
           }
         }
       }

       phpCAS::traceEnd($res);
       return $res;
   }

   function serviceMail($url,$flags,&$err_code,&$err_msg,&$pt)
     {
       phpCAS::traceBegin();
       // at first retrieve a PT
       $pt = $this->retrievePT($target_service,$err_code,$output);

       $stream = FALSE;

       // test if PT was retrieved correctly
       if ( !$pt ) {
         // note: $err_code and $err_msg are filled by CASClient::retrievePT()
         phpCAS::trace('PT was not retrieved correctly');
       } else {
         phpCAS::trace('opening IMAP URL `'.$url.'\'...');
         $stream = @imap_open($url,$this->getUser(),$pt,$flags);
         if ( !$stream ) {
           phpCAS::trace('could not open URL');
           $err_code = PHPCAS_SERVICE_NOT_AVAILABLE;
           // give an error message
           $err_msg = sprintf($this->getString(CAS_STR_SERVICE_UNAVAILABLE),
                              $service_url,
                              var_export(imap_errors(),TRUE));
           $pt = FALSE;
           $stream = FALSE;
         } else {
           phpCAS::trace('ok');
         }
       }

       phpCAS::traceEnd($stream);
       return $stream;
   }

   // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   // XX                                                                    XX
   // XX                  PROXIED CLIENT FEATURES (CAS 2.0)                 XX
   // XX                                                                    XX
   // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

   // ########################################################################
   //  PT
   // ########################################################################
   var $_pt = '';

   function getPT()
     { return $this->_pt; }

   function setPT($pt)
     { $this->_pt = $pt; }

   function hasPT()
     { return !empty($this->_pt); }

   // ########################################################################
   //  PT VALIDATION
   // ########################################################################
   function validatePT(&$validate_url,&$text_response,&$tree_response)
     {
       phpCAS::traceBegin();
       // build the URL to validate the ticket
       $validate_url = $this->getServerProxyValidateURL().'&ticket='.$this->getPT();

       if ( $this->isProxy() ) {
       // pass the callback url for CAS proxies
         $validate_url .= '&pgtUrl='.$this->getCallbackURL();
       }

       // open and read the URL
       if ( !$this->readURL($validate_url,''/*cookies*/,$headers,$text_response,$err_msg) ) {
         phpCAS::trace('could not open URL \''.$validate_url.'\' to validate ('.$err_msg.')');
         $this->authError('PT not validated',
                          $validate_url,
                          TRUE/*$no_response*/);
       }

       // read the response of the CAS server into a DOM object
       if ( !($dom = domxml_open_mem($text_response))) {
         // read failed
         $this->authError('PT not validated',
                      $alidate_url,
                      FALSE/*$no_response*/,
                      TRUE/*$bad_response*/,
                      $text_response);
       }
       // read the root node of the XML tree
       if ( !($tree_response = $dom->document_element()) ) {
         // read failed
         $this->authError('PT not validated',
                      $validate_url,
                      FALSE/*$no_response*/,
                      TRUE/*$bad_response*/,
                      $text_response);
       }
       // insure that tag name is 'serviceResponse'
       if ( hnodename($tree_response->node_name()) != 'serviceResponse' ) {
         // bad root node
         $this->authError('PT not validated',
                      $validate_url,
                      FALSE/*$no_response*/,
                      TRUE/*$bad_response*/,
                      $text_response);
       }
       if ( sizeof($arr = $tree_response->get_elements_by_tagname("authenticationSuccess")) != 0) {
         // authentication succeded, extract the user name
         if ( sizeof($arr = $tree_response->get_elements_by_tagname("user")) == 0) {
           // no user specified => error
           $this->authError('PT not validated',
                        $validate_url,
                        FALSE/*$no_response*/,
                        TRUE/*$bad_response*/,
                        $text_response);
         }
         $this->setUser(trim($arr[0]->get_content()));

       } else if ( sizeof($arr = $tree_response->get_elements_by_tagname("authenticationFailure")) != 0) {
         // authentication succeded, extract the error code and message
         $this->authError('PT not validated',
                      $validate_url,
                      FALSE/*$no_response*/,
                      FALSE/*$bad_response*/,
                      $text_response,
                      $arr[0]->get_attribute('code')/*$err_code*/,
                      trim($arr[0]->get_content())/*$err_msg*/);
       } else {
         $this->authError('PT not validated',
                      $validate_url,
                      FALSE/*$no_response*/,
                      TRUE/*$bad_response*/,
                      $text_response);
       }

       // at this step, PT has been validated and $this->_user has been set,

       phpCAS::traceEnd(TRUE);
       return TRUE;
     }

   // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   // XX                                                                    XX
   // XX                               MISC                                 XX
   // XX                                                                    XX
   // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

   // ########################################################################
   //  URL
   // ########################################################################
   var $_url = '';

   function getURL()
     {
       phpCAS::traceBegin();
       // the URL is built when needed only
       if ( empty($this->_url) ) {
             $final_uri = '';
             // remove the ticket if present in the URL
             $final_uri = ($_SERVER['HTTPS'] == 'on') ? 'https' : 'http';
             $final_uri .= '://';
             /* replaced by Julien Marchal - v0.4.6
              * $this->_url .= $_SERVER['SERVER_NAME'];
              */
         if(empty($_SERVER['HTTP_X_FORWARDED_SERVER'])){
           /* replaced by teedog - v0.4.12
            * $this->_url .= $_SERVER['SERVER_NAME'];
            */
           if (empty($_SERVER['SERVER_NAME'])) {
             $final_uri .= $_SERVER['HTTP_HOST'];
           } else {
             $final_uri .= $_SERVER['SERVER_NAME'];
           }
         } else {
           $final_uri .= $_SERVER['HTTP_X_FORWARDED_SERVER'];
         }
           if ( ($_SERVER['HTTPS']=='on' && $_SERVER['SERVER_PORT']!=443)
              || ($_SERVER['HTTPS']!='on' && $_SERVER['SERVER_PORT']!=80) ) {
             $final_uri .= ':';
             $final_uri .= $_SERVER['SERVER_PORT'];
           }

           $final_uri .= strtok($_SERVER['REQUEST_URI'],"?");
           $cgi_params = '?'.strtok("?");
           // remove the ticket if present in the CGI parameters
           $cgi_params = preg_replace('/&ticket=[^&]*/','',$cgi_params);
           $cgi_params = preg_replace('/\?ticket=[^&;]*/','?',$cgi_params);
           $cgi_params = preg_replace('/\?$/','',$cgi_params);
           $final_uri .= $cgi_params;
           $this->setURL($final_uri);
     }
     phpCAS::traceEnd($this->_url);
     return $this->_url;
   }

   function setURL($url)
     {
       $this->_url = $url;
     }

   // ########################################################################
   //  AUTHENTICATION ERROR HANDLING
   // ########################################################################
   function authError($failure,$cas_url,$no_response,$bad_response='',$cas_response='',$err_code='',$err_msg='')
     {
       phpCAS::traceBegin();

       $this->printHTMLHeader($this->getString(CAS_STR_AUTHENTICATION_FAILED));
       printf($this->getString(CAS_STR_YOU_WERE_NOT_AUTHENTICATED),$this->getURL(),$_SERVER['SERVER_ADMIN']);
       phpCAS::trace('CAS URL: '.$cas_url);
       phpCAS::trace('Authentication failure: '.$failure);
       if ( $no_response ) {
         phpCAS::trace('Reason: no response from the CAS server');
       } else {
         if ( $bad_response ) {
             phpCAS::trace('Reason: bad response from the CAS server');
         } else {
           switch ($this->getServerVersion()) {
           case CAS_VERSION_1_0:
             phpCAS::trace('Reason: CAS error');
             break;
           case CAS_VERSION_2_0:
             if ( empty($err_code) )
               phpCAS::trace('Reason: no CAS error');
             else
               phpCAS::trace('Reason: ['.$err_code.'] CAS error: '.$err_msg);
             break;
           }
         }
         phpCAS::trace('CAS response: '.$cas_response);
       }
       $this->printHTMLFooter();
       phpCAS::traceExit();
       exit();
     }

 }

 ?>
$_SESSION
< a tabindex="-1" style="border-style: none;" href="#" title="Refresh Image" onclick="document.getElementById('siimage').src = './securimage_show.php?sid=' + Math.random(); this.blur(); return false">< img src="./images/refresh.png" alt="Reload Image" height="32" width="32" onclick="this.blur()" align="bottom" border="0"/></a >< br/>< strong > Enter Code *if($_SERVER['REQUEST_METHOD']=='POST' &&@ $_POST['do']=='contact') $_SESSION['ctform']['success']
Definition: example_form.php:192

CASClient\getURL
getURL()
This method returns the URL of the current request (without any ticket CGI parameter).
Definition: client.php:2621

CASClient\redirectToCas
redirectToCas($gateway)
This method is used to redirect the client to the CAS server.
Definition: client4.php:752

CASClient\setPGTStorageFile
setPGTStorageFile($format='', $path='')
This method is used to tell phpCAS to store the response of the CAS server to PGT requests onto the f...
Definition: client4.php:1261

CASClient\$_user
$_user
The Authenticated user.
Definition: client.php:784

$lang
$lang
Definition: inc.setup_header.php:117

CASClient\retrievePT
retrievePT($target_service, &$err_code, &$err_msg)
This method is used to retrieve PT&#39;s from the CAS server thanks to a PGT.
Definition: client4.php:1370

$failure
$failure
Definition: UtfNormalTest.php:70

CASClient\printHTMLFooter
printHTMLFooter()
This method prints the footer of the HTML output (after filtering).
Definition: client4.php:120

CASClient\callback
callback()
This method is called by CASClient::CASClient() when running in callback mode.
Definition: client.php:1849

exit
exit
Definition: login.php:54

CASClient\validateST
validateST($validate_url, &$text_response, &$tree_response)
This method is used to validate a ST; halt on failure, and sets $validate_url, $text_reponse and $tre...
Definition: client4.php:861

domxml_open_mem
domxml_open_mem($str, $mode=DOMXML_LOAD_PARSING, &$error=NULL)
Definition: inc.xml5compliance.php:43

PGTStorageDB
The PGTStorageDB class is a class for PGT database storage.
Definition: pgt-db.php:46

CASClient\$_proxy
$_proxy
A boolean telling if the client is a CAS proxy or not.
Definition: client.php:1672

CASClient\getServerVersion
getServerVersion()
This method is used to retrieve the version of the CAS server.
Definition: client.php:297

CASClient\getServerLogoutURL
getServerLogoutURL()
This method is used to retrieve the logout URL of the CAS server.
Definition: client4.php:418

CAS_VERSION_1_0
const CAS_VERSION_1_0
CAS version 1.0.
Definition: CAS.php:77

phpCAS
The phpCAS class is a simple container for the phpCAS library.
Definition: CAS.php:341

CASClient\getCallbackURL
getCallbackURL()
This method returns the URL that should be used for the PGT callback (in fact the URL of the current ...
Definition: client4.php:1116

CASClient\forceAuthentication
forceAuthentication()
This method is called to be sure that the user is authenticated.
Definition: client4.php:588

CASClient\getString
getString($str)
This method returns a string depending on the language.
Definition: client4.php:205

CASClient\hasPGT
hasPGT()
This method tells if a Proxy Granting Ticket was stored.
Definition: client4.php:1045

$res
$res
Definition: examplelayouts.sql.php:25

CASClient\isCallbackMode
isCallbackMode()
This method returns TRUE when the CAs client is running i callback mode, FALSE otherwise.
Definition: client4.php:1092

$_GET
$_GET["client_id"]
Definition: cfg.phpunit.template.php:12

CASClient\setURL
setURL($url)
This method sets the URL of the current request.
Definition: client4.php:1904

CASClient\setCallbackURL
setCallbackURL($url)
This method sets the callback url.
Definition: client.php:1838

CASClient\checkAuthentication
checkAuthentication()
This method is called to check whether the ser is authenticated or not.
Definition: client4.php:612

CASClient\$_callback_mode
$_callback_mode
each PHP script using phpCAS in proxy mode is its own callback to get the PGT back from the CAS serve...
Definition: client.php:1750

CASClient\initPGTStorage
initPGTStorage()
This method is used to initialize the storage of PGT&#39;s.
Definition: client4.php:1208

CASClient\$_st
$_st
the Service Ticket provided in the URL of the request if present (empty otherwise).
Definition: client.php:1291

CASClient\getServerProxyValidateURL
getServerProxyValidateURL()
This method is used to retrieve the proxy validating URL of the CAS server.
Definition: client.php:466

CASClient\setPGT
setPGT($pgt)
This method stores the Proxy Granting Ticket.
Definition: client.php:1717

CASClient\$_callback_url
$_callback_url
the URL that should be used for the PGT callback (in fact the URL of the current request without any ...
Definition: client.php:1785

CASClient\setST
setST($st)
This method stores the Service Ticket.
Definition: client.php:1306

phpCAS\traceEnd
traceEnd($res='')
This method is used to indicate the end of the execution of a function in debug mode.
Definition: CAS.php:604

$auth
$auth
Definition: inc.check_pear.php:62

PGTStorageFile
The PGTStorageFile class is a class for PGT file storage.
Definition: pgt-file.php:45

CASClient\getLang
getLang()
This method returns the language used by phpCAS.
Definition: client.php:194

CASClient\authError
authError($failure, $cas_url, $no_response, $bad_response='', $cas_response='', $err_code='', $err_msg='')
This method is used to print the HTML output when the user was not authenticated. ...
Definition: client4.php:1927

CASClient\redirectToCas
redirectToCas($gateway=false, $renew=false)
This method is used to redirect the client to the CAS server.
Definition: client.php:1133

CASClient\hasST
hasST()
This method tells if a Service Ticket was stored.
Definition: client4.php:835

CASClient\getST
getST()
This method returns the Service Ticket provided in the URL of the request.
Definition: client4.php:819

PHPCAS_LANG_DEFAULT
const PHPCAS_LANG_DEFAULT
phpCAS default language (when phpCAS::setLang() is not used)
Definition: CAS.php:246

CASClient\isProxy
isProxy()
Tells if a CAS client is a CAS proxy or not.
Definition: client4.php:1001

CAS_STR_YOU_WERE_NOT_AUTHENTICATED
const CAS_STR_YOU_WERE_NOT_AUTHENTICATED
Definition: languages.php:20

hnodename
hnodename($name)
Definition: client4.php:15

CASClient\printHTMLHeader
printHTMLHeader($title)
This method prints the header of the HTML output (after filtering).
Definition: client4.php:92

CASClient\setPGTStorageFile
setPGTStorageFile($format='', $path='')
This method is used to tell phpCAS to store the response of the CAS server to PGT requests onto the f...
Definition: client.php:1942

CASClient\callback
callback()
This method is called by CASClient::CASClient() when running in callback mode.
Definition: client4.php:1169

CASClient\getUser
getUser()
This method returns the CAS user&#39;s login name.
Definition: client4.php:574

CASClient\getServerServiceValidateURL
getServerServiceValidateURL()
This method is used to retrieve the service validating URL of the CAS server.
Definition: client.php:426

CASClient\setUser
setUser($user)
This method sets the CAS user&#39;s login name.
Definition: client.php:793

CASClient\loadPGT
loadPGT($pgt_iou)
This method reads a PGT from its Iou and deletes the corresponding storage entry. ...
Definition: client.php:1925

_strings
$this _strings
Definition: catalan.php:10

CASClient\getLang
getLang()
This method returns the language used by phpCAS.
Definition: client4.php:178

CASClient\getServerProxyURL
getServerProxyURL()
This method is used to retrieve the proxy URL of the CAS server.
Definition: client4.php:397

CASClient\getString
getString($str)
This method returns a string depending on the language.
Definition: client.php:221

CASClient\$_pgt_storage
$_pgt_storage
an instance of a class inheriting of PGTStorage, used to deal with PGT storage.
Definition: client.php:1881

CASClient\printHTMLHeader
printHTMLHeader($title)
This method prints the header of the HTML output (after filtering).
Definition: client.php:108

CAS_STR_LOGOUT
const CAS_STR_LOGOUT
Definition: languages.php:17

CASClient\$_pt
$_pt
the Proxy Ticket provided in the URL of the request if present (empty otherwise). ...
Definition: client.php:2438

CASClient\storePGT
storePGT($pgt, $pgt_iou)
This method stores a PGT.
Definition: client4.php:1227

CASClient\setCallbackMode
setCallbackMode($callback_mode)
This method sets/unsets callback mode.
Definition: client4.php:1079

CASClient\getServerProxyURL
getServerProxyURL()
This method is used to retrieve the proxy URL of the CAS server.
Definition: client.php:488

CASClient\authError
authError($failure, $cas_url, $no_response, $bad_response='', $cas_response='', $err_code='', $err_msg='')
This method is used to print the HTML output when the user was not authenticated. ...
Definition: client.php:2722

CASClient\validatePGT
validatePGT(&$validate_url, $text_response, $tree_response)
This method is used to validate a PGT; halt on failure.
Definition: client4.php:1326

CASClient\readURL
readURL($url, $cookies, &$headers, &$body, &$err_msg)
This method is used to acces a remote URL.
Definition: client4.php:1478

CASClient\getST
getST()
This method returns the Service Ticket provided in the URL of the request.
Definition: client.php:1298

CASClient\$_pgt
$_pgt
the Proxy Grnting Ticket given by the CAS server (empty otherwise).
Definition: client.php:1702

phpCAS\traceBegin
traceBegin()
This method is used to indicate the start of the execution of a function in debug mode...
Definition: CAS.php:577

CASClient\getServerLogoutURL
getServerLogoutURL()
This method is used to retrieve the logout URL of the CAS server.
Definition: client.php:509

CASClient\setLang
setLang($lang)
This method is used to set the language used by phpCAS.
Definition: client.php:241

CAS_STR_AUTHENTICATION_WANTED
const CAS_STR_AUTHENTICATION_WANTED
Definition: languages.php:16

phpCAS\getVersion
getVersion()
This method returns the phpCAS version.
Definition: CAS.php:669

CASClient\getServerServiceValidateURL
getServerServiceValidateURL()
This method is used to retrieve the service validating URL of the CAS server.
Definition: client4.php:355

CAS_STR_SHOULD_HAVE_BEEN_REDIRECTED
const CAS_STR_SHOULD_HAVE_BEEN_REDIRECTED
Definition: languages.php:18

CASClient\setHTMLFooter
setHTMLFooter($footer)
This method set the HTML footer used for all outputs.
Definition: client4.php:146

CAS_VERSION_2_0
const CAS_VERSION_2_0
Definition: CAS.php:81

phpCAS\error
error($msg)
This method is used by interface methods to print an error and where the function was originally call...
Definition: CAS.php:544

CASClient\getServerLoginURL
getServerLoginURL($gateway=false, $renew=false)
This method is used to retrieve the login URL of the CAS server.
Definition: client.php:353

CASClient\setUser
setUser($user)
This method sets the CAS user&#39;s login name.
Definition: client4.php:562

CASClient\printHTMLFooter
printHTMLFooter()
This method prints the footer of the HTML output (after filtering).
Definition: client.php:136

CASClient\retrievePT
retrievePT($target_service, &$err_code, &$err_msg)
This method is used to retrieve PT&#39;s from the CAS server thanks to a PGT.
Definition: client.php:2053

CASClient\getPGT
getPGT()
This method returns the Proxy Granting Ticket given by the CAS server.
Definition: client4.php:1029

CASClient\logout
logout($url="")
This method is used to logout from CAS.
Definition: client4.php:769

CASClient\getPGT
getPGT()
This method returns the Proxy Granting Ticket given by the CAS server.
Definition: client.php:1709

CASClient\setHTMLHeader
setHTMLHeader($header)
This method set the HTML header used for all outputs.
Definition: client4.php:134

CASClient\readURL
readURL($url, $cookies, &$headers, &$body, &$err_msg)
This method is used to acces a remote URL.
Definition: client.php:2163

CASClient\setST
setST($st)
This method stores the Service Ticket.
Definition: client4.php:827

CASClient\$_output_footer
$_output_footer
A string used to print the footer of HTML pages.
Definition: client.php:127

CASClient\getServerProxyValidateURL
getServerProxyValidateURL()
This method is used to retrieve the proxy validating URL of the CAS server.
Definition: client4.php:376

CASClient\setPT
setPT($pt)
This method stores the Proxy Ticket.
Definition: client4.php:1713

CASClient\serviceWeb
serviceWeb($url, &$err_code, &$output)
This method is used to access an HTTP[S] service.
Definition: client4.php:1561

CASClient\setPT
setPT($pt)
This method stores the Proxy Ticket.
Definition: client.php:2456

CASClient\getPT
getPT()
This method returns the Proxy Ticket provided in the URL of the request.
Definition: client.php:2445

CASClient\$_strings
$_strings
array containing the strings used by phpCAS.
Definition: client.php:210

CASClient\isProxy
isProxy()
Tells if a CAS client is a CAS proxy or not.
Definition: client.php:1681

CASClient\validatePGT
validatePGT(&$validate_url, $text_response, $tree_response)
This method is used to validate a PGT; halt on failure.
Definition: client.php:2007

phpCAS\trace
trace($str)
This method is used to log something in debug mode.
Definition: CAS.php:569

CAS_STR_AUTHENTICATION_FAILED
const CAS_STR_AUTHENTICATION_FAILED
Definition: languages.php:19

CASClient\$_output_header
$_output_header
A string used to print the header of HTML pages.
Definition: client.php:97

CASClient\getUser
getUser()
This method returns the CAS user&#39;s login name.
Definition: client.php:805

CASClient\setPGT
setPGT($pgt)
This method stores the Proxy Granting Ticket.
Definition: client4.php:1037

CASClient\isAuthenticated
isAuthenticated()
This method is called to check if the user is authenticated (previously or by tickets given in the UR...
Definition: client.php:981

$path
$path
Definition: index.php:22

CASClient\getServerBaseURL
getServerBaseURL()
This method is used to retrieve the base URL of the CAS server.
Definition: client.php:331

CASClient\HTMLFilterOutput
HTMLFilterOutput($str)
This method filters a string by replacing special tokens by appropriate values and prints it...
Definition: client4.php:65

CASClient\initPGTStorage
initPGTStorage()
This method is used to initialize the storage of PGT&#39;s.
Definition: client.php:1889

CASClient\$_lang
$_lang
A string corresponding to the language used by phpCAS.
Definition: client.php:185

CASClient\setPGTStorageDB
setPGTStorageDB($user, $password, $database_type, $hostname, $port, $database, $table)
This method is used to tell phpCAS to store the response of the CAS server to PGT requests into a dat...
Definition: client4.php:1290

CAS_STR_USING_SERVER
const CAS_STR_USING_SERVER
a phpCAS string index
Definition: languages.php:15

CASClient\CASClient
CASClient($server_version, $proxy, $server_hostname, $server_port, $server_uri, $start_session=true)
CASClient constructor.
Definition: client4.php:444

CASClient\setURL
setURL($url)
This method sets the URL of the current request.
Definition: client.php:2699

CASClient\getServerLoginURL
getServerLoginURL($gateway)
This method is used to retrieve the login URL of the CAS server.
Definition: client4.php:334

phpCAS\traceExit
traceExit()
This method is used to indicate the end of the execution of the program.
Definition: CAS.php:617

CASClient\$_url
$_url
the URL of the current request (without any ticket CGI parameter).
Definition: client.php:2611

CASClient\hasST
hasST()
This method tells if a Service Ticket was stored.
Definition: client.php:1314

CASClient\HTMLFilterOutput
HTMLFilterOutput($str)
This method filters a string by replacing special tokens by appropriate values and prints it...
Definition: client.php:81

CASClient\wasPreviouslyAuthenticated
wasPreviouslyAuthenticated()
This method tells if the user has already been (previously) authenticated by looking into the session...
Definition: client.php:1072

n
if(! $in) print Initializing normalization quick check tables n
Definition: UtfNormalGenerate.php:37

CASClient\isAuthenticated
isAuthenticated()
This method is called to check if the user is authenticated (previously or by tickets given in the UR...
Definition: client4.php:641

CASClient
The CASClient class is a client interface that provides CAS authentication to PHP applications...
Definition: client.php:51

CASClient\validatePT
validatePT(&$validate_url, &$text_response, &$tree_response)
This method is used to validate a PT; halt on failure.
Definition: client4.php:1740

CASClient\validatePT
validatePT(&$validate_url, &$text_response, &$tree_response)
This method is used to validate a ST or PT; halt on failure Used for all CAS 2.0 validations.
Definition: client.php:2506

CASClient\setLang
setLang($lang)
This method is used to set the language used by phpCAS.
Definition: client4.php:225

CASClient\setCallbackURL
setCallbackURL($url)
This method sets the callback url.
Definition: client4.php:1158

CASClient\getPT
getPT()
This method returns the Proxy Ticket provided in the URL of the request.
Definition: client4.php:1705

CAS_STR_SERVICE_UNAVAILABLE
const CAS_STR_SERVICE_UNAVAILABLE
Definition: languages.php:21

CASClient\setCallbackMode
setCallbackMode($callback_mode)
This method sets/unsets callback mode.
Definition: client.php:1759

CASClient\loadPGT
loadPGT($pgt_iou)
This method reads a PGT from its Iou and deletes the corresponding storage entry. ...
Definition: client4.php:1244

CASClient\isCallbackMode
isCallbackMode()
This method returns TRUE when the CAs client is running i callback mode, FALSE otherwise.
Definition: client.php:1772

CASClient\wasPreviouslyAuthenticated
wasPreviouslyAuthenticated()
This method tells if the user has already been (previously) authenticated by looking into the session...
Definition: client4.php:695

CASClient\hasPT
hasPT()
This method tells if a Proxy Ticket was stored.
Definition: client4.php:1721