Beispiel #1
0
// 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_item *jlist;

	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 = json_new_object();
			
			json_set_property_objN(jlist, "ope", 3, get_json_object_user(user_passif));
			json_set_property_objN(jlist, "oper", 4, get_json_object_user(user_actif));
			json_set_property_objN(jlist, "pipe", 4, get_json_object_channel(chan));
			json_set_property_intN(jlist, "level", 5, lvl);
		
			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 = json_new_object();

			json_set_property_objN(jlist, "ope", 3, get_json_object_user(user_passif));
			json_set_property_objN(jlist, "oper", 4, get_json_object_user(NULL));
			json_set_property_objN(jlist, "pipe", 4, get_json_object_channel(chan));
			json_set_property_intN(jlist, "level", 5, lvl);

			newraw = forge_raw(RAW_SETLEVEL, jlist);
			post_raw_channel(newraw, chan, g_ape);
			
		}
		return 1;
	}
	return 0;
}
Beispiel #2
0
void subuser_restor(subuser *sub, acetables *g_ape)
{
	CHANLIST *chanl;
	CHANNEL *chan;
	
	json_item *jlist;
	RAW *newraw;
	USERS *user = sub->user;
	userslist *ulist;

	chanl = user->chan_foot;

	while (chanl != NULL) {
		chan = chanl->chaninfo;
		/*
		 * quiet channel won't be posted on subuser_restor 
		 */
		if (!(chan->flags & CHANNEL_QUIET)) {
			jlist = json_new_object();
			if ( !(chan->flags & CHANNEL_NONINTERACTIVE) && chan->head != NULL ) {
				json_item *user_list = json_new_array();
			
				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);
			newraw->priority = RAW_PRI_HI;
			post_raw_sub(newraw, sub, g_ape);
			POSTRAW_DONE(newraw);
		}
		chanl = chanl->next;
	}

	jlist = json_new_object();
	json_set_property_objN(jlist, "user", 4, get_json_object_user(user));	
	
	newraw = forge_raw("IDENT", jlist);
	newraw->priority = RAW_PRI_HI;
	post_raw_sub(newraw, sub, g_ape);
	POSTRAW_DONE(newraw);
	
}
Beispiel #3
0
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;
}
Beispiel #4
0
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

}
Beispiel #5
0
void json_set_element_int(json_item *obj, long int value)
{
	json_set_property_intN(obj, NULL, 0, value);
}
Beispiel #6
0
void json_set_property_intZ(json_item *obj, const char *key, JSON_int_t value)
{
	int len = (key != NULL ? strlen(key) : 0);
	
	json_set_property_intN(obj, key, len, value);
}