src/ptclib/psoap.cxx

   1 /*
   2  * psoap.cxx
   3  *
   4  * SOAP client / server classes.
   5  *
   6  * Portable Windows Library
   7  *
   8  * Copyright (c) 2003 Andreas Sikkema
   9  *
  10  * The contents of this file are subject to the Mozilla Public License
  11  * Version 1.0 (the "License"); you may not use this file except in
  12  * compliance with the License. You may obtain a copy of the License at
  13  * http://www.mozilla.org/MPL/
  14  *
  15  * Software distributed under the License is distributed on an "AS IS"
  16  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17  * the License for the specific language governing rights and limitations
  18  * under the License.
  19  *
  20  * The Original Code is Portable Windows Library.
  21  *
  22  * The Initial Developer of the Original Code is Andreas Sikkema
  23  *
  24  * Contributor(s): ______________________________________.
  25  *
  26  * $Log$
  27  * Revision 1.8  2004/04/24 01:06:32  rjongbloed
  28  * Apploed  patch that impliments a number of checks to avoid segfaults when dealing with
  29  *   various clients. Thanks Ben Lear
  30  *
  31  * Revision 1.7  2004/01/17 17:45:59  csoutheren
  32  * Changed to use PString::MakeEmpty
  33  *
  34  * Revision 1.6  2003/10/08 21:58:13  dereksmithies
  35  * Add client authentication support. many thanks to Ben Lear.
  36  *
  37  * Revision 1.5  2003/04/28 00:09:14  craigs
  38  * Patches from Andreas Sikkema
  39  *
  40  * Revision 1.4  2003/03/31 06:20:56  craigs
  41  * Split the expat wrapper from the XML file handling to allow reuse of the parser
  42  *
  43  * Revision 1.3  2003/02/09 23:31:54  robertj
  44  * Added referention PString's for efficiency.
  45  *
  46  * Revision 1.2  2003/02/09 23:22:46  robertj
  47  * Fixed spelling errors, and setting return values, thanks Andreas Sikkema
  48  *
  49  * Revision 1.1  2003/02/04 22:46:48  robertj
  50  * Added basic SOAP support, thanks Andreas Sikkema
  51  *
  52  */
  53
  54 #ifdef __GNUC__
  55 #pragma implementation "psoap.h"
  56 #endif
  57
  58
  59 #include <ptlib.h>
  60
  61
  62 #if P_EXPAT
  63
  64 #include <ptclib/psoap.h>
  65
  66
  67
  68 /*
  69  SOAP message classes
  70  ####################
  71  */
  72
  73
  74 PSOAPMessage::PSOAPMessage( int options ) :
  75   PXML( options ),
  76   pSOAPBody( 0 ),
  77   pSOAPMethod( 0 ),
  78   faultCode( PSOAPMessage::NoFault )
  79 {
  80 }
  81
  82 PSOAPMessage::PSOAPMessage( const PString & method, const PString & nameSpace ) :
  83   PXML( PXMLParser::Indent + PXMLParser::NewLineAfterElement ),
  84   pSOAPBody( 0 ),
  85   pSOAPMethod( 0 ),
  86   faultCode( PSOAPMessage::NoFault )
  87 {
  88     SetMethod( method, nameSpace );
  89 }
  90
  91
  92
  93 void PSOAPMessage::SetMethod( const PString & name, const PString & nameSpace )
  94 {
  95   PXMLElement* rtElement = 0;
  96
  97   if ( pSOAPBody == 0 )
  98   {
  99     SetRootElement("SOAP-ENV:Envelope");
 100
 101     rtElement = GetRootElement();
 102
 103     rtElement->SetAttribute("xmlns:SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/", TRUE );
 104     rtElement->SetAttribute("xmlns:xsi", "http://www.w3.org/1999/XMLSchema-instance", TRUE );
 105     rtElement->SetAttribute("xmlns:xsd", "http://www.w3.org/1999/XMLSchema", TRUE );
 106     rtElement->SetAttribute("xmlns:SOAP-ENC", "http://schemas.xmlsoap.org/soap/encoding/", TRUE );
 107
 108     pSOAPBody = new PXMLElement( rtElement, "SOAP-ENV:Body");
 109
 110     rtElement->AddChild( pSOAPBody, TRUE );
 111   }
 112
 113   if ( pSOAPMethod == 0 )
 114   {
 115     rtElement = GetRootElement();
 116
 117     pSOAPMethod = new PXMLElement( rtElement, PString( "m:") + name );
 118     if ( nameSpace != "" )
 119     {
 120       pSOAPMethod->SetAttribute("xmlns:m", nameSpace, TRUE );
 121     }
 122     pSOAPBody->AddChild( pSOAPMethod, TRUE );
 123   }
 124
 125 }
 126
 127 void PSOAPMessage::GetMethod( PString & name, PString & nameSpace )
 128 {
 129   PString fullMethod = pSOAPMethod->GetName();
 130   PINDEX sepLocation = fullMethod.Find(':');
 131   if (sepLocation != P_MAX_INDEX) {
 132     PString methodID = fullMethod.Left(sepLocation);
 133     name = fullMethod.Right(fullMethod.GetSize() - 2 - sepLocation);
 134     nameSpace = pSOAPMethod->GetAttribute( "xmlns:" + methodID );
 135   }
 136 }
 137
 138
 139 void PSOAPMessage::AddParameter( PString name, PString type, PString value )
 140 {
 141   if ( pSOAPMethod )
 142   {
 143     PXMLElement* rtElement = GetRootElement();
 144
 145     PXMLElement* pParameter = new PXMLElement( rtElement, name);
 146     PXMLData* pParameterData = new PXMLData( pParameter, value);
 147
 148     if ( type != "" )
 149     {
 150       pParameter->SetAttribute( "xsi:type", PString( "xsd:" ) + type );
 151     }
 152
 153     pParameter->AddChild( pParameterData, TRUE );
 154
 155     AddParameter( pParameter, TRUE );
 156   }
 157 }
 158
 159 void PSOAPMessage::AddParameter( PXMLElement* parameter, BOOL dirty )
 160 {
 161   if ( pSOAPMethod )
 162   {
 163     pSOAPMethod->AddChild( parameter, dirty );
 164   }
 165 }
 166
 167 void PSOAPMessage::PrintOn(ostream & strm) const
 168 {
 169   BOOL newLine = ( options & PXMLParser::NewLineAfterElement ) != 0;
 170
 171   PString ver = version;
 172   PString enc = encoding;
 173   int salone = standAlone;
 174
 175   if ( ver.IsEmpty() )
 176     ver= "1.0";
 177   if ( enc.IsEmpty() )
 178     enc = "UTF-8";
 179   if ( salone == -2 )
 180     salone = -1;
 181
 182   strm << "<?xml version=\"" << ver << "\" encoding=\"" << enc << "\"";
 183   switch ( salone ) {
 184     case 0:
 185       strm << " standalone=\"no\"";
 186       break;
 187     case 1:
 188       strm << " standalone=\"yes\"";
 189       break;
 190     default:
 191       break;
 192   }
 193
 194   strm << "?>";
 195   if ( newLine )
 196     strm << endl;
 197
 198   if ( rootElement != NULL ) {
 199     rootElement->Output(strm, *(this), 2 );
 200   }
 201 }
 202
 203 PString PSOAPMessage::AsString( void )
 204 {
 205         PStringStream stringStream;
 206         PrintOn( stringStream );
 207
 208         PString SOAPString = stringStream;
 209
 210   return SOAPString;
 211 }
 212
 213
 214 PString faultCodeToString( PINDEX faultCode )
 215 {
 216   PString faultCodeStr;
 217   switch ( faultCode )
 218   {
 219   case PSOAPMessage::VersionMismatch:
 220     faultCodeStr = "VersionMisMatch";
 221     break;
 222   case PSOAPMessage::MustUnderstand:
 223     faultCodeStr = "MustUnderstand";
 224     break;
 225   case PSOAPMessage::Client:
 226     faultCodeStr = "Client";
 227     break;
 228   case PSOAPMessage::Server:
 229     faultCodeStr = "Server";
 230     break;
 231   default:
 232     // Default it's the server's fault. Can't blame it on the customer, because he/she is king ;-)
 233     faultCodeStr = "Server";
 234     break;
 235   }
 236
 237   return faultCodeStr;
 238 }
 239
 240 PINDEX stringToFaultCode( PString & faultStr )
 241 {
 242   if ( faultStr == "VersionMisMatch" )
 243     return PSOAPMessage::VersionMismatch;
 244
 245   if ( faultStr == "MustUnderstand" )
 246     return PSOAPMessage::MustUnderstand;
 247
 248   if ( faultStr == "Client" )
 249     return PSOAPMessage::Client;
 250
 251   if ( faultStr == "Server" )
 252     return PSOAPMessage::Server;
 253
 254   return PSOAPMessage::Server;
 255 }
 256
 257 BOOL PSOAPMessage::GetParameter( const PString & name, PString & value )
 258 {
 259   PXMLElement* pElement = GetParameter( name );
 260   if(pElement == NULL)
 261     return FALSE;
 262
 263
 264   if ( pElement->GetAttribute( "xsi:type") == "xsd:string" )
 265   {
 266     value = pElement->GetData();
 267     return TRUE;
 268   }
 269
 270   value.MakeEmpty();
 271   return FALSE;
 272 }
 273
 274 BOOL PSOAPMessage::GetParameter( const PString & name, int & value )
 275 {
 276   PXMLElement* pElement = GetParameter( name );
 277   if(pElement == NULL)
 278     return FALSE;
 279
 280   if ( pElement->GetAttribute( "xsi:type") == "xsd:int" )
 281   {
 282     value = pElement->GetData().AsInteger();
 283     return TRUE;
 284   }
 285
 286   value = -1;
 287   return FALSE;
 288 }
 289
 290 PXMLElement* PSOAPMessage::GetParameter( const PString & name )
 291 {
 292   if ( pSOAPMethod )
 293   {
 294     return pSOAPMethod->GetElement( name, 0 );
 295   }
 296   else
 297   {
 298     return 0;
 299   }
 300 }
 301
 302 BOOL PSOAPMessage::Load( const PString & str )
 303 {
 304   if ( !PXML::Load( str ) )
 305     return FALSE;
 306
 307   if ( rootElement != NULL )
 308   {
 309     PString soapEnvelopeName = rootElement->GetName();
 310     PString soapEnvelopeID = soapEnvelopeName.Left( soapEnvelopeName.Find(':') );
 311
 312     pSOAPBody = rootElement->GetElement( soapEnvelopeID + ":Body", 0 );
 313
 314     if ( pSOAPBody != NULL )
 315     {
 316       PXMLObjectArray  subObjects = pSOAPBody->GetSubObjects() ;
 317
 318       PINDEX idx;
 319       PINDEX size = subObjects.GetSize();
 320
 321       for ( idx = 0; idx < size; idx++ ) {
 322         if ( subObjects[ idx ].IsElement() ) {
 323           // First subobject being an element is the method
 324           pSOAPMethod = ( PXMLElement * ) &subObjects[ idx  ];
 325
 326           PString method;
 327           PString nameSpace;
 328
 329           GetMethod( method, nameSpace );
 330
 331           // Check if method name is "Fault"
 332           if ( method == "Fault" )
 333           {
 334             // The SOAP server has signalled an error
 335             PString faultCodeData = GetParameter( "faultcode" )->GetData();
 336             faultCode = stringToFaultCode( faultCodeData );
 337             faultText = GetParameter( "faultstring" )->GetData();
 338           }
 339           else
 340           {
 341             return TRUE;
 342           }
 343         }
 344       }
 345     }
 346   }
 347   return FALSE;
 348 }
 349
 350 void PSOAPMessage::SetFault( PINDEX code, const PString & text)
 351 {
 352   faultCode = code;
 353   faultText = text;
 354
 355   PString faultCodeStr = faultCodeToString( code );
 356
 357   SetMethod( "Fault", "" );
 358
 359   AddParameter( "faultcode", "", faultCodeStr );
 360   AddParameter( "faultstring", "", text );
 361
 362 }
 363
 364
 365
 366 /*
 367  SOAP server classes
 368  ####################
 369  */
 370
 371
 372
 373 PSOAPServerResource::PSOAPServerResource()
 374   : PHTTPResource( DEFAULT_SOAP_URL ),
 375   soapAction( " " )
 376 {
 377 }
 378
 379 PSOAPServerResource::PSOAPServerResource(
 380       const PHTTPAuthority & auth )    // Authorisation for the resource.
 381   : PHTTPResource( DEFAULT_SOAP_URL, auth ),
 382   soapAction( " " )
 383 {
 384 }
 385 PSOAPServerResource::PSOAPServerResource(
 386       const PURL & url )               // Name of the resource in URL space.
 387   : PHTTPResource(url )
 388 {
 389 }
 390
 391 PSOAPServerResource::PSOAPServerResource(
 392       const PURL & url,              // Name of the resource in URL space.
 393       const PHTTPAuthority & auth    // Authorisation for the resource.
 394     )
 395   : PHTTPResource( url, auth )
 396 {
 397 }
 398
 399 BOOL PSOAPServerResource::SetMethod(const PString & methodName, const PNotifier & func)
 400 {
 401   // Set the method for the notifier function and add it to the list
 402   PWaitAndSignal m( methodMutex );
 403
 404   // Find the method, or create a new one
 405   PSOAPServerMethod * methodInfo;
 406
 407   PINDEX pos = methodList.GetValuesIndex( methodName );
 408   if (pos != P_MAX_INDEX)
 409   {
 410     methodInfo = ( PSOAPServerMethod *) methodList.GetAt( pos );
 411   }
 412   else
 413   {
 414     methodInfo = new PSOAPServerMethod( methodName );
 415     methodList.Append( methodInfo );
 416   }
 417
 418   // set the function
 419   methodInfo->methodFunc = func;
 420
 421   return TRUE;
 422 }
 423
 424 BOOL PSOAPServerResource::LoadHeaders( PHTTPRequest& /* request */ )    // Information on this request.
 425 {
 426   return TRUE;
 427 }
 428
 429 BOOL PSOAPServerResource::OnPOSTData( PHTTPRequest & request,
 430                                 const PStringToString & /*data*/)
 431 {
 432   PTRACE( 2, "PSOAPServerResource\tReceived post data, request: " << request.entityBody );
 433
 434   PString reply;
 435
 436   BOOL ok = FALSE;
 437
 438   // Check for the SOAPAction header
 439   PString* pSOAPAction = request.inMIME.GetAt( "SOAPAction" );
 440   if ( pSOAPAction )
 441   {
 442     // If it's available check if we are expecting a special header value
 443     if ( soapAction.IsEmpty() || soapAction == " " )
 444     {
 445       // A space means anything goes
 446       ok = OnSOAPRequest( request.entityBody, reply );
 447     }
 448     else
 449     {
 450       // Check if the incoming header is the same as we expected
 451       if ( *pSOAPAction == soapAction )
 452       {
 453         ok = OnSOAPRequest( request.entityBody, reply );
 454       }
 455       else
 456       {
 457         ok = FALSE;
 458         reply = FormatFault( PSOAPMessage::Client, "Incorrect SOAPAction in HTTP Header: " + *pSOAPAction ).AsString();
 459       }
 460     }
 461   }
 462   else
 463   {
 464     ok = FALSE;
 465     reply = FormatFault( PSOAPMessage::Client, "SOAPAction is missing in HTTP Header" ).AsString();
 466   }
 467
 468   // If everything went OK, reply with ReturnCode 200 (OK)
 469   if ( ok )
 470     request.code = PHTTP::RequestOK;
 471   else
 472     // Reply with InternalServerError (500)
 473     request.code = PHTTP::InternalServerError;
 474
 475   // Set the correct content-type
 476   request.outMIME.SetAt(PHTTP::ContentTypeTag, "text/xml");
 477
 478   // Start constructing the response
 479   PINDEX len = reply.GetLength();
 480   request.server.StartResponse( request.code, request.outMIME, len );
 481
 482   // Write the reply to the client
 483   return request.server.Write( (const char* ) reply, len );
 484 }
 485
 486
 487 BOOL PSOAPServerResource::OnSOAPRequest( const PString & body, PString & reply )
 488 {
 489   // Load the HTTP body into the SOAP (XML) parser
 490   PSOAPMessage request;
 491   BOOL ok = request.Load( body );
 492
 493   // If parsing the XML to SOAP failed reply with an error
 494   if ( !ok )
 495   {
 496     reply = FormatFault( PSOAPMessage::Client, "XML error:" + request.GetErrorString() ).AsString();
 497     return FALSE;
 498   }
 499
 500
 501   PString method;
 502   PString nameSpace;
 503
 504   // Retrieve the method from the SOAP messsage
 505   request.GetMethod( method, nameSpace );
 506
 507   PTRACE( 3, "PSOAPServerResource\tReceived SOAP message for method " << method);
 508
 509   return OnSOAPRequest( method, request, reply );
 510 }
 511
 512 BOOL PSOAPServerResource::OnSOAPRequest( const PString & methodName,
 513                                             PSOAPMessage & request,
 514                                             PString & reply )
 515 {
 516   methodMutex.Wait();
 517
 518   // Find the method information
 519   PINDEX pos = methodList.GetValuesIndex( methodName );
 520
 521   if ( pos == P_MAX_INDEX )
 522   {
 523     reply = FormatFault( PSOAPMessage::Client, "Unknown method = " + methodName ).AsString();
 524     return FALSE;
 525   }
 526
 527   PSOAPServerMethod * methodInfo = ( PSOAPServerMethod * )methodList.GetAt( pos );
 528   PNotifier notifier = methodInfo->methodFunc;
 529
 530   methodMutex.Signal();
 531
 532   // create a request/response container to be passed to the notifier function
 533   PSOAPServerRequestResponse p( request );
 534
 535   // call the notifier
 536   notifier( p, 0 );
 537
 538   // get the reply
 539
 540   reply = p.response.AsString();
 541
 542   return p.response.GetFaultCode() == PSOAPMessage::NoFault;
 543 }
 544
 545
 546 PSOAPMessage PSOAPServerResource::FormatFault( PINDEX code, const PString & str )
 547 {
 548   PTRACE(2, "PSOAPServerResource\trequest failed: " << str);
 549
 550   PSOAPMessage reply;
 551
 552   PString faultCodeStr = faultCodeToString( code );
 553
 554   reply.SetMethod( "Fault", "" );
 555
 556   reply.AddParameter( "faultcode", "", faultCodeStr );
 557   reply.AddParameter( "faultstring", "", str );
 558
 559   return reply;
 560 }
 561
 562
 563 /*
 564  SOAP client classes
 565  ####################
 566  */
 567
 568
 569 PSOAPClient::PSOAPClient( const PURL & _url )
 570   : url(_url),
 571   soapAction( " " )
 572 {
 573   timeout = 10000;
 574 }
 575
 576 BOOL PSOAPClient::MakeRequest( const PString & method, const PString & nameSpace )
 577 {
 578   PSOAPMessage request( method, nameSpace );
 579   PSOAPMessage response;
 580
 581   return MakeRequest( request, response );
 582 }
 583
 584 BOOL PSOAPClient::MakeRequest( const PString & method, const PString & nameSpace, PSOAPMessage & response )
 585 {
 586   PSOAPMessage request( method, nameSpace );
 587
 588   return MakeRequest( request, response );
 589 }
 590
 591 BOOL PSOAPClient::MakeRequest( PSOAPMessage & request, PSOAPMessage & response )
 592 {
 593   return  PerformRequest( request, response );
 594 }
 595
 596 BOOL PSOAPClient::PerformRequest( PSOAPMessage & request, PSOAPMessage & response )
 597 {
 598   // create SOAP request
 599   PString soapRequest;
 600
 601   PStringStream txt;
 602
 603   if ( !request.Save( soapRequest ) )
 604   {
 605
 606     txt << "Error creating request XML ("
 607         << request.GetErrorLine()
 608         << ") :"
 609         << request.GetErrorString();
 610     return FALSE;
 611   }
 612
 613   // End with a newline
 614   soapRequest += "\n";
 615
 616   PTRACE( 5, "SOAPClient\tOutgoing SOAP is " << soapRequest );
 617
 618   // do the request
 619   PHTTPClient client;
 620   PMIMEInfo sendMIME, replyMIME;
 621   sendMIME.SetAt( "Server", url.GetHostName() );
 622   sendMIME.SetAt( PHTTP::ContentTypeTag, "text/xml" );
 623   sendMIME.SetAt( "SOAPAction", soapAction );
 624
 625   if(url.GetUserName() != "") {
 626       PStringStream SoapAuthToken;
 627       SoapAuthToken << url.GetUserName() << ":" << url.GetPassword();
 628       sendMIME.SetAt( "Authorization", PBase64::Encode(SoapAuthToken) );
 629   }
 630
 631   // Set thetimeout
 632   client.SetReadTimeout( timeout );
 633
 634   // Send the POST request to the server
 635   BOOL ok = client.PostData( url, sendMIME, soapRequest, replyMIME );
 636
 637   // Find the length of the response
 638   PINDEX contentLength;
 639   if ( replyMIME.Contains( PHTTP::ContentLengthTag ) )
 640     contentLength = ( PINDEX ) replyMIME[ PHTTP::ContentLengthTag ].AsUnsigned();
 641   else if ( ok)
 642     contentLength = P_MAX_INDEX;
 643   else
 644     contentLength = 0;
 645
 646   // Retrieve the response
 647   PString replyBody = client.ReadString( contentLength );
 648
 649   PTRACE( 5, "PSOAP\tIncoming SOAP is " << replyBody );
 650
 651   // Check if the server really gave us something
 652   if ( !ok || replyBody.IsEmpty() )
 653   {
 654     txt << "HTTP POST failed: "
 655         << client.GetLastResponseCode() << ' '
 656         << client.GetLastResponseInfo();
 657   }
 658
 659   // Parse the response only if the response code from the server
 660   // is either 500 (Internal server error) or 200 (RequestOK)
 661
 662   if ( ( client.GetLastResponseCode() == PHTTP::RequestOK ) ||
 663        ( client.GetLastResponseCode() == PHTTP::InternalServerError ) )
 664   {
 665     if (!response.Load(replyBody))
 666     {
 667       txt << "Error parsing response XML ("
 668         << response.GetErrorLine()
 669         << ") :"
 670         << response.GetErrorString();
 671
 672       PStringArray lines = replyBody.Lines();
 673       for ( int offset = -2; offset <= 2; offset++ ) {
 674         int line = response.GetErrorLine() + offset;
 675
 676         if ( line >= 0 && line < lines.GetSize() )
 677           txt << lines[ ( PINDEX ) line ];
 678       }
 679     }
 680   }
 681
 682
 683   if ( ( client.GetLastResponseCode() != PHTTP::RequestOK ) &&
 684        ( client.GetLastResponseCode() != PHTTP::InternalServerError ) &&
 685        ( !ok ) )
 686   {
 687     response.SetFault( PSOAPMessage::Server, txt );
 688     return FALSE;
 689   }
 690
 691
 692   return TRUE;
 693 }
 694
 695
 696 #endif // P_EXPAT
 697
 698
 699 // End of File ////////////////////////////////////////////////////////////////