socket.c

W3100是WIZnet公司专门为以太网互联和嵌入式设备推出的硬件TCP／IP协议栈芯片

{
	u_char k;
	int size;
	un_l2cval wr_ptr, ack_ptr;
	u_char * send_ptr;

S_START:
	EX0 = 0;
	k = IndirectReadByte(SHADOW_TXWR_PTR(s));		// Must read the shadow register for reading 4byte pointer registers
	wait_1us(2);						// wait for reading 4byte pointer registers safely
	IndirectReadBuf(TX_WR_PTR(s),(u_char*)&wr_ptr,4);
	k = IndirectReadByte(SHADOW_TXACK_PTR(s));		// Must read the shadow register for reading 4byte pointer registers
	wait_1us(2);						// wait for reading 4byte pointer registers safely
	IndirectReadBuf(TX_ACK_PTR(s),(u_char*)&ack_ptr,4);
	EX0 = 1;

	// Calculate send free buffer size
	if (wr_ptr.lVal >= ack_ptr.lVal) size = SSIZE[s] - (wr_ptr.lVal - ack_ptr.lVal);
	else size = SSIZE[s] - (0 - ack_ptr.lVal + wr_ptr.lVal);

	
	if (size > SSIZE[s])                                                            // Recalulate after some delay because of error in pointer caluation
	{
		if (select(s, SEL_CONTROL) != SOCK_ESTABLISHED) return -1;              // Error

		wait_1ms(1);
#ifdef DEBUG
//		printf("1 ");
//		printf("%.8lx ", wr_ptr.lVal);
//		printf("%.8lx\r\n", ack_ptr.lVal);
		PutString("send_in() at S_START : ");PutHTOA(s); PutString(" : "); PutLTOA(wr_ptr.lVal) ; PutString(" : ");PutLTOA(ack_ptr.lVal) ;PutStringLn("");
#endif
		goto S_START;
	}

	if (size == 0)                                                                  // Wait when previous sending has not finished yet and there's no free buffer
	{
		if (select(s, SEL_CONTROL) != SOCK_ESTABLISHED) return -1;              // Error
		wait_1ms(1);
#ifdef DEBUG
		PutStringLn("send_in() at S_START : size == 0");
#endif
		goto S_START;
	}
	else if (size < len)	len = size;

	send_ptr = (u_char *)( SBUFBASEADDRESS[s] + (UINT)(wr_ptr.lVal & SMASK[s]));    // Calculate pointer to data copy
	write_data(s, buf, send_ptr, len);                                              // data copy

	while (IndirectReadByte(COMMAND(s)) & CSEND)                                    // Confirm send command
		if (select(s, SEL_CONTROL) != SOCK_ESTABLISHED) return -1;              // Error

	wr_ptr.lVal = wr_ptr.lVal + len;                                                // tx_wr_ptr update
	IndirectWriteBuf(TX_WR_PTR(s),(u_char*)&wr_ptr,4);

	IndirectWriteByte(COMMAND(s),CSEND);                                            // SEND

    return	(len);
}

