void main(){
CallDll();
SocketStartup();//startup the WSA
Listen();
}
DWORD CTcpServerSocketHelper::Start(ITcpServerSocketHelper_Event *pEvent,
DWORD dwListenPort/*=0*/,BOOL bReadData/*=TRUE*/)
{
DWORD dwResult = -1;
DWORD threadID = 0;
m_pEvent = pEvent;
m_dwListenPort = dwListenPort;
if (!CreateTcpSocket(TRUE))
{
dwResult = 1;
goto Exit0;
}
BOOL bOpt = TRUE;
::setsockopt (m_Socket, SOL_SOCKET, SO_REUSEADDR, (const char*)&bOpt, sizeof (bOpt));
if (!Bind())
{
dwResult = 2;
goto Exit0;
}
if (!Listen())
{
dwResult = 3;
goto Exit0;
}
m_hTerminateAcceptThreadEvent = ::CreateEvent(NULL, TRUE, FALSE,NULL);
if (!m_hTerminateAcceptThreadEvent)
{
dwResult = 4;
goto Exit0;
}
m_hAcceptThreadHandle = (HANDLE)::CreateThread( NULL, 0,
(LPTHREAD_START_ROUTINE)_AcceptThreadProc, this, 0, &threadID );
if (!m_hAcceptThreadHandle)
{
dwResult = 5;
goto Exit0;
}
if (bReadData)
{
m_hTerminateReadDataThreadEvent = ::CreateEvent(NULL, TRUE, FALSE,NULL);
if (!m_hTerminateReadDataThreadEvent)
{
dwResult = 6;
goto Exit0;
}
m_hReadDataThreadHandle = (HANDLE)::CreateThread( NULL, 0,
(LPTHREAD_START_ROUTINE)_ReadDataThreadProc, this, 0, &threadID );
if (!m_hReadDataThreadHandle)
{
goto Exit0;
}
}
dwResult = 0;
Exit0:
if (0 != dwResult)
{
Stop();
}
if (dwResult == 0)
{
return m_dwListenPort;
}
return (DWORD)-1;
}
// MAIN
int main(int argc, char **argv) {
// Local variables
int pid;
int port;
int listenfd;
int connfd;
struct sockaddr_in clientAddr;
socklen_t clientSize = sizeof(clientAddr);
FILE* logFile;
// gets port number
if(argc == 2) {
port = atoi(argv[1]);
} else {
perror("Invalid arguments.");
exit(1);
}
// opens log file
logFile = fopen("log.txt", "a+");
// creates listen socket
listenfd = listenSocket(port);
// starts listening
Listen(listenfd, LISTENQUEUE);
for ( ; ; ) {
// accepts a connection
connfd = Accept(listenfd, (struct sockaddr *)&clientAddr, &clientSize);
// prints the info
PrintConnectionInfo(clientAddr);
// log
logConnection(logFile, clientAddr);
// fork
if((pid = fork()) == 0) {
// child process closes the listen socket
close(listenfd);
// process
process(connfd, clientAddr);
// child process closes the connection
close(connfd);
// prints info of disconnection
printDisconnectInfo(clientAddr);
// log
logDisconnection(logFile, clientAddr);
// finished execution
exit(0);
}
// parent process closes the connection with client
close(connfd);
}
// closes log file
fclose(logFile);
return(0);
}
//!! textbook p146 ch 6.11 poll 模板
int
main(int argc, char **argv)
{
int i, maxi, listenfd, connfd, sockfd;
int nready;
ssize_t n;
char buf[MAXLINE];
socklen_t clilen;
struct pollfd client[OPEN_MAX];
struct sockaddr_in cliaddr, servaddr;
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));
Listen(listenfd, LISTENQ);
client[0].fd = listenfd;
client[0].events = POLLRDNORM;
for (i = 1; i < OPEN_MAX; i++)
client[i].fd = -1; /* -1 indicates available entry */
maxi = 0; /* max index into client[] array */
/* end fig01 */
/* include fig02 */
for ( ; ; ) {
nready = Poll(client, maxi+1, INFTIM);
if (client[0].revents & POLLRDNORM) { /* new client connection */
clilen = sizeof(cliaddr);
connfd = Accept(listenfd, (SA *) &cliaddr, &clilen);
#ifdef NOTDEF
printf("new client: %s\n", Sock_ntop((SA *) &cliaddr, clilen));
#endif
for (i = 1; i < OPEN_MAX; i++)
if (client[i].fd < 0) {
client[i].fd = connfd; /* save descriptor */
break;
}
if (i == OPEN_MAX)
err_quit("too many clients");
client[i].events = POLLRDNORM;
if (i > maxi)
maxi = i; /* max index in client[] array */
if (--nready <= 0)
continue; /* no more readable descriptors */
}
for (i = 1; i <= maxi; i++) { /* check all clients for data */
if ( (sockfd = client[i].fd) < 0)
continue;
if (client[i].revents & (POLLRDNORM | POLLERR)) {
if ( (n = read(sockfd, buf, MAXLINE)) < 0) {
if (errno == ECONNRESET) {
/*4connection reset by client */
#ifdef NOTDEF
printf("client[%d] aborted connection\n", i);
#endif
Close(sockfd);
client[i].fd = -1;
} else
err_sys("read error");
} else if (n == 0) {
/*4connection closed by client */
#ifdef NOTDEF
printf("client[%d] closed connection\n", i);
#endif
Close(sockfd);
client[i].fd = -1;
} else
Writen(sockfd, buf, n);
if (--nready <= 0)
break; /* no more readable descriptors */
}
}
}
}
// Management port Listen thread
void NiListenThread(THREAD *thread, void *param)
{
NAT *n = (NAT *)param;
SOCK *a;
UINT i;
bool b = false;
// Validate arguments
if (thread == NULL || param == NULL)
{
return;
}
// Initialize the management list
n->AdminList = NewList(NULL);
while (true)
{
a = Listen(DEFAULT_NAT_ADMIN_PORT);
if (b == false)
{
b = true;
NoticeThreadInit(thread);
}
if (a != NULL)
{
break;
}
Wait(n->HaltEvent, NAT_ADMIN_PORT_LISTEN_INTERVAL);
if (n->Halt)
{
return;
}
}
n->AdminListenSock = a;
AddRef(a->ref);
// Waiting
while (true)
{
SOCK *s = Accept(a);
THREAD *t;
NAT_ADMIN *admin;
if (s == NULL)
{
break;
}
if (n->Halt)
{
ReleaseSock(s);
break;
}
admin = ZeroMalloc(sizeof(NAT_ADMIN));
admin->Nat = n;
admin->Sock = s;
t = NewThread(NiAdminThread, admin);
WaitThreadInit(t);
ReleaseThread(t);
}
// Disconnect all management connections
LockList(n->AdminList);
{
for (i = 0;i < LIST_NUM(n->AdminList);i++)
{
NAT_ADMIN *a = LIST_DATA(n->AdminList, i);
Disconnect(a->Sock);
WaitThread(a->Thread, INFINITE);
ReleaseThread(a->Thread);
ReleaseSock(a->Sock);
Free(a);
}
}
UnlockList(n->AdminList);
ReleaseList(n->AdminList);
ReleaseSock(a);
}
int main(int argc, char **argv)
{
int i, maxi, listenfd, connfd, sockfd;
int nready;
ssize_t n;
char buf[MAXLINE];
socklen_t clilen;
struct pollfd client[OPEN_MAX];
struct sockaddr_in cliaddr, servaddr;
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Bind(listenfd, (SA *)&servaddr, sizeof(servaddr));
Listen(listenfd, LISTENQ);
client[0].fd = listenfd;
client[0].events = POLLIN;
for (i = 1; i < OPEN_MAX; i++)
client[1].fd = -1;
maxi = 0;
for ( ; ; )
{
nready = Poll(client, maxi + 1, INFTIM);
if (client[0].revents & POLLIN) /* new client connection */
{
clilen = sizeof(cliaddr);
connfd = Accept(listenfd, (SA *)&cliaddr, &clilen);
for (i = 1; i < OPEN_MAX; i++)
if (client[i].fd < 0)
{
client[i].fd = connfd; /* save descriptor */
break;
}
if (i == OPEN_MAX)
err_quit("too many clients");
client[i].events = POLLIN;
if (i > maxi)
maxi = i; /* max index in client[] array */
if (--nready <= 0)
continue; /* no more readable descriptors */
}
for (i = 1; i <= maxi; i++) /* check all clients for data */
{
if ((sockfd = client[i].fd) < 0)
continue;
if (client[i].revents & (POLLIN | POLLERR))
{
if ((n = read(sockfd, buf, MAXLINE)) < 0)
{
if (errno == ECONNRESET) /* connection reset by client */
{
Close(sockfd);
client[i].fd = -1;
}
else
err_sys("read error");
}
else if (n == 0) /* connection closed by client */
{
Close(sockfd);
client[i].fd = -1;
}
else
Writen(sockfd, buf, n);
if (--nready <= 0) /* no more readable descriptors */
break;
}
}
}
}
/* We can write a simple version of a TCP daytime server, which will work
* with the daytime client.
*
* TCP服务器端一般要执行的步骤是: socket()->填充结构体(协议类型,本机ip地址,
* 本机端口)->bind()->listen()->accept()->使用连接描述符进行读写.
* TCP客户端一般要执行的步骤是: socket()->填充结构体(协议类型,服务器ip地址,
* 服务器已知端口)->connect()
*/
int main(void)
{
int listenfd, connfd;
struct sockaddr_in servaddr;
char buf[BUFSIZ];
time_t ticks;
/* 1. Create a TCP socket */
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
/* 2. Bind server's well-known port to socket
* The server's well-known port (13 for the daytime service) is bound
* to the socket by filling in an Internet socket address structure and
* calling bind(). We specify the IP address as INADDR_ANY, which allows
* the server to accept a client connection on any interface, in case
* the server host has multiple interfaces.
*
* 以普通用户运行该程序时,会报错: bind error: Permission denied
* 此时,错误码是EACCES. 查看man bind手册,对该错误码解释为:
* EACCES The address is protected, and the user is not the superuser.
*
* 在Linux中,只有 root 用户可以绑定 1024 以下的端口.
* 查看 man 7 ip 手册,里面有如下说明:
* The port numbers below 1024 are called privileged ports (or
* sometimes: reserved ports). Only privileged processes (i.e., those
* having the CAP_NET_BIND_SERVICE capability) may bind to these sockets
* 所以运行该程序时,要用root用户或者sudo命令来运行.
* 另外, 13 这个端口可能被占用导致绑定不成功. Linux下,查看端口是否被占
* 用的方法是: netstat -apn | grep <端口号>. 例如: netstat -apn|grep 13
*/
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(13);
Bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
/* 3. Convert socket to listening socket
* By calling listen(), the socket is converted into a listening socket,
* on which incomming connections from clients will be accepted by the
* kernel. These three steps, socket(), bind(), and listen(), are the
* normal steps for any TCP server to prepare what we call the listening
* descriptor (listenfd in this example).
*/
Listen(listenfd, LISTENQ);
for (; ;) {
/* 4. Accept client connection, send reply
* Normally, the server process is put to sleep in the call to
* accept(), waiting for a client connection to arrive and be
* accepted. A TCP connection uses what is called a three-way
* handshake to establish a connection. When this handshake
* completes, accept() returns, and the return value from the
* function is a new descriptor (connfd) that is called the
* connected descriptor. This new descriptor is used for
* communication with the new client. A new descriptor is returned
* by accept() for each client that connects to our server.
*/
connfd = Accept(listenfd, NULL, NULL);
/* The current time and date are returned by the library function
* time(), which returns the number of seconds since the Unix
* Eproch: 00:00:00 January 1, 1970, Coordinated Universal Time(UTC)
* The next library function, ctime(), converts this integer value
* into a human-readable string sush as: Mon May 26 20:58:40 2003
*/
ticks = time(NULL);
snprintf(buf, sizeof(buf), "%.24s\r\n", ctime(&ticks));
Write(connfd, buf, strlen(buf));
/* 5. Terminate connection
* The server closes its connection with the client by calling
* close(). This initiates the normal TCP connection termination
* sequence: a FIN is sent in each direction and each FIN is
* acknowledged by the other end.
*/
Close(connfd);
}
return 0;
}
//bool CListenSocket::StartListening()
//{
// bListening = true;
//
// // Creating the socket with SO_REUSEADDR may solve LowID issues if emule was restarted
// // quickly or started after a crash, but(!) it will also create another problem. If the
// // socket is already used by some other application (e.g. a 2nd emule), we though bind
// // to that socket leading to the situation that 2 applications are listening at the same
// // port!
// if (!Create(thePrefs.GetPort(), SOCK_STREAM, FD_ACCEPT, CT2CA(theApp.GetBindAddress()), FALSE/*bReuseAddr*/)) // Added by thilon on 2006.10.18, for [BindToAdapter]
// return false;
//
// // Rejecting a connection with conditional WSAAccept and not using SO_CONDITIONAL_ACCEPT
// // -------------------------------------------------------------------------------------
// // recv: SYN
// // send: SYN ACK (!)
// // recv: ACK
// // send: ACK RST
// // recv: PSH ACK + OP_HELLO packet
// // send: RST
// // --- 455 total bytes (depending on OP_HELLO packet)
// // In case SO_CONDITIONAL_ACCEPT is not used, the TCP/IP stack establishes the connection
// // before WSAAccept has a chance to reject it. That's why the remote peer starts to send
// // it's first data packet.
// // ---
// // Not using SO_CONDITIONAL_ACCEPT gives us 6 TCP packets and the OP_HELLO data. We
// // have to lookup the IP only 1 time. This is still way less traffic than rejecting the
// // connection by closing it after the 'Accept'.
//
// // Rejecting a connection with conditional WSAAccept and using SO_CONDITIONAL_ACCEPT
// // ---------------------------------------------------------------------------------
// // recv: SYN
// // send: ACK RST
// // recv: SYN
// // send: ACK RST
// // recv: SYN
// // send: ACK RST
// // --- 348 total bytes
// // The TCP/IP stack tries to establish the connection 3 times until it gives up.
// // Furthermore the remote peer experiences a total timeout of ~ 1 minute which is
// // supposed to be the default TCP/IP connection timeout (as noted in MSDN).
// // ---
// // Although we get a total of 6 TCP packets in case of using SO_CONDITIONAL_ACCEPT,
// // it's still less than not using SO_CONDITIONAL_ACCEPT. But, we have to lookup
// // the IP 3 times instead of 1 time.
//
// //if (thePrefs.GetConditionalTCPAccept() && !thePrefs.GetProxySettings().UseProxy) {
// // int iOptVal = 1;
// // VERIFY( SetSockOpt(SO_CONDITIONAL_ACCEPT, &iOptVal, sizeof iOptVal) );
// //}
//
// if (!Listen())
// return false;
//
// m_port = thePrefs.GetPort();
//
// //// Added by thilon on 2006.10.19, for IFWS - [ICSFirewall]
// //if(thePrefs.GetICFSupport())
// //{
// // bool bResult = (theApp.m_pFirewallOpener->OpenPort(m_port, NAT_PROTOCOL_TCP, EMULE_DEFAULTRULENAME_TCP, thePrefs.GetICFClearOnClose() /*|| thePrefs.GetUseRandomPorts()*/));
// // theApp.QueueLogLine(false, GetResString(bResult ? IDS_FO_TEMPTCP_S : IDS_FO_TEMPTCP_F), m_port);
// //}
//
// if(mapping)
// {
// theApp.RemoveUPnPNatPort(mapping);
// }
//
// if(thePrefs.GetUPnPNat())
// {
// mapping = new CUPnP::UPNPNAT_MAPPING;
// mapping->ref = &mapping;
//
// mapping->internalPort = mapping->externalPort = thePrefs.GetPort();
// mapping->protocol = CUPnP::UNAT_TCP;
// mapping->description = "TCP Port";
// if(theApp.AddUPnPNatPort(mapping, thePrefs.GetUPnPNatTryRandom()))
// thePrefs.SetUPnPTCPExternal(mapping->externalPort);
// }
// /*else
// {
// thePrefs.SetUPnPTCPExternal(thePrefs.GetPort());
// }*/
//
// bListening = true;
// return true;
//}
//upnp_end
bool CListenSocket::StartListening()
{
//ADDED by fengwen on 2007/03/21 <begin> : ·ÀÖ¹Öظ´Create
if (bPortListening)
return true;
//ADDED by fengwen on 2007/03/21 <end> : ·ÀÖ¹Öظ´Create
// Creating the socket with SO_REUSEADDR may solve LowID issues if emule was restarted
// quickly or started after a crash, but(!) it will also create another problem. If the
// socket is already used by some other application (e.g. a 2nd emule), we though bind
// to that socket leading to the situation that 2 applications are listening at the same
// port!
if (!Create(thePrefs.GetPort(), SOCK_STREAM, FD_ACCEPT, thePrefs.GetBindAddrA(), FALSE/*bReuseAddr*/))
return false;
// Rejecting a connection with conditional WSAAccept and not using SO_CONDITIONAL_ACCEPT
// -------------------------------------------------------------------------------------
// recv: SYN
// send: SYN ACK (!)
// recv: ACK
// send: ACK RST
// recv: PSH ACK + OP_HELLO packet
// send: RST
// --- 455 total bytes (depending on OP_HELLO packet)
// In case SO_CONDITIONAL_ACCEPT is not used, the TCP/IP stack establishes the connection
// before WSAAccept has a chance to reject it. That's why the remote peer starts to send
// it's first data packet.
// ---
// Not using SO_CONDITIONAL_ACCEPT gives us 6 TCP packets and the OP_HELLO data. We
// have to lookup the IP only 1 time. This is still way less traffic than rejecting the
// connection by closing it after the 'Accept'.
// Rejecting a connection with conditional WSAAccept and using SO_CONDITIONAL_ACCEPT
// ---------------------------------------------------------------------------------
// recv: SYN
// send: ACK RST
// recv: SYN
// send: ACK RST
// recv: SYN
// send: ACK RST
// --- 348 total bytes
// The TCP/IP stack tries to establish the connection 3 times until it gives up.
// Furthermore the remote peer experiences a total timeout of ~ 1 minute which is
// supposed to be the default TCP/IP connection timeout (as noted in MSDN).
// ---
// Although we get a total of 6 TCP packets in case of using SO_CONDITIONAL_ACCEPT,
// it's still less than not using SO_CONDITIONAL_ACCEPT. But, we have to lookup
// the IP 3 times instead of 1 time.
//if (thePrefs.GetConditionalTCPAccept() && !thePrefs.GetProxySettings().UseProxy) {
// int iOptVal = 1;
// VERIFY( SetSockOpt(SO_CONDITIONAL_ACCEPT, &iOptVal, sizeof iOptVal) );
//}
if (!Listen())
return false;
m_port = thePrefs.GetPort();
bPortListening = true;
bListening = true;
return true;
}
int
main(int argc, char **argv)
{
int sock_fd,msg_flags;
char readbuf[BUFFSIZE];
struct sockaddr_in servaddr, cliaddr;
struct sctp_sndrcvinfo sri;
struct sctp_event_subscribe evnts;
int stream_increment=1;
socklen_t len;
size_t rd_sz;
if (argc == 2)
stream_increment = atoi(argv[1]);
sock_fd = Socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Bind(sock_fd, (SA *) &servaddr, sizeof(servaddr));
/* include mod_serv06 */
bzero(&evnts, sizeof(evnts));
evnts.sctp_data_io_event = 1;
evnts.sctp_association_event = 1;
evnts.sctp_address_event = 1;
evnts.sctp_send_failure_event = 1;
evnts.sctp_peer_error_event = 1;
evnts.sctp_shutdown_event = 1;
evnts.sctp_partial_delivery_event = 1;
#ifdef UN_MOD
evnts.sctp_adaptation_layer_event = 1;
#else
evnts.sctp_adaption_layer_event = 1;
#endif
Setsockopt(sock_fd, IPPROTO_SCTP, SCTP_EVENTS,
&evnts, sizeof(evnts));
Listen(sock_fd, LISTENQ);
printf("Start waiting...\n");
for ( ; ; ) {
len = sizeof(struct sockaddr_in);
rd_sz = Sctp_recvmsg(sock_fd, readbuf, sizeof(readbuf),
(SA *)&cliaddr, &len,
&sri,&msg_flags);
if(msg_flags & MSG_NOTIFICATION) { // 表示收到一個事件,而非一個資料
print_notification(readbuf);
continue;
}
/* end mod_serv06 */
if(stream_increment) {
sri.sinfo_stream++;
// getsockopt用在sctp有問題!!先跳過!
// if(sri.sinfo_stream >= sctp_get_no_strms(sock_fd,(SA *)&cliaddr, len))
if(sri.sinfo_stream >= 100)
sri.sinfo_stream = 0;
}
Sctp_sendmsg(sock_fd, readbuf, rd_sz,
(SA *)&cliaddr, len,
sri.sinfo_ppid,
sri.sinfo_flags,
sri.sinfo_stream,
0, 0);
}
}
MidiInputDeviceMme::MidiInputDeviceMme(std::map<String,DeviceCreationParameter*> Parameters, void* pSampler) : MidiInputDevice(Parameters, pSampler) {
AcquirePorts(((DeviceCreationParameterInt*)Parameters["PORTS"])->ValueAsInt());
if (((DeviceCreationParameterBool*)Parameters["ACTIVE"])->ValueAsBool()) {
Listen();
}
}
int main(int argc, char** argv) {
SOCKET s, s_acceptor; // socket and acceptor socket
struct sockaddr_in saddr, caddr; // server and client address structures
uint16_t lport_n, lport_h; // server port number by htons()
int backlog = 2; // pending requests queue length
socklen_t caddr_len; // client address length
int retValue; // service() returning status
int i;
/* Check number of arguments */
checkArg(argc, 3);
/* The number of children */
n_children = atoi(argv[2]);
if (n_children > 10) {
fprintf(stderr, "- ERROR. Children must be at most 10.\n");
return -1;
}
/* Alloc memory for pids */
pids = (pid_t*)malloc(n_children*sizeof(pid_t));
if (pids == NULL) {
fprintf(stderr, "- ERROR allocating pids.\n");
return -1;
}
/* Instantiate a signal handler for SIGINT */
Signal(SIGINT, sigintHandler);
/* Initialize the socket API (only for Windows) */
SockStartup();
/* Set port number */
lport_n = setPortarg(argv[1], &lport_h);
/* Create the socket */
fprintf(stdout, "Creating the socket...\n");
s = Socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
fprintf(stdout, "- OK. Socket fd: %d\n", s);
/* Prepare server address structure */
saddr.sin_family = AF_INET;
saddr.sin_port = lport_n;
saddr.sin_addr.s_addr = INADDR_ANY;
/* Bind the socket to a local network address */
fprintf(stdout, "Binding the socket...\n");
Bind(s, (struct sockaddr*) &saddr, sizeof(saddr));
fprintf(stdout, "- OK. Socket bound.\n");
/* Listen to connection requests */
fprintf(stdout, "Listen at socket %d with backlog = %d...\n", s, backlog);
Listen(s, backlog);
fprintf(stdout, "- OK. Socket is listening on ");
showAddress(&saddr);
for (i=0; i<n_children; i++) {
if ((pids[i] = fork()) < 0) {
fprintf(stderr, "- ERROR. fork() failed.\n");
} else if ((pids[i]) > 0) {
// The parent
} else {
// The child
while(1) {
/* Accept connection requests */
br();
caddr_len = sizeof(struct sockaddr_in);
s_acceptor = Accept(s, (struct sockaddr*) &caddr, &caddr_len);
fprintf(stdout, "- New connection from client ");
showAddress(&caddr);
retValue = service(s_acceptor);
closesocket(s_acceptor);
fprintf(stdout, "--- Connection closed by %s", (retValue == 0) ? "client\n" : "server\n");
br();
}
}
}
while(1) {
pause();
}
return 0;
}
PlayField::PlayField(Hiscore *h, View *parent, ScrollText *st) : View(Rect(0,0,1,1)), Message(){ //-.25f,-.25f,1.25f,1.25f)){
// Listen("/Devices/Input/Dialogic");
SetClearState(false);
#ifdef NEWSCALE
parent->Apply(this);
players = new DynamicArray();
channels = new DynamicArray();
int dir = 0;
int x = 1;
int y = 1;
int xr = 2;
int yb = 2;
int xl = 0;
int yt = 0;
int n = 1;
for(int _x=0; _x<4; _x++){
for(int _y=0; _y<4; _y++){
Player *pl = new Player(h,Rect((float(x)/4.0f),(float(y)/4.0f),(float(x+1)/4.0f),(float(y+1)/4.0f)),st,n++);
Apply(pl);
players->Add(pl);
channels->Add(0);
switch(dir){
case 0: if(++x==xr){ dir++; xr++; } break;
case 1: if(++y==yb){ dir++; yb++; } break;
case 2: if(--x==xl){ dir++; xl--; } break;
case 3: if(--y==yt){ dir=0; yt--; } break;
}
}
}
#else
parent->Apply(this);
players = new DynamicArray();
channels = new DynamicArray();
int dir = 0;
int x = 1;
int y = 1;
int xr = 2;
int yb = 2;
int xl = 1;
int yt = 1;
int n = 1;
for(int _x=0; _x<4; _x++){
for(int _y=0; _y<4; _y++){
Player *pl = new Player(h,Rect((float(x)/4.0f),(float(y)/4.0f),(float(x+1)/4.0f),(float(y+1)/4.0f)),st,n++);
Apply(pl);
players->Add(pl);
channels->Add(0);
switch(dir){
case 0: if(++x==xr){ dir++; xr++; } break;
case 1: if(++y==yb){ dir++; yb++; } break;
case 2: if(--x==xl){ dir++; xl--; } break;
case 3: if(--y==yt){ dir=0; yt--; x--; y--; } break;
}
}
}
#endif
foo = 0;
player_count=0;
zoom = .5f;
xz = yz = 0;
Listen("/Devices/Input/Dialogic");
}
void ServerThread::Resume() {
#ifdef _WIN32
threadHandle = (HANDLE)_beginthreadex(NULL, 0, ExecuteServerThread, this, 0, &threadId);
if(threadHandle == 0) {
#else
int iRet = pthread_create(&threadId, NULL, ExecuteServerThread, this);
if(iRet != 0) {
#endif
AppendDebugLog("%s - [ERR] Failed to create new ServerThread\n", 0);
}
}
//---------------------------------------------------------------------------
void ServerThread::Run() {
bActive = true;
#ifdef _WIN32
SOCKET s;
#else
int s;
#endif
sockaddr_storage addr;
socklen_t len = sizeof(addr);
#ifndef _WIN32
struct timespec sleeptime;
sleeptime.tv_sec = 0;
sleeptime.tv_nsec = 1000000;
#endif
while(bTerminated == false) {
s = accept(server, (struct sockaddr *)&addr, &len);
if(iSuspendTime == 0) {
if(bTerminated == true) {
#ifdef _WIN32
if(s != INVALID_SOCKET)
shutdown(s, SD_SEND);
closesocket(s);
#else
if(s != -1)
shutdown(s, SHUT_RDWR);
close(s);
#endif
continue;
}
#ifdef _WIN32
if(s == INVALID_SOCKET) {
if(WSAEWOULDBLOCK != WSAGetLastError()) {
#else
if(s == -1) {
if(errno != EWOULDBLOCK) {
if(errno == EMFILE) { // max opened file descriptors limit reached
sleep(1); // longer sleep give us better chance to have free file descriptor available on next accept call
} else {
#endif
clsEventQueue::mPtr->AddThread(clsEventQueue::EVENT_SRVTHREAD_MSG,
("[ERR] accept() for port "+string(ui16Port)+" has returned error.").c_str());
}
#ifndef _WIN32
}
#endif
} else {
if(isFlooder(s, addr) == true) {
#ifdef _WIN32
shutdown(s, SD_SEND);
closesocket(s);
#else
shutdown(s, SHUT_RDWR);
close(s);
#endif
}
#ifdef _WIN32
::Sleep(1);
#else
nanosleep(&sleeptime, NULL);
#endif
}
} else {
uint32_t iSec = 0;
while(bTerminated == false) {
if(iSuspendTime > iSec) {
#ifdef _WIN32
::Sleep(1000);
#else
sleep(1);
#endif
if(bSuspended == false) {
iSec++;
}
continue;
}
#ifdef _WIN32
EnterCriticalSection(&csServerThread);
#else
pthread_mutex_lock(&mtxServerThread);
#endif
iSuspendTime = 0;
#ifdef _WIN32
LeaveCriticalSection(&csServerThread);
#else
pthread_mutex_unlock(&mtxServerThread);
#endif
if(Listen(true) == true) {
clsEventQueue::mPtr->AddThread(clsEventQueue::EVENT_SRVTHREAD_MSG,
("[SYS] Server socket for port "+string(ui16Port)+" sucessfully recovered from suspend state.").c_str());
} else {
Close();
}
break;
}
}
}
bActive = false;
}
//---------------------------------------------------------------------------
void ServerThread::Close() {
bTerminated = true;
#ifdef _WIN32
closesocket(server);
#else
shutdown(server, SHUT_RDWR);
close(server);
#endif
}
//---------------------------------------------------------------------------
void ServerThread::WaitFor() {
#ifdef _WIN32
WaitForSingleObject(threadHandle, INFINITE);
#else
if(threadId != 0) {
pthread_join(threadId, NULL);
threadId = 0;
}
#endif
}
int main(void)
{
unsigned int sockaddr;
unsigned char mysocket;
unsigned int rsize;
/* Initialize the UART for ATmega168 96008N1 */
uart_init();
stdout = &uart_stdout; //Required for printf init
mysocket = 0; // magic number! declare the socket number we will us
sockaddr = W5100_SKT_BASE(mysocket); // calc address of W5100 register set for this socket
puts("AVR Ethernet\r\n");
/*
* Initialize the ATmega168 SPI subsystem
*/
CS_PORT |= (1 << CS_BIT); // pull CS pin high
CS_DDR |= (1 << CS_BIT); // now make it an output
SPI_PORT = SPI_PORT | (1 << PORTB2); // make sure SS is high
SPI_DDR = (1 << PORTB3) | (1 << PORTB5) | (1 << PORTB2); // set MOSI, SCK and SS as output, others as input
SPCR = (1 << SPE) | (1 << MSTR); // enable SPI, master mode 0
SPSR |= (1 << SPI2X); // set the clock rate fck/2
/*
* Load up the callback block, then initialize the Wiznet W5100
*/
my_callbacks._select = &my_select; // callback for selecting the W5100
my_callbacks._xchg = &my_xchg; // callback for exchanging data
my_callbacks._deselect = &my_deselect; // callback for deselecting the W5100
my_callbacks._reset = &my_reset; // callback for hardware-reset of the W5100
W51_register(&my_callbacks); // register our target-specific W5100 routines with the W5100 library
W51_init(); // now initialize the W5100
/*
* Configure the W5100 device to handle PING requests.
* This requires configuring the chip, not a specific socket.
*/
W51_config(&my_cfg); // config the W5100 (MAC, TCP address, subnet, etc
puts("Debug: AVR Ethernet after W5100 config\r\n");
/*
* The main loop. Control stays in this loop forever, processing any received packets
* and sending any requested data.
*/
while (1) {
switch (W51_read(sockaddr + W5100_SR_OFFSET)) // based on current status of socket...
{
case W5100_SKT_SR_CLOSED: // if socket is closed...
if (OpenSocket(mysocket, W5100_SKT_MR_TCP, HTTP_PORT) == mysocket) // if successful opening a socket...
{
Listen(mysocket);
_delay_ms(1);
}
break;
case W5100_SKT_SR_ESTABLISHED: // if socket connection is established...
rsize = ReceivedSize(mysocket); // find out how many bytes
if (rsize > 0) {
if (Receive(mysocket, buf, rsize) != W5100_OK)
break; // if we had problems, all done
/*
* Add code here to process the payload from the packet.
*
* For now, we just ignore the payload and send a canned HTML page so the client at least
* knows we are alive.
*/
strcpy_P((char *)buf,PSTR("HTTP/1.0 200 OK\r\nContent-Type: text/html\r\nPragma: no-cache\r\n\r\n"));
strcat_P((char *)buf,PSTR("<html>\r\n<body>\r\n"));
strcat_P((char *)buf,PSTR("<title>Title</title>\r\n"));
strcat_P((char *)buf,PSTR("<p>Hello world</p>\r\n"));
strcat_P((char *)buf,PSTR("</body>\r\n</html>\r\n"));
if (Send(mysocket, buf, strlen((char *)buf)) == W5100_FAIL) break; // just throw out the packet for now
DisconnectSocket(mysocket);
} else // no data yet...
{
_delay_us(10);
}
break;
case W5100_SKT_SR_FIN_WAIT:
case W5100_SKT_SR_CLOSING:
case W5100_SKT_SR_TIME_WAIT:
case W5100_SKT_SR_CLOSE_WAIT:
case W5100_SKT_SR_LAST_ACK:
CloseSocket(mysocket);
break;
}
}
return 0;
}
void BaseServer::StartWeb(int port)
{
m_ServWebSock.sockfd = Listen(port);
m_ServWebSock.portno = port;
if(m_ServWebSock.sockfd > 0){
FD_SET(m_ServWebSock.sockfd,&m_setWebSock);
if(m_iWebMaxSock < m_ServWebSock.sockfd)
m_iWebMaxSock = m_ServWebSock.sockfd;
cout<<GetSystemTime()<<": Web交互端口 "<<dec<<port<<" 开启成功."<<endl;
}
else{
cout<<GetSystemTime()<<": "<<port<<" 端口开启失败，程序退出."<<endl;
exit(1);
}
int clnt_sock;
struct sockaddr_in clnt_addr;
socklen_t clnt_addr_size = sizeof(clnt_addr);
memset(&clnt_addr,0,sizeof(clnt_addr));
fd_set tempsets;
struct timeval timeout;
timeout.tv_sec = 5;
timeout.tv_usec = 0;
int result = 0;
size_t buflen = MAXPACKLEN;
char buf[MAXPACKLEN] = {0};
while(true)
{
FD_ZERO(&tempsets);
tempsets = m_setWebSock;
timeout.tv_sec = 5;
timeout.tv_usec = 0;
result = select(m_iWebMaxSock+1,&tempsets,NULL,NULL,&timeout);
if(result > 0)
{
if(FD_ISSET(m_ServWebSock.sockfd,&tempsets))
{
clnt_sock = accept(m_ServWebSock.sockfd,(struct sockaddr*)&clnt_addr,&clnt_addr_size);
if(clnt_sock != -1)
{
if(m_bIsConnWeb){
FD_CLR(m_ClntWebSock.sockfd,&m_setWebSock);
close(m_ClntWebSock.sockfd);
}
m_ClntWebSock.sockfd = clnt_sock;
FD_SET(m_ClntWebSock.sockfd,&m_setWebSock);
if(m_iWebMaxSock < m_ClntWebSock.sockfd)
m_iWebMaxSock = m_ClntWebSock.sockfd;
m_ClntWebSock.portno = m_ServWebSock.portno;
memcpy(m_ClntWebSock.ipaddr,inet_ntoa(clnt_addr.sin_addr),16);
m_bIsConnWeb = true;
#ifndef NO_DEBUG
cout<<GetSystemTime()<<": Web Client Connected "<<m_ClntWebSock.ipaddr<<endl;
#endif
}
}
if(m_bIsConnWeb)
{
if(FD_ISSET(m_ClntWebSock.sockfd,&tempsets))
{
while(true)
{
memset(buf,0,buflen);
int len = recvn(m_ClntWebSock.sockfd,buf,buflen);
if(len == 6)
{
if((buf[0]&0xFF) == 0xAA && (buf[1]&0xFF) == 0xAA)
{
/********************添加获取站点信息及截止时间功能***************************/
g_logs.WriteLog("收到采集数据截止日期更新命令.");
pthread_mutex_lock(&m_infoMutex);
iTimeSpace = GetConfigureFromDatabase();
if(iTimeSpace == -1)
{
char space[4] = {0};
#ifndef NO_DEBUG
cout<<"获取数据库截止日期配置失败，从本地读取"<<endl;
#endif
g_logs.WriteLog("获取数据库截止日期配置失败，从本地读取.");
GetConfigureString("TIMESPACE",space,4,"30");
iTimeSpace = atoi(space);
}
pthread_mutex_unlock(&m_infoMutex);
cout<<"超过此截止天数的数据不再接收："<<dec<<iTimeSpace<<" 天"<<endl;
g_logs.WriteLog("超过此截止天数的数据不再接收：%d",iTimeSpace);
/***************************************************** */
}
}
else if(len == 0)
{
FD_CLR(m_ClntWebSock.sockfd,&m_setWebSock);
close(m_ClntWebSock.sockfd);
cout<<GetSystemTime()<<": Web Client DisConnect "<<m_ClntWebSock.ipaddr<<endl;
m_bIsConnWeb = false;
break;
}
else if(len < 0)
{
break;
}
}
}
}
}
else if(result < 0)
{
cout<<GetSystemTime()<<": Web select() error!"<<endl;
}
}
}
int main (void){
char * req = NULL;
char mess[BUFFSIZE];
char * data = NULL;
char file[MAX_FILE_SIZE];
int sockNum = 0, recSock = 0;
int i = 0;
int rc=0, rcr = 0;
int accepted = 0;
int cs=0;
int chunkiterator = 0;
int offset= 0;
struct sockaddr_in from;
socklen_t fromlen;
FILE * fp = NULL;
int bytecounter = 0;
while(1){
req = NULL;
for(i = 0; i < BUFFSIZE ; i++) mess[i] = 0;
data = NULL;
for(i = 0; i < MAX_FILE_SIZE ; i++) file[i] = 0;
sockNum = 0;
recSock = 0;
i = 0;
rc=0;
rcr = 0;
accepted = 0;
cs=0;
chunkiterator = 0;
offset= 0;
fromlen = 0;
fp = NULL;
bytecounter = 0;
//build the request string
req = buildReq(NUMCHUNKS, DATAPORT, FILENAME);
//report request
printf("sent request for \"%s\" in %d chunks over port %d\n", FILENAME, NUMCHUNKS, DATAPORT);
//initialize buffers
//open socket
sockNum = Open("localhost", 11708);
if (DEBUG) fprintf(stderr, "Socket Open\n");
//start listening for response
recSock = Listen(DATAPORT);
//send the request
rc = send( sockNum , req , (strlen(&req[4])+ 4) , 0 ) ;
printf( "Sent %d\n%s\n" , rc , req ) ;
//clean up
free(req);
req = NULL;
close(sockNum);
//start loop for each connection
for (chunkiterator = 0; chunkiterator < NUMCHUNKS; chunkiterator++){
//initialize variables
for(i = 0; i < BUFFSIZE ; i++) mess[i] = 0;
accepted = 0;
offset =0;
//try to accept a connection
while (!accepted){
if (DEBUG) fprintf(stderr, "trying to accept connection. accepted = %d\n", accepted);
fromlen = sizeof(from);
cs = accept( recSock , (struct sockaddr *)&from , &fromlen );
if (DEBUG) fprintf(stderr, "cs = %d\n", cs);
//if it failed, report it
//if it succeeded, raise tthe flafg
if (cs == -1){
perror("accept:");
}else{
(accepted = 1);
}
}
if (DEBUG) fprintf(stderr, "done accepting. cs = %d\n", cs);
do {
//cleart buffer
if (DEBUG) fprintf(stderr, "clearing buffer\n");
for(i = 0; i < BUFFSIZE ; i++) mess[i] = 0;
//read from the socket into the buffer
rc = recv( cs , &mess , sizeof(mess) , 0 ) ;
if (DEBUG) fprintf(stderr, "finished reading %d bytes from socket. offset is currently %d\n", rc, offset);
if (rc == -1)
perror("recv");
//if something was in fact read
if (rc){
//print it out
//if (DEBUG) fprintf(stderr, "recieved: [%s]\n", mess);
//if this is the start of the packet find the offset
if (offset == 0){
offset = ntohl(*((int*)mess));
if(DEBUG) fprintf(stderr, "firstoffset = %d\n", offset);
data = &mess[4];
rcr = rc - 4;
// otherwise deal with it as normal
} else {
data = mess;
rcr = rc;
}
if (DEBUG) fprintf(stderr, "done calculating offset and data pointers\n");
//copy the data character by character into the file buffer
for(i = 0; i < rcr; i++){
//if (DEBUG) fprintf(stderr, "112: writing \'%c\' from index %d in buffer to index %d in file\n", data[i], i, *offset+i);
file[offset] = data[i];
offset++;
bytecounter++;
}
if (DEBUG) fprintf(stderr, "done copying data\n");
}
} while (rc);
close(cs);
}
//fprintf(stderr, "Final File:\n%s\nEnd of File\n", file);
fp = fopen(WRITENAME, "w+");
fwrite(file, bytecounter, 1, fp);
fclose(fp);
printf("wrote %d bytes to the file\n", bytecounter);
close(recSock);
usleep(5000000);
}
return 0;
}
void BaseServer::StartTrans(int port)
{
m_ServTransSock.sockfd = Listen(port);
m_ServTransSock.portno = port;
if(m_ServTransSock.sockfd > 0){
FD_SET(m_ServTransSock.sockfd,&m_setTransSock);
if(m_iTransMaxSock < m_ServTransSock.sockfd)
m_iTransMaxSock = m_ServTransSock.sockfd;
cout<<GetSystemTime()<<": 转发端口 "<<dec<<port<<" 开启成功."<<endl;
}
else{
cout<<GetSystemTime()<<": "<<port<<" 端口开启失败，程序退出."<<endl;
exit(1);
}
int clnt_sock;
struct sockaddr_in clnt_addr;
socklen_t clnt_addr_size = sizeof(clnt_addr);
memset(&clnt_addr,0,sizeof(clnt_addr));
fd_set tempsets;
struct timeval timeout;
timeout.tv_sec = 5;
timeout.tv_usec = 0;
int result = 0;
size_t buflen = MAXPACKLEN;
char buf[MAXPACKLEN] = {0};
while(true)
{
FD_ZERO(&tempsets);
tempsets = m_setTransSock;
result = select(m_iTransMaxSock+1,&tempsets,NULL,NULL,&timeout);
if(result > 0)
{
if(FD_ISSET(m_ServTransSock.sockfd,&tempsets))
{
clnt_sock = accept(m_ServTransSock.sockfd,(struct sockaddr*)&clnt_addr,&clnt_addr_size);
if(clnt_sock != -1)
{
pthread_mutex_lock(&m_mutxTransSock);
if(m_bIsConn){
FD_CLR(m_ClntTransSock.sockfd,&m_setTransSock);
close(m_ClntTransSock.sockfd);
}
m_ClntTransSock.sockfd = clnt_sock;
FD_SET(m_ClntTransSock.sockfd,&m_setTransSock);
if(m_iTransMaxSock < m_ClntTransSock.sockfd)
m_iTransMaxSock = m_ClntTransSock.sockfd;
m_ClntTransSock.portno = m_ServTransSock.portno;
memcpy(m_ClntTransSock.ipaddr,inet_ntoa(clnt_addr.sin_addr),16);
m_bIsConn = true;
m_threadpool.setTransInfo(m_ClntTransSock.sockfd,m_bIsConn);
pthread_mutex_unlock(&m_mutxTransSock);
#ifndef NO_DEBUG
cout<<GetSystemTime()<<": Trans Client Connected "<<m_ClntTransSock.ipaddr<<endl;
#endif
}
}
if(m_bIsConn)
{
if(FD_ISSET(m_ClntTransSock.sockfd,&tempsets))
{
while(true)
{
pthread_mutex_lock(&m_mutxTransSock); /* */
int len = recvn(m_ClntTransSock.sockfd,buf,buflen);
memset(buf,0,buflen);
if(len == 0)
{
FD_CLR(m_ClntTransSock.sockfd,&m_setTransSock);
close(m_ClntTransSock.sockfd);
#ifndef NO_DEBUG
cout<<GetSystemTime()<<": Trans Client DisConnect "<<m_ClntTransSock.ipaddr<<endl;
#endif
m_bIsConn = false;
m_threadpool.setTransInfo(0,m_bIsConn);
break;
}
else if(len < 0)
{
break;
}
}
pthread_mutex_unlock(&m_mutxTransSock);
}
}
}
else if(result < 0)
{
#ifndef NO_DEBUG
cout<<GetSystemTime()<<": Trans select() error!"<<endl;
#endif
}
}//end of while
}
int main()
{
int Listenfd,connfd;
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
int val,len;
pthread_t recv_thread, send_thread,getinfo_thread;
int res;
Listenfd = Socket(AF_INET,SOCK_STREAM,0);
val = 1;
len = sizeof(int);
Setsockopt(Listenfd, SOL_SOCKET, SO_REUSEPORT,(void *)&val, len);
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Bind(Listenfd,(SA*)&servaddr,sizeof(servaddr));
Listen(Listenfd,LISTENQ);
for( ; ;){
val = 1;
len = sizeof(int);
Setsockopt(Listenfd, SOL_SOCKET, SO_DEBUG,(void *)&val, len);
//sleep(8);
clilen = sizeof(cliaddr);
connfd = Accept(Listenfd,(SA*)&cliaddr,&clilen);
openflag=1;
res = pthread_create(&getinfo_thread, NULL, get_info, (void *)(&connfd));
if (res != 0)
{
perror("Thread creation failed!");
exit(EXIT_FAILURE);
}
res = pthread_create(&recv_thread, NULL, recv_function, (void *)(&connfd));
if (res != 0)
{
perror("Thread creation failed!");
exit(EXIT_FAILURE);
}
res = pthread_create(&send_thread, NULL, send_function, (void *)(&connfd));
if (res != 0)
{
perror("Thread creation failed!");
exit(EXIT_FAILURE);
}
//sleep(200);
//printf("close\n");
//交由系统回收关闭文件描述符
//Close(connfd);
}
return 0;
}
int main (int argc, char **argv) {
int listenfd, connfd, n;
struct sockaddr_in servaddr, clientaddr;
//char buf[MAXDATASIZE];
char recvline[MAXLINE + 1];
//time_t ticks;
char error[MAXLINE + 1];
//para obter o endereço do socket
socklen_t addrlen = sizeof(clientaddr);
//valor temporario para o id dos processos filhos
pid_t child_pid;
if (argc != 3) { //caso o usuário não tenha fornecido um IP e a porta para conexão
strcpy(error,"uso: ");
strcat(error,argv[0]);
strcat(error," <Porta> <listen Backlog value");
perror(error);
exit(1);
}
//Inicializa o socket
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
//Preenche informacoes relativas ao socket do servidor
Servaddr(&servaddr, argv[1]);
//Associa socket com um ip e uma porta
Bind(listenfd, &servaddr);
//Diz para o socket ouvir conexoes
Listen(listenfd, atoi(argv[2]));
//Registra funcao de handler
Signal(SIGCHLD, sig_child);
//Prepara arquivo de log
time_t now;
char timeString[256];
FILE *log;
while (1){
//Retarda a remoção dos sockets da fila de conexões completas
sleep(10);
//Aceita uma conexao e atribui a um socket
if ((connfd = Accept(listenfd, &clientaddr, &addrlen)) < 0){
if (errno = EINTR){
continue;
}
else{
err_sys("accept error");
}
}
//Registra conexao
time(&now);
strftime (timeString, 256, "%Y-%m-%d %H:%M:%S", localtime(&now));
log = fopen("log.txt","a");
if (log == NULL){
printf ("Failed to log entry.\n");
}
else{
fprintf(log,"[%s] %s:%u conectou-se\n",
timeString,
inet_ntoa(clientaddr.sin_addr),
ntohs(clientaddr.sin_port));
}
fclose(log);
// Cria subprocesso que lidara com essa conexao
if ((child_pid = fork()) == 0) { //Processo filho
//Fecha socket para ouvir novas conexoes
close(listenfd);
//Imprime o endereço do socket local
getsockname(connfd,(struct sockaddr *)&servaddr, &addrlen);
printf("Endereço local: %s:%u \n",inet_ntoa(servaddr.sin_addr), ntohs(servaddr.sin_port));
//Imprime o endereço do socket remoto
printf("Endereço do cliente: %s:%u \n",
inet_ntoa(clientaddr.sin_addr),
ntohs(clientaddr.sin_port));
while(1) {
//Executa comandos enviados pelo cliente
n = read(connfd, recvline, MAXLINE);
if (n == 0){
// socket disconnected
break;
}
if (strcmp(recvline,"bye\n") == 0){
break;
}
else {
char outputbuffer[MAXLINE + 1];
recvline[n] = 0;
FILE* p = popen(recvline,"r");
if (p == NULL){
printf("Erro executando comando.\n Valor de retorno: %d\n",
pclose(p) / 256);
}
else{
sprintf(outputbuffer, "(%s:%u) %s",
inet_ntoa(clientaddr.sin_addr),
ntohs(clientaddr.sin_port),
recvline);
printf("%s",outputbuffer);
while (fgets(outputbuffer,MAXLINE+1,p)){
//printf("%s",outputbuffer);
write(connfd, outputbuffer, strlen(outputbuffer));
}
pclose(p);
}
}
}
// Registra desconexao
time(&now);
strftime (timeString, 256, "%Y-%m-%d %H:%M:%S", localtime(&now));
log = fopen("log.txt","a");
if (log == NULL){
printf ("Falha no registro\n");
}
else{
fprintf(log,"[%s] %s:%u desconectou-se\n",
timeString,
inet_ntoa(clientaddr.sin_addr),
ntohs(clientaddr.sin_port));
}
fclose(log);
//Fecha socket da conexao
printf("Cliente %s:%u desconectou-se.\n",
inet_ntoa(clientaddr.sin_addr),
ntohs(clientaddr.sin_port));
close(connfd);
return(0);
}
printf("Numero do processo filho: %d\n", child_pid);
close(connfd);
}
}
CWebServerSocket::CWebServerSocket(CWebServer* pWebServer, int port)
: m_pWebServer(pWebServer)
{
Create(port);
Listen();
}
void socket_servers()
{
int ascolto, conn_fd; //qui vengono definiti i descrittori del socket per il serverd
struct sockaddr_in server, serverd;//qui vengono definite le strutture per assegnare una porta e un ip al socket
int i=0;
socklen_t len;//qui si definisce len come un tipo intero di alemno 32 bit
pid_t pid;//qui viene definito il descrittore del processo figlio
int pool[10];
int scelta=0;
ascolto = Socket(AF_INET, SOCK_STREAM, 0);//qui viene creato il socket, al suo interno troviamo 3 parametri(il dominio,il tipo di socket(nel nostro caso SOCK_STREAM è un canale bidirezionale e sequenziale),infine il protocollo che viene inizializzato a 0)
server.sin_family= AF_INET;//qui con AF_INET definiamo che tipo di protocollo usare(IPV4)
server.sin_addr.s_addr = inet_addr("127.0.0.5");//qui impostiamo l'indirizzo del servers,convertendo tramite htonl un numero a 32 bit dal formato macchina a quello di rete
server.sin_port= htons(8888);//qui impostiamo la porta per le comunicazioni con questo server,htons converte un numero a 16bit dal formato macchina a quello di rete
Bind(ascolto, (struct sockaddr *) &server, sizeof(server));//qui tramite la Bind assegnamo un indirizzo al socket
Listen(ascolto, 10);//qui mettiamo in ascolto il server e definiamo quante connessioni pendenti ci posso essere al massimo
printf("IL SERVERS AVVIATO..\n");
while(1)//Nel momento che entriamo nel while il server si manterrà sempre in ascolto
{
len = sizeof(serverd);
conn_fd = Accept(ascolto, (struct sockaddr *)&serverd, &len);//La funzione accept permette al server di accettare connessioni in entrata
char *ip = inet_ntoa(serverd.sin_addr);//qui otteniamo l'indirizzo del client che si è connesso
if (Fork() == 0)
{
close(ascolto);//qui si chiude il descrittore della listen
printf("Ip del del client connesso:%s\n",ip);//qui conosciamo ip del nuovo client connesso al server
FullRead(conn_fd,(char *)&scelta, sizeof(scelta));
if(scelta==1){//tramite questo if verifichiamo chi si è connesso al servers, nel caso si effettua una chiamata alla funzione docenti
docenti(conn_fd, serverd);
}
else if(scelta==2){//tramite questo if verifichiamo se il client che si è connesso è il clients, nel caso si effettua una chiamata alla funzione segreteria_studenti
segreteria_studenti(conn_fd, serverd);
}
}
else //qui siamo nel processo padre
close (conn_fd);//qui si chiude la connesione al ritorno del figlio
}
}
int main(int argc, char argv**)
{
socklen_t len;
int n, listenfd, connfd, char_in, count = 0;
struct sockaddr_in servaddr, cliaddr;
char buff[40], wbuff[MAXLINE], rbuff[MAXLINE], cmd[16], path1[64]=".", path[64], vers[16];
FILE * hFile;
if(argc != 2)
{
err_quit("usage: a.out <Port>");
}
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.sin_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(atoi(argv[1]));
Bind(listenfd, (SA*) &servaddr, sizeof(servaddr));
Listen(listenfd, LISTENQ);
for( ; ; )
{
len = sizeof(cliaddr);
connfd = Accept(listenfd, (SA*) &cliaddr, &len);
printf("\nConnection from %s, port %d\n", Inet_ntop(AF_INET, &cliaddr.sin_addr, buff, sizeof(buff)) ntohs(cliaddr.sin_port));
while((n = read(connfd, rbuff, MAXLINE)) > 0)
{
rbuff[n] = 0;
if(fputs(rbuff, stdout) == 0)
{
err_sys("fputs error");
}
if(strstr(rbuff,"\r\n\r\n") > 0)
{
break;
}
}
if(n < 0)
{
err_sys("read error");
}
sscanf(rbuff, "%s %s %s", cmd, path, vers);
strcat(path1, path);
if(strcmp(path1, "./") == 0)
{
strcpy(path1, "./index.html");
}
hFile = fopen(path1, "r");
if(hFile == NULL)
{
hFIle = fopen("error.html", "r");
}
strcpy(wbuff,"");
while((char_in = fgetc(hFile)) != EOF)
{
wbuff(count) = char_in;
count++;
}
wbuff(count) = 0;
Write(connfd, wbuff, strlen(wbuff));
count = 0;
fclose(hFile);
strcpy(path1,".");
Close(connfd);
}
}
bool Listen(V4addr &host, int maxcon) {
m_LA = host;
return Listen(maxcon);
}
int main()
{
int Listenfd,connfd;
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
int val,len,i=0,last_in = 0,last_out = 0;;
struct tcp_info_user info;
char writebuf[TRANSSIZE];
Listenfd = Socket(AF_INET,SOCK_STREAM,0);
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Bind(Listenfd,(SA*)&servaddr,sizeof(servaddr));
Listen(Listenfd,LISTENQ);
for( ; ;){
clilen = sizeof(cliaddr);
connfd = Accept(Listenfd,(SA*)&cliaddr,&clilen);
val = 1;
len = sizeof(int);
Setsockopt(connfd, SOL_TCP, TCP_CORK,(void *)&val, len);
val = 1;
len = sizeof(int);
Setsockopt(connfd, SOL_SOCKET, SO_DEBUG,(void *)&val, len);
snprintf(writebuf,TRANSSIZE,"world01");
Write(connfd,writebuf,8);
snprintf(writebuf,TRANSSIZE,"world02");
Write(connfd,writebuf,8);
sleep_ms(200);
val = 1;
len = sizeof(int);
Setsockopt(connfd, SOL_TCP, TCP_NODELAY,(void *)&val, len);
snprintf(writebuf,TRANSSIZE,"world03");
Write(connfd,writebuf,8);
snprintf(writebuf,TRANSSIZE,"world04");
Write(connfd,writebuf,8);
sleep_ms(200);
snprintf(writebuf,TRANSSIZE,"world05");
Write(connfd,writebuf,50);
i = 0;
while(i < 100*200)
{
len = sizeof(info);
Getsockopt(connfd, SOL_TCP, TCP_INFO,(void *)&info, (socklen_t *)&len);
if( (last_in != info.tcpi_segs_in) || (last_out != info.tcpi_segs_out) )
{
//sleep_ms(1);
len = sizeof(info);
Getsockopt(connfd, SOL_TCP, TCP_INFO,(void *)&info, (socklen_t *)&len);
printftcpinfo(&info);
printf("i=%d\n",i);
last_in = info.tcpi_segs_in;
last_out = info.tcpi_segs_out;
}
sleep_ms(1);
i++;
}
sleep(200);
printf("close\n");
Close(connfd);
}
return 0;
}
void main() {
struct hw_ip_pair *hi_pair;
char IP_str[20], cache_hw_addr[6];
fd_set rset;
int cache_ifindex, cache_hatype;
struct hw_addr HWaddr;
hi_pair = malloc(sizeof(struct hw_ip_pair));
get_hw_ip_pair(hi_pair);
printf("My IP :%s,\t HW addr", hi_pair->ip_addr);
print_mac_to_string(hi_pair->hw_addr);
printf("\n");
int pf_pack_sockfd = create_pf_pack_socket();
void* buffer = (void*)malloc(ETH_FRAME_LEN);
int listen_sockfd, conn_sockfd, clilen, n;
struct sockaddr_un servaddr, cliaddr;
char sendline[MAXLINE], recvline[MAXLINE];
struct sockaddr_in *destIP = malloc(sizeof(struct sockaddr_in));
char ip_addr[20];
struct arp_packet *arp_req = malloc(sizeof(struct arp_packet));
struct arp_packet *arp_rep = malloc(sizeof(struct arp_packet));
struct arp_packet *arp_recv = malloc(sizeof(struct arp_packet));
struct sockaddr_ll socket_address;
int ll_len = sizeof(struct sockaddr_ll);
int i=0;
listen_sockfd = Socket(AF_LOCAL, SOCK_STREAM, 0);
unlink(SUN_PATH_ARP);
bzero(&servaddr, sizeof(servaddr));
servaddr.sun_family = AF_LOCAL;
strcpy(servaddr.sun_path, SUN_PATH_ARP);
Bind(listen_sockfd, (SA *) &servaddr, sizeof(servaddr));
Listen(listen_sockfd, LISTENQ);
int lookup_flag=0;
clilen = sizeof(struct sockaddr_un);
while(1) {
FD_ZERO(&rset);
FD_SET(listen_sockfd, &rset);
FD_SET(pf_pack_sockfd, &rset);
FD_SET(conn_sockfd, &rset);
int max;
if(conn_sockfd != 0)
max = max(max(listen_sockfd, conn_sockfd),pf_pack_sockfd);
else
max = max(listen_sockfd,pf_pack_sockfd);
int ret = select(max+1, &rset, NULL, NULL, NULL);
if(FD_ISSET(listen_sockfd, &rset)) {
conn_sockfd = Accept(listen_sockfd, (SA *) &cliaddr, &clilen);
/* n = read(conn_sockfd, destIP, sizeof(struct sockaddr_in));
Inet_ntop(AF_INET, &(destIP->sin_addr), ip_addr, 20);
// Lookup for the <HW,IP> pair in the ARP cache
lookup_arp_cache(ip_addr, cache_hw_addr, &cache_ifindex, &cache_hatype,&lookup_flag);
if(lookup_flag == 0) {
printf("Entry not found from cache\n");
create_arp_request_packet(arp_req, ip_addr, hi_pair);
send_arp_request(pf_pack_sockfd, arp_req, hi_pair, conn_sockfd);
}
else{
printf("Entry found from cache\n");
// Send from cache
HWaddr.sll_ifindex = cache_ifindex;
HWaddr.sll_hatype = cache_hatype;
HWaddr.sll_halen = sizeof(cache_hatype);
memcpy(HWaddr.mac_addr, cache_hw_addr,6);
print_mac_to_string(HWaddr.mac_addr);
Write(conn_sockfd, (void *)&HWaddr, sizeof(HWaddr));
close(conn_sockfd);
}
printf("Sent ARP request\n");
*/ }
else if(ret!= -1 && FD_ISSET(conn_sockfd, &rset)) {
n = read(conn_sockfd, destIP, sizeof(struct sockaddr_in));
Inet_ntop(AF_INET, &(destIP->sin_addr), ip_addr, 20);
// Lookup for the <HW,IP> pair in the ARP cache
lookup_arp_cache(ip_addr, cache_hw_addr, &cache_ifindex, &cache_hatype,&lookup_flag);
if(lookup_flag == 0) {
create_arp_request_packet(arp_req, ip_addr, hi_pair);
printf("send 1\n");
send_arp_request(pf_pack_sockfd, arp_req, hi_pair, conn_sockfd);
}
else{
// Send from cache
HWaddr.sll_ifindex = cache_ifindex;
HWaddr.sll_hatype = cache_hatype;
HWaddr.sll_halen = sizeof(cache_hatype);
memcpy(HWaddr.mac_addr, cache_hw_addr,6);
// print_mac_to_string(HWaddr.mac_addr);
Write(conn_sockfd, (void *)&HWaddr, sizeof(HWaddr));
close(conn_sockfd);
conn_sockfd = 0;
}
}
else if(FD_ISSET(pf_pack_sockfd, &rset)) {
Recvfrom(pf_pack_sockfd, buffer, ETH_FRAME_LEN, 0, (SA *)&socket_address, &ll_len);
void *data = buffer + 14;
arp_rep = (struct arp_packet *)data;
if (arp_rep->id == ARP_ID){
if(arp_rep->op == ARP_REQ) {
if(strcmp(arp_rep->dest_IP, hi_pair->ip_addr) == 0) {
printf("Printing Ethernet Header and ARP Request Packet Received\n");
print_ethernet_and_arp(arp_rep->src_mac, arp_rep->dest_mac, arp_rep);
add_to_arp_cache_list(arp_rep->src_IP, arp_rep->src_mac, socket_address.sll_ifindex, socket_address.sll_hatype, conn_sockfd, 1);
// print_arp_cache_list();
create_arp_reply_packet(arp_recv, arp_rep->src_IP, hi_pair, arp_rep->src_mac, arp_rep->id);
send_arp_reply(pf_pack_sockfd, arp_recv, hi_pair, socket_address.sll_ifindex);
}
else {
update_arp_cache(arp_rep->src_IP, arp_rep->src_mac, socket_address.sll_ifindex, 0, conn_sockfd);
}
continue;
}
else if(arp_rep->op == ARP_REP) {
if(ret == -1) {
delete_from_arp_cache(arp_rep->src_IP);
// print_arp_cache_list();
continue;
}
printf("Printing Ethernet Header and ARP Reply Packet Received\n");
print_ethernet_and_arp(arp_rep->src_mac, arp_rep->dest_mac, arp_rep);
update_arp_cache(arp_rep->src_IP, arp_rep->src_mac, socket_address.sll_ifindex, 0, conn_sockfd);
// print_arp_cache_list();
HWaddr.sll_ifindex = socket_address.sll_ifindex;
HWaddr.sll_hatype = socket_address.sll_hatype;
HWaddr.sll_halen = socket_address.sll_halen;
memcpy(HWaddr.mac_addr, arp_rep->src_mac,6);
// print_mac_to_string(HWaddr.mac_addr);
Write(conn_sockfd, (void *)&HWaddr, sizeof(HWaddr));
close(conn_sockfd);
conn_sockfd = 0;
update_arp_cache(arp_rep->src_IP, arp_rep->src_mac, socket_address.sll_ifindex, 0, -1);
// print_arp_cache_list();
}
}
}
}
}
//
// TentacleThink
//
void CTentacle :: Cycle( void )
{
SetNextThink( 0.1 );
// ALERT( at_console, "%s %d %d %d %f %f\n", STRING( pev->targetname ), pev->sequence, m_iGoalAnim, m_iDir, pev->framerate, pev->health );
if (m_MonsterState == MONSTERSTATE_SCRIPT || m_IdealMonsterState == MONSTERSTATE_SCRIPT)
{
Vector angles = GetAbsAngles();
angles.y = m_flInitialYaw;
SetAbsAngles( angles );
pev->ideal_yaw = m_flInitialYaw;
ClearConditions( IgnoreConditions() );
MonsterThink( );
m_iGoalAnim = TENTACLE_ANIM_Pit_Idle;
return;
}
DispatchAnimEvents( );
StudioFrameAdvance( );
ChangeYaw( pev->yaw_speed );
CSound *pSound;
Listen( );
// Listen will set this if there's something in my sound list
if ( HasConditions( bits_COND_HEAR_SOUND ) )
pSound = PBestSound();
else
pSound = NULL;
if ( pSound )
{
Vector vecDir;
if (gpGlobals->time - m_flPrevSoundTime < 0.5)
{
float dt = gpGlobals->time - m_flPrevSoundTime;
vecDir = pSound->m_vecOrigin + (pSound->m_vecOrigin - m_vecPrevSound) / dt - GetAbsOrigin();
}
else
{
vecDir = pSound->m_vecOrigin - GetAbsOrigin();
}
m_flPrevSoundTime = gpGlobals->time;
m_vecPrevSound = pSound->m_vecOrigin;
m_flSoundYaw = UTIL_VecToYaw ( vecDir ) - m_flInitialYaw;
m_iSoundLevel = Level( vecDir.z );
if (m_flSoundYaw < -180)
m_flSoundYaw += 360;
if (m_flSoundYaw > 180)
m_flSoundYaw -= 360;
// ALERT( at_console, "sound %d %.0f\n", m_iSoundLevel, m_flSoundYaw );
if (m_flSoundTime < gpGlobals->time)
{
// play "I hear new something" sound
char *sound;
switch( RANDOM_LONG(0,1) )
{
case 0: sound = "tentacle/te_alert1.wav"; break;
case 1: sound = "tentacle/te_alert2.wav"; break;
}
// UTIL_EmitAmbientSound(ENT(pev), GetAbsOrigin() + Vector( 0, 0, MyHeight()), sound, 1.0, ATTN_NORM, 0, 100);
}
m_flSoundTime = gpGlobals->time + RANDOM_FLOAT( 5.0, 10.0 );
}
// clip ideal_yaw
float dy = m_flSoundYaw;
switch( pev->sequence )
{
case TENTACLE_ANIM_Floor_Rear:
case TENTACLE_ANIM_Floor_Rear_Idle:
case TENTACLE_ANIM_Lev1_Rear:
case TENTACLE_ANIM_Lev1_Rear_Idle:
case TENTACLE_ANIM_Lev2_Rear:
case TENTACLE_ANIM_Lev2_Rear_Idle:
case TENTACLE_ANIM_Lev3_Rear:
case TENTACLE_ANIM_Lev3_Rear_Idle:
if (dy < 0 && dy > -m_flMaxYaw)
dy = -m_flMaxYaw;
if (dy > 0 && dy < m_flMaxYaw)
dy = m_flMaxYaw;
break;
default:
if (dy < -m_flMaxYaw)
dy = -m_flMaxYaw;
if (dy > m_flMaxYaw)
dy = m_flMaxYaw;
}
pev->ideal_yaw = m_flInitialYaw + dy;
if (m_fSequenceFinished)
{
// ALERT( at_console, "%s done %d %d\n", STRING( pev->targetname ), pev->sequence, m_iGoalAnim );
if (pev->health <= 1)
{
m_iGoalAnim = TENTACLE_ANIM_Pit_Idle;
if (pev->sequence == TENTACLE_ANIM_Pit_Idle)
{
pev->health = 75;
}
}
else if ( m_flSoundTime > gpGlobals->time )
{
if (m_flSoundYaw >= -(m_flMaxYaw + 30) && m_flSoundYaw <= (m_flMaxYaw + 30))
{
// strike
m_iGoalAnim = LookupActivity( ACT_T_STRIKE + m_iSoundLevel );
}
else if (m_flSoundYaw >= -m_flMaxYaw * 2 && m_flSoundYaw <= m_flMaxYaw * 2)
{
// tap
m_iGoalAnim = LookupActivity( ACT_T_TAP + m_iSoundLevel );
}
else
{
// go into rear idle
m_iGoalAnim = LookupActivity( ACT_T_REARIDLE + m_iSoundLevel );
}
}
else if (pev->sequence == TENTACLE_ANIM_Pit_Idle)
{
// stay in pit until hear noise
m_iGoalAnim = TENTACLE_ANIM_Pit_Idle;
}
else if (pev->sequence == m_iGoalAnim)
{
if (MyLevel() >= 0 && gpGlobals->time < m_flSoundTime)
{
if (RANDOM_LONG(0,9) < m_flSoundTime - gpGlobals->time)
{
// continue stike
m_iGoalAnim = LookupActivity( ACT_T_STRIKE + m_iSoundLevel );
}
else
{
// tap
m_iGoalAnim = LookupActivity( ACT_T_TAP + m_iSoundLevel );
}
}
else if (MyLevel( ) < 0)
{
m_iGoalAnim = LookupActivity( ACT_T_IDLE + 0 );
}
else
{
if (m_flNextSong < gpGlobals->time)
{
// play "I hear new something" sound
char *sound;
switch( RANDOM_LONG(0,1) )
{
case 0: sound = "tentacle/te_sing1.wav"; break;
case 1: sound = "tentacle/te_sing2.wav"; break;
}
EMIT_SOUND(ENT(pev), CHAN_VOICE, sound, 1.0, ATTN_NORM);
m_flNextSong = gpGlobals->time + RANDOM_FLOAT( 10, 20 );
}
if (RANDOM_LONG(0,15) == 0)
{
// idle on new level
m_iGoalAnim = LookupActivity( ACT_T_IDLE + RANDOM_LONG(0,3) );
}
else if (RANDOM_LONG(0,3) == 0)
{
// tap
m_iGoalAnim = LookupActivity( ACT_T_TAP + MyLevel( ) );
}
else
{
// idle
m_iGoalAnim = LookupActivity( ACT_T_IDLE + MyLevel( ) );
}
}
if (m_flSoundYaw < 0)
m_flSoundYaw += RANDOM_FLOAT( 2, 8 );
else
m_flSoundYaw -= RANDOM_FLOAT( 2, 8 );
}
pev->sequence = FindTransition( pev->sequence, m_iGoalAnim, &m_iDir );
if (m_iDir > 0)
{
pev->frame = 0;
}
else
{
m_iDir = -1; // just to safe
pev->frame = 255;
}
ResetSequenceInfo( );
m_flFramerateAdj = RANDOM_FLOAT( -0.2, 0.2 );
pev->framerate = m_iDir * 1.0 + m_flFramerateAdj;
switch( pev->sequence)
{
case TENTACLE_ANIM_Floor_Tap:
case TENTACLE_ANIM_Lev1_Tap:
case TENTACLE_ANIM_Lev2_Tap:
case TENTACLE_ANIM_Lev3_Tap:
{
Vector vecSrc;
UTIL_MakeVectors( GetAbsAngles() );
TraceResult tr1, tr2;
vecSrc = GetAbsOrigin() + Vector( 0, 0, MyHeight() - 4);
UTIL_TraceLine( vecSrc, vecSrc + gpGlobals->v_forward * 512, ignore_monsters, ENT( pev ), &tr1 );
vecSrc = GetAbsOrigin() + Vector( 0, 0, MyHeight() + 8);
UTIL_TraceLine( vecSrc, vecSrc + gpGlobals->v_forward * 512, ignore_monsters, ENT( pev ), &tr2 );
// ALERT( at_console, "%f %f\n", tr1.flFraction * 512, tr2.flFraction * 512 );
m_flTapRadius = SetBlending( 0, RANDOM_FLOAT( tr1.flFraction * 512, tr2.flFraction * 512 ) );
}
break;
default:
m_flTapRadius = 336; // 400 - 64
break;
}
pev->view_ofs.z = MyHeight( );
// ALERT( at_console, "seq %d\n", pev->sequence );
}
if (m_flPrevSoundTime + 2.0 > gpGlobals->time)
{
// 1.5 normal speed if hears sounds
pev->framerate = m_iDir * 1.5 + m_flFramerateAdj;
}
else if (m_flPrevSoundTime + 5.0 > gpGlobals->time)
{
// slowdown to normal
pev->framerate = m_iDir + m_iDir * (5 - (gpGlobals->time - m_flPrevSoundTime)) / 2 + m_flFramerateAdj;
}
}
int
main(int argc, char **argv)
{
int i, maxi, maxfd, listenfd, connfd, sockfd;
int nready, client[FD_SETSIZE];
ssize_t n;
fd_set rset, allset;
char line[MAXLINE];
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(7);
Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));
Listen(listenfd, LISTENQ);
maxfd = listenfd; /* initialize */
maxi = -1; /* index into client[] array */
for (i = 0; i < FD_SETSIZE; i++)
client[i] = -1; /* -1 indicates available entry */
FD_ZERO(&allset);
FD_SET(listenfd, &allset);
for ( ; ; ) {
rset = allset;
nready = Select(maxfd+1, &rset, NULL, NULL, NULL);
if (FD_ISSET(listenfd, &rset)) { /* new client connection */
printf("listening socket readable\n");
sleep(5);
clilen = sizeof(cliaddr);
connfd = Accept(listenfd, (SA *) &cliaddr, &clilen);
#ifdef NOTDEF
printf("new client: %s, port %d\n",
Inet_ntop(AF_INET, &cliaddr.sin_addr, 4, NULL),
ntohs(cliaddr.sin_port));
#endif
for (i = 0; i < FD_SETSIZE; i++)
if (client[i] < 0) {
client[i] = connfd; /* save descriptor */
break;
}
if (i == FD_SETSIZE)
err_quit("too many clients");
FD_SET(connfd, &allset); /* add new descriptor to set */
if (connfd > maxfd)
maxfd = connfd; /* for select */
if (i > maxi)
maxi = i; /* max index in client[] array */
if (--nready <= 0)
continue; /* no more readable descriptors */
}
for (i = 0; i <= maxi; i++) { /* check all clients for data */
if ( (sockfd = client[i]) < 0)
continue;
if (FD_ISSET(sockfd, &rset)) {
if ( (n = Readline(sockfd, line, MAXLINE)) == 0) {
/* connection closed by client */
Close(sockfd);
FD_CLR(sockfd, &allset);
client[i] = -1;
}
Writen(sockfd, line, n);
if (--nready <= 0)
break; /* no more readable descriptors */
}
}
}
}
void BaseServer::StartListen(int minport,int maxport)
{
m_iServCount = maxport-minport+1;
if(m_iServCount > SERV_COUNT)
{
cout<<GetSystemTime()<<": 要求开启端口数超过限制，程序退出."<<endl;
exit(1);
}
m_ServSocks = new ServInfo[m_iServCount];
for(int i = minport;i <= maxport;i++)
{
m_ServSocks[i-minport].sockfd = Listen(i); //套接字
m_ServSocks[i-minport].portno = i; //端口号
FD_SET(m_ServSocks[i-minport].sockfd,&m_setServSock);
if(m_ServSocks[i-minport].sockfd > 0)
{
if(m_ServSocks[i-minport].sockfd > m_iServMaxSock){
m_iServMaxSock = m_ServSocks[i-minport].sockfd;
}
cout<<GetSystemTime()<<": "<<dec<<i<<" 端口开启成功."<<endl;
}
else
{
cout<<GetSystemTime()<<": "<<dec<<i<<" 端口开启失败，程序退出."<<endl;
exit(1);
}
}
cout<<GetSystemTime()<<": 全部端口开启完毕."<<endl;
struct sockaddr_in clnt_addr;
socklen_t clnt_addr_size = sizeof(clnt_addr);
fd_set connfds;
FD_ZERO(&connfds);
int result = 0;
struct timeval timeout;
timeout.tv_sec = 5;
timeout.tv_usec = 0;
while(true)
{
memset(&clnt_addr,0,clnt_addr_size);
connfds = m_setServSock;
result = select(m_iServMaxSock+1,&connfds,NULL,NULL,&timeout);
if(result > 0)
{
for(int j = 0;j < m_iServCount;j++)
{
if(FD_ISSET(m_ServSocks[j].sockfd,&connfds))
{
if(m_iClntCount < MAX_CLIENT)
{
CONNECT:
int clnt_sock;
clnt_sock = accept(m_ServSocks[j].sockfd,(struct sockaddr*)&clnt_addr,&clnt_addr_size);
if(clnt_sock > 0)
{
pthread_mutex_lock(&m_mutxSock);
m_ClntSocks[m_iClntCount].sockfd = clnt_sock;
m_ClntSocks[m_iClntCount].portno = m_ServSocks[j].portno;
m_ClntSocks[m_iClntCount].lasttime = time(NULL);
memcpy(m_ClntSocks[m_iClntCount].ipaddr,inet_ntoa(clnt_addr.sin_addr),16);
m_iClntCount++;
if(m_iClntMaxSock < clnt_sock)
m_iClntMaxSock = clnt_sock;
FD_SET(clnt_sock,&m_setClntSock);
#ifndef NO_DEBUG
cout<<GetSystemTime()<<": Client "<<inet_ntoa(clnt_addr.sin_addr)<<" Connected on port "<<dec<<m_ClntSocks[m_iClntCount-1].portno<<endl;
#endif
pthread_mutex_unlock(&m_mutxSock);
}
}
else
{
pthread_mutex_lock(&m_mutxSock);
for(int k = m_iClntCount-1;k >= 0;k--)
{
close(m_ClntSocks[k].sockfd);
}
FD_ZERO(&m_setClntSock);
m_iClntCount = 0;
pthread_mutex_unlock(&m_mutxSock);
cout<<GetSystemTime()<<": Sockets are over the max sock of allowed("<<dec<<MAX_CLIENT<<") Disconnect all connections."<<endl;
goto CONNECT;
}
}
}
}
else if(result < 0)
{
#ifndef NO_DEBUG
cout<<GetSystemTime()<<": select() 发生错误!"<<endl;
#endif
}
}// while(true)
}
int
main(int argc, char **argv)
{
int i, maxi, maxfd, listenfd, connfd, sockfd;
int nready, client[FD_SETSIZE];
ssize_t n;
fd_set rset, allset;
char buf[MAXLINE];
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Bind(listenfd, (SA *)&servaddr, sizeof(servaddr));
Listen(listenfd, LISTENQ);
maxfd = listenfd;
maxi = -1;
for( i = 0; i < FD_SETSIZE; ++i)
client[i] = -1;
FD_ZERO(&allset);
FD_SET(listenfd, &allset);
for ( ; ; ) {
rset = allset;
nready = Select(maxfd+1, &rset, NULL, NULL, NULL);
if (FD_ISSET(listenfd, &rset)) {
clilen = sizeof(cliaddr);
connfd = Accept(listenfd, (SA *)&cliaddr, &clilen);
/* Put the new client into the clients array. */
for (i = 0; i< FD_SETSIZE; i++)
if(client[i] < 0) {
client[i] = connfd;
break;
}
if (i == FD_SETSIZE)
err_quit("too many clients");
FD_SET(connfd, &allset);
if(connfd > maxfd)
maxfd = connfd; /* For select */
if(i > maxi)
maxi = i; /* max index in client[] array */
if (--nready <= 0)
continue;
}
for (i = 0; i<= maxi; i++) {
if ( (sockfd = client[i]) < 0)
continue;
if (FD_ISSET(sockfd, &rset)) {
if ( (n = Read(sockfd, buf, MAXLINE)) == 0) {
Close(sockfd);
FD_CLR(sockfd, &allset);
client[i] = -1;
} else
Writen(sockfd, buf, n);
if(--nready <= 0)
break;
}
}
}
}
int main(int argc, char **argv)
{
int listenfd, connfd, udpfd, nready, maxfd1;
char mesg[MAXLINE];
pid_t childpid;
fd_set rset;
ssize_t n;
socklen_t len;
const int on = 1;
struct sockaddr_in servaddr, cliaddr;
void sig_chld(int);
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERV_PORT);
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
Setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
Bind(listenfd, (SA *)&servaddr, sizeof(servaddr));
Listen(listenfd, LISTENQ);
udpfd = Socket(AF_INET, SOCK_DGRAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERV_PORT);
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
Bind(udpfd, (SA *)&servaddr, sizeof(servaddr));
Signal(SIGCHLD, sig_chld);
FD_ZERO(&rset);
maxfd1 = max(listenfd, udpfd) + 1;
for(;;)
{
FD_SET(listenfd, &rset);
FD_SET(udpfd, &rset);
if( (nready = select(maxfd1, &rset, NULL, NULL, NULL)) < 0)
{
if( errno == EINTR)
continue;
else
{
printf("select error.");
exit(1);
}
}
if( FD_ISSET(listenfd, &rset) )
{
len = sizeof(cliaddr);
connfd = Accept(listenfd, (SA *)&cliaddr, &len);
if( (childpid = fork()) == 0)
{
/* child process */
Close(listenfd);
str_echo(connfd);
exit(0);
}
Close(connfd);
}
if( FD_ISSET(udpfd, &rset))
{
len = sizeof(cliaddr);
n = Recvfrom(udpfd, mesg, MAXLINE, 0, (SA *)&cliaddr, &len);
Sendto(udpfd, mesg, n, 0, (SA *)&cliaddr, len);
}
}
exit(0);
}
