um_main.c

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

  	{
  	  return 0;
  	}

  s_user_name = (char *)kstrtolower(user_name,_MM_MOD_UM_ID_);        


  if (um_get_user_byname(s_user_name))
    {
      *errmsg = (lan_type == 2)?(_ERR_CH_UM_USER_ALREADY_EXISTS_):( _ERR_EN_UM_USER_ALREADY_EXISTS_);
      kfree(s_user_name);
      return 0;
    }

  if (um_users->total_user_count >= _UM_MAX_USER_COUNT_)
    {
      *errmsg = (lan_type == 2)?(_ERR_CH_UM_USER_DB_FULL_):(_ERR_EN_UM_USER_DB_FULL_);
      kfree(s_user_name);
      return 0;
    }

  f_user = (struct um_one_user *)kmalloc(sizeof(struct um_one_user),_MM_MOD_UM_ID_);
  if (!f_user)
  	{
  	  *errmsg = (lan_type == 2)?(_ERR_CH_CM_NO_MEMORY_):(_ERR_EN_CM_NO_MEMORY_);
  	  kfree(s_user_name);
  	  return 0;
  	}
  memset(f_user,0,sizeof(struct um_one_user));
      
  name_len = strlen(user_name);
  username =(char *) kmalloc(( name_len + 1),_MM_MOD_UM_ID_);
  if (!username)
  	{
  	  *errmsg = (lan_type == 2)?(_ERR_CH_CM_NO_MEMORY_):(_ERR_EN_CM_NO_MEMORY_);
  	  kfree(s_user_name);
  	  return 0;
  	}
  
  memset(username,0,(name_len+1));
  memcpy(username,user_name,name_len);
  username[name_len] = '\0';      
  f_user->user_name = username;    


  encrypt_passwd = um_encrypt_password(login_pass);
  if (um_password_encrypt == 1)
    {
      set_pass = encrypt_passwd;
    }
  else
    {
      set_pass = login_pass;
    }


  pass_len = strlen(set_pass);



  logpass =(unsigned char *) kmalloc(( pass_len +1 ),_MM_MOD_UM_ID_);
  memset(logpass,0,(pass_len+1));
  if (!logpass)
  	{
  	  *errmsg = (lan_type == 2)?(_ERR_CH_CM_NO_MEMORY_):(_ERR_EN_CM_NO_MEMORY_);
  	  kfree(encrypt_passwd);
  	  kfree(s_user_name);
  	  return 0;
  	}
  
  logpass = strcpy(logpass,set_pass);
  kfree(encrypt_passwd);
  logpass[pass_len] = '\0';
  f_user->login_passwd = logpass;
  
  f_user->user_role = NORMAL_USER;
  f_user->enable_passwd = NULL;
  
  f_user->next_user = NULL;
  f_user->prev_user = um_users->tail;
  
  if (um_users->tail)
    {
      um_users->tail->next_user = f_user;
    }
  else
    {
      um_users->head = f_user;
    }  
          
  um_users->tail = f_user;
  (um_users->total_user_count) ++;      
  
  kfree(s_user_name);
  return 1;

}

