trunk/src/geotoad.c

/*
 * Copyright (C) 2009 Till Harbaum <till@harbaum.org>.
 *
 * This file is part of GPXView.
 *
 * GPXView is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GPXView is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with GPXView.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "gpxview.h"

#include <fcntl.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>

#define BUFFER_SIZE  1500

typedef struct {
  char buf[BUFFER_SIZE];
  int bused;

  /** gdk input tag for async IO */
  gint stdout_tag, stderr_tag;
  gint stdin_fd, stdout_fd, stderr_fd;

} gt_context_t;

/* watch child process and receive events */
static void child_state_cb(GPid pid, gint status, gpointer data) {

  puts("child state");

  if(WIFEXITED(status)) {
  }

  puts("gt exited");

  /* Reap child if needed. */
  waitpid (pid, NULL, WNOHANG);
}

static void child_input_cb(gpointer data, int fd, GdkInputCondition cond) {
  gt_context_t *context = (gt_context_t*)data;

  ssize_t bytes;
  int errnosave=0;

  if(cond != GDK_INPUT_READ) {
    puts("fixme");
    return;
  }

  /* append to current buffer content */
  while( (bytes = read(fd, context->buf+context->bused, 
                 sizeof(context->buf) - context->bused - 1)) > 0) {
    context->bused += bytes;
    context->buf[context->bused]='\0';

    /* consume line by line */
    gchar *ptr = context->buf;
    
    /* parse as long as the buffer contains a newline */
    while( strchr(ptr, '\n') != NULL) {
      char *p = strchr(ptr, '\n');
      *p = '\0';

      printf("line: %s\n", ptr);

      ptr = p+1;
    }

    /* move remaining bytes down the buffer */
    memmove(context->buf, ptr, sizeof(context->buf)-(ptr-context->buf));
    context->bused -= ptr - context->buf;

    /* check if buffer is full but doesn't contain any newline */
    if(context->bused >= sizeof(context->buf)-1) {
      printf("ERROR: reply buffer overflow\n");
      context->bused = 0;
    }
  }

  /* save errno from read */
  errnosave=errno;

  if(errnosave != EAGAIN && errnosave != 0) {
    /* we probably hit EOF */
    puts("removing io");

    // TODO: fixme, make sure process is dead! kill it otherwise, but dont
    // issue an vpnc_disconnect(NULL) !!!!
    
    gdk_input_remove(context->stdout_tag);
    gdk_input_remove(context->stderr_tag);

    printf("freeing context\n");
    g_free(context);
  }
}
        
