Finding invalid pointers

[TDB]

int main() {
void *p;

p=(void *)0x00000005;

// Here
printf(" %d ",* (int *)p);

return 0;
}

When I executed the above code using GCC and VC++, it caused
segmentation error and windows error..

I need a condition that can find whether the pointer address will
cause error or not..

Any suggestions to construct that condition ?

[Ulrich Eckhardt]

TDB wrote:

void *p;

p=(void *)0x00000005;

// Here
printf(" %d ",* (int *)p);

[..]

When I executed the above code using GCC and VC++, it caused
segmentation error and windows error..

I need a condition that can find whether the pointer address will
cause error or not..

There isn't any that is not system-dependant. As a rule of thumb, make sure
that pointers are zero unless they point to something real. Then, you can
simply check them with 'if(p)' or 'if(p!=NULL)'.

Uli

[Walter Roberson]

In article <6a**********************************@u10g2000prn. googlegroups.com>,
TDB <vn*****@gmail.comwrote:

>int main() {
void *p;

p=(void *)0x00000005;

// Here
printf(" %d ",* (int *)p);

return 0;
}

When I executed the above code using GCC and VC++, it caused
segmentation error and windows error..

I need a condition that can find whether the pointer address will
cause error or not..

Any suggestions to construct that condition ?

There is no facility in standard C that would allow you to make
that determination.

For any given pointer value, the answer of whether an access
would lead to an error or not can be dynamic, changing over time.

For example the pointer might be to an object that used to exist
but which has been returned to the operating system with the
address having been removed from range of accessible virtual addresses.

Alternately, the pointer might happen to be to a location that
was not in range before, but is in range right now.

Or the pointer might happen to be to an I/O address to a device
that is wandering in and out of availability (e.g., USB devices
get unplugged, SCSI addresses have bus faults.)

You may wish to investigate use of signal() and SIGSEGV .
It is not certain that a SIGSEGV will be raised for every illegal
access (indeed, it is unlikely on Unix machines, which tend to
have a finer discrimination for different kinds of illegal access),
but you might happen to find that on every implementation you wish
to port to that it is sufficient for whatever it is you are trying to do.
--
"Beware of bugs in the above code; I have only proved it correct,
not tried it." -- Donald Knuth

[Morris Dovey]

TDB wrote:

>
int main() {
void *p;

p=(void *)0x00000005;

// Here
printf(" %d ",* (int *)p);

return 0;
}

When I executed the above code using GCC and VC++, it caused
segmentation error and windows error..

I need a condition that can find whether the pointer address will
cause error or not..

Any suggestions to construct that condition ?

Peek/poke games require either having access to a memory map,
hooks into the OS (for dynamically-allocated areas), or some way
to intercept the segmentation error and render it non-fatal.

If you don't have one of those three facilities, then you're
stuck with the existing mechanism that detects the invalid access
and terminates the program.

FYI *p == 0xC3 on all CP/M systems. :-)

--
Morris Dovey
DeSoto Solar
DeSoto, Iowa USA
http://www.iedu.com/DeSoto

[M.Caggiano]

On 4 Feb, 18:57, TDB <[e-mail]:

int main() {
void *p;

p=(void *)0x00000005;

// Here
printf(" %d ",* (int *)p);

return 0;
}

When I executed the above code using GCC and VC++, it caused
segmentation error and windows error..

I need a condition that can find whether the pointer address will
cause error or not..

Any suggestions to construct that condition ?

In my opinion, you are wrong to use the pointer in that way. If you've
declared p with void, but after you've used then it as an int.

[Walter Roberson]

In article <6a**********************************@u10g2000prn. googlegroups.com>,
M.Caggiano <Mi**************@gmail.comwrote:

>On 4 Feb, 18:57, TDB <[e-mail]:

>int main() {
void *p;

> p=(void *)0x00000005;

> // Here
printf(" %d ",* (int *)p);

> return 0;
}

>In my opinion, you are wrong to use the pointer in that way. If you've
declared p with void, but after you've used then it as an int.

It would not have mattered for the purpose of his question if his
code had been

int main() {
int *p;
p = (int *)0x00000005;
printf(" %d ",* (int *)p);
return 0;
}

This code is not inherently invalid: C implementations are permitted
to define meaningful conversions between integral values and pointers,
but they are not required to, and the result of the dereference
is of course undefined if the resulting pointer is not properly
aligned or does not point to an object.
--
"I will speculate that [...] applications [...] could actually see a
performance boost for most users by going dual-core [...] because it
is running the adware and spyware that [...] are otherwise slowing
down the single CPU that user has today" -- Herb Sutter

[CBFalconer]

Morris Dovey wrote:

TDB wrote:

>int main() {
void *p;

p=(void *)0x00000005;

// Here
printf(" %d ",* (int *)p);
return 0;
}

When I executed the above code using GCC and VC++, it caused
segmentation error and windows error..

I need a condition that can find whether the pointer address
will cause error or not..

Any suggestions to construct that condition ?

Peek/poke games require either having access to a memory map,
hooks into the OS (for dynamically-allocated areas), or some way
to intercept the segmentation error and render it non-fatal.

If you don't have one of those three facilities, then you're
stuck with the existing mechanism that detects the invalid
access and terminates the program.

FYI *p == 0xC3 on all CP/M systems. :-)

I can make it work with 0xCD :-)

--
[mail]: Chuck F (cbfalconer at maineline dot net)
[page]: <http://cbfalconer.home.att.net>
Try the download section.

--
Posted via a free Usenet account from http://www.teranews.com

[Morris Dovey]

CBFalconer wrote:

>
Morris Dovey wrote:

TDB wrote:

int main() {
void *p;

p=(void *)0x00000005;

// Here
printf(" %d ",* (int *)p);
return 0;
}

When I executed the above code using GCC and VC++, it caused
segmentation error and windows error..

I need a condition that can find whether the pointer address
will cause error or not..

Any suggestions to construct that condition ?

Peek/poke games require either having access to a memory map,
hooks into the OS (for dynamically-allocated areas), or some way
to intercept the segmentation error and render it non-fatal.

If you don't have one of those three facilities, then you're
stuck with the existing mechanism that detects the invalid
access and terminates the program.

FYI *p == 0xC3 on all CP/M systems. :-)

I can make it work with 0xCD :-)

%@#&! So can I. :-b

--
Morris Dovey
DeSoto Solar
DeSoto, Iowa USA
http://www.iedu.com/DeSoto

[Army1987]

TDB wrote:

int main() {
void *p;

p=(void *)0x00000005;

// Here
printf(" %d ",* (int *)p);

return 0;
}

When I executed the above code using GCC and VC++, it caused
segmentation error and windows error..

I need a condition that can find whether the pointer address will
cause error or not..

Why? If you need a hard-coded address (as opposed to the address of an
object you have or allocate), what you can find there is extremely
machine-dependent.

--
Army1987 (Replace "NOSPAM" with "email")