fdwalk should return 0 on an empty directory
[kopensolaris-gnu/glibc.git] / mach / msg-destroy.c
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 }