C warning: implicit declaration of function 'flock' only applies to one of two flock() calls

Question

I improved my signal handling function but now when I try to compile my program via gcc ./test2.c -Wall -Wextra, I receive the following;

./test2.c: In function 'end_app':
./test2.c:21: warning: implicit declaration of function 'flock'
./test2.c: In function 'main':
./test2.c:46: warning: implicit declaration of function 'usleep'
./test2.c:47: warning: implicit declaration of function 'close'

This is the source code to test2.c

#include <stdio.h>
#include <stdlib.h>
    #include <signal.h>
    #include <fcntl.h>

    static int end=0;
    static int f;

    static void end_app(int sig){
      printf("Ending from sig#%d",sig);
      struct sigaction si;
      si.sa_handler=SIG_DFL;
      si.sa_flags=0;
      sigaction(SIGCHLD,&si,NULL);
      sigaction(SIGTSTP,&si,NULL);
      sigaction(SIGTTOU,&si,NULL);
      sigaction(SIGTTIN,&si,NULL);
      sigaction(SIGSEGV,&si,NULL);
      sigaction(SIGTERM,&si,NULL);
      sigaction(SIGHUP,&si,NULL);
      flock(f,LOCK_UN); //compiler gives implicit declaration warning
      printf("Ended\n");end=1;
    }

    void newsig(){
      struct sigaction s,o;
      o.sa_handler=SIG_DFL;
      o.sa_flags=0;
      s.sa_handler=&end_app;
      s.sa_flags=SA_RESTART;
      sigaction(SIGCHLD,&s,&o);
      sigaction(SIGTSTP,&s,&o);
      sigaction(SIGTTOU,&s,&o);
      sigaction(SIGTTIN,&s,&o);
      sigaction(SIGSEGV,&s,&o);
      sigaction(SIGTERM,&s,&o);
      sigaction(SIGHUP,&s,&o);
    }

int main(){
      f=open("xx.pid",O_WRONLY|O_CREAT|0x700);
      flock(f,LOCK_EX); //function works here
      printf("Started\n");
      newsig();
      while(1){
        usleep(1000);
        if (end==1){close(f);return 0;}
      }
      return 0;
    }

My question is why would the compiler complain about the use of flock in my signal handler function but it doesn't complain about it in the main function? and what can I do to rectify this? I need flock to work so that I can successfully lock and unlock the file.

[This `flock` manual page](http://man7.org/linux/man-pages/man2/flock.2.html) might help you. I recommend you look up the manual pages for the other functions too. — Some programmer dude, Oct 17 '15 at 04:31
Is `flock()` async-signal-safe? It's not listed in the Linux `signal` man page (http://man7.org/linux/man-pages/man7/signal.7.html) as being async-signal-safe, but I can't see why it wouldn't be as `fcntl()` can be used to perform file locks also, and `fcntl()` is async-signal-safe. — Andrew Henle, Oct 17 '15 at 04:46

score 3 · Answer 1 · edited May 23 '17 at 12:00

As the warning says, the flock function is implicitly declared the first time you use it. Since it was already (implicitly) declared earlier in the file, the compiler doesn't complain about the later usage.

If you comment out the first call, then it should complain about the second.

You should include the header file where the function is declared to get rid of the warning. According to the manpage link in Joachim Pileborg's comment above, the header is <sys/file.h>.

PC Luddite · Accepted Answer · 2015-10-17T05:52:33.053

You're getting that warning because you haven't added the proper #includes (i.e. you used those functions without an explicit declaration). When a function isn't given an explicit prototype, the compiler assumes each parameter type is int. This can cause undesired behavior when the size of actual function parameter types don't equal the size of int.

GCC only issues this warning once per function so your build output won't be cluttered with pages of the same message.

For flock() you need #include <sys/file.h>.

usleep() and close() require #include <unistd.h>.

C warning: implicit declaration of function 'flock' only applies to one of two flock() calls

2 Answers2