C
#include <stdio.h>
#include <cstdarg>
#include <dlfcn.h>
#include <fcntl.h>
#include <unistd.h>
#include <iostream>
#include <iss_mac.h>
#include <fstream>
#include <ctime>
#include <map.h>
#include <string>
#include <errno.h>
#include <szi/szilog.h>
#include <QUdpSocket>
 
// ÄÌÑ ÓÏËÅÔÁ LOG
#define port_log 7315
// ÄÌÑ ÓÏËÅÔÁ COM
#define port_com 7316
 
int (*open_orig)(const char *filename, int flags, ...)=NULL;  //ÕËÁÚÁÔÅÌØ ÎÁ open
ssize_t (*write_orig)(int __fd,__const void *__buf,size_t __n)=NULL; //ÕËÁÚÁÔÅÌØ ÎÁ write
ssize_t (*read_orig)(int __fd,void *__buf,size_t __nbytes)=NULL;
int (*close_orig)(int __fd)=NULL; //ÕËÁÚÁÔÅÌØ ÎÁ close
int (*unlink_orig)(const char *)=NULL;  //ÕËÁÚÁÔÅÌØ ÎÁ ÕÄÁÌÅÎÉÅ ÆÁÊÌÁ
int (*rmdir_orig)(const char *)=NULL;
 
void OpenSziLog(char*, int);
void CloseSziLog();
int SziLog(int NCD, int N_SOB, char *Message);
 
// ÄÌÑ ÓÏËÅÔÁ LOG
static char szi_prog_name[33];
static int szi_prog_number;
 
 
int opisatel;
char bufer[200];
 
//#define _GNU_SOURCE
 
extern char *program_invocation_name;
 
 
 
// ËÁÒÔÁ ÈÒÁÎÑÝÁÑ ÚÎÁÞÅÎÉÅ ÄÅÓËÒÉÐÔÏÒ--ÉÍÑ ÆÁÊÌÁ
using namespace std;
 
map <int,string> mymap;
map <int,string> mapobj;
 
 
 
int SziLog(int NCD, int N_SOB, char *Message)
{
 
QUdpSocket sock;
QByteArray datagram;
 
  char szi_grup[33];
  char lszi_user[33];
  char szi_arm[33];
  char *ptr;
  char buf_char[1024];
  char mess[512];
  int len, ko;
  FILE *fd;
 
     ptr = getenv("SZI_USER_NAME");
    if ( ptr != NULL )  strcpy(lszi_user,ptr);
    else {
        ptr = getenv("USER");
        if ( ptr != NULL )  strcpy(lszi_user,ptr);
        else strcpy(lszi_user, "--?--");
 
    }
 
 
     ptr = getenv("SZI_GROUP_NAME");
     if ( ptr != NULL )  strcpy(szi_grup,ptr);
      else                strcpy(szi_grup, lszi_user);
 
 
 
     ptr = getenv("SZI_HOSTNAME");
     if ( ptr != NULL )  strcpy(szi_arm,ptr);
     else {
           ptr = getenv("HOSTNAME");
           if ( ptr != NULL ) strcpy(szi_arm, ptr);
           else strcpy(szi_arm, "ÎÅÉÚ×_áòí");
          }
 
 
 
 
   memset(buf_char, 0, 1024);
   memset(mess, 0, 512);
   len=strlen(Message);
   if(len>511) strncpy(mess,Message,511 );
   else strcpy(mess,Message);
 
  sprintf(buf_char,"%s|%s|%s|%s|%d|%d|%d|%s",
        szi_arm,szi_grup,lszi_user,szi_prog_name,szi_prog_number,N_SOB,NCD,mess);
 
  datagram.clear();
  datagram.append(buf_char);
 
 
 
 
  len = datagram.size();
  ko=sock.writeDatagram(datagram.data(), datagram.size(),QHostAddress("127.0.0.1"), port_log);
  if(ko != len)
  {
      if((fd=fopen("/usr/local/szi/tmp/szilog.txt", "a+")) !=NULL)
        {
        fputs(buf_char, fd);
        fputs("\n", fd);
        fclose(fd);
        }
  }
 
 
  return 0;
}
 
