Perché open () crea il mio file con le autorizzazioni sbagliate?

Sto cercando di leggere del testo da un file e di scriverlo su un altro usando open() , read() e write() .

Questo è il mio open() per il file-to-write-to (Voglio creare un nuovo file e scriverlo):

 fOut = open ("test-1", O_RDWR | O_CREAT | O_SYNC); 

Questo sta impostando i permessi dei file su qualcosa che non capisco affatto. Questo è l’output di ls -l :

 ---------T 1 chaitanya chaitanya 0 2010-02-11 09:38 test-1 

Anche il permesso di lettura è bloccato. Ho provato a cercare questo, ma non ho trovato nulla. Stranamente, write() scrive ancora correttamente i dati nel file.

Inoltre, se faccio un ‘chmod 777 test-1’, le cose riprendono a funzionare correttamente.

Qualcuno potrebbe per favore farmi sapere dove sto andando male nella mia chiamata aperta?

Grazie!

Come riferimento, ho incollato il programma completo di seguito:

 #include  #include  #include  #include  int main () { char buffer[512], ch; int fIn, fOut, i; ssize_t bytes; FILE *fp = NULL; //open a file fIn = open ("test", O_RDONLY); if (fIn == -1) { printf("\nfailed to open file."); return 1; } //read from file bytes = read (fIn, buffer, sizeof(buffer)); //and close it close (fIn); printf("\nSuccessfully read %d bytes.\n", bytes); //Create a new file fOut = open ("test-1", O_RDWR | O_CREAT | O_SYNC); printf("\nThese are the permissions for test-1\n"); fflush(stdout); system("ls -l test-1"); //write to it and close it. write (fOut, buffer, bytes); close (fOut); //write is somehow locking even the read permission to the file. Change it. system("chmod 777 test-1"); fp = fopen ("test-1", "r"); if (fp == NULL) { printf("\nCan't open test-1"); return 1; } while (1) { ch = fgetc(fp); if (ch == EOF) break; printf("\n%c", ch); } fclose (fp); return 0; } 

open () prende un terzo argomento che è l’insieme di permessi, es

 open(filename, O_RDWR|O_CREAT, 0666) 

0666 è un numero ottale, ovvero ognuno dei 6 corrisponde a tre bit di authorization

6 = rw

7 = rwx

È una trappola tipica. Il compilatore ti permette di allontanare l’argomento dei permessi, perché quando apri un file esistente i bit di authorization non hanno senso. Ma quando dimentichi l’argomento quando crei un file, ottieni un insieme casuale di permessi, ad es. 0000 nel tuo caso (—).

Leggendo http://linux.die.net/man/2/open sembra che tu abbia perso il parametro mode per open:

la modalità deve essere specificata quando O_CREAT è nei flag e viene altrimenti ignorato. La modalità argomento specifica le autorizzazioni da utilizzare in caso di creazione di un nuovo file.

Questa domanda mi ha recentemente aiutato, quindi ho voluto fare la mia parte per aggiungere un po ‘più di profondità a ciò che sta succedendo. Come è stato affermato prima, ti mancava il terzo argomento per open() . Tuttavia, le autorizzazioni che vedi non sono casuali; vengono dallo stack. Guarda il seguente frammento di codice:

  asm("push $0"); asm("push $0"); asm("push $0"); fd = open("base", O_RDWR|O_CREAT); 

Nota il seguente risultato:

  ----------. 1 user user 4 Feb 26 08:21 base 

Cambiamo la prima spinta su 1, cioè esegui il permesso:

  asm("push $1;push $0;push $0"); fd = open("base", O_RDWR|O_CREAT); 

e otteniamo:

  ---------x. 1 user user 4 Feb 26 08:25 base 

Cambia il push a 4, cioè leggi i permessi e fai casino con gli altri due valori:

  asm("push $4;push $5;push $6"); fd = open("base", O_RDWR|O_CREAT); 

e otteniamo:

  -------r--. 1 user user 4 Feb 26 08:27 base 

Quindi possiamo vedere che il terzo valore estratto dallo stack (prima spinto) è ciò che conta davvero. Finalmente per divertimento possiamo provare 5 e poi 50, che risultano rispettivamente in:

  -------rx. 1 user user 4 Feb 26 08:27 base ----rw----. 1 user user 4 Feb 26 08:28 base 

Spero che questo aggiunga un po ‘di chiarezza!

In realtà umask() filtra solo i permessi e non li imposta. Il valore tipico di umask() è 0002 (“non dare il permesso di scrittura al mondo”) e se il valore della modalità in open( "file", O_CREAT, 0777) dato tutte le autorizzazioni, il file risultante avrebbe 775 come le sue peripezioni.

Non strettamente pertinente alla domanda, ma la risposta accettata potrebbe utilizzare questo punto di chiarimento:

Esiste una relazione tra rwx e la sua rappresentazione numerica che può essere vista trattando la presenza di una lettera come binario 1 e la sua assenza come binario 0.

per esempio

 rwx <--> 111 (binary) <--> 7 (octal) r-- <--> 100 (binary) <--> 4 (octal) -wx <--> 011 (binary) <--> 3 (octal) 

Come ulteriore addendum, puoi ora considerare il comando chmod:

chmod 777 nomefile.estensione -> permessi rwxrwxrwx

 777 <--> 111 111 111 <--> rwx rwx rwx 

oppure: chmod 654 nomefile.estensione -> rw-rxr–

 654 <--> 110 101 100 <--> rw- rx r-- 

Spero che questo è informativo!

puoi chiamare umask(0); chiamata di sistema prima di usare open(); chiamata di sistema per impostare le autorizzazioni delle scelte per file correttamente.

Questa è una specie di thread vecchio, ma penso che le persone dovrebbero essere consapevoli della libreria “sys / stat.h”. Ciò include un gruppo di costanti simboliche per l’impostazione di bit di authorization.

Ad esempio: per aprire un file con permessi di lettura / scrittura abilitati per l’utente

 #include  #include  open("Your/File/Path", O_RDWR | O_CREAT, S_IWUSR | S_IRUSR); 

dove:

 S_IWUSR // Sets the Users Write bit S_IRUSR // Sets the Users Read bit 

Questa libreria include un sacco di altri, non li elenco tutti qui ma puoi leggere tutto qui .

Naturalmente è ansible inserire i valori ottali per impostare questi bit, tuttavia alcuni potrebbero sostenere che si tratta di una ctriggers pratica di codifica.