userdb.c

linux下的飞鸽传书 日本人设计 使用非常方便

  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)
    return rc;

  next_count=0;
  rc=hostlist_userinfo_add_with_answer(internal_string,&next_count);
  g_free(internal_string);
  if ( (rc<0) && (rc != -EEXIST) )
    return rc;
  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)
    return rc;

  return 0;
}
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=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) 
      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);
  _assert(new_entry);
  _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;
  userdb_t *del_user_p;
  int rc;

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

  memset(&del_user,0,sizeof(userdb_t));
  rc=convert_string_internal(refer_user_name_from_msg(msg),(const gchar **)&(del_user.user));
  if (rc)
    return rc;

  rc=convert_string_internal(refer_host_name_from_msg(msg),(const gchar **)&(del_user.host));
  if (rc)
    return rc;

  rc=convert_string_internal(udp_get_peeraddr(con),(const gchar **)&(del_user.ipaddr));
  if (rc)
    goto free_user_out;

  dbg_out("del user start\n");
  g_static_mutex_lock(&userdb_mutex);
  del_entry=g_list_find_custom(users,&del_user,userdb_find_element);
  if (!del_entry) {
    rc=-ESRCH;
    dbg_out("No such entry:%s@%s\n",del_user.user,del_user.ipaddr);
    g_static_mutex_unlock(&userdb_mutex);
    goto free_out;
  } 
  del_user_p=del_entry->data;
  dbg_out("Free: %x\n",(unsigned int)del_user_p);
  destroy_user_info(del_user_p);
  users=g_list_remove_link(users,del_entry);
  g_list_free(del_entry);
  g_static_mutex_unlock(&userdb_mutex);

  notify_userdb_changed();

  rc=0;

 free_out:
  dbg_out("del user end\n");
  g_free(del_user.ipaddr);
 free_user_out:
  g_free(del_user.user);
  
  return rc;
}

