Delicious Bookmark this on Delicious Share on Facebook SlashdotSlashdot It! Digg! Digg

PHP : Function Reference : FTP Functions

FTP Functions


The functions in this extension implement client access to file servers speaking the File Transfer Protocol (FTP) as defined in » This extension is meant for detailed access to an FTP server providing a wide range of control to the executing script. If you only wish to read from or write to a file on an FTP server, consider using the ftp:// wrapper with the filesystem functions which provide a simpler and more intuitive interface.


No external libraries are needed to build this extension.


In order to use FTP functions with your PHP configuration, you should add the --enable-ftp option when installing PHP 4 or greater or --with-ftp when using PHP 3.

The windows version of PHP has built in support for this extension. You do not need to load any additional extension in order to use these functions.

Runtime Configuration

This extension has no configuration directives defined in php.ini.

Resource Types

This extension uses one resource type, which is the link identifier of the FTP connection, returned by ftp_connect() or ftp_ssl_connect().

Predefined Constants

The constants below are defined by this extension, and will only be available when the extension has either been compiled into PHP or dynamically loaded at runtime.

FTP_ASCII (integer)
FTP_TEXT (integer)
FTP_BINARY (integer)
FTP_IMAGE (integer)

See ftp_set_option() for information.

The following constants were introduced in PHP 4.3.0.

FTP_AUTOSEEK (integer)

See ftp_set_option() for information.


Automatically determine resume position and start position for GET and PUT requests (only works if FTP_AUTOSEEK is enabled)

FTP_FAILED (integer)

Asynchronous transfer has failed

FTP_FINISHED (integer)

Asynchronous transfer has finished

FTP_MOREDATA (integer)

Asynchronous transfer is still active


Example 715. FTP example

// set up basic connection
$conn_id = ftp_connect($ftp_server);

// login with username and password
$login_result = ftp_login($conn_id, $ftp_user_name, $ftp_user_pass);

