chk_sockfile.cpp

一个不错

   size_t n_rd=5;   // anything >1
   CHK_NOT_DEFAULT(tmp);
   if((r=tmp.read(buf,0,n_rd))!=Ok) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   if((r=tmp.write(buf,0,n_rd))!=Ok) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   if((r=tmp.write(WyStr(),n_rd))!=Ok) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   //if((r=tmp.drain())!=Wym_EINVAL) {
   //  WY_THROW(r); // ref fsync(2)
   //}
   CHK_NOT_DEFAULT(tmp);
 }

 // shutdown,bind,listen,accept,connect,sockname,peername
 //
 {
   WySockFile tmp(LocalObj);
   const WySockAddrLocal addr;
   WySockAddrLocal addr2;
   CHK_NOT_DEFAULT(tmp);
   if(addr2!=addr) {
     WY_THROW( WyRet() );
   }
     
   // I am not sure what shoud be returned for the following functions
   // Coding takes whatever tested
   //
   if((r=tmp.shutdown(SHUT_RD))!=Ok) {  // test showed errno==0
     WY_THROW(r);
   }

   if((r=tmp.bind(addr))!=Ok) {         // test showed errno==0
     WY_THROW(r);
   }
   std::cout << "WySockFile (PF_LOCAL) bind a default address\n";

   if((r=tmp.listen(0))!=Ok) {         // test showed errno==0
     WY_THROW(r);
   }

   WySockFile tmp1;
   CHK_DEFAULT(tmp1);
   if((r=tmp.accept(tmp1,addr2))!=Wym_EINVAL) { // test showed errno=EINVAL
     WY_THROW(r);                      // and addr2 is modified
   }
   CHK_DEFAULT(tmp1);
   if(addr2.is_default()==false) {
     WY_THROW( WyRet() );
   }
   if(addr2.family()!=AF_LOCAL) {
     WY_THROW( WyRet() );
   }
   std::cout << "WySockFile (PF_LOCAL) accepted a default address\n";

   if((r=tmp.connect(addr))!=Wym_EINVAL) { // test showed errno==EINVAL
     WY_THROW(r);
   }

   if((r=tmp.sockname(addr2))!=Ok) {
     WY_THROW(r);
   }
   //if(addr!=addr2) {
   //  WY_THROW(r);
   //}
   if((r=tmp.peername(addr2))!=Wym_ENOTCONN) { // test showed errno==ENOTCONN
     WY_THROW(r);
   }
   //if(addr!=addr2) {
   //  WY_THROW(r);
   //}
   CHK_NOT_DEFAULT(tmp);
 }

 // chk move ctor
 {
  char raw_buf[2*sizeof(WySockFile)];
  ::memset(raw_buf,0,sizeof(raw_buf));
  WySockFile* const p1( reinterpret_cast<WySockFile*>(raw_buf) );
  WySockFile* const p2(p1+1);

  new(p1) WySockFile(PF_LOCAL,SOCK_STREAM);
  if(p1->family()!=PF_LOCAL) {
    p1->~WySockFile();
    WY_THROW( WyRet() );
  }

  // move *p1 to p2
  WyFileHandle ofh( p1->fh() );
  int ofamily( p1->family() );
  try {
    new(p2) WySockFile(*p1,Wy::ByMove);
  }
  catch(...) {
    p1->~WySockFile();
    throw;
  };
  WyFileHandle nfh( p2->fh() );
  int nfamily( p2->family() );
  p2->~WySockFile();

  if(nfh!=ofh) {
    WY_THROW( WyRet() );
  }
  if(nfamily!=ofamily) {
    WY_THROW( WyRet() );
  }
 }
};

static void t_exception(void)
{
 //
 // WySockFile(const WySockFile&)
 //
 try {
   const WySockFile tmp(PF_LOCAL,SOCK_STREAM);
   exaust_cpy_ctor(tmp);
   WY_THROW( WyRet() );  // not expected
 }
 catch(const WySockFile::Reply& e) {
   if((e!=Wym_EMFILE)&&(e!=Wym_ENOMEM)) {
     WyRet r=e;
     WY_THROW(r);
   }
   // FALL_THROUGH 
 };

 // WySockFile(int,int,int)
 try {
   WySockFile(PF_LOCAL,SOCK_STREAM,3);
   WY_THROW( WyRet() );
 }
 catch(const WySockFile::Reply& e) {
   if(e!=Wym_EPROTONOSUPPORT) {
     WY_THROW( WyRet(e) );
   }
   // FALL_THROUGH 
 };

 // WySockFile(WyFileHandle)
 try {
   WySockFile tmp(WyFileHandle(-2));
   WY_THROW( WyRet() );
 }
 catch(const WySockFile::Reply& e) {
   if(e!=Wym_EBADF) {
     WY_THROW( WyRet(e) );
   }
   // FALL_THROUGH 
 };

 // Test destructor exception
 //
 try {
   WySockFile tmp;
   std::memset(&tmp,-2,sizeof(tmp));
   // destructor of tmp is now not to cause exception for this setting
 }
 catch(...) {
   throw;
 };

};

