CODEWITHSUNDEEP
c++clinuxpointers
max
max

Reputation: 2657

proper way to use GNU/Linux read() function

in the man pages of GNU/Linux the read function is described with following synopsis:

ssize_t read(int fd, void *buf, size_t count);

I would like to use this function to read data from a socket or a serial port. If the count is greater than one, the pointer supplied in the function argument will point to the last byte that was read from the port in the memory so pointer decrement is necessary for bringing the pointer to the first byte of data. This is dangerous because using it in a language like C++ with it's dynamic memory allocation of containers based on their size and space needs could corrupt data at the point of return from read() function. I thought of using a C-style array instead of a pointer. Is this the correct approach? If not, what is the correct way to do this? The programming language I'm using is C++.

EDIT:

The code that caused the described situation is as follows:

QSerialPort class was used to configure and open the port with following parameters:

and for the reading part as long as the stackoverflow is concerned the read is performed exactly like this:

A std::vector containing a number of structs defined this way:

struct DataMember 
{
    QString name;
    size_t  count;
    char *buff;
}

then within a while loop until the end of the mentioned std::vector is reached, a read() is performed based on count member variable of the said struct and the data is stored in the same struct's buff:

ssize_t nbytes = read(port->handle(), v.at(i).buff, v.at(i).count);

and then the data is printed on the console. In my test case as long as the data is one byte the value printed is correct but for more than one byte the value displayed is the last value that was read from the port plus some garbage values. I don't know why is this happening. Note that the correct result is obtained when the char *buff is changed to char buff[count].

Upvotes: 0

Views: 2835

Answers (3)

datenwolf
datenwolf

Reputation: 162297

I don't know why is this happening.

But I know. char * is just a pointer, but that pointer needs to be initialized to something before you can use it. Without doing so you're invoking undefined behavior and everything might happen.

Instead of the size_t count; and char *buff elements you should just use a std::vector<char>, before making the read call, resize it to the number of bytes you want to read, then take the address of the first element of that vector and pass that to read:

struct fnord {
    std::string name;
    std::vector data;
};

and use it like this; note that using read requires some additional work to properly deal with signal and error conditions.

size_t readsomething(int fd, size_t count, fnord &f)
{
    // reserve memory
    f.data.reserve(count);

    int rbytes = 0;
    int rv;
    do {
        rv = read(fd, &f.data[rbytes], count - rbytes);
        if( !rv ) {
            // End of File / Stream
            break;
        }
        if( 0 > rv ) {
            if( EINTR == errno ) {
                // signal interrupted read... restart
                continue;
            }
            if( EAGAIN == errno
             || EWOULDBLOCK == errno ) {
                // file / socket is in nonblocking mode and
                // no more data is available.
                break;
            }
            // some critical error happened. Deal with it!
            break;
        }
        rbytes += rv;
    } while(rbytes < count);
    return rbyteS;
}

Looking at your first paragraph of gibberish:

If the count is greater than one, the pointer supplied in the function argument will point to the last byte that was read from the port in the memory

What makes you think so? This is not how it works. Most likely you passed some invalid pointer that wasn't properly initialized. Anything can happen.

so pointer decrement is necessary for bringing the pointer to the first byte of data.

Nope. That's not how it works.

This is dangerous because using it in a language like C++ with it's dynamic memory allocation of containers based on their size and space needs could corrupt data at the point of return from read() function.

Nope. That's not how it works!

C and C++ are an explicit languages. Everything happens in plain sight and nothing happens without you (the programmer) explicitly requesting it. No memory is allocated without you requesting this to happen. It can either be an explicit new, some RAII, automatic storage or the use of a container. But nothing happens "out of the blue" in C and C++. There's no built-in garbage collection^1 in C nor C++. Objects don't move around in memory or resize without you explicitly coding something into your program that makes this happen.

[1]: There are GC libraries you can use, but those never will stomp onto anything that can be reached by code that's executing. Essentially garbage collector libraries for C and C++ are memory leak detectors, which will free memory that can no longer be reached by normal program flow.

Upvotes: 0

Goswin von Brederlow
Goswin von Brederlow

Reputation: 12342

In my test case as long as the data is one byte the value printed is correct but for more than one byte the value displayed is the last value that was read from the port plus some garbage values.

From the read(2) manpage:

On success, the number of bytes read is returned (zero indicates end of file), and the file position is advanced by this number. It is not an error if this number is smaller than the number of bytes requested; this may happen for example because fewer bytes are actually available right now (maybe because we were close to end-of-file, or because we are reading from a pipe, or from a terminal), or because read() was interrupted by a signal. On error, -1 is returned, and errno is set appropriately. In this case it is left unspecified whether the file position (if any) changes.

In the case of pipes, sockets and character devices (that includes serial ports) and a blocking file descriptor (default) read will, in practice, not wait for the full count. In your case read() blocks until a byte comes in on the serial port and returns. That is why in the output the first byte is correct and the rest is garbage (uninitialized memory). You have to add a loop around the read() that repeats until count bytes have been read if you need the full count.

Upvotes: 2

user207421
user207421

Reputation: 311018

If the count is greater than one, the pointer supplied in the function argument will point to the last byte that was read from the port in the memory

No. The pointer is passed to the read() method by value, so it is therefore completely and utterly impossible for the value to be any different after the call than it was before, regardless of the count.

so pointer decrement is necessary for bringing the pointer to the first byte of data.

The pointer already points to the first byte of data. No decrement is necessary.

This is dangerous because using it in a language like C++ with it's dynamic memory allocation of containers based on their size and space needs could corrupt data at the point of return from read() function.

This is all nonsense based on an impossibility.

You are mistaken about all this.

Upvotes: 3

Related Questions