lttv/lttv/modules/gui/tracecontrol/tracecontrol.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2005 Mathieu Desnoyers
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License Version 2 as
   6  * published by the Free Software Foundation;
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16  * MA 02111-1307, USA.
  17  */
  18
  19 #ifdef HAVE_CONFIG_H
  20 #include <config.h>
  21 #endif
  22
  23 #include <glib.h>
  24 #include <glib/gprintf.h>
  25 #include <string.h>
  26 #include <gtk/gtk.h>
  27 #include <gdk/gdk.h>
  28 #include <gdk/gdkkeysyms.h>
  29
  30 #include <lttv/lttv.h>
  31 #include <lttv/module.h>
  32 #include <lttv/hook.h>
  33
  34 #include <lttvwindow/lttvwindow.h>
  35 #include <lttvwindow/lttvwindowtraces.h>
  36 #include <lttvwindow/callbacks.h>
  37 #include <lttvwindow/lttv_plugin_tab.h>
  38
  39 #include "hTraceControlInsert.xpm"
  40 #include "TraceControlStart.xpm"
  41 #include "TraceControlPause.xpm"
  42 #include "TraceControlStop.xpm"
  43
  44 #include <sys/types.h>
  45 #include <unistd.h>
  46 #include <stdlib.h>
  47 #include <pty.h>
  48 #include <utmp.h>
  49 #include <sys/wait.h>
  50 #include <sys/poll.h>
  51 #include <errno.h>
  52 #include <fcntl.h>
  53 #include <sched.h>
  54
  55 #define MAX_ARGS_LEN PATH_MAX * 10
  56
  57 GSList *g_control_list = NULL ;
  58
  59 /*! \file lttv/modules/gui/tracecontrol/tracecontrol.c
  60  *  \brief Graphic trace start/stop control interface.
  61  *
  62  * This plugin interacts with lttctl to start/stop tracing. It needs to take the
  63  * root password to be able to interact with lttctl.
  64  *
  65  */
  66
  67 typedef struct _ControlData ControlData;
  68
  69 /*
  70  * Prototypes
  71  */
  72 GtkWidget *guicontrol_get_widget(ControlData *tcd);
  73 ControlData *gui_control(LttvPluginTab *ptab);
  74 void gui_control_destructor(ControlData *tcd);
  75 GtkWidget* h_guicontrol(LttvPlugin *plugin);
  76 void control_destroy_walk(gpointer data, gpointer user_data);
  77
  78 /*
  79  * Callback functions
  80  */
  81
  82 static void arm_clicked (GtkButton *button, gpointer user_data);
  83 static void disarm_clicked (GtkButton *button, gpointer user_data);
  84 static void start_clicked (GtkButton *button, gpointer user_data);
  85 static void pause_clicked (GtkButton *button, gpointer user_data);
  86 static void unpause_clicked (GtkButton *button, gpointer user_data);
  87 static void stop_clicked (GtkButton *button, gpointer user_data);
  88
  89
  90 /**
  91  *  @struct _ControlData
  92  *
  93  *  @brief Main structure of gui control
  94  */
  95 struct _ControlData {
  96   Tab *tab;                             /**< current tab of module */
  97
  98   GtkWidget *window;                  /**< window */
  99
 100   GtkWidget *main_box;                /**< main container */
 101   GtkWidget *ltt_armall_button;
 102   GtkWidget *ltt_disarmall_button;
 103   GtkWidget *start_button;
 104   GtkWidget *pause_button;
 105   GtkWidget *unpause_button;
 106   GtkWidget *stop_button;
 107   GtkWidget *username_label;
 108   GtkWidget *username_entry;
 109   GtkWidget *password_label;
 110   GtkWidget *password_entry;
 111   GtkWidget *channel_dir_label;
 112   GtkWidget *channel_dir_entry;
 113   GtkWidget *trace_dir_label;
 114   GtkWidget *trace_dir_entry;
 115   GtkWidget *trace_name_label;
 116   GtkWidget *trace_name_entry;
 117   GtkWidget *trace_mode_label;
 118   GtkWidget *trace_mode_combo;
 119   GtkWidget *start_daemon_label;
 120   GtkWidget *start_daemon_check;
 121   GtkWidget *append_label;
 122   GtkWidget *append_check;
 123   GtkWidget *optional_label;
 124   GtkWidget *subbuf_size_label;
 125   GtkWidget *subbuf_size_entry;
 126   GtkWidget *subbuf_num_label;
 127   GtkWidget *subbuf_num_entry;
 128   GtkWidget *lttd_threads_label;
 129   GtkWidget *lttd_threads_entry;
 130   GtkWidget *lttctl_path_label;
 131   GtkWidget *lttctl_path_entry;
 132   GtkWidget *lttd_path_label;
 133   GtkWidget *lttd_path_entry;
 134   GtkWidget *ltt_armall_path_label;
 135   GtkWidget *ltt_armall_path_entry;
 136   GtkWidget *ltt_disarmall_path_label;
 137   GtkWidget *ltt_disarmall_path_entry;
 138 };
 139
 140 /**
 141  *  @fn GtkWidget* guicontrol_get_widget(ControlData*)
 142  *
 143  *  This function returns the current main widget
 144  *  used by this module
 145  *  @param tcd the module struct
 146  *  @return The main widget
 147  */
 148 GtkWidget*
 149 guicontrol_get_widget(ControlData *tcd)
 150 {
 151   return tcd->window;
 152 }
 153
 154 /**
 155  *  @fn ControlData* gui_control(Tab*)
 156  *
 157  *  Constructor is used to create ControlData data structure.
 158  *  @param tab The tab structure used by the widget
 159  *  @return The Filter viewer data created.
 160  */
 161 ControlData*
 162 gui_control(LttvPluginTab *ptab)
 163 {
 164   Tab *tab = ptab->tab;
 165   g_debug("filter::gui_control()");
 166
 167   unsigned i;
 168   GtkCellRenderer *renderer;
 169   GtkTreeViewColumn *column;
 170
 171   ControlData* tcd = g_new(ControlData,1);
 172
 173   tcd->tab  = tab;
 174
 175   tcd->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 176   gtk_window_set_title(GTK_WINDOW(tcd->window), "LTTng Trace Control");
 177   /*
 178    * Initiating GtkTable layout
 179    * starts with 2 rows and 5 columns and
 180    * expands when expressions added
 181    */
 182   tcd->main_box = gtk_table_new(14,7,FALSE);
 183   gtk_table_set_row_spacings(GTK_TABLE(tcd->main_box),5);
 184   gtk_table_set_col_spacings(GTK_TABLE(tcd->main_box),5);
 185
 186   gtk_container_add(GTK_CONTAINER(tcd->window), GTK_WIDGET(tcd->main_box));
 187
 188   GList *focus_chain = NULL;
 189
 190   /*
 191    * start/pause/stop buttons
 192    */
 193
 194   GdkPixbuf *pixbuf;
 195   GtkWidget *image;
 196   pixbuf = gdk_pixbuf_new_from_xpm_data((const char **)TraceControlStart_xpm);
 197   image = gtk_image_new_from_pixbuf(pixbuf);
 198   tcd->ltt_armall_button = gtk_button_new_with_label("Arm LTTng kernel probes");
 199   //2.6 gtk_button_set_image(GTK_BUTTON(tcd->ltt_armall_button), image);
 200   g_object_set(G_OBJECT(tcd->ltt_armall_button), "image", image, NULL);
 201   gtk_button_set_alignment(GTK_BUTTON(tcd->ltt_armall_button), 0.0, 0.0);
 202   gtk_widget_show (tcd->ltt_armall_button);
 203   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->ltt_armall_button,6,7,0,1,GTK_FILL,GTK_FILL,2,2);
 204
 205   pixbuf = gdk_pixbuf_new_from_xpm_data((const char **)TraceControlStop_xpm);
 206   image = gtk_image_new_from_pixbuf(pixbuf);
 207   tcd->ltt_disarmall_button = gtk_button_new_with_label("Disarm LTTng kernel probes");
 208   //2.6 gtk_button_set_image(GTK_BUTTON(tcd->ltt_disarmall_button), image);
 209   g_object_set(G_OBJECT(tcd->ltt_disarmall_button), "image", image, NULL);
 210   gtk_button_set_alignment(GTK_BUTTON(tcd->ltt_disarmall_button), 0.0, 0.0);
 211   gtk_widget_show (tcd->ltt_disarmall_button);
 212   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->ltt_disarmall_button,6,7,1,2,GTK_FILL,GTK_FILL,2,2);
 213
 214   pixbuf = gdk_pixbuf_new_from_xpm_data((const char **)TraceControlStart_xpm);
 215   image = gtk_image_new_from_pixbuf(pixbuf);
 216   tcd->start_button = gtk_button_new_with_label("start");
 217   //2.6 gtk_button_set_image(GTK_BUTTON(tcd->start_button), image);
 218   g_object_set(G_OBJECT(tcd->start_button), "image", image, NULL);
 219   gtk_button_set_alignment(GTK_BUTTON(tcd->start_button), 0.0, 0.0);
 220   gtk_widget_show (tcd->start_button);
 221   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->start_button,6,7,2,3,GTK_FILL,GTK_FILL,2,2);
 222
 223   pixbuf = gdk_pixbuf_new_from_xpm_data((const char **)TraceControlPause_xpm);
 224   image = gtk_image_new_from_pixbuf(pixbuf);
 225   tcd->pause_button = gtk_button_new_with_label("pause");
 226   //2.6 gtk_button_set_image(GTK_BUTTON(tcd->pause_button), image);
 227   g_object_set(G_OBJECT(tcd->pause_button), "image", image, NULL);
 228   gtk_button_set_alignment(GTK_BUTTON(tcd->pause_button), 0.0, 0.0);
 229   gtk_widget_show (tcd->pause_button);
 230   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->pause_button,6,7,3,4,GTK_FILL,GTK_FILL,2,2);
 231
 232   pixbuf = gdk_pixbuf_new_from_xpm_data((const char **)TraceControlPause_xpm);
 233   image = gtk_image_new_from_pixbuf(pixbuf);
 234   tcd->unpause_button = gtk_button_new_with_label("unpause");
 235   //2.6 gtk_button_set_image(GTK_BUTTON(tcd->unpause_button), image);
 236   g_object_set(G_OBJECT(tcd->unpause_button), "image", image, NULL);
 237   gtk_button_set_alignment(GTK_BUTTON(tcd->unpause_button), 0.0, 0.0);
 238   gtk_widget_show (tcd->unpause_button);
 239   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->unpause_button,6,7,4,5,GTK_FILL,GTK_FILL,2,2);
 240
 241   pixbuf = gdk_pixbuf_new_from_xpm_data((const char **)TraceControlStop_xpm);
 242   image = gtk_image_new_from_pixbuf(pixbuf);
 243   tcd->stop_button = gtk_button_new_with_label("stop");
 244   //2.6 gtk_button_set_image(GTK_BUTTON(tcd->stop_button), image);
 245   g_object_set(G_OBJECT(tcd->stop_button), "image", image, NULL);
 246   gtk_button_set_alignment(GTK_BUTTON(tcd->stop_button), 0.0, 0.0);
 247   gtk_widget_show (tcd->stop_button);
 248   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->stop_button,6,7,5,6,GTK_FILL,GTK_FILL,2,2);
 249
 250   /*
 251    *  First half of the filter window
 252    *  - textual entry of filter expression
 253    *  - processing button
 254    */
 255   tcd->username_label = gtk_label_new("Username:");
 256   gtk_widget_show (tcd->username_label);
 257   tcd->username_entry = gtk_entry_new();
 258   gtk_entry_set_text(GTK_ENTRY(tcd->username_entry),"root");
 259   gtk_widget_show (tcd->username_entry);
 260   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->username_label,0,2,0,1,GTK_FILL,GTK_FILL,2,2);
 261   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->username_entry,2,6,0,1,GTK_FILL|GTK_EXPAND|GTK_SHRINK,GTK_FILL,0,0);
 262
 263
 264
 265   tcd->password_label = gtk_label_new("Password:");
 266   gtk_widget_show (tcd->password_label);
 267   tcd->password_entry = gtk_entry_new();
 268   gtk_entry_set_visibility(GTK_ENTRY(tcd->password_entry), FALSE);
 269   gtk_widget_show (tcd->password_entry);
 270   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->password_label,0,2,1,2,GTK_FILL,GTK_FILL,2,2);
 271   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->password_entry,2,6,1,2,GTK_FILL|GTK_EXPAND|GTK_SHRINK,GTK_FILL,0,0);
 272
 273
 274   tcd->channel_dir_label = gtk_label_new("Channel directory:");
 275   gtk_widget_show (tcd->channel_dir_label);
 276   tcd->channel_dir_entry = gtk_entry_new();
 277   gtk_entry_set_text(GTK_ENTRY(tcd->channel_dir_entry),"/mnt/debugfs/ltt");
 278   gtk_widget_show (tcd->channel_dir_entry);
 279   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->channel_dir_label,0,2,2,3,GTK_FILL,GTK_FILL,2,2);
 280   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->channel_dir_entry,2,6,2,3,GTK_FILL|GTK_EXPAND|GTK_SHRINK,GTK_FILL,0,0);
 281
 282   tcd->trace_dir_label = gtk_label_new("Trace directory:");
 283   gtk_widget_show (tcd->trace_dir_label);
 284   tcd->trace_dir_entry = gtk_entry_new();
 285   gtk_entry_set_text(GTK_ENTRY(tcd->trace_dir_entry),"/tmp/trace1");
 286   gtk_widget_show (tcd->trace_dir_entry);
 287   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->trace_dir_label,0,2,3,4,GTK_FILL,GTK_FILL,2,2);
 288   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->trace_dir_entry,2,6,3,4,GTK_FILL|GTK_EXPAND|GTK_SHRINK,GTK_FILL,0,0);
 289
 290   tcd->trace_name_label = gtk_label_new("Trace name:");
 291   gtk_widget_show (tcd->trace_name_label);
 292   tcd->trace_name_entry = gtk_entry_new();
 293   gtk_entry_set_text(GTK_ENTRY(tcd->trace_name_entry),"trace");
 294   gtk_widget_show (tcd->trace_name_entry);
 295   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->trace_name_label,0,2,4,5,GTK_FILL,GTK_FILL,2,2);
 296   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->trace_name_entry,2,6,4,5,GTK_FILL|GTK_EXPAND|GTK_SHRINK,GTK_FILL,0,0);
 297
 298   tcd->trace_mode_label = gtk_label_new("Trace mode ");
 299   gtk_widget_show (tcd->trace_mode_label);
 300   tcd->trace_mode_combo = gtk_combo_box_new_text();
 301   gtk_combo_box_append_text(GTK_COMBO_BOX(tcd->trace_mode_combo),
 302       "normal");
 303   gtk_combo_box_append_text(GTK_COMBO_BOX(tcd->trace_mode_combo),
 304       "flight recorder");
 305   gtk_combo_box_set_active(GTK_COMBO_BOX(tcd->trace_mode_combo), 0);
 306   gtk_widget_show (tcd->trace_mode_combo);
 307   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->trace_mode_label,0,2,5,6,GTK_FILL,GTK_FILL,2,2);
 308   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->trace_mode_combo,2,6,5,6,GTK_FILL|GTK_EXPAND|GTK_SHRINK,GTK_FILL,0,0);
 309
 310   tcd->start_daemon_label = gtk_label_new("Start daemon ");
 311   gtk_widget_show (tcd->start_daemon_label);
 312   tcd->start_daemon_check = gtk_check_button_new();
 313   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tcd->start_daemon_check), TRUE);
 314   gtk_widget_show (tcd->start_daemon_check);
 315   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->start_daemon_label,0,2,6,7,GTK_FILL,GTK_FILL,2,2);
 316   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->start_daemon_check,2,6,6,7,GTK_FILL,GTK_FILL,0,0);
 317
 318   tcd->append_label = gtk_label_new("Append to trace ");
 319   gtk_widget_show (tcd->append_label);
 320   tcd->append_check = gtk_check_button_new();
 321   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(tcd->append_check), FALSE);
 322   gtk_widget_show (tcd->append_check);
 323   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->append_label,0,2,7,8,GTK_FILL,GTK_FILL,2,2);
 324   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->append_check,2,6,7,8,GTK_FILL,GTK_FILL,0,0);
 325
 326
 327   tcd->optional_label = gtk_label_new("Optional fields ");
 328   gtk_widget_show (tcd->optional_label);
 329   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->optional_label,0,6,8,9,GTK_FILL,GTK_FILL,2,2);
 330
 331   tcd->subbuf_size_label = gtk_label_new("Subbuffer size:");
 332   gtk_widget_show (tcd->subbuf_size_label);
 333   tcd->subbuf_size_entry = gtk_entry_new();
 334   gtk_widget_show (tcd->subbuf_size_entry);
 335   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->subbuf_size_label,0,2,9,10,GTK_FILL,GTK_FILL,2,2);
 336   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->subbuf_size_entry,2,6,9,10,GTK_FILL|GTK_EXPAND|GTK_SHRINK,GTK_FILL,0,0);
 337
 338   tcd->subbuf_num_label = gtk_label_new("Number of subbuffers:");
 339   gtk_widget_show (tcd->subbuf_num_label);
 340   tcd->subbuf_num_entry = gtk_entry_new();
 341   gtk_widget_show (tcd->subbuf_num_entry);
 342   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->subbuf_num_label,0,2,10,11,GTK_FILL,GTK_FILL,2,2);
 343   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->subbuf_num_entry,2,6,10,11,GTK_FILL|GTK_EXPAND|GTK_SHRINK,GTK_FILL,0,0);
 344
 345   tcd->lttd_threads_label = gtk_label_new("Number of lttd threads:");
 346   gtk_widget_show (tcd->lttd_threads_label);
 347   tcd->lttd_threads_entry = gtk_entry_new();
 348   gtk_entry_set_text(GTK_ENTRY(tcd->lttd_threads_entry), "1");
 349   gtk_widget_show (tcd->lttd_threads_entry);
 350   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->lttd_threads_label,0,2,11,12,GTK_FILL,GTK_FILL,2,2);
 351   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->lttd_threads_entry,2,6,11,12,GTK_FILL|GTK_EXPAND|GTK_SHRINK,GTK_FILL,0,0);
 352
 353   tcd->lttctl_path_label = gtk_label_new("path to lttctl:");
 354   gtk_widget_show (tcd->lttctl_path_label);
 355   tcd->lttctl_path_entry = gtk_entry_new();
 356   gtk_entry_set_text(GTK_ENTRY(tcd->lttctl_path_entry),PACKAGE_BIN_DIR "/lttctl");
 357   gtk_widget_show (tcd->lttctl_path_entry);
 358   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->lttctl_path_label,0,2,12,13,GTK_FILL,GTK_FILL,2,2);
 359   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->lttctl_path_entry,2,6,12,13,GTK_FILL|GTK_EXPAND|GTK_SHRINK,GTK_FILL,0,0);
 360
 361
 362   tcd->lttd_path_label = gtk_label_new("path to lttd:");
 363   gtk_widget_show (tcd->lttd_path_label);
 364   tcd->lttd_path_entry = gtk_entry_new();
 365   gtk_entry_set_text(GTK_ENTRY(tcd->lttd_path_entry),PACKAGE_BIN_DIR "/lttd");
 366   gtk_widget_show (tcd->lttd_path_entry);
 367   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->lttd_path_label,0,2,13,14,GTK_FILL,GTK_FILL,2,2);
 368   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->lttd_path_entry,2,6,13,14,GTK_FILL|GTK_EXPAND|GTK_SHRINK,GTK_FILL,0,0);
 369
 370   tcd->ltt_armall_path_label = gtk_label_new("path to ltt_armall:");
 371   gtk_widget_show (tcd->ltt_armall_path_label);
 372   tcd->ltt_armall_path_entry = gtk_entry_new();
 373   gtk_entry_set_text(GTK_ENTRY(tcd->ltt_armall_path_entry),PACKAGE_BIN_DIR "/ltt-armall");
 374   gtk_widget_show (tcd->ltt_armall_path_entry);
 375   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->ltt_armall_path_label,0,2,14,15,GTK_FILL,GTK_FILL,2,2);
 376   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->ltt_armall_path_entry,2,6,14,15,GTK_FILL|GTK_EXPAND|GTK_SHRINK,GTK_FILL,0,0);
 377
 378   tcd->ltt_disarmall_path_label = gtk_label_new("path to ltt_disarmall:");
 379   gtk_widget_show (tcd->ltt_disarmall_path_label);
 380   tcd->ltt_disarmall_path_entry = gtk_entry_new();
 381   gtk_entry_set_text(GTK_ENTRY(tcd->ltt_disarmall_path_entry),PACKAGE_BIN_DIR "/ltt-disarmall");
 382   gtk_widget_show (tcd->ltt_disarmall_path_entry);
 383   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->ltt_disarmall_path_label,0,2,15,16,GTK_FILL,GTK_FILL,2,2);
 384   gtk_table_attach( GTK_TABLE(tcd->main_box),tcd->ltt_disarmall_path_entry,2,6,15,16,GTK_FILL|GTK_EXPAND|GTK_SHRINK,GTK_FILL,0,0);
 385
 386   focus_chain = g_list_append (focus_chain, tcd->username_entry);
 387   focus_chain = g_list_append (focus_chain, tcd->password_entry);
 388   focus_chain = g_list_append (focus_chain, tcd->ltt_armall_path_entry);
 389   focus_chain = g_list_append (focus_chain, tcd->ltt_disarmall_path_entry);
 390   focus_chain = g_list_append (focus_chain, tcd->start_button);
 391   focus_chain = g_list_append (focus_chain, tcd->pause_button);
 392   focus_chain = g_list_append (focus_chain, tcd->unpause_button);
 393   focus_chain = g_list_append (focus_chain, tcd->stop_button);
 394   focus_chain = g_list_append (focus_chain, tcd->channel_dir_entry);
 395   focus_chain = g_list_append (focus_chain, tcd->trace_dir_entry);
 396   focus_chain = g_list_append (focus_chain, tcd->trace_name_entry);
 397   focus_chain = g_list_append (focus_chain, tcd->trace_mode_combo);
 398   focus_chain = g_list_append (focus_chain, tcd->start_daemon_check);
 399   focus_chain = g_list_append (focus_chain, tcd->append_check);
 400   focus_chain = g_list_append (focus_chain, tcd->subbuf_size_entry);
 401   focus_chain = g_list_append (focus_chain, tcd->subbuf_num_entry);
 402   focus_chain = g_list_append (focus_chain, tcd->lttd_threads_entry);
 403   focus_chain = g_list_append (focus_chain, tcd->lttctl_path_entry);
 404   focus_chain = g_list_append (focus_chain, tcd->lttd_path_entry);
 405
 406   gtk_container_set_focus_chain(GTK_CONTAINER(tcd->main_box), focus_chain);
 407
 408   g_list_free(focus_chain);
 409
 410   g_signal_connect(G_OBJECT(tcd->start_button), "clicked",
 411       (GCallback)start_clicked, tcd);
 412   g_signal_connect(G_OBJECT(tcd->pause_button), "clicked",
 413       (GCallback)pause_clicked, tcd);
 414   g_signal_connect(G_OBJECT(tcd->unpause_button), "clicked",
 415       (GCallback)unpause_clicked, tcd);
 416   g_signal_connect(G_OBJECT(tcd->stop_button), "clicked",
 417       (GCallback)stop_clicked, tcd);
 418   g_signal_connect(G_OBJECT(tcd->ltt_armall_button), "clicked",
 419       (GCallback)arm_clicked, tcd);
 420   g_signal_connect(G_OBJECT(tcd->ltt_disarmall_button), "clicked",
 421       (GCallback)disarm_clicked, tcd);
 422
 423   /*
 424    * show main container
 425    */
 426   gtk_widget_show(tcd->main_box);
 427   gtk_widget_show(tcd->window);
 428
 429
 430   g_object_set_data_full(
 431       G_OBJECT(guicontrol_get_widget(tcd)),
 432       "control_viewer_data",
 433       tcd,
 434       (GDestroyNotify)gui_control_destructor);
 435
 436   g_control_list = g_slist_append(
 437       g_control_list,
 438       tcd);
 439
 440   return tcd;
 441 }
 442
 443
 444 /**
 445  *  @fn void gui_control_destructor(ControlData*)
 446  *
 447  *  Destructor for the filter gui module
 448  *  @param tcd The module structure
 449  */
 450 void
 451 gui_control_destructor(ControlData *tcd)
 452 {
 453   Tab *tab = tcd->tab;
 454
 455   /* May already been done by GTK window closing */
 456   if(GTK_IS_WIDGET(guicontrol_get_widget(tcd))){
 457     g_info("widget still exists");
 458   }
 459 //  if(tab != NULL) {
 460 //    lttvwindow_unregister_traceset_notify(tcd->tab,
 461 //                                          filter_traceset_changed,
 462 //                                          filter_viewer_data);
 463 //  }
 464   lttvwindowtraces_background_notify_remove(tcd);
 465
 466   g_control_list = g_slist_remove(g_control_list, tcd);
 467
 468   g_free(tcd);
 469 }
 470
 471 static int execute_command(const gchar *command, const gchar *username,
 472     const gchar *password, const gchar *lttd_path)
 473 {
 474   pid_t pid;
 475   int fdpty;
 476   pid = forkpty(&fdpty, NULL, NULL, NULL);
 477   int retval = 0;
 478
 479   if(pid > 0) {
 480     /* parent */
 481     gchar buf[256];
 482     int status;
 483     ssize_t count;
 484     /* discuss with su */
 485     struct timeval timeout;
 486     timeout.tv_sec = 1;
 487     timeout.tv_usec = 0;
 488
 489     struct pollfd pollfd;
 490     int num_rdy;
 491     int num_hup = 0;
 492                 enum read_state { GET_LINE, GET_SEMI, GET_SPACE } read_state = GET_LINE;
 493
 494                 retval = fcntl(fdpty, F_SETFL, O_WRONLY);
 495                 if(retval == -1) {
 496                         perror("Error in fcntl");
 497                         goto wait_child;
 498                 }
 499
 500     /* Read the output from the child terminal before the prompt. If no data in
 501      * 200 ms, we stop reading to give the password */
 502     g_info("Reading from child console...");
 503     while(1) {
 504       pollfd.fd = fdpty;
 505       pollfd.events = POLLIN|POLLPRI|POLLERR|POLLHUP|POLLNVAL;
 506
 507       num_rdy = poll(&pollfd, 1, -1);
 508       if(num_rdy == -1) {
 509         perror("Poll error");
 510         goto wait_child;
 511       }
 512
 513       /* Timeout : Stop waiting for chars */
 514       if(num_rdy == 0) goto wait_child;
 515
 516       switch(pollfd.revents) {
 517         case POLLERR:
 518           g_warning("Error returned in polling fd\n");
 519           num_hup++;
 520           break;
 521         case POLLHUP:
 522           g_info("Polling FD : hung up.");
 523           num_hup++;
 524           break;
 525         case POLLNVAL:
 526           g_warning("Polling fd tells it is not open");
 527           num_hup++;
 528           break;
 529         case POLLPRI:
 530         case POLLIN:
 531           count = read (fdpty, buf, 256);
 532           if(count > 0) {
 533                                                 unsigned int i;
 534             buf[count] = '\0';
 535             g_printf("%s", buf);
 536                                                 for(i=0; i<count; i++) {
 537                                                         switch(read_state) {
 538                                                                 case GET_LINE:
 539                                                                         if(buf[i] == '\n') {
 540                                                                                 read_state = GET_SEMI;
 541                                                                                 g_debug("Tracecontrol input line skip\n");
 542                                                                         }
 543                                                                         break;
 544                                                                 case GET_SEMI:
 545                                                                         if(buf[i] == ':') {
 546                                                                                 g_debug("Tracecontrol input  : marker found\n");
 547                                                                                 read_state = GET_SPACE;
 548                                                                         }
 549                                                                         break;
 550                                                                 case GET_SPACE:
 551                                                                         if(buf[i] == ' ') {
 552                                                                                 g_debug("Tracecontrol input space marker found\n");
 553                                                                                 goto write_password;
 554                                                                         }
 555                                                                         break;
 556                                                         }
 557                                                 }
 558           } else if(count == -1) {
 559             perror("Error in read");
 560             goto wait_child;
 561           }
 562           break;
 563       }
 564       if(num_hup > 0) {
 565         g_warning("Child hung up too fast");
 566         goto wait_child;
 567       }
 568     }
 569 write_password:
 570                 fsync(fdpty);
 571                 pollfd.fd = fdpty;
 572                 pollfd.events = POLLOUT|POLLERR|POLLHUP|POLLNVAL;
 573
 574                 num_rdy = poll(&pollfd, 1, -1);
 575                 if(num_rdy == -1) {
 576                         perror("Poll error");
 577                         goto wait_child;
 578                 }
 579
 580     /* Write the password */
 581     g_info("Got su prompt, now writing password...");
 582     int ret;
 583                 sleep(1);
 584     ret = write(fdpty, password, strlen(password));
 585     if(ret < 0) perror("Error in write");
 586     ret = write(fdpty, "\n", 1);
 587     if(ret < 0) perror("Error in write");
 588     fsync(fdpty);
 589     /* Take the output from the terminal and show it on the real console */
 590     g_info("Getting data from child terminal...");
 591     while(1) {
 592       int num_hup = 0;
 593       pollfd.fd = fdpty;
 594       pollfd.events = POLLIN|POLLPRI|POLLERR|POLLHUP|POLLNVAL;
 595
 596       num_rdy = poll(&pollfd, 1, -1);
 597       if(num_rdy == -1) {
 598         perror("Poll error");
 599         goto wait_child;
 600       }
 601       if(num_rdy == 0) break;
 602
 603                         if(pollfd.revents & (POLLERR|POLLNVAL)) {
 604                                 g_warning("Error returned in polling fd\n");
 605                                 num_hup++;
 606                         }
 607
 608                         if(pollfd.revents & (POLLIN|POLLPRI) ) {
 609                                 count = read (fdpty, buf, 256);
 610                                 if(count > 0) {
 611                                         buf[count] = '\0';
 612                                         printf("%s", buf);
 613                                 } else if(count == -1) {
 614                                         perror("Error in read");
 615                                         goto wait_child;
 616                                 }
 617                         }
 618
 619                         if(pollfd.revents & POLLHUP) {
 620         g_info("Polling FD : hung up.");
 621         num_hup++;
 622                         }
 623
 624       if(num_hup > 0) goto wait_child;
 625     }
 626 wait_child:
 627     g_info("Waiting for child exit...");
 628
 629     ret = waitpid(pid, &status, 0);
 630
 631     if(ret == -1) {
 632       g_warning("An error occured in wait : %s",
 633           strerror(errno));
 634     } else {
 635       if(WIFEXITED(status))
 636         if(WEXITSTATUS(status) != 0) {
 637           retval = WEXITSTATUS(status);
 638           g_warning("An error occured in the su command : %s",
 639               strerror(retval));
 640         }
 641     }
 642
 643     g_info("Child exited.");
 644
 645   } else if(pid == 0) {
 646     /* Setup environment variables */
 647     if(strcmp(lttd_path, "") != 0)
 648       setenv("LTT_DAEMON", lttd_path, 1);
 649
 650                 /* One comment line (must be only one) */
 651     g_printf("Executing (as %s) : %s\n", username, command);
 652
 653     execlp("su", "su", "-p", "-c", command, username, NULL);
 654     exit(-1); /* not supposed to happen! */
 655
 656     //gint ret = execvp();
 657
 658   } else {
 659     /* error */
 660     g_warning("Error happened when forking for su");
 661   }
 662
 663   return retval;
 664 }
 665
 666
 667 /* Callbacks */
 668
 669 void start_clicked (GtkButton *button, gpointer user_data)
 670 {
 671   ControlData *tcd = (ControlData*)user_data;
 672
 673   const gchar *username = gtk_entry_get_text(GTK_ENTRY(tcd->username_entry));
 674   const gchar *password = gtk_entry_get_text(GTK_ENTRY(tcd->password_entry));
 675   const gchar *channel_dir =
 676     gtk_entry_get_text(GTK_ENTRY(tcd->channel_dir_entry));
 677   const gchar *trace_dir = gtk_entry_get_text(GTK_ENTRY(tcd->trace_dir_entry));
 678   const gchar *trace_name =
 679     gtk_entry_get_text(GTK_ENTRY(tcd->trace_name_entry));
 680
 681   const gchar *trace_mode_sel;
 682   GtkTreeIter iter;
 683
 684   gtk_combo_box_get_active_iter(GTK_COMBO_BOX(tcd->trace_mode_combo), &iter);
 685   gtk_tree_model_get(
 686       gtk_combo_box_get_model(GTK_COMBO_BOX(tcd->trace_mode_combo)),
 687       &iter, 0, &trace_mode_sel, -1);
 688   //const gchar *trace_mode_sel =
 689     //2.6+ gtk_combo_box_get_active_text(GTK_COMBO_BOX(tcd->trace_mode_combo));
 690   const gchar *trace_mode;
 691   if(strcmp(trace_mode_sel, "normal") == 0)
 692     trace_mode = "normal";
 693   else
 694     trace_mode = "flight";
 695
 696   gboolean start_daemon =
 697     gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tcd->start_daemon_check));
 698
 699   gboolean append =
 700     gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(tcd->append_check));
 701
 702   const gchar *subbuf_size =
 703     gtk_entry_get_text(GTK_ENTRY(tcd->subbuf_size_entry));
 704   const gchar *subbuf_num =
 705     gtk_entry_get_text(GTK_ENTRY(tcd->subbuf_num_entry));
 706         const gchar *threads_num =
 707     gtk_entry_get_text(GTK_ENTRY(tcd->lttd_threads_entry));
 708   const gchar *lttctl_path =
 709     gtk_entry_get_text(GTK_ENTRY(tcd->lttctl_path_entry));
 710   const gchar *lttd_path = gtk_entry_get_text(GTK_ENTRY(tcd->lttd_path_entry));
 711
 712   /* Setup arguments to su */
 713   /* child */
 714   gchar args[MAX_ARGS_LEN];
 715   gint args_left = MAX_ARGS_LEN - 1; /* for \0 */
 716
 717   args[0] = '\0';
 718
 719   /* Command */
 720   strncat(args, "exec", args_left);
 721   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 722
 723   /* space */
 724   strncat(args, " ", args_left);
 725   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 726
 727   if(strcmp(lttctl_path, "") == 0)
 728     strncat(args, "lttctl", args_left);
 729   else
 730     strncat(args, lttctl_path, args_left);
 731   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 732
 733   /* space */
 734   strncat(args, " ", args_left);
 735   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 736
 737   /* Start daemon ? */
 738   if(start_daemon) {
 739     strncat(args, "-C", args_left);
 740     args_left = MAX_ARGS_LEN - strlen(args) - 1;
 741   } else {
 742     /* Simply create the channel and then start tracing */
 743     //strncat(args, "-b", args_left);
 744     //args_left = MAX_ARGS_LEN - strlen(args) - 1;
 745   }
 746
 747   /* space */
 748   strncat(args, " ", args_left);
 749   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 750
 751   /* channel dir */
 752   strncat(args, "--channel_root ", args_left);
 753   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 754   strncat(args, channel_dir, args_left);
 755   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 756
 757   /* space */
 758   strncat(args, " ", args_left);
 759   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 760
 761   /* trace dir */
 762   strncat(args, "-w ", args_left);
 763   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 764   strncat(args, trace_dir, args_left);
 765   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 766
 767   /* space */
 768   strncat(args, " ", args_left);
 769   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 770
 771   if(strcmp(trace_mode, "flight") == 0) {
 772     strncat(args, "-o channel.all.overwrite=1", args_left);
 773     args_left = MAX_ARGS_LEN - strlen(args) - 1;
 774   } else {
 775     strncat(args, "-o channel.all.overwrite=0", args_left);
 776     args_left = MAX_ARGS_LEN - strlen(args) - 1;
 777   }
 778
 779   /* Append to trace ? */
 780   if(append) {
 781     /* space */
 782     strncat(args, " ", args_left);
 783     args_left = MAX_ARGS_LEN - strlen(args) - 1;
 784     strncat(args, "-a", args_left);
 785     args_left = MAX_ARGS_LEN - strlen(args) - 1;
 786   }
 787
 788   /* optional arguments */
 789   /* subbuffer size */
 790   if(strcmp(subbuf_size, "") != 0) {
 791     /* space */
 792     strncat(args, " ", args_left);
 793     args_left = MAX_ARGS_LEN - strlen(args) - 1;
 794
 795     strncat(args, "-o channel.all.bufsize=", args_left);
 796     args_left = MAX_ARGS_LEN - strlen(args) - 1;
 797     strncat(args, subbuf_size, args_left);
 798     args_left = MAX_ARGS_LEN - strlen(args) - 1;
 799   }
 800
 801   /* number of subbuffers */
 802   if(strcmp(subbuf_num, "") != 0) {
 803     /* space */
 804     strncat(args, " ", args_left);
 805     args_left = MAX_ARGS_LEN - strlen(args) - 1;
 806
 807     strncat(args, "-o channel.all.bufnum=", args_left);
 808     args_left = MAX_ARGS_LEN - strlen(args) - 1;
 809     strncat(args, subbuf_num, args_left);
 810     args_left = MAX_ARGS_LEN - strlen(args) - 1;
 811   }
 812
 813   /* number of lttd threads */
 814   if(strcmp(threads_num, "") != 0) {
 815     /* space */
 816     strncat(args, " ", args_left);
 817     args_left = MAX_ARGS_LEN - strlen(args) - 1;
 818
 819     strncat(args, "-n ", args_left);
 820     args_left = MAX_ARGS_LEN - strlen(args) - 1;
 821     strncat(args, threads_num, args_left);
 822     args_left = MAX_ARGS_LEN - strlen(args) - 1;
 823   }
 824
 825   /* space */
 826   strncat(args, " ", args_left);
 827   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 828
 829   /* name */
 830   strncat(args, trace_name, args_left);
 831   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 832
 833   int retval = execute_command(args, username, password, lttd_path);
 834
 835   if(retval) {
 836     gchar msg[256];
 837     guint msg_left = 256;
 838
 839     strcpy(msg, "A problem occured when executing the su command : ");
 840     msg_left = 256 - strlen(msg) - 1;
 841     strncat(msg, strerror(retval), msg_left);
 842     GtkWidget *dialogue =
 843       gtk_message_dialog_new(
 844         GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(button))),
 845         GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
 846         GTK_MESSAGE_ERROR,
 847         GTK_BUTTONS_OK,
 848         msg);
 849     gtk_dialog_run(GTK_DIALOG(dialogue));
 850     gtk_widget_destroy(dialogue);
 851   }
 852
 853 }
 854
 855
 856 void pause_clicked (GtkButton *button, gpointer user_data)
 857 {
 858   ControlData *tcd = (ControlData*)user_data;
 859
 860   const gchar *username = gtk_entry_get_text(GTK_ENTRY(tcd->username_entry));
 861   const gchar *password = gtk_entry_get_text(GTK_ENTRY(tcd->password_entry));
 862   const gchar *trace_name =
 863     gtk_entry_get_text(GTK_ENTRY(tcd->trace_name_entry));
 864   const gchar *lttd_path = "";
 865
 866   const gchar *lttctl_path =
 867     gtk_entry_get_text(GTK_ENTRY(tcd->lttctl_path_entry));
 868
 869   /* Setup arguments to su */
 870   /* child */
 871   gchar args[MAX_ARGS_LEN];
 872   gint args_left = MAX_ARGS_LEN - 1; /* for \0 */
 873
 874   args[0] = '\0';
 875
 876   /* Command */
 877   strncat(args, "exec", args_left);
 878   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 879
 880   /* space */
 881   strncat(args, " ", args_left);
 882   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 883
 884   if(strcmp(lttctl_path, "") == 0)
 885     strncat(args, "lttctl", args_left);
 886   else
 887     strncat(args, lttctl_path, args_left);
 888   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 889
 890  /* space */
 891   strncat(args, " ", args_left);
 892   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 893
 894   /* Simply pause tracing */
 895   strncat(args, "-p", args_left);
 896   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 897
 898   /* space */
 899   strncat(args, " ", args_left);
 900   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 901
 902   /* name */
 903   strncat(args, trace_name, args_left);
 904   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 905
 906   int retval = execute_command(args, username, password, lttd_path);
 907   if(retval) {
 908     gchar msg[256];
 909     guint msg_left = 256;
 910
 911     strcpy(msg, "A problem occured when executing the su command : ");
 912     msg_left = 256 - strlen(msg) - 1;
 913     strncat(msg, strerror(retval), msg_left);
 914     GtkWidget *dialogue =
 915       gtk_message_dialog_new(
 916         GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(button))),
 917         GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
 918         GTK_MESSAGE_ERROR,
 919         GTK_BUTTONS_OK,
 920         msg);
 921     gtk_dialog_run(GTK_DIALOG(dialogue));
 922     gtk_widget_destroy(dialogue);
 923   }
 924
 925 }
 926
 927 void unpause_clicked (GtkButton *button, gpointer user_data)
 928 {
 929   ControlData *tcd = (ControlData*)user_data;
 930
 931   const gchar *username = gtk_entry_get_text(GTK_ENTRY(tcd->username_entry));
 932   const gchar *password = gtk_entry_get_text(GTK_ENTRY(tcd->password_entry));
 933   const gchar *trace_name =
 934     gtk_entry_get_text(GTK_ENTRY(tcd->trace_name_entry));
 935   const gchar *lttd_path = "";
 936
 937   const gchar *lttctl_path =
 938     gtk_entry_get_text(GTK_ENTRY(tcd->lttctl_path_entry));
 939
 940   /* Setup arguments to su */
 941   /* child */
 942   gchar args[MAX_ARGS_LEN];
 943   gint args_left = MAX_ARGS_LEN - 1; /* for \0 */
 944
 945   args[0] = '\0';
 946
 947   /* Command */
 948   strncat(args, "exec", args_left);
 949   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 950
 951   /* space */
 952   strncat(args, " ", args_left);
 953   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 954
 955   if(strcmp(lttctl_path, "") == 0)
 956     strncat(args, "lttctl", args_left);
 957   else
 958     strncat(args, lttctl_path, args_left);
 959   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 960
 961   /* space */
 962   strncat(args, " ", args_left);
 963   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 964
 965   /* Simply unpause tracing */
 966   strncat(args, "-s", args_left);
 967   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 968
 969   /* space */
 970   strncat(args, " ", args_left);
 971   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 972
 973   /* name */
 974   strncat(args, trace_name, args_left);
 975   args_left = MAX_ARGS_LEN - strlen(args) - 1;
 976
 977   int retval = execute_command(args, username, password, lttd_path);
 978   if(retval) {
 979     gchar msg[256];
 980     guint msg_left = 256;
 981
 982     strcpy(msg, "A problem occured when executing the su command : ");
 983     msg_left = 256 - strlen(msg) - 1;
 984     strncat(msg, strerror(retval), msg_left);
 985     GtkWidget *dialogue =
 986       gtk_message_dialog_new(
 987         GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(button))),
 988         GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
 989         GTK_MESSAGE_ERROR,
 990         GTK_BUTTONS_OK,
 991         msg);
 992     gtk_dialog_run(GTK_DIALOG(dialogue));
 993     gtk_widget_destroy(dialogue);
 994   }
 995
 996 }
 997
 998 void stop_clicked (GtkButton *button, gpointer user_data)
 999 {
1000   ControlData *tcd = (ControlData*)user_data;
1001
1002   const gchar *username = gtk_entry_get_text(GTK_ENTRY(tcd->username_entry));
1003   const gchar *password = gtk_entry_get_text(GTK_ENTRY(tcd->password_entry));
1004   const gchar *trace_name =
1005     gtk_entry_get_text(GTK_ENTRY(tcd->trace_name_entry));
1006   const gchar *lttd_path = "";
1007   const gchar *trace_mode;
1008   const gchar *trace_mode_sel;
1009   GtkTreeIter iter;
1010
1011   gtk_combo_box_get_active_iter(GTK_COMBO_BOX(tcd->trace_mode_combo), &iter);
1012   gtk_tree_model_get(
1013       gtk_combo_box_get_model(GTK_COMBO_BOX(tcd->trace_mode_combo)),
1014       &iter, 0, &trace_mode_sel, -1);
1015   if(strcmp(trace_mode_sel, "normal") == 0)
1016     trace_mode = "normal";
1017   else
1018     trace_mode = "flight";
1019
1020   const gchar *lttctl_path =
1021     gtk_entry_get_text(GTK_ENTRY(tcd->lttctl_path_entry));
1022   gchar *trace_dir = gtk_entry_get_text(GTK_ENTRY(tcd->trace_dir_entry));
1023   GSList * trace_list = NULL;
1024
1025   trace_list = g_slist_append(trace_list, trace_dir);
1026
1027   /* Setup arguments to su */
1028   /* child */
1029   gchar args[MAX_ARGS_LEN];
1030   gint args_left = MAX_ARGS_LEN - 1; /* for \0 */
1031
1032   args[0] = '\0';
1033
1034   /* Command */
1035   strncat(args, "exec", args_left);
1036   args_left = MAX_ARGS_LEN - strlen(args) - 1;
1037
1038   /* space */
1039   strncat(args, " ", args_left);
1040   args_left = MAX_ARGS_LEN - strlen(args) - 1;
1041
1042   if(strcmp(lttctl_path, "") == 0)
1043     strncat(args, "lttctl", args_left);
1044   else
1045     strncat(args, lttctl_path, args_left);
1046   args_left = MAX_ARGS_LEN - strlen(args) - 1;
1047
1048   /* space */
1049   strncat(args, " ", args_left);
1050   args_left = MAX_ARGS_LEN - strlen(args) - 1;
1051
1052   /* Simply stop tracing and destroy channel */
1053   strncat(args, "-D", args_left);
1054   args_left = MAX_ARGS_LEN - strlen(args) - 1;
1055
1056   if(strcmp(trace_mode, "flight") == 0) {
1057     /* space */
1058     strncat(args, " ", args_left);
1059     args_left = MAX_ARGS_LEN - strlen(args) - 1;
1060
1061     /* trace dir */
1062     strncat(args, "-w ", args_left);
1063     args_left = MAX_ARGS_LEN - strlen(args) - 1;
1064     strncat(args, trace_dir, args_left);
1065     args_left = MAX_ARGS_LEN - strlen(args) - 1;
1066   }
1067
1068   /* space */
1069   strncat(args, " ", args_left);
1070   args_left = MAX_ARGS_LEN - strlen(args) - 1;
1071
1072   /* name */
1073   strncat(args, trace_name, args_left);
1074   args_left = MAX_ARGS_LEN - strlen(args) - 1;
1075
1076   int retval = execute_command(args, username, password, lttd_path);
1077   if(retval) {
1078     gchar msg[256];
1079     guint msg_left = 256;
1080
1081     strcpy(msg, "A problem occured when executing the su command : ");
1082     msg_left = 256 - strlen(msg) - 1;
1083     strncat(msg, strerror(retval), msg_left);
1084     GtkWidget *dialogue =
1085       gtk_message_dialog_new(
1086         GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(button))),
1087         GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
1088         GTK_MESSAGE_ERROR,
1089         GTK_BUTTONS_OK,
1090         msg);
1091     gtk_dialog_run(GTK_DIALOG(dialogue));
1092     gtk_widget_destroy(dialogue);
1093     return;
1094   }
1095
1096
1097   /* Ask to the user if he wants to open the trace in a new window */
1098   GtkWidget *dialogue;
1099   GtkWidget *label;
1100   gint id;
1101
1102   dialogue = gtk_dialog_new_with_buttons("Open trace ?",
1103       GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(button))),
1104       GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
1105       GTK_STOCK_YES,GTK_RESPONSE_ACCEPT,
1106       GTK_STOCK_NO,GTK_RESPONSE_REJECT,
1107       NULL);
1108   label = gtk_label_new("Do you want to open the trace in LTTV ?");
1109   gtk_widget_show(label);
1110
1111   gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialogue)->vbox),
1112       label);
1113
1114   id = gtk_dialog_run(GTK_DIALOG(dialogue));
1115
1116   switch(id){
1117     case GTK_RESPONSE_ACCEPT:
1118       {
1119         create_main_window_with_trace_list(trace_list);
1120       }
1121       break;
1122     case GTK_RESPONSE_REJECT:
1123     default:
1124       break;
1125   }
1126   gtk_widget_destroy(dialogue);
1127   g_slist_free(trace_list);
1128 }
1129
1130 void arm_clicked (GtkButton *button, gpointer user_data)
1131 {
1132   ControlData *tcd = (ControlData*)user_data;
1133
1134   const gchar *username = gtk_entry_get_text(GTK_ENTRY(tcd->username_entry));
1135   const gchar *password = gtk_entry_get_text(GTK_ENTRY(tcd->password_entry));
1136   const gchar *ltt_armall_path =
1137     gtk_entry_get_text(GTK_ENTRY(tcd->ltt_armall_path_entry));
1138
1139   /* Setup arguments to su */
1140   /* child */
1141   gchar args[MAX_ARGS_LEN];
1142   gint args_left = MAX_ARGS_LEN - 1; /* for \0 */
1143
1144   args[0] = '\0';
1145
1146   /* Command */
1147   strncat(args, "exec", args_left);
1148   args_left = MAX_ARGS_LEN - strlen(args) - 1;
1149
1150   /* space */
1151   strncat(args, " ", args_left);
1152   args_left = MAX_ARGS_LEN - strlen(args) - 1;
1153
1154   if(strcmp(ltt_armall_path, "") == 0)
1155     strncat(args, "ltt-armall", args_left);
1156   else
1157     strncat(args, ltt_armall_path, args_left);
1158   args_left = MAX_ARGS_LEN - strlen(args) - 1;
1159
1160   int retval = execute_command(args, username, password, "");
1161   if(retval) {
1162     gchar msg[256];
1163     guint msg_left = 256;
1164
1165     strcpy(msg, "A problem occured when executing the su command : ");
1166     msg_left = 256 - strlen(msg) - 1;
1167     strncat(msg, strerror(retval), msg_left);
1168     GtkWidget *dialogue =
1169       gtk_message_dialog_new(
1170         GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(button))),
1171         GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
1172         GTK_MESSAGE_ERROR,
1173         GTK_BUTTONS_OK,
1174         msg);
1175     gtk_dialog_run(GTK_DIALOG(dialogue));
1176     gtk_widget_destroy(dialogue);
1177   }
1178
1179 }
1180
1181 void disarm_clicked (GtkButton *button, gpointer user_data)
1182 {
1183   ControlData *tcd = (ControlData*)user_data;
1184
1185   const gchar *username = gtk_entry_get_text(GTK_ENTRY(tcd->username_entry));
1186   const gchar *password = gtk_entry_get_text(GTK_ENTRY(tcd->password_entry));
1187   const gchar *ltt_disarmall_path =
1188     gtk_entry_get_text(GTK_ENTRY(tcd->ltt_disarmall_path_entry));
1189
1190   /* Setup arguments to su */
1191   /* child */
1192   gchar args[MAX_ARGS_LEN];
1193   gint args_left = MAX_ARGS_LEN - 1; /* for \0 */
1194
1195   args[0] = '\0';
1196
1197   /* Command */
1198   strncat(args, "exec", args_left);
1199   args_left = MAX_ARGS_LEN - strlen(args) - 1;
1200
1201   /* space */
1202   strncat(args, " ", args_left);
1203   args_left = MAX_ARGS_LEN - strlen(args) - 1;
1204
1205   if(strcmp(ltt_disarmall_path, "") == 0)
1206     strncat(args, "ltt-disarmall", args_left);
1207   else
1208     strncat(args, ltt_disarmall_path, args_left);
1209   args_left = MAX_ARGS_LEN - strlen(args) - 1;
1210
1211   int retval = execute_command(args, username, password, "");
1212   if(retval) {
1213     gchar msg[256];
1214     guint msg_left = 256;
1215
1216     strcpy(msg, "A problem occured when executing the su command : ");
1217     msg_left = 256 - strlen(msg) - 1;
1218     strncat(msg, strerror(retval), msg_left);
1219     GtkWidget *dialogue =
1220       gtk_message_dialog_new(
1221         GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(button))),
1222         GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT,
1223         GTK_MESSAGE_ERROR,
1224         GTK_BUTTONS_OK,
1225         msg);
1226     gtk_dialog_run(GTK_DIALOG(dialogue));
1227     gtk_widget_destroy(dialogue);
1228   }
1229
1230 }
1231
1232
1233 /**
1234  *  @fn GtkWidget* h_guicontrol(Tab*)
1235  *
1236  *  Control Module's constructor hook
1237  *
1238  *  This constructor is given as a parameter to the menuitem and toolbar button
1239  *  registration. It creates the list.
1240  *  @param tab A pointer to the parent window.
1241  *  @return The widget created.
1242  */
1243 GtkWidget *
1244 h_guicontrol(LttvPlugin *plugin)
1245 {
1246   LttvPluginTab *ptab = LTTV_PLUGIN_TAB(plugin);
1247   ControlData* f = gui_control(ptab);
1248
1249   return NULL;
1250 }
1251
1252 /**
1253  *  @fn static void init()
1254  *
1255  *  This function initializes the Filter Viewer functionnality through the
1256  *  gtkTraceSet API.
1257  */
1258 static void init() {
1259
1260   lttvwindow_register_constructor("guicontrol",
1261                                   "/",
1262                                   "Insert Tracing Control Module",
1263                                   hTraceControlInsert_xpm,
1264                                   "Insert Tracing Control Module",
1265                                   h_guicontrol);
1266 }
1267
1268 /**
1269  *  @fn void control_destroy_walk(gpointer,gpointer)
1270  *
1271  *  Initiate the destruction of the current gui module
1272  *  on the GTK Interface
1273  */
1274 void
1275 control_destroy_walk(gpointer data, gpointer user_data)
1276 {
1277   ControlData *tcd = (ControlData*)data;
1278
1279   g_debug("traceontrol.c : control_destroy_walk, %p", tcd);
1280
1281   /* May already have been done by GTK window closing */
1282   if(GTK_IS_WIDGET(guicontrol_get_widget(tcd)))
1283     gtk_widget_destroy(guicontrol_get_widget(tcd));
1284 }
1285
1286 /**
1287  *  @fn static void destroy()
1288  *  @brief plugin's destroy function
1289  *
1290  *  This function releases the memory reserved by the module and unregisters
1291  *  everything that has been registered in the gtkTraceSet API.
1292  */
1293 static void destroy() {
1294
1295   g_slist_foreach(g_control_list, control_destroy_walk, NULL );
1296
1297   lttvwindow_unregister_constructor(h_guicontrol);
1298
1299 }
1300
1301
1302 LTTV_MODULE("guitracecontrol", "Trace Control Window", \
1303     "Graphical module that let user control kernel tracing", \
1304     init, destroy, "lttvwindow")
1305