The Web Application Installer Beta is designed to help get you up and running with the most widely used Web Applications freely available for your Windows Server. Web AI provides support for popular ASP.Net and PHP Web applications including Graffiti, DotNetNuke, WordPress, Drupal, OSCommerce and more. With just a few simple clicks, Web AI will check your machine for the necessary pre-requisites, download these applications from their source location in the community, walk you through basic configuration items and then install them on your computer.

Full Story

phpmetablog.com is a blog spot where you can find php source php code source code php scripts php tips php news php technologies php help php job.

PHP Source Code – Meta Blog of Blogs

This class is a wrapper around the ffmpeg program to manipulate and convert video files.

Currently it can perform several types of manipulation operations that include video format conversion, extract video frames into separate image files and assemble a video stream from a set of separate video images.

Several parameters can also be configured like the output video file format (which can be Flash video or any other supported by ffmpeg), video and audio bit rate and sample rate, video dimensions and aspect ratio.

Added files

1. Name: ffmpeg.example8.php
Role: Example script
Description: An example script
2. Name: adapters/videoto.php
Role: Auxiliary script
Description: Simple video conversions class

Changed files

1. Name: CHANGELOG
Role: Documentation
Description: Changlog
Changes: Added version 0.1.0
2. Name: ffmpeg.php
Role: Class source
Description: Main Class File

Changes:

[0.1.0] [02.03.2008]
- ADDED new constant ffmpeg::SIZE_SAS. Which stands for Same As Source,
meaning ffmpeg will automatically convert the movie to a whatever format
but preserve the size of the original movie.
- CORRECTED error/comment spelling mistakes.
- CHANGED ffmpeg::getFileInfo(); to use preg_match so it’s more reliable,
it also contains more information on the file.
- ADDED public function setVideoAspectRatio. Sets the video aspect ratio.
Takes one of three constants as an argument. ffmpeg::RATIO_STANDARD,
ffmpeg::RATIO_WIDE, ffmpeg::RATIO_CINEMATIC
- ADDED public function setVideoBitRate. Sets the video bitrate.
- ADDED public function setVideoFormat. Sets a video codec. It should not
be confused with ffmpeg::setFormat. It provides slightly different
advanced functionality, most simple usage can just use ffmpeg::setFormat.
- ADDED public function setAudioFormat. Sets an audio codec.
- ADDED public function setConstantQuality. Sets a constant encoding
quality.
- ADDED public function getFFmpegInfo. Gets the available data from ffmpeg
and stores the output in ffmpeg::$ffmpeg_info (below).
- ADDED ffmpeg::$ffmpeg_info static var to hold the output of
ffmpeg::getFFmpegInfo();
- ADDED public function getLastProcessTime and getProcessTime to retrieve
the processing times of the ffmpeg calls.
- ADDED adapter classes to provide simple functionality for ffmpeg newbies
/ quick solutions. Each option set can be supplied in the second argument
as part of an array.
VideoTo::PSP(); – Converts video into the PSP mp4 video.
VideoTo::iPod(); – Converts video into the iPod mp4 video.
VideoTo::FLV(); – Converts video into the Flash video (flv).
VideoTo::Gif(); – Converts video into the animated gif.
(experimental as quality is poor)
- CHANGED the way the processing works. The file is processed to the
temp directory and is then checked for consistency before moving to
the output directory.
- CHANGED the return values of ffmpeg::execute(); It no longer returns
just true or false. See class docs for more info.
- CHANGED the third argument in ffmpeg::setOutput() from $overwrite to
$overwrite_mode. Instead of a boolean value, it now takes one of three
constants
ffmegp::OVERWRITE_FAIL – means that if a conflict exists the
process will result in and error.
ffmegp::OVERWRITE_PRESERVE – means that if a conflict exists the
process will preserve the existing
file and report with
ffmpeg::RESULT_OK_BUT_UNWRITABLE.
ffmegp::OVERWRITE_EXISTING – means that if a conflict exists the
process will overwrite any existing
file with the new file.
ffmegp::OVERWRITE_UNIQUE – means that every filename is prepended
with a unique hash to preserve the
existing filesystem.
- MOVED error messages into a class variable for easier translation/changes.
- CHANGED moveLog functionality to use rename instead of copy and unlink.

