Pull bugzilla-5966 into release branch
[linux-2.6] / arch / um / drivers / daemon_user.c
1 /*
2  * Copyright (C) 2001 Lennert Buytenhek (buytenh@gnu.org) and 
3  * James Leu (jleu@mindspring.net).
4  * Copyright (C) 2001 by various other people who didn't put their name here.
5  * Licensed under the GPL.
6  */
7
8 #include <errno.h>
9 #include <unistd.h>
10 #include <stdint.h>
11 #include <sys/socket.h>
12 #include <sys/un.h>
13 #include <sys/time.h>
14 #include "net_user.h"
15 #include "daemon.h"
16 #include "kern_util.h"
17 #include "user_util.h"
18 #include "user.h"
19 #include "os.h"
20 #include "um_malloc.h"
21
22 #define MAX_PACKET (ETH_MAX_PACKET + ETH_HEADER_OTHER)
23
24 enum request_type { REQ_NEW_CONTROL };
25
26 #define SWITCH_MAGIC 0xfeedface
27
28 struct request_v3 {
29         uint32_t magic;
30         uint32_t version;
31         enum request_type type;
32         struct sockaddr_un sock;
33 };
34
35 static struct sockaddr_un *new_addr(void *name, int len)
36 {
37         struct sockaddr_un *sun;
38
39         sun = um_kmalloc(sizeof(struct sockaddr_un));
40         if(sun == NULL){
41                 printk("new_addr: allocation of sockaddr_un failed\n");
42                 return(NULL);
43         }
44         sun->sun_family = AF_UNIX;
45         memcpy(sun->sun_path, name, len);
46         return(sun);
47 }
48
49 static int connect_to_switch(struct daemon_data *pri)
50 {
51         struct sockaddr_un *ctl_addr = pri->ctl_addr;
52         struct sockaddr_un *local_addr = pri->local_addr;
53         struct sockaddr_un *sun;
54         struct request_v3 req;
55         int fd, n, err;
56
57         pri->control = socket(AF_UNIX, SOCK_STREAM, 0);
58         if(pri->control < 0){
59                 err = -errno;
60                 printk("daemon_open : control socket failed, errno = %d\n", 
61                        -err);
62                 return err;
63         }
64
65         if(connect(pri->control, (struct sockaddr *) ctl_addr, 
66                    sizeof(*ctl_addr)) < 0){
67                 err = -errno;
68                 printk("daemon_open : control connect failed, errno = %d\n",
69                        -err);
70                 goto out;
71         }
72
73         fd = socket(AF_UNIX, SOCK_DGRAM, 0);
74         if(fd < 0){
75                 err = -errno;
76                 printk("daemon_open : data socket failed, errno = %d\n",
77                        -err);
78                 goto out;
79         }
80         if(bind(fd, (struct sockaddr *) local_addr, sizeof(*local_addr)) < 0){
81                 err = -errno;
82                 printk("daemon_open : data bind failed, errno = %d\n",
83                        -err);
84                 goto out_close;
85         }
86
87         sun = um_kmalloc(sizeof(struct sockaddr_un));
88         if(sun == NULL){
89                 printk("new_addr: allocation of sockaddr_un failed\n");
90                 err = -ENOMEM;
91                 goto out_close;
92         }
93
94         req.magic = SWITCH_MAGIC;
95         req.version = SWITCH_VERSION;
96         req.type = REQ_NEW_CONTROL;
97         req.sock = *local_addr;
98         n = os_write_file(pri->control, &req, sizeof(req));
99         if(n != sizeof(req)){
100                 printk("daemon_open : control setup request failed, err = %d\n",
101                        -n);
102                 err = -ENOTCONN;
103                 goto out_free;
104         }
105
106         n = os_read_file(pri->control, sun, sizeof(*sun));
107         if(n != sizeof(*sun)){
108                 printk("daemon_open : read of data socket failed, err = %d\n",
109                        -n);
110                 err = -ENOTCONN;
111                 goto out_free;
112         }
113
114         pri->data_addr = sun;
115         return(fd);
116
117  out_free:
118         kfree(sun);
119  out_close:
120         os_close_file(fd);
121  out:
122         os_close_file(pri->control);
123         return(err);
124 }
125
126 static void daemon_user_init(void *data, void *dev)
127 {
128         struct daemon_data *pri = data;
129         struct timeval tv;
130         struct {
131                 char zero;
132                 int pid;
133                 int usecs;
134         } name;
135
136         if(!strcmp(pri->sock_type, "unix"))
137                 pri->ctl_addr = new_addr(pri->ctl_sock, 
138                                          strlen(pri->ctl_sock) + 1);
139         name.zero = 0;
140         name.pid = os_getpid();
141         gettimeofday(&tv, NULL);
142         name.usecs = tv.tv_usec;
143         pri->local_addr = new_addr(&name, sizeof(name));
144         pri->dev = dev;
145         pri->fd = connect_to_switch(pri);
146         if(pri->fd < 0){
147                 kfree(pri->local_addr);
148                 pri->local_addr = NULL;
149         }
150 }
151
152 static int daemon_open(void *data)
153 {
154         struct daemon_data *pri = data;
155         return(pri->fd);
156 }
157
158 static void daemon_remove(void *data)
159 {
160         struct daemon_data *pri = data;
161
162         os_close_file(pri->fd);
163         pri->fd = -1;
164         os_close_file(pri->control);
165         pri->control = -1;
166
167         kfree(pri->data_addr);
168         pri->data_addr = NULL;
169         kfree(pri->ctl_addr);
170         pri->ctl_addr = NULL;
171         kfree(pri->local_addr);
172         pri->local_addr = NULL;
173 }
174
175 int daemon_user_write(int fd, void *buf, int len, struct daemon_data *pri)
176 {
177         struct sockaddr_un *data_addr = pri->data_addr;
178
179         return(net_sendto(fd, buf, len, data_addr, sizeof(*data_addr)));
180 }
181
182 static int daemon_set_mtu(int mtu, void *data)
183 {
184         return(mtu);
185 }
186
187 const struct net_user_info daemon_user_info = {
188         .init           = daemon_user_init,
189         .open           = daemon_open,
190         .close          = NULL,
191         .remove         = daemon_remove,
192         .set_mtu        = daemon_set_mtu,
193         .add_address    = NULL,
194         .delete_address = NULL,
195         .max_packet     = MAX_PACKET - ETH_HEADER_OTHER
196 };
197
198 /*
199  * Overrides for Emacs so that we follow Linus's tabbing style.
200  * Emacs will notice this stuff at the end of the file and automatically
201  * adjust the settings for this buffer only.  This must remain at the end
202  * of the file.
203  * ---------------------------------------------------------------------------
204  * Local variables:
205  * c-file-style: "linux"
206  * End:
207  */