Recieving C socket data to allocated 2D array

Question

I am trying to populate an array I allocated with data recieved from a socket, but am unable to make it work properly. When i define and get data through:

uint16_t data[2048];
recv(network_socket, &data, sizeof(data), 0);

the data is recieved properly, but when I try to do it through an allocated array:

int i;
int N = 3;
int M = 2048;
int **matrix; 

matrix = (int **)calloc(N, sizeof(int *));

for (i=0; i<N; i++) {
    matrix[i] = (int *)calloc(M, sizeof(uint16_t));
}

for (i=0; i<N; i++) {
    recv(network_socket, matrix[i], sizeof(data), 0);
}

I am sensing things go wrong at the final part. As far as I understand matrix[i] at the end gets the pointer to the beginning of row i and should work for recv() but that might be where I'm going wrong here.

EDIT: When I try to printf("Number: %" PRIu16 "\n", matrix[a][b]); I get some whacko large number in the second part, wheras printf("Number: %" PRIu16 "\n", data[a]); works fine in the first.

Answer 1

You tell in your first code you want an array of 16bit unsigned integers and receive them. All is good.

In your second code you want an array of ints which probably aren’t 16bit on your platform. Then you allocate an amount of memory to them based on them being 16bit values and read an undisclosed amount of data in.

Then you try to access them as ints which obviously will cause two uint16_t values being combined into one int if your system is 32bit, or even four on a 64bit system.

Fix your code to use uint16_t as in the first one and it’ll actually know how to handle the 16bit data. Your current code will even have undefined behavior since you try to access memory outside the allocated range.

Answer 2

The comments and other answers have pointed out some of the potential problems regarding type consistency (suggestions to use either int or uint16_t, but not to mix) and allocating memory.

A suggestion regarding memory creation:
For simplicity, and readability, especially when desiring to emulate multiple dimensions of an array, consider encapsulating memory creation into a function. For example:

uint16_t ** Create2D(int c, int r)
{   
    uint16_t **arr;
    int    y;

    arr   = calloc(c, sizeof(uint16_t *));
    for(y=0;y<c;y++)
    {
        arr[y] = calloc(r, sizeof(uint16_t));   
    }
    return arr;
}

Call the function like this:

uint16_t ** matrix = Create2D(N, M);
if(matrix)//always good to check return of [c][m]alloc before using
{
    // Use allocated memory
    ...

Notes:

• This example does not create a 2D matrix, rather an emulation of of one. (as described in great detail HERE) It is actually just a pointer to a collection of pointers, each pointing to the allocated memory such that their contents can be accessed using row-column notation, just as if it had been created as:

uint16_t array[N][M];

• In C, it is not necessary to cast the return of malloc or calloc.
• For every [m][c]alloc() called, there must be a corresponding call to free().

Freeing this memory can also be implemented in an encapsulated form. For example:

void free2D(uint16_t **arr, int c)
{
    int i;
    for(i=0;i<c;i++)
    {
        free(arr[i]);
    }
    free(arr);
}  

Answer 3

int **matrix; 

matrix = (int **)calloc(N, sizeof(int *));
...

The code doesn't work since the above is not a 2D array, but rather a segmented, pointer-based look-up table. As such, it is not in the slightest compatible with arrays.

There is no reason why you need to have such a look-up table here. The problem likely originates in confusion about how to Correctly allocating multi-dimensional arrays.