Related
I have an API function written in php and want to convert to bash script, in shell to run in some simple environment. Is there any tool for that or have to code manually?
Could anyone assist? Thank you and your help will be highly appreciated.
<?php
$accessKey = 'xxxx';
$secretKey = 'xxxx';
$baseUri = 'http://xxx:9989/';
$yl = new YLOpenApi($accessKey, $secretKey, $baseUri);
$regionAllUri = "api/open/v1/manager/region/getAll";
var_dump($yl->get($regionAllUri));
$deviceEditUri = "api/open/v1/manager/device/getEdit";
//var_dump($yl->get($deviceEditUri,["id"=>"1213"]));
$deviceListUri = "api/open/v1/manager/device/getList";
$postDeviceListData = [
"limit" => 20
];
//var_dump($yl->post($deviceListUri, json_encode($postDeviceListData)));
$file = new CURLFile("F:\\000000000079-all.cfg");
$addGroupConfigUri = "api/open/v1/manager/groupConfig/add";
$addGroupData = [
'file'=>$file,
'name'=>'open api test'
];
//var_dump($yl->form($addGroupConfigUri,$addGroupData));
class YLOpenApi
{
const LF = "\n";
const GET = "GET";
const POST = "POST";
const CONTENT_TYPE_JSON = "Content-Type: application/json";
private $accessKey;
private $secretKey;
private $baseUri;
public function __construct($accessKey, $secretKey, $baseUri)
{
$this->secretKey = $secretKey;
$this->accessKey = $accessKey;
$this->baseUri = $baseUri;
}
public function get($uri, $query = [])
{
return $this->doRequest(self::GET, $uri, $query);
}
public function post($uri, $body = false)
{
return $this->doRequest(self::POST, $uri, [], $body, [self::CONTENT_TYPE_JSON]);
}
public function form($uri, $body = false)
{
return $this->doRequest(self::POST, $uri, [], $body);
}
private function doRequest($method, $uri, $query = [], $body = false, $headers = false)
{
list($signHeader, $queryParams) = $this->sign($method, $uri, $query, $body,!$headers);
$ch = curl_init();
$url = $this->getUrl($uri, $queryParams);
curl_setopt($ch, CURLOPT_URL, $url);
if ($method != self::GET) {
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, $method);
}
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$convertHeader = $this->convertCurlHeader($signHeader);
curl_setopt($ch, CURLOPT_HTTPHEADER, $convertHeader);
if ($method != self::GET && $body) {
curl_setopt($ch, CURLOPT_POSTFIELDS, $body);
if ($headers) {
curl_setopt($ch, CURLOPT_HTTPHEADER, array_merge($convertHeader, $headers));
}
}
var_dump($signHeader);
if ($j = curl_exec($ch)) {
return json_decode($j);
} else {
return false;
}
}
private function sign($method, $uri, $query = [], $body = false,$form = false)
{
$systemHeader['X-Ca-Key'] = $this->accessKey;
$systemHeader['X-Ca-Nonce'] = sha1(uniqid('yl'));
$systemHeader['X-Ca-Timestamp'] = intval(microtime(true) * 1000);
if ($body && !$form) {
$systemHeader['Content-MD5'] = base64_encode(md5($body, true));
}
ksort($systemHeader);
$qs = null;
if ($query) {
ksort($query);
$qs = http_build_query($query);
}
// build string to sign
$toSign = $method;
foreach ($systemHeader as $k => $v) {
$toSign .= self::LF . $k . ':' . $v;
}
$toSign .= self::LF . $uri;
if (isset($qs)) {
$toSign .= self::LF . $qs;
}
$systemHeader['X-Ca-Signature'] = base64_encode(hash_hmac('sha256', trim($toSign), $this->secretKey, true));
return [$systemHeader, $qs];
}
private function getUrl($uri, $params)
{
return isset($params) ? $this->baseUri . $uri . '?' . $params : $this->baseUri . $uri;
}
public function convertCurlHeader($arr)
{
$header = [];
$i = 0;
foreach ($arr as $key => $val) {
$header[$i++] = $key . ": " . $val;
}
return $header;
}
}
Alternative solution: You can execute a php script directly from a shell.
1: Add a shebang:
#!/usr/bin/env php
<?php
....
2: make the php script executable
chmod a+x ./path/to/my.php
3: run the script
./path/to/my.php
# or
./path/to/my.php options_and_params
I know this question has been asked multiple times, however looking through all the solutions, none of them have seemed to work for me.
I've been using the IPN Simulator on the PayPal website to integrate Subscriptions into my website, yet the IPN is always returning invalid.
I've tried multiple ways to get this working, but this is my current method:
<?php
class IpnListener {
public $use_curl = true;
public $force_ssl_v3 = false;
public $follow_location = false;
public $use_ssl = true;
public $use_sandbox = false;
public $timeout = 30;
private $post_data = array();
private $post_uri = '';
private $response_status = '';
private $response = '';
const PAYPAL_HOST = 'www.paypal.com';
const SANDBOX_HOST = 'www.sandbox.paypal.com';
protected function curlPost($encoded_data) {
if ($this->use_ssl) {
$uri = 'https://'.$this->getPaypalHost().'/cgi-bin/webscr';
$this->post_uri = $uri;
} else {
$uri = 'http://'.$this->getPaypalHost().'/cgi-bin/webscr';
$this->post_uri = $uri;
}
$ch = curl_init();
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 2);
curl_setopt($ch, CURLOPT_CAINFO, dirname(__FILE__)."/cacert.pem");
curl_setopt($ch, CURLOPT_URL, $uri);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $encoded_data);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, $this->follow_location);
curl_setopt($ch, CURLOPT_TIMEOUT, $this->timeout);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HEADER, true);
if ($this->force_ssl_v3) {
curl_setopt($ch, CURLOPT_SSLVERSION, 3);
} else {
curl_setopt($ch, CURLOPT_SSLVERSION, 4);
}
$this->response = curl_exec($ch);
$this->response_status = strval(curl_getinfo($ch, CURLINFO_HTTP_CODE));
if ($this->response === false || $this->response_status == '0') {
$errno = curl_errno($ch);
$errstr = curl_error($ch);
throw new Exception("cURL error: [$errno] $errstr");
}
}
protected function fsockPost($encoded_data) {
if ($this->use_ssl) {
$uri = 'ssl://'.$this->getPaypalHost();
$port = '443';
$this->post_uri = $uri.'/cgi-bin/webscr';
} else {
$uri = $this->getPaypalHost(); // no "http://" in call to fsockopen()
$port = '80';
$this->post_uri = 'http://'.$uri.'/cgi-bin/webscr';
}
$fp = fsockopen($uri, $port, $errno, $errstr, $this->timeout);
if (!$fp) {
// fsockopen error
throw new Exception("fsockopen error: [$errno] $errstr");
}
$header = "POST /cgi-bin/webscr HTTP/1.1\r\n";
$header .= "Host: ".$this->getPaypalHost()."\r\n";
$header .= "Content-Type: application/x-www-form-urlencoded\r\n";
$header .= "Content-Length: ".strlen($encoded_data)."\r\n";
$header .= "Connection: Close\r\n\r\n";
fputs($fp, $header.$encoded_data."\r\n\r\n");
while(!feof($fp)) {
if (empty($this->response)) {
// extract HTTP status from first line
$this->response .= $status = fgets($fp, 1024);
$this->response_status = trim(substr($status, 9, 4));
} else {
$this->response .= fgets($fp, 1024);
}
}
fclose($fp);
}
private function getPaypalHost() {
if ($this->use_sandbox) return self::SANDBOX_HOST;
else return self::PAYPAL_HOST;
}
public function getPostUri() {
return $this->post_uri;
}
public function getResponse() {
return $this->response;
}
public function getResponseStatus() {
return $this->response_status;
}
public function getTextReport() {
$r = '';
// date and POST url
for ($i=0; $i<80; $i++) { $r .= '-'; }
$r .= "\n[".date('m/d/Y g:i A').'] - '.$this->getPostUri();
if ($this->use_curl) $r .= " (curl)\n";
else $r .= " (fsockopen)\n";
// HTTP Response
for ($i=0; $i<80; $i++) { $r .= '-'; }
$r .= "\n{$this->getResponse()}\n";
// POST vars
for ($i=0; $i<80; $i++) { $r .= '-'; }
$r .= "\n";
foreach ($this->post_data as $key => $value) {
$r .= str_pad($key, 25)."$value\n";
}
$r .= "\n\n";
return $r;
}
public function processIpn($post_data=null) {
$encoded_data = 'cmd=_notify-validate';
if ($post_data === null) {
// use raw POST data
if (!empty($_POST)) {
$this->post_data = $_POST;
$encoded_data .= '&'.file_get_contents('php://input');
} else {
throw new Exception("No POST data found.");
}
} else {
// use provided data array
$this->post_data = $post_data;
foreach ($this->post_data as $key => $value) {
$encoded_data .= "&$key=".urlencode($value);
}
}
if ($this->use_curl) $this->curlPost($encoded_data);
else $this->fsockPost($encoded_data);
if (strpos($this->response_status, '200') === false) {
throw new Exception("Invalid response status: ".$this->response_status);
}
if (strpos($this->response, "VERIFIED") !== false) {
return true;
} elseif (strpos($this->response, "INVALID") !== false) {
return false;
} else {
throw new Exception("Unexpected response from PayPal.");
}
}
public function requirePostMethod() {
// require POST requests
if ($_SERVER['REQUEST_METHOD'] && $_SERVER['REQUEST_METHOD'] != 'POST') {
header('Allow: POST', true, 405);
throw new Exception("Invalid HTTP request method.");
}
}
Then the Payment.php class, which is where PayPal sends the request too.
/*The Database Connection Code Is Here*/
include('ipnlistener.php');
$listener = new IpnListener();
$listener->use_sandbox = true;
//$listener->use_curl = false;
try {
$verified = $listener->processIpn();
} catch (Exception $e) {
file_put_contents("paymentdev.php", $e->getMessage()." ".date("H:i"));
//file_put_contents("paymentdev.php", "fudge");
exit(0);
}
if ($verified) {
file_put_contents("paymentdev.php", "test");
$data = $_POST;
$user_id = json_decode($data['custom'])->user_id;
$subscription = ($data['mc_gross_1'] == '49.95') ? 2 : 1;
$txn_id = $data['txn_id'];
$user_id = $user_id;
$paypal_id = $data['subsc_id'];
$subscription = $subscription;
$expires = date('Y-m-d H:i:s', strtotime('+1 Month'));
$sql = "SELECT * FROM payments WHERE user_id=$user_id";
$payment = $mysqli->query($sql);
if(isset($payment) && $payment->num_rows > 0)
{
$sql = "DELETE FROM payments WHERE user_id=$user_id";
$delete = $mysqli->query($sql);
}
$sql = "INSERT INTO payments (txn_id, user_id, paypal_id, expires, subscription) VALUES ('$txn_id', $user_id, '$paypal_id', '$expires', $subscription)";
$insertpayment = $mysqli->query($sql);
file_put_contents("paymentdev.php", $mysqli->error);
} else {
file_put_contents("paymentdev.php", "Transaction not verified ".date("H:i")."<br>".$listener->getTextReport());
echo "Error: Transaction not verified";
}
Thanks in advance for all your help guys!
Turns out the code I was using was just fine, I updated the server a bit more just to ensure it was using the latest cURL and open ssl, but even so the sandbox would always return INVALID. I tried the live version with subscriptions priced at $0.01 and the payment went through, was valid and my database was updated
Must just be something weird with the IPN simulator/sandbox
i need some advise on this one, im having trouble figuring out the array that comes from google contacts, im already extracting the email from an example i found online, but now i need to extract the name of the contact and the phone number, i am seeing this information in the array doing a print_r() but dont know how to get it.
This is are my files:
gmail.php (this one prints all the emails, here i need also name and phone)
include_once 'GmailOath.php';
$oauth =new GmailOath($consumer_key, $consumer_secret, $argarray, $debug, $callback);
$getcontact_access=new GmailGetContacts();
$request_token=$oauth->rfc3986_decode($_GET['oauth_token']);
$request_token_secret=$oauth->rfc3986_decode($_SESSION['oauth_token_secret']);
$oauth_verifier= $oauth->rfc3986_decode($_GET['oauth_verifier']);
$contact_access = $getcontact_access->get_access_token($oauth,$request_token, $request_token_secret,$oauth_verifier, false, true, true);
$access_token=$oauth->rfc3986_decode($contact_access['oauth_token']);
$access_token_secret=$oauth->rfc3986_decode($contact_access['oauth_token_secret']);
$contacts= $getcontact_access->GetContacts($oauth, $access_token, $access_token_secret, false, true,$emails_count);
foreach($contacts as $k => $a)
{
$final = end($contacts[$k]);
foreach($final as $email)
{
echo 'email: ' . $email["address"] .'<br>';
}
}
GmailOath.php
<?php
class GmailOath {
public $oauth_consumer_key;
public $oauth_consumer_secret;
public $progname;
public $debug;
public $callback;
function __construct($consumer_key, $consumer_secret, $argarray, $debug, $callback) {
$this->oauth_consumer_key = $consumer_key;
$this->oauth_consumer_secret = $consumer_secret;
$this->progname = $argarray;
$this->debug = $debug; // Set to 1 for verbose debugging output
$this->callback = $callback;
}
////////////////// global.php open//////////////
function logit($msg, $preamble=true) {
// date_default_timezone_set('America/Los_Angeles');
$now = date(DateTime::ISO8601, time());
error_log(($preamble ? "+++${now}:" : '') . $msg);
}
function do_get($url, $port=80, $headers=NULL) {
$retarr = array(); // Return value
$curl_opts = array(CURLOPT_URL => $url,
CURLOPT_PORT => $port,
CURLOPT_POST => false,
CURLOPT_SSL_VERIFYHOST => false,
CURLOPT_SSL_VERIFYPEER => false,
CURLOPT_RETURNTRANSFER => true);
if ($headers) {
$curl_opts[CURLOPT_HTTPHEADER] = $headers;
}
$response = $this->do_curl($curl_opts);
if (!empty($response)) {
$retarr = $response;
}
return $retarr;
}
function do_post($url, $postbody, $port=80, $headers=NULL) {
$retarr = array(); // Return value
$curl_opts = array(CURLOPT_URL => $url,
CURLOPT_PORT => $port,
CURLOPT_POST => true,
CURLOPT_SSL_VERIFYHOST => false,
CURLOPT_SSL_VERIFYPEER => false,
CURLOPT_POSTFIELDS => $postbody,
CURLOPT_RETURNTRANSFER => true);
if ($headers) {
$curl_opts[CURLOPT_HTTPHEADER] = $headers;
}
$response = do_curl($curl_opts);
if (!empty($response)) {
$retarr = $response;
}
return $retarr;
}
function do_curl($curl_opts) {
$retarr = array(); // Return value
if (!$curl_opts) {
if ($this->debug) {
$this->logit("do_curl:ERR:curl_opts is empty");
}
return $retarr;
}
// Open curl session
$ch = curl_init();
if (!$ch) {
if ($this->debug) {
$this->logit("do_curl:ERR:curl_init failed");
}
return $retarr;
}
// Set curl options that were passed in
curl_setopt_array($ch, $curl_opts);
// Ensure that we receive full header
curl_setopt($ch, CURLOPT_HEADER, true);
if ($this->debug) {
curl_setopt($ch, CURLINFO_HEADER_OUT, true);
curl_setopt($ch, CURLOPT_VERBOSE, true);
}
// Send the request and get the response
ob_start();
$response = curl_exec($ch);
$curl_spew = ob_get_contents();
ob_end_clean();
if ($this->debug && $curl_spew) {
$this->logit("do_curl:INFO:curl_spew begin");
$this->logit($curl_spew, false);
$this->logit("do_curl:INFO:curl_spew end");
}
// Check for errors
if (curl_errno($ch)) {
$errno = curl_errno($ch);
$errmsg = curl_error($ch);
if ($this->debug) {
$this->logit("do_curl:ERR:$errno:$errmsg");
}
curl_close($ch);
unset($ch);
return $retarr;
}
if ($this->debug) {
$this->logit("do_curl:DBG:header sent begin");
$header_sent = curl_getinfo($ch, CURLINFO_HEADER_OUT);
$this->logit($header_sent, false);
$this->logit("do_curl:DBG:header sent end");
}
// Get information about the transfer
$info = curl_getinfo($ch);
// Parse out header and body
$header_size = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
$header = substr($response, 0, $header_size);
$body = substr($response, $header_size);
// Close curl session
curl_close($ch);
unset($ch);
if ($this->debug) {
$this->logit("do_curl:DBG:response received begin");
if (!empty($response)) {
$this->logit($response, false);
}
$this->logit("do_curl:DBG:response received end");
}
// Set return value
array_push($retarr, $info, $header, $body);
return $retarr;
}
function json_pretty_print($json, $html_output=false) {
$spacer = ' ';
$level = 1;
$indent = 0; // current indentation level
$pretty_json = '';
$in_string = false;
$len = strlen($json);
for ($c = 0; $c < $len; $c++) {
$char = $json[$c];
switch ($char) {
case '{':
case '[':
if (!$in_string) {
$indent += $level;
$pretty_json .= $char . "\n" . str_repeat($spacer, $indent);
} else {
$pretty_json .= $char;
}
break;
case '}':
case ']':
if (!$in_string) {
$indent -= $level;
$pretty_json .= "\n" . str_repeat($spacer, $indent) . $char;
} else {
$pretty_json .= $char;
}
break;
case ',':
if (!$in_string) {
$pretty_json .= ",\n" . str_repeat($spacer, $indent);
} else {
$pretty_json .= $char;
}
break;
case ':':
if (!$in_string) {
$pretty_json .= ": ";
} else {
$pretty_json .= $char;
}
break;
case '"':
if ($c > 0 && $json[$c - 1] != '\\') {
$in_string = !$in_string;
}
default:
$pretty_json .= $char;
break;
}
}
return ($html_output) ?
'<pre>' . htmlentities($pretty_json) . '</pre>' :
$pretty_json . "\n";
}
function oauth_http_build_query($params, $excludeOauthParams=false) {
$query_string = '';
if (!empty($params)) {
// rfc3986 encode both keys and values
$keys = $this->rfc3986_encode(array_keys($params));
$values = $this->rfc3986_encode(array_values($params));
$params = array_combine($keys, $values);
uksort($params, 'strcmp');
$kvpairs = array();
foreach ($params as $k => $v) {
if ($excludeOauthParams && substr($k, 0, 5) == 'oauth') {
continue;
}
if (is_array($v)) {
// If two or more parameters share the same name,
// they are sorted by their value. OAuth Spec: 9.1.1 (1)
natsort($v);
foreach ($v as $value_for_same_key) {
array_push($kvpairs, ($k . '=' . $value_for_same_key));
}
} else {
// For each parameter, the name is separated from the corresponding
// value by an '=' character (ASCII code 61). OAuth Spec: 9.1.1 (2)
array_push($kvpairs, ($k . '=' . $v));
}
}
// Each name-value pair is separated by an '&' character, ASCII code 38.
// OAuth Spec: 9.1.1 (2)
$query_string = implode('&', $kvpairs);
}
return $query_string;
}
function oauth_parse_str($query_string) {
$query_array = array();
if (isset($query_string)) {
// Separate single string into an array of "key=value" strings
$kvpairs = explode('&', $query_string);
// Separate each "key=value" string into an array[key] = value
foreach ($kvpairs as $pair) {
list($k, $v) = explode('=', $pair, 2);
// Handle the case where multiple values map to the same key
// by pulling those values into an array themselves
if (isset($query_array[$k])) {
// If the existing value is a scalar, turn it into an array
if (is_scalar($query_array[$k])) {
$query_array[$k] = array($query_array[$k]);
}
array_push($query_array[$k], $v);
} else {
$query_array[$k] = $v;
}
}
}
return $query_array;
}
function build_oauth_header($params, $realm='') {
$header = 'Authorization: OAuth';
foreach ($params as $k => $v) {
if (substr($k, 0, 5) == 'oauth') {
$header .= ',' . $this->rfc3986_encode($k) . '="' . $this->rfc3986_encode($v) . '"';
}
}
return $header;
}
function oauth_compute_plaintext_sig($consumer_secret, $token_secret) {
return ($consumer_secret . '&' . $token_secret);
}
function oauth_compute_hmac_sig($http_method, $url, $params, $consumer_secret, $token_secret) {
$base_string = $this->signature_base_string($http_method, $url, $params);
$signature_key = $this->rfc3986_encode($consumer_secret) . '&' . $this->rfc3986_encode($token_secret);
$sig = base64_encode(hash_hmac('sha1', $base_string, $signature_key, true));
if ($this->debug) {
logit("oauth_compute_hmac_sig:DBG:sig:$sig");
}
return $sig;
}
/**
* Make the URL conform to the format scheme://host/path
* #param string $url
* #return string the url in the form of scheme://host/path
*/
function normalize_url($url) {
$parts = parse_url($url);
$scheme = $parts['scheme'];
$host = $parts['host'];
$port = $parts['port'];
$path = $parts['path'];
if (!$port) {
$port = ($scheme == 'https') ? '443' : '80';
}
if (($scheme == 'https' && $port != '443')
|| ($scheme == 'http' && $port != '80')) {
$host = "$host:$port";
}
return "$scheme://$host$path";
}
/**
* Returns the normalized signature base string of this request
* #param string $http_method
* #param string $url
* #param array $params
* The base string is defined as the method, the url and the
* parameters (normalized), each urlencoded and the concated with &.
* #see http://oauth.net/core/1.0/#rfc.section.A.5.1
*/
function signature_base_string($http_method, $url, $params) {
// Decompose and pull query params out of the url
$query_str = parse_url($url, PHP_URL_QUERY);
if ($query_str) {
$parsed_query = $this->oauth_parse_str($query_str);
// merge params from the url with params array from caller
$params = array_merge($params, $parsed_query);
}
// Remove oauth_signature from params array if present
if (isset($params['oauth_signature'])) {
unset($params['oauth_signature']);
}
// Create the signature base string. Yes, the $params are double encoded.
$base_string = $this->rfc3986_encode(strtoupper($http_method)) . '&' .
$this->rfc3986_encode($this->normalize_url($url)) . '&' .
$this->rfc3986_encode($this->oauth_http_build_query($params));
$this->logit("signature_base_string:INFO:normalized_base_string:$base_string");
return $base_string;
}
/**
* Encode input per RFC 3986
* #param string|array $raw_input
* #return string|array properly rfc3986 encoded raw_input
* If an array is passed in, rfc3896 encode all elements of the array.
* #link http://oauth.net/core/1.0/#encoding_parameters
*/
function rfc3986_encode($raw_input){
if (is_array($raw_input)) {
//return array_map($this->rfc3986_encode, $raw_input);
return array_map(array($this, 'rfc3986_encode'), $raw_input);
// return $this->rfc3986_encode($raw_input);
} else if (is_scalar($raw_input)) {
return str_replace('%7E', '~', rawurlencode($raw_input));
} else {
return '';
}
}
function rfc3986_decode($raw_input) {
return rawurldecode($raw_input);
}
}
class GmailGetContacts {
function get_request_token($oauth, $usePost=false, $useHmacSha1Sig=true, $passOAuthInHeader=false) {
$retarr = array(); // return value
$response = array();
$url = 'https://www.google.com/accounts/OAuthGetRequestToken';
$params['oauth_version'] = '1.0';
$params['oauth_nonce'] = mt_rand();
$params['oauth_timestamp'] = time();
$params['oauth_consumer_key'] = $oauth->oauth_consumer_key;
$params['oauth_callback'] = $oauth->callback;
$params['scope'] = 'https://www.google.com/m8/feeds';
// compute signature and add it to the params list
if ($useHmacSha1Sig) {
$params['oauth_signature_method'] = 'HMAC-SHA1';
$params['oauth_signature'] =
$oauth->oauth_compute_hmac_sig($usePost ? 'POST' : 'GET', $url, $params,
$oauth->oauth_consumer_secret, null);
} else {
echo "signature mathod not support";
}
// Pass OAuth credentials in a separate header or in the query string
if ($passOAuthInHeader) {
$query_parameter_string = $oauth->oauth_http_build_query($params, FALSE);
$header = $oauth->build_oauth_header($params);
$headers[] = $header;
} else {
$query_parameter_string = $oauth->oauth_http_build_query($params);
}
// POST or GET the request
if ($usePost) {
$request_url = $url;
$oauth->logit("getreqtok:INFO:request_url:$request_url");
$oauth->logit("getreqtok:INFO:post_body:$query_parameter_string");
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
$response = do_post($request_url, $query_parameter_string, 443, $headers);
} else {
$request_url = $url . ($query_parameter_string ?
('?' . $query_parameter_string) : '' );
$oauth->logit("getreqtok:INFO:request_url:$request_url");
$response = $oauth->do_get($request_url, 443, $headers);
}
// extract successful response
if (!empty($response)) {
list($info, $header, $body) = $response;
$body_parsed = $oauth->oauth_parse_str($body);
if (!empty($body_parsed)) {
$oauth->logit("getreqtok:INFO:response_body_parsed:");
//print_r($body_parsed);
}
$retarr = $response;
$retarr[] = $body_parsed;
}
return $body_parsed;
}
function get_access_token($oauth, $request_token, $request_token_secret, $oauth_verifier, $usePost=false, $useHmacSha1Sig=true, $passOAuthInHeader=true) {
$retarr = array(); // return value
$response = array();
$url = 'https://www.google.com/accounts/OAuthGetAccessToken';
$params['oauth_version'] = '1.0';
$params['oauth_nonce'] = mt_rand();
$params['oauth_timestamp'] = time();
$params['oauth_consumer_key'] = $oauth->oauth_consumer_key;
$params['oauth_token'] = $request_token;
$params['oauth_verifier'] = $oauth_verifier;
// compute signature and add it to the params list
if ($useHmacSha1Sig){
$params['oauth_signature_method'] = 'HMAC-SHA1';
$params['oauth_signature'] =
$oauth->oauth_compute_hmac_sig($usePost ? 'POST' : 'GET', $url, $params,
$oauth->oauth_consumer_secret, $request_token_secret);
} else {
echo "signature mathod not support";
}
//
if ($passOAuthInHeader) {
$query_parameter_string = $oauth->oauth_http_build_query($params, false);
$header = $oauth->build_oauth_header($params);
$headers[] = $header;
} else {
$query_parameter_string = $oauth->oauth_http_build_query($params);
}
if ($usePost){
$request_url = $url;
logit("getacctok:INFO:request_url:$request_url");
logit("getacctok:INFO:post_body:$query_parameter_string");
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
$response = $oauth->do_post($request_url, $query_parameter_string, 443, $headers);
} else {
$request_url = $url . ($query_parameter_string ?
('?' . $query_parameter_string) : '' );
$oauth->logit("getacctok:INFO:request_url:$request_url");
$response = $oauth->do_get($request_url, 443, $headers);
}
if (!empty($response)) {
list($info, $header, $body) = $response;
$body_parsed = $oauth->oauth_parse_str($body);
if (!empty($body_parsed)) {
$oauth->logit("getacctok:INFO:response_body_parsed:");
//print_r($body_parsed);
}
$retarr = $response;
$retarr[] = $body_parsed;
}
return $body_parsed;
}
function GetContacts($oauth, $access_token, $access_token_secret, $usePost=false, $passOAuthInHeader=true,$emails_count) {
$retarr = array(); // return value
$response = array();
$url = "https://www.google.com/m8/feeds/contacts/default/full";
$params['alt'] = 'json';
$params['max-results'] = $emails_count;
$params['oauth_version'] = '1.0';
$params['oauth_nonce'] = mt_rand();
$params['oauth_timestamp'] = time();
$params['oauth_consumer_key'] = $oauth->oauth_consumer_key;
$params['oauth_token'] = $access_token;
// compute hmac-sha1 signature and add it to the params list
$params['oauth_signature_method'] = 'HMAC-SHA1';
$params['oauth_signature'] =
$oauth->oauth_compute_hmac_sig($usePost ? 'POST' : 'GET', $url, $params,
$oauth->oauth_consumer_secret, $access_token_secret);
// Pass OAuth credentials in a separate header or in the query string
if ($passOAuthInHeader){
$query_parameter_string = $oauth->oauth_http_build_query($params, false);
$header = $oauth->build_oauth_header($params);
$headers[] = $header;
} else {
$query_parameter_string = $oauth->oauth_http_build_query($params);
}
// POST or GET the request
if ($usePost){
$request_url = $url;
$oauth->logit("callcontact:INFO:request_url:$request_url");
$oauth->logit("callcontact:INFO:post_body:$query_parameter_string");
$headers[] = 'Content-Type: application/x-www-form-urlencoded';
$response = $oauth->do_post($request_url, $query_parameter_string, 80, $headers);
} else {
$request_url = $url . ($query_parameter_string ?
('?' . $query_parameter_string) : '' );
$oauth->logit("callcontact:INFO:request_url:$request_url");
$response = $oauth->do_get($request_url, 443, $headers);
}
if (!empty($response)) {
list($info, $header, $body) = $response;
if ($body) {
$oauth->logit("callcontact:INFO:response:");
$contact = json_decode($oauth->json_pretty_print($body), true);
//echo $contact['feed']['entry'][0]['gd$email'][0]['address'];
return $contact['feed']['entry'];
}
$retarr = $response;
}
return $retarr;
}
}
?>
Can you guys help me on this one please. Thanks in advance!
Not sure if this can help you as you say you have already used print_r (are you using with braces?), but to display the contents of an array in PHP, I have always used this with success.
It displays the integer ref of the array plus the data in each field.
<?php
echo "<pre>"; //print array to console
{print_r($variable_name);}
echo "</pre>";
?>
Alternately, have you checked the information here: https://developers.google.com/google-apps/contacts/v3/#retrieving_contacts_using_query_parameters
Or try the Context.IO API - there's a call specifically for pulling contacts: http://context.io/docs/2.0/accounts/contacts
Hoping any of these might help you.
For your case for first Phone andress and Note Field .
add where you loop the contacts in gmail.php
foreach($contacts as $k => $a)
{
$phone1 = end($a['gd$phoneNumber'][0]);
$note = end($a['content']);
$adress = end($a['gd$postalAddress'][0]);
This API gives me a headache.. Really can't figure out what is wrong here..
It just through back this error:
414. That’s an error.
The requested URL /compile... is too large to pr
The file $filename exists when the echo line is unescaped
Code
$Compile = new Net_minify_JS();
$Compile->script = file_get_contents($filename);
//echo $Compile->script;
$Compile->content_length = strlen($Compile->script);
echo '<pre>';
echo $Compile->get();
echo '</pre>';
class Net_minify_JS extends Net_socket {
private $content = null;
public $script = '';
function get(){
$this->url = 'closure-compiler.appspot.com';
$this->path = '/compile?output_info=compiled_code&output_format=text&compilation_level=SIMPLE_OPTIMIZATIONS&js_code='.urlencode($this->script);
$this->method = 'POST';
$this->connect();
$this->content = $this->get_content();
$string = str_replace("\r\n", "\n", $this->content);
return $string;
}
}
class Net_socket {
public $url = null;
public $path = null;
public $method = 'GET';
public $content_type = 'application/x-www-form-urlencoded';
public $content_length = 0;
public $port = 80;
public $timeout = 20;
private $fp = null;
private $response = null;
function connect(){
$this->response = null;
$this->method = $this->prepare_method();
if($this->fp = fsockopen($this->url, $this->port, $errno, $errstr, $this->timeout)){
$write = "$this->method $this->path HTTP/1.1\r\n";
$write .= "Host: $this->url\r\n";
$write .= "Content-Type: $this->content_type\r\n";
$write .= $this->content_length ? "Content-Length: $this->content_length\r\n":'';
$write .= "Connection: Close\r\n\r\n";
fwrite($this->fp, $write);
while($line = fgets($this->fp)){
if($line !== false) $this->response .= $line;
}
fclose($this->fp);
}
else{
//echo "$errstr ($errno)<br>\n";
}
}
function prepare_method(){
return strtoupper($this->method);
}
function get_content(){
$this->response = str_replace("\r\n", "\n", $this->response);
$expl = explode("\n\n", $this->response);
return $expl[1];
}
}
Sounds like you're violating the size limits. See https://developers.google.com/closure/compiler/docs/api-ref#errors for how much data is allowed.
And, just for good measure, pass js_code in POST instead of GET.
Edit: You're using the POST method, but you're still passing the arguments in the query string instead of the request body. This means they're all visible in the server's (and any proxies') access logs. Even though they're not secret, the query string is still subject to certain limitations: http://en.wikipedia.org/wiki/Query_string#Compatibility_issues
I am trying to integrate the LinkedIn API to a website so that any of the update can be posted to the website. I am using the LinkedIn API and OAuth API to get the desired functionality.
But when I tried to make it work out with my API key and the secret key, it is not returning the request token. What could be the problem with that?
I am attaching the files with this post.
Linkedin.php
<?php
require_once("OAuth.php");
class LinkedIn {
public $base_url = "http://api.linkedin.com";
public $secure_base_url = "https://api.linkedin.com";
public $oauth_callback = "oob";
public $consumer;
public $request_token;
public $access_token;
public $oauth_verifier;
public $signature_method;
public $request_token_path;
public $access_token_path;
public $authorize_path;
public $debug = false;
function __construct($consumer_key, $consumer_secret, $oauth_callback = NULL) {
if($oauth_callback) {
$this->oauth_callback = $oauth_callback;
}
$this->consumer = new OAuthConsumer($consumer_key, $consumer_secret, $this->oauth_callback);
$this->signature_method = new OAuthSignatureMethod_HMAC_SHA1();
$this->request_token_path = $this->secure_base_url . "/uas/oauth/requestToken";
$this->access_token_path = $this->secure_base_url . "/uas/oauth/accessToken";
$this->authorize_path = $this->secure_base_url . "/uas/oauth/authorize";
}
function getRequestToken() {
$consumer = $this->consumer;
$request = OAuthRequest::from_consumer_and_token($consumer, NULL, "GET", $this->request_token_path);
$request->set_parameter("oauth_callback", $this->oauth_callback);
$request->sign_request($this->signature_method, $consumer, NULL);
$headers = Array();
$url = $request->to_url();
$response = $this->httpRequest($url, $headers, "GET");
parse_str($response, $response_params);
$this->request_token = new OAuthConsumer($response_params['oauth_token'], $response_params['oauth_token_secret'], 1);
}
function generateAuthorizeUrl() {
$consumer = $this->consumer;
$request_token = $this->request_token;
return $this->authorize_path . "?oauth_token=" . $request_token->key;
}
function getAccessToken($oauth_verifier) {
$request = OAuthRequest::from_consumer_and_token($this->consumer, $this->request_token, "GET", $this->access_token_path);
$request->set_parameter("oauth_verifier", $oauth_verifier);
$request->sign_request($this->signature_method, $this->consumer, $this->request_token);
$headers = Array();
$url = $request->to_url();
$response = $this->httpRequest($url, $headers, "GET");
parse_str($response, $response_params);
if($debug) {
echo $response . "\n";
}
$this->access_token = new OAuthConsumer($response_params['oauth_token'], $response_params['oauth_token_secret'], 1);
}
function getProfile($resource = "~") {
$profile_url = $this->base_url . "/v1/people/" . $resource;
$request = OAuthRequest::from_consumer_and_token($this->consumer, $this->access_token, "GET", $profile_url);
$request->sign_request($this->signature_method, $this->consumer, $this->access_token);
$auth_header = $request->to_header("https://api.linkedin.com");
if ($debug) {
echo $auth_header;
}
// $response will now hold the XML document
$response = $this->httpRequest($profile_url, $auth_header, "GET");
return $response;
}
function setStatus($status) {
$status_url = $this->base_url . "/v1/people/~/current-status";
echo "Setting status...\n";
$xml = "<current-status>" . htmlspecialchars($status, ENT_NOQUOTES, "UTF-8") . "</current-status>";
echo $xml . "\n";
$request = OAuthRequest::from_consumer_and_token($this->consumer, $this->access_token, "PUT", $status_url);
$request->sign_request($this->signature_method, $this->consumer, $this->access_token);
$auth_header = $request->to_header("https://api.linkedin.com");
if ($debug) {
echo $auth_header . "\n";
}
$response = $this->httpRequest($profile_url, $auth_header, "GET");
return $response;
}
function search($parameters) {
$search_url = $this->base_url . "/v1/people/" . $parameters;
echo "Performing search for: " . $parameters . "\n";
$request = OAuthRequest::from_consumer_and_token($this->consumer, $this->access_token, "GET", $search_url);
$request->sign_request($this->signature_method, $this->consumer, $this->access_token);
$auth_header = $request->to_header("https://api.linkedin.com");
if ($debug) {
echo $request->get_signature_base_string() . "\n";
echo $auth_header . "\n";
}
$response = $this->httpRequest($search_url, $auth_header, "GET");
return $response;
}
function httpRequest($url, $auth_header, $method, $body = NULL) {
if (!$method) {
$method = "GET";
};
$curl = curl_init();
curl_setopt($curl, CURLOPT_URL, $url);
curl_setopt($curl, CURLOPT_HEADER, 0);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($curl, CURLOPT_HTTPHEADER, array($auth_header)); // Set the headers.
if ($body) {
curl_setopt($curl, CURLOPT_POST, 1);
curl_setopt($curl, CURLOPT_POSTFIELDS, $body);
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($curl, CURLOPT_HTTPHEADER, array($auth_header, "Content-Type: text/xml;charset=utf-8"));
}
$data = curl_exec($curl);
if ($this->debug) {
echo $data . "\n";
}
curl_close($curl);
return $data;
}
}
And the oAuth.php:
class OAuthConsumer {
public $key;
public $secret;
function __construct($key, $secret, $callback_url=NULL) {
$this->key = $key;
$this->secret = $secret;
$this->callback_url = $callback_url;
}
function __toString() {
return "OAuthConsumer[key=$this->key,secret=$this->secret]";
}
}
class OAuthToken {
// access tokens and request tokens
public $key;
public $secret;
function __construct($key, $secret) {
$this->key = $key;
$this->secret = $secret;
}
function to_string() {
return "oauth_token=" .
OAuthUtil::urlencode_rfc3986($this->key) .
"&oauth_token_secret=" .
OAuthUtil::urlencode_rfc3986($this->secret);
}
function __toString() {
return $this->to_string();
}
}
abstract class OAuthSignatureMethod {
abstract public function get_name();
abstract public function build_signature($request, $consumer, $token);
public function check_signature($request, $consumer, $token, $signature) {
$built = $this->build_signature($request, $consumer, $token);
return $built == $signature;
}
}
class OAuthSignatureMethod_HMAC_SHA1 extends OAuthSignatureMethod {
function get_name() {
return "HMAC-SHA1";
}
public function build_signature($request, $consumer, $token) {
$base_string = $request->get_signature_base_string();
$request->base_string = $base_string;
$key_parts = array(
$consumer->secret,
($token) ? $token->secret : ""
);
$key_parts = OAuthUtil::urlencode_rfc3986($key_parts);
$key = implode('&', $key_parts);
return base64_encode(hash_hmac('sha1', $base_string, $key, true));
}
}
class OAuthSignatureMethod_PLAINTEXT extends OAuthSignatureMethod {
public function get_name() {
return "PLAINTEXT";
}
public function build_signature($request, $consumer, $token) {
$key_parts = array($consumer->secret,($token) ? $token->secret : "");
$key_parts = OAuthUtil::urlencode_rfc3986($key_parts);
$key = implode('&', $key_parts);
$request->base_string = $key;
return $key;
}
}
abstract class OAuthSignatureMethod_RSA_SHA1 extends OAuthSignatureMethod {
public function get_name() { return "RSA-SHA1";}
protected abstract function fetch_public_cert(&$request);
public function build_signature($request, $consumer, $token) {
$base_string = $request->get_signature_base_string();
$request->base_string = $base_string;
$cert = $this->fetch_private_cert($request);
$privatekeyid = openssl_get_privatekey($cert);
$ok = openssl_sign($base_string, $signature, $privatekeyid);
openssl_free_key($privatekeyid);
return base64_encode($signature);
}
public function check_signature($request, $consumer, $token, $signature) {
$decoded_sig = base64_decode($signature);
$base_string = $request->get_signature_base_string();
$cert = $this->fetch_public_cert($request);
$publickeyid = openssl_get_publickey($cert);
$ok = openssl_verify($base_string, $decoded_sig, $publickeyid);
openssl_free_key($publickeyid);
return $ok == 1;
}
}
class OAuthRequest {
private $parameters;
private $http_method;
private $http_url;
// for debug purposes
public $base_string;
public static $version = '1.0';
public static $POST_INPUT = 'php://input';
function __construct($http_method, $http_url, $parameters=NULL) {
#$parameters or $parameters = array();
$parameters = array_merge( OAuthUtil::parse_parameters(parse_url($http_url, PHP_URL_QUERY)), $parameters);
$this->parameters = $parameters;
$this->http_method = $http_method;
$this->http_url = $http_url;
}
public static function from_request($http_method=NULL, $http_url=NULL, $parameters=NULL) {
$scheme = (!isset($_SERVER['HTTPS']) || $_SERVER['HTTPS'] != "on")
? 'http'
: 'https';
#$http_url or $http_url = $scheme .
'://' . $_SERVER['HTTP_HOST'] .
':' .
$_SERVER['SERVER_PORT'] .
$_SERVER['REQUEST_URI'];
#$http_method or $http_method = $_SERVER['REQUEST_METHOD'];
if (!$parameters) {
$request_headers = OAuthUtil::get_headers();
$parameters = OAuthUtil::parse_parameters($_SERVER['QUERY_STRING']);
if ($http_method == "POST"
&& #strstr($request_headers["Content-Type"],
"application/x-www-form-urlencoded")
) {
$post_data = OAuthUtil::parse_parameters(
file_get_contents(self::$POST_INPUT)
);
$parameters = array_merge($parameters, $post_data);
}
if (#substr($request_headers['Authorization'], 0, 6) == "OAuth ") {
$header_parameters = OAuthUtil::split_header(
$request_headers['Authorization']
);
$parameters = array_merge($parameters, $header_parameters);
}
}
return new OAuthRequest($http_method, $http_url, $parameters);
}
public static function from_consumer_and_token($consumer, $token, $http_method, $http_url, $parameters=NULL) {
#$parameters or $parameters = array();
$defaults = array("oauth_version" => OAuthRequest::$version,
//"oauth_nonce" => OAuthRequest::generate_nonce(),
"oauth_timestamp" => OAuthRequest::generate_timestamp(),
"oauth_consumer_key" => $consumer->key);
if ($token)
$defaults['oauth_token'] = $token->key;
$parameters = array_merge($defaults, $parameters);
return new OAuthRequest($http_method, $http_url, $parameters);
}
public function set_parameter($name, $value, $allow_duplicates = true) {
if ($allow_duplicates && isset($this->parameters[$name])) {
if (is_scalar($this->parameters[$name])) {
$this->parameters[$name] = array($this->parameters[$name]);
}
$this->parameters[$name][] = $value;
} else {
$this->parameters[$name] = $value;
}
}
public function get_parameter($name) {
return isset($this->parameters[$name]) ? $this->parameters[$name] : null;
}
public function get_parameters() {
return $this->parameters;
}
public function unset_parameter($name) {
unset($this->parameters[$name]);
}
public function get_signable_parameters() {
$params = $this->parameters;
if (isset($params['oauth_signature'])) {
unset($params['oauth_signature']);
}
return OAuthUtil::build_http_query($params);
}
public function get_signature_base_string() {
$parts = array(
$this->get_normalized_http_method(),
$this->get_normalized_http_url(),
$this->get_signable_parameters()
);
$parts = OAuthUtil::urlencode_rfc3986($parts);
return implode('&', $parts);
}
public function get_normalized_http_method() {
return strtoupper($this->http_method);
}
public function get_normalized_http_url() {
$parts = parse_url($this->http_url);
$port = #$parts['port'];
$scheme = $parts['scheme'];
$host = $parts['host'];
$path = #$parts['path'];
$port or $port = ($scheme == 'https') ? '443' : '80';
if (($scheme == 'https' && $port != '443')
|| ($scheme == 'http' && $port != '80')) {
$host = "$host:$port";
}
return "$scheme://$host$path";
}
public function to_url() {
$post_data = $this->to_postdata();
$out = $this->get_normalized_http_url();
if ($post_data) {
$out .= '?'.$post_data;
}
return $out;
}
public function to_postdata() {
return OAuthUtil::build_http_query($this->parameters);
}
public function to_header($realm=null) {
if($realm)
$out = 'Authorization: OAuth realm="' . OAuthUtil::urlencode_rfc3986($realm) . '"';
else
$out = 'Authorization: OAuth';
$total = array();
foreach ($this->parameters as $k => $v) {
if (substr($k, 0, 5) != "oauth") continue;
if (is_array($v)) {
throw new OAuthException('Arrays not supported in headers');
}
$out .= ',' .
OAuthUtil::urlencode_rfc3986($k) .
'="' .
OAuthUtil::urlencode_rfc3986($v) .
'"';
}
return $out;
}
public function __toString() {
return $this->to_url();
}
public function sign_request($signature_method, $consumer, $token) {
$this->set_parameter(
"oauth_signature_method",
$signature_method->get_name(),
false
);
$signature = $this->build_signature($signature_method, $consumer, $token);
$this->set_parameter("oauth_signature", $signature, false);
}
public function build_signature($signature_method, $consumer, $token) {
$signature = $signature_method->build_signature($this, $consumer, $token);
return $signature;
}
private static function generate_timestamp() {
return time();
}
private static function generate_nonce() {
$mt = microtime();
$rand = mt_rand();
return md5($mt . $rand); // md5s look nicer than numbers
}
}
class OAuthServer {
protected $timestamp_threshold = 300; // in seconds, five minutes
protected $version = '1.0'; // hi blaine
protected $signature_methods = array();
protected $data_store;
function __construct($data_store) {
$this->data_store = $data_store;
}
public function add_signature_method($signature_method) {
$this->signature_methods[$signature_method->get_name()] =
$signature_method;
}
public function fetch_request_token(&$request) {
$this->get_version($request);
$consumer = $this->get_consumer($request);
$token = NULL;
$this->check_signature($request, $consumer, $token);
$callback = $request->get_parameter('oauth_callback');
$new_token = $this->data_store->new_request_token($consumer, $callback);
return $new_token;
}
public function fetch_access_token(&$request) {
$this->get_version($request);
$consumer = $this->get_consumer($request);
// requires authorized request token
$token = $this->get_token($request, $consumer, "request");
$this->check_signature($request, $consumer, $token);
// Rev A change
$verifier = $request->get_parameter('oauth_verifier');
$new_token = $this->data_store->new_access_token($token, $consumer, $verifier);
return $new_token;
}
public function verify_request(&$request) {
$this->get_version($request);
$consumer = $this->get_consumer($request);
$token = $this->get_token($request, $consumer, "access");
$this->check_signature($request, $consumer, $token);
return array($consumer, $token);
}
private function get_version(&$request) {
$version = $request->get_parameter("oauth_version");
if (!$version) {
// Service Providers MUST assume the protocol version to be 1.0 if this parameter is not present.
// Chapter 7.0 ("Accessing Protected Ressources")
$version = '1.0';
}
if ($version !== $this->version) {
throw new OAuthException("OAuth version '$version' not supported");
}
return $version;
}
private function get_signature_method(&$request) {
$signature_method =
#$request->get_parameter("oauth_signature_method");
if (!$signature_method) {
// According to chapter 7 ("Accessing Protected Ressources") the signature-method
// parameter is required, and we can't just fallback to PLAINTEXT
throw new OAuthException('No signature method parameter. This parameter is required');
}
if (!in_array($signature_method,
array_keys($this->signature_methods))) {
throw new OAuthException(
"Signature method '$signature_method' not supported " .
"try one of the following: " .
implode(", ", array_keys($this->signature_methods))
);
}
return $this->signature_methods[$signature_method];
}
private function get_consumer(&$request) {
$consumer_key = #$request->get_parameter("oauth_consumer_key");
if (!$consumer_key) {
throw new OAuthException("Invalid consumer key");
}
$consumer = $this->data_store->lookup_consumer($consumer_key);
if (!$consumer) {
throw new OAuthException("Invalid consumer");
}
return $consumer;
}
private function get_token(&$request, $consumer, $token_type="access") {
$token_field = #$request->get_parameter('oauth_token');
$token = $this->data_store->lookup_token(
$consumer, $token_type, $token_field
);
if (!$token) {
throw new OAuthException("Invalid $token_type token: $token_field");
}
return $token;
}
private function check_signature(&$request, $consumer, $token) {
// this should probably be in a different method
$timestamp = #$request->get_parameter('oauth_timestamp');
$nonce = #$request->get_parameter('oauth_nonce');
$this->check_timestamp($timestamp);
$this->check_nonce($consumer, $token, $nonce, $timestamp);
$signature_method = $this->get_signature_method($request);
$signature = $request->get_parameter('oauth_signature');
$valid_sig = $signature_method->check_signature(
$request,
$consumer,
$token,
$signature
);
if (!$valid_sig) {
throw new OAuthException("Invalid signature");
}
}
private function check_timestamp($timestamp) {
if( ! $timestamp )
throw new OAuthException(
'Missing timestamp parameter. The parameter is required'
);
// verify that timestamp is recentish
$now = time();
if (abs($now - $timestamp) > $this->timestamp_threshold) {
throw new OAuthException(
"Expired timestamp, yours $timestamp, ours $now"
);
}
}
private function check_nonce($consumer, $token, $nonce, $timestamp) {
if( ! $nonce )
throw new OAuthException(
'Missing nonce parameter. The parameter is required'
);
// verify that the nonce is uniqueish
$found = $this->data_store->lookup_nonce(
$consumer,
$token,
$nonce,
$timestamp
);
if ($found) {
throw new OAuthException("Nonce already used: $nonce");
}
}
}
class OAuthDataStore {
function lookup_consumer($consumer_key) {
// implement me
}
function lookup_token($consumer, $token_type, $token) {
// implement me
}
function lookup_nonce($consumer, $token, $nonce, $timestamp) {
// implement me
}
function new_request_token($consumer, $callback = null) {
// return a new token attached to this consumer
}
function new_access_token($token, $consumer, $verifier = null) {
}
}
class OAuthUtil {
public static function urlencode_rfc3986($input) {
if (is_array($input)) {
return array_map(array('OAuthUtil', 'urlencode_rfc3986'), $input);
} else if (is_scalar($input)) {
return str_replace(
'+',
' ',
str_replace('%7E', '~', rawurlencode($input))
);
} else {
return '';
}
}
public static function urldecode_rfc3986($string) {
return urldecode($string);
}
public static function split_header($header, $only_allow_oauth_parameters = true) {
$pattern = '/(([-_a-z]*)=("([^"]*)"|([^,]*)),?)/';
$offset = 0;
$params = array();
while (preg_match($pattern, $header, $matches, PREG_OFFSET_CAPTURE, $offset) > 0) {
$match = $matches[0];
$header_name = $matches[2][0];
$header_content = (isset($matches[5])) ? $matches[5][0] : $matches[4][0];
if (preg_match('/^oauth_/', $header_name) || !$only_allow_oauth_parameters) {
$params[$header_name] = OAuthUtil::urldecode_rfc3986($header_content);
}
$offset = $match[1] + strlen($match[0]);
}
if (isset($params['realm'])) {
unset($params['realm']);
}
return $params;
}
// helper to try to sort out headers for people who aren't running apache
public static function get_headers() {
if (function_exists('apache_request_headers')) {
// we need this to get the actual Authorization: header
// because apache tends to tell us it doesn't exist
$headers = apache_request_headers();
// sanitize the output of apache_request_headers because
// we always want the keys to be Cased-Like-This and arh()
// returns the headers in the same case as they are in the
// request
$out = array();
foreach( $headers AS $key => $value ) {
$key = str_replace(
" ",
"-",
ucwords(strtolower(str_replace("-", " ", $key)))
);
$out[$key] = $value;
}
} else {
// otherwise we don't have apache and are just going to have to hope
// that $_SERVER actually contains what we need
$out = array();
foreach ($_SERVER as $key => $value) {
if (substr($key, 0, 5) == "HTTP_") {
// this is chaos, basically it is just there to capitalize the first
// letter of every word that is not an initial HTTP and strip HTTP
// code from przemek
$key = str_replace(
" ",
"-",
ucwords(strtolower(str_replace("_", " ", substr($key, 5))))
);
$out[$key] = $value;
}
}
}
return $out;
}
// This function takes a input like a=b&a=c&d=e and returns the parsed
// parameters like this
// array('a' => array('b','c'), 'd' => 'e')
public static function parse_parameters( $input ) {
if (!isset($input) || !$input) return array();
$pairs = explode('&', $input);
$parsed_parameters = array();
foreach ($pairs as $pair) {
$split = explode('=', $pair, 2);
$parameter = OAuthUtil::urldecode_rfc3986($split[0]);
$value = isset($split[1]) ? OAuthUtil::urldecode_rfc3986($split[1]) : '';
if (isset($parsed_parameters[$parameter])) {
// We have already recieved parameter(s) with this name, so add to the list
// of parameters with this name
if (is_scalar($parsed_parameters[$parameter])) {
// This is the first duplicate, so transform scalar (string) into an array
// so we can add the duplicates
$parsed_parameters[$parameter] = array($parsed_parameters[$parameter]);
}
$parsed_parameters[$parameter][] = $value;
} else {
$parsed_parameters[$parameter] = $value;
}
}
return $parsed_parameters;
}
public static function build_http_query($params) {
if (!$params) return '';
// Urlencode both keys and values
$keys = OAuthUtil::urlencode_rfc3986(array_keys($params));
$values = OAuthUtil::urlencode_rfc3986(array_values($params));
$params = array_combine($keys, $values);
// Parameters are sorted by name, using lexicographical byte value ordering.
// Ref: Spec: 9.1.1 (1)
uksort($params, 'strcmp');
$pairs = array();
foreach ($params as $parameter => $value) {
if (is_array($value)) {
// If two or more parameters share the same name, they are sorted by their value
// Ref: Spec: 9.1.1 (1)
natsort($value);
foreach ($value as $duplicate_value) {
$pairs[] = $parameter . '=' . $duplicate_value;
}
} else {
$pairs[] = $parameter . '=' . $value;
}
}
// For each parameter, the name is separated from the corresponding value by an '=' character (ASCII code 61)
// Each name-value pair is separated by an '&' character (ASCII code 38)
return implode('&', $pairs);
}
}
?>
I am using the same LinkedIn class, and it worked the last time I checked in November. I tested again today and had the same issue.
To get detailed error information, try changing your httpRequest method to the following:
function httpRequest($url, $auth_header, $method, $body = NULL) {
if (!$method) {
$method = "GET";
};
$curl = curl_init();
curl_setopt($curl, CURLOPT_URL, $url);
curl_setopt($curl, CURLOPT_HEADER, 1);
curl_setopt($curl, CURLOPT_VERBOSE, 1);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($curl, CURLOPT_HTTPHEADER, array($auth_header)); // Set the headers.
if ($body) {
curl_setopt($curl, CURLOPT_POST, 1);
curl_setopt($curl, CURLOPT_POSTFIELDS, $body);
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, $method);
curl_setopt($curl, CURLOPT_HTTPHEADER, array($auth_header, "Content-Type: text/xml;charset=utf-8"));
}
$data = curl_exec($curl);
if ($this->debug) {
echo $data . "\n";
}
print_r(curl_getinfo($curl)); // get error info
echo "\n\ncURL error number:" .curl_errno($curl); // print error info
echo "\n\ncURL error:" . curl_error($curl);
curl_close($curl);
return $data;
}
I did this and saw that there is an SSL verification issue - I then fixed that by adding
curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, 0);.
This sorts out the SSL error message. However, I am now getting an HTTP error code 400.
I am not sure if this is the same on your side though...
For updating the status, change the function setStatus() to:
function setStatus($status) {
$status_url = $this->base_url . "/v1/people/~/current-status";
//echo "Setting status...\n";
$xml = "" . htmlspecialchars($status, ENT_NOQUOTES, "UTF-8") . "";
//echo $xml . "\n";
$request = OAuthRequest::from_consumer_and_token($this->consumer, $this->access_token, "PUT", $status_url);
$request->sign_request($this->signature_method, $this->consumer, $this->access_token);
$auth_header = $request->to_header("https://api.linkedin.com");
if ($debug) {
echo $auth_header . "\n";
}
$response = $this->httpRequest($status_url, $auth_header, "PUT", $xml);
return $response;
}