The moment you do bb = first;, bb and first are pointing to the same location of memory. first->a = 55; first->b = 55; first->c = 89; will change the values for a, b, and c in that location. The original value of first, is still lingering in memory but no way to access it anymore.

I think what you may want to do is *bb = *first;.

From a technical point of view, using an additional variable ptr to make it possible to return the original destination value is unneccessary, since the caller obviously must already have the value of destination in his scope. If you design a strcpy-like function without returning that value, you can create a more comprehensive implementation, as you have shown above. But the original strcpy function from the standard library is defined to return destination, and my_strcpy obviuosly tries to mimic that behaviour/signature.

The reason for this is mainly "syntactic sugar", allowing the use of strcpy in a call chain. Read this SO post to get a better explanation for what it is good for.

If you want to copy data you should allocate new memory via malloc, then copy your memory via memcpy.

void *startgpswatchdog(void *ptr)
{
    GPSLocation *destination = malloc(sizeof(GPSLocation));
    memcpy(destination, ptr, sizeof(GPSLocation));
}

Is there something wrong with it?

Yes, there is. In each of these cases there is a memory leak. In addition, some of these snippets may do the wrong thing (i.e. the program gives a wrong answer in addition to leaking memory, or just crashes).

In order to understand the memory leak, let's review what assignment does in C. In the words of the standard:

In simple assignment (=), the value of the right operand [...] replaces the value stored in the object designated by the left operand.

In simple down-to-earth words, the left operand forgets the value it was holding before, and starts holding something else.

Now let's recall that a pointer is a value that points to some data (an object, or a block of memory).

What are these values that are copied and forgotten in these statements?

p = malloc(sizeof(something));

// p stores the value returned by malloc, which is a pointer to 
// a block of memory. note that this value is the only pointer in 
// existence that points to that block of memory.

p = something_else;

// p forgets that it was storing a pointer to a block of memory 
// returned by malloc, and now stores a different pointer,
// presumably pointing to another block of memory. 
// the old pointer is now lost forever. there is no other pointer
// that points to the same block.

This is the very definition of memory leak.

Note that the block of memory itself is not touched or modified in any way, shape, or form. Only pointers are changed.

It's the confusion between the pointer and the pointed-to data that leads to this error. It seems that people commit it operate under a false impression that p = malloc(...) allocates space for data, and p = something_else assigns the data to space just allocated. This is indeed not how pointers work. Both statements only assign pointers, and do not touch pointed-to data.

What would be the right way to do this?

It depends on what is "this", i.e. on what you need. There is no universal recipe. In some cases you just want to copy a pointer. Drop the malloc line, and use the second assignment directly:

p = something_else; // no malloc here, just pointer assignment

In other cases you need to copy data pointed to by something_else into a new block of memory returned by malloc and now pointed by p (as opposed to something_else itself, which is a pointer):

p = malloc(sizeof(*p));           // note how sizeof is used here.
copy_data (p, something_else);    // always prefer this over sizeof(some_type)

Of course there is no such thing as copy_data in C. This is something you need to provide yourself, or use one of the standard functions. For example, if you need to copy a string:

p = malloc(strlen(something_else) + 1); // note no sizeof here. the size is dynamic
strcpy(p, something_else);              // also note +1 for the null terminator

// these two lines can be replaced by p = strdup(something_else);
// strdup is a function that has recently entered the C standard, but it was
// supported by all major compilers since the dawn of time

If you need to shallow-copy a struct:

p = malloc(sizeof(*p));
memcpy(p, something_else, sizeof(*p));
// or, if both p and something_else are declared 
// as pointers to struct something
*p = *something_else;

// if the struct contains pointers, this is probably not what you want

I think you have a misunderstanding of what is going on. The statement *p1 = num2; is not changing the value of p1, it is changing the value of whatever p1 points to. Since both p1 and p2 point to the same variable when you change its value through one pointer you will see the same value when you dereference either pointer. What you want to do is have p1 point to num2, not take the value of num2 and store it in whatever p1 points to.

Change

*p1 = num2;

to

p1 = &num2;

To copy strings in C, you can use strcpy. Here is an example:

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

const char * my_str = "Content";
char * my_copy;
my_copy = malloc(sizeof(char) * (strlen(my_str) + 1));
strcpy(my_copy,my_str);

If you want to avoid accidental buffer overflows, use strncpy instead of strcpy. For example:

const char * my_str = "Content";
const size_t len_my_str = strlen(my_str) + 1;
char * my_copy = malloc(len_my_str);
strncpy(my_copy, my_str, len_my_str);