socket

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <iostream>
#include "KsSock.h"

bool kssock::mbInitDll = false;

kssock::kssock()
{
 if (!mbInitDll)
 {
#if WIN32
  WSADATA wsaData;
  int result = WSAStartup(MAKEWORD(2,2),&wsaData);

  if( result == 0 )
  {
   mbInitDll = true;
  }

  mbInitDll = true;
#else
  mbInitDll = true;
#endif
 }

  mbServer = false;
  mbUsing = false;
  memset(msIp,0,sizeof(msIp));
}

kssock::~kssock()
{
 close(true);
}

//
// test can read info
// time out -101
// err -1
// succeed 0
int kssock::isCanRead(int nTimeOut)
{
 fd_set   readfds;
 
 struct timeval timeout;
 int    iret;
 
 timeout.tv_sec = (nTimeOut-nTimeOut%1000)/1000;
 timeout.tv_usec = nTimeOut%1000;
 
 timeout.tv_sec = (nTimeOut-nTimeOut%1000)/1000;
 timeout.tv_usec = nTimeOut%1000;
 
 FD_ZERO(&readfds);
 FD_SET(mkssock,&readfds);
 
 iret = select((int)mkssock+1,&readfds,NULL,NULL,&timeout);
 
 if (SOCK_ERR  == iret)
 {
  return SOCK_ERR;
 }
 
 if (0 == iret) //select超时
 {
  return -101;
 }
 
 if(FD_ISSET(mkssock,&readfds))
 {
  return 0;
 }
 
 return SOCK_ERR;
}

void kssock::GetSIp(char * sIp,int nBufLen)
{
  strcpy(sIp,this->msIp);
 // std::cout<<"接入ＩＰ:"<<this->msIp<<std::endl;
}

//
// test can write info
// time out -101
// err -1
// succeed 0
int kssock::isCanWrite(int nTimeOut)
{
 fd_set   writeds;
 
 struct timeval timeout;
 int    iret;
 
 timeout.tv_sec = (nTimeOut-nTimeOut%1000)/1000;
 timeout.tv_usec = nTimeOut%1000;
 
 FD_ZERO(&writeds);
 FD_SET(mkssock,&writeds);
 
 iret = select((int)mkssock+1,NULL,&writeds,NULL,&timeout);
 
 if (SOCK_ERR  == iret)
  return SOCK_ERR;
 
 if (0 == iret) //select超时
 {
  return -101;
 }
 
 if(FD_ISSET(mkssock,&writeds))
 {
  return 0;
 }
 
 return SOCK_ERR;
}

//
// recv data
// err    -1
// timeout -101
// succeed recv bytes length
int kssock::recv(void * pBuffer,int nLen, int nTimeOut)
{
 if (!mbUsing)
 {
  return -1;
 }
 
 int iret = isCanRead(nTimeOut);
 
 if (iret != 0)
 {
  return iret;
 }
 
 return ::recv(mkssock,(char *)pBuffer,nLen,0);
}

//
// send data
// err    -1
// timeout -101
// succeed send bytes length
int kssock::send(void * pBuffer,int nLen, int nTimeOut)
{
 if (!mbUsing)
 {
  return -1;
 }
 
 int iret = isCanWrite(nTimeOut);
 
 if (iret != 0)
 {
  return iret;
 }
 
 return ::send(mkssock,(char *)pBuffer,nLen,0);
}

//
// connnet
// err -1
// timeout -101
// succeed 0
int kssock::connect(char * sIp, int nPort,int nTimeOut)
{
 if (mbServer || !mbInitDll)
 {
  return -1;
 }
 
 struct sockaddr_in addr;
 
 //
 // 连接服务端口
 memset(&addr,0,sizeof(addr));
 addr.sin_family = AF_INET;
 addr.sin_addr.s_addr = inet_addr(sIp);
 addr.sin_port = htons(nPort);
 
 mkssock = socket(AF_INET,SOCK_STREAM,0);
 
 if( ::connect( mkssock, (const struct sockaddr *)&addr, sizeof(addr) ) == SOCK_ERR )
 {
  return SOCK_ERR;
 }
 
 this->mbServer = false;
 this->mbUsing = true;
 
 return 0;
}

//
// listern on set.
// err -1
// succeed 0
int kssock::listern(int nPort)
{
 if (mbServer || !mbInitDll)
 {
  return -1;
 }
 
 //
 // bind
 struct sockaddr_in addr;
 mkssock = socket(AF_INET,SOCK_STREAM,0);
 
 memset(&addr,0,sizeof(addr));
 addr.sin_family = AF_INET ;
 addr.sin_port = htons(nPort);
 addr.sin_addr.s_addr = htonl(INADDR_ANY) ;
 
 if(bind(mkssock,(const struct sockaddr *)&addr,sizeof(addr)) < 0)
 {
  return SOCK_ERR;
 }
 
 // listen
 if(listen(mkssock,3) < 0)
 {
  return SOCK_ERR;
 }
 
 mbServer = true;
 mbUsing = true;
 
 return 0;
}

