itigoptions.pas

autoupdate 1.02 source code

unit itigoptions;

interface

uses PostFile, Classes, wininet;

const
   DEFAULT_PORT = 0;
   SERVER = 'itig.it.swin.edu.au';

const SU_NO_CONNECTION = 'There is no connection available. Please connect to the internet and try again.';


const REG_APP = 'itig\autoupdate';
const REG_SERVER = 'HostName';
const REG_LAN = 'LAN';
const REG_ALWAYS_DIALUP = 'ADU';
const REG_LOW_SEC = 'unknownCA';

const REG_PR_USE_IE = 'prIE';
const REG_PR_ADDR = 'prAddr';
const REG_PR_PORT = 'prPort';
const REG_PR_LOGIN = 'prLogin';
const REG_PR_USER = 'prUser';
const REG_PR_HPASS = 'prHPass';
const REG_PR_PASS = 'prPass';

const REG_UID_PWD_PRE = 'pw_';
const REG_UID_SEC_PRE = 'sc_';
const REG_UID_SEC_1_PRE = 'scu_';

const PRKN_TIME_EST = 'Estimated time remaining ';

type
   TNoRefInterface = class(TObject, IUnknown)
    function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
    function _AddRef: Integer; stdcall;
    function _Release: Integer; stdcall;
   end;

   TGetProxyFunction = procedure(var AlwaysConnected : Boolean;
                                 var AlwaysConnect : Boolean;
                                 var UsingIESettings : Boolean;
                                 var ProxyAddress : String;
                                 var ProxyPort : Integer;
                                 var UsingProxyLogin : Boolean;
                                 var ProxyUsername : String;
                                 var UsingProxyPassword : Boolean;
                                 var ProxyPassword : String ) of object;


   TItigOptions = class(TNoRefInterface, IPostFileOptions)
   private

      //Internet Options
      ivAlwaysConnected: Boolean;
      ivAlwaysConnect: Boolean;
      ivUsingIESettings: Boolean;
      ivProxyAddress: String;
      ivProxyPort: Integer;
      ivUsingProxyLogin: Boolean;
      ivProxyPasswordNeeded: Boolean;
      ivProxyUsername: String;
      ivProxyPassword: String;

      ivHangup: Boolean;

      ivSSLStrength: String;

      Internet : HINTERNET;
   public

      HttpServerName : String;
      HttpServerPort : Integer;
      HttpServerSecure : Boolean;
      HttpServerSecureDebug : Boolean;
      HttpConnectUploadScript : String;
      HttpConnectDownloadScript : String;
      HttpScriptName : String;
      LowSecurity : Boolean;

      ServerVersion : Integer;
      ApplicationName : String;
      CurrentVersion : String;
      VersionNumber : Integer;
      Readme : String;

      Available : Boolean;
      DownloadedFile : String;
      GetProxyMethod : TGetProxyFunction;

      constructor Create;
      procedure SetURL(URL : String);

      // IPostFileOptions
      function GetUserAgent : String;
      function GetHostName : String;
      function GetPortNumber : Integer;
      function GetHttps : Boolean;
      function GetAllowWrongProperName : Boolean;
      function GetAllowExpiredCertificate : Boolean;
      function GetAllowUnknownCA : Boolean;

      //
      function GetTempPath : String;
      function GetScriptName : String;

      //Save Procedures

      procedure LoadInternet;
      procedure SaveInternet;

      //Internet Settings
      function isAlwaysConnected: Boolean;
      procedure setAlwaysConnected(b: Boolean);
      property AlwaysConnected: Boolean read isAlwaysConnected write setAlwaysConnected;

      function hasAlwaysConnect: Boolean;
      procedure setAlwaysConnect(b:Boolean);
      property AlwaysConnect: Boolean read hasAlwaysConnect write setAlwaysConnect;

      function isUsingIESettings: Boolean;
      procedure setUsingIESettings(b:boolean);
      property UsingIESettings: Boolean read isUsingIESettings write setUsingIESettings;

      function getProxyAddress: String;
      procedure setProxyAddress(pa: String);
      property ProxyAddress: String read getProxyAddress write SetProxyAddress;

      function GetProxyPort: Integer;
      procedure SetProxyPort(pp: Integer);
      property ProxyPort: Integer read GetProxyPort write SetProxyPort;

      function isUsingProxyLogin: Boolean;
      procedure setUsingProxyLogin(b:boolean);
      property UsingProxyLogin: Boolean read isUsingProxyLogin write setUsingProxyLogin;

      function isProxyPasswordNeeded: Boolean;
      procedure setProxyPasswordNeeded(b:boolean);
      property UsingProxyPassword: boolean read isProxyPasswordNeeded write setProxyPasswordNeeded;

      function getProxyUsername: String;
      procedure setProxyUsername(pu: String);
      property ProxyUsername: String read getProxyUserName write SetProxyUsername;

      function getProxyPassword: String;
      procedure setProxyPassword(pp: String);
      property ProxyPassword: String read getProxyPassword write SetProxyPassword;

      procedure setHangup(b: Boolean);
      function isHangup: Boolean;
      property Hangup: Boolean read isHangup write setHangup;

      Property SSLStrength: String Read ivSSLStrength Write ivSSLStrength;
      procedure setSSLStrength(Strength : Integer);

      function GetInternetHandle : HINTERNET;
      procedure SetInternetHandle(h : HINTERNET);

   end;

