hi every one ,i am integrating soundcloud api but getting problem of two times login which i does not want.only login on my site my code is (index.php)
<?php
require_once 'oauth.php';
require_once 'soundcloud.php';
session_start();
if (isset($_GET['logout'])) {
session_destroy();
}
$consumer_key = 'iwixmwcVHP2W79sRb65hw';//consumer key
$consumer_secret = 'IwPOX1tPIvxbehvE6tHmJK7Hgw6F2Y0gOpcuRpB1E';// consumer secret
$callback_url = 'http://localhost/funkeymusic/index.php';//
$tmp_path = $_SERVER['DOCUMENT_ROOT'].'/bids4less/funkeymusic/upload/';
$oauth_token = (isset($_GET['oauth_verifier'])) ? $_GET['oauth_verifier']
: ((isset($_SESSION['oauth_access_token'])) ? $_SESSION['oauth_access_token'] : NULL);
$oauth_request_token = (isset($_SESSION['oauth_request_token']))?$_SESSION['oauth_request_token']
: NULL;
$oauth_request_token_secret = (isset($_SESSION['oauth_request_token_secret']))
? $_SESSION['oauth_request_token_secret'] : NULL;
if (isset($oauth_token) && isset($oauth_request_token) && isset($oauth_request_token_secret)) {
if (!isset($_SESSION['oauth_access_token']) && !isset($_SESSION['oauth_access_token_secret'])) {
$soundcloud = new Soundcloud($consumer_key, $consumer_secret,$_SESSION['oauth_request_token'], $_SESSION['oauth_request_token_secret']
);
$token = $soundcloud->get_access_token($oauth_token);
$_SESSION['oauth_access_token'] = $token['oauth_token'];
$_SESSION['oauth_access_token_secret'] = $token['oauth_token_secret'];
}
$soundcloud = new Soundcloud(
$consumer_key,
$consumer_secret,
$_SESSION['oauth_access_token'],
$_SESSION['oauth_access_token_secret']
);
$me = $soundcloud->request('http://api.soundcloud.com/me');
$me = new SimpleXMLElement($me);
$me = get_object_vars($me);
$me1 = $soundcloud->request('http://api.soundcloud.com/me/tracks');
$me1 = new SimpleXMLElement($me1);
if (isset($_POST['submit'])) {
$mimes = array('aac' => 'video/mp4','aiff' => 'audio/x-aiff','flac' => 'audio/flac', 'mp3' => 'audio/mpeg','ogg' => 'audio/ogg', 'wav' => 'audio/x-wav'
);
$extension = explode('.', $_FILES['file']['name']);
$extension = (isset($extension[count($extension) - 1]))
? $extension[count($extension) - 1] : NULL;
$mime = (isset($mimes[$extension])) ? $mimes[$extension] : NULL;
if (isset($mime)) {
$tmp_file = $tmp_path . $_FILES['file']['name'];
if (move_uploaded_file($_FILES['file']['tmp_name'], $tmp_file)) {
$post_data = array( 'track[title]' => stripslashes($_POST['title']),
'track[asset_data]' => realpath($tmp_file), 'track[sharing]' => 'private' );
if ($response = $soundcloud->upload_track($post_data, $mime)) {
$response = new SimpleXMLElement($response);
$response = get_object_vars($response);
$message = 'Success! <a href="' . $response['permalink-url'] . '">Your track</a> has been uploaded!';
unlink(realpath($tmp_file));
} else {
$message = 'Something went wrong while talking to SoundCloud, please try again.';
}
} else {
$message = 'Couldn\'t move file, make sure the temporary path is ';
}
} else {
$message = 'SoundCloud support .mp3, .aiff, .wav, .flac, .aac, and .ogg ';
}
}
} else {
$soundcloud = new Soundcloud($consumer_key, $consumer_secret);
$token = $soundcloud->get_request_token($callback_url);
$_SESSION['oauth_request_token'] = $token['oauth_token'];
$_SESSION['oauth_request_token_secret'] = $token['oauth_token_secret'];
$login = $soundcloud->get_authorize_url($token['oauth_token']);
} ?>
above is php code in php and html portion is no giving due to word limit and soundcloud.php is
<?php
class Soundcloud {
public static $urls = array('api' => 'http://api.soundcloud.com/',
'oauth' => array('access' => 'http://api.soundcloud.com/oauth/access_token',
'authorize' => 'http://soundcloud.com/oauth/authorize',
'request' => 'http://api.soundcloud.com/oauth/request_token'
) );
function __construct($consumer_key, $consumer_secret, $oauth_token = null, $oauth_token_secret = null) {
$this->sha1_method = new OAuthSignatureMethod_HMAC_SHA1();
$this->consumer = new OAuthConsumer($consumer_key, $consumer_secret);
if (!empty($oauth_token) && !empty($oauth_token_secret)) {
$this->token = new OAuthConsumer($oauth_token, $oauth_token_secret);
} else { $this->token = null;
}
}
function get_authorize_url($token) {
if (is_array($token)) {
$token = $token['oauth_token'];
}
return $this->_get_url('authorize') . '?oauth_token=' . $token;
}
function get_request_token($oauth_callback) {
$request = $this->request($this->_get_url('request'), 'POST', array('oauth_callback' => $oauth_callback) );
$token = $this->_parse_response($request);
$this->token = new OAuthConsumer($token['oauth_token'], $token['oauth_token_secret']
);
return $token;
}
function get_access_token($token) {
$response = $this->request(
$this->_get_url('access'),
'POST',
array('oauth_verifier' => $token)
);
$token = $this->_parse_response($response);
$this->token = new OAuthConsumer(
$token['oauth_token'],
$token['oauth_token_secret']
);
return $token;
}
function upload_track($post_data, $asset_data_mime = null, $artwork_data_mime = null) {
$body = '';
$boundary = '---------------------------' . md5(rand());
$crlf = "\r\n";
$headers = array('Content-Type' => 'multipart/form-data; boundary=' . $boundary, 'Content-Length' => 0 );
foreach ($post_data as $key => $val) {
if (in_array($key, array('track[asset_data]', 'track[artwork_data]'))) {
$body .= '--' . $boundary . $crlf;
$body .= 'Content-Disposition: form-data; name="' . $key . '"; filename="' . basename($val) . '"' . $crlf;
$body .= 'Content-Type: ' . (($key == 'track[asset_data]') ? $asset_data_mime : $artwork_data_mime) . $crlf;
$body .= $crlf;
$body .= file_get_contents($val) . $crlf;
} else {
$body .= '--' . $boundary . $crlf;
$body .= 'Content-Disposition: form-data; name="' . $key .'"' . $crlf;
$body .= $crlf;
$body .= $val . $crlf;
} }
$body .= '--' . $boundary . '--' . $crlf;
$headers['Content-Length'] += strlen($body);
return $this->request('tracks', 'POST', $body, $headers);
}
function request($resource, $method = 'GET', $args = array(), $headers = null) {
if (!preg_match('/http:\/\//', $resource)) {
$url = self::$urls['api'] . $resource;
} else { $url = $resource;
}
if (stristr($headers['Content-Type'], 'multipart/form-data')) {
$body = false;
} elseif (stristr($headers['Content-Type'], 'application/xml')) {
$body = false;
} else { $body = true;
}
$request = OAuthRequest::from_consumer_and_token($this->consumer, $this->token,
$method,
$url, ($body === true) ? $args : null
);
$request->sign_request($this->sha1_method, $this->consumer, $this->token);
return $this->_curl( $request->get_normalized_http_url(), $request,$args,$headers );
}
private function _build_header($headers) {
$h = array();
if (count($headers) > 0) {
foreach ($headers as $key => $val) {
$h[] = $key . ': ' . $val;
}
return $h;
} else { return $headers;
}
}
private function _curl($url, $request, $post_data = null, $headers = null) {
$ch = curl_init();
$mime = (stristr($headers['Content-Type'], 'multipart/form-data')) ? true : false;
$headers['User-Agent'] = (isset($headers['User-Agent']))
? $headers['User-Agent']: 'PHP SoundCloud/' . self::VERSION;
$headers['Content-Length'] = (isset($headers['Content-Length']))
? $headers['Content-Length'] : 0;
$headers = (is_array($headers)) ? $this->_build_header($headers) : array();
$options = array( CURLOPT_URL => $url, CURLOPT_HEADER => false,
CURLOPT_RETURNTRANSFER => true
);
if (in_array($request->get_normalized_http_method(), array('DELETE', 'PUT'))) {
$options[CURLOPT_CUSTOMREQUEST] = $request->get_normalized_http_method();
$options[CURLOPT_POSTFIELDS] = '';
}
if (is_array($post_data) && count($post_data) > 0 || $mime === true) {
$options[CURLOPT_POSTFIELDS] = (is_array($post_data) && count($post_data) == 1)
? ((isset($post_data[key($post_data)])) ? $post_data[key($post_data)] : $post_data)
: $post_data;
$options[CURLOPT_POST] = true;
}
$headers[] = $request->to_header();
$options[CURLOPT_HTTPHEADER] = $headers;
curl_setopt_array($ch, $options);
$response = curl_exec($ch);
$this->http_status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
return $response;
}
private function _get_url($type) {
return (array_key_exists($type, self::$urls['oauth']))
? self::$urls['oauth'][$type]: false;
}
private function _parse_response($response) {
parse_str($response, $output);
return (count($output) > 0) ? $output : false;
}}
and oauth.php is
<?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 {
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();
} }
class OAuthSignatureMethod {
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) {
$sig = array(OAuthUtil::urlencode_rfc3986($consumer->secret));
if ($token) {
array_push($sig, OAuthUtil::urlencode_rfc3986($token->secret));
} else {
array_push($sig, '');
}
$raw = implode("&", $sig);
$request->base_string = $raw;
return OAuthUtil::urlencode_rfc3986($raw);
}
}
class OAuthSignatureMethod_RSA_SHA1 extends OAuthSignatureMethod {
public function get_name() {
return "RSA-SHA1";
}
protected function fetch_public_cert(&$request) {
throw Exception("fetch_public_cert not implemented");
}
protected function fetch_private_cert(&$request) {
throw Exception("fetch_private_cert not implemented");
}
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;
public $base_string;
public static $version = '1.0';
function __construct($http_method, $http_url, $parameters=NULL) {
@$parameters or $parameters = array();
$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'];
$request_headers = OAuthRequest::get_headers();
if ($parameters) {
$req = new OAuthRequest($http_method, $http_url, $parameters);
} else {
$req_parameters = $_GET;
if ($http_method == "POST" && @strstr($request_headers["Content-Type"], "application/x-www-form-urlencoded") ) {
$req_parameters = array_merge($req_parameters, $_POST);
}
if (@substr($request_headers['Authorization'], 0, 6) == "OAuth ") {
$header_parameters = OAuthRequest::split_header($request_headers['Authorization']);
$parameters = array_merge($req_parameters, $header_parameters);
$req = new OAuthRequest($http_method, $http_url, $parameters);
} else $req = new OAuthRequest($http_method, $http_url, $req_parameters);
}
return $req;
}
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);
$parameters = array_merge($defaults, $parameters);
if ($token) {
$parameters['oauth_token'] = $token->key;
}
return new OAuthRequest($http_method, $http_url, $parameters);
}
public function set_parameter($name, $value) {
$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 get_signable_parameters() {
$params = $this->parameters;
if (isset($params['oauth_signature'])) {
unset($params['oauth_signature']);
}
$keys = OAuthUtil::urlencode_rfc3986(array_keys($params));
$values = OAuthUtil::urlencode_rfc3986(array_values($params));
$params = array_combine($keys, $values);
uksort($params, 'strcmp');
$pairs = array();
foreach ($params as $key=>$value ) {
if (is_array($value)) {
natsort($value);
foreach ($value as $v2) {
$pairs[] = $key . '=' . $v2;
}
} else {
$pairs[] = $key . '=' . $value;
}
}
return implode('&', $pairs);
}
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() {
$out = $this->get_normalized_http_url() . "?";
$out .= $this->to_postdata();
return $out;
}
public function to_postdata() {
$total = array();
foreach ($this->parameters as $k => $v) {
if (is_array($v)) {
foreach ($v as $va) {
$total[] = OAuthUtil::urlencode_rfc3986($k) . "[]=" . OAuthUtil::urlencode_rfc3986($va);
}
} else {
$total[] = OAuthUtil::urlencode_rfc3986($k) . "=" . OAuthUtil::urlencode_rfc3986($v);
}
}
$out = implode("&", $total);
return $out;
}
public function to_header() {
$out ='Authorization: OAuth realm=""';
$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());
$signature = $this->build_signature($signature_method, $consumer, $token);
$this->set_parameter("oauth_signature", $signature);
}
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);
}
private static function split_header($header) {
$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];
$params[$header_name] = OAuthUtil::urldecode_rfc3986( $header_content );
$offset = $match[1] + strlen($match[0]);
}
if (isset($params['realm'])) {
unset($params['realm']);
}
return $params;
}
private static function get_headers() {
if (function_exists('apache_request_headers')) {
return apache_request_headers();
}
$out = array();
foreach ($_SERVER as $key => $value) {
if (substr($key, 0, 5) == "HTTP_") {
$key = str_replace(" ", "-", ucwords(strtolower(str_replace("_", " ", substr($key, 5)))));
$out[$key] = $value;
}
}
return $out;
}
}
class OAuthServer {
protected $timestamp_threshold = 300;
protected $version = 1.0;
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);
$new_token = $this->data_store->new_request_token($consumer);
return $new_token;
}
public function fetch_access_token(&$request) {
$this->get_version($request);
$consumer = $this->get_consumer($request);
$token = $this->get_token($request, $consumer, "request");
$this->check_signature($request, $consumer, $token);
$new_token = $this->data_store->new_access_token($token, $consumer);
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) {
$version = 1.0;
}
if ($version && $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) {
$signature_method = "PLAINTEXT";
}
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) {
$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) {
$now = time();
if ($now - $timestamp > $this->timestamp_threshold) {
throw new OAuthException("Expired timestamp, yours $timestamp, ours $now");
}
}
private function check_nonce($consumer, $token, $nonce, $timestamp) {
$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) {
}
function lookup_token($consumer, $token_type, $token) {
}
function lookup_nonce($consumer, $token, $nonce, $timestamp) {
}
function new_request_token($consumer) {
}
function new_access_token($token, $consumer) {
}
}
class SimpleOAuthDataStore extends OAuthDataStore {
private $dbh;
function __construct($path = "oauth.gdbm") {
$this->dbh = dba_popen($path, 'c', 'gdbm');
}
function __destruct() {
dba_close($this->dbh);
}
function lookup_consumer($consumer_key) {
$rv = dba_fetch("consumer_$consumer_key", $this->dbh);
if ($rv === FALSE) {
return NULL;
}
$obj = unserialize($rv);
if (!($obj instanceof OAuthConsumer)) {
return NULL;
}
return $obj;
}
function lookup_token($consumer, $token_type, $token) {
$rv = dba_fetch("${token_type}_${token}", $this->dbh);
if ($rv === FALSE) {
return NULL;
}
$obj = unserialize($rv);
if (!($obj instanceof OAuthToken)) {
return NULL;
}
return $obj;
}
function lookup_nonce($consumer, $token, $nonce, $timestamp) {
if (dba_exists("nonce_$nonce", $this->dbh)) {
return TRUE;
} else {
dba_insert("nonce_$nonce", "1", $this->dbh);
return FALSE;
}
}
function new_token($consumer, $type="request") {
$key = md5(time());
$secret = time() + time();
$token = new OAuthToken($key, md5(md5($secret)));
if (!dba_insert("${type}_$key", serialize($token), $this->dbh)) {
throw new OAuthException("doooom!");
}
return $token;
}
function new_request_token($consumer) {
return $this->new_token($consumer, "request");
}
function new_access_token($token, $consumer) {
$token = $this->new_token($consumer, 'access');
dba_delete("request_" . $token->key, $this->dbh);
return $token;
}
}
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 rawurldecode($string);
}
}
i need to user who login to mywebsite does not need to login again to soundcloud and can upload their track .