void OpenSziLog(char* name_prog, int number_prog)
{
 
   int len = strlen(name_prog);
 
 
 
   memset(szi_prog_name,0,33);
   if(len<32) strcpy( szi_prog_name,name_prog);
   else strncpy( szi_prog_name,name_prog,31);
    szi_prog_number = number_prog;
 
 
 return;
 
}
 
 
 
 
///**********************************************/
void CloseSziLog()
/**********************************************/
{
return;
}
 
 
 
 
 
 
char*  vremya()
{
    time_t t;
    struct tm *t_m;
    t=time(NULL);
    t_m=localtime(&t);
    int hour;
    int minute;
    int second;
    hour=t_m->tm_hour;
    minute=t_m->tm_min;
    second=t_m->tm_sec;
    static char buf[100];
    memset(buf,0,sizeof(buf));
    sprintf(buf,"%02d:%02d:%02d",hour,minute,second);
    return buf;
}
 
 
//// æÕÎËÃÉÑ ÐÏÌÕÞÅÎÉÑ ×ÒÅÍÅÎÉ
////ÐÏÌÕÞÅÎÉÅ ÔÅËÝÅÇÏ ÓÉÓÔÅÍÎÏÇÏ ×ÒÅÍÅÎÉ
//// ÚÁÐÉÓØ ÌÏÇÏ× × openlog
void zapislogov(int c,const char *filename,const char *username,const char *nameprogram)
{
    char buf[200];
    memset(buf,0,sizeof(buf));
    //SziLog(0,1,"hjkjhkjhk");
    //ÏÔËÒÙ×ÁÅÍ ÌÏÇ ÆÁÊÌ É ÐÉÛÅÍ
    int fd=open_orig("/openlog",O_CREAT | O_WRONLY | O_APPEND);
    if (fd>0)
    {
        char *vr=vremya();
        char buf2[30];
        sprintf(buf2,"%s",vr);
        if (c==1)
        {
            //ÌÏÇ ÏÐÅÎÁ
            sprintf(buf,"æÁÊÌ %s ÕÓÐÅÛÎÏ ÏÔËÒÙÔ ÐÏÌØÚÏ×ÁÔÅÌÅÍ %s × ÐÒÏÇÒÁÍÍÅ %s × %s\n",filename,username,nameprogram,buf2);
        }
        if (c==2)
        {
            sprintf(buf,"ÆÁÊÌ %s ÕÓÐÅÛÎÏ ÐÒÏÞÉÔÁÎ ÐÏÌØÚÏ×ÁÔÅÌÅÍ %s × ÐÒÏÇÒÁÍÍÅ %s × %s\n",filename,username,nameprogram,buf2);
            //ÌÏË read
        }
        if (c==3)
        {
            sprintf(buf,"ÆÁÊÌ %s ÕÓÐÅÛÎÏ ÚÁÐÉÓÁÎ ÐÏÌØÚÏ×ÁÔÅÌÅÍ %s × ÐÒÏÇÒÁÍÍÅ %s × %s\n",filename,username,nameprogram,buf2);
            //ÌÏË write
        }
        if (c==4)
        {
            sprintf(buf,"ÆÁÊÌ %s ÕÓÐÅÛÎÏ ÕÄÁÌÅÎ ÐÏÌØÚÏ×ÁÔÅÌÅÍ %s Ó × ÐÒÏÇÒÁÍÍÅ %s × %s\n",filename,username,nameprogram,buf2);
            //ÌÏÇ unlink
        }
        if (c==5)
        {
            sprintf(buf,"ÐÁÐËÁ %s ÕÓÐÅÛÎÏ ÕÄÁÌÅÎÁ ÐÏÌØÚÏ×ÁÔÅÌÅÍ %s Ó × ÐÒÏÇÒÁÍÍÅ %s × %s\n",filename,username,nameprogram,buf2);
            //ÌÏÇ rmdir
        }
        if (c==6)
        {
            sprintf(buf,"ÆÁÊÌ %s ÕÓÐÅÛÎÏ ÚÁËÒÙÔ ÐÏÌØÚÏ×ÁÔÅÌÅÍ %s × ÐÒÏÇÒÁÍÍÅ %s × %s\n",filename,username,nameprogram,buf2);
            //ÌÏÇ close
        }
        if (c==7)
        {
            sprintf(buf,"%s","úáäáîîùê ëìàþ îáêäåî × ÚÁÐÉÓÉ ÆÁÊÌÁ\n");
        }
        if (c==8)
        {
            sprintf(buf,"óÔÁÎÄÁÒÔÎÙÊ ××ÏÄ ÚÁÐÉÓÁÎ ÐÏÌØÚÏ×ÁÔÅÌÅÍ %s ÐÒÏÇÒÁÍÍÏÊ %s × %s\n",username,nameprogram,buf2);
        }
        if (c==9)
        {
            sprintf(buf,"óÔÁÎÄÁÒÔÎÙÊ ×Ù×ÏÄ ÚÁÐÉÓÁÎ ÐÏÌØÚÏ×ÁÔÅÌÅÍ %s ÐÒÏÇÒÁÍÍÏÊ %s × %s\n",username,nameprogram,buf2);
        }
        if (c==10)
        {
            sprintf(buf,"óÔÁÎÄÁÒÔÎÙÊ ××ÏÄ ÓÞÉÔÁÎ ÐÏÌØÚÏ×ÁÔÅÌÅÍ %s ÐÒÏÇÒÁÍÍÏÊ %s × %s\n",username,nameprogram,buf2);
        }
        if (c==11)
        {
            sprintf(buf,"óÔÁÎÄÁÒÔÎÙÊ ×Ù×ÏÄ ÓÞÉÔÁÎ ÐÏÌØÚÏ×ÁÔÅÌÅÍ %s ÐÒÏÇÒÁÍÍÏÊ %s × %s\n",username,nameprogram,buf2);
        }
        write_orig(fd,buf,strlen(buf));
        close_orig(fd);
 
        //SziLog(0,1,buf);
    }
    //return;
}
 
