1: /*
    2:  * Mach Operating System
    3:  * Copyright (c) 1991,1990 Carnegie Mellon University
    4:  * All Rights Reserved.
    5:  *
    6:  * Permission to use, copy, modify and distribute this software and its
    7:  * documentation is hereby granted, provided that both the copyright
    8:  * notice and this permission notice appear in all copies of the
    9:  * software, derivative works or modified versions, and any portions
   10:  * thereof, and that both notices appear in supporting documentation.
   11:  *
   12:  * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
   13:  * CONDITION.  CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
   14:  * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
   15:  *
   16:  * Carnegie Mellon requests users of this software to return to
   17:  *
   18:  *  Software Distribution Coordinator  or  Software.Distribution@CS.CMU.EDU
   19:  *  School of Computer Science
   20:  *  Carnegie Mellon University
   21:  *  Pittsburgh PA 15213-3890
   22:  *
   23:  * any improvements or extensions that they make and grant Carnegie Mellon
   24:  * the rights to redistribute these changes.
   25:  */
   26: /*
   27:  * (pre-GNU) HISTORY
   28:  *
   29:  * Revision 2.4  91/05/14  17:53:15  mrt
   30:  *      Correcting copyright
   31:  *
   32:  * Revision 2.3  91/02/14  14:17:43  mrt
   33:  *      Added new Mach copyright
   34:  *      [91/02/13  12:44:15  mrt]
   35:  *
   36:  * Revision 2.2  90/08/06  17:24:22  rpd
   37:  *      Created.
   38:  *
   39:  */
   40: 
   41: #if 1
   42: #include <mach.h>
   43: #else
   44: /* This is what CMU did, but that fails to declare some used functions.  */
   45: #include <mach/port.h>
   46: #include <mach/message.h>
   47: #include <mach_init.h>
   48: #endif
   49: 
   50: static void mach_msg_destroy_port(mach_port_t, mach_msg_type_name_t);
   51: static void mach_msg_destroy_memory(vm_offset_t, vm_size_t);
   52: 
   53: /*
   54:  *      Routine:     mach_msg_destroy
   55:  *      Purpose:
   56:  *              Deallocates all port rights and out-of-line memory
   57:  *              found in a received message.
   58:  */
   59: 
   60: void
   61: __mach_msg_destroy(msg)
   62:     mach_msg_header_t *msg;
   63: {
   64:     mach_msg_bits_t mbits = msg->msgh_bits;
   65: 
   66:     /*
   67:      *  The msgh_local_port field doesn't hold a port right.
   68:      *  The receive operation consumes the destination port right.
   69:      */
   70: 
   71:     mach_msg_destroy_port(msg->msgh_remote_port, MACH_MSGH_BITS_REMOTE(mbits));
   72: 
   73:     if (mbits & MACH_MSGH_BITS_COMPLEX) {
   74: #ifdef MACH_MSG_PORT_DESCRIPTOR
   75:         mach_msg_body_t                *body;
   76:         mach_msg_descriptor_t  *saddr, *eaddr;
   77: 
   78:         body = (mach_msg_body_t *) (msg + 1);
   79:         saddr = (mach_msg_descriptor_t *)
   80:                         ((mach_msg_base_t *) msg + 1);
   81:         eaddr =  saddr + body->msgh_descriptor_count;
   82: 
   83:         for  ( ; saddr < eaddr; saddr++) {
   84:             switch (saddr->type.type) {
   85: 
   86:                 case MACH_MSG_PORT_DESCRIPTOR: {
   87:                     mach_msg_port_descriptor_t *dsc;
   88: 
   89:                     /*
   90:                      * Destroy port rights carried in the message
   91:                      */
   92:                     dsc = &saddr->port;
   93:                     mach_msg_destroy_port(dsc->name, dsc->disposition);
   94:                     break;
   95:                 }
   96: 
   97:                 case MACH_MSG_OOL_DESCRIPTOR : {
   98:                     mach_msg_ool_descriptor_t *dsc;
   99: 
  100:                     /*
  101:                      * Destroy memory carried in the message
  102:                      */
  103:                     dsc = &saddr->out_of_line;
  104:                     if (dsc->deallocate) {
  105:                         mach_msg_destroy_memory((vm_offset_t)dsc->address,
  106:                                                 dsc->size);
  107:                     }
  108:                     break;
  109:                 }
  110: 
  111:                 case MACH_MSG_OOL_PORTS_DESCRIPTOR : {
  112:                     mach_port_t                       *ports;
  113:                     mach_msg_ool_ports_descriptor_t   *dsc;
  114:                     mach_msg_type_number_t            j;
  115: 
  116:                     /*
  117:                      * Destroy port rights carried in the message
  118:                      */
  119:                     dsc = &saddr->ool_ports;
  120:                     ports = (mach_port_t *) dsc->address;
  121:                     for (j = 0; j < dsc->count; j++, ports++)  {
  122:                         mach_msg_destroy_port(*ports, dsc->disposition);
  123:                     }
  124: 
  125:                     /*
  126:                      * Destroy memory carried in the message
  127:                      */
  128:                     if (dsc->deallocate) {
  129:                         mach_msg_destroy_memory((vm_offset_t)dsc->address,
  130:                                         dsc->count * sizeof(mach_port_t));
  131:                     }
  132:                     break;
  133:                 }
  134:             }
  135:         }
  136: #else
  137:         vm_offset_t saddr;
  138:         vm_offset_t eaddr;
  139: 
  140:         saddr = (vm_offset_t) (msg + 1);
  141:         eaddr = (vm_offset_t) msg + msg->msgh_size;
  142: 
  143:         while (saddr < eaddr) {
  144:             mach_msg_type_long_t *type;
  145:             mach_msg_type_name_t name;
  146:             mach_msg_type_size_t size;
  147:             mach_msg_type_number_t number;
  148:             boolean_t is_inline;
  149:             vm_size_t length;
  150:             vm_offset_t addr;
  151: 
  152:             type = (mach_msg_type_long_t *) saddr;
  153:             is_inline = type->msgtl_header.msgt_inline;
  154:             if (type->msgtl_header.msgt_longform) {
  155:                     name = type->msgtl_name;
  156:                     size = type->msgtl_size;
  157:                     number = type->msgtl_number;
  158:                     saddr += sizeof(mach_msg_type_long_t);
  159:             } else {
  160:                     name = type->msgtl_header.msgt_name;
  161:                     size = type->msgtl_header.msgt_size;
  162:                     number = type->msgtl_header.msgt_number;
  163:                     saddr += sizeof(mach_msg_type_t);
  164:             }
  165: 
  166:             /* calculate length of data in bytes, rounding up */
  167:             length = (((((number * size) + 7) >> 3) + sizeof (int) - 1)
  168:                       &~ (sizeof (int) - 1));
  169: 
  170:             addr = is_inline ? saddr : * (vm_offset_t *) saddr;
  171: 
  172:             if (MACH_MSG_TYPE_PORT_ANY(name)) {
  173:                 mach_port_t *ports = (mach_port_t *) addr;
  174:                 mach_msg_type_number_t i;
  175: 
  176:                 for (i = 0; i < number; i++)
  177:                     mach_msg_destroy_port(*ports++, name);
  178:             }
  179: 
  180:             if (is_inline) {
  181:                 /* inline data sizes round up to int boundaries */
  182:                 saddr += length;
  183:             } else {
  184:                 mach_msg_destroy_memory(addr, length);
  185:                 saddr += sizeof(vm_offset_t);
  186:             }
  187:         }
  188: #endif
  189:     }
  190: }
  191: 
  192: weak_alias (__mach_msg_destroy, mach_msg_destroy)
  193: 
  194: static void
  195: mach_msg_destroy_port(port, type)
  196:     mach_port_t port;
  197:     mach_msg_type_name_t type;
  198: {
  199:     if (MACH_PORT_VALID(port)) switch (type) {
  200:       case MACH_MSG_TYPE_MOVE_SEND:
  201:       case MACH_MSG_TYPE_MOVE_SEND_ONCE:
  202:         /* destroy the send/send-once right */
  203:         (void) __mach_port_deallocate(mach_task_self(), port);
  204:         break;
  205: 
  206:       case MACH_MSG_TYPE_MOVE_RECEIVE:
  207:         /* destroy the receive right */
  208:         (void) __mach_port_mod_refs(mach_task_self(), port,
  209:                                     MACH_PORT_RIGHT_RECEIVE, -1);
  210:         break;
  211: 
  212:       case MACH_MSG_TYPE_MAKE_SEND:
  213:         /* create a send right and then destroy it */
  214:         (void) __mach_port_insert_right(mach_task_self(), port,
  215:                                         port, MACH_MSG_TYPE_MAKE_SEND);
  216:         (void) __mach_port_deallocate(mach_task_self(), port);
  217:         break;
  218: 
  219:       case MACH_MSG_TYPE_MAKE_SEND_ONCE:
  220:         /* create a send-once right and then destroy it */
  221:         (void) __mach_port_extract_right(mach_task_self(), port,
  222:                                          MACH_MSG_TYPE_MAKE_SEND_ONCE,
  223:                                          &port, &type);
  224:         (void) __mach_port_deallocate(mach_task_self(), port);
  225:         break;
  226:     }
  227: }
  228: 
  229: static void
  230: mach_msg_destroy_memory(addr, size)
  231:     vm_offset_t addr;
  232:     vm_size_t size;
  233: {
  234:     if (size > 0)
  235:         (void) __vm_deallocate(__mach_task_self(), addr, size);
  236: }