Socket address showing 0.0.0.0, causing failure to send message

Question

I've been working from Beejs Network examples, introducing a few customizations. In particular, I'm trying to use a single structure to store the necessary information related to communications/sockets. I think I'm having trouble populating an addrinfo structure and using it with sendto for a UDP socket. Bellow is my code, which compiles fine, but it fails with the message outlined below

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>

// Definitions
#define COM_MSG_SIZE 1024
#define COM_HOST_SIZE 128


struct com_socket
{
    char *type;
    int descriptor;
    struct addrinfo addr;
};


void COM_error(char *msg) {
    perror(msg);
    exit(0);
}


int main()
{

    int status;
    struct com_socket COM_client;
    char addr_str[COM_HOST_SIZE];

    // ---------------------------------------------
    // Initialize socket
    COM_client.type = "UDP";
    char *hostname = "192.168.0.110";
    char *port_num = "4000";

    printf("Creating socket...");
    if(strcmp(COM_client.type, "UDP") == 0)
    {
        COM_client.descriptor = socket(AF_INET, SOCK_DGRAM, 0);
    }

    // Error check
    if(COM_client.descriptor < 0)
    {
        COM_error("  ERROR opening socket");
    }
    printf("  Success\n");


    //------------------------------------------------------------------------------------------

    // Define hints
    struct addrinfo hints;

    hints.ai_family = AF_INET; // AF_UNSPEC "unspecified" or can use IPv6 = AF_INET6, IPv4 =  AF_INET
    hints.ai_socktype = SOCK_DGRAM; // Socket type: SOCK_STREAM or SOCK_DGRAM or 0 = auto
    hints.ai_flags = AI_CANONNAME;
    hints.ai_protocol = 0; // 0 = auto
    hints.ai_canonname = NULL;
    hints.ai_addr = NULL;
    hints.ai_addrlen = 0;
    hints.ai_next = NULL;

    // Get the linked list of address info
    struct addrinfo *host_list;
    printf("Building host address list...");
    status = getaddrinfo(hostname,port_num,&hints,&host_list);

    // returns 0 if succeeds
    if (status != 0)
    {
        COM_error("  ERROR getaddrinfo: %s\n");
    }
    printf("  Success\n");


    //------------------------------------------------------------------------------------------
    // Select address

    int count = 1;
    struct addrinfo *entry;

    // Loop through each entry in the "linked list" and pull the necessary one
    for (entry = host_list; entry != NULL; entry = entry->ai_next)
    {

        // Print the list of potential IP addresses
        if( NULL == inet_ntop( AF_INET, &((struct sockaddr_in *) entry->ai_addr)->sin_addr, addr_str, sizeof(addr_str) ) )
        {
            COM_error("  ERROR with inet_ntop\n");
        }
        printf("  Address entry %d: %s",count,addr_str);

        // Update counter
        count = count + 1;

        // Choose which one to copy
        if(strncmp(addr_str,"192.",(size_t) 4) == 0)
        {

            //memcpy(COM_client.addr,entry, sizeof(struct addrinfo));
            COM_client.addr = *entry;
//          COM_client.addr.ai_addr = entry->ai_addr;
//          COM_client.addr.ai_addrlen = entry->ai_addrlen;
//          COM_client.addr.ai_canonname = entry->ai_canonname;
//          COM_client.addr.ai_family = entry->ai_family;
//          COM_client.addr.ai_flags = entry->ai_flags;
//          COM_client.addr.ai_protocol = entry->ai_protocol;
//          COM_client.addr.ai_socktype = entry->ai_socktype;

            if( inet_ntop( AF_INET, &((struct sockaddr_in *) COM_client.addr.ai_addr)->sin_addr, addr_str, sizeof(addr_str) ) == NULL )
            {
                COM_error("  ERROR with arguments to inet_ntop\n");
            }

            printf("   <--------- selected* (%s) \n",addr_str);
            break;
        }
        else
        {
            printf("\n");
        }
    }

    // Clean
    freeaddrinfo(host_list);


    //-------------------------------------------------------


    char *buffer;
    char msg[COM_MSG_SIZE];
    strncpy(msg,"BEGIN",COM_MSG_SIZE);


    printf("ENTER `COM_msg_send` address length %d\n",COM_client.addr.ai_addrlen);

    buffer = calloc(COM_MSG_SIZE+1, sizeof(char));

    printf("AFTER calloc `COM_msg_send` address length %d\n",COM_client.addr.ai_addrlen);

    // Check to see if we were successful
    if (buffer == NULL)
    {
        printf("ERROR Could not allocate required memory\n");
        exit(1);
    }

    // Copy message to buffer
    strncpy(buffer,msg,COM_MSG_SIZE);
    printf("Message input: %s   Message to be sent: %s\n",msg,buffer);


    if( inet_ntop( AF_INET, &((struct sockaddr_in *) COM_client.addr.ai_addr)->sin_addr, addr_str, sizeof(addr_str) ) == NULL )
    {
        COM_error("  ERROR with arguments to inet_ntop\n");
    }
    printf("SEND to address (%s) \n",addr_str);


    // Send the buffer to the destination address
    if(strcmp(COM_client.type, "UDP") == 0)
    {
        status = sendto(COM_client.descriptor, buffer, strlen(buffer), 0, COM_client.addr.ai_addr, COM_client.addr.ai_addrlen);

        // Error check
        if (status < 0)
        {
            COM_error("ERROR could not send message");
        }

    }

    // Free buffer memory
    free(buffer);

    //---------------------------------------------------------
    close(COM_client.descriptor);

    return 0;
}

