klassOop typeArrayKlass::create_klass(BasicType type, int scale,
                                      const char* name_str, TRAPS) {
  typeArrayKlass o;

  Symbol* sym = NULL;
  if (name_str != NULL) {
    sym = SymbolTable::new_symbol(name_str, CHECK_NULL);
  }
  KlassHandle klassklass (THREAD, Universe::typeArrayKlassKlassObj());

  arrayKlassHandle k = base_create_array_klass(o.vtbl_value(), header_size(), klassklass, CHECK_NULL);
  typeArrayKlass* ak = typeArrayKlass::cast(k());
  ak->set_name(sym);
  ak->set_layout_helper(array_layout_helper(type));
  assert(scale == (1 << ak->log2_element_size()), "scale must check out");
  assert(ak->oop_is_javaArray(), "sanity");
  assert(ak->oop_is_typeArray(), "sanity");
  ak->set_max_length(arrayOopDesc::max_array_length(type));
  assert(k()->size() > header_size(), "bad size");

  // Call complete_create_array_klass after all instance variables have been initialized.
  KlassHandle super (THREAD, k->super());
  complete_create_array_klass(k, super, CHECK_NULL);

  return k();
}
klassOop typeArrayKlassKlass::create_klass(TRAPS) {
  typeArrayKlassKlass o;
  KlassHandle h_this_klass(THREAD, Universe::klassKlassObj());  
  KlassHandle k = base_create_klass(h_this_klass, header_size(), o.vtbl_value(), CHECK_0);
  assert(k()->size() == align_object_size(header_size()), "wrong size for object");
  java_lang_Class::create_mirror(k, CHECK_0); // Allocate mirror
  return k();
}
Ejemplo n.º 3
0
int
tls_record_decrypt(tls_record_t ctx,
                          const tls_buffer input,
                          tls_buffer *output,
                          uint8_t *contentType)
{
    int        err;
    tls_buffer       cipherFragment;
    uint8_t         *charPtr;
    uint64_t        seqNum;
    uint8_t         ct;
    charPtr=input.data;

    check(input.length>=header_size(ctx));

    if(input.length<header_size(ctx))
        return errSSLRecordParam;

    ct = *charPtr++;
#if 0 // We dont actually check the record protocol version
    tls_protocol_version pv;
    pv = SSLDecodeInt(charPtr, 2);
#endif
    charPtr+=2;
    if(ctx->isDTLS) {
        seqNum = SSLDecodeUInt64(charPtr, 8); charPtr+=8;
    }

    cipherFragment.length = SSLDecodeInt(charPtr, 2); charPtr+=2;
    cipherFragment.data = charPtr;

#if 0 // This is too strict for the record layer.
    if (ct < tls_record_type_V3_Smallest ||
        ct > tls_record_type_V3_Largest)
        return errSSLRecordProtocol;

    if ((ctx->negProtocolVersion != tls_protocol_version_Undertermined) &&
        (pv != ctx->negProtocolVersion)) {
        sslErrorLog("invalid record protocol version, expected = %04x, received = %04x", ctx->negProtocolVersion, pv);
        return errSSLRecordProtocol; // Invalid record version ?
    }
#endif

    check(input.length>=header_size(ctx)+cipherFragment.length);

    if(input.length<header_size(ctx)+cipherFragment.length) {
        return errSSLRecordParam; // input buffer not enough data
    }

    if(ctx->isDTLS)
    {
        /* if the epoch of the record is different of current read cipher, just drop it */
        if((seqNum>>48)!=(ctx->readCipher.sequenceNum>>48)) {
            return errSSLRecordUnexpectedRecord;
        } else {
            ctx->readCipher.sequenceNum=seqNum;
        }
    }
Ejemplo n.º 4
0
klassOop arrayKlassKlass::create_klass(TRAPS) {
  arrayKlassKlass o;
  KlassHandle h_this_klass(THREAD, Universe::klassKlassObj());
  KlassHandle k = base_create_klass(h_this_klass, header_size(), o.vtbl_value(), CHECK_NULL);
  // Make sure size calculation is right
  assert(k()->size() == align_object_size(header_size()), "wrong size for object");
  java_lang_Class::create_mirror(k, CHECK_NULL); // Allocate mirror, make links
  return k();
}
Ejemplo n.º 5
0
klassOop methodDataKlass::create_klass(TRAPS) {
  methodDataKlass o;
  KlassHandle h_this_klass(THREAD, Universe::klassKlassObj());  
  KlassHandle k = base_create_klass(h_this_klass, header_size(),
				    o.vtbl_value(), CHECK_0);
  // Make sure size calculation is right
  assert(k()->size() == align_object_size(header_size()),
	 "wrong size for object");
  return k();
}
Ejemplo n.º 6
0
Archivo: pdu.cpp Proyecto: Imva/libtins
void PDU::serialize(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
    uint32_t sz = header_size() + trailer_size();
    /* Must not happen... */
    #ifdef TINS_DEBUG
    assert(total_sz >= sz);
    #endif
    prepare_for_serialize(parent);
    if(_inner_pdu)
        _inner_pdu->serialize(buffer + header_size(), total_sz - sz, this);
    write_serialization(buffer, total_sz, parent);
}
Ejemplo n.º 7
0
void EAPOL::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *) {
    #ifdef TINS_DEBUG
    assert(total_sz >= header_size());
    #endif
    std::memcpy(buffer, &_header, sizeof(_header));
    write_body(buffer + sizeof(_header), total_sz - sizeof(_header));
}
Ejemplo n.º 8
0
klassOop constantPoolCacheKlass::create_klass(TRAPS) {
  constantPoolCacheKlass o;
  KlassHandle klassklass(THREAD, Universe::arrayKlassKlassObj());  
  arrayKlassHandle k = base_create_array_klass(o.vtbl_value(), header_size(), klassklass, CHECK_0);
  KlassHandle super (THREAD, k->super());
  complete_create_array_klass(k, super, CHECK_0);
  return k();
}
Ejemplo n.º 9
0
Archivo: pdu.cpp Proyecto: Imva/libtins
uint32_t PDU::size() const {
    uint32_t sz = header_size() + trailer_size();
    const PDU *ptr(_inner_pdu);
    while(ptr) {
        sz += ptr->header_size() + ptr->trailer_size();
        ptr = ptr->inner_pdu();
    }
    return sz;
}
klassOop constantPoolCacheKlass::create_klass(TRAPS) {
  constantPoolCacheKlass o;
  KlassHandle klassklass(THREAD, Universe::arrayKlassKlassObj());  
arrayKlassHandle k=base_create_array_klass(o.vtbl_value(),header_size(),klassklass,constantPoolCacheKlass_kid,CHECK_NULL);
  KlassHandle super (THREAD, k->super());
  complete_create_array_klass(k, super, CHECK_NULL);
  KlassTable::bindReservedKlassId(k(), constantPoolCacheKlass_kid);
  return k();
}
Ejemplo n.º 11
0
void IPSecAH::write_serialization(uint8_t* buffer, uint32_t total_sz) {
    if (inner_pdu()) {
        next_header(Internals::pdu_flag_to_ip_type(inner_pdu()->pdu_type()));
    }
    length(header_size() / sizeof(uint32_t) - 2);
    OutputMemoryStream output(buffer, total_sz);
    output.write(header_);
    output.write(icv_.begin(), icv_.end());
}
Ejemplo n.º 12
0
void header_init(struct header_chunk* header, const struct cap_header* cp, int layer){
	header->cp = cp;
	header->protocol = NULL;
	header->last_net = (struct network){"", "", 0};
	header->truncated = 0;
	header->ptr = NULL;
}

