🚀 go-pugleaf

dA_CoSMiC wrote:

> yow
> 
> had een klein vraagje waar ik al een tijdje mee verveeld zit
> hoe kan je in c code het linux commando " ls -al " opvragen van de actieve
> directory?
> voor alle duidelijkheid, ik programmeer alles ook in linux
>

Je kan zoiets doen via de system() functie.

Dit programma zou het moeten doen:

int main()
{
    system("ls -al");
}

Op http://www.acm.uiuc.edu/webmonkeys/book/c_guide/2.13.html#system staat 
het volgende:

***
2.13.4.5 system

Declaration:

    int system(const char *string);

The command specified by string is passed to the host environment to be 
executed by the command processor. A null pointer can be used to inquire 
whether or not the command processor exists.

If string is a null pointer and the command processor exists, then zero is 
returned. All other return values are implementation-defined. 
***

Mvg,

-- 
Jo Vermeulen
Student Computer Science at the tUL
email: jo@lumumba.luc.ac.be
www: http://lumumba.luc.ac.be/jo

> > had een klein vraagje waar ik al een tijdje mee verveeld zit
> > hoe kan je in c code het linux commando " ls -al " opvragen van de
actieve
> > directory?
> > voor alle duidelijkheid, ik programmeer alles ook in linux
> >
>
> Je kan zoiets doen via de system() functie.
>
> Dit programma zou het moeten doen:
>
> int main()
> {
>     system("ls -al");
> }

bedankt, werkt perfect, heb mij hier al op kapot gegoogled
als ge het niet weet dan is het zoeken naar speld in een hooibert

nu dat nog allen zien om te leiden naar een bestand
met "pipe + c programming" zal dat wel lukken hoop ik

merci

wim

dA_CoSMiC <da_cosmic@hotmail.com> wrote:
> had een klein vraagje waar ik al een tijdje mee verveeld zit hoe kan je in c
> code het linux commando " ls -al " opvragen van de actieve directory?

De properste manier om dit te doen is je directory openen, en in een loop
iedere file stat'en.  Met stat krijg je en pointer naar een struct stat waar
je je zin mee kunt doen.

Probleem met system(3) is dat je met een subprocess zit, wat potentieel op
verschillende punten kapot kan gaan.

Een andere niet-zo-propere manier is execve, net als system zit je met een
subprocess, maar je hebt er wel wat meer controle over.  Je zou bijvoorbeeld
zelf kunnen forken, je child in't oog houden en potenti�le errors op een
gezonde manier vangen.

> voor alle duidelijkheid, ik programmeer alles ook in linux

Zeer verstandig.

 - Philip

-- 
Philip Paeps                                                   philip@paeps.cx

  An optimist is a person who looks forward to marriage.
  A pessimist is a married optimist!

dA_CoSMiC wrote:

> yow
> 
> had een klein vraagje waar ik al een tijdje mee verveeld zit
> hoe kan je in c code het linux commando " ls -al " opvragen van de actieve
> directory?
> voor alle duidelijkheid, ik programmeer alles ook in linux


Je kan Jo's of Philips suggesties gebruiken als je gewoon "ls -la" wil
uitvoeren. Indien je de data die "ls -la" teruggeeft echter verder wil
verwerken in je programma is de system call geen goede oplossing imho. Daar
kan je beter de functies aangeboden in de dirent header voor gebruiken denk
ik. Zie
http://www.gnu.org/manual/glibc-2.2.3/html_node/libc_toc.html --> "Accessing
Directories"  voor wat meer uitleg.

Een simple voorbeeld:
dp = readdir("/de/dir/om/te/lezen");
while(eenEntry = readdir(dp)){
 ..doe iets met eenEntry...
}

mvg
Kris
-- 
Kris Luyten
kris ad lumumba dot luc dot ac dot be
http://lumumba.luc.ac.be/kris/

> > had een klein vraagje waar ik al een tijdje mee verveeld zit hoe kan je
in c
> > code het linux commando " ls -al " opvragen van de actieve directory?
>
> De properste manier om dit te doen is je directory openen, en in een loop
> iedere file stat'en.  Met stat krijg je en pointer naar een struct stat
waar
> je je zin mee kunt doen.

