No Post Data (bitpay) - php

We are integrating Bitpay to our website but each time we make payment and call back out notification url we keep getting "no post data". Our url is https as requested and everything seem to be fine please help. this is the code.
bp_options.php
global $bpOptions;
$bpOptions['apiKey'] = 'xxxxxxx';
$bpOptions['verifyPos'] = true;
$bpOptions['notificationEmail'] = 'our email';
$bpOptions['notificationURL'] = 'https://www.ourwebsite.com/completesubscription/bitpaynotification';;
$bpOptions['redirectURL'] = 'https://www.ourwebsite.com/completesubscription?method=bitpay';;
$bpOptions['currency'] = 'USD';
$bpOptions['physical'] = true;
$bpOptions['fullNotifications'] = true;
$bpOptions['transactionSpeed'] = 'high';
$bpOptions['logFile'] = '/bplog.txt';
$bpOptions['useLogging'] = TRUE;
bp_lib.php
require_once 'bp_options.php';
function bpLog($contents) {
global $bpOptions;
try {
if(isset($bpOptions['logFile']) && $bpOptions['logFile'] != '') {
$file = dirname(__FILE__).$bpOptions['logFile'];
} else {
// Fallback to using a default logfile name in case the variable is
// missing or not set.
$file = dirname(__FILE__).'/bplog.txt';
}
file_put_contents($file, date('m-d H:i:s').": ", FILE_APPEND);
if (is_array($contents))
$contents = var_export($contents, true);
else if (is_object($contents))
$contents = json_encode($contents);
file_put_contents($file, $contents."\n", FILE_APPEND);
} catch (Exception $e) {
echo 'Error: ' . $e->getMessage();
}
}
function bpCurl($url, $apiKey, $post = false) {
global $bpOptions;
if((isset($url) && trim($url) != '') && (isset($apiKey) && trim($apiKey) != '')) {
try {
$curl = curl_init();
$length = 0;
if ($post) {
curl_setopt($curl, CURLOPT_POST, 1);
curl_setopt($curl, CURLOPT_POSTFIELDS, $post);
$length = strlen($post);
}
$uname = base64_encode($apiKey);
if($uname) {
$header = array(
'Content-Type: application/json',
'Content-Length: ' . $length,
'Authorization: Basic ' . $uname,
'X-BitPay-Plugin-Info: phplib1.5',
);
curl_setopt($curl, CURLOPT_URL, $url);
curl_setopt($curl, CURLOPT_PORT, 443);
curl_setopt($curl, CURLOPT_HTTPHEADER, $header);
curl_setopt($curl, CURLOPT_TIMEOUT, 10);
curl_setopt($curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC ) ;
curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, 0); // verify certificate
curl_setopt($curl, CURLOPT_SSL_VERIFYHOST, 2); // check existence of CN and verify that it matches hostname
curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($curl, CURLOPT_FORBID_REUSE, 1);
curl_setopt($curl, CURLOPT_FRESH_CONNECT, 1);
$responseString = curl_exec($curl);
if($responseString == false) {
$response = array('error' => curl_error($curl));
if($bpOptions['useLogging'])
bpLog('Error: ' . curl_error($curl));
} else {
$response = json_decode($responseString, true);
if (!$response) {
$response = array('error' => 'invalid json: '.$responseString);
if($bpOptions['useLogging'])
bpLog('Error - Invalid JSON: ' . $responseString);
}
}
curl_close($curl);
return $response;
} else {
curl_close($curl);
if($bpOptions['useLogging'])
bpLog('Invalid data found in apiKey value passed to bpCurl. (Failed: base64_encode(apikey))');
return array('error' => 'Invalid data found in apiKey value passed to bpCurl. (Failed: base64_encode(apikey))');
}
} catch (Exception $e) {
#curl_close($curl);
if($bpOptions['useLogging'])
bpLog('Error: ' . $e->getMessage());
return array('error' => $e->getMessage());
}
} else {
// Invalid parameter specified
if($bpOptions['useLogging'])
bpLog('Error: You must supply non-empty url and apiKey parameters.');
return array('error' => 'You must supply non-empty url and apiKey parameters.');
}
}
function bpCreateInvoice($orderId, $price, $posData, $options = array()) {
global $bpOptions;
try {
$options = array_merge($bpOptions, $options); // $options override any options found in bp_options.php
$pos = array('posData' => $posData);
if ($bpOptions['verifyPos'])
$pos['hash'] = bpHash(serialize($posData), $options['apiKey']);
$options['posData'] = json_encode($pos);
if(strlen($options['posData']) > 100)
return array('error' => 'posData > 100 character limit. Are you using the posData hash?');
$options['orderID'] = $orderId;
$options['price'] = $price;
$postOptions = array('orderID', 'itemDesc', 'itemCode', 'notificationEmail', 'notificationURL', 'redirectURL',
'posData', 'price', 'currency', 'physical', 'fullNotifications', 'transactionSpeed', 'buyerName',
'buyerAddress1', 'buyerAddress2', 'buyerCity', 'buyerState', 'buyerZip', 'buyerEmail', 'buyerPhone');
/* $postOptions = array('orderID', 'itemDesc', 'itemCode', 'notificationEmail', 'notificationURL', 'redirectURL',
'posData', 'price', 'currency', 'physical', 'fullNotifications', 'transactionSpeed', 'buyerName',
'buyerAddress1', 'buyerAddress2', 'buyerCity', 'buyerState', 'buyerZip', 'buyerEmail', 'buyerPhone',
'pluginName', 'pluginVersion', 'serverInfo', 'serverVersion', 'addPluginInfo');
*/
// Usage information for support purposes. Do not modify.
//$postOptions['pluginName'] = 'PHP Library';
//$postOptions['pluginVersion'] = '1.3';
//$postOptions['serverInfo'] = htmlentities($_SERVER['SERVER_SIGNATURE'], ENT_QUOTES);
//$postOptions['serverVersion'] = htmlentities($_SERVER['SERVER_SOFTWARE'], ENT_QUOTES);
//$postOptions['addPluginInfo'] = htmlentities($_SERVER['SCRIPT_FILENAME'], ENT_QUOTES);
foreach($postOptions as $o) {
if (array_key_exists($o, $options))
$post[$o] = $options[$o];
}
$post = json_encode($post);
$response = bpCurl('bitpay/api/invoice/';, $options['apiKey'], $post);
if($bpOptions['useLogging']) {
bpLog('Create Invoice: ');
bpLog($post);
bpLog('Response: ');
bpLog($response);
}
return $response;
} catch (Exception $e) {
if($bpOptions['useLogging'])
bpLog('Error: ' . $e->getMessage());
return array('error' => $e->getMessage());
}
}
function bpVerifyNotification($apiKey = false) {
global $bpOptions;
try {
if (!$apiKey)
$apiKey = $bpOptions['apiKey'];
$post = file_get_contents("php://input");
if (!$post)
return 'No post data';
$json = json_decode($post, true);
if (is_string($json))
return $json; // error
if (!array_key_exists('posData', $json))
return 'no posData';
$posData = json_decode($json['posData'], true);
if($bpOptions['verifyPos'] and $posData['hash'] != bpHash(serialize($posData['posData']), $apiKey))
return 'authentication failed (bad hash)';
$json['posData'] = $posData['posData'];
return $json;
} catch (Exception $e) {
if($bpOptions['useLogging'])
bpLog('Error: ' . $e->getMessage());
return array('error' => $e->getMessage());
}
}
function bpGetInvoice($invoiceId, $apiKey=false) {
global $bpOptions;
try {
if (!$apiKey)
$apiKey = $bpOptions['apiKey'];
$response = bpCurl('bitpay/invoice/'.$invoiceId, $apiKey);
if (is_string($response))
return $response; // error
$response['posData'] = json_decode($response['posData'], true);
$response['posData'] = $response['posData']['posData'];
return $response;
} catch (Exception $e) {
if($bpOptions['useLogging'])
bpLog('Error: ' . $e->getMessage());
return 'Error: ' . $e->getMessage();
}
}
function bpHash($data, $key) {
global $bpOptions;
try {
$hmac = base64_encode(hash_hmac('sha256', $data, $key, TRUE));
return strtr($hmac, array('+' => '-', '/' => '_', '=' => ''));
} catch (Exception $e) {
if($bpOptions['useLogging'])
bpLog('Error: ' . $e->getMessage());
return 'Error: ' . $e->getMessage();
}
}
function bpDecodeResponse($response) {
global $bpOptions;
try {
if (empty($response) || !(is_string($response)))
return 'Error: decodeResponse expects a string parameter.';
return json_decode($response, true);
} catch (Exception $e) {
if($bpOptions['useLogging'])
bpLog('Error: ' . $e->getMessage());
return 'Error: ' . $e->getMessage();
}
}
function bpCurrencyList() {
global $bpOptions;
$currencies = array();
$rate_url = 'bitpay/rates';;
try {
$clist = json_decode(file_get_contents($rate_url),true);
foreach($clist as $key => $value)
$currencies[$value['code']] = $value['name'];
return $currencies;
} catch (Exception $e) {
if($bpOptions['useLogging'])
bpLog('Error: ' . $e->getMessage());
return 'Error: ' . $e->getMessage();
}
}
function bpGetRate($code = 'USD') {
global $bpOptions;
$rate_url = 'bitpay/rates';;
try {
$clist = json_decode(file_get_contents($rate_url),true);
foreach($clist as $key => $value) {
if($value['code'] == $code)
$rate = number_format($value['rate'], 2, '.', '');
}
return $rate;
} catch (Exception $e) {
if($bpOptions['useLogging'])
bpLog('Error: ' . $e->getMessage());
return 'Error: ' . $e->getMessage();
}
}
send.php
$amount = $this->input->post('total_amount');
$id_order = $this->input->post('id_order');
$post_data = array(
'notificationURL' => '/completesubscription/bitpaynotification';,
'id_order' => $this->input->post('id_order')
);
$addl_options = array(
'itemDesc' => $this->input->get('option')
);
$response = bpCreateInvoice($id_order, $amount, $post_data, $addl_options);
if(!empty($response)){
header('Location:'.$response['url'].'');
notification.php
function BitpayNotification()
{
global $bpOptions;
$session_data = $this->session->userdata('logged_in');
echo $bpOptions['apiKey'];
$response = bpVerifyNotification($bpOptions['apiKey']);
$order_id = $response['posData'];
$sessionid = $order_id;
$this->createSubscribe($sessionid,$session_data['id']);
}
redirect.php
$data['method'] = 'bitpay';
$this->load->view('complete_subscribe_view', $data);
Thats please check and let me know if i did anything wrong.

Related

API post request executes successfully but data is not created in datto

API code executes successfully without giving any errors however the voucher am trying to create doesn't get created in datto below is the response am getting ,the highlighted text is the voucher am trying to create what might be the cause of this because the input body am sending is as indicate in their documentation https://github.com/cloudtrax/docs/blob/master/api/vouchers.md#actions
this is the response and the request code any help will be highly appreciated
<?php
$key = 'xxxxxxxx';
$secret='xxxxxxx';
class Method
{
const GET = 0;
const POST = 1;
const PUT = 2;
const DELETE = 3;
public static function nameForEnumValue($value) {
switch($value) {
case 0: return "GET";
case 1: return "POST";
case 2: return "PUT";
case 3: return "DELETE";
}
}
};
function print_debug_info($method, $endpoint, $headers) {
print( "\n" );
print( "Method: " . Method::nameForEnumValue($method) . "\n");
print( "Endpoint: " . $endpoint . "\n" );
print_r($headers);
}
function build_headers($auth, $sign) {
$headers = array();
$headers[] = "Authorization: " . $auth;
$headers[] = "Signature: " . $sign;
$headers[] = "Content-Type: application/json";
$headers[] = "OpenMesh-API-Version: 1";
return $headers;
}
function invoke_curl($method, $endpoint, $headers, $json) {
$api_server = 'https://api.cloudtrax.com';
try {
// get a curl handle then go to town on it
$ch = curl_init($api_server . $endpoint);
curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
if ($method == Method::DELETE)
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "DELETE");
elseif ($method == Method::PUT) {
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT");
curl_setopt($ch, CURLOPT_POSTFIELDS, $json);
}
else if ($method == Method::POST) {
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $json);
}
$result = curl_exec($ch);
if ($result == FALSE) {
if (curl_errno($ch) == 0)
echo "#### NOTE ####: nil HTTP return: This API call appears to be broken" . "\n";
else
throw new Exception(curl_error($ch), curl_errno($ch));
}
else
echo "RESULT: \n" . $result . "\n";
echo "RESULT: \n" . $json . "\n";
}
catch(Exception $e) {
trigger_error( sprintf('Curl failed with error #%d: "%s"',
$e->getCode(), $e->getMessage()), E_USER_ERROR);
}
}
function call_api_server($method, $endpoint, $data) {
global $key, $secret;
$time = time();
$nonce = rand();
if ($method == Method::POST)
assert( '$data != NULL /* #### POST requires $data #### */');
elseif ($method == Method::GET || $method == Method::DELETE)
assert( '$data == NULL /* ### GET and DELETE take no $data ### */');
$path = $endpoint;
// if present, concatenate encoded json to $endpoint for Signature:
if ($data != NULL) {
$json = json_encode($data);
$path .= $json;
}
$authorization = "key=" . $key . ",timestamp=" . $time . ",nonce=" . $nonce;
$signature = hash_hmac('sha256', $authorization . $path . $body, $secret);
$headers = build_headers($authorization, $signature);
print_debug_info($method, $endpoint, $headers);
invoke_curl($method, $endpoint, $headers, $json);
}
$uniqueKey=strtoupper(substr(sha1(microtime()), rand(0, 6), 6));
$uniqueKey = implode("-", str_split($uniqueKey, 6));
echo($uniqueKey);
$data =array('desired_vouchers',[
'code'=>$uniqueKey,
//'code'=>0103,
'duration'=> 24,
'max_users'=> 4,
'up_limit'=> 20,
'down_limit'=> 40,
'comment'=> "Courtesy of API Test",
'purge_days'=> 5
] );
call_api_server(Method::POST, "/voucher/network/xxxxx",$data);
//call_api_server(Method::GET, "/dna-api/v1/login",Null);
//call_api_server(Method::GET, "/dna-api/doc#get--dna-api-v1-routers-{mac}",Null);
//call_api_server(Method::GET, "/dna-api/v1/users/xxxx/overview",Null);
?>

