madscientist
/
PKG-SNF-CS-WIN
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

git-svn-id: https://svn.microneil.com/svn/PKG-SNF-CS-WIN/trunk@36 ca630060-9ba5-4a53-a91e-8214b6452a9a

master
stargazer 9 years ago
parent
490e4500ba
commit
80866b5864
9 changed files with 653 additions and 1 deletions
Unified View Show Diff Stats
  1. 31
    0
      build/How to swap out SNFServer.exe in the Windows Installer.txt
  2. 1
    1
      build/MessageSnifferRestorer2_1.nsi
  3. BIN
      build/NSIS Extras/ExecDos.dll
  4. BIN
      build/NSIS Extras/newadvsplash.dll
  5. 621
    0
      build/NSIS Extras/rollback.nsh
  6. BIN
      build/Restorer.exe
  7. BIN
      build/SNFServer.exe
  8. BIN
      build/SNFServerV3.1.2-E3.1.4.exe
  9. BIN
      build/SNF_CS_Installer.exe

+ 31
- 0
build/How to swap out SNFServer.exe in the Windows Installer.txt View File

Written by Linda Pagillo 12-9-2015
Step 1 - Download and install NSIS 2.47 to your local machine (http://nsis.sourceforge.net/Download)
Step 2 - Download and install TortoiseSNV to your local machine (https://tortoisesvn.net/downloads.html)
Step 3 - Create a folder on your local Desktop called SNFServerSwap.
Step 4 - Right click on the SNFServerSwap folder and choose SVN Checkout. In the URL of Repository line, add the following: https://svn.microneil.com/svn/PKG-SNF-CS-WIN. In the Checkout area, add the following: C:\Users\yourWindowsusernamehere\Desktop\SNFServerSwap. Leave all other options as is on the screen. Click Ok. This process will download everything you need to complete the task of swapping out the old SNFServer.exe to a new version of SNFServer.exe.
Step 5 - Once the download of all of the files is complete, click the SNFServerSwap folder on your local Desktop.Click Trunk. Click Build. Click NSIS Extras. Find execdos.dll and newadvsplash.dll and save them to your C:\Program Files(x86)\NSIS\Plugins directory. Next, find the rollback.nsh and save it to your C:\Program Files(x86)\NSIS\Includes directory.
Step 6 - Obtain the new SNF Server executable from Pete. It will be called something other than SNFServer.exe. For example, it may be called something like this: SNFServerV3.1.2-E3.1.5.
Step 7 - Go to your SNFServerSwap\Truck\Build\ directory. Find and delete the SNFServer.exe that is there. Copy the new SNF Server executable (SNFServerV3.1.2-E3.1.4) to your SNFServerSwap\Truck\Build\ folder. Next, make a copy of the SNFServerV3.1.2-E3.1.5 and name it SNFServer.exe. So now you will have a SNFServerV3.1.2-E3.1.4 and a SNFServer.exe in the Build directory
Step 8 - In your SNFServerSwap folder you will find an NSIS Script file called MessageSnifferRestorer2_1. Right-click the file and open/edit it with a text editor of your choice (Notepad, Textpad, Notepad ++).Find the line that says something similar to this following (the version number may be different):
!define SNIFFER_SERVER_SPECIFIER "V3.1.2-E3.1.4". Next, remove the "V3.1.2-E3.1.4" and add the new Sniffer Server version number. For example, in the case of SNFServerV3.1.2-E3.1.5, the version number would be "V3.1.2-E3.1.5". Close and save the file.
Step 9 - Next you need to compile the MessageSnifferRestorer2_1. Right click on it and choose "Compile NSIS Script". The script will compile and you may see some errors which you can ignore. Click Close.
Step 10 - Next, still in the Build directory, you will see a file called MessageSnifferInstaller2_1. You need to compile this script as well. Right click on it and choose "Compile NSIS Script". The script will compile and you may see some errors which you can ignore. DO NOT CLICK CLOSE.
Step 11 - Now you need to test the installer to see if the new SNFServer.exe version was applied correctly. click the Test Installer button. This will launch the new installer file that you have created.
Step 12 - When the installer launches, choose Other (custom/unknown combination) and click Next. Specify
C:\SNF as the install directory. Click Next. Select New Install. Click Next. You will see the install start and then another box will pop. Click "I Agree". The next screen will ask for a License and Authentication Code. Use testmode as the license and setuptestingonly as the authentication code. Click Next. Click Next again. The rulebase will start to download. Wait for it to finish and then click Next. Now click Install. Once completed, click Next. Click Close.
Step 13 - Now you need to check to see if the new SNFServer.exe version was installed. Open a command prompt and CD to C:\SNF. At the prompt, type SNFServer.exe - V and hit enter. You will see something like this:
SNF Server Version 3.1.2 Build: Dec 3 2015 02:01:15. If you still see the old version of SNFServer.exe, that means that your scripts did not work to add the new SNFServer.exe to the installer. Contact Linda Pagillo at lpadnet@gmail.com or stargazer@microneil.com for assistance.

+ 1
- 1
build/MessageSnifferRestorer2_1.nsi View File

!verbose 2 !verbose 2
!define TEMP1 $R0 ;Temp variable !define TEMP1 $R0 ;Temp variable
!define SNIFFER_SERVER_SPECIFIER "V3.0.2-E3.0.11" ; This is the ending of the product specific server file.... not the default Server.exe file.
!define SNIFFER_SERVER_SPECIFIER "V3.1.2-E3.1.4" ; This is the ending of the product specific server file.... not the default Server.exe file.
; MessageSnifferRestorer1_1_1.nsi ; MessageSnifferRestorer1_1_1.nsi
; ;
; This script produces an included installer file that is packed inside the MessageSniffer Installer utility. ; This script produces an included installer file that is packed inside the MessageSniffer Installer utility.

BIN
build/NSIS Extras/ExecDos.dll View File


BIN
build/NSIS Extras/newadvsplash.dll View File


+ 621
- 0
build/NSIS Extras/rollback.nsh View File

#########################################################3
## Archiver Include Routines.
##
## Refined: Aug 17 2008. Andrew Wallo, Microneil, ArmResearch All Rights Reserved.
##########################################################
# Main objectives is as follows:
# Enable rollback of a folder to a previous folder state.
# Create the log, and store it in the archive so that it understands what it nees to rollback.
# Log should Contain, target directories, date and other relevent information.
# Dependencies:
# 1: Requires ${GetTime} to be defined in the master install script.
# 2: Requires ${GetBetwee} to be defined in the master install script. Used to parse file lines.
Var /GLOBAL SRS_CurrentArchiveFolder
Var /GLOBAL SRS_Rollback_FileHandle
Var /GLOBAL SRS_Rollback_FileCount
Var /GLOBAL SRS_LogName
!macro StartRollbackSession _ArchivePath _LogName _RootKey _RegistryKey
StrCpy $SRS_LogName ${_LogName}
StrCpy $SRS_CurrentArchiveFolder ${_ArchivePath}
StrCpy $SRS_Rollback_FileCount "0"
; Now put the values onto the stack for the Rollback engine.
Push `${_ArchivePath}`
Push `${_LogName}`
Call OpenRollback
;MessageBox MB_OK "Opened rollback with: $SRS_LogName / ${_ArchivePath} / $SRS_CurrentArchiveFolder"
${IF} "${_RootKey}" != ""
${IF} "${_RegistryKey}" != ""
${SetRegistry_with_RollbackControl} "${_RootKey}" "${_RegistryKey}" "SRS_RollbackPath" "$SRS_CurrentArchiveFolder"
${SetRegistry_with_RollbackControl} "${_RootKey}" "${_RegistryKey}" "SRS_LogName" "$SRS_LogName"
${ENDIF}
${ENDIF}
!macroend
!define StartRollbackSession "!insertmacro StartRollbackSession"
#test
!macro EndRollbackSession _RootKey _RegistryKey
${IF} "${_RootKey}" != ""
${IF} "${_RegistryKey}" != ""
${SetRegistry_with_RollbackControl} "${_RootKey}" "${_RegistryKey}" "SRS_COMPLETE" "1"
${SetRegistry_with_RollbackControl} "${_RootKey}" "${_RegistryKey}" "SRS_INSTDIR" "$INSTDIR"
${SetRegistry_with_RollbackControl} "${_RootKey}" "${_RegistryKey}" "SRS_SERVDIR" "$SNFServerInstallDir"
${ENDIF}
${ENDIF}
FileWrite $SRS_Rollback_FileHandle "<FILECOUNT>$SRS_Rollback_FileCount</FILECOUNT>$\r$\n"
StrCpy $SRS_Rollback_FileCount "0"
FileWrite $SRS_Rollback_FileHandle "<END ROLLBACK FILE>$\r$\n"
FileClose $SRS_Rollback_FileHandle ; close this file
StrCpy $SRS_Rollback_FileHandle "" ;and clear for new rollback session.
!macroend
!define EndRollbackSession "!insertmacro EndRollbackSession"
Function OpenRollback
; First determine if we're trying to open a second consecutive rollback session... ( this would be bad. )
;StrCmp $SRS_Rollback_FileHandle "" runOpenRollback 0 ; if cleared, then we can start a Rollback Session. If not clear, then set errors.
; push $1 ; saves $1
; Exch
; pop $1 ; removes ArchivePath off stack
; Exch
; pop $1 ; removes LogNme off stack
; pop $1 ; restores $1
; SetErrors
; MessageBox MB_OK "Archive in progress?"
; return ; sorry, can't do this right now....
;runOpenRollback: ; ok, clear for take-off:
; First protect the stack by saving the values of the registers we're going to use.
; But they're covering the parameters that were passed......
######################################## Stack Protection ###################################
push $9 ; Save Register $9;
Exch ; Swap Zeroth element in stack with the top most, which will be _LogName from the macro
pop $9 ; put Log into register $9
push $8 ; Save register $8
Exch 2 ; Swap with position 1 from the top. So.... before exch was $1 $0 _ArchivePath
; After Exch was _ArchvePath $0 $1
pop $8 ; $8 holds ArchivePath
push $7 ; Used Locally.... save on stack....
push $6
push $5
push $4
push $3
push $2
push $1
push $0
###################################### End Stack Protection #################################
; Ok,
ifFileExists "$8\*.*" SRS_FolderExists 0 ; if the folder exists, skip create, otherwise create directory.
CreateDirectory $8
SRS_FolderExists:
StrCpy $SRS_CurrentArchiveFolder $8 ; Save master variable for local var.
${GetTime} "" "L" $0 $1 $2 $3 $4 $5 $6 ; set vars for oldfilerename
; $0="01" day
; $1="04" month
; $2="2005" year
; $3="Friday" day of week name
; $4="16" hour
; $5="05" minute
; $6="50" seconds
; Create the specific archive folder path.
StrCpy $7 "Archive_$2$1$0$4$5$6" ; for keying the folder.
; Test for valid name... otherwise use default.
StrCmp $9 "" 0 +2
StrCpy $9 "$7_rllbck.log"
FileOpen $SRS_Rollback_FileHandle $8\$9 w ; Log File created for tracking rollback
FileWrite $SRS_Rollback_FileHandle "<COMMENT>Started Rollback Log</COMMENT>$\r$\n"
FileWrite $SRS_Rollback_FileHandle "<STARTDATE>$2.$1.$0,$4:$5:$6</STARTDATE>$\r$\n"
###################################### Restore the Stack ####################################
pop $0
pop $1
pop $2
pop $3
pop $4
pop $5
pop $6
pop $7
pop $8
pop $9
return
FunctionEnd
#####################################################################################################################################################
## ${SetRegistry_RollbackControl} sets a registry entry to a new value, and stores the old one.
#####################################################################################################################################################
!macro SetRegistry_with_RollbackControl _RootKey _RegistryKey _SubKey _Value
push $1
${Switch} "${_RootKey}"
${Case} "HKLM"
ReadRegStr $1 HKLM "${_RegistryKey}" "${_SubKey}" ; get keys value...
${Case} "HKCR"
ReadRegStr $1 HKCR "${_RegistryKey}" "${_SubKey}" ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKCU"
ReadRegStr $1 HKCU "${_RegistryKey}" "${_SubKey}" ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKU"
ReadRegStr $1 HKU "${_RegistryKey}" "${_SubKey}" ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKCC"
ReadRegStr $1 HKCC "${_RegistryKey}" "${_SubKey}" ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKDD"
ReadRegStr $1 HKDD "${_RegistryKey}" "${_SubKey}" ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKPD"
ReadRegStr $1 HKPD "${_RegistryKey}" "${_SubKey}" ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "SHCTX"
ReadRegStr $1 SHCTX "${_RegistryKey}" "${_SubKey}" ;$R1 $R2 $R3Goto EndSNFServiceTest
${EndSwitch}
StrCmp $1 "" 0 +4
; String is empty. Test for no key.
ifErrors 0 +3 ; Means its a DWORD or something, but I'm not handling that here.
; Key didn't exist.
FileWrite $SRS_Rollback_FileHandle "<REGISTRY><NEW>1</NEW><ROOT>${_RootKey}</ROOT><KEY>${_RegistryKey}</KEY><SUBKEY>${_SubKey}</SUBKEY><VALUE>${_Value}</VALUE></REGISTRY>$\r$\n"
Goto +2 ; skip duplicate line and alter registry....
; Else the key existed.
FileWrite $SRS_Rollback_FileHandle "<REGISTRY><NEW>0</NEW><ROOT>${_RootKey}</ROOT><KEY>${_RegistryKey}</KEY><SUBKEY>${_SubKey}</SUBKEY><VALUE>$1</VALUE></REGISTRY>$\r$\n"
${Switch} "${_RootKey}"
${Case} "HKLM"
WriteRegStr HKLM "${_RegistryKey}" "${_SubKey}" "${_Value}" ; get keys value...
${Case} "HKCR"
WriteRegStr HKCR "${_RegistryKey}" "${_SubKey}" "${_Value}" ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKCU"
WriteRegStr HKCU "${_RegistryKey}" "${_SubKey}" "${_Value}" ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKU"
WriteRegStr HKU "${_RegistryKey}" "${_SubKey}" "${_Value}" ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKCC"
WriteRegStr HKCC "${_RegistryKey}" "${_SubKey}" "${_Value}" ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKDD"
WriteRegStr HKDD "${_RegistryKey}" "${_SubKey}" "${_Value}" ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKPD"
WriteRegStr HKPD "${_RegistryKey}" "${_SubKey}" "${_Value}" ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "SHCTX"
WriteRegStr SHCTX "${_RegistryKey}" "${_SubKey}" "${_Value}" ;$R1 $R2 $R3Goto EndSNFServiceTest
${EndSwitch}
pop $1
!macroend
!define SetRegistry_with_RollbackControl "!insertmacro SetRegistry_with_RollbackControl"
#####################################################################################################################################################
## ${Install_with_RollbackControl} assumes you have set your INSTALL Directory as it will call File _someFilename and put it
## wherever the SetOutPath is pointing....
#####################################################################################################################################################
!macro Install_with_RollbackControl _someFileName _CallbackHandler _onFailCommand
StrCmp "1" "0" 0 +2
File ${_someFileName} ; can't ever happen but we need it here to force the compiler to include the file.
IfFileExists `$OUTDIR\${_someFileName}` 0 +4
; File exists. We need to make a copy of the original file.
CopyFiles /SILENT `$OUTDIR\${_someFileName}` `$SRS_CurrentArchiveFolder\${_someFileName}`
; We need to save the target path seperately because later when we're rolling it back, we'll need to setOutPath for each file seperately.
; If a file has a potential of being tied up, we can specify the action to take on an overwrite failure.
FileWrite $SRS_Rollback_FileHandle "<FILE><NEW>0</NEW><NAME>${_someFileName}</NAME><TARGETPATH>$OUTDIR</TARGETPATH><CALLBACK>${_CallbackHandler}</CALLBACK><ONFAIL>${_onFailCommand}</ONFAIL></FILE>$\r$\n"
Goto +2
; +4 jumps to here.....just Put The File
FileWrite $SRS_Rollback_FileHandle "<FILE><NEW>1</NEW><NAME>${_someFileName}</NAME><TARGETPATH>$OUTDIR</TARGETPATH><CALLBACK>${_CallbackHandler}</CALLBACK><ONFAIL>${_onFailCommand}</ONFAIL></FILE>$\r$\n"
File `${_someFileName}` ; ok, output the file into the install directory.
IntOp $SRS_Rollback_FileCount $SRS_Rollback_FileCount + 1
!macroend
!define Install_with_RollbackControl "!insertmacro Install_with_RollbackControl"
###################################################################################################################################################
## The difference here is that the macro doesn't rely on the SetOutPath or call the File "filename" command. It just archives a file into rollback
## based on the the fully qualified path name supplied.
################################################################################################################################################
!macro Copy_with_RollbackControl _someFileName _Path _CallbackHandler _onFailCommand
ifFileExists ${_Path}\${_someFileName} 0 +5
CopyFiles /SILENT `${_Path}\${_someFileName}` `$SRS_CurrentArchiveFolder\${_someFileName}`
CopyFiles /SILENT `${_Path}\${_someFileName}` `${_Path}\${_someFileName}_pre_sniffer_install.log`
; We need to save the target path seperately because later when we're rolling it back, we'll need to setOutPath for each file seperately.
; If a file has a potential of being tied up, we can specify the action to take on an overwrite failure.
FileWrite $SRS_Rollback_FileHandle "<FILE><NEW>0</NEW><NAME>${_someFileName}</NAME><TARGETPATH>${_Path}</TARGETPATH><CALLBACK>${_CallbackHandler}</CALLBACK><ONFAIL>${_onFailCommand}</ONFAIL></FILE>$\r$\n"
IntOp $SRS_Rollback_FileCount $SRS_Rollback_FileCount + 1
!macroend
!define Copy_with_RollbackControl "!insertmacro Copy_with_RollbackControl"
!macro RollBackTo _rollbackLocalPath _rollbackLogName
push `${_rollbackLocalPath}`
push `${_rollbackLogName}`
Call RollBack
!macroend
!define RollBackTo "!insertmacro RollBackTo"
Function RollBack
push $0 ; save register 0 on stack. ( So stack looks like $0 "_rollbackLogName" _rollbackLocalPath Rest of Stack.....
Exch ; swap the top two objects on the stack.... _rollbackLogName $0 _rollbackLocalPath
pop $0 ; stack looks like $0.._rollbackLocalPath ...Rest of Stack.... Using $0 to hld the RollBackLogName
push $1 ; stack looks like $1 $0.._rollbackLocalPath Rest of Stack Use this var for handling readlines.
Exch 2 ; stack looks like _rollbackLocalPath $0 $1 Rest of Stack
pop $1 ; Use this var for handling the local path of the list of archived files.
Exch ; stack looks like $1 $0 Rest of Stack
push $2 ; stack look like $2 $1 $0 Rest of stack. Use $2 to hold read lines.....
push $3 ; stack looks like $3 $2 $1 $0 RestofStack. Use this var for handling tag parsing of lines....
push $4 ; saving $4 too... use this var for holding filename of file.
push $5 ; saving $5 too... use this var for holding target path.
push $6 ; use this var for the command line to exeute if failed to copy....
push $7 ; use this var for temp file handle
; registry temp vars....
push $R1 ; protect this and use for the Root of the registry handles...
push $R2 ; protect this and use for the Key
push $R3 ; protect this and use for the subkey
push $R4 ; protected this and use for the Value.....
; Not sure what the situation would be..... but theoretically, if the file is open... then.... its still open and the caller wasn't careful about
; ending the rollback.
StrCmp $SRS_Rollback_FileHandle "" ProceedToRollBack 0
; File is open... crap... ok..well, reguardless of what our filename is, ( and it SHOULD be the same file, logically.... ) we want the other closed properly.
MessageBox MB_OK "Had to close the file?"
!insertmacro EndRollbackSession "" "" ; so end it cleanly. THEN open our rollback log. ; We're skipping the registry keys that record
; where the logfile and rollbackpath is... if this happens.
ProceedToRollBack:
ifFileExists "$1\$0" StartRollBack 0
SetErrors
MessageBox MB_OK "Unable to find rollback file: $1\$0"
Goto SRS_DONE
Return ; perhaps the user just gave the file folder.... try to locate the .rllbck file in the folder.... if it exists.
StartRollBack:
clearerrors
FileOpen $SRS_Rollback_FileHandle "$1\$0" r ; open file for read.
IfErrors 0 SRS_RESTORE_ReadLine
MessageBox MB_OK "Error opening the file for rollback: $1\$0"
Goto SRS_DONE
SRS_RESTORE_ReadLine:
ClearErrors
FileRead $SRS_Rollback_FileHandle $2 ; get line for parsing.
;MessageBox MB_OK $2
IfErrors SRS_DONE ; if errors, then EOF. Cleanup stack and exit.
; otherise parse line.
StrCpy $3 $2 6 ;if this line is a file line, then the first six chars should be <FILE>
;Handle Registry Alterations:
StrCmp $3 "<REGIS" 0 SRS_RESTORE_TestForFileLine
FileOpen $7 "$1\SRS_TempFile.txt" w
FileWrite $7 $2
FileClose $7
;<FILE><NEW>1</NEW><NAME>${_someFileName}</NAME><TARGETPATH>$OUTDIR</TARGETPATH><ONFAIL>${_onFailCommand}</ONFAIL></FILE>
;<REGISTRY><NEW>1</NEW><ROOT>${_RootKey}</ROOT><KEY>${_RegistryKey}</KEY><SUBKEY>${_SubKey}</SUBKEY><VALUE>${_Value}</VALUE></REGISTRY>
#MessageBox MB_OK "$2"
; Because GetBetween only uses files as sources.... ( stupid, that I'm using that here, but I am.... )
${GetBetween} "<NEW>" "</NEW>" "$1\SRS_TempFile.txt" $4 ; Get the file name between the file tags of the read_line_in->$2 and stick it in $4
#MessageBox MB_OK $4
${GetBetween} "<ROOT>" "</ROOT>" "$1\SRS_TempFile.txt" $R1 ; Get the file name between the file tags of the read_line_in->$2 and stick it in $4
#MessageBox MB_OK "$R1,$R2,$R3,$R4"
${GetBetween} "<KEY>" "</KEY>" "$1\SRS_TempFile.txt" $R2 ; Get the file name between the file tags of the read_line_in->$2 and stick it in $4
#MessageBox MB_OK "$R1,$R2,$R3,$R4"
${GetBetween} "<SUBKEY>" "</SUBKEY>" "$1\SRS_TempFile.txt" $R3 ; Get the file name between the file tags of the read_line_in->$2 and stick it in $4
#MessageBox MB_OK "$R1,$R2,$R3,$R4"
${GetBetween} "<VALUE>" "</VALUE>" "$1\SRS_TempFile.txt" $R4 ; Get the file name between the file tags of the read_line_in->$2 and stick it in $4
#MessageBox MB_OK "$R1,$R2,$R3,$R4"
#MessageBox MB_OK "$1, $4 , $R1 , $R2 , $R3 , $R4"
StrCmp $4 "SRS_RollbackPath" RemoveIt 0
StrCmp $4 "SRS_Logname" RemoveIt 0
StrCmp $4 "1" 0 SRS_RESTORE_WRITE ; if the new marker is set to 1 then a rollback means remove it entirely.....
RemoveIt:
${Switch} $R1
${Case} "HKLM"
DeleteRegValue HKLM $R2 $R3 ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKCR"
DeleteRegValue HKCR $R2 $R3 ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKCU"
DeleteRegValue HKCU $R2 $R3 ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKU"
DeleteRegValue HKU $R2 $R3 ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKCC"
DeleteRegValue HKCC $R2 $R3 ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKDD"
DeleteRegValue HKDD $R2 $R3 ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKPD"
DeleteRegValue HKPD $R2 $R3 ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "SHCTX"
DeleteRegValue SHCTX $R2 $R3 ;$R1 $R2 $R3Goto EndSNFServiceTest
${EndSwitch}
Goto SRS_RESTORE_ReadLine
SRS_RESTORE_WRITE:
; if not then we need to restore the key.....
${Switch} $R1
${Case} "HKLM"
WriteRegStr HKLM $R2 $R3 $R4
${Case} "HKCR"
WriteRegStr HKCR $R2 $R3 $R4
${Case} "HKCU"
WriteRegStr HKCU $R2 $R3 $R4
${Case} "HKU"
WriteRegStr HKU $R2 $R3 $R4
${Case} "HKCC"
WriteRegStr HKCC $R2 $R3 $R4
${Case} "HKDD"
WriteRegStr HKDD $R2 $R3 $R4
${Case} "HKPD"
WriteRegStr HKPD $R2 $R3 $R4
${Case} "SHCTX"
WriteRegStr SHCTX $R2 $R3 $R4
${EndSwitch}
Goto SRS_RESTORE_ReadLine
SRS_RESTORE_TestForFileLine:
StrCmp $3 "<FILE>" 0 SRS_RESTORE_ReadLine ; if its a file, then handle rolling back the file, otherwise get the next line.
FileOpen $7 "$1\SRS_TempFile.txt" w
FileWrite $7 $2
FileClose $7
; Because GetBetween only uses files as sources.... ( stupid, that I'm using that here, but I am.... )
${GetBetween} "<NAME>" "</NAME>" "$1\SRS_TempFile.txt" $4 ; Get the file name between the file tags of the read_line_in->$2 and stick it in $4
${GetBetween} "<NEW>" "</NEW>" "$1\SRS_TempFile.txt" $R1 ; Get the marker that informed us if there WAS something to be copied, or if it was just installed.
;MessageBox MB_OK "Name:$4"
${GetBetween} "<TARGETPATH>" "</TARGETPATH>" "$1\SRS_TempFile.txt" $5 ; Get the targetpath between the file tags of the read_line_in->$2 and stick it in $5
;MessageBox MB_OK "Target:$5"
clearerrors
${GetBetween} "<CALLBACK>" "</CALLBACK>" "$1\SRS_TempFile.txt" $6 ; Get the CALLBACK name between the file tags of the read_line_in->$2 and stick it in $6
iferrors NoCallbackAvailable 0
StrCmp $6 "" NoCallbackAvailable 0
; Ok, we have a callback, so we don't copy, we call file, and pass the filename.
;MessageBox MB_OK "Pushing $1\$4"
push "$1\$4" ; push the file and path onto the stack.
push $6 ; push the calback value onto the stack,
Call ResolveFunction ; call the resolveFunction Call.
Goto SRS_RESTORE_ReadLine ; No copy, just return for next line handle.
NoCallbackAvailable:
; now deal with new vs archived files...
StrCmp $R1 "1" 0 SRS_NOTNEW_RESTOREIT ; test to see if it was new, or if it required backin gup...
ifFileExists "$5\$4" 0 SRS_RESTORE_ReadLine ; if it WAS new... test to see if file still exists...
Delete "$5\$4" ; Since it was new we'll remove it on a restore....
Goto SRS_RESTORE_ReadLine
SRS_NOTNEW_RESTOREIT:
CopyFiles /SILENT "$1\$4" "$5\$4"
iferrors 0 SRS_RESTORE_ReadLine
clearerrors
${GetBetween} "<ONFAIL>" "</ONFAIL>" "$1\SRS_TempFile.txt" $6 ; Get the onfail name between the file tags of the read_line_in->$2 and stick it in $6
; if we're here, then we need to rexecute the copy after executing the command line
push "$1\$4" ; push the file and path onto the stack.
push $6 ; push the callback value onto the stack,
Call ResolveFunction ; call the resolveFunction Call.
clearerrors
CopyFiles /SILENT "$1\$4" "$5\$4"
iferrors 0 SRS_RESTORE_ReadLine
; if still an error, then notify and try next line.
; MessageBox MB_OK "Error in rolling back file: $1\$4 to $5\$4"
Goto SRS_RESTORE_ReadLine
; ok, either we parsed the file, or we quit with errors... either way. clean the stack....
SRS_DONE: ; done with readling lines from the file.
Delete "$1\SRS_TempFile.txt"
FileClose $SRS_Rollback_FileHandle
; Now parse the file name
pop $R4
pop $R3
pop $R2
pop $R1
pop $7
pop $6
pop $5
pop $4
pop $3
pop $2 ;restore $2
pop $1 ;restore $1
pop $0 ; restore $0 to previous value....
return ; end
FunctionEnd
;!macro moveRollbackArchive _ExistingPath _ExistingLogFile _NewPath
; ifFileExists "${_ExistingPath}" 0 +2
; Delete "${_ExistingPath}\*.*"
; RMDir "${_ExistingPath}"
; rename "${_ExistingPath}\*.*" "${_NewPath}\*.*"
; Push "${_ExistingPath}" #text to be replaced
; Push "${_NewPath}" #replace with
; Push 0 #replace command
; Push 1 #replace but only one occurance.. not all close network references....
; Push "${_NewPath}\${_ExistingLogFile}" #file to replace in
; Call AdvReplaceInFile ;; it reads the pushed variables as parameters.... ( Hey... I didn't design that interface... its confusing. )
;
;!macroend
!macro un.RollBackTo _rollbackLocalPath _rollbackLogName
push `${_rollbackLocalPath}`
push `${_rollbackLogName}`
Call un.RollBack
!macroend
!define un.RollBackTo "!insertmacro un.RollBackTo"
Function un.RollBack
push $0 ; save register 0 on stack. ( So stack looks like $0 "_rollbackLogName" _rollbackLocalPath Rest of Stack.....
Exch ; swap the top two objects on the stack.... _rollbackLogName $0 _rollbackLocalPath
pop $0 ; stack looks like $0.._rollbackLocalPath ...Rest of Stack.... Using $0 to hld the RollBackLogName
push $1 ; stack looks like $1 $0.._rollbackLocalPath Rest of Stack Use this var for handling readlines.
Exch 2 ; stack looks like _rollbackLocalPath $0 $1 Rest of Stack
pop $1 ; Use this var for handling the local path of the list of archived files.
Exch ; stack looks like $1 $0 Rest of Stack
push $2 ; stack look like $2 $1 $0 Rest of stack. Use $2 to hold read lines.....
push $3 ; stack looks like $3 $2 $1 $0 RestofStack. Use this var for handling tag parsing of lines....
push $4 ; saving $4 too... use this var for holding filename of file.
push $5 ; saving $5 too... use this var for holding target path.
push $6 ; use this var for the command line to exeute if failed to copy....
push $7 ; use this var for temp file handle
; registry temp vars....
push $R1 ; protect this and use for the Root of the registry handles...
push $R2 ; protect this and use for the Key
push $R3 ; protect this and use for the subkey
push $R4 ; protected this and use for the Value.....
ifFileExists "$1\$0" StartRollBack 0
SetErrors
MessageBox MB_OK "Unable to find rollback file for uninstall: $1\$0"
Goto SRS_DONE
Return ; perhaps the user just gave the file folder.... try to locate the .rllbck file in the folder.... if it exists.
StartRollBack:
clearerrors
FileOpen $SRS_Rollback_FileHandle "$1\$0" r ; open file for read.
IfErrors 0 SRS_RESTORE_ReadLine
MessageBox MB_OK "Error opening the file for rollback: $1\$0"
Goto SRS_DONE
SRS_RESTORE_ReadLine:
ClearErrors
FileRead $SRS_Rollback_FileHandle $2 ; get line for parsing.
;MessageBox MB_OK $2
IfErrors SRS_DONE ; if errors, then EOF. Cleanup stack and exit.
; otherise parse line.
StrCpy $3 $2 6 ;if this line is a file line, then the first six chars should be <FILE>
;Handle Registry Alterations:
StrCmp $3 "<REGIS" 0 SRS_RESTORE_TestForFileLine
FileOpen $7 "$1\SRS_TempFile.txt" w
FileWrite $7 $2
FileClose $7
;<FILE><NEW>1</NEW><NAME>${_someFileName}</NAME><TARGETPATH>$OUTDIR</TARGETPATH><ONFAIL>${_onFailCommand}</ONFAIL></FILE>
;<REGISTRY><NEW>1</NEW><ROOT>${_RootKey}</ROOT><KEY>${_RegistryKey}</KEY><SUBKEY>${_SubKey}</SUBKEY><VALUE>${_Value}</VALUE></REGISTRY>
#MessageBox MB_OK "$2"
; Because GetBetween only uses files as sources.... ( stupid, that I'm using that here, but I am.... )
${un.GetBetween} "<NEW>" "</NEW>" "$1\SRS_TempFile.txt" $4 ; Get the file name between the file tags of the read_line_in->$2 and stick it in $4
#MessageBox MB_OK $4
${un.GetBetween} "<ROOT>" "</ROOT>" "$1\SRS_TempFile.txt" $R1 ; Get the file name between the file tags of the read_line_in->$2 and stick it in $4
#MessageBox MB_OK "$R1,$R2,$R3,$R4"
${un.GetBetween} "<KEY>" "</KEY>" "$1\SRS_TempFile.txt" $R2 ; Get the file name between the file tags of the read_line_in->$2 and stick it in $4
#MessageBox MB_OK "$R1,$R2,$R3,$R4"
${un.GetBetween} "<SUBKEY>" "</SUBKEY>" "$1\SRS_TempFile.txt" $R3 ; Get the file name between the file tags of the read_line_in->$2 and stick it in $4
#MessageBox MB_OK "$R1,$R2,$R3,$R4"
${un.GetBetween} "<VALUE>" "</VALUE>" "$1\SRS_TempFile.txt" $R4 ; Get the file name between the file tags of the read_line_in->$2 and stick it in $4
#MessageBox MB_OK "$R1,$R2,$R3,$R4"
#MessageBox MB_OK "$1, $4 , $R1 , $R2 , $R3 , $R4"
StrCmp $4 "SRS_RollbackPath" RemoveIt 0
StrCmp $4 "SRS_Logname" RemoveIt 0
StrCmp $4 "1" 0 SRS_RESTORE_WRITE ; if the new marker is set to 1 then a rollback means remove it entirely.....
RemoveIt:
${Switch} $R1
${Case} "HKLM"
DeleteRegValue HKLM $R2 $R3 ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKCR"
DeleteRegValue HKCR $R2 $R3 ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKCU"
DeleteRegValue HKCU $R2 $R3 ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKU"
DeleteRegValue HKU $R2 $R3 ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKCC"
DeleteRegValue HKCC $R2 $R3 ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKDD"
DeleteRegValue HKDD $R2 $R3 ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "HKPD"
DeleteRegValue HKPD $R2 $R3 ;$R1 $R2 $R3Goto EndSNFServiceTest
${Case} "SHCTX"
DeleteRegValue SHCTX $R2 $R3 ;$R1 $R2 $R3Goto EndSNFServiceTest
${EndSwitch}
Goto SRS_RESTORE_ReadLine
SRS_RESTORE_WRITE:
; if not then we need to restore the key.....
${Switch} $R1
${Case} "HKLM"
WriteRegStr HKLM $R2 $R3 $R4
${Case} "HKCR"
WriteRegStr HKCR $R2 $R3 $R4
${Case} "HKCU"
WriteRegStr HKCU $R2 $R3 $R4
${Case} "HKU"
WriteRegStr HKU $R2 $R3 $R4
${Case} "HKCC"
WriteRegStr HKCC $R2 $R3 $R4
${Case} "HKDD"
WriteRegStr HKDD $R2 $R3 $R4
${Case} "HKPD"
WriteRegStr HKPD $R2 $R3 $R4
${Case} "SHCTX"
WriteRegStr SHCTX $R2 $R3 $R4
${EndSwitch}
Goto SRS_RESTORE_ReadLine
SRS_RESTORE_TestForFileLine:
StrCmp $3 "<FILE>" 0 SRS_RESTORE_ReadLine ; if its a file, then handle rolling back the file, otherwise get the next line.
FileOpen $7 "$1\SRS_TempFile.txt" w
FileWrite $7 $2
FileClose $7
; Because GetBetween only uses files as sources.... ( stupid, that I'm using that here, but I am.... )
${un.GetBetween} "<NAME>" "</NAME>" "$1\SRS_TempFile.txt" $4 ; Get the file name between the file tags of the read_line_in->$2 and stick it in $4
${un.GetBetween} "<NEW>" "</NEW>" "$1\SRS_TempFile.txt" $R1 ; Get the marker that informed us if there WAS something to be copied, or if it was just installed.
;MessageBox MB_OK "Name:$4"
${un.GetBetween} "<TARGETPATH>" "</TARGETPATH>" "$1\SRS_TempFile.txt" $5 ; Get the targetpath between the file tags of the read_line_in->$2 and stick it in $5
;MessageBox MB_OK "Target:$5"
clearerrors
${un.GetBetween} "<CALLBACK>" "</CALLBACK>" "$1\SRS_TempFile.txt" $6 ; Get the CALLBACK name between the file tags of the read_line_in->$2 and stick it in $6
iferrors NoCallbackAvailable 0
StrCmp $6 "" NoCallbackAvailable 0
; Ok, we have a callback, so we don't copy, we call file, and pass the filename.
;MessageBox MB_OK "Pushing $1\$4"
push "$1\$4" ; push the file and path onto the stack.
push $6 ; push the calback value onto the stack,
Call un.ResolveFunction ; call the resolveFunction Call.
Goto SRS_RESTORE_ReadLine ; No copy, just return for next line handle.
NoCallbackAvailable:
; now deal with new vs archived files...
StrCmp $R1 "1" 0 SRS_NOTNEW_RESTOREIT ; test to see if it was new, or if it required backin gup...
ifFileExists "$5\$4" 0 SRS_RESTORE_ReadLine ; if it WAS new... test to see if file still exists...
Delete "$5\$4" ; Since it was new we'll remove it on a restore....
Goto SRS_RESTORE_ReadLine
SRS_NOTNEW_RESTOREIT:
CopyFiles /SILENT "$1\$4" "$5\$4"
iferrors 0 SRS_RESTORE_ReadLine
clearerrors
${un.GetBetween} "<ONFAIL>" "</ONFAIL>" "$1\SRS_TempFile.txt" $6 ; Get the onfail name between the file tags of the read_line_in->$2 and stick it in $6
; if we're here, then we need to rexecute the copy after executing the command line
push "$1\$4" ; push the file and path onto the stack.
push $6 ; push the callback value onto the stack,
Call un.ResolveFunction ; call the resolveFunction Call.
clearerrors
CopyFiles /SILENT "$1\$4" "$5\$4"
iferrors 0 SRS_RESTORE_ReadLine
; if still an error, then notify and try next line.
; MessageBox MB_OK "Error in rolling back file: $1\$4 to $5\$4"
Goto SRS_RESTORE_ReadLine
; ok, either we parsed the file, or we quit with errors... either way. clean the stack....
SRS_DONE: ; done with readling lines from the file.
Delete "$1\SRS_TempFile.txt"
FileClose $SRS_Rollback_FileHandle
; Now parse the file name
pop $R4
pop $R3
pop $R2
pop $R1
pop $7
pop $6
pop $5
pop $4
pop $3
pop $2 ;restore $2
pop $1 ;restore $1
pop $0 ; restore $0 to previous value....
return ; end
FunctionEnd

BIN
build/Restorer.exe View File


BIN
build/SNFServer.exe View File


BIN
build/SNFServerV3.1.2-E3.1.4.exe View File


BIN
build/SNF_CS_Installer.exe View File


Write Preview
Loading…
Cancel
Save