1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
/* $Id: socksys.c,v 1.21 2002/02/08 03:57:14 davem Exp $
* socksys.c: /dev/inet/ stuff for Solaris emulation.
*
* Copyright (C) 1997 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
* Copyright (C) 1997, 1998 Patrik Rak (prak3264@ss1000.ms.mff.cuni.cz)
* Copyright (C) 1995, 1996 Mike Jagdis (jaggy@purplet.demon.co.uk)
*/
/*
* Dave, _please_ give me specifications on this fscking mess so that I
* could at least get it into the state when it wouldn't screw the rest of
* the kernel over. socksys.c and timod.c _stink_ and we are not talking
* H2S here, it's isopropilmercaptan in concentrations way over LD50. -- AV
*/
#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/smp.h>
#include <linux/ioctl.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/init.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/syscalls.h>
#include <linux/in.h>
#include <net/sock.h>
#include <asm/uaccess.h>
#include <asm/termios.h>
#include "conv.h"
#include "socksys.h"
static int af_inet_protocols[] = {
IPPROTO_ICMP, IPPROTO_ICMP, IPPROTO_IGMP, IPPROTO_IPIP, IPPROTO_TCP,
IPPROTO_EGP, IPPROTO_PUP, IPPROTO_UDP, IPPROTO_IDP, IPPROTO_RAW,
0, 0, 0, 0, 0, 0,
};
#ifndef DEBUG_SOLARIS_KMALLOC
#define mykmalloc kmalloc
#define mykfree kfree
#else
extern void * mykmalloc(size_t s, gfp_t gfp);
extern void mykfree(void *);
#endif
static unsigned int (*sock_poll)(struct file *, poll_table *);
static struct file_operations socksys_file_ops = {
/* Currently empty */
};
static int socksys_open(struct inode * inode, struct file * filp)
{
int family, type, protocol, fd;
struct dentry *dentry;
int (*sys_socket)(int,int,int) =
(int (*)(int,int,int))SUNOS(97);
struct sol_socket_struct * sock;
family = ((iminor(inode) >> 4) & 0xf);
switch (family) {
case AF_UNIX:
type = SOCK_STREAM;
protocol = 0;
break;
case AF_INET:
protocol = af_inet_protocols[iminor(inode) & 0xf];
switch (protocol) {
case IPPROTO_TCP: type = SOCK_STREAM; break;
case IPPROTO_UDP: type = SOCK_DGRAM; break;
default: type = SOCK_RAW; break;
}
break;
default:
type = SOCK_RAW;
protocol = 0;
break;
}
fd = sys_socket(family, type, protocol);
if (fd < 0)
return fd;
/*
* N.B. The following operations are not legal!
*
* No shit. WTF is it supposed to do, anyway?
*
* Try instead:
* d_delete(filp->f_path.dentry), then d_instantiate with sock inode
*/
dentry = filp->f_path.dentry;
filp->f_path.dentry = dget(fcheck(fd)->f_path.dentry);
filp->f_path.dentry->d_inode->i_rdev = inode->i_rdev;
filp->f_path.dentry->d_inode->i_flock = inode->i_flock;
SOCKET_I(filp->f_path.dentry->d_inode)->file = filp;
filp->f_op = &socksys_file_ops;
sock = (struct sol_socket_struct*)
mykmalloc(sizeof(struct sol_socket_struct), GFP_KERNEL);
if (!sock) return -ENOMEM;
SOLDD(("sock=%016lx(%016lx)\n", sock, filp));
sock->magic = SOLARIS_SOCKET_MAGIC;
sock->modcount = 0;
sock->state = TS_UNBND;
sock->offset = 0;
sock->pfirst = sock->plast = NULL;
filp->private_data = sock;
SOLDD(("filp->private_data %016lx\n", filp->private_data));
sys_close(fd);
dput(dentry);
return 0;
}
static int socksys_release(struct inode * inode, struct file * filp)
{
struct sol_socket_struct * sock;
struct T_primsg *it;
/* XXX: check this */
sock = (struct sol_socket_struct *)filp->private_data;
SOLDD(("sock release %016lx(%016lx)\n", sock, filp));
it = sock->pfirst;
while (it) {
struct T_primsg *next = it->next;
SOLDD(("socksys_release %016lx->%016lx\n", it, next));
mykfree((char*)it);
it = next;
}
filp->private_data = NULL;
SOLDD(("socksys_release %016lx\n", sock));
mykfree((char*)sock);
return 0;
}
static unsigned int socksys_poll(struct file * filp, poll_table * wait)
{
struct inode *ino;
unsigned int mask = 0;
ino=filp->f_path.dentry->d_inode;
if (ino && S_ISSOCK(ino->i_mode)) {
struct sol_socket_struct *sock;
sock = (struct sol_socket_struct*)filp->private_data;
if (sock && sock->pfirst) {
mask |= POLLIN | POLLRDNORM;
if (sock->pfirst->pri == MSG_HIPRI)
mask |= POLLPRI;
}
}
if (sock_poll)
mask |= (*sock_poll)(filp, wait);
return mask;
}
static const struct file_operations socksys_fops = {
.open = socksys_open,
.release = socksys_release,
};
int __init init_socksys(void)
{
int ret;
struct file * file;
int (*sys_socket)(int,int,int) =
(int (*)(int,int,int))SUNOS(97);
int (*sys_close)(unsigned int) =
(int (*)(unsigned int))SYS(close);
ret = register_chrdev (30, "socksys", &socksys_fops);
if (ret < 0) {
printk ("Couldn't register socksys character device\n");
return ret;
}
ret = sys_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (ret < 0) {
printk ("Couldn't create socket\n");
return ret;
}
file = fcheck(ret);
/* N.B. Is this valid? Suppose the f_ops are in a module ... */
socksys_file_ops = *file->f_op;
sys_close(ret);
sock_poll = socksys_file_ops.poll;
socksys_file_ops.poll = socksys_poll;
socksys_file_ops.release = socksys_release;
return 0;
}
void __exit cleanup_socksys(void)
{
unregister_chrdev(30, "socksys");
}
|
