X-Git-Url: https://git.saurik.com/cycript.git/blobdiff_plain/d15b59f5d4f43d12719c5ce37518246058b405c6..7eb6c2f23b20ac241ec4cc1183654d9b01fd86ef:/Handler.mm?ds=sidebyside diff --git a/Handler.mm b/Handler.mm index 39825fa..3298148 100644 --- a/Handler.mm +++ b/Handler.mm @@ -1,56 +1,45 @@ -/* Cycript - Inlining/Optimizing JavaScript Compiler - * Copyright (C) 2009 Jay Freeman (saurik) +/* Cycript - Optimizing JavaScript Compiler/Runtime + * Copyright (C) 2009-2013 Jay Freeman (saurik) */ -/* Modified BSD License {{{ */ +/* GNU General Public License, Version 3 {{{ */ /* - * Redistribution and use in source and binary - * forms, with or without modification, are permitted - * provided that the following conditions are met: + * Cycript is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published + * by the Free Software Foundation, either version 3 of the License, + * or (at your option) any later version. * - * 1. Redistributions of source code must retain the - * above copyright notice, this list of conditions - * and the following disclaimer. - * 2. Redistributions in binary form must reproduce the - * above copyright notice, this list of conditions - * and the following disclaimer in the documentation - * and/or other materials provided with the - * distribution. - * 3. The name of the author may not be used to endorse - * or promote products derived from this software - * without specific prior written permission. + * Cycript is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, - * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR - * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR - * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN - * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF - * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ + * You should have received a copy of the GNU General Public License + * along with Cycript. If not, see <http://www.gnu.org/licenses/>. +**/ /* }}} */ +#include <Foundation/Foundation.h> +#include <pthread.h> +#include <unistd.h> +#include <sstream> + +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <sys/un.h> + #include "cycript.hpp" -#include "Pooling.hpp" +#include "JavaScript.hpp" #include "Parser.hpp" +#include "Pooling.hpp" #include "Cycript.tab.hh" - -#include <Foundation/Foundation.h> -#include <apr_thread_proc.h> -#include <unistd.h> -#include <sstream> +#include "Driver.hpp" struct CYExecute_ { - apr_pool_t *pool_; + CYPool &pool_; const char * volatile data_; }; @@ -68,7 +57,7 @@ struct CYExecute_ { CYExecute_ *execute(reinterpret_cast<CYExecute_ *>([value pointerValue])); const char *data(execute->data_); execute->data_ = NULL; - execute->data_ = CYExecute(execute->pool_, data); + execute->data_ = CYExecute(CYGetJSContext(), execute->pool_, CYUTF8String(data)); } @end @@ -77,7 +66,7 @@ struct CYClient : CYData { int socket_; - apr_thread_t *thread_; + pthread_t thread_; CYClient(int socket) : socket_(socket) @@ -89,42 +78,42 @@ struct CYClient : } void Handle() { - CYClient_ *client = [[CYClient_ alloc] init]; - @try { + NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; + + CYClient_ *client = [[[CYClient_ alloc] init] autorelease]; + + bool dispatch; + if (CFStringRef mode = CFRunLoopCopyCurrentMode(CFRunLoopGetMain())) { + dispatch = true; + CFRelease(mode); + } else + dispatch = false; for (;;) { - size_t size; + uint32_t size; if (!CYRecvAll(socket_, &size, sizeof(size))) return; - CYPool pool; + CYLocalPool pool; char *data(new(pool) char[size + 1]); if (!CYRecvAll(socket_, data, size)) return; data[size] = '\0'; - CYDriver driver(""); - cy::parser parser(driver); - - driver.data_ = data; - driver.size_ = size; - - const char *json; - if (parser.parse() != 0 || !driver.errors_.empty()) { - json = NULL; - size = _not(size_t); - } else { - CYContext context(driver.pool_); - driver.program_->Replace(context); - std::ostringstream str; - CYOutput out(str); - out << *driver.program_; - std::string code(str.str()); - CYExecute_ execute = {pool, code.c_str()}; - [client performSelectorOnMainThread:@selector(execute:) withObject:[NSValue valueWithPointer:&execute] waitUntilDone:YES]; - json = execute.data_; - size = json == NULL ? _not(size_t) : strlen(json); - } + NSAutoreleasePool *ar = [[NSAutoreleasePool alloc] init]; + + std::string code(data, size); + CYExecute_ execute = {pool, code.c_str()}; + NSValue *value([NSValue valueWithPointer:&execute]); + if (dispatch) + [client performSelectorOnMainThread:@selector(execute:) withObject:value waitUntilDone:YES]; + else + [client execute:value]; + + const char *json(execute.data_); + size = json == NULL ? _not(uint32_t) : strlen(json); + + [ar release]; if (!CYSendAll(socket_, &size, sizeof(size))) return; @@ -133,22 +122,89 @@ struct CYClient : return; } - } @finally { - [client release]; - } + [pool release]; } }; -static void * APR_THREAD_FUNC OnClient(apr_thread_t *thread, void *data) { +static void *OnClient(void *data) { CYClient *client(reinterpret_cast<CYClient *>(data)); client->Handle(); delete client; return NULL; } -extern "C" void CYHandleClient(apr_pool_t *pool, int socket) { - CYClient *client(new(pool) CYClient(socket)); - apr_threadattr_t *attr; - _aprcall(apr_threadattr_create(&attr, client->pool_)); - _aprcall(apr_thread_create(&client->thread_, attr, &OnClient, client, client->pool_)); +extern "C" void CYHandleClient(int socket) { + // XXX: this leaks memory... really? + CYPool *pool(new CYPool()); + CYClient *client(new(*pool) CYClient(socket)); + _assert(pthread_create(&client->thread_, NULL, &OnClient, client) == 0); +} + +extern "C" void CYHandleServer(pid_t pid) { + CYInitializeDynamic(); + + int socket(_syscall(::socket(PF_UNIX, SOCK_STREAM, 0))); try { + struct sockaddr_un address; + memset(&address, 0, sizeof(address)); + address.sun_family = AF_UNIX; + sprintf(address.sun_path, "/tmp/.s.cy.%u", pid); + + _syscall(connect(socket, reinterpret_cast<sockaddr *>(&address), SUN_LEN(&address))); + CYHandleClient(socket); + } catch (const CYException &error) { + CYPool pool; + fprintf(stderr, "%s\n", error.PoolCString(pool)); + } +} + +struct CYServer { + pthread_t thread_; + uint16_t port_; + int socket_; + + CYServer(uint16_t port) : + port_(port), + socket_(-1) + { + } + + ~CYServer() { + if (socket_ != -1) + _syscall(close(socket_)); + } + + void Listen() { + socket_ = _syscall(::socket(PF_INET, SOCK_STREAM, 0)); try { + sockaddr_in address; + address.sin_family = AF_INET; + address.sin_addr.s_addr = INADDR_ANY; + address.sin_port = htons(port_); + _syscall(::bind(socket_, reinterpret_cast<sockaddr *>(&address), sizeof(address))); + + _syscall(::listen(socket_, -1)); + + for (;;) { + socklen_t length(sizeof(address)); + int socket(_syscall(::accept(socket_, reinterpret_cast<sockaddr *>(&address), &length))); + CYHandleClient(socket); + } + } catch (const CYException &error) { + CYPool pool; + fprintf(stderr, "%s\n", error.PoolCString(pool)); + } + } +}; + +static void *OnServer(void *data) { + CYServer *server(reinterpret_cast<CYServer *>(data)); + server->Listen(); + delete server; + return NULL; +} + +extern "C" void CYListenServer(short port) { + CYInitializeDynamic(); + + CYServer *server(new CYServer(port)); + _assert(pthread_create(&server->thread_, NULL, &OnServer, server) == 0); }