[apple/system_cmds.git] / mach_init.tproj / testServer / testServer.c

/*
 * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * "Portions Copyright (c) 1999 Apple Computer, Inc.  All Rights
 * Reserved.  This file contains Original Code and/or Modifications of
 * Original Code as defined in and that are subject to the Apple Public
 * Source License Version 1.0 (the 'License').  You may not use this file
 * except in compliance with the License.  Please obtain a copy of the
 * License at http://www.apple.com/publicsource and read it before using
 * this file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License."
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
#import "bootstrap.h"

#import <mach.h>
#import <stdarg.h>
#import <stdio.h>
#import <sys/boolean.h>

#define	NELEM(x)	(sizeof(x)/sizeof(x[0]))
#define	LAST_ELEMENT(x)	((x)[NELEM(x)-1])

print(const char *format, ...)
{
	va_list ap;
	
	va_start(ap, format);
	vfprintf(stderr, format, ap);
	fprintf(stderr, "\n");
	va_end(ap);
}

error(const char *format, ...)
{
	va_list ap;
	
	va_start(ap, format);
	fprintf(stderr, "ERROR: ");
	vfprintf(stderr, format, ap);
	fprintf(stderr, "\n");
	va_end(ap);
}


main()
{
	kern_return_t result;
	port_t bootstrap_port, port, myport;
	port_type_t ptype;
	port_t *mach_ports;
	port_t *ports;
	unsigned port_cnt;
	unsigned mach_ports_cnt;
	name_t name_array[4];
	boolean_t all_known;
	port_t unpriv_port;
	port_t subset_port;
	port_t sub_reg_port;
	boolean_t active;
	name_array_t service_names;
	unsigned service_cnt, server_cnt, service_active_cnt;
	name_array_t server_names;
	boolean_t *service_actives;
	int i;
	
	print("test server running");
	result = task_get_bootstrap_port(task_self(), &bootstrap_port);
	if (result != KERN_SUCCESS) {
		error("Couldn't get bootstrap port: %d", result);
		exit(1);
	} else
		print("Bootstrap port is %d", bootstrap_port);
	if (bootstrap_port == PORT_NULL) {
		error("Invalid bootstrap port");
		exit(1);
	}
	
	/*
	 * Try a checkin
	 */
	print("Checkin test 1");
	result = bootstrap_check_in(bootstrap_port, "FreeService1", &port);
	if (result != BOOTSTRAP_SUCCESS)
		error("Checkin failed: %d", result);
	else {
		result = port_type(task_self(), port, &ptype);
		if (result != KERN_SUCCESS)
			error("port type failed: %d", result);
		else
			print("Checkin returned port type 0x%x", ptype);
		/*
		 * Try a status request
		 */
		result = bootstrap_status(bootstrap_port, "FreeService1", &active);
		if (result != BOOTSTRAP_SUCCESS)
			error("Status failed: %d", result);
		else if (active != TRUE)
			error("Service shown inactive");
	}
	
	/*
	 * Try a lookup
	 */
	print("lookup test");
	result = bootstrap_look_up(bootstrap_port, "FreeService2", &port);
	if (result != BOOTSTRAP_SUCCESS)
		error("lookup failed: %d", result);
	else {
		result = port_type(task_self(), port, &ptype);
		if (result != KERN_SUCCESS)
			error("port type failed: %d", result);
		else
			print("Lookup returned port type 0x%x", ptype);
		/*
		 * Try a status request
		 */
		result = bootstrap_status(bootstrap_port, "FreeService2", &active);
		if (result != BOOTSTRAP_SUCCESS)
			error("Status failed: %d", result);
		else if (active != FALSE)
			error("Service shown active");
	}
	
	/*
	 * Test that mach ports are initialized
	 */
	print("mach ports test");
	result = mach_ports_lookup(task_self(), &mach_ports, &mach_ports_cnt);
	if (result != KERN_SUCCESS)
		error("mach_ports_lookup failed: %d", result);
	else {
		result = bootstrap_look_up(bootstrap_port, "NetMsgService", &port);
		if (result != BOOTSTRAP_SUCCESS)
			error("Lookup of NetMsgService failed: %d", result);
		else if (port != mach_ports[0])
			error("mach ports not setup correctly for NetMsgService");
		
		result = bootstrap_look_up(bootstrap_port, "EnvironService", &port);
		if (result != BOOTSTRAP_SUCCESS)
			error("Lookup of EnvironService failed: %d", result);
		else if (port != mach_ports[1])
			error("mach ports not setup correctly for EnvironService");

		result = bootstrap_look_up(bootstrap_port, "Service", &port);
		if (result != BOOTSTRAP_SUCCESS)
			error("Lookup of Service failed: %d", result);
		else if (port != mach_ports[2])
			error("mach ports not setup correctly for Service");
			
		result = bootstrap_look_up(bootstrap_port, "WindowService", &port);
		if (result != BOOTSTRAP_SUCCESS)
			error("Lookup of WindowService failed: %d", result);
		else if (port != mach_ports[3])
			error("mach ports not setup correctly for WindowService");
	}
	
	/*
	 * Try doing a checkin with the old service interface
	 */
	result = service_checkin(mach_ports[2], mach_ports[1], &myport);
	if (result != KERN_SUCCESS)
		error("service checkin failed: %d", result);
	else {
		result = port_type(task_self(), myport, &ptype);
		if (result != KERN_SUCCESS)
			error("port type failed: %d", result);
		else
			print("Checkin returned port type 0x%x", ptype);
	}
	
	/*
	 * Try a register
	 */
	print("register test");
	print("...Dynamic creation");
	result = port_allocate(task_self(), &myport);
	if (result != KERN_SUCCESS)
		error("couldn't allocate port: %d", result);
	else {
		result = bootstrap_register(bootstrap_port, "NewService", myport);
		if (result != BOOTSTRAP_SUCCESS)
			error("Couldn't register port: %d", result);
		else {
	
			/*
			 * Try a lookup on just registered port
			 */
			result = bootstrap_look_up(bootstrap_port, "NewService", &port);
			if (result != BOOTSTRAP_SUCCESS)
				error("lookup failed: %d", result);
			else {
				result = port_type(task_self(), port, &ptype);
				if (result != KERN_SUCCESS)
					error("port type failed: %d", result);
				else {
					print("Lookup returned port type 0x%x", ptype);
					if (port != myport)
						error("lookup didn't match register");
				}
			}
			
			/*
			 * Try re-registering service name
			 */
			result = bootstrap_register(bootstrap_port, "NewService", myport);
			if (result != BOOTSTRAP_SERVICE_ACTIVE)
				error("Unexpected register response: %d", result);

			/*
			 * Delete the port.  This should cause the service to go away
			 * in the server.
			 */
			port_deallocate(task_self(), myport);
			
			result = bootstrap_look_up(bootstrap_port, "NewService", &port);
			if (result != BOOTSTRAP_UNKNOWN_SERVICE)
				error("service active after port deleted");
		}
	}

	print("...Declared service");
	result = port_allocate(task_self(), &myport);
	if (result != KERN_SUCCESS)
		error("couldn't allocate port: %d", result);
	else {
		result = bootstrap_register(bootstrap_port, "FreeService2", myport);
		if (result != BOOTSTRAP_SUCCESS)
			error("Couldn't register port: %d", result);
		else {
	
			/*
			 * Try a lookup on just registered port
			 */
			result = bootstrap_look_up(bootstrap_port, "FreeService2", &port);
			if (result != BOOTSTRAP_SUCCESS)
				error("lookup failed: %d", result);
			else {
				result = port_type(task_self(), port, &ptype);
				if (result != KERN_SUCCESS)
					error("port type failed: %d", result);
				else {
					print("Lookup returned port type 0x%x", ptype);
					if (port != myport)
						error("lookup didn't match register");
				}
			}
			
			/*
			 * Delete the port.  This should cause service to revert.
			 */
			port_deallocate(task_self(), myport);
			
			result = bootstrap_status(bootstrap_port, "FreeService2", &active);
			if (result != BOOTSTRAP_SUCCESS)
				error("Status failed: %d", result);
			else if (active != FALSE)
				error("Service shown active");
		}
	}

	/*
	 * Try a checkin on a port bound to Terminal server
	 */
	print("Bound checkin test -- Terminal");
	result = bootstrap_check_in(bootstrap_port, "TerminalService", &port);
	if (result != BOOTSTRAP_SUCCESS)
		error("Checkin of TerminalService failed: %d", result);
	else {
		result = port_type(task_self(), port, &ptype);
		if (result != KERN_SUCCESS)
			error("port type failed: %d", result);
		print("Checkin returned port type 0x%x", ptype);
	}

	/*
	 * Try a checkin on a port bound to Sleep server
	 */
	print("Bound checkin test -- Sleep");
	result = bootstrap_check_in(bootstrap_port, "SleepService", &port);
	if (result != BOOTSTRAP_SUCCESS)
		print("Checkin of SleepService failed (as expected): %d",
			result);
	else {
		result = port_type(task_self(), port, &ptype);
		if (result != KERN_SUCCESS)
			error("port type failed: %d", result);
		error("Checkin returned port type 0x%x(didn't fail!)", ptype);
	}

	/*
	 * Try a lookup_array
	 */
	print("Lookup array test");
	
	strncpy(&name_array[0], "NetMsgService", sizeof(name_array[0]));
	LAST_ELEMENT(name_array[0]) = '\0';
	strncpy(&name_array[1], "EnvironService", sizeof(name_array[1]));
	LAST_ELEMENT(name_array[1]) = '\0';
	strncpy(&name_array[2], "Service", sizeof(name_array[2]));
	LAST_ELEMENT(name_array[2]) = '\0';
	strncpy(&name_array[3], "WindowService", sizeof(name_array[3]));
	LAST_ELEMENT(name_array[3]) = '\0';
	
	result = bootstrap_look_up_array(bootstrap_port, name_array, 4, &ports,
	 &port_cnt, &all_known);
	if (result != BOOTSTRAP_SUCCESS)
		error("Lookup array failed: %d", result);
	else {
		print("Port count = %d, all known = %d", port_cnt, all_known);
		for (i = 0; i < 4; i++)
			if (ports[i] != mach_ports[i])
				error("port mismatch on port %d", i);
	}
	
	/*
	 * Get an unprivileged port
	 */
	print("Unprivileged port test");
	result = port_allocate(task_self(), &myport);
	result = bootstrap_get_unpriv_port(bootstrap_port, &unpriv_port);
	if (result != BOOTSTRAP_SUCCESS)
		error("Couldn't get unpriv port: %d", result);
	else {
		/*
		 * Try doing an unpriv operation
		 */
		result = bootstrap_look_up(unpriv_port, "FreeService2", &port);
		if (result != BOOTSTRAP_SUCCESS)
			error("lookup failed: %d", result);
		/*
		 * Try doing a privileged operation
		 */
		result = bootstrap_register(unpriv_port, "ANewService", myport);
		if (result != BOOTSTRAP_NOT_PRIVILEGED)
			error("Unexpected register port response: %d", result);

		/*
		 * Try creating a subset port.
		 */
		result = bootstrap_subset(unpriv_port, task_self(),
			&subset_port);
		if (result != BOOTSTRAP_SUCCESS)
			error("Couldn't get subset port from unpriv %d",
				result);
	}

	/*
	 * Get a subset port.
	 */
	print("Subset port test");
	result = bootstrap_subset(bootstrap_port, task_self(), &subset_port);
	if (result != BOOTSTRAP_SUCCESS)
		error("Couldn't get subset port: %d", result);
	else {

		/*
		 * Register a port.
		 */
		result = port_allocate(task_self(), &sub_reg_port);
		if (result != KERN_SUCCESS)
			error("port_allocate of sub_reg_port failed %d",
				result);
		result = bootstrap_register(subset_port, "SubsetReg",
					    sub_reg_port);
		if (result != BOOTSTRAP_SUCCESS)
			error("register of SubsetReg failed on subset port %d",
				result);
		/*
		 * Check that port registered only in subset.
		 */
		result = bootstrap_status(bootstrap_port, "SubsetReg",
					&active);
		if (result != BOOTSTRAP_UNKNOWN_SERVICE)
			error("status of SubsetReg  ok on bootstrap! %d",
				result);
		result = bootstrap_status(subset_port, "SubsetReg",
					&active);
		if (result != BOOTSTRAP_SUCCESS)
			error("status of SubsetReg failed on subset port %d",
				result);
		if (!active)
			error("SubsetReg isn't active");


		/*
		 * Try an info request.
		 */
		print("Subset info request");
		result = bootstrap_info(subset_port, &service_names,
			&service_cnt,
			&server_names, &server_cnt, &service_actives,
			&service_active_cnt);
		if (result != BOOTSTRAP_SUCCESS)
			error("info failed: %d", result);
		else {
			for (i = 0; i < service_cnt; i++)
				print("Name: %s	Server: %s	Active: %s",
				    service_names[i],
				    server_names[i][0] == '\0'
				     ? "Unknown"
				     : server_names[i],
				    service_actives[i] ? "Yes" : "No");
		}
	}

	/*
	 * Try an info request
	 */
	print("Info test");
	result = bootstrap_info(bootstrap_port, &service_names, &service_cnt,
	  &server_names, &server_cnt, &service_actives, &service_active_cnt);
	if (result != BOOTSTRAP_SUCCESS)
		error("info failed: %d", result);
	else {
		for (i = 0; i < service_cnt; i++)
			print("Name: %s	Server: %s	Active: %s", service_names[i],
			 server_names[i][0] == '\0' ? "Unknown" : server_names[i],
			 service_actives[i] ? "Yes" : "No");
	}
		
	exit(0);
}
Commit	Line	Data
1815bff5 A	1	/*
	2	* Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* "Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
	7	* Reserved. This file contains Original Code and/or Modifications of
	8	* Original Code as defined in and that are subject to the Apple Public
	9	* Source License Version 1.0 (the 'License'). You may not use this file
	10	* except in compliance with the License. Please obtain a copy of the
	11	* License at http://www.apple.com/publicsource and read it before using
	12	* this file.
	13	*
	14	* The Original Code and all software distributed under the License are
	15	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	16	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	17	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	19	* License for the specific language governing rights and limitations
	20	* under the License."
	21	*
	22	* @APPLE_LICENSE_HEADER_END@
	23	*/
	24	#import "bootstrap.h"
	25
	26	#import <mach.h>
	27	#import <stdarg.h>
	28	#import <stdio.h>
	29	#import <sys/boolean.h>
	30
	31	#define NELEM(x) (sizeof(x)/sizeof(x[0]))
	32	#define LAST_ELEMENT(x) ((x)[NELEM(x)-1])
	33
	34	print(const char *format, ...)
	35	{
	36	va_list ap;
	37
	38	va_start(ap, format);
	39	vfprintf(stderr, format, ap);
	40	fprintf(stderr, "\n");
	41	va_end(ap);
	42	}
	43
	44	error(const char *format, ...)
	45	{
	46	va_list ap;
	47
	48	va_start(ap, format);
	49	fprintf(stderr, "ERROR: ");
	50	vfprintf(stderr, format, ap);
	51	fprintf(stderr, "\n");
	52	va_end(ap);
	53	}
	54
	55
	56	main()
	57	{
	58	kern_return_t result;
	59	port_t bootstrap_port, port, myport;
	60	port_type_t ptype;
	61	port_t *mach_ports;
	62	port_t *ports;
	63	unsigned port_cnt;
	64	unsigned mach_ports_cnt;
65	name_t name_array[4];
66	boolean_t all_known;
67	port_t unpriv_port;
68	port_t subset_port;
69	port_t sub_reg_port;
70	boolean_t active;
71	name_array_t service_names;
72	unsigned service_cnt, server_cnt, service_active_cnt;
73	name_array_t server_names;
74	boolean_t *service_actives;
75	int i;
76
77	print("test server running");
78	result = task_get_bootstrap_port(task_self(), &bootstrap_port);
79	if (result != KERN_SUCCESS) {
80	error("Couldn't get bootstrap port: %d", result);
81	exit(1);
82	} else
83	print("Bootstrap port is %d", bootstrap_port);
84	if (bootstrap_port == PORT_NULL) {
85	error("Invalid bootstrap port");
86	exit(1);
87	}
88
89	/*
90	* Try a checkin
91	*/
92	print("Checkin test 1");
93	result = bootstrap_check_in(bootstrap_port, "FreeService1", &port);
94	if (result != BOOTSTRAP_SUCCESS)
95	error("Checkin failed: %d", result);
96	else {
97	result = port_type(task_self(), port, &ptype);
98	if (result != KERN_SUCCESS)
99	error("port type failed: %d", result);
100	else
101	print("Checkin returned port type 0x%x", ptype);
102	/*
103	* Try a status request
104	*/
105	result = bootstrap_status(bootstrap_port, "FreeService1", &active);
106	if (result != BOOTSTRAP_SUCCESS)
107	error("Status failed: %d", result);
108	else if (active != TRUE)
109	error("Service shown inactive");
110	}
111
112	/*
113	* Try a lookup
114	*/
115	print("lookup test");
116	result = bootstrap_look_up(bootstrap_port, "FreeService2", &port);
117	if (result != BOOTSTRAP_SUCCESS)
118	error("lookup failed: %d", result);
119	else {
120	result = port_type(task_self(), port, &ptype);
121	if (result != KERN_SUCCESS)
122	error("port type failed: %d", result);
123	else
124	print("Lookup returned port type 0x%x", ptype);
125	/*
126	* Try a status request
127	*/
128	result = bootstrap_status(bootstrap_port, "FreeService2", &active);
129	if (result != BOOTSTRAP_SUCCESS)
130	error("Status failed: %d", result);
131	else if (active != FALSE)
132	error("Service shown active");
133	}
134
135	/*
136	* Test that mach ports are initialized
137	*/
138	print("mach ports test");
139	result = mach_ports_lookup(task_self(), &mach_ports, &mach_ports_cnt);
140	if (result != KERN_SUCCESS)
141	error("mach_ports_lookup failed: %d", result);
142	else {
143	result = bootstrap_look_up(bootstrap_port, "NetMsgService", &port);
144	if (result != BOOTSTRAP_SUCCESS)
145	error("Lookup of NetMsgService failed: %d", result);
146	else if (port != mach_ports[0])
147	error("mach ports not setup correctly for NetMsgService");
148
149	result = bootstrap_look_up(bootstrap_port, "EnvironService", &port);
150	if (result != BOOTSTRAP_SUCCESS)
151	error("Lookup of EnvironService failed: %d", result);
152	else if (port != mach_ports[1])
153	error("mach ports not setup correctly for EnvironService");
154
155	result = bootstrap_look_up(bootstrap_port, "Service", &port);
156	if (result != BOOTSTRAP_SUCCESS)
157	error("Lookup of Service failed: %d", result);
158	else if (port != mach_ports[2])
159	error("mach ports not setup correctly for Service");
160
161	result = bootstrap_look_up(bootstrap_port, "WindowService", &port);
162	if (result != BOOTSTRAP_SUCCESS)
163	error("Lookup of WindowService failed: %d", result);
164	else if (port != mach_ports[3])
165	error("mach ports not setup correctly for WindowService");
166	}
167
168	/*
169	* Try doing a checkin with the old service interface
170	*/
171	result = service_checkin(mach_ports[2], mach_ports[1], &myport);
172	if (result != KERN_SUCCESS)
173	error("service checkin failed: %d", result);
174	else {
175	result = port_type(task_self(), myport, &ptype);
176	if (result != KERN_SUCCESS)
177	error("port type failed: %d", result);
178	else
179	print("Checkin returned port type 0x%x", ptype);
180	}
181
182	/*
183	* Try a register
184	*/
185	print("register test");
186	print("...Dynamic creation");
187	result = port_allocate(task_self(), &myport);
188	if (result != KERN_SUCCESS)
189	error("couldn't allocate port: %d", result);
190	else {
191	result = bootstrap_register(bootstrap_port, "NewService", myport);
192	if (result != BOOTSTRAP_SUCCESS)
193	error("Couldn't register port: %d", result);
194	else {
195
196	/*
197	* Try a lookup on just registered port
198	*/
199	result = bootstrap_look_up(bootstrap_port, "NewService", &port);
200	if (result != BOOTSTRAP_SUCCESS)
201	error("lookup failed: %d", result);
202	else {
203	result = port_type(task_self(), port, &ptype);
204	if (result != KERN_SUCCESS)
205	error("port type failed: %d", result);
206	else {
207	print("Lookup returned port type 0x%x", ptype);
208	if (port != myport)
209	error("lookup didn't match register");
210	}
211	}
212
213	/*
214	* Try re-registering service name
215	*/
216	result = bootstrap_register(bootstrap_port, "NewService", myport);
217	if (result != BOOTSTRAP_SERVICE_ACTIVE)
218	error("Unexpected register response: %d", result);
219
220	/*
221	* Delete the port. This should cause the service to go away
222	* in the server.
223	*/
224	port_deallocate(task_self(), myport);
225
226	result = bootstrap_look_up(bootstrap_port, "NewService", &port);
227	if (result != BOOTSTRAP_UNKNOWN_SERVICE)
228	error("service active after port deleted");
229	}
230	}
231
232	print("...Declared service");
233	result = port_allocate(task_self(), &myport);
234	if (result != KERN_SUCCESS)
235	error("couldn't allocate port: %d", result);
236	else {
237	result = bootstrap_register(bootstrap_port, "FreeService2", myport);
238	if (result != BOOTSTRAP_SUCCESS)
239	error("Couldn't register port: %d", result);
240	else {
241
242	/*
243	* Try a lookup on just registered port
244	*/
245	result = bootstrap_look_up(bootstrap_port, "FreeService2", &port);
246	if (result != BOOTSTRAP_SUCCESS)
247	error("lookup failed: %d", result);
248	else {
249	result = port_type(task_self(), port, &ptype);
250	if (result != KERN_SUCCESS)
251	error("port type failed: %d", result);
252	else {
253	print("Lookup returned port type 0x%x", ptype);
254	if (port != myport)
255	error("lookup didn't match register");
256	}
257	}
258
259	/*
260	* Delete the port. This should cause service to revert.
261	*/
262	port_deallocate(task_self(), myport);
263
264	result = bootstrap_status(bootstrap_port, "FreeService2", &active);
265	if (result != BOOTSTRAP_SUCCESS)
266	error("Status failed: %d", result);
267	else if (active != FALSE)
268	error("Service shown active");
269	}
270	}
271
272	/*
273	* Try a checkin on a port bound to Terminal server
274	*/
275	print("Bound checkin test -- Terminal");
276	result = bootstrap_check_in(bootstrap_port, "TerminalService", &port);
277	if (result != BOOTSTRAP_SUCCESS)
278	error("Checkin of TerminalService failed: %d", result);
279	else {
280	result = port_type(task_self(), port, &ptype);
281	if (result != KERN_SUCCESS)
282	error("port type failed: %d", result);
283	print("Checkin returned port type 0x%x", ptype);
284	}
285
286	/*
287	* Try a checkin on a port bound to Sleep server
288	*/
289	print("Bound checkin test -- Sleep");
290	result = bootstrap_check_in(bootstrap_port, "SleepService", &port);
291	if (result != BOOTSTRAP_SUCCESS)
292	print("Checkin of SleepService failed (as expected): %d",
293	result);
294	else {
295	result = port_type(task_self(), port, &ptype);
296	if (result != KERN_SUCCESS)
297	error("port type failed: %d", result);
298	error("Checkin returned port type 0x%x(didn't fail!)", ptype);
299	}
300
301	/*
302	* Try a lookup_array
303	*/
304	print("Lookup array test");
305
306	strncpy(&name_array[0], "NetMsgService", sizeof(name_array[0]));
307	LAST_ELEMENT(name_array[0]) = '\0';
308	strncpy(&name_array[1], "EnvironService", sizeof(name_array[1]));
309	LAST_ELEMENT(name_array[1]) = '\0';
310	strncpy(&name_array[2], "Service", sizeof(name_array[2]));
311	LAST_ELEMENT(name_array[2]) = '\0';
312	strncpy(&name_array[3], "WindowService", sizeof(name_array[3]));
313	LAST_ELEMENT(name_array[3]) = '\0';
314
315	result = bootstrap_look_up_array(bootstrap_port, name_array, 4, &ports,
316	&port_cnt, &all_known);
317	if (result != BOOTSTRAP_SUCCESS)
318	error("Lookup array failed: %d", result);
319	else {
320	print("Port count = %d, all known = %d", port_cnt, all_known);
321	for (i = 0; i < 4; i++)
322	if (ports[i] != mach_ports[i])
323	error("port mismatch on port %d", i);
324	}
325
326	/*
327	* Get an unprivileged port
328	*/
329	print("Unprivileged port test");
330	result = port_allocate(task_self(), &myport);
331	result = bootstrap_get_unpriv_port(bootstrap_port, &unpriv_port);
332	if (result != BOOTSTRAP_SUCCESS)
333	error("Couldn't get unpriv port: %d", result);
334	else {
335	/*
336	* Try doing an unpriv operation
337	*/
338	result = bootstrap_look_up(unpriv_port, "FreeService2", &port);
339	if (result != BOOTSTRAP_SUCCESS)
340	error("lookup failed: %d", result);
341	/*
342	* Try doing a privileged operation
343	*/
344	result = bootstrap_register(unpriv_port, "ANewService", myport);
345	if (result != BOOTSTRAP_NOT_PRIVILEGED)
346	error("Unexpected register port response: %d", result);
347
348	/*
349	* Try creating a subset port.
350	*/
351	result = bootstrap_subset(unpriv_port, task_self(),
352	&subset_port);
353	if (result != BOOTSTRAP_SUCCESS)
354	error("Couldn't get subset port from unpriv %d",
355	result);
356	}
357
358	/*
359	* Get a subset port.
360	*/
361	print("Subset port test");
362	result = bootstrap_subset(bootstrap_port, task_self(), &subset_port);
363	if (result != BOOTSTRAP_SUCCESS)
364	error("Couldn't get subset port: %d", result);
365	else {
366
367	/*
368	* Register a port.
369	*/
370	result = port_allocate(task_self(), &sub_reg_port);
371	if (result != KERN_SUCCESS)
372	error("port_allocate of sub_reg_port failed %d",
373	result);
374	result = bootstrap_register(subset_port, "SubsetReg",
375	sub_reg_port);
376	if (result != BOOTSTRAP_SUCCESS)
377	error("register of SubsetReg failed on subset port %d",
378	result);
379	/*
380	* Check that port registered only in subset.
381	*/
382	result = bootstrap_status(bootstrap_port, "SubsetReg",
383	&active);
384	if (result != BOOTSTRAP_UNKNOWN_SERVICE)
385	error("status of SubsetReg ok on bootstrap! %d",
386	result);
387	result = bootstrap_status(subset_port, "SubsetReg",
388	&active);
389	if (result != BOOTSTRAP_SUCCESS)
390	error("status of SubsetReg failed on subset port %d",
391	result);
392	if (!active)
393	error("SubsetReg isn't active");
394
395
396	/*
397	* Try an info request.
398	*/
399	print("Subset info request");
400	result = bootstrap_info(subset_port, &service_names,
401	&service_cnt,
402	&server_names, &server_cnt, &service_actives,
403	&service_active_cnt);
404	if (result != BOOTSTRAP_SUCCESS)
405	error("info failed: %d", result);
406	else {
407	for (i = 0; i < service_cnt; i++)
408	print("Name: %s Server: %s Active: %s",
409	service_names[i],
410	server_names[i][0] == '\0'
411	? "Unknown"
412	: server_names[i],
413	service_actives[i] ? "Yes" : "No");
414	}
415	}
416
417	/*
418	* Try an info request
419	*/
420	print("Info test");
421	result = bootstrap_info(bootstrap_port, &service_names, &service_cnt,
422	&server_names, &server_cnt, &service_actives, &service_active_cnt);
423	if (result != BOOTSTRAP_SUCCESS)
424	error("info failed: %d", result);
425	else {
426	for (i = 0; i < service_cnt; i++)
427	print("Name: %s Server: %s Active: %s", service_names[i],
428	server_names[i][0] == '\0' ? "Unknown" : server_names[i],
429	service_actives[i] ? "Yes" : "No");
430	}
431
432	exit(0);
433	}
434
435
436