Sending SMS Not working With Sinch in Laravel

Sending SMS Not working With Sinch in Laravel .
I've done everything and I don't know to do anything else.
I am trying to send an SMS using Sinch but I am Not getting anything.
I am Wrote key and secret right and phone number.
but I don't know. Is there something missing or not?
You can see my code below.
<?php
class SinchController
{
var $key = "xxxxxxxxxx";
var $secret = "xxxxxxxxx";
var $contentType = "application/json";
var $baseurl = " https://verificationapi-v1.sinch.com";
var $ch;
public function index()
{
$countryCode = "+20";
$phoneNumber = "xxxxxxx";
$receivedCode = "4444";
$result = $this->verifyMobile($countryCode . $phoneNumber, $receivedCode);
}
public function sendCode($mobile)
{
$url_path = $this->encodeurl('/verification/v1/verifications');
$this->ch = curl_init($this->baseurl . $url_path);
$this->setupDefault();
$this->setupSendData($mobile, $url_path);
$return = $this->getResult();
return $return;
}
public function verifyMobile($mobile, $code)
{
$url_path = $this->encodeurl('/verification/v1/verifications/number/' . $mobile);
$this->ch = curl_init($this->baseurl . $url_path);
$this->setupDefault();
$this->setupVerifyData($code, $url_path);
$return = $this->getResult();
return $return;
}
private function setupDefault()
{
curl_setopt($this->ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($this->ch, CURLOPT_SSL_VERIFYPEER, false);
}
private function setupVerifyData($code, $url_path)
{
$data = json_encode([
'method' => 'sms',
'sms' => [
'code' => (string)$code
]
]);
curl_setopt($this->ch, CURLOPT_CUSTOMREQUEST, "PUT");
curl_setopt($this->ch, CURLOPT_POSTFIELDS, $data);
$this->signedHeaders("PUT", $data, $url_path);
}
private function setupSendData($mobile, $url_path)
{
$data = json_encode([
'identity' => [
'type' => 'number',
'endpoint' => $mobile,
],
'method' => 'sms'
]);
curl_setopt($this->ch, CURLOPT_POSTFIELDS, $data);
curl_setopt($this->ch, CURLOPT_POST, true);
$this->signedHeaders("POST", $data, $url_path);
}
private function getResult()
{
$result = curl_exec($this->ch);
$return = [];
if (curl_errno($this->ch)) {
$return['error'] = curl_error($this->ch);
} else {
$return['data'] = $result;
}
return $result;
}
private function compileContentType()
{
return 'content-type: ' . $this->contentType;
}
private function signedHeaders($method, $body, $url_path)
{
$method = strtoupper($method);
$date = date("c");
$contentMd5 = base64_encode(md5(utf8_encode($body), true));
$xTimestamp = "x-timestamp:" . $date;
$StringToSign = $method . "\n" .
$contentMd5 . "\n" .
$this->contentType . "\n" .
$xTimestamp . "\n" .
$url_path;
$signature = base64_encode(hash_hmac("sha256", utf8_encode($StringToSign), base64_decode($this->secret), true));
$Authorization = 'Authorization: Application ' . $this->key . ":" . $signature;
$headers = [
$this->compileContentType(),
$Authorization,
$xTimestamp
];
curl_setopt($this->ch, CURLOPT_HTTPHEADER, $headers);
}
private function encodeurl($url)
{
$url_ = urlencode(utf8_encode($url));
$url_ = str_replace("\\+", "%20", $url_);
$url_ = str_replace("\\%7E", "~", $url_);
return $url;
}
}
Result in postman

WSOD on PHP script

Every time I run the code below, I get a WSOD. Not sure what I'm doing wrong with this code. Nothing gets logged and I've verified my php.ini configurations are well set to display all errors. Any help on this would be appreciated.
// MAIN BIDDING FUNCTION MAIN BIDDING FUNCTION
// this function performs no checking on the input variables
$username = '1*****';
$password = '******';
$item = '*******';
$bid = '***.**';
// $link - itemlink with referral, can leave empty i.e. ''
function place_bid($username, $password, $item, $bid, $link) {
$cookies = dirname(__FILE__).'/cookies.txt';
//set success as default false
$success = false;
$bid_success = false;
$curl = curl_init();
curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($curl, CURLOPT_USERAGENT, 'Mozilla/5.0 (Windows; U; Windows NT 5.0; en-US; rv:1.4) Gecko/20030624 Netscape/7.1 (ax)');
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_FOLLOWLOCATION, true);
curl_setopt($curl, CURLOPT_REFERER, $link);
curl_setopt($curl, CURLOPT_COOKIEFILE, $cookies);
curl_setopt($curl, CURLOPT_COOKIEJAR, $cookies);
//query the sign-out page
//curl_setopt($curl, CURLOPT_URL, "https://signin.ebay.com/ws/eBayISAPI.dll?SignIn&lgout=1");
//$ret = curl_exec ($curl);
//query the referal link page
if ($link) {
curl_setopt($curl, CURLOPT_URL, $link);
$ret = curl_exec ($curl);
}
//IMPORTANT
//query the sign-in page to set the cookies
curl_setopt($curl, CURLOPT_URL, 'https://signin.ebay.com/aw-cgi/eBayISAPI.dll?SignIn&campid=5337161990&customid=7');
$ret = curl_exec ($curl);
$data = [];
$numbers = [];
if (preg_match('%(<form name="SignInForm".*?<\/form)%im', $ret, $regs)) {
$dom = new DOMDocument;
$dom-loadHTML($regs[0]);
$nodes = $dom-getElementsByTagName('input');
foreach($nodes as $node) {
$name = $node-getAttribute('name');
$value = $node-getAttribute('value');
//$size = $node-getAttribute('size');
$type = $node-getAttribute('type');
$data[$name] = $value;
if (is_numeric($name)) {
if ($type == 'text') {
$data[$name] = $username;
}
if ($type == 'password') {
$data[$name] = $password;
}
}
}
}
unset($data['']);
$data_str = http_build_query($data);
//sign-in
curl_setopt($curl, CURLOPT_URL, "https://signin.ebay.com/ws/eBayISAPI.dll?co_partnerId=2&siteid=0&UsingSSL=1");
curl_setopt($curl, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($curl, CURLOPT_POSTFIELDS, $data_str);
$ret = curl_exec ($curl);
if(curl_errno($curl)){
ebaylog('Curl error: ' . curl_error($curl));
}
if (!$ret) {
$ret = curl_exec ($curl);
if(curl_errno($curl)){
ebaylog('Curl error: ' . curl_error($curl));
}
if (!$ret) {
$ret = curl_exec ($curl);
if(curl_errno($curl)){
ebaylog('Curl error: ' . curl_error($curl));
}
}
}
curl_setopt($curl, CURLOPT_URL, 'https://www.ebay.com/myb/WatchList');
$ret = curl_exec ($curl);
//test_write($ret);
if(curl_errno($curl)){
ebaylog('Curl error: ' . curl_error($curl));
}
if (!$ret) {
$ret = curl_exec ($curl);
if(curl_errno($curl)){
ebaylog('Curl error: ' . curl_error($curl));
}
if (!$ret) {
$ret = curl_exec ($curl);
if(curl_errno($curl)){
ebaylog('Curl error: ' . curl_error($curl));
}
}
}
//if (strpos($ret, '"loggedIn":true') === FALSE) {
if ((strpos($ret, "userid={$username}") === FALSE) && (strpos($ret, "usr/{$username}") === FALSE)) {
if (preg_match('%<b class="altTitle"(.*)</b%', $ret, $regs)) {
$err = $regs[1];
ebaylog("\"{$err}\"");
if (strpos($err, 'The alerts below') === 0) {
ebaylog("{$item}: 'The alerts below' found, successful");
//set it to succes
}
} else {
ebaylog("{$item}: Failed signing in");
if (preg_match('%<font face=".*?" size="3"<b(.*?)</b</font%', $ret, $regs)) {
$err = $regs[1];
ebaylog("\"{$err}\"");
}
//test_write($ret);
goto end;
}
} else {
ebaylog("{$item}: Success signing in");
}
//place the inital bid
curl_setopt($curl, CURLOPT_URL, "https://offer.ebay.com/ws/eBayISAPI.dll?MakeBid&item={$item}&maxbid={$bid}&campid=5337161990&customid=7");
$ret = curl_exec ($curl);
if(curl_errno($curl)){
ebaylog('Curl error: ' . curl_error($curl));
}
if (!$ret) {
$ret = curl_exec ($curl);
}
if (preg_match_all('/(?:value="([-0-9a-zA-Z]*)" *)?name="stok"(?: *value="([-0-9a-zA-Z]*)")?/', $ret, $regs)) {
$stok = $regs[1][0];
} else {
//Failed to get 'stok' value
//try and determine why
if (preg_match('%<div class="statusDiv"(.*?)</div%', $ret, $regs)) {
$err = $regs[1];
ebaylog("'{$err}'");
//if string starts with "Enter US $0.41 or more"
if (stripos($err, 'Enter') === 0) {
ebaylog("{$item}: 'Enter' found, aborting");
//set it to success
$success = true;
} else if (stripos($err, 'To enter a') === 0) {
ebaylog("{$item}: 'To enter a' found, aborting");
//set it to success
$success = true;
} else if (stripos($err, 'Transaction Blocked') === 0) {
ebaylog("{$item}: 'Transaction Blocked' found, aborting");
//set it to success
$success = true;
}
} else if (preg_match('%"\d*" - Invalid Item</div%', $subject)) {
ebaylog("{$item}: 'Invalid Item' found, aborting");
test_write($ret);
//set it to success
$success = true;
} else if (preg_match('%<div class="subTlt"<ul class="errList"<li(.*?)</li</ul</div%', $subject)) {
ebaylog("{$item}: 'no longer available' found, aborting");
test_write($ret);
//set it to success
$success = true;
} else if (preg_match('%id="w\d-\d-_msg".*?(.*?)</span%', $ret, $regs)) {
ebaylog("'{$regs[1]}'");
} else if (preg_match('%<div\s+class\s*=\s*"(?:errRed|errBlk|errTitle|statusDiv)"\s*(.*?)</div%i', $ret, $regs)) {
ebaylog("'{$regs[1]}'");
} else {
//don't know why so log the page
ebaylog("{$item}: Failed to get 'stok' value");
test_write($ret);
}
goto end;
}
if (preg_match_all('/(?:value="([-0-9a-zA-Z]*)" *)?name="uiid"(?: *value="([-0-9a-zA-Z]*)")?/', $ret, $regs)) {
$uiid = $regs[1][0];
} else {
ebaylog("{$item}: Failed to get 'uiid' value");
goto end;
}
if ($stok && $uiid) {
ebaylog("{$item}: Success placing initial bid");
} else {
ebaylog("{$item}: Failed placing initial bid");
goto end;
}
//confirm the bid
curl_setopt($curl, CURLOPT_URL, "https://offer.ebay.com/ws/eBayISAPI.dll?MfcISAPICommand=MakeBid&maxbid={$bid}&quant=1&mode=1&stok={$stok}&uiid={$uiid}&co_partnerid=2&user={$username}&fb=0&item={$item}&campid=5337161990&customid=7");
$ret = curl_exec ($curl);
if(curl_errno($curl)){
ebaylog('Curl error: ' . curl_error($curl));
}
if (!$ret) {
$ret = curl_exec ($curl);
}
//perform a number of tests to determine if the bid was a success
$bid_success = true;
if (stripos($ret, "you're the first bidder") === FALSE) {
if (stripos($ret, "you're the high bidder and currently in the lead") === FALSE) {
if (stripos($ret, "you're currently the highest bidder") === FALSE) {
$bid_success = false;
ebaylog("{$item}: Failed placing final bid");
//try and determine why
if (preg_match('%<div\s+class\s*=\s* (?:errRed|errBlk|errTitle|statusDiv|title)"\s*(.*?)</div%i', $ret, $regs)) {
$err = $regs[1];
ebaylog("'{$err}'");
if (stripos($err, 'Enter') === 0) {
ebaylog("{$item}: 'Enter' found, aborting");
//set it to success
$bid_success = true;
} else if (stripos($err, "You've just been outbid") === 0) {
ebaylog("{$item}: 'You've just been outbid' found, aborting");
//set it to success
$bid_success = true;
} else if (stripos($err, "You're currently the high bidder,") === 0) {
ebaylog("{$item}: 'You're currently the high bidder, but the reserve hasn't been met.' found, aborting");
//set it to success
$bid_success = true;
}
} else {
//we don't know why it failed so write the data
test_write($ret);
}
}
}
}
if ($bid_success) {
ebaylog("{$item}: Success placing final bid");
$success = true;
}
end:
//close the curl session
curl_close ($curl);
if ($success) {
ebaylog("{$item}: Success: {$username}");
} else {
ebaylog("{$item}: Failure: {$username}");
}
return $success;
}
?

Gmail contacts API.3 in php, how to get name and phone from contact?

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]);

LinkedIn API + PHP: request token remains blank

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;
}

Categories