void send_data_packets() { int i; struct sockaddr_in* from; int retsize, chunk_size; int * upload_id_list = get_upload_list(&retsize); int * upload_chunk_id_list = get_upload_chunk_list(&chunk_size); int peer_id; unsigned seq_number; int canSend; int timeout; for(i = 0; i < retsize; i++) { peer_id = upload_id_list[i]; canSend = 1; /* if timeout send timeout packet first */ if ((seq_number = get_timeout_seq(peer_id)) == 0) { /* if not timout, check window size */ if(get_queue_size(peer_id) < get_cwnd_size(peer_id)) { seq_number = get_tail_seq_number(peer_id); /* transmit */ timeout = 0; } else{ canSend = 0; } } else { /* retransmit */ printf("retransmit\n"); window_timeout(peer_id); seq_number -= 1; /* offset by 1 */ timeout = 1; } //printf("seq: %d, canSend: %d, queue: %d, cwnd: %d\n", seq_number, canSend, get_queue_size(peer_id), get_cwnd_size(peer_id)); /* send one packet one time to ensure fairness */ if(canSend && seq_number < MAX_PACKET_PER_CHUNK) { char data[MAX_PAYLOAD_SIZE]; struct packet* packet; if(seq_number==MAX_PACKET_PER_CHUNK-1){ int last_packet_size = BT_CHUNK_SIZE-MAX_PAYLOAD_SIZE*(MAX_PACKET_PER_CHUNK-1); read_file(master_data_file_name, data, last_packet_size, upload_chunk_id_list[i] * BT_CHUNK_SIZE + seq_number * MAX_PAYLOAD_SIZE); packet = make_packet(DATA, NULL, data, last_packet_size, seq_number + 1, 0, NULL, NULL, NULL); }else{ read_file(master_data_file_name, data, MAX_PAYLOAD_SIZE, upload_chunk_id_list[i] * BT_CHUNK_SIZE + seq_number * MAX_PAYLOAD_SIZE); packet = make_packet(DATA, NULL, data, MAX_PAYLOAD_SIZE, seq_number + 1, 0, NULL, NULL, NULL); } /* Send DATA */ from = find_addr(peer_id); send_packet(*packet, sock, (struct sockaddr*)from); wait_ack(peer_id, seq_number + 1, timeout); free(packet->header); free(packet); } } free(upload_id_list); free(upload_chunk_id_list); }
static int handle_forward_disassemble(RCore* core, RList *hits, ut8* buf, ut64 len, ut64 current_buf_pos, ut64 current_instr_addr, ut64 end_addr){ // forward disassemble from the current instruction up to the end address ut64 temp_instr_len = 0, temp_instr_addr = current_instr_addr, tmp_current_buf_pos = current_buf_pos, start = 0, end = 0, start_range = current_instr_addr, end_range = end_addr; RAsmOp op; RCoreAsmHit *hit = NULL, *found_addr = NULL; ut8 is_valid = R_FALSE; if (end_addr < current_instr_addr) return end_addr; r_asm_set_pc (core->assembler, current_instr_addr); while ( tmp_current_buf_pos < len && temp_instr_addr < end_addr) { temp_instr_len = len - tmp_current_buf_pos; IFDBG eprintf("Current position: %"PFMT64d" instr_addr: 0x%"PFMT64x"\n", tmp_current_buf_pos, temp_instr_addr); temp_instr_len = r_asm_disassemble (core->assembler, &op, buf+tmp_current_buf_pos, temp_instr_len); if (temp_instr_len == 0){ is_valid = R_FALSE; temp_instr_len = 1; } else is_valid = R_TRUE; // check to see if addr exits found_addr = find_addr(hits, temp_instr_addr); start = temp_instr_addr; end = temp_instr_addr + temp_instr_len; if (!found_addr) { add_hit_to_sorted_hits(hits, temp_instr_addr, temp_instr_len, is_valid); } else if (is_valid && !found_addr->valid && is_addr_in_range(start, end, start_range, end_range )) { ut32 prune_results = 0; prune_results = prune_hits_in_addr_range(hits, temp_instr_addr, temp_instr_len, is_valid); add_hit_to_sorted_hits(hits, temp_instr_addr, temp_instr_len, is_valid); if (prune_results ) { r_list_add_sorted (hits, hit, ((RListComparator)rcoreasm_address_comparator)); IFDBG eprintf("Pruned %u hits from list in fwd sweep.\n", prune_results); } else { free (hit); hit = NULL; } } temp_instr_addr += temp_instr_len; tmp_current_buf_pos += temp_instr_len; } return temp_instr_addr; }
static const char *find_local(MAPS *path, char *ratsign, int rats_offs, char *int_full_key, char *int_bare_key, int query_form, char **extp, char **saved_ext, VSTRING *ext_addr_buf) { const char *myname = "mail_addr_find"; const char *result; int with_domain; int saved_ch; /* * This code was ripped from the middle of a function so that it can be * reused multiple times, that's why the interface makes little sense. */ with_domain = rats_offs ? WITH_DOMAIN : SANS_DOMAIN; saved_ch = *(unsigned char *) (ratsign + rats_offs); *(ratsign + rats_offs) = 0; result = find_addr(path, int_full_key, PARTIAL, with_domain, query_form, ext_addr_buf); *(ratsign + rats_offs) = saved_ch; if (result == 0 && path->error == 0 && int_bare_key != 0) { if ((ratsign = strrchr(int_bare_key, '@')) == 0) msg_panic("%s: bare key botch", myname); saved_ch = *(unsigned char *) (ratsign + rats_offs); *(ratsign + rats_offs) = 0; if ((result = find_addr(path, int_bare_key, PARTIAL, with_domain, query_form, ext_addr_buf)) != 0 && extp != 0) { *extp = *saved_ext; *saved_ext = 0; } *(ratsign + rats_offs) = saved_ch; } return result; }
void Peers::add_p2p_group_client(QStandardItem * /*parent*/, QString params) { /* * dev=02:b5:64:63:30:63 iface=02:b5:64:63:30:63 dev_capab=0x0 * dev_type=1-0050f204-1 dev_name='Wireless Client' * config_methods=0x8c */ QStringList items = params.split(QRegExp(" (?=[^']*('[^']*'[^']*)*$)")); QString addr = ""; QString name = ""; int config_methods = 0; QString dev_type; for (int i = 0; i < items.size(); i++) { QString str = items.at(i); int pos = str.indexOf('=') + 1; if (str.startsWith("dev_name='")) name = str.section('\'', 1, -2); else if (str.startsWith("config_methods=")) config_methods = str.section('=', 1).toInt(0, 0); else if (str.startsWith("dev=")) addr = str.mid(pos); else if (str.startsWith("dev_type=") && dev_type.isEmpty()) dev_type = str.mid(pos); } QStandardItem *item = find_addr(addr); if (item) return; item = new QStandardItem(*default_icon, name); if (item) { /* TODO: indicate somehow the relationship to the group owner * (parent) */ item->setData(addr, peer_role_address); item->setData(config_methods, peer_role_config_methods); item->setData(PEER_TYPE_P2P_CLIENT, peer_role_type); if (!dev_type.isEmpty()) item->setData(dev_type, peer_role_pri_dev_type); item->setData(items.join(QString("\n")), peer_role_details); item->setToolTip(ItemType(PEER_TYPE_P2P_CLIENT)); model.appendRow(item); } }
/* * Create a new node in-memory object and look up the node's addresses. */ static struct node * new_node(const char *name) { struct node *node; node = malloc(sizeof(*node)); if (!node) fail(NULL); memset(node, 0, sizeof(*node)); node->name = strdup(name); if (!node->name) fail(NULL); node->weight = 1; node->addr = find_addr(name); node->nodeid = -1; node->outgoing_fd = -1; node->connecting_fd = -1; return node; }
static int check_callers(int * cannot) { /* * get base addresses of multiarray and python, check if * backtrace is in these libraries only calling dladdr if a new max address * is found. * When after the initial multiarray stack everything is inside python we * can elide as no C-API user could have messed up the reference counts. * Only check until the python frame evaluation function is found * approx 10us overhead for stack size of 10 * * TODO some calls go over scalarmath in umath but we cannot get the base * address of it from multiarraymodule as it is not linked against it */ static int init = 0; /* * measured DSO object memory start and end, if an address is located * inside these bounds it is part of that library so we don't need to call * dladdr on it (assuming linear memory) */ static void * pos_python_start; static void * pos_python_end; static void * pos_ma_start; static void * pos_ma_end; /* known address storage to save dladdr calls */ static void * py_addr[64]; static void * pyeval_addr[64]; static npy_intp n_py_addr = 0; static npy_intp n_pyeval = 0; void *buffer[NPY_MAX_STACKSIZE]; int i, nptrs; int ok = 0; /* cannot determine callers */ if (init == -1) { *cannot = 1; return 0; } nptrs = backtrace(buffer, NPY_MAX_STACKSIZE); if (nptrs == 0) { /* complete failure, disable elision */ init = -1; *cannot = 1; return 0; } /* setup DSO base addresses, ends updated later */ if (NPY_UNLIKELY(init == 0)) { Dl_info info; /* get python base address */ if (dladdr(&PyNumber_Or, &info)) { pos_python_start = info.dli_fbase; pos_python_end = info.dli_fbase; } else { init = -1; return 0; } /* get multiarray base address */ if (dladdr(&PyArray_SetNumericOps, &info)) { pos_ma_start = info.dli_fbase; pos_ma_end = info.dli_fbase; } else { init = -1; return 0; } init = 1; } /* loop over callstack addresses to check if they leave numpy or cpython */ for (i = 0; i < nptrs; i++) { Dl_info info; int in_python = 0; int in_multiarray = 0; #if NPY_ELIDE_DEBUG >= 2 dladdr(buffer[i], &info); printf("%s(%p) %s(%p)\n", info.dli_fname, info.dli_fbase, info.dli_sname, info.dli_saddr); #endif /* check stored DSO boundaries first */ if (buffer[i] >= pos_python_start && buffer[i] <= pos_python_end) { in_python = 1; } else if (buffer[i] >= pos_ma_start && buffer[i] <= pos_ma_end) { in_multiarray = 1; } /* update DSO boundaries via dladdr if necessary */ if (!in_python && !in_multiarray) { if (dladdr(buffer[i], &info) == 0) { init = -1; ok = 0; break; } /* update DSO end */ if (info.dli_fbase == pos_python_start) { pos_python_end = NPY_NUMBER_MAX(buffer[i], pos_python_end); in_python = 1; } else if (info.dli_fbase == pos_ma_start) { pos_ma_end = NPY_NUMBER_MAX(buffer[i], pos_ma_end); in_multiarray = 1; } } /* no longer in ok libraries and not reached PyEval -> no elide */ if (!in_python && !in_multiarray) { ok = 0; break; } /* in python check if the frame eval function was reached */ if (in_python) { /* if reached eval we are done */ if (find_addr(pyeval_addr, n_pyeval, buffer[i])) { ok = 1; break; } /* * check if its some other function, use pointer lookup table to * save expensive dladdr calls */ if (find_addr(py_addr, n_py_addr, buffer[i])) { continue; } /* new python address, check for PyEvalFrame */ if (dladdr(buffer[i], &info) == 0) { init = -1; ok = 0; break; } if (info.dli_sname && strcmp(info.dli_sname, PYFRAMEEVAL_FUNC) == 0) { if (n_pyeval < sizeof(pyeval_addr) / sizeof(pyeval_addr[0])) { /* store address to not have to dladdr it again */ pyeval_addr[n_pyeval++] = buffer[i]; } ok = 1; break; } else if (n_py_addr < sizeof(py_addr) / sizeof(py_addr[0])) { /* store other py function to not have to dladdr it again */ py_addr[n_py_addr++] = buffer[i]; } } } /* all stacks after numpy are from python, we can elide */ if (ok) { *cannot = 0; return 1; } else { #if NPY_ELIDE_DEBUG != 0 puts("cannot elide due to c-api usage"); #endif *cannot = 1; return 0; } }
static void bootp_reply(struct bootp_t *bp) { BOOTPClient *bc; struct mbuf *m; struct bootp_t *rbp; struct sockaddr_in saddr, daddr; struct in_addr dns_addr; int dhcp_msg_type, val; uint8_t *q; /* extract exact DHCP msg type */ dhcp_decode(bp->bp_vend, DHCP_OPT_LEN, &dhcp_msg_type); dprintf("bootp packet op=%d msgtype=%d\n", bp->bp_op, dhcp_msg_type); if (dhcp_msg_type == 0) dhcp_msg_type = DHCPREQUEST; /* Force reply for old BOOTP clients */ if (dhcp_msg_type != DHCPDISCOVER && dhcp_msg_type != DHCPREQUEST) return; /* XXX: this is a hack to get the client mac address */ memcpy(client_ethaddr, bp->bp_hwaddr, 6); if ((m = m_get()) == NULL) return; m->m_data += if_maxlinkhdr; rbp = (struct bootp_t *)m->m_data; m->m_data += sizeof(struct udpiphdr); memset(rbp, 0, sizeof(struct bootp_t)); if (dhcp_msg_type == DHCPDISCOVER) { new_addr: bc = get_new_addr(&daddr.sin_addr); if (!bc) { dprintf("no address left\n"); return; } memcpy(bc->macaddr, client_ethaddr, 6); } else { bc = find_addr(&daddr.sin_addr, bp->bp_hwaddr); if (!bc) { /* if never assigned, behaves as if it was already assigned (windows fix because it remembers its address) */ goto new_addr; } } if (bootp_filename) snprintf(rbp->bp_file, sizeof(rbp->bp_file), "%s", bootp_filename); dprintf("offered addr=%08x\n", ntohl(daddr.sin_addr.s_addr)); saddr.sin_addr.s_addr = htonl(ntohl(special_addr.s_addr) | CTL_ALIAS); saddr.sin_port = htons(BOOTP_SERVER); daddr.sin_port = htons(BOOTP_CLIENT); rbp->bp_op = BOOTP_REPLY; rbp->bp_xid = bp->bp_xid; rbp->bp_htype = 1; rbp->bp_hlen = 6; memcpy(rbp->bp_hwaddr, bp->bp_hwaddr, 6); rbp->bp_yiaddr = daddr.sin_addr; /* Client IP address */ rbp->bp_siaddr = saddr.sin_addr; /* Server IP address */ q = rbp->bp_vend; memcpy(q, rfc1533_cookie, 4); q += 4; if (dhcp_msg_type == DHCPDISCOVER) { *q++ = RFC2132_MSG_TYPE; *q++ = 1; *q++ = DHCPOFFER; } else if (dhcp_msg_type == DHCPREQUEST) { *q++ = RFC2132_MSG_TYPE; *q++ = 1; *q++ = DHCPACK; } if (dhcp_msg_type == DHCPDISCOVER || dhcp_msg_type == DHCPREQUEST) { *q++ = RFC2132_SRV_ID; *q++ = 4; memcpy(q, &saddr.sin_addr, 4); q += 4; *q++ = RFC1533_NETMASK; *q++ = 4; *q++ = 0xff; *q++ = 0xff; *q++ = 0xff; *q++ = 0x00; *q++ = RFC1533_GATEWAY; *q++ = 4; memcpy(q, &saddr.sin_addr, 4); q += 4; *q++ = RFC1533_DNS; *q++ = 4; dns_addr.s_addr = htonl(ntohl(special_addr.s_addr) | CTL_DNS); memcpy(q, &dns_addr, 4); q += 4; *q++ = RFC2132_LEASE_TIME; *q++ = 4; val = htonl(LEASE_TIME); memcpy(q, &val, 4); q += 4; if (*slirp_hostname) { val = strlen(slirp_hostname); *q++ = RFC1533_HOSTNAME; *q++ = val; memcpy(q, slirp_hostname, val); q += val; } } *q++ = RFC1533_END; m->m_len = sizeof(struct bootp_t) - sizeof(struct ip) - sizeof(struct udphdr); udp_output2(NULL, m, &saddr, &daddr, IPTOS_LOWDELAY); }
int launch_new_query(struct author *author/*, int idrowback*/) { int new_query = 0, i, start, end, ret; mbuf_type *mbuf; struct timeval tv; uint64_t msnow = 0; int slotoff, typeoff; start = author->start; end = author->end; gettimeofday(&tv, NULL); msnow = tv.tv_sec * 1000 + tv.tv_usec / 1000; for (i = start; i < end; i++) { slotoff = 0; typeoff = 0; mbuf = NULL; ret = htable_find_list_io(author->s->qlist, i, slotoff, &typeoff, (uchar **)&mbuf); while (ret >= 0) { if (ret > 0) { if (mbuf->qtimes > MAX_TRY_TIMES/* || (msnow - mbuf->stime) > 5000*/) { release_qoutinfo(author, mbuf, GET_AID(i, typeoff)); } else { if (mbuf->stat == NEW_QUERY) { assert(i < QLIST_TABLE_SIZE && typeoff < SUPPORT_TYPE_NUM); mbuf->aid = GET_AID(i, typeoff); //start id mbuf->backid = mbuf->aid; mbuf->mxtry = 0; if (mbuf->fd != -1) mbuf->fd = author->cudp; mbuf->tdbuffer = author->tdbuffer; mbuf->tempbuffer = author->tempbuffer; mbuf->dmbuffer = author->dmbuffer; mbuf->ipbuffer = author->ipbuffer; new_query++; mbuf->stat = PROCESS_QUERY; } if ((msnow - mbuf->stime) > 1000 && (mbuf->sq == 0)) { mbuf->sq = 1; } if ((mbuf->socktype == UDP) && (mbuf->sq == 1)) { ret = find_addr(author->s->forward, author->s->datasets, mbuf, author->ip, author->s->is_forward); if (mbuf->stat == PROCESS_QUERY && ret == 0) query_from_auth_server(mbuf, author); mbuf->qtimes++; // mbuf->stime = msnow; } } } if (ret == 0 || (typeoff == (SUPPORT_TYPE_NUM- 1))) { slotoff++; typeoff = 0; } else typeoff++; mbuf = NULL; ret = htable_find_list_io(author->s->qlist, i, slotoff, &typeoff, (uchar **)&mbuf); } } return new_query; }
static void bootp_reply(const struct bootp_t *bp) { BOOTPClient *bc = NULL; struct mbuf *m; struct bootp_t *rbp; SockAddress saddr, daddr; uint32_t dns_addr; const ipaddr_t *preq_addr; int dhcp_msg_type, val; uint8_t *q; /* extract exact DHCP msg type */ dhcp_decode(bp, &dhcp_msg_type, &preq_addr); dprintf("bootp packet op=%d msgtype=%d", bp->bp_op, dhcp_msg_type); if (preq_addr) { dprintf(" req_addr=%08x\n", ntohl(*(uint32_t*)preq_addr)); } else { dprintf("\n"); } if (dhcp_msg_type == 0) dhcp_msg_type = DHCPREQUEST; /* Force reply for old BOOTP clients */ if (dhcp_msg_type != DHCPDISCOVER && dhcp_msg_type != DHCPREQUEST) return; /* XXX: this is a hack to get the client mac address */ memcpy(client_ethaddr, bp->bp_hwaddr, 6); if ((m = m_get()) == NULL) return; m->m_data += IF_MAXLINKHDR; rbp = (struct bootp_t *)m->m_data; m->m_data += sizeof(struct udpiphdr); memset(rbp, 0, sizeof(struct bootp_t)); if (dhcp_msg_type == DHCPDISCOVER) { if (preq_addr) { bc = request_addr(preq_addr, client_ethaddr); if (bc) { sock_address_init_inet(&daddr, ip_geth(*preq_addr), BOOTP_CLIENT); } } if (!bc) { new_addr: bc = get_new_addr(&daddr, client_ethaddr); if (!bc) { dprintf("no address left\n"); return; } } memcpy(bc->macaddr, client_ethaddr, 6); } else if (preq_addr) { bc = request_addr(preq_addr, client_ethaddr); if (bc) { sock_address_init_inet(&daddr, ip_geth(*preq_addr), BOOTP_CLIENT); memcpy(bc->macaddr, client_ethaddr, 6); } else { sock_address_init_inet(&daddr, 0, BOOTP_CLIENT); } } else { bc = find_addr(&daddr, bp->bp_hwaddr); if (!bc) { /* if never assigned, behaves as if it was already assigned (windows fix because it remembers its address) */ goto new_addr; } } sock_address_init_inet( &saddr, special_addr_ip | CTL_ALIAS, BOOTP_SERVER ); rbp->bp_op = BOOTP_REPLY; rbp->bp_xid = bp->bp_xid; rbp->bp_htype = 1; rbp->bp_hlen = 6; memcpy(rbp->bp_hwaddr, bp->bp_hwaddr, 6); rbp->bp_yiaddr = htonl(sock_address_get_ip(&daddr)); /* Client IP address */ rbp->bp_siaddr = htonl(sock_address_get_ip(&saddr)); /* Server IP address */ q = rbp->bp_vend; memcpy(q, rfc1533_cookie, 4); q += 4; if (bc) { uint32_t saddr_ip = htonl(sock_address_get_ip(&saddr)); dprintf("%s addr=%08x\n", (dhcp_msg_type == DHCPDISCOVER) ? "offered" : "ack'ed", sock_address_get_ip(&daddr)); if (dhcp_msg_type == DHCPDISCOVER) { *q++ = RFC2132_MSG_TYPE; *q++ = 1; *q++ = DHCPOFFER; } else /* DHCPREQUEST */ { *q++ = RFC2132_MSG_TYPE; *q++ = 1; *q++ = DHCPACK; } if (bootp_filename) snprintf((char *)rbp->bp_file, sizeof(rbp->bp_file), "%s", bootp_filename); *q++ = RFC2132_SRV_ID; *q++ = 4; memcpy(q, &saddr_ip, 4); q += 4; *q++ = RFC1533_NETMASK; *q++ = 4; *q++ = 0xff; *q++ = 0xff; *q++ = 0xff; *q++ = 0x00; if (!slirp_restrict) { *q++ = RFC1533_GATEWAY; *q++ = 4; memcpy(q, &saddr_ip, 4); q += 4; *q++ = RFC1533_DNS; *q++ = 4; dns_addr = htonl(special_addr_ip | CTL_DNS); memcpy(q, &dns_addr, 4); q += 4; } *q++ = RFC2132_LEASE_TIME; *q++ = 4; val = htonl(LEASE_TIME); memcpy(q, &val, 4); q += 4; if (*slirp_hostname) { val = strlen(slirp_hostname); *q++ = RFC1533_HOSTNAME; *q++ = val; memcpy(q, slirp_hostname, val); q += val; } } else { static const char nak_msg[] = "requested address not available"; dprintf("nak'ed addr=%08x\n", ip_geth(*preq_addr)); *q++ = RFC2132_MSG_TYPE; *q++ = 1; *q++ = DHCPNAK; *q++ = RFC2132_MESSAGE; *q++ = sizeof(nak_msg) - 1; memcpy(q, nak_msg, sizeof(nak_msg) - 1); q += sizeof(nak_msg) - 1; } *q++ = RFC1533_END; sock_address_init_inet(&daddr, 0xffffffffu, BOOTP_CLIENT); m->m_len = sizeof(struct bootp_t) - sizeof(struct ip) - sizeof(struct udphdr); udp_output2_(NULL, m, &saddr, &daddr, IPTOS_LOWDELAY); }
static void bootp_reply(Slirp *slirp, const struct bootp_t *bp) { BOOTPClient *bc = NULL; struct mbuf *m; struct bootp_t *rbp; struct sockaddr_in saddr, daddr; const struct in_addr *preq_addr; int dhcp_msg_type, val; uint8_t *q; /* extract exact DHCP msg type */ dhcp_decode(bp, &dhcp_msg_type, &preq_addr); DPRINTF("bootp packet op=%d msgtype=%d", bp->bp_op, dhcp_msg_type); if (preq_addr) DPRINTF(" req_addr=%08x\n", ntohl(preq_addr->s_addr)); else DPRINTF("\n"); if (dhcp_msg_type == 0) dhcp_msg_type = DHCPREQUEST; /* Force reply for old BOOTP clients */ if (dhcp_msg_type != DHCPDISCOVER && dhcp_msg_type != DHCPREQUEST) return; /* XXX: this is a hack to get the client mac address */ memcpy(slirp->client_ethaddr, bp->bp_hwaddr, 6); m = m_get(slirp); if (!m) { return; } m->m_data += IF_MAXLINKHDR; rbp = (struct bootp_t *)m->m_data; m->m_data += sizeof(struct udpiphdr); memset(rbp, 0, sizeof(struct bootp_t)); if (dhcp_msg_type == DHCPDISCOVER) { if (preq_addr) { bc = request_addr(slirp, preq_addr, slirp->client_ethaddr); if (bc) { daddr.sin_addr = *preq_addr; } } if (!bc) { new_addr: bc = get_new_addr(slirp, &daddr.sin_addr, slirp->client_ethaddr); if (!bc) { DPRINTF("no address left\n"); return; } } memcpy(bc->macaddr, slirp->client_ethaddr, 6); } else if (preq_addr) { bc = request_addr(slirp, preq_addr, slirp->client_ethaddr); if (bc) { daddr.sin_addr = *preq_addr; memcpy(bc->macaddr, slirp->client_ethaddr, 6); } else { daddr.sin_addr.s_addr = 0; } } else { bc = find_addr(slirp, &daddr.sin_addr, bp->bp_hwaddr); if (!bc) { /* if never assigned, behaves as if it was already assigned (windows fix because it remembers its address) */ goto new_addr; } } saddr.sin_addr = slirp->vhost_addr; saddr.sin_port = htons(BOOTP_SERVER); daddr.sin_port = htons(BOOTP_CLIENT); rbp->bp_op = BOOTP_REPLY; rbp->bp_xid = bp->bp_xid; rbp->bp_htype = 1; rbp->bp_hlen = 6; memcpy(rbp->bp_hwaddr, bp->bp_hwaddr, 6); rbp->bp_yiaddr = daddr.sin_addr; /* Client IP address */ rbp->bp_siaddr = saddr.sin_addr; /* Server IP address */ q = rbp->bp_vend; memcpy(q, rfc1533_cookie, 4); q += 4; if (bc) { DPRINTF("%s addr=%08x\n", (dhcp_msg_type == DHCPDISCOVER) ? "offered" : "ack'ed", ntohl(daddr.sin_addr.s_addr)); if (dhcp_msg_type == DHCPDISCOVER) { *q++ = RFC2132_MSG_TYPE; *q++ = 1; *q++ = DHCPOFFER; } else /* DHCPREQUEST */ { *q++ = RFC2132_MSG_TYPE; *q++ = 1; *q++ = DHCPACK; } if (slirp->bootp_filename) snprintf((char *)rbp->bp_file, sizeof(rbp->bp_file), "%s", slirp->bootp_filename); *q++ = RFC2132_SRV_ID; *q++ = 4; memcpy(q, &saddr.sin_addr, 4); q += 4; *q++ = RFC1533_NETMASK; *q++ = 4; memcpy(q, &slirp->vnetwork_mask, 4); q += 4; if (!slirp->restricted) { *q++ = RFC1533_GATEWAY; *q++ = 4; memcpy(q, &saddr.sin_addr, 4); q += 4; *q++ = RFC1533_DNS; *q++ = 4; memcpy(q, &slirp->vnameserver_addr, 4); q += 4; } *q++ = RFC2132_LEASE_TIME; *q++ = 4; val = htonl(LEASE_TIME); memcpy(q, &val, 4); q += 4; if (*slirp->client_hostname) { val = strlen(slirp->client_hostname); *q++ = RFC1533_HOSTNAME; *q++ = val; memcpy(q, slirp->client_hostname, val); q += val; } } else { static const char nak_msg[] = "requested address not available"; DPRINTF("nak'ed addr=%08x\n", ntohl(preq_addr->s_addr)); *q++ = RFC2132_MSG_TYPE; *q++ = 1; *q++ = DHCPNAK; *q++ = RFC2132_MESSAGE; *q++ = sizeof(nak_msg) - 1; memcpy(q, nak_msg, sizeof(nak_msg) - 1); q += sizeof(nak_msg) - 1; } *q++ = RFC1533_END; daddr.sin_addr.s_addr = 0xffffffffu; m->m_len = sizeof(struct bootp_t) - sizeof(struct ip) - sizeof(struct udphdr); udp_output2(NULL, m, &saddr, &daddr, IPTOS_LOWDELAY); }
static void bootp_reply(struct bootp_t *bp) { BOOTPClient *bc; struct mbuf *m; struct bootp_t *rbp; struct sockaddr_in saddr, daddr; struct in_addr dns_addr; int reply_type = 0; int dhcp_msg_type, val; int no_address_assigned; uint8_t *q; /* extract exact DHCP msg type */ dhcp_decode(bp->bp_vend, DHCP_OPT_LEN, &dhcp_msg_type); dprintf("bootp packet op=%d msgtype=%d\n", bp->bp_op, dhcp_msg_type); if (dhcp_msg_type != DHCPDISCOVER && dhcp_msg_type != DHCPREQUEST) return; /* XXX: this is a hack to get the client mac address */ memcpy(client_ethaddr, bp->bp_hwaddr, 6); if ((m = m_get()) == NULL) return; m->m_data += if_maxlinkhdr; rbp = (struct bootp_t *)m->m_data; m->m_data += sizeof(struct udpiphdr); memset(rbp, 0, sizeof(struct bootp_t)); no_address_assigned = 0; if (dhcp_msg_type == DHCPDISCOVER) { bc = get_new_addr(&daddr.sin_addr); if (!bc) { dprintf("no address left\n"); return; } memcpy(bc->macaddr, client_ethaddr, 6); } else { bc = find_addr(&daddr.sin_addr, bp->bp_hwaddr); if (!bc) { dprintf("no address assigned\n"); dprintf("sending NAK\n"); no_address_assigned = 1; } } dprintf("offered addr=%08x\n", (unsigned int)ntohl(daddr.sin_addr.s_addr)); saddr.sin_addr.s_addr = htonl(ntohl(special_addr.s_addr) | CTL_ALIAS); saddr.sin_port = htons(BOOTP_SERVER); daddr.sin_port = htons(BOOTP_CLIENT); rbp->bp_op = BOOTP_REPLY; rbp->bp_xid = bp->bp_xid; rbp->bp_htype = 1; rbp->bp_hlen = 6; memcpy(rbp->bp_hwaddr, bp->bp_hwaddr, 6); rbp->bp_yiaddr = daddr.sin_addr; /* IP address */ q = rbp->bp_vend; memcpy(q, rfc1533_cookie, 4); q += 4; if (dhcp_msg_type == DHCPDISCOVER) { *q++ = RFC2132_MSG_TYPE; *q++ = 1; *q++ = reply_type = DHCPOFFER; } else if (dhcp_msg_type == DHCPREQUEST) { *q++ = RFC2132_MSG_TYPE; *q++ = 1; if (no_address_assigned) reply_type = DHCPNAK; else reply_type = DHCPACK; *q++ = reply_type; } if ((reply_type != DHCPNAK) && (dhcp_msg_type == DHCPDISCOVER || dhcp_msg_type == DHCPREQUEST)) { *q++ = RFC2132_SRV_ID; *q++ = 4; memcpy(q, &saddr.sin_addr, 4); q += 4; *q++ = RFC1533_NETMASK; *q++ = 4; *q++ = 0xff; *q++ = 0xff; *q++ = 0xff; *q++ = 0x00; *q++ = RFC1533_GATEWAY; *q++ = 4; memcpy(q, &saddr.sin_addr, 4); q += 4; *q++ = RFC1533_DNS; *q++ = 4; dns_addr.s_addr = htonl(ntohl(special_addr.s_addr) | CTL_DNS); memcpy(q, &dns_addr, 4); q += 4; *q++ = RFC2132_LEASE_TIME; *q++ = 4; val = htonl(LEASE_TIME); memcpy(q, &val, 4); q += 4; } *q++ = RFC1533_END; m->m_len = sizeof(struct bootp_t) - sizeof(struct ip) - sizeof(struct udphdr); udp_output2(NULL, m, &saddr, &daddr, IPTOS_LOWDELAY); }
/* Search missing addresses for targets. We make serialized queries so we don't need to keep more than one query reference (walk_query). */ void *_ruli_srv_answer_walk(ruli_srv_t *srv_qry) { ruli_list_t *srv_list = &srv_qry->answer_srv_list; int srv_list_size = ruli_list_size(srv_list); /* Have the user disabled walk query? */ if (srv_qry->srv_options & RULI_RES_OPT_SRV_NOWALK) return query_done(srv_qry, RULI_SRV_CODE_OK); /* * Scan SRV answer targets, considering address lists */ for (; srv_qry->under.walk_index < srv_list_size; ++srv_qry->under.walk_index) { ruli_srv_entry_t *entry = \ (ruli_srv_entry_t *) ruli_list_get(srv_list, srv_qry->under.walk_index); ruli_list_t *addr_list = &entry->addr_list; walk_t *walk_qry; /* If this target already has address(es), skip it */ if (find_addr(addr_list, srv_qry->srv_options)) continue; #ifdef RULI_SRV_DEBUG { char target_txt[RULI_LIMIT_DNAME_TEXT_BUFSZ]; int target_txt_len; int result; result = ruli_dname_decode(target_txt, RULI_LIMIT_DNAME_TEXT_BUFSZ, &target_txt_len, entry->target, entry->target_len); assert(!result); fprintf(stderr, "DEBUG: _ruli_srv_answer_walk(): " "missing target=%s walk_index=%d\n", target_txt, srv_qry->under.walk_index); } #endif /* * Allocate space for auxiliary walk query */ walk_qry = \ (walk_t *) ruli_malloc(sizeof(*walk_qry)); if (!walk_qry) return query_done(srv_qry, RULI_SRV_CODE_WALK_OTHER); walk_qry->srv_query = srv_qry; /* * Initialize walk query arguments */ walk_qry->walk_query.host_resolver = srv_qry->srv_resolver; walk_qry->walk_query.host_on_answer = on_walk_answer; walk_qry->walk_query.host_on_answer_arg = walk_qry; walk_qry->walk_query.host_domain = entry->target; walk_qry->walk_query.host_domain_len = entry->target_len; walk_qry->walk_query.host_options = srv_qry->srv_options; /* RFC 2782 states CNAME aren't valid SRV targets */ walk_qry->walk_query.host_max_cname_depth = (srv_qry->srv_options & RULI_RES_OPT_SRV_CNAME) ? RULI_LIMIT_CNAME_DEPTH : 0; /* * Submit walk query */ if (ruli_host_query_submit(&walk_qry->walk_query)) { ruli_free(walk_qry); return query_done(srv_qry, RULI_SRV_CODE_WALK_QUERY); } /* Wait answer */ return OOP_CONTINUE; } /* for */ /* * All targets scanned, we're done */ return query_done(srv_qry, RULI_SRV_CODE_OK); }
uint32_t eval(int p,int q) { expr_ok=true; int dominant=0; //printf("%d %d\n",p,q); if(p>q){ printf("This is a bad expression\n"); expr_ok=false; return 0; } else if(p==q){ if(tokens[p].type==NUMBER) return atoi(tokens[p].str); else if(tokens[p].type==HEX) { char *hexnum=tokens[p].str+2; uint32_t sum=0,temp=0; int i; for(i=0;hexnum[i]!='\0';i++) { if(hexnum[i]>='0' && hexnum[i]<='9') temp=hexnum[i]-'0'; else if(hexnum[i]>='a' && hexnum[i]<='f') temp=hexnum[i]-'a'+10; sum=sum*16+temp; } return sum; } /*************** VAR NOT DONE **********************/ else if(tokens[p].type==VAR) { uint32_t addr=0; addr=find_addr(tokens[p].str,&is_obj); if(!is_obj) printf("NO SUCH OBJECT!\n"); return addr; //printf("test %2x\n",addr); } /*************** VAR NOT DONE **********************/ else if(tokens[p].type==REG) { reg_right=true; if(strcmp(tokens[p].str,"$eax")==0) return cpu.eax; else if(strcmp(tokens[p].str,"$ecx")==0) return cpu.ecx; else if(strcmp(tokens[p].str,"$edx")==0) return cpu.edx; else if(strcmp(tokens[p].str,"$ebx")==0) return cpu.ebx; else if(strcmp(tokens[p].str,"$esp")==0) return cpu.esp; else if(strcmp(tokens[p].str,"$ebp")==0) return cpu.ebp; else if(strcmp(tokens[p].str,"$esi")==0) return cpu.esi; else if(strcmp(tokens[p].str,"$edi")==0) return cpu.edi; else if(strcmp(tokens[p].str,"$eip")==0) return cpu.eip; else { printf("NO SUCH REGISTER!\n"); expr_ok=false; reg_right=false; return 0; } } else if(tokens[p].type==SREG) { if(strcmp(tokens[p].str,"$ES")==0) return cpu.sreg[0].Sreg; else if(strcmp(tokens[p].str,"$CS")==0) return cpu.sreg[1].Sreg; else if(strcmp(tokens[p].str,"$SS")==0) return cpu.sreg[2].Sreg; else if(strcmp(tokens[p].str,"$DS")==0) return cpu.sreg[3].Sreg; else { printf("A Bad expression!\n"); expr_ok=false; return 0; } } else if(tokens[p].type==EFLAGS) { if(strcmp(tokens[p].str,"$OF")==0) return cpu.OF; else if(strcmp(tokens[p].str,"$SF")==0) return cpu.SF; else if(strcmp(tokens[p].str,"$ZF")==0) return cpu.ZF; else if(strcmp(tokens[p].str,"$AF")==0) return cpu.AF; else if(strcmp(tokens[p].str,"$PF")==0) return cpu.PF; else if(strcmp(tokens[p].str,"$CF")==0) return cpu.CF; } else { printf("A Bad expression!\n"); expr_ok=false; return 0; } } bool check=check_parentheses(p,q); if(!check) { printf("The parentheses not match!\n"); expr_ok=false; return 0; } else if(check) { bool legal; legal=check_legal(p,q); if(legal) return eval(p+1,q-1); else { dominant=find_domiop(p,q); if(tokens[dominant].type==LOGNOT) { int val3=eval(dominant+1,q); return !val3; } else if(tokens[dominant].type==DEREF) { int val4=eval(dominant+1,q); uint32_t value=swaddr_read(val4,4,3); return value; } else { int val1=eval(p,dominant-1); if(expr_ok==false) return 0; int val2=eval(dominant+1,q); if(expr_ok==false) return 0; switch(tokens[dominant].type) { case '+':return val1+val2; case '-':return val1-val2; case '*':return val1*val2; case '/':return val1/val2; case EQ:return val1==val2; case NEQ:return val1!=val2; case LOGAND:return val1&&val2; case LOGOR:return val1||val2; default: assert(0); } } } } return 0; }
const char *mail_addr_find_opt(MAPS *path, const char *address, char **extp, int in_form, int query_form, int out_form, int strategy) { const char *myname = "mail_addr_find"; VSTRING *ext_addr_buf = 0; VSTRING *int_addr_buf = 0; const char *int_addr; static VSTRING *int_result = 0; const char *result; char *ratsign = 0; char *int_full_key; char *int_bare_key; char *saved_ext; int rc = 0; /* * Optionally convert the address from external form. */ if (in_form == MA_FORM_EXTERNAL) { int_addr_buf = vstring_alloc(100); unquote_822_local(int_addr_buf, address); int_addr = STR(int_addr_buf); } else { int_addr = address; } if (query_form == MA_FORM_EXTERNAL_FIRST || query_form == MA_FORM_EXTERNAL) ext_addr_buf = vstring_alloc(100); /* * Initialize. */ int_full_key = mystrdup(int_addr); if (*var_rcpt_delim == 0 || (strategy & MA_FIND_NOEXT) == 0) { int_bare_key = saved_ext = 0; } else { /* XXX This could be done after user+foo@domain fails. */ int_bare_key = strip_addr_internal(int_full_key, &saved_ext, var_rcpt_delim); } /* * Try user+foo@domain and user@domain. */ if ((strategy & MA_FIND_FULL) != 0) { result = find_addr(path, int_full_key, FULL, WITH_DOMAIN, query_form, ext_addr_buf); } else { result = 0; path->error = 0; } if (result == 0 && path->error == 0 && int_bare_key != 0 && (result = find_addr(path, int_bare_key, PARTIAL, WITH_DOMAIN, query_form, ext_addr_buf)) != 0 && extp != 0) { *extp = saved_ext; saved_ext = 0; } /* * Try user+foo if the domain matches user+foo@$myorigin, * user+foo@$mydestination or user+foo@[${proxy,inet}_interfaces]. Then * try with +foo stripped off. */ if (result == 0 && path->error == 0 && (ratsign = strrchr(int_full_key, '@')) != 0 && (strategy & (MA_FIND_LOCALPART_IF_LOCAL | MA_FIND_LOCALPART_AT_IF_LOCAL)) != 0) { if (strcasecmp_utf8(ratsign + 1, var_myorigin) == 0 || (rc = resolve_local(ratsign + 1)) > 0) { if ((strategy & MA_FIND_LOCALPART_IF_LOCAL) != 0) result = find_local(path, ratsign, 0, int_full_key, int_bare_key, query_form, extp, &saved_ext, ext_addr_buf); if (result == 0 && path->error == 0 && (strategy & MA_FIND_LOCALPART_AT_IF_LOCAL) != 0) result = find_local(path, ratsign, 1, int_full_key, int_bare_key, query_form, extp, &saved_ext, ext_addr_buf); } else if (rc < 0) path->error = rc; } /* * Try @domain. */ if (result == 0 && path->error == 0 && ratsign != 0 && (strategy & MA_FIND_AT_DOMAIN) != 0) result = maps_find(path, ratsign, PARTIAL); /* * Try domain (optionally, subdomains). */ if (result == 0 && path->error == 0 && ratsign != 0 && (strategy & MA_FIND_DOMAIN) != 0) { const char *name; const char *next; if ((strategy & MA_FIND_PDMS) && (strategy & MA_FIND_PDDMDS)) msg_warn("mail_addr_find_opt: do not specify both " "MA_FIND_PDMS and MA_FIND_PDDMDS"); for (name = ratsign + 1; *name != 0; name = next) { if ((result = maps_find(path, name, PARTIAL)) != 0 || path->error != 0 || (strategy & (MA_FIND_PDMS | MA_FIND_PDDMDS)) == 0 || (next = strchr(name + 1, '.')) == 0) break; if ((strategy & MA_FIND_PDDMDS) == 0) next++; } } /* * Try localpart@ even if the domain is not local. */ if ((strategy & MA_FIND_LOCALPART_AT) != 0 \ &&result == 0 && path->error == 0) result = find_local(path, ratsign, 1, int_full_key, int_bare_key, query_form, extp, &saved_ext, ext_addr_buf); /* * Optionally convert the result to internal form. The lookup result is * supposed to be one external-form email address. */ if (result != 0 && out_form == MA_FORM_INTERNAL) { if (int_result == 0) int_result = vstring_alloc(100); unquote_822_local(int_result, result); result = STR(int_result); } /* * Clean up. */ if (msg_verbose) msg_info("%s: %s -> %s", myname, address, result ? result : path->error ? "(try again)" : "(not found)"); myfree(int_full_key); if (int_bare_key) myfree(int_bare_key); if (saved_ext) myfree(saved_ext); if (int_addr_buf) vstring_free(int_addr_buf); if (ext_addr_buf) vstring_free(ext_addr_buf); return (result); }
static void bootp_reply(Slirp *slirp, const struct bootp_t *bp) { BOOTPClient *bc = NULL; struct mbuf *m; struct bootp_t *rbp; struct sockaddr_in saddr, daddr; struct in_addr preq_addr; int dhcp_msg_type, val; uint8_t *q; uint8_t *end; uint8_t client_ethaddr[ETH_ALEN]; /* extract exact DHCP msg type */ dhcp_decode(bp, &dhcp_msg_type, &preq_addr); DPRINTF("bootp packet op=%d msgtype=%d", bp->bp_op, dhcp_msg_type); if (preq_addr.s_addr != htonl(0L)) DPRINTF(" req_addr=%08" PRIx32 "\n", ntohl(preq_addr.s_addr)); else { DPRINTF("\n"); } if (dhcp_msg_type == 0) dhcp_msg_type = DHCPREQUEST; /* Force reply for old BOOTP clients */ if (dhcp_msg_type != DHCPDISCOVER && dhcp_msg_type != DHCPREQUEST) return; /* Get client's hardware address from bootp request */ memcpy(client_ethaddr, bp->bp_hwaddr, ETH_ALEN); m = m_get(slirp); if (!m) { return; } m->m_data += IF_MAXLINKHDR; rbp = (struct bootp_t *)m->m_data; m->m_data += sizeof(struct udpiphdr); memset(rbp, 0, sizeof(struct bootp_t)); if (dhcp_msg_type == DHCPDISCOVER) { if (preq_addr.s_addr != htonl(0L)) { bc = request_addr(slirp, &preq_addr, client_ethaddr); if (bc) { daddr.sin_addr = preq_addr; } } if (!bc) { new_addr: bc = get_new_addr(slirp, &daddr.sin_addr, client_ethaddr); if (!bc) { DPRINTF("no address left\n"); return; } } memcpy(bc->macaddr, client_ethaddr, ETH_ALEN); } else if (preq_addr.s_addr != htonl(0L)) { bc = request_addr(slirp, &preq_addr, client_ethaddr); if (bc) { daddr.sin_addr = preq_addr; memcpy(bc->macaddr, client_ethaddr, ETH_ALEN); } else { /* DHCPNAKs should be sent to broadcast */ daddr.sin_addr.s_addr = 0xffffffff; } } else { bc = find_addr(slirp, &daddr.sin_addr, bp->bp_hwaddr); if (!bc) { /* if never assigned, behaves as if it was already assigned (windows fix because it remembers its address) */ goto new_addr; } } /* Update ARP table for this IP address */ arp_table_add(slirp, daddr.sin_addr.s_addr, client_ethaddr); saddr.sin_addr = slirp->vhost_addr; saddr.sin_port = htons(BOOTP_SERVER); daddr.sin_port = htons(BOOTP_CLIENT); rbp->bp_op = BOOTP_REPLY; rbp->bp_xid = bp->bp_xid; rbp->bp_htype = 1; rbp->bp_hlen = 6; memcpy(rbp->bp_hwaddr, bp->bp_hwaddr, ETH_ALEN); rbp->bp_yiaddr = daddr.sin_addr; /* Client IP address */ rbp->bp_siaddr = saddr.sin_addr; /* Server IP address */ q = rbp->bp_vend; end = (uint8_t *)&rbp[1]; memcpy(q, rfc1533_cookie, 4); q += 4; if (bc) { DPRINTF("%s addr=%08" PRIx32 "\n", (dhcp_msg_type == DHCPDISCOVER) ? "offered" : "ack'ed", ntohl(daddr.sin_addr.s_addr)); if (dhcp_msg_type == DHCPDISCOVER) { *q++ = RFC2132_MSG_TYPE; *q++ = 1; *q++ = DHCPOFFER; } else /* DHCPREQUEST */ { *q++ = RFC2132_MSG_TYPE; *q++ = 1; *q++ = DHCPACK; } if (slirp->bootp_filename) snprintf((char *)rbp->bp_file, sizeof(rbp->bp_file), "%s", slirp->bootp_filename); *q++ = RFC2132_SRV_ID; *q++ = 4; memcpy(q, &saddr.sin_addr, 4); q += 4; *q++ = RFC1533_NETMASK; *q++ = 4; memcpy(q, &slirp->vnetwork_mask, 4); q += 4; if (!slirp->restricted) { *q++ = RFC1533_GATEWAY; *q++ = 4; memcpy(q, &saddr.sin_addr, 4); q += 4; *q++ = RFC1533_DNS; *q++ = 4; memcpy(q, &slirp->vnameserver_addr, 4); q += 4; } *q++ = RFC2132_LEASE_TIME; *q++ = 4; val = htonl(LEASE_TIME); memcpy(q, &val, 4); q += 4; if (*slirp->client_hostname) { val = strlen(slirp->client_hostname); if (q + val + 2 >= end) { g_warning("DHCP packet size exceeded, " "omitting host name option."); } else { *q++ = RFC1533_HOSTNAME; *q++ = val; memcpy(q, slirp->client_hostname, val); q += val; } } if (slirp->vdomainname) { val = strlen(slirp->vdomainname); if (q + val + 2 >= end) { g_warning("DHCP packet size exceeded, " "omitting domain name option."); } else { *q++ = RFC1533_DOMAINNAME; *q++ = val; memcpy(q, slirp->vdomainname, val); q += val; } } if (slirp->tftp_server_name) { val = strlen(slirp->tftp_server_name); if (q + val + 2 >= end) { g_warning("DHCP packet size exceeded, " "omitting tftp-server-name option."); } else { *q++ = RFC2132_TFTP_SERVER_NAME; *q++ = val; memcpy(q, slirp->tftp_server_name, val); q += val; } } if (slirp->vdnssearch) { val = slirp->vdnssearch_len; if (q + val >= end) { g_warning("DHCP packet size exceeded, " "omitting domain-search option."); } else { memcpy(q, slirp->vdnssearch, val); q += val; } } } else { static const char nak_msg[] = "requested address not available"; DPRINTF("nak'ed addr=%08" PRIx32 "\n", ntohl(preq_addr.s_addr)); *q++ = RFC2132_MSG_TYPE; *q++ = 1; *q++ = DHCPNAK; *q++ = RFC2132_MESSAGE; *q++ = sizeof(nak_msg) - 1; memcpy(q, nak_msg, sizeof(nak_msg) - 1); q += sizeof(nak_msg) - 1; } assert(q < end); *q = RFC1533_END; daddr.sin_addr.s_addr = 0xffffffffu; m->m_len = sizeof(struct bootp_t) - sizeof(struct ip) - sizeof(struct udphdr); udp_output(NULL, m, &saddr, &daddr, IPTOS_LOWDELAY); }
static void bootp_reply(const struct bootp_t *bp) { BOOTPClient *bc = NULL; struct mbuf *m; struct bootp_t *rbp; struct sockaddr_in saddr, daddr; struct in_addr dns_addr; const struct in_addr *preq_addr; int dhcp_msg_type, val; uint8_t *q; dhcp_decode(bp, &dhcp_msg_type, &preq_addr); dprintf("bootp packet op=%d msgtype=%d", bp->bp_op, dhcp_msg_type); if (preq_addr) dprintf(" req_addr=%08x\n", ntohl(preq_addr->s_addr)); else dprintf("\n"); if (dhcp_msg_type == 0) dhcp_msg_type = DHCPREQUEST; if (dhcp_msg_type != DHCPDISCOVER && dhcp_msg_type != DHCPREQUEST) return; memcpy(client_ethaddr, bp->bp_hwaddr, 6); if ((m = m_get()) == NULL) return; m->m_data += IF_MAXLINKHDR; rbp = (struct bootp_t *)m->m_data; m->m_data += sizeof(struct udpiphdr); memset(rbp, 0, sizeof(struct bootp_t)); if (dhcp_msg_type == DHCPDISCOVER) { if (preq_addr) { bc = request_addr(preq_addr, client_ethaddr); if (bc) { daddr.sin_addr = *preq_addr; } } if (!bc) { new_addr: bc = get_new_addr(&daddr.sin_addr, client_ethaddr); if (!bc) { dprintf("no address left\n"); return; } } memcpy(bc->macaddr, client_ethaddr, 6); } else if (preq_addr) { bc = request_addr(preq_addr, client_ethaddr); if (bc) { daddr.sin_addr = *preq_addr; memcpy(bc->macaddr, client_ethaddr, 6); } else { daddr.sin_addr.s_addr = 0; } } else { bc = find_addr(&daddr.sin_addr, bp->bp_hwaddr); if (!bc) { goto new_addr; } } saddr.sin_addr.s_addr = htonl(ntohl(special_addr.s_addr) | CTL_ALIAS); saddr.sin_port = htons(BOOTP_SERVER); daddr.sin_port = htons(BOOTP_CLIENT); rbp->bp_op = BOOTP_REPLY; rbp->bp_xid = bp->bp_xid; rbp->bp_htype = 1; rbp->bp_hlen = 6; memcpy(rbp->bp_hwaddr, bp->bp_hwaddr, 6); rbp->bp_yiaddr = daddr.sin_addr; rbp->bp_siaddr = saddr.sin_addr; q = rbp->bp_vend; memcpy(q, rfc1533_cookie, 4); q += 4; if (bc) { dprintf("%s addr=%08x\n", (dhcp_msg_type == DHCPDISCOVER) ? "offered" : "ack'ed", ntohl(daddr.sin_addr.s_addr)); if (dhcp_msg_type == DHCPDISCOVER) { *q++ = RFC2132_MSG_TYPE; *q++ = 1; *q++ = DHCPOFFER; } else { *q++ = RFC2132_MSG_TYPE; *q++ = 1; *q++ = DHCPACK; } if (bootp_filename) snprintf((char *)rbp->bp_file, sizeof(rbp->bp_file), "%s", bootp_filename); *q++ = RFC2132_SRV_ID; *q++ = 4; memcpy(q, &saddr.sin_addr, 4); q += 4; *q++ = RFC1533_NETMASK; *q++ = 4; *q++ = 0xff; *q++ = 0xff; *q++ = 0xff; *q++ = 0x00; if (!slirp_restrict) { *q++ = RFC1533_GATEWAY; *q++ = 4; memcpy(q, &saddr.sin_addr, 4); q += 4; *q++ = RFC1533_DNS; *q++ = 4; dns_addr.s_addr = htonl(ntohl(special_addr.s_addr) | CTL_DNS); memcpy(q, &dns_addr, 4); q += 4; } *q++ = RFC2132_LEASE_TIME; *q++ = 4; val = htonl(LEASE_TIME); memcpy(q, &val, 4); q += 4; if (*slirp_hostname) { val = strlen(slirp_hostname); *q++ = RFC1533_HOSTNAME; *q++ = val; memcpy(q, slirp_hostname, val); q += val; } } else { static const char nak_msg[] = "requested address not available"; dprintf("nak'ed addr=%08x\n", ntohl(preq_addr->s_addr)); *q++ = RFC2132_MSG_TYPE; *q++ = 1; *q++ = DHCPNAK; *q++ = RFC2132_MESSAGE; *q++ = sizeof(nak_msg) - 1; memcpy(q, nak_msg, sizeof(nak_msg) - 1); q += sizeof(nak_msg) - 1; } *q++ = RFC1533_END; daddr.sin_addr.s_addr = 0xffffffffu; m->m_len = sizeof(struct bootp_t) - sizeof(struct ip) - sizeof(struct udphdr); udp_output2(NULL, m, &saddr, &daddr, IPTOS_LOWDELAY); }
void Peers::event_notify(WpaMsg msg) { QString text = msg.getMsg(); if (text.startsWith(WPS_EVENT_PIN_NEEDED)) { /* * WPS-PIN-NEEDED 5a02a5fa-9199-5e7c-bc46-e183d3cb32f7 * 02:2a:c4:18:5b:f3 * [Wireless Client|Company|cmodel|123|12345|1-0050F204-1] */ QStringList items = text.split(' '); QString uuid = items[1]; QString addr = items[2]; QString name = ""; QStandardItem *item = find_addr(addr); if (item) return; int pos = text.indexOf('['); if (pos >= 0) { int pos2 = text.lastIndexOf(']'); if (pos2 >= pos) { items = text.mid(pos + 1, pos2 - pos - 1). split('|'); name = items[0]; items.append(addr); } } item = new QStandardItem(*laptop_icon, name); if (item) { item->setData(addr, peer_role_address); item->setData(PEER_TYPE_WPS_PIN_NEEDED, peer_role_type); item->setToolTip(ItemType(PEER_TYPE_WPS_PIN_NEEDED)); item->setData(items.join("\n"), peer_role_details); item->setData(items[5], peer_role_pri_dev_type); model.appendRow(item); } return; } if (text.startsWith(AP_STA_CONNECTED)) { /* AP-STA-CONNECTED 02:2a:c4:18:5b:f3 */ QStringList items = text.split(' '); QString addr = items[1]; QStandardItem *item = find_addr(addr); if (item == NULL || item->data(peer_role_type).toInt() != PEER_TYPE_ASSOCIATED_STATION) add_single_station(addr.toAscii().constData()); return; } if (text.startsWith(AP_STA_DISCONNECTED)) { /* AP-STA-DISCONNECTED 02:2a:c4:18:5b:f3 */ QStringList items = text.split(' '); QString addr = items[1]; if (model.rowCount() == 0) return; QModelIndexList lst = model.match(model.index(0, 0), peer_role_address, addr, -1); for (int i = 0; i < lst.size(); i++) { QStandardItem *item = model.itemFromIndex(lst[i]); if (item && item->data(peer_role_type).toInt() == PEER_TYPE_ASSOCIATED_STATION) { model.removeRow(lst[i].row()); break; } } return; } if (text.startsWith(P2P_EVENT_DEVICE_FOUND)) { /* * P2P-DEVICE-FOUND 02:b5:64:63:30:63 * p2p_dev_addr=02:b5:64:63:30:63 pri_dev_type=1-0050f204-1 * name='Wireless Client' config_methods=0x84 dev_capab=0x21 * group_capab=0x0 */ QStringList items = text.split(QRegExp(" (?=[^']*('[^']*'[^']*)*$)")); QString addr = items[1]; QString name = ""; QString pri_dev_type; int config_methods = 0; for (int i = 0; i < items.size(); i++) { QString str = items.at(i); if (str.startsWith("name='")) name = str.section('\'', 1, -2); else if (str.startsWith("config_methods=")) config_methods = str.section('=', 1).toInt(0, 0); else if (str.startsWith("pri_dev_type=")) pri_dev_type = str.section('=', 1); } QStandardItem *item = find_addr(addr); if (item) { int type = item->data(peer_role_type).toInt(); if (type == PEER_TYPE_P2P) return; } item = new QStandardItem(*default_icon, name); if (item) { item->setData(addr, peer_role_address); item->setData(config_methods, peer_role_config_methods); item->setData(PEER_TYPE_P2P, peer_role_type); if (!pri_dev_type.isEmpty()) item->setData(pri_dev_type, peer_role_pri_dev_type); item->setData(items.join(QString("\n")), peer_role_details); item->setToolTip(ItemType(PEER_TYPE_P2P)); model.appendRow(item); } item = find_addr_type(addr, PEER_TYPE_P2P_PERSISTENT_GROUP_CLIENT); if (item) item->setBackground(Qt::NoBrush); } if (text.startsWith(P2P_EVENT_GROUP_STARTED)) { /* P2P-GROUP-STARTED wlan0-p2p-0 GO ssid="DIRECT-3F" * passphrase="YOyTkxID" go_dev_addr=02:40:61:c2:f3:b7 * [PERSISTENT] */ QStringList items = text.split(' '); if (items.size() < 4) return; int pos = text.indexOf(" ssid=\""); if (pos < 0) return; QString ssid = text.mid(pos + 7); pos = ssid.indexOf(" passphrase=\""); if (pos < 0) pos = ssid.indexOf(" psk="); if (pos >= 0) ssid.truncate(pos); pos = ssid.lastIndexOf('"'); if (pos >= 0) ssid.truncate(pos); QStandardItem *item = new QStandardItem(*group_icon, ssid); if (item) { item->setData(PEER_TYPE_P2P_GROUP, peer_role_type); item->setData(items[1], peer_role_ifname); QString details; if (items[2] == "GO") { details = tr("P2P GO for interface ") + items[1]; } else { details = tr("P2P client for interface ") + items[1]; } if (text.contains(" [PERSISTENT]")) details += "\nPersistent group"; item->setData(details, peer_role_details); item->setToolTip(ItemType(PEER_TYPE_P2P_GROUP)); model.appendRow(item); } } if (text.startsWith(P2P_EVENT_GROUP_REMOVED)) { /* P2P-GROUP-REMOVED wlan0-p2p-0 GO */ QStringList items = text.split(' '); if (items.size() < 2) return; if (model.rowCount() == 0) return; QModelIndexList lst = model.match(model.index(0, 0), peer_role_ifname, items[1]); for (int i = 0; i < lst.size(); i++) model.removeRow(lst[i].row()); return; } if (text.startsWith(P2P_EVENT_PROV_DISC_SHOW_PIN)) { /* P2P-PROV-DISC-SHOW-PIN 02:40:61:c2:f3:b7 12345670 */ QStringList items = text.split(' '); if (items.size() < 3) return; QString addr = items[1]; QString pin = items[2]; QStandardItem *item = find_addr_type(addr, PEER_TYPE_P2P); if (item == NULL) return; item->setData(SEL_METHOD_PIN_LOCAL_DISPLAY, peer_role_selected_method); item->setData(pin, peer_role_selected_pin); QVariant var = item->data(peer_role_requested_method); if (var.isValid() && var.toInt() == SEL_METHOD_PIN_LOCAL_DISPLAY) { ctx_item = item; ctx_p2p_display_pin_pd(); } return; } if (text.startsWith(P2P_EVENT_PROV_DISC_ENTER_PIN)) { /* P2P-PROV-DISC-ENTER-PIN 02:40:61:c2:f3:b7 */ QStringList items = text.split(' '); if (items.size() < 2) return; QString addr = items[1]; QStandardItem *item = find_addr_type(addr, PEER_TYPE_P2P); if (item == NULL) return; item->setData(SEL_METHOD_PIN_PEER_DISPLAY, peer_role_selected_method); QVariant var = item->data(peer_role_requested_method); if (var.isValid() && var.toInt() == SEL_METHOD_PIN_PEER_DISPLAY) { ctx_item = item; ctx_p2p_connect(); } return; } if (text.startsWith(P2P_EVENT_INVITATION_RECEIVED)) { /* P2P-INVITATION-RECEIVED sa=02:f0:bc:44:87:62 persistent=4 */ QStringList items = text.split(' '); if (items.size() < 3) return; if (!items[1].startsWith("sa=") || !items[2].startsWith("persistent=")) return; QString addr = items[1].mid(3); int id = items[2].mid(11).toInt(); char cmd[100]; char reply[100]; size_t reply_len; snprintf(cmd, sizeof(cmd), "GET_NETWORK %d ssid", id); reply_len = sizeof(reply) - 1; if (wpagui->ctrlRequest(cmd, reply, &reply_len) < 0) return; reply[reply_len] = '\0'; QString name; char *pos = strrchr(reply, '"'); if (pos && reply[0] == '"') { *pos = '\0'; name = reply + 1; } else name = reply; QStandardItem *item; item = find_addr_type(addr, PEER_TYPE_P2P_INVITATION); if (item) model.removeRow(item->row()); item = new QStandardItem(*invitation_icon, name); if (!item) return; item->setData(PEER_TYPE_P2P_INVITATION, peer_role_type); item->setToolTip(ItemType(PEER_TYPE_P2P_INVITATION)); item->setData(addr, peer_role_address); item->setData(id, peer_role_network_id); model.appendRow(item); enable_persistent(id); return; } if (text.startsWith(P2P_EVENT_INVITATION_RESULT)) { /* P2P-INVITATION-RESULT status=1 */ /* TODO */ return; } if (text.startsWith(WPS_EVENT_ER_AP_ADD)) { /* * WPS-ER-AP-ADD 87654321-9abc-def0-1234-56789abc0002 * 02:11:22:33:44:55 pri_dev_type=6-0050F204-1 wps_state=1 * |Very friendly name|Company|Long description of the model| * WAP|http://w1.fi/|http://w1.fi/hostapd/ */ QStringList items = text.split(' '); if (items.size() < 5) return; QString uuid = items[1]; QString addr = items[2]; QString pri_dev_type = items[3].mid(13); int wps_state = items[4].mid(10).toInt(); int pos = text.indexOf('|'); if (pos < 0) return; items = text.mid(pos + 1).split('|'); if (items.size() < 1) return; QStandardItem *item = find_uuid(uuid); if (item) return; item = new QStandardItem(*ap_icon, items[0]); if (item) { item->setData(uuid, peer_role_uuid); item->setData(addr, peer_role_address); int type = wps_state == 2 ? PEER_TYPE_WPS_ER_AP: PEER_TYPE_WPS_ER_AP_UNCONFIGURED; item->setData(type, peer_role_type); item->setToolTip(ItemType(type)); item->setData(pri_dev_type, peer_role_pri_dev_type); item->setData(items.join(QString("\n")), peer_role_details); model.appendRow(item); } return; } if (text.startsWith(WPS_EVENT_ER_AP_REMOVE)) { /* WPS-ER-AP-REMOVE 87654321-9abc-def0-1234-56789abc0002 */ QStringList items = text.split(' '); if (items.size() < 2) return; if (model.rowCount() == 0) return; QModelIndexList lst = model.match(model.index(0, 0), peer_role_uuid, items[1]); for (int i = 0; i < lst.size(); i++) { QStandardItem *item = model.itemFromIndex(lst[i]); if (item && (item->data(peer_role_type).toInt() == PEER_TYPE_WPS_ER_AP || item->data(peer_role_type).toInt() == PEER_TYPE_WPS_ER_AP_UNCONFIGURED)) model.removeRow(lst[i].row()); } return; } if (text.startsWith(WPS_EVENT_ER_ENROLLEE_ADD)) { /* * WPS-ER-ENROLLEE-ADD 2b7093f1-d6fb-5108-adbb-bea66bb87333 * 02:66:a0:ee:17:27 M1=1 config_methods=0x14d dev_passwd_id=0 * pri_dev_type=1-0050F204-1 * |Wireless Client|Company|cmodel|123|12345| */ QStringList items = text.split(' '); if (items.size() < 3) return; QString uuid = items[1]; QString addr = items[2]; QString pri_dev_type = items[6].mid(13); int config_methods = -1; int dev_passwd_id = -1; for (int i = 3; i < items.size(); i++) { int pos = items[i].indexOf('=') + 1; if (pos < 1) continue; QString val = items[i].mid(pos); if (items[i].startsWith("config_methods=")) { config_methods = val.toInt(0, 0); } else if (items[i].startsWith("dev_passwd_id=")) { dev_passwd_id = val.toInt(); } } int pos = text.indexOf('|'); if (pos < 0) return; items = text.mid(pos + 1).split('|'); if (items.size() < 1) return; QString name = items[0]; if (name.length() == 0) name = addr; remove_enrollee_uuid(uuid); QStandardItem *item; item = new QStandardItem(*laptop_icon, name); if (item) { item->setData(uuid, peer_role_uuid); item->setData(addr, peer_role_address); item->setData(PEER_TYPE_WPS_ER_ENROLLEE, peer_role_type); item->setToolTip(ItemType(PEER_TYPE_WPS_ER_ENROLLEE)); item->setData(items.join(QString("\n")), peer_role_details); item->setData(pri_dev_type, peer_role_pri_dev_type); if (config_methods >= 0) item->setData(config_methods, peer_role_config_methods); if (dev_passwd_id >= 0) item->setData(dev_passwd_id, peer_role_dev_passwd_id); model.appendRow(item); } return; } if (text.startsWith(WPS_EVENT_ER_ENROLLEE_REMOVE)) { /* * WPS-ER-ENROLLEE-REMOVE 2b7093f1-d6fb-5108-adbb-bea66bb87333 * 02:66:a0:ee:17:27 */ QStringList items = text.split(' '); if (items.size() < 2) return; remove_enrollee_uuid(items[1]); return; } if (text.startsWith(WPS_EVENT_ENROLLEE_SEEN)) { /* TODO: need to time out this somehow or remove on successful * WPS run, etc. */ /* * WPS-ENROLLEE-SEEN 02:00:00:00:01:00 * 572cf82f-c957-5653-9b16-b5cfb298abf1 1-0050F204-1 0x80 4 1 * [Wireless Client] * (MAC addr, UUID-E, pri dev type, config methods, * dev passwd id, request type, [dev name]) */ QStringList items = text.split(' '); if (items.size() < 7) return; QString addr = items[1]; QString uuid = items[2]; QString pri_dev_type = items[3]; int config_methods = items[4].toInt(0, 0); int dev_passwd_id = items[5].toInt(); QString name; QStandardItem *item = find_addr(addr); if (item) { int type = item->data(peer_role_type).toInt(); if (type == PEER_TYPE_ASSOCIATED_STATION) return; /* already associated */ } int pos = text.indexOf('['); if (pos >= 0) { int pos2 = text.lastIndexOf(']'); if (pos2 >= pos) { QStringList items2 = text.mid(pos + 1, pos2 - pos - 1). split('|'); name = items2[0]; } } if (name.isEmpty()) name = addr; item = find_uuid(uuid); if (item) { QVariant var = item->data(peer_role_config_methods); QVariant var2 = item->data(peer_role_dev_passwd_id); if ((var.isValid() && config_methods != var.toInt()) || (var2.isValid() && dev_passwd_id != var2.toInt())) remove_enrollee_uuid(uuid); else return; } item = new QStandardItem(*laptop_icon, name); if (item) { item->setData(uuid, peer_role_uuid); item->setData(addr, peer_role_address); item->setData(PEER_TYPE_WPS_ENROLLEE, peer_role_type); item->setToolTip(ItemType(PEER_TYPE_WPS_ENROLLEE)); item->setData(items.join(QString("\n")), peer_role_details); item->setData(pri_dev_type, peer_role_pri_dev_type); item->setData(config_methods, peer_role_config_methods); item->setData(dev_passwd_id, peer_role_dev_passwd_id); model.appendRow(item); } return; } if (text.startsWith(WPA_EVENT_BSS_ADDED)) { /* CTRL-EVENT-BSS-ADDED 34 00:11:22:33:44:55 */ QStringList items = text.split(' '); if (items.size() < 2) return; char cmd[20]; snprintf(cmd, sizeof(cmd), "BSS ID-%d", items[1].toInt()); add_bss(cmd); return; } if (text.startsWith(WPA_EVENT_BSS_REMOVED)) { /* CTRL-EVENT-BSS-REMOVED 34 00:11:22:33:44:55 */ QStringList items = text.split(' '); if (items.size() < 2) return; remove_bss(items[1].toInt()); return; } }
static RList *r_core_asm_back_disassemble (RCore *core, ut64 addr, int len, ut64 max_hit_count, ut8 disassmble_each_addr, ut32 extra_padding) { RList *hits;; RCoreAsmHit *found_addr = NULL; RAsmOp op; ut8 *buf = NULL; ut8 max_invalid_b4_exit = 4, last_num_invalid = 0; int current_instr_len = 0; ut64 current_instr_addr = addr, current_buf_pos = 0, next_buf_pos = len; RCoreAsmHit dummy_value; ut32 hit_count = 0; if (disassmble_each_addr){ return r_core_asm_back_disassemble_all(core, addr, len, max_hit_count, extra_padding+1); } hits = r_core_asm_hit_list_new (); buf = malloc (len + extra_padding); if (hits == NULL || buf == NULL ){ if (hits) r_list_destroy (hits); if (buf) free (buf); return NULL; } if (r_io_read_at (core->io, (addr + extra_padding)-len, buf, len+extra_padding) != len+extra_padding) { r_list_destroy (hits); free (buf); return NULL; } // // XXX - This is a heavy handed approach without a // an appropriate btree or hash table for storing // hits, because are using: // 1) Sorted RList with many inserts and searches // 2) Pruning hits to find the most optimal disassembly // greedy approach // 1) Consume previous bytes // 1a) Instruction is invalid (incr current_instr_addr) // 1b) Disasm is perfect // 1c) Disasm is underlap (disasm(current_instr_addr, next_instr_addr - current_instr_addr) short some bytes) // 1d) Disasm is overlap (disasm(current_instr_addr, next_instr_addr - current_instr_addr) over some bytes) memset (&dummy_value, 0, sizeof (RCoreAsmHit)); // disassemble instructions previous to current address, extra_padding can move the location of addr // so we need to account for that with current_buf_pos current_buf_pos = len - extra_padding - 1; next_buf_pos = len + extra_padding - 1; current_instr_addr = addr-1; do { if (r_cons_singleton ()->breaked) break; // reset assembler r_asm_set_pc (core->assembler, current_instr_addr); current_instr_len = next_buf_pos - current_buf_pos; current_instr_len = r_asm_disassemble (core->assembler, &op, buf+current_buf_pos, current_instr_len); found_addr = find_addr(hits, current_instr_addr); IFDBG { ut32 byte_cnt = current_instr_len ? current_instr_len : 1; eprintf("current_instr_addr: 0x%"PFMT64x", current_buf_pos: 0x%"PFMT64x", current_instr_len: %d \n", current_instr_addr, current_buf_pos, current_instr_len); ut8 *hex_str = (ut8*)r_hex_bin2strdup(buf+current_buf_pos, byte_cnt); eprintf("==== current_instr_bytes: %s ",hex_str); if (current_instr_len > 0) eprintf("op.buf_asm: %s\n", op.buf_asm); else eprintf("op.buf_asm: <invalid>\n"); if (hex_str) free(hex_str); } // disassembly invalid if (current_instr_len == 0 || strstr (op.buf_asm, "invalid")) { if (current_instr_len == 0) current_instr_len = 1; add_hit_to_sorted_hits(hits, current_instr_addr, current_instr_len, /* is_valid */ R_FALSE); hit_count ++; last_num_invalid ++; // disassembly perfect } else if (current_buf_pos + current_instr_len == next_buf_pos) { // i think this may be the only case where an invalid instruction will be // added because handle_forward_disassemble and handle_disassembly_overlap // are only called in cases where a valid instruction has been found. // and they are lazy, since they purge the hit list ut32 purge_results = 0; ut8 is_valid = R_TRUE; IFDBG eprintf(" handling underlap case: current_instr_addr: 0x%"PFMT64x".\n", current_instr_addr); purge_results = prune_hits_in_addr_range(hits, current_instr_addr, current_instr_len, /* is_valid */ R_TRUE); if (purge_results) { handle_forward_disassemble(core, hits, buf, len, current_buf_pos+current_instr_len, current_instr_addr+current_instr_len, addr); hit_count = r_list_length(hits); } add_hit_to_sorted_hits(hits, current_instr_addr, current_instr_len, is_valid); //handle_forward_disassemble(core, hits, buf, len, current_buf_pos+current_instr_len, current_instr_addr+current_instr_len, addr/*end_addr*/); hit_count ++; next_buf_pos = current_buf_pos; last_num_invalid = 0; // disassembly underlap } else if (current_buf_pos + current_instr_len < next_buf_pos) { ut32 purge_results = 0; ut8 is_valid = R_TRUE; purge_results = prune_hits_in_addr_range(hits, current_instr_addr, current_instr_len, /* is_valid */ R_TRUE); add_hit_to_sorted_hits(hits, current_instr_addr, current_instr_len, is_valid); if (hit_count < purge_results ) hit_count = 0; // WTF?? else hit_count -= purge_results; next_buf_pos = current_buf_pos; handle_forward_disassemble(core, hits, buf, len - extra_padding, current_buf_pos+current_instr_len, current_instr_addr+current_instr_len, addr); hit_count = r_list_length(hits); last_num_invalid = 0; // disassembly overlap } else if (current_buf_pos + current_instr_len > next_buf_pos) { //ut64 value = handle_disassembly_overlap(core, hits, buf, len, current_buf_pos, current_instr_addr); next_buf_pos = current_buf_pos; hit_count = r_list_length (hits); last_num_invalid = 0; } // walk backwards by one instruction IFDBG eprintf(" current_instr_addr: 0x%"PFMT64x" current_instr_len: %d next_instr_addr: 0x%04llx \n", current_instr_addr, current_instr_len, next_buf_pos); IFDBG eprintf(" hit count: %d \n", hit_count ); current_instr_addr -= 1; current_buf_pos -= 1; if ( hit_count >= max_hit_count && (last_num_invalid >= max_invalid_b4_exit || last_num_invalid == 0)) break; } while ( ((int) current_buf_pos >= 0) && (int)(len - current_buf_pos) >= 0 ); r_asm_set_pc (core->assembler, addr); if (buf) free (buf); return hits; }