static VALUE rfpset_spit_array(VALUE self, VALUE array, VALUE filename) {
gzFile out = gzopen(RSTRING_PTR(filename), "wb2");
if(out == NULL) return rb_fix_new(-1);
long ii;
long size = RARRAY_LEN(array);
// sort the array in place
VALUE* values = RARRAY_PTR(array);
rstring_sort_array(values, size);
// spit them at the disk, freeing as we go
VALUE last_value = 0;
for(ii = 0; ii < size; ++ii) {
if(!last_value
|| RSTRING_LEN(values[ii]) != RSTRING_LEN(last_value)
|| memcmp(RSTRING_PTR(values[ii]), RSTRING_PTR(last_value),
RSTRING_LEN(last_value)) != 0) {
// this blob is unique. Write it
rstring_write(out, values[ii]);
last_value = values[ii];
}
}
gzclose(out);
// return the number of blobs written
return rb_fix_new(size);
}
static VALUE asteroid_s_run(VALUE Self, VALUE Host, VALUE Port, VALUE Module){
char *host = StringValuePtr(Host);
int port = FIX2INT(Port);
epoll_fd = asteroid_poll_create(1024);
if(epoll_fd == -1) runtime_error();
struct sockaddr_in addr;
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr(host);
int s = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP), c, one = 1;
if(s == -1) runtime_error();
fcntl(s, F_SETFL, fcntl(s, F_GETFL, 0) | O_NONBLOCK);
setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
nosigpipe(s);
if(bind(s, (struct sockaddr*)&addr, sizeof(addr)) != 0) runtime_error();
if(listen(s, MAX_CONNECTION) != 0) runtime_error();
if(rb_block_given_p()) rb_yield(Qnil);
VALUE Class = rb_define_class_under(Asteroid, "Server", rb_cObject);
rb_define_method(Class, "send_data",
asteroid_server_send_data, 1);
rb_define_method(Class, "write_and_close",
asteroid_server_write_and_close, 0);
rb_include_module(Class, Module);
// Mac OS X, Fedora needs explicit rb_thread_schedule call.
for(running = 1; running; rb_thread_schedule()){
socklen_t len = sizeof(addr);
while((c = accept(s, (struct sockaddr*)&addr, &len)) != -1){
printf("A New client connected here\n");
fcntl(c, F_SETFL, fcntl(c, F_GETFL, 0) | O_NONBLOCK);
asteroid_poll_event_t event;
memset(&event, 0, sizeof(event));
if(asteroid_poll_add(epoll_fd, &event, c) == -1) runtime_error();
// instantiate server class which responds to client.
VALUE Server = rb_class_new_instance(0, NULL, Class);
rb_iv_set(Server, "@fd", rb_fix_new(c));
rb_hash_aset(clients, rb_fix_new(c), Server);
if(rb_respond_to(Server, rb_intern("post_init"))){
rb_funcall(Server, rb_intern("post_init"), 0);
}
}
if(dispatch() != 0) asteroid_s_stop(Asteroid);
// You must call them to give a chance for ruby to handle system events.
// CHECK_INTS;
}
rb_iterate(rb_each, clients, close_socket_proc, Qnil);
rb_funcall(clients, rb_intern("clear"), 0);
close(s);
close(epoll_fd);
return Qnil;
}
static void digipass_to_rbhash(TDigipassBlob* dpdata, VALUE hash) {
char buffer[256];
memset(buffer, 0, sizeof(buffer));
strncpy(buffer, dpdata->Serial, 10);
rb_hash_aset(hash, rb_str_new2("serial"), rb_str_new2(buffer));
memset(buffer, 0, sizeof(buffer));
strncpy(buffer, dpdata->AppName, 12);
rb_hash_aset(hash, rb_str_new2("app_name"), rb_str_new2(buffer));
memset(buffer, 0, sizeof(buffer));
strncpy(buffer, dpdata->Blob, 224);
rb_hash_aset(hash, rb_str_new2("blob"), rb_str_new2(buffer));
rb_hash_aset(hash, rb_str_new2("flags1"), rb_fix_new(dpdata->DPFlags[0]));
rb_hash_aset(hash, rb_str_new2("flags2"), rb_fix_new(dpdata->DPFlags[1]));
}
static VALUE group_translate_ranks(VALUE self, VALUE ary, VALUE rgrp2)
{
VALUE outary;
MPI_Group *grp1, *grp2;
int rv, i, len, *ranks1, *ranks2;
Data_Get_Struct(self, MPI_Group, grp1);
Data_Get_Struct(grp2, MPI_Group, grp2);
len = RARRAY(ary)->len;
ranks1 = ALLOCA_N(int, len);
ranks2 = ALLOCA_N(int, len);
for (i = 0; i < len; i++)
ranks1[i] = FIX2INT(rb_ary_entry(ary, i));
rv = MPI_Group_translate_ranks(*grp1, len, ranks1, *grp2, ranks2);
mpi_exception(rv);
outary = rb_ary_new2(len);
for (i = 0; i < len; i++) {
if (ranks2[i] == MPI_UNDEFINED)
rb_ary_store(outary, i, UNDEFINED);
else
rb_ary_store(outary, i, rb_fix_new(ranks2[i]));
}
return outary;
}
static VALUE status_tag(VALUE self)
{
MPI_Status *stat;
Data_Get_Struct(self, MPI_Status, stat);
return rb_fix_new(stat->MPI_TAG);
}
static VALUE status_source(VALUE self)
{
MPI_Status *stat;
Data_Get_Struct(self, MPI_Status, stat);
return rb_fix_new(stat->MPI_SOURCE);
}
VALUE php_value_to_integer(VALUE self) {
zval *zv = get_zval(self);
if (zv) {
convert_to_long(zv);
return rb_fix_new(Z_LVAL_P(zv));
}
return Qnil;
}
static VALUE group_size(VALUE self)
{
int rv, size;
MPI_Group *grp;
Data_Get_Struct(self, MPI_Group, grp);
rv = MPI_Group_size(*grp, &size);
mpi_exception(rv);
return rb_fix_new(size);
}
static VALUE group_rank(VALUE self)
{
int rv, rank;
MPI_Group *grp;
Data_Get_Struct(self, MPI_Group, grp);
rv = MPI_Group_rank(*grp, &rank);
mpi_exception(rv);
if (rank == MPI_UNDEFINED)
return UNDEFINED;
return rb_fix_new(rank);
}
VALUE rfpset_slurp_array(VALUE self, VALUE filename) {
gzFile in = gzopen(RSTRING_PTR(filename), "rb");
if(in == NULL) return rb_fix_new(-1);
VALUE array = rb_ary_new();
blob* next_blob = blob_make(512);
while((next_blob = blob_read(in, next_blob)) != NULL) {
rb_ary_push(array, rb_str_new(next_blob->data, next_blob->size));
}
gzclose(in);
free(next_blob);
return array;
}
VALUE rfpset_intersect_files(VALUE self, VALUE filenames) {
long file_count = RARRAY_LEN(filenames);
VALUE* values = RARRAY_PTR(filenames);
int ii;
if(file_count == 1) {
return rfpset_slurp_array(self, values[0]);
}
gzFile* files = malloc(sizeof(gzFile) * file_count);
// open all the files
for(ii = 0; ii < file_count; ++ii) {
const char* name = RSTRING_PTR(values[ii]);
gzFile file = gzopen(name, "rb");
if(file == NULL) break; // failure!
files[ii] = file;
}
// make sure they all opened
if(ii < file_count) {
// close them all
int jj;
for(jj = 0; jj < ii; ++jj) {
gzclose(files[jj]);
}
return rb_fix_new(-1);
}
VALUE array = blob_intersect_files(files, file_count);
// close the files
for(ii = 0; ii < file_count; ++ii) {
gzclose(files[ii]);
}
return array;
}
int dispatch(){
int i, s, len;
while(1){
TRAP_BEG;
s = asteroid_poll_wait(epoll_fd, events, EVENT_BUF_SIZE, 1);
TRAP_END;
if(s <= 0) break;
for(i = 0; i < s; ++i){
asteroid_poll_event_t event = events[i];
int fd = AST_POLL_EVENT_SOCK(&event);
VALUE Fd = rb_fix_new(fd);
VALUE Server = rb_hash_aref(clients, Fd);
if(AST_POLL_EVENT_CAN_READ(&event)){
VALUE Buf = rb_str_new("", 0);
char buf[1024];
while((len = read(fd, buf, 1023)) > 0){
buf[len] = '\0';
rb_str_concat(Buf, rb_str_new2(buf));
}
if(len == -1 && errno == EAGAIN){
if(rb_respond_to(Server, rb_intern("receive_data"))){
rb_funcall(Server, rb_intern("receive_data"), 1, Buf);
}
}else{
if(rb_respond_to(Server, rb_intern("unbind"))){
rb_funcall(Server, rb_intern("unbind"), 0);
}
asteroid_poll_remove(epoll_fd, &event, fd);
rb_hash_delete(clients, Fd);
close(fd);
}
}
}
}
return 0;
}
/* @overload crc16(buf)
* Calculate CRC16 checksum of a string
*
* @param buf [String] the string to be checksummed
* @return [Fixnum] the CRC16 value
*/
static VALUE mm_gps_CRC16(VALUE klass, VALUE str)
{
Check_Type(str, T_STRING);
return rb_fix_new(CRC16(RSTRING_PTR(str), RSTRING_LEN(str)));
}
