userdb.c

Linux下的飞鸽传书

  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 != 0) {
    ipmsg_err_dialog(_("Can not convert message from %s into ineternal representation"), udp_get_peeraddr(con));
    return rc;
  }

  rc = convert_string_internal(refer_host_name_from_msg(msg), (const gchar **)&(del_user.host));
  if (rc != 0) {
    ipmsg_err_dialog(_("Can not convert message from %s into ineternal representation"), udp_get_peeraddr(con));
    return rc;
  }
  rc = convert_string_internal(udp_get_peeraddr(con),(const gchar **)&(del_user.ipaddr));
  if (rc != 0) {
    ipmsg_err_dialog(_("Can not convert message from %s into ineternal representation"), udp_get_peeraddr(con));
    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 = g_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_replace_public_key_by_addr(const char *ipaddr,const unsigned long peer_cap,const char *key_e,const char *key_n){
  int rc=-ESRCH;
  userdb_t srch_user;
  userdb_t *user_p=NULL;
  gchar *n_str=NULL,*e_str=NULL;

  if ( (!ipaddr) || (!key_e) || (!key_n) )
    return -EINVAL;

  dbg_out("Here: ipaddr:%s key_e:%s key_n: %s\n",ipaddr,key_e,key_n);

  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 error_out;

  rc=-ENOMEM;
  e_str=g_strdup(key_e);
  if (!e_str)
    goto error_out;
  n_str=g_strdup(key_n);
  if (!n_str)
    goto free_e_out;
  
  if (user_p->pub_key_e)
    g_free(user_p->pub_key_e);
  if (user_p->pub_key_n)
    g_free(user_p->pub_key_n);

  user_p->crypt_cap=peer_cap;
  user_p->pub_key_e=e_str;
  user_p->pub_key_n=n_str;
  dbg_out("Register: ipaddr:%s cap:0x%x key_e:%s key_n:%s\n",
	  ipaddr,
	  user_p->crypt_cap,
	  user_p->pub_key_e,
	  user_p->pub_key_n);

 unlock_out:
  g_static_mutex_unlock(&userdb_mutex);

  return 0;

 free_n_out:
  if (n_str)
    g_free(n_str);
 free_e_out:
  if (e_str)
    g_free(e_str);
 error_out:
  g_static_mutex_unlock(&userdb_mutex);
  return rc;
}
int 
userdb_get_public_key_by_addr(const char *peer_addr,unsigned long *cap_p,char **key_e,char **key_n){
  int rc=-ESRCH;
  int i;
  userdb_t srch_user;
  userdb_t *user_p=NULL;
  char *ret_key_buff_e=NULL;
  char *ret_key_buff_n=NULL;
  GTimeVal tmout;
  gboolean status;

  if ( (!peer_addr) || (!key_e) || (!key_n) || (!cap_p) )
    return -EINVAL;

  dbg_out("Get public key: ipaddr:%s\n",peer_addr);

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

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

  dbg_out("ipaddr found:%s\n",peer_addr);
  print_one_user_entry(user_p,NULL);
  if ((user_p->crypt_cap) &&
      (user_p->pub_key_e) &&
      (user_p->pub_key_n) ) {

    rc=-ENOMEM;
    ret_key_buff_e=g_strdup(user_p->pub_key_e);
    if (!ret_key_buff_e)
      goto unlock_out;
    ret_key_buff_n=g_strdup(user_p->pub_key_n);
    if (!ret_key_buff_n)
      goto free_key_e_out;

    *key_e=ret_key_buff_e;
    *key_n=ret_key_buff_n;
    *cap_p=user_p->crypt_cap;
    dbg_out("Return :%x e=%s n=%s\n",*cap_p,*key_e,*key_n);
    rc=0;
  }else{
    dbg_out("No encrypt cap %x e=%s n=%s\n",
	    user_p->crypt_cap,
	    (user_p->pub_key_e) ? (user_p->pub_key_e) : ("NONE"),
	    (user_p->pub_key_n) ? (user_p->pub_key_n) : ("NONE"));
    rc=-ENOENT;
  }

 unlock_out:
  g_static_mutex_unlock(&userdb_mutex);
 nolock_out:
  return rc;

 free_key_n_out:
  if (ret_key_buff_n)
    g_free(ret_key_buff_n);
 free_key_e_out:
  if (ret_key_buff_e)
    g_free(ret_key_buff_e);

  return rc;
}
int 
userdb_get_crypt_cap_by_addr(const char *ipaddr,unsigned long *cap_p){
  int rc=-ESRCH;
  userdb_t srch_user;
  userdb_t *user_p=NULL;
  gchar *n_str=NULL,*e_str=NULL;

  if ( (!ipaddr) || (!cap_p) )
    return -EINVAL;
  
  dbg_out("Here: ipaddr:%s \n",ipaddr);

  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 error_out;
  rc=-ENOENT;
  if (!(user_p->crypt_cap))
    goto error_out;

  *cap_p=user_p->crypt_cap;

  dbg_out("Return cap:%s = %x\n", ipaddr, *cap_p);
 unlock_out:
  g_static_mutex_unlock(&userdb_mutex);

  return 0;

 free_n_out:
  if (n_str)
    g_free(n_str);
 free_e_out:
  if (e_str)
    g_free(e_str);
 error_out:
  g_static_mutex_unlock(&userdb_mutex);
  return rc;
}
int 
userdb_get_basic_cap_by_addr(const char *ipaddr,unsigned long *cap_p){
  int rc=-ESRCH;
  userdb_t srch_user;
  userdb_t *user_p=NULL;
  gchar *n_str=NULL,*e_str=NULL;

  if ( (!ipaddr) || (!cap_p) )
    return -EINVAL;
  
  dbg_out("Here: ipaddr:%s \n",ipaddr);

  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 error_out;
  rc=-ENOENT;

  *cap_p=user_p->cap;

  dbg_out("Return cap:%s = %x\n", ipaddr, *cap_p);
 unlock_out:
  g_static_mutex_unlock(&userdb_mutex);

  return 0;

 free_n_out:
  if (n_str)
    g_free(n_str);
 free_e_out:
  if (e_str)
    g_free(e_str);
 error_out:
  g_static_mutex_unlock(&userdb_mutex);
  return rc;
}

int
userdb_wait_public_key(const char *peer_addr,unsigned long *cap_p,char **key_e,char **key_n){
  int rc=-ESRCH;
  int i;
  userdb_t srch_user;
  userdb_t *user_p=NULL;
  GTimeVal tmout;
  gboolean status;
  GTimer *wait_timer=NULL;
  gulong elapsed;

  if ( (!peer_addr) || (!key_e) || (!key_n) || (!cap_p) )
    return -EINVAL;

  dbg_out("Wait public key: ipaddr:%s\n",peer_addr);

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


  rc=userdb_get_public_key_by_addr(peer_addr,cap_p,(char **)key_e,(char **)key_n);
  if (!rc) 
    goto out;

  rc=ipmsg_send_getpubkey(udp_con,peer_addr);
  if (rc)
    goto out;

  wait_timer=g_timer_new();  
  if (!wait_timer)
    goto out;

  for(i=0;i<PUBKEY_MAX_RETRY;++i) {
    for(elapsed=0;elapsed<PUBKEY_WAIT_MICRO_SEC;g_timer_elapsed(wait_timer,&elapsed)) {
      ipmsg_update_ui(); /* udpパケットを処理  */
      rc=userdb_get_public_key_by_addr(peer_addr,cap_p,(char **)key_e,(char **)key_n);
      if (!rc)  /* 見付けた */
	goto free_timer_out;
    }
    /*
     * ある程度待っても更新されなければ,鍵要求送信を再度投げる
     */
    rc=ipmsg_send_getpubkey(udp_con,peer_addr);
    if (rc)
      goto free_timer_out;
    g_timer_start(wait_timer);
  }

 free_timer_out:
  g_assert(wait_timer);
  g_timer_destroy(wait_timer);
 out:
  return rc;
}

int
userdb_init_userdb(void){
  users=NULL;

  return 0;
}
int 
userdb_cleanup_userdb(void){

}