Update cy+ dependencies.

[cydget.git] / LockScreen.mm

/* Cydget - open-source AwayView plugin multiplexer
 * Copyright (C) 2009-2011  Jay Freeman (saurik)
*/

/*
 *        Redistribution and use in source and binary
 * forms, with or without modification, are permitted
 * provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the
 *    above copyright notice, this list of conditions
 *    and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the
 *    above copyright notice, this list of conditions
 *    and the following disclaimer in the documentation
 *    and/or other materials provided with the
 *    distribution.
 * 3. The name of the author may not be used to endorse
 *    or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS''
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

#include <substrate.h>
#include <sys/sysctl.h>

#import <GraphicsServices/GraphicsServices.h>
#import <UIKit/UIKit.h>
#import <AddressBook/AddressBook.h>

#import <SpringBoard/SBStatusBarController.h>
#import <SpringBoardUI/SBAwayViewPluginController.h>
#import <TelephonyUI/TPBottomLockBar.h>

#import <QuartzCore/CALayer.h>
// XXX: fix the minimum requirement
extern NSString * const kCAFilterNearest;

#include <WebKit/DOMCSSPrimitiveValue.h>
#include <WebKit/DOMCSSStyleDeclaration.h>
#include <WebKit/DOMDocument.h>
#include <WebKit/DOMHTMLBodyElement.h>
#include <WebKit/DOMNodeList.h>
#include <WebKit/DOMRGBColor.h>

#include <WebKit/WebFrame.h>
#include <WebKit/WebPolicyDelegate.h>
#include <WebKit/WebPreferences.h>
#include <WebKit/WebScriptObject.h>

#import <WebKit/WebView.h>
#import <WebKit/WebView-WebPrivate.h>

#include <WebCore/Page.h>
#include <WebCore/Settings.h>

#include <WebCore/WebCoreThread.h>
#include <WebKit/WebPreferences-WebPrivate.h>

#include "JSGlobalData.h"

#include "SourceCode.h"

#include <apr-1/apr_pools.h>
#include <pcre.h>

#define _transient
#define _forever for (;;)

_disused static unsigned trace_;

#define _trace() do { \
    NSLog(@"_trace(%u)@%s:%u[%s](%p)\n", \
        trace_++, __FILE__, __LINE__, __FUNCTION__, pthread_self() \
    ); \
} while (false)

#define _assert(test) do \
    if (!(test)) { \
        fprintf(stderr, "_assert(%d:%s)@%s:%u[%s]\n", errno, #test, __FILE__, __LINE__, __FUNCTION__); \
        exit(-1); \
    } \
while (false)

#define _syscall(expr) \
    do if ((long) (expr) != -1) \
        break; \
    else switch (errno) { \
        case EINTR: \
            continue; \
        default: \
            _assert(false); \
    } while (true)

@protocol CydgetController
- (NSDictionary *) currentConfiguration;
@end

static Class $CydgetController(objc_getClass("CydgetController"));

MSClassHook(UIWebBrowserView)

static bool Wildcat_, iOS4;

@interface NSString (UIKit)
- (NSString *) stringByAddingPercentEscapes;
@end

@implementation UIWebDocumentView (WebCycript)

- (void) _setScrollerOffset:(CGPoint)offset {
    UIScroller *scroller([self _scroller]);

    CGSize size([scroller contentSize]);
    CGSize bounds([scroller bounds].size);

    CGPoint max;
    max.x = size.width - bounds.width;
    max.y = size.height - bounds.height;

    // wtf Apple?!
    if (max.x < 0)
        max.x = 0;
    if (max.y < 0)
        max.y = 0;

    offset.x = offset.x < 0 ? 0 : offset.x > max.x ? max.x : offset.x;
    offset.y = offset.y < 0 ? 0 : offset.y > max.y ? max.y : offset.y;

    [scroller setOffset:offset];
}

@end

/* Perl-Compatible RegEx {{{ */
class Pcre {
  private:
    pcre *code_;
    pcre_extra *study_;
    int capture_;
    int *matches_;
    const char *data_;

  public:
    Pcre(const char *regex, int options = 0) :
        study_(NULL)
    {
        const char *error;
        int offset;
        code_ = pcre_compile(regex, options, &error, &offset, NULL);

        if (code_ == NULL)
            @throw [NSException exceptionWithName:NSInvalidArgumentException reason:[NSString stringWithFormat:@"*** Pcre(,): [%u] %s", offset, error] userInfo:nil];

        pcre_fullinfo(code_, study_, PCRE_INFO_CAPTURECOUNT, &capture_);
        matches_ = new int[(capture_ + 1) * 3];
    }

    ~Pcre() {
        pcre_free(code_);
        delete matches_;
    }

    NSString *operator [](size_t match) {
        return [[[NSString alloc] initWithBytes:(data_ + matches_[match * 2]) length:(matches_[match * 2 + 1] - matches_[match * 2]) encoding:NSUTF8StringEncoding] autorelease];
    }

    bool operator ()(NSString *data) {
        // XXX: length is for characters, not for bytes
        return operator ()([data UTF8String], [data length]);
    }

    bool operator ()(const char *data, size_t size) {
        data_ = data;
        return pcre_exec(code_, study_, data, size, 0, 0, matches_, (capture_ + 1) * 3) >= 0;
    }
};
/* }}} */

static float CYScrollViewDecelerationRateNormal;

@interface UIScrollView (Apple)
- (void) setDecelerationRate:(float)value;
- (void) setScrollingEnabled:(BOOL)enabled;
@end

@interface UIWebView (Apple)
- (void) setDataDetectorTypes:(int)types;
- (UIScrollView *) _scrollView;
- (UIScroller *) _scroller;
- (void) webView:(WebView *)view didClearWindowObject:(WebScriptObject *)window forFrame:(WebFrame *)frame;
@end

@interface WebView (Apple)
- (void) _setLayoutInterval:(float)interval;
- (void) _setAllowsMessaging:(BOOL)allows;
- (void) setShouldUpdateWhileOffscreen:(BOOL)update;
@end

@protocol CydgetWebViewDelegate //<UIWebViewDelegate>
- (void) webView:(WebView *)view didClearWindowObject:(WebScriptObject *)window forFrame:(WebFrame *)frame;
@end

@class UIWebViewWebViewDelegate;

@interface CydgetWebView : UIWebView {
}

@end

@implementation CydgetWebView

- (void) webView:(WebView *)view decidePolicyForNavigationAction:(NSDictionary *)action request:(NSURLRequest *)request frame:(WebFrame *)frame decisionListener:(id<WebPolicyDecisionListener>)listener {
    [listener use];
}

- (void) webView:(WebView *)view didClearWindowObject:(WebScriptObject *)window forFrame:(WebFrame *)frame {
    NSObject<CydgetWebViewDelegate> *delegate([self delegate]);
    if ([delegate respondsToSelector:@selector(webView:didClearWindowObject:forFrame:)])
        [delegate webView:view didClearWindowObject:window forFrame:frame];
    if ([UIWebView instancesRespondToSelector:@selector(webView:didClearWindowObject:forFrame:)])
        [super webView:view didClearWindowObject:window forFrame:frame];
}

@end

@interface WebCydgetLockScreenView : UIView {
    CydgetWebView *webview_;
    UIScrollView *scroller_;
    NSString *cycript_;
}

@end

@implementation WebCydgetLockScreenView

//#include "UICaboodle/UCInternal.h"

- (void) dealloc {
    [webview_ setDelegate:nil];
    [webview_ release];
    [super dealloc];
}

- (void) loadRequest:(NSURLRequest *)request {
    [webview_ loadRequest:request];
}

- (void) loadURL:(NSURL *)url cachePolicy:(NSURLRequestCachePolicy)policy {
    [self loadRequest:[NSURLRequest
        requestWithURL:url
        cachePolicy:policy
        timeoutInterval:30.0
    ]];
}

- (void) loadURL:(NSURL *)url {
    [self loadURL:url cachePolicy:NSURLRequestUseProtocolCachePolicy];
}

- (id) init {
    CGRect frame = {{0, 0}, {320, 480}};
    frame.size.height -= 20; //[[[$SBStatusBarController sharedStatusBarController] statusBarView] frame].size.height;

    if ((self = [super initWithFrame:frame]) != nil) {
        CGRect bounds([self bounds]);
        bounds.size.height -= [TPBottomLockBar defaultHeight];

        webview_ = [[CydgetWebView alloc] initWithFrame:bounds];
        [webview_ setDelegate:self];
        [self addSubview:webview_];

        if ([webview_ respondsToSelector:@selector(setDataDetectorTypes:)])
            [webview_ setDataDetectorTypes:0x80000000];
        else
            [webview_ setDetectsPhoneNumbers:NO];

        [webview_ setScalesPageToFit:YES];

        UIWebDocumentView *document([webview_ _documentView]);
        WebView *webview([document webView]);
        WebPreferences *preferences([webview preferences]);

        [document setTileSize:CGSizeMake(bounds.size.width, 500)];

        [document setBackgroundColor:[UIColor blackColor]];
        [document setDrawsBackground:NO];

        [webview setPreferencesIdentifier:@"WebCycript"];

        if ([webview respondsToSelector:@selector(_setLayoutInterval:)])
            [webview _setLayoutInterval:0];
        else
            [preferences _setLayoutInterval:0];

        [preferences setCacheModel:WebCacheModelDocumentViewer];
        [preferences setJavaScriptCanOpenWindowsAutomatically:YES];
        [preferences setOfflineWebApplicationCacheEnabled:YES];

        if ([webview respondsToSelector:@selector(setShouldUpdateWhileOffscreen:)])
            [webview setShouldUpdateWhileOffscreen:NO];

        if ([document respondsToSelector:@selector(setAllowsMessaging:)])
            [document setAllowsMessaging:YES];
        if ([webview respondsToSelector:@selector(_setAllowsMessaging:)])
            [webview _setAllowsMessaging:YES];

        if ([webview_ respondsToSelector:@selector(_scrollView)]) {
            scroller_ = [webview_ _scrollView];

            [scroller_ setDirectionalLockEnabled:YES];
            [scroller_ setDecelerationRate:CYScrollViewDecelerationRateNormal];
            [scroller_ setDelaysContentTouches:NO];

            [scroller_ setCanCancelContentTouches:YES];
        } else if ([webview_ respondsToSelector:@selector(_scroller)]) {
            UIScroller *scroller([webview_ _scroller]);
            scroller_ = (UIScrollView *) scroller;

            [scroller setDirectionalScrolling:YES];
            [scroller setScrollDecelerationFactor:CYScrollViewDecelerationRateNormal]; /* 0.989324 */
            [scroller setScrollHysteresis:0]; /* 8 */

            [scroller setThumbDetectionEnabled:NO];
        }

        [scroller_ setFixedBackgroundPattern:YES];
        [scroller_ setBackgroundColor:[UIColor blackColor]];
        [scroller_ setClipsSubviews:NO];

        [scroller_ setBounces:YES];
        [scroller_ setShowBackgroundShadow:NO]; /* YES */

        [self setAutoresizingMask:(UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight)];
        [webview_ setAutoresizingMask:(UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight)];

        NSDictionary *configuration([$CydgetController currentConfiguration]);

        cycript_ = [configuration objectForKey:@"CycriptURLs"];

        [scroller_ setScrollingEnabled:[[configuration objectForKey:@"Scrollable"] boolValue]];

        NSString *homepage([configuration objectForKey:@"Homepage"]);
        [self loadURL:[NSURL URLWithString:homepage]];
    } return self;
}

- (void) webView:(WebView *)webview didClearWindowObject:(WebScriptObject *)window forFrame:(WebFrame *)frame {
    if (cycript_ != nil)
        if (NSString *href = [[[[frame dataSource] request] URL] absoluteString])
            if (Pcre([cycript_ UTF8String], 0 /*XXX:PCRE_UTF8*/)(href))
                if (void *handle = dlopen("/usr/lib/libcycript.dylib", RTLD_LAZY | RTLD_GLOBAL))
                    if (void (*CYSetupContext)(JSGlobalContextRef) = reinterpret_cast<void (*)(JSGlobalContextRef)>(dlsym(handle, "CydgetSetupContext"))) {
                        WebFrame *frame([webview mainFrame]);
                        JSGlobalContextRef context([frame globalContext]);
                        CYSetupContext(context);
                    }
}

@end

@interface WebCycriptLockScreenController : SBAwayViewPluginController {
}

@end

#include <string>

struct State {
    unsigned state;
};

// String Helpers {{{
static const UChar *(*_ZNK7WebCore6String10charactersEv)(const WebCore::String *);
static const UChar *(*_ZN7WebCore6String29charactersWithNullTerminationEv)(const WebCore::String *);
static unsigned (*_ZNK7WebCore6String6lengthEv)(const WebCore::String *);

static bool StringGet(const WebCore::String &string, const UChar *&data, size_t &length) {
    bool terminated;

    if (_ZNK7WebCore6String10charactersEv != NULL) {
        data = (*_ZNK7WebCore6String10charactersEv)(&string);
        terminated = false;
    } else if (_ZN7WebCore6String29charactersWithNullTerminationEv != NULL) {
        data = (*_ZN7WebCore6String29charactersWithNullTerminationEv)(&string);
        terminated = true;
    } else return false;

    if (_ZNK7WebCore6String6lengthEv != NULL)
        length = (*_ZNK7WebCore6String6lengthEv)(&string);
    else if (terminated)
        for (length = 0; data[length] != 0; ++length);
    else return false;

    return true;
}

