void send_nack5( tNode* pNode,UINT32 seqn, int oid_length, BYTE* poid, BOOL fSendNow ) { /* send NACK REASON_5:"ObjectID-payload not supported!" */ IAnnexET00NAckHeader header[sizeof_IAnnexET00NAckHeader]; IAnnexENAckReason reason[sizeof_IAnnexENAckReason_ND]; msaPrintFormat( pNode->pAnnexE->msaType, "Send NAck5(ObjectID-payload not supported, SEQN=%i) to Host(%08x:%i)", seqn, pNode->RemoteHost.nIP, pNode->RemoteHost.nPort ); header[IAnnexET00NAckHeader_Header+IAnnexET00Header_PFLAGS] = 0; /* header.Header.T = 0; header.Header.A = 0; header.Header.S = 0; header.Header.RES = 0; */ header[IAnnexET00NAckHeader_Header+IAnnexET00Header_TRANSPORT_TYPE] = AEPT00_NAck; hton16( 1, &header[IAnnexET00NAckHeader_NACK_COUNT] ); hton24( seqn, &reason[IAnnexENAckReason_SEQNUM] ); reason[IAnnexENAckReason_DATA_LENGTH] = (BYTE)(oid_length & 0xff); hton16( 5, &reason[IAnnexENAckReason_REASON] ); send_payload( pNode, header, sizeof_IAnnexET00NAckHeader, reason, sizeof_IAnnexENAckReason_ND, poid, oid_length, FALSE, FALSE, fSendNow ); }
static void send_request (BArpProbe *o) { if (o->send_sending) { BLog(BLOG_ERROR, "cannot send packet while another packet is being sent!"); return; } // build packet struct arp_packet *arp = &o->send_packet; arp->hardware_type = hton16(ARP_HARDWARE_TYPE_ETHERNET); arp->protocol_type = hton16(ETHERTYPE_IPV4); arp->hardware_size = hton8(6); arp->protocol_size = hton8(4); arp->opcode = hton16(ARP_OPCODE_REQUEST); memcpy(arp->sender_mac, o->if_mac, 6); arp->sender_ip = hton32(0); memset(arp->target_mac, 0, sizeof(arp->target_mac)); arp->target_ip = o->addr; // send packet PacketPassInterface_Sender_Send(o->send_if, (uint8_t *)&o->send_packet, sizeof(o->send_packet)); // set sending o->send_sending = 1; }
void arp_request(void *buffer, ip_t ipaddr_dst) { eth_header_t eth_header; arp_header_t arp_header; mac_t mac_broadcast = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; memcpy(eth_header.mac_dst, mac_broadcast, sizeof(mac_t)); memcpy(eth_header.mac_src, mac_local, sizeof(mac_t)); eth_header.proto = hton16(0x0806); //0x0806 - ARP arp_header.hw_type = hton16(0x0001); //0x0001 - Ethernet arp_header.proto = hton16(0x0800); //0x0800 - IP arp_header.hwaddr_len = sizeof(mac_t); arp_header.protoaddr_len = sizeof(ip_t); arp_header.opcode = hton16(0x0001); //0x0001 - ARP Request memcpy(arp_header.hwaddr_src, mac_local, sizeof(mac_t)); memcpy(arp_header.ipaddr_src, ip_local, sizeof(ip_t)); memset(arp_header.hwaddr_dst, 0, sizeof(mac_t)); memcpy(arp_header.ipaddr_dst, ipaddr_dst, sizeof(ip_t)); memcpy(buffer, ð_header, sizeof(eth_header)); buffer += sizeof(eth_header); memcpy(buffer, &arp_header, sizeof(arp_header)); }
/* Open new pptp_connection. Returns NULL on failure. */ PPTP_CONN * pptp_conn_open(int inet_sock, int isclient, pptp_conn_cb callback) { PPTP_CONN *conn; /* Allocate structure */ if ((conn = malloc(sizeof(*conn))) == NULL) return NULL; if ((conn->call = vector_create()) == NULL) { free(conn); return NULL; } /* Initialize */ conn->inet_sock = inet_sock; conn->conn_state = CONN_IDLE; conn->ka_state = KA_NONE; conn->ka_id = 1; conn->call_serial_number = 0; conn->callback = callback; /* Create I/O buffers */ conn->read_size = conn->write_size = 0; conn->read_alloc = conn->write_alloc = INITIAL_BUFSIZE; conn->read_buffer = malloc(sizeof(*(conn->read_buffer)) * conn->read_alloc); conn->write_buffer = malloc(sizeof(*(conn->write_buffer)) * conn->write_alloc); if (conn->read_buffer == NULL || conn->write_buffer == NULL) { if (conn->read_buffer != NULL) free(conn->read_buffer); if (conn->write_buffer != NULL) free(conn->write_buffer); vector_destroy(conn->call); free(conn); return NULL; } /* Make this socket non-blocking. */ fcntl(conn->inet_sock, F_SETFL, O_NONBLOCK); /* Request connection from server, if this is a client */ if (isclient) { struct pptp_start_ctrl_conn packet = { PPTP_HEADER_CTRL(PPTP_START_CTRL_CONN_RQST), hton16(PPTP_VERSION), 0, 0, hton32(PPTP_FRAME_CAP), hton32(PPTP_BEARER_CAP), hton16(PPTP_MAX_CHANNELS), hton16(PPTP_FIRMWARE_VERSION), PPTP_HOSTNAME, PPTP_VENDOR }; /* fix this packet, if necessary */ int idx, rc; idx = get_quirk_index(); if (idx != -1 && pptp_fixups[idx].start_ctrl_conn) { if ((rc = pptp_fixups[idx].start_ctrl_conn(&packet))) warn("calling the start_ctrl_conn hook failed (%d)", rc); } if (pptp_send_ctrl_packet(conn, &packet, sizeof(packet))) conn->conn_state = CONN_WAIT_CTL_REPLY; else return NULL; /* could not send initial start request. */ } /* Set up interval/keep-alive timer */ /* First, register handler for SIGALRM */ sigpipe_create(); sigpipe_assign(SIGALRM); global.conn = conn; /* Reset event timer */ pptp_reset_timer(); /* all done. */ return conn; }
/* This currently *only* works for client call requests. * We need to do something else to allocate calls for incoming requests. */ PPTP_CALL * pptp_call_open(PPTP_CONN * conn, pptp_call_cb callback, char *phonenr) { PPTP_CALL * call; int i; int idx, rc; /* Send off the call request */ struct pptp_out_call_rqst packet = { PPTP_HEADER_CTRL(PPTP_OUT_CALL_RQST), 0,0, /*call_id, sernum */ hton32(PPTP_BPS_MIN), hton32(PPTP_BPS_MAX), hton32(PPTP_BEARER_CAP), hton32(PPTP_FRAME_CAP), hton16(PPTP_WINDOW), 0, 0, 0, {0}, {0} }; assert(conn && conn->call); assert(conn->conn_state == CONN_ESTABLISHED); /* Assign call id */ if (!vector_scan(conn->call, 0, PPTP_MAX_CHANNELS - 1, &i)) /* no more calls available! */ return NULL; /* allocate structure. */ if ((call = malloc(sizeof(*call))) == NULL) return NULL; /* Initialize call structure */ call->call_type = PPTP_CALL_PNS; call->state.pns = PNS_IDLE; call->call_id = (u_int16_t) i; call->sernum = conn->call_serial_number++; call->callback = callback; call->closure = NULL; packet.call_id = htons(call->call_id); packet.call_sernum = htons(call->sernum); /* if we have a quirk, build a new packet to fit it */ idx = get_quirk_index(); if (idx != -1 && pptp_fixups[idx].out_call_rqst_hook) { if ((rc = pptp_fixups[idx].out_call_rqst_hook(&packet))) warn("calling the out_call_rqst hook failed (%d)", rc); } /* fill in the phone number if it was specified */ if (phonenr) { strncpy((char *)packet.phone_num, phonenr, sizeof(packet.phone_num)); packet.phone_len = strlen(phonenr); if( packet.phone_len > sizeof(packet.phone_num)) packet.phone_len = sizeof(packet.phone_num); packet.phone_len = hton16 (packet.phone_len); } if (pptp_send_ctrl_packet(conn, &packet, sizeof(packet))) { pptp_reset_timer(); call->state.pns = PNS_WAIT_REPLY; /* and add it to the call vector */ vector_insert(conn->call, i, call); return call; } else { /* oops, unsuccessful. Deallocate. */ free(call); return NULL; } }
/* * ip_arp_recv_netbuf() * Handle reception of an ARP packet for IP. */ void ip_arp_recv_netbuf(void *clnt, struct netbuf *nb) { struct ethernet_client *ec; struct ip_datalink_instance *idi; struct eth_phys_header *eph; struct arp_header *ah; struct ip_arp_header *iah; struct ethernet_ip_instance *eii; ec = (struct ethernet_client *)clnt; idi = (struct ip_datalink_instance *)ec->ec_instance; eii = (struct ethernet_ip_instance *)idi; eph = (struct eth_phys_header *)nb->nb_datalink; ah = (struct arp_header *)nb->nb_network; iah = (struct ip_arp_header *)(ah + 1); if (ah->ah_haddr_len != 6) { debug_print_pstr("\farp haddr_len !6"); return; } if (ah->ah_paddr_len != 4) { debug_print_pstr("\farp paddr_len !4"); return; } if (hton32(iah->iah_dest_ip) != idi->idi_client->idc_addr) { return; } /* * Update our ARP cache with the sender's details. */ ip_arp_cache_add(idi, eph->eph_src_mac, hton32(iah->iah_src_ip)); switch (hton16(ah->ah_operation)) { case 1: /* * ARP request. */ ip_arp_recv_request(idi, nb); break; case 2: /* * ARP response. */ break; default: debug_print_pstr("\fip_arp_recv_netbuf: op"); debug_print16(hton16(ah->ah_operation)); } }
void tcp4_do_msg(handler_msg* msg,struct tcp_connection* c) { if(tcp_domsg(msg,c) == 0) { return; } tcp_stream* s = (tcp_stream*)msg->_data; hton16(s->_head+12,msg->_msgid); hton16(s->_head+14,s->_len); msg->_datalen = s->_len +4; msg->_data = s->_head + 12; tcpconnection_add_msg(c,msg); }
static Packet * Packet_create(PacketType type, size_t extraSize) { Packet *result; size_t len; // Alignment requirement. assert(extraSize % 4 == 0); len = packetTypeData[type].len + extraSize; result = Packet_alloc(len); result->header.len = hton16((uint16) len); result->header.type = hton16((uint16) type); return result; }
static int raw_socket_open (struct rawdev *dev) { struct raw_socket_priv *priv; struct ifreq ifr; struct sockaddr_ll sockaddr; priv = malloc(sizeof(struct raw_socket_priv)); if (!priv) { fprintf(stderr, "malloc: failure\n"); goto ERROR; } priv->fd = socket(PF_PACKET, SOCK_RAW, hton16(ETH_P_ALL)); if (priv->fd == -1) { perror("socket"); goto ERROR; } strncpy(ifr.ifr_name, dev->name, sizeof(ifr.ifr_name) - 1); if (ioctl(priv->fd, SIOCGIFINDEX, &ifr) == -1) { perror("ioctl [SIOCGIFINDEX]"); goto ERROR; } memset(&sockaddr, 0x00, sizeof(sockaddr)); sockaddr.sll_family = AF_PACKET; sockaddr.sll_protocol = hton16(ETH_P_ALL); sockaddr.sll_ifindex = ifr.ifr_ifindex; if (bind(priv->fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr)) == -1) { perror("bind"); goto ERROR; } if (ioctl(priv->fd, SIOCGIFFLAGS, &ifr) == -1) { perror("ioctl [SIOCGIFFLAGS]"); goto ERROR; } ifr.ifr_flags = ifr.ifr_flags | IFF_PROMISC; if (ioctl(priv->fd, SIOCSIFFLAGS, &ifr) == -1) { perror("ioctl [SIOCSIFFLAGS]"); goto ERROR; } dev->priv = priv; return 0; ERROR: if (priv) { if (priv->fd == -1) { close(priv->fd); } free(priv); } return -1; }
static int tftp_make_ack_pkt(unsigned char *tx_buf, unsigned short block_num) { tftp_ack_t *pkt = (tftp_ack_t*) &tx_buf[0]; pkt->opcode = hton16((unsigned short) TFTP_OPCODE_ACK); pkt->block_number = hton16(block_num); #if TFTP_DEBUG_PRINT printstr("TFTP: Gen ACK, block #"); printintln(block_num); #endif return TFTP_MIN_PKT_SIZE; }
int gtpie_tv2(void *p, unsigned int *length, unsigned int size, uint8_t t, uint16_t v) { if ((*length + 3) >= size) return 1; ((union gtpie_member*) (p + *length))->tv2.t = hton8(t); ((union gtpie_member*) (p + *length))->tv2.v = hton16(v); *length += 3; return 0; }
void send_ima( tNode* pNode, BOOL fSendNow ) { IAnnexET00IAmAlive ima[sizeof_IAnnexET00IAmAlive_ND]; BYTE cookie[4]; ima[IAnnexET00IAmAlive_Header+IAnnexET00Header_PFLAGS] = 0; AEPOr_T( ima[IAnnexET00IAmAlive_Header+IAnnexET00Header_PFLAGS], AEPT_TransportMessage ); /* ima.Header.S = 0; ima.Header.A = 0; ima.Header.RES = 0; */ ima[IAnnexET00IAmAlive_Header+IAnnexET00Header_TRANSPORT_TYPE] = AEPT00_IAmAlive; IMASet_P( ima ); hton16( (UINT16)get_ima_interval( pNode ), &ima[IAnnexET00IAmAlive_VALIDITY] ); IMASet_CookieLen( ima, sizeof( UINT32 ) ); hton32( timerGetTimeInMilliseconds(), &cookie[0] ); send_payload( pNode, ima, sizeof_IAmAliveHeader( &ima ), &cookie[0], 4, NULL, 0, FALSE, FALSE, fSendNow ); }
static void fillMAD_Get_LFTRecord(UInt8 *umad, SInt64 len, UInt16 smLid, UInt16 destLid, UInt64 trId) { UInt64 mask; struct _LinearForwardingTableRecord lft; memset(umad, 0, len); umad_set_addr(umad, smLid, MAD_QP1, MAD_DEFAULT_SL, IB_DEFAULT_QP1_QKEY); /* Ignore GRH */ mad_set_field (umad_get_mad(umad), 0, IB_MAD_METHOD_F, IB_MAD_METHOD_GET_TABLE); mad_set_field (umad_get_mad(umad), 0, IB_MAD_CLASSVER_F, MAD_HEADER_CLASS_VERSION_SA); mad_set_field (umad_get_mad(umad), 0, IB_MAD_MGMTCLASS_F, IB_SA_CLASS); mad_set_field (umad_get_mad(umad), 0, IB_MAD_BASEVER_F, 1); mad_set_field64(umad_get_mad(umad), 0, IB_MAD_TRID_F, trId); mad_set_field (umad_get_mad(umad), 0, IB_MAD_ATTRID_F, IB_SA_ATTR_LFTRECORD); if (destLid > 0) { memset(&lft, 0, sizeof(lft)); lft.lid = hton16(destLid); mask = 0x1; /* lid */ memcpy((UInt8 *)umad_get_mad(umad) + IB_SA_DATA_OFFS, &lft, sizeof(lft)); } mad_set_field64(umad_get_mad(umad), 0, IB_SA_COMPMASK_F, mask); }
void send_ack( tNode* pNode, UINT32 seqn, BOOL fSendNow ) { IAnnexET00Ack ack[sizeof_IAnnexET00Ack_ND+sizeof_IAnnexEAckData]; ack[IAnnexET00Ack_Header+IAnnexET00Header_PFLAGS] = 0; /* ack.Header.T = 0; ack.Header.A = 0; ack.Header.S = 0; ack.Header.RES = 0; */ ack[IAnnexET00Ack_Header+IAnnexET00Header_TRANSPORT_TYPE] = AEPT00_Ack; hton16( 1, &ack[IAnnexET00Ack_ACK_COUNT] ); hton24( seqn, &ack[IAnnexET00Ack_ACK+IAnnexEAckData_SEQNUM] ); ack[IAnnexET00Ack_ACK+IAnnexEAckData_RESERVED] = 0; send_payload( pNode, ack, sizeof_AckHeader( &ack ), &ack[IAnnexET00Ack_ACK], sizeof_IAnnexEAckData, NULL, 0, FALSE, FALSE, fSendNow ); }
t_osc_err osc_mem_encodeByteorder(unsigned char typetag, char *data, char **out) { size_t size = osc_sizeof(typetag, data); if(!osc_mem_shouldByteswap(typetag)){ memcpy(*out, data, size); return OSC_ERR_NONE; } char tmp[size]; switch(size){ case 1: break; case 2: *((uint16_t *)tmp) = hton16(*((uint16_t *)data)); break; case 4: *((uint32_t *)tmp) = hton32(*((uint32_t *)data)); break; case 8: *((uint64_t *)tmp) = hton64(*((uint64_t *)data)); break; case 16: *((uint128_t *)tmp) = hton128(*((uint128_t *)data)); break; } memcpy(*out, tmp, size); return OSC_ERR_NONE; }
static inline int decompressAddress(uint8_t dispatch, uint16_t src, uint8_t addr_flags, uint8_t **buf, uint8_t *dest) { uint8_t *prefix; uint16_t tmp; int rc = 0; if (dispatch == LOWPAN_HC_LOCAL_PATTERN) prefix = linklocal_prefix; else prefix = __my_address.s6_addr; switch (addr_flags) { case LOWPAN_IPHC_ADDR_128: ip_memcpy(dest, *buf, 16); *buf += 16; break; case LOWPAN_IPHC_ADDR_64: ip_memcpy(dest, prefix, 8); ip_memcpy(dest + 8, *buf, 8); *buf += 8; break; case LOWPAN_IPHC_ADDR_16: rc = decompressShortAddress(dispatch, *buf, dest); *buf += 2; break; case LOWPAN_IPHC_ADDR_0: ip_memcpy(dest, prefix, 8); ip_memclr(dest + 8, 6); tmp = hton16(src); ip_memcpy(dest + 14, (uint8_t *)&tmp, 2); break; } return rc; }
int main(int argc, char** argv){ constexpr uint16_t port = 3000; ////////// //epoll int epoll_fd = epoll_create(10); /////////////// //listen { int r_val; struct sockaddr_in sockadd; bzero(&sockadd, sizeof sockadd); sockadd.sin_family = AF_INET; sockadd.sin_addr.s_addr = INADDR_ANY; sockadd.sin_port = hton16(port); int fd = socket(AF_INET, SOCK_STREAM, 0); int val = 1; r_val = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof val); r_val = bind(fd, (struct sockaddr*)&sockadd, sizeof sockadd); r_val = listen(fd, 0); Epoll_event_handle *ev_h = new Epoll_event_handle; ev_h->on_event = [epoll_fd, fd]( struct epoll_event* ev){ on_accept(fd, epoll_fd); }; struct epoll_event ev; ev.events = EPOLLIN|EPOLLPRI|EPOLLRDHUP|EPOLLERR|EPOLLHUP; ev.data.ptr = (void*)ev_h; r_val = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd, &ev); } ////////////// // main event loop constexpr int max_event_count = 16; struct epoll_event events[max_event_count]; while (1){ int r_val = epoll_wait(epoll_fd, events, max_event_count, -1); if (r_val == -1){ if (errno == EINTR){ continue; } else{ return 0; } } for (int i = 0; i<r_val; i++){ Epoll_event_handle* ev_h = (Epoll_event_handle*) events[i].data.ptr; ev_h->on_event(events+i); } } }
Packet_SelectShip * Packet_SelectShip_create(uint16 ship) { Packet_SelectShip *packet = (Packet_SelectShip *) Packet_create(PACKET_SELECTSHIP, 0); packet->ship = hton16(ship); packet->padding = 0; return packet; }
int gtpie_tlv(void *p, unsigned int *length, unsigned int size, uint8_t t, int l, void *v) { if ((*length + 3 + l) >= size) return 1; ((union gtpie_member*) (p + *length))->tlv.t = hton8(t); ((union gtpie_member*) (p + *length))->tlv.l = hton16(l); memcpy((void*) (p + *length +3), v, l); *length += 3 + l; return 0; }
int main (int argc, char *argv[]) { int soc = -1, acc; uint8_t buf[65536]; ssize_t len; if (microps_init(¶m) == -1) { goto ERROR; } soc = tcp_api_open(); if (soc == -1) { goto ERROR; } if (tcp_api_bind(soc, hton16(7)) == -1) { goto ERROR; } tcp_api_listen(soc); acc = tcp_api_accept(soc); if (acc == -1) { goto ERROR; } fprintf(stderr, "accept success, soc=%d, acc=%d\n", soc, acc); while (1) { len = tcp_api_recv(acc, buf, sizeof(buf)); if (len <= 0) { break; } hexdump(stderr, buf, len); tcp_api_send(acc, buf, len); } tcp_api_close(acc); /* ip_addr_t peer_addr; uint16_t peer_port; ip_addr_pton("72.21.215.232", &peer_addr); peer_port = hton16(80); tcp_api_connect(soc, &peer_addr, peer_port); strcpy(buf, "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: Close\r\n\r\n"); tcp_api_send(soc, (uint8_t *)buf, strlen(buf)); while (1) { len = tcp_api_recv(soc, (uint8_t *)buf, sizeof(buf)); //fprintf(stderr, "len: %ld\n", len); if (len <= 0) { break; } //hexdump(stderr, buf, len); } */ tcp_api_close(soc); microps_cleanup(); return 0; ERROR: if (soc != -1) { tcp_api_close(soc); } microps_cleanup(); return -1; }
/* * ip_arp_request() * Issue an ARP request for a given IP address. */ u8_t ip_arp_request(struct ip_datalink_instance *idi, u32_t ip) { u8_t *pkt; struct netbuf *nb; struct arp_header *ah; struct ip_arp_header *iah; static u8_t broadcast_mac[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; struct ethernet_ip_instance *eii; struct ethernet_server *es; eii = (struct ethernet_ip_instance *)idi; pkt = membuf_alloc(sizeof(struct arp_header) + sizeof(struct ip_arp_header), NULL); ah = (struct arp_header *)pkt; ah->ah_hardware = hton16(1); ah->ah_protocol = hton16(0x0800); ah->ah_haddr_len = 6; ah->ah_paddr_len = 4; ah->ah_operation = hton16(1); iah = (struct ip_arp_header *)(ah + 1); iah->iah_src_ip = hton32(idi->idi_client->idc_addr); iah->iah_dest_ip = hton32(ip); spinlock_lock(&idi->idi_lock); es = eii->eii_arp_server; ethernet_server_ref(es); spinlock_unlock(&idi->idi_lock); memcpy(iah->iah_src_mac, es->es_get_mac(es), 6); memcpy(iah->iah_dest_mac, broadcast_mac, 6); nb = netbuf_alloc(); nb->nb_network_membuf = ah; nb->nb_network = ah; nb->nb_network_size = sizeof(struct arp_header) + sizeof(struct ip_arp_header); es->es_send(es, broadcast_mac, nb); netbuf_deref(nb); ethernet_server_deref(es); return 0; }
yrmcds_error yrmcds_cnt_get(yrmcds_cnt* c, const char* name, size_t name_len, uint32_t* serial) { if( name == NULL || name_len == 0 || name_len > UINT16_MAX ) return YRMCDS_BAD_ARGUMENT; char body[2]; hton16((uint16_t)name_len, body); return send_command(c, YRMCDS_CNT_CMD_GET, serial, sizeof(body), body, name_len, name); }
INT bind( INT sockID, struct sockaddr *localAddress, INT addressLength ) { switch ( sockets[sockID].type ) { case BSD_SOCKET_TCP: { sockets[sockID].local_bind_port = hton16(SOCK4_PORT(localAddress)); return BSD_SUCCESS; } case BSD_SOCKET_UDP: { if ( nx_udp_socket_bind( &sockets[sockID].socket.udp, hton16(SOCK4_PORT(localAddress)), NX_WAIT_FOREVER ) == NX_SUCCESS ) { return BSD_SUCCESS; } break; } } return BSD_ERROR; }
yrmcds_error yrmcds_cnt_release(yrmcds_cnt* c, const char* name, size_t name_len, uint32_t resources, uint32_t* serial) { if( name == NULL || name_len == 0 || name_len > UINT16_MAX ) return YRMCDS_BAD_ARGUMENT; char body[6]; hton32(resources, body); hton16((uint16_t)name_len, body + 4); return send_command(c, YRMCDS_CNT_CMD_RELEASE, serial, sizeof(body), body, name_len, name); }
int dhd_adjust_tcp_winsize(int index, int pk_type, int op_mode, struct sk_buff *skb) { struct iphdr *ipheader; struct tcphdr *tcpheader; uint16 win_size; int32 incremental_checksum; if (!dhd_use_tcp_window_size_adjust || !(op_mode & DHD_FLAG_HOSTAP_MODE)) return 0; if (skb == NULL || skb->data == NULL) return 0; if (index == 0 || pk_type == ETHER_TYPE_IP) { ipheader = (struct iphdr*)(skb->data); if (ipheader->protocol == IPPROTO_TCP) { tcpheader = (struct tcphdr*) skb_pull(skb, (ipheader->ihl)<<2); if (tcpheader) { win_size = ntoh16(tcpheader->window); if (win_size < MIN_TCP_WIN_SIZE && dhd_port_list_match(ntoh16(tcpheader->dest))) { incremental_checksum = ntoh16(tcpheader->check); incremental_checksum += win_size - win_size *WIN_SIZE_SCALE_FACTOR; if (incremental_checksum < 0) --incremental_checksum; tcpheader->window = hton16(win_size*WIN_SIZE_SCALE_FACTOR); tcpheader->check = hton16((unsigned short) incremental_checksum); } } skb_push(skb, (ipheader->ihl)<<2); } } return 0; }
/* * ip_arp_recv_request() */ static void ip_arp_recv_request(struct ip_datalink_instance *idi, struct netbuf *nb) { u8_t *send_packet; struct eth_phys_header *reph; struct arp_header *rah, *sah; struct ip_arp_header *rp, *sp; struct netbuf *nbrep; struct ethernet_ip_instance *eii; struct ethernet_server *es; eii = (struct ethernet_ip_instance *)idi; reph = (struct eth_phys_header *)nb->nb_datalink; rah = (struct arp_header *)nb->nb_network; rp = (struct ip_arp_header *)(rah + 1); /* * Issue an ARP reply. */ send_packet = membuf_alloc(sizeof(struct arp_header) + sizeof(struct ip_arp_header), NULL); sah = (struct arp_header *)send_packet; sp = (struct ip_arp_header *)(sah + 1); memcpy(sp->iah_dest_mac, rp->iah_src_mac, 6); spinlock_lock(&idi->idi_lock); es = eii->eii_arp_server; ethernet_server_ref(es); spinlock_unlock(&idi->idi_lock); memcpy(sp->iah_src_mac, es->es_get_mac(es), 6); sah->ah_hardware = rah->ah_hardware; sah->ah_protocol = rah->ah_protocol; sah->ah_haddr_len = rah->ah_haddr_len; sah->ah_paddr_len = rah->ah_paddr_len; sah->ah_operation = hton16(2); sp->iah_src_ip = hton32(idi->idi_client->idc_addr); sp->iah_dest_ip = hton32(rp->iah_src_ip); nbrep = netbuf_alloc(); nbrep->nb_network_membuf = sah; nbrep->nb_network = sah; nbrep->nb_network_size = sizeof(struct arp_header) + sizeof(struct ip_arp_header); es->es_send(es, sp->iah_dest_mac, nbrep); netbuf_deref(nbrep); ethernet_server_deref(es); }
static uint8_t *add_marker_chunk(uint8_t *em_ptr, scarletbook_output_format_t *ft, uint64_t frame_count, uint16_t mark_type, uint16_t track_flags) { marker_chunk_t *marker_chunk = (marker_chunk_t *) em_ptr; int seconds = (int) (frame_count / SACD_FRAME_RATE); int remainder = seconds % 3600; marker_chunk->chunk_id = MARK_MARKER; marker_chunk->offset = 0; marker_chunk->hours = hton16(seconds / 3600); marker_chunk->minutes = remainder / 60; marker_chunk->seconds = remainder % 60; marker_chunk->samples = hton32((frame_count % SACD_FRAME_RATE) * SAMPLES_PER_FRAME * 64); marker_chunk->mark_type = hton16(mark_type); marker_chunk->mark_channel = hton16(COMT_TYPE_CHANNEL_ALL); marker_chunk->track_flags = hton16(track_flags); marker_chunk->count = 0; marker_chunk->chunk_data_size = CALC_CHUNK_SIZE(EDITED_MASTER_MARKER_CHUNK_SIZE - CHUNK_HEADER_SIZE); em_ptr += CEIL_ODD_NUMBER(EDITED_MASTER_MARKER_CHUNK_SIZE); return em_ptr; }
/* * udp_send_netbuf() * Send a UDP netbuf. * * Note that we assume that all parameters are supplied in network byte order. */ static void udp_send_netbuf(void *srv, u32_t dest_addr, u16_t dest_port, struct netbuf *nb) { struct udp_server *us; struct udp_instance *ui; u16_t csum; struct udp_header *udh; struct ip_server *is; us = (struct udp_server *)srv; ui = (struct udp_instance *)us->us_instance; nb->nb_transport_membuf = membuf_alloc(sizeof(struct udp_header), NULL); nb->nb_transport = nb->nb_transport_membuf; nb->nb_transport_size = sizeof(struct udp_header); udh = (struct udp_header *)nb->nb_transport; udh->uh_dest_port = dest_port; udh->uh_src_port = hton16(us->us_port); udh->uh_len = hton16(nb->nb_transport_size + nb->nb_application_size); udh->uh_csum = 0; spinlock_lock(&ui->ui_lock); is = ui->ui_server; ip_server_ref(is); spinlock_unlock(&ui->ui_lock); csum = ipcsum_pseudo_partial(hton32(((struct ip_instance *)is->is_instance)->ii_addr), dest_addr, 0x11, udh->uh_len); csum = ipcsum_partial(csum, udh, sizeof(struct udp_header)); udh->uh_csum = ipcsum(csum, nb->nb_application, nb->nb_application_size); /* * Pass the netbuf down to the next layer. */ is->is_send(is, dest_addr, 0x11, nb); ip_server_deref(is); }
/* return 0 on success, non zero otherwise */ int orckit_atur3_build_hook(struct pptp_out_call_rqst* packet) { unsigned int name_length = 10; struct pptp_out_call_rqst fixed_packet = { PPTP_HEADER_CTRL(PPTP_OUT_CALL_RQST), 0, /* hton16(call->callid) */ 0, /* hton16(call->sernum) */ hton32(PPTP_BPS_MIN), hton32(PPTP_BPS_MAX), hton32(PPTP_BEARER_DIGITAL), hton32(PPTP_FRAME_ANY), hton16(PPTP_WINDOW), 0, hton16(name_length), 0, {'R','E','L','A','Y','_','P','P','P','1',0}, {0} }; if (!packet) return -1; memcpy(packet, &fixed_packet, sizeof(*packet)); return 0; }
yrmcds_error yrmcds_cnt_acquire(yrmcds_cnt* c, const char* name, size_t name_len, uint32_t resources, uint32_t initial, uint32_t* serial) { if( name == NULL || name_len == 0 || name_len > UINT16_MAX || resources == 0 || resources > initial ) return YRMCDS_BAD_ARGUMENT; char body[10]; hton32(resources, body); hton32(initial, body + 4); hton16((uint16_t)name_len, body + 8); return send_command(c, YRMCDS_CNT_CMD_ACQUIRE, serial, sizeof(body), body, name_len, name); }