Пример #1
0
ssize_t
eth_send(eth_t *eth, const void *buf, size_t len)
{
	PacketInitPacket(eth->pkt, (void *)buf, (UINT) len);
	PacketSendPacket(eth->lpa, eth->pkt, TRUE);
	return ((ssize_t) len);
}
Пример #2
0
void WritePacket(int Snaplen)
{
    LPPACKET lpPacket = 0;   // define a pointer to a PACKET structure

    if (Snaplen > sizeof(tx_buffer)) Snaplen = sizeof(tx_buffer);
    lpPacket = CreatePacket((char*)tx_buffer, Snaplen);
    PacketSetNumWrites(lpAdapter, 1);
    PacketSendPacket(lpAdapter, lpPacket, TRUE);
    ReleasePacket(lpPacket);
}
Пример #3
0
INT PacketSendPackets(LPADAPTER AdapterObject, 
					   PVOID PacketBuff, 
					   ULONG Size, 
					   BOOLEAN Sync)
{
	struct dump_bpf_hdr	*winpcap_hdr;
	PCHAR	EndOfUserBuff = (PCHAR)PacketBuff + Size;
	LPPACKET PacketToSend;
	BOOLEAN res;

	// Start from the first packet
	winpcap_hdr = (struct dump_bpf_hdr*)PacketBuff;

	if( (PCHAR)winpcap_hdr + winpcap_hdr->caplen + sizeof(struct dump_bpf_hdr) > EndOfUserBuff )
	{
		// Malformed buffer
		return 0;
	}

	while( TRUE ){
		
		if(winpcap_hdr->caplen ==0 || winpcap_hdr->caplen > 65536)
		{
			// Malformed header
			return 0;
		}
		
		// Set up the LPPACKET structure
		PacketToSend=PacketAllocatePacket();
		PacketInitPacket(PacketToSend,
			(PCHAR)winpcap_hdr + sizeof(struct dump_bpf_hdr),
			winpcap_hdr->caplen);

		// Send the packet
		res = PacketSendPacket (AdapterObject,	PacketToSend, TRUE);

		// Free the just used LPPACKET structure
		PacketFreePacket(PacketToSend);

		if(res == FALSE){
			// Error sending the packet
			return (PCHAR)winpcap_hdr - (PCHAR)PacketBuff;
		}

		
		// Step to the next packet in the buffer
		(PCHAR)winpcap_hdr += winpcap_hdr->caplen + sizeof(struct dump_bpf_hdr);
		
		// Check if the end of the user buffer has been reached
		if( (PCHAR)winpcap_hdr >= EndOfUserBuff )
		{				
				return (PCHAR)winpcap_hdr - (PCHAR)PacketBuff;
		}
	}
}
Пример #4
0
long sockSendData(void *pData, int Size) {
	u8 *data = (u8*)pData;
//	printf("_sendPacket %d (time=%d)\n", Size, timeGetTime());
	while (Size > 0) {
		PacketInitPacket(lpSendPacket, data, Size > 1024 ? 1024 : Size);
		if(PacketSendPacket(lpAdapter,lpSendPacket,FALSE)==FALSE){
			printf("Error: PacketSendPacket failed\n");
			return (-1);
		}
		data+= 1024; Size-= 1024;
		PacketFreePacket(lpSendPacket);
	}

	return 0;
}
Пример #5
0
static unsigned int WINAPI ether_thread_write_packets(void *arg)
{
	LPPACKET Packet;

	thread_active_1 = true;

	D(bug("ether_thread_write_packets start\n"));

	while(thread_active) {
		// must be alertable, otherwise write completion is never called
		WaitForSingleObjectEx(int_send_now,INFINITE,TRUE);
		while( thread_active && (Packet = get_send_head()) != 0 ) {
			switch (net_if_type) {
			case NET_IF_ROUTER:
				if(router_write_packet((uint8 *)Packet->Buffer, Packet->Length)) {
					Packet->bIoComplete = TRUE;
					recycle_write_packet(Packet);
				}
				break;
			case NET_IF_FAKE:
				Packet->bIoComplete = TRUE;
				recycle_write_packet(Packet);
				break;
			case NET_IF_B2ETHER:
				if(!PacketSendPacket( fd, Packet, FALSE, TRUE )) {
					// already recycled if async
				}
				break;
			case NET_IF_TAP:
				if (!tap_send_packet(fd, Packet, FALSE, TRUE)) {
					// already recycled if async
				}
				break;
			case NET_IF_SLIRP:
				slirp_input((uint8 *)Packet->Buffer, Packet->Length);
				Packet->bIoComplete = TRUE;
				recycle_write_packet(Packet);
				break;
			}
		}
	}

	D(bug("ether_thread_write_packets exit\n"));

	thread_active_1 = false;

	return(0);
}
Пример #6
0
/**
 * Send a packet
 *
 * @param adapter adapter handle received by a call to init_adapter
 * @param buffer complete packet to send (including ETH header; without CRC)
 * @param len length of the packet (including ETH header; without CRC)
 */
