Jetpack_Client_Server::client_authorize() - Code Metrics - Inspection of "Bug fix: load jetpack sync users class more often." - Automattic/jetpack - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — branch-4.2 ( 44dd81...6c890d )

by Jeremy

created 2016-07-08 13:20 UTC

Jetpack_Client_Server::client_authorize() A

↳ Parent: Jetpack_Client_Server

Complexity

Conditions	4
Paths	8

Size

Total Lines	21
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	4
eloc	14
c	1
b	0
f	0
nc	8
nop	0
dl	0
loc	21
rs	9.0534

<?php

/**
 * Client = Plugin
 * Client Server = API Methods the Plugin must respond to
 */
class Jetpack_Client_Server {

	/**
	 * Authorizations
	 */
	function client_authorize() {
		$data              = stripslashes_deep( $_GET );
		$data['auth_type'] = 'client';
		$role              = Jetpack::translate_current_user_to_role();
		$redirect          = isset( $data['redirect'] ) ? esc_url_raw( (string) $data['redirect'] ) : '';

		$this->check_admin_referer( "jetpack-authorize_{$role}_{$redirect}" );

		$result = $this->authorize( $data );
		if ( is_wp_error( $result ) ) {
			Jetpack::state( 'error', $result->get_error_code() );
		}

		if ( wp_validate_redirect( $redirect ) ) {
			$this->wp_safe_redirect( $redirect );
		} else {
			$this->wp_safe_redirect( Jetpack::admin_url() );
		}

		$this->do_exit();
	}

	function authorize( $data = array() ) {
		$redirect = isset( $data['redirect'] ) ? esc_url_raw( (string) $data['redirect'] ) : '';
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

		$jetpack_unique_connection = Jetpack_Options::get_option( 'unique_connection' );
		// Checking if site has been active/connected previously before recording unique connection
		if ( ! $jetpack_unique_connection ) {
			// jetpack_unique_connection option has never been set
			$jetpack_unique_connection = array(
				'connected'     => 0,
				'disconnected'  => 0,
				'version'       => '3.6.1',
			);

			update_option( 'jetpack_unique_connection', $jetpack_unique_connection );

			//track unique connection
			$jetpack = $this->get_jetpack();;
// Bad
$a = 5; $b = 6; $c = 7;

// Good
$a = 5;
$b = 6;
$c = 7;

			$jetpack->stat( 'connections', 'unique-connection' );
			$jetpack->do_stats( 'server_side' );
		}

		// increment number of times connected
		$jetpack_unique_connection['connected'] += 1;
		Jetpack_Options::update_option( 'unique_connection', $jetpack_unique_connection );

		$role = Jetpack::translate_current_user_to_role();

		if ( ! $role ) {
			return new Jetpack_Error( 'no_role', 'Invalid request.', 400 );
		}

		$cap = Jetpack::translate_role_to_cap( $role );
		if ( ! $cap ) {
			return new Jetpack_Error( 'no_cap', 'Invalid request.', 400 );
		}

		if ( ! empty( $data['error'] ) ) {
			return new Jetpack_Error( $data['error'], 'Error included in the request.', 400 );
		}

		if ( ! isset( $data['state'] ) ) {
			return new Jetpack_Error( 'no_state', 'Request must include state.', 400 );
		}

		if ( ! ctype_digit( $data['state'] ) ) {
			return new Jetpack_Error( $data['error'], 'State must be an integer.', 400 );
		}

		$current_user_id = get_current_user_id();
		if ( $current_user_id != $data['state'] ) {
			return new Jetpack_Error( 'wrong_state', 'State does not match current user.', 400 );
		}

		if ( empty( $data['code'] ) ) {
			return new Jetpack_Error( 'no_code', 'Request must include an authorization code.', 400 );
		}

		$token = $this->get_token( $data );

		if ( is_wp_error( $token ) ) {
			$code = $token->get_error_code();
			if ( empty( $code ) ) {
				$code = 'invalid_token';
			}
			return new Jetpack_Error( $code, $token->get_error_message(), 400 );
		}

		if ( ! $token ) {
			return new Jetpack_Error( 'no_token', 'Error generating token.', 400 );
		}

		$is_master_user = ! Jetpack::is_active();

		Jetpack::update_user_token( $current_user_id, sprintf( '%s.%d', $token, $current_user_id ), $is_master_user );

		if ( ! $is_master_user ) {
			// Don't activate anything since we are just connecting a user.
			return 'linked';
		}

		$redirect_on_activation_error = ( 'client' === $data['auth_type'] ) ? true : false;
		if ( $active_modules = Jetpack_Options::get_option( 'active_modules' ) ) {
			Jetpack_Options::delete_option( 'active_modules' );

			Jetpack::activate_default_modules( 999, 1, $active_modules, $redirect_on_activation_error );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		} else {
			Jetpack::activate_default_modules( false, false, array(), $redirect_on_activation_error );
		}
		
		// Start nonce cleaner
		wp_clear_scheduled_hook( 'jetpack_clean_nonces' );
		wp_schedule_event( time(), 'hourly', 'jetpack_clean_nonces' );

		return 'authorized';
	}

