code-diesel » tip

Read the version of a PDF in PHP

sameer — Thu, 21 Jul 2011 13:09:01 +0000

The following is a very short code to read the version number of a PDF document using PHP. I needed this recently during a PDF processing app developed in PHP. As Adobe uses different compression methods in various versions, it becomes necessary to be able to identify the version of the PDF under work.


 
function pdfVersion($filename)
{ 
    $fp = @fopen($filename, 'rb');
 
    if (!$fp) {
        return 0;
    }
 
    /* Reset file pointer to the start */
    fseek($fp, 0);
 
    /* Read 20 bytes from the start of the PDF */
    preg_match('/\d\.\d/',fread($fp,20),$match);
 
    fclose($fp);
 
    if (isset($match[0])) {
        return $match[0];
    } else {
        return 0;
    }
} 
 
$version = pdfVersion("example.pdf");

Tail functionality in PHP

sameer — Tue, 19 Jul 2011 03:38:06 +0000

Frequently one needs to get the last few lines of some log files, whether php error logs or Apache logs. Most of these file sizes run into megabytes, which makes it difficult and time consuming to remotely open them using ftp. If you have shell access then you can easily use the *nix ‘tail’ command to return the last ‘n’ lines; or one can use the following if shell access is not enabled on your hosting.

function Tail($filename) {
  return system('tail -n 20 '.$filename);
}

Sometimes even the ‘system’ command is disabled for security reasons, which brings us to the last solution – coding the tail command in PHP. The following is a simple but useful ‘tail’ implementation in PHP. I’ve encapsulated the tail function in a ‘LogRead’ class, which can be further enlarged by adding other useful log functions.


 
class LogRead
{
    private $filename = '';
 
    function __construct($filename) 
    {
        $this->filename = $filename;
    }
 
    public function tail($lines = 10) 
    {
        $data = '';
        $fp = fopen($this->filename, "r");
        $block = 4096;
        $max = filesize($this->filename);
 
        for($len = 0; $len < $max; $len += $block) 
        {
            $seekSize = ($max - $len > $block) ? $block : $max - $len;
            fseek($fp, ($len + $seekSize) * -1, SEEK_END);
            $data = fread($fp, $seekSize) . $data;
 
            if(substr_count($data, "\n") >= $lines + 1) 
            {
                /* Make sure that the last line ends with a '\n' */
                if(substr($data, strlen($data)-1, 1) !== "\n") {
                    $data .= "\n";
                }
 
                preg_match("!(.*?\n){". $lines ."}$!", $data, $match);
                fclose($fp);
                return $match[0];
            }
        }
        fclose($fp);
        return $data; 
    }
}

Which you can use as following:


$log = new LogRead("errors.log");
 
/* Get the last 6 lines */
$lines = $log->tail(6);
print_r($lines);

adapted from ‘steve at studio831 dot com’

Grabbing website Favicons using curl and php

sameer — Fri, 27 May 2011 10:26:41 +0000

Google Shared Stuff allows one to easily get the Favicon of any website with a single line. For instance to get the Favicon of yahoo.com we can use the following in a browser.

http://www.google.com/s2/favicons?domain=yahoo.com

We can do do the same using PHP and curl using the following code.


 
  function getSiteFavicon($url)
  {
    $ch = curl_init('http://www.google.com/s2/favicons?domain='.$url);
    curl_setopt($ch, CURLOPT_TIMEOUT, 10);
    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);    
    $data = curl_exec($ch);
    curl_close($ch);
 
    header("Content-type: image/png; charset=utf-8");
    echo $data;
  }
 
  getSiteFavicon("yahoo.com");
 
?>

This will display the Favicon in the browser. An even more interesting thing we can do is to save the same to a PNG file. A little modification to the above code will yield the following.


 
  function saveSiteFavicon($url)
  {
    /* Drop the TLD from the url */
    $saveFileName = substr($url,0,-4);
    $fp = fopen ($saveFileName.'.png', 'w+');
    $ch = curl_init('http://www.google.com/s2/favicons?domain='.$url);
 
    curl_setopt($ch, CURLOPT_TIMEOUT, 6);
 
    /* Save the returned data to a file */
    curl_setopt($ch, CURLOPT_FILE, $fp);
    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
    curl_exec($ch);
    curl_close($ch);
    fclose($fp);
  }
 
 
  saveSiteFavicon("yahoo.com");
 
?>

Below is a more elaborate code to grab Favicons from a list of urls and combine them into a single image.


 
function getSiteFavicon($url)
{
    $ch = curl_init('http://www.google.com/s2/favicons?domain='.$url);
    curl_setopt($ch, CURLOPT_TIMEOUT, 10);
    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, false);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $data = curl_exec($ch);
    curl_close($ch);
 
    return $data;
}
 
 
/* Urls to grab the Favicon of */
$urls = array("yahoo.com", "microsoft.com", "wired.com",
              "cakephp.org", "wordpress.com", "msn.com");
 
/* Create a 180px by 40px blank image */
$dest = imagecreate(180, 40);
 
$x = 0;
$y = 0;
 
foreach($urls as $url) {
    /* Get the Favicon data for a url */
    $imageData = getSiteFavicon($url);
 
    /* Create a GD image resource ffrom the data */
    $src = imagecreatefromstring($imageData);
 
    /* Copy each Favicon image to the blank canvas */
    imagecopy($dest, $src, $x, $y, 0, 0, 16, 16);
 
    /* change the x,y offset for the next favicon */
    $x += 20;
 
    if($x >= 60) {
        $x = 0;
        $y += 20;
    }
}
 
/* Output the newly created image */
header('Content-Type: image/gif');
imagegif($dest);
 
imagedestroy($dest);
imagedestroy($src);

The above code will create the following image in your browser.

A little more code change and you can save the image to a file.

Searching server files using GREP

sameer — Thu, 26 May 2011 05:38:52 +0000

During debugging the majority of my time is spent in searching for specific text. Searching on the local machine is a breeze via a IDE, but if I’ve an application hosted on a remote server then it can get difficult and slow, unless of course you have access to SSH when you can use good-old Grep. But many times the server does not have SSH access at which time I have to rely on using Linux commands though PHP.

So for example the following will allow me to recursively search all the files in a directory for the string ” mail”. I just upload the file to the server directory from where I need to make the search. Here I’m using the PHP backtick operator that allows me to escape to the shell, execute the specified command, and return the result in the variable $output.


$output = `grep -r " mail" .`;
echo $output;
?>

The equivalent of the above using the shell_exec function is shown below.


$output = shell_exec('grep -r " mail" .');
echo $output;
?>

Note that the backtick operator and shell_exec are disabled if php is running in safe_mode so you will need to temporarily enable it to run the above code.

The above code searches for the specified string in all the files, but if you need to limit the search for a specific file type than you have to use find in combination with grep. So, the following will search for the string ‘ mail’ only in files with the .php extension.


$output = `find . -iname '*php' | xargs grep ' mail' `;
echo $output;
?>

By default grep lists the matched filename and also the matched line, but if you need to only list the filenames that contain the search term, you can use the ‘-l’ option with grep.

$output = `find . -iname '*php' | xargs grep ' mail' -l `;

Fixing aspect-ratio of images in PHP

sameer — Wed, 15 Sep 2010 14:29:28 +0000

Frequently when you are displaying images on a page using a fixed width and height , the images come out stretched or squeezed. This is because the aspect ratio of the images have not been maintained. In such a case you can use the following script to correctly display the images according to the aspect-ratio of the image without actually resizing the image in a editor. This can be handy when you need to quickly correct image distortions. Here you need to keep either the width or the height fixed, so the other dimension can be calculated. Below the width is kept fixed at 200px, and the height is varied depending on the aspect ratio of the image, thus displaying the image without any distortion.


 
$imageFile = 'path/to/image';
 
/* Set the width fixed at 200px; */
$width = 200;
 
/* Get the image info */
$info = getimagesize($imageFile);
 
/* Calculate aspect ratio by dividing height by width */
$aspectRatio = $info[1] / $info[0];
 
/* Keep the width fix at 100px, 
   but change the height according to the aspect ratio */
$newHeight = (int)($aspectRatio * $width) . "px";
 
/* Use the 'newHeight' in the CSS height property below. */
$width .= "px";
 
echo "\"width: $width; height: $newHeight;\" 
       src=\"$imageFile\" />";

Deleting pesky blank lines from source files

sameer — Thu, 25 Mar 2010 12:46:24 +0000

Blank lines are an eye sore for source files. During the last few weeks I’ve been shuttling php and html files from various host servers and my PC. During the whole ordeal the source files kept adding a huge number of blank lines. At one point an ‘if’ construct in one of my PHP code was about 60 lines away from the next starting brace. This was all caused by the non standard newline character, also known as a line break or end-of-line (EOL) character. As we all know, it is a special character or sequence of characters signifying the end of a line of text. Unfortunately the actual codes representing the newline differ across operating systems, which creates problems such as the above when exchanging data between systems. If you think you don’t use *nix systems and are therefore free from these problems then you are wrong. Even though you may be using Windows, most host servers are Linux based, and so transferring files back and forth from these servers can create these kind of problems.

Viewing EOL markers

I regularly use Notepad++ for editing purposes. In Notepad++ we can see the EOL markers with the ‘View->Show Symbol->Show End of Line’ menu.

The following images shows the EOL markers for Windows and Unix.

Windows

Unix

Line terminations

As you can see Windows files are terminated by the sequence CR+LF (\r\n) and Unix by LF(\n) character. There is a wonderful history behind the newline character, which Wikipedia explains quite nicely. Our main job here is to know how to quickly delete those annoying blank lines.

Deleting blank lines

A quick way to delete blank lines from a file using Notepad++ is to use the ‘Search-Replace’ functionality of the editor as shown below. Note that we are using the ‘Extended’ search mode for the replacements. Using ‘Plain Text’ search mode will not work. If you are using another text editor use the ‘Regular expression’ search mode if it has one.

For deleting blank lines from a Windows file use the string ‘\r\n\r\n’ in the search field, and a blank string for the replacement field. For files with Unix EOL markers use the ‘\n\n’ string for the search field. Note the double ‘\r\n’ and ‘\n’. Specifying a single ‘\n’ or ‘\r\n’ will delete all the EOL markers and convert the text to a single loooong string. Of course if you are using Notepad++ then you have at your disposal the wonderful TextFx plugin; besides a ton of functions, it also lets you delete blank lines from a file. But if you are using any other editor without the functionality then this tip can come handy.

Converting hard tabs to soft tabs

While editing source files I prefer using soft tabs rather than hard tabs, this helps me preserve my code formatting when viewed in another editor which has a different tab setting. Incidentally you can convert hard tabs in your code to soft tabs by replacing ‘\t’ with a n number of spaces as given above.

7 essential php command-line options

sameer — Sat, 12 Dec 2009 05:30:24 +0000

Most of us use PHP from a IDE or using a simple text editor with a browser, rarely dropping down to the command-line for running php programs. But php provides some interesting and quick options you can use to perform various common tasks or to debug some nasty installation problems. Below is a list of some useful options you should be familiar with.

There are two ways to specify options on the command line – Short Option, where you specify a option by a single character and a Long Option, where you use a more readable string to specify the option, such as ‘–php-ini’. In this post we will be using the Short Option.

PHP Command-line options

1 : Using a different php.ini file

The following option can be useful when you need to test various ini configurations, or you need to check if all the modules in a particular ini are loading correctly.

php –c  PATH/to/PHP.INI example.php

2 : Check to see for any syntax errors in a php file.

Need to quickly check for php syntax errors if you do not have access to an IDE, then this option can be quite helpful. Combine it with some shell code and you can easily check for syntax errors for multiple files in a directory.

php –l example.php

You can for example use the windows command line script to scan all the php files in the current directory for syntax errors.

c:\localhost>for %%X in (*.php) do php -l %%X

3 : Display php builtin and loaded modules

php –m

Combine it with php –c to debug any module loading errors for different php.ini files

php –c PATH/to/PHP.INI -m

This came in handy when I was installing php 5.3 and for some reasons the xdebug extension was not loading. With the help of the above command I was able to narrow down the problem to the following reason:

Xdebug requires Zend Engine API version 220090115.
The Zend Engine API version 220090626 which is installed, is newer.
Contact Derick Rethans at http://xdebug.org for a later 
version of Xdebug.

4 : Syntax Highlighting

The following option will display syntax highlighted text using php’s internal mechanism.

php  –s  example.php

You can then write the output to another file using a redirect.

php  –s  example.php  >  syntax.html

5 : Strip the source code of comments and whitespace.

Can be useful if you need to reduce the file size.

php –w example.php

6 : Run php code from the command line

Directly run php code from the command line without using the php start and end tags.

php -r "$foo = 'hello!'; $foo = strtoupper($foo); echo $foo;"

7 : Display information related to a internal function, class or extension

(Available as of PHP 5.1.2)
These options can be quite handy when a PHP manual is not within reach.

php --r[fcei]

Show information about a function:

php --rf usort

Example output for the above:

Function [ <internal:standard> function usort ] {
 
  - Parameters [2] {
    Parameter #0 [  &$arg ]
    Parameter #1 [  $cmp_function ]
  }
}

Show information about a class:

php --rc EmptyIterator

Example output for the above:

Class [ <internal:SPL> <iterateable> class EmptyIterator 
          implements Iterator, Traversable ] {
  - Constants [0] {
  }
  - Static properties [0] {
  }
  - Static methods [0] {
  }
  - Properties [0] {
  }
  - Methods [5] {
    Method [ <internal:SPL, prototype Iterator> public method rewind ] {
    }
    Method [ <internal:SPL, prototype Iterator> public method valid ] {
    }
    Method [ <internal:SPL, prototype Iterator> public method key ] {
    }
    Method [ <internal:SPL, prototype Iterator> public method current ] {
    }
    Method [ <internal:SPL, prototype Iterator> public method next ] {
    }
  }
}

Show information about a extension:

php  --re json

Example output for the above:

xtension [ <persistent> extension #10 json version 1.2.1 ] {

  - Functions {
    Function [ <internal:json> function json_encode ] {
    }
    Function [ <internal:json> function json_decode ] {
    }
  }
}

Show configuration information for a particular extension:

php  --ri tidy

Example output for the above:

tidy
 
Tidy support => enabled
libTidy Release => 15 August 2007
Extension Version => 2.0
($Id: tidy.c,v 1.66.2.8.2.24 2007/09/20 22:25:05 nlopess Exp $)
 
Directive => Local Value => Master Value
tidy.default_config => no value => no value
tidy.clean_output => no value => no value

Simulating Packages in PHP

sameer — Thu, 05 Nov 2009 06:36:15 +0000

Most modern languages have a concept of packages, wherein related classes are stored together. PHP sadly doesn’t have a similar concept. For example in Java we can use the following line to imports all classes from the java.awt.event package.

import java.awt.event.*;

But in the spirit of ‘programming into the language’, what we can do is try to simulate a ‘package-like’ concept in PHP. Take the following directory structure.

So now if we want to import the ‘login.php’ file in our code we must be able to do the following with a newly created ‘import’ function:

import("com.codediesel.Security.login");

This will include the ‘login.php’ file from the ‘com/codediesel/Security’ directory. To include all the files from the ‘Security’ directory we can do the following:

import("com.codediesel.Security.*);

As you can see that this is actually quite different from what the actual package concept implies, which is to import related classes.

Anyways, taking it as a conceptual idea only the code for the import function is shown below:


 
$basePath = "./";
 
function import($classPath)
{
    global $basePath;
 
    /* If the path ends with a '.*' then include
       all the files in the last given directory.
    */
    if(preg_match('/(\.\*)$/', $classPath))
    {
        $importFilePath = substr($classPath, 0, strlen($classPath) - 2);
        $importFilePath = str_replace(".", "/", $importFilePath);
        $d= dir($basePath . $importFilePath);
 
        while(false !== ($file = $d->read())) 
        {
            /* Reject parent, current directories and sub directories */
            if(($file == '.')  ||
               ($file == '..') ||
               (is_dir($d->path . "/" . $file)))
            {
                continue;
            }
 
            require_once($basePath . $importFilePath . "/" . $file);
        }
    } else {
        /* If a single file is specified */
        $importFile = str_replace(".", "/", $classPath) . ".php";
    	require_once($basePath . $importFile);
    }
}
 
?>

Please note that this is just an idea. Detailed error handling is not included to keep the code conceptually simple to understand. It would be fun if readers could bounce around some thoughts.

Now the Problems

The first main problem is that this is not exactly what the package concept implies. What we are essentially doing is dressing-up the ‘include’ concept in new clothes.

The second is that for multiple file inclusion as shown above, we cannot predict in which sequence the files will be included, which can raise some dependency issues.

Including a large number of files can incur a small performance hit. This can be better handled if developed as a PECL extension.

Creating a .htaccess file on Windows

sameer — Mon, 27 Jul 2009 12:10:39 +0000

Everyone who has tried creating a .htaccess on windows knows that Windows Explorer does not accept the ‘.’ character as the first character of a file. For most of you this may be old stuff, but for the newbies, the quick way to create the file is to open the command prompt and type:

copy con .htaccess [press enter]
[press ctrl Z]

The second way is to:
Open notepad and save the document with file name .htaccess with the ‘save as type’ set to ‘All Files’; or save the document with file name as “.htaccess” including the quotes.

Pushing xpi mime content from php

sameer — Fri, 15 May 2009 04:01:49 +0000

A couple of days back I created a Firefox toolbar for my blog as an experiment in learning XUL. Once installed on my blog I wanted Firefox to recognize it as an addon and install it rather than displaying a ‘save/open’ dialog. For that I needed to add the following directive to the servers .htaccess file.

AddType application/x-xpinstall .xpi

But the problem was that my server (godaddy) for some mysterious reasons was not recognizing the above directive. Searching around I found that godaddy has some restrictions on the various htaccess directives (yuck!). After fiddling for some time I finally had to try another solution.

What the Apache ‘AddType’ directive does is that it maps the given filename extension onto the specified MIME content type, so that the browser can understand what it is supposed to do with the content. If we could replicate that in PHP than we are good. A possible solution that worked for me is shown below. You can also use the idea for other MIME types.


 
 
/* File we want to send to the browser */
$filename = "codediesel.xpi";
 
 
/**
 * The following header is required for browsers that do not
 * recognize the xpi extension. i.e all browsers other than Firefox.
 * This will display the familiar 'save/open' dialog if the xpi
 * extension is not supported.
 */
header("Content-Disposition: filename={$filename}");
 
 
/* Tell the browser that the content that is coming is an xpinstall */
header('Content-type: application/x-xpinstall');
 
 
/* Also send the content length */
header('Content-Length: ' . filesize($filename));
 
 
/* readfile reads the file content and echos it to the output */
readfile($filename);
 
?>

Of course if the filesize is large the readfile function could possibly incur a performance hit. But for small files it works good.