stnet.pas

条码控件： 一维条码控件 二维条码控件 PDF417Barcode MaxiCodeBarcode

      read GetLockOutDuration write SetLockOutDuration;
    property LockoutObservationWindow: DWord
      read GetLockoutObservationWindow write SetLockoutObservationWindow;
    property LockoutThreshold      : DWord
      read GetLockoutThreshold write SetLockoutThreshold;

    property User[AName: string] : TStNetUserItem
      read GetUser;
    property Group[AName: string] : TStNetGroupItem
      read GetGroup;
    property Drives : TStringList
      read GetDriveList;
    property Users: TStringList
      read GetUserList;
    property Groups: TStringList
      read GetGroupList;
    property Shares: TStringList
      read GetShareList;
  end;

  TStNetwork = class(TObject)
   private
    FList : TStringList;
   protected
    function GetServer(AServer: string): TStNetServerItem;
    function GetUser(AServer, AName: string): TStNetUserItem;
    function GetGroup(AServer, AName: string): TStNetGroupItem;
    function GetPrimaryDC(ADomain: string): TStNetServerItem;
   public
    constructor Create;
    destructor Destroy; override;

    property Server[AServer: string] : TStNetServerItem
      read GetServer;
    property User[AServer, AName: string]: TStNetUserItem
      read GetUser;
    property Group[AServer, AName: string]: TStNetGroupItem
      read GetGroup;
    property PrimaryDC[ADomain: string] : TStNetServerItem
      read GetPrimaryDC;
  end;

var
  StNetwork : TStNetwork;

implementation

uses SysUtils, StUtils, StSystem, StStrS;

