Function for reading bits

1. Consider checking src[currentByte] for '\0' and abort when it's true (apparently the passed in string wasn't long enough). Depends on your usage though.
2. Alternatively to the previous point you could add a source_length parameter to let the caller supply the information of how long the sequence really is.

3. I would consider changing the interface slightly. Have some methods which manage the object for you:

   bits_t *new_bits_t(int nbits)
   {
        bits_t *res = malloc(sizeof(bits_t));
        res->data = calloc(nbits);
        res->len = nbits;
        return res;
   }
   
   // frees the memory allocated for the structure and sets the reference to NULL
   void delete_bits_t(bits_t **bits)
   {
        if (bits == NULL || *bits == NULL) return;
        free((*bits)->data);
        free(*bits);
        *bits = NULL;
   }
   

   Then your read_bits function could fill in the structure passed in and also return error code in case the reading failed (i.e. source is too short):

   int read_bits(unsigned char *src, bits_t *bits, int bits_offset)
   {
       ...
   }
   

4. bit_position_in_byte = (curr_bit - 1) - (curr_byte * 8); should be equivalent to bit_position_in_byte = (curr_bit - 1) % 8;

5. Your loop is one based for some reason but inside the loop you have to subtract 1 from current_bit everywhere. You should just make your loop 0 based which would de-clutter the loop a bit.
6. I would find bit_in_byte just as descriptive a name as bit_position_in_byte.

7. You could get rid of the remaining_to_read by calculating the position:

   for (curr_bit = 0; curr_bit < nbits; ++curr_bit) {
       input_bit = curr_bit + bits_offset - 1;
       input_byte = input_bit / 8;
       bit_in_byte = input_bit % 8;
       bits->data[nbits - curr_bit - 1] = read_bit(src[input_byte], bit_in_byte);
   }
   

8. The loop apparently fills data from the end which seems little bit unexpected to me (kind of string reversal).

Using _t as a suffix is reserved by POSIX. Also the structure is unnecessary. The len field is essentially unused - the caller knows the length already. So just allocate and return an array. Note that you need to check that the allocation succeeded.

Parameter src should be const

Why is everything unsigned except nbits? I would make all apart from the chars signed - making things unsigned adds nothing here and so is just 'noise'.

Variables should generally be defined one per line and initialised immediately - although it is better to define them at the point of first use.

It is normal to start indexing at 0 rather than 1. And your loop should start at bits_offset, rather than starting at 1 and indexing through.

Here is a revised version. Note the use of % to get the bit offset.

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

static unsigned char* read_bits(const unsigned char *src, int offset, int nbits)
{
    unsigned char *s = malloc((size_t) nbits);
    if (s) {
        --nbits;
        for (int bit = offset; nbits >= 0; ++bit, --nbits){
            int byte = bit / 8;
            int bit_position = bit % 8;
            s[nbits] = (src[byte] >> bit_position) & 1;
        }
    }
    return s;
}

The only, and not so huge issue, I see here is that you could use static allocation instead of dynamic allocation. That is if you're willing to restrict the number of bits that you can handle.

EDIT: Adding possible ways of declaring function

How the struct would be defined:

typedef struct bits_t {
    unsigned char data[8];
    unsigned int len;
} bits_t;

There are some options on how you declare your function. I'll put those out:

1. The function would return the struct itself and would copy sizeof(bits_t) every time it's called

   bits_t read_bits(unsigned char *src, int bits_offset, int nbits);
   

2. The function wouldn't return nothing BUT would change the content of bits. Note that with this, you maybe are able to avoid other parameters as long the caller initializes the contents of bits correctly.

   void read_bits(unsigned char *src, int bits_offset, int nbits, bits_t* bits);
   

3. The function returns bits. And bits works the same as 2.

   bits_t* read_bits(unsigned char *src, int bits_offset, int nbits, bits_t* bits);
   

EDIT: Watch your for loop

for(curr_bit = bits_offset; curr_bit <= nbits; curr_bit++){
    if(remaining_to_read){
        curr_byte = (curr_bit - 1) / 8;
        bit_position_in_byte = (curr_bit - 1) - (curr_byte * 8);
        bits->data[remaining_to_read - 1] = read_bit(src[curr_byte], bit_position_in_byte);
        remaining_to_read--;
    }
}

With this, you have fewer iterations and condition checks.

EDIT: enable a 'hybrid' but usage care solution.

bits_t* bits_t_init(bits_t* bits, size_t nBits){
    if(nBits <= 8 && bits != NULL){
       bits->len = nBits;
       return bits;
    }
   int extra = (nBits % 8) == 0;
   bits_t* aux = (bits_t*)malloc(nBits/8 + sizeof(int) + extra);
   aux->len= nBits;
}

How to use it:

1.Static allocation

bits_t bits;  
bits_t_init(&bits, 8); //ok  
bits_t_init(&bits, 12); //wrong  

2.Dynamic allocation

bits_t* bits = bits_t_init(NULL, 20) //ok