sock_result_t socket_send_ex(sock_handle_t sd, const void* buffer, socklen_t len, uint32_t flags, system_tick_t timeout, void* reserved)
{
sock_result_t result = SOCKET_INVALID;
socket_t* socket = from_handle(sd);
uint16_t bytes_sent = 0;
if (is_open(socket)) {
std::lock_guard<socket_t> lk(*socket);
wiced_result_t wiced_result = WICED_TCPIP_INVALID_SOCKET;
if (is_tcp(socket)) {
wiced_tcp_send_flags_t wiced_flags = timeout == 0 ? WICED_TCP_SEND_FLAG_NONBLOCK : WICED_TCP_SEND_FLAG_NONE;
bytes_sent = (uint16_t)len;
wiced_result = wiced_tcp_send_buffer_ex(tcp(socket), buffer, &bytes_sent, wiced_flags, timeout);
}
else if (is_client(socket)) {
tcp_server_client_t* server_client = client(socket);
size_t written = 0;
wiced_result = server_client->write(buffer, len, &written, flags, timeout);
bytes_sent = (uint16_t)written;
}
if (!wiced_result)
DEBUG("Write %d bytes to socket %d result=%d", (int)len, (int)sd, wiced_result);
result = wiced_result ? as_sock_result(wiced_result) : bytes_sent;
}
return result;
}
wiced_tcp_socket_t* as_wiced_tcp_socket(socket_t* socket)
{
if (is_tcp(socket)) {
return tcp(socket);
}
else if (is_client(socket)) {
return socket->s.tcp_client->get_socket();
}
return NULL;
}
void mod_addr_version(const IP::Addr& addr)
{
switch (addr.version())
{
case IP::Addr::UNSPEC:
break;
case IP::Addr::V4:
if (is_udp())
type_ = UDPv4;
else if (is_tcp())
type_ = TCPv4;
break;
case IP::Addr::V6:
if (is_udp())
type_ = UDPv6;
else if (is_tcp())
type_ = TCPv6;
break;
}
}
sock_result_t socket_shutdown(sock_handle_t sd, int how)
{
sock_result_t result = WICED_ERROR;
socket_t* socket = from_handle(sd);
if (socket && is_open(socket) && is_tcp(socket)) {
std::lock_guard<socket_t> lk(*socket);
result = wiced_tcp_close_shutdown(tcp(socket), (wiced_tcp_shutdown_flags_t)how);
LOG_DEBUG(TRACE, "socket shutdown %x %x", sd, how);
}
return result;
}
void ListenAllTcp( struct ServiceArray* service_array )
{
// for each service
int i;
for (i = 0; i < service_array->size; ++i)
{
struct Service* service = &( service_array->services[i] );
if( is_tcp( service ) )
listen( service->socketfd, BACKLOG );
}
}
void callback(unsigned char *user, const struct pcap_pkthdr *h, const unsigned char *bytes)
{
int len;
const unsigned char *buf;
const unsigned char *cur;
unsigned char url[1024];
int url_len = 0;
char data[1400];
int is_req;
int hdr_len;
int ret;
buf = bytes;
len = h->caplen;
cur = buf;
if (!is_tcp(buf, len)){
return;
}
cur += 54;
len -= 54;//tcp hdr ip hdr
is_req = is_http_request(cur, len);
hdr_len = http_hdr_len(cur, len);
switch (is_req){
case 0:
break;
case 1:
ret = get_url(url,&url_len, cur, hdr_len);
if (ret == 0){
logging(url,url_len);
//printf("url_len:%d\n",url_len);
}
break;
case 2:
ret = get_url(url,&url_len, cur, hdr_len);
if (ret == 0){
logging(url,url_len);
}
//get_data(data, curl, len);
break;
default:
break;
}
}
/**
* Receives data from a socket.
* @param sd
* @param buffer
* @param len
* @param _timeout
* @return The number of bytes read. -1 if the end of the stream is reached.
*/
sock_result_t socket_receive(sock_handle_t sd, void* buffer, socklen_t len, system_tick_t _timeout)
{
sock_result_t bytes_read = -1;
socket_t* socket = from_handle(sd);
if (is_open(socket)) {
std::lock_guard<socket_t> lk(*socket);
if (is_tcp(socket)) {
tcp_socket_t* tcp_socket = tcp(socket);
tcp_packet_t& packet = tcp_socket->packet;
bytes_read = read_packet_and_dispose(packet, buffer, len, tcp_socket, _timeout);
}
else if (is_client(socket)) {
tcp_server_client_t* server_client = client(socket);
bytes_read = read_packet_and_dispose(server_client->packet, buffer, len, server_client->get_socket(), _timeout);
}
}
if (bytes_read<0)
DEBUG("socket_receive on %d returned %d", sd, bytes_read);
return bytes_read;
}
/* for constructing a packet that is captured */
void Packet::build_pkt(const uint8_t *b, uint16_t len)
{
reset();
memcpy(buf_, b, len);
payload = buf_;
ip_hdr = (struct ip*)buf_;
if(is_tcp())
{
tcp_hdr = (struct tcphdr*)((uint8_t *)(ip_hdr) + get_ip_hdr_len());
set_payload((uint8_t *)((uint8_t *)(tcp_hdr) + get_tcp_hdr_len()));
}
else if (is_icmp())
{
icmp_hdr = (struct icmphdr*)((uint8_t *)(ip_hdr) + get_ip_hdr_len());
set_payload((uint8_t *)((uint8_t *)(icmp_hdr) + ICMP_H));
}
else
{
logger->PrintErr("[%s:%d] Only support TCP/ICMP/IP now!\n", __FILE__, __LINE__);
}
}
uint8_t* Packet::get_tcp_opt(uint8_t opt)
{
uint16_t len;
uint8_t* tcp_opt;
uint8_t* p;
if(!is_tcp())
{
return NULL;
}
if((len=get_tcp_opt_len()) <= 0)
{
return NULL;
}
p = tcp_opt = (uint8_t*)tcp_hdr + TCP_H;
while (p<(tcp_opt+len))
{
if(*p==opt)
{
return p+2;
}
switch(*p)
{
case TCPOPT_EOL:
case TCPOPT_NOP:
p++;
break;
default:
p+=*(p+1);
break;
}
}
return NULL;
}
uint16_t Packet::get_tcp_payload_len()
{
return (is_tcp())?(get_ip_len()-get_ip_hdr_len()-get_tcp_hdr_len()):0;
}
bool Packet::is_tcp_urg()
{
return is_tcp() && tcp_hdr->urg > 0;
}
bool Packet::is_tcp_ack()
{
return is_tcp() && tcp_hdr->ack > 0;
}
bool Packet::is_tcp_psh()
{
return is_tcp() && tcp_hdr->psh > 0;
}
bool Packet::is_tcp_rst()
{
return is_tcp() && tcp_hdr->rst > 0;
}
bool Packet::is_tcp_syn()
{
return is_tcp() && tcp_hdr->syn > 0;
}
bool Packet::is_tcp_fin()
{
return is_tcp() && tcp_hdr->fin > 0;
}
static bool
pred_is_tcp(arguments_t args, SkBuff b)
{
return is_tcp(b);
}
bool is_reliable() const { return is_tcp(); }
unsigned int extra_transport_bytes() const
{
return is_tcp() ? sizeof(boost::uint16_t) : 0;
}
inline tcp_socket_t* tcp(socket_t* socket) { return is_tcp(socket) ? &socket->s.tcp : NULL; }
