hostinfo.c

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

  return gconf_client_get_bool(client,HOSTINFO_KEY_LOG_IPADDR,NULL);
}
gboolean
hostinfo_set_ipmsg_ipaddr_logging(gboolean val) {

  gconf_client_clear_cache(client);
  return gconf_client_set_bool(client,HOSTINFO_KEY_LOG_IPADDR,val,NULL);
}

gboolean
hostinfo_refer_ipmsg_logname_logging(void) {

  return gconf_client_get_bool(client,HOSTINFO_KEY_LOG_NAME,NULL);
}
gboolean
hostinfo_set_ipmsg_logname_logging(gboolean val) {

  gconf_client_clear_cache(client);
  return gconf_client_set_bool(client,HOSTINFO_KEY_LOG_NAME,val,NULL);
}

gboolean
hostinfo_refer_ipmsg_enable_log(void) {

  return gconf_client_get_bool(client,HOSTINFO_KEY_ENABLE_LOG,NULL);
}

gboolean
hostinfo_set_ipmsg_enable_log(gboolean val) {

  gconf_client_clear_cache(client);
  return gconf_client_set_bool(client,HOSTINFO_KEY_ENABLE_LOG,val,NULL);
}

gboolean
hostinfo_refer_ipmsg_ipv6_mode(void) {

  return gconf_client_get_bool(client,HOSTINFO_KEY_IPV6,NULL);
}
gboolean
hostinfo_set_ipmsg_ipv6_mode(gboolean val) {

  return gconf_client_set_bool(client,HOSTINFO_KEY_IPV6,val,NULL);
}

gboolean
hostinfo_refer_ipmsg_is_get_hlist(void) {

  return gconf_client_get_bool(client,HOSTINFO_KEY_GET_HLIST,NULL);
}
gboolean
hostinfo_set_ipmsg_is_get_hlist(gboolean val) {

  gconf_client_clear_cache(client);
  return gconf_client_set_bool(client,HOSTINFO_KEY_GET_HLIST,val,NULL);
}

gboolean
hostinfo_refer_ipmsg_is_allow_hlist(void) {

  return gconf_client_get_bool(client,HOSTINFO_KEY_ALLOW_HLIST,NULL);
}
gboolean
hostinfo_set_ipmsg_is_allow_hlist(gboolean val) {

  gconf_client_clear_cache(client);
  return gconf_client_set_bool(client,HOSTINFO_KEY_ALLOW_HLIST,val,NULL);
}

gboolean
hostinfo_refer_ipmsg_dialup_mode(void) {

  return gconf_client_get_bool(client,HOSTINFO_KEY_DIALUP,NULL);
}
gboolean
hostinfo_set_ipmsg_dialup_mode(gboolean val) {

  gconf_client_clear_cache(client);
  return gconf_client_set_bool(client,HOSTINFO_KEY_DIALUP,val,NULL);
}
gboolean
hostinfo_refer_ipmsg_is_sort_with_group(void) {

  return gconf_client_get_bool(client,HOSTINFO_KEY_SORT_GROUP,NULL);
}
gboolean
hostinfo_set_ipmsg_sort_with_group(gboolean val) {

  gconf_client_clear_cache(client);
  return gconf_client_set_bool(client,HOSTINFO_KEY_SORT_GROUP,val,NULL);
}

gint
hostinfo_refer_ipmsg_sub_sort_id(void) {

  return gconf_client_get_int(client,HOSTINFO_KEY_SUB_SORT_ID,NULL);
}
gboolean
hostinfo_set_ipmsg_sub_sort_id(gint val) {

  gconf_client_clear_cache(client);
  return gconf_client_set_int(client,HOSTINFO_KEY_SUB_SORT_ID,val,NULL);
}
gboolean
hostinfo_refer_ipmsg_group_sort_order(void) {

  return !(gconf_client_get_bool(client,HOSTINFO_KEY_SORT_GROUP_DESCENDING,NULL));
}
gboolean
hostinfo_set_ipmsg_group_sort_order(gboolean val) {

  gconf_client_clear_cache(client);
  return gconf_client_set_bool(client,HOSTINFO_KEY_SORT_GROUP_DESCENDING,(!(val)),NULL);
}
gboolean
hostinfo_refer_ipmsg_sub_sort_order(void) {

  return !(gconf_client_get_bool(client,HOSTINFO_KEY_SUB_SORT_DESCENDING,NULL));
}
gboolean
hostinfo_set_ipmsg_sub_sort_order(gboolean val) {

  gconf_client_clear_cache(client);
  return gconf_client_set_bool(client,HOSTINFO_KEY_SUB_SORT_DESCENDING,(!(val)),NULL);
}

