[wxWidgets.git] / src / mac / corefoundation / utilsexc_cf.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/mac/corefoundation/utilsexec_cf.cpp
// Purpose:     Execution-related utilities for Darwin
// Author:      David Elliott, Ryan Norton (wxMacExecute)
// Modified by: Stefan Csomor (added necessary wxT for unicode builds)
// Created:     2004-11-04
// RCS-ID:      $Id$
// Copyright:   (c) David Elliott, Ryan Norton
// Licence:     wxWindows licence
// Notes:       This code comes from src/mac/carbon/utilsexc.cpp,1.11
/////////////////////////////////////////////////////////////////////////////

#include "wx/wxprec.h"
#ifndef WX_PRECOMP
    #include "wx/log.h"
    #include "wx/utils.h"
#endif //ndef WX_PRECOMP
#include "wx/unix/execute.h"
#include "wx/stdpaths.h"
#include "wx/app.h"
#include "wx/apptrait.h"
#include "wx/thread.h"
#include "wx/process.h"

#include <sys/wait.h>

// Use polling instead of Mach ports, which doesn't work on Intel
// due to task_for_pid security issues.

// http://developer.apple.com/technotes/tn/tn2050.html

// What's a better test for Intel vs PPC?
#ifdef WORDS_BIGENDIAN
#define USE_POLLING 0
#else
#define USE_POLLING 1
#endif

#if USE_POLLING

#if wxUSE_THREADS
class wxProcessTerminationEventHandler: public wxEvtHandler
{
  public:
    wxProcessTerminationEventHandler(wxEndProcessData* data)
    {
        m_data = data;
        Connect(-1, wxEVT_END_PROCESS, wxProcessEventHandler(wxProcessTerminationEventHandler::OnTerminate));
    }

    void OnTerminate(wxProcessEvent& event)
    {
        Disconnect(-1, wxEVT_END_PROCESS, wxProcessEventHandler(wxProcessTerminationEventHandler::OnTerminate));
        wxHandleProcessTermination(m_data);

        // NOTE: We don't use this to delay destruction until the next idle run but rather to
        // avoid killing ourselves while our caller (which is our wxEvtHandler superclass
        // ProcessPendingEvents) still needs our m_eventsLocker to be valid.
        // Since we're in the GUI library we can guarantee that ScheduleForDestroy is using
        // the GUI implementation which delays destruction and not the base implementation
        // which does it immediately.
        wxTheApp->GetTraits()->ScheduleForDestroy(this);
    }

    wxEndProcessData* m_data;
};

class wxProcessTerminationThread: public wxThread
{
  public:
    wxProcessTerminationThread(wxEndProcessData* data, wxProcessTerminationEventHandler* handler): wxThread(wxTHREAD_DETACHED)
    {
        m_data = data;
        m_handler = handler;
    }

    virtual void* Entry();

    wxProcessTerminationEventHandler* m_handler;
    wxEndProcessData* m_data;
};

// The problem with this is that we may be examining the
// process e.g. in OnIdle at the point this cleans up the process,
// so we need to delay until it's safe.

void* wxProcessTerminationThread::Entry()
{
    while (true)
    {
        usleep(100);
        int status = 0;
        int rc = waitpid(abs(m_data->pid), & status, 0);
        if (rc != 0)
        {
            if ((rc != -1) && WIFEXITED(status))
                m_data->exitcode = WEXITSTATUS(status);
            else
                m_data->exitcode = -1;

            wxProcessEvent event;
            wxPostEvent(m_handler, event);

            break;
        }
    }

    return NULL;
}

int wxAddProcessCallbackForPid(wxEndProcessData *proc_data, int pid)
{
    if (pid < 1)
        return -1;

    wxProcessTerminationEventHandler* handler = new wxProcessTerminationEventHandler(proc_data);
    wxProcessTerminationThread* thread = new wxProcessTerminationThread(proc_data, handler);

    if (thread->Create() != wxTHREAD_NO_ERROR)
    {
        wxLogDebug(wxT("Could not create termination detection thread."));
        delete thread;
        delete handler;
        return -1;
    }

    thread->Run();

    return 0;
}
#else // !wxUSE_THREADS
int wxAddProcessCallbackForPid(wxEndProcessData*, int)
{
    wxLogDebug(wxT("Could not create termination detection thread."));
    return -1;
}
#endif // wxUSE_THREADS/!wxUSE_THREADS

#else // !USE_POLLING

#include <CoreFoundation/CFMachPort.h>
extern "C" {
#include <mach/mach.h>
}

void wxMAC_MachPortEndProcessDetect(CFMachPortRef port, void *data)
{
    wxEndProcessData *proc_data = (wxEndProcessData*)data;
    wxLogDebug(wxT("Process ended"));
    int status = 0;
    int rc = waitpid(abs(proc_data->pid), &status, WNOHANG);
    if(!rc)
    {
        wxLogDebug(wxT("Mach port was invalidated, but process hasn't terminated!"));
        return;
    }
    if((rc != -1) && WIFEXITED(status))
        proc_data->exitcode = WEXITSTATUS(status);
    else
        proc_data->exitcode = -1;
    wxHandleProcessTermination(proc_data);
}

int wxAddProcessCallbackForPid(wxEndProcessData *proc_data, int pid)
{
    if(pid < 1)
        return -1;
    kern_return_t    kernResult;
    mach_port_t    taskOfOurProcess;
    mach_port_t    machPortForProcess;
    taskOfOurProcess = mach_task_self();
    if(taskOfOurProcess == MACH_PORT_NULL)
    {
        wxLogDebug(wxT("No mach_task_self()"));
        return -1;
    }
    wxLogDebug(wxT("pid=%d"),pid);
    kernResult = task_for_pid(taskOfOurProcess,pid, &machPortForProcess);
    if(kernResult != KERN_SUCCESS)
    {
        wxLogDebug(wxT("no task_for_pid()"));
        // try seeing if it is already dead or something
        // FIXME: a better method would be to call the callback function
        // from idle time until the process terminates. Of course, how
        // likely is it that it will take more than 0.1 seconds for the
        // mach terminate event to make its way to the BSD subsystem?
        usleep(100); // sleep for 0.1 seconds
        wxMAC_MachPortEndProcessDetect(NULL, (void*)proc_data);
        return -1;
    }
    CFMachPortContext termcb_contextinfo;
    termcb_contextinfo.version = 0;
    termcb_contextinfo.info = (void*)proc_data;
    termcb_contextinfo.retain = NULL;
    termcb_contextinfo.release = NULL;
    termcb_contextinfo.copyDescription = NULL;
    CFMachPortRef    CFMachPortForProcess;
    Boolean        ShouldFreePort;
    CFMachPortForProcess = CFMachPortCreateWithPort(NULL, machPortForProcess, NULL, &termcb_contextinfo, &ShouldFreePort);
    if(!CFMachPortForProcess)
    {
        wxLogDebug(wxT("No CFMachPortForProcess"));
        mach_port_deallocate(taskOfOurProcess, machPortForProcess);
        return -1;
    }
    if(ShouldFreePort)
    {
        kernResult = mach_port_deallocate(taskOfOurProcess, machPortForProcess);
        if(kernResult!=KERN_SUCCESS)
        {
            wxLogDebug(wxT("Couldn't deallocate mach port"));
            return -1;
        }
    }
    CFMachPortSetInvalidationCallBack(CFMachPortForProcess, &wxMAC_MachPortEndProcessDetect);
    CFRunLoopSourceRef    runloopsource;
    runloopsource = CFMachPortCreateRunLoopSource(NULL,CFMachPortForProcess, (CFIndex)0);
    if(!runloopsource)
    {
        wxLogDebug(wxT("Couldn't create runloopsource"));
        return -1;
    }

    CFRelease(CFMachPortForProcess);

    CFRunLoopAddSource(CFRunLoopGetCurrent(),runloopsource,kCFRunLoopDefaultMode);
    CFRelease(runloopsource);
    wxLogDebug(wxT("Successfully added notification to the runloop"));
    return 0;
}

#endif // USE_POLLING/!USE_POLLING

/////////////////////////////////////////////////////////////////////////////
// New implementation avoiding mach ports entirely.

#include <CoreFoundation/CFSocket.h>

/*!
    Called due to source signal detected by the CFRunLoop.
    This is nearly identical to the wxGTK equivalent.
 */
