path: root/command.c

#define _GNU_SOURCE
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <sys/time.h>
#include <sys/socket.h>
#include "command.h"
#include "db.h"
#include "user_data.h"


static i64 make_timestamp(void){
	struct timeval tv;
	gettimeofday(&tv,NULL);
	return (i64)tv.tv_sec*1000000+tv.tv_usec;
}


static bool send_raw_text(int fd,const char *text,i64 len){
	i64 cursor=0;
	while(cursor<len){
		i64 nwr=send(fd,text+cursor,len-cursor,0);
		if(nwr<0){
			if(errno==EINTR)continue;
			if(errno==ECONNRESET||errno==EPIPE)return true;
			die_perror("send");
		}
		cursor+=nwr;
	}
	return false;
}

static bool send_ok(int fd,const char *tag){
	char *buf=NULL;
	i64 len=asprintf(&buf,"%s ok\n",tag);
	bool closed=send_raw_text(fd,buf,len);
	free(buf);
	return closed;
}

static bool send_error(int fd,const char *tag,const char *msg){
	char *buf=NULL;
	i64 len=asprintf(&buf,"%s error %s\n",tag,msg);
	bool closed=send_raw_text(fd,buf,len);
	free(buf);
	return closed;
}

static bool send_name(int fd,const char *tag,const char *name){
	char *buf=NULL;
	i64 len=asprintf(&buf,"%s name %s\n",tag,name);
	bool closed=send_raw_text(fd,buf,len);
	free(buf);
	return closed;
}

static bool send_list(int fd,const char *tag,i64 count,const char **list){
	char *buf=NULL;
	i64 len=asprintf(&buf,"%s list %" PRIi64,tag,count);
	bool closed=send_raw_text(fd,buf,len);
	free(buf);
	if(closed)return true;

	if(count>0){
		i64 bufsz=64;
		buf=malloc(bufsz,char);

		for(i64 i=0;i<count;i++){
			i64 len=strlen(list[i]);
			if(len>=bufsz){
				bufsz=len+512;
				buf=realloc(buf,bufsz,char);
			}
			memcpy(buf+1,list[i],len);
			buf[0]=' ';
			if(send_raw_text(fd,buf,len+1)){
				free(buf);
				return true;
			}
		}

		free(buf);
	}

	return send_raw_text(fd,"\n",1);
}


static bool cmd_register(struct conn_data *data,const char *tag,const char **args){
	i64 userid=db_find_user(args[0]);
	if(userid!=-1){
		send_error(data->fd,tag,"Username already exists");
		return false;
	}
	db_create_user(args[0],args[1]);
	return send_ok(data->fd,tag);
}

static bool cmd_login(struct conn_data *data,const char *tag,const char **args){
	i64 userid=db_find_user(args[0]);
	if(userid==-1){
		send_error(data->fd,tag,"User not found");
		return false;
	}
	char *pass=db_get_pass(userid);
	bool success=strcmp(args[1],pass)==0;
	free(pass);
	if(data->userid!=-1){
		userdata_unregister(data->userid,data->fd);
	}
	if(success){
		data->userid=userid;
		userdata_register(userid,data->fd);
		send_ok(data->fd,tag);
	} else {
		data->userid=-1;
		send_error(data->fd,tag,"Incorrect password");
	}
	return false;
}

static bool cmd_list_rooms(struct conn_data *data,const char *tag,const char **args){
	(void)args;
	if(data->userid==-1){
		send_error(data->fd,tag,"Not logged in");
		return false;
	}
	struct db_room_list rl=db_list_rooms(data->userid);
	if(rl.count<=0){
		db_nullify_room_list(rl);
		return send_list(data->fd,tag,0,NULL);
	}
	const char *names[rl.count];
	for(i64 i=0;i<rl.count;i++){
		names[i]=rl.list[i].name;
	}
	bool closed=send_list(data->fd,tag,rl.count,names);
	db_nullify_room_list(rl);
	return closed;
}

