]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMESHUtils/SMESH_MGLicenseKeyGen.cxx
Salome HOME
ec06d988548ae0d1a1a1010a6e161dda1fc55e62
[modules/smesh.git] / 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     {// round1
205       enum { SCHEME = 2, AUTHORITY = 4, PATH = 5 }; // sub-strings
206       std::regex urlRegex ( R"(^(([^:\/?#]+):)?(//([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?)",
207                             std::regex::extended );
208       std::smatch matchResult;
209
210       libraryFile._isURL = false;
211       if ( std::regex_match( libraryFile._name, matchResult, urlRegex ))
212         libraryFile._isURL = ( !matchResult.str( SCHEME    ).empty() &&
213                               !matchResult.str( AUTHORITY ).empty() &&
214                               !matchResult.str( PATH      ).empty() );
215     }
216     if(libraryFile._isURL)
217       return true;
218     {// round2
219       enum { HOST = 2, PORT = 3, PATH = 4 }; // sub-strings
220       std::regex urlRegex ( R"(^(([^:\/?#]+):)?([^/]+)?(/[^#]*))",
221                             std::regex::extended );
222       std::smatch matchResult;
223
224       libraryFile._isURL = false;
225       if ( std::regex_match( libraryFile._name, matchResult, urlRegex ))
226         libraryFile._isURL = ( !matchResult.str( HOST ).empty() &&
227                               !matchResult.str( PORT ).empty() &&
228                               !matchResult.str( PATH ).empty() );
229     }
230     return libraryFile._isURL;
231   }
232
233   //================================================================================
234   /*!
235    * \brief Download libraryFile._name URL to SALOME_TMP_DIR
236    *  \param [in,out] libraryFile - holds the URL and returns name of a downloaded file
237    *  \param [out] error - return error description
238    *  \return bool - is a success
239    */
240   //================================================================================
241
242   bool downloadLib( LibraryFile& libraryFile, std::string & error )
243   {
244     // check if can write into SALOME_TMP_DIR
245
246     std::string tmpDir = Kernel_Utils::GetTmpDirByEnv( theTmpEnvVar );
247     if ( tmpDir.empty() ||
248          !Kernel_Utils::IsExists( tmpDir ))
249     {
250       error = "Can't download " + libraryFile._name + " as SALOME_TMP_DIR is not correctly set";
251       return false;
252     }
253     if ( !Kernel_Utils::IsWritable( tmpDir ))
254     {
255       error = "Can't download " + libraryFile._name + " as '" + tmpDir + "' is not writable. "
256         "Check SALOME_TMP_DIR environment variable";
257       return false;
258     }
259
260     // Download
261
262     std::string url = libraryFile._name;
263
264 #ifdef WIN32
265
266     std::string outFile = tmpDir + "MeshGemsKeyGenerator.dll";
267
268     // use wget (== Invoke-WebRequest) PowerShell command available since Windows 7
269     std::string psCmd = "wget -Uri " + url + " -OutFile " + outFile;
270     std::string   cmd = "powershell.exe " + psCmd;
271
272 #else
273
274     std::string outFile = tmpDir + "libMeshGemsKeyGenerator.so";
275
276     std::string cmd = "wget " + url + " -O " + outFile;
277
278 #endif
279
280     if ( Kernel_Utils::IsExists( outFile )) // remove existing file
281     {
282       SMESH_File lib( outFile, /*open=*/false );
283       if ( !lib.remove() )
284       {
285         error = lib.error();
286         return false;
287       }
288     }
289
290     system( cmd.c_str() ); // download
291
292     SMESH_File resultFile( outFile, /*open=*/false );
293     bool ok = ( resultFile.exists() && resultFile.size() > 0 );
294
295     if ( ok )
296       libraryFile._name = outFile;
297     else
298       error = "Can't download file " + url;
299
300     return ok;
301   }
302
303   //================================================================================
304   /*!
305    * \brief Load libMeshGemsKeyGenerator.so
306    *  \param [out] error - return error description
307    *  \param [out] libraryFile - return library file name and _isURL flag
308    *  \return bool - is a success
309    */
310   //================================================================================
311
312   bool loadLibrary( std::string& error, LibraryFile& libraryFile )
313   {
314     if ( theLibraryHandle )
315       return true;
316
317     const char* libPath = getenv( theEnvVar );
318     if ( !libPath )
319     {
320       error = SMESH_Comment( "Environment variable ") <<  theEnvVar << " is not set";
321       return false;
322     }
323
324     libraryFile._name = libPath;
325     // if ( !setExtension( libraryFile._name, error )) // is it necessary?
326     //   return false;
327
328     if ( isURL( libraryFile ))
329     {
330       if ( !downloadLib( libraryFile, error ))
331       {
332         // try to fix extension
333         std::string url = libraryFile._name;
334         if ( !setExtension( libraryFile._name, error ))
335           return false;
336         if ( url == libraryFile._name )
337           return false; // extension not changed
338
339         if ( !downloadLib( libraryFile, error ))
340           return false;
341       }
342     }
343
344 #if defined( WIN32 ) && defined( UNICODE )
345     std::wstring encodePath = Kernel_Utils::utf8_decode_s( libraryFile._name );
346     const wchar_t*     path = encodePath.c_str();
347 #else
348     const char*        path = libraryFile._name.c_str();
349 #endif
350
351     theLibraryHandle = LoadLib( path );
352     if ( !theLibraryHandle )
353     {
354       if ( ! getLastError( error ))
355         error = "Can't load library '" + libraryFile._name + "'";
356     }
357
358     return theLibraryHandle;
359   }
360
361 } // anonymous namespace
362
363
364 namespace SMESHUtils_MGLicenseKeyGen // API implementation
365 {
366   //================================================================================
367   /*!
368    * \brief Sign a CAD
369    *  \param [in] meshgems_cad - pointer to a MG CAD object (meshgems_cad_t)
370    *  \param [out] error - return error description
371    *  \return bool - is a success
372    */
373   //================================================================================
374
375   bool SignCAD( void* meshgems_cad, std::string& error )
376   {
377     LibraryFile libraryFile;
378     if ( !loadLibrary( error, libraryFile ))
379       return false;
380
381     bool ok = false;
382     typedef bool (*SignFun)(void* );
383     SignFun signFun = (SignFun) GetProc( theLibraryHandle, "SignCAD" );
384     if ( !signFun )
385     {
386       if ( ! getLastError( error ))
387         error = SMESH_Comment( "Can't find symbol 'SignCAD' in '") << getenv( theEnvVar ) << "'";
388     }
389     else
390     {
391       SMESH_TRY;
392
393       ok = signFun( meshgems_cad );
394
395       SMESH_CATCH( SMESH::returnError );
396
397       if ( !error.empty() )
398         ok = false;
399       else if ( !ok )
400         error = "SignCAD() failed (located in '" + libraryFile._name + "')";
401     }
402     return ok;
403   }
404
405   //================================================================================
406   /*!
407    * \brief Sign a mesh
408    *  \param [in] meshgems_mesh - pointer to a MG mesh (meshgems_mesh_t)
409    *  \param [out] error - return error description
410    *  \return bool - is a success
411    */
412   //================================================================================
413
414   bool SignMesh( void* meshgems_mesh, std::string& error )
415   {
416     LibraryFile libraryFile;
417     if ( !loadLibrary( error, libraryFile ))
418       return false;
419
420     bool ok = false;
421     typedef bool (*SignFun)(void* );
422     SignFun signFun = (SignFun) GetProc( theLibraryHandle, "SignMesh" );
423     if ( !signFun )
424     {
425       if ( ! getLastError( error ))
426         error = SMESH_Comment( "Can't find symbol 'SignMesh' in '") << getenv( theEnvVar ) << "'";
427     }
428     else
429     {
430       SMESH_TRY;
431
432       ok = signFun( meshgems_mesh );
433
434       SMESH_CATCH( SMESH::returnError );
435
436       if ( !error.empty() )
437         ok = false;
438       else if ( !ok )
439         error = "SignMesh() failed (located in '" + libraryFile._name + "')";
440     }
441     return ok;
442   }
443
444   //================================================================================
445   /*!
446    * \brief Return a license key to pass as argument to a MG mesher executable
447    *  \param [in] gmfFile - path to an input mesh file
448    *  \param [in] nb* - nb of entities in the input mesh
449    *  \param [out] error - return error description
450    *  \return std::string - the key
451    */
452   //================================================================================
453
454   std::string GetKey(const std::string& gmfFile,
455                      int                nbVertex,
456                      int                nbEdge,
457                      int                nbFace,
458                      int                nbVol,
459                      std::string&       error)
460   {
461     std::string key;
462     LibraryFile libraryFile;
463     if ( !loadLibrary( error, libraryFile ))
464       return key;
465
466     typedef std::string (*GetKeyFun)(std::string const &, int, int, int, int );
467     GetKeyFun keyFun = (GetKeyFun) GetProc( theLibraryHandle, "GetKey" );
468     if ( !keyFun )
469     {
470       if ( ! getLastError( error ))
471         error = SMESH_Comment( "Can't find symbol 'GetKey' in '") << getenv( theEnvVar ) << "'";
472     }
473     else
474     {
475       key = keyFun( gmfFile, nbVertex, nbEdge, nbFace, nbVol );
476     }
477     if ( key.empty() )
478       error = "GetKey() failed (located in '" + libraryFile._name + "')";
479
480     return key;
481   }
482
483   //================================================================================
484   /*!
485    * \brief Return false if libMeshGemsKeyGenerator.so is not functional
486    *  \param [out] error - return error description
487    *  \return bool - is a success
488    */
489   //================================================================================
490
491   bool CheckKeyGenLibrary( std::string& error )
492   {
493     return !GetKey("",4,0,2,0,error ).empty();
494   }
495
496   //================================================================================
497   /*!
498    * \brief Return KeyGenerator library name
499    */
500   //================================================================================
501
502   std::string GetLibraryName()
503   {
504     std::string libName, error;
505     if ( const char* libPath = getenv( theEnvVar ))
506     {
507       libName = Kernel_Utils::GetBaseName( libPath );
508     }
509     else
510     {
511       libName = "libSalomeMeshGemsKeyGenerator";
512     }
513     setExtension( libName, error );
514     return libName;
515   }
516 }