static void OutDot(TCP_SOCKET socket, WORD wv) { //, BYTE t) { BYTE i,r, bafs[6], sus[8]; uitoa(wv, bafs); r = strlen(bafs); for(i=0;i<5-r;i++) sus[i] = '0'; sus[i]=0; strcat(sus,bafs); for(i=0;i<5;i++) { TCPPut(socket, sus[i]); if(i==2) TCPPut(socket, '.'); } }
static void DoStic(TCP_SOCKET socket, BYTE t) { BYTE ch; static double qw; static DWORD ruti, eti, uti; WORD *ww = (WORD*)&httpData[0]; if(t==1) { TCPPutROMString(socket,s_High); for(ch=1;ch<=32;ch++) TCPPut(socket, 0x30+ch/10); TCPPutROMString(socket,s_Lowx); for(ch=1;ch<=32;ch++) TCPPut(socket, 0x30+ch%10); TCPPutROMString(socket,s_Exst); for(ch=0;ch<32;ch++) TCPPut(socket, GetExist(ch) ? 'O':'x'); } else if(t==2) { ruti = dwRunt/100ul; for(ch=0;ch<32;ch++) { if(ruti) { qw = (double)acci[ch]; qw /= (double)ruti; ww[ch] = (WORD)(qw * C_PERF); if(ww[ch]>=1000u) ww[ch]=999u; } else ww[ch] = 0ul; } TCPPutROMString(socket,(ROM BYTE*)"</font><font face=courier new size=2 color=white>"); for(ch=0;ch<32;ch+=8) OutShit(socket,ch); } else if(t==3){ ruti = dwRunt/100ul; TCPPutROMString(socket,s_gotn); OutLong(socket, gotn, 10); TCPPutROMString(socket,s_subm); OutLong(socket, subm, 10); if(ruti) { qw = (double)subm; qw /= (double)ruti; eti = (DWORD)(qw * C_PERF); uti = (DWORD)(qw * 6000.0); } else eti=uti=0ul; TCPPutROMString(socket,s_mhs); OutLong(socket, eti, 5); TCPPutROMString(socket,s_uts); OutDot(socket, uti); if(gotn) { qw = (double)subm/(double)gotn; qw *= 10000.0; uti = (DWORD)qw;} else uti=0ul; TCPPutROMString(socket, s_effi); OutDot(socket,uti); TCPPutROMString(socket, smt); OutTime(socket, ruti/(3600ul * 24ul), 'd'); OutTime(socket, (ruti/(3600ul))%24ul, 'h'); OutTime(socket, (ruti/60ul)%60ul, 'm'); OutTime(socket, ruti%60ul, 's'); TCPPutROMString(socket, s_cpool); TCPPutROMString(socket, rMinPool[AppConfig.who]); TCPPutROMString(socket,AppConfig.who ? s_PoolB:s_PoolA); TCPPutROMString(socket, s_swm); TCPPutROMString(socket, AppConfig.sw_mode ? s_PB:s_EP); TCPPutROMString(socket, s_clk); TCPPutROMString(socket, (AppConfig.CkSel&1) ? s_CkLow:s_CkHigh); } }
static void OutTime(TCP_SOCKET socket, WORD wv, BYTE bt) { BYTE bafs[12]; uitoa(wv,bafs); if(bt != 'd') if(strlen(bafs) < 2) TCPPut(socket, '0'); TCPPutString(socket, bafs); TCPPut(socket, bt); if(bt != 's') { TCPPut(socket, ','); } // TCPPut(socket, ' '); } }
// Callback function for the dynamic variable ~led(num)~. void HTTPPrint_led(WORD num) { // Determine which LED switch(num) { case 0: num = IOGet(p4); break; case 1: num = IOGet(p6); break; case 2: num = IOGet(p17); break; case 3: num = IOGet(p19); break; case 4: num = IOGet(p21); break; default: num = 0; } // Sending back the led status to the webpage. TCPPut(sktHTTP, (num?'1':'0')); return; }
void sendStringEthernet( char * p, char newLine ) { int l = 0; WORD wMaxPut; // Make sure the Socket is connected to something! if(!TCPIsConnected(MySocket)) return; // Find the length of the string while (*(p+l) != 0x00) l++; if(l) { wMaxPut = TCPIsPutReady(MySocket); if(wMaxPut < l) { #ifdef __DEBUG while(1); // Hold here while debugging #endif } else { // Transfer the data out of our local processing buffer and into the TCP TX FIFO. TCPPutArray(MySocket, (BYTE*)p, l); } } if(newLine) TCPPut(MySocket, 10); TCPFlush(MySocket); // Send the data immediatly! }
BOOL PutTelnetConsole(char c) { TCP_SOCKET MySocket; WORD i; MySocket = hTelnetSockets[0]; if (vTelnetStates[0] != SM_AUTHENTICATED) return 1; if (termbufidx < MAXTERMBUF) { termbuf[termbufidx++] = c; termbuftimer = 0; return 1; } if (TCPIsPutReady(MySocket) < termbufidx) { StackTask(); StackApplications(); return 0; } for(i = 0; i < termbufidx; i++) TCPPut(MySocket,termbuf[i]); TCPFlush(MySocket); termbufidx = 0; termbuftimer = 0; return 0; }
void my_socket_write(char* pMsg) { BYTE v; while( (v = *pMsg++) ) { // USARTPut(v); //debug only TCPPut(SMTPSocket, v); //PIC stack only } }
/***************************************************************************** Function: BOOL SMTPPut(BYTE c) Description: Writes a single byte to the SMTP client. Precondition: SMTPBeginUsage returned TRUE on a previous call. Parameters: c - The byte to be written Return Values: TRUE - The byte was successfully written FALSE - The byte was not written, most likely because the buffer was full Remarks: This function should only be called externally when the SMTP client is generating an on-the-fly message. (That is, SMTPSendMail was called with SMTPClient.Body set to NULL.) ***************************************************************************/ BOOL SMTPPut(BYTE c) { if(CRPeriod.State == CR_PERIOD_NEED_INSERTION) { if(TCPPut(MySocket, '.')) CRPeriod.State = CR_PERIOD_SEEK_CR; else return FALSE; } switch(CRPeriod.State) { case CR_PERIOD_SEEK_CR: if(c == '\r') CRPeriod.State++; break; case CR_PERIOD_SEEK_LF: if(c == '\n') CRPeriod.State++; else if(c != '\r') CRPeriod.State--; break; case CR_PERIOD_SEEK_PERIOD: if(c == '.') CRPeriod.State++; // CR_PERIOD_NEED_INSERTION else if(c == '\r') CRPeriod.State--; else CRPeriod.State = CR_PERIOD_SEEK_CR; break; // Default case needed to supress compiler diagnostics // (CR_PERIOD_NEED_INSERTION state already handled above) default: break; } if(!TCPPut(MySocket, c)) return FALSE; return TRUE; }
void writeString2Socket( char* p ) { BYTE c; while( ( c = *p++ ) ) { TCPPut( ftpsocket, c ); } TCPFlush( ftpsocket ); }
void writeRomString2Socket( ROM char* p ) { BYTE c; while( ( c = *p++ ) ) { TCPPut( ftpsocket, c ); DBG_OUT( c ); } TCPFlush( ftpsocket ); }
BOOL SMTPPut(BYTE c) { if(CRPeriod.State == CR_PERIOD_NEED_INSERTION) { if(TCPPut(MySocket, '.')) CRPeriod.State = CR_PERIOD_SEEK_CR; else return FALSE; } switch(CRPeriod.State) { case CR_PERIOD_SEEK_CR: if(c == '\r') CRPeriod.State++; break; case CR_PERIOD_SEEK_LF: if(c == '\n') CRPeriod.State++; else if(c != '\r') CRPeriod.State--; break; case CR_PERIOD_SEEK_PERIOD: if(c == '.') CRPeriod.State++; // CR_PERIOD_NEED_INSERTION else if(c == '\r') CRPeriod.State--; else CRPeriod.State = CR_PERIOD_SEEK_CR; break; } if(!TCPPut(MySocket, c)) return FALSE; return TRUE; }
void writeDecimal( BYTE b ) { char i; BYTE pos, val, c[3]; pos = 0; val = b; while( val != 0 ) { c[ pos++ ] = val % 10; val = val / 10; } for (i=pos-1; i>=0; i-- ) { TCPPut( ftpsocket, '0' + c[ i ] ); } }
/**************************************************************************** Function: ChipKITClientPutByte(TCP_SOCKET hTCP, BYTE b) Description: This routine write 1 byte out on the socket Precondition: hTCP must be open and valid. Parameters: hTCP - The socket to check b - the byte to write out. Returns: True if it succeeded, false otherwise. Remarks: This is to match functionality of the Arduino Client class write method This is an expensive function to call as it flushes the1 byte out; we don't know how many bytes will be written, and the Arduino code expects the byte to go out. Also, this will run the periodic tasks, so a lot of over head is used for this task. ***************************************************************************/ BOOL ChipKITClientPutByte(TCP_SOCKET hTCP, BYTE b) { BOOL fRet = FALSE; // really don't care if it is connected or not // just return the error fRet = TCPPut(hTCP, b); // this is very expensive! if(TCPIsConnected(hTCP)) { TCPFlush(hTCP); // flush any remaining stuff out } // run our tasks so things can be put out and come in. ChipKITPeriodicTasks(); return(fRet); }
void ProcessTelnetTimer(void) { TCP_SOCKET MySocket; WORD i; MySocket = hTelnetSockets[0]; if (vTelnetStates[0] != SM_AUTHENTICATED) return; if (termbufidx < 1) return; if (TCPIsPutReady(MySocket) < termbufidx) { StackTask(); StackApplications(); return; } for(i = 0; i < termbufidx; i++) TCPPut(MySocket,termbuf[i]); termbufidx = 0; termbuftimer = 0; TCPFlush(MySocket); return; }
BOOL PutTelnetConsole(char c) { BYTE vTelnetSession,nconn; TCP_SOCKET MySocket; nconn = 0; for(vTelnetSession = 0; vTelnetSession < MAX_TELNET_CONNECTIONS; vTelnetSession++) { if (vTelnetStates[vTelnetSession] == SM_AUTHENTICATED) nconn++; } nconn = 1; if (nconn > 0) { StackTask(); StackApplications(); } for(vTelnetSession = 0; vTelnetSession < MAX_TELNET_CONNECTIONS; vTelnetSession++) { // Load up static state information for this session MySocket = hTelnetSockets[vTelnetSession]; if (vTelnetStates[vTelnetSession] != SM_AUTHENTICATED) continue; if (TCPIsPutReady(MySocket) < 1) { StackTask(); StackApplications(); return 0; } } for(vTelnetSession = 0; vTelnetSession < MAX_TELNET_CONNECTIONS; vTelnetSession++) { // Load up static state information for this session MySocket = hTelnetSockets[vTelnetSession]; if (vTelnetStates[vTelnetSession] != SM_AUTHENTICATED) continue; TCPPut(MySocket,c); TCPFlush(MySocket); } return 1; }
// ====================================== // = Sends the Requested LED's State = // ====================================== void HTTPPrint_led(WORD num) { // Determine which LED requested switch(num) { case 0: num = LED0_IO; break; case 1: num = LED1_IO; break; case 2: num = LED2_IO; break; default: num = 0; } // Print the output TCPPut(sktHTTP, (num?'1':'0')); return; }
/********************************************************************* * void IO2TCPBridgeTask(void) * * PreCondition: Stack is initialized() * * Input: None * * Output: None * * Side Effects: None * * Overview: None * * Note: None ********************************************************************/ void IO2TCPBridgeTask(void) { static enum _BridgeState { SM_HOME = 0, SM_SOCKET_OBTAINED } BridgeState = SM_HOME; static TCP_SOCKET MySocket = INVALID_SOCKET; WORD wMaxPut, wMaxGet, w; BYTE *RXHeadPtrShadow, *RXTailPtrShadow; BYTE *TXHeadPtrShadow, *TXTailPtrShadow; switch(BridgeState) { case SM_HOME: #if defined(USE_REMOTE_TCP_SERVER) // Connect a socket to the remote TCP server MySocket = TCPOpen((DWORD)USE_REMOTE_TCP_SERVER, TCP_OPEN_ROM_HOST, UART2TCPBRIDGE_PORT, TCP_PURPOSE_UART_2_TCP_BRIDGE); #else MySocket = TCPOpen(0, TCP_OPEN_SERVER, UART2TCPBRIDGE_PORT, TCP_PURPOSE_UART_2_TCP_BRIDGE); #endif // Abort operation if no TCP socket of type TCP_PURPOSE_UART_2_TCP_BRIDGE is available // If this ever happens, you need to go add one to TCPIPConfig.h if(MySocket == INVALID_SOCKET) break; // Eat the first TCPWasReset() response so we don't // infinitely create and reset/destroy client mode sockets TCPWasReset(MySocket); // We have a socket now, advance to the next state BridgeState = SM_SOCKET_OBTAINED; break; case SM_SOCKET_OBTAINED: // Reset all buffers if the connection was lost if(TCPWasReset(MySocket)) { // Optionally discard anything in the UART FIFOs //RXHeadPtr = vUARTRXFIFO; //RXTailPtr = vUARTRXFIFO; //TXHeadPtr = vUARTTXFIFO; //TXTailPtr = vUARTTXFIFO; // If we were a client socket, close the socket and attempt to reconnect #if defined(USE_REMOTE_TCP_SERVER) TCPDisconnect(MySocket); MySocket = INVALID_SOCKET; BridgeState = SM_HOME; break; #endif } // Don't do anything if nobody is connected to us if(!TCPIsConnected(MySocket)) break; if(TRUE == TxData) { //TCPPutArray(MySocket, keyinfo, 1); TCPPut(MySocket, keyinfo); TxData = FALSE; } // No flush. The stack will automatically flush and do // transmit coallescing to minimize the number of TCP // packets that get sent. If you explicitly call TCPFlush() // here, latency will go down, but so will max throughput // and bandwidth efficiency. break; } }
/* * Main entry point. */ void main(void) { static TICK8 t = 0; #ifdef HEATHERD NODE_INFO tcpServerNode; static TCP_SOCKET tcpSocketUser = INVALID_SOCKET; BYTE c; #endif static BYTE testLED; testLED = 1; //Set SWDTEN bit, this will enable the watch dog timer WDTCON_SWDTEN = 1; aliveCntrMain = 0xff; //Disable alive counter during initialization. Setting to 0xff disables it. //Initialize any application specific hardware. InitializeBoard(); //Initialize all stack related components. Following steps must //be performed for all applications using PICmicro TCP/IP Stack. TickInit(); //Initialize buses busInit(); //Initialize serial ports early, because they could be required for debugging if (appcfgGetc(APPCFG_USART1_CFG & APPCFG_USART_ENABLE)) { appcfgUSART(); //Configure the USART1 } if (appcfgGetc(APPCFG_USART2_CFG & APPCFG_USART_ENABLE)) { appcfgUSART2(); //Configure the USART2 } //After initializing all modules that use interrupts, enable global interrupts INTCON_GIEH = 1; INTCON_GIEL = 1; //Initialize file system. fsysInit(); //Intialize HTTP Execution unit htpexecInit(); //Initialize Stack and application related NV variables. appcfgInit(); //First call appcfgCpuIOValues() and then only appcfgCpuIO()!!! This ensures the value are set, before enabling ports. appcfgCpuIOValues(); //Configure the CPU's I/O port pin default values appcfgCpuIO(); //Configure the CPU's I/O port pin directions - input or output appcfgADC(); //Configure ADC unit appcfgPWM(); //Configure PWM Channels //Serial configuration menu - display it for configured time and allow user to enter configuration menu scfInit(appcfgGetc(APPCFG_STARTUP_SER_DLY)); //LCD Display Initialize lcdInit(); //Initialize expansion board appcfgXboard(); StackInit(); #if defined(STACK_USE_HTTP_SERVER) HTTPInit(); #endif #if defined(STACK_USE_FTP_SERVER) FTPInit(); #endif //Intialise network componet of buses - only call after StackInit()! busNetInit(); //Initializes events. evtInit(); //Initializes "UDP Command Port" and "UDP Even Port". cmdInit(); ioInit(); #if (DEBUG_MAIN >= LOG_DEBUG) debugPutMsg(1); //@mxd:1:Starting main loop #endif /* * Once all items are initialized, go into infinite loop and let * stack items execute their tasks. * If application needs to perform its own task, it should be * done at the end of while loop. * Note that this is a "co-operative mult-tasking" mechanism * where every task performs its tasks (whether all in one shot * or part of it) and returns so that other tasks can do their * job. * If a task needs very long time to do its job, it must broken * down into smaller pieces so that other tasks can have CPU time. */ #ifdef HEATHERD //Create a TCP socket that listens on port 54123 tcpSocketUser = TCPListen(HEATHERD); #define HEATHERD_ENABLE (!(appcfgGetc(APPCFG_TRISA) & 1)) #define HEATHERD_WRITE_ENABLE (!(appcfgGetc(APPCFG_TRISA) & 2)) #endif while(1) { aliveCntrMain = 38; //Reset if not services in 52.42ms x 38 = 2 seconds //Blink SYSTEM LED every second. if (appcfgGetc(APPCFG_SYSFLAGS) & APPCFG_SYSFLAGS_BLINKB6) { //Configure RB6 as output, and blink it every 500ms if ( TickGetDiff8bit(t) >= ((TICK8)TICKS_PER_SECOND / (TICK8)2) ) { t = TickGet8bit(); //If B6 is configured as input, change to output if (appcfgGetc(APPCFG_TRISB) & 0x40) { appcfgPutc(APPCFG_TRISB, appcfgGetc(APPCFG_TRISB) & 0b10111111); } TRISB_RB6 = 0; LATB6 ^= 1; //Toggle //Toggle IOR5E LED, if IOR5E is present if (appcfgGetc(APPCFG_XBRD_TYPE) == XBRD_TYPE_IOR5E) { ior5eLatchData.bits.ledPWR ^= 1; // Toggle } } } //This task performs normal stack task including checking for incoming packet, //type of packet and calling appropriate stack entity to process it. StackTask(); //Service LCD display lcdService(); //Process commands cmdTask(); //Process events evtTask(); //Process serial busses busTask(); //I2C Task i2cTask(); #ifdef HEATHERD //Has a remote node made connection with the port we are listening on if ((tcpSocketUser != INVALID_SOCKET) && TCPIsConnected(tcpSocketUser)) { if (HEATHERD_ENABLE) { //Is there any data waiting for us on the TCP socket? //Because of the design of the Modtronix TCP/IP stack we have to //consume all data sent to us as soon as we detect it. while(TCPIsGetReady(tcpSocketUser)) { //We are only interrested in the first byte of the message. TCPGet(tcpSocketUser, &c); if (HEATHERD_WRITE_ENABLE) serPutByte(c); } //Discard the socket buffer. TCPDiscard(tcpSocketUser); while (serIsGetReady() && TCPIsPutReady(tcpSocketUser)) { TCPPut(tcpSocketUser,serGetByte()); } TCPFlush(tcpSocketUser); } else { TCPDisconnect(tcpSocketUser); } } #endif #if defined(STACK_USE_HTTP_SERVER) //This is a TCP application. It listens to TCP port 80 //with one or more sockets and responds to remote requests. HTTPServer(); #endif #if defined(STACK_USE_FTP_SERVER) FTPServer(); #endif #if defined(STACK_USE_ANNOUNCE) DiscoveryTask(); #endif #if defined(STACK_USE_NBNS) NBNSTask(); #endif //Add your application speicifc tasks here. ProcessIO(); //For DHCP information, display how many times we have renewed the IP //configuration since last reset. if ( DHCPBindCount != myDHCPBindCount ) { #if (DEBUG_MAIN >= LOG_INFO) debugPutMsg(2); //@mxd:2:DHCP Bind Count = %D debugPutByteHex(DHCPBindCount); #endif //Display new IP address #if (DEBUG_MAIN >= LOG_INFO) debugPutMsg(3); //@mxd:3:DHCP complete, IP = %D.%D.%D.%D debugPutByteHex(AppConfig.MyIPAddr.v[0]); debugPutByteHex(AppConfig.MyIPAddr.v[1]); debugPutByteHex(AppConfig.MyIPAddr.v[2]); debugPutByteHex(AppConfig.MyIPAddr.v[3]); #endif myDHCPBindCount = DHCPBindCount; #if defined(STACK_USE_ANNOUNCE) AnnounceIP(); #endif } } }
/********************************************************************* * Function: void TelnetTask(void) * * PreCondition: Stack is initialized() * * Input: None * * Output: None * * Side Effects: None * * Overview: None * * Note: None ********************************************************************/ void TelnetTask(void) { BYTE i; BYTE vTelnetSession; WORD w, w2; TCP_SOCKET MySocket; enum { SM_HOME = 0, SM_PRINT_LOGIN, SM_GET_LOGIN, SM_GET_PASSWORD, SM_GET_PASSWORD_BAD_LOGIN, SM_AUTHENTICATED, SM_REFRESH_VALUES } TelnetState; static TCP_SOCKET hTelnetSockets[MAX_TELNET_CONNECTIONS]; static BYTE vTelnetStates[MAX_TELNET_CONNECTIONS]; static BOOL bInitialized = FALSE; // Perform one time initialization on power up if(!bInitialized) { for(vTelnetSession = 0; vTelnetSession < MAX_TELNET_CONNECTIONS; vTelnetSession++) { hTelnetSockets[vTelnetSession] = INVALID_SOCKET; vTelnetStates[vTelnetSession] = SM_HOME; } bInitialized = TRUE; } // Loop through each telnet session and process state changes and TX/RX data for(vTelnetSession = 0; vTelnetSession < MAX_TELNET_CONNECTIONS; vTelnetSession++) { // Load up static state information for this session MySocket = hTelnetSockets[vTelnetSession]; TelnetState = vTelnetStates[vTelnetSession]; // Reset our state if the remote client disconnected from us if(MySocket != INVALID_SOCKET) { if(TCPWasReset(MySocket)) TelnetState = SM_PRINT_LOGIN; } // Handle session state switch(TelnetState) { case SM_HOME: // Connect a socket to the remote TCP server MySocket = TCPOpen(0, TCP_OPEN_SERVER, TELNET_PORT, TCP_PURPOSE_TELNET); // Abort operation if no TCP socket of type TCP_PURPOSE_TELNET is available // If this ever happens, you need to go add one to TCPIPConfig.h if(MySocket == INVALID_SOCKET) break; TelnetState++; break; case SM_PRINT_LOGIN: // Make certain the socket can be written to if(TCPIsPutReady(MySocket) < strlenpgm((ROM char*)strTitle)) break; // Place the application protocol data into the transmit buffer. TCPPutROMString(MySocket, strTitle); // Send the packet TCPFlush(MySocket); TelnetState++; case SM_GET_LOGIN: // Make sure we can put the password prompt if(TCPIsPutReady(MySocket) < strlenpgm((ROM char*)strPassword)) break; // See if the user pressed return w = TCPFind(MySocket, '\n', 0, FALSE); if(w == 0xFFFFu) { if(TCPGetRxFIFOFree(MySocket) == 0u) { TCPPutROMString(MySocket, (ROM BYTE*)"\r\nToo much data.\r\n"); TCPDisconnect(MySocket); } break; } // Search for the username -- case insensitive w2 = TCPFindROMArray(MySocket, (ROM BYTE*)TELNET_USERNAME, sizeof(TELNET_USERNAME)-1, 0, TRUE); if((w2 != 0u) || !((sizeof(TELNET_USERNAME)-1 == w) || (sizeof(TELNET_USERNAME) == w))) { // Did not find the username, but let's pretend we did so we don't leak the user name validity TelnetState = SM_GET_PASSWORD_BAD_LOGIN; } else { TelnetState = SM_GET_PASSWORD; } // Username verified, throw this line of data away TCPGetArray(MySocket, NULL, w + 1); // Print the password prompt TCPPutROMString(MySocket, strPassword); TCPFlush(MySocket); break; case SM_GET_PASSWORD: case SM_GET_PASSWORD_BAD_LOGIN: // Make sure we can put the authenticated prompt if(TCPIsPutReady(MySocket) < strlenpgm((ROM char*)strAuthenticated)) break; // See if the user pressed return w = TCPFind(MySocket, '\n', 0, FALSE); if(w == 0xFFFFu) { if(TCPGetRxFIFOFree(MySocket) == 0u) { TCPPutROMString(MySocket, (ROM BYTE*)"Too much data.\r\n"); TCPDisconnect(MySocket); } break; } // Search for the password -- case sensitive w2 = TCPFindROMArray(MySocket, (ROM BYTE*)TELNET_PASSWORD, sizeof(TELNET_PASSWORD)-1, 0, FALSE); if((w2 != 3u) || !((sizeof(TELNET_PASSWORD)-1 == w-3) || (sizeof(TELNET_PASSWORD) == w-3)) || (TelnetState == SM_GET_PASSWORD_BAD_LOGIN)) { // Did not find the password TelnetState = SM_PRINT_LOGIN; TCPPutROMString(MySocket, strAccessDenied); TCPDisconnect(MySocket); break; } // Password verified, throw this line of data away TCPGetArray(MySocket, NULL, w + 1); // Print the authenticated prompt TCPPutROMString(MySocket, strAuthenticated); TelnetState = SM_AUTHENTICATED; // No break case SM_AUTHENTICATED: if(TCPIsPutReady(MySocket) < strlenpgm((ROM char*)strDisplay) + 4) break; TCPPutROMString(MySocket, strDisplay); TelnetState++; // All future characters will be bold TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[1m"); case SM_REFRESH_VALUES: if(TCPIsPutReady(MySocket) >= 78u) { //[10;1] //"SNTP Time: (disabled)\r\n" //"Analog: 1023\r\n" //"Buttons: 3 2 1 0\r\n" //"LEDs: 7 6 5 4 3 2 1 0\r\n" // Write current UTC seconds from SNTP module, if it is enable // and has changed. Note that conversion from a DWORD to an // ASCII string can take a lot of CPU power, so we only print // this if the value has changed. #if defined(STACK_USE_SNTP_CLIENT) { static DWORD dwTime; BYTE vTime[11]; if(dwTime != SNTPGetUTCSeconds()) { // Position cursor at Line 10, Col 15 TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[10;15f"); dwTime = SNTPGetUTCSeconds(); ultoa(dwTime, vTime); TCPPutROMArray(MySocket, (ROM BYTE*)strSpaces, 10-strlen((char*)vTime)); TCPPutString(MySocket, vTime); } } #endif // Position cursor at Line 11, Col 21 TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[11;21f"); // Put analog value with space padding on right side for 4 characters TCPPutROMArray(MySocket, (ROM BYTE*)strSpaces, 4-strlen((char*)AN0String)); TCPPutString(MySocket, AN0String); // Put Buttons TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[12;18f"); TCPPut(MySocket, BUTTON3_IO ? '1':'0'); TCPPut(MySocket, ' '); TCPPut(MySocket, BUTTON2_IO ? '1':'0'); TCPPut(MySocket, ' '); TCPPut(MySocket, BUTTON1_IO ? '1':'0'); TCPPut(MySocket, ' '); TCPPut(MySocket, BUTTON0_IO ? '1':'0'); // Put LEDs TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[13;10f"); TCPPut(MySocket, LED1_IO ? '1':'0'); TCPPut(MySocket, ' '); TCPPut(MySocket, LED0_IO ? '1':'0'); // Put cursor at beginning of next line TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[14;1f"); // Send the data out immediately TCPFlush(MySocket); } if(TCPIsGetReady(MySocket)) { TCPGet(MySocket, &i); switch(i) { case '\r': case 'q': case 'Q': if(TCPIsPutReady(MySocket) >= strlenpgm((ROM char*)strGoodBye)) TCPPutROMString(MySocket, strGoodBye); TCPDisconnect(MySocket); TelnetState = SM_PRINT_LOGIN; break; } } break; } // Save session state back into the static array hTelnetSockets[vTelnetSession] = MySocket; vTelnetStates[vTelnetSession] = TelnetState; } }
static void HTTPProcess(HTTP_HANDLE h) { char bafs[26], r; BOOL lbContinue; static HTTP_INFO* ph; WORD w; static BYTE *p, *t; ph = &HCB[h]; do { lbContinue = FALSE; if(!TCPIsConnected(ph->socket)) { ph->smHTTP = SM_HTTP_IDLE; break; } switch(ph->smHTTP) { case SM_HTTP_IDLE: w = TCPGetArray(ph->socket, httpData, MAX_HTML_CMD_LEN); if(!w) { if(TCPGetRxFIFOFree(ph->socket) == 0) TCPDisconnect(ph->socket); // Request is too big, we can't support it. break; } httpData[w] = 0; t = p = httpData; while(*p) if(*p=='%') { *t++ = hex2bin(p+1); p += 3; } else *t++ = *p++; *t = 0; r = httpData[150]; httpData[150]=0; lbContinue = TRUE; ph->smHTTP = SM_HTTP_NOT_FOUND; if(strstrrampgm(httpData,"POST")) ph->smHTTP = SM_HTTP_POST; if(strstrrampgm(httpData,"GET")) { ph->smHTTP = SM_HTTP_HEADER; #ifndef _FAVICON_ if(strstrrampgm(httpData,(ROM void*)"favicon")) { TCPDisconnect(ph->socket); ph->smHTTP = SM_HTTP_IDLE; } #else if(strstrrampgm(httpData,"favicon")) ph->smHTTP = SM_ICO_HEADER; #endif if(strstrrampgm(httpData, "Sw_Pool")) AppConfig.who ^= 0x81; if(strstrrampgm(httpData, "Sw_Mode")) AppConfig.sw_mode ^= 1; if(strstrrampgm(httpData, "Sw_Clock")) AppConfig.CkSel ^= 1; if(strstrrampgm(httpData, "Sw_LEDs")) bLEDs ^= 1; } httpData[150]=r; break; case SM_HTTP_POST: exoit(ph->socket); memcpypgm2ram(spwrk,rMinPool,SZ_ROMS ); for(r=0;r<SZ_SRCH;r++) { BYTE *s; p = strstrrampgm(httpData,(ROM BYTE*)(DWORD)sComa[r]); if(p) { p+=5; t=strstrrampgm(p,ampa); if(t) { *t=0; s=p; switch(r) { // case C_JMAC: Hex2Mac(p); break; //S2Mac(p); break; case C_JMIP: StringToIPAddress(p,&AppConfig.MyIPAddr); break; case C_JMSK: StringToIPAddress(p,&AppConfig.MyMask); break; case C_JGTW: StringToIPAddress(p,&AppConfig.MyGateway); break; case C_PDNS: StringToIPAddress(p,&AppConfig.PrimaryDNSServer); break; case C_SDNS: StringToIPAddress(p,&AppConfig.SecondaryDNSServer); break; case C_WPRT: AppConfig.MyPort = atoi(p); break; case C_MPRT: while(*p) if((*p) == ',') { *p=0; AppConfig.MinPort[0] = atoi(s); break; } else p++; AppConfig.MinPort[1] = atoi(++p); *--p = ','; break; case C_MURL: while(*p) if((*p) == ',') { *p=0; strcpy(&spwrk[0],s); break; } else p++; strcpy(&spwrk[sizeof(rMinPool)/2],++p); *--p = ','; break; case C_USPA: while(*p) if((*p) == ',') { *p=0; strcpy(&spwrk[sizeof(rMinPool)],s); break; } else p++; strcpy(&spwrk[sizeof(rMinPool)+sizeof(rUsrPass)/2],++p); *--p = ','; break; } *t='&'; } } } ph->smHTTP = SM_HTTP_IDLE; SetUPS(); break; case SM_HTTP_NOT_FOUND: if(TCPIsPutReady(ph->socket) >= sizeof(hdrErr)) { TCPPutROMString(ph->socket, hdrErr); TCPFlush(ph->socket); TCPDisconnect(ph->socket); ph->smHTTP = SM_HTTP_IDLE; } break; #ifdef _FAVICON_ case SM_ICO_HEADER: if ( TCPIsPutReady(ph->socket) ) { lbContinue = TRUE; if(TCPIsPutReady(ph->socket) >= sizeof(hdrICO)+198) { TCPPutROMString(ph->socket, hdrICO); TCPPutROMArray(ph->socket, favicon,198); TCPFlush(ph->socket); TCPDisconnect(ph->socket); ph->smHTTP = SM_HTTP_IDLE; } } break; #endif case SM_HTTP_HEADER: if ( TCPIsPutReady(ph->socket) ) { lbContinue = TRUE; if(TCPIsPutReady(ph->socket) >= sizeof(hdrOK)) { TCPPutROMString(ph->socket, hdrOK); TCPFlush(ph->socket); ph->smHTTP = SM_HTTP_GET; ph->Pos = Page; } } break; case SM_HTTP_GET: TCPDiscard(ph->socket); if(TCPIsPutReady(ph->socket) >= 400) { ph->Pos = TCPPutROMString(ph->socket, ph->Pos); ph->Pos++; switch (*ph->Pos) { case 0: TCPDisconnect(ph->socket); ph->smHTTP = SM_HTTP_IDLE; ph->Pos = Page; break; case 1: DoStic(ph->socket, 1); break; case 2: DoStic(ph->socket, 2); break; case 3: DoStic(ph->socket, 3); break; // case 4: MAC2Hex(bafs); TCPPutString(ph->socket, bafs); break; case 5: IP2String(AppConfig.MyIPAddr,bafs); TCPPutString(ph->socket, bafs); break; case 6: IP2String(AppConfig.MyMask,bafs); TCPPutString(ph->socket, bafs); break; case 7: IP2String(AppConfig.MyGateway,bafs); TCPPutString(ph->socket, bafs); break; case 8: uitoa(AppConfig.MyPort,bafs); TCPPutString(ph->socket, bafs); break; case 9: IP2String(AppConfig.PrimaryDNSServer,bafs); TCPPutString(ph->socket, bafs); break; case 10: IP2String(AppConfig.SecondaryDNSServer,bafs); TCPPutString(ph->socket, bafs); break; case 11: uitoa(AppConfig.MinPort[0],bafs); TCPPutString(ph->socket, bafs); TCPPut(ph->socket,','); uitoa(AppConfig.MinPort[1],bafs); TCPPutString(ph->socket, bafs); break; case 12: TCPPutROMString(ph->socket, rMinPool[0]); TCPPut(ph->socket,','); TCPPutROMString(ph->socket, rMinPool[1]); break; case 13: TCPPutROMString(ph->socket, rUsrPass[0]); TCPPut(ph->socket,','); TCPPutROMString(ph->socket, rUsrPass[1]); break; } ph->Pos++; } TCPFlush(ph->socket); break; default: break; } } while( lbContinue ); }
/********************************************************************* * Function: void FTPServer(void) * * PreCondition: FTPInit() must already be called. * * Input: None * * Output: Opened FTP connections are served. * * 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 repeatdly to ensure all open * or new connections are served on time. ********************************************************************/ BOOL FTPServer(void) { BYTE v; TICK currentTick; if ( !TCPIsConnected(FTPSocket) ) { FTPStringLen = 0; FTPCommand = FTP_CMD_NONE; smFTP = SM_FTP_NOT_CONNECTED; FTPFlags.Val = 0; smFTPCommand = SM_FTP_CMD_IDLE; return TRUE; } if ( TCPIsGetReady(FTPSocket) ) { lastActivity = TickGet(); while( TCPGet(FTPSocket, &v ) ) { USARTPut(v); FTPString[FTPStringLen++] = v; if ( FTPStringLen == MAX_FTP_CMD_STRING_LEN ) FTPStringLen = 0; } TCPDiscard(FTPSocket); if ( v == '\n' ) { FTPString[FTPStringLen] = '\0'; FTPStringLen = 0; ParseFTPString(); FTPCommand = ParseFTPCommand(FTP_argv[0]); } } else if ( smFTP != SM_FTP_NOT_CONNECTED ) { currentTick = TickGet(); currentTick = TickGetDiff(currentTick, lastActivity); if ( currentTick >= FTP_TIMEOUT ) { lastActivity = TickGet(); FTPCommand = FTP_CMD_QUIT; smFTP = SM_FTP_CONNECTED; } } switch(smFTP) { case SM_FTP_NOT_CONNECTED: FTPResponse = FTP_RESP_BANNER; lastActivity = TickGet(); /* No break - Continue... */ case SM_FTP_RESPOND: SM_FTP_RESPOND_Label: if(!TCPIsPutReady(FTPSocket)) { return TRUE; } else { ROM char* pMsg; pMsg = FTPResponseString[FTPResponse]; while( (v = *pMsg++) ) { USARTPut(v); TCPPut(FTPSocket, v); } TCPFlush(FTPSocket); FTPResponse = FTP_RESP_NONE; smFTP = SM_FTP_CONNECTED; } // No break - this will speed up little bit case SM_FTP_CONNECTED: if ( FTPCommand != FTP_CMD_NONE ) { if ( ExecuteFTPCommand(FTPCommand) ) { if ( FTPResponse != FTP_RESP_NONE ) smFTP = SM_FTP_RESPOND; else if ( FTPCommand == FTP_CMD_QUIT ) smFTP = SM_FTP_NOT_CONNECTED; FTPCommand = FTP_CMD_NONE; smFTPCommand = SM_FTP_CMD_IDLE; } else if ( FTPResponse != FTP_RESP_NONE ) { smFTP = SM_FTP_RESPOND; goto SM_FTP_RESPOND_Label; } } break; } return TRUE; }
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 SMTPClientTask(void) Summary: Performs any pending SMTP client tasks Description: This function handles periodic tasks associated with the SMTP client, such as processing initial connections and command sequences. Precondition: None Parameters: None Returns: None Remarks: This function acts as a task (similar to one in an RTOS). It performs its task in a co-operative manner, and the main application must call this function repeatedly to ensure that all open or new connections are served in a timely fashion. ***************************************************************************/ void SMTPClientTask(void) { uint8_t i; uint16_t w; uint8_t vBase64Buffer[4]; static SYS_TICK SMTPTimer; static uint8_t RXBuffer[4]; static const uint8_t *ROMStrPtr, *ROMStrPtr2; static const uint8_t *RAMStrPtr; static uint16_t wAddressLength; DNS_RESULT dnsRes; switch(TransportState) { case TRANSPORT_HOME: // SMTPBeginUsage() is the only function which will kick // the state machine into the next state break; case TRANSPORT_BEGIN: // Wait for the user to program all the pointers and then // call SMTPSendMail() if(!SMTPFlags.bits.ReadyToStart) break; // Obtain ownership of the DNS resolution module if(DNSBeginUsage(0) != DNS_RES_OK) { break; } // Obtain the IP address associated with the SMTP mail server if(SMTPClient.Server) { DNSResolve((const char*)SMTPClient.Server, DNS_TYPE_A); } else { // If we don't have a mail server, try to send the mail // directly to the destination SMTP server if(SMTPClient.To) { SMTPClient.Server = strchr((char*)SMTPClient.To, '@'); } if(!(SMTPClient.Server)) { if(SMTPClient.CC) { SMTPClient.Server = strchr((char*)SMTPClient.CC, '@'); } } if(!(SMTPClient.Server)) { if(SMTPClient.BCC) { SMTPClient.Server = strchr((char*)SMTPClient.BCC, '@'); } } // See if we found a hostname anywhere which we could resolve if(!(SMTPClient.Server)) { DNSEndUsage(0); ResponseCode = SMTP_RESOLVE_ERROR; TransportState = TRANSPORT_HOME; break; } // Skip over the @ sign and resolve the host name SMTPClient.Server++; DNSResolve((const char*)SMTPClient.Server, DNS_TYPE_MX); } SMTPTimer = SYS_TICK_Get(); TransportState++; break; case TRANSPORT_NAME_RESOLVE: // Wait for the DNS server to return the requested IP address dnsRes = DNSIsResolved((const char*)SMTPClient.Server, &SMTPServer); if(dnsRes == DNS_RES_PENDING) { break; } // Release the DNS module DNSEndUsage(0); if(dnsRes < 0) { // some error occurred ResponseCode = SMTP_RESOLVE_ERROR; TransportState = TRANSPORT_HOME; break; } // DNS_RES_OK TransportState++; // No need to break here case TRANSPORT_OBTAIN_SOCKET: // Connect a TCP socket to the remote SMTP server MySocket = TCPOpenClient(IP_ADDRESS_TYPE_IPV4, SMTPClient.ServerPort, (IP_MULTI_ADDRESS*)&SMTPServer.Val); // Abort operation if no TCP socket could be opened. // If this ever happens, you need to update your tcp_config.h if(MySocket == INVALID_SOCKET) break; TransportState++; SMTPTimer = SYS_TICK_Get(); // No break; fall into TRANSPORT_SOCKET_OBTAINED #if defined(TCPIP_STACK_USE_SSL_CLIENT) case TRANSPORT_SECURING_SOCKET: if(!TCPIsConnected(MySocket)) { // Don't stick around in the wrong state if the // server was connected, but then disconnected us. // Also time out if we can't establish the connection // to the SMTP server if((SYS_TICK_Get()-SMTPTimer) > (SMTP_SERVER_REPLY_TIMEOUT * SYS_TICK_TicksPerSecondGet())) { ResponseCode = SMTP_CONNECT_ERROR; TransportState = TRANSPORT_CLOSE; } break; } SMTPFlags.bits.ConnectedOnce = true; // Start SSL if needed for this connection if(SMTPClient.UseSSL && !TCPStartSSLClient(MySocket,NULL)) break; // Move on to main state SMTPTimer = SYS_TICK_Get(); TransportState++; break; #endif case TRANSPORT_SOCKET_OBTAINED: if(!TCPIsConnected(MySocket)) { // Don't stick around in the wrong state if the // server was connected, but then disconnected us. // Also time out if we can't establish the connection // to the SMTP server if(SMTPFlags.bits.ConnectedOnce || ((SYS_TICK_Get()-SMTPTimer) > (SMTP_SERVER_REPLY_TIMEOUT * SYS_TICK_TicksPerSecondGet()))) { ResponseCode = SMTP_CONNECT_ERROR; TransportState = TRANSPORT_CLOSE; } break; } SMTPFlags.bits.ConnectedOnce = true; #if defined(TCPIP_STACK_USE_SSL_CLIENT) // Make sure the SSL handshake has completed if(SMTPClient.UseSSL && TCPSSLIsHandshaking(MySocket)) break; #endif // See if the server sent us anything while(TCPIsGetReady(MySocket)) { TCPGet(MySocket, &i); switch(RXParserState) { case RX_BYTE_0: case RX_BYTE_1: case RX_BYTE_2: RXBuffer[RXParserState] = i; RXParserState++; break; case RX_BYTE_3: switch(i) { case ' ': SMTPFlags.bits.RXSkipResponse = false; RXParserState++; break; case '-': SMTPFlags.bits.RXSkipResponse = true; RXParserState++; break; case '\r': RXParserState = RX_SEEK_LF; break; } break; case RX_SEEK_CR: if(i == '\r') RXParserState++; break; case RX_SEEK_LF: // If we received the whole command if(i == '\n') { RXParserState = RX_BYTE_0; if(!SMTPFlags.bits.RXSkipResponse) { // The server sent us a response code // Null terminate the ASCII reponse code so we can convert it to an integer RXBuffer[3] = 0; ResponseCode = atoi((char*)RXBuffer); // Handle the response switch(SMTPState) { case SMTP_HELO_ACK: if(ResponseCode >= 200u && ResponseCode <= 299u) { if(SMTPClient.Username) SMTPState = SMTP_AUTH_LOGIN; else SMTPState = SMTP_MAILFROM; } else SMTPState = SMTP_QUIT_INIT; break; case SMTP_AUTH_LOGIN_ACK: case SMTP_AUTH_USERNAME_ACK: if(ResponseCode == 334u) SMTPState++; else SMTPState = SMTP_QUIT_INIT; break; case SMTP_AUTH_PASSWORD_ACK: if(ResponseCode == 235u) SMTPState++; else SMTPState = SMTP_QUIT_INIT; break; case SMTP_HOME: case SMTP_MAILFROM_ACK: case SMTP_RCPTTO_ACK: case SMTP_RCPTTOCC_ACK: case SMTP_RCPTTOBCC_ACK: if(ResponseCode >= 200u && ResponseCode <= 299u) SMTPState++; else SMTPState = SMTP_QUIT_INIT; break; case SMTP_DATA_ACK: if(ResponseCode == 354u) SMTPState++; else SMTPState = SMTP_QUIT_INIT; break; case SMTP_DATA_BODY_ACK: if(ResponseCode >= 200u && ResponseCode <= 299u) SMTPFlags.bits.SentSuccessfully = true; SMTPState = SMTP_QUIT_INIT; break; // Default case needed to supress compiler diagnostics default: break; } } } else if(i != '\r') RXParserState--; break; } } // Generate new data in the TX buffer, as needed, if possible if(TCPIsPutReady(MySocket) < 64u) break; switch(SMTPState) { case SMTP_HELO: if(SMTPClient.Username == NULL) TCPPutString(MySocket, (uint8_t*)"HELO MCHPBOARD\r\n"); else TCPPutString(MySocket, (uint8_t*)"EHLO MCHPBOARD\r\n"); TCPFlush(MySocket); SMTPState++; break; case SMTP_AUTH_LOGIN: // Note: This state is only entered from SMTP_HELO_ACK if the application // has specified a Username to use (SMTPClient.Username is non-NULL) TCPPutString(MySocket, (uint8_t*)"AUTH LOGIN\r\n"); TCPFlush(MySocket); SMTPState++; break; case SMTP_AUTH_USERNAME: // Base 64 encode and transmit the username. RAMStrPtr = (uint8_t*)SMTPClient.Username; w = strlen((char*)RAMStrPtr); while(w) { i = 0; while((i < w) && (i < sizeof(vBase64Buffer)*3/4)) { vBase64Buffer[i] = *RAMStrPtr++; i++; } w -= i; TCPIP_Helper_Base64Encode(vBase64Buffer, i, vBase64Buffer, sizeof(vBase64Buffer)); TCPPutArray(MySocket, vBase64Buffer, sizeof(vBase64Buffer)); } TCPPutString(MySocket, (uint8_t*)"\r\n"); TCPFlush(MySocket); SMTPState++; break; case SMTP_AUTH_PASSWORD: // Base 64 encode and transmit the password RAMStrPtr = (uint8_t*)SMTPClient.Password; w = strlen((char*)RAMStrPtr); while(w) { i = 0; while((i < w) && (i < sizeof(vBase64Buffer)*3/4)) { vBase64Buffer[i] = *RAMStrPtr++; i++; } w -= i; TCPIP_Helper_Base64Encode(vBase64Buffer, i, vBase64Buffer, sizeof(vBase64Buffer)); TCPPutArray(MySocket, vBase64Buffer, sizeof(vBase64Buffer)); } TCPPutString(MySocket, (uint8_t*)"\r\n"); TCPFlush(MySocket); SMTPState++; break; case SMTP_MAILFROM: // Send MAIL FROM header. Note that this is for the SMTP server validation, // not what actually will be displayed in the recipients mail client as a // return address. TCPPutString(MySocket, (uint8_t*)"MAIL FROM:<"); RAMStrPtr = FindEmailAddress((uint8_t*)SMTPClient.From, &wAddressLength); TCPPutArray(MySocket, RAMStrPtr, wAddressLength); TCPPutString(MySocket, (uint8_t*)">\r\n"); TCPFlush(MySocket); SMTPState++; break; case SMTP_RCPTTO_INIT: // See if there are any (To) recipients to process if(SMTPClient.To) { RAMStrPtr = FindEmailAddress((uint8_t*)SMTPClient.To, &wAddressLength); if(wAddressLength) { SMTPState = SMTP_RCPTTO; break; } } SMTPState = SMTP_RCPTTOCC_INIT; break; case SMTP_RCPTTO: case SMTP_RCPTTOCC: case SMTP_RCPTTOBCC: TCPPutString(MySocket, (uint8_t*)"RCPT TO:<"); TCPPutArray(MySocket, RAMStrPtr, wAddressLength); TCPPutString(MySocket, (uint8_t*)">\r\n"); TCPFlush(MySocket); SMTPState++; break; case SMTP_RCPTTO_ISDONE: // See if we have any more (To) recipients to process // If we do, we must roll back a couple of states RAMStrPtr = FindEmailAddress(RAMStrPtr+wAddressLength, &wAddressLength); if(wAddressLength) { SMTPState = SMTP_RCPTTO; break; } // All done with To field SMTPState++; //No break case SMTP_RCPTTOCC_INIT: // See if there are any Carbon Copy (CC) recipients to process if(SMTPClient.CC) { RAMStrPtr = FindEmailAddress((uint8_t*)SMTPClient.CC, &wAddressLength); if(wAddressLength) { SMTPState = SMTP_RCPTTOCC; break; } } SMTPState = SMTP_RCPTTOBCC_INIT; break; case SMTP_RCPTTOCC_ISDONE: // See if we have any more Carbon Copy (CC) recipients to process // If we do, we must roll back a couple of states RAMStrPtr = FindEmailAddress(RAMStrPtr+wAddressLength, &wAddressLength); if(wAddressLength) { SMTPState = SMTP_RCPTTOCC; break; } // All done with CC field SMTPState++; //No break case SMTP_RCPTTOBCC_INIT: // See if there are any Blind Carbon Copy (BCC) recipients to process if(SMTPClient.BCC) { RAMStrPtr = FindEmailAddress((uint8_t*)SMTPClient.BCC, &wAddressLength); if(wAddressLength) { SMTPState = SMTP_RCPTTOBCC; break; } } // All done with BCC field SMTPState = SMTP_DATA; break; case SMTP_RCPTTOBCC_ISDONE: // See if we have any more Blind Carbon Copy (CC) recipients to process // If we do, we must roll back a couple of states RAMStrPtr = FindEmailAddress(RAMStrPtr+wAddressLength, &wAddressLength); if(wAddressLength) { SMTPState = SMTP_RCPTTOBCC; break; } // All done with BCC field SMTPState++; //No break case SMTP_DATA: TCPPutString(MySocket, (uint8_t*)"DATA\r\n"); SMTPState++; PutHeadersState = PUTHEADERS_FROM_INIT; TCPFlush(MySocket); break; case SMTP_DATA_HEADER: while((PutHeadersState != PUTHEADERS_DONE) && (TCPIsPutReady(MySocket) > 64u)) { switch(PutHeadersState) { case PUTHEADERS_FROM_INIT: if(SMTPClient.From) { PutHeadersState = PUTHEADERS_FROM; TCPPutString(MySocket, (uint8_t*)"From: "); } else { PutHeadersState = PUTHEADERS_TO_INIT; } break; case PUTHEADERS_FROM: SMTPClient.From = (char*)TCPPutString(MySocket, (uint8_t*)SMTPClient.From); if(*SMTPClient.From == 0u) PutHeadersState = PUTHEADERS_TO_INIT; break; case PUTHEADERS_TO_INIT: if(SMTPClient.To) { PutHeadersState = PUTHEADERS_TO; TCPPutString(MySocket, (uint8_t*)"\r\nTo: "); } else { PutHeadersState = PUTHEADERS_CC_INIT; } break; case PUTHEADERS_TO: SMTPClient.To = (char*)TCPPutString(MySocket, (uint8_t*)SMTPClient.To); if(*SMTPClient.To == 0u) PutHeadersState = PUTHEADERS_CC_INIT; break; case PUTHEADERS_CC_INIT: if(SMTPClient.CC) { PutHeadersState = PUTHEADERS_CC; TCPPutString(MySocket, (uint8_t*)"\r\nCC: "); } else { PutHeadersState = PUTHEADERS_SUBJECT_INIT; } break; case PUTHEADERS_CC: SMTPClient.CC = (char*)TCPPutString(MySocket, (uint8_t*)SMTPClient.CC); if(*SMTPClient.CC == 0u) PutHeadersState = PUTHEADERS_SUBJECT_INIT; break; case PUTHEADERS_SUBJECT_INIT: if(SMTPClient.Subject) { PutHeadersState = PUTHEADERS_SUBJECT; TCPPutString(MySocket, (uint8_t*)"\r\nSubject: "); } else { PutHeadersState = PUTHEADERS_OTHER_INIT; } break; case PUTHEADERS_SUBJECT: SMTPClient.Subject = (char*)TCPPutString(MySocket, (uint8_t*)SMTPClient.Subject); if(*SMTPClient.Subject == 0u) PutHeadersState = PUTHEADERS_OTHER_INIT; break; case PUTHEADERS_OTHER_INIT: TCPPutArray(MySocket, (uint8_t*)"\r\n", 2); if(SMTPClient.OtherHeaders) { PutHeadersState = PUTHEADERS_OTHER; } else { TCPPutArray(MySocket, (uint8_t*)"\r\n", 2); PutHeadersState = PUTHEADERS_DONE; SMTPState++; } break; case PUTHEADERS_OTHER: SMTPClient.OtherHeaders = (char*)TCPPutString(MySocket, (uint8_t*)SMTPClient.OtherHeaders); if(*SMTPClient.OtherHeaders == 0u) { TCPPutArray(MySocket, (uint8_t*)"\r\n", 2); PutHeadersState = PUTHEADERS_DONE; SMTPState++; } break; // Default case needed to supress compiler diagnostics default: break; } } TCPFlush(MySocket); break; case SMTP_DATA_BODY_INIT: SMTPState++; RAMStrPtr = (uint8_t*)SMTPClient.Body; ROMStrPtr2 = (const uint8_t*)"\r\n.\r\n"; CRPeriod.Pos = NULL; if(RAMStrPtr) CRPeriod.Pos = (uint8_t*)strstr((char*)RAMStrPtr, (const char*)"\r\n."); // No break here case SMTP_DATA_BODY: if(SMTPClient.Body) { if(*ROMStrPtr2) { // Put the application data, doing the transparancy replacement of "\r\n." with "\r\n.." while(CRPeriod.Pos) { CRPeriod.Pos += 3; RAMStrPtr += TCPPutArray(MySocket, RAMStrPtr, CRPeriod.Pos-RAMStrPtr); if(RAMStrPtr == CRPeriod.Pos) { if(!TCPPut(MySocket, '.')) { CRPeriod.Pos -= 3; break; } } else { CRPeriod.Pos -= 3; break; } CRPeriod.Pos = (uint8_t*)strstr((char*)RAMStrPtr, (const char*)"\r\n."); } // If we get down here, either all replacements have been made or there is no remaining space in the TCP output buffer RAMStrPtr = TCPPutString(MySocket, RAMStrPtr); ROMStrPtr2 = TCPPutString(MySocket, (uint8_t*)ROMStrPtr2); TCPFlush(MySocket); } } else { if(SMTPFlags.bits.ReadyToFinish) { if(*ROMStrPtr2) { ROMStrPtr2 = TCPPutString(MySocket, (uint8_t*)ROMStrPtr2); TCPFlush(MySocket); } } } if(*ROMStrPtr2 == 0u) { SMTPState++; } break; case SMTP_QUIT_INIT: SMTPState++; ROMStrPtr = (const uint8_t*)"QUIT\r\n"; // No break here case SMTP_QUIT: if(*ROMStrPtr) { ROMStrPtr = TCPPutString(MySocket, (uint8_t*)ROMStrPtr); TCPFlush(MySocket); } if(*ROMStrPtr == 0u) { TransportState = TRANSPORT_CLOSE; } break; // Default case needed to supress compiler diagnostics default: break; } break; case TRANSPORT_CLOSE: // Close the socket so it can be used by other modules TCPClose(MySocket); MySocket = INVALID_SOCKET; // Go back to doing nothing TransportState = TRANSPORT_HOME; break; } }
/********************************************************************* * Function: static void HTTPProcess(void) * * PreCondition: HTTPInit() called and curHTTP loaded * * Input: None * * Output: None * * Side Effects: None * * Overview: Serves the current HTTP connection in curHTTP * * Note: None ********************************************************************/ static void HTTPProcess(void) { WORD lenA, lenB; BYTE c, i; BOOL isDone; BYTE *ext; BYTE buffer[HTTP_MAX_HEADER_LEN+1]; do { isDone = TRUE; // If a socket is disconnected at any time // forget about it and return to idle state. if(TCPWasReset(sktHTTP)) { smHTTP = SM_HTTP_IDLE; // Make sure any opened files are closed if(curHTTP.file != MPFS_INVALID_HANDLE) { MPFSClose(curHTTP.file); curHTTP.file = MPFS_INVALID_HANDLE; } if(curHTTP.offsets != MPFS_INVALID_HANDLE) { MPFSClose(curHTTP.offsets); curHTTP.offsets = MPFS_INVALID_HANDLE; } // Adjust the TCP FIFOs for optimal reception of // the next HTTP request from the browser TCPAdjustFIFOSize(sktHTTP, 1, 0, TCP_ADJUST_GIVE_REST_TO_RX | TCP_ADJUST_PRESERVE_RX); } switch(smHTTP) { case SM_HTTP_IDLE: // Check how much data is waiting lenA = TCPIsGetReady(sktHTTP); // If a connection has been made, then process the request if(lenA) {// Clear out state info and move to next state curHTTP.ptrData = curHTTP.data; smHTTP = SM_HTTP_PARSE_REQUEST; curHTTP.isAuthorized = 0xff; curHTTP.hasArgs = FALSE; curHTTP.callbackID = TickGet() + HTTP_TIMEOUT*TICK_SECOND; curHTTP.callbackPos = 0xffffffff; curHTTP.byteCount = 0; } // In all cases, we break // For new connections, this waits for the buffer to fill break; case SM_HTTP_PARSE_REQUEST: // Verify the entire first line is in the FIFO if(TCPFind(sktHTTP, '\n', 0, FALSE) == 0xffff) {// First line isn't here yet if(TCPGetRxFIFOFree(sktHTTP) == 0) {// If the FIFO is full, we overflowed curHTTP.httpStatus = HTTP_OVERFLOW; smHTTP = SM_HTTP_SERVE_HEADERS; isDone = FALSE; } if(TickGet() > curHTTP.callbackID) {// A timeout has occurred TCPDisconnect(sktHTTP); smHTTP = SM_HTTP_DISCONNECT; isDone = FALSE; } break; } // Reset the watchdog timer curHTTP.callbackID = TickGet() + HTTP_TIMEOUT*TICK_SECOND; // Determine the request method lenA = TCPFind(sktHTTP, ' ', 0, FALSE); if(lenA > 5) lenA = 5; TCPGetArray(sktHTTP, curHTTP.data, lenA+1); if ( memcmppgm2ram(curHTTP.data, (ROM void*)"GET", 3) == 0) curHTTP.httpStatus = HTTP_GET; #if defined(HTTP_USE_POST) else if ( memcmppgm2ram(curHTTP.data, (ROM void*)"POST", 4) == 0) curHTTP.httpStatus = HTTP_POST; #endif else {// Unrecognized method, so return not implemented curHTTP.httpStatus = HTTP_NOT_IMPLEMENTED; smHTTP = SM_HTTP_SERVE_HEADERS; isDone = FALSE; break; } // Find end of filename lenA = TCPFind(sktHTTP, ' ', 0, FALSE); lenB = TCPFindEx(sktHTTP, '?', 0, lenA, FALSE); lenA = mMIN(lenA, lenB); // If the file name is too long, then reject the request if(lenA > HTTP_MAX_DATA_LEN - HTTP_DEFAULT_LEN - 1) { curHTTP.httpStatus = HTTP_OVERFLOW; smHTTP = SM_HTTP_SERVE_HEADERS; isDone = FALSE; break; } // Read in the filename and decode lenB = TCPGetArray(sktHTTP, curHTTP.data, lenA); curHTTP.data[lenB] = '\0'; HTTPURLDecode(curHTTP.data); // Check if this is an MPFS Upload #if defined(HTTP_MPFS_UPLOAD) if(memcmppgm2ram(&curHTTP.data[1], HTTP_MPFS_UPLOAD, strlenpgm(HTTP_MPFS_UPLOAD)) == 0) {// Read remainder of line, and bypass all file opening, etc. #if defined(HTTP_USE_AUTHENTICATION) curHTTP.isAuthorized = HTTPAuthenticate(NULL, NULL, &curHTTP.data[1]); #endif if(curHTTP.httpStatus == HTTP_GET) curHTTP.httpStatus = HTTP_MPFS_FORM; else curHTTP.httpStatus = HTTP_MPFS_UP; smHTTP = SM_HTTP_PARSE_HEADERS; isDone = FALSE; break; } #endif // If the last character is a not a directory delimiter, then try to open the file // String starts at 2nd character, because the first is always a '/' if(curHTTP.data[lenB-1] != '/') curHTTP.file = MPFSOpen(&curHTTP.data[1]); // If the open fails, then add our default name and try again if(curHTTP.file == MPFS_INVALID_HANDLE) { // Add the directory delimiter if needed if(curHTTP.data[lenB-1] != '/') curHTTP.data[lenB++] = '/'; // Add our default file name // If this is a loopback, then it's an SSL connection if(TCPIsLoopback(sktHTTP)) { strcpypgm2ram((void*)&curHTTP.data[lenB], HTTPS_DEFAULT_FILE); lenB += strlenpgm(HTTPS_DEFAULT_FILE); } else { strcpypgm2ram((void*)&curHTTP.data[lenB], HTTP_DEFAULT_FILE); lenB += strlenpgm(HTTP_DEFAULT_FILE); } // Try to open again curHTTP.file = MPFSOpen(&curHTTP.data[1]); } // Find the extension in the filename for(ext = curHTTP.data + lenB-1; ext != curHTTP.data; ext--) if(*ext == '.') break; // Compare to known extensions to determine Content-Type ext++; for(curHTTP.fileType = HTTP_TXT; curHTTP.fileType < HTTP_UNKNOWN; curHTTP.fileType++) if(!stricmppgm2ram(ext, (ROM void*)httpFileExtensions[curHTTP.fileType])) break; // Perform first round authentication (pass file name only) #if defined(HTTP_USE_AUTHENTICATION) curHTTP.isAuthorized = HTTPAuthenticate(NULL, NULL, &curHTTP.data[1]); #endif // If the file was found, see if it has an index if(curHTTP.file != MPFS_INVALID_HANDLE && (MPFSGetFlags(curHTTP.file) & MPFS2_FLAG_HASINDEX) ) { curHTTP.data[lenB-1] = '#'; curHTTP.offsets = MPFSOpen(&curHTTP.data[1]); } // Read GET args, up to buffer size - 1 lenA = TCPFind(sktHTTP, ' ', 0, FALSE); if(lenA != 0) { curHTTP.hasArgs = TRUE; // Trash the '?' TCPGet(sktHTTP, &c); // Verify there's enough space lenA--; if(lenA >= HTTP_MAX_DATA_LEN - 2) { curHTTP.httpStatus = HTTP_OVERFLOW; smHTTP = SM_HTTP_SERVE_HEADERS; isDone = FALSE; break; } // Read in the arguments and '&'-terminate in anticipation of cookies curHTTP.ptrData += TCPGetArray(sktHTTP, curHTTP.data, lenA); *(curHTTP.ptrData++) = '&'; } // Clear the rest of the line lenA = TCPFind(sktHTTP, '\n', 0, FALSE); TCPGetArray(sktHTTP, NULL, lenA + 1); // Move to parsing the headers smHTTP = SM_HTTP_PARSE_HEADERS; // No break, continue to parsing headers case SM_HTTP_PARSE_HEADERS: // Loop over all the headers while(1) { // Make sure entire line is in the FIFO lenA = TCPFind(sktHTTP, '\n', 0, FALSE); if(lenA == 0xffff) {// If not, make sure we can receive more data if(TCPGetRxFIFOFree(sktHTTP) == 0) {// Overflow curHTTP.httpStatus = HTTP_OVERFLOW; smHTTP = SM_HTTP_SERVE_HEADERS; isDone = FALSE; } if(TickGet() > curHTTP.callbackID) {// A timeout has occured TCPDisconnect(sktHTTP); smHTTP = SM_HTTP_DISCONNECT; isDone = FALSE; } break; } // Reset the watchdog timer curHTTP.callbackID = TickGet() + HTTP_TIMEOUT*TICK_SECOND; // If a CRLF is immediate, then headers are done if(lenA == 1) {// Remove the CRLF and move to next state TCPGetArray(sktHTTP, NULL, 2); smHTTP = SM_HTTP_AUTHENTICATE; isDone = FALSE; break; } // Find the header name, and use isDone as a flag to indicate a match lenB = TCPFindEx(sktHTTP, ':', 0, lenA, FALSE) + 2; isDone = FALSE; // If name is too long or this line isn't a header, ignore it if(lenB > sizeof(buffer)) { TCPGetArray(sktHTTP, NULL, lenA+1); continue; } // Read in the header name TCPGetArray(sktHTTP, buffer, lenB); buffer[lenB-1] = '\0'; lenA -= lenB; // Compare header read to ones we're interested in for(i = 0; i < HTTP_NUM_HEADERS; i++) { if(strcmppgm2ram((char*)buffer, (ROM char *)HTTPRequestHeaders[i]) == 0) {// Parse the header and stop the loop HTTPHeaderParseLookup(i); isDone = TRUE; break; } } // Clear the rest of the line, and call the loop again if(isDone) {// We already know how much to remove unless a header was found lenA = TCPFind(sktHTTP, '\n', 0, FALSE); } TCPGetArray(sktHTTP, NULL, lenA+1); } break; case SM_HTTP_AUTHENTICATE: #if defined(HTTP_USE_AUTHENTICATION) // Check current authorization state if(curHTTP.isAuthorized < 0x80) {// 401 error curHTTP.httpStatus = HTTP_UNAUTHORIZED; smHTTP = SM_HTTP_SERVE_HEADERS; isDone = FALSE; #if defined(HTTP_NO_AUTH_WITHOUT_SSL) if(!TCPIsLoopback(sktHTTP)) curHTTP.httpStatus = HTTP_SSL_REQUIRED; #endif break; } #endif // Parse the args string *curHTTP.ptrData = '\0'; curHTTP.ptrData = HTTPURLDecode(curHTTP.data); // If this is an MPFS upload form request, bypass to headers #if defined(HTTP_MPFS_UPLOAD) if(curHTTP.httpStatus == HTTP_MPFS_FORM) { smHTTP = SM_HTTP_SERVE_HEADERS; isDone = FALSE; break; } #endif // Move on to GET args, unless there are none smHTTP = SM_HTTP_PROCESS_GET; if(!curHTTP.hasArgs) smHTTP = SM_HTTP_PROCESS_POST; isDone = FALSE; curHTTP.hasArgs = FALSE; break; case SM_HTTP_PROCESS_GET: // Run the application callback HTTPExecuteGet() if(HTTPExecuteGet() == HTTP_IO_WAITING) {// If waiting for asynchronous process, return to main app break; } // Move on to POST data smHTTP = SM_HTTP_PROCESS_POST; case SM_HTTP_PROCESS_POST: #if defined(HTTP_USE_POST) // See if we have any new data if(TCPIsGetReady(sktHTTP) == curHTTP.callbackPos) { if(TickGet() > curHTTP.callbackID) {// If a timeout has occured, disconnect TCPDisconnect(sktHTTP); smHTTP = SM_HTTP_DISCONNECT; isDone = FALSE; break; } } if(curHTTP.httpStatus == HTTP_POST #if defined(HTTP_MPFS_UPLOAD) || (curHTTP.httpStatus >= HTTP_MPFS_UP && curHTTP.httpStatus <= HTTP_MPFS_ERROR) #endif ) { // Run the application callback HTTPExecutePost() #if defined(HTTP_MPFS_UPLOAD) if(curHTTP.httpStatus >= HTTP_MPFS_UP && curHTTP.httpStatus <= HTTP_MPFS_ERROR) { c = HTTPMPFSUpload(); if(c == HTTP_IO_DONE) { smHTTP = SM_HTTP_SERVE_HEADERS; isDone = FALSE; break; } } else #endif c = HTTPExecutePost(); // If waiting for asynchronous process, return to main app if(c == HTTP_IO_WAITING) {// return to main app and make sure we don't get stuck by the watchdog curHTTP.callbackPos = TCPIsGetReady(sktHTTP) - 1; break; } else if(c == HTTP_IO_NEED_DATA) {// If waiting for more data curHTTP.callbackPos = TCPIsGetReady(sktHTTP); curHTTP.callbackID = TickGet() + HTTP_TIMEOUT*TICK_SECOND; // If more is expected and space is available, return to main app if(curHTTP.byteCount > 0 && TCPGetRxFIFOFree(sktHTTP) != 0) break; else {// Handle cases where application ran out of data or buffer space curHTTP.httpStatus = HTTP_INTERNAL_SERVER_ERROR; smHTTP = SM_HTTP_SERVE_HEADERS; isDone = FALSE; break; } } } #endif // We're done with POST smHTTP = SM_HTTP_PROCESS_REQUEST; // No break, continue to sending request case SM_HTTP_PROCESS_REQUEST: // Check for 404 if(curHTTP.file == MPFS_INVALID_HANDLE) { curHTTP.httpStatus = HTTP_NOT_FOUND; smHTTP = SM_HTTP_SERVE_HEADERS; isDone = FALSE; break; } // Set up the dynamic substitutions curHTTP.byteCount = 0; if(curHTTP.offsets == MPFS_INVALID_HANDLE) {// If no index file, then set next offset to huge curHTTP.nextCallback = 0xffffffff; } else {// Read in the next callback index MPFSGetLong(curHTTP.offsets, &(curHTTP.nextCallback)); } // Move to next state smHTTP = SM_HTTP_SERVE_HEADERS; case SM_HTTP_SERVE_HEADERS: // We're in write mode now: // Adjust the TCP FIFOs for optimal transmission of // the HTTP response to the browser TCPAdjustFIFOSize(sktHTTP, 1, 0, TCP_ADJUST_GIVE_REST_TO_TX); // Send headers TCPPutROMString(sktHTTP, (ROM BYTE*)HTTPResponseHeaders[curHTTP.httpStatus]); // If this is a redirect, print the rest of the Location: header if(curHTTP.httpStatus == HTTP_REDIRECT) { TCPPutString(sktHTTP, curHTTP.data); TCPPutROMString(sktHTTP, (ROM BYTE*)"\r\n\r\n304 Redirect: "); TCPPutString(sktHTTP, curHTTP.data); TCPPutROMString(sktHTTP, (ROM BYTE*)HTTP_CRLF); } // If not GET or POST, we're done if(curHTTP.httpStatus != HTTP_GET && curHTTP.httpStatus != HTTP_POST) {// Disconnect smHTTP = SM_HTTP_DISCONNECT; break; } // Output the content type, if known if(curHTTP.fileType != HTTP_UNKNOWN) { TCPPutROMString(sktHTTP, (ROM BYTE*)"Content-Type: "); TCPPutROMString(sktHTTP, (ROM BYTE*)httpContentTypes[curHTTP.fileType]); TCPPutROMString(sktHTTP, HTTP_CRLF); } // Output the gzip encoding header if needed if(MPFSGetFlags(curHTTP.file) & MPFS2_FLAG_ISZIPPED) { TCPPutROMString(sktHTTP, (ROM BYTE*)"Content-Encoding: gzip\r\n"); } // Output the cache-control TCPPutROMString(sktHTTP, (ROM BYTE*)"Cache-Control: "); if(curHTTP.httpStatus == HTTP_POST || curHTTP.nextCallback != 0xffffffff) {// This is a dynamic page or a POST request, so no cache TCPPutROMString(sktHTTP, (ROM BYTE*)"no-cache"); } else {// This is a static page, so save it for the specified amount of time TCPPutROMString(sktHTTP, (ROM BYTE*)"max-age="); TCPPutROMString(sktHTTP, (ROM BYTE*)HTTP_CACHE_LEN); } TCPPutROMString(sktHTTP, HTTP_CRLF); // Check if we should output cookies if(curHTTP.hasArgs) smHTTP = SM_HTTP_SERVE_COOKIES; else {// Terminate the headers TCPPutROMString(sktHTTP, HTTP_CRLF); smHTTP = SM_HTTP_SERVE_BODY; } // Move to next stage isDone = FALSE; break; case SM_HTTP_SERVE_COOKIES: #if defined(HTTP_USE_COOKIES) // If the TX FIFO runs out of space, the client will never get CRLFCRLF // Avoid writing huge cookies - keep it under a hundred bytes max // Write cookies one at a time as space permits for(curHTTP.ptrRead = curHTTP.data; curHTTP.hasArgs != 0; curHTTP.hasArgs--) { // Write the header TCPPutROMString(sktHTTP, (ROM BYTE*)"Set-Cookie: "); // Write the name, URL encoded, one character at a time while((c = *(curHTTP.ptrRead++))) { if(c == ' ') TCPPut(sktHTTP, '+'); else if(c < '0' || (c > '9' && c < 'A') || (c > 'Z' && c < 'a') || c > 'z') { TCPPut(sktHTTP, '%'); TCPPut(sktHTTP, btohexa_high(c)); TCPPut(sktHTTP, btohexa_low(c)); } else TCPPut(sktHTTP, c); } TCPPut(sktHTTP, '='); // Write the value, URL encoded, one character at a time while((c = *(curHTTP.ptrRead++))) { if(c == ' ') TCPPut(sktHTTP, '+'); else if(c < '0' || (c > '9' && c < 'A') || (c > 'Z' && c < 'a') || c > 'z') { TCPPut(sktHTTP, '%'); TCPPut(sktHTTP, btohexa_high(c)); TCPPut(sktHTTP, btohexa_low(c)); } else TCPPut(sktHTTP, c); } // Finish the line TCPPutROMString(sktHTTP, HTTP_CRLF); } #endif // We're done, move to next state TCPPutROMString(sktHTTP, HTTP_CRLF); smHTTP = SM_HTTP_SERVE_BODY; case SM_HTTP_SERVE_BODY: isDone = FALSE; // Try to send next packet if(HTTPSendFile()) {// If EOF, then we're done so close and disconnect MPFSClose(curHTTP.file); curHTTP.file = MPFS_INVALID_HANDLE; smHTTP = SM_HTTP_DISCONNECT; isDone = TRUE; } // If the TX FIFO is full, then return to main app loop if(TCPIsPutReady(sktHTTP) == 0) isDone = TRUE; break; case SM_HTTP_SEND_FROM_CALLBACK: isDone = TRUE; // Check that at least the minimum bytes are free if(TCPIsPutReady(sktHTTP) < HTTP_MIN_CALLBACK_FREE) break; // Fill TX FIFO from callback HTTPPrint(curHTTP.callbackID); if(curHTTP.callbackPos == 0) {// Callback finished its output, so move on isDone = FALSE; smHTTP = SM_HTTP_SERVE_BODY; }// Otherwise, callback needs more buffer space, so return and wait break; case SM_HTTP_DISCONNECT: // Loopbacks have no wait state, so all data must be retrieved first if(TCPIsLoopback(sktHTTP) && TCPGetTxFIFOFull(sktHTTP) != 0) break; // Make sure any opened files are closed if(curHTTP.file != MPFS_INVALID_HANDLE) { MPFSClose(curHTTP.file); curHTTP.file = MPFS_INVALID_HANDLE; } if(curHTTP.offsets != MPFS_INVALID_HANDLE) { MPFSClose(curHTTP.offsets); curHTTP.offsets = MPFS_INVALID_HANDLE; } TCPDisconnect(sktHTTP); smHTTP = SM_HTTP_IDLE; break; } } while(!isDone); }
static void OutLong(TCP_SOCKET socket, DWORD dwv, BYTE len) { BYTE r, bafs[12]; ultoa(dwv, bafs); r = strlen(bafs); r = len-r; while(r--) TCPPut(socket, '0'); TCPPutString(socket, bafs); }
void twatchTasks(char frameAdvance){ //this state machine services the #twatch static enum _twatchState { TWATCH_INIT=0, TWATCH_IDLE, TWATCH_TRENDS_TCP_START, TWATCH_TRENDS_TCP_SOCKET_OBTAINED, TWATCH_TRENDS_TCP_PROCESS_RESPONSE, TWATCH_TRENDS_TCP_DISCONNECT, TWATCH_SEARCH_TCP_START, TWATCH_SEARCH_TCP_SOCKET_OBTAINED, TWATCH_SEARCH_TCP_PROCESS_RESPONSE, TWATCH_SEARCH_TCP_DISCONNECT, } twatchState = TWATCH_INIT; //massive twitter parsing state machine static enum _HTTPstatus { UNKNOWN=0, OK, ERROR, } HTTPstatus = UNKNOWN; //get and track HTTP status and handle errors static unsigned char HTTPheaderBuf[20]; //used to store HTTP headers static unsigned char HTTPheaderBufCnt; //pointer static BYTE refreshFeeds=0, HTTPretry=0, URLencode[]="%20";//extra static vars for twitter parser BYTE i,k; WORD w; BYTE vBuffer[51]; BYTE cnt; static TICK Timer; static TCP_SOCKET MySocket = INVALID_SOCKET; if(frameAdvance==1) refreshFeeds++; //counts the minutes switch(twatchState) { case TWATCH_INIT: trendParser.success=0; //clear these flag on first run searchParser.success=0;//display IP address and info until valid connection twatchState=TWATCH_TRENDS_TCP_START; //start TCP data grabber next cycle break; case TWATCH_IDLE: //if this variable set, then start the refresh process if(refreshFeeds>TWATCH_REFRESH_INTERVAL){ //if it has been at least 5 minutes, get new trends and tweet search results refreshFeeds=0; HTTPretry=0; //reset the number of retries twatchState=TWATCH_TRENDS_TCP_START; //start TCP data grabber next cycle } break; case TWATCH_TRENDS_TCP_START: //connect to twitter server MySocket = TCPOpen((DWORD)&ServerName[0], TCP_OPEN_RAM_HOST, ServerPort, TCP_PURPOSE_GENERIC_TCP_CLIENT); if(MySocket == INVALID_SOCKET) break; //abort if error, try again next time trendParser.updatingData=1; //updating data flag (probably not used anywhere) displayMode=UPDATE; //next LCD refresh will draw the update screen and then idle twatchState=TWATCH_TRENDS_TCP_SOCKET_OBTAINED; Timer = TickGet(); break; case TWATCH_TRENDS_TCP_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; twatchState--; } break; } Timer = TickGet(); if(TCPIsPutReady(MySocket) < 125u) break; //if socket error, break and wait //form our trending topics JSON datafeed request TCPPutROMString(MySocket, (ROM BYTE*)"GET "); TCPPutROMString(MySocket, TrendURL); //use the trend URL TCPPutROMString(MySocket, (ROM BYTE*)" HTTP/1.0\r\nHost: "); TCPPutString(MySocket, ServerName); TCPPutROMString(MySocket, (ROM BYTE*)"\r\nConnection: close\r\n\r\n"); TCPFlush(MySocket); //send HTTP request to Twitter //setup/clear the parser struct trendParser.bufWritePointer=0; trendParser.foundTag=0; trendParser.tagCharMatchCnt=0; trendParser.tagTotalCnt=0; trendParser.bufWritePointer=0; searchParser.bufWritePointer=0;//reset the tweet buffer write pointer searchParser.term=0; //reset the number of terns in the tweet search parser structure for(i=0; i<MAX_TREND_TERMS; i++) searchParser.bufValueEndPosition[i]=0;//reset all buffer positions to 0 HTTPstatus = UNKNOWN; //reset the http status checker HTTPheaderBufCnt=0; //status checker buffer counter twatchState=TWATCH_TRENDS_TCP_PROCESS_RESPONSE; //next time process any incoming data break; case TWATCH_TRENDS_TCP_PROCESS_RESPONSE: if(!TCPIsConnected(MySocket)) twatchState = TWATCH_TRENDS_TCP_DISCONNECT; //check if we're still connected // Do not break; We might still have data in the TCP RX FIFO waiting for us w = TCPIsGetReady(MySocket);//how many bytes waiting? //process the server reply i = sizeof(vBuffer)-1; vBuffer[i] = '\0'; while(w){ if(w < i){ i = w; vBuffer[i] = '\0'; } w -= TCPGetArray(MySocket, vBuffer, i); for(cnt=0;cnt<i;cnt++){ //---------------// switch(HTTPstatus){ //check the first few bytes for HTTP/1.1 200 OK case UNKNOWN: //cache until a line break, then check header for response code before extracting tags HTTPheaderBuf[HTTPheaderBufCnt]=vBuffer[cnt];//add to the headerbuf array if(HTTPheaderBufCnt<19) HTTPheaderBufCnt++; //if it won't overrun the array, increment the counter if(vBuffer[cnt]==0x0d){//if current character is a line break, examine the header for the response code //is it HTTP? if(HTTPheaderBuf[0]=='H' && HTTPheaderBuf[1]=='T' && HTTPheaderBuf[2]=='T' && HTTPheaderBuf[3]=='P' ){ //loop past /1.x and space HTTPheaderBufCnt=4; while(HTTPheaderBuf[HTTPheaderBufCnt]!=' '){ HTTPheaderBufCnt++; if(HTTPheaderBufCnt>19) break; //buffer overrun } HTTPheaderBufCnt++; //is it 200? (should be a ASCII->int loop that gets the actual value for error handling.... check for overrun if( (HTTPheaderBufCnt <=17 ) && HTTPheaderBuf[HTTPheaderBufCnt]=='2' && HTTPheaderBuf[HTTPheaderBufCnt+1]=='0' && HTTPheaderBuf[HTTPheaderBufCnt+2]=='0'){ HTTPstatus=OK;//200 OK }else{ HTTPstatus=ERROR; //other status, error } } } break; case OK: //HTTP is OK, process the byte procTrend(vBuffer[cnt]); //json parsing state maching break; case ERROR://do nothing because we need to clear the buffer break; } //------------------// }//for loop if(twatchState == TWATCH_TRENDS_TCP_PROCESS_RESPONSE) break; }//while break; case TWATCH_TRENDS_TCP_DISCONNECT: TCPDisconnect(MySocket); //close the socket MySocket = INVALID_SOCKET; //did not get valid HTML, retry, got no tags, retry if(HTTPstatus!=OK || trendParser.tagTotalCnt==0 ){ HTTPretry++; if(HTTPretry>HTTP_MAX_RETRY){//retry 3 times, then wait a minute.... twatchState = TWATCH_IDLE; LCD_CursorPosition(21); //display waiting error LCD_WriteString("*Error, waiting 5min"); break; } LCD_CursorPosition(21); //display retry error LCD_WriteString("*Error, reconnecting"); twatchState = TWATCH_TRENDS_TCP_START; break; } HTTPretry=0; addToTrendBuffer(' ');//add trailing space trendParser.updatingData=0; //data update complete, clear update flag if(trendParser.success==0){ //if this is the first time throuigh, set the success flag trendParser.success=1; //set success flag, used to identify the very first successful xfer and clear IP address screen LCD_refresh(); //clear IP, show update screen } displayMode=NEWSCROLL;//start scrolling the terms, tweets will show when available in the parser struct twatchState = TWATCH_SEARCH_TCP_START; //will start searching on each term next time. searchParser.term set to 0 above... break; case TWATCH_SEARCH_TCP_START: //begins searching for recent tweets for each trending term //don't continue if there's no more term, an error, or overrun if(searchParser.term>=trendParser.tagTotalCnt || searchParser.term>=MAX_TREND_TERMS ){//don't continue if there's no more terms left to search twatchState = TWATCH_IDLE; //go back to idle break; } //skip if 0 length term if(trendParser.bufValueStartPosition[searchParser.term]==trendParser.bufValueEndPosition[searchParser.term]) { searchParser.term++; //increment to next trend term twatchState = TWATCH_SEARCH_TCP_START; //try again with the next trend term break; } //connect to twitter MySocket = TCPOpen((DWORD)&ServerName[0], TCP_OPEN_RAM_HOST, ServerPort, TCP_PURPOSE_GENERIC_TCP_CLIENT); if(MySocket == INVALID_SOCKET) break; //abort on error twatchState=TWATCH_SEARCH_TCP_SOCKET_OBTAINED; Timer = TickGet(); break; case TWATCH_SEARCH_TCP_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; twatchState--; //searchParser.term++; //increment to next trend term, don't get stuck in loop //should add retries } break; } Timer = TickGet(); if(TCPIsPutReady(MySocket) < 125u) break; //socket ready for writes? TCPPutROMString(MySocket, (ROM BYTE*)"GET "); //setup the HTTP GET request TCPPutROMString(MySocket, SearchURL); //JSON search datafeed URL #ifndef JSON_DEBUG //add the search term to the JSON search URL. Requires urlencoding i=trendParser.bufValueStartPosition[searchParser.term]; //get the starting position of the term in the trend term buffer k=trendParser.bufValueEndPosition[searchParser.term]-1; //end position is one less because of auto increment //add each character of the trend term to the search URL while((i<k) && i<TREND_PARSER_BUFFER ){ //append each byte to the URL until the end position //URLencode anything not a-zA-Z0-9 -_.!~*'() if(URLencodeChar(trendParser.buf[i], &URLencode[0])==0){ TCPPut(MySocket, trendParser.buf[i]); //no URLencode required; }else{ TCPPutString(MySocket, URLencode); //use the URLencoded character now in URLencode array } i++; } #endif //form the rest of the HTTP request TCPPutROMString(MySocket, (ROM BYTE*)" HTTP/1.0\r\nHost: "); TCPPutString(MySocket, ServerName); TCPPutROMString(MySocket, (ROM BYTE*)"\r\nConnection: close\r\n\r\n"); TCPFlush(MySocket); //send the HTTP request to the Twitter server //setup the search parser struct searchParser.foundTag=0; searchParser.tagCharMatchCnt=0; searchParser.tagTotalCnt=0; searchParser.escape=0; HTTPstatus = UNKNOWN; //clear the HTTP status checker HTTPheaderBufCnt=0; addToSearchBuffer(0xff); //add beginning block to the text twatchState=TWATCH_SEARCH_TCP_PROCESS_RESPONSE; break; case TWATCH_SEARCH_TCP_PROCESS_RESPONSE: if(!TCPIsConnected(MySocket)) twatchState = TWATCH_SEARCH_TCP_DISCONNECT; //check for connection // Do not break; We might still have data in the TCP RX FIFO waiting for us w = TCPIsGetReady(MySocket); //how many bytes waiting? i = sizeof(vBuffer)-1; vBuffer[i] = '\0'; //add trailing 0 to array. while(w){ //process server reply if(w < i){ i = w; vBuffer[i] = '\0'; } w -= TCPGetArray(MySocket, vBuffer, i); for(cnt=0;cnt<i;cnt++){ //---------------// switch(HTTPstatus){ case UNKNOWN: //check header for response code before extracting tags HTTPheaderBuf[HTTPheaderBufCnt]=vBuffer[cnt];//add to the headerbuf array if(HTTPheaderBufCnt<19) HTTPheaderBufCnt++; //if it won't overrun the array, increment the counter if(vBuffer[cnt]==0x0d){//current character is a line break, examine the header for the response code //is it HTTP? if(HTTPheaderBuf[0]=='H' && HTTPheaderBuf[1]=='T' && HTTPheaderBuf[2]=='T' && HTTPheaderBuf[3]=='P' ){ //loop past /1.x and space HTTPheaderBufCnt=4; while(HTTPheaderBuf[HTTPheaderBufCnt]!=' '){ HTTPheaderBufCnt++; if(HTTPheaderBufCnt>19) break; //buffer overrun } HTTPheaderBufCnt++; //is it 200? (should be a ASCII->int loop that gets the actual value for error handling.... if( ((HTTPheaderBufCnt+2) < 20) && HTTPheaderBuf[HTTPheaderBufCnt]=='2' && HTTPheaderBuf[HTTPheaderBufCnt+1]=='0' && HTTPheaderBuf[HTTPheaderBufCnt+2]=='0'){ HTTPstatus=OK; }else{ HTTPstatus=ERROR; } } } break; case OK: procSearch(vBuffer[cnt]); break; case ERROR://do nothing because we need to clear the buffer break; } //------------------// }//for loop if(twatchState == TWATCH_SEARCH_TCP_PROCESS_RESPONSE) break; }//while break; case TWATCH_SEARCH_TCP_DISCONNECT: TCPDisconnect(MySocket); //close the socket MySocket = INVALID_SOCKET; //did not get valid HTML, retry, got no tags, retry once if no tags if(HTTPstatus!=OK ){ HTTPretry++; if(HTTPretry>HTTP_MAX_RETRY){//retry, then wait till next time... twatchState = TWATCH_IDLE; break; } twatchState = TWATCH_SEARCH_TCP_START; break; } HTTPretry=0; //success, clear number or retries //repeat for each trend term searchParser.success=1; searchParser.term++; twatchState = TWATCH_SEARCH_TCP_START; break; }//switch }//function
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; }
/********************************************************************* * Function: void TelnetTask(void) * * PreCondition: Stack is initialized() * * Input: None * * Output: None * * Side Effects: None * * Overview: None * * Note: None ********************************************************************/ void TelnetTask(void) { BYTE i; WORD w, w2; static TCP_SOCKET MySocket = INVALID_SOCKET; static enum _TelnetState { SM_HOME = 0, SM_PRINT_LOGIN, SM_GET_LOGIN, SM_GET_PASSWORD, SM_GET_PASSWORD_BAD_LOGIN, SM_AUTHENTICATED, SM_REFRESH_VALUES, } TelnetState = SM_HOME; // Reset our state if the remote client disconnected from us if(MySocket != INVALID_SOCKET) { if(TCPWasReset(MySocket)) TelnetState = SM_PRINT_LOGIN; } switch(TelnetState) { case SM_HOME: // Connect a socket to the remote TCP server MySocket = TCPOpen(0, TCP_OPEN_SERVER, TELNET_PORT, TCP_PURPOSE_TELNET); // Abort operation if no TCP socket of type TCP_PURPOSE_TELNET is available // If this ever happens, you need to go add one to TCPIPConfig.h if(MySocket == INVALID_SOCKET) break; TelnetState++; break; case SM_PRINT_LOGIN: // Make certain the socket can be written to if(TCPIsPutReady(MySocket) < strlenpgm((ROM char*)strTitle)) break; // Place the application protocol data into the transmit buffer. TCPPutROMString(MySocket, strTitle); // Send the packet TCPFlush(MySocket); TelnetState++; case SM_GET_LOGIN: // Make sure we can put the password prompt if(TCPIsPutReady(MySocket) < strlenpgm((ROM char*)strPassword)) break; // See if the user pressed return w = TCPFind(MySocket, '\n', 0, FALSE); if(w == 0xFFFFu) { if(TCPGetRxFIFOFree(MySocket) == 0u) { TCPPutROMString(MySocket, (ROM BYTE*)"\r\nToo much data.\r\n"); TCPDisconnect(MySocket); } break; } // Search for the username -- case insensitive w2 = TCPFindROMArray(MySocket, (ROM BYTE*)USERNAME, sizeof(USERNAME)-1, 0, TRUE); if((w2 != 0) || !((sizeof(USERNAME)-1 == w) || (sizeof(USERNAME) == w))) { // Did not find the username, but let's pretend we did so we don't leak the user name validity TelnetState = SM_GET_PASSWORD_BAD_LOGIN; } else { TelnetState = SM_GET_PASSWORD; } // Username verified, throw this line of data away TCPGetArray(MySocket, NULL, w + 1); // Print the password prompt TCPPutROMString(MySocket, strPassword); TCPFlush(MySocket); break; case SM_GET_PASSWORD: case SM_GET_PASSWORD_BAD_LOGIN: // Make sure we can put the authenticated prompt if(TCPIsPutReady(MySocket) < strlenpgm((ROM char*)strAuthenticated)) break; // See if the user pressed return w = TCPFind(MySocket, '\n', 0, FALSE); if(w == 0xFFFFu) { if(TCPGetRxFIFOFree(MySocket) == 0u) { TCPPutROMString(MySocket, (ROM BYTE*)"Too much data.\r\n"); TCPDisconnect(MySocket); } break; } // Search for the password -- case sensitive w2 = TCPFindROMArray(MySocket, (ROM BYTE*)PASSWORD, sizeof(PASSWORD)-1, 0, FALSE); if((w2 != 3) || !((sizeof(PASSWORD)-1 == w-3) || (sizeof(PASSWORD) == w-3)) || (TelnetState == SM_GET_PASSWORD_BAD_LOGIN)) { // Did not find the password TelnetState = SM_PRINT_LOGIN; TCPPutROMString(MySocket, strAccessDenied); TCPDisconnect(MySocket); break; } // Password verified, throw this line of data away TCPGetArray(MySocket, NULL, w + 1); // Print the authenticated prompt TCPPutROMString(MySocket, strAuthenticated); TelnetState = SM_AUTHENTICATED; // No break case SM_AUTHENTICATED: if(TCPIsPutReady(MySocket) < strlenpgm((ROM char*)strDisplay) + 4) break; TCPPutROMString(MySocket, strDisplay); TelnetState++; // All future characters will be bold TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[1m"); case SM_REFRESH_VALUES: if(TCPIsPutReady(MySocket) >= 60u) { //[10;1] //"Analog: 1023\r\n" //"Buttons: 3 2 1 0\r\n" //"LEDs: 7 6 5 4 3 2 1 0\r\n" // Position cursor at Line 10, Col 21 TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[10;21f"); // Put analog value with space padding on right side for 4 characters TCPPutROMArray(MySocket, (ROM BYTE*)" ", 4-strlen((char*)AN0String)); TCPPutString(MySocket, AN0String); // Put Buttons TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[11;18f"); TCPPut(MySocket, BUTTON3_IO ? '1':'0'); TCPPut(MySocket, ' '); TCPPut(MySocket, BUTTON2_IO ? '1':'0'); TCPPut(MySocket, ' '); TCPPut(MySocket, BUTTON1_IO ? '1':'0'); TCPPut(MySocket, ' '); TCPPut(MySocket, BUTTON0_IO ? '1':'0'); // Put LEDs TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[12;10f"); TCPPut(MySocket, LED7_IO ? '1':'0'); TCPPut(MySocket, ' '); TCPPut(MySocket, LED6_IO ? '1':'0'); TCPPut(MySocket, ' '); TCPPut(MySocket, LED5_IO ? '1':'0'); TCPPut(MySocket, ' '); TCPPut(MySocket, LED4_IO ? '1':'0'); TCPPut(MySocket, ' '); TCPPut(MySocket, LED3_IO ? '1':'0'); TCPPut(MySocket, ' '); TCPPut(MySocket, LED2_IO ? '1':'0'); TCPPut(MySocket, ' '); TCPPut(MySocket, LED1_IO ? '1':'0'); TCPPut(MySocket, ' '); TCPPut(MySocket, LED0_IO ? '1':'0'); // Put cursor at beginning of next line TCPPutROMString(MySocket, (ROM BYTE*)"\x1b[13;1f"); // Send the data out immediately TCPFlush(MySocket); } if(TCPIsGetReady(MySocket)) { TCPGet(MySocket, &i); switch(i) { case '\r': case 'q': case 'Q': if(TCPIsPutReady(MySocket) >= strlenpgm((ROM char*)strGoodBye)) TCPPutROMString(MySocket, strGoodBye); TCPDisconnect(MySocket); TelnetState = SM_PRINT_LOGIN; break; } } break; } }
/***************************************************************************** Function: void SMTPTask(void) Summary: Performs any pending SMTP client tasks Description: This function handles periodic tasks associated with the SMTP client, such as processing initial connections and command sequences. Precondition: None Parameters: None Returns: None Remarks: This function acts as a task (similar to one in an RTOS). It performs its task in a co-operative manner, and the main application must call this function repeatedly to ensure that all open or new connections are served in a timely fashion. ***************************************************************************/ void SMTPTask(void) { BYTE i; WORD w; BYTE vBase64Buffer[4]; static DWORD Timer; static BYTE RXBuffer[4]; static ROM BYTE *ROMStrPtr, *ROMStrPtr2; static BYTE *RAMStrPtr; static WORD wAddressLength; WORD tmp; switch(TransportState) { case TRANSPORT_HOME: // SMTPBeginUsage() is the only function which will kick // the state machine into the next state break; case TRANSPORT_BEGIN: // Wait for the user to program all the pointers and then // call SMTPSendMail() if(!SMTPFlags.bits.ReadyToStart) break; // Obtain ownership of the DNS resolution module if(!DNSBeginUsage()) break; // Obtain the IP address associated with the SMTP mail server if(SMTPClient.Server.szRAM || SMTPClient.Server.szROM) { if(SMTPClient.ROMPointers.Server) DNSResolveROM(SMTPClient.Server.szROM, DNS_TYPE_A); else DNSResolve(SMTPClient.Server.szRAM, DNS_TYPE_A); } else { // If we don't have a mail server, try to send the mail // directly to the destination SMTP server if(SMTPClient.To.szRAM && !SMTPClient.ROMPointers.To) { SMTPClient.Server.szRAM = (BYTE*)strchr((char*)SMTPClient.To.szRAM, '@'); SMTPClient.ROMPointers.Server = 0; } else if(SMTPClient.To.szROM && SMTPClient.ROMPointers.To) { SMTPClient.Server.szROM = (ROM BYTE*)strchrpgm((ROM char*)SMTPClient.To.szROM, '@'); SMTPClient.ROMPointers.Server = 1; } if(!(SMTPClient.Server.szRAM || SMTPClient.Server.szROM)) { if(SMTPClient.CC.szRAM && !SMTPClient.ROMPointers.CC) { SMTPClient.Server.szRAM = (BYTE*)strchr((char*)SMTPClient.CC.szRAM, '@'); SMTPClient.ROMPointers.Server = 0; } else if(SMTPClient.CC.szROM && SMTPClient.ROMPointers.CC) { SMTPClient.Server.szROM = (ROM BYTE*)strchrpgm((ROM char*)SMTPClient.CC.szROM, '@'); SMTPClient.ROMPointers.Server = 1; } } if(!(SMTPClient.Server.szRAM || SMTPClient.Server.szROM)) { if(SMTPClient.BCC.szRAM && !SMTPClient.ROMPointers.BCC) { SMTPClient.Server.szRAM = (BYTE*)strchr((char*)SMTPClient.BCC.szRAM, '@'); SMTPClient.ROMPointers.Server = 0; } else if(SMTPClient.BCC.szROM && SMTPClient.ROMPointers.BCC) { SMTPClient.Server.szROM = (ROM BYTE*)strchrpgm((ROM char*)SMTPClient.BCC.szROM, '@'); SMTPClient.ROMPointers.Server = 1; } } // See if we found a hostname anywhere which we could resolve if(!(SMTPClient.Server.szRAM || SMTPClient.Server.szROM)) { DNSEndUsage(); ResponseCode = SMTP_RESOLVE_ERROR; TransportState = TRANSPORT_HOME; break; } // Skip over the @ sign and resolve the host name if(SMTPClient.ROMPointers.Server) { SMTPClient.Server.szROM++; DNSResolveROM(SMTPClient.Server.szROM, DNS_TYPE_MX); } else { SMTPClient.Server.szRAM++; DNSResolve(SMTPClient.Server.szRAM, DNS_TYPE_MX); } } Timer = TickGet(); TransportState++; break; case TRANSPORT_NAME_RESOLVE: // Wait for the DNS server to return the requested IP address if(!DNSIsResolved(&SMTPServer)) { // Timeout after 6 seconds of unsuccessful DNS resolution if(TickGet() - Timer > 6*TICK_SECOND) { ResponseCode = SMTP_RESOLVE_ERROR; TransportState = TRANSPORT_HOME; DNSEndUsage(); } 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. ResponseCode = SMTP_RESOLVE_ERROR; TransportState = TRANSPORT_HOME; break; } TransportState++; // No need to break here case TRANSPORT_OBTAIN_SOCKET: // Connect a TCP socket to the remote SMTP server MySocket = TCPOpen(SMTPServer.Val, TCP_OPEN_IP_ADDRESS, SMTPClient.ServerPort, TCP_PURPOSE_DEFAULT); // Abort operation if no TCP sockets are available // If this ever happens, add some more // TCP_PURPOSE_DEFAULT sockets in TCPIPConfig.h if(MySocket == INVALID_SOCKET) break; TransportState++; Timer = TickGet(); // No break; fall into TRANSPORT_SOCKET_OBTAINED #if defined(STACK_USE_SSL_CLIENT) case TRANSPORT_SECURING_SOCKET: if(!TCPIsConnected(MySocket)) { // Don't stick around in the wrong state if the // server was connected, but then disconnected us. // Also time out if we can't establish the connection // to the SMTP server if((LONG)(TickGet()-Timer) > (LONG)(SMTP_SERVER_REPLY_TIMEOUT)) { ResponseCode = SMTP_CONNECT_ERROR; TransportState = TRANSPORT_CLOSE; } break; } SMTPFlags.bits.ConnectedOnce = TRUE; // Start SSL if needed for this connection if(SMTPClient.UseSSL && !TCPStartSSLClient(MySocket,NULL)) break; // Move on to main state Timer = TickGet(); TransportState++; break; #endif case TRANSPORT_SOCKET_OBTAINED: if(!TCPIsConnected(MySocket)) { // Don't stick around in the wrong state if the // server was connected, but then disconnected us. // Also time out if we can't establish the connection // to the SMTP server if(SMTPFlags.bits.ConnectedOnce || ((LONG)(TickGet()-Timer) > (LONG)(SMTP_SERVER_REPLY_TIMEOUT))) { ResponseCode = SMTP_CONNECT_ERROR; TransportState = TRANSPORT_CLOSE; } break; } SMTPFlags.bits.ConnectedOnce = TRUE; #if defined(STACK_USE_SSL_CLIENT) // Make sure the SSL handshake has completed if(SMTPClient.UseSSL && TCPSSLIsHandshaking(MySocket)) break; #endif // See if the server sent us anything while(TCPIsGetReady(MySocket)) { TCPGet(MySocket, &i); switch(RXParserState) { case RX_BYTE_0: case RX_BYTE_1: case RX_BYTE_2: RXBuffer[RXParserState] = i; RXParserState++; break; case RX_BYTE_3: switch(i) { case ' ': SMTPFlags.bits.RXSkipResponse = FALSE; RXParserState++; break; case '-': SMTPFlags.bits.RXSkipResponse = TRUE; RXParserState++; break; case '\r': RXParserState = RX_SEEK_LF; break; } break; case RX_SEEK_CR: if(i == '\r') RXParserState++; break; case RX_SEEK_LF: // If we received the whole command if(i == '\n') { RXParserState = RX_BYTE_0; if(!SMTPFlags.bits.RXSkipResponse) { // The server sent us a response code // Null terminate the ASCII reponse code so we can convert it to an integer RXBuffer[3] = 0; ResponseCode = atoi((char*)RXBuffer); // Handle the response switch(SMTPState) { case SMTP_HELO_ACK: if(ResponseCode >= 200u && ResponseCode <= 299u) { if(SMTPClient.Username.szRAM || SMTPClient.Username.szROM) SMTPState = SMTP_AUTH_LOGIN; else SMTPState = SMTP_MAILFROM; } else SMTPState = SMTP_QUIT_INIT; break; case SMTP_AUTH_LOGIN_ACK: case SMTP_AUTH_USERNAME_ACK: if(ResponseCode == 334u) SMTPState++; else SMTPState = SMTP_QUIT_INIT; break; case SMTP_AUTH_PASSWORD_ACK: if(ResponseCode == 235u) SMTPState++; else SMTPState = SMTP_QUIT_INIT; break; case SMTP_HOME: case SMTP_MAILFROM_ACK: case SMTP_RCPTTO_ACK: case SMTP_RCPTTOCC_ACK: case SMTP_RCPTTOBCC_ACK: tmp = SMTPState; if(ResponseCode >= 200u && ResponseCode <= 299u) SMTPState++; else SMTPState = SMTP_QUIT_INIT; break; case SMTP_DATA_ACK: if(ResponseCode == 354u) SMTPState++; else SMTPState = SMTP_QUIT_INIT; break; case SMTP_DATA_BODY_ACK: if(ResponseCode >= 200u && ResponseCode <= 299u) SMTPFlags.bits.SentSuccessfully = TRUE; SMTPState = SMTP_QUIT_INIT; break; // Default case needed to supress compiler diagnostics default: break; } } } else if(i != '\r') RXParserState--; break; } } // Generate new data in the TX buffer, as needed, if possible if(TCPIsPutReady(MySocket) < 64u) break; switch(SMTPState) { case SMTP_HELO: if(SMTPClient.Username.szROM == NULL) TCPPutROMString(MySocket, (ROM BYTE*)"HELO MCHPBOARD\r\n"); else TCPPutROMString(MySocket, (ROM BYTE*)"EHLO MCHPBOARD\r\n"); TCPFlush(MySocket); SMTPState++; break; case SMTP_AUTH_LOGIN: // Note: This state is only entered from SMTP_HELO_ACK if the application // has specified a Username to use (either SMTPClient.Username.szROM or // SMTPClient.Username.szRAM is non-NULL) TCPPutROMString(MySocket, (ROM BYTE*)"AUTH LOGIN\r\n"); TCPFlush(MySocket); SMTPState++; break; case SMTP_AUTH_USERNAME: // Base 64 encode and transmit the username. if(SMTPClient.ROMPointers.Username) { ROMStrPtr = SMTPClient.Username.szROM; w = strlenpgm((ROM char*)ROMStrPtr); } else { RAMStrPtr = SMTPClient.Username.szRAM; w = strlen((char*)RAMStrPtr); } while(w) { i = 0; while((i < w) && (i < sizeof(vBase64Buffer)*3/4)) { if(SMTPClient.ROMPointers.Username) vBase64Buffer[i] = *ROMStrPtr++; else vBase64Buffer[i] = *RAMStrPtr++; i++; } w -= i; Base64Encode(vBase64Buffer, i, vBase64Buffer, sizeof(vBase64Buffer)); TCPPutArray(MySocket, vBase64Buffer, sizeof(vBase64Buffer)); } TCPPutROMString(MySocket, (ROM BYTE*)"\r\n"); TCPFlush(MySocket); SMTPState++; break; case SMTP_AUTH_PASSWORD: // Base 64 encode and transmit the password if(SMTPClient.ROMPointers.Password) { ROMStrPtr = SMTPClient.Password.szROM; w = strlenpgm((ROM char*)ROMStrPtr); } else { RAMStrPtr = SMTPClient.Password.szRAM; w = strlen((char*)RAMStrPtr); } while(w) { i = 0; while((i < w) && (i < sizeof(vBase64Buffer)*3/4)) { if(SMTPClient.ROMPointers.Password) vBase64Buffer[i] = *ROMStrPtr++; else vBase64Buffer[i] = *RAMStrPtr++; i++; } w -= i; Base64Encode(vBase64Buffer, i, vBase64Buffer, sizeof(vBase64Buffer)); TCPPutArray(MySocket, vBase64Buffer, sizeof(vBase64Buffer)); } TCPPutROMString(MySocket, (ROM BYTE*)"\r\n"); TCPFlush(MySocket); SMTPState++; break; case SMTP_MAILFROM: // Send MAIL FROM header. Note that this is for the SMTP server validation, // not what actually will be displayed in the recipients mail client as a // return address. TCPPutROMString(MySocket, (ROM BYTE*)"MAIL FROM:<"); if(SMTPClient.ROMPointers.From) { ROMStrPtr = FindROMEmailAddress(SMTPClient.From.szROM, &wAddressLength); TCPPutROMArray(MySocket, ROMStrPtr, wAddressLength); } else { RAMStrPtr = FindEmailAddress(SMTPClient.From.szRAM, &wAddressLength); TCPPutArray(MySocket, RAMStrPtr, wAddressLength); } TCPPutROMString(MySocket, (ROM BYTE*)">\r\n"); TCPFlush(MySocket); SMTPState++; break; case SMTP_RCPTTO_INIT: // See if there are any (To) recipients to process if(SMTPClient.To.szRAM && !SMTPClient.ROMPointers.To) { RAMStrPtr = FindEmailAddress(SMTPClient.To.szRAM, &wAddressLength); if(wAddressLength) { SMTPState = SMTP_RCPTTO; break; } } if(SMTPClient.To.szROM && SMTPClient.ROMPointers.To) { ROMStrPtr = FindROMEmailAddress(SMTPClient.To.szROM, &wAddressLength); if(wAddressLength) { SMTPState = SMTP_RCPTTO; break; } } SMTPState = SMTP_RCPTTOCC_INIT; break; case SMTP_RCPTTO: case SMTP_RCPTTOCC: case SMTP_RCPTTOBCC: TCPPutROMString(MySocket, (ROM BYTE*)"RCPT TO:<"); if( (SMTPClient.ROMPointers.To && (SMTPState == SMTP_RCPTTO)) || (SMTPClient.ROMPointers.CC && (SMTPState == SMTP_RCPTTOCC)) || (SMTPClient.ROMPointers.BCC && (SMTPState == SMTP_RCPTTOBCC)) ) TCPPutROMArray(MySocket, ROMStrPtr, wAddressLength); else TCPPutArray(MySocket, RAMStrPtr, wAddressLength); TCPPutROMString(MySocket, (ROM BYTE*)">\r\n"); TCPFlush(MySocket); SMTPState++; break; case SMTP_RCPTTO_ISDONE: // See if we have any more (To) recipients to process // If we do, we must roll back a couple of states if(SMTPClient.ROMPointers.To) ROMStrPtr = FindROMEmailAddress(ROMStrPtr+wAddressLength, &wAddressLength); else RAMStrPtr = FindEmailAddress(RAMStrPtr+wAddressLength, &wAddressLength); if(wAddressLength) { SMTPState = SMTP_RCPTTO; break; } // All done with To field SMTPState++; //No break case SMTP_RCPTTOCC_INIT: // See if there are any Carbon Copy (CC) recipients to process if(SMTPClient.CC.szRAM && !SMTPClient.ROMPointers.CC) { RAMStrPtr = FindEmailAddress(SMTPClient.CC.szRAM, &wAddressLength); if(wAddressLength) { SMTPState = SMTP_RCPTTOCC; break; } } if(SMTPClient.CC.szROM && SMTPClient.ROMPointers.CC) { ROMStrPtr = FindROMEmailAddress(SMTPClient.CC.szROM, &wAddressLength); if(wAddressLength) { SMTPState = SMTP_RCPTTOCC; break; } } SMTPState = SMTP_RCPTTOBCC_INIT; break; case SMTP_RCPTTOCC_ISDONE: // See if we have any more Carbon Copy (CC) recipients to process // If we do, we must roll back a couple of states if(SMTPClient.ROMPointers.CC) ROMStrPtr = FindROMEmailAddress(ROMStrPtr+wAddressLength, &wAddressLength); else RAMStrPtr = FindEmailAddress(RAMStrPtr+wAddressLength, &wAddressLength); if(wAddressLength) { SMTPState = SMTP_RCPTTOCC; break; } // All done with CC field SMTPState++; //No break case SMTP_RCPTTOBCC_INIT: // See if there are any Blind Carbon Copy (BCC) recipients to process if(SMTPClient.BCC.szRAM && !SMTPClient.ROMPointers.BCC) { RAMStrPtr = FindEmailAddress(SMTPClient.BCC.szRAM, &wAddressLength); if(wAddressLength) { SMTPState = SMTP_RCPTTOBCC; break; } } if(SMTPClient.BCC.szROM && SMTPClient.ROMPointers.BCC) { ROMStrPtr = FindROMEmailAddress(SMTPClient.BCC.szROM, &wAddressLength); if(wAddressLength) { SMTPState = SMTP_RCPTTOBCC; break; } } // All done with BCC field SMTPState = SMTP_DATA; break; case SMTP_RCPTTOBCC_ISDONE: // See if we have any more Blind Carbon Copy (CC) recipients to process // If we do, we must roll back a couple of states if(SMTPClient.ROMPointers.BCC) ROMStrPtr = FindROMEmailAddress(ROMStrPtr+wAddressLength, &wAddressLength); else RAMStrPtr = FindEmailAddress(RAMStrPtr+wAddressLength, &wAddressLength); if(wAddressLength) { SMTPState = SMTP_RCPTTOBCC; break; } // All done with BCC field SMTPState++; //No break case SMTP_DATA: TCPPutROMString(MySocket, (ROM BYTE*)"DATA\r\n"); SMTPState++; PutHeadersState = PUTHEADERS_FROM_INIT; TCPFlush(MySocket); break; case SMTP_DATA_HEADER: while((PutHeadersState != PUTHEADERS_DONE) && (TCPIsPutReady(MySocket) > 64u)) { switch(PutHeadersState) { case PUTHEADERS_FROM_INIT: if(SMTPClient.From.szRAM || SMTPClient.From.szROM) { PutHeadersState = PUTHEADERS_FROM; TCPPutROMString(MySocket, (ROM BYTE*)"From: "); } else { PutHeadersState = PUTHEADERS_TO_INIT; } break; case PUTHEADERS_FROM: if(SMTPClient.ROMPointers.From) { SMTPClient.From.szROM = TCPPutROMString(MySocket, SMTPClient.From.szROM); if(*SMTPClient.From.szROM == 0u) PutHeadersState = PUTHEADERS_TO_INIT; } else { SMTPClient.From.szRAM = TCPPutString(MySocket, SMTPClient.From.szRAM); if(*SMTPClient.From.szRAM == 0u) PutHeadersState = PUTHEADERS_TO_INIT; } break; case PUTHEADERS_TO_INIT: if(SMTPClient.To.szRAM || SMTPClient.To.szROM) { PutHeadersState = PUTHEADERS_TO; TCPPutROMString(MySocket, (ROM BYTE*)"\r\nTo: "); } else { PutHeadersState = PUTHEADERS_CC_INIT; } break; case PUTHEADERS_TO: if(SMTPClient.ROMPointers.To) { SMTPClient.To.szROM = TCPPutROMString(MySocket, SMTPClient.To.szROM); if(*SMTPClient.To.szROM == 0u) PutHeadersState = PUTHEADERS_CC_INIT; } else { SMTPClient.To.szRAM = TCPPutString(MySocket, SMTPClient.To.szRAM); if(*SMTPClient.To.szRAM == 0u) PutHeadersState = PUTHEADERS_CC_INIT; } break; case PUTHEADERS_CC_INIT: if(SMTPClient.CC.szRAM || SMTPClient.CC.szROM) { PutHeadersState = PUTHEADERS_CC; TCPPutROMString(MySocket, (ROM BYTE*)"\r\nCC: "); } else { PutHeadersState = PUTHEADERS_SUBJECT_INIT; } break; case PUTHEADERS_CC: if(SMTPClient.ROMPointers.CC) { SMTPClient.CC.szROM = TCPPutROMString(MySocket, SMTPClient.CC.szROM); if(*SMTPClient.CC.szROM == 0u) PutHeadersState = PUTHEADERS_SUBJECT_INIT; } else { SMTPClient.CC.szRAM = TCPPutString(MySocket, SMTPClient.CC.szRAM); if(*SMTPClient.CC.szRAM == 0u) PutHeadersState = PUTHEADERS_SUBJECT_INIT; } break; case PUTHEADERS_SUBJECT_INIT: if(SMTPClient.Subject.szRAM || SMTPClient.Subject.szROM) { PutHeadersState = PUTHEADERS_SUBJECT; TCPPutROMString(MySocket, (ROM BYTE*)"\r\nSubject: "); } else { PutHeadersState = PUTHEADERS_OTHER_INIT; } break; case PUTHEADERS_SUBJECT: if(SMTPClient.ROMPointers.Subject) { SMTPClient.Subject.szROM = TCPPutROMString(MySocket, SMTPClient.Subject.szROM); if(*SMTPClient.Subject.szROM == 0u) PutHeadersState = PUTHEADERS_OTHER_INIT; } else { SMTPClient.Subject.szRAM = TCPPutString(MySocket, SMTPClient.Subject.szRAM); if(*SMTPClient.Subject.szRAM == 0u) PutHeadersState = PUTHEADERS_OTHER_INIT; } break; case PUTHEADERS_OTHER_INIT: TCPPutROMArray(MySocket, (ROM BYTE*)"\r\n", 2); if(SMTPClient.OtherHeaders.szRAM || SMTPClient.OtherHeaders.szROM) { PutHeadersState = PUTHEADERS_OTHER; } else { TCPPutROMArray(MySocket, (ROM BYTE*)"\r\n", 2); PutHeadersState = PUTHEADERS_DONE; SMTPState++; } break; case PUTHEADERS_OTHER: if(SMTPClient.ROMPointers.OtherHeaders) { SMTPClient.OtherHeaders.szROM = TCPPutROMString(MySocket, SMTPClient.OtherHeaders.szROM); if(*SMTPClient.OtherHeaders.szROM == 0u) { TCPPutROMArray(MySocket, (ROM BYTE*)"\r\n", 2); PutHeadersState = PUTHEADERS_DONE; SMTPState++; } } else { SMTPClient.OtherHeaders.szRAM = TCPPutString(MySocket, SMTPClient.OtherHeaders.szRAM); if(*SMTPClient.OtherHeaders.szRAM == 0u) { TCPPutROMArray(MySocket, (ROM BYTE*)"\r\n", 2); PutHeadersState = PUTHEADERS_DONE; SMTPState++; } } break; // Default case needed to supress compiler diagnostics default: break; } } TCPFlush(MySocket); break; case SMTP_DATA_BODY_INIT: SMTPState++; RAMStrPtr = SMTPClient.Body.szRAM; ROMStrPtr2 = (ROM BYTE*)"\r\n.\r\n"; CRPeriod.Pos = NULL; if(RAMStrPtr) CRPeriod.Pos = (BYTE*)strstrrampgm((char*)RAMStrPtr, (ROM char*)"\r\n."); // No break here case SMTP_DATA_BODY: if(SMTPClient.Body.szRAM || SMTPClient.Body.szROM) { if(*ROMStrPtr2) { // Put the application data, doing the transparancy replacement of "\r\n." with "\r\n.." while(CRPeriod.Pos) { CRPeriod.Pos += 3; RAMStrPtr += TCPPutArray(MySocket, RAMStrPtr, CRPeriod.Pos-RAMStrPtr); if(RAMStrPtr == CRPeriod.Pos) { if(!TCPPut(MySocket, '.')) { CRPeriod.Pos -= 3; break; } } else { CRPeriod.Pos -= 3; break; } CRPeriod.Pos = (BYTE*)strstrrampgm((char*)RAMStrPtr, (ROM char*)"\r\n."); } // If we get down here, either all replacements have been made or there is no remaining space in the TCP output buffer RAMStrPtr = TCPPutString(MySocket, RAMStrPtr); ROMStrPtr2 = TCPPutROMString(MySocket, ROMStrPtr2); TCPFlush(MySocket); } } else { if(SMTPFlags.bits.ReadyToFinish) { if(*ROMStrPtr2) { ROMStrPtr2 = TCPPutROMString(MySocket, ROMStrPtr2); TCPFlush(MySocket); } } } if(*ROMStrPtr2 == 0u) { SMTPState++; } break; case SMTP_QUIT_INIT: SMTPState++; ROMStrPtr = (ROM BYTE*)"QUIT\r\n"; // No break here case SMTP_QUIT: if(*ROMStrPtr) { ROMStrPtr = TCPPutROMString(MySocket, ROMStrPtr); TCPFlush(MySocket); } if(*ROMStrPtr == 0u) { TransportState = TRANSPORT_CLOSE; } break; // Default case needed to supress compiler diagnostics default: break; } break; case TRANSPORT_CLOSE: // Close the socket so it can be used by other modules TCPDisconnect(MySocket); MySocket = INVALID_SOCKET; // Go back to doing nothing TransportState = TRANSPORT_HOME; break; } }
static void OutShit(TCP_SOCKET socket, BYTE ch) { BYTE end = ch+8; WORD *ww = (WORD*)&httpData[0]; TCPPutROMString(socket,(ROM BYTE*)saci[ch/8]); for(;ch<end;ch++) { TCPPut(socket,' '); OutLong(socket,(DWORD)ww[ch],3); } }