apue | Advanced Programming in the UNIX Environment | Interpreter library

From this sigaction manual page:

This is a pointer to a ucontext_t structure, cast to void *. The structure pointed to by this field contains signal context information that was saved on the user-space stack by the kernel; ... Commonly, the handler function doesn't make any use of the third argument.

So this argument is a kernel-specific pointer to a special signal context. It's not possible to reuse it for user-data.

There’s nothing particularly special about this function. It’s specified by POSIX to read a single, newline-delimited line from stream, into the buffer whose address is given by lineptr and which must be large enough to hold n bytes.

The reason lineptr and n are pointers is that they are used both as input to the function and potentially output from it. If lineptr is NULL on entry, or n indicates that its size is too small to hold the line read from stream, then getline (re)allocates a buffer and updates lineptr and n with the corresponding information.

getline is easier to use than fgets because the latter will stop reading when it reaches the end of the buffer. So if fgets tries to read a line longer than the provided buffer, it will return a partial read and the caller will have to read again and connect the multiple parts. In such circumstances, getline would reallocate the provided buffer, if any.

As explained in the GNU C Library documentation,

Standard C has functions to do this, but they aren’t very safe: null characters and even (for gets) long lines can confuse them. So the GNU C Library provides the nonstandard getline function that makes it easy to read lines reliably.

(getline originated in the GNU C Library and was added to POSIX in the 2008 edition.)

I think that's because according to the manual of pthread_join, it stores the return value of the thread, not a memory address: as you can see on the thr_fn1 and 2 functions, the return value is (void *)1 and (void *)2.

Dereferencing the pointer is pointless, as we are interested in his value, not the address he points to.

The second case uses this technique because ptr is actually a memory address.

In Linux there are blocking and non-blocking system calls. The write is an example of blocking system call, which means the execution thread will be blocked until the write completes. So once the user process called write, it can not execute anything else until the system call is complete. So from user thread perspective it will behave like atomic [although at kernel level lot many things can happen and kernel execution of system call can be interrupted many times].

the correct way is to use sizeof (struct sockaddr_un) actually.

The regex seems ok, you forgot to assign the new value to the text variable:

putenv is reentrant in newer versions of glibc. The problem is that putenv does not copy the string that is given to it, and therefore you cannot base it on your stack. Try keeping your char env[100] in a place where it will not be destroyed at the function's end.

The putenv() function is not required to be reentrant, and the one in glibc 2.0 is not, but the glibc 2.1 version is.

...

Since version 2.1.2, the glibc implementation conforms to SUSv2: the pointer string given to putenv() is used. In particular, this string becomes part of the environment; changing it later will change the environment. (Thus, it is an error to call putenv() with an automatic variable as the argument, then return from the calling function while string is still part of the environment.)

It's embarrassed for me,I make a mistake. My friend and I share the same virtual machine,he read the book faster than me.He runs 4-12 program,which the code like the following:

Your question is a bit confusing.

Let me see if I understand. Please correct me where needed:

1. You have a .pcap file that you can open and load its contents in a program--let's call the program "A".

2. You want to make that .pcap file's contents available in memory buffer that you share with another program--let's call the program "B".

3. Based on the example in the APUE book, your idea is to mmap /dev/zero in program A, copy the contents of the .pcap file into the mapped memory segment, and then expect that when program B also maps /dev/zero, it will see the contents of the .pcap file.

Is that what you're going for?

If so, then I don't think you'll be able to use /dev/zero. Each of the two programs, when it mmap's /dev/zero, will get a separate zero-filled instance of the memory map. The only way for the two programs to share, in that case, would be for one to be a fork() of the other.

However, you could create a named shared memory object other than "/dev/zero" (call it "/tmp/mypcap" or something) and then multiple programs could share it.