stat'en?
ken ik niet echt, ben nog maar een beginner
is stat ��n of ander functie, een type, ... ?

misschien volstaat die system functie wel in mijn klein project maar iets
bijleren kan nooit geen kwaad natuurlijk

thx

wim

On Thu, 6 Mar 2003 19:08:06 +0100, dA_CoSMiC <da_cosmic@hotmail.com> wrote:
>  stat'en?
>  ken ik niet echt, ben nog maar een beginner
>  is stat ��n of ander functie, een type, ... ?

man 2 stat

Mvg,	
	Sven Vermeulen

-- 
	Fighting for peace is like fucking for virginity.

dA_CoSMiC <da_cosmic@hotmail.com> wrote:
> Philip Paeps <philip@paeps.cx> wrote:
> > dA_CoSMiC <da_cosmic@hotmail.com> wrote:
> > > had een klein vraagje waar ik al een tijdje mee verveeld zit hoe kan je
> > > in c code het linux commando " ls -al " opvragen van de actieve
> > > directory?
> >
> > De properste manier om dit te doen is je directory openen, en in een loop
> > iedere file stat'en.  Met stat krijg je en pointer naar een struct stat
> > waar je je zin mee kunt doen.
> 
> stat'en?

Lees ook stat(2).

> ken ik niet echt, ben nog maar een beginner is stat ��n of ander functie,
> een type, ... ?

Het is een systemcall :-P

> misschien volstaat die system functie wel in mijn klein project maar iets
> bijleren kan nooit geen kwaad natuurlijk

Om een klein (en relatief zinloos en lelijk) voorbeeld te geven:


#include <sys/stat.h>
#include <sys/types.h>

#include <dirent.h>
#include <stdio.h>

int
main()
{
	DIR *dirp;              /* lees opendir(3)      */
	struct dirent *dp;      /* van hetzelfde        */
	struct stat st;         /* dit staat in stat(2) */
	
	dirp = opendir(".");    /* open de directory */

	while ((dp = readdir(dirp)) != NULL) 
	{
		stat(dp->d_name,&st);
		printf("%o, %s\n", (int)st.st_mode, dp->d_name);
	}
	(void)closedir(dirp);

	return 0;
}

Als je de source van ls(1) leest zul je (not checked) merken dat die het het
waarschijnlijk ook op zo'n manier doet.

Veel plezier.

 - Philip

-- 
Philip Paeps                                                   philip@paeps.cx

  BOFH Excuse #403:
    Sysadmin didn't hear pager go off due to loud music from bar-room
    speakers.

Kris Luyten <kris.luyten@luc.ac.be> wrote:
> dA_CoSMiC wrote:
> > had een klein vraagje waar ik al een tijdje mee verveeld zit hoe kan je in
> > c code het linux commando " ls -al " opvragen van de actieve directory?
> > voor alle duidelijkheid, ik programmeer alles ook in linux
> 
> Je kan Jo's of Philips suggesties gebruiken als je gewoon "ls -la" wil
> uitvoeren. Indien je de data die "ls -la" teruggeeft echter verder wil
> verwerken in je programma is de system call geen goede oplossing imho. 

Het heeft iets weg van een treinticket kopen en dan te gaan lopen, vind ik.
Terwijl je toch code aan't schrijven bent, kan je even goed even twee
pointertjes en een struct extra gebruiken om rechtstreeks aan de data te
komen, in plaats van een child te forken en dan via een pipe of IPC de data te
gaan inlezen.

More than one way to do it, uiteraard :-)

> Daar
> kan je beter de functies aangeboden in de dirent header voor gebruiken denk
> ik. 

Met dirent(5) alleen ben je niet veel, tenzij je enkel 'opervlakkige' dingen
van de file wil weten (naam, lengte van naam, inode, filetype).  Als je het
soort output van ls(1) wil, kan je best ook nog even stat(2) aanspreken.

> Zie http://www.gnu.org/manual/glibc-2.2.3/html_node/libc_toc.html -->
> "Accessing Directories" voor wat meer uitleg.

Of uiteraard de manual op je systeem :-P

> Een simple voorbeeld:
> dp = readdir("/de/dir/om/te/lezen");
> while(eenEntry = readdir(dp)){

Mmm, je gaat wel eerst de directory moeten openen, niet?  De readdir() call
wil een DIR *, en geen const char*.  Volgens mijn manual, tenminste :-)

 - Philip

