extensions/webservices/soap/src/nsHTTPSOAPTransport.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 2001
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37
  38 #include "nsXPIDLString.h"
  39 #include "nsHTTPSOAPTransport.h"
  40 #include "nsIComponentManager.h"
  41 #include "nsIDOMDocument.h"
  42 #include "nsIDOMText.h"
  43 #include "nsIURI.h"
  44 #include "nsNetUtil.h"
  45 #include "nsIScriptSecurityManager.h"
  46 #include "nsIPrincipal.h"
  47 #include "nsIVariant.h"
  48 #include "nsString.h"
  49 #include "nsSOAPUtils.h"
  50 #include "nsSOAPCall.h"
  51 #include "nsSOAPException.h"
  52 #include "nsSOAPResponse.h"
  53 #include "nsISOAPCallCompletion.h"
  54 #include "nsIDOMEventTarget.h"
  55 #include "nsIDOMSerializer.h"
  56 #include "nsIWebScriptsAccessService.h"
  57 #include "nsMemory.h"
  58 #include "nsIDocument.h"
  59 #include "nsIClassInfoImpl.h"
  60
  61 nsHTTPSOAPTransport::nsHTTPSOAPTransport()
  62 {
  63 }
  64
  65 nsHTTPSOAPTransport::~nsHTTPSOAPTransport()
  66 {
  67 }
  68
  69 NS_IMPL_ISUPPORTS1_CI(nsHTTPSOAPTransport, nsISOAPTransport)
  70 #ifdef DEBUG
  71 #define DEBUG_DUMP_DOCUMENT(message,doc) \
  72   { \
  73           nsresult rcc;\
  74           nsAutoString serial;\
  75           nsCOMPtr<nsIDOMSerializer> serializer(do_CreateInstance(NS_XMLSERIALIZER_CONTRACTID, &rcc));\
  76           if (NS_FAILED(rcc)) return rcc;  \
  77           rcc = serializer->SerializeToString(doc, serial);\
  78           if (NS_FAILED(rcc)) return rcc;\
  79           printf(message ":\n%s\n", NS_ConvertUTF16toUTF8(serial).get());\
  80   }
  81 //  Availble from the debugger...
  82 nsresult DebugPrintDOM(nsIDOMNode * node)
  83 {
  84   DEBUG_DUMP_DOCUMENT("DOM", node) return NS_OK;
  85 }
  86 #else
  87 #define DEBUG_DUMP_DOCUMENT(message,doc)
  88 #endif
  89
  90 /**
  91   * This method will replace the target document's
  92   * codebase principal with the subject codebase to
  93   * override cross-domain checks. So use caution
  94   * because this might lead to a serious security breach
  95   * if misused.
  96   * @param aDocument - The target/response document.
  97   */
  98 static
  99 nsresult ChangePrincipal(nsIDOMDocument* aDocument)
 100 {
 101   if (!aDocument)
 102     return NS_OK;
 103
 104   nsresult rv;
 105   nsCOMPtr<nsIScriptSecurityManager> secMgr =
 106     do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rv);
 107   NS_ENSURE_SUCCESS(rv, rv);
 108
 109   nsCOMPtr<nsIDocument> targetDoc(do_QueryInterface(aDocument, &rv));
 110   NS_ENSURE_SUCCESS(rv, rv);
 111
 112   rv = secMgr->CheckSameOrigin(nsnull, targetDoc->GetDocumentURI());
 113   // change the principal only if the script security
 114   // manager has denied access.
 115   if (NS_FAILED(rv)) {
 116     nsCOMPtr<nsIPrincipal> subjectPrincipal;
 117     rv = secMgr->GetSubjectPrincipal(getter_AddRefs(subjectPrincipal));
 118     if (NS_SUCCEEDED(rv))
 119       targetDoc->SetPrincipal(subjectPrincipal);
 120   }
 121   return rv;
 122 }
 123
 124 /**
 125  * Get and check the transport URI for accessibility.  In the future,
 126  * this might also attempt to automatically add a mustUnderstand
 127  * header to messages for untrusted sources and send them anyway.
 128  */
 129 static nsresult GetTransportURI(nsISOAPCall * aCall, nsAString & aURI)
 130 {
 131   nsresult rc = aCall->GetTransportURI(aURI);
 132   if (NS_FAILED(rc))
 133     return rc;
 134
 135   // Create a new URI
 136   nsCOMPtr<nsIURI> uri;
 137   rc = NS_NewURI(getter_AddRefs(uri), aURI, nsnull);
 138   if (NS_FAILED(rc))
 139     return rc;
 140
 141   nsCOMPtr<nsIWebScriptsAccessService> wsa_service =
 142       do_GetService(NS_WEBSCRIPTSACCESSSERVICE_CONTRACTID, &rc);
 143   if (NS_FAILED(rc))
 144     return rc;
 145
 146   PRBool safe = PR_FALSE;
 147   rc = aCall->GetVerifySourceHeader(&safe);
 148   if (NS_FAILED(rc))
 149     return rc;
 150
 151   nsCOMPtr<nsIScriptSecurityManager> secMan;
 152   PRBool accessGranted;
 153   if (!safe) {
 154     rc = wsa_service->CanAccess(uri, NS_LITERAL_STRING("soap"), &accessGranted);
 155     if (NS_FAILED(rc))
 156       return rc;
 157     if (!accessGranted) {
 158       // Get security manager, check to see if we're allowed to call this URI.
 159       secMan = do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rc);
 160       if (NS_FAILED(rc))
 161         return rc;
 162       if (NS_FAILED(secMan->CheckConnect(nsnull, uri, "SOAPCall", "invoke")))
 163         return SOAP_EXCEPTION(NS_ERROR_FAILURE,
 164                               "SOAP_INVOKE_DISABLED",
 165                               "SOAPCall.invoke not enabled by client");
 166     }
 167   }
 168   else {
 169     // Get security manager, check to see if we're allowed to call this URI.
 170     secMan = do_GetService(NS_SCRIPTSECURITYMANAGER_CONTRACTID, &rc);
 171     if (NS_FAILED(rc))
 172       return rc;
 173     rc = wsa_service->CanAccess(uri, NS_LITERAL_STRING("soapv"), &accessGranted);
 174     if (NS_FAILED(rc))
 175       return rc;
 176     if (!accessGranted) {
 177       if (NS_FAILED(secMan->CheckConnect(nsnull, uri, "SOAPCall", "invokeVerifySourceHeader")))
 178         return SOAP_EXCEPTION(NS_ERROR_FAILURE,
 179                               "SOAP_INVOKE_VERIFY_DISABLED",
 180                               "SOAPCall.invokeVerifySourceHeader not enabled by client");
 181     }
 182
 183     nsAutoString sourceURI;
 184
 185     {
 186
 187       nsCOMPtr<nsIPrincipal> principal;
 188       rc = secMan->GetSubjectPrincipal(getter_AddRefs(principal));
 189       if (NS_FAILED(rc))
 190         return rc;
 191       if (!principal) {
 192         return SOAP_EXCEPTION(NS_ERROR_FAILURE,
 193                               "SOAP_INVOKE_VERIFY_PRINCIPAL",
 194                               "Source-verified message cannot be sent without principal.");
 195       }
 196
 197       nsCOMPtr<nsIURI> uri;
 198       principal->GetURI(getter_AddRefs(uri));
 199       if (!uri) {
 200         return SOAP_EXCEPTION(NS_ERROR_FAILURE,
 201                               "SOAP_INVOKE_VERIFY_URI",
 202                               "Source-verified message cannot be sent without URI.");
 203       }
 204
 205       nsCAutoString spec;
 206       rc = uri->GetSpec(spec);
 207       if (NS_FAILED(rc))
 208         return rc;
 209       CopyASCIItoUTF16(spec, sourceURI);
 210     }
 211
 212 //  Adding a header to tell the server that it must understand and verify the source of the call
 213
 214     nsCOMPtr<nsIDOMElement> element;
 215     rc = aCall->GetHeader(getter_AddRefs(element));
 216     if (NS_FAILED(rc))
 217       return rc;
 218     if (!element)
 219       return SOAP_EXCEPTION(NS_ERROR_FAILURE,"SOAP_INVOKE_VERIFY_HEADER", "Source-verified message cannot be sent without a header.");
 220     //  Node ignored on remove / append calls
 221     nsCOMPtr<nsIDOMNode> ignore;
 222     //  Remove any existing elements that may conflict with this verifySource identification
 223     nsCOMPtr<nsIDOMElement> verifySource;
 224     for (;;) {
 225       nsSOAPUtils::GetSpecificChildElement(nsnull, element, gSOAPStrings->kVerifySourceNamespaceURI,
 226         gSOAPStrings->kVerifySourceHeader, getter_AddRefs(verifySource));
 227       if (verifySource) {
 228         rc = element->RemoveChild(verifySource, getter_AddRefs(ignore));
 229         if (NS_FAILED(rc))
 230           return rc;
 231       }
 232       else
 233        break;
 234     }
 235     //  Document as factory
 236     nsCOMPtr<nsIDOMDocument> document;
 237     rc = element->GetOwnerDocument(getter_AddRefs(document));
 238     if (NS_FAILED(rc))
 239       return rc;
 240     //  Proper version to use of SOAP
 241     PRUint16 version;
 242     rc = aCall->GetVersion(&version);
 243     if (NS_FAILED(rc))
 244       return rc;
 245     //  Proper schema to use for types
 246     nsAutoString XSURI;
 247     nsAutoString XSIURI;
 248     nsAutoString SOAPEncURI;
 249     if (version == nsISOAPMessage::VERSION_1_1) {
 250       XSURI.Assign(gSOAPStrings->kXSURI1999);
 251       XSIURI.Assign(gSOAPStrings->kXSIURI1999);
 252       SOAPEncURI.Assign(gSOAPStrings->kSOAPEncURI11);
 253     }
 254     else {
 255       XSURI.Assign(gSOAPStrings->kXSURI);
 256       XSIURI.Assign(gSOAPStrings->kXSIURI);
 257       SOAPEncURI.Assign(gSOAPStrings->kSOAPEncURI);
 258     }
 259     //  Create the header and append it with mustUnderstand and normal encoding.
 260     rc = document->CreateElementNS(gSOAPStrings->kVerifySourceNamespaceURI,
 261       gSOAPStrings->kVerifySourceHeader,
 262       getter_AddRefs(verifySource));
 263     if (NS_FAILED(rc))
 264       return rc;
 265     rc = element->AppendChild(verifySource, getter_AddRefs(ignore));
 266     if (NS_FAILED(rc))
 267       return rc;
 268     rc = verifySource->SetAttributeNS(*gSOAPStrings->kSOAPEnvURI[version],
 269       gSOAPStrings->kMustUnderstandAttribute,gSOAPStrings->kTrueA);// mustUnderstand
 270     if (NS_FAILED(rc))
 271       return rc;
 272     rc = verifySource->SetAttributeNS(*gSOAPStrings->kSOAPEnvURI[version],
 273       gSOAPStrings->kEncodingStyleAttribute, SOAPEncURI);// 1.2 encoding
 274     if (NS_FAILED(rc))
 275       return rc;
 276
 277     //  Prefixed string for xsi:string
 278     nsAutoString stringType;
 279     {
 280       nsAutoString prefix;
 281       rc = nsSOAPUtils::MakeNamespacePrefix(nsnull, verifySource, XSURI, stringType);
 282       if (NS_FAILED(rc))
 283         return rc;
 284       stringType.Append(gSOAPStrings->kQualifiedSeparator);
 285       stringType.AppendLiteral("anyURI");
 286     }
 287
 288     //  If it is available, add the sourceURI
 289     if (!sourceURI.IsEmpty()) {
 290       rc = document->CreateElementNS(gSOAPStrings->kVerifySourceNamespaceURI,
 291         gSOAPStrings->kVerifySourceURI,getter_AddRefs(element));
 292       if (NS_FAILED(rc))
 293         return rc;
 294       rc = verifySource->AppendChild(element, getter_AddRefs(ignore));
 295       if (NS_FAILED(rc))
 296         return rc;
 297       rc = element->SetAttributeNS(XSIURI,
 298         gSOAPStrings->kXSITypeAttribute,stringType);
 299       if (NS_FAILED(rc))
 300         return rc;
 301       nsCOMPtr<nsIDOMText> text;
 302       rc = document->CreateTextNode(sourceURI, getter_AddRefs(text));
 303       if (NS_FAILED(rc))
 304         return rc;
 305       rc = element->AppendChild(text, getter_AddRefs(ignore));
 306       if (NS_FAILED(rc))
 307         return rc;
 308     }
 309   }
 310   return NS_OK;
 311 }
 312
 313 nsresult // static
 314 nsHTTPSOAPTransport::SetupRequest(nsISOAPCall* aCall, PRBool async,
 315                                   nsIXMLHttpRequest** ret)
 316 {
 317   nsresult rv;
 318   nsCOMPtr<nsIXMLHttpRequest> request = do_CreateInstance(NS_XMLHTTPREQUEST_CONTRACTID, &rv);
 319   if (NS_FAILED(rv))
 320     return rv;
 321
 322   nsAutoString uri;
 323   rv = GetTransportURI(aCall, uri);
 324   if (NS_FAILED(rv))
 325     return rv;
 326   if (AStringIsNull(uri))
 327     return SOAP_EXCEPTION(NS_ERROR_NOT_INITIALIZED,"SOAP_TRANSPORT_URI", "No transport URI was specified.");
 328
 329   rv = request->OverrideMimeType(NS_LITERAL_CSTRING("application/xml"));
 330   if (NS_FAILED(rv))
 331     return rv;
 332
 333   const nsAString& empty = EmptyString();
 334   rv = request->OpenRequest(NS_LITERAL_CSTRING("POST"),
 335                             NS_ConvertUTF16toUTF8(uri), async, empty, empty);
 336   if (NS_FAILED(rv))
 337     return rv;
 338
 339   nsAutoString action;
 340   rv = aCall->GetActionURI(action);
 341   if (NS_FAILED(rv))
 342     return rv;
 343
 344   // nsXMLHttpRequest sends nsIDOMDocument payloads encoded as UTF-8,
 345   // but it doesn't say so in the Content-Type header. For SOAP
 346   // requests, we prefer to make this explicit. Some implementations
 347   // rely on this.
 348
 349   // XXX : Use application/soap+xml for SOAP 1.2 once it gets
 350   // registered by IANA.
 351   rv = request->SetRequestHeader(NS_LITERAL_CSTRING("Content-Type"),
 352                                  NS_LITERAL_CSTRING("text/xml; charset=UTF-8"));
 353   if (NS_FAILED(rv))
 354     return rv;
 355
 356   // Apache Axis web services WSDL files say to set soapAction to "" and require it to be sent.
 357   // So only check if its not void instead of using AStringIsNull.
 358   if (!action.IsVoid()) {
 359
 360     //XXXdoron necko doesn't allow empty header values, so set it to " "
 361     if (action.IsEmpty())
 362       action.AssignLiteral(" ");
 363
 364     rv = request->SetRequestHeader(NS_LITERAL_CSTRING("SOAPAction"),
 365                                    NS_ConvertUTF16toUTF8(action));
 366     if (NS_FAILED(rv))
 367       return rv;
 368   }
 369
 370
 371   NS_ADDREF(*ret = request);
 372
 373   return NS_OK;
 374 }
 375
 376 /* void syncCall (in nsISOAPCall aCall, in nsISOAPResponse aResponse); */
 377 NS_IMETHODIMP
 378 nsHTTPSOAPTransport::SyncCall(nsISOAPCall * aCall, nsISOAPResponse * aResponse)
 379 {
 380   NS_ENSURE_ARG(aCall);
 381
 382   nsCOMPtr<nsIDOMDocument> messageDocument;
 383   nsresult rv = aCall->GetMessage(getter_AddRefs(messageDocument));
 384   if (NS_FAILED(rv))
 385     return rv;
 386   if (!messageDocument)
 387     return SOAP_EXCEPTION(NS_ERROR_NOT_INITIALIZED,"SOAP_MESSAGE_DOCUMENT", "No message document is present.");
 388   DEBUG_DUMP_DOCUMENT("Synchronous Request", messageDocument)
 389
 390   nsCOMPtr<nsIXMLHttpRequest> request;
 391   rv = SetupRequest(aCall, PR_FALSE, getter_AddRefs(request));
 392   if (NS_FAILED(rv))
 393     return rv;
 394
 395   nsCOMPtr<nsIWritableVariant> variant =
 396       do_CreateInstance(NS_VARIANT_CONTRACTID, &rv);
 397   if (NS_FAILED(rv))
 398     return rv;
 399
 400   rv = variant->SetAsInterface(NS_GET_IID(nsIDOMDocument),
 401                                messageDocument);
 402   if (NS_FAILED(rv))
 403     return rv;
 404
 405
 406   rv = request->Send(variant);
 407   if (NS_FAILED(rv))
 408     return rv;
 409
 410 #if 0
 411   PRUint32 status;
 412   rv = request->GetStatus(&status);
 413   if (NS_SUCCEEDED(rv) && (status < 200 || status >= 300))
 414     rv = NS_ERROR_FAILURE;
 415   if (NS_FAILED(rv))
 416     return rv;
 417 #endif
 418
 419   if (aResponse) {
 420     nsCOMPtr<nsIDOMDocument> response;
 421     rv = request->GetResponseXML(getter_AddRefs(response));
 422     if (NS_FAILED(rv))
 423       return rv;
 424     if (response) {
 425     DEBUG_DUMP_DOCUMENT("Asynchronous Response", response)}
 426     rv = aResponse->SetMessage(response);
 427     if (NS_FAILED(rv))
 428       return rv;
 429   }
 430
 431   return NS_OK;
 432 }
 433
 434 NS_IMPL_ISUPPORTS2_CI(nsHTTPSOAPTransportCompletion, nsIDOMEventListener,
 435                       nsISOAPCallCompletion)
 436     nsHTTPSOAPTransportCompletion::nsHTTPSOAPTransportCompletion()
 437 {
 438 }
 439
 440 nsHTTPSOAPTransportCompletion::nsHTTPSOAPTransportCompletion(nsISOAPCall * call, nsISOAPResponse * response, nsIXMLHttpRequest * request, nsISOAPResponseListener * listener) :
 441 mCall(call), mResponse(response), mRequest(request), mListener(listener)
 442 {
 443 }
 444
 445 nsHTTPSOAPTransportCompletion::~nsHTTPSOAPTransportCompletion()
 446 {
 447 }
 448
 449 /* readonly attribute nsISOAPCall call; */
 450 NS_IMETHODIMP nsHTTPSOAPTransportCompletion::GetCall(nsISOAPCall * *aCall)
 451 {
 452   NS_ENSURE_ARG(aCall);
 453   *aCall = mCall;
 454   NS_IF_ADDREF(*aCall);
 455   return NS_OK;
 456 }
 457
 458 /* readonly attribute nsISOAPResponse response; */
 459 NS_IMETHODIMP
 460     nsHTTPSOAPTransportCompletion::GetResponse(nsISOAPResponse *
 461                                                *aResponse)
 462 {
 463   NS_ENSURE_ARG(aResponse);
 464   *aResponse =
 465       mRequest ? nsnull : mResponse.get();
 466   NS_IF_ADDREF(*aResponse);
 467   return NS_OK;
 468 }
 469
 470 /* readonly attribute nsISOAPResponseListener listener; */
 471 NS_IMETHODIMP
 472     nsHTTPSOAPTransportCompletion::GetListener(nsISOAPResponseListener *
 473                                                *aListener)
 474 {
 475   NS_ENSURE_ARG(aListener);
 476   *aListener = mListener;
 477   NS_IF_ADDREF(*aListener);
 478   return NS_OK;
 479 }
 480
 481 /* readonly attribute boolean isComplete; */
 482 NS_IMETHODIMP
 483     nsHTTPSOAPTransportCompletion::GetIsComplete(PRBool * aIsComplete)
 484 {
 485   NS_ENSURE_ARG(aIsComplete);
 486   *aIsComplete = mRequest == nsnull;
 487   return NS_OK;
 488 }
 489
 490 /* boolean abort (); */
 491 NS_IMETHODIMP nsHTTPSOAPTransportCompletion::Abort(PRBool * _retval)
 492 {
 493   NS_ENSURE_ARG(_retval);
 494   if (mRequest) {
 495     if (NS_SUCCEEDED(mRequest->Abort())) {
 496       *_retval = PR_TRUE;
 497       mRequest = nsnull;
 498       return NS_OK;
 499     }
 500   }
 501   *_retval = PR_FALSE;
 502   return NS_OK;
 503 }
 504
 505 NS_IMETHODIMP
 506     nsHTTPSOAPTransportCompletion::HandleEvent(nsIDOMEvent * aEvent)
 507 {
 508   NS_ENSURE_ARG(aEvent);
 509 //  PRUint32 status;
 510   nsresult rv = NS_OK;
 511   if (mRequest) {                //  Avoid if it has been aborted.
 512 #if 0
 513     rv = mRequest->GetStatus(&status);
 514     if (NS_SUCCEEDED(rv) && (status < 200 || status >= 300))
 515       rv = NS_ERROR_FAILURE;
 516 #endif
 517     if (mResponse) { // && NS_SUCCEEDED(rv)) {
 518       nsCOMPtr<nsIDOMDocument> document;
 519       rv = mRequest->GetResponseXML(getter_AddRefs(document));
 520       if (NS_SUCCEEDED(rv) && document) {
 521         rv = mResponse->SetMessage(document);
 522         ChangePrincipal(document);
 523         DEBUG_DUMP_DOCUMENT("Asynchronous Response", document)
 524       }
 525       else {
 526         mResponse = nsnull;
 527       }
 528     } else {
 529       mResponse = nsnull;
 530     }
 531     nsCOMPtr<nsISOAPCallCompletion> kungFuDeathGrip = this;
 532     mRequest = nsnull;                //  Break cycle of references by releasing the request.
 533     PRBool c;                        //  In other transports, this may signal to stop returning if multiple returns
 534     mListener->HandleResponse(mResponse, mCall, rv, PR_TRUE, &c);
 535   }
 536   return NS_OK;
 537 }
 538
 539 /* void asyncCall (in nsISOAPCall aCall, in nsISOAPResponseListener aListener, in nsISOAPResponse aResponse); */
 540 NS_IMETHODIMP
 541 nsHTTPSOAPTransport::AsyncCall(nsISOAPCall * aCall,
 542                                nsISOAPResponseListener * aListener,
 543                                nsISOAPResponse * aResponse,
 544                                nsISOAPCallCompletion ** aCompletion)
 545 {
 546   NS_ENSURE_ARG(aCall);
 547   NS_ENSURE_ARG(aCompletion);
 548
 549
 550   nsCOMPtr<nsIDOMDocument> messageDocument;
 551   nsresult rv = aCall->GetMessage(getter_AddRefs(messageDocument));
 552   if (NS_FAILED(rv))
 553     return rv;
 554   if (!messageDocument)
 555     return SOAP_EXCEPTION(NS_ERROR_NOT_INITIALIZED,"SOAP_MESSAGE_DOCUMENT", "No message document is present.");
 556   DEBUG_DUMP_DOCUMENT("Asynchronous Request", messageDocument)
 557
 558   nsCOMPtr<nsIXMLHttpRequest> request;
 559   rv = SetupRequest(aCall, PR_TRUE, getter_AddRefs(request));
 560   if (NS_FAILED(rv))
 561     return rv;
 562
 563   nsCOMPtr<nsIDOMEventTarget> eventTarget =
 564     do_QueryInterface(request, &rv);
 565   if (NS_FAILED(rv))
 566     return rv;
 567
 568   nsCOMPtr<nsIWritableVariant> variant =
 569       do_CreateInstance(NS_VARIANT_CONTRACTID, &rv);
 570   if (NS_FAILED(rv))
 571     return rv;
 572
 573   rv = variant->SetAsInterface(NS_GET_IID(nsIDOMDocument),
 574                                messageDocument);
 575   if (NS_FAILED(rv))
 576     return rv;
 577
 578   nsCOMPtr<nsISOAPCallCompletion> completion;
 579
 580   if (aListener) {
 581     completion =
 582         new nsHTTPSOAPTransportCompletion(aCall, aResponse, request,
 583                                           aListener);
 584     if (!completion)
 585       return NS_ERROR_OUT_OF_MEMORY;
 586
 587     nsCOMPtr<nsIDOMEventListener> listener =
 588         do_QueryInterface(completion);
 589     rv = eventTarget->AddEventListener(NS_LITERAL_STRING("load"), listener,
 590                                        PR_FALSE);
 591     if (NS_FAILED(rv))
 592       return rv;
 593     rv = eventTarget->AddEventListener(NS_LITERAL_STRING("error"),
 594                                        listener, PR_FALSE);
 595     if (NS_FAILED(rv))
 596       return rv;
 597   }
 598   rv = request->Send(variant);
 599   if (NS_FAILED(rv))
 600     return rv;
 601
 602   *aCompletion = completion;
 603   NS_IF_ADDREF(*aCompletion);
 604
 605   return NS_OK;
 606 }
 607
 608 /* void addListener (in nsISOAPTransportListener aListener, in boolean aCapture); */
 609 NS_IMETHODIMP
 610     nsHTTPSOAPTransport::AddListener(nsISOAPTransportListener * aListener,
 611                                      PRBool aCapture)
 612 {
 613   return NS_ERROR_NOT_IMPLEMENTED;
 614 }
 615
 616 /* void removeListener (in nsISOAPTransportListener aListener, in boolean aCapture); */
 617 NS_IMETHODIMP
 618     nsHTTPSOAPTransport::RemoveListener(nsISOAPTransportListener *
 619                                         aListener, PRBool aCapture)
 620 {
 621   return NS_ERROR_NOT_IMPLEMENTED;
 622 }
 623
 624 nsHTTPSSOAPTransport::nsHTTPSSOAPTransport()
 625 {
 626 }
 627
 628 nsHTTPSSOAPTransport::~nsHTTPSSOAPTransport()
 629 {
 630 }
 631
 632 NS_IMPL_ISUPPORTS1_CI(nsHTTPSSOAPTransport, nsISOAPTransport)