C++ (Cpp) COPYITEM Examples

Example #1

File: buildconfig.cpp Project: 3L173-CNW/Zeus

HttpInject::HEADER *webFake2Binary(Config0::VAR *pcfgvar)
{
  if(pcfgvar->bValuesCount < 3)return NULL;

  HttpInject::HEADER wf;
  wf.size = 0;

  //Flags
  wf.flags = 0;
  WORD tmp = Str::_LengthA(pcfgvar->pValues[2]);
  for(WORD i = 0; i < tmp; i++)switch(pcfgvar->pValues[2][i])
  {
    case 'P': wf.flags |= HttpInject::FLAG_REQUEST_POST; break;
    case 'G': wf.flags |= HttpInject::FLAG_REQUEST_GET; break;
    case 'S': wf.flags |= HttpInject::FLAG_IS_MIRRORFAKE; break;
  }
  if((wf.flags & HttpInject::FLAG_IS_MIRRORFAKE) == 0)wf.flags |= HttpInject::FLAG_IS_FAKE;

  wf.urlMask           = Str::_LengthA(pcfgvar->pValues[0]);
  wf.fakeUrl           = Str::_LengthA(pcfgvar->pValues[1]);
  wf.postDataBlackMask = pcfgvar->bValuesCount > 3 && !(pcfgvar->pValues[3][0] == '*' && pcfgvar->pValues[3][1] == 0) ? Str::_LengthA(pcfgvar->pValues[3]) : 0;
  wf.postDataWhiteMask = pcfgvar->bValuesCount > 4 && !(pcfgvar->pValues[4][0] == '*' && pcfgvar->pValues[4][1] == 0) ? Str::_LengthA(pcfgvar->pValues[4]) : 0;
  wf.blockOnUrl        = pcfgvar->bValuesCount > 5 ? Str::_LengthA(pcfgvar->pValues[5]) : 0;
  wf.contextMask       = 0;

  LPBYTE data = (LPBYTE)Mem::alloc(10 + sizeof(HttpInject::HEADER) + wf.urlMask + wf.fakeUrl + wf.postDataBlackMask + wf.postDataWhiteMask + wf.blockOnUrl + wf.contextMask);
  if(data == NULL)return NULL;
  LPBYTE cur = data + sizeof(HttpInject::HEADER);

  COPYITEM(wf.urlMask,           0, wf);
  COPYITEM(wf.fakeUrl,           1, wf);
  COPYITEM(wf.postDataBlackMask, 3, wf);
  COPYITEM(wf.postDataWhiteMask, 4, wf);
  COPYITEM(wf.blockOnUrl,        5, wf);

  wf.size += sizeof(HttpInject::HEADER);
  Mem::_copy(data, &wf, sizeof(HttpInject::HEADER));

  return (HttpInject::HEADER *)data;
}

Example #2

File: ITEM.C Project: thearttrooper/KappaPC

/* The chunk header passed in must be the first one.
 * Start from that chunk and walk until find enough space to
 * add the object.
 */
ITEMID AddNewItem(WORD wType, GLOBALHANDLE hChunk, WORD wMax,
                  WORD wItemSize, LPSTR lpData, LPLPSTR lpItem, 
                  ATOMID idName)
{
    GLOBALHANDLE hChunk1 = 0, hFirstChunk;
    FIXCHUNKHDR lpChunkHdr;
    ITEMHDR lpItemHdr;
    ITEMID keyCount;
    BOOL bFirst = TRUE, bDeleted;
    LPSTR lpTmp;
    register short i;

    for (hFirstChunk = hChunk; hChunk && (hChunk1 = hChunk);
         hChunk = lpChunkHdr->hNext, GLOBALUNLOCK(hChunk1)) {
        lpChunkHdr = (FIXCHUNKHDR) GLOBALLOCK(hChunk);

        if (!lpChunkHdr)
            return ERROR;

        if (bFirst)
        {
            bFirst = FALSE;
            ++lpChunkHdr->wRelCounter;
        }

        bDeleted = NUM_DELETED_ITEMS(lpChunkHdr) ? TRUE : FALSE;

        /* if chunk contains no deleted items ...   */
        /* and it's full, move on to the next chunk */
        if (!bDeleted && lpChunkHdr->wIndex >= wMax)
            continue;

        lpItemHdr = (ITEMHDR) ((DWORD) lpChunkHdr + (WORD) SIZE_FIXCHUNKHDR);

        /* Get the new item */
        lpItemHdr = GetNewItem(wType, lpItemHdr, hFirstChunk,
                               lpChunkHdr, bDeleted, wItemSize, &keyCount);
        if (!lpItemHdr)
            return FALSE;

        /* If data passed in, copy it */
        if (lpData)
        {
            lpTmp = (LPSTR) ((DWORD) lpItemHdr + SIZE_ITEMHDR);
            COPYITEM(lpData, lpTmp, wItemSize);
        }
        
        if (idName)
            use_access_table(wType, lpChunkHdr, idName, keyCount, 
                             bSortAccess, kADDMODE);

        /* if ptr passed in, set and & DONT UNLOCK */
        if (lpItem)
            *lpItem = (LPSTR) ((DWORD) lpItemHdr + SIZE_ITEMHDR);
        else 
            GLOBALUNLOCK(hChunk);
        
        return keyCount;
    }

    /* Need to add a new chunk */
    lpChunkHdr = (FIXCHUNKHDR) GLOBALLOCK(hChunk1);

    if (!lpChunkHdr)
        return ERROR;

    hChunk = lpChunkHdr->hNext = AddNewChunk(wType);
    GLOBALUNLOCK(hChunk1);

    /* Add the object */
    lpChunkHdr = (FIXCHUNKHDR) GLOBALLOCK(hChunk);
    if (!lpChunkHdr)
        return ERROR;

    INIT_FIXCHUNKHDR(lpChunkHdr);
    lpItemHdr = (ITEMHDR) ((DWORD) lpChunkHdr + (WORD) SIZE_FIXCHUNKHDR);
    keyCount = lpItemHdr->key = AssignNewId(wType, hFirstChunk);
    if (!keyCount) 
        return ERROR;

    /** If data passed in, copy it **/
    if (lpData)
    {
        lpTmp = (LPSTR) ((DWORD) lpItemHdr + SIZE_ITEMHDR);
        COPYITEM(lpData, lpTmp, wItemSize);
    }

    if (idName)
        use_access_table(wType, lpChunkHdr, idName, keyCount,
                         bSortAccess, kADDMODE);

    if (lpItem)
        *lpItem = (LPSTR) ((DWORD) lpItemHdr + SIZE_ITEMHDR);
    else 
        GLOBALUNLOCK(hChunk);

    return keyCount;
}