title: Link Paho MQTT CMake
body: <p>I am trying to compile a simple test application that uses PAHO-MQTT.
  I am running Antergos Linux x64. I can't compile my project because the PAHO files are not linked, and I don't know how to link them correctly.
  This is the Main.cpp I am trying to compile.</p>
  
  <pre><code>#include "stdio.h"
  #include "stdlib.h"
  #include "string.h"
  #include "src/MQTTAsync.h"
  #include "unistd.h"
  
  
  #define PUBLISHER 0
  volatile MQTTAsync_token deliveredtoken;
  
  int finished = 0;
  
  #if PUBLISHER
  
  #define ADDRESS     "tcp://192.168.2.118:1883"
  #define CLIENTID    "Publisher"
  #define TOPIC       "test/topic"
  #define PAYLOAD     "Hello World!"
  #define QOS         1
  #define TIMEOUT     10000L
  
  void connlost(void *context, char *cause)
  {
          MQTTAsync client = (MQTTAsync)context;
          MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
          int rc;
  
          printf("\nConnection lost\n");
          printf("     cause: %s\n", cause);
  
          printf("Reconnecting\n");
          conn_opts.keepAliveInterval = 20;
          conn_opts.cleansession = 1;
          if ((rc = MQTTAsync_connect(client, &amp;conn_opts)) != MQTTASYNC_SUCCESS)
          {
                  printf("Failed to start connect, return code %d\n", rc);
                  finished = 1;
          }
  }
  
  
  void onDisconnect(void* context, MQTTAsync_successData* response)
  {
          printf("Successful disconnection\n");
          finished = 1;
  }
  
  
  void onSend(void* context, MQTTAsync_successData* response)
  {
          MQTTAsync client = (MQTTAsync)context;
          MQTTAsync_disconnectOptions opts = MQTTAsync_disconnectOptions_initializer;
          int rc;
  
          printf("Message with token value %d delivery confirmed\n", response-&gt;token);
  
          opts.onSuccess = onDisconnect;
          opts.context = client;
  
          if ((rc = MQTTAsync_disconnect(client, &amp;opts)) != MQTTASYNC_SUCCESS)
          {
                  printf("Failed to start sendMessage, return code %d\n", rc);
                  exit(-1);
          }
  }
  
  
  void onConnectFailure(void* context, MQTTAsync_failureData* response)
  {
          printf("Connect failed, rc %d\n", response ? response-&gt;code : 0);
          finished = 1;
  }
  
  
  void onConnect(void* context, MQTTAsync_successData* response)
  {
          MQTTAsync client = (MQTTAsync)context;
          MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer;
          MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
          int rc;
  
          printf("Successful connection\n");
  
          opts.onSuccess = onSend;
          opts.context = client;
  
          pubmsg.payload = (void *) PAYLOAD;
          pubmsg.payloadlen = strlen(PAYLOAD);
          pubmsg.qos = QOS;
          pubmsg.retained = 0;
          deliveredtoken = 0;
  
          if ((rc = MQTTAsync_sendMessage(client, TOPIC, &amp;pubmsg, &amp;opts)) != MQTTASYNC_SUCCESS)
          {
                  printf("Failed to start sendMessage, return code %d\n", rc);
                  exit(-1);
          }
  }
  
  
  int main(int argc, char* argv[])
  {
          MQTTAsync client;
          MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
          MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
          MQTTAsync_token token;
          int rc;
  
          MQTTAsync_create(&amp;client, ADDRESS, CLIENTID, MQTTCLIENT_PERSISTENCE_NONE, NULL);
  
          MQTTAsync_setCallbacks(client, NULL, connlost, NULL, NULL);
  
          conn_opts.keepAliveInterval = 20;
          conn_opts.cleansession = 1;
          conn_opts.onSuccess = onConnect;
          conn_opts.onFailure = onConnectFailure;
          conn_opts.context = client;
          if ((rc = MQTTAsync_connect(client, &amp;conn_opts)) != MQTTASYNC_SUCCESS)
          {
                  printf("Failed to start connect, return code %d\n", rc);
                  exit(-1);
          }
  
          printf("Waiting for publication of %s\n"
           "on topic %s for client with ClientID: %s\n",
           PAYLOAD, TOPIC, CLIENTID);
          while (!finished)
  #if defined(WIN32) || defined(WIN64)
                          Sleep(100);
  #else
                          usleep(10000L);
  #endif
  
          MQTTAsync_destroy(&amp;client);
          return rc;
  }
  
  #elif PUBLISHER == 0
  
  #define ADDRESS     "tcp://192.168.2.118:1883"
  #define CLIENTID    "Subscriber"
  #define TOPIC       "test/topic"
  #define PAYLOAD     "Hello World!"
  #define QOS         1
  #define TIMEOUT     10000L
  
  int disc_finished = 0;
  int subscribed = 0;
  
  void connlost(void *context, char *cause) {
      MQTTAsync client = (MQTTAsync) context;
      MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
      int rc;
  
      printf("\nConnection lost\n");
      printf("     cause: %s\n", cause);
  
      printf("Reconnecting\n");
      conn_opts.keepAliveInterval = 20;
      conn_opts.cleansession = 1;
      if ((rc = MQTTAsync_connect(client, &amp;conn_opts)) != MQTTASYNC_SUCCESS) {
          printf("Failed to start connect, return code %d\n", rc);
          finished = 1;
      }
  }
  
  
  int msgarrvd(void *context, char *topicName, int topicLen, MQTTAsync_message *message) {
      int i;
      char *payloadptr;
  
      printf("Message arrived\n");
      printf("     topic: %s\n", topicName);
      printf("   message: ");
  
      payloadptr = (char *) message-&gt;payload;
      for (i = 0; i &lt; message-&gt;payloadlen; i++) {
          putchar(*payloadptr++);
      }
      putchar('\n');
      MQTTAsync_freeMessage(&amp;message);
      MQTTAsync_free(topicName);
      return 1;
  }
  
  
  void onDisconnect(void *context, MQTTAsync_successData *response) {
      printf("Successful disconnection\n");
      disc_finished = 1;
  }
  
  
  void onSubscribe(void *context, MQTTAsync_successData *response) {
      printf("Subscribe succeeded\n");
      subscribed = 1;
  }
  
  void onSubscribeFailure(void *context, MQTTAsync_failureData *response) {
      printf("Subscribe failed, rc %d\n", response ? response-&gt;code : 0);
      finished = 1;
  }
  
  
  void onConnectFailure(void *context, MQTTAsync_failureData *response) {
      printf("Connect failed, rc %d\n", response ? response-&gt;code : 0);
      finished = 1;
  }
  
  
  void onConnect(void *context, MQTTAsync_successData *response) {
      MQTTAsync client = (MQTTAsync) context;
      MQTTAsync_responseOptions opts = MQTTAsync_responseOptions_initializer;
      MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
      int rc;
  
      printf("Successful connection\n");
  
      printf("Subscribing to topic %s\nfor client %s using QoS%d\n\n"
             "Press Q&lt;Enter&gt; to quit\n\n", TOPIC, CLIENTID, QOS);
      opts.onSuccess = onSubscribe;
      opts.onFailure = onSubscribeFailure;
      opts.context = client;
  
      deliveredtoken = 0;
  
      if ((rc = MQTTAsync_subscribe(client, TOPIC, QOS, &amp;opts)) != MQTTASYNC_SUCCESS) {
          printf("Failed to start subscribe, return code %d\n", rc);
          exit(-1);
      }
  }
  
  
  int main(int argc, char *argv[]) {
      MQTTAsync client;
      MQTTAsync_connectOptions conn_opts = MQTTAsync_connectOptions_initializer;
      MQTTAsync_disconnectOptions disc_opts = MQTTAsync_disconnectOptions_initializer;
      MQTTAsync_message pubmsg = MQTTAsync_message_initializer;
      MQTTAsync_token token;
      int rc;
      int ch;
  
      MQTTAsync_create(&amp;client, ADDRESS, CLIENTID, MQTTCLIENT_PERSISTENCE_NONE, NULL);
  
      MQTTAsync_setCallbacks(client, NULL, connlost, msgarrvd, NULL);
  
      conn_opts.keepAliveInterval = 20;
      conn_opts.cleansession = 1;
      conn_opts.onSuccess = onConnect;
      conn_opts.onFailure = onConnectFailure;
      conn_opts.context = client;
      if ((rc = MQTTAsync_connect(client, &amp;conn_opts)) != MQTTASYNC_SUCCESS) {
          printf("Failed to start connect, return code %d\n", rc);
          exit(-1);
      }
  
      while (!subscribed)
  #if defined(WIN32) || defined(WIN64)
          Sleep(100);
  #else
          usleep(10000L);
  #endif
  
      if (finished)
          goto exit;
  
      do {
          ch = getchar();
      } while (ch != 'Q' &amp;&amp; ch != 'q');
  
      disc_opts.onSuccess = onDisconnect;
      if ((rc = MQTTAsync_disconnect(client, &amp;disc_opts)) != MQTTASYNC_SUCCESS) {
          printf("Failed to start disconnect, return code %d\n", rc);
          exit(-1);
      }
      while (!disc_finished)
  #if defined(WIN32) || defined(WIN64)
          Sleep(100);
  #else
          usleep(10000L);
  #endif
  
      exit:
      MQTTAsync_destroy(&amp;client);
      return rc;
  }
  
  #endif
  </code></pre>
  
  <p>The paho mqtt classes are in the <code>src</code> directory.
  In my CMake I am trying to link them like so:</p>
  
  <pre><code>cmake_minimum_required(VERSION 3.10)
  project(MQTT)
  
  set(CMAKE_CXX_STANDARD 11)
  file(GLOB src "*.h" "*.c")
  
  add_executable(MQTT main.cpp ${src})
  </code></pre>
  
  <p>The following exception is prompted when trying to compile:</p>
  
  <pre><code>[ 50%] Linking CXX executable MQTT
  CMakeFiles/MQTT.dir/main.cpp.o: In function `connlost(user*, char*)':
  /home/user/Documents/Projects/MQTT/main.cpp:161: undefined reference to `MQTTAsync_connect'
  CMakeFiles/MQTT.dir/main.cpp.o: In function `msgarrvd(user*, char*, int, MQTTAsync_message*)':
  /home/user/Documents/Projects/MQTT/main.cpp:181: undefined reference to `MQTTAsync_freeMessage'
  /home/user/Documents/Projects/MQTT/main.cpp:182: undefined reference to `MQTTAsync_free'
  CMakeFiles/MQTT.dir/main.cpp.o: In function `onConnect(user*, MQTTAsync_successData*)':
  /home/user/Documents/Projects/MQTT/main.cpp:226: undefined reference to `MQTTAsync_subscribe'
  CMakeFiles/MQTT.dir/main.cpp.o: In function `main':
  /home/user/Documents/Projects/MQTT/main.cpp:242: undefined reference to `MQTTAsync_create'
  /home/user/Documents/Projects/MQTT/main.cpp:244: undefined reference to `MQTTAsync_setCallbacks'
  /home/user/Documents/Projects/MQTT/main.cpp:251: undefined reference to `MQTTAsync_connect'
  /home/user/Documents/Projects/MQTT/main.cpp:271: undefined reference to `MQTTAsync_disconnect'
  /home/user/Documents/Projects/MQTT/main.cpp:283: undefined reference to `MQTTAsync_destroy'
  collect2: error: ld returned 1 exit status
  make[3]: *** [CMakeFiles/MQTT.dir/build.make:95: MQTT] Error 1
  make[2]: *** [CMakeFiles/Makefile2:68: CMakeFiles/MQTT.dir/all] Error 2
  make[1]: *** [CMakeFiles/Makefile2:80: CMakeFiles/MQTT.dir/rule] Error 2
  make: *** [Makefile:118: MQTT] Error 2
  </code></pre>
  
  <p>How can I correctly link all these files?</p>