class.nusoap_base.php

Go to the documentation of this file.

<?php

/*
$Id: class.nusoap_base.php,v 1.51 2007/11/06 15:17:46 snichol Exp $

NuSOAP - Web Services Toolkit for PHP

Copyright (c) 2002 NuSphere Corporation

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

The NuSOAP project home is:
http://sourceforge.net/projects/nusoap/

The primary support for NuSOAP is the mailing list:
nusoap-general@lists.sourceforge.net

If you have any questions or comments, please email:

Dietrich Ayala
dietrich@ganx4.com
http://dietrich.ganx4.com/nusoap

NuSphere Corporation
http://www.nusphere.com

*/

/*
 *  Some of the standards implmented in whole or part by NuSOAP:
 *
 *  SOAP 1.1 (http://www.w3.org/TR/2000/NOTE-SOAP-20000508/)
 *  WSDL 1.1 (http://www.w3.org/TR/2001/NOTE-wsdl-20010315)
 *  SOAP Messages With Attachments (http://www.w3.org/TR/SOAP-attachments)
 *  XML 1.0 (http://www.w3.org/TR/2006/REC-xml-20060816/)
 *  Namespaces in XML 1.0 (http://www.w3.org/TR/2006/REC-xml-names-20060816/)
 *  XML Schema 1.0 (http://www.w3.org/TR/xmlschema-0/)
 *  RFC 2045 Multipurpose Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies
 *  RFC 2068 Hypertext Transfer Protocol -- HTTP/1.1
 *  RFC 2617 HTTP Authentication: Basic and Digest Access Authentication
 */

/* load classes

// necessary classes
require_once('class.soapclient.php');
require_once('class.soap_val.php');
require_once('class.soap_parser.php');
require_once('class.soap_fault.php');

// transport classes
require_once('class.soap_transport_http.php');

// optional add-on classes
require_once('class.xmlschema.php');
require_once('class.wsdl.php');

// server class
require_once('class.soap_server.php');*/

// class variable emulation
// cf. http://www.webkreator.com/php/techniques/php-static-class-variables.html
$GLOBALS['_transient']['static']['nusoap_base']->globalDebugLevel = 9;

class nusoap_base {
    var $title = 'NuSOAP';
    var $version = '0.7.3';
    var $revision = '$Revision: 1.51 $';
    var $error_str = '';
    var $debug_str = '';
    var $charencoding = true;
    var $debugLevel;

    var $XMLSchemaVersion = 'http://www.w3.org/2001/XMLSchema';
    
    var $soap_defencoding = 'ISO-8859-1';
    //var $soap_defencoding = 'UTF-8';

    var $namespaces = array(
        'SOAP-ENV' => 'http://schemas.xmlsoap.org/soap/envelope/',
        'xsd' => 'http://www.w3.org/2001/XMLSchema',
        'xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
        'SOAP-ENC' => 'http://schemas.xmlsoap.org/soap/encoding/'
        );

    var $usedNamespaces = array();

    var $typemap = array(
    'http://www.w3.org/2001/XMLSchema' => array(
        'string'=>'string','boolean'=>'boolean','float'=>'double','double'=>'double','decimal'=>'double',
        'duration'=>'','dateTime'=>'string','time'=>'string','date'=>'string','gYearMonth'=>'',
        'gYear'=>'','gMonthDay'=>'','gDay'=>'','gMonth'=>'','hexBinary'=>'string','base64Binary'=>'string',
        // abstract "any" types
        'anyType'=>'string','anySimpleType'=>'string',
        // derived datatypes
        'normalizedString'=>'string','token'=>'string','language'=>'','NMTOKEN'=>'','NMTOKENS'=>'','Name'=>'','NCName'=>'','ID'=>'',
        'IDREF'=>'','IDREFS'=>'','ENTITY'=>'','ENTITIES'=>'','integer'=>'integer','nonPositiveInteger'=>'integer',
        'negativeInteger'=>'integer','long'=>'integer','int'=>'integer','short'=>'integer','byte'=>'integer','nonNegativeInteger'=>'integer',
        'unsignedLong'=>'','unsignedInt'=>'','unsignedShort'=>'','unsignedByte'=>'','positiveInteger'=>''),
    'http://www.w3.org/2000/10/XMLSchema' => array(
        'i4'=>'','int'=>'integer','boolean'=>'boolean','string'=>'string','double'=>'double',
        'float'=>'double','dateTime'=>'string',
        'timeInstant'=>'string','base64Binary'=>'string','base64'=>'string','ur-type'=>'array'),
    'http://www.w3.org/1999/XMLSchema' => array(
        'i4'=>'','int'=>'integer','boolean'=>'boolean','string'=>'string','double'=>'double',
        'float'=>'double','dateTime'=>'string',
        'timeInstant'=>'string','base64Binary'=>'string','base64'=>'string','ur-type'=>'array'),
    'http://soapinterop.org/xsd' => array('SOAPStruct'=>'struct'),
    'http://schemas.xmlsoap.org/soap/encoding/' => array('base64'=>'string','array'=>'array','Array'=>'array'),
    'http://xml.apache.org/xml-soap' => array('Map')
    );