	public static function deactivate_plugin( $probable_file, $probable_title ) {
		include_once( ABSPATH . 'wp-admin/includes/plugin.php' );
		if ( is_plugin_active( $probable_file ) ) {
			deactivate_plugins( $probable_file );
			return 1;
		} else {
			// If the plugin is not in the usual place, try looking through all active plugins.
			$active_plugins = Jetpack::get_active_plugins();
			foreach ( $active_plugins as $plugin ) {
				$data = get_plugin_data( WP_PLUGIN_DIR . '/' . $plugin );
				if ( $data['Name'] == $probable_title ) {
					deactivate_plugins( $plugin );
					return 1;
				}
			}
		}

		return 0;
	}

	/**
	 * @return object|WP_Error
	 */
	function get_token( $data ) {
		$role = Jetpack::translate_current_user_to_role();

		if ( ! $role ) {
			return new Jetpack_Error( 'role', __( 'An administrator for this blog must set up the Jetpack connection.', 'jetpack' ) );
		}

		$client_secret = Jetpack_Data::get_access_token();
		if ( ! $client_secret ) {
			return new Jetpack_Error( 'client_secret', __( 'You need to register your Jetpack before connecting it.', 'jetpack' ) );
		}

		$redirect = isset( $data['redirect'] ) ? esc_url_raw( (string) $data['redirect'] ) : '';
		$redirect_uri = ( 'calypso' === $data['auth_type'] )
			? $data['redirect_uri']
			: add_query_arg( array(
				'action' => 'authorize',
				'_wpnonce' => wp_create_nonce( "jetpack-authorize_{$role}_{$redirect}" ),
				'redirect' => $redirect ? urlencode( $redirect ) : false,
			), menu_page_url( 'jetpack', false ) );

		$body = array(
			'client_id' => Jetpack_Options::get_option( 'id' ),
			'client_secret' => $client_secret->secret,
			'grant_type' => 'authorization_code',
			'code' => $data['code'],
			'redirect_uri' => $redirect_uri,
		);

		$args = array(
			'method' => 'POST',
			'body' => $body,
			'headers' => array(
				'Accept' => 'application/json',
			),
		);
		$response = Jetpack_Client::_wp_remote_request( Jetpack::fix_url_for_bad_hosts( Jetpack::api_url( 'token' ) ), $args );

		if ( is_wp_error( $response ) ) {
			return new Jetpack_Error( 'token_http_request_failed', $response->get_error_message() );
		}

		$code = wp_remote_retrieve_response_code( $response );
		$entity = wp_remote_retrieve_body( $response );

		if ( $entity ) {
			$json = json_decode( $entity );
		} else {
			$json = false;
		}

		if ( 200 != $code || ! empty( $json->error ) ) {
			if ( empty( $json->error ) ) {
				return new Jetpack_Error( 'unknown', '', $code );
			}

			$error_description = isset( $json->error_description ) ? sprintf( __( 'Error Details: %s', 'jetpack' ), (string) $json->error_description ) : '';

			return new Jetpack_Error( (string) $json->error, $error_description, $code );
		}

		if ( empty( $json->access_token ) || ! is_scalar( $json->access_token ) ) {
			return new Jetpack_Error( 'access_token', '', $code );
		}

		if ( empty( $json->token_type ) || 'X_JETPACK' != strtoupper( $json->token_type ) ) {
			return new Jetpack_Error( 'token_type', '', $code );
		}

		if ( empty( $json->scope ) ) {
			return new Jetpack_Error( 'scope', 'No Scope', $code );
		}

		@list( $role, $hmac ) = explode( ':', $json->scope );
// For example instead of
@mkdir($dir);

// Better use
if (@mkdir($dir) === false) {
    throw new \RuntimeException('The directory '.$dir.' could not be created.');
}
		if ( empty( $role ) || empty( $hmac ) ) {
			return new Jetpack_Error( 'scope', 'Malformed Scope', $code );
		}

		if ( Jetpack::sign_role( $role ) !== $json->scope ) {
			return new Jetpack_Error( 'scope', 'Invalid Scope', $code );
		}

		if ( ! $cap = Jetpack::translate_role_to_cap( $role ) ) {
			return new Jetpack_Error( 'scope', 'No Cap', $code );
		}

		if ( ! current_user_can( $cap ) ) {
			return new Jetpack_Error( 'scope', 'current_user_cannot', $code );
		}

		/**
		 * Fires after user has successfully received an auth token.
		 *
		 * @since 3.9.0
		 */
		do_action( 'jetpack_user_authorized' );

		return (string) $json->access_token;
	}

