middleware/netware/ethernettftp.c File Reference

Go to the source code of this file.

Functions

void F_EthernetTftpInit (void)
void F_EthernetTftpSvc (void)
INT8U F_EthernetTftpInUseCheck (INT16U UserId)
INT8U F_EthernetTftpAllocate (INT16U UserId)
INT8U F_EthernetTftpRelease (INT16U UserId)
INT8U F_EthernetTftpReset (INT16U UserId)
void F_EthernetTftpPacketReceive (ETHBUFFER *pBuffer)
void F_EthernetTftpWrqReceive (ETHBUFFER *pBuffer)
INT8U F_EthernetTftpDataReceive (ETHBUFFER *pBuffer)
INT8U F_EthernetTftpErrorReceive (ETHBUFFER *pBuffer)
void F_EthernetTftpPut (INT8U *pData, INT32U Length)
void F_EthernetTftpAckSend (TFTP_HEAD *pTftpHead, INT16U BlockNumber)
INT8U F_EthernetTftpAddressSet (INT16U UserId, INT32U DownloadAddress)
INT8U F_EthernetTftpDownloadCheck (void)

Variables

TFTP_CONTROL TftpCtrl

Function Documentation

void F_EthernetTftpAckSend ( TFTP_HEAD *  pTftpHead,
INT16U  BlockNumber 
)

Definition at line 215 of file ethernettftp.c.

00215                                                                    {
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 }

INT8U F_EthernetTftpAddressSet ( INT16U  UserId,
INT32U  DownloadAddress 
)

Definition at line 61 of file ethernettftp.c.

00061                                                                     {
00062     if((TftpCtrl.InUse==TRUE)&&(TftpCtrl.UserId==UserId)){        
00063         TftpCtrl.DownloadAddress=DownloadAddress;
00064         return TRUE;
00065     }
00066     else return FALSE;
00067 }

INT8U F_EthernetTftpAllocate ( INT16U  UserId  ) 

Definition at line 46 of file ethernettftp.c.

00046                                            {
00047     if(TftpCtrl.InUse==FALSE){             
00048         TftpCtrl.UserId=UserId;        
00049         TftpCtrl.InUse=TRUE;  
00050         return TRUE;
00051     }
00052     else return FALSE;
00053 }

INT8U F_EthernetTftpDataReceive ( ETHBUFFER *  pBuffer  ) 

Definition at line 146 of file ethernettftp.c.

00146                                                    {
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 }

INT8U F_EthernetTftpDownloadCheck ( void   ) 

Definition at line 81 of file ethernettftp.c.

00081                                        {
00082     if(TftpCtrl.InUse==TRUE){
00083         if(TftpCtrl.End==TRUE) return TRUE;
00084         else return FALSE;
00085     }
00086     else return FALSE;
00087 }

INT8U F_EthernetTftpErrorReceive ( ETHBUFFER *  pBuffer  ) 

Definition at line 196 of file ethernettftp.c.

00196                                                     {
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 }

void F_EthernetTftpInit ( void   ) 

Definition at line 29 of file ethernettftp.c.

00029                              {
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 }

INT8U F_EthernetTftpInUseCheck ( INT16U  UserId  ) 

Definition at line 42 of file ethernettftp.c.

00042                                              {
00043     if(TftpCtrl.InUse==TRUE) return TRUE;
00044     else return FALSE; 
00045 }

void F_EthernetTftpPacketReceive ( ETHBUFFER *  pBuffer  ) 

Definition at line 88 of file ethernettftp.c.

00088                                                     {
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 }

void F_EthernetTftpPut ( INT8U *  pData,
INT32U  Length 
)

Definition at line 205 of file ethernettftp.c.

00205                                                   {    
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 }

INT8U F_EthernetTftpRelease ( INT16U  UserId  ) 

Definition at line 54 of file ethernettftp.c.

00054                                           {
00055     if((TftpCtrl.InUse==TRUE)&&(TftpCtrl.UserId==UserId)){        
00056         TftpCtrl.InUse=FALSE;
00057         return TRUE;
00058     }
00059     else return FALSE;
00060 }

INT8U F_EthernetTftpReset ( INT16U  UserId  ) 

Definition at line 68 of file ethernettftp.c.

00068                                         {
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 }

void F_EthernetTftpSvc ( void   ) 

Definition at line 41 of file ethernettftp.c.

00041 {}

void F_EthernetTftpWrqReceive ( ETHBUFFER *  pBuffer  ) 

Definition at line 132 of file ethernettftp.c.

00132                                                  {
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 }

Variable Documentation

TFTP_CONTROL TftpCtrl

Definition at line 15 of file ethernettftp.c.

Generated on Tue Sep 2 08:45:42 2008 for A Simple operation System using S3C2410 by  doxygen 1.5.6