kiir.cpp

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>

#define USI unsigned int
#define USC unsigned char

#define SORHOSSZ 256
#define SPACE 32


void SorFeldolgozasa(void);
void kiirja(char *);

struct jogosultsag { // jogosultságok
int x:1;
int w:1;
int r:1;
int egyebek:5;
};

struct specialis { // jogosultságok
int sticky:1;
int groupid:1;
int userid:1;
int egyebek:5;
};


union jogok {
jogosultsag j;
USC byte;
};


union speci {
specialis s;
USC byte;
};

char *mem; // ide olvassuk majd be a fájlt
char voltszazalekjel;


int jbhossz; // ebben lesz benne a kiirandó mező hossza
char kiirando[256];
char jb; // 1: balra igazít, 2: jobbra igazít, 0: alapértelmezés szerint igazít

USC sor[SORHOSSZ];
USI szamlalo;
USI hossz;
USC kapcsolok[256];

USI dirszam;  // altartalomjegyzékek száma
USI fileszam; // fájlok száma
double osszfoglalt,allomanymeret;
USC konyvtare;
USC ponte;
USC cc;

jogok tulajdonos;
jogok csoport;
jogok mindenki;
speci spec;

USI mezo2;
USI mezo3;
USI mezo4;
USI mezo5;
USI mezo6;
USI mezo7;
USI mezo8;


char filemeret[256];
char allomanyattributuma[20];
char allomany2[20];
char allomany3[20];
char allomany4[20];
char allomany5[20];
char allomany6[20];
char allomany7[20];
char allomany8[20];
char allomany9[20];
char allomanyneve[256];

char *formatumstring;
char vaneformatumstring;
int formatumstringhossz=0;
char FormatumString[]="%d %O %10T %10G %D %I %20M %n";


//  ---------------  main --------------------------

