unsigned int cmd_connect(callbackp *callbacki)
{
USERS *nuser;
RAW *newraw;
json_item *jstr = NULL;
nuser = adduser(NULL, NULL, NULL, callbacki->call_user, callbacki->g_ape);
callbacki->call_user = nuser;
jstr = json_new_object();
json_set_property_objN(jstr, "user", 4, get_json_object_user(callbacki->call_user));
newraw = forge_raw("IDENT", jstr);
newraw->priority = RAW_PRI_HI;
post_raw_sub(newraw, callbacki->call_subuser, callbacki->g_ape);
jstr = json_new_object();
json_set_property_strN(jstr, "sessid", 6, nuser->sessid, 32);
newraw = forge_raw(RAW_LOGIN, jstr);
newraw->priority = RAW_PRI_HI;
post_raw(newraw, nuser, callbacki->g_ape);
return (RETURN_NOTHING);
}
static void process_message_callback(GMimeObject *part, gpointer user_data)
{
struct mime_cbinfo *cbinfo = user_data;
cbinfo->count++;
/* We strip off the headers before we get here, so should only see GMIME_IS_PART */
if (GMIME_IS_MESSAGE_PART(part)) {
ast_log(LOG_WARNING, "Got unexpected GMIME_IS_MESSAGE_PART\n");
return;
} else if (GMIME_IS_MESSAGE_PARTIAL(part)) {
ast_log(LOG_WARNING, "Got unexpected GMIME_IS_MESSAGE_PARTIAL\n");
return;
} else if (GMIME_IS_MULTIPART(part)) {
GList *l;
ast_log(LOG_WARNING, "Got unexpected GMIME_IS_MULTIPART, trying to process subparts\n");
l = GMIME_MULTIPART(part)->subparts;
while (l) {
process_message_callback(l->data, cbinfo);
l = l->next;
}
} else if (GMIME_IS_PART(part)) {
const char *filename;
if (ast_strlen_zero(filename = g_mime_part_get_filename(GMIME_PART(part)))) {
ast_debug(1, "Skipping part with no filename\n");
return;
}
post_raw(GMIME_PART(part), cbinfo->post_dir, filename);
} else {
ast_log(LOG_ERROR, "Encountered unknown MIME part. This should never happen!\n");
}
}
void ban(CHANNEL *chan, USERS *banner, const char *ip, char *reason, unsigned int expire, acetables *g_ape) // Ban IP
{
userslist *uTmp, *tUtmp;
RAW *newraw;
json *jlist;
BANNED *blist, *bTmp;
unsigned int isban = 0;
long int nextime = (expire * 60)+time(NULL); // NOW !
if (chan == NULL) {
return;
}
uTmp = chan->head;
bTmp = chan->banned;
while (uTmp != NULL) {
if (strcmp(ip, uTmp->userinfo->ip) == 0) { // We find somebody with the same IP
jlist = NULL;
set_json("reason", reason, &jlist);
if (banner != NULL) {
set_json("banner", NULL, &jlist);
json_attach(jlist, get_json_object_user(banner), JSON_OBJECT);
} else {
set_json("banner", NULL, &jlist);
json_attach(jlist, get_json_object_user(NULL), JSON_OBJECT);
}
set_json("pipe", NULL, &jlist);
json_attach(jlist, get_json_object_channel(chan), JSON_OBJECT);
newraw = forge_raw(RAW_BAN, jlist);
post_raw(newraw, uTmp->userinfo, g_ape);
if (isban == 0) {
blist = xmalloc(sizeof(*blist));
strncpy(blist->ip, ip, 16);
strncpy(blist->reason, reason, 256);
blist->expire = nextime;
blist->next = bTmp;
chan->banned = blist;
isban = 1;
}
tUtmp = uTmp->next;
left(uTmp->userinfo, chan, g_ape); // if the user is the last : "chan" is free (rmchan())
uTmp = tUtmp;
continue;
}
uTmp = uTmp->next;
}
}
unsigned int cmd_ban(callbackp *callbacki)
{
CHANNEL *chan;
RAW *newraw;
json *jlist;
USERS *victim;
if ((chan = getchan(callbacki->param[2], callbacki->g_ape)) == NULL) {
send_error(callbacki->call_user, "UNKNOWN_CHANNEL", "103", callbacki->g_ape);
} else if (!isonchannel(callbacki->call_user, chan)) {
send_error(callbacki->call_user, "NOT_IN_CHANNEL", "104", callbacki->g_ape);
} else if (getuchan(callbacki->call_user, chan)->level < 3) {
send_error(callbacki->call_user, "CANT_BAN", "107", callbacki->g_ape);
} else {
victim = seek_user(callbacki->param[3], chan->name, callbacki->g_ape);
if (victim == NULL) {
send_error(callbacki->call_user, "UNKNOWN_USER", "102", callbacki->g_ape);
} else if (victim->flags & FLG_NOKICK) {
send_error(callbacki->call_user, "USER_PROTECTED", "106", callbacki->g_ape);
// Bad boy :-)
jlist = NULL;
set_json("banner", NULL, &jlist);
json_attach(jlist, get_json_object_user(callbacki->call_user), JSON_OBJECT);
set_json("channel", NULL, &jlist);
json_attach(jlist, get_json_object_channel(chan), JSON_OBJECT);
newraw = forge_raw("TRY_BAN", jlist);
post_raw(newraw, victim, callbacki->g_ape);
} else if (strlen(callbacki->param[4]) > 255 || atoi(callbacki->param[5]) > 44640) { // 31 days max
send_error(callbacki->call_user, "REASON_OR_TIME_TOO_LONG", "107", callbacki->g_ape);
} else {
ban(chan, callbacki->call_user, victim->ip, callbacki->param[4], atoi(callbacki->param[5]), callbacki->g_ape);
}
}
return (FOR_NOTHING);
}
void send_msg(USERS *user, const char *msg, const char *type, acetables *g_ape)
{
RAW *newraw;
json *jlist = NULL;
set_json("value", msg, &jlist);
newraw = forge_raw(type, jlist);
post_raw(newraw, user, g_ape);
}
void send_msg(USERS *user, const char *msg, const char *type, acetables *g_ape)
{
RAW *newraw;
json_item *jlist = json_new_object();
json_set_property_strZ(jlist, "value", msg);
newraw = forge_raw(type, jlist);
post_raw(newraw, user, g_ape);
}
void send_error(USERS *user, const char *msg, const char *code, acetables *g_ape)
{
RAW *newraw;
json *jlist = NULL;
set_json("value", msg, &jlist);
set_json("code", code, &jlist);
newraw = forge_raw(RAW_ERR, jlist);
post_raw(newraw, user, g_ape);
}
/* to manage subuser use post_to_pipe() instead */
void post_raw_pipe(RAW *raw, char *pipe, acetables *g_ape)
{
transpipe *spipe;
if ((spipe = get_pipe(pipe, g_ape)) != NULL) {
if (spipe->type == CHANNEL_PIPE) {
post_raw_channel(raw, spipe->pipe, g_ape);
} else {
post_raw(raw, spipe->pipe, g_ape);
}
}
}
void send_error(USERS *user, const char *msg, const char *code, acetables *g_ape)
{
RAW *newraw;
json_item *jlist = json_new_object();
json_set_property_strZ(jlist, "code", code);
json_set_property_strZ(jlist, "value", msg);
newraw = forge_raw(RAW_ERR, jlist);
post_raw(newraw, user, g_ape);
POSTRAW_DONE(newraw);
}
/* Post raw to a channel and propagate it to all of it's users */
void post_raw_channel(RAW *raw, struct CHANNEL *chan, acetables *g_ape)
{
userslist *list;
if (chan == NULL || raw == NULL || chan->head == NULL) {
return;
}
list = chan->head;
while (list) {
post_raw(raw, list->userinfo, g_ape);
list = list->next;
}
}
/* Post raw to a channel and propagate it to all of it's users with a *ruser exception */
void post_raw_channel_restricted(RAW *raw, struct CHANNEL *chan, USERS *ruser, acetables *g_ape)
{
userslist *list;
if (chan == NULL || raw == NULL || chan->head == NULL) {
return;
}
list = chan->head;
while (list) {
if (list->userinfo != ruser) {
post_raw(raw, list->userinfo, g_ape);
}
list = list->next;
}
}
/* Post raw to a proxy and propagate it to all of it's attached users */
void proxy_post_raw(RAW *raw, ape_proxy *proxy, acetables *g_ape)
{
ape_proxy_pipe *to = proxy->to;
transpipe *pipe;
while (to != NULL) {
pipe = get_pipe(to->pipe, g_ape);
if (pipe != NULL && pipe->type == USER_PIPE) {
post_raw(raw, pipe->pipe, g_ape);
} else {
;//
}
to = to->next;
}
}
int post_to_pipe(json_item *jlist, const char *rawname, const char *pipe, subuser *from, acetables *g_ape)
{
USERS *sender = from->user;
transpipe *recver = get_pipe_strict(pipe, sender, g_ape);
json_item *jlist_copy = NULL;
RAW *newraw;
if (sender != NULL) {
if (recver == NULL) {
send_error(sender, "UNKNOWN_PIPE", "109", g_ape);
return 0;
}
json_set_property_objN(jlist, "from", 4, get_json_object_user(sender));
}
if (sender != NULL && sender->nsub > 1) {
jlist_copy = json_item_copy(jlist, NULL);
json_set_property_objN(jlist_copy, "pipe", 4, get_json_object_pipe(recver));
newraw = forge_raw(rawname, jlist_copy);
post_raw_restricted(newraw, sender, from, g_ape);
}
switch(recver->type) {
case USER_PIPE:
json_set_property_objN(jlist, "pipe", 4, get_json_object_user(sender));
newraw = forge_raw(rawname, jlist);
post_raw(newraw, recver->pipe, g_ape);
break;
case CHANNEL_PIPE:
if (((CHANNEL*)recver->pipe)->head != NULL && ((CHANNEL*)recver->pipe)->head->next != NULL) {
json_set_property_objN(jlist, "pipe", 4, get_json_object_channel(recver->pipe));
newraw = forge_raw(rawname, jlist);
post_raw_channel_restricted(newraw, recver->pipe, sender, g_ape);
}
break;
case CUSTOM_PIPE:
json_set_property_objN(jlist, "pipe", 4, get_json_object_user(sender));
post_json_custom(jlist, sender, recver, g_ape);
break;
default:
break;
}
return 1;
}
unsigned int cmd_join(callbackp *callbacki)
{
CHANNEL *jchan;
RAW *newraw;
json *jlist;
BANNED *blist;
if ((jchan = getchan(callbacki->param[2], callbacki->g_ape)) == NULL) {
jchan = mkchan(callbacki->param[2], "Default%20Topic", callbacki->g_ape);
if (jchan == NULL) {
send_error(callbacki->call_user, "CANT_JOIN_CHANNEL", "202", callbacki->g_ape);
} else {
join(callbacki->call_user, jchan, callbacki->g_ape);
}
} else if (isonchannel(callbacki->call_user, jchan)) {
send_error(callbacki->call_user, "ALREADY_ON_CHANNEL", "100", callbacki->g_ape);
} else {
blist = getban(jchan, callbacki->call_user->ip);
if (blist != NULL) {
jlist = NULL;
set_json("reason", blist->reason, &jlist);
set_json("error", "YOU_ARE_BANNED", &jlist);
/*
TODO: Add Until
*/
newraw = forge_raw(RAW_ERR, jlist);
post_raw(newraw, callbacki->call_user, callbacki->g_ape);
} else {
join(callbacki->call_user, jchan, callbacki->g_ape);
}
}
return (FOR_NOTHING);
}
unsigned int cmd_proxy_connect(callbackp *callbacki)
{
ape_proxy *proxy;
RAW *newraw;
json *jlist = NULL;
proxy = proxy_init_by_host_port(callbacki->param[2], callbacki->param[3], callbacki->g_ape);
if (proxy == NULL) {
send_error(callbacki->call_user, "PROXY_INIT_ERROR", "204", callbacki->g_ape);
} else {
proxy_attach(proxy, callbacki->call_user->pipe->pubid, 1, callbacki->g_ape);
set_json("pipe", NULL, &jlist);
json_attach(jlist, get_json_object_proxy(proxy), JSON_OBJECT);
newraw = forge_raw(RAW_PROXY, jlist);
post_raw(newraw, callbacki->call_user, callbacki->g_ape);
}
return (FOR_NOTHING);
}
unsigned int cmd_connect(callbackp *callbacki)
{
USERS *nuser;
RAW *newraw;
struct json *jstr = NULL;
nuser = adduser(callbacki->fdclient, callbacki->host, callbacki->g_ape);
callbacki->call_user = nuser;
if (nuser == NULL) {
SENDH(callbacki->fdclient, ERR_CONNECT, callbacki->g_ape);
return (FOR_NOTHING);
}
if (strcmp(callbacki->param[1], "2") == 0) {
nuser->transport = TRANSPORT_IFRAME;
nuser->flags |= FLG_PCONNECT;
} else {
nuser->transport = TRANSPORT_LONGPOLLING;
}
subuser_restor(getsubuser(callbacki->call_user, callbacki->host), callbacki->g_ape);
set_json("sessid", nuser->sessid, &jstr);
newraw = forge_raw(RAW_LOGIN, jstr);
newraw->priority = 1;
post_raw(newraw, nuser, callbacki->g_ape);
return (FOR_LOGIN | FOR_UPDATE_IP);
}
void join(USERS *user, CHANNEL *chan, acetables *g_ape)
{
userslist *list, *ulist;
CHANLIST *chanl;
FIRE_EVENT_NULL(join, user, chan, g_ape);
RAW *newraw;
json *jlist = NULL;
char level[8];
if (isonchannel(user, chan)) {
return;
}
list = (userslist *)xmalloc(sizeof(*list)); // is it free ?
list->userinfo = user;
list->level = 1;
list->next = chan->head;
chan->head = list;
chanl = (CHANLIST *)xmalloc(sizeof(*chanl)); // is it free ?
chanl->chaninfo = chan;
chanl->next = user->chan_foot;
user->chan_foot = chanl;
if (chan->interactive) {
jlist = NULL;
set_json("user", NULL, &jlist);
json_attach(jlist, get_json_object_user(user), JSON_OBJECT);
set_json("pipe", NULL, &jlist);
json_attach(jlist, get_json_object_channel(chan), JSON_OBJECT);
newraw = forge_raw(RAW_JOIN, jlist);
post_raw_channel_restricted(newraw, chan, user, g_ape);
jlist = NULL;
set_json("users", NULL, &jlist);
ulist = chan->head;
while (ulist != NULL) {
struct json *juser = NULL;
if (ulist->userinfo != user) {
//make_link(user, ulist->userinfo);
}
sprintf(level, "%i", ulist->level);
set_json("level", level, &juser);
json_concat(juser, get_json_object_user(ulist->userinfo));
json_attach(jlist, juser, JSON_ARRAY);
ulist = ulist->next;
}
}
set_json("pipe", NULL, &jlist);
json_attach(jlist, get_json_object_channel(chan), JSON_OBJECT);
newraw = forge_raw(RAW_CHANNEL, jlist);
post_raw(newraw, user, g_ape);
#if 0
if (user->flags & FLG_AUTOOP) {
setlevel(NULL, user, chan, 3);
}
#endif
}
void join(USERS *user, CHANNEL *chan, acetables *g_ape)
{
userslist *list, *ulist;
CHANLIST *chanl;
FIRE_EVENT_NULL(join, user, chan, g_ape);
RAW *newraw;
json_item *jlist = json_new_object();
if (isonchannel(user, chan)) {
return;
}
list = xmalloc(sizeof(*list)); // TODO is it free ?
list->userinfo = user;
list->level = 1;
list->next = chan->head;
chan->head = list;
chanl = xmalloc(sizeof(*chanl)); // TODO is it free ?
chanl->chaninfo = chan;
chanl->next = user->chan_foot;
user->chan_foot = chanl;
if (chan->interactive) {
json_item *user_list = json_new_array();
json_item *uinfo = json_new_object();
json_set_property_objN(uinfo, "user", 4, get_json_object_user(user));
json_set_property_objN(uinfo, "pipe", 4, get_json_object_channel(chan));
newraw = forge_raw(RAW_JOIN, uinfo);
post_raw_channel_restricted(newraw, chan, user, g_ape);
ulist = chan->head;
while (ulist != NULL) {
json_item *juser = get_json_object_user(ulist->userinfo);
if (ulist->userinfo != user) {
//make_link(user, ulist->userinfo);
}
json_set_property_intN(juser, "level", 5, ulist->level);
json_set_element_obj(user_list, juser);
ulist = ulist->next;
}
json_set_property_objN(jlist, "users", 5, user_list);
}
json_set_property_objN(jlist, "pipe", 4, get_json_object_channel(chan));
newraw = forge_raw(RAW_CHANNEL, jlist);
post_raw(newraw, user, g_ape);
#if 0
if (user->flags & FLG_AUTOOP) {
setlevel(NULL, user, chan, 3);
}
#endif
}
void left(USERS *user, CHANNEL *chan, acetables *g_ape) // Vider la liste chainée de l'user
{
userslist *list, *prev;
CHANLIST *clist, *ctmp;
RAW *newraw;
json_item *jlist;
FIRE_EVENT_NULL(left, user, chan, g_ape);
if (!isonchannel(user, chan)) {
return;
}
list = chan->head;
prev = NULL;
clist = user->chan_foot;
ctmp = NULL;
while (clist != NULL) {
if (clist->chaninfo == chan) {
if (ctmp != NULL) {
ctmp->next = clist->next;
} else {
user->chan_foot = clist->next;
}
free(clist);
break;
}
ctmp = clist;
clist = clist->next;
}
while (list != NULL && list->userinfo != NULL) {
if (list->userinfo == user) {
jlist = json_new_object();
json_set_property_objN(jlist, "user", 4, get_json_object_user(user));
json_set_property_objN(jlist, "pipe", 4, get_json_object_channel(chan));
newraw = forge_raw(RAW_LEFT, jlist);
post_raw(newraw, user, g_ape);
if (prev != NULL) {
prev->next = list->next;
} else {
chan->head = list->next;
}
free(list);
list = NULL;
if (chan->head != NULL && !(chan->flags & CHANNEL_NONINTERACTIVE)) {
jlist = json_new_object();
json_set_property_objN(jlist, "user", 4, get_json_object_user(user));
json_set_property_objN(jlist, "pipe", 4, get_json_object_channel(chan));
newraw = forge_raw(RAW_LEFT, jlist);
post_raw_channel(newraw, chan, g_ape);
} else if (chan->head == NULL && chan->flags & CHANNEL_AUTODESTROY) {
rmchan(chan, g_ape);
}
break;
}
prev = list;
list = list->next;
}
}
unsigned int cmd_kick(callbackp *callbacki)
{
CHANNEL *chan;
RAW *newraw;
json *jlist;
USERS *victim;
if ((chan = getchan(callbacki->param[2], callbacki->g_ape)) == NULL) {
send_error(callbacki->call_user, "UNKNOWN_CHANNEL", "103", callbacki->g_ape);
} else if (!isonchannel(callbacki->call_user, chan)) {
send_error(callbacki->call_user, "NOT_IN_CHANNEL", "104", callbacki->g_ape);
} else if (getuchan(callbacki->call_user, chan)->level < 3) {
send_error(callbacki->call_user, "CANT_KICK", "105", callbacki->g_ape);
} else {
victim = seek_user(callbacki->param[3], chan->name, callbacki->g_ape);
if (victim == NULL) {
send_error(callbacki->call_user, "UNKNOWN_USER", "102", callbacki->g_ape);
} else if (victim->flags & FLG_NOKICK) {
send_error(callbacki->call_user, "USER_PROTECTED", "106", callbacki->g_ape);
// haha ;-)
jlist = NULL;
set_json("kicker", NULL, &jlist);
json_attach(jlist, get_json_object_user(callbacki->call_user), JSON_OBJECT);
set_json("channel", NULL, &jlist);
json_attach(jlist, get_json_object_channel(chan), JSON_OBJECT);
newraw = forge_raw("TRY_KICK", jlist);
post_raw(newraw, victim, callbacki->g_ape);
} else {
jlist = NULL;
set_json("kicker", NULL, &jlist);
json_attach(jlist, get_json_object_user(callbacki->call_user), JSON_OBJECT);
set_json("channel", NULL, &jlist);
json_attach(jlist, get_json_object_channel(chan), JSON_OBJECT);
newraw = forge_raw(RAW_KICK, jlist);
post_raw(newraw, victim, callbacki->g_ape);
left(victim, chan, callbacki->g_ape); // chan may be removed
}
}
return (FOR_NOTHING);
}
