Subversion Repositories or1k

/* tcp.c -- Definition of functions for peripheral to 
 * communicate with host via a tcp socket.
 
   Copyright (C) 2002 Richard Prescott <rip@step.polymtl.ca>
 
This file is part of OpenRISC 1000 Architectural Simulator.
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
 
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
#include "channel.h"
#include "generic.h"
#include "fd.h"
 
struct tcp_channel
{
	struct fd_channel fds;
	int socket_fd;				/* Socket to listen to */
	int port_number;			/* TCP port number */
	int connected;				/* If 0, no remote endpoint yet */
	int nonblocking;			/* If 0, read/write will block until 
								   remote client connects */
};
 
static void * tcp_init(const char * input)
{
	int port_number, fd, flags;
	struct sockaddr_in local_ip;
	struct tcp_channel* channel = (struct tcp_channel*)malloc(sizeof(struct tcp_channel));
	if (!channel)
		return NULL;
 
	fd = 0;
	channel->nonblocking = 1;
	channel->fds.fdin = -1;
	channel->fds.fdout = -1;
	channel->socket_fd = -1;
	channel->port_number = -1;
 
	port_number = atoi(input);
	if (port_number == 0)
		goto error;
 
	fd = socket(AF_INET, SOCK_STREAM, 0);
	if (fd < 0)
		goto error;
 
	flags = 1;
	if(setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,(const char*)&flags,sizeof(int)) < 0)
    {
		perror("Can not set SO_REUSEADDR option on channel socket");
		goto error;
	}
 
	memset(&local_ip, 0, sizeof(local_ip));
	local_ip.sin_family = AF_INET;
	local_ip.sin_addr.s_addr = htonl(INADDR_ANY);
	local_ip.sin_port = htons(port_number);
	if (bind(fd, (struct sockaddr*)&local_ip, sizeof(local_ip)) < 0) {
		perror("Can't bind local address");
		goto error;
	}
 
	if (channel->nonblocking) {
		if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0)
		{
			perror("Can not make channel socket non-blocking");
			goto error;
		}
	}
 
	if (listen(fd, 1) < 0)
		goto error;
 
	channel->socket_fd = fd;
	channel->port_number = port_number;
	channel->connected = 0;
	return (void*)channel;
 
error:
	if (fd)
		close(fd);
	free(channel);
	return NULL;
}
 
static int tcp_open(void * data)
{
	/* Socket is opened lazily, upon first read or write, so do nothing here */
	return 0;
}
 
 
static int wait_for_tcp_connect(struct tcp_channel* channel)
{		
	int fd, sizeof_remote_ip;
	struct sockaddr_in remote_ip;
 
	sizeof_remote_ip = sizeof(remote_ip);
	fd = accept(channel->socket_fd, (struct sockaddr*)&remote_ip, &sizeof_remote_ip);
	if (fd < 0) {
		if (channel->nonblocking) {
			/* Not an error if there is not yet a remote connection - try again later */
			if (errno == EAGAIN)
				return 0;
		}
		perror("Couldn't accept connection");
		return -1;
	}
 
	channel->fds.fdin = channel->fds.fdout = fd;
	close(channel->socket_fd);
	channel->socket_fd = -1;
    channel->connected = 1;
	return 1;
}
 
static int tcp_read(void * data, char * buffer, int size)
{
	struct tcp_channel* channel = data;
 
	/* Lazily connect to tcp partner on read/write */
	if (!channel->connected) {
		int retval = wait_for_tcp_connect(data);
		if (retval <= 0)
			return retval;
	}
	return fd_read(data, buffer, size);
}
 
static int tcp_write(void * data, const char * buffer, int size)
{
	struct tcp_channel* channel = data;
 
	/* Lazily connect to tcp partner on read/write */
	if (!channel->connected) {
		int retval = wait_for_tcp_connect(data);
		if (retval < 0)
			return retval;
	}
	return fd_write(data, buffer, size);
}
 
struct channel_ops tcp_channel_ops =
{
	init:	tcp_init,
	open:	tcp_open,
	close:	generic_close,
	read:	tcp_read,
	write:	tcp_write,
	free:	generic_free,
};
 
/*
 * Local variables:
 * c-file-style: "linux"
 * End:
 */