int main (int argc, char **argv) {

struct stat st;
unsigned long int size;

char argvnulla[256];
char * argvnull;

FILE *fp;
int c;
USI kapcsolohossz;
char AlapertelmezettTartalomjegyzek[]=".  ";
char AlapertelmezettKapcsolok[]="- ";
char *mappa;
char *kapcs;

pid_t pid, ppid;
gid_t gid;
char pidstring[64];
char fileneve[256];
USI pidhossz;
USI nevhossz;
USI argv0hossz;
USI filenevehossza;
USI mappanevehossza;
int statusz;

char parancseleje[]="ls -a -l ";
char rekurzivparancseleje[]="ls -R -a -l ";
char *eleje;
const char*torloparancseleje="rm ";
USI parancselejehossza;
char parancs[256];
const char *prefix="/var/tmp/";
USI prefixhossz;
unsigned long int L;
USI i;

AlapertelmezettKapcsolok[1]=AlapertelmezettTartalomjegyzek[1]=0;
vaneformatumstring=0;

for(i=0;i<256;i++) kapcsolok[i]=0;
prefixhossz=strlen(prefix);
for(i=0;i<prefixhossz;i++) fileneve[i]=prefix[i];

argv0hossz=strlen(argv[0]);
for(i=0;i<argv0hossz;i++) {argvnulla[i]=argv[0][i];
if(argvnulla[i]=='/') argvnulla[i]='_';
if(argvnulla[i]=='.') argvnulla[i]='_';
}
argvnulla[argv0hossz]=0;

argvnull=argvnulla;
while(argvnull[0]=='_') {argvnull++;} // A ciklus lefutása után argvnull az első nem alahuzas karakterre mutat





if(argc>1) {
if((argv[1][0]=='-')&&((argv[1][1]=='?')||(argv[1][1]=='h'))) {

printf ("E szkriptet készítette: Viola Zoltán ( [email protected] )\n"
"Licenc: GPL\n"
"Mit csinál: kb ugyanazt mint az ls -l\n"
"parancs, a következő különbségekkel: a fájl vagy könyvtár jogosultságait 4 oktális számjeggyxel írja ki,\n"
"például: 0777\n"
"Rendesen lekezeli az USERID, GROUPID és STICKY biteket is. (Ezek a kilistázott 4 karakteres\n"
"oktális szám legnagyobb helyiértékű azaz baloldali számjegyét alkotják).\n"
"A legelső karakter a kilistázott sorban egy \"-\" ha fájl, és \"d\" ha könyvtár, ezután jön egy szóköz.\n"
"Legelőször kilistázza az összes könyvtárat, utána a többi fájlt.\n"
"Így kell lefordítani:\n"
"g++ kiir.cpp -o kiir\n"
"Használat:\n");
printf("%s — ez az aktuális könyvtárban listáz\n",argvnull);
printf("%s állománynév — a megadott állományt listázza ki.\n",argvnull);
printf("%s könyvtárnév — a megadott könyvtárat listázza ki.\n",argvnull);
printf("%s -? — kiírja ezt a helpet\n",argvnull);
printf("%s -h — kiírja ezt a helpet\n",argvnull);
printf("%s \"formátumstring\" könyvtárnév — a megadott könyvtárat listázza ki a formátumstringben specifikált módon.\n",argvnull);
printf("%s -kapcsolók \"formátumstring\" könyvtárnév — a megadott könyvtárat listázza ki a formátumstringben specifikált módon, a kapcsolók szerint.\n",argvnull);
printf("%s -kapcsolók ÁllománynévVagyKönyvtárnév - az adott állományt vagy könyvtárat listázza ki a kapcsolóknak megfelelően\n",argvnull);
printf("A kapcsolókból akármennyit meg lehet adni, egyetlen \"-\" jel után, pld: -pPo\n");
printf("A kapcsolók jelentése:\n");
printf("p = listázza a \".\" és a \"..\" tartalomjegyzékeket is. (Kis p)\n");
printf("P = listázza a rejtett tartalomjegyzékeket is (amiknek a neve ponttal kezdődik). (Nagy P)\n");
printf("(Csak akkor listázza a . és a .. valamint a rejtett tartralomjegyzékeket, ha a p és P kapcsolók mindegyikét megadtuk!)\n");
printf("o = kirírja a lista végére az altartalomjegyzékek és a fájlok darabszámát\n");
printf("d = nem listázza a könyvtárakat (A . és .. nevűt sem!)\n");
printf("f = nem listázza a fájlokat (A rejtett állományokat sem!)\n");
printf("L = nem listázza a linkeket\n");
printf("R = rekurzíven listáz. E kapcsoló esetén nem listázza külön előbb a tartalomjegyzékeket majd a linkeket majd fájlokat az egyes\n"
"altartalomjegyzékekben, hanem minden almappa tartalmát kilistázza olyan sorrendben ahogy azt az \"ls -R\" tenné.\n"
"Ellenben ezesetben ha megadtuk a -o kapcsolót, a fájlok összmérete az összes kilistázott könyvtár összes fájljának méretét tartalmazza majd.\n"
);
printf("M = Kiírja az \"ls -a -l\" parancs esetén kapott azon sorokat is, amelyek nem fájl- vagy könyvtárbejegyzések\n");
printf("A = az alapértelmezett formátumstring szerint listáz, azaz mintha ezt adtuk volna meg:\n");
printf("\"%s\"\n",FormatumString);
printf("Ez a kapcsoló felülbírálja az esetlegesen külön megadott formátumstringet!\n");
printf("\nA formátumstringre vonatkozó szabályok:\n");
printf("Ha nincs megadva formátumstring, akkor az \"ls -l\" esetén szokásos módon listáz, azt kivéve, hogy az attributumstring helyett\n"
"oktális formában írja ki a jogosultságokat.\n");
printf("A formátumstringben a speciális jelentéssel bíró karaktereket a %% jel kell megelőzze.\n"
"Ha a %% jelet olyan karakter követi melynek nincs meghatározott jelentése, kiírja a %% jelet is és e karaktert is.\n"
"Ami karaktert nem előz meg %% prefix, azt is kiírja.\n"
"A speciális karakterek:\n"
"%%%% - a %% jel\n"
"%%/ - újsor karakter\n"
"%%d - egy karakter, mely azt jelzi, könyvtár-e vagy fájl. Könyvtár esetén ez \"d\", fájl esetén \"-\" karakter. link esetén \"l\" karakter.\n"
"%%a - az \"ls\" esetén  szokásos 9 karakteres attributumstring (például \"rwxrwxrwx\")\n"
"%%s - a chmod parancsnál megadható legnagyobb helyiértékű oktális számjegy, ez tartalmazza a STICKY, GROUPID és USERID biteket.\n"
"%%t - a chmod parancsnál megadható jobbról a harmadik oktális számjegy, a fájl tulajdonosának jogait határozza meg.\n"
"%%c - a chmod parancsnál megadható jobbról a második oktális számjegy, a csoport jogait határozza meg.\n"
"%%m - a chmod parancsnál megadható jobbról az első oktális számjegy, amely a \"mindenki más\" jogait határozza meg.\n"
"%%O - a chmod parancsnál oktális módon megadható mind a 4 számjegy egymás után.\n"
"%%l - a fájla mutató hard linkek számát írja ki.\n"
"%%T - A tuladonos neve\n"
"%%G - A csoport neve\n"
"%%M - Az állomány mérete\n"
"%%D - A dátum\n"
"%%I - Az idő\n"
"%%n - Az állomány neve\n"
"A formátumstringben megadható bizonyos tételek mezőhossza és igazitási módja. Azon tételeknél, melyek hossza változó lehet.\n"
"Ezek a következők: %%l, %%T, %%G, %%M, %%n\n"
"A hossz és formátummegadás a következőképp történik:\n"
"%%j15M - ez a méretet 15 karakteres mezőben írja ki, jobbra igazítva.\n"
"%%j30n - ez a file (vagy a könyvtár) nevét 30 karakteres mezőben írja ki, jobbra igazítva.\n"
"%%b15M - ez a méretet 15 karakteres mezőben írja ki, balra igazítva.\n"
"%%b30n - ez a file (vagy a könyvtár) nevét 30 karakteres mezőben írja ki, balra igazítva.\n"
"Hasonlóképp adhatjuk meg a többi felsorolt mezőnél is.\n"
"Ha nem adunk meg b vagy j karaktert csak számot, akkor alapértelmezés szerinti irányba igazít. Ez a következő:\n"
"nevek esetében ( %%T, %%G, %%n ) balra igazít, számok esetében ( %%l, %%M ) jobbra.\n"
"Például: %%20M egy 20 karakteres mezőbe írja ki jobbra zárva a méretet.\n"
"%%20n egy 20 karakteres mezőbe írja ki balra zárva a file nevét.\n"
"Ha nem fér bele a mezőhosszba a kiiratandó adat, akkor nem veszi figyelembe a mezőhosszat hanem kiírja az egészet.\n"
"Ha olyan adatnál adunk hossz-specifikációt (akár j vagy b-vel együtt akár enélkül) amely fix hosszúságú, azaz nem a fentebb felsoroltak\n"
"valamelyike, akkor azt a hosszt egyszerűen nem veszi figyelembe, hanem kiírja a maga megszokott fix hosszúságában. Például:\n"
"%%45O vagy %%j45O - ez hiába adtunk meg 45-öt, akkor is csak 4 karakter hosszan írja ki a file jogosultságainak oktális értékét.\n"
);


return(0);
}
} // argc>1 teszt vége


if(argc==1) {mappa=AlapertelmezettTartalomjegyzek;kapcs=AlapertelmezettKapcsolok;}

else {

if(argc==2) {if (argv[1][0]=='-') {mappa=AlapertelmezettTartalomjegyzek;kapcs=argv[1];}  else {mappa=argv[1];kapcs=AlapertelmezettKapcsolok;} }
else {
if((argc==3)&&(argv[1][0]=='-')) {mappa=argv[2];kapcs=argv[1];}
if((argc==3)&&(argv[1][0]!='-')) {mappa=argv[2];kapcs=AlapertelmezettKapcsolok;vaneformatumstring=1;formatumstring=argv[1];
}

if((argc==4)&&(argv[1][0]!='-')) {
printf("Hibásan adtad meg a kapcsolósor prefixumát!\n"
"Próbálkozz a\n%s -h\nvagy a\n%s -?\nparanccsal, hogy lássad a lehetséges kapcsolók listáját!\n",argv[0],argv[0]);
return(1);
}

if(argc==4) {mappa=argv[3];kapcs=argv[1];vaneformatumstring=1;formatumstring=argv[2];}


}
} // else vége




kapcsolohossz=strlen(kapcs);
for(i=1;i<kapcsolohossz;i++) {// kapcsolók beolvasása
kapcsolok[kapcs[i]]=1;
} // kapcsolók beolvasásának vége

if(kapcsolok['A']) {vaneformatumstring=1;formatumstring=FormatumString;}


if(vaneformatumstring) formatumstringhossz=strlen(formatumstring);

// beolvassuk a process id értékét
if ((pid = getpid()) < 0) {  perror("Nem tudom beolvasni a pid-et");return(1);}

sprintf(pidstring, "%d", pid); // stringgé konvertáljuk a pid értéket


// előállítjuk a fájlnevet
pidhossz=strlen(pidstring);
if(kapcsolok['R']) eleje=rekurzivparancseleje; else eleje=parancseleje;

parancselejehossza=strlen(eleje);
mappanevehossza=strlen(mappa);
for(i=0;i<parancselejehossza;i++) parancs[i]=eleje[i];
for(i=0;i<argv0hossz;i++) {fileneve[prefixhossz+i]=argvnull[i];}
for(i=0;i<pidhossz;i++) {fileneve[prefixhossz+argv0hossz+i]=pidstring[i];}
fileneve[prefixhossz+argv0hossz+i]=0;
filenevehossza=strlen(fileneve);
for(i=0;i<mappanevehossza;i++) parancs[parancselejehossza+i]=mappa[i];
parancs[parancselejehossza+i]=SPACE;
parancs[parancselejehossza+i+1]='>';

for(i=0;i<filenevehossza;i++) parancs[parancselejehossza+mappanevehossza+2+i]=fileneve[i];
parancs[parancselejehossza+mappanevehossza+filenevehossza+2]=0;

statusz = system(parancs);

if(statusz==-1) {printf("Nem sikerült a %s parancs végrehajtása!\n",parancs); return(1);}


stat(fileneve, &st);
size = st.st_size; // A file mérete
// printf("mérete: %f\n",(double)size);

if(size>0) {mem = new char [size]; //helyfoglalás a file-nek
} else {printf("A file mérete nulla!\n"); return(1);}

fp=fopen(fileneve,"rb");

if (!fp) { printf ("Nem tudom megnyitni a %s állományt!\n", fileneve); return(1); }

for(L=0L;L<size;L++) mem[L]=(char)fgetc(fp); // beolvassuk az állományt
fclose(fp); // bezárjuk az állományt






// ---------------- FŐCIKLUS ---------------

dirszam=fileszam=0;

osszfoglalt=0;

szamlalo=0; // lenullázzuk a következő sor számára

if(!kapcsolok['R']) {// ha nem rekurzívan listáz

// Tartalomjegyzékek listázása
for(L=0L;L<size;L++) {// állományfeldolgozás kezdete
// Itt kezdődik egy sor beolvasása
c=(USC)mem[L];
sor[szamlalo]=c;;
szamlalo++;
if(szamlalo==SORHOSSZ) {printf("Túl hosszú az állományból beolvasandó sor!\n"); return(1);}
if(c=='\n') { // itt dolgozzuk fel a sort
sor[szamlalo]=0; // lezárjuk a stringet egy nulla bájttal, mert biztos ami biztos...
hossz=szamlalo; // ebben van a sor hossza hogy hány karakterből áll
konyvtare=sor[0];
if(konyvtare=='d') SorFeldolgozasa();
szamlalo=0; // lenullázzuk a következő sor számára

} // sorfeldolgozás vége
} // állományfeldolgozás vége


// linkek istázása
if(!kapcsolok['L']) {// nem listázzuk a linkeket a -L kapcsoló esetén

for(L=0L;L<size;L++) {// állományfeldolgozás kezdete
// Itt kezdődik egy sor beolvasása
c=(USC)mem[L];
sor[szamlalo]=c;;
szamlalo++;
if(szamlalo==SORHOSSZ) {printf("Túl hosszú az állományból beolvasandó sor!\n"); return(1);}
if(c=='\n') { // itt dolgozzuk fel a sort
sor[szamlalo]=0; // lezárjuk a stringet egy nulla bájttal, mert biztos ami biztos...
hossz=szamlalo; // ebben van a sor hossza hogy hány karakterből áll
konyvtare=sor[0];
if(konyvtare=='l') SorFeldolgozasa();
szamlalo=0; // lenullázzuk a következő sor számára

} // sorfeldolgozás vége
} // állományfeldolgozás vége

} // linklistázás vége

// fájlok istázása
for(L=0L;L<size;L++) {// állományfeldolgozás kezdete
// Itt kezdődik egy sor beolvasása
c=(USC)mem[L];
sor[szamlalo]=c;;
szamlalo++;
if(szamlalo==SORHOSSZ) {printf("Túl hosszú az állományból beolvasandó sor!\n"); return(1);}
if(c=='\n') { // itt dolgozzuk fel a sort
sor[szamlalo]=0; // lezárjuk a stringet egy nulla bájttal, mert biztos ami biztos...
hossz=szamlalo; // ebben van a sor hossza hogy hány karakterből áll
konyvtare=sor[0];
if(konyvtare=='-') SorFeldolgozasa();
szamlalo=0; // lenullázzuk a következő sor számára

} // sorfeldolgozás vége
} // állományfeldolgozás vége




} // nem rekurzív listázás vége

else {// rekurzív listázás kezdete

for(L=0L;L<size;L++) {// állományfeldolgozás kezdete
// Itt kezdődik egy sor beolvasása
c=(USC)mem[L];
sor[szamlalo]=c;;
szamlalo++;
if(szamlalo==SORHOSSZ) {printf("Túl hosszú az állományból beolvasandó sor!\n"); return(1);}
if(c=='\n') { // itt dolgozzuk fel a sort
sor[szamlalo]=0; // lezárjuk a stringet egy nulla bájttal, mert biztos ami biztos...
hossz=szamlalo; // ebben van a sor hossza hogy hány karakterből áll
konyvtare=sor[0];
if((konyvtare=='.')||(konyvtare=='/')) printf("\n%s\n",sor);
else SorFeldolgozasa();
szamlalo=0; // lenullázzuk a következő sor számára

} // sorfeldolgozás vége
} // állományfeldolgozás vége


} // rekurzív listázás vége


// egyebek istázása
for(L=0L;L<size;L++) {// állományfeldolgozás kezdete
// Itt kezdődik egy sor beolvasása
c=(USC)mem[L];
sor[szamlalo]=c;;
szamlalo++;
if(szamlalo==SORHOSSZ) {printf("Túl hosszú az állományból beolvasandó sor!\n"); return(1);}
if(c=='\n') { // itt dolgozzuk fel a sort
sor[szamlalo]=0; // lezárjuk a stringet egy nulla bájttal, mert biztos ami biztos...
hossz=szamlalo; // ebben van a sor hossza hogy hány karakterből áll
konyvtare=sor[0];
if((konyvtare!='-')&&(konyvtare!='l')&&(konyvtare!='d')) SorFeldolgozasa();
szamlalo=0; // lenullázzuk a következő sor számára

} // sorfeldolgozás vége
} // állományfeldolgozás vége










if(kapcsolok['o']) {
printf("Alkönyvtárak száma: %u; fájlok száma: %u, Összesen: %u állomány\n",dirszam,fileszam,dirszam+fileszam);
printf("A fájlok összmérete: %20.0f byte, ez %17.0f KB, ez %14.0f MB, ez %11.0f GB\n",osszfoglalt,osszfoglalt/1024+1,osszfoglalt/1024/1024+1,
osszfoglalt/1024/1024/1024+1);

}

printf("\n");


// Töröljük az ideiglenes állományt
parancselejehossza=strlen(torloparancseleje);
for(i=0;i<parancselejehossza;i++) parancs[i]=torloparancseleje[i];
for(i=0;i<filenevehossza;i++) parancs[parancselejehossza+i]=fileneve[i];
parancs[parancselejehossza+filenevehossza]=0;
statusz = system(parancs);
if(statusz==-1) {printf("Nem sikerült a %s parancs végrehajtása!\n",parancs); return(1);}



delete[] mem; // felszabadítjuk a memóriaterületet

return(0);
}
// ======================================================================================ó
// ------------------------  main vége -------------------------

