/* Java Native Method for exit */
static void
MTRACE_native_exit(JNIEnv *env, jclass klass, jobject thread, jint cnum, jint mnum)
{
enter_critical_section(gdata->jvmti);
{
/* It's possible we get here right after VmDeath event, be careful */
if ( !gdata->vm_is_dead ) {
ClassInfo *cp;
MethodInfo *mp;
if ( cnum >= gdata->ccount ) {
fatal_error("ERROR: Class number out of range\n");
}
cp = gdata->classes + cnum;
if ( mnum >= cp->mcount ) {
fatal_error("ERROR: Method number out of range\n");
}
mp = cp->methods + mnum;
if ( interested((char*)cp->name, (char*)mp->name,
gdata->include, gdata->exclude) ) {
mp->returns++;
}
}
}
exit_critical_section(gdata->jvmti);
}
STDMETHODIMP EventSource::RegisterListener(IEventListener * aListener,
ComSafeArrayIn(VBoxEventType_T, aInterested),
BOOL aActive)
{
CheckComArgNotNull(aListener);
CheckComArgSafeArrayNotNull(aInterested);
AutoCaller autoCaller(this);
if (FAILED(autoCaller.rc())) return autoCaller.rc();
{
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
Listeners::const_iterator it = m->mListeners.find(aListener);
if (it != m->mListeners.end())
return setError(E_INVALIDARG,
tr("This listener already registered"));
com::SafeArray<VBoxEventType_T> interested(ComSafeArrayInArg (aInterested));
RecordHolder<ListenerRecord> lrh(new ListenerRecord(aListener, interested, aActive, this));
m->mListeners.insert(Listeners::value_type(aListener, lrh));
}
VBoxEventDesc evDesc;
evDesc.init(this, VBoxEventType_OnEventSourceChanged, aListener, TRUE);
evDesc.fire(0);
return S_OK;
}
HRESULT EventSource::registerListener(const ComPtr<IEventListener> &aListener,
const std::vector<VBoxEventType_T> &aInteresting,
BOOL aActive)
{
AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
if (m->fShutdown)
return setError(VBOX_E_INVALID_OBJECT_STATE,
tr("This event source is already shut down"));
Listeners::const_iterator it = m->mListeners.find(aListener);
if (it != m->mListeners.end())
return setError(E_INVALIDARG,
tr("This listener already registered"));
com::SafeArray<VBoxEventType_T> interested(aInteresting);
RecordHolder<ListenerRecord> lrh(new ListenerRecord(aListener, interested, aActive, this));
m->mListeners.insert(Listeners::value_type((IEventListener *)aListener, lrh));
VBoxEventDesc evDesc;
evDesc.init(this, VBoxEventType_OnEventSourceChanged, (IEventListener *)aListener, TRUE);
evDesc.fire(0);
return S_OK;
}
static int
get_size(struct lib_context *lc, const char *path, char *name, int sysfs)
{
int fd, ret = 0;
char *dev_path;
struct dev_info *di = NULL;
if (!(dev_path = dbg_malloc(strlen(_PATH_DEV) + strlen(name) + 1)))
return log_alloc_err(lc, __func__);
sprintf(dev_path, "%s%s", _PATH_DEV, name);
if (!interested(lc, dev_path)) {
ret = 0;
goto out;
}
if (removable_device(lc, dev_path) ||
!(di = alloc_dev_info(lc, dev_path)) ||
(sysfs && !sysfs_get_size(lc, di, path, name)) ||
(fd = open(dev_path, O_RDONLY)) == -1)
goto out;
if (di_ioctl(lc, fd, di)) {
list_add(&di->list, LC_DI(lc));
ret = 1;
}
close(fd);
out:
dbg_free(dev_path);
if (!ret && di)
free_dev_info(lc, di);
return ret;
}
void PeerWireClient::processIncomingData()
{
invalidateTimeout = true;
if (!receivedHandShake) {
// Check that we received enough data
if (bytesAvailable() < MinimalHeaderSize)
return;
// Sanity check the protocol ID
QByteArray id = read(ProtocolIdSize + 1);
if (id.at(0) != ProtocolIdSize || !id.mid(1).startsWith(ProtocolId)) {
abort();
return;
}
// Discard 8 reserved bytes, then read the info hash and peer ID
(void) read(8);
// Read infoHash
QByteArray peerInfoHash = read(20);
if (!infoHash.isEmpty() && peerInfoHash != infoHash) {
abort();
return;
}
emit infoHashReceived(peerInfoHash);
if (infoHash.isEmpty()) {
abort();
return;
}
// Send handshake
if (!sentHandShake)
sendHandShake();
receivedHandShake = true;
}
// Handle delayed peer id arrival
if (!gotPeerId) {
if (bytesAvailable() < 20)
return;
gotPeerId = true;
if (read(20) == peerIdString) {
// We connected to ourself
abort();
return;
}
}
// Initialize keep-alive timer
if (!keepAliveTimer)
keepAliveTimer = startTimer(KeepAliveInterval);
do {
// Find the packet length
if (nextPacketLength == -1) {
if (bytesAvailable() < 4)
return;
char tmp[4];
read(tmp, sizeof(tmp));
nextPacketLength = fromNetworkData(tmp);
if (nextPacketLength < 0 || nextPacketLength > 200000) {
// Prevent DoS
abort();
return;
}
}
// KeepAlive
if (nextPacketLength == 0) {
nextPacketLength = -1;
continue;
}
// Wait with parsing until the whole packet has been received
if (bytesAvailable() < nextPacketLength)
return;
// Read the packet
QByteArray packet = read(nextPacketLength);
if (packet.size() != nextPacketLength) {
abort();
return;
}
switch (packet.at(0)) {
case ChokePacket:
// We have been choked.
pwState |= ChokedByPeer;
incoming.clear();
if (pendingRequestTimer)
killTimer(pendingRequestTimer);
emit choked();
break;
case UnchokePacket:
// We have been unchoked.
pwState &= ~ChokedByPeer;
emit unchoked();
break;
case InterestedPacket:
// The peer is interested in downloading.
pwState |= PeerIsInterested;
emit interested();
break;
case NotInterestedPacket:
// The peer is not interested in downloading.
pwState &= ~PeerIsInterested;
emit notInterested();
break;
case HavePacket: {
// The peer has a new piece available.
quint32 index = fromNetworkData(&packet.data()[1]);
if (index < quint32(peerPieces.size())) {
// Only accept indexes within the valid range.
peerPieces.setBit(int(index));
}
emit piecesAvailable(availablePieces());
break;
}
case BitFieldPacket:
// The peer has the following pieces available.
for (int i = 1; i < packet.size(); ++i) {
for (int bit = 0; bit < 8; ++bit) {
if (packet.at(i) & (1 << (7 - bit))) {
int bitIndex = int(((i - 1) * 8) + bit);
if (bitIndex >= 0 && bitIndex < peerPieces.size()) {
// Occasionally, broken clients claim to have
// pieces whose index is outside the valid range.
// The most common mistake is the index == size
// case.
peerPieces.setBit(bitIndex);
}
}
}
}
emit piecesAvailable(availablePieces());
break;
case RequestPacket: {
// The peer requests a block.
quint32 index = fromNetworkData(&packet.data()[1]);
quint32 begin = fromNetworkData(&packet.data()[5]);
quint32 length = fromNetworkData(&packet.data()[9]);
emit blockRequested(int(index), int(begin), int(length));
break;
}
case PiecePacket: {
int index = int(fromNetworkData(&packet.data()[1]));
int begin = int(fromNetworkData(&packet.data()[5]));
incoming.removeAll(TorrentBlock(index, begin, packet.size() - 9));
// The peer sends a block.
emit blockReceived(index, begin, packet.mid(9));
// Kill the pending block timer.
if (pendingRequestTimer) {
killTimer(pendingRequestTimer);
pendingRequestTimer = 0;
}
break;
}
case CancelPacket: {
// The peer cancels a block request.
quint32 index = fromNetworkData(&packet.data()[1]);
quint32 begin = fromNetworkData(&packet.data()[5]);
quint32 length = fromNetworkData(&packet.data()[9]);
for (int i = 0; i < pendingBlocks.size(); ++i) {
const BlockInfo &blockInfo = pendingBlocks.at(i);
if (blockInfo.pieceIndex == int(index)
&& blockInfo.offset == int(begin)
&& blockInfo.length == int(length)) {
pendingBlocks.removeAt(i);
break;
}
}
break;
}
default:
// Unsupported packet type; just ignore it.
break;
}
nextPacketLength = -1;
} while (bytesAvailable() > 0);
}
/* Callback for JVMTI_EVENT_CLASS_FILE_LOAD_HOOK */
static void JNICALL
cbClassFileLoadHook(jvmtiEnv *jvmti, JNIEnv* env,
jclass class_being_redefined, jobject loader,
const char* name, jobject protection_domain,
jint class_data_len, const unsigned char* class_data,
jint* new_class_data_len, unsigned char** new_class_data)
{
enter_critical_section(jvmti);
{
/* It's possible we get here right after VmDeath event, be careful */
if ( !gdata->vm_is_dead ) {
*new_class_data_len = 0;
*new_class_data = NULL;
/* The tracker class itself? */
if ( interested((char*)name, "", gdata->include, gdata->exclude)
&& strcmp(name, STRING(MTRACE_class)) != 0 ) {
jint cnum;
int system_class;
unsigned char *new_image;
long new_length;
ClassInfo *cp;
/* Get unique number for every class file image loaded */
cnum = gdata->ccount++;
/* Save away class information */
if ( gdata->classes == NULL ) {
gdata->classes = (ClassInfo*)malloc(
gdata->ccount*sizeof(ClassInfo));
} else {
gdata->classes = (ClassInfo*)
realloc((void*)gdata->classes,
gdata->ccount*sizeof(ClassInfo));
}
if ( gdata->classes == NULL ) {
fatal_error("ERROR: Out of malloc memory\n");
}
cp = gdata->classes + cnum;
cp->name = (const char *)strdup(name);
cp->calls = 0;
cp->mcount = 0;
cp->methods = NULL;
/* Is it a system class? If the class load is before VmStart
* then we will consider it a system class that should
* be treated carefully. (See java_crw_demo)
*/
system_class = 0;
if ( !gdata->vm_is_started ) {
system_class = 1;
}
new_image = NULL;
new_length = 0;
/* Call the class file reader/write demo code */
java_crw_demo(cnum,
name,
class_data,
class_data_len,
system_class,
STRING(MTRACE_class), "L" STRING(MTRACE_class) ";",
STRING(MTRACE_entry), "(II)V",
STRING(MTRACE_exit), "(II)V",
NULL, NULL,
NULL, NULL,
&new_image,
&new_length,
NULL,
&mnum_callbacks);
/* If we got back a new class image, return it back as "the"
* new class image. This must be JVMTI Allocate space.
*/
if ( new_length > 0 ) {
unsigned char *jvmti_space;
jvmti_space = (unsigned char *)allocate(jvmti, (jint)new_length);
(void)memcpy((void*)jvmti_space, (void*)new_image, (int)new_length);
*new_class_data_len = (jint)new_length;
*new_class_data = jvmti_space; /* VM will deallocate */
}
/* Always free up the space we get from java_crw_demo() */
if ( new_image != NULL ) {
(void)free((void*)new_image); /* Free malloc() space with free() */
}
}
}
}
exit_critical_section(jvmti);
}
