PHP HTML CSS Tutorials

HTML5 Local Storage – Complete Guide

admin — Mon, 20 Sep 2010 10:15:31 +0000

HTML5 is one of the most fashionable topics in today’s web programming world. HTML5 contains lots of new features that allege to change the web face, big players like Google and Apple are pushing for it and browsers competes to implement more and more html5 features. In this conditions there is no surprise that everyone is talking about it.

In this post we are going to analyse exhaustively an HTML5 simple feature which is already implemented in all the modern browsers: local storage. Local Storage is just a part of the Web Storage api. It is already defined in the HTML5 specifications and it’s implemented in all the modern browsers:

IE	Firefox	Safari	Chrome	Opera	IPhone	Android
8+	3.5	4.0+	4.0+	10.5+	2.0+	2.0+

Local Storage is intended to be used for storing and retrieving data in html pages from the same domain. The data can be retrieved from all the windows in the same domain even if the browser is restarted. The Session Storage is the other Web Storage option and the data is available only in the window it was stored in and is lost when the browser window is closed.

Local Storage along with Session Storage aims to be a replacement of the cookies, defining a more consistent API. There are a few differences from the cookies:
- While the cookies are accessible from both client and server side, Web Storage in general and Local Storage in particular is accessible only from client side.
- Enhanced capacity(official for cookies is 4 kbytes) to more than 5Mb per domain(Firefox, Google Chrome, and Opera and 10MB in IE).

The local storage is a simple javascript api that you can use inside html5 pages if it’s supported by the browser. The Local Storage implements the same interface that can be used for Session Storage as well. Here is the interface as it is defined by :

interface Storage {
  readonly attribute unsigned long length;
  getter DOMString key(in unsigned long index);
  getter any getItem(in DOMString key);
  setter creator void setItem(in DOMString key, in any value);
  deleter void removeItem(in DOMString key);
  void clear();
};

Testing if the browser supports Local Storage

When you intend to use Local Storage you have to take in consideration that it is not supported by all the browsers. If the correct run of your application depends on the local storage functionality you have find other features to rely if it’s not supported, or to inform the user that the application doesn’t run properly on his browser. In order to check if it’s supported you have to check if the localStorage instance exists.

	function testSupport()
	{
		if (localStorage)
			return "Local Storage: Supported";
		else
			return "Local Storage: Unsupported";
	}

How to Store a Value

Storing values is very simple, all you have to do is to invoke the setItem method, providing a key and a value, or to use use the localStorage object as an associative array:

	localStorage.setItem("key1", "value1");
	localStorage["key1"] = "value1";

How to Retrieve a Value

Retrieving stored values is as simple as possible:

	alert(localStorage.getItem("key1"));
	alert(localStorage["key1"]);

List all stored values

If you need to check all the values stored in local storage you can iterate through the keys, listing the values accordingly.

function listAllItems(){
	for (i=0; i<=localStorage.length-1; i++)
	{
		key = localStorage.key(i);
		val = localStorage.getItem(key);
	}
}

Remove a Value

Compared to cookies, html5 local storage has a much bigger capacity. However, it doesn't mean it's unlimited. If you application uses intensively the local storage, you have to take care to remove the objects you don't need anymore.

    void removeItem("key1");

Clear all the values

When the web application is "closed" or "started" you can clean all the stored values:

	localStorage.clear();

How to write a simple scraper in PHP without Regex

admin — Tue, 15 Jun 2010 14:19:41 +0000

Web scrappers are simple programs that are used to extract certain data from the web. Usually the structure of the the pages is known so scrappers have reduced complexity compared to parsers and crawlers.

In this tutorial we are going to create a simple parser that extract the title and favicon from any html page.

Usually scrappers are based on regular expressions but we are going to avoid them because they are difficult to manage and sometimes they have unexpected results. We are going to use simple php string functions instead.

Let’s assume all the pages we are scrapping have the following structure.


Page Tile | Site Name

...

...
Title
...

We are going to retrieve the title and the favicon from the meta section and if the title is not populated we are going to search for the title inside the body. Those operations can be covered using only 2 simple functions:

