if a and b are pointing to the same address and it's not lost, why can't I access the array from inside main?

You change b and return it, but dont save return in main

a = foo(a)

Hi, I have a question, i'm creating a simple program that checks for a password to pratise some C programming, but I get a Segmentation Fault in the fgets function but don't know why. The C code is this one: #include <openssl/md5.h> #include <stdio.h> #include "md5.h" #include "hex.h" int main() { char pass[30]; char *out; char *out2; printf("[=] Password: "); fgets(pass, sizeof(pass), stdin); // HERE IS THE ERROR out = md5crypt(pass); out2 = hexencode(out); if(strcmp(out2, "E492931E5DAA29C4B1FE5B4A924567DB") == 0) { printf("[+] Access granted, use the password as flag!\n"); exit(1); } else { printf("[-] Try again!\n"); } return 0; }

I am seeing openssl/md5.h and hex.h for.the very first time.

I was also thinking about it and what about openssl/md5 ? That is also written by him ?

if a and b are pointing to the same address and it's not lost, why can't I access the array from inside main?

What is line 7 intend to do here ?

Reserving 4 contiguous blocks of size 4 bytes in heap

Why before malloc, there is (*int)?

Not really needed, but having or not having it is not problem

But then in that particular code why he/she used it ?

getting an error like this : warning: no return statement in function returning non-void [-Wreturn-type] }

then what should i do about that?

sorry man, thanks tho

What does && in the above program does?

What does && in the above program does?

As far as i understood you can replace main() with 0

if a and b are pointing to the same address and it's not lost, why can't I access the array from inside main?

that can not be replaced

me too, but it's a little bit interesting ,becuese there is a Recursion, it should ended till the x reach the N

i'm sure it does.

Did a gdb there, can clearly see a and b hold same addresses

Did they even after foo is closed?

Not sure about b because once foo exited, we can't access b. But a still hold the same address

But the print doesn't print what you expect, right?

My code doesn't use reference. It's a C program

My code doesn't use reference. It's a C program

#include<iostream> using namespace std; int N = 10; int main() { static int x = 1; if (cout << x << " " && x++ < N && main()) { } return 0; }

Then return int* or pass int**

I deliberately didn't do that. Reason: malloc does allocation in a heap segment. That segment is available until we free or terminate the program. Now b is pointing to contiguous blocks of 4 ints. So, if I know address contained in b, I should be able to know about values also that are contained in those 4 blocks, shouldn't I?

Why? Without doing that why consecutive blocks of memory are not accessible outside of foo (via a)?

Why? Without doing that why consecutive blocks of memory are not accessible outside of foo (via a)?

Cause b is a copy of a. When you change b, a holds old value

Doesn't a have the same address as b despite b doesn't exist anymore?

Imagine a, b are int. b is copy of a. Here you have same situation

They are at two different memory addresses. In my case, it's the same memory addres that a and b are pointing to

Only before call. When b is changed, they point to different addresses

How has b changed? It still points to the start of the memory block ..right?

b = ... b changed

Which line number has b changed in?

if a and b are pointing to the same address and it's not lost, why can't I access the array from inside main?

The malloc one

But I did a gdb..and just before foo exits, b holds the same address which it held at the beginning of foo

But I did a gdb..and just before foo exits, b holds the same address which it held at the beginning of foo

Points to or has?