int main(int argc, char **argv)
{
Preferences::Instance()->SetFile("/boot/home/config/settings/RemoteControl.perfs");
args.porti=4321;
args.ports=4322;
args.passwd=0;
parse(argc, argv);
MyApp *app=new MyApp();
int32 socki=CreateSocket(args.porti);
int32 socks=CreateSocket(args.ports);
if((socki<0) || (socks<0))
return 1;
new InputListener (socki, args.passwd);
new ScreenListener(socks, args.passwd);
app->Run();
return 0;
}
void UdpSocket::CreateConnection()
{
#ifdef ENABLE_IPV6
#ifdef IPPROTO_IPV6
if (IsIpv6())
{
if (GetSocket() == INVALID_SOCKET)
{
SOCKET s = CreateSocket(AF_INET6, SOCK_DGRAM, "udp");
if (s == INVALID_SOCKET)
{
return;
}
SetNonblocking(true, s);
Attach(s);
}
return;
}
#endif
#endif
if (GetSocket() == INVALID_SOCKET)
{
SOCKET s = CreateSocket(AF_INET, SOCK_DGRAM, "udp");
if (s == INVALID_SOCKET)
{
return;
}
SetNonblocking(true, s);
Attach(s);
}
}
int EgSock::Connect(const char* ip, uint16_t port, function<void(sp_EgSock)> callback)
{
_fd = CreateSocket();
SetNonblock(fd);
SetNodelay(fd);
_peer_ip = ip;
_port = port;
_state = EG_SOCK_CONNECTING;
_callback = callback;
sockaddr_in serv_addr;
SetAddr(ip, port, &serv_addr);
if (connect(_fd, (sockaddr*)&serv_addr, sizeof(serv_addr)) == SOCKET_ERROR) {
if (!((errno == EINPROGRESS) || (errno == EWOULDBLOCK))) {
loge("connect failed, err_code=%d", errno);
close(_fd);
throw egex("connect failed, errno=%d", errno);
}
} else {
_state = EG_SOCK_CONNECTED;
callback(shared_from_this());
}
return _fd;
}
int CLS_TCPSvr::Listen()
{
char *strIP;
if(m_iStatus==SS_UNUSED)
if(CreateSocket()<0)
return -1;
if(m_iStatus!=SS_LISTEN)
{
if(m_iStatus!=SS_BOUND)
if(Bind()<0)
return -2;
if (listen(m_iSocket, 5)<0)
{
CloseSocket();
return -3;
}
if(!m_iLocalPort)
{
strIP=GetLocalHost(&m_iLocalPort);
if(strIP)
strcpy(m_strLocalIP, strIP);
}
m_iStatus=SS_LISTEN;
}
return 0;
}
// Write a socket
wxInt32 BufferedSocket::SendData(const wxInt32 &Timeout)
{
wxInt32 BytesSent;
if (CreateSocket() == false)
return 0;
// clear it
memset(m_SendBuffer, 0, MAX_PAYLOAD);
// copy data
size_t WrittenSize = m_SendBufferHandler->CopyTo(m_SendBuffer,
MAX_PAYLOAD);
// Creation of this will start the stop watch
wxStopWatch sw;
// send the data
BytesSent = send(m_Socket, (const char *)m_SendBuffer, WrittenSize, 0);
// set the start ping
m_SendPing = sw.Time();
CheckError();
// return the amount of bytes sent
return BytesSent;
}
nsresult
KeyStoreConnector::CreateListenSocket(struct sockaddr* aAddress,
socklen_t* aAddressLength,
int& aListenFd)
{
ScopedClose fd;
nsresult rv = CreateSocket(fd.rwget());
if (NS_FAILED(rv)) {
return rv;
}
rv = SetSocketFlags(fd);
if (NS_FAILED(rv)) {
return rv;
}
if (aAddress && aAddressLength) {
rv = CreateAddress(*aAddress, *aAddressLength);
if (NS_FAILED(rv)) {
return rv;
}
}
// Allow access for wpa_supplicant (different user, different group)
//
// TODO: Improve this by setting specific user/group for
// wpa_supplicant by calling |fchmod| and |fchown|.
//
chmod(KEYSTORE_SOCKET_PATH, S_IRUSR|S_IWUSR|
S_IRGRP|S_IWGRP|
S_IROTH|S_IWOTH);
aListenFd = fd.forget();
return NS_OK;
}
int Client::Run(const char* pIP, unsigned short uPort, const char * pFileName)
{
int iRet = 0;
if (pIP == NULL)
{
iRet = -1;
return iRet;
}
memccpy(m_sIPAddress, pIP, 0, sizeof(m_sIPAddress) - 1);
m_sIPAddress[sizeof(m_sIPAddress) - 1] = 0;
m_uPort = uPort;
if (pFileName != NULL) {
m_RequireType = 2; //File
memccpy(m_sFilename, pFileName, 0, sizeof(m_sFilename) - 1);
m_sFilename[sizeof(m_sFilename) - 1] = 0;
}
else
{
m_RequireType = 1; //DIR
}
CreateSocket();
ConnectSocket();
return iRet;
}
DWORD CEgTcpDriver::CreateAcceptSocket(BOOL bBindIocp)
{
DWORD dwRecvNumBytes = 0;
DWORD dwRes;
if (bBindIocp)
{
m_ListenSocketContext.m_ConnectioID.m_Socket = m_ListenSocket;
m_ListenSocketContext.m_pIOContext.m_IoOperation = ClientIoAccept;
dwRes = BindCompletionPort(m_ListenSocketContext);
if (dwRes != 0)
return dwRes;
}
m_ListenSocketContext.m_pIOContext.m_SocketAccept = CreateSocket();
if (INVALID_SOCKET == m_ListenSocketContext.m_pIOContext.m_SocketAccept)
return WSAGetLastError();
int nRet = AcceptEx(
m_ListenSocket,
m_ListenSocketContext.m_pIOContext.m_SocketAccept,
(LPVOID)(m_ListenSocketContext.m_pIOContext.m_ReceiveBuffer.buf),
0,
sizeof(SOCKADDR_IN) + 16,
sizeof(SOCKADDR_IN) + 16,
&dwRecvNumBytes,
(LPOVERLAPPED) &(m_ListenSocketContext.m_pIOContext.m_SendOverlapped)
);
if (nRet == SOCKET_ERROR && (ERROR_IO_PENDING != WSAGetLastError()))
return WSAGetLastError();
return 0;
}
virtual bool Bind( const CIPAddr *pAddr )
{
if ( !CreateSocket() )
return false;
return BindPart2( pAddr );
}
DWORD WINAPI CEgTcpDriver::CreateListenSocket()
{
SOCKADDR_IN si_addrlocal;
int nRet;
LINGER lingerStruct;
lingerStruct.l_onoff = 0;
lingerStruct.l_linger = 0;
m_ListenSocket = CreateSocket();
if (INVALID_SOCKET == m_ListenSocket)
return WSAGetLastError();
si_addrlocal.sin_family = AF_INET;
si_addrlocal.sin_port = htons(m_usServerPort);
si_addrlocal.sin_addr.s_addr = htonl(INADDR_ANY);
nRet = bind(m_ListenSocket, (struct sockaddr *)&si_addrlocal, sizeof(si_addrlocal));
if (SOCKET_ERROR == nRet)
return WSAGetLastError();
nRet = listen(m_ListenSocket, SOMAXCONN);
if (SOCKET_ERROR == nRet)
return WSAGetLastError();
return 0;
}
BOOL PortTransfer_1(WORD ListenPort, char *szIP, WORD wPort)
{
HANDLE hThread;
DWORD dwThreadId;
SOCKET AcceptSocket;
TransferParam<ADDRESS, SOCKET> ConfigInfo;
_snprintf(ConfigInfo.GlobalData.szIP, ADDRSIZE, "%s", szIP);
ConfigInfo.GlobalData.wPort = wPort;
//监听个服务端口，即映射端口
SOCKET localsockid = CreateSocket(INADDR_ANY, ListenPort);
if(localsockid <= 0)
goto error;
while(1)
{
printf("Accepting new Client...");
AcceptSocket = accept(localsockid, NULL, NULL);
if(AcceptSocket == INVALID_SOCKET)
goto error;
nTimes++;
printf("OK.\r\n");
//将接受到的客户请求套接字转到新的线程里处理
//然后继续等待新的请求
ConfigInfo.LocalData.Push(AcceptSocket);
hThread = CreateThread(NULL, 0, PortTransfer_1, (LPVOID)&ConfigInfo, NULL, &dwThreadId);
if(hThread)
CloseHandle(hThread);
else
Sleep(1000);
}
error:
printf("Error.\r\n");
closesocket(localsockid);
return false;
}
void SocketEngine::sendData(const char* data)
{
if (m_socket==NULL) {
CreateSocket();
}
if (m_socket==NULL) {
cout<<"Socket创建失败"<<endl;
return;
}
try {
cocos2d::CCLog("send() datas : %s \n\n",data);
m_socket->SendData(data, strlen(data)+1);
}catch (SocketException &excep) {
cout<<"收到参数意外"<<endl;
cocos2d::CCLog("sendData recvDatas Error: %s \n\n",(const char*)excep);
return;
}
// strcpy(outData, data);
cout<<"开始线程接受Socket数据"<<endl;
if(pthread_create(&pthead_rec, NULL, reciveData, this)!=0){
//pthead_recx线程标示，reciveData回调函数， m_socket传入的参数
cout<<"创建reciveData失败"<<endl;
}
}
int UdpSocket::Bind(SocketAddress& ad, int range)
{
if (GetSocket() == INVALID_SOCKET)
{
Attach(CreateSocket(ad.GetFamily(), SOCK_DGRAM, "udp"));
}
if (GetSocket() != INVALID_SOCKET)
{
SetNonblocking(true);
int n = bind(GetSocket(), ad, ad);
int tries = range;
while (n == -1 && tries--)
{
ad.SetPort(ad.GetPort() + 1);
n = bind(GetSocket(), ad, ad);
}
if (n == -1)
{
Handler().LogError(this, "bind", Errno, StrError(Errno), LOG_LEVEL_FATAL);
SetCloseAndDelete();
#ifdef ENABLE_EXCEPTIONS
throw Exception("bind() failed for UdpSocket, port:range: " + Utility::l2string(ad.GetPort()) + ":" + Utility::l2string(range));
#endif
return -1;
}
m_bind_ok = true;
m_port = ad.GetPort();
return 0;
}
return -1;
}
int
main(int argc, char *argv[])
{
if (argc != 3)
{
printf("%s serverhost serverport\n", argv[0]);
exit(0);
}
// get the server host info
//
int serverport = atoi(argv[2]);
int err;
struct hostent hp;
char buf[1024];
unsigned long hostAddr = 0;
if((gethostbyname_r(argv[1], &hp, buf, sizeof(buf), &err) == NULL))
{
printf("unable to resolve host address(%s)\n", argv[1]);
exit(0);
}
hostAddr = ((struct in_addr*)hp.h_addr)->s_addr;
while (1)
{
// Create the socket
//
CreateSocket(hostAddr, serverport);
}
}
int SocketInfo::Create(const std::string& context) const {
auto types = android::base::Split(type(), "+");
int flags =
((types[0] == "stream" ? SOCK_STREAM : (types[0] == "dgram" ? SOCK_DGRAM : SOCK_SEQPACKET)));
bool passcred = types.size() > 1 && types[1] == "passcred";
return CreateSocket(name().c_str(), flags, passcred, perm(), uid(), gid(), context.c_str());
}
nsresult
NfcConnector::CreateStreamSocket(struct sockaddr* aAddress,
socklen_t* aAddressLength,
int& aStreamFd)
{
ScopedClose fd;
nsresult rv = CreateSocket(fd.rwget());
if (NS_FAILED(rv)) {
return rv;
}
rv = SetSocketFlags(fd);
if (NS_FAILED(rv)) {
return rv;
}
if (aAddress && aAddressLength) {
rv = CreateAddress(*aAddress, *aAddressLength);
if (NS_FAILED(rv)) {
return rv;
}
}
aStreamFd = fd.forget();
return NS_OK;
}
U1 NetServer::Create(){
//创建SOCKET
if(!CreateSocket())
return false;
U16 PORT = Converter::ToU16(m_Info.strPort);
// 绑定socket到一个本地地址
sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_port = htons(PORT);
sin.sin_addr.S_un.S_addr = INADDR_ANY;
if (::bind(m_Socket, (LPSOCKADDR)&sin, sizeof(sockaddr_in)) == SOCKET_ERROR)
{
OutputDebugStringA("绑定失败\n");
return false;
}
// 设置socket进入监听状态
if (::listen(m_Socket, 10) == SOCKET_ERROR)
{
OutputDebugStringA("监听失败\n");
return false;
}
//启动监听线程
m_ThreadListen.Start(m_Socket,this);
//启动发送线程
m_ThreadSend.Start(this);
return true;
}
int SctpSocket::Bind(SocketAddress& ad)
{
if (!ad.IsValid())
{
Handler().LogError(this, "SctpSocket", -1, "invalid address", LOG_LEVEL_ERROR);
return -1;
}
if (GetSocket() == INVALID_SOCKET)
{
Attach(CreateSocket(ad.GetFamily(), m_type, "sctp"));
}
if (GetSocket() != INVALID_SOCKET)
{
int n = bind(GetSocket(), ad, ad);
if (n == -1)
{
Handler().LogError(this, "SctpSocket", -1, "bind() failed", LOG_LEVEL_ERROR);
#ifdef ENABLE_EXCEPTIONS
throw Exception("bind() failed for SctpSocket, port: " + Utility::l2string(ad.GetPort()));
#endif
}
return n;
}
return -1;
}
BOOL CServerSocet::StartServer(CString* sError)
{
if(bCreateSocket)
CloseSocket(sError);
if(!bInitWinSocket)
if (!StartWinSock(sError)) return FALSE;
if (!SocketGetHostName(sError)) return FALSE;
if (!CreateSocket(sError)) return FALSE;
if (!LinkSoketPort(sError)) return FALSE;
if (!LinkWindowSocket(hWnd,sError)) return FALSE;
if (!ListenSocket(sError)) return FALSE;
sokClientSocket = new stSockets *[iMaxCol];
int i;
for(i=0;i<iMaxCol;i++)
{
sokClientSocket[i] = new (stSockets);
sokClientSocket[i]->dBase = NULL;
sokClientSocket[i]->sUserIP = _T("");
sokClientSocket[i]->bAdmin = FALSE;
sokClientSocket[i]->sDataStart = _T("");
sokClientSocket[i]->sok = NULL;
sokClientSocket[i]->hThread = 0;
}
bStatus = TRUE;
return TRUE;
}
int main(int argc, char* argv[]) {
//sending = true;
//Socket socket();
InitializeSockets();
CreateSocket();
if (sending) {
//SendPacket(data, sizeof(data));
}
if (!gameCanStart) {
printf("Waiting for players to connect...\n");
FindPlayers();
}
ReceivePacket();
ShutdownSockets();
std::cin.get();
return 0;
}
DWORD cClientSocket::ConnectTo(DWORD u32_ServerIP, USHORT u16_ServerPort)
{
DWORD u32_Error = ERROR_SUCCESS;
if (CreateSocket())
{
u32_Error = WSAGetLastError();
cout << "Create socket failed with error " << u32_Error << endl;
return u32_Error;
}
sockaddr_in kAddressStruct;
ZeroMemory(&kAddressStruct, sizeof(kAddressStruct));
kAddressStruct.sin_family = AF_INET;
kAddressStruct.sin_port = htons(u16_ServerPort);
kAddressStruct.sin_addr.s_addr = u32_ServerIP;
do
{
if (connect(m_hSocket, (LPSOCKADDR)&kAddressStruct, sizeof(SOCKADDR_IN)) != 0)
{
cout << "Could not connect to server. (" << WSAGetLastError() << ")" << endl;
}
else
{
cout << "Got connection with server, start working..." << endl;
return u32_Error;
}
Sleep(5000);
} while (true);
}
CBlockingUDPSocket::CBlockingUDPSocket() :
m_cserIP(),
m_Socket( 0 ),
m_pImpl( new CImpl )
{
CreateSocket();
}
void*
runThreadedSocket(void *argv)
{
char **argvptr = (char **)argv;
printf("socket> thread launching\n");
CreateSocket(argvptr);
return (void*)NULL;
}
void NetworkManager::AcceptNewConnection()
{
NetworkThread& worker = get_network_thread_for_new_connection();
SocketPtr connection = CreateSocket(worker);
acceptor_->async_accept(connection->socket(),
boost::bind(&NetworkManager::OnNewConnection, this, connection, boost::asio::placeholders::error));
}
int CLS_UDP::Connect()
{
char *strIP;
static struct sockaddr_in sockAddr;
if(m_iStatus==SS_UNUSED)
{
if(CreateSocket()<0)
return -1;
}
if(m_iStatus!=SS_CONNECT)
{
if(m_iStatus!=SS_BOUND)
{
if(Bind()<0)
return -1;
}
memset(&sockAddr, 0, sizeof(sockAddr));
sockAddr.sin_family = AF_INET;
sockAddr.sin_addr.s_addr = inet_addr(m_strPeerIP);
sockAddr.sin_port = htons(m_iPeerPort);
if(connect(m_iSocket, (struct sockaddr *)&sockAddr, sizeof(sockAddr))<0)
{
#ifdef _WIN32
m_iSocketError=GetLastError();
// if(!(m_iSocketError==WSAEINPROGRESS || m_iSocketError==WAEISCONN))
if(m_iSocketError!=WSAEISCONN)
{
if(m_iSocketError==WSAEINVAL)
CloseSocket();
#else
m_iSocketError=errno;
// if(!(m_iSocketError==EINPROGRESS || m_iSocketError==EISCONN))
if(m_iSocketError!=EISCONN)
{
if(m_iSocketError==EINVAL)
CloseSocket();
#endif
return -3;
}
}
if(!(m_strLocalIP[0]||m_iLocalPort))
{
strIP=GetLocalHost(&m_iLocalPort);
if(strIP)
strcpy(m_strLocalIP, strIP);
}
m_iSocketError=0;
m_iStatus=SS_CONNECT;
}
return 0;
}
SocketHandle::SocketHandle(SocketEventHandle *eventHandle,SocketEventHandle *continueHandle):
socket_(INVALID_SOCKET),
eventHandle_(eventHandle),
continueHandle_(continueHandle)
{
ZeroMemory(&localAddr_,sizeof(SOCKADDR_IN));
ZeroMemory(&remoteAddr_,sizeof(SOCKADDR_IN));
CreateSocket();
}
HANDLE S3PDBSocketServer::Start()
{
HANDLE hRet = NULL;
if ( ( NULL != m_hServer )
|| ( NULL == m_piRunSignal )
|| ( NULL == m_pSocketPool )
|| ( NULL == m_hEnablePool ) )
{
hRet = NULL;
return hRet;
}
// The follow code is used to initialize
// the environment for Windows OS platform
// and should be removed or changed when
// replanted to other platforms.
//------>BEGIN
WORD wVersionRequired = MAKEWORD(1,1);
WSADATA WSAdata;
if ( 0 != WSAStartup( wVersionRequired, &WSAdata ) )
{
hRet = NULL;
return hRet;
}
//<------END
if ( INVALID_SOCKET == m_Socket )
{
if ( FALSE == CreateSocket() )
{
hRet = NULL;
return hRet;
}
}
// Start up server thread
//------>BEGIN
if ( NULL != m_pSocketPool )
{
m_pSocketPool->Init( m_Socket, m_hEnablePool );
m_pSocketPool->Start();
}
*m_piRunSignal = 1;
m_ServerParam.piRunSignal = m_piRunSignal;
m_ServerParam.pSocketPool = m_pSocketPool;
m_ServerParam.serverSocket = m_Socket;
m_hServer =
KPICreateThread( S3PDBSocketServer::StartServer, &m_ServerParam, &m_dwServerThreadId );
hRet = m_hServer;
//<------END
return hRet;
}
// Send 2 pipelined HTTP requests 1 GET and 1 POST
//
main(int argc, char *argv[])
{
if (argc != 7)
{
printf("%s serverhost serverport myport postbodylen geturl posturl\n",
argv[0]);
exit(0);
}
CreateSocket(argc, argv);
}
int SocketServer_Run(SocketServer* self, char * listening_port_number)
{
self->itsPort = atoi(listening_port_number);
StartWSA(self);
CreateSocket(self);
BindToSocket(self);
WaitForConnection(self);
Shutdown(self);
return 0;
}
void Listener<SocketType>::BeginAccept()
{
auto worker = SelectWorker();
auto socket = worker->CreateSocket();
m_acceptor->async_accept(socket->GetAsioSocket(),
[this, worker, socket] (const boost::system::error_code &ec)
{
this->OnAccept(worker, socket, ec);
});
}