function strInBetween($text,
                               $separatorStart,
                               $separatorEnd,
                               &$positionOut = null,
                               $after = null,
                               $afterIndex = 0)
{
	$CYCLE_LIMIT = 500;

	$stop = false;
	$pos = 0;
	$current = strInBetween($text, $separatorStart, $separatorEnd, $pos);
	$matching = strpos($current, $containing);
	$i = 0;
	$afterIndex = 0;
	while ($pos >= 0 && $matching === false && $i < $CYCLE_LIMIT)
	{
		$afterIndex += $pos + strlen($current);
		$current = strInBetween($text, $separatorStart, $separatorEnd, $pos, null, $afterIndex);
		$matching = strpos($current, $containing);
		$i++;
	}

	if ($matching)
		return $current;
	else
		return null;
}

This previous function returns the first substring found inside the input $text, surrounded by 2 string delimiters: $separatorStart and $separatorEnd. Optionally, another substring or index could be specified to start the search only after it:

$text - the text where to search the substring
$separatorStart - the string delimiter in the left
$separatorEnd - the string delimiter in the right
&$positionOut - optional output parameter, contains the position where the string is.
$after - optional parameter, is specified, the result is searched only after $after is encountered
$afterIndex - optional parameter used if $after is null. It indicates the index where the search should start.

function strInBetweenContaining($text,
                               $separatorStart,
                               $containing,
                               $separatorEnd,
                               &$pos = null,
                               $after = null,
                               $afterIndex = 0)
{
    if ($after != null)
	{
        $pos = strpos($text, $after);
		if ($pos !== false)
			$afterIndex = $pos;
	}

	$start = -1;
	$pos = strpos($text, $separatorStart, $afterIndex);
	if ($pos !== false)
		$start = $pos;

	$end = -1;
	$pos = strpos($text, $separatorEnd, $start + strlen($separatorStart));
	if ($pos !== false)
		$end = $pos;

	if ($start < 0 && $end < 0)
	{
		if ($positionOut != null)
			$positionOut = -1;

		return null;
	}
	else
	{
		if ($positionOut != null)
			$positionOut = -1;

		return substr($text, $start + strlen($separatorStart), $end - ($start + strlen($separatorStart)));
	}
}

strInBetweenContaining is based on the first function, and returns the string as mentioned in previous function only if it contains the specified string.

Here is the scraping section:

require_once('util/getpage.php');
require_once('util/stringutils.php');

$url = $_GET['u'];
$page = getpage($url);

function getTitle($page) { return strInBetween($page, '', ''); }
function getH1($page) { return strInBetween($page, ''); }
function getLink($page)
{
	$block = strInBetweenContaining($page, '');
	return strInBetween($block, 'href="', '"');
}

