Wordpress Ping

Discussion in 'Blogging' started by drumltd, Dec 15, 2008.

  1. drumltd

    drumltd Regular Member

    Joined:
    Dec 4, 2008
    Messages:
    469
    Likes Received:
    13
    Is there any of the php files you can in wordpress to cause it to run a ping.

    Because I'm inserting posts directly into the database, WP doesn't do the ping for me, so I want to cause a ping automagically when my system inserts a post into the DB.
     
  2. yoyas

    yoyas Junior Member

    Joined:
    Nov 14, 2008
    Messages:
    145
    Likes Received:
    397
    Location:
    Spain
    You can ping your site manually from this great site:
    Code:
    http://pingler.com/
     
  3. drumltd

    drumltd Regular Member

    Joined:
    Dec 4, 2008
    Messages:
    469
    Likes Received:
    13
    I need something I can automate due to volume. I know wordpress has it built in, I just need to figure out how to trigger it remotely.
     
  4. darksorrow

    darksorrow Registered Member

    Joined:
    Oct 25, 2008
    Messages:
    93
    Likes Received:
    346
    I would highly suggest MaxBlogPress Ping Optimizer.

    You can find it on the forum, but I liked it so much I just bought it when the new version came out.
     
  5. q3ick

    q3ick Regular Member

    Joined:
    Oct 27, 2008
    Messages:
    414
    Likes Received:
    115
    Occupation:
    Full Time Student -- Working On My Masters In Busi
    Location:
    Places
    Code:
    Pingler.com
    is awsome just do it 1-2 times a day. Pings 92+ sites.
     
  6. drumltd

    drumltd Regular Member

    Joined:
    Dec 4, 2008
    Messages:
    469
    Likes Received:
    13
    Would still take a while For 100s of blogs?
     
  7. drumltd

    drumltd Regular Member

    Joined:
    Dec 4, 2008
    Messages:
    469
    Likes Received:
    13

    Does this allow me to trigger a ping externally from script?
     
  8. Black&Red

    Black&Red Regular Member

    Joined:
    Mar 14, 2008
    Messages:
    445
    Likes Received:
    248
    Location:
    Latvia
    Doesn't wordpress have this thing where you just add list of sites to ping and it does it automatically?
     
  9. drumltd

    drumltd Regular Member

    Joined:
    Dec 4, 2008
    Messages:
    469
    Likes Received:
    13
    Yes it does, and that's what I'm trying to trigger, because I'm putting the posts directly into the database with a script.
     
  10. pintonbd

    pintonbd Power Member

    Joined:
    Feb 12, 2008
    Messages:
    619
    Likes Received:
    186
    Occupation:
    Banker
    can anyone publish a huge ping list for wordpress blogs?
     
  11. zone69

    zone69 Junior Member

    Joined:
    Nov 24, 2008
    Messages:
    196
    Likes Received:
    1,291
    I had whipped up something some time back that can do this using opensource libraries.
    Here it is:
    File with functions: IXR_Lib.php
    PHP:
    <?php

    /* 
       IXR - The Inutio XML-RPC Library - (c) Incutio Ltd 2002
       Version 1.61 - Simon Willison, 11th July 2003 (htmlentities -> htmlspecialchars)
       Site:   http://scripts.incutio.com/xmlrpc/
       Manual: http://scripts.incutio.com/xmlrpc/manual.php
       Made available under the Artistic License: http://www.opensource.org/licenses/artistic-license.php
    */


    class IXR_Value {
        var 
    $data;
        var 
    $type;
        function 
    IXR_Value ($data$type false) {
            
    $this->data $data;
            if (!
    $type) {
                
    $type $this->calculateType();
            }
            
    $this->type $type;
            if (
    $type == 'struct') {
                
    /* Turn all the values in the array in to new IXR_Value objects */
                
    foreach ($this->data as $key => $value) {
                    
    $this->data[$key] = new IXR_Value($value);
                }
            }
            if (
    $type == 'array') {
                for (
    $i 0$j count($this->data); $i $j$i++) {
                    
    $this->data[$i] = new IXR_Value($this->data[$i]);
                }
            }
        }
        function 
    calculateType() {
            if (
    $this->data === true || $this->data === false) {
                return 
    'boolean';
            }
            if (
    is_integer($this->data)) {
                return 
    'int';
            }
            if (
    is_double($this->data)) {
                return 
    'double';
            }
            
    // Deal with IXR object types base64 and date
            
    if (is_object($this->data) && is_a($this->data'IXR_Date')) {
                return 
    'date';
            }
            if (
    is_object($this->data) && is_a($this->data'IXR_Base64')) {
                return 
    'base64';
            }
            
    // If it is a normal PHP object convert it in to a struct
            
    if (is_object($this->data)) {
                
                
    $this->data get_object_vars($this->data);
                return 
    'struct';
            }
            if (!
    is_array($this->data)) {
                return 
    'string';
            }
            
    /* We have an array - is it an array or a struct ? */
            
    if ($this->isStruct($this->data)) {
                return 
    'struct';
            } else {
                return 
    'array';
            }
        }
        function 
    getXml() {
            
    /* Return XML for this value */
            
    switch ($this->type) {
                case 
    'boolean':
                    return 
    '<boolean>'.(($this->data) ? '1' '0').'</boolean>';
                    break;
                case 
    'int':
                    return 
    '<int>'.$this->data.'</int>';
                    break;
                case 
    'double':
                    return 
    '<double>'.$this->data.'</double>';
                    break;
                case 
    'string':
                    return 
    '<string>'.htmlspecialchars($this->data).'</string>';
                    break;
                case 
    'array':
                    
    $return '<array><data>'."n";
                    foreach (
    $this->data as $item) {
                        
    $return .= '  <value>'.$item->getXml()."</value>n";
                    }
                    
    $return .= '</data></array>';
                    return 
    $return;
                    break;
                case 
    'struct':
                    
    $return '<struct>'."n";
                    foreach (
    $this->data as $name => $value) {
                        
    $return .= "  <member><name>$name</name><value>";
                        
    $return .= $value->getXml()."</value></member>n";
                    }
                    
    $return .= '</struct>';
                    return 
    $return;
                    break;
                case 
    'date':
                case 
    'base64':
                    return 
    $this->data->getXml();
                    break;
            }
            return 
    false;
        }
        function 
    isStruct($array) {
            
    /* Nasty function to check if an array is a struct or not */
            
    $expected 0;
            foreach (
    $array as $key => $value) {
                if ((string)
    $key != (string)$expected) {
                    return 
    true;
                }
                
    $expected++;
            }
            return 
    false;
        }
    }


    class 
    IXR_Message {
        var 
    $message;
        var 
    $messageType;  // methodCall / methodResponse / fault
        
    var $faultCode;
        var 
    $faultString;
        var 
    $methodName;
        var 
    $params;
        
    // Current variable stacks
        
    var $_arraystructs = array();   // The stack used to keep track of the current array/struct
        
    var $_arraystructstypes = array(); // Stack keeping track of if things are structs or array
        
    var $_currentStructName = array();  // A stack as well
        
    var $_param;
        var 
    $_value;
        var 
    $_currentTag;
        var 
    $_currentTagContents;
        
    // The XML parser
        
    var $_parser;
        function 
    IXR_Message ($message) {
            
    $this->message $message;
        }
        function 
    parse() {
            
    // first remove the XML declaration
            
    $this->message preg_replace('/<?xml(.*)??'.'>/'''$this->message);
            if (
    trim($this->message) == '') {
                return 
    false;
            }
            
    $this->_parser xml_parser_create();
            
    // Set XML parser to take the case of tags in to account
            
    xml_parser_set_option($this->_parserXML_OPTION_CASE_FOLDINGfalse);
            
    // Set XML parser callback functions
            
    xml_set_object($this->_parser$this);
            
    xml_set_element_handler($this->_parser'tag_open''tag_close');
            
    xml_set_character_data_handler($this->_parser'cdata');
            if (!
    xml_parse($this->_parser$this->message)) {
                
    /* die(sprintf('XML error: %s at line %d',
                    xml_error_string(xml_get_error_code($this->_parser)),
                    xml_get_current_line_number($this->_parser))); */
                
    return false;
            }
            
    xml_parser_free($this->_parser);
            
    // Grab the error messages, if any
            
    if ($this->messageType == 'fault') {
                
    $this->faultCode $this->params[0]['faultCode'];
                
    $this->faultString $this->params[0]['faultString'];
            }
            return 
    true;
        }
        function 
    tag_open($parser$tag$attr) {
            
    $this->currentTag $tag;
            switch(
    $tag) {
                case 
    'methodCall':
                case 
    'methodResponse':
                case 
    'fault':
                    
    $this->messageType $tag;
                    break;
                
    /* Deal with stacks of arrays and structs */
                
    case 'data':    // data is to all intents and puposes more interesting than array
                    
    $this->_arraystructstypes[] = 'array';
                    
    $this->_arraystructs[] = array();
                    break;
                case 
    'struct':
                    
    $this->_arraystructstypes[] = 'struct';
                    
    $this->_arraystructs[] = array();
                    break;
            }
        }
        function 
    cdata($parser$cdata) {
            
    $this->_currentTagContents .= $cdata;
        }
        function 
    tag_close($parser$tag) {
            
    $valueFlag false;
            switch(
    $tag) {
                case 
    'int':
                case 
    'i4':
                    
    $value = (int)trim($this->_currentTagContents);
                    
    $this->_currentTagContents '';
                    
    $valueFlag true;
                    break;
                case 
    'double':
                    
    $value = (double)trim($this->_currentTagContents);
                    
    $this->_currentTagContents '';
                    
    $valueFlag true;
                    break;
                case 
    'string':
                    
    $value = (string)trim($this->_currentTagContents);
                    
    $this->_currentTagContents '';
                    
    $valueFlag true;
                    break;
                case 
    'dateTime.iso8601':
                    
    $value = new IXR_Date(trim($this->_currentTagContents));
                    
    // $value = $iso->getTimestamp();
                    
    $this->_currentTagContents '';
                    
    $valueFlag true;
                    break;
                case 
    'value':
                    
    // "If no type is indicated, the type is string."
                    
    if (trim($this->_currentTagContents) != '') {
                        
    $value = (string)$this->_currentTagContents;
                        
    $this->_currentTagContents '';
                        
    $valueFlag true;
                    }
                    break;
                case 
    'boolean':
                    
    $value = (boolean)trim($this->_currentTagContents);
                    
    $this->_currentTagContents '';
                    
    $valueFlag true;
                    break;
                case 
    'base64':
                    
    $value base64_decode($this->_currentTagContents);
                    
    $this->_currentTagContents '';
                    
    $valueFlag true;
                    break;
                
    /* Deal with stacks of arrays and structs */
                
    case 'data':
                case 
    'struct':
                    
    $value array_pop($this->_arraystructs);
                    
    array_pop($this->_arraystructstypes);
                    
    $valueFlag true;
                    break;
                case 
    'member':
                    
    array_pop($this->_currentStructName);
                    break;
                case 
    'name':
                    
    $this->_currentStructName[] = trim($this->_currentTagContents);
                    
    $this->_currentTagContents '';
                    break;
                case 
    'methodName':
                    
    $this->methodName trim($this->_currentTagContents);
                    
    $this->_currentTagContents '';
                    break;
            }
            if (
    $valueFlag) {
                
    /*
                if (!is_array($value) && !is_object($value)) {
                    $value = trim($value);
                }
                */
                
    if (count($this->_arraystructs) > 0) {
                    
    // Add value to struct or array
                    
    if ($this->_arraystructstypes[count($this->_arraystructstypes)-1] == 'struct') {
                        
    // Add to struct
                        
    $this->_arraystructs[count($this->_arraystructs)-1][$this->_currentStructName[count($this->_currentStructName)-1]] = $value;
                    } else {
                        
    // Add to array
                        
    $this->_arraystructs[count($this->_arraystructs)-1][] = $value;
                    }
                } else {
                    
    // Just add as a paramater
                    
    $this->params[] = $value;
                }
            }
        }       
    }


    class 
    IXR_Server {
        var 
    $data;
        var 
    $callbacks = array();
        var 
    $message;
        var 
    $capabilities;
        function 
    IXR_Server($callbacks false$data false) {
            
    $this->setCapabilities();
            if (
    $callbacks) {
                
    $this->callbacks $callbacks;
            }
            
    $this->setCallbacks();
            
    $this->serve($data);
        }
        function 
    serve($data false) {
            if (!
    $data) {
                global 
    $HTTP_RAW_POST_DATA;
                if (!
    $HTTP_RAW_POST_DATA) {
                   die(
    'XML-RPC server accepts POST requests only.');
                }
                
    $data $HTTP_RAW_POST_DATA;
            }
            
    $this->message = new IXR_Message($data);
            if (!
    $this->message->parse()) {
                
    $this->error(-32700'parse error. not well formed');
            }
            if (
    $this->message->messageType != 'methodCall') {
                
    $this->error(-32600'server error. invalid xml-rpc. not conforming to spec. Request must be a methodCall');
            }
            
    $result $this->call($this->message->methodName$this->message->params);
            
    // Is the result an error?
            
    if (is_a($result'IXR_Error')) {
                
    $this->error($result);
            }
            
    // Encode the result
            
    $r = new IXR_Value($result);
            
    $resultxml $r->getXml();
            
    // Create the XML
            
    $xml = <<<EOD
    <methodResponse>
      <params>
        <param>
          <value>
            
    $resultxml
          </value>
        </param>
      </params>
    </methodResponse>

    EOD;
            
    // Send it
            
    $this->output($xml);
        }
        function 
    call($methodname$args) {
            if (!
    $this->hasMethod($methodname)) {
                return new 
    IXR_Error(-32601'server error. requested method '.$methodname.' does not exist.');
            }
            
    $method $this->callbacks[$methodname];
            
    // Perform the callback and send the response
            
    if (count($args) == 1) {
                
    // If only one paramater just send that instead of the whole array
                
    $args $args[0];
            }
            
    // Are we dealing with a function or a method?
            
    if (substr($method05) == 'this:') {
                
    // It's a class method - check it exists
                
    $method substr($method5);
                if (!
    method_exists($this$method)) {
                    return new 
    IXR_Error(-32601'server error. requested class method "'.$method.'" does not exist.');
                }
                
    // Call the method
                
    $result $this->$method($args);
            } else {
                
    // It's a function - does it exist?
                
    if (!function_exists($method)) {
                    return new 
    IXR_Error(-32601'server error. requested function "'.$method.'" does not exist.');
                }
                
    // Call the function
                
    $result $method($args);
            }
            return 
    $result;
        }

        function 
    error($error$message false) {
            
    // Accepts either an error object or an error code and message
            
    if ($message && !is_object($error)) {
                
    $error = new IXR_Error($error$message);
            }
            
    $this->output($error->getXml());
        }
        function 
    output($xml) {
            
    $xml '<?xml version="1.0"?>'."n".$xml;
            
    $length strlen($xml);
            
    header('Connection: close');
            
    header('Content-Length: '.$length);
            
    header('Content-Type: text/xml');
            
    header('Date: '.date('r'));
            echo 
    $xml;
            exit;
        }
        function 
    hasMethod($method) {
            return 
    in_array($methodarray_keys($this->callbacks));
        }
        function 
    setCapabilities() {
            
    // Initialises capabilities array
            
    $this->capabilities = array(
                
    'xmlrpc' => array(
                    
    'specUrl' => 'http://www.xmlrpc.com/spec',
                    
    'specVersion' => 1
                
    ),
                
    'faults_interop' => array(
                    
    'specUrl' => 'http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php',
                    
    'specVersion' => 20010516
                
    ),
                
    'system.multicall' => array(
                    
    'specUrl' => 'http://www.xmlrpc.com/discuss/msgReader$1208',
                    
    'specVersion' => 1
                
    ),
            );   
        }
        function 
    getCapabilities($args) {
            return 
    $this->capabilities;
        }
        function 
    setCallbacks() {
            
    $this->callbacks['system.getCapabilities'] = 'this:getCapabilities';
            
    $this->callbacks['system.listMethods'] = 'this:listMethods';
            
    $this->callbacks['system.multicall'] = 'this:multiCall';
        }
        function 
    listMethods($args) {
            
    // Returns a list of methods - uses array_reverse to ensure user defined
            // methods are listed before server defined methods
            
    return array_reverse(array_keys($this->callbacks));
        }
        function 
    multiCall($methodcalls) {
            
    // See http://www.xmlrpc.com/discuss/msgReader$1208
            
    $return = array();
            foreach (
    $methodcalls as $call) {
                
    $method $call['methodName'];
                
    $params $call['params'];
                if (
    $method == 'system.multicall') {
                    
    $result = new IXR_Error(-32600'Recursive calls to system.multicall are forbidden');
                } else {
                    
    $result $this->call($method$params);
                }
                if (
    is_a($result'IXR_Error')) {
                    
    $return[] = array(
                        
    'faultCode' => $result->code,
                        
    'faultString' => $result->message
                    
    );
                } else {
                    
    $return[] = array($result);
                }
            }
            return 
    $return;
        }
    }

    class 
    IXR_Request {
        var 
    $method;
        var 
    $args;
        var 
    $xml;
        function 
    IXR_Request($method$args) {
            
    $this->method $method;
            
    $this->args $args;
            
    $this->xml = <<<EOD
    <?xml version="1.0"?>
    <methodCall>
    <methodName>
    {$this->method}</methodName>
    <params>

    EOD;
            foreach (
    $this->args as $arg) {
                
    $this->xml .= '<param><value>';
                
    $v = new IXR_Value($arg);
                
    $this->xml .= $v->getXml();
                
    $this->xml .= "</value></param>n";
            }
            
    $this->xml .= '</params></methodCall>';
        }
        function 
    getLength() {
            return 
    strlen($this->xml);
        }
        function 
    getXml() {
            return 
    $this->xml;
        }
    }


    class 
    IXR_Client {
        var 
    $server;
        var 
    $port;
        var 
    $path;
        var 
    $useragent;
        var 
    $response;
        var 
    $message false;
        var 
    $debug false;
        
    // Storage place for an error message
        
    var $error false;
        function 
    IXR_Client($server$path false$port 80) {
            if (!
    $path) {
                
    // Assume we have been given a URL instead
                
    $bits parse_url($server);
                
    $this->server $bits['host'];
                
    $this->port = isset($bits['port']) ? $bits['port'] : 80;
                
    $this->path = isset($bits['path']) ? $bits['path'] : '/';
                
    // Make absolutely sure we have a path
                
    if (!$this->path) {
                    
    $this->path '/';
                }
            } else {
                
    $this->server $server;
                
    $this->path $path;
                
    $this->port $port;
            }
            
    $this->useragent 'The Incutio XML-RPC PHP Library';
        }
        function 
    query() {
            
    $args func_get_args();
            
    $method array_shift($args);
            
    $request = new IXR_Request($method$args);
            
    $length $request->getLength();
            
    $xml $request->getXml();
            
    $r "rn";
            
    $request  "POST {$this->path} HTTP/1.0$r";
            
    $request .= "Host: {$this->server}$r";
            
    $request .= "Content-Type: text/xml$r";
            
    $request .= "User-Agent: {$this->useragent}$r";
            
    $request .= "Content-length: {$length}$r$r";
            
    $request .= $xml;
            
    // Now send the request
            
    if ($this->debug) {
                echo 
    '<pre>'.htmlspecialchars($request)."n</pre>nn";
            }
            
    $fp = @fsockopen($this->server$this->port);
            if (!
    $fp) {
                
    $this->error = new IXR_Error(-32300'transport error - could not open socket');
                return 
    false;
            }
            
    fputs($fp$request);
            
    $contents '';
            
    $gotFirstLine false;
            
    $gettingHeaders true;
            while (!
    feof($fp)) {
                
    $line fgets($fp4096);
                if (!
    $gotFirstLine) {
                    
    // Check line for '200'
                    
    if (strstr($line'200') === false) {
                        
    $this->error = new IXR_Error(-32300'transport error - HTTP status code was not 200');
                        return 
    false;
                    }
                    
    $gotFirstLine true;
                }
                if (
    trim($line) == '') {
                    
    $gettingHeaders false;
                }
                if (!
    $gettingHeaders) {
                    
    $contents .= trim($line)."n";
                }
            }
            if (
    $this->debug) {
                echo 
    '<pre>'.htmlspecialchars($contents)."n</pre>nn";
            }
            
    // Now parse what we've got back
            
    $this->message = new IXR_Message($contents);
            if (!
    $this->message->parse()) {
                
    // XML error
                
    $this->error = new IXR_Error(-32700'parse error. not well formed');
                return 
    false;
            }
            
    // Is the message a fault?
            
    if ($this->message->messageType == 'fault') {
                
    $this->error = new IXR_Error($this->message->faultCode$this->message->faultString);
                return 
    false;
            }
            
    // Message must be OK
            
    return true;
        }
        function 
    getResponse() {
            
    // methodResponses can only have one param - return that
            
    return $this->message->params[0];
        }
        function 
    isError() {
            return (
    is_object($this->error));
        }
        function 
    getErrorCode() {
            return 
    $this->error->code;
        }
        function 
    getErrorMessage() {
            return 
    $this->error->message;
        }
    }


    class 
    IXR_Error {
        var 
    $code;
        var 
    $message;
        function 
    IXR_Error($code$message) {
            
    $this->code $code;
            
    $this->message $message;
        }
        function 
    getXml() {
            
    $xml = <<<EOD
    <methodResponse>
      <fault>
        <value>
          <struct>
            <member>
              <name>faultCode</name>
              <value><int>
    {$this->code}</int></value>
            </member>
            <member>
              <name>faultString</name>
              <value><string>
    {$this->message}</string></value>
            </member>
          </struct>
        </value>
      </fault>
    </methodResponse> 

    EOD;
            return 
    $xml;
        }
    }


    class 
    IXR_Date {
        var 
    $year;
        var 
    $month;
        var 
    $day;
        var 
    $hour;
        var 
    $minute;
        var 
    $second;
        function 
    IXR_Date($time) {
            
    // $time can be a PHP timestamp or an ISO one
            
    if (is_numeric($time)) {
                
    $this->parseTimestamp($time);
            } else {
                
    $this->parseIso($time);
            }
        }
        function 
    parseTimestamp($timestamp) {
            
    $this->year date('Y'$timestamp);
            
    $this->month date('Y'$timestamp);
            
    $this->day date('Y'$timestamp);
            
    $this->hour date('H'$timestamp);
            
    $this->minute date('i'$timestamp);
            
    $this->second date('s'$timestamp);
        }
        function 
    parseIso($iso) {
            
    $this->year substr($iso04);
            
    $this->month substr($iso42); 
            
    $this->day substr($iso62);
            
    $this->hour substr($iso92);
            
    $this->minute substr($iso122);
            
    $this->second substr($iso152);
        }
        function 
    getIso() {
            return 
    $this->year.$this->month.$this->day.'T'.$this->hour.':'.$this->minute.':'.$this->second;
        }
        function 
    getXml() {
            return 
    '<dateTime.iso8601>'.$this->getIso().'</dateTime.iso8601>';
        }
        function 
    getTimestamp() {
            return 
    mktime($this->hour$this->minute$this->second$this->month$this->day$this->year);
        }
    }


    class 
    IXR_Base64 {
        var 
    $data;
        function 
    IXR_Base64($data) {
            
    $this->data $data;
        }
        function 
    getXml() {
            return 
    '<base64>'.base64_encode($this->data).'</base64>';
        }
    }


    class 
    IXR_IntrospectionServer extends IXR_Server {
        var 
    $signatures;
        var 
    $help;
        function 
    IXR_IntrospectionServer() {
            
    $this->setCallbacks();
            
    $this->setCapabilities();
            
    $this->capabilities['introspection'] = array(
                
    'specUrl' => 'http://xmlrpc.usefulinc.com/doc/reserved.html',
                
    'specVersion' => 1
            
    );
            
    $this->addCallback(
                
    'system.methodSignature'
                
    'this:methodSignature'
                array(
    'array''string'), 
                
    'Returns an array describing the return type and required parameters of a method'
            
    );
            
    $this->addCallback(
                
    'system.getCapabilities'
                
    'this:getCapabilities'
                array(
    'struct'), 
                
    'Returns a struct describing the XML-RPC specifications supported by this server'
            
    );
            
    $this->addCallback(
                
    'system.listMethods'
                
    'this:listMethods'
                array(
    'array'), 
                
    'Returns an array of available methods on this server'
            
    );
            
    $this->addCallback(
                
    'system.methodHelp'
                
    'this:methodHelp'
                array(
    'string''string'), 
                
    'Returns a documentation string for the specified method'
            
    );
        }
        function 
    addCallback($method$callback$args$help) {
            
    $this->callbacks[$method] = $callback;
            
    $this->signatures[$method] = $args;
            
    $this->help[$method] = $help;
        }
        function 
    call($methodname$args) {
            
    // Make sure it's in an array
            
    if ($args && !is_array($args)) {
                
    $args = array($args);
            }
            
    // Over-rides default call method, adds signature check
            
    if (!$this->hasMethod($methodname)) {
                return new 
    IXR_Error(-32601'server error. requested method "'.$this->message->methodName.'" not specified.');
            }
            
    $method $this->callbacks[$methodname];
            
    $signature $this->signatures[$methodname];
            
    $returnType array_shift($signature);
            
    // Check the number of arguments
            
    if (count($args) != count($signature)) {
                
    // print 'Num of args: '.count($args).' Num in signature: '.count($signature);
                
    return new IXR_Error(-32602'server error. wrong number of method parameters');
            }
            
    // Check the argument types
            
    $ok true;
            
    $argsbackup $args;
            for (
    $i 0$j count($args); $i $j$i++) {
                
    $arg array_shift($args);
                
    $type array_shift($signature);
                switch (
    $type) {
                    case 
    'int':
                    case 
    'i4':
                        if (
    is_array($arg) || !is_int($arg)) {
                            
    $ok false;
                        }
                        break;
                    case 
    'base64':
                    case 
    'string':
                        if (!
    is_string($arg)) {
                            
    $ok false;
                        }
                        break;
                    case 
    'boolean':
                        if (
    $arg !== false && $arg !== true) {
                            
    $ok false;
                        }
                        break;
                    case 
    'float':
                    case 
    'double':
                        if (!
    is_float($arg)) {
                            
    $ok false;
                        }
                        break;
                    case 
    'date':
                    case 
    'dateTime.iso8601':
                        if (!
    is_a($arg'IXR_Date')) {
                            
    $ok false;
                        }
                        break;
                }
                if (!
    $ok) {
                    return new 
    IXR_Error(-32602'server error. invalid method parameters');
                }
            }
            
    // It passed the test - run the "real" method call
            
    return parent::call($methodname$argsbackup);
        }
        function 
    methodSignature($method) {
            if (!
    $this->hasMethod($method)) {
                return new 
    IXR_Error(-32601'server error. requested method "'.$method.'" not specified.');
            }
            
    // We should be returning an array of types
            
    $types $this->signatures[$method];
            
    $return = array();
            foreach (
    $types as $type) {
                switch (
    $type) {
                    case 
    'string':
                        
    $return[] = 'string';
                        break;
                    case 
    'int':
                    case 
    'i4':
                        
    $return[] = 42;
                        break;
                    case 
    'double':
                        
    $return[] = 3.1415;
                        break;
                    case 
    'dateTime.iso8601':
                        
    $return[] = new IXR_Date(time());
                        break;
                    case 
    'boolean':
                        
    $return[] = true;
                        break;
                    case 
    'base64':
                        
    $return[] = new IXR_Base64('base64');
                        break;
                    case 
    'array':
                        
    $return[] = array('array');
                        break;
                    case 
    'struct':
                        
    $return[] = array('struct' => 'struct');
                        break;
                }
            }
            return 
    $return;
        }
        function 
    methodHelp($method) {
            return 
    $this->help[$method];
        }
    }


    class 
    IXR_ClientMulticall extends IXR_Client {
        var 
    $calls = array();
        function 
    IXR_ClientMulticall($server$path false$port 80) {
            
    parent::IXR_Client($server$path$port);
            
    $this->useragent 'The Incutio XML-RPC PHP Library (multicall client)';
        }
        function 
    addCall() {
            
    $args func_get_args();
            
    $methodName array_shift($args);
            
    $struct = array(
                
    'methodName' => $methodName,
                
    'params' => $args
            
    );
            
    $this->calls[] = $struct;
        }
        function 
    query() {
            
    // Prepare multicall, then call the parent::query() method
            
    return parent::query('system.multicall'$this->calls);
        }
    }

    ?>
    Example file using the functions(ping list is very old so make sure to update but i left it for people to see how to add them). Also update the variables on top of file for your blog:
    PHP:
    <?php

    $myBlogName 
    'My Blog Title';
    $myBlogUrl 'http://MyBlogDomain.com';
    $myBlogUpdateUrl 'http://MyBlogDomain';
    $myBlogRSSFeedUrl 'http://MyBlogDomain/feed';

    // Just and example so you need to put your own list here
    // I haven't used many of these for years
    // List of Servers to Ping
    $xmlRpcPingUrls[] = 'http://rpc.technorati.com/rpc/ping';
    $xmlRpcPingUrls[] = 'http://api.moreover.com/RPC2';
    $xmlRpcPingUrls[] = 'http://api.my.yahoo.com/RPC2';
    $xmlRpcPingUrls[] = 'http://blogupdate.org/ping/';
    $xmlRpcPingUrls[] = 'http://ping.bloggers.jp/rpc/';
    $xmlRpcPingUrls[] = 'http://ping.feedburner.com';
    $xmlRpcPingUrls[] = 'http://ping.syndic8.com/xmlrpc.php';
    $xmlRpcPingUrls[] = 'http://ping.weblogalot.com/rpc.php';
    $xmlRpcPingUrls[] = 'http://rpc.icerocket.com:10080/';
    $xmlRpcPingUrls[] = 'http://rpc.weblogs.com/RPC2';
    $xmlRpcPingUrls[] = 'http://services.newsgator.com/ngws/xmlrpcping.aspx';
    $xmlRpcPingUrls[] = 'http://www.blogpeople.net/servlet/weblogUpdates';
    $xmlRpcPingUrls[] = 'http://www.feedsky.com/api/RPC2';
    $xmlRpcPingUrls[] = 'http://ping.blogoon.net/';
    $xmlRpcPingUrls[] = 'http://ping.blogs.yandex.ru/RPC2';
    $xmlRpcPingUrls[] = 'http://ping.syndic8.com/xmlrpc.php';
    $xmlRpcPingUrls[] = 'http://www.blogpeople.net/ping';
    $xmlRpcPingUrls[] = 'http://www.blogpeople.net/servlet/weblogUpdates';
    $xmlRpcPingUrls[] = 'http://www.pubsub.com/ping';
    $xmlRpcPingUrls[] = 'http://www.syndic8.com/xmlrpc.php';
    $xmlRpcPingUrls[] = 'http://xping.pubsub.com/ping/';
    $xmlRpcPingUrls[] = 'http://api.moreover.com/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.com/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.ae/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.at/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.be/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.bg/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.ca/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.ch/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.cl/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.co.cr/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.co.hu/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.co.id/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.co.il/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.co.in/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.co.it/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.co.jp/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.co.ma/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.co.nz/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.co.th/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.co.uk/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.co.ve/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.co.za/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.com.ar/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.com.au/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.com.br/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.com.co/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.com.do/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.com.mx/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.com.my/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.com.pe/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.com.sa/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.com.sg/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.com.tr/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.com.tw/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.com.ua/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.com.uy/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.com.vn/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.com/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.de/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.es/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.fi/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.fr/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.gr/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.hr/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.ie/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.in/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.it/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.jp/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.lt/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.nl/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.pl/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.pt/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.ro/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.ru/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.se/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.sk/ping/RPC2';
    $xmlRpcPingUrls[] = 'http://blogsearch.google.tw/ping/RPC2';


    require_once( 
    'IXR_Lib.php' );
     
    function 
    xmlRpcPing$url ) {
        global 
    $myBlogName$myBlogUrl$myBlogUpdateUrl$myBlogRSSFeedUrl;
        
    $client = new IXR_Client$url );
        
    $client->timeout 3;
        
    $client->useragent .= ' -- XPOZiO/1.0.0';
        
    $client->debug false;
     
        if( 
    $client->query'weblogUpdates.extendedPing'$myBlogName$myBlogUrl$myBlogUpdateUrl$myBlogRSSFeedUrl ) )
        {
            return 
    $client->getResponse();
        }
     
        echo 
    'Failed extended XML-RPC ping for "' $url '": ' $client->getErrorCode() . '->' $client->getErrorMessage() . '<br />';
     
        if( 
    $client->query'weblogUpdates.ping'$myBlogName$myBlogUrl ) )
        {
            return 
    $client->getResponse();
        }
     
        echo 
    'Failed basic XML-RPC ping for "' $url '": ' $client->getErrorCode() . '->' $client->getErrorMessage() . '<br />';
     
        return 
    false;
    }
     
    foreach( 
    $xmlRpcPingUrls as $url )
    {
        echo 
    '<h1>XML-RPC pinging ' $url '</h1>';
        echo 
    '<pre>';
        
    print_rxmlRpcPing$url ) );
        echo 
    '</pre>';
        
    ob_flush();
        
    flush();
    }
    ?>

    Put these files into your webroot or where ever you wish and then to do the ping you just call the second file. You can do it through a browser to test hitting the example_ping.php or if you need to do it programatically then use wget like this :

    Code:
    wget -q -O /dev/null http://yourdomain/example_ping.php
    
    example_ping.php is the second code snippet I have included here.

    Hope this helps you out!

    And Merry Christmas to All!
     
    • Thanks Thanks x 5
  12. drumltd

    drumltd Regular Member

    Joined:
    Dec 4, 2008
    Messages:
    469
    Likes Received:
    13
    Thanks for that, I'll have a play with the code over the holidays. Much appreciated.
     
  13. drumltd

    drumltd Regular Member

    Joined:
    Dec 4, 2008
    Messages:
    469
    Likes Received:
    13
    I've been playing with the code, I'm getting errors when I submit the pings.

    I've dug into the code and it looks like ping service is responding with nothing. It could even be timing out.
     
  14. drumltd

    drumltd Regular Member

    Joined:
    Dec 4, 2008
    Messages:
    469
    Likes Received:
    13
    Sussed it, the code you posted had all the n and r codes replaced with n and r I'm guessing when it was pasted in or something. Anyway help to get me familar with the code, and I now have it working. Thanks.
     
  15. zone69

    zone69 Junior Member

    Joined:
    Nov 24, 2008
    Messages:
    196
    Likes Received:
    1,291
    Glad you got it all working! Not sure how the n r would have gotten there.
    You can always PM me if you have any issues.
     
  16. drumltd

    drumltd Regular Member

    Joined:
    Dec 4, 2008
    Messages:
    469
    Likes Received:
    13
    Suspect its when you pasted it on the forum, as when I tried to describe what I'd found in the above post, it removed the slashes aswell.