Here is the output showing messages from the print statements as well as the failure

Creating socket...  Success
Building host address list...  Success
  Address entry 1: 192.168.0.110   <--------- selected* (192.168.0.110) 
ENTER `COM_msg_send` address length 16
AFTER calloc `COM_msg_send` address length 16
Message input: BEGIN   Message to be sent: BEGIN
L1 = 16  L2 = 16 
SEND to address (0.0.0.0) 
ERROR could not send message: Invalid argument

Showing SEND to address (0.0.0.0), it appears that something is wrong with the address stored in the structure COM_client. Specifically, I believe I'm having trouble with this part

            //memcpy(COM_client.addr,entry, sizeof(struct addrinfo));
            COM_client.addr = *entry;
//          COM_client.addr.ai_addr = entry->ai_addr;
//          COM_client.addr.ai_addrlen = entry->ai_addrlen;
//          COM_client.addr.ai_canonname = entry->ai_canonname;
//          COM_client.addr.ai_family = entry->ai_family;
//          COM_client.addr.ai_flags = entry->ai_flags;
//          COM_client.addr.ai_protocol = entry->ai_protocol;
//          COM_client.addr.ai_socktype = entry->ai_socktype;    

As you can see, I've tried various things, all of which fail. I want to continue to use the COM_client structure approach as my intention is to make the code more modular in which I can pass the structure containing all the necessary communication information.

Answer 1

This line

COM_client.addr = *entry;

"tries" to copy a struct addrinfo, which it in fact does, but as it contains pointers and "only" copies the pointers' values. The memory those pointers point to had been allocated by getaddrinfo() and thus will be deallocates by the call to freeaddrinfo() leaving the pointers inside the copy dangle afterwards.

To get around this you need to perform a "deep copy" of a struct addrinfo.

This for example can be done like so:

/* Does a deep copy to where pdst point from where pscr points to. 
   Returns 0 on success and -1 on error. Sets errno. */   

int addrinfo_copy(struct addrinfo * pdst, struct addrinfo * psrc)
{
  int result = 0; /* Be optimistic. */

  assert(pdst);
  assert(psrc);

  *pdst = *pscr; /* Copy all. Note that the pointer elements copied
                   need to be recreated. See below ... */
  do
  {
    pdst->ai_addr = malloc(psrc->ai_addrlen);
    if (!pdst->ai_addr)
    {
      result = -1;
      break;
    }

    memcpy(pdst->ai_addr, psrc->ai_addr, psrc->ai_addrlen);

    pdst->ai_canonname = strdup(psrc->ai_canonname); /* Assumes POSIX. */
    if (!pdst->ai_canonname)
    {
      result = -1;
      break;
    }
  } while (0);

  return result;       
}

To get rid of such a copy you need something like this:

/* Deallocates and sets to a 0/NULL what had been created by 
   addrinfo_copy(). */

void addrinfo_free(struct addrinfo * p)
{
  assert(p);

  free(p->ai_addr);
  free(p->canonname);

  memset(p, 0, sizeof *p); /* In fact not necessary. */
}

Use it like this:

  struct addrinfo * entry, * entry_copy;

  /* Set entry to something returned by getaddrinfo (). */
  ...

  if (-1 = addrinfo_copy(entry_copy, entry))
  {
    perror("addrinfo_copy() failed"):
    exit(EXIT_FAILURE);
  }

  /* Deallocate all results returned by getaddrinfo(). */
  freeaddrinfo(...);

  /* Still use entry_copy here. */
  ...

  /* Clean up. */
  addrinfo_free(entry_copy);

---

As a final note:

If when doing C you observe obscure sudden/unexpected changes in memory content this all most ever dues to having messed up memory management by writing and/or reading to "wrong" memory. This some times happened way long before those changes in memory become obvious and/or in code (seemingly) completely unrelated to where you observe such changes in memory.