LockScreen.mm

   1 /* Cydget - open-source AwayView plugin multiplexer
   2  * Copyright (C) 2009-2011  Jay Freeman (saurik)
   3 */
   4
   5 /*
   6  *        Redistribution and use in source and binary
   7  * forms, with or without modification, are permitted
   8  * provided that the following conditions are met:
   9  *
  10  * 1. Redistributions of source code must retain the
  11  *    above copyright notice, this list of conditions
  12  *    and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the
  14  *    above copyright notice, this list of conditions
  15  *    and the following disclaimer in the documentation
  16  *    and/or other materials provided with the
  17  *    distribution.
  18  * 3. The name of the author may not be used to endorse
  19  *    or promote products derived from this software
  20  *    without specific prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS''
  23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
  24  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  25  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
  27  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  28  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  29  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  30  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  31  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  32  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  33  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  34  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  35  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36 */
  37
  38 #include <substrate.h>
  39 #include <sys/sysctl.h>
  40
  41 #import <GraphicsServices/GraphicsServices.h>
  42 #import <UIKit/UIKit.h>
  43 #import <AddressBook/AddressBook.h>
  44
  45 #import <SpringBoard/SBStatusBarController.h>
  46 #import <SpringBoardUI/SBAwayViewPluginController.h>
  47 #import <TelephonyUI/TPBottomLockBar.h>
  48
  49 #import <QuartzCore/CALayer.h>
  50 // XXX: fix the minimum requirement
  51 extern NSString * const kCAFilterNearest;
  52
  53 #include <WebKit/DOMCSSPrimitiveValue.h>
  54 #include <WebKit/DOMCSSStyleDeclaration.h>
  55 #include <WebKit/DOMDocument.h>
  56 #include <WebKit/DOMHTMLBodyElement.h>
  57 #include <WebKit/DOMNodeList.h>
  58 #include <WebKit/DOMRGBColor.h>
  59
  60 #include <WebKit/WebFrame.h>
  61 #include <WebKit/WebPolicyDelegate.h>
  62 #include <WebKit/WebPreferences.h>
  63 #include <WebKit/WebScriptObject.h>
  64
  65 #import <WebKit/WebView.h>
  66 #import <WebKit/WebView-WebPrivate.h>
  67
  68 #include <WebCore/Page.h>
  69 #include <WebCore/Settings.h>
  70
  71 #include <WebCore/WebCoreThread.h>
  72 #include <WebKit/WebPreferences-WebPrivate.h>
  73
  74 #include "JSGlobalData.h"
  75
  76 #include "SourceCode.h"
  77
  78 #include <apr-1/apr_pools.h>
  79 #include <pcre.h>
  80
  81 #define _transient
  82 #define _forever for (;;)
  83
  84 _disused static unsigned trace_;
  85
  86 #define _trace() do { \
  87     NSLog(@"_trace(%u)@%s:%u[%s](%p)\n", \
  88         trace_++, __FILE__, __LINE__, __FUNCTION__, pthread_self() \
  89     ); \
  90 } while (false)
  91
  92 #define _assert(test) do \
  93     if (!(test)) { \
  94         fprintf(stderr, "_assert(%d:%s)@%s:%u[%s]\n", errno, #test, __FILE__, __LINE__, __FUNCTION__); \
  95         exit(-1); \
  96     } \
  97 while (false)
  98
  99 #define _syscall(expr) \
 100     do if ((long) (expr) != -1) \
 101         break; \
 102     else switch (errno) { \
 103         case EINTR: \
 104             continue; \
 105         default: \
 106             _assert(false); \
 107     } while (true)
 108
 109 @protocol CydgetController
 110 - (NSDictionary *) currentConfiguration;
 111 @end
 112
 113 static Class $CydgetController(objc_getClass("CydgetController"));
 114
 115 static bool iOS32, iOS4;
 116
 117 @interface NSString (UIKit)
 118 - (NSString *) stringByAddingPercentEscapes;
 119 @end
 120
 121 @implementation UIWebDocumentView (WebCycript)
 122
 123 - (void) _setScrollerOffset:(CGPoint)offset {
 124     UIScroller *scroller([self _scroller]);
 125
 126     CGSize size([scroller contentSize]);
 127     CGSize bounds([scroller bounds].size);
 128
 129     CGPoint max;
 130     max.x = size.width - bounds.width;
 131     max.y = size.height - bounds.height;
 132
 133     // wtf Apple?!
 134     if (max.x < 0)
 135         max.x = 0;
 136     if (max.y < 0)
 137         max.y = 0;
 138
 139     offset.x = offset.x < 0 ? 0 : offset.x > max.x ? max.x : offset.x;
 140     offset.y = offset.y < 0 ? 0 : offset.y > max.y ? max.y : offset.y;
 141
 142     [scroller setOffset:offset];
 143 }
 144
 145 @end
 146
 147 /* Perl-Compatible RegEx {{{ */
 148 class Pcre {
 149   private:
 150     pcre *code_;
 151     pcre_extra *study_;
 152     int capture_;
 153     int *matches_;
 154     const char *data_;
 155
 156   public:
 157     Pcre(const char *regex, int options = 0) :
 158         study_(NULL)
 159     {
 160         const char *error;
 161         int offset;
 162         code_ = pcre_compile(regex, options, &error, &offset, NULL);
 163
 164         if (code_ == NULL)
 165             @throw [NSException exceptionWithName:NSInvalidArgumentException reason:[NSString stringWithFormat:@"*** Pcre(,): [%u] %s", offset, error] userInfo:nil];
 166
 167         pcre_fullinfo(code_, study_, PCRE_INFO_CAPTURECOUNT, &capture_);
 168         matches_ = new int[(capture_ + 1) * 3];
 169     }
 170
 171     ~Pcre() {
 172         pcre_free(code_);
 173         delete matches_;
 174     }
 175
 176     NSString *operator [](size_t match) {
 177         return [[[NSString alloc] initWithBytes:(data_ + matches_[match * 2]) length:(matches_[match * 2 + 1] - matches_[match * 2]) encoding:NSUTF8StringEncoding] autorelease];
 178     }
 179
 180     bool operator ()(NSString *data) {
 181         // XXX: length is for characters, not for bytes
 182         return operator ()([data UTF8String], [data length]);
 183     }
 184
 185     bool operator ()(const char *data, size_t size) {
 186         data_ = data;
 187         return pcre_exec(code_, study_, data, size, 0, 0, matches_, (capture_ + 1) * 3) >= 0;
 188     }
 189 };
 190 /* }}} */
 191
 192 static float CYScrollViewDecelerationRateNormal;
 193
 194 @interface UIScrollView (Apple)
 195 - (void) setDecelerationRate:(float)value;
 196 - (void) setScrollingEnabled:(BOOL)enabled;
 197 @end
 198
 199 @interface UIWebView (Apple)
 200 - (void) setDataDetectorTypes:(int)types;
 201 - (UIScrollView *) _scrollView;
 202 - (UIScroller *) _scroller;
 203 - (void) webView:(WebView *)view didClearWindowObject:(WebScriptObject *)window forFrame:(WebFrame *)frame;
 204 @end
 205
 206 @interface WebView (Apple)
 207 - (void) _setLayoutInterval:(float)interval;
 208 - (void) _setAllowsMessaging:(BOOL)allows;
 209 - (void) setShouldUpdateWhileOffscreen:(BOOL)update;
 210 @end
 211
 212 @protocol CydgetWebViewDelegate //<UIWebViewDelegate>
 213 - (void) webView:(WebView *)view didClearWindowObject:(WebScriptObject *)window forFrame:(WebFrame *)frame;
 214 @end
 215
 216 @class UIWebViewWebViewDelegate;
 217
 218 @interface CydgetWebView : UIWebView {
 219 }
 220
 221 @end
 222
 223 @implementation CydgetWebView
 224
 225 - (void) webView:(WebView *)view decidePolicyForNavigationAction:(NSDictionary *)action request:(NSURLRequest *)request frame:(WebFrame *)frame decisionListener:(id<WebPolicyDecisionListener>)listener {
 226     [listener use];
 227 }
 228
 229 - (void) webView:(WebView *)view didClearWindowObject:(WebScriptObject *)window forFrame:(WebFrame *)frame {
 230     NSObject<CydgetWebViewDelegate> *delegate([self delegate]);
 231     if ([delegate respondsToSelector:@selector(webView:didClearWindowObject:forFrame:)])
 232         [delegate webView:view didClearWindowObject:window forFrame:frame];
 233     if ([UIWebView instancesRespondToSelector:@selector(webView:didClearWindowObject:forFrame:)])
 234         [super webView:view didClearWindowObject:window forFrame:frame];
 235 }
 236
 237 @end
 238
 239 @interface WebCydgetLockScreenView : UIView {
 240     CydgetWebView *webview_;
 241     UIScrollView *scroller_;
 242     NSString *cycript_;
 243 }
 244
 245 @end
 246
 247 @implementation WebCydgetLockScreenView
 248
 249 //#include "UICaboodle/UCInternal.h"
 250
 251 - (void) dealloc {
 252     [webview_ setDelegate:nil];
 253     [webview_ release];
 254     [super dealloc];
 255 }
 256
 257 - (void) loadRequest:(NSURLRequest *)request {
 258     [webview_ loadRequest:request];
 259 }
 260
 261 - (void) loadURL:(NSURL *)url cachePolicy:(NSURLRequestCachePolicy)policy {
 262     [self loadRequest:[NSURLRequest
 263         requestWithURL:url
 264         cachePolicy:policy
 265         timeoutInterval:30.0
 266     ]];
 267 }
 268
 269 - (void) loadURL:(NSURL *)url {
 270     [self loadURL:url cachePolicy:NSURLRequestUseProtocolCachePolicy];
 271 }
 272
 273 - (id) init {
 274     CGRect frame = {{0, 0}, {320, 480}};
 275     frame.size.height -= 20; //[[[$SBStatusBarController sharedStatusBarController] statusBarView] frame].size.height;
 276
 277     if ((self = [super initWithFrame:frame]) != nil) {
 278         CGRect bounds([self bounds]);
 279         bounds.size.height -= [TPBottomLockBar defaultHeight];
 280
 281         webview_ = [[CydgetWebView alloc] initWithFrame:bounds];
 282         [webview_ setDelegate:self];
 283         [self addSubview:webview_];
 284
 285         if ([webview_ respondsToSelector:@selector(setDataDetectorTypes:)])
 286             [webview_ setDataDetectorTypes:0x80000000];
 287         else
 288             [webview_ setDetectsPhoneNumbers:NO];
 289
 290         [webview_ setScalesPageToFit:YES];
 291
 292         UIWebDocumentView *document([webview_ _documentView]);
 293         WebView *webview([document webView]);
 294         WebPreferences *preferences([webview preferences]);
 295
 296         [document setTileSize:CGSizeMake(bounds.size.width, 500)];
 297
 298         [document setBackgroundColor:[UIColor blackColor]];
 299         [document setDrawsBackground:NO];
 300
 301         [webview setPreferencesIdentifier:@"WebCycript"];
 302
 303         if ([webview respondsToSelector:@selector(_setLayoutInterval:)])
 304             [webview _setLayoutInterval:0];
 305         else
 306             [preferences _setLayoutInterval:0];
 307
 308         [preferences setCacheModel:WebCacheModelDocumentViewer];
 309         [preferences setJavaScriptCanOpenWindowsAutomatically:YES];
 310         [preferences setOfflineWebApplicationCacheEnabled:YES];
 311
 312         if ([webview respondsToSelector:@selector(setShouldUpdateWhileOffscreen:)])
 313             [webview setShouldUpdateWhileOffscreen:NO];
 314
 315         if ([document respondsToSelector:@selector(setAllowsMessaging:)])
 316             [document setAllowsMessaging:YES];
 317         if ([webview respondsToSelector:@selector(_setAllowsMessaging:)])
 318             [webview _setAllowsMessaging:YES];
 319
 320         if ([webview_ respondsToSelector:@selector(_scrollView)]) {
 321             scroller_ = [webview_ _scrollView];
 322
 323             [scroller_ setDirectionalLockEnabled:YES];
 324             [scroller_ setDecelerationRate:CYScrollViewDecelerationRateNormal];
 325             [scroller_ setDelaysContentTouches:NO];
 326
 327             [scroller_ setCanCancelContentTouches:YES];
 328
 329             [scroller_ setAlwaysBounceVertical:NO];
 330         } else if ([webview_ respondsToSelector:@selector(_scroller)]) {
 331             UIScroller *scroller([webview_ _scroller]);
 332             scroller_ = (UIScrollView *) scroller;
 333
 334             [scroller setDirectionalScrolling:YES];
 335             [scroller setScrollDecelerationFactor:CYScrollViewDecelerationRateNormal]; /* 0.989324 */
 336             [scroller setScrollHysteresis:0]; /* 8 */
 337
 338             [scroller setThumbDetectionEnabled:NO];
 339         }
 340
 341         [scroller_ setFixedBackgroundPattern:YES];
 342         [scroller_ setBackgroundColor:[UIColor blackColor]];
 343         [scroller_ setClipsSubviews:NO];
 344
 345         [scroller_ setBounces:YES];
 346         [scroller_ setShowBackgroundShadow:NO]; /* YES */
 347
 348         [self setAutoresizingMask:(UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight)];
 349         [webview_ setAutoresizingMask:(UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight)];
 350
 351         NSDictionary *configuration([$CydgetController currentConfiguration]);
 352
 353         cycript_ = [configuration objectForKey:@"CycriptURLs"];
 354
 355         [scroller_ setScrollingEnabled:[[configuration objectForKey:@"Scrollable"] boolValue]];
 356
 357         NSString *homepage([configuration objectForKey:@"Homepage"]);
 358         [self loadURL:[NSURL URLWithString:homepage]];
 359     } return self;
 360 }
 361
 362 - (void) webView:(WebView *)webview didClearWindowObject:(WebScriptObject *)window forFrame:(WebFrame *)frame {
 363     if (cycript_ != nil)
 364         if (NSString *href = [[[[frame dataSource] request] URL] absoluteString])
 365             if (Pcre([cycript_ UTF8String], 0 /*XXX:PCRE_UTF8*/)(href))
 366                 if (void *handle = dlopen("/usr/lib/libcycript.dylib", RTLD_LAZY | RTLD_GLOBAL))
 367                     if (void (*CYSetupContext)(JSGlobalContextRef) = reinterpret_cast<void (*)(JSGlobalContextRef)>(dlsym(handle, "CydgetSetupContext"))) {
 368                         WebFrame *frame([webview mainFrame]);
 369                         JSGlobalContextRef context([frame globalContext]);
 370                         CYSetupContext(context);
 371                     }
 372 }
 373
 374 @end
 375
 376 @interface WebCycriptLockScreenController : SBAwayViewPluginController {
 377 }
 378
 379 @end
 380
 381 #include <string>
 382
 383 struct State {
 384     unsigned state;
 385 };
 386
 387 // String Helpers {{{
 388 static const UChar *(*_ZNK7WebCore6String10charactersEv)(const WebCore::String *);
 389 static const UChar *(*_ZN7WebCore6String29charactersWithNullTerminationEv)(const WebCore::String *);
 390 static unsigned (*_ZNK7WebCore6String6lengthEv)(const WebCore::String *);
 391
 392 static bool StringGet(const WebCore::String &string, const UChar *&data, size_t &length) {
 393     bool terminated;
 394
 395     if (_ZNK7WebCore6String10charactersEv != NULL) {
 396         data = (*_ZNK7WebCore6String10charactersEv)(&string);
 397         terminated = false;
 398     } else if (_ZN7WebCore6String29charactersWithNullTerminationEv != NULL) {
 399         data = (*_ZN7WebCore6String29charactersWithNullTerminationEv)(&string);
 400         terminated = true;
 401     } else return false;
 402
 403     if (_ZNK7WebCore6String6lengthEv != NULL)
 404         length = (*_ZNK7WebCore6String6lengthEv)(&string);
 405     else if (terminated)
 406         for (length = 0; data[length] != 0; ++length);
 407     else return false;
 408
 409     return true;
 410 }
 411
 412 static bool StringEquals(const WebCore::String &string, const char *value) {
 413     const UChar *data;
 414     size_t size;
 415     if (!StringGet(string, data, size))
 416         return false;
 417
 418     size_t length(strlen(value));
 419     if (size != length)
 420         return false;
 421
 422     for (size_t index(0); index != length; ++index)
 423         if (data[index] != value[index])
 424             return false;
 425
 426     return true;
 427 }
 428 // }}}
 429 // State Machine {{{
 430 static bool cycript_;
 431
 432 MSHook(bool, _ZN7WebCore16MIMETypeRegistry29isSupportedJavaScriptMIMETypeERKNS_6StringE, const WebCore::String &mime) {
 433     if (!StringEquals(mime, "text/cycript")) {
 434         cycript_ = false;
 435         return __ZN7WebCore16MIMETypeRegistry29isSupportedJavaScriptMIMETypeERKNS_6StringE(mime);
 436     }
 437
 438     static void *handle(dlopen("/usr/lib/libcycript.dylib", RTLD_LAZY | RTLD_GLOBAL));
 439     if (handle == NULL)
 440         return false;
 441
 442     cycript_ = true;
 443     return true;
 444 }
 445 // }}}
 446 // Script Compiler {{{
 447 static void Log(const WebCore::String &string) {
 448 #if 0
 449     const UChar *data;
 450     size_t length;
 451     if (!StringGet(string, data, length))
 452         return;
 453
 454     UChar terminated[length + 1];
 455     terminated[length] = 0;
 456     memcpy(terminated, data, length * 2);
 457     NSLog(@"wtf %p:%zu:%S:", &string, length, terminated);
 458 #endif
 459 }
 460
 461 static void Cycriptify(apr_pool_t *pool, const uint16_t *&data, size_t &size) {
 462     cycript_ = false;
 463
 464     if (void *handle = dlopen("/usr/lib/libcycript.dylib", RTLD_LAZY | RTLD_GLOBAL))
 465         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")))
 466             CydgetPoolParse(pool, &data, &size);
 467 }
 468
 469 static void (*_ZN7WebCore6String6appendEPKtj)(WebCore::String *, const UChar *, unsigned);
 470 static void (*_ZN7WebCore6String8truncateEj)(WebCore::String *, unsigned);
 471
 472 static void Cycriptify(const WebCore::String &source, int *psize = NULL) {
 473     if (!cycript_)
 474         return;
 475
 476     const UChar *data;
 477     size_t length;
 478
 479     if (!StringGet(source, data, length)) {
 480         return;
 481     }
 482
 483     size_t size(length);
 484
 485     apr_pool_t *pool;
 486     apr_pool_create(&pool, NULL);
 487
 488     Cycriptify(pool, data, size);
 489
 490     WebCore::String &script(const_cast<WebCore::String &>(source));
 491
 492     _ZN7WebCore6String8truncateEj(&script, 0);
 493     _ZN7WebCore6String6appendEPKtj(&script, data, size);
 494
 495     if (psize != NULL)
 496         *psize = size;
 497
 498     apr_pool_destroy(pool);
 499
 500     Log(source);
 501 }
 502 // }}}
 503
 504 extern "C" void *_ZN3JSC7UString3Rep14nullBaseStringE __attribute__((__weak_import__));
 505 extern "C" void *_ZN3JSC7UString3Rep7destroyEv __attribute__((__weak_import__));
 506 extern "C" void *_ZN3JSC7UStringC1EPKti __attribute__((__weak_import__));
 507 extern "C" void *_ZN3JSC7UStringC1EPKc __attribute__((__weak_import__));
 508 extern "C" void *_ZNK3JSC7UString6substrEii __attribute__((__weak_import__));
 509 extern "C" void *_ZN3WTF10fastMallocEm __attribute__((__weak_import__));
 510 extern "C" void WTFReportAssertionFailure(const char *, int, const char *, const char *) __attribute__((__weak_import__));
 511 extern "C" void *_ZN3WTF8fastFreeEPv __attribute__((__weak_import__));
 512
 513 bool CYWeakHell() {
 514     return
 515         &_ZN3JSC7UString3Rep14nullBaseStringE == NULL ||
 516         &_ZN3JSC7UString3Rep7destroyEv == NULL ||
 517         &_ZN3JSC7UStringC1EPKti == NULL ||
 518         &_ZN3JSC7UStringC1EPKc == NULL ||
 519         &_ZNK3JSC7UString6substrEii == NULL ||
 520         &_ZN3WTF10fastMallocEm == NULL ||
 521         &WTFReportAssertionFailure == NULL ||
 522         &_ZN3WTF8fastFreeEPv == NULL ||
 523     false;
 524 }
 525
 526 static WebCore::String *string;
 527
 528 // iOS 2.x
 529 MSHook(State, _ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_6StringENS0_5StateES3_i, void *_this, const WebCore::String &string, State state, const WebCore::String &url, int line) {
 530     Cycriptify(string);
 531     return __ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_6StringENS0_5StateES3_i(_this, string, state, url, line);
 532 }
 533
 534 // iOS 3.x
 535 MSHook(void, _ZN3JSC6Parser5parseEPNS_12JSGlobalDataEPiPNS_7UStringE, JSC::SourceCode **_this, JSC::JSGlobalData *global, int *line, JSC::UString *message) {
 536     if (cycript_) {
 537         JSC::SourceCode *source(_this[iOS32 ? 6 : 0]);
 538         const uint16_t *data(source->data());
 539         size_t size(source->length());
 540
 541         apr_pool_t *pool;
 542         apr_pool_create(&pool, NULL);
 543
 544         Cycriptify(pool, data, size);
 545         source->~SourceCode();
 546         // XXX: I actually don't have the original URL here: pants
 547         new (source) JSC::SourceCode(JSC::UStringSourceProvider::create(JSC::UString(data, size), "cycript://"), 1);
 548
 549         apr_pool_destroy(pool);
 550
 551     }
 552
 553     return __ZN3JSC6Parser5parseEPNS_12JSGlobalDataEPiPNS_7UStringE(_this, global, line, message);
 554 }
 555
 556 // iOS 4.x cdata
 557 MSHook(void, _ZN7WebCore16ScriptSourceCodeC2ERKNS_6StringERKNS_4KURLEi, void *_this, const WebCore::String &source, const WebCore::KURL &url, int line) {
 558     Cycriptify(source);
 559     return __ZN7WebCore16ScriptSourceCodeC2ERKNS_6StringERKNS_4KURLEi(_this, source, url, line);
 560 }
 561
 562 // iOS 4.x @src=
 563 MSHook(const WebCore::String &, _ZN7WebCore12CachedScript6scriptEv, void *_this) {
 564     const WebCore::String &script(__ZN7WebCore12CachedScript6scriptEv(_this));
 565     string = const_cast<WebCore::String *>(&script);
 566     Log(script);
 567     return script;
 568 }
 569
 570 // iOS 4.x @src=
 571 MSHook(State, _ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_16ScriptSourceCodeENS0_5StateE, void *_this, void *source, State state) {
 572     if (string != NULL) {
 573         if (iOS4)
 574             Cycriptify(*string, reinterpret_cast<int *>(source) + 3);
 575         else
 576             Cycriptify(*string);
 577     }
 578     string = NULL;
 579     return __ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_16ScriptSourceCodeENS0_5StateE(_this, source, state);
 580 }
 581
 582 /* Cydget:// Protocol {{{ */
 583 @interface CydgetURLProtocol : NSURLProtocol {
 584 }
 585
 586 @end
 587
 588 @implementation CydgetURLProtocol
 589
 590 + (BOOL) canInitWithRequest:(NSURLRequest *)request {
 591     NSURL *url([request URL]);
 592     if (url == nil)
 593         return NO;
 594     NSString *scheme([[url scheme] lowercaseString]);
 595     if (scheme == nil || ![scheme isEqualToString:@"cydget"])
 596         return NO;
 597     return YES;
 598 }
 599
 600 + (NSURLRequest *) canonicalRequestForRequest:(NSURLRequest *)request {
 601     return request;
 602 }
 603
 604 - (void) _returnPNGWithImage:(UIImage *)icon forRequest:(NSURLRequest *)request {
 605     id<NSURLProtocolClient> client([self client]);
 606     if (icon == nil)
 607         [client URLProtocol:self didFailWithError:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorFileDoesNotExist userInfo:nil]];
 608     else {
 609         NSData *data(UIImagePNGRepresentation(icon));
 610
 611         NSURLResponse *response([[[NSURLResponse alloc] initWithURL:[request URL] MIMEType:@"image/png" expectedContentLength:-1 textEncodingName:nil] autorelease]);
 612         [client URLProtocol:self didReceiveResponse:response cacheStoragePolicy:NSURLCacheStorageNotAllowed];
 613         [client URLProtocol:self didLoadData:data];
 614         [client URLProtocolDidFinishLoading:self];
 615     }
 616 }
 617
 618 - (void) startLoading {
 619     id<NSURLProtocolClient> client([self client]);
 620     NSURLRequest *request([self request]);
 621
 622     NSURL *url([request URL]);
 623     NSString *href([url absoluteString]);
 624
 625     NSString *path([href substringFromIndex:9]);
 626     NSRange slash([path rangeOfString:@"/"]);
 627
 628     NSString *command;
 629     if (slash.location == NSNotFound) {
 630         command = path;
 631         path = nil;
 632     } else {
 633         command = [path substringToIndex:slash.location];
 634         path = [path substringFromIndex:(slash.location + 1)];
 635     }
 636
 637     if ([command isEqualToString:@"_UIImageWithName"]) {
 638         if (path == nil)
 639             goto fail;
 640         path = [path stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
 641         UIImage *icon(_UIImageWithName(path));
 642         [self _returnPNGWithImage:icon forRequest:request];
 643     } else fail: {
 644         [client URLProtocol:self didFailWithError:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorResourceUnavailable userInfo:nil]];
 645     }
 646 }
 647
 648 - (void) stopLoading {
 649 }
 650
 651 @end
 652 /* }}} */
 653 /* Cydget-CGI:// Protocol {{{ */
 654 @interface CydgetCGIURLProtocol : NSURLProtocol {
 655     pid_t pid_;
 656     CFHTTPMessageRef http_;
 657     NSFileHandle *handle_;
 658 }
 659
 660 @end
 661
 662 @implementation CydgetCGIURLProtocol
 663
 664 + (BOOL) canInitWithRequest:(NSURLRequest *)request {
 665     NSURL *url([request URL]);
 666     if (url == nil)
 667         return NO;
 668     NSString *scheme([[url scheme] lowercaseString]);
 669     if (scheme == nil || ![scheme isEqualToString:@"cydget-cgi"])
 670         return NO;
 671     return YES;
 672 }
 673
 674 + (NSURLRequest *) canonicalRequestForRequest:(NSURLRequest *)request {
 675     return request;
 676 }
 677
 678 - (id) initWithRequest:(NSURLRequest *)request cachedResponse:(NSCachedURLResponse *)response client:(id<NSURLProtocolClient>)client {
 679     if ((self = [super initWithRequest:request cachedResponse:response client:client]) != nil) {
 680         pid_ = -1;
 681     } return self;
 682 }
 683
 684 - (void) startLoading {
 685     id<NSURLProtocolClient> client([self client]);
 686     NSURLRequest *request([self request]);
 687     NSURL *url([request URL]);
 688
 689     NSString *path([url path]);
 690     if (path == nil) {
 691         [client URLProtocol:self didFailWithError:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorResourceUnavailable userInfo:nil]];
 692         return;
 693     }
 694
 695     NSFileManager *manager([NSFileManager defaultManager]);
 696     if (![manager fileExistsAtPath:path]) {
 697         [client URLProtocol:self didFailWithError:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorFileDoesNotExist userInfo:nil]];
 698         return;
 699     }
 700
 701     int fds[2];
 702     _assert(pipe(fds) != -1);
 703
 704     _assert(pid_ == -1);
 705     pid_ = fork();
 706     if (pid_ == -1) {
 707         _assert(close(fds[0]) != -1);
 708         _assert(close(fds[1]) != -1);
 709         [client URLProtocol:self didFailWithError:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorResourceUnavailable userInfo:nil]];
 710         return;
 711     }
 712
 713     if (pid_ == 0) {
 714         const char *script([path UTF8String]);
 715
 716         setenv("GATEWAY_INTERFACE", "CGI/1.1", true);
 717         setenv("SCRIPT_FILENAME", script, true);
 718         NSString *query([url query]);
 719         if (query != nil)
 720             setenv("QUERY_STRING", [query UTF8String], true);
 721
 722         _assert(dup2(fds[1], 1) != -1);
 723         _assert(close(fds[0]) != -1);
 724         _assert(close(fds[1]) != -1);
 725
 726         execl(script, script, NULL);
 727         exit(1);
 728         _assert(false);
 729     }
 730
 731     _assert(close(fds[1]) != -1);
 732
 733     _assert(http_ == NULL);
 734     http_ = CFHTTPMessageCreateEmpty(kCFAllocatorDefault, FALSE);
 735     CFHTTPMessageAppendBytes(http_, (const uint8_t *) "HTTP/1.1 200 OK\r\n", 17);
 736
 737     _assert(handle_ == nil);
 738     handle_ = [[NSFileHandle alloc] initWithFileDescriptor:fds[0] closeOnDealloc:YES];
 739
 740     [[NSNotificationCenter defaultCenter]
 741         addObserver:self
 742         selector:@selector(onRead:)
 743         name:@"NSFileHandleReadCompletionNotification"
 744         object:handle_
 745     ];
 746
 747     [handle_ readInBackgroundAndNotify];
 748 }
 749
 750 - (void) onRead:(NSNotification *)notification {
 751     NSFileHandle *handle([notification object]);
 752
 753     NSData *data([[notification userInfo] objectForKey:NSFileHandleNotificationDataItem]);
 754
 755     if (size_t length = [data length]) {
 756         CFHTTPMessageAppendBytes(http_, reinterpret_cast<const UInt8 *>([data bytes]), length);
 757         [handle readInBackgroundAndNotify];
 758     } else {
 759         id<NSURLProtocolClient> client([self client]);
 760
 761         CFStringRef mime(CFHTTPMessageCopyHeaderFieldValue(http_, CFSTR("Content-type")));
 762         if (mime == NULL)
 763             [client URLProtocol:self didFailWithError:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorBadServerResponse userInfo:nil]];
 764         else {
 765             NSURLRequest *request([self request]);
 766
 767             NSURLResponse *response([[[NSURLResponse alloc] initWithURL:[request URL] MIMEType:(NSString *)mime expectedContentLength:-1 textEncodingName:nil] autorelease]);
 768             CFRelease(mime);
 769
 770             [client URLProtocol:self didReceiveResponse:response cacheStoragePolicy:NSURLCacheStorageNotAllowed];
 771
 772             CFDataRef body(CFHTTPMessageCopyBody(http_));
 773             [client URLProtocol:self didLoadData:(NSData *)body];
 774             CFRelease(body);
 775
 776             [client URLProtocolDidFinishLoading:self];
 777         }
 778
 779         CFRelease(http_);
 780         http_ = NULL;
 781     }
 782 }
 783
 784     //[client URLProtocol:self didFailWithError:[NSError errorWithDomain:NSURLErrorDomain code:NSURLErrorNetworkConnectionLost userInfo:nil]];
 785
 786 - (void) stopLoading_ {
 787     [[NSNotificationCenter defaultCenter] removeObserver:self];
 788
 789     if (handle_ != nil) {
 790         [handle_ release];
 791         handle_ = nil;
 792     }
 793
 794     if (pid_ != -1) {
 795         kill(pid_, SIGTERM);
 796         int status;
 797         _syscall(waitpid(pid_, &status, 0));
 798         pid_ = -1;
 799     }
 800 }
 801
 802 - (void) stopLoading {
 803     [self
 804         performSelectorOnMainThread:@selector(stopLoading_)
 805         withObject:nil
 806         waitUntilDone:NO
 807     ];
 808 }
 809
 810 @end
 811 /* }}} */
 812
 813 template <typename Type_>
 814 static void nlset(Type_ &function, struct nlist *nl, size_t index) {
 815     struct nlist &name(nl[index]);
 816     uintptr_t value(name.n_value);
 817     if ((name.n_desc & N_ARM_THUMB_DEF) != 0)
 818         value |= 0x00000001;
 819     function = reinterpret_cast<Type_>(value);
 820 }
 821
 822 template <typename Type_>
 823 static void dlset(Type_ &function, const char *name) {
 824     function = reinterpret_cast<Type_>(dlsym(RTLD_DEFAULT, name));
 825 }
 826
 827 template <typename Type_>
 828 static void msset_(Type_ &function, const char *name, MSImageRef handle) {
 829     function = reinterpret_cast<Type_>(MSFindSymbol(handle, name));
 830 }
 831
 832 #define msset(function, handle) \
 833     msset_(function, "_" #function, handle)
 834
 835 @implementation WebCycriptLockScreenController
 836
 837 static void $UIWebViewWebViewDelegate$webView$didClearWindowObject$forFrame$(UIWebViewWebViewDelegate *self, SEL sel, WebView *view, WebScriptObject *window, WebFrame *frame) {
 838     UIWebView *uiWebView(MSHookIvar<UIWebView *>(self, "uiWebView"));
 839     if ([uiWebView respondsToSelector:@selector(webView:didClearWindowObject:forFrame:)])
 840         [uiWebView webView:view didClearWindowObject:window forFrame:frame];
 841 }
 842
 843 + (void) initialize {
 844     if (Class $UIWebViewWebViewDelegate = objc_getClass("UIWebViewWebViewDelegate"))
 845         class_addMethod($UIWebViewWebViewDelegate, @selector(webView:didClearWindowObject:forFrame:), (IMP) &$UIWebViewWebViewDelegate$webView$didClearWindowObject$forFrame$, "v20@0:4@8@12@16");
 846
 847     if (float *_UIScrollViewDecelerationRateNormal = reinterpret_cast<float *>(dlsym(RTLD_DEFAULT, "UIScrollViewDecelerationRateNormal")))
 848         CYScrollViewDecelerationRateNormal = *_UIScrollViewDecelerationRateNormal;
 849     else // XXX: this actually might be fast on some older systems: we should look into this
 850         CYScrollViewDecelerationRateNormal = 0.998;
 851
 852     iOS4 = kCFCoreFoundationVersionNumber >= 550.32;
 853     iOS32 = !iOS4 && kCFCoreFoundationVersionNumber >= 478.61;
 854
 855     int maxproc;
 856     size_t size(sizeof(maxproc));
 857     if (sysctlbyname("kern.maxproc", &maxproc, &size, NULL, 0) == -1)
 858         NSLog(@"sysctlbyname(\"kern.maxproc\", ?)");
 859     else if (maxproc < 72) {
 860         maxproc = 72;
 861         if (sysctlbyname("kern.maxproc", NULL, NULL, &maxproc, sizeof(maxproc)) == -1)
 862             NSLog(@"sysctlbyname(\"kern.maxproc\", #)");
 863     }
 864
 865     apr_initialize();
 866
 867     [NSURLProtocol registerClass:[CydgetURLProtocol class]];
 868     [NSURLProtocol registerClass:[CydgetCGIURLProtocol class]];
 869
 870     if (!iOS4) {
 871         void (*_ZN3JSC6Parser5parseEPNS_12JSGlobalDataEPiPNS_7UStringE)(JSC::SourceCode **, JSC::JSGlobalData *, int *, JSC::UString *);
 872         dlset(_ZN3JSC6Parser5parseEPNS_12JSGlobalDataEPiPNS_7UStringE, "_ZN3JSC6Parser5parseEPNS_12JSGlobalDataEPiPNS_7UStringE");
 873         if (_ZN3JSC6Parser5parseEPNS_12JSGlobalDataEPiPNS_7UStringE != NULL)
 874             MSHookFunction(_ZN3JSC6Parser5parseEPNS_12JSGlobalDataEPiPNS_7UStringE, MSHake(_ZN3JSC6Parser5parseEPNS_12JSGlobalDataEPiPNS_7UStringE));
 875     }
 876
 877     struct nlist nl[9];
 878     memset(nl, 0, sizeof(nl));
 879
 880     nl[0].n_un.n_name = (char *) "__ZN7WebCore16MIMETypeRegistry29isSupportedJavaScriptMIMETypeERKNS_6StringE";
 881
 882     nl[1].n_un.n_name = (char *) "__ZN7WebCore16ScriptSourceCodeC2ERKNS_6StringERKNS_4KURLEi";
 883
 884     nl[2].n_un.n_name = (char *) "__ZN7WebCore12CachedScript6scriptEv";
 885     nl[3].n_un.n_name = (char *) "__ZNK7WebCore20StringSourceProvider6sourceEv";
 886
 887     nl[4].n_un.n_name = (char *) "__ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_6StringENS0_5StateES3_i";
 888     nl[5].n_un.n_name = (char *) "__ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_16ScriptSourceCodeENS0_5StateE";
 889
 890     nl[6].n_un.n_name = (char *) "__ZN7WebCore6String6appendEPKtj";
 891     nl[7].n_un.n_name = (char *) "__ZN7WebCore6String8truncateEj";
 892
 893     nlist("/System/Library/PrivateFrameworks/WebCore.framework/WebCore", nl);
 894
 895     bool (*_ZN7WebCore16MIMETypeRegistry29isSupportedJavaScriptMIMETypeERKNS_6StringE)(const WebCore::String &);
 896     nlset(_ZN7WebCore16MIMETypeRegistry29isSupportedJavaScriptMIMETypeERKNS_6StringE, nl, 0);
 897     if (_ZN7WebCore16MIMETypeRegistry29isSupportedJavaScriptMIMETypeERKNS_6StringE != NULL)
 898         MSHookFunction(_ZN7WebCore16MIMETypeRegistry29isSupportedJavaScriptMIMETypeERKNS_6StringE, MSHake(_ZN7WebCore16MIMETypeRegistry29isSupportedJavaScriptMIMETypeERKNS_6StringE));
 899
 900     void (*_ZN7WebCore16ScriptSourceCodeC2ERKNS_6StringERKNS_4KURLEi)(void *, const WebCore::String &, const WebCore::KURL &, int);
 901     nlset(_ZN7WebCore16ScriptSourceCodeC2ERKNS_6StringERKNS_4KURLEi, nl, 1);
 902     if (_ZN7WebCore16ScriptSourceCodeC2ERKNS_6StringERKNS_4KURLEi != NULL)
 903         MSHookFunction(_ZN7WebCore16ScriptSourceCodeC2ERKNS_6StringERKNS_4KURLEi, MSHake(_ZN7WebCore16ScriptSourceCodeC2ERKNS_6StringERKNS_4KURLEi));
 904
 905     if (iOS4) {
 906         const WebCore::String &(*_ZN7WebCore12CachedScript6scriptEv)(void *);
 907         nlset(_ZN7WebCore12CachedScript6scriptEv, nl, 2);
 908         if (_ZN7WebCore12CachedScript6scriptEv != NULL)
 909             MSHookFunction(_ZN7WebCore12CachedScript6scriptEv, MSHake(_ZN7WebCore12CachedScript6scriptEv));
 910     }
 911
 912     State (*_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_6StringENS0_5StateES3_i)(void *, const WebCore::String &, State, const WebCore::String &, int);
 913     nlset(_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_6StringENS0_5StateES3_i, nl, 4);
 914     if (_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_6StringENS0_5StateES3_i != NULL)
 915         MSHookFunction(_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_6StringENS0_5StateES3_i, MSHake(_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_6StringENS0_5StateES3_i));
 916
 917     if (iOS4) {
 918         State (*_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_16ScriptSourceCodeENS0_5StateE)(void *, void *, State);
 919         nlset(_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_16ScriptSourceCodeENS0_5StateE, nl, 5);
 920         if (_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_16ScriptSourceCodeENS0_5StateE != NULL)
 921             MSHookFunction(_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_16ScriptSourceCodeENS0_5StateE, MSHake(_ZN7WebCore13HTMLTokenizer15scriptExecutionERKNS_16ScriptSourceCodeENS0_5StateE));
 922     }
 923
 924     nlset(_ZN7WebCore6String6appendEPKtj, nl, 6);
 925     nlset(_ZN7WebCore6String8truncateEj, nl, 7);
 926
 927     MSImageRef JavaScriptCore(MSGetImageByName("/System/Library/PrivateFrameworks/JavaScriptCore.framework/JavaScriptCore"));
 928     MSImageRef WebCore(MSGetImageByName("/System/Library/PrivateFrameworks/WebCore.framework/WebCore"));
 929
 930     if (_ZN7WebCore6String6appendEPKtj == NULL)
 931         msset(_ZN7WebCore6String6appendEPKtj, JavaScriptCore);
 932
 933     if (_ZN7WebCore6String8truncateEj == NULL)
 934         msset(_ZN7WebCore6String8truncateEj, JavaScriptCore);
 935
 936     msset(_ZNK7WebCore6String10charactersEv, WebCore);
 937     msset(_ZN7WebCore6String29charactersWithNullTerminationEv, JavaScriptCore);
 938     msset(_ZNK7WebCore6String6lengthEv, WebCore);
 939 }
 940
 941 + (id) rootViewController {
 942     return [[[self alloc] init] autorelease];
 943 }
 944
 945 - (void) loadView {
 946     [self setView:[[[WebCydgetLockScreenView alloc] init] autorelease]];
 947 }
 948
 949 @end