コード例 #1
0
ファイル: m_pgsql.cpp プロジェクト: AliSharifi/inspircd
	bool DoConnect()
	{
		sql = PQconnectStart(GetDSN().c_str());
		if (!sql)
			return false;

		if(PQstatus(sql) == CONNECTION_BAD)
			return false;

		if(PQsetnonblocking(sql, 1) == -1)
			return false;

		/* OK, we've initalised the connection, now to get it hooked into the socket engine
		* and then start polling it.
		*/
		this->fd = PQsocket(sql);

		if(this->fd <= -1)
			return false;

		if (!ServerInstance->SE->AddFd(this, FD_WANT_NO_WRITE | FD_WANT_NO_READ))
		{
			ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "BUG: Couldn't add pgsql socket to socket engine");
			return false;
		}

		/* Socket all hooked into the engine, now to tell PgSQL to start connecting */
		return DoPoll();
	}
コード例 #2
0
bool wxEpollDispatcher::HasPending() const
{
    epoll_event event;

    // NB: it's not really clear if epoll_wait() can return a number greater
    //     than the number of events passed to it but just in case it can, use
    //     >= instead of == here, see #10397
    return DoPoll(&event, 1, 0) >= 1;
}
コード例 #3
0
ファイル: m_pgsql.cpp プロジェクト: AliSharifi/inspircd
	void DoEvent()
	{
		if((status == CREAD) || (status == CWRITE))
		{
			DoPoll();
		}
		else if((status == RREAD) || (status == RWRITE))
		{
			DoResetPoll();
		}
		else
		{
			DoConnectedPoll();
		}
	}
コード例 #4
0
ファイル: m_pgsql.cpp プロジェクト: thepaul/inspircd-deb
	bool DoEvent()
	{
		bool ret;

		if((status == CREAD) || (status == CWRITE))
		{
			ret = DoPoll();
		}
		else if((status == RREAD) || (status == RWRITE))
		{
			ret = DoResetPoll();
		}
		else
		{
			ret = DoConnectedPoll();
		}
		return ret;
	}
コード例 #5
0
ファイル: m_pgsql.cpp プロジェクト: thepaul/inspircd-deb
	bool DoResetPoll()
	{
		switch(PQresetPoll(sql))
		{
			case PGRES_POLLING_WRITING:
				ServerInstance->SE->WantWrite(this);
				status = CWRITE;
				return DoPoll();
			case PGRES_POLLING_READING:
				status = CREAD;
				return true;
			case PGRES_POLLING_FAILED:
				return false;
			case PGRES_POLLING_OK:
				status = WWRITE;
				return DoConnectedPoll();
			default:
				return true;
		}
	}
コード例 #6
0
int wxEpollDispatcher::Dispatch(int timeout)
{
    epoll_event events[16];

    const int rc = DoPoll(events, WXSIZEOF(events), timeout);

    if ( rc == -1 )
    {
        wxLogSysError(_("Waiting for IO on epoll descriptor %d failed"),
                      m_epollDescriptor);
        return -1;
    }

    int numEvents = 0;
    for ( epoll_event *p = events; p < events + rc; p++ )
    {
        wxFDIOHandler * const handler = (wxFDIOHandler *)(p->data.ptr);
        if ( !handler )
        {
            wxFAIL_MSG( wxT("NULL handler in epoll_event?") );
            continue;
        }

        // note that for compatibility with wxSelectDispatcher we call
        // OnReadWaiting() on EPOLLHUP as this is what epoll_wait() returns
        // when the write end of a pipe is closed while with select() the
        // remaining pipe end becomes ready for reading when this happens
        if ( p->events & (EPOLLIN | EPOLLHUP) )
            handler->OnReadWaiting();
        else if ( p->events & EPOLLOUT )
            handler->OnWriteWaiting();
        else if ( p->events & EPOLLERR )
            handler->OnExceptionWaiting();
        else
            continue;

        numEvents++;
    }

    return numEvents;
}
コード例 #7
0
ファイル: m_pgsql.cpp プロジェクト: AliSharifi/inspircd
	bool DoResetPoll()
	{
		switch(PQresetPoll(sql))
		{
			case PGRES_POLLING_WRITING:
				ServerInstance->SE->ChangeEventMask(this, FD_WANT_POLL_WRITE | FD_WANT_NO_READ);
				status = CWRITE;
				return DoPoll();
			case PGRES_POLLING_READING:
				ServerInstance->SE->ChangeEventMask(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE);
				status = CREAD;
				return true;
			case PGRES_POLLING_FAILED:
				return false;
			case PGRES_POLLING_OK:
				ServerInstance->SE->ChangeEventMask(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE);
				status = WWRITE;
				DoConnectedPoll();
			default:
				return true;
		}
	}
