[deliverable/linux.git] / arch / um / drivers / slip_user.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stddef.h>
#include <sched.h>
#include <string.h>
#include <errno.h>
#include <sys/termios.h>
#include <sys/wait.h>
#include <sys/signal.h>
#include "kern_util.h"
#include "user.h"
#include "net_user.h"
#include "slip.h"
#include "slip_common.h"
#include "os.h"
#include "um_malloc.h"

static int slip_user_init(void *data, void *dev)
{
	struct slip_data *pri = data;

	pri->dev = dev;
	return 0;
}

static int set_up_tty(int fd)
{
	int i;
	struct termios tios;

	if (tcgetattr(fd, &tios) < 0) {
		printk("could not get initial terminal attributes\n");
		return(-1);
	}

	tios.c_cflag = CS8 | CREAD | HUPCL | CLOCAL;
	tios.c_iflag = IGNBRK | IGNPAR;
	tios.c_oflag = 0;
	tios.c_lflag = 0;
	for (i = 0; i < NCCS; i++)
		tios.c_cc[i] = 0;
	tios.c_cc[VMIN] = 1;
	tios.c_cc[VTIME] = 0;

	cfsetospeed(&tios, B38400);
	cfsetispeed(&tios, B38400);

	if (tcsetattr(fd, TCSAFLUSH, &tios) < 0) {
		printk("failed to set terminal attributes\n");
		return(-1);
	}
	return(0);
}

struct slip_pre_exec_data {
	int stdin;
	int stdout;
	int close_me;
};

static void slip_pre_exec(void *arg)
{
	struct slip_pre_exec_data *data = arg;

	if(data->stdin >= 0) dup2(data->stdin, 0);
	dup2(data->stdout, 1);
	if(data->close_me >= 0) os_close_file(data->close_me);
}

static int slip_tramp(char **argv, int fd)
{
	struct slip_pre_exec_data pe_data;
	char *output;
	int status, pid, fds[2], err, output_len;

	err = os_pipe(fds, 1, 0);
	if(err < 0){
		printk("slip_tramp : pipe failed, err = %d\n", -err);
		goto out;
	}

	err = 0;
	pe_data.stdin = fd;
	pe_data.stdout = fds[1];
	pe_data.close_me = fds[0];
	err = run_helper(slip_pre_exec, &pe_data, argv, NULL);
	if(err < 0)
		goto out_close;
	pid = err;

	output_len = page_size();
	output = um_kmalloc(output_len);
	if(output == NULL){
		printk("slip_tramp : failed to allocate output buffer\n");
		os_kill_process(pid, 1);
		err = -ENOMEM;
		goto out_free;
	}

	os_close_file(fds[1]);
	read_output(fds[0], output, output_len);
	printk("%s", output);

	CATCH_EINTR(err = waitpid(pid, &status, 0));
	if(err < 0)
		err = errno;
	else if(!WIFEXITED(status) || (WEXITSTATUS(status) != 0)){
		printk("'%s' didn't exit with status 0\n", argv[0]);
		err = -EINVAL;
	}
	else err = 0;

	os_close_file(fds[0]);

out_free:
	kfree(output);
	return err;

out_close:
	os_close_file(fds[0]);
	os_close_file(fds[1]);
out:
	return err;
}