    var $xmlEntities = array('quot' => '"','amp' => '&',
        'lt' => '<','gt' => '>','apos' => "'");

    function nusoap_base() {
        $this->debugLevel = $GLOBALS['_transient']['static']['nusoap_base']->globalDebugLevel;
    }

    function getGlobalDebugLevel() {
        return $GLOBALS['_transient']['static']['nusoap_base']->globalDebugLevel;
    }

    function setGlobalDebugLevel($level) {
        $GLOBALS['_transient']['static']['nusoap_base']->globalDebugLevel = $level;
    }

    function getDebugLevel() {
        return $this->debugLevel;
    }

    function setDebugLevel($level) {
        $this->debugLevel = $level;
    }

    function debug($string){
        if ($this->debugLevel > 0) {
            $this->appendDebug($this->getmicrotime().' '.get_class($this).": $string\n");
        }
    }

    function appendDebug($string){
        if ($this->debugLevel > 0) {
            // it would be nice to use a memory stream here to use
            // memory more efficiently
            $this->debug_str .= $string;
        }
    }

    function clearDebug() {
        // it would be nice to use a memory stream here to use
        // memory more efficiently
        $this->debug_str = '';
    }

    function &getDebug() {
        // it would be nice to use a memory stream here to use
        // memory more efficiently
        return $this->debug_str;
    }

    function &getDebugAsXMLComment() {
        // it would be nice to use a memory stream here to use
        // memory more efficiently
        while (strpos($this->debug_str, '--')) {
            $this->debug_str = str_replace('--', '- -', $this->debug_str);
        }
        $ret = "<!--\n" . $this->debug_str . "\n-->";
        return $ret;
    }

    function expandEntities($val) {
        if ($this->charencoding) {
            $val = str_replace('&', '&amp;', $val);
            $val = str_replace("'", '&apos;', $val);
            $val = str_replace('"', '&quot;', $val);
            $val = str_replace('<', '&lt;', $val);
            $val = str_replace('>', '&gt;', $val);
        }
        return $val;
    }

    function getError(){
        if($this->error_str != ''){
            return $this->error_str;
        }
        return false;
    }

    function setError($str){
        $this->error_str = $str;
    }

    function isArraySimpleOrStruct($val) {
        $keyList = array_keys($val);
        foreach ($keyList as $keyListValue) {
            if (!is_int($keyListValue)) {
                return 'arrayStruct';
            }
        }
        return 'arraySimple';
    }

