1/* iig(DriverKit-286 Mar 29 2024 10:27:09) generated from IOUserServer.iig */
2
3#undef IIG_IMPLEMENTATION
4#define IIG_IMPLEMENTATION IOUserServer.iig
5
6#if KERNEL
7#include <libkern/c++/OSString.h>
8#else
9#include <DriverKit/DriverKit.h>
10#endif /* KERNEL */
11#include <DriverKit/IOReturn.h>
12#include <DriverKit/IOUserServer.h>
13
14/* @iig implementation */
15#include <IOKit/IOUserServer.h>
16/* @iig end */
17
18
19#if __has_builtin(__builtin_load_member_function_pointer)
20#define SimpleMemberFunctionCast(cfnty, self, func) (cfnty)__builtin_load_member_function_pointer(self, func)
21#else
22#define SimpleMemberFunctionCast(cfnty, self, func) ({ union { typeof(func) memfun; cfnty cfun; } pair; pair.memfun = func; pair.cfun; })
23#endif
24
25
26struct IOUserServer_Create_Msg_Content
27{
28 IORPCMessage __hdr;
29 OSObjectRef __object;
30 OSString * bundleID;
31#if !defined(__LP64__)
32 uint32_t __bundleIDPad;
33#endif /* !defined(__LP64__) */
34 const char * name;
35#if !defined(__LP64__)
36 uint32_t __namePad;
37#endif /* !defined(__LP64__) */
38 char __name[64];
39 uint64_t tag;
40 uint64_t options;
41};
42#pragma pack(4)
43struct IOUserServer_Create_Msg
44{
45 IORPCMessageMach mach;
46 mach_msg_port_descriptor_t __object__descriptor;
47 mach_msg_ool_descriptor_t bundleID__descriptor;
48 IOUserServer_Create_Msg_Content content;
49};
50#pragma pack()
51#define IOUserServer_Create_Msg_ObjRefs (2)
52
53struct IOUserServer_Create_Rpl_Content
54{
55 IORPCMessage __hdr;
56 OSObjectRef server;
57};
58#pragma pack(4)
59struct IOUserServer_Create_Rpl
60{
61 IORPCMessageMach mach;
62 mach_msg_port_descriptor_t server__descriptor;
63 IOUserServer_Create_Rpl_Content content;
64};
65#pragma pack()
66#define IOUserServer_Create_Rpl_ObjRefs (1)
67
68
69typedef union
70{
71 const IORPC rpc;
72 struct
73 {
74 const struct IOUserServer_Create_Msg * message;
75 struct IOUserServer_Create_Rpl * reply;
76 uint32_t sendSize;
77 uint32_t replySize;
78 };
79}
80IOUserServer_Create_Invocation;
81struct IOUserServer_Exit_Msg_Content
82{
83 IORPCMessage __hdr;
84 OSObjectRef __object;
85 const char * reason;
86#if !defined(__LP64__)
87 uint32_t __reasonPad;
88#endif /* !defined(__LP64__) */
89 char __reason[1024];
90};
91#pragma pack(4)
92struct IOUserServer_Exit_Msg
93{
94 IORPCMessageMach mach;
95 mach_msg_port_descriptor_t __object__descriptor;
96 IOUserServer_Exit_Msg_Content content;
97};
98#pragma pack()
99#define IOUserServer_Exit_Msg_ObjRefs (1)
100
101struct IOUserServer_Exit_Rpl_Content
102{
103 IORPCMessage __hdr;
104};
105#pragma pack(4)
106struct IOUserServer_Exit_Rpl
107{
108 IORPCMessageMach mach;
109 IOUserServer_Exit_Rpl_Content content;
110};
111#pragma pack()
112#define IOUserServer_Exit_Rpl_ObjRefs (0)
113
114
115typedef union
116{
117 const IORPC rpc;
118 struct
119 {
120 const struct IOUserServer_Exit_Msg * message;
121 struct IOUserServer_Exit_Rpl * reply;
122 uint32_t sendSize;
123 uint32_t replySize;
124 };
125}
126IOUserServer_Exit_Invocation;
127struct IOUserServer_LoadModule_Msg_Content
128{
129 IORPCMessage __hdr;
130 OSObjectRef __object;
131 const char * path;
132#if !defined(__LP64__)
133 uint32_t __pathPad;
134#endif /* !defined(__LP64__) */
135 char __path[1024];
136};
137#pragma pack(4)
138struct IOUserServer_LoadModule_Msg
139{
140 IORPCMessageMach mach;
141 mach_msg_port_descriptor_t __object__descriptor;
142 IOUserServer_LoadModule_Msg_Content content;
143};
144#pragma pack()
145#define IOUserServer_LoadModule_Msg_ObjRefs (1)
146
147struct IOUserServer_LoadModule_Rpl_Content
148{
149 IORPCMessage __hdr;
150};
151#pragma pack(4)
152struct IOUserServer_LoadModule_Rpl
153{
154 IORPCMessageMach mach;
155 IOUserServer_LoadModule_Rpl_Content content;
156};
157#pragma pack()
158#define IOUserServer_LoadModule_Rpl_ObjRefs (0)
159
160
161typedef union
162{
163 const IORPC rpc;
164 struct
165 {
166 const struct IOUserServer_LoadModule_Msg * message;
167 struct IOUserServer_LoadModule_Rpl * reply;
168 uint32_t sendSize;
169 uint32_t replySize;
170 };
171}
172IOUserServer_LoadModule_Invocation;
173#if !KERNEL
174extern OSMetaClass * gOSContainerMetaClass;
175extern OSMetaClass * gOSDataMetaClass;
176extern OSMetaClass * gOSNumberMetaClass;
177extern OSMetaClass * gOSBooleanMetaClass;
178extern OSMetaClass * gOSDictionaryMetaClass;
179extern OSMetaClass * gOSArrayMetaClass;
180extern OSMetaClass * gOSSetMetaClass;
181extern OSMetaClass * gOSOrderedSetMetaClass;
182extern OSMetaClass * gIODispatchQueueMetaClass;
183extern OSMetaClass * gOSStringMetaClass;
184extern OSMetaClass * gIOMemoryDescriptorMetaClass;
185extern OSMetaClass * gIOBufferMemoryDescriptorMetaClass;
186extern OSMetaClass * gIOUserClientMetaClass;
187extern OSMetaClass * gIOServiceStateNotificationDispatchSourceMetaClass;
188#endif /* !KERNEL */
189
190#if !KERNEL
191
192#define IOUserServer_QueueNames ""
193
194#define IOUserServer_MethodNames ""
195
196#define IOUserServerMetaClass_MethodNames ""
197
198struct OSClassDescription_IOUserServer_t
199{
200 OSClassDescription base;
201 uint64_t methodOptions[2 * 0];
202 uint64_t metaMethodOptions[2 * 0];
203 char queueNames[sizeof(IOUserServer_QueueNames)];
204 char methodNames[sizeof(IOUserServer_MethodNames)];
205 char metaMethodNames[sizeof(IOUserServerMetaClass_MethodNames)];
206};
207
208const struct OSClassDescription_IOUserServer_t
209OSClassDescription_IOUserServer =
210{
211 .base =
212 {
213 .descriptionSize = sizeof(OSClassDescription_IOUserServer_t),
214 .name = "IOUserServer",
215 .superName = "IOService",
216 .methodOptionsSize = 2 * sizeof(uint64_t) * 0,
217 .methodOptionsOffset = __builtin_offsetof(struct OSClassDescription_IOUserServer_t, methodOptions),
218 .metaMethodOptionsSize = 2 * sizeof(uint64_t) * 0,
219 .metaMethodOptionsOffset = __builtin_offsetof(struct OSClassDescription_IOUserServer_t, metaMethodOptions),
220 .queueNamesSize = sizeof(IOUserServer_QueueNames),
221 .queueNamesOffset = __builtin_offsetof(struct OSClassDescription_IOUserServer_t, queueNames),
222 .methodNamesSize = sizeof(IOUserServer_MethodNames),
223 .methodNamesOffset = __builtin_offsetof(struct OSClassDescription_IOUserServer_t, methodNames),
224 .metaMethodNamesSize = sizeof(IOUserServerMetaClass_MethodNames),
225 .metaMethodNamesOffset = __builtin_offsetof(struct OSClassDescription_IOUserServer_t, metaMethodNames),
226 .flags = 1*kOSClassCanRemote,
227 },
228 .methodOptions =
229 {
230 },
231 .metaMethodOptions =
232 {
233 },
234 .queueNames = IOUserServer_QueueNames,
235 .methodNames = IOUserServer_MethodNames,
236 .metaMethodNames = IOUserServerMetaClass_MethodNames,
237};
238
239OSMetaClass * gIOUserServerMetaClass;
240
241static kern_return_t
242IOUserServer_New(OSMetaClass * instance);
243
244const OSClassLoadInformation
245IOUserServer_Class =
246{
247 .description = &OSClassDescription_IOUserServer.base,
248 .metaPointer = &gIOUserServerMetaClass,
249 .version = 1,
250 .instanceSize = sizeof(IOUserServer),
251
252 .New = &IOUserServer_New,
253};
254
255extern const void * const
256gIOUserServer_Declaration;
257const void * const
258gIOUserServer_Declaration
259__attribute__((visibility("hidden"),section("__DATA_CONST,__osclassinfo,regular,no_dead_strip"),no_sanitize("address")))
260 = &IOUserServer_Class;
261
262static kern_return_t
263IOUserServer_New(OSMetaClass * instance)
264{
265 if (!new(instance) IOUserServerMetaClass) return (kIOReturnNoMemory);
266 return (kIOReturnSuccess);
267}
268
269kern_return_t
270IOUserServerMetaClass::New(OSObject * instance)
271{
272 if (!new(instance) IOUserServer) return (kIOReturnNoMemory);
273 return (kIOReturnSuccess);
274}
275
276#endif /* !KERNEL */
277
278kern_return_t
279IOUserServer::Dispatch(const IORPC rpc)
280{
281 return _Dispatch(self: this, rpc);
282}
283
284kern_return_t
285IOUserServer::_Dispatch(IOUserServer * self, const IORPC rpc)
286{
287 kern_return_t ret = kIOReturnUnsupported;
288 IORPCMessage * msg = IORPCMessageFromMach(msg: rpc.message, reply: false);
289
290 switch (msg->msgid)
291 {
292 case IOUserServer_Exit_ID:
293 {
294 ret = IOUserServer::Exit_Invoke(rpc, target: self, SimpleMemberFunctionCast(IOUserServer::Exit_Handler, *self, &IOUserServer::Exit_Impl));
295 break;
296 }
297 case IOUserServer_LoadModule_ID:
298 {
299 ret = IOUserServer::LoadModule_Invoke(rpc, target: self, SimpleMemberFunctionCast(IOUserServer::LoadModule_Handler, *self, &IOUserServer::LoadModule_Impl));
300 break;
301 }
302#if KERNEL
303 case IOService_RegisterService_ID:
304 {
305 ret = IOService::RegisterService_Invoke(rpc, target: self, SimpleMemberFunctionCast(IOService::RegisterService_Handler, *self, &IOUserServer::RegisterService_Impl));
306 break;
307 }
308#endif /* !KERNEL */
309
310 default:
311 ret = IOService::_Dispatch(self, rpc);
312 break;
313 }
314
315 return (ret);
316}
317
318#if KERNEL
319kern_return_t
320IOUserServer::MetaClass::Dispatch(const IORPC rpc)
321{
322#else /* KERNEL */
323kern_return_t
324IOUserServerMetaClass::Dispatch(const IORPC rpc)
325{
326#endif /* !KERNEL */
327
328 kern_return_t ret = kIOReturnUnsupported;
329 IORPCMessage * msg = IORPCMessageFromMach(msg: rpc.message, reply: false);
330
331 switch (msg->msgid)
332 {
333#if KERNEL
334 case IOUserServer_Create_ID:
335 ret = IOUserServer::Create_Invoke(rpc, func: &IOUserServer::Create_Impl);
336 break;
337#endif /* !KERNEL */
338
339 default:
340 ret = OSMetaClassBase::Dispatch(rpc);
341 break;
342 }
343
344 return (ret);
345}
346
347kern_return_t
348IOUserServer::Create(
349 const char * name,
350 uint64_t tag,
351 uint64_t options,
352 OSString * bundleID,
353 IOUserServer ** server)
354{
355 kern_return_t ret;
356 union
357 {
358 IOUserServer_Create_Msg msg;
359 struct
360 {
361 IOUserServer_Create_Rpl rpl;
362 mach_msg_max_trailer_t trailer;
363 } rpl;
364 } buf;
365 struct IOUserServer_Create_Msg * msg = &buf.msg;
366 struct IOUserServer_Create_Rpl * rpl = &buf.rpl.rpl;
367
368 memset(s: msg, c: 0, n: sizeof(struct IOUserServer_Create_Msg));
369 msg->mach.msgh.msgh_id = kIORPCVersion190615;
370 msg->mach.msgh.msgh_size = sizeof(*msg);
371 msg->content.__hdr.flags = 0*kIORPCMessageOneway
372 | 0*kIORPCMessageSimpleReply
373 | 0*kIORPCMessageLocalHost
374 | 0*kIORPCMessageOnqueue;
375 msg->content.__hdr.msgid = IOUserServer_Create_ID;
376 msg->content.__object = (OSObjectRef) OSTypeID(IOUserServer);
377 msg->content.__hdr.objectRefs = IOUserServer_Create_Msg_ObjRefs;
378 msg->mach.msgh_body.msgh_descriptor_count = 2;
379
380 msg->__object__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
381
382 msg->content.name = NULL;
383
384 strlcpy(dst: &msg->content.__name[0], src: name, n: sizeof(msg->content.__name));
385
386 msg->content.tag = tag;
387
388 msg->content.options = options;
389
390 msg->bundleID__descriptor.type = MACH_MSG_OOL_DESCRIPTOR;
391 msg->bundleID__descriptor.copy = MACH_MSG_VIRTUAL_COPY;
392 msg->bundleID__descriptor.address = (void *) __builtin_offsetof(IOUserServer_Create_Msg_Content, bundleID);
393 msg->content.bundleID = bundleID;
394
395 IORPC rpc = { .message = &buf.msg.mach, .reply = &buf.rpl.rpl.mach, .sendSize = sizeof(buf.msg), .replySize = sizeof(buf.rpl) };
396 ret = OSMTypeID(IOUserServer)->Invoke(rpc);
397
398 if (kIOReturnSuccess == ret)
399 do {
400 {
401 if (rpl->mach.msgh.msgh_size != sizeof(*rpl)) { ret = kIOReturnIPCError; break; };
402 if (rpl->content.__hdr.msgid != IOUserServer_Create_ID) { ret = kIOReturnIPCError; break; };
403 if (rpl->mach.msgh_body.msgh_descriptor_count != 1) { ret = kIOReturnIPCError; break; };
404 if (IOUserServer_Create_Rpl_ObjRefs != rpl->content.__hdr.objectRefs) { ret = kIOReturnIPCError; break; };
405 }
406 }
407 while (false);
408 if (kIOReturnSuccess == ret)
409 {
410 *server = OSDynamicCast(IOUserServer, (OSObject *) rpl->content.server);
411 if (rpl->content.server && !*server) ret = kIOReturnBadArgument;
412 }
413
414
415 return (ret);
416}
417
418kern_return_t
419IOUserServer::Exit(
420 const char * reason,
421 OSDispatchMethod supermethod)
422{
423 kern_return_t ret;
424 union
425 {
426 IOUserServer_Exit_Msg msg;
427 struct
428 {
429 IOUserServer_Exit_Rpl rpl;
430 mach_msg_max_trailer_t trailer;
431 } rpl;
432 } buf;
433 struct IOUserServer_Exit_Msg * msg = &buf.msg;
434 struct IOUserServer_Exit_Rpl * rpl = &buf.rpl.rpl;
435
436 memset(s: msg, c: 0, n: sizeof(struct IOUserServer_Exit_Msg));
437 msg->mach.msgh.msgh_id = kIORPCVersion190615;
438 msg->mach.msgh.msgh_size = sizeof(*msg);
439 msg->content.__hdr.flags = 0*kIORPCMessageOneway
440 | 1*kIORPCMessageSimpleReply
441 | 0*kIORPCMessageLocalHost
442 | 0*kIORPCMessageOnqueue;
443 msg->content.__hdr.msgid = IOUserServer_Exit_ID;
444 msg->content.__object = (OSObjectRef) this;
445 msg->content.__hdr.objectRefs = IOUserServer_Exit_Msg_ObjRefs;
446 msg->mach.msgh_body.msgh_descriptor_count = 1;
447
448 msg->__object__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
449
450 msg->content.reason = NULL;
451
452 strlcpy(dst: &msg->content.__reason[0], src: reason, n: sizeof(msg->content.__reason));
453
454 IORPC rpc = { .message = &buf.msg.mach, .reply = &buf.rpl.rpl.mach, .sendSize = sizeof(buf.msg), .replySize = sizeof(buf.rpl) };
455 if (supermethod) ret = supermethod((OSObject *)this, rpc);
456 else ret = ((OSObject *)this)->Invoke(rpc);
457
458 if (kIOReturnSuccess == ret)
459 do {
460 {
461 if (rpl->mach.msgh.msgh_size != sizeof(*rpl)) { ret = kIOReturnIPCError; break; };
462 if (rpl->content.__hdr.msgid != IOUserServer_Exit_ID) { ret = kIOReturnIPCError; break; };
463 if (rpl->mach.msgh_body.msgh_descriptor_count != 0) { ret = kIOReturnIPCError; break; };
464 if (IOUserServer_Exit_Rpl_ObjRefs != rpl->content.__hdr.objectRefs) { ret = kIOReturnIPCError; break; };
465 }
466 }
467 while (false);
468 if (kIOReturnSuccess == ret)
469 {
470 }
471
472
473 return (ret);
474}
475
476kern_return_t
477IOUserServer::LoadModule(
478 const char * path,
479 OSDispatchMethod supermethod)
480{
481 kern_return_t ret;
482 union
483 {
484 IOUserServer_LoadModule_Msg msg;
485 struct
486 {
487 IOUserServer_LoadModule_Rpl rpl;
488 mach_msg_max_trailer_t trailer;
489 } rpl;
490 } buf;
491 struct IOUserServer_LoadModule_Msg * msg = &buf.msg;
492 struct IOUserServer_LoadModule_Rpl * rpl = &buf.rpl.rpl;
493
494 memset(s: msg, c: 0, n: sizeof(struct IOUserServer_LoadModule_Msg));
495 msg->mach.msgh.msgh_id = kIORPCVersion190615;
496 msg->mach.msgh.msgh_size = sizeof(*msg);
497 msg->content.__hdr.flags = 0*kIORPCMessageOneway
498 | 1*kIORPCMessageSimpleReply
499 | 0*kIORPCMessageLocalHost
500 | 0*kIORPCMessageOnqueue;
501 msg->content.__hdr.msgid = IOUserServer_LoadModule_ID;
502 msg->content.__object = (OSObjectRef) this;
503 msg->content.__hdr.objectRefs = IOUserServer_LoadModule_Msg_ObjRefs;
504 msg->mach.msgh_body.msgh_descriptor_count = 1;
505
506 msg->__object__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
507
508 msg->content.path = NULL;
509
510 strlcpy(dst: &msg->content.__path[0], src: path, n: sizeof(msg->content.__path));
511
512 IORPC rpc = { .message = &buf.msg.mach, .reply = &buf.rpl.rpl.mach, .sendSize = sizeof(buf.msg), .replySize = sizeof(buf.rpl) };
513 if (supermethod) ret = supermethod((OSObject *)this, rpc);
514 else ret = ((OSObject *)this)->Invoke(rpc);
515
516 if (kIOReturnSuccess == ret)
517 do {
518 {
519 if (rpl->mach.msgh.msgh_size != sizeof(*rpl)) { ret = kIOReturnIPCError; break; };
520 if (rpl->content.__hdr.msgid != IOUserServer_LoadModule_ID) { ret = kIOReturnIPCError; break; };
521 if (rpl->mach.msgh_body.msgh_descriptor_count != 0) { ret = kIOReturnIPCError; break; };
522 if (IOUserServer_LoadModule_Rpl_ObjRefs != rpl->content.__hdr.objectRefs) { ret = kIOReturnIPCError; break; };
523 }
524 }
525 while (false);
526 if (kIOReturnSuccess == ret)
527 {
528 }
529
530
531 return (ret);
532}
533
534kern_return_t
535IOUserServer::Create_Invoke(const IORPC _rpc,
536 Create_Handler func)
537{
538 IOUserServer_Create_Invocation rpc = { .rpc: _rpc };
539 kern_return_t ret;
540
541 if (2 != rpc.message->mach.msgh_body.msgh_descriptor_count) return (kIOReturnIPCError);
542 if (IOUserServer_Create_Msg_ObjRefs != rpc.message->content.__hdr.objectRefs) return (kIOReturnIPCError);
543 if (rpc.message != NULL && rpc.sendSize < sizeof(IOUserServer_Create_Msg)) return (kIOReturnIPCError);
544 if (rpc.reply != NULL && rpc.replySize < sizeof(IOUserServer_Create_Rpl)) return (kIOReturnIPCError);
545 if (((OSObject *) rpc.message->content.bundleID) != NULL && OSDynamicCast(OSString, (OSObject *) rpc.message->content.bundleID) == NULL) { return kIOReturnBadArgument; }
546 if (strnlen(s: &rpc.message->content.__name[0], n: sizeof(rpc.message->content.__name)) >= sizeof(rpc.message->content.__name)) return kIOReturnBadArgument;
547
548 ret = (*func)( &rpc.message->content.__name[0],
549 rpc.message->content.tag,
550 rpc.message->content.options,
551 rpc.message->content.bundleID,
552 (IOUserServer **)&rpc.reply->content.server);
553
554 if (kIOReturnSuccess != ret) return (ret);
555
556 rpc.reply->content.__hdr.msgid = IOUserServer_Create_ID;
557 rpc.reply->content.__hdr.flags = kIORPCMessageOneway;
558 rpc.reply->mach.msgh.msgh_id = kIORPCVersion190615Reply;
559 rpc.reply->mach.msgh.msgh_size = sizeof(*rpc.reply);
560 rpc.reply->mach.msgh_body.msgh_descriptor_count = 1;
561 rpc.reply->content.__hdr.objectRefs = IOUserServer_Create_Rpl_ObjRefs;
562 rpc.reply->server__descriptor.type = MACH_MSG_PORT_DESCRIPTOR;
563
564 return (ret);
565}
566
567kern_return_t
568IOUserServer::Exit_Invoke(const IORPC _rpc,
569 OSMetaClassBase * target,
570 Exit_Handler func)
571{
572 IOUserServer_Exit_Invocation rpc = { .rpc: _rpc };
573 kern_return_t ret;
574
575 if (1 != rpc.message->mach.msgh_body.msgh_descriptor_count) return (kIOReturnIPCError);
576 if (IOUserServer_Exit_Msg_ObjRefs != rpc.message->content.__hdr.objectRefs) return (kIOReturnIPCError);
577 if (rpc.message != NULL && rpc.sendSize < sizeof(IOUserServer_Exit_Msg)) return (kIOReturnIPCError);
578 if (rpc.reply != NULL && rpc.replySize < sizeof(IOUserServer_Exit_Rpl)) return (kIOReturnIPCError);
579 if (strnlen(s: &rpc.message->content.__reason[0], n: sizeof(rpc.message->content.__reason)) >= sizeof(rpc.message->content.__reason)) return kIOReturnBadArgument;
580
581 ret = (*func)(target,
582 &rpc.message->content.__reason[0]);
583
584 if (kIOReturnSuccess != ret) return (ret);
585
586 rpc.reply->content.__hdr.msgid = IOUserServer_Exit_ID;
587 rpc.reply->content.__hdr.flags = kIORPCMessageOneway;
588 rpc.reply->mach.msgh.msgh_id = kIORPCVersion190615Reply;
589 rpc.reply->mach.msgh.msgh_size = sizeof(*rpc.reply);
590 rpc.reply->mach.msgh_body.msgh_descriptor_count = 0;
591 rpc.reply->content.__hdr.objectRefs = IOUserServer_Exit_Rpl_ObjRefs;
592
593 return (ret);
594}
595
596kern_return_t
597IOUserServer::LoadModule_Invoke(const IORPC _rpc,
598 OSMetaClassBase * target,
599 LoadModule_Handler func)
600{
601 IOUserServer_LoadModule_Invocation rpc = { .rpc: _rpc };
602 kern_return_t ret;
603
604 if (1 != rpc.message->mach.msgh_body.msgh_descriptor_count) return (kIOReturnIPCError);
605 if (IOUserServer_LoadModule_Msg_ObjRefs != rpc.message->content.__hdr.objectRefs) return (kIOReturnIPCError);
606 if (rpc.message != NULL && rpc.sendSize < sizeof(IOUserServer_LoadModule_Msg)) return (kIOReturnIPCError);
607 if (rpc.reply != NULL && rpc.replySize < sizeof(IOUserServer_LoadModule_Rpl)) return (kIOReturnIPCError);
608 if (strnlen(s: &rpc.message->content.__path[0], n: sizeof(rpc.message->content.__path)) >= sizeof(rpc.message->content.__path)) return kIOReturnBadArgument;
609
610 ret = (*func)(target,
611 &rpc.message->content.__path[0]);
612
613 if (kIOReturnSuccess != ret) return (ret);
614
615 rpc.reply->content.__hdr.msgid = IOUserServer_LoadModule_ID;
616 rpc.reply->content.__hdr.flags = kIORPCMessageOneway;
617 rpc.reply->mach.msgh.msgh_id = kIORPCVersion190615Reply;
618 rpc.reply->mach.msgh.msgh_size = sizeof(*rpc.reply);
619 rpc.reply->mach.msgh_body.msgh_descriptor_count = 0;
620 rpc.reply->content.__hdr.objectRefs = IOUserServer_LoadModule_Rpl_ObjRefs;
621
622 return (ret);
623}
624
625
626
627