/*
********************************************************************************
*               TCP data receiving function.
*
* Description : This function is for receiving TCP data.
*     The recv() function is an application I/F function. It continues to wait for as much data as the application wants to receive.
* Arguments   : s   - channel number
*               buf - Pointer where the data to be received is copied
*               len - Size of the data to be received
* Returns     : Succeeded: received data size, Failed: -1
* Note        : API Fcuntion
********************************************************************************
*/
int recv(SOCKET s, const u_char xdata* buf, u_int len)
{
	u_char k;
	u_int size;
	un_l2cval wr_ptr, rd_ptr;
	u_char * recv_ptr;

R_START:
	EX0 = 0;
	k = IndirectReadByte(SHADOW_RXWR_PTR(s));		// Must read the shadow register for reading 4byte pointer registers
	wait_1us(2);						// wait for reading 4byte pointer registers safely
	IndirectReadBuf(RX_WR_PTR(s),(u_char*)&wr_ptr,4);

	k = IndirectReadByte(SHADOW_RXRD_PTR(s));		// Must read the shadow register for reading 4byte pointer registers
	wait_1us(2);						// wait for reading 4byte pointer registers safely
	IndirectReadBuf(RX_RD_PTR(s),(u_char*)&rd_ptr,4);
	EX0 = 1;

	// calculate received data size
	if ( len <= 0 ) return (0);
	else if (wr_ptr.lVal >= rd_ptr.lVal) size = wr_ptr.lVal - rd_ptr.lVal;
	else size = 0 - rd_ptr.lVal + wr_ptr.lVal;

	
	if (size < len)                                                                 // Wait until receiving is done when received data size is less then len
	{
		if (select(s, SEL_CONTROL) != SOCK_ESTABLISHED) return -1;              // Error
		wait_1ms(1);  
#ifdef DEBUG
//		printf("size < len\r\n");
		PutStringLn("size < len");
#endif
		goto R_START;
	}

	recv_ptr = (u_char *) (RBUFBASEADDRESS[s] + (UINT)(rd_ptr.lVal & RMASK[s]));    // Calculate pointer to be copied received data

	read_data(s, recv_ptr, buf, len);                                               // Copy receibed data

	rd_ptr.lVal += len;                                                             // Update rx_rd_ptr
	IndirectWriteBuf(RX_RD_PTR(s),(u_char*)&rd_ptr,4);

	IndirectWriteByte(COMMAND(s),CRECV);                                            // RECV

    return	(len);
}
#endif	// __TCP__

