//
//    СЕРВЕР Olimp 1.01
//

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <netdb.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <signal.h>
#include <fcntl.h>
#include <mysql/mysql.h>
#include <strings.h>
#include <time.h>
#include <wait.h>
#include <sys/resource.h>

#include <grp.h>
#include <pwd.h>

#include "sql.h"
#include "version.h"
#include "logger.h"

#define SERV_PORT 	777		
#define SERV_EXE	"in.olimpd"
#define CfgName		"olimpd.cfg"
#define MAXFILES	20

/******************** флаги для run_process () ********************/

#define F_DUPSOCK   1
#define F_CLOSEALL  2

/******************** глобальные переменные ********************/
uid_t serv_uid=500;
gid_t serv_gid=500;

char buf[2 * 1024];		// буфер, используется для всяких непотребных целей
int sock, nsock;		// служебные сокеты
int numproc = 0;		// текущее количество работающих процессов

char LogRecord[1024];

//фильтр IP
#define ALLOW_IP_MAX	50
#define ALLOW_IP_LENGTH 20
#define DENY_IP_MAX	50
#define DENY_IP_LENGTH	20

int	order_ad=1;
int	allow_ip_cnt=0;
char	allow_ip[ALLOW_IP_MAX][ALLOW_IP_LENGTH+1];
int	deny_ip_cnt=0;
char	deny_ip[DENY_IP_MAX][DENY_IP_LENGTH+1];

int ip_allowed(char *ip);
int ip_denied(char *ip);
int CheckIP(char *ip);


#define PROC_DESCR_MAX 100
struct _procdescr{
  pid_t		pid;
  char		IP[20];
};
typedef struct _procdescr procdescr;

procdescr ProcDescrs[PROC_DESCR_MAX];

//config для olimpd
int	maxproc=20;	
int	maxproc4ip=2;
int	servtimelimit=300;

char	workdir[256];	
char	rundir[256];	
char	cfgdir[256];	


/******************** прототипы функций ********************/

void init();			  	
void run_process(char *name, int flags, char *ip);
void onSigChld(int i);
void onSigHup(int i);
void onSigAlrm(int i);
void ShowLimits();
void reply(int nsock, int code, char *msg);

//---------------------- Надежный вариант функции signal
void (*rel_signal(int signo, void (*hndlr)(int)))(int)
{ 
  struct sigaction act,oact;
  
  act.sa_handler=hndlr;
  sigemptyset(&act.sa_mask);
  act.sa_flags=0;
  act.sa_flags |= SA_RESTART;
  
  if (sigaction(signo,&act,&oact)<0)
     return(SIG_ERR);
  return (oact.sa_handler);
}

//---------------------- long => "число.число.число.число"
void long2IP(long l, char *IP){
  unsigned char *c=&l;
  
  sprintf(IP,"%d.%d.%d.%d",c[0],c[1],c[2],c[3]);
}

//-----------------------Проверка процессов на одинаковый IP
int CheckProc4IP(char *ip){
  int i,cnt;
  
  for(i=0,cnt=0; i<maxproc; i++){
    if((ProcDescrs[i].pid>0) && (!strcmp(ip,ProcDescrs[i].IP))) cnt++;
  }
  
  if(cnt>=maxproc4ip) return 1;
  else return 0;
}

//----------------Получение базового, рабочего, и каталога конфига
void GetDirs(char *base, char *workdir, char *cfgdir){
  int i;

  workdir[0]=0;
  strcpy(workdir,base);
  
  //удалить имя программы
  for(i=strlen(workdir)-1; i>=0 && workdir[i]!='/'; i--);
  if(i>=0) workdir[i]=0;
  else workdir[0]=0;
  
  strcat(workdir,"/");
  if(!strcmp(workdir,"./") || !strcmp(workdir,"/")) workdir[0]=0;
  
  sprintf(cfgdir,"%s../etc/",workdir);
  
  if(!workdir[0]) strcpy(workdir,"./");
}  

//----------------------Посылка ответа в виде "Код - расшифровка"
void reply(int nsock, int code, char *msg){
  char buf[256];

  sprintf(buf,"%d - %s\n",code,msg);
  write(nsock,buf,strlen(buf));
}

