mach/msgserver.c

   1 /* Copyright (C) 1993, 1994, 1995, 1996, 2001 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 Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the 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    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, write to the Free
  16    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  17    02111-1307 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.7  2001/07/06 04:55:34  aj
  53  * Update to LGPL v2.1.
  54  *
  55  * Revision 1.6  2001/04/09 21:23:38  roland
  56  * 2001-04-07  Roland McGrath  <roland@frob.com>
  57  *
  58  *      * mach/msgserver.c (__mach_msg_server_timeout): Add an assert.
  59  *
  60  * Revision 1.5  1996/12/20 01:32:35  drepper
  61  * Update from main archive 961219
  62  *
  63  * Revision 1.5  1996/12/19 20:23:45  drepper
  64  * Spelling corrections.
  65  *
  66  * Revision 1.4  1996/01/29 15:44:23  roland
  67  * Declare DEMUX arg with prototype.
  68  *
  69  * Revision 1.3  1995/01/21  15:00:57  roland
  70  * Converted to use weak aliases with macros from libc-symbols.h.
  71  *
  72  * Revision 1.2  1994/10/10  07:20:14  roland
  73  * Increase default MAX_SIZE to two pages.
  74  *
  75  * Revision 1.1  1993/12/06  23:25:25  roland
  76  * entered into RCS
  77  *
  78  * Revision 2.4  91/05/14  17:53:22  mrt
  79  *      Correcting copyright
  80  *
  81  * Revision 2.3  91/02/14  14:17:47  mrt
  82  *      Added new Mach copyright
  83  *      [91/02/13  12:44:20  mrt]
  84  *
  85  * Revision 2.2  90/08/06  17:23:58  rpd
  86  *      Created.
  87  *
  88  */
  89
  90
  91 #include <mach.h>
  92 #include <mach/mig_errors.h>
  93 #include <stdlib.h>             /* For malloc and free.  */
  94 #include <assert.h>
  95
  96 mach_msg_return_t
  97 __mach_msg_server_timeout (boolean_t (*demux) (mach_msg_header_t *request,
  98                                                mach_msg_header_t *reply),
  99                            mach_msg_size_t max_size,
 100                            mach_port_t rcv_name,
 101                            mach_msg_option_t option,
 102                            mach_msg_timeout_t timeout)
 103 {
 104   register mig_reply_header_t *request, *reply;
 105   register mach_msg_return_t mr;
 106
 107   if (max_size == 0)
 108     {
 109       option |= MACH_RCV_LARGE;
 110       max_size = 2 * __vm_page_size; /* Generic.  Good? XXX */
 111     }
 112
 113   request = __alloca (max_size);
 114   reply = __alloca (max_size);
 115
 116   while (1)
 117     {
 118     get_request:
 119       mr = __mach_msg (&request->Head, MACH_RCV_MSG|option,
 120                        0, max_size, rcv_name,
 121                        timeout, MACH_PORT_NULL);
 122       while (mr == MACH_MSG_SUCCESS)
 123         {
 124           /* We have a request message.
 125              Pass it to DEMUX for processing.  */
 126
 127           (void) (*demux) (&request->Head, &reply->Head);
 128           assert (reply->Head.msgh_size <= max_size);
 129
 130           switch (reply->RetCode)
 131             {
 132             case KERN_SUCCESS:
 133               /* Hunky dory.  */
 134               break;
 135
 136             case MIG_NO_REPLY:
 137               /* The server function wanted no reply sent.
 138                  Loop for another request.  */
 139               goto get_request;
 140
 141             default:
 142               /* Some error; destroy the request message to release any
 143                  port rights or VM it holds.  Don't destroy the reply port
 144                  right, so we can send an error message.  */
 145               request->Head.msgh_remote_port = MACH_PORT_NULL;
 146               __mach_msg_destroy (&request->Head);
 147               break;
 148             }
 149
 150           if (reply->Head.msgh_remote_port == MACH_PORT_NULL)
 151             {
 152               /* No reply port, so destroy the reply.  */
 153               if (reply->Head.msgh_bits & MACH_MSGH_BITS_COMPLEX)
 154                 __mach_msg_destroy (&reply->Head);
 155               goto get_request;
 156             }
 157
 158           /* Send the reply and the get next request.  */
 159
 160           {
 161             /* Swap the request and reply buffers.  mach_msg will read the
 162                reply message from the buffer we pass and write the new
 163                request message to the same buffer.  */
 164             void *tmp = request;
 165             request = reply;
 166             reply = tmp;
 167           }
 168
 169           mr = __mach_msg (&request->Head,
 170                            MACH_SEND_MSG|MACH_RCV_MSG|option,
 171                            request->Head.msgh_size, max_size, rcv_name,
 172                            timeout, MACH_PORT_NULL);
 173         }
 174
 175       /* A message error occurred.  */
 176
 177       switch (mr)
 178         {
 179         case MACH_RCV_TOO_LARGE:
 180           /* The request message is larger than MAX_SIZE, and has not
 181              been dequeued.  The message header has the actual size of
 182              the message.  We recurse here in hopes that the compiler
 183              will optimize the tail-call and allocate some more stack
 184              space instead of way too much.  */
 185           return __mach_msg_server_timeout (demux, request->Head.msgh_size,
 186                                             rcv_name, option, timeout);
 187
 188         case MACH_SEND_INVALID_DEST:
 189           /* The reply can't be delivered, so destroy it.  This error
 190              indicates only that the requester went away, so we
 191              continue and get the next request.  */
 192           __mach_msg_destroy (&request->Head);
 193           break;
 194
 195         default:
 196           /* Some other form of lossage; return to caller.  */
 197           return mr;
 198         }
 199     }
 200 }
 201 weak_alias (__mach_msg_server_timeout, mach_msg_server_timeout)
 202
 203 mach_msg_return_t
 204 __mach_msg_server (demux, max_size, rcv_name)
 205      boolean_t (*demux) (mach_msg_header_t *in, mach_msg_header_t *out);
 206      mach_msg_size_t max_size;
 207      mach_port_t rcv_name;
 208 {
 209   return __mach_msg_server_timeout (demux, max_size, rcv_name,
 210                                     MACH_MSG_OPTION_NONE,
 211                                     MACH_MSG_TIMEOUT_NONE);
 212 }
 213 weak_alias (__mach_msg_server, mach_msg_server)