userdb.c

Linux下的飞鸽传书

  entry->host=host;
  entry->group=group;
  entry->nickname=nickname;
  entry->ipaddr=ipaddr;
  entry->cap=IPMSG_DIALUPOPT; /*  ダイアルアップとみなす  */
  dbg_out("OK entry:\nuser : %s\nhost :%s\ngroup : %s\nnickname : %s\nipaddr : %s\n",  
	  entry->user=user,
	  entry->host=host,
	  entry->group=group,
	  entry->nickname=nickname,
	  entry->ipaddr=ipaddr);

  rc=add_with_userdb_entry(entry);
  *entry_string_p += (ep - buffer);
  dbg_out("Return: %s (%d)\n",*entry_string_p,rc);
  if (buffer)
    g_free(buffer);
  return rc;

 free_group_out:
  if (group)
    g_free(group);
 free_nickname_out:
  if (nickname)
    g_free(nickname);
 free_ipaddr_out:
  if (ipaddr)
    g_free(ipaddr);
 free_host_out:
  if (host)
    g_free(host);
 free_user_out:
  if (user)
    g_free(user);
 free_buffer_out:
  if (buffer)
    g_free(buffer);
  return rc;
}
static int
hostlist_userinfo_add_with_answer(const char *message,int *next_count){
  int rc;
  int start,end;
  char *string;
  char *sp,*ep;
  long remains;
  int intval;
  size_t len;
  userdb_t *entry=NULL;
  size_t this_count;
  size_t remain_count;
  int is_last=0;

  if ( (!message) || (!next_count) ) 
    return -EINVAL;

  string=g_strdup(message);
  if (!string)
    return -ENOMEM;
  
  rc=-ENOENT;
  len=strlen(message);
  remains=len;
  this_count=0;
  *next_count=0;

  /*
   * start
   */
  sp=string;
  ep=memchr(sp, HOSTLIST_SEPARATOR, remains);
  if (!ep) 
    goto free_string_out;
  
  remains =len - ((unsigned long)ep-(unsigned long)sp);
  *ep='\0';
  start=strtol(sp, (char **)NULL, 10);
  if (start<0)
    goto free_string_out;
  ++ep;
  dbg_out("Start:%d\n",start);

  /*
   * total
   */
  sp=ep;
  ep=memchr(sp, HOSTLIST_SEPARATOR, remains);
  if (!ep)
    goto free_string_out;
  remains =len - ((unsigned long)ep-(unsigned long)sp);
  *ep='\0';
  end=strtol(sp, (char **)NULL, 10);
  if (end<0)
    goto free_string_out;
  ++ep;
  dbg_out("End:%d\n",end);

  if (end<start) 
    goto free_string_out;

  sp=ep;
  remains =len - ((unsigned long)ep-(unsigned long)sp);
  is_last=0;
  while ( (sp) && (!is_last) && (remains>0) ){
    dbg_out("Add %d th entry:%s\n",this_count+1,sp);
    rc=alloc_user_info(&entry);
    if (rc)
      goto free_string_out;
    rc=userdb_add_hostlist_entry(entry,(const char **)&sp,&is_last);
    if ( (rc) && (rc != -EEXIST) )
      goto free_string_out;  /*  エントリ不正時は追加処理側で開放する  */
    ++this_count;
    remains =len - ((unsigned long)ep-(unsigned long)sp);
  }

 free_string_out:
  g_free(string);


  if ( (this_count == 0) || (end < (this_count + start)) )
    *next_count=0;
  else
    *next_count=(start + this_count);
  dbg_out("Next count:%d (this,start,total)=(%d,%d,%d)\n",
	  *next_count,
	  this_count,
	  start,
	  end);

  return rc;
}
static int 
internal_refer_user_by_addr(const char *ipaddr,const userdb_t **entry_ref){
  int rc=-ESRCH;
  userdb_t srch_user;
  GList *found;

  if ( (!ipaddr) || (!entry_ref) )
    return -EINVAL;

  memset(&srch_user,0,sizeof(userdb_t));

  srch_user.ipaddr=(char *)ipaddr;

  found=g_list_find_custom (users,&srch_user,userdb_find_by_ipaddr);
  if (found) {
    g_assert(found->data);
    rc=0;
    *entry_ref=found->data;
  }

  return rc;
}
int
destroy_user_info(userdb_t *entry){
  int rc;

  if (!entry)
    return -EINVAL;

  rc=destroy_user_info_contents(entry);
  if (rc)
    return rc;

  memset(entry,0,sizeof(userdb_t));
  dbg_out("Free: %x\n",(unsigned int)entry);
  g_slice_free(userdb_t,entry);

  return 0;
}
int
userdb_hostlist_answer_add(const udp_con_t *con,const msg_data_t *msg){
  int next_count=0;
  int rc;
  gchar *internal_string=NULL;

  if ( (!con) || (!msg) )
    return -EINVAL;
  if (!(msg->message))
    return -EINVAL;

  dbg_out("Here\n");
  rc=convert_string_internal(msg->message,(const gchar **)&internal_string);
  if (rc < 0) {
    ipmsg_err_dialog(_("Can not convert message from %s into ineternal representation"), udp_get_peeraddr(con));
    return rc;
  }

  next_count=0;
  rc=hostlist_userinfo_add_with_answer(internal_string,&next_count);
  if ( (rc<0) && (rc != -EEXIST) ) 
    goto  free_string_out;

  if (next_count) {
    dbg_out("Send next:%d\n",next_count);
    rc=ipmsg_send_get_list(udp_con,udp_get_peeraddr(con),next_count);
  }
  if (rc<0)
    goto  free_string_out;

 free_string_out:
  if (internal_string)
    g_free(internal_string);
 error_out:
  return rc;
}
static gint 
userdb_sort_with_view_config(gconstpointer data_a,
			     gconstpointer data_b,
			     gpointer user_data){
  userdb_t *user_a=(userdb_t *)data_a;
  userdb_t *user_b=(userdb_t *)data_b;  
  gint rc;

  g_assert(user_a);
  g_assert(user_b);
 
  if (user_b->prio != user_a->prio)
    return (user_b->prio - user_a->prio);

  if ( (hostinfo_refer_ipmsg_is_sort_with_group()) &&
       ( (user_a->group) && (user_b->group) ) ) {
    rc=strcmp(user_a->group,user_b->group);
    if (rc) {
      if (hostinfo_refer_ipmsg_group_sort_order())
	return rc;
      else
	return -rc;
    }
  }
  rc=0;
  switch(hostinfo_refer_ipmsg_sub_sort_id()) {
  default:
    case SORT_TYPE_USER:
      if ((user_a->user) && (user_b->user))
	rc=strcmp(user_a->user,user_b->user);
      break;
    case SORT_TYPE_IPADDR:
      if ((user_a->ipaddr) && (user_b->ipaddr))
	rc=strcmp(user_a->ipaddr,user_b->ipaddr);
      break;
    case SORT_TYPE_MACHINE:
      if ((user_a->host) && (user_b->host))
	rc=strcmp(user_a->host,user_b->host);
      break;
  }

  if (!hostinfo_refer_ipmsg_sub_sort_order())
    return -rc;

  return rc;
}
int
update_users_on_message_window(GtkWidget *window,gboolean is_force){
  GtkWidget *view;
  GList *current_users;

  g_assert(window);

  view=lookup_widget(window,"messageUserTree");
  g_assert(view);
  dbg_out("Notify userdb change :%x\n",(unsigned int)window);
  g_static_mutex_lock(&userdb_mutex);
  current_users=g_list_copy(refer_user_list());
  if (current_users) {
    current_users=g_list_sort(current_users,(GCompareFunc)userdb_sort_with_view_config);
    update_user_entry(current_users,view,is_force);
    g_list_free(current_users);    
  }else{
    current_users=refer_user_list();
    update_user_entry(current_users,view,is_force);
  }
  g_static_mutex_unlock(&userdb_mutex);  

}
int
userdb_search_user(const char *user,const char *ipaddr,const userdb_t **entry_ref){
  int rc=-ESRCH;
  userdb_t srch_user;
  GList *found;

  if ( (!user) || (!ipaddr) || (!entry_ref) )
    return -EINVAL;

  memset(&srch_user,0,sizeof(userdb_t));

  srch_user.user=(char *)user;
  srch_user.ipaddr=(char *)ipaddr;

  g_static_mutex_lock(&userdb_mutex);  

  found=g_list_find_custom (users,&srch_user,userdb_find_element);
  if (found) {
    userdb_t *new_user;
    _assert(found->data);
    rc=-ENOMEM;
    if (alloc_user_info(&new_user)) 
      goto unlock_out;

    rc=copy_user_info(new_user,found->data);    
    if (rc<0) {
      destroy_user_info(new_user);
      goto  unlock_out;
    }
    *entry_ref=new_user;
  }
 unlock_out:
  g_static_mutex_unlock(&userdb_mutex);
  return rc;
}