static bool cmd_list_members(struct conn_data *data,const char *tag,const char **args){
	if(data->userid==-1){
		send_error(data->fd,tag,"Not logged in");
		return false;
	}
	i64 roomid=db_find_room(args[0]);
	if(roomid==-1){
		send_error(data->fd,tag,"Room not found");
		return false;
	}
	if(!db_is_member(roomid,data->userid)){
		send_error(data->fd,tag,"Not in that room");
		return false;
	}

	struct db_user_list ul=db_list_members(roomid);
	if(ul.count<=0){
		db_nullify_user_list(ul);
		return send_list(data->fd,tag,0,NULL);
	}
	const char *names[ul.count];
	for(i64 i=0;i<ul.count;i++){
		names[i]=ul.list[i].name;
	}
	bool closed=send_list(data->fd,tag,ul.count,names);
	db_nullify_user_list(ul);
	return closed;
}

static bool cmd_create_room(struct conn_data *data,const char *tag,const char **args){
	(void)args;
	if(data->userid==-1){
		send_error(data->fd,tag,"Not logged in");
		return false;
	}
	struct db_name_id room=db_create_room();
	db_add_member(room.id,data->userid);
	bool closed=send_name(data->fd,tag,room.name);
	db_nullify_name_id(room);
	return closed;
}

static bool cmd_invite(struct conn_data *data,const char *tag,const char **args){
	if(data->userid==-1){
		send_error(data->fd,tag,"Not logged in");
		return false;
	}
	i64 roomid=db_find_room(args[0]);
	if(roomid==-1){
		send_error(data->fd,tag,"Room not found");
		return false;
	}

	i64 user2=db_find_user(args[1]);
	if(user2==-1){
		send_error(data->fd,tag,"User not found");
		return false;
	}

	if(!db_is_member(roomid,data->userid)){
		send_error(data->fd,tag,"Not in that room");
		return false;
	}
	if(db_is_member(roomid,user2)){
		send_error(data->fd,tag,"User already in that room");
		return false;
	}

	db_add_member(roomid,user2);

	const char *username=args[1];
	char *joinbuf=NULL;
	i64 joinbuflen=asprintf(&joinbuf,"_push join %s %s\n",args[0],username);
	char *invitebuf=NULL;
	i64 invitebuflen=asprintf(&invitebuf,"_push invite %s\n",args[0]);

	struct db_user_list members=db_list_members(roomid);
	for(i64 i=0;i<members.count;i++){
		i64 nfds;
		const int *fds=userdata_online(members.list[i].id,&nfds);
		if(nfds<=0)continue;
		for(i64 j=0;j<nfds;j++){
			if(fds[j]!=data->fd){
				if(members.list[i].id==user2){
					send_raw_text(fds[j],invitebuf,invitebuflen);
				} else {
					send_raw_text(fds[j],joinbuf,joinbuflen);
				}
			}
		}
	}

	db_nullify_user_list(members);
	free(joinbuf);
	free(invitebuf);

	return send_ok(data->fd,tag);
}

static bool cmd_send(struct conn_data *data,const char *tag,const char **args){
	if(data->userid==-1){
		send_error(data->fd,tag,"Not logged in");
		return false;
	}
	i64 roomid=db_find_room(args[0]);
	if(roomid==-1){
		send_error(data->fd,tag,"Room not found");
		return false;
	}
	if(!db_is_member(roomid,data->userid)){
		send_error(data->fd,tag,"Not in that room");
		return false;
	}

	i64 timestamp=make_timestamp();
	db_create_message(roomid,data->userid,make_timestamp(),args[1]);
	bool closed=send_ok(data->fd,tag);

	char *pushbuf=NULL;
	char *username=db_get_username(data->userid);
	i64 pushbuflen=asprintf(&pushbuf,"_push message %s %s %" PRIi64 " %s\n",
			args[0],username,timestamp,args[1]);
	free(username);

	struct db_user_list members=db_list_members(roomid);
	for(i64 i=0;i<members.count;i++){
		i64 nfds;
		const int *fds=userdata_online(members.list[i].id,&nfds);
		if(nfds<=0)continue;
		for(i64 j=0;j<nfds;j++){
			if(fds[j]!=data->fd){
				send_raw_text(fds[j],pushbuf,pushbuflen);
			}
		}
	}

	db_nullify_user_list(members);
	free(pushbuf);

	return closed;
}