implementation

uses Windows, URegEdit, Forms, SysUtils;

function TNoRefInterface.QueryInterface(const IID: TGUID; out Obj): HResult;
const
  E_NOINTERFACE = HResult($80004002);
begin
  if GetInterface(IID, Obj) then Result := 0 else Result := E_NOINTERFACE;
end;

function TNoRefInterface._AddRef: Integer; stdcall;
begin
   Result := 1;
end;

function TNoRefInterface._Release: Integer; stdcall;
begin
   Result := 1;
end;


constructor TItigOptions.Create;
var
   Prefix : String;
begin

   HttpServerName := SERVER;
   HttpServerPort := DEFAULT_PORT;
   HttpServerSecure := False;
   HttpServerSecureDebug := True;
   LowSecurity := False;

   //Prefix := '/~jn/server/';
   Prefix := '/~itig/';
   HttpScriptName := Prefix + 'autoupdate.php';

   SSLStrength := 'Unknown';

   LoadInternet;

   Internet := nil;
end;

function TItigOptions.GetUserAgent : String;
begin
   Result := 'ITIG AutoUpgrade Agent (MSIE)';
end;


function TItigOptions.GetPortNumber : Integer;
begin
   if HttpServerPort = DEFAULT_PORT then
   begin
      if HttpServerSecure then
      begin
         Result := INTERNET_DEFAULT_HTTPS_PORT;
      end
      else
      begin
         Result := INTERNET_DEFAULT_HTTP_PORT;
      end;
   end
   else
   begin
      Result := HttpServerPort;
   end;
end;

function TItigOptions.GetHostName : String;
begin
   Result := HttpServerName;
end;

function TItigOptions.GetHttps : Boolean;
begin
   Result := HttpServerSecure;
end;

function TItigOptions.GetAllowWrongProperName : Boolean;
begin
   Result := HttpServerSecureDebug;
end;

function TItigOptions.GetAllowExpiredCertificate : Boolean;
begin
   Result := HttpServerSecureDebug;
end;

function TItigOptions.GetAllowUnknownCA : Boolean;
begin
   Result := LowSecurity;
end;

// this could check the available free space and pick another
// disk if necessary.
function TItigOptions.GetTempPath : String;
var
   L : Integer;
begin
   L := 256;
   SetLength(Result, L);
   L := Windows.GetTempPath(L, PChar(Result));
   SetLength(Result, L);
end;

function TItigOptions.GetScriptName : String;
begin
   Result := HttpScriptName;
end;

procedure TItigOptions.setSSLStrength(Strength : Integer);
begin
   if (Strength and SECURITY_FLAG_STRENGTH_STRONG) = SECURITY_FLAG_STRENGTH_STRONG then
   begin
      SSLStrength := '128 bit';
   end
   else if (Strength and SECURITY_FLAG_STRENGTH_MEDIUM) = SECURITY_FLAG_STRENGTH_MEDIUM then
   begin
      SSLStrength := '56 bit';
   end
   else if (Strength and SECURITY_FLAG_STRENGTH_WEAK) = SECURITY_FLAG_STRENGTH_WEAK then
   begin
      SSLSTrength := '40 bit';
   end
   else
   begin
      SSLStrength := 'Unknown';
   end;
end;

function TItigOptions.isAlwaysConnected: Boolean;
begin
   Result := ivAlwaysConnected;
end;

procedure TItigOptions.setAlwaysConnected(b: Boolean);
begin
   ivAlwaysConnected := b;
end;

function TItigOptions.hasAlwaysConnect: Boolean;
begin
   Result := ivAlwaysConnect;
end;

procedure TItigOptions.setAlwaysConnect(b:Boolean);
begin
   ivAlwaysConnect := b;
end;

function TItigOptions.isUsingIESettings: Boolean;
begin
   Result := ivUsingIESettings;
end;

procedure TItigOptions.setUsingIESettings(b:boolean);
begin
   ivUsingIESettings := b;
end;

function TItigOptions.GetProxyAddress: String;
begin
   Result := ivProxyAddress;
end;

procedure TItigOptions.SetProxyAddress(pa: String);
begin
   ivProxyAddress := pa;
end;

function TItigOptions.GetProxyPort: Integer;
begin
   Result := ivProxyPort;
end;

procedure TItigOptions.SetProxyPort(pp :Integer);
begin
   ivProxyPort := pp;
end;


function TItigOptions.isUsingProxyLogin: Boolean;
begin
   Result := ivUsingProxyLogin;
end;

procedure TItigOptions.setUsingProxyLogin(b:boolean);
begin
   ivUsingProxyLogin := b;
end;

