void send_msg_channel(CHANNEL *chan, 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_channel(newraw, chan, g_ape);
}
void send_msg_sub(subuser *sub, 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_sub(newraw, sub, 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);
}
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);
}
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);
POSTRAW_DONE(newraw);
}
void proxy_onevent(ape_proxy *proxy, char *event, acetables *g_ape)
{
RAW *newraw;
json_item *jlist = json_new_object();
json_set_property_strZ(jlist, "event", event);
json_set_property_objN(jlist, "pipe", 4, get_json_object_proxy(proxy));
newraw = forge_raw("PROXY_EVENT", jlist);
proxy_post_raw(newraw, proxy, g_ape);
}
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_item *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 = json_new_object();
json_set_property_strZ(jlist, "reason", reason);
json_set_property_objN(jlist, "banner", 6, get_json_object_user(banner));
json_set_property_objN(jlist, "pipe", 4, get_json_object_channel(chan));
newraw = forge_raw(RAW_BAN, jlist);
post_raw(newraw, uTmp->userinfo, g_ape);
if (isban == 0) {
blist = xmalloc(sizeof(*blist));
memset(blist->reason, 0, 256);
strncpy(blist->ip, ip, 16);
strncpy(blist->reason, reason, 255);
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;
}
}
/* This is usefull to ask all subuser to update their sessions */
unsigned int cmd_pong(callbackp *callbacki)
{
if (strcmp(callbacki->param[2], callbacki->call_user->lastping) == 0) {
RAW *newraw;
callbacki->call_user->lastping[0] = '\0';
json *jlist = NULL;
set_json("value", callbacki->param[2], &jlist);
newraw = forge_raw("UPDATE", jlist);
post_raw_sub(newraw, getsubuser(callbacki->call_user, callbacki->host), callbacki->g_ape);
}
return (FOR_NOTHING);
}
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 checkcmd(clientget *cget, transport_t transport, subuser **iuser, acetables *g_ape)
{
struct _cmd_process pc = {cget->hlines, NULL, NULL, cget->client, cget->host, cget->ip_get, transport};
json_item *ijson, *ojson;
unsigned int ret;
ijson = ojson = init_json_parser(cget->get);
if (ijson == NULL || ijson->jchild.child == NULL) {
RAW *newraw;
json_item *jlist = json_new_object();
json_set_property_strZ(jlist, "code", "005");
json_set_property_strZ(jlist, "value", "BAD_JSON");
newraw = forge_raw(RAW_ERR, jlist);
send_raw_inline(cget->client, transport, newraw, g_ape);
} else {
for (ijson = ijson->jchild.child; ijson != NULL; ijson = ijson->next) {
if (pc.guser != NULL && pc.guser->istmp) { /* if "CONNECT" was delayed, push other cmd to the queue and stop execution */
pc.guser->cmdqueue = json_item_copy(ijson, NULL);
break;
}
if ((ret = process_cmd(ijson, &pc, iuser, g_ape)) != -1) {
free_json_item(ojson);
return ret;
}
if (*iuser != NULL) {
pc.sub = *iuser;
}
}
free_json_item(ojson);
return (CONNECT_KEEPALIVE);
}
return (CONNECT_SHUTDOWN);
}
void sendback_session(USERS *user, session *sess, acetables *g_ape)
{
subuser *current = user->subuser;
while (current != NULL) {
if (current->need_update) {
json *jlist = NULL, *jobj = NULL;
RAW *newraw;
current->need_update = 0;
set_json("sessions", NULL, &jlist);
set_json(sess->key, (sess != NULL ? sess->val : NULL), &jobj);
json_attach(jlist, jobj, JSON_OBJECT);
newraw = forge_raw("SESSIONS", jlist);
newraw->priority = 1;
post_raw_sub(newraw, current, g_ape);
}
current = current->next;
}
}
unsigned int cmd_session(callbackp *callbacki)
{
if (strcmp(callbacki->param[2], "set") == 0 && (callbacki->nParam == 4 || callbacki->nParam == 5)) {
if (callbacki->nParam == 5) {
subuser *tmpSub = getsubuser(callbacki->call_user, callbacki->host);
if (tmpSub != NULL) {
tmpSub->need_update = 0;
}
}
if (set_session(callbacki->call_user, callbacki->param[3], callbacki->param[4], (callbacki->nParam == 4 ? 0 : 1), callbacki->g_ape) == NULL) {
send_error(callbacki->call_user, "SESSION_ERROR", "203", callbacki->g_ape);
}
} else if (strcmp(callbacki->param[2], "get") == 0 && callbacki->nParam >= 3) {
int i;
json *jlist = NULL, *jobj = NULL;
RAW *newraw;
set_json("sessions", NULL, &jlist);
for (i = 3; i <= callbacki->nParam; i++) {
if (strlen(callbacki->param[i]) > 32) {
continue;
}
session *sTmp = get_session(callbacki->call_user, callbacki->param[i]);
set_json(callbacki->param[i], (sTmp != NULL ? sTmp->val : NULL), &jobj);
}
json_attach(jlist, jobj, JSON_OBJECT);
newraw = forge_raw("SESSIONS", jlist);
newraw->priority = 1;
/* Only sending to current subuser */
post_raw_sub(newraw, getsubuser(callbacki->call_user, callbacki->host), callbacki->g_ape);
} else {
send_error(callbacki->call_user, "SESSION_ERROR_PARAMS", "108", callbacki->g_ape);
}
return (FOR_NOTHING);
}
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;
subuser_restor(getsubuser(callbacki->call_user, callbacki->host), 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);
}
void proxy_process_eol(ape_socket *co, acetables *g_ape)
{
char *b64;
ape_proxy *proxy = co->attach;
char *data = co->buffer_in.data;
RAW *newraw;
json_item *jlist = json_new_object();
data[co->buffer_in.length] = '\0';
b64 = base64_encode(data, strlen(data));
json_set_property_strZ(jlist, "data", b64);
json_set_property_strN(jlist, "event", 5, "READ", 4);
json_set_property_objN(jlist, "pipe", 4, get_json_object_proxy(proxy));
newraw = forge_raw("PROXY_EVENT", jlist);
proxy_post_raw(newraw, proxy, g_ape);
free(b64);
}
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);
}
void sendback_session(USERS *user, session *sess, acetables *g_ape)
{
subuser *current = user->subuser;
while (current != NULL) {
if (current->need_update) {
json_item *jlist = json_new_object(), *jobj_item = json_new_object();
RAW *newraw;
current->need_update = 0;
json_set_property_strZ(jobj_item, sess->key, sess->val);
json_set_property_objN(jlist, "sessions", 8, jobj_item);
newraw = forge_raw("SESSIONS", jlist);
newraw->priority = RAW_PRI_HI;
post_raw_sub(copy_raw_z(newraw), current, g_ape);
}
current = current->next;
}
}
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);
}
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);
}
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
}
int process_cmd(json_item *ijson, struct _cmd_process *pc, subuser **iuser, acetables *g_ape)
{
callback *cmdback, tmpback = {handle_bad_cmd, NEED_NOTHING};
json_item *rjson = json_lookup(ijson->jchild.child, "cmd"), *jchl;
subuser *sub = pc->sub;
unsigned int flag;
unsigned short int attach = 1;
if (rjson != NULL && rjson->jval.vu.str.value != NULL) {
callbackp cp;
cp.client = NULL;
cp.cmd = rjson->jval.vu.str.value;
cp.data = NULL;
cp.hlines = NULL;
json_item *jsid;
if ((cmdback = (callback *)hashtbl_seek(g_ape->hCallback, rjson->jval.vu.str.value)) == NULL) {
cmdback = &tmpback;
}
if ((pc->guser == NULL && (jsid = json_lookup(ijson->jchild.child, "sessid")) != NULL && jsid->jval.vu.str.value != NULL)) {
pc->guser = seek_user_id(jsid->jval.vu.str.value, g_ape);
}
if (cmdback->need != NEED_NOTHING || pc->guser != NULL) { // We process the connection like a "NEED_SESSID" if the user provide its key
if (pc->guser == NULL) {
RAW *newraw;
json_item *jlist = json_new_object();
json_set_property_strZ(jlist, "code", "004");
json_set_property_strZ(jlist, "value", "BAD_SESSID");
newraw = forge_raw(RAW_ERR, jlist);
send_raw_inline(pc->client, pc->transport, newraw, g_ape);
return (CONNECT_SHUTDOWN);
} else if (sub == NULL) {
sub = getsubuser(pc->guser, pc->host);
if (sub != NULL && sub->client->fd != pc->client->fd && sub->state == ALIVE) {
/* The user open a new connection while he already has one openned */
struct _transport_open_same_host_p retval = transport_open_same_host(sub, pc->client, pc->guser->transport);
if (retval.client_close != NULL) {
// Send CLOSE if no response has been sent yet
if (!sub->headers.sent) {
RAW *newraw;
json_item *jlist = json_new_object();
json_set_property_strZ(jlist, "value", "null");
newraw = forge_raw("CLOSE", jlist);
send_raw_inline((retval.client_close->fd == pc->client->fd ? pc->client : sub->client), pc->transport, newraw, g_ape);
}
// It's not safe to leave the subuser pointer in co->attach anymore
// since subuser could subsequently be deleted, leaving a pointer into free heap.
// So, let this socket finish up on its own and pretend its already finished.
sub->state = ADIED;
sub->headers.sent = 0;
http_headers_free(sub->headers.content);
sub->headers.content = NULL;
sub->burn_after_writing = 0;
g_ape->co[retval.client_close->fd]->attach = NULL;
safe_shutdown(retval.client_close->fd, g_ape);
}
sub->client = cp.client = retval.client_listener;
sub->state = retval.substate;
attach = retval.attach;
} else if (sub == NULL) {
sub = addsubuser(pc->client, pc->host, pc->guser, g_ape);
if (sub != NULL) {
subuser_restor(sub, g_ape);
}
} else if (sub != NULL) {
sub->client = pc->client;
}
pc->guser->idle = (long int)time(NULL); // update user idle
sub->idle = pc->guser->idle; // Update subuser idle
}
}
if (pc->guser != NULL && sub != NULL && (jchl = json_lookup(ijson->jchild.child, "chl")) != NULL /*&& jchl->jval.vu.integer_value > sub->current_chl*/) {
sub->current_chl = jchl->jval.vu.integer_value;
}
#if 0
else if (pc->guser != NULL && sub != NULL) {
/* if a bad challenge is detected, we are stoping walking on cmds */
send_error(pc->guser, "BAD_CHL", "250", g_ape);
sub->state = ALIVE;
return (CONNECT_KEEPALIVE);
}
#endif
cp.param = json_lookup(ijson->jchild.child, "params");
cp.client = (cp.client != NULL ? cp.client : pc->client);
cp.call_user = pc->guser;
cp.call_subuser = sub;
cp.g_ape = g_ape;
cp.host = pc->host;
cp.ip = pc->ip;
cp.chl = (sub != NULL ? sub->current_chl : 0);
cp.transport = pc->transport;
cp.hlines = pc->hlines;
/* Little hack to access user object on connect hook callback (preallocate an user) */
if (strncasecmp(cp.cmd, "CONNECT", 7) == 0 && cp.cmd[7] == '\0') {
pc->guser = cp.call_user = adduser(cp.client, cp.host, cp.ip, NULL, g_ape);
pc->guser->transport = pc->transport;
sub = cp.call_subuser = cp.call_user->subuser;
}
if ((flag = call_cmd_hook(cp.cmd, &cp, g_ape)) == RETURN_CONTINUE) {
flag = cmdback->func(&cp);
}
if (flag & RETURN_NULL) {
pc->guser = NULL;
} else if (flag & RETURN_BAD_PARAMS) {
RAW *newraw;
json_item *jlist = json_new_object();
if (cp.chl) {
json_set_property_intN(jlist, "chl", 3, cp.chl);
}
json_set_property_strZ(jlist, "code", "001");
json_set_property_strZ(jlist, "value", "BAD_PARAMS");
newraw = forge_raw(RAW_ERR, jlist);
if (cp.call_user != NULL) {
//cp.call_user->istmp = 0;
if (sub == NULL) {
sub = getsubuser(pc->guser, pc->host);
}
post_raw_sub(newraw, sub, g_ape);
} else {
send_raw_inline(pc->client, pc->transport, newraw, g_ape);
}
//guser = NULL;
} else if (flag & RETURN_BAD_CMD) {
RAW *newraw;
json_item *jlist = json_new_object();
if (cp.chl) {
json_set_property_intN(jlist, "chl", 3, cp.chl);
}
json_set_property_strZ(jlist, "code", "003");
json_set_property_strZ(jlist, "value", "BAD_CMD");
newraw = forge_raw(RAW_ERR, jlist);
if (cp.call_user != NULL) {
if (sub == NULL) {
sub = getsubuser(pc->guser, pc->host);
}
post_raw_sub(newraw, sub, g_ape);
} else {
send_raw_inline(pc->client, pc->transport, newraw, g_ape);
}
}
if (pc->guser != NULL) {
if (sub == NULL) {
sub = getsubuser(pc->guser, pc->host);
}
if (iuser != NULL) {
*iuser = (attach ? sub : NULL);
}
/* If tmpfd is set, we do not have any reasons to change its state */
sub->state = ALIVE;
if (flag & RETURN_HANG || flag & RETURN_BAD_PARAMS) {
return (CONNECT_KEEPALIVE);
}
} else if (flag & RETURN_HANG) {
/* Doesn't need sessid */
return (CONNECT_KEEPALIVE);
} else {
return (CONNECT_SHUTDOWN);
}
} else {
RAW *newraw;
json_item *jlist = json_new_object();
json_set_property_strZ(jlist, "code", "003");
json_set_property_strZ(jlist, "value", "NO_CMD");
newraw = forge_raw(RAW_ERR, jlist);
send_raw_inline(pc->client, pc->transport, newraw, g_ape);
//printf("Cant find %s\n", rjson->jval.vu.str.value);
return (CONNECT_SHUTDOWN);
}
return -1;
}
// TODO : Rewrite this f***g ugly function
unsigned int setlevel(USERS *user_actif, USERS *user_passif, CHANNEL *chan, unsigned int lvl, acetables *g_ape)
{
RAW *newraw;
userslist *user_passif_chan, *user_actif_chan;
json *jlist;
char level[8];
user_passif_chan = getuchan(user_passif, chan);
if (user_actif != NULL) {
user_actif_chan = getuchan(user_actif, chan);
if (user_passif_chan == NULL || user_actif_chan == NULL || ((user_actif_chan->level < lvl || user_actif_chan->level < user_passif_chan->level) && !(user_actif->flags & FLG_AUTOOP)) || lvl < 1 || lvl > 32) {
send_error(user_actif, "SETLEVEL_ERROR", "110", g_ape);
return 0;
}
user_passif_chan->level = lvl;
if (chan->interactive) {
jlist = NULL;
set_json("ope", NULL, &jlist);
json_attach(jlist, get_json_object_user(user_passif), JSON_OBJECT);
set_json("opeur", NULL, &jlist);
json_attach(jlist, get_json_object_user(user_actif), JSON_OBJECT);
set_json("level", itos(lvl, level), &jlist);
set_json("pipe", NULL, &jlist);
json_attach(jlist, get_json_object_channel(chan), JSON_OBJECT);
newraw = forge_raw(RAW_SETLEVEL, jlist);
post_raw_channel(newraw, chan, g_ape);
}
return 1;
} else if (user_passif_chan != NULL && lvl > 0 && lvl < 32) {
user_passif_chan->level = lvl;
if (chan->interactive) {
jlist = NULL;
set_json("ope", NULL, &jlist);
json_attach(jlist, get_json_object_user(user_passif), JSON_OBJECT);
set_json("opeur", NULL, &jlist);
json_attach(jlist, get_json_object_user(NULL), JSON_OBJECT);
set_json("level", itos(lvl, level), &jlist);
set_json("pipe", NULL, &jlist);
json_attach(jlist, get_json_object_channel(chan), JSON_OBJECT);
newraw = forge_raw(RAW_SETLEVEL, jlist);
post_raw_channel(newraw, chan, g_ape);
}
return 1;
}
return 0;
}
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) {
if (prev != NULL) {
prev->next = list->next;
} else {
chan->head = list->next;
}
free(list);
list = NULL;
if (chan->head != NULL && chan->interactive) {
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) {
rmchan(chan, g_ape);
}
break;
}
prev = list;
list = list->next;
}
}
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 subuser_restor(subuser *sub, acetables *g_ape)
{
CHANLIST *chanl;
CHANNEL *chan;
json *jlist = NULL;
RAW *newraw;
USERS *user = sub->user;
userslist *ulist;
char level[8];
chanl = user->chan_foot;
while (chanl != NULL) {
jlist = NULL;
chan = chanl->chaninfo;
if (chan->interactive) {
ulist = chan->head;
set_json("users", NULL, &jlist);
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);
newraw->priority = 1;
post_raw_sub(newraw, sub, g_ape);
chanl = chanl->next;
}
jlist = NULL;
set_json("user", NULL, &jlist);
json_attach(jlist, get_json_object_user(user), JSON_OBJECT);
newraw = forge_raw("IDENT", jlist);
newraw->priority = 1;
post_raw_sub(newraw, sub, g_ape);
}
