精华内容
下载资源
问答
  • //服务器实例 class LittleServer : public QMainWindow { Q_OBJECT public: LittleServer(void); virtual ~LittleServer(void); public: QUdpSocket *UdpSender;//udp套接字器 QTcpSocket *TcpReciever;//...
    //服务器实例
    class LittleServer :
    	public QMainWindow
    {
    	Q_OBJECT
    public:
    	LittleServer(void);
    	virtual ~LittleServer(void);
    
    public: 
     QUdpSocket *UdpSender;//udp套接字器
    QTcpSocket *TcpReciever;//tcp套接字器
    QTcpServer* m_TcpServer;//tcp服务器
    	QWidget* m_CentralWidget;//中心窗体
    	QByteArray datagram;//数据 
    	QLabel* m_Label;
    	QLineEdit* m_LineEdit;
    	QPushButton* m_SendButton;
    	public slots:
    		void slot_Send();
    		void acceptConnection();
            public:	
    		void readClient();
    	
    };
    
    //cpp实现
    LittleServer::LittleServer(void)
    {
    	m_TcpServer=new QTcpServer(this);//创建服务器实例
    	TcpReciever=nullptr;//赞无接收套接字
    	m_TcpServer->listen(QHostAddress::Any, 8888);//监听端口号为8888,这里自行设计
    	connect(m_TcpServer, SIGNAL(newConnection()), this, SLOT(acceptConnection()));//当服务器发现有新的连接时,出发接受新连接函数
    	m_Label=new QLabel("",this);
    	m_CentralWidget=new QWidget(this);
    	QHBoxLayout* mainLayout=new QHBoxLayout(this);
    	m_SendButton=new QPushButton("发送",this);
    	m_LineEdit=new QLineEdit(this);
    	mainLayout->addStretch();
    	mainLayout->addWidget(m_SendButton);
            mainLayout->addWidget(m_LineEdit);
    	mainLayout->addStretch();
    	mainLayout->addWidget(m_Label);
    	this->setCentralWidget(m_CentralWidget);
    	m_CentralWidget->setLayout(mainLayout);
    	UdpSender = new QUdpSocket(this);//暂时没使用
            connect(m_SendButton,SIGNAL(clicked()),this,SLOT(slot_Send()));
    
    }
    
    
    LittleServer::~LittleServer(void)
    {
    }
    //当点击的时候发送
    void LittleServer::slot_Send()
    {
    	datagram=m_LineEdit->text().toAscii();//得到显示的数据
    	//UDP广播
    	UdpSender->writeDatagram(datagram.data(),datagram.size(),QHostAddress::Broadcast,6665);
    
    	//向特定IP发送
     	QHostAddress serverAddress = QHostAddress("192.168.20.156");
    	int Ret=UdpSender->writeDatagram(datagram.data(), datagram.size(),QHostAddress::LocalHost, 6665);
    
    	/* writeDatagram函数原型,发送成功返回字节数,否则-1
    	qint64 writeDatagram(const char *data,qint64 size,const QHostAddress &address,quint16 port)
    	qint64 writeDatagram(const QByteArray &datagram,const QHostAddress &host,quint16 port)
    	*/
    
    }
    
    void LittleServer::acceptConnection()
    {
    	//当有客户端连接到服务器的时候:就得到当前的socket,然后有数据就读取
    	//qDebug(State:%d\n”,mSocket->state()); // State: 2; 2代表ConnectingState,正确的应该为3(ConnectedState)
    	TcpReciever =m_TcpServer->nextPendingConnection();//套接字器指向该链接
    	
    	
    	connect(TcpReciever, SIGNAL(readyRead()), this, SLOT(readClient()));//当有数据来时,触发读取客户端的信息
    	QString ipCli =TcpReciever->peerAddress().toString();//链接地址   
    	qint16 portCli = TcpReciever->peerPort();//链接方端口
    	QString temp = QString("客户端:[%1:%2]:连接成功").arg(ipCli).arg(portCli);
    	ipCli=TcpReciever->localAddress().toString();
    	portCli=TcpReciever->localPort();
    	temp += QString("服务器:[%1:%2]").arg(ipCli).arg(portCli);
    	m_Label->setText(temp);//显示服务器客户端分别地址和ip
    }
    
    void LittleServer::readClient()
    {
    //将读取的客户端信息显出来
    	TcpReciever->waitForReadyRead();
    	QString str = TcpReciever->readAll();
    
    	m_Label->setText(str);
    	//或者
    	//char buf[1024];
    	//m_TcpServer->read(buf,1024);
    }
    
    class LittleClient :
    	public QMainWindow
    {
    	Q_OBJECT
    public:
    	LittleClient(void);
    	virtual ~LittleClient(void);
    	QTcpSocket* m_TcpSocket;
    	QUdpSocket *UdpReceiver;//udp
    	QWidget* m_CentralWidget;//中心窗体
    	QByteArray datagram;//接受到的数据
    	QLabel* m_Label;
    	QPushButton* m_ShowButton;
    
    	//信号槽
    	private slots:  
    		void readPendingDatagrams();
    		void sendTcp();
    		void ConnectToServerSuccessed();
    
    };
    LittleClient::LittleClient(void)
    	:UdpReceiver(new QUdpSocket(this))
    {
    
    	UdpReceiver->bind(QHostAddress::LocalHost, 6665);//绑定端口
    	connect(UdpReceiver, SIGNAL(readyRead()),this, SLOT(readPendingDatagrams()));
    	m_CentralWidget=new QWidget(this);
    	QHBoxLayout* mainLayout=new QHBoxLayout(this);
    	m_ShowButton=new QPushButton("显示",this);
    	m_Label=new QLabel("开始",this);
    
    	mainLayout->addStretch();
    	mainLayout->addWidget(m_ShowButton);
    	mainLayout->addWidget(m_Label);
    	mainLayout->addStretch();
    	this->setCentralWidget(m_CentralWidget);
    	m_CentralWidget->setLayout(mainLayout);
    	
    
    
    	m_TcpSocket=new QTcpSocket(this);
    	//m_TcpSocket->abort();
    	connect(m_TcpSocket,SIGNAL(connected()),this,SLOT(ConnectToServerSuccessed()));
    	m_TcpSocket->connectToHost(QHostAddress::LocalHost,8888);//链接服务器
    	bool isConnected=m_TcpSocket->waitForConnected();//只有使用waitForConnected()后,QTcpSocket才真正尝试连接服务器,并返回是否连接的结果。
    	//m_TcpSocket->connectToHost("192.168.20.156", 9999);//先建立链接
    	connect(m_ShowButton,SIGNAL(clicked()),this,SLOT(sendTcp()));
    	
    }
    
    
    LittleClient::~LittleClient(void)
    {
    }
    
    void LittleClient::readPendingDatagrams()
    {
       	while (UdpReceiver->hasPendingDatagrams()) {
    		datagram.resize(UdpReceiver->pendingDatagramSize());
    		UdpReceiver->readDatagram(datagram.data(), datagram.size());
    		m_Label->setText(QString(datagram));
    		//数据接收在datagram里
    		/* readDatagram 函数原型
    		qint64 readDatagram(char *data,qint64 maxSize,QHostAddress *address=0,quint16 *port=0)
    		*/
    	}
    }
    
    void LittleClient::sendTcp()
    {
    	QString str=m_Label->text();
    	//m_TcpSocket->write(str.toAscii());
    	
    	m_TcpSocket->write("12345",5);
    	//m_TcpSocket->write(str.toStdString().c_str(), strlen(str.toStdString().c_str()));
    	bool isSend=m_TcpSocket->waitForBytesWritten(); //当使用waitForBytesWritten()后,QTcpSocket才真正发送数据。 
    }
    
    void LittleClient::ConnectToServerSuccessed()
    {
    	
    	m_Label->setText(QString("服务器:[%1:%2 客户端:%3:%4]").arg(m_TcpSocket->peerAddress().toString()).arg(m_TcpSocket->peerPort()).arg(m_TcpSocket->localAddress().toString()).arg(m_TcpSocket->localPort()));
    
    }

    然后分别创建该littleclient实例和 littleserver实例,即可进行通讯(端口和Ip依据实际情况填写),其中tcp收发信息需要客户端和服务端先建立链接,才行,而udp发送消息则不需要理会,只管发,不管对方是否接受或者处理。

    展开全文
  • https://www.jianshu.com/p/2e408c3eaaa8 iOS UDP 简易交互 https://www.cnblogs.com/reyalPDC/p/6387190.html 转载于:https://www.cnblogs.com/-WML-/p/9493107.html

    https://www.jianshu.com/p/2e408c3eaaa8

     

    iOS UDP 简易交互

     

    https://www.cnblogs.com/reyalPDC/p/6387190.html

    转载于:https://www.cnblogs.com/-WML-/p/9493107.html

    展开全文
  • HTTP协议链接服务器进行数据收发的接口 在下乃小白程序猿一个,在之前参加的项目中负责了一个简单的数据收发接口,相当于一个中间商。以文本数据收发为例,分享一下实现方式(注释中附解释与参考) public void ...

    HTTP协议链接服务器进行数据收发的接口

    在下乃小白程序猿一个,在之前参加的项目中负责了一个简单的数据收发接口,相当于一个中间商。以文本数据收发为例,分享一下实现方式(注释中附解释与参考)

    public void methodShow(){
    	OutputStream os = null;
    	try{
    	String sendText="发送的文本";
    	//这里是要链接的服务器的地址(可能也会有mapping什么的)
    	URL url= new URL("http://localhost:8080"); 
    	//建立HTTP链接
    	HttpURLConnection connection=(HttpURLConnection )url.openConnection()
    	//因为要进行数据的收发,所以以下两项设为true
    	connection.setDoOutput(true);
        connection.setDoInput(true);
        connection.setRequestMethod("POST")
        // Post 请求不能使用缓存   
        //connection.setUseCaches(false); 
        /*
        *接下来是设置connection的参数  相当于请求体中的各种内容,前面是名称,后面是参数,名称可以自定义
    	*/
    	connection.setRequestProperty("Content-Type", ”text/plain;charset=utf-8);
        connection.setRequestProperty("Connection", ”Keep-Alive");
        connection.setRequestProperty("Host","localhost:8080"); 
    	connection.setRequestProperty("content","要发送的文本"getBytes(StandardCharsets.UTF_8)); //发文本数据可以这么发,注意指定编码格式,这种方式不推荐
     	//如果需要,还可以再加一些参数
    	//下面是设置超时时间
     	connection.setConnectTimeout(3000)//设置链接时超时的时间(连上服务器到收到服务器返回数据),单位为毫秒
     	connection.setReadTimeout(3000)//设置读取时超时的时间,单位为毫秒
     	connection.connect();		//执行链接
        os = connection.getOutputStream();
        os.write(sendText.getBytes(StandardCharsets.UTF_8));//向服务器发送
        os.flush();		//冲出
        os.close();
    	if (connection.getResponseCode() == 200) {		//通常200是处理正常的时候,然后进行后续操作
    	InputStreamReader inputStream = new InputStreamReader(connection.getInputStream(),
                  StandardCharsets.UTF_8);
        reader = new BufferedReader(inputStream);
        String retData = null;
        StringBuffer strBuffer = new StringBuffer();  //用来存储数据
        /*
        *readLine如果遇到“\r\n”就会认为是下一行,如果服务器返回的有这种情况,就用fistFlag 来判断一下
        *最好用byte数组来进行读取
        *
        */
        boolean fistFlag = true;								
        while ((retData = reader.readLine()) != null) {
          if (fistFlag == false) {
             strBuffer.append("\r\n");     
            }
        strBuffer.append(retData);
        fistFlag = false;
        }
        String endText= strBuffer.toString();
        System..out.Println(endText);
    }catch (Exception e) {
    	
    	}finally{
    	os.close();
    	reader.close();
    }
    }
    
    展开全文
  • 游戏服务器数据收发缓存

    千次阅读 2014-01-16 22:41:35
    游戏服务器 的一些数据接收处理,处理的是接收和发送的数据包队列,以客户端发送到逻辑服务器和逻辑服务器发送到数据服务器为例,来讨论一下底层的一些对网络数据接收的处理。 (代码是以一个手游服务器的代码为例)...

    游戏服务器  的一些数据接收处理,处理的是接收和发送的数据包队列。

    以客户端发送到逻辑服务器和逻辑服务器发送到数据服务器为例,

    以一个手游服务器的代码为例,来看下底层的一些对网络数据接收的处理。


    以逻辑服务器连接数据服务器(服务器之间的连接)为例。

    1、网络线程例程

    2、接收数据

    (1)网络接收数据到接收缓存

    (2)拷贝和粘包到处理缓存

    3、发送数据

    (1)发送缓存区数据到队列

     (2)网络socket发送


    1、网络线程例程

    CDBManager这个是逻辑服务器作为客户端连接到数据服务器的自定义socket连接类,是个线程类,处理角色数据的存取档。

    //例行函数

    void CDBManager::SingleRun()//每次逻辑循环的例行逻辑处理函数
    {
    if (m_boStarted)
    {
    super::SingleRun();//自定义socket的例行处理(开始时连接过去,发送心跳包,收发数据)
    ProcessLoadPlayerData();//处理加载角色数据(1、处理接收数据)
    ProcessSavePlayerData();//处理保存角色数据(2、处理发送数据)
    }
    }

    开始时连接过去,发送心跳包,收发数据

    VOID CCustomWorkSocket::SingleRun()
    {
    //接收数据
    if ( connected() )
    ReadSocket();//网络接收数据到接收缓存区(m_pRecvBuffer->pBuffer接收缓存区,m_pRecvBuffer->nOffset是接收到的长度)

    //处理接受到的数据包
    if ( connected() )
    ProcessRecvBuffers(m_pProcRecvBuffer);

    //调用例行函数
    OnRun();

    //发送数据
    if ( connected() && m_bSendData)
    {
    SendSocketBuffers();
    }
    }

    2、接收数据

    (1)网络接收数据到接收缓存

    VOID CCustomWorkSocket::ReadSocket()
    {
    static const int OnceRecvSize = 4096;
    int nError;
    TICKCOUNT dwCurTick = _getTickCount();

    while ( TRUE )
    {
    //增长接收缓冲区大小
    if ( m_pRecvBuffer->nSize - m_pRecvBuffer->nOffset < OnceRecvSize * 2 )
    {
    size_t nPointer = m_pRecvBuffer->pPointer - m_pRecvBuffer->pBuffer;
    m_pRecvBuffer->nSize += OnceRecvSize * 2;
    m_pRecvBuffer->pBuffer = (char*)realloc(m_pRecvBuffer->pBuffer, m_pRecvBuffer->nSize);
    m_pRecvBuffer->pPointer = m_pRecvBuffer->pBuffer + nPointer;
    }
    //从套接字读取数据
    nError = recv(&m_pRecvBuffer->pBuffer[m_pRecvBuffer->nOffset], OnceRecvSize);
    if ( nError <= 0 )
    break;

    m_pRecvBuffer->nOffset += nError;
    m_pRecvBuffer->pBuffer[m_pRecvBuffer->nOffset] = 0;
    m_dwMsgTick = dwCurTick;
    }
    }

    套接字接收数据

    INT CCustomSocket::recv(LPVOID buf, INT len, const INT flags)
    {
    int nErr = ::recv( m_nSocket, (char*)buf, len, flags );
    if ( nErr == 0 )
    {
    close();
    }
    else if ( nErr < 0 )
    {
    if ( !m_boBlock )
    {
    nErr = WSAGetLastError();
    if ( nErr != WSAEWOULDBLOCK )
    {
    SocketError( nErr );
    nErr = -1;
    }
    else nErr = SOCKET_ERROR - 1;
    }
    }


    return nErr;
    }

    (2)拷贝和粘包到处理缓存

    //逻辑服务器处理存储接收的缓存数据

    VOID CCustomSSTClientSocket::ProcessRecvBuffers(PDATABUFFER pDataBuffer)
    {
    //如果连接已断开则丢弃所有数据
    if ( !connected() )
    {
    super::ProcessRecvBuffers(pDataBuffer);对接受数据的默认处理是什么都不做,只清空数据
    SwapRecvProcessBuffers();//交换接收和处理这两个缓冲包的队列
    return;
    }

    if ( pDataBuffer->nOffset <= 0 )
    {
    SwapRecvProcessBuffers();
    return;
    }

    INT_PTR dwRemainSize;
    PNETPACKETHEADER pPackHdr;
    char* pDataEnd = pDataBuffer->pBuffer + pDataBuffer->nOffset;
    while ( TRUE )
    {
    dwRemainSize = (INT_PTR)(pDataEnd - pDataBuffer->pPointer);
    //如果缓冲区中的剩余长度小于通信协议头的长度,则交换缓冲(继续粘包)并在以后继续进行处理
    if ( dwRemainSize < (INT_PTR)sizeof(*pPackHdr) )
    {
    SwapRecvProcessBuffers();
    break;
    }

    //只有找到包头才处理,否则就一直接收和粘包(这种做法可以防止发来的无效数据,后面还是要检查包长度的)
    pPackHdr = (PNETPACKETHEADER)pDataBuffer->pPointer;
    //检查包头标志是否有效,如果包头标志无效则需要遍历数据包查找包头
    if ( pPackHdr->dwIdent != NETPACKETHEADER::NetPacketHeaderIdent )
    {
    char* sCurPtr = pDataBuffer->pPointer;
    do 
    {
    pDataBuffer->pPointer++;//一个个字节的检查,看是否有包头
    pPackHdr = (PNETPACKETHEADER)pDataBuffer->pPointer;
    //找到包头标记则终止查找
    if ( pPackHdr->dwIdent == NETPACKETHEADER::NetPacketHeaderIdent )
    break;

    while (pDataBuffer->pPointer < pDataEnd - 1);
    //如果无法查找到包头,则保留接收缓冲末尾的最后一个字符并交换接收/处理缓冲以便下次继续连接新接收的数据后重新查找包头
    if ( pPackHdr->dwIdent != NETPACKETHEADER::NetPacketHeaderIdent )
    {
    SwapRecvProcessBuffers();
    //找不到协议头标志,输出错误消息

    //协议头标志使用来校验包是否是是开始的数据,只有是开始的数据才能开始处理

    logError("来自服务器的数据包中没有包含有效的数据包头");
    break;
    }
    //输出找到包头的消息
    logWarn("在来自服务器的数据包中的包头前跳过了%d字节", 
    (int)(pDataBuffer->pPointer - sCurPtr));
    }
    //如果处理接收数据的缓冲中的剩余数据长度不足协议头中的数据长度,则交换缓冲并在下次继续处理

    //不会处理不到包头指定长度 的数据
    dwRemainSize -= sizeof(*pPackHdr);
    if ( pPackHdr->wPacketSize > dwRemainSize )//包还是没到包的应有长度,就继续粘包
    {
    SwapRecvProcessBuffers();
    break;
    }
    //将缓冲读取指针调整到下一个通信数据包的位置
    pDataBuffer->pPointer += sizeof(*pPackHdr) + pPackHdr->wPacketSize;

    //开始处理派送接到的数据
    //将通信数据段保存在packet中
    CDataPacketReader packet(pPackHdr + 1, pPackHdr->wPacketSize);
    //分派数据包处理(对db发来的这个数据包,在派送后就是直接处理的了)
    DispatchRecvPacket(packet);
    }
    }

    拷贝数据并粘包

    VOID CCustomWorkSocket::SwapRecvProcessBuffers()
    {
    INT_PTR dwSize;
    //m_pRecvBuffer 是接收到的数据,m_pProcRecvBuffer是粘包后的数据,m_pProcRecvBuffer->nOffset 是数据包总长度
    //数据包处理完毕
    dwSize = (int)(m_pProcRecvBuffer->pPointer - m_pProcRecvBuffer->pBuffer);
    if ( dwSize >= m_pProcRecvBuffer->nOffset )
    {
    PDATABUFFER pDataBuffer = m_pProcRecvBuffer;
    m_pProcRecvBuffer = m_pRecvBuffer;
    m_pRecvBuffer = pDataBuffer;

    m_pProcRecvBuffer->pPointer = m_pProcRecvBuffer->pBuffer;
    m_pRecvBuffer->pPointer = m_pRecvBuffer->pBuffer;
    m_pRecvBuffer->nOffset = 0;
    }
    //有新的数据
    else if ( m_pRecvBuffer->nOffset > 0 )
    {
    //将剩余数据移动到头部
    dwSize = m_pProcRecvBuffer->nOffset - (INT_PTR)(m_pProcRecvBuffer->pPointer - m_pProcRecvBuffer->pBuffer);
    if ( m_pProcRecvBuffer->pPointer > m_pProcRecvBuffer->pBuffer )
    {
    memcpy(m_pProcRecvBuffer->pBuffer, m_pProcRecvBuffer->pPointer, dwSize);
    m_pProcRecvBuffer->nOffset = dwSize;
    m_pProcRecvBuffer->pBuffer[m_pProcRecvBuffer->nOffset] = 0;
    }
    //拷贝新数据
    if ( m_pProcRecvBuffer->nSize <= m_pRecvBuffer->nOffset + m_pProcRecvBuffer->nOffset )
    {
    m_pProcRecvBuffer->nSize += __max(8192, m_pRecvBuffer->nOffset + 1);
    m_pProcRecvBuffer->pBuffer = (char*)realloc(m_pProcRecvBuffer->pBuffer, m_pProcRecvBuffer->nSize);
    }
    memcpy(&m_pProcRecvBuffer->pBuffer[m_pProcRecvBuffer->nOffset], m_pRecvBuffer->pBuffer, m_pRecvBuffer->nOffset);
    m_pProcRecvBuffer->nOffset += m_pRecvBuffer->nOffset;
    m_pProcRecvBuffer->pBuffer[m_pProcRecvBuffer->nOffset] = 0;
    m_pProcRecvBuffer->pPointer = m_pProcRecvBuffer->pBuffer;


    m_pRecvBuffer->nOffset = 0;
    m_pRecvBuffer->pPointer = m_pRecvBuffer->pBuffer;
    }
    }

    3、发送数据

    (1)把追加数据队列的发送包添加到发送队列队列

    逻辑线程提交包都是提交到追加数据队列,发送前会把追加队列里的数据包添加到发送队列,发送完之后就把发送队列的数据包放到空闲队列准备以后再次发送时使用


    //数据buffer的发送(发送队列处理)

    VOID CCustomWorkSocket::SendSocketBuffers()
    {
    if ( sendToSocket(*this) > 0 )
    {
    m_dwMsgTick = _getTickCount();//记录发送的时间
    }
    }


    //从发送包队列里获取发送包并循环发送,直到连接关闭或者当前包没有发送完

    //逻辑线程提交的发送包都是提交到发送队列里的追加队列,m_SendingPacketList.flush()会把追加队列里的数据包添加到发送队列(追加时需要加锁)

    //网络发送完之后就到空闲队列准备以后再次发送时获取空的内存数据包(包的内存池)

    size_t CSendPacketPool::sendToSocket(CCustomSocket& socket)
    {
    INT_PTR nCount, nAvalLength, nBytesWriten;
    CDataPacket **pPacketList, *pPacket;
    size_t nTotalSent = 0;

    //提交追加到发送队列中的数据包(会加锁)
    m_SendingPacketList.flush();

    //循环发送数据包
    pPacketList = m_SendingPacketList;
    nCount = m_SendingPacketList.count();
    for (; m_nSendingPacketIdx<nCount; ++m_nSendingPacketIdx)
    {
    pPacket = pPacketList[m_nSendingPacketIdx];
    nAvalLength = pPacket->getAvaliableLength();
    if (nAvalLength > 0)
    {
    //网络发送数据
    nBytesWriten = socket.send(pPacket->getOffsetPtr(), (INT)nAvalLength);
    if ( nBytesWriten <= 0 )
    break;
    }
    else nBytesWriten = 0;
    nTotalSent += nBytesWriten;
    //该数据包中的数据是否已经发完
    if (nBytesWriten >= nAvalLength)
    {
    //清空数据包的数据长度
    pPacket->setLength(0);
    }
    else
    {
    //调整偏移到下次继续发送的位置(因为使用的是非阻塞socket发送,tcp发送要是网络阻塞就立刻返回)
    pPacket->adjustOffset(nBytesWriten);
    break;//发送时
    }
    }
    //如果发送队列中的数据已经全部发送完毕,则将数据包全部移动到空闲数据包列表中
    if ( m_nSendingPacketIdx >= nCount )
    {
    m_nSendingPacketIdx = 0;
    m_FreeSendPackList.lock();
    m_FreeSendPackList.addArray(m_SendingPacketList, m_SendingPacketList.count());
    m_SendingPacketList.trunc(0);
    m_FreeSendPackList.unlock();
    }
    return nTotalSent;
    }

     (2)网络socket发送

    INT CCustomSocket::send(LPVOID buf, INT len, const INT flags)
    {
    int nRet, nErr;
    char *ptr = (char*)buf;

    nRet = 0;
    while ( len > 0 )
    {
    nErr = ::send( m_nSocket, (char*)ptr, len, flags );
    if ( nErr == 0 )
    {
    nRet = 0;
    close();
    break;
    }
    else if ( nErr < 0 )
    {
    if ( !m_boBlock )
    {
    nErr = WSAGetLastError();
    if ( nErr != WSAEWOULDBLOCK )
    {
    nRet = SOCKET_ERROR;
    SocketError( WSAGetLastError() );
    }
    else if ( nRet == 0 )
    {
    nRet = SOCKET_ERROR - 1;
    }
    }
    break;
    }
    else 
    {
    nRet += nErr;
    ptr += nErr;
    len -= nErr;
    }
    }
    return nRet;
    }

     

    展开全文
  • 我们开发通信的时候,客户的明明把数据发送出去了,而服务端就是没接收到,或是收发数据不稳定,有时能收到,有时不能收到, 这个时候有3种可能:  1、客户端的问题,数据发送有问题  2、服务端的问题,数据接收有...
  • 主要介绍了PHP向socket服务器收发数据的方法,分析了socket收发数据的方法,并介绍了socket常用函数,需要的朋友可以参考下
  • STM32F107以太网TCP服务器收发数据实验
  • 这种情况下是否会出现冲突的情况,客户端无法判断优先从哪个端口接收数据? 如果会有冲突,那么应该采用何种方式解决这种客户端同时接收到文件的情况? 部分代码如下 private void Form1_Load(object sender...
  • 简单的搭建一个服务器server:import socketsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.bind(('localhost', 9401)) sock.listen(15) connection,address = sock.acept()while True: try:
  • PHP中向socket服务器收发数据

    千次阅读 2016-12-21 15:22:28
    /*socket收发数据 @host(string) socket服务器IP @post(int) 端口 @str(string) 要发送的数据 @back 1|0 socket端是否有数据返回 返回true|false|服务端数据 */ function sendSocketMsg($host,$port,$str,$back...
  • STM32F107以太网UDP服务器收发数据实验
  • STM32F107以太网TCP服务器收发数据实验
  • 服务器端的Socket编程
  • 为了方便从网上直接购买了一个带有esp8266的开发板 ... //给web浏览器时间来接收数据 // close the connection: client.stop(); Serial.println("[Client disonnected]"); } } 就是这样 直连WIFI
  • 1. 服务端接收 1.1 通过HttpServletRequest request获取json信息 String param= null; try { BufferedReader streamReader = new BufferedReader( new InputStreamReader(request.getInputStream(), ...
  • 服务器(server.py) # -*- coding: UTF-8 -*- import socket import sys import os class server: def __init__(self, ip, port): self.port = port self.ip = ip self.bufferSize = 102...
  • DNS服务器 尽管浏览器能够解析网址并生成 HTTP 消息,但它本身并不具备将消息发送到网络中的功能,因此这一功能需要委托操作系统来实现 。在委托操作系统发送消息时,必须要提供的不是通信对象的域名,而是它的 IP ...
  • 用mina做数据收发服务器 最近要用java做个数据处理接口程序。用socket通讯,所以想到了用mina来做服务器端。不多说直接上代码。 首先导入所需jar包 初始化mina服务类 import org.apache.mina.core....
  • 本文在官方所给例子的基础上实现ESP8266与MQTT服务器之间收发数据。 有关MQTT服务器的搭建可以参考: 《MQTT服务器Mosquitto 2.x编译安装配置》 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,026
精华内容 810
关键字:

服务器数据收发