callbacks.c

一个在LINUX下运行的东西

/*
 * callbacks.c
 * Copyright (C) wkt 2007 <linux@debian>
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif
//#define _GNU_SOURCE
#include <stdio.h>
#include <unistd.h>
#include<grp.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <stdlib.h>
#include <string.h>
#include<signal.h>
#include <errno.h>
#include <gtk/gtk.h>
//#include <libnotify/notify.h>

#include "callbacks.h"
#include "main.h"
#include "guis.h"
#include "func.h"
#include "debug.h"

 char *dpath="/etc/ppp/peers";

 const char *logfile="/tmp/.pppd.log.file";

__def def = {"dsl-provider",NULL,NULL,NULL};

 void dis_connect()
 {
     char *cmd[]={"/usr/bin/poff",def.adslname,NULL};
     if(access(cmd[0],X_OK)==0){
       g_print("dis_connect:adslname -> %s\n",def.adslname);
       g_print("EXEC /usr/bin/poff %s\n",def.adslname);
       g_print("dis_connect:my_exec(): return %d \n",my_exec(cmd,0));
       my_exec(cmd,0);//for safe
     }
      else
//     my_exec(cmd,-1);
       if(is_pppoe_on()&&pppd.pid>5){
         g_print("Try to kill pppd pid = %d.\n",pppd.pid);
         if( kill(pppd.pid,15)==-1)
           fprintf(stderr,"dis_connect():kill():%s .\n",strerror(errno));
          //for no poff like magiclinux
     }
 }

void status_page(GtkStatusIcon *status_icon,gpointer data)
{
//  static char pet = 's';
//   if(pet == 'h'){
     if( gtk_window_is_active (GTK_WINDOW(window))){
     gtk_widget_hide(window);
//     pet = 's';
     return ;
     }
//   }
  gtk_window_present(GTK_WINDOW(window));
  //gtk_widget_show_all(note);
  gtk_notebook_set_current_page(GTK_NOTEBOOK(note),2);
//  pet = 'h';
  //g_print("status_page()\n");
}

void  status_notify(GObject *gobject, GParamSpec *arg1, gpointer user_data)
{
//    g_print("It works !\n");
}

void status_pop_menu(GtkStatusIcon* icon, guint button, guint activate_time,gpointer user_data)
{
//     gint x, y;
//    gboolean push_in;
    GtkWidget* prop ;
    GtkWidget* dis_connect ;
    GtkWidget* menu = gtk_menu_new();

    gpointer flag=NULL ;/// I don't want flag to be this type .
                        ///But when try something else there are some problem .

    if(is_pppoe_on()){
     dis_connect = gtk_menu_item_new_with_mnemonic(_("_Disconnect"));
     flag = (void*)0xffffffff;
    }
    else{
     dis_connect = gtk_menu_item_new_with_mnemonic(_("_Connect"));
     flag = NULL;
    }
    //g_print("flag :%p\n",flag);
    g_signal_connect((gpointer)dis_connect, "activate", G_CALLBACK(on_disconnect), flag);

    gtk_menu_shell_append(GTK_MENU_SHELL(menu), dis_connect);

    if(gtk_window_is_active(GTK_WINDOW(window))){
      prop= gtk_menu_item_new_with_mnemonic(_("_Hide"));
      flag = (void*)0xffffffff;
    }
     else {
       prop = gtk_menu_item_new_with_mnemonic(_("_Show"));
       flag = NULL;
    }

    g_signal_connect((gpointer)prop, "activate", GTK_SIGNAL_FUNC(on_prop), flag);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), prop);

    GtkWidget* sep = gtk_separator_menu_item_new();
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), sep);

    GtkWidget* quit = gtk_menu_item_new_with_mnemonic(_("_Quit"));
    g_signal_connect((gpointer)quit, "activate", G_CALLBACK(on_quit), NULL);
    gtk_menu_shell_append(GTK_MENU_SHELL(menu), quit);

    gtk_widget_show(dis_connect);
    gtk_widget_show(prop);
    gtk_widget_show(sep);
    gtk_widget_show(quit);
    gtk_widget_show(menu);

    /* gtk_status_icon_position_menu(GTK_MENU(menu), &x, &y, &push_in, icon); */
    gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 1, gtk_get_current_event_time());
    //g_print("Goddman it.\n");
}

gboolean on_window_delete_event(GtkWidget *widget,GdkEvent *event,   gpointer user_data)
{
  if(is_pppoe_on())gtk_widget_hide(widget);
    else{
      dis_connect();
      gtk_main_quit();
    }
  return TRUE;
}

gboolean on_status_delete_event(GtkWidget *widget,GdkEvent *event,   gpointer user_data)
{
   gtk_widget_hide(widget);
   //g_print("status:goddman it.\n");
   dis_connect(); ///stop pppd before quit .
   gtk_main_quit();
   return TRUE;
}

void on_quit (GtkMenuItem *menuitem, gpointer  user_data)
{
  //if(pppd.pid>5)kill(pppd.pid,15);
  dis_connect();
  gtk_main_quit();
}