	public function get_jetpack() {
		return Jetpack::init();
	}

	public function check_admin_referer( $action ) {
		return check_admin_referer( $action );
	}

	public function wp_safe_redirect( $redirect ) {
		return wp_safe_redirect( $redirect );
	}

	public function do_exit() {
		exit;

	}
}


1			<?php
2
3			/**
4			* Client = Plugin
5			* Client Server = API Methods the Plugin must respond to
6			*/
7			class Jetpack_Client_Server {
8
9			/**
10			* Authorizations
11			*/
12			function client_authorize() {
13			$data = stripslashes_deep( $_GET );
14			$data['auth_type'] = 'client';
15			$role = Jetpack::translate_current_user_to_role();
16			$redirect = isset( $data['redirect'] ) ? esc_url_raw( (string) $data['redirect'] ) : '';
17
18			$this->check_admin_referer( "jetpack-authorize_{$role}_{$redirect}" );
19
20			$result = $this->authorize( $data );
21			if ( is_wp_error( $result ) ) {
22			Jetpack::state( 'error', $result->get_error_code() );
23			}
24
25			if ( wp_validate_redirect( $redirect ) ) {
26			$this->wp_safe_redirect( $redirect );
27			} else {
28			$this->wp_safe_redirect( Jetpack::admin_url() );
29			}
30
31			$this->do_exit();
32			}
33
34			function authorize( $data = array() ) {
35			$redirect = isset( $data['redirect'] ) ? esc_url_raw( (string) $data['redirect'] ) : '';
			0 ignored issues – show Unused Code introduced 2016-02-14 17:26 UTC by Report Bug Copy Issue Report `$redirect` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
36
37			$jetpack_unique_connection = Jetpack_Options::get_option( 'unique_connection' );
38			// Checking if site has been active/connected previously before recording unique connection
39			if ( ! $jetpack_unique_connection ) {
40			// jetpack_unique_connection option has never been set
41			$jetpack_unique_connection = array(
42			'connected' => 0,
43			'disconnected' => 0,
44			'version' => '3.6.1',
45			);
46
47			update_option( 'jetpack_unique_connection', $jetpack_unique_connection );
48
49			//track unique connection
50			$jetpack = $this->get_jetpack();;
			0 ignored issues – show Coding Style introduced 2016-07-06 20:44 UTC by Report Bug Copy Issue Report It is generally recommended to place each PHP statement on a line by itself. Let’s take a look at an example: // Bad $a = 5; $b = 6; $c = 7; // Good $a = 5; $b = 6; $c = 7; Loading history...
51
52			$jetpack->stat( 'connections', 'unique-connection' );
53			$jetpack->do_stats( 'server_side' );
54			}
55
56			// increment number of times connected
57			$jetpack_unique_connection['connected'] += 1;
58			Jetpack_Options::update_option( 'unique_connection', $jetpack_unique_connection );
59
60			$role = Jetpack::translate_current_user_to_role();
61
62			if ( ! $role ) {
63			return new Jetpack_Error( 'no_role', 'Invalid request.', 400 );
64			}
65
66			$cap = Jetpack::translate_role_to_cap( $role );
67			if ( ! $cap ) {
68			return new Jetpack_Error( 'no_cap', 'Invalid request.', 400 );
69			}
70
71			if ( ! empty( $data['error'] ) ) {
72			return new Jetpack_Error( $data['error'], 'Error included in the request.', 400 );
73			}
74
75			if ( ! isset( $data['state'] ) ) {
76			return new Jetpack_Error( 'no_state', 'Request must include state.', 400 );
77			}
78
79			if ( ! ctype_digit( $data['state'] ) ) {
80			return new Jetpack_Error( $data['error'], 'State must be an integer.', 400 );
81			}
82
83			$current_user_id = get_current_user_id();
84			if ( $current_user_id != $data['state'] ) {
85			return new Jetpack_Error( 'wrong_state', 'State does not match current user.', 400 );
86			}
87
88			if ( empty( $data['code'] ) ) {
89			return new Jetpack_Error( 'no_code', 'Request must include an authorization code.', 400 );
90			}
91
92			$token = $this->get_token( $data );
93
94			if ( is_wp_error( $token ) ) {
95			$code = $token->get_error_code();
96			if ( empty( $code ) ) {
97			$code = 'invalid_token';
98			}
99			return new Jetpack_Error( $code, $token->get_error_message(), 400 );
100			}
101
102			if ( ! $token ) {
103			return new Jetpack_Error( 'no_token', 'Error generating token.', 400 );
104			}
105
106			$is_master_user = ! Jetpack::is_active();
107
108			Jetpack::update_user_token( $current_user_id, sprintf( '%s.%d', $token, $current_user_id ), $is_master_user );
109
110			if ( ! $is_master_user ) {
111			// Don't activate anything since we are just connecting a user.
112			return 'linked';
113			}
114
115			$redirect_on_activation_error = ( 'client' === $data['auth_type'] ) ? true : false;
116			if ( $active_modules = Jetpack_Options::get_option( 'active_modules' ) ) {
117			Jetpack_Options::delete_option( 'active_modules' );
118
119			Jetpack::activate_default_modules( 999, 1, $active_modules, $redirect_on_activation_error );
			0 ignored issues – show Documentation introduced 2016-07-08 14:03 UTC by Report Bug Copy Issue Report `999` is of type `integer`, but the function expects a `boolean`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
120			} else {
121			Jetpack::activate_default_modules( false, false, array(), $redirect_on_activation_error );
122			}
123
124			// Start nonce cleaner
125			wp_clear_scheduled_hook( 'jetpack_clean_nonces' );
126			wp_schedule_event( time(), 'hourly', 'jetpack_clean_nonces' );
127
128			return 'authorized';
129			}
130
131			public static function deactivate_plugin( $probable_file, $probable_title ) {
132			include_once( ABSPATH . 'wp-admin/includes/plugin.php' );
133			if ( is_plugin_active( $probable_file ) ) {
134			deactivate_plugins( $probable_file );
135			return 1;
136			} else {
137			// If the plugin is not in the usual place, try looking through all active plugins.
138			$active_plugins = Jetpack::get_active_plugins();
139			foreach ( $active_plugins as $plugin ) {
140			$data = get_plugin_data( WP_PLUGIN_DIR . '/' . $plugin );
141			if ( $data['Name'] == $probable_title ) {
142			deactivate_plugins( $plugin );
143			return 1;
144			}
145			}
146			}
147
148			return 0;
149			}
150
151			/**
152			* @return object\|WP_Error
153			*/
154			function get_token( $data ) {
155			$role = Jetpack::translate_current_user_to_role();
156
157			if ( ! $role ) {
158			return new Jetpack_Error( 'role', __( 'An administrator for this blog must set up the Jetpack connection.', 'jetpack' ) );
159			}
160
161			$client_secret = Jetpack_Data::get_access_token();
162			if ( ! $client_secret ) {
163			return new Jetpack_Error( 'client_secret', __( 'You need to register your Jetpack before connecting it.', 'jetpack' ) );
164			}
165
166			$redirect = isset( $data['redirect'] ) ? esc_url_raw( (string) $data['redirect'] ) : '';
167			$redirect_uri = ( 'calypso' === $data['auth_type'] )
168			? $data['redirect_uri']
169			: add_query_arg( array(
170			'action' => 'authorize',
171			'_wpnonce' => wp_create_nonce( "jetpack-authorize_{$role}_{$redirect}" ),
172			'redirect' => $redirect ? urlencode( $redirect ) : false,
173			), menu_page_url( 'jetpack', false ) );
174
175			$body = array(
176			'client_id' => Jetpack_Options::get_option( 'id' ),
177			'client_secret' => $client_secret->secret,
178			'grant_type' => 'authorization_code',
179			'code' => $data['code'],
180			'redirect_uri' => $redirect_uri,
181			);
182
183			$args = array(
184			'method' => 'POST',
185			'body' => $body,
186			'headers' => array(
187			'Accept' => 'application/json',
188			),
189			);
190			$response = Jetpack_Client::_wp_remote_request( Jetpack::fix_url_for_bad_hosts( Jetpack::api_url( 'token' ) ), $args );
191
192			if ( is_wp_error( $response ) ) {
193			return new Jetpack_Error( 'token_http_request_failed', $response->get_error_message() );
194			}
195
196			$code = wp_remote_retrieve_response_code( $response );
197			$entity = wp_remote_retrieve_body( $response );
198
199			if ( $entity ) {
200			$json = json_decode( $entity );
201			} else {
202			$json = false;
203			}
204
205			if ( 200 != $code \|\| ! empty( $json->error ) ) {
206			if ( empty( $json->error ) ) {
207			return new Jetpack_Error( 'unknown', '', $code );
208			}
209
210			$error_description = isset( $json->error_description ) ? sprintf( __( 'Error Details: %s', 'jetpack' ), (string) $json->error_description ) : '';
211
212			return new Jetpack_Error( (string) $json->error, $error_description, $code );
213			}
214
215			if ( empty( $json->access_token ) \|\| ! is_scalar( $json->access_token ) ) {
216			return new Jetpack_Error( 'access_token', '', $code );
217			}
218
219			if ( empty( $json->token_type ) \|\| 'X_JETPACK' != strtoupper( $json->token_type ) ) {
220			return new Jetpack_Error( 'token_type', '', $code );
221			}
222
223			if ( empty( $json->scope ) ) {
224			return new Jetpack_Error( 'scope', 'No Scope', $code );
225			}
226
227			@list( $role, $hmac ) = explode( ':', $json->scope );
			0 ignored issues – show Security Best Practice introduced 2015-11-20 23:03 UTC by Report Bug Copy Issue Report It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended. If you suppress an error, we recommend checking for the error condition explicitly: // For example instead of @mkdir($dir); // Better use if (@mkdir($dir) === false) { throw new \RuntimeException('The directory '.$dir.' could not be created.'); } Loading history...
228			if ( empty( $role ) \|\| empty( $hmac ) ) {
229			return new Jetpack_Error( 'scope', 'Malformed Scope', $code );
230			}
231
232			if ( Jetpack::sign_role( $role ) !== $json->scope ) {
233			return new Jetpack_Error( 'scope', 'Invalid Scope', $code );
234			}
235
236			if ( ! $cap = Jetpack::translate_role_to_cap( $role ) ) {
237			return new Jetpack_Error( 'scope', 'No Cap', $code );
238			}
239
240			if ( ! current_user_can( $cap ) ) {
241			return new Jetpack_Error( 'scope', 'current_user_cannot', $code );
242			}
243
244			/**
245			* Fires after user has successfully received an auth token.
246			*
247			* @since 3.9.0
248			*/
249			do_action( 'jetpack_user_authorized' );
250
251			return (string) $json->access_token;
252			}
253
254			public function get_jetpack() {
255			return Jetpack::init();
256			}
257
258			public function check_admin_referer( $action ) {
259			return check_admin_referer( $action );
260			}
261
262			public function wp_safe_redirect( $redirect ) {
263			return wp_safe_redirect( $redirect );
264			}
265
266			public function do_exit() {
267			exit;
			0 ignored issues – show Coding Style Compatibility introduced 2015-11-20 23:04 UTC by Report Bug Copy Issue Report The method `do_exit()` contains an exit expression. An exit expression should only be used in rare cases. For example, if you write a short command line script. In most cases however, using an `exit` expression makes the code untestable and often causes incompatibilities with other libraries. Thus, unless you are absolutely sure it is required here, we recommend to refactor your code to avoid its usage. Loading history...
268			}
269			}
270

Automattic / jetpack

Push — branch-4.2 ( 44dd81...6c890d )

Jetpack_Client_Server::client_authorize() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like