First, a C string is not just a char, but an array of char with the last element (or at least the last one that's counted as part of the string) set to the null character (numerically 0, also '\0' as a character constant).

Next, in the code you posted you probably meant char buffer[50] rather than char *buffer[50]... the version you have is an array of 50 char *s, but you need an array of 50 chars. After that's corrected, then...

Since fgets() always fills in a null char at the end of the string it read, buffer would already be a valid C string after you call fgets(). If you'd like to copy it to another string so you can reuse the buffer to read more input, you can use the usual string handling functions from <string.h>, such as strcpy(). Just make sure the string you copy it into is large enough to hold all the used characters plus a terminating null character.

This code copies the string into a newly malloc()ed string (error checking omitted):

char buffer[50];
char *str;
fgets(buffer,50,stdin);
str = malloc(strlen(buffer) + 1);
strcpy(str,buffer);

This code does the same, but copies to a char array on the stack (not malloc()ed):

char buffer[50];
char str[50];
fgets(buffer,50,stdin);
strcpy(str,buffer);

strlen() will tell you how many characters are used in the string, but doesn't count the terminating null (so you need to have one more character allocated than what strlen() returns). strcpy() will copy the characters and the null at the end from one string/buffer to another. It stops after the null, and doesn't know how much space you've allocated -- so you need to make sure it will find a null character before running out of space in the destination, or reaching the end of the source buffer. If in doubt, place a null at the end of the buffer yourself to make sure.

The array animals is an array of pointers. It is not an array of buffers of some size. Therefor, if you do

sizeof(*animals)

You will get the sizeof of the first element of that array. Equivalent to

sizeof(char*)

Because your array stores pointers. So, in the line that reads

char *output[sizeof(*animals)];

You allocate 4 or 8 pointers in one array (depends on how wide a pointer on your platform is. Usually it's either 4 or 8). But that's of course not senseful! What you wanted to do is create an array of pointers of the same size as animals. You will have to first get the total size of the animals array, and then divide by the size of one element

char *output[sizeof(animals)/sizeof(*animals)];

Now, that is what you want. But the pointers will yet have indeterminate values... Next you pass the array using *&animals (same for the other). Why that? You can pass animals directly. Taking its address and then dereference is the same as doing nothing in the first place.

Then in the function you call, you copy the strings pointed to by elements in animal to some indeterminate destination (remember the elements of the output array - the pointers - have yet indeterminate values. We have not assigned them yet!). You first have to allocate the right amount of memory and make the elements point to that.

while(*animals) {
        // now after this line, the pointer points to something sensible
        *output = malloc(sizeof("new animal ") + strlen(*animals));
        sprintf(*output, "new animal %s", *animals); 
        output++; // no need to dereference the result
        animals++; // don't forget to increment animals too!
}

Addition, about the sizeof above

There's one important thing you have to be sure about. It's the way we calculate the size. Whatever you do, make sure you always have enough room for your string! A C string consists of characters and a terminating null character, which marks the end of the string. So, *output should point to a buffer that is at least as large so that it contains space for "new animal " and *animals. The first contains 11 characters. The second depends on what we actually copy over - its length is what strlen returns. So, in total we need

12 + strlen(*animals)

space for all characters including the terminating null. Now it's not good style to hardcode that number into your code. The prefix could change and you could forget to update the number or miscount about one or two characters. That is why we use sizeof, which we provide with the string literal we want to have prepended. Recall that a sizeof expression evaluates to the size of its operand. You use it in main to get the total size of your array before. Now you use it for the string literal. All string literals are arrays of characters. string literals consist of the characters you type in addition to the null character. So, the following condition holds, because strlen counts the length of a C string, and does not include the terminating null character to its length

// "abc" would have the type char[4] (array of 4 characters)
sizeof "..." == strlen("...") + 1

We don't have to divide by the size of one element, because the sizeof char is one anyway, so it won't make a difference. Why do we use sizeof instead of strlen? Because it already accounts for the terminating null character, and it evaluates at compile time. The compiler can literally substitute the size that the sizeof expression returns.

OK, reading the answer to the question linked to in the comments (thanks, @"John Zwinck" and @"eryksun"), there are two ways of storing the data, either in a bytearray or a numpy.array. In all these snippets, image_data is of type POINTER(c_ubyte), and we have array_type defined as -

array_type = c_ubyte * num_channels * width * height

We can create a bytearray first and then loop over and set the bytes

arr_bytes = bytearray(array_size)
for i in range(array_size):
    arr_bytes[i] = image_data[i]

Or a better way is to create a C array instance using from_address and then initialize a bytearray with it -

image_data_carray = array_type.from_address(addressof(image_data.contents))

# Copy into bytearray
image_data_bytearray = bytearray(image_data_carray)

And during writing the image (didn't ask this question, just sharing for completeness), we can obtain pointer to the bytearray data like this and give it to stbi_write_png

image_data_carray = array_type.from_buffer(image_data_bytearray)
image_data = cast(image_data_carray, POINTER(c_ubyte))

The numpy based way of doing it is as answered in the linked question

address = addressof(image_data.contents)
image_data_ptr = np.ctypeslib.as_array(array_type.from_address(address))

This alone however only points to the memory returned by the C function, doesn't copy into a Python-managed array object. We can copy by creating a numpy array as

image_data = np.array(image_data_ptr)

To confirm I have done an assert all(arr_np == arr_bytes) there. And arr_np.dtype is uint8.

And during writing the image, we can obtain a pointer to the numpy array's data like this

image_data = image_data_numpy.ctypes.data_as(POINTER(c_ubyte))

The fundamental copying, where you know how many bytes you want to copy, where you want to take them from, and where you want to put them, can be done with memcpy:

#include <string.h>

char const* src = "888";
char dest[] = "Hello World!";

memcpy(&dest[2], src, 3);

// dest now contains "He888 World!"

That copies 3 bytes from src to &dest[2] (which is two bytes past the start). Like most things in C, it’s up to you to make sure the operation is valid.

If the length of src is variable, you can use strlen to find its length:

char const* src = "1234";
char dest[] = "Hello World!";

memcpy(&dest[2], src, strlen(src));

// dest now contains "He1234World!"

If you want to produce the result as a separate string from both inputs, you can allocate memory for a copy of the string and copy it using strdup before making any changes (this memory has to be freed with free):

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

char const* src = "1234";
char const* dest = "Hello World!";
char* result = strdup(dest);

if (result == NULL) {
    fputs("failed to allocate memory\n", stderr);
    return EXIT_FAILURE;
}

memcpy(&result[2], src, strlen(src));

// result now contains "He1234World!"

free(result);

If it’s not otherwise guaranteed that src will fit in dest, you get to experience the wonderful world of avoiding integer overflow:

size_t offset = 2;

if (offset > strlen(dest) || strlen(src) > strlen(dest) - offset) {
    fprintf(
        stderr,
        "src (%zu bytes) is too long to copy into dest (%zu bytes) at offset %zu",
        strlen(src), strlen(dest), offset
    );
    return EXIT_FAILURE;
}

memcpy(&result[offset], src, strlen(src));

Hoping that’s not necessary for your purposes.

Avoid using an operation that makes a temporary copy, or that creates temporary objects while iterating. This should be a direct copy from the source buffer to the target buffer. It's simplest to use ctypes.memmove:

f = Foo()
f.f1=1
f.f2=2

buf = (c_char * 100)()
memmove(buf, byref(f), sizeof(f))

Or use a temporary array created with from_buffer (not a copy):

memoryview(buf)[:sizeof(f)] = (c_char * sizeof(f)).from_buffer(f)

The latter doesn't work in Python 3, however. It should work, but the buffer format codes that ctypes uses aren't supported by memoryview.

If you wanted a new array that was the same size or smaller, you could use the array type's from_buffer_copy method (2.6+):

buf = (c_char * sizeof(f)).from_buffer_copy(f)

You need to assign to dest inside the function

int tokenCopy(char *dest, const char *src, int destSize) {
    *dest = 0;
    // rest of the code
}

Thanks to @ErykSun the solution:

Python code

string1 = "my string 1"
string2 = "my string 2"

# create byte objects from the strings
b_string1 = string1.encode('utf-8')
b_string2 = string2.encode('utf-8')

# send strings to c function
my_c_function.argtypes = [ctypes.c_char_p, ctypes.c_char_p]
my_c_function(b_string1, b_string2)

First, you import the ctypes module. Then you need to load your c dll containing the said function. After that you need to set the argument types and the result type of that function. Finally you create your destination buffer and call your function.

Python:

import ctypes as ct

MAX_BUFSIZE = 100
  
mycdll = ct.CDLL("path_to_your_c_dll")  # for windows you use ct.WinDLL(path)

mycdll.function_name.argtypes = [ct.c_char_p, ct.c_int,
                                 ct.c_char_p, ct.c_char_p]

mycdll.function_name.restype = ct.c_int

mystrbuf = ct.create_string_buffer(MAX_BUFSIZE)
result = mycdll.function_name(mystrbuf, len(mystrbuf), 
                              b"my_input", b"my_second_input")

Working example using strncpy:

import ctypes as ct

MAX_BUFSIZE = 100

mycdll = ct.CDLL("libc.so.6")  # on windows you use cdll.msvcrt, instead

mycdll.strncpy.argtypes = [ct.c_char_p, ct.c_char_p, ct.c_size_t]

mycdll.strncpy.restype = ct.c_char_p

mystrbuf = ct.create_string_buffer(MAX_BUFSIZE)
dest = mycdll.strncpy(mystrbuf, b"my_input", len(mystrbuf))

print(mystrbuf.value)

Python 3 output:

user@Mint20:~/Dokumente/Programmieren/sites/Stackoverflow$ python3 --version
Python 3.8.5

user@Mint20:~/Dokumente/Programmieren/sites/Stackoverflow$ python3 python_ctypes.py 
b'my_input'

Python 2 output:

user@Mint20:~/Dokumente/Programmieren/sites/Stackoverflow$ python2 --version
Python 2.7.18

user@Mint20:~/Dokumente/Programmieren/sites/Stackoverflow$ python2 python_ctypes.py 
my_input

The correct answer is:

p.communicate(b"insert into egg values ('egg')")

Note the leading b, telling you that it's a string of bytes, not a string of unicode characters. Also, if you are reading this from a file:

value = open('thefile', 'rt').read()
p.communicate(value)

The change that to:

value = open('thefile', 'rb').read()
p.communicate(value)

Again, note the 'b'. Now if your value is a string you get from an API that only returns strings no matter what, then you need to encode it.

p.communicate(value.encode('latin-1'))

Latin-1, because unlike ASCII it supports all 256 bytes. But that said, having binary data in unicode is asking for trouble. It's better if you can make it binary from the start.

The problem was that I was not finding the right API call for what I needed. Here is the call (in case anyone cares) that solves this problem: Py_BuildValue and is documented here:

https://docs.python.org/3/extending/extending.html#building-arbitrary-values