vs_recv.c

/* 
 * A simple RUDP receiver to receive files from remote hosts.
 * It takes only one argument - local port to be used.
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <ctype.h>
#include <errno.h>
#include <syslog.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "rudp_api.h" 
#include "event.h" 
#include "vsftp.h"


/*
 * Data structure for keeping track of partially received files 
 */

struct rxfile {
	struct rxfile *next;		/* Next pointer for linked list */
	int fileopen;			/* True if file is open */
	int fd;				/* File descriptor */
	struct sockaddr_in remote;	/* Peer */
	char name[VS_FILENAMELENGTH+1]; /* Name of file */

};

/* 
 * Prototypes 
 */

int filesender(int fd, void *arg);
int rudp_receiver(rudp_socket_t rsocket, struct sockaddr_in *remote, char *buf, int len);
int eventhandler(rudp_socket_t rsocket, rudp_event_t event, struct sockaddr_in *remote);
int usage();

/* 
 * Global variables 
 */
int debug = 0;				/* Print debug messages */
struct rxfile *rxhead = NULL;		/* Pointer to linked list of rxfiles */

/* 
 * usage: how to use program
 */

int usage() {
	fprintf(stderr, "Usage: vs_recv [-d] port\n");
	exit(1);
}

int main(int argc, char* argv[]) 
{
	rudp_socket_t rsock;
	int port;

	int c;

	/* 
	 * Parse and collect arguments
	 */
	opterr = 0;

	while ((c = getopt(argc, argv, "d")) != -1) 
	{
		if (c == 'd') 
		{
			debug = 1;
		}
		else 
			usage();
	}
	if (argc - optind != 1) 
	{
		usage();
	}
	
	port = atoi(argv[optind]);
	if (port <= 0) 
	{
		fprintf(stderr, "Bad destination port: %s\n", argv[optind]);
		exit(1);
	}

	if (debug) 
	{
		printf("RUDP receiver waiting on port %i.\n",port);
	}

	/*
	 * Create RUDP listener socket
	 */

	if ((rsock = rudp_socket(port)) == NULL) 
	{
		fprintf(stderr,"vs_recv: rudp_socket() failed\n");
		exit(1);
	}

	/*
	 * Register receiver callback function
	 */

	rudp_recvfrom_handler(rsock, rudp_receiver);

	/*
	 * Register event handler callback function
	 */

	rudp_event_handler(rsock, eventhandler);

	/*
	 * Hand over control to event manager
	 */

	eventloop(0);

	return (0);
}

/*
 * rxfind: helper function to lookup a rxfile descriptor on the linked list.
 * Create new if not found
 */

static struct rxfile *rxfind(struct sockaddr_in *addr) 
{
	struct rxfile *rx;

	for (rx = rxhead; rx != NULL; rx = rx->next) 
	{
		if (memcmp(&rx->remote, addr, sizeof(struct in_addr)) == 0)
			return rx;
	}
	/* Not found, create new */
	if ((rx = malloc(sizeof(struct rxfile))) == NULL) 
	{
		fprintf(stderr, "vs_receiver: malloc failed\n");
		exit(1);
	}
	rx->fileopen = 0;
	rx->remote = *addr;
	rx->next = rxhead;
	rxhead = rx;
	return rx;
}

/*
 * rxdel: helper function to unlink and free a rxfile descriptor
 */

static int rxdel(struct rxfile *rx) 
{
	struct rxfile **rxp;

	for (rxp = &rxhead; *rxp != NULL && *rxp != rx; rxp = &(*rxp)->next)
		;
	if (*rxp == NULL) 
	{ /* Not found */
		fprintf(stderr, "vs_recv: Can't find rx record for peer\n");
		return -1;
	}
	*rxp = rx->next;
	free(rx);
	return 0;
}


/* 
 * eventhandler: callback function for RUDP events
 */

