|
|
The include() statement includes and evaluates
the specified file.
The documentation below also applies to require().
The two constructs are identical in every way except how they handle
failure. They both produce a
Warning, but require()
results in a Fatal Error.
In other words, use require() if you want
a missing file to halt processing of the page. include() does
not behave this way, the script will continue regardless. Be sure to have an
appropriate include_path setting as well.
Be warned that parse error in included file doesn't cause processing halting
in PHP versions prior to PHP 4.3.5. Since this version, it does.
Files for including are first looked in include_path relative to the current working directory
and then in include_path relative to the directory of current script. E.g. if your include_path
is ., current working directory is /www/,
you included include/a.php and there is include "b.php"
in that file, b.php is first looked in /www/
and then in /www/include/.
If filename begins with ./ or ../, it
is looked only in include_path relative to the current working directory.
When a file is included, the code it contains inherits the
variable scope of the
line on which the include occurs. Any variables available at that line
in the calling file will be available within the called file, from that
point forward.
However, all functions and classes defined in the included file have the
global scope.
Пример 16-5. Basic include() example |
vars.php
<?php
$color = 'green';
$fruit = 'apple';
?>
test.php
<?php
echo "A $color $fruit"; include 'vars.php';
echo "A $color $fruit"; ?>
|
|
If the include occurs inside a function within the calling file,
then all of the code contained in the called file will behave as
though it had been defined inside that function. So, it will follow
the variable scope of that function.
Пример 16-6. Including within functions |
<?php
function foo()
{
global $color;
include 'vars.php';
echo "A $color $fruit";
}
foo(); echo "A $color $fruit"; ?>
|
|
When a file is included, parsing drops out of PHP mode and
into HTML mode at the beginning of the target file, and resumes
again at the end. For this reason, any code inside the target
file which should be executed as PHP code must be enclosed within
valid PHP start
and end tags.
If "URL fopen wrappers"
are enabled in PHP (which they are in the default configuration),
you can specify the file to be included using a URL (via HTTP or
other supported wrapper - see Прил. M for a list
of protocols) instead of a local pathname. If the target server interprets
the target file as PHP code, variables may be passed to the included
file using a URL request string as used with HTTP GET. This is
not strictly speaking the same thing as including the file and having
it inherit the parent file's variable scope; the script is actually
being run on the remote server and the result is then being
included into the local script.
| Внимание |
Версии PHP для Windows до PHP 4.3.0 не
поддерживают возможность использования удаленных файлов этой
функцией даже в том случае, если опция
allow_url_fopen
включена. |
Пример 16-7. include() through HTTP |
<?php
include 'http://www.example.com/file.txt?foo=1&bar=2';
include 'file.php?foo=1&bar=2';
include 'http://www.example.com/file.php?foo=1&bar=2';
$foo = 1;
$bar = 2;
include 'file.txt'; include 'file.php'; ?>
|
|
| Security warning |
Remote file may be processed at the remote server (depending on the file
extension and the fact if the remote server runs PHP or not) but it still
has to produce a valid PHP script because it will be processed at the
local server. If the file from the remote server should be processed
there and outputted only, readfile() is much better
function to use. Otherwise, special care should be taken to secure the
remote script to produce a valid and desired code.
|
See also Remote files,
fopen() and file() for related
information.
Handling Returns: It is possible to execute a return()
statement inside an included file in order to terminate processing in that
file and return to the script which called it. Also, it's possible to return
values from included files. You can take the value of the include call as
you would a normal function. This is not, however, possible when including
remote files unless the output of the remote file has
valid PHP start
and end tags (as with any local file). You can declare the needed
variables within those tags and they will be introduced at whichever point
the file was included.
Because include() is a special language construct,
parentheses are not needed around its argument. Take care when comparing
return value.
Пример 16-8. Comparing return value of include |
<?php
if (include('vars.php') == 'OK') {
echo 'OK';
}
if ((include 'vars.php') == 'OK') {
echo 'OK';
}
?>
|
|
Замечание:
In PHP 3, the return may not appear inside a block unless it's
a function block, in which case the return() applies
to that function and not the whole file.
Пример 16-9. include() and the return() statement |
return.php
<?php
$var = 'PHP';
return $var;
?>
noreturn.php
<?php
$var = 'PHP';
?>
testreturns.php
<?php
$foo = include 'return.php';
echo $foo; $bar = include 'noreturn.php';
echo $bar; ?>
|
|
$bar is the value 1 because the include
was successful. Notice the difference between the above examples. The first uses
return() within the included file while the other does not.
If the file can't be included, FALSE is returned and
E_WARNING is issued.
If there are functions defined in the included file, they can be used in the
main file independent if they are before return() or after.
If the file is included twice, PHP 5 issues fatal error because functions
were already declared, while PHP 4 doesn't complain about functions
defined after return().
It is recommended to use include_once() instead of
checking if the file was already included and conditionally return inside
the included file.
Another way to "include" a PHP file into a variable is to capture the
output by using the Output Control
Functions with include(). For example:
Пример 16-10. Using output buffering to include a PHP file into a string |
<?php
$string = get_include_contents('somefile.php');
function get_include_contents($filename) {
if (is_file($filename)) {
ob_start();
include $filename;
$contents = ob_get_contents();
ob_end_clean();
return $contents;
}
return false;
}
?>
|
|
In order to automatically include files within scripts, see also the
auto_prepend_file and
auto_append_file
configuration options in php.ini.
Замечание: Поскольку это языковая
конструкция, а не функция, она не может вызываться при помощи
переменных функций
See also require(), require_once(),
include_once(), get_included_files(),
readfile(), virtual(), and
include_path.
slush puppie
24-Oct-2007 11:40
two little methods i wrote up that work on our IIS6 server. the first makes an alternate include call you can use to include things by calling them via their root location. the second method alters the include path so all include() calls are via the root location.
these are a compilation of a few methods i found here, but i think i made them a bit more modular. anyhow...
<?php
function rinclude($path){
$levels = substr_count($_SERVER['PHP_SELF'],'/');
$root = '';
for($i = 1; $i < $levels; $i++){$root .= '../';}
include($root . $path);
}
rinclude('file.inc.php'); rinclude('dir/file.inc.php'); ?>
<hr />
<?php
function setinclude(){
$levels = substr_count($_SERVER['PHP_SELF'],'/');
$root = '';
for($i = 1; $i < $levels; $i++){$root .= '../';}
set_include_path($root);
}
setinclude();
include('file.inc.php'); include('dir/file.inc.phpp'); ?>
sbwoodside at yahoo dot com
07-Oct-2007 02:19
Here's a really simple solution to a common problem. Let's say you want to include files the way that apache does, relative to the document root (the root dir of your app). Independent of what server you are on, so that you don't have to specify an absolute path on your filesystem. At the top of your page put:
<?php set_include_path( get_include_path() . PATH_SEPARATOR . $_SERVER['DOCUMENT_ROOT'] ); ?>
Now anywhere you do an include you can do something like:
<?php include ( "Templates/header.inc") ?>
So, if your server files are in /var/www/mysite, this will include /var/www/mysite/Templates/header.inc when it's on your server. And if on your dev machine it's in /user/myname/mysite, it will include /user/myname/mysite/Templates/header.inc when it's on your dev machine.
gomodo at free dot fr
02-Sep-2007 03:29
Reponse to rayro at gmx dot de (21-Aug-2007 11:48 )
Hi rayro,
your code :
<?php
include(realpath('../../../test.php'));
?>
..Don't works when a function is called by another remote function (with a another remote include) -> realpath don't use __FILE__ reference :(
This works always and everywhere ( thanks to Jonny Rylands http://fr2.php.net/manual/fr/function.realpath.php#56773 ) :
<?
include (realpath(dirname(__FILE__).'/relative/path/to/include.inc.php'));
?>
friendly.
twolfley at gmail dot com
30-Aug-2007 10:37
With a large system you might have lots of functions. I have noticed that this can produce large memory overhead, some of which can be alleviated by using includes in the following manner:
e.g.
<?php
function foo() {
return $bar;
}
?>
can be rewritten as:
<?php
function foo() {
return include "foo.php";
}
?>
where foo.php contains the following:
<?php
return $bar;
?>
The result is the function's body does not get loaded into memory until the function is actually called.
rayro at gmx dot de
21-Aug-2007 02:48
well, im using "realpath" on each include i make.
http://www.php.net/realpath
this function rewrites relative paths and symbolic links:
<?php
include(realpath('../../../test.php'));
?>
eeckart at gmail dot com
16-Aug-2007 09:17
In reference to the fopen() and $use_include_path workaround for checking whether a include file exists as posted by [arnold at bean-it dot nl]...
I did some benchmarks with 100 dirs (each with 1 file) in the include_path on Apache/2.0.55 (Win32) PHP/5.2.1.
Here are the results:
(note: in the success scenarios, I am include'ing the file in the LAST directory on the include stack. This is to maximize the seek time; fail scenarios simply use a non-existent file; all times are in seconds )
benchmarks --> plain vanilla INCLUDE
(success)
0.05515718460083
0.054859161376953
0.053768157958984
(fail)
0.22402501106262
0.17378783226013
0.14510798454285
benchmarks --> fopen() and $use_include_path workaround
(success)
0.060588836669922
0.069549798965454
0.056423902511597
(fail)
0.05295991897583
0.039775133132935
0.054499864578247
>>> CONCLUSION
In cases involving MANY include paths, include() is -marginally- faster than the workaround (unsurprising - we incur the extra overhead of BOTH the fopen() call AND the $use_include_path seek). I say marginal in comparison to the "fail" scenarios, detailed next..
The most surprising thing is the inefficiency of include() when you are trying for a non-existent file. As compared to the workaround, the native include() method is roughly 3 times slower.
Based on additional tests (50 paths only), I note that any decrease in seek time for either case is generally linear to the number of paths.
---
THEREFORE, depending on the amount of paths you have, you might want to resort to different methods of optimizing the includes in your scripts, especially if you need to constantly test for the existence of include'd files (our organization uses a templating engine that relies on a virtual flat directory structure using the set_include_path() function).
---
From a technical perspective, I have no idea why this is the case and I find the prospect of trawling the PHP source to be rather daunting. However, as an educated guess: I figure that the include() code assumes the file exists, and so wastes processor cycles making a system read call, which inevitably fails.
For those interested in the benchmark script, you can email me at the email address provided above. No support, of course. :P
tim furry
09-Aug-2007 08:09
A small tweak to alex's getFilePath function allows it to work for Windows-based PHP as well:
<?php
$absPath = str_replace("\\", "/", dirname($_SERVER['SCRIPT_FILENAME']));
?>
Windows recognizes a forward slash as a directory separator character.
Using $_SERVER['DOCUMENT_ROOT'] and similar solutions didn't seem to work for web paths with internal symbolic links. Alex's function gets around that and works great.
alex carstea
26-Jul-2007 08:07
Since include() caused me many problems when i was trying to test my code, I wrote a small function. It receives as parameter the path to the file to include relative to the current file. The format similar to :
"../../path/FileName.php"
The function returns the absolute path to the file to be included. This path can be used as argument to include() and resolves the problem of nested inclusions.
<?php
function getFilePath($relativePath){
$absPath=dirname($_SERVER['SCRIPT_FILENAME']);
$relativeArray=explode("/",$relativePath);
$absArray=explode("/",$absPath);
$upTokens=0;
while(( $upTokens<count($relativeArray)) and ($relativeArray[$upTokens]=="..")) {
$upTokens++;
}
$filePath=$absArray[0];
for ($i=1; $i< (count($absArray)-$upTokens);$i++) {
$filePath.="/".$absArray[$i];
}
for ($i=$upTokens; $i< count($relativeArray);$i++){
$filePath.="/".$relativeArray[$i];
}
return $filePath;
}
?>
Hope you will find it usefull....
Alex
Cory Gagliardi
25-Jul-2007 11:22
Easy way to set $_GET values for local includes.
This is an easy way to make up fake URLs for SEO purposes that are really just running other PHP pages with special $_GET values.
This will NOT work:
<?PHP
include('communities.php?show=gated&where=naples');
?>
However, this will:
<?PHP
$_GET = array();
$_GET['show'] = 'gated';
$_GET['where'] = 'naples';
include('communities.php');
?>
Putting this on your page and nothing else will give the same result as going to
'communities.php?show=gated&where=naples'
but the URL can be whatever you want it to be.
none
17-Jul-2007 02:09
If you want to include a file that has no PHP in it (such as a template), it is more efficient to use file_get_contents().
Instead of:
include "file.htm";
use:
echo file_get_contents("file.htm");
In a rough millisecond test using gettimeofday(), it proved to be about twice as fast.
adam at adamleayr dot id dot au
02-Jul-2007 05:22
In response to oasis1 below, I use mod_rewrite to pipe all my requests through the index.php file, so I'm able to use the below code to find the root directory:
$sRoot = $_SERVER['HTTP_HOST'] . dirname($_SERVER['SCRIPT_NAME']);
You may be able to modify it to suit yourself.
oasis1 at geocities dot com
29-Jun-2007 08:11
What a pain! I have struggled with including files from various subdirectories. My server doesn't support an easy way to get to the root HTML directory so this is what I came up with:
<?php
$times = substr_count($_SERVER['PHP_SELF'],"/");
$rootaccess = "";
$i = 1;
while ($i < $times) {
$rootaccess .= "../";
$i++;
}
include ($rootaccess."foo/bar.php");
?>
This will give you what it takes to get to the root directory, regardless of how many subdirectories you have traveled through.
post-nospam at brucemiller dot co dot uk
04-Jun-2007 02:07
A very EASY way to get 'include' to find its way to another directory, other than setting the 'include path', and useful for fetching one or two files:
include ($_SERVER['DOCUMENT_ROOT']."/foo/bar.php");
This creates an include that is relative to the root rather than the current directory.
The dot is for concatenation, not current directory, as with 'include path' syntax.
See Appendix M of Manual > Reserved words > Predefined Variables, for more info on $SERVER.
safak_ozpinar at NOSPAM dot yahoo dot com
02-Jun-2007 06:18
This is a good example for returning a value from an included file I think.
I'm working on my own template class like Smarty. This class gets html code from template files. Then it creates a file that will be included directly. It displays only installed modules for the page. The included page always checks the installed modules. If the comparision returns false, the included file returns FALSE and warns the class to recreate itself. Then a new file with requested modules will be overwritten to the existing one.
Here is the main framework of my class:
<?php
class MyInclude {
private $modules = array();
private $numModules = 0;
function MyInclude($inputModules) {
if(!is_array($inputModules)) $inputModules = array($inputModules);
foreach($inputModules as $module) {
$this->modules[$this->numModules] = $module;
$this->numModules++;
}
}
function Display($fname, $reCreate = FALSE) {
if(@file_exists($fname) && !$reCreate) {
if((include $fname)==FALSE) {
$this->Display($fname, TRUE);
return;
}
}
else {
$this->Create($fname);
include($fname);
}
}
private function Create($fname) {
$contentsPHP = '<?'."\n";
$contentsHTML = '<html><body>'."\n";
foreach($this->modules as $module) {
$contentsPHP .= '$storedModules[] = \''.$module.'\';'."\n";
$contentsHTML .= '<p>HTML code for module <b>"'.$module.'"</b></p>'."\n";
}
$contentsPHP .= 'if(!$this->Compare($storedModules)) return FALSE;'."\n";
$contentsPHP .= '?>'."\n";
$contentsHTML .= '</body></html>';
$fp = fopen($fname,'wb');
fwrite($fp, $contentsPHP.$contentsHTML);
fclose($fp);
}
function Compare($storedModules) {
$count = count($storedModules);
if($count == $this->numModules) {
for($i=0; $i<$count; $i++) {
if(strcmp($storedModules[$i],$this->modules[$i])!=0)
return FALSE;
}
return TRUE;
}
else return FALSE;
}
}
$tpl = new MyInclude(array('headline','main_menu','sub_menu','text_ads'));
$tpl->Display('inc.php');
?>
I haven't written error controls here because the code would be too large. For instance; if a html template for requested modules doesn't exist, you may want to display an error message or make some operations.
---
Safak Ozpinar (from Istanbul University)
user at example.com
20-May-2007 08:38
Regarding the caching of includes.
I submitted a bug for this, apparently it's not a bug it's supposed to work that way for some reason.
The bugs team declined to elaborate as to why but it would seem includes aren't meant to use dynamic code, which makes this function worthless and by extension makes php needlessly time consuming because you can't reuse files properly.
13-May-2007 08:40
Even when you set cache control and expiry headers:
header("Expires: 0");
header("Last-Modified: " . gmdate("D, d M Y H:i:s") . " GMT");
header("cache-control: no-store, no-cache, must-revalidate");
header("Pragma: no-cache");
It doesn't seem to reparse the include on the second hit to the page without a forced refresh.
e.g. a page where you direct to a login page which changes a $_SESSION var then returns to the originating page.
The originating page doesn't execute the code so it looks like still not logged in.
cmedina at bluecorestudio dot com
30-Apr-2007 10:03
I wanted that included files behave like in C/C++ and this was killing me. So I created this function that really helped me (Note: You should add these lines to EVERY included file).
Code Lines:
<?
$FILE_PATH = preg_replace_callback(
'/(.*)(\\\?.*?)\s*;\1(\\\?.*?)\s*$/',
create_function(
'$matches',
'$path = str_replace("\\\", "/",(isset($matches[2])?
preg_replace(
\'/(?:^\/|^\\\\\)?[^\/\\\\\]+(?:\/|\\\\\)?/\',
"../",$matches[2]):"./").
(isset($matches[3])?$matches[3]:""));
return !empty($path)? "$path/" : "./";'
)
,realpath("./").";".dirname(__FILE__)
);
?>
Usage Example:
Files hierarchy for example
/www/file.php
/include/secondfile.php
/include/test/anotherfile
<? //file.php
//i will not include the code lines in example to avoid repetition but you have to
// --- FILE_PATH code lines here ---
// include the file relative to the caller position remember to use a relative path from each file to desired file
include ($FILE_PATH . "../../include/secondfile.php");
?>
<? //secondfile.php
// --- FILE_PATH code lines here ---
//note that path used is in reference to secondfile.php's path and not the original caller's(file.php) path
include ($FILE_PATH . "test/anotherfile"); //or include ($FILE_PATH . "./test/anotherfile");
?>
<? //anotherfile
/* --- some mixed content here --- */
?>
Now you can do recursive includes to files inside already
included files using each file's path as reference, like in
c/c++!!!
I'd tested this just in WINXP (PHP Version 4.4.1), so, I
dont know how it behaves in other OS/PHP-Versions. Any
additional suggestions or bugs, please let me know.
gabriel at bumpt dot net
09-Mar-2007 07:36
In response to baofu:
The problem with calling:
set_include_path( ... )
before including any file, is that if one of the included files, in turn, does a set_include_path to include yet another bunch of files, then the following include statement in your topmost file, is done in an include path context that has changed.
Using: include dirname(__FILE__).'/../foo/bar' remains the best solution.
Khaos
23-Feb-2007 11:43
This might help a bit for security (no guarantees).
Instead of
include $page;
put
include str_replace('../', '', './' . $page);
-hh-
23-Feb-2007 03:47
coldflame,
<?=$foo?> equals <? print $foo ?>
If 1 is not needed at the end, just use <? include($filename) ?> without the equal sign.
anon
12-Feb-2007 05:49
Be careful using the <?= / ?> start and end tags with include / require.
A lovely feature/bug/misunderstanding meant that the result of
<?=include(filename)?>
was to get the contents of the file, suffixed with a '1'. I can only assume that the one is the return code of the include.
hopefully my pain can help somebody else :D
cheers,
coldflame
mbread at m-bread dot com
10-Feb-2007 09:23
If you have a problem with "Permission denied" errors (or other permissions problems) when including files, check:
1) That the file you are trying to include has the appropriate "r" (read) permission set, and
2) That all the directories that are ancestors of the included file, but not of the script including the file, have the appropriate "x" (execute/search) permission set.
baofu
02-Feb-2007 07:22
you can also use the following before you include any files.
set_include_path(dirname(__FILE__))
Nathan Ostgard
19-Jan-2007 02:32
You can also use debug_backtrace to write a function that do the chdir automatically:
<?php
function include_relative($file)
{
$bt = debug_backtrace();
$old = getcwd();
chdir(dirname($bt[0]['file']));
include($file);
chdir($old);
}
?>
anonymous
18-Jan-2007 01:49
When I'm dealing with a package that uses relative includes of its own, rather than modify all of their includes, I found it was easier to change PHP's working directory before and after the include, like so:
<?
$wd_was = getcwd();
chdir("/path/to/included/app");
include("mainfile.php");
chdir($wd_was);
?>
This way neither my includes nor theirs are affected; they all work as expected.
dionyziz at deviantart dot com
18-Jan-2007 08:06
In reply to the last anonymous note, this is exactly the way mediawiki code handles this problem. They have various-depth include paths.
So, for instance, inside includes/normal/UtfNormal.php (as of revision 19455) they do:
<?php
require_once dirname(__FILE__).'/UtfNormalUtil.php';
?>
...to include the file includes/normal/UtfNormal.php.
vahe dot ayvazyan at googlemail dot com
10-Jan-2007 03:12
If you want the "include" function to work correctly with paths and GET parameters, try the following code:
<?php
$_GET['param1'] = 'param1value';
$_GET['param2'] = 'param2value';
@include($_SERVER['DOCUMENT_ROOT'] . "/path1/path2/include.php");
?>
Then within your "include.php" use $_GET['param1'] and $_GET['param2'] to access values of parameters.
I spent several hours to figure this out.
anonymous
01-Jan-2007 06:42
I'm gonna throw my hat in the rink and also say that I've always thought that the include path being relative to the current directory is silly. PHP is the only language I can think of that does this. Almost all of my include paths have always had to be prefixed with <?php dirname(__FILE__) ?> to operate expectedly.
Nathan Ostgard
28-Dec-2006 11:27
I have to agree with sean dot farrell at digital-egg dot org.
If I put "../" or "./" in a call to include(), I expect it to be relative to the file I am including from, not the current working directory of the application.
This backwards mentality for relative paths really interferes with PHP's ability to build packages of files independent of an application.
sean dot farrell at digital-egg dot org
29-Nov-2006 06:12
The way PHP handles the ./ and ../ is totally counter intuitive. As said if the included file is preceded by a ./ and ../ it looked up from the current working directory. And that is defined by the of the EXECUTED script. That is the script that you specified in the url.
So if your have a.php that includes include/b.php that includes ../extern/c.php, it will not do what you want. You can use extern/c.php instead if you never execute outside of the document root. For me that just will not cut it. Since I execute test suites if files are directly called, like in python.
Here is my dirty trick that works, since I only have two levels of file hierarchy:
set_include_path("../:./");
require_once("extern/c.php");
And here is an open question: Why are the included files not looked up relative from the file that includes them and then in the include path? This would be a behavior like in all other languages.
rickkyREMOVETHIS at gmail dot com
16-Nov-2006 01:03
In response to http://uk.php.net/manual/en/function.include.php#38000
Using the following at the top of your CLI scripts will make includes work similar to web PHP.
#!/usr/bin/php
<?php chdir(dirname(__FILE__)); ?>
This changes the current working directory to the one your script is running in. Its quite used for taking existing web scripts and getting them to run quickly in the command line.
Janci
16-Nov-2006 07:59
Please note that althought you can call a function that is DEFINED later in the code, you cannot call a function that is defined in a file which is INCLUDED later. Consider following two examples:
Example 1:
<?php
test();
function test()
{
echo 'In test.';
}
?>
Example 2:
file1.php:
<?
test();
include 'file2.php';
?>
file2.php:
<?
function test()
{
echo 'In test.';
}
?>
Please be aware that while the first example will work as expected, the second one will generate a fatal error "Call to undefined function: test() ...". The same is true for the require.
nospam at nospam dot com
13-Aug-2006 05:28
Trick to get around including get method...
Since this doesn't work:
include('page.php?id=1');
Try this:
$_REQUEST['id'] = 1;
include('page.php');
mlindal at pfc dot forestry dot ca
08-Aug-2006 08:33
If a person directly accesses an include file by mistake, you may want to forward them to a correct default page.
Do this by:
Say the file to be included is 'newpubs.php'
and the main pages are either newpubs_e.php or newpubs_f.php
if($_SERVER[PHP_SELF]=="/newpubs.php")
{
header("Location: newpubs_e.php");
exit;
}
Will send them to newpubs_e.php if they try to access newpubs.php directly.
medhefgo at googlemail dot com
27-May-2006 04:50
Because there is no quick way to check if a file is in include_path, I've made this function:
<?php
function is_includeable($filename, $returnpaths = false) {
$include_paths = explode(PATH_SEPARATOR, ini_get('include_path'));
foreach ($include_paths as $path) {
$include = $path.DIRECTORY_SEPARATOR.$filename;
if (is_file($include) && is_readable($include)) {
if ($returnpaths == true) {
$includable_paths[] = $path;
} else {
return true;
}
}
}
return (isset($includeable_paths) && $returnpaths == true) ? $includeable_paths : false;
}
?>
NOdasnipaSPAM
19-May-2006 02:40
at spam guard dot gmail com
to php dot net at reinsveien dot com:
if you know the domain the file should be coming from then you can parse the variable for the domain and make sure that it matches the domain you expect, example:
<?php
$path="/full/path/to/script/";
if (getdomain($path) == 'yourdomain'){
include($path.'somefile.php');
}
?>
this should prevent remote execution of any malicious script
lholst+phpnet at students dot cs dot uu dot nl
08-May-2006 12:15
What cavarlier refers to is that on some editors, UTF-8 files are prefixed with a BOM (Byte Order Mark), an invisible marker three bytes in size, which are output by PHP if it encouters them (which is before the <?php on the first line). Notepad is particularly notorious creating these.
However, any decent editor (e.g. Notepad2) can save UTF-8 files without BOM, and if you do that the first <?php tag will truly be on the first character of the file.
So this does not mean that UTF-8 cannot be used by PHP.
cavarlier [at] hotmail [dot] com
22-Apr-2006 12:59
please note when you include a (utf-8) encoded file, this will be sufficient to send headers even if it doesnt contain any line breaks
arnold at bean-it dot nl
24-Feb-2006 02:15
Currently there is no clean way to check if a file can be included. Simply including a file which can't be opened causes a warning to be triggered. Suppressing include() with an @ (as often seen below) is not advisable, since parse errors won't be displayed, but will cause the script to die, causing a blank screen. (Happy debugging, hope you're using ZendStudio or some other debugger).
The best solution I've come up with is:
<?php
if (($fp = @fopen($filename, 'r', 1)) and fclose($fp)) include $filename;
?>
I believe the functions file_exists(), filesize(), is_readable() and is_writable() should have an use_include_path just like fopen().
If you agree with this, please PLEASE VOTE on bug #6932 (http://bugs.php.net/bug.php?id=6932). This bug has been open for over 5 years. Apparently no one is willing to add this feature.
Stephen Lee
19-Jan-2006 04:36
@ajsharp at gmail dot com
To find out which script has included another, use the Server Variable 'SCRIPT_NAME' (note: there are other server variables that also contain the script name, but I use this one simply because it works for me) e.g.
"variables.php"
<?php
$includer = basename($_SERVER['SCRIPT_NAME']);
switch ($includer) {
case 'a.php':
$this_variable = 'included by script a.php';
break;
case 'b.php':
$this_variable = 'included by script b.php';
break;
default:
$this_variable = 'included by unkown script';
}
echo $this_variable;
?>
Test with 3 different files "a.php", "b.php", "c.php", all with the same content:
<?php
include 'variables.php';
?>
stalker at ruun dot de
10-Jan-2006 04:55
a simple function to recursively include e.g. the include-directory of your site and its subdirs:
<?php
function includeRecurse($dirName) {
if(!is_dir($dirName))
return false;
$dirHandle = opendir($dirName);
while(false !== ($incFile = readdir($dirHandle))) {
if($incFile != "."
&& $incFile != "..") {
if(is_file("$dirName/$incFile"))
include_once("$dirName/$incFile");
elseif(is_dir("$dirName/$incFile"))
includeRecurse("$dirName/$incFile");
}
}
closedir($dirHandle);
}
?>
php at bucksvsbytes dot com
03-Oct-2005 12:31
The documentation should make it clearer that the include argument is not a site path (i.e. not relative to the document root or to any web server defined aliases), but rather a path on the host relative to the calling script's directory.
wamsleye at yahoo dot com
24-Aug-2005 02:21
I had been looking around on how to make sure that a file is included, I guess the way to do it changed with new version, here we go:
<?php
if ((include "header.php") == true) {
echo ("header loaded");
}else{
echo("header not loaded");
}?>
hope that helps!
Jesper Juhl
14-Aug-2005 08:14
If you want to prevent direct access to some files and only allow them to be used as include files by other scripts, then an easy way to accomplish that is to check a define in the include file.
Like this.
includefile.php
---
<?php
defined('_VALID_INCLUDE') or die('Direct access not allowed.');
?>
script.php
---
<?php
define('_VALID_INCLUDE', TRUE);
include('includefile.php');
?>
ignacio esviza
19-Jul-2005 02:10
Hi, there...
I've use this in order to grab the output from an include() but without sending it to the buffer.
Headers are not sent neither.
<?php
function include2($file){
$buffer = ob_get_contents();
include $file;
$output = substr(ob_get_contents(),strlen($buffer));
ob_end_clean();
ob_start();
echo $buffer;
return $output;
}
?>
Ethilien
18-Jul-2005 12:04
Another way of getting the proper include path relative to the current file, rather than the working directory is:
<?php
include realpath(dirname(__FILE__) . "/" . "relative_path");
?>
Berenguer Blasi
04-Jul-2005 06:07
When working with a well organized project you may come across multiple problems when including, if your files are properly stored in some nice folders structure such as:
- src
- web
- bo
- lib
- test
- whatever
as the include path's behaviour is somehow strange.
The workaround I use is having a file (ex: SiteCfg.class.php) where you set all the include paths for your project such as:
$BASE_PATH = dirname(__FILE__);
$DEPENDS_PATH = ".;".$BASE_PATH;
$DEPENDS_PATH .= ";".$BASE_PATH."/lib";
$DEPENDS_PATH .= ";".$BASE_PATH."/test";
ini_set("include_path", ini_get("include_path").";".$DEPENDS_PATH);
Make all paths in this file relative to IT'S path. Later on you can import any file within those folders from wherever with inlude/_once, require/_once without worrying about their path.
Just cross fingers you have permissions to change the server's include path.
17-May-2005 08:10
Thought you can figure it out by reading the doc, this hint might save you some time. If you override include_path, be sure to include the current directory ( . ) in the path list, otherwise include("includes/a.php") will not search in the current script directory.
e.g :
if(file_exists("includes/a.php"))
include("includes/a.php")
The first line will test to true, however include will not find the file, and you'll get a "failed to open stream" error
php at REMOVEMEkennel17 dot co dot uk
02-May-2005 05:20
As stated above, when using return() to terminate execution of an included file, any functions defined in the file will still be defined in the global scope, even if the return() occurs before their definition.
It should be noted that class definitions behave in the same way.
morris.php <A T> it-solutions.org
28-Apr-2005 05:31
Something not previously stated here - but found elsewhere - is that if a file is included using a URL and it has a '.php' extension - the file is parsed by php - not just included as it would be if it were linked to locally.
This means the functions and (more importantly) classes included will NOT work.
for example:
include "http://MyServer.com/MyInclude.php";
would not give you access to any classes or functions within the MyInclude.php file.
to get access to the functions or classes you need to include the file with a different extension - such as '.inc' This way the php interpreter will not 'get in the way' and the text will be included normally.
gillis dot php at TAKETHISAWAY dot gillis dot fi
14-Apr-2005 02:47
This is not directly linked to the include function itself. But i had a problem with dynamically generated include-files that could generate parse errors and cause the whole script to parse-error.
So as i could not find any ready solution for this problem i wrote the mini-function. It's not the most handsome solution, but it works for me.
<?php
function ChkInc($file){
if(substr(exec("php -l $file"), 0, 28) == "No syntax errors detected in"){
return true;
}else{
return false;
}
}
?>
if someone else has a better solution, do post it...
Note. remember that this function uses unchecked variables passed to exec, so don't use it for direct user input without improving it.
//Gillis Danielsen
dragon at wastelands dot net
09-Dec-2004 04:30
The __FILE__ macro will give the full path and name of an included script when called from inside the script. E.g.
<? include("/different/root/script.php"); ?>
And this file contains:
<? echo __FILE__; ?>
The output is:
/different/root/script.php
Surprisingly useful :> Obviously something like dirname(__FILE__) works just fine.
mattcimino at gardiners dot com
10-Aug-2004 05:47
To avoid painfully SLOW INCLUDES under IIS be sure to set "output_buffering = on" in php.ini. File includes dropped from about 2 seconds to 0 seconds when this was set.
durkboek A_T hotmail D_O_T com
03-Jun-2004 04:09
I would like to emphasize the danger of remote includes. For example:
Suppose, we have a server A with Linux and PHP 4.3.0 or greater installed which has the file index.php with the following code:
<?php
include ($_GET['id'].".php");
?>
This is, of course, not a very good way to program, but i actually found a program doing this.
Then, we hava a server B, also Linux with PHP installed, that has the file list.php with the following code:
<?php
$output = "";
exec("ls -al",$output);
foreach($output as $line) {
echo $line . "<br>\n";
}
?>
If index.php on Server A is called like this: http://server_a/index.php?id=http://server_b/list
then Server B will execute list.php and Server A will include the output of Server B, a list of files.
But here's the trick: if Server B doesn't have PHP installed, it returns the file list.php to Server A, and Server A executes that file. Now we have a file listing of Server A!
I tried this on three different servers, and it allways worked.
This is only an example, but there have been hacks uploading files to servers etc.
So, allways be extremely carefull with remote includes.
marco_ at voxpopuli-forum dot net
12-Apr-2004 09:27
In addition to the redeye at cs-aktuell dot de note:
to make pseudo-frame in total security
example: http://www.yourdomain.com/index.php?page=news
<?php
if(isset($HTTP_GET_VARS['page']))
{
$p = $HTTP_GET_VARS['page'];
}
else
{
$p = 'index';
}
switch($p)
{
case 'index':
require('welcome.php');
break;
case 'news':
require('news.php');
break;
case 'what you want':
require('the file you want');
break;
default:
exit('Wrong parameter for file inclusion');
}
?>
marco_
moosh at php dot net
15-Jan-2004 07:03
<?php
@include('/foo') OR die ("bar"); @(include('/foo')) OR die ("bar"); ?>
so "or" have prority on "include"
james at gogo dot co dot nz
09-Dec-2003 10:03
While you can return a value from an included file, and receive the value as you would expect, you do not seem to be able to return a reference in any way (except in array, references are always preserved in arrays).
For example, we have two files, file 1.php contains...
<?php
function &x(&$y)
{
return include(dirname(__FILE__) . '/2.php');
}
$z = "FOO\n";
$z2 = &x($z);
echo $z2;
$z = "NOO\n";
echo $z2;
?>
and file 2.php contains...
<?php return $y; ?>
calling 1.php will produce
FOO
FOO
i.e the reference passed to x() is broken on it's way out of the include()
Neither can you do something like <?php $foo =& include(....); ?> as that's a parse error (include is not a real function, so can't take a reference in that case). And you also can't do <?php return &$foo ?> in the included file (parse error again, nothing to assign the reference too).
The only solutions are to set a variable with the reference which the including code can then return itself, or return an array with the reference inside.
---
James Sleeman
http://www.gogo.co.nz/
david dot gaia dot kano at dartmouth dot edu
04-Dec-2003 01:13
I just discovered a "gotcha" for the behavior of include when using the command line version of php.
I copied all the included files needed for a new version of a program into a temporary directory, so I could run them "off to the side" before they were ready for release into the live area. One of the files with a new version (call it common.inc.php for this example) normally lives in one of the directories in the include path. But I did not want to put the new version there yet! So I copied common.inc.php into my temporary directory along with the others, figuring that the interpreter would find it there before it found it in the include directory, because my include path has a . at the beginning. When I tested it, everything was fine.
But then I setup a cron job to run the script automatically every day. In the crontab I placed the full path of the script. But when it ran, it included the old version of my common.inc.php file out of the include directory. Interestingly, the other include files that only existed in the temporary directory were included fine.
Evidently AFTER the include path is searched, the directory in which the main script lives is searched as well. So my temporary installation almost worked fine, except for the lack of the small change I had made in the common file introduced a bug.
To make it work I use a shell script to start my php script. It contains a cd command into the temporary directory, then starts the php script.
So "current directory" (the . in the include path) for a command line script is really the current directory you are in when executing the script. Whereas it means the directory in which the script lives when executing under apache.
I hope this helps save someone else the hours it took me to figure out my problem!
David
php at mijav dot dk
19-Nov-2003 06:07
The @ directive works with this construct as well. My experience is you can use an if-statement to verify if the script was included (I havn't tested this on remote includes, there might be non-standard-404 pages that makes it impossible to verify you got the right page)
Example:
// ignore the notice and evaluate the return value of the script, if any.
if(@include(dirname(__FILE__)."/foo.php"))
echo "foo.php included";
else
echo "failed to include foo.php";
redeye at cs-aktuell dot de
08-Feb-2003 05:29
As to the security risks of an include statement like:
<?php
include($page);
?>
This is a really bad way on writing an include statement because the user could include server- or password-files which PHP can read as well. You could check the $page variable first but a simple check like
<?php
if ( file_exists($page) ) AND !preg_match("#^\.\./#",$page) )
include($page);
?>
wont make it any safer. ( Think of $page = 'pages/../../../etc/passwd' )
To be sure only pages are called you want the user to call use something like this:
<?php
$path = 'pages/';
$extension = '.php';
if ( preg_match("#^[a-z0-9_]+$#i",$page) ){
$filename = $path.$page.$extension;
include($filename);
}
?>
This will only make sure only files from the directory $path are called if they have the fileextension $extension.
|
require
