trunk/src/net_io.c

/*
 * Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
 *
 * This file is part of OSM2Go.
 *
 * OSM2Go 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.
 *
 * OSM2Go 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 OSM2Go.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "appdata.h"

#include <curl/curl.h>
#include <curl/types.h> /* new for v7 */
#include <curl/easy.h>  /* new for v7 */
#include <unistd.h>

static struct http_message_s {
  int id;
  char *msg;
} http_messages [] = {
  { 200, "Ok" },
  { 400, "Bad Request" },
  { 401, "Unauthorized" },
  { 403, "Forbidden" },
  { 404, "Not Found" },
  { 405, "Method Not Allowed" },
  { 410, "Gone" },
  { 412, "Precondition Failed" },
  { 417, "(Expect rejected)" },
  { 500, "Internal Server Error" },
  { 503, "Service Unavailable" },
  { 0,   NULL }
};

typedef struct {
  char *ptr;
  int len;
} curl_mem_t;

typedef enum { NET_IO_FILE, NET_IO_MEM } net_io_type_t;

typedef struct {
  net_io_type_t type;
  gint refcount;       /* reference counter for master and worker thread */ 

  char *url;
  gboolean cancel;
  float progress;

  /* curl/http related stuff: */
  CURLcode res;
  long response;
  char buffer[CURL_ERROR_SIZE];

  union {
    char *filename;
    curl_mem_t mem;
  };

} net_io_request_t;

static char *http_message(int id) {
  struct http_message_s *msg = http_messages;

  while(msg->id) {
    if(msg->id == id) return _(msg->msg);
    msg++;
  }

  return NULL;
}

static gint dialog_destroy_event(GtkWidget *widget, gpointer data) {
  /* set cancel flag */
  *(gboolean*)data = TRUE;
  return FALSE;
}

static void on_cancel(GtkWidget *widget, gpointer data) {
  /* set cancel flag */
  *(gboolean*)data = TRUE;
}

/* create the dialog box shown while worker is running */
static GtkWidget *busy_dialog(GtkWidget *parent, GtkWidget **pbar,
                              gboolean *cancel_ind) {
  GtkWidget *dialog = gtk_dialog_new();

  gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
  gtk_window_set_title(GTK_WINDOW(dialog), _("Downloading..."));
  gtk_window_set_default_size(GTK_WINDOW(dialog), 300, 10);

  gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
  gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(parent));

  g_assert(pbar);
  *pbar = gtk_progress_bar_new();
  gtk_progress_bar_set_pulse_step(GTK_PROGRESS_BAR(*pbar), 0.1);

  gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(dialog)->vbox), *pbar);

  GtkWidget *button = gtk_button_new_with_label(_("Cancel"));
  gtk_signal_connect(GTK_OBJECT(button), "clicked",
                     GTK_SIGNAL_FUNC(on_cancel), (gpointer)cancel_ind);
  gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), button);

  gtk_signal_connect(GTK_OBJECT(dialog), "destroy", 
             G_CALLBACK(dialog_destroy_event), (gpointer)cancel_ind);

  gtk_widget_show_all(dialog);

  return dialog;
}

static void request_free(net_io_request_t *request) {
  g_free(request->url);
  if(request->type == NET_IO_FILE)
    g_free(request->filename);

  g_free(request);
}

static int curl_progress_func(net_io_request_t *request,
                            double t, /* dltotal */ double d, /* dlnow */
                            double ultotal, double ulnow) {
  request->progress = t?d/t:0;
  return 0;
}

static size_t mem_write(void *ptr, size_t size, size_t nmemb, 
                        void *stream) {
  curl_mem_t *p = (curl_mem_t*)stream;
  
  p->ptr = g_realloc(p->ptr, p->len + size*nmemb + 1);
  if(p->ptr) {
    memcpy(p->ptr+p->len, ptr, size*nmemb);
    p->len += size*nmemb;
    p->ptr[p->len] = 0;
  }
  return nmemb;
}

static void *worker_thread(void *ptr) {
  net_io_request_t *request = (net_io_request_t*)ptr;
  
  printf("thread: running\n");

  CURL *curl = curl_easy_init();
  if(curl) {
    FILE *outfile = NULL;
    gboolean ok = FALSE;

    if(request->type == NET_IO_FILE) {
      outfile = fopen(request->filename, "w");
      ok = (outfile != NULL);
    } else {
      request->mem.ptr = NULL;
      request->mem.len = 0;
      ok = TRUE;
    }

    if(ok) {
      curl_easy_setopt(curl, CURLOPT_URL, request->url);
      if(request->type == NET_IO_FILE) {
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, outfile);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, fwrite);
      } else {
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &request->mem);
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, mem_write);
      }
      curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
      curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, curl_progress_func);
      curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, request);
      curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, request->buffer);
      
      request->res = curl_easy_perform(curl);
      printf("thread: curl perform returned with %d\n", request->res);
    
      curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &request->response);

      if(request->type == NET_IO_FILE) 
        fclose(outfile);
    }

    /* always cleanup */
    curl_easy_cleanup(curl);
  }
  
  printf("thread: io done\n");
  
  if(request->refcount < 2) {
    printf("thread: master has prematurely released request\n");

    request_free(request);
  } else {
    printf("thread: informing master about result\n");

    request->refcount--;
  }

  printf("thread: terminating\n");
  return NULL;
}