Download ffmpeg Class From HERE

<html>
<head>
<title># of Files to Upload</title>
<meta http-equiv=”Content-Type” content=”text/html; charset=iso-8859-1″>
</head>

<body>
<form name=”form1″ method=”post” action=”uploadForm2.php”>
<p>Enter the amount of boxes you will need below. Max = 9.</p>
<p>
<input name=”uploadNeed” type=”text” id=”uploadNeed” maxlength=”1″>
</p>
<p>
<input type=”submit” name=”Submit” value=”Submit”>
</p>
</form>
</body>
</html>

As you can see this first page is very basic. In my form I set the uploadNeed maxlength to 1. This way the max upload boxes he or she can get is 9. You can increase or decrease this to satisfy your own project needs.

uploadForm2.php

Ok, this page will be doing one half of the work. We will be using the for loop to get this task done.

<html>
<head>
<title>Untitled Document</title>
<meta http-equiv=”Content-Type” content=”text/html; charset=iso-8859-1″>
</head>

<body>

<form name=”form1″ enctype=”multipart/form-data” method=”post” action=”processFiles.php”>
<p>
<?
// start of dynamic form
$uploadNeed = $_POST['uploadNeed'];
for($x=0;$x<$uploadNeed;$x++){
?>
<input name=”uploadFile<? echo $x;?>” type=”file” id=”uploadFile<? echo $x;?>”>
</p>
<?
// end of for loop
}
?>
<p><input name=”uploadNeed” type=”hidden” value=”<? echo $uploadNeed;?>”>
<input type=”submit” name=”Submit” value=”Submit”>
</p>
</form>
</body>
</html>

In this page, all I did was create a simple HTML form with the value of the attribute “type” set to “file”. Within the form I put a block of code to start the for loop. I set $x to 0 and I made it stop at the desired need by setting $x to be less than $uploadNeed – the value specified by the user. I also echo the $uploadNeed into a hidden input field to be carried over to the last page.

The key to making this all work however is the $x variable I am echoing right next to the uploadFile name. What this will do is append a number starting with 0 to the name. This in turn will make each upload field’s name unique.

processFiles.php

Here is the last page to complete our multiple upload tasks.

