Error in compiling program using libad9361 and libiio

#include <stdio.h>
#include <stdlib.h>
#include <iio.h>

// Define the desired parameters
#define RX_LO_FREQ 915000000UL   // 915 MHz
#define TX_LO_FREQ 915000000UL   // 915 MHz
#define SAMPLING_RATE 3200000UL  // 3.2 MSPS
#define RX_GAIN 50               // Example RX gain in dB
#define TX_GAIN 50               // Example TX gain in dB

void loop(struct iio_buffer *rx_buffer, struct iio_channel *rx_chan);

int main() {
    struct iio_context *ctx;
    struct iio_device *rx_dev, *tx_dev;
    struct iio_channel *rx_chan, *tx_chan;

    // Initialize the IIO library
    //ctx = iio_create_default_context();
	ctx = iio_create_network_context("192.168.2.1");

    if (!ctx) {
        fprintf(stderr, "No context\n");
        return -1;
    }

    // Connect to RX and TX devices
    rx_dev = iio_context_find_device(ctx, "ad9361-phy");
    tx_dev = iio_context_find_device(ctx, "ad9361-phy");

    if (!rx_dev || !tx_dev) {
        fprintf(stderr, "No device found\n");
        iio_context_destroy(ctx);
        return -1;
    }

    // Configure RX LO frequency
    rx_chan = iio_device_find_channel(rx_dev, "altvoltage0", true);
    if (!rx_chan) {
        fprintf(stderr, "Cannot find RX LO channel\n");
        iio_context_destroy(ctx);
        return -1;
    }
    iio_channel_attr_write_longlong(rx_chan, "frequency", RX_LO_FREQ);

    // Configure TX LO frequency
    tx_chan = iio_device_find_channel(tx_dev, "altvoltage1", true);
    if (!tx_chan) {
        fprintf(stderr, "Cannot find TX LO channel\n");
        iio_context_destroy(ctx);
        return -1;
    }
    iio_channel_attr_write_longlong(tx_chan, "frequency", TX_LO_FREQ);

    // Configure sampling rate and gain for RX
    struct iio_channel *rx_samp_chan = iio_device_find_channel(rx_dev, "voltage0", false);
    if (!rx_samp_chan) {
        fprintf(stderr, "Cannot find RX sample channel\n");
        iio_context_destroy(ctx);
        return -1;
    }
    iio_channel_attr_write_longlong(rx_samp_chan, "sampling_frequency", SAMPLING_RATE);
    iio_channel_attr_write_int(rx_samp_chan, "gain_control_mode", 0); // Set to manual gain control mode
    iio_channel_attr_write_int(rx_samp_chan, "hardwaregain", RX_GAIN);

    // Configure sampling rate and gain for TX
    struct iio_channel *tx_samp_chan = iio_device_find_channel(tx_dev, "voltage0", true);
    if (!tx_samp_chan) {
        fprintf(stderr, "Cannot find TX sample channel\n");
        iio_context_destroy(ctx);
        return -1;
    }
    iio_channel_attr_write_longlong(tx_samp_chan, "sampling_frequency", SAMPLING_RATE);
    iio_channel_attr_write_int(tx_samp_chan, "hardwaregain", TX_GAIN);

// Define buffer sizes (number of samples)
#define RX_BUFFER_SIZE 1024  // Example size
#define TX_BUFFER_SIZE 1024  // Example size
.

// Create and configure RX and TX buffers
struct iio_buffer *rx_buffer;
struct iio_buffer *tx_buffer;

rx_buffer = iio_device_create_buffer(rx_dev, RX_BUFFER_SIZE, false);
if (!rx_buffer) {
    fprintf(stderr, "Could not create RX buffer\n");
    iio_context_destroy(ctx);
    return -1;
}

tx_buffer = iio_device_create_buffer(tx_dev, TX_BUFFER_SIZE, true);
if (!tx_buffer) {
    fprintf(stderr, "Could not create TX buffer\n");
    iio_context_destroy(ctx);
    iio_buffer_destroy(rx_buffer);
    return -1;
}
// set blocking mode for both rx and tx buffers
iio_buffer_set_blocking_mode(rx_buffer, true); // Set RX buffer to blocking mode
iio_buffer_set_blocking_mode(tx_buffer, true); // Set TX buffer to blocking mode

loop_fun();


// Clean up
iio_buffer_destroy(rx_buffer);
iio_buffer_destroy(tx_buffer);
iio_context_destroy(ctx);

 // Cleanup
iio_context_destroy(ctx);
    return 0;
}

void loop(struct iio_buffer *rx_buffer, struct iio_channel *rx_chan)
{
	// Streaming loop (example for RX)
while (1) {
    // Refill RX buffer
    ssize_t nbytes_rx = iio_buffer_refill(rx_buffer);
    if (nbytes_rx < 0) {
        printf("\n No i,q samples in iio buffer\n");
        break;
    }

    // Process RX data
    const char *rx_data = iio_buffer_first(rx_buffer, rx_chan);
    // Process 'nbytes_rx' bytes of data starting at 'rx_data'

    // Example: Read and process samples
    for (ssize_t i = 0; i < nbytes_rx / sizeof(int16_t); i += 2) {
        int16_t i_sample = ((int16_t *)rx_data)[i];   // I sample
        int16_t q_sample = ((int16_t *)rx_data)[i+1]; // Q sample
        // Process (I, Q) samples
		float i_sample_float = (float)i_sample / 2048.0f;
		float q_sample_float = (float)q_sample / 2048.0f;

    }
}

}