/**************************************************
Delete a user from 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_del_user(char *user_name,char **errmsg,unsigned short lan_type)
{
  struct um_one_user *one_user;
  char *s_user_name;

  s_user_name = (char *) kstrtolower(user_name,_MM_MOD_UM_ID_);
  if (strcmp(s_user_name,_UM_DEFAULT_USER_NAME_) == 0)
  	{
  	  *errmsg =(lan_type == 2)?(_ERR_CH_UM_CANT_DEL_DEFAULT_USER_):( _ERR_EN_UM_CANT_DEL_DEFAULT_USER_);
  	  kfree(s_user_name);
  	  return 0;
  	}
  one_user = um_get_user_byname(s_user_name);

  if (!one_user)
  	{
  	  kfree(s_user_name);
  	  *errmsg = (lan_type == 2)?(_ERR_CH_UM_USER_DONOT_EXISTS_):(_ERR_EN_UM_USER_DONOT_EXISTS_) ;
  	  return 0;
  	}

  um_delete_oneuser(one_user);
  kfree(s_user_name);
  return 1;
}


/**************************************************
get a user's user role  
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_get_user_role(char *user_name, enum um_user_role_type *user_role, char **errmsg,unsigned short lan_type)
{
  char *s_user_name;
  struct um_one_user *one_user;
  s_user_name = (char *) kstrtolower(user_name,_MM_MOD_UM_ID_);
  one_user = um_get_user_byname(s_user_name);
  if (!one_user)
  	{
  	  *errmsg =(lan_type == 2)?(_ERR_CH_UM_USER_DONOT_EXISTS_):( _ERR_EN_UM_USER_DONOT_EXISTS_);
  	  kfree(s_user_name);
  	  return 0;
  	}
  else
  	{
  	  *user_role = one_user->user_role;
  	  kfree(s_user_name);
  	  return 1;
  	}
}



/**************************************************
set a user's user role 
if set to admin user , enable_pass must be legal
if set to normal user , enable_pass arg can be NULL.
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_set_user_role(char *user_name,enum um_user_role_type user_role,unsigned char *enable_pass, char **errmsg,unsigned short lan_type)
{
  struct um_one_user *one_user;
  unsigned char *en_pass;
  enum um_user_role_type urole;
  int ret;
  unsigned char *set_pass;
  char *s_user_name;
  unsigned char *encrypt_passwd;

  s_user_name = (char *) kstrtolower(user_name,_MM_MOD_UM_ID_);
  one_user = um_get_user_byname(s_user_name);
  if (!one_user)
  	{
  	  *errmsg = (lan_type == 2)?(_ERR_CH_UM_USER_DONOT_EXISTS_):(_ERR_EN_UM_USER_DONOT_EXISTS_);
  	  kfree(s_user_name);
  	  return 0;
  	}
  else
  	{
  	  if (user_role == ADMIN_USER)
  	  	{
  	  	  ret = um_get_user_role(s_user_name,&urole,errmsg,lan_type);
                  if (!ret)
                        {
                           kfree(s_user_name);
                           return 0;
                        } 
  	  	  if (urole == ADMIN_USER)
  	  	  	{
  	  	  	  *errmsg = (lan_type == 2)?(_ERR_CH_UM_USER_ALREADY_ADMIN_USER_):(_ERR_EN_UM_USER_ALREADY_ADMIN_USER_);
  	  	  	  kfree(s_user_name);
  	  	  	  return 0;
  	  	  	}
  	  	  if (!(um_check_pass_legal(enable_pass,errmsg,1,lan_type)))
  	  	  	{
  	  	  	  kfree(s_user_name);
  	  	  	  return 0;
  	  	  	}

		  encrypt_passwd = um_encrypt_password(enable_pass);

		  if (um_password_encrypt == 1)
		    {
		      set_pass = encrypt_passwd;
		    }
		  else
		    {
		      set_pass = enable_pass;
		    }
	          en_pass = (unsigned char *)kmalloc((strlen(set_pass)+1),_MM_MOD_UM_ID_);
	          memset(en_pass,0,strlen(set_pass)+1);
          
	          if (!en_pass)
        	  	{
          		  kfree(encrypt_passwd);
		    	  *errmsg = (lan_type == 2)?(_ERR_CH_CM_NO_MEMORY_):(_ERR_EN_CM_NO_MEMORY_);
		    	  kfree(s_user_name);
	          	  return 0;
	          	}
	          memcpy(en_pass,set_pass,strlen(set_pass));
          	  kfree(encrypt_passwd);
  	  	  one_user->user_role = user_role;
                  one_user->enable_passwd = en_pass;
                  kfree(s_user_name);
  	  	  return 1;
  	  	  
  	  	}
  	  else
  	  	{
           if (strcmp(s_user_name,_UM_DEFAULT_USER_NAME_) == 0)
  	          {
  	             *errmsg =(lan_type == 2)?(_ERR_CH_UM_CANT_NORMAL_DEFAULT_USER_):( _ERR_EN_UM_CANT_NORMAL_DEFAULT_USER_);
  	             kfree(s_user_name);
  	             return 0;  	          
  	         }
  	  	
  	  	  one_user->user_role = user_role;
  	  	  if (one_user->enable_passwd)
  	  	  	{
  	  	  	  kfree(one_user->enable_passwd);
  	  	  	}
  	  	  kfree(s_user_name);	
  	  	  return 1;

  	  	}
  	}

}


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

*****************************************************/
int um_get_login_pass(char *user_name, unsigned char **login_pass, char **errmsg,unsigned short lan_type)
{
  char *s_user_name;
  struct um_one_user *one_user;
  s_user_name = (char *)kstrtolower(user_name,_MM_MOD_UM_ID_);
  one_user = um_get_user_byname(s_user_name);
  if (!one_user)
  	{
  	  *errmsg = (lan_type == 2)?(_ERR_CH_UM_USER_DONOT_EXISTS_):(_ERR_EN_UM_USER_DONOT_EXISTS_);
  	  kfree(s_user_name);
  	  return 0;
  	}
  else
  	{
  	  *login_pass = one_user->login_passwd;
  	  kfree(s_user_name);
  	  return 1;
  	}
}



