static void send_destination_down_resp(int s, const uint8_t* mac, enum dlep_status_code sc)
{
uint8_t msg[30];
uint16_t msg_len = 0;
/* Write the message header */
uint8_t* p = write_message_header(msg,DLEP_DEST_DOWN_RESP);
/* Write out our MAC Address */
p = write_data_item(p,DLEP_MAC_ADDRESS_DATA_ITEM,6);
memcpy(p,mac,6);
p += 6;
/* Write out our Status code */
p = write_status_code(p,sc);
msg_len = p - msg;
/* Octet 2 and 3 are the message length, minus the length of the header */
write_uint16(msg_len - 4,msg + 2);
printf("Sending Destination Down Response message\n");
if (send(s,msg,msg_len,0) != msg_len)
printf("Failed to send Destination Down Response message: %s\n",strerror(errno));
}
static void
mono_debug_add_type (MonoClass *klass)
{
MonoDebugHandle *handle;
MonoDebugClassEntry *entry;
guint8 buffer [BUFSIZ];
guint8 *ptr, *oldptr;
guint32 size, total_size, max_size;
int base_offset = 0;
if (klass->generic_class || klass->rank ||
(klass->byval_arg.type == MONO_TYPE_VAR) || (klass->byval_arg.type == MONO_TYPE_MVAR))
return;
mono_debugger_lock ();
handle = _mono_debug_get_image (klass->image);
if (!handle) {
mono_debugger_unlock ();
return;
}
max_size = 12 + sizeof (gpointer);
if (max_size > BUFSIZ)
ptr = oldptr = g_malloc (max_size);
else
ptr = oldptr = buffer;
if (klass->valuetype)
base_offset = - (int)(sizeof (MonoObject));
write_leb128 (klass->type_token, ptr, &ptr);
write_leb128 (klass->instance_size + base_offset, ptr, &ptr);
WRITE_UNALIGNED (gpointer, ptr, klass);
ptr += sizeof (gpointer);
size = ptr - oldptr;
g_assert (size < max_size);
total_size = size + sizeof (MonoDebugClassEntry);
g_assert (total_size + 9 < DATA_TABLE_CHUNK_SIZE);
entry = (MonoDebugClassEntry *) allocate_data_item (
handle->type_table, MONO_DEBUG_DATA_ITEM_CLASS, total_size);
entry->size = total_size;
memcpy (&entry->data, oldptr, size);
write_data_item (handle->type_table, (guint8 *) entry);
if (max_size > BUFSIZ)
g_free (oldptr);
mono_debugger_unlock ();
}
static int send_session_init_message(int s, uint32_t router_heartbeat_interval)
{
uint8_t msg[300];
uint16_t msg_len = 0;
size_t peer_type_len = 0;
uint8_t flags = 0x00;
/* Write the message header */
uint8_t* p = write_message_header(msg,DLEP_SESSION_INIT);
/* Write out our Heartbeat Interval */
p = write_data_item(p,DLEP_HEARTBEAT_INTERVAL_DATA_ITEM,4);
p = write_uint32(router_heartbeat_interval,p);
/* Write out Peer Type */
peer_type_len = strlen(PEER_TYPE);
if (peer_type_len > sizeof(msg) - 17)
peer_type_len = sizeof(msg) - 17;
p = write_data_item(p,DLEP_PEER_TYPE_DATA_ITEM, 1 + peer_type_len); /* includes length of the flag + description fields */
*p++ = flags;
if (peer_type_len)
{
memcpy(p, PEER_TYPE, peer_type_len);
p += peer_type_len;
}
msg_len = p - msg;
/* Octet 2 and 3 are the message length, minus the length of the header */
write_uint16(msg_len - 4,msg + 2);
printf("Sending Session Initialization message\n");
if (send(s,msg,msg_len,0) != msg_len)
{
printf("Failed to send Session Initialization message: %s\n",strerror(errno));
return 0;
}
return 1;
}
static uint8_t* write_status_code(uint8_t* msg, enum dlep_status_code sc)
{
/* Write out Status Code header */
msg = write_data_item(msg,DLEP_STATUS_DATA_ITEM,1);
/* And the code */
*msg++ = sc;
return msg;
}
void
mono_debug_add_delegate_trampoline (gpointer code, int size)
{
MonoDebugDelegateTrampolineEntry *entry;
if (!mono_debug_initialized)
return;
mono_debugger_lock ();
entry = (MonoDebugDelegateTrampolineEntry *) allocate_data_item (
mono_symbol_table->global_data_table, MONO_DEBUG_DATA_ITEM_DELEGATE_TRAMPOLINE,
sizeof (MonoDebugDelegateTrampolineEntry));
entry->code = code;
entry->size = size;
write_data_item (mono_symbol_table->global_data_table, (guint8 *) entry);
mono_debugger_unlock ();
}
MonoDebugMethodAddress *
mono_debug_add_method (MonoMethod *method, MonoDebugMethodJitInfo *jit, MonoDomain *domain)
{
MonoMethod *declaring;
MonoDebugDataTable *table;
MonoDebugMethodHeader *header;
MonoDebugMethodAddress *address;
MonoDebugMethodInfo *minfo;
MonoDebugHandle *handle;
guint8 buffer [BUFSIZ];
guint8 *ptr, *oldptr;
guint32 i, size, total_size, max_size;
gboolean is_wrapper = FALSE;
mono_debugger_lock ();
table = lookup_data_table (domain);
handle = _mono_debug_get_image (method->klass->image);
minfo = _mono_debug_lookup_method (method);
if (!minfo || (method->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL) ||
(method->iflags & METHOD_IMPL_ATTRIBUTE_RUNTIME) ||
(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL) ||
(method->flags & METHOD_ATTRIBUTE_ABSTRACT) ||
(method->wrapper_type != MONO_WRAPPER_NONE)) {
is_wrapper = TRUE;
}
max_size = (5 * 5) + 1 + (10 * jit->num_line_numbers) +
(25 + sizeof (gpointer)) * (1 + jit->num_params + jit->num_locals);
if (max_size > BUFSIZ)
ptr = oldptr = g_malloc (max_size);
else
ptr = oldptr = buffer;
write_leb128 (jit->prologue_end, ptr, &ptr);
write_leb128 (jit->epilogue_begin, ptr, &ptr);
write_leb128 (jit->num_line_numbers, ptr, &ptr);
for (i = 0; i < jit->num_line_numbers; i++) {
MonoDebugLineNumberEntry *lne = &jit->line_numbers [i];
write_sleb128 (lne->il_offset, ptr, &ptr);
write_sleb128 (lne->native_offset, ptr, &ptr);
}
*ptr++ = jit->this_var ? 1 : 0;
if (jit->this_var)
write_variable (jit->this_var, ptr, &ptr);
write_leb128 (jit->num_params, ptr, &ptr);
for (i = 0; i < jit->num_params; i++)
write_variable (&jit->params [i], ptr, &ptr);
write_leb128 (jit->num_locals, ptr, &ptr);
for (i = 0; i < jit->num_locals; i++)
write_variable (&jit->locals [i], ptr, &ptr);
size = ptr - oldptr;
g_assert (size < max_size);
total_size = size + sizeof (MonoDebugMethodAddress);
address = (MonoDebugMethodAddress *) allocate_data_item (
table, MONO_DEBUG_DATA_ITEM_METHOD, total_size);
address->header.size = total_size;
address->header.symfile_id = handle ? handle->index : 0;
address->header.domain_id = mono_domain_get_id (domain);
address->header.method_id = is_wrapper ? 0 : minfo->index;
address->header.method = method;
address->code_start = jit->code_start;
address->code_size = jit->code_size;
memcpy (&address->data, oldptr, size);
if (max_size > BUFSIZ)
g_free (oldptr);
declaring = method->is_inflated ? ((MonoMethodInflated *) method)->declaring : method;
header = g_hash_table_lookup (table->method_hash, declaring);
if (!header) {
header = &address->header;
g_hash_table_insert (table->method_hash, declaring, header);
if (is_wrapper) {
MonoDebugWrapperData *wrapper;
header->wrapper_data = wrapper = g_new0 (MonoDebugWrapperData, 1);
wrapper->wrapper_type = method->wrapper_type;
wrapper->method_name = mono_method_full_name (declaring, TRUE);
wrapper->obsolete_cil_code = "";
}
} else {
address->header.wrapper_data = header->wrapper_data;
header->address_list = g_slist_prepend (header->address_list, address);
}
g_hash_table_insert (table->method_address_hash, method, address);
write_data_item (table, (guint8 *) address);
mono_debugger_unlock ();
return address;
}