//----------------------Главное
main (int argc, char **argv){
  int addrlen, child, i, errcode;
  struct sockaddr_in tmp1;
  char IP[30];
  char fname[256];

//Получить каталоги из командной строки
  GetDirs(argv[0],rundir,cfgdir);  
  
//Начать серверный лог
  strcpy (argv[0], "olimp: kernel");
  open_log(DEFAULT_LOG);
  chown(DEFAULT_LOG,serv_uid,serv_gid);
  
//temporary
  strcpy(workdir,"/tmp/olimp");

  init();

//ДО БЕСКОНЕЧНОСТИ
  listen (sock, 5);
  while(1){
    //сокет для ответов клиентам создаётся
    close (nsock);
    addrlen=sizeof(tmp1);
    //!busy! Обработка состояния Server is busy
    while(numproc >= maxproc);
    
    nsock = accept (sock, (struct sockaddr *) &tmp1, &addrlen);
    //если ошибка создания сокета - заново
    if (nsock < 0){
      //if (errno != EINTR) perror("Не могу взять соединение");
      continue;
    }
	
    long2IP(tmp1.sin_addr.s_addr,IP);

    /* Обрабатывается выше - не открывается сокет    
    //проверить на загруженность (MaxProc)
    if(numproc>=maxproc){
      write_log(IP,"too many connections (MaxProc limit)");
      reply(nsock,552,"server is busy");
      continue;
    }
    */

    //проверить на соединения с одного IP
    if(CheckProc4IP(IP)){
      write_log(IP,"too many connections from this IP");
      reply(nsock,551,"too many connections from your IP");
      continue;    
    }
        
    //проверить на допустимость
    if(CheckIP(IP)){
      //передать инфо сервису
      setenv("IP",IP,1); 
      sprintf(fname,"%s%s",rundir,SERV_EXE);
      run_process(fname,F_DUPSOCK,IP);
    }
    else{
      //ошибку в лог
      write_log(IP,"bad IP-address");
      reply(nsock,550,"your IP-address restricted");
    }
  }
  close (sock);
}

//--------------Проверка IP на допустимость
int CheckIP(char *ip){
  if(order_ad){
    if(!ip_allowed(ip)) return 0; //не разрешен
    if(ip_denied(ip)) return 0;
    return 1;
  }
  else{
    if(!ip_denied(ip)) return 1; //не запрещён
    if(ip_allowed(ip)) return 1;
    return 0;
  }
}

//-----------------------Имя юзера => UID
uid_t user2uid(char *user){
  struct passwd *pwd;
  if(pwd=getpwnam(user)) return pwd->pw_uid;
  else return 0;
}

//-----------------------Имя группы => GID
gid_t group2gid(char *group){
  struct group *grp;
  if(grp=getgrnam(group)) return grp->gr_gid;
  else return 0;
}

//-----------------------По шаблону проверяются переданные IP
//с теми, которые разрешены в конфиге
int ip_allowed(char *ip){
  int i;
  int res=0;  
  int j0,j1;
  
  for(i=0; i<allow_ip_cnt; i++){
    for(j0=j1=0; ip[j1]; j1++){
      if(allow_ip[i][j0]=='?') j0++; 
      else 
        if(allow_ip[i][j0]=='*'){  
          while(allow_ip[i][j0]=='*') j0++;
	  while(ip[j1+1] && ip[j1+1]!=allow_ip[i][j0]) j1++;
	}
	else 
	  if(allow_ip[i][j0]!=ip[j1]){res=0; break;}
	  else j0++;
    }
    //проверить не сошлись ли шаблоны
    if(ip[j1]==0){ 
      res=1;
      break;
    }
  }
  return res;
}

