void update_grid_from_edit(int edit_iItem, int edit_iSubItem)
{
TCHAR buf[64];
t_stream* pt_stream=g_apt_streams[edit_iItem];
t_ether_packet *pt_eth_hdr = (void *)pt_stream->data;
t_ip_hdr *iph=eth_data(pt_eth_hdr);
t_ipv6_hdr *ip6h=(void *)iph;
int type = eth_type(pt_eth_hdr);
GetWindowText(hwnd_dynamic_edit, buf, sizeof(buf));
ShowWindow (hwnd_dynamic_edit, 0);
ListView_SetItemText(hwnd_lv, edit_iItem, edit_iSubItem, buf);
if (edit_iSubItem==3)
{
strcpy(pt_stream->name, buf);
return;
}
if (edit_iSubItem==7)
{
pt_stream->len = atoi(buf);
goto exit;
}
if (type!=ETH_P_IP && type!=ETH_P_IPV6)
{
if (edit_iSubItem==4)
{
mac_str2n(pt_stream->eth_packet.src, buf);
}
else if (edit_iSubItem==5)
{
mac_str2n(pt_stream->eth_packet.dst, buf);
}
return;
}
if (edit_iSubItem==4)
{
if (type==ETH_P_IP)
ip_str2n(&(iph->saddr), buf);
else
ip6_str2n(ip6h->saddr, buf);
}
else if (edit_iSubItem==5)
{
if (type==ETH_P_IP)
ip_str2n(&(iph->daddr), buf);
else
ip6_str2n(ip6h->daddr, buf);
}
exit:
update_stream(pt_stream);
}
/***************************************************************************
* sl_collect_nb:
*
* Routine to manage a connection to a SeedLink server based on the values
* given in the slconn struct and collect data.
*
* Designed to run in a tight loop at the heart of a client program, this
* function is a non-blocking version sl_collect(). SLNOPACKET will be
* returned when no data is available.
*
* Returns SLPACKET when something is received and sets the slpack
* pointer to the received packet. Returns SLNOPACKET when no packets
* have been received, slpack is set to NULL. When the connection was
* closed by the server or the termination sequence completed
* SLTERMINATE is returned and the slpack pointer is set to NULL.
***************************************************************************/
int
sl_collect_nb (SLCD * slconn, SLpacket ** slpack)
{
int bytesread;
double current_time;
char retpacket;
*slpack = NULL;
/* Check if the info was set */
if ( slconn->info != NULL )
{
slconn->stat->query_mode = InfoQuery;
}
/* If the connection is not up check the SLCD and reset the timing variables */
if ( slconn->link == -1 )
{
if ( sl_checkslcd(slconn) )
{
sl_log_r (slconn, 2, 0, "problems with the connection description\n");
return SLTERMINATE;
}
slconn->stat->netto_trig = -1; /* Init net timeout trigger to reset state */
slconn->stat->keepalive_trig = -1; /* Init keepalive trigger to reset state */
}
/* Start the main sequence */
if ( ! slconn->terminate )
{
if (slconn->link == -1)
{
slconn->stat->sl_state = SL_DOWN;
}
/* Check for network timeout */
if (slconn->stat->sl_state == SL_DATA &&
slconn->netto && slconn->stat->netto_trig > 0)
{
sl_log_r (slconn, 1, 0, "network timeout (%ds), reconnecting in %ds\n",
slconn->netto, slconn->netdly);
slconn->link = sl_disconnect (slconn);
slconn->stat->sl_state = SL_DOWN;
slconn->stat->netto_trig = -1;
slconn->stat->netdly_trig = -1;
}
/* Check if a keepalive packet needs to be sent */
if (slconn->stat->sl_state == SL_DATA && !slconn->stat->expect_info &&
slconn->keepalive && slconn->stat->keepalive_trig > 0)
{
sl_log_r (slconn, 1, 2, "sending keepalive request\n");
if ( sl_send_info (slconn, "ID", 3) != -1 )
{
slconn->stat->query_mode = KeepAliveQuery;
slconn->stat->expect_info = 1;
slconn->stat->keepalive_trig = -1;
}
}
/* Check if an in-stream INFO request needs to be sent */
if (slconn->stat->sl_state == SL_DATA &&
!slconn->stat->expect_info && slconn->info)
{
if ( sl_send_info (slconn, slconn->info, 1) != -1 )
{
slconn->stat->query_mode = InfoQuery;
slconn->stat->expect_info = 1;
}
else
{
slconn->stat->query_mode = NoQuery;
}
slconn->info = NULL;
}
/* Throttle the loop while delaying */
if (slconn->stat->sl_state == SL_DOWN && slconn->stat->netdly_trig > 0)
{
slp_usleep (500000);
}
/* Connect to remote SeedLink */
if (slconn->stat->sl_state == SL_DOWN && slconn->stat->netdly_trig == 0)
{
if (sl_connect (slconn, 1) != -1)
{
slconn->stat->sl_state = SL_UP;
}
slconn->stat->netto_trig = -1;
slconn->stat->netdly_trig = -1;
slconn->stat->keepalive_trig = -1;
}
/* Negotiate/configure the connection */
if (slconn->stat->sl_state == SL_UP)
{
int slconfret = 0;
/* Only send query if a query is set and no streams are defined,
* if streams are defined we'll send the query after configuration.
*/
if (slconn->info && slconn->streams == NULL)
{
if ( sl_send_info (slconn, slconn->info, 1) != -1 )
{
slconn->stat->query_mode = InfoQuery;
slconn->stat->expect_info = 1;
}
else
{
slconn->stat->query_mode = NoQuery;
slconn->stat->expect_info = 0;
}
slconn->info = NULL;
}
else
{
slconfret = sl_configlink (slconn);
slconn->stat->expect_info = 0;
}
if (slconfret != -1)
{
slconn->stat->recptr = 0; /* initialize the data buffer pointers */
slconn->stat->sendptr = 0;
slconn->stat->sl_state = SL_DATA;
}
else
{
sl_log_r (slconn, 2, 0, "negotiation with remote SeedLink failed\n");
slconn->link = sl_disconnect (slconn);
slconn->stat->netdly_trig = -1;
}
}
}
else /* We are terminating */
{
if (slconn->link != -1)
{
slconn->link = sl_disconnect (slconn);
}
slconn->stat->sl_state = SL_DATA;
}
/* DEBUG
sl_log_r (slconn, 1, 0, "link: %d, sendptr: %d, recptr: %d, diff: %d\n",
slconn->link, slconn->stat->sendptr, slconn->stat->recptr,
(slconn->stat->recptr - slconn->stat->sendptr) );
*/
/* Process data in buffer */
while (slconn->stat->recptr - slconn->stat->sendptr >= SLHEADSIZE + SLRECSIZE)
{
retpacket = 1;
/* Check for an INFO packet */
if (!strncmp (&slconn->stat->databuf[slconn->stat->sendptr], INFOSIGNATURE, 6))
{
char terminator;
terminator = (slconn->stat->databuf[slconn->stat->sendptr + SLHEADSIZE - 1] != '*');
if ( !slconn->stat->expect_info )
{
sl_log_r (slconn, 2, 0, "unexpected INFO packet received, skipping\n");
}
else
{
if ( terminator )
{
slconn->stat->expect_info = 0;
}
/* Keep alive packets are not returned */
if ( slconn->stat->query_mode == KeepAliveQuery )
{
retpacket = 0;
if ( !terminator )
{
sl_log_r (slconn, 2, 0, "non-terminated keep-alive packet received!?!\n");
}
else
{
sl_log_r (slconn, 1, 2, "keepalive packet received\n");
}
}
}
if ( slconn->stat->query_mode != NoQuery )
{
slconn->stat->query_mode = NoQuery;
}
}
else /* Update the stream chain entry if not an INFO packet */
{
if ( (update_stream (slconn, (SLpacket *) &slconn->stat->databuf[slconn->stat->sendptr])) == -1 )
{
/* If updating didn't work the packet is broken */
retpacket = 0;
}
}
/* Increment the send pointer */
slconn->stat->sendptr += (SLHEADSIZE + SLRECSIZE);
/* Return packet */
if ( retpacket )
{
*slpack = (SLpacket *) &slconn->stat->databuf[slconn->stat->sendptr - (SLHEADSIZE + SLRECSIZE)];
return SLPACKET;
}
}
/* A trap door for terminating, all complete data packets from the buffer
have been sent to the caller */
if ( slconn->terminate ) {
return SLTERMINATE;
}
/* After processing the packet buffer shift the data */
if ( slconn->stat->sendptr )
{
memmove (slconn->stat->databuf,
&slconn->stat->databuf[slconn->stat->sendptr],
slconn->stat->recptr - slconn->stat->sendptr);
slconn->stat->recptr -= slconn->stat->sendptr;
slconn->stat->sendptr = 0;
}
/* Catch cases where the data stream stopped */
if ((slconn->stat->recptr - slconn->stat->sendptr) == 7 &&
!strncmp (&slconn->stat->databuf[slconn->stat->sendptr], "ERROR\r\n", 7))
{
sl_log_r (slconn, 2, 0, "SeedLink server reported an error with the last command\n");
slconn->link = sl_disconnect (slconn);
return SLTERMINATE;
}
if ((slconn->stat->recptr - slconn->stat->sendptr) == 3 &&
!strncmp (&slconn->stat->databuf[slconn->stat->sendptr], "END", 3))
{
sl_log_r (slconn, 1, 1, "End of buffer or selected time window\n");
slconn->link = sl_disconnect (slconn);
return SLTERMINATE;
}
/* Process data in our buffer and then read incoming data */
if (slconn->stat->sl_state == SL_DATA)
{
/* Check for more available data from the socket */
bytesread = 0;
bytesread = sl_recvdata (slconn, (void *) &slconn->stat->databuf[slconn->stat->recptr],
BUFSIZE - slconn->stat->recptr, slconn->sladdr);
if (bytesread < 0 && ! slconn->terminate) /* read() failed */
{
slconn->link = sl_disconnect (slconn);
slconn->stat->netdly_trig = -1;
}
else if (bytesread > 0) /* Data is here, process it */
{
slconn->stat->recptr += bytesread;
/* Reset the timeout and keepalive timers */
slconn->stat->netto_trig = -1;
slconn->stat->keepalive_trig = -1;
}
}
/* Update timing variables */
current_time = sl_dtime ();
/* Network timeout timing logic */
if (slconn->netto)
{
if (slconn->stat->netto_trig == -1) /* reset timer */
{
slconn->stat->netto_time = current_time;
slconn->stat->netto_trig = 0;
}
else if (slconn->stat->netto_trig == 0 &&
(current_time - slconn->stat->netto_time) > slconn->netto)
{
slconn->stat->netto_trig = 1;
}
}
/* Keepalive/heartbeat interval timing logic */
if (slconn->keepalive)
{
if (slconn->stat->keepalive_trig == -1) /* reset timer */
{
slconn->stat->keepalive_time = current_time;
slconn->stat->keepalive_trig = 0;
}
else if (slconn->stat->keepalive_trig == 0 &&
(current_time - slconn->stat->keepalive_time) > slconn->keepalive)
{
slconn->stat->keepalive_trig = 1;
}
}
/* Network delay timing logic */
if (slconn->netdly)
{
if (slconn->stat->netdly_trig == -1) /* reset timer */
{
slconn->stat->netdly_time = current_time;
slconn->stat->netdly_trig = 1;
}
else if (slconn->stat->netdly_trig == 1 &&
(current_time - slconn->stat->netdly_time) > slconn->netdly)
{
slconn->stat->netdly_trig = 0;
}
}
/* Non-blocking and no data was returned */
return SLNOPACKET;
} /* End of sl_collect_nb() */
