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; }