echo getTitle($page) . '
';
echo strip_tags('';

$favicon = getLink($page);
if ($favicon == null)
	$favicon = $url . 'favicon.ico';

//echo $favicon;
echo "";

The code is pretty much self-explanatory. The title and the first h1 tag is extracted, then the favico. If no favico is found the code returns the default one(according to the convention it should be the "favicon.ico" in the server root).

This example demonstrate how to retrieve a couple of simple values using a simple algorithm. It can be reused and extended to scrap any data from webpages. A regular expression parser would be a more flexible solution but it requires a good regex knowledge.

If you have question, requests or new ideas just use the comments section to submit them.

Creating a Simple PHP Cache Script

admin — Wed, 03 Mar 2010 09:42:35 +0000

Cache is a programming concept that can be used in a various range of applications and for various purposes. A cache library can be used for storing database queries for later use, to store rendered pages to be served again without generating them again, or to save indexed pages in a crawler application to be processed by multiple modules.

to store a value(identified by a key).
to retrieve a value if it’s not expired.
additionally it can offer a mechanism to invalidate a set of values or the entire cache.

In this tutorial we are going to create a disk cache script. It stores the string values in files, each value is stored in a file and it contains an additional file to store the expiration date. Performance wise, this is not the best approach, but the script is designed like that with a clear purpose: the additional file can be used to store additional attributes, beside the expiration date. Imagine an application that crawls pages, with different modules. Each time a module crawls the page, it adds it’s result to the additional file.

The cache library in our tutorial is based only on a few functions grouped in a single class. Let’s start with the skeleton of the SimpleCache class:

class SimpleCache
{
	public function exists($key)
	{
	}

	public function get($key)
	{
	}

	public function put($key, $content)
	{
	}
}

Once we have the skeleton class, we create a test class:

// SimpleCacheTest.php - file to test the class
require_once "SimpleCache.php";

// instantiate the class
$cache = new SimpleCache();

// cache a value
$cache->put('key', 'this value');

// retrieved the cached value by key
$val = $cache->get('key');

// assert the retrieved value
if ($val != 'this value')
     echo 'Something went wrong!';
else
     echo 'Value as expected. Cache Test Passed';

the location where the cache files are stored. The location can be an absolute one or relative to the starting point of the script(in the code above is the cache subdirectory, located in the same directory where index.php is invoked from).
the expiry interval in which the cache values expire.

class SimpleCache
{
	private $cacheDir = 'cache';
	private $expiryInterval = 2592000; //30*24*60*60;

	public function setCacheDir($val) {  $this->cacheDir = $val; }
	public function setExpiryInterval($val) {  $this->expiryInterval = $val; }
	...
}

Then we implement the put function. The code is very simple: we create the path if it doesn’t exist, then we we write the data in the main cache file and the expiration interval in the additional file:

	public function put($key, $content)
	{
		$time = time(); //Current Time

		if (! file_exists($this->cacheDir))
			mkdir($this->cacheDir);

		$filename_cache = $this->cacheDir . '/' . $key . '.cache'; //Cache filename
		$filename_info = $this->cacheDir . '/' . $key . '.info'; //Cache info

		file_put_contents ($filename_cache ,  $content); // save the content
		file_put_contents ($filename_info , $time); // save the time of last cache update
	}

The method to retrieve the code is pretty simple. We try to read the expiry time from the additional file. If it exists and the data is not expired we read the content of the cache file and return it:

	public function get($key)
	{
		$filename_cache = $this->cacheDir . '/' . $key . '.cache'; //Cache filename
		$filename_info = $this->cacheDir . '/' . $key . '.info'; //Cache info

		if (file_exists($filename_cache) && file_exists($filename_info))
		{
			$cache_time = file_get_contents ($filename_info) + (int)$this->expiryInterval; //Last update time of the cache file
			$time = time(); //Current Time

			$expiry_time = (int)$time; //Expiry time for the cache

			if ((int)$cache_time >= (int)$expiry_time) //Compare last updated and current time
			{
				return file_get_contents ($filename_cache);   //Get contents from file
			}
		}

		return null;
	}

We create an additional function to check the existence of valid data in cache, similar to get function, in case we need to check it without reading it:

	public function exists($key)
	{
		$filename_cache = $this->cacheDir . '/' . $key . '.cache'; //Cache filename
		$filename_info = $this->cacheDir . '/' . $key . '.info'; //Cache info

		if (file_exists($filename_cache) && file_exists($filename_info))
		{
			$cache_time = file_get_contents ($filename_info) + (int)$this->expiryInterval; //Last update time of the cache file
			$time = time(); //Current Time

			$expiry_time = (int)$time; //Expiry time for the cache

			if ((int)$cache_time >= (int)$expiry_time) //Compare last updated and current time
			{
				return true;
			}
		}

		return false;
	}

Now that the code was written it can be testes using the test file. In a next tutorial we are going to rewrite this cache mechanism using the file modify date time instead of the additional time.

Php Class to Retrieve Alexa Rank

admin — Sun, 28 Feb 2010 22:46:43 +0000

Alexa is a service acquired by Amazon which offers a web traffic report for websites. They retrieve the data from toolbar that can be installed in different browsers, centralize the data and display reports to anyone. The most important indicator is the Alexa Rank. It represents the rank of a webpage in a list of all the websites. It’s not the 100% accurate but it gives a good indication.

Alexa does not offer any free API to obtain Alexa Rank. However there is a simple method to obtain it in the same way the Alexa Toolbar does. All you have to do is to invoke the following url(replacing php-html.net with your domain): http://data.alexa.com/data?cli=10&dat=s&url=php-html.net

The response should look like this one:

All we have to do is to take the response and extract the Alexa Rank from it. There are various options, we are just going to use a simple regular expression:

class AlexaRank
{
	public function getRequestUri($domain)
	{
		return 'http://data.alexa.com/data?cli=10&dat=s&url=' . $domain;
	}

	public function parse( $httpResponse )
	{
		preg_match( '##si', $httpResponse, $p );
		$res = ( $p[2] ) ? number_format( intval($p[2]) ):0;

		return str_replace(',', '', $res);
	}
}

Then we can simply get the alexa rank:

echo $extractor->parse(file_get_contents($extractor->getRequestUri('php-html.net')));

The extractor class contains the 2 functions one to build the url to be invoked for a domain and the second one to parse the response. This solution was chosen offer the option to use an external function that retrieve the response content. This is because for some hosting servers the file_get_contents does not work, for other curl does not work…

Remember the “use it but not abuse it” concept. Alexa didn’t expose this through a public api for some reason. If you use this function zillions times a day you will probably be detected and have the ip banned.

Model View Controller(MVC) in PHP

admin — Mon, 10 Aug 2009 08:38:57 +0000

The model view controller pattern is the most used pattern for today’s world web applications. It has been used for the first time in Smalltalk and then adopted and popularized by Java. At present there are more than a dozen PHP web frameworks based on MVC pattern.

Despite the fact that the MVC pattern is very popular in PHP, is hard to find a proper tutorial accompanied by a simple source code example. That is the purpose of this tutorial.

The model is responsible to manage the data; it stores and retrieves entities used by an application, usually from a database, and contains the logic implemented by the application.
The view (presentation) is responsible to display the data provided by the model in a specific format. It has a similar usage with the template modules present in some popular web applications, like wordpress, joomla, …
The controller handles the model and view layers to work together. The controller receives a request from the client, invoke the model to perform the requested operations and send the data to the View. The view format the data to be presented to the user, in a web application as an html output.

The above figure contains the MVC Collaboration Diagram, where the links and dependencies between figures can be observed:

Our short php example has a simple structure, putting each MVC module in one folder:

Controller

The controller is the first thing which takes a request, parse it, initialize and invoke the model and takes the model response and send it to the presentation layer. It’s practically the liant between the Model and the View, a small framework where Model and View are plugged in. In our naive php implementation the controller is implemented by only one class, named unexpectedly controller. The application entry point will be index.php. The index php file will delegate all the requests to the controller:

	// index.php file
	include_once("controller/Controller.php");

	$controller = new Controller();
	$controller->invoke();

Our Controller class has only one function and the constructor. The constructor instantiate a model class and when a request is done, the controller decide which data is required from the model. Then it calls the model class to retrieve the data. After that it calls the corresponding passing the data coming from the model. The code is extremely simple. Note that the controller does not know anything about the database or about how the page is generated.

include_once("model/Model.php");

class Controller {
     public $model;	

     public function __construct()
     {
          $this->model = new Model();
     } 

     public function invoke()
     {
          if (!isset($_GET['book']))
          {
               // no special book is requested, we'll show a list of all available books
               $books = $this->model->getBookList();
               include 'view/booklist.php';
          }
          else
          {
               // show the requested book
               $book = $this->model->getBook($_GET['book']);
               include 'view/viewbook.php';
          }
     }
}

In the following MVC Sequence Diagram it can be observed the flow during a http request:

Model and Entity Classes

storing, deleting, updating the application data. Generally it includes the database operations, but implementing the same operations invoking external web services or APIs is not an unusual at all.
encapsulating the application logic. This is the layer that should implement all the logic of the application. The most common mistakes are to implement application logic operations inside the controller or the view(presentation) layer.

In our example the model is represented by 2 classes: the “Model” class and a “Book” class. The model doesn’t need any other presentation. The “Book” class is an entity class. This class should be exposed to the View layer and represents the format exported by the Model view. In a good implementation of the MVC pattern only entity classes should be exposed by the model and they should not encapsulate any business logic. Their solely purpose is to keep data. Depending on implementation Entity objects can be replaced by xml or json chunk of data. In the above snippet you can notice how Model is returning a specific book, or a list of all available books:

include_once("model/Book.php");

class Model {
	public function getBookList()
	{
		// here goes some hardcoded values to simulate the database
		return array(
			"Jungle Book" => new Book("Jungle Book", "R. Kipling", "A classic book."),
			"Moonwalker" => new Book("Moonwalker", "J. Walker", ""),
			"PHP for Dummies" => new Book("PHP for Dummies", "Some Smart Guy", "")
		);
	}

	public function getBook($title)
	{
		// we use the previous function to get all the books and then we return the requested one.
		// in a real life scenario this will be done through a db select command
		$allBooks = $this->getBookList();
		return $allBooks[$title];
	}

}

In our example the model layer includes the Book class. In a real scenario, the model will include all the entities and the classes to persist data into the database, and the classes encapsulating the business logic.

class Book {
	public $title;
	public $author;
	public $description;

	public function __construct($title, $author, $description)
    {
        $this->title = $title;
	    $this->author = $author;
	    $this->description = $description;
    }
}

View (Presentation)

The view(presentation layer)is responsible for formating the data received from the model in a form accessible to the user. The data can come in different formats from the model: simple objects( sometimes called Value Objects), xml structures, json, …

The view should not be confused to the template mechanism sometimes they work in the same manner and address similar issues. Both will reduce the dependency of the presentation layer of from rest of the system and separates the presentation elements(html) from the code. The controller delegate the data from the model to a specific view element, usually associated to the main entity in the model. For example the operation “display account” will be associated to a “display account” view. The view layer can use a template system to render the html pages. The template mechanism can reuse specific parts of the page: header, menus, footer, lists and tables, …. Speaking in the context of the MVC pattern

In our example the view contains only 2 files one for displaying one book and the other one for displaying a list of books.

viewbook.php






	title . '
';
		echo 'Author:' . $book->author . '
';
		echo 'Description:' . $book->description . '
';

	?>

booklist.php






	 $book)
			{
				echo '';
			}

		?>
	
		Title Author Description
		'.$book->title.' '.$book->author.' '.$book->description.'