function TItigOptions.isProxyPasswordNeeded: Boolean;
begin
   Result := ivProxyPasswordNeeded;
end;

procedure TItigOptions.setProxyPasswordNeeded(b:boolean);
begin
   ivProxyPasswordNeeded := b;
end;

function TItigOptions.getProxyUsername: String;
begin
   Result := ivProxyUSername;
end;

procedure TItigOptions.SetProxyUsername(pu: String);
begin
   ivProxyUsername := pu;
end;

function TItigOptions.getProxyPassword: String;
begin
   result := ivProxyPassword;
end;

procedure TItigOptions.SetProxyPassword(pp: String);
begin
   ivProxyPassword := pp;
end;

procedure TItigOptions.SaveInternet;
var
   reg: TRegEdit;
begin
   reg := TRegEdit.Create;

   try
      reg.AppName := REG_APP;

      //Internet Settings
      reg.WriteSetting(REG_SERVER, GetHostName);
      reg.WriteSetting(REG_LAN, AlwaysConnected);
      reg.WriteSetting(REG_ALWAYS_DIALUP, AlwaysConnect);

      //Proxy Settings
      reg.WriteSetting(REG_PR_USE_IE, UsingIESettings);
      reg.WriteSetting(REG_PR_ADDR, ProxyAddress);
      reg.WriteSetting(REG_PR_PORT, ProxyPort);
      reg.WriteSetting(REG_PR_LOGIN, UsingProxyLogin);
      reg.WriteSetting(REG_PR_USER, ProxyUsername);
      reg.WriteSetting(REG_PR_HPASS, UsingProxyPassword);
      reg.WriteSetting(REG_PR_PASS, ProxyPassword);

      reg.WriteSetting(REG_LOW_SEC, LowSecurity);
   finally
      reg.Free;
   end;
end;

procedure TItigOptions.LoadInternet;
var
   reg: TRegEdit;
begin

   reg := TRegEdit.Create;
   try
      reg.AppName := REG_APP;

      //Internet Settings
//      HttpServerName   := reg.ReadString(REG_SERVER, SERVER);
      AlwaysConnected  := reg.ReadBoolean(REG_LAN, False);
      AlwaysConnect    := reg.ReadBoolean(REG_ALWAYS_DIALUP, False);

      //Proxy Settings
      UsingIESettings    := reg.ReadBoolean(REG_PR_USE_IE, True );
      ProxyAddress       := reg.ReadString(REG_PR_ADDR, '' );
      ProxyPort          := reg.ReadInteger(REG_PR_PORT, 0 );
      UsingProxyLogin    := reg.ReadBoolean(REG_PR_LOGIN, False );
      ProxyUsername      := reg.ReadString(REG_PR_USER, '' );
      UsingProxyPassword := reg.ReadBoolean(REG_PR_HPASS, False );
      ProxyPassword      := reg.ReadString(REG_PR_PASS, '' );

      LowSecurity := True;

      if Assigned(GetProxyMethod) then
      begin
         GetProxyMethod(ivAlwaysConnected,
                        ivAlwaysConnect,
                        ivUsingIESettings,
                        ivProxyAddress,
                        ivProxyPort,
                        ivUsingProxyLogin,
                        ivProxyUsername,
                        ivProxyPasswordNeeded,
                        ivProxyPassword);
      end;
   finally
      reg.Free;
   end;
end;

procedure TItigOptions.setHangup(b: Boolean);
begin
   ivHangup := b;
end;

function TItigOptions.isHangup: Boolean;
begin
   Result := ivHangup;
end;

function TItigOptions.GetInternetHandle : HINTERNET;
begin
   Result := Internet;
end;

procedure TItigOptions.SetInternetHandle(h : HINTERNET);
begin
   Internet := h;
end;

procedure TItigOptions.SetURL(URL : String);
var
   p : Integer;
   p2 : Integer;
begin
   // chop up the url and work out the
   // protocol (http or https)
   // the hostname
   // the port number (optional)
   // the location
   // <protocol>://<hostname>[:<port>]/<location>

   if Pos('https://', URL) = 1 then
   begin
      HttpServerSecure := True;
      Delete(URL, 1, 8);
      HttpServerPort := DEFAULT_PORT;
   end
   else if Pos('http://', URL) = 1 then
   begin
      HttpServerSecure := False;
      Delete(URL, 1, 7);
      HttpServerPort := DEFAULT_PORT;
   end
   else
   begin
      // error
      exit;
   end;

   p := Pos('/', URL);
   p2 := Pos(':', URL);
   if (p2 > 0) and (p > p2) then
   begin
      // get the port number
      HttpServerName := Copy(URL, 1, p2 - 1);
      Delete(URL, 1, p2);
      p := Pos('/', URL);
      HttpServerPort := StrToIntDef(Copy(URL, 1, p - 1), HttpServerPort);
      Delete(URL, 1, p - 1);
   end
   else
   begin
      // just get the host name
      HttpServerName := Copy(URL, 1, p - 1);
      Delete(URL, 1, p - 1);
   end;

   HttpScriptName := URL;
end;


end.