ScarabDatum *
scarab_new_atomic()
{
ScarabDatum *datum;
datum=(ScarabDatum*)scarab_mem_malloc(sizeof(ScarabDatum));
datum->type=SCARAB_NULL;
datum->ref_count = 1;
#ifdef THREAD_SAFE_SCARAB_DATUM
datum->mutex = (pthread_mutex_t *)scarab_mem_malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(datum->mutex, NULL);
#endif
return datum;
}
static int
ldo_session_connect(ScarabSession * session)
{
LDO_Session *s;
unsigned char expected_magic[sizeof(MAGIC)];
int i;
s = (LDO_Session*)scarab_mem_malloc(sizeof(LDO_Session));
s->refs = scarab_dict_new(11, scarab_dict_times2);
int magic_size = 0;
if ((magic_size = scarab_session_read(session, expected_magic, sizeof(MAGIC)))
!= sizeof(MAGIC)) {
fprintf(stderr,"Wrong size magic (is %d, should be %d)\n",
magic_size, sizeof(MAGIC));fflush(stderr);
return scarab_session_seterr(session, LDO_ERR_BAD_HEADER);
}
for (i = 0; i < sizeof(MAGIC); i++) {
if (expected_magic[i] != MAGIC[i]) {
fprintf(stderr,"Wrong magic (in pos %d: is: %x, should be %x)\n",
i, MAGIC[i], expected_magic[i]);
fflush(stderr);
return scarab_session_seterr(session, LDO_ERR_BAD_HEADER);
}
}
scarab_session_set_encoder(session, &scarab_ldo_encoder, s);
return 0;
}
ScarabDatum *scarab_init_lock(ScarabDatum *datum){
#ifdef THREAD_SAFE_SCARAB_DATUM
if(datum != NULL){
datum->mutex =
(pthread_mutex_t *)scarab_mem_malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(datum->mutex, NULL);
}
#endif
}
ScarabDatum *
scarab_new_molecular()
{
ScarabDatum *datum;
datum=(ScarabDatum*)scarab_mem_malloc(sizeof(ScarabDatum));
datum->type=SCARAB_NULL;
datum->ref_count = 1;
scarab_init_lock(datum);
return datum;
}
static int
ldo_session_accept(ScarabSession * session)
{
LDO_Session *s;
s = (LDO_Session*)scarab_mem_malloc(sizeof(LDO_Session));
s->refs = scarab_dict_new(11, scarab_dict_times2);
int write_size = scarab_session_write(session, (const void *)MAGIC, 7);
scarab_session_send(session);
if (write_size != 7 )
return scarab_session_seterr(session, LDO_ERR_BAD_HEADER);
scarab_session_set_encoder(session, &scarab_ldo_encoder, s);
return 0;
}
ScarabDatum *scarab_new_opaque(const char* opaque, int size)
{
ScarabDatum *d = scarab_new_atomic();
d->type = SCARAB_OPAQUE;
if (size < 0) {
size = 0;
}
d->data.opaque.size = size;
// Allocate space for size+1 bytes, and set the extra byte to NUL to protect against
// code that blindly assumes the data is NUL-terminated
d->data.opaque.data = (unsigned char *)scarab_mem_malloc((size + 1) * sizeof(unsigned char));
d->data.opaque.data[size] = '\0';
if (opaque != NULL) {
memcpy(d->data.opaque.data, opaque, size);
}
return d;
}
static ScarabDatum *
ldo_read(ScarabSession * session)
{
LDO_Session *s;
ScarabDatum *attrib;
ScarabDatum *value;
long long refid;
long long sign;
long long esign;
long long len;
unsigned char lastByte;
s = (LDO_Session *) session->encoder;
attrib = NULL;
refid = -1;
sign = 1;
esign = 1;
// PAJ really wish the guys who wrote this left some comments in here
// this read calls the stream head read which calls stream_read in
// stream_tcpip.c. This is the place where all the socket comm stuff
// happens. This is where recv is called....and will block
if (scarab_session_read(session, &lastByte, 1) != 1)
return NULL;
if (DEFINE_REFERENCE == lastByte)
{
refid = ldo_readber(session);
if (scarab_session_read(session, &lastByte, 1) != 1)
return NULL;
}
if (ATTRIBUTES == lastByte)
{
if (scarab_session_read(session, &lastByte, 1) != 1)
return NULL;
if (REFERENCE == lastByte)
{
refid = ldo_readber(session);
} else if (DEFINE_REFERENCE == lastByte)
{
refid = ldo_readber(session);
ldo_putref(session, refid, ldo_read_dict(session));
}
attrib = ldo_getref(session, refid);
if (scarab_session_read(session, &lastByte, 1) != 1)
return NULL;
}
switch (lastByte)
{
/*
* integer
*/
case INTEGER_N:
sign = -1;
case INTEGER_P:
value = scarab_new_integer(ldo_readber(session) * sign);
break;
/*
* float
*/
case FLOAT_NN:
esign = -1;
case FLOAT_NP:
sign = -1;
value = scarab_new_float(ldo_readfloat(session, sign, esign));
break;
case FLOAT_PN:
esign = -1;
case FLOAT_PP:
value = scarab_new_float(ldo_readfloat(session, sign, esign));
break;
case FLOAT_INF:
value = scarab_new_atomic();
value->type = SCARAB_FLOAT_INF;
break;
case FLOAT_OPAQUE:
//value = scarab_new_atomic();
//value->type = SCARAB_FLOAT_NAN;
// fprintf(stderr, "This is f***ing ridiculous!!!!!\n");
// fprintf(stderr, "Reading a god damn float nan\n");
len = ldo_readber(session);
value = scarab_new_atomic();
value->type = SCARAB_FLOAT_OPAQUE; //HAXXOR WARNING
value->data.opaque.size = len;
value->data.opaque.data = (unsigned char*)scarab_mem_malloc(
sizeof(char) * len);
scarab_session_read(session, value->data.opaque.data, len);
break;
/*
* opaque thingies
*/
case OPAQUE:
len = ldo_readber(session);
value = scarab_new_atomic();
value->type = SCARAB_OPAQUE;
value->data.opaque.size = len;
value->data.opaque.data = (unsigned char*)scarab_mem_malloc(
sizeof(char) * len);
scarab_session_read(session, value->data.opaque.data, len);
break;
/*
* compound
*/
case DICTIONARY:
value = ldo_read_dict(session);
break;
case LIST:
value = ldo_read_list(session);
break;
case REFERENCE:
value = ldo_getref(session, ldo_readber(session));
break;
case 0x0: // DDC August 10, 2005, changed from NULL
value = scarab_new_atomic();
value->type = SCARAB_NULL;
break;
default:
return NULL;
}
/*
* save the reference if there is one
*/
if (refid != -1)
ldo_putref(session, refid, value);
/*
* if attributes were used, add them to the value
*/
if (attrib != NULL)
value->attributes = attrib;
return value;
}
