static User *
add_new_user_for_pwent (Daemon *daemon,
struct passwd *pwent)
{
User *user;
user = user_new (daemon, pwent->pw_uid);
user_update_from_pwent (user, pwent);
user_register (user);
g_hash_table_insert (daemon->priv->users,
g_strdup (user_get_user_name (user)),
user);
accounts_accounts_emit_user_added (ACCOUNTS_ACCOUNTS (daemon), user_get_object_path (user));
return user;
}
user *beforechat(SSL **ssl)
{
user *ret;
char choice[20];
SSL *s = *ssl;
bzero(choice,sizeof(choice));
while(1)
{
SSL_read(s,choice,20);
if(strcmp("LOGIN",choice) == 0)
if((ret = login(s)) != NULL)
return ret;
if(strcmp("REGISTER",choice) == 0)
if((ret = user_register(s)) != NULL)
return ret;
}
return NULL;
}
extern "C" void handle_register(const char* request,char* feedback){
Json::Value feedback_root;
char username[32],password[32],real_name[32];
get_user(request,username,password,real_name);
int user_exist = user_check_exist(username);
if (user_exist)
{
feedback_root["result"] = "fail";
feedback_root["message"] = "username exists!";
strcpy(feedback,feedback_root.toStyledString().c_str());
} else
{
user_register(username, password, real_name);
feedback_root["result"] = "pass";
feedback_root["message"] = "register success!";
strcpy(feedback,feedback_root.toStyledString().c_str());
}
}
static void* handleThread(int *fd)
{
int sockfd;
char buff[MAXSIZE];
int rwsize;
USER usermsg;
sockfd = *fd;
rwsize = epoll_read(sockfd, buff, MAXSIZE);
//printf("receve:%s\n", buff);
//epoll_write(sockfd, buff);
memcpy(&usermsg, buff, sizeof(buff));
usermsg.From_sockfd = sockfd;
switch(usermsg.MsgType)
{
/*登陆*/
case 1:
user_login(&usermsg);
memcpy(buff, &usermsg, sizeof(usermsg));
epoll_write(sockfd, buff);
break;
/*注册*/
case 2:
user_register(&usermsg);
memcpy(buff, &usermsg, sizeof(usermsg));
epoll_write(sockfd, buff);
break;
/*找回密码*/
case 3:
break;
}
return (void*)0;
}
void process(int cmd, int connfd, std::vector<std::string> &tokens){
// std::unique_lock<std::mutex> lck(mtx1);
switch(cmd){
case 1:{
msg_all(connfd);
break;
}
case 2:{
msg_flw(connfd, tokens);
break;
}
case 3:{
login(connfd, tokens);
break;
}
case 4:{
user_register(connfd, tokens);
break;
}
case 5:{
compose(connfd, tokens);
break;
}
case 6:{
follow(connfd, tokens);
break;
}
case 7:{
unfollow(connfd, tokens);
break;
}
default:{
write(connfd, "error", 5);
break;
}
}
}
void loop_process(int cfd) {
DEBUG(" Child=======> In child!\n");
int acceptfd;
int recved;
fd_set readfds;
int delay = 300;
struct timeval timeout;
timeout.tv_sec = 10;
timeout.tv_usec = 0;
struct sockaddr_in client_addr;
socklen_t sock_len = sizeof(struct sockaddr);
char buffer[512];
ctl_hdr *hdr;
uint16 ret_code = 0;
//服务器对web服务器的回复报文
struct replay_packet replay;
replay.head.len = 2;
replay.head.encrpyt = ENCRPYT_NO;
replay.head.mo = MO_SERVER;
replay.head.ttl = 0;
replay.head.ki = KI_REPLAY;
while (1) {
DEBUG(" Child=======> Waiting for connect! In child thread!\n");
FD_ZERO(&readfds);
FD_SET(cfd, &readfds);
timeout.tv_sec = delay;
timeout.tv_usec = 0;
int tt;
switch(tt = select(cfd + 1, &readfds, NULL, NULL, &timeout)) {
case -1:
//error
continue;
break;
default:
if (FD_ISSET(cfd, &readfds)) {
acceptfd = accept(cfd,(struct sockaddr *) &client_addr, &sock_len);
if (acceptfd <=0) {
DEBUG(" Child=======> accept failed!\n");
exit(-1);
}
recved = recv(acceptfd, buffer, sizeof(buffer), 0);
DEBUG(" Child=======> Listen socket: %d\tAccept socket: %d\n", cfd, acceptfd);
struct common_packet * common = (struct common_packet *)buffer;
DEBUG(" Child=======> Received KI: %d\n", common->head.ki);
DEBUG(" Child=======> Received data length: %d\n", recved);
if (recved > 0) {
hdr = (ctl_hdr *)buffer;
//如果是登录请求
if (hdr->ki == KI_LOGIN) {
//判断用户名和密码是否正确
struct register_struct * user_struct = (struct register_struct *)buffer;
if (user_check(&(user_struct->user_struct)) == 0) {
//登录成功
replay.data = RPL_LOGIN_SUCCESS;
replay.head.extent = 111;
writen(acceptfd, (void *)&replay, sizeof(replay));
DEBUG(" Child=======> Login successful!\n");
tcp_close(acceptfd);
} else {
replay.data = RPL_LOGIN_FALLED;
writen(acceptfd, (void *)&replay, sizeof(replay));
DEBUG(" Child=======> Login failed!\n");
tcp_close(acceptfd);
}
} else if (hdr->ki == KI_REGISTER) {
//用户注册
struct register_struct * user_struct = (struct register_struct *)buffer;
if (user_register(&(user_struct->user_struct)) == 0) {
//注册成功
replay.data = RPL_REGISTER_SUCCESS;
writen(acceptfd, (void *)&replay, sizeof(replay));
DEBUG("Register User Successful\n");
tcp_close(acceptfd);
} else {
replay.data = RPL_REGISTER_FALLED;
writen(acceptfd, (void *)&replay, sizeof(replay));
DEBUG("Register User Failed\n");
tcp_close(acceptfd);
}
//如果是发送的数据包，判断extent值，看是否已登录成功
} else {
hdr = (ctl_hdr *)buffer;
DEBUG(" Child=======> extent is : %d\tttl is : %d\n", hdr->extent, hdr->ttl);
if ((hdr->extent) == 111) {
ret_code = proc_packet(buffer, acceptfd);
if (ret_code == RPL_NO_COMMON_REPLAY) {
} else {
replay.data = ret_code;
writen(acceptfd, (void *)&replay, sizeof(replay));
}
tcp_close(acceptfd);
}
}
}
}
break;
}
tcp_close(acceptfd);
DEBUG(" Child=======> tt is %d\n", tt);
}
}
static void
reload_users (Daemon *daemon)
{
GHashTable *users;
GHashTable *old_users;
GHashTable *local;
GHashTableIter iter;
gpointer name;
User *user;
/* Track the users that we saw during our (re)load */
users = create_users_hash_table ();
/*
* NOTE: As we load data from all the sources, notifies are
* frozen in load_entries() and then thawed as we process
* them below.
*/
/* Load the local users into our hash table */
load_entries (daemon, users, entry_generator_fgetpwent);
local = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_iter_init (&iter, users);
while (g_hash_table_iter_next (&iter, &name, NULL))
g_hash_table_add (local, name);
/* Now add/update users from other sources, possibly non-local */
load_entries (daemon, users, wtmp_helper_entry_generator);
load_entries (daemon, users, entry_generator_cachedir);
/* Mark which users are local, which are not */
g_hash_table_iter_init (&iter, users);
while (g_hash_table_iter_next (&iter, &name, (gpointer *)&user))
user_update_local_account_property (user, g_hash_table_lookup (local, name) != NULL);
g_hash_table_destroy (local);
/* Swap out the users */
old_users = daemon->priv->users;
daemon->priv->users = users;
/* Remove all the old users */
g_hash_table_iter_init (&iter, old_users);
while (g_hash_table_iter_next (&iter, &name, (gpointer *)&user)) {
if (!g_hash_table_lookup (users, name)) {
user_unregister (user);
accounts_accounts_emit_user_deleted (ACCOUNTS_ACCOUNTS (daemon),
user_get_object_path (user));
}
}
/* Register all the new users */
g_hash_table_iter_init (&iter, users);
while (g_hash_table_iter_next (&iter, &name, (gpointer *)&user)) {
if (!g_hash_table_lookup (old_users, name)) {
user_register (user);
accounts_accounts_emit_user_added (ACCOUNTS_ACCOUNTS (daemon),
user_get_object_path (user));
}
g_object_thaw_notify (G_OBJECT (user));
}
g_hash_table_destroy (old_users);
}