int
userdb_get_hostlist_string(int start, int *length, const char **ret_string,unsigned long *flags) {
  int index;
  unsigned int last;
  unsigned int total;
  int rc;
  GList *node;
  size_t str_size=0;
  size_t len=0;
  userdb_t *data;
  char tmp_buff[IPMSG_BUFSIZ];
  unsigned long command;
  char *string;
  size_t remain_len;
  int count;
  int start_no;

  rc=-EINVAL;
  if ( (start<0) || (!length) || ((*length) < 0) || (!ret_string) || (!flags) )
    return rc;

  g_static_mutex_lock(&userdb_mutex);
  last=start + (*length);
  total=g_list_length(users);
  rc=-ENOENT;
  if (!total)
    goto unlock_out;
  --total;
  if ( total < (last) ) 
    last=total;
  
  memset(tmp_buff,0,IPMSG_BUFSIZ);
  snprintf(tmp_buff,IPMSG_BUFSIZ-1,"%5d%c%5d%c",start,HOSTLIST_SEPARATOR,total,HOSTLIST_SEPARATOR);
  str_size=strlen(tmp_buff)+1;

  /*
   *start:length:ユーザ名:ホスト名:コマンド番号:IP アドレス:
   *ポート番号（リトルエンディアン）:ニックネーム:グループ名
   */
  /* length チェック  */
  for(index=start,count=0;
      ( (data=(userdb_t *)g_list_nth_data(users,index)) && (index<=last) );
      ++index){
    memset(tmp_buff,0,IPMSG_BUFSIZ);
    snprintf(tmp_buff,IPMSG_BUFSIZ-1,"%s%c%s%c%d%c%s%c%d%c%s%c%s%c",
	     (data->user)?(data->user):(HOSTLIST_DUMMY),
	     HOSTLIST_SEPARATOR,
	     (data->host)?(data->host):(HOSTLIST_DUMMY),
	     HOSTLIST_SEPARATOR,
	     IPMSG_ANSLIST,
	     HOSTLIST_SEPARATOR,
	     (data->ipaddr)?(data->ipaddr):(HOSTLIST_DUMMY),
	     HOSTLIST_SEPARATOR,
	     hostinfo_refer_ipmsg_port(),
	     HOSTLIST_SEPARATOR,
	     (data->nickname)?(data->nickname):(HOSTLIST_DUMMY),
	     HOSTLIST_SEPARATOR,
	     (data->group)?(data->group):(HOSTLIST_DUMMY),
	     HOSTLIST_SEPARATOR);
    len=strlen(tmp_buff);
    if ( (len + str_size) > (_MSG_BUF_MIN_SIZE / 2) ) {
      last=index;
    }
    str_size += len+1;
    ++count;
  }
  rc=-ENOMEM;
  string=malloc(str_size+1);
  if (!string)
    goto unlock_out;

  /*
   * 作成
   */
  memset(string,0,str_size+1);
  if (count)
    --count;
  start_no=((start+count)==total)?(0):start+count; /* 0は終端を示す  */
  snprintf(string,IPMSG_BUFSIZ-1,"%5d%c%5d%c",start_no,HOSTLIST_SEPARATOR,total,HOSTLIST_SEPARATOR);
  dbg_out("Create from %d to %d\n",start,last);
  for(index=start,remain_len=(str_size-strlen(string));
      index<=last;
      ++index){
    data=(userdb_t *)g_list_nth_data(users,index);
    memset(tmp_buff,0,IPMSG_BUFSIZ);
    snprintf(tmp_buff,IPMSG_BUFSIZ-1,"%s%c%s%c%d%c%s%c%d%c%s%c%s%c",
	     (data->user)?(data->user):(HOSTLIST_DUMMY),
	     HOSTLIST_SEPARATOR,
	     (data->host)?(data->host):(HOSTLIST_DUMMY),
	     HOSTLIST_SEPARATOR,
	     IPMSG_ANSLIST,
	     HOSTLIST_SEPARATOR,
	     (data->ipaddr)?(data->ipaddr):(HOSTLIST_DUMMY),
	     HOSTLIST_SEPARATOR,
	     hostinfo_refer_ipmsg_port(),
	     HOSTLIST_SEPARATOR,
	     (data->nickname)?(data->nickname):(HOSTLIST_DUMMY),
	     HOSTLIST_SEPARATOR,
	     (data->group)?(data->group):(HOSTLIST_DUMMY),
	     HOSTLIST_SEPARATOR);
    len=strlen(tmp_buff);
    g_assert(len<=(remain_len-1));
    dbg_out("%d th :%s\n",index,tmp_buff);
    strncat(string,tmp_buff,remain_len);
    remain_len -= len;
  }
  
  len=strlen(string);
  if (string[len-1]==HOSTLIST_SEPARATOR)
    string[len-1]='\0';
  dbg_out("String:%s\n",string);
  rc=0;
  *length=last-start;
  *ret_string=string;
 unlock_out:
  g_static_mutex_unlock(&userdb_mutex);
  
  return rc;
}
int 
userdb_invalidate_userdb(void){
  GList *node;
  userdb_t *del_user;
  GList *new_list=NULL;

  dbg_out("Here\n");

  g_static_mutex_lock(&userdb_mutex);
  for(node=g_list_first(users);node;node=g_list_next (node)) {
    g_assert(node->data);
    del_user=(userdb_t *)node->data;
    /*  Dial Up hostは残留組となる
     *  (可達確認がブロードキャストでできないので)
     */
    if ( del_user->cap & IPMSG_DIALUPOPT) 
      new_list=g_list_append(new_list,del_user); 
    else
      destroy_user_info(del_user);
  }
  g_list_free (users);
  users=new_list;
  g_static_mutex_unlock(&userdb_mutex);

  return 0;
}
int 
userdb_send_broad_cast(const udp_con_t *con,const char *msg,size_t len) {
  GList *node;
  userdb_t *the_user;

  dbg_out("Here\n");

  g_static_mutex_lock(&userdb_mutex);
  for(node=g_list_first(users);node;node=g_list_next (node)) {
    g_assert(node->data);
    the_user=(userdb_t *)node->data;
    dbg_out("Check host:%s\n",the_user->ipaddr);
    if (the_user->cap & IPMSG_DIALUPOPT) {
      if (!the_user->ipaddr) {
	dbg_out("dialup host does not have ipaddr, ignored\n");
	print_one_user_entry((gpointer)the_user,NULL);
      }else{
	dbg_out("%s is dialup host\n",the_user->ipaddr);
	udp_send_broadcast_with_addr(con,the_user->ipaddr,msg,len);
      }
    }
  }
  g_static_mutex_unlock(&userdb_mutex);

  return 0;
}
int
userdb_add_waiter_window(GtkWidget *window){
  if (!window)
    return -EINVAL;

  dbg_out("here %x\n",(unsigned int)window);

  g_static_mutex_lock(&win_mutex);
  waiter_windows=g_list_append(waiter_windows,(gpointer)window);
  g_static_mutex_unlock(&win_mutex);

  return 0;
}
int
userdb_remove_waiter_window(GtkWidget *window){
  if (!window)
    return -EINVAL;

  dbg_out("here %x\n",(unsigned int)window);

  g_static_mutex_lock(&win_mutex);
  waiter_windows=g_list_remove(waiter_windows,(gpointer)window);
  g_static_mutex_unlock(&win_mutex);

  return 0;
}
int
userdb_init_userdb(void){
  users=NULL;
  return 0;
}