January 26, 2021, 05:30:04 AM

Author Topic: [bmx] Armadillo/Software Passport Functions by gellyware [ 1+ years ago ]  (Read 912 times)

Offline BlitzBot

  • Jr. Member
  • **
  • Posts: 1
Title : Armadillo/Software Passport Functions
Author : gellyware
Posted : 1+ years ago

Description : Functions to get information from an Armadillo/Software Passport Protected EXE

Code :
Code: BlitzMax
  1. '*********************************************************************
  2. ' ARMADILLO ACCESS FUNCTIONS
  3. ' Compiled by: Gellyware - 2006
  4. '*********************************************************************
  5.  
  6.  
  7. '*********************************************************************
  8. 'get environment variable
  9. '*********************************************************************
  10.  
  11. Extern "Win32"
  12.    Function GetEnvironmentVariable(lpName$z, lpBuffer:Byte Ptr, nSize) = "GetEnvironmentVariableA@12"
  13. End Extern
  14.  
  15. Function GetEnv$(envVar$)
  16.   Local buff:Byte[256]
  17.  
  18.   Local rtnLen = GetEnvironmentVariable(envVar$, buff, buff.length)
  19.   If rtnLen > (buff.length - 1)
  20.     buff = buff[..rtnLen]
  21.     rtnLen = GetEnvironmentVariable(envVar$, buff, buff.length)
  22.   EndIf
  23.  
  24.   Return String.FromBytes(buff, rtnLen)
  25. End Function
  26.  
  27. '*********************************************************************
  28. 'armaccess.dll functions
  29. '*********************************************************************
  30. Global Libary=LoadLibraryA("ArmAccess.dll")
  31. Global CheckCode( Name:String, Code:String )"win32"=getprocaddress(Libary,"CheckCode")
  32. Global VerifyKey( Name:String, Code:String )"win32"=getprocaddress(Libary,"VerifyKey")
  33. Global InstallKey( Name:String, Code:String )"win32"=getprocaddress(Libary,"InstallKey")
  34. Global InstallKeyLater( Name:String, Code:String )"win32"=getprocaddress(Libary,"InstallKeyLater")
  35. Global UninstallKey()"win32"=getprocaddress(Libary,"UninstallKey")
  36. Global SetDefaultKey()"win32"=getprocaddress(Libary,"SetDefaultKey")
  37. Global UpdateEnvironment()"win32"=getprocaddress(Libary,"UpdateEnvironment")
  38. Global IncrementCounter()"win32"=getprocaddress(Libary,"IncrementCounter")
  39. Global CopiesRunning()"win32"=getprocaddress(Libary,"CopiesRunning")
  40. Global ChangeHardwareLock()"win32"=getprocaddress(Libary,"ChangeHardwareLock")
  41. Global GetShellProcessID()"win32"=getprocaddress(Libary,"GetShellProcessID")
  42. Global FixClock( FixClockKey:String )"win32"=getprocaddress(Libary,"FixClock")
  43. Global RawFingerprintInfo( Item:Int )"win32"=getprocaddress(Libary,"RawFingerprintInfo")
  44. Global SetUserString( Which:Int, Str:String )"win32"=getprocaddress(Libary,"SetUserString")
  45. Global VBGetUserString( Which:Int )"win32"=getprocaddress(Libary,"VBGetUserString")
  46. Global WriteHardwareChangeLog( FileName:String )"win32"=getprocaddress(Libary,"WriteHardwareChangeLog")
  47. Global ConnectedToServer()"win32"=getprocaddress(Libary,"ConnectedToServer")
  48. Global CallBuyNowURL( ParentWindow:Int )"win32"=getprocaddress(Libary,"CallBuyNowURL")
  49. Global CallCustomerServiceURL( ParentWindow:Int )"win32"=getprocaddress(Libary,"CallCustomerServiceURL")
  50. Global ShowReminderMessage( ParentWindow:Int )"win32"=getprocaddress(Libary,"ShowReminderMessage")
  51. Global ShowReminderMessage2( ParentWindow:Int )"win32"=getprocaddress(Libary,"ShowReminderMessage2")
  52. Global ShowEnterKeyDialog( ParentWindow:Int )"win32"=getprocaddress(Libary,"ShowEnterKeyDialog")
  53. Global ExpireCurrentKey()"win32"=getprocaddress(Libary,"ExpireCurrentKey")
  54.  
  55.  
  56. '*********************************************************************
  57. 'KEY INFORMATION
  58. '*********************************************************************
  59.  
  60. Function getAltUserName$()
  61.         Rem
  62.         This is the name on the user's key, or the string "DEFAULT"
  63.         (without the quotation marks) If they're using the default certificate. Same as USERNAME.
  64.         Possible values:
  65.         The name that the currently-installed key was made For, Or "DEFAULT".
  66.         EndRem
  67.        
  68.         Return GetEnv("ALTUSERNAME")
  69. EndFunction
  70.  
  71. Function getCopiesAllowed$()
  72.         Rem
  73.         If your program uses the Limit Copies feature, this variable is set to the number of
  74.         copies permitted for the current certificate and key.
  75.  
  76.         Possible values:
  77.    The number of copies permitted by the current certificate and key, if the current
  78.         certificate uses the Limit Copies option. Otherwise NULL.
  79.         EndRem
  80.        
  81.         Return GetEnv("COPIESALLOWED")
  82. EndFunction
  83.  
  84. Function getDaysInstalled$()
  85.         Rem
  86.         This variable contains the number of days since the current key was installed.
  87.  
  88.         Possible values:
  89.     The decimal value of the number of days the current key has been installed.
  90.         EndRem
  91.        
  92.         Return GetEnv("DAYSINSTALLED")
  93. EndFunction
  94.  
  95. Function getDaysInstalledBitx$()
  96.         Rem
  97.         This is actually fifteen different variables,
  98.         DAYSINSTALLEDBIT1 through DAYSINSTALLEDBIT15.
  99.         They contain the number of days since the corresponding
  100.         "extra information" bit was last changed, and can be used with
  101.         Modification Keys to set up a trial period for separate modules in your program.
  102.        
  103.         Note: although SoftwarePassport/Armadillo now supports 32 extra-info bits,
  104.         only bits 1 through 15 have a days-installed entry. This is by design.
  105.        
  106.         Possible values:
  107.         The decimal value of the number of days the current key has been installed.
  108.         EndRem
  109.        
  110.         Return GetEnv("DAYSINSTALLEDBITx")
  111. EndFunction
  112.  
  113. Function getExtraInfo$()
  114.         Rem
  115.         Contains any user-defined "extra information" you have placed in the key, in decimal format.
  116.  
  117.         Possible values:
  118.     The user-defined "extra information" stored in the key, if any. Otherwise "0".
  119.         EndRem
  120.        
  121.         Return GetEnv("EXTRAINFO")
  122. EndFunction
  123.  
  124. Function getExtraInfoBits$()
  125.         Rem
  126.         This stores the same information as the EXTRAINFO variable, but in binary format.
  127.         The least-significant bit (bit 1) is the first character of the string; the last
  128.         character is the most-significant bit (bit 32). If the bit is set (on), the character
  129.         in the corresponding location will be a one ("1"); otherwise, it will be a zero ("0").
  130.         This string will always be thirty-two characters long, regardless of the information
  131.         stored in it. It is designed for those languages that don't have easy access to
  132.         bit-manipulation operators.
  133.  
  134.         Possible values:
  135.     "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx", where each "x" can be a zero character or a one character.
  136.         EndRem
  137.        
  138.         Return GetEnv("EXTRAINFOBITS")
  139. EndFunction
  140.  
  141. Function getKeyCreated$()
  142.         Rem
  143.         This contains the date that the currently-installed key was created on.
  144.  
  145.         Possible values:
  146.         The date, in the form "YYYY.MM.DD", that the currently-installed key was created on,
  147.         or NULL if the program is using the default certificate.
  148.         EndRem
  149.        
  150.         Return GetEnv("KEYCREATED")
  151. EndFunction
  152.  
  153. Function getUserKey$()
  154.         Rem
  155.     This is the key that the program is currently running under. It is not set for the default key.
  156.  
  157.     Possible values:
  158.     The key that the program is currently using, if one was entered.
  159.     "CLIENT" if this is a client copy of a client/server Network Licensing setup.
  160.     NULL if neither of those applies.
  161.         EndRem
  162.        
  163.         Return GetEnv("USERKEY")
  164. EndFunction
  165.  
  166. Function getSeverKey$()
  167.         Rem
  168.         The USERKEY environment variable is set to "CLIENT" for the client side of a client/server
  169.         Network Licensing system. If you want to have access to the server's key on such a system,
  170.         you can use the SERVERKEY environment variable instead. It's not set unless USERKEY is "CLIENT".
  171.  
  172.         Possible values:
  173.     The key used on the server copy, or NULL if this is not a client copy of the program.
  174.         EndRem
  175.        
  176.         Return GetEnv("SERVERKEY")
  177. EndFunction
  178.  
  179. Function getSeverAdress$()
  180.         Rem
  181.         On the client systems of a client/server Network Licensing system, the SERVERADDRESS
  182.         environment variable contains the IP address of the server.
  183.  
  184.         Possible values:
  185.     The IP address, in dotted-decimal format, of the server (if this is a client copy). Otherwise NULL.
  186.         EndRem
  187.        
  188.         Return GetEnv("SERVERADDRESS")
  189. EndFunction
  190.  
  191. Function getStolenKey$()
  192.         Rem
  193.         When a key is entered or was previously entered, and is found to be in the Stolen Codes
  194.         Database, the program sets the STOLENKEY environment variable to that key. This variable
  195.         remains set until the program exits, or until a new key is successfully installed.
  196.  
  197.         Possible values:
  198.         The stolen key that was entered or found on the system, or NULL if no stolen key was found.
  199.         EndRem
  200.        
  201.         Return GetEnv("STOLENKEY")
  202. EndFunction
  203.  
  204. Function getTotalUses$()
  205.         Rem
  206.         This variable contains the total number of times that the program has been started since
  207.         the current key was installed. It is incremented every time the program is started.
  208.  
  209.         Possible values:
  210.     The number of times the program has been started since the current key was installed.
  211.         Note that this will start at zero if the key was installed during the current run, but
  212.         that installing a key via the INI file method is done before the count is incremented,
  213.         so it will start at one in that case.
  214.         EndRem
  215.        
  216.         Return GetEnv("TOTALUSES")
  217. EndFunction
  218.  
  219. Function getTotalUsesAllKeys$()
  220.         Rem
  221.         Similar to TOTALUSES, but doesn't get reset when a key is installed.
  222.  
  223.         Possible values:
  224.     The total number of times the program has been started since it was installed.
  225.         EndRem
  226.        
  227.         Return GetEnv("TOTALUSESALLKEYS")
  228. EndFunction
  229.  
  230. Function getUserName$()
  231.         Rem
  232.         This is the name on the user's key, or the string "DEFAULT"
  233.         (without the quotation marks) if they're using the default certificate.
  234.  
  235.         Please note that Windows also sets this variable, to the name of the
  236.         logged-in user. SoftwarePassport/Armadillo will override this for protected programs,
  237.         but because of this, you cannot use the existence of USERNAME as an indication that
  238.         he program is protected. For this reason, the environment variable ALTUSERNAME carries the same information.
  239.  
  240.         Possible values:
  241.     The name that the currently-installed key was made for, or "DEFAULT".
  242.         EndRem
  243.        
  244.         Return GetEnv("USERNAME")
  245. EndFunction
  246.  
  247. '*********************************************************************
  248. 'EXPIRATION
  249. '*********************************************************************
  250.  
  251. Function getDaysLeft$()
  252.         Rem
  253.         For date- and day-limited certificates, this is set to the number of valid days left
  254.         on the key. When this is set to 1, the key will expire at midnight.
  255.        
  256.         Possible values:
  257.         The number of days remaining on the certificate, or NULL if the certificate is not
  258.         date- or days-limited.
  259.         EndRem
  260.        
  261.         Return GetEnv("DAYSLEFT")
  262. EndFunction
  263.  
  264. Function getExpired$()
  265.         Rem
  266.         This variable is set if you've chosen the "don't show expiration message" option and the
  267.         certificate is expired, if the key entered via ArmAccess.DLL's functions is already expired,
  268.         or if the current key becomes expired after a call to an ArmAccess.DLL function.
  269.        
  270.         SoftwarePassport/Armadillo can only automatically stop the program from running if the key
  271.         is expired when the program starts up; if the key expires after that, and the program is
  272.         still running, it will continue to run unless you check for the existence of this variable,
  273.         and take action if it's set.
  274.        
  275.         Possible values:
  276.         "True" if the certificate is expired, otherwise NULL.
  277.         EndRem
  278.        
  279.         Return GetEnv("EXPIRED")
  280. EndFunction
  281.  
  282. Function getExpiredDate$()
  283.         Rem
  284.         For expire-by-date certificates (only), this is set to the date the certificate expires on.
  285.        
  286.         Possible values:
  287.         The date the expire-by-date certificate expires on, in YYYY.MM.DD format, or NULL
  288.         if the certificate is not expire-by-date.
  289.         EndRem
  290.        
  291.         Return GetEnv("EXPIREDATE")
  292. EndFunction
  293.  
  294. Function getExpiredEver$()
  295.         Rem
  296.         For expire-by-version certificates, this tells you what version the key will expire on.
  297.        
  298.         Possible values:
  299.         The decimal value of the expiration version, with two digits after the decimal point,
  300.         if the current certificate is expire-by-version, otherwise NULL. Example: "3.75".
  301.         EndRem
  302.        
  303.         Return GetEnv("EXPIREVER")
  304. EndFunction
  305.  
  306. Function getTimeLeftNow$()
  307.         Rem
  308.         If you set the expire-by-minutes per-run timer, the TIMELEFTNOW environment variable
  309.         is set to the amount of time left in this run, in the form HH:MM:SS, where HH is the
  310.         number of hours (one or two digits), MM is the number of minutes (always two digits),
  311.         and SS is the number of seconds (again, always two digits).
  312.        
  313.         Possible values:
  314.         The amount of time left during this run, in hours, minutes, and seconds, or NULL if
  315.         the per-run timer isn't used in this certificate.
  316.         EndRem
  317.        
  318.         Return GetEnv("TIMELEFTNOW")
  319. EndFunction
  320.  
  321. Function getTimeLeftTotal$()
  322.         Rem
  323.         If you set the expire-by-minutes total-time timer, the TIMELEFTTOTAL environment
  324.         variable is set to the total amount of time left on the timer, in the form HH:MM:SS,
  325.         where HH is the number of hours (one, two, or three digits), MM is the number of minutes
  326.         (always two digits), and SS is the number of seconds (again, always two digits).
  327.        
  328.         Possible values:
  329.         The amount of time left on the timer, in hours, minutes, and seconds, or NULL if
  330.         the total-time timer isn't used in this certificate.
  331.         EndRem
  332.        
  333.         Return GetEnv("TIMELEFTTOTAL")
  334. EndFunction
  335.  
  336. Function getUsesLeft$()
  337.         Rem
  338.         For certificates offering a limited number-of-uses, this is set to the number of
  339.         uses remaining. If the user is on the last use, this is set to 1.
  340.        
  341.         Possible values:
  342.         The number of uses remaining, in decimal format, if the certificate is one of
  343.         the expire-by-uses ones. Otherwise NULL.
  344.         EndRem
  345.        
  346.         Return GetEnv("USESLEFT")
  347. EndFunction
  348.  
  349. Function getUsesLeftAfter$()
  350.         Rem
  351.         This will always be equal to USESLEFT minus one, and is intended for use in the
  352.         show-after Reminder Message.
  353.        
  354.         Possible values:
  355.         The number of uses remaining minus one, in decimal format, if the certificate is
  356.         one of the expire-by-uses ones. Otherwise NULL.
  357.         EndRem
  358.        
  359.         Return GetEnv("USESLEFTAFTER")
  360. EndFunction
  361.  
  362. '*********************************************************************
  363. 'CLOCK PROBLEMS
  364. '*********************************************************************
  365.  
  366. Function getClockBack$()
  367.         Rem
  368.         If you have chosen To disable SoftwarePassport/Armadillo's clock-back checking
  369.         (by way of the Don't Report Clock-Back option), this variable will be set when
  370.         SoftwarePassport/Armadillo detects a system clock that has been turned back.
  371.        
  372.         Possible values:
  373.         "True" If the clock has been set back, otherwise NULL.
  374.         EndRem
  375.        
  376.         Return GetEnv("CLOCKBACK")
  377. EndFunction
  378.  
  379. Function getClockForward$()
  380.         Rem
  381.         Similar To CLOCKBACK. If you have chosen To disable the clock-forward checking
  382.         (using the Don't Report Clock-Forward option), this variable will be set when
  383.         SoftwarePassport/Armadillo detects a system clock that has been set to a date
  384.         in the future. Please note that SoftwarePassport/Armadillo allows for several weeks'
  385.         leeway before reporting a problem.
  386.  
  387.         Possible values:
  388.     "True" If the clock has been set forward, otherwise NULL.
  389.         EndRem
  390.        
  391.         Return GetEnv("CLOCKFORWARD")
  392. EndFunction
  393.  
  394. Function getClockWhy$()
  395.         Rem
  396.         When CLOCKBACK Or CLOCKFORWARD are set, CLOCKWHY contains the reason-code that would
  397.         normally be shown on the error screen.
  398.  
  399.         Possible values:
  400.    "CCB-A" (For CLOCKFORWARD only)
  401.    "CCB-F" (CLOCKBACK)
  402.    "CCB-TT" (special)
  403.    "GDDM" (same as CCB-F, but For Limit Install Time keys)
  404.    "xxxx,yyyy,zzzz" (where x, y, And z are numbers; CLOCKBACK)
  405.     Null (If there is no clock problem)
  406.  
  407.         If you need To know the meaning of a particular code, please contact us by e-mail
  408.         at support@siliconrealms.com.
  409.         EndRem
  410.        
  411.         Return GetEnv("CLOCKWHY")
  412. EndFunction
  413.  
  414.  
  415. '*********************************************************************
  416. 'HARDWARE FINGERPRINTS
  417. '*********************************************************************
  418. Function getEnhFingerprint$()
  419.         Rem
  420.         Similar to the FINGERPRINT variable, this one holds the enhanced hardware-locking
  421.         fingerprint, for certificates that use enhanced hardware locking.
  422.        
  423.         Possible values:
  424.         The 32-bit Enhanced hardware fingerprint, in hexadecimal format, separated into two
  425.         four-digit groups by a dash. Example: "A1B2-C3D4".
  426.         EndRem
  427.        
  428.         Return GetEnv("ENHFINGERPRINT")
  429. EndFunction
  430.  
  431. Function getFingerPrint$()
  432.         Rem
  433.         This variable contains the eight-digit hexadecimal "machine fingerprint" of the
  434.         computer your program is currently running on, which is necessary to make a
  435.         hardware-locked key. This is the Standard fingerprint value; for the Enhanced
  436.         fingerprint value, see ENHFINGERPRINT.
  437.        
  438.         Possible values:
  439.         The 32-bit Standard hardware fingerprint, in hexadecimal format, separated into
  440.         two four-digit groups by a dash. Example: "A1B2-C3D4".
  441.         EndRem
  442.        
  443.         Return GetEnv("FINGERPRINT")
  444. EndFunction
  445.  
  446. '*********************************************************************
  447. 'MISCELANEOUS OR SPECIAL PURPOSE
  448. '*********************************************************************
  449.  
  450. Function getCommandLine$()
  451.         Rem
  452.         When you have enabled the Allow Only One Copy option, and a user tries to start
  453.         a second copy of your program, the raw command line of the second copy is passed
  454.         to your program via this variable. Please see the description of the Allow Only One
  455.         Copy option for details.
  456.        
  457.         Possible values:
  458.         The command line arguments of the second copy.
  459.         EndRem
  460.        
  461.         Return GetEnv("COMMANDLINE")
  462. EndFunction
  463.  
  464. Function getControlPID$()
  465.         Rem
  466.         When using CopyMem-II or the Debugger-Blocker, this variable will contain the program
  467.         ID of the SoftwarePassport/Armadillo control process for your program (the number that
  468.         is normally returned by the GetCurrentProcessId() API call), in decimal format. This is
  469.         sometimes needed to handle DDE messages.
  470.        
  471.         Possible values:
  472.         This variable will either contain the ProcessID of the control process
  473.         (if using the Debugger-Blocker or CopyMem-II settings) or the ProcessID of the current process.
  474.  
  475.         EndRem
  476.        
  477.         Return GetEnv("CONTROLPID")
  478. EndFunction
  479.  
  480. Function getDateLastRun$()
  481.         Rem
  482.         Contains the date that this program was last run on this system.
  483.         The first time it's run, this will contain the current date.
  484.        
  485.         Possible values:
  486.         The date of the last time the program was run, in YYYY.MM.DD format.
  487.         EndRem
  488.        
  489.         Return GetEnv("DATELASTRUN")
  490. EndFunction
  491.  
  492. Function getDr_Tagged$()
  493.         Rem
  494.         If your program is tagged for use with the Digital River Network, this environment
  495.         variable will be set.
  496.        
  497.         Possible values:
  498.         "True" or NULL.
  499.         EndRem
  500.        
  501.         Return GetEnv("DR_TAGGED")
  502. EndFunction
  503.  
  504. Function getEmulator$()
  505.         Rem
  506.         If your protected program is running under the VMware or VirtualPC emulators,
  507.         the EMULATOR environment variable will be set. Your program can use this to refuse
  508.         to run under such emulators, if desired.
  509.        
  510.         Possible values:
  511.         "VMware", "VirtualPC", or "VirtualPC/Mac" (without the quotation marks) if your
  512.         program is running under one of those emulators. Otherwise NULL.
  513.         EndRem
  514.        
  515.         Return GetEnv("EMULATOR")
  516. EndFunction
  517.  
  518. Function getFirstRun$()
  519.         Rem
  520.         This variable is set on the first run of your program. Your program can use it to
  521.         initialize things that are only set on the first run, or to show dialogs that only
  522.         need to be shown once.
  523.        
  524.         Possible values:
  525.         "True" on the first run of your program on a particular machine, otherwise NULL.
  526.  
  527.         EndRem
  528.        
  529.         Return GetEnv("FIRSTRUN")
  530. EndFunction
  531.  
  532. Function getInvalidKey$()
  533.         Rem
  534.         This variable is used if you have the "Auto-revert on invalid key" option set, and the key
  535.         stored on a user's system is invalid (probably because you've changed an encryption template
  536.         (this is referred to as encryption key in the SoftwarePassport GUI) or disabled or removed
  537.         the certificate entirely). It is only set during the first such run, and the program will
  538.         automatically revert to the default certificate, if any. This is intended to let your program
  539.         gracefully warn the user of the change.
  540.        
  541.         It is also now set if the key was found in the Stolen Codes Database.
  542.        
  543.         Possible values:
  544.         "True" if the previously-installed key was invalid or discovered in the Stolen Codes Database,
  545.         otherwise NULL.
  546.         EndRem
  547.        
  548.         Return GetEnv("INVALIDKEY")
  549. EndFunction
  550.  
  551. Function getLoadingWindow$()
  552.         Rem
  553.         If you use a custom bitmap splash screen window, this variable holds the handle of
  554.         this window. You can use this handle to hide the splash screen window when your program
  555.         starts up, if you don't wish to rely on SoftwarePassport/Armadillo's timer (you can't close
  556.         it directly, because it's opened by a different thread).
  557.        
  558.         Possible values:
  559.         The value of the window handle, in hexadecimal format, if your program has a splash screen.
  560.         Otherwise NULL.
  561.         EndRem
  562.        
  563.         Return GetEnv("LOADINGWINDOW")
  564. EndFunction
  565.  
  566. Function getProtectedFile$()
  567.         Rem
  568.         This variable holds the path and filename of the protected file. Not really needed anymore, but it remains for compatibility.
  569.        
  570.         Possible values:
  571.         The full path and filename of the protected file.
  572.         EndRem
  573.        
  574.         Return GetEnv("PROTECTEDFILE")
  575. EndFunction
  576.  
  577. Function getProtectedFilePath$()
  578.         Rem
  579.         This is the directory path to the protected file, without the filename.
  580.         For example, if the protected program (stored in PROTECTEDFILE) is
  581.         "C:Program FilesMy ProgramMy Program.exe", then the PROTECTEDFILEPATH will be
  582.         "C:Program FilesMy Program". This is primarily here for backwards compatibility,
  583.         but can also be used in HTML messages to locate graphics files.
  584.        
  585.         Possible values:
  586.         The full directory path to the protected file, without the filename. It always ends
  587.         in a back-slash.
  588.         EndRem
  589.        
  590.         Return GetEnv("PROTECTEDFILEPATH")
  591. EndFunction
  592.  
  593. Function getVersionNumber$()
  594.         Rem
  595.         If you define a version (on the Edit Project screen), SoftwarePassport/Armadillo will put that
  596.         version number in this variable.
  597.        
  598.         Possible values:
  599.         The version number you've entered on the Edit Project screen, if any, in decimal format with
  600.         two digits after the decimal point. Otherwise NULL.
  601.         EndRem
  602.        
  603.         Return GetEnv("VERSIONNUMBER")
  604. EndFunction
  605.  
  606. Function getWebsiteUrl$()
  607.         Rem
  608.         This contains the URL you've entered into the Website/Buy Now box in
  609.         SoftwarePassport/Armadillo, if any.
  610.        
  611.         Possible values:
  612.         The URL in the Website/Buy Now box for the current certificate, if any. Otherwise NULL.
  613.         EndRem
  614.        
  615.         Return GetEnv("WEBSITEURL")
  616. EndFunction


Comments :


kfprimm(Posted 1+ years ago)

 here's a smaller GetEnv command that doesn't require any externed functions
Code: [Select]
Function GetEnv$(env_var$)
Return String(getenv_(env_var))
End Function


 

SimplePortal 2.3.6 © 2008-2014, SimplePortal