vorbis-tools/ogg123/http_transport.c

   1 /********************************************************************
   2  *                                                                  *
   3  * THIS FILE IS PART OF THE OggVorbis SOFTWARE CODEC SOURCE CODE.   *
   4  * USE, DISTRIBUTION AND REPRODUCTION OF THIS SOURCE IS GOVERNED BY *
   5  * THE GNU PUBLIC LICENSE 2, WHICH IS INCLUDED WITH THIS SOURCE.    *
   6  * PLEASE READ THESE TERMS BEFORE DISTRIBUTING.                     *
   7  *                                                                  *
   8  * THE Ogg123 SOURCE CODE IS (C) COPYRIGHT 2000-2001                *
   9  * by Stan Seibert <volsung@xiph.org> AND OTHER CONTRIBUTORS        *
  10  * http://www.xiph.org/                                             *
  11  *                                                                  *
  12  ********************************************************************
  13
  14  last mod: $Id$
  15
  16 ********************************************************************/
  17
  18 #ifdef HAVE_CONFIG_H
  19 #include "config.h"
  20 #endif
  21 #ifdef HAVE_CURL
  22
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include <signal.h>
  27
  28 #include <curl/curl.h>
  29 #include <curl/easy.h>
  30 #include <pthread.h>
  31
  32 #include "ogg123.h"
  33 #include "transport.h"
  34 #include "buffer.h"
  35 #include "status.h"
  36 #include "callbacks.h"
  37 #include "i18n.h"
  38
  39 #define INPUT_BUFFER_SIZE 32768
  40
  41 extern stat_format_t *stat_format;  /* FIXME Bad hack!  Will fix after RC3! */
  42 extern signal_request_t sig_request;  /* Need access to global cancel flag */
  43
  44 typedef struct http_private_t {
  45   int cancel_flag;
  46
  47   buf_t *buf;
  48
  49   pthread_t curl_thread;
  50
  51   CURL *curl_handle;
  52   struct curl_slist *header_list;
  53   char error[CURL_ERROR_SIZE];
  54
  55   data_source_t *data_source;
  56   data_source_stats_t stats;
  57 } http_private_t;
  58
  59
  60 transport_t http_transport;  /* Forward declaration */
  61
  62 /* -------------------------- curl callbacks ----------------------- */
  63
  64 size_t write_callback (void *ptr, size_t size, size_t nmemb, void *arg)
  65 {
  66   http_private_t *myarg = arg;
  67
  68   if (myarg->cancel_flag || sig_request.cancel)
  69     return 0;
  70
  71   if (!buffer_submit_data(myarg->buf, ptr, size*nmemb))
  72     return 0;
  73
  74   if (myarg->cancel_flag || sig_request.cancel)
  75     return 0;
  76
  77   return size * nmemb;
  78 }
  79
  80 int progress_callback (void *arg, size_t dltotal, size_t dlnow,
  81                        size_t ultotal, size_t ulnow)
  82 {
  83   http_private_t *myarg = arg;
  84   print_statistics_arg_t *pstats_arg;
  85   data_source_t *source = myarg->data_source;
  86
  87   if (myarg->cancel_flag || sig_request.cancel)
  88     return -1;
  89
  90   pstats_arg = new_print_statistics_arg(stat_format,
  91                                         source->transport->statistics(source),
  92                                         NULL);
  93
  94   print_statistics_action(NULL, pstats_arg);
  95
  96   if (myarg->cancel_flag || sig_request.cancel)
  97     return -1;
  98
  99   return 0;
 100 }
 101
 102
 103 /* -------------------------- Private functions --------------------- */
 104
 105 void set_curl_opts (http_private_t *private)
 106 {
 107   CURL *handle = private->curl_handle;
 108
 109   curl_easy_setopt(handle, CURLOPT_FILE, private);
 110   curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, write_callback);
 111   curl_easy_setopt(handle, CURLOPT_URL, private->data_source->source_string);
 112   /*
 113   if (inputOpts.ProxyPort)
 114     curl_easy_setopt(handle, CURLOPT_PROXYPORT, inputOpts.ProxyPort);
 115   if (inputOpts.ProxyHost)
 116     curl_easy_setopt(handle, CURLOPT_PROXY, inputOpts.ProxyHost);
 117   if (inputOpts.ProxyTunnel)
 118     curl_easy_setopt (handle, CURLOPT_HTTPPROXYTUNNEL, inputOpts.ProxyTunnel);
 119   */
 120 #ifdef CURLOPT_MUTE
 121   curl_easy_setopt(handle, CURLOPT_MUTE, 1);
 122 #endif
 123   curl_easy_setopt(handle, CURLOPT_ERRORBUFFER, private->error);
 124   curl_easy_setopt(handle, CURLOPT_PROGRESSFUNCTION, progress_callback);
 125   curl_easy_setopt(handle, CURLOPT_PROGRESSDATA, private);
 126   curl_easy_setopt(handle, CURLOPT_NOPROGRESS, 0);
 127   curl_easy_setopt(handle, CURLOPT_USERAGENT, "ogg123/"VERSION);
 128   curl_easy_setopt(handle, CURLOPT_HTTPHEADER, private->header_list);
 129   curl_easy_setopt(handle, CURLOPT_FOLLOWLOCATION, 1);
 130 }
 131
 132
 133 void *curl_thread_func (void *arg)
 134 {
 135   http_private_t *myarg = (http_private_t *) arg;
 136   CURLcode ret;
 137   sigset_t set;
 138
 139   /* Block signals to this thread */
 140   sigfillset (&set);
 141   sigaddset (&set, SIGINT);
 142   sigaddset (&set, SIGTSTP);
 143   sigaddset (&set, SIGCONT);
 144   if (pthread_sigmask (SIG_BLOCK, &set, NULL) != 0)
 145     status_error(_("ERROR: Could not set signal mask."));
 146
 147   ret = curl_easy_perform((CURL *) myarg->curl_handle);
 148
 149   if (myarg->cancel_flag || sig_request.cancel) {
 150     buffer_abort_write(myarg->buf);
 151     ret = 0;  // "error" was on purpose
 152   } else
 153     buffer_mark_eos(myarg->buf);
 154
 155   if (ret != 0)
 156     status_error(myarg->error);
 157
 158   curl_easy_cleanup(myarg->curl_handle);
 159   myarg->curl_handle = 0;
 160
 161   curl_slist_free_all(myarg->header_list);
 162   myarg->header_list = NULL;
 163
 164   return (void *) ret;
 165 }
 166
 167
 168 /* -------------------------- Public interface -------------------------- */
 169
 170 int http_can_transport (char *source_string)
 171 {
 172   int tmp;
 173
 174   tmp = strchr(source_string, ':') - source_string;
 175   return tmp < 10 &&
 176     tmp + 2 < strlen(source_string) &&
 177     !strncmp(source_string + tmp, "://", 3);
 178 }
 179
 180
 181 data_source_t* http_open (char *source_string, ogg123_options_t *ogg123_opts)
 182 {
 183   data_source_t *source;
 184   http_private_t *private;
 185
 186   /* Allocate data source structures */
 187   source = malloc(sizeof(data_source_t));
 188   private = malloc(sizeof(http_private_t));
 189
 190   if (source != NULL && private != NULL) {
 191     source->source_string = strdup(source_string);
 192     source->transport = &http_transport;
 193     source->private = private;
 194
 195     private->buf = buffer_create (ogg123_opts->input_buffer_size,
 196                                   ogg123_opts->input_buffer_size *
 197                                   ogg123_opts->input_prebuffer / 100.0,
 198                                   NULL, NULL,  /* No write callback, using
 199                                                   buffer in pull mode. */
 200                                   0 /* Irrelevant */);
 201     if (private->buf == NULL) {
 202       status_error(_("ERROR: Unable to create input buffer.\n"));
 203       exit(1);
 204     }
 205
 206     private->curl_handle = NULL;
 207     private->header_list = NULL;
 208     private->data_source = source;
 209     private->stats.transfer_rate = 0;
 210     private->stats.bytes_read = 0;
 211     private->stats.input_buffer_used = 0;
 212     private->cancel_flag = 0;
 213
 214   } else {
 215     fprintf(stderr, _("ERROR: Out of memory.\n"));
 216     exit(1);
 217   }
 218
 219   /* ogg123 only accepts Ogg files, and optionally FLAC as well */
 220 #ifdef HAVE_LIBFLAC
 221   private->header_list = curl_slist_append(NULL, "Accept: application/ogg, audio/ogg, video/ogg, audio/x-flac;q=0.9");
 222 #else
 223   private->header_list = curl_slist_append(NULL, "Accept: application/ogg, audio/ogg, video/ogg;q=0.9");
 224 #endif
 225   if (private->header_list == NULL)
 226     goto fail;
 227
 228   /* Open URL */
 229   private->curl_handle = curl_easy_init();
 230   if (private->curl_handle == NULL)
 231     goto fail;
 232
 233   set_curl_opts(private);
 234
 235   /* Start thread */
 236   if (pthread_create(&private->curl_thread, NULL, curl_thread_func,
 237                      private) != 0)
 238     goto fail;
 239
 240
 241   stat_format[2].enabled = 0;  /* remaining playback time */
 242   stat_format[3].enabled = 0;  /* total playback time  */
 243   stat_format[6].enabled = 1;  /* Input buffer fill % */
 244   stat_format[7].enabled = 1;  /* Input buffer state  */
 245
 246   return source;
 247
 248
 249 fail:
 250   if (private->curl_handle != NULL)
 251     curl_easy_cleanup(private->curl_handle);
 252   if (private->header_list != NULL)
 253     curl_slist_free_all(private->header_list);
 254   free(source->source_string);
 255   free(private);
 256   free(source);
 257
 258   return NULL;
 259 }
 260
 261
 262 int http_peek (data_source_t *source, void *ptr, size_t size, size_t nmemb)
 263 {
 264   /*
 265   http_private_t *private = source->private;
 266   int items;
 267   long start;
 268
 269   bytes_read = buffer_get_data(data->buf, ptr, size, nmemb);
 270
 271   private->stats.bytes_read += bytes_read;
 272   */
 273
 274   return 0;
 275 }
 276
 277
 278 int http_read (data_source_t *source, void *ptr, size_t size, size_t nmemb)
 279 {
 280   http_private_t *private = source->private;
 281   int bytes_read;
 282
 283   if (private->cancel_flag || sig_request.cancel)
 284     return 0;
 285
 286   bytes_read = buffer_get_data(private->buf, ptr, size * nmemb);
 287
 288   private->stats.bytes_read += bytes_read;
 289
 290   return bytes_read;
 291 }
 292
 293
 294 int http_seek (data_source_t *source, long offset, int whence)
 295 {
 296   return -1;
 297 }
 298
 299
 300 data_source_stats_t *http_statistics (data_source_t *source)
 301 {
 302   http_private_t *private = source->private;
 303   data_source_stats_t *data_source_stats;
 304   buffer_stats_t *buffer_stats;
 305
 306   data_source_stats = malloc_data_source_stats(&private->stats);
 307   data_source_stats->input_buffer_used = 1;
 308   data_source_stats->transfer_rate = 0;
 309
 310   buffer_stats = buffer_statistics(private->buf);
 311   data_source_stats->input_buffer = *buffer_stats;
 312   free(buffer_stats);
 313
 314   return data_source_stats;
 315 }
 316
 317
 318 long http_tell (data_source_t *source)
 319 {
 320   return 0;
 321 }
 322
 323
 324 void http_close (data_source_t *source)
 325 {
 326   http_private_t *private = source->private;
 327
 328   private->cancel_flag = 1;
 329   buffer_abort_write(private->buf);
 330   pthread_join(private->curl_thread, NULL);
 331
 332   buffer_destroy(private->buf);
 333   private->buf = NULL;
 334
 335   free(source->source_string);
 336   free(source->private);
 337   free(source);
 338 }
 339
 340
 341 transport_t http_transport = {
 342   "http",
 343   &http_can_transport,
 344   &http_open,
 345   &http_peek,
 346   &http_read,
 347   &http_seek,
 348   &http_statistics,
 349   &http_tell,
 350   &http_close
 351 };
 352
 353 #endif /* HAVE_CURL */