Newsgroup: it.comp.lang.c
Titolo: open O_CREAT

Non riesco a creare il file, da un problema con la O_CREAT mentre se ho già
un file creato la O_WRONLY funziona perfettamente
fd =open(pluto,"O_WRONLY"||"O_CREAT","S_IRWXU");
Ho provato in diversi modi, in fase di compilazione tutto ok ma quando
faccio girare il programma se il file non esiste mi ritorna fd=-1.
Chi può aiutarmi? Grazie



Ciao,
    prova a usare questa forma:
fd = open(pluto,O_WRONLY | O_CREAT);
In Unix questa procedura funziona benissimo. Naturalmente devi aver
importato le giuste librerie.



Hey, O_WRONLY, O_CREAT e S_IRWXU sono costanti, che sono quelle
virgolette?:)
Jop

 ha scritto nel messaggio
news:l_mi9.18528$Hc7.3...@twister1.libero.it...


Chi puň aiutarmi? Grazie
'open()' l'ho usato solo poche volte; a quello che ci ho capito:
#include <fcntl.h>
#if SYSTEM == MSDOS /*borland*/
  #define HDR <io.h>
#elif
  #define HDR <unistd.h> /*unix*/
#endif 
#include HDR
#if SYSTEM == MSDOS
  #define PERMS _A_NORMAL
#elif
  #define PERMS  0666
#endif 
[...]
if((fd=open(name, O_WRONLY , 0))==-1)
           fd=creat(name, PERMS);

Provando a togliere le virgolette " in compilazione mi dice O_WRONLY
undeclared (first use in this function)
Usavo le virgolette perchè ho visto che se il file non deve crearlo e quindi
non uso O_CREAT funziona!
Le librerie che includo sono le seguenti:
signal.h
errno.h
stdio.h
ne manca qualcuna?
Inoltre nello spezzone di codice precedente
fd=open(pippo, "O_RDONLY", 0),
if (fd != -1)
        dup2(fd,0);
else
        printf(".....");
il programma fa esattamente quello che chiedo (in questo caso ridirige lo
Standard Input)
Il problema è appunto nel caso in cui voglio ridirigere lo Standard Output
(ex. ls > ls.txt)
Se ls.txt non esiste non lo crea e dice impossibile aprire il file se invece
lo creo precedentemente e lancio questo comando ecco che mi mette la lista
dei file.

OK trovato mancava una libreria, grazie!
Chissa come mai perň in certi casi funzionava...


forse perche' quelle macro O_WRONLY O_ECC sono numeri

 fd =open(pluto,"O_WRONLY"||"O_CREAT","S_IRWXU");
fd = open(pluto, O_WRONLY | O_CREAT, S_IRWXU);
Sono macro  con valore numerico. Inoltre  ci vuole  un or bit  a bit. Mi
stupisce che  quello spezzone compili... Qui` pero`  siamo OT. Se lavori
sotto linux:
it.comp.os.linux.development
ciao
Kronos
-- 
Home: 
http://kronoz.cjb.net
"New processes are created by other processes, just like new
 humans. New humans are created by other humans, of course,
 not by processes." -- Unix System Administration Handbook

 Chissa come mai però in certi casi funzionava...
Il problema nasce dal fatto che il programma si aspettava un numero (nel 
caso in tipo intero) e tu gli passavi una stringa.
Quando tu passavi come parametro "O_CREAT" in realta' stavi passando alla 
funzione un puntatore a una zona di memoria contenente 8 caratteri (i 7 
caratteri della parola O_CREAT piu' il terminatore di stringa), 
probabilmente non modificabili.
Trovandosi in questa situazione, il compilatore convertiva il puntatore, che 
non e' altro che un indirizzo di memoria, in un intero e lo valutava.
Come puoi immaginare il comportamento in questi casi e' indefinito e cosa 
molto triste potrebbe anche funzionare correttamente ogni tanto.
P.S.  Alle prese con il laboratorio di Sistemi 2? :)
-- 
Mox
"Trust the programmer."
"Don't prevent the programmer from doing what needs to be done."
"Keep the language small and simple."
"Provide only one way to do an operation."

 probabilmente non modificabili.
Strano che il compilatore non desse nemmeno un warning [1].
C:\>iao Angelo
[1] O il programmatore non lo guardava, tanto e' solo un warning ... :-)
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

quasi, Sistemi 1!
"Mox" <m...@email.it.invalid> ha scritto nel messaggio
news:CEGi9.20752$Av4.3...@twister2.libero.it...


 [1] O il programmatore non lo guardava, tanto e' solo un warning ... :-)
No nessun warning!!!!


 Strano che il compilatore non desse nemmeno un warning.
Beh, un puntatore viene convertito[1] in intero quando utilizzato ove 
richiesto un intero.
Quando fai:
<code>
pippo * p;
if (!p) puts("Puntatore nullo");
</code>
Il compilatore converte il puntatore a un intero, mica ti segnala un warning 
:)
Stesso discorso si applica per il puntatore di cui sopra (nonostante sia.
[1] Il discorso non e' semplice. Un puntatore puo' essere in realta' 
rappresentato come in tipo intero o come una struttura piu' complessa.
Lo standard riporta questa informazione (C99-6.3.2.3): "Since pointers and 
integers are now considered incommensurate, the only integer value that can 
be safely converted to a pointer is the constant 0. The result of 
converting any other integer value to a point er is implement at 
ion-defined."
Stesso discorso (anche se non ho trovato un riferimento esplicito), vale nel 
caso opposto: puoi sempre essere sicuro che un puntatore a NULL venga 
convertito in 0, ma non sai in cosa verra' convertito un qualunque altro 
puntatore (se non che non sara' uno zero).
Questo pero' e' lecito e non deve segnalare warning.


 warning  :)
Implicitamente quella istruzione confronta il puntatore con NULL e questa
operazione, a quanto mi risulta, e' sempre permessa. Per questo non vengono
dati warning.
Che mi risulti, tutti i compilatori piu' recenti, quando si fanno
operazioni potenzialmente molto pericolose almeno un warning lo danno.
C:\>iao Angelo


 operazioni potenzialmente molto pericolose almeno un warning lo danno.
Gia', come detto prima dovevo controllare anche il comportamento dei 
compilatori oltre che la documentazione ufficiale del C.