static bool cmd_history(struct conn_data *data,const char *tag,const char **args){
	char *endp;
	i64 nrequested=strtoll(args[1],&endp,10);
	if(args[1][0]=='\0'||*endp!='\0'||nrequested<0){
		debug("Connection fd=%d sent an invalid number for 'history': '%s'",data->fd,args[1]);
		return true;
	}

	if(data->userid==-1){
		send_error(data->fd,tag,"Not logged in");
		return false;
	}
	i64 roomid=db_find_room(args[0]);
	if(roomid==-1){
		send_error(data->fd,tag,"Room not found");
		return false;
	}
	if(!db_is_member(roomid,data->userid)){
		send_error(data->fd,tag,"Not in that room");
		return false;
	}

	struct db_message_list ml=db_get_messages(roomid,nrequested);
	char *buf=NULL;
	i64 len=asprintf(&buf,"%s history %" PRIi64 "\n",tag,ml.count);
	bool closed=send_raw_text(data->fd,buf,len);
	free(buf);

	if(closed){
		db_nullify_message_list(ml);
		return true;
	}

	for(i64 i=ml.count-1;i>=0;i--){
		char *username=db_get_username(ml.list[i].userid);
		len=asprintf(&buf,"%s history_message %" PRIi64 " %s %s %" PRIi64 " %s\n",
				tag,ml.count-1-i,args[0],username,ml.list[i].timestamp,ml.list[i].message);
		closed=send_raw_text(data->fd,buf,len);
		free(buf);
		if(closed)break;
	}

	db_nullify_message_list(ml);
	return closed;
}


struct cmd_info{
	const char *cmdname;
	int nargs;
	bool longlast;  // whether the last argument should span the rest of the input line
	bool (*handler)(struct conn_data *data,const char *tag,const char **args);
};

static const struct cmd_info commands[]={
	{"register",2,true,cmd_register},
	{"login",2,true,cmd_login},
	{"list_rooms",0,false,cmd_list_rooms},
	{"list_members",1,false,cmd_list_members},
	{"create_room",0,false,cmd_create_room},
	{"invite",2,false,cmd_invite},
	{"send",2,true,cmd_send},
	{"history",2,false,cmd_history},
};
#define NCOMMANDS (sizeof(commands)/sizeof(commands[0]))


bool handle_input_line(struct conn_data *data,char *line,size_t linelen){
	line[linelen]='\0';
	char *sepp=memchr(line,' ',linelen);
	if(sepp==NULL){
		debug("No space in input line from connection %d",data->fd);
		return true;
	}
	char *tag=line;
	size_t taglen=sepp-tag;
	*sepp='\0';
	line+=taglen+1;
	linelen-=taglen+1;

	sepp=memchr(line,' ',linelen);
	if(sepp==NULL)sepp=line+linelen;
	size_t cmdlen=sepp-line;
	size_t cmdi;
	for(cmdi=0;cmdi<NCOMMANDS;cmdi++){
		if(strncmp(line,commands[cmdi].cmdname,cmdlen)==0){
			break;
		}
	}

	if(cmdi==NCOMMANDS){
		debug("Unknown command %s on connection %d",line,data->fd);
		return true;
	}

	int nargs=commands[cmdi].nargs;
	char *args[nargs];
	size_t cursor=cmdlen+1;

	for(int i=0;i<nargs;i++){
		if(cursor>linelen){
			debug("Connection %d sent too few parameters to command %s",data->fd,commands[cmdi].cmdname);
			return true;
		}
		if(i==nargs-1&&commands[cmdi].longlast){
			sepp=line+linelen;
		} else {
			sepp=memchr(line+cursor,' ',linelen-cursor);
			if(sepp==NULL)sepp=line+linelen;
		}
		*sepp='\0';
		args[i]=line+cursor;
		cursor=sepp-line+1;
	}
	if(sepp-line<(i64)linelen){
		debug("Connection %d sent too many parameters to command %s",data->fd,commands[cmdi].cmdname);
		return true;
	}

	return commands[cmdi].handler(data,tag,(const char**)args);
}