void on_prop(GtkMenuItem *menuitem, gpointer user_data)
{
 //g_print("User_data : %p\n",user_data);
 if(user_data){
  //g_print("Hide window.\n");
  gtk_widget_hide(window);
 }
  else {
  	//g_print("Show window.\n");
  	gtk_window_present(GTK_WINDOW(window));
  }
}

gboolean on_disconnect (GtkWidget *widget,gpointer user_data)
{
  //if(pppd.pid>5)kill(pppd.pid,15);
  //g_print("user_data:%p \n",user_data);

  if(user_data){

    dis_connect();
	  gtk_widget_hide(statuswin);
//	gtk_widget_show(window);
	  gtk_status_icon_set_from_stock(GTK_STATUS_ICON(status_icon),GTK_STOCK_REFRESH);
//	fprintf(stderr,"%d\n",pppd.pid);
	}
	else   on_connect(NULL,NULL);

	return FALSE;
}

gboolean on_wvdial_out (GIOChannel *source, GIOCondition condition, gpointer data)
{
//	gtk_widget_show(statuswin);
	GtkWidget * label = statuslabel;//lookup_widget(statuswin,"statuslabel");
  gchar *line ,*line1;
  GIOStatus status;

  status = g_io_channel_read_line (source, &line1, NULL, NULL, NULL);

  line = get_addr(line1,'p');
  if (status != G_IO_STATUS_NORMAL)
    return FALSE;
#ifndef magic_linux
  if(g_strrstr(line,"pppd"))g_print ("ADSL Dialer: STDOUT: %s", line);
    else { g_free(line1); return TRUE ;}
#else
  g_print ("ADSL Dialer: STDOUT: %s", line);
#endif

	if (g_strrstr (line, "Using interface") != NULL)
		{
		 gtk_label_set_text (GTK_LABEL (label), line);
		 g_print ("USEFUL: %s", line);
		}
	if (g_strrstr (line, "Connection terminated.") != NULL)
		{

			gtk_status_icon_set_from_stock(GTK_STATUS_ICON(status_icon),GTK_STOCK_REFRESH);
			gtk_label_set_text (GTK_LABEL (label), _("Connection failed..."));
	 		///if( !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(chb1)))  gtk_widget_show_all(dialog1);

	 		static gint id = 0;
	 		if(id)goto loop;
	 		id = msgbox(_("Connection failed..."),0,TRUE);
	 		switch(id){
	 		 case 1:
	 		   gtk_main_quit();
	 		   break;
	 		 case 2:
	 		   break;
	 		 default:
	 		   gtk_main_quit();
	 		   break;
	 		 }
    id =0;
		}
	//	 g_print("FAILED");
	if (g_strrstr (line, "authentication succeeded") != NULL)
			 gtk_label_set_text (GTK_LABEL (label), _("Authentication succeeded"));
	if (g_strrstr (line, "replacing old default route") != NULL)
			 gtk_label_set_text (GTK_LABEL (label), _("Setting local route"));
	if (g_strrstr (line, "remote IP address") != NULL){
		 //gtk_widget_show(window);
                 gint id = 0;
		 gtk_label_set_text (GTK_LABEL (label), _("Ready to use"));

	         gtk_status_icon_set_from_stock(GTK_STATUS_ICON(status_icon),GTK_STOCK_NETWORK);
                 id = msgbox(_("Succeeded."),5,FALSE);
                  switch(id){
                    case 1 :
                       dis_connect();
                       gtk_main_quit();
                       break;
                    default:
                      break;
                   }
                 gtk_widget_hide(statuswin);
	  }
loop:  g_free (line1);
  return TRUE;
}

gboolean save_pro_changed(gchar *asl)
{
 gchar *pwd= (gchar*) gtk_entry_get_text(GTK_ENTRY(password_edit));
 gchar *unm= (gchar*) gtk_entry_get_text(GTK_ENTRY(username_edit));
// gchar *asl= gtk_combo_box_get_active_text(GTK_COMBO_BOX(adslname_edit));
 //g_print("passwd:  %-25s--%25s\n",pwd,def.passwd);
 g_print("username:%-25s--%25s\n",unm,def.username);
 g_print("adslname:%-25s--%25s\n",asl,def.adslname);

 if(strcmp(unm,def.username)||strcmp(pwd,def.passwd)||strcmp(asl,def.adslname))
 {

   g_print("save_pro_changed().\n");
   save_profile(pwd,unm,asl);
   del_user_in("/etc/ppp/chap-secrets",def.username);
   del_user_in("/etc/ppp/pap-secrets",def.username);
   write_password_file(unm,pwd,"/etc/ppp/chap-secrets");
   write_password_file(unm,pwd,"/etc/ppp/pap-secrets");
   load_active_pro(adslname_edit);
   def.passwd=pwd; //update defaults
   def.username=unm;
   def.adslname=asl;
   return TRUE;
  }
  //g_print("Quit out  save_pro_changed()\n");
  return FALSE;
}

