ecostestsocket.cpp

ecos为实时嵌入式操作系统

    while((nTodo>0) && ((0==pFnStop) || (!pFnStop(pParam)))){
        int s=bSend?::send(m_nSock, c, nTodo, 0): ::recv(m_nSock, c, nTodo, 0);
        if(0==s && !bSend){
            m_nErr=ERR_READ_AFTER_CLOSE;
        } else {
            SaveError();
        }
        if(-1==s && WOULDBLOCK==SocketError()){
            CeCosTestUtils::Duration d=CeCosTestUtils::Time::Now()-ft0;
            if(d>dTimeout){
				TRACE("%d/%d mSec timeout on socket %d %s %s - processed %d/%d bytes\n" ,
                    d,dTimeout,m_nSock,pszSR,pszMsg, 
                    nLength-nTodo,nLength);
                m_nErr=ERR_TIMEOUT;
				break;
			}
            CeCosTestUtils::Sleep(100);
       } else if (s>0) {
			c+=s;
			nTodo-=s;
            ft0=CeCosTestUtils::Time::Now();
        } else {
			TRACE("Error on socket %d %s %s - %s\n" ,m_nSock, pszSR, pszMsg, (const char *)SocketErrString());
			break;
		}
    }
//TRACE("Done %s %s rc=%d\n",pszSR,pszMsg,0==nTodo);
    return 0==nTodo;
}

// Graceful socket closedown
CeCosTestSocket::~CeCosTestSocket()
{
	CloseSocket(m_nSock);
}

bool CeCosTestSocket::CloseSocket(int &sock)
{
    if(-1!=sock){
TRACE("Closing socket %d\n",sock);
        shutdown(sock,0);// SD_BOTH
#ifdef _WIN32
        closesocket(sock);
#else
        close(sock);
#endif
        sock=-1;
    }
	return true;
}

bool CeCosTestSocket::SetSocketOptions()
{
    bool rc;
	#ifdef _WIN32
    int nTrue=1;
    rc=(0==::ioctlsocket(m_nSock, FIONBIO, (unsigned long *)&nTrue));
    SaveError();
	#else
    int flags=::fcntl(m_nSock,F_GETFL);
    SaveError();
	flags|=O_NONBLOCK;
    rc=(0==::fcntl (m_nSock, F_SETFL, flags));
    SaveError();
	#endif
    //LINGER linger;
    //setsockopt(m_nSock,SOL_SOCKET,SO_LINGER,(const char *)linger, sizeof(LINGER));
	if(!rc){
        TRACE("Failed to set socket options socket %d - %s\n",m_nSock,(const char *)SocketErrString());
    }
TRACE("SetSocketOptions %d rc=%d\n",m_nSock,rc);
    return rc;
}