int header_walk(struct header_chunk* header){
	if ( !header->ptr ){
		header->protocol = protocol_get(PROTOCOL_ETHERNET);
		header->ptr = header->cp->payload;

		if ( limited_caplen(header->cp, header->ptr, header_size(header)) ){
			header->truncated = 1;
		}

		return 1;
	}

	return next_payload(header);
}

void header_dump(FILE* fp, const struct header_chunk* header, const char* prefix){
	if ( !header->protocol->dump ){
		fprintf(fp, "%s(not implemented)\n", prefix);
		return;
	}

	if ( header->truncated && !header->protocol->partial_print ){
		fprintf(fp, "%s[Packet size limited during capture]\n", prefix);
		return;
	}


	ptr_sanity(header->cp, header->ptr, NULL);
	header->protocol->dump(fp, header, header->ptr, prefix, 0);
}

void header_format(FILE* fp, const struct header_chunk* header, int flags){
	if ( header->truncated && !header->protocol->partial_print ){
		fprintf(fp, ": %s [Packet size limited during capture]", header->protocol->name);
		return;
	}

	if ( !header->protocol->format ){
		fprintf(fp, ": %s", header->protocol->name);
		return;
	}

	ptr_sanity(header->cp, header->ptr, NULL);
	header->protocol->format(fp, header, header->ptr, flags);
}

