예제 #1
0
void MainWindow::on_checkBoxConnect_toggled(bool checked)
{
  if (checked) {
    quint16 port = ui->lineEditPort->text().toUInt();
    tcpSocket = new QTcpSocket(this);
    connect(tcpSocket, SIGNAL(connected()), this, SLOT(onConnect()));
    connect(tcpSocket, SIGNAL(readyRead()), this, SLOT(onRead()));
    tcpSocket->connectToHost(ui->lineEditIp->text(), port);
  } else {
    tcpSocket->disconnect();
    disconnect(tcpSocket, SIGNAL(connected()), this, SLOT(onConnect()));
    disconnect(tcpSocket, SIGNAL(readyRead()), this, SLOT(onRead()));
    delete tcpSocket;
  }
}
예제 #2
0
int
FileAction::onOpenRead(ServerContext& ctxt, FileServer& server, handle_t **handle, const char *path)
{
	int status = 0;
	
	if (!canRead(ctxt, server, path))
	{
		return -EPERM;
	}
	*handle = ctxt.getSession().createHandle(HDL_FILE);
	TAG_HANDLE(*handle);
	_DEBUG("onOpenRead: created handle for %s", path);
	if (*handle == NULL)
	{
		return -EIO;
	}
	HANDLE_PATH(**handle) = path;
	(*handle)->h_special_data = true;
	(*handle)->h_action = this;
	status = onRead(ctxt, server, translate(path).c_str(), HANDLE_CONTENTS(**handle));
	if (status >= 0)
	{
		status = 0;
		(*handle)->h_count = status;
	}
	return status;
}
예제 #3
0
void TcpGateDialog::InitConnect()
{
	m_ndConnect.group = ui->gbConnect;
	m_ndConnect.cbIp = ui->cbCIP;
	m_ndConnect.spinPort = ui->spinCPort;
	m_ndConnect.lnSend = ui->lnCSendBytes;
	m_ndConnect.lnRecv = ui->lnCRecvBytes;
	m_ndConnect.leStatus = ui->leCStatus;
	m_ndConnect.btnStart = ui->btnConnect;	
	connect(m_ndConnect.btnStart, SIGNAL(clicked()), this, SLOT(onClkBtnConnect()));
		
	m_ndConnect.bConnected = false;
	m_ndConnect.bStarted = false;
	m_ndConnect.nSendBytes = 0;
	m_ndConnect.nRecvBytes = 0;	
	QSettings setting;
	m_ndConnect.latestIpList = setting.value("TcpGateTest/Connect/LatestIP", "").toStringList();
	int nCount = m_ndConnect.latestIpList.count();
	for (int i = nCount-1; i >= 0; i--)
	{
		if (!m_ndConnect.latestIpList[i].isEmpty())
		{
			m_ndConnect.cbIp->addItem(m_ndConnect.latestIpList[i]);
		}
	}
	
	m_ndConnect.tcpServer = NULL;	
	m_ndConnect.tcpSocket = new QTcpSocket(this);
	m_ndConnect.spinPort->setValue(setting.value("TcpGateTest/Connect/LatestPort", 5100).toInt());	
	connect(m_ndConnect.tcpSocket, SIGNAL(connected()), this, SLOT(onConnected()));
	connect(m_ndConnect.tcpSocket, SIGNAL(disconnected()), this, SLOT(onDisConnected()));
	connect(m_ndConnect.tcpSocket, SIGNAL(readyRead()), this, SLOT(onRead()));
	connect(m_ndConnect.tcpSocket, SIGNAL(error(QAbstractSocket::SocketError)),
		this, SLOT(onNdcError(QAbstractSocket::SocketError)));
}
예제 #4
0
void http_session::do_read()
{
    std::weak_ptr<http_session> wp(shared_Derived_from_this<http_session>());
    //开始异步读取
    socket_->async_read_some(boost::asio::buffer(data_ + pos_, max_length - pos_),
        [wp](const boost::system::error_code &ec, std::size_t length){

        auto sp(wp.lock());
        if (sp)
        {
            sp->onRead(ec, length);
        }
    });
}
예제 #5
0
ZTPManager::ZTPManager(quint16 port,
           QHostAddress groupAddress, QObject *parent):
    QObject(parent)
{
    _Socketlistener.bind(QHostAddress::Any,port,QUdpSocket::ShareAddress);
    if(groupAddress.toIPv4Address()>0xe0000000 && groupAddress.toIPv4Address()<0xf0000000)
    {
        _Socketlistener.joinMulticastGroup(groupAddress);
        //_Socketlistener.setSocketOption(QAbstractSocket::MulticastTtlOption, 5);
    }
    connect(&_Socketlistener,SIGNAL(readyRead()),this,SLOT(onRead()),Qt::AutoConnection);
    MTU = 60000;
    _timeout = 3000;

}
예제 #6
0
파일: Client.cpp 프로젝트: o-g-r-e/Rooms
void Client::onSocketStateChanged(QAbstractSocket::SocketState socketState)
{
	//qDebug() << "client: socket state" << socketState;
	ClientRoom* room = (ClientRoom*)sender();
	switch (socketState)
	{
	case QAbstractSocket::ConnectedState:
		rooms.insert(room->getName(), room);
		this->sendMessage(room->getSocket(), instMessage(nickName, room->getName(), MessageType::CONNECT_TO_ROOM));
		connect(room->getSocket(), SIGNAL(readyRead()), this, SLOT(onRead()));
		break;
	case QAbstractSocket::UnconnectedState:
		emit addNewMessage("{System}: Room offline", room->getName());
		break;
	}
}
예제 #7
0
void TcpGateDialog::onNewConnection()
{
	if(m_ndListen.tcpSocket)
	{
		m_ndListen.tcpSocket->close();
		delete m_ndListen.tcpSocket;
	}
	
	m_ndListen.tcpSocket = m_ndListen.tcpServer->nextPendingConnection();
	connect(m_ndListen.tcpSocket, SIGNAL(disconnected()), this, SLOT(onDisConnected()));
	connect(m_ndListen.tcpSocket, SIGNAL(readyRead()), this, SLOT(onRead()));
	connect(m_ndListen.tcpSocket, SIGNAL(error(QAbstractSocket::SocketError)),
		this, SLOT(onError(QAbstractSocket::SocketError)));
	
	Log2Main(tr("receive new connect%1:%2").arg(m_ndListen.tcpSocket->peerAddress().toString()).arg(m_ndListen.tcpSocket->peerPort()));
	
	m_ndListen.bConnected = true;
}
void NuCachedSource2::onMessageReceived(const sp<AMessage> &msg) {
    switch (msg->what()) {
        case kWhatFetchMore:
        {
            onFetch();
            break;
        }

        case kWhatRead:
        {
            onRead(msg);
            break;
        }

        default:
            TRESPASS();
    }
}
예제 #9
0
int ExtConn::onError()
{
    int error = errno;
    int ret = getSockError(&error);
    if ((ret == -1) || (error != 0))
    {
        if (ret != -1)
            errno = error;
    }
    LS_DBG_L(this, "ExtConn::onError()");
    if (error != 0)
    {
        m_iState = CLOSING;
        doError(error);
    }
    else
        onRead();
    return LS_FAIL;
}
예제 #10
0
int EdStream::handleEvents(short event)
{
    int ret = 0;
    LS_DBG_L("EdStream::handleEvent(), fd: %d, event: %hd", getfd(), event);
    if (event & POLLIN)
    {
        ret = onRead();
        if (!getAssignedRevent())
            goto EVENT_DONE;
    }
    if (event & POLLHUP)
    {
        if ((ret != -1) || (getHupCounter() > 50))
            ret = onHangup();
        else if (getHupCounter() > 100)
            abort();
        if (!getAssignedRevent())
            goto EVENT_DONE;
    }
    if ((ret != -1) && (event & POLLHUP))
    {
        ret = onHangup();
        if (!getAssignedRevent())
            return 0;
    }
    if ((ret != -1) && (event & POLLOUT))
    {
        ret = onWrite();
        if (!getAssignedRevent())
            goto EVENT_DONE;
    }
    if ((ret != -1) && (event & POLLERR))
    {
        ret = onError();
        if (!getAssignedRevent())
            return 0;
    }
EVENT_DONE:    
    if (ret != -1)
        onEventDone(event);
    return 0;
}
예제 #11
0
 void WsConnection::onConnEvent(const ConnectionPtr_t& conn, ConnEvent event, const void* context)
 {
     switch(event)
     {
         case Conn_ReadEvent:
             {
                 const StackBuffer* buffer = (const StackBuffer*)context;
                 onRead(conn, buffer->buffer, buffer->count);
             }
             break;    
         case Conn_WriteCompleteEvent:
             {
                 m_sendCallback();
                 m_sendCallback = std::bind(&dummyCallback);    
             }
             break;
         default:
             break;
     }
 }