static bool StringEquals(const WebCore::String &string, const char *value) {
    const UChar *data;
    size_t size;
    if (!StringGet(string, data, size))
        return false;

    size_t length(strlen(value));
    if (size != length)
        return false;

    for (size_t index(0); index != length; ++index)
        if (data[index] != value[index])
            return false;

    return true;
}
// }}}
// State Machine {{{
static bool cycript_;

MSHook(bool, _ZN7WebCore16MIMETypeRegistry29isSupportedJavaScriptMIMETypeERKNS_6StringE, const WebCore::String &mime) {
    if (!StringEquals(mime, "text/cycript")) {
        cycript_ = false;
        return __ZN7WebCore16MIMETypeRegistry29isSupportedJavaScriptMIMETypeERKNS_6StringE(mime);
    }

    static void *handle(dlopen("/usr/lib/libcycript.dylib", RTLD_LAZY | RTLD_GLOBAL));
    if (handle == NULL)
        return false;

    cycript_ = true;
    return true;
}
// }}}
// Script Compiler {{{
static void Log(const WebCore::String &string) {
#if 0
    const UChar *data;
    size_t length;
    if (!StringGet(string, data, length))
        return;

    UChar terminated[length + 1];
    terminated[length] = 0;
    memcpy(terminated, data, length * 2);
    NSLog(@"wtf %p:%zu:%S:", &string, length, terminated);
#endif
}

static void Cycriptify(apr_pool_t *pool, const uint16_t *&data, size_t &size) {
    cycript_ = false;

    if (void *handle = dlopen("/usr/lib/libcycript.dylib", RTLD_LAZY | RTLD_GLOBAL))
        if (void (*CydgetPoolParse)(apr_pool_t *, const uint16_t **, size_t *) = reinterpret_cast<void (*)(apr_pool_t *, const uint16_t **, size_t *)>(dlsym(handle, "CydgetPoolParse")))
            CydgetPoolParse(pool, &data, &size);
}

static void (*_ZN7WebCore6String6appendEPKtj)(WebCore::String *, const UChar *, unsigned);
static void (*_ZN7WebCore6String8truncateEj)(WebCore::String *, unsigned);

static void Cycriptify(const WebCore::String &source, int *psize = NULL) {
    if (!cycript_)
        return;

    const UChar *data;
    size_t length;

    if (!StringGet(source, data, length)) {
        return;
    }

    size_t size(length);

    apr_pool_t *pool;
    apr_pool_create(&pool, NULL);

    Cycriptify(pool, data, size);

    WebCore::String &script(const_cast<WebCore::String &>(source));

    _ZN7WebCore6String8truncateEj(&script, 0);
    _ZN7WebCore6String6appendEPKtj(&script, data, size);

    if (psize != NULL)
        *psize = size;

    apr_pool_destroy(pool);

    Log(source);
}
// }}}

extern "C" void *_ZN3JSC7UString3Rep14nullBaseStringE __attribute__((__weak_import__));
extern "C" void *_ZN3JSC7UString3Rep7destroyEv __attribute__((__weak_import__));
extern "C" void *_ZN3JSC7UStringC1EPKti __attribute__((__weak_import__));
extern "C" void *_ZN3JSC7UStringC1EPKc __attribute__((__weak_import__));
extern "C" void *_ZNK3JSC7UString6substrEii __attribute__((__weak_import__));
extern "C" void *_ZN3WTF10fastMallocEm __attribute__((__weak_import__));
extern "C" void WTFReportAssertionFailure(const char *, int, const char *, const char *) __attribute__((__weak_import__));
extern "C" void *_ZN3WTF8fastFreeEPv __attribute__((__weak_import__));

bool CYWeakHell() {
    return
        &_ZN3JSC7UString3Rep14nullBaseStringE == NULL ||
        &_ZN3JSC7UString3Rep7destroyEv == NULL ||
        &_ZN3JSC7UStringC1EPKti == NULL ||
        &_ZN3JSC7UStringC1EPKc == NULL ||
        &_ZNK3JSC7UString6substrEii == NULL ||
        &_ZN3WTF10fastMallocEm == NULL ||
        &WTFReportAssertionFailure == NULL ||
        &_ZN3WTF8fastFreeEPv == NULL ||
    false;
}

static WebCore::String *string;

// iOS 2.x
MSHook(State, _ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_6StringENS0_5StateES3_i, void *_this, const WebCore::String &string, State state, const WebCore::String &url, int line) {
    Cycriptify(string);
    return __ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_6StringENS0_5StateES3_i(_this, string, state, url, line);
}