gint my_io_watch(gchar *file,GIOFunc func,GIOCondition condition)
{
 int in = 0;
 int out = 1;
 int err = 3;

 GIOCondition gcdn = G_IO_IN | G_IO_HUP | G_IO_ERR;
 static GIOChannel *gout = NULL;
 gchar *cmd[] = {"/usr/bin/tail","-s1","-n0","-f",file,NULL};
 GError *error = NULL;

 if(gout){
  g_print("my_io_watch(): I run before .\n");
  return -1;
 }
//  GIOChannel *gerr;
 g_print("my_io_watch():I try to watch %s.\n",file);

 if(access(file,F_OK)){
   g_print("my_io_watch:access() %s:%s",file,strerror(errno));
/*   char *cli[]={"touch",file,NULL};
   g_print("Try touch %s .\n",file);
   my_exec(cli,0);
*/
  fclose(fopen(file,"a+"));
  }
  tail_pid = 0;
 if(!g_spawn_async_with_pipes(NULL,
 				cmd,
 				NULL,
 				G_SPAWN_SEARCH_PATH,
 				NULL,NULL,
 				&tail_pid,&in,&out,
 				&err,&error
                               )){
 	   g_print("my_io_watch():Failed to %s .\n",file);
 	   g_error_free (error);
 	   error = NULL;
 	 }
 	else {
 	  gout = g_io_channel_unix_new (out);
 	  g_io_channel_set_encoding (gout, NULL, NULL);
          if(condition)gcdn = condition ;//g_io_channel_seek_position(gout,-1l,G_SEEK_END,&error);
          g_io_add_watch (gout,gcdn,func,NULL);
          g_io_channel_unref (gout);
 }
 return 0;
}

void on_connect (GtkWidget  *widget,  gpointer user_data)
{

	gchar * profilename = gtk_combo_box_get_active_text(GTK_COMBO_BOX(adslname_edit));
	//fprintf(stderr,"%s\n",profilename);
  int id = 0;
  if(is_pppoe_on())id = msgbox(_("\nPPP is online already .OK to continue ,cancel ot cancel.\n"),0,TRUE);
  switch(id){
    case 0:
    case 2:
    break;
   case 1:
    return;
   default:
    return ;
  } 
  if(save_pro_changed(profilename))g_print("Profile saved.\n");

	pppd.cmd[0] = "/usr/sbin/pppd";
	pppd.cmd[1] = "call";
	pppd.cmd[2] = profilename;
	pppd.cmd[3] = NULL;

  dis_connect();///before connect we shut down .
	g_print("EXEC /usr/sbin/pppd call %s\n",profilename);

  if (!g_spawn_async_with_pipes (NULL,
                                 (char **)pppd.cmd,
                                 NULL,
                                 G_SPAWN_SEARCH_PATH,
                                 NULL, NULL,
                                 &pppd.pid,
                                 &pppd.in_pipe,
                                 &pppd.out_pipe,
                                 &pppd.err_pipe,
                                 &pppd.error)) {
                g_warning (_("ADSL Dialer: Command failed: %s\n"), pppd.error->message);
                g_error_free (pppd.error);
                pppd.error = NULL;
        }
        else {
        	gtk_widget_hide(window);

	        gtk_widget_show(statuswin);

          debug(g_print("pppd pid :%d .\n",pppd.pid));
	         //GtkWidget * label = lookup_widget(statuswin,"statuslabel");
          gtk_label_set_text (GTK_LABEL ( statuslabel), _("Prepare to connecting..."));

         if( access("/var/log/syslog",F_OK) == 0 )
               my_io_watch("/var/log/syslog",on_wvdial_out,0);
          else
              my_io_watch((char *)logfile,on_wvdial_out,0);
         }
    //if(tmp)free(tmp);
	//g_print("Sorry,we do nothing right now!\n");
}

void on_del (GtkWidget  *widget,  gpointer user_data)
{
 char file[1024]={0};

 sprintf(file,"%s/%s",dpath,gtk_combo_box_get_active_text(GTK_COMBO_BOX(adslname_edit)));
 if(remove(file))g_print("Can't remove %s\n",file);
 gint i = gtk_combo_box_get_active(GTK_COMBO_BOX(adslname_edit));
 //gint j = gtk_combo_box_get_column_span_column(GTK_COMBO_BOX(adslname_edit));
 //if(i==0)j=i;
 //g_print("i= %d j=%d\n",i,j);
 gtk_combo_box_set_active(GTK_COMBO_BOX(adslname_edit),i+1);
 gtk_combo_box_remove_text(GTK_COMBO_BOX(adslname_edit),i);
  //j= gtk_combo_box_get_row_span_column(GTK_COMBO_BOX(adslname_edit));
  //g_print("i= %d j=%d\n",gtk_combo_box_get_active(GTK_COMBO_BOX(adslname_edit)),j);


}

gboolean enter_press(GtkWidget *widget,GdkEventKey *event,GtkWidget *data)