ViewVC Help
View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing
root/public/ibx/trunk/runtime/IBServices.pas
(Generate patch)

Comparing ibx/trunk/runtime/IBServices.pas (file contents):
Revision 43 by tony, Thu Sep 22 17:10:15 2016 UTC vs.
Revision 45 by tony, Tue Dec 6 10:33:46 2016 UTC

# Line 42 | Line 42
42   unit IBServices;
43  
44   {$Mode Delphi}
45 {$IF FPC_FULLVERSION >= 20700 }
45   {$codepage UTF8}
47 {$ENDIF}
46  
47   interface
48  
# Line 54 | Line 52 | uses
52   {$ELSE}
53    unix,
54   {$ENDIF}
55 <  SysUtils, Classes, IBHeader, IB, IBExternals, CustApp;
55 >  SysUtils, Classes, IBHeader, IB, IBExternals, CustApp, IBTypes, IBSQL;
56  
57   const
58    DefaultBufferSize = 32000;
59  
60    SPBPrefix = 'isc_spb_';
61 +  isc_spb_last_spb_constant = 12;
62    SPBConstantNames: array[1..isc_spb_last_spb_constant] of String = (
63      'user_name',
64      'sys_user_name',
# Line 76 | Line 75 | const
75    );
76  
77    SPBConstantValues: array[1..isc_spb_last_spb_constant] of Integer = (
78 <    isc_spb_user_name_mapped_to_server,
79 <    isc_spb_sys_user_name_mapped_to_server,
80 <    isc_spb_sys_user_name_enc_mapped_to_server,
81 <    isc_spb_password_mapped_to_server,
82 <    isc_spb_password_enc_mapped_to_server,
83 <    isc_spb_command_line_mapped_to_server,
84 <    isc_spb_dbname_mapped_to_server,
85 <    isc_spb_verbose_mapped_to_server,
86 <    isc_spb_options_mapped_to_server,
87 <    isc_spb_connect_timeout_mapped_to_server,
88 <    isc_spb_dummy_packet_interval_mapped_to_server,
89 <    isc_spb_sql_role_name_mapped_to_server
78 >    isc_spb_user_name,
79 >    isc_spb_sys_user_name,
80 >    isc_spb_sys_user_name_enc,
81 >    isc_spb_password,
82 >    isc_spb_password_enc,
83 >    isc_spb_command_line,
84 >    isc_spb_dbname,
85 >    isc_spb_verbose,
86 >    isc_spb_options,
87 >    isc_spb_connect_timeout,
88 >    isc_spb_dummy_packet_interval,
89 >    isc_spb_sql_role_name
90    );
91  
92   type
94  TProtocol = (TCP, SPX, NamedPipe, Local);
93    TOutputBufferOption = (ByLine, ByChunk);
94  
95    TIBCustomService = class;
# Line 103 | Line 101 | type
101  
102    TIBCustomService = class(TComponent)
103    private
106    FIBLoaded: Boolean;
104      FParamsChanged : Boolean;
105 <    FSPB, FQuerySPB : PChar;
106 <    FSPBLength, FQuerySPBLength : Short;
105 >    FQueryParams: String;
106 >    FSPB : ISPB;
107 >    FSRB: ISRB;
108 >    FSQPB: ISQPB;
109      FTraceFlags: TTraceFlags;
110      FOnLogin: TLoginEvent;
111      FLoginPrompt: Boolean;
113    FBufferSize: Integer;
114    FOutputBuffer: PChar;
115    FQueryParams: String;
112      FServerName: string;
113 <    FHandle: TISC_SVC_HANDLE;
113 >    FService: IServiceManager;
114      FStreamedActive  : Boolean;
115      FOnAttach: TNotifyEvent;
116      FOutputBufferOption: TOutputBufferOption;
117      FProtocol: TProtocol;
118      FParams: TStrings;
119 +    FServiceQueryResults: IServiceQueryResults;
120      function GetActive: Boolean;
121      function GetServiceParamBySPB(const Idx: Integer): String;
122 +    function GetSQPB: ISQPB;
123 +    function GetSRB: ISRB;
124      procedure SetActive(const Value: Boolean);
126    procedure SetBufferSize(const Value: Integer);
125      procedure SetParams(const Value: TStrings);
126      procedure SetServerName(const Value: string);
127      procedure SetProtocol(const Value: TProtocol);
128 +    procedure SetService(AValue: IServiceManager);
129      procedure SetServiceParamBySPB(const Idx: Integer;
130        const Value: String);
131 <    function IndexOfSPBConst(st: String): Integer;
131 >    function IndexOfSPBConst(action: byte): Integer;
132 >    function GetSPBConstName(action: byte): string;
133      procedure ParamsChange(Sender: TObject);
134      procedure ParamsChanging(Sender: TObject);
135      procedure CheckServerName;
136 <    function Call(ErrCode: ISC_STATUS; RaiseError: Boolean): ISC_STATUS;
137 <    function ParseString(var RunLen: Integer): string;
138 <    function ParseInteger(var RunLen: Integer): Integer;
139 <    procedure GenerateSPB(sl: TStrings; var SPB: String; var SPBLength: Short);
136 >    function GenerateSPB(sl: TStrings): ISPB;
137  
138    protected
139      procedure Loaded; override;
# Line 144 | Line 141 | type
141      procedure CheckActive;
142      procedure CheckInactive;
143      procedure HandleException(Sender: TObject);
147    property OutputBuffer : PChar read FOutputBuffer;
148    property OutputBufferOption : TOutputBufferOption read FOutputBufferOption write FOutputBufferOption;
149    property BufferSize : Integer read FBufferSize write SetBufferSize default DefaultBufferSize;
144      procedure InternalServiceQuery;
145 <    property ServiceQueryParams: String read FQueryParams write FQueryParams;
145 >    property SRB: ISRB read GetSRB;
146 >    property SQPB: ISQPB read GetSQPB;
147 >    property ServiceQueryResults: IServiceQueryResults read FServiceQueryResults;
148  
149    public
150      constructor Create(AOwner: TComponent); override;
151      destructor Destroy; override;
152      procedure Attach;
153      procedure Detach;
154 <    property Handle: TISC_SVC_HANDLE read FHandle;
154 >    property ServiceIntf: IServiceManager read FService write SetService;
155      property ServiceParamBySPB[const Idx: Integer]: String read GetServiceParamBySPB
156                                                        write SetServiceParamBySPB;
157    published
# Line 231 | Line 227 | type
227      FLicenseMaskInfo: TLicenseMaskInfo;
228      FVersionInfo: TVersionInfo;
229      FConfigParams: TConfigParams;
234    procedure ParseConfigFileData(var RunLen: Integer);
230    public
231      constructor Create(AOwner: TComponent); override;
232      destructor Destroy; override;
# Line 250 | Line 245 | type
245      property Options : TPropertyOptions read FOptions write FOptions;
246    end;
247  
248 +  { TIBControlService }
249 +
250    TIBControlService = class (TIBCustomService)
251    private
255    FStartParams: String;
256    FStartSPB: PChar;
257    FStartSPBLength: Integer;
252      function GetIsServiceRunning: Boolean;
253    protected
254 <    property ServiceStartParams: String read FStartParams write FStartParams;
261 <    procedure SetServiceStartOptions; virtual;
262 <    procedure ServiceStartAddParam (Value: string; param: Integer); overload;
263 <    procedure ServiceStartAddParam (Value: Integer; param: Integer); overload;
254 >    procedure CheckServiceNotRunning;
255      procedure InternalServiceStart;
256 +    procedure SetServiceStartOptions; virtual;
257  
258    public
259      constructor Create(AOwner: TComponent); override;
# Line 269 | Line 261 | type
261      property IsServiceRunning : Boolean read GetIsServiceRunning;
262    end;
263  
264 +  { TIBControlAndQueryService }
265 +
266    TIBControlAndQueryService = class (TIBControlService)
267    private
268      FEof: Boolean;
# Line 280 | Line 274 | type
274      constructor create (AOwner: TComponent); override;
275      function GetNextLine : String;
276      function GetNextChunk : String;
277 +    function WriteNextChunk(stream: TStream): integer;
278      property Eof: boolean read FEof;
284  published
285    property BufferSize;
279    end;
280  
281    TShutdownMode = (Forced, DenyTransaction, DenyAttachment);
# Line 333 | Line 326 | type
326      property Options :  TStatOptions read FOptions write FOptions;
327    end;
328  
329 +  TBackupLocation = (flServerSide,flClientSide);
330 +
331 +  { TIBBackupRestoreService }
332  
333    TIBBackupRestoreService = class(TIBControlAndQueryService)
334    private
335 +    FBackupFileLocation: TBackupLocation;
336      FVerbose: Boolean;
337    protected
338    public
339 +    constructor Create(AOwner: TComponent); override;
340    published
341      property Verbose : Boolean read FVerbose write FVerbose default False;
342 +    property BackupFileLocation: TBackupLocation read FBackupFileLocation
343 +                                                      write FBackupFileLocation default flServerSide;
344    end;
345  
346    TBackupOption = (IgnoreChecksums, IgnoreLimbo, MetadataOnly, NoGarbageCollection,
# Line 372 | Line 372 | type
372      Replace, CreateNewDB, UseAllSpace);
373  
374    TRestoreOptions = set of TRestoreOption;
375 +
376 +  { TIBRestoreService }
377 +
378    TIBRestoreService = class (TIBBackupRestoreService)
379    private
380      FDatabaseName: TStrings;
# Line 379 | Line 382 | type
382      FOptions: TRestoreOptions;
383      FPageSize: Integer;
384      FPageBuffers: Integer;
385 +    FSendBytes: integer;
386      procedure SetBackupFile(const Value: TStrings);
387      procedure SetDatabaseName(const Value: TStrings);
388    protected
# Line 386 | Line 390 | type
390    public
391      constructor Create(AOwner: TComponent); override;
392      destructor Destroy; override;
393 +    function SendNextChunk(stream: TStream; var line: String): integer;
394    published
395      { a name=value pair of filename and length }
396      property DatabaseName: TStrings read FDatabaseName write SetDatabaseName;
# Line 516 | Line 521 | type
521   implementation
522  
523   uses
524 <  IBIntf , IBSQLMonitor, Math;
524 >  IBSQLMonitor, Math, FBMessages;
525 >
526 > { TIBBackupRestoreService }
527 >
528 > constructor TIBBackupRestoreService.Create(AOwner: TComponent);
529 > begin
530 >  inherited Create(AOwner);
531 >  FBackupFileLocation := flServerSide;
532 > end;
533  
534   { TIBCustomService }
535  
536   procedure TIBCustomService.Attach;
537 < var
525 <  SPB: String;
526 <  ConnectString: String;
527 <  aServerName: string;
537 > var aServerName: string;
538   begin
539    CheckInactive;
540    CheckServerName;
541  
542    aServerName := FServerName;
543 +
544    if FLoginPrompt and not Login(aServerName) then
545      IBError(ibxeOperationCancelled, [nil]);
546  
# Line 537 | Line 548 | begin
548    if FParamsChanged then
549    begin
550      FParamsChanged := False;
551 <    GenerateSPB(FParams, SPB, FSPBLength);
541 <    IBAlloc(FSPB, 0, FsPBLength);
542 <    Move(SPB[1], FSPB[0], FSPBLength);
543 <  end;
544 <  case FProtocol of
545 <    TCP: ConnectString := aServerName + ':service_mgr'; {do not localize}
546 <    SPX: ConnectString := aServerName + '@service_mgr'; {do not localize}
547 <    NamedPipe: ConnectString := '\\' + aServerName + '\service_mgr'; {do not localize}
548 <    Local: ConnectString := 'service_mgr'; {do not localize}
549 <  end;
550 <  if call(isc_service_attach(StatusVector, Length(ConnectString),
551 <                         PChar(ConnectString), @FHandle,
552 <                         FSPBLength, FSPB), False) > 0 then
553 <  begin
554 <    FHandle := nil;
555 <    IBDataBaseError;
551 >    FSPB := GenerateSPB(FParams);
552    end;
553  
554 +  FService := FirebirdAPI.GetServiceManager(aServerName,FProtocol,FSPB);
555 +
556    if Assigned(FOnAttach) then
557      FOnAttach(Self);
558  
# Line 596 | Line 594 | begin
594    else
595    if assigned(IBGUIInterface)  then
596    begin
597 <    IndexOfUser := IndexOfSPBConst(SPBConstantNames[isc_spb_user_name]);
597 >    IndexOfUser := IndexOfSPBConst(isc_spb_user_name);
598      if IndexOfUser <> -1 then
599        Username := Copy(Params[IndexOfUser],
600                                           Pos('=', Params[IndexOfUser]) + 1, {mbcs ok}
601                                           Length(Params[IndexOfUser]));
602 <    IndexOfPassword := IndexOfSPBConst(SPBConstantNames[isc_spb_password]);
602 >    IndexOfPassword := IndexOfSPBConst(isc_spb_password);
603      if IndexOfPassword <> -1 then
604        Password := Copy(Params[IndexOfPassword],
605                                           Pos('=', Params[IndexOfPassword]) + 1, {mbcs ok}
# Line 609 | Line 607 | begin
607      result := IBGUIInterface.ServerLoginDialog(aServerName, Username, Password);
608      if result then
609      begin
610 <      IndexOfPassword := IndexOfSPBConst(SPBConstantNames[isc_spb_password]);
610 >      IndexOfPassword := IndexOfSPBConst(isc_spb_password);
611        if IndexOfUser = -1 then
612 <        Params.Add(SPBConstantNames[isc_spb_user_name] + '=' + Username)
612 >        Params.Add(GetSPBConstName(isc_spb_user_name) + '=' + Username)
613        else
614 <        Params[IndexOfUser] := SPBConstantNames[isc_spb_user_name] +
614 >        Params[IndexOfUser] := GetSPBConstName(isc_spb_user_name) +
615                                   '=' + Username;
616        if IndexOfPassword = -1 then
617 <        Params.Add(SPBConstantNames[isc_spb_password] + '=' + Password)
617 >        Params.Add(GetSPBConstName(isc_spb_password) + '=' + Password)
618        else
619 <        Params[IndexOfPassword] := SPBConstantNames[isc_spb_password] +
619 >        Params[IndexOfPassword] := GetSPBConstName(isc_spb_password) +
620                                       '=' + Password;
621      end
622    end
# Line 630 | Line 628 | procedure TIBCustomService.CheckActive;
628   begin
629    if FStreamedActive and (not Active) then
630      Loaded;
631 <  if FHandle = nil then
631 >  if FService = nil then
632      IBError(ibxeServiceActive, [nil]);
633   end;
634  
635   procedure TIBCustomService.CheckInactive;
636   begin
637 <  if FHandle <> nil then
637 >  if FService <> nil then
638      IBError(ibxeServiceInActive, [nil]);
639   end;
640  
# Line 659 | Line 657 | end;
657   constructor TIBCustomService.Create(AOwner: TComponent);
658   begin
659    inherited Create(AOwner);
662  FIBLoaded := False;
663  CheckIBLoaded;
664  FIBLoaded := True;
660    FserverName := '';
661    FParams := TStringList.Create;
662    FParamsChanged := True;
663    TStringList(FParams).OnChange := ParamsChange;
664    TStringList(FParams).OnChanging := ParamsChanging;
670  FSPB := nil;
671  FQuerySPB := nil;
672  FBufferSize := DefaultBufferSize;
673  FHandle := nil;
665    FLoginPrompt := True;
666    FTraceFlags := [];
667 <  FOutputbuffer := nil;
667 >  FService := nil;
668 >  FSRB := nil;
669 >  FSPB := nil;
670 >  FServiceQueryResults := nil;
671    FProtocol := Local;
672    if (AOwner <> nil) and
673       (AOwner is TCustomApplication) and
# Line 683 | Line 677 | end;
677  
678   destructor TIBCustomService.Destroy;
679   begin
680 <  if FIBLoaded then
687 <  begin
688 <    if FHandle <> nil then
680 >  if FService <> nil then
681        Detach;
682 <    FreeMem(FSPB);
683 <    FSPB := nil;
684 <    FParams.Free;
685 <  end;
694 <  ReallocMem(FOutputBuffer, 0);
682 >  FSRB := nil;
683 >  FSPB := nil;
684 >  FParams.Free;
685 >  FServiceQueryResults := nil;
686    inherited Destroy;
687   end;
688  
689   procedure TIBCustomService.Detach;
690   begin
691    CheckActive;
692 <  if (Call(isc_service_detach(StatusVector, @FHandle), False) > 0) then
693 <  begin
703 <    FHandle := nil;
704 <    IBDataBaseError;
705 <  end
706 <  else
707 <    FHandle := nil;
692 >  FService.Detach;
693 >  FService := nil;
694    MonitorHook.ServiceDetach(Self);
695   end;
696  
697   function TIBCustomService.GetActive: Boolean;
698   begin
699 <  result := FHandle <> nil;
699 >  result := FService <> nil;
700   end;
701  
702   function TIBCustomService.GetServiceParamBySPB(const Idx: Integer): String;
# Line 719 | Line 705 | var
705   begin
706    if (Idx > 0) and (Idx <= isc_spb_last_spb_constant) then
707    begin
708 <    ConstIdx := IndexOfSPBConst(SPBConstantNames[Idx]);
708 >    ConstIdx := IndexOfSPBConst(Idx);
709      if ConstIdx = -1 then
710        result := ''
711      else
# Line 736 | Line 722 | begin
722      result := '';
723   end;
724  
725 + function TIBCustomService.GetSQPB: ISQPB;
726 + begin
727 +  CheckActive;
728 +  if FSQPB = nil then
729 +    FSQPB := FService.AllocateSQPB;
730 +  Result := FSQPB;
731 + end;
732 +
733 + function TIBCustomService.GetSRB: ISRB;
734 + begin
735 +  CheckActive;
736 +  if FSRB = nil then
737 +    FSRB := FService.AllocateSRB;
738 +  Result := FSRB;
739 + end;
740 +
741   procedure TIBCustomService.InternalServiceQuery;
742   begin
743 <  FQuerySPBLength := Length(FQueryParams);
744 <  if FQuerySPBLength = 0 then
745 <    IBError(ibxeQueryParamsError, [nil]);
744 <  IBAlloc(FQuerySPB, 0, FQuerySPBLength);
745 <  Move(FQueryParams[1], FQuerySPB[0], FQuerySPBLength);
746 <  if (FOutputBuffer = nil) then
747 <    IBAlloc(FOutputBuffer, 0, FBufferSize);
748 <  try
749 <    if call(isc_service_query(StatusVector, @FHandle, nil, 0, nil,
750 <                           FQuerySPBLength, FQuerySPB,
751 <                           FBufferSize, FOutputBuffer), False) > 0 then
752 <    begin
753 <      FHandle := nil;
754 <      IBDataBaseError;
755 <    end;
756 <  finally
757 <    FreeMem(FQuerySPB);
758 <    FQuerySPB := nil;
759 <    FQuerySPBLength := 0;
760 <    FQueryParams := '';
761 <  end;
743 >  FServiceQueryResults := FService.Query(FSQPB,FSRB);
744 >  FSQPB := nil;
745 >  FSRB := nil;
746    MonitorHook.ServiceQuery(Self);
747   end;
748  
# Line 767 | Line 751 | begin
751    if csReading in ComponentState then
752      FStreamedActive := Value
753    else
754 <    if Value <> Active then  
754 >    if Value <> Active then
755 >    begin
756        if Value then
757          Attach
758        else
759          Detach;
760 < end;
761 <
762 < procedure TIBCustomService.SetBufferSize(const Value: Integer);
763 < begin
764 <  if (FOutputBuffer <> nil) and (Value <> FBufferSize) then
765 <    IBAlloc(FOutputBuffer, 0, FBufferSize);
760 >    end
761 >   else if Value then
762 >   begin
763 >     FService.Detach;
764 >     FService.Attach;
765 >   end;
766   end;
767  
768   procedure TIBCustomService.SetParams(const Value: TStrings);
# Line 805 | Line 790 | begin
790    end;
791   end;
792  
793 + procedure TIBCustomService.SetService(AValue: IServiceManager);
794 + begin
795 +  if FService = AValue then Exit;
796 +  FService := AValue;
797 +  if AValue <> nil then
798 +    FServerName := FService.getServerName;
799 + end;
800 +
801   procedure TIBCustomService.SetServiceParamBySPB(const Idx: Integer;
802    const Value: String);
803   var
804    ConstIdx: Integer;
805   begin
806 <  ConstIdx := IndexOfSPBConst(SPBConstantNames[Idx]);
806 >  ConstIdx := IndexOfSPBConst(Idx);
807    if (Value = '') then
808    begin
809      if ConstIdx <> -1 then
# Line 819 | Line 812 | begin
812    else
813    begin
814      if (ConstIdx = -1) then
815 <      Params.Add(SPBConstantNames[Idx] + '=' + Value)
815 >      Params.Add(GetSPBConstName(Idx) + '=' + Value)
816      else
817 <      Params[ConstIdx] := SPBConstantNames[Idx] + '=' + Value;
817 >      Params[ConstIdx] := GetSPBConstName(Idx) + '=' + Value;
818    end;
819   end;
820  
821 < function TIBCustomService.IndexOfSPBConst(st: String): Integer;
821 > function TIBCustomService.IndexOfSPBConst(action: byte): Integer;
822   var
823 <  i, pos_of_str: Integer;
823 >  i,  pos_of_str: Integer;
824 >  st: string;
825   begin
826    result := -1;
827 +  st := GetSPBConstName(action);
828 +  if st <> '' then
829    for i := 0 to Params.Count - 1 do
830    begin
831      pos_of_str := Pos(st, Params[i]); {mbcs ok}
# Line 841 | Line 837 | begin
837    end;
838   end;
839  
840 + function TIBCustomService.GetSPBConstName(action: byte): string;
841 + var i: integer;
842 + begin
843 +  Result := '';
844 +  for i := Low(SPBConstantValues) to High(SPBConstantValues) do
845 +    if SPBConstantValues[i] = action then
846 +    begin
847 +      Result := SPBConstantNames[i];
848 +      break;
849 +    end;
850 + end;
851 +
852   procedure TIBCustomService.ParamsChange(Sender: TObject);
853   begin
854    FParamsChanged := True;
# Line 857 | Line 865 | begin
865      IBError(ibxeServerNameMissing, [nil]);
866   end;
867  
860 function TIBCustomService.Call(ErrCode: ISC_STATUS;
861  RaiseError: Boolean): ISC_STATUS;
862 begin
863  result := ErrCode;
864  if RaiseError and (ErrCode > 0) then
865    IBDataBaseError;
866 end;
867
868 function TIBCustomService.ParseString(var RunLen: Integer): string;
869 var
870  Len: UShort;
871  tmp: Char;
872 begin
873  Len := isc_vax_integer(OutputBuffer + RunLen, 2);
874  RunLen := RunLen + 2;
875  if (Len <> 0) then
876  begin
877    tmp := OutputBuffer[RunLen + Len];
878    OutputBuffer[RunLen + Len] := #0;
879    result := String(PChar(@OutputBuffer[RunLen]));
880    OutputBuffer[RunLen + Len] := tmp;
881    RunLen := RunLen + Len;
882  end
883  else
884    result := '';
885 end;
886
887 function TIBCustomService.ParseInteger(var RunLen: Integer): Integer;
888 begin
889  result := isc_vax_integer(OutputBuffer + RunLen, 4);
890  RunLen := RunLen + 4;
891 end;
892
868   {
869   * GenerateSPB -
870   *  Given a string containing a textual representation
871   *  of the Service parameters, generate a service
872 < *  parameter buffer, and return it and its length
898 < *  in SPB and SPBLength, respectively.
872 > *  parameter buffer, and return it .
873   }
874 < procedure TIBCustomService.GenerateSPB(sl: TStrings; var SPB: String;
901 <  var SPBLength: Short);
874 > function TIBCustomService.GenerateSPB(sl: TStrings): ISPB;
875   var
876    i, j, SPBVal, SPBServerVal: UShort;
877    param_name, param_value: String;
# Line 906 | Line 879 | begin
879    { The SPB is initially empty, with the exception that
880     the SPB version must be the first byte of the string.
881    }
882 <  SPBLength := 2;
883 <  SPB := Char(isc_spb_version);
911 <  SPB := SPB + Char(isc_spb_current_version);
882 >  Result := FirebirdAPI.AllocateSPB;
883 >
884    { Iterate through the textual service parameters, constructing
885     a SPB on-the-fly }
886    if sl.Count > 0 then
# Line 935 | Line 907 | begin
907          SPBServerVal := SPBConstantValues[j];
908          break;
909        end;
910 <    case SPBVal of
910 >    case SPBServerVal of
911        isc_spb_user_name, isc_spb_password:
912 <      begin
941 <        SPB := SPB +
942 <               Char(SPBServerVal) +
943 <               Char(Length(param_value)) +
944 <               param_value;
945 <        Inc(SPBLength, 2 + Length(param_value));
946 <      end;
912 >        Result.Add(SPBServerVal).AsString := param_value;
913        else
914        begin
915 <        if (SPBVal > 0) and
950 <           (SPBVal <= isc_dpb_last_dpb_constant) then
915 >        if GetSPBConstName(SPBServerVal) <> '' then
916            IBError(ibxeSPBConstantNotSupported,
917 <                   [SPBConstantNames[SPBVal]])
917 >                   [GetSPBConstName(SPBServerVal)])
918          else
919 <          IBError(ibxeSPBConstantUnknown, [SPBVal]);
919 >          IBError(ibxeSPBConstantUnknown, [SPBServerVal]);
920        end;
921      end;
922    end;
# Line 978 | Line 943 | begin
943    inherited Destroy;
944   end;
945  
981 procedure TIBServerProperties.ParseConfigFileData(var RunLen: Integer);
982 begin
983  Inc(RunLen);
984  with FConfigParams.ConfigFileData do
985  begin
986    SetLength (ConfigFileValue, Length(ConfigFileValue)+1);
987    SetLength (ConfigFileKey, Length(ConfigFileKey)+1);
988
989    ConfigFileKey[High(ConfigFileKey)] := Integer(OutputBuffer[RunLen-1]);
990    ConfigFileValue[High(ConfigFileValue)] := ParseInteger(RunLen);
991  end;
992 end;
993
946   procedure TIBServerProperties.Fetch;
947   begin
948    if (Database in Options) then
# Line 1007 | Line 959 | end;
959  
960   procedure TIBServerProperties.FetchConfigParams;
961   var
962 <  RunLen: Integer;
962 >  i, j: Integer;
963  
964   begin
965 <  ServiceQueryParams := Char(isc_info_svc_get_config) +
966 <                        Char(isc_info_svc_get_env) +
967 <                        Char(isc_info_svc_get_env_lock) +
968 <                        Char(isc_info_svc_get_env_msg) +
969 <                        Char(isc_info_svc_user_dbpath);
965 >  SRB.Add(isc_info_svc_get_config);
966 >  SRB.Add(isc_info_svc_get_env);
967 >  SRB.Add(isc_info_svc_get_env_lock);
968 >  SRB.Add(isc_info_svc_get_env_msg);
969 >  SRB.Add(isc_info_svc_user_dbpath);
970  
971    InternalServiceQuery;
972 <  RunLen := 0;
973 <  While (not (Integer(OutputBuffer[RunLen]) = isc_info_end)) do
972 >
973 >  for i := 0 to FServiceQueryResults.Count - 1 do
974 >  with FServiceQueryResults[i] do
975    begin
976 <    case Integer(OutputBuffer[RunLen]) of
976 >    case getItemType of
977        isc_info_svc_get_config:
978        begin
979 <        FConfigParams.ConfigFileData.ConfigFileKey := nil;
980 <        FConfigParams.ConfigFileData.ConfigFileValue := nil;
981 <        Inc (RunLen);
982 <        while (not (Integer(OutputBuffer[RunLen]) = isc_info_flag_end)) do
983 <          ParseConfigFileData (RunLen);
984 <        if (Integer(OutputBuffer[RunLen]) = isc_info_flag_end) then
985 <          Inc (RunLen);
979 >        SetLength (FConfigParams.ConfigFileData.ConfigFileValue, Count);
980 >        SetLength (FConfigParams.ConfigFileData.ConfigFileKey, Count);
981 >
982 >        for j := 0 to Count - 1 do
983 >        begin
984 >          FConfigParams.ConfigFileData.ConfigFileKey[j] := getItemType;
985 >          FConfigParams.ConfigFileData.ConfigFileValue[j] := AsInteger;
986 >        end;
987        end;
988  
989        isc_info_svc_get_env:
990 <      begin
1037 <        Inc (RunLen);
1038 <        FConfigParams.BaseLocation := ParseString(RunLen);
1039 <      end;
990 >        FConfigParams.BaseLocation := AsString;
991  
992        isc_info_svc_get_env_lock:
993 <      begin
1043 <        Inc (RunLen);
1044 <        FConfigParams.LockFileLocation := ParseString(RunLen);
1045 <      end;
993 >        FConfigParams.LockFileLocation := AsString;
994  
995        isc_info_svc_get_env_msg:
996 <      begin
1049 <        Inc (RunLen);
1050 <        FConfigParams.MessageFileLocation := ParseString(RunLen);
1051 <      end;
996 >        FConfigParams.MessageFileLocation := AsString;
997  
998        isc_info_svc_user_dbpath:
999 <      begin
1000 <        Inc (RunLen);
1056 <        FConfigParams.SecurityDatabaseLocation := ParseString(RunLen);
1057 <      end;
999 >        FConfigParams.SecurityDatabaseLocation := AsString;
1000 >
1001        else
1002 <        IBError(ibxeOutputParsingError, [nil]);
1002 >        IBError(ibxeOutputParsingError, [getItemType]);
1003      end;
1004    end;
1005   end;
1006  
1007   procedure TIBServerProperties.FetchDatabaseInfo;
1008   var
1009 <  i, RunLen: Integer;
1009 >  i,j: Integer;
1010   begin
1011 <  ServiceQueryParams := Char(isc_info_svc_svr_db_info);
1011 >  SRB.Add(isc_info_svc_svr_db_info);
1012    InternalServiceQuery;
1013 <  if (OutputBuffer[0] <> Char(isc_info_svc_svr_db_info)) then
1014 <      IBError(ibxeOutputParsingError, [nil]);
1015 <  RunLen := 1;
1016 <  if (OutputBuffer[RunLen] <> Char(isc_spb_num_att)) then
1017 <      IBError(ibxeOutputParsingError, [nil]);
1018 <  Inc(RunLen);
1019 <  FDatabaseInfo.NoOfAttachments := ParseInteger(RunLen);
1020 <  if (OutputBuffer[RunLen] <> Char(isc_spb_num_db)) then
1021 <      IBError(ibxeOutputParsingError, [nil]);
1022 <  Inc(RunLen);
1023 <  FDatabaseInfo.NoOfDatabases := ParseInteger(RunLen);
1024 <  FDatabaseInfo.DbName := nil;
1025 <  SetLength(FDatabaseInfo.DbName, FDatabaseInfo.NoOfDatabases);
1026 <  i := 0;
1027 <  while (OutputBuffer[RunLen] <> Char(isc_info_flag_end)) do
1028 <  begin
1029 <    if (OutputBuffer[RunLen] <> Char(SPBConstantValues[isc_spb_dbname])) then
1030 <      IBError(ibxeOutputParsingError, [nil]);
1031 <    Inc(RunLen);
1032 <    FDatabaseInfo.DbName[i] := ParseString(RunLen);
1033 <    Inc (i);
1034 <  end;
1013 >
1014 >  SetLength(FDatabaseInfo.DbName,0);
1015 >  for i := 0 to FServiceQueryResults.Count - 1 do
1016 >  with FServiceQueryResults[i] do
1017 >  begin
1018 >    case getItemType of
1019 >      isc_info_svc_svr_db_info:
1020 >        for j := 0 to FServiceQueryResults[i].Count - 1 do
1021 >        with FServiceQueryResults[i][j] do
1022 >        case getItemType of
1023 >        isc_spb_num_att:
1024 >          FDatabaseInfo.NoOfAttachments := AsInteger;
1025 >
1026 >        isc_spb_num_db:
1027 >          FDatabaseInfo.NoOfDatabases := AsInteger;
1028 >
1029 >        isc_spb_dbname:
1030 >          begin
1031 >            SetLength(FDatabaseInfo.DbName,length(FDatabaseInfo.DbName)+1);
1032 >            FDatabaseInfo.DbName[length(FDatabaseInfo.DbName)-1] := AsString;
1033 >          end;
1034 >        else
1035 >          IBError(ibxeOutputParsingError, [getItemType]);
1036 >        end;
1037 >      else
1038 >        IBError(ibxeOutputParsingError, [getItemType]);
1039 >    end;
1040 > end;
1041   end;
1042  
1043   procedure TIBServerProperties.FetchLicenseInfo;
1044   var
1045 <  i, RunLen: Integer;
1097 <  done: Integer;
1045 >  i,j : Integer;
1046   begin
1047 <  ServiceQueryParams := Char(isc_info_svc_get_license) +
1048 <                        Char(isc_info_svc_get_licensed_users);
1047 >  SRB.Add(isc_info_svc_get_license);
1048 >  SRB.Add(isc_info_svc_get_licensed_users);
1049    InternalServiceQuery;
1050 <  RunLen := 0;
1051 <  done := 0;
1052 <  i := 0;
1053 <  FLicenseInfo.key := nil;
1054 <  FLicenseInfo.id := nil;
1055 <  FLicenseInfo.desc := nil;
1056 <
1057 <  While done < 2 do begin
1058 <    Inc(Done);
1111 <    Inc(RunLen);
1112 <    case Integer(OutputBuffer[RunLen-1]) of
1050 >
1051 >  SetLength(FLicenseInfo.key, 0);
1052 >  SetLength(FLicenseInfo.id, 0);
1053 >  SetLength(FLicenseInfo.desc, 0);
1054 >
1055 >  for i := 0 to FServiceQueryResults.Count - 1 do
1056 >  with FServiceQueryResults[i] do
1057 >  begin
1058 >    case getItemType of
1059        isc_info_svc_get_license:
1114      begin
1115        while (OutputBuffer[RunLen] <> Char(isc_info_flag_end)) do
1060          begin
1061 <          if (i >= Length(FLicenseInfo.key)) then
1062 <          begin
1063 <            SetLength(FLicenseInfo.key, i + 10);
1064 <            SetLength(FLicenseInfo.id, i + 10);
1065 <            SetLength(FLicenseInfo.desc, i + 10);
1061 >          SetLength(FLicenseInfo.key, Count);
1062 >          SetLength(FLicenseInfo.id, Count);
1063 >          SetLength(FLicenseInfo.desc, Count);
1064 >
1065 >          for j := 0 to Count -1 do
1066 >          with Items[j] do
1067 >          case getItemType of
1068 >             isc_spb_lic_id:
1069 >                FLicenseInfo.id[j] := AsString;
1070 >
1071 >             isc_spb_lic_key:
1072 >                FLicenseInfo.key[j] := AsString;
1073 >
1074 >             isc_spb_lic_desc:
1075 >               FLicenseInfo.desc[j] := AsString;
1076 >          else
1077 >            IBError(ibxeOutputParsingError, [getItemType]);
1078            end;
1123          if (OutputBuffer[RunLen] <> Char(isc_spb_lic_id)) then
1124              IBError(ibxeOutputParsingError, [nil]);
1125          Inc(RunLen);
1126          FLicenseInfo.id[i] := ParseString(RunLen);
1127          if (OutputBuffer[RunLen] <> Char(isc_spb_lic_key)) then
1128              IBError(ibxeOutputParsingError, [nil]);
1129          Inc(RunLen);
1130          FLicenseInfo.key[i] := ParseString(RunLen);
1131          if (OutputBuffer[RunLen] <> Char(7)) then
1132              IBError(ibxeOutputParsingError, [nil]);
1133          Inc(RunLen);
1134          FLicenseInfo.desc[i] := ParseString(RunLen);
1135          Inc(i);
1136        end;
1137        Inc(RunLen);
1138        if (Length(FLicenseInfo.key) > i) then
1139        begin
1140          SetLength(FLicenseInfo.key, i);
1141          SetLength(FLicenseInfo.id, i);
1142          SetLength(FLicenseInfo.desc, i);
1079          end;
1144      end;
1145      isc_info_svc_get_licensed_users:
1146        FLicenseInfo.LicensedUsers := ParseInteger(RunLen);
1080        else
1081 <        IBError(ibxeOutputParsingError, [nil]);
1081 >        IBError(ibxeOutputParsingError, [getItemType]);
1082      end;
1083    end;
1084   end;
1085  
1086   procedure TIBServerProperties.FetchLicenseMaskInfo();
1087   var
1088 <  done,RunLen:integer;
1088 >  i : Integer;
1089   begin
1090 <  ServiceQueryParams := Char(isc_info_svc_get_license_mask) +
1091 <                        Char(isc_info_svc_capabilities);
1090 >  SRB.Add(isc_info_svc_get_license_mask);
1091 >  SRB.Add(isc_info_svc_capabilities);
1092    InternalServiceQuery;
1093 <  RunLen := 0;
1094 <  done := 0;
1095 <  While done <= 1 do
1096 <  begin
1097 <    Inc(done);
1165 <    Inc(RunLen);
1166 <    case Integer(OutputBuffer[RunLen-1]) of
1093 >
1094 >  for i := 0 to FServiceQueryResults.Count - 1 do
1095 >  with FServiceQueryResults[i] do
1096 >  begin
1097 >    case getItemType of
1098        isc_info_svc_get_license_mask:
1099 <        FLicenseMaskInfo.LicenseMask := ParseInteger(RunLen);
1099 >        FLicenseMaskInfo.LicenseMask := AsInteger;
1100        isc_info_svc_capabilities:
1101 <        FLicenseMaskInfo.CapabilityMask := ParseInteger(RunLen);
1101 >        FLicenseMaskInfo.CapabilityMask := AsInteger;
1102        else
1103 <        IBError(ibxeOutputParsingError, [nil]);
1103 >        IBError(ibxeOutputParsingError, [getItemType]);
1104      end;
1105    end;
1106   end;
# Line 1177 | Line 1108 | end;
1108  
1109   procedure TIBServerProperties.FetchVersionInfo;
1110   var
1111 <  RunLen: Integer;
1181 <  done: Integer;
1111 >  i : Integer;
1112   begin
1113 <  ServiceQueryParams := Char(isc_info_svc_version) +
1114 <                        Char(isc_info_svc_server_version) +
1115 <                        Char(isc_info_svc_implementation);
1113 >  SRB.Add(isc_info_svc_version);
1114 >  SRB.Add(isc_info_svc_server_version);
1115 >  SRB.Add(isc_info_svc_implementation);
1116    InternalServiceQuery;
1187  RunLen := 0;
1188  done := 0;
1117  
1118 <  While done <= 2 do
1118 >  for i := 0 to FServiceQueryResults.Count - 1 do
1119 >  with FServiceQueryResults[i] do
1120    begin
1121 <    Inc(done);
1193 <    Inc(RunLen);
1194 <    case Integer(OutputBuffer[RunLen-1]) of
1121 >    case getItemType of
1122        isc_info_svc_version:
1123 <        FVersionInfo.ServiceVersion := ParseInteger(RunLen);
1123 >        FVersionInfo.ServiceVersion := AsInteger;
1124        isc_info_svc_server_version:
1125 <        FVersionInfo.ServerVersion := ParseString(RunLen);
1125 >        FVersionInfo.ServerVersion := AsString;
1126        isc_info_svc_implementation:
1127 <        FVersionInfo.ServerImplementation := ParseString(RunLen);
1127 >        FVersionInfo.ServerImplementation := AsString;
1128        else
1129 <        IBError(ibxeOutputParsingError, [nil]);
1129 >        IBError(ibxeOutputParsingError, [getItemType]);
1130      end;
1131    end;
1132   end;
1133  
1134   { TIBControlService }
1135 +
1136   procedure TIBControlService.SetServiceStartOptions;
1137   begin
1138  
1139   end;
1140  
1141   function TIBControlService.GetIsServiceRunning: Boolean;
1214 var
1215  RunLen: Integer;
1142   begin
1143 <  ServiceQueryParams := Char(isc_info_svc_running);
1143 >  SRB.Add(isc_info_svc_running);
1144    InternalServiceQuery;
1219  if (OutputBuffer[0] <> Char(isc_info_svc_running)) then
1220    IBError(ibxeOutputParsingError, [nil]);
1221  RunLen := 1;
1222  if (ParseInteger(RunLen) = 1) then
1223    result := True
1224  else
1225    result := False;
1226 end;
1145  
1146 < procedure TIBControlService.ServiceStartAddParam (Value: string; param: Integer);
1147 < var
1148 <  Len: UShort;
1231 < begin
1232 <  Len := Length(Value);
1233 <  if Len > 0 then
1234 <  begin
1235 <    FStartParams  := FStartParams +
1236 <                     Char(Param) +
1237 <                     PChar(@Len)[0] +
1238 <                     PChar(@Len)[1] +
1239 <                     Value;
1240 <  end;
1146 >  Result := (FServiceQueryResults.Count > 0) and
1147 >             (FServiceQueryResults[0].getItemType = isc_info_svc_running) and
1148 >              (FServiceQueryResults[0].AsInteger = 1);
1149   end;
1150  
1151 < procedure TIBControlService.ServiceStartAddParam (Value: Integer; param: Integer);
1151 > procedure TIBControlService.CheckServiceNotRunning;
1152   begin
1153 <  FStartParams  := FStartParams +
1154 <                   Char(Param) +
1247 <                   PChar(@Value)[0] +
1248 <                   PChar(@Value)[1] +
1249 <                   PChar(@Value)[2] +
1250 <                   PChar(@Value)[3];
1153 >  if IsServiceRunning then
1154 >    IBError(ibxeServiceRunning,[nil]);
1155   end;
1156  
1157   constructor TIBControlService.Create(AOwner: TComponent);
1158   begin
1159    inherited create(AOwner);
1160 <  FStartParams := '';
1161 <  FStartSPB := nil;
1258 <  FStartSPBLength := 0;
1160 >  FSRB := nil;
1161 >  FSPB := nil;
1162   end;
1163  
1164   procedure TIBControlService.InternalServiceStart;
1165   begin
1166 <  FStartSPBLength := Length(FStartParams);
1264 <  if FStartSPBLength = 0 then
1166 >  if SRB = nil then
1167      IBError(ibxeStartParamsError, [nil]);
1168 <  IBAlloc(FStartSPB, 0, FStartSPBLength);
1267 <  Move(FStartParams[1], FStartSPB[0], FstartSPBLength);
1168 >
1169    try
1170 <    if call(isc_service_start(StatusVector, @FHandle, nil,
1270 <                           FStartSPBLength, FStartSPB), False) > 0 then
1271 <    begin
1272 <      FHandle := nil;
1273 <      IBDataBaseError;
1274 <    end;
1170 >    FService.Start(SRB);
1171    finally
1172 <    FreeMem(FStartSPB);
1277 <    FStartSPB := nil;
1278 <    FStartSPBLength := 0;
1279 <    FStartParams := '';
1172 >    FSRB := nil;
1173    end;
1174    MonitorHook.ServiceStart(Self);
1175   end;
# Line 1284 | Line 1177 | end;
1177   procedure TIBControlService.ServiceStart;
1178   begin
1179    CheckActive;
1180 +  CheckServiceNotRunning;
1181    SetServiceStartOptions;
1182    InternalServiceStart;
1183   end;
# Line 1297 | Line 1191 | end;
1191  
1192   procedure TIBConfigService.ActivateShadow;
1193   begin
1194 <  ServiceStartParams  := Char(isc_action_svc_properties);
1195 <  ServiceStartAddParam (FDatabaseName, SPBConstantValues[isc_spb_dbname]);
1196 <  ServiceStartAddParam (isc_spb_prp_activate, SPBConstantValues[isc_spb_options]);
1194 >  SRB.Add(isc_action_svc_properties);
1195 >  SRB.Add(isc_spb_dbname).AsString :=  FDatabaseName;
1196 >  SRB.Add(isc_spb_options).AsInteger := isc_spb_prp_activate;
1197    InternalServiceStart;
1198   end;
1199  
1200   procedure TIBConfigService.BringDatabaseOnline;
1201   begin
1202 <  ServiceStartParams  := Char(isc_action_svc_properties);
1203 <  ServiceStartAddParam (FDatabaseName, SPBConstantValues[isc_spb_dbname]);
1204 <  ServiceStartAddParam (isc_spb_prp_db_online, SPBConstantValues[isc_spb_options]);
1202 >  SRB.Add(isc_action_svc_properties);
1203 >  SRB.Add(isc_spb_dbname).AsString :=  FDatabaseName;
1204 >  SRB.Add(isc_spb_options).AsInteger := isc_spb_prp_db_online;
1205    InternalServiceStart;
1206   end;
1207  
1208   procedure TIBConfigService.SetAsyncMode(Value: Boolean);
1209   begin
1210 <  ServiceStartParams  := Char(isc_action_svc_properties);
1211 <  ServiceStartAddParam (FDatabaseName, SPBConstantValues[isc_spb_dbname]);
1212 <  ServiceStartParams := ServiceStartParams +
1319 <                        Char(isc_spb_prp_write_mode);
1210 >  SRB.Add(isc_action_svc_properties);
1211 >  SRB.Add(isc_spb_dbname).AsString :=  FDatabaseName;
1212 >  with SRB.Add(isc_spb_prp_write_mode) do
1213    if Value then
1214 <    ServiceStartParams  := ServiceStartParams +
1322 <                           Char(isc_spb_prp_wm_async)
1214 >    AsInteger := isc_spb_prp_wm_async
1215    else
1216 <    ServiceStartParams  := ServiceStartParams +
1325 <                           Char(isc_spb_prp_wm_sync);
1216 >    AsInteger := isc_spb_prp_wm_sync;
1217    InternalServiceStart;
1218   end;
1219  
# Line 1333 | Line 1224 | end;
1224  
1225   procedure TIBConfigService.SetPageBuffers(Value: Integer);
1226   begin
1227 <  ServiceStartParams  := Char(isc_action_svc_properties);
1228 <  ServiceStartAddParam (FDatabaseName, SPBConstantValues[isc_spb_dbname]);
1229 <  ServiceStartAddParam (Value, isc_spb_prp_page_buffers);
1227 >  SRB.Add(isc_action_svc_properties);
1228 >  SRB.Add(isc_spb_dbname).AsString :=  FDatabaseName;
1229 >  SRB.Add(isc_spb_prp_page_buffers).AsInteger := Value;
1230    InternalServiceStart;
1231   end;
1232  
1233   procedure TIBConfigService.SetReadOnly(Value: Boolean);
1234   begin
1235 <  ServiceStartParams  := Char(isc_action_svc_properties);
1236 <  ServiceStartAddParam (FDatabaseName, SPBConstantValues[isc_spb_dbname]);
1237 <  ServiceStartParams := ServiceStartParams +
1347 <                         Char(isc_spb_prp_access_mode);
1235 >  SRB.Add(isc_action_svc_properties);
1236 >  SRB.Add(isc_spb_dbname).AsString :=  FDatabaseName;
1237 >  with SRB.Add(isc_spb_prp_access_mode) do
1238    if Value then
1239 <    ServiceStartParams  := ServiceStartParams +
1350 <                           Char(isc_spb_prp_am_readonly)
1239 >    AsInteger := isc_spb_prp_am_readonly
1240    else
1241 <    ServiceStartParams  := ServiceStartParams +
1353 <                           Char(isc_spb_prp_am_readwrite);
1241 >    AsInteger := isc_spb_prp_am_readwrite;
1242    InternalServiceStart;
1243   end;
1244  
1245   procedure TIBConfigService.SetReserveSpace(Value: Boolean);
1246   begin
1247 <  ServiceStartParams  := Char(isc_action_svc_properties);
1248 <  ServiceStartAddParam (FDatabaseName, SPBConstantValues[isc_spb_dbname]);
1249 <  ServiceStartParams := ServiceStartParams +
1362 <                        Char(isc_spb_prp_reserve_space);
1247 >  SRB.Add(isc_action_svc_properties);
1248 >  SRB.Add(isc_spb_dbname).AsString :=  FDatabaseName;
1249 >  with SRB.Add(isc_spb_prp_reserve_space) do
1250    if Value then
1251 <    ServiceStartParams  := ServiceStartParams +
1365 <                           Char(isc_spb_prp_res)
1251 >    AsInteger := isc_spb_prp_res
1252    else
1253 <    ServiceStartParams  := ServiceStartParams +
1368 <                           Char(isc_spb_prp_res_use_full);
1253 >    AsInteger := isc_spb_prp_res_use_full;
1254    InternalServiceStart;
1255   end;
1256  
1257   procedure TIBConfigService.SetSweepInterval(Value: Integer);
1258   begin
1259 <  ServiceStartParams  := Char(isc_action_svc_properties);
1260 <  ServiceStartAddParam (FDatabaseName, SPBConstantValues[isc_spb_dbname]);
1261 <  ServiceStartAddParam (Value, isc_spb_prp_sweep_interval);
1259 >  SRB.Add(isc_action_svc_properties);
1260 >  SRB.Add(isc_spb_dbname).AsString :=  FDatabaseName;
1261 >  SRB.Add(isc_spb_prp_sweep_interval).AsInteger := Value;
1262    InternalServiceStart;
1263   end;
1264  
1265   procedure TIBConfigService.SetDBSqlDialect(Value: Integer);
1266   begin
1267 <  ServiceStartParams  := Char(isc_action_svc_properties);
1268 <  ServiceStartAddParam (FDatabaseName, SPBConstantValues[isc_spb_dbname]);
1269 <  ServiceStartAddParam (Value, isc_spb_prp_set_sql_dialect);
1267 >  SRB.Add(isc_action_svc_properties);
1268 >  SRB.Add(isc_spb_dbname).AsString :=  FDatabaseName;
1269 >  SRB.Add(isc_spb_prp_set_sql_dialect).AsInteger := Value;
1270    InternalServiceStart;
1271   end;
1272  
1273   procedure TIBConfigService.ShutdownDatabase(Options: TShutdownMode;
1274    Wait: Integer);
1275   begin
1276 <  ServiceStartParams  := Char(isc_action_svc_properties);
1277 <  ServiceStartAddParam (FDatabaseName, SPBConstantValues[isc_spb_dbname]);
1276 >  SRB.Add(isc_action_svc_properties);
1277 >  SRB.Add(isc_spb_dbname).AsString :=  FDatabaseName;
1278    if (Options = Forced) then
1279 <    ServiceStartAddParam (Wait, isc_spb_prp_shutdown_db)
1279 >  SRB.Add(isc_spb_prp_shutdown_db).AsInteger := Wait
1280    else if (Options = DenyTransaction) then
1281 <    ServiceStartAddParam (Wait, isc_spb_prp_deny_new_transactions)
1281 >    SRB.Add(isc_spb_prp_deny_new_transactions).AsInteger := Wait
1282    else
1283 <    ServiceStartAddParam (Wait, isc_spb_prp_deny_new_attachments);
1283 >    SRB.Add(isc_spb_prp_deny_new_attachments).AsInteger := Wait;
1284    InternalServiceStart;
1285   end;
1286  
1287 +
1288   { TIBStatisticalService }
1289  
1290   procedure TIBStatisticalService.SetDatabaseName(const Value: string);
# Line 1407 | Line 1293 | begin
1293   end;
1294  
1295   procedure TIBStatisticalService.SetServiceStartOptions;
1296 < var
1411 <  param: Integer;
1296 > var param: integer;
1297   begin
1298    if FDatabaseName = '' then
1299      IBError(ibxeStartParamsError, [nil]);
1300 +
1301    param := 0;
1302    if (DataPages in Options) then
1303      param := param or isc_spb_sts_data_pages;
# Line 1424 | Line 1310 | begin
1310    if (SystemRelations in Options) then
1311      param := param or isc_spb_sts_sys_relations;
1312    Action := isc_action_svc_db_stats;
1313 <  ServiceStartParams  := Char(isc_action_svc_db_stats);
1314 <  ServiceStartAddParam (FDatabaseName, SPBConstantValues[isc_spb_dbname]);
1315 <  ServiceStartAddParam (param, SPBConstantValues[isc_spb_options]);
1313 >  SRB.Add(isc_action_svc_db_stats);
1314 >  SRB.Add(isc_spb_dbname).AsString := FDatabaseName;
1315 >  SRB.Add(isc_spb_options).AsInteger := param;
1316   end;
1317  
1318   { TIBBackupService }
# Line 1453 | Line 1339 | begin
1339    if (ConvertExtTables in Options) then
1340      param := param or isc_spb_bkp_convert;
1341    Action := isc_action_svc_backup;
1342 <  ServiceStartParams  := Char(isc_action_svc_backup);
1343 <  ServiceStartAddParam(FDatabaseName, SPBConstantValues[isc_spb_dbname]);
1344 <  ServiceStartAddParam(param, SPBConstantValues[isc_spb_options]);
1345 <  if Verbose then
1346 <    ServiceStartParams := ServiceStartParams + Char(SPBConstantValues[isc_spb_verbose]);
1342 >  SRB.Add(isc_action_svc_backup);
1343 >  SRB.Add(isc_spb_dbname).AsString := FDatabaseName;
1344 >  SRB.Add(isc_spb_options).AsInteger := param;
1345 >  if Verbose  and (BackupFileLocation = flServerSide) then
1346 >    SRB.Add(isc_spb_verbose);
1347    if FBlockingFactor > 0 then
1348 <    ServiceStartAddParam(FBlockingFactor, isc_spb_bkp_factor);
1348 >    SRB.Add(isc_spb_bkp_factor).AsInteger := FBlockingFactor;
1349 >  if BackupFileLocation = flServerSide then
1350    for i := 0 to FBackupFile.Count - 1 do
1351    begin
1352      if (Trim(FBackupFile[i]) = '') then
1353        continue;
1354      if (Pos('=', FBackupFile[i]) <> 0) then
1355      begin {mbcs ok}
1356 <      ServiceStartAddParam(FBackupFile.Names[i], isc_spb_bkp_file);
1356 >      SRB.Add(isc_spb_bkp_file).AsString := FBackupFile.Names[i];
1357        value := Copy(FBackupFile[i], Pos('=', FBackupFile[i]) + 1, Length(FBackupFile.Names[i])); {mbcs ok}
1358 <      param := StrToInt(value);
1472 <      ServiceStartAddParam(param, isc_spb_bkp_length);
1358 >      SRB.Add(isc_spb_bkp_length).AsInteger := StrToInt(value);;
1359      end
1360      else
1361 <      ServiceStartAddParam(FBackupFile[i], isc_spb_bkp_file);
1362 <  end;
1361 >      SRB.Add(isc_spb_bkp_file).AsString := FBackupFile[i];
1362 >  end
1363 >  else
1364 >  SRB.Add(isc_spb_bkp_file).AsString := 'stdout';
1365   end;
1366  
1367   constructor TIBBackupService.Create(AOwner: TComponent);
# Line 1516 | Line 1404 | begin
1404    if (UseAllSpace in Options) then
1405      param := param or isc_spb_res_use_all_space;
1406    Action := isc_action_svc_restore;
1407 <  ServiceStartParams  := Char(isc_action_svc_restore);
1408 <  ServiceStartAddParam(param, SPBConstantValues[isc_spb_options]);
1409 <  if Verbose then ServiceStartParams := ServiceStartParams + Char(SPBConstantValues[isc_spb_verbose]);
1407 >  SRB.Add(isc_action_svc_restore);
1408 >  SRB.Add(isc_spb_options).AsInteger := param;
1409 >  if Verbose then
1410 >    SRB.Add(isc_spb_verbose);
1411    if FPageSize > 0 then
1412 <    ServiceStartAddParam(FPageSize, isc_spb_res_page_size);
1412 >    SRB.Add(isc_spb_res_page_size).AsInteger := FPageSize;
1413    if FPageBuffers > 0 then
1414 <    ServiceStartAddParam(FPageBuffers, isc_spb_res_buffers);
1414 >    SRB.Add(isc_spb_res_buffers).AsInteger := FPageBuffers;
1415 >  if BackupFileLocation = flServerSide then
1416    for i := 0 to FBackupFile.Count - 1 do
1417    begin
1418      if (Trim(FBackupFile[i]) = '') then continue;
1419      if (Pos('=', FBackupFile[i]) <> 0) then  {mbcs ok}
1420      begin
1421 <      ServiceStartAddParam(AnsiUpperCase(FBackupFile.Names[i]), isc_spb_bkp_file);
1421 >      SRB.Add(isc_spb_bkp_file).AsString := FBackupFile.Names[i];
1422        value := Copy(FBackupFile[i], Pos('=', FBackupFile[i]) + 1, Length(FBackupFile.Names[i])); {mbcs ok}
1423 <      param := StrToInt(value);
1534 <      ServiceStartAddParam(param, isc_spb_bkp_length);
1423 >      SRB.Add(isc_spb_bkp_length).AsInteger := StrToInt(value);;
1424      end
1425      else
1426 <      ServiceStartAddParam(FBackupFile[i], isc_spb_bkp_file);
1427 <  end;
1426 >      SRB.Add(isc_spb_bkp_file).AsString := FBackupFile[i];
1427 >  end
1428 >  else
1429 >    SRB.Add(isc_spb_bkp_file).AsString := 'stdin';
1430 >
1431    for i := 0 to FDatabaseName.Count - 1 do
1432    begin
1433      if (Trim(FDatabaseName[i]) = '') then continue;
1434      if (Pos('=', FDatabaseName[i]) <> 0) then {mbcs ok}
1435 <    begin
1436 <      ServiceStartAddParam(FDatabaseName.Names[i], SPBConstantValues[isc_spb_dbname]);
1435 >    begin
1436 >      SRB.Add(isc_spb_dbname).AsString := FDatabaseName.Names[i];
1437        value := Copy(FDatabaseName[i], Pos('=', FDatabaseName[i]) + 1, Length(FDatabaseName[i])); {mbcs ok}
1438 <      param := StrToInt(value);
1547 <      ServiceStartAddParam(param, isc_spb_res_length);
1438 >      SRB.Add(isc_spb_res_length).AsInteger :=  StrToInt(value);
1439      end
1440      else
1441 <      ServiceStartAddParam(FDatabaseName[i], SPBConstantValues[isc_spb_dbname]);
1441 >      SRB.Add(isc_spb_dbname).AsString := FDatabaseName[i];
1442    end;
1443   end;
1444  
# Line 1566 | Line 1457 | begin
1457    inherited Destroy;
1458   end;
1459  
1460 + function TIBRestoreService.SendNextChunk(stream: TStream; var line: String
1461 +  ): integer;
1462 + var
1463 +  i: Integer;
1464 + begin
1465 +  Result := 0;
1466 +  line := '';
1467 +  if (FEof = True) then
1468 +    exit;
1469 +
1470 +  if (FAction = 0) then
1471 +    IBError(ibxeQueryParamsError, [nil]);
1472 +
1473 +  SRB.Add(isc_info_svc_line);
1474 +  SRB.Add(isc_info_svc_stdin);
1475 +
1476 +  SQPB.Add(isc_info_svc_timeout).AsInteger := 1;
1477 +  if FSendBytes > 0 then
1478 +    Result := SQPB.Add(isc_info_svc_line).CopyFrom(stream,FSendBytes);
1479 +  InternalServiceQuery;
1480 +
1481 +  FSendBytes := 0;
1482 +  for i := 0 to FServiceQueryResults.Count - 1 do
1483 +  with FServiceQueryResults[i] do
1484 +  begin
1485 +    case getItemType of
1486 +      isc_info_svc_line:
1487 +         line := AsString;
1488 +
1489 +      isc_info_svc_stdin:
1490 +        FSendBytes := AsInteger;
1491 +
1492 +      isc_info_svc_timeout,
1493 +      isc_info_data_not_ready:
1494 +        {ignore};
1495 +    else
1496 +      IBError(ibxeOutputParsingError, [getItemType]);
1497 +    end;
1498 +  end;
1499 +  FEOF := (FSendBytes = 0) and (line = '');
1500 + end;
1501 +
1502   procedure TIBRestoreService.SetBackupFile(const Value: TStrings);
1503   begin
1504    FBackupFile.Assign(Value);
# Line 1593 | Line 1526 | begin
1526   end;
1527  
1528   procedure TIBValidationService.FetchLimboTransactionInfo;
1529 +
1530 +  procedure NextLimboTransaction(index: integer);
1531 +  begin
1532 +    SetLength(FLimboTransactionInfo, index+1);
1533 +    FLimboTransactionInfo[index] := TLimboTransactionInfo.Create;
1534 +    { if no advice commit as default }
1535 +    FLimboTransactionInfo[index].Advise := UnknownAdvise;
1536 +    FLimboTransactionInfo[index].Action:= CommitAction;
1537 +  end;
1538 +
1539   var
1540 <  i, RunLen: Integer;
1540 >  i,j, k: Integer;
1541    Value: Char;
1542   begin
1600  ServiceQueryParams := Char(isc_info_svc_limbo_trans);
1601  InternalServiceQuery;
1602  RunLen := 0;
1603  if (OutputBuffer[RunLen] <> Char(isc_info_svc_limbo_trans)) then
1604    IBError(ibxeOutputParsingError, [nil]);
1605  Inc(RunLen, 3);
1543    for i := 0 to High(FLimboTransactionInfo) do
1544      FLimboTransactionInfo[i].Free;
1545 <  FLimboTransactionInfo := nil;
1546 <  i := 0;
1547 <  while (OutputBuffer[RunLen] <> Char(isc_info_end)) do
1548 <  begin
1549 <    if (i >= Length(FLimboTransactionInfo)) then
1550 <      SetLength(FLimboTransactionInfo, i + 10);
1551 <    if FLimboTransactionInfo[i] = nil then
1552 <      FLimboTransactionInfo[i] := TLimboTransactionInfo.Create;
1553 <    with FLimboTransactionInfo[i] do
1545 >  SetLength(FLimboTransactionInfo,0);
1546 >
1547 >  SRB.Add(isc_info_svc_limbo_trans);
1548 >  InternalServiceQuery;
1549 >
1550 >  k := -1;
1551 >  for i := 0 to FServiceQueryResults.Count - 1 do
1552 >  with FServiceQueryResults[i] do
1553 >  case getItemType of
1554 >  isc_info_svc_limbo_trans:
1555      begin
1556 <      if (OutputBuffer[RunLen] = Char(isc_spb_single_tra_id)) then
1557 <      begin
1558 <        Inc(RunLen);
1621 <        MultiDatabase := False;
1622 <        ID := ParseInteger(RunLen);
1623 <      end
1624 <      else
1556 >      if FServiceQueryResults[i].Count = 0 then continue;
1557 >      NextLimboTransaction(0);
1558 >      for j := 0 to FServiceQueryResults[i].Count - 1 do
1559        begin
1560 <        Inc(RunLen);
1627 <        MultiDatabase := True;
1628 <        ID := ParseInteger(RunLen);
1629 <        HostSite := ParseString(RunLen);
1630 <        if (OutputBuffer[RunLen] <> Char(isc_spb_tra_state)) then
1631 <          IBError(ibxeOutputParsingError, [nil]);
1632 <        Inc(RunLen);
1633 <        Value := OutputBuffer[RunLen];
1634 <        Inc(RunLen);
1635 <        if (Value = Char(isc_spb_tra_state_limbo)) then
1636 <          State := LimboState
1637 <        else
1638 <          if (Value = Char(isc_spb_tra_state_commit)) then
1639 <            State := CommitState
1640 <          else
1641 <            if (Value = Char(isc_spb_tra_state_rollback)) then
1642 <              State := RollbackState
1643 <            else
1644 <              State := UnknownState;
1645 <        RemoteSite := ParseString(RunLen);
1646 <        RemoteDatabasePath := ParseString(RunLen);
1647 <        Value := OutputBuffer[RunLen];
1648 <        Inc(RunLen);
1649 <        if (Value = Char(isc_spb_tra_advise_commit)) then
1560 >        with FServiceQueryResults[i][j] do
1561          begin
1562 <          Advise := CommitAdvise;
1563 <          Action:= CommitAction;
1564 <        end
1565 <        else
1566 <          if (Value = Char(isc_spb_tra_advise_rollback)) then
1567 <          begin
1568 <            Advise := RollbackAdvise;
1569 <            Action := RollbackAction;
1570 <          end
1571 <          else
1572 <          begin
1573 <            { if no advice commit as default }
1574 <            Advise := UnknownAdvise;
1575 <            Action:= CommitAction;
1562 >          case getItemType of
1563 >            isc_spb_single_tra_id:
1564 >            begin
1565 >              Inc(k);
1566 >              if k > 0 then
1567 >                NextLimboTransaction(k);
1568 >              FLimboTransactionInfo[k].MultiDatabase := False;
1569 >              FLimboTransactionInfo[k].ID := AsInteger;
1570 >            end;
1571 >
1572 >            isc_spb_multi_tra_id:
1573 >            begin
1574 >              Inc(k);
1575 >              if k > 0 then
1576 >                NextLimboTransaction(k);
1577 >              FLimboTransactionInfo[k].MultiDatabase := True;
1578 >              FLimboTransactionInfo[k].ID := AsInteger;
1579 >            end;
1580 >
1581 >            isc_spb_tra_host_site:
1582 >              FLimboTransactionInfo[k].HostSite := AsString;
1583 >
1584 >            isc_spb_tra_state:
1585 >              case AsByte of
1586 >                isc_spb_tra_state_limbo:
1587 >                  FLimboTransactionInfo[k].State := LimboState;
1588 >
1589 >                isc_spb_tra_state_commit:
1590 >                  FLimboTransactionInfo[k].State := CommitState;
1591 >
1592 >                isc_spb_tra_state_rollback:
1593 >                  FLimboTransactionInfo[k].State := RollbackState;
1594 >
1595 >                else
1596 >                  FLimboTransactionInfo[k].State := UnknownState;
1597 >              end;
1598 >
1599 >            isc_spb_tra_remote_site:
1600 >              FLimboTransactionInfo[k].RemoteSite := AsString;
1601 >
1602 >            isc_spb_tra_db_path:
1603 >              FLimboTransactionInfo[k].RemoteDatabasePath := AsString;
1604 >
1605 >            isc_spb_tra_advise:
1606 >            with FLimboTransactionInfo[k] do
1607 >            begin
1608 >              case (AsByte) of
1609 >              isc_spb_tra_advise_commit:
1610 >              begin
1611 >                Advise := CommitAdvise;
1612 >                Action:= CommitAction;
1613 >              end;
1614 >
1615 >              isc_spb_tra_advise_rollback:
1616 >              begin
1617 >                Advise := RollbackAdvise;
1618 >                Action := RollbackAction;
1619 >              end;
1620 >
1621 >              else
1622 >                Advise := UnknownAdvise;
1623 >              end;
1624 >            end;
1625 >
1626 >            else
1627 >              IBError(ibxeOutputParsingError, [getItemType]);
1628            end;
1629 +        end;
1630        end;
1667      Inc (i);
1631      end;
1632 +  else
1633 +    IBError(ibxeOutputParsingError, [getItemType]);
1634    end;
1670  if (i > 0) then
1671    SetLength(FLimboTransactionInfo, i+1);
1635   end;
1636  
1637   procedure TIBValidationService.FixLimboTransactionErrors;
1638   var
1639    i: Integer;
1640   begin
1641 <  ServiceStartParams  := Char(isc_action_svc_repair);
1642 <  ServiceStartAddParam (FDatabaseName, SPBConstantValues[isc_spb_dbname]);
1643 <  if (FGlobalAction = NoGlobalAction) then
1644 <  begin
1682 <    i := 0;
1683 <    while (FLimboTransactionInfo[i].ID <> 0) do
1641 >  SRB.Add(isc_action_svc_repair);
1642 >  SRB.Add(isc_spb_dbname).AsString := FDatabaseName;
1643 >  case FGlobalAction of
1644 >  NoGlobalAction:
1645      begin
1646 <      if (FLimboTransactionInfo[i].Action = CommitAction) then
1686 <        ServiceStartAddParam (FLimboTransactionInfo[i].ID, isc_spb_rpr_commit_trans)
1687 <      else
1688 <        ServiceStartAddParam (FLimboTransactionInfo[i].ID, isc_spb_rpr_rollback_trans);                              
1689 <      Inc(i);
1690 <    end;
1691 <  end
1692 <  else
1693 <  begin
1694 <    i := 0;
1695 <    if (FGlobalAction = CommitGlobal) then
1696 <      while (FLimboTransactionInfo[i].ID <> 0) do
1646 >      for i := 0 to LimboTransactionInfoCount - 1 do
1647        begin
1648 <        ServiceStartAddParam (FLimboTransactionInfo[i].ID, isc_spb_rpr_commit_trans);
1649 <        Inc(i);
1650 <      end
1651 <    else
1652 <      while (FLimboTransactionInfo[i].ID <> 0) do
1648 >        if (FLimboTransactionInfo[i].Action = CommitAction) then
1649 >          SRB.Add(isc_spb_rpr_commit_trans).AsInteger :=  FLimboTransactionInfo[i].ID
1650 >        else
1651 >          SRB.Add(isc_spb_rpr_rollback_trans).AsInteger :=  FLimboTransactionInfo[i].ID;
1652 >      end;
1653 >    end;
1654 >
1655 >  CommitGlobal:
1656 >    begin
1657 >      for i := 0 to LimboTransactionInfoCount - 1 do
1658 >        SRB.Add(isc_spb_rpr_commit_trans).AsInteger :=  FLimboTransactionInfo[i].ID;
1659 >    end;
1660 >
1661 >    RollbackGlobal:
1662        begin
1663 <        ServiceStartAddParam (FLimboTransactionInfo[i].ID, isc_spb_rpr_rollback_trans);
1664 <        Inc(i);
1663 >        for i := 0 to LimboTransactionInfoCount - 1 do
1664 >          SRB.Add(isc_spb_rpr_rollback_trans).AsInteger :=  FLimboTransactionInfo[i].ID;
1665        end;
1666 +
1667 +    RecoverTwoPhaseGlobal:
1668 +    begin
1669 +      for i := 0 to LimboTransactionInfoCount - 1 do
1670 +        SRB.Add(isc_spb_rpr_recover_two_phase).AsInteger :=  FLimboTransactionInfo[i].ID;
1671 +    end;
1672    end;
1673    InternalServiceStart;
1674   end;
# Line 1718 | Line 1683 | end;
1683  
1684   function TIBValidationService.GetLimboTransactionInfoCount: integer;
1685   begin
1686 <  Result := High(FLimboTransactionInfo);
1686 >  Result := Length(FLimboTransactionInfo);
1687   end;
1688  
1689   procedure TIBValidationService.SetDatabaseName(const Value: string);
# Line 1733 | Line 1698 | begin
1698    Action := isc_action_svc_repair;
1699    if FDatabaseName = '' then
1700      IBError(ibxeStartParamsError, [nil]);
1701 +  SRB.Add(isc_action_svc_repair);
1702 +  SRB.Add(isc_spb_dbname).AsString := FDatabaseName;
1703    param := 0;
1704    if (SweepDB in Options) then
1705      param := param or isc_spb_rpr_sweep_db;
1706    if (ValidateDB in Options) then
1707      param := param or isc_spb_rpr_validate_db;
1708 <  ServiceStartParams  := Char(isc_action_svc_repair);
1742 <  ServiceStartAddParam (FDatabaseName, SPBConstantValues[isc_spb_dbname]);
1743 <  if param > 0 then
1744 <    ServiceStartAddParam (param, SPBConstantValues[isc_spb_options]);
1745 <  param := 0;
1708 >
1709    if (LimboTransactions in Options) then
1710      param := param or isc_spb_rpr_list_limbo_trans;
1711    if (CheckDB in Options) then
# Line 1760 | Line 1723 | begin
1723         param := param or isc_spb_rpr_validate_db;
1724    end;
1725    if param > 0 then
1726 <    ServiceStartAddParam (param, SPBConstantValues[isc_spb_options]);
1726 >   SRB.Add(isc_spb_options).AsInteger := param;
1727   end;
1728  
1729   { TIBSecurityService }
# Line 1782 | Line 1745 | end;
1745  
1746   procedure TIBSecurityService.FetchUserInfo;
1747   var
1748 <  i, RunLen: Integer;
1748 >  i, j, k: Integer;
1749   begin
1750 <  ServiceQueryParams := Char(isc_info_svc_get_users);
1750 >  SRB.Add(isc_info_svc_get_users);
1751    InternalServiceQuery;
1752 <  RunLen := 0;
1790 <  if (OutputBuffer[RunLen] <> Char(isc_info_svc_get_users)) then
1791 <    IBError(ibxeOutputParsingError, [nil]);
1792 <  Inc(RunLen);
1752 >
1753    for i := 0 to High(FUserInfo) do
1754      FUserInfo[i].Free;
1755 <  FUserInfo := nil;
1756 <  i := 0;
1757 <  { Don't have any use for the combined length
1758 <   so increment past by 2 }
1759 <  Inc(RunLen, 2);
1760 <  while (OutputBuffer[RunLen] <> Char(isc_info_end)) do
1761 <  begin
1762 <    if (i >= Length(FUSerInfo)) then
1763 <      SetLength(FUserInfo, i + 10);
1764 <    if (OutputBuffer[RunLen] <> Char(isc_spb_sec_username)) then
1765 <      IBError(ibxeOutputParsingError, [nil]);
1766 <    Inc(RunLen);
1767 <    if FUserInfo[i] = nil then
1768 <      FUserInfo[i] := TUserInfo.Create;
1769 <    FUserInfo[i].UserName := ParseString(RunLen);
1770 <    if (OutputBuffer[RunLen] <> Char(isc_spb_sec_firstname)) then
1771 <      IBError(ibxeOutputParsingError, [nil]);
1772 <    Inc(RunLen);
1773 <    FUserInfo[i].FirstName := ParseString(RunLen);
1774 <    if (OutputBuffer[RunLen] <> Char(isc_spb_sec_middlename)) then
1775 <      IBError(ibxeOutputParsingError, [nil]);
1776 <    Inc(RunLen);
1777 <    FUserInfo[i].MiddleName := ParseString(RunLen);
1778 <    if (OutputBuffer[RunLen] <> Char(isc_spb_sec_lastname)) then
1779 <      IBError(ibxeOutputParsingError, [nil]);
1780 <    Inc(RunLen);
1781 <    FUserInfo[i].LastName := ParseString(RunLen);
1782 <    if (OutputBuffer[RunLen] <> Char(isc_spb_sec_userId)) then
1783 <      IBError(ibxeOutputParsingError, [nil]);
1784 <    Inc(RunLen);
1785 <    FUserInfo[i].UserId := ParseInteger(RunLen);
1786 <    if (OutputBuffer[RunLen] <> Char(isc_spb_sec_groupid)) then
1787 <      IBError(ibxeOutputParsingError, [nil]);
1788 <    Inc(RunLen);
1789 <    FUserInfo[i].GroupID := ParseInteger(RunLen);
1790 <    Inc (i);
1755 >  for i := 0 to FServiceQueryResults.Count - 1 do
1756 >  with FServiceQueryResults[i] do
1757 >  begin
1758 >    case getItemType of
1759 >    isc_info_svc_get_users:
1760 >      begin
1761 >        SetLength(FUserInfo,1);
1762 >        k := 0;
1763 >        FUserInfo[0] := TUserInfo.Create;
1764 >        FUserInfo[0].UserName := '';
1765 >        for j := 0 to FServiceQueryResults[i].Count - 1 do
1766 >        begin
1767 >          with FServiceQueryResults[i][j] do
1768 >          case getItemType of
1769 >          isc_spb_sec_username:
1770 >            begin
1771 >              if FUserInfo[k].UserName <> '' then
1772 >              begin
1773 >                Inc(k);
1774 >                SetLength(FUserInfo,k+1);
1775 >                if FUserInfo[k] = nil then
1776 >                  FUserInfo[k] := TUserInfo.Create;
1777 >              end;
1778 >              FUserInfo[k].UserName := AsString;
1779 >            end;
1780 >
1781 >          isc_spb_sec_firstname:
1782 >            FUserInfo[k].FirstName := AsString;
1783 >
1784 >          isc_spb_sec_middlename:
1785 >            FUserInfo[k].MiddleName := AsString;
1786 >
1787 >          isc_spb_sec_lastname:
1788 >            FUserInfo[k].LastName := AsString;
1789 >
1790 >          isc_spb_sec_userId:
1791 >            FUserInfo[k].UserId := AsInteger;
1792 >
1793 >          isc_spb_sec_groupid:
1794 >            FUserInfo[k].GroupID := AsInteger;
1795 >
1796 >          else
1797 >            IBError(ibxeOutputParsingError, [getItemType]);
1798 >          end;
1799 >        end;
1800 >      end;
1801 >    else
1802 >      IBError(ibxeOutputParsingError, [getItemType]);
1803 >    end;
1804    end;
1832  if (i > 0) then
1833    SetLength(FUserInfo, i+1);
1805   end;
1806  
1807   function TIBSecurityService.GetUserInfo(Index: Integer): TUserInfo;
# Line 1843 | Line 1814 | end;
1814  
1815   function TIBSecurityService.GetUserInfoCount: Integer;
1816   begin
1817 <  Result := Max(High(FUSerInfo),0);
1817 >  Result := Length(FUserInfo);
1818   end;
1819  
1820   procedure TIBSecurityService.AddUser;
# Line 1861 | Line 1832 | end;
1832   procedure TIBSecurityService.DisplayUsers;
1833   begin
1834    SecurityAction := ActionDisplayUser;
1835 <  ServiceStartParams  := Char(isc_action_svc_display_user);
1835 >  SRB.Add(isc_action_svc_display_user);
1836    InternalServiceStart;
1837    FetchUserInfo;
1838   end;
# Line 1869 | Line 1840 | end;
1840   procedure TIBSecurityService.DisplayUser(UserName: String);
1841   begin
1842    SecurityAction := ActionDisplayUser;
1843 <  ServiceStartParams  := Char(isc_action_svc_display_user);
1844 <  ServiceStartAddParam (UserName, isc_spb_sec_username);
1843 >  SRB.Add(isc_action_svc_display_user);
1844 >  SRB.Add(isc_spb_sec_username).AsString := UserName;
1845    InternalServiceStart;
1846    FetchUserInfo;
1847   end;
# Line 1955 | Line 1926 | begin
1926        Len := Length(FUserName);
1927        if (Len = 0) then
1928          IBError(ibxeStartParamsError, [nil]);
1929 <      ServiceStartParams  := Char(isc_action_svc_add_user);
1930 <      ServiceStartAddParam (FSQLRole, SPBConstantValues[isc_spb_sql_role_name]);
1931 <      ServiceStartAddParam (FUserName, isc_spb_sec_username);
1932 <      ServiceStartAddParam (FUserID, isc_spb_sec_userid);
1933 <      ServiceStartAddParam (FGroupID, isc_spb_sec_groupid);
1934 <      ServiceStartAddParam (FPassword, isc_spb_sec_password);
1935 <      ServiceStartAddParam (FFirstName, isc_spb_sec_firstname);
1936 <      ServiceStartAddParam (FMiddleName, isc_spb_sec_middlename);
1937 <      ServiceStartAddParam (FLastName, isc_spb_sec_lastname);
1929 >      SRB.Add(isc_action_svc_add_user);
1930 >      SRB.Add(isc_spb_sec_username).AsString := FUserName;
1931 >      SRB.Add(isc_spb_sql_role_name).AsString := FSQLRole;
1932 >      SRB.Add(isc_spb_sec_userid).AsInteger := FUserID;
1933 >      SRB.Add(isc_spb_sec_groupid).AsInteger := FGroupID;
1934 >      SRB.Add(isc_spb_sec_password).AsString := FPassword;
1935 >      SRB.Add(isc_spb_sec_firstname).AsString := FFirstName;
1936 >      SRB.Add(isc_spb_sec_middlename).AsString := FMiddleName;
1937 >      SRB.Add(isc_spb_sec_lastname).AsString := FLastName;
1938      end;
1939      ActionDeleteUser:
1940      begin
# Line 1971 | Line 1942 | begin
1942        Len := Length(FUserName);
1943        if (Len = 0) then
1944          IBError(ibxeStartParamsError, [nil]);
1945 <      ServiceStartParams  := Char(isc_action_svc_delete_user);
1946 <      ServiceStartAddParam (FSQLRole, SPBConstantValues[isc_spb_sql_role_name]);
1947 <      ServiceStartAddParam (FUserName, isc_spb_sec_username);
1945 >      SRB.Add(isc_action_svc_delete_user);
1946 >      SRB.Add(isc_spb_sec_username).AsString := FUserName;
1947 >      SRB.Add(isc_spb_sql_role_name).AsString := FSQLRole;
1948      end;
1949      ActionModifyUser:
1950      begin
# Line 1981 | Line 1952 | begin
1952        Len := Length(FUserName);
1953        if (Len = 0) then
1954          IBError(ibxeStartParamsError, [nil]);
1955 <      ServiceStartParams  := Char(isc_action_svc_modify_user);
1956 <      ServiceStartAddParam (FSQLRole, SPBConstantValues[isc_spb_sql_role_name]);
1957 <      ServiceStartAddParam (FUserName, isc_spb_sec_username);
1955 >      SRB.Add(isc_action_svc_modify_user);
1956 >      SRB.Add(isc_spb_sec_username).AsString := FUserName;
1957 >      SRB.Add(isc_spb_sql_role_name).AsString := FSQLRole;
1958        if (ModifyUserId in FModifyParams) then
1959 <        ServiceStartAddParam (FUserID, isc_spb_sec_userid);
1959 >        SRB.Add(isc_spb_sec_userid).AsInteger := FUserID;
1960        if (ModifyGroupId in FModifyParams) then
1961 <        ServiceStartAddParam (FGroupID, isc_spb_sec_groupid);
1961 >        SRB.Add(isc_spb_sec_groupid).AsInteger := FGroupID;
1962        if (ModifyPassword in FModifyParams) then
1963 <        ServiceStartAddParam (FPassword, isc_spb_sec_password);
1963 >        SRB.Add(isc_spb_sec_password).AsString := FPassword;
1964        if (ModifyFirstName in FModifyParams) then
1965 <        ServiceStartAddParam (FFirstName, isc_spb_sec_firstname);
1965 >        SRB.Add(isc_spb_sec_firstname).AsString := FFirstName;
1966        if (ModifyMiddleName in FModifyParams) then
1967 <        ServiceStartAddParam (FMiddleName, isc_spb_sec_middlename);
1967 >        SRB.Add(isc_spb_sec_middlename).AsString := FMiddleName;
1968        if (ModifyLastName in FModifyParams) then
1969 <        ServiceStartAddParam (FLastName, isc_spb_sec_lastname);
1969 >        SRB.Add(isc_spb_sec_lastname).AsString := FLastName;
1970      end;
1971    end;
1972    ClearParams;
1973   end;
1974  
1975   { TIBUnStructuredService }
1976 < constructor TIBControlAndQueryService.Create(AOwner: TComponent);
1976 > constructor TIBControlAndQueryService.create(AOwner: TComponent);
1977   begin
1978    inherited Create(AOwner);
1979    FEof := False;
# Line 2018 | Line 1989 | end;
1989  
1990   function TIBControlAndQueryService.GetNextChunk: String;
1991   var
1992 <  Length: Integer;
1992 >  i: Integer;
1993   begin
1994    if (FEof = True) then
1995    begin
# Line 2027 | Line 1998 | begin
1998    end;
1999    if (FAction = 0) then
2000      IBError(ibxeQueryParamsError, [nil]);
2001 <  ServiceQueryParams := Char(isc_info_svc_to_eof);
2001 >
2002 >  SRB.Add(isc_info_svc_to_eof);
2003    InternalServiceQuery;
2004 <  if (OutputBuffer[0] <> Char(isc_info_svc_to_eof)) then
2005 <    IBError(ibxeOutputParsingError, [nil]);
2006 <  Length := isc_vax_integer(OutputBuffer + 1, 2);
2007 <  if (OutputBuffer[3 + Length] = Char(isc_info_truncated)) then
2008 <    FEof := False
2009 <  else
2010 <    if (OutputBuffer[3 + Length] = Char(isc_info_end)) then
2011 <      FEof := True
2004 >
2005 >  FEof := True;
2006 >  for i := 0 to FServiceQueryResults.Count - 1 do
2007 >  with FServiceQueryResults[i] do
2008 >  begin
2009 >    case getItemType of
2010 >      isc_info_svc_to_eof:
2011 >        Result := AsString;
2012 >
2013 >      isc_info_truncated:
2014 >        FEof := False;
2015      else
2016 <      IBError(ibxeOutputParsingError, [nil]);
2017 <  OutputBuffer[3 + Length] := #0;
2018 <  result := String(PChar(@OutputBuffer[3]));
2016 >      IBError(ibxeOutputParsingError, [getItemType]);
2017 >    end;
2018 >  end;
2019   end;
2020  
2021 < function TIBControlAndQueryService.GetNextLine: String;
2021 > function TIBControlAndQueryService.WriteNextChunk(stream: TStream): integer;
2022   var
2023 <  Length: Integer;
2023 >  i: Integer;
2024   begin
2025 +  result := 0;
2026    if (FEof = True) then
2051  begin
2052    result := '';
2027      exit;
2054  end;
2028    if (FAction = 0) then
2029      IBError(ibxeQueryParamsError, [nil]);
2030 <  ServiceQueryParams := Char(isc_info_svc_line);
2030 >
2031 >  SQPB.Add(isc_info_svc_timeout).AsInteger := 1;
2032 >  SRB.Add(isc_info_svc_to_eof);
2033    InternalServiceQuery;
2034 <  if (OutputBuffer[0] <> Char(isc_info_svc_line)) then
2035 <    IBError(ibxeOutputParsingError, [nil]);
2036 <  Length := isc_vax_integer(OutputBuffer + 1, 2);
2037 <  if (OutputBuffer[3 + Length] <> Char(isc_info_end)) then
2063 <    IBError(ibxeOutputParsingError, [nil]);
2064 <  if (length <> 0) then
2065 <    FEof := False
2066 <  else
2034 >
2035 >  FEof := True;
2036 >  for i := 0 to FServiceQueryResults.Count - 1 do
2037 >  with FServiceQueryResults[i] do
2038    begin
2039 <    result := '';
2040 <    FEof := True;
2039 >    case getItemType of
2040 >      isc_info_svc_to_eof:
2041 >      begin
2042 >        Result := CopyTo(stream,0);
2043 >        FEof := Result = 0;
2044 >      end;
2045 >
2046 >      isc_info_truncated:
2047 >        FEof := False;
2048 >
2049 >      isc_info_svc_timeout:
2050 >        {ignore};
2051 >    else
2052 >      IBError(ibxeOutputParsingError, [getItemType]);
2053 >    end;
2054 >  end;
2055 > end;
2056 >
2057 > function TIBControlAndQueryService.GetNextLine: String;
2058 > var
2059 >  i: Integer;
2060 > begin
2061 >  Result := '';
2062 >  if (FEof = True) then
2063      exit;
2064 +
2065 +  if (FAction = 0) then
2066 +    IBError(ibxeQueryParamsError, [nil]);
2067 +
2068 +  SRB.Add(isc_info_svc_line);
2069 +  InternalServiceQuery;
2070 +
2071 +  for i := 0 to FServiceQueryResults.Count - 1 do
2072 +  with FServiceQueryResults[i] do
2073 +  begin
2074 +    case getItemType of
2075 +      isc_info_svc_line:
2076 +         Result := AsString;
2077 +    else
2078 +      IBError(ibxeOutputParsingError, [getItemType]);
2079 +    end;
2080    end;
2081 <  OutputBuffer[3 + Length] := #0;
2073 <  result := String(PChar(@OutputBuffer[3]));
2081 >  FEOF := Result = '';
2082   end;
2083  
2084   { TIBLogService }
# Line 2078 | Line 2086 | end;
2086   procedure TIBLogService.SetServiceStartOptions;
2087   begin
2088    Action := isc_action_svc_get_ib_log;
2089 <  ServiceStartParams  := Char(isc_action_svc_get_ib_log);
2089 >  SRB.Add(isc_action_svc_get_ib_log);
2090   end;
2091  
2092   { TDatabaseInfo }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines