plugin/plugin-downloader.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * plugin-downloader.cpp: Moonlight plugin download routines.
   4  *
   5  * Contact:
   6  *   Moonlight List (moonlight-list@lists.ximian.com)
   7  *
   8  * Copyright 2007 Novell, Inc. (http://www.novell.com)
   9  *
  10  * See the LICENSE file included with the distribution for details.
  11  *
  12  */
  13
  14 #include <config.h>
  15
  16 #include "plugin-downloader.h"
  17 #include "browser-bridge.h"
  18 #include "npstream-request.h"
  19
  20 #define d(x)
  21
  22 bool downloader_shutdown = false;
  23
  24 guint32
  25 plugin_downloader_started (DownloaderResponse *response, gpointer state)
  26 {
  27         d(printf ("plugin_downloader_started (%p, %p).\n", response, state));
  28         PluginDownloader *pd = (PluginDownloader *)state;
  29
  30         if (pd != NULL) {
  31                 pd->setResponse (response);
  32                 pd->Started ();
  33         }
  34
  35         return DOWNLOADER_OK;
  36 }
  37
  38 guint32
  39 plugin_downloader_available (DownloaderResponse *response, gpointer state, char *buffer, guint32 length)
  40 {
  41         d(printf ("plugin_downloader_available (%p, %p, %p, %u).\n", response, state, buffer, length));
  42         PluginDownloader *pd = (PluginDownloader *)state;
  43
  44         if (pd != NULL) {
  45                 return pd->Read (buffer, length);
  46         }
  47
  48         return DOWNLOADER_ERR;
  49 }
  50
  51 guint32
  52 plugin_downloader_finished (DownloaderResponse *response, gpointer state, bool success, gpointer data, const char *uri)
  53 {
  54         d(printf ("plugin_downloader_finished (%p, %p).\n", response, state));
  55         PluginDownloader *pd = (PluginDownloader *)state;
  56
  57         if (pd != NULL) {
  58                 pd->Finished (success, data, uri);
  59         }
  60
  61         return DOWNLOADER_OK;
  62 }
  63
  64 static gpointer
  65 plugin_downloader_create_state (Downloader *dl)
  66 {
  67         PluginDownloader *state = new PluginDownloader (dl);
  68
  69         d (printf ("plugin_downloader_create_state (%p)\n", state));
  70
  71         return state;
  72 }
  73
  74 static void
  75 plugin_downloader_destroy_state (gpointer data)
  76 {
  77         d (printf ("plugin_downloader_destroy_state (%p)\n", data));
  78
  79         delete (PluginDownloader *) data;
  80 }
  81
  82 static void
  83 plugin_downloader_open (gpointer state, const char *verb, const char *uri, bool custom_header_support, bool disable_cache)
  84 {
  85         d (printf ("plugin_downloader_open (%s, %s, %p)\n", verb, uri, state));
  86
  87         PluginDownloader *pd = (PluginDownloader *) state;
  88
  89         pd->Open (verb, uri, custom_header_support, disable_cache);
  90 }
  91
  92 static void
  93 plugin_downloader_send (gpointer state)
  94 {
  95         d (printf ("plugin_downloader_send (%p)\n", state));
  96
  97         PluginDownloader *pd = (PluginDownloader *) state;
  98
  99         pd->Send ();
 100 }
 101
 102 static void
 103 plugin_downloader_set_body (gpointer state, void *body, guint32 length)
 104 {
 105         d (printf ("plugin_downloader_set_body (%p)\n", state));
 106
 107         PluginDownloader *pd = (PluginDownloader *) state;
 108
 109         pd->SetBody (body, length);
 110 }
 111
 112 static void
 113 plugin_downloader_set_header (gpointer state, const char *header, const char *value)
 114 {
 115         d (printf ("plugin_downloader_set_header (%p)\n", state));
 116
 117         PluginDownloader *pd = (PluginDownloader *) state;
 118
 119         pd->SetHttpHeader (header, value);
 120 }
 121
 122 static void
 123 plugin_downloader_abort (gpointer state)
 124 {
 125         d (printf ("plugin_downloader_abort (%p)\n", state));
 126
 127         if (downloader_shutdown)
 128                 return;
 129
 130         PluginDownloader *pd = (PluginDownloader *) state;
 131
 132         pd->Abort ();
 133 }
 134
 135 static void *
 136 plugin_downloader_create_webrequest (const char *method, const char *uri, gpointer context)
 137 {
 138         if (!context)
 139                 return NULL;
 140
 141         PluginInstance *instance = (PluginInstance *) context;
 142         BrowserBridge *bridge = instance->GetBridge ();
 143
 144         return bridge ? bridge->CreateDownloaderRequest (method, uri, false) : NULL;
 145 }
 146
 147 static void
 148 plugin_downloader_set_response_header_callback (gpointer state, DownloaderResponseHeaderCallback callback, gpointer context)
 149 {
 150         if (!state)
 151                 return;
 152
 153         PluginDownloader *pd = (PluginDownloader *) state;
 154         pd->SetResponseHeaderCallback (callback, context);
 155 }
 156
 157 static DownloaderResponse *
 158 plugin_downloader_get_response (gpointer state)
 159 {
 160         if (!state)
 161                 return NULL;
 162
 163         return ((PluginDownloader *) state)->getResponse ();
 164 }
 165
 166 PluginDownloader::PluginDownloader (Downloader *dl)
 167 {
 168         d (printf ("PluginDownloader::PluginDownloader (), this: %p, dl: %p\n", this, dl));
 169         this->dl = dl;
 170         this->uri = NULL;
 171         this->verb = NULL;
 172         this->response = NULL;
 173         this->request = NULL;
 174         this->finished = false;
 175         this->response_header_callback = NULL;
 176         this->response_header_context = NULL;
 177 }
 178
 179 PluginDownloader::~PluginDownloader ()
 180 {
 181         d (printf ("PluginDownloader::~PluginDownloader (), this: %p, dl: %p\n", this, dl));
 182
 183         Abort ();
 184
 185         g_free (verb);
 186         g_free (uri);
 187         dl = NULL;
 188 }
 189
 190 void
 191 PluginDownloader::Abort ()
 192 {
 193         d (printf ("PluginDownloader::Abort (), this: %p, dl: %p, finished: %i, request: %p, response: %p\n", this, dl, finished, request, response));
 194
 195         if (finished)
 196                 return;
 197
 198         response_header_callback = NULL;
 199         response_header_context = NULL;
 200
 201         if (this->request) {
 202                 this->request->Abort ();
 203                 delete request;
 204                 this->request = NULL;
 205         }
 206         if (this->response) {
 207                 this->response->Abort ();
 208                 this->response->unref ();
 209                 this->response = NULL;
 210         }
 211 }
 212
 213 void
 214 PluginDownloader::Open (const char *verb, const char *uri, bool custom_header_support, bool disable_cache)
 215 {
 216         d (printf ("PluginDownloader::Open (), this: %p, dl: %p\n", this, dl));
 217
 218         //delete this->bdl;
 219         g_free (this->uri);
 220         g_free (this->verb);
 221
 222         this->verb = g_strdup (verb);
 223         this->uri = g_strdup (uri);
 224
 225         if (custom_header_support) {
 226                 BrowserBridge *bridge = GetPlugin ()->GetBridge ();
 227                 if (bridge)
 228                         this->request = bridge->CreateDownloaderRequest (this->verb, this->uri, disable_cache);
 229         } else {
 230                 this->request = new NPStreamRequest (this->verb, this->uri, GetPlugin ());
 231         }
 232 }
 233
 234 void
 235 PluginDownloader::Send ()
 236 {
 237         d (printf ("PluginDownloader::Send (), this: %p, dl: %p\n", this, dl));
 238
 239         finished = false;
 240         this->offset = 0;
 241         this->request->GetResponse (plugin_downloader_started, plugin_downloader_available, plugin_downloader_finished, this);
 242 }
 243
 244 void
 245 PluginDownloader::Started ()
 246 {
 247         d (printf ("PluginDownloader::Started (), this: %p, dl: %p\n", this, dl));
 248 }
 249
 250 void
 251 PluginDownloader::setResponse (DownloaderResponse *response)
 252 {
 253         d (printf ("PluginDownloader::setResponse (%p)\n", response));
 254
 255         if (this->response == response)
 256                 return;
 257
 258         if (this->response != NULL)
 259                 this->response->unref ();
 260         this->response = response;
 261         if (this->response != NULL) {
 262                 this->response->ref ();
 263
 264                 if (response_header_callback != NULL)
 265                         response->SetHeaderVisitor (response_header_callback, response_header_context);
 266         }
 267 }
 268
 269 void
 270 PluginDownloader::SetResponseHeaderCallback (DownloaderResponseHeaderCallback callback, gpointer context)
 271 {
 272         response_header_callback = NULL;
 273         if (response) {
 274                 response->SetHeaderVisitor (callback, context);
 275         } else {
 276                 response_header_callback = callback;
 277                 response_header_context = context;
 278         }
 279 }
 280
 281 DownloaderRequest *
 282 PluginDownloader::getRequest ()
 283 {
 284         return this->request;
 285 }
 286
 287 guint32
 288 PluginDownloader::Read (char *buffer, guint32 length)
 289 {
 290         d (printf ("PluginDownloader::Read (), this: %p, dl: %p\n", this, dl));
 291
 292         if (dl != NULL) {
 293                 dl->Write (buffer, this->offset, length);
 294                 this->offset += length;
 295                 return DOWNLOADER_OK;
 296         }
 297
 298         return DOWNLOADER_ERR;
 299 }
 300
 301 void
 302 PluginDownloader::Finished (bool success, gpointer data, const char *uri)
 303 {
 304         d (printf ("PluginDownloader::Finished (), this: %p, dl: %p\n", this, dl));
 305
 306         finished = true;
 307
 308         if (dl != NULL) {
 309                 if (success) {
 310                         dl->NotifySize (this->offset);
 311                         dl->SetFilename ((const char *)data);
 312                         dl->NotifyFinished (uri);
 313                 } else {
 314                         dl->NotifyFailed ("download failed");
 315                 }
 316         }
 317 }
 318
 319 void
 320 PluginDownloader::SetHttpHeader (const char *header, const char *value)
 321 {
 322         d (printf ("PluginDownloader::SetHttpHeader (), this: %p, dl: %p\n", this, dl));
 323
 324         if (request != NULL)
 325                 request->SetHttpHeader (header, value);
 326 }
 327
 328 void
 329 PluginDownloader::SetBody (void *body, guint32 length)
 330 {
 331         d (printf ("PluginDownloader::SetBody (), this: %p, dl: %p\n", this, dl));
 332
 333         if (request != NULL)
 334                 request->SetBody (body, length);
 335 }
 336
 337 PluginInstance *
 338 PluginDownloader::GetPlugin ()
 339 {
 340         PluginInstance *instance = NULL;
 341
 342         if (dl && dl->GetContext ()) {
 343                 // Get the context from the downloader.
 344                 instance = (PluginInstance *) dl->GetContext ();
 345         } else if (plugin_instances && plugin_instances->data) {
 346                 // TODO: Review if we really should allowing download with the first plugin.
 347                 NPP_t *plugin = (NPP_t *) plugin_instances->data;
 348                 if (plugin == NULL || plugin->pdata == NULL)
 349                         return NULL;
 350                 instance = (PluginInstance*)plugin->pdata;
 351         }
 352
 353         return instance;
 354 }
 355
 356 void
 357 downloader_initialize (void)
 358 {
 359         downloader_shutdown = false;
 360
 361         Downloader::SetFunctions (
 362                 &plugin_downloader_create_state,
 363                 &plugin_downloader_destroy_state,
 364                 &plugin_downloader_open,
 365                 &plugin_downloader_send,
 366                 &plugin_downloader_abort,
 367                 &plugin_downloader_set_header,
 368                 &plugin_downloader_set_body,
 369                 &plugin_downloader_create_webrequest,
 370                 &plugin_downloader_set_response_header_callback,
 371                 &plugin_downloader_get_response);
 372 }
 373
 374 void
 375 downloader_destroy (void)
 376 {
 377         downloader_shutdown = true;
 378 }