static int saveable(unsigned long * pfn)
{
struct page * page = pfn_to_page(*pfn);
if (PageNosave(page))
return 0;
if (!PageReserved(page)) {
int chunk_size;
if ((chunk_size = is_head_of_free_region(page))) {
*pfn += chunk_size - 1;
return 0;
}
} else if (PageReserved(page)) {
/* Just copy whole code segment.
* Hopefully it is not that big.
*/
if ((ADDRESS(*pfn) >= (unsigned long) ADDRESS2(&__nosave_begin)) &&
(ADDRESS(*pfn) < (unsigned long) ADDRESS2(&__nosave_end))) {
pr_debug("[nosave %lx]\n", ADDRESS(*pfn));
return 0;
}
/* Hmm, perhaps copying all reserved pages is not
* too healthy as they may contain
* critical bios data?
*/
}
return 1;
}
bool_t bst_insert(skey_t key, sval_t val, node_t* node_r) {
node_t* new_internal = NULL;
node_t* new_node = NULL;
uint created = 0;
while (1) {
UPDATE_TRY();
bst_seek(key, node_r);
if (seek_record->leaf->key == key) {
#if GC == 1
if (created) {
ssmem_free(alloc, new_internal);
ssmem_free(alloc, new_node);
}
#endif
return FALSE;
}
node_t* parent = seek_record->parent;
node_t* leaf = seek_record->leaf;
node_t** child_addr;
if (key < parent->key) {
child_addr= (node_t**) &(parent->left);
} else {
child_addr= (node_t**) &(parent->right);
}
if (likely(created==0)) {
new_internal=create_node(max(key,leaf->key),0,0);
new_node = create_node(key,val,0);
created=1;
} else {
new_internal->key=max(key,leaf->key);
}
if ( key < leaf->key) {
new_internal->left = new_node;
new_internal->right = leaf;
} else {
new_internal->right = new_node;
new_internal->left = leaf;
}
#ifdef __tile__
MEM_BARRIER;
#endif
node_t* result = CAS_PTR(child_addr, ADDRESS(leaf), ADDRESS(new_internal));
if (result == ADDRESS(leaf)) {
return TRUE;
}
node_t* chld = *child_addr;
if ( (ADDRESS(chld)==leaf) && (GETFLAG(chld) || GETTAG(chld)) ) {
bst_cleanup(key);
}
}
}
sval_t bst_remove(skey_t key, node_t* node_r) {
bool_t injecting = TRUE;
node_t* leaf;
sval_t val = 0;
while (1) {
UPDATE_TRY();
bst_seek(key, node_r);
val = seek_record->leaf->value;
node_t* parent = seek_record->parent;
node_t** child_addr;
if (key < parent->key) {
child_addr = (node_t**) &(parent->left);
} else {
child_addr = (node_t**) &(parent->right);
}
if (injecting == TRUE) {
leaf = seek_record->leaf;
if (leaf->key != key) {
return 0;
}
node_t* lf = ADDRESS(leaf);
node_t* result = CAS_PTR(child_addr, lf, FLAG(lf));
if (result == ADDRESS(leaf)) {
injecting = FALSE;
bool_t done = bst_cleanup(key);
if (done == TRUE) {
return val;
}
} else {
node_t* chld = *child_addr;
if ( (ADDRESS(chld) == leaf) && (GETFLAG(chld) || GETTAG(chld)) ) {
bst_cleanup(key);
}
}
} else {
if (seek_record->leaf != leaf) {
return val;
} else {
bool_t done = bst_cleanup(key);
if (done == TRUE) {
return val;
}
}
}
}
}
/* if pagedir_p != NULL it also copies the counted pages */
static int count_and_copy_data_pages(struct pbe *pagedir_p)
{
int chunk_size;
int nr_copy_pages = 0;
int pfn;
struct page *page;
#ifdef CONFIG_DISCONTIGMEM
panic("Discontingmem not supported");
#else
BUG_ON (max_pfn != num_physpages);
#endif
for (pfn = 0; pfn < max_pfn; pfn++) {
page = pfn_to_page(pfn);
if (PageHighMem(page))
panic("Swsusp not supported on highmem boxes. Send 1GB of RAM to <*****@*****.**> and try again ;-).");
if (!PageReserved(page)) {
if (PageNosave(page))
continue;
if ((chunk_size=is_head_of_free_region(page))!=0) {
pfn += chunk_size - 1;
continue;
}
} else if (PageReserved(page)) {
BUG_ON (PageNosave(page));
/*
* Just copy whole code segment. Hopefully it is not that big.
*/
if ((ADDRESS(pfn) >= (unsigned long) ADDRESS2(&__nosave_begin)) &&
(ADDRESS(pfn) < (unsigned long) ADDRESS2(&__nosave_end))) {
PRINTK("[nosave %lx]", ADDRESS(pfn));
continue;
}
/* Hmm, perhaps copying all reserved pages is not too healthy as they may contain
critical bios data? */
} else BUG();
nr_copy_pages++;
if (pagedir_p) {
pagedir_p->orig_address = ADDRESS(pfn);
copy_page((void *) pagedir_p->address, (void *) pagedir_p->orig_address);
pagedir_p++;
}
}
return nr_copy_pages;
}
void rexx_exit (void)
{
if (ARexxPort) {
struct RexxMsg *msg;
gui_rexx_s *gui = &gui_rexx[ON_EXIT];
if (gui->port[0] && gui->cmd_on[0]) {
if (ADDRESS(gui->port, gui->cmd_on) != RC_OK) {
write_log ("%s:%s:%s\n", gui->port,
gui->cmd_on,
RESULT);
}
gui->port[0] = '\0';
}
Forbid ();
while ((msg = (struct RexxMsg*)GetMsg (ARexxPort))) {
msg->rm_Result1 = RC_ERROR;
msg->rm_Result2 = 0;
ReplyMsg ((void*)msg);
}
DeletePort (ARexxPort);
Permit ();
ARexxPort = NULL;
}
#ifdef __amigaos4__
if (IRexxSys) {
DropInterface ((struct Interface *)IRexxSys);
IRexxSys = NULL;
}
#endif
if (RexxSysBase) {
CloseLibrary ((void*)RexxSysBase);
RexxSysBase = NULL;
}
}
static void free_suspend_pagedir(unsigned long this_pagedir)
{
struct page *page;
int pfn;
unsigned long this_pagedir_end = this_pagedir +
(PAGE_SIZE << pagedir_order);
for(pfn = 0; pfn < num_physpages; pfn++) {
page = pfn_to_page(pfn);
if (!TestClearPageNosave(page))
continue;
if (ADDRESS(pfn) >= this_pagedir && ADDRESS(pfn) < this_pagedir_end)
continue; /* old pagedir gets freed in one */
free_page(ADDRESS(pfn));
}
free_pages(this_pagedir, pagedir_order);
}
void rexx_filename (unsigned int num, const char *filename)
{
gui_rexx_s *gui = NULL;
if (num > 3)
return;
gui = &gui_rexx[NAME_DF0 + num];
if (gui->port[0] && gui->cmd_on[0]) {
char buf[CMD_LEN];
sprintf (buf, gui->cmd_on, filename);
if (ADDRESS (gui->port, buf) != RC_OK) {
write_log ("%s:%s:%s\n", gui->port, buf, RESULT);
}
}
}
seek_record_t * bst_seek(skey_t key, node_t* node_r){
PARSE_TRY();
volatile seek_record_t seek_record_l;
node_t* node_s = ADDRESS(node_r->left);
seek_record_l.ancestor = node_r;
seek_record_l.successor = node_s;
seek_record_l.parent = node_s;
seek_record_l.leaf = ADDRESS(node_s->left);
node_t* parent_field = (node_t*) seek_record_l.parent->left;
node_t* current_field = (node_t*) seek_record_l.leaf->left;
node_t* current = ADDRESS(current_field);
while (current != NULL) {
if (!GETTAG(parent_field)) {
seek_record_l.ancestor = seek_record_l.parent;
seek_record_l.successor = seek_record_l.leaf;
}
seek_record_l.parent = seek_record_l.leaf;
seek_record_l.leaf = current;
parent_field = current_field;
if (key < current->key) {
current_field= (node_t*) current->left;
} else {
current_field= (node_t*) current->right;
}
current=ADDRESS(current_field);
}
seek_record->ancestor=seek_record_l.ancestor;
seek_record->successor=seek_record_l.successor;
seek_record->parent=seek_record_l.parent;
seek_record->leaf=seek_record_l.leaf;
return seek_record;
}
static void copy_pages(void)
{
struct pbe * p = pagedir_save;
unsigned long pfn;
int n = 0;
for (pfn = 0; pfn < max_pfn; pfn++) {
if (saveable(&pfn)) {
n++;
p->orig_address = ADDRESS(pfn);
copy_page((void *) p->address,
(void *) p->orig_address);
p++;
}
}
BUG_ON(n != pmdisk_pages);
}
uint32_t ccHash32Data( void *data, int size )
{
uint32_t hash;
int rem;
rem = size & 3;
size >>= 2;
hash = 0;
if( !( ( (uintptr_t)data ) & 0x1 ) )
{
for( ; size ; size-- )
{
hash += CC_HASH_AREAD16( data, 0 );
hash = ( hash << 16 ) ^ ( ( CC_HASH_AREAD16( data, 2 ) << 11 ) ^ hash );
hash += hash >> 11;
data = ADDRESS( data, 4 );
}
}
else
{
for( ; size ; size-- )
void rexx_led (int led, int on)
{
gui_rexx_s *gui = NULL;
if (led < 0 || led > 4)
return;
led_state[led] = on;
if (led == 0) gui = &gui_rexx[LED_POW];
if (led == 1) gui = &gui_rexx[LED_DF0];
if (led == 2) gui = &gui_rexx[LED_DF1];
if (led == 3) gui = &gui_rexx[LED_DF2];
if (led == 4) gui = &gui_rexx[LED_DF3];
if (gui->port[0] && gui->cmd_on[0] && gui->cmd_off[0]) {
if (ADDRESS (gui->port, on ? gui->cmd_on : gui->cmd_off) != RC_OK) {
write_log ("%s:%s:%s\n", gui->port,
on ? gui->cmd_on : gui->cmd_off,
RESULT);
}
}
}
static bool InitParamMap()
{
paramMap.clear();
paramMap["next"] = DataElement(READONLY_TYPE);
paramMap["pairs"] = DataElement(READONLY_TYPE);
// dummy FeatureDef for address lookups
const FeatureDef fd;
const char* start = ADDRESS(fd);
ADD_FUNCTION("model", fd, ModelTable);
ADD_FUNCTION("collisionVolume", fd.collisionVolume, ColVolTable);
ADD_FUNCTION("modelname", fd, ModelName);
ADD_FUNCTION("height", fd, ModelHeight);
ADD_FUNCTION("radius", fd, ModelRadius);
ADD_FUNCTION("drawTypeString", fd, ModelDrawType);
ADD_FUNCTION("customParams", fd.customParams, CustomParamsTable);
ADD_INT("id", fd.id);
ADD_INT("deathFeatureID", fd.deathFeatureDefID);
ADD_STRING("name", fd.name);
ADD_STRING("tooltip", fd.description);
ADD_FLOAT("metal", fd.metal);
ADD_FLOAT("energy", fd.energy);
ADD_FLOAT("maxHealth", fd.health);
ADD_FLOAT("reclaimTime", fd.reclaimTime);
ADD_FLOAT("mass", fd.mass);
ADD_INT("xsize", fd.xsize);
ADD_INT("zsize", fd.zsize);
ADD_INT("drawType", fd.drawType);
ADD_BOOL("upright", fd.upright);
ADD_BOOL("destructable", fd.destructable);
ADD_BOOL("reclaimable", fd.reclaimable);
ADD_BOOL("autoreclaim", fd.autoreclaim);
ADD_BOOL("blocking", fd.collidable);
ADD_BOOL("burnable", fd.burnable);
ADD_BOOL("floating", fd.floating);
ADD_BOOL("geoThermal", fd.geoThermal);
ADD_BOOL("noSelect", fd.selectable);
ADD_INT("resurrectable", fd.resurrectable);
ADD_INT("smokeTime", fd.smokeTime);
ADD_DEPRECATED_LUADEF_KEY("minx");
ADD_DEPRECATED_LUADEF_KEY("miny");
ADD_DEPRECATED_LUADEF_KEY("minz");
ADD_DEPRECATED_LUADEF_KEY("midx");
ADD_DEPRECATED_LUADEF_KEY("midy");
ADD_DEPRECATED_LUADEF_KEY("midz");
ADD_DEPRECATED_LUADEF_KEY("maxx");
ADD_DEPRECATED_LUADEF_KEY("maxy");
ADD_DEPRECATED_LUADEF_KEY("maxz");
ADD_DEPRECATED_LUADEF_KEY("deathFeature");
return true;
}
/* Resize the given region to the new size, returning a pointer
to the (possibly moved) region. This is optimized for speed;
some benchmarks seem to indicate that greater compactness is
achieved by unconditionally allocating and copying to a
new region. */
void *
realloc(void *ptr, size_t size)
{
void *result, *previous;
int block, blocks, type;
int oldlimit;
if (!ptr)
return malloc(size);
if (!size) {
free(ptr);
return malloc(0);
}
block = BLOCK(ptr);
switch (type = _heapinfo[block].busy.type) {
case 0:
/* Maybe reallocate a large block to a small fragment. */
if (size <= BLOCKSIZE / 2) {
if ((result = malloc(size)) != NULL) {
memcpy(result, ptr, size);
free(ptr);
}
return result;
}
/* The new size is a large allocation as well; see if
we can hold it in place. */
blocks = BLOCKIFY(size);
if (blocks < _heapinfo[block].busy.info.size) {
/* The new size is smaller; return excess memory
to the free list. */
_heapinfo[block + blocks].busy.type = 0;
_heapinfo[block + blocks].busy.info.size
= _heapinfo[block].busy.info.size - blocks;
_heapinfo[block].busy.info.size = blocks;
free(ADDRESS(block + blocks));
return ptr;
} else if (blocks == _heapinfo[block].busy.info.size)
/* No size change necessary. */
return ptr;
else {
/* Won't fit, so allocate a new region that will. Free
the old region first in case there is sufficient adjacent
free space to grow without moving. */
blocks = _heapinfo[block].busy.info.size;
/* Prevent free from actually returning memory to the system. */
oldlimit = _heaplimit;
_heaplimit = 0;
free(ptr);
_heaplimit = oldlimit;
result = malloc(size);
if (!result) {
/* Now we're really in trouble. We have to unfree
the thing we just freed. Unfortunately it might
have been coalesced with its neighbors. */
if (_heapindex == block)
malloc(blocks * BLOCKSIZE);
else {
previous = malloc((block - _heapindex) * BLOCKSIZE);
malloc(blocks * BLOCKSIZE);
free(previous);
}
return NULL;
}
if (ptr != result)
memmove(result, ptr, blocks * BLOCKSIZE);
return result;
}
break;
default:
/* Old size is a fragment; type is logarithm to base two of
the fragment size. */
if ((size > 1 << (type - 1)) && (size <= 1 << type))
/* New size is the same kind of fragment. */
return ptr;
else {
/* New size is different; allocate a new space, and copy
the lesser of the new size and the old. */
result = malloc(size);
if (!result)
return NULL;
memcpy(result, ptr, MIN(size, 1 << type));
free(ptr);
return result;
}
break;
}
}
TEST(JInstruction, ExtractAddress3)
{
int32 inst(0x08100006);
EXPECT_EQ(ADDRESS(inst), 0x00400018);
}
static int
_dwarf_lineno_run_program(Dwarf_CU *cu, Dwarf_LineInfo li, uint8_t *p,
uint8_t *pe, Dwarf_Addr pc, Dwarf_Error *error)
{
Dwarf_Line ln, tln;
uint64_t address, file, line, column, isa, opsize;
int is_stmt, basic_block, end_sequence;
int prologue_end, epilogue_begin;
int ret;
ln = &li->li_line;
#define RESET_REGISTERS \
do { \
address = 0; \
file = 1; \
line = 1; \
column = 0; \
is_stmt = li->li_defstmt; \
basic_block = 0; \
end_sequence = 0; \
prologue_end = 0; \
epilogue_begin = 0; \
} while(0)
#define APPEND_ROW \
do { \
if (pc < address) { \
return DW_DLE_NONE; \
} \
ln->ln_addr = address; \
ln->ln_symndx = 0; \
ln->ln_fileno = file; \
ln->ln_lineno = line; \
ln->ln_column = column; \
ln->ln_bblock = basic_block; \
ln->ln_stmt = is_stmt; \
ln->ln_endseq = end_sequence; \
li->li_lnlen++; \
} while(0)
#define LINE(x) (li->li_lbase + (((x) - li->li_opbase) % li->li_lrange))
#define ADDRESS(x) ((((x) - li->li_opbase) / li->li_lrange) * li->li_minlen)
/*
* ln->ln_li = li; \
* Set registers to their default values.
*/
RESET_REGISTERS;
/*
* Start line number program.
*/
while (p < pe) {
if (*p == 0) {
/*
* Extended Opcodes.
*/
p++;
opsize = _dwarf_decode_uleb128(&p);
switch (*p) {
case DW_LNE_end_sequence:
p++;
end_sequence = 1;
RESET_REGISTERS;
break;
case DW_LNE_set_address:
p++;
address = dbg->decode(&p, cu->addr_size);
break;
case DW_LNE_define_file:
p++;
ret = _dwarf_lineno_add_file(li, &p, NULL,
error, dbg);
if (ret != DW_DLE_NONE)
goto prog_fail;
break;
default:
/* Unrecognized extened opcodes. */
p += opsize;
}
} else if (*p > 0 && *p < li->li_opbase) {
/*
* Standard Opcodes.
*/
switch (*p++) {
case DW_LNS_copy:
APPEND_ROW;
basic_block = 0;
prologue_end = 0;
epilogue_begin = 0;
break;
case DW_LNS_advance_pc:
address += _dwarf_decode_uleb128(&p) *
li->li_minlen;
break;
case DW_LNS_advance_line:
line += _dwarf_decode_sleb128(&p);
break;
case DW_LNS_set_file:
file = _dwarf_decode_uleb128(&p);
break;
case DW_LNS_set_column:
column = _dwarf_decode_uleb128(&p);
break;
case DW_LNS_negate_stmt:
is_stmt = !is_stmt;
break;
case DW_LNS_set_basic_block:
basic_block = 1;
break;
case DW_LNS_const_add_pc:
address += ADDRESS(255);
break;
case DW_LNS_fixed_advance_pc:
address += dbg->decode(&p, 2);
break;
case DW_LNS_set_prologue_end:
prologue_end = 1;
break;
case DW_LNS_set_epilogue_begin:
epilogue_begin = 1;
break;
case DW_LNS_set_isa:
isa = _dwarf_decode_uleb128(&p);
break;
default:
/* Unrecognized extened opcodes. What to do? */
break;
}
} else {
/*
* Special Opcodes.
*/
line += LINE(*p);
address += ADDRESS(*p);
APPEND_ROW;
basic_block = 0;
prologue_end = 0;
epilogue_begin = 0;
p++;
}
}
return (DW_DLE_NONE);
prog_fail:
return (ret);
#undef RESET_REGISTERS
#undef APPEND_ROW
#undef LINE
#undef ADDRESS
}
int main(int argc, char ** argv)
{
algorithm_instance_t * instance;
traceroute_options_t options = traceroute_get_default_options();
probe_t * probe;
pt_loop_t * loop;
int family;
int ret = EXIT_FAILURE;
const char * ip_protocol_name;
const char * protocol_name;
address_t dst_addr;
// Harcoded command line parsing here
char dst_ip[] = "8.8.8.8";
//char dst_ip[] = "1.1.1.2";
//char dst_ip[] = "2001:db8:85a3::8a2e:370:7338";
if (!address_guess_family(dst_ip, &family)) {
fprintf(stderr, "Cannot guess family of destination address (%s)", dst_ip);
goto ERR_ADDRESS_GUESS_FAMILY;
}
if (address_from_string(family, dst_ip, &dst_addr) != 0) {
fprintf(stderr, "Cannot guess family of destination address (%s)", dst_ip);
goto ERR_ADDRESS_FROM_STRING;
}
// Prepare options related to the 'traceroute' algorithm
options.do_resolv = false;
options.dst_addr = &dst_addr;
options.num_probes = 1;
// options.max_ttl = 1;
printf("num_probes = %zu max_ttl = %u\n", options.num_probes, options.max_ttl);
// Create libparistraceroute loop
// No information shared by traceroute algorithm instances, so we pass NULL
if (!(loop = pt_loop_create(loop_handler, NULL))) {
fprintf(stderr, "Cannot create libparistraceroute loop");
goto ERR_LOOP_CREATE;
}
// Probe skeleton definition: IPv4/UDP probe targetting 'dst_ip'
if (!(probe = probe_create())) {
fprintf(stderr, "Cannot create probe skeleton");
goto ERR_PROBE_CREATE;
}
switch (family) {
case AF_INET:
ip_protocol_name = "ipv4";
protocol_name = "icmpv4";
break;
case AF_INET6:
ip_protocol_name = "ipv6";
protocol_name = "icmpv6";
break;
default:
fprintf(stderr, "Internet family not supported (%d)\n", family);
goto ERR_FAMILY;
}
// protocol_name = "udp";
protocol_name = "tcp";
printf("protocol_name = %s\n", protocol_name);
if (!probe_set_protocols(probe, ip_protocol_name, protocol_name, NULL)) {
fprintf(stderr, "Can't set protocols %s/%s\n", ip_protocol_name, protocol_name);
goto ERR_PROBE_SET_PROTOCOLS;
}
if (strncmp("icmp", protocol_name, 4) != 0) {
probe_write_payload(probe, "\0\0\0\0", 4);
} else {
probe_set_field(probe, I32("body", 1));
}
probe_set_fields(probe,
ADDRESS("dst_ip", &dst_addr),
I16("dst_port", 3000),
NULL
);
/*
if (strcmp("tcp", protocol_name) == 0) {
printf("setting tcp fields\n");
uint8_t one = 1;
probe_set_fields(probe,
BITS("reserved", 1, &one),
BITS("ns", 1, &one),
BITS("cwr", 1, &one),
BITS("ece", 1, &one),
BITS("urg", 1, &one),
BITS("ack", 1, &one),
BITS("psh", 1, &one),
BITS("rst", 1, &one),
BITS("syn", 1, &one),
BITS("fin", 1, &one),
NULL
);
}
*/
probe_dump(probe);
// Instanciate a 'traceroute' algorithm
if (!(instance = pt_add_instance(loop, "traceroute", &options, probe))) {
fprintf(stderr, "Cannot add 'traceroute' algorithm");
goto ERR_INSTANCE;
}
// Wait for events. They will be catched by handler_user()
if (pt_loop(loop, 0) < 0) {
fprintf(stderr, "Main loop interrupted");
goto ERR_IN_PT_LOOP;
}
ret = EXIT_SUCCESS;
// Free data and quit properly
ERR_IN_PT_LOOP:
// instance is freed by pt_loop_free
ERR_INSTANCE:
ERR_PROBE_SET_PROTOCOLS:
ERR_FAMILY:
probe_free(probe);
ERR_PROBE_CREATE:
pt_loop_free(loop);
ERR_LOOP_CREATE:
ERR_ADDRESS_FROM_STRING:
ERR_ADDRESS_GUESS_FAMILY:
exit(ret);
}
int main(int argc, char ** argv)
{
int exit_code = EXIT_FAILURE;
char * version = strdup("version 1.0");
const char * usage = "usage: %s [options] host\n";
void * algorithm_options;
traceroute_options_t traceroute_options;
traceroute_options_t * ptraceroute_options;
mda_options_t mda_options;
probe_t * probe;
pt_loop_t * loop;
int family;
address_t dst_addr;
options_t * options;
char * dst_ip;
const char * algorithm_name;
const char * protocol_name;
bool use_icmp, use_udp, use_tcp;
// Prepare the commande line options
if (!(options = init_options(version))) {
fprintf(stderr, "E: Can't initialize options\n");
goto ERR_INIT_OPTIONS;
}
// Retrieve values passed in the command-line
if (options_parse(options, usage, argv) != 1) {
fprintf(stderr, "%s: destination required\n", basename(argv[0]));
goto ERR_OPT_PARSE;
}
// We assume that the target IP address is always the last argument
dst_ip = argv[argc - 1];
algorithm_name = algorithm_names[0];
protocol_name = protocol_names[0];
// Checking if there is any conflicts between options passed in the commandline
if (!check_options(is_icmp, is_tcp, is_udp, is_ipv4, is_ipv6, dst_port[3], src_port[3], protocol_name, algorithm_name)) {
goto ERR_CHECK_OPTIONS;
}
use_icmp = is_icmp || strcmp(protocol_name, "icmp") == 0;
use_tcp = is_tcp || strcmp(protocol_name, "tcp") == 0;
use_udp = is_udp || strcmp(protocol_name, "udp") == 0;
// If not any ip version is set, call address_guess_family.
// If only one is set to true, set family to AF_INET or AF_INET6
if (is_ipv4) {
family = AF_INET;
} else if (is_ipv6) {
family = AF_INET6;
} else {
// Get address family if not defined by the user
if (!address_guess_family(dst_ip, &family)) goto ERR_ADDRESS_GUESS_FAMILY;
}
// Translate the string IP / FQDN into an address_t * instance
if (address_from_string(family, dst_ip, &dst_addr) != 0) {
fprintf(stderr, "E: Invalid destination address %s\n", dst_ip);
goto ERR_ADDRESS_IP_FROM_STRING;
}
// Probe skeleton definition: IPv4/UDP probe targetting 'dst_ip'
if (!(probe = probe_create())) {
fprintf(stderr,"E: Cannot create probe skeleton");
goto ERR_PROBE_CREATE;
}
// Prepare the probe skeleton
probe_set_protocols(
probe,
get_ip_protocol_name(family), // "ipv4" | "ipv6"
get_protocol_name(family, use_icmp, use_tcp, use_udp), // "icmpv4" | "icmpv6" | "tcp" | "udp"
NULL
);
probe_set_field(probe, ADDRESS("dst_ip", &dst_addr));
if (send_time[3]) {
if(send_time[0] <= 10) { // seconds
probe_set_delay(probe, DOUBLE("delay", send_time[0]));
} else { // milli-seconds
probe_set_delay(probe, DOUBLE("delay", 0.001 * send_time[0]));
}
}
// ICMPv* do not support src_port and dst_port fields nor payload.
if (!use_icmp) {
uint16_t sport = 0,
dport = 0;
if (use_udp) {
// Option -U sets port to 53 (DNS) if dst_port is not explicitely set
sport = src_port[3] ? src_port[0] : UDP_DEFAULT_SRC_PORT;
dport = dst_port[3] ? dst_port[0] : (is_udp ? UDP_DST_PORT_USING_U : UDP_DEFAULT_DST_PORT);
} else if (use_tcp) {
// Option -T sets port to 80 (http) if dst_port is not explicitely set
sport = src_port[3] ? src_port[0] : TCP_DEFAULT_SRC_PORT;
dport = dst_port[3] ? dst_port[0] : (is_tcp ? TCP_DST_PORT_USING_T : TCP_DEFAULT_DST_PORT);
}
// Update ports
probe_set_fields(
probe,
I16("src_port", sport),
I16("dst_port", dport),
NULL
);
// Resize payload (it will be use to set our customized checksum in the {TCP, UDP} layer)
probe_payload_resize(probe, 2);
}
// Algorithm options (dedicated options)
if (strcmp(algorithm_name, "paris-traceroute") == 0) {
traceroute_options = traceroute_get_default_options();
ptraceroute_options = &traceroute_options;
algorithm_options = &traceroute_options;
algorithm_name = "traceroute";
} else if ((strcmp(algorithm_name, "mda") == 0) || options_mda_get_is_set()) {
mda_options = mda_get_default_options();
ptraceroute_options = &mda_options.traceroute_options;
algorithm_options = &mda_options;
options_mda_init(&mda_options);
} else {
fprintf(stderr, "E: Unknown algorithm");
goto ERR_UNKNOWN_ALGORITHM;
}
// Algorithm options (common options)
options_traceroute_init(ptraceroute_options, &dst_addr);
// Create libparistraceroute loop
if (!(loop = pt_loop_create(loop_handler, NULL))) {
fprintf(stderr, "E: Cannot create libparistraceroute loop");
goto ERR_LOOP_CREATE;
}
// Set network options (network and verbose)
options_network_init(loop->network, is_debug);
printf("%s to %s (", algorithm_name, dst_ip);
address_dump(&dst_addr);
printf("), %u hops max, %u bytes packets\n",
ptraceroute_options->max_ttl,
(unsigned int)packet_get_size(probe->packet)
);
// Add an algorithm instance in the main loop
if (!pt_add_instance(loop, algorithm_name, algorithm_options, probe)) {
fprintf(stderr, "E: Cannot add the chosen algorithm");
goto ERR_INSTANCE;
}
// Wait for events. They will be catched by handler_user()
if (pt_loop(loop, 0) < 0) {
fprintf(stderr, "E: Main loop interrupted");
goto ERR_PT_LOOP;
}
exit_code = EXIT_SUCCESS;
// Leave the program
ERR_PT_LOOP:
ERR_INSTANCE:
// pt_loop_free() automatically removes algorithms instances,
// probe_replies and events from the memory.
// Options and probe must be manually removed.
pt_loop_free(loop);
ERR_LOOP_CREATE:
ERR_UNKNOWN_ALGORITHM:
probe_free(probe);
ERR_PROBE_CREATE:
ERR_ADDRESS_IP_FROM_STRING:
ERR_ADDRESS_GUESS_FAMILY:
if (errno) perror(gai_strerror(errno));
ERR_CHECK_OPTIONS:
ERR_OPT_PARSE:
ERR_INIT_OPTIONS:
free(version);
exit(exit_code);
}
for( ; size ; size-- )
{
hash += CC_HASH_AREAD16( data, 0 );
hash = ( hash << 16 ) ^ ( ( CC_HASH_AREAD16( data, 2 ) << 11 ) ^ hash );
hash += hash >> 11;
data = ADDRESS( data, 4 );
}
}
else
{
for( ; size ; size-- )
{
hash += CC_HASH_UREAD16( data, 0 );
hash = ( hash << 16 ) ^ ( ( CC_HASH_UREAD16( data, 2 ) << 11 ) ^ hash );
hash += hash >> 11;
data = ADDRESS( data, 4 );
}
}
switch( rem )
{
case 3:
hash += CC_HASH_UREAD16( data, 0 );
hash ^= hash << 16;
hash ^= CC_HASH_READ8( data, 2 ) << 18;
hash += hash >> 11;
break;
case 2:
hash += CC_HASH_UREAD16( data, 0 );
hash ^= hash << 11;
hash += hash >> 17;
break;
# define ADDRESS(x) (0x02 ## x)
#else
# define ADDRESS(x) (0xCA ## x)
#endif
/* This produces incorrect code */
#define REG_1 (*(__xdata unsigned char*)ADDRESS(00))
void incorrect(void)
{
REG_1 |= 1;
REG_1 |= 2;
}
/* This produces correct code */
__xdata unsigned char __at(ADDRESS(01)) REG_2;
void correct(void)
{
REG_2 |= 1;
REG_2 |= 2;
}
void testBug(void)
{
#ifdef SDCC
REG_1 = 0x40;
incorrect();
ASSERT (REG_1 == 0x43);
#endif
REG_2 = 0x50;
unsigned long mm_getFreePages(int gfp_mask, unsigned long order) {
unsigned long flags;
unsigned long ret_address;
unsigned long page_order ;
stat_allocs++;
ret_address = 0;
page_order = order;
if (order >= NR_MEM_LISTS)
return ret_address;
spin_lock_irqsave(&free_area_lock, flags);
do {
struct free_mem_area_struct * area = free_mem_area+order;
unsigned long new_order = order;
do { struct page *prev = memory_head(area), *ret = prev->next;
while (memory_head(area) != ret) {
if ( CAN_DMA(ret)) {
unsigned long map_nr;
(prev->next = ret->next)->prev = prev;
map_nr = ret - g_mem_map;
MARK_USED(map_nr, new_order, area);
area->stat_count--;
g_nr_free_pages -= 1 << order;
EXPAND(ret, map_nr, order, new_order, area);
DEBUG(" Page alloc return address: %x mask:%x order:%d \n",ADDRESS(map_nr),gfp_mask,order);
if (gfp_mask & MEM_CLEAR) ut_memset(ADDRESS(map_nr),0,PAGE_SIZE<<order);
if (!(gfp_mask & MEM_FOR_CACHE)) memleakHook_alloc(ADDRESS(map_nr),PAGE_SIZE<<order,0,0);
ret_address = ADDRESS(map_nr);
goto last;
}
prev = ret;
ret = ret->next;
}
new_order++; area++;
} while (new_order < NR_MEM_LISTS);
} while (0);
last:
if (ret_address > 0) {
unsigned long i = (1 << page_order);
struct page *page = virt_to_page(ret_address);
while (i--) {
#ifdef MEMORY_DEBUG
if (PageReferenced(page)){
ut_log("Page Backtrace in Alloc page :\n");
ut_printBackTrace(page->bt_addr_list,MAX_BACKTRACE_LENGTH);
}
#endif
assert(!PageReferenced(page));
PageSetReferenced(page);
#ifdef MEMORY_DEBUG
ut_storeBackTrace(page->bt_addr_list,MAX_BACKTRACE_LENGTH);
#endif
page++;
}
}
spin_unlock_irqrestore(&free_area_lock, flags);
if (ret_address ==0) return ret_address;
if ((ret_address >= (KADDRSPACE_START+g_phy_mem_size)) || (ret_address < KADDRSPACE_START)){
ut_log(" ERROR: frames execeeding the max frames :%x\n",ret_address);
BUG();
}
return ret_address;
}
void *mrealloc(xbt_mheap_t mdp, void *ptr, size_t size)
{
void *result;
int type;
size_t block, blocks, oldlimit;
/* Only keep real realloc, and reroute hidden malloc and free to the relevant functions */
if (size == 0) {
mfree(mdp, ptr);
return mmalloc(mdp, 0);
} else if (ptr == NULL) {
return mmalloc(mdp, size);
}
//printf("(%s)realloc %p to %d...",xbt_thread_self_name(),ptr,(int)size);
if ((char *) ptr < (char *) mdp->heapbase || BLOCK(ptr) > mdp->heapsize) {
printf
("FIXME. Ouch, this pointer is not mine, refusing to proceed (another solution would be to malloc it instead of reallocing it, see source code)\n");
result = mmalloc(mdp, size);
abort();
return result;
}
size_t requested_size = size; // The amount of memory requested by user, for real
/* Work even if the user was stupid enough to ask a ridicullously small block (even 0-length),
* ie return a valid block that can be realloced and freed.
* glibc malloc does not use this trick but return a constant pointer, but we need to enlist the free fragments later on.
*/
if (size < SMALLEST_POSSIBLE_MALLOC)
size = SMALLEST_POSSIBLE_MALLOC;
block = BLOCK(ptr);
type = mdp->heapinfo[block].type;
switch (type) {
case -1:
fprintf(stderr, "Asked realloc a fragment coming from a *free* block. I'm puzzled.\n");
abort();
break;
case 0:
/* Maybe reallocate a large block to a small fragment. */
if (size <= BLOCKSIZE / 2) { // Full block -> Fragment; no need to optimize for time
result = mmalloc(mdp, size);
if (result != NULL) { // useless (mmalloc never returns NULL), but harmless
memcpy(result, ptr, requested_size);
mfree(mdp, ptr);
return (result);
}
}
/* Full blocks -> Full blocks; see if we can hold it in place. */
blocks = BLOCKIFY(size);
if (blocks < mdp->heapinfo[block].busy_block.size) {
int it;
/* The new size is smaller; return excess memory to the free list. */
//printf("(%s) return excess memory...",xbt_thread_self_name());
for (it= block+blocks; it< mdp->heapinfo[block].busy_block.size ; it++){
mdp->heapinfo[it].type = 0; // FIXME that should be useless, type should already be 0 here
mdp->heapinfo[it].busy_block.ignore = 0;
}
mdp->heapinfo[block + blocks].busy_block.size
= mdp->heapinfo[block].busy_block.size - blocks;
mfree(mdp, ADDRESS(block + blocks));
mdp->heapinfo[block].busy_block.size = blocks;
mdp->heapinfo[block].busy_block.busy_size = requested_size;
mdp->heapinfo[block].busy_block.ignore = 0;
result = ptr;
} else if (blocks == mdp->heapinfo[block].busy_block.size) {
/* No block size change necessary; only update the requested size */
result = ptr;
mdp->heapinfo[block].busy_block.busy_size = requested_size;
mdp->heapinfo[block].busy_block.ignore = 0;
} else {
/* Won't fit, so allocate a new region that will.
Free the old region first in case there is sufficient adjacent free space to grow without moving.
This trick mandates using a specific version of mmalloc that does not memset the memory to 0 after
action for obvious reasons. */
blocks = mdp->heapinfo[block].busy_block.size;
/* Prevent free from actually returning memory to the system. */
oldlimit = mdp->heaplimit;
mdp->heaplimit = 0;
mfree(mdp, ptr);
mdp->heaplimit = oldlimit;
result = mmalloc_no_memset(mdp, requested_size);
//fprintf(stderr,"remalloc(%zu)~>%p\n",requested_size,result);
if (ptr != result)
memmove(result, ptr, blocks * BLOCKSIZE);
/* FIXME: we should memset the end of the recently area */
}
break;
default: /* Fragment -> ??; type=logarithm to base two of the fragment size. */
if (size > (size_t) (1 << (type - 1)) && size <= (size_t) (1 << type)) {
/* The new size is the same kind of fragment. */
//printf("(%s) new size is same kind of fragment...",xbt_thread_self_name());
result = ptr;
int frag_nb = RESIDUAL(result, BLOCKSIZE) >> type;
mdp->heapinfo[block].busy_frag.frag_size[frag_nb] = requested_size;
mdp->heapinfo[block].busy_frag.ignore[frag_nb] = 0;
} else { /* fragment -> Either other fragment, or block */
static bool InitParamMap()
{
paramMap["next"] = DataElement(READONLY_TYPE);
paramMap["pairs"] = DataElement(READONLY_TYPE);
// dummy WeaponDef for offset generation
const WeaponDef wd;
const char* start = ADDRESS(wd);
ADD_FUNCTION("damages", wd.damages, DamagesArray);
ADD_FUNCTION("visuals", wd.visuals, VisualsTable);
ADD_FUNCTION("hitSound", wd.soundhit, GuiSoundSetTable);
ADD_FUNCTION("fireSound", wd.firesound, GuiSoundSetTable);
ADD_FUNCTION("customParams", wd.customParams, CustomParamsTable);
ADD_FUNCTION("noEnemyCollide", wd.collisionFlags, NoEnemyCollide);
ADD_FUNCTION("noFriendlyCollide", wd.collisionFlags, NoFriendlyCollide);
ADD_FUNCTION("noFeatureCollide", wd.collisionFlags, NoFeatureCollide);
ADD_FUNCTION("noNeutralCollide", wd.collisionFlags, NoNeutralCollide);
ADD_FUNCTION("noGroundCollide", wd.collisionFlags, NoGroundCollide);
ADD_DEPRECATED_LUADEF_KEY("areaOfEffect");
ADD_DEPRECATED_LUADEF_KEY("maxVelocity");
ADD_DEPRECATED_LUADEF_KEY("onlyTargetCategories");
ADD_INT("id", wd.id);
ADD_INT("tdfId", wd.tdfId);
ADD_STRING("name", wd.name);
ADD_STRING("description", wd.description);
ADD_STRING("cegTag", wd.cegTag);
ADD_STRING("type", wd.type);
ADD_FLOAT("range", wd.range);
ADD_FLOAT("heightMod", wd.heightmod);
ADD_FLOAT("accuracy", wd.accuracy);
ADD_FLOAT("sprayAngle", wd.sprayAngle);
ADD_FLOAT("movingAccuracy", wd.movingAccuracy);
ADD_FLOAT("targetMoveError", wd.targetMoveError);
ADD_FLOAT("leadLimit", wd.leadLimit);
ADD_FLOAT("leadBonus", wd.leadBonus);
ADD_FLOAT("predictBoost", wd.predictBoost);
ADD_INT("highTrajectory", wd.highTrajectory);
ADD_BOOL("noSelfDamage", wd.noSelfDamage);
ADD_BOOL("impactOnly", wd.impactOnly);
ADD_FLOAT("craterAreaOfEffect", wd.craterAreaOfEffect);
ADD_FLOAT("damageAreaOfEffect", wd.damageAreaOfEffect);
ADD_FLOAT("edgeEffectiveness", wd.edgeEffectiveness);
ADD_FLOAT("fireStarter", wd.fireStarter);
ADD_FLOAT("size", wd.size);
ADD_FLOAT("sizeGrowth", wd.sizeGrowth);
ADD_FLOAT("collisionSize", wd.collisionSize);
ADD_INT("salvoSize", wd.salvosize);
ADD_INT("projectiles", wd.projectilespershot);
ADD_FLOAT("salvoDelay", wd.salvodelay);
ADD_FLOAT("reload", wd.reload);
ADD_FLOAT("beamtime", wd.beamtime);
ADD_BOOL("beamburst", wd.beamburst);
ADD_BOOL("waterbounce", wd.waterBounce);
ADD_BOOL("groundbounce", wd.groundBounce);
ADD_FLOAT("groundslip", wd.bounceSlip);
ADD_FLOAT("bouncerebound", wd.bounceRebound);
ADD_INT("numbounce", wd.numBounce);
ADD_FLOAT("maxAngle", wd.maxAngle);
ADD_FLOAT("restTime", wd.restTime);
ADD_FLOAT("uptime", wd.uptime);
ADD_FLOAT("metalCost", wd.metalcost);
ADD_FLOAT("energyCost", wd.energycost);
ADD_BOOL("turret", wd.turret);
ADD_BOOL("onlyForward", wd.onlyForward);
ADD_BOOL("waterWeapon", wd.waterweapon);
ADD_BOOL("tracks", wd.tracks);
ADD_BOOL("paralyzer", wd.paralyzer);
ADD_BOOL("noAutoTarget", wd.noAutoTarget);
ADD_BOOL("manualFire", wd.manualfire);
ADD_INT("targetable", wd.targetable);
ADD_BOOL("stockpile", wd.stockpile);
ADD_INT("interceptor", wd.interceptor);
ADD_FLOAT("coverageRange", wd.coverageRange);
ADD_FLOAT("stockpileTime", wd.stockpileTime);
ADD_FLOAT("intensity", wd.intensity);
ADD_FLOAT("duration", wd.duration);
ADD_INT("beamTTL", wd.beamLaserTTL);
ADD_BOOL("soundTrigger", wd.soundTrigger);
ADD_BOOL("selfExplode", wd.selfExplode);
ADD_BOOL("gravityAffected", wd.gravityAffected);
ADD_FLOAT("myGravity", wd.myGravity);
ADD_BOOL("noExplode", wd.noExplode);
ADD_FLOAT("startvelocity", wd.startvelocity);
ADD_FLOAT("weaponAcceleration", wd.weaponacceleration);
ADD_FLOAT("turnRate", wd.turnrate);
ADD_FLOAT("projectilespeed", wd.projectilespeed);
ADD_FLOAT("explosionSpeed", wd.explosionSpeed);
ADD_FLOAT("wobble", wd.wobble);
ADD_FLOAT("dance", wd.dance);
ADD_FLOAT("trajectoryHeight", wd.trajectoryHeight);
ADD_BOOL("largeBeamLaser", wd.largeBeamLaser);
ADD_BOOL("laserHardStop", wd.laserHardStop);
ADD_BOOL("isShield", wd.isShield);
ADD_BOOL("shieldRepulser", wd.shieldRepulser);
ADD_BOOL("smartShield", wd.smartShield);
ADD_BOOL("exteriorShield", wd.exteriorShield);
ADD_BOOL("visibleShield", wd.visibleShield);
ADD_BOOL("visibleShieldRepulse", wd.visibleShieldRepulse);
ADD_INT( "visibleShieldHitFrames", wd.visibleShieldHitFrames);
ADD_FLOAT("shieldEnergyUse", wd.shieldEnergyUse);
ADD_FLOAT("shieldRadius", wd.shieldRadius);
ADD_FLOAT("shieldForce", wd.shieldForce);
ADD_FLOAT("shieldMaxSpeed", wd.shieldMaxSpeed);
ADD_FLOAT("shieldPower", wd.shieldPower);
ADD_FLOAT("shieldPowerRegen", wd.shieldPowerRegen);
ADD_FLOAT("shieldPowerRegenEnergy", wd.shieldPowerRegenEnergy);
ADD_INT( "shieldRechargeDelay", wd.shieldRechargeDelay);
ADD_FLOAT("shieldGoodColorR", wd.shieldGoodColor.x);
ADD_FLOAT("shieldGoodColorG", wd.shieldGoodColor.y);
ADD_FLOAT("shieldGoodColorB", wd.shieldGoodColor.z);
ADD_FLOAT("shieldBadColorR", wd.shieldBadColor.x);
ADD_FLOAT("shieldBadColorG", wd.shieldBadColor.y);
ADD_FLOAT("shieldBadColorB", wd.shieldBadColor.z);
ADD_FLOAT("shieldAlpha", wd.shieldAlpha);
ADD_INT("shieldInterceptType", wd.shieldInterceptType);
ADD_INT("interceptedByShieldType", wd.interceptedByShieldType);
ADD_BOOL("avoidFriendly", wd.avoidFriendly);
ADD_BOOL("avoidFeature", wd.avoidFeature);
ADD_BOOL("avoidNeutral", wd.avoidNeutral);
ADD_FLOAT("targetBorder", wd.targetBorder);
ADD_FLOAT("cylinderTargetting", wd.cylinderTargetting);
ADD_FLOAT("minIntensity", wd.minIntensity);
ADD_FLOAT("heightBoostFactor", wd.heightBoostFactor);
ADD_FLOAT("proximityPriority", wd.proximityPriority);
ADD_BOOL("sweepFire", wd.sweepFire);
ADD_BOOL("canAttackGround", wd.canAttackGround);
return true;
}
TEST(JInstruction, ExtractAddress1)
{
int32 inst(0xffffffff);
EXPECT_EQ(ADDRESS(inst), 67108863 << 2);
}
static bool InitParamMap()
{
paramMap["next"] = DataElement(READONLY_TYPE);
paramMap["pairs"] = DataElement(READONLY_TYPE);
// dummy UnitDef for address lookups
const UnitDef& ud = *unitDefHandler->unitDefs[0];
const char* start = ADDRESS(ud);
/*
ADD_FLOAT("maxRange", maxRange); // CUSTOM
ADD_BOOL("hasShield", hasShield); // CUSTOM
ADD_BOOL("canParalyze", canParalyze); // CUSTOM
ADD_BOOL("canStockpile", canStockpile); // CUSTOM
ADD_BOOL("canAttackWater", canAttackWater); // CUSTOM
*/
// ADD_INT("buildOptionsCount", ud.buildOptions.size(")); // CUSTOM
ADD_FUNCTION("builder", ud, ReturnFalse); // DEPRECATED
ADD_FUNCTION("floater", ud, ReturnFalse); // DEPRECATED
ADD_FUNCTION("canDGun", ud, ReturnFalse); // DEPRECATED
ADD_FUNCTION("canCrash", ud, ReturnFalse); // DEPRECATED
ADD_FUNCTION("isCommander", ud, ReturnFalse); // DEPRECATED
ADD_FUNCTION("moveData", ud.pathType, ReturnNil); // DEPRECATED
ADD_FUNCTION("type", ud, ReturnEmptyString); // DEPRECATED
ADD_FUNCTION("maxSlope", ud, ReturnMinusOne); // DEPRECATED
ADD_FUNCTION("totalEnergyOut", ud, TotalEnergyOut);
ADD_FUNCTION("modCategories", ud.categoryString, CategorySetFromString);
ADD_FUNCTION("springCategories", ud.category, CategorySetFromBits);
ADD_FUNCTION("noChaseCategories", ud.noChaseCategory, CategorySetFromBits);
ADD_FUNCTION("customParams", ud.customParams, CustomParamsTable);
ADD_FUNCTION("buildOptions", ud.buildOptions, BuildOptions);
ADD_FUNCTION("decoyDef", ud.decoyDef, UnitDefToID);
ADD_FUNCTION("weapons", ud.weapons, WeaponsTable);
ADD_FUNCTION("sounds", ud.sounds, SoundsTable);
ADD_FUNCTION("model", ud, ModelTable);
ADD_FUNCTION("moveDef", ud.pathType, MoveDefTable);
ADD_FUNCTION("shieldWeaponDef", ud.shieldWeaponDef, WeaponDefToID);
ADD_FUNCTION("stockpileWeaponDef", ud.stockpileWeaponDef, WeaponDefToID);
ADD_FUNCTION("iconType", ud.iconType, SafeIconType);
ADD_FUNCTION("isTransport", ud, IsTransportUnit);
ADD_FUNCTION("isImmobile", ud, IsImmobileUnit);
ADD_FUNCTION("isBuilding", ud, IsBuildingUnit);
ADD_FUNCTION("isBuilder", ud, IsBuilderUnit);
ADD_FUNCTION("isMobileBuilder", ud, IsMobileBuilderUnit);
ADD_FUNCTION("isStaticBuilder", ud, IsStaticBuilderUnit);
ADD_FUNCTION("isFactory", ud, IsFactoryUnit);
ADD_FUNCTION("isExtractor", ud, IsExtractorUnit);
ADD_FUNCTION("isGroundUnit", ud, IsGroundUnit);
ADD_FUNCTION("isAirUnit", ud, IsAirUnit);
ADD_FUNCTION("isStrafingAirUnit", ud, IsStrafingAirUnit);
ADD_FUNCTION("isHoveringAirUnit", ud, IsHoveringAirUnit);
ADD_FUNCTION("isFighterAirUnit", ud, IsFighterAirUnit);
ADD_FUNCTION("isBomberAirUnit", ud, IsBomberAirUnit);
ADD_FUNCTION("height", ud, ModelHeight);
ADD_FUNCTION("radius", ud, ModelRadius);
ADD_FUNCTION("minx", ud, ModelMinx);
ADD_FUNCTION("midx", ud, ModelMidx);
ADD_FUNCTION("maxx", ud, ModelMaxx);
ADD_FUNCTION("miny", ud, ModelMiny);
ADD_FUNCTION("midy", ud, ModelMidy);
ADD_FUNCTION("maxy", ud, ModelMaxy);
ADD_FUNCTION("minz", ud, ModelMinz);
ADD_FUNCTION("midz", ud, ModelMidz);
ADD_FUNCTION("maxz", ud, ModelMaxz);
ADD_INT("id", ud.id);
ADD_INT("cobID", ud.cobID);
ADD_STRING("name", ud.name);
ADD_STRING("humanName", ud.humanName);
ADD_STRING("tooltip", ud.tooltip);
ADD_STRING("wreckName", ud.wreckName);
ADD_FUNCTION("deathExplosion", ud.deathExpWeaponDef, WeaponDefToName);
ADD_FUNCTION("selfDExplosion", ud.selfdExpWeaponDef, WeaponDefToName);
ADD_STRING("buildpicname", ud.buildPicName);
ADD_INT("techLevel", ud.techLevel);
ADD_INT("maxThisUnit", ud.maxThisUnit);
ADD_FLOAT("metalUpkeep", ud.metalUpkeep);
ADD_FLOAT("energyUpkeep", ud.energyUpkeep);
ADD_FLOAT("metalMake", ud.metalMake);
ADD_FLOAT("makesMetal", ud.makesMetal);
ADD_FLOAT("energyMake", ud.energyMake);
ADD_FLOAT("metalCost", ud.metal);
ADD_FLOAT("energyCost", ud.energy);
ADD_FLOAT("buildTime", ud.buildTime);
ADD_FLOAT("extractsMetal", ud.extractsMetal);
ADD_FLOAT("extractRange", ud.extractRange);
ADD_FLOAT("windGenerator", ud.windGenerator);
ADD_FLOAT("tidalGenerator", ud.tidalGenerator);
ADD_FLOAT("metalStorage", ud.metalStorage);
ADD_FLOAT("energyStorage", ud.energyStorage);
ADD_DEPRECATED_LUADEF_KEY("extractSquare");
ADD_FLOAT("power", ud.power);
ADD_FLOAT("health", ud.health);
ADD_FLOAT("autoHeal", ud.autoHeal);
ADD_FLOAT("idleAutoHeal", ud.idleAutoHeal);
ADD_INT("idleTime", ud.idleTime);
ADD_BOOL("canSelfD", ud.canSelfD);
ADD_INT("selfDCountdown", ud.selfDCountdown);
ADD_FLOAT("speed", ud.speed);
ADD_FLOAT("turnRate", ud.turnRate);
ADD_BOOL("turnInPlace", ud.turnInPlace);
ADD_FLOAT("turnInPlaceSpeedLimit", ud.turnInPlaceSpeedLimit);
ADD_BOOL("upright", ud.upright);
ADD_BOOL("collide", ud.collide);
ADD_FLOAT("losHeight", ud.losHeight);
ADD_FLOAT("losRadius", ud.losRadius);
ADD_FLOAT("airLosRadius", ud.airLosRadius);
ADD_INT("radarRadius", ud.radarRadius);
ADD_INT("sonarRadius", ud.sonarRadius);
ADD_INT("jammerRadius", ud.jammerRadius);
ADD_INT("sonarJamRadius", ud.sonarJamRadius);
ADD_INT("seismicRadius", ud.seismicRadius);
ADD_FLOAT("seismicSignature", ud.seismicSignature);
ADD_BOOL("stealth", ud.stealth);
ADD_BOOL("sonarStealth", ud.sonarStealth);
ADD_FLOAT("mass", ud.mass);
ADD_FLOAT("maxHeightDif", ud.maxHeightDif);
ADD_FLOAT("minWaterDepth", ud.minWaterDepth);
ADD_FLOAT("maxWaterDepth", ud.maxWaterDepth);
ADD_FLOAT("waterline", ud.waterline);
ADD_INT("flankingBonusMode", ud.flankingBonusMode);
ADD_FLOAT("flankingBonusMax", ud.flankingBonusMax);
ADD_FLOAT("flankingBonusMin", ud.flankingBonusMin);
ADD_FLOAT("flankingBonusDirX", ud.flankingBonusDir.x);
ADD_FLOAT("flankingBonusDirY", ud.flankingBonusDir.y);
ADD_FLOAT("flankingBonusDirZ", ud.flankingBonusDir.z);
ADD_FLOAT("flankingBonusMobilityAdd", ud.flankingBonusMobilityAdd);
ADD_INT("armorType", ud.armorType);
ADD_FLOAT("armoredMultiple", ud.armoredMultiple);
ADD_FLOAT("minCollisionSpeed", ud.minCollisionSpeed);
ADD_FLOAT("slideTolerance", ud.slideTolerance);
ADD_FLOAT("maxWeaponRange", ud.maxWeaponRange);
ADD_FLOAT("maxCoverage", ud.maxCoverage);
ADD_BOOL( "buildRange3D", ud.buildRange3D);
ADD_FLOAT("buildDistance", ud.buildDistance);
ADD_FLOAT("buildSpeed", ud.buildSpeed);
ADD_FLOAT("repairSpeed", ud.repairSpeed);
ADD_FLOAT("maxRepairSpeed", ud.repairSpeed);
ADD_FLOAT("reclaimSpeed", ud.reclaimSpeed);
ADD_FLOAT("resurrectSpeed", ud.resurrectSpeed);
ADD_FLOAT("captureSpeed", ud.captureSpeed);
ADD_FLOAT("terraformSpeed", ud.terraformSpeed);
ADD_BOOL("canSubmerge", ud.canSubmerge);
ADD_BOOL("floatOnWater", ud.floatOnWater);
ADD_BOOL("canFly", ud.canfly);
ADD_BOOL("canMove", ud.canmove);
ADD_BOOL("onOffable", ud.onoffable);
ADD_BOOL("activateWhenBuilt", ud.activateWhenBuilt);
ADD_DEPRECATED_LUADEF_KEY("canHover");
ADD_BOOL("reclaimable", ud.reclaimable);
ADD_BOOL("capturable", ud.capturable);
ADD_BOOL("repairable", ud.repairable);
ADD_BOOL("canManualFire", ud.canManualFire);
ADD_BOOL("canCloak", ud.canCloak);
ADD_BOOL("canRestore", ud.canRestore);
ADD_BOOL("canRepair", ud.canRepair);
ADD_BOOL("canSelfRepair", ud.canSelfRepair);
ADD_BOOL("canReclaim", ud.canReclaim);
ADD_BOOL("canAttack", ud.canAttack);
ADD_BOOL("canPatrol", ud.canPatrol);
ADD_BOOL("canFight", ud.canFight);
ADD_BOOL("canGuard", ud.canGuard);
ADD_BOOL("canAssist", ud.canAssist);
ADD_BOOL("canBeAssisted", ud.canBeAssisted);
ADD_BOOL("canRepeat", ud.canRepeat);
ADD_BOOL("canCapture", ud.canCapture);
ADD_BOOL("canResurrect", ud.canResurrect);
ADD_BOOL("canLoopbackAttack", ud.canLoopbackAttack);
ADD_BOOL("canFireControl", ud.canFireControl);
ADD_INT( "fireState", ud.fireState);
ADD_INT( "moveState", ud.moveState);
ADD_BOOL("fullHealthFactory", ud.fullHealthFactory);
ADD_BOOL("factoryHeadingTakeoff", ud.factoryHeadingTakeoff);
//aircraft stuff
ADD_DEPRECATED_LUADEF_KEY("drag");
ADD_FLOAT("wingDrag", ud.wingDrag);
ADD_FLOAT("wingAngle", ud.wingAngle);
ADD_FLOAT("crashDrag", ud.crashDrag);
ADD_FLOAT("frontToSpeed", ud.frontToSpeed);
ADD_FLOAT("speedToFront", ud.speedToFront);
ADD_FLOAT("myGravity", ud.myGravity);
ADD_FLOAT("verticalSpeed",ud.verticalSpeed);
ADD_FLOAT("maxBank", ud.maxBank);
ADD_FLOAT("maxPitch", ud.maxPitch);
ADD_FLOAT("turnRadius", ud.turnRadius);
ADD_FLOAT("wantedHeight", ud.wantedHeight);
ADD_BOOL("hoverAttack", ud.hoverAttack);
ADD_BOOL("airStrafe", ud.airStrafe);
ADD_BOOL("bankingAllowed",ud.bankingAllowed);
ADD_BOOL("useSmoothMesh", ud.useSmoothMesh);
// < 0 means it can land,
// >= 0 indicates how much the unit will move during hovering on the spot
ADD_FLOAT("dlHoverFactor", ud.dlHoverFactor);
// bool DontLand (") { return dlHoverFactor >= 0.0f; }
ADD_FLOAT("maxAcc", ud.maxAcc);
ADD_FLOAT("maxDec", ud.maxDec);
ADD_FLOAT("maxAileron", ud.maxAileron);
ADD_FLOAT("maxElevator", ud.maxElevator);
ADD_FLOAT("maxRudder", ud.maxRudder);
ADD_FLOAT("maxFuel", ud.maxFuel);
ADD_FLOAT("refuelTime", ud.refuelTime);
ADD_FLOAT("minAirBasePower", ud.minAirBasePower);
// unsigned char* yardmapLevels[6];
// unsigned char* yardmaps[4]; //Iterations of the Ymap for building rotation
ADD_INT("xsize", ud.xsize);
ADD_INT("zsize", ud.zsize);
// transport stuff
ADD_INT( "transportCapacity", ud.transportCapacity);
ADD_INT( "transportSize", ud.transportSize);
ADD_FLOAT("transportMass", ud.transportMass);
ADD_FLOAT("loadingRadius", ud.loadingRadius);
ADD_BOOL( "isAirBase", ud.isAirBase);
ADD_BOOL( "isFirePlatform", ud.isFirePlatform);
ADD_BOOL( "holdSteady", ud.holdSteady);
ADD_BOOL( "releaseHeld", ud.releaseHeld);
ADD_BOOL( "cantBeTransported", ud.cantBeTransported);
ADD_BOOL( "transportByEnemy", ud.transportByEnemy);
ADD_INT( "transportUnloadMethod", ud.transportUnloadMethod);
ADD_FLOAT("fallSpeed", ud.fallSpeed);
ADD_FLOAT("unitFallSpeed", ud.unitFallSpeed);
ADD_BOOL( "startCloaked", ud.startCloaked);
ADD_FLOAT("cloakCost", ud.cloakCost);
ADD_FLOAT("cloakCostMoving", ud.cloakCostMoving);
ADD_FLOAT("decloakDistance", ud.decloakDistance);
ADD_BOOL( "decloakSpherical", ud.decloakSpherical);
ADD_BOOL( "decloakOnFire", ud.decloakOnFire);
ADD_INT( "cloakTimeout", ud.cloakTimeout);
ADD_BOOL( "canKamikaze", ud.canKamikaze);
ADD_FLOAT("kamikazeDist", ud.kamikazeDist);
ADD_BOOL( "kamikazeUseLOS", ud.kamikazeUseLOS);
ADD_BOOL("targfac", ud.targfac);
ADD_BOOL("needGeo", ud.needGeo);
ADD_BOOL("isFeature", ud.isFeature);
ADD_BOOL("hideDamage", ud.hideDamage);
ADD_BOOL("showPlayerName", ud.showPlayerName);
ADD_INT("highTrajectoryType", ud.highTrajectoryType);
ADD_BOOL( "leaveTracks", ud.decalDef.leaveTrackDecals);
ADD_INT( "trackType", ud.decalDef.trackDecalType);
ADD_FLOAT("trackWidth", ud.decalDef.trackDecalWidth);
ADD_FLOAT("trackOffset", ud.decalDef.trackDecalOffset);
ADD_FLOAT("trackStrength", ud.decalDef.trackDecalStrength);
ADD_FLOAT("trackStretch", ud.decalDef.trackDecalStretch);
ADD_BOOL( "canDropFlare", ud.canDropFlare);
ADD_FLOAT("flareReloadTime", ud.flareReloadTime);
ADD_FLOAT("flareEfficiency", ud.flareEfficiency);
ADD_FLOAT("flareDelay", ud.flareDelay);
ADD_FLOAT("flareDropVectorX", ud.flareDropVector.x);
ADD_FLOAT("flareDropVectorY", ud.flareDropVector.y);
ADD_FLOAT("flareDropVectorZ", ud.flareDropVector.z);
ADD_INT( "flareTime", ud.flareTime);
ADD_INT( "flareSalvoSize", ud.flareSalvoSize);
ADD_INT( "flareSalvoDelay", ud.flareSalvoDelay);
ADD_BOOL("levelGround", ud.levelGround);
ADD_BOOL("strafeToAttack", ud.strafeToAttack);
ADD_BOOL( "useBuildingGroundDecal", ud.decalDef.useGroundDecal);
ADD_INT( "buildingDecalType", ud.decalDef.groundDecalType);
ADD_INT( "buildingDecalSizeX", ud.decalDef.groundDecalSizeX);
ADD_INT( "buildingDecalSizeY", ud.decalDef.groundDecalSizeY);
ADD_FLOAT("buildingDecalDecaySpeed", ud.decalDef.groundDecalDecaySpeed);
ADD_BOOL("showNanoFrame", ud.showNanoFrame);
ADD_BOOL("showNanoSpray", ud.showNanoSpray);
ADD_FLOAT("nanoColorR", ud.nanoColor.x);
ADD_FLOAT("nanoColorG", ud.nanoColor.y);
ADD_FLOAT("nanoColorB", ud.nanoColor.z);
ADD_STRING("scriptName", ud.scriptName);
ADD_STRING("scriptPath", ud.scriptName); //FIXME // backward compability
return true;
}
BOOL
FIsIndirectJump(
BYTE * rgbBuffer,
DWORD cbBuff,
HTHDX hthd,
UOFFSET uoffset,
UOFFSET * lpuoffThunkDest,
LPDWORD lpdwThunkSize
)
{
// MIPS indirect (dll import) thunk either looks like this:
// R4k
// 0x00, 0x00, 0x08, 0x3C, // lui $8,IAT
// 0x00, 0x00, 0x08, 0x8D, // lw $8,IAT($8)
// 0x08, 0x00, 0x00, 0x01, // jr $8
// 0x00, 0x00, 0x00, 0x00, // nop (delay slot)
//
// or like this:
// R3k
// 0x00, 0x00, 0x08, 0x3C, // lui $8,IAT
// 0x00, 0x00, 0x08, 0x8D, // lw $8,IAT($8)
// 0x00, 0x00, 0x00, 0x00, // nop (Required for R3000)
// 0x08, 0x00, 0x00, 0x01, // jr $8
// 0x00, 0x00, 0x00, 0x00, // nop (delay slot)
if (cbBuff >= 16) {
DWORD *Inst = (DWORD *)rgbBuffer;
DWORD ThunkSize = 0;
if ((OPCODE(*(Inst+0)) == 0x3C08) &&
(OPCODE(*(Inst+1)) == 0x8D08) &&
(*(Inst+2) == 0x01000008) &&
(*(Inst+3) == 0x00000000))
{
// We've got a R4K thunk.
ThunkSize = 16;
} else {
if (cbBuff >= 20) {
if ((OPCODE(*(Inst+0)) == 0x3C08) &&
(OPCODE(*(Inst+1)) == 0x8D08) &&
(*(Inst+2) == 0x00000000) &&
(*(Inst+3) == 0x01000008) &&
(*(Inst+4) == 0x00000000))
{
// We've got a R3K thunk.
ThunkSize = 20;
}
}
}
if (ThunkSize) {
DWORD Address;
Address = ADDRESS(*(Inst+0)) << 16 + ADDRESS(*(Inst+1));
if ( DbgReadMemory (
hthd->hprc,
(LPCVOID)Address,
lpuoffThunkDest,
sizeof(UOFFSET),
NULL)
) {
*lpdwThunkSize = ThunkSize;
return TRUE;
}
}
}
return FALSE;
}
