static struct mwChannel *make_channel(struct mwServiceDirectory *srvc) {
struct mwSession *session;
struct mwChannelSet *cs;
struct mwChannel *chan;
session = mwService_getSession(MW_SERVICE(srvc));
cs = mwSession_getChannels(session);
chan = mwChannel_newOutgoing(cs);
mwChannel_setService(chan, MW_SERVICE(srvc));
mwChannel_setProtoType(chan, PROTOCOL_TYPE);
mwChannel_setProtoVer(chan, PROTOCOL_VER);
return mwChannel_create(chan)? NULL: chan;
}
static void stop(struct mwServiceFileTransfer *srvc) {
while(srvc->transfers) {
mwFileTransfer_free(srvc->transfers->data);
}
mwService_stopped(MW_SERVICE(srvc));
}
struct mwServiceDirectory *
mwServiceDirectory_new(struct mwSession *session,
struct mwDirectoryHandler *handler) {
struct mwServiceDirectory *srvc;
struct mwService *service;
g_return_val_if_fail(session != NULL, NULL);
g_return_val_if_fail(handler != NULL, NULL);
srvc = g_new0(struct mwServiceDirectory, 1);
service = MW_SERVICE(srvc);
mwService_init(service, session, SERVICE_DIRECTORY);
service->get_name = getName;
service->get_desc = getDesc;
service->start = (mwService_funcStart) start;
service->stop = (mwService_funcStop) stop;
service->clear = (mwService_funcClear) clear;
service->recv_create = (mwService_funcRecvCreate) recv_create;
service->recv_accept = (mwService_funcRecvAccept) recv_accept;
service->recv_destroy = (mwService_funcRecvDestroy) recv_destroy;
service->recv = (mwService_funcRecv) recv;
srvc->handler = handler;
srvc->requests = map_guint_new();
srvc->books = g_hash_table_new_full(g_str_hash, g_str_equal,
NULL, (GDestroyNotify) book_free);
return srvc;
}
void mwServiceStorage_save(struct mwServiceStorage *srvc,
struct mwStorageUnit *item,
mwStorageCallback cb,
gpointer data, GDestroyNotify d_free) {
/* - construct a request
- put request at end of pending
- if channel is open and connected
- compose the save message
- send message
- set request to sent
- else
- start service
*/
struct mwStorageReq *req;
req = request_new(srvc, item, cb, data, d_free);
req->action = action_save;
srvc->pending = g_list_append(srvc->pending, req);
if(MW_SERVICE_IS_STARTED(MW_SERVICE(srvc)))
request_send(srvc->channel, req);
}
struct mwServicePlace *
mwServicePlace_new(struct mwSession *session,
struct mwPlaceHandler *handler) {
struct mwServicePlace *srvc_place;
struct mwService *srvc;
g_return_val_if_fail(session != NULL, NULL);
g_return_val_if_fail(handler != NULL, NULL);
srvc_place = g_new0(struct mwServicePlace, 1);
srvc_place->handler = handler;
srvc = MW_SERVICE(srvc_place);
mwService_init(srvc, session, mwService_PLACE);
srvc->start = NULL;
srvc->stop = (mwService_funcStop) stop;
srvc->recv_create = NULL;
srvc->recv_accept = recv_channelAccept;
srvc->recv_destroy = recv_channelDestroy;
srvc->recv = recv;
srvc->clear = (mwService_funcClear) clear;
srvc->get_name = get_name;
srvc->get_desc = get_desc;
return srvc_place;
}
void mwSession_stop(struct mwSession *s, guint32 reason) {
GList *list, *l = NULL;
struct mwMsgChannelDestroy *msg;
g_return_if_fail(s != NULL);
if(mwSession_isStopped(s) || mwSession_isStopping(s)) {
g_debug("attempted to stop session that is already stopped/stopping");
return;
}
state(s, mwSession_STOPPING, GUINT_TO_POINTER(reason));
for(list = l = mwSession_getServices(s); l; l = l->next)
mwService_stop(MW_SERVICE(l->data));
g_list_free(list);
msg = (struct mwMsgChannelDestroy *)
mwMessage_new(mwMessage_CHANNEL_DESTROY);
msg->head.channel = MW_MASTER_CHANNEL_ID;
msg->reason = reason;
/* don't care if this fails, we're closing the connection anyway */
mwSession_send(s, MW_MESSAGE(msg));
mwMessage_free(MW_MESSAGE(msg));
session_buf_free(s);
/* close the connection */
io_close(s);
state(s, mwSession_STOPPED, GUINT_TO_POINTER(reason));
}
struct mwServiceFileTransfer *
mwServiceFileTransfer_new(struct mwSession *session,
struct mwFileTransferHandler *handler) {
struct mwServiceFileTransfer *srvc_ft;
struct mwService *srvc;
g_return_val_if_fail(session != NULL, NULL);
g_return_val_if_fail(handler != NULL, NULL);
srvc_ft = g_new0(struct mwServiceFileTransfer, 1);
srvc = MW_SERVICE(srvc_ft);
mwService_init(srvc, session, mwService_FILE_TRANSFER);
srvc->recv_create = (mwService_funcRecvCreate) recv_channelCreate;
srvc->recv_accept = (mwService_funcRecvAccept) recv_channelAccept;
srvc->recv_destroy = (mwService_funcRecvDestroy) recv_channelDestroy;
srvc->recv = recv;
srvc->clear = (mwService_funcClear) clear;
srvc->get_name = name;
srvc->get_desc = desc;
srvc->start = start;
srvc->stop = (mwService_funcStop) stop;
srvc_ft->handler = handler;
return srvc_ft;
}
static void recv_destroy(struct mwServiceDirectory *srvc,
struct mwChannel *chan,
struct mwMsgChannelDestroy *msg) {
srvc->channel = NULL;
mwService_stop(MW_SERVICE(srvc));
/** @todo session sense service */
}
static void ft_create_chan(struct mwFileTransfer *ft) {
struct mwSession *s;
struct mwChannelSet *cs;
struct mwChannel *chan;
struct mwLoginInfo *login;
struct mwPutBuffer *b;
/* we only should be calling this if there isn't a channel already
associated with the conversation */
g_return_if_fail(ft != NULL);
g_return_if_fail(mwFileTransfer_isNew(ft));
g_return_if_fail(ft->channel == NULL);
s = mwService_getSession(MW_SERVICE(ft->service));
cs = mwSession_getChannels(s);
chan = mwChannel_newOutgoing(cs);
mwChannel_setService(chan, MW_SERVICE(ft->service));
mwChannel_setProtoType(chan, PROTOCOL_TYPE);
mwChannel_setProtoVer(chan, PROTOCOL_VER);
/* offer all known ciphers */
mwChannel_populateSupportedCipherInstances(chan);
/* set the target */
login = mwChannel_getUser(chan);
login->user_id = g_strdup(ft->who.user);
login->community = g_strdup(ft->who.community);
/* compose the addtl create */
b = mwPutBuffer_new();
guint32_put(b, 0x00);
mwString_put(b, ft->filename);
mwString_put(b, ft->message);
guint32_put(b, ft->size);
guint32_put(b, 0x00);
guint16_put(b, 0x00);
mwPutBuffer_finalize(mwChannel_getAddtlCreate(chan), b);
ft->channel = mwChannel_create(chan)? NULL: chan;
if(ft->channel) {
mwChannel_setServiceData(ft->channel, ft, NULL);
}
}
int mwConference_open(struct mwConference *conf) {
struct mwSession *session;
struct mwChannel *chan;
struct mwPutBuffer *b;
int ret;
g_return_val_if_fail(conf != NULL, -1);
g_return_val_if_fail(conf->service != NULL, -1);
g_return_val_if_fail(conf->state == mwConference_NEW, -1);
g_return_val_if_fail(conf->channel == NULL, -1);
session = mwService_getSession(MW_SERVICE(conf->service));
g_return_val_if_fail(session != NULL, -1);
if(! conf->name) {
char *user = mwSession_getProperty(session, mwSession_AUTH_USER_ID);
conf->name = conf_generate_name(user? user: "******");
}
chan = mwChannel_newOutgoing(mwSession_getChannels(session));
mwChannel_setService(chan, MW_SERVICE(conf->service));
mwChannel_setProtoType(chan, PROTOCOL_TYPE);
mwChannel_setProtoVer(chan, PROTOCOL_VER);
#if 0
/* offer all known ciphers */
mwChannel_populateSupportedCipherInstances(chan);
#endif
b = mwPutBuffer_new();
mwString_put(b, conf->name);
mwString_put(b, conf->title);
guint32_put(b, 0x00);
mwPutBuffer_finalize(mwChannel_getAddtlCreate(chan), b);
ret = mwChannel_create(chan);
if(ret) {
conf_state(conf, mwConference_ERROR);
} else {
conf_state(conf, mwConference_PENDING);
conf->channel = chan;
}
return ret;
}
static void start(struct mwServiceDirectory *srvc) {
struct mwChannel *chan;
chan = make_channel(srvc);
if(chan) {
srvc->channel = chan;
} else {
mwService_stopped(MW_SERVICE(srvc));
return;
}
}
int mwPlace_open(struct mwPlace *p) {
struct mwSession *session;
struct mwChannelSet *cs;
struct mwChannel *chan;
struct mwPutBuffer *b;
int ret;
g_return_val_if_fail(p != NULL, -1);
g_return_val_if_fail(p->service != NULL, -1);
session = mwService_getSession(MW_SERVICE(p->service));
g_return_val_if_fail(session != NULL, -1);
cs = mwSession_getChannels(session);
g_return_val_if_fail(cs != NULL, -1);
chan = mwChannel_newOutgoing(cs);
mwChannel_setService(chan, MW_SERVICE(p->service));
mwChannel_setProtoType(chan, PROTOCOL_TYPE);
mwChannel_setProtoVer(chan, PROTOCOL_VER);
mwChannel_populateSupportedCipherInstances(chan);
b = mwPutBuffer_new();
mwString_put(b, mwPlace_getName(p));
mwString_put(b, mwPlace_getTitle(p));
guint32_put(b, 0x00); /* ? */
mwPutBuffer_finalize(mwChannel_getAddtlCreate(chan), b);
ret = mwChannel_create(chan);
if(ret) {
place_state(p, mwPlace_ERROR);
} else {
place_state(p, mwPlace_PENDING);
p->channel = chan;
mwChannel_setServiceData(chan, p, NULL);
}
return ret;
}
MeanwhileSession::~MeanwhileSession()
{
HERE;
if (isConnected() || isConnecting())
disconnect();
mwSession_removeService(session, mwService_STORAGE);
mwSession_removeService(session, mwService_RESOLVE);
mwSession_removeService(session, mwService_IM);
mwSession_removeService(session, mwService_AWARE);
mwAwareList_free(awareList);
mwService_free(MW_SERVICE(storageService));
mwService_free(MW_SERVICE(resolveService));
mwService_free(MW_SERVICE(imService));
mwService_free(MW_SERVICE(awareService));
mwCipher_free(mwSession_getCipher(session, mwCipher_RC2_40));
mwCipher_free(mwSession_getCipher(session, mwCipher_RC2_128));
mwSession_free(session);
}
static void recv_accept(struct mwServiceAware *srvc,
struct mwChannel *chan,
struct mwMsgChannelAccept *msg) {
g_return_if_fail(srvc->channel != NULL);
g_return_if_fail(srvc->channel == chan);
if(MW_SERVICE_IS_STARTING(MW_SERVICE(srvc))) {
GList *list = NULL;
list = map_collect_values(srvc->entries);
send_add(chan, list);
g_list_free(list);
send_attrib_list(srvc);
mwService_started(MW_SERVICE(srvc));
} else {
mwChannel_destroy(chan, ERR_FAILURE, NULL);
}
}
static void recv_accept(struct mwServiceDirectory *srvc,
struct mwChannel *chan,
struct mwMsgChannelAccept *msg) {
g_return_if_fail(srvc->channel != NULL);
g_return_if_fail(srvc->channel == chan);
if(MW_SERVICE_IS_STARTING(srvc)) {
mwService_started(MW_SERVICE(srvc));
} else {
mwChannel_destroy(chan, ERR_FAILURE, NULL);
}
}
const char *mwPlace_getTitle(struct mwPlace *place) {
g_return_val_if_fail(place != NULL, NULL);
if(! place->title) {
struct mwSession *session;
struct mwLoginInfo *li;
session = mwService_getSession(MW_SERVICE(place->service));
li = mwSession_getLoginInfo(session);
place->title = place_generate_title(li? li->user_name: NULL);
}
return place->title;
}
struct mwServiceStorage *mwServiceStorage_new(struct mwSession *session) {
struct mwServiceStorage *srvc_store;
struct mwService *srvc;
srvc_store = g_new0(struct mwServiceStorage, 1);
srvc = MW_SERVICE(srvc_store);
mwService_init(srvc, session, mwService_STORAGE);
srvc->get_name = get_name;
srvc->get_desc = get_desc;
srvc->recv_accept = recv_channelAccept;
srvc->recv_destroy = recv_channelDestroy;
srvc->recv = recv;
srvc->start = start;
srvc->stop = stop;
srvc->clear = clear;
return srvc_store;
}
static struct mwConference *conf_new(struct mwServiceConference *srvc) {
struct mwConference *conf;
struct mwSession *session;
const char *user;
conf = g_new0(struct mwConference, 1);
conf->state = mwConference_NEW;
conf->service = srvc;
conf->members = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL,
(GDestroyNotify) login_free);
session = mwService_getSession(MW_SERVICE(srvc));
user = mwSession_getProperty(session, mwSession_AUTH_USER_ID);
srvc->confs = g_list_prepend(srvc->confs, conf);
return conf;
}
static void stop(struct mwServiceConference *srvc) {
while(srvc->confs)
mwConference_destroy(srvc->confs->data, ERR_SUCCESS, NULL);
mwService_stopped(MW_SERVICE(srvc));
}
static void stop(struct mwServicePlace *srvc) {
while(srvc->places)
mwPlace_destroy(srvc->places->data, ERR_SUCCESS);
mwService_stopped(MW_SERVICE(srvc));
}