CMakeLua/Source/CTest/cmCTestSubmitHandler.cxx

   1 /*=========================================================================
   2
   3 Program:   CMake - Cross-Platform Makefile Generator
   4 Module:    $RCSfile: cmCTestSubmitHandler.cxx,v $
   5 Language:  C++
   6 Date:      $Date: 2009-03-31 19:30:36 $
   7 Version:   $Revision: 1.41 $
   8
   9 Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  10 See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  11
  12 This software is distributed WITHOUT ANY WARRANTY; without even
  13 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14 PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17 #include "cmCTestSubmitHandler.h"
  18
  19 #include "cmSystemTools.h"
  20 #include "cmVersion.h"
  21 #include "cmGeneratedFileStream.h"
  22 #include "cmCTest.h"
  23
  24 #include <cmsys/Process.h>
  25 #include <cmsys/Base64.h>
  26
  27 // For XML-RPC submission
  28 #include "cm_xmlrpc.h"
  29
  30 // For curl submission
  31 #include "cm_curl.h"
  32
  33 #include <sys/stat.h>
  34
  35 typedef std::vector<char> cmCTestSubmitHandlerVectorOfChar;
  36
  37 static size_t
  38 cmCTestSubmitHandlerWriteMemoryCallback(void *ptr, size_t size, size_t nmemb,
  39   void *data)
  40 {
  41   register int realsize = (int)(size * nmemb);
  42
  43   cmCTestSubmitHandlerVectorOfChar *vec
  44     = static_cast<cmCTestSubmitHandlerVectorOfChar*>(data);
  45   const char* chPtr = static_cast<char*>(ptr);
  46   vec->insert(vec->end(), chPtr, chPtr + realsize);
  47
  48   return realsize;
  49 }
  50
  51 static size_t
  52 cmCTestSubmitHandlerCurlDebugCallback(CURL *, curl_infotype, char *chPtr,
  53   size_t size, void *data)
  54 {
  55   cmCTestSubmitHandlerVectorOfChar *vec
  56     = static_cast<cmCTestSubmitHandlerVectorOfChar*>(data);
  57   vec->insert(vec->end(), chPtr, chPtr + size);
  58
  59   return size;
  60 }
  61
  62 //----------------------------------------------------------------------------
  63 cmCTestSubmitHandler::cmCTestSubmitHandler() : HTTPProxy(), FTPProxy()
  64 {
  65   this->Initialize();
  66 }
  67
  68 //----------------------------------------------------------------------------
  69 void cmCTestSubmitHandler::Initialize()
  70 {
  71   // We submit all available parts by default.
  72   for(cmCTest::Part p = cmCTest::PartStart;
  73       p != cmCTest::PartCount; p = cmCTest::Part(p+1))
  74     {
  75     this->SubmitPart[p] = true;
  76     }
  77   this->CDash = false;
  78   this->Superclass::Initialize();
  79   this->HTTPProxy = "";
  80   this->HTTPProxyType = 0;
  81   this->HTTPProxyAuth = "";
  82   this->FTPProxy = "";
  83   this->FTPProxyType = 0;
  84   this->LogFile = 0;
  85   this->Files.clear();
  86 }
  87
  88 //----------------------------------------------------------------------------
  89 bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
  90   const std::set<cmStdString>& files,
  91   const cmStdString& remoteprefix,
  92   const cmStdString& url)
  93 {
  94   CURL *curl;
  95   CURLcode res;
  96   FILE* ftpfile;
  97   char error_buffer[1024];
  98
  99   /* In windows, this will init the winsock stuff */
 100   ::curl_global_init(CURL_GLOBAL_ALL);
 101
 102   cmCTest::SetOfStrings::const_iterator file;
 103   for ( file = files.begin(); file != files.end(); ++file )
 104     {
 105     /* get a curl handle */
 106     curl = curl_easy_init();
 107     if(curl)
 108       {
 109       // Using proxy
 110       if ( this->FTPProxyType > 0 )
 111         {
 112         curl_easy_setopt(curl, CURLOPT_PROXY, this->FTPProxy.c_str());
 113         switch (this->FTPProxyType)
 114           {
 115         case 2:
 116           curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
 117           break;
 118         case 3:
 119           curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
 120           break;
 121         default:
 122           curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
 123           }
 124         }
 125
 126       // enable uploading
 127       ::curl_easy_setopt(curl, CURLOPT_UPLOAD, 1) ;
 128
 129       cmStdString local_file = *file;
 130       if ( !cmSystemTools::FileExists(local_file.c_str()) )
 131         {
 132         local_file = localprefix + "/" + *file;
 133         }
 134       cmStdString upload_as
 135         = url + "/" + remoteprefix + cmSystemTools::GetFilenameName(*file);
 136
 137       struct stat st;
 138       if ( ::stat(local_file.c_str(), &st) )
 139         {
 140         cmCTestLog(this->CTest, ERROR_MESSAGE, "   Cannot find file: "
 141           << local_file.c_str() << std::endl);
 142         ::curl_easy_cleanup(curl);
 143         ::curl_global_cleanup();
 144         return false;
 145         }
 146
 147       ftpfile = ::fopen(local_file.c_str(), "rb");
 148       *this->LogFile << "\tUpload file: " << local_file.c_str() << " to "
 149           << upload_as.c_str() << std::endl;
 150       cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "   Upload file: "
 151         << local_file.c_str() << " to "
 152         << upload_as.c_str() << std::endl);
 153
 154       ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
 155
 156       // specify target
 157       ::curl_easy_setopt(curl,CURLOPT_URL, upload_as.c_str());
 158
 159       // now specify which file to upload
 160       ::curl_easy_setopt(curl, CURLOPT_INFILE, ftpfile);
 161
 162       // and give the size of the upload (optional)
 163       ::curl_easy_setopt(curl, CURLOPT_INFILESIZE,
 164         static_cast<long>(st.st_size));
 165
 166       // and give curl the buffer for errors
 167       ::curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &error_buffer);
 168
 169       // specify handler for output
 170       ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
 171         cmCTestSubmitHandlerWriteMemoryCallback);
 172       ::curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION,
 173         cmCTestSubmitHandlerCurlDebugCallback);
 174
 175       /* we pass our 'chunk' struct to the callback function */
 176       cmCTestSubmitHandlerVectorOfChar chunk;
 177       cmCTestSubmitHandlerVectorOfChar chunkDebug;
 178       ::curl_easy_setopt(curl, CURLOPT_FILE, (void *)&chunk);
 179       ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void *)&chunkDebug);
 180
 181       // Now run off and do what you've been told!
 182       res = ::curl_easy_perform(curl);
 183
 184       if ( chunk.size() > 0 )
 185         {
 186         cmCTestLog(this->CTest, DEBUG, "CURL output: ["
 187           << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
 188           << std::endl);
 189         }
 190       if ( chunkDebug.size() > 0 )
 191         {
 192         cmCTestLog(this->CTest, DEBUG, "CURL debug output: ["
 193           << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size()) << "]"
 194           << std::endl);
 195         }
 196
 197       fclose(ftpfile);
 198       if ( res )
 199         {
 200         cmCTestLog(this->CTest, ERROR_MESSAGE,
 201           "   Error when uploading file: "
 202           << local_file.c_str() << std::endl);
 203         cmCTestLog(this->CTest, ERROR_MESSAGE, "   Error message was: "
 204           << error_buffer << std::endl);
 205         *this->LogFile << "   Error when uploading file: "
 206                        << local_file.c_str()
 207                        << std::endl
 208                        << "   Error message was: "
 209                        << error_buffer << std::endl
 210                        << "   Curl output was: ";
 211         // avoid dereference of empty vector
 212         if(chunk.size())
 213           {
 214           *this->LogFile << cmCTestLogWrite(&*chunk.begin(), chunk.size());
 215           cmCTestLog(this->CTest, ERROR_MESSAGE, "CURL output: ["
 216                      << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
 217                      << std::endl);
 218           }
 219         *this->LogFile << std::endl;
 220         ::curl_easy_cleanup(curl);
 221         ::curl_global_cleanup();
 222         return false;
 223         }
 224       // always cleanup
 225       ::curl_easy_cleanup(curl);
 226       cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Uploaded: " + local_file
 227         << std::endl);
 228       }
 229     }
 230   ::curl_global_cleanup();
 231   return true;
 232 }
 233
 234 //----------------------------------------------------------------------------
 235 // Uploading files is simpler
 236 bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
 237   const std::set<cmStdString>& files,
 238   const cmStdString& remoteprefix,
 239   const cmStdString& url)
 240 {
 241   CURL *curl;
 242   CURLcode res;
 243   FILE* ftpfile;
 244   char error_buffer[1024];
 245
 246   /* In windows, this will init the winsock stuff */
 247   ::curl_global_init(CURL_GLOBAL_ALL);
 248
 249   cmStdString::size_type kk;
 250   cmCTest::SetOfStrings::const_iterator file;
 251   for ( file = files.begin(); file != files.end(); ++file )
 252     {
 253     /* get a curl handle */
 254     curl = curl_easy_init();
 255     if(curl)
 256       {
 257       curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
 258
 259       // Using proxy
 260       if ( this->HTTPProxyType > 0 )
 261         {
 262         curl_easy_setopt(curl, CURLOPT_PROXY, this->HTTPProxy.c_str());
 263         switch (this->HTTPProxyType)
 264           {
 265         case 2:
 266           curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
 267           break;
 268         case 3:
 269           curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
 270           break;
 271         default:
 272           curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
 273           if (this->HTTPProxyAuth.size() > 0)
 274             {
 275             curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD,
 276               this->HTTPProxyAuth.c_str());
 277             }
 278           }
 279         }
 280
 281       /* enable uploading */
 282       curl_easy_setopt(curl, CURLOPT_UPLOAD, 1) ;
 283
 284       /* HTTP PUT please */
 285       ::curl_easy_setopt(curl, CURLOPT_PUT, 1);
 286       ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
 287
 288       cmStdString local_file = *file;
 289       if ( !cmSystemTools::FileExists(local_file.c_str()) )
 290         {
 291         local_file = localprefix + "/" + *file;
 292         }
 293       cmStdString remote_file
 294         = remoteprefix + cmSystemTools::GetFilenameName(*file);
 295
 296       *this->LogFile << "\tUpload file: " << local_file.c_str() << " to "
 297           << remote_file.c_str() << std::endl;
 298
 299       cmStdString ofile = "";
 300       for ( kk = 0; kk < remote_file.size(); kk ++ )
 301         {
 302         char c = remote_file[kk];
 303         char hexCh[4] = { 0, 0, 0, 0 };
 304         hexCh[0] = c;
 305         switch ( c )
 306           {
 307         case '+':
 308         case '?':
 309         case '/':
 310         case '\\':
 311         case '&':
 312         case ' ':
 313         case '=':
 314         case '%':
 315           sprintf(hexCh, "%%%02X", (int)c);
 316           ofile.append(hexCh);
 317           break;
 318         default:
 319           ofile.append(hexCh);
 320           }
 321         }
 322       cmStdString upload_as
 323         = url + ((url.find("?",0) == cmStdString::npos) ? "?" : "&")
 324         + "FileName=" + ofile;
 325
 326       struct stat st;
 327       if ( ::stat(local_file.c_str(), &st) )
 328         {
 329         cmCTestLog(this->CTest, ERROR_MESSAGE, "   Cannot find file: "
 330           << local_file.c_str() << std::endl);
 331         ::curl_easy_cleanup(curl);
 332         ::curl_global_cleanup();
 333         return false;
 334         }
 335
 336       ftpfile = ::fopen(local_file.c_str(), "rb");
 337       cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "   Upload file: "
 338         << local_file.c_str() << " to "
 339         << upload_as.c_str() << " Size: " << st.st_size << std::endl);
 340
 341
 342       // specify target
 343       ::curl_easy_setopt(curl,CURLOPT_URL, upload_as.c_str());
 344
 345       // now specify which file to upload
 346       ::curl_easy_setopt(curl, CURLOPT_INFILE, ftpfile);
 347
 348       // and give the size of the upload (optional)
 349       ::curl_easy_setopt(curl, CURLOPT_INFILESIZE,
 350         static_cast<long>(st.st_size));
 351
 352       // and give curl the buffer for errors
 353       ::curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &error_buffer);
 354
 355       // specify handler for output
 356       ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
 357         cmCTestSubmitHandlerWriteMemoryCallback);
 358       ::curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION,
 359         cmCTestSubmitHandlerCurlDebugCallback);
 360
 361       /* we pass our 'chunk' struct to the callback function */
 362       cmCTestSubmitHandlerVectorOfChar chunk;
 363       cmCTestSubmitHandlerVectorOfChar chunkDebug;
 364       ::curl_easy_setopt(curl, CURLOPT_FILE, (void *)&chunk);
 365       ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void *)&chunkDebug);
 366
 367       // Now run off and do what you've been told!
 368       res = ::curl_easy_perform(curl);
 369
 370       if ( chunk.size() > 0 )
 371         {
 372         cmCTestLog(this->CTest, DEBUG, "CURL output: ["
 373           << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
 374           << std::endl);
 375         }
 376       if ( chunkDebug.size() > 0 )
 377         {
 378         cmCTestLog(this->CTest, DEBUG, "CURL debug output: ["
 379           << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size()) << "]"
 380           << std::endl);
 381         }
 382
 383       fclose(ftpfile);
 384       if ( res )
 385         {
 386         cmCTestLog(this->CTest, ERROR_MESSAGE,
 387           "   Error when uploading file: "
 388           << local_file.c_str() << std::endl);
 389         cmCTestLog(this->CTest, ERROR_MESSAGE, "   Error message was: "
 390           << error_buffer << std::endl);
 391         *this->LogFile << "   Error when uploading file: "
 392                        << local_file.c_str()
 393                        << std::endl
 394                        << "   Error message was: " << error_buffer
 395                        << std::endl;
 396         // avoid deref of begin for zero size array
 397         if(chunk.size())
 398           {
 399           *this->LogFile << "   Curl output was: "
 400                          << cmCTestLogWrite(&*chunk.begin(), chunk.size())
 401                          << std::endl;
 402           cmCTestLog(this->CTest, ERROR_MESSAGE, "CURL output: ["
 403                      << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
 404                      << std::endl);
 405           }
 406         ::curl_easy_cleanup(curl);
 407         ::curl_global_cleanup();
 408         return false;
 409         }
 410       // always cleanup
 411       ::curl_easy_cleanup(curl);
 412       cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Uploaded: " + local_file
 413         << std::endl);
 414       }
 415     }
 416   ::curl_global_cleanup();
 417   return true;
 418 }
 419
 420 //----------------------------------------------------------------------------
 421 bool cmCTestSubmitHandler::TriggerUsingHTTP(
 422   const std::set<cmStdString>& files,
 423   const cmStdString& remoteprefix,
 424   const cmStdString& url)
 425 {
 426   CURL *curl;
 427   char error_buffer[1024];
 428   /* In windows, this will init the winsock stuff */
 429   ::curl_global_init(CURL_GLOBAL_ALL);
 430
 431   cmCTest::SetOfStrings::const_iterator file;
 432   for ( file = files.begin(); file != files.end(); ++file )
 433     {
 434     /* get a curl handle */
 435     curl = curl_easy_init();
 436     if(curl)
 437       {
 438       // Using proxy
 439       if ( this->HTTPProxyType > 0 )
 440         {
 441         curl_easy_setopt(curl, CURLOPT_PROXY, this->HTTPProxy.c_str());
 442         switch (this->HTTPProxyType)
 443           {
 444         case 2:
 445           curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS4);
 446           break;
 447         case 3:
 448           curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5);
 449           break;
 450         default:
 451           curl_easy_setopt(curl, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
 452           if (this->HTTPProxyAuth.size() > 0)
 453             {
 454             curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD,
 455               this->HTTPProxyAuth.c_str());
 456             }
 457           }
 458         }
 459
 460       ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
 461
 462       // and give curl the buffer for errors
 463       ::curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, &error_buffer);
 464
 465       // specify handler for output
 466       ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
 467         cmCTestSubmitHandlerWriteMemoryCallback);
 468       ::curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION,
 469         cmCTestSubmitHandlerCurlDebugCallback);
 470
 471       /* we pass our 'chunk' struct to the callback function */
 472       cmCTestSubmitHandlerVectorOfChar chunk;
 473       cmCTestSubmitHandlerVectorOfChar chunkDebug;
 474       ::curl_easy_setopt(curl, CURLOPT_FILE, (void *)&chunk);
 475       ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void *)&chunkDebug);
 476
 477       cmStdString rfile
 478         = remoteprefix + cmSystemTools::GetFilenameName(*file);
 479       cmStdString ofile = "";
 480       cmStdString::iterator kk;
 481       for ( kk = rfile.begin(); kk < rfile.end(); ++ kk)
 482         {
 483         char c = *kk;
 484         char hexCh[4] = { 0, 0, 0, 0 };
 485         hexCh[0] = c;
 486         switch ( c )
 487           {
 488         case '+':
 489         case '?':
 490         case '/':
 491         case '\\':
 492         case '&':
 493         case ' ':
 494         case '=':
 495         case '%':
 496           sprintf(hexCh, "%%%02X", (int)c);
 497           ofile.append(hexCh);
 498           break;
 499         default:
 500           ofile.append(hexCh);
 501           }
 502         }
 503       cmStdString turl
 504         = url + ((url.find("?",0) == cmStdString::npos) ? "?" : "&")
 505         + "xmlfile=" + ofile;
 506       *this->LogFile << "Trigger url: " << turl.c_str() << std::endl;
 507       cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "   Trigger url: "
 508         << turl.c_str() << std::endl);
 509       curl_easy_setopt(curl, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
 510       curl_easy_setopt(curl, CURLOPT_URL, turl.c_str());
 511       if ( curl_easy_perform(curl) )
 512         {
 513         cmCTestLog(this->CTest, ERROR_MESSAGE, "   Error when triggering: "
 514           << turl.c_str() << std::endl);
 515         cmCTestLog(this->CTest, ERROR_MESSAGE, "   Error message was: "
 516           << error_buffer << std::endl);
 517         *this->LogFile << "\tTrigerring failed with error: " << error_buffer
 518                        << std::endl
 519                        << "   Error message was: " << error_buffer
 520                        << std::endl;
 521         if(chunk.size())
 522           {
 523           *this->LogFile
 524             << "   Curl output was: "
 525             << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << std::endl;
 526           cmCTestLog(this->CTest, ERROR_MESSAGE, "CURL output: ["
 527                      << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
 528                      << std::endl);
 529           }
 530         ::curl_easy_cleanup(curl);
 531         ::curl_global_cleanup();
 532         return false;
 533         }
 534
 535       if ( chunk.size() > 0 )
 536         {
 537         cmCTestLog(this->CTest, DEBUG, "CURL output: ["
 538           << cmCTestLogWrite(&*chunk.begin(), chunk.size()) << "]"
 539           << std::endl);
 540         }
 541       if ( chunkDebug.size() > 0 )
 542         {
 543         cmCTestLog(this->CTest, DEBUG, "CURL debug output: ["
 544           << cmCTestLogWrite(&*chunkDebug.begin(), chunkDebug.size())
 545           << "]" << std::endl);
 546         }
 547
 548       // always cleanup
 549       ::curl_easy_cleanup(curl);
 550       cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl);
 551       }
 552     }
 553   ::curl_global_cleanup();
 554   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Dart server triggered..."
 555     << std::endl);
 556   return true;
 557 }
 558
 559 //----------------------------------------------------------------------------
 560 bool cmCTestSubmitHandler::SubmitUsingSCP(
 561   const cmStdString& scp_command,
 562   const cmStdString& localprefix,
 563   const std::set<cmStdString>& files,
 564   const cmStdString& remoteprefix,
 565   const cmStdString& url)
 566 {
 567   if ( !scp_command.size() || !localprefix.size() ||
 568     !files.size() || !remoteprefix.size() || !url.size() )
 569     {
 570     return 0;
 571     }
 572   std::vector<const char*> argv;
 573   argv.push_back(scp_command.c_str()); // Scp command
 574   argv.push_back(scp_command.c_str()); // Dummy string for file
 575   argv.push_back(scp_command.c_str()); // Dummy string for remote url
 576   argv.push_back(0);
 577
 578   cmsysProcess* cp = cmsysProcess_New();
 579   cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
 580   //cmsysProcess_SetTimeout(cp, timeout);
 581
 582   int problems = 0;
 583
 584   cmCTest::SetOfStrings::const_iterator file;
 585   for ( file = files.begin(); file != files.end(); ++file )
 586     {
 587     int retVal;
 588
 589     std::string lfname = localprefix;
 590     cmSystemTools::ConvertToUnixSlashes(lfname);
 591     lfname += "/" + *file;
 592     lfname = cmSystemTools::ConvertToOutputPath(lfname.c_str());
 593     argv[1] = lfname.c_str();
 594     std::string rfname = url + "/" + remoteprefix + *file;
 595     argv[2] = rfname.c_str();
 596     cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Execute \"" << argv[0]
 597       << "\" \"" << argv[1] << "\" \""
 598       << argv[2] << "\"" << std::endl);
 599     *this->LogFile << "Execute \"" << argv[0] << "\" \"" << argv[1] << "\" \""
 600       << argv[2] << "\"" << std::endl;
 601
 602     cmsysProcess_SetCommand(cp, &*argv.begin());
 603     cmsysProcess_Execute(cp);
 604     char* data;
 605     int length;
 606
 607     while(cmsysProcess_WaitForData(cp, &data, &length, 0))
 608       {
 609       cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
 610         cmCTestLogWrite(data, length));
 611       }
 612
 613     cmsysProcess_WaitForExit(cp, 0);
 614
 615     int result = cmsysProcess_GetState(cp);
 616
 617     if(result == cmsysProcess_State_Exited)
 618       {
 619       retVal = cmsysProcess_GetExitValue(cp);
 620       if ( retVal != 0 )
 621         {
 622         cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "\tSCP returned: "
 623           << retVal << std::endl);
 624         *this->LogFile << "\tSCP returned: " << retVal << std::endl;
 625         problems ++;
 626         }
 627       }
 628     else if(result == cmsysProcess_State_Exception)
 629       {
 630       retVal = cmsysProcess_GetExitException(cp);
 631       cmCTestLog(this->CTest, ERROR_MESSAGE, "\tThere was an exception: "
 632         << retVal << std::endl);
 633       *this->LogFile << "\tThere was an exception: " << retVal << std::endl;
 634       problems ++;
 635       }
 636     else if(result == cmsysProcess_State_Expired)
 637       {
 638       cmCTestLog(this->CTest, ERROR_MESSAGE, "\tThere was a timeout"
 639         << std::endl);
 640       *this->LogFile << "\tThere was a timeout" << std::endl;
 641       problems ++;
 642       }
 643     else if(result == cmsysProcess_State_Error)
 644       {
 645       cmCTestLog(this->CTest, ERROR_MESSAGE, "\tError executing SCP: "
 646         << cmsysProcess_GetErrorString(cp) << std::endl);
 647       *this->LogFile << "\tError executing SCP: "
 648         << cmsysProcess_GetErrorString(cp) << std::endl;
 649       problems ++;
 650       }
 651     }
 652   cmsysProcess_Delete(cp);
 653   if ( problems )
 654     {
 655     return false;
 656     }
 657   return true;
 658 }
 659
 660 //----------------------------------------------------------------------------
 661 bool cmCTestSubmitHandler::SubmitUsingCP(
 662   const cmStdString& localprefix,
 663   const std::set<cmStdString>& files,
 664   const cmStdString& remoteprefix,
 665   const cmStdString& destination)
 666 {
 667   if ( !localprefix.size() ||
 668     !files.size() || !remoteprefix.size() || !destination.size() )
 669     {
 670     cmCTestLog(this->CTest, ERROR_MESSAGE,
 671                "Missing arguments for submit via cp:\n"
 672                << "\tlocalprefix: " << localprefix << "\n"
 673                << "\tNumber of files: " << files.size() << "\n"
 674                << "\tremoteprefix: " << remoteprefix << "\n"
 675                << "\tdestination: " << destination << std::endl);
 676     return 0;
 677     }
 678   cmCTest::SetOfStrings::const_iterator file;
 679   bool problems = false;
 680   for ( file = files.begin(); file != files.end(); ++file )
 681     {
 682     std::string lfname = localprefix;
 683     cmSystemTools::ConvertToUnixSlashes(lfname);
 684     lfname += "/" + *file;
 685     std::string rfname = destination + "/" + remoteprefix + *file;
 686     cmSystemTools::CopyFileAlways(lfname.c_str(), rfname.c_str());
 687     cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "   Copy file: "
 688         << lfname.c_str() << " to "
 689         << rfname.c_str() << std::endl);
 690     }
 691   std::string tagDoneFile = destination + "/" + remoteprefix + "DONE";
 692   cmSystemTools::Touch(tagDoneFile.c_str(), true);
 693   if ( problems )
 694     {
 695     return false;
 696     }
 697   return true;
 698 }
 699
 700
 701 //----------------------------------------------------------------------------
 702 bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const cmStdString& localprefix,
 703   const std::set<cmStdString>& files,
 704   const cmStdString& remoteprefix,
 705   const cmStdString& url)
 706 {
 707   xmlrpc_env env;
 708   char ctestString[] = "CTest";
 709   std::string ctestVersionString = cmVersion::GetCMakeVersion();
 710   char* ctestVersion = const_cast<char*>(ctestVersionString.c_str());
 711
 712   cmStdString realURL = url + "/" + remoteprefix + "/Command/";
 713
 714   /* Start up our XML-RPC client library. */
 715   xmlrpc_client_init(XMLRPC_CLIENT_NO_FLAGS, ctestString, ctestVersion);
 716
 717   /* Initialize our error-handling environment. */
 718   xmlrpc_env_init(&env);
 719
 720   /* Call the famous server at UserLand. */
 721   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Submitting to: "
 722     << realURL.c_str() << " (" << remoteprefix.c_str() << ")" << std::endl);
 723   cmCTest::SetOfStrings::const_iterator file;
 724   for ( file = files.begin(); file != files.end(); ++file )
 725     {
 726     xmlrpc_value *result;
 727
 728     cmStdString local_file = *file;
 729     if ( !cmSystemTools::FileExists(local_file.c_str()) )
 730       {
 731       local_file = localprefix + "/" + *file;
 732       }
 733     cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Submit file: "
 734       << local_file.c_str() << std::endl);
 735     struct stat st;
 736     if ( ::stat(local_file.c_str(), &st) )
 737       {
 738       cmCTestLog(this->CTest, ERROR_MESSAGE, "  Cannot find file: "
 739         << local_file.c_str() << std::endl);
 740       return false;
 741       }
 742
 743     // off_t can be bigger than size_t.  fread takes size_t.
 744     // make sure the file is not too big.
 745     if(static_cast<off_t>(static_cast<size_t>(st.st_size)) !=
 746        static_cast<off_t>(st.st_size))
 747       {
 748       cmCTestLog(this->CTest, ERROR_MESSAGE, "  File too big: "
 749         << local_file.c_str() << std::endl);
 750       return false;
 751       }
 752     size_t fileSize = static_cast<size_t>(st.st_size);
 753     FILE* fp = fopen(local_file.c_str(), "rb");
 754     if ( !fp )
 755       {
 756       cmCTestLog(this->CTest, ERROR_MESSAGE, "  Cannot open file: "
 757         << local_file.c_str() << std::endl);
 758       return false;
 759       }
 760
 761     unsigned char *fileBuffer = new unsigned char[fileSize];
 762     if ( fread(fileBuffer, 1, fileSize, fp) != fileSize )
 763       {
 764       delete [] fileBuffer;
 765       fclose(fp);
 766       cmCTestLog(this->CTest, ERROR_MESSAGE, "  Cannot read file: "
 767         << local_file.c_str() << std::endl);
 768       return false;
 769       }
 770     fclose(fp);
 771
 772     char remoteCommand[] = "Submit.put";
 773     char* pRealURL = const_cast<char*>(realURL.c_str());
 774     result = xmlrpc_client_call(&env, pRealURL, remoteCommand,
 775       "(6)", fileBuffer, (xmlrpc_int32)fileSize );
 776
 777     delete [] fileBuffer;
 778
 779     if ( env.fault_occurred )
 780       {
 781       cmCTestLog(this->CTest, ERROR_MESSAGE, " Submission problem: "
 782         << env.fault_string << " (" << env.fault_code << ")" << std::endl);
 783       xmlrpc_env_clean(&env);
 784       xmlrpc_client_cleanup();
 785       return false;
 786       }
 787
 788     /* Dispose of our result value. */
 789     xmlrpc_DECREF(result);
 790     }
 791
 792   /* Clean up our error-handling environment. */
 793   xmlrpc_env_clean(&env);
 794
 795   /* Shutdown our XML-RPC client library. */
 796   xmlrpc_client_cleanup();
 797   return true;
 798 }
 799
 800 //----------------------------------------------------------------------------
 801 int cmCTestSubmitHandler::ProcessHandler()
 802 {
 803   std::string iscdash = this->CTest->GetCTestConfiguration("IsCDash");
 804   // cdash does not need to trigger so just return true
 805   if(iscdash.size())
 806     {
 807     this->CDash = true;
 808     }
 809
 810   const std::string &buildDirectory
 811     = this->CTest->GetCTestConfiguration("BuildDirectory");
 812   if ( buildDirectory.size() == 0 )
 813     {
 814     cmCTestLog(this->CTest, ERROR_MESSAGE,
 815       "Cannot find BuildDirectory  key in the DartConfiguration.tcl"
 816       << std::endl);
 817     return -1;
 818     }
 819
 820   if ( getenv("HTTP_PROXY") )
 821     {
 822     this->HTTPProxyType = 1;
 823     this->HTTPProxy = getenv("HTTP_PROXY");
 824     if ( getenv("HTTP_PROXY_PORT") )
 825       {
 826       this->HTTPProxy += ":";
 827       this->HTTPProxy += getenv("HTTP_PROXY_PORT");
 828       }
 829     if ( getenv("HTTP_PROXY_TYPE") )
 830       {
 831       cmStdString type = getenv("HTTP_PROXY_TYPE");
 832       // HTTP/SOCKS4/SOCKS5
 833       if ( type == "HTTP" )
 834         {
 835         this->HTTPProxyType = 1;
 836         }
 837       else if ( type == "SOCKS4" )
 838         {
 839         this->HTTPProxyType = 2;
 840         }
 841       else if ( type == "SOCKS5" )
 842         {
 843         this->HTTPProxyType = 3;
 844         }
 845       }
 846     if ( getenv("HTTP_PROXY_USER") )
 847       {
 848       this->HTTPProxyAuth = getenv("HTTP_PROXY_USER");
 849       }
 850     if ( getenv("HTTP_PROXY_PASSWD") )
 851       {
 852       this->HTTPProxyAuth += ":";
 853       this->HTTPProxyAuth += getenv("HTTP_PROXY_PASSWD");
 854       }
 855     }
 856
 857   if ( getenv("FTP_PROXY") )
 858     {
 859     this->FTPProxyType = 1;
 860     this->FTPProxy = getenv("FTP_PROXY");
 861     if ( getenv("FTP_PROXY_PORT") )
 862       {
 863       this->FTPProxy += ":";
 864       this->FTPProxy += getenv("FTP_PROXY_PORT");
 865       }
 866     if ( getenv("FTP_PROXY_TYPE") )
 867       {
 868       cmStdString type = getenv("FTP_PROXY_TYPE");
 869       // HTTP/SOCKS4/SOCKS5
 870       if ( type == "HTTP" )
 871         {
 872         this->FTPProxyType = 1;
 873         }
 874       else if ( type == "SOCKS4" )
 875         {
 876         this->FTPProxyType = 2;
 877         }
 878       else if ( type == "SOCKS5" )
 879         {
 880         this->FTPProxyType = 3;
 881         }
 882       }
 883     }
 884
 885   if ( this->HTTPProxy.size() > 0 )
 886     {
 887     cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Use HTTP Proxy: "
 888       << this->HTTPProxy << std::endl);
 889     }
 890   if ( this->FTPProxy.size() > 0 )
 891     {
 892     cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Use FTP Proxy: "
 893       << this->FTPProxy << std::endl);
 894     }
 895   cmGeneratedFileStream ofs;
 896   this->StartLogFile("Submit", ofs);
 897
 898   cmCTest::SetOfStrings files;
 899   std::string prefix = this->GetSubmitResultsPrefix();
 900
 901   if (!this->Files.empty())
 902     {
 903     // Submit the explicitly selected files:
 904     //
 905     cmCTest::SetOfStrings::const_iterator it;
 906     for (it = this->Files.begin(); it != this->Files.end(); ++it)
 907       {
 908       files.insert(*it);
 909       }
 910     }
 911
 912   // Add to the list of files to submit from any selected, existing parts:
 913   //
 914
 915   // TODO:
 916   // Check if test is enabled
 917
 918   this->CTest->AddIfExists(cmCTest::PartUpdate, "Update.xml");
 919   this->CTest->AddIfExists(cmCTest::PartConfigure, "Configure.xml");
 920   this->CTest->AddIfExists(cmCTest::PartBuild, "Build.xml");
 921   this->CTest->AddIfExists(cmCTest::PartTest, "Test.xml");
 922   if(this->CTest->AddIfExists(cmCTest::PartCoverage, "Coverage.xml"))
 923     {
 924     cmCTest::VectorOfStrings gfiles;
 925     std::string gpath
 926       = buildDirectory + "/Testing/" + this->CTest->GetCurrentTag();
 927     std::string::size_type glen = gpath.size() + 1;
 928     gpath = gpath + "/CoverageLog*";
 929     cmCTestLog(this->CTest, DEBUG, "Globbing for: " << gpath.c_str()
 930       << std::endl);
 931     if ( cmSystemTools::SimpleGlob(gpath, gfiles, 1) )
 932       {
 933       size_t cc;
 934       for ( cc = 0; cc < gfiles.size(); cc ++ )
 935         {
 936         gfiles[cc] = gfiles[cc].substr(glen);
 937         cmCTestLog(this->CTest, DEBUG, "Glob file: " << gfiles[cc].c_str()
 938           << std::endl);
 939         this->CTest->AddSubmitFile(cmCTest::PartCoverage, gfiles[cc].c_str());
 940         }
 941       }
 942     else
 943       {
 944       cmCTestLog(this->CTest, ERROR_MESSAGE, "Problem globbing" << std::endl);
 945       }
 946     }
 947   this->CTest->AddIfExists(cmCTest::PartMemCheck, "DynamicAnalysis.xml");
 948   this->CTest->AddIfExists(cmCTest::PartMemCheck, "Purify.xml");
 949   this->CTest->AddIfExists(cmCTest::PartNotes, "Notes.xml");
 950
 951   // Query parts for files to submit.
 952   for(cmCTest::Part p = cmCTest::PartStart;
 953       p != cmCTest::PartCount; p = cmCTest::Part(p+1))
 954     {
 955     // Skip parts we are not submitting.
 956     if(!this->SubmitPart[p])
 957       {
 958       continue;
 959       }
 960
 961     // Submit files from this part.
 962     std::vector<std::string> const& pfiles = this->CTest->GetSubmitFiles(p);
 963     for(std::vector<std::string>::const_iterator pi = pfiles.begin();
 964         pi != pfiles.end(); ++pi)
 965       {
 966       files.insert(*pi);
 967       }
 968     }
 969
 970   if ( ofs )
 971     {
 972     ofs << "Upload files:" << std::endl;
 973     int cnt = 0;
 974     cmCTest::SetOfStrings::iterator it;
 975     for ( it = files.begin(); it != files.end(); ++ it )
 976       {
 977       ofs << cnt << "\t" << it->c_str() << std::endl;
 978       cnt ++;
 979       }
 980     }
 981   cmCTestLog(this->CTest, HANDLER_OUTPUT, "Submit files (using "
 982     << this->CTest->GetCTestConfiguration("DropMethod") << ")"
 983     << std::endl);
 984   const char* specificTrack = this->CTest->GetSpecificTrack();
 985   if ( specificTrack )
 986     {
 987     cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Send to track: "
 988       << specificTrack << std::endl);
 989     }
 990   this->SetLogFile(&ofs);
 991
 992   cmStdString dropMethod(this->CTest->GetCTestConfiguration("DropMethod"));
 993
 994   if ( dropMethod == "" || dropMethod == "ftp" )
 995     {
 996     ofs << "Using drop method: FTP" << std::endl;
 997     cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Using FTP submit method"
 998       << std::endl
 999       << "   Drop site: ftp://");
