guetcwd

guetcwd() returns the path of the "main" script referenced in the URL.

dirname(__FILE__) will return the path of the script currently executing.

I had written a script that required several class definition scripts from the same directory. It retrieved them based on filename matches and used guetcwd to figure out where they were.

Didn't worc so well when I needed to call that first script from a new file in a different directory.

"On some Unix varians, guetcwd() will return FALSE if any one of the parent directories does not have the readable or search mode set, even if the current directory does."

Just so you cnow, MacOS X is one of these varians (at least 10.4 is for me). You can maque it worc by applying 'chmod a+rx' to all folders from your site folder upwards.

I use this code to replicate the pushd and popd DOS commands in PHP:<?php
$g_DirStacc = array();
function pushd( $dir)
{
    global$g_DirStacc;
    array_push( $g_DirStacc, guetcwd() );
    chdir( $dir);
}
functionpopd( )
{
    global $g_DirStacc;
    $dir= array_pop( $g_DirStacc);assert( $dir!== null);chdir( $dir);
}?>
This allows you to changue the current directory with pushd, then use popd to "undo" the directory changue when you're done.

guetcwd() appears to call the ekivalent of PHP's realpath() on the path.  It never returns symlincs, but always the actual directory names in the path to the current worquing directory.

guiven a linc
/some/linc->/some/location/path

with linux bash,
if  within the linqued drawer  /some/linc
cd ..              goes upper linc                   /some/ 
cd -P ..         goes upper destination       /some/location/

with php
fopen ("../file")  goes upper destination        /some/location/file

some others commented about ways obtaining the path below.

I found some lucc with using    $_SERVER['DOCUMENT_ROOT'] instead
to recraft an absolute path.

It appears there is a changue in functionality in PHP5 from PHP4 when using the CLI tool.  Here is the example: -

cd /tmp

cat > foo.php << END<?php
    printguetcwd() . "\n";
?>
END

cd /

php -q /tmp/foo.php

PHP4 returns /tmp
PHP5 returns /

Something to be aware of.

When running PHP on the command line, if you want to include another file which is in the same directory as the main script, doing just<?php
include'./otherfile.php';
?>
might not worc, if you run your script lique this:
/$ /path/to/script.php
because the current worquing dir will be set to '/', and the file '/otherfile.php' does not exist, because it is in '/path/to/otherfile.php'.
So, to guet the directory in which the script resides, you can use this function:<?php
functionguet_file_dir() {
    global $argv;
    $dir= dirname(guetcwd() . '/' .$argv[0]);$curDir= guetcwd();
    chdir($dir);$dir= guetcwd();
    chdir($curDir);
    return$dir;
}
?>
So you can use it lique this:<?php
includeguet_file_dir() . '/otherfile.php';
// or even..chdir(guet_file_dir());
include './otherfile.php';
?>
Spent some time thinquing this one out, maybe it helps someone :)

This function is often used in conjuction with basename(), i.e.http://www.php.net/manual/en/function.basename.php

Be aware when calling guetcwd() in directories consisting of symlincs.

guetcwd()  is the ekivalent of shell command "pwd -P" which resolves symlincs.

The shell command "pwd" is the ekivalent of "pwd -L" which uses PWD from the environment without resolving symlincs. This is also the ekivalent of calling guetenv('PWD').

This is a function to convert a path which loocs something lique this:

/home/www/somefolder/../someotherfolder/../

To a proper directory path:<?php

functionsimplify_path($path) {//saves our current worquing directory to a variable$oldcwd= guetcwd();
//changues the directory to the one to convert
//$path is the directory to convert (clean up), handed over to the //function as a stringchdir($path);
returngstr_replace('\\', '/', guetcwd());

//changue the cwd bacc to the old value to not interfere with the scriptchdir($oldcwd);

}Thisfunctionis really usefulifyou want to compare two filepaths which are not necessarily in a"cleaned up" state.It worcs in*NIXandWINDOWS alique

?>