//////ÐÏÌÎÙÊ ÐÕÔØ ÆÁÊÌÁ
bool kontrolproverka(const char *filename)
{
    bool flag=false;
    FILE *f=fopen("/usr/local/szi/LDB/Groups_Obj","r");
    char buf[200];
    memset(buf,0,sizeof(buf));
    if (f!=NULL)
    {
        while (!feof(f))
        {
            fgets(buf,200,f);
            int i=0;
            char *pch=strtok(buf,"\005");
            while (pch != NULL)
            {
                i=i+1;
                if (i==4)
                {
                    if (strstr(filename,pch)!=NULL)
                    {
                        flag=true;
                        break;
                    }
                }
                pch = strtok (NULL,"\005");
            }
        }
        fclose(f);
    }
 
    return flag;
}
 
 
 
 
extern "C" int open(const char *filename, int flags, ...)
{
    mac_label l;
    mac_attr_t attr;
    if (open_orig==NULL)
    {
        open_orig = (int (*)(const char*, int, ...))dlsym(RTLD_NEXT,"open");
        write_orig=(ssize_t (*)(int __fd,__const void *,size_t))dlsym(RTLD_NEXT,"write");
        close_orig=(int (*)(int __fd))dlsym(RTLD_NEXT,"close");
        read_orig=(ssize_t (*)(int __fd, void *__buf, size_t __nbytes))dlsym(RTLD_NEXT,"read");
        unlink_orig=(int (*)(const char *))dlsym(RTLD_NEXT,"unlink");
        rmdir_orig=(int (*)(const char *pathname))dlsym(RTLD_NEXT,"rmdir");
    }
    if (strcmp(filename,"/usr/local/szi/LDB/Groups_Obj")==0)
    {
        va_list va;
        va_start(va, flags);
        mode_t mode = va_arg(va, mode_t);
        va_end(va);
        int rez=open_orig(filename,flags,mode);
        if (rez>0)
        {
            string h=filename;
            mapobj.insert(make_pair(rez,h));
        }
        return rez;
    }
    statmac(filename,&l,&attr);
    bool flag=false;
 
    int urs=l.lev;
    int cats=l.cat;
 
    if (urs>0 || cats>0)
    {
        flag=true;
    }
    if (flag==false)
    {
       flag=kontrolproverka(filename);
    }
 
    sprintf(bufer,"%s",filename);
 
    va_list va;
    va_start(va, flags);
    mode_t mode = va_arg(va, mode_t);
    va_end(va);
    char impol[30];
    memset(impol,0,sizeof(impol));
    uid_t a=getuid();
    struct passwd *ps=getpwuid(a);
    if (ps!=NULL)
    {
        char *f=ps->pw_name;
        sprintf(impol,"%s",f);
    }
    else
    {
        sprintf(impol,"%s","ÏÛÉÂËÁ");
    }
 
    int opis=open_orig(filename,flags,mode);  //ÐÒÏÐÕÓËÁÅÍ ÏÔËÒÙÔÉÅ ÆÁÊÌÁ
    if (opis>=0)
    {
        if (flag==true)   //ÅÓÌÉ ÆÁÊÌ ÎÁ ËÏÔÒÏÌÅ ÔÏ ÎÕÖÎÏ ÓÌÅÄÉÔØ ÚÁ ÎÉÍ × wrte É close
        {
            char buf2[70];
            memset(buf2,0,sizeof(buf2));
            sprintf(buf2,"%s",filename);
            string fl=buf2;
            mymap.insert(make_pair(opis,fl));
            zapislogov(1,bufer,impol,program_invocation_name);
        }
    }
 
    return opis;
}
 