-- 
Philip Paeps                                                   philip@paeps.cx

  Never sleep with anyone crazier than yourself.

Philip Paeps wrote:
<snip>
>> Zie http://www.gnu.org/manual/glibc-2.2.3/html_node/libc_toc.html -->
>> "Accessing Directories" voor wat meer uitleg.
> 
> Of uiteraard de manual op je systeem :-P
> 
>> Een simple voorbeeld:
>> dp = readdir("/de/dir/om/te/lezen");
>> while(eenEntry = readdir(dp)){
> 
> Mmm, je gaat wel eerst de directory moeten openen, niet?  De readdir()
> call
> wil een DIR *, en geen const char*.  Volgens mijn manual, tenminste :-)

Het was code louter ter illustratie natuurlijk. Voor de rest: Read The Fine
Manual ;-)

Cheers,
Kris
-- 
Kris Luyten
kris ad lumumba dot luc dot ac dot be
http://lumumba.luc.ac.be/kris/

"dA_CoSMiC" <da_cosmic@hotmail.com> wrote in message
news:b47vqh$m1h$1@reader11.wxs.nl...
> > > had een klein vraagje waar ik al een tijdje mee verveeld zit
> > > hoe kan je in c code het linux commando " ls -al " opvragen van de
> actieve
> > > directory?
> > > voor alle duidelijkheid, ik programmeer alles ook in linux
> > >
> >
> > Je kan zoiets doen via de system() functie.
> >
> > Dit programma zou het moeten doen:
> >
> > int main()
> > {
> >     system("ls -al");
> > }
>
> bedankt, werkt perfect, heb mij hier al op kapot gegoogled
> als ge het niet weet dan is het zoeken naar speld in een hooibert
>
> nu dat nog allen zien om te leiden naar een bestand
> met "pipe + c programming" zal dat wel lukken hoop ik

Dit is quick and dirty:

system ("ls -al >bestand");

Luc K

> Dit is quick and dirty:
>
> system ("ls -al >bestand");
>
> Luc K

allemaal ongelofelijk bedankt!
was al bezig met de andere tips wat uit te werken, maar dat liep niet direct
van een leien dakje
dat het dirty code is geeft niet direct, het project draait immers eerder
rond sockets enzo dan rond system calls en het feit of die al dan niet
netjes zijn

waarom is dat eigenlijk zo'n beetje not done om op die manier te werken?

grtz

wim

dA_CoSMiC <da_cosmic@hotmail.com> wrote:
> > Dit is quick and dirty:
> >
> > system ("ls -al >bestand");
> >
> > Luc K
> 
> allemaal ongelofelijk bedankt!
> was al bezig met de andere tips wat uit te werken, maar dat liep niet direct
> van een leien dakje

Doorzetten!  Je kunt er alleen maar van bijleren.  En zo bepaald 'advanced'
waren de voorbeelden ook niet :-)

> dat het dirty code is geeft niet direct, het project draait immers eerder
> rond sockets enzo dan rond system calls en het feit of die al dan niet
> netjes zijn

Sockets gebruiken ook syscalls hoor :-P  Bind(2) is een syscall, listen(2)
ook, socket(2) ook, connect(2) ook...  Blijven niet veel library calls over
(nuja :-P).

> waarom is dat eigenlijk zo'n beetje not done om op die manier te werken?

Het probleem is dat je met system() een shell forkt die gaat dan je commando
uitvoeren.  Dat kan op veel manieren sterven: wil niet forken, child sterft,
uiteindelijke commando sterft, data overflowt de buffer die je ervoor
voorziet, enz.  Door gewoon zelf de informatie aan het systeem te vragen kan
je minder problemen krijgen, en zijn de problemen ook makkelijker te vangen.
Je hebt ook meer kans op 'portable' (brede definitie) code.  Je weet immers
niet wat voor krankzinnige shell 'Platform X' waarop je code gaat draaien
gebruikt, en wat voor bizarre dingen die met je input en output gaat doen.

System calls als stat zijn relatief standaard (POSIX...), en met een minimum
aan preprocessor geklungel kan je zonder problemen tussen de meeste UNIXen
porten.