CeCosTestUtils::String CeCosTestSocket::SocketErrString()
{
    CeCosTestUtils::String str;
    int nErr;
    #ifdef _WIN32
    nErr=WSAGetLastError();
    switch(nErr){
        case ERR_TIMEOUT: str="Read operation timed out";break;
        case ERR_READ_AFTER_CLOSE: str="Read operation after socket closed";break;

        case WSAEACCES: str="Permission denied";break;
        case WSAEADDRINUSE: str="Address already in use";break;
        case WSAEADDRNOTAVAIL: str="Cannot assign requested address";break;
        case WSAEAFNOSUPPORT: str="Address family not supported by protocol family";break;
        case WSAEALREADY: str="Operation already in progress";break;
        case WSAECONNABORTED: str="Software caused connection abort";break;
        case WSAECONNREFUSED: str="Connection refused";break;
        case WSAECONNRESET: str="Connection reset by peer";break;
        case WSAEDESTADDRREQ: str="Destination address required";break;
        case WSAEFAULT: str="Bad address";break;
        case WSAEHOSTDOWN: str="Host is down";break;
        case WSAEHOSTUNREACH: str="No route to host";break;
        case WSAEINPROGRESS: str="Operation now in progress";break;
        case WSAEINTR: str="Interrupted function call";break;
        case WSAEINVAL: str="Invalid argument";break;
        case WSAEISCONN: str="Socket is already connected";break;
        case WSAEMFILE: str="Too many open files";break;
        case WSAEMSGSIZE: str="Message too long";break;
        case WSAENETDOWN: str="Network is down";break;
        case WSAENETRESET: str="Network dropped connection on reset";break;
        case WSAENETUNREACH: str="Network is unreachable";break;
        case WSAENOBUFS: str="No buffer space available";break;
        case WSAENOPROTOOPT: str="Bad protocol option";break;
        case WSAENOTCONN: str="Socket is not connected";break;
        case WSAENOTSOCK: str="Socket operation on non-socket";break;
        case WSAEOPNOTSUPP: str="Operation not supported";break;
        case WSAEPFNOSUPPORT: str="Protocol family not supported";break;
        case WSAEPROCLIM: str="Too many processes";break;
        case WSAEPROTONOSUPPORT: str="Protocol not supported";break;
        case WSAEPROTOTYPE: str="Protocol wrong type for socket";break;
        case WSAESHUTDOWN: str="Cannot send after socket shutdown";break;
        case WSAESOCKTNOSUPPORT: str="Socket type not supported";break;
        case WSAETIMEDOUT: str="Connection timed out";break;
        case WSATYPE_NOT_FOUND: str="Class type not found";break;
        case WSAEWOULDBLOCK: str="Resource temporarily unavailable";break;
        case WSAHOST_NOT_FOUND: str="Host not found";break;
        case WSA_INVALID_HANDLE: str="Specified event object handle is invalid";break;
        case WSA_INVALID_PARAMETER: str="One or more parameters are invalid";break;
        //case WSAINVALIDPROCTABLE: str="Invalid procedure table from service provider";break;
        //case WSAINVALIDPROVIDER: str="Invalid service provider version number";break;
        case WSA_IO_INCOMPLETE: str="Overlapped I/O event object not in signaled state";break;
        case WSA_IO_PENDING: str="Overlapped operations will complete later";break;
        case WSA_NOT_ENOUGH_MEMORY: str="Insufficient memory available";break;
        case WSANOTINITIALISED: str="Successful case WSAStartup not yet:performed";break;
        case WSANO_DATA: str="Valid name, no data record of requested type";break;
        case WSANO_RECOVERY: str="This is a non-recoverable error";break;
        //case WSAPROVIDERFAILEDINIT: str="Unable to initialize a service provider";break;
        case WSASYSCALLFAILURE: str="System call failure";break;
        case WSASYSNOTREADY: str="Network subsystem is unavailable";break;
        case WSATRY_AGAIN: str="Non-authoritative host not found";break;
        case WSAVERNOTSUPPORTED: str="WINSOCK.DLL version out of range";break;
        case WSAEDISCON: str="Graceful shutdown in progress";break;
        case WSA_OPERATION_ABORTED: str="Overlapped operation aborted";break;
        default:
            str.Format("Unknown error %d (0x%08x)",nErr,nErr);
    }
#else
   switch(errno){
        case ERR_TIMEOUT: str="Read operation timed out";break;
        case ERR_READ_AFTER_CLOSE: str="Read operation after socket closed";break;
        default:
            str=strerror(errno);
   }
#endif
    return str;
}

bool CeCosTestSocket::sendInteger(int n,const char *pszMsg,CeCosTestUtils::Duration dTimeout)
{
    // This has to be more sophisticated if we support cross-architectural (endianness)
    return send (&n, sizeof n,pszMsg,dTimeout);
}

bool CeCosTestSocket::recvInteger(int & n,const char *pszMsg,CeCosTestUtils::Duration dTimeout)
{
    // This has to be more sophisticated if we support cross-architectural (endianness)
    return recv (&n, sizeof n,pszMsg,dTimeout);
}


bool CeCosTestSocket::recvString  (CeCosTestUtils::String &str,const char * const pszMsg,Duration dTimeout)
{
    int nLength;
    bool rc=false;
    if(recvInteger(nLength,pszMsg,dTimeout)){
        rc=(0==nLength || recv(str.GetBuffer(nLength),nLength,pszMsg,dTimeout));
        str.ReleaseBuffer();
    }
    return rc;
}