/**************************************************
set a user's login password
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_set_login_pass(char *user_name, unsigned char *pass, char **errmsg,unsigned short lan_type)
{
  struct um_one_user *one_user;
  unsigned char *newpass;
  int pass_len;
  char *s_user_name;
  unsigned char *set_pass;
  
  unsigned char *encrypt_passwd;


  if (!(um_check_pass_legal(pass,errmsg,0,lan_type)))
    {
  	  	  	  return 0;
    }



  s_user_name = (char *) kstrtolower(user_name,_MM_MOD_UM_ID_);



  one_user = um_get_user_byname(s_user_name);
  if (!one_user)
  	{
  	  *errmsg =(lan_type == 2)?(_ERR_CH_UM_USER_DONOT_EXISTS_):( _ERR_EN_UM_USER_DONOT_EXISTS_);
  	  kfree(s_user_name);
  	  return 0;
  	}
  else
  	{
	  if (one_user->login_passwd)
            kfree(one_user->login_passwd);

	  encrypt_passwd = um_encrypt_password(pass);

	  if (um_password_encrypt == 1)
	    {
	      set_pass = encrypt_passwd;
	    }
	  else
	    {
	      set_pass = pass;
	    }
      pass_len = strlen(set_pass);
      newpass = (unsigned char *)kmalloc((pass_len+1),_MM_MOD_UM_ID_);
      memset(newpass,0,(pass_len+1));
      if (!newpass)
      	{
      	  kfree(encrypt_passwd);
  	  *errmsg = (lan_type == 2)?(_ERR_CH_CM_NO_MEMORY_):(_ERR_EN_CM_NO_MEMORY_);
  	  kfree(s_user_name);
       	  return 0;
      	}
      strcpy(newpass,set_pass);
      kfree(encrypt_passwd);
      newpass[pass_len]='\0';
      one_user->login_passwd = newpass;
      kfree(s_user_name);
      return 1;  
  	}

}




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

*****************************************************/
int um_get_enable_pass(char *user_name,unsigned char **enable_pass,char **errmsg,unsigned short lan_type)
{
  struct um_one_user *one_user;
  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)
  	{
  	  *errmsg = (lan_type == 2)?(_ERR_CH_UM_USER_DONOT_EXISTS_):(_ERR_EN_UM_USER_DONOT_EXISTS_);
  	  kfree(s_user_name);
  	  return 0;
  	}
  else
  	{
  	  *enable_pass = one_user->enable_passwd;
  	  kfree(s_user_name);
  	  return 1;
  	}

}



