2 * Server-side mailslot management
4 * Copyright (C) 1998 Alexandre Julliard
5 * Copyright (C) 2005 Mike McCormack
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #include "wine/port.h"
26 #define WIN32_NO_STATUS
27 #include "wine/unicode.h"
36 #include <sys/types.h>
38 #ifdef HAVE_SYS_IOCTL_H
39 #include <sys/ioctl.h>
41 #ifdef HAVE_SYS_SOCKET_H
42 #include <sys/socket.h>
44 #ifdef HAVE_SYS_FILIO_H
45 #include <sys/filio.h>
60 unsigned int max_msgsize;
65 /* mailslot functions */
66 static void mailslot_dump( struct object*, int );
67 static struct fd *mailslot_get_fd( struct object * );
68 static unsigned int mailslot_map_access( struct object *obj, unsigned int access );
69 static struct object *mailslot_open_file( struct object *obj, unsigned int access,
70 unsigned int sharing, unsigned int options );
71 static void mailslot_destroy( struct object * );
73 static const struct object_ops mailslot_ops =
75 sizeof(struct mailslot), /* size */
76 mailslot_dump, /* dump */
77 add_queue, /* add_queue */
78 remove_queue, /* remove_queue */
79 default_fd_signaled, /* signaled */
80 no_satisfied, /* satisfied */
81 no_signal, /* signal */
82 mailslot_get_fd, /* get_fd */
83 mailslot_map_access, /* map_access */
84 no_lookup_name, /* lookup_name */
85 mailslot_open_file, /* open_file */
86 fd_close_handle, /* close_handle */
87 mailslot_destroy /* destroy */
90 static enum server_fd_type mailslot_get_info( struct fd *fd, int *flags );
91 static void mailslot_queue_async( struct fd *fd, const async_data_t *data, int type, int count );
93 static const struct fd_ops mailslot_fd_ops =
95 default_fd_get_poll_events, /* get_poll_events */
96 default_poll_event, /* poll_event */
98 mailslot_get_info, /* get_file_info */
99 mailslot_queue_async, /* queue_async */
100 default_fd_reselect_async, /* reselect_async */
101 default_fd_cancel_async /* cancel_async */
108 struct mailslot *mailslot;
111 unsigned int sharing;
114 static void mail_writer_dump( struct object *obj, int verbose );
115 static struct fd *mail_writer_get_fd( struct object *obj );
116 static unsigned int mail_writer_map_access( struct object *obj, unsigned int access );
117 static void mail_writer_destroy( struct object *obj);
119 static const struct object_ops mail_writer_ops =
121 sizeof(struct mail_writer), /* size */
122 mail_writer_dump, /* dump */
123 no_add_queue, /* add_queue */
124 NULL, /* remove_queue */
126 NULL, /* satisfied */
127 no_signal, /* signal */
128 mail_writer_get_fd, /* get_fd */
129 mail_writer_map_access, /* map_access */
130 no_lookup_name, /* lookup_name */
131 no_open_file, /* open_file */
132 fd_close_handle, /* close_handle */
133 mail_writer_destroy /* destroy */
136 static enum server_fd_type mail_writer_get_info( struct fd *fd, int *flags );
138 static const struct fd_ops mail_writer_fd_ops =
140 NULL, /* get_poll_events */
141 NULL, /* poll_event */
142 no_flush, /* flush */
143 mail_writer_get_info, /* get_file_info */
144 no_queue_async, /* queue_async */
145 NULL /* cancel_async */
149 struct mailslot_device
151 struct object obj; /* object header */
152 struct fd *fd; /* pseudo-fd for ioctls */
153 struct namespace *mailslots; /* mailslot namespace */
156 static void mailslot_device_dump( struct object *obj, int verbose );
157 static struct fd *mailslot_device_get_fd( struct object *obj );
158 static struct object *mailslot_device_lookup_name( struct object *obj, struct unicode_str *name,
160 static struct object *mailslot_device_open_file( struct object *obj, unsigned int access,
161 unsigned int sharing, unsigned int options );
162 static void mailslot_device_destroy( struct object *obj );
163 static enum server_fd_type mailslot_device_get_file_info( struct fd *fd, int *flags );
165 static const struct object_ops mailslot_device_ops =
167 sizeof(struct mailslot_device), /* size */
168 mailslot_device_dump, /* dump */
169 no_add_queue, /* add_queue */
170 NULL, /* remove_queue */
172 no_satisfied, /* satisfied */
173 no_signal, /* signal */
174 mailslot_device_get_fd, /* get_fd */
175 no_map_access, /* map_access */
176 mailslot_device_lookup_name, /* lookup_name */
177 mailslot_device_open_file, /* open_file */
178 fd_close_handle, /* close_handle */
179 mailslot_device_destroy /* destroy */
182 static const struct fd_ops mailslot_device_fd_ops =
184 default_fd_get_poll_events, /* get_poll_events */
185 default_poll_event, /* poll_event */
186 no_flush, /* flush */
187 mailslot_device_get_file_info, /* get_file_info */
188 default_fd_queue_async, /* queue_async */
189 default_fd_reselect_async, /* reselect_async */
190 default_fd_cancel_async /* cancel_async */
193 static void mailslot_destroy( struct object *obj)
195 struct mailslot *mailslot = (struct mailslot *) obj;
197 assert( mailslot->fd );
198 assert( mailslot->write_fd );
200 shutdown( get_unix_fd( mailslot->fd ), SHUT_RDWR );
201 release_object( mailslot->fd );
202 release_object( mailslot->write_fd );
205 static void mailslot_dump( struct object *obj, int verbose )
207 struct mailslot *mailslot = (struct mailslot *) obj;
209 assert( obj->ops == &mailslot_ops );
210 fprintf( stderr, "Mailslot max_msgsize=%d read_timeout=%d\n",
211 mailslot->max_msgsize, mailslot->read_timeout );
214 static enum server_fd_type mailslot_get_info( struct fd *fd, int *flags )
216 struct mailslot *mailslot = get_fd_user( fd );
217 assert( mailslot->obj.ops == &mailslot_ops );
219 return FD_TYPE_MAILSLOT;
222 static struct fd *mailslot_get_fd( struct object *obj )
224 struct mailslot *mailslot = (struct mailslot *) obj;
226 return (struct fd *)grab_object( mailslot->fd );
229 static unsigned int mailslot_map_access( struct object *obj, unsigned int access )
231 /* mailslots can only be read */
232 if (access & GENERIC_READ) access |= FILE_GENERIC_READ;
233 if (access & GENERIC_ALL) access |= FILE_GENERIC_READ;
234 return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
237 static struct object *mailslot_open_file( struct object *obj, unsigned int access,
238 unsigned int sharing, unsigned int options )
240 struct mailslot *mailslot = (struct mailslot *)obj;
241 struct mail_writer *writer;
243 if (!(sharing & FILE_SHARE_READ))
245 set_error( STATUS_SHARING_VIOLATION );
249 if (!list_empty( &mailslot->writers ))
251 /* Readers and writers cannot be mixed.
252 * If there's more than one writer, all writers must open with FILE_SHARE_WRITE
254 writer = LIST_ENTRY( list_head(&mailslot->writers), struct mail_writer, entry );
256 if (((access & (GENERIC_WRITE|FILE_WRITE_DATA)) || (writer->access & FILE_WRITE_DATA)) &&
257 !((sharing & FILE_SHARE_WRITE) && (writer->sharing & FILE_SHARE_WRITE)))
259 set_error( STATUS_SHARING_VIOLATION );
264 if (!(writer = alloc_object( &mail_writer_ops ))) return NULL;
265 grab_object( mailslot );
266 writer->mailslot = mailslot;
267 writer->access = mail_writer_map_access( &writer->obj, access );
268 writer->sharing = sharing;
270 list_add_head( &mailslot->writers, &writer->entry );
274 static void mailslot_queue_async( struct fd *fd, const async_data_t *data, int type, int count )
276 struct mailslot *mailslot = get_fd_user( fd );
279 assert(mailslot->obj.ops == &mailslot_ops);
281 if ((async = fd_queue_async( fd, data, type, count )))
283 if (mailslot->read_timeout != -1)
285 struct timeval when = current_time;
286 add_timeout( &when, max(1,mailslot->read_timeout) );
287 async_set_timeout( async, &when, STATUS_IO_TIMEOUT );
289 release_object( async );
290 set_error( STATUS_PENDING );
294 static void mailslot_device_dump( struct object *obj, int verbose )
296 assert( obj->ops == &mailslot_device_ops );
297 fprintf( stderr, "Mail slot device\n" );
300 static struct fd *mailslot_device_get_fd( struct object *obj )
302 struct mailslot_device *device = (struct mailslot_device *)obj;
303 return (struct fd *)grab_object( device->fd );
306 static struct object *mailslot_device_lookup_name( struct object *obj, struct unicode_str *name,
309 struct mailslot_device *device = (struct mailslot_device*)obj;
310 struct object *found;
312 assert( obj->ops == &mailslot_device_ops );
314 if ((found = find_object( device->mailslots, name, attr | OBJ_CASE_INSENSITIVE )))
320 static struct object *mailslot_device_open_file( struct object *obj, unsigned int access,
321 unsigned int sharing, unsigned int options )
323 return grab_object( obj );
326 static void mailslot_device_destroy( struct object *obj )
328 struct mailslot_device *device = (struct mailslot_device*)obj;
329 assert( obj->ops == &mailslot_device_ops );
330 if (device->fd) release_object( device->fd );
331 free( device->mailslots );
334 static enum server_fd_type mailslot_device_get_file_info( struct fd *fd, int *flags )
337 return FD_TYPE_DEVICE;
340 void create_mailslot_device( struct directory *root, const struct unicode_str *name )
342 struct mailslot_device *dev;
344 if ((dev = create_named_object_dir( root, name, 0, &mailslot_device_ops )) &&
345 get_error() != STATUS_OBJECT_NAME_EXISTS)
347 dev->mailslots = NULL;
348 if (!(dev->fd = alloc_pseudo_fd( &mailslot_device_fd_ops, &dev->obj )) ||
349 !(dev->mailslots = create_namespace( 7 )))
351 release_object( dev );
355 if (dev) make_object_static( &dev->obj );
358 static struct mailslot *create_mailslot( struct directory *root,
359 const struct unicode_str *name, unsigned int attr,
360 int max_msgsize, int read_timeout )
363 struct unicode_str new_name;
364 struct mailslot_device *dev;
365 struct mailslot *mailslot;
368 if (!name || !name->len) return alloc_object( &mailslot_ops );
370 if (!(obj = find_object_dir( root, name, attr, &new_name )))
372 set_error( STATUS_OBJECT_NAME_INVALID );
378 if (attr & OBJ_OPENIF && obj->ops == &mailslot_ops)
379 /* it already exists - there can only be one mailslot to read from */
380 set_error( STATUS_OBJECT_NAME_EXISTS );
381 else if (attr & OBJ_OPENIF)
382 set_error( STATUS_OBJECT_TYPE_MISMATCH );
384 set_error( STATUS_OBJECT_NAME_COLLISION );
385 release_object( obj );
389 if (obj->ops != &mailslot_device_ops)
391 set_error( STATUS_OBJECT_NAME_INVALID );
392 release_object( obj );
396 dev = (struct mailslot_device *)obj;
397 mailslot = create_object( dev->mailslots, &mailslot_ops, &new_name, NULL );
398 release_object( dev );
400 if (!mailslot) return NULL;
403 mailslot->write_fd = NULL;
404 mailslot->max_msgsize = max_msgsize;
405 mailslot->read_timeout = read_timeout;
406 list_init( &mailslot->writers );
408 if (!socketpair( PF_UNIX, SOCK_DGRAM, 0, fds ))
410 fcntl( fds[0], F_SETFL, O_NONBLOCK );
411 fcntl( fds[1], F_SETFL, O_NONBLOCK );
412 shutdown( fds[0], SHUT_RD );
413 mailslot->fd = create_anonymous_fd( &mailslot_fd_ops, fds[1], &mailslot->obj,
414 FILE_SYNCHRONOUS_IO_NONALERT );
415 mailslot->write_fd = create_anonymous_fd( &mail_writer_fd_ops, fds[0], &mailslot->obj,
416 FILE_SYNCHRONOUS_IO_NONALERT );
417 if (mailslot->fd && mailslot->write_fd) return mailslot;
419 else file_set_error();
421 release_object( mailslot );
425 static void mail_writer_dump( struct object *obj, int verbose )
427 fprintf( stderr, "Mailslot writer\n" );
430 static void mail_writer_destroy( struct object *obj)
432 struct mail_writer *writer = (struct mail_writer *) obj;
434 list_remove( &writer->entry );
435 release_object( writer->mailslot );
438 static enum server_fd_type mail_writer_get_info( struct fd *fd, int *flags )
441 return FD_TYPE_MAILSLOT;
444 static struct fd *mail_writer_get_fd( struct object *obj )
446 struct mail_writer *writer = (struct mail_writer *) obj;
448 return (struct fd *)grab_object( writer->mailslot->write_fd );
451 static unsigned int mail_writer_map_access( struct object *obj, unsigned int access )
453 /* mailslot writers can only get write access */
454 if (access & GENERIC_WRITE) access |= FILE_GENERIC_WRITE;
455 if (access & GENERIC_ALL) access |= FILE_GENERIC_WRITE;
456 return access & ~(GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | GENERIC_ALL);
459 static struct mailslot *get_mailslot_obj( struct process *process, obj_handle_t handle,
460 unsigned int access )
462 return (struct mailslot *)get_handle_obj( process, handle, access, &mailslot_ops );
466 /* create a mailslot */
467 DECL_HANDLER(create_mailslot)
469 struct mailslot *mailslot;
470 struct unicode_str name;
471 struct directory *root = NULL;
474 get_req_unicode_str( &name );
475 if (req->rootdir && !(root = get_directory_obj( current->process, req->rootdir, 0 )))
478 if ((mailslot = create_mailslot( root, &name, req->attributes, req->max_msgsize,
479 req->read_timeout )))
481 reply->handle = alloc_handle( current->process, mailslot, req->access, req->attributes );
482 release_object( mailslot );
485 if (root) release_object( root );
489 /* set mailslot information */
490 DECL_HANDLER(set_mailslot_info)
492 struct mailslot *mailslot = get_mailslot_obj( current->process, req->handle, 0 );
496 if (req->flags & MAILSLOT_SET_READ_TIMEOUT)
497 mailslot->read_timeout = req->read_timeout;
498 reply->max_msgsize = mailslot->max_msgsize;
499 reply->read_timeout = mailslot->read_timeout;
500 release_object( mailslot );