/*

    File:       Main.c

    Contains:   Demonstrates how to use the kqueue mechanism to be notified when the contents 

                of a folder change.  Efficient method for detecting when a file is added, deleted,

                or renamed.  This sample creates a simple MP thread which watches a few defined

                locations for modifications, then posts the event back to the main queue to display

                the relevant kevent information to the main window.

    Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc.

                ("Apple") in consideration of your agreement to the following terms, and your

                use, installation, modification or redistribution of this Apple software

                constitutes acceptance of these terms.  If you do not agree with these terms,

                please do not use, install, modify or redistribute this Apple software.

                In consideration of your agreement to abide by the following terms, and subject

                to these terms, Apple grants you a personal, non-exclusive license, under AppleÕs

                copyrights in this original Apple software (the "Apple Software"), to use,

                reproduce, modify and redistribute the Apple Software, with or without

                modifications, in source and/or binary forms; provided that if you redistribute

                the Apple Software in its entirety and without modifications, you must retain

                this notice and the following text and disclaimers in all such redistributions of

                the Apple Software.  Neither the name, trademarks, service marks or logos of

                Apple Computer, Inc. may be used to endorse or promote products derived from the

                Apple Software without specific prior written permission from Apple.  Except as

                expressly stated in this notice, no other rights or licenses, express or implied,

                are granted by Apple herein, including but not limited to any patent rights that

                may be infringed by your derivative works or by other works in which the Apple

                Software may be incorporated.

                The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO

                WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED

                WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR

                PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE OR IN

                COMBINATION WITH YOUR PRODUCTS.

                IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR

                CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE

                GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

                ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION

                OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, TORT

                (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN

                ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    Copyright © 2004 Apple Computer, Inc., All Rights Reserved

*/

#include    <Carbon/Carbon.h>

#include    "Main.h"

#include    <sys/event.h>

#include    <sys/stat.h>

#include    <sys/fcntl.h>

#include    <unistd.h>

static  OSErr   InitializeApplication( void );

static  void    DisplaySimpleWindow( void );

static  pascal  OSStatus AppEventEventHandlerProc( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData );

static  pascal  OSStatus MPWindowEventHandlerProc( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData );

static  void    PrintKEvent( WindowRef window, struct kevent *kevp );

static  OSStatus    MyMPTask( void *parameter );

static  OSStatus    PostKQueueEvent( struct kevent *kevp );

GlobalAppInfo   g;              //  globals

int main( void )

{

    OSErr   err;

    err = InitializeApplication();

    if ( err != noErr ) goto Bail;

    SendCommandProcessEvent( kHICommandNew );                           //  Send a kHICommandNew to ourselves to create a default new window

    RunApplicationEventLoop();

Bail:   

    if ( g.mainNib != NULL )    DisposeNibReference( g.mainNib );

    if ( g.mainBundle != NULL ) CFRelease( g.mainBundle );

    return( noErr );

}

static  OSErr   InitializeApplication( void )

{

    OSErr                       err;

    static const EventTypeSpec  sApplicationEvents[] =  {   { kEventClassCommand, kEventCommandProcess }    };

    BlockZero( &g, sizeof(g) );

    g.mainBundle = CFBundleGetMainBundle();

    if ( g.mainBundle == NULL )         { err = -1; goto Bail;  }

    if ( MPLibraryIsLoaded() == false ) { err = -1; goto Bail;  }

    err = CreateNibReferenceWithCFBundle( g.mainBundle, CFSTR("main"), &g.mainNib );

    if ( err != noErr ) goto Bail;

    if ( g.mainNib == NULL )        { err = -1; goto Bail;  }

    err = SetMenuBarFromNib( g.mainNib, CFSTR("MenuBar") );

    if ( err != noErr ) goto Bail;

    InstallApplicationEventHandler( NewEventHandlerUPP(AppEventEventHandlerProc), GetEventTypeCount(sApplicationEvents), sApplicationEvents, 0, NULL );

Bail:   

    return( err );

}

/*****************************************************

*

* DisplaySimpleWindow ( void ) 

*

* Purpose:  Called to create a new window in response to a kHICommandNew event.  Here we create a window, set up the MyMPTaskInfo structure,

*           and create an MP thread to monitor our specified directories.

*

*/

static  void    DisplaySimpleWindow( void )