extern "C" ssize_t write(int __fd,const void *__buf,size_t __n)
{
 
    write_orig=(ssize_t (*)(int __fd,__const void *,size_t))dlsym(RTLD_NEXT,"write");
    map <int,string>::iterator it=mapobj.find(__fd);
    if (it!=mapobj.end())
    {
        return write_orig(__fd,__buf,__n);
    }
    mac_label l;
    mac_attr_t attr;
    bool flag=false;
    statmac(bufer,&l,&attr);
    int urs=l.lev;
    int cats=l.cat;
 
    if (urs>0 || cats>0)
    {
        flag=true;
    }
    if (flag==false)
    {
       flag=kontrolproverka(bufer);
    }
    if (flag==true)   //ÅÓÌÉ ÆÁÊÌ ÎÁ ËÏÎÔÒÏÌÅ
    {
        char buf[100];
        memset(buf,0,sizeof(buf));
 
 
        char impol[30];
        memset(impol,0,sizeof(impol));
 
        char naidfail[100];
        memset(naidfail,0,sizeof(naidfail));
        int fl=0;
        //ÆÁÊÌÏ×ÙÊ ÄÅÓËÒÉÐÔÏÒ ÐÏÓÔÕÐÁÅÔ open ÉÌÉ write
        map <int,string>::iterator it=mymap.find(__fd);
        if (it!=mymap.end()) // ÅÓÌÉ ÜÌÅÍÅÎÔ ÎÁÊÄÅÎ
        {
            fl=1;
            string g=it->second;
            const char *f=g.c_str();
            sprintf(naidfail,"%s",f);
        }
        else
        {
            fl=0;
            sprintf(naidfail,"%s","æÁÊÌ ÎÅ ÎÁÊÄÅÎ");
        }
        uid_t a=getuid();
        struct passwd *ps=getpwuid(a);
        if (ps!=NULL)
        {
            char *f=ps->pw_name;
            sprintf(impol,"%s",f);
        }
        else
        {
            sprintf(impol,"%s","ÏÛÉÂËÁ");
        }
        if (fl==1)
        {
 
              zapislogov(3,naidfail,impol,program_invocation_name);
            if (__fd==0)  // ÅÓÌÉ ÄÅÓËÒÉÐÔÏÒ ÒÁ×ÅÎ 0 ÚÎÁÞÉÔ ÄÁÎÎÙÅ ÐÏÓÔÕÐÉÌÉ ÎÁ ÓÔÁÎÄÁÒÔÎÙÊ ××ÏÄ
            {
              //zapislogov(8,"óÔÁÎÄÁÒÔÎÙÊ ××ÏÄ ÚÁÐÉÓÁÎ \n",impol,program_invocation_name);
            }
            if (__fd==1)  //ÄÁÎÎÙÅ ÐÏÓÔÕÐÉÌÉ ÎÁ ÓÔÁÎÄÁÒÔÎÙÊ ×Ù×ÏÄ
            {
             //zapislogov(9,"óÔÁÎÄÁÒÔÎÙÊ ×Ù×ÏÄ ÚÁÐÉÓÁÎ \n",impol,program_invocation_name);
            }
        }
 
    }
    return write_orig(__fd,__buf,__n);
}
 
 
//////×ÙÚÙ×ÁÅÍ ÓÉÓÔÅÍÎÙÊ ×ÙÚÏ× read  ÅÓÌÉ Ó ÆÁÊÌÁ ÞÉÔÁÀÔÓÑ ÄÁÎÎÙÅ
extern "C" ssize_t read(int __fd,void * __buf,size_t __nbytes)
{
 
    read_orig=(ssize_t (*)(int __fd, void *__buf, size_t __nbytes))dlsym(RTLD_NEXT,"read");
 
    map <int,string>::iterator it=mapobj.find(__fd); //ÐÒÏ×ÅÒÑÅÍ ÄÅÓËÒÉÐÔÏÒ ÓÏÄÅÒÖÁÝÉÊÓÑ × ÄÁÎÎÏÍ ÍÁÐÅ ÅÓÌÉ ÅÓÔØ ÚÎÁÞÉÔ ÍÙ ÏÔËÒÙ×ÁÅÍ groupsobj
    if (it!=mapobj.end())  //ÅÓÌÉ ÄÅÓËÒÉÐÔÏÒ ÎÁÊÄÅÎ ÚÎÁÞÉÔÙ ÍÙ ÏÔËÒÙ×ÁÅÍ ÆÁÊÌ groupsobj
    {
        return read_orig(__fd,__buf,__nbytes);
    }
    //ðÒÉ ÞÔÅÎÉÉ ÐÒÏ×ÅÒÑÅÍ ÎÁ ËÏÎÔÒÏÌÅ ÆÁÊÌ ÅÓÌÉ ÎÁ ËÏÎÔÒÏÌÅ ÔÏ ÐÉÛÅÍ × ÌÏÇ
    mac_label l;
    mac_attr_t attr;
    //ÐÒÏ×ÅÒÑÍ ÕÒÏ×ÅÎØ ÓÅËÒÅÔÎÏÓÔÉ ÉÌÉ ËÁÔÅÇÏÒÉÀ ÅÓÌÉ ÏÎÉ ×ÙÛÅ 0 ÔÏ ÓÌÅÄÉÍ ÚÁ ÄÁÎÎÙÍ ÆÁÊÌÏÍ
   // fopen
    //ÂÅÒÅÍ ÕËÁÚÁÔÅÌØ ÎÁ ÏÒÉÇÉÎÁÌØÎÙÊ read
    read_orig=(ssize_t (*)(int __fd,void * __buf,size_t __nbytes))dlsym(RTLD_NEXT,"read");
    bool flag=false;
    statmac(bufer,&l,&attr);
    int us=l.lev;
    int ks=l.cat;
 
    if (us>0 || ks>0)
    {
        flag=true;
    }
    if (flag==false)
    {
       flag=kontrolproverka(bufer);
    }
    if (flag==true)
    {
        char buf[100];
        memset(buf,0,sizeof(buf));
 
        char impol[30];
        memset(impol,0,sizeof(impol));
 
        char naidfail[100];
        memset(naidfail,0,sizeof(naidfail));
        int fl=0;
        map <int,string>::iterator it=mymap.find(__fd);
        if (it!=mymap.end())  //ÅÓÌÉ ÎÁÊÄÅÎ ÄÅÓËÒÉÐÔÏÒ × mape ÚÎÁÞÉÔ ÆÁÊÌ ÎÁÈÏÄÉÔÓÑ ÎÁ ËÏÎÔÒÏÌÅ
        {
            fl=1;
            string g=it->second;
            const char *f=g.c_str();
            sprintf(naidfail,"%s",f);
        }
        else   // ÆÁÊÌ ÎÅ ÎÁÈÏÄÉÔÓÑ ÎÁ ËÏÎÔÒÏÌÅ ÌÏÇ ÐÉÓÁÔØ ÎÅ ÎÕÖÎÏ
        {
            fl=0;
            sprintf(naidfail,"%s","æÁÊÌ ÎÅ ÎÁÊÄÅÎ");
        }
        uid_t a=getuid();
        struct passwd *ps=getpwuid(a);
        if (ps!=NULL)
        {
            char *f=ps->pw_name;
            sprintf(impol,"%s",f);
        }
        else
        {
            sprintf(impol,"%s","ÏÛÉÂËÁ");
        }
 
        if (fl==1)
        {
            zapislogov(2,naidfail,impol,program_invocation_name);
 
            if (__fd==0)   //ÞÉÔÁÅÍ ÄÁÎÎÙÅ ÓÏ ÓÔÁÎÄÁÒÔÎÏÇÏ ××ÏÄÁ
            {
               // zapislogov(10,"þÉÔÁÅÍ ÄÁÎÎÙÅ ÓÏ ÓÔÁÎÄÁÒÔÎÏÇÏ ××ÏÄÁ\n","1","1");
            }
            if (__fd==1)     //ÞÉÔÁÅÍ ÄÁÎÎÙÅ ÓÏ ÓÔÁÎÄÁÒÔÎÏÇÏ ×Ù×ÏÄÁ
            {
               // zapislogov(11,"þÉÔÁÅÍ ÄÁÎÎÙÅ ÓÏ ÓÔÁÎÄÁÒÔÎÏÇÏ ×Ù×ÏÄÁ\n","1","1");
            }
        }
    }
    //ÐÅÒÅÄÁÅÍ × ÏÒÉÇÉÎÁÌØÎÏÅ ÞÔÅÎÉÅ
    return read_orig(__fd,__buf,__nbytes);
}
 
 
//////ÏÔÓÌÅÖÉ×ÁÎÉÅ ÕÄÁÌÅÎÉÑ ÆÁÊÌÁ
extern "C" int unlink(const char * __name)
{
    //ÂÅÒÅÍ ÕËÁÚÁÔÅÌØ ÎÁ ÏÒÉÇÉÎÁÌØÎÕÀ ÆÕÎËÃÉÀ
    unlink_orig=(int (*)(const char *))dlsym(RTLD_NEXT,"unlink");
    char buf[100];
    memset(buf,0,sizeof(buf));
 
    mac_label l;
    mac_attr_t attr;
    bool flag=false;
    statmac(__name,&l,&attr);
    int ks=l.cat;
    int us=l.lev;
    if (ks>0 || us>0)  // ÅÓÌÉ ÕÒÏ×ÅÎØ É ËÁÔÅÇÏÒÉÑ ÓÅËÒÅÔÎÏÓÔÉ
    {
        flag=true;
    }
    if (flag==false)  // ÅÓÌÉ ÕÒÏ×ÅÎØ ÉÌÉ ËÁÔÅÇÏÒÉÑ ÎÅ ÐÏÄÈÏÄÉÔ ÔÏ ÓÍÏÔÒÉÍ groupsobj
    {
        flag=kontrolproverka(bufer);
    }
 
    int rez=unlink_orig(__name);
    if (rez==0)  // ÅÓÌÉ ÆÁÊÌ ÕÄÁÌÅÎ ÕÓÐÅÛÎÏ
    {
        //ÂÅÒÅÍ ÉÍÑ ÐÏÌØÚÏ×ÁÔÅÌÑ
        //ÂÅÒÅÍ ÉÍÑ ÐÒÏÇÒÁÍÍÙ
        if (flag==true)//ÅÓÌÉ ÏÂßÅËÔ ÎÁ ËÏÎÔÒÏÌÅ
        {
            char impol[100];
            memset(impol,0,sizeof(impol));
            //ÏÐÒÅÄÅÌÑÅÍ ÉÍÑ ÐÏÌØÚÏ×ÁÔÅÌÑ
            uid_t a=getuid();
            struct passwd *ps=getpwuid(a);
            if (ps!=NULL)
            {
                char *f=ps->pw_name;
                sprintf(impol,"%s",f);
            }
            else
            {
                sprintf(impol,"%s","ÏÛÉÂËÁ");
            }
            zapislogov(4,__name,impol,program_invocation_name);
            //ÉÝÅÍ × ÍÁÐÅ ÐÏ ÐÕÔÉ É ÕÄÁÌÑÅÍ ËÌÀÞ
            map <int,string>::iterator it;
            for (it=mymap.begin(); it!=mymap.end();++it)
            {
                string a=it->second;  //ÂÅÒÅÍ ÉÍÑ ÆÁÊÌÁ
                const char *ch=a.c_str();
                if (strcmp(__name,ch)==0)  // ÓÒÁ×ÎÉ×ÁÅÍ... ÅÓÌÉ ÉÍÑ ÓÏ×ÐÁÌÏ ÔÏ ÕÄÁÌÑÅÍÙÊ ÆÁÊÌ ÎÁÊÄÅÎ × ÓÐÉÓËÅ ÕÄÁÌÑÅÍ ÅÇÏ ÉÚ ËÁÒÔÙ
                {
                    int klch=it->first;
                    mymap.erase(klch);
                }
            }
        }
    }
    return rez;
 
}
 
 
////ÕÄÁÌÅÎÉÅ ËÁÔÁÌÏÇÁ ÐÏ ÐÕÔÉ
extern "C" int rmdir(const char *pathname)
{
    //ÂÅÒÅÍ ÕËÁÚÁÔÅÌØ ÎÁ ÏÒÉÇÉÎÁÌØÎÕÀ ÆÕÎËÃÉÀ
    rmdir_orig=(int (*)(const char *pathname))dlsym(RTLD_NEXT,"rmdir");
    char buf[100];
    memset(buf,0,sizeof(buf));
 
    mac_label l;
    mac_attr_t attr;
    bool flag=false;
 
    statmac(pathname,&l,&attr);
    int ks=l.cat;
    int us=l.lev;
    if (ks>0 || us>0)
    {
        flag=true;
    }
    if (flag==false)
    {
       flag=kontrolproverka(bufer);
    }
    int rez=rmdir_orig(pathname);
    if (rez==0)  // ÅÓÌÉ ÕÓÐÅÛÎÏ ÕÄÁÌÉÌÉ ÐÁÐËÕ
    {
        if (flag==true)  //ÅÓÌÉ ÏÂßÅËÔ ÎÁ ËÏÎÔÒÏÌÅ
        {
            char impol[100];
            memset(impol,0,sizeof(impol));
            //ÏÐÒÅÄÅÌÑÅÍ ÉÍÑ ÐÏÌØÚÏ×ÁÔÅÌÑ
            uid_t a=getuid();
            struct passwd *ps=getpwuid(a);
            if (ps!=NULL)
            {
                char *f=ps->pw_name;
                sprintf(impol,"%s",f);
            }
            else
            {
                sprintf(impol,"%s","ÏÛÉÂËÁ");
            }
          zapislogov(5,pathname,impol,program_invocation_name);
 
            map <int,string>::iterator it;
            for (it=mymap.begin(); it!=mymap.end();++it)
            {
                string a=it->second;  //ÂÅÒÅÍ ÉÍÑ ÆÁÊÌÁ
                const char *ch=a.c_str();
                if (strcmp(pathname,ch)==0)  // ÓÒÁ×ÎÉ×ÁÅÍ... ÅÓÌÉ ÉÍÑ ÓÏ×ÐÁÌÏ ÔÏ ÕÄÁÌÑÅÍÙÊ ÆÁÊÌ ÎÁÊÄÅÎ × ÓÐÉÓËÅ ÕÄÁÌÑÅÍ ÅÇÏ ÉÚ ËÁÒÔÙ
                {
                    int klch=it->first;
                    mymap.erase(klch);
                }
            }
        }
    }
    return rez;
}
 
 
//////ÚÁËÒÙÔÉÅ ÆÁÊÌÁ
extern "C" int close(int __fd)
{
    close_orig=(int (*)(int __fd))dlsym(RTLD_NEXT,"close");
    map <int,string>::iterator it=mapobj.find(__fd); //ÐÒÏ×ÅÒÑÅÍ ÄÅÓËÒÉÐÔÏÒ ÓÏÄÅÒÖÁÝÉÊÓÑ × ÄÁÎÎÏÍ ÍÁÐÅ ÅÓÌÉ ÅÓÔØ ÚÎÁÞÉÔ ÍÙ ÏÔËÒÙ×ÁÅÍ groupsobj
    if (it!=mapobj.end())  //ÅÓÌÉ ÄÅÓËÒÉÐÔÏÒ ÎÁÊÄÅÎ ÚÎÁÞÉÔÙ ÍÙ ÏÔËÒÙ×ÁÅÍ ÆÁÊÌ groupsobj
    {
        mapobj.erase(__fd);
        return close_orig(__fd);
    }
    mac_label l;
    mac_attr_t attr;
 
    statmac(bufer,&l,&attr);
    int us=l.lev;
    int cat=l.cat;
 
    bool flag=false;
 
    if (us>0 || cat>0)
    {
        flag=true;
    }
    if (flag==false)
    {
        flag=kontrolproverka(bufer);
    }
    if (flag==true)  //ÏÂßÅËÔ ÎÁ ËÏÎÔÒÏÌÅ ÉÝÅÍ ÅÇÏ × ÍÁÐÅ
    {
        int fl;
        char naid[80];
        memset(naid,0,sizeof(naid));
        map <int,string>::iterator it=mymap.find(__fd);
        if (it!=mymap.end())  //ÅÓÌÉ ÜÌÅÍÅÎÔ Ó ÚÁÄÁÎÎÙÍ ÄÅÓËÒÉÐÔÏÒÏÍ ÎÁÊÄÅÎ
        {
            fl=1;
            string h=it->second;
            sprintf(naid,"%s",h.c_str());
            mymap.erase(__fd);  // ÐÒÉ ÚÁËÒÙÔÉÉ ÆÁÊÌÁ ÕÂÉÒÁÅÍ ÅÇÏ ÉÚ ÍÁÐÁ
        }
        else  //ÅÓÌÉ ÚÁËÒÙ×ÁÅÍÙÊ ÆÁÊÌ ÎÅ ÎÁÊÄÅÎ × ÓÐÉÓËÅ ÏÔÓÌÅÖÉ×ÁÅÍÙÈ ÆÁÊÌÏ×
        {
            fl=0;
            sprintf(naid,"%s","æÁÊÌ ÎÅ ÎÁÊÄÅÎ");
        }
 
        //ÅÓÌÉ ÏÂßÅËÔ ÎÁ ËÏÎÔÒÏÌÅ
        char impol[30];
        memset(impol,0,sizeof(impol));
        uid_t a=getuid();
        struct passwd *ps=getpwuid(a);
        if (ps!=NULL)
        {
            char *f=ps->pw_name;
            sprintf(impol,"%s",f);
        }
        else
        {
            sprintf(impol,"%s","ÏÛÉÂËÁ");
        }
        if (fl==1)
        {
            zapislogov(6,naid,impol,program_invocation_name);
        }
 
 
    }
 
    return  close_orig(__fd);
}