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
|
/* Protocol family operations
Copyright (C) 1995, 1999, 2000, 2008 Free Software Foundation, Inc.
Written by Miles Bader <miles@gnu.ai.mit.edu>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2, or (at
your option) any later version.
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.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include <stddef.h>
#include <sys/socket.h>
#include <hurd/pipe.h>
#include <hurd/trivfs.h>
#include "sock.h"
#include "socket_S.h"
/* Create a new socket. Sock type is, for example, SOCK_STREAM,
SOCK_DGRAM, or some such. */
error_t
S_socket_create (trivfs_protid_t pf,
int sock_type, int protocol,
mach_port_t *port, mach_msg_type_name_t *port_type)
{
error_t err;
struct sock *sock;
struct pipe_class *pipe_class;
mode_t mode;
/* We have a set of `magic' protocols that allow the user to choose
the file type of the socket. The primary application is to make
sockets that pretend to be a FIFO, for the implementations of
pipes. */
switch (protocol)
{
case 0:
mode = S_IFSOCK;
break;
case S_IFCHR:
case S_IFSOCK:
case S_IFIFO:
mode = protocol;
break;
default:
return EPROTONOSUPPORT;
}
switch (sock_type)
{
case SOCK_STREAM:
pipe_class = stream_pipe_class; break;
case SOCK_DGRAM:
pipe_class = dgram_pipe_class; break;
case SOCK_SEQPACKET:
pipe_class = seqpack_pipe_class; break;
default:
return EPROTOTYPE;
}
err = sock_create (pipe_class, mode, &sock);
if (!err)
{
err = sock_create_port (sock, port);
if (err)
sock_free (sock);
else
*port_type = MACH_MSG_TYPE_MAKE_SEND;
}
if (!err)
{
if (pf->user->uids->num > 0)
sock->uid = pf->user->uids->ids[0];
if (pf->user->gids->num > 0)
sock->gid = pf->user->gids->ids[0];
}
return err;
}
error_t
S_socket_create_address (mach_port_t pf, int sockaddr_type,
const_data_t data,
mach_msg_type_number_t data_len,
mach_port_t *addr_port,
mach_msg_type_name_t *addr_port_type)
{
return EOPNOTSUPP;
}
error_t
S_socket_fabricate_address (mach_port_t pf,
int sockaddr_type,
mach_port_t *addr_port,
mach_msg_type_name_t *addr_port_type)
{
error_t err;
struct addr *addr;
if (sockaddr_type != AF_LOCAL)
return EAFNOSUPPORT;
err = addr_create (&addr);
if (err)
return err;
*addr_port = ports_get_right (addr);
*addr_port_type = MACH_MSG_TYPE_MAKE_SEND;
ports_port_deref (addr);
return 0;
}
/* Implement socket_whatis_address as described in <hurd/socket.defs>.
Since we cannot tell what our address is, return an empty string as
the file name. This is primarily for the implementation of accept
and recvfrom. The functions getsockname and getpeername remain
unsupported for the local namespace. */
error_t
S_socket_whatis_address (struct addr *addr,
int *sockaddr_type,
data_t *sockaddr,
mach_msg_type_number_t *sockaddr_len)
{
socklen_t addr_len = (offsetof (struct sockaddr, sa_data) + 1);
if (! addr)
return EOPNOTSUPP;
*sockaddr_type = AF_LOCAL;
if (*sockaddr_len < addr_len)
*sockaddr = mmap (0, addr_len, PROT_READ|PROT_WRITE, MAP_ANON, 0, 0);
((struct sockaddr *) *sockaddr)->sa_len = addr_len;
((struct sockaddr *) *sockaddr)->sa_family = *sockaddr_type;
((struct sockaddr *) *sockaddr)->sa_data[0] = 0;
*sockaddr_len = addr_len;
return 0;
}
|