    function serialize_val($val,$name=false,$type=false,$name_ns=false,$type_ns=false,$attributes=false,$use='encoded',$soapval=false) {
        $this->debug("in serialize_val: name=$name, type=$type, name_ns=$name_ns, type_ns=$type_ns, use=$use, soapval=$soapval");
        $this->appendDebug('value=' . $this->varDump($val));
        $this->appendDebug('attributes=' . $this->varDump($attributes));
        
        if (is_object($val) && get_class($val) == 'soapval' && (! $soapval)) {
            $this->debug("serialize_val: serialize soapval");
            $xml = $val->serialize($use);
            $this->appendDebug($val->getDebug());
            $val->clearDebug();
            $this->debug("serialize_val of soapval returning $xml");
            return $xml;
        }
        // force valid name if necessary
        if (is_numeric($name)) {
            $name = '__numeric_' . $name;
        } elseif (! $name) {
            $name = 'noname';
        }
        // if name has ns, add ns prefix to name
        $xmlns = '';
        if($name_ns){
            $prefix = 'nu'.rand(1000,9999);
            $name = $prefix.':'.$name;
            $xmlns .= " xmlns:$prefix=\"$name_ns\"";
        }
        // if type is prefixed, create type prefix
        if($type_ns != '' && $type_ns == $this->namespaces['xsd']){
            // need to fix this. shouldn't default to xsd if no ns specified
            // w/o checking against typemap
            $type_prefix = 'xsd';
        } elseif($type_ns){
            $type_prefix = 'ns'.rand(1000,9999);
            $xmlns .= " xmlns:$type_prefix=\"$type_ns\"";
        }
        // serialize attributes if present
        $atts = '';
        if($attributes){
            foreach($attributes as $k => $v){
                $atts .= " $k=\"".$this->expandEntities($v).'"';
            }
        }
        // serialize null value
        if (is_null($val)) {
            $this->debug("serialize_val: serialize null");
            if ($use == 'literal') {
                // TODO: depends on minOccurs
                $xml = "<$name$xmlns$atts/>";
                $this->debug("serialize_val returning $xml");
                return $xml;
            } else {
                if (isset($type) && isset($type_prefix)) {
                    $type_str = " xsi:type=\"$type_prefix:$type\"";
                } else {
                    $type_str = '';
                }
                $xml = "<$name$xmlns$type_str$atts xsi:nil=\"true\"/>";
                $this->debug("serialize_val returning $xml");
                return $xml;
            }
        }
        // serialize if an xsd built-in primitive type
        if($type != '' && isset($this->typemap[$this->XMLSchemaVersion][$type])){
            $this->debug("serialize_val: serialize xsd built-in primitive type");
            if (is_bool($val)) {
                if ($type == 'boolean') {
                    $val = $val ? 'true' : 'false';
                } elseif (! $val) {
                    $val = 0;
                }
            } else if (is_string($val)) {
                $val = $this->expandEntities($val);
            }
            if ($use == 'literal') {
                $xml = "<$name$xmlns$atts>$val</$name>";
                $this->debug("serialize_val returning $xml");
                return $xml;
            } else {
                $xml = "<$name$xmlns xsi:type=\"xsd:$type\"$atts>$val</$name>";
                $this->debug("serialize_val returning $xml");
                return $xml;
            }
        }
        // detect type and serialize
        $xml = '';
        switch(true) {
            case (is_bool($val) || $type == 'boolean'):
                $this->debug("serialize_val: serialize boolean");
                if ($type == 'boolean') {
                    $val = $val ? 'true' : 'false';
                } elseif (! $val) {
                    $val = 0;
                }
                if ($use == 'literal') {
                    $xml .= "<$name$xmlns$atts>$val</$name>";
                } else {
                    $xml .= "<$name$xmlns xsi:type=\"xsd:boolean\"$atts>$val</$name>";
                }
                break;
            case (is_int($val) || is_long($val) || $type == 'int'):
                $this->debug("serialize_val: serialize int");
                if ($use == 'literal') {
                    $xml .= "<$name$xmlns$atts>$val</$name>";
                } else {
                    $xml .= "<$name$xmlns xsi:type=\"xsd:int\"$atts>$val</$name>";
                }
                break;
            case (is_float($val)|| is_double($val) || $type == 'float'):
                $this->debug("serialize_val: serialize float");
                if ($use == 'literal') {
                    $xml .= "<$name$xmlns$atts>$val</$name>";
                } else {
                    $xml .= "<$name$xmlns xsi:type=\"xsd:float\"$atts>$val</$name>";
                }
                break;
            case (is_string($val) || $type == 'string'):
                $this->debug("serialize_val: serialize string");
                $val = $this->expandEntities($val);
                if ($use == 'literal') {
                    $xml .= "<$name$xmlns$atts>$val</$name>";
                } else {
                    $xml .= "<$name$xmlns xsi:type=\"xsd:string\"$atts>$val</$name>";
                }
                break;
            case is_object($val):
                $this->debug("serialize_val: serialize object");
                if (get_class($val) == 'soapval') {
                    $this->debug("serialize_val: serialize soapval object");
                    $pXml = $val->serialize($use);
                    $this->appendDebug($val->getDebug());
                    $val->clearDebug();
                } else {
                    if (! $name) {
                        $name = get_class($val);
                        $this->debug("In serialize_val, used class name $name as element name");
                    } else {
                        $this->debug("In serialize_val, do not override name $name for element name for class " . get_class($val));
                    }
                    foreach(get_object_vars($val) as $k => $v){
                        $pXml = isset($pXml) ? $pXml.$this->serialize_val($v,$k,false,false,false,false,$use) : $this->serialize_val($v,$k,false,false,false,false,$use);
                    }
                }
                if(isset($type) && isset($type_prefix)){
                    $type_str = " xsi:type=\"$type_prefix:$type\"";
                } else {
                    $type_str = '';
                }
                if ($use == 'literal') {
                    $xml .= "<$name$xmlns$atts>$pXml</$name>";
                } else {
                    $xml .= "<$name$xmlns$type_str$atts>$pXml</$name>";
                }
                break;
            break;
            case (is_array($val) || $type):
                // detect if struct or array
                $valueType = $this->isArraySimpleOrStruct($val);
                if($valueType=='arraySimple' || ereg('^ArrayOf',$type)){
                    $this->debug("serialize_val: serialize array");
                    $i = 0;
                    if(is_array($val) && count($val)> 0){
                        foreach($val as $v){
                            if(is_object($v) && get_class($v) ==  'soapval'){
                                $tt_ns = $v->type_ns;
                                $tt = $v->type;
                            } elseif (is_array($v)) {
                                $tt = $this->isArraySimpleOrStruct($v);
                            } else {
                                $tt = gettype($v);
                            }
                            $array_types[$tt] = 1;
                            // TODO: for literal, the name should be $name
                            $xml .= $this->serialize_val($v,'item',false,false,false,false,$use);
                            ++$i;
                        }
                        if(count($array_types) > 1){
                            $array_typename = 'xsd:anyType';
                        } elseif(isset($tt) && isset($this->typemap[$this->XMLSchemaVersion][$tt])) {
                            if ($tt == 'integer') {
                                $tt = 'int';
                            }
                            $array_typename = 'xsd:'.$tt;
                        } elseif(isset($tt) && $tt == 'arraySimple'){
                            $array_typename = 'SOAP-ENC:Array';
                        } elseif(isset($tt) && $tt == 'arrayStruct'){
                            $array_typename = 'unnamed_struct_use_soapval';
                        } else {
                            // if type is prefixed, create type prefix
                            if ($tt_ns != '' && $tt_ns == $this->namespaces['xsd']){
                                 $array_typename = 'xsd:' . $tt;
                            } elseif ($tt_ns) {
                                $tt_prefix = 'ns' . rand(1000, 9999);
                                $array_typename = "$tt_prefix:$tt";
                                $xmlns .= " xmlns:$tt_prefix=\"$tt_ns\"";
                            } else {
                                $array_typename = $tt;
                            }
                        }
                        $array_type = $i;
                        if ($use == 'literal') {
                            $type_str = '';
                        } else if (isset($type) && isset($type_prefix)) {
                            $type_str = " xsi:type=\"$type_prefix:$type\"";
                        } else {
                            $type_str = " xsi:type=\"SOAP-ENC:Array\" SOAP-ENC:arrayType=\"".$array_typename."[$array_type]\"";
                        }
                    // empty array
                    } else {
                        if ($use == 'literal') {
                            $type_str = '';
                        } else if (isset($type) && isset($type_prefix)) {
                            $type_str = " xsi:type=\"$type_prefix:$type\"";
                        } else {
                            $type_str = " xsi:type=\"SOAP-ENC:Array\" SOAP-ENC:arrayType=\"xsd:anyType[0]\"";
                        }
                    }
                    // TODO: for array in literal, there is no wrapper here
                    $xml = "<$name$xmlns$type_str$atts>".$xml."</$name>";
                } else {
                    // got a struct
                    $this->debug("serialize_val: serialize struct");
                    if(isset($type) && isset($type_prefix)){
                        $type_str = " xsi:type=\"$type_prefix:$type\"";
                    } else {
                        $type_str = '';
                    }
                    if ($use == 'literal') {
                        $xml .= "<$name$xmlns$atts>";
                    } else {
                        $xml .= "<$name$xmlns$type_str$atts>";
                    }
                    foreach($val as $k => $v){
                        // Apache Map
                        if ($type == 'Map' && $type_ns == 'http://xml.apache.org/xml-soap') {
                            $xml .= '<item>';
                            $xml .= $this->serialize_val($k,'key',false,false,false,false,$use);
                            $xml .= $this->serialize_val($v,'value',false,false,false,false,$use);
                            $xml .= '</item>';
                        } else {
                            $xml .= $this->serialize_val($v,$k,false,false,false,false,$use);
                        }
                    }
                    $xml .= "</$name>";
                }
                break;
            default:
                $this->debug("serialize_val: serialize unknown");
                $xml .= 'not detected, got '.gettype($val).' for '.$val;
                break;
        }
        $this->debug("serialize_val returning $xml");
        return $xml;
    }

