diff --git a/Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/client/GadpClient.java b/Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/client/GadpClient.java index ad97cb70ef..ce7bb52a88 100644 --- a/Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/client/GadpClient.java +++ b/Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/client/GadpClient.java @@ -143,33 +143,33 @@ public class GadpClient implements DebuggerObjectModel { Gadp.ErrorReply error = MSG_HELPER.expect(msg, Gadp.ErrorReply.getDefaultInstance()); if (error != null) { switch (error.getCode()) { - case NO_INTERFACE: + case EC_NO_INTERFACE: throw new DebuggerModelTypeException(error.getMessage()); - case NO_OBJECT: + case EC_NO_OBJECT: throw new DebuggerModelNoSuchPathException(error.getMessage()); - case BAD_ARGUMENT: + case EC_BAD_ARGUMENT: throw new DebuggerIllegalArgumentException(error.getMessage()); - case MEMORY_ACCESS: + case EC_MEMORY_ACCESS: throw new DebuggerMemoryAccessException(error.getMessage()); - case REGISTER_ACCESS: + case EC_REGISTER_ACCESS: throw new DebuggerRegisterAccessException(error.getMessage()); - case BAD_ADDRESS: + case EC_BAD_ADDRESS: throw new AssertionError( "Client implementation sent an invalid address: " + error.getMessage()); - case BAD_REQUEST: + case EC_BAD_REQUEST: throw new AssertionError( "Client implementation sent an invalid request: " + error.getMessage()); case UNRECOGNIZED: throw new AssertionError( "Server replied with an error code unknown to the client: " + error.getCodeValue() + ": " + error.getMessage()); - case USER_ERROR: + case EC_USER_ERROR: throw new DebuggerUserException(error.getMessage()); - case MODEL_ACCESS: + case EC_MODEL_ACCESS: throw new DebuggerModelAccessException(error.getMessage()); - case UNKNOWN: + case EC_UNKNOWN: throw new RuntimeException("Unknown: " + error.getMessage()); - case NO_VERSION: + case EC_NO_VERSION: default: throw new GadpErrorException(error.getCode(), error.getMessage()); } diff --git a/Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/server/AbstractGadpServer.java b/Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/server/AbstractGadpServer.java index ec1e61fa9c..fbbf2d5de8 100644 --- a/Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/server/AbstractGadpServer.java +++ b/Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/server/AbstractGadpServer.java @@ -23,7 +23,6 @@ import ghidra.comm.service.AbstractAsyncServer; import ghidra.dbg.*; import ghidra.dbg.gadp.error.GadpErrorException; import ghidra.dbg.gadp.protocol.Gadp; -import ghidra.dbg.gadp.protocol.Gadp.ErrorCode; import ghidra.program.model.address.*; public abstract class AbstractGadpServer @@ -59,7 +58,7 @@ public abstract class AbstractGadpServer protected AddressRange getAddressRange(Gadp.AddressRange range) { AddressSpace space = model.getAddressSpace(range.getSpace()); if (space == null) { - throw new GadpErrorException(ErrorCode.BAD_ADDRESS, + throw new GadpErrorException(Gadp.ErrorCode.EC_BAD_ADDRESS, "Unrecognized address space: " + range); } Address min = space.getAddress(range.getOffset()); diff --git a/Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/server/GadpClientHandler.java b/Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/server/GadpClientHandler.java index 79c0347c9a..4827d8bb2c 100644 --- a/Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/server/GadpClientHandler.java +++ b/Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/server/GadpClientHandler.java @@ -292,30 +292,30 @@ public class GadpClientHandler return channel.write(buildError(req, error.getCode(), error.getMessage())); } if (t instanceof UnsupportedOperationException) { - return channel.write(buildError(req, ErrorCode.NOT_SUPPORTED, t.getMessage())); + return channel.write(buildError(req, ErrorCode.EC_NOT_SUPPORTED, t.getMessage())); } if (t instanceof DebuggerModelNoSuchPathException) { - return channel.write(buildError(req, ErrorCode.NO_OBJECT, t.getMessage())); + return channel.write(buildError(req, ErrorCode.EC_NO_OBJECT, t.getMessage())); } if (t instanceof DebuggerModelTypeException) { - return channel.write(buildError(req, ErrorCode.NO_INTERFACE, t.getMessage())); + return channel.write(buildError(req, ErrorCode.EC_NO_INTERFACE, t.getMessage())); } if (t instanceof DebuggerIllegalArgumentException) { - return channel.write(buildError(req, ErrorCode.BAD_ARGUMENT, t.getMessage())); + return channel.write(buildError(req, ErrorCode.EC_BAD_ARGUMENT, t.getMessage())); } if (t instanceof DebuggerMemoryAccessException) { - return channel.write(buildError(req, ErrorCode.MEMORY_ACCESS, t.getMessage())); + return channel.write(buildError(req, ErrorCode.EC_MEMORY_ACCESS, t.getMessage())); } if (t instanceof DebuggerRegisterAccessException) { - return channel.write(buildError(req, ErrorCode.REGISTER_ACCESS, t.getMessage())); + return channel.write(buildError(req, ErrorCode.EC_REGISTER_ACCESS, t.getMessage())); } if (t instanceof DebuggerUserException) { - return channel.write(buildError(req, ErrorCode.USER_ERROR, t.getMessage())); + return channel.write(buildError(req, ErrorCode.EC_USER_ERROR, t.getMessage())); } if (t instanceof DebuggerModelAccessException) { - return channel.write(buildError(req, ErrorCode.MODEL_ACCESS, t.getMessage())); + return channel.write(buildError(req, ErrorCode.EC_MODEL_ACCESS, t.getMessage())); } - return channel.write(buildError(req, ErrorCode.UNKNOWN, "Unknown server-side error")); + return channel.write(buildError(req, ErrorCode.EC_UNKNOWN, "Unknown server-side error")); } protected GadpVersion getVersion() { @@ -367,7 +367,7 @@ public class GadpClientHandler case INVOKE_REQUEST: return processInvoke(msg.getSequence(), msg.getInvokeRequest()); default: - throw new GadpErrorException(ErrorCode.BAD_REQUEST, + throw new GadpErrorException(Gadp.ErrorCode.EC_BAD_REQUEST, "Unrecognized request: " + msg.getMsgCase()); } } @@ -375,7 +375,8 @@ public class GadpClientHandler protected CompletableFuture processConnect(int seqno, Gadp.ConnectRequest req) { String ver = getVersion().getName(); if (!req.getVersionList().contains(ver)) { - throw new GadpErrorException(ErrorCode.NO_VERSION, "No listed version is supported"); + throw new GadpErrorException(Gadp.ErrorCode.EC_NO_VERSION, + "No listed version is supported"); } TargetObjectSchema rootSchema = model.getRootSchema(); return channel.write(Gadp.RootMessage.newBuilder() @@ -523,7 +524,7 @@ public class GadpClientHandler case PID: return attacher.attach(req.getPid()); default: - throw new GadpErrorException(ErrorCode.BAD_REQUEST, + throw new GadpErrorException(Gadp.ErrorCode.EC_BAD_REQUEST, "Unrecognized attach specification:" + req); } }).thenCompose(__ -> { @@ -546,7 +547,7 @@ public class GadpClientHandler AddressRange range = server.getAddressRange(req.getAddress()); return breaks.placeBreakpoint(range, kinds); default: - throw new GadpErrorException(ErrorCode.BAD_REQUEST, + throw new GadpErrorException(Gadp.ErrorCode.EC_BAD_REQUEST, "Unrecognized breakpoint specification: " + req); } }).thenCompose(__ -> { diff --git a/Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/util/GadpValueUtils.java b/Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/util/GadpValueUtils.java index d7515f0949..442c20e52a 100644 --- a/Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/util/GadpValueUtils.java +++ b/Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/util/GadpValueUtils.java @@ -67,13 +67,13 @@ public enum GadpValueUtils { public static TargetBreakpointKind getBreakKind(Gadp.BreakKind kind) { switch (kind) { - case READ: + case BK_READ: return TargetBreakpointKind.READ; - case WRITE: + case BK_WRITE: return TargetBreakpointKind.WRITE; - case EXECUTE: + case BK_EXECUTE: return TargetBreakpointKind.EXECUTE; - case SOFTWARE: + case BK_SOFTWARE: return TargetBreakpointKind.SOFTWARE; default: throw new IllegalArgumentException(); @@ -89,13 +89,13 @@ public enum GadpValueUtils { public static Gadp.BreakKind makeBreakKind(TargetBreakpointKind kind) { switch (kind) { case READ: - return Gadp.BreakKind.READ; + return Gadp.BreakKind.BK_READ; case WRITE: - return Gadp.BreakKind.WRITE; + return Gadp.BreakKind.BK_WRITE; case EXECUTE: - return Gadp.BreakKind.EXECUTE; + return Gadp.BreakKind.BK_EXECUTE; case SOFTWARE: - return Gadp.BreakKind.SOFTWARE; + return Gadp.BreakKind.BK_SOFTWARE; default: throw new IllegalArgumentException(); } @@ -108,9 +108,9 @@ public enum GadpValueUtils { public static TargetAttachKind getAttachKind(Gadp.AttachKind kind) { switch (kind) { - case BY_OBJECT_REF: + case AK_BY_OBJECT_REF: return TargetAttachKind.BY_OBJECT_REF; - case BY_ID: + case AK_BY_ID: return TargetAttachKind.BY_ID; default: throw new IllegalArgumentException(); @@ -126,9 +126,9 @@ public enum GadpValueUtils { public static Gadp.AttachKind makeAttachKind(TargetAttachKind kind) { switch (kind) { case BY_OBJECT_REF: - return Gadp.AttachKind.BY_OBJECT_REF; + return Gadp.AttachKind.AK_BY_OBJECT_REF; case BY_ID: - return Gadp.AttachKind.BY_ID; + return Gadp.AttachKind.AK_BY_ID; default: throw new IllegalArgumentException(); } @@ -141,23 +141,23 @@ public enum GadpValueUtils { public static TargetStepKind getStepKind(Gadp.StepKind kind) { switch (kind) { - case ADVANCE: + case SK_ADVANCE: return TargetStepKind.ADVANCE; - case FINISH: + case SK_FINISH: return TargetStepKind.FINISH; - case INTO: + case SK_INTO: return TargetStepKind.INTO; - case LINE: + case SK_LINE: return TargetStepKind.LINE; - case OVER: + case SK_OVER: return TargetStepKind.OVER; - case OVER_LINE: + case SK_OVER_LINE: return TargetStepKind.OVER_LINE; - case RETURN: + case SK_RETURN: return TargetStepKind.RETURN; - case SKIP: + case SK_SKIP: return TargetStepKind.SKIP; - case UNTIL: + case SK_UNTIL: return TargetStepKind.UNTIL; default: throw new IllegalArgumentException(); @@ -167,23 +167,23 @@ public enum GadpValueUtils { public static Gadp.StepKind makeStepKind(TargetStepKind kind) { switch (kind) { case ADVANCE: - return Gadp.StepKind.ADVANCE; + return Gadp.StepKind.SK_ADVANCE; case FINISH: - return Gadp.StepKind.FINISH; + return Gadp.StepKind.SK_FINISH; case INTO: - return Gadp.StepKind.INTO; + return Gadp.StepKind.SK_INTO; case LINE: - return Gadp.StepKind.LINE; + return Gadp.StepKind.SK_LINE; case OVER: - return Gadp.StepKind.OVER; + return Gadp.StepKind.SK_OVER; case OVER_LINE: - return Gadp.StepKind.OVER_LINE; + return Gadp.StepKind.SK_OVER_LINE; case RETURN: - return Gadp.StepKind.RETURN; + return Gadp.StepKind.SK_RETURN; case SKIP: - return Gadp.StepKind.SKIP; + return Gadp.StepKind.SK_SKIP; case UNTIL: - return Gadp.StepKind.UNTIL; + return Gadp.StepKind.SK_UNTIL; default: throw new IllegalArgumentException(); } @@ -191,15 +191,15 @@ public enum GadpValueUtils { public static TargetExecutionState getExecutionState(Gadp.ExecutionState state) { switch (state) { - case INACTIVE: + case ES_INACTIVE: return TargetExecutionState.INACTIVE; - case ALIVE: + case ES_ALIVE: return TargetExecutionState.ALIVE; - case STOPPED: + case ES_STOPPED: return TargetExecutionState.STOPPED; - case RUNNING: + case ES_RUNNING: return TargetExecutionState.RUNNING; - case TERMINATED: + case ES_TERMINATED: return TargetExecutionState.TERMINATED; default: throw new IllegalArgumentException(); @@ -209,15 +209,15 @@ public enum GadpValueUtils { public static Gadp.ExecutionState makeExecutionState(TargetExecutionState state) { switch (state) { case INACTIVE: - return Gadp.ExecutionState.INACTIVE; + return Gadp.ExecutionState.ES_INACTIVE; case ALIVE: - return Gadp.ExecutionState.ALIVE; + return Gadp.ExecutionState.ES_ALIVE; case STOPPED: - return Gadp.ExecutionState.STOPPED; + return Gadp.ExecutionState.ES_STOPPED; case RUNNING: - return Gadp.ExecutionState.RUNNING; + return Gadp.ExecutionState.ES_RUNNING; case TERMINATED: - return Gadp.ExecutionState.TERMINATED; + return Gadp.ExecutionState.ES_TERMINATED; default: throw new IllegalArgumentException(); } @@ -230,25 +230,25 @@ public enum GadpValueUtils { return TargetEventType.STOPPED; case EV_RUNNING: return TargetEventType.RUNNING; - case PROCESS_CREATED: + case EV_PROCESS_CREATED: return TargetEventType.PROCESS_CREATED; - case PROCESS_EXITED: + case EV_PROCESS_EXITED: return TargetEventType.PROCESS_EXITED; - case THREAD_CREATED: + case EV_THREAD_CREATED: return TargetEventType.THREAD_CREATED; - case THREAD_EXITED: + case EV_THREAD_EXITED: return TargetEventType.THREAD_EXITED; - case MODULE_LOADED: + case EV_MODULE_LOADED: return TargetEventType.MODULE_LOADED; - case MODULE_UNLOADED: + case EV_MODULE_UNLOADED: return TargetEventType.MODULE_UNLOADED; - case BREAKPOINT_HIT: + case EV_BREAKPOINT_HIT: return TargetEventType.BREAKPOINT_HIT; - case STEP_COMPLETED: + case EV_STEP_COMPLETED: return TargetEventType.STEP_COMPLETED; - case EXCEPTION: + case EV_EXCEPTION: return TargetEventType.EXCEPTION; - case SIGNAL: + case EV_SIGNAL: return TargetEventType.SIGNAL; } } @@ -261,25 +261,25 @@ public enum GadpValueUtils { case RUNNING: return Gadp.TargetEventType.EV_RUNNING; case PROCESS_CREATED: - return Gadp.TargetEventType.PROCESS_CREATED; + return Gadp.TargetEventType.EV_PROCESS_CREATED; case PROCESS_EXITED: - return Gadp.TargetEventType.PROCESS_EXITED; + return Gadp.TargetEventType.EV_PROCESS_EXITED; case THREAD_CREATED: - return Gadp.TargetEventType.THREAD_CREATED; + return Gadp.TargetEventType.EV_THREAD_CREATED; case THREAD_EXITED: - return Gadp.TargetEventType.THREAD_EXITED; + return Gadp.TargetEventType.EV_THREAD_EXITED; case MODULE_LOADED: - return Gadp.TargetEventType.MODULE_LOADED; + return Gadp.TargetEventType.EV_MODULE_LOADED; case MODULE_UNLOADED: - return Gadp.TargetEventType.MODULE_UNLOADED; + return Gadp.TargetEventType.EV_MODULE_UNLOADED; case BREAKPOINT_HIT: - return Gadp.TargetEventType.BREAKPOINT_HIT; + return Gadp.TargetEventType.EV_BREAKPOINT_HIT; case STEP_COMPLETED: - return Gadp.TargetEventType.STEP_COMPLETED; + return Gadp.TargetEventType.EV_STEP_COMPLETED; case EXCEPTION: - return Gadp.TargetEventType.EXCEPTION; + return Gadp.TargetEventType.EV_EXCEPTION; case SIGNAL: - return Gadp.TargetEventType.SIGNAL; + return Gadp.TargetEventType.EV_SIGNAL; } } @@ -383,22 +383,22 @@ public enum GadpValueUtils { public static Gadp.UpdateMode makeUpdateMode(TargetUpdateMode mode) { switch (mode) { case SOLICITED: - return Gadp.UpdateMode.SOLICITED; + return Gadp.UpdateMode.UM_SOLICITED; case FIXED: - return Gadp.UpdateMode.FIXED; + return Gadp.UpdateMode.UM_FIXED; case UNSOLICITED: default: - return Gadp.UpdateMode.UNSOLICITED; + return Gadp.UpdateMode.UM_UNSOLICITED; } } public static TargetUpdateMode getUpdateMode(Gadp.UpdateMode mode) { switch (mode) { - case FIXED: + case UM_FIXED: return TargetUpdateMode.FIXED; - case SOLICITED: + case UM_SOLICITED: return TargetUpdateMode.SOLICITED; - case UNSOLICITED: + case UM_UNSOLICITED: default: return TargetUpdateMode.UNSOLICITED; } diff --git a/Ghidra/Debug/Debugger-gadp/src/main/proto/gadp.proto b/Ghidra/Debug/Debugger-gadp/src/main/proto/gadp.proto index fc514fd979..af875ddeb9 100644 --- a/Ghidra/Debug/Debugger-gadp/src/main/proto/gadp.proto +++ b/Ghidra/Debug/Debugger-gadp/src/main/proto/gadp.proto @@ -17,18 +17,18 @@ syntax = "proto3"; package ghidra.dbg.gadp.protocol; enum ErrorCode { - UNKNOWN = 0; - BAD_REQUEST = 1; - NO_VERSION = 2; - NO_OBJECT = 3; - NO_INTERFACE = 4; - BAD_ARGUMENT = 5; - BAD_ADDRESS = 6; - NOT_SUPPORTED = 7; - MEMORY_ACCESS = 8; - REGISTER_ACCESS = 9; - USER_ERROR = 10; - MODEL_ACCESS = 11; + EC_UNKNOWN = 0; + EC_BAD_REQUEST = 1; + EC_NO_VERSION = 2; + EC_NO_OBJECT = 3; + EC_NO_INTERFACE = 4; + EC_BAD_ARGUMENT = 5; + EC_BAD_ADDRESS = 6; + EC_NOT_SUPPORTED = 7; + EC_MEMORY_ACCESS = 8; + EC_REGISTER_ACCESS = 9; + EC_USER_ERROR = 10; + EC_MODEL_ACCESS = 11; } // For testing: cause the server to report an unrecognized request error @@ -78,10 +78,10 @@ message PathList { } enum BreakKind { - READ = 0; - WRITE = 1; - EXECUTE = 2; - SOFTWARE = 3; + BK_READ = 0; + BK_WRITE = 1; + BK_EXECUTE = 2; + BK_SOFTWARE = 3; } message BreakKindsSet { @@ -89,15 +89,15 @@ message BreakKindsSet { } enum StepKind { - INTO = 0; - ADVANCE = 1; - FINISH = 2; - LINE = 3; - OVER = 4; - OVER_LINE = 5; - SKIP = 6; - RETURN = 7; - UNTIL = 8; + SK_INTO = 0; + SK_ADVANCE = 1; + SK_FINISH = 2; + SK_LINE = 3; + SK_OVER = 4; + SK_OVER_LINE = 5; + SK_SKIP = 6; + SK_RETURN = 7; + SK_UNTIL = 8; } message StepKindsSet { @@ -109,8 +109,8 @@ message StringList { } enum AttachKind { - BY_OBJECT_REF = 0; - BY_ID = 1; + AK_BY_OBJECT_REF = 0; + AK_BY_ID = 1; } message AttachKindSet { @@ -118,20 +118,20 @@ message AttachKindSet { } enum ExecutionState { - INACTIVE = 0; - ALIVE = 1; - STOPPED = 2; - RUNNING = 3; - TERMINATED = 4; + ES_INACTIVE = 0; + ES_ALIVE = 1; + ES_STOPPED = 2; + ES_RUNNING = 3; + ES_TERMINATED = 4; } enum PrimitiveKind { - UNDEFINED = 0; - VOID = 1; - UINT = 2; - SINT = 3; - FLOAT = 4; - COMPLEX = 5; + PK_UNDEFINED = 0; + PK_VOID = 1; + PK_UINT = 2; + PK_SINT = 3; + PK_FLOAT = 4; + PK_COMPLEX = 5; } message DataType { @@ -166,9 +166,9 @@ message DataType { } enum UpdateMode { - UNSOLICITED = 0; - SOLICITED = 1; - FIXED = 2; + UM_UNSOLICITED = 0; + UM_SOLICITED = 1; + UM_FIXED = 2; } enum ValueType { @@ -493,18 +493,18 @@ message InvokeReply { } enum TargetEventType { - EV_STOPPED = 0; // Stupid name conflict + EV_STOPPED = 0; EV_RUNNING = 1; - PROCESS_CREATED = 2; - PROCESS_EXITED = 3; - THREAD_CREATED = 4; - THREAD_EXITED = 5; - MODULE_LOADED = 6; - MODULE_UNLOADED = 7; - BREAKPOINT_HIT = 8; - STEP_COMPLETED = 9; - EXCEPTION = 10; - SIGNAL = 11; + EV_PROCESS_CREATED = 2; + EV_PROCESS_EXITED = 3; + EV_THREAD_CREATED = 4; + EV_THREAD_EXITED = 5; + EV_MODULE_LOADED = 6; + EV_MODULE_UNLOADED = 7; + EV_BREAKPOINT_HIT = 8; + EV_STEP_COMPLETED = 9; + EV_EXCEPTION = 10; + EV_SIGNAL = 11; } message TargetEvent {