netsock.c

基于东南大学开发的SEP3203的ARM7中的所有驱动

/* netsock.c - BSD Socket IO API
 * $Id: netsock.c,v 1.1.1.1 2004/12/22 10:02:10 zyu Exp $
 * Copyright (C)2002 Jiang Wei.
 */

#include "netconf.h"
#include <string.h>
#include "net.h"
#include "netbuf.h"
#include "nettimer.h"
#include "netppp.h"
//#include "netfsm.h"
#include "netchap.h"
#include "netmagic.h"
#include "netauth.h"
#include "netlcp.h"

#include <stdio.h>
#include "netdebug.h"
#if TRACELCP > 0
#include <string.h>
#endif

#include "netudp.h"
#include "nettcp.h"
#include "netsock.h"


#define MAXTCP 6            /* Maximum TCP connections incl listeners. */
#define MAXUDP          4

typedef struct {
	int domain;	/* shall be AF_INET */
	int type;		/* shall be SOCK_STREAM for TCP, or SOCK_DGRAM for UDP */
	int protocol;	/* shall be 0 for normal operations */
	int index;		/* shall be index for PCB block */
	void *pcb;	/* pointer to udp/tcp PCB */
} SOCKET;

SOCKET sockets[MAXSOCK];	/* max supported socket number */


extern TCPCB tcbs[MAXTCP];
extern UDPCB udps[MAXUDP];


void sockInit(void)
{
	/*int i = 0;*/
	memset(&sockets, 0, sizeof(SOCKET ) * MAXSOCK);
}

int	socket (int domain, int type, int protocol)
{
	int i, j;
	
	switch (domain) {
	case AF_INET:
		OS_ENTER_CRITICAL();
		for (i = 0; i < MAXSOCK; ++i)
			if (sockets[i].domain == AF_UNSPEC) break;
		OS_EXIT_CRITICAL();
		if (i == MAXSOCK) return -1;
			switch (type) {
		case SOCK_STREAM:
			j = tcpOpen();
			if (j < 0) return j;
			sockets[i].index = j;
			sockets[i].pcb = &tcbs[j];
			break;
		case SOCK_DGRAM:
			j = udpOpen();
			if (j < 0) return j;
			sockets[i].index = j;
			sockets[i].pcb = &udps[j];
			break;
		default:
			return -1;
			break;
		}
		break;
	default:
		return -1;
		break;
	};

	if (i < 0) return i;
	sockets[i].domain = domain;
	sockets[i].type = type;
	sockets[i].protocol = protocol;
	return i;
	
}

int close(int sockfd)
{
	int i;
	
	if (sockfd < 0 || sockfd > MAXSOCK) return -1;
	switch (sockets[sockfd].domain) {
	case AF_INET:
		switch (sockets[sockfd].type) {
		case SOCK_STREAM:
			i = tcpClose(sockets[sockfd].index);
			break;
		case SOCK_DGRAM:
			i = udpClose(sockets[sockfd].index);
			break;
		default:
			return -1;
			break;
		}
		break;
	default:
		return -1;
		break;
	}
	
	OS_ENTER_CRITICAL();
	sockets[sockfd].domain = AF_UNSPEC;
	OS_EXIT_CRITICAL();

	return i;
}

int	connect (int sockfd, const struct sockaddr *serv_addr, socklen_t addrlen)
{
	int i;

	if (sockfd < 0 || sockfd > MAXSOCK) return -1;

	switch (sockets[sockfd].domain) {
	case AF_INET:
		switch (sockets[sockfd].type) {
		case SOCK_STREAM:
			i = tcpConnect(sockets[sockfd].index, (struct sockaddr_in *)serv_addr, 0);
			break;
		case SOCK_DGRAM:
			i = udpConnect(sockets[sockfd].index, (struct sockaddr_in *)serv_addr, 0);
			break;
		default:
			return -1;
			break;
		}
		break;
	default:
		return -1;
		break;
	}

	return i;
}

ssize_t	recv (int s, void *buf, size_t len, int flags)
{
	int i;

	if (s < 0 || s > MAXSOCK) return -1;

	switch (sockets[s].domain) {
	case AF_INET:
		switch (sockets[s].type) {
		case SOCK_STREAM:
			i = tcpRead(sockets[s].index, buf, len);
			break;
		case SOCK_DGRAM:
			i = udpRead(sockets[s].index, buf, len);
			break;
		default:
			return -1;
			break;
		}
		break;
	default:
		return -1;
		break;
	}

	return i;
}

ssize_t	recvfrom (int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
{
	long l;
	
	if (s < 0 || s > MAXSOCK) return -1;

	switch (sockets[s].domain) {
	case AF_INET:
		switch (sockets[s].type) {
		case SOCK_DGRAM:
			l = udpRecvFrom(sockets[s].index, buf, len, (struct sockaddr_in *)from);
			break;
		default:
			return -1;
			break;
		}
		break;
	default:
		return -1;
		break;
	}

	return l;
}

ssize_t	send (int s, const void *msg, size_t len, int flags)
{
	int i;

	if (s < 0 || s > MAXSOCK) return -1;

	switch (sockets[s].domain) {
	case AF_INET:
		switch (sockets[s].type) {
		case SOCK_STREAM:
			i = tcpWrite(sockets[s].index, msg, len);
			break;
		case SOCK_DGRAM:
			i = udpWrite(sockets[s].index, msg, len);
			break;
		default:
			return -1;
			break;
		}
		break;
	default:
		return -1;
		break;
	}

	return i;
}

 ssize_t	sendto (int s, const void *msg, size_t len, int flags, const struct sockaddr * to, socklen_t tolen)
{
	long l;
	
	if (s < 0 || s > MAXSOCK) return -1;

	switch (sockets[s].domain) {
	case AF_INET:
		switch (sockets[s].type) {
		case SOCK_DGRAM:
			l = udpSendTo(sockets[s].index, msg, len,(struct sockaddr_in *) to);
			break;
		default:
			return -1;
			break;
		}
		break;
	default:
		return -1;
		break;
	}

	return l;
}

int	setsockopt (int s, int level, int optname, const void *optval, socklen_t optlen)
{
       return -1;
}

int	getpeername (int s, struct sockaddr *name, socklen_t *namelen)
{
       return -1;
}

int	getsockname (int s, struct sockaddr *name, socklen_t *namelen)
{
	return -1;
}

int	getsockopt (int s, int level, int optname, void *optval, socklen_t *optlen)
{
	return -1;
}

int	listen (int s, int backlog)
{
	int i;
	
	if (s < 0 || s > MAXSOCK) return -1;

	switch (sockets[s].domain) {
	case AF_INET:
		switch (sockets[s].type) {
		case SOCK_STREAM:
			i = tcpListen(sockets[s].index, backlog);
			break;
		default:
			return -1;
			break;
		}
		break;
	default:
		return -1;
		break;
	}

	return i;
}

int	accept(int s, struct sockaddr *addr, socklen_t *addrlen)
{
	return -1;
}

int	bind (int s, const struct sockaddr *my_addr, socklen_t addrlen)
{
	int i;
	
	if (s < 0 || s > MAXSOCK) return -1;

	switch (sockets[s].domain) {
	case AF_INET:
		switch (sockets[s].type) {
		case SOCK_STREAM:
			i = tcpBind(sockets[s].index,(struct sockaddr_in *) my_addr);
			break;
		default:
			return -1;
			break;
		}
		break;
	default:
		return -1;
		break;
	}

	return i;
}