» DoYourself.org » PHP

Process XML configuration files with PHP

CarcaBot — Fri, 30 Jul 2010 23:48:32 +0000

Summary: XML provides a convenient, easy-to-use expression language for an application’s configuration files. To extract this information into a PHP script can sometimes pose a challenge. That’s where the XJConf for PHP package comes in: It provides an API to read XML-encoded information and directly use it to configure PHP data structures like scalars, arrays and PHP objects. This article introduces the package and demonstrates some useful real-world applications of its usage, including configuring complex class trees and building a Web-based configuration interface.

Introduction

As a general rule, when you develop any reasonably-complex piece of software, it’s a good idea to take time to identify the product’s key configuration variables, and then separate these from the standard variable namespace and place them in a separate area. With this process, you can create a centralized repository of application configuration information and simplify the task of modifying the product to work in different environment. It can also help increase a developer’s familiarity with, and understanding of, the key pieces of information needed to get the product up and running.

Traditionally, configuration variables are stored in one (or more) configuration files. The variables are often expressed using XML, which provides a flexible framework for document authors to describe content using custom tags and markup. In most cases, developers also need to construct a user interface to interact with these XML configuration files, to read and use the configuration data contained therein.

XJConf for PHP helps PHP developers with this task. This open-source package provides an API to extract XML-encoded information from a configuration file and turn it into a native data structure, for immediate use within an application. As such, it provides a robust, easy-to-use widget for any PHP application.

Install required software

The XJConf package is maintained by Frank Kleine and Stephan Schmidt, and released to the PHP community under the GNU LGPL. It requires PHP 5.0 (or better), and the easiest way to install it is with the automated PEAR installer, which should have been included by default with your PHP build. To install it, simply issue the following commands at your shell prompt:

shell> pear channel-discover pear.php-tools.net

shell> pear install pat/XJConfForPHP-alpha

The PEAR installer will now connect to the new channel, download the package, and install it to the appropriate location on your system. This article uses XJConf for PHP V. 0.2.0.

To install the package manually, visit its home page, download the source code archive, and manually uncompress the files to the desired location. You’ll find links to the package home page, as well as to in-development builds, in the Resources of this article. Note that this manual installation process presupposes some knowledge of PEAR’s package organization structure.

One final dependency: the XJConf for PHP package requires that you enable the xmlreader extension of PHP. This extension is enabled by default in PHP 5.1.0 or later. Users of older PHP versions can obtain detailed information and activation instructions from the appropriate section of the PHP manual (see Resources for links).

This article assumes that you have a working knowledge of PHP and XML, and are comfortable using PHP’s simple and complex data types. It assumes a reasonable degree of knowledge of both general OOP concepts and the specific class model used by PHP 5, as well as some knowledge of XML tree generation with PHP’s Document Object Model (DOM) extension.

Understand basic usage

XJConf provides PHP application developers with an API that reads XML-formatted configuration files and converts the data within them to native PHP data types or custom objects. These data types or objects can then be used within a PHP script in the normal fashion. Any XJConf-based program has three components:

The XML-formatted configuration file
A PHP script that parses and extracts data from the configuration file
A definition file, which maps elements from the configuration file into native PHP structures

The best way to illustrate the interaction of these three components is with an example. Consider Listing 1, which shows an XML configuration file for a pet housecat:
Listing 1. An XML configuration file (cat.xml)



    Martha
    4
    Siamese

Now, suppose you need to read these configuration values into your PHP application. The first step is to create a definition file, which maps each element from Listing 1 to a native PHP data type. Listing 2 illustrates such a file:
Listing 2. An XJConf definition file (defs.xml)

Take a moment to study the structure of this definition file, because understanding it will be critical for all subsequent examples in this article. An outer element encloses a series of elements, each of which represents an element from the XML configuration file. Each must have at least the name and type attributes. The name attribute specifies an element name from the configuration file, while the type attribute specifies the corresponding PHP data type. Common primitive types are string, integer and boolean; however, as you’ll see a little further along in this article, you can also map an element to an array or a custom class.

All that’s left now is a PHP script to initialize an instance of XJConf and use the definitions in Listing 2 to retrieve configuration data. Listing 3 illustrates the required PHP code:
Listing 3. A PHP script to read XML configuration data

addDefinition('defs.xml');

// parse XML
$conf->parse('cat.xml');

// access XML element values
echo $conf->getConfigValue('name') . " is " . $conf->getConfigValue('breed')
. " and " . $conf->getConfigValue('age') . " year(s) old.";
?>

Listing 4 illustrates the output of this script:
Listing 4. The output generated by Listing 3

Martha is Siamese and 4 year(s) old.

Look closely at Listing 3, and it’s easy to understand what it does. The listing first reads in the required class definition files, and then loads and initializes an XJConf facade object. In XJConf, this object provides a common interface to the DefinitionParser method, which handles the definition file in Listing 2; and the XMLParser method, which handles the XML-formatted configuration file in Listing 1.

First, the script calls the addDefinition() method of the XJConfFacade object to read the various tag definitions from Listing 2 and attach these definitions to the object. Next, the parse() method of the object parses the configuration data file in Listing 1. During this parsing process, the elements and data in the configuration file are converted into key-value pairs, similar to that found in a PHP associative array.

Once parsing is complete (the process will stop with an error message if your XML file definition has an error), you can access the keys and values with the getConfigValue() method of the XJConfFacade object, which accepts a key name as argument and returns the corresponding value. Thus, in Listing 4, a call to getConfigValue('name') returns the value of the element from the configuration file cat.xml (Listing 1), which in this case happens to be Martha.

Now, try to edit the values in the configuration file (Listing 1) such that it looks like Listing 5:
Listing 5. A revised configuration file



    Tom
    1
    Norwegian

And now, when you re-run the PHP script in Listing 4, you’ll see the revised output shown in Listing 6:
Listing 6. The revised output of Listing 4

Tom is Norwegian and 1 year(s) old.

