C++ (Cpp) Align32 Examples

Example #1

File: security-token.c Project: borland667/pbis

static
ULONG
RtlAccessTokenRelativeSize(
    PACCESS_TOKEN pToken
    )
{
    BOOLEAN isLocked = FALSE;
    ULONG ulRelativeSize = 0;
    ULONG i = 0;

    ulRelativeSize += sizeof(ACCESS_TOKEN_SELF_RELATIVE);
    Align32(&ulRelativeSize);

    SHARED_LOCK_RWLOCK(&pToken->RwLock, isLocked);

    ulRelativeSize += RtlLengthSid(pToken->User.Sid);
    Align32(&ulRelativeSize);

    if (pToken->Groups)
    {
        ulRelativeSize += sizeof(SID_AND_ATTRIBUTES_SELF_RELATIVE) * pToken->GroupCount;
        Align32(&ulRelativeSize);

        for (i = 0; i < pToken->GroupCount; i++)
        {
            ulRelativeSize += RtlLengthSid(pToken->Groups[i].Sid);
            Align32(&ulRelativeSize);
        }
    }

    if (pToken->Privileges)
    {
        ulRelativeSize += sizeof(pToken->Privileges[0]) * pToken->PrivilegeCount;
        Align32(&ulRelativeSize);
    }

    if (pToken->Owner)
    {
        ulRelativeSize += RtlLengthSid(pToken->Owner);
        Align32(&ulRelativeSize);
    }

    if (pToken->PrimaryGroup)
    {
        ulRelativeSize += RtlLengthSid(pToken->PrimaryGroup);
        Align32(&ulRelativeSize);
    }

    if (pToken->DefaultDacl)
    {
        ulRelativeSize += RtlGetAclSize(pToken->DefaultDacl);
        Align32(&ulRelativeSize);
    }

    UNLOCK_RWLOCK(&pToken->RwLock, isLocked);

    return ulRelativeSize;
}

Example #2

File: BmpWrite.cpp Project: jnsdbr/ss2010

int BmpWrite::operator=(Image& img) {
   long BytesPerLine;
   long BufferSize;
   int x,y;
   unsigned char* buffer;
   if (NULL !=f ) {
      width  = img.Width();
      height = img.Height();
      BytesPerLine = Align32(width*3);
      BufferSize = BytesPerLine*height;
      // Bitmap File Header
      fwrite("BM",1,2,f);
      write_long(14+40+BufferSize);
      write_short(0);
      write_short(0);
      write_long(14+40);
      // DIB Header
      write_long(40);
      write_long(width);
      write_long(height);
      write_short(1);
      write_short(24);
      write_long(0);
      write_long(BufferSize);
      write_long(0);
      write_long(0);
      write_long(0);
      write_long(0);
      // no LUT
      ;
      // write pixel data
      for (y=0;y<height;y++) {
         for (x=0;x<width;x++) {
            write_char(img[y][x].Blue());
            write_char(img[y][x].Green());
            write_char(img[y][x].Red());
            buffer +=3;
         }
         for (int i=BytesPerLine-3*x;i>0;i--) {
            write_char(0);
         }
      }
      fclose(f);
      f = NULL;
      return 0;
   } else {
      return 1;
   }
}

Example #3

File: security-token.c Project: borland667/pbis

