/*
	Main server for the project. Hides database logic and controls security/access
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <syslog.h>
#include <signal.h>
#include <sys/stat.h>
#include <tlmplib.h>
#include <tlmpnet.h>
#include <string>
#include "fdpass.h"
#include <tlmpsql.h>


static DEBUG_KEY D_PROTO ("proto","Protocol information");

enum CONNECT_TYPE { TYPE_NONE, TYPE_CONTROL, TYPE_CLIENT, TYPE_ADMIN };

struct HANDLE_INFO: public ARRAY_OBJ{
	CONNECT_TYPE type;
	int no;
	std::string host;
	REQUEST_INFO req;
	std::string userid;
	HANDLE_INFO(){
		no = -1;
		type = TYPE_NONE;
	}
};

#include "proto/trlid_control.protoh"
#include "proto/trlid_client.protoh"
#include "proto/trlid_admin.protoh"

using namespace std;


#include "proto/trli-writed_client.protoch"
#define trli_sessiond_client_getsessioninfovars_NOTNEED
#define trli_sessiond_client_setvar_NOTNEED
#include "proto/trli-sessiond_client.protoch"

<mod>
static int trlid_main (
	const char *bind,
	const char *portstr,
	const char *control,	// Unix socket
	const CONNECT_INFO &con,
	const CONNECT_INFO &con_sess,
	const char *user,
	const char *pidfile,
	bool daemon,
	const map<string,string> &admin_secrets,
	const map<string,string> &client_secrets)
{
	int ret = -1;
	glocal CONNECT_INFO con = con;
	glocal CONNECT_INFO con_sess = con_sess;
	glocal const map<string,string> *admin_secrets = &admin_secrets;
	glocal const map<string,string> *client_secrets = &client_secrets;
	glocal unsigned long nbrequest_client = 0;
	glocal unsigned long nbrequest_admin = 0;
	glocal string unixportclient = string_f("unix:/tmp/trlid-client-%s.sock",portstr);
	glocal string unixportadmin = string_f("unix:/tmp/trlid-admin-%s.sock",portstr);
	<obj TCPSERVER s>(bind,glocal.unixportclient,5);
	<f newclient>
		HANDLE_INFO *n = new HANDLE_INFO;
		info.data = n;
		if (strcmp(info.port,glocal.unixportclient.c_str())==0){
			n->req.secret = fdpass_findsecret (*glocal.client_secrets,info.port);
			if (n->req.secret.size() > 0){
				n->type = TYPE_CLIENT;
			}else{
				tlmp_error ("Rejected client connexion from port %s\n",info.port);
				endclient = true;
			}
		}else if (strcmp(info.port,glocal.unixportadmin.c_str())==0){
			n->req.secret = fdpass_findsecret (*glocal.admin_secrets,info.port);
			if (n->req.secret.size() > 0){
				n->type = TYPE_ADMIN;
			}else{
				tlmp_error ("Rejected admin connexion from port %s\n",info.port);
				endclient = true;
			}
		}else if (strncmp(info.port,"unix:",5)==0){
			n->type = TYPE_CONTROL;
		}else{
			settcpnodelay(true);
			char addr[20];
			ipnum_ip2a (from,addr);
			n->host = addr;
			n->req.secret = fdpass_findsecret (*glocal.client_secrets,addr);
			if (n->req.secret.size() > 0){
				n->type = TYPE_CLIENT;
			}else{
				n->req.secret = fdpass_findsecret (*glocal.admin_secrets,addr);
				if (n->req.secret.size() > 0){
					n->type = TYPE_ADMIN;
				}else{
					tlmp_error ("Rejected connexion from IP %s\n",addr);
					endclient = true;
				}
			}
		}
	</f>
	<f endclient>
	</f>
	<f receive>
		HANDLE_INFO *c = (HANDLE_INFO*)info.data;
		glocal HANDLE_INFO *c = c;
		glocal string userid = c->userid;
		debug_printf (D_PROTO,"receive line: %s\n",line);
		if (c->type == TYPE_CONTROL){
			<call trlid_control>(this,c->req,line,info.linelen, endserver, endclient, no,c,c->host.c_str());
			<f status>
				vector<string> tb;
				tb.push_back(string_f("Version %s",VERSION));
				tb.push_back(string_f ("nbrequest_admin=%lu",glocal.nbrequest_admin));
				tb.push_back(string_f ("nbrequest_client=%lu",glocal.nbrequest_client));
				rep_status(tb);
			</f>
			<f quit>
				endserver = true;
			</f>
			<f debug>
				if (on){
					debug_seton();
				}else{
					debug_setoff();
				}
			</f>
			<f debugfile>
				debug_setfdebug (filename);
			</f>
			<f invalid>
				endclient = true;
			</f>
			</call>
		}else if (c->type == TYPE_CLIENT){
			glocal.nbrequest_client++;
			<call trlid_client>(this,c->req,line, info.linelen,endserver, endclient,no,c,c->host.c_str());
			<f createsession>
				<call trli_writed_client_createsession>(glocal.con);
				<f ok>
					glocal.trlid_client.rep_createsession(sessionid);
				</f>
				</call>
			</f>
			<f login>
				<call trli_writed_client_login>(glocal.con,sessionid,email,password);
				<f ok>
					glocal.trlid_client.rep_login(success);
				</f>
				</call>
			</f>
			<f logout>
				<call trli_writed_client_logout>(glocal.con,sessionid);
				<f ok>
				</f>
				</call>
			</f>
			<f adduser>
				<call trli_writed_client_adduser>(glocal.con,name,email,password);
				<f ok>
					glocal.trlid_client.rep_adduser (confirmid,msg);
				</f>
				</call>
			</f>
			<f confirmuser>
				<call trli_writed_client_confirmuser>(glocal.con,id);
				<f ok>
					glocal.trlid_client.rep_confirmuser(success,msg);
				</f>
				</call>
			</f>
			<f deleteuser>
				<call trli_writed_client_deleteuser>(glocal.con,sessionid);
				<f ok>
					glocal.trlid_client.rep_deleteuser (email,confirmid);
				</f>
				</call>
			</f>
			<f confirmdelete>
				<call trli_writed_client_confirmdelete>(glocal.con,confirmid);
				<f ok>
					glocal.trlid_client.rep_confirmdelete(success,msg);
				</f>
				</call>
			</f>
			<f addnews>
				<call trli_writed_client_addnews>(glocal.con,sessionid,url,title,text);
				<f ok>
					glocal.trlid_client.rep_addnews (success,newsid,msg);
				</f>
				</call>
			</f>
			<f validnews>
				glocal bool success = false;
				glocal string newsid;
				<call sql_query>("select newsid_str from news where url='%s'",url);
				<f onerow>
					glocal.success = true;
					glocal.newsid = row[0];
				</f>
				</call>
				rep_validnews(glocal.success,glocal.newsid);
			</f>
			<f addproof>
				<call trli_writed_client_addproof>(glocal.con,sessionid,newsid,valid,type,title,text);
				<f ok>
					glocal.trlid_client.rep_addproof (success,proofid,msg);
				</f>
				</call>
			</f>
			<f addcomment>
				<call trli_writed_client_addcomment>(glocal.con,sessionid,proofid,vote,text);
				<f ok>
					glocal.trlid_client.rep_addcomment (success,commentid,msg);
				</f>
				</call>
			</f>
			<f addblogcomment>
				<call trli_writed_client_addblogcomment>(glocal.con,sessionid,blogid,content);
				<f ok>
					glocal.trlid_client.rep_addblogcomment (success,msg);
				</f>
				</call>
			</f>
			<f addargument> // sessionid newsid replyto title content = success:b msg
				<call trli_writed_client_addargument>(glocal.con,sessionid,newsid,replyto,title,content);
				<f ok>
					glocal.trlid_client.rep_addargument(success,msg,argid);
				</f>
				</call>
			</f>
			<f addnewsurl> // sessionid newsid url content = success:b msg
				<call trli_writed_client_addnewsurl>(glocal.con,sessionid,newsid,url,content);
				<f ok>
					glocal.trlid_client.rep_addnewsurl(success,msg);
				</f>
				</call>
			</f>
			<f listarguments> // listarguments newsid offset:u nb:u = argids:v nicknames:v replytos:v titles:v contents:v submits:v levels:vu
				glocal vector<string> argids;
				glocal vector<string> nicknames;
				glocal vector<string> replytos;
				glocal vector<string> titles;
				glocal vector<string> contents;
				glocal vector<string> submits;
				glocal vector<unsigned> levels;
				<call sql_query>("select argid_str,id2name.name"
					",(select t1.argid_str from arguments t1 where t1.argid=arguments.replyto) as replyto"
					",arguments.title,arguments.content,arguments.created,arguments.level from news"
					" join arguments on news.newsid=arguments.newsid"
					" join id2name on arguments.userid = id2name.userid"
					" where newsid_str='%s' order by pres_order limit %u,%u",newsid,offset,nb);
				<f onerow>
					glocal.argids.push_back(row[0]);
					glocal.nicknames.push_back(row[1]);
					glocal.replytos.push_back(row[2]==NULL ? "" : row[2]);
					glocal.titles.push_back(row[3]);
					glocal.contents.push_back(row[4]);
					glocal.submits.push_back(row[5]);
					glocal.levels.push_back(atoi(row[6]));
				</f>
				</call>
				rep_listarguments(glocal.argids,glocal.nicknames,glocal.replytos,glocal.titles,glocal.contents,glocal.submits,glocal.levels);
			</f>
			<f getargument> // argid = success:b nickname replyto title content submit level:u
				<call sql_query>("select id2name.name"
					",(select t1.argid_str from arguments t1 where t1.argid=arguments.replyto) as replyto"
					",arguments.title,arguments.content,arguments.created,arguments.level from arguments"
					" join id2name on arguments.userid = id2name.userid"
					" where argid_str='%s'",argid);
				<f onerow>
					glocal.trlid_client.rep_getargument(true,row[0],row[1]==NULL ? "" : row[1],row[2],row[3],row[4],atoi(row[5]));
				</f>
				<f empty>
					glocal.trlid_client.rep_getargument(false,"","","","","",0);
				</f>
				</call>
			</f>
			<f listnews>
				glocal vector<string> nicknames;
				glocal vector<string> newsids;
				glocal vector<string> titles;
				glocal vector<string> urls;
				glocal vector<string> contents;
				glocal vector<string> submits;
				glocal vector<unsigned> nbproofs;
				glocal vector<unsigned> nbcomments;
				glocal vector<int> verdicts;
				if (nb > 20) nb = 20;
				<call sql_query>("select newsid_str,title,url,content,approved,name,nbproofs,nbcomments,verdict from news join id2name on news.userid=id2name.userid"
					" where approved is not null order by approved desc,newsid desc limit %d,%d",offset,nb);
				<f onerow>
					glocal.newsids.push_back(row[0]);
					glocal.titles.push_back(row[1]);
					glocal.urls.push_back(row[2]);
					glocal.contents.push_back(row[3]);
					glocal.submits.push_back(row[4]);
					glocal.nicknames.push_back(row[5]);
					glocal.nbproofs.push_back(atoi(row[6]));
					glocal.nbcomments.push_back(atoi(row[7]));
					glocal.verdicts.push_back(atoi(row[8]));
				</f>
				</call>
				rep_listnews(glocal.nicknames,glocal.newsids,glocal.titles,glocal.urls,glocal.contents,glocal.submits
					,glocal.nbproofs,glocal.nbcomments,glocal.verdicts);
			</f>
			<f listnews_v1>
				glocal vector<string> nicknames;
				glocal vector<string> newsids;
				glocal vector<string> titles;
				glocal vector<string> urls;
				glocal vector<string> contents;
				glocal vector<string> submits;
				glocal vector<unsigned> nbproofs;
				glocal vector<unsigned> nbcomments;
				glocal vector<int> verdicts;
				if (nb > 20) nb = 20;
				string joinsub;
				if (subject != 0){
					joinsub = string_f (" join subnews on subnews.newsid=news.newsid and subnews.subjectid=%u",subject);
				}
				<call sql_query>("select newsid_str,title,url,content,approved,name,nbproofs,nbcomments,verdict"
					" from news join id2name on news.userid=id2name.userid"
					"%s"
					" where approved is not null order by approved desc,news.newsid desc limit %d,%d",joinsub.c_str(),offset,nb);
				<f onerow>
					glocal.newsids.push_back(row[0]);
					glocal.titles.push_back(row[1]);
					glocal.urls.push_back(row[2]);
					glocal.contents.push_back(row[3]);
					glocal.submits.push_back(row[4]);
					glocal.nicknames.push_back(row[5]);
					glocal.nbproofs.push_back(atoi(row[6]));
					glocal.nbcomments.push_back(atoi(row[7]));
					glocal.verdicts.push_back(atoi(row[8]));
				</f>
				</call>
				rep_listnews_v1(glocal.nicknames,glocal.newsids,glocal.titles,glocal.urls,glocal.contents,glocal.submits
					,glocal.nbproofs,glocal.nbcomments,glocal.verdicts);
			</f>
			<f listnews_v2>
				glocal vector<string> nicknames;
				glocal vector<string> newsids;
				glocal vector<string> titles;
				glocal vector<string> urls;
				glocal vector<string> contents;
				glocal vector<string> submits;
				glocal vector<unsigned> nbproofs;
				glocal vector<unsigned> nbcomments;
				glocal vector<int> verdicts;
				glocal vector<unsigned> nbarguments;
				if (nb > 20) nb = 20;
				string joinsub;
				if (subject != 0){
					joinsub = string_f (" join subnews on subnews.newsid=news.newsid and subnews.subjectid=%u",subject);
				}
				<call sql_query>("select newsid_str,title,url,content,approved,name,nbproofs,nbcomments,verdict,nbarguments"
					" from news join id2name on news.userid=id2name.userid"
					"%s"
					" where approved is not null order by approved desc,news.newsid desc limit %d,%d",joinsub.c_str(),offset,nb);
				<f onerow>
					glocal.newsids.push_back(row[0]);
					glocal.titles.push_back(row[1]);
					glocal.urls.push_back(row[2]);
					glocal.contents.push_back(row[3]);
					glocal.submits.push_back(row[4]);
					glocal.nicknames.push_back(row[5]);
					glocal.nbproofs.push_back(atoi(row[6]));
					glocal.nbcomments.push_back(atoi(row[7]));
					glocal.verdicts.push_back(atoi(row[8]));
					glocal.nbarguments.push_back(atoi(row[9]));
				</f>
				</call>
				rep_listnews_v2(glocal.nicknames,glocal.newsids,glocal.titles,glocal.urls,glocal.contents,glocal.submits
					,glocal.nbproofs,glocal.nbcomments,glocal.verdicts,glocal.nbarguments);
			</f>
			<f listnews_v3>
				glocal vector<string> nicknames;
				glocal vector<string> newsids;
				glocal vector<string> titles;
				glocal vector<string> urls;
				glocal vector<string> contents;
				glocal vector<string> submits;
				glocal vector<unsigned> nbproofs;
				glocal vector<unsigned> nbcomments;
				glocal vector<int> verdicts;
				glocal vector<unsigned> nbarguments;
				glocal vector<unsigned> nbextraurls;
				if (nb > 20) nb = 20;
				string joinsub;
				if (subject != 0){
					joinsub = string_f (" join subnews on subnews.newsid=news.newsid and subnews.subjectid=%u",subject);
				}
				<call sql_query>("select newsid_str,title,url,content,approved,name,nbproofs,nbcomments,verdict,nbarguments"
					",(select count(*) from extraurls where extraurls.newsid=news.newsid and extraurls.approved is not null) as nbextraurls"
					" from news join id2name on news.userid=id2name.userid"
					"%s"
					" where approved is not null order by approved desc,news.newsid desc limit %d,%d",joinsub.c_str(),offset,nb);
				<f onerow>
					glocal.newsids.push_back(row[0]);
					glocal.titles.push_back(row[1]);
					glocal.urls.push_back(row[2]);
					glocal.contents.push_back(row[3]);
					glocal.submits.push_back(row[4]);
					glocal.nicknames.push_back(row[5]);
					glocal.nbproofs.push_back(atoi(row[6]));
					glocal.nbcomments.push_back(atoi(row[7]));
					glocal.verdicts.push_back(atoi(row[8]));
					glocal.nbarguments.push_back(atoi(row[9]));
					glocal.nbextraurls.push_back(atoi(row[10]));
				</f>
				</call>
				rep_listnews_v3(glocal.nicknames,glocal.newsids,glocal.titles,glocal.urls,glocal.contents,glocal.submits
					,glocal.nbproofs,glocal.nbcomments,glocal.verdicts,glocal.nbarguments,glocal.nbextraurls);
			</f>
			<f listnews_v4>
				glocal vector<string> nicknames;
				glocal vector<string> newsids;
				glocal vector<string> titles;
				glocal vector<string> urls;
				glocal vector<string> contents;
				glocal vector<string> submits;
				glocal vector<unsigned> nbproofs;
				glocal vector<unsigned> nbcomments;
				glocal vector<int> verdicts;
				glocal vector<unsigned> nbarguments;
				glocal vector<unsigned> nbextraurls;
				if (nb > 20) nb = 20;
				string joinsub;
				if (subject != 0){
					joinsub = string_f (" join subnews on subnews.newsid=news.newsid and subnews.subjectid=%u",subject);
				}
				const char *order_field = order ? "approved" : "updated"; 
				<call sql_query>("select newsid_str,title,url,content,approved,name,nbproofs,nbcomments,verdict,nbarguments"
					",(select count(*) from extraurls where extraurls.newsid=news.newsid and extraurls.approved is not null) as nbextraurls"
					" from news join id2name on news.userid=id2name.userid"
					"%s"
					" where approved is not null order by %s desc,news.newsid desc limit %d,%d",joinsub.c_str(),order_field,offset,nb);
				<f onerow>
					glocal.newsids.push_back(row[0]);
					glocal.titles.push_back(row[1]);
					glocal.urls.push_back(row[2]);
					glocal.contents.push_back(row[3]);
					glocal.submits.push_back(row[4]);
					glocal.nicknames.push_back(row[5]);
					glocal.nbproofs.push_back(atoi(row[6]));
					glocal.nbcomments.push_back(atoi(row[7]));
					glocal.verdicts.push_back(atoi(row[8]));
					glocal.nbarguments.push_back(atoi(row[9]));
					glocal.nbextraurls.push_back(atoi(row[10]));
				</f>
				</call>
				rep_listnews_v3(glocal.nicknames,glocal.newsids,glocal.titles,glocal.urls,glocal.contents,glocal.submits
					,glocal.nbproofs,glocal.nbcomments,glocal.verdicts,glocal.nbarguments,glocal.nbextraurls);
			</f>
			<f listsubjects>
				glocal vector<unsigned> ids;
				glocal vector<string> texts;
				<call sql_query>("select subjectid,text from subjects");
				<f onerow>
					glocal.ids.push_back(atoi(row[0]));
					glocal.texts.push_back(row[1]);
				</f>
				</call>
				rep_listsubjects(glocal.ids,glocal.texts);
			</f>
			<f getnews>
				<call sql_query>("select name,title,url,content,approved,nbproofs,nbcomments,verdict from news join id2name on news.userid=id2name.userid where newsid_str='%s'",newsid);
				<f onerow>
					glocal.trlid_client.rep_getnews(true,row[0],row[1],row[2],row[3],row[4],atoi(row[5]),atoi(row[6]),atoi(row[7]));
				</f>
				<f empty>
					glocal.trlid_client.rep_getnews(false,"","","","","",0,0,0);
				</f>
				</call>
			</f>
			<f getnews_v2>
				<call sql_query>("select name,title,url,content,approved,nbproofs,nbcomments,verdict,nbarguments from news join id2name on news.userid=id2name.userid where newsid_str='%s'",newsid);
				<f onerow>
					glocal.trlid_client.rep_getnews_v2(true,row[0],row[1],row[2],row[3],row[4],atoi(row[5]),atoi(row[6]),atoi(row[7]),atoi(row[8]));
				</f>
				<f empty>
					glocal.trlid_client.rep_getnews_v2(false,"","","","","",0,0,0,0);
				</f>
				</call>
			</f>
			<f getnews_v3>
				<call sql_query>("select name,title,url,content,approved,nbproofs,nbcomments,verdict,nbarguments"
					",(select count(*) from extraurls where extraurls.newsid=news.newsid and extraurls.approved is not null) as nbextraurls"
					" from news join id2name on news.userid=id2name.userid where newsid_str='%s'",newsid);
				<f onerow>
					glocal.trlid_client.rep_getnews_v3(true,row[0],row[1],row[2],row[3],row[4],atoi(row[5]),atoi(row[6]),atoi(row[7]),atoi(row[8]),atoi(row[9]));
				</f>
				<f empty>
					glocal.trlid_client.rep_getnews_v3(false,"","","","","",0,0,0,0,0);
				</f>
				</call>
			</f>
			<f getproof>
				<call sql_query>("select name,valid,type,title,content,created,nbcomments from proofs join id2name on proofs.userid=id2name.userid where proofid_str='%s'",proofid);
				<f onerow>
					glocal.trlid_client.rep_getproof(true,row[0],atoi(row[1]),atoi(row[2]),row[3],row[4],row[5],atoi(row[6]));
				</f>
				<f empty>
					glocal.trlid_client.rep_getproof(false,"",0,0,"","","",0);
				</f>
				</call>
			</f>
			<f getproofuser>
				glocal const char *newsid = newsid;
				<call trli_sessiond_client_getsessioninfo>(glocal.con_sess,sessionid);
				<f ok>
					debug_printf ("getsessioninfo success=%d userid=%u\n",success,userid);
					if (success){
						<call sql_query>("select valid,type,proofs.title,proofs.content,proofs.created from proofs join news on proofs.newsid=news.newsid"
							" where proofs.userid=%u and newsid_str='%s'",userid,glocal.newsid);
						<f onerow>
							glocal.trlid_client.rep_getproofuser(true,atoi(row[0]),atoi(row[1]),row[2],row[3],row[4]);
						</f>
						<f empty>
							glocal.trlid_client.rep_getproofuser(false,0,0,"","","");
						</f>
						</call>
					}else{
						glocal.trlid_client.rep_getproofuser(false,0,0,"","","");
					}
				</f>
				</call>
			</f>
			<f getcomment>
				<call sql_query>("select name,vote,content,created from comments join id2name on comments.userid=id2name.userid where commentid_str='%s'",commentid);
				<f onerow>
					glocal.trlid_client.rep_getcomment(true,row[0],atoi(row[1]),row[2],row[3]);
				</f>
				<f empty>
					glocal.trlid_client.rep_getcomment(false,"",0,"","");
				</f>
				</call>
			</f>
			<f getcommentuser>
				glocal const char *proofid = proofid;
				<call trli_sessiond_client_getsessioninfo>(glocal.con_sess,sessionid);
				<f ok>
					if (success){
						<call sql_query>("select vote,comments.content,comments.created from comments join proofs on comments.proofid=proofs.proofid"
							" where comments.userid=%u and proofid_str='%s'",userid,glocal.proofid);
						<f onerow>
							glocal.trlid_client.rep_getcommentuser(true,atoi(row[0]),row[1],row[2]);
						</f>
						<f empty>
							glocal.trlid_client.rep_getcommentuser(false,0,"","");
						</f>
						</call>
					}else{
						glocal.trlid_client.rep_getcommentuser(false,0,"","");
					}
				</f>
				</call>
			</f>
			<f listproofs>
				glocal vector<string> nicknames;
				glocal vector<string> proofids;
				glocal vector<string> newsids;
				glocal vector<string> titles;
				glocal vector<string> contents;
				glocal vector<string> submits;
				glocal vector<unsigned> valids;
				glocal vector<unsigned> types;
				glocal vector<unsigned> nbcomments;
				if (nb > 20) nb = 20;
				<call sql_query>("select name,proofid_str,newsid_str,proofs.title,proofs.content,proofs.created,valid,type,proofs.nbcomments"
					" from proofs join news on proofs.newsid=news.newsid"
					"      join id2name on proofs.userid=id2name.userid"
					" where newsid_str='%s' and proofs.newsid=news.newsid limit %d,%d",newsid,offset,nb);
				<f onerow>
					glocal.nicknames.push_back(row[0]);
					glocal.proofids.push_back(row[1]);
					glocal.newsids.push_back(row[2]);
					glocal.titles.push_back(row[3]);
					glocal.contents.push_back(row[4]);
					glocal.submits.push_back(row[5]);
					glocal.valids.push_back(atoi(row[6]));
					glocal.types.push_back(atoi(row[7]));
					glocal.nbcomments.push_back(atoi(row[8]));
				</f>
				</call>
				rep_listproofs (glocal.nicknames,glocal.proofids,glocal.newsids,glocal.submits,glocal.valids,glocal.types,glocal.titles,glocal.contents,glocal.nbcomments);
			</f>
			<f listcomments>
				glocal vector<string> nicknames;
				glocal vector<string> commentids;
				glocal vector<string> proofids;
				glocal vector<unsigned> votes;
				glocal vector<string> contents;
				glocal vector<string> submits;
				if (nb > 20) nb = 20;
				<call sql_query>("select name,commentid_str,proofid_str,comments.vote,comments.content,comments.created"
					" from comments join proofs on comments.proofid=proofs.proofid"
					"      join id2name on id2name.userid=comments.userid"
					" where proofid_str='%s' limit %d,%d",proofid,offset,nb);
				<f onerow>
					glocal.nicknames.push_back(row[0]);
					glocal.commentids.push_back(row[1]);
					glocal.proofids.push_back(row[2]);
					glocal.votes.push_back(atoi(row[3]));
					glocal.contents.push_back(row[4]);
					glocal.submits.push_back(row[5]);
				</f>
				</call>
				rep_listcomments (glocal.nicknames,glocal.commentids,glocal.proofids,glocal.votes,glocal.contents,glocal.submits);
			</f>
			<f getblog> // blogid = success:b title content submit
				<call sql_query>("select title,content,created"
					" from blog where blogid_str = '%s'",blogid);
				<f onerow>
					glocal.trlid_client.rep_getblog (true,row[0],row[1],row[2]);
				</f>
				<f empty>
					glocal.trlid_client.rep_getblog (false,"","","");
				</f>
				</call>
			</f>
			<f getblogcomment> // sessionid blogid = success:b content submit
				glocal const char *blogid = blogid;
				<call trli_sessiond_client_getsessioninfo>(glocal.con_sess,sessionid);
				<f ok>
					debug_printf ("getsessioninfo success=%d userid=%u\n",success,userid);
					if (success){
						<call sql_query>("select blogcomments.content,blogcomments.created"
							" from blog join blogcomments on blog.blogid = blogcomments.blogid and blogcomments.userid=%u"
							" where blogid_str = '%s'",userid,glocal.blogid);
						<f onerow>
							glocal.trlid_client.rep_getblogcomment (true,row[0],row[1]);
						</f>
						<f empty>
							glocal.trlid_client.rep_getblogcomment (false,"","");
						</f>
						</call>
					}else{
						glocal.trlid_client.rep_getblogcomment (false,"","");
					}
				</f>
				</call>
			</f>
			<f listblogs> // offset:u nb:u order:u = blogids:v titles:v contents:v submits:v nbcomments:uv
				const char *desc = order ? "" : "desc";
				if (nb > 20) nb = 20;
				glocal vector<string> blogids;
				glocal vector<string> titles;
				glocal vector<string> contents;
				glocal vector<string> createds;
				glocal vector<unsigned> nbcomments;
				<call sql_query>("select blogid_str,title,content,created"
					",(select count(*) from blogcomments where blogid=blog.blogid)"
					" from blog order by created %s limit %u,%u"
					,desc,offset,nb);
				<f onerow>
					glocal.blogids.push_back(row[0]);
					glocal.titles.push_back(row[1]);
					glocal.contents.push_back(row[2]);
					glocal.createds.push_back(row[3]);
					glocal.nbcomments.push_back(atoi(row[4]));
				</f>
				</call>
				rep_listblogs (glocal.blogids,glocal.titles,glocal.contents,glocal.createds,glocal.nbcomments);
			</f>
			<f listblogcomments> // blogid offset:u nb:u = nicknames:v contents:v submits:v
				if (nb > 20) nb = 20;
				glocal vector<string> nicknames;
				glocal vector<string> contents;
				glocal vector<string> submits;
				<call sql_query>("select id2name.name,blogcomments.content,blogcomments.created from blog"
					" join blogcomments on blog.blogid=blogcomments.blogid"
					" join id2name on blogcomments.userid=id2name.userid"
					" where blog.blogid_str='%s' limit %u,%u",blogid,offset,nb);
				<f onerow>
					glocal.nicknames.push_back(row[0]);
					glocal.contents.push_back(row[1]);
					glocal.submits.push_back(row[2]);
				</f>
				</call>
				rep_listblogcomments (glocal.nicknames,glocal.contents,glocal.submits);
			</f>
			<f getstats> // offset:u nb:u = newsids:v urls:v subjects:vv nbproofs:vu nbcomments:vu nbarguments:vu vecdict:vi
				glocal vector<string> newsids;
				glocal vector<string> urls;
				glocal vector<string> submits;
				glocal vector<string> titles;
				glocal vector<vector<string>> subjects;
				glocal vector<unsigned> nbproofs;
				glocal vector<unsigned> nbcomments;
				glocal vector<unsigned> nbarguments;
				glocal vector<int> verdicts;
				<call sql_query>("select newsid,newsid_str,url,nbproofs,nbcomments,nbarguments,verdict,created,title from news order by newsid limit %u,%u",offset,nb);
				<f onerow>
					glocal.newsids.push_back(row[1]);
					glocal.urls.push_back(row[2]);
					glocal.nbproofs.push_back(atoi(row[3]));
					glocal.nbcomments.push_back(atoi(row[4]));
					glocal.nbarguments.push_back(atoi(row[5]));
					glocal.verdicts.push_back(atoi(row[6]));
					glocal.submits.push_back(row[7]);
					glocal.titles.push_back(row[8]);
					glocal vector<string> subs;
					<call sql_query>("select subjects.text from subnews join subjects on subnews.subjectid=subjects.subjectid where newsid=%s",row[0]);
					<f onerow>
						glocal.subs.push_back(row[0]);
					</f>
					</call>
					glocal.subjects.push_back(glocal.subs);
				</f>
				</call>
				rep_getstats (glocal.newsids,glocal.urls,glocal.submits,glocal.titles,glocal.subjects,glocal.nbproofs,glocal.nbcomments,glocal.nbarguments,glocal.verdicts);
			</f>
			<f getextraurls> // newsid = urls:v contents:v submits:v nicknames:v
				glocal unsigned offset = offset;
				glocal unsigned nb = nb;
				glocal vector<string> urls;
				glocal vector<string> contents;
				glocal vector<string> submits;
				glocal vector<string> nicknames;
				<call sql_query>("select newsid from  news where newsid_str='%s'",newsid);
				<f onerow>
					<call sql_query>("select extraurls.url,extraurls.content,extraurls.created,id2name.name"
						" from extraurls join id2name on extraurls.userid=id2name.userid"
						" where newsid=%s and approved is not null order by created limit %u,%u",row[0],glocal.offset,glocal.nb);
					<f onerow>
						glocal.urls.push_back(row[0]);
						glocal.contents.push_back(row[1]);
						glocal.submits.push_back(row[2]);
						glocal.nicknames.push_back(row[3]);
					</f>
					</call>
				</f>
				</call>
				rep_getextraurls (glocal.urls,glocal.contents,glocal.submits,glocal.nicknames);
			</f>
			<f validextraurl> // newsid url = success:b msg
				glocal const char *url = url;
				glocal bool success = false;
				glocal string msg;
				<call sql_query>("select newsid from  news where newsid_str='%s'",newsid);
				<f onerow>
					<call sql_query>("select url from extraurls"
						" where newsid=%s and url='%s'",row[0],glocal.url);
					<f onerow>
						glocal.msg = "Already exist";
					</f>
					<f empty>
						glocal.success = true;
					</f>
					</call>
				</f>
				</call>
				rep_validextraurl (glocal.success,glocal.msg);
			</f>
			<f invalid>
				tlmp_error ("CLIENT: Invalid command: %s\n",line);
				endclient = true;
			</f>
			</call>
		}else if (c->type == TYPE_ADMIN){
			glocal.nbrequest_admin++;
			<call trlid_admin>(this,c->req,line, info.linelen,endserver, endclient, no,c,c->host.c_str());
			<f listauthor>
				// listauthor sessionid offset:u nb:u = authorid author
				<call trli_writed_client_listauthor>(glocal.con,sessionid,offset,nb);
				<f ok>
					vector<string> ids,names;
					for (unsigned i=0; i<authorid.size(); i++){
						ids.push_back(authorid[i]);
						names.push_back(author[i]);
					}
					glocal.trlid_admin.rep_listauthor(ids,names);
				</f>
				</call>
			</f>
			<f searchauthor>
				// searchauthor sessionid name = authorid author
				<call trli_writed_client_searchauthor>(glocal.con,sessionid,name);
				<f ok>
					glocal.trlid_admin.rep_searchauthor(authorid,author);
				</f>
				</call>
			</f>
			<f listnewnews>
				// listnewnews sessionid offset nb = newsids:v
				<call trli_writed_client_listnewnews>(glocal.con,sessionid,offset,nb);
				<f ok>
					vector<string> ids;
					for (auto n:newsids) ids.push_back(n);
					glocal.trlid_admin.rep_listnewnews(success,ids);
				</f>
				</call>
			</f>
			<f rejectnews>
				// rejectnews sessionid newsid = success:b msg
				<call trli_writed_client_rejectnews>(glocal.con,sessionid,newsid);
				<f ok>
					glocal.trlid_admin.rep_rejectnews(success,msg);
				</f>
				</call>
			</f>
			<f approvenews>
				// approvenews sessionid newsid = success:b msg
				<call trli_writed_client_approvenews>(glocal.con,sessionid,newsid);
				<f ok>
					glocal.trlid_admin.rep_approvenews(success,msg);
				</f>
				</call>
			</f>
			<f modifynews>
				// modifynews sessionid newsid content = success:b msg
				<call trli_writed_client_modifynews>(glocal.con,sessionid,newsid,content);
				<f ok>
					glocal.trlid_admin.rep_modifynews(success,msg);
				</f>
				</call>
			</f>
			<f getnewnews>
				glocal const char *newsid = newsid;
				// success:b nickname title url content submit
				<call trli_sessiond_client_getsessioninfo>(glocal.con_sess,sessionid);
				<f ok>
					debug_printf ("getsessioninfo success=%d userid=%u admin=%d\n",success,userid,admin);
					if (success && admin){
						<call sql_query>("select id2name.name,title,url,content,created from news join id2name on news.userid=id2name.userid"
							" where news.newsid_str='%s' and approved is null and rejected is null",glocal.newsid);
						<f onerow>
							glocal.trlid_admin.rep_getnewnews(true,row[0],row[1],row[2],row[3],row[4]);
						</f>
						<f empty>
							glocal.trlid_admin.rep_getnewnews(false,"","","","","");
						</f>
						</call>
					}
				</f>
				</call>
			</f>
			<f addblog>
				<call trli_writed_client_addblog>(glocal.con,sessionid,blogid,title,content,created);
				<f ok>
					glocal.trlid_admin.rep_addblog (success,msg);
				</f>
				</call>
			</f>
			<f assignsubjects> // sessionid newsid subjects:v = success:b
				<call trli_writed_client_assignsubjects>(glocal.con,sessionid,newsid,subjects);
				<f ok>
					glocal.trlid_admin.rep_assignsubjects(success,msg);
				</f>
				</call>
			</f>
			<f approvenewsurl> // sessionid newsid url = success:b msg
				<call trli_writed_client_approvenewsurl>(glocal.con,sessionid,newsid,url);
				<f ok>
					glocal.trlid_admin.rep_approvenewsurl(success,msg);
				</f>
				</call>
			</f>
			<f listnewnewsurl> // sessionid offset:u nb:u = success:b newsids:v urls:vv
				glocal unsigned offset = offset;
				glocal unsigned last = offset+nb;
				glocal bool success = false;
				glocal vector<string> newsids;
				glocal vector<vector<string>> urls;
				<call trli_sessiond_client_getsessioninfo>(glocal.con_sess,sessionid);
				<f ok>
					if (success && admin){
						glocal map<string,vector<string>> newsurls;
						<call sql_query>("select newsid_str,extraurls.url from extraurls"
							" join news on extraurls.newsid=news.newsid"
							" where extraurls.approved is null");
						<f onerow>
							glocal.newsurls[row[0]].push_back(row[1]);
						</f>
						</call>
						unsigned pos = 0;
						for (auto nu:glocal.newsurls){
							if (pos >= glocal.offset && pos < glocal.last){
								glocal.newsids.push_back(nu.first);
								glocal.urls.push_back(nu.second);
							}
						}
						glocal.success = true;
					}
							
				</f>
				</call>
				rep_listnewnewsurl (glocal.success,glocal.newsids,glocal.urls);
			</f>
			<f test>
				glocal bool sessiond1=false;
				glocal bool sessiond2=false;
				glocal bool writed = false;
				glocal bool bdtrli1 = false;
				glocal bool bdtrli2 = false;
				glocal bool bdusers = false;
				glocal bool internal_error1 = false;
				glocal bool compute = false;
				<call trli_sessiond_client_test>(glocal.con_sess);
				<f ok>
					glocal.internal_error1 = internal_error;
					glocal.sessiond1 = success;
				</f>
				</call>
				<call trli_writed_client_test>(glocal.con);
				<f ok>
					glocal.writed = !internal_error;
					glocal.sessiond2 = sessiond;
					glocal.bdusers = bdusers;
					glocal.bdtrli2 = bdtrli;
					glocal.compute = compute;
				</f>
				</call>
				<call sql_query>("select count(*) from id2name");
				<f onerow>
					glocal.bdtrli1=true;
				</f>
				</call>
				glocal.trlid_admin.rep_test(glocal.internal_error1
					,glocal.writed,glocal.bdtrli1,glocal.bdtrli2,glocal.bdusers
					,glocal.sessiond1,glocal.sessiond2,glocal.compute);
			</f>
			<f invalid>
				tlmp_error ("ADMIN: Invalid command: %s\n",line);
				endclient = true;
			</f>
			</call>
		}
	</f>
	</obj>
	bool some_errors = false;
	if (control != NULL && fdpass_setcontrol(s,control,user)==-1){
		some_errors = true;
	}
	if (s.listen(NULL,glocal.unixportadmin)==-1){
		tlmp_error ("Can't setup socket on %s (%s)\n",glocal.unixportadmin.c_str(),strerror(errno));
		some_errors = true;
	}


	if (!some_errors && s.is_ok()){
		chmod (glocal.unixportclient.c_str()+5,0666);
		chmod (glocal.unixportadmin.c_str()+5,0666);
		s.setrawmode (true);
		if (daemon){
			daemon_init(pidfile,user);
		}
		s.loop();
		ret = 0;
	}
	return ret;
}
</mod>
<mod>
int main (int argc, char *argv[])
{
	glocal int ret = -1;
	glocal const char *admin_secretfile = "/etc/trli/secrets.admin";
	glocal const char *client_secretfile = "/etc/trli/secrets.client";
	glocal const char *bind = "0.0.0.0";
	glocal const char *port = "9000";
	glocal const char *control = "/var/run/trlid.sock";
	glocal const char *adminhost = "127.0.0.3";
	glocal const char *adminport = "9100";
	glocal const char *sesshost = "127.0.0.4";
	glocal const char *sessport = "9200";
	glocal const char *user = "trli";
	glocal const char *mysecret = NULL;
	glocal const char *dbserv = "localhost";
	glocal const char *dbname = "trli";
	glocal const char *dbuser = NULL;
	glocal const char *sql_tcpport = NULL;
	glocal bool daemon = false;
	glocal int workers = 1;
	glocal const char *pidfile = "/var/run/trlid.pid";

	signal (SIGPIPE,SIG_IGN);
	glocal.ret = <call tlmpprogram>(argc,argv,"tlmpsql");
	<f init>
		setproginfo ("trlid",VERSION,"Implement all business logic");
		setgrouparg ("Networking");
		setarg ('b',"bindaddr","Bind to this address (TCP)",glocal.bind,false);
		setarg ('p',"tcpport","Listen for command on this TCP port",glocal.port,false);
		setarg ('c',"control","Unix socket for trlid-control",glocal.control,false);
		setgrouparg ("Admin server");
		setarg (' ',"adminhost","Host running the trli-writed server",glocal.adminhost,false);
		setarg (' ',"adminport","Port to reach the trli-writed server",glocal.adminport,false);
		setarg (' ',"sesshost","Host running the trli-sessiond server",glocal.sesshost,false);
		setarg (' ',"sessport","Port to reach the trli-sessiond server",glocal.sessport,false);
		setarg (' ',"mysecret","Secret used to communicate with trli-writed",glocal.mysecret,true);
		setgrouparg ("Misc.");
		setarg (' ',"admin_secrets","File holding admin secrets for communication",glocal.admin_secretfile,false);
		setarg (' ',"client_secrets","File holding client secrets for communication",glocal.client_secretfile,false);
		setarg (' ',"user","Run the program as this user",glocal.user,false);
		setarg (' ',"daemon","Run in background",glocal.daemon,false);
		setarg (' ',"workers","Number of sub-process to lauch",glocal.workers,false);
		setarg (' ',"pidfile","FIle holding the PID of the process",glocal.pidfile,false);
		setgrouparg ("Database");
		setarg (' ',"dbserv","Database server",glocal.dbserv,false);
		setarg (' ',"dbname","Database name",glocal.dbname,false);
		setarg (' ',"dbuser","Database user",glocal.dbuser,true);
		setarg (' ',"sqltcpport","Database TCP port",glocal.sql_tcpport,false);
	</f>
	<f showerror>
		glocal const char *msg = msg;
		<call savefile>("/tmp/err.log",true);
		<f dowrite>
			fprintf (fout,"%s\n",glocal.msg);
			return 0;
		</f>
		</call>
		if (glocal.daemon){
			syslog (LOG_ERR,"%s",msg);
		}else{
			fprintf (stderr,"%s",msg);
		}
	</f>
	<f showwarn>
		if (glocal.daemon){
			syslog (LOG_WARNING,"%s",msg);
		}else{
			fprintf (stderr,"%s",msg);
		}
	</f>
	<f main_noarg>
		glocal CONNECT_INFO con;
		glocal CONNECT_INFO con_sess;
		glocal map<string,string> admin_secrets;
		glocal map<string,string> client_secrets;
		fdpass_readsecrets (glocal.client_secretfile,glocal.client_secrets);
		fdpass_readsecrets (glocal.admin_secretfile,glocal.admin_secrets);
		//glocal.con.host = glocal.adminhost;
		glocal.con.port = glocal.adminport;
		glocal.con.secret = glocal.mysecret;
		glocal.con.bind = glocal.bind;
		//glocal.con_sess.host = glocal.sesshost;
		glocal.con_sess.port = glocal.sessport;
		glocal.con_sess.secret = glocal.mysecret;
		glocal.con_sess.bind = glocal.bind;
		if (glocal.sql_tcpport != NULL) nsql_settcpport (atoi(glocal.sql_tcpport));
		{
			const char *dbpass = getenv("TRLID_PWD");
			if (dbpass == NULL){
				tlmp_error ("Can't get database password from environment,aborting\n");
				exit (-1);
			}
			query_setdefaultdb (glocal.dbserv,glocal.dbname,glocal.dbuser,dbpass);
		}

		int ret = -1;
		if (glocal.workers==1){
			ret = trlid_main (glocal.bind,glocal.port,glocal.control
				,glocal.con,glocal.con_sess,glocal.user,glocal.pidfile,glocal.daemon
				,glocal.admin_secrets,glocal.client_secrets);
		}else{
			int port = atoi(glocal.port);
			for (int w=0; w<glocal.workers; w++){
				char portstr[10];
				snprintf (portstr,sizeof(portstr)-1,"%d",port+w);
				string control = string(glocal.control) + string_f("+%d",w);
				pid_t pid = fork();
				if (pid == (pid_t)0){
					ret = trlid_main (glocal.bind,portstr,control.c_str()
						,glocal.con,glocal.con_sess,glocal.user,glocal.pidfile,false
						,glocal.admin_secrets,glocal.client_secrets);
				}else if (pid == (pid_t)-1){
					tlmp_error("Can't fork (%s), aborting\n",strerror(errno));
					exit (-1);
				}else{
				}
			}
		}

		return ret;
	</f>
	</call>
	return glocal.ret;
}
</mod>