Beispiel #1
0
int
parse_int(char* str)
{
  int r, i = atoi(str);
  REVERSE_32(r, i);
  return r;
}
SKERR SKIntegerList::SetFileName(const char *pszFileName,
                                 const char *pszDefaultFileName)
{
    m_bInitialized = PR_FALSE;

    if(m_bOwner && m_pIntegerList)
    {
        delete[] (PRUint32 *)m_pIntegerList;
        m_pIntegerList = NULL;
    }

    SKERR err = SKFile::SetFileName(pszFileName, pszDefaultFileName);
    if(err != noErr)
        return err;

    PRFileInfo info;
    if(PR_GetFileInfo(GetSharedFileName(), &info) != PR_SUCCESS)
        return err_failure;

    if((info.size & 0x3))
        return err_failure;

    PRFileDesc *f = skPR_Open(GetSharedFileName(), PR_RDONLY, 0);
    if(!f)
        return err_notfound;

    m_bOwner = PR_TRUE;
    m_iSize = info.size / 4;
    m_pIntegerList = new PRUint32[m_iSize];
    if(m_iSize && !m_pIntegerList)
    {
        PR_Close(f);
        return err_memory;
    }

    if(PR_Read(f, (void *)m_pIntegerList, info.size) != info.size)
    {
        PR_Close(f);
        return err_failure;
    }

#if IS_BIG_ENDIAN
    for(PRUint32 i = 0; i < m_iSize; ++i)
    {
        REVERSE_32(((PRUint32*)m_pIntegerList)[i]);
    }
#endif

    PR_Close(f);

    qsort((void *)m_pIntegerList, m_iSize, sizeof(PRUint32), &g_sComparePRUint32);
    m_bInitialized = PR_TRUE;

    return noErr;
}
Beispiel #3
0
int
parse_bitcoin_block(unsigned char* json, size_t size, block_header* block)
{
  unsigned short* res = calloc(size, sizeof(unsigned short));
  if (res == NULL) {
    return -1;
  }
  int ret = js0n(json, size, res, size);
  enum block_tokens token = UNKNOWN;
  uint32 value;

  int i =0, processed = 0;
  while (processed < 7 & res[i] != 0)
  {
    int s = res[i++];
    int l = res[i++];
    token = parse_token(json, s, l);
    s = res[i++];
    l = res[i++];

    if (is_valid_token(token))
    {
      char* str = (char*)(json + s);
      str[l] ='\0';  // LAMb
//      printf("str=%s\n", str);

      switch(token)
      { 
        case HASH:
          break;

        case VERSION:
          value = parse_int(str);
          REVERSE_32(block->version, value);
          break;

        case PREV_BLOCK:
          hex_to_bytes_rev(str, l, block->prev_block, 256);
          break;

        case MRKL_ROOT:
          hex_to_bytes_rev(str, l, block->mrkl_root, 256);
          break;

        case SECS:
          value = parse_int(str);
          REVERSE_32(block->time, value);
          break;

        case BITS:
          value = parse_int(str);
          REVERSE_32(block->bits, value);
          break;

        case NONCE:
          value = parse_int(str);
          REVERSE_32(block->nonce, value);
          break;

        default:
          break;

      }
      processed++;
    }
  }

  free(res);
  return 0;
}