int main(int argc, char *argv[])
{
long len;
int sockfd;
struct sockaddr_in ser_addr;
char **pptr;
struct hostent *sh;
struct in_addr **addrs;
float rate_of_transmission;
float time_interval;
FILE* file_pointer;
if (argc!= 2)
{
printf("parameters not match.");
exit(EXIT_FAILURE);
}
if ((sh=gethostbyname(argv[1]))==NULL) {
printf("error when gethostbyname");
exit(EXIT_FAILURE);
}
//Create Socket for Operation
sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0)
{
printf("Error in Creating Socket");
exit(EXIT_FAILURE);
}
addrs = (struct in_addr **)sh->h_addr_list;
printf("canonical name: %s\n", sh->h_name);
//Print out socket information
for (pptr=sh->h_aliases; *pptr != NULL; pptr++)
printf("the aliases name is: %s\n", *pptr);
switch(sh->h_addrtype)
{
case AF_INET:
printf("AF_INET\n");
break;
fileSfault:
printf("unknown addrtype\n");
break;
}
ser_addr.sin_family = AF_INET;
ser_addr.sin_port = htons(MYUDP_PORT);
memcpy(&(ser_addr.sin_addr.s_addr), *addrs, sizeof(struct in_addr));
bzero(&(ser_addr.sin_zero), 8);
if((file_pointer = fopen ("myfile.txt","r+t")) == NULL)
{
printf("File doesn't exist\n");
exit(EXIT_FAILURE);
}
time_interval = transmit_packets(file_pointer, sockfd, (struct sockaddr *)&ser_addr, sizeof(struct sockaddr_in), &len);
rate_of_transmission = (len/(float)time_interval);
printf("Time(ms) : %.3f, Data sent(byte): %d\nData rate: %f (Kbytes/s)\n", time_interval, (int)len, rate_of_transmission);
close(sockfd);
exit(EXIT_SUCCESS);
}
/**
* @ingroup tx_functions
* Transmit thread
*/
int tx_pkt_handler(struct bcm_mini_adapter *Adapter /**< pointer to adapter object*/)
{
int status = 0;
while (!kthread_should_stop()) {
/* FIXME - the timeout looks like workaround for racey usage of TxPktAvail */
if (Adapter->LinkUpStatus)
wait_event_timeout(Adapter->tx_packet_wait_queue,
tx_pending(Adapter), msecs_to_jiffies(10));
else
wait_event_interruptible(Adapter->tx_packet_wait_queue,
tx_pending(Adapter));
if (Adapter->device_removed)
break;
if (Adapter->downloadDDR == 1) {
Adapter->downloadDDR += 1;
status = download_ddr_settings(Adapter);
if (status)
pr_err(PFX "DDR DOWNLOAD FAILED! %d\n", status);
continue;
}
/* Check end point for halt/stall. */
if (Adapter->bEndPointHalted == TRUE) {
Bcm_clear_halt_of_endpoints(Adapter);
Adapter->bEndPointHalted = FALSE;
StartInterruptUrb((PS_INTERFACE_ADAPTER)(Adapter->pvInterfaceAdapter));
}
if (Adapter->LinkUpStatus && !Adapter->IdleMode) {
if (atomic_read(&Adapter->TotalPacketCount))
update_per_sf_desc_cnts(Adapter);
}
if (atomic_read(&Adapter->CurrNumFreeTxDesc) &&
Adapter->LinkStatus == SYNC_UP_REQUEST &&
!Adapter->bSyncUpRequestSent) {
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Calling LinkMessage");
LinkMessage(Adapter);
}
if ((Adapter->IdleMode || Adapter->bShutStatus) && atomic_read(&Adapter->TotalPacketCount)) {
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Device in Low Power mode...waking up");
Adapter->usIdleModePattern = ABORT_IDLE_MODE;
Adapter->bWakeUpDevice = TRUE;
wake_up(&Adapter->process_rx_cntrlpkt);
}
transmit_packets(Adapter);
atomic_set(&Adapter->TxPktAvail, 0);
}
BCM_DEBUG_PRINT(Adapter, DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Exiting the tx thread..\n");
Adapter->transmit_packet_thread = NULL;
return 0;
}
int
send_packets(int *sockfd){
demand_qnode_data demand;
cperf_demand ack_packet;
int32_t interface_index;
int interface_num = 0;
//int sockfd = open_socket(interface_num, &interface_index, (int)host_number);
// int32_t flags = fcntl(sockfd, F_GETFL, 0);
//fcntl(sockfd, F_SETFL, O_NONBLOCK | flags);
uint16_t src_mac1 = 0x0001;
uint32_t src_mac2 = 0x00000002;
uint16_t dest_mac1 = 0x0000;
uint32_t dest_mac2 = 0x000002;
// uint16_t packet_type = ETH_P_Exp;
int32_t retval = 0;
int n;
demand.src = 0;
while(1){
fflush(stdout);
dequeue_demand(&demand);
if(demand.src != 0){
// printf("\nPackets Sent: Src: %hd Dest: %hd Flow: %hd vlanid: %hd Port: %hd", demand.src, demand.dest, demand.flow, demand.vlanid, demand.port);
fprintf(send_pkts_fp, "Transmitting Flow: Timestamp: %d Src: %hd Dest: %hd Flow: %hd vlanid: %hd Port: %hd\n",demand.timeslot, demand.src, demand.dest, demand.flow, demand.vlanid, demand.port);
// transmit_packets(sockfd, interface_index, src_mac1, src_mac2, dest_mac1, dest_mac2, packet_type, demand.vlanid, demand.src,
// demand.dest, demand.port, demand.flow);
//sleep(1);
// transmit_packets();
//demand.flow = 20;
//if(demand.port == 5001)
// sleep((float)rand()/pow(10, 10));
///if(demand.port != 5001){
//retval = transmit_packets((int32_t)demand.src, (int32_t)demand.dest, (int32_t)demand.port, (int16_t)demand.vlanid, (int32_t)demand.flow);
//usleep(5000);
// TS finish message
if(demand.dest == 100 && curr_ts == demand.timeslot){
fprintf(send_pkts_fp, "Sending Timeslot ACK: Timeslot: %d \n",curr_ts);
fflush(send_pkts_fp);
ack_packet.src = host_number;
ack_packet.flow = curr_ts;
ack_packet.ack = 1;
n = write(*sockfd,(void *)&ack_packet, sizeof(host_reply));
curr_ts = 0;
}else{
/* if(prev_dest == demand.dest)
usleep(50);*/
curr_ts = demand.timeslot;
//if(curr_ts == prev_ts || curr_ts == 0){
retval = transmit_packets((int32_t)demand.src, (int32_t)demand.dest, (int32_t)demand.port, (int16_t)demand.vlanid, (int32_t)demand.flow);
prev_dest = demand.dest;
//usleep(50);
//prev_ts = curr_ts;
}
//}
// if(demand.src == 5001)
}else{
// send Ack to arbiter
/* if(curr_ts > 0){
fprintf(send_pkts_fp, "Sending Timeslot ACK: Timeslot: %d \n",curr_ts);
fflush(send_pkts_fp);
ack_packet.src = host_number;
ack_packet.flow = curr_ts;
ack_packet.ack = 1;
n = write(*sockfd,(void *)&ack_packet, sizeof(host_reply));
curr_ts = 0;
}*/
pthread_mutex_lock(&req_qlock);
// printf("\n>>>>>>>>> Going In MUTEX QUEUE");
pthread_cond_wait(&queue_not_empty, &req_qlock);
// printf("\n<<<<<<<<<<<COming Out of MUTEX QUEUE");
pthread_mutex_unlock(&req_qlock);
}
demand.src = 0;
fflush(send_pkts_fp);
}
return 1;
}
INT bcm_transmit(struct sk_buff *skb, /**< skb */
struct net_device *dev /**< net device pointer */
)
{
PMINI_ADAPTER Adapter = NULL;
USHORT qindex=0;
struct timeval tv;
UINT pkt_type = 0;
UINT calltransmit = 0;
INT status = STATUS_SUCCESS;
BCM_DEBUG_PRINT (Adapter, DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL, "\n%s====>\n",__FUNCTION__);
memset(&tv, 0, sizeof(tv));
/* Check for valid parameters */
if(skb == NULL || dev==NULL)
{
BCM_DEBUG_PRINT (Adapter, DBG_TYPE_TX,TX_OSAL_DBG, DBG_LVL_ALL, "Got NULL skb or dev\n");
return -EINVAL;
}
Adapter = GET_BCM_ADAPTER(dev);
if(!Adapter)
{
BCM_DEBUG_PRINT (Adapter, DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL, "Got Invalid Adapter\n");
status = -EINVAL;
goto exit_path;
}
if(Adapter->device_removed == TRUE || !Adapter->LinkUpStatus)
{
if(!netif_queue_stopped(dev)) {
netif_carrier_off(dev);
netif_stop_queue(dev);
}
status = STATUS_FAILURE;
goto exit_path;
}
BCM_DEBUG_PRINT (Adapter, DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL, "Packet size : %d\n", skb->len);
/*Add Ethernet CS check here*/
if(Adapter->TransferMode == IP_PACKET_ONLY_MODE )
{
pkt_type = ntohs(*(PUSHORT)(skb->data + 12));
/* Get the queue index where the packet is to be queued */
BCM_DEBUG_PRINT (Adapter, DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL, "Getting the Queue Index.....");
qindex = GetPacketQueueIndex(Adapter,skb);
if((SHORT)INVALID_QUEUE_INDEX==(SHORT)qindex)
{
if(pkt_type == ETH_ARP_FRAME)
{
/*
Reply directly to ARP request packet
ARP Spoofing only if NO ETH CS rule matches for it
*/
BCM_DEBUG_PRINT (Adapter,DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL,"ARP OPCODE = %02x",
(*(PUCHAR)(skb->data + 21)));
reply_to_arp_request(skb);
BCM_DEBUG_PRINT (Adapter, DBG_TYPE_TX,TX_OSAL_DBG, DBG_LVL_ALL,"After reply_to_arp_request \n");
}
else
{
BCM_DEBUG_PRINT (Adapter, DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL,
"Invalid queue index, dropping pkt\n");
status = STATUS_FAILURE;
}
goto exit_path;
}
if(Adapter->PackInfo[qindex].uiCurrentPacketsOnHost >= SF_MAX_ALLOWED_PACKETS_TO_BACKUP)
{
atomic_inc(&Adapter->TxDroppedPacketCount);
status = STATUS_FAILURE;
goto exit_path;
}
/* Now Enqueue the packet */
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, NEXT_SEND, DBG_LVL_ALL, "bcm_transmit Enqueueing the Packet To Queue %d",qindex);
spin_lock(&Adapter->PackInfo[qindex].SFQueueLock);
Adapter->PackInfo[qindex].uiCurrentBytesOnHost += skb->len;
Adapter->PackInfo[qindex].uiCurrentPacketsOnHost++;
*((B_UINT32 *)skb->cb + SKB_CB_LATENCY_OFFSET ) = jiffies;
ENQUEUEPACKET(Adapter->PackInfo[qindex].FirstTxQueue,
Adapter->PackInfo[qindex].LastTxQueue, skb);
atomic_inc(&Adapter->TotalPacketCount);
spin_unlock(&Adapter->PackInfo[qindex].SFQueueLock);
do_gettimeofday(&tv);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL,"ENQ: \n");
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL, "Pkt Len = %d, sec: %ld, usec: %ld\n",
(skb->len-ETH_HLEN), tv.tv_sec, tv.tv_usec);
#ifdef BCM_SHM_INTERFACE
spin_lock(&Adapter->txtransmitlock);
if(Adapter->txtransmit_running == 0)
{
Adapter->txtransmit_running = 1;
calltransmit = 1;
}
else
calltransmit = 0;
spin_unlock(&Adapter->txtransmitlock);
#endif
if(calltransmit == 1)
transmit_packets(Adapter);
else
{
if(!atomic_read(&Adapter->TxPktAvail))
{
atomic_set(&Adapter->TxPktAvail, 1);
#ifdef BCM_SHM_INTERFACE
virtual_mail_box_interrupt();
#endif
wake_up(&Adapter->tx_packet_wait_queue);
}
}
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_OSAL_DBG, DBG_LVL_ALL, "<====");
}
else
status = STATUS_FAILURE;
exit_path:
if(status != STATUS_SUCCESS)
bcm_kfree_skb(skb);
/* It is expected to return the correct status if running in cut-through mode */
if(Adapter->bNetworkInterfaceRegistered == FALSE)
return status;
/* It is expected to return as Success for Network Stack
- This will ensure that the packet is owned by the driver which shall free the same*/
else
return STATUS_SUCCESS;
}
/**
@ingroup tx_functions
Transmit thread
*/
int tx_pkt_handler(PMINI_ADAPTER Adapter /**< pointer to adapter object*/
)
{
#ifndef BCM_SHM_INTERFACE
int status = 0;
#endif
UINT calltransmit = 1;
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Entring to wait for signal from the interrupt service thread!Adapter = 0x%lx",(ULONG) Adapter);
while(1)
{
if(Adapter->LinkUpStatus){
wait_event_timeout(Adapter->tx_packet_wait_queue,
((atomic_read(&Adapter->TxPktAvail) &&
(MINIMUM_PENDING_DESCRIPTORS <
atomic_read(&Adapter->CurrNumFreeTxDesc)) &&
(Adapter->device_removed == FALSE))) ||
(1 == Adapter->uiFirstInterrupt) || kthread_should_stop()
#ifndef BCM_SHM_INTERFACE
|| (TRUE == Adapter->bEndPointHalted)
#endif
, msecs_to_jiffies(10));
}
else{
wait_event(Adapter->tx_packet_wait_queue,
((atomic_read(&Adapter->TxPktAvail) &&
(MINIMUM_PENDING_DESCRIPTORS <
atomic_read(&Adapter->CurrNumFreeTxDesc)) &&
(Adapter->device_removed == FALSE))) ||
(1 == Adapter->uiFirstInterrupt) || kthread_should_stop()
#ifndef BCM_SHM_INTERFACE
|| (TRUE == Adapter->bEndPointHalted)
#endif
);
}
if(kthread_should_stop() || Adapter->device_removed)
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Exiting the tx thread..\n");
Adapter->transmit_packet_thread = NULL;
return 0;
}
if(Adapter->uiFirstInterrupt == 1)
{
SetUpTargetDsxBuffers(Adapter);
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Seting DSX...\n");
Adapter->uiFirstInterrupt +=1;
#ifndef BCM_SHM_INTERFACE
status = download_ddr_settings(Adapter);
if(status)
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "DDR DOWNLOAD FAILED!\n");
#endif
continue;
}
#ifndef BCM_SHM_INTERFACE
//Check end point for halt/stall.
if(Adapter->bEndPointHalted == TRUE)
{
Bcm_clear_halt_of_endpoints(Adapter);
Adapter->bEndPointHalted = FALSE;
StartInterruptUrb((PS_INTERFACE_ADAPTER)(Adapter->pvInterfaceAdapter));
}
if(Adapter->LinkUpStatus && !Adapter->IdleMode)
{
if(atomic_read(&Adapter->TotalPacketCount))
{
update_per_sf_desc_cnts(Adapter);
}
}
#endif
if( atomic_read(&Adapter->CurrNumFreeTxDesc) &&
Adapter->LinkStatus == SYNC_UP_REQUEST &&
!Adapter->bSyncUpRequestSent)
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Calling LinkMessage");
LinkMessage(Adapter);
}
if((Adapter->IdleMode || Adapter->bShutStatus) && atomic_read(&Adapter->TotalPacketCount))
{
BCM_DEBUG_PRINT(Adapter,DBG_TYPE_TX, TX_PACKETS, DBG_LVL_ALL, "Device in Low Power mode...waking up");
Adapter->usIdleModePattern = ABORT_IDLE_MODE;
Adapter->bWakeUpDevice = TRUE;
wake_up(&Adapter->process_rx_cntrlpkt);
}
#ifdef BCM_SHM_INTERFACE
spin_lock_bh(&Adapter->txtransmitlock);
if(Adapter->txtransmit_running == 0)
{
Adapter->txtransmit_running = 1;
calltransmit = 1;
}
else
calltransmit = 0;
spin_unlock_bh(&Adapter->txtransmitlock);
#endif
if(calltransmit)
transmit_packets(Adapter);
atomic_set(&Adapter->TxPktAvail, 0);
}
return 0;
}
