Re: programi parsing question

[Phlip]

Scott Lurndal wrote:

>if((fd = open(_PATH_UTMP , O_RDONLY)) < 0)

The open system call is defined to return '-1' on failure, not any
negative number. So the above check is incorrect. This can
cause problems with mmap, lseek and other system calls whose return
values, if declared or cast as signed, while legal are negative.

mmap() should always be checked against MAP_FAILED, and lseek return
should always be compared with the expected value (i.e. the offset
arg for SEEK_SET, and the expected offset for the other SEEK_* variants).

Would it also cause a problem if your file descriptors go "around the horn", and
exceed some platform-specific limit, such as 0x80000000? They would "go
negative" when expressed as signed integers...

It's good practice to always test for the defined return code
(which in most cases is -1, not < 0).

Does some relatively standard .h file define a good constant there?

--
Phlip

[Keith Thompson]

rl*@hoekstra-uitgeverij.nl (Richard Bos) writes:

Keith Thompson <ks***@mib.orgw rote:

>rl*@hoekstra-uitgeverij.nl (Richard Bos) writes:

Keith Thompson <ks***@mib.orgw rote:
CBFalconer <cb********@yah oo.comwrites:
Phlip wrote:
Yet open() _is_ the implementation. It's just not (apparently) in
the narrowest C Standard.

No, open() is not in ANY C implementation.

Yes, it certainly is in many C implementations . It's not defined by
the C standard, but it's allowed as an extension.

C99 4p6:

A conforming implementation may have extensions (including
additional library functions), provided they do not alter the
behavior of any strictly conforming program.

open() is one of these "additional library functions".

Not so; a strictly conforming program may itself define open().

Of course, but how does that disagree with what I wrote?

It means that open() may not exist for any strictly-C program.

Of course. Again, how does that disagree with what I wrote?

What a C implementation _may_ do is declaring open() in a non-Standard
header, since #including such a header renders a program not strictly
conforming anyway.

Right. On POSIX systems, open() is declared in <fcntl.h>.

So open() is not actually in the _C_ implementation, but in the _POSIX_
implementation.

Which is (or at least may be) part of the C implementation. It's an
*extension*. It's an additional library function that doesn't alter
the behavior of any strictly conforming program. It is therefore
something that a conforming C implementation is allowed to have.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"