EXPORT
int add_breakpoint(mach_port_t task, vm_address_t patch_addr, int cont, callback handler) {
kern_return_t kret;
char *tmp;
mach_vm_size_t len = 1; // number of bytes to write
uint8_t opcode = 0xcc; // the CC byte to write
interface *face;
face = find_interface(task);
if(face->registered_exception_handler == 0) {
DEBUG_PRINT("[+add_breakpoint] HERE IN ADD BREAK\n %d", 0);
register_(task);
}
kret = mach_vm_protect(task, patch_addr, len, FALSE, VM_PROT_READ | VM_PROT_WRITE | VM_PROT_EXECUTE);
RETURN_ON_MACH_ERROR("[-add_breakpoint] mach_vm_protect()", kret);
if (patch_addr <= MAX_BREAKS) {
DEBUG_PRINT("[-add_breakpoint] INVALID BREAKPOINT ADDRESS %lx\n", patch_addr);
return -1;
} else if(face->current_break >= MAX_BREAKS) {
DEBUG_PRINT("[-add_breakpoint] Max %d breaks reached!\n", MAX_BREAKS);
return -1;
}
DEBUG_PRINT("[+add_breakpoint] Breakpoint %u: %lx added\n", face->current_break, patch_addr);
tmp = (char*) read_memory(task, patch_addr, 1);
breakpoint_struct *new_break = safe_malloc(sizeof(breakpoint_struct));
new_break->address = patch_addr;
new_break->original = tmp[0] & 0xff;
new_break->handler = handler;
if(face->single_step) {
new_break->index = face->single_step_index;
}
else {
new_break->index = face->current_break == 0 ? 0 : face->breaks[face->current_break-1]->index + 1;
}
new_break->flags = cont;
if(face->max_break == 0) {
face->max_break = 1;
}
if(face->current_break >= (face->max_break - 1)) {
DEBUG_PRINT("[+add_breakpoint] ALLOCATING MORE BP! CURRENTLY: %d\n", face->current_break);
face->breaks = safe_realloc(face->breaks, sizeof(breakpoint_struct*) *(face->max_break*2));
face->max_break *= 2;
}
// face->breaks = safe_realloc(face->breaks, sizeof(breakpoint_struct*) *(face->current_break+1));
face->breaks[face->current_break++] = new_break;
write_memory(task, patch_addr, opcode, len); // write the byte
kret = mach_vm_protect(task, patch_addr, (mach_vm_size_t)1, FALSE, VM_PROT_READ | VM_PROT_EXECUTE);
RETURN_ON_MACH_ERROR("[-add_breakpoint] RESTORE mach_vm_protect()", kret);
return 1;
}
//-------------------------------------------------------------------
saliency_server_t::saliency_server_t(const char* inifile)
{
iniWrapper ini;
//fs::path filepath(core::relative_bin_config_path);
if (ini.Load(inifile))
{
int port = ini.GetInt("server:port", 30307);
set_port(port);
}
register_();
}
Service::Handler::Handler ( const string &service )
: myHandle(0)
{
myHandle = register_(service.c_str(),this);
// Initialize default state.
::ZeroMemory(&myValue,sizeof(myValue));
myValue.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
myValue.dwControlsAccepted = SERVICE_ACCEPT_STOP;
myValue.dwWin32ExitCode = NO_ERROR;
myValue.dwCurrentState = SERVICE_RUNNING;
// Tell the SCM the service is up and running.
signal(Status::running);
}
int MetaServerManager::keepalive(const int8_t type, common::MetaServer& server)
{
int32_t iret = TFS_ERROR;
switch (type)
{
case RTS_MS_KEEPALIVE_TYPE_LOGIN:
iret = register_(server);
break;
case RTS_MS_KEEPALIVE_TYPE_RENEW:
iret = renew(server);
break;
case RTS_MS_KEEPALIVE_TYPE_LOGOUT:
iret = unregister(server.base_info_.id_);
break;
default:
TBSYS_LOG(ERROR, "%s keepalive, type: %d not found",
tbsys::CNetUtil::addrToString(server.base_info_.id_).c_str(), type);
break;
}
return iret;
}
uint8_t register_array(void* adress, uint16_t size, datatype type, uint8_t writeable, char* name)
{
uint16_t octets = 0;
switch(type)
{
case FLOAT:
octets = 4;
break;
case UINT8:
octets = 1;
break;
case UINT16:
octets = 2;
break;
case UINT32:
octets = 4;
break;
case INT8:
octets = 1;
break;
case INT16:
octets = 2;
break;
case INT32:
octets = 4;
break;
default:
octets = 1;
break;
}
return register_((uint8_t*)(adress), octets * size, type, writeable, name);
}
