9 if ( !function_exists('wp_set_current_user') ) :

     9 if ( ! function_exists( 'wp_set_current_user' ) ) :

    10 /**

    10 	/**

    11  * Changes the current user by ID or name.

    11 	 * Changes the current user by ID or name.

    12  *

    12 	 *

    13  * Set $id to null and specify a name if you do not know a user's ID.

    13 	 * Set $id to null and specify a name if you do not know a user's ID.

    14  *

    14 	 *

    15  * Some WordPress functionality is based on the current user and not based on

    15 	 * Some WordPress functionality is based on the current user and not based on

    16  * the signed in user. Therefore, it opens the ability to edit and perform

    16 	 * the signed in user. Therefore, it opens the ability to edit and perform

    17  * actions on users who aren't signed in.

    17 	 * actions on users who aren't signed in.

    18  *

    18 	 *

    19  * @since 2.0.3

    19 	 * @since 2.0.3

    20  * @global WP_User $current_user The current user object which holds the user data.

    20 	 * @global WP_User $current_user The current user object which holds the user data.

    21  *

    21 	 *

    22  * @param int    $id   User ID

    22 	 * @param int    $id   User ID

    23  * @param string $name User's username

    23 	 * @param string $name User's username

    24  * @return WP_User Current user User object

    24 	 * @return WP_User Current user User object

    25  */

    25 	 */

    26 function wp_set_current_user($id, $name = '') {

    26 	function wp_set_current_user( $id, $name = '' ) {

    27 	global $current_user;

    27 		global $current_user;

    28 

    28 

    29 	// If `$id` matches the user who's already current, there's nothing to do.

    29 		// If `$id` matches the current user, there is nothing to do.

    30 	if ( isset( $current_user )

    30 		if ( isset( $current_user )

    34 	) {

    34 		) {

    35 			return $current_user;

    36 		}

    37 

    38 		$current_user = new WP_User( $id, $name );

    39 

    40 		setup_userdata( $current_user->ID );

    41 

    42 		/**

    43 		 * Fires after the current user is set.

    44 		 *

    45 		 * @since 2.0.1

    46 		 */

    47 		do_action( 'set_current_user' );

    48 

    37 

    51 endif;

    38 	$current_user = new WP_User( $id, $name );

    52 

    39 

    53 if ( ! function_exists( 'wp_get_current_user' ) ) :

    40 	setup_userdata( $current_user->ID );

    54 	/**

    41 

    55 	 * Retrieve the current user object.

    42 	/**

    56 	 *

    43 	 * Fires after the current user is set.

    57 	 * Will set the current user, if the current user is not set. The current user

    44 	 *

    58 	 * will be set to the logged-in person. If no user is logged-in, then it will

    45 	 * @since 2.0.1

    59 	 * set the current user to 0, which is invalid and won't have any permissions.

    46 	 */

    60 	 *

    47 	do_action( 'set_current_user' );

    61 	 * @since 2.0.3

    48 

    62 	 *

    49 	return $current_user;

    63 	 * @see _wp_get_current_user()

    50 }

    64 	 * @global WP_User $current_user Checks if the current user is set.

    51 endif;

    65 	 *

    52 

    66 	 * @return WP_User Current WP_User instance.

    53 if ( !function_exists('wp_get_current_user') ) :

    67 	 */

    54 /**

    68 	function wp_get_current_user() {

    55  * Retrieve the current user object.

    69 		return _wp_get_current_user();

    56  *

    70 	}

    57  * Will set the current user, if the current user is not set. The current user

    71 endif;

    58  * will be set to the logged-in person. If no user is logged-in, then it will

    72 

    59  * set the current user to 0, which is invalid and won't have any permissions.

    73 if ( ! function_exists( 'get_userdata' ) ) :

    60  *

    74 	/**

    61  * @since 2.0.3

    75 	 * Retrieve user info by user ID.

    62  *

    76 	 *

    63  * @see _wp_get_current_user()

    77 	 * @since 0.71

    64  * @global WP_User $current_user Checks if the current user is set.

    78 	 *

    65  *

    79 	 * @param int $user_id User ID

    66  * @return WP_User Current WP_User instance.

    80 	 * @return WP_User|false WP_User object on success, false on failure.

    67  */

    81 	 */

    68 function wp_get_current_user() {

    82 	function get_userdata( $user_id ) {

    69 	return _wp_get_current_user();

    83 		return get_user_by( 'id', $user_id );

    70 }

    84 	}

    71 endif;

    85 endif;

    72 

    86 

    73 if ( !function_exists('get_userdata') ) :

    87 if ( ! function_exists( 'get_user_by' ) ) :

    74 /**

    88 	/**

    75  * Retrieve user info by user ID.

    89 	 * Retrieve user info by a given field

    76  *

    90 	 *

    77  * @since 0.71

    91 	 * @since 2.8.0

    78  *

    92 	 * @since 4.4.0 Added 'ID' as an alias of 'id' for the `$field` parameter.

    79  * @param int $user_id User ID

    93 	 *

    80  * @return WP_User|false WP_User object on success, false on failure.

    94 	 * @param string     $field The field to retrieve the user with. id | ID | slug | email | login.

    81  */

    95 	 * @param int|string $value A value for $field. A user ID, slug, email address, or login name.

    82 function get_userdata( $user_id ) {

    96 	 * @return WP_User|false WP_User object on success, false on failure.

    83 	return get_user_by( 'id', $user_id );

    97 	 */

    84 }

    98 	function get_user_by( $field, $value ) {

    85 endif;

    99 		$userdata = WP_User::get_data_by( $field, $value );

    86 

   100 

    87 if ( !function_exists('get_user_by') ) :

   101 		if ( ! $userdata ) {

    88 /**

   102 			return false;

    89  * Retrieve user info by a given field

   103 		}

    90  *

   104 

    91  * @since 2.8.0

   105 		$user = new WP_User;

    92  * @since 4.4.0 Added 'ID' as an alias of 'id' for the `$field` parameter.

   106 		$user->init( $userdata );

    93  *

   107 

    94  * @param string     $field The field to retrieve the user with. id | ID | slug | email | login.

   108 		return $user;

    95  * @param int|string $value A value for $field. A user ID, slug, email address, or login name.

   109 	}

    96  * @return WP_User|false WP_User object on success, false on failure.

   110 endif;

    97  */

   111 

    98 function get_user_by( $field, $value ) {

   112 if ( ! function_exists( 'cache_users' ) ) :

    99 	$userdata = WP_User::get_data_by( $field, $value );

   113 	/**

   100 

   114 	 * Retrieve info for user lists to prevent multiple queries by get_userdata()

   101 	if ( !$userdata )

   115 	 *

   102 		return false;

   116 	 * @since 3.0.0

   103 

   117 	 *

   104 	$user = new WP_User;

   118 	 * @global wpdb $wpdb WordPress database abstraction object.

   105 	$user->init( $userdata );

   119 	 *

   106 

   120 	 * @param array $user_ids User ID numbers list

   107 	return $user;

   121 	 */

   108 }

   122 	function cache_users( $user_ids ) {

   109 endif;

   123 		global $wpdb;

   110 

   124 

   111 if ( !function_exists('cache_users') ) :

   125 		$clean = _get_non_cached_ids( $user_ids, 'users' );

   112 /**

   126 

   113  * Retrieve info for user lists to prevent multiple queries by get_userdata()

   127 		if ( empty( $clean ) ) {

   114  *

   128 			return;

   115  * @since 3.0.0

   129 		}

   116  *

   130 

   117  * @global wpdb $wpdb WordPress database abstraction object.

   131 		$list = implode( ',', $clean );

   118  *

   132 

   119  * @param array $user_ids User ID numbers list

   133 		$users = $wpdb->get_results( "SELECT * FROM $wpdb->users WHERE ID IN ($list)" );

   120  */

   134 

   121 function cache_users( $user_ids ) {

   135 		$ids = array();

   122 	global $wpdb;

   136 		foreach ( $users as $user ) {

   123 

   137 			update_user_caches( $user );

   124 	$clean = _get_non_cached_ids( $user_ids, 'users' );

   138 			$ids[] = $user->ID;

   125 

   139 		}

   126 	if ( empty( $clean ) )

   140 		update_meta_cache( 'user', $ids );

   127 		return;

   141 	}

   128 

   142 endif;

   129 	$list = implode( ',', $clean );

   143 

   130 

   144 if ( ! function_exists( 'wp_mail' ) ) :

   131 	$users = $wpdb->get_results( "SELECT * FROM $wpdb->users WHERE ID IN ($list)" );

   145 	/**

   132 

   146 	 * Send mail, similar to PHP's mail

   133 	$ids = array();

   147 	 *

   134 	foreach ( $users as $user ) {

   148 	 * A true return value does not automatically mean that the user received the

   135 		update_user_caches( $user );

   149 	 * email successfully. It just only means that the method used was able to

   136 		$ids[] = $user->ID;

   150 	 * process the request without any errors.

   137 	}

   151 	 *

   138 	update_meta_cache( 'user', $ids );

   152 	 * Using the two 'wp_mail_from' and 'wp_mail_from_name' hooks allow from

   139 }

   153 	 * creating a from address like 'Name <email@address.com>' when both are set. If

   140 endif;

   154 	 * just 'wp_mail_from' is set, then just the email address will be used with no

   141 

   155 	 * name.

   142 if ( !function_exists( 'wp_mail' ) ) :

   156 	 *

   143 /**

   157 	 * The default content type is 'text/plain' which does not allow using HTML.

   144  * Send mail, similar to PHP's mail

   158 	 * However, you can set the content type of the email by using the

   145  *

   159 	 * {@see 'wp_mail_content_type'} filter.

   146  * A true return value does not automatically mean that the user received the

   160 	 *

   147  * email successfully. It just only means that the method used was able to

   161 	 * The default charset is based on the charset used on the blog. The charset can

   148  * process the request without any errors.

   162 	 * be set using the {@see 'wp_mail_charset'} filter.

   149  *

   163 	 *

   150  * Using the two 'wp_mail_from' and 'wp_mail_from_name' hooks allow from

   164 	 * @since 1.2.1

   151  * creating a from address like 'Name <email@address.com>' when both are set. If

   165 	 *

   152  * just 'wp_mail_from' is set, then just the email address will be used with no

   166 	 * @global PHPMailer $phpmailer

   153  * name.

   167 	 *

   154  *

   168 	 * @param string|array $to          Array or comma-separated list of email addresses to send message.

   155  * The default content type is 'text/plain' which does not allow using HTML.

   169 	 * @param string       $subject     Email subject

   156  * However, you can set the content type of the email by using the

   170 	 * @param string       $message     Message contents

   157  * {@see 'wp_mail_content_type'} filter.

   171 	 * @param string|array $headers     Optional. Additional headers.

   158  *

   172 	 * @param string|array $attachments Optional. Files to attach.

   159  * The default charset is based on the charset used on the blog. The charset can

   173 	 * @return bool Whether the email contents were sent successfully.

   160  * be set using the {@see 'wp_mail_charset'} filter.

   174 	 */

   161  *

   175 	function wp_mail( $to, $subject, $message, $headers = '', $attachments = array() ) {

   162  * @since 1.2.1

   176 		// Compact the input, apply the filters, and extract them back out

   163  *

   177 

   164  * @global PHPMailer $phpmailer

   178 		/**

   165  *

   179 		 * Filters the wp_mail() arguments.

   166  * @param string|array $to          Array or comma-separated list of email addresses to send message.

   180 		 *

   167  * @param string       $subject     Email subject

   181 		 * @since 2.2.0

   168  * @param string       $message     Message contents

   182 		 *

   169  * @param string|array $headers     Optional. Additional headers.

   183 		 * @param array $args A compacted array of wp_mail() arguments, including the "to" email,

   170  * @param string|array $attachments Optional. Files to attach.

   184 		 *                    subject, message, headers, and attachments values.

   171  * @return bool Whether the email contents were sent successfully.

   185 		 */

   172  */

   186 		$atts = apply_filters( 'wp_mail', compact( 'to', 'subject', 'message', 'headers', 'attachments' ) );

   173 function wp_mail( $to, $subject, $message, $headers = '', $attachments = array() ) {

   187 

   174 	// Compact the input, apply the filters, and extract them back out

   188 		if ( isset( $atts['to'] ) ) {

   175 

   189 			$to = $atts['to'];

   176 	/**

   190 		}

   177 	 * Filters the wp_mail() arguments.

   191 

   178 	 *

   192 		if ( ! is_array( $to ) ) {

   179 	 * @since 2.2.0

   193 			$to = explode( ',', $to );

   180 	 *

   194 		}

   181 	 * @param array $args A compacted array of wp_mail() arguments, including the "to" email,

   195 

   182 	 *                    subject, message, headers, and attachments values.

   196 		if ( isset( $atts['subject'] ) ) {

   183 	 */

   197 			$subject = $atts['subject'];

   184 	$atts = apply_filters( 'wp_mail', compact( 'to', 'subject', 'message', 'headers', 'attachments' ) );

   198 		}

   185 

   199 

   186 	if ( isset( $atts['to'] ) ) {

   200 		if ( isset( $atts['message'] ) ) {

   187 		$to = $atts['to'];

   201 			$message = $atts['message'];

   188 	}

   202 		}

   189 

   203 

   190 	if ( !is_array( $to ) ) {

   204 		if ( isset( $atts['headers'] ) ) {

   191 		$to = explode( ',', $to );

   205 			$headers = $atts['headers'];

   192 	}

   206 		}

   193 

   207 

   194 	if ( isset( $atts['subject'] ) ) {

   208 		if ( isset( $atts['attachments'] ) ) {

   195 		$subject = $atts['subject'];

   209 			$attachments = $atts['attachments'];

   196 	}

   210 		}

   197 

   211 

   198 	if ( isset( $atts['message'] ) ) {

   212 		if ( ! is_array( $attachments ) ) {

   199 		$message = $atts['message'];

   213 			$attachments = explode( "\n", str_replace( "\r\n", "\n", $attachments ) );

   200 	}

   214 		}

   201 

   215 		global $phpmailer;

   202 	if ( isset( $atts['headers'] ) ) {

   216 

   203 		$headers = $atts['headers'];

   217 		// (Re)create it, if it's gone missing

   204 	}

   218 		if ( ! ( $phpmailer instanceof PHPMailer ) ) {

   205 

   219 			require_once ABSPATH . WPINC . '/class-phpmailer.php';

   206 	if ( isset( $atts['attachments'] ) ) {

   220 			require_once ABSPATH . WPINC . '/class-smtp.php';

   207 		$attachments = $atts['attachments'];

   221 			$phpmailer = new PHPMailer( true );

   208 	}

   222 		}

   209 

   223 

   210 	if ( ! is_array( $attachments ) ) {

   224 		// Headers

   211 		$attachments = explode( "\n", str_replace( "\r\n", "\n", $attachments ) );

   225 		$cc = $bcc = $reply_to = array();

   212 	}

   226 

   213 	global $phpmailer;

   227 		if ( empty( $headers ) ) {

   214 

   228 			$headers = array();

   215 	// (Re)create it, if it's gone missing

   216 	if ( ! ( $phpmailer instanceof PHPMailer ) ) {

   217 		require_once ABSPATH . WPINC . '/class-phpmailer.php';

   218 		require_once ABSPATH . WPINC . '/class-smtp.php';

   219 		$phpmailer = new PHPMailer( true );

   220 	}

   221 

   222 	// Headers

   223 	$cc = $bcc = $reply_to = array();

   224 

   225 	if ( empty( $headers ) ) {

   226 		$headers = array();

   227 	} else {

   228 		if ( !is_array( $headers ) ) {

   229 			// Explode the headers out, so this function can take both

   230 			// string headers and an array of headers.

   231 			$tempheaders = explode( "\n", str_replace( "\r\n", "\n", $headers ) );

   233 			$tempheaders = $headers;

   230 			if ( ! is_array( $headers ) ) {

   234 		}

   231 				// Explode the headers out, so this function can take both

   235 		$headers = array();

   232 				// string headers and an array of headers.

   236 

   233 				$tempheaders = explode( "\n", str_replace( "\r\n", "\n", $headers ) );

   237 		// If it's actually got contents

   234 			} else {

   238 		if ( !empty( $tempheaders ) ) {

   235 				$tempheaders = $headers;

   239 			// Iterate through the raw headers

   236 			}

   240 			foreach ( (array) $tempheaders as $header ) {

   237 			$headers = array();

   241 				if ( strpos($header, ':') === false ) {

   238 

   242 					if ( false !== stripos( $header, 'boundary=' ) ) {

   239 			// If it's actually got contents

   243 						$parts = preg_split('/boundary=/i', trim( $header ) );

   240 			if ( ! empty( $tempheaders ) ) {

   244 						$boundary = trim( str_replace( array( "'", '"' ), '', $parts[1] ) );

   241 				// Iterate through the raw headers

   242 				foreach ( (array) $tempheaders as $header ) {

   243 					if ( strpos( $header, ':' ) === false ) {

   244 						if ( false !== stripos( $header, 'boundary=' ) ) {

   245 							$parts    = preg_split( '/boundary=/i', trim( $header ) );

   246 							$boundary = trim( str_replace( array( "'", '"' ), '', $parts[1] ) );

   247 						}

   248 						continue;

   248 				// Explode them out

   412 			}

   249 				list( $name, $content ) = explode( ':', trim( $header ), 2 );

   413 		}

   250 

   414 

   251 				// Cleanup crew

   415 		// Set to use PHP's mail()

   252 				$name    = trim( $name    );

   416 		$phpmailer->isMail();

   253 				$content = trim( $content );

   417 

   254 

   418 		// Set Content-Type and charset

   255 				switch ( strtolower( $name ) ) {

   419 		// If we don't have a content-type from the input headers

   256 					// Mainly for legacy -- process a From: header if it's there

   420 		if ( ! isset( $content_type ) ) {

   257 					case 'from':

   421 			$content_type = 'text/plain';

   258 						$bracket_pos = strpos( $content, '<' );

   422 		}

   259 						if ( $bracket_pos !== false ) {

   423 

   260 							// Text before the bracketed email is the "From" name.

   424 		/**

   261 							if ( $bracket_pos > 0 ) {

   425 		 * Filters the wp_mail() content type.

   262 								$from_name = substr( $content, 0, $bracket_pos - 1 );

   426 		 *

   263 								$from_name = str_replace( '"', '', $from_name );

   427 		 * @since 2.3.0

   264 								$from_name = trim( $from_name );

   428 		 *

   265 							}

   429 		 * @param string $content_type Default wp_mail() content type.

   266 

   430 		 */

   267 							$from_email = substr( $content, $bracket_pos + 1 );

   431 		$content_type = apply_filters( 'wp_mail_content_type', $content_type );

   268 							$from_email = str_replace( '>', '', $from_email );

   432 

   269 							$from_email = trim( $from_email );

   433 		$phpmailer->ContentType = $content_type;

   270 

   434 

   271 						// Avoid setting an empty $from_email.

   435 		// Set whether it's plaintext, depending on $content_type

   272 						} elseif ( '' !== trim( $content ) ) {

   436 		if ( 'text/html' == $content_type ) {

   273 							$from_email = trim( $content );

   437 			$phpmailer->isHTML( true );

   274 						}

   438 		}

   275 						break;

   439 

   276 					case 'content-type':

   440 		// If we don't have a charset from the input headers

   277 						if ( strpos( $content, ';' ) !== false ) {

   441 		if ( ! isset( $charset ) ) {

   278 							list( $type, $charset_content ) = explode( ';', $content );

   442 			$charset = get_bloginfo( 'charset' );

   279 							$content_type = trim( $type );

   443 		}

   280 							if ( false !== stripos( $charset_content, 'charset=' ) ) {

   444 

   281 								$charset = trim( str_replace( array( 'charset=', '"' ), '', $charset_content ) );

   445 		// Set the content-type and charset

   282 							} elseif ( false !== stripos( $charset_content, 'boundary=' ) ) {

   446 

   283 								$boundary = trim( str_replace( array( 'BOUNDARY=', 'boundary=', '"' ), '', $charset_content ) );

   447 		/**

   284 								$charset = '';

   448 		 * Filters the default wp_mail() charset.

   285 							}

   449 		 *

   286 

   450 		 * @since 2.3.0

   287 						// Avoid setting an empty $content_type.

   451 		 *

   288 						} elseif ( '' !== trim( $content ) ) {

   452 		 * @param string $charset Default email charset.

   289 							$content_type = trim( $content );

   453 		 */

   290 						}

   454 		$phpmailer->CharSet = apply_filters( 'wp_mail_charset', $charset );

   291 						break;

   455 

   292 					case 'cc':

   456 		// Set custom headers

   293 						$cc = array_merge( (array) $cc, explode( ',', $content ) );

   457 		if ( ! empty( $headers ) ) {

   294 						break;

   458 			foreach ( (array) $headers as $name => $content ) {

   295 					case 'bcc':

   459 				$phpmailer->addCustomHeader( sprintf( '%1$s: %2$s', $name, $content ) );

   296 						$bcc = array_merge( (array) $bcc, explode( ',', $content ) );

   460 			}

   297 						break;

   461 

   298 					case 'reply-to':

   462 			if ( false !== stripos( $content_type, 'multipart' ) && ! empty( $boundary ) ) {

   299 						$reply_to = array_merge( (array) $reply_to, explode( ',', $content ) );

   463 				$phpmailer->addCustomHeader( sprintf( "Content-Type: %s;\n\t boundary=\"%s\"", $content_type, $boundary ) );

   300 						break;

   464 			}

   301 					default:

   465 		}

   302 						// Add it to our grand headers array

   466 

   303 						$headers[trim( $name )] = trim( $content );

   467 		if ( ! empty( $attachments ) ) {

   304 						break;

   468 			foreach ( $attachments as $attachment ) {

   469 				try {

   470 					$phpmailer->addAttachment( $attachment );

   471 				} catch ( phpmailerException $e ) {

   472 					continue;

   308 	}

   476 

   309 

   477 		/**

   310 	// Empty out the values that may be set

   478 		 * Fires after PHPMailer is initialized.

   311 	$phpmailer->clearAllRecipients();

   479 		 *

   312 	$phpmailer->clearAttachments();

   480 		 * @since 2.2.0

   313 	$phpmailer->clearCustomHeaders();

   481 		 *

   314 	$phpmailer->clearReplyTos();

   482 		 * @param PHPMailer $phpmailer The PHPMailer instance (passed by reference).

   315 

   483 		 */

   316 	// From email and name

   484 		do_action_ref_array( 'phpmailer_init', array( &$phpmailer ) );

   317 	// If we don't have a name from the input headers

   485 

   318 	if ( !isset( $from_name ) )

   486 		// Send!

   319 		$from_name = 'WordPress';

   487 		try {

   320 

   488 			return $phpmailer->send();

   321 	/* If we don't have an email from the input headers default to wordpress@$sitename

   489 		} catch ( phpmailerException $e ) {

   322 	 * Some hosts will block outgoing mail from this address if it doesn't exist but

   490 

   323 	 * there's no easy alternative. Defaulting to admin_email might appear to be another

   491 			$mail_error_data                             = compact( 'to', 'subject', 'message', 'headers', 'attachments' );

   324 	 * option but some hosts may refuse to relay mail from an unknown domain. See

   492 			$mail_error_data['phpmailer_exception_code'] = $e->getCode();

   325 	 * https://core.trac.wordpress.org/ticket/5007.

   493 

   326 	 */

   494 			/**

   327 

   495 			 * Fires after a phpmailerException is caught.

   328 	if ( !isset( $from_email ) ) {

   496 			 *

   329 		// Get the site domain and get rid of www.

   497 			 * @since 4.4.0

   330 		$sitename = strtolower( $_SERVER['SERVER_NAME'] );

   498 			 *

   331 		if ( substr( $sitename, 0, 4 ) == 'www.' ) {

   499 			 * @param WP_Error $error A WP_Error object with the phpmailerException message, and an array

   332 			$sitename = substr( $sitename, 4 );

   500 			 *                        containing the mail recipient, subject, message, headers, and attachments.

   333 		}

   501 			 */

   334 

   502 			do_action( 'wp_mail_failed', new WP_Error( 'wp_mail_failed', $e->getMessage(), $mail_error_data ) );

   335 		$from_email = 'wordpress@' . $sitename;

   503 

   336 	}

   504 			return false;

   337 

   505 		}

   338 	/**

   506 	}

   339 	 * Filters the email address to send from.

   507 endif;

   340 	 *

   508 

   341 	 * @since 2.2.0

   509 if ( ! function_exists( 'wp_authenticate' ) ) :

   342 	 *

   510 	/**

   343 	 * @param string $from_email Email address to send from.

   511 	 * Authenticate a user, confirming the login credentials are valid.

   344 	 */

   512 	 *

   345 	$from_email = apply_filters( 'wp_mail_from', $from_email );

   513 	 * @since 2.5.0

   346 

   347 	/**

   348 	 * Filters the name to associate with the "from" email address.

   349 	 *

   350 	 * @since 2.3.0

   351 	 *

   352 	 * @param string $from_name Name associated with the "from" email address.

   353 	 */

   354 	$from_name = apply_filters( 'wp_mail_from_name', $from_name );

   355 

   356 	try {

   357 		$phpmailer->setFrom( $from_email, $from_name, false );

   358 	} catch ( phpmailerException $e ) {

   359 		$mail_error_data = compact( 'to', 'subject', 'message', 'headers', 'attachments' );

   360 		$mail_error_data['phpmailer_exception_code'] = $e->getCode();

   361 

   362 		/** This filter is documented in wp-includes/pluggable.php */

   363 		do_action( 'wp_mail_failed', new WP_Error( 'wp_mail_failed', $e->getMessage(), $mail_error_data ) );

   364 

   365 		return false;

   366 	}

   367 

   368 	// Set mail's subject and body

   369 	$phpmailer->Subject = $subject;

   370 	$phpmailer->Body    = $message;

   371 

   372 	// Set destination addresses, using appropriate methods for handling addresses

   373 	$address_headers = compact( 'to', 'cc', 'bcc', 'reply_to' );

   374 

   375 	foreach ( $address_headers as $address_header => $addresses ) {

   376 		if ( empty( $addresses ) ) {

   377 			continue;

   378 		}

   379 

   380 		foreach ( (array) $addresses as $address ) {

   381 			try {

   382 				// Break $recipient into name and address parts if in the format "Foo <bar@baz.com>"

   383 				$recipient_name = '';

   384 

   385 				if ( preg_match( '/(.*)<(.+)>/', $address, $matches ) ) {

   386 					if ( count( $matches ) == 3 ) {

   387 						$recipient_name = $matches[1];

   388 						$address        = $matches[2];

   389 					}

   390 				}

   391 

   392 				switch ( $address_header ) {

   393 					case 'to':

   394 						$phpmailer->addAddress( $address, $recipient_name );

   395 						break;

   396 					case 'cc':

   397 						$phpmailer->addCc( $address, $recipient_name );

   398 						break;

   399 					case 'bcc':

   400 						$phpmailer->addBcc( $address, $recipient_name );

   401 						break;

   402 					case 'reply_to':

   403 						$phpmailer->addReplyTo( $address, $recipient_name );

   404 						break;

   405 				}

   406 			} catch ( phpmailerException $e ) {

   407 				continue;

   408 			}

   409 		}

   410 	}

   411 

   412 	// Set to use PHP's mail()

   413 	$phpmailer->isMail();

   414 

   415 	// Set Content-Type and charset

   416 	// If we don't have a content-type from the input headers

   417 	if ( !isset( $content_type ) )

   418 		$content_type = 'text/plain';

   419 

   420 	/**

   421 	 * Filters the wp_mail() content type.

   422 	 *

   423 	 * @since 2.3.0

   424 	 *

   425 	 * @param string $content_type Default wp_mail() content type.

   426 	 */

   427 	$content_type = apply_filters( 'wp_mail_content_type', $content_type );

   428 

   429 	$phpmailer->ContentType = $content_type;

   430 

   431 	// Set whether it's plaintext, depending on $content_type

   432 	if ( 'text/html' == $content_type )

   433 		$phpmailer->isHTML( true );

   434 

   435 	// If we don't have a charset from the input headers

   436 	if ( !isset( $charset ) )

   437 		$charset = get_bloginfo( 'charset' );

   438 

   439 	// Set the content-type and charset

   440 

   441 	/**

   442 	 * Filters the default wp_mail() charset.

   443 	 *

   444 	 * @since 2.3.0

   445 	 *

   446 	 * @param string $charset Default email charset.

   447 	 */

   448 	$phpmailer->CharSet = apply_filters( 'wp_mail_charset', $charset );

   449 

   450 	// Set custom headers

   451 	if ( !empty( $headers ) ) {

   452 		foreach ( (array) $headers as $name => $content ) {

   453 			$phpmailer->addCustomHeader( sprintf( '%1$s: %2$s', $name, $content ) );

   454 		}

   455 

   456 		if ( false !== stripos( $content_type, 'multipart' ) && ! empty($boundary) )

   457 			$phpmailer->addCustomHeader( sprintf( "Content-Type: %s;\n\t boundary=\"%s\"", $content_type, $boundary ) );

   458 	}

   459 

   460 	if ( !empty( $attachments ) ) {

   461 		foreach ( $attachments as $attachment ) {

   462 			try {

   463 				$phpmailer->addAttachment($attachment);

   464 			} catch ( phpmailerException $e ) {

   465 				continue;

   466 			}

   467 		}

   468 	}

   469 

   470 	/**

   471 	 * Fires after PHPMailer is initialized.

   472 	 *

   473 	 * @since 2.2.0

   474 	 *

   475 	 * @param PHPMailer $phpmailer The PHPMailer instance (passed by reference).

   476 	 */

   477 	do_action_ref_array( 'phpmailer_init', array( &$phpmailer ) );

   478 

   479 	// Send!

   480 	try {

   481 		return $phpmailer->send();

   482 	} catch ( phpmailerException $e ) {

   483 

   484 		$mail_error_data = compact( 'to', 'subject', 'message', 'headers', 'attachments' );

   485 		$mail_error_data['phpmailer_exception_code'] = $e->getCode();

   486 

   487 		/**

   488 		 * Fires after a phpmailerException is caught.

   489 		 *

   490 		 * @since 4.4.0

   491 		 *

   492 		 * @param WP_Error $error A WP_Error object with the phpmailerException message, and an array

   493 		 *                        containing the mail recipient, subject, message, headers, and attachments.

   494 		 */

   495 		do_action( 'wp_mail_failed', new WP_Error( 'wp_mail_failed', $e->getMessage(), $mail_error_data ) );

   496 

   497 		return false;

   498 	}

   499 }

   500 endif;

   501 

   502 if ( !function_exists('wp_authenticate') ) :

   503 /**

   504  * Authenticate a user, confirming the login credentials are valid.

   505  *

   506  * @since 2.5.0

   507  * @since 4.5.0 `$username` now accepts an email address.

   508  *

   509  * @param string $username User's username or email address.

   510  * @param string $password User's password.

   511  * @return WP_User|WP_Error WP_User object if the credentials are valid,

   512  *                          otherwise WP_Error.

   513  */

   514 function wp_authenticate($username, $password) {

   515 	$username = sanitize_user($username);

   516 	$password = trim($password);

   517 

   518 	/**

   519 	 * Filters whether a set of user login credentials are valid.

   520 	 *

   521 	 * A WP_User object is returned if the credentials authenticate a user.

   522 	 * WP_Error or null otherwise.

   523 	 *

   524 	 * @since 2.8.0

   527 	 * @param null|WP_User|WP_Error $user     WP_User if the user is authenticated.

   516 	 * @param string $username User's username or email address.

   528 	 *                                        WP_Error or null otherwise.

   517 	 * @param string $password User's password.

   529 	 * @param string                $username Username or email address.

   518 	 * @return WP_User|WP_Error WP_User object if the credentials are valid,

   530 	 * @param string                $password User password

   519 	 *                          otherwise WP_Error.

   531 	 */

   520 	 */

   532 	$user = apply_filters( 'authenticate', null, $username, $password );

   521 	function wp_authenticate( $username, $password ) {

   533 

   522 		$username = sanitize_user( $username );

   534 	if ( $user == null ) {

   523 		$password = trim( $password );

   535 		// TODO what should the error message be? (Or would these even happen?)

   524 

   536 		// Only needed if all authentication handlers fail to return anything.

   525 		/**

   537 		$user = new WP_Error( 'authentication_failed', __( '<strong>ERROR</strong>: Invalid username, email address or incorrect password.' ) );

   526 		 * Filters whether a set of user login credentials are valid.

   538 	}

   527 		 *

   539 

   528 		 * A WP_User object is returned if the credentials authenticate a user.

   540 	$ignore_codes = array('empty_username', 'empty_password');

   529 		 * WP_Error or null otherwise.

   541 

   530 		 *

   542 	if (is_wp_error($user) && !in_array($user->get_error_code(), $ignore_codes) ) {

   531 		 * @since 2.8.0

   543 		/**

   532 		 * @since 4.5.0 `$username` now accepts an email address.

   544 		 * Fires after a user login has failed.

   533 		 *

   545 		 *

   534 		 * @param null|WP_User|WP_Error $user     WP_User if the user is authenticated.

   546 		 * @since 2.5.0

   535 		 *                                        WP_Error or null otherwise.

   547 		 * @since 4.5.0 The value of `$username` can now be an email address.

   536 		 * @param string                $username Username or email address.

   548 		 *

   537 		 * @param string                $password User password

   549 		 * @param string $username Username or email address.

   538 		 */

   550 		 */

   539 		$user = apply_filters( 'authenticate', null, $username, $password );

   551 		do_action( 'wp_login_failed', $username );

   540 

   552 	}

   541 		if ( $user == null ) {

   553 

   542 			// TODO what should the error message be? (Or would these even happen?)

   554 	return $user;

   543 			// Only needed if all authentication handlers fail to return anything.

   555 }

   544 			$user = new WP_Error( 'authentication_failed', __( '<strong>ERROR</strong>: Invalid username, email address or incorrect password.' ) );

   556 endif;

   545 		}

   557 

   546 

   558 if ( !function_exists('wp_logout') ) :

   547 		$ignore_codes = array( 'empty_username', 'empty_password' );

   559 /**

   548 

   560  * Log the current user out.

   549 		if ( is_wp_error( $user ) && ! in_array( $user->get_error_code(), $ignore_codes ) ) {

   561  *

   550 			/**

   562  * @since 2.5.0

   551 			 * Fires after a user login has failed.

   563  */

   552 			 *

   564 function wp_logout() {

   553 			 * @since 2.5.0

   565 	wp_destroy_current_session();

   554 			 * @since 4.5.0 The value of `$username` can now be an email address.

   566 	wp_clear_auth_cookie();

   555 			 *

   567 

   556 			 * @param string $username Username or email address.

   568 	/**

   557 			 */

   569 	 * Fires after a user is logged-out.

   558 			do_action( 'wp_login_failed', $username );

   570 	 *

   559 		}

   571 	 * @since 1.5.0

   560 

   572 	 */

   561 		return $user;

   573 	do_action( 'wp_logout' );

   562 	}

   574 }

   563 endif;

   575 endif;

   564 

   576 

   565 if ( ! function_exists( 'wp_logout' ) ) :

   577 if ( !function_exists('wp_validate_auth_cookie') ) :

   566 	/**

   578 /**

   567 	 * Log the current user out.

   579  * Validates authentication cookie.

   568 	 *

   580  *

   569 	 * @since 2.5.0

   581  * The checks include making sure that the authentication cookie is set and

   570 	 */

   582  * pulling in the contents (if $cookie is not used).

   571 	function wp_logout() {

   583  *

   572 		wp_destroy_current_session();

   584  * Makes sure the cookie is not expired. Verifies the hash in cookie is what is

   573 		wp_clear_auth_cookie();

   585  * should be and compares the two.

   574 

   586  *

   575 		/**

   587  * @since 2.5.0

   576 		 * Fires after a user is logged-out.

   588  *

   577 		 *

   589  * @global int $login_grace_period

   578 		 * @since 1.5.0

   590  *

   579 		 */

   591  * @param string $cookie Optional. If used, will validate contents instead of cookie's

   580 		do_action( 'wp_logout' );

   592  * @param string $scheme Optional. The cookie scheme to use: auth, secure_auth, or logged_in

   581 	}

   593  * @return false|int False if invalid cookie, User ID if valid.

   582 endif;

   594  */

   583 

   595 function wp_validate_auth_cookie($cookie = '', $scheme = '') {

   584 if ( ! function_exists( 'wp_validate_auth_cookie' ) ) :

   596 	if ( ! $cookie_elements = wp_parse_auth_cookie($cookie, $scheme) ) {

   585 	/**

   597 		/**

   586 	 * Validates authentication cookie.

   598 		 * Fires if an authentication cookie is malformed.

   587 	 *

   588 	 * The checks include making sure that the authentication cookie is set and

   589 	 * pulling in the contents (if $cookie is not used).

   590 	 *

   591 	 * Makes sure the cookie is not expired. Verifies the hash in cookie is what is

   592 	 * should be and compares the two.

   593 	 *

   594 	 * @since 2.5.0

   595 	 *

   596 	 * @global int $login_grace_period

   597 	 *

   598 	 * @param string $cookie Optional. If used, will validate contents instead of cookie's

   599 	 * @param string $scheme Optional. The cookie scheme to use: auth, secure_auth, or logged_in

   600 	 * @return false|int False if invalid cookie, User ID if valid.

   601 	 */

   602 	function wp_validate_auth_cookie( $cookie = '', $scheme = '' ) {

   603 		if ( ! $cookie_elements = wp_parse_auth_cookie( $cookie, $scheme ) ) {

   604 			/**

   605 			 * Fires if an authentication cookie is malformed.

   606 			 *

   607 			 * @since 2.7.0

   608 			 *

   609 			 * @param string $cookie Malformed auth cookie.

   610 			 * @param string $scheme Authentication scheme. Values include 'auth', 'secure_auth',

   611 			 *                       or 'logged_in'.

   612 			 */

   613 			do_action( 'auth_cookie_malformed', $cookie, $scheme );

   614 			return false;

   615 		}

   616 

   617 		$scheme   = $cookie_elements['scheme'];

   618 		$username = $cookie_elements['username'];

   619 		$hmac     = $cookie_elements['hmac'];

   620 		$token    = $cookie_elements['token'];

   621 		$expired  = $expiration = $cookie_elements['expiration'];

   622 

   623 		// Allow a grace period for POST and Ajax requests

   624 		if ( wp_doing_ajax() || 'POST' == $_SERVER['REQUEST_METHOD'] ) {

   625 			$expired += HOUR_IN_SECONDS;

   626 		}

   627 

   628 		// Quick check to see if an honest cookie has expired

   629 		if ( $expired < time() ) {

   630 			/**

   631 			 * Fires once an authentication cookie has expired.

   632 			 *

   633 			 * @since 2.7.0

   634 			 *

   635 			 * @param array $cookie_elements An array of data for the authentication cookie.

   636 			 */

   637 			do_action( 'auth_cookie_expired', $cookie_elements );

   638 			return false;

   639 		}

   640 

   641 		$user = get_user_by( 'login', $username );

   642 		if ( ! $user ) {

   643 			/**

   644 			 * Fires if a bad username is entered in the user authentication process.

   645 			 *

   646 			 * @since 2.7.0

   647 			 *

   648 			 * @param array $cookie_elements An array of data for the authentication cookie.

   649 			 */

   650 			do_action( 'auth_cookie_bad_username', $cookie_elements );

   651 			return false;

   652 		}

   653 

   654 		$pass_frag = substr( $user->user_pass, 8, 4 );

   655 

   656 		$key = wp_hash( $username . '|' . $pass_frag . '|' . $expiration . '|' . $token, $scheme );

   657 

   658 		// If ext/hash is not present, compat.php's hash_hmac() does not support sha256.

   659 		$algo = function_exists( 'hash' ) ? 'sha256' : 'sha1';

   660 		$hash = hash_hmac( $algo, $username . '|' . $expiration . '|' . $token, $key );

   661 

   662 		if ( ! hash_equals( $hash, $hmac ) ) {

   663 			/**

   664 			 * Fires if a bad authentication cookie hash is encountered.

   665 			 *

   666 			 * @since 2.7.0

   667 			 *

   668 			 * @param array $cookie_elements An array of data for the authentication cookie.

   669 			 */

   670 			do_action( 'auth_cookie_bad_hash', $cookie_elements );

   671 			return false;

   672 		}

   673 

   674 		$manager = WP_Session_Tokens::get_instance( $user->ID );

   675 		if ( ! $manager->verify( $token ) ) {

   676 			do_action( 'auth_cookie_bad_session_token', $cookie_elements );

   677 			return false;

   678 		}

   679 

   680 		// Ajax/POST grace period set above

   681 		if ( $expiration < time() ) {

   682 			$GLOBALS['login_grace_period'] = 1;

   683 		}

   684 

   685 		/**

   686 		 * Fires once an authentication cookie has been validated.

   602 		 * @param string $cookie Malformed auth cookie.

   690 		 * @param array   $cookie_elements An array of data for the authentication cookie.

   603 		 * @param string $scheme Authentication scheme. Values include 'auth', 'secure_auth',

   691 		 * @param WP_User $user            User object.

   604 		 *                       or 'logged_in'.

   692 		 */

   605 		 */

   693 		do_action( 'auth_cookie_valid', $cookie_elements, $user );

   606 		do_action( 'auth_cookie_malformed', $cookie, $scheme );

   694 

   607 		return false;

   695 		return $user->ID;

   608 	}

   696 	}

   609 

   697 endif;

   610 	$scheme = $cookie_elements['scheme'];

   698 

   611 	$username = $cookie_elements['username'];

   699 if ( ! function_exists( 'wp_generate_auth_cookie' ) ) :

   612 	$hmac = $cookie_elements['hmac'];

   700 	/**

   613 	$token = $cookie_elements['token'];

   701 	 * Generate authentication cookie contents.

   614 	$expired = $expiration = $cookie_elements['expiration'];

   615 

   616 	// Allow a grace period for POST and Ajax requests

   617 	if ( wp_doing_ajax() || 'POST' == $_SERVER['REQUEST_METHOD'] ) {

   618 		$expired += HOUR_IN_SECONDS;

   619 	}

   620 

   621 	// Quick check to see if an honest cookie has expired

   622 	if ( $expired < time() ) {

   623 		/**

   624 		 * Fires once an authentication cookie has expired.

   625 		 *

   626 		 * @since 2.7.0

   627 		 *

   628 		 * @param array $cookie_elements An array of data for the authentication cookie.

   629 		 */

   630 		do_action( 'auth_cookie_expired', $cookie_elements );

   631 		return false;

   632 	}

   633 

   634 	$user = get_user_by('login', $username);

   635 	if ( ! $user ) {

   636 		/**

   637 		 * Fires if a bad username is entered in the user authentication process.

   638 		 *

   639 		 * @since 2.7.0

   640 		 *

   641 		 * @param array $cookie_elements An array of data for the authentication cookie.

   642 		 */

   643 		do_action( 'auth_cookie_bad_username', $cookie_elements );

   644 		return false;

   645 	}

   646 

   647 	$pass_frag = substr($user->user_pass, 8, 4);

   648 

   649 	$key = wp_hash( $username . '|' . $pass_frag . '|' . $expiration . '|' . $token, $scheme );

   650 

   651 	// If ext/hash is not present, compat.php's hash_hmac() does not support sha256.

   652 	$algo = function_exists( 'hash' ) ? 'sha256' : 'sha1';

   653 	$hash = hash_hmac( $algo, $username . '|' . $expiration . '|' . $token, $key );

   654 

   655 	if ( ! hash_equals( $hash, $hmac ) ) {

   656 		/**

   657 		 * Fires if a bad authentication cookie hash is encountered.

   658 		 *

   659 		 * @since 2.7.0

   660 		 *

   661 		 * @param array $cookie_elements An array of data for the authentication cookie.

   662 		 */

   663 		do_action( 'auth_cookie_bad_hash', $cookie_elements );

   664 		return false;

   665 	}

   666 

   667 	$manager = WP_Session_Tokens::get_instance( $user->ID );

   668 	if ( ! $manager->verify( $token ) ) {

   669 		do_action( 'auth_cookie_bad_session_token', $cookie_elements );

   670 		return false;

   671 	}

   672 

   673 	// Ajax/POST grace period set above

   674 	if ( $expiration < time() ) {

   675 		$GLOBALS['login_grace_period'] = 1;

   676 	}

   677 

   678 	/**

   679 	 * Fires once an authentication cookie has been validated.

   680 	 *

   681 	 * @since 2.7.0

   682 	 *

   683 	 * @param array   $cookie_elements An array of data for the authentication cookie.

   684 	 * @param WP_User $user            User object.

   685 	 */

   686 	do_action( 'auth_cookie_valid', $cookie_elements, $user );

   687 

   688 	return $user->ID;

   689 }

   690 endif;

   691 

   692 if ( !function_exists('wp_generate_auth_cookie') ) :

   693 /**

   694  * Generate authentication cookie contents.

   695  *

   696  * @since 2.5.0

   697  * @since 4.0.0 The `$token` parameter was added.

   698  *

   699  * @param int    $user_id    User ID

   700  * @param int    $expiration The time the cookie expires as a UNIX timestamp.

   701  * @param string $scheme     Optional. The cookie scheme to use: auth, secure_auth, or logged_in

   702  * @param string $token      User's session token to use for this cookie

   703  * @return string Authentication cookie contents. Empty string if user does not exist.

   704  */

   705 function wp_generate_auth_cookie( $user_id, $expiration, $scheme = 'auth', $token = '' ) {

   706 	$user = get_userdata($user_id);

   707 	if ( ! $user ) {

   708 		return '';

   709 	}

   710 

   711 	if ( ! $token ) {

   712 		$manager = WP_Session_Tokens::get_instance( $user_id );

   713 		$token = $manager->create( $expiration );

   714 	}

   715 

   716 	$pass_frag = substr($user->user_pass, 8, 4);

   717 

   718 	$key = wp_hash( $user->user_login . '|' . $pass_frag . '|' . $expiration . '|' . $token, $scheme );

   719 

   720 	// If ext/hash is not present, compat.php's hash_hmac() does not support sha256.

   721 	$algo = function_exists( 'hash' ) ? 'sha256' : 'sha1';

   722 	$hash = hash_hmac( $algo, $user->user_login . '|' . $expiration . '|' . $token, $key );

   723 

   724 	$cookie = $user->user_login . '|' . $expiration . '|' . $token . '|' . $hash;

   725 

   726 	/**

   727 	 * Filters the authentication cookie.

   732 	 * @param string $cookie     Authentication cookie.

   706 	 * @param int    $user_id    User ID

   733 	 * @param int    $user_id    User ID.

   735 	 * @param string $scheme     Cookie scheme used. Accepts 'auth', 'secure_auth', or 'logged_in'.

   708 	 * @param string $scheme     Optional. The cookie scheme to use: auth, secure_auth, or logged_in

   736 	 * @param string $token      User's session token used.

   709 	 * @param string $token      User's session token to use for this cookie

   737 	 */

   710 	 * @return string Authentication cookie contents. Empty string if user does not exist.

   738 	return apply_filters( 'auth_cookie', $cookie, $user_id, $expiration, $scheme, $token );

   711 	 */

   739 }

   712 	function wp_generate_auth_cookie( $user_id, $expiration, $scheme = 'auth', $token = '' ) {

   740 endif;

   713 		$user = get_userdata( $user_id );

   741 

   714 		if ( ! $user ) {

   742 if ( !function_exists('wp_parse_auth_cookie') ) :

   715 			return '';

   743 /**

   716 		}

   744  * Parse a cookie into its components

   717 

   745  *

   718 		if ( ! $token ) {

   746  * @since 2.7.0

   719 			$manager = WP_Session_Tokens::get_instance( $user_id );

   747  *

   720 			$token   = $manager->create( $expiration );

   748  * @param string $cookie

   721 		}

   749  * @param string $scheme Optional. The cookie scheme to use: auth, secure_auth, or logged_in

   722 

   750  * @return array|false Authentication cookie components

   723 		$pass_frag = substr( $user->user_pass, 8, 4 );

   751  */

   724 

   752 function wp_parse_auth_cookie($cookie = '', $scheme = '') {

   725 		$key = wp_hash( $user->user_login . '|' . $pass_frag . '|' . $expiration . '|' . $token, $scheme );

   753 	if ( empty($cookie) ) {

   726 

   754 		switch ($scheme){

   727 		// If ext/hash is not present, compat.php's hash_hmac() does not support sha256.

   755 			case 'auth':

   728 		$algo = function_exists( 'hash' ) ? 'sha256' : 'sha1';

   756 				$cookie_name = AUTH_COOKIE;

   729 		$hash = hash_hmac( $algo, $user->user_login . '|' . $expiration . '|' . $token, $key );

   757 				break;

   730 

   758 			case 'secure_auth':

   731 		$cookie = $user->user_login . '|' . $expiration . '|' . $token . '|' . $hash;

   759 				$cookie_name = SECURE_AUTH_COOKIE;

   732 

   760 				break;

   733 		/**

   761 			case "logged_in":

   734 		 * Filters the authentication cookie.

   762 				$cookie_name = LOGGED_IN_COOKIE;

   735 		 *

   763 				break;

   736 		 * @since 2.5.0

   764 			default:

   737 		 * @since 4.0.0 The `$token` parameter was added.

   765 				if ( is_ssl() ) {

   738 		 *

   739 		 * @param string $cookie     Authentication cookie.

   740 		 * @param int    $user_id    User ID.

   741 		 * @param int    $expiration The time the cookie expires as a UNIX timestamp.

   742 		 * @param string $scheme     Cookie scheme used. Accepts 'auth', 'secure_auth', or 'logged_in'.

   743 		 * @param string $token      User's session token used.

   744 		 */

   745 		return apply_filters( 'auth_cookie', $cookie, $user_id, $expiration, $scheme, $token );

   746 	}

   747 endif;

   748 

   749 if ( ! function_exists( 'wp_parse_auth_cookie' ) ) :

   750 	/**

   751 	 * Parse a cookie into its components

   752 	 *

   753 	 * @since 2.7.0

   754 	 *

   755 	 * @param string $cookie

   756 	 * @param string $scheme Optional. The cookie scheme to use: auth, secure_auth, or logged_in

   757 	 * @return array|false Authentication cookie components

   758 	 */

   759 	function wp_parse_auth_cookie( $cookie = '', $scheme = '' ) {

   760 		if ( empty( $cookie ) ) {

   761 			switch ( $scheme ) {

   762 				case 'auth':

   763 					$cookie_name = AUTH_COOKIE;

   764 					break;

   765 				case 'secure_auth':

   767 					$scheme = 'secure_auth';

   767 					break;

   768 				} else {

   768 				case 'logged_in':

   769 					$cookie_name = AUTH_COOKIE;

   769 					$cookie_name = LOGGED_IN_COOKIE;

   770 					$scheme = 'auth';

   770 					break;

   771 				}

   771 				default:

   772 	    }

   772 					if ( is_ssl() ) {

   773 

   773 						$cookie_name = SECURE_AUTH_COOKIE;

   774 		if ( empty($_COOKIE[$cookie_name]) )

   774 						$scheme      = 'secure_auth';

   775 					} else {

   776 						$cookie_name = AUTH_COOKIE;

   777 						$scheme      = 'auth';

   778 					}

   779 			}

   780 

   781 			if ( empty( $_COOKIE[ $cookie_name ] ) ) {

   782 				return false;

   783 			}

   784 			$cookie = $_COOKIE[ $cookie_name ];

   785 		}

   786 

   787 		$cookie_elements = explode( '|', $cookie );

   788 		if ( count( $cookie_elements ) !== 4 ) {

   776 		$cookie = $_COOKIE[$cookie_name];

   790 		}

   777 	}

   791 

   778 

   792 		list( $username, $expiration, $token, $hmac ) = $cookie_elements;

   779 	$cookie_elements = explode('|', $cookie);

   793 

   780 	if ( count( $cookie_elements ) !== 4 ) {

   794 		return compact( 'username', 'expiration', 'token', 'hmac', 'scheme' );

   781 		return false;

   795 	}

   782 	}

   796 endif;

   783 

   797 

   784 	list( $username, $expiration, $token, $hmac ) = $cookie_elements;

   798 if ( ! function_exists( 'wp_set_auth_cookie' ) ) :

   785 

   799 	/**

   786 	return compact( 'username', 'expiration', 'token', 'hmac', 'scheme' );

   800 	 * Log in a user by setting authentication cookies.

   787 }

   801 	 *

   788 endif;

   802 	 * The $remember parameter increases the time that the cookie will be kept. The

   789 

   803 	 * default the cookie is kept without remembering is two days. When $remember is

   790 if ( !function_exists('wp_set_auth_cookie') ) :

   804 	 * set, the cookies will be kept for 14 days or two weeks.

   791 /**

   805 	 *

   792  * Log in a user by setting authentication cookies.

   806 	 * @since 2.5.0

   793  *

   807 	 * @since 4.3.0 Added the `$token` parameter.

   794  * The $remember parameter increases the time that the cookie will be kept. The

   808 	 *

   795  * default the cookie is kept without remembering is two days. When $remember is

   809 	 * @param int    $user_id  User ID

   796  * set, the cookies will be kept for 14 days or two weeks.

   810 	 * @param bool   $remember Whether to remember the user

   797  *

   811 	 * @param mixed  $secure   Whether the admin cookies should only be sent over HTTPS.

   798  * @since 2.5.0

   812 	 *                         Default is_ssl().

   799  * @since 4.3.0 Added the `$token` parameter.

   813 	 * @param string $token    Optional. User's session token to use for this cookie.

   800  *

   814 	 */

   801  * @param int    $user_id  User ID

   815 	function wp_set_auth_cookie( $user_id, $remember = false, $secure = '', $token = '' ) {

   802  * @param bool   $remember Whether to remember the user

   816 		if ( $remember ) {

   803  * @param mixed  $secure   Whether the admin cookies should only be sent over HTTPS.

   817 			/**

   804  *                         Default is_ssl().

   818 			 * Filters the duration of the authentication cookie expiration period.

   805  * @param string $token    Optional. User's session token to use for this cookie.

   819 			 *

   806  */

   820 			 * @since 2.8.0

   807 function wp_set_auth_cookie( $user_id, $remember = false, $secure = '', $token = '' ) {

   821 			 *

   808 	if ( $remember ) {

   822 			 * @param int  $length   Duration of the expiration period in seconds.

   809 		/**

   823 			 * @param int  $user_id  User ID.

   810 		 * Filters the duration of the authentication cookie expiration period.

   824 			 * @param bool $remember Whether to remember the user login. Default false.

   811 		 *

   825 			 */

   812 		 * @since 2.8.0

   826 			$expiration = time() + apply_filters( 'auth_cookie_expiration', 14 * DAY_IN_SECONDS, $user_id, $remember );

   813 		 *