Beispiel #1
0
static void
set_bitfield (char *f, bitfield *array, int value,
	      unsigned int size, int lineno)
{
  unsigned int i;

  if (strcmp (f, "CpuFP") == 0)
    {
      set_bitfield("Cpu387", array, value, size, lineno);
      set_bitfield("Cpu287", array, value, size, lineno);
      f = "Cpu8087";
    }
  else if (strcmp (f, "Mmword") == 0)
    f= "Qword";
  else if (strcmp (f, "Oword") == 0)
    f= "Xmmword";

  for (i = 0; i < size; i++)
    if (strcasecmp (array[i].name, f) == 0)
      {
	array[i].value = value;
	return;
      }

  if (value)
    {
      const char *v = strchr (f, '=');

      if (v)
	{
	  size_t n = v - f;
	  char *end;

	  for (i = 0; i < size; i++)
	    if (strncasecmp (array[i].name, f, n) == 0)
	      {
		value = strtol (v + 1, &end, 0);
		if (*end == '\0')
		  {
		    array[i].value = value;
		    return;
		  }
		break;
	      }
	}
    }

  /* Handle CPU_XXX_FLAGS.  */
  if (!set_bitfield_from_cpu_flag_init (f, array, value, size, lineno))
    return;

  if (lineno != -1)
    fail (_("%s: %d: Unknown bitfield: %s\n"), filename, lineno, f);
  else
    fail (_("Unknown bitfield: %s\n"), f);
}
Beispiel #2
0
static void
process_i386_cpu_flag (FILE *table, char *flag, int macro,
                       const char *comma, const char *indent)
{
    char *str, *next, *last;
    bitfield flags [ARRAY_SIZE (cpu_flags)];

    /* Copy the default cpu flags.  */
    memcpy (flags, cpu_flags, sizeof (cpu_flags));

    if (strcasecmp (flag, "unknown") == 0)
    {
        unsigned int i;

        /* We turn on everything except for cpu64 in case of
        CPU_UNKNOWN_FLAGS. */
        for (i = 0; i < ARRAY_SIZE (flags); i++)
            if (flags[i].position != Cpu64)
                flags[i].value = 1;
    }
    else if (strcmp (flag, "0"))
    {
        last = flag + strlen (flag);
        for (next = flag; next && next < last; )
        {
            str = next_field (next, '|', &next);
            if (str)
                set_bitfield (str, flags, ARRAY_SIZE (flags));
        }
    }

    output_cpu_flags (table, flags, ARRAY_SIZE (flags), macro,
                      comma, indent);
}
Beispiel #3
0
static int
set_bitfield_from_cpu_flag_init (char *f, bitfield *array,
				 int value, unsigned int size,
				 int lineno)
{
  char *str, *next, *last;
  unsigned int i;

  for (i = 0; i < ARRAY_SIZE (cpu_flag_init); i++)
    if (strcmp (cpu_flag_init[i].name, f) == 0)
      {
	/* Turn on selective bits.  */
	char *init = xstrdup (cpu_flag_init[i].init);
	last = init + strlen (init);
	for (next = init; next && next < last; )
	  {
	    str = next_field (next, '|', &next, last);
	    if (str)
	      set_bitfield (str, array, 1, size, lineno);
	  }
	free (init);
	return 0;
      }

  return -1;
}
Beispiel #4
0
static void
process_i386_opcode_modifier (FILE *table, char *mod)
{
    char *str, *next, *last;
    bitfield modifiers [ARRAY_SIZE (opcode_modifiers)];

    /* Copy the default opcode modifier.  */
    memcpy (modifiers, opcode_modifiers, sizeof (modifiers));

    if (strcmp (mod, "0"))
    {
        last = mod + strlen (mod);
        for (next = mod; next && next < last; )
        {
            str = next_field (next, '|', &next);
            if (str)
                set_bitfield (str, modifiers, ARRAY_SIZE (modifiers));
        }
    }
    output_opcode_modifier (table, modifiers, ARRAY_SIZE (modifiers));
}
Beispiel #5
0
static void
process_i386_operand_type (FILE *table, char *op, int macro,
			   const char *indent, int lineno)
{
  char *str, *next, *last;
  bitfield types [ARRAY_SIZE (operand_types)];

  /* Copy the default operand type.  */
  memcpy (types, operand_types, sizeof (types));

  if (strcmp (op, "0"))
    {
      last = op + strlen (op);
      for (next = op; next && next < last; )
	{
	  str = next_field (next, '|', &next, last);
	  if (str)
	    set_bitfield (str, types, 1, ARRAY_SIZE (types), lineno);
	}
    }
  output_operand_type (table, types, ARRAY_SIZE (types), macro,
		       indent);
}
Beispiel #6
0
int Peer::process_messages()
{
    //is handshake
    if (m_buf.length - m_buf.pos >= HANDSHAKE_LENGHT &&
            m_buf.data[m_buf.pos] == '\x13' &&
            memcmp(&m_buf.data[m_buf.pos + 1], "BitTorrent protocol", 19) == 0 &&
            m_torrent->memcmp_infohash_bin((unsigned char*)&m_buf.data[m_buf.pos + 28]))
    {
        if (m_state != PEER_STATE_WAIT_HANDSHAKE)
            return ERR_INTERNAL;
        m_buf.pos += HANDSHAKE_LENGHT;
        m_state = PEER_STATE_GENERAL_READY;
#ifdef PEER_DEBUG
        logger::LOGGER() << "Peer " << m_ip.c_str() << ": is received handshake\n";
#endif
    }
    char ip[16];
    memset(ip, 0, 16);
    strcpy(ip,  inet_ntoa(m_sock->m_peer.sin_addr));
    uint32_t piece_count = m_torrent->get_piece_count();
    BLOCK_ID block_id;
    while((int)m_buf.length - (int)m_buf.pos > 4)
    {
        uint32_t len = 0;
        memcpy(&len, &m_buf.data[m_buf.pos], 4);
        len = ntohl(len);
        if (m_buf.length - m_buf.pos < len + 4)
            goto end;
        m_buf.pos += 4;
        if (len != 0)
        {
            char id = m_buf.data[m_buf.pos++];
            switch (id)
            {
            case '\x00'://choke: <len=0001><id=0>
#ifdef PEER_DEBUG
                logger::LOGGER() << "Peer " << m_ip.c_str() << ": is received choke";
#endif
                if ( m_state == PEER_STATE_WAIT_HANDSHAKE)
                    return ERR_INTERNAL;
                m_peer_choking = true;
                if (m_state == PEER_STATE_WAIT_UNCHOKE)
                    return ERR_INTERNAL;//m_state = PEER_STATE_GENERAL_READY; иначе зацикливаемся
                break;
            case '\x01'://unchoke: <len=0001><id=1>
#ifdef PEER_DEBUG
                logger::LOGGER() << "Peer " << m_ip.c_str() << ": is received unchoke";
#endif
                if ( m_state == PEER_STATE_WAIT_HANDSHAKE)
                    return ERR_INTERNAL;
                m_peer_choking = false;
                if (m_state == PEER_STATE_WAIT_UNCHOKE)
                    m_state = PEER_STATE_REQUEST_READY;
                break;
            case '\x02'://interested: <len=0001><id=2>
#ifdef PEER_DEBUG
                logger::LOGGER() << "Peer " << m_ip.c_str() << ": is received interested";
#endif
                if ( m_state == PEER_STATE_WAIT_HANDSHAKE)
                    return ERR_INTERNAL;
                m_peer_interested = true;
                send_unchoke();
                break;
            case '\x03'://not interested: <len=0001><id=3>
#ifdef PEER_DEBUG
                logger::LOGGER() << "Peer " << m_ip.c_str() << ": is received not interested";
#endif
                if ( m_state == PEER_STATE_WAIT_HANDSHAKE)
                    return ERR_INTERNAL;
                m_peer_interested = false;
                break;
            case '\x04'://have: <len=0005><id=4><piece index>
#ifdef PEER_DEBUG
                logger::LOGGER() << "Peer " << m_ip.c_str() << ": is received have";
#endif
                if ( m_state == PEER_STATE_WAIT_HANDSHAKE)
                    return ERR_INTERNAL;
                PIECE_INDEX piece_index;
                memcpy(&piece_index, &m_buf.data[m_buf.pos], 4);
                piece_index = ntohl(piece_index);
                if (piece_index >= piece_count)
                    return ERR_INTERNAL;
                m_available_pieces.insert(piece_index);
                set_bitfield(piece_index, piece_count, m_bitfield);
                break;
            case '\x05'://bitfield: <len=0001+X><id=5><bitfield>
#ifdef PEER_DEBUG
                logger::LOGGER() << "Peer " << m_ip.c_str() << ": is received bitfield";
#endif

                if (len - 1 != m_torrent->get_bitfield_length())
                    return ERR_INTERNAL;
                if (m_state == PEER_STATE_WAIT_HANDSHAKE)
                    return ERR_INTERNAL;
                memcpy(m_bitfield, &m_buf.data[m_buf.pos], len - 1);
                for(PIECE_INDEX i = 0; i < piece_count; i++)
                {
                    if (bit_in_bitfield(i, piece_count, m_bitfield))
                        m_available_pieces.insert(i);
                }
                break;
            case '\x06'://request: <len=0013><id=6><index><begin><length>
                if ( m_state == PEER_STATE_WAIT_HANDSHAKE)
                    return ERR_INTERNAL;
                PIECE_INDEX index;//индекс куска
                BLOCK_OFFSET offset;
                uint32_t length;
                memcpy(&index,&m_buf.data[m_buf.pos], 4);
                index = ntohl(index);
                memcpy(&offset,&m_buf.data[m_buf.pos + 4], 4);
                offset = ntohl(offset);
                memcpy(&length,&m_buf.data[m_buf.pos + 8], 4);
                length = ntohl(length);
                //проверяем валидность индексов, смещений
                if (length == 0 || length > BLOCK_LENGTH || offset % BLOCK_LENGTH != 0)
                    return ERR_INTERNAL;
                BLOCK_INDEX block_index;
                m_torrent->get_block_index_by_offset(index, offset, block_index) ;
                uint32_t real_block_length;
                m_torrent->get_block_length_by_index(index, block_index, real_block_length);
                if (real_block_length != length)
                    return ERR_INTERNAL;
                //кладем индекс блока в очередь запросов
                generate_block_id(index, block_index, block_id);
                m_requests_queue.insert(block_id);

#ifdef PEER_DEBUG
                logger::LOGGER() << "Peer " << m_ip.c_str() << ": is received request piece=" << index << " block=" << block_index;
#endif

                break;
            case '\x07'://piece: <len=0009+X><id=7><index><begin><block>
            {
                PIECE_INDEX index;//индекс куска
                BLOCK_OFFSET offset;
                uint32_t block_length = len - 9;
                if (m_state == PEER_STATE_WAIT_HANDSHAKE)
                    return ERR_INTERNAL;
                if (block_length == 0 || block_length > BLOCK_LENGTH)
                    return ERR_INTERNAL;
                memcpy(&index,&m_buf.data[m_buf.pos], 4);
                index = ntohl(index);
                memcpy(&offset,&m_buf.data[m_buf.pos + 4], 4);
                offset = ntohl(offset);
                if (offset % BLOCK_LENGTH != 0)
                    return ERR_INTERNAL;

                generate_block_id(index, offset / BLOCK_LENGTH, block_id);
                std::set<BLOCK_ID>::iterator iter = m_requested_blocks.find(block_id);

#ifdef PEER_DEBUG
                logger::LOGGER() << "Peer " << m_ip.c_str() << ": is received piece piece=" << index << " block=" << offset / BLOCK_LENGTH;
#endif

                if (iter == m_requested_blocks.end())
                    return ERR_INTERNAL;

                if (m_torrent->save_block(index, offset, block_length, &m_buf.data[m_buf.pos + 8]) != ERR_NO_ERROR)
                    return ERR_INTERNAL;

                m_requested_blocks.erase(iter);
                m_downloaded += block_length;

                break;
            }
            case '\x08'://cancel: <len=0013><id=8><index><begin><length>
            {
                if (m_state == PEER_STATE_WAIT_HANDSHAKE)
                    return ERR_INTERNAL;
                PIECE_INDEX index;//индекс куска
                BLOCK_OFFSET offset;
                uint32_t length;
                memcpy(&index,&m_buf.data[m_buf.pos], 4);
                index = ntohl(index);
                memcpy(&offset,&m_buf.data[m_buf.pos + 4], 4);
                offset = ntohl(offset);
                memcpy(&length,&m_buf.data[m_buf.pos + 8], 4);
                length = ntohl(length);
                //проверяем валидность индексов, смещений
                if (length == 0 || length > BLOCK_LENGTH || offset % BLOCK_LENGTH != 0)
                    return ERR_INTERNAL;
                uint32_t block_index;
                m_torrent->get_block_index_by_offset(index, offset, block_index);

#ifdef PEER_DEBUG
                logger::LOGGER() << "Peer " << m_ip.c_str() << ": is received cancel piece=" << index << " block=" << block_index;
#endif

                uint32_t real_block_length;
                m_torrent->get_block_length_by_index(index, block_index, real_block_length);
                if (real_block_length != length)
                    return ERR_INTERNAL;
                generate_block_id(index, block_index, block_id);
                m_requested_blocks.erase(block_id);
                break;
            }
            case '\x09'://port: <len=0003><id=9><listen-port>
                if (m_state == PEER_STATE_WAIT_HANDSHAKE)
                    return ERR_INTERNAL;
                break;
            default:
                return ERR_INTERNAL;
                break;
            }
            m_buf.pos += len - 1;
        }
    }
end:
    char temp[BUFFER_SIZE];
    size_t len = m_buf.length - m_buf.pos;
    memcpy(temp, &m_buf.data[m_buf.pos], len);
    m_buf.length = len;
    m_buf.pos = 0;
    memcpy(m_buf.data, temp, len);
    return ERR_NO_ERROR;
}
Beispiel #7
0
static void
process_i386_cpu_flag (FILE *table, char *flag, int macro,
		       const char *comma, const char *indent,
		       int lineno)
{
  char *str, *next, *last;
  unsigned int i;
  bitfield flags [ARRAY_SIZE (cpu_flags)];

  /* Copy the default cpu flags.  */
  memcpy (flags, cpu_flags, sizeof (cpu_flags));

  if (strcasecmp (flag, "unknown") == 0)
    {
      /* We turn on everything except for cpu64 in case of
	 CPU_UNKNOWN_FLAGS.  */
      for (i = 0; i < ARRAY_SIZE (flags); i++)
	if (flags[i].position != Cpu64)
	  flags[i].value = 1;
    }
  else if (flag[0] == '~')
    {
      last = flag + strlen (flag);

      if (flag[1] == '(')
	{
	  last -= 1;
	  next = flag + 2;
	  if (*last != ')')
	    fail (_("%s: %d: Missing `)' in bitfield: %s\n"), filename,
		  lineno, flag);
	  *last = '\0';
	}
      else
	next = flag + 1;

      /* First we turn on everything except for cpu64.  */
      for (i = 0; i < ARRAY_SIZE (flags); i++)
	if (flags[i].position != Cpu64)
	  flags[i].value = 1;

      /* Turn off selective bits.  */
      for (; next && next < last; )
	{
	  str = next_field (next, '|', &next, last);
	  if (str)
	    set_bitfield (str, flags, 0, ARRAY_SIZE (flags), lineno);
	}
    }
  else if (strcmp (flag, "0"))
    {
      /* Turn on selective bits.  */
      last = flag + strlen (flag);
      for (next = flag; next && next < last; )
	{
	  str = next_field (next, '|', &next, last);
	  if (str)
	    set_bitfield (str, flags, 1, ARRAY_SIZE (flags), lineno);
	}
    }

  output_cpu_flags (table, flags, ARRAY_SIZE (flags), macro,
		    comma, indent);
}
Beispiel #8
0
static u16 set_ddr3_mem_reg_col(u16 reg, u16 col)
{
	return set_bitfield(reg, col, 3, 0);
}
Beispiel #9
0
static u16 set_ddr3_mem_reg_c1m(u16 reg, u16 c1m)
{
	return set_bitfield(reg, c1m, 1, 13);
}
Beispiel #10
0
static u16 set_ddr3_mem_reg_size(u16 reg, u16 size)
{
	return set_bitfield(reg, size, 4, 8);
}
Beispiel #11
0
static u16 set_ddr3_mem_reg_row(u16 reg, u16 row)
{
	return set_bitfield(reg, row, 3, 5);
}