extern "C" void WXCF_EndProcessDetector(CFSocketRef s, CFSocketCallBackType callbackType, CFDataRef address, void const *data, void *info)
{
    wxEndProcessData * const proc_data = static_cast<wxEndProcessData*>(info);

/// This code could reasonably be shared between wxMac/wxCocoa and wxGTK ///
    // PID is always positive on UNIX but wx uses the sign bit as a flag.
    int pid = (proc_data->pid > 0) ? proc_data->pid : -proc_data->pid;
    int status = 0;
    int rc = waitpid(pid, &status, WNOHANG);
    if(rc == 0)
    {
        // Keep waiting in case we got a spurious notification
        // NOTE: In my limited testing, this doesn't happen.
        return;
    }

    if(rc == -1)
    {   // Error.. really shouldn't happen but try to gracefully handle it
        wxLogLastError(_T("waitpid"));
        proc_data->exitcode = -1;
    }
    else
    {   // Process ended for some reason
        wxASSERT_MSG(rc == pid, _T("unexpected waitpid() return value"));

        if(WIFEXITED(status))
            proc_data->exitcode = WEXITSTATUS(status);
        else if(WIFSIGNALED(status))
            // wxGTK doesn't do this but why not?
            proc_data->exitcode = -WTERMSIG(status);
        else
        {   // Should NEVER happen according to waitpid docs
            wxLogError(wxT("waitpid indicates process exited but not due to exiting or signalling"));
            proc_data->exitcode = -1;
        }
    }
/// The above code could reasonably be shared between wxMac/wxCocoa and wxGTK ///

    /*
        Either waitpid failed or the process ended successfully.  Either way,
        we're done.  It's not if waitpid is going to magically succeed when
        we get fired again.  CFSocketInvalidate closes the fd for us and also
        invalidates the run loop source for us which should cause it to
        release the CFSocket (thus causing it to be deallocated) and remove
        itself from the runloop which should release it and cause it to also
        be deallocated.  Of course, it's possible the RunLoop hangs onto
        one or both of them by retaining/releasing them within its stack
        frame.  However, that shouldn't be depended on.  Assume that s is
        deallocated due to the following call.
     */
    CFSocketInvalidate(s);

    // Now tell wx that the process has ended.
    wxHandleProcessTermination(proc_data);
}

/*!
    Implements the GUI-specific wxAddProcessCallback for both wxMac and
    wxCocoa using the CFSocket/CFRunLoop API which is available to both.
    Takes advantage of the fact that sockets on UNIX are just regular
    file descriptors and thus even a non-socket file descriptor can
    apparently be used with CFSocket so long as you only tell CFSocket
    to do things with it that would be valid for a non-socket fd.
 */
int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
{
    static int s_last_tag = 0;
    CFSocketContext context =
    {   0
    ,   static_cast<void*>(proc_data)
    ,   NULL
    ,   NULL
    ,   NULL
    };
    CFSocketRef cfSocket = CFSocketCreateWithNative(kCFAllocatorDefault,fd,kCFSocketReadCallBack,&WXCF_EndProcessDetector,&context);
    if(cfSocket == NULL)
    {
        wxLogError(wxT("Failed to create socket for end process detection"));
        return 0;
    }
    CFRunLoopSourceRef runLoopSource = CFSocketCreateRunLoopSource(kCFAllocatorDefault, cfSocket, /*highest priority:*/0);
    if(runLoopSource == NULL)
    {
        wxLogError(wxT("Failed to create CFRunLoopSource from CFSocket for end process detection"));
        // closes the fd.. we can't really stop it, nor do we necessarily want to.
        CFSocketInvalidate(cfSocket);
        CFRelease(cfSocket);
        return 0;
    }
    // Now that the run loop source has the socket retained and we no longer
    // need to refer to it within this method, we can release it.
    CFRelease(cfSocket);

    CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopCommonModes);
    // Now that the run loop has the source retained we can release it.
    CFRelease(runLoopSource);

    /*
        Feed wx some bullshit.. we don't use it since CFSocket helpfully passes
        itself into our callback and that's enough to be able to
        CFSocketInvalidate it which is all we need to do to get everything we
        just created to be deallocated.
     */
    return ++s_last_tag;
}

