userdb.c

飞鸽传书的linux源代码

    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,&sp,&is_last);
    if ( (rc) && (rc != -EEXIST) )
      goto free_string_out;  /*  エントリ不正時は追加処理側で開放する  */
    ++this_count;
    remains =len - ((unsigned long)ep-(unsigned long)sp);
  }

 free_string_out:
  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;
}
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,&internal_string);
  if (rc<0)
    return rc;

  next_count=0;
  rc=hostlist_userinfo_add_with_answer(internal_string,&next_count);
  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;
}
int
update_users_on_message_window(GtkWidget *window){
  GtkWidget *view;
  GList *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);
  users=refer_user_list();
  update_user_entry(users,view);
  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=0;
    copy_user_info(new_user,found->data);    
    *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;
  GList *found;

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

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

  srch_user.ipaddr=(char *)ipaddr;

  g_static_mutex_lock(&userdb_mutex);  
  found=g_list_find_custom (users,&srch_user,userdb_find_by_ipaddr);
  if (found) {
    userdb_t *new_user;
    _assert(found->data);

    rc=-ENOMEM;
    if (alloc_user_info(&new_user)) 
      goto unlock_out;
    rc=0;
    copy_user_info(new_user,found->data);
    *entry_ref=new_user;
  }
 unlock_out:
  g_static_mutex_unlock(&userdb_mutex);
  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;
}
void
userdb_print_user_list(void){
  g_list_foreach(users,
		 print_one_user_entry,
		 NULL);  
}
void
userdb_update_group_list(GtkComboBox *widget){
  if (!widget)
    return;

  g_list_foreach(users,
		 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)
    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;
  GList *update_entry;
  GList *new_entry;
  int rc;

  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)
    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(new_user);
    return -ENOMEM;
  } else {
    /*
     * 旧来の情報を削除して新しい情報を追加
     */
    old_user=update_entry->data;
    g_free(old_user->ipaddr);
    g_free(old_user->nickname);
    g_free(old_user->group);
    g_free(old_user->host);
    g_free(old_user->user);
    dbg_out("Free: %x\n",(unsigned int)old_user);
    g_slice_free(userdb_t,old_user);
    users=g_list_remove_link(users,update_entry);
    g_list_free(update_entry);
    users=g_list_append(users,new_user);
  }

  /*
   * 健全性チェック
   */
  new_entry=g_list_find_custom(users,new_user,userdb_find_element);
  _assert(new_entry);
  _assert(new_entry->data == new_user);
  g_static_mutex_unlock(&userdb_mutex);

  notify_userdb_changed();

  return 0;
}
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;
  g_free(del_user_p->ipaddr);
  g_free(del_user_p->nickname);
  g_free(del_user_p->group);
  g_free(del_user_p->host);
  g_free(del_user_p->user);
  dbg_out("Free: %x\n",(unsigned int)del_user_p);
  g_slice_free(userdb_t,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;
}