I am working on an assignment in which we are developing our own RPC client. Upon compiling my server portion, I receive warnings for the following:
implicit declaration of function 'read'
implicit declaration of function 'write'
I understand that I would typically receive this warning if I were to create a function following my main, ex:
int main() {
doSomething();
}
void doSomething() {
...
}
In the above case, it should complain about the function that I created "doSomething".
Why then would my compiler complain that a system call was declared implicitly, when it appears in a function that was declared before the main? Below is the function in which the system call appears.
void Open(int connfd) {
/*Get message size*/
unsigned char temp[4] = { 0 };
int n = read(connfd, temp, 4);
if(n < 0) {/*On error*/
perror("Read error");
exit(1);
}/*End if*/
unsigned int msgSize = temp[0] +
(temp[1] * 256) +
(temp[2] * 256 * 2) +
(temp[3] * 256 * 3);
printf("msgSize = %d\n", msgSize);
/*Allocate memory for message*/
char * msg = malloc(msgSize);
if(msg == NULL) {
perror("Allocation error");
exit(1);
}/*End if*/
msg = memset(msg, 0, msgSize);
/*Read entire message from client*/
n = read(connfd, msg, msgSize);
if(n < 0) {/*On error*/
perror("Read error");
exit(1);
}/*End if*/
/*Extract pathname from message - NULL terminated*/
char * pathname = malloc(strlen(msg) + 1);
if(pathname == NULL) {
perror("Allocation error");
exit(1);
}/*End if*/
pathname = memset(pathname, 0, strlen(msg) + 1);
pathname = memcpy(pathname, msg, strlen(msg));
/*Extract flags from message*/
int i;
for(i = 0; i < sizeof(int); i++) {
temp[i] = msg[strlen(pathname) + 1 + i];
}/*End for i*/
unsigned int flags = temp[0] +
(temp[1] * 256) +
(temp[2] * 256 * 2) +
(temp[3] * 256 * 3);
/*Extract mode from message*/
for(i = 0; i < sizeof(mode_t); i++) {
temp[i] = msg[strlen(pathname) + 1 + sizeof(int) + 1 + i];
}/*End for i*/
mode_t mode = temp[0] +
(temp[1] * 256) +
(temp[2] * 256 * 2) +
(temp[3] * 256 * 3);
free(msg);/*Free msg since it is no longer needed*/
/*Open pathname*/
umask(0);
int fd = open(pathname, flags, mode);
free(pathname);/*Free pathname since it is no longer needed*/
/*Prepare response*/
char * response = malloc(sizeof(int) * 2);
if(response == NULL) {
perror("Allocation error");
exit(1);
}/*End if*/
response = memset(response, 0, sizeof(int) * 2);
/*Build return message*/
memcpy(&response[0], &fd, sizeof(fd));
memcpy(&response[4], &errno, sizeof(fd));
/*Can't guarante socket will accept all we try to write, cope*/
int num, put;
int left = sizeof(int) * 2; put = 0;
while(left > 0) {
if((num = write(connfd, response + put, left)) < 0) {
perror("inet_wstream: write");
exit(1);
} else {
left -= num;
put += num;
}/*End else*/
}/*End while*/
free(response);/*Free response since it is no longer needed*/
return;
}/*End Open*/
If a name appears in a program and is not explicitly declared, it is implicitly declared. The scope of an implicit declaration is determined as if the name were declared in a DECLARE statement immediately following the PROCEDURE statement of the external procedure in which the name is used.
Explicit variable declaration means that the type of the variable is declared before or when the variable is set. Implicit variable declaration means the type of the variable is assumed by the operators, but any data can be put in it.
Prior to the C99 standard, the C language permitted calls to functions with no visible declaration. Such a call would in effect create an implicit declaration of a function returning int and taking arguments of whatever (promoted) type you actually passed. Depending on this has never been a good idea.
Declaring a function - function prototypes In C and C++, functions must be declared before the are used. You can declare a function by providing its return value, name, and the types for its arguments. The names of the arguments are optional. A function definition counts as a function declaration.
Add #include <unistd.h>
include directive in your program.
read
and write
functions are declared in unistd.h
and you need a declaration of your functions before to be able to call them.
Implicit function declarations are those that the compiler sees the first time used as a function call (as opposed to those where a prototype or function definition is seen first).
"System calls" are no exception to this rule, since the C Standard(s) don't make a distinction between "ordinary functions" and "system calls". You likely forgot to include the relevant header providing the prototype (unistd.h
).
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With