int roveTCP_Recv(rove_tcp_socket* rove_tcp_socket, char* recv_buffer, int recv_buffer_byte_cnt) {
if (rove_tcp_socket->connected_flag == CONNECTED) {
//TODO
int recv_byte_cnt = recv(rove_tcp_socket->socket_fd, recv_buffer, recv_buffer_byte_cnt, MSG_WAITALL);
if (recv_byte_cnt < ZERO_BYTES) {
printf("RETURN DISCONNECTED: Failed roveTCP_Recv");
rove_tcp_socket->error_code = fdError();
roveCatch_NdkErrors(rove_tcp_socket->error_code);
return DISCONNECTED;
}//endif
return recv_byte_cnt;
}//endif
return DISCONNECTED;
}//endfnctn roveTCP_Connect
int roveTCP_Connect(rove_tcp_socket* rove_tcp_socket) {
rove_tcp_socket->socket_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
//flag for bad socket
if ( (rove_tcp_socket->socket_fd) < 1) {
printf("Failed socket() with socket_fd: %d \n\n" , rove_tcp_socket->socket_fd);
roveCatch_NdkErrors( fdError() );
return DISCONNECTED;
}//endif
//init bsd socket config struct
memset(&rove_tcp_socket->server_addr, 0, sizeof(struct sockaddr_in));
//config the socket
rove_tcp_socket->server_addr.sin_family = AF_INET;
rove_tcp_socket->server_addr.sin_port = htons(TCPPORT);
inet_pton(AF_INET, RED_IP_ADDRESS, &(rove_tcp_socket->server_addr.sin_addr));
//set a timeout on the socket
rove_tcp_socket->tcp_timeout.tv_sec = TCP_SOCKET_TIMEOUT_SEC;
rove_tcp_socket->tcp_timeout.tv_usec = 0;
setsockopt(rove_tcp_socket->socket_fd, SOL_SOCKET, SO_RCVTIMEO, &(rove_tcp_socket->tcp_timeout), sizeof(struct timeval) );
//connect the socket
if (connect(rove_tcp_socket->socket_fd, (PSA) &(rove_tcp_socket->server_addr), sizeof(struct sockaddr_in)) < 0) {
printf("Failed connect() with socket_fd: %d \n\n" , rove_tcp_socket->socket_fd);
roveCatch_NdkErrors( fdError() );
return DISCONNECTED;
} else {
return CONNECTED;
}//endif
}//endfnctn
void QGitHubReleaseAPIPrivate::init() const {
QObject::connect(m_apiDownloader, SIGNAL(error(QString)), this, SLOT(fdError(QString)));
QObject::connect(m_apiDownloader, SIGNAL(downloaded(FileDownloader)),
this, SLOT(downloaded(FileDownloader)));
QObject::connect(m_apiDownloader, SIGNAL(progress(qint64,qint64)),
this, SLOT(downloadProgress(qint64,qint64)));
m_apiDownloader->start(m_type);
}
// tftpReadPacket()
//
// Read a data packet from the peer socket
// Sets bytes read to ZERO on a timeout
//
static int tftpReadPacket( TFTP *pTftp )
{
int rc = 0;
int addrLength;
struct tftphdr *ReadBuffer;
INT32 BytesRead;
UINT32 TimeStart;
ReadBuffer = (struct tftphdr *)pTftp->PacketBuffer;
TimeStart = llTimerGetTime(0);
RETRY:
// Don't allow stray traffic to keep us alive
if( (TimeStart+TFTP_SOCK_TIMEOUT) <= llTimerGetTime(0) )
{
BytesRead = 0;
goto ABORT;
}
// Attempt to read data
addrLength = sizeof(pTftp->tmpaddr);
BytesRead = recvfrom( pTftp->Sock, ReadBuffer, DATA_SIZE, 0,
(struct sockaddr *)&pTftp->tmpaddr, &addrLength );
// Handle read errors first
if( BytesRead < 0 )
{
// On a timeout error, ABORT with no error
// Else report error
if( fdError() == EWOULDBLOCK )
BytesRead = 0;
else
rc = TFTPERROR_SOCKET;
goto ABORT;
}
// If this packet is not from our peer, retry
if( pTftp->tmpaddr.sin_addr.s_addr != pTftp->PeerAddress )
goto RETRY;
// If the peer port is NOT TFTP, then it must match our expected
// peer.
if( pTftp->peeraddr.sin_port != htons(PORT_TFTP) )
{
if( pTftp->tmpaddr.sin_port != pTftp->peeraddr.sin_port )
goto RETRY;
}
ABORT:
pTftp->Length = (UINT32)BytesRead; // Store number of bytes read
return(rc);
}
void QGitHubReleaseAPIPrivate::downloaded(const FileDownloader &fd) {
QObject::connect(m_apiDownloader, SIGNAL(error(QString)), this, SLOT(fdError(QString)));
QObject::connect(m_apiDownloader, SIGNAL(downloaded(FileDownloader)),
this, SLOT(downloaded(FileDownloader)));
QObject::connect(m_apiDownloader, SIGNAL(progress(qint64,qint64)),
this, SLOT(downloadProgress(qint64,qint64)));
m_jsonData = fd.downloadedData();
foreach(const FileDownloader::RAWHEADERPAIR &pair, fd.rawHeaderPairs()) {
if(pair.first == "ETag") m_eTag = pair.second.mid(2);
if(pair.first == "X-RateLimit-Reset") {
m_rateLimitReset = QDateTime::fromTime_t(QString(pair.second).toUInt());
}
if(pair.first == "X-RateLimit-Limit") m_rateLimit = QString(pair.second).toUInt();
if(pair.first == "X-RateLimit-Remaining") {
m_rateLimitRemaining = QString(pair.second).toUInt();
}
}
QVariant va(parseJSon(m_jsonData, m_errorString));
if(m_errorString.isNull()) {
if(m_singleEntryRequested) {
m_vdata.append(va);
} else if((m_vdata = va.toList()).isEmpty()) {
m_errorString = va.toMap()["message"].toString();
emit error(m_errorString);
return;
}
emit available();
} else {
emit error(m_errorString);
}
}
void nullsrv()
{
SOCKET stcpactive = INVALID_SOCKET;
struct sockaddr_in sin1;
struct timeval timeout; // Timeout struct for select
int size;
int cnt;
char *pBuf;
HANDLE hBuffer;
//gpioEnableGlobalInterrupt();
// Allocate the file environment for this task
fdOpenSession(TaskSelf());
TaskSleep(15000);
platform_write("Raw Eth Task Started ... \n");
// Create the main TCP listen socket
platform_write("creating main TCP listen socket\n");
int k=0;
int n=0;
IMG_STORE_REQST_TYP a;
int *data;
UInt32 time1,time2;
for(;;)
{
//time1=Clock_getTicks();
a.fps=acquire_data();
a.number=min((int)a.fps*sizeof(int),PULSE_SAMPLE*sizeof(int));
//time2=Clock_getTicks();
///platform_write("time taken for acquire data is %lu \n",(unsigned long)(time2-time1));
//time1=Clock_getTicks();
for(k=0;k<2;k++)
{
if(k==0)
data=&data_bufferA[0];
else
data=&data_bufferB[0];
//WWdis_data();
stcp = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if( stcp == INVALID_SOCKET )
{
int ret=fdError();
goto leave;
}
timeout.tv_sec = 30;
timeout.tv_usec = 0;
setsockopt( stcp, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof( timeout ) );
setsockopt( stcp, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof( timeout ) );
//timeout.tv_sec = 3;
//int opt = 1;
//setsockopt( stcp, SOL_SOCKET, SO_BLOCKING , &opt, sizeof( opt ) );
platform_write("created main TCP client socket\n");
// Set Port = 1001, leaving IP address = Any
bzero( &sin1, sizeof(struct sockaddr_in) );
sin1.sin_family = AF_INET;
sin1.sin_addr.s_addr =inet_addr(PCStaticIP);
sin1.sin_port = htons(7000);
sin1.sin_len = sizeof( sin1 );
platform_write("LLL %d \n",(sin1.sin_addr.s_addr));
//fcntl(stcp, F_SETFL, O_NONBLOCK);
//while(1)
if( connect(stcp, (struct sockaddr *) &sin1, sizeof(sin1)) < 0)
{
if (fdError() == EINPROGRESS)
{
fd_set wrsd;
struct timeval tv;
FD_ZERO(&wrsd);
FD_SET(stcp, &wrsd);
tv.tv_sec = 2;
tv.tv_usec = 0;
int ret = fdSelect((int)stcp, 0, &wrsd, 0, &tv );
if(ret>0)
{
int err, lenErr;
lenErr = sizeof(err);
ret = getsockopt(stcp, SOL_SOCKET, SO_ERROR, &err, &lenErr);
if(ret==0 && err==0)
{
platform_write("connection completed");
break;
}
else
{
platform_write("Attempting to connect again");
continue;
}
}
}
}
platform_write("completed connect \n");
a.hydrophone=k;
n=0;
n = send(stcp,&a,sizeof(a),0);
if (n < 0)
{
perror("ERROR writing to socket");
break;
}
platform_write("writing hydrophone %d,bytes %d\n",k,a.number);
n=0;
int c=0;
//platform_write("writing %s \n",data);
do
{
n = send(stcp,data,a.number-c,0);
//platform_write("writing %d bytes \n",n);
if (n < 0)
{
perror("ERROR writing to socket");
break;
}
c=c+n;
data=data+n;
}while(c<a.number);
if (n < 0)
break;
//free(orig);
int status;
HANDLE hbuffer;
n = recv(stcp, &status, sizeof(status),0);
if(status==0)
{
platform_write("Client request success\n");
}
else
{
platform_write("Client request error");
continue;
}
if( stcp != INVALID_SOCKET )
fdClose(stcp);
}
if( stcp != INVALID_SOCKET )
{
shutdown(stcp,0);
fdClose(stcp);
}
//time2=Clock_getTicks();
platform_write("time taken for data transfer is %lu \n",(unsigned long)(time2-time1));
//TaskSleep(5);fe
}
leave:
TaskSleep(5000);
// We only get here on an error - close the sockets
// if( stcp != INVALID_SOCKET )
// fdClose( stcp );
platform_write("NullSrv Fatal Error\n");
// NetworkClose((HANDLE)TaskSelf());
// This task is killed by the system - here, we block
//TaskBlock( TaskSelf() );
}
