Handler.mm

   1 /* Cycript - Optimizing JavaScript Compiler/Runtime
   2  * Copyright (C) 2009-2012  Jay Freeman (saurik)
   3 */
   4
   5 /* GNU Lesser General Public License, Version 3 {{{ */
   6 /*
   7  * Cycript is free software: you can redistribute it and/or modify it under
   8  * the terms of the GNU Lesser General Public License as published by the
   9  * Free Software Foundation, either version 3 of the License, or (at your
  10  * option) any later version.
  11  *
  12  * Cycript is distributed in the hope that it will be useful, but WITHOUT
  13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  15  * License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public License
  18  * along with Cycript.  If not, see <http://www.gnu.org/licenses/>.
  19 **/
  20 /* }}} */
  21
  22 #include "cycript.hpp"
  23 #include "JavaScript.hpp"
  24
  25 #include "Pooling.hpp"
  26 #include "Parser.hpp"
  27
  28 #include "Cycript.tab.hh"
  29
  30 #include <Foundation/Foundation.h>
  31 #include <apr_thread_proc.h>
  32 #include <unistd.h>
  33 #include <sstream>
  34
  35 #include <sys/types.h>
  36 #include <sys/socket.h>
  37 #include <netinet/in.h>
  38 #include <sys/un.h>
  39
  40 struct CYExecute_ {
  41     apr_pool_t *pool_;
  42     const char * volatile data_;
  43 };
  44
  45 // XXX: this is "tre lame"
  46 @interface CYClient_ : NSObject {
  47 }
  48
  49 - (void) execute:(NSValue *)value;
  50
  51 @end
  52
  53 @implementation CYClient_
  54
  55 - (void) execute:(NSValue *)value {
  56     CYExecute_ *execute(reinterpret_cast<CYExecute_ *>([value pointerValue]));
  57     const char *data(execute->data_);
  58     execute->data_ = NULL;
  59     execute->data_ = CYExecute(execute->pool_, CYUTF8String(data));
  60 }
  61
  62 @end
  63
  64 struct CYClient :
  65     CYData
  66 {
  67     int socket_;
  68     apr_thread_t *thread_;
  69
  70     CYClient(int socket) :
  71         socket_(socket)
  72     {
  73     }
  74
  75     ~CYClient() {
  76         _syscall(close(socket_));
  77     }
  78
  79     void Handle() {
  80         NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
  81
  82         CYClient_ *client = [[[CYClient_ alloc] init] autorelease];
  83
  84         bool dispatch;
  85         if (CFStringRef mode = CFRunLoopCopyCurrentMode(CFRunLoopGetMain())) {
  86             dispatch = true;
  87             CFRelease(mode);
  88         } else
  89             dispatch = false;
  90
  91         for (;;) {
  92             size_t size;
  93             if (!CYRecvAll(socket_, &size, sizeof(size)))
  94                 return;
  95
  96             CYLocalPool pool;
  97             char *data(new(pool) char[size + 1]);
  98             if (!CYRecvAll(socket_, data, size))
  99                 return;
 100             data[size] = '\0';
 101
 102             CYDriver driver;
 103             cy::parser parser(driver);
 104
 105             driver.data_ = data;
 106             driver.size_ = size;
 107
 108             const char *json;
 109             if (parser.parse() != 0 || !driver.errors_.empty()) {
 110                 json = NULL;
 111                 size = _not(size_t);
 112             } else {
 113                 NSAutoreleasePool *ar = [[NSAutoreleasePool alloc] init];
 114
 115                 CYOptions options;
 116                 CYContext context(options);
 117                 driver.program_->Replace(context);
 118                 std::ostringstream str;
 119                 CYOutput out(str, options);
 120                 out << *driver.program_;
 121                 std::string code(str.str());
 122                 CYExecute_ execute = {pool, code.c_str()};
 123                 NSValue *value([NSValue valueWithPointer:&execute]);
 124                 if (dispatch)
 125                     [client performSelectorOnMainThread:@selector(execute:) withObject:value waitUntilDone:YES];
 126                 else
 127                     [client execute:value];
 128                 json = execute.data_;
 129                 size = json == NULL ? _not(size_t) : strlen(json);
 130
 131                 [ar release];
 132             }
 133
 134             if (!CYSendAll(socket_, &size, sizeof(size)))
 135                 return;
 136             if (json != NULL)
 137                 if (!CYSendAll(socket_, json, size))
 138                     return;
 139         }
 140
 141         [pool release];
 142     }
 143 };
 144
 145 static void * APR_THREAD_FUNC OnClient(apr_thread_t *thread, void *data) {
 146     CYClient *client(reinterpret_cast<CYClient *>(data));
 147     client->Handle();
 148     delete client;
 149     return NULL;
 150 }
 151
 152 extern "C" void CYHandleClient(apr_pool_t *pool, int socket) {
 153     CYClient *client(new(pool) CYClient(socket));
 154     apr_threadattr_t *attr;
 155     _aprcall(apr_threadattr_create(&attr, client->pool_));
 156     _aprcall(apr_thread_create(&client->thread_, attr, &OnClient, client, client->pool_));
 157 }
 158
 159 extern "C" void CYHandleServer(pid_t pid) {
 160     CYInitializeDynamic();
 161
 162     int socket(_syscall(::socket(PF_UNIX, SOCK_STREAM, 0))); try {
 163         struct sockaddr_un address;
 164         memset(&address, 0, sizeof(address));
 165         address.sun_family = AF_UNIX;
 166         sprintf(address.sun_path, "/tmp/.s.cy.%u", pid);
 167
 168         _syscall(connect(socket, reinterpret_cast<sockaddr *>(&address), SUN_LEN(&address)));
 169
 170         apr_pool_t *pool;
 171         apr_pool_create(&pool, NULL);
 172
 173         CYHandleClient(pool, socket);
 174     } catch (const CYException &error) {
 175         CYPool pool;
 176         fprintf(stderr, "%s\n", error.PoolCString(pool));
 177     }
 178 }