static unsigned char * handle_bind_next (fs_backend *be, fs_segment segment,
unsigned int length,
unsigned char *content)
{
unsigned char *reply;
if (segment > be->segments) {
fs_error(LOG_ERR, "invalid segment number: %d", segment);
return fsp_error_new(segment, "invalid segment number");
}
if (length != 8) {
fs_error(LOG_ERR, "bind_next(%d) wrong length %u", segment, length);
return fsp_error_new(segment, "wrong length");
}
unsigned int flags;
int count;
memcpy(&flags, content, sizeof (flags));
memcpy(&count, content + 4, sizeof (count));
fs_rid_vector **bindings;
bindings = fs_bind_next(be, segment, flags, count);
int k, cols = 0;
for (k = 0; k < 4; ++k) {
if (flags & 1 << k) cols++;
}
if (bindings == NULL) {
/* NULL => no match */
reply = message_new(FS_NO_MATCH, segment, 0);
cols = 0;
} else if (cols == 0) {
/* Zero columns => match with no binding */
reply = message_new(FS_BIND_LIST, segment, 0);
} else {
/* otherwise return bindings */
reply = message_new(FS_BIND_LIST, segment, bindings[0]->length * 8 * cols);
unsigned char *data = reply + FS_HEADER;
for (k= 0; k < cols; ++k) {
memcpy(data, bindings[k]->data, bindings[k]->length * 8);
data += bindings[k]->length * 8;
}
}
for (k = 0; k < cols; ++k) {
fs_rid_vector_free(bindings[k]);
}
free(bindings);
return reply;
}
void Libni_Sender::init_header() {
int pos = 0;
for(int i=0; i<4; i++) {
message[pos] = MAGIC[i];
pos += 1;
}
u16_t version = htons(PROTOCOL_VERSION);
for(int i=0; i<2; i++) {
message[pos] = ((char *)&version)[i];
pos += 1;
}
u16_t protocol_type = htons(1); //TODO: read or define 1 elsewhere - 1 means event based protocol
for(int i=0; i<2; i++) {
message[pos] = ((char *)&protocol_type)[i];
pos += 1;
}
for(int i=0; i<4; i++) {
message[pos] = random(256);
pos += 1;
}
//byte CLIENT_ID[4] = {0,0,0,1};
uint32_t client_id_network = htonl(client_id);
byte *client_id_ptr = (byte *)&client_id_network;
for(int i=0; i<4; i++) {
message[pos] = client_id_ptr[i];
pos += 1;
}
message_new(); // reset message size to header size
}
static unsigned char * fsp_handle_no_op (fs_segment segment,
unsigned int length,
unsigned char *content)
{
unsigned char *reply = message_new(FS_DONE_OK, segment, 0);
return reply;
}
static unsigned char * handle_get_data_size (fs_backend *be, fs_segment segment,
unsigned int length,
unsigned char *content)
{
if (segment > be->segments) {
fs_error(LOG_ERR, "invalid segment number: %d", segment);
return fsp_error_new(segment, "invalid segment number");
}
if (length > 0) {
fs_error(LOG_ERR, "get_data_size(%d) extraneous content", segment);
return fsp_error_new(segment, "extraneous content");
}
fs_data_size size = fs_get_data_size(be, segment);
fs_old_data_size old_size;
old_size.quads_s = size.quads_s;
old_size.quads_o = size.quads_o;
old_size.resources = size.resources;
old_size.models_s = size.models_s;
old_size.models_o = size.models_o;
unsigned char *reply = message_new(FS_SIZE, segment, sizeof(old_size));
memcpy(reply + FS_HEADER, &old_size, sizeof(old_size));
return reply;
}
u32 object_write(Worker *worker, u64 oid, u32 mtime, u64 offset,
u32 count, u8 *data, void *raw)
{
struct object_write_env env = {
.worker = worker,
.oid = oid,
.mtime = mtime,
.offset = offset,
.count = count,
.data = data
};
Transaction *trans = trans_new(storage_servers[0], NULL, message_new());
struct Rswrite *res;
assert(raw != NULL);
trans->out->raw = raw;
trans->out->tag = ALLOCTAG;
trans->out->id = TSWRITE;
set_tswrite(trans->out, mtime, offset, count, data, oid);
send_request_to_all(trans, (void (*)(void *)) object_write_cb, &env);
res = &trans->in->msg.rswrite;
return res->count;
}
static unsigned char * handle_get_quad_freq (fs_backend *be, fs_segment segment,
unsigned int length,
unsigned char *content)
{
if (segment > be->segments) {
fs_error(LOG_ERR, "invalid segment number: %d", segment);
return fsp_error_new(segment, "invalid segment number");
}
if (length != 8) {
fs_error(LOG_ERR, "get_quad_freq(%d) wrong length %u", segment, length);
return fsp_error_new(segment, "wrong length");
}
int index, count;
memcpy(&index, content, sizeof(int));
memcpy(&count, content + sizeof(int), sizeof(int));
const char *filename;
/* this branch has no frequency data */
filename = "";
int fd = open(filename, FS_O_NOATIME | O_RDONLY, 0);
unsigned char *reply = message_new(FS_QUAD_FREQ, segment, count * sizeof(fs_quad_freq));
//ssize_t bytes = read(fd, reply + FS_HEADER, count * sizeof(fs_quad_freq));
ssize_t bytes = 0;
unsigned int *l = (unsigned int *) (reply + 4);
*l = bytes;
close(fd);
return reply;
}
u64 object_reserve_oid(Worker *worker) {
assert(storage_server_count > 0);
/* is someone else in the process of requesting new oids? */
while (object_reserve_wait != NULL)
cond_wait(object_reserve_wait);
/* do we need to request a fresh batch of oids? */
if (object_reserve_remaining == 0) {
/* the first storage server is considered the master */
Transaction *trans = trans_new(storage_servers[0], NULL, message_new());
struct Rsreserve *res;
pthread_cond_t *wait;
trans->out->tag = ALLOCTAG;
trans->out->id = TSRESERVE;
wait = object_reserve_wait = cond_new();
send_request(trans);
object_reserve_wait = NULL;
cond_broadcast(wait);
res = &trans->in->msg.rsreserve;
object_reserve_next = res->firstoid;
object_reserve_remaining = res->count;
}
object_reserve_remaining--;
return object_reserve_next++;
}
static unsigned char * handle_new_models (fs_backend *be, fs_segment segment,
unsigned int length,
unsigned char *content)
{
if (segment > be->segments) {
fs_error(LOG_ERR, "invalid segment number: %d", segment);
return fsp_error_new(segment, "invalid segment number");
}
if (length < sizeof(fs_rid)) {
fs_error(LOG_ERR, "new_models(%d) missing model RIDs", segment);
return fsp_error_new(segment, "missing model RIDs");
}
fs_rid *models = (fs_rid *) content;
int invalid_count = 0;
for (int k= 0; k < (length / sizeof(fs_rid)); ++k) {
if (FS_IS_URI(models[k])) {
fs_backend_model_set_usage(be, segment, models[k], 0);
} else {
invalid_count++;
}
}
fs_mhash_flush(be->models);
if (invalid_count > 0) {
return fsp_error_new(segment, "one or more model RIDs is not a URI");
}
return message_new(FS_DONE_OK, segment, 0);
}
int sd_rtnl_message_new_route(sd_netlink *rtnl, sd_netlink_message **ret,
uint16_t nlmsg_type, int rtm_family,
unsigned char rtm_protocol) {
struct rtmsg *rtm;
int r;
assert_return(rtnl_message_type_is_route(nlmsg_type), -EINVAL);
assert_return((nlmsg_type == RTM_GETROUTE && rtm_family == AF_UNSPEC) ||
rtm_family == AF_INET || rtm_family == AF_INET6, -EINVAL);
assert_return(ret, -EINVAL);
r = message_new(rtnl, ret, nlmsg_type);
if (r < 0)
return r;
if (nlmsg_type == RTM_NEWROUTE)
(*ret)->hdr->nlmsg_flags |= NLM_F_CREATE | NLM_F_APPEND;
rtm = NLMSG_DATA((*ret)->hdr);
rtm->rtm_family = rtm_family;
rtm->rtm_scope = RT_SCOPE_UNIVERSE;
rtm->rtm_type = RTN_UNICAST;
rtm->rtm_table = RT_TABLE_MAIN;
rtm->rtm_protocol = rtm_protocol;
return 0;
}
static unsigned char * handle_commit_quad (fs_backend *be, fs_segment segment,
unsigned int length,
unsigned char *content)
{
if (segment > be->segments) {
fs_error(LOG_ERR, "invalid segment number: %d", segment);
return fsp_error_new(segment, "invalid segment number");
}
if (length != sizeof(int)) {
fs_error(LOG_ERR, "commit_quad(%d) missing flags", segment);
return fsp_error_new(segment, "missing flags");
}
int flags;
memcpy(&flags, content, sizeof (flags));
int ret = fs_quad_import_commit(be, segment, flags, 1);
if (ret) {
fs_error(LOG_ERR, "commit_quad(%d) failed", segment);
return fsp_error_new(segment, "quad commit failed");
}
return message_new(FS_DONE_OK, segment, 0);
}
int sd_rtnl_message_new_addr(sd_netlink *rtnl, sd_netlink_message **ret,
uint16_t nlmsg_type, int index,
int family) {
struct ifaddrmsg *ifa;
int r;
assert_return(rtnl_message_type_is_addr(nlmsg_type), -EINVAL);
assert_return((nlmsg_type == RTM_GETADDR && index == 0) ||
index > 0, -EINVAL);
assert_return((nlmsg_type == RTM_GETADDR && family == AF_UNSPEC) ||
family == AF_INET || family == AF_INET6, -EINVAL);
assert_return(ret, -EINVAL);
r = message_new(rtnl, ret, nlmsg_type);
if (r < 0)
return r;
if (nlmsg_type == RTM_GETADDR)
(*ret)->hdr->nlmsg_flags |= NLM_F_DUMP;
ifa = NLMSG_DATA((*ret)->hdr);
ifa->ifa_index = index;
ifa->ifa_family = family;
if (family == AF_INET)
ifa->ifa_prefixlen = 32;
else if (family == AF_INET6)
ifa->ifa_prefixlen = 128;
return 0;
}
static unsigned char * handle_resolve_attr (fs_backend *be, fs_segment segment,
unsigned int length,
unsigned char *content)
{
unsigned int count = length / sizeof(fs_rid);
if (segment > be->segments) {
fs_error(LOG_ERR, "invalid segment number: %d", segment);
return fsp_error_new(segment, "invalid segment number");
}
if (length < sizeof(fs_rid)) {
fs_error(LOG_ERR, "resolve_attr(%d) too short", segment);
return fsp_error_new(segment, "too short");
}
unsigned char *reply;
fs_rid_vector v;
fs_resource resources[count];
v.size = v.length = count;
v.data = (fs_rid *) content;
fs_resolve(be, segment, &v, resources);
unsigned int k, serial_length = 0;
for (k = 0; k < count; ++k) {
if (resources[k].lex) {
serial_length+= ((28 + strlen(resources[k].lex)) / 8);
} else {
serial_length+= 3;
}
}
reply = message_new(FS_RESOURCE_ATTR_LIST, segment, 8 * serial_length);
unsigned char *record = reply + FS_HEADER;
for (k = 0; k < count; ++k) {
unsigned int one_length;
if (resources[k].lex) {
one_length = ((28 + strlen(resources[k].lex)) / 8) * 8;
} else {
one_length = 24;
}
memcpy(record, &(resources[k].rid), sizeof (fs_rid));
memcpy(record + 8, &(resources[k].attr), sizeof (fs_rid));
memcpy(record + 16, &one_length, sizeof(one_length));
/* ASCII NUL is used to terminate strings on the wire */
if (resources[k].lex) {
strcpy((char *) record + 20, resources[k].lex);
} else {
*(record + 20) = '\0';
}
record += one_length;
}
return reply;
}
struct Message* encode_data(unsigned char pid, unsigned int size) {
log_fine("encoding data message %d %d %d", data, pid, size);
struct Message *m = message_new();
int header = (version << 24) + (data << 20) + (pid << 16) + size;
log_fine("encoded header: %d", header);
message_header(m, &header, 1);
return m;
}
unsigned char *fsp_error_new(fs_segment segment, const char *message)
{
size_t length = strlen(message) + 1;
unsigned char *err = message_new(FS_ERROR, segment, length);
memcpy(err + FS_HEADER, message, length);
return err;
}
int fsp_ver_fixup (fsp_link *link, int sock)
{
int err;
if (link->hash_type != FS_HASH_UNKNOWN) {
/* already know the type of hash we're using */
return 0;
}
unsigned char *out = message_new(FS_NO_OP, 0, 0);
err = write(sock, out, FS_HEADER + 0);
free(out);
if (err != FS_HEADER) {
fs_error(LOG_ERR, "unable to write to socket, %s", strerror(errno));
return -1;
}
unsigned char header[FS_HEADER];
err = recv(sock, header, FS_HEADER, MSG_WAITALL);
if (err < 0) {
fs_error(LOG_ERR, "recv header from socket failed, %s", strerror(errno));
return -1;
} else if (err == 0) {
return -1;
}
switch (header[2]) {
case 0x80:
link->hash_type = FS_HASH_MD5;
break;
case 0x81:
link->hash_type = FS_HASH_CRC64;
break;
case 0x82:
link->hash_type = FS_HASH_UMAC;
break;
default:
fs_error(LOG_ERR, "incompatible protocol");
return -1;
}
if (fsp_vermagic[2] == header[2]) {
/* guessed right first time, clean up */
unsigned int * const l = (unsigned int *) (header + 4);
char *buffer = calloc(1, *l);
recv(sock, buffer, *l, MSG_WAITALL);
free(buffer);
return 0;
} else {
fsp_vermagic[2] = header[2];
return 1;
}
}
static unsigned char * handle_unlock (fs_backend *be,
fs_segment segment,
unsigned int length,
unsigned char *content)
{
/* this is currently a NOOP, the COMMIT phase closes the lock implicitly, so
* theres no need to here */
return message_new(FS_DONE_OK, 0, 0);
}
/*
0x9000 MESSAGE (Bi-directional)
When sent from a client, will take that parameter, and pass it (along with the msg ID and
name) to the other clients, depending on their FOLLOW or UPDATE modes.
When sent from server to client, indicates that a message was received at the server, and
relayed to the client. Will also be accompanied by a MSG_ID and a NAME command before the
MESSAGE.
The MSG_ID can be used to update the ID of the latest message.
If the server is sending multiple messages from the same Name, it will only send Name once,
followed by the multiple messages. Only when messages are being sent from different names,
will those entries also be included.
*/
void cmdMessage(void *base, risp_length_t length, risp_data_t *data)
{
session_t *session = (session_t *) base;
// At every opportunity, we need to make sure that our data is legit.
assert(base != NULL);
assert(length >= 0);
assert(data != NULL);
// the protocol allows a message up to 64k chars in length. If it is greater than that, then we ignore it.
assert(length < 65536);
if (length < 65536) {
if (checkAuth(session) == true) {
/// need to relay the message to each client that is connected and in follow mode (other than this
/// one, unless it has echo enabled).
maindata_t *maindata = session->maindata;
assert(maindata);
// store the message in our messages store.
long long msgID = message_new(maindata, session->data.name, length, (char *) data);
assert(msgID > 0);
// when we added the message to the messages array, it copied the message and ensured it was null
// termined, so we can now get a pointer to it.
unsigned char *message = message_get_msg(maindata, msgID);
unsigned char *name = message_get_name(maindata, msgID);
printf("Session[%d]: Received Message '%s'\n", session->id, message);
// Response for sessions in NOFOLLOW mode.
// CMD_LATEST_MSG_ID(integer)
//
// Response for sessions in FOLLOW mode.
// CMD_MSG_ID(integer)
// CMD_NAME(string) - If name is supplied.
// CMD_MESSAGE(string)
// the sessions are referenced in an array.
assert(maindata);
assert(maindata->sessions.list);
assert(maindata->sessions.max > 0);
for (int i=0; i<maindata->sessions.max; i++) {
session_t *relay = maindata->sessions.list[i];
if (relay) {
if (relay->session_ptr) {
relay_msg(relay, msgID, name, length, data);
}
}
}
}
}
}
void MyWarningHandler(String errmsg)
{
message_t reply = message_new(next_serial++);
message_add_packet(reply);
fprintf(stderr,"Warning: %s\n",errmsg);
fflush(stderr);
message_put_dblword(reply,WARNING_REPLY);
message_write_string(reply,errmsg,string_tag);
message_send(client_socket,reply);
message_free(reply);
}
static unsigned char * handle_choose_segment (fs_backend *be, fs_segment segment,
unsigned int length,
unsigned char *content)
{
if (fs_backend_open_files(be, segment, O_RDWR | O_CREAT, FS_OPEN_ALL)) {
fs_error(LOG_ERR, "failed to open files for segment %d", segment);
return fsp_error_new(segment, "cannot open indexes");
}
return message_new(FS_DONE_OK, 0, 0);
}
static unsigned char * handle_price (fs_backend *be, fs_segment segment,
unsigned int length,
unsigned char *content)
{
if (segment > be->segments) {
fs_error(LOG_ERR, "invalid segment number: %d", segment);
return fsp_error_new(segment, "invalid segment number");
}
if (length < 24) {
fs_error(LOG_ERR, "price(%d) much too short", segment);
return fsp_error_new(segment, "much too short");
}
unsigned char *reply;
unsigned long long int rows = 0;
fs_rid_vector models, subjects, predicates, objects;
unsigned int flags, value;
memcpy(&flags, content, sizeof (flags));
memcpy(&value, content + 4, sizeof (models.length));
models.size = models.length = value / 8;
memcpy(&value, content + 8, sizeof (subjects.length));
subjects.size = subjects.length = value / 8;
memcpy(&value, content + 12, sizeof (predicates.length));
predicates.size = predicates.length = value / 8;
memcpy(&value, content + 16, sizeof (objects.length));
objects.size = objects.length = value / 8;
content += 24;
if (length < (models.size + subjects.size + predicates.size + objects.size) * 8 + 24) {
fs_error(LOG_ERR, "price(%d) too short", segment);
return fsp_error_new(segment, "too short");
}
models.data = (fs_rid *) content;
content += models.length * 8;
subjects.data = (fs_rid *) content;
content += subjects.length * 8;
predicates.data = (fs_rid *) content;
content += predicates.length * 8;
objects.data = (fs_rid *) content;
rows = fs_bind_price(be, segment, flags, &models, &subjects, &predicates, &objects);
reply = message_new(FS_ESTIMATED_ROWS, segment, 8);
memcpy(reply + FS_HEADER, &rows, sizeof(rows));
return reply;
}
int main(void){
chat_t * chat = chat_new("First Chat");
printf("1st task(Chat name is) : %s\n", get_chat_name(chat));//1st task
user_t * firstUser = user_new("Dima", "Diachenko", 18);
chat_add_user(chat, firstUser);
user_t * secondUser = user_new("Gleb", "Davidov", 18);
chat_add_user(chat, secondUser); //6th task
list_t * users_list = list_new();
users_list = chat_get_list_of_users(chat);
printf("4th task (and 6th task)(Users in list) : %i\n", list_getSize(users_list));//4th task
printf("2d task : List of users:\n"); // 2d task
for(int i = 0; i < list_getSize(users_list); i++){
user_t * tmp = (user_t*) list_get(users_list, i);
printf("%s %s %i\n", user_get_name(tmp), user_get_surname(tmp), user_get_age(tmp));
}
printf("7th task : %s - this user was removed!\n", user_get_surname(chat_remove_user_by_surname(chat, "Davidov")));//7th task
users_list = chat_get_list_of_users(chat);
printf("2d task : List of users:\n"); // 2d task
for(int i = 0; i < list_getSize(users_list); i++){
user_t * tmp = (user_t*) list_get(users_list, i);
printf("%s %s %i\n", user_get_name(tmp), user_get_surname(tmp), user_get_age(tmp));
}
message_t * msg1 = message_new("Hello!", firstUser);
chat_add_message(chat, msg1);//8th task
printf("8th task: added message to chat:\n%s:\t%s\n", user_get_surname(get_owner(msg1)), get_message_text(msg1));
list_t * msgs_list = list_new();
msgs_list = get_list_of_messages_of_one_user(chat, firstUser);//5th task
printf("5th task : Messages of user %s\n", user_get_surname(firstUser));
for(int i = 0; i < list_getSize(msgs_list); i++){
message_t * tmpmsg = list_get(msgs_list, i);
printf("%s\n", get_message_text(tmpmsg));
}
msgs_list = get_last_messages(chat, 1);
printf("3d task : List of last messages(1):\n");
for(int i = 0; i < list_getSize(msgs_list); i++){
message_t * tmpmsg = list_get(msgs_list, i);
printf("%s\n", get_message_text(tmpmsg));
}
return 0;
}
void object_delete(Worker *worker, u64 oid) {
struct object_delete_env env = {
.worker = worker,
.oid = oid
};
Transaction *trans = trans_new(storage_servers[0], NULL, message_new());
trans->out->tag = ALLOCTAG;
trans->out->id = TSDELETE;
set_tsdelete(trans->out, oid);
send_request_to_all(trans, (void (*)(void *)) object_delete_cb, &env);
}
void object_wstat(Worker *worker, u64 oid, struct p9stat *info) {
struct object_wstat_env env = {
.worker = worker,
.oid = oid,
.info = info
};
Transaction *trans = trans_new(storage_servers[0], NULL, message_new());
trans->out->tag = ALLOCTAG;
trans->out->id = TSWSTAT;
set_tswstat(trans->out, oid, info);
send_request_to_all(trans, (void (*)(void *)) object_wstat_cb, &env);
}
void MyErrorHandler(String errmsg)
{
message_t reply = message_new(next_serial++);
message_add_packet(reply);
fprintf(stderr,"Error: %s\n",errmsg);
fflush(stderr);
message_put_dblword(reply,ERROR_REPLY);
message_write_string(reply,errmsg,string_tag);
message_send(client_socket,reply);
message_free(reply);
longjmp(env,1);
exit(-1);
}
static void
my_message_callback(struct mosquitto *mosq, void *userdata,
const struct mosquitto_message *message)
{
if (message->payloadlen)
{
llog(LOG_INFO, "Received message %s : %s\n", message->topic,
message->payload);
Subscription *subscription = subscription_get(&SUBSCRIPTIONS,
message->topic);
if (subscription)
{
llog(LOG_INFO, "Notify %d lws clients for topic %s\n",
subscription->count_subscribed, message->topic);
Message msg;
message_new(&msg, PUBLISH, message->topic, message->payload);
message_serialize_response(&msg);
// create libwebsockets message from MQTT payload
unsigned char buf[LWS_SEND_BUFFER_PRE_PADDING + msg.size
+ LWS_SEND_BUFFER_POST_PADDING];
unsigned char *lws_message = &buf[LWS_SEND_BUFFER_PRE_PADDING];
int lws_message_length = sprintf((char* )lws_message, "%s",
msg.serialized);
// dispatch message to all subscribers
for (int i = 0; i < subscription->count_subscribed; i++)
{
struct libwebsocket *wsi = subscription->subscribers[i];
int bytes_written = libwebsocket_write(wsi, lws_message,
lws_message_length, LWS_WRITE_TEXT);
if (bytes_written < lws_message_length)
{
llog(LOG_ERR,
"ERROR only %d bytes written (message length is %d)\n",
bytes_written, lws_message_length);
}
}
message_free(&msg);
}
else
llog(LOG_ERR, "No lws clients are subscribed to topic %s\n",
message->topic);
}
else
printf("%s (null)\n", message->topic);
}
int rtnl_message_new_synthetic_error(int error, uint32_t serial, sd_rtnl_message **ret) {
struct nlmsgerr *err;
int r;
assert(error <= 0);
r = message_new(NULL, ret, NLMSG_ERROR);
if (r < 0)
return r;
(*ret)->hdr->nlmsg_seq = serial;
err = NLMSG_DATA((*ret)->hdr);
err->error = error;
return 0;
}
static unsigned char * handle_commit_resource (fs_backend *be, fs_segment segment,
unsigned int length,
unsigned char *content)
{
if (segment > be->segments) {
fs_error(LOG_ERR, "invalid segment number: %d", segment);
return fsp_error_new(segment, "invalid segment number");
}
if (length > 0) {
fs_error(LOG_ERR, "commit_resource(%d) extraneous content", segment);
return fsp_error_new(segment, "extraneous content");
}
fs_res_import_commit(be, segment, 1);
return message_new(FS_DONE_OK, segment, 0);
}
static unsigned char * handle_delete_quads (fs_backend *be, fs_segment segment,
unsigned int length,
unsigned char *content)
{
if (segment > be->segments) {
fs_error(LOG_ERR, "invalid segment number: %d", segment);
return fsp_error_new(segment, "invalid segment number");
}
if (length < 32) {
fs_error(LOG_ERR, "delete_quads(%d) much too short", segment);
return fsp_error_new(segment, "much too short");
}
fs_rid_vector models, subjects, predicates, objects;
models.size = models.length = length / 32;
subjects.size = subjects.length = length / 32;
predicates.size = predicates.length = length / 32;
objects.size = objects.length = length / 32;
if (length < (models.size + subjects.size + predicates.size + objects.size) * 8) {
fs_error(LOG_ERR, "delete_quads(%d) too short (%d < %d)", segment, length,
(models.size + subjects.size + predicates.size + objects.size) * 8);
return fsp_error_new(segment, "too short");
}
models.data = (fs_rid *) content;
content += models.length * 8;
subjects.data = (fs_rid *) content;
content += subjects.length * 8;
predicates.data = (fs_rid *) content;
content += predicates.length * 8;
objects.data = (fs_rid *) content;
fs_rid_vector *args[4] = { &models, &subjects, &predicates, &objects };
fs_delete_quads(be, args);
/* FIXME, should check return value */
return message_new(FS_DONE_OK, 0, 0);
}
message_t * message_new_text(char *body){
message_t *msg = message_new(CHARC_MSG_TEXT);
int msg_size = (int)strlen(body);
// Set the body of the message
message_set_body(msg, body, msg_size + 1);
if(msg_size > CHARCOAL_MSG_BODY_SIZE){
msg->total_chunks = msg_size / CHARCOAL_MSG_BODY_SIZE + (1 * msg_size % CHARCOAL_MSG_BODY_SIZE);
msg->chuncked = 1;
} else {
msg->chunk_seq = 0;
msg->total_chunks = 1;
}
return msg;
}
static unsigned char * handle_get_size_reverse (fs_backend *be, fs_segment segment,
unsigned int length,
unsigned char *content)
{
if (segment > be->segments) {
fs_error(LOG_ERR, "invalid segment number: %d", segment);
return fsp_error_new(segment, "invalid segment number");
}
if (length > 0) {
fs_error(LOG_ERR, "get_data_size(%d) extraneous content", segment);
return fsp_error_new(segment, "extraneous content");
}
fs_data_size size = fs_get_data_size(be, segment);
unsigned char *reply = message_new(FS_SIZE_REVERSE, segment, sizeof(size.quads_sr));
memcpy(reply + FS_HEADER, &size.quads_sr, sizeof(size.quads_sr));
return reply;
}