static gboolean net_io_do(GtkWidget *parent, net_io_request_t *request) {
  GtkWidget *pbar = NULL;
  GtkWidget *dialog = busy_dialog(parent, &pbar, &request->cancel);
  
  /* create worker thread */
  request->refcount = 2;   // master and worker hold a reference
  if(!g_thread_create(&worker_thread, request, FALSE, NULL) != 0) {
    g_warning("failed to create the worker thread");

    /* free request and return error */
    request_free(request);
    gtk_widget_destroy(dialog);
    return FALSE;
  }

  /* wait for worker thread */
  float progress = 0;
  while(request->refcount > 1 && !request->cancel) {
    while(gtk_events_pending())
      gtk_main_iteration();

    /* worker has made progress changed the progress value */
    if(request->progress != progress) {
      gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pbar), request->progress);
      progress = request->progress;
    } else 
      if(!progress) 
        gtk_progress_bar_pulse(GTK_PROGRESS_BAR(pbar));

    usleep(10000);
  }

  gtk_widget_destroy(dialog);

  /* user pressed cancel */
  if(request->refcount > 1) {
    printf("operation cancelled, leave worker alone\n");

    /* remove the file that may have been written by now. the kernel */
    /* should cope with the fact that the worker thread may still have */
    /* an open reference to this and might thus still write to this file. */
    /* letting the worker delete the file is worse since it may take the */
    /* worker some time to come to the point to delete this file. If the */
    /* user has restarted the download by then, the worker will erase that */
    /* newly written file */
    g_remove(request->filename);

    request->refcount--;
    return FALSE;
  }

  printf("worker thread has ended\n");

  /* --------- evaluate result --------- */

  if(request->res != 0) {
    errorf(parent, _("Download failed with message:\n\n%s"), request->buffer);
    g_remove(request->filename);
    request_free(request);
    return FALSE;
  }

  if(request->response != 200) {
    errorf(parent, _("Download failed with code %ld:\n\n%s\n"), 
           request->response, http_message(request->response));
    g_remove(request->filename);
    request_free(request);
    return FALSE;
  }

  /* memory transfer needs the result as it contains the result pointer */
  if(request->type != NET_IO_MEM)
    request_free(request);

  return TRUE;
}

gboolean net_io_download_file(GtkWidget *parent, char *url, char *filename) {
  /* the request structure is shared between master and worker thread. */
  /* typically the master thread will do some waiting until the worker */
  /* thread returns. But the master may very well stop waiting since e.g. */
  /* the user activated some cancel button. The client will learn this */
  /* from the fact that it's holding the only reference to the request */
  net_io_request_t *request = g_new0(net_io_request_t, 1);

  printf("net_io: download %s to file %s\n", url, filename);
  request->type = NET_IO_FILE;
  request->url = g_strdup(url);
  request->filename = g_strdup(filename);

  return net_io_do(parent, request);
}


