vorbis-tools-1.2.0/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: http_transport.c,v 1.12 2003/08/06 23:14:12 volsung Exp $
  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   buffer_submit_data(myarg->buf, ptr, size*nmemb);
  72
  73   if (myarg->cancel_flag || sig_request.cancel)
  74     return 0;
  75
  76   return size * nmemb;
  77 }
  78
  79 int progress_callback (void *arg, size_t dltotal, size_t dlnow,
  80                        size_t ultotal, size_t ulnow)
  81 {
  82   http_private_t *myarg = arg;
  83   print_statistics_arg_t *pstats_arg;
  84   data_source_t *source = myarg->data_source;
  85
  86   if (myarg->cancel_flag || sig_request.cancel)
  87     return -1;
  88
  89   pstats_arg = new_print_statistics_arg(stat_format,
  90                                         source->transport->statistics(source),
  91                                         NULL);
  92
  93   print_statistics_action(NULL, pstats_arg);
  94
  95   if (myarg->cancel_flag || sig_request.cancel)
  96     return -1;
  97
  98   return 0;
  99 }
 100
 101
 102 /* -------------------------- Private functions --------------------- */
 103
 104 void set_curl_opts (http_private_t *private)
 105 {
 106   CURL *handle = private->curl_handle;
 107
 108   curl_easy_setopt(handle, CURLOPT_FILE, private);
 109   curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, write_callback);
 110   curl_easy_setopt(handle, CURLOPT_URL, private->data_source->source_string);
 111   /*
 112   if (inputOpts.ProxyPort)
 113     curl_easy_setopt(handle, CURLOPT_PROXYPORT, inputOpts.ProxyPort);
 114   if (inputOpts.ProxyHost)
 115     curl_easy_setopt(handle, CURLOPT_PROXY, inputOpts.ProxyHost);
 116   if (inputOpts.ProxyTunnel)
 117     curl_easy_setopt (handle, CURLOPT_HTTPPROXYTUNNEL, inputOpts.ProxyTunnel);
 118   */
 119 #ifdef CURLOPT_MUTE
 120   curl_easy_setopt(handle, CURLOPT_MUTE, 1);
 121 #endif
 122   curl_easy_setopt(handle, CURLOPT_ERRORBUFFER, private->error);
 123   curl_easy_setopt(handle, CURLOPT_PROGRESSFUNCTION, progress_callback);
 124   curl_easy_setopt(handle, CURLOPT_PROGRESSDATA, private);
 125   curl_easy_setopt(handle, CURLOPT_NOPROGRESS, 0);
 126   curl_easy_setopt(handle, CURLOPT_USERAGENT, "ogg123/"VERSION);
 127   curl_easy_setopt(handle, CURLOPT_HTTPHEADER, private->header_list);
 128   curl_easy_setopt(handle, CURLOPT_FOLLOWLOCATION, 1);
 129 }
 130
 131
 132 void *curl_thread_func (void *arg)
 133 {
 134   http_private_t *myarg = (http_private_t *) arg;
 135   CURLcode ret;
 136   sigset_t set;
 137
 138   /* Block signals to this thread */
 139   sigfillset (&set);
 140   sigaddset (&set, SIGINT);
 141   sigaddset (&set, SIGTSTP);
 142   sigaddset (&set, SIGCONT);
 143   if (pthread_sigmask (SIG_BLOCK, &set, NULL) != 0)
 144     status_error(_("Error: Could not set signal mask."));
 145
 146   ret = curl_easy_perform((CURL *) myarg->curl_handle);
 147
 148   if (myarg->cancel_flag || sig_request.cancel) {
 149     buffer_abort_write(myarg->buf);
 150     ret = 0;  // "error" was on purpose
 151   } else
 152     buffer_mark_eos(myarg->buf);
 153
 154   if (ret != 0)
 155     status_error(myarg->error);
 156
 157   curl_easy_cleanup(myarg->curl_handle);
 158   myarg->curl_handle = 0;
 159
 160   curl_slist_free_all(myarg->header_list);
 161   myarg->header_list = NULL;
 162
 163   return (void *) ret;
 164 }
 165
 166
 167 /* -------------------------- Public interface -------------------------- */
 168
 169 int http_can_transport (char *source_string)
 170 {
 171   int tmp;
 172
 173   tmp = strchr(source_string, ':') - source_string;
 174   return tmp < 10 &&
 175     tmp + 2 < strlen(source_string) &&
 176     !strncmp(source_string + tmp, "://", 3);
 177 }
 178
 179
 180 data_source_t* http_open (char *source_string, ogg123_options_t *ogg123_opts)
 181 {
 182   data_source_t *source;
 183   http_private_t *private;
 184
 185   /* Allocate data source structures */
 186   source = malloc(sizeof(data_source_t));
 187   private = malloc(sizeof(http_private_t));
 188
 189   if (source != NULL && private != NULL) {
 190     source->source_string = strdup(source_string);
 191     source->transport = &http_transport;
 192     source->private = private;
 193
 194     private->buf = buffer_create (ogg123_opts->input_buffer_size,
 195                                   ogg123_opts->input_buffer_size *
 196                                   ogg123_opts->input_prebuffer / 100.0,
 197                                   NULL, NULL,  /* No write callback, using
 198                                                   buffer in pull mode. */
 199                                   0 /* Irrelevant */);
 200     if (private->buf == NULL) {
 201       status_error(_("Error: Unable to create input buffer.\n"));
 202       exit(1);
 203     }
 204
 205     private->curl_handle = NULL;
 206     private->header_list = NULL;
 207     private->data_source = source;
 208     private->stats.transfer_rate = 0;
 209     private->stats.bytes_read = 0;
 210     private->stats.input_buffer_used = 0;
 211     private->cancel_flag = 0;
 212
 213   } else {
 214     fprintf(stderr, _("Error: Out of memory.\n"));
 215     exit(1);
 216   }
 217
 218   /* ogg123 only accepts Ogg files, and optionally FLAC as well */
 219 #ifdef HAVE_LIBFLAC
 220   private->header_list = curl_slist_append(NULL, "Accept: application/ogg, audio/ogg, video/ogg, audio/x-flac;q=0.9");
 221 #else
 222   private->header_list = curl_slist_append(NULL, "Accept: application/ogg, audio/ogg, video/ogg;q=0.9");
 223 #endif
 224   if (private->header_list == NULL)
 225     goto fail;
 226
 227   /* Open URL */
 228   private->curl_handle = curl_easy_init();
 229   if (private->curl_handle == NULL)
 230     goto fail;
 231
 232   set_curl_opts(private);
 233
 234   /* Start thread */
 235   if (pthread_create(&private->curl_thread, NULL, curl_thread_func,
 236                      private) != 0)
 237     goto fail;
 238
 239
 240   stat_format[2].enabled = 0;  /* remaining playback time */
 241   stat_format[3].enabled = 0;  /* total playback time  */
 242   stat_format[6].enabled = 1;  /* Input buffer fill % */
 243   stat_format[7].enabled = 1;  /* Input buffer state  */
 244
 245   return source;
 246
 247
 248 fail:
 249   if (private->curl_handle != NULL)
 250     curl_easy_cleanup(private->curl_handle);
 251   if (private->header_list != NULL)
 252     curl_slist_free_all(private->header_list);
 253   free(source->source_string);
 254   free(private);
 255   free(source);
 256
 257   return NULL;
 258 }
 259
 260
 261 int http_peek (data_source_t *source, void *ptr, size_t size, size_t nmemb)
 262 {
 263   /*
 264   http_private_t *private = source->private;
 265   int items;
 266   long start;
 267
 268   bytes_read = buffer_get_data(data->buf, ptr, size, nmemb);
 269
 270   private->stats.bytes_read += bytes_read;
 271   */
 272
 273   return 0;
 274 }
 275
 276
 277 int http_read (data_source_t *source, void *ptr, size_t size, size_t nmemb)
 278 {
 279   http_private_t *private = source->private;
 280   int bytes_read;
 281
 282   if (private->cancel_flag || sig_request.cancel)
 283     return 0;
 284
 285   bytes_read = buffer_get_data(private->buf, ptr, size * nmemb);
 286
 287   private->stats.bytes_read += bytes_read;
 288
 289   return bytes_read;
 290 }
 291
 292
 293 int http_seek (data_source_t *source, long offset, int whence)
 294 {
 295   return -1;
 296 }
 297
 298
 299 data_source_stats_t *http_statistics (data_source_t *source)
 300 {
 301   http_private_t *private = source->private;
 302   data_source_stats_t *data_source_stats;
 303   buffer_stats_t *buffer_stats;
 304
 305   data_source_stats = malloc_data_source_stats(&private->stats);
 306   data_source_stats->input_buffer_used = 1;
 307   data_source_stats->transfer_rate = 0;
 308
 309   buffer_stats = buffer_statistics(private->buf);
 310   data_source_stats->input_buffer = *buffer_stats;
 311   free(buffer_stats);
 312
 313   return data_source_stats;
 314 }
 315
 316
 317 long http_tell (data_source_t *source)
 318 {
 319   return 0;
 320 }
 321
 322
 323 void http_close (data_source_t *source)
 324 {
 325   http_private_t *private = source->private;
 326
 327   private->cancel_flag = 1;
 328   buffer_abort_write(private->buf);
 329   pthread_join(private->curl_thread, NULL);
 330
 331   buffer_destroy(private->buf);
 332   private->buf = NULL;
 333
 334   free(source->source_string);
 335   free(source->private);
 336   free(source);
 337 }
 338
 339
 340 transport_t http_transport = {
 341   "http",
 342   &http_can_transport,
 343   &http_open,
 344   &http_peek,
 345   &http_read,
 346   &http_seek,
 347   &http_statistics,
 348   &http_tell,
 349   &http_close
 350 };
 351
 352 #endif /* HAVE_CURL */