int
packet_send(void *adapter, void *buffer, int len)
{
  struct packet_adapter *pa = (struct packet_adapter*)adapter;
  LPPACKET lpPacket;

  if (pa == NULL) {
    return -1;
  }
  if ((lpPacket = PacketAllocatePacket()) == NULL) {
    return -1;
  }
  PacketInitPacket(lpPacket, buffer, len);
  if (!PacketSendPacket(pa->lpAdapter, lpPacket, TRUE)) {
    return -1;
  }
  PacketFreePacket(lpPacket);

  return 0;
}
Пример #7
0
/* Send a packet to the network */
int 
pcap_sendpacket(pcap_t *p, u_char *buf, int size){
	LPPACKET PacketToSend;

	if (p->adapter==NULL)
	{
		snprintf(p->errbuf, PCAP_ERRBUF_SIZE, "Writing a packet is allowed only on a physical adapter");
		return -1;
	}

	PacketToSend=PacketAllocatePacket();
	PacketInitPacket(PacketToSend,buf,size);
	if(PacketSendPacket(p->adapter,PacketToSend,TRUE) == FALSE){
		PacketFreePacket(PacketToSend);
		return -1;
	}

	PacketFreePacket(PacketToSend);
	return 0;
}
Пример #8
0
void
bx_win32_pktmover_c::sendpkt(void *buf, unsigned io_len)
{
#if BX_ETH_WIN32_LOGGING
    fprintf (pktlog_txt, "a packet from guest to host, length %u\n", io_len);
    Bit8u *charbuf = (Bit8u *)buf;
    unsigned n;
    for (n=0; n<io_len; n++) {
        if (((n % 16) == 0) && n>0)
            fprintf (pktlog_txt, "\n");
        fprintf (pktlog_txt, "%02x ", (unsigned)charbuf[n]);
    }
    fprintf (pktlog_txt, "\n--\n");
    fflush (pktlog_txt);
#endif

    // SendPacket Here.
    PacketInitPacket(pkSend, (char *)buf, io_len);

    if (!PacketSendPacket(lpAdapter, pkSend, TRUE)) {
        fprintf(stderr, "[ETH-WIN32] Error sending packet: %lu\n", GetLastError());
    }
}
Пример #9
0
/*
 * Our WinPcap send function.
 * Not sure if partial writes are possible with NPF. Retry if rc != length.
 */
