protocol.c

Linux下的飞鸽传书

  char *msg=NULL;
  size_t len;
  int rc;
  unsigned long local_flags = flags;

  local_flags |= IPMSG_ANSENTRY;

  if (hostinfo_is_ipmsg_absent()) 
    local_flags |= IPMSG_ABSENCEOPT;

  memset(base,0,IPMSG_BUFSIZ);
  memset(ext,0,IPMSG_BUFSIZ);

  snprintf(base,IPMSG_BUFSIZ-1,MSG_STRING,ipmsg_get_pkt_no(),hostinfo_refer_user_name(),hostinfo_refer_host_name(),local_flags,hostinfo_refer_nick_name_proto());

  snprintf(ext,IPMSG_BUFSIZ-1,"%s",hostinfo_refer_group_name_proto());
  if (hostinfo_is_ipmsg_absent()) {
    char *absent_title=NULL;
    gchar *absent_title_proto=NULL;
    int index;

    if (!hostinfo_get_absent_id(&index)) {
      hostinfo_get_absent_title(index,(const char **)&absent_title);
      g_assert (absent_title);
      convert_string_ipmsg_proto(absent_title,(const gchar **)&absent_title_proto);
      g_free(absent_title);
      g_assert (absent_title_proto);
      if (absent_title_proto) {
	snprintf(ext,IPMSG_BUFSIZ-1,"%s[%s]",hostinfo_refer_group_name_proto(),absent_title_proto);
	g_free (absent_title_proto);
      }
    }
  }

  rc = construct_message(base,ext,&msg,&len);
  if (rc<0)
    return rc;

  dbg_out("AnserEntry:%s\n",msg);

  udp_send_message(con, ipaddr, hostinfo_refer_ipmsg_port(), msg, len);

  g_free(msg);

  return 0;
}

int
ipmsg_send_gratuitous_ans_entry(const udp_con_t *con, const char *ipaddr, const int flags){
  int rc = 0;

  if ( (con == NULL) || (ipaddr == NULL) )
    return -EINVAL;

  /*  無条件に送りつけるANS_ENTRYなので, flagsは呼び出し側責任で設定する.
   *  これは, 暗号化通信のキャンセルなどで使用する.
   */

  dbg_out("Send gratutous ANS_ENTRY to %s with 0x%08x\n",
	  ipaddr, flags);

  rc = ipmsg_send_ans_entry_common(con, ipaddr, flags);

  return rc;
}

int
ipmsg_send_ans_entry(const udp_con_t *con,const int flags){
  char base[IPMSG_BUFSIZ];
  char ext[IPMSG_BUFSIZ];
  char *msg=NULL;
  size_t len;
  int rc;
  unsigned long local_flags;

  local_flags  = flags;
  local_flags |= hostinfo_get_normal_entry_flags();

  /*
   * 応答用ANS_ENTRYを返す.
   */
  rc = ipmsg_send_ans_entry_common(con, udp_get_peeraddr(con), local_flags);

  return rc;
}
int
ipmsg_send_recv_msg(const udp_con_t *con,const msg_data_t *orig_msg){
  char base[IPMSG_BUFSIZ];
  char *msg=NULL;
  size_t len;
  int rc;

  memset(base,0,IPMSG_BUFSIZ);

  snprintf(base,IPMSG_BUFSIZ-1,MSG_STRING_RECVMSG,ipmsg_get_pkt_no(),hostinfo_refer_user_name(),hostinfo_refer_host_name(),(IPMSG_RECVMSG|IPMSG_AUTORETOPT),refer_pkt_no_name_from_msg(orig_msg));

  rc=construct_message(base,NULL,&msg,&len);
  if (rc<0)
    return rc;
  udp_send_peer(con,msg,len);
  g_free(msg);

  return 0;
}
int
ipmsg_send_release_files(const udp_con_t *con,const char *ipaddr,int pktno){
  char base[IPMSG_BUFSIZ];
  char *msg=NULL;
  size_t len;
  int rc;

  memset(base,0,IPMSG_BUFSIZ);

  snprintf(base,IPMSG_BUFSIZ-1,MSG_STRING_RECVMSG,ipmsg_get_pkt_no(),hostinfo_refer_user_name(),hostinfo_refer_host_name(),IPMSG_RELEASEFILES,pktno);

  rc=construct_message(base,NULL,&msg,&len);
  if (rc<0)
    return rc;
  rc=udp_send_message(con,ipaddr,hostinfo_refer_ipmsg_port(),msg,len);
  g_free(msg);

  if (rc<0)
    return rc;

  return 0;
}