Notice that you didn’t have to change a single line of Listing 4 to access the revised configuration data. Thus, the benefits of storing configuration variables in a separate file and using a tool like XJConf to access them should be clear: Global changes become as simple as altering a single file, with the changes reflecting instantly across the application.

Configure arrays

Simple data types are just the tip of the iceberg—XJConf also lets you define collections of related configuration variables, and converts these into native PHP arrays. XJConf supports both numerically-indexed and associative arrays.

To see how this works, consider Listing 7, which sets up a configuration file containing a collection of values:
Listing 7. A data file containing a collection of related items (collection.xml)



    
        apples
        pears
        oranges

Listing 8 contains the corresponding definition file:
Listing 8. A definition file (defs.xml)

Notice the values of the type attribute in this definition file: The element is mapped to an array, while the nested s are mapped to simple string values. Notice also a new attribute introduced in this listing: The keyAttribute attribute, which tells XJConf which element attribute to consider when it sets the keys of the output associative array.

Listing 9 has the PHP code that parses and displays the configuration data:
Listing 9. A PHP script to read XML configuration data into a PHP array

addDefinition('defs.xml');

// parse XML
$xml->parse('collection.xml');

// access XML element values
print_r($xml->getConfigValue('collection'));
?>

Listing 10 displays the output:
Listing 10. The output of Listing 9

Array
(
    [a] => apples
    [p] => pears
    [o] => oranges
)

By setting the keyAttribute to letter, XJConf automatically assigns the value of the letter attribute of every element to the corresponding key of the output associative array.

Prefer a regular numerically-indexed array? Simply alter the definition file and set the value of the keyAttribute to the special symbol __none:
Listing 11. The revised definition file (defs.xml)

And Listing 12 now displays the revised output:
Listing 12. The revised output of Listing 9

Array
(
    [0] => apples
    [1] => pears
    [2] => oranges
)

Now consider a realistic application of this feature: Configuring a database connection from variables present in an XML configuration file. Assume that the configuration file looks something like Listing 13:
Listing 13. A XML database configuration file (conf.xml)



    
        root
        mysql123
        localhost
        test

Further, assume that the task is to read these configuration values into an array, and then use this array to connect to a MySQL database server. The first step, then, is to map the XML into an array using a definitions file like the one in Listing 14:
Listing 14. A definition file (defs.xml)

Listing 15 has the PHP script that uses this data to attempt a MySQL database connection:
Listing 15. A PHP script to read and use database configuration data from an XML file

addDefinition('defs.xml');

// parse XML
$xml->parse('conf.xml');

// access database configuration array
$db = $xml->getConfigValue('database');

// test MySQL connection
$conn = mysql_connect($db['host'], $db['user'], $db['pass'])
or die('Connection error!');
mysql_select_db($db['db'], $conn) or die('Database selection error!');
mysql_close($conn);
echo 'Database test successful';
?>

Listing 15 uses XJConf to create and populate an array named $db with data from the configuration file conf.xml. This array is then used to open a connection to the MySQL database server and select a database for use. As explained in earlier examples, the key to the script lies in the definition file, defs.xml, which tells XJConf how to map elements from the configuration file into a PHP array.

Configure classes and objects

One of the most powerful features in XJConf, however, lies in its support for PHP classes and objects. With XJConf, it’s quite simple to instantiate custom objects from an XML configuration file, and even configure the properties of said object using the data present in the configuration file.

To illustrate this, let’s first define a simple RectangularObject class, which exposes three key properties to the configuration API: the length, width, and height. This class also exposes a getVolume() method, which uses these properties to calculate the volume of the object. Listing 16 has the code:
Listing 16. A PHP class definition (RectangularObject.php)

length = $l;
    }

    function setHeight($h) {
        $this->height = $h;
    }

    function setWidth($w) {
        $this->width = $w;
    }

    // declare other methods
    function getVolume() {
        return ($this->length * $this->width * $this->height);
    }
}
?>

Listing 17 contains XML-formatted configuration data for one such RectangularObject class:
Listing 17. An XML configuration file (data.xml)

Mapping data into an object instance is fairly easy. All you need to do is set the type attribute to the name of the class you wish to instantiate. Listing 18 illustrates the corresponding definition:
Listing 18. An XJConf definition file (defs.xml)

Assuming that the setter methods are correctly named, XJConf will do two things

Instantiate an object of that class.
Call setter methods for each nested element to automatically configure the properties of the object.

Thus, the setLength() method is automatically invoked for the element, the setHeight() method for the element, and so on.

Listings 19 and 20 illustrate the PHP code and output respectively:
Listing 19. A PHP script to instantiate and configure an object from XML data

addDefinition('defs.xml');

// parse XML
$xml->parse('data.xml');

// access object instance
$instance = $xml->getConfigValue('rectangularobject');
print 'The volume of the object is: ' . $instance->getVolume() . ' units';
?>

Listing 20 displays the output:
Listing 20. The output of Listing 19

The volume of the object is: 3000 units

Configure default and mandatory Values

You can write an XML configuration file using attributes  instead of nested tags, and use these attributes to configure an object  instance.  To see how this works in practice, first revise Listing 17 such that it uses attributes instead of nested elements:

Listing 21. The revised XML configuration file (data.xml)






    






Obviously, this necessitates a change in the definition file as well:

Listing 22. The revised XJConf definition file (defs.xml)





    
        
        
        
    






This change consists of replacing the  elements with  elements, thus telling XJConf to consider attributes of the named tag when setting object properties, rather than the CDATA content of its child elements.
You can also possible to set default values for a particular configuration           variable, or mark a certain configuration variable as mandatory, through skillful           use of the default and required attributes in the definition file. Consider Listing 23, which makes the length and width configuration variables mandatory and sets a default value for the height:

Listing 23. An XJConf definition file with 'default' and 'required' constraints





    
        
        
        
    






If you now try to read a configuration file which is missing a required value, XJConf will throw a MissingAttributeException (Figure 1):

Figure 1. An XJConf exception thrown when a required attribute is missing