static int slip_open(void *data)
{
	struct slip_data *pri = data;
	char version_buf[sizeof("nnnnn\0")];
	char gate_buf[sizeof("nnn.nnn.nnn.nnn\0")];
	char *argv[] = { "uml_net", version_buf, "slip", "up", gate_buf, 
			 NULL };
	int sfd, mfd, err;

	err = get_pty();
	if(err < 0){
		printk("slip-open : Failed to open pty, err = %d\n", -err);
		goto out;
	}
	mfd = err;

	err = os_open_file(ptsname(mfd), of_rdwr(OPENFLAGS()), 0);
	if(err < 0){
		printk("Couldn't open tty for slip line, err = %d\n", -err);
		goto out_close;
	}
	sfd = err;

	if(set_up_tty(sfd))
		goto out_close2;

	pri->slave = sfd;
	pri->slip.pos = 0;
	pri->slip.esc = 0;
	if(pri->gate_addr != NULL){
		sprintf(version_buf, "%d", UML_NET_VERSION);
		strcpy(gate_buf, pri->gate_addr);

		err = slip_tramp(argv, sfd);

		if(err < 0){
			printk("slip_tramp failed - err = %d\n", -err);
			goto out_close2;
		}
		err = os_get_ifname(pri->slave, pri->name);
		if(err < 0){
			printk("get_ifname failed, err = %d\n", -err);
			goto out_close2;
		}
		iter_addresses(pri->dev, open_addr, pri->name);
	}
	else {
		err = os_set_slip(sfd);
		if(err < 0){
			printk("Failed to set slip discipline encapsulation - "
			       "err = %d\n", -err);
			goto out_close2;
		}
	}
	return(mfd);
out_close2:
	os_close_file(sfd);
out_close:
	os_close_file(mfd);
out:
	return err;
}

static void slip_close(int fd, void *data)
{
	struct slip_data *pri = data;
	char version_buf[sizeof("nnnnn\0")];
	char *argv[] = { "uml_net", version_buf, "slip", "down", pri->name, 
			 NULL };
	int err;

	if(pri->gate_addr != NULL)
		iter_addresses(pri->dev, close_addr, pri->name);

	sprintf(version_buf, "%d", UML_NET_VERSION);

	err = slip_tramp(argv, pri->slave);

	if(err != 0)
		printk("slip_tramp failed - errno = %d\n", -err);
	os_close_file(fd);
	os_close_file(pri->slave);
	pri->slave = -1;
}

int slip_user_read(int fd, void *buf, int len, struct slip_data *pri)
{
	return slip_proto_read(fd, buf, len, &pri->slip);
}

int slip_user_write(int fd, void *buf, int len, struct slip_data *pri)
{
	return slip_proto_write(fd, buf, len, &pri->slip);
}

static int slip_set_mtu(int mtu, void *data)
{
	return(mtu);
}

static void slip_add_addr(unsigned char *addr, unsigned char *netmask,
			  void *data)
{
	struct slip_data *pri = data;

	if(pri->slave < 0) return;
	open_addr(addr, netmask, pri->name);
}

static void slip_del_addr(unsigned char *addr, unsigned char *netmask,
			    void *data)
{
	struct slip_data *pri = data;

	if(pri->slave < 0) return;
	close_addr(addr, netmask, pri->name);
}

const struct net_user_info slip_user_info = {
	.init		= slip_user_init,
	.open		= slip_open,
	.close	 	= slip_close,
	.remove	 	= NULL,
	.set_mtu	= slip_set_mtu,
	.add_address	= slip_add_addr,
	.delete_address = slip_del_addr,
	.max_packet	= BUF_SIZE
};
Commit	Line	Data
1da177e4 LT	1	#include <stdio.h>
	2	#include <stdlib.h>
	3	#include <unistd.h>
	4	#include <stddef.h>
	5	#include <sched.h>
	6	#include <string.h>
	7	#include <errno.h>
	8	#include <sys/termios.h>
	9	#include <sys/wait.h>
	10	#include <sys/signal.h>
1da177e4 LT	11	#include "kern_util.h"
	12	#include "user.h"
	13	#include "net_user.h"
	14	#include "slip.h"