// iOS 3.x
MSHook(void, _ZN3JSC6Parser5parseEPNS_12JSGlobalDataEPiPNS_7UStringE, JSC::SourceCode **_this, JSC::JSGlobalData *global, int *line, JSC::UString *message) {
    if (cycript_) {
        JSC::SourceCode *source(*_this);
        const uint16_t *data(source->data());
        size_t size(source->length());

        apr_pool_t *pool;
        apr_pool_create(&pool, NULL);

        Cycriptify(pool, data, size);
        source->~SourceCode();
        // XXX: I actually don't have the original URL here: pants
        new (source) JSC::SourceCode(JSC::UStringSourceProvider::create(JSC::UString(data, size), "cycript://"), 1);

        apr_pool_destroy(pool);

    }

    return __ZN3JSC6Parser5parseEPNS_12JSGlobalDataEPiPNS_7UStringE(_this, global, line, message);
}

// iOS 4.x cdata
MSHook(void, _ZN7WebCore16ScriptSourceCodeC2ERKNS_6StringERKNS_4KURLEi, void *_this, const WebCore::String &source, const WebCore::KURL &url, int line) {
    Cycriptify(source);
    return __ZN7WebCore16ScriptSourceCodeC2ERKNS_6StringERKNS_4KURLEi(_this, source, url, line);
}

// iOS 4.x @src=
MSHook(const WebCore::String &, _ZN7WebCore12CachedScript6scriptEv, void *_this) {
    const WebCore::String &script(__ZN7WebCore12CachedScript6scriptEv(_this));
    string = const_cast<WebCore::String *>(&script);
    Log(script);
    return script;
}

// iOS 4.x @src=
MSHook(State, _ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_16ScriptSourceCodeENS0_5StateE, void *_this, void *source, State state) {
    if (string != NULL) {
        if (iOS4)
            Cycriptify(*string, reinterpret_cast<int *>(source) + 3);
        else
            Cycriptify(*string);
    }
    string = NULL;
    return __ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_16ScriptSourceCodeENS0_5StateE(_this, source, state);
}

/* Cydget:// Protocol {{{ */
@interface CydgetURLProtocol : NSURLProtocol {
}

@end

@implementation CydgetURLProtocol

+ (BOOL) canInitWithRequest:(NSURLRequest *)request {
    NSURL *url([request URL]);
    if (url == nil)
        return NO;
    NSString *scheme([[url scheme] lowercaseString]);
    if (scheme == nil || ![scheme isEqualToString:@"cydget"])
        return NO;
    return YES;
}

+ (NSURLRequest *) canonicalRequestForRequest:(NSURLRequest *)request {
    return request;
}

- (void) _returnPNGWithImage:(UIImage *)icon forRequest:(NSURLRequest *)request {
    id<NSURLProtocolClient> client([self client]);
    if (icon == nil)
        [client URLProtocol:self didFailWithError:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorFileDoesNotExist userInfo:nil]];
    else {
        NSData *data(UIImagePNGRepresentation(icon));

        NSURLResponse *response([[[NSURLResponse alloc] initWithURL:[request URL] MIMEType:@"image/png" expectedContentLength:-1 textEncodingName:nil] autorelease]);
        [client URLProtocol:self didReceiveResponse:response cacheStoragePolicy:NSURLCacheStorageNotAllowed];
        [client URLProtocol:self didLoadData:data];
        [client URLProtocolDidFinishLoading:self];
    }
}

- (void) startLoading {
    id<NSURLProtocolClient> client([self client]);
    NSURLRequest *request([self request]);

    NSURL *url([request URL]);
    NSString *href([url absoluteString]);

    NSString *path([href substringFromIndex:9]);
    NSRange slash([path rangeOfString:@"/"]);

    NSString *command;
    if (slash.location == NSNotFound) {
        command = path;
        path = nil;
    } else {
        command = [path substringToIndex:slash.location];
        path = [path substringFromIndex:(slash.location + 1)];
    }

    if ([command isEqualToString:@"_UIImageWithName"]) {
        if (path == nil)
            goto fail;
        path = [path stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
        UIImage *icon(_UIImageWithName(path));
        [self _returnPNGWithImage:icon forRequest:request];
    } else fail: {
        [client URLProtocol:self didFailWithError:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorResourceUnavailable userInfo:nil]];
    }
}

- (void) stopLoading {
}

@end
/* }}} */
/* Cydget-CGI:// Protocol {{{ */
@interface CydgetCGIURLProtocol : NSURLProtocol {
    pid_t pid_;
    CFHTTPMessageRef http_;
    NSFileHandle *handle_;
}

@end

@implementation CydgetCGIURLProtocol

