violazoli

kiir.cpp

May 14th, 2013
386
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4. #include <unistd.h>
  5. #include <sys/types.h>
  6. #include <sys/stat.h>
  7.  
  8. #define USI unsigned int
  9. #define USC unsigned char
  10.  
  11. #define SORHOSSZ 256
  12. #define SPACE 32
  13.  
  14.  
  15. void SorFeldolgozasa(void);
  16. void kiirja(char *);
  17.  
  18. struct jogosultsag { // jogosultságok
  19. int x:1;
  20. int w:1;
  21. int r:1;
  22. int egyebek:5;
  23. };
  24.  
  25. struct specialis { // jogosultságok
  26. int sticky:1;
  27. int groupid:1;
  28. int userid:1;
  29. int egyebek:5;
  30. };
  31.  
  32.  
  33. union jogok {
  34. jogosultsag j;
  35. USC byte;
  36. };
  37.  
  38.  
  39. union speci {
  40. specialis s;
  41. USC byte;
  42. };
  43.  
  44. char *mem; // ide olvassuk majd be a fájlt
  45. char voltszazalekjel;
  46.  
  47.  
  48. int jbhossz; // ebben lesz benne a kiirandó mező hossza
  49. char kiirando[256];
  50. char jb; // 1: balra igazít, 2: jobbra igazít, 0: alapértelmezés szerint igazít
  51.  
  52. USC sor[SORHOSSZ];
  53. USI szamlalo;
  54. USI hossz;
  55. USC kapcsolok[256];
  56.  
  57. USI dirszam;  // altartalomjegyzékek száma
  58. USI fileszam; // fájlok száma
  59. double osszfoglalt,allomanymeret;
  60. USC konyvtare;
  61. USC ponte;
  62. USC cc;
  63.  
  64. jogok tulajdonos;
  65. jogok csoport;
  66. jogok mindenki;
  67. speci spec;
  68.  
  69. USI mezo2;
  70. USI mezo3;
  71. USI mezo4;
  72. USI mezo5;
  73. USI mezo6;
  74. USI mezo7;
  75. USI mezo8;
  76.  
  77.  
  78. char filemeret[256];
  79. char allomanyattributuma[20];
  80. char allomany2[20];
  81. char allomany3[20];
  82. char allomany4[20];
  83. char allomany5[20];
  84. char allomany6[20];
  85. char allomany7[20];
  86. char allomany8[20];
  87. char allomany9[20];
  88. char allomanyneve[256];
  89.  
  90. char *formatumstring;
  91. char vaneformatumstring;
  92. int formatumstringhossz=0;
  93. char FormatumString[]="%d %O %10T %10G %D %I %20M %n";
  94.  
  95.  
  96. //  ---------------  main --------------------------
  97.  
  98. int main (int argc, char **argv) {
  99.  
  100. struct stat st;
  101. unsigned long int size;
  102.  
  103. char argvnulla[256];
  104. char * argvnull;
  105.  
  106. FILE *fp;
  107. int c;
  108. USI kapcsolohossz;
  109. char AlapertelmezettTartalomjegyzek[]=".  ";
  110. char AlapertelmezettKapcsolok[]="- ";
  111. char *mappa;
  112. char *kapcs;
  113.  
  114. pid_t pid, ppid;
  115. gid_t gid;
  116. char pidstring[64];
  117. char fileneve[256];
  118. USI pidhossz;
  119. USI nevhossz;
  120. USI argv0hossz;
  121. USI filenevehossza;
  122. USI mappanevehossza;
  123. int statusz;
  124.  
  125. char parancseleje[]="ls -a -l ";
  126. char rekurzivparancseleje[]="ls -R -a -l ";
  127. char *eleje;
  128. const char*torloparancseleje="rm ";
  129. USI parancselejehossza;
  130. char parancs[256];
  131. const char *prefix="/var/tmp/";
  132. USI prefixhossz;
  133. unsigned long int L;
  134. USI i;
  135.  
  136. AlapertelmezettKapcsolok[1]=AlapertelmezettTartalomjegyzek[1]=0;
  137. vaneformatumstring=0;
  138.  
  139. for(i=0;i<256;i++) kapcsolok[i]=0;
  140. prefixhossz=strlen(prefix);
  141. for(i=0;i<prefixhossz;i++) fileneve[i]=prefix[i];
  142.  
  143. argv0hossz=strlen(argv[0]);
  144. for(i=0;i<argv0hossz;i++) {argvnulla[i]=argv[0][i];
  145. if(argvnulla[i]=='/') argvnulla[i]='_';
  146. if(argvnulla[i]=='.') argvnulla[i]='_';
  147. }
  148. argvnulla[argv0hossz]=0;
  149.  
  150. argvnull=argvnulla;
  151. while(argvnull[0]=='_') {argvnull++;} // A ciklus lefutása után argvnull az első nem alahuzas karakterre mutat
  152.  
  153.  
  154.  
  155.  
  156.  
  157. if(argc>1) {
  158. if((argv[1][0]=='-')&&((argv[1][1]=='?')||(argv[1][1]=='h'))) {
  159.  
  160. printf ("E szkriptet készítette: Viola Zoltán ( violazoli@gmail.com )\n"
  161. "Licenc: GPL\n"
  162. "Mit csinál: kb ugyanazt mint az ls -l\n"
  163. "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"
  164. "például: 0777\n"
  165. "Rendesen lekezeli az USERID, GROUPID és STICKY biteket is. (Ezek a kilistázott 4 karakteres\n"
  166. "oktális szám legnagyobb helyiértékű azaz baloldali számjegyét alkotják).\n"
  167. "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"
  168. "Legelőször kilistázza az összes könyvtárat, utána a többi fájlt.\n"
  169. "Így kell lefordítani:\n"
  170. "g++ kiir.cpp -o kiir\n"
  171. "Használat:\n");
  172. printf("%s — ez az aktuális könyvtárban listáz\n",argvnull);
  173. printf("%s állománynév — a megadott állományt listázza ki.\n",argvnull);
  174. printf("%s könyvtárnév — a megadott könyvtárat listázza ki.\n",argvnull);
  175. printf("%s -? — kiírja ezt a helpet\n",argvnull);
  176. printf("%s -h — kiírja ezt a helpet\n",argvnull);
  177. 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);
  178. 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);
  179. 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);
  180. printf("A kapcsolókból akármennyit meg lehet adni, egyetlen \"-\" jel után, pld: -pPo\n");
  181. printf("A kapcsolók jelentése:\n");
  182. printf("p = listázza a \".\" és a \"..\" tartalomjegyzékeket is. (Kis p)\n");
  183. printf("P = listázza a rejtett tartalomjegyzékeket is (amiknek a neve ponttal kezdődik). (Nagy P)\n");
  184. printf("(Csak akkor listázza a . és a .. valamint a rejtett tartralomjegyzékeket, ha a p és P kapcsolók mindegyikét megadtuk!)\n");
  185. printf("o = kirírja a lista végére az altartalomjegyzékek és a fájlok darabszámát\n");
  186. printf("d = nem listázza a könyvtárakat (A . és .. nevűt sem!)\n");
  187. printf("f = nem listázza a fájlokat (A rejtett állományokat sem!)\n");
  188. printf("L = nem listázza a linkeket\n");
  189. 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"
  190. "altartalomjegyzékekben, hanem minden almappa tartalmát kilistázza olyan sorrendben ahogy azt az \"ls -R\" tenné.\n"
  191. "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"
  192. );
  193. 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");
  194. printf("A = az alapértelmezett formátumstring szerint listáz, azaz mintha ezt adtuk volna meg:\n");
  195. printf("\"%s\"\n",FormatumString);
  196. printf("Ez a kapcsoló felülbírálja az esetlegesen külön megadott formátumstringet!\n");
  197. printf("\nA formátumstringre vonatkozó szabályok:\n");
  198. 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"
  199. "oktális formában írja ki a jogosultságokat.\n");
  200. printf("A formátumstringben a speciális jelentéssel bíró karaktereket a %% jel kell megelőzze.\n"
  201. "Ha a %% jelet olyan karakter követi melynek nincs meghatározott jelentése, kiírja a %% jelet is és e karaktert is.\n"
  202. "Ami karaktert nem előz meg %% prefix, azt is kiírja.\n"
  203. "A speciális karakterek:\n"
  204. "%%%% - a %% jel\n"
  205. "%%/ - újsor karakter\n"
  206. "%%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"
  207. "%%a - az \"ls\" esetén  szokásos 9 karakteres attributumstring (például \"rwxrwxrwx\")\n"
  208. "%%s - a chmod parancsnál megadható legnagyobb helyiértékű oktális számjegy, ez tartalmazza a STICKY, GROUPID és USERID biteket.\n"
  209. "%%t - a chmod parancsnál megadható jobbról a harmadik oktális számjegy, a fájl tulajdonosának jogait határozza meg.\n"
  210. "%%c - a chmod parancsnál megadható jobbról a második oktális számjegy, a csoport jogait határozza meg.\n"
  211. "%%m - a chmod parancsnál megadható jobbról az első oktális számjegy, amely a \"mindenki más\" jogait határozza meg.\n"
  212. "%%O - a chmod parancsnál oktális módon megadható mind a 4 számjegy egymás után.\n"
  213. "%%l - a fájla mutató hard linkek számát írja ki.\n"
  214. "%%T - A tuladonos neve\n"
  215. "%%G - A csoport neve\n"
  216. "%%M - Az állomány mérete\n"
  217. "%%D - A dátum\n"
  218. "%%I - Az idő\n"
  219. "%%n - Az állomány neve\n"
  220. "A formátumstringben megadható bizonyos tételek mezőhossza és igazitási módja. Azon tételeknél, melyek hossza változó lehet.\n"
  221. "Ezek a következők: %%l, %%T, %%G, %%M, %%n\n"
  222. "A hossz és formátummegadás a következőképp történik:\n"
  223. "%%j15M - ez a méretet 15 karakteres mezőben írja ki, jobbra igazítva.\n"
  224. "%%j30n - ez a file (vagy a könyvtár) nevét 30 karakteres mezőben írja ki, jobbra igazítva.\n"
  225. "%%b15M - ez a méretet 15 karakteres mezőben írja ki, balra igazítva.\n"
  226. "%%b30n - ez a file (vagy a könyvtár) nevét 30 karakteres mezőben írja ki, balra igazítva.\n"
  227. "Hasonlóképp adhatjuk meg a többi felsorolt mezőnél is.\n"
  228. "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"
  229. "nevek esetében ( %%T, %%G, %%n ) balra igazít, számok esetében ( %%l, %%M ) jobbra.\n"
  230. "Például: %%20M egy 20 karakteres mezőbe írja ki jobbra zárva a méretet.\n"
  231. "%%20n egy 20 karakteres mezőbe írja ki balra zárva a file nevét.\n"
  232. "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"
  233. "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"
  234. "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"
  235. "%%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"
  236. );
  237.  
  238.  
  239. return(0);
  240. }
  241. } // argc>1 teszt vége
  242.  
  243.  
  244. if(argc==1) {mappa=AlapertelmezettTartalomjegyzek;kapcs=AlapertelmezettKapcsolok;}
  245.  
  246. else {
  247.  
  248. if(argc==2) {if (argv[1][0]=='-') {mappa=AlapertelmezettTartalomjegyzek;kapcs=argv[1];}  else {mappa=argv[1];kapcs=AlapertelmezettKapcsolok;} }
  249. else {
  250. if((argc==3)&&(argv[1][0]=='-')) {mappa=argv[2];kapcs=argv[1];}
  251. if((argc==3)&&(argv[1][0]!='-')) {mappa=argv[2];kapcs=AlapertelmezettKapcsolok;vaneformatumstring=1;formatumstring=argv[1];
  252. }
  253.  
  254. if((argc==4)&&(argv[1][0]!='-')) {
  255. printf("Hibásan adtad meg a kapcsolósor prefixumát!\n"
  256. "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]);
  257. return(1);
  258. }
  259.  
  260. if(argc==4) {mappa=argv[3];kapcs=argv[1];vaneformatumstring=1;formatumstring=argv[2];}
  261.  
  262.  
  263. }
  264. } // else vége
  265.  
  266.  
  267.  
  268.  
  269. kapcsolohossz=strlen(kapcs);
  270. for(i=1;i<kapcsolohossz;i++) {// kapcsolók beolvasása
  271. kapcsolok[kapcs[i]]=1;
  272. } // kapcsolók beolvasásának vége
  273.  
  274. if(kapcsolok['A']) {vaneformatumstring=1;formatumstring=FormatumString;}
  275.  
  276.  
  277. if(vaneformatumstring) formatumstringhossz=strlen(formatumstring);
  278.  
  279. // beolvassuk a process id értékét
  280. if ((pid = getpid()) < 0) {  perror("Nem tudom beolvasni a pid-et");return(1);}
  281.  
  282. sprintf(pidstring, "%d", pid); // stringgé konvertáljuk a pid értéket
  283.  
  284.  
  285. // előállítjuk a fájlnevet
  286. pidhossz=strlen(pidstring);
  287. if(kapcsolok['R']) eleje=rekurzivparancseleje; else eleje=parancseleje;
  288.  
  289. parancselejehossza=strlen(eleje);
  290. mappanevehossza=strlen(mappa);
  291. for(i=0;i<parancselejehossza;i++) parancs[i]=eleje[i];
  292. for(i=0;i<argv0hossz;i++) {fileneve[prefixhossz+i]=argvnull[i];}
  293. for(i=0;i<pidhossz;i++) {fileneve[prefixhossz+argv0hossz+i]=pidstring[i];}
  294. fileneve[prefixhossz+argv0hossz+i]=0;
  295. filenevehossza=strlen(fileneve);
  296. for(i=0;i<mappanevehossza;i++) parancs[parancselejehossza+i]=mappa[i];
  297. parancs[parancselejehossza+i]=SPACE;
  298. parancs[parancselejehossza+i+1]='>';
  299.  
  300. for(i=0;i<filenevehossza;i++) parancs[parancselejehossza+mappanevehossza+2+i]=fileneve[i];
  301. parancs[parancselejehossza+mappanevehossza+filenevehossza+2]=0;
  302.  
  303. statusz = system(parancs);
  304.  
  305. if(statusz==-1) {printf("Nem sikerült a %s parancs végrehajtása!\n",parancs); return(1);}
  306.  
  307.  
  308. stat(fileneve, &st);
  309. size = st.st_size; // A file mérete
  310. // printf("mérete: %f\n",(double)size);
  311.  
  312. if(size>0) {mem = new char [size]; //helyfoglalás a file-nek
  313. } else {printf("A file mérete nulla!\n"); return(1);}
  314.  
  315. fp=fopen(fileneve,"rb");
  316.  
  317. if (!fp) { printf ("Nem tudom megnyitni a %s állományt!\n", fileneve); return(1); }
  318.  
  319. for(L=0L;L<size;L++) mem[L]=(char)fgetc(fp); // beolvassuk az állományt
  320. fclose(fp); // bezárjuk az állományt
  321.  
  322.  
  323.  
  324.  
  325.  
  326.  
  327. // ---------------- FŐCIKLUS ---------------
  328.  
  329. dirszam=fileszam=0;
  330.  
  331. osszfoglalt=0;
  332.  
  333. szamlalo=0; // lenullázzuk a következő sor számára
  334.  
  335. if(!kapcsolok['R']) {// ha nem rekurzívan listáz
  336.  
  337. // Tartalomjegyzékek listázása
  338. for(L=0L;L<size;L++) {// állományfeldolgozás kezdete
  339. // Itt kezdődik egy sor beolvasása
  340. c=(USC)mem[L];
  341. sor[szamlalo]=c;;
  342. szamlalo++;
  343. if(szamlalo==SORHOSSZ) {printf("Túl hosszú az állományból beolvasandó sor!\n"); return(1);}
  344. if(c=='\n') { // itt dolgozzuk fel a sort
  345. sor[szamlalo]=0; // lezárjuk a stringet egy nulla bájttal, mert biztos ami biztos...
  346. hossz=szamlalo; // ebben van a sor hossza hogy hány karakterből áll
  347. konyvtare=sor[0];
  348. if(konyvtare=='d') SorFeldolgozasa();
  349. szamlalo=0; // lenullázzuk a következő sor számára
  350.  
  351. } // sorfeldolgozás vége
  352. } // állományfeldolgozás vége
  353.  
  354.  
  355. // linkek istázása
  356. if(!kapcsolok['L']) {// nem listázzuk a linkeket a -L kapcsoló esetén
  357.  
  358. for(L=0L;L<size;L++) {// állományfeldolgozás kezdete
  359. // Itt kezdődik egy sor beolvasása
  360. c=(USC)mem[L];
  361. sor[szamlalo]=c;;
  362. szamlalo++;
  363. if(szamlalo==SORHOSSZ) {printf("Túl hosszú az állományból beolvasandó sor!\n"); return(1);}
  364. if(c=='\n') { // itt dolgozzuk fel a sort
  365. sor[szamlalo]=0; // lezárjuk a stringet egy nulla bájttal, mert biztos ami biztos...
  366. hossz=szamlalo; // ebben van a sor hossza hogy hány karakterből áll
  367. konyvtare=sor[0];
  368. if(konyvtare=='l') SorFeldolgozasa();
  369. szamlalo=0; // lenullázzuk a következő sor számára
  370.  
  371. } // sorfeldolgozás vége
  372. } // állományfeldolgozás vége
  373.  
  374. } // linklistázás vége
  375.  
  376. // fájlok istázása
  377. for(L=0L;L<size;L++) {// állományfeldolgozás kezdete
  378. // Itt kezdődik egy sor beolvasása
  379. c=(USC)mem[L];
  380. sor[szamlalo]=c;;
  381. szamlalo++;
  382. if(szamlalo==SORHOSSZ) {printf("Túl hosszú az állományból beolvasandó sor!\n"); return(1);}
  383. if(c=='\n') { // itt dolgozzuk fel a sort
  384. sor[szamlalo]=0; // lezárjuk a stringet egy nulla bájttal, mert biztos ami biztos...
  385. hossz=szamlalo; // ebben van a sor hossza hogy hány karakterből áll
  386. konyvtare=sor[0];
  387. if(konyvtare=='-') SorFeldolgozasa();
  388. szamlalo=0; // lenullázzuk a következő sor számára
  389.  
  390. } // sorfeldolgozás vége
  391. } // állományfeldolgozás vége
  392.  
  393.  
  394.  
  395.  
  396. } // nem rekurzív listázás vége
  397.  
  398. else {// rekurzív listázás kezdete
  399.  
  400. for(L=0L;L<size;L++) {// állományfeldolgozás kezdete
  401. // Itt kezdődik egy sor beolvasása
  402. c=(USC)mem[L];
  403. sor[szamlalo]=c;;
  404. szamlalo++;
  405. if(szamlalo==SORHOSSZ) {printf("Túl hosszú az állományból beolvasandó sor!\n"); return(1);}
  406. if(c=='\n') { // itt dolgozzuk fel a sort
  407. sor[szamlalo]=0; // lezárjuk a stringet egy nulla bájttal, mert biztos ami biztos...
  408. hossz=szamlalo; // ebben van a sor hossza hogy hány karakterből áll
  409. konyvtare=sor[0];
  410. if((konyvtare=='.')||(konyvtare=='/')) printf("\n%s\n",sor);
  411. else SorFeldolgozasa();
  412. szamlalo=0; // lenullázzuk a következő sor számára
  413.  
  414. } // sorfeldolgozás vége
  415. } // állományfeldolgozás vége
  416.  
  417.  
  418. } // rekurzív listázás vége
  419.  
  420.  
  421. // egyebek istázása
  422. for(L=0L;L<size;L++) {// állományfeldolgozás kezdete
  423. // Itt kezdődik egy sor beolvasása
  424. c=(USC)mem[L];
  425. sor[szamlalo]=c;;
  426. szamlalo++;
  427. if(szamlalo==SORHOSSZ) {printf("Túl hosszú az állományból beolvasandó sor!\n"); return(1);}
  428. if(c=='\n') { // itt dolgozzuk fel a sort
  429. sor[szamlalo]=0; // lezárjuk a stringet egy nulla bájttal, mert biztos ami biztos...
  430. hossz=szamlalo; // ebben van a sor hossza hogy hány karakterből áll
  431. konyvtare=sor[0];
  432. if((konyvtare!='-')&&(konyvtare!='l')&&(konyvtare!='d')) SorFeldolgozasa();
  433. szamlalo=0; // lenullázzuk a következő sor számára
  434.  
  435. } // sorfeldolgozás vége
  436. } // állományfeldolgozás vége
  437.  
  438.  
  439.  
  440.  
  441.  
  442.  
  443.  
  444.  
  445.  
  446.  
  447. if(kapcsolok['o']) {
  448. printf("Alkönyvtárak száma: %u; fájlok száma: %u, Összesen: %u állomány\n",dirszam,fileszam,dirszam+fileszam);
  449. 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,
  450. osszfoglalt/1024/1024/1024+1);
  451.  
  452. }
  453.  
  454. printf("\n");
  455.  
  456.  
  457. // Töröljük az ideiglenes állományt
  458. parancselejehossza=strlen(torloparancseleje);
  459. for(i=0;i<parancselejehossza;i++) parancs[i]=torloparancseleje[i];
  460. for(i=0;i<filenevehossza;i++) parancs[parancselejehossza+i]=fileneve[i];
  461. parancs[parancselejehossza+filenevehossza]=0;
  462. statusz = system(parancs);
  463. if(statusz==-1) {printf("Nem sikerült a %s parancs végrehajtása!\n",parancs); return(1);}
  464.  
  465.  
  466.  
  467. delete[] mem; // felszabadítjuk a memóriaterületet
  468.  
  469. return(0);
  470. }
  471. // ======================================================================================ó
  472. // ------------------------  main vége -------------------------
  473.  
  474. void SorFeldolgozasa() {
  475. USI i;
  476. USI mezohossz;
  477. char formatumkarakter;
  478.  
  479. // A sor karakterei sor[0] - tól sor[hossz-1] -ig vannak
  480.  
  481. 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
  482. if((konyvtare!='-')&&(konyvtare!='b')&&(konyvtare!='c')&&(konyvtare!='s')&&(konyvtare!='d')&&(konyvtare!='l'))
  483. {printf("%s",sor);return;} // Ha első karaktere nem fájltípusjelölő, kiírjuk.
  484.  }
  485.  
  486. if((konyvtare!='-')&&(konyvtare!='b')&&(konyvtare!='c')&&(konyvtare!='s')&&(konyvtare!='d')&&(konyvtare!='l')) {return;}
  487.  
  488. for(i=1;i<10;i++) allomanyattributuma[i-1]=sor[i];
  489. allomanyattributuma[10]=0;
  490.  
  491. // Itt jön egy undorító szövegfeldolgozás, ahol szétvágjuk mezőkre a beolvasott sort
  492. mezo2=10;
  493. while((cc=sor[mezo2])==SPACE) {mezo2++;} // A ciklus lefutása után mezo2 az első nem szóköz karakterre mutat
  494. i=0;while((allomany2[i]=sor[mezo2+i])!=SPACE) {i++;} allomany2[i]=0;
  495.  
  496. mezo3=mezo2;
  497. while((cc=sor[mezo3])!=SPACE) {mezo3++;} // A ciklus lefutása után mezo3 az első szóköz karakterre mutat
  498. while((cc=sor[mezo3])==SPACE) {mezo3++;} // A ciklus lefutása után mezo3 az első nem szóköz karakterre mutat
  499. i=0;while((allomany3[i]=sor[mezo3+i])!=SPACE) {i++;} allomany3[i]=0;
  500.  
  501. mezo4=mezo3;
  502. while((cc=sor[mezo4])!=SPACE) {mezo4++;} // A ciklus lefutása után mezo4 az első szóköz karakterre mutat
  503. while((cc=sor[mezo4])==SPACE) {mezo4++;} // A ciklus lefutása után mezo4 az első nem szóköz karakterre mutat
  504. i=0;while((allomany4[i]=sor[mezo4+i])!=SPACE) {i++;} allomany4[i]=0;
  505.  
  506. mezo5=mezo4;
  507. while((cc=sor[mezo5])!=SPACE) {mezo5++;} // A ciklus lefutása után mezo5 az első szóköz karakterre mutat
  508. while((cc=sor[mezo5])==SPACE) {mezo5++;} // A ciklus lefutása után mezo5 az első nem szóköz karakterre mutat
  509. i=0;while((allomany5[i]=sor[mezo5+i])!=SPACE) {i++;} allomany5[i]=0;
  510.  
  511. mezo6=mezo5;
  512. while((cc=sor[mezo6])!=SPACE) {mezo6++;} // A ciklus lefutása után mezo6 az első szóköz karakterre mutat
  513. while((cc=sor[mezo6])==SPACE) {mezo6++;} // A ciklus lefutása után mezo6 az első nem szóköz karakterre mutat
  514. i=0;while((allomany6[i]=sor[mezo6+i])!=SPACE) {i++;} allomany6[i]=0;
  515.  
  516. mezo7=mezo6;
  517. while((cc=sor[mezo7])!=SPACE) {mezo7++;} // A ciklus lefutása után mezo7 az első szóköz karakterre mutat
  518. while((cc=sor[mezo7])==SPACE) {mezo7++;} // A ciklus lefutása után mezo7 az első nem szóköz karakterre mutat
  519. i=0;while((allomany7[i]=sor[mezo7+i])!=SPACE) {i++;} allomany7[i]=0;
  520.  
  521. mezo8=mezo7;
  522. while((cc=sor[mezo8])!=SPACE) {mezo8++;} // A ciklus lefutása után mezo8 az első szóköz karakterre mutat
  523. while((cc=sor[mezo8])==SPACE) {mezo8++;} // A ciklus lefutása után mezo8 az első nem szóköz karakterre mutat
  524. i=0;while((allomany8[i]=sor[mezo8 + i])!='\n') {i++;}  allomany8[i]=0;
  525.  
  526.  
  527.  
  528. if(kapcsolok['p']==0) {// Akkor listázzuk a . és .. tartalomjegyzékeket, ha be van kapcsolva a -p kapcsoló
  529. if ((sor[mezo8]=='.')&&(sor[mezo8 + 1]=='\n')) {return; } // Kihagyjuk a "." bejegyzést
  530. if ((sor[mezo8]=='.')&&(sor[mezo8 + 1]==0)) {return; } // Kihagyjuk a "." bejegyzést
  531. if ((sor[mezo8]=='.')&&(sor[mezo8 + 1]=='.')&&(sor[mezo8 + 2]=='\n')) {return;} // Kihagyjuk a ".." bejegyzést
  532. if ((sor[mezo8]=='.')&&(sor[mezo8 + 1]=='.')&&(sor[mezo8 + 2]==0)) {return;} // Kihagyjuk a ".." bejegyzést
  533. } // -p kapcsoló tesztjének vége
  534.  
  535. 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ó
  536.  
  537. if (sor[mezo8]=='.') {
  538. if (!
  539. (
  540. ((sor[mezo8]=='.')&&(sor[mezo8 + 1]=='\n'))
  541. ||
  542. ((sor[mezo8]=='.')&&(sor[mezo8 + 1]=='.')&&(sor[mezo8 + 2]=='\n'))
  543. )
  544. ) // if vege
  545.  
  546. return; // Kihagyjuk a ponttal kezdődő nevű bejegyzéseket
  547.  
  548. }
  549. } // -P kapcsoló tesztjének vége
  550.  
  551.  
  552.  
  553.  
  554.  
  555.  
  556.  
  557.  
  558.  
  559.  
  560.  
  561.  
  562.  
  563. allomanymeret=0;
  564.  
  565. if(konyvtare=='d') dirszam++;
  566. if(konyvtare=='-') fileszam++;
  567.  
  568.  
  569.  
  570.  
  571.  
  572.  
  573. // kezdetben minden bit nulla
  574. tulajdonos.byte=csoport.byte=mindenki.byte=spec.byte=0;
  575.  
  576.  
  577. if(sor[9]=='T') {spec.s.sticky=1;}
  578. if(sor[9]=='t') {spec.s.sticky=1;mindenki.j.x=1;}
  579. if(sor[6]=='S') {spec.s.groupid=1;}
  580. if(sor[6]=='s') {spec.s.groupid=1;csoport.j.x=1;}
  581. if(sor[3]=='S') {spec.s.userid=1;}
  582. if(sor[3]=='s') {spec.s.userid=1;tulajdonos.j.x=1;}
  583.  
  584. if (sor[1]=='r') {tulajdonos.j.r=1;}
  585. if (sor[2]=='w') {tulajdonos.j.w=1;}
  586. if (sor[3]=='x') {tulajdonos.j.x=1;}
  587. if (sor[4]=='r') {csoport.j.r=1;}
  588. if (sor[5]=='w') {csoport.j.w=1;}
  589. if (sor[6]=='x') {csoport.j.x=1;}
  590. if (sor[7]=='r') {mindenki.j.r=1;}
  591. if (sor[8]=='w') {mindenki.j.w=1;}
  592. if (sor[9]=='x') {mindenki.j.x=1;}
  593.  
  594.  
  595.  
  596. for(i=mezo5;i<mezo6;i++) filemeret[i-mezo5]=sor[i];
  597. filemeret[i]=0;
  598. allomanymeret=atof(filemeret);
  599. if(konyvtare=='-') osszfoglalt+=allomanymeret;
  600.  
  601. if((kapcsolok['d'])&&(konyvtare=='d')) return; // A -d kapcsoló esetén nem listázza a könyvtárakat
  602. if((kapcsolok['f'])&&(konyvtare=='-')) return; // A -f kapcsoló esetén nem listázza a fájlokat
  603.  
  604.  
  605. 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;}
  606.  
  607. // Formátumstring szerinti kiírás
  608.  
  609. jb=0; // Alapértelmezés szerint igazítunk: állományméretet és linkszámot jobbra, tulajdonos- és csoportnevet meg állománynevet balra
  610. jbhossz=0;
  611. voltszazalekjel=0;
  612. for(i=0;i<formatumstringhossz;i++) { // formátumstringfeldolgozó ciklus
  613. formatumkarakter=formatumstring[i];
  614. if(voltszazalekjel==0) {
  615. if(formatumkarakter!='%') {printf("%c",formatumkarakter);continue;}
  616. i++;if(i==formatumstringhossz) {printf("\nHibás formátumstring!\n");exit(1);}
  617. formatumkarakter=formatumstring[i];
  618. } //
  619. if(formatumkarakter=='%') {printf("%%");voltszazalekjel=0;jb=0;jbhossz=0;continue;} // % karakter
  620. if(formatumkarakter=='/') {printf("\n");voltszazalekjel=0;jb=0;jbhossz=0;continue;} // újsor karakter
  621.  
  622. 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
  623.  
  624. if(formatumkarakter=='a') {printf("%s",allomanyattributuma);voltszazalekjel=0;jb=0;jbhossz=0;continue;} // Az eredeti attributumstring ( rwxrwxrwx )
  625.  
  626. if(formatumkarakter=='s') {printf("%c",spec.byte+48);voltszazalekjel=0;jb=0;jbhossz=0;continue;} // A STICKY bit meg egyebek bájtja
  627.  
  628. if(formatumkarakter=='t') {printf("%c",tulajdonos.byte+48);voltszazalekjel=0;jb=0;jbhossz=0;continue;} // Az oktális jogosultságok első karaktere
  629.  
  630. if(formatumkarakter=='c') {printf("%c",csoport.byte+48);voltszazalekjel=0;jb=0;jbhossz=0;continue;} // Az oktális jogosultságok masodik karaktere
  631.  
  632. if(formatumkarakter=='m') {printf("%c",mindenki.byte+48);voltszazalekjel=0;jb=0;jbhossz=0;continue;} // Az oktális jogosultságok harmaddik karaktere
  633. 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;}
  634. // Az oktális jogosultságok mindegyik karaktere
  635.  
  636. if(formatumkarakter=='l') {if(jb==0){jb=2;} if(jbhossz==0) jbhossz=strlen(allomany2);kiirja(allomany2);continue;} // a 2. mező, linkek száma
  637.  
  638. if(formatumkarakter=='T') {if(jb==0){jb=1;} if(jbhossz==0) jbhossz=strlen(allomany3);kiirja(allomany3);continue;} // a 3. mező, a tulajdonos
  639. if(formatumkarakter=='G') {if(jb==0){jb=1;} if(jbhossz==0) jbhossz=strlen(allomany4);kiirja(allomany4);continue;} // a 4. mező, a csoport
  640. if(formatumkarakter=='M') {if(jb==0){jb=2;} if(jbhossz==0) jbhossz=strlen(allomany5);kiirja(allomany5);continue;} // a 5. mező, a méret
  641. if(formatumkarakter=='D') {printf("%s",allomany6);voltszazalekjel=0;jb=0;jbhossz=0;continue;} // a 6. mező, a dátum
  642. if(formatumkarakter=='I') {printf("%s",allomany7);voltszazalekjel=0;jb=0;jbhossz=0;continue;} // a 7. mező, az idő
  643. if(formatumkarakter=='n') {if(jb==0){jb=1;} if(jbhossz==0) {jbhossz=strlen(allomany8);} kiirja(allomany8);continue;} // a 8. mező, az állománynév
  644.  
  645. if(formatumkarakter=='b') {jb=1;voltszazalekjel=1;
  646. i++;if(i==formatumstringhossz) {printf("\nHibás formátumstring!\n");exit(1);}
  647. formatumkarakter=formatumstring[i];
  648. if((formatumkarakter<'0')||(formatumkarakter>'9')) {printf("\nHibás formátumstring!\n");exit(1);}
  649. jbhossz=0;
  650. while((formatumkarakter>='0')&&(formatumkarakter<='9')) {
  651. jbhossz*=10;jbhossz=jbhossz+formatumkarakter-'0';
  652. formatumkarakter=formatumstring[++i];
  653. } // while vége
  654. --i;
  655. continue;}
  656.  
  657. if(formatumkarakter=='j') {jb=2;voltszazalekjel=1;
  658. i++;if(i==formatumstringhossz) {printf("\nHibás formátumstring!\n");exit(1);}
  659. formatumkarakter=formatumstring[i];
  660. if((formatumkarakter<'0')||(formatumkarakter>'9')) {printf("\nHibás formátumstring!\n");exit(1);}
  661. jbhossz=0;
  662. while((formatumkarakter>='0')&&(formatumkarakter<='9')) {
  663. jbhossz*=10;jbhossz=jbhossz+formatumkarakter-'0';
  664. formatumkarakter=formatumstring[++i];
  665. } // while vége
  666. --i;
  667. continue;}
  668.  
  669. if((formatumkarakter>='0')&&(formatumkarakter<='9')) {jb=0;voltszazalekjel=1;
  670. jbhossz=0;
  671. while((formatumkarakter>='0')&&(formatumkarakter<='9')) {
  672. jbhossz*=10;jbhossz=jbhossz+formatumkarakter-'0';
  673. formatumkarakter=formatumstring[++i];
  674. } // while vége
  675. --i;
  676. continue;}
  677.  
  678.  
  679.  
  680. printf("%%%c",formatumkarakter); // ismeretlen kapcsolót csak simán kiírunk
  681. jb=0;voltszazalekjel=0;jbhossz=0;
  682. } //formátumstringfeldolgozó ciklus vége
  683. printf("\n");
  684.  
  685.  
  686. }
  687.  
  688. // ======================================================================================
  689.  
  690. void kiirja(char *mezo) {
  691. int mezohossz;int i;int max;
  692. // printf("jb=%u; jbhossz=%u, mezohossz=%u mezo=%s\n",jb,jbhossz,strlen(mezo),mezo);
  693. // printf("%s",mezo);
  694.  
  695. /*
  696. int jbhossz; // ebben lesz benne a kiirandó mező hossza
  697. char kiirando[256];
  698. char jb; // 1: balra igazít, 2: jobbra igazít
  699. */
  700. if(jb==0) {printf("%s",mezo);jbhossz=0;voltszazalekjel=0;return;jb=0;} // ekkor nem igazít
  701. if(jb>2) {printf("\nHIBA! jb=%u; mezo=%s\n",jb,mezo);exit(1);} // hiba, kilépés
  702. if(jbhossz>254) jbhossz=254; // Mert az ördög nem alszik...
  703. mezohossz=strlen(mezo);
  704. max=mezohossz;if(mezohossz>jbhossz) {printf("%s",mezo);jbhossz=0;jb=0;voltszazalekjel=0;return;}
  705. for(i=0;i<jbhossz;i++) {kiirando[i]=SPACE;}  // puffer törlése
  706.  
  707. if(jb==1) {kiirando[jbhossz]=0;
  708. for(i=0;i<max;i++) {kiirando[i]=mezo[i];} // for vége
  709.  
  710. } // jb==1 vége
  711.  
  712. if(jb==2) {
  713. for(i=0;i<max;i++) {kiirando[jbhossz-mezohossz+i]=mezo[i];} // for vége
  714. kiirando[jbhossz]=0;
  715. } // jb==2 vége
  716.  
  717. printf("%s",kiirando);
  718. jb=0; // Alapértelmezés szerint igazítunk: állományméretet és linkszámot jobbra, tulajdonos- és csoportnevet meg állománynevet balra
  719. jbhossz=0;
  720.  
  721. voltszazalekjel=0;
  722. return;
  723.  
  724. };
RAW Paste Data