    function serializeEnvelope($body,$headers=false,$namespaces=array(),$style='rpc',$use='encoded',$encodingStyle='http://schemas.xmlsoap.org/soap/encoding/'){
    // TODO: add an option to automatically run utf8_encode on $body and $headers
    // if $this->soap_defencoding is UTF-8.  Not doing this automatically allows
    // one to send arbitrary UTF-8 characters, not just characters that map to ISO-8859-1

    $this->debug("In serializeEnvelope length=" . strlen($body) . " body (max 1000 characters)=" . substr($body, 0, 1000) . " style=$style use=$use encodingStyle=$encodingStyle");
    $this->debug("headers:");
    $this->appendDebug($this->varDump($headers));
    $this->debug("namespaces:");
    $this->appendDebug($this->varDump($namespaces));

    // serialize namespaces
    $ns_string = '';
    foreach(array_merge($this->namespaces,$namespaces) as $k => $v){
        $ns_string .= " xmlns:$k=\"$v\"";
    }
    if($encodingStyle) {
        $ns_string = " SOAP-ENV:encodingStyle=\"$encodingStyle\"$ns_string";
    }

    // serialize headers
    if($headers){
        if (is_array($headers)) {
            $xml = '';
            foreach ($headers as $k => $v) {
                if (is_object($v) && get_class($v) == 'soapval') {
                    $xml .= $this->serialize_val($v, false, false, false, false, false, $use);
                } else {
                    $xml .= $this->serialize_val($v, $k, false, false, false, false, $use);
                }
            }
            $headers = $xml;
            $this->debug("In serializeEnvelope, serialized array of headers to $headers");
        }
        $headers = "<SOAP-ENV:Header>".$headers."</SOAP-ENV:Header>";
    }
    // serialize envelope
    return
    '<?xml version="1.0" encoding="'.$this->soap_defencoding .'"?'.">".
    '<SOAP-ENV:Envelope'.$ns_string.">".
    $headers.
    "<SOAP-ENV:Body>".
        $body.
    "</SOAP-ENV:Body>".
    "</SOAP-ENV:Envelope>";
    }

