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); }