/**
  * @param string $file
  */
 private function clean($file)
 {
     if (ftp_size($this->connection, $file) == -1) {
         $result = ftp_nlist($this->connection, $file);
         foreach ($result as $childFile) {
             $this->clean($childFile);
         }
         ftp_rmdir($this->connection, $file);
     } else {
         ftp_delete($this->connection, $file);
     }
 }

function DeleteFile($fichierAsupprimer)
{
    global $ftp;
    // Tente d'effacer le fichier $file
    if (ftp_delete($ftp, $fichierAsupprimer)) {
        echo "{$fichierAsupprimer} effacé avec succès\n";
    } else {
        echo "Impossible d'effacer le fichier {$fichierAsupprimer}\n";
    }
    return 1;
}

function DeleteUpfile($R, $d)
{
    global $g, $table;
    $UPFILES = getArrayString($R['upload']);
    foreach ($UPFILES['data'] as $_val) {
        $U = getUidData($table['s_upload'], $_val);
        if ($U['uid']) {
            if ($U['url'] == $d['comment']['ftp_urlpath']) {
                $FTP_CONNECT = ftp_connect($d['comment']['ftp_host'], $d['comment']['ftp_port']);
                $FTP_CRESULT = ftp_login($FTP_CONNECT, $d['comment']['ftp_user'], $d['comment']['ftp_pass']);
                if ($d['comment']['ftp_pasv']) {
                    ftp_pasv($FTP_CONNECT, true);
                }
                if (!$FTP_CONNECT) {
                    getLink('', '', 'FTP서버 연결에 문제가 발생했습니다.', '');
                }
                if (!$FTP_CRESULT) {
                    getLink('', '', 'FTP서버 아이디나 패스워드가 일치하지 않습니다.', '');
                }
                ftp_delete($FTP_CONNECT, $d['comment']['ftp_folder'] . $U['folder'] . '/' . $U['tmpname']);
                if ($U['type'] == 2) {
                    ftp_delete($FTP_CONNECT, $d['comment']['ftp_folder'] . $U['folder'] . '/' . $U['thumbname']);
                }
                ftp_close($FTP_CONNECT);
            } else {
                unlink($U['url'] . $U['folder'] . '/' . $U['tmpname']);
                if ($U['type'] == 2) {
                    unlink($U['url'] . $U['folder'] . '/' . $U['thumbname']);
                }
            }
            getDbDelete($table['s_upload'], 'uid=' . $U['uid']);
        }
    }
}

 public function del($file)
 {
     if (!$this->connect_id) {
         return false;
     }
     return ftp_delete($this->connect_id, $file);
 }