size_t header_size(const struct header_chunk* header){
	return header->protocol->size_dyn ? header->protocol->size_dyn(header, header->ptr) : header->protocol->size;
}
Ejemplo n.º 13
0
klassOop klassKlass::create_klass(TRAPS) {
  KlassHandle h_this_klass;
  klassKlass o;
  // for bootstrapping, handles may not be available yet.
  klassOop k = base_create_klass_oop(h_this_klass, header_size(), o.vtbl_value(), CHECK_NULL);
  k->set_klass(k); // point to thyself
  // Do not try to allocate mirror, java.lang.Class not loaded at this point.
  // See Universe::fixup_mirrors()
  return k;
}
Ejemplo n.º 14
0
void mixinOopDesc::bootstrap_object(bootstrap* st) {
  memOopDesc::bootstrap_header(st);
  st->read_oop((oop*)&addr()->_methods);
  st->read_oop((oop*)&addr()->_inst_vars);
  st->read_oop((oop*)&addr()->_class_vars);
  st->read_oop((oop*)&addr()->_primary_invocation);
  st->read_oop((oop*)&addr()->_class_mixin);
  st->read_oop((oop*)&addr()->_installed);
  memOopDesc::bootstrap_body(st, header_size());
}
Ejemplo n.º 15
0
  static size_t allocation_size(jint statics_size, jint vtable_length) {
    size_t size = header_size() + statics_size;

#if USE_EMBEDDED_VTABLE_BITMAP
    size += bitmap_size(vtable_length);
#else
    (void)vtable_length;
#endif

    return align_allocation_size(size);
  }