<?
$uploadNeed = $_POST['uploadNeed'];
// start for loop
for($x=0;$x<$uploadNeed;$x++){
$file_name = $_FILES['uploadFile'. $x]['name'];
// strip file_name of slashes
$file_name = stripslashes($file_name);
$file_name = str_replace(“‘”,”",$file_name);
$copy = copy($_FILES['uploadFile'. $x]['tmp_name'],$file_name);
// check if successfully copied
if($copy){
echo “$file_name | uploaded sucessfully!<br>”;
}else{
echo “$file_name | could not be uploaded!<br>”;
}
} // end of loop
?>

The first thing we do in this page is grab the uploadNeed from uploadForm2.php. We setup our for loop in the same fashion as the last page. The difference here though is we get the $_FILES name within the for loop. I assign this to the local variable name $file_name.

Next, we do a little parsing by adding the stripslashes and str_replace functions. The reason we add the stripslashes is due to file that may have apostrophes in their name; otherwise this will generate a parse error and prevent that file from being uploaded.

Notice once again how I add the $x variable, which in turn is a number, to the name of the $_FILES. By doing this the script now knows which file it is uploading.

We will use the copy function now to actually begin the upload process. The last thing I added was a simple if statement to check that the copy was successful and I echo that message out to the screen.

This little script I am sure will come in handy when you have multiple files that you want to upload all at once. Some other things you could add to this script are listed below.

• Insert file names into a mysql database.
• Get the size of the file and store that in the database too.
• Create a temp text file delimited by commas for the files that have trouble uploading and at the end of the script do a retry on those files.
• Create a mass-delete of files.

class dUnzip2 {
function getVersion() {
return “2.6″;
}
// Public
var $fileName;
var $compressedList; // You will problably use only this one!
var $centralDirList; // Central dir list… It’s a kind of ‘extra attributes’ for a set of files
var $endOfCentral; // End of central dir, contains ZIP Comments
var $debug;

// Private
var $fh;
var $zipSignature = “\x50\x4b\x03\x04″; // local file header signature
var $dirSignature = “\x50\x4b\x01\x02″; // central dir header signature
var $dirSignatureE = “\x50\x4b\x05\x06″; // end of central dir signature

// Public
function dUnzip2($fileName) {
$this->fileName = $fileName;
$this->compressedList = $this->centralDirList = $this->endOfCentral = Array ();
}

function getList($stopOnFile = false) {
if (sizeof($this->compressedList)) {
$this->debugMsg(1, “Returning already loaded file list.”);
return $this->compressedList;
}

// Open file, and set file handler
$fh = fopen($this->fileName, “r”);
$this->fh = & $fh;
if (!$fh) {
$this->debugMsg(2, “Failed to load file.”);
return false;
}

$this->debugMsg(1, “Loading list from ‘End of Central Dir’ index list…”);
if (!$this->_loadFileListByEOF($fh, $stopOnFile)) {
$this->debugMsg(1, “Failed! Trying to load list looking for signatures…”);
if (!$this->_loadFileListBySignatures($fh, $stopOnFile)) {
$this->debugMsg(1, “Failed! Could not find any valid header.”);
$this->debugMsg(2, “ZIP File is corrupted or empty”);
return false;
}
}

if ($this->debug) {
#——- Debug compressedList
$kkk = 0;
echo “<table border=’0′ style=’font: 11px Verdana; border: 1px solid #000′>”;
foreach ($this->compressedList as $fileName => $item) {
if (!$kkk && $kkk = 1) {
echo “<tr style=’background: #ADA’>”;
foreach ($item as $fieldName => $value)
echo “<td>$fieldName</td>”;
echo ‘</tr>’;
}
echo “<tr style=’background: #CFC’>”;
foreach ($item as $fieldName => $value) {
if ($fieldName == ‘lastmod_datetime’)
echo “<td title=’$fieldName’ nowrap=’nowrap’>” . date(“d/m/Y H:i:s”, $value) . “</td>”;
else
echo “<td title=’$fieldName’ nowrap=’nowrap’>$value</td>”;
}
echo “</tr>”;
}
echo “</table>”;

#——- Debug centralDirList
$kkk = 0;
if (sizeof($this->centralDirList)) {
echo “<table border=’0′ style=’font: 11px Verdana; border: 1px solid #000′>”;
foreach ($this->centralDirList as $fileName => $item) {
if (!$kkk && $kkk = 1) {
echo “<tr style=’background: #AAD’>”;
foreach ($item as $fieldName => $value)
echo “<td>$fieldName</td>”;
echo ‘</tr>’;
}
echo “<tr style=’background: #CCF’>”;
foreach ($item as $fieldName => $value) {
if ($fieldName == ‘lastmod_datetime’)
echo “<td title=’$fieldName’ nowrap=’nowrap’>” . date(“d/m/Y H:i:s”, $value) . “</td>”;
else
echo “<td title=’$fieldName’ nowrap=’nowrap’>$value</td>”;
}
echo “</tr>”;
}
echo “</table>”;
}

#——- Debug endOfCentral
$kkk = 0;
if (sizeof($this->endOfCentral)) {
echo “<table border=’0′ style=’font: 11px Verdana’ style=’border: 1px solid #000′>”;
echo “<tr style=’background: #DAA’><td colspan=’2′>dUnzip – End of file</td></tr>”;
foreach ($this->endOfCentral as $field => $value) {
echo “<tr>”;
echo “<td style=’background: #FCC’>$field</td>”;
echo “<td style=’background: #FDD’>$value</td>”;
echo “</tr>”;
}
echo “</table>”;
}
}

return $this->compressedList;
}
function getExtraInfo($compressedFileName) {
return isset ($this->centralDirList[$compressedFileName]) ? $this->centralDirList[$compressedFileName] : false;
}
function getZipInfo($detail = false) {
return $detail ? $this->endOfCentral[$detail] : $this->endOfCentral;
}

function unzip($compressedFileName, $targetFileName = false, $applyChmod = false) {
if (!sizeof($this->compressedList)) {
$this->debugMsg(1, “Trying to unzip before loading file list… Loading it!”);
$this->getList(false, $compressedFileName);
}

$fdetails = & $this->compressedList[$compressedFileName];
if (!isset ($this->compressedList[$compressedFileName])) {
$this->debugMsg(2, “File ‘<b>$compressedFileName</b>’ is not compressed in the zip.”);
return false;
}
if (substr($compressedFileName, -1) == “/”) {
$this->debugMsg(2, “Trying to unzip a folder name ‘<b>$compressedFileName</b>’.”);
return false;
}
if (!$fdetails['uncompressed_size']) {
$this->debugMsg(1, “File ‘<b>$compressedFileName</b>’ is empty.”);
return $targetFileName ? file_put_contents($targetFileName, “”) : “”;
}

fseek($this->fh, $fdetails['contents-startOffset']);
$ret = $this->uncompress(fread($this->fh, $fdetails['compressed_size']), $fdetails['compression_method'], $fdetails['uncompressed_size'], $targetFileName);
if ($applyChmod && $targetFileName)
chmod($targetFileName, 0777);

return $ret;
}
function unzipAll($targetDir = false, $baseDir = “”, $maintainStructure = true, $applyChmod = false) {
if ($targetDir === false)
$targetDir = dirname(__FILE__) . “/”;

$lista = $this->getList();
if (sizeof($lista))
foreach ($lista as $fileName => $trash) {
$dirname = dirname($fileName);
$outDN = “$targetDir/$dirname”;

if (substr($dirname, 0, strlen($baseDir)) != $baseDir)
continue;

if (!is_dir($outDN) && $maintainStructure) {
$str = “”;
$folders = explode(“/”, $dirname);
foreach ($folders as $folder) {
$str = $str ? “$str/$folder” : $folder;
if (!is_dir(“$targetDir/$str”)) {
$this->debugMsg(1, “Creating folder: $targetDir/$str”);
mkdir(“$targetDir/$str”);
if ($applyChmod)
chmod(“$targetDir/$str”, $applyChmod);
}
}
}
if (substr($fileName, -1, 1) == “/”)
continue;

$maintainStructure ? $this->unzip($fileName, “$targetDir/$fileName”, $applyChmod) : $this->unzip($fileName, “$targetDir/” . basename($fileName), $applyChmod);
}
}

function close() { // Free the file resource
if ($this->fh)
fclose($this->fh);
}
function __destroy() {
$this->close();
}

// Private (you should NOT call these methods):
function uncompress($content, $mode, $uncompressedSize, $targetFileName = false) {
switch ($mode) {
case 0 :
// Not compressed
return $targetFileName ? file_put_contents($targetFileName, $content) : $content;
case 1 :
$this->debugMsg(2, “Shrunk mode is not supported… yet?”);
return false;
case 2 :
case 3 :
case 4 :
case 5 :
$this->debugMsg(2, “Compression factor ” . ($mode -1) . ” is not supported… yet?”);
return false;
case 6 :
$this->debugMsg(2, “Implode is not supported… yet?”);
return false;
case 7 :
$this->debugMsg(2, “Tokenizing compression algorithm is not supported… yet?”);
return false;
case 8 :
// Deflate
return $targetFileName ? file_put_contents($targetFileName, gzinflate($content, $uncompressedSize)) : gzinflate($content, $uncompressedSize);
case 9 :
$this->debugMsg(2, “Enhanced Deflating is not supported… yet?”);
return false;
case 10 :
$this->debugMsg(2, “PKWARE Date Compression Library Impoloding is not supported… yet?”);
return false;
case 12 :
// Bzip2
return $targetFileName ? file_put_contents($targetFileName, bzdecompress($content)) : bzdecompress($content);
case 18 :
$this->debugMsg(2, “IBM TERSE is not supported… yet?”);
return false;
default :
$this->debugMsg(2, “Unknown uncompress method: $mode”);
return false;
}
}
function debugMsg($level, $string) {
if ($this->debug)
if ($level == 1)
echo “<b style=’color: #777′>dUnzip2:</b> $string<br>”;
if ($level == 2)
echo “<b style=’color: #F00′>dUnzip2:</b> $string<br>”;
}

function _loadFileListByEOF(& $fh, $stopOnFile = false) {
// Check if there’s a valid Central Dir signature.
// Let’s consider a file comment smaller than 1024 characters…
// Actually, it length can be 65536.. But we’re not going to support it.

for ($x = 0; $x < 1024; $x++) {
fseek($fh, -22 – $x, SEEK_END);

$signature = fread($fh, 4);
if ($signature == $this->dirSignatureE) {
// If found EOF Central Dir
$eodir['disk_number_this'] = unpack(“v”, fread($fh, 2)); // number of this disk
$eodir['disk_number'] = unpack(“v”, fread($fh, 2)); // number of the disk with the start of the central directory
$eodir['total_entries_this'] = unpack(“v”, fread($fh, 2)); // total number of entries in the central dir on this disk
$eodir['total_entries'] = unpack(“v”, fread($fh, 2)); // total number of entries in
$eodir['size_of_cd'] = unpack(“V”, fread($fh, 4)); // size of the central directory
$eodir['offset_start_cd'] = unpack(“V”, fread($fh, 4)); // offset of start of central directory with respect to the starting disk number
$zipFileCommentLenght = unpack(“v”, fread($fh, 2)); // zipfile comment length
$eodir['zipfile_comment'] = $zipFileCommentLenght[1] ? fread($fh, $zipFileCommentLenght[1]) : ”; // zipfile comment
$this->endOfCentral = Array (
‘disk_number_this’ => $eodir['disk_number_this'][1],
‘disk_number’ => $eodir['disk_number'][1],
‘total_entries_this’ => $eodir['total_entries_this'][1],
‘total_entries’ => $eodir['total_entries'][1],
‘size_of_cd’ => $eodir['size_of_cd'][1],
‘offset_start_cd’ => $eodir['offset_start_cd'][1],
‘zipfile_comment’ => $eodir['zipfile_comment'],

);

// Then, load file list
fseek($fh, $this->endOfCentral['offset_start_cd']);
$signature = fread($fh, 4);

while ($signature == $this->dirSignature) {
$dir['version_madeby'] = unpack(“v”, fread($fh, 2)); // version made by
$dir['version_needed'] = unpack(“v”, fread($fh, 2)); // version needed to extract
$dir['general_bit_flag'] = unpack(“v”, fread($fh, 2)); // general purpose bit flag
$dir['compression_method'] = unpack(“v”, fread($fh, 2)); // compression method
$dir['lastmod_time'] = unpack(“v”, fread($fh, 2)); // last mod file time
$dir['lastmod_date'] = unpack(“v”, fread($fh, 2)); // last mod file date
$dir['crc-32'] = fread($fh, 4); // crc-32
$dir['compressed_size'] = unpack(“V”, fread($fh, 4)); // compressed size
$dir['uncompressed_size'] = unpack(“V”, fread($fh, 4)); // uncompressed size
$fileNameLength = unpack(“v”, fread($fh, 2)); // filename length
$extraFieldLength = unpack(“v”, fread($fh, 2)); // extra field length
$fileCommentLength = unpack(“v”, fread($fh, 2)); // file comment length
$dir['disk_number_start'] = unpack(“v”, fread($fh, 2)); // disk number start
$dir['internal_attributes'] = unpack(“v”, fread($fh, 2)); // internal file attributes-byte1
$dir['external_attributes1'] = unpack(“v”, fread($fh, 2)); // external file attributes-byte2
$dir['external_attributes2'] = unpack(“v”, fread($fh, 2)); // external file attributes
$dir['relative_offset'] = unpack(“V”, fread($fh, 4)); // relative offset of local header
$dir['file_name'] = fread($fh, $fileNameLength[1]); // filename
$dir['extra_field'] = $extraFieldLength[1] ? fread($fh, $extraFieldLength[1]) : ”; // extra field
$dir['file_comment'] = $fileCommentLength[1] ? fread($fh, $fileCommentLength[1]) : ”; // file comment

// Convert the date and time, from MS-DOS format to UNIX Timestamp
$BINlastmod_date = str_pad(decbin($dir['lastmod_date'][1]), 16, ’0′, STR_PAD_LEFT);
$BINlastmod_time = str_pad(decbin($dir['lastmod_time'][1]), 16, ’0′, STR_PAD_LEFT);
$lastmod_dateY = bindec(substr($BINlastmod_date, 0, 7)) + 1980;
$lastmod_dateM = bindec(substr($BINlastmod_date, 7, 4));
$lastmod_dateD = bindec(substr($BINlastmod_date, 11, 5));
$lastmod_timeH = bindec(substr($BINlastmod_time, 0, 5));
$lastmod_timeM = bindec(substr($BINlastmod_time, 5, 6));
$lastmod_timeS = bindec(substr($BINlastmod_time, 11, 5));

$this->centralDirList[$dir['file_name']] = Array (
‘version_madeby’ => $dir['version_madeby'][1],
‘version_needed’ => $dir['version_needed'][1],
‘general_bit_flag’ => str_pad(decbin($dir['general_bit_flag'][1]
), 8, ’0′, STR_PAD_LEFT), ‘compression_method’ => $dir['compression_method'][1], ‘lastmod_datetime’ => mktime($lastmod_timeH, $lastmod_timeM, $lastmod_timeS, $lastmod_dateM, $lastmod_dateD, $lastmod_dateY), ‘crc-32′ => str_pad(dechex(ord($dir['crc-32'][3])), 2, ’0′, STR_PAD_LEFT) .
str_pad(dechex(ord($dir['crc-32'][2])), 2, ’0′, STR_PAD_LEFT) .
str_pad(dechex(ord($dir['crc-32'][1])), 2, ’0′, STR_PAD_LEFT) .
str_pad(dechex(ord($dir['crc-32'][0])), 2, ’0′, STR_PAD_LEFT), ‘compressed_size’ => $dir['compressed_size'][1], ‘uncompressed_size’ => $dir['uncompressed_size'][1], ‘disk_number_start’ => $dir['disk_number_start'][1], ‘internal_attributes’ => $dir['internal_attributes'][1], ‘external_attributes1′ => $dir['external_attributes1'][1], ‘external_attributes2′ => $dir['external_attributes2'][1], ‘relative_offset’ => $dir['relative_offset'][1], ‘file_name’ => $dir['file_name'], ‘extra_field’ => $dir['extra_field'], ‘file_comment’ => $dir['file_comment'],);
$signature = fread($fh, 4);
}

// If loaded centralDirs, then try to identify the offsetPosition of the compressed data.
if ($this->centralDirList)
foreach ($this->centralDirList as $filename => $details) {
$i = $this->_getFileHeaderInformation($fh, $details['relative_offset']);
$this->compressedList[$filename]['file_name'] = $filename;
$this->compressedList[$filename]['compression_method'] = $details['compression_method'];
$this->compressedList[$filename]['version_needed'] = $details['version_needed'];
$this->compressedList[$filename]['lastmod_datetime'] = $details['lastmod_datetime'];
$this->compressedList[$filename]['crc-32'] = $details['crc-32'];
$this->compressedList[$filename]['compressed_size'] = $details['compressed_size'];
$this->compressedList[$filename]['uncompressed_size'] = $details['uncompressed_size'];
$this->compressedList[$filename]['lastmod_datetime'] = $details['lastmod_datetime'];
$this->compressedList[$filename]['extra_field'] = $i['extra_field'];
$this->compressedList[$filename]['contents-startOffset'] = $i['contents-startOffset'];
if (strtolower($stopOnFile) == strtolower($filename))
break;
}
return true;
}
}
return false;
}
function _loadFileListBySignatures(& $fh, $stopOnFile = false) {
fseek($fh, 0);

$return = false;
for (;;) {
$details = $this->_getFileHeaderInformation($fh);
if (!$details) {
$this->debugMsg(1, “Invalid signature. Trying to verify if is old style Data Descriptor…”);
fseek($fh, 12 – 4, SEEK_CUR); // 12: Data descriptor – 4: Signature (that will be read again)
$details = $this->_getFileHeaderInformation($fh);
}
if (!$details) {
$this->debugMsg(1, “Still invalid signature. Probably reached the end of the file.”);
break;
}
$filename = $details['file_name'];
$this->compressedList[$filename] = $details;
$return = true;
if (strtolower($stopOnFile) == strtolower($filename))
break;
}

return $return;
}
function _getFileHeaderInformation(& $fh, $startOffset = false) {
if ($startOffset !== false)
fseek($fh, $startOffset);

$signature = fread($fh, 4);
if ($signature == $this->zipSignature) {
# $this->debugMsg(1, “Zip Signature!”);

// Get information about the zipped file
$file['version_needed'] = unpack(“v”, fread($fh, 2)); // version needed to extract
$file['general_bit_flag'] = unpack(“v”, fread($fh, 2)); // general purpose bit flag
$file['compression_method'] = unpack(“v”, fread($fh, 2)); // compression method
$file['lastmod_time'] = unpack(“v”, fread($fh, 2)); // last mod file time
$file['lastmod_date'] = unpack(“v”, fread($fh, 2)); // last mod file date
$file['crc-32'] = fread($fh, 4); // crc-32
$file['compressed_size'] = unpack(“V”, fread($fh, 4)); // compressed size
$file['uncompressed_size'] = unpack(“V”, fread($fh, 4)); // uncompressed size
$fileNameLength = unpack(“v”, fread($fh, 2)); // filename length
$extraFieldLength = unpack(“v”, fread($fh, 2)); // extra field length
$file['file_name'] = fread($fh, $fileNameLength[1]); // filename
$file['extra_field'] = $extraFieldLength[1] ? fread($fh, $extraFieldLength[1]) : ”; // extra field
$file['contents-startOffset'] = ftell($fh);

// Bypass the whole compressed contents, and look for the next file
fseek($fh, $file['compressed_size'][1], SEEK_CUR);

// Convert the date and time, from MS-DOS format to UNIX Timestamp
$BINlastmod_date = str_pad(decbin($file['lastmod_date'][1]), 16, ’0′, STR_PAD_LEFT);
$BINlastmod_time = str_pad(decbin($file['lastmod_time'][1]), 16, ’0′, STR_PAD_LEFT);
$lastmod_dateY = bindec(substr($BINlastmod_date, 0, 7)) + 1980;
$lastmod_dateM = bindec(substr($BINlastmod_date, 7, 4));
$lastmod_dateD = bindec(substr($BINlastmod_date, 11, 5));
$lastmod_timeH = bindec(substr($BINlastmod_time, 0, 5));
$lastmod_timeM = bindec(substr($BINlastmod_time, 5, 6));
$lastmod_timeS = bindec(substr($BINlastmod_time, 11, 5));

// Mount file table
$i = Array (
‘file_name’ => $file['file_name'],
‘compression_method’ => $file['compression_method'][1],
‘version_needed’ => $file['version_needed'][1],
‘lastmod_datetime’ => mktime($lastmod_timeH,
$lastmod_timeM,
$lastmod_timeS,
$lastmod_dateM,
$lastmod_dateD,
$lastmod_dateY
), ‘crc-32′ => str_pad(dechex(ord($file['crc-32'][3])), 2, ’0′, STR_PAD_LEFT) .
str_pad(dechex(ord($file['crc-32'][2])), 2, ’0′, STR_PAD_LEFT) .
str_pad(dechex(ord($file['crc-32'][1])), 2, ’0′, STR_PAD_LEFT) .
str_pad(dechex(ord($file['crc-32'][0])), 2, ’0′, STR_PAD_LEFT), ‘compressed_size’ => $file['compressed_size'][1], ‘uncompressed_size’ => $file['uncompressed_size'][1], ‘extra_field’ => $file['extra_field'], ‘general_bit_flag’ => str_pad(decbin($file['general_bit_flag'][1]), 8, ’0′, STR_PAD_LEFT), ‘contents-startOffset’ => $file['contents-startOffset']);
return $i;
}
return false;
}
}

$zip = new dUnzip2(‘zipfile.zip’);
$zip->debug = false; // you can enable if you want to show whats happning
$zip->getList();
$zip->unzipAll();

?>

You can download this script from here

// set up basic connection
$_conn_id = ftp_connect($_server);

// login with username and password
$_login_result = ftp_login($_conn_id, $_user_name, $_user_pass);

// check connection
if ((!$_conn_id) || (!$_login_result)) {
$_error = “FTP connection has failed!”;
$_error .= “Attempted to connect to $_server for user $_user_name”;
$result = false;
} else {
$_error = “Connected to $_server, for user $_user_name”;
$result = true;
}

$conn_id = $_conn_id;

@ ftp_mkdir($conn_id, $remote_dir);
$handle = opendir($local_dir);
while (($file = readdir($handle)) !== false) {
if (($file != ‘.’) && ($file != ‘..’)) {
if (is_dir($local_dir . $file)) {
//recursive call
moveFolder($conn_id, $local_dir . $file . ‘/’, $remote_dir . $file . ‘/’);
} else
$f[] = $file;
}
}
closedir($handle);
if (count($f)) {
sort($f);
@ ftp_chdir($conn_id, $remote_dir);
foreach ($f as $files) {
$from = @ fopen(“$local_dir$files”, ‘r’);
$moveFolder = ftp_fput($conn_id, $files, $from, FTP_BINARY);

// check upload status
if (!$moveFolder) {
$this->_error = “FTP upload has failed! From: ” . $local_dir . ” To: ” . $remote_dir;
$result = false;
} else {
$this->_error = “Uploaded $local_dir to $remote_dir as $this->_server”;
$result = true;
}
}
}
return $result;
}