/////////////////////////////////////////////////////////////////////////////

// NOTE: This doesn't really belong here but this was a handy file to
// put it in because it's already compiled for wxCocoa and wxMac GUI lib.
#if wxUSE_GUI

#if wxUSE_STDPATHS
static wxStandardPathsCF gs_stdPaths;
wxStandardPathsBase& wxGUIAppTraits::GetStandardPaths()
{
    return gs_stdPaths;
}
#endif

#endif // wxUSE_GUI
Commit	Line	Data
5d553c56 DE	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/mac/corefoundation/utilsexec_cf.cpp
	3	// Purpose: Execution-related utilities for Darwin
62705a27	4	// Author: David Elliott, Ryan Norton (wxMacExecute)
5d553c56 DE	5	// Modified by: Stefan Csomor (added necessary wxT for unicode builds)
	6	// Created: 2004-11-04
	7	// RCS-ID: $Id$
62705a27	8	// Copyright: (c) David Elliott, Ryan Norton
24498521	9	// Licence: wxWindows licence
5d553c56 DE	10	// Notes: This code comes from src/mac/carbon/utilsexc.cpp,1.11
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13	#include "wx/wxprec.h"
	14	#ifndef WX_PRECOMP
	15	#include "wx/log.h"
	16	#include "wx/utils.h"
	17	#endif //ndef WX_PRECOMP
	18	#include "wx/unix/execute.h"
fc480dc1	19	#include "wx/stdpaths.h"
5a9d14c1	20	#include "wx/app.h"
fc480dc1	21	#include "wx/apptrait.h"
110ffa16 JS	22	#include "wx/thread.h"
110ffa16 JS	23	#include "wx/process.h"
5d553c56	24
f523d7ce VZ	25	#include <sys/wait.h>
f523d7ce VZ	26
110ffa16 JS	27	// Use polling instead of Mach ports, which doesn't work on Intel
110ffa16 JS	28	// due to task_for_pid security issues.
62705a27	29
653a54d0 SC	30	// http://developer.apple.com/technotes/tn/tn2050.html
653a54d0 SC	31
110ffa16 JS	32	// What's a better test for Intel vs PPC?
	33	#ifdef WORDS_BIGENDIAN
	34	#define USE_POLLING 0
	35	#else
	36	#define USE_POLLING 1
	37	#endif
	38
	39	#if USE_POLLING
	40
4fa167e6	41	#if wxUSE_THREADS
110ffa16 JS	42	class wxProcessTerminationEventHandler: public wxEvtHandler
	43	{
	44	public:
	45	wxProcessTerminationEventHandler(wxEndProcessData* data)
	46	{
	47	m_data = data;
	48	Connect(-1, wxEVT_END_PROCESS, wxProcessEventHandler(wxProcessTerminationEventHandler::OnTerminate));
	49	}
	50
	51	void OnTerminate(wxProcessEvent& event)
	52	{
	53	Disconnect(-1, wxEVT_END_PROCESS, wxProcessEventHandler(wxProcessTerminationEventHandler::OnTerminate));
	54	wxHandleProcessTermination(m_data);
5a9d14c1 DE	55
	56	// NOTE: We don't use this to delay destruction until the next idle run but rather to
	57	// avoid killing ourselves while our caller (which is our wxEvtHandler superclass
	58	// ProcessPendingEvents) still needs our m_eventsLocker to be valid.
	59	// Since we're in the GUI library we can guarantee that ScheduleForDestroy is using
	60	// the GUI implementation which delays destruction and not the base implementation
	61	// which does it immediately.
	62	wxTheApp->GetTraits()->ScheduleForDestroy(this);
110ffa16 JS	63	}
	64
	65	wxEndProcessData* m_data;
	66	};
	67
	68	class wxProcessTerminationThread: public wxThread
	69	{
	70	public:
	71	wxProcessTerminationThread(wxEndProcessData* data, wxProcessTerminationEventHandler* handler): wxThread(wxTHREAD_DETACHED)
	72	{
	73	m_data = data;
	74	m_handler = handler;
	75	}
	76
	77	virtual void* Entry();
	78
	79	wxProcessTerminationEventHandler* m_handler;
	80	wxEndProcessData* m_data;
	81	};
	82
	83	// The problem with this is that we may be examining the
	84	// process e.g. in OnIdle at the point this cleans up the process,
	85	// so we need to delay until it's safe.
	86
	87	void* wxProcessTerminationThread::Entry()
	88	{
	89	while (true)
	90	{
	91	usleep(100);
	92	int status = 0;
eff41cb9	93	int rc = waitpid(abs(m_data->pid), & status, 0);
110ffa16 JS	94	if (rc != 0)
	95	{
	96	if ((rc != -1) && WIFEXITED(status))
	97	m_data->exitcode = WEXITSTATUS(status);
	98	else
	99	m_data->exitcode = -1;
	100
	101	wxProcessEvent event;
	102	wxPostEvent(m_handler, event);
	103
	104	break;
	105	}
	106	}
9e34f56b	107
110ffa16 JS	108	return NULL;
	109	}
	110
	111	int wxAddProcessCallbackForPid(wxEndProcessData *proc_data, int pid)
	112	{
	113	if (pid < 1)
	114	return -1;
	115
9e34f56b	116	wxProcessTerminationEventHandler* handler = new wxProcessTerminationEventHandler(proc_data);
110ffa16	117	wxProcessTerminationThread* thread = new wxProcessTerminationThread(proc_data, handler);
9e34f56b	118
110ffa16 JS	119	if (thread->Create() != wxTHREAD_NO_ERROR)
	120	{
	121	wxLogDebug(wxT("Could not create termination detection thread."));
	122	delete thread;
	123	delete handler;
	124	return -1;
	125	}
	126
	127	thread->Run();
9e34f56b	128
110ffa16 JS	129	return 0;
110ffa16 JS	130	}
4fa167e6 PC	131	#else // !wxUSE_THREADS
	132	int wxAddProcessCallbackForPid(wxEndProcessData*, int)
	133	{
	134	wxLogDebug(wxT("Could not create termination detection thread."));
	135	return -1;
	136	}
	137	#endif // wxUSE_THREADS/!wxUSE_THREADS
