Is this a portable strdup

Question

I have a c program I'm writing that I want to be portable and future compliant. The POSIX function strdup() is not in the current C standard, but it has been added to the C2x standard. Will this code work properly with C standard compliant compilers in the future.

Will it work on both POSIX and non POSIX systems?

my_strdup.h

#ifndef MY_STRDUP_H
#define MY_STRDUP_H

#include <string.h>

#ifndef strdup
#ifdef _MSC_VER
#if _MSC_VER > 1920
#define strdup _strdup
#endif
#else
#define strdup mystrdup      
#endif
#endif

char* mystrdup(const char* string_to_copy);
unsigned char* ucstrdup(const unsigned char* string_to_copy);

#endif  // MY_STRDUP_H

my_strdup.c

#include "my_strdup.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* mystrdup(const char* string_to_copy)
{
    char* return_string = NULL;
    size_t length = strlen(string_to_copy);
    ++length;

    return_string = calloc(length, sizeof(*return_string));
    if (return_string)
    {
        memcpy(return_string, string_to_copy, length - 1);
    }

    return return_string;
}

unsigned char* ucstrdup(const unsigned char* string_to_copy)
{
    unsigned char* return_string = NULL;
    size_t length = strlen((const char*)string_to_copy);
    ++length;

    return_string = calloc(length, sizeof(*return_string));
    if (return_string)
    {
        memcpy(return_string, string_to_copy, length - 1);
    }

    return return_string;
}

Post Answer Update:

This code is part of a project I am working on, the code that uses this code can be found in 4 questions on Code Review. Those questions are all related to unit tests I am writing for this project.

Here are the questions on code review in the order asked:

1. Hand Coded State Driven Lexical Analyzer in C With Unit Test Part A
2. Hand Coded State Driven Lexical Analyzer in C With Unit Test Part B
3. Part C
4. Follow up to Part C

Feel free to write answers for the questions as long as they follow the Code Review Guidelines

Answer 1

Read carefully the C11 standard n1570. For things like Arduino, you might not even have any malloc, and you could have some free-standing implemention of C11.

As a concrete example, the Linux kernel is coded in C, and your code could not be part of it.

Also see this answer providing some funny implementation of malloc (you could extend it to calloc...)

Will this code work properly with C standard compliant compilers in the future.

Of course not in general.

Look on many examples of toy operating systems on OSDEV.

You could have some operating system without  malloc or calloc but with a C compiler.

I have a c program I'm writing that I want to be portable and future compliant.

The motto I read somewhere is: there is no such thing as portable programs, just programs which have been ported (to some given systems)

Did you consider some approach inspired by GNU autoconf ? Your build automation could use preprocessing tricks and/or generate C code with e.g. GPP, SWIG or other tools.