Ejemplo n.º 16
0
static void do_init(int ifindex)
{
  enum ef_pd_flags pd_flags = 0;
  ef_filter_spec filter_spec;
  struct pkt_buf* pb;
  enum ef_vi_flags vi_flags = 0;
  int i;

  if( cfg_use_vf )
    pd_flags |= EF_PD_VF;
  if( cfg_phys_mode )
    pd_flags |= EF_PD_PHYS_MODE;
  if( cfg_disable_tx_push )
    vi_flags |= EF_VI_TX_PUSH_DISABLE;

  /* Allocate virtual interface. */
  TRY(ef_driver_open(&driver_handle));
  TRY(ef_pd_alloc(&pd, driver_handle, ifindex, pd_flags));
  TRY(ef_vi_alloc_from_pd(&vi, driver_handle, &pd, driver_handle,
                          -1, -1, -1, NULL, -1, vi_flags));
#ifdef __x86_64__
  TRY(ef_pio_alloc(&pio, driver_handle, &pd, -1, driver_handle));
  TRY(ef_pio_link_vi(&pio, driver_handle, &vi, driver_handle));
#else
  /* PIO is only available on x86_64 systems */
  TEST(0);
#endif

  ef_filter_spec_init(&filter_spec, EF_FILTER_FLAG_NONE);
  TRY(ef_filter_spec_set_ip4_local(&filter_spec, IPPROTO_UDP,
                                   sa_local.sin_addr.s_addr,
                                   sa_local.sin_port));
  TRY(ef_vi_filter_add(&vi, driver_handle, &filter_spec, NULL));

  {
    int bytes = (N_RX_BUFS + 1) * RX_BUF_SIZE;
    void* p;
    TEST(posix_memalign(&p, 4096, bytes) == 0);
    TRY(ef_memreg_alloc(&memreg, driver_handle, &pd, driver_handle, p, bytes));
    for( i = 0; i <= N_RX_BUFS; ++i ) {
      pkt_bufs[i] = (void*) ((char*) p + i * RX_BUF_SIZE);
      pkt_bufs[i]->dma_buf_addr = ef_memreg_dma_addr(&memreg, i * RX_BUF_SIZE);
    }
  }

  for( i = 0; i <= N_RX_BUFS; ++i ) {
    pb = pkt_bufs[i];
    pb->id = i;
    pb->dma_buf_addr += MEMBER_OFFSET(struct pkt_buf, dma_buf);
  }

  init_udp_pkt(pkt_bufs[N_RX_BUFS]->dma_buf, cfg_payload_len);
  tx_frame_len = cfg_payload_len + header_size();
}
Ejemplo n.º 17
0
void FreeChunk::mangleFreed(size_t size) {
  assert(baadbabeHeapWord != deadbeefHeapWord, "Need distinct patterns");
  // mangle all but the header of a just-freed block of storage
  // just prior to passing it to the storage dictionary
  assert(size >= MinChunkSize, "smallest size of object");
  assert(size == _size, "just checking");
  HeapWord* addr = (HeapWord*)this;
  size_t hdr = header_size();
  Memory::set_words(addr + hdr, size - hdr,
                    deadbeefHeapWord);
}
Ejemplo n.º 18
0
int ConstMethod::size(int code_size,
                      InlineTableSizes* sizes) {
  int extra_bytes = code_size;
  if (sizes->compressed_linenumber_size() > 0) {
    extra_bytes += sizes->compressed_linenumber_size();
  }
  if (sizes->checked_exceptions_length() > 0) {
    extra_bytes += sizeof(u2);
    extra_bytes += sizes->checked_exceptions_length() * sizeof(CheckedExceptionElement);
  }
  if (sizes->localvariable_table_length() > 0) {
    extra_bytes += sizeof(u2);
    extra_bytes +=
              sizes->localvariable_table_length() * sizeof(LocalVariableTableElement);
  }
  if (sizes->exception_table_length() > 0) {
    extra_bytes += sizeof(u2);
    extra_bytes += sizes->exception_table_length() * sizeof(ExceptionTableElement);
  }
  if (sizes->generic_signature_index() != 0) {
    extra_bytes += sizeof(u2);
  }
  // This has to be a less-than-or-equal check, because we might be
  // storing information from a zero-length MethodParameters
  // attribute.  We have to store these, because in some cases, they
  // cause the reflection API to throw a MalformedParametersException.
  if (sizes->method_parameters_length() >= 0) {
    extra_bytes += sizeof(u2);
    extra_bytes += sizes->method_parameters_length() * sizeof(MethodParametersElement);
  }

  // Align sizes up to a word.
  extra_bytes = align_size_up(extra_bytes, BytesPerWord);

  // One pointer per annotation array
  if (sizes->method_annotations_length() > 0) {
    extra_bytes += sizeof(AnnotationArray*);
  }
  if (sizes->parameter_annotations_length() > 0) {
    extra_bytes += sizeof(AnnotationArray*);
  }
  if (sizes->type_annotations_length() > 0) {
    extra_bytes += sizeof(AnnotationArray*);
  }
  if (sizes->default_annotations_length() > 0) {
    extra_bytes += sizeof(AnnotationArray*);
  }

  int extra_words = align_size_up(extra_bytes, BytesPerWord) / BytesPerWord;
  assert(extra_words == extra_bytes/BytesPerWord, "should already be aligned");
  return align_metadata_size(header_size() + extra_words);
}
Ejemplo n.º 19
0
void FreeChunk::mangleAllocated(size_t size) {
  // mangle all but the header of a just-allocated block
  // of storage
  assert(size >= MinChunkSize, "smallest size of object");
  // we can't assert that _size == size because this may be an
  // allocation out of a linear allocation block
  assert(sizeof(FreeChunk) % HeapWordSize == 0,
         "shouldn't write beyond chunk");
  HeapWord* addr = (HeapWord*)this;
  size_t hdr = header_size();
  Memory::set_words(addr + hdr, size - hdr,
                    baadbabeHeapWord);
}
Ejemplo n.º 20
0
void EthernetII::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
    #ifdef TINS_DEBUG
    assert(total_sz >= header_size() + trailer_size());
    #endif

    /* Inner type defaults to IP */
    if (inner_pdu()) {
        Constants::Ethernet::e flag = Internals::pdu_flag_to_ether_type(
            inner_pdu()->pdu_type()
        );
        payload_type(static_cast<uint16_t>(flag));
    }
    memcpy(buffer, &_eth, sizeof(ethhdr));
    uint32_t trailer = trailer_size();
    if (trailer) {
        uint32_t trailer_offset = header_size();
        if (inner_pdu())
            trailer_offset += inner_pdu()->size();
        memset(buffer + trailer_offset, 0, trailer);
    }

}
Ejemplo n.º 21
0
void RSNEAPOL::write_body(uint8_t *buffer, uint32_t total_sz) {
    #ifdef TINS_DEBUG
    assert(total_sz >= header_size() - sizeof(eapolhdr));
    #endif
    if(_key.size()) {
        if(!_header.key_t) {
            _header.key_length = Endian::host_to_be<uint16_t>(32);
            wpa_length(_key.size());
        }
        else if(_key.size()) {
            wpa_length(_key.size());
        }
    }
    std::memcpy(buffer, &_header, sizeof(_header));
    buffer += sizeof(_header);
    std::copy(_key.begin(), _key.end(), buffer);
}
Ejemplo n.º 22
0
void DHCP::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
    #ifdef TINS_DEBUG
    assert(total_sz >= header_size());
    #endif
    if(_size) {
        vend_type &result(BootP::vend());
        result.resize(_size);
        uint8_t *ptr = &result[0] + sizeof(uint32_t);
        // Magic cookie
        *((uint32_t*)&result[0]) = Endian::host_to_be<uint32_t>(0x63825363);
        for(options_type::const_iterator it = _options.begin(); it != _options.end(); ++it) {
            *(ptr++) = it->option();
            *(ptr++) = it->length_field();
            std::copy(it->data_ptr(), it->data_ptr() + it->data_size(), ptr);
            ptr += it->data_size();
        }
    }
    BootP::write_serialization(buffer, total_sz, parent);
}
int constMethodOopDesc::object_size(int code_size,
                                    int compressed_line_number_size,
                                    int local_variable_table_length,
                                    int checked_exceptions_length) {
  int extra_bytes = code_size;
  if (compressed_line_number_size > 0) {
    extra_bytes += compressed_line_number_size;
  }
  if (checked_exceptions_length > 0) {
    extra_bytes += sizeof(u2);
    extra_bytes += checked_exceptions_length * sizeof(CheckedExceptionElement);
  }
  if (local_variable_table_length > 0) {
    extra_bytes += sizeof(u2);
    extra_bytes +=
              local_variable_table_length * sizeof(LocalVariableTableElement);
  }
  int extra_words = align_size_up(extra_bytes, BytesPerWord) / BytesPerWord;
  return align_object_size(header_size() + extra_words);
}
Ejemplo n.º 24
0
static int next_payload(struct header_chunk* header){
	/* stop processing if protocol doesn't define next_payload */
	if ( !header->protocol->next_payload ){
		return 0;
	}

	/* stop if previous header was truncated */
	if ( header->truncated ){
		return 0;
	}

	const char* next = header->ptr;
	const struct caputils_protocol* current = header->protocol;
	enum caputils_protocol_type type = current->next_payload(header, header->ptr, &next);

	header->ptr = next;
	header->protocol = protocol_get(type);
	if ( !header->protocol ){
		fprintf(stderr, "invalid protocol type %d, make sure protocol is registerd\n", type);
		abort();
	}

	/* validate payload pointer */
	if ( (header->ptr == NULL && type == PROTOCOL_DONE) || limited_caplen(header->cp, header->ptr, 0) ){
		header->ptr = NULL;
		header->truncated = 1;
		return 0;
	}

	/* make sure pointer is actually inside the captured packet (and not pointing at random data because of a corrupted packet) */
	ptr_sanity(header->cp, header->ptr, current);

	/* ensure there is enough data left */
	if ( limited_caplen(header->cp, header->ptr, header_size(header)) ){
		header->truncated = 1;
	}

	return
		type != PROTOCOL_UNKNOWN &&
		type != PROTOCOL_DONE;
}
Ejemplo n.º 25
0
void TaskMirrorDesc::variable_oops_do(void do_oop(OopDesc **)) {

  if (_object_size == header_size()) {
    // no statics so don't continue.  It may be a size_type_array class which
    // isn't really an instance.  Hence trying to obtain the embedded_oop_map
    // will result in a crash
    return;
  }

  // The statics are embedded at the end of this TaskMirrorDesc but the oopmap
  // for them is in the JavaClass object
  if (_containing_class != NULL) {
    jubyte *map = _containing_class->embedded_oop_map();
    // skip over non-static oopmap entries to get to the statics
    while (*map++ != OopMapSentinel) {}
    if (*map != OopMapSentinel) {
        map_oops_do(map, do_oop);
    }
  }

}
Ejemplo n.º 26
0
ssize_t
RecordSetOutBase::write_header (byte_t* const buf, ssize_t const size)
{
    int const csize(check_size(check_type_));

    assert (header_size_max() + csize <= size);

    ssize_t const hdr_offset(header_size_max() - header_size());

    assert (hdr_offset >= 0);

    size_ -= hdr_offset;

    int off(hdr_offset);

    buf[off] = (static_cast<byte_t>(version_) << 4) | /* upper 4 bytes: ver */
               (static_cast<byte_t>(check_type_) & 0x0f);
    off += 1;

    off += uleb128_encode(size_,  buf + off, size - off);
    off += uleb128_encode(count_, buf + off, size - off);

    /* write header CRC */
    uint32_t const crc(gu_fast_hash32(buf + hdr_offset, off - hdr_offset));
    *(reinterpret_cast<uint32_t*>(buf + off)) = htog(crc);

    off += VER1_CRC_SIZE;

    /* append payload checksum */
    if (check_type_ != CHECK_NONE)
    {
        assert (csize <= size - off);
        check_.append (buf + hdr_offset, off - hdr_offset); /* append header */
        check_.gather (buf + off, csize);
    }

    return hdr_offset;
}
Ejemplo n.º 27
0
void ClassInfoDesc::variable_oops_do(void do_oop(OopDesc**)) {
  //
  // Reminder:: remember to change ROMWriter::stream_class_info()
  // whenever you change this function!
  //

  if (_access_flags.is_array_class()) {
    //do_oop((OopDesc**)&array._name);
  } else {
    do_oop((OopDesc**)&instance._methods);
    do_oop((OopDesc**)&instance._local_interfaces);
    do_oop((OopDesc**)&instance._fields);
    do_oop((OopDesc**)&instance._constants);
#if ENABLE_REFLECTION
    do_oop((OopDesc**)&instance._inner_classes);
#endif
  }

  // vtable
  OopDesc** vtable = (OopDesc**) ((address) this + header_size());
  int i;
  for (i = 0; i < _vtable_length; i++) {
    do_oop(vtable++);  // visit virtual method
  }

  // itable
  OopDesc** itable = vtable;
  OopDesc** itable_end = (OopDesc**) ((address) this + _object_size);
  for (i = 0; i < _itable_length; i++) {
    itable++;          // skip interface klass_index
    itable++;          // skip integer method index
  }
  while (itable < itable_end) {
    do_oop(itable++);  // visit interface method
  }    
}
Ejemplo n.º 28
0
void Dot11::write_serialization(uint8_t *buffer, uint32_t total_sz, const PDU *parent) {
    #ifdef TINS_DEBUG
    assert(total_sz >= header_size());
    #endif
    memcpy(buffer, &_header, sizeof(_header));
    buffer += sizeof(_header);
    total_sz -= sizeof(_header);

    uint32_t written = write_ext_header(buffer, total_sz);
    buffer += written;
    total_sz -= written;

    uint32_t child_len = write_fixed_parameters(buffer, total_sz - _options_size);
    buffer += child_len;
    #ifdef TINS_DEBUG
    assert(total_sz >= child_len + _options_size);
    #endif
    for(std::list<option>::const_iterator it = _options.begin(); it != _options.end(); ++it) {
        *(buffer++) = it->option();
        *(buffer++) = it->length_field();
        std::copy(it->data_ptr(), it->data_ptr() + it->data_size(), buffer);
        buffer += it->data_size();
    }
}
int object_size()const{return header_size();}
Ejemplo n.º 30
0
 static int referent_index_offset() {
   return header_size() + 0 * sizeof(kjobject);
 }