Exponential Basic 2.4.0.1 Exponential Basic CMS — PHP Class Reference

ezsiteaccess.php
Go to the documentation of this file.
1 <?php
17 class eZSiteAccess
18 {
24 const TYPE_DEFAULT = 1;
25 const TYPE_URI = 2;
26 const TYPE_PORT = 3;
27 const TYPE_HTTP_HOST = 4;
28 const TYPE_INDEX_FILE = 5;
29 const TYPE_STATIC = 6;
30 const TYPE_SERVER_VAR = 7;
31 const TYPE_URL = 8;
32 const TYPE_HTTP_HOST_URI = 9;
33 const TYPE_CUSTOM = 10;
34
35 const SUBTYPE_PRE = 1;
36 const SUBTYPE_POST = 2;
37
38 static function siteAccessList()
39 {
40 $siteAccessList = array();
41 $ini = eZINI::instance();
42 $availableSiteAccessList = $ini->variable( 'SiteAccessSettings', 'AvailableSiteAccessList' );
43 if ( !is_array( $availableSiteAccessList ) )
44 $availableSiteAccessList = array();
45
46 $serverSiteAccess = eZSys::serverVariable( $ini->variable( 'SiteAccessSettings', 'ServerVariableName' ), true );
47 if ( $serverSiteAccess )
48 $availableSiteAccessList[] = $serverSiteAccess;
49
50 $availableSiteAccessList = array_unique( $availableSiteAccessList );
51 foreach ( $availableSiteAccessList as $siteAccessName )
52 {
53 $siteAccessItem = array();
54 $siteAccessItem['name'] = $siteAccessName;
55 $siteAccessItem['id'] = eZSys::ezcrc32( $siteAccessName );
56 $siteAccessList[] = $siteAccessItem;
57 }
58 return $siteAccessList;
59 }
60
67 static function findPathToSiteAccess( $siteAccess )
68 {
69 $ini = eZINI::instance();
70 $siteAccessList = $ini->variable( 'SiteAccessSettings', 'AvailableSiteAccessList' );
71 if ( !in_array( $siteAccess, $siteAccessList ) )
72 return false;
73
74 $currentPath = 'settings/siteaccess/' . $siteAccess;
75 if ( file_exists( $currentPath ) )
76 return $currentPath;
77
78 $activeExtensions = eZExtension::activeExtensions();
79 $baseDir = eZExtension::baseDirectory();
80 foreach ( $activeExtensions as $extension )
81 {
82 $currentPath = $baseDir . '/' . $extension . '/settings/siteaccess/' . $siteAccess;
83 if ( file_exists( $currentPath ) )
84 return $currentPath;
85 }
86
87 return 'settings/siteaccess/' . $siteAccess;
88 }
89
104 public static function match( eZURI $uri, $host, $port = 80, $file = '/index.php' )
105 {
106 eZDebugSetting::writeDebug( 'kernel-siteaccess', array( 'uri' => $uri,
107 'host' => $host,
108 'port' => $port,
109 'file' => $file ), __METHOD__ );
110 $ini = eZINI::instance();
111 if ( $ini->hasVariable( 'SiteAccessSettings', 'StaticMatch' ) )
112 {
113 $match = $ini->variable( 'SiteAccessSettings', 'StaticMatch' );
114 if ( $match != '' )
115 {
116 $access = array( 'name' => $match,
117 'type' => eZSiteAccess::TYPE_STATIC,
118 'uri_part' => array() );
119 return $access;
120 }
121 }
122
123 list( $siteAccessList, $order ) =
124 $ini->variableMulti( 'SiteAccessSettings', array( 'AvailableSiteAccessList', 'MatchOrder' ) );
125 $access = array( 'name' => $ini->variable( 'SiteSettings', 'DefaultAccess' ),
126 'type' => eZSiteAccess::TYPE_DEFAULT,
127 'uri_part' => array() );
128
129 if ( $order == 'none' )
130 return $access;
131
132 $order = $ini->variableArray( 'SiteAccessSettings', 'MatchOrder' );
133
134 // Change the default type to eZSiteAccess::TYPE_URI if we're using URI MatchOrder.
135 // This is to keep backward compatiblity with the ezurl operator. ezurl has since
136 // rev 4949 added default siteaccess to generated URLs, even when there is
137 // no siteaccess in the current URL.
138 if ( in_array( 'uri', $order ) )
139 {
140 $access['type'] = eZSiteAccess::TYPE_URI;
141 }
142
143 foreach ( $order as $matchprobe )
144 {
145 $name = '';
146 $type = '';
147 $match_type = '';
148 $uri_part = array();
149
150 switch( $matchprobe )
151 {
152 case 'servervar':
153 {
154 if ( $serversiteaccess = eZSys::serverVariable( $ini->variable( 'SiteAccessSettings', 'ServerVariableName' ), true ) )
155 {
156 $access['name'] = $serversiteaccess;
157 $access['type'] = eZSiteAccess::TYPE_SERVER_VAR;
158 return $access;
159 }
160 else
161 continue 2;
162 } break;
163 case 'port':
164 {
165 if ( $ini->hasVariable( 'PortAccessSettings', $port ) )
166 {
167 $access['name'] = $ini->variable( 'PortAccessSettings', $port );
168 $access['type'] = eZSiteAccess::TYPE_PORT;
169 return $access;
170 }
171 else
172 continue 2;
173 } break;
174 case 'uri':
175 {
176 $type = eZSiteAccess::TYPE_URI;
177 $match_type = $ini->variable( 'SiteAccessSettings', 'URIMatchType' );
178
179 if ( $match_type == 'map' )
180 {
181 if ( $ini->hasVariable( 'SiteAccessSettings', 'URIMatchMapItems' ) )
182 {
183 $match_item = $uri->element( 0 );
184 $matchMapItems = $ini->variableArray( 'SiteAccessSettings', 'URIMatchMapItems' );
185 foreach ( $matchMapItems as $matchMapItem )
186 {
187 $matchMapURI = $matchMapItem[0];
188 $matchMapAccess = $matchMapItem[1];
189 if ( $access['name'] == $matchMapAccess and in_array( $matchMapAccess, $siteAccessList ) )
190 {
191 $uri_part = array( $matchMapURI );
192 }
193 if ( $matchMapURI == $match_item and in_array( $matchMapAccess, $siteAccessList ) )
194 {
195 $uri->increase( 1 );
196 $uri->dropBase();
197 $access['name'] = $matchMapAccess;
198 $access['type'] = $type;
199 $access['uri_part'] = array( $matchMapURI );
200 return $access;
201 }
202 }
203 }
204 }
205 else if ( $match_type == 'element' )
206 {
207 $match_index = $ini->variable( 'SiteAccessSettings', 'URIMatchElement' );
208 $elements = $uri->elements( false );
209 $elements = array_slice( $elements, 0, $match_index );
210 $name = implode( '_', $elements );
211 $uri_part = $elements;
212 }
213 else if ( $match_type == 'text' )
214 {
215 $match_item = $uri->elements();
216 $matcher_pre = $ini->variable( 'SiteAccessSettings', 'URIMatchSubtextPre' );
217 $matcher_post = $ini->variable( 'SiteAccessSettings', 'URIMatchSubtextPost' );
218 }
219 else if ( $match_type == 'regexp' )
220 {
221 $match_item = $uri->elements();
222 $matcher = $ini->variable( 'SiteAccessSettings', 'URIMatchRegexp' );
223 $match_num = $ini->variable( 'SiteAccessSettings', 'URIMatchRegexpItem' );
224 }
225 else
226 continue 2;
227 } break;
228 case 'host':
229 {
230 $type = eZSiteAccess::TYPE_HTTP_HOST;
231 $match_type = $ini->variable( 'SiteAccessSettings', 'HostMatchType' );
232 $match_item = $host;
233 if ( $match_type == 'map' )
234 {
235 if ( $ini->hasVariable( 'SiteAccessSettings', 'HostMatchMapItems' ) )
236 {
237 $matchMapItems = $ini->variableArray( 'SiteAccessSettings', 'HostMatchMapItems' );
238 foreach ( $matchMapItems as $matchMapItem )
239 {
240 $matchMapHost = $matchMapItem[0];
241 $matchMapAccess = $matchMapItem[1];
242 if ( $matchMapHost == $host )
243 {
244 $access['name'] = $matchMapAccess;
245 $access['type'] = $type;
246 return $access;
247 }
248 }
249 }
250 }
251 else if ( $match_type == 'element' )
252 {
253 $match_index = $ini->variable( 'SiteAccessSettings', 'HostMatchElement' );
254 $match_arr = explode( '.', $match_item );
255 $name = $match_arr[$match_index];
256 }
257 else if ( $match_type == 'text' )
258 {
259 $matcher_pre = $ini->variable( 'SiteAccessSettings', 'HostMatchSubtextPre' );
260 $matcher_post = $ini->variable( 'SiteAccessSettings', 'HostMatchSubtextPost' );
261 }
262 else if ( $match_type == 'regexp' )
263 {
264 $matcher = $ini->variable( 'SiteAccessSettings', 'HostMatchRegexp' );
265 $match_num = $ini->variable( 'SiteAccessSettings', 'HostMatchRegexpItem' );
266 }
267 else
268 continue 2;
269 } break;
270 case 'host_uri':
271 {
272 $type = eZSiteAccess::TYPE_HTTP_HOST_URI;
273 if ( $ini->hasVariable( 'SiteAccessSettings', 'HostUriMatchMapItems' ) )
274 {
275 $uriString = $uri->elements();
276 $matchMapItems = $ini->variableArray( 'SiteAccessSettings', 'HostUriMatchMapItems' );
277 $defaultHostMatchMethod = $ini->variable( 'SiteAccessSettings', 'HostUriMatchMethodDefault' );
278
279 foreach ( $matchMapItems as $matchMapItem )
280 {
281 $matchHost = $matchMapItem[0];
282 $matchURI = $matchMapItem[1];
283 $matchAccess = $matchMapItem[2];
284 $matchHostMethod = isset( $matchMapItem[3] ) ? $matchMapItem[3] : $defaultHostMatchMethod;
285
286 if ( $matchURI !== '' && !preg_match( "@^$matchURI\b@u", $uriString ) )
287 continue;
288
289 switch( $matchHostMethod )
290 {
291 case 'strict':
292 {
293 $hasHostMatch = ( $matchHost === $host );
294 } break;
295 case 'start':
296 {
297 $hasHostMatch = ( strpos($host, $matchHost) === 0 );
298 } break;
299 case 'end':
300 {
301 $hasHostMatch = ( strstr($host, $matchHost) === $matchHost );
302 } break;
303 case 'part':
304 {
305 $hasHostMatch = ( strpos($host, $matchHost) !== false );
306 } break;
307 default:
308 {
309 $hasHostMatch = false;
310 eZDebug::writeError( "Unknown host_uri host match: $matchHostMethod", "access" );
311 } break;
312 }
313
314 if ( $hasHostMatch )
315 {
316 if ( $matchURI !== '' )
317 {
318 $matchURIFolders = explode( '/', $matchURI );
319 $uri->increase( count( $matchURIFolders ) );
320 $uri->dropBase();
321 $access['uri_part'] = $matchURIFolders;
322 }
323 $access['name'] = $matchAccess;
324 $access['type'] = $type;
325 return $access;
326 }
327 }
328 }
329 } break;
330 case 'index':
331 {
332 $type = eZSiteAccess::TYPE_INDEX_FILE;
333 $match_type = $ini->variable( 'SiteAccessSettings', 'IndexMatchType' );
334 $match_item = $file;
335 if ( $match_type == 'element' )
336 {
337 $match_index = $ini->variable( 'SiteAccessSettings', 'IndexMatchElement' );
338 $match_pos = strpos( $match_item, '.php' );
339 if ( $match_pos !== false )
340 {
341 $match_item = substr( $match_item, 0, $match_pos );
342 $match_arr = explode( '_', $match_item );
343 $name = $match_arr[$match_index];
344 }
345 }
346 else if ( $match_type == 'text' )
347 {
348 $matcher_pre = $ini->variable( 'SiteAccessSettings', 'IndexMatchSubtextPre' );
349 $matcher_post = $ini->variable( 'SiteAccessSettings', 'IndexMatchSubtextPost' );
350 }
351 else if ( $match_type == 'regexp' )
352 {
353 $matcher = $ini->variable( 'SiteAccessSettings', 'IndexMatchRegexp' );
354 $match_num = $ini->variable( 'SiteAccessSettings', 'IndexMatchRegexpItem' );
355 }
356 else
357 continue 2;
358 } break;
359 default:
360 {
361 eZDebug::writeError( "Unknown access match: $matchprobe", "access" );
362 } break;
363 }
364
365 if ( $match_type == 'regexp' )
366 $name = self::matchRegexp( $match_item, $matcher, $match_num );
367 else if ( $match_type == 'text' )
368 $name = self::matchText( $match_item, $matcher_pre, $matcher_post );
369
370 if ( isset( $name ) && $name != '' )
371 {
372 $nameClean = self::washName( $name );
373
374 if ( in_array( $nameClean, $siteAccessList ) )
375 {
376 if ( $nameClean !== $name )
377 {
378 if ( !$ini->hasVariable( 'SiteAccessSettings', 'NormalizeSANames' ) || $ini->variable( 'SiteAccessSettings', 'NormalizeSANames' ) == 'enabled' )
379 {
380 $name = $nameClean;
381 if ( $ini->hasVariable( 'SiteAccessSettings', 'RedirectOnNormalize' ) && $ini->variable( 'SiteAccessSettings', 'RedirectOnNormalize' ) == 'enabled' )
382 {
383 header( $_SERVER['SERVER_PROTOCOL'] . " 301 Moved Permanently" );
384 header( "Status: 301 Moved Permanently" );
385 $uriSlice = $uri->URIArray;
386 array_shift( $uriSlice );
387 $newUri = $name . '/' . implode( '/' , $uriSlice );
388 $location = eZSys::indexDir() . "/" . eZURI::encodeIRI( $newUri );
389 header( "Location: " . $location );
390 eZExecution::cleanExit();
391 }
392 }
393 }
394 if ( $type == eZSiteAccess::TYPE_URI )
395 {
396 if ( $match_type == 'element' )
397 {
398 $uri->increase( $match_index );
399 $uri->dropBase();
400 }
401 else if ( $match_type == 'regexp' )
402 {
403 $uri->setURIString( $match_item );
404 }
405 else if ( $match_type == 'text' )
406 {
407 $uri->setURIString( $match_item );
408 }
409 }
410 $access['type'] = $type;
411 $access['name'] = $name;
412 $access['uri_part'] = $uri_part;
413 return $access;
414 }
415 }
416 }
417 return $access;
418 }
419
429 static function matchRegexp( &$text, $reg, $num )
430 {
431 $reg = str_replace( '/', "\\/", $reg );
432 if ( preg_match( "/$reg/", $text, $regs ) && $num < count( $regs ) )
433 {
434 $text = str_replace( $regs[$num], '', $text );
435 return $regs[$num];
436 }
437 return null;
438 }
439
449 static function matchText( &$text, $match_pre, $match_post )
450 {
451 $ret = null;
452 if ( $match_pre !== '' )
453 {
454 $pos = strpos( $text, $match_pre );
455 if ( $pos === false )
456 return null;
457
458 $ret = substr( $text, $pos + strlen( $match_pre ) );
459 $text = substr( $text, 0, $pos );
460 }
461 if ( $match_post !== '' )
462 {
463 $pos = strpos( $ret, $match_post );
464 if ( $pos === false )
465 return null;
466
467 $text .= substr( $ret, $pos + 1 );
468 $ret = substr( $ret, 0, $pos );
469 }
470 return $ret;
471 }
472
479 static function reInitialise()
480 {
481 if ( isset( $GLOBALS['eZCurrentAccess'] ) )
482 {
483 self::load( $GLOBALS['eZCurrentAccess'] );
484 return true;
485 }
486 else
487 {
488 return false;
489 }
490 }
491
504 static function change( array $access, eZINI $siteINI = null )
505 {
506 $name = $access['name'];
507 $GLOBALS['eZCurrentAccess'] =& $access;
508 if ( $siteINI !== null )
509 {
510 $ini = $siteINI;
511 }
512 else
513 {
514 $ini = eZINI::instance();
515 }
516
517 $ini->prependOverrideDir( "siteaccess/$name", false, 'siteaccess', 'siteaccess' );
518
519 /* Make sure extension siteaccesses are prepended */
520 eZExtension::prependExtensionSiteAccesses( $name, $ini );
521
522 $ini->loadCache();
523
524 // change some global settings if $siteINI is null
525 if ( $siteINI === null )
526 {
527 eZSys::clearAccessPath();
528 if ( empty( $access['uri_part'] ) || $access['uri_part'] === null )
529 {
530 if ( $ini->hasVariable('SiteSettings', 'SiteUriParts') )
531 $access['uri_part'] = $ini->variable('SiteSettings', 'SiteUriParts');
532 else if ( isset( $access['type'] ) && $access['type'] === eZSiteAccess::TYPE_URI )
533 $access['uri_part'] = array( $access['name'] );
534 else
535 $access['uri_part'] = array();
536 }
537
538 eZSys::setAccessPath( $access['uri_part'], $name );
539
540 eZContentLanguage::expireCache( false );
541
542 eZUpdateDebugSettings();
543 eZDebugSetting::writeDebug( 'kernel-siteaccess', "Updated settings to use siteaccess '$name'", __METHOD__ );
544 }
545
546 return $access;
547 }
548
561 private static function washName( $name )
562 {
563 return preg_replace(
564 array( '/[^a-zA-Z0-9]+/', '/_+/', '/^_/', '/_$/' ),
565 array( '_', '_', '', '' ),
566 $name
567 );
568 }
569
586 static function load( array $access, eZINI $siteINI = null )
587 {
588 $currentSiteAccess = $GLOBALS['eZCurrentAccess'];
589 unset( $GLOBALS['eZCurrentAccess'] );
590
591 // Clear all ini override dirs
592 if ( $siteINI instanceof eZINI )
593 {
594 $siteINI->resetOverrideDirs();
595 }
596 else
597 {
598 eZINI::resetAllInstances();
599 eZExtension::clearActiveExtensionsMemoryCache();
600 eZTemplateDesignResource::clearInMemoryCache();
601 }
602
603 // Reload extensions, siteaccess and access extensions
604 eZExtension::activateExtensions( 'default', $siteINI );
605 $access = self::change( $access, $siteINI );
606 eZExtension::activateExtensions( 'access', $siteINI );
607
608 // Restore current (old) siteacces if changes where only to be applied to locale instance of site.ini
609 if ( $siteINI instanceof eZINI )
610 {
611 $GLOBALS['eZCurrentAccess'] = $currentSiteAccess;
612 }
613 else
614 {
615 $moduleRepositories = eZModule::activeModuleRepositories();
616 eZModule::setGlobalPathList( $moduleRepositories );
617 }
618
619 return $access;
620 }
621
632 static function getIni( $siteAccess, $settingFile = 'site.ini' )
633 {
634 // return global if siteaccess is same as requested or false
635 if ( isset( $GLOBALS['eZCurrentAccess']['name'] )
636 && $GLOBALS['eZCurrentAccess']['name'] === $siteAccess )
637 {
638 return eZINI::instance( $settingFile );
639 }
640 else if ( !$siteAccess )
641 {
642 return eZINI::instance( $settingFile );
643 }
644
645 // create a site ini instance using $useLocalOverrides = true
646 $siteIni = new eZINI( 'site.ini', 'settings', null, null, true );
647
648 // create a dummy access definition (not used as long as $siteIni is sent to self::load() )
649 $access = array( 'name' => $siteAccess,
650 'type' => eZSiteAccess::TYPE_STATIC,
651 'uri_part' => array() );
652
653 // Load siteaccess but on our locale instance of site.ini only
654 $access = self::load( $access, $siteIni );
655
656 // if site.ini, return with no further work needed
657 if ( $settingFile === 'site.ini' )
658 {
659 return $siteIni;
660 }
661
662 // load settings file with $useLocalOverrides = true
663 $ini = new eZINI( $settingFile,'settings', null, null, true );
664 $ini->setOverrideDirs( $siteIni->overrideDirs( false ) );
665 $ini->load();
666
667 return $ini;
668 }
669
676 static function current()
677 {
678 if ( isset( $GLOBALS['eZCurrentAccess']['name'] ) )
679 return $GLOBALS['eZCurrentAccess'];
680 return null;
681 }
682
692 public static function saNameByLanguage( $language )
693 {
694 $ini = eZINI::instance();
695 if ( $ini->hasVariable( 'RegionalSettings', 'LanguageSA' ) )
696 {
697 $langMap = $ini->variable( 'RegionalSettings', 'LanguageSA' );
698 if ( !isset( $langMap[$language] ) )
699 {
700 return null;
701 }
702 $sa = $langMap[$language];
703 }
704 else
705 {
706 $sa = explode( '-', $language );
707 $sa = $sa[0];
708 }
709
710 if ( in_array( $sa, $ini->variable( 'SiteAccessSettings', 'RelatedSiteAccessList' ) ) )
711 {
712 return $sa;
713 }
714 eZDebug::writeWarning("Tried to find siteaccess based on '$language' but '$sa' is not a valid RelatedSiteAccessList[]", __METHOD__ );
715 return null;
716 }
717
723 public static function exists( $siteAccessName )
724 {
725 foreach ( eZSiteAccess::siteAccessList() as $siteaccessListItem )
726 {
727 if ( $siteaccessListItem['name'] == $siteAccessName )
728 {
729 return true;
730 }
731 }
732 return false;
733 }
734 }
$uri
$uri
Definition: activate.php:71
$access
if(! $user->isRegistered()) $access
Definition: authorize.php:88
eZContentLanguage\expireCache
static expireCache( $expireCluster=true)
Definition: ezcontentlanguage.php:917
eZDebugSetting\writeDebug
static writeDebug( $conditionName, $string, $label="")
Definition: ezdebugsetting.php:128
eZDebug\writeError
static writeError( $string, $label="", $backgroundClass="")
Definition: ezdebug.php:546
eZDebug\writeWarning
static writeWarning( $string, $label="", $backgroundClass="")
Definition: ezdebug.php:503
eZExecution\cleanExit
static cleanExit()
Definition: ezexecution.php:101
eZExtension\clearActiveExtensionsMemoryCache
static clearActiveExtensionsMemoryCache()
Definition: ezextension.php:588
eZExtension\activateExtensions
static activateExtensions( $extensionType='default', eZINI $siteINI=null)
Definition: ezextension.php:188
eZExtension\activeExtensions
static activeExtensions( $extensionType=false, eZINI|null $siteINI=null)
Definition: ezextension.php:61
eZExtension\baseDirectory
static baseDirectory(eZINI|null $siteINI=null)
Definition: ezextension.php:40
eZExtension\prependExtensionSiteAccesses
static prependExtensionSiteAccesses( $accessName=false, $ini=false, $globalDir=true, $identifier=null, $order=true)
Definition: ezextension.php:230
eZINI
Reads and writes .ini style configuration files.
eZSiteAccess
Definition: ezsiteaccess.php:18
eZSiteAccess\TYPE_HTTP_HOST
const TYPE_HTTP_HOST
Definition: ezsiteaccess.php:27
eZSiteAccess\reInitialise
static reInitialise()
Definition: ezsiteaccess.php:479
eZSiteAccess\SUBTYPE_POST
const SUBTYPE_POST
Definition: ezsiteaccess.php:36
eZSiteAccess\TYPE_URI
const TYPE_URI
Definition: ezsiteaccess.php:25
eZSiteAccess\TYPE_CUSTOM
const TYPE_CUSTOM
Definition: ezsiteaccess.php:33
eZSiteAccess\washName
static washName( $name)
Definition: ezsiteaccess.php:561
eZSiteAccess\siteAccessList
static siteAccessList()
Definition: ezsiteaccess.php:38
eZSiteAccess\match
static match(eZURI $uri, $host, $port=80, $file='/index.php')
Definition: ezsiteaccess.php:104
eZSiteAccess\current
static current()
Definition: ezsiteaccess.php:676
eZSiteAccess\TYPE_SERVER_VAR
const TYPE_SERVER_VAR
Definition: ezsiteaccess.php:30
eZSiteAccess\saNameByLanguage
static saNameByLanguage( $language)
Definition: ezsiteaccess.php:692
eZSiteAccess\change
static change(array $access, eZINI $siteINI=null)
Definition: ezsiteaccess.php:504
eZSiteAccess\matchText
static matchText(&$text, $match_pre, $match_post)
Definition: ezsiteaccess.php:449
eZSiteAccess\findPathToSiteAccess
static findPathToSiteAccess( $siteAccess)
Definition: ezsiteaccess.php:67
eZSiteAccess\getIni
static getIni( $siteAccess, $settingFile='site.ini')
Definition: ezsiteaccess.php:632
eZSiteAccess\TYPE_HTTP_HOST_URI
const TYPE_HTTP_HOST_URI
Definition: ezsiteaccess.php:32
eZSiteAccess\TYPE_URL
const TYPE_URL
Definition: ezsiteaccess.php:31
eZSiteAccess\load
static load(array $access, eZINI $siteINI=null)
Definition: ezsiteaccess.php:586
eZSiteAccess\matchRegexp
static matchRegexp(&$text, $reg, $num)
Definition: ezsiteaccess.php:429
eZSiteAccess\TYPE_PORT
const TYPE_PORT
Definition: ezsiteaccess.php:26
eZSiteAccess\TYPE_STATIC
const TYPE_STATIC
Definition: ezsiteaccess.php:29
eZSiteAccess\SUBTYPE_PRE
const SUBTYPE_PRE
Definition: ezsiteaccess.php:35
eZSiteAccess\exists
static exists( $siteAccessName)
Definition: ezsiteaccess.php:723
eZSiteAccess\TYPE_INDEX_FILE
const TYPE_INDEX_FILE
Definition: ezsiteaccess.php:28
eZSiteAccess\TYPE_DEFAULT
const TYPE_DEFAULT
Definition: ezsiteaccess.php:24
eZSys\indexDir
static indexDir( $withAccessList=true)
Definition: ezsys.php:594
eZSys\serverVariable
static serverVariable( $variableName, $quiet=false)
Definition: ezsys.php:857
eZSys\clearAccessPath
static clearAccessPath( $siteaccess=true)
Definition: ezsys.php:1060
eZSys\setAccessPath
static setAccessPath(array $path=array(), $name='undefined', $siteaccess=true)
Definition: ezsys.php:1046
eZSys\ezcrc32
static ezcrc32( $string)
Definition: ezsys.php:1298
eZURI
Definition: ezuri.php:29
eZURI\encodeIRI
static encodeIRI( $str)
Definition: ezuri.php:105
$ini
$ini
Definition: classes/admin/linklist.php:64
$type
$type
Definition: classes/admin/linkselect.php:220
$name
$name
Definition: companytypelist.php:194
file_exists
static file_exists( $inifilename)
Definition: eZPBINIFile.php:195
$file
$file
Definition: ezfilemanager/user/filedownload.php:35
$ret
$ret
Definition: ezsitemanager/admin/filelist.php:88
$elements
$elements
Definition: formedit.php:355
eZUpdateDebugSettings
eZUpdateDebugSettings()
Definition: global_functions.php:88
$language
$language
Definition: messageform.php:32
$order
$order
Definition: productreport.php:182
$location
$location
Definition: user/gotolink.php:43
Copyright © 1998 – 2026 7x. All rights reserved. Licensed under the GNU GPLv2+.