tarina

aseqnet.c (13284B)

---

 /*
  * network server/client for ALSA sequencer
  *   ver.0.1
  *
  * Copyright (C) 1999-2000 Takashi Iwai
  * 
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2 as
  *  published by the Free Software Foundation.
  * 
  *  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.
  *
  */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <ctype.h>
 #include <string.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <netdb.h>
 #include <locale.h>
 #include <alsa/asoundlib.h>
 #include <getopt.h>
 #include <signal.h>
 #include <assert.h>
 #include "aconfig.h"
 #include "gettext.h"
 
 /*
  * prototypes
  */
 static void usage(void);
 static void init_buf(void);
 static void init_pollfds(void);
 static void close_files(void);
 static void init_seq(char *source, char *dest);
 static int get_port(char *service);
 static void sigterm_exit(int sig);
 static void init_server(int port);
 static void init_client(char *server, int port);
 static void do_loop(void);
 static int copy_local_to_remote(void);
 static int copy_remote_to_local(int fd);
 
 /*
  * default TCP port number
  */
 #define DEFAULT_PORT	40002
 
 /*
  * local input buffer
  */
 static char *readbuf;
 static int max_rdlen;
 static char *writebuf;
 static int cur_wrlen, max_wrlen;
 
 #define MAX_BUF_EVENTS	200
 #define MAX_CONNECTION	10
 
 static snd_seq_t *handle;
 static struct pollfd *seqifds = NULL;
 static struct pollfd *seqofds = NULL;
 static struct pollfd *pollfds = NULL;
 static int seqifds_count = 0;
 static int seqofds_count = 0;
 static int pollfds_count = 0;
 static int sockfd, netfd[MAX_CONNECTION] = {[0 ... MAX_CONNECTION-1] = -1};
 static int max_connection;
 static int cur_connected;
 static int seq_port;
 
 static int server_mode;
 static int verbose = 0;
 static int info = 0;
 
 
 /*
  * main routine
  */
 
 static const struct option long_option[] = {
 	{"port", 1, NULL, 'p'},
 	{"source", 1, NULL, 's'},
 	{"dest", 1, NULL, 'd'},
 	{"help", 0, NULL, 'h'},
 	{"verbose", 0, NULL, 'v'},
 	{"info", 0, NULL, 'i'},
 	{NULL, 0, NULL, 0},
 };
 
 int main(int argc, char **argv)
 {
 	int c;
 	int port = DEFAULT_PORT;
 	char *source = NULL, *dest = NULL;
 
 #ifdef ENABLE_NLS
 	setlocale(LC_ALL, "");
 	textdomain(PACKAGE);
 #endif
 
 	while ((c = getopt_long(argc, argv, "p:s:d:vi", long_option, NULL)) != -1) {
 		switch (c) {
 		case 'p':
 			if (isdigit(*optarg))
 				port = atoi(optarg);
 			else
 				port = get_port(optarg);
 			break;
 		case 's':
 			source = optarg;
 			break;
 		case 'd':
 			dest = optarg;
 			break;
 		case 'v':
 			verbose++;
 			break;
 		case 'i':
 			info++;
 			break;
 		default:
 			usage();
 			exit(1);
 		}
 	}
 
 	signal(SIGINT, sigterm_exit);
 	signal(SIGTERM, sigterm_exit);
 
 	init_buf();
 	init_seq(source, dest);
 
 	if (optind >= argc) {
 		server_mode = 1;
 		max_connection = MAX_CONNECTION;
 		init_pollfds();
 		init_server(port);
 	} else {
 		server_mode = 0;
 		max_connection = 1;
 		init_pollfds();
 		init_client(argv[optind], port);
 	}
 
 	do_loop();
 
 	close_files();
 
 	return 0;
 }
 
 
 /*
  * print usage
  */
 static void usage(void)
 {
 	printf(_("aseqnet - network client/server on ALSA sequencer\n"));
 	printf(_("  Copyright (C) 1999 Takashi Iwai\n"));
 	printf(_("usage:\n"));
 	printf(_("  server mode: aseqnet [-options]\n"));
 	printf(_("  client mode: aseqnet [-options] server_host\n"));
 	printf(_("options:\n"));
 	printf(_("  -p,--port # : specify TCP port (digit or service name)\n"));
 	printf(_("  -s,--source addr : read from given addr (client:port)\n"));
 	printf(_("  -d,--dest addr : write to given addr (client:port)\n"));
 	printf(_("  -v, --verbose : print verbose messages\n"));
 	printf(_("  -i, --info : print certain received events\n"));
 }
 
 
 /*
  * allocate and initialize buffers
  */
 static void init_buf(void)
 {
 	max_wrlen = MAX_BUF_EVENTS * sizeof(snd_seq_event_t);
 	max_rdlen = MAX_BUF_EVENTS * sizeof(snd_seq_event_t);
 	writebuf = malloc(max_wrlen);
 	readbuf = malloc(max_rdlen);
 	if (writebuf == NULL || readbuf == NULL) {
 		fprintf(stderr, _("can't malloc\n"));
 		exit(1);
 	}
 	memset(writebuf, 0, max_wrlen);
 	memset(readbuf, 0, max_rdlen);
 	cur_wrlen = 0;
 }
 
 /*
  * allocate and initialize poll array
  */
 static void init_pollfds(void)
 {
 	pollfds_count = seqifds_count + seqofds_count + 1 + max_connection;
 	pollfds = (struct pollfd *)calloc(pollfds_count, sizeof(struct pollfd));
 	assert(pollfds);
 }
 
 /*
  * close all files
  */
 static void close_files(void)
 {
 	int i;
 	if (verbose)
 		fprintf(stderr, _("closing files..\n"));
 	for (i = 0; i < max_connection; i++) {
 		if (netfd[i] >= 0)
 			close(netfd[i]);
 	}
 	if (sockfd >= 0)
 		close(sockfd);
 }
 
 
 /*
  * initialize sequencer
  */
 static void init_seq(char *source, char *dest)
 {
 	snd_seq_addr_t addr;
 	int err, counti, counto;
 
 	if (snd_seq_open(&handle, "default", SND_SEQ_OPEN_DUPLEX, 0) < 0) {
 		perror("snd_seq_open");
 		exit(1);
 	}
 	if (seqifds)
 		free(seqifds);
 	if (seqofds)
 		free(seqofds);
 	counti = seqifds_count = snd_seq_poll_descriptors_count(handle, POLLIN);
 	assert(counti > 0);
 	counto = seqofds_count = snd_seq_poll_descriptors_count(handle, POLLOUT);
 	assert(counto > 0);
 	seqifds = (struct pollfd *)calloc(counti, sizeof(struct pollfd));
 	assert(seqifds);
 	seqofds = (struct pollfd *)calloc(counto, sizeof(struct pollfd));
 	assert(seqofds);
 	err = snd_seq_poll_descriptors(handle, seqifds, counti, POLLIN);
 	assert(err == counti);
 	err = snd_seq_poll_descriptors(handle, seqofds, counto, POLLOUT);
 	assert(err == counto);
 
 	snd_seq_nonblock(handle, 1);
 
 	/* set client info */
 	if (server_mode)
 		snd_seq_set_client_name(handle, "Net Server");
 	else
 		snd_seq_set_client_name(handle, "Net Client");
 
 	/* create a port */
 	seq_port = snd_seq_create_simple_port(handle, "Network",
 					      SND_SEQ_PORT_CAP_READ |
 					      SND_SEQ_PORT_CAP_WRITE |
 					      SND_SEQ_PORT_CAP_SUBS_READ |
 					      SND_SEQ_PORT_CAP_SUBS_WRITE,
 					      SND_SEQ_PORT_TYPE_MIDI_GENERIC);
 	if (seq_port < 0) {
 		perror("create seq port");
 		exit(1);
 	}
 	if (verbose)
 		fprintf(stderr, _("sequencer opened: %d:%d\n"),
 			snd_seq_client_id(handle), seq_port);
 
 	/* explicit subscriptions */
 	if (source) {
 		/* read subscription */
 		if (snd_seq_parse_address(handle, &addr, source) < 0) {
 			fprintf(stderr, _("invalid source address %s\n"), source);
 			exit(1);
 		}
 		if (snd_seq_connect_from(handle, seq_port, addr.client, addr.port)) {
 			perror("read subscription");
 			exit(1);
 		}
 	}
 	if (dest) {
 		/* write subscription */
 		if (snd_seq_parse_address(handle, &addr, dest) < 0) {
 			fprintf(stderr, _("invalid destination address %s\n"), dest);
 			exit(1);
 		}
 		if (snd_seq_connect_to(handle, seq_port, addr.client, addr.port)) {
 			perror("write subscription");
 			exit(1);
 		}
 	}
 }
 
 
 /*
  * convert from string to TCP port number
  */
 static int get_port(char *service)
 {
 	struct servent *sp;
 
 	if ((sp = getservbyname(service, "tcp")) == NULL){
 		fprintf(stderr, _("service '%s' is not found in /etc/services\n"), service);
 		return -1;
 	}
 	return sp->s_port;
 }
 
 /*
  * signal handler
  */
 static void sigterm_exit(int sig)
 {
 	close_files();
 	exit(1);
 }
 
 
 /*
  * initialize network server
  */
 static void init_server(int port)
 {
 	int i;
 	int curstate = 1;
 	struct sockaddr_in addr;
 
 	memset(&addr, 0, sizeof(addr));
 
 	addr.sin_family = AF_INET;
 	addr.sin_addr.s_addr = INADDR_ANY;
 	addr.sin_port = htons(port);
 
 	sockfd = socket(AF_INET, SOCK_STREAM, 0);
 	if (sockfd < 0)  {
 		perror("create socket");
 		exit(1);
 	}
 	setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &curstate, sizeof(curstate));
 	/* the return value is ignored.. */
 
 	if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0)  {
 		perror("can't bind");
 		exit(1);
 	}
 
 	if (listen(sockfd, 5) < 0)  {
 		perror("can't listen");
 		exit(1);
 	}
 
 	cur_connected = 0;
 	for (i = 0; i < max_connection; i++)
 		netfd[i] = -1;
 }
 
 /*
  * start connection on server
  */
 static void start_connection(void)
 {
 	struct sockaddr_in addr;
 	int i;
 	socklen_t addr_len;
 
 	for (i = 0; i < max_connection; i++) {
 		if (netfd[i] < 0)
 			break;
 	}
 	if (i >= max_connection) {
 		fprintf(stderr, _("too many connections!\n"));
 		exit(1);
 	}
 	memset(&addr, 0, sizeof(addr));
 	addr_len = sizeof(addr);
 	netfd[i] = accept(sockfd, (struct sockaddr *)&addr, &addr_len);
 	if (netfd[i] < 0) {
 		perror("accept");
 		exit(1);
 	}
 	if (verbose)
 		fprintf(stderr, _("accepted[%d]\n"), netfd[i]);
 	cur_connected++;
 }
 
 /*
  * initialize network client
  */
 static void init_client(char *server, int port)
 {
 	struct sockaddr_in addr;
 	struct hostent *host;
 	int curstate = 1;
 	int fd;
 
 	if ((fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0){
 		perror("create socket");
 		exit(1);
 	}
 	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &curstate, sizeof(curstate)) < 0) {
 		perror("setsockopt");
 		exit(1);
 	}
 	if ((host = gethostbyname(server)) == NULL){
 		fprintf(stderr, _("can't get address %s\n"), server);
 		exit(1);
 	}
 	addr.sin_port = htons(port);
 	addr.sin_family = AF_INET;
 	memcpy(&addr.sin_addr, host->h_addr, host->h_length);
 	if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
 		perror("connect");
 		exit(1);
 	}
 	if (verbose)
 		fprintf(stderr, _("ok.. connected\n"));
 	netfd[0] = fd;
 	cur_connected = 1;
 }
 
 /*
  * event loop
  */
 static void do_loop(void)
 {
 	int i, rc, width;
 	int seqifd_ptr, sockfd_ptr = -1, netfd_ptr;
 
 	for (;;) {
 		memset(pollfds, 0, pollfds_count * sizeof(struct pollfd));
 		seqifd_ptr = 0;
 		memcpy(pollfds, seqifds, sizeof(*seqifds)*(width = seqifds_count));
 		if (server_mode) {
 			sockfd_ptr = width;
 			pollfds[width].fd = sockfd;
 			pollfds[width].events = POLLIN;
 			width++;
 		}
 		netfd_ptr = width;
 		for (i = 0; i < max_connection; i++) {
 			if (netfd[i] >= 0) {
 				pollfds[width].fd = netfd[i];
 				pollfds[width].events = POLLIN;
 				width++;
 			}
 		}
 		do {
 			rc = poll(pollfds, width, -1);
 		} while (rc <= 0 && errno == EINTR);
 		if (rc <= 0) {
 			perror("poll");
 			exit(1);
 		}
 		if (server_mode) {
 			if (pollfds[sockfd_ptr].revents & (POLLIN|POLLOUT))
 				start_connection();
 		}
 		for (i = 0; i < seqifds_count; i++)
 			if (pollfds[seqifd_ptr + i].revents & (POLLIN|POLLOUT)) {
 				if (copy_local_to_remote())
 					return;
 				break;
 			}
 		for (i = 0; i < max_connection; i++) {
 			if (netfd[i] < 0)
 				continue;
 			if (pollfds[netfd_ptr + i].revents & (POLLIN|POLLOUT)) {
 				if (copy_remote_to_local(netfd[i])) {
 					netfd[i] = -1;
 					cur_connected--;
 					if (cur_connected <= 0)
 						return;
 				}
 			}
 		}
 	}
 }
 
 
 /*
  * flush write buffer - send data to the socket
  */
 static void flush_writebuf(void)
 {
 	if (cur_wrlen) {
 		int i;
 		for (i = 0; i < max_connection; i++) {
 			if (netfd[i] >= 0)
 				write(netfd[i], writebuf, cur_wrlen);
 		}
 		cur_wrlen = 0;
 	}
 }
 
 /*
  * get space from write buffer
  */
 static char *get_writebuf(int len)
 {
 	char *buf;
 	if (cur_wrlen + len >= max_wrlen)
 		flush_writebuf();
 	buf = writebuf + cur_wrlen;
 	cur_wrlen += len;
 	return buf;
 }
 
 static void print_event(snd_seq_event_t *ev)
 {
 	switch (ev->type) {
 	case SND_SEQ_EVENT_CONTROLLER: 
 		printf(_("Channel %2d: Control event : %5d\n"),
 			ev->data.control.channel, ev->data.control.value);
 		break;
 	case SND_SEQ_EVENT_PITCHBEND:
 		printf(_("Channel %2d: Pitchbender   : %5d\n"), 
 			ev->data.control.channel, ev->data.control.value);
 		break;
 	case SND_SEQ_EVENT_NOTEON:
 		printf(_("Channel %2d: Note On event : %5d\n"),
 			ev->data.control.channel, ev->data.note.note);
 		break;
 	case SND_SEQ_EVENT_NOTEOFF: 
 		printf(_("Channel %2d: Note Off event: %5d\n"),
 		       ev->data.control.channel, ev->data.note.note);           
 		break;
 	}
 }
 
 #define EVENT_PACKET_SIZE	32
 
 /*
  * copy events from sequencer to port(s)
  */
 static int copy_local_to_remote(void)
 {
 	int rc;
 	snd_seq_event_t *ev;
 	char *buf;
 
 	while ((rc = snd_seq_event_input(handle, &ev)) >= 0 && ev) {
 		if (ev->type >= SND_SEQ_EVENT_CLIENT_START &&
 		    ! snd_seq_ev_is_variable_type(ev)) {
 			snd_seq_free_event(ev);
 			continue;
 		}
 		if (snd_seq_ev_is_variable(ev)) {
 			int len;
 			len = EVENT_PACKET_SIZE + ev->data.ext.len;
 			buf = get_writebuf(len);
 			memcpy(buf, ev, sizeof(snd_seq_event_t));
 			memcpy(buf + EVENT_PACKET_SIZE, ev->data.ext.ptr, ev->data.ext.len);
 		} else {
 			buf = get_writebuf(EVENT_PACKET_SIZE);
 			memcpy(buf, ev, EVENT_PACKET_SIZE);
 		}
 		if (info)
 			print_event(ev);
 		snd_seq_free_event(ev);
 	}
 	flush_writebuf();
 	return 0;
 }
 
 /*
  * copy events from a port to sequencer
  */
 static int copy_remote_to_local(int fd)
 {
 	int count;
 	char *buf;
 	snd_seq_event_t *ev;
 
 	count = read(fd, readbuf, MAX_BUF_EVENTS * sizeof(snd_seq_event_t));
 	buf = readbuf;
 
 	if (count == 0) {
 		if (verbose)
 			fprintf(stderr, _("disconnected\n"));
 		return 1;
 	}
 
 	while (count > 0) {
 		ev = (snd_seq_event_t*)buf;
 		buf += EVENT_PACKET_SIZE;
 		count -= EVENT_PACKET_SIZE;
 		if (snd_seq_ev_is_variable(ev) && ev->data.ext.len > 0) {
 			ev->data.ext.ptr = buf;
 			buf += ev->data.ext.len;
 			count -= ev->data.ext.len;
 		}
 		snd_seq_ev_set_direct(ev);
 		snd_seq_ev_set_source(ev, seq_port);
 		snd_seq_ev_set_subs(ev);
 		if (info)
 			print_event(ev);
 		snd_seq_event_output(handle, ev);
 	}
 
 	snd_seq_drain_output(handle);
 	return 0;
 }