epollet | demonstration of how to use the EPOLLET flag | Access Management library

by eklitzke C Version: Current License: No License

X-Ray Key Features Code Snippets Community Discussions(10)Vulnerabilities Install Support

kandi X-RAY | epollet Summary

epollet is a C library typically used in Security, Access Management applications. epollet has no bugs, it has no vulnerabilities and it has low support. You can download it from GitHub.

demonstration of how to use the EPOLLET flag

Support

Quality

Security

License

Reuse

Support

epollet has a low active ecosystem.

It has 54 star(s) with 11 fork(s). There are 1 watchers for this library.

It had no major release in the last 6 months.

There are 1 open issues and 0 have been closed. There are no pull requests.

It has a neutral sentiment in the developer community.

The latest version of epollet is current.

Quality

epollet has 0 bugs and 0 code smells.

Security

epollet has no vulnerabilities reported, and its dependent libraries have no vulnerabilities reported.

epollet code analysis shows 0 unresolved vulnerabilities.

There are 0 security hotspots that need review.

License

epollet does not have a standard license declared.

Check the repository for any license declaration and review the terms closely.

Without a license, all rights are reserved, and you cannot use the library in your applications.

Reuse

epollet releases are not available. You will need to build from source code and install.

Top functions reviewed by kandi - BETA

kandi's functional review helps you automatically verify the functionalities of the libraries and avoid rework.
Currently covering the most popular Java, JavaScript and Python libraries. See a Sample of epollet

Get all kandi verified functions for this library.

epollet Key Features

No Key Features are available at this moment for epollet.

epollet Examples and Code Snippets

No Code Snippets are available at this moment for epollet.

Community Discussions

Trending Discussions on epollet

epoll does not signal an event when socket is close

When to rearm epoll with edge mode & oneshot?

Linux C socket how to prevent 2 forked process from accepting the same connection when using epoll?

How does epoll return the correct file descriptor

How to safely delete a socket file descriptor used with epoll in a multithreaded program?

Random lack of connection and message delay in DTLS with OpenSSL

Why getsockopt optlen is zero?

epoll_wait stores a different value in "epoll_event"

How to use an eventfd with level triggered behaviour on epoll?

Can't figure out epoll example in manual

QUESTION

epoll does not signal an event when socket is close

Asked 2022-Jan-29 at 21:11

I have a listener socket, every new connection I get I add it to epoll like this:

...

ANSWER

Answered 2022-Jan-29 at 21:11

There are a few problems with your attempt.

You should not use EPOLLONESHOT unless you know what you are doing and you really need it. It disables the report of any other events to the epoll instance until you enable it again with EPOLL_CTL_MOD.
You should not use EPOLLHUP to determine if a connection was closed. The EPOLLHUP event may be raised before all data is read from the socket input stream, even if the client disconnects gracefully. I recommend you to only use EPOLLIN. If there is no input left (because of forceful or graceful disconnect), the read() would return 0 (EOF) and you can close the socket.
Your read() call will block the reading thread and consume the whole stream until EOF (connection closed). The whole point in using epoll() is to not have to use a while ( read(...) > 0 ) loop.
You should not use EPOLLET because "the code runs multithreaded" but because you need it. You can write multithreaded code without the edge-triggered mode. The use of EPOLLET requires a thorough knowledge of the differences between blocking and non-blocking I/O. You can easily run into pitfalls (as mentioned in the manual), like edge-triggered starvation.

Source https://stackoverflow.com/questions/70905227

QUESTION

When to rearm epoll with edge mode & oneshot?

Asked 2021-Nov-08 at 18:01

I'm writing a coroutine wrapper for sockets as a demo for coroutine use cases and I'm struggling a bit with how to use epoll safely (without introducing race conditions).

I have already figured out that I have to use the edge mode EPOLLET with EPOLLONESHOT. But now I'm not sure when I should be rearming the socket.

Should I rearm before calling a non-blocking operation or after? I want to make sure that I neither miss the event nor receive a phantom one.

...