예제 #12
0
void ZTPManager::commonInit(const QHostAddress& groupAddress)
{
    #if QT_VERSION < QT_VERSION_CHECK(5,0,0)
    QThreadPool::globalInstance()->setMaxThreadCount(QThreadPool::globalInstance()->maxThreadCount()+1);
    #endif
    ztpThreadPool = new QThreadPool;
    ztpThreadPool->setMaxThreadCount(1);
    if(groupAddress.toIPv4Address()>0xe0000000 && groupAddress.toIPv4Address()<0xf0000000)
    {
        _Socketlistener.joinMulticastGroup(groupAddress);
        //_Socketlistener.setSocketOption(QAbstractSocket::MulticastTtlOption, 5);
    }
    connect(&_Socketlistener,SIGNAL(readyRead()),this,SLOT(onRead()),Qt::DirectConnection);
    MTU = 60000;
    _timeout = 3000;

    moveToThread(&ztpTask);
    connect(this,SIGNAL(registTask(const QByteArray &,const QString &,quint16)),this,
            SLOT(procPkg(const QByteArray &,const QString &,quint16)),Qt::QueuedConnection);
}
/*!
  Creates and connects server and its signals
*/
void WlanConnection::startServer()
{
    if (!mServer) {
        mServer = new WlanServer(this);

        QObject::connect(mServer, SIGNAL(read(QByteArray)),
                         this, SLOT(onRead(QByteArray)));
        QObject::connect(mServer, SIGNAL(clientConnected(QString)),
                         this, SLOT(onClientConnected(QString)));
        QObject::connect(mServer, SIGNAL(clientDisconnected(int)),
                         this, SLOT(onClientDisconnected(int)));
        QObject::connect(mServer, SIGNAL(reconnectToNetwork()),
                         this, SLOT(onReconnect()));
        QObject::connect(mServer, SIGNAL(socketError(int)),
                         this, SLOT(onSocketError(int)));

        WlanNetworkMgr& mgr = Network::networkManager();
        QObject::connect(&mgr, SIGNAL(stateChanged(QNetworkSession::State)),
                         mServer, SLOT(onNetworkStateChanged(QNetworkSession::State)));
        QObject::connect(&mgr, SIGNAL(ipChanged(QString)),
                         mServer, SLOT(onIpChanged(QString)));

    }
void StemmedFileProcessingDialog::processFiles(const QString &inFile, const QString &outFile)
{
    ui->cbxReading->setText(ui->cbxReading->text() + " " + inFile);
    ui->cbxWriting->setText(ui->cbxWriting->text() + " " + outFile);
    this->in = inFile;
    this->out = outFile;

    QThread* t = new QThread(this);
    StemmedFileParserController* controller = new StemmedFileParserController(this);
    controller->moveToThread(t);
    t->start();
    QObject::connect(this, SIGNAL(read(QString)), controller, SLOT(onRead(QString)), Qt::QueuedConnection);
    QObject::connect(this, SIGNAL(process()), controller, SLOT(onProcess()), Qt::QueuedConnection);
    QObject::connect(this, SIGNAL(write(QString)), controller, SLOT(onWrite(QString)), Qt::QueuedConnection);
    QObject::connect(this, SIGNAL(generateHistograms(QString)), controller, SLOT(onGenerateHistograms(QString)), Qt::QueuedConnection);
    QObject::connect(controller, SIGNAL(readDone(bool)), this, SLOT(onReadDone(bool)), Qt::QueuedConnection);
    QObject::connect(controller, SIGNAL(processDone()), this, SLOT(onProcessDone()), Qt::QueuedConnection);
    QObject::connect(controller, SIGNAL(writeDone(bool)), this, SLOT(onWriteDone(bool)), Qt::QueuedConnection);
    QObject::connect(controller, SIGNAL(generateHistogramsDone(bool, QString)), this, SLOT(onGenerateHistogramsDone(bool, QString)), Qt::QueuedConnection);
    emit read(this->in);

    this->show();
}
예제 #15
0
int SkSocket::readPacket(void (*onRead)(int, const void*, size_t, DataType,
                                        void*), void* context) {
    if (!fConnected || !fReady || NULL == onRead || NULL == context
        || fReadSuspended)
        return -1;

    int totalBytesRead = 0;

    char packet[PACKET_SIZE];
    for (int i = 0; i <= fMaxfd; ++i) {
        if (!FD_ISSET (i, &fMasterSet))
            continue;

        memset(packet, 0, PACKET_SIZE);
        SkDynamicMemoryWStream stream;
        int attempts = 0;
        bool failure = false;
        int bytesReadInTransfer = 0;
        int bytesReadInPacket = 0;
        header h;
        h.done = false;
        h.bytes = 0;
        while (!h.done && fConnected && !failure) {
            int retval = read(i, packet + bytesReadInPacket,
                              PACKET_SIZE - bytesReadInPacket);

            ++attempts;
            if (retval < 0) {
#ifdef NONBLOCKING_SOCKETS
                if (errno == EWOULDBLOCK || errno == EAGAIN) {
                    if (bytesReadInPacket > 0 || bytesReadInTransfer > 0)
                        continue; //incomplete packet or frame, keep tring
                    else
                        break; //nothing to read
                }
#endif
                //SkDebugf("Read() failed with error: %s\n", strerror(errno));
                failure = true;
                break;
            }

            if (retval == 0) {
                //SkDebugf("Peer closed connection or connection failed\n");
                failure = true;
                break;
            }

            SkASSERT(retval > 0);
            bytesReadInPacket += retval;
            if (bytesReadInPacket < PACKET_SIZE) {
                //SkDebugf("Read %d/%d\n", bytesReadInPacket, PACKET_SIZE);
                continue; //incomplete packet, keep trying
            }

            SkASSERT((bytesReadInPacket == PACKET_SIZE) && !failure);
            memcpy(&h.done, packet, sizeof(bool));
            memcpy(&h.bytes, packet + sizeof(bool), sizeof(int));
            memcpy(&h.type, packet + sizeof(bool) + sizeof(int), sizeof(DataType));
            if (h.bytes > CONTENT_SIZE || h.bytes <= 0) {
                //SkDebugf("bad packet\n");
                failure = true;
                break;
            }
            //SkDebugf("read packet(done:%d, bytes:%d) from fd:%d in %d tries\n",
            //         h.done, h.bytes, fSockfd, attempts);
            stream.write(packet + HEADER_SIZE, h.bytes);
            bytesReadInPacket = 0;
            attempts = 0;
            bytesReadInTransfer += h.bytes;
        }

        if (failure) {
            onRead(i, NULL, 0, h.type, context);
            this->onFailedConnection(i);
            continue;
        }

        if (bytesReadInTransfer > 0) {
            SkData* data = stream.copyToData();
            SkASSERT(data->size() == bytesReadInTransfer);
            onRead(i, data->data(), data->size(), h.type, context);
            data->unref();

            totalBytesRead += bytesReadInTransfer;
        }
    }
    return totalBytesRead;
}
예제 #16
0
void Conn::setupReadHandler() {
	onRead( boost::system::error_code(), std::make_shared< boost::asio::streambuf >() );
}
예제 #17
0
bool  TCPNetwork::init()
{
  QObject::connect(&_sock, SIGNAL(readyRead()), this, SLOT(onRead()));
  QObject::connect(&_sock, SIGNAL(disconnected()), this, SLOT(on_disconnect()));
  return (true);
}
예제 #18
0
파일: movieWatcher.c 프로젝트: beantaxi/dev
int main ()
{
	int rc;		// generic return code from various functions
	
	const char* configFile = "movieWatcher.ini";
	config cfg;
	rc = ini_parse(configFile, configHandler, &cfg);
	if (rc < 0)
	{
		perror("Error on ini_parse()");
		exit(EXIT_FAILURE);
	}


	// Watch for movie file being created
	int fd = inotify_init();
	if (fd == -1)
	{
		perror("Error with inotify_init()");
		exit(EXIT_FAILURE);
	}
	
	printf("watchedPath=%s\n", cfg.watchedPath);
	int wd = inotify_add_watch(fd, cfg.watchedPath, IN_CREATE | IN_MODIFY);
	if (wd == -1)
	{
		perror("Error with inotify_add_watch()");
		exit(EXIT_FAILURE);
	}

	while (1)
	{
		// poll until there is something left to read.
		// This is necessary because we will be reading a variable number of bytes
			// (eg the name of the file)
		struct pollfd pfd;
		pfd.fd = fd;
		pfd.events = POLLIN;
		rc = poll(&pfd, 1, -1);
		if (rc == -1)
		{
			perror("Error with poll()");
			exit(EXIT_FAILURE);
		}

		// Since there is something to read, get the byte count
		int nToRead;
		rc = ioctl(pfd.fd, FIONREAD, &nToRead);
		if (rc == -1)
		{
			perror("Error with ioctl()");
			exit(EXIT_FAILURE);
		}
		
		onRead(pfd.fd, nToRead, &cfg);
	}	

	rc = inotify_rm_watch(fd, wd);
	if (rc == -1)
	{
		perror("Error with inotify_add_watch");
		exit(EXIT_FAILURE);
	}
	
	close(fd);
}