void SorFeldolgozasa() {
USI i;
USI mezohossz;
char formatumkarakter;

// A sor karakterei sor[0] - tól sor[hossz-1] -ig vannak

if(kapcsolok['M']) { // Az -M kapcsoló esetén kiírjuk az állomány azon sorait is, amik nem könyvtár- vagy fájlbejegyzések
if((konyvtare!='-')&&(konyvtare!='b')&&(konyvtare!='c')&&(konyvtare!='s')&&(konyvtare!='d')&&(konyvtare!='l'))
{printf("%s",sor);return;} // Ha első karaktere nem fájltípusjelölő, kiírjuk.
 }

if((konyvtare!='-')&&(konyvtare!='b')&&(konyvtare!='c')&&(konyvtare!='s')&&(konyvtare!='d')&&(konyvtare!='l')) {return;}

for(i=1;i<10;i++) allomanyattributuma[i-1]=sor[i];
allomanyattributuma[10]=0;

// Itt jön egy undorító szövegfeldolgozás, ahol szétvágjuk mezőkre a beolvasott sort
mezo2=10;
while((cc=sor[mezo2])==SPACE) {mezo2++;} // A ciklus lefutása után mezo2 az első nem szóköz karakterre mutat
i=0;while((allomany2[i]=sor[mezo2+i])!=SPACE) {i++;} allomany2[i]=0;

mezo3=mezo2;
while((cc=sor[mezo3])!=SPACE) {mezo3++;} // A ciklus lefutása után mezo3 az első szóköz karakterre mutat
while((cc=sor[mezo3])==SPACE) {mezo3++;} // A ciklus lefutása után mezo3 az első nem szóköz karakterre mutat
i=0;while((allomany3[i]=sor[mezo3+i])!=SPACE) {i++;} allomany3[i]=0;

mezo4=mezo3;
while((cc=sor[mezo4])!=SPACE) {mezo4++;} // A ciklus lefutása után mezo4 az első szóköz karakterre mutat
while((cc=sor[mezo4])==SPACE) {mezo4++;} // A ciklus lefutása után mezo4 az első nem szóköz karakterre mutat
i=0;while((allomany4[i]=sor[mezo4+i])!=SPACE) {i++;} allomany4[i]=0;

mezo5=mezo4;
while((cc=sor[mezo5])!=SPACE) {mezo5++;} // A ciklus lefutása után mezo5 az első szóköz karakterre mutat
while((cc=sor[mezo5])==SPACE) {mezo5++;} // A ciklus lefutása után mezo5 az első nem szóköz karakterre mutat
i=0;while((allomany5[i]=sor[mezo5+i])!=SPACE) {i++;} allomany5[i]=0;

mezo6=mezo5;
while((cc=sor[mezo6])!=SPACE) {mezo6++;} // A ciklus lefutása után mezo6 az első szóköz karakterre mutat
while((cc=sor[mezo6])==SPACE) {mezo6++;} // A ciklus lefutása után mezo6 az első nem szóköz karakterre mutat
i=0;while((allomany6[i]=sor[mezo6+i])!=SPACE) {i++;} allomany6[i]=0;

mezo7=mezo6;
while((cc=sor[mezo7])!=SPACE) {mezo7++;} // A ciklus lefutása után mezo7 az első szóköz karakterre mutat
while((cc=sor[mezo7])==SPACE) {mezo7++;} // A ciklus lefutása után mezo7 az első nem szóköz karakterre mutat
i=0;while((allomany7[i]=sor[mezo7+i])!=SPACE) {i++;} allomany7[i]=0;

mezo8=mezo7;
while((cc=sor[mezo8])!=SPACE) {mezo8++;} // A ciklus lefutása után mezo8 az első szóköz karakterre mutat
while((cc=sor[mezo8])==SPACE) {mezo8++;} // A ciklus lefutása után mezo8 az első nem szóköz karakterre mutat
i=0;while((allomany8[i]=sor[mezo8 + i])!='\n') {i++;}  allomany8[i]=0;



if(kapcsolok['p']==0) {// Akkor listázzuk a . és .. tartalomjegyzékeket, ha be van kapcsolva a -p kapcsoló
if ((sor[mezo8]=='.')&&(sor[mezo8 + 1]=='\n')) {return; } // Kihagyjuk a "." bejegyzést
if ((sor[mezo8]=='.')&&(sor[mezo8 + 1]==0)) {return; } // Kihagyjuk a "." bejegyzést
if ((sor[mezo8]=='.')&&(sor[mezo8 + 1]=='.')&&(sor[mezo8 + 2]=='\n')) {return;} // Kihagyjuk a ".." bejegyzést
if ((sor[mezo8]=='.')&&(sor[mezo8 + 1]=='.')&&(sor[mezo8 + 2]==0)) {return;} // Kihagyjuk a ".." bejegyzést
} // -p kapcsoló tesztjének vége

if(kapcsolok['P']==0) {// Akkor listázzuk a .-tal kezdődő nevű bejegyyzéseket (rejtett könyvtárak és állományok) ha be van kapcsolva a -P kapcsoló

if (sor[mezo8]=='.') {
if (!
(
((sor[mezo8]=='.')&&(sor[mezo8 + 1]=='\n'))
||
((sor[mezo8]=='.')&&(sor[mezo8 + 1]=='.')&&(sor[mezo8 + 2]=='\n'))
)
) // if vege

return; // Kihagyjuk a ponttal kezdődő nevű bejegyzéseket

}
} // -P kapcsoló tesztjének vége













allomanymeret=0;

if(konyvtare=='d') dirszam++;
if(konyvtare=='-') fileszam++;






// kezdetben minden bit nulla
tulajdonos.byte=csoport.byte=mindenki.byte=spec.byte=0;


if(sor[9]=='T') {spec.s.sticky=1;}
if(sor[9]=='t') {spec.s.sticky=1;mindenki.j.x=1;}
if(sor[6]=='S') {spec.s.groupid=1;}
if(sor[6]=='s') {spec.s.groupid=1;csoport.j.x=1;}
if(sor[3]=='S') {spec.s.userid=1;}
if(sor[3]=='s') {spec.s.userid=1;tulajdonos.j.x=1;}

if (sor[1]=='r') {tulajdonos.j.r=1;}
if (sor[2]=='w') {tulajdonos.j.w=1;}
if (sor[3]=='x') {tulajdonos.j.x=1;}
if (sor[4]=='r') {csoport.j.r=1;}
if (sor[5]=='w') {csoport.j.w=1;}
if (sor[6]=='x') {csoport.j.x=1;}
if (sor[7]=='r') {mindenki.j.r=1;}
if (sor[8]=='w') {mindenki.j.w=1;}
if (sor[9]=='x') {mindenki.j.x=1;}



for(i=mezo5;i<mezo6;i++) filemeret[i-mezo5]=sor[i];
filemeret[i]=0;
allomanymeret=atof(filemeret);
if(konyvtare=='-') osszfoglalt+=allomanymeret;

if((kapcsolok['d'])&&(konyvtare=='d')) return; // A -d kapcsoló esetén nem listázza a könyvtárakat
if((kapcsolok['f'])&&(konyvtare=='-')) return; // A -f kapcsoló esetén nem listázza a fájlokat


if(!vaneformatumstring) {printf("%c %c%c%c%c %s",konyvtare,spec.byte+48,tulajdonos.byte+48,csoport.byte+48,mindenki.byte+48,sor+10);return;}

// Formátumstring szerinti kiírás

jb=0; // Alapértelmezés szerint igazítunk: állományméretet és linkszámot jobbra, tulajdonos- és csoportnevet meg állománynevet balra
jbhossz=0;
voltszazalekjel=0;
for(i=0;i<formatumstringhossz;i++) { // formátumstringfeldolgozó ciklus
formatumkarakter=formatumstring[i];
if(voltszazalekjel==0) {
if(formatumkarakter!='%') {printf("%c",formatumkarakter);continue;}
i++;if(i==formatumstringhossz) {printf("\nHibás formátumstring!\n");exit(1);}
formatumkarakter=formatumstring[i];
} //
if(formatumkarakter=='%') {printf("%%");voltszazalekjel=0;jb=0;jbhossz=0;continue;} // % karakter
if(formatumkarakter=='/') {printf("\n");voltszazalekjel=0;jb=0;jbhossz=0;continue;} // újsor karakter

if(formatumkarakter=='d') {printf("%c",konyvtare);voltszazalekjel=0;jb=0;jbhossz=0;continue;} // "-" vagy "d" karakter, aszerint hogy könyvtár-e vagy közönséges fájl

if(formatumkarakter=='a') {printf("%s",allomanyattributuma);voltszazalekjel=0;jb=0;jbhossz=0;continue;} // Az eredeti attributumstring ( rwxrwxrwx )

if(formatumkarakter=='s') {printf("%c",spec.byte+48);voltszazalekjel=0;jb=0;jbhossz=0;continue;} // A STICKY bit meg egyebek bájtja

if(formatumkarakter=='t') {printf("%c",tulajdonos.byte+48);voltszazalekjel=0;jb=0;jbhossz=0;continue;} // Az oktális jogosultságok első karaktere

if(formatumkarakter=='c') {printf("%c",csoport.byte+48);voltszazalekjel=0;jb=0;jbhossz=0;continue;} // Az oktális jogosultságok masodik karaktere

if(formatumkarakter=='m') {printf("%c",mindenki.byte+48);voltszazalekjel=0;jb=0;jbhossz=0;continue;} // Az oktális jogosultságok harmaddik karaktere
if(formatumkarakter=='O') {printf("%c%c%c%c",spec.byte+48,tulajdonos.byte+48,csoport.byte+48,mindenki.byte+48);voltszazalekjel=0;jb=0;jbhossz=0;continue;}
// Az oktális jogosultságok mindegyik karaktere

if(formatumkarakter=='l') {if(jb==0){jb=2;} if(jbhossz==0) jbhossz=strlen(allomany2);kiirja(allomany2);continue;} // a 2. mező, linkek száma

if(formatumkarakter=='T') {if(jb==0){jb=1;} if(jbhossz==0) jbhossz=strlen(allomany3);kiirja(allomany3);continue;} // a 3. mező, a tulajdonos
if(formatumkarakter=='G') {if(jb==0){jb=1;} if(jbhossz==0) jbhossz=strlen(allomany4);kiirja(allomany4);continue;} // a 4. mező, a csoport
if(formatumkarakter=='M') {if(jb==0){jb=2;} if(jbhossz==0) jbhossz=strlen(allomany5);kiirja(allomany5);continue;} // a 5. mező, a méret
if(formatumkarakter=='D') {printf("%s",allomany6);voltszazalekjel=0;jb=0;jbhossz=0;continue;} // a 6. mező, a dátum
if(formatumkarakter=='I') {printf("%s",allomany7);voltszazalekjel=0;jb=0;jbhossz=0;continue;} // a 7. mező, az idő
if(formatumkarakter=='n') {if(jb==0){jb=1;} if(jbhossz==0) {jbhossz=strlen(allomany8);} kiirja(allomany8);continue;} // a 8. mező, az állománynév

if(formatumkarakter=='b') {jb=1;voltszazalekjel=1;
i++;if(i==formatumstringhossz) {printf("\nHibás formátumstring!\n");exit(1);}
formatumkarakter=formatumstring[i];
if((formatumkarakter<'0')||(formatumkarakter>'9')) {printf("\nHibás formátumstring!\n");exit(1);}
jbhossz=0;
while((formatumkarakter>='0')&&(formatumkarakter<='9')) {
jbhossz*=10;jbhossz=jbhossz+formatumkarakter-'0';
formatumkarakter=formatumstring[++i];
} // while vége
--i;
continue;}

if(formatumkarakter=='j') {jb=2;voltszazalekjel=1;
i++;if(i==formatumstringhossz) {printf("\nHibás formátumstring!\n");exit(1);}
formatumkarakter=formatumstring[i];
if((formatumkarakter<'0')||(formatumkarakter>'9')) {printf("\nHibás formátumstring!\n");exit(1);}
jbhossz=0;
while((formatumkarakter>='0')&&(formatumkarakter<='9')) {
jbhossz*=10;jbhossz=jbhossz+formatumkarakter-'0';
formatumkarakter=formatumstring[++i];
} // while vége
--i;
continue;}

if((formatumkarakter>='0')&&(formatumkarakter<='9')) {jb=0;voltszazalekjel=1;
jbhossz=0;
while((formatumkarakter>='0')&&(formatumkarakter<='9')) {
jbhossz*=10;jbhossz=jbhossz+formatumkarakter-'0';
formatumkarakter=formatumstring[++i];
} // while vége
--i;
continue;}



printf("%%%c",formatumkarakter); // ismeretlen kapcsolót csak simán kiírunk
jb=0;voltszazalekjel=0;jbhossz=0;
} //formátumstringfeldolgozó ciklus vége
printf("\n");


}

