void toggleSwitches(void){ if (commands[0] == high(OW_DS2405_FAMILY_CODE) && commands[1] == low(OW_DS2405_FAMILY_CODE) && (commands[2] == COMMAND_OFF || commands[2] == COMMAND_ON)){ unsigned char stat = MT8870_GetStat(); for (unsigned char i=0; i<switchCurr; i++){ if (stat == COMMAND_OFF && DS24x05_GetState(owDevicesIDs[i]) == true){ DS24x05_Toggle(owDevicesIDs[i]); printf("\r"); print_address(owDevicesIDs[i]); printf(" - Switch OFF"); }else if (stat == COMMAND_ON && DS24x05_GetState(owDevicesIDs[i]) == false){ DS24x05_Toggle(owDevicesIDs[i]); printf("\r"); print_address(owDevicesIDs[i]); printf(" - Switch ON"); } } commands_Reset(); } }
/*---------------------------------------------------------------------------*/ void print_addresses(void) { uip_ds6_addr_t *lladdr; printf("link-local IPv6 address: "); lladdr = uip_ds6_get_link_local(-1); if(lladdr != NULL){ print_address(lladdr); printf("\r\n"); } else printf("None\r\n"); printf("global IPv6 address: "); lladdr = uip_ds6_get_global(-1); if(lladdr != NULL){ print_address(lladdr); printf("\r\n"); } else printf("None\r\n"); }
enum sym_get_lval symbol_picker_interactive(const char* name, const struct sgv_data* sgv, struct dbg_lvalue* rtn) { char buffer[512]; unsigned i; if (!dbg_interactiveP) { dbg_printf("More than one symbol named %s, picking the first one\n", name); *rtn = sgv->syms[0].lvalue; return sglv_found; } dbg_printf("Many symbols with name '%s', " "choose the one you want (<cr> to abort):\n", name); for (i = 0; i < sgv->num; i++) { if (sgv->num - sgv->num_thunks > 1 && (sgv->syms[i].flags & SYMFLAG_THUNK) && !DBG_IVAR(AlwaysShowThunks)) continue; dbg_printf("[%d]: ", i + 1); if (sgv->syms[i].flags & SYMFLAG_LOCAL) { dbg_printf("%s %sof %s\n", sgv->syms[i].flags & SYMFLAG_PARAMETER ? "Parameter" : "Local variable", sgv->syms[i].flags & (SYMFLAG_REGISTER|SYMFLAG_REGREL) ? "(in a register) " : "", name); } else if (sgv->syms[i].flags & SYMFLAG_THUNK) { print_address(&sgv->syms[i].lvalue.addr, TRUE); /* FIXME: should display where the thunks points to */ dbg_printf(" thunk %s\n", name); } else { print_address(&sgv->syms[i].lvalue.addr, TRUE); dbg_printf("\n"); } } do { i = 0; if (input_read_line("=> ", buffer, sizeof(buffer))) { if (buffer[0] == '\0') return sglv_aborted; i = atoi(buffer); if (i < 1 || i > sgv->num) dbg_printf("Invalid choice %d\n", i); } else return sglv_aborted; } while (i < 1 || i > sgv->num); /* The array is 0-based, but the choices are 1..n, * so we have to subtract one before returning. */ *rtn = sgv->syms[i - 1].lvalue; return sglv_found; }
int main( int argc, char *argv[]) { BACNET_ADDRESS src = { 0 }; /* address where message came from */ uint16_t pdu_len = 0; unsigned timeout = 100; /* milliseconds */ BACNET_ADDRESS my_address, broadcast_address; (void) argc; (void) argv; Device_Set_Object_Instance_Number(4194300); address_init(); Init_Service_Handlers(); dlenv_init(); datalink_get_broadcast_address(&broadcast_address); print_address("Broadcast", &broadcast_address); datalink_get_my_address(&my_address); print_address("Address", &my_address); printf("BACnet stack running...\n"); /* loop forever */ for (;;) { /* input */ /* returns 0 bytes on timeout */ pdu_len = datalink_receive(&src, &Rx_Buf[0], MAX_MPDU, timeout); /* process */ if (pdu_len) { npdu_handler(&src, &Rx_Buf[0], pdu_len); } if (I_Am_Request) { I_Am_Request = false; Send_I_Am(&Handler_Transmit_Buffer[0]); } else if (Who_Is_Request) { Who_Is_Request = false; Send_WhoIs(-1, -1); } else { Read_Properties(); } /* output */ /* blink LEDs, Turn on or off outputs, etc */ /* wait for ESC from keyboard before quitting */ if (kbhit() && (getch() == 0x1B)) break; } print_address_cache(); return 0; }
static void at_return(app_pc instr_addr, app_pc target_addr) { file_t f = (file_t)(ptr_uint_t) dr_get_tls_field(dr_get_current_drcontext()); #ifdef SHOW_SYMBOLS print_address(f, instr_addr, "RETURN @ "); print_address(f, target_addr, "\t to "); #else dr_fprintf(f, "RETURN @ "PFX" to "PFX"\n", instr_addr, target_addr); #endif }
print_ranges_property(device *me, const device_property *property) { int range_nr; range_property_spec range; for (range_nr = 0; device_find_range_array_property(me, property->name, range_nr, &range); range_nr++) { print_address(me, &range.child_address); print_address(device_parent(me), &range.parent_address); print_size(me, &range.size); } }
/*********************************************************************** * break_should_continue * * Determine if we should continue execution after a SIGTRAP signal when * executing in the given mode. */ BOOL break_should_continue(ADDRESS64* addr, DWORD code) { enum dbg_exec_mode mode = dbg_curr_thread->exec_mode; if (dbg_curr_thread->stopped_xpoint > 0) { if (!should_stop(dbg_curr_thread->stopped_xpoint)) return TRUE; switch (dbg_curr_process->bp[dbg_curr_thread->stopped_xpoint].xpoint_type) { case be_xpoint_break: case be_xpoint_watch_exec: dbg_printf("Stopped on breakpoint %d at ", dbg_curr_thread->stopped_xpoint); print_address(&dbg_curr_process->bp[dbg_curr_thread->stopped_xpoint].addr, TRUE); dbg_printf("\n"); break; case be_xpoint_watch_read: case be_xpoint_watch_write: dbg_printf("Stopped on watchpoint %d at ", dbg_curr_thread->stopped_xpoint); print_address(addr, TRUE); dbg_printf(" new value %s\n", wine_dbgstr_longlong(dbg_curr_process->bp[dbg_curr_thread->stopped_xpoint].w.oldval)); } return FALSE; } /* * If our mode indicates that we are stepping line numbers, * get the current function, and figure out if we are exactly * on a line number or not. */ if (mode == dbg_exec_step_over_line || mode == dbg_exec_step_into_line) { if (symbol_get_function_line_status(addr) == dbg_on_a_line_number) dbg_curr_thread->exec_count--; } else if (mode == dbg_exec_step_over_insn || mode == dbg_exec_step_into_insn) dbg_curr_thread->exec_count--; if (dbg_curr_thread->exec_count > 0 || mode == dbg_exec_finish) { /* * We still need to execute more instructions. */ return TRUE; } /* no breakpoint, continue if in continuous mode */ return mode == dbg_exec_cont || mode == dbg_exec_finish; }
static void at_call(app_pc instr_addr, app_pc target_addr) { file_t f = (file_t)(ptr_uint_t) dr_get_tls_field(dr_get_current_drcontext()); dr_mcontext_t mc = {sizeof(mc),DR_MC_CONTROL/*only need xsp*/}; dr_get_mcontext(dr_get_current_drcontext(), &mc); #ifdef SHOW_SYMBOLS print_address(f, instr_addr, "CALL @ "); print_address(f, target_addr, "\t to "); dr_fprintf(f, "\tTOS is "PFX"\n", mc.xsp); #else dr_fprintf(f, "CALL @ "PFX" to "PFX", TOS is "PFX"\n", instr_addr, target_addr, mc.xsp); #endif }
retc_t disasm_addr(struct ps_prochandle * ph, ulong_t addr, int num_inst) { ulong_t offset; ulong_t end; int vers = V8_MODE; if (ph->pp_dmodel == PR_MODEL_LP64) vers = V9_MODE | V9_SGI_MODE; for (offset = addr, end = addr + num_inst * 4; offset < end; offset += 4) { char * instr_str; unsigned int instr; if (ps_pread(ph, offset, (char *)&instr, sizeof (unsigned)) != PS_OK) perror("da: ps_pread"); cur_ph = ph; instr_str = disassemble(instr, offset, print_address, 0, 0, vers); printf("%-30s: %s\n", print_address(offset), instr_str); } return (RET_OK); }
/* Like print_address with slightly different parameters. */ static void dis_asm_print_address (bfd_vma addr, struct disassemble_info *info) { struct gdbarch *gdbarch = info->application_data; print_address (gdbarch, addr, info->stream); }
int main(int argc, const char * argv[]) { struct address data[SIZE]; int i = 0, operation; while (1) { get_operation(&operation); if (operation == 2) { break; } else if (operation == 0){ if (i < SIZE){ data[i++] = input_address(); } else puts("\n\nDatensatz voll. Keine Aufnahme zusaetzlicher Daten moeglich.\n\n"); } else if (operation == 1){ if(i == 0){ puts("\n\nEs sind noch keine Datensaetze vorhanden. Geben Sie bitte erst welche ein.\n\n"); } else{ for (int j = 0; j < i ; j++) { print_address(&data[j]); } } } } return EXIT_SUCCESS; }
/* Function to set the disassembly window's content. Disassemble count lines starting at pc. Return address of the count'th instruction after pc. */ static CORE_ADDR tui_disassemble (struct gdbarch *gdbarch, struct tui_asm_line *asm_lines, CORE_ADDR pc, int count) { string_file gdb_dis_out; /* Now construct each line. */ for (; count > 0; count--, asm_lines++) { if (asm_lines->addr_string) xfree (asm_lines->addr_string); if (asm_lines->insn) xfree (asm_lines->insn); print_address (gdbarch, pc, &gdb_dis_out); asm_lines->addr = pc; asm_lines->addr_string = xstrdup (gdb_dis_out.c_str ()); gdb_dis_out.clear (); pc = pc + gdb_print_insn (gdbarch, pc, &gdb_dis_out, NULL); asm_lines->insn = xstrdup (gdb_dis_out.c_str ()); /* Reset the buffer to empty. */ gdb_dis_out.clear (); } return pc; }
/*----------------------------------------------------------------------------*/ void print_node_conf(void){ PRINTF("[CFG]: NODE: "); print_address(&(conf.my_address)); PRINTF("\n"); PRINTF("[CFG]: - Network ID: %d\n[CFG]: - Beacon Period: %d\n[CFG]: - " "Report Period: %d\n[CFG]: - Rules TTL: %d\n[CFG]: - Min RSSI: " "%d\n[CFG]: - Packet TTL: %d\n[CFG]: - Next Hop -> Sink: ", conf.my_net, conf.beacon_period, conf.report_period, conf.rule_ttl, conf.rssi_min, conf.packet_ttl); print_address(&(conf.nxh_vs_sink)); PRINTF(" (hops: %d, rssi: %d)\n", conf.hops_from_sink, conf.rssi_from_sink); PRINTF("[CFG]: - Sink: "); print_address(&(conf.sink_address)); PRINTF("\n"); }
int connect_to_ip (const ip_address *ip, int port, const char *print) { struct sockaddr_storage ss; struct sockaddr *sa = (struct sockaddr *)&ss; int sock; /* If PRINT is non-NULL, print the "Connecting to..." line, with PRINT being the host name we're connecting to. */ if (print) { const char *txt_addr = print_address (ip); if (0 != strcmp (print, txt_addr)) { char *str = NULL, *name; if (opt.enable_iri && (name = idn_decode ((char *) print)) != NULL) { int len = strlen (print) + strlen (name) + 4; str = xmalloc (len); snprintf (str, len, "%s (%s)", name, print); str[len-1] = '\0'; xfree (name); } logprintf (LOG_VERBOSE, _("Connecting to %s|%s|:%d... "), str ? str : escnonprint_uri (print), txt_addr, port); if (str) xfree (str); } else { if (ip->family == AF_INET) logprintf (LOG_VERBOSE, _("Connecting to %s:%d... "), txt_addr, port); #ifdef ENABLE_IPV6 else if (ip->family == AF_INET6) logprintf (LOG_VERBOSE, _("Connecting to [%s]:%d... "), txt_addr, port); #endif } } /* Store the sockaddr info to SA. */ sockaddr_set_data (sa, ip, port); printf("The socket function reached!\n"); /* Create the socket of the family appropriate for the address. */ sock = socket (sa->sa_family, SOCK_STREAM, 0); if (sock < 0) goto err; #if defined(ENABLE_IPV6) && defined(IPV6_V6ONLY) if (opt.ipv6_only) { int on = 1; /* In case of error, we will go on anyway... */ int err = setsockopt (sock, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof (on)); IF_DEBUG if (err < 0) DEBUGP (("Failed setting IPV6_V6ONLY: %s", strerror (errno))); }
/* Function to set the disassembly window's content. Disassemble count lines starting at pc. Return address of the count'th instruction after pc. */ static CORE_ADDR tui_disassemble (struct tui_asm_line* asm_lines, CORE_ADDR pc, int count) { struct ui_file *gdb_dis_out; /* now init the ui_file structure */ gdb_dis_out = tui_sfileopen (256); /* Now construct each line */ for (; count > 0; count--, asm_lines++) { if (asm_lines->addr_string) xfree (asm_lines->addr_string); if (asm_lines->insn) xfree (asm_lines->insn); print_address (pc, gdb_dis_out); asm_lines->addr = pc; asm_lines->addr_string = xstrdup (tui_file_get_strbuf (gdb_dis_out)); ui_file_rewind (gdb_dis_out); pc = pc + gdb_print_insn (pc, gdb_dis_out); asm_lines->insn = xstrdup (tui_file_get_strbuf (gdb_dis_out)); /* reset the buffer to empty */ ui_file_rewind (gdb_dis_out); } ui_file_delete (gdb_dis_out); return pc; }
static int format_addr(msp430_amode_t amode, uint16_t addr) { char name[64]; int numeric = 0; const char *prefix = ""; switch (amode) { case MSP430_AMODE_REGISTER: case MSP430_AMODE_INDIRECT: case MSP430_AMODE_INDIRECT_INC: return 0; case MSP430_AMODE_IMMEDIATE: prefix = "#"; case MSP430_AMODE_INDEXED: numeric = 1; break; case MSP430_AMODE_ABSOLUTE: prefix = "&"; break; case MSP430_AMODE_SYMBOLIC: break; } print_address(addr, name, sizeof(name)); return printc("%s\x1b[1m%s\x1b[0m", prefix, name); }
uint32_t ble_central_bondmngr_init(ble_central_bondmngr_t * p_bm, ble_central_bondmngr_init_t * p_bm_init) { uint32_t err_code; p_bm->p_sec_params = p_bm_init->p_sec_params; bond_info.keyset.keys_periph.p_enc_key = &bond_info.enc_key; if (p_bm_init->delete_bonds) { err_code = ble_flash_page_erase(BLE_CENTRAL_BONDMNGR_PAGE_NUM); if (err_code != NRF_SUCCESS) return err_code; } else { uint8_t size_to_read = sizeof(bond_info)/sizeof(uint32_t); err_code = ble_flash_page_read(BLE_CENTRAL_BONDMNGR_PAGE_NUM, (uint32_t *) &bond_info, &size_to_read); if (err_code != NRF_ERROR_NOT_FOUND && err_code != NRF_SUCCESS) return err_code; printf("Restoring data from %d, %d...\r\n", BLE_CENTRAL_BONDMNGR_PAGE_NUM, BLE_CENTRAL_BONDMNGR_PAGE_NUM*NRF_FICR->CODEPAGESIZE); } print_address(&bond_info.addr); return NRF_SUCCESS; }
static int format_addr(msp430_amode_t amode, address_t addr) { char name[MAX_SYMBOL_LENGTH]; const char *prefix = ""; switch (amode) { case MSP430_AMODE_REGISTER: case MSP430_AMODE_INDIRECT: case MSP430_AMODE_INDIRECT_INC: return 0; case MSP430_AMODE_IMMEDIATE: prefix = "#"; case MSP430_AMODE_INDEXED: break; case MSP430_AMODE_ABSOLUTE: prefix = "&"; break; case MSP430_AMODE_SYMBOLIC: break; } print_address(addr, name, sizeof(name), PRINT_ADDRESS_EXACT); return printc("%s\x1b[1m%s\x1b[0m", prefix, name); }
/* uses default "hd" style, i.e. 16 bytes followed by ASCII */ static void hexdump_line(FILE *out, uint64_t address, unsigned char *buf) { int i; static char tbl[16] = "0123456789ABCDEF"; fprintf(out," "); print_address(out, address); fprintf(out," "); /* hex */ for (i = 0; i < 16; i++) { fprintf(out, "%c%c", tbl[(unsigned char)buf[i]>> 4], tbl[(unsigned char)buf[i] & 0x0f]); fprintf(out," "); if (i == 7) fprintf(out," "); } fprintf(out," "); /* ascii */ for (i = 0; i < 16; i++) { if (isprint(buf[i])) { fprintf(out, "%c", buf[i]); } else { fprintf(out, "."); } } fprintf(out, "\n"); }
static void print_ranges_property (struct hw *me, const struct hw_property *property, struct printer *p) { int range_nr; range_property_spec range; for (range_nr = 0; hw_find_range_array_property (me, property->name, range_nr, &range); range_nr++) { print_address (me, &range.child_address, p); print_address (hw_parent (me), &range.parent_address, p); print_size (me, &range.size, p); } }
bool dos_blocker::incoming(address const& addr, time_point const now, dht_logger* logger) { TORRENT_UNUSED(logger); node_ban_entry* match = nullptr; node_ban_entry* min = m_ban_nodes; for (node_ban_entry* i = m_ban_nodes; i < m_ban_nodes + num_ban_nodes; ++i) { if (i->src == addr) { match = i; break; } if (i->count < min->count) min = i; else if (i->count == min->count && i->limit < min->limit) min = i; } if (match) { ++match->count; if (match->count >= m_message_rate_limit * 10) { if (now < match->limit) { if (match->count == m_message_rate_limit * 10) { #ifndef TORRENT_DISABLE_LOGGING if (logger != nullptr && logger->should_log(dht_logger::tracker)) { logger->log(dht_logger::tracker, "BANNING PEER [ ip: %s time: %d ms count: %d ]" , print_address(addr).c_str() , int(total_milliseconds((now - match->limit) + seconds(10))) , match->count); } #else TORRENT_UNUSED(logger); #endif // TORRENT_DISABLE_LOGGING // we've received too many messages in less than 10 seconds // from this node. Ignore it until it's silent for 5 minutes match->limit = now + seconds(m_block_timeout); } return false; } // the messages we received from this peer took more than 10 // seconds. Reset the counter and the timer match->count = 0; match->limit = now + seconds(10); } } else { min->count = 1; min->limit = now + seconds(10); min->src = addr; } return true; }
int main() { int Num = 5; printf("%p\n", &Num); print_address(Num); return 0; }
static void gdbscm_disasm_print_address (bfd_vma addr, struct disassemble_info *info) { struct gdbscm_disasm_data *data = (struct gdbscm_disasm_data *) info->application_data; struct gdbarch *gdbarch = data->gdbarch; print_address (gdbarch, addr, (struct ui_file *) info->stream); }
static void print_an_address (void) { struct address_s address; address.street = "1823 23rd Ave NE"; address.city = "Seattle"; address.region = "WA"; address.postal_code = "98023"; print_address (&address); }
static void print_simm_not_reg (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, void * dis_info, long value, unsigned int attrs ATTRIBUTE_UNUSED, bfd_vma pc ATTRIBUTE_UNUSED, int length ATTRIBUTE_UNUSED) { print_address (cd, dis_info, value, attrs, pc, length); }
void print_address(int nb, int sz) { if (sz == 0) return ; else { print_address(nb / 16, sz - 1); ft_puthexa(nb % 16); } }
static void test_wlan_address(int argc, char **argv) { struct wlan_network network; if (wlan_get_current_network(&network)) { wmprintf("not connected\r\n"); return; } print_address(&network.address); }
static void memory_report_invalid_addr(const void* addr) { ADDRESS64 address; address.Mode = AddrModeFlat; address.Segment = 0; address.Offset = (unsigned long)addr; dbg_printf("*** Invalid address "); print_address(&address, FALSE); dbg_printf("\n"); }
/** This is called by Gap to notify the application we connected */ virtual void onConnectionComplete(const ble::ConnectionCompleteEvent &event) { printf("Connected to peer: "); print_address(event.getPeerAddress().data()); printf("Peer random resolvable address: "); print_address(event.getPeerResolvablePrivateAddress().data()); _handle = event.getConnectionHandle(); if (_bonded) { /* disconnect in 2s */ _event_queue.call_in( 2000, &_ble.gap(), disconnect_call, _handle, ble::local_disconnection_reason_t(ble::local_disconnection_reason_t::USER_TERMINATION) ); } };
print_reg_property(device *me, const device_property *property) { int reg_nr; reg_property_spec reg; for (reg_nr = 0; device_find_reg_array_property(me, property->name, reg_nr, ®); reg_nr++) { print_address(device_parent(me), ®.address); print_size(me, ®.size); } }