int
key_init(void)
{
if (!keys_configured) {
warnx("key init called without an active key configured");
return -1;
}
if (eventTap != NULL) {
warnx("key init called when events already initialized");
return -1;
}
eventTap = CGEventTapCreate (
kCGHIDEventTap,
kCGSessionEventTap,
kCGEventTapOptionListenOnly,
CGEventMaskBit(kCGEventKeyDown) | CGEventMaskBit(kCGEventKeyUp),
key_event_callback,
NULL
);
if (eventTap == NULL) {
warnx("unable to create event tap");
return -1;
}
runLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, eventTap, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopCommonModes);
return 0;
}
int main(int argc, const char *argv[]) {
// Create an event tap to retrieve keypresses.
CGEventMask eventMask = (CGEventMaskBit(kCGEventKeyDown) | CGEventMaskBit(kCGEventFlagsChanged));
CFMachPortRef eventTap = CGEventTapCreate(
kCGSessionEventTap, kCGHeadInsertEventTap, 0, eventMask, CGEventCallback, NULL
);
// Exit the program if unable to create the event tap.
if(!eventTap) {
fprintf(stderr, "ERROR: Unable to create event tap.\n");
exit(1);
}
// Create a run loop source and add enable the event tap.
CFRunLoopSourceRef runLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, eventTap, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopCommonModes);
CGEventTapEnable(eventTap, true);
initscr();
int row, col;
getmaxyx(stdscr,row,col);
clear();
mvprintw(row/2,(col-10)/2,"0.000000%%");
refresh();
CFRunLoopRun();
return 0;
}
Status EventTappingEventPublisher::restart() {
stop();
WriteLock lock(run_loop_mutex_);
run_loop_ = CFRunLoopGetCurrent();
CGEventMask mask = kCGEventNull;
if (FLAGS_enable_keyboard_events) {
mask |= 1 << kCGEventKeyDown;
}
if (FLAGS_enable_mouse_events) {
mask |= 1 << kCGEventLeftMouseDown;
}
event_tap_ = CGEventTapCreate(kCGSessionEventTap,
kCGHeadInsertEventTap,
kCGEventTapOptionListenOnly,
mask,
eventCallback,
nullptr);
if (event_tap_ == nullptr) {
run_loop_ = nullptr;
return Status(1, "Could not create event tap");
}
run_loop_source_ =
CFMachPortCreateRunLoopSource(kCFAllocatorDefault, event_tap_, 0);
CFRunLoopAddSource(run_loop_, run_loop_source_, kCFRunLoopCommonModes);
CGEventTapEnable(event_tap_, true);
return Status(0);
}
void MouseEventTool::AddHook()
{
CGEventMask eventMask;
CFRunLoopSourceRef runLoopSource;
ProcessSerialNumber psn;
myself = this;
OSErr err = GetCurrentProcess(&psn);
if (err) {
return;
}
// Create an event tap.
eventMask = kCGEventMaskForAllEvents;
eventTap_ = CGEventTapCreateForPSN((void*) &psn, kCGHeadInsertEventTap, 0, eventMask, myCGEventCallback, NULL);
//eventTap = CGEventTapCreate(kCGHIDEventTap, kCGHeadInsertEventTap, 0, eventMask, myCGEventCallback, NULL);
if (!eventTap_) {
exit(1);
}
// Create a run loop source.
runLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, eventTap_, 0);
// Add to the current run loop.
CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopCommonModes);
// Enable the event tap.
CGEventTapEnable(eventTap_, true);
}
int main(int argc, char **argv)
{
if(CheckArguments(argc, argv))
return 0;
KwmInit();
KWMMach.EventMask = ((1 << kCGEventKeyDown) |
(1 << kCGEventKeyUp) |
(1 << kCGEventMouseMoved));
KWMMach.EventTap = CGEventTapCreate(kCGSessionEventTap, kCGHeadInsertEventTap, kCGEventTapOptionDefault, KWMMach.EventMask, CGEventCallback, NULL);
if(!KWMMach.EventTap || !CGEventTapIsEnabled(KWMMach.EventTap))
Fatal("ERROR: Could not create event-tap!");
CFRunLoopAddSource(CFRunLoopGetMain(),
CFMachPortCreateRunLoopSource(kCFAllocatorDefault, KWMMach.EventTap, 0),
kCFRunLoopCommonModes);
CGEventTapEnable(KWMMach.EventTap, true);
CreateWorkspaceWatcher(KWMMach.WorkspaceWatcher);
// NOTE(koekeishiya): Initialize AXLIB
// AXLibInit(&AXApplications);
// AXLibRunningApplications();
NSApplicationLoad();
CFRunLoopRun();
return 0;
}
void startListen(){
CFMachPortRef eventTap;
CGEventMask eventMask;
CFRunLoopSourceRef runLoopSource;
// Create an event tap. We are interested in key presses.
//eventMask = ((1 << kCGEventKeyDown) | (1 << kCGEventKeyUp) | (1 << kCGEventFlagsChanged));
eventMask = ((1 << kCGEventKeyDown) | (1 << kCGEventFlagsChanged));
eventTap = CGEventTapCreate(kCGSessionEventTap, kCGHeadInsertEventTap, 0,
eventMask, myCGEventCallback, NULL);
if (!eventTap) {
fprintf(stderr, "failed to create event tap\n");
exit(1);
}
// Create a run loop source.
runLoopSource = CFMachPortCreateRunLoopSource(
kCFAllocatorDefault, eventTap, 0);
// Add to the current run loop.
CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource,
kCFRunLoopCommonModes);
// Enable the event tap.
CGEventTapEnable(eventTap, true);
// Set it all running.
CFRunLoopRun();
// In a real program, one would have arranged for cleaning up.
}
Qt::Native::Status insertEventHandler_Quartz(QNativeInput *nativeInput, int pid = 0)
{
uid_t uid = geteuid();
if (uid != 0)
qWarning("MacNativeEvents: You must be root to listen for key events!");
CFMachPortRef port;
if (!pid){
port = CGEventTapCreate(kCGHIDEventTap,
kCGHeadInsertEventTap, kCGEventTapOptionListenOnly,
kCGEventMaskForAllEvents, EventHandler_Quartz, nativeInput);
} else {
ProcessSerialNumber psn;
GetProcessForPID(pid, &psn);
port = CGEventTapCreateForPSN(&psn,
kCGHeadInsertEventTap, kCGEventTapOptionListenOnly,
kCGEventMaskForAllEvents, EventHandler_Quartz, nativeInput);
}
CFRunLoopSourceRef eventSrc = CFMachPortCreateRunLoopSource(NULL, port, 0);
CFRunLoopAddSource((CFRunLoopRef) GetCFRunLoopFromEventLoop(GetMainEventLoop()),
eventSrc, kCFRunLoopCommonModes);
return Qt::Native::Success;
}
int main(void) {
fprintf(stderr, "Starting up.\n");
CFMachPortRef eventTap;
CFRunLoopSourceRef runLoopSource;
CGEventFlags oldFlags = CGEventSourceFlagsState(kCGEventSourceStateCombinedSessionState);
eventTap = CGEventTapCreate(kCGSessionEventTap,
kCGHeadInsertEventTap,
0,
kCGEventMaskForAllEvents,
//CGEventMaskBit(kCGEventFlagsChanged) | CGEventMaskBit(kCGEventKeyDown) | CGEventMaskBit(kCGEventKeyUp),
myCGEventCallback,
&oldFlags);
if (!eventTap) {
fprintf(stderr, "Failed to create event tap!\n");
exit(1);
}
runLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, eventTap, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopCommonModes);
CGEventTapEnable(eventTap, true);
CFRunLoopRun();
exit(0);
}
int main(int argc, const char *argv[]) {
struct timespec ts;
current_utc_time(&ts);
//printf("s: %lu\n", ts.tv_sec);
//printf("ns: %lu\n", ts.tv_nsec);
// Create an event tap to retrieve keypresses.
CGEventMask eventMask = (CGEventMaskBit(kCGEventKeyDown) | CGEventMaskBit(kCGEventFlagsChanged));
CFMachPortRef eventTap = CGEventTapCreate(
kCGSessionEventTap, kCGHeadInsertEventTap, 0, eventMask, CGEventCallback, NULL
);
// Exit the program if unable to create the event tap.
if(!eventTap) {
fprintf(stderr, "ERROR: Unable to create event tap.\n");
exit(1);
}
// Create a run loop source and add enable the event tap.
CFRunLoopSourceRef runLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, eventTap, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopCommonModes);
CGEventTapEnable(eventTap, true);
// Clear the logfile if clear argument used or log to specific file if given.
if(argc == 2) {
if(strcmp(argv[1], "clear") == 0) {
fopen(logfileLocation, "w");
printf("%s cleared.\n", logfileLocation);
fflush(stdout);
exit(1);
} else {
logfileLocation = argv[1];
}
}
// Get the current time and open the logfile.
time_t result = time(NULL);
logfile = fopen(logfileLocation, "a");
if (!logfile) {
fprintf(stderr, "ERROR: Unable to open log file. Ensure that you have the proper permissions.\n");
exit(1);
}
// Output to logfile.
fprintf(logfile, "\n\nKeylogging has begun.\n%s\n", asctime(localtime(&result)));
fflush(logfile);
// Display the location of the logfile and start the loop.
printf("Logging to: %s\n", logfileLocation);
fflush(stdout);
CFRunLoopRun();
return 0;
}
Boolean SetupMIGServer()
{
Boolean result = true;
kern_return_t kern_result = KERN_SUCCESS;
CFMachPortRef upsdMachPort = NULL; // must release
mach_port_t ups_port = MACH_PORT_NULL;
/*if (IOUPSMIGServerIsRunning(&bootstrap_port, NULL)) {
result = false;
goto finish;
}*/
kern_result = task_get_bootstrap_port(mach_task_self(), &bootstrap_port);
if (kern_result != KERN_SUCCESS)
{
result = false;
goto finish;
}
gMainRunLoop = CFRunLoopGetCurrent();
if (!gMainRunLoop) {
result = false;
goto finish;
}
kern_result = bootstrap_check_in(
bootstrap_port,
kIOUPSPlugInServerName,
&ups_port);
if (BOOTSTRAP_SUCCESS != kern_result)
{
syslog(LOG_ERR, "ioupsd: bootstrap_check_in \"%s\" error = %d\n",
kIOUPSPlugInServerName, kern_result);
} else {
upsdMachPort = CFMachPortCreateWithPort(kCFAllocatorDefault, ups_port,
upsd_mach_port_callback, NULL, NULL);
gClientRequestRunLoopSource = CFMachPortCreateRunLoopSource(
kCFAllocatorDefault, upsdMachPort, 0);
if (!gClientRequestRunLoopSource) {
result = false;
goto finish;
}
CFRunLoopAddSource(gMainRunLoop, gClientRequestRunLoopSource,
kCFRunLoopDefaultMode);
}
finish:
if (gClientRequestRunLoopSource) CFRelease(gClientRequestRunLoopSource);
if (upsdMachPort) CFRelease(upsdMachPort);
return result;
}
int main(int argc, char *argv[]) {
CGEventMask mask = CGEventMaskBit(kCGEventScrollWheel);
CFMachPortRef port = CGEventTapCreate(kCGSessionEventTap, kCGHeadInsertEventTap, kCGEventTapOptionDefault, mask, &callback, NULL);
if(port == NULL)
return -1;
CFRunLoopSourceRef source = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, port, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), source, kCFRunLoopCommonModes);
CGEventTapEnable(port, true);
CFRunLoopRun();
return 1;
}
IOReturn IOFireWireSBP2LibLUN::addIODispatcherToRunLoop( CFRunLoopRef cfRunLoopRef )
{
IOReturn status = kIOReturnSuccess;
FWLOG(( "IOFireWireSBP2LibLUN : addIODispatcherToRunLoop\n" ));
if( !fConnection )
return kIOReturnNoDevice;
if( status == kIOReturnSuccess )
{
CFMachPortContext context;
Boolean shouldFreeInfo; // zzz what's this for?
context.version = 1;
context.info = this;
context.retain = NULL;
context.release = NULL;
context.copyDescription = NULL;
fCFAsyncPort = CFMachPortCreateWithPort( kCFAllocatorDefault, fAsyncPort,
(CFMachPortCallBack) IODispatchCalloutFromMessage,
&context, &shouldFreeInfo );
if( !fCFAsyncPort )
status = kIOReturnNoMemory;
}
if( status == kIOReturnSuccess )
{
fCFRunLoopSource = CFMachPortCreateRunLoopSource( kCFAllocatorDefault, fCFAsyncPort, 0 );
if( !fCFRunLoopSource )
status = kIOReturnNoMemory;
}
if( status == kIOReturnSuccess )
{
fCFRunLoop = cfRunLoopRef;
CFRunLoopAddSource( fCFRunLoop, fCFRunLoopSource, kCFRunLoopCommonModes );
}
if( status == kIOReturnSuccess )
{
io_async_ref64_t asyncRef;
mach_msg_type_number_t size = 0;
asyncRef[kIOAsyncCalloutFuncIndex] = (uint64_t)&IOFireWireSBP2LibLUN::staticMessageCallback;
asyncRef[kIOAsyncCalloutRefconIndex] = (uint64_t)this;
status = IOConnectCallAsyncScalarMethod( fConnection, kIOFWSBP2UserClientSetMessageCallback, fAsyncPort, asyncRef, kOSAsyncRef64Count, NULL, 0, NULL, &size );
}
return status;
}
CFRunLoopSourceRef CFUserNotificationCreateRunLoopSource(CFAllocatorRef allocator, CFUserNotificationRef userNotification, CFUserNotificationCallBack callout, CFIndex order) {
CHECK_FOR_FORK();
CFRunLoopSourceRef source = NULL;
if (userNotification && callout && !userNotification->_machPort && MACH_PORT_NULL != userNotification->_replyPort) {
CFMachPortContext context = {0, userNotification, NULL, NULL, NULL};
userNotification->_machPort = CFMachPortCreateWithPort(CFGetAllocator(userNotification), (mach_port_t)userNotification->_replyPort, _CFUserNotificationMachPortCallBack, &context, NULL);
}
if (userNotification && userNotification->_machPort) {
source = CFMachPortCreateRunLoopSource(allocator, userNotification->_machPort, order);
userNotification->_callout = callout;
}
return source;
}
__private_extern__
void
server_init()
{
serverSessionRef mySession;
CFRunLoopSourceRef rls;
char *service_name;
mach_port_t service_port = MACH_PORT_NULL;
kern_return_t status;
service_name = getenv("SCD_SERVER");
if (!service_name) {
service_name = SCD_SERVER;
}
/* Check "configd" server status */
status = bootstrap_check_in(bootstrap_port, service_name, &service_port);
switch (status) {
case BOOTSTRAP_SUCCESS :
/* if we are being [re-]started by launchd */
break;
case BOOTSTRAP_NOT_PRIVILEGED :
/* if another instance of the server is starting */
SCLog(TRUE, LOG_ERR, CFSTR("'%s' server already starting"), service_name);
exit (EX_UNAVAILABLE);
case BOOTSTRAP_SERVICE_ACTIVE :
/* if another instance of the server is active */
SCLog(TRUE, LOG_ERR, CFSTR("'%s' server already active"), service_name);
exit (EX_UNAVAILABLE);
default :
SCLog(TRUE, LOG_ERR,
CFSTR("server_init bootstrap_check_in(..., '%s', ...) failed: %s"),
service_name,
bootstrap_strerror(status));
exit (EX_UNAVAILABLE);
}
/* Create the primary / new connection port and backing session */
mySession = addSession(service_port, serverMPCopyDescription);
configd_port = mySession->serverPort;
/*
* Create and add a run loop source for the port and add this source
* to the default run loop mode.
*/
rls = CFMachPortCreateRunLoopSource(NULL, configd_port, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), rls, kCFRunLoopDefaultMode);
CFRelease(rls);
return;
}
static void
start_service(mach_port_t service_port)
{
CFMachPortRef mp;
CFRunLoopSourceRef rls;
mp = CFMachPortCreateWithPort(NULL, service_port, server_handle_request,
NULL, NULL);
rls = CFMachPortCreateRunLoopSource(NULL, mp, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), rls, kCFRunLoopDefaultMode);
CFRelease(mp);
CFRelease(rls);
return;
}
void
COSXScreen::enable()
{
// watch the clipboard
m_clipboardTimer = m_events->newTimer(1.0, NULL);
m_events->adoptHandler(CEvent::kTimer, m_clipboardTimer,
new TMethodEventJob<COSXScreen>(this,
&COSXScreen::handleClipboardCheck));
if (m_isPrimary) {
// FIXME -- start watching jump zones
// kCGEventTapOptionDefault = 0x00000000 (Missing in 10.4, so specified literally)
m_eventTapPort = CGEventTapCreate(kCGHIDEventTap, kCGHeadInsertEventTap, 0,
kCGEventMaskForAllEvents,
handleCGInputEvent,
this);
}
else {
// FIXME -- prevent system from entering power save mode
if (m_autoShowHideCursor) {
hideCursor();
}
// warp the mouse to the cursor center
fakeMouseMove(m_xCenter, m_yCenter);
// there may be a better way to do this, but we register an event handler even if we're
// not on the primary display (acting as a client). This way, if a local event comes in
// (either keyboard or mouse), we can make sure to show the cursor if we've hidden it.
m_eventTapPort = CGEventTapCreate(kCGHIDEventTap, kCGHeadInsertEventTap, 0,
kCGEventMaskForAllEvents,
handleCGInputEventSecondary,
this);
}
if (!m_eventTapPort) {
LOG((CLOG_ERR "failed to create quartz event tap"));
}
m_eventTapRLSR = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, m_eventTapPort, 0);
if (!m_eventTapRLSR) {
LOG((CLOG_ERR "failed to create a CFRunLoopSourceRef for the quartz event tap"));
}
CFRunLoopAddSource(CFRunLoopGetCurrent(), m_eventTapRLSR, kCFRunLoopDefaultMode);
}
void createEventTap (CGEventTapCallBack eventCallback) {
CGEventFlags oldFlags = CGEventSourceFlagsState(kCGEventSourceStateCombinedSessionState);
//CGEventMask eventMask = (CGEventMaskBit(kCGEventKeyDown) | CGEventMaskBit(kCGEventFlagsChanged));
CGEventMask eventMask = kCGEventMaskForAllEvents;
CFMachPortRef eventTap = CGEventTapCreate(kCGSessionEventTap,
kCGHeadInsertEventTap, 0, eventMask, eventCallback, &oldFlags);
if (!eventTap) {
fprintf(stderr, "failed to create event tap\nyou need to enable \"Enable access for assitive devices\" in Universal Access preference panel.");
exit(1);
}
CFRunLoopSourceRef runLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, eventTap, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopCommonModes);
CGEventTapEnable(eventTap, true);
}
void
_SCDPluginExecInit()
{
struct sigaction act;
CFMachPortContext context = { 0
, (void *)1
, NULL
, NULL
, childReapedMPCopyDescription
};
CFRunLoopSourceRef rls;
// create the "a child has been reaped" notification port
childReaped = CFMachPortCreate(NULL, childrenReaped, &context, NULL);
// set queue limit
{
mach_port_limits_t limits;
kern_return_t status;
limits.mpl_qlimit = 1;
status = mach_port_set_attributes(mach_task_self(),
CFMachPortGetPort(childReaped),
MACH_PORT_LIMITS_INFO,
(mach_port_info_t)&limits,
MACH_PORT_LIMITS_INFO_COUNT);
if (status != KERN_SUCCESS) {
perror("mach_port_set_attributes");
}
}
// add to our runloop
rls = CFMachPortCreateRunLoopSource(NULL, childReaped, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), rls, kCFRunLoopDefaultMode);
CFRelease(rls);
// enable signal handler
act.sa_handler = reaper;
sigemptyset(&act.sa_mask);
act.sa_flags = SA_RESTART|SA_NOCLDSTOP;
if (sigaction(SIGCHLD, &act, NULL) == -1) {
perror("sigaction");
}
return;
}
/**
* Attaches to OSX event system
*/
bool EventMonitorMac::setupEventTap() {
CGEventMask mask = CGEventMaskBit(kCGEventKeyUp) | CGEventMaskBit(kCGEventKeyDown);
m_eventTap = CGEventTapCreate( kCGHIDEventTap, kCGTailAppendEventTap, kCGEventTapOptionDefault, mask, eventCallback, NULL );
if( !m_eventTap ) {
// FIXME
fprintf( stderr, "Couldn't create event tap!" );
return false;
}
m_runLoopSource = CFMachPortCreateRunLoopSource( kCFAllocatorDefault, m_eventTap, 0 );
CFRunLoopAddSource( CFRunLoopGetMain(), m_runLoopSource, kCFRunLoopCommonModes );
return true;
}
int main(void)
{
static const CGEventMask eventMask = CGEventMaskBit(kCGEventKeyDown) | CGEventMaskBit(kCGEventKeyUp) | CGEventMaskBit(kCGEventFlagsChanged);
CFMachPortRef eventTap = CGEventTapCreate(kCGSessionEventTap, kCGHeadInsertEventTap, 0, eventMask, myCGEventCallback, NULL);
if (eventTap == NULL)
{
printf("Failed to create event tap.\n");
return -1;
}
CFRunLoopSourceRef runLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, eventTap, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopCommonModes);
CGEventTapEnable(eventTap, true);
CFRunLoopRun();
CFRelease(eventTap);
return 0;
}
int main(int argc, const char * argv[]) {
startLightService();
CGEventMask keyMask = CGEventMaskBit(kCGEventKeyDown);
CFMachPortRef eventTap = CGEventTapCreate(kCGSessionEventTap,
kCGTailAppendEventTap, kCGEventTapOptionListenOnly, keyMask,
lightCallback, NULL);
if (eventTap == NULL) {
fprintf(stderr, "Event tap could not be created. Ending program.");
exit(1);
}
CFRunLoopSourceRef runLoopSource =
CFMachPortCreateRunLoopSource(kCFAllocatorDefault, eventTap, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource,
kCFRunLoopCommonModes);
CGEventTapEnable(eventTap, true); // needed? should be enabled by default
CFRunLoopRun();
return 0;
}
//------------------------------------------------------------------------------
// IOMIGMachPortScheduleWithRunLoop
//------------------------------------------------------------------------------
void IOMIGMachPortScheduleWithRunLoop(IOMIGMachPortRef migPort, CFRunLoopRef runLoop, CFStringRef runLoopMode)
{
migPort->runLoop = runLoop;
migPort->runLoopMode = runLoopMode;
require(migPort->runLoop, exit);
require(migPort->runLoopMode, exit);
// init the sources
if ( !migPort->source ) {
migPort->source = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, migPort->port, 1);
require(migPort->source, exit);
}
CFRunLoopAddSource(runLoop, migPort->source, runLoopMode);
exit:
return;
}
/*
* rend_addtorunloop
*/
static int rend_addtorunloop(dns_service_discovery_ref client) {
mach_port_t port=DNSServiceDiscoveryMachPort(client);
if(!port)
return -1;
else {
CFMachPortContext context = { 0, 0, NULL, NULL, NULL };
Boolean shouldFreeInfo;
CFMachPortRef cfMachPort=CFMachPortCreateWithPort(kCFAllocatorDefault,
port, rend_handler,
&context, &shouldFreeInfo);
CFRunLoopSourceRef rls=CFMachPortCreateRunLoopSource(NULL,cfMachPort,0);
CFRunLoopAddSource(CFRunLoopGetCurrent(),
rls,kCFRunLoopDefaultMode);
CFRelease(rls);
return 0;
}
}
/* Radar 6386278 New launchd api is npot on embedded yet */
int
ppp_mach_start_server()
{
boolean_t active;
kern_return_t status;
CFRunLoopSourceRef rls;
active = FALSE;
status = bootstrap_status(bootstrap_port, PPPCONTROLLER_SERVER, &active);
switch (status) {
case BOOTSTRAP_SUCCESS:
if (active) {
fprintf(stderr, "\"%s\" is currently active.\n",
PPPCONTROLLER_SERVER);
return -1;
}
break;
case BOOTSTRAP_UNKNOWN_SERVICE:
break;
default:
fprintf(stderr,
"bootstrap_status(): %s\n", mach_error_string(status));
return -1;
}
gServer_cfport = CFMachPortCreate(NULL, server_handle_request, NULL, NULL);
rls = CFMachPortCreateRunLoopSource(NULL, gServer_cfport, 0);
gControllerRunloop = CFRunLoopGetCurrent();
CFRunLoopAddSource(gControllerRunloop, rls, kCFRunLoopDefaultMode);
CFRunLoopAddSource(gControllerRunloop, gTerminalrls, kCFRunLoopDefaultMode);
CFRelease(rls);
status = bootstrap_register(bootstrap_port, PPPCONTROLLER_SERVER,
CFMachPortGetPort(gServer_cfport));
if (status != BOOTSTRAP_SUCCESS) {
mach_error("bootstrap_register", status);
return -1;
}
return 0;
}
int main (int argc, const char * argv[]) {
CGEventFlags oldFlags = CGEventSourceFlagsState(kCGEventSourceStateCombinedSessionState);
CGEventMask eventMask = (CGEventMaskBit(kCGEventKeyDown) | CGEventMaskBit(kCGEventFlagsChanged));
CFMachPortRef eventTap = CGEventTapCreate(kCGSessionEventTap, kCGHeadInsertEventTap, 0, eventMask, myCGEventCallback, &oldFlags);
if (!eventTap) {
fprintf(stderr, "failed to create event tap\nyou need to enable \"Enable access for assitive devices\" in Universal Access preference panel.");
exit(1);
}
CFRunLoopSourceRef runLoopSource = CFMachPortCreateRunLoopSource(kCFAllocatorDefault, eventTap, 0);
CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopCommonModes);
CGEventTapEnable(eventTap, true);
logFile = fopen("/var/log/keystroke.log", "a");
CFRunLoopRun();
return 0;
}
internal inline void
ConfigureRunLoop()
{
KWMMach.EventMask = ((1 << kCGEventMouseMoved) |
(1 << kCGEventLeftMouseDragged) |
(1 << kCGEventLeftMouseDown) |
(1 << kCGEventLeftMouseUp) |
(1 << kCGEventRightMouseDragged) |
(1 << kCGEventRightMouseDown) |
(1 << kCGEventRightMouseUp));
KWMMach.EventTap = CGEventTapCreate(kCGSessionEventTap, kCGHeadInsertEventTap, kCGEventTapOptionDefault, KWMMach.EventMask, CGEventCallback, NULL);
if(!KWMMach.EventTap || !CGEventTapIsEnabled(KWMMach.EventTap))
Fatal("Error: Could not create event-tap!");
CFRunLoopAddSource(CFRunLoopGetMain(),
CFMachPortCreateRunLoopSource(kCFAllocatorDefault, KWMMach.EventTap, 0),
kCFRunLoopCommonModes);
}
// This constructor is the short form. The CFMachPort will own the send and receive rights.
CACFMachPort::CACFMachPort(CFMachPortCallBack inCallBack, void* inUserData)
:
mMachPort(NULL),
mRunLoopSource(NULL),
mOwnsPort(true)
{
CFMachPortContext theContext = { 1, inUserData, NULL, NULL, NULL };
mMachPort = CFMachPortCreate(NULL, inCallBack, &theContext, NULL);
ThrowIfNULL(mMachPort, CAException('what'), "CACFMachPort::CACFMachPort(s): couldn't create the CFMachPort");
mRunLoopSource = CFMachPortCreateRunLoopSource(NULL, mMachPort, 0);
if(mRunLoopSource == NULL)
{
CFMachPortInvalidate(mMachPort);
CFRelease(mMachPort);
mMachPort = NULL;
DebugMessage("CACFMachPort::CACFMachPort(s): couldn't create the CFRunLoopSource");
throw CAException('what');
}
}
void MonitorStartupItem (StartupContext aStartupContext, CFMutableDictionaryRef anItem)
{
pid_t aPID = StartupItemGetPID(anItem);
if (anItem && aPID > 0)
{
mach_port_t aPort;
kern_return_t aResult;
CFMachPortContext aContext;
CFMachPortRef aMachPort;
CFRunLoopSourceRef aSource;
TerminationContext aTerminationContext = (TerminationContext) malloc(sizeof(struct TerminationContextStorage));
aTerminationContext->aStartupContext = aStartupContext;
aTerminationContext->anItem = anItem;
aContext.version = 0;
aContext.info = aTerminationContext;
aContext.retain = 0;
aContext.release = 0;
if ((aResult = task_for_pid(mach_task_self(), aPID, &aPort)) != KERN_SUCCESS)
goto out_bad;
if (!(aMachPort = CFMachPortCreateWithPort(NULL, aPort, NULL, &aContext, NULL)))
goto out_bad;
if (!(aSource = CFMachPortCreateRunLoopSource(NULL, aMachPort, 0))) {
CFRelease(aMachPort);
goto out_bad;
}
CFMachPortSetInvalidationCallBack(aMachPort, startupItemTerminated);
CFRunLoopAddSource(CFRunLoopGetCurrent(), aSource, kCFRunLoopCommonModes);
CFRelease(aSource);
CFRelease(aMachPort);
return;
out_bad:
/* The assumption is something failed, the task already terminated. */
startupItemTerminated(NULL, aTerminationContext);
}
}
static
void init_self_audittoken(void)
{
/* create a mach port and an event source */
CFMachPortRef server_port = CFMachPortCreate (NULL, server_callback, NULL, false);
CFRunLoopSourceRef server_source = CFMachPortCreateRunLoopSource(NULL, server_port, 0/*order*/);
/* add the source to the current run loop */
CFRunLoopAddSource(CFRunLoopGetCurrent(), server_source, kCFRunLoopDefaultMode);
CFRelease(server_source);
/* Send the request */
sectask_client_request(CFMachPortGetPort(server_port));
/* Run the loop to process the message */
CFRunLoopRun();
/* done */
CFRelease(server_port);
}
// This constructor is the general form:
// - If inMachPort is MACH_PORT_NULL, the CFMachPort will allocate the port and own the send and
// receive rights. Otherwise, the caller owns the rights and is resposible for cleaning them
// up.
// - If inCallBack is NULL, then received messages will just get swallowed by the CFMachPort.
// This is useful if you are only using the CFMachPort to track port death (aka invalidation).
// - If inInvalidationCallBack is non-NULL, then it will be installed as the invalidation
// callback on the CFMachPort.
CACFMachPort::CACFMachPort(mach_port_t inMachPort, CFMachPortCallBack inCallBack, CFMachPortInvalidationCallBack inInvalidationCallBack, void* inUserData)
:
mMachPort(NULL),
mRunLoopSource(NULL),
mOwnsPort(false)
{
CFMachPortContext theContext = { 1, inUserData, NULL, NULL, NULL };
if(inMachPort == MACH_PORT_NULL)
{
mMachPort = CFMachPortCreate(NULL, inCallBack, &theContext, NULL);
ThrowIfNULL(mMachPort, CAException('what'), "CACFMachPort::CACFMachPort: couldn't create the CFMachPort");
mOwnsPort = true;
}
else
{
mMachPort = CFMachPortCreateWithPort(NULL, inMachPort, inCallBack, &theContext, NULL);
ThrowIfNULL(mMachPort, CAException('what'), "CACFMachPort::CACFMachPort: couldn't create the CFMachPort with a port");
mOwnsPort = false;
}
mRunLoopSource = CFMachPortCreateRunLoopSource(NULL, mMachPort, 0);
if(mRunLoopSource == NULL)
{
if(mOwnsPort)
{
CFMachPortInvalidate(mMachPort);
}
CFRelease(mMachPort);
mMachPort = NULL;
DebugMessage("CACFMachPort::CACFMachPort: couldn't create the CFRunLoopSource");
throw CAException('what');
}
if(inInvalidationCallBack != NULL)
{
CFMachPortSetInvalidationCallBack(mMachPort, inInvalidationCallBack);
}
}
