main ()
{
SOCKET LSock, CSock;
unsigned short usPort=80;
int Rc;
char szVer [128];
Tcp4uVer (szVer, sizeof szVer);
printf ("Using %s\n", szVer);
/* --- prepare a listening connection */
Tcp4uInit ();
Rc = TcpGetListenSocket (& LSock, "http", & usPort, 1);
if (Rc!=TCP4U_SUCCESS)
{
printf ("%s\n", Tcp4uErrorString(Rc));
return 0;
}
/* --- now listen at port */
Rc = TcpAccept (&CSock, LSock, 0);
while (Rc>=TCP4U_SUCCESS)
{
/* now the application code. Note that you can fork or creat */
/* a new thread in order to create a multi-user server */
/* --- in this app, we listen at the opened socket */
Rc = TnReadLine (CSock, szBuf, sizeof szBuf, 60, HFILE_ERROR);
if (Rc>=TCP4U_SUCCESS) printf ("%s\n", szBuf);
}
TcpClose (& CSock);
Tcp4uCleanup ();
return 0;
} /* main */
/**
Timeout handler for 2MSL timer.
@param Tcb Pointer to the TCP_CB of this TCP instance.
**/
VOID
Tcp2MSLTimeout (
IN OUT TCP_CB *Tcb
)
{
DEBUG ((EFI_D_WARN, "Tcp2MSLTimeout: connection closed "
"because TIME_WAIT timer timeouts for TCB %p\n", Tcb));
TcpClose (Tcb);
}
/**
Timeout handler for FIN_WAIT_2 timer.
@param Tcb Pointer to the TCP_CB of this TCP instance.
**/
VOID
TcpFinwait2Timeout (
IN OUT TCP_CB *Tcb
)
{
DEBUG ((EFI_D_WARN, "TcpFinwait2Timeout: connection closed "
"because FIN_WAIT2 timer timeouts for TCB %p\n", Tcb));
TcpClose (Tcb);
}
/* ------------------------------------------------------------ */
int _export PASCAL FAR FtpLocalClose (void)
{
LPProcData pProcData;
pProcData = ToolsLocateProcData ();
if (pProcData == NULL) return FTPERR_NOTINITIALIZED;
FtpCloseFileTransfer (pProcData, FALSE);
TcpClose (& pProcData->ftp.ctrl_socket);
return pProcData->ftp.ctrl_socket==INVALID_SOCKET
&& pProcData->ftp.data_socket==INVALID_SOCKET ?
FTPERR_OK : FTPERR_CANTCLOSE;
} /* FtpLocalClose */
bool NetworkClient::StopClient ()
{
int result = TcpClose ( &socket );
if ( result == TCP4U_SUCCESS )
return true;
else
return false;
}
/*######################################################################
*##
*## NAME: HttpGetHeaders10
*##
*## PURPOSE: Return the header section of the http request
*##
*####################################################################*/
int HttpGetHeaders10( LPCSTR szURL, /* URL target */
LPSTR szResponse, /* user's buffer for HTTP response */
int nResponseSize, /* */
LPSTR szData, /* user's buffer for HTTP headers */
int nDataSize /* */)
{
int Rc;
SOCKET CSock = INVALID_SOCKET;
char szService[SERVICE_LENGTH];
char szHost[HOST_LENGTH];
char szFichier[FILE_LENGTH];
unsigned short usPort;
struct S_HttpStatus saRespStatus;
Tcp4uLog (LOG4U_INTERN, "HttpGetHeaders10");
/* control the URL's validity and receive the URL distinct components */
if (!HttpIsValidURL(szURL,
&usPort,
szService, sizeof szService ,
szHost, sizeof szHost ,
szFichier, sizeof szFichier ))
return HTTP4U_BAD_URL;
/* connect to the http server */
Rc = TcpConnect(&CSock,
szHost,
szService,
&usPort);
switch (Rc)
{
case TCP4U_SUCCESS : break; /* continue */
case TCP4U_HOSTUNKNOWN : return HTTP4U_HOST_UNKNOWN;
default : return HTTP4U_TCP_CONNECT;
}
/* Send request-line method "HEAD" then receive the status-line answer */
/* then receive headers */
(Rc = HttpSendRequest10 (CSock,"HEAD ", szURL)) == HTTP4U_SUCCESS
&& (Rc = HttpRecvRespStatus (CSock, & saRespStatus,
szResponse, nResponseSize)) == HTTP4U_SUCCESS
&& (Rc = HttpRecvHeaders10 (CSock, szData, nDataSize)) == HTTP4U_SUCCESS ;
TcpClose (&CSock);
return Rc;
} /* END HttpGetHeaders10 */
/**
Timeout handler for TCP retransmission timer.
@param Tcb Pointer to the TCP_CB of this TCP instance.
**/
VOID
TcpRexmitTimeout (
IN OUT TCP_CB *Tcb
)
{
UINT32 FlightSize;
DEBUG ((EFI_D_WARN, "TcpRexmitTimeout: transmission "
"timeout for TCB %p\n", Tcb));
//
// Set the congestion window. FlightSize is the
// amount of data that has been sent but not
// yet ACKed.
//
FlightSize = TCP_SUB_SEQ (Tcb->SndNxt, Tcb->SndUna);
Tcb->Ssthresh = MAX ((UINT32) (2 * Tcb->SndMss), FlightSize / 2);
Tcb->CWnd = Tcb->SndMss;
Tcb->LossRecover = Tcb->SndNxt;
Tcb->LossTimes++;
if ((Tcb->LossTimes > Tcb->MaxRexmit) &&
!TCP_TIMER_ON (Tcb->EnabledTimer, TCP_TIMER_CONNECT)) {
DEBUG ((EFI_D_ERROR, "TcpRexmitTimeout: connection closed "
"because too many timeouts for TCB %p\n", Tcb));
if (EFI_ABORTED == Tcb->Sk->SockError) {
SOCK_ERROR (Tcb->Sk, EFI_TIMEOUT);
}
TcpClose (Tcb);
return ;
}
TcpBackoffRto (Tcb);
TcpRetransmit (Tcb, Tcb->SndUna);
TcpSetTimer (Tcb, TCP_TIMER_REXMIT, Tcb->Rto);
Tcb->CongestState = TCP_CONGEST_LOSS;
TCP_CLEAR_FLG (Tcb->CtrlFlag, TCP_CTRL_RTT_ON);
}
/* ----------------------------------------------------- */
int Skt4uInit (void)
{
int Ark;
if (! bInitDone) /* Aucune socket ouverte */
{
for (Ark=0 ; Ark<SizeOfTab(HistoSocket) ; Ark++)
HistoSocket[Ark].skt = INVALID_SOCKET;
bInitDone=TRUE;
}
#ifdef WINDOWS
/* liberation des sockets appartenant a des taches mortes */
else
{
for (Ark=0 ; Ark<SizeOfTab(HistoSocket) ; Ark++)
if ( HistoSocket[Ark].skt!=INVALID_SOCKET
&& !IsTask(HistoSocket[Ark].hTask) )
TcpClose (& HistoSocket[Ark].skt);
} /* InitDone */
#endif
return TCP4U_SUCCESS;
} /* Skt4wInit */
/**
Timeout handler for keepalive timer.
@param Tcb Pointer to the TCP_CB of this TCP instance.
**/
VOID
TcpKeepaliveTimeout (
IN OUT TCP_CB *Tcb
)
{
Tcb->KeepAliveProbes++;
//
// Too many Keep-alive probes, drop the connection
//
if (Tcb->KeepAliveProbes > Tcb->MaxKeepAlive) {
if (EFI_ABORTED == Tcb->Sk->SockError) {
SOCK_ERROR (Tcb->Sk, EFI_TIMEOUT);
}
TcpClose (Tcb);
return ;
}
TcpSendZeroProbe (Tcb);
TcpSetKeepaliveTimer (Tcb);
}
/* ------------------------------------------------------------------ */
int Skt4uCleanup (void)
{
int Ark;
if (bInitDone)
{
/* blocking call ? */
if (WSAIsBlocking())
{
WSACancelBlockingCall ();
return TCP4U_ERROR;
}
else
{
/* TcpClose (&s) force s a -1 -> pas besoin de UnrcdSkt */
for (Ark=0 ; Ark<SizeOfTab(HistoSocket) ; Ark++)
if ( HistoSocket[Ark].hTask == GetCurrentTask ()
&& HistoSocket[Ark].skt != INVALID_SOCKET )
TcpClose (& HistoSocket[Ark].skt);
WSACleanup ();
} /* requete non bloquante */
} /* bInitDone */
return TCP4U_SUCCESS;
} /* Skt4wCleanup */
/**
Connect timeout handler.
@param Tcb Pointer to the TCP_CB of this TCP instance.
**/
VOID
TcpConnectTimeout (
IN OUT TCP_CB *Tcb
)
{
if (!TCP_CONNECTED (Tcb->State)) {
DEBUG ((EFI_D_ERROR, "TcpConnectTimeout: connection closed "
"because conenction timer timeout for TCB %p\n", Tcb));
if (EFI_ABORTED == Tcb->Sk->SockError) {
SOCK_ERROR (Tcb->Sk, EFI_TIMEOUT);
}
if (TCP_SYN_RCVD == Tcb->State) {
DEBUG ((EFI_D_WARN, "TcpConnectTimeout: send reset because "
"connection timer timeout for TCB %p\n", Tcb));
TcpResetConnection (Tcb);
}
TcpClose (Tcb);
}
}
// ------------------------------------------------------------------------------------------------
static void ExitState(TcpConn *conn, uint state)
{
NetBuf *inPkt;
TcpHeader *inHdr;
Packet *outPkt;
TcpHeader *outHdr;
ASSERT_EQ_UINT(conn->state, state);
ASSERT_TRUE(ListIsEmpty(&s_outPackets));
switch (state)
{
case TCP_CLOSED:
TcpClose(conn);
break;
case TCP_SYN_SENT:
TcpClose(conn);
break;
case TCP_SYN_RECEIVED:
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_ACK);
TcpInput(inPkt);
ExitState(conn, TCP_ESTABLISHED);
break;
case TCP_ESTABLISHED:
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_FIN | TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, conn->localPort);
ASSERT_EQ_UINT(outHdr->dstPort, conn->remotePort);
ASSERT_EQ_UINT(outHdr->seq, conn->sndNxt);
ASSERT_EQ_UINT(outHdr->ack, conn->rcvNxt);
ASSERT_EQ_HEX8(outHdr->flags, TCP_ACK);
free(outPkt);
ExitState(conn, TCP_CLOSE_WAIT);
break;
case TCP_FIN_WAIT_1:
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_FIN | TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, conn->localPort);
ASSERT_EQ_UINT(outHdr->dstPort, conn->remotePort);
ASSERT_EQ_UINT(outHdr->seq, conn->sndNxt);
ASSERT_EQ_UINT(outHdr->ack, conn->rcvNxt);
ASSERT_EQ_HEX8(outHdr->flags, TCP_ACK);
free(outPkt);
ExitState(conn, TCP_TIME_WAIT);
break;
case TCP_FIN_WAIT_2:
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_FIN | TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, conn->localPort);
ASSERT_EQ_UINT(outHdr->dstPort, conn->remotePort);
ASSERT_EQ_UINT(outHdr->seq, conn->sndNxt);
ASSERT_EQ_UINT(outHdr->ack, conn->rcvNxt);
ASSERT_EQ_HEX8(outHdr->flags, TCP_ACK);
free(outPkt);
ExitState(conn, TCP_TIME_WAIT);
break;
case TCP_CLOSE_WAIT:
TcpClose(conn);
outPkt = PopPacket();
outHdr = (TcpHeader *)outPkt->data;
TcpSwap(outHdr);
ASSERT_EQ_UINT(outHdr->srcPort, conn->localPort);
ASSERT_EQ_UINT(outHdr->dstPort, conn->remotePort);
ASSERT_EQ_UINT(outHdr->seq, conn->sndNxt - 1);
ASSERT_EQ_UINT(outHdr->ack, conn->rcvNxt);
ASSERT_EQ_HEX8(outHdr->flags, TCP_FIN | TCP_ACK);
free(outPkt);
ExitState(conn, TCP_LAST_ACK);
break;
case TCP_CLOSING:
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_ACK);
TcpInput(inPkt);
ExitState(conn, TCP_TIME_WAIT);
break;
case TCP_LAST_ACK:
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_ACK);
TcpInput(inPkt);
break;
case TCP_TIME_WAIT:
g_pitTicks += 2 * TCP_MSL;
TcpPoll();
break;
default:
ASSERT_EQ_UINT(state, 0);
break;
}
ASSERT_EQ_UINT(conn->state, TCP_CLOSED);
}
// ------------------------------------------------------------------------------------------------
static void EnterState(TcpConn *conn, uint state)
{
NetBuf *inPkt;
TcpHeader *inHdr;
Packet *outPkt;
//TcpHeader *outHdr;
switch (state)
{
case TCP_SYN_SENT:
ASSERT_TRUE(TcpConnect(conn, &s_ipAddr, 80));
outPkt = PopPacket();
free(outPkt);
break;
case TCP_SYN_RECEIVED:
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, 1000, 0, TCP_SYN);
TcpInput(inPkt);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_ESTABLISHED:
EnterState(conn, TCP_SYN_SENT);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_SYN | TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_FIN_WAIT_1:
EnterState(conn, TCP_ESTABLISHED);
TcpClose(conn);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_FIN_WAIT_2:
EnterState(conn, TCP_FIN_WAIT_1);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_ACK);
TcpInput(inPkt);
break;
case TCP_CLOSE_WAIT:
EnterState(conn, TCP_ESTABLISHED);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_FIN | TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_CLOSING:
EnterState(conn, TCP_FIN_WAIT_1);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt - 1, TCP_FIN | TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_LAST_ACK:
EnterState(conn, TCP_CLOSE_WAIT);
TcpClose(conn);
outPkt = PopPacket();
free(outPkt);
break;
case TCP_TIME_WAIT:
EnterState(conn, TCP_FIN_WAIT_1);
inPkt = NetAllocBuf();
inHdr = PrepareInPkt(conn, inPkt, conn->rcvNxt, conn->sndNxt, TCP_FIN | TCP_ACK);
TcpInput(inPkt);
outPkt = PopPacket();
free(outPkt);
break;
default:
ASSERT_EQ_UINT(state, 0);
break;
}
ASSERT_EQ_UINT(conn->state, state);
ASSERT_TRUE(ListIsEmpty(&s_outPackets));
}
void HttpcRun(TCP_HANDLE h, USHORT sLen, PCHAR pBuf)
{
UCHAR iEvent;
if (h != _pHttpcTcb || Sys_iCurMode != SYS_MODE_AUTOPROV)
{
UdpDebugString("unknown tcp handle");
TcpFree(h);
return;
}
iEvent = TcpGetEvent(_pHttpcTcb);
if (iEvent & (TCP_EVENT_RESET|TCP_EVENT_ABORT|TCP_EVENT_USERTO|TCP_EVENT_RETRYTO))
{
UdpDebugString("AutoProv client abort");
if (iEvent & TCP_EVENT_ABORT)
{
TcpStartSend(_pHttpcTcb);
}
// should wait for some time before re-init this socket?
if (_iHttpcTask == HTTPC_TASK_REBOOT)
{
UdpDebugString("rebooting ...");
FlashReboot();
}
else if (_iHttpcTask == HTTPC_TASK_PROV_FAIL)
{
UdpDebugString("Prov failed ...");
HttpcDone(0);
}
else if (_iHttpcTask == HTTPC_TASK_NONE)
{
HttpcDone(1);
}
else
{
if (_iHttpcRetry >= PROV_MAX_RETRY)
{
if (_iHttpcTask == HTTPC_TASK_CFG_AUTH)
{
_iHttpcRetry = 0;
_iHttpcTask = HTTPC_TASK_POST_CFGFAIL;
HttpcRetry();
}
else
{
HttpcFailed();
}
}
else
{
_iHttpcRetry ++;
HttpcRetry();
}
}
return;
}
if (iEvent & TCP_EVENT_CONNECT)
{
UdpDebugString("AutoProv client connect");
if (_iHttpcTask == HTTPC_TASK_GET_PROV)
{
UdpDebugString("Prov stage 2");
HttpcGetProv();
}
else if (_iHttpcTask == HTTPC_TASK_GET_CFG || _iHttpcTask == HTTPC_TASK_CFG_AUTH)
{
UdpDebugIDS(IDS_GET_SETTINGS);
HttpcGetCfg();
}
else if (_iHttpcTask == HTTPC_TASK_GET_SW)
{
UdpDebugIDS(IDS_GET_FIRMWARE);
HttpcGetSW();
}
else if (_iHttpcTask > HTTPC_TASK_REBOOT)
{
UdpDebugString("Post message");
HttpcPostMsg();
}
}
if (iEvent & TCP_EVENT_DATA)
{
HttpcRunData(sLen, pBuf);
}
if (iEvent & TCP_EVENT_CLOSE)
{
UdpDebugString("AutoProv client close");
_iHttpcState = HCS_INIT;
TcpClose(_pHttpcTcb);
}
TcpClearEvent(_pHttpcTcb);
if (_iHttpcState == HCS_MESSAGE_END)
{
TcpClose(_pHttpcTcb);
_iHttpcState = HCS_INIT;
}
TcpStartSend(_pHttpcTcb);
}
