src/SMESHUtils/SMESH_MGLicenseKeyGen.cxx

   1 // Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 // File      : SMESHUtils_MGLicenseKeyGen.cxx
  20 // Created   : Sat Jul 31 18:54:16 2021
  21 // Author    : Edward AGAPOV (OCC)
  22
  23 #include "SMESH_MGLicenseKeyGen.hxx"
  24
  25 #include "SMESH_Comment.hxx"
  26 #include "SMESH_File.hxx"
  27 #include "SMESH_TryCatch.hxx"
  28
  29 #include <Basics_DirUtils.hxx>
  30 #include <Basics_Utils.hxx>
  31
  32 #include <regex>
  33 #include <cstdlib> // getenv, system
  34
  35 #include <boost/filesystem.hpp>
  36 namespace boofs = boost::filesystem;
  37
  38 #ifdef WIN32
  39
  40 #  include <windows.h>
  41 #  include <process.h>
  42
  43 #  define LibHandle HMODULE
  44 #  define LoadLib( name ) LoadLibrary( name )
  45 #  define GetProc GetProcAddress
  46 #  define UnLoadLib( handle ) FreeLibrary( handle );
  47
  48 #else // WIN32
  49
  50 #  include <dlfcn.h>
  51
  52 #  define LibHandle void*
  53 #  define LoadLib( name ) dlopen( name, RTLD_LAZY | RTLD_LOCAL )
  54 #  define GetProc dlsym
  55 #  define UnLoadLib( handle ) dlclose( handle );
  56
  57 #endif // WIN32
  58
  59 // to retrieve description of exception caught by SMESH_TRY
  60 #undef SMESH_CAUGHT
  61 #define SMESH_CAUGHT error =
  62
  63
  64 namespace
  65 {
  66   static LibHandle theLibraryHandle = nullptr; //!< handle of a loaded library
  67
  68   const char* theEnvVar = "SALOME_MG_KEYGEN_LIB_PATH"; /* var specifies either full file name
  69                                                           of libSalomeMeshGemsKeyGenerator or
  70                                                           URL to download the library from */
  71
  72   const char* theTmpEnvVar = "SALOME_TMP_DIR"; // directory to download the library to
  73
  74   //-----------------------------------------------------------------------------------
  75   /*!
  76    * \brief Remove library file at destruction in case if it was downloaded from server
  77    */
  78   //-----------------------------------------------------------------------------------
  79
  80   struct LibraryFile
  81   {
  82     std::string _name; // full file name
  83     bool        _isURL;
  84
  85     LibraryFile(): _isURL( false ) {}
  86
  87     ~LibraryFile()
  88     {
  89       if ( _isURL )
  90       {
  91         if ( theLibraryHandle )
  92         {
  93           UnLoadLib( theLibraryHandle );
  94           theLibraryHandle = nullptr;
  95         }
  96
  97         std::string tmpDir; // tmp dir that should not be removed
  98         if ( const char* libPath = getenv( theTmpEnvVar ))
  99         {
 100           tmpDir = libPath;
 101           while (( !tmpDir.empty() ) &&
 102                  ( tmpDir.back() == '/' || tmpDir.back() == '\\' ))
 103             tmpDir.pop_back();
 104         }
 105
 106         while ( SMESH_File( _name ).remove() )
 107         {
 108           size_t length = _name.size();
 109           _name = boofs::path( _name ).parent_path().string(); // goto parent directory
 110           if ( _name.size() == length )
 111             break; // no more parents
 112
 113           if ( _name == tmpDir )
 114             break; // don't remove tmp dir
 115
 116           if ( !Kernel_Utils::IsEmptyDir( _name ))
 117             break;
 118         }
 119       }
 120     }
 121   };
 122
 123
 124   //================================================================================
 125   /*!
 126    * \brief Retrieve description of the last error
 127    *  \param [out] error - return the description
 128    *  \return bool - true if the description found
 129    */
 130   //================================================================================
 131
 132   bool getLastError( std::string& error )
 133   {
 134 #ifndef WIN32
 135
 136     if ( const char* text = dlerror() )
 137     {
 138       error = text;
 139       return true;
 140     }
 141     return false;
 142
 143 #else
 144
 145     DWORD dw = GetLastError();
 146     void* cstr;
 147     DWORD msgLen = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
 148                                  NULL,
 149                                  dw,
 150                                  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
 151                                  (LPTSTR) &cstr,
 152                                  0,
 153                                  NULL
 154                                  );
 155     if ( msgLen > 0 ) {
 156 #  if defined( UNICODE )
 157       error = Kernel_Utils::encode_s((wchar_t*)cstr);
 158 #  else
 159       error = (char*)cstr;
 160 #  endif
 161       LocalFree(cstr);
 162     }
 163
 164     return (bool)msgLen;
 165
 166 #endif
 167   }
 168
 169   //================================================================================
 170   /*!
 171    * \brief Adjust file extension according to the platform
 172    */
 173   //================================================================================
 174
 175   bool setExtension( std::string& fileName, std::string& error )
 176   {
 177     if ( fileName.empty() )
 178     {
 179       error = "Library file name is empty";
 180       return false;
 181     }
 182 #if defined(WIN32)
 183     std::string ext = ".dll";
 184 #elif defined(__APPLE__)
 185     std::string ext = ".dylib";
 186 #else
 187     std::string ext = ".so";
 188 #endif
 189
 190     fileName = fileName.substr( 0, fileName.find_last_of('.')) + ext;
 191     return true;
 192   }
 193
 194   //================================================================================
 195   /*!
 196    * \brief Check if library file name looks like an URL
 197    *  \param [in,out] libraryFile - holds file name and returns result in _isURL member field
 198    *  \return bool - true if the file name looks like an URL
 199    */
 200   //================================================================================
 201
 202   bool isURL( LibraryFile & libraryFile )
 203   {
 204     enum { SCHEME = 2, AUTHORITY = 4, PATH = 5 }; // sub-strings
 205     std::regex urlRegex ( R"(^(([^:\/?#]+):)?(//([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?)",
 206                           std::regex::extended );
 207     std::smatch matchResult;
 208
 209     libraryFile._isURL = false;
 210     if ( std::regex_match( libraryFile._name, matchResult, urlRegex ))
 211       libraryFile._isURL = ( !matchResult.str( SCHEME    ).empty() &&
 212                              !matchResult.str( AUTHORITY ).empty() &&
 213                              !matchResult.str( PATH      ).empty() );
 214
 215     return libraryFile._isURL;
 216   }
 217
 218   //================================================================================
 219   /*!
 220    * \brief Download libraryFile._name URL to SALOME_TMP_DIR
 221    *  \param [in,out] libraryFile - holds the URL and returns name of a downloaded file
 222    *  \param [out] error - return error description
 223    *  \return bool - is a success
 224    */
 225   //================================================================================
 226
 227   bool downloadLib( LibraryFile& libraryFile, std::string & error )
 228   {
 229     // check if can write into SALOME_TMP_DIR
 230
 231     std::string tmpDir = Kernel_Utils::GetTmpDirByEnv( theTmpEnvVar );
 232     if ( tmpDir.empty() ||
 233          !Kernel_Utils::IsExists( tmpDir ))
 234     {
 235       error = "Can't download " + libraryFile._name + " as SALOME_TMP_DIR is not correctly set";
 236       return false;
 237     }
 238     if ( !Kernel_Utils::IsWritable( tmpDir ))
 239     {
 240       error = "Can't download " + libraryFile._name + " as '" + tmpDir + "' is not writable. "
 241         "Check SALOME_TMP_DIR environment variable";
 242       return false;
 243     }
 244
 245     // Download
 246
 247     std::string url = libraryFile._name;
 248
 249 #ifdef WIN32
 250
 251     std::string outFile = tmpDir + "MeshGemsKeyGenerator.dll";
 252
 253     // use wget (== Invoke-WebRequest) PowerShell command available since Windows 7
 254     std::string psCmd = "wget -Uri " + url + " -OutFile " + outFile;
 255     std::string   cmd = "powershell.exe " + psCmd;
 256
 257 #else
 258
 259     std::string outFile = tmpDir + "libMeshGemsKeyGenerator.so";
 260
 261     std::string cmd = "wget " + url + " -O " + outFile;
 262
 263 #endif
 264
 265     if ( Kernel_Utils::IsExists( outFile )) // remove existing file
 266     {
 267       SMESH_File lib( outFile, /*open=*/false );
 268       if ( !lib.remove() )
 269       {
 270         error = lib.error();
 271         return false;
 272       }
 273     }
 274
 275     system( cmd.c_str() ); // download
 276
 277     SMESH_File resultFile( outFile, /*open=*/false );
 278     bool ok = ( resultFile.exists() && resultFile.size() > 0 );
 279
 280     if ( ok )
 281       libraryFile._name = outFile;
 282     else
 283       error = "Can't download file " + url;
 284
 285     return ok;
 286   }
 287
 288   //================================================================================
 289   /*!
 290    * \brief Load libMeshGemsKeyGenerator.so
 291    *  \param [out] error - return error description
 292    *  \param [out] libraryFile - return library file name and _isURL flag
 293    *  \return bool - is a success
 294    */
 295   //================================================================================
 296
 297   bool loadLibrary( std::string& error, LibraryFile& libraryFile )
 298   {
 299     if ( theLibraryHandle )
 300       return true;
 301
 302     const char* libPath = getenv( theEnvVar );
 303     if ( !libPath )
 304     {
 305       error = SMESH_Comment( "Environment variable ") <<  theEnvVar << " is not set";
 306       return false;
 307     }
 308
 309     libraryFile._name = libPath;
 310     // if ( !setExtension( libraryFile._name, error )) // is it necessary?
 311     //   return false;
 312
 313     if ( isURL( libraryFile ))
 314     {
 315       if ( !downloadLib( libraryFile, error ))
 316       {
 317         // try to fix extension
 318         std::string url = libraryFile._name;
 319         if ( !setExtension( libraryFile._name, error ))
 320           return false;
 321         if ( url == libraryFile._name )
 322           return false; // extension not changed
 323
 324         if ( !downloadLib( libraryFile, error ))
 325           return false;
 326       }
 327     }
 328
 329 #if defined( WIN32 ) && defined( UNICODE )
 330     std::wstring encodePath = Kernel_Utils::utf8_decode_s( libraryFile._name );
 331     const wchar_t*     path = encodePath.c_str();
 332 #else
 333     const char*        path = libraryFile._name.c_str();
 334 #endif
 335
 336     theLibraryHandle = LoadLib( path );
 337     if ( !theLibraryHandle )
 338     {
 339       if ( ! getLastError( error ))
 340         error = "Can't load library '" + libraryFile._name + "'";
 341     }
 342
 343     return theLibraryHandle;
 344   }
 345
 346 } // anonymous namespace
 347
 348
 349 namespace SMESHUtils_MGLicenseKeyGen // API implementation
 350 {
 351   //================================================================================
 352   /*!
 353    * \brief Sign a CAD
 354    *  \param [in] meshgems_cad - pointer to a MG CAD object (meshgems_cad_t)
 355    *  \param [out] error - return error description
 356    *  \return bool - is a success
 357    */
 358   //================================================================================
 359
 360   bool SignCAD( void* meshgems_cad, std::string& error )
 361   {
 362     LibraryFile libraryFile;
 363     if ( !loadLibrary( error, libraryFile ))
 364       return false;
 365
 366     bool ok = false;
 367     typedef bool (*SignFun)(void* );
 368     SignFun signFun = (SignFun) GetProc( theLibraryHandle, "SignCAD" );
 369     if ( !signFun )
 370     {
 371       if ( ! getLastError( error ))
 372         error = SMESH_Comment( "Can't find symbol 'SignCAD' in '") << getenv( theEnvVar ) << "'";
 373     }
 374     else
 375     {
 376
 377       SMESH_TRY;
 378
 379       ok = signFun( meshgems_cad );
 380
 381       SMESH_CATCH( SMESH::returnError );
 382
 383       if ( !error.empty() )
 384         ok = false;
 385       else if ( !ok )
 386         error = "SignCAD() failed (located in '" + libraryFile._name + "')";
 387     }
 388     return ok;
 389   }
 390
 391   //================================================================================
 392   /*!
 393    * \brief Sign a mesh
 394    *  \param [in] meshgems_mesh - pointer to a MG mesh (meshgems_mesh_t)
 395    *  \param [out] error - return error description
 396    *  \return bool - is a success
 397    */
 398   //================================================================================
 399
 400   bool SignMesh( void* meshgems_mesh, std::string& error )
 401   {
 402     LibraryFile libraryFile;
 403     if ( !loadLibrary( error, libraryFile ))
 404       return false;
 405
 406     typedef bool (*SignFun)(void* );
 407     SignFun signFun = (SignFun) GetProc( theLibraryHandle, "SignMesh" );
 408     if ( !signFun )
 409     {
 410       if ( ! getLastError( error ))
 411         error = SMESH_Comment( "Can't find symbol 'SignMesh' in '") << getenv( theEnvVar ) << "'";
 412     }
 413     bool ok;
 414
 415     SMESH_TRY;
 416
 417     ok = signFun( meshgems_mesh );
 418
 419     SMESH_CATCH( SMESH::returnError );
 420
 421     if ( !error.empty() )
 422       ok = false;
 423     else if ( !ok )
 424       error = "SignMesh() failed (located in '" + libraryFile._name + "')";
 425
 426     return ok;
 427   }
 428
 429   //================================================================================
 430   /*!
 431    * \brief Return a license key to pass as argument to a MG mesher executable
 432    *  \param [in] gmfFile - path to an input mesh file
 433    *  \param [in] nb* - nb of entities in the input mesh
 434    *  \param [out] error - return error description
 435    *  \return std::string - the key
 436    */
 437   //================================================================================
 438
 439   std::string GetKey(const std::string& gmfFile,
 440                      int                nbVertex,
 441                      int                nbEdge,
 442                      int                nbFace,
 443                      int                nbVol,
 444                      std::string&       error)
 445   {
 446     std::string key;
 447     LibraryFile libraryFile;
 448     if ( !loadLibrary( error, libraryFile ))
 449       return key;
 450
 451     typedef std::string (*GetKeyFun)(std::string const &, int, int, int, int );
 452     GetKeyFun keyFun = (GetKeyFun) GetProc( theLibraryHandle, "GetKey" );
 453     if ( !keyFun )
 454     {
 455       if ( ! getLastError( error ))
 456         error = SMESH_Comment( "Can't find symbol 'GetKey' in '") << getenv( theEnvVar ) << "'";
 457     }
 458     key = keyFun( gmfFile, nbVertex, nbEdge, nbFace, nbVol );
 459
 460     if ( key.empty() )
 461       error = "GetKey() failed (located in '" + libraryFile._name + "')";
 462
 463     return key;
 464   }
 465
 466   //================================================================================
 467   /*!
 468    * \brief Return false if libMeshGemsKeyGenerator.so is not functional
 469    *  \param [out] error - return error description
 470    *  \return bool - is a success
 471    */
 472   //================================================================================
 473
 474   bool CheckKeyGenLibrary( std::string& error )
 475   {
 476     return !GetKey("",4,0,2,0,error ).empty();
 477   }
 478
 479   //================================================================================
 480   /*!
 481    * \brief Return KeyGenerator library name
 482    */
 483   //================================================================================
 484
 485   std::string GetLibraryName()
 486   {
 487     std::string libName, error;
 488     if ( const char* libPath = getenv( theEnvVar ))
 489     {
 490       libName = Kernel_Utils::GetBaseName( libPath );
 491     }
 492     else
 493     {
 494       libName = "libSalomeMeshGemsKeyGenerator";
 495     }
 496     setExtension( libName, error );
 497     return libName;
 498   }
 499 }