wp_set_auth_cookie

The timeline below displays how wordpress function wp_set_auth_cookie has changed across different WordPress versions. If a version is not listed, refer to the next available version below.

WordPress Version: 6.2

/**
 * Sets the authentication cookies based on user ID.
 *
 * The $remember parameter increases the time that the cookie will be kept. The
 * default the cookie is kept without remembering is two days. When $remember is
 * set, the cookies will be kept for 14 days or two weeks.
 *
 * @since 2.5.0
 * @since 4.3.0 Added the `$token` parameter.
 *
 * @param int         $user_id  User ID.
 * @param bool        $remember Whether to remember the user.
 * @param bool|string $secure   Whether the auth cookie should only be sent over HTTPS. Default is an empty
 *                              string which means the value of `is_ssl()` will be used.
 * @param string      $token    Optional. User's session token to use for this cookie.
 */
function wp_set_auth_cookie($user_id, $remember = false, $secure = '', $token = '')
{
    if ($remember) {
        /**
         * Filters the duration of the authentication cookie expiration period.
         *
         * @since 2.8.0
         *
         * @param int  $length   Duration of the expiration period in seconds.
         * @param int  $user_id  User ID.
         * @param bool $remember Whether to remember the user login. Default false.
         */
        $expiration = time() + apply_filters('auth_cookie_expiration', 14 * DAY_IN_SECONDS, $user_id, $remember);
        /*
         * Ensure the browser will continue to send the cookie after the expiration time is reached.
         * Needed for the login grace period in wp_validate_auth_cookie().
         */
        $expire = $expiration + 12 * HOUR_IN_SECONDS;
    } else {
        /** This filter is documented in wp-includes/pluggable.php */
        $expiration = time() + apply_filters('auth_cookie_expiration', 2 * DAY_IN_SECONDS, $user_id, $remember);
        $expire = 0;
    }
    if ('' === $secure) {
        $secure = is_ssl();
    }
    // Front-end cookie is secure when the auth cookie is secure and the site's home URL uses HTTPS.
    $secure_logged_in_cookie = $secure && 'https' === parse_url(get_option('home'), PHP_URL_SCHEME);
    /**
     * Filters whether the auth cookie should only be sent over HTTPS.
     *
     * @since 3.1.0
     *
     * @param bool $secure  Whether the cookie should only be sent over HTTPS.
     * @param int  $user_id User ID.
     */
    $secure = apply_filters('secure_auth_cookie', $secure, $user_id);
    /**
     * Filters whether the logged in cookie should only be sent over HTTPS.
     *
     * @since 3.1.0
     *
     * @param bool $secure_logged_in_cookie Whether the logged in cookie should only be sent over HTTPS.
     * @param int  $user_id                 User ID.
     * @param bool $secure                  Whether the auth cookie should only be sent over HTTPS.
     */
    $secure_logged_in_cookie = apply_filters('secure_logged_in_cookie', $secure_logged_in_cookie, $user_id, $secure);
    if ($secure) {
        $auth_cookie_name = SECURE_AUTH_COOKIE;
        $scheme = 'secure_auth';
    } else {
        $auth_cookie_name = AUTH_COOKIE;
        $scheme = 'auth';
    }
    if ('' === $token) {
        $manager = WP_Session_Tokens::get_instance($user_id);
        $token = $manager->create($expiration);
    }
    $auth_cookie = wp_generate_auth_cookie($user_id, $expiration, $scheme, $token);
    $logged_in_cookie = wp_generate_auth_cookie($user_id, $expiration, 'logged_in', $token);
    /**
     * Fires immediately before the authentication cookie is set.
     *
     * @since 2.5.0
     * @since 4.9.0 The `$token` parameter was added.
     *
     * @param string $auth_cookie Authentication cookie value.
     * @param int    $expire      The time the login grace period expires as a UNIX timestamp.
     *                            Default is 12 hours past the cookie's expiration time.
     * @param int    $expiration  The time when the authentication cookie expires as a UNIX timestamp.
     *                            Default is 14 days from now.
     * @param int    $user_id     User ID.
     * @param string $scheme      Authentication scheme. Values include 'auth' or 'secure_auth'.
     * @param string $token       User's session token to use for this cookie.
     */
    do_action('set_auth_cookie', $auth_cookie, $expire, $expiration, $user_id, $scheme, $token);
    /**
     * Fires immediately before the logged-in authentication cookie is set.
     *
     * @since 2.6.0
     * @since 4.9.0 The `$token` parameter was added.
     *
     * @param string $logged_in_cookie The logged-in cookie value.
     * @param int    $expire           The time the login grace period expires as a UNIX timestamp.
     *                                 Default is 12 hours past the cookie's expiration time.
     * @param int    $expiration       The time when the logged-in authentication cookie expires as a UNIX timestamp.
     *                                 Default is 14 days from now.
     * @param int    $user_id          User ID.
     * @param string $scheme           Authentication scheme. Default 'logged_in'.
     * @param string $token            User's session token to use for this cookie.
     */
    do_action('set_logged_in_cookie', $logged_in_cookie, $expire, $expiration, $user_id, 'logged_in', $token);
    /**
     * Allows preventing auth cookies from actually being sent to the client.
     *
     * @since 4.7.4
     * @since 6.2.0 The `$expire`, `$expiration`, `$user_id`, `$scheme`, and `$token` parameters were added.
     *
     * @param bool   $send       Whether to send auth cookies to the client. Default true.
     * @param int    $expire     The time the login grace period expires as a UNIX timestamp.
     *                           Default is 12 hours past the cookie's expiration time. Zero when clearing cookies.
     * @param int    $expiration The time when the logged-in authentication cookie expires as a UNIX timestamp.
     *                           Default is 14 days from now. Zero when clearing cookies.
     * @param int    $user_id    User ID. Zero when clearing cookies.
     * @param string $scheme     Authentication scheme. Values include 'auth' or 'secure_auth'.
     *                           Empty string when clearing cookies.
     * @param string $token      User's session token to use for this cookie. Empty string when clearing cookies.
     */
    if (!apply_filters('send_auth_cookies', true, $expire, $expiration, $user_id, $scheme, $token)) {
        return;
    }
    setcookie($auth_cookie_name, $auth_cookie, $expire, PLUGINS_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie($auth_cookie_name, $auth_cookie, $expire, ADMIN_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, COOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    if (COOKIEPATH != SITECOOKIEPATH) {
        setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, SITECOOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    }
}

WordPress Version: 5.4

/**
 * Sets the authentication cookies based on user ID.
 *
 * The $remember parameter increases the time that the cookie will be kept. The
 * default the cookie is kept without remembering is two days. When $remember is
 * set, the cookies will be kept for 14 days or two weeks.
 *
 * @since 2.5.0
 * @since 4.3.0 Added the `$token` parameter.
 *
 * @param int         $user_id  User ID.
 * @param bool        $remember Whether to remember the user.
 * @param bool|string $secure   Whether the auth cookie should only be sent over HTTPS. Default is an empty
 *                              string which means the value of `is_ssl()` will be used.
 * @param string      $token    Optional. User's session token to use for this cookie.
 */
function wp_set_auth_cookie($user_id, $remember = false, $secure = '', $token = '')
{
    if ($remember) {
        /**
         * Filters the duration of the authentication cookie expiration period.
         *
         * @since 2.8.0
         *
         * @param int  $length   Duration of the expiration period in seconds.
         * @param int  $user_id  User ID.
         * @param bool $remember Whether to remember the user login. Default false.
         */
        $expiration = time() + apply_filters('auth_cookie_expiration', 14 * DAY_IN_SECONDS, $user_id, $remember);
        /*
         * Ensure the browser will continue to send the cookie after the expiration time is reached.
         * Needed for the login grace period in wp_validate_auth_cookie().
         */
        $expire = $expiration + 12 * HOUR_IN_SECONDS;
    } else {
        /** This filter is documented in wp-includes/pluggable.php */
        $expiration = time() + apply_filters('auth_cookie_expiration', 2 * DAY_IN_SECONDS, $user_id, $remember);
        $expire = 0;
    }
    if ('' === $secure) {
        $secure = is_ssl();
    }
    // Front-end cookie is secure when the auth cookie is secure and the site's home URL uses HTTPS.
    $secure_logged_in_cookie = $secure && 'https' === parse_url(get_option('home'), PHP_URL_SCHEME);
    /**
     * Filters whether the auth cookie should only be sent over HTTPS.
     *
     * @since 3.1.0
     *
     * @param bool $secure  Whether the cookie should only be sent over HTTPS.
     * @param int  $user_id User ID.
     */
    $secure = apply_filters('secure_auth_cookie', $secure, $user_id);
    /**
     * Filters whether the logged in cookie should only be sent over HTTPS.
     *
     * @since 3.1.0
     *
     * @param bool $secure_logged_in_cookie Whether the logged in cookie should only be sent over HTTPS.
     * @param int  $user_id                 User ID.
     * @param bool $secure                  Whether the auth cookie should only be sent over HTTPS.
     */
    $secure_logged_in_cookie = apply_filters('secure_logged_in_cookie', $secure_logged_in_cookie, $user_id, $secure);
    if ($secure) {
        $auth_cookie_name = SECURE_AUTH_COOKIE;
        $scheme = 'secure_auth';
    } else {
        $auth_cookie_name = AUTH_COOKIE;
        $scheme = 'auth';
    }
    if ('' === $token) {
        $manager = WP_Session_Tokens::get_instance($user_id);
        $token = $manager->create($expiration);
    }
    $auth_cookie = wp_generate_auth_cookie($user_id, $expiration, $scheme, $token);
    $logged_in_cookie = wp_generate_auth_cookie($user_id, $expiration, 'logged_in', $token);
    /**
     * Fires immediately before the authentication cookie is set.
     *
     * @since 2.5.0
     * @since 4.9.0 The `$token` parameter was added.
     *
     * @param string $auth_cookie Authentication cookie value.
     * @param int    $expire      The time the login grace period expires as a UNIX timestamp.
     *                            Default is 12 hours past the cookie's expiration time.
     * @param int    $expiration  The time when the authentication cookie expires as a UNIX timestamp.
     *                            Default is 14 days from now.
     * @param int    $user_id     User ID.
     * @param string $scheme      Authentication scheme. Values include 'auth' or 'secure_auth'.
     * @param string $token       User's session token to use for this cookie.
     */
    do_action('set_auth_cookie', $auth_cookie, $expire, $expiration, $user_id, $scheme, $token);
    /**
     * Fires immediately before the logged-in authentication cookie is set.
     *
     * @since 2.6.0
     * @since 4.9.0 The `$token` parameter was added.
     *
     * @param string $logged_in_cookie The logged-in cookie value.
     * @param int    $expire           The time the login grace period expires as a UNIX timestamp.
     *                                 Default is 12 hours past the cookie's expiration time.
     * @param int    $expiration       The time when the logged-in authentication cookie expires as a UNIX timestamp.
     *                                 Default is 14 days from now.
     * @param int    $user_id          User ID.
     * @param string $scheme           Authentication scheme. Default 'logged_in'.
     * @param string $token            User's session token to use for this cookie.
     */
    do_action('set_logged_in_cookie', $logged_in_cookie, $expire, $expiration, $user_id, 'logged_in', $token);
    /**
     * Allows preventing auth cookies from actually being sent to the client.
     *
     * @since 4.7.4
     *
     * @param bool $send Whether to send auth cookies to the client.
     */
    if (!apply_filters('send_auth_cookies', true)) {
        return;
    }
    setcookie($auth_cookie_name, $auth_cookie, $expire, PLUGINS_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie($auth_cookie_name, $auth_cookie, $expire, ADMIN_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, COOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    if (COOKIEPATH != SITECOOKIEPATH) {
        setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, SITECOOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    }
}

WordPress Version: 5.3

/**
 * Sets the authentication cookies based on user ID.
 *
 * The $remember parameter increases the time that the cookie will be kept. The
 * default the cookie is kept without remembering is two days. When $remember is
 * set, the cookies will be kept for 14 days or two weeks.
 *
 * @since 2.5.0
 * @since 4.3.0 Added the `$token` parameter.
 *
 * @param int    $user_id  User ID.
 * @param bool   $remember Whether to remember the user.
 * @param mixed  $secure   Whether the admin cookies should only be sent over HTTPS.
 *                         Default is the value of is_ssl().
 * @param string $token    Optional. User's session token to use for this cookie.
 */
function wp_set_auth_cookie($user_id, $remember = false, $secure = '', $token = '')
{
    if ($remember) {
        /**
         * Filters the duration of the authentication cookie expiration period.
         *
         * @since 2.8.0
         *
         * @param int  $length   Duration of the expiration period in seconds.
         * @param int  $user_id  User ID.
         * @param bool $remember Whether to remember the user login. Default false.
         */
        $expiration = time() + apply_filters('auth_cookie_expiration', 14 * DAY_IN_SECONDS, $user_id, $remember);
        /*
         * Ensure the browser will continue to send the cookie after the expiration time is reached.
         * Needed for the login grace period in wp_validate_auth_cookie().
         */
        $expire = $expiration + 12 * HOUR_IN_SECONDS;
    } else {
        /** This filter is documented in wp-includes/pluggable.php */
        $expiration = time() + apply_filters('auth_cookie_expiration', 2 * DAY_IN_SECONDS, $user_id, $remember);
        $expire = 0;
    }
    if ('' === $secure) {
        $secure = is_ssl();
    }
    // Front-end cookie is secure when the auth cookie is secure and the site's home URL is forced HTTPS.
    $secure_logged_in_cookie = $secure && 'https' === parse_url(get_option('home'), PHP_URL_SCHEME);
    /**
     * Filters whether the connection is secure.
     *
     * @since 3.1.0
     *
     * @param bool $secure  Whether the connection is secure.
     * @param int  $user_id User ID.
     */
    $secure = apply_filters('secure_auth_cookie', $secure, $user_id);
    /**
     * Filters whether to use a secure cookie when logged-in.
     *
     * @since 3.1.0
     *
     * @param bool $secure_logged_in_cookie Whether to use a secure cookie when logged-in.
     * @param int  $user_id                 User ID.
     * @param bool $secure                  Whether the connection is secure.
     */
    $secure_logged_in_cookie = apply_filters('secure_logged_in_cookie', $secure_logged_in_cookie, $user_id, $secure);
    if ($secure) {
        $auth_cookie_name = SECURE_AUTH_COOKIE;
        $scheme = 'secure_auth';
    } else {
        $auth_cookie_name = AUTH_COOKIE;
        $scheme = 'auth';
    }
    if ('' === $token) {
        $manager = WP_Session_Tokens::get_instance($user_id);
        $token = $manager->create($expiration);
    }
    $auth_cookie = wp_generate_auth_cookie($user_id, $expiration, $scheme, $token);
    $logged_in_cookie = wp_generate_auth_cookie($user_id, $expiration, 'logged_in', $token);
    /**
     * Fires immediately before the authentication cookie is set.
     *
     * @since 2.5.0
     * @since 4.9.0 The `$token` parameter was added.
     *
     * @param string $auth_cookie Authentication cookie value.
     * @param int    $expire      The time the login grace period expires as a UNIX timestamp.
     *                            Default is 12 hours past the cookie's expiration time.
     * @param int    $expiration  The time when the authentication cookie expires as a UNIX timestamp.
     *                            Default is 14 days from now.
     * @param int    $user_id     User ID.
     * @param string $scheme      Authentication scheme. Values include 'auth' or 'secure_auth'.
     * @param string $token       User's session token to use for this cookie.
     */
    do_action('set_auth_cookie', $auth_cookie, $expire, $expiration, $user_id, $scheme, $token);
    /**
     * Fires immediately before the logged-in authentication cookie is set.
     *
     * @since 2.6.0
     * @since 4.9.0 The `$token` parameter was added.
     *
     * @param string $logged_in_cookie The logged-in cookie value.
     * @param int    $expire           The time the login grace period expires as a UNIX timestamp.
     *                                 Default is 12 hours past the cookie's expiration time.
     * @param int    $expiration       The time when the logged-in authentication cookie expires as a UNIX timestamp.
     *                                 Default is 14 days from now.
     * @param int    $user_id          User ID.
     * @param string $scheme           Authentication scheme. Default 'logged_in'.
     * @param string $token            User's session token to use for this cookie.
     */
    do_action('set_logged_in_cookie', $logged_in_cookie, $expire, $expiration, $user_id, 'logged_in', $token);
    /**
     * Allows preventing auth cookies from actually being sent to the client.
     *
     * @since 4.7.4
     *
     * @param bool $send Whether to send auth cookies to the client.
     */
    if (!apply_filters('send_auth_cookies', true)) {
        return;
    }
    setcookie($auth_cookie_name, $auth_cookie, $expire, PLUGINS_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie($auth_cookie_name, $auth_cookie, $expire, ADMIN_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, COOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    if (COOKIEPATH != SITECOOKIEPATH) {
        setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, SITECOOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    }
}

WordPress Version: 5.1

/**
 * Log in a user by setting authentication cookies.
 *
 * The $remember parameter increases the time that the cookie will be kept. The
 * default the cookie is kept without remembering is two days. When $remember is
 * set, the cookies will be kept for 14 days or two weeks.
 *
 * @since 2.5.0
 * @since 4.3.0 Added the `$token` parameter.
 *
 * @param int    $user_id  User ID
 * @param bool   $remember Whether to remember the user
 * @param mixed  $secure   Whether the admin cookies should only be sent over HTTPS.
 *                         Default is_ssl().
 * @param string $token    Optional. User's session token to use for this cookie.
 */
function wp_set_auth_cookie($user_id, $remember = false, $secure = '', $token = '')
{
    if ($remember) {
        /**
         * Filters the duration of the authentication cookie expiration period.
         *
         * @since 2.8.0
         *
         * @param int  $length   Duration of the expiration period in seconds.
         * @param int  $user_id  User ID.
         * @param bool $remember Whether to remember the user login. Default false.
         */
        $expiration = time() + apply_filters('auth_cookie_expiration', 14 * DAY_IN_SECONDS, $user_id, $remember);
        /*
         * Ensure the browser will continue to send the cookie after the expiration time is reached.
         * Needed for the login grace period in wp_validate_auth_cookie().
         */
        $expire = $expiration + 12 * HOUR_IN_SECONDS;
    } else {
        /** This filter is documented in wp-includes/pluggable.php */
        $expiration = time() + apply_filters('auth_cookie_expiration', 2 * DAY_IN_SECONDS, $user_id, $remember);
        $expire = 0;
    }
    if ('' === $secure) {
        $secure = is_ssl();
    }
    // Front-end cookie is secure when the auth cookie is secure and the site's home URL is forced HTTPS.
    $secure_logged_in_cookie = $secure && 'https' === parse_url(get_option('home'), PHP_URL_SCHEME);
    /**
     * Filters whether the connection is secure.
     *
     * @since 3.1.0
     *
     * @param bool $secure  Whether the connection is secure.
     * @param int  $user_id User ID.
     */
    $secure = apply_filters('secure_auth_cookie', $secure, $user_id);
    /**
     * Filters whether to use a secure cookie when logged-in.
     *
     * @since 3.1.0
     *
     * @param bool $secure_logged_in_cookie Whether to use a secure cookie when logged-in.
     * @param int  $user_id                 User ID.
     * @param bool $secure                  Whether the connection is secure.
     */
    $secure_logged_in_cookie = apply_filters('secure_logged_in_cookie', $secure_logged_in_cookie, $user_id, $secure);
    if ($secure) {
        $auth_cookie_name = SECURE_AUTH_COOKIE;
        $scheme = 'secure_auth';
    } else {
        $auth_cookie_name = AUTH_COOKIE;
        $scheme = 'auth';
    }
    if ('' === $token) {
        $manager = WP_Session_Tokens::get_instance($user_id);
        $token = $manager->create($expiration);
    }
    $auth_cookie = wp_generate_auth_cookie($user_id, $expiration, $scheme, $token);
    $logged_in_cookie = wp_generate_auth_cookie($user_id, $expiration, 'logged_in', $token);
    /**
     * Fires immediately before the authentication cookie is set.
     *
     * @since 2.5.0
     * @since 4.9.0 The `$token` parameter was added.
     *
     * @param string $auth_cookie Authentication cookie value.
     * @param int    $expire      The time the login grace period expires as a UNIX timestamp.
     *                            Default is 12 hours past the cookie's expiration time.
     * @param int    $expiration  The time when the authentication cookie expires as a UNIX timestamp.
     *                            Default is 14 days from now.
     * @param int    $user_id     User ID.
     * @param string $scheme      Authentication scheme. Values include 'auth' or 'secure_auth'.
     * @param string $token       User's session token to use for this cookie.
     */
    do_action('set_auth_cookie', $auth_cookie, $expire, $expiration, $user_id, $scheme, $token);
    /**
     * Fires immediately before the logged-in authentication cookie is set.
     *
     * @since 2.6.0
     * @since 4.9.0 The `$token` parameter was added.
     *
     * @param string $logged_in_cookie The logged-in cookie value.
     * @param int    $expire           The time the login grace period expires as a UNIX timestamp.
     *                                 Default is 12 hours past the cookie's expiration time.
     * @param int    $expiration       The time when the logged-in authentication cookie expires as a UNIX timestamp.
     *                                 Default is 14 days from now.
     * @param int    $user_id          User ID.
     * @param string $scheme           Authentication scheme. Default 'logged_in'.
     * @param string $token            User's session token to use for this cookie.
     */
    do_action('set_logged_in_cookie', $logged_in_cookie, $expire, $expiration, $user_id, 'logged_in', $token);
    /**
     * Allows preventing auth cookies from actually being sent to the client.
     *
     * @since 4.7.4
     *
     * @param bool $send Whether to send auth cookies to the client.
     */
    if (!apply_filters('send_auth_cookies', true)) {
        return;
    }
    setcookie($auth_cookie_name, $auth_cookie, $expire, PLUGINS_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie($auth_cookie_name, $auth_cookie, $expire, ADMIN_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, COOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    if (COOKIEPATH != SITECOOKIEPATH) {
        setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, SITECOOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    }
}

WordPress Version: 4.9

/**
 * Log in a user by setting authentication cookies.
 *
 * The $remember parameter increases the time that the cookie will be kept. The
 * default the cookie is kept without remembering is two days. When $remember is
 * set, the cookies will be kept for 14 days or two weeks.
 *
 * @since 2.5.0
 * @since 4.3.0 Added the `$token` parameter.
 *
 * @param int    $user_id  User ID
 * @param bool   $remember Whether to remember the user
 * @param mixed  $secure   Whether the admin cookies should only be sent over HTTPS.
 *                         Default is_ssl().
 * @param string $token    Optional. User's session token to use for this cookie.
 */
function wp_set_auth_cookie($user_id, $remember = false, $secure = '', $token = '')
{
    if ($remember) {
        /**
         * Filters the duration of the authentication cookie expiration period.
         *
         * @since 2.8.0
         *
         * @param int  $length   Duration of the expiration period in seconds.
         * @param int  $user_id  User ID.
         * @param bool $remember Whether to remember the user login. Default false.
         */
        $expiration = time() + apply_filters('auth_cookie_expiration', 14 * DAY_IN_SECONDS, $user_id, $remember);
        /*
         * Ensure the browser will continue to send the cookie after the expiration time is reached.
         * Needed for the login grace period in wp_validate_auth_cookie().
         */
        $expire = $expiration + 12 * HOUR_IN_SECONDS;
    } else {
        /** This filter is documented in wp-includes/pluggable.php */
        $expiration = time() + apply_filters('auth_cookie_expiration', 2 * DAY_IN_SECONDS, $user_id, $remember);
        $expire = 0;
    }
    if ('' === $secure) {
        $secure = is_ssl();
    }
    // Front-end cookie is secure when the auth cookie is secure and the site's home URL is forced HTTPS.
    $secure_logged_in_cookie = $secure && 'https' === parse_url(get_option('home'), PHP_URL_SCHEME);
    /**
     * Filters whether the connection is secure.
     *
     * @since 3.1.0
     *
     * @param bool $secure  Whether the connection is secure.
     * @param int  $user_id User ID.
     */
    $secure = apply_filters('secure_auth_cookie', $secure, $user_id);
    /**
     * Filters whether to use a secure cookie when logged-in.
     *
     * @since 3.1.0
     *
     * @param bool $secure_logged_in_cookie Whether to use a secure cookie when logged-in.
     * @param int  $user_id                 User ID.
     * @param bool $secure                  Whether the connection is secure.
     */
    $secure_logged_in_cookie = apply_filters('secure_logged_in_cookie', $secure_logged_in_cookie, $user_id, $secure);
    if ($secure) {
        $auth_cookie_name = SECURE_AUTH_COOKIE;
        $scheme = 'secure_auth';
    } else {
        $auth_cookie_name = AUTH_COOKIE;
        $scheme = 'auth';
    }
    if ('' === $token) {
        $manager = WP_Session_Tokens::get_instance($user_id);
        $token = $manager->create($expiration);
    }
    $auth_cookie = wp_generate_auth_cookie($user_id, $expiration, $scheme, $token);
    $logged_in_cookie = wp_generate_auth_cookie($user_id, $expiration, 'logged_in', $token);
    /**
     * Fires immediately before the authentication cookie is set.
     *
     * @since 2.5.0
     * @since 4.9.0 The `$token` parameter was added.
     *
     * @param string $auth_cookie Authentication cookie.
     * @param int    $expire      The time the login grace period expires as a UNIX timestamp.
     *                            Default is 12 hours past the cookie's expiration time.
     * @param int    $expiration  The time when the authentication cookie expires as a UNIX timestamp.
     *                            Default is 14 days from now.
     * @param int    $user_id     User ID.
     * @param string $scheme      Authentication scheme. Values include 'auth', 'secure_auth', or 'logged_in'.
     * @param string $token       User's session token to use for this cookie.
     */
    do_action('set_auth_cookie', $auth_cookie, $expire, $expiration, $user_id, $scheme, $token);
    /**
     * Fires immediately before the logged-in authentication cookie is set.
     *
     * @since 2.6.0
     * @since 4.9.0 The `$token` parameter was added.
     *
     * @param string $logged_in_cookie The logged-in cookie.
     * @param int    $expire           The time the login grace period expires as a UNIX timestamp.
     *                                 Default is 12 hours past the cookie's expiration time.
     * @param int    $expiration       The time when the logged-in authentication cookie expires as a UNIX timestamp.
     *                                 Default is 14 days from now.
     * @param int    $user_id          User ID.
     * @param string $scheme           Authentication scheme. Default 'logged_in'.
     * @param string $token            User's session token to use for this cookie.
     */
    do_action('set_logged_in_cookie', $logged_in_cookie, $expire, $expiration, $user_id, 'logged_in', $token);
    /**
     * Allows preventing auth cookies from actually being sent to the client.
     *
     * @since 4.7.4
     *
     * @param bool $send Whether to send auth cookies to the client.
     */
    if (!apply_filters('send_auth_cookies', true)) {
        return;
    }
    setcookie($auth_cookie_name, $auth_cookie, $expire, PLUGINS_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie($auth_cookie_name, $auth_cookie, $expire, ADMIN_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, COOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    if (COOKIEPATH != SITECOOKIEPATH) {
        setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, SITECOOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    }
}

WordPress Version: 4.8

/**
 * Log in a user by setting authentication cookies.
 *
 * The $remember parameter increases the time that the cookie will be kept. The
 * default the cookie is kept without remembering is two days. When $remember is
 * set, the cookies will be kept for 14 days or two weeks.
 *
 * @since 2.5.0
 * @since 4.3.0 Added the `$token` parameter.
 *
 * @param int    $user_id  User ID
 * @param bool   $remember Whether to remember the user
 * @param mixed  $secure   Whether the admin cookies should only be sent over HTTPS.
 *                         Default is_ssl().
 * @param string $token    Optional. User's session token to use for this cookie.
 */
function wp_set_auth_cookie($user_id, $remember = false, $secure = '', $token = '')
{
    if ($remember) {
        /**
         * Filters the duration of the authentication cookie expiration period.
         *
         * @since 2.8.0
         *
         * @param int  $length   Duration of the expiration period in seconds.
         * @param int  $user_id  User ID.
         * @param bool $remember Whether to remember the user login. Default false.
         */
        $expiration = time() + apply_filters('auth_cookie_expiration', 14 * DAY_IN_SECONDS, $user_id, $remember);
        /*
         * Ensure the browser will continue to send the cookie after the expiration time is reached.
         * Needed for the login grace period in wp_validate_auth_cookie().
         */
        $expire = $expiration + 12 * HOUR_IN_SECONDS;
    } else {
        /** This filter is documented in wp-includes/pluggable.php */
        $expiration = time() + apply_filters('auth_cookie_expiration', 2 * DAY_IN_SECONDS, $user_id, $remember);
        $expire = 0;
    }
    if ('' === $secure) {
        $secure = is_ssl();
    }
    // Front-end cookie is secure when the auth cookie is secure and the site's home URL is forced HTTPS.
    $secure_logged_in_cookie = $secure && 'https' === parse_url(get_option('home'), PHP_URL_SCHEME);
    /**
     * Filters whether the connection is secure.
     *
     * @since 3.1.0
     *
     * @param bool $secure  Whether the connection is secure.
     * @param int  $user_id User ID.
     */
    $secure = apply_filters('secure_auth_cookie', $secure, $user_id);
    /**
     * Filters whether to use a secure cookie when logged-in.
     *
     * @since 3.1.0
     *
     * @param bool $secure_logged_in_cookie Whether to use a secure cookie when logged-in.
     * @param int  $user_id                 User ID.
     * @param bool $secure                  Whether the connection is secure.
     */
    $secure_logged_in_cookie = apply_filters('secure_logged_in_cookie', $secure_logged_in_cookie, $user_id, $secure);
    if ($secure) {
        $auth_cookie_name = SECURE_AUTH_COOKIE;
        $scheme = 'secure_auth';
    } else {
        $auth_cookie_name = AUTH_COOKIE;
        $scheme = 'auth';
    }
    if ('' === $token) {
        $manager = WP_Session_Tokens::get_instance($user_id);
        $token = $manager->create($expiration);
    }
    $auth_cookie = wp_generate_auth_cookie($user_id, $expiration, $scheme, $token);
    $logged_in_cookie = wp_generate_auth_cookie($user_id, $expiration, 'logged_in', $token);
    /**
     * Fires immediately before the authentication cookie is set.
     *
     * @since 2.5.0
     *
     * @param string $auth_cookie Authentication cookie.
     * @param int    $expire      The time the login grace period expires as a UNIX timestamp.
     *                            Default is 12 hours past the cookie's expiration time.
     * @param int    $expiration  The time when the authentication cookie expires as a UNIX timestamp.
     *                            Default is 14 days from now.
     * @param int    $user_id     User ID.
     * @param string $scheme      Authentication scheme. Values include 'auth', 'secure_auth', or 'logged_in'.
     */
    do_action('set_auth_cookie', $auth_cookie, $expire, $expiration, $user_id, $scheme);
    /**
     * Fires immediately before the logged-in authentication cookie is set.
     *
     * @since 2.6.0
     *
     * @param string $logged_in_cookie The logged-in cookie.
     * @param int    $expire           The time the login grace period expires as a UNIX timestamp.
     *                                 Default is 12 hours past the cookie's expiration time.
     * @param int    $expiration       The time when the logged-in authentication cookie expires as a UNIX timestamp.
     *                                 Default is 14 days from now.
     * @param int    $user_id          User ID.
     * @param string $scheme           Authentication scheme. Default 'logged_in'.
     */
    do_action('set_logged_in_cookie', $logged_in_cookie, $expire, $expiration, $user_id, 'logged_in');
    /**
     * Allows preventing auth cookies from actually being sent to the client.
     *
     * @since 4.7.4
     *
     * @param bool $send Whether to send auth cookies to the client.
     */
    if (!apply_filters('send_auth_cookies', true)) {
        return;
    }
    setcookie($auth_cookie_name, $auth_cookie, $expire, PLUGINS_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie($auth_cookie_name, $auth_cookie, $expire, ADMIN_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, COOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    if (COOKIEPATH != SITECOOKIEPATH) {
        setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, SITECOOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    }
}

WordPress Version: 4.6

/**
 * Log in a user by setting authentication cookies.
 *
 * The $remember parameter increases the time that the cookie will be kept. The
 * default the cookie is kept without remembering is two days. When $remember is
 * set, the cookies will be kept for 14 days or two weeks.
 *
 * @since 2.5.0
 * @since 4.3.0 Added the `$token` parameter.
 *
 * @param int    $user_id  User ID
 * @param bool   $remember Whether to remember the user
 * @param mixed  $secure   Whether the admin cookies should only be sent over HTTPS.
 *                         Default is_ssl().
 * @param string $token    Optional. User's session token to use for this cookie.
 */
function wp_set_auth_cookie($user_id, $remember = false, $secure = '', $token = '')
{
    if ($remember) {
        /**
         * Filters the duration of the authentication cookie expiration period.
         *
         * @since 2.8.0
         *
         * @param int  $length   Duration of the expiration period in seconds.
         * @param int  $user_id  User ID.
         * @param bool $remember Whether to remember the user login. Default false.
         */
        $expiration = time() + apply_filters('auth_cookie_expiration', 14 * DAY_IN_SECONDS, $user_id, $remember);
        /*
         * Ensure the browser will continue to send the cookie after the expiration time is reached.
         * Needed for the login grace period in wp_validate_auth_cookie().
         */
        $expire = $expiration + 12 * HOUR_IN_SECONDS;
    } else {
        /** This filter is documented in wp-includes/pluggable.php */
        $expiration = time() + apply_filters('auth_cookie_expiration', 2 * DAY_IN_SECONDS, $user_id, $remember);
        $expire = 0;
    }
    if ('' === $secure) {
        $secure = is_ssl();
    }
    // Front-end cookie is secure when the auth cookie is secure and the site's home URL is forced HTTPS.
    $secure_logged_in_cookie = $secure && 'https' === parse_url(get_option('home'), PHP_URL_SCHEME);
    /**
     * Filters whether the connection is secure.
     *
     * @since 3.1.0
     *
     * @param bool $secure  Whether the connection is secure.
     * @param int  $user_id User ID.
     */
    $secure = apply_filters('secure_auth_cookie', $secure, $user_id);
    /**
     * Filters whether to use a secure cookie when logged-in.
     *
     * @since 3.1.0
     *
     * @param bool $secure_logged_in_cookie Whether to use a secure cookie when logged-in.
     * @param int  $user_id                 User ID.
     * @param bool $secure                  Whether the connection is secure.
     */
    $secure_logged_in_cookie = apply_filters('secure_logged_in_cookie', $secure_logged_in_cookie, $user_id, $secure);
    if ($secure) {
        $auth_cookie_name = SECURE_AUTH_COOKIE;
        $scheme = 'secure_auth';
    } else {
        $auth_cookie_name = AUTH_COOKIE;
        $scheme = 'auth';
    }
    if ('' === $token) {
        $manager = WP_Session_Tokens::get_instance($user_id);
        $token = $manager->create($expiration);
    }
    $auth_cookie = wp_generate_auth_cookie($user_id, $expiration, $scheme, $token);
    $logged_in_cookie = wp_generate_auth_cookie($user_id, $expiration, 'logged_in', $token);
    /**
     * Fires immediately before the authentication cookie is set.
     *
     * @since 2.5.0
     *
     * @param string $auth_cookie Authentication cookie.
     * @param int    $expire      The time the login grace period expires as a UNIX timestamp.
     *                            Default is 12 hours past the cookie's expiration time.
     * @param int    $expiration  The time when the authentication cookie expires as a UNIX timestamp.
     *                            Default is 14 days from now.
     * @param int    $user_id     User ID.
     * @param string $scheme      Authentication scheme. Values include 'auth', 'secure_auth', or 'logged_in'.
     */
    do_action('set_auth_cookie', $auth_cookie, $expire, $expiration, $user_id, $scheme);
    /**
     * Fires immediately before the logged-in authentication cookie is set.
     *
     * @since 2.6.0
     *
     * @param string $logged_in_cookie The logged-in cookie.
     * @param int    $expire           The time the login grace period expires as a UNIX timestamp.
     *                                 Default is 12 hours past the cookie's expiration time.
     * @param int    $expiration       The time when the logged-in authentication cookie expires as a UNIX timestamp.
     *                                 Default is 14 days from now.
     * @param int    $user_id          User ID.
     * @param string $scheme           Authentication scheme. Default 'logged_in'.
     */
    do_action('set_logged_in_cookie', $logged_in_cookie, $expire, $expiration, $user_id, 'logged_in');
    setcookie($auth_cookie_name, $auth_cookie, $expire, PLUGINS_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie($auth_cookie_name, $auth_cookie, $expire, ADMIN_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, COOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    if (COOKIEPATH != SITECOOKIEPATH) {
        setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, SITECOOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    }
}

WordPress Version: 4.5

/**
 * Log in a user by setting authentication cookies.
 *
 * The $remember parameter increases the time that the cookie will be kept. The
 * default the cookie is kept without remembering is two days. When $remember is
 * set, the cookies will be kept for 14 days or two weeks.
 *
 * @since 2.5.0
 * @since 4.3.0 Added the `$token` parameter.
 *
 * @param int    $user_id  User ID
 * @param bool   $remember Whether to remember the user
 * @param mixed  $secure   Whether the admin cookies should only be sent over HTTPS.
 *                         Default is_ssl().
 * @param string $token    Optional. User's session token to use for this cookie.
 */
function wp_set_auth_cookie($user_id, $remember = false, $secure = '', $token = '')
{
    if ($remember) {
        /**
         * Filter the duration of the authentication cookie expiration period.
         *
         * @since 2.8.0
         *
         * @param int  $length   Duration of the expiration period in seconds.
         * @param int  $user_id  User ID.
         * @param bool $remember Whether to remember the user login. Default false.
         */
        $expiration = time() + apply_filters('auth_cookie_expiration', 14 * DAY_IN_SECONDS, $user_id, $remember);
        /*
         * Ensure the browser will continue to send the cookie after the expiration time is reached.
         * Needed for the login grace period in wp_validate_auth_cookie().
         */
        $expire = $expiration + 12 * HOUR_IN_SECONDS;
    } else {
        /** This filter is documented in wp-includes/pluggable.php */
        $expiration = time() + apply_filters('auth_cookie_expiration', 2 * DAY_IN_SECONDS, $user_id, $remember);
        $expire = 0;
    }
    if ('' === $secure) {
        $secure = is_ssl();
    }
    // Front-end cookie is secure when the auth cookie is secure and the site's home URL is forced HTTPS.
    $secure_logged_in_cookie = $secure && 'https' === parse_url(get_option('home'), PHP_URL_SCHEME);
    /**
     * Filter whether the connection is secure.
     *
     * @since 3.1.0
     *
     * @param bool $secure  Whether the connection is secure.
     * @param int  $user_id User ID.
     */
    $secure = apply_filters('secure_auth_cookie', $secure, $user_id);
    /**
     * Filter whether to use a secure cookie when logged-in.
     *
     * @since 3.1.0
     *
     * @param bool $secure_logged_in_cookie Whether to use a secure cookie when logged-in.
     * @param int  $user_id                 User ID.
     * @param bool $secure                  Whether the connection is secure.
     */
    $secure_logged_in_cookie = apply_filters('secure_logged_in_cookie', $secure_logged_in_cookie, $user_id, $secure);
    if ($secure) {
        $auth_cookie_name = SECURE_AUTH_COOKIE;
        $scheme = 'secure_auth';
    } else {
        $auth_cookie_name = AUTH_COOKIE;
        $scheme = 'auth';
    }
    if ('' === $token) {
        $manager = WP_Session_Tokens::get_instance($user_id);
        $token = $manager->create($expiration);
    }
    $auth_cookie = wp_generate_auth_cookie($user_id, $expiration, $scheme, $token);
    $logged_in_cookie = wp_generate_auth_cookie($user_id, $expiration, 'logged_in', $token);
    /**
     * Fires immediately before the authentication cookie is set.
     *
     * @since 2.5.0
     *
     * @param string $auth_cookie Authentication cookie.
     * @param int    $expire      Login grace period in seconds. Default 43,200 seconds, or 12 hours.
     * @param int    $expiration  Duration in seconds the authentication cookie should be valid.
     *                            Default 1,209,600 seconds, or 14 days.
     * @param int    $user_id     User ID.
     * @param string $scheme      Authentication scheme. Values include 'auth', 'secure_auth', or 'logged_in'.
     */
    do_action('set_auth_cookie', $auth_cookie, $expire, $expiration, $user_id, $scheme);
    /**
     * Fires immediately before the secure authentication cookie is set.
     *
     * @since 2.6.0
     *
     * @param string $logged_in_cookie The logged-in cookie.
     * @param int    $expire           Login grace period in seconds. Default 43,200 seconds, or 12 hours.
     * @param int    $expiration       Duration in seconds the authentication cookie should be valid.
     *                                 Default 1,209,600 seconds, or 14 days.
     * @param int    $user_id          User ID.
     * @param string $scheme           Authentication scheme. Default 'logged_in'.
     */
    do_action('set_logged_in_cookie', $logged_in_cookie, $expire, $expiration, $user_id, 'logged_in');
    setcookie($auth_cookie_name, $auth_cookie, $expire, PLUGINS_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie($auth_cookie_name, $auth_cookie, $expire, ADMIN_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, COOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    if (COOKIEPATH != SITECOOKIEPATH) {
        setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, SITECOOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    }
}

WordPress Version: 4.3

/**
 * Sets the authentication cookies based on user ID.
 *
 * The $remember parameter increases the time that the cookie will be kept. The
 * default the cookie is kept without remembering is two days. When $remember is
 * set, the cookies will be kept for 14 days or two weeks.
 *
 * @since 2.5.0
 * @since 4.3.0 Added the `$token` parameter.
 *
 * @param int    $user_id  User ID
 * @param bool   $remember Whether to remember the user
 * @param mixed  $secure   Whether the admin cookies should only be sent over HTTPS.
 *                         Default is_ssl().
 * @param string $token    Optional. User's session token to use for this cookie.
 */
function wp_set_auth_cookie($user_id, $remember = false, $secure = '', $token = '')
{
    if ($remember) {
        /**
         * Filter the duration of the authentication cookie expiration period.
         *
         * @since 2.8.0
         *
         * @param int  $length   Duration of the expiration period in seconds.
         * @param int  $user_id  User ID.
         * @param bool $remember Whether to remember the user login. Default false.
         */
        $expiration = time() + apply_filters('auth_cookie_expiration', 14 * DAY_IN_SECONDS, $user_id, $remember);
        /*
         * Ensure the browser will continue to send the cookie after the expiration time is reached.
         * Needed for the login grace period in wp_validate_auth_cookie().
         */
        $expire = $expiration + 12 * HOUR_IN_SECONDS;
    } else {
        /** This filter is documented in wp-includes/pluggable.php */
        $expiration = time() + apply_filters('auth_cookie_expiration', 2 * DAY_IN_SECONDS, $user_id, $remember);
        $expire = 0;
    }
    if ('' === $secure) {
        $secure = is_ssl();
    }
    // Frontend cookie is secure when the auth cookie is secure and the site's home URL is forced HTTPS.
    $secure_logged_in_cookie = $secure && 'https' === parse_url(get_option('home'), PHP_URL_SCHEME);
    /**
     * Filter whether the connection is secure.
     *
     * @since 3.1.0
     *
     * @param bool $secure  Whether the connection is secure.
     * @param int  $user_id User ID.
     */
    $secure = apply_filters('secure_auth_cookie', $secure, $user_id);
    /**
     * Filter whether to use a secure cookie when logged-in.
     *
     * @since 3.1.0
     *
     * @param bool $secure_logged_in_cookie Whether to use a secure cookie when logged-in.
     * @param int  $user_id                 User ID.
     * @param bool $secure                  Whether the connection is secure.
     */
    $secure_logged_in_cookie = apply_filters('secure_logged_in_cookie', $secure_logged_in_cookie, $user_id, $secure);
    if ($secure) {
        $auth_cookie_name = SECURE_AUTH_COOKIE;
        $scheme = 'secure_auth';
    } else {
        $auth_cookie_name = AUTH_COOKIE;
        $scheme = 'auth';
    }
    if ('' === $token) {
        $manager = WP_Session_Tokens::get_instance($user_id);
        $token = $manager->create($expiration);
    }
    $auth_cookie = wp_generate_auth_cookie($user_id, $expiration, $scheme, $token);
    $logged_in_cookie = wp_generate_auth_cookie($user_id, $expiration, 'logged_in', $token);
    /**
     * Fires immediately before the authentication cookie is set.
     *
     * @since 2.5.0
     *
     * @param string $auth_cookie Authentication cookie.
     * @param int    $expire      Login grace period in seconds. Default 43,200 seconds, or 12 hours.
     * @param int    $expiration  Duration in seconds the authentication cookie should be valid.
     *                            Default 1,209,600 seconds, or 14 days.
     * @param int    $user_id     User ID.
     * @param string $scheme      Authentication scheme. Values include 'auth', 'secure_auth', or 'logged_in'.
     */
    do_action('set_auth_cookie', $auth_cookie, $expire, $expiration, $user_id, $scheme);
    /**
     * Fires immediately before the secure authentication cookie is set.
     *
     * @since 2.6.0
     *
     * @param string $logged_in_cookie The logged-in cookie.
     * @param int    $expire           Login grace period in seconds. Default 43,200 seconds, or 12 hours.
     * @param int    $expiration       Duration in seconds the authentication cookie should be valid.
     *                                 Default 1,209,600 seconds, or 14 days.
     * @param int    $user_id          User ID.
     * @param string $scheme           Authentication scheme. Default 'logged_in'.
     */
    do_action('set_logged_in_cookie', $logged_in_cookie, $expire, $expiration, $user_id, 'logged_in');
    setcookie($auth_cookie_name, $auth_cookie, $expire, PLUGINS_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie($auth_cookie_name, $auth_cookie, $expire, ADMIN_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, COOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    if (COOKIEPATH != SITECOOKIEPATH) {
        setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, SITECOOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    }
}

WordPress Version: 4.0

/**
 * Sets the authentication cookies based on user ID.
 *
 * The $remember parameter increases the time that the cookie will be kept. The
 * default the cookie is kept without remembering is two days. When $remember is
 * set, the cookies will be kept for 14 days or two weeks.
 *
 * @since 2.5.0
 *
 * @param int $user_id User ID
 * @param bool $remember Whether to remember the user
 * @param mixed $secure  Whether the admin cookies should only be sent over HTTPS.
 *                       Default is_ssl().
 */
function wp_set_auth_cookie($user_id, $remember = false, $secure = '')
{
    if ($remember) {
        /**
         * Filter the duration of the authentication cookie expiration period.
         *
         * @since 2.8.0
         *
         * @param int  $length   Duration of the expiration period in seconds.
         * @param int  $user_id  User ID.
         * @param bool $remember Whether to remember the user login. Default false.
         */
        $expiration = time() + apply_filters('auth_cookie_expiration', 14 * DAY_IN_SECONDS, $user_id, $remember);
        /*
         * Ensure the browser will continue to send the cookie after the expiration time is reached.
         * Needed for the login grace period in wp_validate_auth_cookie().
         */
        $expire = $expiration + 12 * HOUR_IN_SECONDS;
    } else {
        /** This filter is documented in wp-includes/pluggable.php */
        $expiration = time() + apply_filters('auth_cookie_expiration', 2 * DAY_IN_SECONDS, $user_id, $remember);
        $expire = 0;
    }
    if ('' === $secure) {
        $secure = is_ssl();
    }
    // Frontend cookie is secure when the auth cookie is secure and the site's home URL is forced HTTPS.
    $secure_logged_in_cookie = $secure && 'https' === parse_url(get_option('home'), PHP_URL_SCHEME);
    /**
     * Filter whether the connection is secure.
     *
     * @since 3.1.0
     *
     * @param bool $secure  Whether the connection is secure.
     * @param int  $user_id User ID.
     */
    $secure = apply_filters('secure_auth_cookie', $secure, $user_id);
    /**
     * Filter whether to use a secure cookie when logged-in.
     *
     * @since 3.1.0
     *
     * @param bool $secure_logged_in_cookie Whether to use a secure cookie when logged-in.
     * @param int  $user_id                 User ID.
     * @param bool $secure                  Whether the connection is secure.
     */
    $secure_logged_in_cookie = apply_filters('secure_logged_in_cookie', $secure_logged_in_cookie, $user_id, $secure);
    if ($secure) {
        $auth_cookie_name = SECURE_AUTH_COOKIE;
        $scheme = 'secure_auth';
    } else {
        $auth_cookie_name = AUTH_COOKIE;
        $scheme = 'auth';
    }
    $manager = WP_Session_Tokens::get_instance($user_id);
    $token = $manager->create($expiration);
    $auth_cookie = wp_generate_auth_cookie($user_id, $expiration, $scheme, $token);
    $logged_in_cookie = wp_generate_auth_cookie($user_id, $expiration, 'logged_in', $token);
    /**
     * Fires immediately before the authentication cookie is set.
     *
     * @since 2.5.0
     *
     * @param string $auth_cookie Authentication cookie.
     * @param int    $expire      Login grace period in seconds. Default 43,200 seconds, or 12 hours.
     * @param int    $expiration  Duration in seconds the authentication cookie should be valid.
     *                            Default 1,209,600 seconds, or 14 days.
     * @param int    $user_id     User ID.
     * @param string $scheme      Authentication scheme. Values include 'auth', 'secure_auth', or 'logged_in'.
     */
    do_action('set_auth_cookie', $auth_cookie, $expire, $expiration, $user_id, $scheme);
    /**
     * Fires immediately before the secure authentication cookie is set.
     *
     * @since 2.6.0
     *
     * @param string $logged_in_cookie The logged-in cookie.
     * @param int    $expire           Login grace period in seconds. Default 43,200 seconds, or 12 hours.
     * @param int    $expiration       Duration in seconds the authentication cookie should be valid.
     *                                 Default 1,209,600 seconds, or 14 days.
     * @param int    $user_id          User ID.
     * @param string $scheme           Authentication scheme. Default 'logged_in'.
     */
    do_action('set_logged_in_cookie', $logged_in_cookie, $expire, $expiration, $user_id, 'logged_in');
    setcookie($auth_cookie_name, $auth_cookie, $expire, PLUGINS_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie($auth_cookie_name, $auth_cookie, $expire, ADMIN_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, COOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    if (COOKIEPATH != SITECOOKIEPATH) {
        setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, SITECOOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    }
}

WordPress Version: 3.9

/**
 * Sets the authentication cookies based on user ID.
 *
 * The $remember parameter increases the time that the cookie will be kept. The
 * default the cookie is kept without remembering is two days. When $remember is
 * set, the cookies will be kept for 14 days or two weeks.
 *
 * @since 2.5.0
 *
 * @param int $user_id User ID
 * @param bool $remember Whether to remember the user
 */
function wp_set_auth_cookie($user_id, $remember = false, $secure = '')
{
    if ($remember) {
        /**
         * Filter the duration of the authentication cookie expiration period.
         *
         * @since 2.8.0
         *
         * @param int  $length   Duration of the expiration period in seconds.
         * @param int  $user_id  User ID.
         * @param bool $remember Whether to remember the user login. Default false.
         */
        $expiration = time() + apply_filters('auth_cookie_expiration', 14 * DAY_IN_SECONDS, $user_id, $remember);
        /*
         * Ensure the browser will continue to send the cookie after the expiration time is reached.
         * Needed for the login grace period in wp_validate_auth_cookie().
         */
        $expire = $expiration + 12 * HOUR_IN_SECONDS;
    } else {
        /** This filter is documented in wp-includes/pluggable.php */
        $expiration = time() + apply_filters('auth_cookie_expiration', 2 * DAY_IN_SECONDS, $user_id, $remember);
        $expire = 0;
    }
    if ('' === $secure) {
        $secure = is_ssl();
    }
    /**
     * Filter whether the connection is secure.
     *
     * @since 3.1.0
     *
     * @param bool $secure  Whether the connection is secure.
     * @param int  $user_id User ID.
     */
    $secure = apply_filters('secure_auth_cookie', $secure, $user_id);
    /**
     * Filter whether to use a secure cookie when logged-in.
     *
     * @since 3.1.0
     *
     * @param bool $cookie  Whether to use a secure cookie when logged-in.
     * @param int  $user_id User ID.
     * @param bool $secure  Whether the connection is secure.
     */
    $secure_logged_in_cookie = apply_filters('secure_logged_in_cookie', false, $user_id, $secure);
    if ($secure) {
        $auth_cookie_name = SECURE_AUTH_COOKIE;
        $scheme = 'secure_auth';
    } else {
        $auth_cookie_name = AUTH_COOKIE;
        $scheme = 'auth';
    }
    $auth_cookie = wp_generate_auth_cookie($user_id, $expiration, $scheme);
    $logged_in_cookie = wp_generate_auth_cookie($user_id, $expiration, 'logged_in');
    /**
     * Fires immediately before the authentication cookie is set.
     *
     * @since 2.5.0
     *
     * @param string $auth_cookie Authentication cookie.
     * @param int    $expire      Login grace period in seconds. Default 43,200 seconds, or 12 hours.
     * @param int    $expiration  Duration in seconds the authentication cookie should be valid.
     *                            Default 1,209,600 seconds, or 14 days.
     * @param int    $user_id     User ID.
     * @param string $scheme      Authentication scheme. Values include 'auth', 'secure_auth', or 'logged_in'.
     */
    do_action('set_auth_cookie', $auth_cookie, $expire, $expiration, $user_id, $scheme);
    /**
     * Fires immediately before the secure authentication cookie is set.
     *
     * @since 2.6.0
     *
     * @param string $logged_in_cookie The logged-in cookie.
     * @param int    $expire           Login grace period in seconds. Default 43,200 seconds, or 12 hours.
     * @param int    $expiration       Duration in seconds the authentication cookie should be valid.
     *                                 Default 1,209,600 seconds, or 14 days.
     * @param int    $user_id          User ID.
     * @param string $scheme           Authentication scheme. Default 'logged_in'.
     */
    do_action('set_logged_in_cookie', $logged_in_cookie, $expire, $expiration, $user_id, 'logged_in');
    setcookie($auth_cookie_name, $auth_cookie, $expire, PLUGINS_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie($auth_cookie_name, $auth_cookie, $expire, ADMIN_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, COOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    if (COOKIEPATH != SITECOOKIEPATH) {
        setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, SITECOOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    }
}

WordPress Version: 3.7

/**
 * Sets the authentication cookies based User ID.
 *
 * The $remember parameter increases the time that the cookie will be kept. The
 * default the cookie is kept without remembering is two days. When $remember is
 * set, the cookies will be kept for 14 days or two weeks.
 *
 * @since 2.5
 *
 * @param int $user_id User ID
 * @param bool $remember Whether to remember the user
 */
function wp_set_auth_cookie($user_id, $remember = false, $secure = '')
{
    if ($remember) {
        $expiration = time() + apply_filters('auth_cookie_expiration', 14 * DAY_IN_SECONDS, $user_id, $remember);
        // Ensure the browser will continue to send the cookie after the expiration time is reached.
        // Needed for the login grace period in wp_validate_auth_cookie().
        $expire = $expiration + 12 * HOUR_IN_SECONDS;
    } else {
        $expiration = time() + apply_filters('auth_cookie_expiration', 2 * DAY_IN_SECONDS, $user_id, $remember);
        $expire = 0;
    }
    if ('' === $secure) {
        $secure = is_ssl();
    }
    $secure = apply_filters('secure_auth_cookie', $secure, $user_id);
    $secure_logged_in_cookie = apply_filters('secure_logged_in_cookie', false, $user_id, $secure);
    if ($secure) {
        $auth_cookie_name = SECURE_AUTH_COOKIE;
        $scheme = 'secure_auth';
    } else {
        $auth_cookie_name = AUTH_COOKIE;
        $scheme = 'auth';
    }
    $auth_cookie = wp_generate_auth_cookie($user_id, $expiration, $scheme);
    $logged_in_cookie = wp_generate_auth_cookie($user_id, $expiration, 'logged_in');
    do_action('set_auth_cookie', $auth_cookie, $expire, $expiration, $user_id, $scheme);
    do_action('set_logged_in_cookie', $logged_in_cookie, $expire, $expiration, $user_id, 'logged_in');
    setcookie($auth_cookie_name, $auth_cookie, $expire, PLUGINS_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie($auth_cookie_name, $auth_cookie, $expire, ADMIN_COOKIE_PATH, COOKIE_DOMAIN, $secure, true);
    setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, COOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    if (COOKIEPATH != SITECOOKIEPATH) {
        setcookie(LOGGED_IN_COOKIE, $logged_in_cookie, $expire, SITECOOKIEPATH, COOKIE_DOMAIN, $secure_logged_in_cookie, true);
    }
}