libanjuta/anjuta-launcher.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * anjuta-launcher.c
   4  * Copyright (C) 2003 Naba Kumar  <naba@gnome.org>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Library General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License along with this library; if not, write to the Free
  18  * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  */
  20
  21 /**
  22  * SECTION:anjuta-launcher
  23  * @short_description: External process launcher with async input/output
  24  * @see_also:
  25  * @stability: Unstable
  26  * @include: libanjuta/anjuta-launcher.h
  27  *
  28  */
  29
  30 #ifdef HAVE_CONFIG_H
  31 #  include <config.h>
  32 #endif
  33
  34 #include <errno.h>
  35 #include <unistd.h>
  36 #include <fcntl.h>
  37 #include <signal.h>
  38
  39 /* not sure if any platform has more than one of these, so play it
  40    safe and use any-and-all-found rather than elif fallback */
  41 #ifdef HAVE_LIBUTIL_H
  42 #  include <libutil.h>
  43 #endif
  44 #ifdef HAVE_UTIL_H
  45 #  include <util.h>
  46 #endif
  47 #ifdef HAVE_PTY_H
  48 #  include <pty.h>
  49 #endif
  50
  51 #include "anjuta-utils-priv.h"
  52
  53 #include <assert.h>
  54 #include <termios.h>
  55
  56 #include <string.h>
  57 #include <time.h>
  58 #include <glib/gi18n.h>
  59 #include <glib.h>
  60
  61 #include "anjuta-utils.h"
  62 #include "anjuta-marshal.h"
  63 #include "resources.h"
  64 #include "anjuta-launcher.h"
  65 #include "anjuta-debug.h"
  66
  67 #define ANJUTA_PIXMAP_PASSWORD "password.png"
  68 #define FILE_BUFFER_SIZE 1024
  69 #define FILE_INPUT_BUFFER_SIZE  (1024 * 1024 * 4)
  70 #ifndef __MAX_BAUD
  71 #  if defined(B460800)
  72 #    define __MAX_BAUD B460800
  73 #  elif defined(B307200)
  74 #    define __MAX_BAUD B307200
  75 #  elif defined(B256000)
  76 #    define __MAX_BAUD B256000
  77 #  else
  78 #    define __MAX_BAUD B230400
  79 #  endif
  80 #endif
  81
  82 /*
  83 static gboolean
  84 anjuta_launcher_pty_check_child_exit_code (AnjutaLauncher *launcher,
  85                                                                                    const gchar* line);
  86 */
  87 struct _AnjutaLauncherPriv
  88 {
  89         /*
  90         *  Busy flag is TRUE if the Launcher
  91         *  is currently executing a child.
  92         */
  93         gboolean busy;
  94
  95         /* These flags are used to synchronize the IO operations. */
  96         gboolean stdout_is_done;
  97         gboolean stderr_is_done;
  98
  99         /* GIO channels */
 100         GIOChannel *stdout_channel;
 101         GIOChannel *stderr_channel;
 102         /*GIOChannel *stdin_channel;*/
 103         GIOChannel *pty_channel;
 104
 105         /* GIO watch handles */
 106         guint stdout_watch;
 107         guint stderr_watch;
 108         guint pty_watch;
 109
 110         /* Output line buffers */
 111         gchar *stdout_buffer;
 112         gchar *stderr_buffer;
 113
 114         /* Output of the pty is constantly stored here.*/
 115         gchar *pty_output_buffer;
 116
 117         /* Terminal echo */
 118         gboolean terminal_echo_on;
 119
 120         /* The child */
 121         pid_t child_pid;
 122         guint source;
 123         gint child_status;
 124         gboolean child_has_terminated;
 125
 126         /* Synchronization in progress */
 127         guint completion_check_timeout;
 128
 129         /* Terminate child on child exit */
 130         gboolean terminate_on_exit;
 131
 132         /* Start time of execution */
 133         time_t start_time;
 134
 135         /* Should the outputs be buffered */
 136         gboolean buffered_output;
 137
 138         /* Should we check for password prompts in stdout and pty */
 139         gboolean check_for_passwd_prompt;
 140
 141         /* Output callback */
 142         AnjutaLauncherOutputCallback output_callback;
 143
 144         /* Callback data */
 145         gpointer callback_data;
 146
 147         /* Encondig */
 148         gboolean custom_encoding;
 149         gchar* encoding;
 150
 151         /* Env */
 152         GHashTable* env;
 153 };
 154
 155 enum
 156 {
 157         /* OUTPUT_ARRIVED_SIGNAL, */
 158         CHILD_EXITED_SIGNAL,
 159         BUSY_SIGNAL,
 160         LAST_SIGNAL
 161 };
 162
 163 static void anjuta_launcher_class_init (AnjutaLauncherClass * klass);
 164 static void anjuta_launcher_init (AnjutaLauncher * obj);
 165 static gboolean anjuta_launcher_call_execution_done (gpointer data);
 166 static gboolean anjuta_launcher_check_for_execution_done (gpointer data);
 167 static void anjuta_launcher_execution_done_cleanup (AnjutaLauncher *launcher,
 168                                                                                                         gboolean emit_signal);
 169
 170 static gboolean is_password_prompt(const gchar* line);
 171
 172 static guint launcher_signals[LAST_SIGNAL] = { 0 };
 173 static AnjutaLauncherClass *parent_class;
 174
 175 static void
 176 anjuta_launcher_initialize (AnjutaLauncher *obj)
 177 {
 178         /* Busy flag */
 179         obj->priv->busy = FALSE;
 180
 181         /* These flags are used to synchronize the IO operations. */
 182         obj->priv->stdout_is_done = FALSE;
 183         obj->priv->stderr_is_done = FALSE;
 184
 185         /* GIO channels */
 186         obj->priv->stdout_channel = NULL;
 187         obj->priv->stderr_channel = NULL;
 188         obj->priv->pty_channel = NULL;
 189
 190         /* Output line buffers */
 191         obj->priv->stdout_buffer = NULL;
 192         obj->priv->stderr_buffer = NULL;
 193
 194         /* Pty buffer */
 195         obj->priv->pty_output_buffer = NULL;
 196
 197         obj->priv->terminal_echo_on = TRUE;
 198
 199         /* The child */
 200         obj->priv->child_pid = 0;
 201         obj->priv->child_status = -1;
 202         obj->priv->child_has_terminated = TRUE;
 203         obj->priv->source = 0;
 204
 205         /* Synchronization in progress */
 206         obj->priv->completion_check_timeout = 0;
 207
 208         /* Terminate child on child exit */
 209         obj->priv->terminate_on_exit = FALSE;
 210
 211         /* Start time of execution */
 212         obj->priv->start_time = 0;
 213
 214         obj->priv->buffered_output = TRUE;
 215         obj->priv->check_for_passwd_prompt = TRUE;
 216
 217         /* Output callback */
 218         obj->priv->output_callback = NULL;
 219         obj->priv->callback_data = NULL;
 220
 221         /* Encoding */
 222         obj->priv->custom_encoding = FALSE;
 223         obj->priv->encoding = NULL;
 224
 225         /* Env */
 226         obj->priv->env = g_hash_table_new_full (g_str_hash, g_str_equal,
 227                                                                                         g_free, g_free);
 228 }
 229
 230 GType
 231 anjuta_launcher_get_type ()
 232 {
 233         static GType obj_type = 0;
 234
 235         if (!obj_type)
 236         {
 237                 static const GTypeInfo obj_info =
 238                 {
 239                         sizeof (AnjutaLauncherClass),
 240                         (GBaseInitFunc) NULL,
 241                         (GBaseFinalizeFunc) NULL,
 242                         (GClassInitFunc) anjuta_launcher_class_init,
 243                         (GClassFinalizeFunc) NULL,
 244                         NULL,           /* class_data */
 245                         sizeof (AnjutaLauncher),
 246                         0,              /* n_preallocs */
 247                         (GInstanceInitFunc) anjuta_launcher_init,
 248                         NULL            /* value_table */
 249                 };
 250                 obj_type = g_type_register_static (G_TYPE_OBJECT,
 251                                                    "AnjutaLauncher", &obj_info, 0);
 252         }
 253         return obj_type;
 254 }
 255
 256 static void
 257 anjuta_launcher_dispose (GObject *obj)
 258 {
 259         AnjutaLauncher *launcher = ANJUTA_LAUNCHER (obj);
 260         if (anjuta_launcher_is_busy (launcher))
 261         {
 262                 g_source_remove (launcher->priv->source);
 263                 launcher->priv->source = 0;
 264
 265                 anjuta_launcher_execution_done_cleanup (launcher, FALSE);
 266
 267                 launcher->priv->busy = FALSE;
 268
 269         }
 270         G_OBJECT_CLASS (parent_class)->dispose (obj);
 271 }
 272
 273 static void
 274 anjuta_launcher_finalize (GObject *obj)
 275 {
 276         AnjutaLauncher *launcher = ANJUTA_LAUNCHER (obj);
 277         if (launcher->priv->custom_encoding && launcher->priv->encoding)
 278                 g_free (launcher->priv->encoding);
 279
 280         g_hash_table_destroy (launcher->priv->env);
 281
 282         g_free (launcher->priv);
 283         G_OBJECT_CLASS (parent_class)->finalize (obj);
 284 }
 285
 286 static void
 287 anjuta_launcher_class_init (AnjutaLauncherClass * klass)
 288 {
 289         GObjectClass *object_class;
 290         g_return_if_fail (klass != NULL);
 291         object_class = (GObjectClass *) klass;
 292
 293         /* DEBUG_PRINT ("%s", "Initializing launcher class"); */
 294
 295         parent_class = g_type_class_peek_parent (klass);
 296
 297         /**
 298          * AnjutaLauncher::child-exited:
 299          * @launcher: a #AnjutaLancher object.
 300          * @child_pid: process ID of the child
 301          * @status: status as returned by waitpid function
 302          * @time: time in seconds taken by the child
 303          *
 304          * Emitted when the child has exited and all i/o channels have
 305          * been closed. If the terminate on exit flag is set, the i/o
 306          * channels are automatically closed when the child exit.
 307          * You need to use WEXITSTATUS and friend to get the child exit
 308          * code from the status returned.
 309          **/
 310         launcher_signals[CHILD_EXITED_SIGNAL] =
 311                 g_signal_new ("child-exited",
 312                                         G_TYPE_FROM_CLASS (object_class),
 313                                         G_SIGNAL_RUN_FIRST,
 314                                         G_STRUCT_OFFSET (AnjutaLauncherClass,
 315                                                                          child_exited),
 316                                         NULL, NULL,
 317                                         anjuta_cclosure_marshal_VOID__INT_INT_ULONG,
 318                                         G_TYPE_NONE, 3, G_TYPE_INT,
 319                                         G_TYPE_INT, G_TYPE_ULONG);
 320
 321         /**
 322          * AnjutaLauncher::busy:
 323          * @launcher: a #AnjutaLancher object.
 324          * @busy: %TRUE is a child is currently running
 325          *
 326          * Emitted when a child starts after a call to one execute function
 327          * (busy is %TRUE) or when a child exits and all i/o channels are
 328          * closed (busy is %FALSE).
 329          **/
 330         launcher_signals[BUSY_SIGNAL] =
 331                 g_signal_new ("busy",
 332                                         G_TYPE_FROM_CLASS (object_class),
 333                                         G_SIGNAL_RUN_FIRST,
 334                                         G_STRUCT_OFFSET (AnjutaLauncherClass,
 335                                                                          busy),
 336                                         NULL, NULL,
 337                                         anjuta_cclosure_marshal_VOID__BOOLEAN,
 338                                         G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
 339
 340         object_class->dispose = anjuta_launcher_dispose;
 341         object_class->finalize = anjuta_launcher_finalize;
 342 }
 343
 344 static void
 345 anjuta_launcher_init (AnjutaLauncher * obj)
 346 {
 347         g_return_if_fail (obj != NULL);
 348         obj->priv = g_new0 (AnjutaLauncherPriv, 1);
 349         anjuta_launcher_initialize (obj);
 350 }
 351
 352 /**
 353  * anjuta_launcher_is_busy:
 354  * @launcher: a #AnjutaLancher object.
 355  *
 356  * Tells if the laucher is currently executing any command.
 357  *
 358  * Return value: %TRUE if launcher is busy, otherwise %FALSE.
 359  */
 360 gboolean
 361 anjuta_launcher_is_busy (AnjutaLauncher *launcher)
 362 {
 363         return launcher->priv->busy;
 364 }
 365
 366 static void
 367 anjuta_launcher_set_busy (AnjutaLauncher *launcher, gboolean flag)
 368 {
 369         gboolean old_busy = launcher->priv->busy;
 370         launcher->priv->busy = flag;
 371         if (old_busy != flag)
 372                 g_signal_emit_by_name (G_OBJECT (launcher), "busy", flag);
 373 }
 374
 375 /**
 376  * anjuta_launcher_send_stdin:
 377  * @launcher: a #AnjutaLancher object.
 378  * @input_str: The string to send to STDIN of the process.
 379  *
 380  * Sends a string to Standard input of the process currently being executed.
 381  */
 382 void
 383 anjuta_launcher_send_stdin (AnjutaLauncher *launcher, const gchar * input_str)
 384 {
 385         g_return_if_fail (launcher);
 386         g_return_if_fail (input_str);
 387
 388         anjuta_launcher_send_ptyin (launcher, input_str);
 389 }
 390
 391 /**
 392  * anjuta_launcher_send_stdin_eof:
 393  * @launcher: a #AnjutaLancher object.
 394  *
 395  * Sends a EOF to Standard input of the process currently being executed.
 396  */
 397
 398 void
 399 anjuta_launcher_send_stdin_eof (AnjutaLauncher *launcher)
 400 {
 401         GError* err = NULL;
 402         g_io_channel_shutdown (launcher->priv->pty_channel, TRUE,
 403                                                    &err);
 404         g_io_channel_unref (launcher->priv->pty_channel);
 405         launcher->priv->pty_channel = NULL;
 406
 407         if (err)
 408         {
 409                 g_warning ("g_io_channel_shutdown () failed: %s", err->message);
 410         }
 411 }
 412
 413 /**
 414  * anjuta_launcher_send_ptyin:
 415  * @launcher: a #AnjutaLancher object.
 416  * @input_str: The string to send to PTY of the process.
 417  *
 418  * Sends a string to TTY input of the process currently being executed.
 419  * Mostly useful for entering passwords and other inputs which are directly
 420  * read from TTY input of the process.
 421  */
 422 void
 423 anjuta_launcher_send_ptyin (AnjutaLauncher *launcher, const gchar * input_str)
 424 {
 425         gsize bytes_written = 0;
 426         GError *err = NULL;
 427
 428         g_return_if_fail (launcher);
 429         g_return_if_fail (input_str);
 430         g_return_if_fail (launcher->priv->pty_channel != NULL);
 431
 432         if (strlen (input_str) == 0)
 433                 return;
 434
 435         do
 436         {
 437                 g_io_channel_write_chars (launcher->priv->pty_channel,
 438                                                           input_str, strlen (input_str),
 439                                                           &bytes_written, &err);
 440                 g_io_channel_flush (launcher->priv->pty_channel, NULL);
 441                 if (err)
 442                 {
 443                         g_warning ("Error encountered while writing to PTY!. %s",
 444                                            err->message);
 445                         g_error_free (err);
 446
 447                         return;
 448                 }
 449                 input_str += bytes_written;
 450         }
 451         while (*input_str);
 452 }
 453
 454 /**
 455  * anjuta_launcher_reset:
 456  * @launcher: a #AnjutaLancher object.
 457  *
 458  * Resets the launcher and kills (SIGTERM) current process, if it is still
 459  * executing.
 460  */
 461 void
 462 anjuta_launcher_reset (AnjutaLauncher *launcher)
 463 {
 464         if (anjuta_launcher_is_busy (launcher) &&
 465             launcher->priv->child_pid)
 466                 kill (launcher->priv->child_pid, SIGTERM);
 467 }
 468
 469 /**
 470  * anjuta_launcher_signal:
 471  * @launcher: a #AnjutaLancher object.
 472  * @sig: kernel signal ID (e.g. SIGTERM).
 473  *
 474  * Sends a kernel signal to the process that is being executed.
 475  */
 476 void
 477 anjuta_launcher_signal (AnjutaLauncher *launcher, int sig)
 478 {
 479         if (launcher->priv->child_pid)
 480                 kill (launcher->priv->child_pid, sig);
 481 }
 482
 483 /**
 484  * anjuta_launcher_get_child_pid:
 485  * @launcher: a #AnjutaLancher object.
 486  *
 487  * Gets the Process ID of the child being executed.
 488  *
 489  * Return value: Process ID of the child.
 490  */
 491 pid_t
 492 anjuta_launcher_get_child_pid (AnjutaLauncher *launcher)
 493 {
 494   if (anjuta_launcher_is_busy (launcher))
 495     return launcher->priv->child_pid;
 496   else
 497     return -1;
 498 }
 499
 500 static void
 501 anjuta_launcher_synchronize (AnjutaLauncher *launcher)
 502 {
 503         if (launcher->priv->child_has_terminated &&
 504                 launcher->priv->stdout_is_done &&
 505                 launcher->priv->stderr_is_done)
 506         {
 507                 if (launcher->priv->completion_check_timeout != 0)
 508                         g_source_remove (launcher->priv->completion_check_timeout);
 509                 launcher->priv->completion_check_timeout =
 510                         /* Use a low priority timer to make sure all pending I/O are flushed out */
 511                     g_timeout_add_full (G_PRIORITY_DEFAULT_IDLE, 50, anjuta_launcher_check_for_execution_done,
 512                                                          launcher, NULL);
 513         }
 514
 515         /* This case is not very good, but it blocks the whole IDE
 516         because we never new if the child has finished */
 517         else if (launcher->priv->stdout_is_done &&
 518                          launcher->priv->stderr_is_done)
 519         {
 520                 /* DEBUG_PRINT ("%s", "Child has't exited yet waiting for 200ms"); */
 521                 if (launcher->priv->completion_check_timeout != 0)
 522                         g_source_remove (launcher->priv->completion_check_timeout);
 523                 launcher->priv->completion_check_timeout =
 524                         /* Use a low priority timer to make sure all pending I/O are flushed out */
 525                     g_timeout_add_full(G_PRIORITY_DEFAULT_IDLE, 200, anjuta_launcher_check_for_execution_done,
 526                                                         launcher, NULL);
 527         }
 528         /* Add this case for gdb. It creates child inheriting gdb
 529          * pipes which are not closed if gdb crashes */
 530         else if (launcher->priv->child_has_terminated &&
 531                         launcher->priv->terminate_on_exit)
 532         {
 533                 if (launcher->priv->completion_check_timeout != 0)
 534                         g_source_remove (launcher->priv->completion_check_timeout);
 535                 launcher->priv->completion_check_timeout =
 536                         /* Use a low priority timer to make sure all pending I/O are flushed out */
 537                         g_idle_add ( anjuta_launcher_call_execution_done,
 538                                                  launcher);
 539         }
 540 }
 541
 542 /* Password dialog */
 543 static GtkWidget*
 544 create_password_dialog (const gchar* prompt)
 545 {
 546         GtkWidget *dialog;
 547         GtkWidget *hbox;
 548         GtkWidget *box;
 549         GtkWidget *icon;
 550         GtkWidget *label;
 551         GtkWidget *entry;
 552
 553         g_return_val_if_fail (prompt, NULL);
 554
 555         dialog = gtk_dialog_new_with_buttons (prompt,
 556                                 NULL, //FIXME: Pass the parent window here
 557                                                         // for transient purpose.
 558                                 GTK_DIALOG_DESTROY_WITH_PARENT,
 559                                 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 560                                 GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
 561         gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
 562
 563         gtk_window_set_wmclass (GTK_WINDOW (dialog), "launcher-password-prompt",
 564                                                         "anjuta");
 565         hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
 566         gtk_widget_show (hbox);
 567         gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG(dialog))), hbox);
 568
 569         icon = anjuta_res_get_image (ANJUTA_PIXMAP_PASSWORD);
 570         gtk_widget_show (icon);
 571         gtk_box_pack_start (GTK_BOX(hbox), icon, TRUE, TRUE, 0);
 572
 573         if (strlen (prompt) < 20) {
 574                 box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
 575         } else {
 576                 box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
 577         }
 578         gtk_widget_show (box);
 579         gtk_box_pack_start (GTK_BOX (hbox), box, TRUE, TRUE, 0);
 580
 581         label = gtk_label_new (_(prompt));
 582         gtk_widget_show (label);
 583         gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
 584
 585         entry = gtk_entry_new ();
 586         gtk_widget_show (entry);
 587         gtk_entry_set_visibility (GTK_ENTRY (entry), FALSE);
 588         gtk_box_pack_start (GTK_BOX (box), entry, FALSE, FALSE, 0);
 589
 590         g_object_ref (entry);
 591         g_object_set_data_full (G_OBJECT (dialog), "password_entry",
 592                                                           g_object_ref (entry),
 593                                                           g_object_unref);
 594         gtk_widget_grab_focus (entry);
 595         gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
 596
 597         return dialog;
 598 }
 599
 600 /* pty buffer check for password authentication */
 601 static void
 602 anjuta_launcher_check_password_real (AnjutaLauncher *launcher,
 603                                                                          const gchar* last_line)
 604 {
 605         if (anjuta_launcher_is_busy (launcher) == FALSE)
 606                 return;
 607
 608         if (last_line) {
 609
 610                 /* DEBUG_PRINT ("(In password) Last line = %s", last_line); */
 611                 if (is_password_prompt(last_line)) {
 612                         /* Password prompt detected */
 613                         GtkWidget* dialog;
 614                         gint button;
 615                         const gchar* passwd;
 616                         gchar* line;
 617
 618                         dialog = create_password_dialog (last_line);
 619                         button = gtk_dialog_run (GTK_DIALOG(dialog));
 620                         switch (button) {
 621                                 case GTK_RESPONSE_OK:
 622                                         passwd = gtk_entry_get_text (
 623                                                 GTK_ENTRY (g_object_get_data (G_OBJECT (dialog),
 624                                                                         "password_entry")));
 625                                         line = g_strconcat (passwd, "\n", NULL);
 626                                         anjuta_launcher_send_ptyin (launcher, line);
 627                                         g_free (line);
 628                                         break;
 629                                 case GTK_RESPONSE_CANCEL:
 630                                         anjuta_launcher_reset (launcher);
 631                                         break;
 632                                 default:
 633                                         break;
 634                         }
 635                         gtk_widget_destroy (dialog);
 636                 }
 637         }
 638 }
 639
 640 static void
 641 anjuta_launcher_check_password (AnjutaLauncher *launcher, const gchar *chars)
 642 {
 643         glong start, end;
 644         gchar *last_line;
 645
 646         if (!chars || strlen(chars) <= 0)
 647                 return;
 648
 649         /* DEBUG_PRINT ("Chars buffer = %s", chars); */
 650         start = end = strlen (chars);
 651         while (start > 0 && chars[start-1] != '\n') start--;
 652
 653         if (end > start)
 654         {
 655                 last_line = g_strndup (&chars[start], end - start + 1);
 656
 657                 /* DEBUG_PRINT ("Last line = %s", last_line); */
 658                 /* Checks for password, again */
 659                 anjuta_launcher_check_password_real (launcher, last_line);
 660                 g_free (last_line);
 661         }
 662 }
 663
 664 static gboolean
 665 is_password_prompt (const gchar* line)
 666 {
 667         const gchar* regex = "[Pp]assword.*:";
 668         /*
 669          * Translators: This regex should match the password prompts of
 670          * at least the "su" and the "sudo" command line utility in your
 671          * language and possible other things like "ssh".
 672          * More information on the regular expression syntax can be
 673          * found at http://library.gnome.org/devel/glib/unstable/glib-regex-syntax.html
 674          */
 675         const gchar* i18n_regex = _("[Pp]assword.*:");
 676         if (g_regex_match_simple (regex, line, 0, 0))
 677                 return TRUE;
 678         else if (g_regex_match_simple (i18n_regex, line, 0, 0))
 679                 return TRUE;
 680
 681         return FALSE;
 682 }
 683
 684 static void
 685 anjuta_launcher_buffered_output (AnjutaLauncher *launcher,
 686                                                                  AnjutaLauncherOutputType output_type,
 687                                                                  const gchar *chars)
 688 {
 689         gchar *all_lines;
 690         gchar *incomplete_line;
 691         gchar **buffer;
 692
 693         g_return_if_fail (chars != NULL);
 694         g_return_if_fail (strlen (chars) > 0);
 695
 696         if (launcher->priv->output_callback == NULL)
 697                 return;
 698         if (launcher->priv->buffered_output == FALSE)
 699         {
 700                 (launcher->priv->output_callback)(launcher, output_type, chars,
 701                                                                                   launcher->priv->callback_data);
 702                 return;
 703         }
 704         switch (output_type)
 705         {
 706         case ANJUTA_LAUNCHER_OUTPUT_STDOUT:
 707                 buffer = &launcher->priv->stdout_buffer;
 708                 break;
 709         case ANJUTA_LAUNCHER_OUTPUT_STDERR:
 710                 buffer = &launcher->priv->stderr_buffer;
 711                 break;
 712         default:
 713                 g_warning ("Should not reach here");
 714                 return;
 715         }
 716         if (*buffer)
 717                 all_lines = g_strconcat (*buffer, chars, NULL);
 718         else
 719                 all_lines = g_strdup (chars);
 720
 721         /* Buffer the last incomplete line */
 722         incomplete_line = all_lines + strlen (all_lines);
 723         while (incomplete_line > all_lines &&
 724                    *incomplete_line != '\n')
 725         {
 726                 incomplete_line = g_utf8_prev_char (incomplete_line);
 727         }
 728         if (*incomplete_line == '\n')
 729                 incomplete_line++;
 730
 731         /* Update line buffer */
 732         g_free(*buffer);
 733         *buffer = NULL;
 734         if (strlen(incomplete_line))
 735         {
 736                 *buffer = g_strdup (incomplete_line);
 737                 /* DEBUG_PRINT ("Line buffer for %d: %s", output_type, incomplete_line); */
 738         }
 739         /* Check for password prompt */
 740         if (launcher->priv->check_for_passwd_prompt)
 741                 anjuta_launcher_check_password (launcher, incomplete_line);
 742
 743         /* Deliver complete lines */
 744         *incomplete_line = '\0';
 745         if (strlen (all_lines) > 0)
 746                 (launcher->priv->output_callback)(launcher, output_type, all_lines,
 747                                                                                   launcher->priv->callback_data);
 748         g_free (all_lines);
 749 }
 750
 751 static gboolean
 752 anjuta_launcher_scan_output (GIOChannel *channel, GIOCondition condition,
 753                                                          AnjutaLauncher *launcher)
 754 {
 755         gsize n;
 756         gchar buffer[FILE_BUFFER_SIZE];
 757         gboolean ret = TRUE;
 758
 759         if (condition & G_IO_IN)
 760         {
 761                 GError *err = NULL;
 762                 do
 763                 {
 764                         g_io_channel_read_chars (channel, buffer, FILE_BUFFER_SIZE-1, &n, &err);
 765                         if (n > 0) /* There is output */
 766                         {
 767                                 gchar *utf8_chars = NULL;
 768                                 buffer[n] = '\0';
 769                                 if (!launcher->priv->custom_encoding)
 770                                         utf8_chars = anjuta_util_convert_to_utf8 (buffer);
 771                                 else
 772                                         utf8_chars = g_strdup(buffer);
 773                                 anjuta_launcher_buffered_output (launcher,
 774                                                                                                  ANJUTA_LAUNCHER_OUTPUT_STDOUT,
 775                                                                                                  utf8_chars);
 776                                 g_free (utf8_chars);
 777                         }
 778                         /* Ignore illegal characters */
 779                         if (err && err->domain == G_CONVERT_ERROR)
 780                         {
 781                                 g_error_free (err);
 782                                 err = NULL;
 783                         }
 784                         /* The pipe is closed on the other side */
 785                         /* if not related to non blocking read or interrupted syscall */
 786                         else if (err && errno != EAGAIN && errno != EINTR)
 787                         {
 788                                 launcher->priv->stdout_is_done = TRUE;
 789                                 anjuta_launcher_synchronize (launcher);
 790                                 ret = FALSE;
 791                         }
 792                 /* Read next chars if buffer was too small
 793                  * (the maximum length of one character is 6 bytes) */
 794                 } while (!err && (n > FILE_BUFFER_SIZE - 7));
 795                 if (err)
 796                         g_error_free (err);
 797         }
 798         if ((condition & G_IO_ERR) || (condition & G_IO_HUP))
 799         {
 800                 DEBUG_PRINT ("%s", "launcher.c: STDOUT pipe closed");
 801                 launcher->priv->stdout_is_done = TRUE;
 802                 anjuta_launcher_synchronize (launcher);
 803                 ret = FALSE;
 804         }
 805         return ret;
 806 }
 807
 808 static gboolean
 809 anjuta_launcher_scan_error (GIOChannel *channel, GIOCondition condition,
 810                                                         AnjutaLauncher *launcher)
 811 {
 812         gsize n;
 813         gchar buffer[FILE_BUFFER_SIZE];
 814         gboolean ret = TRUE;
 815
 816         if (condition & G_IO_IN)
 817         {
 818                 GError *err = NULL;
 819                 do
 820                 {
 821                         g_io_channel_read_chars (channel, buffer, FILE_BUFFER_SIZE-1, &n, &err);
 822                         if (n > 0) /* There is stderr output */
 823                         {
 824                                 gchar *utf8_chars;
 825                                 buffer[n] = '\0';
 826                                 utf8_chars = anjuta_util_convert_to_utf8 (buffer);
 827                                 anjuta_launcher_buffered_output (launcher,
 828                                                                                                  ANJUTA_LAUNCHER_OUTPUT_STDERR,
 829                                                                                                  utf8_chars);
 830                                 g_free (utf8_chars);
 831                         }
 832                         /* Ignore illegal characters */
 833                         if (err && err->domain == G_CONVERT_ERROR)
 834                         {
 835                                 g_error_free (err);
 836                                 err = NULL;
 837                         }
 838                         /* The pipe is closed on the other side */
 839                         /* if not related to non blocking read or interrupted syscall */
 840                         else if (err && errno != EAGAIN && errno != EINTR)
 841                         {
 842
 843                                 launcher->priv->stderr_is_done = TRUE;
 844                                 anjuta_launcher_synchronize (launcher);
 845                                 ret = FALSE;
 846                         }
 847                 /* Read next chars if buffer was too small
 848                  * (the maximum length of one character is 6 bytes) */
 849                 } while (!err && (n > FILE_BUFFER_SIZE - 7));
 850                 if (err)
 851                         g_error_free (err);
 852         }
 853         if ((condition & G_IO_ERR) || (condition & G_IO_HUP))
 854         {
 855                 DEBUG_PRINT ("%s", "launcher.c: STDERR pipe closed");
 856                 launcher->priv->stderr_is_done = TRUE;
 857                 anjuta_launcher_synchronize (launcher);
 858                 ret = FALSE;
 859         }
 860         return ret;
 861 }
 862
 863 static gboolean
 864 anjuta_launcher_scan_pty (GIOChannel *channel, GIOCondition condition,
 865                                                   AnjutaLauncher *launcher)
 866 {
 867         gsize n;
 868         gchar buffer[FILE_BUFFER_SIZE];
 869         gboolean ret = TRUE;
 870
 871         if (condition & G_IO_IN)
 872         {
 873                 GError *err = NULL;
 874                 do
 875                 {
 876                         g_io_channel_read_chars (channel, buffer, FILE_BUFFER_SIZE-1, &n, &err);
 877                         if (n > 0) /* There is stderr output */
 878                         {
 879                                 gchar *utf8_chars;
 880                                 gchar *old_str = launcher->priv->pty_output_buffer;
 881                                 buffer[n] = '\0';
 882                                 utf8_chars = anjuta_util_convert_to_utf8 (buffer);
 883                                 if (old_str)
 884                                 {
 885                                         gchar *str = g_strconcat (old_str, utf8_chars, NULL);
 886                                         launcher->priv->pty_output_buffer = str;
 887                                         g_free (old_str);
 888                                 }
 889                                 else
 890                                         launcher->priv->pty_output_buffer = g_strdup (utf8_chars);
 891                                 g_free (utf8_chars);
 892                         }
 893                         /* Ignore illegal characters */
 894                         if (err && err->domain == G_CONVERT_ERROR)
 895                         {
 896                                 g_error_free (err);
 897                                 err = NULL;
 898                         }
 899                         /* The pipe is closed on the other side */
 900                         /* if not related to non blocking read or interrupted syscall */
 901                         else if (err && errno != EAGAIN && errno != EINTR)
 902                         {
 903                                 ret = FALSE;
 904                         }
 905                 /* Read next chars if buffer was too small
 906                  * (the maximum length of one character is 6 bytes) */
 907                 } while (!err && (n > FILE_BUFFER_SIZE - 7));
 908                 if (err)
 909                         g_error_free (err);
 910                 if (launcher->priv->check_for_passwd_prompt
 911                         && launcher->priv->pty_output_buffer
 912                         && strlen (launcher->priv->pty_output_buffer) > 0)
 913                 {
 914                         anjuta_launcher_check_password (launcher,
 915                                                                                         launcher->priv->pty_output_buffer);
 916                 }
 917         }
 918         /* In pty case, we handle the cases in different invocations */
 919         /* Do not hook up for G_IO_HUP */
 920         if (condition & G_IO_ERR)
 921         {
 922                 DEBUG_PRINT ("%s", "launcher.c: PTY pipe error!");
 923                 ret = FALSE;
 924         }
 925         return ret;
 926 }
 927
 928 static void
 929 anjuta_launcher_execution_done_cleanup (AnjutaLauncher *launcher,
 930                                                                                 gboolean emit_signal)
 931 {
 932         gint child_status, child_pid;
 933         time_t start_time;
 934
 935         /* Remove pending timeout */
 936         if (launcher->priv->completion_check_timeout != 0)
 937                 g_source_remove (launcher->priv->completion_check_timeout);
 938
 939         if (launcher->priv->stdout_channel)
 940         {
 941                 g_io_channel_shutdown (launcher->priv->stdout_channel, emit_signal, NULL);
 942                 g_io_channel_unref (launcher->priv->stdout_channel);
 943                 if (!launcher->priv->stdout_is_done)
 944                         g_source_remove (launcher->priv->stdout_watch);
 945         }
 946
 947         if (launcher->priv->stderr_channel)
 948         {
 949                 g_io_channel_shutdown (launcher->priv->stderr_channel, emit_signal, NULL);
 950                 g_io_channel_unref (launcher->priv->stderr_channel);
 951                 if (!launcher->priv->stderr_is_done)
 952                         g_source_remove (launcher->priv->stderr_watch);
 953         }
 954
 955         if (launcher->priv->pty_channel)
 956         {
 957                 g_io_channel_shutdown (launcher->priv->pty_channel, emit_signal, NULL);
 958                 g_io_channel_unref (launcher->priv->pty_channel);
 959
 960                 g_source_remove (launcher->priv->pty_watch);
 961         }
 962
 963         if (launcher->priv->pty_output_buffer)
 964                 g_free (launcher->priv->pty_output_buffer);
 965         if (launcher->priv->stdout_buffer)
 966         {
 967                 /* Send remaining data if last line is not terminated with EOL */
 968                 (launcher->priv->output_callback)(launcher,
 969                                ANJUTA_LAUNCHER_OUTPUT_STDOUT,
 970                                launcher->priv->stdout_buffer,
 971                                launcher->priv->callback_data);
 972                 g_free (launcher->priv->stdout_buffer);
 973         }
 974         if (launcher->priv->stderr_buffer)
 975         {
 976                 /* Send remaining data if last line is not terminated with EOL */
 977                 (launcher->priv->output_callback)(launcher,
 978                                ANJUTA_LAUNCHER_OUTPUT_STDERR,
 979                                launcher->priv->stderr_buffer,
 980                                launcher->priv->callback_data);
 981                 g_free (launcher->priv->stdout_buffer);
 982         }
 983
 984         /* Save them before we re-initialize */
 985         child_status = launcher->priv->child_status;
 986         child_pid = launcher->priv->child_pid;
 987         start_time = launcher->priv->start_time;
 988
 989         if (emit_signal)
 990                 anjuta_launcher_set_busy (launcher, FALSE);
 991
 992         anjuta_launcher_initialize (launcher);
 993
 994
 995         /* Call this here, after set_busy (FALSE) so we are able to
 996            launch a new child from the terminate function.
 997            (by clubfan 2002-04-07)
 998         */
 999         /* DEBUG_PRINT ("Exit status: %d", child_status); */
1000         if (emit_signal)
1001                 g_signal_emit_by_name (launcher, "child-exited", child_pid,
1002                                                            child_status,
1003                                                            time (NULL) - start_time);
1004 }
1005
1006 /* Using this function is necessary because
1007  * anjuta_launcher_execution_done_cleanup needs to be called in the same
1008  * thread than the gtk main loop */
1009 static gboolean
1010 anjuta_launcher_call_execution_done (gpointer data)
1011 {
1012         AnjutaLauncher *launcher = data;
1013
1014         launcher->priv->completion_check_timeout = 0;
1015         anjuta_launcher_execution_done_cleanup (launcher, TRUE);
1016         return FALSE;
1017 }
1018
1019 /* monitors closure of stdout stderr and pty through a gtk_timeout_add setup */
1020 static gboolean
1021 anjuta_launcher_check_for_execution_done (gpointer data)
1022 {
1023         AnjutaLauncher *launcher = data;
1024         /*
1025         DEBUG_PRINT ("launcher_execution_done STDOUT:%d, STDERR:%d",
1026                                  launcher->priv->stdout_is_done ? 1 : 0,
1027                                  launcher->priv->stderr_is_done ? 1 : 0);
1028         */
1029         if (launcher->priv->stdout_is_done == FALSE ||
1030             launcher->priv->stderr_is_done == FALSE)
1031                 return TRUE;
1032         if (launcher->priv->child_has_terminated == FALSE)
1033         {
1034                 /* DEBUG_PRINT ("%s", "launcher: We missed the exit of the child"); */
1035         }
1036         launcher->priv->completion_check_timeout = 0;
1037         anjuta_launcher_execution_done_cleanup (launcher, TRUE);
1038         return FALSE;
1039 }
1040
1041 static void
1042 anjuta_launcher_child_terminated (GPid pid, gint status, gpointer data)
1043 {
1044         AnjutaLauncher *launcher = data;
1045
1046         g_return_if_fail(ANJUTA_IS_LAUNCHER(launcher));
1047
1048         /* Save child exit code */
1049         launcher->priv->child_status = status;
1050         launcher->priv->child_has_terminated = TRUE;
1051         anjuta_launcher_synchronize (launcher);
1052 }
1053
1054
1055 static gboolean
1056 anjuta_launcher_set_encoding_real (AnjutaLauncher *launcher, const gchar *charset)
1057 {
1058         GIOStatus s;
1059         gboolean r = TRUE;
1060
1061         g_return_val_if_fail (launcher != NULL, FALSE);
1062         // charset can be NULL
1063
1064         s = g_io_channel_set_encoding (launcher->priv->stderr_channel, charset, NULL);
1065         if (s != G_IO_STATUS_NORMAL) r = FALSE;
1066         s = g_io_channel_set_encoding (launcher->priv->stdout_channel, charset, NULL);
1067         if (s != G_IO_STATUS_NORMAL) r = FALSE;
1068         s = g_io_channel_set_encoding (launcher->priv->pty_channel, charset, NULL);
1069         if (s != G_IO_STATUS_NORMAL) r = FALSE;
1070
1071         if (! r)
1072         {
1073                 g_warning ("launcher.c: Failed to set channel encoding!");
1074         }
1075         return r;
1076 }
1077
1078
1079 /**
1080  * anjuta_launcher_set_encoding:
1081  * @launcher: a #AnjutaLancher object.
1082  * @charset: Character set to use for Input/Output with the process.
1083  *
1084  * Sets the character set to use for Input/Output with the process.
1085  *
1086  */
1087 void
1088 anjuta_launcher_set_encoding (AnjutaLauncher *launcher, const gchar *charset)
1089 {
1090         if (launcher->priv->custom_encoding)
1091                 g_free (launcher->priv->encoding);
1092
1093         launcher->priv->custom_encoding = TRUE;
1094         if (charset)
1095           launcher->priv->encoding = g_strdup(charset);
1096         else
1097           launcher->priv->encoding = NULL;
1098 }
1099
1100 static pid_t
1101 anjuta_launcher_fork (AnjutaLauncher *launcher, const gchar *dir, gchar *const args[], gchar *const envp[])
1102 {
1103         int pty_master_fd, md;
1104         int stdout_pipe[2], stderr_pipe[2];
1105         pid_t child_pid;
1106         struct termios termios_flags;
1107         gchar * const *env;
1108
1109         /* The pipes */
1110         pipe (stderr_pipe);
1111         pipe (stdout_pipe);
1112
1113         /* Fork the command */
1114         child_pid = forkpty (&pty_master_fd, NULL, NULL, NULL);
1115         if (child_pid == 0)
1116         {
1117                 close (2);
1118                 dup (stderr_pipe[1]);
1119                 close (1);
1120                 dup (stdout_pipe[1]);
1121
1122                 /* Close unnecessary pipes */
1123                 close (stderr_pipe[0]);
1124                 close (stdout_pipe[0]);
1125
1126                 /*
1127                 if ((ioctl(pty_slave_fd, TIOCSCTTY, NULL))
1128                         perror ("Could not set new controlling tty");
1129                 */
1130                 /* Set no delays for the write pipes (non_buffered) so
1131                 that we get all the outputs immidiately */
1132                 if ((md = fcntl (stdout_pipe[1], F_GETFL)) != -1)
1133                         fcntl (stdout_pipe[1], F_SETFL, O_SYNC | md);
1134                 if ((md = fcntl (stderr_pipe[1], F_GETFL)) != -1)
1135                         fcntl (stderr_pipe[1], F_SETFL, O_SYNC | md);
1136
1137                 /* Set working directory */
1138                 if (dir != NULL)
1139                 {
1140                         /* Exit if working directory doesn't exist */
1141                         if (chdir (dir) != 0) _exit(-1);
1142                 }
1143
1144                 /* Set up environment */
1145                 if (envp != NULL)
1146                 {
1147                         GString *variable = g_string_new (NULL);
1148                         for (env = envp; *env != NULL; env++)
1149                         {
1150                                 gchar *value = strchr (*env, '=');
1151
1152                                 if (value == NULL)
1153                                 {
1154                                         g_setenv (*env, NULL, TRUE);
1155                                 }
1156                                 else
1157                                 {
1158                                         g_string_truncate (variable, 0);
1159                                         g_string_append_len (variable, *env, value - *env);
1160                                         g_setenv (variable->str, value + 1, TRUE);
1161                                 }
1162                         }
1163                         g_string_free (variable, TRUE);
1164                 }
1165
1166                 execvp (args[0], args);
1167                 g_warning (_("Cannot execute command: \"%s\""), args[0]);
1168                 perror(_("execvp failed"));
1169                 _exit(-1);
1170         }
1171
1172         /* Close parent's side pipes */
1173         close (stderr_pipe[1]);
1174         close (stdout_pipe[1]);
1175
1176         if (child_pid < 0)
1177         {
1178                 g_warning ("launcher.c: Fork failed!");
1179                 /* Close parent's side pipes */
1180                 close (stderr_pipe[0]);
1181                 close (stdout_pipe[0]);
1182                 return child_pid;
1183         }
1184
1185         /*
1186         *  Set pipes none blocking, so we can read big buffers
1187         *  in the callback without having to use FIONREAD
1188         *  to make sure the callback doesn't block.
1189         */
1190         if ((md = fcntl (stdout_pipe[0], F_GETFL)) != -1)
1191                 fcntl (stdout_pipe[0], F_SETFL, O_NONBLOCK | md);
1192         if ((md = fcntl (stderr_pipe[0], F_GETFL)) != -1)
1193                 fcntl (stderr_pipe[0], F_SETFL, O_NONBLOCK | md);
1194         if ((md = fcntl (pty_master_fd, F_GETFL)) != -1)
1195                 fcntl (pty_master_fd, F_SETFL, O_NONBLOCK | md);
1196
1197         launcher->priv->child_pid = child_pid;
1198         launcher->priv->stderr_channel = g_io_channel_unix_new (stderr_pipe[0]);
1199         launcher->priv->stdout_channel = g_io_channel_unix_new (stdout_pipe[0]);
1200         launcher->priv->pty_channel = g_io_channel_unix_new (pty_master_fd);
1201
1202         g_io_channel_set_buffer_size (launcher->priv->pty_channel, FILE_INPUT_BUFFER_SIZE);
1203
1204         if (!launcher->priv->custom_encoding)
1205           g_get_charset ((const gchar**)&launcher->priv->encoding);
1206         anjuta_launcher_set_encoding_real (launcher, launcher->priv->encoding);
1207
1208         tcgetattr(pty_master_fd, &termios_flags);
1209         termios_flags.c_iflag &= ~(IGNPAR | INPCK | INLCR | IGNCR | ICRNL | IXON |
1210                                         IXOFF | ISTRIP);
1211         termios_flags.c_iflag |= IGNBRK | BRKINT | IMAXBEL | IXANY;
1212         termios_flags.c_oflag &= ~OPOST;
1213 //      termios_flags.c_oflag |= 0;
1214         termios_flags.c_cflag &= ~(CSTOPB | PARENB | HUPCL);
1215         termios_flags.c_cflag |= CS8 | CLOCAL;
1216
1217         if (!launcher->priv->terminal_echo_on)
1218         {
1219                 termios_flags.c_lflag &= ~(ECHOKE | ECHOE | ECHO | ECHONL |
1220 #ifdef ECHOPRT
1221                                                 ECHOPRT |
1222 #endif
1223                                                 ECHOCTL | ISIG | ICANON | IEXTEN | NOFLSH | TOSTOP);
1224         }
1225 //      termios_flags.c_lflag |= 0;
1226         termios_flags.c_cc[VMIN] = 0;
1227         cfsetospeed(&termios_flags, __MAX_BAUD);
1228         tcsetattr(pty_master_fd, TCSANOW, &termios_flags);
1229
1230         launcher->priv->stderr_watch =
1231                 g_io_add_watch (launcher->priv->stderr_channel,
1232                                                 G_IO_IN | G_IO_ERR | G_IO_HUP,
1233                                                 (GIOFunc)anjuta_launcher_scan_error, launcher);
1234         launcher->priv->stdout_watch =
1235                 g_io_add_watch (launcher->priv->stdout_channel,
1236                                                 G_IO_IN | G_IO_ERR | G_IO_HUP,
1237                                                 (GIOFunc)anjuta_launcher_scan_output, launcher);
1238         launcher->priv->pty_watch =
1239                 g_io_add_watch (launcher->priv->pty_channel,
1240                                                 G_IO_IN | G_IO_ERR, /* Do not hook up for G_IO_HUP */
1241                                                 (GIOFunc)anjuta_launcher_scan_pty, launcher);
1242
1243         /* DEBUG_PRINT ("Terminal child forked: %d", launcher->priv->child_pid); */
1244         launcher->priv->source = g_child_watch_add (launcher->priv->child_pid,
1245                         anjuta_launcher_child_terminated, launcher);
1246         return child_pid;
1247 }
1248
1249 /**
1250  * anjuta_launcher_execute_v:
1251  * @launcher: a #AnjutaLancher object.
1252  * @dir: Working directory or %NULL.
1253  * @argv: Command args.
1254  * @envp: Additional environment variable.
1255  * @callback: The callback for delivering output from the process.
1256  * @callback_data: Callback data for the above callback.
1257  *
1258  * The first of the @args is the command itself. The rest are sent to the
1259  * as it's arguments. This function works similar to anjuta_launcher_execute().
1260  *
1261  * Return value: %TRUE if successfully launched, otherwise %FALSE.
1262  */
1263 gboolean
1264 anjuta_launcher_execute_v (AnjutaLauncher *launcher, gchar *const dir,
1265                 gchar *const argv[],
1266                 gchar *const envp[],
1267                 AnjutaLauncherOutputCallback callback,
1268                 gpointer callback_data)
1269 {
1270         if (anjuta_launcher_is_busy (launcher))
1271                 return FALSE;
1272
1273         anjuta_launcher_set_busy (launcher, TRUE);
1274
1275         launcher->priv->start_time = time (NULL);
1276         launcher->priv->child_status = 0;
1277         launcher->priv->stdout_is_done = FALSE;
1278         launcher->priv->stderr_is_done = FALSE;
1279         launcher->priv->child_has_terminated = FALSE;
1280         launcher->priv->output_callback = callback;
1281         launcher->priv->callback_data = callback_data;
1282
1283         /* On a fork error perform a cleanup and return */
1284         if (anjuta_launcher_fork (launcher, dir, argv, envp) < 0)
1285         {
1286                 anjuta_launcher_initialize (launcher);
1287                 return FALSE;
1288         }
1289         return TRUE;
1290 }
1291
1292 /**
1293  * anjuta_launcher_execute:
1294  * @launcher: a #AnjutaLancher object.
1295  * @command_str: The command to execute.
1296  * @callback: The callback for delivering output from the process.
1297  * @callback_data: Callback data for the above callback.
1298  *
1299  * Executes a command in the launcher. Both outputs (STDOUT and STDERR) are
1300  * delivered to the above callback. The data are delivered as they arrive
1301  * from the process and could be of any lenght. If the process asks for
1302  * passwords, the user will be automatically prompted with a dialog to enter
1303  * it. Please note that not all formats of the password are recognized. Those
1304  * with the standard 'assword:' substring in the prompt should work well.
1305  *
1306  * Return value: %TRUE if successfully launched, otherwise %FALSE.
1307  */
1308 gboolean
1309 anjuta_launcher_execute (AnjutaLauncher *launcher, const gchar *command_str,
1310                                                  AnjutaLauncherOutputCallback callback,
1311                                                  gpointer callback_data)
1312 {
1313         GList *args_list, *args_list_ptr;
1314         gchar **args, **args_ptr;
1315         gboolean ret;
1316
1317         /* Prepare command args */
1318         args_list = anjuta_util_parse_args_from_string (command_str);
1319         args = g_new (char*, g_list_length (args_list) + 1);
1320         args_list_ptr = args_list;
1321         args_ptr = args;
1322         while (args_list_ptr)
1323         {
1324                 *args_ptr = (char*) args_list_ptr->data;
1325                 args_list_ptr = g_list_next (args_list_ptr);
1326                 args_ptr++;
1327         }
1328         *args_ptr = NULL;
1329
1330         ret = anjuta_launcher_execute_v (launcher, NULL, args, NULL,
1331                 callback, callback_data);
1332         g_free (args);
1333         anjuta_util_glist_strings_free (args_list);
1334         return ret;
1335 }
1336
1337 /**
1338  * anjuta_launcher_set_buffered_output:
1339  * @launcher: a #AnjutaLancher object.
1340  * @buffered: buffer output.
1341  *
1342  * Sets if output should buffered or not. By default, it is buffered.
1343  *
1344  * Return value: Previous flag value
1345  */
1346 gboolean
1347 anjuta_launcher_set_buffered_output (AnjutaLauncher *launcher, gboolean buffered)
1348 {
1349         gboolean past_value = launcher->priv->buffered_output;
1350         launcher->priv->buffered_output = buffered;
1351         return past_value;
1352 }
1353
1354 /**
1355  * anjuta_launcher_set_check_passwd_prompt:
1356  * @launcher: a #AnjutaLancher object.
1357  * @check_passwd: check for password.
1358  *
1359  * Set if output is checked for a password prompti. A special dialog box
1360  * is use to enter it in this case. By default, this behavior is enabled.
1361  *
1362  * Return value: Previous flag value
1363  */
1364 gboolean
1365 anjuta_launcher_set_check_passwd_prompt (AnjutaLauncher *launcher, gboolean check_passwd)
1366 {
1367         gboolean past_value = launcher->priv->check_for_passwd_prompt;
1368         launcher->priv->check_for_passwd_prompt = check_passwd;
1369         return past_value;
1370 }
1371
1372 /**
1373  * anjuta_launcher_set_terminal_echo:
1374  * @launcher: a #AnjutaLancher object.
1375  * @echo_on: Echo ON flag.
1376  *
1377  * Sets if input (those given in STDIN) should enabled or disabled. By default,
1378  * it is disabled.
1379  *
1380  * Return value: Previous flag value
1381  */
1382 gboolean
1383 anjuta_launcher_set_terminal_echo (AnjutaLauncher *launcher,
1384                                                                    gboolean echo_on)
1385 {
1386         gboolean past_value = launcher->priv->terminal_echo_on;
1387         launcher->priv->terminal_echo_on = echo_on;
1388         return past_value;
1389 }
1390
1391 /**
1392  * anjuta_launcher_set_terminate_on_exit:
1393  * @launcher: a #AnjutaLancher object.
1394  * @terminate_on_exit: terminate on exit flag
1395  *
1396  * When this flag is set, al i/o channels are closed and the child-exit
1397  * signal is emitted as soon as the child exit. By default, or when this
1398  * flag is clear, the launcher object wait until the i/o channels are
1399  * closed.
1400  *
1401  * Return value: Previous flag value
1402  */
1403 gboolean
1404 anjuta_launcher_set_terminate_on_exit (AnjutaLauncher *launcher,
1405                                                 gboolean terminate_on_exit)
1406 {
1407         gboolean past_value = launcher->priv->terminate_on_exit;
1408         launcher->priv->terminate_on_exit = terminate_on_exit;
1409         return past_value;
1410 }
1411
1412 /**
1413  * anjuta_launcher_new:
1414  *
1415  * Sets if input (those given in STDIN) should enabled or disabled. By default,
1416  * it is disabled.
1417  *
1418  * Return value: a new instance of #AnjutaLancher class.
1419  */
1420 AnjutaLauncher*
1421 anjuta_launcher_new ()
1422 {
1423         return g_object_new (ANJUTA_TYPE_LAUNCHER, NULL);
1424 }