callbacks.c

飞鸽传书的linux源代码

  attachment_editor =  (GtkWidget*) g_object_get_data (G_OBJECT (mainwindow),
						      "attach_win");
  g_assert(attachment_editor);
  g_object_set_data (G_OBJECT (attachment_editor),
		     "main_win",
		     NULL);
  g_object_set_data (G_OBJECT (mainwindow),
		     "attach_win",
		     NULL);
  attachment_editor =  (GtkWidget*) g_object_get_data (G_OBJECT (mainwindow),
						      "attach_win");
  g_assert(!attachment_editor);
}


void
on_attachFileEditor_show               (GtkWidget       *widget,
                                        gpointer         user_data)
{
  GtkWidget *attachment_editor;
  GtkWidget *add_btn;
  GtkWidget *remove_btn;
  GtkWidget *view;
  GtkWidget *entry;
  GtkTreeSelection *sel;
  GtkTreeModel     *model;
  GtkTreeIter  selected_row;
  size_t size;
  time_t mtime;
  int type;
  int rc;
  gchar *filepath;

  dbg_out("here\n");

  /*
   * setup button/entry
   */
  attachment_editor=lookup_widget(widget,"attachFileEditor");
  g_assert(attachment_editor);

  add_btn=lookup_widget(GTK_WIDGET(attachment_editor),"AttachFIleAddBtn");
  g_assert(add_btn);
  remove_btn=lookup_widget(GTK_WIDGET(attachment_editor),"AttachFileRemoveBtn");
  g_assert(remove_btn);
  entry=lookup_widget(GTK_WIDGET(attachment_editor),"AttachFilePathEntry");
  g_assert(entry);

  filepath=(char *)gtk_entry_get_text(GTK_ENTRY(entry));
  rc=get_file_info(filepath,&size,&mtime,&type);
  if ( (rc) || (type != IPMSG_FILE_REGULAR) )
    gtk_widget_set_sensitive(add_btn,FALSE);
  else
    gtk_widget_set_sensitive(add_btn,TRUE);

  view=lookup_widget(GTK_WIDGET(attachment_editor),"attachedFilesView");
  g_assert(GTK_TREE_VIEW(view));

  sel=gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
  g_assert(gtk_tree_selection_get_mode(sel) == GTK_SELECTION_SINGLE);

  if (gtk_tree_selection_get_selected(sel, &model, &selected_row))
    gtk_widget_set_sensitive(remove_btn,TRUE);
  else
    gtk_widget_set_sensitive(remove_btn,FALSE);
}



void
on_AttachFIleAddBtn_clicked            (GtkButton       *button,
                                        gpointer         user_data)
{
  GtkWidget *parent_window;
  GtkWidget *file_entry;
  char *filename;

  dbg_out("here\n");

  parent_window=lookup_widget(GTK_WIDGET(button),"attachFileEditor");
  file_entry=lookup_widget(GTK_WIDGET(button),"AttachFilePathEntry");
  filename=(char *)gtk_entry_get_text(GTK_ENTRY(file_entry)); 

  on_add_new_file(filename,parent_window,TRUE);
}


void
on_AttachFileRemoveBtn_clicked         (GtkButton       *button,
                                        gpointer         user_data)
{
  GtkTreeIter  selected_row;
  GtkWidget    *view;
  GtkTreeSelection *sel;
  GtkTreeModel *model;
  GtkWidget    *remove_btn;
  GtkWidget    *file_entry;

  dbg_out("here\n");

  view=lookup_widget(GTK_WIDGET(button),"attachedFilesView");
  g_assert(view);
  remove_btn=lookup_widget(GTK_WIDGET(button),"AttachFileRemoveBtn");
  g_assert(remove_btn);  
  sel=gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
  g_assert(sel);  
  file_entry=lookup_widget(GTK_WIDGET(button),"AttachFilePathEntry");
  g_assert(file_entry);
  g_assert(gtk_tree_selection_get_mode(sel) == GTK_SELECTION_SINGLE);

  if (gtk_tree_selection_get_selected(sel, &model, &selected_row))
    {
      gchar *tree_path;

      gtk_tree_model_get (model, &selected_row, 
                          0, &tree_path,
                          -1);
      dbg_out("Selected: %s\n",tree_path);
      gtk_entry_set_text(GTK_ENTRY(file_entry), tree_path);       
      g_free(tree_path);
      gtk_list_store_remove(GTK_LIST_STORE(model), &selected_row);
      gtk_widget_set_sensitive(remove_btn, FALSE);
    }
}

