A Simple operation System using S3C2410: middleware/netware/ethernettftp.c Source File

00001 /******************************************************
00002 * Function: etherent tftp protocol handler
00003 *
00004 * File:   etherenttftp.c
00005 * Author: Book Chen
00006 * Date:   2008.07.18
00007 *******************************************************
00008 */
00009 #include "includes.h"
00010 
00011 #define EthernetTftpIdleState     0
00012 #define EthernetTftpDownloadState 1
00013 #define EthernetTftpUpLoadState   2
00014 
00015 TFTP_CONTROL TftpCtrl;
00016 void F_EthernetTftpInit(void);
00017 void F_EthernetTftpSvc(void);
00018 INT8U F_EthernetTftpInUseCheck(INT16U UserId);
00019 INT8U F_EthernetTftpAllocate(INT16U UserId);
00020 INT8U F_EthernetTftpRelease(INT16U UserId);
00021 INT8U F_EthernetTftpReset(INT16U UserId);
00022 void F_EthernetTftpPacketReceive(ETHBUFFER *pBuffer);
00023 void F_EthernetTftpWrqReceive(ETHBUFFER *pBuffer);
00024 INT8U F_EthernetTftpDataReceive(ETHBUFFER *pBuffer);
00025 INT8U F_EthernetTftpErrorReceive(ETHBUFFER *pBuffer);
00026 void F_EthernetTftpPut(INT8U *pData,INT32U Length);
00027 void F_EthernetTftpAckSend(TFTP_HEAD *pTftpHead,INT16U BlockNumber);
00028 
00029 void F_EthernetTftpInit(void){
00030     TftpCtrl.ClientBlock=0;
00031     TftpCtrl.Begin=FALSE;
00032     TftpCtrl.End=FALSE;
00033     TftpCtrl.HasData=FALSE;
00034     TftpCtrl.Length=0;
00035     TftpCtrl.Counter=0;
00036     TftpCtrl.InUse=FALSE;
00037     //TftpCtrl.Id=ID_ETHERNET_TFTP;
00038     TftpCtrl.Status=0;
00039     TftpCtrl.State=EthernetTftpIdleState;
00040 }
00041 void F_EthernetTftpSvc(void){}
00042 INT8U F_EthernetTftpInUseCheck(INT16U UserId){
00043     if(TftpCtrl.InUse==TRUE) return TRUE;
00044     else return FALSE; 
00045 }
00046 INT8U F_EthernetTftpAllocate(INT16U UserId){
00047     if(TftpCtrl.InUse==FALSE){             
00048         TftpCtrl.UserId=UserId;        
00049         TftpCtrl.InUse=TRUE;  
00050         return TRUE;
00051     }
00052     else return FALSE;
00053 }
00054 INT8U F_EthernetTftpRelease(INT16U UserId){
00055     if((TftpCtrl.InUse==TRUE)&&(TftpCtrl.UserId==UserId)){        
00056         TftpCtrl.InUse=FALSE;
00057         return TRUE;
00058     }
00059     else return FALSE;
00060 }
00061 INT8U F_EthernetTftpAddressSet(INT16U UserId,INT32U DownloadAddress){
00062     if((TftpCtrl.InUse==TRUE)&&(TftpCtrl.UserId==UserId)){        
00063         TftpCtrl.DownloadAddress=DownloadAddress;
00064         return TRUE;
00065     }
00066     else return FALSE;
00067 }                            
00068 INT8U F_EthernetTftpReset(INT16U UserId){
00069     if((TftpCtrl.InUse==TRUE)&&(TftpCtrl.UserId==UserId)){        
00070         TftpCtrl.Begin=FALSE;
00071         TftpCtrl.End=FALSE;
00072         TftpCtrl.HasData=FALSE;
00073         TftpCtrl.Length=0;
00074         TftpCtrl.Counter=0;
00075         TftpCtrl.Status=0;
00076         TftpCtrl.State=EthernetTftpIdleState;
00077         return TRUE;
00078     }
00079     else return FALSE;
00080 }
00081 INT8U F_EthernetTftpDownloadCheck(void){
00082     if(TftpCtrl.InUse==TRUE){
00083         if(TftpCtrl.End==TRUE) return TRUE;
00084         else return FALSE;
00085     }
00086     else return FALSE;
00087 }
00088 void F_EthernetTftpPacketReceive(ETHBUFFER *pBuffer){
00089     TFTP_HEAD *pTftpHead;
00090     
00091     #if(DEBUG_ETHERNET_TFTP==1)
00092         printf("\n TFTP rx ");
00093     #endif
00094     pTftpHead=(TFTP_HEAD *)pBuffer->pData;
00095     switch(F_EthernetUnsignedShortN2H(pTftpHead->Opcode)){
00096         case TFTP_READ_REQUEST:
00097             #if(DEBUG_ETHERNET_TFTP==1)
00098                 printf("READ PACKET ");
00099             #endif
00100             break;
00101         case TFTP_WRITE_REQUEST:
00102             #if(DEBUG_ETHERNET_TFTP==1)
00103                 printf("WRITE REQUEST ");
00104             #endif
00105             F_EthernetTftpWrqReceive(pBuffer);
00106             break;
00107         case TFTP_DATA_PACKET:
00108             #if(DEBUG_ETHERNET_TFTP==1)
00109                 printf("DATA PACKET ");
00110             #endif
00111             F_EthernetTftpDataReceive(pBuffer);
00112             break;
00113         case TFTP_ACKNOWLEDGE:
00114             #if(DEBUG_ETHERNET_TFTP==1)
00115                 printf("ACKNOWLEDGE ");
00116             #endif
00117             break;
00118         case TFTP_ERROR:        
00119             #if(DEBUG_ETHERNET_TFTP==1)
00120                 printf("ERROR ");
00121             #endif
00122             F_EthernetTftpErrorReceive(pBuffer);            
00123             TftpCtrl.End=TRUE;
00124             break;
00125         default:
00126             #if(DEBUG_ETHERNET_TFTP==1)
00127                 printf("NONE ");
00128             #endif
00129             break;
00130     }
00131 }
00132 void F_EthernetTftpWrqReceive(ETHBUFFER *pBuffer){
00133     TFTP_HEAD *pTftpHead;
00134     
00135     memcpy(TftpCtrl.ClientIp,F_EthernetIpSourceIpGet(pBuffer),ETHERNET_IP_LENGTH);
00136     TftpCtrl.ClientPort=F_EthernetUdpSourcePortGet(pBuffer);
00137     pTftpHead=(TFTP_HEAD *)pBuffer->pData;
00138     F_EthernetTftpAckSend(pTftpHead,0); // send ack to host
00139     TftpCtrl.ClientBlock=1; // 1.2.3.4.5...increase after each data receive
00140     TftpCtrl.pData=(INT8U *)TftpCtrl.DownloadAddress;
00141     TftpCtrl.Begin=TRUE;    // set tftp download start flag
00142     TftpCtrl.End=FALSE;     // clear tftp download end flag 
00143     TftpCtrl.Length=0;      
00144     TftpCtrl.Counter=0;
00145 }
00146 INT8U F_EthernetTftpDataReceive(ETHBUFFER *pBuffer){
00147     TFTP_HEAD *pTftpHead;
00148     INT32U     Length;
00149     INT8U     *pData;
00150     
00151     pData=F_EthernetIpSourceIpGet(pBuffer);
00152     if((TftpCtrl.ClientIp[0]!=pData[0])||
00153        (TftpCtrl.ClientIp[1]!=pData[1])||
00154        (TftpCtrl.ClientIp[2]!=pData[2])||
00155        (TftpCtrl.ClientIp[3]!=pData[3])){        
00156         #if(DEBUG_ETHERNET_TFTP==1)
00157             printf("IP error");
00158         #endif
00159         return FALSE;
00160     }    
00161     if(TftpCtrl.ClientPort!=F_EthernetUdpSourcePortGet(pBuffer)){
00162         #if(DEBUG_ETHERNET_TFTP==1)
00163             printf("PORT error");
00164         #endif
00165         return FALSE;
00166     }
00167     pTftpHead=(TFTP_HEAD *)pBuffer->pData;
00168     if(TftpCtrl.ClientBlock==F_EthernetUnsignedShortN2H(pTftpHead->Un.BlockNumber)){
00169         #if(DEBUG_ETHERNET_TFTP==1)
00170             printf(" data 0 ");
00171         #endif
00172         Length=pBuffer->Length-sizeof(TFTP_HEAD);
00173         F_EthernetTftpPut((INT8U *)pTftpHead+sizeof(TFTP_HEAD),Length); // get tftp data 
00174         F_EthernetTftpAckSend(pTftpHead,TftpCtrl.ClientBlock);
00175         TftpCtrl.ClientBlock++;
00176         if(Length<512){
00177             TftpCtrl.End=TRUE;
00178         }                    
00179     }
00180     else if(TftpCtrl.ClientBlock>F_EthernetUnsignedShortN2H(pTftpHead->Un.BlockNumber)){
00181         #if(DEBUG_ETHERNET_TFTP==1)
00182             printf(" data 1 ");
00183         #endif
00184         F_EthernetTftpAckSend(pTftpHead,F_EthernetUnsignedShortN2H(pTftpHead->Un.BlockNumber));        
00185         TftpCtrl.End=TRUE;
00186     }
00187     else{
00188         #if(DEBUG_ETHERNET_TFTP==1)
00189             printf(" data 2 ");
00190         #endif
00191         F_EthernetTftpAckSend(pTftpHead,TftpCtrl.ClientBlock);        
00192         TftpCtrl.End=TRUE;
00193     }
00194     return TRUE;
00195 }
00196 INT8U F_EthernetTftpErrorReceive(ETHBUFFER *pBuffer){
00197     TFTP_HEAD *pTftpHead;
00198     
00199     if(TftpCtrl.ClientIp!=F_EthernetIpSourceIpGet(pBuffer)) return FALSE;
00200     if(TftpCtrl.ClientPort!=F_EthernetUdpSourcePortGet(pBuffer)) return FALSE;
00201     pTftpHead=(TFTP_HEAD *)pBuffer->pData;
00202     F_EthernetTftpAckSend(pTftpHead,TftpCtrl.ClientBlock);
00203     return TRUE;
00204 }
00205 void F_EthernetTftpPut(INT8U *pData,INT32U Length){    
00206     
00207     TftpCtrl.Counter=TftpCtrl.Counter+Length; 
00208     if(TftpCtrl.Counter>32*1024){
00209         TftpCtrl.HasData=TRUE; // flag for each 32k data receive
00210         TftpCtrl.Counter=0;    
00211     }
00212     memcpy(TftpCtrl.pData+TftpCtrl.Length,pData,Length);
00213     TftpCtrl.Length=TftpCtrl.Length+Length;
00214 }
00215 void F_EthernetTftpAckSend(TFTP_HEAD *pTftpHead,INT16U BlockNumber){
00216     TFTP_HEAD *pTftpAck; 
00217     ETHBUFFER *pBuffer;
00218     
00219     #if(DEBUG_ETHERNET_TFTP==1)
00220         printf(" ack send ");
00221     #endif
00222     pBuffer=F_EthernetBufferAllocate();
00223     F_EthernetUdpBufferReserve(pBuffer);
00224     pTftpAck=(TFTP_HEAD *)F_EthernetBufferPut(pBuffer,sizeof(TFTP_HEAD));
00225     pTftpAck->Opcode=F_EthernetUnsignedShortH2N(TFTP_ACKNOWLEDGE);
00226     pTftpAck->Un.BlockNumber=F_EthernetUnsignedShortH2N(BlockNumber);
00227     F_EthernetUdpPacketSend(pBuffer,(INT8U *)TftpCtrl.ClientIp,TFTP,TftpCtrl.ClientPort); // TFTP=0x45 is a UDP protocol #
00228 }
00229 
00230