int
ipmsg_send_get_list(const udp_con_t *con,const char *ipaddr,int index){
  char base[IPMSG_BUFSIZ];
  char *msg=NULL;
  size_t len;
  int rc;

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

  memset(base,0,IPMSG_BUFSIZ);

  snprintf(base,IPMSG_BUFSIZ-1,MSG_STRING_RECVMSG,ipmsg_get_pkt_no(),hostinfo_refer_user_name(),hostinfo_refer_host_name(),IPMSG_GETLIST,index);

  rc=construct_message(base,NULL,&msg,&len);
  if (rc<0)
    return rc;
  rc=udp_send_message(con,ipaddr,hostinfo_refer_ipmsg_port(),msg,len);
  g_free(msg);

  if (rc<0)
    return rc;

  return 0;
}

int
ipmsg_send_read_msg(const udp_con_t *con,const char *ipaddr,int pktno){
  char base[IPMSG_BUFSIZ];
  char *msg=NULL;
  size_t len;
  int rc;

  memset(base,0,IPMSG_BUFSIZ);

  snprintf(base,IPMSG_BUFSIZ-1,MSG_STRING_RECVMSG,ipmsg_get_pkt_no(),hostinfo_refer_user_name(),hostinfo_refer_host_name(),IPMSG_READMSG,pktno);

  rc=construct_message(base,NULL,&msg,&len);
  if (rc<0)
    return rc;
  rc=udp_send_message(con,ipaddr,hostinfo_refer_ipmsg_port(),msg,len);
  g_free(msg);

  if (rc<0)
    return rc;

  return 0;
}

int
ipmsg_send_get_info_msg(const udp_con_t *con,const char *ipaddr,unsigned long command){
  char base[IPMSG_BUFSIZ];
  char *send_string=NULL;
  size_t len;
  int rc;

  if ( (!con) || (!ipaddr) || ( (command != IPMSG_GETINFO) && (command != IPMSG_GETABSENCEINFO) ) )
    return -EINVAL;

  memset(base,0,IPMSG_BUFSIZ);

  snprintf(base,IPMSG_BUFSIZ-1,MSG_GETINFO_STRING,ipmsg_get_pkt_no(),hostinfo_refer_user_name(),hostinfo_refer_host_name(),command);

  rc=construct_message(base,NULL,&send_string,&len);
  if (rc<0)
    return rc;

  rc=udp_send_message(con,ipaddr,hostinfo_refer_ipmsg_port(),send_string,len);
  g_free(send_string);

  if (rc<0)
    return rc;

  return 0;
}
int
ipmsg_send_getpubkey(const udp_con_t *con,const char *ipaddr){
  int rc;
  char *message=NULL;
  char base[IPMSG_BUFSIZ];
  char *send_string=NULL;
  size_t len;

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

#if defined(USE_OPENSSL)
  memset(base,0,IPMSG_BUFSIZ);

  rc=pcrypt_crypt_generate_getpubkey_string(hostinfo_get_ipmsg_crypt_capability(),(const char **)&message);
  if (rc)
    return rc;

  snprintf(base,IPMSG_BUFSIZ-1,MSG_STRING,ipmsg_get_pkt_no(),hostinfo_refer_user_name(),hostinfo_refer_host_name(),IPMSG_GETPUBKEY,message);

  rc=construct_message(base,NULL,&send_string,&len);
  if (rc<0)
    goto free_message_out;

  rc=udp_send_message(con,ipaddr,hostinfo_refer_ipmsg_port(),send_string,len);
  g_free(send_string);

  if (rc<0)
    goto free_message_out;

  rc=0;

 free_message_out:
  if (message)
    g_free(message);
#else
  rc=-ENOSYS;
#endif  /*   USE_OPENSSL  */
  return rc;
}
int
ipmsg_send_send_msg(const udp_con_t *con,const char *ipaddr,int flags,int pkt_no,const char *message,const char *ext_part){
  int rc;
  size_t len;
  char *send_string=NULL;
  char *sent_message=NULL;
  size_t sent_msg_len;
  gchar *internal_message=NULL;
  unsigned long peer_cap=0;

  if ( (!con) || (!ipaddr) || (!message) )
    return -EINVAL;

  if ( (flags & IPMSG_FILEATTACHOPT) && (!ext_part) )
    return -EINVAL;

#if defined(USE_OPENSSL)
  if (flags & IPMSG_ENCRYPTOPT) {
    rc=userdb_get_basic_cap_by_addr(ipaddr,&peer_cap);
    if ( (rc) || (!(peer_cap & IPMSG_ENCRYPTOPT)) ) {
      dbg_out("Peer can not handle crypted message.rc=%d cap=%x\n",rc,peer_cap);
      flags &= ~IPMSG_ENCRYPTOPT;
      sent_message=(char *)message;
    }else{
      dbg_out("Peer's cap=%x\n",peer_cap);
      rc=ipmsg_encrypt_message(ipaddr,message,(unsigned char **)&sent_message,&sent_msg_len);
      if (rc) {
	dbg_out("Peer can not encode the message.rc=%d\n",rc);
	flags &= ~IPMSG_ENCRYPTOPT;
	sent_message=(char *)message;
      }else{
	dbg_out("Encoded message.%s\n",sent_message);
      }
    }
  }
#else
  flags &= ~IPMSG_ENCRYPTOPT;
  sent_message=(char *)message;
#endif  /*  USE_OPENSSL  */

  if (flags & IPMSG_FILEATTACHOPT)
    rc=ipmsg_construct_file_attach_message(sent_message,ext_part,flags,&len,&send_string,pkt_no);
  else
    rc=ipmsg_construct_normal_message(sent_message,flags,&len,&send_string,pkt_no);

#if !defined(USE_OPENSSL)
  g_assert(!(flags & IPMSG_ENCRYPTOPT));
#endif  /*  USE_OPENSSL  */

  if (flags & IPMSG_ENCRYPTOPT) {
    g_assert(sent_message);
    g_free(sent_message);
  }

  if (rc<0){
    if (send_string)
      g_free(send_string);
    return rc;
  }

  dbg_out("send message to %s:%s\n",ipaddr,send_string);
  rc=register_sent_message(con,ipaddr,pkt_no,send_string,len);
  if (rc<0) {
    rc *= -1;
    ipmsg_err_dialog(_("Can not register message for:%s reason: %s error code = %d"), ipaddr, strerror(rc), rc);
    return -rc;
  }

  rc=udp_send_message(con,ipaddr,hostinfo_refer_ipmsg_port(), send_string,len);
  if (rc<0) {
    rc*=-1;
    ipmsg_err_dialog(_("Can not send message to %s. reason: %s error code = %d"), ipaddr, strerror(rc), rc);
    goto error_out;
  }

  convert_string_internal(message,(const gchar **)&internal_message);
  if (internal_message) {
    logfile_send_log(ipaddr, internal_message);
    g_free(internal_message);
  } else {
    ipmsg_err_dialog(_("Can not convert message for %s into ineternal representation"), ipaddr);
  }

  rc=0;
 error_out:
  g_free(send_string);
  return rc;
}
int
ipmsg_proc_br_absence(const udp_con_t *con,const msg_data_t *msg){
  dbg_out("\nNew user: \n\tUser:%s Host: %s\n\tNickName: %s GroupName:%s\n",
	  refer_user_name_from_msg(msg),
	  refer_host_name_from_msg(msg),
	  refer_nick_name_from_msg(msg),
	  refer_group_name_from_msg(msg));

  userdb_update_user(con,msg);
  userdb_print_user_list();

  return 0;
}
int
ipmsg_proc_br_entry(const udp_con_t *con,const msg_data_t *msg) {
  int rc=0;

  ipmsg_send_ans_entry(con,0);

  rc=userdb_add_user(con,msg);
  if (rc == -EEXIST)
    rc=userdb_update_user(con,msg);
  userdb_print_user_list();

  return rc;
}
int
ipmsg_proc_br_exit(const udp_con_t *con,const msg_data_t *msg) {
  dbg_out("\nLeave user: \n\tUser:%s Host: %s\n\tNickName: %s GroupName:%s\n",
	  refer_user_name_from_msg(msg),
	  refer_host_name_from_msg(msg),
	  refer_nick_name_from_msg(msg),
	  refer_group_name_from_msg(msg));
  userdb_del_user(con,msg);
  userdb_print_user_list();

  return 0;
}

