Tweak.mm

   1 /* Cyrker - Remove Execution Server and Disassembler
   2  * Copyright (C) 2009  Jay Freeman (saurik)
   3 */
   4
   5 /* Modified BSD License {{{ */
   6 /*
   7  *        Redistribution and use in source and binary
   8  * forms, with or without modification, are permitted
   9  * provided that the following conditions are met:
  10  *
  11  * 1. Redistributions of source code must retain the
  12  *    above copyright notice, this list of conditions
  13  *    and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the
  15  *    above copyright notice, this list of conditions
  16  *    and the following disclaimer in the documentation
  17  *    and/or other materials provided with the
  18  *    distribution.
  19  * 3. The name of the author may not be used to endorse
  20  *    or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS''
  24  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
  25  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  26  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE
  28  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  29  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  30  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  31  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  32  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  33  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  34  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  35  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  36  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  37 */
  38 /* }}} */
  39
  40 #include <substrate.h>
  41
  42 #include "sig/parse.hpp"
  43 #include "sig/ffi_type.hpp"
  44
  45 #include <apr-1/apr_pools.h>
  46 #include <apr-1/apr_strings.h>
  47
  48 #include <unistd.h>
  49
  50 #include <CoreFoundation/CoreFoundation.h>
  51 #include <CoreFoundation/CFLogUtilities.h>
  52
  53 #include <CFNetwork/CFNetwork.h>
  54 #include <Foundation/Foundation.h>
  55
  56 #include <JavaScriptCore/JSBase.h>
  57 #include <JavaScriptCore/JSValueRef.h>
  58 #include <JavaScriptCore/JSObjectRef.h>
  59 #include <JavaScriptCore/JSContextRef.h>
  60 #include <JavaScriptCore/JSStringRef.h>
  61 #include <JavaScriptCore/JSStringRefCF.h>
  62
  63 #include <WebKit/WebScriptObject.h>
  64
  65 #include <sys/types.h>
  66 #include <sys/socket.h>
  67 #include <netinet/in.h>
  68
  69 #undef _assert
  70 #undef _trace
  71
  72 /* XXX: bad _assert */
  73 #define _assert(test) do { \
  74     if ((test)) break; \
  75     CFLog(kCFLogLevelNotice, CFSTR("_assert(%s):%u"), #test, __LINE__); \
  76     throw; \
  77 } while (false)
  78
  79 #define _trace() do { \
  80     CFLog(kCFLogLevelNotice, CFSTR("_trace():%u"), __LINE__); \
  81 } while (false)
  82
  83 /* Objective-C Handle<> {{{ */
  84 template <typename Type_>
  85 class _H {
  86     typedef _H<Type_> This_;
  87
  88   private:
  89     Type_ *value_;
  90
  91     _finline void Retain_() {
  92         if (value_ != nil)
  93             [value_ retain];
  94     }
  95
  96     _finline void Clear_() {
  97         if (value_ != nil)
  98             [value_ release];
  99     }
 100
 101   public:
 102     _finline _H(const This_ &rhs) :
 103         value_(rhs.value_ == nil ? nil : [rhs.value_ retain])
 104     {
 105     }
 106
 107     _finline _H(Type_ *value = NULL, bool mended = false) :
 108         value_(value)
 109     {
 110         if (!mended)
 111             Retain_();
 112     }
 113
 114     _finline ~_H() {
 115         Clear_();
 116     }
 117
 118     _finline operator Type_ *() const {
 119         return value_;
 120     }
 121
 122     _finline This_ &operator =(Type_ *value) {
 123         if (value_ != value) {
 124             Type_ *old(value_);
 125             value_ = value;
 126             Retain_();
 127             if (old != nil)
 128                 [old release];
 129         } return *this;
 130     }
 131 };
 132 /* }}} */
 133
 134 #define _pooled _H<NSAutoreleasePool> _pool([[NSAutoreleasePool alloc] init], true);
 135
 136 static JSContextRef Context_;
 137
 138 static JSClassRef ffi_;
 139 static JSClassRef joc_;
 140 static JSClassRef ptr_;
 141 static JSClassRef sel_;
 142
 143 static JSObjectRef Array_;
 144
 145 static JSStringRef name_;
 146 static JSStringRef message_;
 147 static JSStringRef length_;
 148
 149 static Class NSCFBoolean_;
 150
 151 struct Client {
 152     CFHTTPMessageRef message_;
 153     CFSocketRef socket_;
 154 };
 155
 156 @interface NSMethodSignature (Cyrver)
 157 - (NSString *) _typeString;
 158 @end
 159
 160 @interface NSObject (Cyrver)
 161 - (NSString *) cy$toJSON;
 162 - (JSValueRef) cy$JSValueInContext:(JSContextRef)context;
 163 @end
 164
 165 @implementation NSObject (Cyrver)
 166
 167 - (NSString *) cy$toJSON {
 168     return [self description];
 169 }
 170
 171 - (JSValueRef) cy$JSValueInContext:(JSContextRef)context {
 172     return JSObjectMake(context, joc_, [self retain]);
 173 }
 174
 175 @end
 176
 177 @implementation WebUndefined (Cyrver)
 178
 179 - (NSString *) cy$toJSON {
 180     return @"undefined";
 181 }
 182
 183 - (JSValueRef) cy$JSValueInContext:(JSContextRef)context {
 184     return JSValueMakeUndefined(context);
 185 }
 186
 187 @end
 188
 189 @implementation NSArray (Cyrver)
 190
 191 - (NSString *) cy$toJSON {
 192     NSMutableString *json([[[NSMutableString alloc] init] autorelease]);
 193     [json appendString:@"["];
 194
 195     bool comma(false);
 196     for (id object in self) {
 197         if (comma)
 198             [json appendString:@","];
 199         else
 200             comma = true;
 201         [json appendString:[object cy$toJSON]];
 202     }
 203
 204     [json appendString:@"]"];
 205     return json;
 206 }
 207
 208 @end
 209
 210 @implementation NSDictionary (Cyrver)
 211
 212 - (NSString *) cy$toJSON {
 213     NSMutableString *json([[[NSMutableString alloc] init] autorelease]);
 214     [json appendString:@"("];
 215     [json appendString:@"{"];
 216
 217     bool comma(false);
 218     for (id key in self) {
 219         if (comma)
 220             [json appendString:@","];
 221         else
 222             comma = true;
 223         [json appendString:[key cy$toJSON]];
 224         [json appendString:@":"];
 225         NSObject *object([self objectForKey:key]);
 226         [json appendString:[object cy$toJSON]];
 227     }
 228
 229     [json appendString:@"})"];
 230     return json;
 231 }
 232
 233 @end
 234
 235 @implementation NSNumber (Cyrver)
 236
 237 - (NSString *) cy$toJSON {
 238     return [self class] != NSCFBoolean_ ? [self stringValue] : [self boolValue] ? @"true" : @"false";
 239 }
 240
 241 - (JSValueRef) cy$JSValueInContext:(JSContextRef)context {
 242     return [self class] != NSCFBoolean_ ? JSValueMakeNumber(context, [self doubleValue]) : JSValueMakeBoolean(context, [self boolValue]);
 243 }
 244
 245 @end
 246
 247 @implementation NSString (Cyrver)
 248
 249 - (NSString *) cy$toJSON {
 250     CFMutableStringRef json(CFStringCreateMutableCopy(kCFAllocatorDefault, 0, (CFStringRef) self));
 251
 252     CFStringFindAndReplace(json, CFSTR("\\"), CFSTR("\\\\"), CFRangeMake(0, CFStringGetLength(json)), 0);
 253     CFStringFindAndReplace(json, CFSTR("\""), CFSTR("\\\""), CFRangeMake(0, CFStringGetLength(json)), 0);
 254     CFStringFindAndReplace(json, CFSTR("\t"), CFSTR("\\t"), CFRangeMake(0, CFStringGetLength(json)), 0);
 255     CFStringFindAndReplace(json, CFSTR("\r"), CFSTR("\\r"), CFRangeMake(0, CFStringGetLength(json)), 0);
 256     CFStringFindAndReplace(json, CFSTR("\n"), CFSTR("\\n"), CFRangeMake(0, CFStringGetLength(json)), 0);
 257
 258     CFStringInsert(json, 0, CFSTR("\""));
 259     CFStringAppend(json, CFSTR("\""));
 260
 261     return [reinterpret_cast<const NSString *>(json) autorelease];
 262 }
 263
 264 @end
 265
 266 @interface CY$JSObject : NSDictionary {
 267     JSObjectRef object_;
 268     JSContextRef context_;
 269 }
 270
 271 - (id) initWithJSObject:(JSObjectRef)object inContext:(JSContextRef)context;
 272
 273 - (NSUInteger) count;
 274 - (id) objectForKey:(id)key;
 275 - (NSEnumerator *) keyEnumerator;
 276 - (void) setObject:(id)object forKey:(id)key;
 277 - (void) removeObjectForKey:(id)key;
 278
 279 @end
 280
 281 @interface CY$JSArray : NSArray {
 282     JSObjectRef object_;
 283     JSContextRef context_;
 284 }
 285
 286 - (id) initWithJSObject:(JSObjectRef)object inContext:(JSContextRef)context;
 287
 288 - (NSUInteger) count;
 289 - (id) objectAtIndex:(NSUInteger)index;
 290
 291 @end
 292
 293 JSContextRef JSGetContext() {
 294     return Context_;
 295 }
 296
 297 void CYThrow(JSContextRef context, JSValueRef value);
 298
 299 id JSObjectToNSObject(JSContextRef context, JSObjectRef object) {
 300     if (JSValueIsObjectOfClass(context, object, joc_))
 301         return reinterpret_cast<id>(JSObjectGetPrivate(object));
 302     JSValueRef exception(NULL);
 303     bool array(JSValueIsInstanceOfConstructor(context, object, Array_, &exception));
 304     CYThrow(context, exception);
 305     if (array)
 306         return [[[CY$JSArray alloc] initWithJSObject:object inContext:context] autorelease];
 307     return [[[CY$JSObject alloc] initWithJSObject:object inContext:context] autorelease];
 308 }
 309
 310 CFStringRef CYCopyCFString(JSStringRef value) {
 311     return JSStringCopyCFString(kCFAllocatorDefault, value);
 312 }
 313
 314 CFStringRef CYCopyCFString(JSContextRef context, JSValueRef value) {
 315     JSValueRef exception(NULL);
 316     JSStringRef string(JSValueToStringCopy(context, value, &exception));
 317     CYThrow(context, exception);
 318     CFStringRef object(CYCopyCFString(string));
 319     JSStringRelease(string);
 320     return object;
 321 }
 322
 323 NSString *CYCastNSString(JSStringRef value) {
 324     return [reinterpret_cast<const NSString *>(CYCopyCFString(value)) autorelease];
 325 }
 326
 327 CFTypeRef CYCopyCFType(JSContextRef context, JSValueRef value) {
 328     JSType type(JSValueGetType(context, value));
 329
 330     switch (type) {
 331         case kJSTypeUndefined:
 332             return CFRetain([WebUndefined undefined]);
 333         break;
 334
 335         case kJSTypeNull:
 336             return nil;
 337         break;
 338
 339         case kJSTypeBoolean:
 340             return CFRetain(JSValueToBoolean(context, value) ? kCFBooleanTrue : kCFBooleanFalse);
 341         break;
 342
 343         case kJSTypeNumber: {
 344             JSValueRef exception(NULL);
 345             double number(JSValueToNumber(context, value, &exception));
 346             CYThrow(context, exception);
 347             return CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &number);
 348         } break;
 349
 350         case kJSTypeString:
 351             return CYCopyCFString(context, value);
 352         break;
 353
 354         case kJSTypeObject:
 355             return CFRetain((CFTypeRef) JSObjectToNSObject(context, (JSObjectRef) value));
 356         break;
 357
 358         default:
 359             _assert(false);
 360         break;
 361     }
 362 }
 363
 364 NSArray *CYCastNSArray(JSPropertyNameArrayRef names) {
 365     size_t size(JSPropertyNameArrayGetCount(names));
 366     NSMutableArray *array([NSMutableArray arrayWithCapacity:size]);
 367     for (size_t index(0); index != size; ++index)
 368         [array addObject:CYCastNSString(JSPropertyNameArrayGetNameAtIndex(names, index))];
 369     return array;
 370 }
 371
 372 id CYCastNSObject(JSContextRef context, JSValueRef value) {
 373     const NSObject *object(reinterpret_cast<const NSObject *>(CYCopyCFType(context, value)));
 374     return object == nil ? nil : [object autorelease];
 375 }
 376
 377 void CYThrow(JSContextRef context, JSValueRef value) {
 378     if (value == NULL)
 379         return;
 380     @throw CYCastNSObject(context, value);
 381 }
 382
 383 JSValueRef CYCastJSValue(JSContextRef context, id value) {
 384     return value == nil ? JSValueMakeNull(context) : [value cy$JSValueInContext:context];
 385 }
 386
 387 JSStringRef CYCopyJSString(id value) {
 388     return JSStringCreateWithCFString(reinterpret_cast<CFStringRef>([value description]));
 389 }
 390
 391 JSStringRef CYCopyJSString(const char *value) {
 392     return JSStringCreateWithUTF8CString(value);
 393 }
 394
 395 JSStringRef CYCopyJSString(JSStringRef value) {
 396     return JSStringRetain(value);
 397 }
 398
 399 // XXX: this is not a safe handle
 400 class CYString {
 401   private:
 402     JSStringRef string_;
 403
 404   public:
 405     template <typename Type_>
 406     CYString(Type_ value) {
 407         string_ = CYCopyJSString(value);
 408     }
 409
 410     ~CYString() {
 411         JSStringRelease(string_);
 412     }
 413
 414     operator JSStringRef() const {
 415         return string_;
 416     }
 417 };
 418
 419 void CYThrow(JSContextRef context, id error, JSValueRef *exception) {
 420     *exception = CYCastJSValue(context, error);
 421 }
 422
 423 @implementation CY$JSObject
 424
 425 - (id) initWithJSObject:(JSObjectRef)object inContext:(JSContextRef)context {
 426     if ((self = [super init]) != nil) {
 427         object_ = object;
 428         context_ = context;
 429     } return self;
 430 }
 431
 432 - (NSUInteger) count {
 433     JSPropertyNameArrayRef names(JSObjectCopyPropertyNames(context_, object_));
 434     size_t size(JSPropertyNameArrayGetCount(names));
 435     JSPropertyNameArrayRelease(names);
 436     return size;
 437 }
 438
 439 - (id) objectForKey:(id)key {
 440     JSValueRef exception(NULL);
 441     JSValueRef value(JSObjectGetProperty(context_, object_, CYString(key), &exception));
 442     CYThrow(context_, exception);
 443     return CYCastNSObject(context_, value);
 444 }
 445
 446 - (NSEnumerator *) keyEnumerator {
 447     JSPropertyNameArrayRef names(JSObjectCopyPropertyNames(context_, object_));
 448     NSEnumerator *enumerator([CYCastNSArray(names) objectEnumerator]);
 449     JSPropertyNameArrayRelease(names);
 450     return enumerator;
 451 }
 452
 453 - (void) setObject:(id)object forKey:(id)key {
 454     JSValueRef exception(NULL);
 455     JSObjectSetProperty(context_, object_, CYString(key), CYCastJSValue(context_, object), kJSPropertyAttributeNone, &exception);
 456     CYThrow(context_, exception);
 457 }
 458
 459 - (void) removeObjectForKey:(id)key {
 460     JSValueRef exception(NULL);
 461     // XXX: this returns a bool
 462     JSObjectDeleteProperty(context_, object_, CYString(key), &exception);
 463     CYThrow(context_, exception);
 464 }
 465
 466 @end
 467
 468 @implementation CY$JSArray
 469
 470 - (id) initWithJSObject:(JSObjectRef)object inContext:(JSContextRef)context {
 471     if ((self = [super init]) != nil) {
 472         object_ = object;
 473         context_ = context;
 474     } return self;
 475 }
 476
 477 - (NSUInteger) count {
 478     JSValueRef exception(NULL);
 479     JSValueRef value(JSObjectGetProperty(context_, object_, length_, &exception));
 480     CYThrow(context_, exception);
 481     double number(JSValueToNumber(context_, value, &exception));
 482     CYThrow(context_, exception);
 483     return number;
 484 }
 485
 486 - (id) objectAtIndex:(NSUInteger)index {
 487     JSValueRef exception(NULL);
 488     JSValueRef value(JSObjectGetPropertyAtIndex(context_, object_, index, &exception));
 489     CYThrow(context_, exception);
 490     id object(CYCastNSObject(context_, value));
 491     return object == nil ? [NSNull null] : object;
 492 }
 493
 494 @end
 495
 496 CFStringRef JSValueToJSONCopy(JSContextRef context, JSValueRef value) {
 497     id object(CYCastNSObject(context, value));
 498     return reinterpret_cast<CFStringRef>([(object == nil ? @"null" : [object cy$toJSON]) retain]);
 499 }
 500
 501 static void OnData(CFSocketRef socket, CFSocketCallBackType type, CFDataRef address, const void *value, void *info) {
 502     switch (type) {
 503         case kCFSocketDataCallBack:
 504             CFDataRef data(reinterpret_cast<CFDataRef>(value));
 505             Client *client(reinterpret_cast<Client *>(info));
 506
 507             if (client->message_ == NULL)
 508                 client->message_ = CFHTTPMessageCreateEmpty(kCFAllocatorDefault, TRUE);
 509
 510             if (!CFHTTPMessageAppendBytes(client->message_, CFDataGetBytePtr(data), CFDataGetLength(data)))
 511                 CFLog(kCFLogLevelError, CFSTR("CFHTTPMessageAppendBytes()"));
 512             else if (CFHTTPMessageIsHeaderComplete(client->message_)) {
 513                 CFURLRef url(CFHTTPMessageCopyRequestURL(client->message_));
 514                 Boolean absolute;
 515                 CFStringRef path(CFURLCopyStrictPath(url, &absolute));
 516                 CFRelease(client->message_);
 517
 518                 CFStringRef code(CFURLCreateStringByReplacingPercentEscapes(kCFAllocatorDefault, path, CFSTR("")));
 519                 CFRelease(path);
 520
 521                 JSStringRef script(JSStringCreateWithCFString(code));
 522                 CFRelease(code);
 523
 524                 JSValueRef result(JSEvaluateScript(JSGetContext(), script, NULL, NULL, 0, NULL));
 525                 JSStringRelease(script);
 526
 527                 CFHTTPMessageRef response(CFHTTPMessageCreateResponse(kCFAllocatorDefault, 200, NULL, kCFHTTPVersion1_1));
 528                 CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Type"), CFSTR("application/json; charset=utf-8"));
 529
 530                 CFStringRef json(JSValueToJSONCopy(JSGetContext(), result));
 531                 CFDataRef body(CFStringCreateExternalRepresentation(kCFAllocatorDefault, json, kCFStringEncodingUTF8, NULL));
 532                 CFRelease(json);
 533
 534                 CFStringRef length(CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%u"), CFDataGetLength(body)));
 535                 CFHTTPMessageSetHeaderFieldValue(response, CFSTR("Content-Length"), length);
 536                 CFRelease(length);
 537
 538                 CFHTTPMessageSetBody(response, body);
 539                 CFRelease(body);
 540
 541                 CFDataRef serialized(CFHTTPMessageCopySerializedMessage(response));
 542                 CFRelease(response);
 543
 544                 CFSocketSendData(socket, NULL, serialized, 0);
 545                 CFRelease(serialized);
 546
 547                 CFRelease(url);
 548             }
 549         break;
 550     }
 551 }
 552
 553 static void OnAccept(CFSocketRef socket, CFSocketCallBackType type, CFDataRef address, const void *value, void *info) {
 554     switch (type) {
 555         case kCFSocketAcceptCallBack:
 556             Client *client(new Client());
 557
 558             client->message_ = NULL;
 559
 560             CFSocketContext context;
 561             context.version = 0;
 562             context.info = client;
 563             context.retain = NULL;
 564             context.release = NULL;
 565             context.copyDescription = NULL;
 566
 567             client->socket_ = CFSocketCreateWithNative(kCFAllocatorDefault, *reinterpret_cast<const CFSocketNativeHandle *>(value), kCFSocketDataCallBack, &OnData, &context);
 568
 569             CFRunLoopAddSource(CFRunLoopGetCurrent(), CFSocketCreateRunLoopSource(kCFAllocatorDefault, client->socket_, 0), kCFRunLoopDefaultMode);
 570         break;
 571     }
 572 }
 573
 574 static JSValueRef joc_getProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef *exception) {
 575     return NULL;
 576 }
 577
 578 typedef id jocData;
 579
 580 static void joc_finalize(JSObjectRef object) {
 581     id data(reinterpret_cast<jocData>(JSObjectGetPrivate(object)));
 582     [data release];
 583 }
 584
 585 static JSValueRef obc_getProperty(JSContextRef context, JSObjectRef object, JSStringRef propertyName, JSValueRef *exception) {
 586     NSString *name([(NSString *) JSStringCopyCFString(kCFAllocatorDefault, propertyName) autorelease]);
 587     if (Class _class = NSClassFromString(name))
 588         return JSObjectMake(context, joc_, [_class retain]);
 589     return NULL;
 590 }
 591
 592 void CYSetProperty(JSContextRef context, JSObjectRef object, const char *name, JSValueRef value) {
 593     JSValueRef exception(NULL);
 594     JSObjectSetProperty(context, object, CYString(name), value, kJSPropertyAttributeNone, &exception);
 595     CYThrow(context, exception);
 596 }
 597
 598 struct ffiData {
 599     apr_pool_t *pool_;
 600     void (*function_)();
 601     const char *type_;
 602     sig::Signature signature_;
 603     ffi_cif cif_;
 604 };
 605
 606 char *CYPoolCString(apr_pool_t *pool, JSStringRef value) {
 607     size_t size(JSStringGetMaximumUTF8CStringSize(value));
 608     char *string(reinterpret_cast<char *>(apr_palloc(pool, size)));
 609     JSStringGetUTF8CString(value, string, size);
 610     JSStringRelease(value);
 611     return string;
 612 }
 613
 614 SEL CYCastSEL(JSContextRef context, JSValueRef value) {
 615     if (JSValueIsNull(context, value))
 616         return NULL;
 617     else if (JSValueIsObjectOfClass(context, value, sel_))
 618         return reinterpret_cast<SEL>(JSObjectGetPrivate((JSObjectRef) value));
 619     else {
 620         JSValueRef exception(NULL);
 621         JSStringRef string(JSValueToStringCopy(context, value, &exception));
 622         CYThrow(context, exception);
 623         size_t size(JSStringGetMaximumUTF8CStringSize(string));
 624         char utf8[size];
 625         JSStringGetUTF8CString(string, utf8, size);
 626         JSStringRelease(string);
 627         return sel_registerName(utf8);
 628     }
 629 }
 630
 631 void CYToFFI(apr_pool_t *pool, JSContextRef context, sig::Type *type, void *data, JSValueRef value) {
 632     switch (type->primitive) {
 633         case sig::boolean_P:
 634             *reinterpret_cast<bool *>(data) = JSValueToBoolean(context, value);
 635         break;
 636
 637 #define CYToFFI_(primitive, native) \
 638         case sig::primitive ## _P: { \
 639             JSValueRef exception(NULL); \
 640             double number(JSValueToNumber(context, value, &exception)); \
 641             CYThrow(context, exception); \
 642             *reinterpret_cast<native *>(data) = number; \
 643         } break;
 644
 645         CYToFFI_(uchar, unsigned char)
 646         CYToFFI_(char, char)
 647         CYToFFI_(ushort, unsigned short)
 648         CYToFFI_(short, short)
 649         CYToFFI_(ulong, unsigned long)
 650         CYToFFI_(long, long)
 651         CYToFFI_(uint, unsigned int)
 652         CYToFFI_(int, int)
 653         CYToFFI_(ulonglong, unsigned long long)
 654         CYToFFI_(longlong, long long)
 655         CYToFFI_(float, float)
 656         CYToFFI_(double, double)
 657
 658         case sig::object_P:
 659         case sig::typename_P:
 660             *reinterpret_cast<id *>(data) = CYCastNSObject(context, value);
 661         break;
 662
 663         case sig::selector_P:
 664             *reinterpret_cast<SEL *>(data) = CYCastSEL(context, value);
 665         break;
 666
 667         case sig::pointer_P: {
 668             void *&pointer(*reinterpret_cast<void **>(data));
 669             if (JSValueIsNull(context, value))
 670                 pointer = NULL;
 671             else if (JSValueIsObjectOfClass(context, value, ptr_))
 672                 pointer = JSObjectGetPrivate((JSObjectRef) value);
 673             else {
 674                 JSValueRef exception(NULL);
 675                 double number(JSValueToNumber(context, value, &exception));
 676                 CYThrow(context, exception);
 677                 pointer = reinterpret_cast<void *>(static_cast<uintptr_t>(number));
 678             }
 679         } break;
 680
 681         case sig::string_P: {
 682             JSValueRef exception(NULL);
 683             JSStringRef string(JSValueToStringCopy(context, value, &exception));
 684             CYThrow(context, exception);
 685             size_t size(JSStringGetMaximumUTF8CStringSize(string));
 686             char *utf8(reinterpret_cast<char *>(apr_palloc(pool, size)));
 687             JSStringGetUTF8CString(string, utf8, size);
 688             JSStringRelease(string);
 689             *reinterpret_cast<char **>(data) = utf8;
 690         } break;
 691
 692         case sig::struct_P:
 693             goto fail;
 694
 695         case sig::void_P:
 696         break;
 697
 698         default: fail:
 699             NSLog(@"CYToFFI(%c)\n", type->primitive);
 700             _assert(false);
 701     }
 702 }
 703
 704 JSValueRef CYFromFFI(apr_pool_t *pool, JSContextRef context, sig::Type *type, void *data) {
 705     JSValueRef value;
 706
 707     switch (type->primitive) {
 708         case sig::boolean_P:
 709             value = JSValueMakeBoolean(context, *reinterpret_cast<bool *>(data));
 710         break;
 711
 712 #define CYFromFFI_(primitive, native) \
 713         case sig::primitive ## _P: \
 714             value = JSValueMakeNumber(context, *reinterpret_cast<native *>(data)); \
 715         break;
 716
 717         CYFromFFI_(uchar, unsigned char)
 718         CYFromFFI_(char, char)
 719         CYFromFFI_(ushort, unsigned short)
 720         CYFromFFI_(short, short)
 721         CYFromFFI_(ulong, unsigned long)
 722         CYFromFFI_(long, long)
 723         CYFromFFI_(uint, unsigned int)
 724         CYFromFFI_(int, int)
 725         CYFromFFI_(ulonglong, unsigned long long)
 726         CYFromFFI_(longlong, long long)
 727         CYFromFFI_(float, float)
 728         CYFromFFI_(double, double)
 729
 730         case sig::object_P:
 731         case sig::typename_P: {
 732             value = CYCastJSValue(context, *reinterpret_cast<id *>(data));
 733         } break;
 734
 735         case sig::selector_P: {
 736             SEL sel(*reinterpret_cast<SEL *>(data));
 737             value = sel == NULL ? JSValueMakeNull(context) : JSObjectMake(context, sel_, sel);
 738         } break;
 739
 740         case sig::pointer_P: {
 741             void *pointer(*reinterpret_cast<void **>(data));
 742             value = pointer == NULL ? JSValueMakeNull(context) : JSObjectMake(context, ptr_, pointer);
 743         } break;
 744
 745         case sig::string_P: {
 746             char *utf8(*reinterpret_cast<char **>(data));
 747             value = utf8 == NULL ? JSValueMakeNull(context) : JSValueMakeString(context, CYString(utf8));
 748         } break;
 749
 750         case sig::struct_P:
 751             goto fail;
 752
 753         case sig::void_P:
 754             value = NULL;
 755         break;
 756
 757         default: fail:
 758             NSLog(@"CYFromFFI(%c)\n", type->primitive);
 759             _assert(false);
 760     }
 761
 762     return value;
 763 }
 764
 765 class CYPool {
 766   private:
 767     apr_pool_t *pool_;
 768
 769   public:
 770     CYPool() {
 771         apr_pool_create(&pool_, NULL);
 772     }
 773
 774     ~CYPool() {
 775         apr_pool_destroy(pool_);
 776     }
 777
 778     operator apr_pool_t *() const {
 779         return pool_;
 780     }
 781 };
 782
 783 static JSValueRef CYCallFunction(JSContextRef context, size_t count, const JSValueRef *arguments, JSValueRef *exception, sig::Signature *signature, ffi_cif *cif, void (*function)()) {
 784     @try {
 785         if (count != signature->count - 1)
 786             [NSException raise:NSInvalidArgumentException format:@"incorrect number of arguments to ffi function"];
 787
 788         CYPool pool;
 789         void *values[count];
 790
 791         for (unsigned index(0); index != count; ++index) {
 792             sig::Element *element(&signature->elements[index + 1]);
 793             values[index] = apr_palloc(pool, cif->arg_types[index]->size);
 794             CYToFFI(pool, context, element->type, values[index], arguments[index]);
 795         }
 796
 797         uint8_t value[cif->rtype->size];
 798         ffi_call(cif, function, value, values);
 799
 800         return CYFromFFI(pool, context, signature->elements[0].type, value);
 801     } @catch (id error) {
 802         CYThrow(context, error, exception);
 803         return NULL;
 804     }
 805 }
 806
 807 static JSValueRef $objc_msgSend(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { _pooled
 808     const char *type;
 809
 810     @try {
 811         if (count < 2)
 812             [NSException raise:NSInvalidArgumentException format:@"too few arguments to objc_msgSend"];
 813
 814         id self(CYCastNSObject(context, arguments[0]));
 815         if (self == nil)
 816             return JSValueMakeNull(context);
 817
 818         SEL _cmd(CYCastSEL(context, arguments[1]));
 819         NSMethodSignature *method([self methodSignatureForSelector:_cmd]);
 820         if (method == nil)
 821             [NSException raise:NSInvalidArgumentException format:@"unrecognized selector %s sent to object %p", sel_getName(_cmd), self];
 822
 823         type = [[method _typeString] UTF8String];
 824     } @catch (id error) {
 825         CYThrow(context, error, exception);
 826         return NULL;
 827     }
 828
 829     CYPool pool;
 830
 831     sig::Signature signature;
 832     sig::Parse(pool, &signature, type);
 833
 834     void (*function)() = reinterpret_cast<void (*)()>(&objc_msgSend);
 835
 836     ffi_cif cif;
 837     sig::sig_ffi_cif(pool, &sig::sig_objc_ffi_type, &signature, &cif);
 838
 839     return CYCallFunction(context, count, arguments, exception, &signature, &cif, function);
 840 }
 841
 842 static JSValueRef ffi_callAsFunction(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
 843     ffiData *data(reinterpret_cast<ffiData *>(JSObjectGetPrivate(object)));
 844     return CYCallFunction(context, count, arguments, exception, &data->signature_, &data->cif_, data->function_);
 845 }
 846
 847 static void ffi_finalize(JSObjectRef object) {
 848     ffiData *data(reinterpret_cast<ffiData *>(JSObjectGetPrivate(object)));
 849     apr_pool_destroy(data->pool_);
 850 }
 851
 852 void CYSetFunction(JSContextRef context, JSObjectRef object, const char *name, void (*function)(), const char *type) {
 853     apr_pool_t *pool;
 854     apr_pool_create(&pool, NULL);
 855
 856     ffiData *data(reinterpret_cast<ffiData *>(apr_palloc(pool, sizeof(ffiData))));
 857
 858     data->pool_ = pool;
 859     data->function_ = function;
 860     data->type_ = apr_pstrdup(pool, type);
 861
 862     sig::Parse(pool, &data->signature_, type);
 863     sig::sig_ffi_cif(pool, &sig::sig_objc_ffi_type, &data->signature_, &data->cif_);
 864
 865     JSObjectRef value(JSObjectMake(context, ffi_, data));
 866     CYSetProperty(context, object, name, value);
 867 }
 868
 869 MSInitialize { _pooled
 870     apr_initialize();
 871
 872     NSCFBoolean_ = objc_getClass("NSCFBoolean");
 873
 874     pid_t pid(getpid());
 875
 876     struct sockaddr_in address;
 877     address.sin_len = sizeof(address);
 878     address.sin_family = AF_INET;
 879     address.sin_addr.s_addr = INADDR_ANY;
 880     address.sin_port = htons(10000 + pid);
 881
 882     CFDataRef data(CFDataCreate(kCFAllocatorDefault, reinterpret_cast<UInt8 *>(&address), sizeof(address)));
 883
 884     CFSocketSignature signature;
 885     signature.protocolFamily = AF_INET;
 886     signature.socketType = SOCK_STREAM;
 887     signature.protocol = IPPROTO_TCP;
 888     signature.address = data;
 889
 890     CFSocketRef socket(CFSocketCreateWithSocketSignature(kCFAllocatorDefault, &signature, kCFSocketAcceptCallBack, &OnAccept, NULL));
 891     CFRunLoopAddSource(CFRunLoopGetCurrent(), CFSocketCreateRunLoopSource(kCFAllocatorDefault, socket, 0), kCFRunLoopDefaultMode);
 892
 893     JSClassDefinition definition;
 894
 895     definition = kJSClassDefinitionEmpty;
 896     definition.getProperty = &obc_getProperty;
 897     JSClassRef obc(JSClassCreate(&definition));
 898
 899     definition = kJSClassDefinitionEmpty;
 900     definition.className = "ffi";
 901     definition.callAsFunction = &ffi_callAsFunction;
 902     definition.finalize = &ffi_finalize;
 903     ffi_ = JSClassCreate(&definition);
 904
 905     definition = kJSClassDefinitionEmpty;
 906     definition.className = "ptr";
 907     ptr_ = JSClassCreate(&definition);
 908
 909     definition = kJSClassDefinitionEmpty;
 910     definition.className = "sel";
 911     sel_ = JSClassCreate(&definition);
 912
 913     definition = kJSClassDefinitionEmpty;
 914     definition.className = "joc";
 915     definition.getProperty = &joc_getProperty;
 916     definition.finalize = &joc_finalize;
 917     joc_ = JSClassCreate(&definition);
 918
 919     JSContextRef context(JSGlobalContextCreate(obc));
 920     Context_ = context;
 921
 922     JSObjectRef global(JSContextGetGlobalObject(context));
 923
 924 #define CYSetFunction_(name, type) \
 925     CYSetFunction(context, global, #name, reinterpret_cast<void (*)()>(&name), type)
 926
 927     CYSetFunction_(class_createInstance, "@#L");
 928     CYSetFunction_(class_getInstanceSize, "L#");
 929     CYSetFunction_(class_getIvarLayout, "*#");
 930     CYSetFunction_(class_getName, "*#");
 931     CYSetFunction_(class_getSuperclass, "##");
 932     CYSetFunction_(class_getVersion, "i#");
 933     CYSetFunction_(class_isMetaClass, "B#");
 934     CYSetFunction_(class_respondsToSelector, "B#:");
 935     CYSetFunction_(class_setSuperclass, "###");
 936     CYSetFunction_(class_setVersion, "v#i");
 937     CYSetFunction_(objc_allocateClassPair, "##*L");
 938     CYSetFunction_(objc_getClass, "#*");
 939     CYSetFunction_(objc_getFutureClass, "#*");
 940     CYSetFunction_(objc_getMetaClass, "@*");
 941     CYSetFunction_(objc_getRequiredClass, "@*");
 942     CYSetFunction_(objc_lookUpClass, "@*");
 943     CYSetFunction_(objc_registerClassPair, "v#");
 944     CYSetFunction_(objc_setFutureClass, "v#*");
 945     CYSetFunction_(object_copy, "@@L");
 946     CYSetFunction_(object_dispose, "@@");
 947     CYSetFunction_(object_getClass, "#@");
 948     CYSetFunction_(object_getClassName, "*@");
 949     CYSetFunction_(object_setClass, "#@#");
 950     CYSetFunction_(sel_getName, "*:");
 951     CYSetFunction_(sel_getUid, ":*");
 952     CYSetFunction_(sel_isEqual, "B::");
 953     CYSetFunction_(sel_registerName, ":*");
 954
 955     CYSetProperty(context, global, "objc_msgSend", JSObjectMakeFunctionWithCallback(context, CYString("objc_msgSend"), &$objc_msgSend));
 956
 957     CYSetProperty(context, global, "YES", JSValueMakeBoolean(context, true));
 958     CYSetProperty(context, global, "NO", JSValueMakeBoolean(context, false));
 959     CYSetProperty(context, global, "nil", JSValueMakeNull(context));
 960
 961     name_ = JSStringCreateWithUTF8CString("name");
 962     message_ = JSStringCreateWithUTF8CString("message");
 963     length_ = JSStringCreateWithUTF8CString("length");
 964
 965     JSValueRef exception(NULL);
 966     JSValueRef value(JSObjectGetProperty(JSGetContext(), global, CYString("Array"), &exception));
 967     CYThrow(context, exception);
 968     Array_ = JSValueToObject(JSGetContext(), value, &exception);
 969     CYThrow(context, exception);
 970 }