void geotoad(appdata_t *appdata) {
  gt_context_t *context = g_new0(gt_context_t, 1);

  printf("geoToad\n");

  /* setup context */
  context->bused = 0;
  context->stdout_tag = -1;
  context->stderr_tag = -1;
  context->stdin_fd  = -1;
  context->stderr_fd = -1;
  context->stderr_fd = -1;

  /* build list of arguments */
  GPtrArray *gt_argv = g_ptr_array_new();
  g_ptr_array_add (gt_argv, "/usr/bin/env");
  //  g_ptr_array_add (gt_argv, "/tmp");
  g_ptr_array_add (gt_argv, NULL);
 
  GError *error=NULL;
  GPid pid;
  GSource *gt_watch;

  if (!g_spawn_async_with_pipes (NULL, /* CWD */
                                 (char **) gt_argv->pdata, /* argv */
                                 NULL, /* envp */
                                 G_SPAWN_DO_NOT_REAP_CHILD, /* flags */
                                 NULL, /* child setup */
                                 NULL, /* user data */
                                 &pid,
                                 &context->stdin_fd,
                                 &context->stdout_fd,
                                 &context->stderr_fd,
                                 &error)) {
    g_ptr_array_free(gt_argv, TRUE);
    errorf(_("GeoToad failed to start.\n\nError: '%s'"), error->message);
    g_error_free(error);
    return;
  }
  g_ptr_array_free (gt_argv, TRUE);

  printf("GeoToad: pid = %d\n", pid);

  gt_watch = g_child_watch_source_new(pid);
  g_source_set_callback(gt_watch, (GSourceFunc) child_state_cb, NULL, NULL);

  g_source_attach(gt_watch, NULL);
  g_source_unref(gt_watch);

  /* make nonblocking */
  if(fcntl(context->stdout_fd, F_SETFL, O_NONBLOCK) == -1) 
    perror("fcntl failed");

  if(fcntl(context->stderr_fd, F_SETFL, O_NONBLOCK) == -1) 
    perror("fcntl failed");

  /* use gdk to monitor read end of stdout */
  context->stdout_tag = 
    gdk_input_add(context->stdout_fd, GDK_INPUT_READ, child_input_cb, context); 
  context->stderr_tag = 
    gdk_input_add(context->stderr_fd, GDK_INPUT_READ, child_input_cb, context); 
}
1	/*
2	* Copyright (C) 2009 Till Harbaum <till@harbaum.org>.
3	*
4	* This file is part of GPXView.
5	*
6	* GPXView is free software: you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation, either version 3 of the License, or
9	* (at your option) any later version.
10	*
11	* GPXView 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
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with GPXView. If not, see <http://www.gnu.org/licenses/>.
18	*/
19
20	#include "gpxview.h"
21
22	#include <fcntl.h>
23	#include <sys/types.h>
24	#include <sys/wait.h>
25	#include <errno.h>
26
27	#define BUFFER_SIZE 1500
28
29	typedef struct {
30	char buf[BUFFER_SIZE];
31	int bused;
32
33	/** gdk input tag for async IO */
34	gint stdout_tag, stderr_tag;
35	gint stdin_fd, stdout_fd, stderr_fd;
36
37	} gt_context_t;
38
39	/* watch child process and receive events */
40	static void child_state_cb(GPid pid, gint status, gpointer data) {
41
42	puts("child state");
43
44	if(WIFEXITED(status)) {
45	}
46
47	puts("gt exited");
48
49	/* Reap child if needed. */
50	waitpid (pid, NULL, WNOHANG);
51	}
52
53	static void child_input_cb(gpointer data, int fd, GdkInputCondition cond) {
54	gt_context_t context = (gt_context_t)data;
55
56	ssize_t bytes;
57	int errnosave=0;
58
59	if(cond != GDK_INPUT_READ) {
60	puts("fixme");
61	return;
62	}
63
64	/* append to current buffer content */
65	while( (bytes = read(fd, context->buf+context->bused,
66	sizeof(context->buf) - context->bused - 1)) > 0) {
67	context->bused += bytes;
68	context->buf[context->bused]='\0';
69
70	/* consume line by line */
71	gchar *ptr = context->buf;
72
73	/* parse as long as the buffer contains a newline */
74	while( strchr(ptr, '\n') != NULL) {
75	char *p = strchr(ptr, '\n');
76	*p = '\0';
77
78	printf("line: %s\n", ptr);
79
80	ptr = p+1;
81	}
82
83	/* move remaining bytes down the buffer */
84	memmove(context->buf, ptr, sizeof(context->buf)-(ptr-context->buf));
85	context->bused -= ptr - context->buf;
86
87	/* check if buffer is full but doesn't contain any newline */
88	if(context->bused >= sizeof(context->buf)-1) {
89	printf("ERROR: reply buffer overflow\n");
90	context->bused = 0;
91	}
92	}
93
94	/* save errno from read */
95	errnosave=errno;
96
97	if(errnosave != EAGAIN && errnosave != 0) {
98	/* we probably hit EOF */
99	puts("removing io");
100
101	// TODO: fixme, make sure process is dead! kill it otherwise, but dont
102	// issue an vpnc_disconnect(NULL) !!!!
103
104	gdk_input_remove(context->stdout_tag);
105	gdk_input_remove(context->stderr_tag);
106
107	printf("freeing context\n");
108	g_free(context);
109	}
110	}
111
112	void geotoad(appdata_t *appdata) {
113	gt_context_t *context = g_new0(gt_context_t, 1);
114
115	printf("geoToad\n");
116
117	/* setup context */
118	context->bused = 0;
119	context->stdout_tag = -1;
120	context->stderr_tag = -1;
121	context->stdin_fd = -1;
122	context->stderr_fd = -1;
123	context->stderr_fd = -1;
124
125	/* build list of arguments */
126	GPtrArray *gt_argv = g_ptr_array_new();
127	g_ptr_array_add (gt_argv, "/usr/bin/env");
128	// g_ptr_array_add (gt_argv, "/tmp");
129	g_ptr_array_add (gt_argv, NULL);
130
131	GError *error=NULL;
132	GPid pid;
133	GSource *gt_watch;
134
135	if (!g_spawn_async_with_pipes (NULL, /* CWD */
136	(char *) gt_argv->pdata, / argv */
137	NULL, /* envp */
138	G_SPAWN_DO_NOT_REAP_CHILD, /* flags */
139	NULL, /* child setup */
140	NULL, /* user data */
141	&pid,
142	&context->stdin_fd,
143	&context->stdout_fd,
144	&context->stderr_fd,
145	&error)) {
146	g_ptr_array_free(gt_argv, TRUE);
147	errorf(_("GeoToad failed to start.\n\nError: '%s'"), error->message);
148	g_error_free(error);
149	return;
150	}
151	g_ptr_array_free (gt_argv, TRUE);
152
153	printf("GeoToad: pid = %d\n", pid);
154
155	gt_watch = g_child_watch_source_new(pid);
156	g_source_set_callback(gt_watch, (GSourceFunc) child_state_cb, NULL, NULL);
157
158	g_source_attach(gt_watch, NULL);
159	g_source_unref(gt_watch);
160
161	/* make nonblocking */
162	if(fcntl(context->stdout_fd, F_SETFL, O_NONBLOCK) == -1)
163	perror("fcntl failed");
164
165	if(fcntl(context->stderr_fd, F_SETFL, O_NONBLOCK) == -1)
166	perror("fcntl failed");
167
168	/* use gdk to monitor read end of stdout */
169	context->stdout_tag =
170	gdk_input_add(context->stdout_fd, GDK_INPUT_READ, child_input_cb, context);
171	context->stderr_tag =
172	gdk_input_add(context->stderr_fd, GDK_INPUT_READ, child_input_cb, context);
173	}