int
ipmsg_proc_ans_entry(const udp_con_t *con,const msg_data_t *msg) {
  dbg_out("\nNew user: \n\tUser:%s Host: %s\n\tNickName: %s GroupName:%s\n",
	  refer_user_name_from_msg(msg),
	  refer_host_name_from_msg(msg),
	  refer_nick_name_from_msg(msg),
	  refer_group_name_from_msg(msg));
  userdb_add_user(con,msg);
  userdb_print_user_list();

  return 0;
}

int
ipmsg_proc_send_msg(const udp_con_t *con,const msg_data_t *msg) {
  gchar *internal_message=NULL;
  int flags;

  if ( (msg->command_opts & IPMSG_SENDCHECKOPT) && 
       (!(msg->command_opts & IPMSG_NO_REPLY_OPTS)) ) {
    dbg_out("Send check opt is enabled\n");
    ipmsg_send_recv_msg(con,msg);
  }
  dbg_out("\nmessage:\n%s\n",msg->message);

  convert_string_internal(msg->message,(const gchar **)&internal_message);
  if (internal_message) {
    if (!(msg->command_opts & IPMSG_NOLOGOPT))
      logfile_recv_log(udp_get_peeraddr(con),internal_message);
    g_free(internal_message);
  } else {
    ipmsg_err_dialog(_("Can not convert message from %s into ineternal representation"), udp_get_peeraddr(con));
  }

  if (hostinfo_is_ipmsg_absent()){
    flags=hostinfo_get_normal_send_flags();
    if (hostinfo_refer_ipmsg_default_secret())
      flags |= IPMSG_SECRETOPT;
    if (!(msg->command_opts & IPMSG_NO_REPLY_OPTS))
      ipmsg_send_absent_msg(con,flags);
  }

  if (hostinfo_refer_ipmsg_default_popup()) /* if it is set, should not pop-up the win */
    store_message_window(msg,udp_get_peeraddr(con));
  else
    recv_message_window(msg,udp_get_peeraddr(con));

  return 0;
}
int
ipmsg_proc_read_msg(const udp_con_t *con,const msg_data_t *msg) {
  long pktno;
  gchar *user;
  struct timeval tv;

  gettimeofday(&tv, NULL);
  pktno=strtol(msg->message, (char **)NULL, 10);
  dbg_out("read mssage:seq %ld\n",pkt_no);

  dbg_out("read mssage:seq %s\n",msg->message);
  user=g_strdup(refer_user_name_from_msg(msg));
  /*  メモリ不足の場合はNULLを送信。処理は受け手で考える  */
  read_message_dialog(user,udp_get_peeraddr(con),tv.tv_sec);