bool CeCosTestSocket::sendString  (const char *pszString,const char * const pszMsg,Duration dTimeout)
{
    int nLength=strlen(pszString);
    return sendInteger(nLength,pszMsg,dTimeout) && (0==nLength || send(pszString,nLength,pszMsg,dTimeout));
}


// Give indication of bytes available to be read (but don't read them)
bool CeCosTestSocket::Peek (unsigned int &nAvail)
{
    char buf[8192];
    int n=::recv(m_nSock, buf, sizeof buf, MSG_PEEK);
    nAvail=0;
    bool rc=false;
    switch(n) {
        case -1:
            SaveError();
            if(WOULDBLOCK==SocketError()){
                rc=true; // nAvail stays==0
            } else {
                ERROR("Peek: err=%d %s\n",SocketError(),(const char *)SocketErrString());
            }
            break;
        case 0:
            m_nErr=ERR_READ_AFTER_CLOSE;
            break;
        default:
            rc=true;
            nAvail=n;
    }
    return rc;
}

// Connect tcp/ip port and serial port together.
// Traffic is passed through pFunc, passed parameter pParam.
// The pFunc function:
//    may reallocate pBuf (using malloc/realloc etc...)
//    must leave pBuf allocated on exit
//    should not close either serial or socket
//    should leave writing to its caller
//    should return false if it wishes to terminate the connection (after caller has written output)
bool ConnectSocketToSerial (
    int nListenSock,const char *pszPort, int nBaud,
    FilterFunc *pSerialToSocketFilterFunc/*=0*/,FilterFunc *pSocketToSerialFilterFunc/*=0*/,void *pParam/*=0*/,
    bool *pbStop)
{

    TRACE("ConnectSocketToSerial : socket %d <--> %s\n",nListenSock,pszPort);

    CeCosTestSerial serial;
    serial.SetBlockingReads(false);
    bool rc=false;
    // Open serial device.
    if (!serial.Open(pszPort,nBaud)){
        ERROR("Couldn't open port %s\n",pszPort);
    } else {
        // Flush the serial buffer.
        serial.Flush();

        TRACE("ConnectSocketToSerial: waiting for connection...\n");
        CeCosTestSocket socket;
        if(!socket.Accept(nListenSock,pbStop)){
            ERROR("ConnectSocketToSerial - couldn't accept\n");
        } else {    
            serial.ClearError();
            enum {BUFSIZE=8192};
            void *pBuf=malloc(BUFSIZE);
            TRACE("ConnectSocketToSerial: connected\n");
            rc=true;
            while(rc && (0==pbStop || !(*pbStop))){
                unsigned int nRead=0;
                switch(SSRead (serial,socket,pBuf,BUFSIZE,nRead)){
                    case 2:
                        VTRACE("Serial:%d\n",nRead);
                        if(pSerialToSocketFilterFunc){
                            rc=pSerialToSocketFilterFunc(pBuf,nRead,serial,socket,pParam);
                        }
                        if(nRead && !socket.send(pBuf,nRead)){
                            TRACE("Failed to write to socket\n");
                            rc=false;
                        }
                        break;
                    case 1:
                        unsigned int nWritten;
                        VTRACE("Socket:%d\n",nRead);
                        if(pSocketToSerialFilterFunc){
                            rc=pSocketToSerialFilterFunc(pBuf,nRead,serial,socket,pParam);
                        }
                        {
                            char *c=(char *)pBuf;
                            int nToWrite=nRead;
                            while(nToWrite>0){
                                if(!serial.Write(pBuf,nRead,nWritten)){
                                    TRACE("Failed to write to serial\n");
                                    rc=false;
                                    break;
                                }
                                nToWrite-=nWritten;
                                c+=nWritten;
                            }
                        }
                        break;
                    case 0:
                        TRACE("SSRead returned error indication\n");
                        rc=false;
                        break;
                        // Error
                }
            }
            free(pBuf);
        }
    }
    TRACE("ConnectSocketToSerial : done\n");
    return rc;
}