//-----------------------По шаблону проверяются переданные IP
//с теми, которые запрещены в конфиге
int ip_denied(char *ip){
  int i;
  int res=0;  
  int j0,j1;
  
  for(i=0; i<deny_ip_cnt; i++){
    for(j0=j1=0; ip[j1]; j1++){
      if(deny_ip[i][j0]=='?') j0++; 
      else 
        if(deny_ip[i][j0]=='*'){  
          while(deny_ip[i][j0]=='*') j0++;
	  while(ip[j1+1] && ip[j1+1]!=deny_ip[i][j0]) j1++;
	}
	else 
	  if(deny_ip[i][j0]!=ip[j1]){res=0; break;}
	  else j0++;
    }
    //проверить не сошлись ли шаблоны
    if(ip[j1]==0){ 
      res=1;
      break;
    }
  }
  return res;
}

//------------------------Чтение конфигурации
int LoadCfg(char *errline){
  FILE *f;
  char fname[256];
  char buf[1024];
  char *kwd,*next;
  char *delim=" \t\r\n";   //разделители параметров
  char *delimex=" \t\r\n,";
  int  tmp;
  char buf1[256];
  int  linenum=0;
  int  res=0;
  
  
  res=0; linenum=0; 
  sprintf(fname,"%s%s",cfgdir,CfgName);
  sprintf(LogRecord, "Чтение конфигурации из файла %s",fname);
  write_log("SYSTEM",LogRecord);
  //инициализация
  allow_ip_cnt=0;
  deny_ip_cnt=0; 
  //по умолчанию
  maxproc=20;	
  maxproc4ip=2;
  servtimelimit=300;   
  strcpy(workdir,"/tmp/olimp");
  serv_uid=500;
  serv_gid=500;
  
//открыть конфиг
  if((f=fopen(fname,"r"))==NULL) return -1;
  while(!res && !feof(f)){
    fgets(buf,sizeof(buf),f);
    linenum++;
    sprintf(errline,"Line %d: %s",linenum,buf);
    
    kwd=strtok(buf,delim);

    if(kwd==NULL) continue;
    if(*kwd=='#') continue;	//пропуск комментария

    //WorkDir
    if(!strcmp(kwd,"WorkDir")){
      next=strtok(NULL,delim);
      strcpy(workdir,next);
    }    
    
    //User
    if(!strcmp(kwd,"User")){
      char user[256];
    
      next=strtok(NULL,delim);
      strcpy(user,next);
      //определить uid
      if(tmp=user2uid(user)){ 
        serv_uid=tmp;
//	sprintf(LogRecord,"serv_uid=%d",serv_uid);
//	write_log("",LogRecord);
      }
      else return 11;
    }
    
    //Group
    if(!strcmp(kwd,"Group")){
      char group[256];
    
      next=strtok(NULL,delim);
      strcpy(group,next);
      //определить gid
      if(tmp=group2gid(group)){ 
        serv_gid=tmp;
//	sprintf(LogRecord,"serv_gid=%d",serv_gid);
//	write_log("",LogRecord);
      }
      else return 10;
    }    
    
    //order
    if(!strcmp(kwd,"order")){
      next=strtok(NULL,delimex);
      if(next && !strcmp(next,"allow")) order_ad=1;
      else order_ad=0;
    }
    
    //allow from
    if(!strcmp(kwd,"allow")){
      next=strtok(NULL,delim);
      if(next && !strcmp(next,"from")){
        next=strtok(NULL,delim);
	while(next && allow_ip_cnt<ALLOW_IP_MAX){
	  strcpy(allow_ip[allow_ip_cnt++],next);
	  next=strtok(NULL,delim);
	}
      }
      else{
        sprintf(errline,"line %d %s",linenum,buf);
	res=1;
	break;
      }
    }    
    
    //deny from
    if(!strcmp(kwd,"deny")){
      next=strtok(NULL,delim);
      if(next && !strcmp(next,"from")){
        next=strtok(NULL,delim);
	while(next && deny_ip_cnt<DENY_IP_MAX){
	  strcpy(deny_ip[deny_ip_cnt++],next);
	  next=strtok(NULL,delim);
	}
      }
      else{
	sprintf(errline,"line %d %s",linenum,buf);
	res=2;
	break;
      }
    }        
  //Мах процессов
    if(!strcmp(kwd,"MaxProc")){
      next=strtok(NULL,delim);
      if(next) maxproc=atoi(next);
      if(maxproc>PROC_DESCR_MAX) maxproc=PROC_DESCR_MAX;
    }            
  //Мах процессов с одного IP
    if(!strcmp(kwd,"MaxProc4IP")){
      next=strtok(NULL,delim);
      if(next) maxproc4ip=atoi(next);
    }                
  //Тайм-аут сервака
    if(!strcmp(kwd,"ServTimeout")){
      next=strtok(NULL,delim);
      if(next) servtimelimit=atoi(next);
    }                
  }
  fclose(f);
  
//  ShowLimits();
  //Вернуть номер ошибочной строки
  if(!res) errline[0]=0;
  return res;
}

//--------------------Показ конфига
void ShowLimits(){
  int i;
  char buf[1024];

//разрешённые
  sprintf(LogRecord,"allowed: ");
  for(i=0; i<allow_ip_cnt; i++){
    sprintf(buf,"%s ",allow_ip[i]);
    strcat(LogRecord,buf);
  }
  
//Другие параметры
  sprintf(buf,
    "MaxProc=%d, MaxProc4IP=%d, ServTimeout=%d",
    maxproc,maxproc4ip,servtimelimit
  );
  strcat(LogRecord,buf);

//Текущее количество порожденных процессов
  sprintf(buf, ", numproc= %d", numproc);
  strcat(LogRecord,buf);
  
//в лог
  write_log("SYSTEM",LogRecord);
}

//-----------------------ИНИЦИАЛИЗАЦИЯ
void init(){
  int i, child, id, tourid;
  struct sockaddr_in tmp1;
  struct tm tm;
  time_t t, t1;
  char *p1, *p2;
  char errline[1024];

  //load configuration
  if(LoadCfg(errline)){
    sprintf(LogRecord,"error in olimpd.cfg: %s",errline);
    write_log("SYSTEM",LogRecord);
    exit(1);
  }
  
//...сначала все порождённые процессы не существуют...
  for(i=0; i<PROC_DESCR_MAX; i++) ProcDescrs[i].pid=-1;
//Проверка системных сигналов
  rel_signal(SIGCHLD,onSigChld);
  rel_signal(SIGHUP,onSigHup);
  rel_signal(SIGALRM,onSigAlrm);
  
//записать в log о старте
  write_log("SYSTEM","olimpd started");
//сделать temporary
  mkdir(workdir,0);
  chmod(workdir,0770);
  chown(workdir,serv_uid,serv_gid);
//сделать инетовский сокет "сервисный"
  sock = socket (PF_INET, SOCK_STREAM, 0);
  if(sock < 0){
    perror ("Не могу открыть сокет для сервиса");
    exit (1);
  }

  child = 1;
  setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, &child, sizeof (child));
//Сокет привязывается к серверному порту
  bzero ((char *) &tmp1, sizeof (tmp1));
  tmp1.sin_port = htons (SERV_PORT);
  tmp1.sin_family = AF_INET;
  if (bind (sock, (struct sockaddr *) &tmp1, sizeof (tmp1)) < 0)
    {
      perror ("Не могу посадить сокет на порт");
      close (sock);
      exit (1);
    }
}

//-----------------Породить как дочерний процесс прогу name
//для обслуживания клиентского IP
void run_process(char *name, int flags, char *ip){
  int pid, i;
  struct rlimit rlim;

  numproc++;
  
  pid=fork();
  if(pid > 0){
    //записать в таблицу
    for(i=0; i<maxproc; i++)
      if(ProcDescrs[i].pid==-1){ 
        ProcDescrs[i].pid=pid;
	strcpy(ProcDescrs[i].IP,ip);
	break;
      } 
  
    return;
  }
  else if (pid == 0){
    setgid(serv_gid);
    setuid(serv_uid);
  
    //Limits for CPU
    rlim.rlim_cur = servtimelimit;
    rlim.rlim_max = rlim.rlim_cur + 2;
    if (setrlimit (RLIMIT_CPU, &rlim) < 0){
      sprintf(LogRecord,"can't set CPU limit %d for service",rlim.rlim_cur);
      write_log("SERVICE",LogRecord);
      exit (1);
    }  
//дублировать "сервисный" сокет
    if(flags & F_DUPSOCK){
      dup2(nsock, 0);
      dup2(nsock, 1);
      dup2(nsock, 2);
    }
    if(flags & F_CLOSEALL){
      for (i = 0; i < MAXFILES; i++)
      close (i);
    }
//запуск проги
    do{
      execl (name, name, 0);
    }while (errno == EAGAIN);
      
    printf ("Can`t execl program %s\n", name);
    return;
  }
  printf ("Can`t fork process with program %s\n", name);
}

//--------------- обработка сигналов системы: HUP
void onSigHup(int i){
  char errline[256];
  int  res;

//при ошибке в конфиге вылететь
  if( (res=LoadCfg(errline)) != 0){
    sprintf(LogRecord,"error %d in olimpd.cfg (%s). Shutting down...",res,errline);
    write_log("SYSTEM",LogRecord);
    exit(1);
  }
//показать ограничения из конфига
  ShowLimits();
//сигнал получен и принят...
  rel_signal(SIGHUP,onSigHup);
}

//--------------- обработка сигналов системы: CHILD
void onSigChld(int i){
  int exitstatus;
  pid_t pid;

  //проверить статус
  pid=waitpid(-1,&exitstatus,WNOHANG);
  if(pid>-1){
    //зафиксировать смерть ребенка 
    numproc--;
    
    //потереть в таблице
    for(i=0; i<maxproc; i++){
      if(ProcDescrs[i].pid==pid) ProcDescrs[i].pid=-1;
    }
    
//    sprintf(LogRecord,"service [%d] stopped",pid);
//    write_log("SYSTEM",LogRecord);
  }
  
//сигнал получен и принят...
  rel_signal(SIGCHLD,onSigChld);
}

void onSigAlrm(int i)
{ 
  char str[1024];
  char Time[1024];
  char dat[10],tim[10];
  struct tm time1,time2;
  time_t t1,t2;
  int Cmd,Prm,row=0,res;
  double dlt;
  int delta;
  SQL *db;
  
  db=SQL_Open(0,"olimpd",0,"olimp",0);
  write_log("Scheduler","Получен сигнал SigAlarm");
  do
    { if (SQL_Query(db,"select Time,Command,Param from Schedule order by Time")&&
         SQL_NotNull(db))
      { write_log("Scheduler","Найдены отложенные команды");
        row=SQL_NumRows(db);
        strcpy(Time,SQL_Field(db,1));
        t1=dt2time_t(Time,&time1);
        Cmd=atoi(SQL_Field(db,2));
        Prm=atoi(SQL_Field(db,3));
        getdatetime(dat,tim);
        sprintf(str,"%s%s",dat,tim);
        t2=dt2time_t(str,&time2);
        dlt=difftime(t1,t2);
	delta=dlt;
	if (dlt<=0)
	 { sprintf(str,"./sch.olimp %d %d 2>/dev/null 1>2 &",Cmd,Prm);
	   system(str);
	   sprintf(str,"Выполняется команда %d параметр %d",Cmd,Prm);
	   write_log("Scheduler",str);
	   SQL_Query(db,"delete from Schedule where Time='%s' and Command=%d and Param=%d",Time,Cmd,Prm);
	 }
	else
	 { 
	   if (dlt>30000)
	    { alarm(30000);
	      write_log("Scheduler","Запланирован контрольный сигнал");
	    }
	   else
	    { alarm(delta);
  	      sprintf(str,"Запланировано задание в %d-%02d-%02d %02d:%02d Command=%d Param=%d",
	         time1.tm_mday,time1.tm_mon+1,time1.tm_year+1900,time1.tm_hour,time1.tm_min,Cmd,Prm);
	      write_log("Scheduler",str);
	    };
	 };
      }
     else
      {
        write_log("Scheduler","Нет запланированных заданий");
	row=0;
      };
  } while ((dlt<=0)&&(row!=0));
  SQL_Close(db);
// сигнал получен и принят
  rel_signal(SIGALRM,onSigAlrm);
};