ANSWER

Answered 2021-Nov-08 at 18:01

Should I rearm before calling a non-blocking operation or after?

Technically, after, but it's not as simple as that.

Regardless of EPOLLONESHOT, once you receive an edge-triggered event signalling read-readiness of a given file descriptor, you must consider that FD to continue to be ready until a read() on it fails with errno set to EAGAIN (and therefore the file must be in non-blocking mode). Over the course of those reads, it may be the case that you read all remaining bytes with one read(), but then more arrive before the next. In that case, if the FD is still armed then a new event for it will be queued (or merged with another event for that FD, as appropriate). This is the case that could result in you receiving an event when in fact the FD is not any longer ready.

You should consider just accepting those "phantom" events. Since your file will be in non-blocking mode, they will not cause unwanted stalls, just a little extra work. And your code will be simpler. But if you do use EPOLLONESHOT to avoid receiving phantom events, then you must not re-arm the FD before you determine it to be unready (via a read failing with EAGAIN), else you defeat the purpose.

Thus, the full answer is after the FD is determined to be unready. That will take at least two read()s, and possibly more. If the file becomes ready after the last read and before the rearming then the rearming should cause an appropriate event to be queued.

Source https://stackoverflow.com/questions/69887234

QUESTION

Linux C socket how to prevent 2 forked process from accepting the same connection when using epoll?

Asked 2021-Oct-27 at 01:40

for (int t = 0; t < physicalCoreCount; t++) {
        int pid = fork();
        if (pid==0) {
            // setting up epoll    
            epoll_fd = epoll_create1(0);                
            event.data.fd = listenSocketfd;
            event.events = EPOLLIN | EPOLLET;
            ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listenSocketfd, &event);                
            events = (epoll_event*)calloc(LISTENQ, sizeof(event));
           
            //*****/
            while (1) {
                int ndfs = epoll_wait(epoll_fd, events, curfdCount, -1);
                if (ndfs==-1) {                        
                    continue;
                }
                for (int i=0; i < ndfs; i++) {
                    if (events[i].data.fd == listenSocketfd) { // original listener
                        int new_connfd = accept(events[i].data.fd, (sockaddr*)&clientaddr, &clientlen);
                        if (new_connfd==-1) {
                            if (errno==EAGAIN || errno==EWOULDBLOCK) {
                                continue;
                            }
                            else exitPerrorLog("accept()");
                        }

                        set_non_block(new_connfd);
                        event.events = EPOLLIN | EPOLLET;
                        event.data.fd = new_connfd;
                        if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, new_connfd, &event) < 0)
                            exitPerrorLog("epoll_ctl");

                        clientaddrOfFd[new_connfd] = new sockaddr_in();
                        memcpy(clientaddrOfFd[new_connfd], &clientaddr, sizeof(clientaddr));
                        curfdCount++;
                    }   
                    else {
                        process(events[i].data.fd, clientaddrOfFd[events[i].data.fd]);
                        //epoll_ctl(epoll_fd, EPOLL_CTL_DEL, events[i].data.fd, &event);                           
                        if (curfdCount > 10000) curfdCount = 10000; //curfdCount--;
                    }
                }
            }
        }
    }

...

ANSWER

Answered 2021-Oct-26 at 16:57

You are creating multiple epoll instances and registering for edge-triggered events on the listening socket in each one. Naturally, you will get an event from each one when a new connection becomes available to accept. However, only one process can successfully accept each connection. As observed in comments, two different children might accept connections that are assigned the same file descriptor number in the respective processes, but that doesn't mean they refer to the same socket.

You have several options, but prominent among them are:

use a single epoll instance, shared by all the processes. You can get this automatically by having the parent create it before forking off any of the children. In this case, only one child will receive each edge-triggered event. Of course, if the children intend to register for events that should be received only by them, then this isn't going to work very well.
just accept (no pun intended) that multiple processes will receive events when a connection becomes available, and deal with it. That appears to be what you're doing now (by ignoring EAGAIN and EWOULDBLOCK errors from accept()), and I see no particular reason why you shouldn't keep doing it.