In previous examples, you saw that XJConf can automatically call the           appropriate setter methods to configure object instances. This automatic           invocation of setter methods depends greatly on the correct naming of the setter           methods for easy identification and mapping to element/attribute names. If you           don't like this, you can also explicitly define the setter method for each           element/attribute, with the setter attribute in the           definition file. Listing 24 illustrates this use of  custom setter methods for the length and width attributes:

Listing 24. An XJConf definition file with custom setter methods





    
        
        
        
    






As you might know, a new feature in PHP 5 is the introduction of the special           __set() and __get() overloading methods, which you can use to set object  properties even if a setter or getter method is not explicitly defined  for that property. Listing 25 revises the class definition from Listing 16 to illustrate how this works in practice:

Listing 25. A PHP class definition with __set() and __get()




$property = $value;
    }

    // declare generic getter method
    public function __get($property) {
        return $this->property;
    }

    // declare other methods
    function getVolume() {
        return ($this->length * $this->width * $this->height);
    }
}
?>





Assume the same data and definition files as in Listing 17 and Listing 18 respectively and try to run the PHP script in Listing 26:

Listing 26. A PHP script to configure an object using an XJConf configuration file




addDefinition('defs.xml');

// parse XML
$xml->parse('data.xml');

// access object instance
$instance = $xml->getConfigValue('rectangularobject');
print 'The volume of the object is: ' . $instance->getVolume() . ' units';
?>





You should see the following output:

Listing 27. The output of Listing 26




The volume of the object is: 3000 units





You'll notice that despite the lack of explicitly-defined  setter methods in the class definition, XJConf was still able to  configure the object's properties through the __set() method. This feature can, again, significantly reduce the length of your  class definitions and make your application code simpler to maintain  and easier to read.
In versions of XJConf for PHP prior to V. 0.2.0, these special overloading           methods are not supported and attempts to use them will generate a fatal error in your PHP script.
Finally, you'll see that all the previous listings explicitly load the class           definition files, before parsing the XML definitions and data. XJConf can           automatically do this task for you using its own class loader as needed;           examples illustrating this feature are available in the XJConf for PHP package           (See Resources). You should definitely look at           them if you work with numerous classes in your application.
Project: Configure a complex class tree
As the previous listings demonstrated, XJConf can use either attributes or           child elements to correctly configure an instantiated object. In all cases but           one, therefore, it is your relative comfort level with these two techniques that           will define your approach. However, in one case, the use of  child elements           offers an advantage over attributes: When you link one or more objects to another in a complex tree.
To illustrate, consider Listing 28, which defines some classes:

Listing 28. Some PHP class definitions (App.php)




host = $confArray['host'];
        }
        if (isset($confArray['port'])) {
            $this->port = $confArray['port'];
        }
        if (isset($confArray['user'])) {
            $this->user = $confArray['user'];
        }
        if (isset($confArray['pass'])) {
            $this->pass = $confArray['pass'];
        }
    }
}

// these inherit from the Config class
class DBConfig extends Config {
}

class SMTPConfig extends Config {
}

// application class
class App {
    // declare properties
    public $DBConfig;
    public $SMTPConfig;

    // declare constructor
    public function __construct() {
        return true;
    }

    // declare setter methods
    function setDBConfig($db) {
        $this->DBConfig = $db;
    }
    function setSMTPConfig($smtp) {
        $this->SMTPConfig = $smtp;
    }    

    // declare getter methods
    function getDBConfig() {
        return $this->DBConfig;
    }
    function getSMTPConfig() {
        return $this->SMTPConfig;
    }
}
?>





Listing 28 begins with the Config class, which exposes a generic API to receive an associative array of server access parameters. The DBConfig and SMTPConfig classes are sub-classes of this Config class, and are intended specifically to store access parameters for a database server and an SMTP server respectively. DBConfig and SMTPConfig objects are, in turn, used by the App class, which represents an application. This App class exposes setter and getter methods to set and retrieve the corresponding Config class as needed.
Configuration of these classes occurs through an XML configuration file, such as the one in Listing 29:

Listing 29. An XML configuration file (conf.xml)






  
    
      
        localhost
        guest
        mysql123
      
    

    
      
        mail.domain.com
        sluggo
        mypass
        25
      
    
  






The glue needed to convert the XML data in Listing 29 into a fully-configured App object instance lies in the definition file (Listing 30) and the corresponding PHP script (Listing 31). Look at the definition file first:

Listing 30. An XJConf definition file (defs.xml)





  
    
        
            
            
            
        
    
    
        
            
            
            
            
        
    
  






How does this work? It's not really as difficult as it looks:

When XJConf encounters an  element in           the configuration file, it instantiates an App object           instance. From the class definitions in Listing 28, you'll           see that this App object exposes the setDBConfig() and setSMTPConfig() methods.
 When XJConf next encounters a  or  element, it           instantiates a DBConfig or SMTPConfig object and invokes the setConfig() setter method of the object. The input to this setter method is an  array of configuration parameters, which is natively created from the  element and its children.
The DBConfig and SMTPConfig objects created in step 2 are then attached back to the App object through the setter methods setDBConfig() and setSMTPConfig(). You'll notice that these methods are also named in the definition file through the setter attribute.
The resulting App object instance is then retrieved from within a PHP script by calling getConfigValue(). In a similar vein, the instantiated and configured           DBConfig and SMTPConfig objects can also be retrieved, by calling App::getDBConfig() or App::getSMTPConfig(). You can see this in Listing 31:

Listing 31. A PHP script to configure a complex class tree




addDefinition('defs.xml');

// parse XML
$xml->parse('conf.xml');

// access objects
$app = $xml->getConfigValue('app');
$db = $app->getDBConfig();
$smtp = $app->getSMTPConfig();

// display App object
print_r($app);
?>





Listing 32 displays the output:

Listing 32. The output of Listing 31




App Object
(
    [DBConfig] => DBConfig Object
        (
            [host:private] => localhost
            [port:private] =>
            [user:private] => guest
            [pass:private] => mysql123
        )

    [SMTPConfig] => SMTPConfig Object
        (
            [host:private] => mail.domain.com
            [port:private] => 25
            [user:private] => sluggo
            [pass:private] => mypass
        )

)