int
userdb_search_user_by_addr(const char *ipaddr,const userdb_t **entry_ref){
  int rc=-ESRCH;
  userdb_t srch_user;
  userdb_t *user_p=NULL;
    userdb_t *new_user;

  if ( (!ipaddr) || (!entry_ref) )
    return -EINVAL;

  memset(&srch_user,0,sizeof(userdb_t));
  srch_user.ipaddr=(char *)ipaddr;

  g_static_mutex_lock(&userdb_mutex);  

  rc=alloc_user_info(&new_user);
  if (rc<0) 
    goto unlock_out;

  rc=internal_refer_user_by_addr(ipaddr,(const userdb_t **)&user_p);
  if (rc<0){
    destroy_user_info(new_user);
    goto unlock_out;
  }
  rc=copy_user_info(new_user,user_p);
  if (rc<0) {
    destroy_user_info(new_user);
    goto unlock_out;
  }
  rc=0;
  *entry_ref=new_user;

 unlock_out:
  g_static_mutex_unlock(&userdb_mutex);

  return rc;
}
void
userdb_print_user_list(void){
  g_list_foreach(users,
		 print_one_user_entry,
		 NULL);  
}
static gint 
userdb_find_group(gconstpointer a,gconstpointer b) {
  int rc=-EINVAL;

  if ( (!a) || (!b) ) 
    return -EINVAL;


  dbg_out("Pointer:0x%x 0x%x\n",a,b);
  return strcmp((char *)a,(char *)b);
}
GList *
get_group_list(void){
  GList *ret=NULL;
  GList *found;
  GList *node;
  userdb_t *ref;
  gchar *string;

  g_static_mutex_lock(&userdb_mutex);
  for(node=g_list_first(users);node;node=g_list_next(node)) {
    ref=node->data;
    
    found=g_list_find_custom (ret,ref->group,userdb_find_group);
    if (found)
      continue;
    string=g_strdup(ref->group);
    if (string)
      ret=g_list_append(ret,string);
  }
  g_static_mutex_unlock(&userdb_mutex);  

  return ret;
}
void
userdb_update_group_list(GtkComboBox *widget){
  if (!widget)
    return;

  g_list_foreach(users,
                 (GFunc)update_one_group_entry,
                 widget);
}
GList *
refer_user_list(void) {
  return users;
}
int 
userdb_add_user(const udp_con_t *con,const msg_data_t *msg){
  int rc=0;
  userdb_t *new_user;

  if ( (!con) || (!msg) )
    return -EINVAL;

  if (alloc_user_info(&new_user)) 
    return -ENOMEM;

  rc=fill_user_info_with_message(udp_get_peeraddr(con),msg,new_user);
  if (rc<0) {
    destroy_user_info(new_user);
    return rc;
  }
  rc=add_with_userdb_entry(new_user);

  return rc;
}
int 
userdb_update_user(const udp_con_t *con,const msg_data_t *msg){
  userdb_t new_user;
  userdb_t *old_user;
  userdb_t backup_user;
  GList *update_entry;
  GList *new_entry;
  int rc;

  if ( (!con) || (!msg) )
    return -EINVAL;


  memset(&new_user,0,sizeof(userdb_t));
  rc=fill_user_info_with_message(udp_get_peeraddr(con),msg,&new_user);
  if (rc<0) {
    return rc;
  }
  g_static_mutex_lock(&userdb_mutex);
  update_entry=g_list_find_custom(users,&new_user,userdb_find_element);
  if (!update_entry) {
    g_static_mutex_unlock(&userdb_mutex);
    destroy_user_info_contents(&new_user);
    return -ENOMEM;
  } else {
    /*
     * 旧来の情報を削除して新しい情報で更新
     */
    old_user=update_entry->data;
    
    memset(&backup_user,0,sizeof(userdb_t));
    rc=copy_user_info(&backup_user,old_user);
    if (rc<0) {
      destroy_user_info_contents(old_user);
      goto fill_error_out;
    }
    destroy_user_info_contents(old_user);    
    rc=fill_user_info_with_message(udp_get_peeraddr(con),msg,old_user);
    if (rc<0)
      goto fill_error_out;

    old_user->prio=backup_user.prio;
    destroy_user_info_contents(&backup_user);
    goto ok_out;

  fill_error_out:
    destroy_user_info_contents(&backup_user);
    destroy_user_info(old_user);
    users=g_list_remove_link(users,update_entry);
    g_list_free(update_entry);
    g_static_mutex_unlock(&userdb_mutex);
    return rc;
  }
 ok_out:
  /*
   * 健全性チェック
   */
  new_entry=g_list_find_custom(users,&new_user,userdb_find_element);
  g_assert(new_entry);
  g_assert(new_entry->data == old_user);
  destroy_user_info_contents(&new_user);
  g_static_mutex_unlock(&userdb_mutex);

  notify_userdb_changed();

  return 0;
}
int 
userdb_replace_prio_by_addr(const char *ipaddr,int prio,gboolean need_notify){
  int rc=-ESRCH;
  userdb_t srch_user;
  userdb_t *user_p=NULL;

  if  (!ipaddr)
    return -EINVAL;

  dbg_out("Here: ipaddr:%s prio:%d\n",ipaddr,prio);

  memset(&srch_user,0,sizeof(userdb_t));
  srch_user.ipaddr=(char *)ipaddr;

  g_static_mutex_lock(&userdb_mutex);  

  rc=internal_refer_user_by_addr(ipaddr,(const userdb_t **)&user_p);
  if (rc<0)
    goto unlock_out;

  user_p->prio=prio;
  rc=hostinfo_update_ipmsg_ipaddr_prio(ipaddr,prio);

 unlock_out:
  g_static_mutex_unlock(&userdb_mutex);
  if (need_notify)
    notify_userdb_changed();
  return rc;
}
void
update_all_user_list_view(void){
  notify_userdb_changed();
}
int 
userdb_del_user(const udp_con_t *con,const msg_data_t *msg){
  GList *del_entry;
  userdb_t del_user;