    function formatDump($str){
        $str = htmlspecialchars($str);
        return nl2br($str);
    }

    function contractQname($qname){
        // get element namespace
        //$this->xdebug("Contract $qname");
        if (strrpos($qname, ':')) {
            // get unqualified name
            $name = substr($qname, strrpos($qname, ':') + 1);
            // get ns
            $ns = substr($qname, 0, strrpos($qname, ':'));
            $p = $this->getPrefixFromNamespace($ns);
            if ($p) {
                return $p . ':' . $name;
            }
            return $qname;
        } else {
            return $qname;
        }
    }

    function expandQname($qname){
        // get element prefix
        if(strpos($qname,':') && !ereg('^http://',$qname)){
            // get unqualified name
            $name = substr(strstr($qname,':'),1);
            // get ns prefix
            $prefix = substr($qname,0,strpos($qname,':'));
            if(isset($this->namespaces[$prefix])){
                return $this->namespaces[$prefix].':'.$name;
            } else {
                return $qname;
            }
        } else {
            return $qname;
        }
    }

    function getLocalPart($str){
        if($sstr = strrchr($str,':')){
            // get unqualified name
            return substr( $sstr, 1 );
        } else {
            return $str;
        }
    }

    function getPrefix($str){
        if($pos = strrpos($str,':')){
            // get prefix
            return substr($str,0,$pos);
        }
        return false;
    }

