static uint8_t * _dns_question(DNS_Query *query, uint8_t *buf) { uint8_t *buf_ptr = buf; DNS_PTR_Method *hooks = NULL; if(config.config.osc.mode == OSC_MODE_UDP) hooks = hooks_udp; else hooks = hooks_tcp; char *qname; buf_ptr = _unroll_qname(query, buf_ptr, &qname); DNS_Question *question =(DNS_Question *)buf_ptr; question->QTYPE = hton(question->QTYPE); question->QCLASS = hton(question->QCLASS); buf_ptr += sizeof(DNS_Question); // TODO answer as unicast //uint_fast8_t unicast = question->QCLASS & MDNS_CLASS_UNICAST; if( (question->QCLASS & 0x7fff) == MDNS_CLASS_INET) // check question class { // for IP mDNS lookup if( (question->QTYPE == MDNS_TYPE_A) || (question->QTYPE == MDNS_TYPE_AAAA) || (question->QTYPE == MDNS_TYPE_ANY) ) { // reply with current IP when there is a request for our name if(!strncmp(hook_self, qname, len_self)) { uint8_t *head = BUF_O_OFFSET(buf_o_ptr); uint8_t *tail = head; tail = _serialize_query(tail, query->ID, MDNS_FLAGS_QR | MDNS_FLAGS_AA, 0, 1, 0, 0); //FIXME append negative response for IPv6 via NSEC record tail = _serialize_answer(tail, hook_self, MDNS_TYPE_A, MDNS_CLASS_FLUSH | MDNS_CLASS_INET, MDNS_TTL_75MIN, 4); memcpy(tail, config.comm.ip, 4); tail += 4; udp_send(config.mdns.socket.sock, BUF_O_BASE(buf_o_ptr), tail-head); } } // for mDNS reverse-lookup and for mDNS-SD(service discovery) if( (question->QTYPE == MDNS_TYPE_PTR) || (question->QTYPE == MDNS_TYPE_ANY) ) { DNS_PTR_Method *hook; for(hook=hooks; hook->name; hook++) if(!strcmp(hook->name, qname)) // is there a hook with this qname registered? hook->cb(query); } } return buf_ptr; }
bool mld_interface::send_mld_query(const in6_addr &addr, const std::set<in6_addr> &sources) { if (!sources.empty() && mif_mld_version >= 2) { mldv2_query *query = g_mrd->opktb->header<mldv2_query>(); query->construct_query(addr, conf()); query->nsrcs = hton((uint16_t)sources.size()); in6_addr *addr = g_mrd->opktb->header<in6_addr>(sizeof(mldv2_query)); for (std::set<in6_addr>::const_iterator i = sources.begin(); i != sources.end(); ++i) { *addr = *i; addr++; } if (mld->send_icmp(owner(), in6addr_linkscope_allnodes, (icmp6_hdr *)query, query->length())) { m_stats.counter(QueryCount, TX)++; mld->stats().counter(QueryCount, TX)++; return true; } else { /*m_stats.counter(FailedSendQueryCount)++; mld->stats().counter(FailedSendQueryCount)++;*/ return false; } } return true; }
int main(int argc, char *argv[]) { int rslt = 0; char x = 0x12; fprintf(stdout, "net endian? %s\n", is_net_endian() ? "yes" : "no"); fprintf(stdout, "0x%08x : ", x); hton(&x, sizeof(x)); fprintf(stdout, "0x%08x\n", x); fprintf(stdout, "sizeof eth_head_st: %d\n", sizeof(eth_head_st)); fprintf(stdout, "sizeof arp_frame_st: %d\n", sizeof(arp_frame_st)); fprintf(stdout, "sizeof arp_packet_st: %d\n", sizeof(arp_packet_st)); do { byte_t smac[MAC_ADDR_LEN] = { //0x4E, 0x55, 0xBB, 0x27, 0x00, 0x08, 0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, }; byte_t sip[IP_ADDR_LEN] = { //0x65, 0x38, 0xA8, 0xC0, 0x01, 0x38, 0xA8, 0xC0, }; byte_t dmac[MAC_ADDR_LEN] = { //0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x4E, 0x55, 0xBB, 0x27, 0x00, 0x08, }; byte_t dip[IP_ADDR_LEN] = { 0x65, 0x38, 0xA8, 0xC0, }; send_arp(dmac, dip, smac, sip); } while (0); return rslt; }
bool CC1101::begin(const void* config) { // Reset the device m_cs.pulse(30); DELAY(30); strobe(SRES); DELAY(300); // Upload the configuration. Check for default configuration spi.begin(this); loop_until_bit_is_clear(PIN, Board::MISO); write_P(IOCFG2, config ? (const uint8_t*) config : CC1101::config, CONFIG_MAX); spi.end(); // Adjust configuration with instance specific state uint16_t sync = hton(m_addr.network); spi.begin(this); loop_until_bit_is_clear(PIN, Board::MISO); write(PATABLE, 0x60); write(CHANNR, m_channel); write(ADDR, m_addr.device); write(SYNC1, &sync, sizeof(sync)); spi.end(); // Initiate device driver state and enable interrupt handler m_avail = false; spi.attach(this); m_irq.enable(); return (true); }
void serialize(OutputArchive& ar, boost::units::quantity<U, T> q) { static_assert(std::is_integral<T>::value, "Only integral based quantities are supported"); auto tmp = hton(q.value()); ar << tmp; }
void csismp_construct( unsigned char *buffer, unsigned char source_addr[6], unsigned char dest_addr[6], int c_type, int start, int end, int slice, int session, const char* s_tlvs, int len) { struct packet *csismp = (void *)buffer; int i; memcpy(csismp->smac, source_addr, 6); memcpy(csismp->dmac, dest_addr, 6); csismp->pro_type = 0x1122; csismp->c_type = c_type; csismp->start = start; csismp->end = end; csismp->slice = slice; csismp->session = session; strncpy(csismp->tlvs, s_tlvs, len); hton((char *)csismp, 22 + len); }
bool RFM69::begin(const void* config) { // Wait for the transceiver to become ready do write(SYNC_VALUE1, 0xaa); while (read(SYNC_VALUE1) != 0xaa); do write(SYNC_VALUE1, 0x55); while (read(SYNC_VALUE1) != 0x55); // Upload the configuration. Check for default configuration const uint8_t* cp = RFM69::config; Reg reg; if (config != NULL) cp = (const uint8_t*) config; while ((reg = (Reg) pgm_read_byte(cp++)) != 0) write(reg, pgm_read_byte(cp++)); // Adjust configuration with instance specific state uint16_t sync = hton(m_addr.network); write(SYNC_VALUE1, &sync, sizeof(sync)); write(NODE_ADDR, m_addr.device); // Set standby mode and calibrate RC oscillator recalibrate(); // Initiate device driver state and enable interrupt handler m_avail = false; m_done = true; spi.attach(this); m_irq.enable(); return (true); }
void mldv2_query::construct(const in6_addr &addr, int type, mld_intfconf_node *n) { mldv1::construct(addr, type, n); qrv = n->robustness(); suppress = 0; resv2 = 0; uint32_t qis = n->query_interval() / 1000; if (qis < 128) qqic = qis; else { int exp = 0; while ((qis >> (exp+3)) > 0x1f) exp++; qis >>= exp+3; qis -= 0x10; qqic = 0x80 | (exp << 4) | qis; } nsrcs = hton((uint16_t)0); }
static inline void compress(I begin,I end,O out) { unsigned int bufLen = LZ4_compressBound(ZT_COMPRESSION_BLOCK_SIZE); char *buf = new char[bufLen * 2]; char *buf2 = buf + bufLen; try { I inp(begin); for(;;) { unsigned int readLen = 0; while ((readLen < ZT_COMPRESSION_BLOCK_SIZE)&&(inp != end)) { buf[readLen++] = (char)*inp; ++inp; } if (!readLen) break; uint32_t l = hton((uint32_t)readLen); out((const void *)&l,4); // original size if (readLen < 32) { // don't bother compressing itty bitty blocks l = 0; // stored out((const void *)&l,4); out((const void *)buf,readLen); continue; } int lz4CompressedLen = LZ4_compressHC(buf,buf2,(int)readLen); if ((lz4CompressedLen <= 0)||(lz4CompressedLen >= (int)readLen)) { l = 0; // stored out((const void *)&l,4); out((const void *)buf,readLen); continue; } l = hton((uint32_t)lz4CompressedLen); // lz4 only out((const void *)&l,4); out((const void *)buf2,(unsigned int)lz4CompressedLen); } delete [] buf; } catch ( ... ) { delete [] buf; throw; } }
prefixed_send_buffer(data_type&& data) : data_(std::move(data)) , prefix_(hton(static_cast<prefix_type>(data_.size()))) { BOOST_ASSERT_MSG(std::numeric_limits<prefix_type>::max() >= data_.size(), "prefixed_send_buffer: Try to send data which size is too large " "(choose a larger prefix type)."); }
static uint8_t * _dns_answer(DNS_Query *query, uint8_t *buf) { uint8_t *buf_ptr = buf; char *qname; buf_ptr = _unroll_qname(query, buf_ptr, &qname); DNS_Answer *answer =(DNS_Answer *)buf_ptr; answer->RTYPE = hton(answer->RTYPE); answer->RCLASS = hton(answer->RCLASS); answer->TTL = htonl(answer->TTL); answer->RLEN = hton(answer->RLEN); buf_ptr += sizeof(DNS_Answer); switch(answer->RTYPE) { case MDNS_TYPE_A: // ignore when qname was not requested by us previously if(!resolve.cb || strcmp(qname, resolve.name)) break; //TODO handle conflicts when probing uint8_t *ip = (uint8_t *)buf_ptr; if(ip_part_of_subnet(ip)) // check IP for same subnet TODO make this configurable { timer_pause(mdns_timer); // stop timeout timer resolve.cb(ip, resolve.data); // reset request resolve.name[0] = '\0'; resolve.cb = NULL; resolve.data = NULL; } break; default: // ignore remaining answer types, e.g MDNS_TYPE_PTR, MDNS_TYPE_SRV, MDNS_TYPE_TXT break; } buf_ptr += answer->RLEN; // skip rdata return buf_ptr; }
static uint8_t * _serialize_answer(uint8_t *buf, char *qname, uint16_t rtype, uint16_t rclass, uint32_t ttl, uint16_t rlen) { uint16_t *len = NULL; uint8_t *buf_ptr = _serialize_answer_inline(buf, qname, rtype, rclass, ttl, &len); *len = hton(rlen); return buf_ptr; }
static uint8_t * _serialize_question(uint8_t *buf, char *qname, uint16_t qtype, uint16_t qclass) { uint8_t *buf_ptr = buf; uint16_t len = strlen(qname) + 1; memcpy(buf_ptr, qname, len); buf_ptr += len; DNS_Question quest; quest.QTYPE = hton(qtype); quest.QCLASS = hton(qclass); memcpy(buf_ptr, &quest, sizeof(DNS_Question)); buf_ptr += sizeof(DNS_Question); return buf_ptr; }
void mldv1::construct(const in6_addr &addr, int _type, mld_intfconf_node *n) { type = _type; code = 0; checksum = 0; /* General Query * max_response_delay = [Query Response Interval] * Multicast-Address-Specific Query * max_response_delay = [Last Listener Query Interval] */ if (IN6_IS_ADDR_UNSPECIFIED(&addr)) maxdelay = hton((uint16_t)n->query_response_interval()); else maxdelay = hton((uint16_t)n->last_listener_query_interval()); data = hton((uint16_t)0); mcaddr = addr; }
static uint8_t * _serialize_answer_inline(uint8_t *buf, char *qname, uint16_t rtype, uint16_t rclass, uint32_t ttl, uint16_t **rlen) { uint8_t *buf_ptr = buf; uint16_t len = strlen(qname) + 1; memcpy(buf_ptr, qname, len); buf_ptr += len; DNS_Answer a; a.RTYPE = hton(rtype); a.RCLASS = hton(rclass); a.TTL = htonl(ttl); a.RLEN = 0; *rlen = (uint16_t *)(buf_ptr + offsetof(DNS_Answer, RLEN)); memcpy(buf_ptr, &a, sizeof(DNS_Answer)); buf_ptr += sizeof(DNS_Answer); return buf_ptr; }
/* * Creates a streaming socket and connects to a server. * * serverName - the ip address or hostname of the server given as a string * port - the port number of the server * dest - the server's address information; the structure should be created with information * on the server (like port, address, and family) in this function call * * return value - the socket identifier or a negative number indicating the error if a connection could not be established */ int createSocket(char * serverName, int port, struct sockaddr_in * dest) { int socketCreation = 0; memset(dest, 0, sizeof(dest)); dest.sin_family = AF_INET; inet_pton(AF_INET, serverName, dest.sin_addr); //Sever IP address dest.sin_port = hton(port); socketCreation = socket(PF_INET, SOCK_STREAM, 0); if(connect(s, (struct sockaddr *)dest, sizeof(dest))< 0) { socketCreation = -1; } return socketCreation; }
int LocalSocketStream::send(const Head & head, const void * buf, unsigned int size) { if (fd < 0) return -1; if (!buf) return -1; if (size == 0) return -1; Head clone_head(head); uint8_t buf_head[sizeof(head)]; hton(clone_head); serialize(buf_head, clone_head); int rc = ::write(fd, buf_head, sizeof(buf_head)); if (rc < 0) return -1; rc = ::write(fd, buf, size); if (rc < 0) return -1; return rc; }
bool SendFile( SOCKET sock, const char* strFileName, int nBufSize ) { //get file header NETF_STAT nfstat; if( GetNetfStat(strFileName, &nfstat)!=0 )return false; //send file header hton( nfstat ); SendNetfStat( sock, &nfstat ); //send the file content stream. FILE* pf = fopen( strFileName, "rb" ); if( pf==NULL )return false; bool bOk = SendFileStream( sock, pf, nBufSize ); fclose( pf ); return bOk; }
int htoi(char s[]) { int len, i, n; len = strlen(s); n = 0; if (len < 3) return -1; if (s[0] != '0') return -1; if (s[1] != 'x' && s[1] != 'X') return -1; for (i = 2; i < len; ++i) { if ((s[i] >= '0' && s[i] <= '9') || (s[i] >='a' && s[i] <= 'z') || (s[i] >= 'A' && s[i]<= 'Z')) { n = 16 * n + hton(s[i]); } else { return -1; } } return n; }
void mdns_dispatch(uint8_t *buf, uint16_t len) { (void)len; // update qname labels corresponding to self len_self = _update_hook_self(config.name); len_instance = _update_hook_instance(config.name); len_arpa = _update_hook_arpa(config.comm.ip); uint8_t *buf_ptr = buf; DNS_Query *query =(DNS_Query *)buf_ptr; // convert from network byteorder query->ID = hton(query->ID); query->FLAGS = hton(query->FLAGS); query->QDCOUNT = hton(query->QDCOUNT); query->ANCOUNT = hton(query->ANCOUNT); query->NSCOUNT = hton(query->NSCOUNT); query->ARCOUNT = hton(query->ARCOUNT); uint8_t qr =(query->FLAGS & MDNS_FLAGS_QR) >> MDNS_FLAGS_QR_BIT; //uint8_t opcode =(query->FLAGS & MDNS_FLAGS_OPCODE) >> MDNS_FLAGS_OPCODE_SHIFT; //uint8_t aa =(query->FLAGS & MDNS_FLAGS_AA) >> MDNS_FLAGS_AA_BIT; //uint8_t tc =(query->FLAGS & MDNS_FLAGS_TC) >> MDNS_FLAGS_TC_BIT; //uint8_t rd =(query->FLAGS & MDNS_FLAGS_RD) >> MDNS_FLAGS_RD_BIT; //uint8_t ra =(query->FLAGS & MDNS_FLAGS_RA) >> MDNS_FLAGS_RA_BIT; //uint8_t z =(query->FLAGS & MDNS_FLAGS_Z) >> MDNS_FLAGS_Z_SHIFT; //uint8_t rcode =(query->FLAGS & MDNS_FLAGS_RCODE) >> MDNS_FLAGS_RCODE_SHIFT; buf_ptr += sizeof(DNS_Query); uint_fast8_t i; switch(qr) { case 0x0: // mDNS Query Question for(i=0; i<query->QDCOUNT; i++) // walk all questions buf_ptr = _dns_question(query, buf_ptr); // ignore answers break; case 0x1: // mDNS Query Answer for(i=0; i<query->QDCOUNT; i++) // skip all questions buf_ptr += strlen((char *)buf_ptr) + 1 + sizeof(DNS_Question); for(i=0; i<query->ANCOUNT; i++) // walk all answers buf_ptr = _dns_answer(query, buf_ptr); break; } }
int ICMP::ping_request(uint8_t dest[4]) { // Check given socket if (m_sock == NULL) return (ENOTSOCK); // Build echo request block header_t req; req.type = ECHO; req.code = 0; req.checksum = 0; req.echo.id = m_id; req.echo.seq = ++m_seq; req.timestamp = RTC::millis(); req.checksum = hton(INET::checksum(&req, sizeof(req))); // And send to destination network address int res = m_sock->send(&req, sizeof(req), dest, 0); if (res < 0) return (res); return (res == sizeof(req) ? 0 : -1); }
std::vector<u8> AmfVector<T, typename VectorProperties<T>::type>::serialize(SerializationContext& ctx) const { int index = ctx.getIndex(*this); if (index != -1) return std::vector<u8> { VectorProperties<T>::marker, u8(index << 1) }; ctx.addObject(*this); // U29V value std::vector<u8> buf = AmfInteger::asLength(values.size(), VectorProperties<T>::marker); // fixed-vector marker buf.push_back(fixed ? 0x01 : 0x00); for (const T& it : values) { // values are encoded in network byte order // ints are encoded as U32, not U29 T netvalue = hton(it); const u8* bytes = reinterpret_cast<const u8*>(&netvalue); buf.insert(buf.end(), bytes, bytes + VectorProperties<T>::size); } return buf; }
static uint8_t * _serialize_TXT_instance(uint8_t *buf, uint16_t rclass, uint32_t ttl) { uint8_t *buf_ptr = buf; uint16_t *len = NULL; DNS_PTR_Method *hooks = NULL; if(config.config.osc.mode == OSC_MODE_UDP) hooks = hooks_udp; else hooks = hooks_tcp; buf_ptr = _serialize_answer_inline(buf_ptr, hooks[HOOK_INSTANCE].name, MDNS_TYPE_TXT, rclass, ttl, &len); uint8_t *txt = buf_ptr; buf_ptr = _serialize_TXT_record(buf_ptr, TXT_TXTVERSION); buf_ptr = _serialize_TXT_record(buf_ptr, TXT_VERSION); buf_ptr = _serialize_TXT_record(buf_ptr, TXT_URI); buf_ptr = _serialize_TXT_record(buf_ptr, TXT_TYPES); if(config.config.osc.mode == OSC_MODE_SLIP) buf_ptr = _serialize_TXT_record(buf_ptr, TXT_FRAMING); buf_ptr = _serialize_TXT_record(buf_ptr, TXT_RESET[reset_mode]); if(config.dhcpc.enabled || config.ipv4ll.enabled) { if(config.dhcpc.enabled) buf_ptr = _serialize_TXT_record(buf_ptr, TXT_DHCP); if(config.ipv4ll.enabled) buf_ptr = _serialize_TXT_record(buf_ptr, TXT_IPV4LL); } else buf_ptr = _serialize_TXT_record(buf_ptr, TXT_STATIC); //TODO send UID? *len = hton(buf_ptr - txt); return buf_ptr; }
static uint8_t * _serialize_query(uint8_t *buf, uint16_t id, uint16_t flags, uint16_t qdcount, uint16_t ancount, uint16_t nscount, uint16_t arcount) { uint8_t *buf_ptr = buf; DNS_Query q; q.ID = hton(id); q.FLAGS = hton(flags); q.QDCOUNT = hton(qdcount); // number of questions q.ANCOUNT = hton(ancount); // number of answers q.NSCOUNT = hton(nscount); // number of authoritative records q.ARCOUNT = hton(arcount); // number of resource records memcpy(buf_ptr, &q, sizeof(DNS_Query)); buf_ptr += sizeof(DNS_Query); return buf_ptr; }
char * tftp_get(IPAddr server, char * file, void(*receiver)(Octet *, Uint32)) { UDP *sendBuf = (UDP *)enet_alloc(); UDPPort local = udp_allocPort(NULL); sendBuf->ip.dest = hton(server); sendBuf->udp.dest = htons(tftpPort); sendBuf->udp.srce = htons(local); TFTPHeader * sendHeader = (TFTPHeader *)&(sendBuf->data[0]); sendHeader->op = htons(tftpOpRRQ); Uint32 pos = tftpPosName; appendStr(sendBuf, &pos, file); appendStr(sendBuf, &pos, "octet"); Uint32 blockNum; for (blockNum = 1; ; blockNum++) { Uint32 recvLen; IP * recvBuf; TFTPHeader * recvHeader; Octet * recvData; Uint32 dataLen; int tries; for (tries = 0; ; tries++) { if (tries >= retryLimit) { udp_freePort(local); enet_free((Enet *)sendBuf); return "Timeout"; } udp_send(sendBuf, pos); recvLen = udp_recv(&recvBuf, local, timeout); if (recvBuf) { recvHeader = (TFTPHeader *)udp_payload(recvBuf); recvData = udp_payload(recvBuf) + tftpPosData; dataLen = recvLen - tftpPosData; if (ntohs(recvHeader->op) == tftpOpData) { if (ntohs(recvHeader->block) == blockNum) break; } else if (ntohs(recvHeader->op) == tftpOpError) { recvData[dataLen-1] = 0; // in case server omitted it udp_freePort(local); enet_free((Enet *)sendBuf); int slen = strlen((char *)recvData); char *s = malloc(slen+1); strncpy(s, (char *)recvData, slen+1); udp_recvDone(recvBuf); return s; } else { udp_freePort(local); enet_free((Enet *)sendBuf); udp_recvDone(recvBuf); return "Unknown opcode from server"; } // ignore other stuff - excess retransmissions udp_recvDone(recvBuf); } } // The only way to get here is by receiving the expected data block receiver(recvData, dataLen); UDPHeader *recvUDPHeader = (UDPHeader *)ip_payload(recvBuf); sendBuf->udp.dest = recvUDPHeader->srce; sendHeader->op = htons(tftpOpAck); sendHeader->block = recvHeader->block; pos = tftpPosData; udp_recvDone(recvBuf); if (dataLen < 512) break; } udp_send(sendBuf, pos); // final ACK, sent without retransmissions udp_freePort(local); enet_free((Enet *)sendBuf); return NULL; }
void hton(int16_t val, uint8_t* bytes) { hton((uint16_t)val, bytes); }
bool Babuino::withInt32() { STACKPTR location, index; int32_t rhs, lhs; switch (_regs.opCode) { case OP_ASHIFT: case OP_LSHIFT: { int8_t shift; popUint8(_stack, (uint8_t*)&shift); popUint32(_stack, (uint32_t*)&lhs); if (shift >= 0) pushUint32(_stack, (uint32_t)(lhs << shift)); else pushUint32(_stack, (uint32_t)(lhs >> -shift)); return true; } case OP_SET: //Serial.println("---set---"); popStackPtr(_stack, &location); popUint32(_stack, (uint32_t*)&rhs); setUint32(_stack, location, (uint32_t)rhs); return true; case OP_GET: //Serial.println("---get---"); popStackPtr(_stack, &location); getUint32(_stack, location, (uint32_t*)&rhs); pushUint32(_stack, (uint32_t)rhs); return true; case OP_ASET: //Serial.println("---aset---"); popStackPtr(_stack, &location); popStackPtr(_stack, &index); popUint32(_stack, (uint32_t*)&rhs); setUint32(_stack, location + index * sizeof(int32_t), (uint32_t)rhs); return true; case OP_AGET: //Serial.println("---aget---"); popStackPtr(_stack, &location); popStackPtr(_stack, &index); getUint32(_stack, location + index * sizeof(int32_t), (uint32_t*)&rhs); pushUint32(_stack, (uint32_t)rhs); return true; case OP_OUTPUT: { //Serial.print("output "); popUint32(_stack, (uint32_t*)&rhs); // The return value // point to where the arguments size is on the stack. location = getArgsLocation(); uint8_t argsSize; getUint8(_stack, location - sizeof(uint8_t), &argsSize); // Get size of args. // If the size > 0 then step over the size location too. // Otherwise keep pointing to the same place because the return // value should overwrite where the arguments size would be. if (argsSize > 0) argsSize += sizeof(uint8_t); setUint32(_stack, location - (STACKPTR)argsSize - sizeof(int32_t), (uint32_t)rhs); } return true; case OP_SEND: { //Serial.println("---send---"); popUint32(_stack, (uint32_t*)&rhs); uint8_t buf[sizeof(int32_t)]; hton(rhs, buf); //_defaultStream->write(nbuf, sizeof(int32_t)); // Replaced for debugging _defaultStream->print(rhs); } return true; case OP_SENDN: { //Serial.println("---sendn---"); uint8_t items; uint8_t port; STACKPTR bufLoc; popUint8(_stack, &items); popUint8(_stack, &port); popStackPtr(_stack, &bufLoc); int32_t* buf = (int32_t*)getStackAddress(_stack, bufLoc); uint8_t nbuf[sizeof(int32_t)]; for (int i = 0; i < items; i++) { rhs = *buf; hton(rhs, nbuf); //_defaultStream->write(nbuf, sizeof(int32_t)); // Replaced for debugging _defaultStream->print(rhs); buf++; } } return true; #ifdef SUPPORT_STRING case OP_TOSTR: { //Serial.println("---tostr---"); popUint32(_stack, (uint32_t*)&rhs); // ***KLUDGE WARNING*** // Borrowing unused (hopefully) stack space as a buffer! // just to avoid having to allocate another buffer. char* psz = (char *)getTopAddress(_stack); itoa((int) rhs, psz, 10); // Logically this is wrong because I'm apparently // pushing a string to a location that it already // occupies. However, the stack implementation // pushes strings onto a separate stack, then // pushes the location onto the main stack. So // the string doesn't get copied over itself, and // is already copied before the first characters are // overwritten by pushing the said location onto the // main stack. pushString(_stack, (uint8_t*)psz); } return true; #endif case OP_FOREACH: { //Serial.print("foreach "); PROGPTR blockAddr; popProgPtr(_stack, &blockAddr); // Block address popStackPtr(_stack, &location); // Iterator variable location (Variable contains a 'pointer') uint8_t itemsRemaining; popUint8(_stack, &itemsRemaining); // Number of items remaining // If we've gone through the block then we need to pop the // previous list item off the stack if (hasBlockExecuted()) { uint32_t tmpUint32; popUint32(_stack, &tmpUint32); } if (itemsRemaining > 0) // Any items remaining { // Set the value of the variable to the location on the // stack of the next list item (ie the top) setStackPtr(_stack, location, getTop(_stack) - sizeof(int32_t)); _regs.pc = blockAddr; // Point to the top of the block for the next iteration itemsRemaining--; // Decrement the number of items remaining pushUint8(_stack, itemsRemaining); // Save number of items remaining for next time pushStackPtr(_stack, location); // Save iterator variable location for next time pushProgPtr(_stack, blockAddr); // Save block address for next time } else { ascendBlock(); // Leaving. Pop the block. } } return true; } popUint32(_stack, (uint32_t*)&rhs); switch (_regs.opCode) { case OP_BITNOT: pushUint32(_stack, (uint32_t)~rhs); return true; case OP_ABS: pushUint32(_stack, (uint32_t)abs(rhs)); return true; case OP_NEG: pushUint32(_stack, (uint32_t)-rhs); return true; } popUint32(_stack, (uint32_t*)&lhs); switch (_regs.opCode) { case OP_ADD: pushUint32(_stack, (uint32_t)(lhs + rhs)); return true; case OP_SUB: pushUint32(_stack, (uint32_t)(lhs - rhs)); return true; case OP_MUL: pushUint32(_stack, (uint32_t)(lhs * rhs)); return true; case OP_DIV: pushUint32(_stack, (uint32_t)(lhs / rhs)); return true; case OP_MOD: pushUint32(_stack, (uint32_t)(lhs % rhs)); return true; case OP_EQ: pushUint8(_stack, (uint8_t)(lhs == rhs)); return true; case OP_GT: pushUint8(_stack, (uint8_t)(lhs > rhs)); return true; case OP_LT: pushUint8(_stack, (uint8_t)(lhs < rhs)); return true; case OP_LE: pushUint8(_stack, (uint8_t)(lhs <= rhs)); return true; case OP_GE: pushUint8(_stack, (uint8_t)(lhs >= rhs)); return true; case OP_NE: pushUint8(_stack, (uint8_t)(lhs != rhs)); return true; case OP_BITAND: pushUint32(_stack, (uint32_t)(lhs & rhs)); return true; case OP_BITOR: pushUint32(_stack, (uint32_t)(lhs | rhs)); return true; case OP_BITXOR: pushUint32(_stack, (uint32_t)(lhs ^ rhs)); return true; case OP_MIN: pushUint32(_stack, (uint32_t)min(lhs, rhs)); return true; case OP_MAX: pushUint32(_stack, (uint32_t)max(lhs, rhs)); return true; } return false; }
operator network_type() const { return network_cast(hton(BASE::get())); }
static void serialize_value(lua_State *L, int pos, luaL_Buffer* frame, int* indice, uint16_t* key) { if (!lua_checkstack(L, 2)) { luaL_error(L, "cannot serialize: stack won't grow"); } uint8_t type = get_luatobin_type(L, pos); switch (type) { case BIN_NIL: { //printf("(nil[1])"); lua_pushlstring(L, (char *) &type, 1); write_object(L, indice); break; } case BIN_BOOLEAN: { //printf("(boolean[2])"); int boolean = lua_toboolean(L, pos); luaL_buffinit(L, frame); luaL_addchar(frame, type); luaL_addchar(frame, boolean & 0xFF); luaL_pushresult(frame); write_object(L, indice); break; } case BIN_DOUBLE: { double number = lua_tonumber(L, pos); luaL_buffinit(L, frame); luaL_addchar(frame, type); //printf("(number[%d])", sizeof(number)); if (sendian.double_) hton(&number, sizeof(number), sendian.double_); luaL_addlstring(frame, (char*) &number, sizeof(number)); luaL_pushresult(frame); write_object(L, indice); break; } case BIN_INTEGER: { int32_t number = lua_tointeger(L, pos); luaL_buffinit(L, frame); luaL_addchar(frame, type); //printf("(number[%d])", sizeof(number)); if (sendian.int32_) hton(&number, sizeof(number), sendian.int32_); luaL_addlstring(frame, (char*) &number, sizeof(number)); luaL_pushresult(frame); write_object(L, indice); break; } case BIN_STRING: { uint16_t cached = verify_cache(L, pos, key); if (cached != 0) { //printf("(stringref[%d])", cached); luaL_buffinit(L, frame); luaL_addchar(frame, BIN_REF); if (sendian.int16_) hton(&cached, sizeof(cached), sendian.int16_); luaL_addlstring(frame, (char*) &cached, sizeof(cached)); luaL_pushresult(frame); write_object(L, indice); break; } size_t s; const char* string = lua_tolstring(L, pos, &s); if (s >= 0xFFFF) luaL_error(L, "cannot serialize: string length > 65k"); uint16_t size = (uint16_t) s; luaL_buffinit(L, frame); luaL_addchar(frame, type); uint16_t nsize = size; if (sendian.int16_) hton(&nsize, sizeof(nsize), sendian.int16_); luaL_addlstring(frame, (char*) &nsize, sizeof(nsize)); //printf("(string[%d][%d])", *key, size); luaL_addlstring(frame, string, size); luaL_pushresult(frame); write_object(L, indice); break; } case BIN_FUNCTION: { uint16_t cached = verify_cache(L, pos, key); if (cached != 0) { //printf("(functionref[%d])", cached); luaL_buffinit(L, frame); luaL_addchar(frame, BIN_REF); if (sendian.int16_) hton(&cached, sizeof(cached), sendian.int16_); luaL_addlstring(frame, (char*) &cached, sizeof(cached)); luaL_pushresult(frame); write_object(L, indice); break; } serialize_function(L, frame, pos); size_t s; const char* string = lua_tolstring(L, -1, &s); if (s >= 0xFFFF) luaL_error(L, "cannot serialize: function length > 65k"); uint16_t size = (uint16_t) s; luaL_buffinit(L, frame); luaL_addchar(frame, type); uint16_t nsize = size; if (sendian.int16_) hton(&nsize, sizeof(nsize), sendian.int16_); luaL_addlstring(frame, (char*) &nsize, sizeof(nsize)); //printf("(function[%d][%d])", *key, size); luaL_addlstring(frame, string, size); luaL_pushresult(frame); write_object(L, indice); lua_pop(L, 1); // remove the serialized function break; } case BIN_TABLE: { uint16_t cached = verify_cache(L, pos, key); if (cached != 0) { //printf("(tableref[%d])", cached); luaL_buffinit(L, frame); luaL_addchar(frame, BIN_REF); if (sendian.int16_) hton(&cached, sizeof(cached), sendian.int16_); luaL_addlstring(frame, (char*) &cached, sizeof(cached)); luaL_pushresult(frame); write_object(L, indice); break; } // reserved for table header (as size cannot be calculated beforehand) *indice = *indice + 1; int header = *indice; //printf("{table="); int top; size_t s = 0; lua_pushnil(L); while (lua_next(L, pos) != 0) { top = lua_gettop(L); serialize_value(L, top - 1, frame, indice, key); serialize_value(L, top, frame, indice, key); lua_pop(L, 1); s++; } if (s >= 0xFFFF) luaL_error(L, "cannot serialize: table length > 65k"); uint16_t size = (uint16_t) s; luaL_buffinit(L, frame); luaL_addchar(frame, type); uint16_t nsize = size; if (sendian.int16_) hton(&nsize, sizeof(nsize), sendian.int16_); luaL_addlstring(frame, (char*) &nsize, sizeof(nsize)); luaL_pushresult(frame); // set table header lua_rawseti(L, 3, header); //printf("[%d]}", size); break; } default: luaL_error(L, "cannot serialize: unsupported type (%d)", lua_type(L, pos)); } }
// send_arp // 功能:发送arp包 int send_arp(byte_t dmac[], byte_t dip[], byte_t smac[], byte_t sip[]) { static byte_t const ETH_FRAME_TYPE[] = { 0x06, 0x08, }; static byte_t const ARP_HD_TYPE[] = { 0x01, 0x00, }; static byte_t const ARP_PROTO_TYPE[] = { 0x00, 0x08, }; static byte_t const ARP_OP_TYPE[] = { ARPOP_REQUEST & 0xFF, (ARPOP_REQUEST >> 8) & 0xFF, }; int rslt = 0; int fd = 0; arp_packet_st arp_packet = { { {0}, }, { {0}, }, }; assert(NULL != dmac); assert(NULL != dip); assert(NULL != smac); assert(NULL != sip); // 创建套接字 fd = socket(AF_INET, SOCK_PACKET, htons(ETH_P_ARP)); if (-1 == fd) { perror("[ERROR] socket error"); rslt = -1; goto SOCKET_ERR; } // arp包结构初始化,以太头 memcpy(arp_packet.m_eth_head.ma_dest_mac, dmac, MAC_ADDR_LEN); hton(arp_packet.m_eth_head.ma_dest_mac, MAC_ADDR_LEN); memcpy(arp_packet.m_eth_head.ma_src_mac, smac, MAC_ADDR_LEN); hton(arp_packet.m_eth_head.ma_src_mac, MAC_ADDR_LEN); memcpy(arp_packet.m_eth_head.ma_frame_type, Ð_FRAME_TYPE, ETH_FRAME_TYPE_LEN); hton(arp_packet.m_eth_head.ma_frame_type, ETH_FRAME_TYPE_LEN); // arp包结构初始化,arp帧 memcpy(arp_packet.m_arp_frame.ma_hd_type, ARP_HD_TYPE, ARP_HD_TYPE_LEN); hton(arp_packet.m_arp_frame.ma_hd_type, ARP_HD_TYPE_LEN); memcpy(arp_packet.m_arp_frame.ma_proto_type, ARP_PROTO_TYPE, ARP_PROTO_TYPE_LEN); hton(arp_packet.m_arp_frame.ma_proto_type, ARP_HD_TYPE_LEN); arp_packet.m_arp_frame.m_hd_addr_len = MAC_ADDR_LEN; arp_packet.m_arp_frame.m_proto_addr_len = IP_ADDR_LEN; memcpy(arp_packet.m_arp_frame.ma_op_type, ARP_OP_TYPE, ARP_OP_TYPE_LEN); hton(arp_packet.m_arp_frame.ma_op_type, ARP_OP_TYPE_LEN); memcpy(arp_packet.m_arp_frame.ma_from_mac, smac, MAC_ADDR_LEN); hton(arp_packet.m_arp_frame.ma_from_mac, MAC_ADDR_LEN); memcpy(arp_packet.m_arp_frame.ma_from_ip, sip, IP_ADDR_LEN); hton(arp_packet.m_arp_frame.ma_from_ip, IP_ADDR_LEN); memcpy(arp_packet.m_arp_frame.ma_to_mac, dmac, MAC_ADDR_LEN); hton(arp_packet.m_arp_frame.ma_to_mac, MAC_ADDR_LEN); memcpy(arp_packet.m_arp_frame.ma_to_ip, dip, IP_ADDR_LEN); hton(arp_packet.m_arp_frame.ma_to_ip, IP_ADDR_LEN); while (1) { struct sockaddr target; int n = 0; strcpy(target.sa_data, "vboxnet0"); n = sendto(fd, &arp_packet, sizeof(arp_packet_st), 0, (struct sockaddr *)&target, sizeof(target)); if (-1 == n) { fprintf(stderr, "[%d]", errno); fprintf(stderr, "[%d]", ENOTCONN); perror("[ERROR] sendto failed"); rslt = -1; break; } sleep(1); } // 错误处理 do { close(fd); SOCKET_ERR: break; } while (0); return rslt; }