コード例 #8
0
ファイル: devpoll.c プロジェクト: pp7462-git/sandbox
int
PerformOperation(short port)
{
    int acceptFd = 0;
    struct sockaddr_in sin;
    socklen_t sinlen = sizeof(sin);
    int fd = 0;
    int blocking = 1;
    int reuseaddr = 1;
    int devpoll = 0;
    int pollresult = 0;
    struct pollfd dp_fds[MAXSET];
    struct dvpoll pollset;
    int procClient = 0;
    int i = 0;

    /* create devpoll fd
     */
    if ((devpoll = open("/dev/poll", O_RDWR)) == -1)
    {
        printf("devpoll can't be opened: %s(%d)\n", strerror(errno), errno);
        exit(0);
    }
    /* create the accept socket
    */
    acceptFd = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    if (acceptFd == -1)
    {
        /* Error creating accept fd
        */
        printf("Error creating socket: %s\n", strerror(errno));
        exit(0);
    }

    /* set socket opt to reuse address
     */
    if (setsockopt(acceptFd, SOL_SOCKET, SO_REUSEADDR, 
                                        &reuseaddr, sizeof(reuseaddr)) == -1)
    {
        printf("Error w/ setsockopt: %s\n", strerror(errno));  
        close(acceptFd);
        exit(0);
    }

    /* setup the accept fd as nonblocking
    */
    if (ioctl(acceptFd, FIONBIO, &blocking) == -1)
    {
        /* error setting the nonblocking of fd
        */
        printf("Error setting FIONBIO: %s\n", strerror(errno));
        close(acceptFd);
        exit(0);
    }

    /* bind the socket to the port
    */
    memset(&sin, 0, sizeof(sin));
    sin.sin_family = AF_INET;
    sin.sin_port = htons(port);
    sin.sin_addr.s_addr = INADDR_ANY;
    if (bind(acceptFd, (struct sockaddr*)&sin, sizeof(sin))==-1)
    {
        printf("Error binding socket: %s\n", strerror(errno));
        close(acceptFd);
        exit(0);
    }

    /* setup the listen queue
    */
    if (listen(acceptFd, 1) == -1)
    {
        printf("Error listening: %s\n", strerror(errno));
        close(acceptFd);
        exit(0);
    }

    /* Add to dev poll queue
     */
    Add(devpoll, acceptFd);

    while (1)
    {
        /* Get and service any active fd
         */
        pollset.dp_fds = dp_fds;
        pollset.dp_nfds = MAXSET;
        pollset.dp_timeout = -1;

        if ((pollresult = DoPoll(devpoll, &pollset)) == -1)
        {
            printf("Error w/ the polling: %s(%d)\n", strerror(errno), errno);
            exit(0);
        }
        
        for (i = 0; i < pollresult; i++)
        {
            /* if accept then accept the conn and add it to the devpoll
             */
            if (pollset.dp_fds[i].fd == acceptFd)
            {
                fd = Accept(acceptFd);
                Add(devpoll, fd);
            }
            else
            {
                /* if a client fd then get the data and echo back
                 */ 
                procClient = ProcessClient(pollset.dp_fds[i].fd);
                if (procClient == 0)
                {
                    /* client closed conn remove it from devpoll
                     */
                    Remove(devpoll, fd);
                }
            }
        }
    }
    
}