socket.c

用MCS51 单片机的TCIP协议的测试,很基本的程序,对新手可能有帮助!

	rd_ptr.cVal[2] = *(RX_RD_PTR(s) + 2);
	rd_ptr.cVal[3] = *(RX_RD_PTR(s) + 3);
	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(len > RSIZE[s]) len = RSIZE[s];	      // 'len' value don't excced receive buffer size of w3100a
	if (size < len)                               // Wait while being able to receive as the size of received data                                                                           
	{
		wait_1ms(1);
#ifdef DEBUG
//		printf("size < len\r\n");
		PutStringLn("size < len");
#endif
		if ((OPT_PROTOCOL(s) & 0x07) == SOCK_DGRAM)
		goto R1_START;
	}

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

	if ((OPT_PROTOCOL(s) & 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  
		ret1 = ret = 0;        
		while(len > 0)									    // Received UDP Data is processed by bulk
		{
            size = UDPHeader.u.header.size-8;					    // Calculate data size of UDP Packet 
			rd_ptr.lVal += 8;                                                             // Increment read pointer by 8, because already read as UDP header size
			recv_ptr = (u_char *)(RBUFBASEADDRESS[s] + (UINT)(rd_ptr.lVal & RMASK[s])); // Calculate UDP data copy pointer

			ret1 = read_data(s, recv_ptr, buf+ret, size);                               // Concate one UDP data packet to user-specific buffer
			rd_ptr.lVal += ret1;							    // Increment read pointer by UDP packet data size
			ret += ret1;                                                                // Increment real received data size
			
			if((len -= (8+size)) > 0)  						    // Subtract user-specific receive size to UDPHeader size and UDP data size
			{
				recv_ptr = (u_char *)(RBUFBASEADDRESS[s] + (UINT)(rd_ptr.lVal & RMASK[s]));  
				read_data(s,recv_ptr,UDPHeader.u.stream,8);                         // Get Next UDP Header
//				if(UDPHeader.u.header.port != *port) break;			    // if next packet 'PORT' is differnt from previous packet, then exit to loop
				if((UDPHeader.u.header.port != *port) || (UDPHeader.u.header.port == DHCP_SERVER_PORT)) break;			    // if next packet 'PORT' is differnt from previous packet, then exit to loop
				if((*(u_long*)UDPHeader.u.header.addr) != (*(u_long*)addr)) break;  // if next packet 'IP address' is differnt from previous packet, then exit to loop
			}
			
		}

#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 ((OPT_PROTOCOL(s) & 0x07) == SOCK_IPL_RAW)                                  // When received IP layer RAW mode data
	{
//		for(i = 0; i < 4; i++) addr[i] = recv_ptr[2+i];                             // IP layer header copy
		read_data(s,recv_ptr,UDPHeader.u.stream,6);
		
		size = UDPHeader.u.stream[0];															// Read IP layer RAW Packet size
		size = (size << 8) + UDPHeader.u.stream[1];
		//kkk
		//PutString(" >> stream 0, 1 = ");PutHTOA(UDPHeader.u.stream[0]);PutByte(' ');PutHTOA(UDPHeader.u.stream[1]);PutStringLn("");
		//PutString(" size = ");PutITOA(size);PutStringLn("");
		
		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("");		
#endif
		rd_ptr.lVal += 6;                                                           // Increment read pointer by 6, because already read as IP RAW header size
		recv_ptr = (u_char *)(RBUFBASEADDRESS[s] + (UINT)(rd_ptr.lVal & RMASK[s])); // Calculate IP layer raw mode data pointer
		//kkk
		//ret = read_data(s, recv_ptr, buf, len-6);                                     // data copy.
		//rd_ptr.lVal += ret;
		ret = read_data(s, recv_ptr, buf, size);                                     // data copy.
		rd_ptr.lVal = rd_ptr.lVal + (ret - 4);
	} 
#endif	// end __IP_RAW__

	*RX_RD_PTR(s)       = rd_ptr.cVal[0];		// Update rx_rd_ptr
	*(RX_RD_PTR(s) + 1) = rd_ptr.cVal[1];
	*(RX_RD_PTR(s) + 2) = rd_ptr.cVal[2];
	*(RX_RD_PTR(s) + 3) = rd_ptr.cVal[3];

#ifdef DEBUG
	EX0 = 0;
	k = *SHADOW_RXWR_PTR(s);
	wait_1us(2);
	wr_ptr.cVal[0] = *RX_WR_PTR(s);
	wr_ptr.cVal[1] = *(RX_WR_PTR(s) + 1);
	wr_ptr.cVal[2] = *(RX_WR_PTR(s) + 2);
	wr_ptr.cVal[3] = *(RX_WR_PTR(s) + 3);

	k = *SHADOW_RXRD_PTR(s);
	wait_1us(2);
	rd_ptr.cVal[0] = *RX_RD_PTR(s);
	rd_ptr.cVal[1] = *(RX_RD_PTR(s) + 1);
	rd_ptr.cVal[2] = *(RX_RD_PTR(s) + 2);
	rd_ptr.cVal[3] = *(RX_RD_PTR(s) + 3);
	EX0 = 1;

//	printf("%.8lx : %.8lx\r\n", wr_ptr.lVal, rd_ptr.lVal);
	PutLTOA(wr_ptr.lVal); PutString(" : ");PutLTOA(rd_ptr.lVal); PutStringLn("");
#endif


	COMMAND(s) = CRECV;                                                                 // RECV

    return	(ret);	// Real received size return
}
#endif	// __UDP__

/*
********************************************************************************
*               Channel closing function.
*
* Description : Function for closing the connection of the designated channel.
* Arguments   : s - channel number
* Returns     : None
* Note        : API Function	       
********************************************************************************
*/
void close(SOCKET s)
{
	u_int len;

	if (select(s, SEL_CONTROL) == SOCK_CLOSED) return;	   // Already closed

	// When closing, if there's data which have not processed, Insert some source codes to handle this
	// Or before application call close(), handle those data first and call close() later.


	len = select(s, SEL_SEND);
	if (len == SSIZE[s])
	{
		I_STATUS[s] =0;
		COMMAND(s) = CCLOSE;                               // CLOSE
		while(!(I_STATUS[s] & SCLOSED));		   
	}
}

/*
********************************************************************************
*               Function handling the channel socket information.
*
* Description : Return socket information of designated channel
* Arguments   : s    - channel number
*               func - SEL_CONTROL(0x00) -> return socket status 
*                      SEL_SEND(0x01)    -> return free transmit buffer size
*                      SEL_RECV(0x02)    -> return received data size
* Returns     : socket status or free transmit buffer size or received data size
* Note        : API Function
********************************************************************************
*/
u_int select(SOCKET s, u_char func)
{
	u_int val;
	un_l2cval rd_ptr, wr_ptr, ack_ptr;
	u_char k;

	switch (func) {
	case SEL_CONTROL :                                     // socket status information
		val = SOCK_STATUS(s);
		break;

	case SEL_SEND :                                        // Calculate send free buffer size
		EX0 = 0;
		k = *SHADOW_TXWR_PTR(s);
		wait_1us(2);
		wr_ptr.cVal[0] = *TX_WR_PTR(s);
		wr_ptr.cVal[1] = *(TX_WR_PTR(s) + 1);
		wr_ptr.cVal[2] = *(TX_WR_PTR(s) + 2);
		wr_ptr.cVal[3] = *(TX_WR_PTR(s) + 3);

		k = *SHADOW_TXACK_PTR(s);
		wait_1us(2);
		ack_ptr.cVal[0] = *TX_ACK_PTR(s);
		ack_ptr.cVal[1] = *(TX_ACK_PTR(s) + 1);
		ack_ptr.cVal[2] = *(TX_ACK_PTR(s) + 2);
		ack_ptr.cVal[3] = *(TX_ACK_PTR(s) + 3);
		EX0 = 1;

		if (wr_ptr.lVal >= ack_ptr.lVal) val = SSIZE[s] - (wr_ptr.lVal - ack_ptr.lVal);
		else val = SSIZE[s] - (0 - ack_ptr.lVal + wr_ptr.lVal);
		break;
	case SEL_RECV :                                        // Calculate received data size
		EX0 = 0;
		k = *SHADOW_RXWR_PTR(s);
		wait_1us(2);
		wr_ptr.cVal[0] = *RX_WR_PTR(s);
		wr_ptr.cVal[1] = *(RX_WR_PTR(s) + 1);
		wr_ptr.cVal[2] = *(RX_WR_PTR(s) + 2);
		wr_ptr.cVal[3] = *(RX_WR_PTR(s) + 3);

		k = *SHADOW_RXRD_PTR(s);
		wait_1us(2);
		rd_ptr.cVal[0] = *RX_RD_PTR(s);
		rd_ptr.cVal[1] = *(RX_RD_PTR(s) + 1);
		rd_ptr.cVal[2] = *(RX_RD_PTR(s) + 2);
		rd_ptr.cVal[3] = *(RX_RD_PTR(s) + 3);
		EX0 = 1;

		if (wr_ptr.lVal == rd_ptr.lVal){ val = 0;}
		else if (wr_ptr.lVal > rd_ptr.lVal) val = wr_ptr.lVal - rd_ptr.lVal;
		else val = 0 - rd_ptr.lVal + wr_ptr.lVal;
#ifdef DEBUG
		PutString("wr_ptr.lVal = ");PutLTOA(wr_ptr.lVal);PutString(" : rd_ptr.lVal = ");PutLTOA(rd_ptr.lVal);PutString(" : size = ");PutITOA(val);PutStringLn("");
#endif		
		break;
	default :
		val = -1;
		break;
	}

    return	( val );
}

/*
********************************************************************************
*               Copies the receive buffer data of the W3100A to the system buffer.
*
* Description : Copies the receive buffer data of the W3100A to the system buffer.
*    It is called from the recv()or recvfrom() function.
* Arguments   : s   - channel number
*               src - receive buffer pointer of W3100A
*               dst - system buffer pointer
*               len - data size to copy
* Returns     : copied data size
* Note        : Internal Function
********************************************************************************
*/
/*
u_int read_data(SOCKET s, u_char xdata* src, u_char xdata* dst, u_int len)
{
	u_int i, size, size1;

	if (len == 0) return 0;

	if( (((u_int)src & RMASK[s]) + len)  > RSIZE[s] ) 
	{
		size = RSIZE[s] - ((u_int)src & RMASK[s]);
		for (i = 0; i < size; i++) *dst++ = *src++;
		size1 = len - size;
		src =  RBUFBASEADDRESS[s];
		for (i = 0; i < size1; i++) *dst++ = *src++;
	}
	else
        	for (i = 0; i < len; i++) *dst++ = *src++;
	return len;
}
*/

u_int read_data(SOCKET s, u_char xdata* src, u_char xdata* dst, u_int len)
{
	u_int size, size1;

	if (len == 0) return 0;

	if( (((u_int)src & RMASK[s]) + len)  > RSIZE[s] ) 
	{
		size = RSIZE[s] - ((u_int)src & RMASK[s]);
		memcpy(dst, src, size);
		
		size1 = len - size;
		src =  RBUFBASEADDRESS[s];
		dst += size;
		memcpy(dst, src, size1);
	}
	else {
		memcpy(dst, src, len);
    }
        
	return len;
}

/*
********************************************************************************
*               Copies the system buffer data to the transmit buffer of the W3100A.
*
* Description : Copies the system buffer data to the transmit buffer of the W3100A.
*               It is called from the send_in()or sendto_in() function.
* Arguments   : s   - channel number
*               src - system buffer pointer
*               dst - send buffer pointer of W3100A
*               len - data size to copy
* Returns     : copied data size
* Note        : Internal Function
********************************************************************************
*/
/*
u_int write_data(SOCKET s, u_char xdata* src, u_char xdata* dst, u_int len)
{
	u_int i, size, size1;

	if (len == 0) return 0;

	if ( (((u_int)dst & SMASK[s]) + len) > SSIZE[s] ) 
	{
		size = SSIZE[s] - ((UINT)dst & SMASK[s]);

		for (i = 0; i < size; i++) *dst++ = *src++;
		size1 = len - size;
		dst = (SBUFBASEADDRESS[s]);
		for (i = 0; i < size1; i++) *dst++ = *src++;
	} 
	else
		for (i = 0; i < len; i++) *dst++ = *src++;

	return len;
}
*/


u_int write_data(SOCKET s, u_char xdata* src, u_char xdata* dst, u_int len)
{
	u_int size, size1;

	if (len == 0) return 0;

	if ( (((u_int)dst & SMASK[s]) + len) > SSIZE[s] ) 
	{
		size = SSIZE[s] - ((UINT)dst & SMASK[s]);

		memcpy(dst, src, size);
		
		size1 = len - size;
		dst = (SBUFBASEADDRESS[s]);
		
		src += size;
		memcpy(dst, src, size1);
	} 
	else {
		memcpy(dst, src, len);
	}
	return len;
}


/*
********************************************************************************
*               Designate the delay
*
* Description : Wait for 10 milliseconds
* Arguments   : cnt - time to wait
* Returns     : None
* Note        : Internal Function
********************************************************************************
*/

void wait_10ms(int cnt)
{
	u_int i;

	for (i = 0; i < cnt; i++) wait_1ms(10);
}


/*
********************************************************************************
*               Designate the delay
*
* Description : Wait for 1 millisecond
* Arguments   : cnt - time to wait
* Returns     : None
* Note        : Internal Function
********************************************************************************
*/
void wait_1ms(int cnt)
{
	u_int i;

	for (i = 0; i < cnt; i++) wait_1us(1000);
}

/*
********************************************************************************
*               Designate the delay
*
* Description : Wait for 1 microsecond
* Arguments   : cnt - time to wait
* Returns     : None
* Note        : Internal Function, System Dependant            
********************************************************************************
*/
void wait_1us(int cnt)
{
	u_int i;

	for (i = 0; i < cnt; i++) ;
}