The above example is a simplified implementation in PHP. Most of the PHP web frameworks based on MVC have similar implementations, in a much better shape. However, the possibility of MVC pattern are endless. For example different layers can be implemented in different languages or distributed on different machines. AJAX applications can implements the View layer directly in Javascript in the browser, invoking JSON services. The controller can be partially implemented on client, partially on server…

the Model and View are separated, making the application more flexible.
the Model and view can be changed separately, or replaced. For example a web application can be transformed in a smart client application just by writing a new View module, or an application can use web services in the backend instead of a database, just replacing the model module.
each module can be tested and debugged separately.

The files are available for download as a zip from http://sourceforge.net/projects/mvc-php/files/mvc.zip/download

How to handle URLs in PHP

admin — Thu, 30 Jul 2009 23:15:03 +0000

URL handling is one of the tasks you have to do from time to time in PHP. Sometimes you have to do it because you want to record the referral sites, other times because you want to write your own spider or just because you want to retrieve your current URL.

PHP is a language developed around web for web developers and it contains all the functions you might need in your quests. There is a section in php documentation which groups the URL functions. Along with a few functions used to encode/decode which are rarely used the package contains the functions you can not live without:

parse_url

parse_url – a function that parses a URL and returns an associative array containing all the various components of the URL that are present.

