plugin/firefox/browser-http.inc

   1 #include <nsCOMPtr.h>
   2 #include <nsXPCOM.h>
   3 #include <nsIURI.h>
   4 #include <nsIServiceManager.h>
   5 #include <nsIComponentManager.h>
   6 #include <nsComponentManagerUtils.h>
   7 #include <nsIIOService.h>
   8 #include <nsStringAPI.h>
   9 #include <nsIInputStream.h>
  10 #include <nsIOutputStream.h>
  11 #include <nsIStreamListener.h>
  12 #include <nsEmbedString.h>
  13 #include <nsIChannel.h>
  14 #include <nsIRequest.h>
  15 #include <nsIRequestObserver.h>
  16 #include <nsIHttpChannel.h>
  17 #include <nsIHttpHeaderVisitor.h>
  18 #include <nsEmbedString.h>
  19 #include <nsIUploadChannel.h>
  20
  21 // unfrozen apis
  22 #if WITH_LIBXUL_UNSTABLE
  23 #include <nsNetError.h>
  24 #include <nsIStorageStream.h>
  25 #else
  26 #include <necko/nsNetError.h>
  27 #include <xpcom/nsIStorageStream.h>
  28 #endif
  29
  30 class GECKO_SYM(HeaderVisitor) : public nsIHttpHeaderVisitor {
  31  public:
  32         NS_DECL_ISUPPORTS
  33         NS_DECL_NSIHTTPHEADERVISITOR
  34
  35         GECKO_SYM(HeaderVisitor) (DownloaderResponseHeaderCallback cb, gpointer context)
  36         {
  37                 this->callback = cb;
  38                 this->context = context;
  39         }
  40         virtual ~GECKO_SYM(HeaderVisitor)()
  41         {
  42         }
  43
  44  private:
  45         DownloaderResponseHeaderCallback callback;
  46         gpointer context;
  47 };
  48
  49 NS_IMPL_ISUPPORTS1(GECKO_SYM(HeaderVisitor), nsIHttpHeaderVisitor)
  50
  51 NS_IMETHODIMP
  52 GECKO_SYM(HeaderVisitor)::VisitHeader(const nsACString &header, const nsACString &value)
  53 {
  54         const char *name, *val;
  55         PRUint32 nl, vl;
  56
  57         nl = NS_CStringGetData (header, &name);
  58         vl = NS_CStringGetData (value, &val);
  59
  60         name = g_strndup (name, nl);
  61         val = g_strndup (val, vl);
  62
  63         callback (context, name, val);
  64
  65         g_free ((gpointer) name);
  66         g_free ((gpointer) val);
  67
  68         return NS_OK;
  69 }
  70
  71 class GECKO_SYM(DownloaderResponse) : public DownloaderResponse, public nsIStreamListener {
  72  private:
  73         nsCOMPtr<nsIChannel> channel;
  74         bool aborted;
  75
  76  protected:
  77         NS_DECL_NSIREQUESTOBSERVER
  78         NS_DECL_NSISTREAMLISTENER
  79
  80  public:
  81         NS_DECL_ISUPPORTS
  82
  83         GECKO_SYM(DownloaderResponse) (nsCOMPtr<nsIChannel> channel, DownloaderResponseStartedHandler started, DownloaderResponseDataAvailableHandler available, DownloaderResponseFinishedHandler finished, gpointer context)
  84                 : DownloaderResponse (started, available, finished, context)
  85         {
  86                 this->channel = channel;
  87                 this->aborted = false;
  88         }
  89
  90         virtual ~GECKO_SYM(DownloaderResponse) ()
  91         {
  92         }
  93
  94         virtual void ref ()
  95         {
  96                 AddRef ();
  97         }
  98
  99         virtual void unref ()
 100         {
 101                 Release ();
 102         }
 103
 104         void Abort ();
 105         virtual void SetHeaderVisitor (DownloaderResponseHeaderCallback visitor, gpointer context);
 106         int GetResponseStatus ();
 107         const char *GetResponseStatusText ();
 108 };
 109
 110 class GECKO_SYM(DownloaderRequest) : public DownloaderRequest {
 111  private:
 112         bool disable_cache;
 113         nsCOMPtr<nsIChannel> channel;
 114
 115         void CreateChannel ();
 116
 117  public:
 118         GECKO_SYM(DownloaderRequest) (const char *method, const char *uri, bool disable_cache)
 119             : DownloaderRequest (method, uri)
 120         {
 121                 this->disable_cache = disable_cache;
 122                 CreateChannel ();
 123         }
 124
 125         ~GECKO_SYM(DownloaderRequest) ()
 126         {
 127         }
 128
 129         DownloaderResponse *GetResponse ();
 130         bool GetResponse (DownloaderResponseStartedHandler started, DownloaderResponseDataAvailableHandler available, DownloaderResponseFinishedHandler finished, gpointer context);
 131         void SetHttpHeader (const char *name, const char *value);
 132         void SetBody (void *body, int size);
 133
 134         void Abort ();
 135 };
 136
 137 // DownloaderResponse
 138
 139 NS_IMPL_ISUPPORTS1 (GECKO_SYM(DownloaderResponse), nsIStreamListener)
 140
 141 void
 142 GECKO_SYM(DownloaderResponse)::SetHeaderVisitor (DownloaderResponseHeaderCallback visitor, gpointer context)
 143 {
 144         GECKO_SYM(HeaderVisitor) *hv = new GECKO_SYM(HeaderVisitor) (visitor, context);
 145         nsCOMPtr<nsIHttpChannel> httpchannel = do_QueryInterface (channel);
 146
 147         httpchannel->VisitResponseHeaders (hv);
 148 }
 149
 150 int
 151 GECKO_SYM(DownloaderResponse)::GetResponseStatus ()
 152 {
 153         PRUint32 status;
 154         nsCOMPtr<nsIHttpChannel> httpchannel = do_QueryInterface (channel);
 155
 156         httpchannel->GetResponseStatus (&status);
 157
 158         return status;
 159 }
 160
 161 const char *
 162 GECKO_SYM(DownloaderResponse)::GetResponseStatusText ()
 163 {
 164         nsCString status;
 165         nsCOMPtr<nsIHttpChannel> httpchannel = do_QueryInterface (channel);
 166
 167         httpchannel->GetResponseStatusText (status);
 168
 169         return status.get();
 170 }
 171
 172 void
 173 GECKO_SYM(DownloaderResponse)::Abort ()
 174 {
 175         if (!aborted) {
 176                 this->channel->Cancel (NS_BINDING_ABORTED);
 177                 aborted = true;
 178         }
 179 }
 180
 181 NS_IMETHODIMP
 182 GECKO_SYM(DownloaderResponse)::OnStartRequest (nsIRequest *request, nsISupports *context)
 183 {
 184         if (!aborted)
 185                 return started (this, this->context);
 186         return NS_OK;
 187 }
 188
 189 NS_IMETHODIMP
 190 GECKO_SYM(DownloaderResponse)::OnStopRequest (nsIRequest *request, nsISupports *ctx, nsresult status)
 191 {
 192         if (!aborted)
 193                 return finished (this, this->context, (status == NS_OK), NULL, NULL);
 194         return NS_OK;
 195 }
 196
 197 NS_IMETHODIMP
 198 GECKO_SYM(DownloaderResponse)::OnDataAvailable (nsIRequest *request, nsISupports *context, nsIInputStream *input, PRUint32 offset, PRUint32 count)
 199 {
 200         PRUint32 length = 0;
 201         nsresult res;
 202
 203         if (aborted)
 204                 return NS_OK;
 205
 206         char *buffer = (char *) NS_Alloc (count);
 207         input->Read (buffer, count, &length);
 208         res = available (this, this->context, buffer, length);
 209         NS_Free (buffer);
 210
 211         return res;
 212 }
 213
 214 // DownloaderRequest
 215
 216 void
 217 GECKO_SYM(DownloaderRequest)::CreateChannel ()
 218 {
 219         nsresult rv = NS_OK;
 220         nsCOMPtr<nsIServiceManager> mgr;
 221         rv = NS_GetServiceManager (getter_AddRefs (mgr));
 222         if (NS_FAILED (rv)) {
 223                 printf ("failed to ge a ServiceManager \n");
 224                 return;
 225         }
 226
 227         nsCOMPtr<nsIIOService> ioservice;
 228         rv = mgr->GetServiceByContractID ("@mozilla.org/network/io-service;1",
 229                         NS_GET_IID (nsIIOService), getter_AddRefs (ioservice));
 230
 231         if (NS_FAILED (rv)) {
 232                 printf ("failed to get a IOService \n");
 233                 return;
 234         }
 235
 236         nsEmbedCString url;
 237         url = this->uri;
 238
 239         printf ("DownloaderRequest: %s\n", uri);
 240
 241         nsCOMPtr<nsIURI> uri;
 242         rv = ioservice->NewURI (url, nsnull, nsnull, getter_AddRefs (uri));
 243
 244         ioservice->NewChannelFromURI (uri, getter_AddRefs (this->channel));
 245
 246         nsCOMPtr<nsIHttpChannel> httpchannel = do_QueryInterface (channel);
 247         if (!httpchannel)
 248                 return;
 249
 250         nsEmbedCString meth;
 251         meth = this->method;
 252         httpchannel->SetRequestMethod (meth);
 253 }
 254
 255 void
 256 GECKO_SYM(DownloaderRequest)::Abort ()
 257 {
 258         channel->Cancel (NS_BINDING_ABORTED);
 259
 260         if (response != NULL && !response->IsAborted ())
 261                 response->Abort ();
 262 }
 263
 264 bool
 265 GECKO_SYM(DownloaderRequest)::GetResponse (DownloaderResponseStartedHandler started, DownloaderResponseDataAvailableHandler available, DownloaderResponseFinishedHandler finished, gpointer context)
 266 {
 267         nsresult rs = NS_OK;
 268         GECKO_SYM(DownloaderResponse) *response;
 269         nsCOMPtr<nsIHttpChannel> httpchannel = do_QueryInterface (channel);
 270
 271         response = new GECKO_SYM(DownloaderResponse) (channel, started, available, finished, context);
 272         response->SetDownloaderRequest (this);
 273         if (disable_cache)
 274                 httpchannel->SetLoadFlags (nsIRequest::INHIBIT_CACHING);
 275
 276         rs = channel->AsyncOpen (response, (GECKO_SYM(DownloaderResponse)*)response);
 277
 278         this->response = response;
 279         return !NS_FAILED (rs);
 280 }
 281
 282 void
 283 GECKO_SYM(DownloaderRequest)::SetHttpHeader (const char *name, const char *value)
 284 {
 285         nsCOMPtr<nsIHttpChannel> httpchannel = do_QueryInterface (channel);
 286         if (!httpchannel)
 287                 return;
 288
 289         nsEmbedCString nsname, nsvalue;
 290         nsname = name;
 291         nsvalue = value;
 292
 293         httpchannel->SetRequestHeader (nsname, nsvalue, true);
 294 }
 295
 296 void
 297 GECKO_SYM(DownloaderRequest)::SetBody (void *body, int size)
 298 {
 299         nsCOMPtr<nsIHttpChannel> httpchannel = do_QueryInterface (channel);
 300         if (!httpchannel)
 301                 return;
 302
 303         nsCOMPtr<nsIUploadChannel> upload = do_QueryInterface (channel);
 304         if (!upload)
 305                 return;
 306
 307         nsEmbedCString type;
 308         nsresult rv;
 309
 310         nsCOMPtr<nsIStorageStream> storage = do_CreateInstance ("@mozilla.org/storagestream;1", &rv);
 311         storage->Init (2048, PR_UINT32_MAX, nsnull);
 312
 313         nsCOMPtr<nsIOutputStream> output;
 314         storage->GetOutputStream (0, getter_AddRefs (output));
 315
 316         PRUint32 written;
 317         output->Write ((const char *)body, size, &written);
 318         output->Close ();
 319
 320         nsCOMPtr<nsIInputStream> input;
 321         rv = storage->NewInputStream (0, getter_AddRefs (input));
 322
 323         nsCString method;
 324         httpchannel->GetRequestMethod (method);
 325
 326         upload->SetUploadStream (input, type, -1);
 327
 328         httpchannel->SetRequestMethod (method);
 329 }