is it possible to detect an illegal address?

webquinty · 01-23-2013, 10:05 AM

Hello,

I would like to check if address is legal or not.
For example, one variable of my program is 0x08453212 is legal but 0x06000000 is an illegal address.

I have tried to detect a illegal address with this code:

Code:

addr_writeable = read(fd_zero, (UDINT *)(rcv_data + 0), 1 );

but always return me 1.

is there any way to detect a illgeal address access??

Best regards.

NevemTeve · 01-23-2013, 10:43 AM

'read' has nothing to do with memory addresses. When you access an invalid address you get a SIGSEGV signal.

webquinty · 01-24-2013, 04:17 AM

Quote:

Originally Posted by NevemTeve

'read' has nothing to do with memory addresses. When you access an invalid address you get a SIGSEGV signal.

As I understood, system emit signal when SIGSEGV is emit, but after catch the signal, program continue in the same line and execute illegal command again and program crash.

is it correct?

NevemTeve · 01-24-2013, 04:35 AM

Normally, SIGSEGV stops the program, but you might to try to handle it with a signal-handler (see sigaction(2) for details).

additional reading: http://en.wikipedia.org/wiki/Segmentation_fault

sundialsvcs · 01-24-2013, 07:04 PM

This is precisely what you should do: just go ahead and attempt the operation. If it fails for this reason, a SIGSEGV will be thrown, and you can catch it.

You don't need to try to "test to see if the address will be valid." Just go for it. Nearly all the time, the operation will be successful and you can just go on your merry way. The exception to that rule is when the address isn't valid ... and that's one reason why we call 'em "exceptions."

bigearsbilly · 01-28-2013, 09:03 AM

you can't catch a SIGSEGV (edit: rubbish)

or maybe you can...

there is example code on the man page on how to do it:

http://linux.die.net/man/2/mprotect

bigearsbilly · 01-28-2013, 11:02 AM

actually, I got interested, read detects bad memory addresses anyway...

Code:

int
main(int argc, char *argv[])
{
    int n = 0;
    char buffer[1024];
    char *p = "hello fishes";
    // p = buffer;

    // set_handler();

    int fd = open(argv[1], 0, 0);
    printf("read %d\n", fd);

    while ( (n = read(fd, p, 2)) ) {

        if (n == -1) {
            switch (errno) {
                case EFAULT:
                    fprintf(stderr, "BAD MEMORY DETECTED\n");

                default:
                    perror("read:");
            }
            break;
        } else {
            printf("%s", p);
        }
    }

    //*p = 'x'; // oops here

    printf("bye\n");

    exit(EXIT_SUCCESS);
}

Code:

[billy@elmer:0]$ ./sigsev /etc/hosts 
read 3
BAD MEMORY DETECTED
read:: Bad address
bye
[billy@elmer:0]$ ./sigsev /etc/fish 
read -1
read:: Bad file descriptor
bye

mina86 · 01-28-2013, 12:22 PM

read() and other system calls check for validity of the address and return -EFAULT if the address is invalid (ie. inaccessible for given purpose). SIGSEGV is thrown when program tries to access given memory directly as in:

Code:

*(volatile char *)pointer;

webquinty, why do you need to check validity of an address? It sounds to me like you're doing something you should not be doing.

sundialsvcs · 01-28-2013, 06:20 PM

Within kernel mode, yes, address validity checks do occur. The Kernel is special.

JohnGraham · 01-29-2013, 04:49 AM

IMHO, checking the "validity" of an address in this way (i.e checking that it's in your virtual address space) is totally useless.

Even if you can verify it's in your address space, this isn't really "valid", since it could be pointing anywhere in your address space, including data you don't intend or want to be overwritten.

Take the time you're using trying to pre-empt these mistakes and spend it making sure your code's correct.

mina86 · 01-29-2013, 06:44 AM

Quote:

Originally Posted by sundialsvcs

Within kernel mode, yes, address validity checks do occur. The Kernel is special.

Point is, calls to read() won't cause a SIGSEGV, but instead will set errno to EFAULT.

sundialsvcs · 01-29-2013, 08:10 AM

One "trick" that I have used a lot is to write a few routines of my own to do memory-allocation within an application.

The first routine allocates a guaranteed zero-filled buffer of the specified size plus 8 bytes more. It puts a "4-byte eyecatcher" at the beginning and at the end. The trailing "eyecatcher" begins with a zero-byte. It returns a pointer past the eyecatcher.

Another routine simply checks for the presence of the eyecatcher (at 4 bytes before the passed cannot-be-NULL pointer, and at the end), and throws an exception if not. Otherwise it returns the value passed.

A final routine checks and then disposes-of the buffer passed, doing nothing if NULL.

Each routine also requires a pointer to a character-string constant which is used in the exception-message if thrown.

So what happens? An amazing number of "nassss-s-s-s-ssty little bugssssss-s-s-s-s-ssss" get stomped during development, and/or almost-instantaneously discovered during initial beta-testing. At basically zero cost in performance.

mina86 · 01-29-2013, 08:18 AM

Quote:

Originally Posted by sundialsvcs

Another routine simply checks for the presence of the eyecatcher (at 4 bytes before the passed cannot-be-NULL pointer, and at the end), and throws an exception if not. Otherwise it returns the value passed.

This of course won't work for arraies if you pass a pointer to an element in the middle of the array. Strings are among this category.

NevemTeve · 01-29-2013, 08:44 AM

Note: A similar useful tool is Electric Fence.