Handler.cpp

   1 /* Cycript - The Truly Universal Scripting Language
   2  * Copyright (C) 2009-2016  Jay Freeman (saurik)
   3 */
   4
   5 /* GNU Affero General Public License, Version 3 {{{ */
   6 /*
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as published by
   9  * the Free Software Foundation, either version 3 of the License, or
  10  * (at your option) any later version.
  11
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 **/
  20 /* }}} */
  21
  22 #include "cycript.hpp"
  23
  24 #include <dlfcn.h>
  25 #include <pthread.h>
  26 #include <unistd.h>
  27 #include <sstream>
  28
  29 #include <sys/stat.h>
  30 #include <sys/types.h>
  31 #include <sys/socket.h>
  32 #include <netinet/in.h>
  33 #include <sys/un.h>
  34
  35 #ifdef __APPLE__
  36 #include <CoreFoundation/CoreFoundation.h>
  37 #endif
  38
  39 #include "Driver.hpp"
  40 #include "JavaScript.hpp"
  41 #include "Syntax.hpp"
  42 #include "Pooling.hpp"
  43
  44 struct CYExecute_ {
  45     CYPool &pool_;
  46     const char * volatile data_;
  47     pthread_mutex_t mutex_;
  48     pthread_cond_t condition_;
  49 };
  50
  51 void CYPerform(void *arg) {
  52     CYExecute_ *execute(reinterpret_cast<CYExecute_ *>(arg));
  53
  54     const char *data(execute->data_);
  55     execute->data_ = NULL;
  56     execute->data_ = CYExecute(CYGetJSContext(), execute->pool_, CYUTF8String(data));
  57
  58     pthread_mutex_lock(&execute->mutex_);
  59     pthread_cond_signal(&execute->condition_);
  60     pthread_mutex_unlock(&execute->mutex_);
  61 }
  62
  63 struct CYClient :
  64     CYData
  65 {
  66     int socket_;
  67     pthread_t thread_;
  68
  69     CYClient(int socket) :
  70         socket_(socket)
  71     {
  72     }
  73
  74     ~CYClient() {
  75         _syscall(close(socket_));
  76     }
  77
  78     void Handle() {
  79         bool dispatch;
  80 #ifdef __APPLE__
  81         CFRunLoopRef loop(CFRunLoopGetMain());
  82         if (CFStringRef mode = CFRunLoopCopyCurrentMode(loop)) {
  83             dispatch = true;
  84             CFRelease(mode);
  85         } else
  86 #endif
  87             dispatch = false;
  88
  89         for (;;) {
  90             uint32_t size;
  91             if (!CYRecvAll(socket_, &size, sizeof(size)))
  92                 return;
  93
  94             CYLocalPool pool;
  95             char *data(new(pool) char[size + 1]);
  96             if (!CYRecvAll(socket_, data, size))
  97                 return;
  98             data[size] = '\0';
  99
 100             std::string code(data, size);
 101             CYExecute_ execute = {pool, code.c_str()};
 102
 103             pthread_mutex_init(&execute.mutex_, NULL);
 104             pthread_cond_init(&execute.condition_, NULL);
 105
 106             if (!dispatch)
 107                 CYPerform(&execute);
 108 #ifdef __APPLE__
 109             else {
 110                 CFRunLoopSourceContext context;
 111                 memset(&context, 0, sizeof(context));
 112                 context.version = 0;
 113                 context.info = &execute;
 114                 context.perform = &CYPerform;
 115
 116                 CFRunLoopSourceRef source(CFRunLoopSourceCreate(kCFAllocatorDefault, 0, &context));
 117
 118                 pthread_mutex_lock(&execute.mutex_);
 119
 120                 CFRunLoopAddSource(loop, source, kCFRunLoopCommonModes);
 121                 CFRunLoopSourceSignal(source);
 122
 123                 CFRunLoopWakeUp(loop);
 124                 pthread_cond_wait(&execute.condition_, &execute.mutex_);
 125                 pthread_mutex_unlock(&execute.mutex_);
 126
 127                 CFRunLoopRemoveSource(loop, source, kCFRunLoopCommonModes);
 128                 CFRelease(source);
 129             }
 130 #endif
 131
 132             pthread_cond_destroy(&execute.condition_);
 133             pthread_mutex_destroy(&execute.mutex_);
 134
 135             const char *json(execute.data_);
 136             size = json == NULL ? _not(uint32_t) : strlen(json);
 137
 138             if (!CYSendAll(socket_, &size, sizeof(size)))
 139                 return;
 140             if (json != NULL)
 141                 if (!CYSendAll(socket_, json, size))
 142                     return;
 143         }
 144     }
 145 };
 146
 147 static void *OnClient(void *data) {
 148     CYClient *client(reinterpret_cast<CYClient *>(data));
 149     client->Handle();
 150     delete client;
 151     return NULL;
 152 }
 153
 154 void CYHandleClient(int socket) {
 155     // XXX: this leaks memory... really?
 156     CYPool *pool(new CYPool());
 157     CYClient *client(new(*pool) CYClient(socket));
 158     _assert(pthread_create(&client->thread_, NULL, &OnClient, client) == 0);
 159 }
 160
 161 static void CYHandleSocket(const char *path) {
 162     int socket(_syscall(::socket(PF_UNIX, SOCK_STREAM, 0)));
 163
 164     struct sockaddr_un address;
 165     memset(&address, 0, sizeof(address));
 166     address.sun_family = AF_UNIX;
 167     strcpy(address.sun_path, path);
 168
 169     _syscall(connect(socket, reinterpret_cast<sockaddr *>(&address), sizeof(address)));
 170
 171     CYInitializeDynamic();
 172     CYHandleClient(socket);
 173 }
 174
 175 _extern void CYHandleServer(pid_t pid) { try {
 176     char path[1024];
 177     sprintf(path, "/tmp/.s.cy.%u", pid);
 178     CYHandleSocket(path);
 179 } catch (const CYException &error) {
 180     CYPool pool;
 181     fprintf(stderr, "%s\n", error.PoolCString(pool));
 182 } }
 183
 184 _extern char *MSmain0(int argc, char *argv[]) { try {
 185     _assert(argc == 2);
 186     CYHandleSocket(argv[1]);
 187
 188     static void *handle(NULL);
 189     if (handle == NULL) {
 190         Dl_info info;
 191         _assert(dladdr(reinterpret_cast<void *>(&MSmain0), &info) != 0);
 192 #ifdef __ANDROID__
 193         handle = dlopen(info.dli_fname, 0);
 194 #else
 195         handle = dlopen(info.dli_fname, RTLD_NOLOAD);
 196 #endif
 197     }
 198
 199     return NULL;
 200 } catch (const CYException &error) {
 201     CYPool pool;
 202     return strdup(error.PoolCString(pool));
 203 } }
 204
 205 struct CYServer {
 206     pthread_t thread_;
 207     uint16_t port_;
 208     int socket_;
 209
 210     CYServer(uint16_t port) :
 211         port_(port),
 212         socket_(-1)
 213     {
 214     }
 215
 216     ~CYServer() {
 217         if (socket_ != -1)
 218             _syscall(close(socket_));
 219     }
 220
 221     void Listen() {
 222         socket_ = _syscall(::socket(PF_INET, SOCK_STREAM, 0)); try {
 223             int value;
 224             _syscall(::setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR, &(value = 1), sizeof(value)));
 225
 226             sockaddr_in address;
 227             address.sin_family = AF_INET;
 228             address.sin_addr.s_addr = INADDR_ANY;
 229             address.sin_port = htons(port_);
 230             _syscall(::bind(socket_, reinterpret_cast<sockaddr *>(&address), sizeof(address)));
 231
 232             _syscall(::listen(socket_, -1));
 233
 234             for (;;) {
 235                 socklen_t length(sizeof(address));
 236                 int socket(_syscall(::accept(socket_, reinterpret_cast<sockaddr *>(&address), &length)));
 237                 CYHandleClient(socket);
 238             }
 239         } catch (const CYException &error) {
 240             CYPool pool;
 241             fprintf(stderr, "%s\n", error.PoolCString(pool));
 242         }
 243     }
 244 };
 245
 246 static void *OnServer(void *data) {
 247     CYServer *server(reinterpret_cast<CYServer *>(data));
 248     server->Listen();
 249     delete server;
 250     return NULL;
 251 }
 252
 253 _extern void CYListenServer(short port) {
 254     CYInitializeDynamic();
 255
 256     CYServer *server(new CYServer(port));
 257     _assert(pthread_create(&server->thread_, NULL, &OnServer, server) == 0);
 258 }