Thread

CREATE TABLE `tcs_users` (
  `id` mediumint(8) unsigned NOT NULL AUTO_INCREMENT,
  `group_id` mediumint(8) unsigned NOT NULL,
  `ip_address` char(16) NOT NULL,
  `username` varchar(15) NOT NULL,
  `password` varchar(40) NOT NULL,
  `salt` varchar(40) DEFAULT NULL,
  `email` varchar(100) NOT NULL,
  `activation_code` varchar(40) DEFAULT NULL,
  `forgotten_password_code` varchar(40) DEFAULT NULL,
  `remember_code` varchar(40) DEFAULT NULL,
  `created_on` int(11) unsigned NOT NULL,
  `last_login` int(11) unsigned DEFAULT NULL,
  `last_login_ip` varchar(20) DEFAULT NULL,
  `active` tinyint(1) unsigned DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

/**
     * login
     *
     * @return bool
     * @author Mathew
     **/
    public function login($identity, $password, $remember=FALSE)
    {
        if (empty($identity) || empty($password) || !$this->identity_check($identity))
        {
        return FALSE;
        }

        $query = $this->db->select($this->identity_column.', id, password, group_id, last_login, ip_address')
                  ->where($this->identity_column, $identity)
                  ->where('active', 1)
                  ->where($this->ion_auth->_extra_where)
                  ->limit(1)
                  ->get($this->tables['users']);

        $result = $query->row();

        if ($query->num_rows() == 1)
        {
        $password = $this->hash_password_db($identity, $password);

        if ($result->password === $password)
        {

            $group_row = $this->db->select('name')->where('id', $result->group_id)->get($this->tables['groups'])->row();

            $session_data = array(
                    $this->identity_column => $result->{$this->identity_column},
                    'id'                   => $result->id, //kept for backwards compatibility
                    'user_id'              => $result->id, //everyone likes to overwrite id so we'll use user_id
                    'group_id'             => $result->group_id,
                    'group'                => $group_row->name,
                    'userlastlogin'        => $result->last_login,
                    'userlastloginip'      => $this->session->userdata('ip_address')
                     );

            $this->session->set_userdata($session_data);
                
            $this->update_last_login($result->id, $this->session->userdata('ip_address'));
        
            if ($remember && $this->config->item('remember_users', 'ion_auth'))
            {
            $this->remember_user($result->id);
            }

            return TRUE;
        }
        }

        return FALSE;
    }

/**
     * update_last_login
     *
     * @return bool
     * @author Ben Edmunds
     **/
    public function update_last_login($id,$lastloginip)
    {
        $this->load->helper('date');

        if (isset($this->ion_auth->_extra_where) && !empty($this->ion_auth->_extra_where))
        {
            $this->db->where($this->ion_auth->_extra_where);
        }

        $this->db->update($this->tables['users'], array('last_login' => now(), 'last_login_ip' => $lastloginip), array('id' => $id));

        return $this->db->affected_rows() == 1;
    }

echo $this->session->userdata('userlastlogin')
echo $this->session->userdata('userlastloginip')

if ( ! class_exists('Controller'))
{
    class Controller extends CI_Controller {}
}

class Auth extends Controller {

    //redirect if needed, otherwise display the user list
    function index()
    {

class Auth extends CI_Controller {

    //redirect if needed, otherwise display the user list
    public function index()
    {

/*
 * CREATE TABLE
 * ip_address: ip address of the person that attempted to login
 * datetime: when the login attempt happened
 * identity: email or username depending on ion_auth settings
*/
DROP TABLE IF EXISTS `auth_failed_login`;
CREATE TABLE IF NOT EXISTS `auth_failed_login` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `ip_address` varchar(15) NOT NULL,
  `datetime` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
  `identity` varchar(255) NOT NULL,
  PRIMARY KEY (`id`)
);

/*
 * ion_auth CONFIG FILE
 */
//add to the tables list
$config['tables']['failed_login']    = 'auth_failed_login';
//number of failed login attempts allowed
$config['max_attempts'] = 5;
//limit the max_attempts to an amount of time
//i.e default = 5 attempts allowed within 180 seconds (5 minutes)
$config['max_within'] = 300;
//number of seconds after the last failed attempt the user
//will not be allowed to login (ban time). default = 600 seconds (10 minutes)
$config['ban_seconds'] = 600;

/*
 * ion_auth_model MODEL FUNCTIONS
 */

/**
 * add_failed_login
 *
 * create a new failed login line on the database
 *
 * @return bool
 * @author Madoc
 **/
public function add_failed_login($identity, $ipaddress)
{
    if (!$identity || !$ipaddress) : return false; endif;

    $this->db->set('ip_address', $ipaddress);
    $this->db->set('identity', $identity);
    $this->db->set('datetime', 'now()', false);

    return $this->db->insert($this->tables['failed_login']);
}

/**
 * get_count_failed_logins
 *
 * get the number of failed login attempts for a given $identity
 * within the period $datefrom to ($datefrom - $period_seconds)
 *
 * @return int
 * @author Madoc
 **/
public function get_count_failed_logins($identity, $datefrom, $period_seconds)
{

    if (!$identity) : return 0; endif;
    if (!$datefrom) : return 0; endif;
    if (!$period_seconds) : return 0; endif;
    if (!is_numeric($period_seconds)) : return 0; endif;

    $sqlquery = "select count(*) as nbattempts from " . $this->tables['failed_login'];
    $sqlquery .= " where identity = '".$identity."'";
    $sqlquery .= " and datetime between DATE_ADD('".$datefrom."', INTERVAL -".$period_seconds." SECOND) and now()";

    $result = $this->db->query($sqlquery);

    if ($result)
    {
        $row = $result->row_array();
        return (int)$row['nbattempts'];
    }
    else
    {
        return 0;
    }

}

/*
 * get_last_attempt
 *
 * returns the timestamp of the last failed attempt for $identity
 * and time difference in seconds between the last failed login attempt
 * for $identity and NOW()
 *
 * @author Madoc
 *
 */
public function get_last_attempt($identity)
{
    if (!$identity) : return false; endif;

    $this->db->select('datetime, TIME_TO_SEC(TIMEDIFF(NOW(), datetime)) as timediff',false);
    $this->db->where('identity', $identity);
    $this->db->order_by('datetime','desc');
    $this->db->limit(1);

    $result = $this->db->get($this->tables['failed_login']);

    if ($result->num_rows > 0)
    {
        $row = $result->row_array();
        return $row;
    }
    else
    {
        return false;
    }
}

/*
 * Ion_auth LIBRARY FUNCTIONS
 */

/**
 * is_user_banned
 *
 * returns true if the identity is banned, false otherwise.
 * identity banned = the identity was used more than the
 * maximum number of attempts within the maximum allowed failed time
 * and for which the last failed login attempt timestamp is
 * within the banned period (or the max_within if bigger)
 *
 * @return bool
 * @author Madoc
 **/
public function is_user_banned($identity)
{
    if (!$identity) : return false; endif;

    $max_attempts = $this->ci->config->item('max_attempts', 'ion_auth');
    $ban_seconds = $this->ci->config->item('ban_seconds', 'ion_auth');
    $max_within = $this->ci->config->item('max_within', 'ion_auth');

    //get the last attempt
    $last_attempt_array = $this->ci->ion_auth_model->get_last_attempt($identity);
    if ($last_attempt_array)
    {
        //time difference between now and the last failed attempt
        $timediff = $last_attempt_array['timediff'];
        //datetime of the last failed attempt
        $last_attempt = $last_attempt_array['datetime'];
        //number of failed attempts between the last failed attempt and the max_within
        $count_failed_logins = $this->ci->ion_auth_model->get_count_failed_logins($identity, $last_attempt, $max_within);

        //not banned if the maximum number of attempts is not reached
        if ($count_failed_logins >= $max_attempts)
        {
            //at this point, end of ban = end of ban period
            //or end of max_minthin if it is longer

            if ($max_within > $ban_seconds) : $max_time = $max_within; else: $max_time = $ban_seconds; endif;

            if ($timediff < $max_time)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
    else
    {
        //no time difference means no record for this attempt
        return false;
    }
}