blockingSockTest: Undo member renames using m_ prefix

Using the m_ prefix to denote class data members is dangerous in
code that has to compile on VxWorks 5.5 (which 3.15 does) because
the net/mbuf.h header contains the following macro definitions:

#define m_next          mBlkHdr.mNext
#define m_len           mBlkHdr.mLen
#define m_data          mBlkHdr.mData
#define m_type          mBlkHdr.mType
#define m_flags         mBlkHdr.mFlags
#define m_nextpkt       mBlkHdr.mNextPkt
#define m_act           m_nextpkt
#define m_pkthdr        mBlkPktHdr
#define m_ext           pClBlk
#define m_extBuf        m_ext->clNode.pClBuf
#define m_extFreeRtn    m_ext->pClFreeRtn
#define m_extSize       m_ext->clSize
#define m_extRefCnt     m_ext->clRefCnt
#define m_extArg1       m_ext->clFreeArg1
#define m_extArg2       m_ext->clFreeArg2
#define m_extArg3       m_ext->clFreeArg3
#define  m_copy(m, o, l)        m_copym((m), (o), (l), M_DONTWAIT)
#define  m_copym(m, o, l, w)    netMblkChainDup(_pNetDpool, (m), (o), (l), (w))
#define  m_freem(m)             netMblkClChainFree(m)
#define  m_free(m)              netMblkClFree(m)    
#define m_mbufs         mNum
#define m_drops         mDrops
#define m_wait          mWait
#define m_drain         mDrain
#define m_mtypes        mTypes

While the names in the original change all appear to be safe, I
don't want us to start using this convention because we will then
have to police commits more closely or risk build failures in the
future when someone who doesn't know about or remember the issue
can't or doesn't try building their code against VxWorks 5.5.