<?php
//a small class for database connectivity
class database {
private $db_handle;
private $user_name;
private $password;
private $data_base;
private $host_name;
private $sql;
private $results;

function __construct($host = “localhost”, $user, $passwd) {
$this->db_handle = mysql_connect($host, $user, $passwd);
}

function dbSelect($db) {
$this->data_base = $db;
if (!mysql_select_db($this->data_base, $this->db_handle)) {
error_log(mysql_error(), 3, “/phplog.err”);
die(“Error connecting to Database”);
}
}

function executeSql($sql_stmt) {
$this->sql = $sql_stmt;
$this->result = mysql_query($this->sql);
}
function returnResults() {
return $this->result;
}
}

//database variables
$host = “localhost”;
$user = “root”;
$passwd = “”;
$db = “bg_db”;
$sql = “SELECT * FROM table ORDER BY id”; // a query to fetch records from database

$dbObject = new database($host, $user, $passwd);
$dbObject->dbSelect($db);
$dbObject->executeSql($sql);

$res = $dbObject->returnResults(); // result reasource

$newFileName = “emp_names.csv”; //file name that you want to create
$fpWrite = fopen($newFileName, “w”); // open file as writable
$nameStr = “”;

$rows = mysql_fetch_assoc($res); // fetching associate records

$sStr = “”;

//first store the fields name as header of csv in $sStr
foreach($rows as $key=>$val) {
$sStr .= $key.”,”;
}

//then store all records
do {
$sStr .= “– —–\n”; //to seprate every record
foreach($rows as $key=>$row) {
$sStr .= $row.”,”;
}
}while($rows = mysql_fetch_assoc($res));

$sStrExp = explode(“– —–”, $sStr);//separate every record
foreach($sStrExp as $val) {
$sStr2 .= rtrim($val, “,”);
}

echo $sStr2;

fwrite($fpWrite, $sStr2); //now write to csv file
fclose($fpWrite);//close file
?>

that all
enjoy….