Write to file without write permission in C? - c

Question

I want to create a file and the file has no write permission like this.
#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
main()
{
int fd;
fd=open("xxx",O_CREAT|O_WRONLY|O_APPEND,S_IRUSR);
if(fd==-1)
return 0;
else
if(write(fd,"created",7)==-1)
return 0;
if(close(fd)==-1)
return 0;
printf("OK");
}
I ran executable file and notice that the file xxx could be written to. Of cource, when I ran executable after first time, it worked like I expect when it could't be written to.
But how can I make the file xxx even can't be written to in first time (when it is created).

Answer 1

You should remove:
O_WRONLY
And it should look like this:
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
int main(void){
int fd;
fd=open("test.sh",O_CREAT|O_APPEND,S_IRUSR);
if(fd==-1)
return 0;
else
if(write(fd,"created",7)==-1)
return 0;
if(close(fd)==-1)
return 0;
printf("OK");
return 0;
}
And if you try to write that file, you will get:
[ Error writing test.sh: Permission denied ]
Anyway, on my Linux machine if I wanna check that file, I will do it like this:
#include <stdio.h>
#include <stdlib.h>
#include<unistd.h>
void fileCheck(const char *fileName){
if(!access(fileName, F_OK )){
printf("The File %s\t Found\n",fileName);
}else{
printf("The File %s\t not Found\n",fileName);
exit(1);
}
if(!access(fileName, R_OK )){
printf("The File %s\t can be read\n",fileName);
}else{
printf("The File %s\t cannot be read\n",fileName);
}
if(!access( fileName, W_OK )){
printf("The File %s\t it can be Edited\n",fileName);
}else{
printf("The File %s\t it cannot be Edited\n",fileName);
}
if(!access( fileName, X_OK )){
printf("The File %s\t is an Executable\n",fileName);
}else{
printf("The File %s\t is not an Executable\n",fileName);
}
}
int main (void){
char *fileName = "test.sh";
fileCheck(fileName);
return 0;
}
And the output says:
The File test.sh Found
The File test.sh can be read
The File test.sh it cannot be Edited
The File test.sh is not an Executable

Answer 2

I can understand author's intent. He want to test the usage of S_IRUSR. I will explain why it doesn't work at first time.
At first let us resolve your question. you can just remove O_WRONLY and O_APPEND flag, and add O_RDONLY flag or not. Codes are following:
#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
int main() {
int fd;
fd = open("xxx", O_CREAT|O_RDONLY, S_IRUSR);
// or
// fd = open("xxx", O_CREAT, S_IRUSR);
if (fd == -1) {
printf("open failed\n");
return 0;
} else {
if (write(fd, "created", 7) == -1) {
printf("write failed\n");
return 0;
}
}
if (close(fd) == -1) {
printf("close failed\n");
return 0;
}
printf("OK\n");
}
then execute the program whenever, it will always says "write failed", and "xxx" is empty.
$ ls
test.c
$ make test
cc test.c -o test
$ ls
test test.c
$ ./test
write failed
$ ls
test test.c xxx
$ cat xxx
$ ./test
write failed
you said:
Of cource, when I ran executable after first time, it worked like I expect when it could't be written to.
in fact, if use your code, ran after first time, it is not couldn't be written to, it is not be open.
$ ls
test test.c
$ ./test
OK
$ ls
test test.c xxx
$ cat xxx
created
$ ./test
open failed
Then let us face the more important question, why S_ISUSR doens't work at first time. let us run 'man 2 open', it says:
Note that this mode applies only to future accesses of the newly created file; the open() call that creates a read-only file may well return a read/write file descriptor.
It means S_ISUSR only works after first time. Even S_ISUSR is read only, but in fact still return read/write permission, the final permission depends on the flags, if the flag is O_WRONLY, it can only write when create, if the flag is O_RDONLY, it can only read when create.
let's do a test:
#include <stdio.h>
#include <fcntl.h>
#include <sys/stat.h>
int main() {
int fd;
char buf[10];
fd = open("xxx", O_CREAT|O_WRONLY, S_IRUSR);
if (fd == -1) {
printf("open failed\n");
return 0;
} else {
if (write(fd, "created", 7) == -1) {
printf("write failed\n");
return 0;
}
}
if (read(fd, buf, 7) == -1) {
printf("read failed\n");
return 0;
} else {
printf(buf);
}
if (close(fd) == -1) {
printf("close failed\n");
return 0;
}
printf("OK\n");
}
and result is expected, at first time, when file create, if has write permission and has no read permission, after first time, it open failed:
$ ls
test.c
$ make test
cc test.c -o test
$ ./test
read failed
$ ./test
open failed
$ cat xxx
created
And I can understand why they design the mode parameter only work after first time. You think, if S_IRUSR works when file create, then the file is always empty and read only, it has no sense.