After function call, argument pointers don't keep their value

Question

I am passing 3 pointers (key, K1Ptr, K2Ptr) as arguments to a function (keyGenerator) but when the function call ends, only the key pointer keeps the value from the function call and the other 2 pointers don't.

I have tried a lot of different things, like returning an array with the 2 pointers, or i tried not using pointers and pass 2 arrays instead. Both tries had the same result none kept value after the function call.

char K1[9], K2[9];
char *K1ptr, *K2ptr;

K1ptr = K1;
K2ptr = K2;

keyGenerator(key, K1ptr, K2ptr);

printf("Key. %s\n", key);
printf("K1. %s\n", K1Ptr);
printf("K2. %s\n", K2Ptr);

\

void keyGenerator(char *key, char *K1, char *K2) {

char P10_Left[6];
char P10_Right[6];
char *P10leftPtr, *P10rightPtr;


printf("Starting key: %s\n", key);

//P10 Operation first step
P10_swap(key);
printf("P10swap key: %s\n", key);

//Initializing the left and right arrays
int i;
for(i=0;i<5;i++) {

    P10_Left[i] = key[i];
    P10_Right[i] = key[i+5];
}
P10_Left[5] = '\0';
P10_Right[5] = '\0';

P10leftPtr = P10_Left;
P10rightPtr = P10_Right;

//The left half shift
LS(P10leftPtr, 1);
//The right half shift
LS(P10rightPtr, 1);


//P8 swap starts here
K1 = P8_swap(P10leftPtr, P10rightPtr);

printf("K1 key: %s\n", K1);
//P8 swap ends here


//After we find K1 we need to shift the 2 halves again, 2 times to the left this time
//The left half shift
LS(P10leftPtr, 2);
//The right half shift
LS(P10rightPtr, 2);


//After the 2 shifts we use P8 operation again on the new halves
//P8 swap starts here
K2 = P8_swap(P10leftPtr, P10rightPtr);

printf("K2 key: %s\n", K2);
//P8 swap ends here

} //

char* P8_swap(char *left_key, char *right_key) {

int P8[8] = {6, 3, 7, 4, 8, 5, 10, 9}; //key possitions after P8 operation
char P8_Output[9];
char *K1; //They key after the P8 swap
char keyLR[11]; //The left and right halves will be stored together here

int i;

//The two halves become one so that we can do the P8 swap
for(i=0;i<5;i++) {
    keyLR[i] = left_key[i];
    keyLR[i+5] = right_key[i];
}

//P8 swap
for(i=0; i<8; i++) {
    P8_Output[i] = keyLR[P8[i]-1];  //P10[i] - 1 because the possitiongs in P10 are from 1-10 and not 0-9
}

P8_Output[8] = '\0';

K1 = P8_Output;

return K1;

}

After the function keyGenerator when i print the K1Ptr and K2Ptr i get nothing but i was expecting to get the values that are stored inside the function.

Answer 1

In this line:

K1 = P8_swap(P10leftPtr, P10rightPtr);

you change the value of K1 but that change is local to the function and will not change the value of K1ptr in main.

If you want to change the value of K1ptr in main you need to pass a pointer to K1ptr to the function. However, that would seem a bit strange as you initialize K1ptr to point to the char-array K1[9]. My guess is that you don't want to change the pointer value in the function but just copy some data into the "pointed-to" array.

BTW:

Your P8_swap is wrong. You return a pointer to P8_Output which is a local variable. Never do that! When the function returns, the local variable goes out of scope (aka no longer exists) so the returned pointer points to illegal memory. If you really want something like that, you must use dynamic memory allocation.

Answer 2

Definition of function parameters K1 and K2:

void keyGenerator(char *key, char *K1, char *K2)

shadows global variables:

char K1[9], K2[9];

And since function parameters are local to the scope of the function they are in fact assigned, but the value is not propagated to the variables defined elsewhere.

Try to use:

void keyGenerator(char *key, char **K1, char **K2)

and call it:

keyGenerator(key, & K1ptr, & K2ptr);

Also there is a need to change assignmend to K1 inside the function depending on P8_swap function.

Answer 3

The problem is here

K1 = P8_swap(P10leftPtr, P10rightPtr);

and here

K2 = P8_swap(P10leftPtr, P10rightPtr);

You are basically overwriting the value of the pointers, so that they point to something else that is eventually destroyed at the end of the function call.

So, instead, you need to copy the return value of P8_swap() call into the pointers' content, like so:

char* tmp = P8_swap(P10leftPtr, P10rightPtr);
memcpy(K1, tmp, strlen(tmp)+1);

...

tmp = P8_swap(P10leftPtr, P10rightPtr);
memcpy(K2, tmp, strlen(tmp)+1);

You can read more about memcpy here.

or a basic for loop would also do it

char* tmp = P8_swap(P10leftPtr, P10rightPtr);
for(int i = 0; i < strlen(tmp); i++) {
  K1[i] = tmp[i];
}

---

Edit:

As @4386427 just pointed out, the tmp would be in this case an unsafe pointer to use, since the return value P8_swap() might get destroyed in the meantime - because it's defined locally within the function.

However, if the memory was allocated dynamically for the value (within the function) - as I initially assumed, then the pointer would be safe to use. See demo.