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