使用make包含头文件时出错

Question

I have to compile two independent processes- sendfdsock.c and recvfdsock.c using make file. Both the files have there own main function. This means they are independent and I have to compile them as two different binaries. This is my make file:

compileAll:sendfdsock recvfdsock


sendfdsock:sendfdsock.o 
    gcc -o sendfdsock sendfdsock.o

sendfdsock.o:sendfdsock.c accessories.h
    gcc -c sendfdsock.c


recvfdsock.o:recvfdsock.c accessories.h
    gcc -c recvfdsock.c

recvfdsock:recvfdsock.o 
    gcc -o recvfdsock recvfdsock.o

Here I have made a compileAll target which compiles both the files.
Both files need to use accessories.h . As mention in GNU Make Doc - A simple Make file. I wrote this make file.

accessories.h :

#include <malloc.h>
#include <time.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <pthread.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <error.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <sys/un.h>
#include <stropts.h>

#define PORT "4444" //port we are listening on

int sendall(int fd, char *buf, int *len);
int recvall(int fd, char *buf, int *len);
void logp(int typ, char* msg);
void errorp(char *where, int boolean, int errn,char *what);

accessories.c :

#include "accessories.h"

void logp(int typ, char* msg) // typ --> type(category) of message [1-Normal Log, 2-Warning(any unexpected thing happened), 3-Error, 4-Debugging Log ]
{
    int fd;
    time_t now;
    ssize_t wlength=0;
    char * dat;
    char * str;
    int size = 45+strlen(msg);//14+24+5+sizeof msg+1

    str= (char *) malloc(size);

    time(&now);//system time in seconds
    dat = ctime(&now); // converting seconds to date-time format
    dat = strtok(dat,"\n");

    //Appending type of log
    switch(typ)
    {
    case 1:
        strcpy(str,"__LOG__    |  ");
        strcat(str,dat);
        break;
    case 2:
        strcpy(str,"__WARN__   |  ");
        strcat(str,dat);
        break;
    case 3:
        strcpy(str,"__ERR__    |  ");
        strcat(str,dat);
        break;
    case 4:
        strcpy(str,"__DEBUG__  |  ");
        strcat(str,dat);
        break;
    default:
        strcpy(str,"__UNDEF__  |  ");
        strcat(str,dat);
        break;
    }


    strcat(str,"  |  ");
    strcat(str,msg);//appending message
    strcat(str,"\n");

    fd = open("log", O_WRONLY | O_CREAT | O_APPEND, 0644); // should be opened somewhere else
    if (fd == -1)
        printf("Could not open log - %s\n",strerror(errno));
    else
    {//need to add lock to the file and printing error message
        while ( wlength < strlen(str) )
        {
            wlength = write(fd, str,strlen(str));
            if (wlength == -1)
            {
                printf("Error : writing log\n");
                break;
            }
        }


    }
}

int sendall(int fd, char *buf, int *len)
{
    int total = 0;        // how many bytes we've sent
    int bytesleft = *len; // how many we have left to send
    int n;

    while(total < *len) {
        n = send(fd, buf+total, bytesleft, 0);
        if (n == -1) { break; }
        total += n;
        bytesleft -= n;
    }

    *len = total; // return number actually sent here

    return n==-1?-1:0; // return -1 on failure, 0 on success
}

int recvall(int fd, char *buf, int *len)
{
    int total = 0;        // how many bytes we've sent
    int bytesleft = *len; // how many we have left to send
    int n;

    while(total < *len) {
        n = recv(fd, buf+total, bytesleft, 0);
        if (n == -1) { break; }
        total += n;
        bytesleft -= n;
    }

    *len = total; // return number actually sent here

    return n==-1?-1:0; // return -1 on failure, 0 on success
} 

void errorp(char *where, int boolean, int errn,char *what)
{
    char errmsg[21+strlen(where)];
    strcpy(errmsg,"Where - ");
    strcat(errmsg,where);
    strcat(errmsg,"  |  Error - ");

    if(boolean == 1)//we got error number
    {
        strcat(errmsg,strerror(errn));
        //fprintf(stderr,"ERROR - In %s and error is %s\n",where ,strerror(errn));
        logp(3,errmsg);
    }
    else if(boolean == 0)//we got a message
    {
        strcat(errmsg,what);
        //fprintf(stderr,"ERROR - In %s and error is %s\n",where ,what);
        logp(3,errmsg);
    }
    else//we got nothing
    {
        strcat(errmsg,"No Message");
        //fprintf(stderr,"ERROR - In %s\n",where);
        logp(3,errmsg); 
    }
}

