How to use a function which takes a function parameter, in a thread that is used as a tcp server

Question

And I have to create a thread inside a function, that is (the thread) in an infinite loop waiting for connections and accepting messages from another process (so, the thread is going to work as a tcp server), and whenever a message comes, it has to ¿use? or call or whatever the function that's passed as a parameter, to the function the thread is created in.

So this is the function header

 int init(void (*notif)(const char *, const char *),
            void (*parameter1)(const char *),
            void (*parameter2)(const char *));

So I've seen this post How do you pass a function as a parameter in C? and it kind of helps to get the idea but I'm completly unsure how would I do it inside a thread.

And the reason for that is because I have little to no experience with servers inside threads, I found this code which is really helpful https://gist.github.com/silv3rm00n/5821760

But the way it works, all of the code is in the function (so outside the thread) and the thread takes as the only parameter the socket used for connections. I've seen it used similar to this a few times already.

And then I doubt: does it make sense to put all of the code of the server inside the thread? Or it would make little sense and the thread would be too "heavy" and it would be better to fork in that case.

I'm sorry if the question is poorly worded or I'm not explaining myself properly, I have little experience with threads and 0 experience with this type of problems.

edit: this is all I've got so far but I'm missing something, it does not work:

void (*funcionParametroThread)(const char *, const char *);
funcionParametroThread=(*notif_evento)(const char *, const char *);
pthread_create(&thid, &atrib_th, tcp_server, funcionParametroThread);

I tried making it similar to this code that is an answer from the linked question above

int dosomethingwithchar(char a) { return 1; }
functiontype2 func2 = &dosomethingwithchar
int result = func2('a');

Answer 1

(Keep in mind that I'm writing on the fly)

A thread (linux pthread) as normally this signature:

void * threadName(void *parms)

It's started by the function pthread_create that starts it passing parms.

typedef void * THFN_t(void *parms)

struct thStruct {
 volatile int a; //volatile because the value may change during inter-process!
 volatile int b;
 volatile int c;
};

void * thread(struct thStruct *k) 
{
    for(;;) {
       /* do your job */
    }

    pthread_exit(NULL);
}

int main(void) 
{
   struct thStruct s;

   s.a=1; //These structure will be passed to the thread
   s.b=2;
   s.c=3;

   pthread_attr_t attr;
    pthread_t thr;
   pthread_attr_init(attr);
    if (pthread_create(
                (pthread_t*)&thr,
                (pthread_attr_t*)&attr,
                (THFN_t *)thread, //The function above
                (void *)&s)) {
                     perror("Error");
                     return errno;
      }

      while(s.a!=0) { //Used to lock the main, but also to pass something to the thread!
         printf("Insert a number: ");
         scanf("%d",s.a);
      }
}

This is the skeleton that contains hints to explain you how to pass information to a running thread. Remember the volatile and remember that some changes may be executed as atomic (you might use mutex to change them in the correct way).

I understand you need to inform your thread that it has to call a function and you need this function be a parameter.

I hope this function will have a fixed number of parameter ... :)

We say that the function we will call will have this signature:

int fnname(int a, char *b);

Then we declare (I prefer so):

typedef int FNX(int a, char *b);

Then we insert in the structure thStruct an element that specifies a pointer to the function we want call.

struct thStruct {
 volatile int a; //volatile because the value may change during inter-process!
 volatile int b;
 volatile int c;
 volatile FNX * fn; //Function pointer
};

Now we need the function:

int functionX(int a, char *b)
{
   printf("%d %s\n",a,b);
}

Next step: In the main, where we have initialized the thStruct, we want signal what function the thread will be call when a specific event occurs (for example s.a becomes 5)

Ok:

we add:

s.fn=functionX;

Now we modify the thread:

void * thread(struct thStruct *k) 
{
    for(;;) {
       if (k->a==5) {
          k->fn(a,"Yeah!\n");
          k->a=4; //To avoid continue calling k->fn
       }
       sched_yield(); //To avoid useless use of CPU time
                      //(this thread does nothing and waits for nothing!)
    }

    pthread_exit(NULL);
}

Now, if the program doesn't contain errors, you may compile it (I think you may solve if errors occurs) and will run.

When it will ran, you may insert 5 when main asks you a number and the function functionX will be called!

How I said you, I've written this code on the fly to help you. It may contain errors, but it should be able to explain some basilar things you need. There's more, but I think this give you a good way!

This is the end!!! (The Doors)

Answer 2

What I've done based on the links given and the incredibly detailed post of Sergio Formiggini:

The function:

int init(void (*notif)(const char *, const char *),
        void (*parameter1)(const char *),
        void (*parameter2)(const char *));

inside that:

void (*funcionParametroThread)(const char *, const char *);
funcionParametroThread=&(*notif);

and to create the thread:

pthread_create(&thid, &atrib_th, tcp_server, funcionParametroThread);

And once inside the function I use for the thread (tcp_server):

void (*funcionParametroThread)(const char *, const char *);
    funcionParametroThread=arg;
    (*funcionParametroThread)(temaRecibido,valorRecibido);