/* main */
int main(void)
{
int ret;
Variable * res;
float f = 1.0;
double d = 1.0;
/* VT_FLOAT */
if((res = variable_new(VT_FLOAT, &f)) == NULL)
return 2;
if((ret = marshall_call(res, (MarshallCallback)_callf_float, 1, &res))
== 0)
ret = variable_get_as(res, VT_FLOAT, &f);
variable_delete(res);
if(ret != 0)
return 3;
if(f + 1.0 != (float)M_PI)
return 4;
/* VT_DOUBLE */
if((res = variable_new(VT_DOUBLE, &d)) == NULL)
return 5;
if((ret = marshall_call(res, (MarshallCallback)_callf_double, 1, &res))
== 0)
ret = variable_get_as(res, VT_DOUBLE, &d);
variable_delete(res);
if(ret != 0)
return 6;
if(d + 1.0 != M_PI)
return 7;
return 0;
}
static int _serialize_call(AppMessage * message, Buffer * buffer, Buffer * b)
{
int ret;
Variable * v;
size_t i;
if(_serialize_id(message, buffer, b) != 0)
return -1;
if((v = variable_new(VT_STRING, message->t.call.method)) == NULL)
return -1;
ret = (variable_serialize(v, b, 0) == 0
&& _serialize_append(buffer, b) == 0) ? 0 : -1;
variable_delete(v);
if(ret != 0)
return ret;
for(i = 0; i < message->t.call.args_cnt; i++)
{
if(message->t.call.args[i].direction == AMCD_OUT)
continue;
if(variable_serialize(message->t.call.args[i].arg, b, 1) != 0
|| _serialize_append(buffer, b) != 0)
break;
}
buffer_delete(b);
return (i == message->t.call.args_cnt) ? 0 : -1;
}
static AppMessage * _new_deserialize_id(AppMessage * message, char const * data,
const size_t size, size_t * pos)
{
int ret = 0;
size_t s = size;
Variable * v;
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
if((v = variable_new_deserialize_type(VT_UINT32, &s, &data[*pos]))
== NULL)
{
error_set_code(1, "%s", "Could not obtain the AppMessage ID");
appmessage_delete(message);
return NULL;
}
ret = variable_get_as(v, VT_UINT32, &message->id);
variable_delete(v);
if(ret != 0)
{
appmessage_delete(message);
return NULL;
}
*pos += s;
return message;
}
/* ssl_socket_queue */
static int _ssl_socket_queue(SSLSocket * sslsocket, Buffer * buffer)
{
uint32_t len;
char * p;
Variable * v;
Buffer * b = NULL;
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s(%d)\n", __func__, sslsocket->fd);
#endif
/* serialize the buffer */
v = variable_new(VT_BUFFER, buffer);
b = buffer_new(0, NULL);
if(v == NULL || b == NULL || variable_serialize(v, b, 0) != 0)
{
if(v != NULL)
variable_delete(v);
if(b != NULL)
buffer_delete(b);
return -1;
}
variable_delete(v);
len = buffer_get_size(b);
/* FIXME queue the serialized buffer directly as a message instead */
if((p = realloc(sslsocket->bufout, sslsocket->bufout_cnt + len))
== NULL)
{
buffer_delete(b);
return -1;
}
sslsocket->bufout = p;
memcpy(&p[sslsocket->bufout_cnt], buffer_get_data(b), len);
/* register the callback if necessary */
if(sslsocket->bufout_cnt == 0)
event_register_io_write(sslsocket->transport->helper->event,
sslsocket->fd,
(EventIOFunc)_ssl_socket_callback_write,
sslsocket);
sslsocket->bufout_cnt += len;
buffer_delete(b);
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s(%d) => %d\n", __func__, sslsocket->fd, 0);
#endif
return 0;
}
/* main */
int main(void)
{
int ret = 0;
size_t i;
const size_t count = 10;
Variable ** args;
int32_t i32;
Variable * res;
i32 = 0;
if((res = variable_new(VT_INT32, &i32)) == NULL)
return 2;
if((args = malloc(sizeof(*args) * count)) == NULL)
{
variable_delete(res);
return 2;
}
for(i = 0; i < count; i++)
{
i32 = i * 1111;
if((args[i] = variable_new(VT_INT32, &i32)) == NULL)
ret = 3;
}
for(i = 0; ret == 0 && i < count; i++)
{
i32 = i;
if(variable_set_from(args[0], VT_INT32, &i32) != 0)
ret = i + 4;
else if(marshall_call(res, (MarshallCallback)_calln, i + 1,
args) != 0)
ret = i + 4;
else if(variable_get_as(res, VT_INT32, &i32) != 0 || i32 != 0)
ret = i + 4;
}
for(i = 0; i < count; i++)
if(args[i] != NULL)
variable_delete(args[i]);
variable_delete(res);
free(args);
return ret;
}
static int _serialize_type(AppMessage * message, Buffer * buffer, Buffer * b)
{
int ret;
Variable * v;
if((v = variable_new(VT_UINT8, &message->type)) == NULL)
return -1;
ret = (variable_serialize(v, b, 0) == 0
&& _serialize_append(buffer, b) == 0) ? 0 : -1;
variable_delete(v);
return ret;
}
AppMessage * appmessage_new_deserialize(Buffer * buffer)
{
AppMessage * message;
char const * data = buffer_get_data(buffer);
size_t size = buffer_get_size(buffer);
size_t pos = 0;
size_t s;
Variable * v;
uint8_t u8;
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
if((message = object_new(sizeof(*message))) == NULL)
return NULL;
s = size;
if((v = variable_new_deserialize_type(VT_UINT8, &s, &data[pos]))
== NULL)
{
object_delete(message);
return NULL;
}
pos += s;
size -= s;
/* XXX may fail */
variable_get_as(v, VT_UINT8, &u8);
variable_delete(v);
switch((message->type = u8))
{
case AMT_ACKNOWLEDGEMENT:
return _new_deserialize_acknowledgement(message, data,
size, pos);
case AMT_CALL:
return _new_deserialize_call(message, data, size, pos);
default:
error_set_code(1, "%s%u", "Unknown message type ", u8);
/* XXX should not happen */
object_delete(message);
return NULL;
}
}
/* variable */
static int _variable(char const * progname)
{
int ret = 0;
Variable * variable;
const int samples[] = { 0, -1, 1, -127, -128, 126, 127 };
size_t i;
int32_t j;
int8_t i8;
size_t s;
void * p;
/* variable_new */
for(i = 0; i < sizeof(samples) / sizeof(*samples); i++)
{
printf("%s: Testing variable_new_deserialize_type(): %d\n",
progname, samples[i]);
i8 = samples[i];
s = sizeof(i8);
p = &i8;
if((variable = variable_new_deserialize_type(VT_INT8, &s, p))
== NULL)
{
error_print(progname);
ret += 1;
continue;
}
p = &j;
if(variable_get_as(variable, VT_INT32, p) != 0
|| j != samples[i])
{
error_print(progname);
ret += 1;
}
variable_delete(variable);
}
return ret;
}
static AppMessage * _socket_callback_message(SSLSocket * sslsocket)
{
AppMessage * message = NULL;
size_t size;
Variable * variable;
Buffer * buffer;
size = sslsocket->bufin_cnt;
/* deserialize the data as a buffer (containing a message) */
if((variable = variable_new_deserialize_type(VT_BUFFER, &size,
sslsocket->bufin)) == NULL)
/* XXX assumes not enough data was available */
return NULL;
sslsocket->bufin_cnt -= size;
memmove(sslsocket->bufin, &sslsocket->bufin[size],
sslsocket->bufin_cnt);
if((variable_get_as(variable, VT_BUFFER, &buffer)) == 0)
{
message = appmessage_new_deserialize(buffer);
buffer_delete(buffer);
}
variable_delete(variable);
return message;
}
static AppMessage * _new_deserialize_call(AppMessage * message,
char const * data, const size_t size, size_t pos)
{
size_t s;
Variable * v;
size_t i;
AppMessageCallArgument * p;
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s()\n", __func__);
#endif
if(_new_deserialize_id(message, data, size, &pos) == NULL)
return NULL;
message->t.call.method = NULL;
message->t.call.args = NULL;
message->t.call.args_cnt = 0;
s = size;
if((v = variable_new_deserialize_type(VT_STRING, &s, &data[pos]))
== NULL)
{
error_set_code(1, "%s", "Could not obtain the AppMessage call"
" method");
appmessage_delete(message);
return NULL;
}
pos += s;
/* XXX may fail */
variable_get_as(v, VT_STRING, &message->t.call.method);
variable_delete(v);
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s() \"%s\"\n", __func__,
message->t.call.method);
#endif
/* deserialize the arguments */
for(i = 0; pos < size; i++)
{
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s() %lu\n", __func__, i);
#endif
if((p = realloc(message->t.call.args, sizeof(*p) * (i + 1)))
== NULL)
{
appmessage_delete(message);
return NULL;
}
message->t.call.args = p;
s = size - pos;
if((v = variable_new_deserialize(&s, &data[pos])) == NULL)
{
appmessage_delete(message);
return NULL;
}
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s() %lu (%u)\n", __func__, i,
variable_get_type(v));
#endif
pos += s;
message->t.call.args[i].direction = AMCD_IN; /* XXX */
message->t.call.args[i].arg = v;
message->t.call.args_cnt = i + 1;
}
return message;
}
/* main */
int main(void)
{
int ret;
Variable * res;
double d = -1.0;
float f = -1.0;
int32_t r32 = -1;
int64_t r64 = -1;
char * s;
/* VT_INT32 */
if((res = variable_new(VT_INT32, &r32)) == NULL)
return 2;
if((ret = marshall_call(res, (MarshallCallback)_call0_int32, 0, NULL))
== 0)
ret = variable_get_as(res, VT_INT32, &r32);
variable_delete(res);
if(ret != 0)
return 3;
if(r32 != 0x41424344)
return 4;
/* VT_INT64 */
if((res = variable_new(VT_INT64, &r64)) == NULL)
return 5;
if((ret = marshall_call(res, (MarshallCallback)_call0_int64, 0, NULL))
== 0)
ret = variable_get_as(res, VT_INT64, &r64);
variable_delete(res);
if(ret != 0)
return 6;
if(r64 != 0x4142434445464748)
return 7;
/* VT_DOUBLE */
if((res = variable_new(VT_DOUBLE, &d)) == NULL)
return 8;
if((ret = marshall_call(res, (MarshallCallback)_call0_double, 0, NULL))
== 0)
ret = variable_get_as(res, VT_DOUBLE, &d);
variable_delete(res);
if(ret != 0)
return 9;
if(d != 1.234567e89)
return 10;
/* VT_FLOAT */
if((res = variable_new(VT_FLOAT, &f)) == NULL)
return 11;
if((ret = marshall_call(res, (MarshallCallback)_call0_float, 0, NULL))
== 0)
ret = variable_get_as(res, VT_FLOAT, &f);
variable_delete(res);
if(ret != 0)
return 12;
if(f != 1.234e5)
return 13;
/* VT_STRING */
if((res = variable_new(VT_STRING, "")) == NULL)
return 14;
if((ret = marshall_call(res, (MarshallCallback)_call0_string, 0, NULL))
== 0)
ret = variable_get_as(res, VT_STRING, &s);
variable_delete(res);
if(ret != 0)
return 15;
if(strcmp(s, "_call0_string") != 0)
return 16;
return 0;
}