1000     std::string url = "ftp://";
1001     url += cmCTest::MakeURLSafe(
1002       this->CTest->GetCTestConfiguration("DropSiteUser")) + ":" +
1003       cmCTest::MakeURLSafe(this->CTest->GetCTestConfiguration(
1004           "DropSitePassword")) + "@" +
1005       this->CTest->GetCTestConfiguration("DropSite") +
1006       cmCTest::MakeURLSafe(
1007         this->CTest->GetCTestConfiguration("DropLocation"));
1008     if ( this->CTest->GetCTestConfiguration("DropSiteUser").size() > 0 )
1009       {
1010       cmCTestLog(this->CTest, HANDLER_OUTPUT,
1011         this->CTest->GetCTestConfiguration(
1012           "DropSiteUser").c_str());
1013       if ( this->CTest->GetCTestConfiguration("DropSitePassword").size() > 0 )
1014         {
1015         cmCTestLog(this->CTest, HANDLER_OUTPUT, ":******");
1016         }
1017       cmCTestLog(this->CTest, HANDLER_OUTPUT, "@");
1018       }
1019     cmCTestLog(this->CTest, HANDLER_OUTPUT,
1020       this->CTest->GetCTestConfiguration("DropSite")
1021       << this->CTest->GetCTestConfiguration("DropLocation") << std::endl);
1022     if ( !this->SubmitUsingFTP(buildDirectory + "/Testing/"
1023         + this->CTest->GetCurrentTag(),
1024         files, prefix, url) )
1025       {
1026       cmCTestLog(this->CTest, ERROR_MESSAGE,
1027         "   Problems when submitting via FTP"
1028         << std::endl);
1029       ofs << "   Problems when submitting via FTP" << std::endl;
1030       return -1;
1031       }
1032     if(!this->CDash)
1033       {
1034       cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Using HTTP trigger method"
1035                  << std::endl
1036                  << "   Trigger site: "
1037                  << this->CTest->GetCTestConfiguration("TriggerSite")
1038                  << std::endl);
1039       if ( !this->
1040            TriggerUsingHTTP(files, prefix,
1041                             this->CTest->GetCTestConfiguration("TriggerSite")))
1042         {
1043         cmCTestLog(this->CTest, ERROR_MESSAGE,
1044                    "   Problems when triggering via HTTP" << std::endl);
1045         ofs << "   Problems when triggering via HTTP" << std::endl;
1046         return -1;
1047         }
1048       cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Submission successful"
1049                  << std::endl);
1050       ofs << "   Submission successful" << std::endl;
1051       return 0;
1052       }
1053     }
1054   else if ( dropMethod == "http" || dropMethod == "https" )
1055     {
1056     std::string url = dropMethod;
1057     url += "://";
1058     ofs << "Using drop method: HTTP" << std::endl;
1059     cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Using HTTP submit method"
1060       << std::endl
1061       << "   Drop site:" << url);
1062      if ( this->CTest->GetCTestConfiguration("DropSiteUser").size() > 0 )
1063       {
1064       url += this->CTest->GetCTestConfiguration("DropSiteUser");
1065       cmCTestLog(this->CTest, HANDLER_OUTPUT,
1066         this->CTest->GetCTestConfiguration("DropSiteUser").c_str());
1067       if ( this->CTest->GetCTestConfiguration("DropSitePassword").size() > 0 )
1068         {
1069         url += ":" + this->CTest->GetCTestConfiguration("DropSitePassword");
1070         cmCTestLog(this->CTest, HANDLER_OUTPUT, ":******");
1071         }
1072       url += "@";
1073       cmCTestLog(this->CTest, HANDLER_OUTPUT, "@");
1074       }
1075     url += this->CTest->GetCTestConfiguration("DropSite") +
1076       this->CTest->GetCTestConfiguration("DropLocation");
1077     cmCTestLog(this->CTest, HANDLER_OUTPUT,
1078       this->CTest->GetCTestConfiguration("DropSite")
1079       << this->CTest->GetCTestConfiguration("DropLocation") << std::endl);
1080     if ( !this->SubmitUsingHTTP(buildDirectory + "/Testing/" +
1081         this->CTest->GetCurrentTag(), files, prefix, url) )
1082       {
1083       cmCTestLog(this->CTest, ERROR_MESSAGE,
1084         "   Problems when submitting via HTTP" << std::endl);
1085       ofs << "   Problems when submitting via HTTP" << std::endl;
1086       return -1;
1087       }
1088     if(!this->CDash)
1089       {
1090       cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Using HTTP trigger method"
1091                  << std::endl
1092                  << "   Trigger site: "
1093                  << this->CTest->GetCTestConfiguration("TriggerSite")
1094                  << std::endl);
1095       if ( !this->
1096            TriggerUsingHTTP(files, prefix,
1097                             this->CTest->GetCTestConfiguration("TriggerSite")))
1098         {
1099         cmCTestLog(this->CTest, ERROR_MESSAGE,
1100                    "   Problems when triggering via HTTP" << std::endl);
1101         ofs << "   Problems when triggering via HTTP" << std::endl;
1102         return -1;
1103         }
1104       }
1105     cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Submission successful"
1106                << std::endl);
1107     ofs << "   Submission successful" << std::endl;
1108     return 0;
1109     }
1110   else if ( dropMethod == "xmlrpc" )
1111     {
1112     ofs << "Using drop method: XML-RPC" << std::endl;
1113     cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Using XML-RPC submit method"
1114       << std::endl);
1115     std::string url = this->CTest->GetCTestConfiguration("DropSite");
1116     prefix = this->CTest->GetCTestConfiguration("DropLocation");
1117     if ( !this->SubmitUsingXMLRPC(buildDirectory + "/Testing/" +
1118         this->CTest->GetCurrentTag(), files, prefix, url) )
1119       {
1120       cmCTestLog(this->CTest, ERROR_MESSAGE,
1121         "   Problems when submitting via XML-RPC" << std::endl);
1122       ofs << "   Problems when submitting via XML-RPC" << std::endl;
1123       return -1;
1124       }
1125     cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Submission successful"
1126       << std::endl);
1127     ofs << "   Submission successful" << std::endl;
1128     return 0;
1129     }
1130   else if ( dropMethod == "scp" )
1131     {
1132     std::string url;
1133     std::string oldWorkingDirectory;
1134     if ( this->CTest->GetCTestConfiguration("DropSiteUser").size() > 0 )
1135       {
1136       url += this->CTest->GetCTestConfiguration("DropSiteUser") + "@";
1137       }
1138     url += this->CTest->GetCTestConfiguration("DropSite") + ":" +
1139       this->CTest->GetCTestConfiguration("DropLocation");
1140
1141     // change to the build directory so that we can uses a relative path
1142     // on windows since scp dosn't support "c:" a drive in the path
1143     oldWorkingDirectory = cmSystemTools::GetCurrentWorkingDirectory();
1144     cmSystemTools::ChangeDirectory(buildDirectory.c_str());
1145
1146     if ( !this->SubmitUsingSCP(
1147         this->CTest->GetCTestConfiguration("ScpCommand"),
1148         "Testing/"+this->CTest->GetCurrentTag(), files, prefix, url) )
1149       {
1150       cmSystemTools::ChangeDirectory(oldWorkingDirectory.c_str());
1151       cmCTestLog(this->CTest, ERROR_MESSAGE,
1152         "   Problems when submitting via SCP"
1153         << std::endl);
1154       ofs << "   Problems when submitting via SCP" << std::endl;
1155       return -1;
1156       }
1157     cmSystemTools::ChangeDirectory(oldWorkingDirectory.c_str());
1158     cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Submission successful"
1159       << std::endl);
1160     ofs << "   Submission successful" << std::endl;
1161     return 0;
1162     }
1163   else if ( dropMethod == "cp" )
1164     {
1165     std::string location
1166       = this->CTest->GetCTestConfiguration("DropLocation");
1167
1168
1169     // change to the build directory so that we can uses a relative path
1170     // on windows since scp dosn't support "c:" a drive in the path
1171     std::string
1172       oldWorkingDirectory = cmSystemTools::GetCurrentWorkingDirectory();
1173     cmSystemTools::ChangeDirectory(buildDirectory.c_str());
1174     cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "   Change directory: "
1175                << buildDirectory.c_str() << std::endl);
1176
1177     if ( !this->SubmitUsingCP(
1178            "Testing/"+this->CTest->GetCurrentTag(),
1179            files,
1180            prefix,
1181            location) )
1182       {
1183       cmSystemTools::ChangeDirectory(oldWorkingDirectory.c_str());
1184       cmCTestLog(this->CTest, ERROR_MESSAGE,
1185         "   Problems when submitting via CP"
1186         << std::endl);
1187       ofs << "   Problems when submitting via cp" << std::endl;
1188       return -1;
1189       }
1190     cmSystemTools::ChangeDirectory(oldWorkingDirectory.c_str());
1191     cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Submission successful"
1192       << std::endl);
1193     ofs << "   Submission successful" << std::endl;
1194     return 0;
1195     }
1196
1197   cmCTestLog(this->CTest, ERROR_MESSAGE, "   Unknown submission method: \""
1198     << dropMethod << "\"" << std::endl);
1199   return -1;
1200 }
1201
1202 //----------------------------------------------------------------------------
1203 std::string cmCTestSubmitHandler::GetSubmitResultsPrefix()
1204 {
1205   std::string name = this->CTest->GetCTestConfiguration("Site") +
1206     "___" + this->CTest->GetCTestConfiguration("BuildName") +
1207     "___" + this->CTest->GetCurrentTag() + "-" +
1208     this->CTest->GetTestModelString() + "___XML___";
1209   return name;
1210 }
1211
1212 //----------------------------------------------------------------------------
1213 void cmCTestSubmitHandler::SelectParts(std::set<cmCTest::Part> const& parts)
1214 {
1215   // Check whether each part is selected.
1216   for(cmCTest::Part p = cmCTest::PartStart;
1217       p != cmCTest::PartCount; p = cmCTest::Part(p+1))
1218     {
1219     this->SubmitPart[p] =
1220       (std::set<cmCTest::Part>::const_iterator(parts.find(p)) != parts.end());
1221     }
1222 }
1223
1224 //----------------------------------------------------------------------------
1225 void cmCTestSubmitHandler::SelectFiles(cmCTest::SetOfStrings const& files)
1226 {
1227   cmCTest::SetOfStrings::const_iterator it;
1228   for (it = files.begin(); it != files.end(); ++it)
1229     {
1230     this->Files.insert(*it);
1231     }
1232 }