int pkt_send (const void *tx, int length)
{
  const ADAPTER *adapter;
  PACKET pkt;
  int    tx_cnt, rc = 0;

  ASSERT_PKT_INF (0);

  adapter = (const ADAPTER*) _pkt_inf->adapter;

  PROFILE_START ("pkt_send");

  for (tx_cnt = 1 + pkt_txretries; tx_cnt > 0; tx_cnt--)
  {
    pkt.Buffer = (void*) tx;
    pkt.Length = length;
    if (PacketSendPacket (adapter, &pkt, TRUE))
    {
      rc = length;
      break;
    }
    STAT (macstats.num_tx_retry++);
  }

  if (rc == length)
  {
    num_tx_pkt++;
    num_tx_bytes += length;
  }
  else
  {
    num_tx_errors++;  /* local copy */
    STAT (macstats.num_tx_err++);
  }
  PROFILE_STOP();
  return (rc);
}
//发包
int NetworkInterface::SendPacket(u_char *buffer, int packetLen, int repeatNum)
{
	
	LPPACKET   lpPacket;

	memcpy((buffer + 6), srcMAC, 6);
	//分配并初始化一个包结构,将用于发送数据包
	if ( (lpPacket = PacketAllocatePacket()) == NULL )
	{
		LastErrCode = GetLastError();
		strcpy_s(LastErrStr, "Error: failed to allocate the LPPACKET structure.");
		return (-1);
	}

	PacketInitPacket(lpPacket, buffer, packetLen);

	if (PacketSetNumWrites(adapter.lpAdapter, repeatNum) == FALSE)
	{
		LastErrCode = GetLastError();
		strcpy_s(LastErrStr, "Unable to send more than one packet in a single write!");
		PacketFreePacket(lpPacket);
		return -1;
	}
	
	if(PacketSendPacket(adapter.lpAdapter, lpPacket, TRUE) == FALSE)
	{
		LastErrCode = GetLastError();
		strcpy_s(LastErrStr, "Error sending the packets!");
		PacketFreePacket(lpPacket);
		return -1;
	}
	PacketFreePacket(lpPacket);
	//将发送的数据包转存到文件中
	//PrintPacket(buffer, packetLen, 1);
	return 0;
}
Пример #11
0
int
libnet_win32_write_raw_ipv4(libnet_t *l, const uint8_t *payload, uint32_t payload_s)
{    
    static BYTE dst[ETHER_ADDR_LEN];
    static BYTE src[ETHER_ADDR_LEN];
	
    uint8_t *packet      = NULL;
    uint32_t packet_s;

    LPPACKET lpPacket   = NULL;
    DWORD remoteip      = 0;
    DWORD BytesTransfered;
    NetType type;
    struct libnet_ipv4_hdr *ip_hdr = NULL;
	
    memset(dst, 0, sizeof(dst));
    memset(src, 0, sizeof(src));

    packet_s = payload_s + l->link_offset;
    packet = (uint8_t *)malloc(packet_s);
    if (packet == NULL)
    {
        snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
                "%s(): failed to allocate packet\n", __func__);
        return (-1);
    }
	
    /* we have to do the IP checksum  */
    if (libnet_do_checksum(l, payload, IPPROTO_IP, LIBNET_IPV4_H) == -1)
    {
        /* error msg set in libnet_do_checksum */
        return (-1);
    } 

    /* MACs, IPs and other stuff... */
    ip_hdr = (struct libnet_ipv4_hdr *)payload;
    memcpy(src, libnet_get_hwaddr(l), sizeof(src));
    remoteip = ip_hdr->ip_dst.S_un.S_addr;
		
    /* check if the remote station is the local station */
    if (remoteip == libnet_get_ipaddr4(l))
    {
        memcpy(dst, src, sizeof(dst));
    }
    else
    {
        memcpy(dst, libnet_win32_get_remote_mac(l, remoteip), sizeof(dst));
    }

    PacketGetNetType(l->lpAdapter, &type);
	
    switch(type.LinkType)
    {
        case NdisMedium802_3:
            libnet_win32_build_fake_ethernet(dst, src, ETHERTYPE_IP, payload,
                    payload_s, packet, l , 0);
            break;
        case NdisMedium802_5:
            libnet_win32_build_fake_token(dst, src, ETHERTYPE_IP, payload,
                    payload_s, packet, l, 0);
            break;
        case NdisMediumFddi:
            break;
        case NdisMediumWan:
        case NdisMediumAtm:
        case NdisMediumArcnet878_2:
        default:
            snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
                "%s(): network type (%d) is not supported\n", __func__,
                type.LinkType);
            return (-1);
            break;
    }    

    BytesTransfered = -1;
    if ((lpPacket = PacketAllocatePacket()) == NULL)
    {
        snprintf(l->err_buf, LIBNET_ERRBUF_SIZE,
                "%s(): failed to allocate the LPPACKET structure\n", __func__);
	    return (-1);
    }
    
    PacketInitPacket(lpPacket, packet, packet_s);

    /* PacketSendPacket returns a BOOLEAN */
    if (PacketSendPacket(l->lpAdapter, lpPacket, TRUE))
    {
        BytesTransfered = packet_s;
    }

    PacketFreePacket(lpPacket);
    free(packet);

    return (BytesTransfered);
}