精华内容
下载资源
问答
  • 基于TCPsocket编程

    千次阅读 2010-01-07 16:41:00
    基于TCPsocket编程(聊天室程序例解) 基于TCPsocket编程关键词: VC sockets(套接字)编程有三种,流式套接字(SOCK_STREAM),数据报套接字(SOCK_DGRAM),原始套接字(SOCK_
    基于TCP的socket编程(聊天室程序例解)
     
     

    基于TCP的socket编程

    关键词VC                                          

     

    sockets(套接字)编程有三种,流式套接字(SOCK_STREAM),数据报套接字(SOCK_DGRAM),原始套接字(SOCK_RAW);基于TCP的socket编程是采用的流式套接字。

    在这个程序中,将两个工程添加到一个工作区。要链接一个ws2_32.lib的库文件。

    服务器端编程的步骤:

    1:加载套接字库,创建套接字(WSAStartup()/socket());

      注明:SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);

           socket()构照函数初始化SOCKET 类的实例

    2:绑定套接字到一个IP地址和一个端口上(bind());

      注明:使 Socket 与一个本地终结点相关联。

    3:将套接字设置为监听模式等待连接请求(listen());

      注明:The listen function places a socket in a state      

       int listen(
             SOCKET s,
             int backlog(最大链接数)
        );
    

     

    4:请求到来后,接受连接请求,返回一个新的对应于此次连接的套接字(accept());

       注明:为新建连接创建新的 Socket

    5:用返回的套接字和客户端进行通信(send()/recv());

    6:返回,等待另一连接请求;

    7:关闭套接字,关闭加载的套接字库(closesocket()/WSACleanup())。

    服务器端代码如下:

    #include <stdio.h>
    #include <Winsock2.h>
    void main()
    {
     WORD wVersionRequested;
     WSADATA wsaData;
     int err;
     
     wVersionRequested = MAKEWORD( 1, 1 );
     
     err = WSAStartup( wVersionRequested, &wsaData );
     if ( err != 0 ) {
      return;
     }
     
     if ( LOBYTE( wsaData.wVersion ) != 1 ||
            HIBYTE( wsaData.wVersion ) != 1 ) {
      WSACleanup( );
      return;
     }
     SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);

     SOCKADDR_IN addrSrv;
     addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
     addrSrv.sin_family=AF_INET;
     addrSrv.sin_port=htons(6000);
     
     bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));

     listen(sockSrv,5);

     SOCKADDR_IN addrClient;
     int len=sizeof(SOCKADDR);
     while(1)
     {
      SOCKET sockConn=accept(sockSrv,(SOCKADDR*)&addrClient,&len);
      char sendBuf[50];
      sprintf(sendBuf,"Welcome %s to here!",inet_ntoa(addrClient.sin_addr));
      send(sockConn,sendBuf,strlen(sendBuf)+1,0);
      char recvBuf[50];
      recv(sockConn,recvBuf,50,0);
      printf("%s/n",recvBuf);
      closesocket(sockConn);
     }

    }

    客户端编程的步骤:

    1:加载套接字库,创建套接字(WSAStartup()/socket());

    2:向服务器发出连接请求(connect());

       注明:建立与远程主机的连接。

    3:和服务器端进行通信(send()/recv());

    4:关闭套接字,关闭加载的套接字库(closesocket()/WSACleanup())。

    客户端的代码如下:

    #include <stdio.h>
    #include <Winsock2.h>
    void main()
    {
     WORD wVersionRequested;
     WSADATA wsaData;
     int err;
     
     wVersionRequested = MAKEWORD( 1, 1 );
     
     err = WSAStartup( wVersionRequested, &wsaData );
     if ( err != 0 ) {
      return;
     }
     
     if ( LOBYTE( wsaData.wVersion ) != 1 ||
            HIBYTE( wsaData.wVersion ) != 1 ) {
      WSACleanup( );
      return;
     }
     SOCKET sockClient=socket(AF_INET,SOCK_STREAM,0);
     
     SOCKADDR_IN addrSrv;
     addrSrv.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
     addrSrv.sin_family=AF_INET;
     addrSrv.sin_port=htons(6000);
     connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
     char recvBuf[50];
     recv(sockClient,recvBuf,50,0);
     printf("%s/n",recvBuf);
     send(sockClient,"hello",strlen("hello")+1,0);
     
     closesocket(sockClient);
     WSACleanup();
    }

    // stdafx.h : 标准系统包含文件的包含文件,
    // 或是经常使用但不常更改的
    // 特定于项目的包含文件
    //

    #pragma once


    #define WIN32_LEAN_AND_MEAN  // 从 Windows 头中排除极少使用的资料
    #pragma comment(lib, "ws2_32.lib")
    #pragma  comment(lib,"wininet.lib")

    #include <stdio.h>
    #include <tchar.h>
    #include <stdlib.h>
    #include <conio.h>
    #include <string.h>
    #include <winsock2.h>

     

    // TODO: 在此处引用程序需要的其他头文件

    展开全文
  • 一、基于TCPSocket通信 1、TCP协议:TCP协议是面向连接的、可靠的、有序的,以字节流方式传输数据的通信协议。客户端与服务器要想实现通信,首先需要建立连接。 2、Java提供的基于TCP协议实现网络通信的类为:...

    一、基于TCP的Socket通信

    1、TCP协议:TCP协议是面向连接的、可靠的、有序的,以字节流方式传输数据的通信协议。客户端与服务器要想实现通信,首先需要建立连接。

    2、Java提供的基于TCP协议实现网络通信的类为:客户端的Socket类、服务器端的ServerSocket类。

    3、Socket通信模型,见下图(摘自慕课网)


    4、Socket通信的实现步骤:

    (1)创建ServerSocket和Socket对象

    (2)打开Socket的输入/输出流

    (3)从输入/输出流中读/写数据

    (4)关闭相关资源


    二、Socket编程实例

    1、非多线程的情况

    服务器端:

    ServerDemo.java

    public class ServerDemo {
    	public static void main(String[] args) throws IOException {
    		ServerSocket server = null;
    		Socket client = null;
    		InputStream in = null;
    		InputStreamReader reader = null;
    		BufferedReader bufReader = null;
    		OutputStream out = null;
    		PrintWriter writer = null;
    		
    		try {
    			//1、创建服务器端socket,并绑定9999端口,绑定端口之后,服务器一直监听9999端口的请求
    			server = new ServerSocket(9999);
    			System.out.println("------服务器已启动,等待客户端信息------");
    			//2、服务器端接收到客户端的请求,建立连接
    			client = server.accept();
    			
    			//3、将客户的请求数据以输入流的形式读取出来
    			in = client.getInputStream();
    			reader = new InputStreamReader(in);
    			bufReader = new BufferedReader(reader);
    			String msg = null;
    			while((msg = bufReader.readLine()) != null) {
    				System.out.println("收到客户端的信息:" + msg);
    			}
    			//4、关闭输入流
    			client.shutdownInput();
    			
    			//5、通过输出流向客户端发送信息
    			out = client.getOutputStream();
    			writer = new PrintWriter(out);
    			writer.write("我是服务器,我已经收到了你的信息!");
    			writer.flush();
    			//6、关闭输出流
    			client.shutdownOutput();
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			//7、程序最后一定要关闭资源
    			if(in != null)
    				in.close();
    			if(reader != null) 
    				reader.close();
    			if(bufReader != null)
    				bufReader.close();
    			if(out != null)
    				out.close();
    			if(writer != null)
    				writer.close();
    			if(client != null)
    				client.close();
    			if(server != null)
    				server.close();
    		}
    	}
    }
    
    客户端:

    ClientDemo.java

    public class ClientDemo {
    	public static void main(String[] args) throws IOException {
    		Socket client = null;
    		InputStream in = null;
    		InputStreamReader reader = null;
    		BufferedReader bufReader = null;
    		OutputStream out = null;
    		PrintWriter writer = null;
    		
    		try {
    			 //1、新建客户端socket,指明需要连接的服务器地址和端口号
    			 //如果是本机,地址可以是localhost或者127.0.0.1
    			client = new Socket("localhost", 9999);
    			System.out.println("------客户端准备与服务器端建立连接------");
    			
    			//2、建立连接后通过输出流向服务器端发送信息
    			out = client.getOutputStream();
    			writer = new PrintWriter(out);
    			writer.write("我是客户端,你收到我的请求了吗?");
    			writer.flush();
    			//3、关闭输出流
    			client.shutdownOutput();
    			
    			//4、将服务器端的响应以输出流的形式读取出来
    			in = client.getInputStream();
    			reader = new InputStreamReader(in);
    			bufReader = new BufferedReader(reader);
    			String msg = null;
    			while((msg = bufReader.readLine()) != null) {
    				System.out.println("收到服务器的应答:" + msg);
    			}
    			//5、关闭输出流
    			client.shutdownInput();
    		} catch (UnknownHostException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			//6、程序的最后一定要关闭资源
    			if(in != null)
    				in.close();
    			if(reader != null) 
    				reader.close();
    			if(bufReader != null)
    				bufReader.close();
    			if(out != null)
    				out.close();
    			if(writer != null)
    				writer.close();
    			if(client != null)
    				client.close();
    		}
    	}
    }
    

    2、多线程的情况(即一个服务器端可以不断接收多个客户端的请求)

    服务器端入口:

    ServerThreadMain.java

    public class ServerThreadMain {
    	public static void main(String[] args) {
    		ServerSocket server = null;
    		Socket client = null;
    		try {
    			server = new ServerSocket(9999);
    			System.out.println("------服务器已启动,等待客户端信息------");
    
    			while(true) {
    				client = server.accept();
    				ServerThread thread = new ServerThread(client);
    				thread.start();
    			}
    			
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    }

    这里写了一个死循环,代表服务器端一直接收客户端的请求,每接收到一个客户端请求,服务器端会新启一个线程进行处理。

    代表服务器端核心处理的线程:

    ServerThread.java

    public class ServerThread extends Thread {
    	public Socket client;
    	
    	public ServerThread(Socket client) {
    		this.client = client;
    	}
    	
    	public void run() {
    		InputStream in = null;
    		InputStreamReader reader = null;
    		BufferedReader bufReader = null;
    		OutputStream out = null;
    		PrintWriter writer = null;
    		
    		try {			
    			in = client.getInputStream();
    			reader = new InputStreamReader(in);
    			bufReader = new BufferedReader(reader);
    			String msg = null;
    			while((msg = bufReader.readLine()) != null) {
    				System.out.println("收到客户端的信息:" + msg);
    			}
    			client.shutdownInput();
    			
    			out = client.getOutputStream();
    			writer = new PrintWriter(out);
    			writer.write("我是服务器,我已经收到了你的信息!");
    			writer.flush();
    			client.shutdownOutput();
    		} catch (IOException e) {
    			e.printStackTrace();
    		} finally {
    			try {
    				if(in != null)
    					in.close();
    				if(reader != null) 
    					reader.close();
    				if(bufReader != null)
    					bufReader.close();
    				if(out != null)
    					out.close();
    				if(writer != null)
    					writer.close();
    				if(client != null)
    					client.close();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    }
    
    客户端代码与非多线程的客户端代码相同,不再赘述。


    展开全文
  • 基于TCPSocket 编程

    万次阅读 2011-07-22 17:42:17
    基于TCP(面向连接)的socket编程,分为客户端和服务器端。客户端的流程如下:(1)创建套接字(socket)(2)向服务器发出连接请求(connect)(3)和服务器端进行通信(send/recv)(4)关闭套接字服务器端的流程...
     

    基于TCP(面向连接)的socket编程,分为客户端和服务器端。

    客户端的流程如下:

    (1)创建套接字(socket)

    (2)向服务器发出连接请求(connect)

    (3)和服务器端进行通信(send/recv)

    (4)关闭套接字

    服务器端的流程如下:

    (1)创建套接字(socket)

    (2)将套接字绑定到一个本地地址和端口上(bind)

    (3)将套接字设为监听模式,准备接收客户端请求(listen)

    (4)等待客户请求到来;当请求到来后,接受连接请求,返回一个新的对应于此次连接的套接字(accept)

    (5)用返回的套接字和客户端进行通信(send/recv)

    (6)返回,等待另一个客户请求。

    (7)关闭套接字。

     

    下面通过一个具体例子讲解一下具体的过程和相关的函数。

    客户端代码,运行于vs2008

    // ClientTest.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <stdio.h>
    #include <stdlib.h>
    #include <winsock2.h>
    
    #define SERVER_PORT 5208 //侦听端口
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	WORD wVersionRequested;
    	WSADATA wsaData;
    	int ret;
    	SOCKET sClient; //连接套接字
    	struct sockaddr_in saServer; //服务器地址信息
    	char *ptr;
    	BOOL fSuccess = TRUE;
    
    	//WinSock初始化
    	wVersionRequested = MAKEWORD(2, 2); //希望使用的WinSock DLL的版本
    	ret = WSAStartup(wVersionRequested, &wsaData);	//加载套接字库
    	if(ret!=0)
    	{
    		printf("WSAStartup() failed!\n");
    		//return 0;
    	}
    	//确认WinSock DLL支持版本2.2
    	if(LOBYTE(wsaData.wVersion)!=2 || HIBYTE(wsaData.wVersion)!=2)
    	{
    		WSACleanup();	//释放为该程序分配的资源,终止对winsock动态库的使用
    		printf("Invalid WinSock version!\n");
    		//return 0;
    	}
    
    	//创建Socket,使用TCP协议
    	sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    	if (sClient == INVALID_SOCKET)
    	{
    		WSACleanup();
    		printf("socket() failed!\n");
    		//return 0;
    	}
    
    	//构建服务器地址信息
    	saServer.sin_family = AF_INET; //地址家族
    	saServer.sin_port = htons(SERVER_PORT); //注意转化为网络节序
    	saServer.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    
    	//连接服务器
    	ret = connect(sClient, (struct sockaddr *)&saServer, sizeof(saServer));
    	if (ret == SOCKET_ERROR)
    	{
    		printf("connect() failed!\n");
    		closesocket(sClient); //关闭套接字
    		WSACleanup();
    		//return 0;
    	}
    
    
    	char sendMessage[]="ZhongXingPengYue"; 
    	ret = send (sClient, (char *)&sendMessage, sizeof(sendMessage), 0);
    	if (ret == SOCKET_ERROR)
    	{
    		printf("send() failed!\n");
    	}
    	else
    		printf("client info has been sent!");
    	char recvBuf[100];
    	recv(sClient,recvBuf,100,0);
    	printf("%s\n",recvBuf);
    	closesocket(sClient); //关闭套接字
    	WSACleanup();
    	getchar();
    	//return 0;
    }
    
    
     

            第一步,加载套接字。使用WSAStartup 函数,如:ret = WSAStartup(wVersionRequested, &wsaData)。WSAStartup函数的原型为

    int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData)

    第一参数wVersionRequested,用来指定准备加载的winsock库的版本。利用MAKEWORD(x,y)宏来赋值。x是高位字节,表示副版本号;y是低位字节,表示主版本号。MAKEWORD(2, 2)表示版本号为2.2。

    第二个参数是指向WSADATA结构的指针,是一个返回值,保存了库版本的有关信息。

     

           第二步,创建套接字。使用socket函数,如:sClient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)。socket函数的原型为:

    SOCKET socket(int af, int type, int protocol );
    
    

    第一个参数,指定地址族,对于TCP/IP协议的套接字,只能为AF_INET;

    第二个参数,指定socket类型,SOCK_STREAM指产生流式套接字,SOCK_DGRAM指产生数据报套接字,TCP/IP协议使用SOCK_STREAM。

    第三个参数,与特定的地址家族相关的协议,TCP协议一般为IPPROTO_TCP。也可以写0,那么系统会根据地址格式和套接字类别,自动选择一个适合的协议。

    如果socket创建成功,则返回一个新的SOCKET数据类型的套接字描述符;若失败,则返回INVALID_SOCKET,由此可以判断是否创建成功。

     

            第三步,连接服务器。使用connect函数,如:ret = connect(sClient, (struct sockaddr *)&saServer, sizeof(saServer))。connect函数函数原型为

    int connect(SOCKET s, const struct sockaddr FAR* name, int namelen);
    
    

    第一个参数是将在上面建立连接的那个套接字的描述符,即之前创建socket的返回值sClient。

    第二个参数是要连接的服务器端的地址信息。它是一个结构体类型struct sockaddr_in ,需要在调用connect函数之前构建服务器地址信息。sockaddr_in的定义如下:

    struct sockaddr_in{
    
    short sin_family;
    
    unsigned short sin_port;
    
    struct in_addr sin_addr;
    
    char sin_zero[8]
    
    };
    
    


    设置服务器端口时,用到htons函数,该函数把一个u_short类型的值从主机字节顺序转换为TCP/IP网络字节顺序,因为不同的计算机存放多字节的顺序不同(基于Intel CPU是高字节存放在低地址,低字节存放在高地址),所以网络中不同主机间通信时,要统一采用网络字节顺序。设置服务器IP地址时,使用到inet_addr函数,它是将点分十进制的IP地址的字符串转换成unsigned long型。inet_ntoa函数做相反的转换。

    第三个参数是服务器端地址结构体的大小。

     

            第四步,发送。使用send函数向服务器发送数据,如:ret = send (sClient, (char *)&sendMessage, sizeof(sendMessage), 0)。send函数的原型为

    int send(SOCKET s, const char FAR* buf, int len, int flags);
    

    第一个参数,是一个与服务器已经建立连接的套接字。

    第二个参数,指向包含要发送的数据的缓冲区的指针。

    第三个参数,是所指向的缓冲区的长度。准确的说,应该是所要发送的数据的长度,因为不是缓冲区的所有数据都要同时发送。

    第四个参数,它设定的值将影响函数的行为,一般将其设置为0即可。

    如果发送失败,send会返回SOCKET_ERROR,由此可以判断发送是否成功。

     

            第五步,接收。使用recv函数接收服务器发过来的数据,如recv(sClient,recvBuf,100,0)。recv函数的原型为

    int recv(SOCKET s, const char FAR* buf, int len, int flags);
    

    recv函数的参数的含义和send函数参数含义差不多,只是第二个参数是指向用来保存接收数据的缓冲区的指针。recv函数的返回值应该是所接收的数据的长度,如果返回SOCKET_ERROR表示接收失败;返回0表示服务器端关闭连接。

     

           第六步,关闭socket,释放资源。使用closesocket函数关闭套接字,如closesocket(sClient);使用WSACleanup函数释放为该程序分配的资源,终止对winsock动态库的使用,如WSACleanup();
     

    服务器端代码,运行于vs2008

    // ServerTest.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <stdio.h>
    #include <winsock2.h>
    
    #define SERVER_PORT 5208 //侦听端口
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	WORD wVersionRequested;
        WSADATA wsaData;
        int ret, nLeft, length;
        SOCKET sListen, sServer; //侦听套接字,连接套接字
        struct sockaddr_in saServer, saClient; //地址信息   
        char *ptr;//用于遍历信息的指针   
        //WinSock初始化
        wVersionRequested=MAKEWORD(2, 2); //希望使用的WinSock DLL 的版本
        ret=WSAStartup(wVersionRequested, &wsaData);
        if(ret!=0)
        {
            printf("WSAStartup() failed!\n");
            //return 0;
        }
        //创建Socket,使用TCP协议
        sListen=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (sListen == INVALID_SOCKET)
        {
            WSACleanup();
            printf("socket() faild!\n");
            //return 0;
        }
        //构建本地地址信息
        saServer.sin_family = AF_INET; //地址家族
        saServer.sin_port = htons(SERVER_PORT); //注意转化为网络字节序
        saServer.sin_addr.S_un.S_addr = htonl(INADDR_ANY); //使用INADDR_ANY 指示任意地址
      
        //绑定
        ret = bind(sListen, (struct sockaddr *)&saServer, sizeof(saServer));
        if (ret == SOCKET_ERROR)
        {
            printf("bind() faild! code:%d\n", WSAGetLastError());
            closesocket(sListen); //关闭套接字
            WSACleanup();
            //return 0;
        }
      
        //侦听连接请求
        ret = listen(sListen, 5);
        if (ret == SOCKET_ERROR)
        {
            printf("listen() faild! code:%d\n", WSAGetLastError());
            closesocket(sListen); //关闭套接字
            //return 0;
        }
      
        printf("Waiting for client connecting!\n");
        printf("Tips: Ctrl+c to quit!\n");
        //阻塞等待接受客户端连接
    	while(1)//循环监听客户端,永远不停止,所以,在本项目中,我们没有心跳包。
    	{
    		length = sizeof(saClient);
    		sServer = accept(sListen, (struct sockaddr *)&saClient, &length);
    		if (sServer == INVALID_SOCKET)
    		{
    			printf("accept() faild! code:%d\n", WSAGetLastError());
    			closesocket(sListen); //关闭套接字
    			WSACleanup();
    			return 0;
    		}  
    
    		char sendMessage[]="hello client";  //发送信息给客户端
    		send(sServer,sendMessage,strlen(sendMessage)+1,0);
    
    		char receiveMessage[5000];
    		nLeft = sizeof(receiveMessage);
    		ptr = (char *)&receiveMessage;
    		while(nLeft>0)
    		{
    			//接收数据
    			ret = recv(sServer, ptr, 5000, 0);
    			if (ret == SOCKET_ERROR)
    			{
    				printf("recv() failed!\n");
    				return 0;
    			}
    			if (ret == 0) //客户端已经关闭连接
    			{
    				printf("Client has closed the connection\n");
    				break;
    			}
    			nLeft -= ret;
    			ptr += ret;
    		}  
    		printf("receive message:%s\n", receiveMessage);//打印我们接收到的消息。
    		
    
    	} 
      //  closesocket(sListen);
      //  closesocket(sServer);
      //  WSACleanup();
    	return 0;
    }
    


     

            第一步,加载套接字库,和客户端得加载套接字一样。

     

            第二步,创建监听套接字,sListen=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);仍然使用的是socket函数。

     

            第三步,绑定。使用bind函数,该函数的作用是将一个创建好的套接字绑定到本地的某个地址和端口上,该函数的原型为:

    int bind(SOCKET s, const struct sockaddr FAR* name, int namelen);
    
    

    第一个参数,指定要绑定的套接字;

    第二个参数,指定该套接字的地址信息,这里即服务器的地址信息,它仍是指向struct sockaddr_in类型的结构体的指针。这个结构体和客户端调用connect函数之前构建服务器地址信息的一样。其中INADDR_ANY 是指示任意地址,因为服务器含有可能多个网卡,可能有多个IP地址,这边指选择一个任意可用的地址。

    第三个参数,地址的信息的长度。

     

            第四步,监听连接。使用listen函数,该函数是将指定的套接字设置为监听模式,如ret = listen(sListen, 5)。函数原型为

    int listen(SOCKET s, int backlog);
    


    第一个参数,是要设置为监听的套接字描述符。

    第二个参数,是等待连接队列的最大的长度。注意了,设置这个值是为了设置等待连接队列的最大长度,而不是在一个端口上可以连接的最大数目。例如,设置为5,当有6个连接请求同时到达,前面5个连接请求会被放到等待请求连接队列中,然后服务器依次处理这些请求服务,但是第6个连接请求会被拒绝。

     

           第五步,接受客户端的连接请求。使用accept函数接受客户端发送的连接请求,如sServer = accept(sListen, (struct sockaddr *)&saClient, &length);该函数的原型为

    SOCKET accept(SOCKET s, struct sockaddr FAR* addr, int FAR* addrlen);
    


    第一个参数,是一个已设为监听模式的socket的描述符。

    第二个参数,是一个返回值,它指向一个struct sockaddr类型的结构体的变量,保存了发起连接的客户端得IP地址信息和端口信息。

    第三个参数,也是一个返回值,指向整型的变量,保存了返回的地址信息的长度。

    accept函数返回值是一个客户端和服务器连接的SOCKET类型的描述符,在服务器端标识着这个客户端。

          

           第六、七步是发送和接收,分别使用send和recv函数,这里和客户端的一样,不再重复。

           accept函数是放在一个死循环中的,一直监听客户的请求。当服务器关闭时要关闭所有的套接字,和释放资源。

     

     

    展开全文
  • java 基于tcpsocket编程

    千次阅读 2018-12-05 21:05:11
    二、利用socket实现tcp网络通信 实现这个功能可以是c语言、java、python。我是用java写的,所以我以java为例进行socket简单叙说。 1、编译工具 我用的是elicpse(这里我插一段小故事,因为我把elicpse配置...

    一、计算机网络课

    计算机网络这门课真的和我们的日常和一些常识太精密了,无意中你会发现,唉这是计算机老师讲过的。只要你玩计算机,那么计算机网络常识你应该知道。

    二、利用socket实现tcp网络通信

    实现这个功能可以是c语言、java、python。我是用java写的,所以我以java为例进行socket简单叙说。

    1、编译工具

    我用的是elicpse(这里我插一段小故事,因为我把elicpse配置成web的环境了,所以我以为不可以写纯java的程序了,但是百度和查资料发现是可以的。在新建中选择other,你会看到java project,这样就可以了)。我建议使用elicpse,因为它的自动补齐代码,重要的是异常也可以帮助你处理。

    2、elicpse运行俩个程序

    看了网上好多的教程,说的真是复杂,关键还不实用,我是看了好久都没有解决,在这个问题比我编写代码还要累,花的时间都要久。其实这个非常简单(1)运行你的server代码(2)紧接着运行clicent代码(3)在console下的右边有一排小的的图标,你选择第四个就可以了。点击它选择你已运行的代码。

    注释:运行俩个代码后一个不会覆盖第二个,按照我说的做就一定可以成功。

    3、java包

    因为你要用到sockect和字符流等所以需要引进下面俩个包。

    import java.net.*;

    import java.io.*;

    如何使用里边的方法,大家需要认真学习java的理论知识了

    4、程序

    4.1这是老师布置的作业,所以我给大家看一下老师的要求。

    使用socket实现一个基于C/S架构的通信程序
    (1)客户端发送给服务器请求,发送表征身份的用户名和密码(“admin”,“123456”);
    (2)服务器根据客户端发来的信息验证身份,如果验证错误,返回“refuse”字符串,并且断开连接信道;
    (3)如果通过身份验证,服务器向客户端返回“accept”字符串;
    (4)客户端在收到“accept”后,发送服务请求号,“1”表示请求文件传输服务,“2”表示请求数据库查询服务;
    (5)服务器收到服务请求号后,用打印语句来模拟服务的动作,完成后返回“finish”字符串;
    (6)客户端收到“finish”串后,向服务器端发送“byebye”,终止连接;
    (7)双方中断连接,关闭socket。

    4.2server

    import java.io.BufferedReader;
    
    import java.io.BufferedReader;
    
    import java.io.IOException;
    
    importjava.io.InputStream;import
    
    java.io.InputStreamReader;import
    
    java.io.OutputStream;
    
    import java.io.PrintWriter;
    
    import java.net.*;
    public class server {
    public static void main(String[] args) throws UnknownHostException,IOException {
    
    // TODO Auto-generated method stub int port=9999;
    
    //服务器端口
    
    ServerSocket serverSocket =new ServerSocket(port);
    
    //建立连接 Socket socket=serverSocket.accept();
    
    System.out.println("server say connection success");
    
    String line; String input;
    
    BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));
    
    //输入流 PrintWriter os=new PrintWriter(socket.getOutputStream());
    
    //输出流 BufferedReader sin=new BufferedReader(new InputStreamReader(System.in,"utf-8")); //键盘读入的数据
    
    for(int j=0;j<=5;j++)
    
    { input=is.readLine();
    
    System.out.println(input);
    
    if(input.equals("jcy")) { os.println("accept");
    
    //向客户端输出的数据 os.flush(); }
    
    else if(input.equals("1"))
    
    { System.out.println("文件传输完成");
    
    os.println("finsh");//向客户端输出的数据 os.flush(); }
    
    else if(input.equals("2"))
    
    { System.out.println("数据库查询完成"); os.println("finsh");
    
    //向客户端输出的数据 os.flush();
    
    }else { os.println("refuse");
    
    //向客户端输出的数据
    
    os.flush(); os.close(); is.close(); socket.close(); //System.out.println("请输入2"); }
    } os.close(); is.close(); socket.close(); } 
    }
    
    

    4.3clicent

    import java.io.IOException;
    
    import java.io.*;
    
    import java.net.Socket;
    
    import java.net.UnknownHostException;
    public class clicent {
    public static void main(String[] args) throws UnknownHostException, IOException
    
    { // TODO Auto-generated method stub
    
    String host="localhost"; int port = 9999;
    
    Socket socket =new Socket(host,port);
    
    //建立连接 System.out.println("clicent say connction success too");
    
    BufferedReader sin=new BufferedReader(new InputStreamReader(System.in,"utf-8"));
    
    //键盘读入的数据 PrintWriter os=new PrintWriter(socket.getOutputStream());
    
    //输出流(往服务器发送的数据)
    
    BufferedReader is=new BufferedReader(new InputStreamReader(socket.getInputStream()));
    
    //输入流 //System.out.println("chdw");
    
    //System.out.println("server say :"+is.readLine());
    
    //键盘读入的数据 String readline=sin.readLine(); os.println(readline);
    
    //发送到server System.out.println(readline); os.flush();
    
    //刷新 for(int i=0;i<=5;i++){  
    
      String isread=is.readLine(); if(isread.equals("accept"))
    
    { System.out.println("请输入1或2");
    
    String comand=sin.readLine();
    
    os.println(comand); os.flush(); }
    
    else if(isread.equals("finsh"))
    
    { os.println("byebye"); os.flush(); }
    
    else { os.close(); is.close(); socket.close(); //System.out.println("请输入1"); } } os.close(); is.close(); socket.close(); }
    }
    

    代码不难,大家仔细看一下就会懂得。

    更详细的实现过程可以看我的博文:
    java 基于tcp的socket编程

    展开全文
  • Windows下C语言的基于TCPSocket编程

    千次阅读 2020-03-26 18:23:14
    Windows下C语言的基于TCPSocket编程 博客说明 文章所涉及的资料来自互联网整理和个人总结,意在于个人学习和经验汇总,如有什么地方侵权,请联系本人删除,谢谢! 说明 注意在windows平台是需要winsock2.h头文件...
  • 基于TCPSocket编程

    千次阅读 2018-06-06 13:46:28
    TCP/IP(Transmission Control Protocol/Internet Protocol) 即传输控制协议/网间协议,是一种面向连接(连接导向)的、可靠的、基于字节流的运输层(Transport layer)通信协议。在使用TCP协议传输数据,接收端...
  • 基于TCPsocket编程是采用的流式套接字。 在这个程序中,将两个工程添加到一个工作区。要链接一个ws2_32.lib的库文件。 服务器端编程的步骤: 1:加载套接字库,创建套接字(WSAStartup()/socket()); 2
  • 基于TCPsocket编程实现client和server通信 . 实验内容: . client为单线程、server为多线程(群聊功能) . 原理: . 套接字(socket)是一个抽象层,应用程序可以通过它发送或接收数据,可对其进行像对文件一样的...
  • QT基于TCPSocket编程

    千次阅读 2017-12-03 20:22:03
    1、在工程文件中加入QT += network 2、服务器除了使用到了QTcpSocket类,还需要用到QTcpSever类 (1)创建QTcpSever对象 ...tcpServer = new QTcpServer(this);  (2)监听端口 [cpp
  • 基于TCP/UDP的socket编程流程

    千次阅读 2018-03-08 21:30:20
    其实Socket编程也对应于TCP和...基于TCP(面向连接)的socket编程的服务器端程序如下: 1、创建套接字(socket) 2、将套接字绑定到一个本地地址和端口上(bind) 3、将套接字设为监听模式,准备接收客户端请求(l...
  • Android 基于TCPSocket 编程实现(结合 okio)

    万次阅读 多人点赞 2017-03-31 16:35:17
    两个进程如果要进行通讯最基本的一个前提就是能够唯一的标识一个进程,在本地进程通讯中我们可以使用 PID 来...我们知道 IP 层的 ip 地址可以唯一标示主机,而 TCP 层协议和端口号结合就可以唯一标示主机的一个进程了。
  • 基于TCPsocket编程网络掉线重连

    千次阅读 2013-10-24 01:51:55
    基于TCPsocket编程  sockets(套接字)编程有三种,流式套接字(SOCK_STREAM),数据报套接字(SOCK_DGRAM),原始套接字(SOCK_RAW);基于TCPsocket编程是采用的流式套接字。  正在装载数据…  在这个...
  • Windows系统下基于TCP的Sockets编程 一、前情提要 what’s TCP? 传输控制协议(TCP,Transmission Control Protocol)是一种面向连接的、可靠的、基于字节流的传输层通信协议,由IETF的RFC 793 [1] 定义。 TCP旨在...
  • Java基于TCPSocket编程练习

    千次阅读 2012-04-20 14:45:19
    环境:Notpad ++ 6.0 + JDK 6.0.31 问题:使用套接字编写客户—服务器...解决:利用Java的Socket编程。客户端发送数据,服务端接收数据,并进行相应的处理。 代码:  TcpServer.java:   import java.io.Buffere
  • golang TCP Socket编程

    千次阅读 2018-09-09 09:54:55
    上一篇文章介绍了golang进行UDP编程的方式,本篇文章继续golang的网络编程,我们看看如何实现TCP编程。UDP传输的是数据包,传输时不会建立实际的连接,UDP传输数据不会保证可靠性。TCP则不同,它会维持客户端和...
  • 基于TCPSocket编程:使用HashMap类来实现字符串的加密和解密 加密算法采用简单的字母映射,映射方式如下: 原文:abcdefghijklmnopqrstuvwxyz* 密文:veknohzf*iljxdmygbrcswqupta 使用HashMap类来实现字符...
  • Go语言TCP Socket编程

    千次阅读 2016-12-29 17:03:18
    在日常应用中,我们也可以看到Go中的net以及其subdirectories下的包均是“高频+刚需”,而TCP socket则是网络编程的主流,即便您没有直接使用到net中有关TCP Socket方面的接口,但net/http总是用到了吧,http底层...
  • 声明:本教程不收取任何费用,欢迎转载,尊重作者劳动成果,不得...上篇讲了基于tcp的编程,服务器端循环监听接收多个客户端_多线程服务器程序,如需了解可参考 java网络编程:9、基于TCPsocket编程(二)循环...
  • TCP是面向连接的,安全可靠的,相比UDP性能低一些。它底层和UDP不一样,UDP使用的是数据包进行传输,包里面写目标地址,TCP是使用IO流做操作。 大家上网的时候在浏览器输入URL,URL请求服务器的资源,服务器根据你的...
  • 关键步骤如下: 1、两个端点进行连接 2、打开传递信息的输入/输出流 3、传递数据,接受数据 4、关闭连接。 ...模拟用户登录的功能,实现:客户发送登录用户信息...3、打开Socket关联的输入/输出流。 4、向输出流中...
  • CC3200 TCP socket编程

    千次阅读 2016-11-10 19:38:45
    对于TCP,服务器先创建TCP套接字sl_Socket,并将其绑定在TCP服务器地址sl_Bind,然后指定端口监听sl_Listen,并接受TCP连接sl_Accept,一单建立起TCP连接,就能进行数据接受sl_Recv和数据传送sl_Send,最后关闭TCP套接字...
  • 接收: 创建TCP服务端的Socket对象 监听客户端对象 获取输入流,读取数据 释放资源客户端:通过指定一个InetAddress对象和一个端口号,创建一个Socket对象,通过这个对象,连接到服务器。 发送: 创建...
  • Linux下C语言实现TCP Socket编程

    千次阅读 2019-01-16 18:25:24
    TCP/IP(Transmission Control Protocol/Internet Protocol) 即传输控制协议/网间协议,是一种面向连接(连接导向)的、可靠的、基于字节流的运输层(Transport layer)通信协议。 TCP服务器端和客户端流程: 具体...
  • 计算机网络实验——基于TCP协议的socket编程

    万次阅读 多人点赞 2018-06-15 16:44:03
    4. 实现TCP套接字编程。 二、实验内容(一)实验思路1、学习理解TCP协议。2、实现TCP客户端之间多线程通信以及聊天页面的UI实现。 (二)实验步骤1、理解TCP协议。TCP(Transmission Control Proto...
  • 基于TCP(面向连接)的socket编程,分为客户端和服务器端。 客户端的流程如下: (1)创建套接字(socket) (2)向服务器发出连接请求(connect) (3)和服务器端进行通信(send/recv) (4)关闭套接字 服务器端...
  • 【socket】基于TCP和UDP的Socket编程

    千次阅读 2018-09-06 22:56:30
    socket socket是应用层与TCP/IP协议族通信的中间软件抽象层,它是一组接口,把复杂的TCP/IP协议族隐藏在socket接口后面,一组简单的接口就是全部,让socket去组织数据,以符合指定...基于TCP协议的socket编程 简单...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 77,126
精华内容 30,850
关键字:

基于tcp的socket编程