a3c77c67	15	#include "slip_common.h"
1da177e4	16	#include "os.h"
c13e5690	17	#include "um_malloc.h"
1da177e4	18
f34d9d2d	19	static int slip_user_init(void data, void dev)
1da177e4 LT	20	{
	21	struct slip_data *pri = data;
	22
	23	pri->dev = dev;
f34d9d2d	24	return 0;
1da177e4 LT	25	}
	26
	27	static int set_up_tty(int fd)
	28	{
	29	int i;
	30	struct termios tios;
	31
	32	if (tcgetattr(fd, &tios) < 0) {
	33	printk("could not get initial terminal attributes\n");
	34	return(-1);
	35	}
	36
	37	tios.c_cflag = CS8 \| CREAD \| HUPCL \| CLOCAL;
	38	tios.c_iflag = IGNBRK \| IGNPAR;
	39	tios.c_oflag = 0;
	40	tios.c_lflag = 0;
	41	for (i = 0; i < NCCS; i++)
	42	tios.c_cc[i] = 0;
	43	tios.c_cc[VMIN] = 1;
	44	tios.c_cc[VTIME] = 0;
	45
	46	cfsetospeed(&tios, B38400);
	47	cfsetispeed(&tios, B38400);
	48
	49	if (tcsetattr(fd, TCSAFLUSH, &tios) < 0) {
	50	printk("failed to set terminal attributes\n");
	51	return(-1);
	52	}
	53	return(0);
	54	}
	55
	56	struct slip_pre_exec_data {
	57	int stdin;
	58	int stdout;
	59	int close_me;
	60	};
	61
	62	static void slip_pre_exec(void *arg)
	63	{
	64	struct slip_pre_exec_data *data = arg;
	65
	66	if(data->stdin >= 0) dup2(data->stdin, 0);
	67	dup2(data->stdout, 1);
	68	if(data->close_me >= 0) os_close_file(data->close_me);
	69	}
	70
	71	static int slip_tramp(char **argv, int fd)
	72	{
	73	struct slip_pre_exec_data pe_data;
	74	char *output;
	75	int status, pid, fds[2], err, output_len;
	76
	77	err = os_pipe(fds, 1, 0);
	78	if(err < 0){
	79	printk("slip_tramp : pipe failed, err = %d\n", -err);
a3c77c67	80	goto out;
1da177e4 LT	81	}
	82
	83	err = 0;
	84	pe_data.stdin = fd;
	85	pe_data.stdout = fds[1];
	86	pe_data.close_me = fds[0];
a3c77c67 JD	87	err = run_helper(slip_pre_exec, &pe_data, argv, NULL);
	88	if(err < 0)
	89	goto out_close;
	90	pid = err;
	91
	92	output_len = page_size();
	93	output = um_kmalloc(output_len);
	94	if(output == NULL){
	95	printk("slip_tramp : failed to allocate output buffer\n");
	96	os_kill_process(pid, 1);
	97	err = -ENOMEM;
	98	goto out_free;
	99	}
1da177e4	100
a3c77c67 JD	101	os_close_file(fds[1]);
	102	read_output(fds[0], output, output_len);
	103	printk("%s", output);
	104
	105	CATCH_EINTR(err = waitpid(pid, &status, 0));
	106	if(err < 0)
	107	err = errno;
	108	else if(!WIFEXITED(status) \|\| (WEXITSTATUS(status) != 0)){
	109	printk("'%s' didn't exit with status 0\n", argv[0]);
	110	err = -EINVAL;
1da177e4	111	}
a3c77c67	112	else err = 0;
1da177e4 LT	113
	114	os_close_file(fds[0]);
	115
a3c77c67 JD	116	out_free:
	117	kfree(output);
	118	return err;
	119
	120	out_close:
	121	os_close_file(fds[0]);
	122	os_close_file(fds[1]);
	123	out:
	124	return err;
1da177e4 LT	125	}
	126
	127	static int slip_open(void *data)
	128	{
	129	struct slip_data *pri = data;
	130	char version_buf[sizeof("nnnnn\0")];
	131	char gate_buf[sizeof("nnn.nnn.nnn.nnn\0")];
	132	char *argv[] = { "uml_net", version_buf, "slip", "up", gate_buf,
	133	NULL };
	134	int sfd, mfd, err;
	135
a3c77c67 JD	136	err = get_pty();
	137	if(err < 0){
	138	printk("slip-open : Failed to open pty, err = %d\n", -err);
	139	goto out;
1da177e4	140	}
a3c77c67 JD	141	mfd = err;
	142
	143	err = os_open_file(ptsname(mfd), of_rdwr(OPENFLAGS()), 0);
	144	if(err < 0){
	145	printk("Couldn't open tty for slip line, err = %d\n", -err);
	146	goto out_close;
1da177e4	147	}
a3c77c67 JD	148	sfd = err;
	149
	150	if(set_up_tty(sfd))
	151	goto out_close2;
	152
1da177e4	153	pri->slave = sfd;
a3c77c67 JD	154	pri->slip.pos = 0;
a3c77c67 JD	155	pri->slip.esc = 0;
1da177e4 LT	156	if(pri->gate_addr != NULL){
	157	sprintf(version_buf, "%d", UML_NET_VERSION);
	158	strcpy(gate_buf, pri->gate_addr);
	159
	160	err = slip_tramp(argv, sfd);
	161
	162	if(err < 0){
	163	printk("slip_tramp failed - err = %d\n", -err);
a3c77c67	164	goto out_close2;
1da177e4 LT	165	}
	166	err = os_get_ifname(pri->slave, pri->name);
	167	if(err < 0){
	168	printk("get_ifname failed, err = %d\n", -err);
a3c77c67	169	goto out_close2;
1da177e4 LT	170	}
	171	iter_addresses(pri->dev, open_addr, pri->name);
	172	}
	173	else {
	174	err = os_set_slip(sfd);
	175	if(err < 0){
	176	printk("Failed to set slip discipline encapsulation - "
	177	"err = %d\n", -err);
a3c77c67	178	goto out_close2;
1da177e4 LT	179	}
	180	}
	181	return(mfd);
a3c77c67 JD	182	out_close2:
	183	os_close_file(sfd);
	184	out_close:
	185	os_close_file(mfd);
	186	out:
	187	return err;
1da177e4 LT	188	}
	189
	190	static void slip_close(int fd, void *data)
	191	{
	192	struct slip_data *pri = data;
	193	char version_buf[sizeof("nnnnn\0")];
	194	char *argv[] = { "uml_net", version_buf, "slip", "down", pri->name,
	195	NULL };
	196	int err;
	197
	198	if(pri->gate_addr != NULL)
	199	iter_addresses(pri->dev, close_addr, pri->name);
	200
	201	sprintf(version_buf, "%d", UML_NET_VERSION);
	202
	203	err = slip_tramp(argv, pri->slave);
	204
	205	if(err != 0)
	206	printk("slip_tramp failed - errno = %d\n", -err);
	207	os_close_file(fd);
	208	os_close_file(pri->slave);
	209	pri->slave = -1;
	210	}
	211
	212	int slip_user_read(int fd, void buf, int len, struct slip_data pri)
	213	{
a3c77c67	214	return slip_proto_read(fd, buf, len, &pri->slip);
1da177e4 LT	215	}
	216
	217	int slip_user_write(int fd, void buf, int len, struct slip_data pri)
	218	{
a3c77c67	219	return slip_proto_write(fd, buf, len, &pri->slip);
1da177e4 LT	220	}
	221
	222	static int slip_set_mtu(int mtu, void *data)
	223	{
	224	return(mtu);
	225	}
	226
	227	static void slip_add_addr(unsigned char addr, unsigned char netmask,
	228	void *data)
	229	{
	230	struct slip_data *pri = data;
	231
	232	if(pri->slave < 0) return;
	233	open_addr(addr, netmask, pri->name);
	234	}
	235
	236	static void slip_del_addr(unsigned char addr, unsigned char netmask,
	237	void *data)
	238	{
	239	struct slip_data *pri = data;
	240
	241	if(pri->slave < 0) return;
	242	close_addr(addr, netmask, pri->name);
	243	}
	244
5e7672ec	245	const struct net_user_info slip_user_info = {
1da177e4 LT	246	.init = slip_user_init,
	247	.open = slip_open,
	248	.close = slip_close,
	249	.remove = NULL,
	250	.set_mtu = slip_set_mtu,
	251	.add_address = slip_add_addr,
	252	.delete_address = slip_del_addr,
	253	.max_packet = BUF_SIZE
	254	};