static void t_error(void)
{
 WyRet r;
 WySockFile LocalObj(PF_LOCAL,SOCK_STREAM);

 // stat
 {
  WySockFile tmp;
  WyFileStat stt;
  if((r=tmp.stat(stt))!=Wym_EBADF) {
    WY_THROW(r);
  }
 }

 // reset(const WySockFile&)
 {
   WySockFile tmp(LocalObj);
   CHK_SAME_SYSF(tmp,LocalObj);
   if((r=tmp.reset(LocalObj))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,LocalObj);

   const WyFileHandle TmpFh( tmp.fh() );
   if((r=tmp.reset(tmp))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,LocalObj);
   if(tmp.fh()!=TmpFh) {
     // ok, equ or not
   }
 }

 // reset(int,int,int)
 {
   WySockFile tmp(LocalObj);
   CHK_SAME_SYSF(tmp,LocalObj);

   if((r=tmp.reset(PF_LOCAL,SOCK_STREAM,3))!=Wym_EPROTONOSUPPORT) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,LocalObj);

   if((r=tmp.reset(PF_LOCAL,SOCK_STREAM,0))!=Ok) {
     WY_THROW(r);
   }
   CHK_NOT_DEFAULT(tmp);
 }

 // reset(WyFileHandle)
 {
   WySockFile tmp(LocalObj);
   if((r=tmp.reset(LocalObj.fh()))!=Ok) {
     WY_THROW(r);
   }
   CHK_SAME_SYSF(tmp,LocalObj);
 }

 // read/write
 {
   WySockFile tmp;
   char buf[2];
   size_t n_rd,n_wr;
   WyStr str;
   n_rd=4;
   if((tmp.read(buf,sizeof(buf),n_rd))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   if((tmp.read(str,sizeof(buf),n_rd))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if(n_rd!=0) {
     WY_THROW( WyRet() );
   }
   CHK_DEFAULT(tmp);
   n_wr=6;
   if((tmp.write(buf,sizeof(buf),n_wr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }
   n_wr=6;
   if((tmp.write(str,n_wr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if(n_wr!=0) {
     WY_THROW( WyRet() );
   }

   //if((tmp.drain())!=Wym_EBADF) {
   //  WY_THROW(r);
   //}
   CHK_DEFAULT(tmp);
 }

 // shutdown/
 {
   WySockFile tmp,tmp2;
   WySockAddrLocal addr;
   if((r=tmp.shutdown(SHUT_RD))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.bind(addr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.listen(0))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.accept(tmp2,addr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.connect(addr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.sockname(addr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   if((r=tmp.peername(addr))!=Wym_EBADF) {
     WY_THROW(r);
   }
   CHK_DEFAULT(tmp);
   if(addr.is_default()==false) {
     WY_THROW( WyRet() );
   }
 }

 // EFBIG
 {
  WySockFile tmp(LocalObj);
  WyStr buf;
  size_t n_rd(7);
  CHK_NOT_DEFAULT(tmp);
  if((r=tmp.read(buf,WyStr::max_capacity()+1,n_rd))!=Wym_EFBIG) {
    WY_THROW(r);
  }
  if(n_rd!=0) {
    WY_THROW( WyRet() );
  }
  n_rd=88;
  if((r=tmp.read(buf,std::numeric_limits<size_t>::max(),n_rd))!=Wym_EFBIG) {
    WY_THROW(r);
  }
  if(n_rd!=0) {
    WY_THROW( WyRet() );
  }
 }

 // chk _alloc not override
 {
   class T : public WySockFile {
   } tmp;
   WyByteFlow* p=tmp._alloc(r);
   if(r!=Wym_ENOSYS) {
     if(r==Ok) {
       delete p;
     }
     WY_THROW(r);
   }
 }
};

static void t_local_mis(void)
try {
 // chk sockname(..) result consistent
 //
 const WySockAddrLocal Addr(LocalSockFileName);
 WySockFile sock(PF_LOCAL,SOCK_STREAM,0);
 WyRet r;

 Wy::unlink(LocalSockFileName);

 if((r=sock.bind(Addr))!=Ok) {
   WY_THROW(r);
 }

 WySockAddrLocal sname;
 if((r=sock.sockname(sname))!=Ok) {
   WY_THROW(r);
 }

 if(sname._path()!=LocalSockFileName) {
   WY_THROW( WyRet() );
 }

 // Note: WySockFile is derived from WyByteFlow, and does not override
 //       reset(const char*,int). chk access from the base get ENXIO
 //
 {
   WySockFile tmp;
   WyByteFlow *bfp(&tmp);
   if((r=bfp->reset(LocalSockFileName,O_RDONLY))!=Wym_ENXIO) {
     WY_THROW( WyRet(r) );
   }
   if((r=bfp->reset(LocalSockFileName.c_str(),O_RDONLY))!=Wym_ENXIO) {
     WY_THROW( WyRet(r) );
   }
 }
 Wy::unlink(LocalSockFileName);
}
catch(...) {
 Wy::unlink(LocalSockFileName);
 throw;
};

// Test WySockFile communication (AF_LOCAL)
//
// Connect to LocalSockFileName and receieve SvrMsg, then send CliMsg 
// and exit(0).
//
static int process_client_local(void) throw()
try {
 WyRet r;
 WySockFile cli;
 const WySockAddrLocal Saddr(LocalSockFileName);
 
 // Open socket (PF_LOCAL) and connect to the server
 //
 if((r=cli.reset(PF_LOCAL,SOCK_STREAM))!=Ok) {
   WY_THROW(r);
 }
 if((r=cli.connect(Saddr))!=Ok) {
   WY_THROW(r);
 }

 // stat
 {
   WyFileStat stt;
   if((r=cli.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_sock()==false) {
     WY_THROW( WyRet() );
   }
 }

 // Dump addr
 {
  WyStr str(Saddr._path());
  std::cout << "process_client_local connected to: " << str.c_str() << std::endl;
 }

 // chk peername
 {
  WySockAddrLocal taddr;
  if((r=cli.peername(taddr))!=Ok) {
    WY_THROW(r);
  }
  if(taddr._path()!=WyStr(Saddr._path())) {
    WY_THROW(r);
  }
 }

 // Receive message from the server (SvrMsg expected)
 //
 size_t n_rd;
 char rbuf[64];
 if(sizeof(rbuf)<SvrMsg.size()+1) {
   WY_THROW( WyRet() );   // rbuf not long enough, reedit rbuf size.
 }
 if((r=cli.read(rbuf,sizeof(rbuf),n_rd))!=Ok) {
   WY_THROW(r);
 }
 if(n_rd!=SvrMsg.size()) {
   WY_THROW( WyRet() ); 
 }
 if(Wy::_strcmp(SvrMsg,WyCSeg(rbuf,n_rd))!=0) {
   WY_THROW( WyRet() );   // not expected server message
 }
 
 // Send message CliMsg to the server
 //
 size_t n_wr;
 if((r=cli.write(CliMsg.begin(),CliMsg.size(),n_wr))!=Ok) {
   WY_THROW(r);
 }
 if(n_wr!=CliMsg.size()) {
   WY_THROW( WyRet() ); 
 }

 return(0);
}
catch(const WyRet& e) {
 std::cerr << "process_client_local: "  << Wy::wrd(e).c_str() << std::endl;
 return(-1);
}
catch(...) {
 std::cerr << "process_client_local : caught throw" << std::endl;
 return(-1);
};

// Test WySockFile communication (AF_LOCAL)
// t_comm_local fork process_client_local and 
//
static void t_comm_local(void)
try {
 WyRet r;
 pid_t child_pid;
 int child_status;

 // Create server socket (PF_LOCAL) LocalSockFileName
 //
 ::unlink(LocalSockFileName.c_str());
 WySockAddrLocal saddr(LocalSockFileName);
 WySockFile svr;

 if((r=svr.reset(PF_LOCAL,SOCK_STREAM))!=Ok) {
   WY_THROW(r);
 }
 if((r=svr.bind(saddr))!=Ok) {
   WY_THROW(r);
 }
 if((r=svr.listen(1))!=Ok) {
   WY_THROW(r);
 }

 // stat
 {
   WyFileStat stt;
   if((r=svr.stat(stt))!=Ok) {
     WY_THROW(r);
   }
   if(stt.is_sock()==false) {
     WY_THROW( WyRet() );
   }
   std::cout << "socket(Local), _blksize= " << stt.sf_mode() << '\n';
 }

 // Fork child process
 //
 child_pid=::fork();
 if(child_pid<0) {
   WY_THROW( WyRet(WyReply(errno)) );
 }
 if(child_pid==0) {
   ::exit(process_client_local());
 }

 // Server accepts connection
 //
 WySockFile psock;
 WySockAddrLocal paddr;
 if((r=svr.accept(psock,paddr))!=Ok) {
   WY_THROW(r);
 } 

 // test showed default address returned (probable right for PF_LOCAL?)
 //
 if(paddr.is_default()==false) {
   // Dump the accept addr
   {
    WyStr str( paddr._path() );
    std::cout << "server(PF_LOCAL) accept() address: " << str.c_str() << std::endl;
   }
   WY_THROW( WyRet() );
 }

 // Send SvrMsg to the client
 //
 size_t n_wr;
 if((r=psock.write(SvrMsg.begin(),SvrMsg.size(),n_wr))!=Ok) {
   WY_THROW(r);
 }
 if(n_wr!=SvrMsg.size()) {
   WY_THROW( WyRet() ); 
 }

 // Receive message from the client (CliMsg expected)
 //