// check connection
if ((!$conn_id) || (!$login_result)) {
"FTP connection has failed!";
"Attempted to connect to $ftp_server for user $ftp_user_name";
   } else {
"Connected to $ftp_server, for user $ftp_user_name";

// upload the file
$upload = ftp_put($conn_id, $destination_file, $source_file, FTP_BINARY);

// check upload status
if (!$upload) {
"FTP upload has failed!";
   } else {
"Uploaded $source_file to $ftp_server as $destination_file";

// close the FTP stream

Table of Contents

ftp_alloc — Allocates space for a file to be uploaded
ftp_cdup — Changes to the parent directory
ftp_chdir — Changes the current directory on a FTP server
ftp_chmod — Set permissions on a file via FTP
ftp_close — Closes an FTP connection
ftp_connect — Opens an FTP connection
ftp_delete — Deletes a file on the FTP server
ftp_exec — Requests execution of a command on the FTP server
ftp_fget — Downloads a file from the FTP server and saves to an open file
ftp_fput — Uploads from an open file to the FTP server
ftp_get_option — Retrieves various runtime behaviours of the current FTP stream
ftp_get — Downloads a file from the FTP server
ftp_login — Logs in to an FTP connection
ftp_mdtm — Returns the last modified time of the given file
ftp_mkdir — Creates a directory
ftp_nb_continue — Continues retrieving/sending a file (non-blocking)
ftp_nb_fget — Retrieves a file from the FTP server and writes it to an open file (non-blocking)
ftp_nb_fput — Stores a file from an open file to the FTP server (non-blocking)
ftp_nb_get — Retrieves a file from the FTP server and writes it to a local file (non-blocking)
ftp_nb_put — Stores a file on the FTP server (non-blocking)
ftp_nlist — Returns a list of files in the given directory
ftp_pasv — Turns passive mode on or off
ftp_put — Uploads a file to the FTP server
ftp_pwd — Returns the current directory name
ftp_quit — Alias of ftp_close()
ftp_raw — Sends an arbitrary command to an FTP server
ftp_rawlist — Returns a detailed list of files in the given directory
ftp_rename — Renames a file or a directory on the FTP server
ftp_rmdir — Removes a directory
ftp_set_option — Set miscellaneous runtime FTP options
ftp_site — Sends a SITE command to the server
ftp_size — Returns the size of the given file
ftp_ssl_connect — Opens an Secure SSL-FTP connection
ftp_systype — Returns the system type identifier of the remote FTP server

Code Examples / Notes » ref.ftp

dot a dot@dot dot com

This took me a few hours to work out. It is based on the code below I've just added a string replace to convert pathname given by Windows to Unix pathname. Hope it saves somebody some time. Enjoy! (Also, delete file function is included:))
$myFile = $_FILES['file']; // This will make an array out of the file information that was stored.
$file = $myFile['tmp_name'];  //Converts the array into a new string containing the path name on the server where your file is.
$myFileName = $_POST['MyFile']; //Retrieve file path and file name
$myfile_replace = str_replace('\\', '/', $myFileName); //convert path for use with unix
$myfile = basename($myfile_replace); //extract file name from path
$destination_file = "/".$myfile;  //where you want to throw the file on the webserver (relative to your login dir)
// connection settings
$ftp_server = "";  //address of ftp server (leave out ftp://)
$ftp_user_name = ""; // Username
$ftp_user_pass = "";   // Password
$conn_id = ftp_connect($ftp_server);        // set up basic connection
// login with username and password, or give invalid user message
$login_result = ftp_login($conn_id, $ftp_user_name, $ftp_user_pass) or die("<h1>You do not have access to this ftp server!</h1>");
$upload = ftp_put($conn_id, $destination_file, $file, FTP_BINARY);  // upload the file
if (!$upload) {  // check upload status
echo "<h2>FTP upload of $myFileName has failed!</h2> <br />";
// try to delete $file
if (ftp_delete($conn_id, $destination_file)) {
echo "$destination_file has been deleted!\n";
} else {
echo "Could not delete $destination_file!\n";
ftp_close($conn_id); // close the FTP stream
<form name="form" enctype="multipart/form-data" action="<?php echo $_SERVER['PHP_SELF']; ?>" method="POST" >
Please choose a file: <input type="file" name="file" accept="text/plain" onChange="MyFile.value=file.value">
<input name="MyFile" type="hidden" id="MyFile" tabindex="99" size="1" />
<input type="submit" name="submit" value="upload" style="vertical-align:middle"/><br/><br/>


This is a simple script writen by me which allows the user
run it in console and get tree from FTP Server.
$argv = $_SERVER["argv"];
$argv = array_slice($argv,1);
if (getenv("HTTP_HOST")) {exit("For bash execution only!");}
if ((empty($argv[0])) || (empty($argv[1]))) {exit("Usage: thisscript.php /games/Arcade/
where is the FTP Server and /games/Arcade is the start path on FTP\n");}
// connect to the ftp server
$connect_id = ftp_connect($argv[0]);
// login on the server
if ($connect_id) { $login_result = ftp_login($connect_id, 'anonymous', 'JustForFun'); }
// check connection
if ((!$connect_id) || (!$login_result)) {
  echo "Unable to connect the remote FTP Server!\n";
function ftp_get_dir ($ftp_dir) {
global $connect_id;
$ftp_contents = ftp_nlist ($connect_id, $ftp_dir);
for ($myCounter_for_server_elements = 0; !empty ($ftp_contents[$myCounter_for_server_elements]);
// get elements list in current dir
echo $argv[0] . $ftp_dir . $ftp_contents[$myCounter_for_server_elements] . "\n";
ftp_get_dir ($ftp_dir . $ftp_contents[$myCounter_for_server_elements] . '/');
ftp_get_dir ($argv[1]);
// close connection


It may seem obvious to others, but it had me stumped for nearly an hour! If you can connect to an ftp site but some functions (list, put, get etc) don't work, then try using ftp_pasv and set passive mode on.
// setup $host and $file variables for your setup before here...
$hostip = gethostbyname($host);
$conn_id = ftp_connect($hostip);
// login with username and password
$login_result = ftp_login($conn_id, $ftp_user_name, $ftp_user_pass);
// IMPORTANT!!! turn passive mode on
ftp_pasv ( $conn_id, true );
if ((!$conn_id) || (!$login_result)) {
 echo "FTP connection has failed!";
 echo "Attempted to connect to $host for user $ftp_user_name";
} else {
 echo "Connected to $host, for user $ftp_user_name
 echo "Host IP is $hostip
 // upload a file
 if (ftp_put($conn_id, $remote_file, $file, FTP_ASCII)) {
   echo "successfully uploaded $file
 } else {
   echo "There was a problem while uploading $file

 // close the connection


If you prefer a OO-approach to the FTP-functions, you can use this snippet of code (PHP5 only! and does add some overhead). It's just a "start-up", extend/improve as you wish...
You can pass all ftp_* functions to your object and stripping ftp_ of the function name. Plus, you don't have to pass the ftp-resource as the first argument.
For example:
ftp_delete($ftp, $file); // Where $ftp is your ftp-resource
Can become:
$ftp->delete($file); // Where $ftp is your FTP-object
class FTP {
private $ftp;

/* public Void __construct(): Constructor */
public function __construct($host, $port = 21, $timeout = 90) {
$this->ftp = ftp_connect($host, $port, $timeout);

/* public Void __destruct(): Destructor */
public function __destruct() {
/* public Mixed __call(): Re-route all function calls to the PHP-functions */
public function __call($function, $arguments) {
// Prepend the ftp resource to the arguments array
array_unshift($arguments, $this->ftp);

// Call the PHP function
return call_user_func_array('ftp_' . $function, $arguments);



I think what some other posts were trying to say which may need clarification is that in PHP 4.2.3, ftp_connect("") was failing most of the time, except it would work like every few minutes.
The fix is that ftp_connect seems to have a bug resolving addresses. If you do:
$hostip = gethostbyname($host);
$conn_id = ftp_connect($hostip);
It seems to solve the problem.
(Other users referred to an ftpbuf() error... not sure what that is, but this should fix it.)


I have written an OpenSource ZIP2FTP interface, which actually takes a given ZIP file and decompresses it in the folder on an FTP server you specify...
Therefore it may be quite interesting for you people interested in FTP, its adress is ; those who directly want the source may visit


I had some major problems running ftp_connect from my Web Browser and not from the CLI from 1 server and yet from another Internal server I had no trouble at all. After a few hours I figured out this was because SELINUX was enabled on one server and DISABLED on the server that it worked on.
So in short, if you are having trouble with connecting in your Web Browser make sure you have HTTPD connect's enabled in it like so at the command prompt:
; Turns it on temporarily.
/usr/sbin/setsebool httpd_can_network_connect=1
; Turns it on Permenantly
/usr/sbin/setsebool -P httpd_can_network_connect=1
I hope this helps make someones life a little easier. :)
(I actually found this fix on the fopen manual page).


I fixed the below upload script to work with Windows uploads (and updated some of the syntax). I also added a Javascript "progress indicator" for those of us who don't use PHP 5.2
if(isset($_POST['start_upload']) && $_FILES['txt_file']['name'] != ""){

$local_file = $_FILES['txt_file']['tmp_name']; // Defines Name of Local File to be Uploaded
$destination_file = "/".basename($_FILES['txt_file']['name']);  // Path for File Upload (relative to your login dir)
// Global Connection Settings
$ftp_server = "";   // FTP Server Address (exlucde ftp://)
$ftp_user_name = "username"; // FTP Server Username
$ftp_user_pass = "password";   // Password
// Connect to FTP Server
$conn_id = ftp_connect($ftp_server);
// Login to FTP Server
$login_result = ftp_login($conn_id, $ftp_user_name, $ftp_user_pass);

// Verify Log In Status
if ((!$conn_id) || (!$login_result)) {
echo "FTP connection has failed! <br />";
echo "Attempted to connect to $ftp_server for user $ftp_user_name";
} else {
echo "Connected to $ftp_server, for user $ftp_user_name <br />";
$upload = ftp_put($conn_id, $destination_file, $local_file, FTP_BINARY);  // Upload the File

// Verify Upload Status
if (!$upload) {
echo "<h2>FTP upload of ".$_FILES['txt_file']['name']." has failed!</h2><br /><br />";
} else {
echo "Success!<br />" . $_FILES['txt_file']['name'] . " has been uploaded to " . $ftp_server . $destination_file . "!<br /><br />";
ftp_close($conn_id); // Close the FTP Connection
<script type="text/javascript">
window.onload = function() {
document.getElementById("progress").style.visibility = "hidden";
document.getElementById("prog_text").style.visibility = "hidden";

function dispProgress() {
document.getElementById("progress").style.visibility = "visible";
document.getElementById("prog_text").style.visibility = "visible";


<form action="<?php echo $_SERVER['PHP_SELF'];?>" method="POST" enctype="multipart/form-data">
Please choose a file: <input name="txt_file" type="file" size="35" />
<input type="submit" name="start_upload" value="Upload File" onClick="dispProgress()" />

<!-- Link to progress file: see for animated gifs -->
<img id="progress" src="" />
<p id="prog_text" style="display:inline;"> Upload Started!



I didn't quite like my FTP program since I had to make all the settings all over when i restarted the client, so I made this script for simple ftp uploading, its running as a CLI app.
//if STDIN isn't defined, define it
if (!defined("STDIN"))

define("STDIN", fopen("php://stdin", "r"));


echo "FTP file uploader\r\n\r\n";
echo "Server: ";
//trim() all the fgets cause it seams to add a \n
$server = trim(fgets(STDIN));

echo "Username: ";

$username = trim(fgets(STDIN));

echo "Password: ";

$password = trim(fgets(STDIN));

$connect = ftp_connect($server);
$login = ftp_login($connect, $username, $password);

if ((!$connect) || (!$login))

exit("Login failed.\r\n");


echo "Connected\r\n";
echo "PASV (Y/Any key = Off): ";

if(trim(fgets(STDIN)) == "Y")
//enable passive mode
ftp_pasv($connect, true);

echo "PASV: On\r\n";


echo "PASV: Off\r\n";
$showContent = ftp_nlist($connect, "");

echo "Listing Contents:\r\n";

echo "File to upload: ";

$file = trim(fgets(STDIN));

//escape the uploading process by typing "exit;"
if ($file == "exit;")



//use "$file, $file" since the file shouldn't be renamed, also if its a binary file change the last argument to FTP_BINARY
$upload = ftp_put($connect, $file, $file, FTP_ASCII);

if (!$upload)

exit("Upload failed.\r\n");


echo "The file \"" . $file . "\" was successfully uploaded. :)\r\nSize of \"" . $file . "\": " . filesize($file) / 1024 ."kb.\r\n";
echo "My work is done, bye.\r\n";




Here's another FTP interface over PHP (also uses MySQL)
PS: this script will ALSO allow you to download its source... So it becomes interesting for YOU PROGRAMMERS as well :D

kristy christie kristy

Here's a little function that I created to recurse through a local directory and upload the entire contents to a remote FTP server.
In the example, I'm trying to copy the entire "iwm" directory located at /home/kristy/scripts/iwm to a remote server's /public_html/test/ via FTP.
The only trouble is that for the line "if (!ftp_chdir($ftpc,$ftproot.$srcrela))", which I use to check if the directory already exists on the remote server, spits out a warning about being unable to change to that directory if it doesn't exist.
But an error handler should take care of it.
My thanks to the person who posted the snippet on retrieving the list of files in a directory.
For the version of the script that echo's it's progress as it recurses & uploads, go to:
// --------------------------------------------------------------------
// --------------------------------------------------------------------
// set the various variables
$ftproot = "/public_html/test/";
$srcroot = "/home/kristy/scripts/";
$srcrela = "iwm/";
// connect to the destination FTP & enter appropriate directories both locally and remotely
$ftpc = ftp_connect("");
$ftpr = ftp_login($ftpc,"username","password");
if ((!$ftpc) || (!$ftpr)) { echo "FTP connection not established!"; die(); }
if (!chdir($srcroot)) { echo "Could not enter local source root directory."; die(); }
if (!ftp_chdir($ftpc,$ftproot)) { echo "Could not enter FTP root directory."; die(); }
// start ftp'ing over the directory recursively
ftpRec ($srcrela);
// close the FTP connection
// --------------------------------------------------------------------
// --------------------------------------------------------------------
function ftpRec ($srcrela)
global $srcroot;
global $ftproot;
global $ftpc;
global $ftpr;

// enter the local directory to be recursed through

// check if the directory exists & change to it on the destination
if (!ftp_chdir($ftpc,$ftproot.$srcrela))
// remote directory doesn't exist so create & enter it
  ftp_mkdir ($ftpc,$ftproot.$srcrela);
  ftp_chdir ($ftpc,$ftproot.$srcrela);
if ($handle = opendir("."))
  while (false !== ($fil = readdir($handle)))
      if ($fil != "." && $fil != "..")
      // check if it's a file or directory
      if (!is_dir($fil))
      // it's a file so upload it
      ftp_put($ftpc, $ftproot.$srcrela.$fil, $fil, FTP_BINARY);
// it's a directory so recurse through it
if ($fil == "templates")
// I want the script to ignore any directories named "templates"
// and therefore, not recurse through them and upload their contents
ftpRec ($srcrela.$fil."/");
chdir ("../");


Here is an example for downloading a remote ftp structure to local server, useful for migrating sites from one server to another, especially when you are upgrading ensim ;)


connection to a ftp server across proxy
$ftp_server = "proxy"; f.e. 123.456.789.10
$ftp_user_name = "username@ftpserver"; f.e.
$ftp_user_pass = "password";
$conn_id = ftp_connect($ftp_server, 2121);
$login_result = ftp_login( $conn_id, $ftp_user_name, $ftp_user_pass );

arjenjb dot wanadoo dot nl

Check for a FTP server written in PHP.
Supports Passive and Active FTP, and all other standard FTP commands as decribed in RFC959.


After looking everywhere for a "FULLY WORKING" ftp uploader script, I finally came up with this, by using a lot of various one’s I found on the web. If you find a better way of doing something, please let me know. Thanks, and Enjoy
     $myFile = $_FILES['txt_file']; // This will make an array out of the file information that was stored.
     $file = $myFile['tmp_name'];  //Converts the array into a new string containing the path name on the server where your file is.

     $myFileName = basename($_POST['txt_fileName']); //Retrieve filename out of file path
     $destination_file = "/".$myFileName;  //where you want to throw the file on the webserver (relative to your login dir)
     // connection settings
     $ftp_server = "";  //address of ftp server.
     $ftp_user_name = "Your UserName"; // Username
     $ftp_user_pass = "Your Password";   // Password
     $conn_id = ftp_connect($ftp_server);        // set up basic connection
     $login_result = ftp_login($conn_id, $ftp_user_name, $ftp_user_pass) or die("<h2>You do not have access to this ftp server!</h2>");   // login with username and password, or give invalid user message
     if ((!$conn_id) || (!$login_result)) {  // check connection
            // wont ever hit this, b/c of the die call on ftp_login
            echo "FTP connection has failed! <br />";
            echo "Attempted to connect to $ftp_server for user $ftp_user_name";
        } else {
        //    echo "Connected to $ftp_server, for user $ftp_user_name <br />";
     $upload = ftp_put($conn_id, $destination_file, $file, FTP_BINARY);  // upload the file
     if (!$upload) {  // check upload status
        echo "<h2>FTP upload of $myFileName has failed!</h2> <br />";
     } else {
        echo "Uploading $myFileName Complete!<br /><br />";
     ftp_close($conn_id); // close the FTP stream
       <form enctype="multipart/form-data" action="<?php echo $_SERVER['PHP_SELF'];?>" method="POST">
           Please choose a file: <input name="txt_file" type="file" id="txt_file" tabindex="1" size="35" onChange="txt_fileName.value=txt_file.value" />
           <input name="txt_fileName" type="hidden" id="txt_fileName" tabindex="99" size="1" />
           <input type="submit" name="SubmitFile" value="Upload File" accesskey="ENTER" tabindex="2" />

ras "at" fyn {dot} dk

A function to get a remote file and return it's contents, instead of saving to a local file, was missing - here it is:
function ftp_fetch($ftp_stream, $remote_file) {
$out = fopen('php://output', 'w');
if (!ftp_fget($ftp_stream, $out, $remote_file, FTP_ASCII)) die('Unable to get file: ' . $remote_file);
$data = ob_get_clean();
return $data;
It works the same as ftp_get(), but instead returns the contents of the remote file - for example:
$ftp = ftp_connect('', 21, 60);
ftp_login($ftp, 'username', 'password');
$data = ftp_fetch($ftp, 'path/to/remote.file');
echo $data;
Note, I use it to fetch text-files from a server - if you need to fetch binary files, change FTP_ASCII to FTP_BINARY .. but most likely, getting files to memory is only useful for smaller files, e.g. plain text, xml, etc.

vikrant korde
//If you want to move or replicate the folder hierarchy from your current server to another remote server. Then this will be helpful as this will browse the current server's directory and at the same time it will copy that file in the remote server in the same directory.
//This script will copy all the files from this directory and subdirectory to another remote server via FTP
function rec_copy ($source_path, $destination_path, $con)
ftp_mkdir($con, $destination_path);
ftp_site($con, 'CHMOD 0777 '.$destination_path);
if (is_dir($source_path))
while (($file = readdir($handle))!==false)
if (($file != ".") && ($file != ".."))
if (is_dir($file))
// here i am restricting the folder name 'propertyimages' from being copied to remote server. -- VK
if($file != "propertyimages")
rec_copy ($source_path."/".$file, $file, $con);
if (is_file($file))
$fp = fopen($file,"r");
// this will convert spaces to '_' so that it will not throw error.  -- VK
ftp_fput ($con, str_replace(" ", "_", $file), $fp,FTP_BINARY);
ftp_site($con, 'CHMOD 0755 '.str_replace(" ", "_", $file));
// make a FTP connection --VK
$con = ftp_connect("",21);
$login_result = ftp_login($con,"username","password");
// this is the root path for the remote server-- VK
$rootpath = "mainwebsite_html";
// this is the physical path of the source directory. actually u can also use the relative path. -- VK
$sourcepath = realpath("../")."/resdesk";
// this directory name will only change the top most directory and not the inner one -- VK
$destination_dir_name = "resdesk_".$account_id."/";
rec_copy ($sourcepath, $destination_dir_name, $con);
if (function_exists("ftp_close"))

Change Language

Follow Navioo On Twitter
.NET Functions
Apache-specific Functions
Alternative PHP Cache
Advanced PHP debugger
Array Functions
Aspell functions [deprecated]
BBCode Functions
BCMath Arbitrary Precision Mathematics Functions
PHP bytecode Compiler
Bzip2 Compression Functions
Calendar Functions
CCVS API Functions [deprecated]
Class/Object Functions
Classkit Functions
ClibPDF Functions [deprecated]
COM and .Net (Windows)
Crack Functions
Character Type Functions
Cybercash Payment Functions
Credit Mutuel CyberMUT functions
Cyrus IMAP administration Functions
Date and Time Functions
DB++ Functions
Database (dbm-style) Abstraction Layer Functions
dBase Functions
DBM Functions [deprecated]
dbx Functions
Direct IO Functions
Directory Functions
DOM Functions
DOM XML Functions
enchant Functions
Error Handling and Logging Functions
Exif Functions
Expect Functions
File Alteration Monitor Functions
Forms Data Format Functions
Fileinfo Functions
filePro Functions
Filesystem Functions
Filter Functions
Firebird/InterBase Functions
Firebird/Interbase Functions (PDO_FIREBIRD)
FriBiDi Functions
FrontBase Functions
FTP Functions
Function Handling Functions
GeoIP Functions
Gettext Functions
GMP Functions
gnupg Functions
Haru PDF Functions
hash Functions
Hyperwave Functions
Hyperwave API Functions
i18n Functions
IBM Functions (PDO_IBM)
iconv Functions
ID3 Functions
IIS Administration Functions
Image Functions
Imagick Image Library
Informix Functions
Informix Functions (PDO_INFORMIX)
Ingres II Functions
IRC Gateway Functions
PHP / Java Integration
JSON Functions
LDAP Functions
libxml Functions
Lotus Notes Functions
LZF Functions
Mail Functions
Mailparse Functions
Mathematical Functions
MaxDB PHP Extension
MCAL Functions
Mcrypt Encryption Functions
MCVE (Monetra) Payment Functions
Memcache Functions
Mhash Functions
Mimetype Functions
Ming functions for Flash
Miscellaneous Functions
mnoGoSearch Functions
Microsoft SQL Server Functions
Microsoft SQL Server and Sybase Functions (PDO_DBLIB)
Mohawk Software Session Handler Functions
mSQL Functions
Multibyte String Functions
muscat Functions
MySQL Functions
MySQL Functions (PDO_MYSQL)
MySQL Improved Extension
Ncurses Terminal Screen Control Functions
Network Functions
Newt Functions
NSAPI-specific Functions
Object Aggregation/Composition Functions
Object property and method call overloading
Oracle Functions
ODBC Functions (Unified)
ODBC and DB2 Functions (PDO_ODBC)
OpenAL Audio Bindings
OpenSSL Functions
Oracle Functions [deprecated]
Oracle Functions (PDO_OCI)
Output Control Functions
Ovrimos SQL Functions
Paradox File Access
Parsekit Functions
Process Control Functions
Regular Expression Functions (Perl-Compatible)
PDF Functions
PDO Functions
Phar archive stream and classes
PHP Options&Information
POSIX Functions
Regular Expression Functions (POSIX Extended)
PostgreSQL Functions
PostgreSQL Functions (PDO_PGSQL)
Printer Functions
Program Execution Functions
PostScript document creation
Pspell Functions
qtdom Functions
Rar Functions
GNU Readline
GNU Recode Functions
RPM Header Reading Functions
runkit Functions
SAM - Simple Asynchronous Messaging
Satellite CORBA client extension [deprecated]
SCA Functions
SDO Functions
SDO XML Data Access Service Functions
SDO Relational Data Access Service Functions
SESAM Database Functions
PostgreSQL Session Save Handler
Session Handling Functions
Shared Memory Functions
SimpleXML functions
SNMP Functions
SOAP Functions
Socket Functions
Standard PHP Library (SPL) Functions
SQLite Functions
SQLite Functions (PDO_SQLITE)
Secure Shell2 Functions
Statistics Functions
Stream Functions
String Functions
Subversion Functions
Shockwave Flash Functions
Swish Functions
Sybase Functions
TCP Wrappers Functions
Tidy Functions
Tokenizer Functions
Unicode Functions
URL Functions
Variable Handling Functions
Verisign Payflow Pro Functions
vpopmail Functions
W32api Functions
WDDX Functions
win32ps Functions
win32service Functions
xattr Functions
xdiff Functions
XML Parser Functions
XML-RPC Functions
XMLReader functions
XMLWriter Functions
XSL functions
XSLT Functions
YAZ Functions
YP/NIS Functions
Zip File Functions
Zlib Compression Functions
eXTReMe Tracker