Is this a correct implementation of quicksort in C?
The most valuable feature of quicksort is that it sorts in-place, without a temporary array. The average space complexity quicksort is logarithmic, whereas the one of your solution is linear. The time complexity is also affected by the copying from temporary back to original.

NB: If you can afford a linear temporary, don't use quicksort. Mergesort will win hands down: it doesn't have a worst case, and besides it is stable.
Choosing middle element for the pivot, while harmless, doesn't avoid the worst case. The performance of the quicksort is affected not by where the pivot is chosen, but by where it lands after partitioning. Worst case arises when they consistently land near the edges of the array.
I don't see the need to treat left of pivot and right of pivot separately:

Swap the pivot with the first element (`array[0]` now holds the pivot)
Partition the entire [1..length) range in one pass
Swap the `array[0]` (which holds the pivot) with `array[length_small]`.

A length of the array should be size_t. There is no guarantee that unsigned int is wide enough to represent a size of a very large array.
The code before the recursive call implements an important algorithm, namely partition and deserves to be a function of its own. Consider

void quicksort(int *array, size_t length)
{
    if (length &lt;= 1) {
        return;
    }
    size_t partition_point = partition(array, length);
    quicksort(array, partition_point);
    quicksort(array + partition_point + 1, length - partition_point - 1);
}

Further down, you may want to implement two improvements:


Recursion cutoff: when the array becomes small enough, insertion sort performs better
Tail call elimination (not really necessary, the C compilers are good in it)