void *net_io_download_mem(GtkWidget *parent, char *url) {
  /* the request structure is shared between master and worker thread. */
  /* typically the master thread will do some waiting until the worker */
  /* thread returns. But the master may very well stop waiting since e.g. */
  /* the user activated some cancel button. The client will learn this */
  /* from the fact that it's holding the only reference to the request */
  net_io_request_t *request = g_new0(net_io_request_t, 1);

  printf("net_io: download %s to memory\n", url);
  request->type = NET_IO_MEM;
  request->url = g_strdup(url);

  if(!net_io_do(parent, request)) 
    return NULL;

  printf("ptr = %p, len = %d\n", 
         request->mem.ptr, request->mem.len);

  char *retval = request->mem.ptr;
  request_free(request);
  return retval;
}
1	harbaum	4	/*
2			* Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
3			*
4			* This file is part of OSM2Go.
5			*
6			* OSM2Go 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			* OSM2Go 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 OSM2Go. If not, see <http://www.gnu.org/licenses/>.
18			*/
19
20			#include "appdata.h"
21
22			#include <curl/curl.h>
23			#include <curl/types.h> /* new for v7 */
24			#include <curl/easy.h> /* new for v7 */
25			#include <unistd.h>
26
27			static struct http_message_s {
28			int id;
29			char *msg;
30			} http_messages [] = {
31			{ 200, "Ok" },
32			{ 400, "Bad Request" },
33			{ 401, "Unauthorized" },
34			{ 403, "Forbidden" },
35			{ 404, "Not Found" },
36			{ 405, "Method Not Allowed" },
37			{ 410, "Gone" },
38			{ 412, "Precondition Failed" },
39			{ 417, "(Expect rejected)" },
40			{ 500, "Internal Server Error" },
41			{ 503, "Service Unavailable" },
42			{ 0, NULL }
43			};
44
45			typedef struct {
46			char *ptr;
47			int len;
48			} curl_mem_t;
49
50			typedef enum { NET_IO_FILE, NET_IO_MEM } net_io_type_t;
51
52			typedef struct {
53			net_io_type_t type;
54			gint refcount; /* reference counter for master and worker thread */
55
56			char *url;
57			gboolean cancel;
58			float progress;
59
60			/* curl/http related stuff: */
61			CURLcode res;
62			long response;
63			char buffer[CURL_ERROR_SIZE];
64
65			union {
66			char *filename;
67			curl_mem_t mem;
68			};
69
70			} net_io_request_t;
71
72			static char *http_message(int id) {
73			struct http_message_s *msg = http_messages;
74
75			while(msg->id) {
76			if(msg->id == id) return _(msg->msg);
77			msg++;
78			}
79
80			return NULL;
81			}
82
83			static gint dialog_destroy_event(GtkWidget *widget, gpointer data) {
84			/* set cancel flag */
85			(gboolean)data = TRUE;
86			return FALSE;
87			}
88
89			static void on_cancel(GtkWidget *widget, gpointer data) {
90			/* set cancel flag */
91			(gboolean)data = TRUE;
92			}
93
94			/* create the dialog box shown while worker is running */
95			static GtkWidget busy_dialog(GtkWidget parent, GtkWidget **pbar,
96			gboolean *cancel_ind) {
97			GtkWidget *dialog = gtk_dialog_new();
98
99			gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
100			gtk_window_set_title(GTK_WINDOW(dialog), _("Downloading..."));
101			gtk_window_set_default_size(GTK_WINDOW(dialog), 300, 10);
102
103			gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
104			gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(parent));
105
106			g_assert(pbar);
107			*pbar = gtk_progress_bar_new();
108			gtk_progress_bar_set_pulse_step(GTK_PROGRESS_BAR(*pbar), 0.1);
109
110			gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(dialog)->vbox), *pbar);
111
112			GtkWidget *button = gtk_button_new_with_label(_("Cancel"));
113			gtk_signal_connect(GTK_OBJECT(button), "clicked",
114			GTK_SIGNAL_FUNC(on_cancel), (gpointer)cancel_ind);
115			gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->action_area), button);
116
117			gtk_signal_connect(GTK_OBJECT(dialog), "destroy",
118			G_CALLBACK(dialog_destroy_event), (gpointer)cancel_ind);
119
120			gtk_widget_show_all(dialog);
121
122			return dialog;
123			}
124
125			static void request_free(net_io_request_t *request) {
126			g_free(request->url);
127			if(request->type == NET_IO_FILE)
128			g_free(request->filename);
129
130			g_free(request);
131			}
132
133			static int curl_progress_func(net_io_request_t *request,
134			double t, /* dltotal / double d, / dlnow */
135			double ultotal, double ulnow) {
136			request->progress = t?d/t:0;
137			return 0;
138			}
139
140			static size_t mem_write(void *ptr, size_t size, size_t nmemb,
141			void *stream) {
142			curl_mem_t p = (curl_mem_t)stream;
143
144			p->ptr = g_realloc(p->ptr, p->len + size*nmemb + 1);
145			if(p->ptr) {
146			memcpy(p->ptr+p->len, ptr, size*nmemb);
147			p->len += size*nmemb;
148			p->ptr[p->len] = 0;
149			}
150			return nmemb;
151			}
152
153			static void worker_thread(void ptr) {
154			net_io_request_t request = (net_io_request_t)ptr;
155
156			printf("thread: running\n");
157
158			CURL *curl = curl_easy_init();
159			if(curl) {
160			FILE *outfile = NULL;
161			gboolean ok = FALSE;
162
163			if(request->type == NET_IO_FILE) {
164			outfile = fopen(request->filename, "w");
165			ok = (outfile != NULL);
166			} else {
167			request->mem.ptr = NULL;
168			request->mem.len = 0;
169			ok = TRUE;
170			}
171
172			if(ok) {
173			curl_easy_setopt(curl, CURLOPT_URL, request->url);
174			if(request->type == NET_IO_FILE) {
175			curl_easy_setopt(curl, CURLOPT_WRITEDATA, outfile);
176			curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, fwrite);
177			} else {
178			curl_easy_setopt(curl, CURLOPT_WRITEDATA, &request->mem);
179			curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, mem_write);
180			}
181			curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
182			curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, curl_progress_func);
183			curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, request);
184			curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, request->buffer);
185
186			request->res = curl_easy_perform(curl);
187			printf("thread: curl perform returned with %d\n", request->res);
188
189			curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &request->response);
190
191			if(request->type == NET_IO_FILE)
192			fclose(outfile);
193			}
194
195			/* always cleanup */
196			curl_easy_cleanup(curl);
197			}
198
199			printf("thread: io done\n");
200
201			if(request->refcount < 2) {
202			printf("thread: master has prematurely released request\n");
203
204			request_free(request);
205			} else {
206			printf("thread: informing master about result\n");
207
208			request->refcount--;
209			}
210
211			printf("thread: terminating\n");
212			return NULL;
213			}
214
215			static gboolean net_io_do(GtkWidget parent, net_io_request_t request) {
216			GtkWidget *pbar = NULL;
217			GtkWidget *dialog = busy_dialog(parent, &pbar, &request->cancel);
218
219			/* create worker thread */
220			request->refcount = 2; // master and worker hold a reference
221			if(!g_thread_create(&worker_thread, request, FALSE, NULL) != 0) {
222			g_warning("failed to create the worker thread");
223
224			/* free request and return error */
225			request_free(request);
226			gtk_widget_destroy(dialog);
227			return FALSE;
228			}
229
230			/* wait for worker thread */
231			float progress = 0;
232			while(request->refcount > 1 && !request->cancel) {
233			while(gtk_events_pending())
234			gtk_main_iteration();
235
236			/* worker has made progress changed the progress value */
237			if(request->progress != progress) {
238			gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pbar), request->progress);
239			progress = request->progress;
240			} else
241			if(!progress)
242			gtk_progress_bar_pulse(GTK_PROGRESS_BAR(pbar));
243
244			usleep(10000);
245			}
246
247			gtk_widget_destroy(dialog);
248
249			/* user pressed cancel */
250			if(request->refcount > 1) {
251			printf("operation cancelled, leave worker alone\n");
252
253			/* remove the file that may have been written by now. the kernel */
254			/* should cope with the fact that the worker thread may still have */
255			/* an open reference to this and might thus still write to this file. */
256			/* letting the worker delete the file is worse since it may take the */
257			/* worker some time to come to the point to delete this file. If the */
258			/* user has restarted the download by then, the worker will erase that */
259			/* newly written file */
260			g_remove(request->filename);
261
262			request->refcount--;
263			return FALSE;
264			}
265
266			printf("worker thread has ended\n");
267
268			/* --------- evaluate result --------- */
269
270			if(request->res != 0) {
271			errorf(parent, _("Download failed with message:\n\n%s"), request->buffer);
272			g_remove(request->filename);
273			request_free(request);
274			return FALSE;
275			}
276
277			if(request->response != 200) {
278			errorf(parent, _("Download failed with code %ld:\n\n%s\n"),
279			request->response, http_message(request->response));
280			g_remove(request->filename);
281			request_free(request);
282			return FALSE;
283			}
284
285			/* memory transfer needs the result as it contains the result pointer */
286			if(request->type != NET_IO_MEM)
287			request_free(request);
288
289			return TRUE;
290			}
291
292			gboolean net_io_download_file(GtkWidget parent, char url, char *filename) {
293			/* the request structure is shared between master and worker thread. */
294			/* typically the master thread will do some waiting until the worker */
295			/* thread returns. But the master may very well stop waiting since e.g. */
296			/* the user activated some cancel button. The client will learn this */
297			/* from the fact that it's holding the only reference to the request */
298			net_io_request_t *request = g_new0(net_io_request_t, 1);
299
300			printf("net_io: download %s to file %s\n", url, filename);
301			request->type = NET_IO_FILE;
302			request->url = g_strdup(url);
303			request->filename = g_strdup(filename);
304
305			return net_io_do(parent, request);
306			}
307
308
309			void net_io_download_mem(GtkWidget parent, char *url) {
310			/* the request structure is shared between master and worker thread. */
311			/* typically the master thread will do some waiting until the worker */
312			/* thread returns. But the master may very well stop waiting since e.g. */
313			/* the user activated some cancel button. The client will learn this */
314			/* from the fact that it's holding the only reference to the request */
315			net_io_request_t *request = g_new0(net_io_request_t, 1);
316
317			printf("net_io: download %s to memory\n", url);
318			request->type = NET_IO_MEM;
319			request->url = g_strdup(url);
320
321			if(!net_io_do(parent, request))
322			return NULL;
323
324			printf("ptr = %p, len = %d\n",
325			request->mem.ptr, request->mem.len);
326
327			char *retval = request->mem.ptr;
328			request_free(request);
329			return retval;
330			}