MPI_Recv not receiving the entire array - c

Question

My master process has a string array, which it sends to the slaves process. The slaves process quicksort the array and send it back. The problem is on receiving it back.
After MPI_Recv, only the first 3 indexes of the array is filled and the rest of the elements are empty. When I print the Array before sending, the elements are there. But after receiving, except for the those 3, all others are empty.
slave that send the message code. It receive an array of strings, quicksotr it and send it back ordered
// receiving number of elements
MPI_Recv(&size, 1, MPI_INT, 0, tag, MPI_COMM_WORLD, &status);
// allocating the array
array = (char**) malloc(sizeof(*array) * size);
array[0] = (char*) malloc(sizeof(*array[0]) * size * buf);
for(i=1; i<size; i++)
array[i] = &(array[0][i*buf]);
// receiving the array
MPI_Recv(&array[0][0], size*buf, MPI_CHAR, 0, tag, MPI_COMM_WORLD, &status);
// sorting the array
quicksort(array, 0, size-1);
// sending the ordered array back
//DEBUG printf("%d: Sending for %d -> %d...\n", rank, 0, size);
MPI_Send(&size, 1, MPI_INT, 0, tag, MPI_COMM_WORLD);
//DEBUG printf("%d: Sending for %d -> %d...\n", rank, 0, size*buf);
//printArray(array, size);
printf("%d: before sending\n", rank);
for(i=0; i<size; i++)
printf("%d: %s", rank, array[i]);
MPI_Send(&array[0][0], size*buf, MPI_CHAR, 0, tag, MPI_COMM_WORLD);
the master, who sends the array and is supposed to receive it back ordered
// sending the messages
int j = 0;
for(i=1; i<procs; i++){
MPI_Send(&division[i], 1, MPI_INT, i, tag, MPI_COMM_WORLD);
MPI_Send(&array[j][0], division[i]*buf, MPI_CHAR, i, tag, MPI_COMM_WORLD);
j += division[i];
}
printf("%d: All Sent\n", rank);
// receiving the ordered arrays
printf("%d: Waiting for answers...\n", rank);
// receiving number of elements
MPI_Recv(&sizeA, 1, MPI_INT, MPI_ANY_SOURCE, tag, MPI_COMM_WORLD, &status);
// alocating an array
arrayA = (char**) malloc(sizeof(*arrayA) * sizeA);
arrayA[0] = (char*) malloc(sizeof(*arrayA[0]) * sizeA * buf);
for(i=1; i<sizeA; i++)
arrayA[i] = &(arrayA[0][i*buf]);
// receiving the array
MPI_Recv(&arrayA[0][0], sizeA*buf, MPI_CHAR, status.MPI_SOURCE, tag, MPI_COMM_WORLD, &status);
for(i=0; i<sizeA; i++)
printf("%i: %s", i, arrayA[i]);
EDIT The problem seems to be on the quicksort. If i comment the quicksort line i receive the entire array. Although it works fine on the sequential version. Here's the code.
void quicksort(char **array, int left, int right){
// array empty
if(right - left < 1)
return;
// end of quicksort, just two elements left
if(right - left == 1){
if(strcomp(array[left], array[right]) > 0)
swap(array, left, right);
return;
}
int i = left + 1; // left + 1: used to avoid the pivot, on the first position
int j = right; // right
int pivot = (left + right) / 2; // pivot position
char *key = array[pivot]; // string with the array[pivot] element
// moving the pivot to the beginning
swap(array, left, pivot);
// quicksorting
while(i < j){
// if an element is on the left of the pivot and, is <= than the pivot
// keep the element there and increase i
while(i <= right && strcomp(array[i], key) < 0){
i++;
}
// if an element is on the right of the pivot, and is > than the pivot
// keep the element there and decrease j
while(j >= left && strcomp(array[j], key) > 0){
j--;
}
// array[i] > key, and should be on the right
// array[j] <= key, and should be on the left
if(i < j){
swap(array, i, j);
}
}
// moving the pivot back to the middle
swap(array, left, j);
// left recursion
if(left < j-1)
quicksort(array, left, j-1);
// right recursion
if(j+1 < right)
quicksort(array, j+1, right);
}