Initially everything work fine but when I trid to use any function which is defined in accessories.c compilation give me error.
For example I use the log function in sendfdsock.c :

#include "accessories.h"


#define CONTROLLEN  CMSG_LEN(sizeof(int))


static struct cmsghdr   *cmptr = NULL;  /* malloc'ed first time */ 
int send_err(int fd, int errcode, const char *msg);
int send_fd(int fd, int fd_to_send);

int main(int argc, char const *argv[])
{   
    logp(1,"started"); //This function is defined in accessories.c

    int fd_to_send;
    if((fd_to_send = open("vi",O_RDONLY)) < 0)
        printf("vi open failed");

    struct sockaddr_un address;
    int  socket_fd, nbytes;
    char buffer[256];
........

Output of the compilation is:

abhi@abhi-me:~/bridge/server$ make compileAll 
gcc -c sendfdsock.c
sendfdsock.c: In function ‘send_fd’:
sendfdsock.c:111:9: warning: format ‘%d’ expects argument of type ‘int’, but argument 2 has type ‘ssize_t’ [-Wformat]
sendfdsock.c:114:5: warning: format ‘%d’ expects argument of type ‘int’, but argument 2 has type ‘ssize_t’ [-Wformat]
gcc -o sendfdsock sendfdsock.o
sendfdsock.o: In function `main':
sendfdsock.c:(.text+0x32): undefined reference to `logp'
collect2: ld returned 1 exit status
make: *** [sendfdsock] Error 1
abhi@abhi-me:~/bridge/server$ 

Why undefined reference to logp error?

Why I don't write accessories.o in final linking:

But as this example is given in GNU Make Doc:

In this example, all the C files include ‘defs.h’, but 
only those defining editing comminclude ‘command.h’, and only
low level files that change the editor buffer include 'buffer.h':


edit : main.o kbd.o command.o display.o \
    insert.o search.o files.o utils.o
    cc -o edit main.o kbd.o command.o display.o \
    insert.o search.o files.o utils.o
main.o : main.c defs.h
    cc -c main.c
kbd.o : kbd.c defs.h command.h
    cc -c kbd.c
command.o : command.c defs.h command.h
    cc -c command.c
display.o : display.c defs.h buffer.h
    cc -c display.c
insert.o : insert.c defs.h buffer.h
    cc -c insert.c
search.o : search.c defs.h buffer.h
    cc -c search.c
files.o : files.c defs.h buffer.h command.h
    cc -c files.c
utils.o : utils.c defs.h
    cc -c utils.c
clean :
    rm edit main.o kbd.o command.o display.o \
    insert.o search.o files.o utils.o

Here while linking all the files in edit they don't write defs.o or buffer.o . Means while linking they are not including object files of header files. Also they have not written any target like: defs.o or buffer.o Why ?

Answer 1

You just missed accessories.o in both linking targets. Something like this:

accessories.o: accessories.c

sendfdsock: sendfdsock.o accessories.o
    $(CC) -o $@ $(CFLAGS) $(LDFLAGS) $+

Also, consider using the built-in rules, just modify their parameters, if needed. See make -p for the full list (and makes infopage)

Answer 2

You misunderstand the relationship between source files, header files and object files.

Suppose I have the following four files:

//foo.h
#define PI 3.1

//bar.h
void func();

//bar.c
#include "foo.h"
#include "bar.h"
void func()
{
  ...
}

//baz.c
#include "foo.h"
#include "bar.h"

int main()
{
  func();
}

(I left out the header guards, I presume you know about those.) I must use the compiler to produce an object file from each source file: bar.c -> bar.o and baz.c -> baz.o . I don't have to make object files from the headers foo.h and bar.h , those will simply be #include d by any source file that needs them. Then I link the object files together to form an executable:

baz: bar.o baz.o
    gcc -o baz bar.o baz.o

bar.o: bar.c foo.h bar.h
    gcc -c bar.c

baz.o: baz.c foo.h bar.h
    gcc -c baz.c

If I neglect to link bar.o into the executable, I'll get a linker error when the linker gets to the place where baz calls func() and the linker doesn't know what to put there (because it lacks the definition of func() in bar.o ):

baz.o: In function `main':
baz.c:(.text+0x32): undefined reference to `func()'

So the GNU Make doc is correct, and as Alex said, your rule should have:

sendfdsock:sendfdsock.o accessories.o
    ...

accessories.o: accessories.c accessories.h
    ...

(Incidentally, once you get this makefile working, we can show you how to make it more concise.)