/**************************************************
set a user's enable password
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_set_enable_pass(char *user_name,unsigned  char *pass, char **errmsg,unsigned short lan_type)
{
  struct um_one_user *one_user;
  unsigned char *newpass;
  int pass_len;
  unsigned char *set_pass;
  
  unsigned char *encrypt_passwd;
  char *s_user_name;

  s_user_name = (char *)kstrtolower(user_name,_MM_MOD_UM_ID_);

  if (!(um_check_pass_legal(pass,errmsg,1,lan_type)))
    {
  	  	  	  return 0;
    }



  one_user = um_get_user_byname(s_user_name);
  if (!one_user)
  	{
  	  *errmsg =(lan_type == 2)?(_ERR_CH_UM_USER_DONOT_EXISTS_):( _ERR_EN_UM_USER_DONOT_EXISTS_);
  	  kfree(s_user_name);
  	  return 0;
  	}
  else
  	{
  	  if (one_user->user_role == NORMAL_USER)
  	    {
      	      *errmsg =(lan_type == 2)?(_ERR_CH_UM_USER_NOT_ADMIN_):( _ERR_EN_UM_USER_NOT_ADMIN_);
  	      kfree(s_user_name);
  	      return 0;
  	      
  	    }
          if (one_user->enable_passwd)
          kfree(one_user->enable_passwd);

	  encrypt_passwd = um_encrypt_password(pass);

	  if (um_password_encrypt == 1)
	    {
	      set_pass = encrypt_passwd;
	    }
	  else
	    {
	      set_pass = pass;
	    }
          pass_len = strlen(set_pass);
          newpass = (unsigned char *)kmalloc((pass_len+1),_MM_MOD_UM_ID_);
          memset(newpass,0,(pass_len+1));
          if (!newpass)
      	    {
      	      kfree(encrypt_passwd);
              *errmsg = (lan_type == 2)?(_ERR_CH_CM_NO_MEMORY_):(_ERR_EN_CM_NO_MEMORY_);
              kfree(s_user_name);
       	      return 0;
      	    }
	      strcpy(newpass,set_pass);
  	      kfree(encrypt_passwd);
	      newpass[pass_len]='\0';
	      one_user->enable_passwd = newpass;
	      kfree(s_user_name);
	      return 1;  
  	}

}

       
/*********************************
Init user database struct return 1 if success 0 if failed 
***********************************/
int um_init_user_db(char **errmsg)
{
  unsigned short lan_type = 1;
  um_users = (struct um_user_list *)kmalloc( sizeof(struct um_user_list) ,_MM_MOD_UM_ID_);

  if (!um_users)
  	{
  	  *errmsg = (lan_type == 2)?(_ERR_CH_CM_NO_MEMORY_):(_ERR_EN_CM_NO_MEMORY_);
  	  return 0;
  	}  
  
  memset(um_users,0,sizeof(struct um_user_list));
  um_users->total_user_count = 0;  
  um_users->head = NULL;
  um_users->tail = NULL;
  return 1;

}


/*****************************************
check if there is at least one user in user db
if true , return 1
if false , try create default user , if success , return 1 , if failt return 0
*************************************/
int um_check_user_db(char **errmsg)
{
  int ret;
  if (um_users->total_user_count == 0) 
    {
       if (!( ret = um_add_user(_UM_DEFAULT_USER_NAME_,_UM_DEFAULT_LOGIN_PASS_,errmsg,1)))
       	  {
       	    return 0;
       	  }
       if (!(ret = um_set_user_role(_UM_DEFAULT_USER_NAME_,ADMIN_USER,_UM_DEFAULT_ENABLE_PASS_,errmsg,1)))
       	  {
       	    return 0;
       	  }
       return 1; 
    }
  return 1;
}

/*******************************************
  Init User Mange
********************************************/

int  um_main_init(void)
{
  char **errmsg;
  um_init_user_db(errmsg);

  return 1;

}


#endif

#ifdef _cplusplus
}
#endif