stnet.pas

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

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

  inherited Destroy;
end;

function TStNetGroupItem.GetGroupItemList: TStringList;

  function JustDomain(Value: string): string;
  begin
    Result := StrStCopyS(Value, 1, Pos('\', Value)-1);
  end;

  function JustName(Value: string): string;
  begin
    Result := StrStCopyS(Value, Pos('\', Value)+1, Length(Value));
  end;

var
  NewList      : TStringList;
  ErrorD       : DWord;
  Index        : Integer;
  Buffer       : Pointer;
  DBuffer      : string;
  EntriesRead  : DWord;
  TotalEntries : DWord;
  S            : TStNetServerItem;
  NewItem      : TStNetItem;
  CurrentName  : string;
  CurrentDandN : string;
  CurrentDomain: string;
begin
  NewList := TStringList.Create;
  try
    { get the list of items that this group has }
    case ItemType of
      nitGlobalGroup :
        begin
          ErrorD := StNetGroupGetUsers(FServer, FName, 0, Buffer, DWord(-1),
                                       EntriesRead, TotalEntries, nil);
          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.User[CurrentName];
                  end;

                  if (NewItem = nil) then begin
                    NewItem := TStNetUserItem.CreateEx(CurrentName, '', FServer,
                                                       nitUnknown);
                    NewItem.FNetwork := FNetwork;
                  end;
                  NewList.AddObject(CurrentName, NewItem);
                end;
              end;                                                     {!!.02}
            finally
              StNetApiBufferFree(Buffer);
              Buffer := nil;
            end;
          end else begin
            RaiseStWin32Error(EStNetException, ErrorD);
          end;
        end;
      nitLocalGroup :
        begin
          ErrorD := StNetLocalGroupGetMembers(FServer, FName, 2, Buffer,
                                              DWord(-1), EntriesRead,
                                              TotalEntries, nil);
          if ErrorD = NERR_SUCCESS then begin
            try
              if EntriesRead > 0 then begin                            {!!.02}
                for Index := 0 to EntriesRead-1 do begin
                  CurrentDandN := TLocalGroupMembersInfo2Array(Buffer^)[Index].lgrmi2_domainandname;
                  CurrentDomain := JustDomain(CurrentDandN);
                  CurrentName  := JustName(CurrentDandN);

                  if (UpperCase(CurrentDomain) <> UpperCase(FServer)) and
                     (UpperCase(CurrentDomain) <> 'NT AUTHORITY') then begin

                    ErrorD := StNetGetDCName('', CurrentDomain, DBuffer);
                    if ErrorD = NERR_SUCCESS then
                      CurrentDomain := FilterS(DBuffer, '\')
                    else
                      RaiseStWin32Error(EStNetException, ErrorD);
                  end else begin
                    CurrentDomain := FServer;
                  end;

                  NewItem := nil;
                  case TLocalGroupMembersInfo2Array(Buffer^)[Index].lgrmi2_sidusage of
                    SidTypeUser :
                      begin
                        if (FNetwork <> nil) then begin
                          S := FNetwork.Server[CurrentDomain];
                          NewItem := S.User[CurrentName];
                        end;

                        if (NewItem = nil) then begin
                          NewItem := TStNetUserItem.CreateEx(CurrentName, '',
                                                             CurrentDomain,
                                                             nitUnknown);
                          NewItem.FNetwork := FNetwork;
                        end;
                        NewList.AddObject(CurrentName, NewItem);
                      end;
                    SidTypeGroup :
                      begin
                        if (FNetwork <> nil) then begin
                          S := FNetwork.Server[CurrentDomain];
                          NewItem := S.Group[CurrentName]
                        end;

                        if (NewItem = nil) then begin
                          NewItem := TStNetGroupItem.CreateEx(CurrentName, '',
                                                              CurrentDomain,
                                                              nitUnknown);
                          NewItem.FNetwork := FNetwork;
                        end;
                        NewList.AddObject(CurrentName, NewItem);
                      end;
                    SidTypeWellKnownGroup :
                      begin
                        { filter out these groups }
                      end;
                  end;
                end;
              end;                                                     {!!.02}
            finally
              StNetApiBufferFree(Buffer);
              Buffer := nil;
            end;
          end else begin
            RaiseStWin32Error(EStNetException, ErrorD);
          end;
        end;
    end;
    FItemList.Assign(NewList);
  finally
    NewList.Free;
  end;
  Result := FItemList as TStringList;
end;

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

function TStNetGroupItem.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 TStNetGroupItem.AddToGroup(AItem: TStNetItem);
var
  ErrorD : DWord;
  S : PSid;
begin
  case ItemType of
    nitGlobalGroup :
      begin
        if (AItem.ItemType = nitLocalUser) or (AItem.ItemType = nitGlobalUser) then begin
          ErrorD := StNetGroupAddUser(FServer, FName, AItem.Name);
          if ErrorD = NERR_SUCCESS then begin
            { add this user to this groups internal list }
            FItemList.AddObject(AItem.Name, AItem);
          end else begin
            RaiseStWin32Error(EStNetException, ErrorD);
          end;
        end else begin
          { can't add this item type to the group }
          RaiseStWin32Error(EStNetException, stscNetInvalidItemType);
        end;
      end;
    nitLocalGroup  :
      begin
        if (AItem.ItemType = nitLocalUser) or (AItem.ItemType = nitGlobalUser) or
           (AItem.ItemType = nitGlobalGroup) then begin

          { get the SID for this user }
          S := nil;
          case AItem.ItemType of
            nitLocalUser, nitGlobalUser : S := TStNetUserItem(AItem).Sid.Value;
            nitGlobalGroup              : S := TStNetGroupItem(AItem).Sid.Value;
          end;

          ErrorD := StNetLocalGroupAddMembers(FServer, FName, 0, S, 1);
          if ErrorD = NERR_SUCCESS then begin
            { add this user to this groups internal list }
            FItemList.AddObject(AItem.Name, AItem);
          end else begin
            RaiseStWin32Error(EStNetException, ErrorD);
          end;
        end else begin
          { can't add this item type to the group }
          RaiseStWin32Error(EStNetException, stscNetInvalidItemType);
        end;
      end;
  end;
end;

procedure TStNetGroupItem.RemoveFromGroup(AItem: TStNetItem);
var
  ErrorD : DWord;
  S : PSid;
begin
  case ItemType of
    nitGlobalGroup :
      begin
        if (AItem.ItemType = nitLocalUser) or (AItem.ItemType = nitGlobalUser) then begin
          ErrorD := StNetGroupDelUser(FServer, FName, AItem.Name);
          if ErrorD = NERR_SUCCESS then begin
            { remove this user from the groups internal list }
            FItemList.Delete(FItemList.IndexOf(AItem.Name));
          end else begin
            RaiseStWin32Error(EStNetException, ErrorD);
          end;
        end else begin
          { this item can't be in a group .. unable to remove it }
          RaiseStWin32Error(EStNetException, stscNetInvalidItemType);
        end;
      end;
    nitLocalGroup  :
      begin
        if (AItem.ItemType = nitLocalUser) or (AItem.ItemType = nitGlobalUser) or
           (AItem.ItemType = nitGlobalGroup) then begin

          { get the SID for this user }
          S := nil;
          case AItem.ItemType of
            nitLocalUser, nitGlobalUser : S := TStNetUserItem(AItem).Sid.Value;
            nitGlobalGroup              : S := TStNetGroupItem(AItem).Sid.Value;
          end;

          ErrorD := StNetLocalGroupDelMembers(FServer, FName, 0, S, 1);
          if ErrorD = NERR_SUCCESS then begin
            { remove this user from the groups internal list }
            FItemList.Delete(FItemList.IndexOf(AItem.Name));
          end else begin
            RaiseStWin32Error(EStNetException, ErrorD);
          end;
        end else begin
          { this item can't be in a group .. unable to remove it }
          RaiseStWin32Error(EStNetException, stscNetInvalidItemType);
        end;
      end;
  end;
end;

procedure TStNetGroupItem.Delete;
var
  ErrorD : DWord;
begin
  case ItemType of
    nitGlobalGroup :
      begin
        ErrorD := StNetGroupDel(FServer, FName);
        if ErrorD = NERR_SUCCESS then begin
         { can't possible remove it from all lists, but at least remove from server list }
         FNetwork.Server[FServer].FGroupList.Delete(FNetwork.Server[FServer].FGroupList.IndexOf(FName));

         { free this item }
         Free;
        end else begin
          RaiseStWin32Error(EStNetException, ErrorD);
        end;
      end;
    nitLocalGroup :
      begin
        ErrorD := StNetLocalGroupDel(FServer, FName);
        if ErrorD = NERR_SUCCESS then begin
         { can't possible remove it from all lists, but at least remove from server list }
         FNetwork.Server[FServer].FGroupList.Delete(FNetwork.Server[FServer].FGroupList.IndexOf(FName));

         { free this item }
         Free;
        end else begin
          RaiseStWin32Error(EStNetException, ErrorD);
        end;
      end;
  end;
end;

procedure TStNetGroupItem.Refresh;
var
  ErrorD : DWord;
  Buffer : Pointer;
begin
  case ItemType of
    nitGlobalGroup :
      begin
        ErrorD := StNetGroupGetInfo(FServer, FName, 2, Buffer);
        if ErrorD = NERR_SUCCESS then begin
          try
            FID       := TGROUP_INFO_2(Buffer^).grpi2_group_id;
            FComment  := TGROUP_INFO_2(Buffer^).grpi2_comment;
          finally
            StNetApiBufferFree(Buffer);
            Buffer := nil;
          end;
        end else begin
          RaiseStWin32Error(EStNetException, ErrorD);
        end;;
      end;
    nitLocalGroup :
      begin
        ErrorD := StNetLocalGroupGetInfo(FServer, FName, 1, Buffer);
        if ErrorD = NERR_SUCCESS then begin
          try
            FID       := TGROUP_INFO_2(Buffer^).grpi2_group_id;
            FComment  := TGROUP_INFO_2(Buffer^).grpi2_comment;
          finally
            StNetApiBufferFree(Buffer);
            Buffer := nil;
          end;
        end else begin
          RaiseStWin32Error(EStNetException, ErrorD);
        end;;
      end;
  end;
end;

function TStNetGroupItem.GetName: string;
begin
  Result := FName;
end;

procedure TStNetGroupItem.SetName(Value: string);
var
  ErrorD : DWord;
  Data : TLMWideChar;
  ParmErr : DWord;
  S : TStNetServerItem;
begin
  if Value <> FName then begin
    case ItemType of
      nitGlobalGroup :
        begin
          Data.Value := nil;
          try
            CvtToWideCharLM(Value, Data);
            ErrorD := StNetGroupSetInfo(FServer, FName, 0, @Data.Value, ParmErr);
            if ErrorD = NERR_SUCCESS then begin
              S := FNetwork.Server[FServer];
              S.FGroupList[S.FGroupList.IndexOf(FName)] := Value;;

              FName := Value;
            end else begin
              RaiseStWin32Error(EStNetException, ErrorD);
            end;
          finally
            StNetApiBufferFree(Data.Value);
          end;
        end;
      nitLocalGroup  :
        begin
          Data.Value := nil;
          try
            CvtToWideCharLM(Value, Data);
            ErrorD := StNetLocalGroupSetInfo(FServer, FName, 0, @Data.Value, ParmErr);
            if ErrorD = NERR_SUCCESS then begin
              S := FNetwork.Server[FServer];
              S.FGroupList[S.FGroupList.IndexOf(FName)] := Value;;

              FName := Value;
            end else begin
              RaiseStWin32Error(EStNetException, ErrorD);