| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /** |
| * @author Evgueni Brevnov |
| */ |
| |
| #include <stdarg.h> |
| #include <string.h> |
| #include <assert.h> |
| #include <stdlib.h> |
| |
| #include <apr_dso.h> |
| #include <apr_strings.h> |
| #include <apr_portable.h> |
| |
| #include "port_disasm.h" |
| |
| // this is mostly imperical data |
| #if defined(_IA32_) |
| #define ADDR_SIZE 16 |
| #define MNEMONIC_SIZE 15 |
| #define BYTES_PER_LINE 2 |
| #define BYTES_TOTAL 100 |
| //BYTES_SIZE = BYTES_PER_LINE * 3 |
| #define BYTES_SIZE 6 |
| #else |
| #define ADDR_SIZE 0 |
| #define MNEMONIC_SIZE 0 |
| #define BYTES_PER_LINE 0 |
| #define BYTES_TOTAL 0 |
| #define BYTES_SIZE 0 |
| #endif |
| |
| typedef int (* fprinf_func_t)(port_disassembler_t *, const char *, ...); |
| |
| /* Private Interface */ |
| |
| struct port_disassembler_t { |
| fprinf_func_t fprintf_func; |
| port_disasm_info_t port_info; |
| int line_size; |
| char * real_stream; |
| apr_pool_t * user_pool; |
| apr_file_t * user_file; |
| apr_size_t num_bytes_total; |
| apr_size_t num_bytes_used; |
| }; |
| |
| #if defined(_IA32_) |
| |
| /* General printing routines */ |
| |
| static int disasm_sprint_default(port_disassembler_t * disassembler, const char * fmt, ...) { |
| int required_length; |
| va_list args; |
| va_start(args, fmt); |
| required_length = apr_vsnprintf(NULL, 0, fmt, args); |
| assert(required_length >= 0); |
| // insure space |
| while ((unsigned int)required_length >= disassembler->num_bytes_total - |
| disassembler->num_bytes_used) { |
| void * buf = malloc(disassembler->num_bytes_used); |
| memcpy(buf, disassembler->real_stream, disassembler->num_bytes_used); |
| apr_pool_clear(disassembler->user_pool); |
| disassembler->num_bytes_total *= 2; |
| disassembler->real_stream = apr_palloc(disassembler->user_pool, |
| disassembler->num_bytes_total); |
| memcpy(disassembler->real_stream, buf, disassembler->num_bytes_used); |
| free(buf); |
| } |
| apr_vsnprintf(disassembler->real_stream + disassembler->num_bytes_used, |
| required_length + 1, fmt, args); |
| disassembler->num_bytes_used += required_length; |
| return required_length; |
| } |
| |
| static int disasm_fprint_default(port_disassembler_t * disassembler, const char * fmt, ...) { |
| int required_length; |
| va_list args; |
| va_start(args, fmt); |
| required_length = apr_vsnprintf(NULL, 0, fmt, args); |
| assert(required_length >= 0); |
| // insure space |
| if ((unsigned int)required_length >= disassembler->num_bytes_total - |
| disassembler->num_bytes_used) { |
| apr_file_write(disassembler->user_file, disassembler->real_stream, |
| &disassembler->num_bytes_used); |
| disassembler->num_bytes_used = 0; |
| } |
| while ((unsigned int)required_length >= disassembler->num_bytes_total - |
| disassembler->num_bytes_used) { |
| disassembler->num_bytes_total *= 2; |
| } |
| apr_vsnprintf(disassembler->real_stream + disassembler->num_bytes_used, |
| required_length + 1, fmt, args); |
| disassembler->num_bytes_used += required_length; |
| return 0; |
| } |
| |
| static void disasm_print(port_disassembler_t * disassembler, |
| const char * code, |
| apr_int64_t len) { |
| // iterate over the code buffer |
| while (len > 0) { |
| int bytes_read = 1; |
| |
| // print instruction address |
| if (disassembler->port_info.print_addr) { |
| disassembler->fprintf_func(disassembler, |
| "0x%08X\t", (apr_uint32_t)code); |
| } |
| |
| // print mnemonic |
| // FIXME: no support |
| assert(disassembler->port_info.print_mnemonic == 0); |
| |
| // print native bytes |
| if (disassembler->port_info.print_bytes) { |
| int i; |
| disassembler->fprintf_func(disassembler, "\t"); |
| for (i = 0; i < bytes_read; i++) { |
| disassembler->fprintf_func(disassembler, |
| "%02X ", ((int)*(code + i)) & 0xff); |
| } |
| } |
| disassembler->fprintf_func(disassembler, "\n"); |
| code += bytes_read; |
| len -= bytes_read; |
| #ifndef NDEBUG |
| if (len < 0) { |
| fprintf(stderr, "WARNING: Disassembler read %i byte(s) more " |
| "than specified buffer length\n", (apr_int32_t)-len); |
| } |
| #endif |
| } |
| } |
| #endif // defined(_IA32_) |
| |
| /* Public Interface */ |
| |
| APR_DECLARE(apr_status_t) port_disasm_initialize() { |
| #if defined(_IA32_) |
| return APR_SUCCESS; |
| #else |
| return APR_ENOTIMPL; |
| #endif |
| } |
| |
| APR_DECLARE(apr_status_t) port_disassembler_create(port_disassembler_t ** disassembler, |
| apr_pool_t * pool) { |
| #if defined(_IA32_) |
| apr_status_t status; |
| port_disasm_info_t info = {1, 0, 1}; |
| |
| if ((status = port_disasm_initialize()) != APR_SUCCESS) { |
| return status; |
| } |
| |
| *disassembler = (port_disassembler_t *) |
| apr_palloc(pool, sizeof(port_disassembler_t)); |
| |
| // initialize port_info |
| port_disasm_set_info(*disassembler, info, NULL); |
| |
| |
| // initialize the rest fields |
| (*disassembler)->real_stream = NULL; |
| (*disassembler)->user_pool = pool; |
| (*disassembler)->user_file = NULL; |
| (*disassembler)->num_bytes_total = 0; |
| (*disassembler)->num_bytes_used = 0; |
| |
| return APR_SUCCESS; |
| #else |
| return APR_ENOTIMPL; |
| #endif |
| } |
| |
| APR_DECLARE(apr_status_t) port_disasm_set_info(port_disassembler_t * disassembler, |
| const port_disasm_info_t new_info, |
| port_disasm_info_t * old_info) { |
| #if defined(_IA32_) |
| if (old_info != NULL) { |
| *old_info = disassembler->port_info; |
| } |
| disassembler->port_info = new_info; |
| disassembler->line_size = 0; |
| if (disassembler->port_info.print_addr) { |
| disassembler->line_size += ADDR_SIZE; |
| } |
| // FIXME: no support for mnemonic |
| disassembler->port_info.print_mnemonic = 0; |
| |
| if (disassembler->port_info.print_bytes) { |
| disassembler->line_size += BYTES_SIZE; |
| } |
| return APR_SUCCESS; |
| #else |
| return APR_ENOTIMPL; |
| #endif |
| } |
| |
| APR_DECLARE(apr_status_t) port_disasm(port_disassembler_t * disassembler, |
| const char * code, |
| unsigned int len, |
| char ** disasm_code) { |
| #if defined(_IA32_) |
| // check if nothing should be printed |
| if (disassembler->line_size == 0) { |
| *disasm_code = NULL; |
| return APR_SUCCESS; |
| } |
| |
| if (disassembler->num_bytes_total == 0) { |
| // Calculate required number of bytes |
| disassembler->num_bytes_total = disassembler->line_size * len / BYTES_PER_LINE; |
| // initialize stream |
| disassembler->real_stream = apr_palloc(disassembler->user_pool, |
| disassembler->num_bytes_total); |
| } |
| |
| strcpy(disassembler->real_stream, ""); |
| |
| disassembler->fprintf_func = disasm_sprint_default; |
| |
| disasm_print(disassembler, code, len); |
| |
| *disasm_code = disassembler->real_stream; |
| |
| disassembler->real_stream = NULL; |
| disassembler->num_bytes_total = 0; |
| disassembler->num_bytes_used = 0; |
| |
| return APR_SUCCESS; |
| #else |
| return APR_ENOTIMPL; |
| #endif |
| } |
| |
| APR_DECLARE(apr_status_t) port_disasm_to_file(port_disassembler_t * disassembler, |
| const char * code, |
| unsigned int len, |
| apr_file_t * thefile) { |
| #if defined(_IA32_) |
| // check if nothing should be printed |
| if (disassembler->line_size == 0) { |
| return APR_SUCCESS; |
| } |
| |
| if (disassembler->num_bytes_total == 0) { |
| // Calculate required number of bytes |
| disassembler->num_bytes_total = disassembler->line_size * BYTES_TOTAL / BYTES_PER_LINE; |
| // initialize stream |
| disassembler->real_stream = apr_palloc(disassembler->user_pool, |
| disassembler->num_bytes_total); |
| } |
| |
| // initialize file |
| disassembler->user_file = thefile; |
| |
| strcpy(disassembler->real_stream, ""); |
| |
| disassembler->fprintf_func = disasm_fprint_default; |
| |
| disasm_print(disassembler, code, len); |
| |
| // flush |
| apr_file_write(disassembler->user_file, disassembler->real_stream, |
| &disassembler->num_bytes_used); |
| apr_file_flush(disassembler->user_file); |
| |
| disassembler->user_file = NULL; |
| disassembler->num_bytes_used = 0; |
| |
| return APR_SUCCESS; |
| #else |
| return APR_ENOTIMPL; |
| #endif |
| } |
