IoObject *IoAppleSensors_smsVector(IoAppleSensors *self, IoObject *locals, IoMessage *m)
{
/*doc AppleSensors smsVector(aVector)
Sets aVector to the current x, y and z accelerometer values.
Returns true on success and false on failure.
*/
IoSeq *vector = IoMessage_locals_seqArgAt_(m, locals, 0);
float *f = IoSeq_floatPointerOfLength_(vector, 3);
int err;
if (smsType == -1)
{
smsType = detect_sms();
}
int v[3] = {0, 0, 0};
err = read_sms(smsType, &v[0], &v[1], &v[3]);
f[0] = v[0];
f[1] = v[1];
f[2] = v[2];
return err ? IOTRUE(self) : IOFALSE(self);
}
IO_METHOD(IoDirectory, exists)
{
/*doc Directory exists(optionalPath)
Returns true if the Directory path exists, and false otherwise.
If optionalPath string is provided, it tests the existence of that path instead.
*/
IoSymbol *path = DATA(self)->path;
DIR *dirp;
if (IoMessage_argCount(m) > 0)
{
path = IoMessage_locals_symbolArgAt_(m, locals, 0);
}
#if !defined(_WIN32) || defined(__CYGWIN__)
dirp = opendir(CSTRING(path));
if (!dirp)
{
return IOFALSE(self);
}
(void)closedir(dirp);
return IOTRUE(self);
#else
{
DWORD d = GetFileAttributes(CSTRING(path));
return (d != INVALID_FILE_ATTRIBUTES) && (d & FILE_ATTRIBUTE_DIRECTORY) ? IOTRUE(self) : IOFALSE(self);
}
#endif
}
IO_METHOD(IoDirectory, exists)
{
/*doc Directory exists(optionalPath)
Returns true if the Directory path exists, and false otherwise.
If optionalPath string is provided, it tests the existance of that path instead.
*/
IoSymbol *path = DATA(self)->path;
DIR *dirp;
if (IoMessage_argCount(m) > 0)
{
path = IoMessage_locals_symbolArgAt_(m, locals, 0);
}
dirp = opendir(CSTRING(path));
if (!dirp)
{
return IOFALSE(self);
}
(void)closedir(dirp);
return IOTRUE(self);
}
IoObject *IoAsyncRequest_isDone(IoAsyncRequest *self, IoObject *locals, IoMessage *m)
{
/*doc AsyncRequest isDone
Returns true if the request is done, false otherwise.
*/
int r = aio_error(IOCB(self));
return (r == 0 || r != EINPROGRESS) ? IOTRUE(self) : IOFALSE(self);
}
IoSecureClient *IoSecureClient_proto(void *state)
{
initSSL();
IoObject *self = IoObject_new(state);
IoObject_tag_(self, IoSecureClient_newTag(state));
SSL_CTX *ctx = SSL_CTX_new(TLSv1_client_method());
if(ctx == NULL)
{
ERR_print_errors_fp(stderr);
}
IoObject_setDataPointer_(self, ctx);
SSL_CTX_set_default_passwd_cb(ctx, IoSecureSockets_Password_Callback);
SSL_CTX_set_default_passwd_cb_userdata(ctx, self);
SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, IoSecureSockets_Verify_Callback);
#ifdef DTLS_IMPLEMENTED
IoObject_setSlot_to_(self, IOSYMBOL("supportsDTLS"), IOTRUE(self));
#else
IoObject_setSlot_to_(self, IOSYMBOL("supportsDTLS"), IOFALSE(self));
#endif
IoState_registerProtoWithFunc_((IoState *)state, self, IoSecureClient_proto);
{
IoMethodTable methodTable[] = {
{"setKeyFile", IoSecureClient_setKeyFile},
//doc SecureClient setKeyFile(aPath) Sets the key file. Returns self.
{"setCertFile", IoSecureClient_setCertFile},
//doc SecureClient setCertFile(aPath) Sets the Certificate file. Returns self.
{"setCAFile", IoSecureClient_setCAFile},
//doc SecureClient setCAFile(aPath) Sets the CA file. Returns self.
{"setCRLFile", IoSecureClient_setCRLFile},
//doc SecureClient setCRLFile(aPath) Sets the CRL file. Returns self.
{"useTLS", IoSecureClient_useTLS},
//doc SecureClient useTLS Returns useTLS value.
{"useDTLS", IoSecureClient_useDTLS},
//doc SecureClient useDTLS Returns useDTLS value.
{"connectionToServer", IoSecureClient_connectionToServer},
//doc SecureClient connectionToServer Returns connectionToServer.
{NULL, NULL}
};
IoObject_addMethodTable_(self, methodTable);
}
return self;
}
IoObject *IoFile_isUserExecutable(IoFile *self, IoObject *locals, IoMessage *m)
{
/*doc File isUserExecutable
Returns true if the receiver is user group executable, false otherwise.
*/
#ifdef ON_WINDOWS
return IOFALSE(self);
#else
mode_t mode = IoFile_statPointer(self, locals, m)->st_mode;
mode_t check = S_IXUSR;
return IOBOOL(self, mode & check);
#endif
}
IoObject* IoMySQL_connect(IoObject* self, IoObject* locals, IoMessage* m) {
IoObject *host = NULL, *user = NULL, *password = NULL, *database = NULL, *port = NULL, *socket = NULL, *ssl = NULL;
/*#io
docSlot("connect(host, user, password, database, port, unixSocket, useSSL)",
"Connect to a MySQL database.")
*/
switch(IoMessage_argCount(m)) {
case 7: ssl = IoMessage_locals_quickValueArgAt_(m, locals, 6);
case 6: socket = IoMessage_locals_quickValueArgAt_(m, locals, 5);
case 5: port = IoMessage_locals_quickValueArgAt_(m, locals, 4);
case 4: database = IoMessage_locals_quickValueArgAt_(m, locals, 3);
case 3: password = IoMessage_locals_quickValueArgAt_(m, locals, 2);
case 2: user = IoMessage_locals_quickValueArgAt_(m, locals, 1);
case 1: host = IoMessage_locals_quickValueArgAt_(m, locals, 0);
}
if(DATA(self)->connected)
mysql_close(&DATA(self)->connection);
if(mysql_real_connect(
&DATA(self)->connection,
host && ISSEQ(host) ? IoSeq_asCString(host) : NULL,
user && ISSEQ(user) ? IoSeq_asCString(user) : NULL,
password && ISSEQ(password) ? IoSeq_asCString(password) : NULL,
database && ISSEQ(database) ? IoSeq_asCString(database) : NULL,
port && ISNUMBER(port) ? (unsigned) IoNumber_asInt(port) : 0,
socket && ISSEQ(socket) ? IoSeq_asCString(socket) : NULL,
ssl && ISFALSE(ssl) ? 0 : CLIENT_SSL
)) {
DATA(self)->connected = 1;
IoObject_setSlot_to_(self, IOSYMBOL("host"), host ? host : IONIL(self));
IoObject_setSlot_to_(self, IOSYMBOL("user"), user ? user : IONIL(self));
IoObject_setSlot_to_(self, IOSYMBOL("password"), password ? password : IONIL(self));
IoObject_setSlot_to_(self, IOSYMBOL("database"), database ? database : IONIL(self));
IoObject_setSlot_to_(self, IOSYMBOL("port"), port ? port : IONIL(self));
IoObject_setSlot_to_(self, IOSYMBOL("socket"), socket ? socket : IONIL(self));
IoObject_setSlot_to_(self, IOSYMBOL("usingSSL"), ssl ? IOBOOL(self, ISTRUE(ssl)) : IOFALSE(self));
}
else
IoState_error_(IOSTATE, m, "connection error(%d): %s", mysql_errno(&DATA(self)->connection), mysql_error(&DATA(self)->connection));
return self;
}
void IoMessage_ifPossibleCacheToken_(IoMessage *self, IoToken *p)
{
IoSymbol *method = DATA(self)->name;
IoObject *r = NULL;
switch ((int)IoToken_type(p))
{
case TRIQUOTE_TOKEN:
r = IoSeq_rawAsUntriquotedSymbol(method);
break;
case MONOQUOTE_TOKEN:
r = IoSeq_rawAsUnescapedSymbol(IoSeq_rawAsUnquotedSymbol(method));
break;
case NUMBER_TOKEN:
r = IONUMBER(IoSeq_asDouble(method));
break;
case HEXNUMBER_TOKEN:
r = IONUMBER(IoSeq_rawAsDoubleFromHex(method));
break;
default:
if (IoSeq_rawEqualsCString_(method, "nil"))
{
r = IONIL(self);
}
else if (IoSeq_rawEqualsCString_(method, "true"))
{
r = IOTRUE(self);
}
else if (IoSeq_rawEqualsCString_(method, "false"))
{
r = IOFALSE(self);
}
}
IoMessage_cachedResult_(self, r);
}
IoSecureServer *IoSecureServer_proto(void *state)
{
initSSL();
IoObject *self = IoObject_new(state);
IoObject_tag_(self, IoSecureServer_newTag(state));
IoObject_setDataPointer_(self, (SecureServerData *)calloc(1, sizeof(SecureServerData)));
SSL_CTX *ctx = SSL_CTX_new(TLSv1_server_method());
DATA(self)->ssl_ctx = ctx;
SSL_CTX_set_default_passwd_cb(ctx, IoSecureSockets_Password_Callback);
SSL_CTX_set_default_passwd_cb_userdata(ctx, self);
SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, IoSecureSockets_Verify_Callback);
#ifdef DTLS_IMPLEMENTED
IoObject_setSlot_to_(self, IOSYMBOL("supportsDTLS"), IOTRUE(self));
#else
IoObject_setSlot_to_(self, IOSYMBOL("supportsDTLS"), IOFALSE(self));
#endif
//doc SecureServer supportsDTLS Returns true if server supports DTLS, false otherwise.
IoState_registerProtoWithFunc_((IoState *)state, self, IoSecureServer_proto);
{
IoMethodTable methodTable[] = {
{"setKeyFile", IoSecureServer_setKeyFile},
//doc SecureServer setKeyFile(path) Sets the key file. Returns self.
{"setCertFile", IoSecureServer_setCertFile},
//doc SecureServer setCertFile(path) Sets the certificate file. Returns self.
{"setCAFile", IoSecureServer_setCAFile},
//doc SecureServer setCAFile(path) Sets the CA file. Returns self.
{"setCRLFile", IoSecureServer_setCRLFile},
//doc SecureServer setCRLFile(path) Sets the CRL file. Returns self.
{"useTLS", IoSecureServer_useTLS},
//doc SecureServer useTLS Returns useTLS value.
{"useDTLS", IoSecureServer_useDTLS},
//doc SecureServer useDTLS Returns useDTLS value.
{"setRequiresClientCertificate", IoSecureServer_setRequiresClientCertificate},
//doc SecureServer setRequiresClientCertificate(aBool) Sets the requires client certificate attribute. Returns self.
{"tlsWrap", IoSecureServer_tlsWrap},
//doc SecureServer tlsWrap Returns tlsWrap value.
#ifdef DTLS_IMPLEMENTED
{"dtlsWrap", IoSecureServer_dtlsWrap},
//doc SecureServer dtlsWrap Returns dtlsWrap value.
{"udpRecvIP", IoSecureServer_udpRecvIP},
//doc SecureServer udpRecvIP Returns udpRecvIP value.
{"dispatchUdp", IoSecureServer_dispatchUDP},
//doc SecureServer dispatchUdp Returns dispatchUdp value.
#endif
{NULL, NULL}
};
IoObject_addMethodTable_(self, methodTable);
}
return self;
}