    function getNamespaceFromPrefix($prefix){
        if (isset($this->namespaces[$prefix])) {
            return $this->namespaces[$prefix];
        }
        //$this->setError("No namespace registered for prefix '$prefix'");
        return false;
    }

    function getPrefixFromNamespace($ns) {
        foreach ($this->namespaces as $p => $n) {
            if ($ns == $n || $ns == $p) {
                $this->usedNamespaces[$p] = $n;
                return $p;
            }
        }
        return false;
    }

    function getmicrotime() {
        if (function_exists('gettimeofday')) {
            $tod = gettimeofday();
            $sec = $tod['sec'];
            $usec = $tod['usec'];
        } else {
            $sec = time();
            $usec = 0;
        }
        return strftime('%Y-%m-%d %H:%M:%S', $sec) . '.' . sprintf('%06d', $usec);
    }

    function varDump($data) {
        ob_start();
        var_dump($data);
        $ret_val = ob_get_contents();
        ob_end_clean();
        return $ret_val;
    }

    function __toString() {
        return $this->varDump($this);
    }
}

// XML Schema Datatype Helper Functions

//xsd:dateTime helpers

function timestamp_to_iso8601($timestamp,$utc=true){
    $datestr = date('Y-m-d\TH:i:sO',$timestamp);
    if($utc){
        $eregStr =
        '([0-9]{4})-'.  // centuries & years CCYY-
        '([0-9]{2})-'.  // months MM-
        '([0-9]{2})'.   // days DD
        'T'.            // separator T
        '([0-9]{2}):'.  // hours hh:
        '([0-9]{2}):'.  // minutes mm:
        '([0-9]{2})(\.[0-9]*)?'. // seconds ss.ss...
        '(Z|[+\-][0-9]{2}:?[0-9]{2})?'; // Z to indicate UTC, -/+HH:MM:SS.SS... for local tz's

        if(ereg($eregStr,$datestr,$regs)){
            return sprintf('%04d-%02d-%02dT%02d:%02d:%02dZ',$regs[1],$regs[2],$regs[3],$regs[4],$regs[5],$regs[6]);
        }
        return false;
    } else {
        return $datestr;
    }
}

function iso8601_to_timestamp($datestr){
    $eregStr =
    '([0-9]{4})-'.  // centuries & years CCYY-
    '([0-9]{2})-'.  // months MM-
    '([0-9]{2})'.   // days DD
    'T'.            // separator T
    '([0-9]{2}):'.  // hours hh:
    '([0-9]{2}):'.  // minutes mm:
    '([0-9]{2})(\.[0-9]+)?'. // seconds ss.ss...
    '(Z|[+\-][0-9]{2}:?[0-9]{2})?'; // Z to indicate UTC, -/+HH:MM:SS.SS... for local tz's
    if(ereg($eregStr,$datestr,$regs)){
        // not utc
        if($regs[8] != 'Z'){
            $op = substr($regs[8],0,1);
            $h = substr($regs[8],1,2);
            $m = substr($regs[8],strlen($regs[8])-2,2);
            if($op == '-'){
                $regs[4] = $regs[4] + $h;
                $regs[5] = $regs[5] + $m;
            } elseif($op == '+'){
                $regs[4] = $regs[4] - $h;
                $regs[5] = $regs[5] - $m;
            }
        }
        return gmmktime($regs[4], $regs[5], $regs[6], $regs[2], $regs[3], $regs[1]);
//      return strtotime("$regs[1]-$regs[2]-$regs[3] $regs[4]:$regs[5]:$regs[6]Z");
    } else {
        return false;
    }
}

function usleepWindows($usec)
{
    $start = gettimeofday();
    
    do
    {
        $stop = gettimeofday();
        $timePassed = 1000000 * ($stop['sec'] - $start['sec'])
        + $stop['usec'] - $start['usec'];
    }
    while ($timePassed < $usec);
}


?>