To clarify the article title, when I say web service, I mean a piece of software that will receive and send out data via the HTTP protocol. Furthermore, this data is usually transmitted in XML format. I will also call this XML RPC occasionally, but there is also a specification called XML-RPC so things can get confusing. Again in summary, this post will describe a very simple way to send and receive method calls and responses using XML and HTTP POST.

Sending your request
This will use the PHP cURL extension, so make sure your PHP is compiled with the correct options. The XML parser later will also use SimpleXML, which needs PHP 5 and the SimpleXML extension.

The following function will submit a query to an arbitrary web server, and also allow you to pass a POST string through to it.

   function cURL($link, $poststring){
        $ch = curl_init();

        curl_setopt ($ch, CURLOPT_URL, $link);
        curl_setopt ($ch, CURLOPT_POST, 1);
        curl_setopt ($ch, CURLOPT_POSTFIELDS, $poststring);
        curl_setopt ($ch, CURLOPT_HEADER, 0);
        curl_setopt ($ch, CURLOPT_RETURNTRANSFER, 1);
        curl_setopt ($ch, CURLOPT_SSL_VERIFYPEER, 0);
        curl_setopt ($ch, CURLOPT_TIMEOUT, 15);

        $response = trim(curl_exec ($ch));
        return $response;
   } //cURL

Now, you should decide on a format for your XML requests; we’ll use something very simple here:

   <?xml version='1.0'?>
   <request>
      <user>Mike</user>
      <type>getDate</type>
   </request>

This will ask another server for the current time, and use basic user name authentication.

To send the request:

   $poststring = "request=$xml";
   $response = cURL('http://server.com/xml.php', $poststring);

Receiving the request
On the other side of the connection we write some code to parse the request (i.e. this is in xml.php hosted on server.com).

   $xml = (isset($_POST['request'])) ? $_POST['request'] : false;
   if (!$xml) { return; }

Now the above XML we sent is stored in the $xml variable. To process it, we can use the following code:

   $obj = simplexml_load_string($xml);

   $error = '';

   if ((string)$obj->user == 'Mike') {
      switch ((string)$obj->type) {
         case 'getDate' :
            $response = "<?xml version='1.0'?>
               <response>
                  <date>".date('l, d F Y at H:i:s', time())."</date>
               </response>";
            break;

         default :
            $error = 'Invalid method';
      } //switch
   } else {
      $error = 'Invalid user';
   } //else

   if ($error) {
      print "<?xml version='1.0'?>
         <response>
            <error>$error</error>
         </response>";
   } else {
      print $response;
   } //else

After checking the user name the method name is handled, and if it doesn’t exist on this implementation an error is returned. Printing the XML response is how we pass data back to the server that requested the service - if you look back you’ll see that the cURL function returns whatever content the URL returned, i.e. our printed XML.

That should be everything, this should of course be expanded into a class or structured methods.

Comments(0)

Just a quick post - if you’re using PHP’s shell_exec to execute shell commands, take note of the following:

Permissions
If you’re reading or writing files, ensure that your working directory has the correct permissions for the www/apache user to access what it needs. On some systems, PHP will run as the nobody user, so adjust accordingly.

Pipes
Using pipes and redirection inside your command string is not going to work most of the time, what you probably want to do is create a seperate bash script on your server that contains all the commands you want to run. Then use PHP to execute the single bash script.

Paths
This one has got me a few times - just because a command is in the path when you’re SSH’d into the server, it doesn’t mean that it’ll be on PHP’s perceived path. This means that you’ll need to specify the full path to any system applications you are using (not for standard commands like cat, though). For example:

   shell_exec("/usr/local/bin/htmldoc --jpeg=0 --webpage \
      -f out.pdf in.html");

Comments(0)

I often (a couple times a month) have to sort an array of arrays by some arbitrary value located in the internal array. For example, I might want to sort the following structure by name.

   Array[0] {
      Array[0] {
         id => 1
         name => mike
         age => 20
      }

      Array[1] {
         id => 2
         name => bob
         age: 21
      }
   }

I want the same structure returned, but the array containing ‘bob’ in it’s name key must appear first in the array. PHP’s sort() function is insuffficient in this case, it sorts by the first key of each internal array (i.e. ‘id’ in this case).

The solution is to use usort(), which allows for a custom compare function to be used.

   function cmp($x, $y) {
      if ($x[1] == $y[1]) {
         return 0;
      } //if

      return ($x[1] > $y[1]) ? 1 : -1;
      //or return strcmp($x[1], $y[1]);
   } //cmp

   usort($array, 'cmp');

usort() takes the provided function name and uses it as the compare function between two elements. This also allows you to sort by multiple fields, if the first two fields are equal you can drop down to checking another field, and so on.

Comments(0)

CakePHP is an awesome MVC (Model-View-Controller) framework for PHP 4 and 5 - it provides a great base to build your web application on, and can save you a huge amount of time if used correctly.

Unfortunately, the manual is sometimes lacking - whilst the information you need might be there, you probably will not be able to find it because it’s hidden away in some random corner. I’m going to cover a few common questions (in my opinion) here.

