/** * This is the back-end implementation for disabling * (what are at the JDI level) EventRequests. */ static jboolean clearCommand(PacketInputStream *in, PacketOutputStream *out) { jvmtiError error; jdwpEvent eventType; HandlerID handlerID; EventIndex ei; eventType = inStream_readByte(in); if (inStream_error(in)) { return JNI_TRUE; } handlerID = inStream_readInt(in); if (inStream_error(in)) { return JNI_TRUE; } ei = jdwp2EventIndex(eventType); if (ei == 0) { /* NOTE: Clear command not yet spec'ed to return INVALID_EVENT_TYPE */ outStream_setError(out, JDWP_ERROR(INVALID_EVENT_TYPE)); return JNI_TRUE; } error = eventHandler_freeByID(ei, handlerID); if (error != JVMTI_ERROR_NONE) { outStream_setError(out, map2jdwpError(error)); } return JNI_TRUE; }
static jboolean clearAllBreakpoints(PacketInputStream *in, PacketOutputStream *out) { jvmtiError error; error = eventHandler_freeAll(EI_BREAKPOINT); if (error != JVMTI_ERROR_NONE) { outStream_setError(out, map2jdwpError(error)); } return JNI_TRUE; }
/** * Take JDWP "modifiers" (which are JDI explicit filters, like * addCountFilter(), and implicit filters, like the LocationOnly * filter that goes with breakpoints) and add them as filters * (eventFilter) to the HandlerNode (eventHandler). */ static jdwpError readAndSetFilters(JNIEnv *env, PacketInputStream *in, HandlerNode *node, jint filterCount) { int i; jdwpError serror = JDWP_ERROR(NONE); for (i = 0; i < filterCount; ++i) { jbyte modifier; modifier = inStream_readByte(in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; switch (modifier) { case JDWP_REQUEST_MODIFIER(Conditional): { jint exprID; exprID = inStream_readInt(in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; serror = map2jdwpError( eventFilter_setConditionalFilter(node, i, exprID)); break; } case JDWP_REQUEST_MODIFIER(Count): { jint count; count = inStream_readInt(in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; serror = map2jdwpError( eventFilter_setCountFilter(node, i, count)); break; } case JDWP_REQUEST_MODIFIER(ThreadOnly): { jthread thread; thread = inStream_readThreadRef(env, in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; serror = map2jdwpError( eventFilter_setThreadOnlyFilter(node, i, thread)); break; } case JDWP_REQUEST_MODIFIER(LocationOnly): { jbyte tag; jclass clazz; jmethodID method; jlocation location; tag = inStream_readByte(in); /* not currently used */ tag = tag; /* To shut up lint */ if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; clazz = inStream_readClassRef(env, in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; method = inStream_readMethodID(in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; location = inStream_readLocation(in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; serror = map2jdwpError( eventFilter_setLocationOnlyFilter(node, i, clazz, method, location)); break; } case JDWP_REQUEST_MODIFIER(FieldOnly): { jclass clazz; jfieldID field; clazz = inStream_readClassRef(env, in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; field = inStream_readFieldID(in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; serror = map2jdwpError( eventFilter_setFieldOnlyFilter(node, i, clazz, field)); break; } case JDWP_REQUEST_MODIFIER(ClassOnly): { jclass clazz; clazz = inStream_readClassRef(env, in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; serror = map2jdwpError( eventFilter_setClassOnlyFilter(node, i, clazz)); break; } case JDWP_REQUEST_MODIFIER(ExceptionOnly): { jclass exception; jboolean caught; jboolean uncaught; exception = inStream_readClassRef(env, in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; caught = inStream_readBoolean(in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; uncaught = inStream_readBoolean(in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; serror = map2jdwpError( eventFilter_setExceptionOnlyFilter(node, i, exception, caught, uncaught)); break; } case JDWP_REQUEST_MODIFIER(InstanceOnly): { jobject instance; instance = inStream_readObjectRef(env, in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; serror = map2jdwpError( eventFilter_setInstanceOnlyFilter(node, i, instance)); break; } case JDWP_REQUEST_MODIFIER(ClassMatch): { char *pattern; pattern = inStream_readString(in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; serror = map2jdwpError( eventFilter_setClassMatchFilter(node, i, pattern)); break; } case JDWP_REQUEST_MODIFIER(ClassExclude): { char *pattern; pattern = inStream_readString(in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; serror = map2jdwpError( eventFilter_setClassExcludeFilter(node, i, pattern)); break; } case JDWP_REQUEST_MODIFIER(Step): { jthread thread; jint size; jint depth; thread = inStream_readThreadRef(env, in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; size = inStream_readInt(in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; depth = inStream_readInt(in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) break; serror = map2jdwpError( eventFilter_setStepFilter(node, i, thread, size, depth)); break; } case JDWP_REQUEST_MODIFIER(SourceNameMatch): { char *sourceNamePattern; sourceNamePattern = inStream_readString(in); if ( (serror = inStream_error(in)) != JDWP_ERROR(NONE) ) { break; } serror = map2jdwpError( eventFilter_setSourceNameMatchFilter(node, i, sourceNamePattern)); break; } default: serror = JDWP_ERROR(ILLEGAL_ARGUMENT); break; } if ( serror != JDWP_ERROR(NONE) ) break; } return serror; }
/** * This is the back-end implementation for enabling * (what are at the JDI level) EventRequests. * * Allocate the event request handler (eventHandler). * Add any filters (explicit or implicit). * Install the handler. * Return the handlerID which is used to map subsequent * events to the EventRequest that created it. */ static jboolean setCommand(PacketInputStream *in, PacketOutputStream *out) { jdwpError serror; HandlerNode *node; HandlerID requestID = -1; jdwpEvent eventType; jbyte suspendPolicy; jint filterCount; EventIndex ei; node = NULL; eventType = inStream_readByte(in); if (inStream_error(in)) { return JNI_TRUE; } suspendPolicy = inStream_readByte(in); if (inStream_error(in)) { return JNI_TRUE; } filterCount = inStream_readInt(in); if (inStream_error(in)) { return JNI_TRUE; } ei = jdwp2EventIndex(eventType); if (ei == 0) { outStream_setError(out, JDWP_ERROR(INVALID_EVENT_TYPE)); return JNI_TRUE; } if (ei == EI_VM_INIT) { /* * VM is already initialized so there's no need to install a handler * for this event. However we need to allocate a requestID to send in * the reply to the debugger. */ serror = JDWP_ERROR(NONE); requestID = eventHandler_allocHandlerID(); } else { node = eventHandler_alloc(filterCount, ei, suspendPolicy); if (node == NULL) { outStream_setError(out, JDWP_ERROR(OUT_OF_MEMORY)); return JNI_TRUE; } if (eventType == JDWP_EVENT(METHOD_EXIT_WITH_RETURN_VALUE)) { node->needReturnValue = 1; } else { node->needReturnValue = 0; } serror = readAndSetFilters(getEnv(), in, node, filterCount); if (serror == JDWP_ERROR(NONE)) { jvmtiError error; error = eventHandler_installExternal(node); serror = map2jdwpError(error); if (serror == JDWP_ERROR(NONE)) { requestID = node->handlerID; } } } if (serror == JDWP_ERROR(NONE)) { (void)outStream_writeInt(out, requestID); } else { (void)eventHandler_free(node); outStream_setError(out, serror); } return JNI_TRUE; }
jdwpError transport_startTransport(jboolean isServer, char *name, char *address, long timeout) { jvmtiStartFunction func; jdwpTransportEnv *trans; char threadName[MAXPATHLEN + 100]; jint err; jdwpError serror; /* * If the transport is already loaded then use it * Note: We're assuming here that we don't support multiple * transports - when we do then we need to handle the case * where the transport library only supports a single environment. * That probably means we have a bag a transport environments * to correspond to the transports bag. */ if (transport != NULL) { trans = transport; } else { serror = loadTransport(name, &trans); if (serror != JDWP_ERROR(NONE)) { return serror; } } if (isServer) { char *retAddress; char *launchCommand; TransportInfo *info; jvmtiError error; int len; char* prop_value; info = jvmtiAllocate(sizeof(*info)); if (info == NULL) { return JDWP_ERROR(OUT_OF_MEMORY); } info->name = jvmtiAllocate((int)strlen(name)+1); (void)strcpy(info->name, name); info->address = NULL; info->timeout = timeout; if (info->name == NULL) { serror = JDWP_ERROR(OUT_OF_MEMORY); goto handleError; } if (address != NULL) { info->address = jvmtiAllocate((int)strlen(address)+1); (void)strcpy(info->address, address); if (info->address == NULL) { serror = JDWP_ERROR(OUT_OF_MEMORY); goto handleError; } } info->transport = trans; err = (*trans)->StartListening(trans, address, &retAddress); if (err != JDWPTRANSPORT_ERROR_NONE) { printLastError(trans, err); serror = JDWP_ERROR(TRANSPORT_INIT); goto handleError; } /* * Record listener address in a system property */ len = (int)strlen(name) + (int)strlen(retAddress) + 2; /* ':' and '\0' */ prop_value = (char*)jvmtiAllocate(len); strcpy(prop_value, name); strcat(prop_value, ":"); strcat(prop_value, retAddress); setTransportProperty(getEnv(), prop_value); jvmtiDeallocate(prop_value); (void)strcpy(threadName, "JDWP Transport Listener: "); (void)strcat(threadName, name); func = &acceptThread; error = spawnNewThread(func, (void*)info, threadName); if (error != JVMTI_ERROR_NONE) { serror = map2jdwpError(error); goto handleError; } launchCommand = debugInit_launchOnInit(); if (launchCommand != NULL) { serror = launch(launchCommand, name, retAddress); if (serror != JDWP_ERROR(NONE)) { goto handleError; } } else { if ( ! gdata->quiet ) { TTY_MESSAGE(("Listening for transport %s at address: %s", name, retAddress)); } } return JDWP_ERROR(NONE); handleError: jvmtiDeallocate(info->name); jvmtiDeallocate(info->address); jvmtiDeallocate(info); } else { /* * Note that we don't attempt to do a launch here. Launching * is currently supported only in server mode. */ /* * If we're connecting to another process, there shouldn't be * any concurrent listens, so its ok if we block here in this * thread, waiting for the attach to finish. */ err = (*trans)->Attach(trans, address, timeout, 0); if (err != JDWPTRANSPORT_ERROR_NONE) { printLastError(trans, err); serror = JDWP_ERROR(TRANSPORT_INIT); return serror; } /* * Start the transport loop in a separate thread */ (void)strcpy(threadName, "JDWP Transport Listener: "); (void)strcat(threadName, name); func = &attachThread; err = spawnNewThread(func, (void*)trans, threadName); serror = map2jdwpError(err); } return serror; }
/* * Determine the component class by looking thru all classes for * one that has the signature of the component and the same class loadeer * as the array. See JVM spec 5.3.3: * If the component type is a reference type, C is marked as having * been defined by the defining class loader of the component type. */ static jdwpError getComponentClass(JNIEnv *env, jclass arrayClass, char *componentSignature, jclass *componentClassPtr) { jobject arrayClassLoader; jclass *classes; jint count; jclass componentClass = NULL; jdwpError serror; jvmtiError error; serror = JDWP_ERROR(NONE); error = classLoader(arrayClass, &arrayClassLoader); if (error != JVMTI_ERROR_NONE) { return map2jdwpError(error); } error = allLoadedClasses(&classes, &count); if (error != JVMTI_ERROR_NONE) { serror = map2jdwpError(error); } else { int i; for (i = 0; (i < count) && (componentClass == NULL); i++) { char *signature = NULL; jclass clazz = classes[i]; jboolean match; jvmtiError error; /* signature must match */ error = classSignature(clazz, &signature, NULL); if (error != JVMTI_ERROR_NONE) { serror = map2jdwpError(error); break; } match = strcmp(signature, componentSignature) == 0; jvmtiDeallocate(signature); /* if signature matches, get class loader to check if * it matches */ if (match) { jobject loader; error = classLoader(clazz, &loader); if (error != JVMTI_ERROR_NONE) { return map2jdwpError(error); } match = isSameObject(env, loader, arrayClassLoader); } if (match) { componentClass = clazz; } } jvmtiDeallocate(classes); *componentClassPtr = componentClass; } if (serror == JDWP_ERROR(NONE) && componentClass == NULL) { /* per JVM spec, component class is always loaded * before array class, so this should never occur. */ serror = JDWP_ERROR(NOT_FOUND); } return serror; }