+ (BOOL) canInitWithRequest:(NSURLRequest *)request {
    NSURL *url([request URL]);
    if (url == nil)
        return NO;
    NSString *scheme([[url scheme] lowercaseString]);
    if (scheme == nil || ![scheme isEqualToString:@"cydget-cgi"])
        return NO;
    return YES;
}

+ (NSURLRequest *) canonicalRequestForRequest:(NSURLRequest *)request {
    return request;
}

- (id) initWithRequest:(NSURLRequest *)request cachedResponse:(NSCachedURLResponse *)response client:(id<NSURLProtocolClient>)client {
    if ((self = [super initWithRequest:request cachedResponse:response client:client]) != nil) {
        pid_ = -1;
    } return self;
}

- (void) startLoading {
    id<NSURLProtocolClient> client([self client]);
    NSURLRequest *request([self request]);
    NSURL *url([request URL]);

    NSString *path([url path]);
    if (path == nil) {
        [client URLProtocol:self didFailWithError:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorResourceUnavailable userInfo:nil]];
        return;
    }

    NSFileManager *manager([NSFileManager defaultManager]);
    if (![manager fileExistsAtPath:path]) {
        [client URLProtocol:self didFailWithError:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorFileDoesNotExist userInfo:nil]];
        return;
    }

    int fds[2];
    _assert(pipe(fds) != -1);

    _assert(pid_ == -1);
    pid_ = fork();
    if (pid_ == -1) {
        _assert(close(fds[0]) != -1);
        _assert(close(fds[1]) != -1);
        [client URLProtocol:self didFailWithError:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorResourceUnavailable userInfo:nil]];
        return;
    }

    if (pid_ == 0) {
        const char *script([path UTF8String]);

        setenv("GATEWAY_INTERFACE", "CGI/1.1", true);
        setenv("SCRIPT_FILENAME", script, true);
        NSString *query([url query]);
        if (query != nil)
            setenv("QUERY_STRING", [query UTF8String], true);

        _assert(dup2(fds[1], 1) != -1);
        _assert(close(fds[0]) != -1);
        _assert(close(fds[1]) != -1);

        execl(script, script, NULL);
        exit(1);
        _assert(false);
    }

    _assert(close(fds[1]) != -1);

    _assert(http_ == NULL);
    http_ = CFHTTPMessageCreateEmpty(kCFAllocatorDefault, FALSE);
    CFHTTPMessageAppendBytes(http_, (const uint8_t *) "HTTP/1.1 200 OK\r\n", 17);

    _assert(handle_ == nil);
    handle_ = [[NSFileHandle alloc] initWithFileDescriptor:fds[0] closeOnDealloc:YES];

    [[NSNotificationCenter defaultCenter]
        addObserver:self
        selector:@selector(onRead:)
        name:@"NSFileHandleReadCompletionNotification"
        object:handle_
    ];

    [handle_ readInBackgroundAndNotify];
}

- (void) onRead:(NSNotification *)notification {
    NSFileHandle *handle([notification object]);

    NSData *data([[notification userInfo] objectForKey:NSFileHandleNotificationDataItem]);

    if (size_t length = [data length]) {
        CFHTTPMessageAppendBytes(http_, reinterpret_cast<const UInt8 *>([data bytes]), length);
        [handle readInBackgroundAndNotify];
    } else {
        id<NSURLProtocolClient> client([self client]);

        CFStringRef mime(CFHTTPMessageCopyHeaderFieldValue(http_, CFSTR("Content-type")));
        if (mime == NULL)
            [client URLProtocol:self didFailWithError:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorBadServerResponse userInfo:nil]];
        else {
            NSURLRequest *request([self request]);

            NSURLResponse *response([[[NSURLResponse alloc] initWithURL:[request URL] MIMEType:(NSString *)mime expectedContentLength:-1 textEncodingName:nil] autorelease]);
            CFRelease(mime);

            [client URLProtocol:self didReceiveResponse:response cacheStoragePolicy:NSURLCacheStorageNotAllowed];

            CFDataRef body(CFHTTPMessageCopyBody(http_));
            [client URLProtocol:self didLoadData:(NSData *)body];
            CFRelease(body);

            [client URLProtocolDidFinishLoading:self];
        }

        CFRelease(http_);
        http_ = NULL;
    }
}

    //[client URLProtocol:self didFailWithError:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorNetworkConnectionLost userInfo:nil]];

- (void) stopLoading_ {
    [[NSNotificationCenter defaultCenter] removeObserver:self];

    if (handle_ != nil) {
        [handle_ release];
        handle_ = nil;
    }

    if (pid_ != -1) {
        kill(pid_, SIGTERM);
        int status;
        _syscall(waitpid(pid_, &status, 0));
        pid_ = -1;
    }
}