// ======================================================================================

void kiirja(char *mezo) {
int mezohossz;int i;int max;
// printf("jb=%u; jbhossz=%u, mezohossz=%u mezo=%s\n",jb,jbhossz,strlen(mezo),mezo);
// printf("%s",mezo);

/*
int jbhossz; // ebben lesz benne a kiirandó mező hossza
char kiirando[256];
char jb; // 1: balra igazít, 2: jobbra igazít
*/
if(jb==0) {printf("%s",mezo);jbhossz=0;voltszazalekjel=0;return;jb=0;} // ekkor nem igazít
if(jb>2) {printf("\nHIBA! jb=%u; mezo=%s\n",jb,mezo);exit(1);} // hiba, kilépés
if(jbhossz>254) jbhossz=254; // Mert az ördög nem alszik...
mezohossz=strlen(mezo);
max=mezohossz;if(mezohossz>jbhossz) {printf("%s",mezo);jbhossz=0;jb=0;voltszazalekjel=0;return;}
for(i=0;i<jbhossz;i++) {kiirando[i]=SPACE;}  // puffer törlése

if(jb==1) {kiirando[jbhossz]=0;
for(i=0;i<max;i++) {kiirando[i]=mezo[i];} // for vége

} // jb==1 vége

if(jb==2) {
for(i=0;i<max;i++) {kiirando[jbhossz-mezohossz+i]=mezo[i];} // for vége
kiirando[jbhossz]=0;
} // jb==2 vége

printf("%s",kiirando);
jb=0; // Alapértelmezés szerint igazítunk: állományméretet és linkszámot jobbra, tulajdonos- és csoportnevet meg állománynevet balra
jbhossz=0;

voltszazalekjel=0;
return;

};