How do I turn off the automatic database connection?

Sometimes you want a controller and model that don’t have any mapping to the database - for example, a static page controller. Cake complains unless you have a correctly named table in the database when you view the page.

Add this line to your model file to disable this feature:

   var $useTable = false;

How do I turn off auto-layout rendering?

Cake also automatically lays out your controller methods into the default layout - you might want to turn this off if the controller deals with AJAX calls and returns simple responses, or simply if you want to make use of print and print_r.

At the top of your controller, inside the class, add:

   var $autoRender = false;

You can also disable this per method, as far as I know.

Additionally, Cake comes with a AJAX layout in the core that returns the template file without the default layout. You can use it by specifying the render function in the last line of your method (e.g. for function myAction()):

   $this->render('myAction', 'ajax');

Where do I put application-wide code?

Create a file called app_controller.php in your app directory:

project/app/app_controller.php

   <?php
      class AppController extends Controller {
         //code
      } //AppController
   ?>

This file overrides the default app controller that each of your controller’s extends, thus you can add any code here that you want all of your controllers to see.

Comments(3)

PHP is a dynamic, weakly-typed language, and as such, beginners to the language will often find their code acting unpredictably because of assumptions they have made.

PHP has a fairly low entry point for new programmers - it’s easy enough to get a couple of small sample scripts up and running, but on the same token, it’s really easy to pick up bad habits and carry them through into larger projects. Since PHP is often the first language used extensively by a new generation of web programmers, and doesn’t have strict typing or error reporting, a lot of people simply never pick up the best practices for system design and implementation.

This tutorial is going to be a quick introduction to variables in PHP, and how to test them effectively for missing or incorrect data.

To define a variable in PHP, you simply refer to it and assign it a value. Notice that you don’t need to place a type before it, e.g. int or string.

  $var1 = 'abc';

One variable is now present in your system, $var1, with the value abc.

If you are planning on using a group of variables in your program, it is generally good practice to declare them near the top of your function or method, or near the top of the file, and assign them sensible default values:

  $counter = 0;
  $name = '';
  $max = 10;

Testing variables

To maintain a predictable system, you need to ensure that you are always testing variables for expected values and sanitising them where necessary. Sanitising refers to cleaning up any data that has come from an untrusted source, i.e. a user submitted form or something similar. Such data must never be used directly without being checked or parsed - a common mistake is to take data a user has submitted and immediately use it in a database query:

  $query = "SELECT * FROM table WHERE name LIKE = {$_POST['name']}";

This is a classic example of an SQL injection flaw. A malicious user could easily craft a request to modify or even drop your entire database.

A better query would look like this:

  $name = mysql_escape_string($_POST[’name’]);
  $query = “SELECT * FROM table WHERE name LIKE = ‘$name’”;

Notice the additional quotes around $name in the query; and the curly braces around the variable are no longer required as it isn’t a value being accessed in an array. Additionally, notice that the $query string is surrounded by double quotes (”) - this means that variables and string literals inside the string will be parsed.

  $name = 'Michael';
  $test1 = 'My name is $name';
  $test2 = "My name is $name";

Try printing the variables above in your own script and see the difference. $test1 will say ‘My name is $name‘ whilst $test2 will say ‘My name is Michael‘.

PHP provides several functions to test variables with, here is a table of the results from a couple of them:

Above, we use empty to test if a variable has a value, this function will return FALSE if variable has a non-empty and non-zero value. The following are values that PHP treats as false (zero):

• "" i.e. empty string
• 0 as an Integer
• "0" as a String
• NULL
• FALSE
• array()

Also note that empty only tests variables, anything else will result in a parse error. In other words, the following will not work: empty(trim($name)); (From www.php.net/empty).

Once a variable is defined (or set), you can use unset($var) or $var = null to destroy it.

Because PHP is weakly-typed, since PHP 5 (I think, maybe sooner), an additional operator has been included. By extending the standard boolean test operator ‘==’ to 3 equal signs, ‘===’, the variables being tested will also be tested to see if their base types match. In other words:

  (0 == '')

returns true because both are seen as false (0) by PHP, but

  (0 === '')

returns false because 0 is an integer and ” is a string, so their values match, but not their types.

This additional checking can also be used in the negative form, i.e. ‘!==’.

Using everything we’ve discussed above, a sensible way to read from the HTTP POST parameter super-global and set a default value is to use the ternary operator in PHP:

  $name = (isset($_POST['name'])) ? $_POST['name'] : 'none';

A good way to quickly play around with all these different functions, and to test your logic, is to use the PHP interactive shell (PHP 5.1 onwards):

$ php -a

Alternatively use PHP-Shell which has more features than the built-in shell (link below).

Related links

1. PHP-Shell by Jan Kneschke
2. http://www.php.net/manual/en/function.isset.php
3. http://www.php.net/manual/en/function.empty.php
4. http://www.php.net/manual/en/function.unset.php

Comments(1)