int NetConnect(OpSyslog_Data *op_data)
{
if(op_data == NULL)
{
/* XXX */
return 1;
}
if(op_data->local_logging == 1)
{
return 0;
}
if(op_data->socket > 0)
{
if(NetTestSocket(op_data))
{
op_data->socket = -1;
/* Test reconnection */
}
}
/* Set socket information */
if (inet_aton(op_data->server,&op_data->sockaddr.sin_addr) != 1)
{
if ((op_data->hostPtr = gethostbyname(op_data->server)) == NULL)
{
FatalError("could not resolve address[%s]",op_data->server);
}
memcpy(&op_data->sockaddr.sin_addr,op_data->hostPtr->h_addr,sizeof(op_data->sockaddr.sin_addr));
}
op_data->sockaddr.sin_port = htons(op_data->port);
op_data->sockaddr.sin_family = AF_INET;
switch(op_data->proto)
{
case 0:
return UDPConnect(op_data);
break;
case 1:
return TCPConnect(op_data);
break;
default:
FatalError("Protocol not supported\n");
return 1;
break;
}
/* XXX */
/* Should never be reached */
return 1;
}
int ConnectHopHTTPSProxy(STREAM *S, const char *Proxy, const char *Destination)
{
char *Tempstr=NULL, *Token=NULL;
char *Proto=NULL, *Host=NULL, *User=NULL, *Pass=NULL;
const char *ptr=NULL;
int result=FALSE, Port;
ParseConnectDetails(Proxy, &Token, &Host, &Token, &User, &Pass, NULL);
Port=atoi(Token);
if (! (S->State & SS_INITIAL_CONNECT_DONE))
{
if (Port==0) Port=443;
S->in_fd=TCPConnect(Host,Port,0);
S->out_fd=S->in_fd;
if (S->in_fd == -1)
{
RaiseError(0, "ConnectHopHTTPSProxy", "failed to connect to proxy at %s:%d", Host, Port);
return(FALSE);
}
}
ptr=Destination;
if (strncmp(ptr,"tcp:",4)==0) ptr+=4;
Tempstr=FormatStr(Tempstr,"CONNECT %s HTTP/1.1\r\n\r\n",ptr);
STREAMWriteLine(Tempstr,S);
STREAMFlush(S);
Tempstr=STREAMReadLine(Tempstr,S);
if (Tempstr)
{
StripTrailingWhitespace(Tempstr);
ptr=GetToken(Tempstr," ",&Token,0);
ptr=GetToken(ptr," ",&Token,0);
if (*Token=='2') result=TRUE;
else RaiseError(0, "ConnectHopHTTPSProxy", "proxy request to %s:%d failed. %s", Host, Port, Tempstr);
while (StrLen(Tempstr))
{
Tempstr=STREAMReadLine(Tempstr,S);
StripTrailingWhitespace(Tempstr);
}
}
else RaiseError(0, "ConnectHopHTTPSProxy", "proxy request to %s:%d failed. Server Disconnectd.", Host, Port);
DestroyString(Tempstr);
DestroyString(Token);
DestroyString(Host);
DestroyString(User);
DestroyString(Pass);
return(result);
}
NTSTATUS DispTdiConnect(
PIRP Irp)
/*
* FUNCTION: TDI_CONNECT handler
* ARGUMENTS:
* Irp = Pointer to an I/O request packet
* RETURNS:
* Status of operation
*/
{
PCONNECTION_ENDPOINT Connection;
PTDI_REQUEST_KERNEL Parameters;
PTRANSPORT_CONTEXT TranContext;
PIO_STACK_LOCATION IrpSp;
NTSTATUS Status;
TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
IrpSp = IoGetCurrentIrpStackLocation(Irp);
/* Get associated connection endpoint file object. Quit if none exists */
TranContext = IrpSp->FileObject->FsContext;
if (!TranContext) {
TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
Status = STATUS_INVALID_PARAMETER;
goto done;
}
Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
if (!Connection) {
TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
Status = STATUS_INVALID_PARAMETER;
goto done;
}
Parameters = (PTDI_REQUEST_KERNEL)&IrpSp->Parameters;
Status = DispPrepareIrpForCancel(TranContext->Handle.ConnectionContext,
Irp,
DispCancelRequest);
if (NT_SUCCESS(Status)) {
Status = TCPConnect(
TranContext->Handle.ConnectionContext,
Parameters->RequestConnectionInformation,
Parameters->ReturnConnectionInformation,
DispDataRequestComplete,
Irp );
}
done:
if (Status != STATUS_PENDING) {
DispDataRequestComplete(Irp, Status, 0);
} else
IoMarkIrpPending(Irp);
TI_DbgPrint(MAX_TRACE, ("TCP Connect returned %08x\n", Status));
return Status;
}
TCPClient::TCPClient(string port, string host)
{
TCPConnect(port, host);
}
static BOOL PutFile(void)
{
BYTE v;
switch(smFTPCommand)
{
case SM_FTP_CMD_IDLE:
if ( !FTPFlags.Bits.bLoggedIn )
{
FTPResponse = FTP_RESP_LOGIN;
return TRUE;
}
else
{
FTPResponse = FTP_RESP_DATA_OPEN;
FTPDataSocket = TCPConnect(&REMOTE_HOST(FTPSocket), FTPDataPort.Val);
// Make sure that a valid socket was available and returned
// If not, return with an error
if(FTPDataSocket != INVALID_SOCKET)
{
smFTPCommand = SM_FTP_CMD_WAIT;
}
else
{
FTPResponse = FTP_RESP_DATA_NO_SOCKET;
return TRUE;
}
}
break;
case SM_FTP_CMD_WAIT:
if ( TCPIsConnected(FTPDataSocket) )
{
#if defined(FTP_PUT_ENABLED)
if ( !MPFSIsInUse() )
#endif
{
#if defined(FTP_PUT_ENABLED)
FTPFileHandle = MPFSFormat();
#endif
smFTPCommand = SM_FTP_CMD_RECEIVE;
}
}
break;
case SM_FTP_CMD_RECEIVE:
if ( TCPIsGetReady(FTPDataSocket) )
{
// Reload timeout timer.
lastActivity = TickGet();
MPFSPutBegin(FTPFileHandle);
while( TCPGet(FTPDataSocket, &v) )
{
USARTPut(v);
#if defined(FTP_PUT_ENABLED)
MPFSPut(v);
#endif
}
FTPFileHandle = MPFSPutEnd();
TCPDiscard(FTPDataSocket);
// Print hash characters on FTP client display
if(TCPIsPutReady(FTPSocket))
{
TCPPut(FTPSocket, '#');
TCPFlush(FTPSocket);
}
}
else if ( !TCPIsConnected(FTPDataSocket) )
{
#if defined(FTP_PUT_ENABLED)
MPFSPutEnd();
MPFSClose();
#endif
TCPDisconnect(FTPDataSocket);
FTPDataSocket = INVALID_SOCKET;
FTPResponse = FTP_RESP_DATA_CLOSE;
return TRUE;
}
}
return FALSE;
}
void timeSync(void)
{
BYTE i;
signed char j;
static TICK Timer;
static TICK perodicTick = 0;
static TICK t = 0;
static TCP_SOCKET MySocket = INVALID_SOCKET;
static NODE_INFO Server;
static int arp_tries = 0;
static int tcp_tries = 0;
BYTE rcnt=0;
BYTE ncnt=0;
char foundData=0;
if ((tickGet()-t) >= TICK_1S )
{
t = tickGet();
timeNow++;
}
switch(smTS)
{
case SM_START:
#if defined(TIMESYNC_DEBUG)
putrsUART("Start!\r\n");
#endif
// Set IP adress to connect to.
Server.IPAddr.v[0]=193;
Server.IPAddr.v[1]=11;
Server.IPAddr.v[2]=249;
Server.IPAddr.v[3]=54;
arp_tries = 0;
tcp_tries = 0;
smTS = SM_ARP_RESOLVE;
break;
case SM_ARP_RESOLVE:
#if defined(TIMESYNC_DEBUG)
putrsUART("Resolve..\r\n");
#endif
// If ARP is redy..
if (ARPIsTxReady())
{
// Resolve the IP adress..
ARPResolve(&Server.IPAddr);
arp_tries++;
Timer = tickGet();
smTS = SM_ARP_RESOLVED;
}
break;
case SM_ARP_RESOLVED:
#if defined(TIMESYNC_DEBUG)
putrsUART("Resolved..\r\n");
#endif
// If IP adress is resolved, go to next state
if (ARPIsResolved(&Server.IPAddr, &Server.MACAddr))
{
smTS = SM_CONNECT;
}
// If not resolved and spent long time here,
// Go back to previous state and re-resolve.
else if (tickGet()-Timer > 1*TICK_1S)
{
smTS = SM_ARP_RESOLVE;
}
else if (arp_tries>=MAX_ARP_TRIES)
{
//Abort
smTS = SM_ABORT;
}
break;
case SM_CONNECT:
#if defined(TIMESYNC_DEBUG)
putrsUART("Connect..\r\n");
#endif
// We have an sucessfull ARP, connect..
MySocket = TCPConnect(&Server, ServerPort);
tcp_tries++;
if(MySocket == INVALID_SOCKET)
{
// Do something.
}
Timer = tickGet();
smTS = SM_CONNECT_WAIT;
break;
case SM_CONNECT_WAIT:
#if defined(TIMESYNC_DEBUG)
putrsUART("Connect wait..\r\n");
#endif
// Wait for connection..
if (TCPIsConnected(MySocket))
{
smTS = SM_CONNECTED;
}
// If not connected and spent long time here,
// Go back to previous state and re-connect.
else if (tickGet()-Timer > 5*TICK_1S)
{
TCPDisconnect(MySocket);
MySocket = INVALID_SOCKET;
smTS = SM_CONNECT;
}
else if (tcp_tries>=MAX_TCP_TRIES)
{
//Abort
TCPDisconnect(MySocket);
MySocket = INVALID_SOCKET;
smTS = SM_ABORT;
}
break;
case SM_CONNECTED:
#if defined(TIMESYNC_DEBUG)
putrsUART("Connected..\r\n");
#endif
// Send data.
Timer = tickGet();
if(TCPIsPutReady(MySocket))
{
TCPPut(MySocket, 'G');
TCPPut(MySocket, 'E');
TCPPut(MySocket, 'T');
TCPPut(MySocket, ' ');
TCPPut(MySocket, '/');
TCPPut(MySocket, 't');
TCPPut(MySocket, 'i');
TCPPut(MySocket, 'm');
TCPPut(MySocket, 'e');
TCPPut(MySocket, '.');
TCPPut(MySocket, 'p');
TCPPut(MySocket, 'h');
TCPPut(MySocket, 'p');
TCPPut(MySocket, ' ');
TCPPut(MySocket, 'H');
TCPPut(MySocket, 'T');
TCPPut(MySocket, 'T');
TCPPut(MySocket, 'P');
TCPPut(MySocket, '/');
TCPPut(MySocket, '1');
TCPPut(MySocket, '.');
TCPPut(MySocket, '0');
TCPPut(MySocket, '\r');
TCPPut(MySocket, '\n');
TCPPut(MySocket, '\r');
TCPPut(MySocket, '\n');
// Send the packet
TCPFlush(MySocket);
smTS = SM_RECEIVE;
}
break;
case SM_RECEIVE:
#if defined(TIMESYNC_DEBUG)
putrsUART("Receive..\r\n");
#endif
// Client disconnected.
if(!TCPIsConnected(MySocket))
{
smTS = SM_ABORT;
break;
}
if(TCPIsGetReady(MySocket))
{
while(TCPGet(MySocket, &i))
{
if (i==CR) rcnt++;
else if(i==LF) ncnt++;
else
{
rcnt=0;
ncnt=0;
}
if (foundData==1)
{
if (j>=0)
{
timeNow=timeNow+(((DWORD)i)<<(8*j--));
#if defined(TIMESYNC_DEBUG)
while(BusyUART()); WriteUART(i);
#endif
}
}
if(rcnt>1 && ncnt>1) {j=3; timeNow=0; foundData=1;}
}
smTS = SM_DISCONNECT;
}
break;
case SM_DISCONNECT:
#if defined(TIMESYNC_DEBUG)
putrsUART("\r\nDisconnect\r\n");
#endif
foundData=0;
t = tickGet();
lastSync = timeNow;
perodicTick=tickGet();
TCPDisconnect(MySocket);
MySocket = INVALID_SOCKET;
smTS = SM_DONE;
break;
case SM_ABORT:
#if defined(TIMESYNC_DEBUG)
putrsUART("Abort...\r\n");
#endif
smTS = SM_START;
break;
case SM_DONE:
if (tickGet()-perodicTick > SYNC_INTERVAL*TICK_1S)
{
#if defined(TIMESYNC_DEBUG)
putrsUART("GO!\r\n");
#endif
smTS = SM_START;
}
break;
default: smTS = SM_START; break;
}
}
/*********************************************************************
* Function: void GenericTCPClient(void)
*
* PreCondition: Stack is initialized()
*
* Input: None
*
* Output: None
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
void GenericTCPClient(void)
{
BYTE i;
BYTE *StringPtr;
static TICK Timer;
static TCP_SOCKET MySocket = INVALID_SOCKET;
static NODE_INFO Server;
static enum _GenericTCPExampleState
{
SM_HOME = 0,
SM_NAME_RESOLVE,
SM_ARP_START_RESOLVE,
SM_ARP_RESOLVE,
SM_SOCKET_OBTAIN,
SM_SOCKET_OBTAINED,
SM_PROCESS_RESPONSE,
SM_DISCONNECT,
SM_DONE
} GenericTCPExampleState = SM_DONE;
switch(GenericTCPExampleState)
{
case SM_HOME:
// Obtain ownership of the DNS resolution module
if(!DNSBeginUsage())
break;
// Obtain the IP address associated with the common ServerName
DNSResolve(ServerName, DNS_TYPE_A);
GenericTCPExampleState++;
break;
case SM_NAME_RESOLVE:
// Wait for the DNS server to return the requested IP address
if(!DNSIsResolved(&Server.IPAddr))
break;
// Release the DNS module, we no longer need it
if(!DNSEndUsage())
{
// An invalid IP address was returned from the DNS
// server. Quit and fail permanantly if host is not valid.
GenericTCPExampleState = SM_DONE;
break;
}
GenericTCPExampleState++;
case SM_ARP_START_RESOLVE:
// Obtain the MAC address associated with the server's IP address (either direct MAC address on same subnet, or the MAC address of the Gateway machine)
ARPResolve(&Server.IPAddr);
Timer = TickGet();
GenericTCPExampleState++;
break;
case SM_ARP_RESOLVE:
// Wait for the MAC address to finish being obtained
if(!ARPIsResolved(&Server.IPAddr, &Server.MACAddr))
{
// Time out if too much time is spent in this state
if(TickGet()-Timer > 1*TICK_SECOND)
{
// Retransmit ARP request
GenericTCPExampleState--;
}
break;
}
GenericTCPExampleState++;
case SM_SOCKET_OBTAIN:
// Connect a socket to the remote TCP server
MySocket = TCPConnect(&Server, ServerPort);
// Abort operation if no TCP sockets are available
// If this ever happens, incrementing MAX_TCP_SOCKETS in
// StackTsk.h may help (at the expense of more global memory
// resources).
if(MySocket == INVALID_SOCKET)
break;
GenericTCPExampleState++;
Timer = TickGet();
break;
case SM_SOCKET_OBTAINED:
// Wait for the remote server to accept our connection request
if(!TCPIsConnected(MySocket))
{
// Time out if too much time is spent in this state
if(TickGet()-Timer > 5*TICK_SECOND)
{
// Close the socket so it can be used by other modules
TCPDisconnect(MySocket);
MySocket = INVALID_SOCKET;
GenericTCPExampleState--;
}
break;
}
Timer = TickGet();
// Make certain the socket can be written to
if(!TCPIsPutReady(MySocket))
break;
// Place the application protocol data into the transmit buffer. For this example, we are connected to an HTTP server, so we'll send an HTTP GET request.
TCPPutROMString(MySocket, (ROM BYTE*)"GET ");
TCPPutROMString(MySocket, RemoteURL);
TCPPutROMString(MySocket, (ROM BYTE*)" HTTP/1.1\r\nHost: ");
TCPPutString(MySocket, ServerName);
TCPPutROMString(MySocket, (ROM BYTE*)"\r\n\r\n");
// Send the packet
TCPFlush(MySocket);
GenericTCPExampleState++;
case SM_PROCESS_RESPONSE:
// Check to see if the remote node has disconnected from us or sent us any application data
// If application data is available, write it to the UART
if(!TCPIsConnected(MySocket))
{
GenericTCPExampleState++;
}
if(!TCPIsGetReady(MySocket))
break;
// Obtain the server reply
while(TCPGet(MySocket, &i))
{
while(BusyUART());
WriteUART(i);
}
break;
case SM_DISCONNECT:
// Close the socket so it can be used by other modules
// For this application, we wish to stay connected, but this state will still get entered if the remote server decides to disconnect
TCPDisconnect(MySocket);
MySocket = INVALID_SOCKET;
GenericTCPExampleState = SM_DONE;
break;
case SM_DONE:
// Do nothing unless the user pushes BUTTON1 and wants to restart the whole connection/download process
if(BUTTON1_IO == 0u)
GenericTCPExampleState = SM_HOME;
break;
}
}
/*********************************************************************
* Function: void SMTP Client State machine(void)
*
* PreCondition: FTPInit() must already be called.
*
* Input: None
*
* Output: Ready to send mail.
*
* Side Effects: None
*
* Overview:
*
* Note: This function acts as a task (similar to one in
* RTOS). This function performs its task in
* co-operative manner. Main application must call
* this function repeatedly to ensure it can send
* mails when requested. (include in the main loop)
********************************************************************/
void SMTPClient(void)
{
BYTE v;
// TICK currentTick;
// check if state machine is stuck somewhere and reset the SM after a while if needed :
if ((smSMTP != SM_SMTP_STDBY) && (TickGetDiff(TickGet(), lastActivity) > (15 * TICK_SECOND))) {
if (TCPIsConnected(SMTPSocket))
TCPDisconnect(SMTPSocket) ;
if(cptretry--) { // if not all retries done...
lastActivity = TickGet(); // re-init delay
smSMTP = SM_SMTP_STDBY ; // force standby state
} else {
fsend_mail = FALSE ; // give up !
smSMTP = SM_SMTP_STDBY ; // -> standby
}
}
// work each state :
switch(smSMTP)
{
case SM_SMTP_STDBY: // standby: idle, waiting for connection request
if (fsend_mail) {
if (TickGetDiff(TickGet(), lastActivity) > (10 * TICK_SECOND)) {
USARTPut(0xBB) ;
lastActivity = TickGet();
ARPResolve(&nodedist.IPAddr) ; // resolve IP adress
smSMTP = SM_SMTP_ARP ; // -> wait ARP answer
}
}
break ;
case SM_SMTP_ARP: // wait ARP to be resolved
if ( ARPIsResolved(&nodedist.IPAddr, &nodedist.MACAddr)) {
SMTPSocket = TCPConnect(&nodedist, SMTP_PORT) ;
if (SMTPSocket == INVALID_SOCKET) {
fsend_mail = FALSE ; // avorte
} else {
smSMTP = SM_SMTP_CONNECT ; // -> attente ACK
}
}
break ;
case SM_SMTP_CONNECT: // standby: attente ack connexion
if (TCPIsConnected(SMTPSocket)) {
smSMTP = SM_SMTP_WELCOME ; // -> attente WELCOME
}
break ;
case SM_SMTP_WELCOME: // attente welcome du serveur
if (TCPIsGetReady(SMTPSocket)) {
if (TCPGet(SMTPSocket, &v)) {
if (v == '2') { // commence par un 2 ? (220..)
TCPDiscard(SMTPSocket) ;
ExecuteSMTPCommand(SMTP_CMD_HELO) ;
smSMTP = SM_SMTP_HELO ; // -> attente reponse au HELO
}else {
smSMTP = SM_SMTP_DONE ; // -> disconnect
}
}
}
break ;
case SM_SMTP_HELO: // attente HELO du serveur
if (TCPIsGetReady(SMTPSocket)) {
if (TCPGet(SMTPSocket,&v)) {
if (v == '2') { // commence par un 2 ? (220..)
TCPDiscard(SMTPSocket) ;
ExecuteSMTPCommand(SMTP_CMD_FROM) ;
smSMTP = SM_SMTP_FROM ; // -> attente reponse au FROM
}else {
smSMTP = SM_SMTP_DONE ; // -> disconnect
}
}
}
break ;
case SM_SMTP_FROM: // attente HELO du serveur
if (TCPIsGetReady(SMTPSocket)) {
if (TCPGet(SMTPSocket,&v)) {
if (v == '2') { // commence par un 2 ? (220..)
TCPDiscard(SMTPSocket) ;
ExecuteSMTPCommand(SMTP_CMD_TO) ;
smSMTP = SM_SMTP_TO ; // -> attente reponse au TO
}else {
smSMTP = SM_SMTP_DONE ; // -> disconnect
}
}
}
break ;
case SM_SMTP_TO: // attente HELO du serveur
if (TCPIsGetReady(SMTPSocket)) {
if (TCPGet(SMTPSocket,&v)) {
if (v == '2') { // commence par un 2 ? (220..)
TCPDiscard(SMTPSocket) ;
ExecuteSMTPCommand(SMTP_CMD_DATA) ;
smSMTP = SM_SMTP_DATA1 ; // -> attente reponse au DATA
}else {
smSMTP = SM_SMTP_DONE ; // -> disconnect
}
}
}
break ;
case SM_SMTP_DATA1: // when OK send message headers
if (TCPIsGetReady(SMTPSocket)) {
if (TCPGet(SMTPSocket,&v)) {
if (v == '3') { // commence par un 3 ? (220..)
TCPDiscard(SMTPSocket) ;
ExecuteSMTPCommand(SMTP_CMD_DATA_HEADERS) ; // send headers
// ExecuteSMTPCommand(SMTP_CMD_DATA_MESSAGE) ; // message
// ExecuteSMTPCommand(SMTP_CMD_DATA_END) ; // termine
smSMTP = SM_SMTP_DATA2; // -> send body
}else {
smSMTP = SM_SMTP_DONE ; // -> disconnect
}
}
}
break ;
case SM_SMTP_DATA2: // wait to send message body
if (TCPIsPutReady(SMTPSocket)) { // wait for TX buffer free
ExecuteSMTPCommand(SMTP_CMD_DATA_MESSAGE) ; // message
smSMTP = SM_SMTP_DATA3 ; // -> attente reponse au TO
} else {
// USARTPut(0xCC) ; vérifié qu'il y avait bien besoin d'une attente ici
}
break ;
case SM_SMTP_DATA3: // wait to send the final "."
if (TCPIsPutReady(SMTPSocket)) { // wait for TX buffer free
ExecuteSMTPCommand(SMTP_CMD_DATA_END) ; // termine
smSMTP = SM_SMTP_QUIT ; // -> end
} else {
// USARTPut(0xDD) ; vérifié qu'il y avait bien besoin d'une attente ici
}
break ;
case SM_SMTP_QUIT: // wait last message before leaving...
if (TCPIsGetReady(SMTPSocket)) {
if (TCPGet(SMTPSocket,&v)) {
if (v == '2') { // commence par un 2 ? (220..)
TCPDiscard(SMTPSocket) ;
smSMTP = SM_SMTP_DONE ; // -> deconnecte
}else {
smSMTP = SM_SMTP_DONE ; // -> disconnect
}
}
}
break ;
case SM_SMTP_DONE: // disconnect Socket :
if (TCPIsConnected(SMTPSocket) && (TCPIsPutReady(SMTPSocket))) { // wait for TX buff free
TCPDisconnect(SMTPSocket) ;
}
fsend_mail = FALSE ; // done !
smSMTP = SM_SMTP_STDBY ; // -> standby
break ;
}
}
void lftp_task( void )
{
WORD ttt;
BYTE c;
BOOL bPreLine;
BOOL bPostLine;
// Nothing to do if we don't have a link
if ( !MACIsLinked() ) return;
// check if state machine is stuck somewhere and reset the it after a while if needed :
if ( ( ftp_state != LFTP_STATE_NONE ) &&
( TickGetDiff( TickGet(), lastActivity) > ( LFTP_TIMEOUT * TICK_SECOND ) ) ) {
// Close ftp client socker if open
//if ( TCPIsConnected( ftpsocket ) ) {
writeRomString2Socket( quit );
TCPDisconnect( ftpsocket );
ftpsocket = UNKNOWN_SOCKET;
//}
// Close data socket if open
TCPDisconnect( datasocket );
datasocket = UNKNOWN_SOCKET;
// Check if we should try again or if its time
// to pack it in
cntBeforeFail++;
if ( cntBeforeFail > LFTP_MAX_RETRIES ) {
cntBeforeFail = 0;
ftp_state = LFTP_STATE_NONE; // Give up...
bftpLoadWork = FALSE; // Work is done - failed
}
ftp_state = LFTP_STATE_NONE;
}
switch( ftp_state ) {
// **
// Start to work if its time to do so
case LFTP_STATE_NONE:
// Check timer and see if we should fetch
// data from the server.
lastActivity = TickGet();
if ( bftpLoadWork ) {
ftp_state = LFTP_STATE_ARP; // Must get MAC address for server
cntBeforeFail = 0; // Init. failure counter
DBG_OUT('A');
}
break;
//**
// Resolve the MAC address of the ftp server
case LFTP_STATE_ARP:
ftp_nodeinfo.IPAddr.v[ 0 ] = LFTP_SERVER_IP_v0;
ftp_nodeinfo.IPAddr.v[ 1 ] = LFTP_SERVER_IP_v1;
ftp_nodeinfo.IPAddr.v[ 2 ] = LFTP_SERVER_IP_v2;
ftp_nodeinfo.IPAddr.v[ 3 ] = LFTP_SERVER_IP_v3;
if ( ARPIsTxReady() ) {
DBG_OUT('B');
ARPResolve( &ftp_nodeinfo.IPAddr ); // resolve IP adress
ftp_state = LFTP_STATE_ARP_RESOLVE;
lastActivity = TickGet();
}
break;
// **
// Check if the ftp MAC address is resolved
case LFTP_STATE_ARP_RESOLVE:
if ( ARPIsResolved( &ftp_nodeinfo.IPAddr, &ftp_nodeinfo.MACAddr ) ) {
DBG_OUT('D');
ftp_state = LFTP_STATE_CONNECT;
lastActivity = TickGet();
}
break;
// **
// Connect to ftp server
case LFTP_STATE_CONNECT:
// Try to connect
ftpsocket = TCPConnect( &ftp_nodeinfo, LFTP_PORT );
if ( INVALID_SOCKET != ftpsocket ) {
DBG_OUT('E');
ftp_state = LFTP_STATE_CONNECT_WAIT;
lastActivity = TickGet();
}
break;
// **
// Waiting for ftp connection
case LFTP_STATE_CONNECT_WAIT:
if ( TCPIsConnected( ftpsocket ) ) {
DBG_OUT('F');
ftp_state = LFTP_STATE_USER;
lastActivity = TickGet();
}
break;
// Here we wait for server connection and send
// USER command if OK
case LFTP_STATE_USER:
// Fetch data if we are connected
if ( TCPIsGetReady( ftpsocket ) ) {
// get first digit
while( TCPGet( ftpsocket, &c ) ) {
if ( isdigit( c ) ) break;
}
// If connected with positive response "2xx - xxxxxxxx..."
// we send username. If not we just timeout
if ( '2' == c ) {
DBG_OUT('G');
writeRomString2Socket( user );
ftp_state = LFTP_STATE_PASS;
lastActivity = TickGet();
}
TCPDiscard( ftpsocket );
}
break;
// **
// Here we wait for response from USER command
// and send PASS command if OK
case LFTP_STATE_PASS:
// Fetch data if we are connected
if ( TCPIsGetReady( ftpsocket ) ) {
DBG_OUT('$');
// get first digit
while( TCPGet( ftpsocket, &c ) ) {
DBG_OUT(c);
if ( isdigit( c ) ) break;
}
// If connected with positive response "3xx - xxxxxxxx..."
// we send username. If not we just timeout
if ( ('3' == c ) || ('2' == c ) ) {
DBG_OUT('H');
writeRomString2Socket( pass );
ftp_state = LFTP_STATE_PASV;
lastActivity = TickGet();
}
TCPDiscard( ftpsocket );
}
break;
// **
// Here we wait for response of PASS command
// and send PASV command if positive and also
// creates the data socket
case LFTP_STATE_PASV:
// Fetch data if we are connected
if ( TCPIsGetReady( ftpsocket ) ) {
DBG_OUT('!');
// get first digit
while( TCPGet( ftpsocket, &c ) ) {
DBG_OUT(c);
if ( isdigit( c ) ) break;
}
// If connected with positive response "2xx - xxxxxxxx..."
// we send username. If not we just timeout
if ( '2' == c ) {
DBG_OUT('I');
writeRomString2Socket( pasv );
ftp_state = LFTP_STATE_RETR;
lastActivity = TickGet();
}
TCPDiscard( ftpsocket );
}
break;
// **
// Here we wait for the result of PASV command
// and parse its data
// if OK we send RETR and go on to the next state
case LFTP_STATE_RETR:
// Fetch data if we are connected
if ( TCPIsGetReady( ftpsocket ) ) {
TCPGet( ftpsocket, &c );
if ( '2' == c ) {
DBG_OUT('J');
// Get pasv parameters
getPasvParams();
// retrive file
writeRomString2Socket( retr );
ttt = portdata;
while ( ttt ) {
DBG_OUT('0' + (ttt % 10) );
ttt = ttt / 10;
}
ftp_state = LFTP_STATE_DATA_CONNECT;
}
TCPDiscard( ftpsocket );
}
break;
// **
// Connect to the data socket
case LFTP_STATE_DATA_CONNECT:
// Try to connect
datasocket = TCPConnect( &ftp_nodeinfo, portdata );
if ( INVALID_SOCKET != datasocket ) {
DBG_OUT('K');
ftp_state = LFTP_STATE_WAIT_DATA_CONNECT;
lastActivity = TickGet();
}
break;
// **
// Wait for the data connection to establish
case LFTP_STATE_WAIT_DATA_CONNECT:
if ( TCPIsConnected( datasocket ) ) {
DBG_OUT('L');
//writeRomString2Socket( lftpDataSocket, crlf );
ftp_state = LFTP_STATE_FETCH_DATA;
lastActivity = TickGet();
}
// Check for reply on ftp socket FIX!!!!
if ( TCPIsGetReady( ftpsocket ) ) {
DBG_OUT('?');
while( TCPGet( ftpsocket, &c ) ) {
DBG_OUT( c );
}
TCPDiscard( ftpsocket );
}
break;
// **
// Fetch the data and send it out on the
// serial i/f
case LFTP_STATE_FETCH_DATA:
// Fetch data if we are connected
if ( TCPIsGetReady( datasocket ) ) {
DBG_OUT('M');
// Framework start
serPutByte( 0x00 );
serPutByte( 0xff );
serPutByte( 0xff );
serPutByte( 0x01 );
serPutByte( 0x01 );
serPutByte( 0x01 );
bPreLine = FALSE;
bPostLine = FALSE;
// get data
while( TCPGet( datasocket, &c ) ) {
if ( 0x0d == c ) {
// We skip CR
}
else if ( 0x0a == c ) {
// Send end line stuff
serPutByte( 0xff );
bPreLine = FALSE;
bPostLine = TRUE;
}
else {
bPostLine = FALSE; // no end line codes sent
if ( !bPreLine ) {
// Send preline stuff
bPreLine = TRUE;
serPutByte( 0x01 );
serPutByte( 0x03 );
serPutByte( 0xef );
serPutByte( 0xb0 );
}
serPutByte( c );
}
}
// If we end with a row without LF we must send
// Line end stuff
if ( !bPostLine ) {
serPutByte( 0xff );
}
// Framework end
serPutByte( 0xff );
serPutByte( 0x00 );
ftp_state = LFTP_STATE_END;
TCPDiscard( datasocket );
}
// Check for data on ftp socket
if ( TCPIsGetReady( ftpsocket ) ) {
while( TCPGet( ftpsocket, &c ) ) {
DBG_OUT( c );
}
TCPDiscard( ftpsocket );
}
break;
// **
// We are done for this time
case LFTP_STATE_END:
DBG_OUT('*');
TCPDisconnect( ftpsocket );
TCPDisconnect( datasocket );
bftpLoadWork = FALSE; // Work is done
ftp_state = LFTP_STATE_NONE;
break;
}
}
int ConnectHopSSH(STREAM *S, int Type, const char *ProxyURL, const char *Destination)
{
char *Tempstr=NULL, *Token=NULL, *Token2=NULL;
char *Host=NULL, *User=NULL, *Pass=NULL;
STREAM *tmpS;
int result=FALSE, val, i;
unsigned int Port=0, DPort=0;
ParseConnectDetails(ProxyURL, NULL, &Host, &Token, &User, &Pass, NULL);
if (StrValid(Token)) Port=atoi(Token);
if (Type==CONNECT_HOP_SSHTUNNEL)
{
//get hostname and port of next hop
DPort=(rand() % (0xFFFF - 9000)) +9000;
//Host will be Token, and port Token2
ParseConnectDetails(Destination, NULL, &Token, &Token2, NULL, NULL, NULL);
Tempstr=FormatStr(Tempstr,"tunnel:%d:%s:%s ",DPort,Token,Token2);
tmpS=SSHConnect(Host, Port, User, Pass, Tempstr);
if (tmpS)
{
if (! S->Items) S->Items=ListCreate();
ListAddNamedItem(S->Items, "LU:AssociatedStream", tmpS);
for (i=0; i < 60; i++)
{
S->in_fd=TCPConnect("127.0.0.1",DPort,0);
if (S->in_fd > -1)
{
S->out_fd=S->in_fd;
result=TRUE;
break;
}
usleep(200000);
}
}
}
else
{
ParseConnectDetails(Destination, NULL, &Token, &Token2, NULL, NULL, NULL);
DPort=atoi(Token2);
Tempstr=FormatStr(Tempstr,"stdin:%s:%d", Token, DPort);
tmpS=SSHConnect(Host, Port, User, Pass, Tempstr);
if (tmpS)
{
usleep(200000);
result=TRUE;
S->in_fd=tmpS->in_fd;
S->out_fd=tmpS->out_fd;
}
if (tmpS)
{
//set these to -1 so STREAMClose won't close our connection
tmpS->in_fd=-1;
tmpS->out_fd=-1;
STREAMClose(tmpS);
}
}
if (! result) RaiseError(0, "ConnectHopSSH", "failed to sshtunnel via %s to %s", ProxyURL, Destination);
DestroyString(Tempstr);
DestroyString(Token2);
DestroyString(Token);
DestroyString(Host);
DestroyString(User);
DestroyString(Pass);
return(result);
}
int ConnectHopSocks(STREAM *S, int SocksLevel, const char *ProxyURL, const char *Destination)
{
char *Tempstr=NULL;
char *Token=NULL, *Host=NULL, *User=NULL, *Pass=NULL;
uint8_t *ptr;
uint32_t IP;
const char *tptr;
int result, RetVal=FALSE, val;
uint8_t HostType=HT_IP4;
ParseConnectDetails(ProxyURL, NULL, &Host, &Token, &User, &Pass, NULL);
if (! (S->State & SS_INITIAL_CONNECT_DONE))
{
val=atoi(Token);
S->in_fd=TCPConnect(Host, val, 0);
S->out_fd=S->in_fd;
if (S->in_fd == -1)
{
RaiseError(0, "ConnectHopSocks", "connection to socks proxy at %s failed", ProxyURL);
return(FALSE);
}
if (SocksLevel==CONNECT_HOP_SOCKS5)
{
if (! ConnectHopSocks5Auth(S, User, Pass))
{
RaiseError(0, "ConnectHopSocks", "authentication to socks proxy at %s failed", ProxyURL);
return(FALSE);
}
}
}
//Horrid binary protocol.
Tempstr=SetStrLen(Tempstr, StrLen(User) + 20 + StrLen(Destination));
ptr=Tempstr;
//version
if (SocksLevel==CONNECT_HOP_SOCKS5) *ptr=5;
else *ptr=4; //version number
ptr++;
//connection type
*ptr=1; //outward connection (2 binds a port for incoming)
ptr++;
//Sort out destination now
tptr=Destination;
if (strncmp(tptr,"tcp:",4)==0) tptr+=4;
tptr=GetToken(tptr,":",&Token,0);
if (IsIP4Address(Token)) HostType=HT_IP4;
else if (IsIP6Address(Token)) HostType=HT_IP6;
else HostType=HT_DOMAIN;
if (SocksLevel==CONNECT_HOP_SOCKS5)
{
//Socks 5 has a 'reserved' byte after the connection type
*ptr=0;
ptr++;
*ptr=HostType;
ptr++;
switch (HostType)
{
case HT_IP4:
*((uint32_t *) ptr) =StrtoIP(Token);
ptr+=4;
break;
case HT_IP6:
break;
default:
val=StrLen(Token);
*ptr=val;
ptr++;
memcpy(ptr, Token, val);
ptr+=val;
break;
}
}
//destination port. By a weird coincidence this is in the right place
//for either socks4 or 5, despite the fact that it comes after the
//host in socks5, and before the host in socks4
*((uint16_t *) ptr) =htons(atoi(tptr));
ptr+=2;
if (SocksLevel==CONNECT_HOP_SOCKS4)
{
//destination host
switch (HostType)
{
case HT_IP4:
*((uint32_t *) ptr) =StrtoIP(Token);
ptr+=4;
val=StrLen(User)+1;
memcpy(ptr,User,val);
ptr+=val;
break;
default:
*((uint32_t *) ptr) =StrtoIP("0.0.0.1");
ptr+=4;
break;
}
val=StrLen(User)+1;
memcpy(ptr, User, val);
ptr+=val;
//+1 to include terminating \0
val=StrLen(Token) +1;
memcpy(ptr, Token, val);
ptr+=val;
}
STREAMWriteBytes(S,Tempstr,(char *)ptr-Tempstr);
STREAMFlush(S);
Tempstr=SetStrLen(Tempstr, 32);
result=STREAMReadBytes(S,Tempstr,32);
if (SocksLevel==CONNECT_HOP_SOCKS5)
{
if ((result > 8) && (Tempstr[0]==5) && (Tempstr[1]==0))
{
RetVal=TRUE;
}
}
else
{
//Positive response will be 0x00 0x5a 0x00 0x00 0x00 0x00 0x00 0x00
//although only the leading two bytes (0x00 0x5a, or \0Z) matters
if ((result==8) && (Tempstr[0]=='\0') && (Tempstr[1]=='Z'))
{
RetVal=TRUE;
IP=*(uint32_t *) (Tempstr + 4);
if (IP != 0) STREAMSetValue(S, "IPAddress", IPtoStr(IP));
}
}
if (! RetVal) RaiseError(0, "ConnectHopSocks", "socks proxy at %s refused connection to %s", ProxyURL, Destination);
DestroyString(Tempstr);
DestroyString(Host);
DestroyString(User);
DestroyString(Pass);
DestroyString(Token);
return(RetVal);
}
