r4831: added udp support to our generic sockets library.
[bbaumbach/samba-autobuild/.git] / source4 / lib / socket / socket_unix.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    unix domain socket functions
5
6    Copyright (C) Stefan Metzmacher 2004
7    Copyright (C) Andrew Tridgell 2004-2005
8    
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include "includes.h"
25 #include "system/network.h"
26
27
28
29 /*
30   approximate errno mapping
31 */
32 static NTSTATUS unixdom_error(int ernum)
33 {
34         return map_nt_error_from_unix(ernum);
35 }
36
37 static NTSTATUS unixdom_init(struct socket_context *sock)
38 {
39         sock->fd = socket(PF_UNIX, SOCK_STREAM, 0);
40         if (sock->fd == -1) {
41                 return NT_STATUS_INSUFFICIENT_RESOURCES;
42         }
43         sock->private_data = NULL;
44
45         return NT_STATUS_OK;
46 }
47
48 static void unixdom_close(struct socket_context *sock)
49 {
50         close(sock->fd);
51 }
52
53 static NTSTATUS unixdom_connect_complete(struct socket_context *sock, uint32_t flags)
54 {
55         int error=0, ret;
56         socklen_t len = sizeof(error);
57
58         /* check for any errors that may have occurred - this is needed
59            for non-blocking connect */
60         ret = getsockopt(sock->fd, SOL_SOCKET, SO_ERROR, &error, &len);
61         if (ret == -1) {
62                 return map_nt_error_from_unix(errno);
63         }
64         if (error != 0) {
65                 return map_nt_error_from_unix(error);
66         }
67
68         if (!(flags & SOCKET_FLAG_BLOCK)) {
69                 ret = set_blocking(sock->fd, False);
70                 if (ret == -1) {
71                         return map_nt_error_from_unix(errno);
72                 }
73         }
74
75         sock->state = SOCKET_STATE_CLIENT_CONNECTED;
76
77         return NT_STATUS_OK;
78 }
79
80 static NTSTATUS unixdom_connect(struct socket_context *sock,
81                                 const char *my_address, int my_port,
82                                 const char *srv_address, int srv_port,
83                                 uint32_t flags)
84 {
85         struct sockaddr_un srv_addr;
86         int ret;
87
88         if (strlen(srv_address)+1 > sizeof(srv_addr.sun_path)) {
89                 return NT_STATUS_INVALID_PARAMETER;
90         }
91
92         ZERO_STRUCT(srv_addr);
93         srv_addr.sun_family = AF_UNIX;
94         strncpy(srv_addr.sun_path, srv_address, sizeof(srv_addr.sun_path));
95
96         ret = connect(sock->fd, (const struct sockaddr *)&srv_addr, sizeof(srv_addr));
97         if (ret == -1) {
98                 return unixdom_error(errno);
99         }
100
101         return unixdom_connect_complete(sock, flags);
102 }
103
104 static NTSTATUS unixdom_listen(struct socket_context *sock,
105                                const char *my_address, int port,
106                                int queue_size, uint32_t flags)
107 {
108         struct sockaddr_un my_addr;
109         int ret;
110
111         if (strlen(my_address)+1 > sizeof(my_addr.sun_path)) {
112                 return NT_STATUS_INVALID_PARAMETER;
113         }
114
115         /* delete if it already exists */
116         unlink(my_address);
117
118         ZERO_STRUCT(my_addr);
119         my_addr.sun_family = AF_UNIX;
120         strncpy(my_addr.sun_path, my_address, sizeof(my_addr.sun_path));
121
122         ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
123         if (ret == -1) {
124                 return unixdom_error(errno);
125         }
126
127         ret = listen(sock->fd, queue_size);
128         if (ret == -1) {
129                 return unixdom_error(errno);
130         }
131
132         if (!(flags & SOCKET_FLAG_BLOCK)) {
133                 ret = set_blocking(sock->fd, False);
134                 if (ret == -1) {
135                         return unixdom_error(errno);
136                 }
137         }
138
139         sock->state = SOCKET_STATE_SERVER_LISTEN;
140         sock->private_data = (void *)talloc_strdup(sock, my_address);
141
142         return NT_STATUS_OK;
143 }
144
145 static NTSTATUS unixdom_accept(struct socket_context *sock, 
146                                struct socket_context **new_sock)
147 {
148         struct sockaddr_un cli_addr;
149         socklen_t cli_addr_len = sizeof(cli_addr);
150         int new_fd;
151
152         new_fd = accept(sock->fd, (struct sockaddr *)&cli_addr, &cli_addr_len);
153         if (new_fd == -1) {
154                 return unixdom_error(errno);
155         }
156
157         if (!(sock->flags & SOCKET_FLAG_BLOCK)) {
158                 int ret = set_blocking(new_fd, False);
159                 if (ret == -1) {
160                         close(new_fd);
161                         return map_nt_error_from_unix(errno);
162                 }
163         }
164
165         (*new_sock) = talloc_p(NULL, struct socket_context);
166         if (!(*new_sock)) {
167                 close(new_fd);
168                 return NT_STATUS_NO_MEMORY;
169         }
170
171         /* copy the socket_context */
172         (*new_sock)->type               = sock->type;
173         (*new_sock)->state              = SOCKET_STATE_SERVER_CONNECTED;
174         (*new_sock)->flags              = sock->flags;
175
176         (*new_sock)->fd                 = new_fd;
177
178         (*new_sock)->private_data       = NULL;
179         (*new_sock)->ops                = sock->ops;
180
181         return NT_STATUS_OK;
182 }
183
184 static NTSTATUS unixdom_recv(struct socket_context *sock, void *buf, 
185                              size_t wantlen, size_t *nread, uint32_t flags)
186 {
187         ssize_t gotlen;
188         int flgs = 0;
189
190         /* TODO: we need to map all flags here */
191         if (flags & SOCKET_FLAG_PEEK) {
192                 flgs |= MSG_PEEK;
193         }
194
195         if (flags & SOCKET_FLAG_BLOCK) {
196                 flgs |= MSG_WAITALL;
197         }
198
199         *nread = 0;
200
201         gotlen = recv(sock->fd, buf, wantlen, flgs);
202         if (gotlen == 0) {
203                 return NT_STATUS_END_OF_FILE;
204         } else if (gotlen == -1) {
205                 return unixdom_error(errno);
206         }
207
208         *nread = gotlen;
209
210         return NT_STATUS_OK;
211 }
212
213 static NTSTATUS unixdom_send(struct socket_context *sock,
214                              const DATA_BLOB *blob, size_t *sendlen, uint32_t flags)
215 {
216         ssize_t len;
217         int flgs = 0;
218
219         *sendlen = 0;
220
221         len = send(sock->fd, blob->data, blob->length, flgs);
222         if (len == -1) {
223                 return unixdom_error(errno);
224         }       
225
226         *sendlen = len;
227
228         return NT_STATUS_OK;
229 }
230
231 static NTSTATUS unixdom_set_option(struct socket_context *sock, 
232                                    const char *option, const char *val)
233 {
234         return NT_STATUS_OK;
235 }
236
237 static char *unixdom_get_peer_name(struct socket_context *sock, TALLOC_CTX *mem_ctx)
238 {
239         return talloc_strdup(mem_ctx, "LOCAL/unixdom");
240 }
241
242 static char *unixdom_get_peer_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
243 {
244         return talloc_strdup(mem_ctx, "LOCAL/unixdom");
245 }
246
247 static int unixdom_get_peer_port(struct socket_context *sock)
248 {
249         return 0;
250 }
251
252 static char *unixdom_get_my_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
253 {
254         return talloc_strdup(mem_ctx, "LOCAL/unixdom");
255 }
256
257 static int unixdom_get_my_port(struct socket_context *sock)
258 {
259         return 0;
260 }
261
262 static int unixdom_get_fd(struct socket_context *sock)
263 {
264         return sock->fd;
265 }
266
267 static const struct socket_ops unixdom_ops = {
268         .name                   = "unix",
269         .fn_init                = unixdom_init,
270         .fn_connect             = unixdom_connect,
271         .fn_connect_complete    = unixdom_connect_complete,
272         .fn_listen              = unixdom_listen,
273         .fn_accept              = unixdom_accept,
274         .fn_recv                = unixdom_recv,
275         .fn_send                = unixdom_send,
276         .fn_close               = unixdom_close,
277
278         .fn_set_option          = unixdom_set_option,
279
280         .fn_get_peer_name       = unixdom_get_peer_name,
281         .fn_get_peer_addr       = unixdom_get_peer_addr,
282         .fn_get_peer_port       = unixdom_get_peer_port,
283         .fn_get_my_addr         = unixdom_get_my_addr,
284         .fn_get_my_port         = unixdom_get_my_port,
285
286         .fn_get_fd              = unixdom_get_fd
287 };
288
289 const struct socket_ops *socket_unixdom_ops(enum socket_type type)
290 {
291         if (type != SOCKET_TYPE_STREAM) {
292                 return NULL;
293         }
294         return &unixdom_ops;
295 }