//
// accept user connect
// err -1
// timeout -101
// succeed 0
int kssock::acceptconnect(kssock & sock)
{
 int iret;
 
 if (!mbServer)
 {
  return -1;
 }
 
 //
 // 多路复用,是否Read
 iret = isCanRead(15*1000);
 
 if (0 == iret)
 {
  char szIp[128]={0};int nlen;
  SOCKADDR_IN Addr;
  memset(&Addr,0,sizeof(Addr));
  nlen = sizeof(Addr);
  KS_SOCK handle = accept(mkssock,(SOCKADDR*)&Addr,&nlen);
  sprintf(szIp,"%s",inet_ntoa(Addr.sin_addr));
  
  sock.setHandle(handle,szIp);
  
  return 0;
 }
 
 // 可以加入验证用户
 //***
 
 return iret;
}

//
// set socket handle
int kssock::setHandle(KS_SOCK & sock, char * sIp)
{
 mkssock = sock;
 memset(msIp,0,sizeof(msIp));
 strcpy(msIp,sIp);

 mbUsing = true;
 mbServer = true;
 
 return 0;
}

//
// close user
int kssock::close(bool bShutDown)
{
 if (mbUsing)
 {
  if (bShutDown)
  {
      // 测试进行shut down socket
      std::cout<<"[socket]shutdown(2)"<<std::endl;
   shutdown(mkssock,2);
  }

  closesocket(mkssock);
  
    mbServer = false;
  mbUsing = false;
 }

 return 0;
}

void kssock::setNetInt32(int nInt, char * buffer,int nLen)
{
 int tmpLen = 0;

 tmpLen = nInt;
 buffer[3]=tmpLen%256;
  
 tmpLen=(tmpLen>>8);
 buffer[2]=tmpLen%256;
  
 tmpLen=(tmpLen>>8);
 buffer[1]=tmpLen%256;

 tmpLen=(tmpLen>>8);
 buffer[0]=tmpLen%256;
}

void kssock::SetOptionNullDelay()
{
  //
  bool iOptVal = true;
  bool iOptLen = sizeof(bool);
  ::setsockopt(mkssock,IPPROTO_TCP,TCP_NODELAY,(char*)&iOptVal,iOptLen);
}

 

 

 

 

 

 

 

 

#ifndef _KS_SOCK_H
#define _KS_SOCK_H

#if WIN32
 #include <winsock.h>
 
 typedef SOCKET KS_SOCK;
#else
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <sys/time.h>
 #include <sys/times.h>
 #include <sys/select.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <unistd.h>
 
 typedef int  KS_SOCK;
#endif

#define SOCK_ERR -1

// 除去VC8和VC6的区别
#pragma   warning(disable:4996)

/**
 描述: 完成socket应用类封装
 */
class kssock
{
public:
 kssock();
 ~kssock();

 //
 // test can read info
 // time out -101
 // err -1
 // succeed 0
 int isCanRead(int nTimeOut);

 //
 // test can write info
 // time out -101
 // err -1
 // succeed 0
 int isCanWrite(int nTimeOut);
 //
 // recv data
 // err    -1
 // timeout -101
 // succeed recv bytes length
 int recv(void * pBuffer,int nLen, int nTimeOut);
 
 //
 // send data
 // err    -1
 // timeout -101
 // succeed send bytes length
 int send(void * pBuffer,int nLen, int nTimeOut);
 
 //
 // connnet
 // err -1
 // timeout -101
 // succeed 0
 int connect(char * sIp, int nPort,int nTimeOut);

 //
 // listern on set.
 // err -1
 // succeed 0
 int listern(int nPort);
 
 //
 // accept user connect
 // err -1
 // timeout -101
 // succeed 0
 int acceptconnect(kssock & sock);
 
 //
 // set socket handle
 int setHandle(KS_SOCK & sock, char * sIp);

 //
 // close user
 int close(bool bShutDown);

 //
 // get addr
 void GetSIp(char * sIp,int nBufLen);

  // 设置无延迟发送数据send完成发送数据
  void SetOptionNullDelay();

public:
 static void setNetInt32(int nInt, char * buffer,int nLen);
 static int  getNetInt32(char * buffer);
 
private:
 // socket handle
 KS_SOCK mkssock;
 char    msIp[128];
 
 bool mbServer;
 bool mbUsing;
 
 static bool mbInitDll;
};

#endif