- (void) stopLoading {
    [self
        performSelectorOnMainThread:@selector(stopLoading_)
        withObject:nil
        waitUntilDone:NO
    ];
}

@end
/* }}} */

template <typename Type_>
static void nlset(Type_ &function, struct nlist *nl, size_t index) {
    struct nlist &name(nl[index]);
    uintptr_t value(name.n_value);
    if ((name.n_desc & N_ARM_THUMB_DEF) != 0)
        value |= 0x00000001;
    function = reinterpret_cast<Type_>(value);
}

template <typename Type_>
static void dlset(Type_ &function, const char *name) {
    function = reinterpret_cast<Type_>(dlsym(RTLD_DEFAULT, name));
}

template <typename Type_>
static void msset_(Type_ &function, const char *name, MSImageRef handle) {
    function = reinterpret_cast<Type_>(MSFindSymbol(handle, name));
}

#define msset(function, handle) \
    msset_(function, "_" #function, handle)

@implementation WebCycriptLockScreenController

static void $UIWebViewWebViewDelegate$webView$didClearWindowObject$forFrame$(UIWebViewWebViewDelegate *self, SEL sel, WebView *view, WebScriptObject *window, WebFrame *frame) {
    UIWebView *uiWebView(MSHookIvar<UIWebView *>(self, "uiWebView"));
    if ([uiWebView respondsToSelector:@selector(webView:didClearWindowObject:forFrame:)])
        [uiWebView webView:view didClearWindowObject:window forFrame:frame];
}

+ (void) initialize {
    if (Class $UIWebViewWebViewDelegate = objc_getClass("UIWebViewWebViewDelegate"))
        class_addMethod($UIWebViewWebViewDelegate, @selector(webView:didClearWindowObject:forFrame:), (IMP) &$UIWebViewWebViewDelegate$webView$didClearWindowObject$forFrame$, "v20@0:4@8@12@16");

    if (float *_UIScrollViewDecelerationRateNormal = reinterpret_cast<float *>(dlsym(RTLD_DEFAULT, "UIScrollViewDecelerationRateNormal")))
        CYScrollViewDecelerationRateNormal = *_UIScrollViewDecelerationRateNormal;
    else // XXX: this actually might be fast on some older systems: we should look into this
        CYScrollViewDecelerationRateNormal = 0.998;

    iOS4 = kCFCoreFoundationVersionNumber >= 550.32;

    if ($UIWebBrowserView == nil) {
        Wildcat_ = false;
        $UIWebBrowserView = objc_getClass("UIWebDocumentView");
    } else {
        Wildcat_ = true;
    }

    int maxproc;
    size_t size(sizeof(maxproc));
    if (sysctlbyname("kern.maxproc", &maxproc, &size, NULL, 0) == -1)
        NSLog(@"sysctlbyname(\"kern.maxproc\", ?)");
    else if (maxproc < 72) {
        maxproc = 72;
        if (sysctlbyname("kern.maxproc", NULL, NULL, &maxproc, sizeof(maxproc)) == -1)
            NSLog(@"sysctlbyname(\"kern.maxproc\", #)");
    }

    apr_initialize();

    [NSURLProtocol registerClass:[CydgetURLProtocol class]];
    [NSURLProtocol registerClass:[CydgetCGIURLProtocol class]];

    if (!iOS4) {
        void (*_ZN3JSC6Parser5parseEPNS_12JSGlobalDataEPiPNS_7UStringE)(JSC::SourceCode **, JSC::JSGlobalData *, int *, JSC::UString *);
        dlset(_ZN3JSC6Parser5parseEPNS_12JSGlobalDataEPiPNS_7UStringE, "_ZN3JSC6Parser5parseEPNS_12JSGlobalDataEPiPNS_7UStringE");
        if (_ZN3JSC6Parser5parseEPNS_12JSGlobalDataEPiPNS_7UStringE != NULL)
            MSHookFunction(_ZN3JSC6Parser5parseEPNS_12JSGlobalDataEPiPNS_7UStringE, MSHake(_ZN3JSC6Parser5parseEPNS_12JSGlobalDataEPiPNS_7UStringE));
    }

    struct nlist nl[9];
    memset(nl, 0, sizeof(nl));

    nl[0].n_un.n_name = (char *) "__ZN7WebCore16MIMETypeRegistry29isSupportedJavaScriptMIMETypeERKNS_6StringE";

    nl[1].n_un.n_name = (char *) "__ZN7WebCore16ScriptSourceCodeC2ERKNS_6StringERKNS_4KURLEi";

    nl[2].n_un.n_name = (char *) "__ZN7WebCore12CachedScript6scriptEv";
    nl[3].n_un.n_name = (char *) "__ZNK7WebCore20StringSourceProvider6sourceEv";

    nl[4].n_un.n_name = (char *) "__ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_6StringENS0_5StateES3_i";
    nl[5].n_un.n_name = (char *) "__ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_16ScriptSourceCodeENS0_5StateE";

    nl[6].n_un.n_name = (char *) "__ZN7WebCore6String6appendEPKtj";
    nl[7].n_un.n_name = (char *) "__ZN7WebCore6String8truncateEj";

    nlist("/System/Library/PrivateFrameworks/WebCore.framework/WebCore", nl);

    bool (*_ZN7WebCore16MIMETypeRegistry29isSupportedJavaScriptMIMETypeERKNS_6StringE)(const WebCore::String &);
    nlset(_ZN7WebCore16MIMETypeRegistry29isSupportedJavaScriptMIMETypeERKNS_6StringE, nl, 0);
    if (_ZN7WebCore16MIMETypeRegistry29isSupportedJavaScriptMIMETypeERKNS_6StringE != NULL)
        MSHookFunction(_ZN7WebCore16MIMETypeRegistry29isSupportedJavaScriptMIMETypeERKNS_6StringE, MSHake(_ZN7WebCore16MIMETypeRegistry29isSupportedJavaScriptMIMETypeERKNS_6StringE));

    void (*_ZN7WebCore16ScriptSourceCodeC2ERKNS_6StringERKNS_4KURLEi)(void *, const WebCore::String &, const WebCore::KURL &, int);
    nlset(_ZN7WebCore16ScriptSourceCodeC2ERKNS_6StringERKNS_4KURLEi, nl, 1);
    if (_ZN7WebCore16ScriptSourceCodeC2ERKNS_6StringERKNS_4KURLEi != NULL)
        MSHookFunction(_ZN7WebCore16ScriptSourceCodeC2ERKNS_6StringERKNS_4KURLEi, MSHake(_ZN7WebCore16ScriptSourceCodeC2ERKNS_6StringERKNS_4KURLEi));

    if (iOS4) {
        const WebCore::String &(*_ZN7WebCore12CachedScript6scriptEv)(void *);
        nlset(_ZN7WebCore12CachedScript6scriptEv, nl, 2);
        if (_ZN7WebCore12CachedScript6scriptEv != NULL)
            MSHookFunction(_ZN7WebCore12CachedScript6scriptEv, MSHake(_ZN7WebCore12CachedScript6scriptEv));
    }

    State (*_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_6StringENS0_5StateES3_i)(void *, const WebCore::String &, State, const WebCore::String &, int);
    nlset(_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_6StringENS0_5StateES3_i, nl, 4);
    if (_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_6StringENS0_5StateES3_i != NULL)
        MSHookFunction(_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_6StringENS0_5StateES3_i, MSHake(_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_6StringENS0_5StateES3_i));

    if (iOS4) {
        State (*_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_16ScriptSourceCodeENS0_5StateE)(void *, void *, State);
        nlset(_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_16ScriptSourceCodeENS0_5StateE, nl, 5);
        if (_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_16ScriptSourceCodeENS0_5StateE != NULL)
            MSHookFunction(_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_16ScriptSourceCodeENS0_5StateE, MSHake(_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_16ScriptSourceCodeENS0_5StateE));
    }

    nlset(_ZN7WebCore6String6appendEPKtj, nl, 6);
    nlset(_ZN7WebCore6String8truncateEj, nl, 7);

    MSImageRef JavaScriptCore(MSGetImageByName("/System/Library/PrivateFrameworks/JavaScriptCore.framework/JavaScriptCore"));
    MSImageRef WebCore(MSGetImageByName("/System/Library/PrivateFrameworks/WebCore.framework/WebCore"));

    if (_ZN7WebCore6String6appendEPKtj == NULL)
        msset(_ZN7WebCore6String6appendEPKtj, JavaScriptCore);

    if (_ZN7WebCore6String8truncateEj == NULL)
        msset(_ZN7WebCore6String8truncateEj, JavaScriptCore);

    msset(_ZNK7WebCore6String10charactersEv, WebCore);
    msset(_ZN7WebCore6String29charactersWithNullTerminationEv, JavaScriptCore);
    msset(_ZNK7WebCore6String6lengthEv, WebCore);
}

+ (id) rootViewController {
    return [[[self alloc] init] autorelease];
}

- (void) loadView {
    [self setView:[[[WebCydgetLockScreenView alloc] init] autorelease]];
}

@end