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