bool send_init_oft2(file_transfer *ft, char* file) { aimString astr(file); unsigned short len = max(0x100, 0xc0 + astr.getTermSize()); oft2 *oft = (oft2*)alloca(len); memset(oft, 0, len); memcpy(oft->protocol_version, "OFT2", 4); oft->length = _htons(len); oft->type = 0x0101; oft->total_files = _htons(ft->pfts.totalFiles); oft->num_files_left = _htons(ft->pfts.totalFiles - ft->pfts.currentFileNumber); oft->total_parts = _htons(1); oft->parts_left = _htons(1); oft->total_size = _htonl(ft->pfts.totalBytes); oft->size = _htonl(ft->pfts.currentFileSize); oft->mod_time = _htonl(ft->pfts.currentFileTime); oft->checksum = _htonl(aim_oft_checksum_file(ft->pfts.tszCurrentFile)); oft->recv_RFchecksum = 0x0000FFFF; oft->RFchecksum = 0x0000FFFF; oft->recv_checksum = 0x0000FFFF; memcpy(oft->idstring, "Cool FileXfer", 13); oft->flags = 0x20; oft->list_name_offset = 0x1c; oft->list_size_offset = 0x11; oft->encoding = _htons(astr.isUnicode() ? 2 : 0); memcpy(oft->filename, astr.getBuf(), astr.getTermSize()); if (!ft->requester || ft->pfts.currentFileNumber) memcpy(oft->icbm_cookie, ft->icbm_cookie, 8); return Netlib_Send(ft->hConn, (char*)oft, len, 0) > 0; }
void tcp_send_fin(struct tcp_sock *tsk) { struct tcp *otcp; struct pkbuf *opkb; opkb = alloc_pkb(ETH_HRD_SZ + IP_HRD_SZ + TCP_HRD_SZ); /* fill tcp head */ otcp = (struct tcp *)pkb2ip(opkb)->ip_data; otcp->src = tsk->sk.sk_sport; otcp->dst = tsk->sk.sk_dport; otcp->doff = TCP_HRD_DOFF; otcp->seq = _htonl(tsk->snd_nxt); otcp->window = _htons(tsk->rcv_wnd); otcp->fin = 1; /* * Should we send an ACK? * Yes, tcp stack will drop packet if it has no ACK bit * according to RFC 793 #SEGMENT RECEIVE */ otcp->ackn = _htonl(tsk->rcv_nxt); otcp->ack = 1; tcpdbg("send FIN(%u)/ACK(%u) [WIN %d] to "IPFMT":%d", _ntohl(otcp->seq), _ntohl(otcp->ackn), _ntohs(otcp->window), ipfmt(tsk->sk.sk_daddr), _ntohs(otcp->dst)); tcp_send_out(tsk, opkb, NULL); }
void tcp_send_synack(struct tcp_sock *tsk, struct tcp_segment *seg) { /* * LISTEN : * SYN-SENT: * SEG: SYN, no ACK, no RST * <SEQ=ISS><ACK=RCV.NXT><CTL=SYN,ACK> * (ISS == SND.NXT) */ struct tcp *otcp, *tcphdr = seg->tcphdr; struct pkbuf *opkb; if (tcphdr->rst) return; opkb = alloc_pkb(ETH_HRD_SZ + IP_HRD_SZ + TCP_HRD_SZ); /* fill tcp head */ otcp = (struct tcp *)pkb2ip(opkb)->ip_data; otcp->src = tcphdr->dst; otcp->dst = tcphdr->src; otcp->doff = TCP_HRD_DOFF; otcp->seq = _htonl(tsk->iss); otcp->ackn = _htonl(tsk->rcv_nxt); otcp->syn = 1; otcp->ack = 1; otcp->window = _htons(tsk->rcv_wnd); tcpdbg("send SYN(%u)/ACK(%u) [WIN %d] to "IPFMT":%d", _ntohl(otcp->seq), _ntohs(otcp->window), _ntohl(otcp->ackn), ipfmt(seg->iphdr->ip_dst), _ntohs(otcp->dst)); tcp_send_out(tsk, opkb, seg); }
extern "C" __declspec(dllexport) const PLUGININFOEX* MirandaPluginInfoEx(DWORD mirandaVersion) { if (mirandaVersion < __VERSION_DWORD) { MessageBox(NULL, _T("The AIM protocol plugin cannot be loaded. It requires Miranda IM ") _T(__VERSION_STRING) _T(" or later."), _T("Miranda"), MB_OK | MB_ICONWARNING | MB_SETFOREGROUND | MB_TOPMOST); return NULL; } *(unsigned long*)(&AIM_CAP_MIRANDA[8]) = _htonl(mirandaVersion); *(unsigned long*)(&AIM_CAP_MIRANDA[12]) = _htonl(__VERSION_DWORD); return &pluginInfo; }
//Function to write tlv header into a msg according to tlv info, the input buffer size should be at least MAX_TLV_HEADER_SIZE static tlv_status_t write_tlv_header(uint8_t *msg, const tlv_info_t *info) { uint8_t type = info->type; if(info->size>UINT16_MAX ||info->header_size == LARGE_TLV_HEADER_SIZE){//6 bytes header uint32_t size = info->size; //4 bytes in size field type |= FOUR_BYTES_SIZE_TYPE; msg[0] = type; msg[1] = info->version; size = _htonl(size); if(memcpy_s(&msg[2], sizeof(uint32_t), &size, sizeof(size))!=0){ AESM_DBG_ERROR("memcpy failed"); return TLV_UNKNOWN_ERROR; } }else{//4 bytes header uint16_t size = (uint16_t)info->size;//2 bytes in size field msg[0] = type; msg[1] = info->version; size = _htons(size); if(memcpy_s(&msg[2], sizeof(uint16_t), &size, sizeof(size))!=0){ AESM_DBG_ERROR("memcpy failed"); return TLV_UNKNOWN_ERROR; } } return TLV_SUCCESS; }
static ae_error_t prov_es_gen_header(provision_request_header_t *es_header, const uint8_t *xid, uint32_t msg_buffer_size) { uint32_t total_size = 0; total_size = ES_SELECTOR_TLV_SIZE(); //initialize ES Msg1 Header es_header->protocol = ENDPOINT_SELECTION; es_header->type = TYPE_ES_MSG1; es_header->version = TLV_VERSION_1; if(0!=memcpy_s(es_header->xid, XID_SIZE, xid, XID_SIZE)){ AESM_DBG_FATAL("memcpy error"); return PVE_UNEXPECTED_ERROR; } uint32_t size_in; size_in = _htonl(total_size);//big endian size required in msg header if(0!=memcpy_s(&es_header->size,sizeof(es_header->size), &size_in, sizeof(size_in))){ AESM_DBG_FATAL("memcpy error"); return PVE_UNEXPECTED_ERROR; } if(total_size +sizeof(*es_header) >msg_buffer_size){//the input msg body buffer size is not large enough AESM_DBG_ERROR("input msg buffer is too small"); return PVE_INSUFFICIENT_MEMORY_ERROR; } return AE_SUCCESS; }
ae_error_t CertificateProvisioningProtocol::msg3_create_header(const upse::Buffer& transactionID, uint32_t nonceSize, uint32_t quoteSize, uint32_t epidSigSize, uint32_t csrSize, provision_request_header_t& header) { ae_error_t status = AESM_PSE_PR_INTERNAL_ERROR; do { uint32_t seq2_0_tlv_block_cipher_text_size = BLOCK_CIPHER_TEXT_TLV_SIZE(quoteSize + epidSigSize + csrSize); uint32_t seq3_0_tlv_nonce_size = nonceSize; uint32_t seq4_0_tlv_mac_size = MAC_TLV_SIZE(MAC_SIZE); header.protocol = PSE_PROVISIONING; header.version = TLV_VERSION_1; header.type = static_cast<uint8_t>(TYPE_PSE_MSG3); if (XID_SIZE != transactionID.getSize()) break; if (memcpy_s(header.xid, sizeof(header.xid), transactionID.getData(), transactionID.getSize()) != 0) break; uint32_t totalSize = seq2_0_tlv_block_cipher_text_size + seq3_0_tlv_nonce_size + seq4_0_tlv_mac_size; uint32_t serializedSize = _htonl(totalSize); se_static_assert(sizeof(serializedSize) == sizeof(header.size)); if (memcpy_s(header.size, sizeof(header.size), &serializedSize, sizeof(serializedSize)) != 0) break; status = AE_SUCCESS; } while (0); return status; }
/* * Reset algorithm is not stated directly in RFC 793, * but we can conclude it according to all reset generation. * NOTE: maybe @tsk is NULL */ void tcp_send_reset(struct tcp_sock *tsk, struct tcp_segment *seg) { struct tcp *otcp, *tcphdr = seg->tcphdr; struct pkbuf *opkb; if (tcphdr->rst) return; opkb = alloc_pkb(ETH_HRD_SZ + IP_HRD_SZ + TCP_HRD_SZ); /* fill tcp head */ otcp = (struct tcp *)pkb2ip(opkb)->ip_data; otcp->src = tcphdr->dst; otcp->dst = tcphdr->src; if (tcphdr->ack) { /* * Should we set ack? * -Yes for xinu, it always set ack to seq+len * +No for Linux * +No for tapip */ otcp->seq = tcphdr->ackn; } else { otcp->ackn = _htonl(seg->seq + seg->len); otcp->ack = 1; } otcp->doff = TCP_HRD_DOFF; otcp->rst = 1; tcpdbg("send RESET from "IPFMT":%d to "IPFMT":%d", ipfmt(seg->iphdr->ip_dst), _ntohs(otcp->src), ipfmt(seg->iphdr->ip_src), _ntohs(otcp->dst)); tcp_send_out(NULL, opkb, seg); }
/* We're all done sorting. Write out the logfile. * Format: * Magic number 0x43 0x9f 0x22 0x53 * Number of elements * Array of absolute offsets from the start of the file * Magic number 0xa4 0xc3 0x2d 0xe5 * Array of events */ static int st_write(struct state *st) { int jump_offset; struct evt_file_header file_header; uint32_t offset; qDebug() << "Writing out..."; st->out_fdh->seek(0); offset = 0; // Write out the file header memset(&file_header, 0, sizeof(file_header)); memcpy(file_header.magic1, EVENT_HDR_1, strlen(EVENT_HDR_1)); file_header.version = _ntohl(1); file_header.count = _htonl(hdr_count); offset += st->out_fdh->write((char *)&file_header, sizeof(file_header)); // Advance the offset past the jump table offset += hdr_count*sizeof(offset); // Read in the jump table entries st->fdh->seek(0); for (jump_offset=0; jump_offset<hdr_count; jump_offset++) { union evt evt; uint32_t offset_swab = _htonl(offset); st->out_fdh->write((char *)&offset_swab, sizeof(offset_swab)); st->fdh->seek(hdrs[jump_offset].pos); memset(&evt, 0, sizeof(evt)); event_get_next(st, &evt); if (evt.header.size > 32768) return 1; offset += evt.header.size; } offset += st->out_fdh->write(EVENT_HDR_2, 4); // Now copy over the exact events for (jump_offset=0; jump_offset<hdr_count; jump_offset++) { union evt evt; st->fdh->seek(hdrs[jump_offset].pos); event_get_next(st, &evt); event_write(st, &evt); } sstate_set(st, ST_DONE); return 1; }
/* Start Adafruit_WINC1500UDP socket, listening at local port PORT */ uint8_t Adafruit_WINC1500UDP::begin(uint16_t port, uint32_t multicastAddr) { struct sockaddr_in addr; uint32 u32EnableCallbacks = 0; _flag = 0; _head = 0; _tail = 0; _rcvSize = 0; _rcvPort = 0; _rcvIP = 0; _sndSize = 0; // Initialize socket address structure. addr.sin_family = AF_INET; addr.sin_port = _htons(port); addr.sin_addr.s_addr = 0; // Open TCP server socket. if ((_socket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { return 0; } // Add socket buffer handler: socketBufferRegister(_socket, &_flag, &_head, &_tail, (uint8 *)_recvBuffer); setsockopt(_socket, SOL_SOCKET, SO_SET_UDP_SEND_CALLBACK, &u32EnableCallbacks, 0); // Set multicast address option if a multicast address was specified. if (multicastAddr != 0) { multicastAddr = _htonl(multicastAddr); if (setsockopt(_socket, SOL_SOCKET, IP_ADD_MEMBERSHIP, &multicastAddr, sizeof(multicastAddr)) < 0) { // Failed to set the multicast address option. close(_socket); _socket = -1; return 0; } } // Bind socket: if (bind(_socket, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) < 0) { close(_socket); _socket = -1; return 0; } // Wait for connection or timeout: unsigned long start = millis(); while (!READY && millis() - start < 2000) { m2m_wifi_handle_events(NULL); } if (!READY) { close(_socket); _socket = -1; return 0; } _flag &= ~SOCKET_BUFFER_FLAG_BIND; return 1; }
QByteArray fromNumberToBuffer (quint32 number) { QByteArray temp; QDataStream ds (temp); ds << _htonl(number); return (temp); }
static inline void set_tcp_ip_src(struct __sk_buff *skb, __u32 new_ip) { __u32 old_ip = _htonl(load_word(skb, IP_SRC_OFF)); bpf_l4_csum_replace(skb, TCP_CSUM_OFF, old_ip, new_ip, IS_PSEUDO | sizeof(new_ip)); bpf_l3_csum_replace(skb, IP_CSUM_OFF, old_ip, new_ip, sizeof(new_ip)); bpf_skb_store_bytes(skb, IP_SRC_OFF, &new_ip, sizeof(new_ip), 0); }
static void tcp_init_text(struct tcp_sock *tsk, struct pkbuf *pkb, void *buf, int size) { struct tcp *tcphdr = pkb2tcp(pkb); tcphdr->src = tsk->sk.sk_sport; tcphdr->dst = tsk->sk.sk_dport; tcphdr->doff = TCP_HRD_DOFF; tcphdr->seq = _htonl(tsk->snd_nxt); tcphdr->ackn = _htonl(tsk->rcv_nxt); tcphdr->ack = 1; tcphdr->window = _htons(tsk->rcv_wnd); memcpy(tcphdr->data, buf, size); tsk->snd_nxt += size; tsk->snd_wnd -= size; tcpsdbg("send TEXT(%u:%d) [WIN %d] to "IPFMT":%d", _ntohl(tcphdr->seq), size, _ntohs(tcphdr->window), ipfmt(tsk->sk.sk_daddr), _ntohs(tcphdr->dst)); }
/* * Need enough RX buffer space to receive a complete name service packet when * used in UDP mode. NS expects MTU of 1500 subtracts UDP, IP and Ethernet * Type II overhead. 1500 - 8 -20 - 18 = 1454. txData buffer size needs to * be big enough to hold a NS WHO-HAS for one name (4 + 2 + 256 = 262) in UDP * mode. TCP buffer size dominates in that case. */ AJ_Status AJ_Net_Connect(AJ_BusAttachment* bus, const AJ_Service* service) { int ret; // IPAddress ip(service->ipv4); if (!(service->addrTypes & AJ_ADDR_TCP4)) { // AJ_ErrPrintf(("AJ_Net_Connect(): only IPV4 TCP supported\n", ret)); return AJ_ERR_CONNECT; } // printf("AJ_Net_Connect(netSock=0x%p, addrType=%d.)\n", netSock, addrType); printf("AJ_Net_Connect()\n"); // ret = g_client.connect(ip, service->ipv4port); // addr.sin_port = _htons(48256); // addr.sin_addr.s_addr = _htonl(0xc0a8141d); addr.sin_port = _htons(service->ipv4port); addr.sin_addr.s_addr = _htonl(service->ipv4); printf("AJ_Net_Connect(): ipv4= %x, port = %d\n",addr.sin_addr.s_addr, addr.sin_port); tcp_client_socket = socket(AF_INET, SOCK_STREAM, 0); ret=connect(tcp_client_socket, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)); printf("AJ_Net_Connect(): connect\n"); //ждем подключения while(tcp_ready_to_send==0) { m2m_wifi_handle_events(NULL); } printf("AJ_Net_Connect(): connect OK\n"); if (ret == -1) { //AJ_ErrPrintf(("AJ_Net_Connect(): connect() failed: %d: status=AJ_ERR_CONNECT\n", ret)); return AJ_ERR_CONNECT; } else { //AJ_IOBufInit(&netSock->rx, rxData, sizeof(rxData), AJ_IO_BUF_RX, (void*)&g_clientUDP); bus->sock.rx.bufStart = AJ_in_data_tcp; bus->sock.rx.bufSize = sizeof(AJ_in_data_tcp); bus->sock.rx.readPtr = AJ_in_data_tcp; bus->sock.rx.writePtr = AJ_in_data_tcp; bus->sock.rx.direction = AJ_IO_BUF_RX; bus->sock.rx.recv = AJ_Net_Recv; // AJ_IOBufInit(&netSock->tx, txData, sizeof(txData), AJ_IO_BUF_TX, (void*)&g_clientUDP); bus->sock.tx.bufStart = tcp_data_tx; bus->sock.tx.bufSize = sizeof(tcp_data_tx); bus->sock.tx.readPtr = tcp_data_tx; bus->sock.tx.writePtr = tcp_data_tx; bus->sock.tx.direction = AJ_IO_BUF_TX; bus->sock.tx.send = AJ_Net_Send; printf("AJ_Net_Connect(): connect() success: status=AJ_OK\n"); return AJ_OK; } printf("AJ_Net_Connect(): connect() failed: %d: status=AJ_ERR_CONNECT\n", ret); return AJ_ERR_CONNECT; }
static int _get_packet(unsigned char *packet, int *len) { uint32_t data[12]; struct timeval_t now = {0, 0}; if (*len < 48) { log_err("packet buf too short!\n"); return -1; } memset(packet, 0, *len); data[0] = _htonl((LI << 30) | (VN << 27) | (MODE << 24) | (STRATUM << 16) | (POLL << 8) | (PREC & 0xff)); data[1] = _htonl(1 << 16); /* Root Delay (seconds) */ data[2] = _htonl(1 << 16); /* Root Dispersion (seconds) */ data[10] = _htonl(now.tv_sec + JAN_1970); /* Transmit Timestamp coarse */ data[11] = _htonl(NTPFRAC(now.tv_usec)); /* Transmit Timestamp fine */ memcpy(packet, data, 48); *len = 48; return 0; }
/* * Acknowledgment algorithm is not stated directly in RFC 793, * but we can conclude it from all acknowledgment situation. */ void tcp_send_ack(struct tcp_sock *tsk, struct tcp_segment *seg) { /* * SYN-SENT : * SEG: SYN, acceptable ACK, no RST (SND.NXT = SEG.SEQ+1) * <SEQ=SND.NXT><ACK=RCV.NXT><CTL=ACK> * SYN-RECEIVED / ESTABLISHED / FIN-WAIT-1 / FIN-WAIT-2 / * CLOSE-WAIT / CLOSING / LAST-ACK / TIME-WAIT : * SEG: no RST, ??ACK, ??SYN (segment is not acceptable) * <SEQ=SND.NXT><ACK=RCV.NXT><CTL=ACK> * ESTABLISHED / FIN-WAIT-1 / FIN-WAIT-2 / process the segment text: * SEG: ACK, no RST * <SEQ=SND.NXT><ACK=RCV.NXT><CTL=ACK> * (This acknowledgment should be piggybacked on a segment being * transmitted if possible without incurring undue delay.) */ struct tcp *otcp, *tcphdr = seg->tcphdr; struct pkbuf *opkb; if (tcphdr->rst) return; opkb = alloc_pkb(ETH_HRD_SZ + IP_HRD_SZ + TCP_HRD_SZ); /* fill tcp head */ otcp = (struct tcp *)pkb2ip(opkb)->ip_data; otcp->src = tcphdr->dst; otcp->dst = tcphdr->src; otcp->doff = TCP_HRD_DOFF; otcp->seq = _htonl(tsk->snd_nxt); otcp->ackn = _htonl(tsk->rcv_nxt); otcp->ack = 1; otcp->window = _htons(tsk->rcv_wnd); tcpdbg("send ACK(%u) [WIN %d] to "IPFMT":%d", _ntohl(otcp->ackn), _ntohs(otcp->window), ipfmt(seg->iphdr->ip_src), _ntohs(otcp->dst)); tcp_send_out(tsk, opkb, seg); }
void WiFiMDNSResponder::replyToRequest() { int nameLength = name.length(); int domainLength = sizeof(domain); uint32_t ipAddress = WiFi.localIP(); uint32_t ttl = _htonl(ttlSeconds); int responseSize = sizeof(responseHeader) + 1 + nameLength + 1 + domainLength + 1 + sizeof(aRecord) + sizeof(nsecRecord); uint8_t response[responseSize]; uint8_t* r = response; // copy header memcpy_P(r, responseHeader, sizeof(responseHeader)); r += sizeof(responseHeader); // copy name *r = nameLength; memcpy(r + 1, name.c_str(), nameLength); r += (1 + nameLength); // copy domain *r = domainLength; memcpy_P(r + 1, domain, domainLength); r += (1 + domainLength); // terminator *r = 0x00; r++; // copy A record memcpy_P(r, aRecord, sizeof(aRecord)); memcpy(r + TTL_OFFSET, &ttl, sizeof(ttl)); // replace TTL value memcpy(r + IP_OFFSET, &ipAddress, sizeof(ipAddress)); // replace IP address value r += sizeof(aRecord); // copy NSEC record memcpy_P(r, nsecRecord, sizeof(nsecRecord)); r += sizeof(nsecRecord); udpSocket.beginPacket(IPAddress(224, 0, 0, 251), 5353); udpSocket.write(response, responseSize); udpSocket.endPacket(); }
//Function to initialize request header for ProvMsg1 //msg1_header: request header for ProvMsg1 to fill in //use_flags: whether the flag tlv is included //xid: transaction ID //msg1_buffer_size: buffer size for ProvMsg1, in bytes static ae_error_t prov_msg1_gen_header(provision_request_header_t *msg1_header, bool use_flags, const uint8_t *xid, uint32_t msg1_buffer_size) { uint32_t total_size = 0; //platform info tlv size uint32_t field1_data_size = PLATFORM_INFO_TLV_SIZE(); field1_data_size += CIPHER_TEXT_TLV_SIZE(RSA_3072_KEY_BYTES); //add flag tlv if needed if(use_flags){ field1_data_size += FLAGS_TLV_SIZE(); } if(sizeof(*msg1_header)>msg1_buffer_size){ AESM_DBG_ERROR("Too small ProvMsg1 buffer size"); return PVE_INSUFFICIENT_MEMORY_ERROR; } total_size = CIPHER_TEXT_TLV_SIZE(RSA_3072_KEY_BYTES) + BLOCK_CIPHER_TEXT_TLV_SIZE(field1_data_size) +MAC_TLV_SIZE(MAC_SIZE); //initialize Msg1 Header msg1_header->protocol = SE_EPID_PROVISIONING; msg1_header->type = TYPE_PROV_MSG1; msg1_header->version = TLV_VERSION_2; if(0!=memcpy_s(msg1_header->xid, sizeof(msg1_header->xid), xid, XID_SIZE)){ AESM_DBG_FATAL("fail in memcpy_s"); return PVE_UNEXPECTED_ERROR; } uint32_t size_in; //use as a tmp size, big endian required in msg header size_in = _htonl(total_size); //copy big endian msg body size into header if(0!=memcpy_s(&msg1_header->size, sizeof(msg1_header->size),&size_in, sizeof(size_in))){ AESM_DBG_FATAL("fail in memcpy_s"); return PVE_UNEXPECTED_ERROR; } if(total_size +sizeof(*msg1_header) >msg1_buffer_size){ //the input msg body size is not large enough AESM_DBG_ERROR("Too small ProvMsg1 buffer size"); return PVE_INSUFFICIENT_MEMORY_ERROR; } return AE_SUCCESS; }
void tcp_send_syn(struct tcp_sock *tsk, struct tcp_segment *seg) { /* * SYN-SENT: */ struct tcp *otcp; struct pkbuf *opkb; opkb = alloc_pkb(ETH_HRD_SZ + IP_HRD_SZ + TCP_HRD_SZ); /* fill tcp head */ otcp = (struct tcp *)pkb2ip(opkb)->ip_data; otcp->src = tsk->sk.sk_sport; otcp->dst = tsk->sk.sk_dport; otcp->doff = TCP_HRD_DOFF; otcp->seq = _htonl(tsk->iss); otcp->syn = 1; otcp->window = _htons(tsk->rcv_wnd); tcpdbg("send SYN(%u) [WIN %d] to "IPFMT":%d", _ntohl(otcp->seq), _ntohs(otcp->window), ipfmt(tsk->sk.sk_daddr), _ntohs(otcp->dst)); tcp_send_out(tsk, opkb, seg); }
// // get_sgx_gid // // get sgx gid from epid blob, specifically from stored group cert in epid blob // // inputs // // pgid: pointer to gid // // outputs // // *pgid: gid // status // ae_error_t EPIDBlob::get_sgx_gid(uint32_t* pgid) { ae_error_t aesm_result = AE_SUCCESS; epid_blob_with_cur_psvn_t epid_blob; sgx_sealed_data_t *sealed_epid = reinterpret_cast<sgx_sealed_data_t *>(epid_blob.trusted_epid_blob); if (NULL != pgid) { // // get the epid blob // aesm_result = this->read(epid_blob); if (AE_SUCCESS == aesm_result) { // // get the gid // uint32_t plain_text_offset = sealed_epid->plain_text_offset; se_plaintext_epid_data_t* plain_text = reinterpret_cast<se_plaintext_epid_data_t *>(epid_blob.trusted_epid_blob + sizeof(sgx_sealed_data_t) + plain_text_offset); if(memcpy_s(pgid, sizeof(*pgid), &plain_text->epid_group_cert.gid, sizeof(plain_text->epid_group_cert.gid))) //read gid from EPID Data blob { AESM_DBG_ERROR("memcpy_s failed"); aesm_result = AE_FAILURE; } // // return little-endian // *pgid = _htonl(*pgid); AESM_DBG_TRACE(": get gid %d from epid blob", *pgid); } } else { aesm_result = AE_INVALID_PARAMETER; } return aesm_result; }
void __cdecl CAimProto::aim_proxy_helper(void* param) { file_transfer *ft = (file_transfer*)param; if (ft->requester) { if (proxy_initialize_send(ft->hConn, username, ft->icbm_cookie)) return;//error } else { if (proxy_initialize_recv(ft->hConn, username, ft->icbm_cookie, ft->port)) return;//error } //start listen for packets stuff NETLIBPACKETRECVER packetRecv = {0}; packetRecv.cbSize = sizeof(packetRecv); packetRecv.dwTimeout = INFINITE; HANDLE hServerPacketRecver = (HANDLE) CallService(MS_NETLIB_CREATEPACKETRECVER, (WPARAM)ft->hConn, 2048 * 4); for (;;) { int recvResult = CallService(MS_NETLIB_GETMOREPACKETS, (WPARAM)hServerPacketRecver, (LPARAM)&packetRecv); if (recvResult == 0) { sendBroadcast(ft->hContact, ACKTYPE_FILE, ACKRESULT_FAILED, ft, 0); break; } if (recvResult == SOCKET_ERROR) { sendBroadcast(ft->hContact, ACKTYPE_FILE, ACKRESULT_FAILED, ft, 0); break; } if (recvResult > 0) { unsigned short length = _htons(*(unsigned short*)&packetRecv.buffer[0]); packetRecv.bytesUsed = length + 2; unsigned short type = _htons(*(unsigned short*)&packetRecv.buffer[4]); if (type == 0x0001) { unsigned short error = _htons(*(unsigned short*)&packetRecv.buffer[12]); switch (error) { case 0x000D: ShowPopup("Proxy Server File Transfer Error: Bad Request.", ERROR_POPUP); break; case 0x0010: ShowPopup("Proxy Server File Transfer Error: Initial Request Timed Out.", ERROR_POPUP); break; case 0x001A: ShowPopup("Proxy Server File Transfer Error: Accept Period Timed Out.", ERROR_POPUP); break; case 0x000e: ShowPopup("Proxy Server File Transfer Error: Incorrect command syntax.", ERROR_POPUP); break; case 0x0016: ShowPopup("Proxy Server File Transfer Error: Unknown command issued.", ERROR_POPUP); break; } } else if (type == 0x0003) { unsigned short port = _htons(*(unsigned short*)&packetRecv.buffer[12]); unsigned long ip = _htonl(*(unsigned long*)&packetRecv.buffer[14]); aim_send_file(hServerConn, seqno, ip, port, true, ft); LOG("Stage %d Proxy ft and we are not the sender.", ft->req_num); } else if (type == 0x0005) { if (!ft->requester) { aim_file_ad(hServerConn, seqno, ft->sn, ft->icbm_cookie, false, ft->max_ver); ft->accepted = true; } sendBroadcast(ft->hContact, ACKTYPE_FILE, ACKRESULT_CONNECTED, ft, 0); int i; for (i = 21; --i; ) { if (Miranda_Terminated()) return; Sleep(100); if (ft->accepted) break; } if (i == 0) { sendBroadcast(ft->hContact, ACKTYPE_FILE, ACKRESULT_FAILED, ft, 0); break; } packetRecv.dwTimeout = 350000; int result; if (ft->sending)//we are sending result = sending_file(ft, hServerPacketRecver, packetRecv); else result = receiving_file(ft, hServerPacketRecver, packetRecv); sendBroadcast(ft->hContact, ACKTYPE_FILE, result ? ACKRESULT_FAILED : ACKRESULT_SUCCESS, ft, 0); break; } } } Netlib_CloseHandle(hServerPacketRecver); Netlib_CloseHandle(ft->hConn); ft_list.remove_by_ft(ft); }
unsigned long SNAC::ulong(int pos) { return _htonl(*(unsigned long*)&value_[pos]); }
extern "C" __declspec(dllexport) const PLUGININFOEX* MirandaPluginInfoEx(DWORD mirandaVersion) { *(unsigned long*)(&AIM_CAP_MIRANDA[8]) = _htonl(mirandaVersion); *(unsigned long*)(&AIM_CAP_MIRANDA[12]) = _htonl(PLUGIN_MAKE_VERSION(__MAJOR_VERSION, __MINOR_VERSION, __RELEASE_NUM, __BUILD_NUM)); return &pluginInfo; }
/** * \brief Main application function. * * Initialize system, UART console, network then start time client. * * \return Program return value. */ int main(void) { tstrWifiInitParam param; int8_t ret; struct sockaddr_in addr_in; /* Initialize the board. */ system_init(); /* Initialize the UART console. */ configure_console(); printf(STRING_HEADER); /* Initialize the BSP. */ nm_bsp_init(); /* Initialize Wi-Fi parameters structure. */ memset((uint8_t *)¶m, 0, sizeof(tstrWifiInitParam)); /* Initialize Wi-Fi driver with data and status callbacks. */ param.pfAppWifiCb = wifi_cb; ret = m2m_wifi_init(¶m); if (M2M_SUCCESS != ret) { printf("main: m2m_wifi_init call error!(%d)\r\n", ret); while (1) { } } /* Turn LED0 off initially. */ port_pin_set_output_level(LED_0_PIN, true); /* Initialize Socket module */ socketInit(); /* Register socket handler, resolve handler */ registerSocketCallback(socket_cb, resolve_cb); /* Connect to router. */ m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID), MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL); while (1) { /* Handle pending events from network controller. */ m2m_wifi_handle_events(NULL); if (gbConnectedWifi) { /* * Create the socket for the first time. */ if (udp_socket < 0) { udp_socket = socket(AF_INET, SOCK_DGRAM, 0); if (udp_socket < 0) { printf("main: UDP Client Socket Creation Failed.\r\n"); continue; } /* Initialize default socket address structure. */ addr_in.sin_family = AF_INET; addr_in.sin_addr.s_addr = _htonl(MAIN_DEFAULT_ADDRESS); addr_in.sin_port = _htons(MAIN_DEFAULT_PORT); bind(udp_socket, (struct sockaddr *)&addr_in, sizeof(struct sockaddr_in)); } } } return 0; }
// used when requesting a regular file transfer int CAimProto::aim_send_file(HANDLE hServerConn, unsigned short &seqno, unsigned long ip, unsigned short port, bool force_proxy, file_transfer *ft) { char msg_frag[2048]; unsigned short frag_offset = 0; aim_writeshort(0, frag_offset, msg_frag); // request type aim_writegeneric(8, ft->icbm_cookie, frag_offset, msg_frag); // icbm cookie aim_writegeneric(AIM_CAPS_LENGTH, AIM_CAP_FILE_TRANSFER, frag_offset, msg_frag); // uuid aim_writetlvshort(0x0a, ++ft->req_num, frag_offset, msg_frag); // request number aim_writetlvlong(0x02, ip, frag_offset, msg_frag); // ip aim_writetlvlong(0x16, ~ip, frag_offset, msg_frag); // ip check aim_writetlvshort(0x05, port, frag_offset, msg_frag); // port aim_writetlvshort(0x17, ~port, frag_offset, msg_frag); // port ip check if (force_proxy) aim_writetlv(0x10, 0, 0, frag_offset, msg_frag); // request proxy transfer else aim_writetlvlong(0x03, m_internal_ip, frag_offset, msg_frag); // ip if (ft->req_num == 1) { if (ft->message) { aimString dscr(ft->message); const char* charset = dscr.isUnicode() ? "unicode-2-0" : "us-ascii"; const unsigned short charset_len = (unsigned short)mir_strlen(charset); const char* desc_msg = dscr.getBuf(); const unsigned short desc_len = dscr.getSize(); aim_writetlv(0x0e, 2, "en", frag_offset, msg_frag); // language used by the data aim_writetlv(0x0d, charset_len, charset, frag_offset, msg_frag);// charset used by the data aim_writetlv(0x0c, desc_len, desc_msg, frag_offset, msg_frag); // invitaion text } aim_writetlv(0x0f, 0, 0, frag_offset, msg_frag); // request host check const char* fname = get_fname(ft->file); const unsigned short fnlen = (unsigned short)mir_strlen(fname); char* fblock = (char*)alloca(9 + fnlen); *(unsigned short*)&fblock[0] = _htons(ft->pfts.totalFiles > 1 ? 2 : 1); // single file transfer *(unsigned short*)&fblock[2] = _htons(ft->pfts.totalFiles); // number of files *(unsigned long*)&fblock[4] = _htonl(ft->pfts.totalBytes); // total bytes in files memcpy(&fblock[8], fname, fnlen + 1); const char* enc = is_utf(fname) ? "utf-8" : "us-ascii"; aim_writetlv(0x2711, 9 + fnlen, fblock, frag_offset, msg_frag); // extra data, file names, size aim_writetlv(0x2712, 8, enc, frag_offset, msg_frag); // character set used by data // aim_writetlvlong64(0x2713,ft->pfts.totalBytes,frag_offset,msg_frag); // file length debugLogA("Attempting to Send a file to a buddy."); } else { aim_writetlvshort(0x14, 0x0a, frag_offset, msg_frag); // Counter proposal reason } unsigned short offset = 0; unsigned short sn_length = (unsigned short)mir_strlen(ft->sn); char* buf = (char*)alloca(SNAC_SIZE + TLV_HEADER_SIZE * 2 + 12 + frag_offset + sn_length); aim_writesnac(0x04, 0x06, offset, buf); // msg to host aim_writegeneric(8, ft->icbm_cookie, offset, buf); // icbm cookie aim_writeshort(2, offset, buf); // icbm channel aim_writechar((unsigned char)sn_length, offset, buf); // screen name length aim_writegeneric(sn_length, ft->sn, offset, buf); // screen name aim_writetlv(0x05, frag_offset, msg_frag, offset, buf); // icbm tags aim_writetlv(0x03, 0, 0, offset, buf); // request ack char cip[20]; long_ip_to_char_ip(ip, cip); debugLogA("IP for Buddy to connect to: %s:%u", cip, port); return aim_sendflap(hServerConn, 0x02, offset, buf, seqno) == 0; }
int CAimProto::receiving_file(file_transfer *ft, HANDLE hServerPacketRecver, NETLIBPACKETRECVER &packetRecv) { debugLogA("P2P: Entered file receiving thread."); bool failed = true; bool failed_conn = false; bool accepted_file = false; int fid = -1; oft2 *oft = NULL; ft->pfts.tszWorkingDir = mir_utf8decodeT(ft->file); //start listen for packets stuff for (;;) { int recvResult = packetRecv.bytesAvailable - packetRecv.bytesUsed; if (recvResult <= 0) recvResult = CallService(MS_NETLIB_GETMOREPACKETS, (WPARAM)hServerPacketRecver, (LPARAM)&packetRecv); if (recvResult == 0) { debugLogA("P2P: File transfer connection Error: 0"); break; } if (recvResult == SOCKET_ERROR) { failed_conn = true; debugLogA("P2P: File transfer connection Error: -1"); break; } if (recvResult > 0) { if (!accepted_file) { if (recvResult < 0x100) continue; oft2* recv_ft = (oft2*)&packetRecv.buffer[packetRecv.bytesUsed]; unsigned short pkt_len = _htons(recv_ft->length); if (recvResult < pkt_len) continue; packetRecv.bytesUsed += pkt_len; unsigned short type = _htons(recv_ft->type); if (type == 0x0101) { debugLogA("P2P: Buddy Ready to begin transfer."); oft = (oft2*)mir_realloc(oft, pkt_len); memcpy(oft, recv_ft, pkt_len); memcpy(oft->icbm_cookie, ft->icbm_cookie, 8); int buflen = pkt_len - 0x100 + 64; char *buf = (char*)mir_calloc(buflen + 2); unsigned short enc; ft->pfts.currentFileSize = _htonl(recv_ft->size); ft->pfts.totalBytes = _htonl(recv_ft->total_size); ft->pfts.currentFileTime = _htonl(recv_ft->mod_time); memcpy(buf, recv_ft->filename, buflen); enc = _htons(recv_ft->encoding); TCHAR *name; if (enc == 2) { wchar_t* wbuf = (wchar_t*)buf; wcs_htons(wbuf); for (wchar_t *p = wbuf; *p; ++p) { if (*p == 1) *p = '\\'; } name = mir_u2t(wbuf); } else { for (char *p = buf; *p; ++p) { if (*p == 1) *p = '\\'; } name = mir_a2t(buf); } mir_free(buf); TCHAR fname[256]; mir_sntprintf(fname, _T("%s%s"), ft->pfts.tszWorkingDir, name); mir_free(name); mir_free(ft->pfts.tszCurrentFile); ft->pfts.tszCurrentFile = mir_tstrdup(fname); ResetEvent(ft->hResumeEvent); if (ProtoBroadcastAck(ft->hContact, ACKTYPE_FILE, ACKRESULT_FILERESUME, ft, (LPARAM)&ft->pfts)) WaitForSingleObject(ft->hResumeEvent, INFINITE); if (ft->pfts.tszCurrentFile) { TCHAR* dir = get_dir(ft->pfts.tszCurrentFile); CreateDirectoryTreeT(dir); mir_free(dir); oft->type = _htons(ft->pfts.currentFileProgress ? 0x0205 : 0x0202); const int flag = ft->pfts.currentFileProgress ? 0 : _O_TRUNC; fid = _topen(ft->pfts.tszCurrentFile, _O_CREAT | _O_WRONLY | _O_BINARY | flag, _S_IREAD | _S_IWRITE); if (fid < 0) { report_file_error(fname); break; } accepted_file = ft->pfts.currentFileProgress == 0; if (ft->pfts.currentFileProgress) { bool the_same; oft->recv_bytes = _htonl(ft->pfts.currentFileProgress); oft->recv_checksum = _htonl(aim_oft_checksum_file(ft->pfts.tszCurrentFile)); the_same = oft->size == oft->recv_bytes && oft->checksum == oft->recv_checksum; if (the_same) { ft->pfts.totalProgress += ft->pfts.currentFileProgress; oft->type = _htons(0x0204); _close(fid); ProtoBroadcastAck(ft->hContact, ACKTYPE_FILE, ACKRESULT_NEXTFILE, ft, 0); ++ft->pfts.currentFileNumber; ft->pfts.currentFileProgress = 0; } } } else { oft->type = _htons(0x0204); ProtoBroadcastAck(ft->hContact, ACKTYPE_FILE, ACKRESULT_NEXTFILE, ft, 0); ++ft->pfts.currentFileNumber; ft->pfts.currentFileProgress = 0; } if (Netlib_Send(ft->hConn, (char*)oft, pkt_len, 0) == SOCKET_ERROR) break; if (ft->pfts.currentFileNumber >= ft->pfts.totalFiles && _htons(oft->type) == 0x0204) { failed = false; break; } } else if (type == 0x0106) { oft = (oft2*)mir_realloc(oft, pkt_len); memcpy(oft, recv_ft, pkt_len); ft->pfts.currentFileProgress = _htonl(oft->recv_bytes); ft->pfts.totalProgress += ft->pfts.currentFileProgress; _lseeki64(fid, ft->pfts.currentFileProgress, SEEK_SET); accepted_file = true; oft->type = _htons(0x0207); if (Netlib_Send(ft->hConn, (char*)oft, pkt_len, 0) == SOCKET_ERROR) break; } else break; } else { packetRecv.bytesUsed = packetRecv.bytesAvailable; _write(fid, packetRecv.buffer, packetRecv.bytesAvailable); ft->pfts.currentFileProgress += packetRecv.bytesAvailable; ft->pfts.totalProgress += packetRecv.bytesAvailable; ProtoBroadcastAck(ft->hContact, ACKTYPE_FILE, ACKRESULT_DATA, ft, (LPARAM)&ft->pfts); if (ft->pfts.currentFileSize == ft->pfts.currentFileProgress) { oft->type = _htons(0x0204); oft->recv_bytes = _htonl(ft->pfts.currentFileProgress); oft->recv_checksum = _htonl(aim_oft_checksum_file(ft->pfts.tszCurrentFile)); debugLogA("P2P: We got the file successfully"); Netlib_Send(ft->hConn, (char*)oft, _htons(oft->length), 0); if (_htons(oft->num_files_left) == 1) { failed = false; break; } else { accepted_file = false; _close(fid); ProtoBroadcastAck(ft->hContact, ACKTYPE_FILE, ACKRESULT_NEXTFILE, ft, 0); ++ft->pfts.currentFileNumber; ft->pfts.currentFileProgress = 0; } } } } } if (accepted_file) _close(fid); mir_free(oft); ft->success = !failed; return failed ? (failed_conn ? 1 : 2) : 0; }
int CAimProto::sending_file(file_transfer *ft, HANDLE hServerPacketRecver, NETLIBPACKETRECVER &packetRecv) { debugLogA("P2P: Entered file sending thread."); bool failed = true; bool failed_conn = false; if (!setup_next_file_send(ft)) return 2; debugLogA("Sent file information to buddy."); //start listen for packets stuff for (;;) { int recvResult = packetRecv.bytesAvailable - packetRecv.bytesUsed; if (recvResult <= 0) recvResult = CallService(MS_NETLIB_GETMOREPACKETS, (WPARAM)hServerPacketRecver, (LPARAM)&packetRecv); if (recvResult == 0) { debugLogA("P2P: File transfer connection Error: 0"); break; } if (recvResult == SOCKET_ERROR) { failed_conn = true; debugLogA("P2P: File transfer connection Error: -1"); break; } if (recvResult > 0) { if (recvResult < 0x100) continue; oft2* recv_ft = (oft2*)&packetRecv.buffer[packetRecv.bytesUsed]; unsigned short pkt_len = _htons(recv_ft->length); if (recvResult < pkt_len) continue; packetRecv.bytesUsed += pkt_len; unsigned short type = _htons(recv_ft->type); if (type == 0x0202 || type == 0x0207) { debugLogA("P2P: Buddy Accepts our file transfer."); int fid = _topen(ft->pfts.tszCurrentFile, _O_RDONLY | _O_BINARY, _S_IREAD); if (fid < 0) { report_file_error(ft->pfts.tszCurrentFile); return 2; } if (ft->pfts.currentFileProgress) _lseeki64(fid, ft->pfts.currentFileProgress, SEEK_SET); NETLIBSELECT tSelect = { 0 }; tSelect.cbSize = sizeof(tSelect); tSelect.hReadConns[0] = ft->hConn; ProtoBroadcastAck(ft->hContact, ACKTYPE_FILE, ACKRESULT_DATA, ft, (LPARAM)&ft->pfts); clock_t lNotify = clock(); for (;;) { char buffer[4096]; int bytes = _read(fid, buffer, sizeof(buffer)); if (bytes <= 0) break; if (Netlib_Send(ft->hConn, buffer, bytes, MSG_NODUMP) <= 0) break; ft->pfts.currentFileProgress += bytes; ft->pfts.totalProgress += bytes; if (clock() >= lNotify) { ProtoBroadcastAck(ft->hContact, ACKTYPE_FILE, ACKRESULT_DATA, ft, (LPARAM)&ft->pfts); if (CallService(MS_NETLIB_SELECT, 0, (LPARAM)&tSelect)) break; lNotify = clock() + 500; } } ProtoBroadcastAck(ft->hContact, ACKTYPE_FILE, ACKRESULT_DATA, ft, (LPARAM)&ft->pfts); debugLogA("P2P: Finished sending file bytes."); _close(fid); } else if (type == 0x0204) { // Handle file skip case if (ft->pfts.currentFileProgress == 0) { ft->pfts.totalProgress += ft->pfts.currentFileSize; } debugLogA("P2P: Buddy says they got the file successfully"); if ((ft->pfts.currentFileNumber + 1) < ft->pfts.totalFiles) { ProtoBroadcastAck(ft->hContact, ACKTYPE_FILE, ACKRESULT_NEXTFILE, ft, 0); ++ft->pfts.currentFileNumber; ++ft->cf; if (!setup_next_file_send(ft)) { report_file_error(ft->pfts.tszCurrentFile); return 2; } } else { failed = _htonl(recv_ft->recv_bytes) != ft->pfts.currentFileSize; break; } } else if (type == 0x0205) { recv_ft = (oft2*)packetRecv.buffer; recv_ft->type = _htons(0x0106); ft->pfts.currentFileProgress = _htonl(recv_ft->recv_bytes); if (aim_oft_checksum_file(ft->pfts.tszCurrentFile, ft->pfts.currentFileProgress) != _htonl(recv_ft->recv_checksum)) { ft->pfts.currentFileProgress = 0; recv_ft->recv_bytes = 0; } debugLogA("P2P: Buddy wants us to start sending at a specified file point. (%I64u)", ft->pfts.currentFileProgress); if (Netlib_Send(ft->hConn, (char*)recv_ft, _htons(recv_ft->length), 0) <= 0) break; ft->pfts.totalProgress += ft->pfts.currentFileProgress; ProtoBroadcastAck(ft->hContact, ACKTYPE_FILE, ACKRESULT_DATA, ft, (LPARAM)&ft->pfts); } } } ft->success = !failed; return failed ? (failed_conn ? 1 : 2) : 0; }
/** * \brief Main application function. * * Initialize system, UART console, network then start function of UDP socket. * * \return program return value. */ int main(void) { tstrWifiInitParam param; int8_t ret; struct sockaddr_in addr; /* Initialize the board. */ sysclk_init(); board_init(); /* Initialize the UART console. */ configure_console(); printf(STRING_HEADER); /* Initialize the BSP. */ nm_bsp_init(); /* Initialize socket address structure. */ addr.sin_family = AF_INET; addr.sin_port = _htons(MAIN_WIFI_M2M_SERVER_PORT); addr.sin_addr.s_addr = _htonl(MAIN_WIFI_M2M_SERVER_IP); /* Initialize Wi-Fi parameters structure. */ memset((uint8_t *)¶m, 0, sizeof(tstrWifiInitParam)); /* Initialize Wi-Fi driver with data and status callbacks. */ param.pfAppWifiCb = wifi_cb; ret = m2m_wifi_init(¶m); if (M2M_SUCCESS != ret) { printf("main: m2m_wifi_init call error!(%d)\r\n", ret); while (1) { } } /* Initialize socket module */ socketInit(); registerSocketCallback(socket_cb, NULL); /* Connect to router. */ m2m_wifi_connect((char *)MAIN_WLAN_SSID, sizeof(MAIN_WLAN_SSID), MAIN_WLAN_AUTH, (char *)MAIN_WLAN_PSK, M2M_WIFI_CH_ALL); packetCnt = 0; while (1) { if (packetCnt >= MAIN_WIFI_M2M_PACKET_COUNT) { printf("UDP Server test Complete!\r\n"); close(rx_socket); rx_socket = -1; break; } m2m_wifi_handle_events(NULL); if (wifi_connected == M2M_WIFI_CONNECTED) { /* Create socket for Rx UDP */ if (rx_socket < 0) { if ((rx_socket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { printf("main : failed to create RX UDP Client socket error!\r\n"); continue; } /* Socket bind */ bind(rx_socket, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)); } } } return 0; }