src/osm-traces.c

   1 /*
   2  * viking -- GPS Data and Topo Analyzer, Explorer, and Manager
   3  *
   4  * Copyright (C) 2007, Guilhem Bonnefille <guilhem.bonnefille@gmail.com>
   5  *
   6  * This program 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 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program 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 this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21 #ifdef HAVE_CONFIG_H
  22 #include "config.h"
  23 #endif
  24
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <errno.h>
  28
  29 #include <curl/curl.h>
  30 #include <curl/types.h>
  31 #include <curl/easy.h>
  32
  33 #include <glib.h>
  34 #include <glib/gstdio.h>
  35 #include <glib/gi18n.h>
  36
  37 #include "viking.h"
  38 #include "viktrwlayer.h"
  39 #include "osm-traces.h"
  40 #include "gpx.h"
  41 #include "background.h"
  42
  43 /**
  44  * Login to use for OSM uploading.
  45  */
  46 static gchar *user = NULL;
  47
  48 /**
  49  * Password to use for OSM uploading.
  50  */
  51 static gchar *password = NULL;
  52
  53 /**
  54  * Mutex to protect auth. token
  55  */
  56 static GMutex *login_mutex = NULL;
  57
  58 /**
  59  * Struct hosting needed info.
  60  */
  61 typedef struct _OsmTracesInfo {
  62   gchar *name;
  63   gchar *description;
  64   gchar *tags;
  65   gboolean public;
  66   VikTrwLayer *vtl;
  67   gchar *track_name;
  68 } OsmTracesInfo;
  69
  70 /**
  71  * Free an OsmTracesInfo struct.
  72  */
  73 static void oti_free(OsmTracesInfo *oti)
  74 {
  75   if (oti) {
  76     /* Fields have been g_strdup'ed */
  77     g_free(oti->name); oti->name = NULL;
  78     g_free(oti->description); oti->description = NULL;
  79     g_free(oti->tags); oti->tags = NULL;
  80     g_free(oti->track_name); oti->track_name = NULL;
  81
  82     g_object_unref(oti->vtl); oti->vtl = NULL;
  83   }
  84   /* Main struct has been g_malloc'ed */
  85   g_free(oti);
  86 }
  87
  88 static const gchar *get_default_user()
  89 {
  90   const gchar *default_user = NULL;
  91
  92   /* Retrieve "standard" EMAIL varenv */
  93   default_user = g_getenv("EMAIL");
  94
  95   return default_user;
  96 }
  97
  98 static void set_login(const gchar *user_, const gchar *password_)
  99 {
 100   /* Allocate mutex */
 101   if (login_mutex == NULL)
 102   {
 103     login_mutex = g_mutex_new();
 104   }
 105   g_mutex_lock(login_mutex);
 106   g_free(user); user = NULL;
 107   g_free(password); password = NULL;
 108   user        = g_strdup(user_);
 109   password    = g_strdup(password_);
 110   g_mutex_unlock(login_mutex);
 111 }
 112
 113 static gchar *get_login()
 114 {
 115   gchar *user_pass = NULL;
 116   g_mutex_lock(login_mutex);
 117   user_pass = g_strdup_printf("%s:%s", user, password);
 118   g_mutex_unlock(login_mutex);
 119   return user_pass;
 120 }
 121
 122 /*
 123  * Upload a file
 124  */
 125 void osm_traces_upload_file(const char *user,
 126                             const char *password,
 127                             const char *file,
 128                             const char *filename,
 129                             const char *description,
 130                             const char *tags,
 131                             gboolean public)
 132 {
 133   CURL *curl;
 134   CURLcode res;
 135   char curl_error_buffer[CURL_ERROR_SIZE];
 136   struct curl_slist *headers = NULL;
 137   struct curl_httppost *post=NULL;
 138   struct curl_httppost *last=NULL;
 139   gchar *public_string;
 140
 141   char *base_url = "http://www.openstreetmap.org/api/0.5/gpx/create";
 142
 143   gchar *user_pass = get_login();
 144
 145   g_debug("%s: %s %s %s %s %s %s", __FUNCTION__,
 146           user, password, file, filename, description, tags);
 147
 148   /* Init CURL */
 149   curl = curl_easy_init();
 150
 151   /* Filling the form */
 152   curl_formadd(&post, &last,
 153                CURLFORM_COPYNAME, "description",
 154                CURLFORM_COPYCONTENTS, description, CURLFORM_END);
 155   curl_formadd(&post, &last,
 156                CURLFORM_COPYNAME, "tags",
 157                CURLFORM_COPYCONTENTS, tags, CURLFORM_END);
 158   if (public)
 159     public_string = "1";
 160   else
 161     public_string = "0";
 162   curl_formadd(&post, &last,
 163                CURLFORM_COPYNAME, "public",
 164                CURLFORM_COPYCONTENTS, public_string, CURLFORM_END);
 165   curl_formadd(&post, &last,
 166                CURLFORM_COPYNAME, "file",
 167                CURLFORM_FILE, file,
 168                CURLFORM_FILENAME, filename,
 169                CURLFORM_CONTENTTYPE, "text/xml", CURLFORM_END);
 170
 171   /* Prepare request */
 172   /* As explained in http://wiki.openstreetmap.org/index.php/User:LA2 */
 173   /* Expect: header seems to produce incompatibilites between curl and httpd */
 174   headers = curl_slist_append(headers, "Expect: ");
 175   curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
 176   curl_easy_setopt(curl, CURLOPT_HTTPPOST, post);
 177   curl_easy_setopt(curl, CURLOPT_URL, base_url);
 178   curl_easy_setopt(curl, CURLOPT_USERPWD, user_pass);
 179   curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
 180   curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &curl_error_buffer);
 181   if (vik_verbose)
 182     curl_easy_setopt ( curl, CURLOPT_VERBOSE, 1 );
 183
 184   /* Execute request */
 185   res = curl_easy_perform(curl);
 186   if (res == CURLE_OK)
 187   {
 188     long code;
 189     res = curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &code);
 190     if (res == CURLE_OK)
 191     {
 192       g_debug("received valid curl response: %ld", code);
 193       if (code != 200)
 194         g_warning(_("failed to upload data: HTTP response is %ld"), code);
 195     }
 196     else
 197       g_error(_("curl_easy_getinfo failed: %d"), res);
 198   }
 199   else
 200     {
 201       g_warning(_("curl request failed: %s"), curl_error_buffer);
 202     }
 203
 204   /* Memory */
 205   g_free(user_pass); user_pass = NULL;
 206
 207   curl_formfree(post);
 208   curl_easy_cleanup(curl);
 209 }
 210
 211 /**
 212  * uploading function executed by the background" thread
 213  */
 214 static void osm_traces_upload_thread ( OsmTracesInfo *oti, gpointer threaddata )
 215 {
 216   /* Due to OSM limits, we have to enforce ele and time fields */
 217   static GpxWritingOptions options = { TRUE, TRUE };
 218   FILE *file = NULL;
 219   gchar *filename = NULL;
 220   int fd;
 221   GError *error = NULL;
 222   int ret;
 223
 224   g_assert(oti != NULL);
 225
 226   /* Opening temporary file */
 227   fd = g_file_open_tmp("viking_osm_upload_XXXXXX.gpx", &filename, &error);
 228   if (fd < 0) {
 229     g_error(_("failed to open temporary file: %s"), strerror(errno));
 230     return;
 231   }
 232   g_clear_error(&error);
 233   g_debug("%s: temporary file = %s", __FUNCTION__, filename);
 234
 235   /* Creating FILE* */
 236   file = fdopen(fd, "w");
 237
 238   /* writing gpx file */
 239   if (oti->track_name != NULL)
 240   {
 241     /* Upload only the selected track */
 242     VikTrack *track = vik_trw_layer_get_track(oti->vtl, oti->track_name);
 243     a_gpx_write_track_file_options(&options, oti->track_name, track, file);
 244   }
 245   else
 246   {
 247     /* Upload the whole VikTrwLayer */
 248     a_gpx_write_file_options(&options, oti->vtl, file);
 249   }
 250
 251   /* We can close the file */
 252   /* This also close the associated fd */
 253   fclose(file);
 254   file = NULL;
 255
 256   /* finally, upload it */
 257   osm_traces_upload_file(user, password, filename,
 258                          oti->name, oti->description, oti->tags, oti->public);
 259
 260   /* Removing temporary file */
 261   ret = g_unlink(filename);
 262   if (ret != 0) {
 263     g_error(_("failed to unlink temporary file: %s"), strerror(errno));
 264   }
 265 }
 266
 267 /**
 268  * Uploading a VikTrwLayer
 269  *
 270  * @param vtl VikTrwLayer
 271  * @param track_name if not null, the name of the track to upload
 272  */
 273 static void osm_traces_upload_viktrwlayer ( VikTrwLayer *vtl, const gchar *track_name )
 274 {
 275   GtkWidget *dia = gtk_dialog_new_with_buttons (_("OSM upload"),
 276                                                  VIK_GTK_WINDOW_FROM_LAYER(vtl),
 277                                                  GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
 278                                                  GTK_STOCK_CANCEL,
 279                                                  GTK_RESPONSE_REJECT,
 280                                                  GTK_STOCK_OK,
 281                                                  GTK_RESPONSE_ACCEPT,
 282                                                  NULL);
 283
 284   const gchar *name = NULL;
 285   GtkWidget *user_label, *user_entry;
 286   GtkWidget *password_label, *password_entry;
 287   GtkWidget *name_label, *name_entry;
 288   GtkWidget *description_label, *description_entry;
 289   GtkWidget *tags_label, *tags_entry;
 290   GtkWidget *public;
 291   GtkTooltips* dialog_tips;
 292
 293   dialog_tips = gtk_tooltips_new();
 294
 295   user_label = gtk_label_new(_("Email:"));
 296   user_entry = gtk_entry_new();
 297   if (user != NULL)
 298     gtk_entry_set_text(GTK_ENTRY(user_entry), user);
 299   else
 300   {
 301     const gchar *default_user = get_default_user();
 302     if (default_user != NULL)
 303       gtk_entry_set_text(GTK_ENTRY(user_entry), default_user);
 304   }
 305   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), user_label, FALSE, FALSE, 0);
 306   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), user_entry, FALSE, FALSE, 0);
 307   gtk_widget_show_all ( user_label );
 308   gtk_widget_show_all ( user_entry );
 309   gtk_tooltips_set_tip (dialog_tips, user_entry,
 310                         _("The email used as login"),
 311                         _("Enter the email you use to login into www.openstreetmap.org."));
 312
 313   password_label = gtk_label_new(_("Password:"));
 314   password_entry = gtk_entry_new();
 315   if (password != NULL)
 316     gtk_entry_set_text(GTK_ENTRY(password_entry), password);
 317   /* This is a password -> invisible */
 318   gtk_entry_set_visibility(GTK_ENTRY(password_entry), FALSE);
 319   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), password_label, FALSE, FALSE, 0);
 320   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), password_entry, FALSE, FALSE, 0);
 321   gtk_widget_show_all ( password_label );
 322   gtk_widget_show_all ( password_entry );
 323   gtk_tooltips_set_tip (dialog_tips, password_entry,
 324                         _("The password used to login"),
 325                         _("Enter the password you use to login into www.openstreetmap.org."));
 326
 327   name_label = gtk_label_new(_("File's name:"));
 328   name_entry = gtk_entry_new();
 329   if (track_name != NULL)
 330     name = track_name;
 331   else
 332     name = vik_layer_get_name(VIK_LAYER(vtl));
 333   gtk_entry_set_text(GTK_ENTRY(name_entry), name);
 334   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), name_label, FALSE, FALSE, 0);
 335   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), name_entry, FALSE, FALSE, 0);
 336   gtk_widget_show_all ( name_label );
 337   gtk_widget_show_all ( name_entry );
 338   gtk_tooltips_set_tip (dialog_tips, name_entry,
 339                         _("The name of the file on OSM"),
 340                         _("This is the name of the file created on the server. "
 341                         "This is not the name of the local file."));
 342
 343   description_label = gtk_label_new(_("Description:"));
 344   description_entry = gtk_entry_new();
 345   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), description_label, FALSE, FALSE, 0);
 346   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), description_entry, FALSE, FALSE, 0);
 347   gtk_widget_show_all ( description_label );
 348   gtk_widget_show_all ( description_entry );
 349   gtk_tooltips_set_tip (dialog_tips, description_entry,
 350                         _("The description of the trace"),
 351                         "");
 352
 353   tags_label = gtk_label_new(_("Tags:"));
 354   tags_entry = gtk_entry_new();
 355   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), tags_label, FALSE, FALSE, 0);
 356   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), tags_entry, FALSE, FALSE, 0);
 357   gtk_widget_show_all ( tags_label );
 358   gtk_widget_show_all ( tags_entry );
 359   gtk_tooltips_set_tip (dialog_tips, tags_entry,
 360                         _("The tags associated to the trace"),
 361                         "");
 362
 363   public = gtk_check_button_new_with_label(_("Public"));
 364   /* Set public by default */
 365   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(public), TRUE);
 366   gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dia)->vbox), public, FALSE, FALSE, 0);
 367   gtk_widget_show_all ( public );
 368   gtk_tooltips_set_tip (dialog_tips, public,
 369                         _("Indicates if the trace is public or not"),
 370                         "");
 371
 372   if ( gtk_dialog_run ( GTK_DIALOG(dia) ) == GTK_RESPONSE_ACCEPT )
 373   {
 374     gchar *title = NULL;
 375
 376     /* overwrite authentication info */
 377     set_login(gtk_entry_get_text(GTK_ENTRY(user_entry)),
 378               gtk_entry_get_text(GTK_ENTRY(password_entry)));
 379
 380     /* Storing data for the future thread */
 381     OsmTracesInfo *info = g_malloc(sizeof(OsmTracesInfo));
 382     info->name        = g_strdup(gtk_entry_get_text(GTK_ENTRY(name_entry)));
 383     info->description = g_strdup(gtk_entry_get_text(GTK_ENTRY(description_entry)));
 384     /* TODO Normalize tags: they will be used as URL part */
 385     info->tags        = g_strdup(gtk_entry_get_text(GTK_ENTRY(tags_entry)));
 386     info->public      = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(public));
 387     info->vtl         = VIK_TRW_LAYER(g_object_ref(vtl));
 388     info->track_name  = (track_name == NULL) ? NULL : g_strdup(track_name);
 389
 390     title = g_strdup_printf(_("Uploading %s to OSM"), info->name);
 391
 392     /* launch the thread */
 393     a_background_thread(VIK_GTK_WINDOW_FROM_LAYER(vtl),          /* parent window */
 394                         title,                                   /* description string */
 395                         (vik_thr_func) osm_traces_upload_thread, /* function to call within thread */
 396                         info,                                    /* pass along data */
 397                         (vik_thr_free_func) oti_free,            /* function to free pass along data */
 398                         (vik_thr_free_func) NULL,
 399                         1 );
 400     g_free ( title ); title = NULL;
 401   }
 402   gtk_widget_destroy ( dia );
 403 }
 404
 405 /**
 406  * Function called by the entry menu of a TrwLayer
 407  */
 408 void osm_traces_upload_cb ( gpointer layer_and_vlp[2], guint file_type )
 409 {
 410   osm_traces_upload_viktrwlayer(VIK_TRW_LAYER(layer_and_vlp[0]), NULL);
 411 }
 412
 413 /**
 414  * Function called by the entry menu of a single track
 415  */
 416 void osm_traces_upload_track_cb ( gpointer pass_along[6] )
 417 {
 418   osm_traces_upload_viktrwlayer(VIK_TRW_LAYER(pass_along[0]), pass_along[3]);
 419 }