int eventhandler(rudp_socket_t rsocket, rudp_event_t event, struct sockaddr_in *remote) 
{
	struct rxfile *rx;

	switch (event) 
	{
	case RUDP_EVENT_TIMEOUT:
		if (remote) 
		{
			fprintf(stderr, "vs_recv: time out in communication with %s:%d\n",
				inet_ntoa(remote->sin_addr),
				ntohs(remote->sin_port));
			if ((rx = rxfind(remote))) 
			{
				if (rx->fileopen) 
				{
					close(rx->fd);
				}
				rxdel(rx);
			}
		}
		else 
		{
			fprintf(stderr, "vs_recv: time out\n");
		}
		break;
	case RUDP_EVENT_CLOSED:
		if (remote && (rx = rxfind(remote))) 
		{
			if (rx->fileopen) 
			{
				fprintf(stderr, "vs_recv: prematurely closed communication with %s:%d\n",
							inet_ntoa(remote->sin_addr),
							ntohs(remote->sin_port));
				close(rx->fd);
			}
			rxdel(rx);
		} /* else ignore */
                break;
	default:
		fprintf(stderr, "vs_recv: unknown event %d\n", event);
		break;
	}
	return 0;
}

/*
 * rudp_receiver: callback function for processing data received
 * on RUDP socket.
 */

int rudp_receiver(rudp_socket_t rsocket, struct sockaddr_in *remote, char *buf, int len) 
{
	struct rxfile *rx;
	int namelen;
	int i;

	printf("vs_recv: rudp_receiver\n");
	
	struct vsftp *vs = (struct vsftp *) buf;
	if (len < VS_MINLEN) 
	{
		fprintf(stderr, "vs_recv: Too short VSFTP packet (%d bytes)\n",
			len);
		return 0;
	}
	rx = rxfind(remote);
	switch (ntohl(vs->vs_type)) 
	{
	case VS_TYPE_BEGIN:
		namelen = len - sizeof(vs->vs_type);
		if (namelen > VS_FILENAMELENGTH)
			namelen = VS_FILENAMELENGTH;
		strncpy(rx->name, vs->vs_info.vs_filename, namelen);
		rx->name[namelen] = '\0'; /* Null terminated */

		/* Verify that file name is valid
		 * Only alpha-numerical, period, dash and
		 * underscore are allowed */
		for (i = 0; i < namelen; i++) 
		{
			char c = rx->name[i];
			if (!(isalnum(c) || c == '.' || c == '_' || c == '-')) 
			{
				fprintf(stderr, "vs_recv: Illegal file name \"%s\"\n", rx->name);
				rudp_close(rsocket);
				return 0;
			}
		}

		if (debug) 
		{
			fprintf(stderr, "vs_recv: BEGIN \"%s\" (%d bytes) from %s:%d\n", 
							rx->name, len,
							inet_ntoa(remote->sin_addr), ntohs(remote->sin_port));
		}
		if ((rx->fd = creat(rx->name, 0644)) < 0) 
		{
			perror("vs_recv: create");
			rudp_close(rsocket);
		}
		else 
		{
			rx->fileopen = 1;
		}
		break;
	case VS_TYPE_DATA:
		if (debug) 
		{
			fprintf(stderr, "vs_recv: DATA (%d bytes) from %s:%d\n", 
					len, 
					inet_ntoa(remote->sin_addr), ntohs(remote->sin_port));
		}
		len -= sizeof(vs->vs_type);
		/* len now is length of payload (data or file name) */
		if (rx->fileopen) 
		{
			if ((write(rx->fd, vs->vs_info.vs_filename, len)) < 0) 
			{
				perror("vs_recv: write");
			}
		}
		else 
		{
			fprintf(stderr, "vs_recv: DATA ignored (file not open)\n");
		}
		break;
	case VS_TYPE_END:
		if (debug) 
		{
			fprintf(stderr, "vs_recv: END (%d bytes) from %s:%d\n",
				len, inet_ntoa(remote->sin_addr), ntohs(remote->sin_port));
		}
		printf("vs_recv: received end of file \"%s\"\n", rx->name);
		if (rx->fileopen) 
		{
			close(rx->fd);
			rxdel(rx);
		}
		/* else ignore */
		break;
	default:
		fprintf(stderr, "vs_recv: bad vsftp type %d from %s:%d\n",
			vs->vs_type, inet_ntoa(remote->sin_addr), ntohs(remote->sin_port));
	}
	return 0;
}