{

    OSStatus                err;

    OSStatus                err1;

    WindowRef               window;

    ControlRef              control;

    MPTaskID                mpTaskID;

    MyMPTaskInfo            *mpTaskInfo;

    FSRef                   fsRef;

    char                    path[MAXPATHLEN];

    DialogRef               alertDialog;

    static  EventHandlerUPP mpWindowEventHandlerUPP;

    SInt32                  i           = -1;

    const EventTypeSpec windowEvents[]  =   {

                                                { kEventClassCommand, kEventCommandProcess },

                                                { kEventClassMP, kEventKQueue },

                                                { kEventClassWindow, kEventWindowClose }

                                            };

    err = CreateWindowFromNib( g.mainNib, CFSTR("MainWindow"), &window );

    if ( (err != noErr) || (window == NULL) )   goto Bail;

    if ( mpWindowEventHandlerUPP == NULL ) mpWindowEventHandlerUPP  = NewEventHandlerUPP( MPWindowEventHandlerProc );   //  MPWindowEventHandlerProc handles events for this window

    err = InstallWindowEventHandler( window, mpWindowEventHandlerUPP, GetEventTypeCount(windowEvents), windowEvents, window, NULL );

    //  Display the directories we are going to watch in the static text fields.  In this sample we hard code the values to a few specific locations

    err = FSFindFolder( kUserDomain, kDesktopFolderType, kDontCreateFolder, &fsRef );                               //  Watch the Desktop folder

    err1 = FSRefMakePath( &fsRef, (UInt8 *)path, MAXPATHLEN );

    if ( (err == noErr) && (err1 == noErr) )

        SetControlCString( window, 'STxt', ++i, path );

    err = FSFindFolder( kUserDomain, kDocumentsFolderType, kDontCreateFolder, &fsRef );                             //  Watch the Documents folder

    err1 = FSRefMakePath( &fsRef, (UInt8 *)path, MAXPATHLEN );

    if ( (err == noErr) && (err1 == noErr) )

        SetControlCString( window, 'STxt', ++i, path );

    err = FSFindFolder( kUserDomain, kCurrentUserFolderType, kDontCreateFolder, &fsRef );                           //  Watch the Users folder

    err1 = FSRefMakePath( &fsRef, (UInt8 *)path, MAXPATHLEN );

    if ( (err == noErr) && (err1 == noErr) )

        SetControlCString( window, 'STxt', ++i, path );

    mpTaskInfo  = (MyMPTaskInfo*) NewPtrClear( sizeof(MyMPTaskInfo) );

    SetWRefCon( window, (long) mpTaskInfo );

    for ( mpTaskInfo->count = 0 ; mpTaskInfo->count < kMaxFoldersToWatch ; mpTaskInfo->count++ )

    {

        GetControlCString( window, 'STxt', mpTaskInfo->count, mpTaskInfo->path[mpTaskInfo->count] );                //  This code pretty much just reads back the strings we set above

        if ( mpTaskInfo->path[mpTaskInfo->count][0] == '\0' )   break;

        //  We initialize a number of values which are not be safe to retrieve from an MP thread.

        GetControlBySigAndID( window, 'Date', mpTaskInfo->count, &mpTaskInfo->mpControlInfo[mpTaskInfo->count].dateControl );

        GetControlBySigAndID( window, 'STxt', mpTaskInfo->count, &control );

        mpTaskInfo->mpControlInfo[mpTaskInfo->count].eventTarget = GetControlEventTarget( control );

    }

    if ( mpTaskInfo->count < 1 )

    {

        DisposePtr( (Ptr) mpTaskInfo );

        goto Bail;

    }

    //  Create our MP thread and pass in mpTaskInfo.  MyMPTask is responsible for watching the passed in directories, and posting notifications of changes.

    err = MPCreateTask( MyMPTask, (void *) mpTaskInfo, 0, NULL, 0, 0, kNilOptions, &mpTaskID );

    if ( err != noErr )                                                                                             //  Alert if an error occured

    {

        CreateStandardAlert( kAlertStopAlert, CFSTR("MPCreateTask returned an error! Will not create window."), NULL, NULL, &alertDialog );

        RunStandardAlert( alertDialog, NULL, NULL );

        goto Bail;

    }

    ShowWindow( window );

Bail:

    return;

}

static  pascal  OSStatus AppEventEventHandlerProc( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData )

{

    #pragma unused ( inCallRef, inUserData )

    HICommand       command;

    OSStatus        err         = eventNotHandledErr;

    UInt32          eventClass  = GetEventClass( inEvent );

    UInt32          eventKind   = GetEventKind(inEvent);

    switch ( eventClass )

    {

        case kEventClassCommand:

            GetEventParameter( inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &command );

            if ( eventKind == kEventCommandProcess )

            {

                if ( command.commandID == kHICommandNew )

                {

                    DisplaySimpleWindow();

                }

            }

            break;

    }

    return( err );

}

/*****************************************************

*

* MPWindowEventHandlerProc ( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData ) 

*

* Purpose:  Window event handling routine

*

* Returns:  OSStatus    - eventNotHandledErr to allow other EventHandlers to run

*/

static  pascal  OSStatus    MPWindowEventHandlerProc( EventHandlerCallRef inCallRef, EventRef inEvent, void* inUserData )

{

    #pragma unused ( inCallRef, inUserData )

    LongDateRec             lDate;  

    LongDateTime            lSecs;

    unsigned long           secs;

    ControlRef              dateControl;

    WindowRef               window;

    struct kevent           kev;

    HICommand               command;

    FSRef                   fsRef;

    CFURLRef                urlRef          = NULL;

    CFURLRef                fullUrlRef      = NULL;

    OSStatus                err             = eventNotHandledErr;

    UInt32                  eventKind       = GetEventKind( inEvent );

    UInt32                  eventClass      = GetEventClass( inEvent );

    switch ( eventClass )

    {

        case kEventClassMP:

            if ( eventKind == kEventKQueue )

            {

                //  When we receive the kEventKQueue event, we update the date control associated with the path we are watching.

                GetEventParameter( inEvent, kEventParamDirectObject, typeKEvent, NULL, sizeof(struct kevent), NULL, &kev );

                GetEventParameter( inEvent, kEventParamControlRef, typeControlRef, NULL, sizeof(ControlRef), NULL, &dateControl );

                GetDateTime( &secs );

                lSecs   = secs;

                LongSecondsToDate( &lSecs, &lDate );

                (void) SetControlData( dateControl, 0, kControlClockLongDateTag, sizeof(lDate), &lDate );

                Draw1Control( dateControl );

                PrintKEvent( GetControlOwner( dateControl ) , &kev );   //  Display the kevent information

            }

            break;

        case kEventClassWindow:

            if ( eventKind == kEventWindowClose )

            {

                GetEventParameter( inEvent, kEventParamDirectObject, typeWindowRef, NULL, sizeof(WindowRef), NULL, &window );

                ((MyMPTaskInfo*)GetWRefCon( window ))->done  = true;    //  Flag the thread to terminate (thread checks at least every 30 seconds in this sample)

            }

            break;

        case kEventClassCommand:

            GetEventParameter( inEvent, kEventParamDirectObject, typeHICommand, NULL, sizeof(HICommand), NULL, &command );

            if ( eventKind == kEventCommandProcess )

            {

                if ( command.commandID == 'Help' )                      //  Our 'Help' command, just have LaunchServices open the "kqueue.pdf" file within our bundle.

                {

                    urlRef  = CFBundleCopyResourcesDirectoryURL( CFBundleGetMainBundle() );

                    fullUrlRef  = CFURLCreateCopyAppendingPathComponent( NULL, urlRef, CFSTR("kqueue.pdf"), false );

                    CFURLGetFSRef( fullUrlRef, &fsRef );

                    (void) LSOpenFSRef( &fsRef, NULL );                 //  Open the file

                    if ( urlRef != NULL )   CFRelease( urlRef );

                    if ( urlRef != NULL )   CFRelease( fullUrlRef );

                }

            }

            break;

    }

    return( err );

}

static  void    PrintKEvent( WindowRef window, struct kevent *kevp )

{

    char                s[512];

    char                descriptionText[512];

    static char *const  filter[]    = { "EVFILT_UNKNOWN",   /*  0 */

                                        "EVFILT_READ",      /* -1 */

                                        "EVFILT_WRITE",     /* -2 */

                                        "EVFILT_AIO",       /* -3 */

                                        "EVFILT_VNODE",     /* -4 */

                                        "EVFILT_PROC",      /* -5 */

                                        "EVFILT_SIGNAL",    /* -6 */

                                        "EVFILT_TIMER",     /* -7 */

                                        "EVFILT_MACHPORT"   /* -8 */

                                        };

    sprintf( descriptionText, "\tident=%d, filter=%s,", (int)kevp->ident, filter[-kevp->filter] );

    if ( kevp->flags == 0 )

    {

        sprintf( s, " flags=0x0000, " );

        strcat( descriptionText, s );

    }

    else

    {

        sprintf( s, " flags=0x%04x (%s%s%s%s%s%s%s%s), ",

                        kevp->flags,

                        (kevp->flags & EV_EOF) ? "EV_EOF" : "",

                        (kevp->flags & EV_ERROR)    ? ((kevp->flags & (~(EV_ERROR - 1) & ~EV_ERROR)) ? " | EV_ERROR" : "EV_ERROR") : "",

                        (kevp->flags & EV_ADD)      ? ((kevp->flags & (EV_SYSFLAGS | (EV_ADD - 1))) ? " | EV_ADD" : "EV_ADD") : "",

                        (kevp->flags & EV_DELETE)   ? ((kevp->flags & (EV_SYSFLAGS | (EV_DELETE - 1))) ? " | EV_DELETE" : "EV_DELETE") : "",

                        (kevp->flags & EV_ENABLE)   ? ((kevp->flags & (EV_SYSFLAGS | (EV_ENABLE - 1))) ? " | EV_ENABLE" : "EV_ENABLE") : "",

                        (kevp->flags & EV_DISABLE)  ? ((kevp->flags & (EV_SYSFLAGS | (EV_DISABLE - 1))) ? " | EV_DISABLE" : "EV_DISABLE") : "",

                        (kevp->flags & EV_ONESHOT)  ? ((kevp->flags & (EV_SYSFLAGS | (EV_ONESHOT - 1))) ? " | EV_ONESHOT" : "EV_ONESHOT") : "",

                        (kevp->flags & EV_CLEAR)    ? ((kevp->flags & (EV_SYSFLAGS | (EV_CLEAR - 1))) ? " | EV_CLEAR" : "EV_CLEAR") : "" );

        strcat( descriptionText, s );

    }

    sprintf( s, "fflags=0x%08x (%s%s%s%s%s%s%s)\n",

                        kevp->fflags,

                        (kevp->fflags & NOTE_DELETE) ? "NOTE_DELETE" : "",

                        (kevp->fflags & NOTE_WRITE) ? ((kevp->fflags & (NOTE_WRITE - 1)) ? " | NOTE_WRITE" : "NOTE_WRITE") : "",

                        (kevp->fflags & NOTE_EXTEND) ? ((kevp->fflags & (NOTE_EXTEND - 1)) ? " | NOTE_EXTEND" : "NOTE_EXTEND") : "",

                        (kevp->fflags & NOTE_ATTRIB) ? ((kevp->fflags & (NOTE_ATTRIB - 1)) ? " | NOTE_ATTRIB" : "NOTE_ATTRIB") : "",

                        (kevp->fflags & NOTE_LINK) ? ((kevp->fflags & (NOTE_LINK - 1)) ? " | NOTE_LINK" : "NOTE_LINK") : "",

                        (kevp->fflags & NOTE_RENAME) ? ((kevp->fflags & (NOTE_RENAME - 1)) ? " | NOTE_RENAME" : "NOTE_RENAME") : "",

                        (kevp->fflags & NOTE_REVOKE) ? ((kevp->fflags & (NOTE_REVOKE - 1)) ? " | NOTE_REVOKE" : "NOTE_REVOKE") : "" );

    strcat( descriptionText, s );

    sprintf( s, "\tdata = %d, udata = 0x%08lx\n", (int)kevp->data, (unsigned long)kevp->udata );

    strcat( descriptionText, s );

    (void) SetControlCString( window, 'STxt', 100, descriptionText );

}

#pragma mark -

#pragma mark ¥ Routines running on MP Thread ¥

/*****************************************************

*

* MyMPTask ( void *parameter ) 

*

* Purpose:  This routine is the entry point for our MP thread called from DisplaySimpleWindow().  It sets up the array of kevent

*           structures, and then loops while calling kevent(). The calls to kevent() block until one of the events, vnode_events,

*           we are interested in occurs to one of the file descriptors we are watching.  After we receive notification, we then 

*           post the information back to the main event queue for display.

*

* Inputs:   parameter   - MyMPTaskInfo* set up within DisplaySimpleWindow().

*

* Returns:  OSStatus    - Error

*/

