Initial revision
[kopensolaris-gnu/glibc.git] / mach / msgserver.c
1 /* Copyright (C) 1993, 1994 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public License as
6 published by the Free Software Foundation; either version 2 of the
7 License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public
15 License along with the GNU C Library; see the file COPYING.LIB.  If
16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
17 Cambridge, MA 02139, USA.  */
18
19 /* Based on CMU's mach_msg_server.c revision 2.4 of 91/05/14, and thus
20    under the following copyright.  Rewritten by Roland McGrath (FSF)
21    93/12/06 to use stack space instead of malloc, and to handle
22    large messages with MACH_RCV_LARGE.  */
23
24 /* 
25  * Mach Operating System
26  * Copyright (c) 1991,1990 Carnegie Mellon University
27  * All Rights Reserved.
28  * 
29  * Permission to use, copy, modify and distribute this software and its
30  * documentation is hereby granted, provided that both the copyright
31  * notice and this permission notice appear in all copies of the
32  * software, derivative works or modified versions, and any portions
33  * thereof, and that both notices appear in supporting documentation.
34  * 
35  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
36  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
37  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
38  * 
39  * Carnegie Mellon requests users of this software to return to
40  * 
41  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
42  *  School of Computer Science
43  *  Carnegie Mellon University
44  *  Pittsburgh PA 15213-3890
45  * 
46  * any improvements or extensions that they make and grant Carnegie Mellon
47  * the rights to redistribute these changes.
48  */
49 /*
50  * HISTORY
51  * $Log$
52  * Revision 1.2  1994/10/10 07:20:14  roland
53  * Increase default MAX_SIZE to two pages.
54  *
55  * Revision 1.1  1993/12/06  23:25:25  roland
56  * entered into RCS
57  *
58  * Revision 2.4  91/05/14  17:53:22  mrt
59  *      Correcting copyright
60  * 
61  * Revision 2.3  91/02/14  14:17:47  mrt
62  *      Added new Mach copyright
63  *      [91/02/13  12:44:20  mrt]
64  * 
65  * Revision 2.2  90/08/06  17:23:58  rpd
66  *      Created.
67  * 
68  */
69
70
71 #include <mach.h>
72 #include <mach/mig_errors.h>
73 #include <stdlib.h>             /* For malloc and free.  */
74
75 mach_msg_return_t
76 __mach_msg_server_timeout (boolean_t (*demux) (mach_msg_header_t *request,
77                                                mach_msg_header_t *reply),
78                            mach_msg_size_t max_size,
79                            mach_port_t rcv_name,
80                            mach_msg_option_t option,
81                            mach_msg_timeout_t timeout)
82 {
83   register mig_reply_header_t *request, *reply;
84   register mach_msg_return_t mr;
85
86   if (max_size == 0)
87     {
88       option |= MACH_RCV_LARGE;
89       max_size = 2 * __vm_page_size; /* Generic.  Good? XXX */
90     }
91
92   request = __alloca (max_size);
93   reply = __alloca (max_size);
94
95   while (1)
96     {
97     get_request:
98       mr = __mach_msg (&request->Head, MACH_RCV_MSG|option,
99                        0, max_size, rcv_name,
100                        timeout, MACH_PORT_NULL);
101       while (mr == MACH_MSG_SUCCESS)
102         {
103           /* We have a request message.
104              Pass it to DEMUX for processing.  */
105
106           (void) (*demux) (&request->Head, &reply->Head);
107
108           switch (reply->RetCode)
109             {
110             case KERN_SUCCESS:
111               /* Hunky dory.  */
112               break;
113
114             case MIG_NO_REPLY:
115               /* The server function wanted no reply sent.
116                  Loop for another request.  */
117               goto get_request;
118
119             default:
120               /* Some error; destroy the request message to release any
121                  port rights or VM it holds.  Don't destroy the reply port
122                  right, so we can send an error message.  */
123               request->Head.msgh_remote_port = MACH_PORT_NULL;
124               __mach_msg_destroy (&request->Head);
125               break;
126             }
127
128           if (reply->Head.msgh_remote_port == MACH_PORT_NULL)
129             {
130               /* No reply port, so destroy the reply.  */
131               if (reply->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX)
132                 __mach_msg_destroy (&reply->Head);
133               goto get_request;
134             }
135
136           /* Send the reply and the get next request.  */
137
138           {
139             /* Swap the request and reply buffers.  mach_msg will read the
140                reply message from the buffer we pass and write the new
141                request message to the same buffer.  */
142             void *tmp = request;
143             request = reply;
144             reply = tmp;
145           }
146
147           mr = __mach_msg (&request->Head,
148                            MACH_SEND_MSG|MACH_RCV_MSG|option,
149                            request->Head.msgh_size, max_size, rcv_name,
150                            timeout, MACH_PORT_NULL);
151         }
152
153       /* A message error occurred.  */
154
155       switch (mr)
156         {
157         case MACH_RCV_TOO_LARGE:
158           /* The request message is larger than MAX_SIZE, and has not
159              been dequued.  The message header has the actual size of
160              the message.  We recurse here in hopes that the compiler
161              will optimize the tail-call and allocate some more stack
162              space instead of way too much.  */
163           return __mach_msg_server_timeout (demux, request->Head.msgh_size,
164                                             rcv_name, option, timeout);
165
166         case MACH_SEND_INVALID_DEST:
167           /* The reply can't be delivered, so destroy it.  This error
168              indicates only that the requestor went away, so we
169              continue and get the next request.  */
170           __mach_msg_destroy (&request->Head);
171           break;
172
173         default:
174           /* Some other form of lossage; return to caller.  */
175           return mr;
176         }
177     }
178 }
179
180
181 mach_msg_return_t
182 __mach_msg_server (demux, max_size, rcv_name)
183      boolean_t (*demux) ();
184      mach_msg_size_t max_size;
185      mach_port_t rcv_name;
186 {
187   return __mach_msg_server_timeout (demux, max_size, rcv_name,
188                                     MACH_MSG_OPTION_NONE,
189                                     MACH_MSG_TIMEOUT_NONE);
190 }