NTSTATUS
RtlAccessTokenToSelfRelativeAccessToken(
    IN PACCESS_TOKEN pToken,
    OUT OPTIONAL PACCESS_TOKEN_SELF_RELATIVE pRelative,
    IN OUT PULONG pulSize
    )
{
    NTSTATUS status = STATUS_SUCCESS;
    BOOLEAN isLocked = FALSE;
    ULONG ulRelativeSize = RtlAccessTokenRelativeSize(pToken);
    PSID_AND_ATTRIBUTES_SELF_RELATIVE pGroups = NULL;
    PBYTE pBuffer = NULL;
    ULONG ulOffset = 0;
    ULONG i = 0;

    if (pRelative)
    {
        if (*pulSize < ulRelativeSize)
        {
            status = STATUS_BUFFER_TOO_SMALL;
            GOTO_CLEANUP_ON_STATUS(status);
        }

        pBuffer = (PBYTE) pRelative;
        
        SHARED_LOCK_RWLOCK(&pToken->RwLock, isLocked);

        pRelative->Flags = pToken->Flags;
        pRelative->User.Attributes = pToken->User.Attributes;
        pRelative->GroupCount = pToken->GroupCount;
        pRelative->PrivilegeCount = pToken->PrivilegeCount;
        pRelative->Uid = pToken->Uid;
        pRelative->Gid = pToken->Gid;
        pRelative->Umask = pToken->Umask;
        
        ulOffset += sizeof(*pRelative);
        Align32(&ulOffset);
        
        pRelative->User.SidOffset = ulOffset;
        memcpy(pBuffer + ulOffset, pToken->User.Sid, RtlLengthSid(pToken->User.Sid));
        ulOffset += RtlLengthSid(pToken->User.Sid);
        Align32(&ulOffset);
        
        if (pToken->Groups)
        {
            pRelative->GroupsOffset = ulOffset;
            pGroups = (PSID_AND_ATTRIBUTES_SELF_RELATIVE) (pBuffer + ulOffset);
            ulOffset += sizeof(SID_AND_ATTRIBUTES_SELF_RELATIVE) * pToken->GroupCount;
            Align32(&ulOffset);
            
            for (i = 0; i < pToken->GroupCount; i++)
            {
                pGroups[i].Attributes = pToken->Groups[i].Attributes;
                pGroups[i].SidOffset = ulOffset;
                memcpy(pBuffer + ulOffset, pToken->Groups[i].Sid, RtlLengthSid(pToken->Groups[i].Sid));
                ulOffset += RtlLengthSid(pToken->Groups[i].Sid);
                Align32(&ulOffset);
            }
        }
        else
        {
            pRelative->GroupsOffset = 0;
        }
        
        if (pToken->Privileges)
        {
            pRelative->PrivilegesOffset = ulOffset;
            memcpy(pBuffer + ulOffset,
                   pToken->Privileges,
                   sizeof(pToken->Privileges[0]) * pToken->PrivilegeCount);
            ulOffset += sizeof(pToken->Privileges[0]) * pToken->PrivilegeCount;
            Align32(&ulOffset);
        }
        else
        {
            pRelative->PrivilegesOffset = 0;
        }

        if (pToken->Owner)
        {
            pRelative->OwnerOffset = ulOffset;
            memcpy(pBuffer + ulOffset, pToken->Owner, RtlLengthSid(pToken->Owner));
            ulOffset += RtlLengthSid(pToken->Owner);
            Align32(&ulOffset);
        }
        else
        {
            pRelative->OwnerOffset = 0;
        }
        
        if (pToken->PrimaryGroup)
        {
            pRelative->PrimaryGroupOffset = ulOffset;
            memcpy(pBuffer + ulOffset, pToken->PrimaryGroup, RtlLengthSid(pToken->PrimaryGroup));
            ulOffset += RtlLengthSid(pToken->PrimaryGroup);
            Align32(&ulOffset);
        }
        else
        {
            pRelative->PrimaryGroupOffset = 0;
        }
        
        if (pToken->DefaultDacl)
        {
            pRelative->DefaultDaclOffset = ulOffset;
            memcpy(pBuffer + ulOffset, pToken->DefaultDacl, RtlGetAclSize(pToken->DefaultDacl));
            ulOffset += RtlGetAclSize(pToken->DefaultDacl);
            Align32(&ulOffset);
        }
        else
        {
            pRelative->DefaultDaclOffset = 0;
        }
        

        assert(ulOffset == ulRelativeSize);
    }

cleanup:
    UNLOCK_RWLOCK(&pToken->RwLock, isLocked);

    *pulSize = ulRelativeSize;

    return status;
}