static int 
on_attach_window_drag_data_received(GtkWidget *widget,GtkSelectionData *data){
  GtkWidget *attachment_editor;
  int rc;

  if (!data)
    return -EINVAL;

  dbg_out("here:data %s\n",(char *)data->data);  


  attachment_editor=lookup_widget(widget,"attachFileEditor");
  g_assert(attachment_editor);

  gtk_widget_show(attachment_editor);

  rc=handle_attachment_drag_data(data,attachment_editor);
  if (rc<0)
    err_out("Can not handle drag data %s (%d)\n",strerror(-rc),-rc);

  return rc;
}

void
on_attachedFilesView_drag_data_received
                                        (GtkWidget       *widget,
                                        GdkDragContext  *drag_context,
                                        gint             x,
                                        gint             y,
                                        GtkSelectionData *data,
                                        guint            info,
                                        guint            time,
                                        gpointer         user_data)
{
  int rc;

  dbg_out("here\n");

  if (!data)
    return;

  rc=on_attach_window_drag_data_received(widget,data);

  if (rc<0)
    err_out("Can not handle drag data %s (%d)\n",strerror(-rc),-rc);

  return;
}

static int
download_file_ok_operation(const char *file,const char *filepath,size_t size,const char *dir){
  GtkWidget *dialog=create_DownloadConfirmDialog();
  GtkWidget *file_label;
  GtkWidget *size_label;
  char buff[1024];
  gint result;
  gchar *url;
  gchar *utf8_fname;
  int rc=-EINVAL;

  if ( (!file) || (!filepath) || (!dir) )
    return -EINVAL;

  dbg_out("Post down load opetation filepath:%s dir:%s\n",filepath,dir);
  g_assert(dialog);
  file_label=GTK_WIDGET(lookup_widget(dialog,"DownLoadCompleteFileLabel"));
  size_label=GTK_WIDGET(lookup_widget(dialog,"DownLoadConfirmFileSizeLabel"));
  g_assert(file_label);
  g_assert(size_label);

  buff[1023]='\0';
  snprintf(buff,1023,"%s : %s",_("Downloaded File"),file);
  gtk_label_set_text(GTK_LABEL(file_label),buff);

  snprintf(buff,1023,"%s : %d (%d KB)",_("Downloaded Size"),size,(size/1024));
  gtk_label_set_text(GTK_LABEL(size_label),buff);
  result=gtk_dialog_run (GTK_DIALOG (dialog));

  switch (result) {
  case GTK_RESPONSE_OK:
    dbg_out("Accept for directory\n");
    url=gnome_vfs_get_uri_from_local_path(dir);
    break;
  case GTK_RESPONSE_ACCEPT:
    dbg_out("Accept for exec\n");
    url=gnome_vfs_get_uri_from_local_path(filepath);
    break;
  case GTK_RESPONSE_CLOSE:
  default:
    dbg_out("response:%d close\n",result);
    gtk_widget_destroy (dialog);
    rc=-ENOENT;
    goto no_free_out;
    break;
  }
  gtk_widget_destroy (dialog);

  rc=gnome_vfs_url_show(url);
  if ( rc != GNOME_VFS_OK)
    rc=-rc;
  else
    rc=0;

 free_url:
  g_free(url);
 no_free_out:
  return rc;
}
static int
download_file_failed_operation(const char *filepath,const char *basename){
  GtkWidget *dialog=create_downLoadFailDialog ();
  GtkWidget *flabel;
  gint result;
  int rc;

  if (!dialog) {
    err_out("Can not create dialog\n");
    return -ENOMEM;
  }
  flabel=lookup_widget(dialog,"downLoadFailFileLabel");
  g_assert(flabel);
  if (basename)
    gtk_label_set_text(GTK_LABEL(flabel),basename);
  else
    gtk_label_set_text(GTK_LABEL(flabel),_("UnKnown"));

  rc=0;
  result=gtk_dialog_run (GTK_DIALOG (dialog));

  switch (result) {
  case GTK_RESPONSE_OK:
    dbg_out("response:%d ok\n",result);
    rc=-EAGAIN;
    break;
  case GTK_RESPONSE_CANCEL:
  default:
    dbg_out("response:%d cancel\n",result);
    if (filepath) {
    dbg_out("remove:%s\n",filepath);
      unlink(filepath);
    }
    break;
  }
  gtk_widget_destroy (dialog);

  return rc;
}
static int
post_download_operation(int code,const char *filepath,size_t size,size_t all_size,const char *dir){
  int rc;
  char *file;
  
  if ( (!filepath) || (!dir) )
    return -EINVAL;

  file=g_path_get_basename(filepath);
  if (!file)
    return -ENOMEM;

  if ( (!code) && (size == all_size) ) {
    rc=download_file_ok_operation(file,filepath,size,dir);
  }  else 
    if (rc != -EFAULT)
      rc=download_file_failed_operation(filepath,file);

  g_free(file);

  return rc;
}