#ifdef	__UDP__
/*
********************************************************************************
*               UDP data sending function.
*
* Description : Composed of the sendto()and sendto_in() functions.
*    The send() function is an application I/F function.
*    It continues to call the send_in() function to complete the sending of the data up to the size of the data to be sent
*    when the application is called.Unlike TCP transmission, it designates the destination address and the port.
* Arguments   : s    - channel port
*               buf  - Pointer pointing data to send
*               len  - data size to send
*               addr - destination IP address to send data
*               port - destination port number to send data
* Returns     : Sent data size
* Note        : API Function
********************************************************************************
*/
u_int sendto(SOCKET s, const u_char xdata* buf, u_int len, u_char * addr, u_int port)
{
	int ptr, size;

	while(IndirectReadByte(COMMAND(s)) & CSEND)			// Wait until previous send commnad has completed
		if(select(s,SEL_CONTROL) == SOCK_CLOSED) return -1;	// Errors.

	if (port != 0)							// Designate destination port number
		IndirectWriteBuf(DST_PORT_PTR(s),(u_char*)&port,2);					

	IndirectWriteBuf(DST_IP_PTR(s),addr,4);				// Designate destination IP address


#ifdef DEBUG
//	printf("sendto Parameter\r\n");
//	printf("Destination Port : %d\r\n", (u_int)*(DST_PORT_PTR(s)));
//	printf("Destination IP : %d.%d.%d.%d\r\n", *DST_IP_PTR(s) ,*DST_IP_PTR(s)+1, *DST_IP_PTR(s)+2, *DST_IP_PTR(s)+3);
	PutStringLn("sendto Parameter");
	PutString("Destination Port : ");PutHTOA(IndirectReadByte(DST_PORT_PTR(s)));PutHTOA(IndirectReadByte((DST_PORT_PTR(s)+1)));PutStringLn("");
	PutString("Destination IP : "); 
	PutHTOA(IndirectReadByte(DST_IP_PTR(s))); PutByte('.'); PutHTOA(IndirectReadByte((DST_IP_PTR(s)+1))); PutByte('.'); PutHTOA(IndirectReadByte((DST_IP_PTR(s)+2))); PutByte('.'); PutHTOA(IndirectReadByte((DST_IP_PTR(s)+3)));
	PutStringLn("");
#endif
	if (len <= 0) return (0);
	else 
	{
		ptr = 0;
		do{
			size = sendto_in(s, buf + ptr, len);
			if(size == -1) return -1;	// Error
			len = len - size;
			ptr += size;
		}while ( len > 0);
	}
	return ptr;
}
/*
********************************************************************************
*               UDP data sending function.
*
* Description : An internal function that is the same as the send_in() function of the TCP.
* Arguments   : s   - Channel number
*               buf - Pointer indicating the data to send
*               len - data size to send
* Returns     : Sent data size
* Note        : Internal Function
********************************************************************************
*/
u_int sendto_in(SOCKET s, const u_char xdata* buf, u_int len)
{
	u_char k;
	u_int size;
	un_l2cval wr_ptr, rd_ptr;
	u_char * send_ptr;

S2_START:
	if(select(s,SEL_CONTROL)==SOCK_CLOSED) return -1;	// Error
	EX0 = 0;
	k = IndirectReadByte(SHADOW_TXWR_PTR(s));
	wait_1us(2);
	IndirectReadBuf(TX_WR_PTR(s),(u_char*)&wr_ptr,4);

	k = IndirectReadByte(SHADOW_TXRD_PTR(s));
	wait_1us(2);
	IndirectReadBuf(TX_RD_PTR(s),(u_char*)&rd_ptr,4);
        EX0 = 1;

	// Calculate free buffer size to send
	if (wr_ptr.lVal >= rd_ptr.lVal) size = SSIZE[s] - (wr_ptr.lVal - rd_ptr.lVal);
	else size = SSIZE[s] - (0 - rd_ptr.lVal + wr_ptr.lVal);
	
	if (size > SSIZE[s])                                                            // Recalulate after some delay because of error in pointer caluation
	{
		wait_1ms(1);
#ifdef DEBUG
		PutString("sendto_in() at S2_START : ");PutHTOA(s); PutString(" : "); PutLTOA(wr_ptr.lVal) ; PutString(" : ");PutLTOA(rd_ptr.lVal) ;PutStringLn("");
#endif
		goto S2_START;
	}

	if (size == 0)                                                                  // Wait when previous sending has not finished yet and there's no free buffer
	{
		wait_1ms(1);
#ifdef DEBUG
		PutString("sendto_in() at S2_START : size == 0");
#endif
		goto S2_START;
	} 
	else if (size < len)	len = size;

	send_ptr = (u_char *)(SBUFBASEADDRESS[s] + (UINT)(wr_ptr.lVal & SMASK[s]));     // Calculate pointer to copy data pointer

	write_data(s, buf, send_ptr, len);                                              // Copy data

	while (IndirectReadByte(COMMAND(s)) & CSEND)					// Confirm previous send command
		if(select(s,SEL_CONTROL)==SOCK_CLOSED) return -1;                       // Error

	wr_ptr.lVal = wr_ptr.lVal + len;                                                // Update tx_wr_ptr
	IndirectWriteBuf(TX_WR_PTR(s),(u_char*)&wr_ptr,4);

	IndirectWriteByte(COMMAND(s),CSEND);						// SEND

    return	(len);
}
/*
********************************************************************************
*               UDP or IP data receiving function.
*
* Description : Function for receiving UDP and IP layer RAW mode data, and handling the data header.
* Arguments   : s    - channel number
*               buf  - Pointer where the data to be received is copied
*               len  - any number greater than zero.
*               addr - Peer IP address for receiving
*               port - Peer port number for receiving
* Returns     : Data size of received packet 
* Note        : API Function
********************************************************************************
*/
u_int recvfrom(SOCKET s, const u_char xdata * buf, u_int len,u_char * addr, u_int * port)
{
	struct _UDPHeader                      // When receiving UDP data, header added by W3100A
	{
		union 
		{
			struct
			 { 
				u_int size; 
				u_char addr[4]; 
				u_int port;
			}header;
			u_char stream[8];
        	}u;
	}xdata UDPHeader;

	u_int ret;
	u_char * recv_ptr;
	un_l2cval wr_ptr, rd_ptr;
	u_long size;
	u_char k;

	if(select(s,SEL_CONTROL)==SOCK_CLOSED) return -1;
	EX0 = 0;
	k = IndirectReadByte(SHADOW_RXWR_PTR(s));
	wait_1us(2);
	IndirectReadBuf(RX_WR_PTR(s),(u_char*)&wr_ptr,4);

	k = IndirectReadByte(SHADOW_RXRD_PTR(s));
	wait_1us(2);
	IndirectReadBuf(RX_RD_PTR(s),(u_char*)&rd_ptr,4);
	EX0 = 1;

	// Calculate received data size
	if(len <=0) return 0;
	else if (wr_ptr.lVal >= rd_ptr.lVal) size = wr_ptr.lVal - rd_ptr.lVal;
	else size = 0 - rd_ptr.lVal + wr_ptr.lVal;

	if(size == 0) return 0;
	
	recv_ptr = (u_char *)(RBUFBASEADDRESS[s] + (UINT)(rd_ptr.lVal & RMASK[s]));     // Calulate received data pointer

	k = IndirectReadByte(OPT_PROTOCOL(s));
	if ( (k & 0x07) == SOCK_DGRAM)							// Handle UDP data
	{
		read_data(s,recv_ptr,UDPHeader.u.stream,8);                             // W3100A UDP header copy
  		addr[0] = UDPHeader.u.header.addr[0];                                   // Read IP address of the peer
		addr[1] = UDPHeader.u.header.addr[1];
		addr[2] = UDPHeader.u.header.addr[2];
		addr[3] = UDPHeader.u.header.addr[3];                                   // Read Port number of the peer
		*port = UDPHeader.u.stream[6];
		*port = (*port << 8) + UDPHeader.u.stream[7];

#ifdef DEBUG
//		printf("UDP msg arrived\r\n");
//		printf("source Port : %d\r\n", *port);
//		printf("source IP : %d.%d.%d.%d\r\n", addr[0], addr[1], addr[2], addr[3]);
		PutStringLn("UDP msg arrived");
		PutString("UDP Header Size : 0x");PutITOA(UDPHeader.u.header.size);PutStringLn("");
		PutString("Source Port : ");PutITOA(*port);PutStringLn("");
		PutString("Destination IP : ");PutHTOA(addr[0]);PutByte('.');PutHTOA(addr[1]);PutByte('.');PutHTOA(addr[2]);PutByte('.');PutHTOA(addr[3]);PutStringLn("");
#endif  
		size = UDPHeader.u.header.size - 8;
		rd_ptr.lVal += 8;		
		recv_ptr = (u_char *)(RBUFBASEADDRESS[s] + (UINT)(rd_ptr.lVal & RMASK[s]));
		ret = read_data(s, recv_ptr, buf,size);
		rd_ptr.lVal += ret;
#ifdef DEBUG
{
 		int i;	
//		printf("%.8lx : %.8lx : %.8lx\r\n", recv_ptr, buf, rd_ptr.lVal);
//		for (i = 0; i < ret; i++) printf("%c", buf[i]);
		PutLTOA((u_long)(recv_ptr)); PutString(" : ");PutLTOA((u_long)buf); PutString(" : ");PutLTOA(rd_ptr.lVal); PutStringLn("");
		for (i = 0; i < ret; i++) PutByte(buf[i]);
		PutStringLn("");
}
#endif
	}
#ifdef __IP_RAW__	
	else if ((k & 0x07) == SOCK_IPL_RAW)						// When received IP layer RAW mode data
	{
		read_data(s,recv_ptr,UDPHeader.u.stream,6);				// IP layer header copy
		addr[0] = UDPHeader.u.header.addr[0];
		addr[1] = UDPHeader.u.header.addr[1];
		addr[2] = UDPHeader.u.header.addr[2];
		addr[3] = UDPHeader.u.header.addr[3];
#ifdef DEBUG
//		printf("ICMP msg received\r\n");
		PutStringLn("ICMP msg received");
		PutString("IP RAW Packet Data Size = ");PutITOA(UDPHeader.u.header.size);PutStringLn("");
		PutString("Destination IP : ");PutHTOA(addr[0]);PutByte('.');PutHTOA(addr[1]);PutByte('.');PutHTOA(addr[2]);PutByte('.');PutHTOA(addr[3]);PutStringLn("");