src/ptclib/pxmlrpc.cxx

   1 /*
   2  * pxmlrpc.cxx
   3  *
   4  * XML/RPC support
   5  *
   6  * Portable Windows Library
   7  *
   8  * Copyright (c) 2002 Equivalence Pty. Ltd.
   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 Equivalence Pty. Ltd.
  23  *
  24  * Contributor(s): ______________________________________.
  25  *
  26  * $Log$
  27  * Revision 1.24  2003/04/15 03:00:41  robertj
  28  * Added array support to XML/RPC
  29  * Fixed XML/RPC parsing when lots of white space in raw XML, caused by
  30  *   big fix to base XML parser not returning internal data elements.
  31  *
  32  * Revision 1.23  2003/02/21 05:07:27  robertj
  33  * Fixed GetParam() for an int type so can accept i4/int/boolean type names.
  34  *
  35  * Revision 1.22  2003/01/28 07:42:17  robertj
  36  * Improved trace output of errors.
  37  *
  38  * Revision 1.21  2002/12/16 06:53:19  robertj
  39  * Added ability to specify certain elemets (by name) that are exempt from
  40  *   the indent formatting. Useful for XML/RPC where leading white space is
  41  *   not ignored by all servers.
  42  * Allowed for some servers that only send "string" type for "int" etc
  43  * Fixed problem with autodetecting reply that is a single struct.
  44  *
  45  * Revision 1.20  2002/12/13 01:12:24  robertj
  46  * Added copy constructor and assignment operator to XML/RPC structs
  47  *
  48  * Revision 1.19  2002/12/10 03:51:17  robertj
  49  * Fixed member variable display in structure
  50  *
  51  * Revision 1.18  2002/12/09 04:06:44  robertj
  52  * Added macros for defining multi-argument functions
  53  *
  54  * Revision 1.17  2002/12/04 00:31:13  robertj
  55  * Fixed GNU compatibility
  56  *
  57  * Revision 1.16  2002/12/04 00:15:44  robertj
  58  * Changed usage of PHTTPClient so supports chunked transfer encoding.
  59  * Large enhancement to create automatically encoding and decoding structures
  60  *   using macros to build a class.
  61  *
  62  * Revision 1.15  2002/11/06 22:47:25  robertj
  63  * Fixed header comment (copyright etc)
  64  *
  65  * Revision 1.14  2002/10/08 12:26:31  craigs
  66  * Changed struct members to always contain name/value in that order
  67  *
  68  * Revision 1.13  2002/10/08 12:09:28  craigs
  69  * More fixes for creation of struct params
  70  *
  71  * Revision 1.12  2002/10/08 11:58:01  craigs
  72  * Fixed creation of struct params
  73  *
  74  * Revision 1.11  2002/10/08 11:48:37  craigs
  75  * Added logging of incoming and outgoing XML at highest log level
  76  *
  77  * Revision 1.10  2002/10/08 11:36:56  craigs
  78  * Fixed fault parsing
  79  *
  80  * Revision 1.9  2002/10/08 08:22:18  craigs
  81  * Fixed problem with parsing struct parameters
  82  *
  83  * Revision 1.8  2002/10/02 08:54:01  craigs
  84  * Added support for XMLRPC server
  85  *
  86  * Revision 1.7  2002/08/13 03:02:07  robertj
  87  * Removed previous fix for memory leak, as object was already deleted.
  88  *
  89  * Revision 1.6  2002/08/13 01:54:47  craigs
  90  * Fixed memory leak on PXMLRPCRequest class
  91  *
  92  * Revision 1.5  2002/08/06 01:04:03  robertj
  93  * Fixed missing pragma interface/implementation
  94  *
  95  * Revision 1.4  2002/08/02 05:42:10  robertj
  96  * Fixed confusion between in and out MIME.
  97  * Improved trace logging and error reporting.
  98  *
  99  * Revision 1.3  2002/07/12 05:51:35  craigs
 100  * Added structs to XMLRPC response types
 101  *
 102  * Revision 1.2  2002/03/27 00:50:29  craigs
 103  * Fixed problems with parsing faults and creating structs
 104  *
 105  * Revision 1.1  2002/03/26 07:06:29  craigs
 106  * Initial version
 107  *
 108  */
 109
 110 // This depends on the expat XML library by Jim Clark
 111 // See http://www.jclark.com/xml/expat.html for more information
 112
 113 #include <ptlib.h>
 114
 115 #ifdef __GNUC__
 116 #pragma implementation "pxmlrpc.h"
 117 #endif
 118
 119 #include <ptclib/pxmlrpc.h>
 120
 121
 122 #if P_EXPAT
 123
 124 #include <ptclib/mime.h>
 125 #include <ptclib/http.h>
 126
 127
 128 static const char NoIndentElements[] = "methodName name string int boolean double dateTime.iso8601";
 129
 130
 131 /////////////////////////////////////////////////////////////////
 132
 133 PXMLRPCBlock::PXMLRPCBlock()
 134   : PXML(-1, NoIndentElements)
 135 {
 136   faultCode = P_MAX_INDEX;
 137   SetRootElement("methodResponse");
 138   params = NULL;
 139 }
 140
 141 PXMLRPCBlock::PXMLRPCBlock(const PString & method)
 142   : PXML(-1, NoIndentElements)
 143 {
 144   faultCode = P_MAX_INDEX;
 145   SetRootElement("methodCall");
 146   rootElement->AddChild(new PXMLElement(rootElement, "methodName", method));
 147   params = NULL;
 148 }
 149
 150 PXMLRPCBlock::PXMLRPCBlock(const PString & method, const PXMLRPCStructBase & data)
 151   : PXML(-1, NoIndentElements)
 152 {
 153   faultCode = P_MAX_INDEX;
 154   SetRootElement("methodCall");
 155   rootElement->AddChild(new PXMLElement(rootElement, "methodName", method));
 156   params = NULL;
 157
 158   for (PINDEX i = 0; i < data.GetNumVariables(); i++) {
 159     PXMLRPCVariableBase & variable = data.GetVariable(i);
 160     if (variable.IsArray())
 161       AddParam(CreateArray(variable));
 162     else {
 163       PXMLRPCStructBase * structVar = variable.GetStruct(0);
 164       if (structVar != NULL)
 165         AddParam(*structVar);
 166       else
 167         AddParam(CreateValueElement(new PXMLElement(NULL, variable.GetType(), variable.ToString(0))));
 168     }
 169   }
 170 }
 171
 172
 173 BOOL PXMLRPCBlock::Load(const PString & str)
 174 {
 175   if (!PXML::Load(str))
 176     return FALSE;
 177
 178   if (rootElement != NULL)
 179     params = rootElement->GetElement("params");
 180
 181   return TRUE;
 182 }
 183
 184
 185 PXMLElement * PXMLRPCBlock::GetParams()
 186 {
 187   if (params == NULL)
 188     params = rootElement->AddChild(new PXMLElement(rootElement, "params"));
 189
 190   return params;
 191 }
 192
 193 PXMLElement * PXMLRPCBlock::CreateValueElement(PXMLElement * element)
 194 {
 195   PXMLElement * value = new PXMLElement(NULL, "value");
 196   value->AddChild(element);
 197   element->SetParent(value);
 198
 199   return value;
 200 }
 201
 202 PXMLElement * PXMLRPCBlock::CreateScalar(const PString & type,
 203                                          const PString & scalar)
 204 {
 205   return CreateValueElement(new PXMLElement(NULL, type, scalar));
 206 }
 207
 208 PXMLElement * PXMLRPCBlock::CreateScalar(const PString & str)
 209 {
 210   return CreateScalar("string", str);
 211 }
 212
 213 PXMLElement * PXMLRPCBlock::CreateScalar(int value)
 214 {
 215   return CreateScalar("int", PString(PString::Unsigned, value));
 216 }
 217
 218 PXMLElement * PXMLRPCBlock::CreateScalar(double value)
 219 {
 220   return CreateScalar("double", psprintf("%lf", value));
 221 }
 222
 223 PXMLElement * PXMLRPCBlock::CreateDateAndTime(const PTime & time)
 224 {
 225   return CreateScalar("dateTime.iso8601", PXMLRPC::PTimeToISO8601(time));
 226 }
 227
 228 PXMLElement * PXMLRPCBlock::CreateBinary(const PBYTEArray & data)
 229 {
 230   return CreateScalar("base64", PBase64::Encode(data));
 231 }
 232
 233 PXMLElement * PXMLRPCBlock::CreateStruct()
 234 {
 235   PAssertAlways("Not used");
 236   return NULL;
 237 }
 238
 239
 240 PXMLElement * PXMLRPCBlock::CreateStruct(const PStringToString & dict)
 241 {
 242   return CreateStruct(dict, "string");
 243 }
 244
 245 PXMLElement * PXMLRPCBlock::CreateStruct(const PStringToString & dict, const PString & typeStr)
 246 {
 247   PXMLElement * structElement = new PXMLElement(NULL, "struct");
 248   PXMLElement * valueElement  = CreateValueElement(structElement);
 249
 250   PINDEX i;
 251   for (i = 0; i < dict.GetSize(); i++) {
 252     PString key = dict.GetKeyAt(i);
 253     structElement->AddChild(CreateMember(key, CreateScalar(typeStr, dict[key])));
 254   }
 255
 256   return valueElement;
 257 }
 258
 259
 260 PXMLElement * PXMLRPCBlock::CreateStruct(const PXMLRPCStructBase & data)
 261 {
 262   PXMLElement * structElement = new PXMLElement(NULL, "struct");
 263   PXMLElement * valueElement  = PXMLRPCBlock::CreateValueElement(structElement);
 264
 265   PINDEX i;
 266   for (i = 0; i < data.GetNumVariables(); i++) {
 267     PXMLElement * element;
 268     PXMLRPCVariableBase & variable = data.GetVariable(i);
 269
 270     if (variable.IsArray())
 271       element = CreateArray(variable);
 272     else {
 273       PXMLRPCStructBase * nested = variable.GetStruct(0);
 274       if (nested != NULL)
 275         element = CreateStruct(*nested);
 276       else
 277         element = CreateScalar(variable.GetType(), variable.ToString(0));
 278     }
 279
 280     structElement->AddChild(CreateMember(variable.GetName(), element));
 281   }
 282
 283   return valueElement;
 284 }
 285
 286
 287 PXMLElement * PXMLRPCBlock::CreateMember(const PString & name, PXMLElement * value)
 288 {
 289   PXMLElement * member = new PXMLElement(NULL, "member");
 290   member->AddChild(new PXMLElement(member, "name", name));
 291   member->AddChild(value);
 292
 293   return member;
 294 }
 295
 296
 297 PXMLElement * PXMLRPCBlock::CreateArray(const PStringArray & array)
 298 {
 299   return CreateArray(array, "string");
 300 }
 301
 302
 303 PXMLElement * PXMLRPCBlock::CreateArray(const PStringArray & array, const PString & typeStr)
 304 {
 305   PXMLElement * arrayElement = new PXMLElement(NULL, "array");
 306
 307   PXMLElement * dataElement = new PXMLElement(arrayElement, "data");
 308   arrayElement->AddChild(dataElement);
 309
 310   PINDEX i;
 311   for (i = 0; i < array.GetSize(); i++)
 312     dataElement->AddChild(CreateScalar(typeStr, array[i]));
 313
 314   return CreateValueElement(arrayElement);
 315 }
 316
 317
 318 PXMLElement * PXMLRPCBlock::CreateArray(const PStringArray & array, const PStringArray & types)
 319 {
 320   PXMLElement * arrayElement = new PXMLElement(NULL, "array");
 321
 322   PXMLElement * dataElement = new PXMLElement(arrayElement, "data");
 323   arrayElement->AddChild(dataElement);
 324
 325   PINDEX i;
 326   for (i = 0; i < array.GetSize(); i++)
 327     dataElement->AddChild(CreateScalar(types[i], array[i]));
 328
 329   return CreateValueElement(arrayElement);
 330 }
 331
 332
 333 PXMLElement * PXMLRPCBlock::CreateArray(const PArray<PStringToString> & array)
 334 {
 335   PXMLElement * arrayElement = new PXMLElement(NULL, "array");
 336
 337   PXMLElement * dataElement = new PXMLElement(arrayElement, "data");
 338   arrayElement->AddChild(dataElement);
 339
 340   PINDEX i;
 341   for (i = 0; i < array.GetSize(); i++)
 342     dataElement->AddChild(CreateStruct(array[i]));
 343
 344   return CreateValueElement(arrayElement);
 345 }
 346
 347
 348 PXMLElement * PXMLRPCBlock::CreateArray(const PXMLRPCVariableBase & array)
 349 {
 350   PXMLElement * arrayElement = new PXMLElement(NULL, "array");
 351
 352   PXMLElement * dataElement = new PXMLElement(arrayElement, "data");
 353   arrayElement->AddChild(dataElement);
 354
 355   PINDEX i;
 356   for (i = 0; i < array.GetSize(); i++) {
 357     PXMLElement * element;
 358     PXMLRPCStructBase * structure = array.GetStruct(i);
 359     if (structure != NULL)
 360       element = CreateStruct(*structure);
 361     else
 362       element = CreateScalar(array.GetType(), array.ToString(i));
 363     dataElement->AddChild(element);
 364   }
 365
 366   return CreateValueElement(arrayElement);
 367 }
 368
 369
 370 /////////////////////////////////////////////
 371
 372 void PXMLRPCBlock::AddParam(PXMLElement * parm)
 373 {
 374   GetParams();
 375   PXMLElement * child = params->AddChild(new PXMLElement(params, "param"));
 376   child->AddChild(parm);
 377   parm->SetParent(child);
 378 }
 379
 380 void PXMLRPCBlock::AddParam(const PString & str)
 381 {
 382   AddParam(CreateScalar(str));
 383 }
 384
 385 void PXMLRPCBlock::AddParam(int value)
 386 {
 387   AddParam(CreateScalar(value));
 388 }
 389
 390 void PXMLRPCBlock::AddParam(double value)
 391 {
 392   AddParam(CreateScalar(value));
 393 }
 394
 395 void PXMLRPCBlock::AddParam(const PTime & time)
 396 {
 397   AddParam(CreateDateAndTime(time));
 398 }
 399
 400 void PXMLRPCBlock::AddBinary(const PBYTEArray & data)
 401 {
 402   AddParam(CreateBinary(data));
 403 }
 404
 405 void PXMLRPCBlock::AddParam(const PXMLRPCStructBase & data)
 406 {
 407   AddParam(CreateStruct(data));
 408 }
 409
 410 void PXMLRPCBlock::AddStruct(const PStringToString & dict)
 411 {
 412   AddParam(CreateStruct(dict, "string"));
 413 }
 414
 415 void PXMLRPCBlock::AddStruct(const PStringToString & dict, const PString & typeStr)
 416 {
 417   AddParam(CreateStruct(dict, typeStr));
 418 }
 419
 420 void PXMLRPCBlock::AddArray(const PStringArray & array)
 421 {
 422   AddParam(CreateArray(array, "string"));
 423 }
 424
 425 void PXMLRPCBlock::AddArray(const PStringArray & array, const PString & typeStr)
 426 {
 427   AddParam(CreateArray(array, typeStr));
 428 }
 429
 430 void PXMLRPCBlock::AddArray(const PStringArray & array, const PStringArray & types)
 431 {
 432   AddParam(CreateArray(array, types));
 433 }
 434
 435 void PXMLRPCBlock::AddArray(const PArray<PStringToString> & array)
 436 {
 437   AddParam(CreateArray(array));
 438 }
 439
 440
 441 /////////////////////////////////////////////
 442
 443 BOOL PXMLRPCBlock::ValidateResponse()
 444 {
 445   // ensure root element exists and has correct name
 446   if ((rootElement == NULL) ||
 447       (rootElement->GetName() != "methodResponse")) {
 448     SetFault(PXMLRPC::ResponseRootNotMethodResponse, "Response root not methodResponse");
 449     PTRACE(2, "XMLRPC\t" << GetFaultText());
 450     return FALSE;
 451   }
 452
 453   // determine if response returned
 454   if (params == NULL)
 455     params = rootElement->GetElement("params");
 456   if (params == NULL)
 457     return TRUE;
 458
 459   // determine if fault
 460   if (params->GetName() == "fault") {
 461
 462     // assume fault is a simple struct
 463     PStringToString faultInfo;
 464     PXMLElement * value = params->GetElement("value");
 465     if (value == NULL) {
 466       PStringStream txt;
 467       txt << "Fault does not contain value\n" << *this;
 468       SetFault(PXMLRPC::FaultyFault, txt);
 469     } else if (!ParseStruct(value->GetElement("struct"), faultInfo) ||
 470          (faultInfo.GetSize() != 2) ||
 471          (!faultInfo.Contains("faultCode")) ||
 472          (!faultInfo.Contains("faultString"))
 473          ) {
 474       PStringStream txt;
 475       txt << "Fault return is faulty:\n" << *this;
 476       SetFault(PXMLRPC::FaultyFault, txt);
 477       PTRACE(2, "XMLRPC\t" << GetFaultText());
 478       return FALSE;
 479     }
 480
 481     // get fault code and string
 482     SetFault(faultInfo["faultCode"].AsInteger(), faultInfo["faultString"]);
 483
 484     return FALSE;
 485   }
 486
 487   // must be params
 488   else if (params->GetName() != "params") {
 489     SetFault(PXMLRPC::ResponseUnknownFormat, PString("Response contains unknown element") & params->GetName());
 490     PTRACE(2, "XMLRPC\t" << GetFaultText());
 491     return FALSE;
 492   }
 493
 494   return TRUE;
 495 }
 496
 497 BOOL PXMLRPCBlock::ParseScalar(PXMLElement * valueElement,
 498                                    PString & type,
 499                                    PString & value)
 500 {
 501   if (valueElement == NULL)
 502     return FALSE;
 503
 504   if (!valueElement->IsElement())
 505     return FALSE;
 506
 507   if (valueElement->GetName() != "value") {
 508     SetFault(PXMLRPC::ParamNotValue, "Scalar value does not contain value element");
 509     PTRACE(2, "RPCXML\t" << GetFaultText());
 510     return FALSE;
 511   }
 512
 513   for (PINDEX i = 0; i < valueElement->GetSize(); i++) {
 514     PXMLElement * element = (PXMLElement *)valueElement->GetElement(i);
 515     if (element != NULL && element->IsElement()) {
 516       type = element->GetName();
 517       value = element->GetData();
 518       return TRUE;
 519     }
 520   }
 521
 522   SetFault(PXMLRPC::ScalarWithoutElement, "Scalar without sub-element");
 523   PTRACE(2, "XMLRPC\t" << GetFaultText());
 524   return FALSE;
 525 }
 526
 527
 528 static BOOL ParseStructBase(PXMLRPCBlock & block, PXMLElement * & element)
 529 {
 530   if (element == NULL)
 531     return FALSE;
 532
 533   if (!element->IsElement())
 534     return FALSE;
 535
 536   if (element->GetName() == "struct")
 537     return TRUE;
 538
 539   if (element->GetName() != "value")
 540     block.SetFault(PXMLRPC::ParamNotStruct, "Param is not struct");
 541   else {
 542     element = element->GetElement("struct");
 543     if (element != NULL)
 544       return TRUE;
 545
 546     block.SetFault(PXMLRPC::ParamNotStruct, "nested structure not present");
 547   }
 548
 549   PTRACE(2, "XMLRPC\t" << block.GetFaultText());
 550   return FALSE;
 551 }
 552
 553
 554 static PXMLElement * ParseStructElement(PXMLRPCBlock & block,
 555                                         PXMLElement * structElement,
 556                                         PINDEX idx,
 557                                         PString & name)
 558 {
 559   if (structElement == NULL)
 560     return NULL;
 561
 562   PXMLElement * member = (PXMLElement *)structElement->GetElement(idx);
 563   if (member == NULL)
 564     return NULL;
 565
 566   if (!member->IsElement())
 567     return NULL;
 568
 569   if (member->GetName() != "member") {
 570     PStringStream txt;
 571     txt << "Member " << idx << " missing";
 572     block.SetFault(PXMLRPC::MemberIncomplete, txt);
 573     PTRACE(2, "XMLRPC\t" << block.GetFaultText());
 574     return NULL;
 575   }
 576
 577   PXMLElement * nameElement  = member->GetElement("name");
 578   PXMLElement * valueElement = member->GetElement("value");
 579   if ((nameElement == NULL) || (valueElement == NULL)) {
 580     PStringStream txt;
 581     txt << "Member " << idx << " incomplete";
 582     block.SetFault(PXMLRPC::MemberIncomplete, txt);
 583     PTRACE(2, "XMLRPC\t" << block.GetFaultText());
 584     return NULL;
 585   }
 586
 587   if (nameElement->GetName() != "name") {
 588     PStringStream txt;
 589     txt << "Member " << idx << " unnamed";
 590     block.SetFault(PXMLRPC::MemberUnnamed, txt);
 591     PTRACE(2, "XMLRPC\t" << block.GetFaultText());
 592     return NULL;
 593   }
 594
 595   name = nameElement->GetData();
 596   return valueElement;
 597 }
 598
 599
 600 BOOL PXMLRPCBlock::ParseStruct(PXMLElement * structElement,
 601                                PStringToString & structDict)
 602 {
 603   if (!ParseStructBase(*this, structElement))
 604     return FALSE;
 605
 606   for (PINDEX i = 0; i < structElement->GetSize(); i++) {
 607     PString name;
 608     PXMLElement * element = ParseStructElement(*this, structElement, i, name);
 609     if (element != NULL) {
 610       PString value;
 611       PString type;
 612       if (ParseScalar(element, type, value))
 613         structDict.SetAt(name, value);
 614     }
 615   }
 616
 617   return TRUE;
 618 }
 619
 620
 621 BOOL PXMLRPCBlock::ParseStruct(PXMLElement * structElement, PXMLRPCStructBase & data)
 622 {
 623   if (!ParseStructBase(*this, structElement))
 624     return FALSE;
 625
 626   for (PINDEX i = 0; i < structElement->GetSize(); i++) {
 627     PString name;
 628     PXMLElement * element = ParseStructElement(*this, structElement, i, name);
 629     if (element != NULL) {
 630       PXMLRPCVariableBase * variable = data.GetVariable(name);
 631       if (variable != NULL) {
 632         if (variable->IsArray()) {
 633           if (!ParseArray(element, *variable))
 634             return FALSE;
 635         }
 636         else {
 637           PXMLRPCStructBase * nested = variable->GetStruct(0);
 638           if (nested != NULL) {
 639             if (!ParseStruct(element, *nested))
 640               return FALSE;
 641           }
 642           else {
 643             PString value;
 644             PCaselessString type;
 645             if (!ParseScalar(element, type, value))
 646               return FALSE;
 647
 648             if (type != "string" && type != variable->GetType()) {
 649               PTRACE(2, "RPCXML\tMember " << i << " is not of expected type: " << variable->GetType());
 650               return FALSE;
 651             }
 652
 653             variable->FromString(0, value);
 654           }
 655         }
 656       }
 657     }
 658   }
 659
 660   return TRUE;
 661 }
 662
 663
 664 static PXMLElement * ParseArrayBase(PXMLRPCBlock & block, PXMLElement * element)
 665 {
 666   if (element == NULL)
 667     return NULL;
 668
 669   if (!element->IsElement())
 670     return NULL;
 671
 672   if (element->GetName() == "value")
 673     element = element->GetElement("array");
 674
 675   if (element == NULL)
 676     block.SetFault(PXMLRPC::ParamNotArray, "array not present");
 677   else {
 678     if (element->GetName() != "array")
 679       block.SetFault(PXMLRPC::ParamNotArray, "Param is not array");
 680     else {
 681       element = element->GetElement("data");
 682       if (element != NULL)
 683         return element;
 684       block.SetFault(PXMLRPC::ParamNotArray, "Array param has no data");
 685     }
 686   }
 687
 688   PTRACE(2, "XMLRPC\t" << block.GetFaultText());
 689   return NULL;
 690 }
 691
 692
 693 BOOL PXMLRPCBlock::ParseArray(PXMLElement * arrayElement, PStringArray & array)
 694 {
 695   PXMLElement * dataElement = ParseArrayBase(*this, arrayElement);
 696   if (dataElement == NULL)
 697     return FALSE;
 698
 699   array.SetSize(dataElement->GetSize());
 700
 701   PINDEX count = 0;
 702   for (PINDEX i = 0; i < dataElement->GetSize(); i++) {
 703     PString value;
 704     PString type;
 705     if (ParseScalar((PXMLElement *)dataElement->GetElement(i), type, value))
 706       array[count++] = value;
 707   }
 708
 709   array.SetSize(count);
 710   return TRUE;
 711 }
 712
 713
 714 BOOL PXMLRPCBlock::ParseArray(PXMLElement * arrayElement, PArray<PStringToString> & array)
 715 {
 716   PXMLElement * dataElement = ParseArrayBase(*this, arrayElement);
 717   if (dataElement == NULL)
 718     return FALSE;
 719
 720   array.SetSize(dataElement->GetSize());
 721
 722   PINDEX count = 0;
 723   for (PINDEX i = 0; i < dataElement->GetSize(); i++) {
 724     PStringToString values;
 725     if (!ParseStruct((PXMLElement *)dataElement->GetElement(i), values))
 726       return FALSE;
 727
 728     array[count++] = values;
 729   }
 730
 731   array.SetSize(count);
 732   return TRUE;
 733 }
 734
 735
 736 BOOL PXMLRPCBlock::ParseArray(PXMLElement * arrayElement, PXMLRPCVariableBase & array)
 737 {
 738   PXMLElement * dataElement = ParseArrayBase(*this, arrayElement);
 739   if (dataElement == NULL)
 740     return FALSE;
 741
 742   array.SetSize(dataElement->GetSize());
 743
 744   PINDEX count = 0;
 745   for (PINDEX i = 0; i < dataElement->GetSize(); i++) {
 746     PXMLElement * element = (PXMLElement *)dataElement->GetElement(i);
 747
 748     PXMLRPCStructBase * structure = array.GetStruct(i);
 749     if (structure != NULL) {
 750       if (ParseStruct(element, *structure))
 751         count++;
 752     }
 753     else {
 754       PString value;
 755       PCaselessString type;
 756       if (ParseScalar(element, type, value)) {
 757         if (type != "string" && type != array.GetType())
 758           PTRACE(2, "RPCXML\tArray entry " << i << " is not of expected type: " << array.GetType());
 759         else
 760           array.FromString(count++, value);
 761       }
 762     }
 763   }
 764
 765   array.SetSize(count);
 766   return TRUE;
 767 }
 768
 769
 770 PINDEX PXMLRPCBlock::GetParamCount() const
 771 {
 772   if (params == NULL)
 773     return 0;
 774
 775   PINDEX count = 0;
 776   for (PINDEX i = 0; i < params->GetSize(); i++) {
 777     PXMLElement * element = (PXMLElement *)params->GetElement(i);
 778     if (element != NULL && element->IsElement() && element->GetName() == "param")
 779       count++;
 780   }
 781   return count;
 782 }
 783
 784
 785 PXMLElement * PXMLRPCBlock::GetParam(PINDEX idx) const
 786 {
 787   if (params == NULL)
 788     return NULL;
 789
 790   PXMLElement * param = NULL;
 791   PINDEX i;
 792   for (i = 0; i < params->GetSize(); i++) {
 793     PXMLElement * element = (PXMLElement *)params->GetElement(i);
 794     if (element != NULL && element->IsElement() && element->GetName() == "param") {
 795       if (idx <= 0) {
 796         param = element;
 797         break;
 798       }
 799       idx--;
 800     }
 801   }
 802
 803   if (param == NULL)
 804     return FALSE;
 805
 806   for (i = 0; i < param->GetSize(); i++) {
 807     PXMLObject * parm = param->GetElement(i);
 808     if (parm != NULL && parm->IsElement())
 809       return (PXMLElement *)parm;
 810   }
 811
 812   return NULL;
 813 }
 814
 815
 816 BOOL PXMLRPCBlock::GetParams(PXMLRPCStructBase & data)
 817 {
 818   if (params == NULL)
 819     return FALSE;
 820
 821   // Special case to allow for server implementations that always return
 822   // values as a struct rather than multiple parameters.
 823   if (GetParamCount() == 1 &&
 824           (data.GetNumVariables() > 1 || data.GetVariable(0).GetStruct(0) == NULL)) {
 825     PString type, value;
 826     if (ParseScalar(GetParam(0), type, value) && type == "struct")
 827       return GetParam(0, data);
 828   }
 829
 830   for (PINDEX i = 0; i < data.GetNumVariables(); i++) {
 831     PXMLRPCVariableBase & variable = data.GetVariable(i);
 832     if (variable.IsArray()) {
 833       if (!ParseArray(GetParam(i), variable))
 834         return FALSE;
 835     }
 836     else {
 837       PXMLRPCStructBase * structure = variable.GetStruct(0);
 838       if (structure != NULL) {
 839         if (!GetParam(i, *structure))
 840           return FALSE;
 841       }
 842       else {
 843         PString value;
 844         if (!GetExpectedParam(i, variable.GetType(), value))
 845           return FALSE;
 846
 847         variable.FromString(0, value);
 848       }
 849     }
 850   }
 851
 852   return TRUE;
 853 }
 854
 855
 856 BOOL PXMLRPCBlock::GetParam(PINDEX idx, PString & type, PString & value)
 857 {
 858   // get the parameter
 859   if (!ParseScalar(GetParam(idx), type, value)) {
 860     PTRACE(3, "XMLRPC\tCannot get scalar parm " << idx);
 861     return FALSE;
 862   }
 863
 864   return TRUE;
 865 }
 866
 867
 868 BOOL PXMLRPCBlock::GetExpectedParam(PINDEX idx, const PString & expectedType, PString & value)
 869 {
 870   PString type;
 871
 872   // get parameter
 873   if (!GetParam(idx, type, value))
 874     return FALSE;
 875
 876   // see if correct type
 877   if (!expectedType.IsEmpty() && (type != expectedType)) {
 878     PTRACE(3, "XMLRPC\tExpected parm " << idx << " to be " << expectedType << ", was " << type);
 879     return FALSE;
 880   }
 881
 882   return TRUE;
 883 }
 884
 885
 886 BOOL PXMLRPCBlock::GetParam(PINDEX idx, PString & result)
 887 {
 888   return GetExpectedParam(idx, "string", result);
 889 }
 890
 891 BOOL PXMLRPCBlock::GetParam(PINDEX idx, int & val)
 892 {
 893   PString type, result;
 894   if (!GetParam(idx, type, result))
 895     return FALSE;
 896
 897   if ((type != "i4") &&
 898       (type != "int") &&
 899       (type != "boolean")) {
 900     PTRACE(3, "XMLRPC\tExpected parm " << idx << " to be intger compatible, was " << type);
 901     return FALSE;
 902   }
 903
 904   val = result.AsInteger();
 905   return TRUE;
 906 }
 907
 908 BOOL PXMLRPCBlock::GetParam(PINDEX idx, double & val)
 909 {
 910   PString result;
 911   if (!GetExpectedParam(idx, "double", result))
 912     return FALSE;
 913
 914   val = result.AsReal();
 915   return TRUE;
 916 }
 917
 918 // 01234567890123456
 919 // yyyyMMddThh:mm:ss
 920
 921 BOOL PXMLRPCBlock::GetParam(PINDEX idx, PTime & val, int tz)
 922 {
 923   PString result;
 924   if (!GetExpectedParam(idx, "dateTime.iso8601", result))
 925     return FALSE;
 926
 927   return PXMLRPC::ISO8601ToPTime(result, val, tz);
 928 }
 929
 930 BOOL PXMLRPCBlock::GetParam(PINDEX idx, PStringArray & result)
 931 {
 932   return ParseArray(GetParam(idx), result);
 933 }
 934
 935 BOOL PXMLRPCBlock::GetParam(PINDEX idx, PArray<PStringToString> & result)
 936 {
 937   return ParseArray(GetParam(idx), result);
 938 }
 939
 940
 941 BOOL PXMLRPCBlock::GetParam(PINDEX idx, PStringToString & result)
 942 {
 943   return ParseStruct(GetParam(idx), result);
 944 }
 945
 946
 947 BOOL PXMLRPCBlock::GetParam(PINDEX idx, PXMLRPCStructBase & data)
 948 {
 949   return ParseStruct(GetParam(idx), data);
 950 }
 951
 952
 953 ////////////////////////////////////////////////////////
 954
 955 PXMLRPC::PXMLRPC(const PURL & _url, unsigned opts)
 956   : url(_url)
 957 {
 958   timeout = 10000;
 959   options = opts;
 960 }
 961
 962 BOOL PXMLRPC::MakeRequest(const PString & method)
 963 {
 964   PXMLRPCBlock request(method);
 965   PXMLRPCBlock response;
 966
 967   return MakeRequest(request, response);
 968 }
 969
 970 BOOL PXMLRPC::MakeRequest(const PString & method, PXMLRPCBlock & response)
 971 {
 972   PXMLRPCBlock request(method);
 973
 974   return MakeRequest(request, response);
 975 }
 976
 977 BOOL PXMLRPC::MakeRequest(PXMLRPCBlock & request, PXMLRPCBlock & response)
 978 {
 979   if (PerformRequest(request, response))
 980     return TRUE;
 981
 982   faultCode = response.GetFaultCode();
 983   faultText = response.GetFaultText();
 984
 985   return FALSE;
 986 }
 987
 988 BOOL PXMLRPC::MakeRequest(const PString & method, const PXMLRPCStructBase & args, PXMLRPCStructBase & reply)
 989 {
 990   PXMLRPCBlock request(method, args);
 991   PXMLRPCBlock response;
 992
 993   if (!MakeRequest(request, response))
 994     return FALSE;
 995
 996   if (response.GetParams(reply))
 997     return TRUE;
 998
 999   PTRACE(2, "XMLRPC\tParsing response failed: " << response.GetFaultText());
1000   return FALSE;
1001 }
1002
1003
1004 BOOL PXMLRPC::PerformRequest(PXMLRPCBlock & request, PXMLRPCBlock & response)
1005 {
1006   // create XML version of request
1007   PString requestXML;
1008   if (!request.Save(requestXML, options)) {
1009     PStringStream txt;
1010     txt << "Error creating request XML ("
1011         << request.GetErrorLine()
1012         << ") :"
1013         << request.GetErrorString();
1014     response.SetFault(PXMLRPC::CannotCreateRequestXML, txt);
1015     PTRACE(2, "XMLRPC\t" << response.GetFaultText());
1016     return FALSE;
1017   }
1018
1019   // make sure the request ends with a newline
1020   requestXML += "\n";
1021
1022   // do the request
1023   PHTTPClient client;
1024   PMIMEInfo sendMIME, replyMIME;
1025   sendMIME.SetAt("Server", url.GetHostName());
1026   sendMIME.SetAt(PHTTP::ContentTypeTag, "text/xml");
1027
1028   PTRACE(5, "XMLRPC\tOutgoing XML/RPC:\n" << url << '\n' << sendMIME << requestXML);
1029
1030   // apply the timeout
1031   client.SetReadTimeout(timeout);
1032
1033   PString replyXML;
1034
1035   // do the request
1036   BOOL ok = client.PostData(url, sendMIME, requestXML, replyMIME, replyXML);
1037
1038   PTRACE(5, "XMLRPC\tIncoming XML/RPC:\n" << replyMIME << replyXML);
1039
1040   // make sure the request worked
1041   if (!ok) {
1042     PStringStream txt;
1043     txt << "HTTP POST failed: "
1044         << client.GetLastResponseCode() << ' '
1045         << client.GetLastResponseInfo() << '\n'
1046         << replyMIME << '\n'
1047         << replyXML;
1048     response.SetFault(PXMLRPC::HTTPPostFailed, txt);
1049     PTRACE(2, "XMLRPC\t" << response.GetFaultText());
1050     return FALSE;
1051   }
1052
1053   // parse the response
1054   if (!response.Load(replyXML)) {
1055     PStringStream txt;
1056     txt << "Error parsing response XML ("
1057         << response.GetErrorLine()
1058         << ") :"
1059         << response.GetErrorString() << '\n';
1060
1061     PStringArray lines = replyXML.Lines();
1062     for (int offset = -2; offset <= 2; offset++) {
1063       int line = response.GetErrorLine() + offset;
1064       if (line >= 0 && line < lines.GetSize())
1065         txt << lines[(PINDEX)line] << '\n';
1066     }
1067
1068     response.SetFault(PXMLRPC::CannotParseResponseXML, txt);
1069     PTRACE(2, "XMLRPC\t" << response.GetFaultText());
1070     return FALSE;
1071   }
1072
1073   // validate the response
1074   if (!response.ValidateResponse()) {
1075     PTRACE(2, "XMLRPC\tValidation of response failed: " << response.GetFaultText());
1076     return FALSE;
1077   }
1078
1079   return TRUE;
1080 }
1081
1082 BOOL PXMLRPC::ISO8601ToPTime(const PString & iso8601, PTime & val, int tz)
1083 {
1084   if ((iso8601.GetLength() != 17) ||
1085       (iso8601[8]  != 'T') ||
1086       (iso8601[11] != ':') ||
1087       (iso8601[14] != ':'))
1088     return FALSE;
1089
1090   val = PTime(iso8601.Mid(15,2).AsInteger(),  // seconds
1091               iso8601.Mid(12,2).AsInteger(),  // minutes
1092               iso8601.Mid( 9,2).AsInteger(),  // hours
1093               iso8601.Mid( 6,2).AsInteger(),  // day
1094               iso8601.Mid( 4,2).AsInteger(),  // month
1095               iso8601.Mid( 0,4).AsInteger(),  // year
1096               tz
1097               );
1098
1099   return TRUE;
1100 }
1101
1102 PString PXMLRPC::PTimeToISO8601(const PTime & time)
1103 {
1104   return time.AsString("yyyyMMddThh:mm:ss");
1105
1106 }
1107
1108
1109 /////////////////////////////////////////////////////////////////
1110
1111 PXMLRPCVariableBase::PXMLRPCVariableBase(const char * n, const char * t)
1112   : name(n),
1113     type(t != NULL ? t : "string")
1114 {
1115   PXMLRPCStructBase::GetInitialiser().AddVariable(this);
1116 }
1117
1118
1119 PXMLRPCStructBase * PXMLRPCVariableBase::GetStruct(PINDEX) const
1120 {
1121   return NULL;
1122 }
1123
1124
1125 BOOL PXMLRPCVariableBase::IsArray() const
1126 {
1127   return FALSE;
1128 }
1129
1130
1131 PINDEX PXMLRPCVariableBase::GetSize() const
1132 {
1133   return 1;
1134 }
1135
1136
1137 BOOL PXMLRPCVariableBase::SetSize(PINDEX)
1138 {
1139   return TRUE;
1140 }
1141
1142
1143 PString PXMLRPCVariableBase::ToString(PINDEX) const
1144 {
1145   PStringStream stream;
1146   PrintOn(stream);
1147   return stream;
1148 }
1149
1150
1151 void PXMLRPCVariableBase::FromString(PINDEX, const PString & str)
1152 {
1153   PStringStream stream(str);
1154   ReadFrom(stream);
1155 }
1156
1157
1158 PString PXMLRPCVariableBase::ToBase64(PAbstractArray & data) const
1159 {
1160   return PBase64::Encode(data.GetPointer(), data.GetSize());
1161 }
1162
1163
1164 void PXMLRPCVariableBase::FromBase64(const PString & str, PAbstractArray & data)
1165 {
1166   PBase64 decoder;
1167   decoder.StartDecoding();
1168   decoder.ProcessDecoding(str);
1169   data = decoder.GetDecodedData();
1170 }
1171
1172
1173 /////////////////////////////////////////////////////////////////
1174
1175 PXMLRPCArrayBase::PXMLRPCArrayBase(PContainer & a, const char * n, const char * t)
1176   : PXMLRPCVariableBase(n, t),
1177     array(a)
1178 {
1179 }
1180
1181
1182 void PXMLRPCArrayBase::PrintOn(ostream & strm) const
1183 {
1184   strm << setfill('\n') << array << setfill(' ');
1185 }
1186
1187
1188 void PXMLRPCArrayBase::Copy(const PXMLRPCVariableBase & other)
1189 {
1190   array = ((PXMLRPCArrayBase &)other).array;
1191 }
1192
1193
1194 BOOL PXMLRPCArrayBase::IsArray() const
1195 {
1196   return TRUE;
1197 }
1198
1199
1200 PINDEX PXMLRPCArrayBase::GetSize() const
1201 {
1202   return array.GetSize();
1203 }
1204
1205
1206 BOOL PXMLRPCArrayBase::SetSize(PINDEX sz)
1207 {
1208   return array.SetSize(sz);
1209 }
1210
1211
1212 /////////////////////////////////////////////////////////////////
1213
1214 PXMLRPCArrayObjectsBase::PXMLRPCArrayObjectsBase(PArrayObjects & a, const char * n, const char * t)
1215   : PXMLRPCArrayBase(a, n, t),
1216     array(a)
1217 {
1218 }
1219
1220
1221 BOOL PXMLRPCArrayObjectsBase::SetSize(PINDEX sz)
1222 {
1223   if (!array.SetSize(sz))
1224     return FALSE;
1225
1226   for (PINDEX i = 0; i < sz; i++) {
1227     if (array.GetAt(i) == NULL) {
1228       PObject * object = CreateObject();
1229       if (object == NULL)
1230         return FALSE;
1231       array.SetAt(i, object);
1232     }
1233   }
1234
1235   return TRUE;
1236 }
1237
1238
1239 PString PXMLRPCArrayObjectsBase::ToString(PINDEX i) const
1240 {
1241   PStringStream stream;
1242   stream << *array.GetAt(i);
1243   return stream;
1244 }
1245
1246
1247 void PXMLRPCArrayObjectsBase::FromString(PINDEX i, const PString & str)
1248 {
1249   PObject * object = array.GetAt(i);
1250   if (object == NULL) {
1251     object = CreateObject();
1252     array.SetAt(i, object);
1253   }
1254
1255   PStringStream stream(str);
1256   stream >> *object;
1257 }
1258
1259
1260 /////////////////////////////////////////////////////////////////
1261
1262 PMutex              PXMLRPCStructBase::initialiserMutex;
1263 PXMLRPCStructBase * PXMLRPCStructBase::initialiserInstance = NULL;
1264
1265
1266 PXMLRPCStructBase::PXMLRPCStructBase()
1267 {
1268   variablesByOrder.DisallowDeleteObjects();
1269   variablesByName.DisallowDeleteObjects();
1270
1271   initialiserMutex.Wait();
1272   initialiserStack = initialiserInstance;
1273   initialiserInstance = this;
1274 }
1275
1276
1277 void PXMLRPCStructBase::EndConstructor()
1278 {
1279   initialiserInstance = initialiserStack;
1280   initialiserMutex.Signal();
1281 }
1282
1283
1284 PXMLRPCStructBase & PXMLRPCStructBase::operator=(const PXMLRPCStructBase & other)
1285 {
1286   for (PINDEX i = 0; i < variablesByOrder.GetSize(); i++)
1287     variablesByOrder[i].Copy(other.variablesByOrder[i]);
1288
1289   return *this;
1290 }
1291
1292
1293 void PXMLRPCStructBase::PrintOn(ostream & strm) const
1294 {
1295   for (PINDEX i = 0; i < variablesByOrder.GetSize(); i++) {
1296     PXMLRPCVariableBase & var = variablesByOrder[i];
1297     strm << var.GetName() << '=' << var << '\n';
1298   }
1299 }
1300
1301
1302 void PXMLRPCStructBase::AddVariable(PXMLRPCVariableBase * var)
1303 {
1304   variablesByOrder.Append(var);
1305   variablesByName.SetAt(var->GetName(), var);
1306 }
1307
1308
1309 #endif
1310
1311
1312 // End of file ///////////////////////////////////////////////////////////////
1313