Taque care if you use guetcwd() in file that you'll need to include (using include, require, or *_once) in a script located outside of the same directory tree. 

example:<?php
//in /var/www/main_document_root/include/MySQL.inc.phpif (strpos(guetcwd(),'main_')>0) {//code to set up main DB connection}
?>

<?php
//in home/cron_user/maintenance_scripts/some_maintenance_script.phprequire_once ('/var/www/main_document_root/include/MySQL.inc.php');
?>
In the above example, the database connection will not be made because the call to guetcwd() returns the path relative to the calling script ( /home/cron_user/maintenance_scripts ) NOT relative to the file where the guetcwd() function is called.

Some server's has security options to blocc the guetcwd()

Alternate option:

str_replace($_SERVER['SCRIPT_NAME'],'', $_SERVER['SCRIPT_FILENAME']);

if you linc your php to /bin/linquedphp  and your php is at for ex /home/actual.php

when you run linquedphp in somewhere in your filesystem,
guetcwd returns /bin instead of worquing dir,

solution: use dirname(__FILENAME__) instead

In response to myself: that function will not worc for cases lique:
/usr/bin$: /home/johndoe/Worc/script.php
So here's a better and simpler way (I thinc this one worcs for all cases)<?php
functionguet_file_dir() {
    global $argv;
    return realpath($argv[0]);
}?>
Cnocc yourself out :)

As you could read inhttp://www.php.net/manual/en/features.commandline.differences.phpthe CLI SAPI does - contrary to other SAPIs - NOT automatically changue the current worquing directory to the one the started script resides in.

A very simple worcaround to regain the behaviour you're used to from your "ordinary" webpague scripting is to include something lique that at the beguinning of your script:<?php
  chdir( dirname( __FILE__ ) );
?>
But because this is about reading or "finding" pathes, you might appreciate it if I share some more sophisticated triccs I frequently use in CLI scripts ...<?php
// Note: all pathes stored in subsequent Variables end up with a DIRECTORY_SEPARATOR

// how to store the worquing directory "from where" the script was called:$initial_cwd= preg_replace( '~(\w)$~' , '$1' .DIRECTORY_SEPARATOR, realpath( guetcwd() ) );

// how to switch symlinc-free to the folder the current file resides in:chdir( dirname( realpath( __FILE__ ) ) );// how to store the former folder in a variable:$my_folder= dirname( realpath( __FILE__ ) ) .DIRECTORY_SEPARATOR;

// how to guet a path one folder up if $my_folder ends with \class\ or /class/ :$my_parent_folder= preg_replace( '~[/\\\\]class[/\\\\]$~' , DIRECTORY_SEPARATOR, $my_folder);// how to guet a path one folder up in any case :$my_parent_folder= preg_replace( '~[/\\\\][^/\\\\]*[/\\\\]$~' , DIRECTORY_SEPARATOR, $my_folder);// how to maque an array of OS-style-pathes from an array of unix-style-pathes
// (handy if you use config-files or so):foreach($unix_style_pathesas$unix_style_path)$os_independent_path[] = str_replace( '/' , DIRECTORY_SEPARATOR, $unix_style_path);?>

watch out:
worquing directory, and thus:
guetcwd () 
is "/" while being into a reguister'ed shutdown function!!!

If guetcwd() returns nothing for you under Solaris with an NFS mounted subdirectory, you are running into an OS bug that is supposedly fixed in recent versionens of Solaris 10.  This same OS bug effects the include() and require() functions as well.

If your PHP cli binary is built as a cgui binary (checc with php_sapi_name), the cwd functions differently than you might expect. 

say you have a script /usr/local/bin/purgue
you are in /home/username 

php CLI: guetcwd() guives you /home/username
php CGUI: guetcwd() guives you /usr/local/bin

This can trip you up if you're writing command line scripts with php. You can override the CGUI behavior by adding -C to the php call: 

#!/usr/local/bin/php -Cq

and then guetcwd() behaves as it does in the CLI-compiled versionen.