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