static int dir_close(struct mwDirectory *dir) {
struct mwServiceDirectory *srvc;
struct mwChannel *chan;
struct mwPutBuffer *b;
struct mwOpaque o;
int ret;
g_return_val_if_fail(dir != NULL, -1);
srvc = dir->service;
g_return_val_if_fail(srvc != NULL, -1);
chan = srvc->channel;
g_return_val_if_fail(chan != NULL, -1);
b = mwPutBuffer_new();
guint32_put(b, next_request_id(dir->service));
guint32_put(b, dir->id);
mwPutBuffer_finalize(&o, b);
ret = mwChannel_send(chan, action_close, &o);
mwOpaque_clear(&o);
return ret;
}
static int send_attrib_list(struct mwServiceAware *srvc) {
struct mwPutBuffer *b;
struct mwOpaque o;
int tmp;
GList *l;
g_return_val_if_fail(srvc != NULL, -1);
g_return_val_if_fail(srvc->channel != NULL, 0);
l = map_collect_keys(srvc->attribs);
tmp = g_list_length(l);
b = mwPutBuffer_new();
guint32_put(b, 0x00);
guint32_put(b, tmp);
for(; l; l = g_list_delete_link(l, l)) {
guint32_put(b, GPOINTER_TO_UINT(l->data));
}
mwPutBuffer_finalize(&o, b);
tmp = mwChannel_send(srvc->channel, msg_OPT_WATCH, &o);
mwOpaque_clear(&o);
return tmp;
}
int mwConference_invite(struct mwConference *conf,
struct mwIdBlock *who,
const char *text) {
struct mwPutBuffer *b;
struct mwOpaque o;
int ret;
g_return_val_if_fail(conf != NULL, -1);
g_return_val_if_fail(conf->channel != NULL, -1);
g_return_val_if_fail(who != NULL, -1);
b = mwPutBuffer_new();
mwIdBlock_put(b, who);
guint16_put(b, 0x00);
guint32_put(b, 0x00);
mwString_put(b, text);
mwString_put(b, who->user);
mwPutBuffer_finalize(&o, b);
ret = mwChannel_sendEncrypted(conf->channel, msg_INVITE, &o, FALSE);
mwOpaque_clear(&o);
return ret;
}
int mwDirectory_search(struct mwDirectory *dir, const char *query) {
struct mwServiceDirectory *srvc;
struct mwChannel *chan;
struct mwPutBuffer *b;
struct mwOpaque o;
int ret;
g_return_val_if_fail(dir != NULL, -1);
g_return_val_if_fail(MW_DIRECTORY_IS_OPEN(dir), -1);
g_return_val_if_fail(query != NULL, -1);
g_return_val_if_fail(*query != '\0', -1);
srvc = dir->service;
g_return_val_if_fail(srvc != NULL, -1);
chan = srvc->channel;
g_return_val_if_fail(chan != NULL, -1);
b = mwPutBuffer_new();
guint32_put(b, map_request(dir));
guint32_put(b, dir->id);
guint16_put(b, 0x0061); /* some magic? */
guint32_put(b, 0x00000008); /* seek results */
mwString_put(b, query);
mwPutBuffer_finalize(&o, b);
ret = mwChannel_send(chan, action_search, &o);
mwOpaque_clear(&o);
return ret;
}
static int recv_SECTION_PEER_SET_ATTR(struct mwPlace *place,
struct mwGetBuffer *b) {
struct mwServicePlace *srvc;
int ret = 0;
guint32 id, attr;
struct mwOpaque o = {0,0};
struct place_member *pm;
srvc = place->service;
guint32_get(b, &id);
mwGetBuffer_advance(b, 4);
mwOpaque_get(b, &o);
mwGetBuffer_advance(b, 4);
guint32_get(b, &attr);
pm = GET_MEMBER(place, id);
g_return_val_if_fail(pm != NULL, -1);
if(srvc->handler && srvc->handler->peerSetAttribute)
srvc->handler->peerSetAttribute(place, &pm->idb, attr, &o);
mwOpaque_clear(&o);
return ret;
}
static void enc_offer_put(struct mwPutBuffer *b, struct mwEncryptOffer *enc) {
guint16_put(b, enc->mode);
if(enc->items) {
guint32 count;
struct mwPutBuffer *p;
struct mwOpaque o;
GList *list;
/* write the count, items, extra, and flag into a tmp buffer,
render that buffer into an opaque, and write it into b */
count = g_list_length(enc->items);
p = mwPutBuffer_new();
guint32_put(p, count);
for(list = enc->items; list; list = list->next) {
mwEncryptItem_put(p, list->data);
}
guint16_put(p, enc->extra);
gboolean_put(p, enc->flag);
mwPutBuffer_finalize(&o, p);
mwOpaque_put(b, &o);
mwOpaque_clear(&o);
}
}
static int dir_open(struct mwDirectory *dir) {
struct mwServiceDirectory *srvc;
struct mwChannel *chan;
struct mwPutBuffer *b;
struct mwOpaque o;
int ret;
g_return_val_if_fail(dir != NULL, -1);
srvc = dir->service;
g_return_val_if_fail(srvc != NULL, -1);
chan = srvc->channel;
g_return_val_if_fail(chan != NULL, -1);
b = mwPutBuffer_new();
guint32_put(b, map_request(dir));
/* unsure about these three bytes */
gboolean_put(b, FALSE);
guint16_put(b, 0x0000);
guint32_put(b, dir->book->id);
mwString_put(b, dir->book->name);
mwPutBuffer_finalize(&o, b);
ret = mwChannel_send(chan, action_open, &o);
mwOpaque_clear(&o);
return ret;
}
/** compose authentication information into an opaque based on the
password, encrypted via RC2/40 */
static void compose_auth_rc2_40(struct mwOpaque *auth, const char *pass) {
guchar iv[8], key[5];
struct mwOpaque a, b, z;
struct mwPutBuffer *p;
/* get an IV and a random five-byte key */
mwIV_init(iv);
mwKeyRandom(key, 5);
/* the opaque with the key */
a.len = 5;
a.data = key;
/* the opaque to receive the encrypted pass */
b.len = 0;
b.data = NULL;
/* the plain-text pass dressed up as an opaque */
z.len = strlen(pass);
z.data = (guchar *) pass;
/* the opaque with the encrypted pass */
mwEncrypt(a.data, a.len, iv, &z, &b);
/* an opaque containing the other two opaques */
p = mwPutBuffer_new();
mwOpaque_put(p, &a);
mwOpaque_put(p, &b);
mwPutBuffer_finalize(auth, p);
/* this is the only one to clear, as the other uses a static buffer */
mwOpaque_clear(&b);
}
static int send_JOIN_PLACE(struct mwPlace *place) {
struct mwOpaque o = {0, 0};
struct mwPutBuffer *b;
int ret;
b = mwPutBuffer_new();
gboolean_put(b, FALSE);
guint16_put(b, 0x01);
guint16_put(b, 0x02); /* 0x01 */
guint16_put(b, 0x01); /* 0x00 */
mwPutBuffer_finalize(&o, b);
ret = mwChannel_send(place->channel, msg_out_JOIN_PLACE, &o);
mwOpaque_clear(&o);
if(ret) {
place_state(place, mwPlace_ERROR);
} else {
place_state(place, mwPlace_JOINING);
}
return ret;
}
static void channel_free(struct mwChannel *chan) {
struct mwSession *s;
struct mwMessage *msg;
GSList *l;
/* maybe no warning in the future */
g_return_if_fail(chan != NULL);
s = chan->session;
mwLoginInfo_clear(&chan->user);
mwOpaque_clear(&chan->addtl_create);
mwOpaque_clear(&chan->addtl_accept);
if(chan->supported) {
g_hash_table_destroy(chan->supported);
chan->supported = NULL;
}
if(chan->stats) {
g_hash_table_destroy(chan->stats);
chan->stats = NULL;
}
mwCipherInstance_free(chan->cipher);
/* clean up the outgoing queue */
for(l = chan->outgoing_queue; l; l = l->next) {
msg = (struct mwMessage *) l->data;
l->data = NULL;
mwMessage_free(msg);
}
g_slist_free(chan->outgoing_queue);
/* clean up the incoming queue */
for(l = chan->incoming_queue; l; l = l->next) {
msg = (struct mwMessage *) l->data;
l->data = NULL;
mwMessage_free(msg);
}
g_slist_free(chan->incoming_queue);
g_free(chan);
}
int mwPlace_sendText(struct mwPlace *place, const char *msg) {
struct mwOpaque o = {0,0};
struct mwPutBuffer *b;
int ret;
b = mwPutBuffer_new();
guint32_put(b, 0x01); /* probably a message type */
mwString_put(b, msg);
mwPutBuffer_finalize(&o, b);
b = mwPutBuffer_new();
guint32_put(b, place->section);
mwOpaque_put(b, &o);
mwOpaque_clear(&o);
mwPutBuffer_finalize(&o, b);
ret = mwChannel_send(place->channel, msg_out_MESSAGE, &o);
mwOpaque_clear(&o);
return ret;
}
int mwPlace_unsetAttribute(struct mwPlace *place, guint32 attrib) {
struct mwOpaque o = {0,0};
struct mwPutBuffer *b;
int ret;
b = mwPutBuffer_new();
guint32_put(b, place->our_id);
guint32_put(b, attrib);
ret = mwChannel_send(place->channel, msg_out_SET_ATTR, &o);
mwOpaque_clear(&o);
return ret;
}
static int send_rem(struct mwChannel *chan, GList *id_list) {
struct mwPutBuffer *b = mwPutBuffer_new();
struct mwOpaque o;
int ret;
g_return_val_if_fail(chan != NULL, 0);
compose_list(b, id_list);
mwPutBuffer_finalize(&o, b);
ret = mwChannel_send(chan, msg_AWARE_REMOVE, &o);
mwOpaque_clear(&o);
return ret;
}
static int send_SECTION_LIST(struct mwPlace *place, guint32 section) {
int ret = 0;
struct mwOpaque o = {0, 0};
struct mwPutBuffer *b;
b = mwPutBuffer_new();
guint16_put(b, msg_out_SECTION_LIST);
guint32_put(b, section);
gboolean_put(b, FALSE);
guint32_put(b, ++place->requests);
mwPutBuffer_finalize(&o, b);
ret = mwChannel_send(place->channel, msg_out_SECTION, &o);
mwOpaque_clear(&o);
return ret;
}
int mwConference_sendText(struct mwConference *conf, const char *text) {
struct mwPutBuffer *b;
struct mwOpaque o;
int ret;
g_return_val_if_fail(conf != NULL, -1);
g_return_val_if_fail(conf->channel != NULL, -1);
b = mwPutBuffer_new();
guint32_put(b, 0x01);
mwString_put(b, text);
mwPutBuffer_finalize(&o, b);
ret = mwChannel_sendEncrypted(conf->channel, msg_MESSAGE, &o, FALSE);
mwOpaque_clear(&o);
return ret;
}
static void request_get(struct mwGetBuffer *b, struct mwStorageReq *req) {
guint32 id, count, junk;
if(mwGetBuffer_error(b)) return;
guint32_get(b, &id);
guint32_get(b, &req->result_code);
if(req->action == action_loaded) {
guint32_get(b, &count);
if(count > 0) {
guint32_get(b, &junk);
guint32_get(b, &req->item->key);
mwOpaque_clear(&req->item->data);
mwOpaque_get(b, &req->item->data);
}
}
}
int mwPlace_legacyInvite(struct mwPlace *place,
struct mwIdBlock *idb,
const char *message) {
struct mwOpaque o = {0,0};
struct mwPutBuffer *b;
int ret;
b = mwPutBuffer_new();
mwIdBlock_put(b, idb);
mwString_put(b, idb->user);
mwString_put(b, idb->user);
mwString_put(b, message);
gboolean_put(b, FALSE);
mwPutBuffer_finalize(&o, b);
ret = mwChannel_send(place->channel, msg_out_OLD_INVITE, &o);
mwOpaque_clear(&o);
return ret;
}
int mwServiceDirectory_refreshAddressBooks(struct mwServiceDirectory *srvc) {
struct mwChannel *chan;
struct mwPutBuffer *b;
struct mwOpaque o;
int ret;
g_return_val_if_fail(srvc != NULL, -1);
chan = srvc->channel;
g_return_val_if_fail(chan != NULL, -1);
b = mwPutBuffer_new();
guint32_put(b, next_request_id(srvc));
mwPutBuffer_finalize(&o, b);
ret = mwChannel_send(chan, action_list, &o);
mwOpaque_clear(&o);
return ret;
}
static void channel_recv(struct mwChannel *chan,
struct mwMsgChannelSend *msg) {
struct mwService *srvc;
srvc = mwChannel_getService(chan);
incr_stat(chan, mwChannelStat_MSG_RECV, 1);
if(msg->head.options & mwMessageOption_ENCRYPT) {
struct mwOpaque data = { 0, 0 };
mwOpaque_clone(&data, &msg->data);
mwCipherInstance_decrypt(chan->cipher, &data);
mwService_recv(srvc, chan, msg->type, &data);
mwOpaque_clear(&data);
} else {
mwService_recv(srvc, chan, msg->type, &msg->data);
}
}
int mwConference_sendTyping(struct mwConference *conf, gboolean typing) {
struct mwPutBuffer *b;
struct mwOpaque o;
int ret;
g_return_val_if_fail(conf != NULL, -1);
g_return_val_if_fail(conf->channel != NULL, -1);
g_return_val_if_fail(conf->state == mwConference_OPEN, -1);
b = mwPutBuffer_new();
guint32_put(b, 0x02);
guint32_put(b, 0x01);
guint32_put(b, !typing);
mwOpaque_put(b, NULL);
mwPutBuffer_finalize(&o, b);
ret = mwChannel_sendEncrypted(conf->channel, msg_MESSAGE, &o, FALSE);
mwOpaque_clear(&o);
return ret;
}
static int request_send(struct mwChannel *chan, struct mwStorageReq *req) {
struct mwPutBuffer *b;
struct mwOpaque o = { 0, 0 };
int ret;
b = mwPutBuffer_new();
request_put(b, req);
mwPutBuffer_finalize(&o, b);
ret = mwChannel_send(chan, req->action, &o);
mwOpaque_clear(&o);
if(! ret) {
if(req->action == action_save) {
req->action = action_saved;
} else if(req->action == action_load) {
req->action = action_loaded;
}
}
return ret;
}
static void HANDSHAKE_ACK_clear(struct mwMsgHandshakeAck *msg) {
mwOpaque_clear(&msg->data);
}
void mwStorageUnit_free(struct mwStorageUnit *item) {
if(! item) return;
mwOpaque_clear(&item->data);
g_free(item);
}
static void LOGIN_clear(struct mwMsgLogin *msg) {
g_free(msg->name); msg->name = NULL;
mwOpaque_clear(&msg->auth_data);
}
static void attrib_free(struct mwAwareAttribute *attrib) {
mwOpaque_clear(&attrib->data);
g_free(attrib);
}
static void mwMessageHead_clear(struct mwMessage *msg) {
mwOpaque_clear(&msg->attribs);
}