Source https://stackoverflow.com/questions/69726535

QUESTION

How does epoll return the correct file descriptor

Asked 2021-Aug-04 at 17:45

I have two UDP connections and I'm trying to add them to use epoll(). I am looking at this example:

https://programmer.ink/think/epoll-for-linux-programming.html

I've pasted the code below.

At the beginning they create an epoll event along with an array of epoll events:

struct epoll_event ev,events[20];

I'm not sure why both are needed.

They then call epoll_wait():

nfds=epoll_wait(epfd,events,20,500);

and the socket is retrieved:

if(events[i].data.fd==listenfd)

However, events was not populated between these three lines.

So how does events[i].data.fd contain the socket file descriptor?
Why do we set ev.data.fd=listenfd; if we have an array of epoll_event, which has a file descriptor data member?
...

ANSWER

Answered 2021-Aug-04 at 17:45

So how does events[i].data.fd contain the socket file descriptor?

It's put in there by epoll_wait(). It fills in the events array with information about all the events that occurred.

Why do we set ev.data.fd=listenfd; if we have an array of epoll_event, which has a file descriptor data member?

ev is used to register events to wait for with epoll_ctl(), the events array contains the events that occurred.

Source https://stackoverflow.com/questions/68655433

QUESTION

How to safely delete a socket file descriptor used with epoll in a multithreaded program?

Asked 2021-Jun-23 at 10:55

I am trying to solve the epoll race condition problem where an epoll event loop is running and I want it to stop watching a socket file descriptor (FD), but I can't really know after calling epoll_ctl(..., EPOLL_CTL_DEL, ...) if the epoll instance actually deleted it, or if it's handling an event associated with the FD, or if it's just waking up the thread from epoll_wait().