A complete link that is parsed by parse-url should be in the following form:

scheme://username:password@host:port/path/?query#fragment

For example the following code:

parse_url('http://username:password@php-html.net:80/tutorials/?arg=value#anchor');

will return the following array:

Array
(
    [scheme] => http
    [host] => php-html.net
    [user] => username
    [pass] => password
    [path] => /tutorials
    [port] => /80
    [query] => arg=value
    [fragment] => anchor
)

You can provide a second parameter in the function to retrieve only one of the values, as a string. The possible parameters are: PHP_URL_SCHEME, PHP_URL_HOST, PHP_URL_PORT, PHP_URL_USER, PHP_URL_PASS, PHP_URL_PATH, PHP_URL_QUERY or PHP_URL_FRAGMENT:

echo parse_url('http://php-html.net/tutorials/', PHP_URL_HOST); // prints php-html.net
echo parse_url('http://php-html.net/tutorials/', PHP_URL_PATH); // prints /tutorials
...

You have to keep in mind that:
- This function does not work with relative urls.
- It should not be used for url validation, it only parses urls and splits them in components.
- It works fine on partial urls

http_build_query

http_build_query – is a complementary function that builds an url query string based on an associative (or indexed) array:

$data = array('foo'=>'bar',
              'baz'=>'boom',
              'cow'=>'milk',
              'php'=>'hypertext processor');

echo http_build_query($data); // foo=bar&baz=boom&cow=milk&php=hypertext+processor
echo http_build_query($data, '', '&'); // foo=bar&baz=boom&cow=milk&php=hypertext+processor

Encoding/Decoding urls

Base64 encoding

The base 64 encoding transforms a string to another string that can be transmitted through transport layers that are not 8-bit clean, such as mail bodies. Basically it means that a string is transformed in another string that uses a limited set of characters(ASCII). The functions base64_encode / base64_decode can be used to encode and decode any string:

$str = 'This is an encoded string';
echo base64_encode($str); // will print VGhpcyBpcyBhbiBlbmNvZGVkIHN0cmluZw==
echo base64_decode(base64_encode($str)); // will print This is an encoded string

url encoding / url decoding

There are 2 types of encoding / decoding functions designed especially for urls, with the intent to make them usable in a query part of a URL, as a convenient way to pass variables to the next page. There is a slight difference between them:

urlencode / urldecode – encodes a string replacing all non-alphanumeric characters except -_. with a percent (%) sign followed by the 2 hex digits representation. The spaces are encoded as (+) signs. It encodes strings in the same way that the posted data from a WWW form is encoded, that is the same way as in application/x-www-form-urlencoded media type.
rawurlencode / rawurldecode – It does the same job as the above function, except that it replace the spaces with percent sign followed by the hex representation: %20. This function implements the standard RFC 1738.

Getting the Current URL

There are many cases when you have to retrieve the current url for different reasons. Unfortunately php does not implement a function dedicated to this scenario, but such a function can be easily written to build the current url string from the server variables.

function current_url() {
    $isHTTPS = ( isset($_SERVER["HTTPS"]) && $_SERVER["HTTPS"] == "on" );
    $isPort = ( isset($_SERVER["SERVER_PORT"]) && ((!$isHTTPS && $_SERVER["SERVER_PORT"] != "80")
                 || ($isHTTPS && $_SERVER["SERVER_PORT"] != "443")));

    $port = ( $isPort ) ? ( ':'.$_SERVER["SERVER_PORT"] ) : '';

    //On some setups like nginx and php-fastcgi, REQUEST_URI include the query string
    if ( ($pos = strpos($_SERVER['REQUEST_URI'], '?')) === false )
    {
        // REQUEST_URI include the query string, it should be appended:

        $isQuery = ( isset($_SERVER["QUERY_STRING"]) && $_SERVER["QUERY_STRING"] != '');
        $query = ( $isQuery ) ? ( '?'.$_SERVER["QUERY_STRING"] ) : '';

        $url = ( $isHTTPS ? 'https://' : 'http://')
                    .$_SERVER["SERVER_NAME"].$port.$_SERVER["REQUEST_URI"].$query;
    }
    else
    {
        // the query string is already included in $_SERVER["REQUEST_URI"], no need to append it
        $url = ( $isHTTPS ? 'https://' : 'http://')
                    .$_SERVER["SERVER_NAME"].$port.$_SERVER["REQUEST_URI"];
    }

    return $url;
}

The function don’t need further explanations. It uses the $_SERVER variables to construct the url and checks if a port other that the default one is used and if the page is secure or not. The snippet was improved thanks to the comments from Joseph and ferdhie.

How to Write a PHP Script to Run Shell Commands from Browser

admin — Tue, 28 Jul 2009 18:44:52 +0000

It happens pretty often for me to have to run shell commands in a hosting environment. I do it all the time via a simple php script. I tested it on godaddy and dreamhost and on other hostings environments and it works fine.

Before starting the tutorial you should note that if this script is not handled carefully it can have undesired results. A wrong rm command can delete all the files you have on your hosting, so run the commands with care.

Running Shell Commands from PHP

In the first part of this tutorial we are going to see how we can run a shell command from php and how to retrieve the command ouput. The php function which is responsible to run a shell command is proc_open.

The proc_open function accepts a couple of parameters:

resource proc_open ( string $cmd
                           , array $descriptorspec
                           , array &$pipes
                         [, string $cwd
                         [, array $env
                         [, array $other_options ]]] )

We are going to use the first 3 parameters:

cmd – the command to execute. The command string will contain the full command as we would write in the shell command line, including the input parameters.
descriptorspec – is an indexed array containing the description of the pipes. The first element should contain the input pipe, the second one should contain the output pipe and the third one the stderr(the pipe where the command will return the error it encounter). Each one can be one of the types “pipe” of “file”
pipes – is another indexed array that contains the reference to the pipes that are created during process. For example if in the descriptorsspec is specified a pipe for the input, the pipe array will contain the input pipe, which can be used to write to the input stream. The same can happen with the output stream: a pipe can be used to take the output of the command.
If a pipe is not used, a file can be used instead. Usually temporary files are used. In our example we are going to use a pipe for the input and tmp files for the output and for the stderr. Because we don’t need to pass any input file to the command we are going to close the input pipe immediately, without writing anything in it.

The proc_open function will be run slightly different on windows and linux environments. Windows processes don’t return a stderr, so it can not be used to test the success of a command on and windows environment.

Here is the function we are going to use to run a command:

function cmd_exec($cmd, &$stdout, &$stderr)
{
   $outfile = tempnam(".", "cmd");
   $errfile = tempnam(".", "cmd");
   $descriptorspec = array(
       0 => array("pipe", "r"),
       1 => array("file", $outfile, "w"),
       2 => array("file", $errfile, "w")
   );
   $proc = proc_open($cmd, $descriptorspec, $pipes);

   if (!is_resource($proc)) return 255;

   fclose($pipes[0]);    //Don't really want to give any input

   $exit = proc_close($proc);
   $stdout = file($outfile);
   $stderr = file($errfile);

   unlink($outfile);
   unlink($errfile);
   return $exit;
}

Adding a Form

Now that we wrote the function to run a shell command from php, we need to write a html form from where to trigger the execution of the shell commands. First we define an html form:





Command:

And finally we add the code to run the command entered in the form:

if (isset($_POST['command']))
{
	echo 'Command: ' . $_POST['command'] . '';
	$exit = cmd_exec($_POST['command'],$stdout, $stderr);

	//print the output
	foreach ($stdout as $line)
	{
		echo "$line";
	}

	//in case there an error is returned
	foreach ($stderr as $line)
	{
		echo "$line";
	}
}

Now all you have to do is to put all the snippets described above in a php file. Of you can download it from here. You have to use with caution and keep in mind that it is not protected by password. In the next tutorial we are going to ad a login form to the script.

How to Identify Duplicate and Similar Text in Php

admin — Sun, 12 Jul 2009 11:17:33 +0000

It’s not a common problem but sometimes you have to check if 2 texts are similar. If you have to aggregate data from multiple sources you might know what I’m talking about.

The most simple thing you can try is to simply compare the 2 strings. A simple comparison will not help if one of the strings are contains an extra space. A more serious algorithm should be used for such cases. Fortunately php provides us several functions that can be used.

soundex() – accepts a string as a parameter and returns a string 4 characters long, starting with a letter. The result is called soundex key and words pronounced similarly produce the same soundex key. It should be used only for single words.
levensthein() – returns a number based on levenshtein algorithm which describes the similarity between 2 strings. It can be used only for strings with less than 255 characters.
similar_text() – calculates the similarity between two strings and can return the result as a number representing the number of matching chars in both strings or a similarity percentage.

soundex() it’s a php function which implements the soundex algorithm described by Donald Knuth in “The Art Of Computer Programming, vol. 3: Sorting And Searching”. It can be used to find similar words, misspelled words or to create indexes to simplify searches in databases when the pronunciation is known but not the spelling.

levenshtein() – levenshtein distance represents the minimal number of characters you have to replace, insert or delete to transform one string into another. The complexity of the algorithm is O(m*n). The function can be used only on string with less that 255 characters. If you want to aggregate rss feeds and eliminate duplicates, this function could be just fine if the rss items are truncated.

simple_text() – calculates the similarity between two strings. It returns the number the number of matching characters in both strings or a percentage of how similar the strings are. The function implements recursively and algorithm and has the complexity of O(N**3). The function is not so efficient as the levenshtein function but it can e used for strings more than 255 characters.

There are a few remarks about similar_text() you should consider:
- if you apply it on 2 texts of which one one is the first half of the other one the similarity would be 50% even if the strings are identically.
- the function might take a few seconds to compare strings of more than 20 000 on a regular computer.