/**
* Deletes an Attachment
*/
function unlink_attach($filename, $mode = false)
{
    global $upload_dir, $config, $lang;
    $filename = basename($filename);
    if (!intval($config['allow_ftp_upload'])) {
        if ($mode == MODE_THUMBNAIL) {
            $filename = $upload_dir . '/' . THUMB_DIR . '/t_' . $filename;
        } else {
            $filename = $upload_dir . '/' . $filename;
        }
        $deleted = @unlink($filename);
    } else {
        $conn_id = attach_init_ftp($mode);
        if ($mode == MODE_THUMBNAIL) {
            $filename = 't_' . $filename;
        }
        $res = @ftp_delete($conn_id, $filename);
        if (!$res) {
            if (ATTACH_DEBUG) {
                $add = $mode == MODE_THUMBNAIL ? '/' . THUMB_DIR : '';
                message_die(GENERAL_ERROR, sprintf($lang['Ftp_error_delete'], $config['ftp_path'] . $add));
            }
            return $deleted;
        }
        @ftp_quit($conn_id);
        $deleted = true;
    }
    return $deleted;
}

 /**
  * Salva o conteúdo do arquivo no servidor Oracle
  * Caso seja possível salvar o arquivo, será retornado
  * o filename completo de onde o arquivo será armazenado
  * 
  * @param Zend_Db $db
  * @return string
  */
 public function save($db = null)
 {
     if ($db == null) {
         $db = Zend_Registry::get('db.projta');
     }
     if ($this->_content instanceof ZendT_Type_Blob) {
         $sql = "\n                    declare\n                      v_blob BLOB;\n                    begin\n                       insert into tmp_blob(content) values (:content);\n                       select content into v_blob FROM tmp_blob;\n                       arquivo_pkg.write_to_disk(p_data => v_blob,\n                                                 p_file_name => :name,\n                                                 p_path_name => :path);\n                    end;                \n                ";
         @($conn = ftp_connect('192.168.1.251'));
         if (!$conn) {
             throw new ZendT_Exception(error_get_last());
         }
         @($result = ftp_login($conn, 'anonymous', 'anonymous'));
         if (!$result) {
             throw new ZendT_Exception(error_get_last());
         }
         $fileNameServer = 'pub/temp/' . $this->_name;
         @ftp_delete($conn, $fileNameServer);
         @($result = ftp_put($conn, $fileNameServer, $this->_fileName, FTP_BINARY));
         if (!$result) {
             throw new ZendT_Exception(error_get_last() . ". Name Server: {$fileNameServer} || Name Local: {$this->_fileName}");
         }
         @($result = ftp_close($conn));
     } else {
         $sql = "\n                    begin\n                    arquivo_pkg.write_to_disk(p_data => :content,\n                                              p_file_name => :name,\n                                              p_path_name => :path);\n                    end;                \n                ";
         $stmt = $db->prepare($sql);
         $stmt->bindValue(':content', $this->_content);
         $stmt->bindValue(':name', $this->_name);
         $stmt->bindValue(':path', $this->_path);
         $stmt->execute();
     }
     $filename = $this->_path . '/' . $this->_name;
     return $filename;
 }

 public function FTPDelete($file)
 {
     if (!@ftp_delete($this->connection, $file)) {
         require_once 'Newstool/FTP/Exception.php';
         throw new Newstool_FTP_Exception('Could not delete the file');
     }
 }

 function del_file($path)
 {
     $this->off = @ftp_delete($this->conn_id, $path);
     if (!$this->off) {
         echo "文件删除失败，请检查权限及路径是否正确！";
     }
 }

 public function delete($strPath)
 {
     if (stristr($strPath, "*") === false) {
         //*** Regular FTP delete.
         try {
             @ftp_delete($this->objFTP, $strPath);
         } catch (Exception $e) {
             echo $e->getMessage();
         }
     } else {
         //*** Wildcard delete.
         $strBasePath = dirname($strPath);
         $strFileName = basename($strPath);
         //*** Get files in remote folder.
         $arrFiles = $this->nlist($strBasePath);
         if ($arrFiles !== false) {
             foreach ($arrFiles as $strFile) {
                 $strBaseFile = basename($strFile);
                 if (!$this->is_dir($strFile) && $this->hasWildcard($strFileName, $strBaseFile)) {
                     @ftp_delete($this->objFTP, $strBasePath . "/" . $strBaseFile);
                 }
             }
         }
     }
 }

 function mdelete($path)
 {
     if (!$this->conn_id) {
         return false;
     }
     return @ftp_delete($this->conn_id, $path);
 }

 function delete($filename)
 {
     if (!@ftp_delete($this->ftp_conn, $filename)) {
         $this->error[] = "Could not delete {$filename}";
         return false;
     }
     return true;
 }

 function remove($ident)
 {
     $conn_id = ftp_connect(__FTP_SERVER__);
     $login_result = ftp_login($conn_id, __FTP_UNAME__, __FTP_PASSWD__);
     $ret = ftp_delete($conn_id, __FTP_DIR__ . "/" . $ident);
     ftp_close($conn_id);
     return $ret;
 }

 protected function ftpDelete($path)
 {
     $result;
     $conn_id = ftp_connect(FTP_SERVER);
     $login_result = ftp_login($conn_id, FTP_USER_NAME, FTP_USER_PASS);
     $result = ftp_delete($conn_id, $path);
     ftp_close($conn_id);
     return $result;
 }

 protected function deleteFiles($files)
 {
     foreach ($files as $file) {
         $success = ftp_delete($this->connection, $file);
         if (!$success) {
             throw new \Exception('Could not delete file from ftp: ' . $file);
         }
     }
 }

