You could have an array that starts out with 10 elements. Read input character by character. If it goes over, realloc another 5 more. Not the best, but then you can free the other space later.

Overall

Your header doesn't include any function declarations so I'm not sure what your "public interface" will be but only few of your functions are static so I have to assume you intend to make all others available in which case I have to say I don't like the interface into your structure.

From the looks of it your Dynamic_String should only be manipulated through the appropriate ds_ functions yet your return the pointer to the internal storage from various functions which has the potential for the programmer screwing it up easily.

So consider carefully defining the interface into your structure and how you intend it to be used. Most of you functions should either return Dynamic_String * or an int result indicating whether or not the operation was successfully executed. When dealing with memory allocation you should always check the result.

I'd probably even go as far as making Dynamic_String opaque. Suggested interface in your header file:

typedef struct Dynamic_String Dynamic_String;

Dynamic_String* ds_allocate(size_t initial_size);
int ds_resize(Dynamic_String* ds, size_t new_size);
int ds_reserve(Dynamic_String* ds, size_t amount);
int ds_shrink(Dynamic_String* ds, size_t amount);
void ds_free(Dynamic_String* ds);

int ds_compare(const Dynamic_String* first, const Dynamic_String* second);
int ds_compare_cstr(const Dynamic_String* first, const char* second);

int ds_copy(Dynamic_String* destination, const Dynamic_String* source);
int ds_copy_cstr(Dynamic_String* destination, const char *src);

Dynamic_String* ds_duplicate(const Dynamic_String* ds);
Dynamic_String* ds_from_cstr(const char *str);

int ds_append(Dynamic_String* destination, const Dynamic_String* source);
int ds_append_cstr(Dynamic_String* destination, const char* source);

... // etc. other useful manipulation functions 

const char* ds_getcontent(Dynamic_String* ds);
char* ds_getcontent_unsafe(Dynamic_String* ds); // all bets are of

... // query function like capacity, current size, is_empty/full etc.

Technical Details

1. ds_allocate does not check if there is already memory allocated and will simply leak if you pass in a structure which already has storage allocated. It think ds_allocate should simply allocate the structure and return it. Otherwise the programmer has to allocate the Dynamic_String structure and then call this init function which seems redundant. As user I'd prefer something along these lines:

   Dynamic_String* ds_allocate(size_t initial_size)
   {
       Dynamic_String *result = malloc(sizeof(Dynamic_string));
       if (result == NULL)
       {
           return NULL;
       }
       ...
   }
   

   Basically return NULL if any of the memory allocations fail or initial_size < 1. Provide a ds_allocate_default() if you want to give the programmer an option to just allocate an object with default size (I personally don't like these implicit "pass 0 or negative to obtain a default size allocation" implementations but YMMV).

2. Technically the result of a pointer subtraction is ptrdiff_t and not size_t. The former is signed while the latter is unsigned. You should probably store the result of the subtraction in a local variable of type ptrdiff_t and check that it's not negative before returning it as size_t. If it's negative you apparently have hit a bug in the implementation.

3. ds_append_cstring can be greatly simplified by using memcpy rather than copying each byte individually. It will also be much faster.