r3016: - converted the events code to talloc
[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
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
26 static NTSTATUS unixdom_init(struct socket_context *sock)
27 {
28         sock->fd = socket(PF_UNIX, SOCK_STREAM, 0);
29         if (sock->fd == -1) {
30                 return NT_STATUS_INSUFFICIENT_RESOURCES;
31         }
32         sock->private_data = NULL;
33
34         return NT_STATUS_OK;
35 }
36
37 static void unixdom_close(struct socket_context *sock)
38 {
39         close(sock->fd);
40         /* if we were listening, then don't leave the socket lying
41            around in the filesystem */
42         if (sock->private_data) {
43                 unlink((const char *)sock->private_data);
44         }
45 }
46
47 static NTSTATUS unixdom_connect(struct socket_context *sock,
48                                 const char *my_address, int my_port,
49                                 const char *srv_address, int srv_port,
50                                 uint32_t flags)
51 {
52         struct sockaddr_un srv_addr;
53         int ret;
54
55         if (strlen(srv_address)+1 > sizeof(srv_addr.sun_path)) {
56                 return NT_STATUS_INVALID_PARAMETER;
57         }
58
59         ZERO_STRUCT(srv_addr);
60         srv_addr.sun_family = AF_UNIX;
61         strncpy(srv_addr.sun_path, srv_address, sizeof(srv_addr.sun_path));
62
63         if (!(flags & SOCKET_FLAG_BLOCK)) {
64                 ret = set_blocking(sock->fd, False);
65                 if (ret == -1) {
66                         return NT_STATUS_INVALID_PARAMETER;
67                 }
68         }
69
70         ret = connect(sock->fd, (const struct sockaddr *)&srv_addr, sizeof(srv_addr));
71         if (ret == -1) {
72                 return NT_STATUS_CONNECTION_REFUSED;
73         }
74
75         sock->state = SOCKET_STATE_CLIENT_CONNECTED;
76
77         return NT_STATUS_OK;
78 }
79
80 static NTSTATUS unixdom_listen(struct socket_context *sock,
81                                const char *my_address, int port,
82                                int queue_size, uint32_t flags)
83 {
84         struct sockaddr_un my_addr;
85         int ret;
86
87         if (strlen(my_address)+1 > sizeof(my_addr.sun_path)) {
88                 return NT_STATUS_INVALID_PARAMETER;
89         }
90
91         /* delete if it already exists */
92         unlink(my_address);
93
94         ZERO_STRUCT(my_addr);
95         my_addr.sun_family = AF_UNIX;
96         strncpy(my_addr.sun_path, my_address, sizeof(my_addr.sun_path));
97
98         ret = bind(sock->fd, (struct sockaddr *)&my_addr, sizeof(my_addr));
99         if (ret == -1) {
100                 return NT_STATUS_UNSUCCESSFUL;
101         }
102
103         ret = listen(sock->fd, queue_size);
104         if (ret == -1) {
105                 return NT_STATUS_INSUFFICIENT_RESOURCES;
106         }
107
108         if (!(flags & SOCKET_FLAG_BLOCK)) {
109                 ret = set_blocking(sock->fd, False);
110                 if (ret == -1) {
111                         return NT_STATUS_INVALID_PARAMETER;
112                 }
113         }
114
115         sock->state = SOCKET_STATE_SERVER_LISTEN;
116         sock->private_data = (void *)talloc_strdup(sock, my_address);
117
118         return NT_STATUS_OK;
119 }
120
121 static NTSTATUS unixdom_accept(struct socket_context *sock, 
122                                struct socket_context **new_sock, 
123                                uint32_t flags)
124 {
125         struct sockaddr_un cli_addr;
126         socklen_t cli_addr_len = sizeof(cli_addr);
127         int new_fd;
128
129         new_fd = accept(sock->fd, (struct sockaddr *)&cli_addr, &cli_addr_len);
130         if (new_fd == -1) {
131                 return NT_STATUS_INSUFFICIENT_RESOURCES;
132         }
133
134         (*new_sock) = talloc_p(NULL, struct socket_context);
135         if (!(*new_sock)) {
136                 close(new_fd);
137                 return NT_STATUS_NO_MEMORY;
138         }
139
140         /* copy the socket_context */
141         (*new_sock)->type               = sock->type;
142         (*new_sock)->state              = SOCKET_STATE_SERVER_CONNECTED;
143         (*new_sock)->flags              = flags;
144
145         (*new_sock)->fd                 = new_fd;
146
147         (*new_sock)->private_data       = NULL;
148         (*new_sock)->ops                = sock->ops;
149
150         return NT_STATUS_OK;
151 }
152
153 static NTSTATUS unixdom_recv(struct socket_context *sock, TALLOC_CTX *mem_ctx,
154                              DATA_BLOB *blob, size_t wantlen, uint32_t flags)
155 {
156         ssize_t gotlen;
157         void *buf;
158         int flgs = 0;
159
160         buf = talloc(mem_ctx, wantlen);
161         if (!buf) {
162                 return NT_STATUS_NO_MEMORY;
163         }
164
165         /* TODO: we need to map all flags here */
166         if (flags & SOCKET_FLAG_PEEK) {
167                 flgs |= MSG_PEEK;
168         }
169
170         if (!(flags & SOCKET_FLAG_BLOCK)) {
171                 flgs |= MSG_DONTWAIT;
172         }
173
174         if (flags & SOCKET_FLAG_BLOCK) {
175                 flgs |= MSG_WAITALL;
176         }
177
178         gotlen = recv(sock->fd, buf, wantlen, flgs);
179         if (gotlen == 0) {
180                 talloc_free(buf);
181                 return NT_STATUS_END_OF_FILE;
182         } else if (gotlen == -1) {
183                 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
184                 switch (errno) {
185                         case EBADF:
186                         case ENOTCONN:
187                         case ENOTSOCK:
188                         case EFAULT:
189                         case EINVAL:
190                                 status = NT_STATUS_INVALID_PARAMETER;
191                                 break;
192                         case EAGAIN:
193                         case EINTR:
194                                 status = STATUS_MORE_ENTRIES;
195                                 break;
196                         case ECONNREFUSED:
197                                 status = NT_STATUS_CONNECTION_REFUSED;
198                                 break;
199                 }
200                 talloc_free(buf);
201                 return status;
202         }
203
204         blob->length = gotlen;
205         blob->data = talloc_realloc(mem_ctx, buf, gotlen);
206         if (!blob->data) {
207                 return NT_STATUS_NO_MEMORY;
208         }
209
210         return NT_STATUS_OK;
211 }
212
213 static NTSTATUS unixdom_send(struct socket_context *sock, TALLOC_CTX *mem_ctx,
214                              const DATA_BLOB *blob, size_t *sendlen, uint32_t flags)
215 {
216         ssize_t len;
217         int flgs = 0;
218
219         /* TODO: we need to map all flags here */
220         if (!(flags & SOCKET_FLAG_BLOCK)) {
221                 flgs |= MSG_DONTWAIT;
222         }
223
224         len = send(sock->fd, blob->data, blob->length, flgs);
225         if (len == -1) {
226                 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
227                 switch (errno) {
228                         case EBADF:
229                         case ENOTSOCK:
230                         case EFAULT:
231                         case EINVAL:
232                                 status = NT_STATUS_INVALID_PARAMETER;
233                                 break;
234                         case EMSGSIZE:
235                                 status = NT_STATUS_INVALID_BUFFER_SIZE;
236                                 break;
237                         case EAGAIN:
238                         /*case EWOULDBLOCK: this is an alis of EAGAIN --metze */
239                         case EINTR:
240                                 *sendlen = 0;
241                                 status = STATUS_MORE_ENTRIES;
242                                 break;
243                         case ENOBUFS:
244                                 status = NT_STATUS_FOOBAR;
245                                 break;
246                         case ENOMEM:
247                                 status = NT_STATUS_NO_MEMORY;
248                                 break;
249                         case EPIPE:
250                                 status = NT_STATUS_CONNECTION_DISCONNECTED;
251                                 break;
252                 }
253                 return status;
254         }       
255
256         *sendlen = len;
257
258         return NT_STATUS_OK;
259 }
260
261 static NTSTATUS unixdom_set_option(struct socket_context *sock, 
262                                    const char *option, const char *val)
263 {
264         set_socket_options(sock->fd, option);
265         return NT_STATUS_OK;
266 }
267
268 static char *unixdom_get_peer_name(struct socket_context *sock, TALLOC_CTX *mem_ctx)
269 {
270         return talloc_strdup(mem_ctx, "LOCAL/unixdom");
271 }
272
273 static char *unixdom_get_peer_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
274 {
275         return talloc_strdup(mem_ctx, "LOCAL/unixdom");
276 }
277
278 static int unixdom_get_peer_port(struct socket_context *sock)
279 {
280         return 0;
281 }
282
283 static char *unixdom_get_my_addr(struct socket_context *sock, TALLOC_CTX *mem_ctx)
284 {
285         return talloc_strdup(mem_ctx, "LOCAL/unixdom");
286 }
287
288 static int unixdom_get_my_port(struct socket_context *sock)
289 {
290         return 0;
291 }
292
293 static int unixdom_get_fd(struct socket_context *sock)
294 {
295         return sock->fd;
296 }
297
298 static const struct socket_ops unixdom_ops = {
299         .name           = "unix",
300         .type           = SOCKET_TYPE_STREAM,
301
302         .init           = unixdom_init,
303         .connect        = unixdom_connect,
304         .listen         = unixdom_listen,
305         .accept         = unixdom_accept,
306         .recv           = unixdom_recv,
307         .send           = unixdom_send,
308         .close          = unixdom_close,
309
310         .set_option     = unixdom_set_option,
311
312         .get_peer_name  = unixdom_get_peer_name,
313         .get_peer_addr  = unixdom_get_peer_addr,
314         .get_peer_port  = unixdom_get_peer_port,
315         .get_my_addr    = unixdom_get_my_addr,
316         .get_my_port    = unixdom_get_my_port,
317
318         .get_fd         = unixdom_get_fd
319 };
320
321 const struct socket_ops *socket_unixdom_ops(void)
322 {
323         return &unixdom_ops;
324 }
325
326 NTSTATUS socket_unixdom_init(void)
327 {
328         return NT_STATUS_OK;
329 }