110ffa16	138
f523d7ce	139	#else // !USE_POLLING
62705a27	140
5d553c56	141	#include <CoreFoundation/CFMachPort.h>
5d553c56 DE	142	extern "C" {
	143	#include <mach/mach.h>
	144	}
	145
	146	void wxMAC_MachPortEndProcessDetect(CFMachPortRef port, void *data)
	147	{
24498521	148	wxEndProcessData proc_data = (wxEndProcessData)data;
3bdb628b	149	wxLogDebug(wxT("Process ended"));
24498521 DE	150	int status = 0;
	151	int rc = waitpid(abs(proc_data->pid), &status, WNOHANG);
	152	if(!rc)
	153	{
f523d7ce VZ	154	wxLogDebug(wxT("Mach port was invalidated, but process hasn't terminated!"));
f523d7ce VZ	155	return;
24498521 DE	156	}
24498521 DE	157	if((rc != -1) && WIFEXITED(status))
f523d7ce	158	proc_data->exitcode = WEXITSTATUS(status);
24498521	159	else
f523d7ce	160	proc_data->exitcode = -1;
24498521	161	wxHandleProcessTermination(proc_data);
5d553c56 DE	162	}
	163
	164	int wxAddProcessCallbackForPid(wxEndProcessData *proc_data, int pid)
	165	{
	166	if(pid < 1)
	167	return -1;
	168	kern_return_t kernResult;
	169	mach_port_t taskOfOurProcess;
	170	mach_port_t machPortForProcess;
	171	taskOfOurProcess = mach_task_self();
	172	if(taskOfOurProcess == MACH_PORT_NULL)
	173	{
	174	wxLogDebug(wxT("No mach_task_self()"));
	175	return -1;
	176	}
	177	wxLogDebug(wxT("pid=%d"),pid);
	178	kernResult = task_for_pid(taskOfOurProcess,pid, &machPortForProcess);
	179	if(kernResult != KERN_SUCCESS)
	180	{
	181	wxLogDebug(wxT("no task_for_pid()"));
	182	// try seeing if it is already dead or something
	183	// FIXME: a better method would be to call the callback function
	184	// from idle time until the process terminates. Of course, how
	185	// likely is it that it will take more than 0.1 seconds for the
	186	// mach terminate event to make its way to the BSD subsystem?
	187	usleep(100); // sleep for 0.1 seconds
	188	wxMAC_MachPortEndProcessDetect(NULL, (void*)proc_data);
	189	return -1;
	190	}
	191	CFMachPortContext termcb_contextinfo;
b409fa19	192	termcb_contextinfo.version = 0;
5d553c56 DE	193	termcb_contextinfo.info = (void*)proc_data;
	194	termcb_contextinfo.retain = NULL;
	195	termcb_contextinfo.release = NULL;
	196	termcb_contextinfo.copyDescription = NULL;
	197	CFMachPortRef CFMachPortForProcess;
	198	Boolean ShouldFreePort;
	199	CFMachPortForProcess = CFMachPortCreateWithPort(NULL, machPortForProcess, NULL, &termcb_contextinfo, &ShouldFreePort);
	200	if(!CFMachPortForProcess)
	201	{
	202	wxLogDebug(wxT("No CFMachPortForProcess"));
	203	mach_port_deallocate(taskOfOurProcess, machPortForProcess);
	204	return -1;
	205	}
	206	if(ShouldFreePort)
	207	{
	208	kernResult = mach_port_deallocate(taskOfOurProcess, machPortForProcess);
	209	if(kernResult!=KERN_SUCCESS)
	210	{
	211	wxLogDebug(wxT("Couldn't deallocate mach port"));
	212	return -1;
	213	}
	214	}
	215	CFMachPortSetInvalidationCallBack(CFMachPortForProcess, &wxMAC_MachPortEndProcessDetect);
	216	CFRunLoopSourceRef runloopsource;
	217	runloopsource = CFMachPortCreateRunLoopSource(NULL,CFMachPortForProcess, (CFIndex)0);
	218	if(!runloopsource)
	219	{
	220	wxLogDebug(wxT("Couldn't create runloopsource"));
	221	return -1;
	222	}
9e34f56b	223
5d553c56 DE	224	CFRelease(CFMachPortForProcess);
	225
	226	CFRunLoopAddSource(CFRunLoopGetCurrent(),runloopsource,kCFRunLoopDefaultMode);
	227	CFRelease(runloopsource);
	228	wxLogDebug(wxT("Successfully added notification to the runloop"));
	229	return 0;
	230	}
	231
f523d7ce	232	#endif // USE_POLLING/!USE_POLLING
110ffa16	233
a3261ffb DE	234	/////////////////////////////////////////////////////////////////////////////
	235	// New implementation avoiding mach ports entirely.
	236
	237	#include <CoreFoundation/CFSocket.h>
	238
	239	/*!
	240	Called due to source signal detected by the CFRunLoop.
	241	This is nearly identical to the wxGTK equivalent.
	242	*/
	243	extern "C" void WXCF_EndProcessDetector(CFSocketRef s, CFSocketCallBackType callbackType, CFDataRef address, void const data, void info)
	244	{
	245	wxEndProcessData * const proc_data = static_cast<wxEndProcessData*>(info);
	246
	247	/// This code could reasonably be shared between wxMac/wxCocoa and wxGTK ///
	248	// PID is always positive on UNIX but wx uses the sign bit as a flag.
	249	int pid = (proc_data->pid > 0) ? proc_data->pid : -proc_data->pid;
	250	int status = 0;
	251	int rc = waitpid(pid, &status, WNOHANG);
	252	if(rc == 0)
	253	{
	254	// Keep waiting in case we got a spurious notification
	255	// NOTE: In my limited testing, this doesn't happen.
	256	return;
	257	}
	258
	259	if(rc == -1)
	260	{ // Error.. really shouldn't happen but try to gracefully handle it
	261	wxLogLastError(_T("waitpid"));
	262	proc_data->exitcode = -1;
	263	}
	264	else
	265	{ // Process ended for some reason
	266	wxASSERT_MSG(rc == pid, _T("unexpected waitpid() return value"));
	267
	268	if(WIFEXITED(status))
	269	proc_data->exitcode = WEXITSTATUS(status);
	270	else if(WIFSIGNALED(status))
	271	// wxGTK doesn't do this but why not?
	272	proc_data->exitcode = -WTERMSIG(status);
	273	else
	274	{ // Should NEVER happen according to waitpid docs
	275	wxLogError(wxT("waitpid indicates process exited but not due to exiting or signalling"));
	276	proc_data->exitcode = -1;
	277	}
	278	}
	279	/// The above code could reasonably be shared between wxMac/wxCocoa and wxGTK ///
	280
	281	/*
	282	Either waitpid failed or the process ended successfully. Either way,
	283	we're done. It's not if waitpid is going to magically succeed when
	284	we get fired again. CFSocketInvalidate closes the fd for us and also
	285	invalidates the run loop source for us which should cause it to
	286	release the CFSocket (thus causing it to be deallocated) and remove
	287	itself from the runloop which should release it and cause it to also
	288	be deallocated. Of course, it's possible the RunLoop hangs onto
	289	one or both of them by retaining/releasing them within its stack
	290	frame. However, that shouldn't be depended on. Assume that s is
	291	deallocated due to the following call.
	292	*/
	293	CFSocketInvalidate(s);
	294
	295	// Now tell wx that the process has ended.
	296	wxHandleProcessTermination(proc_data);
	297	}