static  OSStatus    MyMPTask( void *parameter )

{

    int             i;

    int             kq;

    int             ev_count;

    struct kevent   *kevp;

    struct kevent   ev_change[kMaxFoldersToWatch];

    int             fd[kMaxFoldersToWatch];

    MyMPTaskInfo    *mpTaskInfo                     = (MyMPTaskInfo *) parameter;                       //  Our passed in data from DisplaySimpleWindow()

    OSStatus        err                             = noErr;

    int             foldersToWatch                  = 0;

    struct kevent   ev_receive[kMaxFoldersToWatch]  = { { 0 } };

    struct timespec timeOut                         = { 30, 0 };                                        //  Time out 30 seconds, we check mpTaskInfo->done at leaset every 30 seconds

    u_int           vnode_events                    = NOTE_DELETE |  NOTE_WRITE | NOTE_EXTEND |         //  Events we are interested in watching

                                                      NOTE_ATTRIB | NOTE_LINK | NOTE_RENAME | NOTE_REVOKE;

    if ( (kq = kqueue()) < 0 )  goto Bail;

    for ( foldersToWatch = 0 ; foldersToWatch < mpTaskInfo->count ; foldersToWatch++ )

    {

        //  Currently the O_EVTONLY is designed so that to keep a dir file descriptor open without stopping users from unmounting the disk. ÊHFS+ only on 10.3

        fd[foldersToWatch]  = open( mpTaskInfo->path[foldersToWatch], O_EVTONLY );                      //  Open a descriptor for each directory we are watching

        if ( fd[foldersToWatch] <= 0 )  break;                                                          //  If we get any errors, just break and continue with what we have

        EV_SET( &ev_change[foldersToWatch], fd[foldersToWatch], EVFILT_VNODE, EV_ADD | EV_CLEAR, vnode_events, 0, &(mpTaskInfo->mpControlInfo[foldersToWatch]) );

    }

    //  The main worker loop

    ev_count    = kevent( kq, ev_change, foldersToWatch, ev_receive, kMaxFoldersToWatch, &timeOut );    //  First call kevent specifying the number of folders to watch

    while ( (ev_count >= 0) && (mpTaskInfo->done != true) )                                             //  If error, or window closed (setting done to true) fall through to Bail

    {

        for ( i = 0 ; i < ev_count ; i++ )

        {

            kevp    = &ev_receive[i];

            if ( kevp->flags == EV_ERROR )  goto Bail;

            PostKQueueEvent( kevp );                                                                    //  Post kevent

        }

        ev_count    = kevent( kq, ev_change, 0, ev_receive, kMaxFoldersToWatch, &timeOut );             //  Subsequent calls to kevent we will not be watching any additional file descriptors

    }

Bail:

    for ( i = 0 ; i < foldersToWatch ; i++ )                                                            //  Clean up and close any open file descriptors

        (void) close( fd[i] );

    DisposePtr( (Ptr) mpTaskInfo );

    return( err );

}

OSStatus    PostKQueueEvent( struct kevent *kevp )

{

    OSStatus                err             = noErr;

    EventRef                event           = NULL;

    MPControlInfo           *mpControl      = kevp->udata;

    err = CreateEvent( NULL,  kEventClassMP, kEventKQueue, GetCurrentEventTime(), kEventAttributeNone, &event );

    if ( err != noErr ) goto Bail;

    err = SetEventParameter( event, kEventParamDirectObject, typeKEvent, sizeof(struct kevent), kevp );     //  Send the kevent

    if ( err != noErr ) goto Bail;

    err = SetEventParameter( event, kEventParamPostTarget, typeEventTargetRef, sizeof(void*), &mpControl->eventTarget );    //  Target the date control

    if ( err != noErr ) goto Bail;

    err = SetEventParameter( event, kEventParamControlRef, typeControlRef, sizeof(ControlRef), &mpControl->dateControl );   //  ControlRef to update

    if ( err != noErr ) goto Bail;

    err = PostEventToQueue( GetMainEventQueue(), event, kEventPriorityStandard );                       //  Post the event to the main event queue on the main thread

Bail:

    if ( event != NULL )    (void) ReleaseEvent( event );

    return( err );

}