Handler.mm

   1 /* Cycript - Optimizing JavaScript Compiler/Runtime
   2  * Copyright (C) 2009-2013  Jay Freeman (saurik)
   3 */
   4
   5 /* GNU General Public License, Version 3 {{{ */
   6 /*
   7  * Cycript is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published
   9  * by the Free Software Foundation, either version 3 of the License,
  10  * or (at your option) any later version.
  11  *
  12  * Cycript is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Cycript.  If not, see <http://www.gnu.org/licenses/>.
  19 **/
  20 /* }}} */
  21
  22 #include <Foundation/Foundation.h>
  23 #include <pthread.h>
  24 #include <unistd.h>
  25 #include <sstream>
  26
  27 #include <sys/types.h>
  28 #include <sys/socket.h>
  29 #include <netinet/in.h>
  30 #include <sys/un.h>
  31
  32 #include "cycript.hpp"
  33
  34 #include "JavaScript.hpp"
  35 #include "Parser.hpp"
  36 #include "Pooling.hpp"
  37
  38 #include "Cycript.tab.hh"
  39 #include "Driver.hpp"
  40
  41 struct CYExecute_ {
  42     CYPool &pool_;
  43     const char * volatile data_;
  44 };
  45
  46 // XXX: this is "tre lame"
  47 @interface CYClient_ : NSObject {
  48 }
  49
  50 - (void) execute:(NSValue *)value;
  51
  52 @end
  53
  54 @implementation CYClient_
  55
  56 - (void) execute:(NSValue *)value {
  57     CYExecute_ *execute(reinterpret_cast<CYExecute_ *>([value pointerValue]));
  58     const char *data(execute->data_);
  59     execute->data_ = NULL;
  60     execute->data_ = CYExecute(execute->pool_, CYUTF8String(data));
  61 }
  62
  63 @end
  64
  65 struct CYClient :
  66     CYData
  67 {
  68     int socket_;
  69     pthread_t thread_;
  70
  71     CYClient(int socket) :
  72         socket_(socket)
  73     {
  74     }
  75
  76     ~CYClient() {
  77         _syscall(close(socket_));
  78     }
  79
  80     void Handle() {
  81         NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
  82
  83         CYClient_ *client = [[[CYClient_ alloc] init] autorelease];
  84
  85         bool dispatch;
  86         if (CFStringRef mode = CFRunLoopCopyCurrentMode(CFRunLoopGetMain())) {
  87             dispatch = true;
  88             CFRelease(mode);
  89         } else
  90             dispatch = false;
  91
  92         for (;;) {
  93             uint32_t size;
  94             if (!CYRecvAll(socket_, &size, sizeof(size)))
  95                 return;
  96
  97             CYLocalPool pool;
  98             char *data(new(pool) char[size + 1]);
  99             if (!CYRecvAll(socket_, data, size))
 100                 return;
 101             data[size] = '\0';
 102
 103             CYStream stream(data, data + size);
 104             CYDriver driver(stream);
 105
 106             cy::parser parser(driver);
 107
 108             const char *json;
 109             if (parser.parse() != 0 || !driver.errors_.empty()) {
 110                 json = NULL;
 111                 size = _not(uint32_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(uint32_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 *OnClient(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(int socket) {
 153     // XXX: this leaks memory... really?
 154     CYPool *pool(new CYPool());
 155     CYClient *client(new(*pool) CYClient(socket));
 156     _assert(pthread_create(&client->thread_, NULL, &OnClient, client) == 0);
 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         CYHandleClient(socket);
 170     } catch (const CYException &error) {
 171         CYPool pool;
 172         fprintf(stderr, "%s\n", error.PoolCString(pool));
 173     }
 174 }
 175
 176 struct CYServer {
 177     pthread_t thread_;
 178     uint16_t port_;
 179     int socket_;
 180
 181     CYServer(uint16_t port) :
 182         port_(port),
 183         socket_(-1)
 184     {
 185     }
 186
 187     ~CYServer() {
 188         if (socket_ != -1)
 189             _syscall(close(socket_));
 190     }
 191
 192     void Listen() {
 193         socket_ = _syscall(::socket(PF_INET, SOCK_STREAM, 0)); try {
 194             sockaddr_in address;
 195             address.sin_family = AF_INET;
 196             address.sin_addr.s_addr = INADDR_ANY;
 197             address.sin_port = htons(port_);
 198             _syscall(::bind(socket_, reinterpret_cast<sockaddr *>(&address), sizeof(address)));
 199
 200             _syscall(::listen(socket_, -1));
 201
 202             for (;;) {
 203                 socklen_t length(sizeof(address));
 204                 int socket(_syscall(::accept(socket_, reinterpret_cast<sockaddr *>(&address), &length)));
 205                 CYHandleClient(socket);
 206             }
 207         } catch (const CYException &error) {
 208             CYPool pool;
 209             fprintf(stderr, "%s\n", error.PoolCString(pool));
 210         }
 211     }
 212 };
 213
 214 static void *OnServer(void *data) {
 215     CYServer *server(reinterpret_cast<CYServer *>(data));
 216     server->Listen();
 217     delete server;
 218     return NULL;
 219 }
 220
 221 extern "C" void CYListenServer(short port) {
 222     CYInitializeDynamic();
 223
 224     CYServer *server(new CYServer(port));
 225     _assert(pthread_create(&server->thread_, NULL, &OnServer, server) == 0);
 226 }