function deleteimg($img)
{
    $imgd = $img;
    $conn = ftp_connect("localhost");
    ftp_login($conn, "root", "sandy");
    ftp_chdir($conn, "dj/images");
    echo ftp_delete($conn, "{$imgd}.jpg");
    ftp_close($conn);
}

 static function ftp_image_delete_file($sourceFileName)
 {
     if (self::ftp_image_connect()) {
         if (@ftp_delete(ImageLib::$ftp_image_connect_id, $sourceFileName)) {
             return true;
         }
     }
     return false;
 }

 public function limitbackup()
 {
     $fileList = $this->getBackupTimeList();
     $connection = $this->getConnection();
     for ($index = 0; count($fileList) > $this->limit - 1; ++$index) {
         $fileName = Vtiger_BackupZip::getDefaultFileName($fileList[$index]);
         @ftp_delete($connection, $fileName);
         unset($fileList[$index]);
     }
 }

 public function delete($file)
 {
     if (ftp_size($this->connection, $file) != -1) {
         $delete = ftp_delete($this->connection, $file);
         if ($delete) {
         } else {
         }
     }
     return $this;
 }

/**
 * Recursively delete the files in a directory via FTP.
 *
 * @author      Aidan Lister <[email protected]>
 * @version     1.0.0
 * @link        http://aidanlister.com/2004/04/recursively-deleting-directories-via-ftp/ 
 * @param       resource $ftp_stream   The link identifier of the FTP connection
 * @param       string   $directory    The directory to delete
 */
function ftp_rmdirr($ftp_stream, $directory)
{
    // Sanity check
    if (!is_resource($ftp_stream) || get_resource_type($ftp_stream) !== 'FTP Buffer') {
        return false;
    }
    // Init
    $i = 0;
    $files = array();
    $folders = array();
    $statusnext = false;
    $currentfolder = $directory;
    // Get raw file listing
    $list = ftp_rawlist($ftp_stream, $directory, true);
    // Iterate listing
    foreach ($list as $current) {
        // An empty element means the next element will be the new folder
        if (empty($current)) {
            $statusnext = true;
            continue;
        }
        // Save the current folder
        if ($statusnext === true) {
            $currentfolder = substr($current, 0, -1);
            $statusnext = false;
            continue;
        }
        // Split the data into chunks
        $split = preg_split('[ ]', $current, 9, PREG_SPLIT_NO_EMPTY);
        $entry = $split[8];
        $isdir = $split[0][0] === 'd' ? true : false;
        // Skip pointers
        if ($entry === '.' || $entry === '..') {
            continue;
        }
        // Build the file and folder list
        if ($isdir === true) {
            $folders[] = $currentfolder . '/' . $entry;
        } else {
            $files[] = $currentfolder . '/' . $entry;
        }
    }
    // Delete all the files
    foreach ($files as $file) {
        ftp_delete($ftp_stream, $file);
    }
    // Delete all the directories
    // Reverse sort the folders so the deepest directories are unset first
    rsort($folders);
    foreach ($folders as $folder) {
        ftp_rmdir($ftp_stream, $folder);
    }
    // Delete the final folder and return its status
    return ftp_rmdir($ftp_stream, $directory);
}

 public function delete($file_path)
 {
     $result = ftp_delete($this->_connection_id, $file_path);
     if ($result) {
         return true;
     } else {
         $log = new \Kiva\Silverpop_Connector\Logger();
         $log->error("Failed to remove {$file_path} from FTP.");
         return false;
     }
 }