I don't particularly like the this-> convention to mark member
names either, but until the VxWorks 5.5 support requirement goes
away the m_ convention is worse. Another common convention of
using a leading underscore is not safe either, those names are
reserved for the C/C++ implementation.
This commit is contained in:
Andrew Johnson
2014-08-02 14:02:43 -05:00
parent 8d5cdc3747
commit b7f8f17227
+45 -46
View File
@@ -22,8 +22,8 @@
epicsAssert(__FILE__, __LINE__, #exp, epicsAssertAuthor))
union address {
struct sockaddr_in m_ia;
struct sockaddr m_sa;
struct sockaddr_in ia;
struct sockaddr sa;
};
class circuit {
@@ -37,10 +37,10 @@ public:
bool sendWakeupDetected () const;
virtual const char * pName () = 0;
protected:
SOCKET m_sock;
epicsThreadId m_id;
bool m_recvWakeup;
bool m_sendWakeup;
SOCKET sock;
epicsThreadId id;
bool recvWakeup;
bool sendWakeup;
protected:
virtual ~circuit() {}
};
@@ -66,45 +66,45 @@ public:
void daemon ();
address addr () const;
protected:
address m_addr;
SOCKET m_sock;
epicsThreadId m_id;
bool m_exit;
address srvaddr;
SOCKET sock;
epicsThreadId id;
bool exit;
};
circuit::circuit ( SOCKET sockIn ) :
m_sock ( sockIn ),
m_id ( 0 ),
m_recvWakeup ( false ),
m_sendWakeup ( false )
sock ( sockIn ),
id ( 0 ),
recvWakeup ( false ),
sendWakeup ( false )
{
verify ( m_sock != INVALID_SOCKET );
verify ( this->sock != INVALID_SOCKET );
}
bool circuit::recvWakeupDetected () const
{
return m_recvWakeup;
return this->recvWakeup;
}
bool circuit::sendWakeupDetected () const
{
return m_sendWakeup;
return this->sendWakeup;
}
void circuit::shutdown ()
{
int status = ::shutdown ( m_sock, SHUT_RDWR );
int status = ::shutdown ( this->sock, SHUT_RDWR );
verify ( status == 0 );
}
void circuit::signal ()
{
epicsSignalRaiseSigAlarm ( m_id );
epicsSignalRaiseSigAlarm ( this->id );
}
void circuit::close ()
{
epicsSocketDestroy ( m_sock );
epicsSocketDestroy ( this->sock );
}
void circuit::recvTest ()
@@ -112,11 +112,11 @@ void circuit::recvTest ()
epicsSignalInstallSigAlarmIgnore ();
char buf [1];
while ( true ) {
int status = recv ( m_sock,
int status = recv ( this->sock,
buf, (int) sizeof ( buf ), 0 );
if ( status == 0 ) {
testDiag ( "%s was disconnected", this->pName () );
m_recvWakeup = true;
this->recvWakeup = true;
break;
}
else if ( status > 0 ) {
@@ -128,7 +128,7 @@ void circuit::recvTest ()
sockErrBuf, sizeof ( sockErrBuf ) );
testDiag ( "%s socket recv() error was \"%s\"\n",
this->pName (), sockErrBuf );
m_recvWakeup = true;
this->recvWakeup = true;
break;
}
}
@@ -145,15 +145,15 @@ clientCircuit::clientCircuit ( const address & addrIn ) :
{
address tmpAddr = addrIn;
int status = ::connect (
m_sock, & tmpAddr.m_sa, sizeof ( tmpAddr ) );
this->sock, & tmpAddr.sa, sizeof ( tmpAddr ) );
verify ( status == 0 );
circuit * pCir = this;
m_id = epicsThreadCreate (
this->id = epicsThreadCreate (
"client circuit", epicsThreadPriorityMedium,
epicsThreadGetStackSize(epicsThreadStackMedium),
socketRecvTest, pCir );
verify ( m_id );
verify ( this->id );
}
@@ -168,43 +168,42 @@ extern "C" void serverDaemon ( void * pParam ) {
}
server::server ( const address & addrIn ) :
m_addr ( addrIn ),
m_sock ( epicsSocketCreate ( AF_INET, SOCK_STREAM, IPPROTO_TCP ) ),
m_id ( 0 ), m_exit ( false )
srvaddr ( addrIn ),
sock ( epicsSocketCreate ( AF_INET, SOCK_STREAM, IPPROTO_TCP ) ),
id ( 0 ), exit ( false )
{
verify ( m_sock != INVALID_SOCKET );
verify ( this->sock != INVALID_SOCKET );
// setup server side
int status = bind ( m_sock,
& m_addr.m_sa, sizeof ( m_addr ) );
osiSocklen_t slen = sizeof ( this->srvaddr );
int status = bind ( this->sock, & this->srvaddr.sa, slen );
if ( status ) {
testDiag ( "bind to server socket failed, status = %d", status );
}
osiSocklen_t slen = sizeof ( m_addr );
if ( getsockname(m_sock, &m_addr.m_sa, &slen) != 0 ) {
if ( getsockname(this->sock, & this->srvaddr.sa, & slen) != 0 ) {
testAbort ( "Failed to read socket address" );
}
status = listen ( m_sock, 10 );
status = listen ( this->sock, 10 );
verify ( status == 0 );
}
void server::start ()
{
m_id = epicsThreadCreate (
"server daemon", epicsThreadPriorityMedium,
epicsThreadGetStackSize(epicsThreadStackMedium),
this->id = epicsThreadCreate (
"server daemon", epicsThreadPriorityMedium,
epicsThreadGetStackSize(epicsThreadStackMedium),
serverDaemon, this );
verify ( m_id );
verify ( this->id );
}
void server::daemon ()
{
while ( ! m_exit ) {
while ( ! this->exit ) {
// accept client side
address addr;
osiSocklen_t addressSize = sizeof ( addr );
SOCKET ns = accept ( m_sock,
& m_addr.m_sa, & addressSize );
SOCKET ns = accept ( this->sock,
& addr.sa, & addressSize );
verify ( ns != INVALID_SOCKET );
circuit * pCir = new serverCircuit ( ns );
verify ( pCir );
@@ -213,7 +212,7 @@ void server::daemon ()
address server::addr () const
{
return m_addr;
return this->srvaddr;
}
serverCircuit::serverCircuit ( SOCKET sockIn ) :
@@ -257,9 +256,9 @@ MAIN(blockingSockTest)
address addr;
memset ( (char *) & addr, 0, sizeof ( addr ) );
addr.m_ia.sin_family = AF_INET;
addr.m_ia.sin_addr.s_addr = htonl ( INADDR_LOOPBACK );
addr.m_ia.sin_port = 0;
addr.ia.sin_family = AF_INET;
addr.ia.sin_addr.s_addr = htonl ( INADDR_LOOPBACK );
addr.ia.sin_port = 0;
server srv ( addr );
srv.start ();