src/Core/CommunicationProtocolRSH.cxx

   1 //  Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 /*
  23  *  CommunicationProtocolRSH.cxx :
  24  *
  25  *  Created on: 14 sept. 2009
  26  *  Author : Renaud BARATE - EDF R&D
  27  */
  28
  29 #ifdef WIN32
  30 #include <direct.h>
  31 #include <iostream>
  32
  33 #include <RunTimeException.hxx>
  34 #endif
  35
  36 #include <config.h>
  37
  38 #include "CommunicationProtocolRSH.hxx"
  39
  40 using namespace std;
  41
  42 namespace Batch {
  43
  44   vector<string> CommunicationProtocolRSH::getExecCommandArgs(const string & subCommand,
  45                                                               const string & host,
  46                                                               const string & user) const
  47   {
  48     vector<string> cmd;
  49
  50     cmd.push_back(RSH_COMMAND);
  51     cmd.push_back(host);
  52
  53     if (user.size() > 0) {
  54       cmd.push_back("-l");
  55       cmd.push_back(user);
  56     }
  57
  58 #ifdef WIN32
  59     cmd.push_back("-n");
  60 #endif
  61
  62     cmd.push_back(subCommand);
  63
  64     return cmd;
  65   }
  66
  67   vector<string> CommunicationProtocolRSH::getCopyCommandArgs(const string & sourcePath,
  68                                                               const string & sourceHost,
  69                                                               const string & sourceUser,
  70                                                               const string & destinationPath,
  71                                                               const string & destinationHost,
  72                                                               const string & destinationUser) const
  73   {
  74     vector<string> cmd;
  75
  76     string fullSource;
  77     if (sourceHost.size() != 0) {
  78       if (sourceUser.size() != 0) {
  79 #ifdef WIN32
  80         fullSource += sourceHost + "." + sourceUser + ":";
  81 #else
  82         fullSource += sourceUser + "@" + sourceHost + ":";
  83 #endif
  84       } else {
  85         fullSource += sourceHost + ":";
  86       }
  87     }
  88     fullSource += sourcePath;
  89
  90     string fullDestination;
  91     if (destinationHost.size() != 0) {
  92       if (destinationUser.size() != 0) {
  93 #ifdef WIN32
  94         fullDestination += destinationHost + "." + destinationUser + ":";
  95 #else
  96         fullDestination += destinationUser + "@" + destinationHost + ":";
  97 #endif
  98       } else {
  99         fullDestination += destinationHost + ":";
 100       }
 101     }
 102     fullDestination += destinationPath;
 103
 104     cmd.push_back(RCP_COMMAND);
 105     cmd.push_back("-r");
 106     cmd.push_back(fullSource);
 107     cmd.push_back(fullDestination);
 108
 109     return cmd;
 110   }
 111
 112 #ifdef WIN32
 113   int CommunicationProtocolRSH::copyFile(const std::string & sourcePath,
 114                                          const std::string & sourceHost,
 115                                          const std::string & sourceUser,
 116                                          const std::string & destinationPath,
 117                                          const std::string & destinationHost,
 118                                          const std::string & destinationUser) const
 119   {
 120     // On Windows, we can't use drive letters in the paths of rcp command because they
 121     // are confused with host names. So we must first change the working directory and
 122     // then copy the file using its path without the drive letter.
 123
 124     // Extract the drive letter from the source path
 125     string sourcePathWithoutDrive;
 126     char sourceDriveLetter = getDriveLetter(sourcePath, &sourcePathWithoutDrive);
 127     // Error if we have a drive letter and it is a remote path
 128     if (sourceDriveLetter != '\0' && sourceHost.size() != 0)
 129       throw RunTimeException(string("Invalid path: ") + sourcePath + " for host " + sourceHost);
 130
 131     // Extract the drive letter from the destination path
 132     string destinationPathWithoutDrive;
 133     char destinationDriveLetter = getDriveLetter(destinationPath, &destinationPathWithoutDrive);
 134     // Error if we have a drive letter and it is a remote path
 135     if (destinationDriveLetter != '\0' && destinationHost.size() != 0)
 136       throw RunTimeException(string("Invalid path: ") + destinationPath + " for host " + destinationHost);
 137
 138     // Error if we have two drive letters and they are different
 139     if (sourceDriveLetter != '\0' && destinationDriveLetter != '\0' &&
 140         sourceDriveLetter != destinationDriveLetter)
 141       throw RunTimeException(string("Can't use RCP to copy files between different drives: ") +
 142                              sourcePath + (", ") + destinationPath);
 143
 144     // Now get the drive letter to use if there is one
 145     char driveLetter = (sourceDriveLetter != '\0') ? sourceDriveLetter : destinationDriveLetter;
 146
 147     // Get the drive of the current working directory
 148     char cwd[_MAX_PATH];
 149     _getcwd(cwd, _MAX_PATH);
 150     char currentDrive = getDriveLetter(cwd);
 151
 152     // Change working directory if necessary
 153     if (driveLetter != '\0' && driveLetter != currentDrive) {
 154       char newdir[3];
 155       newdir[0] = driveLetter;
 156       newdir[1] = ':';
 157       newdir[2] = '\0';
 158       cout << "Changing directory: " << newdir << endl;
 159       _chdir(newdir);
 160     }
 161
 162     int status = CommunicationProtocol::copyFile(sourcePathWithoutDrive, sourceHost, sourceUser,
 163                                                  destinationPathWithoutDrive, destinationHost, destinationUser);
 164
 165     // Go back to previous directory if necessary
 166     if (driveLetter != '\0' && driveLetter != currentDrive) {
 167       cout << "Changing directory: " << cwd << endl;
 168       _chdir(cwd);
 169     }
 170
 171     return status;
 172   }
 173
 174   char CommunicationProtocolRSH::getDriveLetter(const string & path, string * pathWithoutDrive) const
 175   {
 176     if (path.find(':') != string::npos) {
 177       // Error if the colon is not the second character
 178       if (path.size() < 2 || path[1] != ':')
 179         throw RunTimeException(string("Invalid path: ") + path);
 180       else {
 181         if (pathWithoutDrive != NULL) *pathWithoutDrive = path.substr(2);
 182         return path[0];
 183       }
 184     } else {
 185       if (pathWithoutDrive != NULL) *pathWithoutDrive = path;
 186       return '\0';
 187     }
 188   }
 189
 190 #endif
 191
 192 }