int 
hostinfo_set_ipmsg_logfile(const char *file) {
  gchar *string;
  int rc;

  if (!file)
    return -EINVAL;

  rc=logfile_reopen_logfile(file);
  if (rc)
    return rc;

  g_static_mutex_lock(&hostinfo_mutex);  

  if (logfile_string)
    g_free(logfile_string);

  logfile_string=NULL;

  gconf_client_set_string(client,HOSTINFO_KEY_LOGFILEPATH,file,NULL);

  string=gconf_client_get_string(client,HOSTINFO_KEY_LOGFILEPATH,NULL);
  if (string) {
    dbg_out("gconf return logfile %s\n",string);
    g_static_mutex_unlock(&hostinfo_mutex);  
    logfile_string=string;
    gconf_client_clear_cache(client);
    return 0;
  }
  g_static_mutex_unlock(&hostinfo_mutex);  
  return -ENOMEM;
}
const char *
hostinfo_refer_ipmsg_logfile(void) {
  char *string;

  g_static_mutex_lock(&hostinfo_mutex);  
  if (logfile_string)
    goto unlock_out;

  string=gconf_client_get_string(client,HOSTINFO_KEY_LOGFILEPATH,NULL);

  if (string) {
    dbg_out("gconf return logfile %s\n",string);
    g_static_mutex_unlock(&hostinfo_mutex);  
    logfile_string=string;
  }  
 unlock_out:
  g_static_mutex_unlock(&hostinfo_mutex);  
  return (logfile_string)?(logfile_string):("");
}

const char *
hostinfo_refer_ipmsg_cite_string(void) {
  char *string;

  if (cite_string)
    return cite_string;

  g_static_mutex_lock(&hostinfo_mutex);
  string=gconf_client_get_string(client,HOSTINFO_KEY_CITE_STRING,NULL);

  if (string) {
    dbg_out("gconf return cite string:%s\n",string);
    cite_string=string;
    g_static_mutex_unlock(&hostinfo_mutex);  
    return (const char *)cite_string;
  }
  g_static_mutex_unlock(&hostinfo_mutex);  
  return ">";
}
int
hostinfo_refer_ipmsg_port(void){
  int port;

  g_static_mutex_lock(&hostinfo_mutex);  
  port=gconf_client_get_int(client,HOSTINFO_KEY_PORT,NULL);
  dbg_out("gconf return port:%d\n",port);
  g_static_mutex_unlock(&hostinfo_mutex);  
  if (!port) 
    return DEFAULT_PORT;
  
  return port;
}
int
hostinfo_set_ipmsg_port(int port){
  int new;

  g_static_mutex_lock(&hostinfo_mutex);  
  gconf_client_set_int(client,HOSTINFO_KEY_PORT,port,NULL);
  gconf_client_clear_cache(client);
  new=gconf_client_get_int(client,HOSTINFO_KEY_PORT,NULL);
  dbg_out("gconf return port:%d\n",new);
  g_static_mutex_unlock(&hostinfo_mutex);  
  if (!new)
    return DEFAULT_PORT;

  return port;
}

const char *
hostinfo_refer_user_name(void) {
  struct passwd *ref_p;

  g_static_mutex_lock(&hostinfo_mutex);  
  ref_p=getpwuid(getuid());

  if (!ref_p) {
    err_out("Can not get pwent:%s (%d)\n",strerror(errno),errno);
    g_static_mutex_unlock(&hostinfo_mutex);  
    return _("UnKnown");
  }
  dbg_out("UserName:%s\n",ref_p->pw_name);
  g_static_mutex_unlock(&hostinfo_mutex);  
  return ref_p->pw_name;
}

const char *
hostinfo_refer_group_name(void) {

  g_static_mutex_lock(&hostinfo_mutex);  
  if (!groupname) {
    groupname=gconf_client_get_string(client,HOSTINFO_KEY_GROUP,NULL);
    dbg_out("gconf return groupname:%s\n",groupname);
  }
  g_static_mutex_unlock(&hostinfo_mutex);  
  return (groupname)?(groupname):(_("Default Group"));
}
int
hostinfo_set_group_name(const char *groupName) {

  if (!groupName)
    return -EINVAL;

  dbg_out("set groupname:%s\n",groupName);

  g_static_mutex_lock(&hostinfo_mutex);  
  if (groupname)
    g_free(groupname);

  if (groupname_proto)
    g_free(groupname_proto);

  g_assert(client);

  gconf_client_set_string(client,HOSTINFO_KEY_GROUP,groupName,NULL);
  gconf_client_clear_cache(client);
  groupname=gconf_client_get_string(client,HOSTINFO_KEY_GROUP,NULL);
  dbg_out("gconf return groupname:%s\n",groupname);
  convert_string_ipmsg_proto(groupname,(const gchar **)&groupname_proto);
  g_static_mutex_unlock(&hostinfo_mutex);  
  return 0;
}

int
hostinfo_set_nick_name(const char *nickName) {

  if (!nickName)
    return -EINVAL;

  g_static_mutex_lock(&hostinfo_mutex);  
  dbg_out("set nickName:%s\n",nickName);

  g_assert(client);

  if (nickname)
    g_free(nickname);
  if (nickname_proto)
    g_free(nickname_proto);

  gconf_client_set_string(client,HOSTINFO_KEY_NICKNAME,nickName,NULL);
  gconf_client_clear_cache(client);
  nickname=gconf_client_get_string(client,HOSTINFO_KEY_NICKNAME,NULL);
  dbg_out("gconf return nick name:%s\n",nickname);
  convert_string_ipmsg_proto(nickname,(const gchar **)&nickname_proto);
  g_static_mutex_unlock(&hostinfo_mutex);  
  return 0;
}

