Esempio n. 1
0
void SkylarkApp::Quit()
{
	quit = true;
#ifdef PLATFORM_POSIX
	Broadcast(SIGTERM);
#endif
	TcpSocket s;
	s.Timeout(100);
	s.Connect("127.0.0.1", port);
}
Esempio n. 2
0
BOOL WINAPI SkylarkApp::CtrlCHandlerRoutine(__in  DWORD dwCtrlType)
{
	LOG("Ctrl+C handler");
	TheApp().quit = true;
	Cout() << "Ctrl + C\n";
	TcpSocket h;
	h.Connect("127.0.0.1", TheApp().port);
	h.Put("quit");
	return TRUE;
}
Esempio n. 3
0
String Request(const String& r)
{
	TcpSocket s;
	if(!s.Connect(CommandLine().GetCount() ? CommandLine()[0] : "127.0.0.1", 3214)) {
		Cout() << "Unable to connect to server!\n";
		SetExitCode(1);
		return Null;
	}
	s.Put(r + '\n');
	return s.GetLine();
}
Esempio n. 4
0
int main(int argc, char const *argv[])
{
	// signal(SIGPIPE, SIG_IGN);
	//=========== client ===========
	if(argc == 3)
	{
		const char* ip = argv[1];
		unsigned short port = (unsigned short)atoi(argv[2]);

		printf("ip %s\nport %hu\n", ip, port);

		TcpSocket sock;
		assert(sock.Init());
		assert(sock.Connect(ip, port));

		assert(sock.SetNonBlocking());

		getchar();

		char msg[] = "hello server";
		int nsent;
		if(sock.CanSend())
		{
			nsent = sock.Send((unsigned char*)msg, strlen(msg));
			printf("nsent:%d\n", nsent);
		}
		else
		{
			printf("can not send\n");
		}
		getchar();

		if(1/*sock.CanSend()*/)
		{
			nsent = sock.Send((unsigned char*)msg, strlen(msg));
			printf("nsent:%d\n", nsent);
		}
		else
		{
			printf("can not send\n");
		}
		getchar();

		if(sock.CanRecv())
		{
			const int buf_len = 1024;
			char buf[buf_len];
			memset(buf, 0, buf_len);
			int nread = sock.Recv((unsigned char*)buf, buf_len);

			printf("recv(%d): %s\n", nread, buf);
		}
		else
		{
			printf("can not recv\n");
		}
	}
	//=========== server ===========
	else
	{
		printf("tcp echo server\n");
		bool r = false;

		unsigned short port = 9999;
		TcpSocket sock;
		assert(sock.Init());
		r = sock.Listen(port);

		assert(r == true);

		// sock.SetNonBlocking();
		
		while(1)
		{
			printf("waiting for connection...\n");
			TcpSocket client;
			assert(client.Init());
			char ip_buf[32];
			memset(ip_buf, 0, 32);
			bool b = sock.Accept(client, ip_buf);
			printf("client ip: %s\n", ip_buf);

			// client.SetNonBlocking();

			while(b)
			{
				const int buf_len = 1024;
				char buf[buf_len];
				memset(buf, 0, buf_len);

				if(1/*client.CanRecv()*/)
				{
					int nread = client.Recv((unsigned char*)buf, buf_len);
					printf("recv(%d): %s\n", nread, buf);
					toolbox::print_bytes(buf, strlen(buf) + 2);
					if(nread <= 0)
					{
						break;
					}

					if(client.CanSend())
					{
						int nsent = client.Send((unsigned char*)buf, strlen(buf));
						printf("send(%d): %s\n", nsent, buf);
						if(nsent <= 0)
						{
							break;
						}
					}
					else
					{
						printf("can not send\n");
					}
				}
				else
				{
					printf("can not recv\n");
				}

				sleep(1);
			}
			sleep(1);
		}

	}

	return 0;
}