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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include "wine/port.h"
25 #include "wine/unicode.h"
34 #include <sys/types.h>
36 #ifdef HAVE_SYS_IOCTL_H
37 #include <sys/ioctl.h>
39 #ifdef HAVE_SYS_SOCKET_H
40 #include <sys/socket.h>
56 unsigned int max_msgsize
;
57 unsigned int read_timeout
;
62 /* mailslot functions */
63 static void mailslot_dump( struct object
*, int );
64 static struct fd
*mailslot_get_fd( struct object
* );
65 static void mailslot_destroy( struct object
* );
67 static const struct object_ops mailslot_ops
=
69 sizeof(struct mailslot
), /* size */
70 mailslot_dump
, /* dump */
71 default_fd_add_queue
, /* add_queue */
72 default_fd_remove_queue
, /* remove_queue */
73 default_fd_signaled
, /* signaled */
74 no_satisfied
, /* satisfied */
75 no_signal
, /* signal */
76 mailslot_get_fd
, /* get_fd */
77 mailslot_destroy
/* destroy */
80 static int mailslot_get_poll_events( struct fd
* );
81 static void mailslot_poll_event( struct fd
*, int );
82 static int mailslot_get_info( struct fd
* );
83 static void mailslot_queue_async( struct fd
*, void*, void*, void*, int, int );
84 static void mailslot_cancel_async( struct fd
* );
86 static const struct fd_ops mailslot_fd_ops
=
88 mailslot_get_poll_events
, /* get_poll_events */
89 mailslot_poll_event
, /* poll_event */
91 mailslot_get_info
, /* get_file_info */
92 mailslot_queue_async
, /* queue_async */
93 mailslot_cancel_async
/* cancel_async */
99 struct mailslot
*mailslot
;
105 static void mail_writer_dump( struct object
*obj
, int verbose
);
106 static struct fd
*mail_writer_get_fd( struct object
*obj
);
107 static void mail_writer_destroy( struct object
*obj
);
109 static const struct object_ops mail_writer_ops
=
111 sizeof(struct mail_writer
), /* size */
112 mail_writer_dump
, /* dump */
113 no_add_queue
, /* add_queue */
114 NULL
, /* remove_queue */
116 NULL
, /* satisfied */
117 no_signal
, /* signal */
118 mail_writer_get_fd
, /* get_fd */
119 mail_writer_destroy
/* destroy */
122 static int mail_writer_get_info( struct fd
*fd
);
124 static const struct fd_ops mail_writer_fd_ops
=
126 NULL
, /* get_poll_events */
127 NULL
, /* poll_event */
128 no_flush
, /* flush */
129 mail_writer_get_info
, /* get_file_info */
130 no_queue_async
, /* queue_async */
131 NULL
/* cancel_async */
134 static void mailslot_destroy( struct object
*obj
)
136 struct mailslot
*mailslot
= (struct mailslot
*) obj
;
138 assert( mailslot
->fd
);
139 assert( mailslot
->write_fd
);
141 async_terminate_queue( &mailslot
->read_q
, STATUS_CANCELLED
);
143 release_object( mailslot
->fd
);
144 release_object( mailslot
->write_fd
);
147 static void mailslot_dump( struct object
*obj
, int verbose
)
149 struct mailslot
*mailslot
= (struct mailslot
*) obj
;
151 assert( obj
->ops
== &mailslot_ops
);
152 fprintf( stderr
, "Mailslot max_msgsize=%d read_timeout=%d\n",
153 mailslot
->max_msgsize
, mailslot
->read_timeout
);
156 static int mailslot_message_count(struct mailslot
*mailslot
)
160 /* poll the socket to see if there's any messages */
161 pfd
.fd
= get_unix_fd( mailslot
->fd
);
164 return (poll( &pfd
, 1, 0 ) == 1) ? 1 : 0;
167 static int mailslot_next_msg_size( struct mailslot
*mailslot
)
172 fd
= get_unix_fd( mailslot
->fd
);
173 ioctl( fd
, FIONREAD
, &size
);
177 static int mailslot_get_info( struct fd
*fd
)
179 struct mailslot
*mailslot
= get_fd_user( fd
);
180 assert( mailslot
->obj
.ops
== &mailslot_ops
);
181 return FD_FLAG_TIMEOUT
| FD_FLAG_AVAILABLE
;
184 static struct fd
*mailslot_get_fd( struct object
*obj
)
186 struct mailslot
*mailslot
= (struct mailslot
*) obj
;
188 return (struct fd
*)grab_object( mailslot
->fd
);
191 static int mailslot_get_poll_events( struct fd
*fd
)
193 struct mailslot
*mailslot
= get_fd_user( fd
);
195 assert( mailslot
->obj
.ops
== &mailslot_ops
);
197 if( !list_empty( &mailslot
->read_q
))
203 static void mailslot_poll_event( struct fd
*fd
, int event
)
205 struct mailslot
*mailslot
= get_fd_user( fd
);
207 if( !list_empty( &mailslot
->read_q
) && (POLLIN
& event
) )
208 async_terminate_head( &mailslot
->read_q
, STATUS_ALERTED
);
210 set_fd_events( fd
, mailslot_get_poll_events(fd
) );
213 static void mailslot_queue_async( struct fd
*fd
, void *apc
, void *user
,
214 void *iosb
, int type
, int count
)
216 struct mailslot
*mailslot
= get_fd_user( fd
);
217 int events
, *ptimeout
= NULL
;
219 assert(mailslot
->obj
.ops
== &mailslot_ops
);
221 if( type
!= ASYNC_TYPE_READ
)
223 set_error(STATUS_INVALID_PARAMETER
);
227 if( list_empty( &mailslot
->writers
) ||
228 !mailslot_message_count( mailslot
))
230 set_error(STATUS_IO_TIMEOUT
);
234 if (mailslot
->read_timeout
!= MAILSLOT_WAIT_FOREVER
)
235 ptimeout
= &mailslot
->read_timeout
;
237 if (!create_async( current
, ptimeout
, &mailslot
->read_q
, apc
, user
, iosb
))
240 /* Check if the new pending request can be served immediately */
241 events
= check_fd_events( fd
, mailslot_get_poll_events( fd
) );
244 mailslot_poll_event( fd
, events
);
248 set_fd_events( fd
, mailslot_get_poll_events( fd
));
251 static void mailslot_cancel_async( struct fd
*fd
)
253 struct mailslot
*mailslot
= get_fd_user( fd
);
255 assert(mailslot
->obj
.ops
== &mailslot_ops
);
256 async_terminate_queue( &mailslot
->read_q
, STATUS_CANCELLED
);
259 static struct mailslot
*create_mailslot( const WCHAR
*name
, size_t len
, int max_msgsize
,
262 struct mailslot
*mailslot
;
264 static const WCHAR slot
[] = {'m','a','i','l','s','l','o','t','\\',0};
266 if( ( len
<= strlenW( slot
) ) || strncmpiW( slot
, name
, strlenW( slot
) ) )
268 set_error( STATUS_OBJECT_NAME_INVALID
);
272 mailslot
= create_named_object( sync_namespace
, &mailslot_ops
, name
, len
);
276 /* it already exists - there can only be one mailslot to read from */
277 if( get_error() == STATUS_OBJECT_NAME_COLLISION
)
279 release_object( mailslot
);
284 mailslot
->write_fd
= NULL
;
285 mailslot
->max_msgsize
= max_msgsize
;
286 mailslot
->read_timeout
= read_timeout
;
287 list_init( &mailslot
->writers
);
288 list_init( &mailslot
->read_q
);
290 if( !socketpair( PF_UNIX
, SOCK_DGRAM
, 0, fds
) )
292 fcntl( fds
[0], F_SETFL
, O_NONBLOCK
);
293 fcntl( fds
[1], F_SETFL
, O_NONBLOCK
);
294 mailslot
->fd
= create_anonymous_fd( &mailslot_fd_ops
,
295 fds
[1], &mailslot
->obj
);
296 mailslot
->write_fd
= create_anonymous_fd( &mail_writer_fd_ops
,
297 fds
[0], &mailslot
->obj
);
298 if( mailslot
->fd
&& mailslot
->write_fd
) return mailslot
;
300 else file_set_error();
302 release_object( mailslot
);
306 static struct mailslot
*open_mailslot( const WCHAR
*name
, size_t len
)
310 obj
= find_object( sync_namespace
, name
, len
);
313 if (obj
->ops
== &mailslot_ops
)
314 return (struct mailslot
*)obj
;
315 release_object( obj
);
316 set_error( STATUS_OBJECT_TYPE_MISMATCH
);
319 set_error( STATUS_OBJECT_NAME_NOT_FOUND
);
324 static void mail_writer_dump( struct object
*obj
, int verbose
)
326 fprintf( stderr
, "Mailslot writer\n" );
329 static void mail_writer_destroy( struct object
*obj
)
331 struct mail_writer
*writer
= (struct mail_writer
*) obj
;
333 list_remove( &writer
->entry
);
334 release_object( writer
->mailslot
);
337 static int mail_writer_get_info( struct fd
*fd
)
342 static struct fd
*mail_writer_get_fd( struct object
*obj
)
344 struct mail_writer
*writer
= (struct mail_writer
*) obj
;
346 return (struct fd
*)grab_object( writer
->mailslot
->write_fd
);
350 * Readers and writers cannot be mixed.
351 * If there's more than one writer, all writers must open with FILE_SHARE_WRITE
353 static struct mail_writer
*create_mail_writer( struct mailslot
*mailslot
, unsigned int access
,
354 unsigned int sharing
)
356 struct mail_writer
*writer
;
358 if (!list_empty( &mailslot
->writers
))
360 writer
= LIST_ENTRY( list_head(&mailslot
->writers
), struct mail_writer
, entry
);
362 if (((access
& GENERIC_WRITE
) || (writer
->access
& GENERIC_WRITE
)) &&
363 !((sharing
& FILE_SHARE_WRITE
) && (writer
->sharing
& FILE_SHARE_WRITE
)))
365 set_error( STATUS_SHARING_VIOLATION
);
370 writer
= alloc_object( &mail_writer_ops
);
374 grab_object( mailslot
);
375 writer
->mailslot
= mailslot
;
376 writer
->access
= access
;
377 writer
->sharing
= sharing
;
379 list_add_head( &mailslot
->writers
, &writer
->entry
);
384 static struct mailslot
*get_mailslot_obj( struct process
*process
, obj_handle_t handle
,
385 unsigned int access
)
388 obj
= get_handle_obj( process
, handle
, access
, &mailslot_ops
);
389 return (struct mailslot
*) obj
;
393 /* create a mailslot */
394 DECL_HANDLER(create_mailslot
)
396 struct mailslot
*mailslot
;
399 mailslot
= create_mailslot( get_req_data(), get_req_data_size(),
400 req
->max_msgsize
, req
->read_timeout
);
403 reply
->handle
= alloc_handle( current
->process
, mailslot
,
404 GENERIC_READ
, req
->inherit
);
405 release_object( mailslot
);
410 /* open an existing mailslot */
411 DECL_HANDLER(open_mailslot
)
413 struct mailslot
*mailslot
;
417 if( ! ( req
->sharing
& FILE_SHARE_READ
) )
419 set_error( STATUS_SHARING_VIOLATION
);
423 mailslot
= open_mailslot( get_req_data(), get_req_data_size() );
426 struct mail_writer
*writer
;
428 writer
= create_mail_writer( mailslot
, req
->access
, req
->sharing
);
431 reply
->handle
= alloc_handle( current
->process
, writer
,
432 req
->access
, req
->inherit
);
433 release_object( writer
);
435 release_object( mailslot
);
438 set_error( STATUS_NO_SUCH_FILE
);
442 /* set mailslot information */
443 DECL_HANDLER(set_mailslot_info
)
445 struct mailslot
*mailslot
= get_mailslot_obj( current
->process
, req
->handle
, 0 );
449 if( req
->flags
& MAILSLOT_SET_READ_TIMEOUT
)
450 mailslot
->read_timeout
= req
->read_timeout
;
451 reply
->max_msgsize
= mailslot
->max_msgsize
;
452 reply
->read_timeout
= mailslot
->read_timeout
;
453 reply
->msg_count
= mailslot_message_count(mailslot
);
455 /* get the size of the next message */
456 if( reply
->msg_count
)
457 reply
->next_msgsize
= mailslot_next_msg_size(mailslot
);
459 reply
->next_msgsize
= MAILSLOT_NO_MESSAGE
;
461 release_object( mailslot
);