How to Send Mail From PHP

admin — Fri, 27 Feb 2009 11:49:43 +0000

Sending mails from PHP can raise certain problems. Usually the mail is sent from php through a simple function PHP function: mail(…). However the function needs a module that should be enabled in the php ini file. Not all the hosting providers enable it and you can not make changes in php admin area in the php shared hosting. In this case the another alternative should be used. There are 2 php libraries I’ve tried to send a mail which will be described in this tutorial: PHPMailer and Mail PEAR Package.

1. Using the php mail() function.
The first alternative you should use if it available is the php mail function.

2 Using PHPMailer
The PHP Mailer is a Object Oriented PHP library that can be used to send mails through SMTP and using the send mail Linux command. It is recommended to use SMTP for sending the emails. Most of the hosting providers offer the option to configure email boxes which can be used to send mails using SMTP protocol.

Here is a piece of code that can be used to send mails through SMTP:

SMTPAuth = true; // turn on SMTP authentication
$mail->Username = "xxxx@xxxx.com"; // SMTP username
$mail->Password = "xxxxxx"; // SMTP password
$webmaster_email = "xxxx@xxxx.com"; //Reply to this email ID

$email="yyyy@yyyy.com"; // Recipients email ID
$name="name"; // Recipient's name
$mail->From = $webmaster_email;
$mail->FromName = "Webmaster";
$mail->AddAddress($email,$name);
$mail->AddReplyTo($webmaster_email,"Webmaster");
$mail->WordWrap = 50; // set word wrap
$mail->IsHTML(true); // send as HTML
$mail->Subject = "This is the subject";
$mail->Body = "Hi,This is the HTML BODY "; //HTML Body
$mail->AltBody = "This is the body when user views in plain text format"; //Text Body
if(!$mail->Send())
{
  echo "Mailer Error: " . $mail->ErrorInfo;
}
else
{
  echo "Message has been sent";
}
?>

The previous piece of code was tested sending emails through gmail accounts and worked fine.

In many cases PHPMailer seems to raise some difficulties when it is used in different accounts. The same code might work for one hosting without working on other hosting accounts and the message errors are not detailed enough to give enough hints to fix the problem.

A frequent problem raised by PHPMailer is the following Exception:Language string failed to load: instantiate. This problem is generated by the fact that the languages files can not be found and appears usually when another error must be reported and when phpmailer is not installed in the root of the application.

Svn Commands

admin — Mon, 16 Feb 2009 19:27:39 +0000

1. Svn commands on server

Create a repository – in order to create a svn repository(server) you need access on the server machine. The command can work only locally and it can not work on network paths:

// Windows:
svn admin c:\\svn\serverfiles\

// Linux:
svn admin /svn/serverfiles/

Start the server – to start a server you must run the following command(if svnserver is not present in the path you can add it or you can use the full pathname).:

//Windows:
svnserve --daemon --root c:\\svn\serverfiles\

//Linux:
svnserve --daemon --root /svn/serverfiles/

//To see all the options:
svnserve --help

2. Client Commands

Considering we have a svn server installed with a repository created, and the server is up and running, let’s add a new project to the repository(the svnserver can run on the same machine, but it’s still a server). To begin with let’s create the following structure, putting the files of out project inside the trunk server.

Once done run the following command to add the project structure in the new repository on the server and to commit the first version:

//Windows:
svn import project file:///c:/projects/project -m "Initial Version"

//Linux:
svn import project file:///projects/project -m "Initial Version"

svn co
svn add –force .
svn commit -m “this is a message”

show changed files:
svn log -r 1:2 -v

Ignore Command:

Ignore a file:
svn propset svn:ignore .project .

Ignore a directory and all the files inside it:
svn propset svn:ignore ‘*’ classes/

If the location of the repository is changed you can use the following command to switch the local working copy(checked out from the old location of the repository), to the new one:
svn switch –relocate svn://oldlocation.com/svn/project/trunk http://newlocation.org/repository/project/trunk

svn switch –relocate svn://anonsvn.opensource.apple.com/svn/webkit/trunk \

http://svn.webkit.org/repository/webkit/trunk

Title	Author	Description
'.$book->title.'	'.$book->author.'	'.$book->description.'