const char *
hostinfo_refer_group_name_proto(void) {
  char *internal_name;

  g_static_mutex_lock(&hostinfo_mutex);  
  if (!groupname_proto) {
    internal_name=gconf_client_get_string(client,HOSTINFO_KEY_GROUP,NULL);
    convert_string_ipmsg_proto(internal_name,(const gchar **)&groupname_proto);
    dbg_out("gconf return groupname:%s\n",groupname_proto);
    g_free(internal_name);
  }
  g_static_mutex_unlock(&hostinfo_mutex);  

  return groupname_proto;
}

const char *
hostinfo_refer_nick_name(void) {

  g_static_mutex_lock(&hostinfo_mutex);  
  if (!nickname) {
    nickname=gconf_client_get_string(client,HOSTINFO_KEY_NICKNAME,NULL);
    dbg_out("gconf return nick name:%s\n",nickname);
    if (!nickname_proto)
      convert_string_ipmsg_proto(nickname,(const gchar **)&nickname_proto);
  }
  g_static_mutex_unlock(&hostinfo_mutex);  
  return (nickname)?(nickname):(_("Default Nick Name"));
}

const char *
hostinfo_refer_nick_name_proto(void) {
  gchar *internal_name;

  g_static_mutex_lock(&hostinfo_mutex);  
  if (!nickname_proto) {
    internal_name=gconf_client_get_string(client,HOSTINFO_KEY_NICKNAME,NULL);
    convert_string_ipmsg_proto(internal_name,(const gchar **)&nickname_proto);
    g_free(internal_name);
    dbg_out("gconf return nickname:%s\n",nickname_proto);
  }
  g_static_mutex_unlock(&hostinfo_mutex);  
  return nickname_proto;
}

const char *
hostinfo_refer_host_name(void){

  if (hostname)
    goto ret;

  g_static_mutex_lock(&hostinfo_mutex);  
  hostname=malloc(64);

  if (gethostname(hostname,64) < 0) {
    free(hostname);
    hostname=NULL;
    g_static_mutex_unlock(&hostinfo_mutex);  
    return _("UnKnown");
  }
  hostname[63]=0;
  g_static_mutex_unlock(&hostinfo_mutex);  
 ret:
  return hostname;
}


static void
hostinfo_gconf_notify_func(GConfClient *client, guint cnxn_id, GConfEntry  *entry,
			   gpointer user_data){
  dbg_out("Configuration is changed: key=%s\n",(char *)user_data);
}
unsigned long 
hostinfo_get_normal_send_flags(void){
  unsigned long flags=0;

  g_static_mutex_lock(&hostinfo_mutex);  
  flags=IPMSG_SENDCHECKOPT; /* 受信確認をデフォルト  */

  if (gconf_client_get_bool(client,HOSTINFO_KEY_MSGSEC,NULL))
    flags|=IPMSG_SECRETOPT;

  if (gconf_client_get_bool(client,HOSTINFO_KEY_CONFIRM_MSG,NULL))
    flags|=IPMSG_SENDCHECKOPT;

  dbg_out("gconf return flags:%x\n",flags);
  g_static_mutex_unlock(&hostinfo_mutex);  
  return flags;
}
unsigned long 
hostinfo_get_normal_entry_flags(void){
  unsigned long flags=G2IPMSG_DEFAULT_ENTRY_FLAGS;

  g_static_mutex_lock(&hostinfo_mutex);  
  if (hostinfo_refer_ipmsg_dialup_mode())
    flags |= IPMSG_DIALUPOPT;

  if (hostinfo_is_ipmsg_absent())
    flags |= IPMSG_ABSENCEOPT;

  dbg_out("gconf return flags:%x\n",flags);
  g_static_mutex_unlock(&hostinfo_mutex);  
  return flags;
}
static int 
hostinfo_get_ipmsg_window_size(const gchar *wkey,const gchar *hkey,gint *width,gint *height){

  dbg_out("here\n");

  if ( (!wkey) || (!hkey) ||  (!width) || (!height) )
    return -EINVAL;

  g_static_mutex_lock(&hostinfo_mutex);
  *width=gconf_client_get_int(client,wkey,NULL);
  *height=gconf_client_get_int(client,hkey,NULL);
  g_static_mutex_unlock(&hostinfo_mutex);

  dbg_out("gconf return size:(%s,%s)=(%d,%d)\n",wkey,hkey,*width,*height);

  return 0;
}
static int 
hostinfo_set_ipmsg_window_size(const gchar *wkey,const gchar *hkey,gint width,gint height){
  int rwidth,rheight;

  dbg_out("here\n");