{ --- TStNetItem ------------------------------------------------------------ }
constructor TStNetItem.Create;
begin
  { don't allow manual creation of this object }
  RaiseStError(EStNetException, stscNetNoManualCreate);
end;

constructor TStNetItem.CreateEx(AName, AComment, AServer: string;
                                AItemType: TStNetItemType);
begin
  inherited Create;
  FName := AName;
  FComment := AComment;
  FServer := AServer;
  FItemType := AItemType;
  FNetwork := nil;
end;

destructor TStNetItem.Destroy;
begin
  inherited Destroy;
end;

{ --- TStNetUserItem -------------------------------------------------------- }

constructor TStNetUserItem.CreateEx(AName, AComment, AServer: string;
                                    AItemType: TStNetItemType);
var
  ErrorD : DWord;
  Flags  : DWord;
begin
  inherited CreateEx(AName, AComment, AServer, AItemType);
  FGroupList := TStringList.Create;
  FUserData  := nil;

  { need to find out what type of user this is }
  if (AItemType = nitUnknown) then begin
    ErrorD := StNetUserGetInfo(FServer, FName, 3, FUserData);
    if ErrorD = NERR_SUCCESS then begin
      Flags := TUSER_INFO_3(FUserData^).usri3_flags;
      if LongFlagIsSet(Flags, UF_TEMP_DUPLICATE_ACCOUNT) then
        FItemType := nitLocalUser
      else if LongFlagIsSet(Flags, UF_NORMAL_ACCOUNT) then
        FItemType := nitGlobalUser
      else if LongFlagIsSet(Flags, UF_INTERDOMAIN_TRUST_ACCOUNT) then
        FItemType := nitInterdomainTrust
      else if LongFlagIsSet(Flags, UF_WORKSTATION_TRUST_ACCOUNT) then
        FItemType := nitWorkstationTrust
      else if LongFlagIsSet(Flags, UF_SERVER_TRUST_ACCOUNT) then
        FItemType := nitServerTrust;

      FComment := TUSER_INFO_3(FUserData^).usri3_comment;
      FID      := TUSER_INFO_3(FUserData^).usri3_user_id;
      FFullName:= TUSER_INFO_3(FUserData^).usri3_full_name;
    end else begin
      RaiseStWin32Error(EStNetException, ErrorD);
    end;
  end;
end;

constructor TStNetUserItem.CreateExEnum(AName, AComment, AServer,
                                        AFullName: string; AGlobal: Boolean;
                                        AID: Cardinal);
begin
  inherited CreateEx(AName, AComment, AServer, nitUnknown);
  FGroupList := TStringList.Create;

  FFullName := AFullName;
  FID       := AID;

  if AGlobal then
    FItemType := nitGlobalUser
  else
    FItemType := nitLocalUser;
end;

destructor TStNetUserItem.Destroy;
begin
  FGroupList.Free;

  if (FSidRecord.Value <> nil) then
    StNetApiBufferFree(FSidRecord.Value);

  if (FUserData <> nil) then
    StNetApiBufferFree(FUserData);

  inherited Destroy;
end;

function TStNetUserItem.GetGroupItemList: TStringList;
var
  NewList      : TStringList;
  ErrorD       : DWord;
  Index        : Integer;
  Buffer       : Pointer;
  EntriesRead  : DWord;
  TotalEntries : DWord;
  S            : TStNetServerItem;
  NewItem      : TStNetGroupItem;
  CurrentName  : string;
begin
  NewList := TStringList.Create;
  try
    { get the list of global groups that this user belongs to }
    ErrorD := StNetUserGetGroups(FServer, FName, 0, Buffer, DWord(-1),
                                 EntriesRead, TotalEntries);
    if ErrorD = NERR_SUCCESS then begin
      try
        if EntriesRead > 0 then begin                                  {!!.02}
          for Index := 0 to EntriesRead-1 do begin
            CurrentName := TGroupUsersInfo0Array(Buffer^)[Index].grui0_name;
            { does this group already exist in the servers list of groups }
            NewItem := nil;
            if (FNetwork <> nil) then begin
              S := FNetwork.Server[FServer];
              NewItem := S.Group[CurrentName];
              NewItem.FItemType := nitGlobalGroup;
            end;

            if (NewItem = nil) then begin
              NewItem := TStNetGroupItem.CreateEx(CurrentName, '', FServer,
                                                  nitGlobalGroup);
              NewItem.FNetwork := FNetwork;
            end;
            NewList.AddObject(CurrentName, NewItem);
          end;
        end;                                                           {!!.02}
      finally
        StNetApiBufferFree(Buffer);
        Buffer := nil;
      end;
    end else begin
      RaiseStWin32Error(EStNetException, ErrorD);
    end;

    { get the list of local groups that this user belongs to }
    ErrorD := StNetUserGetLocalGroups(FServer, FName, 0, 0, Buffer,
                               DWord(-1), EntriesRead, TotalEntries);
    if ErrorD = NERR_SUCCESS then begin
      try
        if EntriesRead > 0 then begin                                  {!!.02}
          for Index := 0 to EntriesRead-1 do begin
            CurrentName := TLocalGroupUsersInfo0Array(Buffer^)[Index].lgrui0_name;
            { does this group already exist in the servers list of groups }
            NewItem := nil;
            if (FNetwork <> nil) then begin
              S := FNetwork.Server[FServer];
              NewItem := S.Group[CurrentName];
              NewItem.FItemType := nitLocalGroup;
            end;

            if (NewItem = nil) then begin
              NewItem := TStNetGroupItem.CreateEx(CurrentName, '', FServer,
                                                  nitLocalGroup);
              NewItem.FNetwork := FNetwork;
            end;
            NewList.AddObject(CurrentName, NewItem);
          end;
        end;                                                           {!!.02}
      finally
        StNetApiBufferFree(Buffer);
        Buffer := nil;
      end;
    end else begin
      RaiseStWin32Error(EStNetException, ErrorD);
    end;

    FGroupList.Assign(NewList);
  finally
    NewList.Free;
  end;
  Result := FGroupList as TStringList
end;

function TStNetUserItem.GetPrimaryGroup: TStNetItem;
var
  GList : TStringList;
  I : Integer;
begin
  GList := Groups;
  Result := nil;
  for I := 0 to GList.Count -1 do begin
    if TStNetGroupItem(GList.Objects[I]).ID = TUSER_INFO_3(FUserData^).usri3_primary_group_id then begin
      Result := TStNetItem(GList.Objects[I]);
      Exit;
    end;
  end;
end;

function TStNetUserItem.GetDomain: string;
begin
  if (FSidRecord.Value = nil) then begin
    FSidRecord := GetSid;
  end;
  Result := FDomain;
end;

function TStNetUserItem.GetSid: TStSidRecord;
var
  NoError: Boolean;
  _SidUse: DWord;
  Index  : Integer;
begin
  if (FSidRecord.Value = nil) then begin
    NoError := StLookupAccountName(FServer, FName, FSidRecord.Value,
                                   FSidRecord.Length, FDomain, _SidUse);
    if NoError then begin
      { and the SID usage flag to the enumeration }
      FSidRecord.Usage := TStNetSidType(_SidUse);

      { convert the sid to a readable string }
      FSidRecord.ValueS :=
        Format('S-1-%d',
            [TSIDIdentifierAuthority(
               StGetSidIdentifierAuthority(FSidRecord.Value)^).Value[5]]);

          for Index := 0 to StGetSidSubAuthorityCount(FSidRecord.Value) - 1 do begin
            FSidRecord.ValueS :=
              Format(FSidRecord.ValueS + '-%d', [StGetSidSubAuthority(
                                                  FSidRecord.Value, Index)]);
          end;
    end else begin
      RaiseStWin32Error(EStNetException, GetLastError);
    end;
  end;
  Result := FSidRecord;
end;

procedure TStNetUserItem.Refresh;
var
  ErrorD  : DWord;
  Buffer  : Pointer;
begin
  { get the account name, comment and ID for the item }
  ErrorD := StNetUserGetInfo(FServer, FName, 3, Buffer);
  if ErrorD = NERR_SUCCESS then begin
    StNetApiBufferFree(FUserData);
    FUserData := Buffer;

    FComment := TUSER_INFO_3(FUserData^).usri3_comment;
    FID      := TUSER_INFO_3(FUserData^).usri3_user_id;

    if LongFlagIsSet(TUSER_INFO_3(FUserData^).usri3_flags, UF_NORMAL_ACCOUNT) then
      FItemType := nitGlobalUser
    else if LongFlagIsSet(TUSER_INFO_3(FUserData^).usri3_flags, UF_TEMP_DUPLICATE_ACCOUNT) then
      FItemType := nitLocalUser
    else
      FItemType := nitUnknown;
  end else begin
    RaiseStWin32Error(EStNetException, ErrorD);
  end;
end;

procedure TStNetUserItem.AddToGroup(AGroup : TStNetItem);
var
  ErrorD : DWord;
begin
  if AGroup.ItemType = nitGlobalGroup then begin
    ErrorD := StNetGroupAddUser(AGroup.Server, AGroup.Name, FName);
    if ErrorD = NERR_SUCCESS then begin
      if FGroupList.IndexOf(AGroup.Name) < 0 then
        FGroupList.AddObject(AGroup.Name, AGroup);
    end else begin
      RaiseStWin32Error(EStNetException, ErrorD);
    end;
  end else if AGroup.ItemType = nitLocalGroup then begin
    ErrorD := StNetLocalGroupAddMembers(FServer, AGroup.Name, 0, Sid.Value, 1);
    if ErrorD = NERR_SUCCESS then begin
      if FGroupList.IndexOf(AGroup.Name) < 0 then
        FGroupList.AddObject(AGroup.Name, AGroup);
    end else begin
      RaiseStWin32Error(EStNetException, ErrorD);
    end;
  end else begin
    RaiseStError(EStNetException, stscNetGroupNotSpecified);
  end;
end;

procedure TStNetUserItem.RemoveFromGroup(AGroup: TStNetItem);
var
  ErrorD : DWord;
begin
  if AGroup.ItemType = nitGlobalGroup then begin
    ErrorD := StNetGroupDelUser(FServer, AGroup.Name, FName);
    if ErrorD = NERR_SUCCESS then begin
      FGroupList.Delete(FGroupList.IndexOf(AGroup.Name));
    end else begin
      RaiseStWin32Error(EStNetException, ErrorD);
    end;
  end else if AGroup.ItemType = nitLocalGroup then begin
    ErrorD := StNetLocalGroupDelMembers(AGroup.Server, AGroup.Name, 0, Sid.Value, 1);
    if ErrorD = NERR_SUCCESS then begin
    FGroupList.Delete(FGroupList.IndexOf(AGroup.Name));
    end else begin
      RaiseStWin32Error(EStNetException, ErrorD);
    end;
  end else begin
    RaiseStError(EStNetException, stscNetGroupNotSpecified);
  end;
end;

procedure TStNetUserItem.Delete;
  { removes this user from the server }
var
  ErrorD : DWord;
  S : TStNetServerItem;
begin
  { remove from the server }
  ErrorD := StNetUserDel(FServer, FName);
  if ErrorD = NERR_SUCCESS then begin
    if FNetwork <> nil then begin
      S := FNetwork.Server[FServer];
      S.FUserList.Objects[S.FUserList.IndexOf(FName)] := nil;
      S.FUserList.Delete(S.FUserList.IndexOf(FName));
    end;
    Free;
  end else begin
    RaiseStWin32Error(EStNetException, ErrorD);
  end;
end;

function TStNetUserItem.GetAccountDisabled: Boolean;
var
  Data : DWord;
begin
  if (FUserData = nil) then
    Refresh;
  Data := TUSER_INFO_3(FUserData^).usri3_flags;
  Result := LongFlagIsSet(Data, UF_ACCOUNTDISABLE);
end;

function TStNetUserItem.GetAccountExpires: TStDateTimeRec;
var
  Data : DWord;
begin
  if (FUserData = nil) then
    Refresh;
  Data := TUSER_INFO_3(FUserData^).usri3_acct_expires;
  if Data = TIMEQ_FOREVER then begin
    Result.D := 0;
    Result.T := 0;
  end else
    Result := GlobalDateTimeToLocal(UnixTimeToStDateTime(Data), 0);
end;

function TStNetUserItem.GetBadPasswordCount: Cardinal;
begin
  if (FUserData = nil) then
    Refresh;
  Result := TUSER_INFO_3(FUserData^).usri3_bad_pw_count;
end;

function TStNetUserItem.GetFullName: string;
begin
  if (FUserData = nil) then