Project: Build a web-based           configuration interface

Another common real-world requirement for many projects  is a Web-based           configuration tool, which allows users to input configuration  data through a Web           form and saves this to a file in XML format. XJConf has  limited usefulness in           this context. While the package provides a full-featured API  to read           XML-formatted configuration data into PHP data structures, it  does not offer any           methods to write data back to a file. Thus, in these  situations, it is necessary           to supplement XJConf with the DOM extension in PHP, which  provides an API to dynamically construct an XML tree and write it to a  file.

Listing 33 demonstrates the use of these two tools:

Listing 33. A PHP script to edit and save configuration data to a file




addDefinition($defsFile);

        // parse XML
        $xml->parse($dataFile);
    }
?>

 
 
  Configuration
  
   
    
     POP3 host name
     
    
    
     POP3 port
     
    
    
     POP3 user name
     
    
    
     POP3 user password
     
    
    
     
    
   
  
 

createElement('conf');
    $dom->appendChild($conf);    

    // attach child nodes
    $host = new DOMElement('host', $_POST['pop3_host']);
    $port = new DOMElement('port', $_POST['pop3_port']);
    $user = new DOMElement('user', $_POST['pop3_user']);
    $pass = new DOMElement('pass', $_POST['pop3_pass']);
    $conf->appendChild($host);
    $conf->appendChild($port);
    $conf->appendChild($user);
    $conf->appendChild($pass);

    // save to configuration file
    $dom->formatOutput = true;
    if ($dom->save($dataFile)) {
        echo 'Configuration successfully saved!';
    }
}
?>





Listing 33 is divided into two parts: a form which displays the current  configuration (if available) and allows the user to edit it, and a form  processor, which accepts the new configuration and saves it to a file.  XJConf is used in the first half of the script, to parse the XML  configuration file and retrieve its contents into PHP variables; these  variables are then used to pre-fill the fields of the Web form.
Listing 34 contains the simple definition file used by Listing 33:

Listing 34. An XJConf definition file (defs.xml)





  
  
  
  






Once the form is submitted, the DOM extension in PHP takes over. A DOMDocument instance is created, and child elements are attached to it holding the  configuration values input by the user. Once the entire DOM tree has  been constructed, it's written back to the configuration file using the DOMDocument::save() method.
Figure 2 illustrates what the form looks like:

Figure 2. A Web form to edit and save configuration data



And Listing 35 demonstrates one such configuration file written by this script:

Listing 35. An example file created by Listing 34






  localhost
  110
  joelle
  guessme






As the previous listings illustrate, the XJConf package  provides an           easy-to-use, flexible API that reads XML-formatted  configuration files and           converts the values found therein into PHP data structures. In  addition to           simple string and numeric values, it also supports the use of  arrays and           objects, and includes built-in intelligence to automatically  configure           newly-instantiated objects through setter methods. For all  these reasons, it's a           worthy addition to the toolkit of any PHP developer. Try it  out the next time you need a interface between your PHP application and  your XML configuration file, and see for yourself!
 

Resources
Learn

The XJConf for PHP Web site: Find more information on the XJConf package.
 The Stubbles project: See XJConf for PHP in action. With this PHP 5 framework,  combine your favorite features from other programming languages and  frameworks. Use only  the packages you like and combine it with PEAR,  the Zend Framework or any other PHP-based framework.
 XJConf Timeline: Track development and news of XJConf for PHP.
 XMLReader functions: Obtain instructions for to activate PHP's xmlreader extension.
 More PEAR packages related to PHP and XML development: Find other PEAR packages related to PHP and XML development.
 developerWorks XML zone: Get the resources you need to advance your skills in the XML arena with articles, tutorials, forums, and more.
 The technology bookstore: Browse for books on these and other technical topics.
 IBM XML certification: Find out how you can become an IBM-Certified Developer in XML and related technologies.
 XML technical library: See the developerWorks XML Zone for a wide range of technical articles and tips, tutorials, standards, and IBM Redbooks.
 developerWorks technical events and webcasts: Stay current with technology in these sessions.

Get products and technologies

  XJConf for PHP package: Download this API.
 IBM trial software: Build your next development project with trial software available for download directly from developerWorks.

Discuss

Participate in the discussion forum.
 XML zone discussion forums: Participate in any of several XML-centered forums.
 developerWorks blogs: Check out these blogs and get involved in the developerWorks community.
 XML zone discussion forums: Participate in any of several XML-centered forums.

PHP cannot connect to mysql when run inside Apache

CarcaBot — Fri, 30 Jul 2010 23:41:17 +0000

I ran into a very strange issue when Apache/PHP/MySQL.
What happend was my php code suddenly cannot connect to mysql on another machine any more. The error message is:

mysqli_connect() [function.mysqli-connect]: (HY000/2003): Can't connect to MySQL server on '218.241.156.222' (13)

The strange thing was that if I connect mySQL from command line, even run the same code by php directly from command line, it worked just fine.

After searched around, I finally found the answer. Looks like it has something to do with SELinux settings.

To fix the issue, I only need to run:

setsebool httpd_can_network_connect_db 1

Before I ran the script, the file content of /selinux/booleans/httpd_can_network_connect_db was:
0 0

After I ran the script, content changed to:
1 1

How do I expire a PHP session after 30 minutes?

CarcaBot — Tue, 10 Nov 2009 06:50:33 +0000

You should implement a session timeout on your own. Both session.gc_maxlifetime and session.cookie_lifetime are not reliable. The reason for that is:

First:

session.gc_maxlifetime
session.gc_maxlifetime
specifies the number of seconds after which data will be seen as
‘garbage’ and cleaned up. Garbage collection occurs during session
start.

But the garbage collector is only started with a probability of session.gc_probability devided by session.gc_divisor. And using the default values for that options (1 and 100), the chance is only at 1%.

Furthermore the age of the session data is calculated on the fileâ€™s last modification date and not the last access date:

Note: If you are using the default
file-based session handler, your filesystem must keep track of access
times (atime). Windows FAT does not so you will have to come up with
another way to handle garbage collecting your session if you are stuck
with a FAT filesystem or any other filesystem where atime tracking is
not available. Since PHP 4.2.3 it has used mtime (modified date)
instead of atime. So, you won’t have problems with filesystems where
atime tracking is not available.

So it additionally might occur that a session data file is deleted while the session itself is still considered as valid.

And second:

session.cookie_lifetime
session.cookie_lifetime specifies the lifetime of the cookie in seconds which is sent to the browser. [â€¦]

This does only affect the cookie lifetime. But the session itself
may be still valid. Itâ€™s the serverâ€™s task to invalidate a session, not
the clientâ€™s.

So the best solution would be to implement a session timeout on your own:

if (!isset($_SESSION['CREATED'])) {    $_SESSION['CREATED'] = time();} else if (time() - $_SESSION['CREATED'] > 1800) {    // session started more than 30 minates ago    session_destroy();    $_SESSION = array();}

You can scrap sessions after a certain lifespan by using the session.gc-maxlifetime ini setting:

ini_set('session.gc-maxlifetime', 60*30);

Manipulate Zip Files with PHP

CarcaBot — Sun, 25 Oct 2009 08:48:35 +0000

Back in the olden days the easiest way to create zip files using php
was to have the operating system (OS) do it. Sure, there were modules
you could compile php with but really affected portability. So using
the OS wasnâ€™t too big of an issue but it still wasnâ€™t optimal.

Zip Files

The Old Way

Assuming the OS was Linux, and if you were doing php web development
it probably was, youâ€™d execute a call like the below to create a
gzipped archive:

exec(tar cfvz ".$WhereBackup."/".$Name.".tar.gz ".$whatBackup.");?>

The above sucks for a couple reasons. For one, it requires a pretty
large security hole to not be plugged; exec allows piping commands to
the OS directly. For another, the above method will only work on Linux;
Windows doesnâ€™t have a â€œtarâ€ command.

The biggest reason the above sucked, for me at least, was that the
layman doesnâ€™t understand the tar.gz file extension. I canâ€™t count the
number of times Iâ€™ve had to explain to a client or colleague that
tar.gz is, as far as their needs go, that tar.gz is ok. â€œYou can open
it in WinZip or WinRar.â€, Iâ€™d say. Sighâ€¦

Enter PclZip

PclZip
is a php class that creates and manage ZIP formatted archives. PclZip
works on both Windows and Linux and is pretty easy to use. Thereâ€™s a
pretty extensive user manual too.

I first heard about it while writing the WordPress plugin
iTunes-Data. I wanted to allow the upload of the iTunes XML files but
mine was over 10MB so testing was becomingâ€¦ inconvenient. I knew
WordPress could manipulate zip archives so I took a look under the hood
and the was PclZip.

Anyway, you can create zip files, remove files from existing zip
files and extract zip files using the PclZip class. Below are a couple
examples of how to do each.

The Basics

The most important thing to know about using PclZip is that the
PclZip object must be instantiated with a â€œ.zipâ€ file being passed. It
doesnâ€™t matter if youâ€™re creating, extracting or modifying, you have to
pass the file you want to manipulate before you do anything else.

require_once('pclzip.lib.php');$archive = new PclZip('tmp/archive.zip');?>

Optional Arguments

PclZip allows for detailed control over archives through the use of optional arguments that get passed at the tail end of functions. According to the official site:

The optional arguments are identified by a name, which is in reality a
static integer value. The value of the argument can be a single value
or a list of values. In some cases they does not take a value, their
name is enought to indicate a specific action to the method.

Thereâ€™s far too many arguments you can use so I wonâ€™t bother listing
them all here but thereâ€™s a complete list at the end of the article.

Create a Zip File

To create a zip file you have to pass the name of the archive you
want to create to the object. The file passed will be where to the
archive will be created.

You can include multiple files by either passing the directory, if
you want the entire directory or by using a couple different methods to
pass individual files and directories; arrays or a csv string.

require_once('pclzip.lib.php');$archive = new PclZip('tmp/archive.zip'); //includes the file "debug.cl" and the directory "logs"$files = './debug.cl,./logs/';if ($archive->create($files) == 0) {	die('Error : '.$archive->errorInfo(true));}?>

require_once('pclzip.lib.php');$archive = new PclZip('tmp/archive.zip'); //same as above$files = array('./debug.cl','./logs/');if ($archive->create($files) == 0) {	die('Error : '.$archive->errorInfo(true));}?>

Extracting Files from Archive

There are quite a few options for extracting files from a zip
archive. PclZip contains a pretty extensive filtering mechanism that
allows for some pretty selective extractions.

By default when extracting the files from an archive PclZip puts the files relative to where the script is executed.

$archive = new PclZip('tmp/archive.zip');if ($archive->extract() == 0) {	die("Error : ".$archive->errorInfo(true));}

You can explicitly state where the archive files are extracted by
setting a value to the â€œPCLZIP_OPT_PATHâ€ parameter. The below extracts
all the files to the â€œ./tmpâ€ directory:

$archive = new PclZip('tmp/archive.zip');if ($archive->extract(PCLZIP_OPT_PATH, "./tmp") == 0) {	die("Error : ".$archive->errorInfo(true));}

Optional Argument List

PCLZIP_OPT_PATH
PCLZIP_OPT_ADD_PATH
PCLZIP_OPT_REMOVE_PATH
PCLZIP_OPT_REMOVE_ALL_PATH
PCLZIP_OPT_SET_CHMOD
PCLZIP_OPT_BY_NAME
PCLZIP_OPT_BY_EREG
PCLZIP_OPT_BY_PREG
PCLZIP_OPT_BY_INDEX
PCLZIP_OPT_EXTRACT_AS_STRING
PCLZIP_OPT_EXTRACT_IN_OUTPUT
PCLZIP_OPT_NO_COMPRESSION
PCLZIP_OPT_COMMENT
PCLZIP_OPT_ADD_COMMENT
PCLZIP_OPT_PREPEND_COMMENT
PCLZIP_OPT_REPLACE_NEWER
PCLZIP_OPT_EXTRACT_DIR_RESTRICTION
PCLZIP_OPT_ADD_TEMP_FILE_ON
PCLZIP_OPT_ADD_TEMP_FILE_THRESHOLD
PCLZIP_OPT_ADD_TEMP_FILE_OFF

How to unzip ZIP files with PHP

CarcaBot — Sun, 25 Oct 2009 08:47:54 +0000

How to automatically unzip uploaded zip files with PHP

I wanted to upload a zip file with php script and unzip it within
the server running PHP and linux. How to do it? i am documenting here
about a solution to unpack uploaded zip files locally within the server
with PHP.

well! it can be done in 3 ways. I

1. Using PHP exec command
2. suPHP (Alternative to PHPsuexec)
3. Get Pclzip class library. (create and extract ZIP files
4. Using Zziplib with PHP

I was successful with (3) option.

I tried the first option of using php exec command calling system level but it never worked for me and it just kept getting checkdir errors in my apache log.

// uses unzip command just like in commandline
//
//
echo system(‘unzip uploads/test.zip’,$output);
print_r($output);
?>

checkdir error: cannot create ithemex
unable to process xtheme/images/mini-archive.gif.
checkdir error: cannot create ithemex
unable to process itheme-x/images/mini-archive.png.

Using suPHP

suPHP is a good method just because instead of apache running as
nobody/apache it runs under user account ownership. Basically what this
means that it will have no problem with file permissions for zip files.
Another great advantage of suphp is security (it restricts local users
reading php files).

Unfortunately i couldnt use suphp because it needs PHP to be running as CGI, but mine was apache module. I couldnt use suPHP

Using Pclzip class for Zip files

This method worked best for me. I uploaded a zip and it cleanly unpacked within my server. Just download the pclzip class library.
Set the folder permissions to 755 where you are unpacking the files. It
need not be 777. If that 755 doesnt work set the ownership and
usergroup to apache or nobody.

Now upload a sample zip file test.zip and put the following code in php file

require_once(‘pclzip.lib.php’);
$archive = new PclZip(‘test.zip’);
if (($v_result_list = $archive->extract(PCLZIP_OPT_PATH, ‘uploads’)) == 0) {
die(“Error : ”.$archive->errorInfo(true));
}
echo
“
```
”;  
```
var_dump($v_result_list);
echo “”;
>

PCLZIP_OPT_PATH, â€˜uploadsâ€™ -> is the destination unzip folder (give it 777 or 755 permissions)

Just the php script and you will see error codes if any. In my case it worked perfectly fine unpacking the zip file. Refer to Pclzip documentation.

Note: You must have Zlib support installed for this script to work. To install Zlib with PHP just do yum install zlib zip php-zip

Dont forget to check apache logs to trace the exact error!

Perfect PHP Pagination

CarcaBot — Wed, 12 Aug 2009 10:12:02 +0000

Pagination is a topic that has been done to death — dozens
of articles and reference classes can be found for the management of
result sets … however (and you knew there was a “however” coming
there, didn’t you?) I’ve always been disgruntled with the current
offerings to date. In this article I offer an improved solution.

Some pagination classes require parameters, such as a database
resource and an SQL string or two, to be passed to the constructor.
Classes that utilize this approach are lacking in flexibility – what if
you require a different formatting of page numbers at the top and
bottom of your pages, for example? Do you then have to modify some
output function, or subclass the entire class, just to override that
one method? These potential “solutions” are restrictive and don’t
encourage code reuse.

This tutorial is an attempt to further abstract a class for managing
result pagination, thereby removing its dependencies on database
connections and SQL queries. The approach I’ll discuss provides a
measure of flexibility, allowing the developer to create his or her
very own page layouts, and simply register them with the class through
the use of an object oriented design pattern known as the Strategy
Design Pattern.

What Is the Strategy Design Pattern?

Consider the following: you have on your site a handful of web pages
for which the results of a query are paged. Your site uses a function
or class that handles the retrieval of your results and the publishing
of your paged links.

This is all well and good until you decide to change the layout of
the paged links on one (or all) of the pages. In doing so, you’re most
likely going to have to modify the method to which this responsibility
was delegated.

A better solution would be to create as many layouts as you like,
and dynamically choose the one you desire at runtime. The Strategy
Design Pattern allows you to do this. In a nutshell, the Strategy
Design Pattern is an object oriented design pattern used by a class
that wants to swap behavior at run time.

Using the polymorphic capabilities of PHP, a container class (such
as the Paginated class that we’ll build in this article) uses an object
that implements an interface, and defines concrete implementations for
the methods defined in that interface.

While an interface cannot be instantiated, it can reference
implementing classes. So when we create a new layout, we can let the
strategy or interface within the container (the Paginated class)
reference the layouts dynamically at runtime. Calls that produce the
paged links will therefore produce a page that’s rendered with the
currently referenced layout.

Required Files

As I mentioned, this tutorial is not about the mechanics of how
results are paged, but how to use an interface to implement this logic
while retaining flexibility. I’ve provided as a starting point a class
that contains functionality for registering primitive arrays or objects
- the Paginated class — as well as an interface that all of our page
layouts must implement (PageLayout) and an implementation for a page layout (DoubleBarLayout). And all the code we’ll use in the article is available for download.

A Basic Example

The following examples use an array of strings. Here’s my data set:

Andrew
Bernard
Castello
Dennis
Ernie
Frank
Greg
Henry
Isac
Jax
Kester
Leonard
Matthew
Nigel
Oscar

However, this code could easily be extended to use an array of
integers, characters, or other objects that have been fetched from a
previous database call.

Here’s how we’d use the Paginated class:

require_once "Paginated.php";


//create an array of names in alphabetic order 

$names = array("Andrew", "Bernard", "Castello", "Dennis", "Ernie",

Frank",   Greg", "Henry", "Isac", "Jax", "Kester", "Leonard",

"Matthew", "Nigel", "Oscar"); 

   

$pagedResults = new Paginated($names, 10, 1); 

   

echo "
"; 

   

while($row = $pagedResults->fetchPagedRow()) { 

  echo "{$row}
"; 

} 

   

echo "
"; 

?>

First, we include the Paginated class and register an array with the constructor. The constructor takes three arguments, the final two of which are optional:

The first parameter is the array of items to display
– as I mentioned, these can be primitive data types or more complex
objects.

The second parameter is the number of results we want to display on a page. By default, this figure is set to ten.

The third parameter is the current page number.

In the above example, we’ve used the constant 1 to
specify “page 1″, however you’re probably going to want to pass this as
a parameter from the query string (more on this later). If an invalid
page is supplied to the constructor, the page will default to 1.

By calling the fetchPagedRow method from within the
while loop, our code iterates through the array, printing out the first
ten names in the list (in this example, “Kester”, “Leonard”, “Matthew”,
“Nigel” and “Oscar” would be omitted). These items should be included
on page two, but, as the image below illustrates, there are no links to
page two yet! While Paginated will manage the access to
any object registered by the programmer, the responsibility of
publishing paged links is delegated to a class that implements the PageLayout interface.

Let’s add some code to display the page numbers, then we’ll dig a
little deeper into the interior workings and flexibility of this class.

Create a new file with a PHP extension that contains the following code:

require_once "Paginated.php"; require_once "DoubleBarLayout.php";


//create an array of names in alphabetic order 

$names = array("Andrew", "Bernard", "Castello", "Dennis", "Ernie",

"Frank", "Greg", "Henry", "Isac", "Jax", "Kester", "Leonard",

"Matthew", "Nigel", "Oscar"); 
$page = $_GET['page']; 
$pagedResults = new Paginated($names, 10, 1); 
echo "
"; 
while($row = $pagedResults->fetchPagedRow()) { 

  echo "
{$row}
"; 

} 
echo "
";

$pagedResults->setLayout(new DoubleBarLayout()); echo $pagedResults->fetchPagedNavigation(); ?>

When we run the above script now, we’ll see a list of the first ten
names, as well as some additional orientation information shown in the
image below. Our script now displays the text “Page 1″, as well as a
link to the second page that reads “next >”.

In the code snippet above, we’ve made use of a class called DoubleBarLayout, which implements the interface PageLayout and contains an implementation of the fetchPagedLinks method. This method takes two parameters: the Pagination object, and the query parameters that we want to attach to the hyperlinks (if any).

The great thing about this method is that it takes advantage of
PHP’s polymorphic capabilities, allowing the strategy that’s currently
registered to be called. It’s therefore important for us to set the
strategy first, before calling the method. Setting the strategy is done
via a call to the setter method setLayout, which takes as a parameter an object that implements the PageLayout interface.

Hover over one of these links, and you’ll notice that the parameter
page and its value of 2 are included in the URL page number. However,
in its current state, if you click this link to the second page, the
names that we would expect to be rendered will not be displayed.

Let’s see why this is the case by revisiting the constructor of Paginated.

The constructor takes three parameters:

the array of primitive variables or objects to be processed

the number of records to display

the page number

Because the method fetchPagedNavigation writes a query parameter, we can replace our hardcoded value of 1 with the value held in $_GET['page']. This way, if the user manually modifies the value in the URL to something that’s invalid, Paginated will default the page number to 1. How you choose to validate your GET parameters is up to you, though, so I won’t dwell on this issue any further.

Flexibility in Page Layout Schemes

The flexibility of this class is accomplished via the PageLayout interface, which is part of the Paginated object. The PageLayout interface can reference any object that implements it, and calls to the Paginated method fetchPagedNavigation
will cause the currently registered object to be referenced. If you
haven’t used interfaces before, this may seem a little confusing, but
basically the end result is that the correct code will be called, and
our results will be correctly spread over multiple pages.

To implement this technique, all you need to do is create a layout strategy that implements the PageLayout interface. Then, provide an implementation for the method fetchPagedLinks.

This method takes two parameters:

$parent, which is the Paginated object

$queryVars, which is the list of query parameters to append to the page numbers (and is optional)

There are three important points to note here:

You’ll never be making direct calls to fetchPagedLinks. All methods of Paginated can be accessed through the parent object.

If you want to use your own page layouts, you must change the layout of the paginated result via calls to setLayout.

With those points in mind, let’s create our own page layout! We’ll call it TrailingLayout. Here’s the code:

class TrailingLayout implements PageLayout {


  public function fetchPagedLinks($parent, $queryVars) { 

   

    $currentPage = $parent->getPageNumber(); 

    $totalPages = $parent->fetchNumberPages(); 

    $str = ""; 
    if($totalPages >= 1) { 

     

      for($i = 1; $i <= $totalPages; $i++) { 

     

        $str .= " Page $i"; 

        $str .= $i != $totalPages ? " | " : ""; 

      } 

    }

return $str; } } ?>

The above class, TrailingLayout, implements the PageLayout interface, and provides implementation for fetchPagedLinks. Remember the parameter $parent is an instance of the Paginated object, so we can determine the current page, and the total number of pages, by making calls to getPageNumber and fetchNumberPages, respectively.

In this simple layout, once there’s more than a single page, the
script will loop through the array of pages, and create a hyperlink and
page number for each one. The $queryVars are also written to the href as part of this loop; the parameter $queryVars comes in handy when we’re paging the results of a search that may have included a few parameters.

Note that the string "Page" is not a part of the queryVars, but is written by the loop that appends the page numbers to the string.

Now let’s try implementing our new layout:

require_once "Paginated.php"; //include your customized layout require_once "TrailingLayout.php";


//create an array of names in alphabetic order. A database call could have retrieved these items 

$names = array("Andrew", "Bernard", "Castello", "Dennis", "Ernie",

"Frank", "Greg", "Henry", "Isac", "Jax", "Kester", "Leonard",

"Matthew", "Nigel", "Oscar"); 
$page = $_GET['page']; 
$pagedResults = new Paginated($names, 10, $page); 
echo "
"; 
while($row = $pagedResults->fetchPagedRow()) { 

  echo "
{$row}
"; 

} 
echo "
";

//$pagedResults->setLayout(new TrailingLayout()); echo $pagedResults->fetchPagedNavigation("&firstLetter=l"); ?>

If we were to run the script above as is, we’d get the following error message:

"Fatal error: Call to a member function fetchPagedLinks() on a non-object".

This error occurs because we haven’t yet registered the strategy that we wish to use before calling fetchPagedNavigation. To change the layout of the paged links, we pass to the setLayout method a parameter, which can be any object that implements the PageLayout interface. In the code from our TrailingLayout example above, uncomment the second-last line of PHP code, and refresh your page to see the final result, shown below.

The last line in that code demonstrates how the fetchPagedNavigation method can take an optional parameter string to define the rest of the query (note the inclusion of the ampersand before the firstLetter parameter in the URL to distinguish it from the page parameter).

Summary

In this article, I introduced the Strategy Design Pattern, which can
be used to provide flexibility when you’re laying out paged links.

We saw this pattern in action through the Paginated
class, which will hopefully prove useful to you when you’re displaying
data across multiple pages. The class can be used to display arrays
containing primitive data types or more complex objects.

How to get a page’s Google PageRank (PR) with PHP

CarcaBot — Fri, 24 Jul 2009 10:28:33 +0000

I was recently looking for an easy way to lookup the Page Rank for a given page, site or really any URL. I've seen lots of tools out that that can do it, and many of them allow you to integrate the tool into your site. But those require a lot of extra work, and they just really display the PR. I wanted to actually retrieve the value with PHP. Doing a quick search on google revealed a Google PageRank class from phpclasses.org. It seems to be pretty robust, and it looks like it will do the job!

Determine a visitor’s location by their IP address!

CarcaBot — Fri, 24 Jul 2009 10:28:33 +0000

Tracking a visitor's geographical location (ie. country, region, city, latitude, longitude, ZIP code, ISP and domain name) used to be a cool trick. Now it is an integral part of many websites, enabling them to identify the locations from where they're getting the maximum traffic; and tune your webpages accordingly. It also enables you to modify the site according to location, or send users to specific sections (ie. show prices in CAD for Canadian visitors).

It is relatively easy to use this technology on your website with IP2Location's proprietary IP address lookup database. This database is free for the IP-Country version. Of you need more details like region, city, latitude, longitude, ZIP code, ISP and domain name for the IP address, you need to purchase the full database.

To determine the user's location by their IP address, you need to perform these three steps:

1. Retrieve the visitors' IP address
Here are the functions to get the IP address using ASP, PHP, an .Net (C# & VB.Net).

2. Convert the visitor's IP address to an IP Number
Here are the functions to convert an IP address to an IP number using ASP, PHP, an .Net (C# & VB.Net).

3. Locate the IP Number in the IP-Country database
Example: the IP Address 202.186.13.4 converts to IP Number 3401190660. It is between the beginning and the ending of the following IP numbers:
"3401056256","3401400319","MY","MALAYSIA"

From the IP-Country recordset, the Country_Name with this IP number range is Malaysia, the Country_Code is MY.

So once you have the IP Number, here's the SQL Query to locate the matching recordset:

SELECT country_name FROM ip_to_country WHERE
[your IP number] BETWEEN ip_start AND ip_end

Of course, you need to download the IP2Country database.

How to retrieve a visitor’s IP address

CarcaBot — Fri, 24 Jul 2009 10:28:33 +0000

Every visitor to your site or web application has an IP address. It is quite handy to be able to get that address. It can be used for security logging, or perhaps tracing. It can also be used to determine where they are in the world, or at least where their ISP is.

The difficulty is when they're behind a proxy of some sort, you only see the IP address of the proxy server. So, here are the code snippets in PHP, ASP and .Net that first check for an IP addresses that's forwarded from behind a proxy, and if there's none then just get the IP address.

Here it is in PHP

if (getenv(HTTP_X_FORWARDED_FOR)) {
$ip_address = getenv(HTTP_X_FORWARDED_FOR);
} else {
$ip_address = getenv(REMOTE_ADDR);
}
?>

And here's how to get the IP address in ASP

<%
ip_address = Request.ServerVariables("HTTP_X_FORWARDED_FOR")
if ip_address = "" then
ip_address = Request.ServerVariables("REMOTE_ADDR")
end if
%>

And here's the IP retriever with proxy detection in .Net (C#)

public string IpAddress()
{
string strIpAddress;
strIpAddress = Request.ServerVariables["HTTP_X_FORWARDED_FOR"];
if (strIpAddress == null)
{
strIpAddress = Request.ServerVariables["REMOTE_ADDR"];
}
return strIpAddress;
}

And here's the same IP retriever with proxy detection in .Net, but in VB.Net

Public Function IpAddress()
Dim strIpAddress As String
strIpAddress = Request.ServerVariables("HTTP_X_FORWARDED_FOR")
If strIpAddress = "" Then
strIpAddress = Request.ServerVariables("REMOTE_ADDR")
End If
IpAddress = strIpAddress
End Function

PHPCart payment processor for Chase Paymentech (Orbital)

CarcaBot — Fri, 24 Jul 2009 10:28:22 +0000

I was working on a project recently, implementing the PHPCart ecommerce shopping cart solution. The merchant uses Chase Paymentech as their credit card processor, and the PHPCart website mentioned that there was a gateway already made. However, I quickly found out that there wasn't so I had to code one myself! So I'm offering it up for free as open source. Download the php chase payment gateway.

You need to place it in the 'processor/' directory of the PHPCart installation. It has the following features:

Configure your merchant #
Configure your Terminal ID
Configure your BIN #
Specify the credit cards you accept (I suggest "Visa,MasterCard,American Express,Discover,JCB")
Creates the proper expiry date with only the last two chars of the years from PHPcart
Chase processors dollar amount with implied decimal, so that's taken out
Converts the credit card name into the Chase approved format
You can uncomment line 39 and comment line 40 to switch to the testing server before you're certified.

Anyhow, enjoy! If there are any enhancements or modifications you make, feel free to tell me about them.