I have googled a little bit, and found a peculiar kernel patch adding a EPOLL_CTL_DISABLE operation (here). Sadly, it requires EPOLLONESHOT, which I don't think is very efficient, since rearming isn't a trivial operation (it requires a search in the epoll's red-black tree).

Thus I was wondering about my own solution. I can obviously just stop the event loop's thread and eventually recreate it later after I'm done dealing with my socket file descriptor, and I can know when the thread is gone by simply doing pthread_join(), but let's not be naive, pthread_join() will make the kernel release the thread's resources and then pthread_create() will allocate the same resources again, which is not ideal as in the EPOLLONESHOT case and will surely take some performance penalty.

Now I'm wondering about something else. If I could somehow manually dispatch an event on the socket that epoll_wait() will wake up to, I can just deploy any blocking synchronization method after it wakes up to be sure that it doesn't go on further. This way, it will go to the next epoll_wait() iteration, where it will realise the socket got removed and no race conditions will happen. To illustrate, something like the following (can really use anything instead of barriers):

...

ANSWER

Answered 2021-Jun-23 at 10:55

There are several ways to dispatch an event. Since you are using Linux, why don't you use an eventfd https://man7.org/linux/man-pages/man2/eventfd.2.html. Create the eventfd and register it with epoll. When you write to it you will wake up epoll and you can process it like any other file descriptor you need to process.

Source https://stackoverflow.com/questions/68097108

QUESTION

Random lack of connection and message delay in DTLS with OpenSSL

Asked 2021-Jan-12 at 08:27

Trying to write a server for DTLS that will currently just output the text that it receives. The working client is taken from https://github.com/stepheny/openssl-dtls-custom-bio and it sends and receives to its own server just fine.

However, when it sends to this server something strange is happening. Firstly the connection happens only sometimes, there seems to be no way to determine if the connection will start or not. Secondly, and that is even stranger the data is "delayed". One needs to send 6 messages for 1 message to arrive.

So this is the situation:

Start the server.
Start the client.
Hope for connection.
If connected type 5 messages in client to send to server, they are sent, but the server keeps having an error decoding them.
Once you send the 6th message you can note that the 1st message arrives on server.
Once you send the 7th, you will get the 2nd. Etc.

It should be noted that we are not talking about a time delay, there is no way to simply read 5 empty messages at the start of the server, the queue is empty. Only once the 6th message is sent is the queue populated with the 1st real message.

Code:

...

ANSWER

Answered 2021-Jan-12 at 08:27

In case somebody else will have a similar issue. The problem was that the wait between calling server's recv function was 1 second. In that time client thought that server has not responded and began doing weird things. Lowering the delay solved the problem.

Source https://stackoverflow.com/questions/65664358

QUESTION

Why getsockopt optlen is zero?

Asked 2020-Sep-18 at 20:57

I use nonblocking sockets and event library with it. I just noticed when I call connect rapidly to my local ip's ports randomly getsockopt(fd, SOL_SOCKET, SO_ERROR, &val, &optlen);'s optlen becomes 0.

I tried to make smaller code that's able to show problem. I used epoll in this code but same problem happens in other event libraries too.

...

ANSWER

Answered 2020-Sep-18 at 20:55

Calling getsockopt() requires that you provide the buffer to the system, and that means you have to set the optlen before the call:

Source https://stackoverflow.com/questions/63962595

QUESTION

epoll_wait stores a different value in "epoll_event"

Asked 2020-Jul-04 at 13:41

I'll try keep this simple. I have the code below:

...

ANSWER

Answered 2020-Jul-04 at 13:41

The type of the data member of struct epoll_event is a union. As such, only one of its members contains a value at any given time, so when you assign to event.data.ptr you replace the value previously written to event.data.fd. The subsequent epoll_ctl call therefore probably does not express interest in the events you think it does, but in any case, you should expect to read back only the ptr member from the resulting event data, not the fd member.

Source https://stackoverflow.com/questions/62729545

QUESTION

How to use an eventfd with level triggered behaviour on epoll?

Asked 2020-Jun-06 at 19:19

Registering a level triggered eventfd on epoll_ctl only fires once, when not decrementing the eventfd counter. To summarize the problem, I have observed that the epoll flags (EPOLLET, EPOLLONESHOT or None for level triggered behaviour) behave similar. Or in other words: Does not have an effect.

Could you confirm this bug?

I have an application with multiple threads. Each thread waits for new events with epoll_wait with the same epollfd. If you want to terminate the application gracefully, all threads have to be woken up. My thought was that you use the eventfd counter (EFD_SEMAPHORE|EFD_NONBLOCK) for this (with level triggered epoll behavior) to wake up all together. (Regardless of the thundering herd problem for a small number of filedescriptors.)

E.g. for 4 threads you write 4 to the eventfd. I was expecting epoll_wait returns immediately and again and again until the counter is decremented (read) 4 times. epoll_wait only returns once for every write.

Yep, I read all related manuals carefully ;)

...

ANSWER

Answered 2020-Jun-06 at 19:19

When you write to an eventfd, a function eventfd_signal is called. It contains the following line which does the wake up:

Source https://stackoverflow.com/questions/62231433

QUESTION

Can't figure out epoll example in manual

Asked 2020-Apr-16 at 05:04

Recently, I am study system call epoll. I already have basic concept about this topic, but I stuck in example given by manual.

...

ANSWER

Answered 2020-Apr-16 at 05:04

You can look at the man page for epoll_wait for details on struct epoll_event and its data member and to help make sense of the code.

Any given events[n].data.fd refers to an fd that had some kind of event on it. It could either be the listening socket, or it could be a client socket if there are active client connections.

If the fd with activity is the listen_sock listening socket, this means that a new client is attempting a connection. At this point we accept the connection and add the new conn_sock fd to the set of epoll's fds.

Source https://stackoverflow.com/questions/61242842

Community Discussions, Code Snippets contain sources that include Stack Exchange Network

Vulnerabilities

No vulnerabilities reported

Install epollet

You can download it from GitHub.

Support

For any new features, suggestions and bugs create an issue on GitHub. If you have any questions check and ask questions on community page Stack Overflow .

Find more information at: