int cmd_import( REPLY *r, const char *addr_str) {
char addrbuf[FULL_ADDSTRLEN+1];
IP addr;
int rc;
/* If the address contains no port - use the default port */
if( (rc = addr_parse_full( &addr, addr_str, DHT_PORT, gconf->af )) == ADDR_PARSE_SUCCESS ) {
if( kad_ping( &addr ) == 0 ) {
r_printf( r, "Send ping to: %s\n", str_addr( &addr, addrbuf ) );
return 0;
} else {
r_printf( r, "Failed to send ping.\n" );
return 1;
}
} else if( rc == ADDR_PARSE_CANNOT_RESOLVE ) {
r_printf( r, "Failed to resolve address.\n" );
return 1;
} else if( rc == ADDR_PARSE_NO_ADDR_FOUND ) {
r_printf( r, "Failed to aquire address of required protocol.\n" );
return 1;
} else {
r_printf( r, "Failed to parse address.\n" );
return 1;
}
}
int cmd_blacklist( REPLY *r, const char *addr_str ) {
char addrbuf[FULL_ADDSTRLEN+1];
IP addr;
if( addr_parse( &addr, addr_str, NULL, gconf->af ) != 0 ) {
r_printf( r, "Invalid address.\n" );
return 1;
} else {
kad_blacklist( &addr );
r_printf( r, "Added to blacklist: %s\n", str_addr( &addr, addrbuf ) );
return 0;
}
}
void cmd_remote_handler( int rc, int sock ) {
char* argv[32];
int argc;
IP clientaddr;
socklen_t addrlen_ret;
socklen_t addrlen;
char request[1500];
REPLY reply;
addrlen_ret = sizeof(IP);
rc = recvfrom( sock, request, sizeof(request) - 1, 0, (struct sockaddr*)&clientaddr, &addrlen_ret );
if( rc <= 0 ) {
return;
} else {
request[rc] = '\0';
}
/* Initialize reply and reserve room for return status */
r_init( &reply, false );
r_printf( &reply, "_" );
/* Split up the command line into an argument array */
cmd_to_args( request, &argc, &argv[0], N_ELEMS(argv) );
/* Execute command line */
rc = cmd_exec( &reply, argc, argv );
/* Insert return code */
reply.data[0] = (rc == 0) ? '0' : '1';
addrlen = addr_len( &clientaddr );
rc = sendto( sock, reply.data, reply.size, 0, (struct sockaddr *)&clientaddr, addrlen );
}
int main(int argc, char *argv[])
{
rvm_codelabel_t *err;
rpa_compiler_t *co;
rpastat_t *stat;
unsigned int mainoff;
char teststr[] = "abcabcabcdefghiabc";
co = rpa_compiler_create();
stat = rpa_stat_create(NULL, 4096);
rvm_cpu_addswitable(stat->cpu, "common_table", common_calltable);
rpa_stat_init(stat, RPA_ENCODING_UTF8, teststr, teststr, teststr+12, NULL);
mainoff = rvm_codegen_addins(co->cg, rvm_asml(RVM_NOP, XX, XX, XX, -1));
rvm_codegen_addins(co->cg, rvm_asml(RVM_MOV, R_TOP, DA, XX, -1));
rvm_codegen_addins(co->cg, rvm_asml(RVM_MOV, FP, DA, XX, 0));
rvm_codegen_addins(co->cg, rvm_asml(RVM_MOV, SP, DA, XX, 0));
rvm_codegen_addins(co->cg, rvm_asm(RPA_SHIFT, XX, XX, XX, 0));
code_rpa_matchminusexp(co, stat);
rvm_codegen_addins(co->cg, rvm_asm(RVM_NOP, XX, XX, XX, 0xabc));
rvm_codegen_addins(co->cg, rvm_asm(RVM_EXT, XX, XX, XX, 0));
if (rvm_codegen_relocate(co->cg, &err) < 0) {
r_printf("Unresolved symbol: %s\n", err->name->str);
goto end;
}
rvm_cpu_exec(stat->cpu, rvm_codegen_getcode(co->cg, 0), mainoff);
end:
rpa_stat_destroy(stat);
rpa_compiler_destroy(co);
r_printf("Max alloc mem: %ld\n", r_debug_get_maxmem());
r_printf("Leaked mem: %ld\n", r_debug_get_allocmem());
return 0;
}
/* Export up to 32 peer addresses - more would not fit into one UDP packet */
int cmd_export( REPLY *r ) {
char addrbuf[FULL_ADDSTRLEN+1];
IP addr_array[32];
size_t addr_num;
size_t i;
addr_num = N_ELEMS(addr_array);
if( kad_export_nodes( addr_array, &addr_num ) != 0 ) {
return 1;
}
for( i = 0; i < addr_num; ++i ) {
r_printf( r, "%s\n", str_addr( &addr_array[i], addrbuf ) );
}
if( i == 0 ) {
r_printf( r, "No good nodes found.\n" );
return 1;
}
return 0;
}
int cmd_exec( REPLY *r, int argc, char **argv ) {
char addrbuf[FULL_ADDSTRLEN+1];
time_t lifetime;
int minutes;
IP addrs[16];
int port;
int count;
static struct value_t *value;
char *p;
int rc = 0;
if( argc == 0 ) {
/* Print usage */
r_printf( r, cmd_usage );
if( r->allow_debug ) {
r_printf( r, cmd_usage_debug );
}
rc = 1;
} else if( match( argv[0], "import" ) && argc == 2 ) {
rc = cmd_import( r, argv[1] );
#if 0
} else if( match( argv[0], "lookup_node" ) && argc == 2 ) {
/* Check searches for node */
rc = kad_lookup_node( argv[1], &addrs[0] );
if( rc == 0 ) {
r_printf( r, "%s\n", str_addr( &addrs[0], addrbuf ) );
} else if( rc == 1 ) {
r_printf( r ,"No search found.\n" );
rc = 1;
} else if( rc == 2 ) {
r_printf( r ,"Invalid id format. 20 digit hex string expected.\n" );
rc = 1;
} else {
rc = 1;
}
#endif
} else if( match( argv[0], "lookup" ) && argc == 2 ) {
size_t num = N_ELEMS(addrs);
size_t i;
/* Check searches for node */
rc = kad_lookup_value( argv[1], addrs, &num );
if( rc >= 0 && num > 0 ) {
for( i = 0; i < num; ++i ) {
r_printf( r, "%s\n", str_addr( &addrs[i], addrbuf ) );
}
} else if( rc < 0 ) {
r_printf( r ,"Some error occured.\n" );
rc = 1;
} else if( rc == 0 ) {
r_printf( r ,"Search in progress.\n" );
rc = 1;
} else {
r_printf( r ,"Search started.\n" );
rc = 1;
}
} else if( match( argv[0], "status" ) && argc == 1 ) {
/* Print node id and statistics */
cmd_print_status( r );
} else if( match( argv[0], "announce" ) && (argc == 1 || argc == 2 || argc == 3) ) {
if( argc == 1 ) {
/* Announce all values; does not update value.refreshed */
count = 0;
value = values_get();
while( value ) {
kad_announce_once( value->id, value->port );
count++;
value = value->next;
}
r_printf( r ,"%d announcements started.\n", count );
rc = 0;
goto end;
} else if( argc == 2 ) {
minutes = 0;
lifetime = 0;
} else if( argc == 3 ) {
minutes = atoi( argv[2] );
if( minutes < 0 ) {
minutes = 0;
lifetime = LONG_MAX;
} else {
/* Round up to multiple of 30 minutes */
minutes = (30 * (minutes/30 + 1));
lifetime = (time_now_sec() + (minutes * 60));
}
} else {
/* Make compilers happy */
exit( 1 );
}
int is_random_port = 0;
/* Find <id>:<port> delimiter */
p = strchr( argv[1], ':' );
if( p ) {
*p = '\0';
port = port_parse( p + 1, -1 );
} else {
/* A valid port will be choosen inside kad_announce() */
port = 0;
is_random_port = 1;
}
if( kad_announce( argv[1], port, lifetime ) >= 0 ) {
#ifdef FWD
if( !is_random_port ) {
forwardings_add( port, lifetime);
}
#endif
if( lifetime == 0 ) {
r_printf( r ,"Start single announcement now.\n" );
} else if( lifetime == LONG_MAX ) {
r_printf( r ,"Start regular announcements for the entire run time (%sport %d).\n", (is_random_port ? "random " : ""), port );
} else {
r_printf( r ,"Start regular announcements for %d minutes (%sport %d).\n", minutes, (is_random_port ? "random " : ""), port );
}
} else {
r_printf( r ,"Invalid port or query too long.\n" );
rc = 1;
}
} else if( match( argv[0], "blacklist" ) && argc == 2 ) {
rc = cmd_blacklist( r, argv[1] );
} else if( match( argv[0], "export" ) && argc == 1 ) {
rc = cmd_export( r );
} else if( match( argv[0], "list" ) && argc == 2 && r->allow_debug ) {
if( gconf->is_daemon == 1 ) {
r_printf( r ,"The 'list' command is not available while KadNode runs as daemon.\n" );
rc = 1;
goto end;
} else if( match( argv[1], "blacklist" ) ) {
kad_debug_blacklist( STDOUT_FILENO );
rc = 0;
} else if( match( argv[1], "buckets" ) ) {
kad_debug_buckets( STDOUT_FILENO );
rc = 0;
} else if( match( argv[1], "constants" ) ) {
kad_debug_constants( STDOUT_FILENO );
rc = 0;
#ifdef FWD
} else if( match( argv[1], "forwardings" ) ) {
forwardings_debug( STDOUT_FILENO );
rc = 0;
#endif
#ifdef AUTH
} else if( match( argv[1], "pkeys" ) ) {
auth_debug_pkeys( STDOUT_FILENO );
rc = 0;
} else if( match( argv[1], "skeys" ) ) {
auth_debug_skeys( STDOUT_FILENO );
rc = 0;
#endif
} else if( match( argv[1], "results" ) ) {
results_debug( STDOUT_FILENO );
rc = 0;
} else if( match( argv[1], "searches" ) ) {
kad_debug_searches( STDOUT_FILENO );
rc = 0;
} else if( match( argv[1], "storage" ) ) {
kad_debug_storage( STDOUT_FILENO );
rc = 0;
} else if( match( argv[1], "values" ) ) {
values_debug( STDOUT_FILENO );
rc = 0;
} else {
dprintf( STDERR_FILENO, "Unknown argument.\n" );
rc = 1;
}
r_printf( r ,"\nOutput send to console.\n" );
} else {
/* print usage */
r_printf( r, cmd_usage );
if( r->allow_debug ) {
r_printf( r, cmd_usage_debug );
}
rc = 1;
}
end:
;
return rc;
}
/* DANG_BEGIN_FUNCTION write_pic0,write_pic1
*
* write_pic_0() and write_pic1() implement dos writes to the pic ports.
* They are called by the code that emulates inb and outb instructions.
* Each function implements both ports for the pic: pic0 is on ports
* 0x20 and 0x21; pic1 is on ports 0xa0 and 0xa1. These functions take
* two arguments: a port number (0 or 1) and a value to be written.
*
* DANG_END_FUNCTION
*/
void write_pic0(ioport_t port, Bit8u value)
{
/* if port == 0 this must be either an ICW1, OCW2, or OCW3
* if port == 1 this must be either ICW2, ICW3, ICW4, or load IMR
*/
#if 0
static char icw_state, /* !=0 => port 1 does icw 2,3,(4) */
#endif
static char icw_max_state; /* number of icws expected */
int ilevel; /* level to reset on outb 0x20 */
port -= 0x20;
ilevel = 32;
if (pic_isr)
ilevel=find_bit(pic_isr);
if (ilevel != 32 && !test_bit(ilevel, &pic_irqall)) {
/* this is a fake IRQ, don't allow to reset its ISR bit */
pic_print(1, "Protecting ISR bit for lvl ", ilevel, " from spurious EOI");
ilevel = 32;
}
if (in_dpmi_pm())
dpmi_return_request(); /* we have to leave the signal context */
if(!port){ /* icw1, ocw2, ocw3 */
if(value&0x10){ /* icw1 */
icw_max_state = (value & 1) + 1;
if(value&2) ++icw_max_state;
pic0_icw_state = 1;
pic0_cmd=1;
}
else if (value&0x08){ /* ocw3 */
if(value&2) pic0_isr_requested = value&1;
if(value&64)pic_smm = value&32; /* must be either 0 or 32, conveniently */
pic0_cmd=3;
}
else if((value&0xb8) == 0x20) { /* ocw2 */
/* irqs on pic1 require an outb20 to each pic. we settle for any 2 */
if(!clear_bit(ilevel,&pic1_isr)) {
clear_bit(ilevel,&pic_isr); /* the famous outb20 */
pic_print(1,"EOI resetting bit ",ilevel, " on pic0");
#if 1
/* XXX hack: to avoid timer interrupt re-entrancy,
* we try to disable interrupts in a hope IRET will re-enable
* them. This fixes Tetris Classic problem:
* https://github.com/stsp/dosemu2/issues/99
* Need to check also IMR because DPMI uses another hack
* that masks the IRQs. */
if (ilevel == PIC_IRQ0 && isset_IF() && !(pic_imr & (1 << ilevel))) {
r_printf("PIC: disabling interrupts to avoid reentrancy\n");
clear_IF_timed();
}
#endif
}
else
pic_print(1,"EOI resetting bit ",ilevel, " on pic1");
pic0_cmd=2;
}
}
else /* icw2, icw3, icw4, or mask register */
switch(pic0_icw_state){
case 0: /* mask register */
set_pic0_imr(value);
pic_print(1, "Set mask to ", value, " on pic0");
break;
case 1: /* icw2 */
set_pic0_base(value);
default: /* icw2, 3, and 4*/
if(pic0_icw_state++ >= icw_max_state) pic0_icw_state=0;
}
}
int main(int argc, char *argv[])
{
rvmcpu_t *cpu;
rvm_codegen_t *cg;
rvm_codelabel_t *err;
unsigned int ntable;
cg = rvm_codegen_create();
cpu = rvm_cpu_create_default();
ntable = rvm_cpu_addswitable(cpu, "switable", switable);
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 7));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 1 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 8));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 2 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 9));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 3 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 3));
rvm_codegen_addrelocins_s(cg, RVM_RELOC_JUMP, "add3", rvm_asm(RVM_BXL, DA, XX, XX, 0));
rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(RVM_SWI_ID(ntable, 0)), R0, XX, XX, 0));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 1));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 1 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 2));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 2 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 3));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 3 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 4));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 4 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 4));
rvm_codegen_addrelocins_s(cg, RVM_RELOC_BRANCH, "varadd", rvm_asm(RVM_BL, DA, XX, XX, 0));
rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(RVM_SWI_ID(ntable, 0)), R0, XX, XX, 0));
rvm_codegen_addins(cg, rvm_asm(RVM_EXT, XX, XX, XX, 0));
rvm_codegen_funcstart_s(cg, "add2", 2);
rvm_codegen_addins(cg, rvm_asm(RVM_LDS, R0, FP, DA, 1));
rvm_codegen_addins(cg, rvm_asm(RVM_LDS, R1, FP, DA, 2));
rvm_codegen_addins(cg, rvm_asm(RVM_ADD, R0, R0, R1, 0));
rvm_codegen_funcend(cg);
rvm_codegen_funcstart_s(cg, "add3", 3);
rvm_codegen_addins(cg, rvm_asm(RVM_LDS, R0, FP, DA, 1));
rvm_codegen_addins(cg, rvm_asm(RVM_LDS, R1, FP, DA, 2));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 1 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R1, SP, DA, 2 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 2));
rvm_codegen_addrelocins_s(cg, RVM_RELOC_BRANCH, "add2", rvm_asm(RVM_BL, DA, XX, XX, 0));
rvm_codegen_addins(cg, rvm_asm(RVM_LDS, R1, FP, DA, 3));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 1 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R1, SP, DA, 2 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 2));
rvm_codegen_addrelocins_s(cg, RVM_RELOC_BRANCH, "add2", rvm_asm(RVM_BL, DA, XX, XX, 0));
rvm_codegen_funcend(cg);
rvm_codegen_vargs_funcstart_s(cg, "varadd");
rvm_codegen_addins(cg, rvm_asm(RVM_LDS, R7, FP, DA, -3));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 0));
rvm_codegen_addins(cg, rvm_asm(RVM_CMP, R7, DA, XX, 0));
rvm_codegen_addins(cg, rvm_asm(RVM_BLEQ, DA, XX, XX, 5));
rvm_codegen_addins(cg, rvm_asm(RVM_LDS, R1, FP, R7, 0));
rvm_codegen_addins(cg, rvm_asm(RVM_ADD, R0, R0, R1, 0));
rvm_codegen_addins(cg, rvm_asm(RVM_SUB, R7, R7, DA, 1));
rvm_codegen_addins(cg, rvm_asm(RVM_B, DA, XX, XX, -5));
rvm_codegen_addins(cg, rvm_asm(RVM_NOP, XX, XX, XX, 0));
rvm_codegen_funcend(cg);
rvm_codegen_addins(cg, rvm_asm(RVM_NOP, XX, XX, XX, 0));
rvm_codegen_addins(cg, rvm_asm(RVM_NOP, XX, XX, XX, 0));
rvm_codegen_addins(cg, rvm_asm(RVM_NOP, XX, XX, XX, 0));
if (rvm_codegen_relocate(cg, &err) < 0) {
r_printf("Unresolved symbol: %s\n", err->name->str);
goto end;
}
rvm_asm_dump(cpu, rvm_codegen_getcode(cg, 0), rvm_codegen_getcodesize(cg));
rvm_cpu_exec_debug(cpu, rvm_codegen_getcode(cg, 0), 0);
end:
rvm_cpu_destroy(cpu);
rvm_codegen_destroy(cg);
fprintf(stdout, "It works!\n");
return 0;
}