static int
do_download(GtkTreeModel *model,
	       GtkTreePath *path,
	       GtkTreeIter *iter,
	       gpointer data){
  int rc;
  tcp_con_t con;
  int fd;
  GtkWidget *window;
  GtkWidget *entry;
  ipmsg_recvmsg_private_t *sender_info;
  ipmsg_private_data_t *priv;
  long pkt_no;
  int fileid;
  char buff[_MSG_BUF_SIZE];
  ssize_t recv_len;
  ssize_t len;
  ssize_t soc_remains;
  ssize_t write_len;
  size_t total_write;
  size_t total_read;
  size_t file_remains;
  char filepath[PATH_MAX];
  char *filename;
  char *dirname;
  char *req_message=NULL;
  int is_retry;
  int wait_max=TCP_DOWNLOAD_RETRY;

  window=GTK_WIDGET(data);
  if (!GTK_IS_WINDOW(window))
    return -EFAULT; 
  entry=lookup_widget(GTK_WIDGET(window),"DownLoadDirectoryEntry");
  if (!GTK_IS_ENTRY(entry))
    return -EFAULT; 

  priv=(ipmsg_private_data_t *)lookup_widget(GTK_WIDGET(window),"senderInfo");
  g_assert(priv);
  sender_info=priv->data; 
  g_assert(sender_info->ipaddr);

  pkt_no=sender_info->pktno;

  gtk_tree_model_get (model, iter, 
		      0, &fileid,
		      1, &filename,
		      3, &total_read,
		      -1);
  dirname=(char *)gtk_entry_get_text(GTK_ENTRY(entry));
  snprintf(filepath,PATH_MAX-1,"%s/%s",dirname,filename);
  filepath[PATH_MAX-1]='\0';
  g_free(filename);

  dbg_out("download %d th element of %ld from %s into %s\n",fileid,pkt_no,sender_info->ipaddr,filepath);

  fd=open(filepath,O_RDWR|O_EXCL|O_CREAT,S_IRWXU|S_IRWXG|S_IRWXO);
  if (fd<0) {
    if (errno == EEXIST) {
      GtkWidget *dialog=create_ipmsgDownloadOverWrite ();
      GtkWidget *label;
      gint result;

      g_assert(dialog);
      label=GTK_WIDGET(lookup_widget(dialog,"overwriteFileNameLabel"));
      gtk_label_set_text(GTK_LABEL(label),filepath);
      result=gtk_dialog_run (GTK_DIALOG (dialog));
      switch (result) {
      case GTK_RESPONSE_OK:
	dbg_out("Accept for overwrite\n");
	fd=open(filepath,O_RDWR|O_CREAT,S_IRWXU|S_IRWXG|S_IRWXO);
	if (fd<0) {
	  err_out("Can not open file:%s (%d)\n",strerror(errno),errno);
	  gtk_widget_destroy (dialog);
	  rc=-errno;
	  goto no_close_out;
	}
	break;
      default:
	if (errno)
	  err_out("response:%d Can not open file:%s (%d)\n",result,strerror(errno),errno);
	gtk_widget_destroy (dialog);
	rc=-ENOENT;
	goto no_close_out;
	break;
      }
      gtk_widget_destroy (dialog);
    } else{
      err_out("Can not open file:%s (%d)\n",strerror(errno),errno);
      rc=-errno;
      goto no_close_out;
    }
  }
  memset(&con,0,sizeof(tcp_con_t));
  rc=tcp_setup_client(hostinfo_get_ipmsg_system_addr_family(),sender_info->ipaddr,hostinfo_refer_ipmsg_port(),&con);
  if (rc<0) {
    rc=-errno;
    goto file_close_out;
  }
  /* 送信側は受信側を待つ仕様なのでselectは使用不可能なので, タイムアウト付きで
   *   仮読みを開始する
   */
  rc=sock_recv_time_out(con.soc,TCP_CLIENT_TMOUT_MS); 
  if (rc<0) {
    rc=-errno;
    goto file_close_out;
  }
 retry_this_file:
  memset(buff,0,TCP_FILE_BUFSIZ);
  snprintf(buff,TCP_FILE_BUFSIZ-1,"%x:%x:0",(unsigned int)pkt_no,(unsigned int)fileid);
  buff[TCP_FILE_BUFSIZ-1]='\0';

  dbg_out("request:%s\n",buff);

  rc=ipmsg_construct_getfile_message(buff,0,(size_t *)&len,&req_message,ipmsg_get_pkt_no());
  if (rc<0) {
    rc=-errno;
    goto file_close_out;
  }
  dbg_out("request message:%s\n",req_message);

  wait_max=TCP_DOWNLOAD_RETRY;
 wrtite_wait_start:
  ipmsg_update_ui();
  rc=wait_socket(con.soc,WAIT_FOR_WRITE,TCP_SELECT_SEC);
  if (rc<0) {
    --wait_max;
    if (wait_max)
      goto wrtite_wait_start;
    err_out("Can not write for socket %s (%d)\n",strerror(-rc),-rc);
    free(req_message);
    goto err_io;
  }  

  soc_remains=len;
  while(soc_remains > 0) {
    write_len=send(con.soc, req_message,len, MSG_NOSIGNAL);
    if (write_len < 0) {
      err_out("Can not write socket :%s (%d)\n",strerror(errno),errno);
      free(req_message);
      rc=-errno;
      goto err_io;
    }
    soc_remains -= write_len;
    dbg_out("Write remains:%d\n",soc_remains);
  }
  free(req_message);

  total_write=0;
  file_remains=total_read;
  dbg_out("Try to read %d byte total\n", file_remains);
  /*
   *読み取り
   */
  while(file_remains>0) {
    ipmsg_update_ui();
    wait_max=TCP_DOWNLOAD_RETRY; /* 送信側は受信側を待つ仕様なのでselectは使用不可能 */
  read_wait_start:
    memset(buff, 0, sizeof(buff));
    errno=0;
    recv_len=recv(con.soc,buff,_MSG_BUF_SIZE,(MSG_PEEK));
    if (!recv_len) {
      err_out("Peeked message zero\n");
      rc=-errno;
      goto err_io; /* err or end */
    }
    if (recv_len<0) {
      if (errno) {
	if ( ( (errno == EAGAIN) || (errno == EINTR) ) && (wait_max) ) {
	  err_out("Read time out %s(errno:%d) (remains:%d)\n",strerror(errno),errno,wait_max);
	  --wait_max;
	  goto read_wait_start;
	}
	err_out("Can not peek message %s(errno:%d)\n",strerror(errno),errno);
      }
      rc=-errno;
      goto err_io; /* err or end */
    }


    dbg_out("tcp peek read:%d\n",recv_len);
    if (file_remains<recv_l