Als extra voordeel is het gewoon effici�nter, en je spaart een paar entries in
je process-table.  Zuinig zijn op resources heet dat dan :-)

 - Philip

-- 
Philip Paeps                                                   philip@paeps.cx

  BOFH Excuse #192:
    runaway cat on system.

> > > Dit is quick and dirty:
> > >
> > > system ("ls -al >bestand");


> > allemaal ongelofelijk bedankt!
> > was al bezig met de andere tips wat uit te werken, maar dat liep niet
direct
> > van een leien dakje

> Doorzetten!  Je kunt er alleen maar van bijleren.  En zo bepaald
'advanced'
> waren de voorbeelden ook niet :-)

niet zo advanced, inderdaad, er kwamen al bepaalde zinnige dingen uit mijn
probeersel
maar het zat nog niet echt correct enzo
maar ik wil nu even doorwerken op de rest (is belangrijker)
als er nog tijd is voor de inleverdatum pas ik het misschien nog wel even
aan

en ja, ben nog maar een week of 3 met c bezig, altijd van die prutsdingen
read en write was zowat het maximum van systems calls (hoop dat ik deze keer
juist zit ;) )
de rest was verwerking zonder de kernel aan te hoeven spreken voor van die
dingen
vorige week is daar wat netwerkfunctionaliteit bij komen kijken
wil eigenlijk maar gewoon zeggen, het is maar door ervaring dat ge met zo'n
dingen effici�nt leert werken
en dat dat voor een stuk mee bepaalt hoe eenvoudig/moeilijk dingen zijn

> > waarom is dat eigenlijk zo'n beetje not done om op die manier te werken?

> <knip uw uitleg>

interessant om weten allemaal, merci

zal de illusie al maar opbergen om jullie ook ooit eens iets bij te kunnen
leren ;)
ik sta duidelijk een paar niveau's lager


grtz

wim

dA_CoSMiC <da_cosmic@hotmail.com> wrote:
> > > > Dit is quick and dirty:
> > > >
> > > > system ("ls -al >bestand");
> > >
> > > allemaal ongelofelijk bedankt!  was al bezig met de andere tips wat uit
> > > te werken, maar dat liep niet direct van een leien dakje
> >
> > Doorzetten!  Je kunt er alleen maar van bijleren.  En zo bepaald
> > 'advanced' waren de voorbeelden ook niet :-)
> 
> niet zo advanced, inderdaad, er kwamen al bepaalde zinnige dingen uit mijn
> probeersel maar het zat nog niet echt correct enzo maar ik wil nu even
> doorwerken op de rest (is belangrijker) als er nog tijd is voor de
> inleverdatum pas ik het misschien nog wel even aan

Prachtig :-) 

Je kunt je docent misschien nog verrassen door hem een mooie implementatie met
dingen 'buiten de cursus' te tonen.  More than one way to do things, en ik ben
er zeker van dat die mens na dertig system()s te verbeteren, een opendir(),
readdir(), stat(), closedir() een hele verademing zal vinden :-P

> en ja, ben nog maar een week of 3 met c bezig, altijd van die prutsdingen
> read en write was zowat het maximum van systems calls (hoop dat ik deze keer
> juist zit ;) )

Je hebt 'System Calls' (Section 2 van de de UNIX manual, lees ook intro(2)),
en 'system()', wat eigenlijk een 'Library Function' (Section 3 van de UNIX
manual, zie intro(3)) is.  Een System Call is een functie die door het systeem
ge�mplementeerd wordt, een Library Function wordt door je C-library (glibc op
Linux) aangeleverd, of door eender welke andere library waar je toevallig mee
linkt. (Very rough definition :-P)

Read(2) en write(2) zijn system calls.

> zal de illusie al maar opbergen om jullie ook ooit eens iets bij te kunnen
> leren ;)

Ik leer graag bij :-)  Ik leer elke dag wel iets bij (door domme fouten
voornamelijk :-P).

> ik sta duidelijk een paar niveau's lager

Je staat al op het C-niveau op Linux, je kon nog veeeeel lager zitten *grin*

 - Philip

-- 
Philip Paeps                                                   philip@paeps.cx

  As the economy gets better, everything else gets worse.