298
299	/*!
300	Implements the GUI-specific wxAddProcessCallback for both wxMac and
301	wxCocoa using the CFSocket/CFRunLoop API which is available to both.
302	Takes advantage of the fact that sockets on UNIX are just regular
303	file descriptors and thus even a non-socket file descriptor can
304	apparently be used with CFSocket so long as you only tell CFSocket
305	to do things with it that would be valid for a non-socket fd.
306	*/
307	int wxAddProcessCallback(wxEndProcessData *proc_data, int fd)
308	{
309	static int s_last_tag = 0;
310	CFSocketContext context =
311	{ 0
312	, static_cast<void*>(proc_data)
313	, NULL
314	, NULL
315	, NULL
316	};
317	CFSocketRef cfSocket = CFSocketCreateWithNative(kCFAllocatorDefault,fd,kCFSocketReadCallBack,&WXCF_EndProcessDetector,&context);
318	if(cfSocket == NULL)
319	{
2263f62d	320	wxLogError(wxT("Failed to create socket for end process detection"));
a3261ffb DE	321	return 0;
	322	}
	323	CFRunLoopSourceRef runLoopSource = CFSocketCreateRunLoopSource(kCFAllocatorDefault, cfSocket, /highest priority:/0);
	324	if(runLoopSource == NULL)
	325	{
2263f62d	326	wxLogError(wxT("Failed to create CFRunLoopSource from CFSocket for end process detection"));
a3261ffb DE	327	// closes the fd.. we can't really stop it, nor do we necessarily want to.
	328	CFSocketInvalidate(cfSocket);
	329	CFRelease(cfSocket);
	330	return 0;
	331	}
	332	// Now that the run loop source has the socket retained and we no longer
	333	// need to refer to it within this method, we can release it.
	334	CFRelease(cfSocket);
	335
	336	CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopCommonModes);
	337	// Now that the run loop has the source retained we can release it.
	338	CFRelease(runLoopSource);
	339
	340	/*
	341	Feed wx some bullshit.. we don't use it since CFSocket helpfully passes
	342	itself into our callback and that's enough to be able to
	343	CFSocketInvalidate it which is all we need to do to get everything we
	344	just created to be deallocated.
	345	*/
	346	return ++s_last_tag;
	347	}
	348
	349	/////////////////////////////////////////////////////////////////////////////
	350
9e34f56b	351	// NOTE: This doesn't really belong here but this was a handy file to
fc480dc1	352	// put it in because it's already compiled for wxCocoa and wxMac GUI lib.
9e34f56b VZ	353	#if wxUSE_GUI
9e34f56b VZ	354
531814a7	355	#if wxUSE_STDPATHS
fc480dc1 DE	356	static wxStandardPathsCF gs_stdPaths;
	357	wxStandardPathsBase& wxGUIAppTraits::GetStandardPaths()
	358	{
	359	return gs_stdPaths;
	360	}
531814a7	361	#endif
fc480dc1	362
9e34f56b VZ	363	#endif // wxUSE_GUI
9e34f56b VZ	364