碼上快樂

相關內容    簡體    繁體

Python中的 socket示例

本文轉載自   查看原文   2018-05-13 23:22   1040 

linux send與recv函數詳解

  
1 #include <sys/socket.h>
2 ssize_t recv(int sockfd, void *buff, size_t nbytes, int flags);
3 ssize_t send(int sockfd, const void *buff, size_t nbytes, int flags);

recv 和send的前3個參數等同於read和write。

flags參數值為0或：

 
flags 說明 recv send
 MSG_DONTROUTE 繞過路由表查找      •
 MSG_DONTWAIT 僅本操作非阻塞    •       •
 MSG_OOB　　　　 發送或接收帶外數據   •   •
 MSG_PEEK　　 窺看外來消息   •  
 MSG_WAITALL　　 等待所有數據    •  

 1. send解析

 sockfd：指定發送端套接字描述符。

 buff：    存放要發送數據的緩沖區

 nbytes:  實際要改善的數據的字節數

 flags：   一般設置為0

 1) send先比較發送數據的長度nbytes和套接字sockfd的發送緩沖區的長度，如果nbytes > 套接字sockfd的發送緩沖區的長度, 該函數返回SOCKET_ERROR;

 2) 如果nbtyes <= 套接字sockfd的發送緩沖區的長度，那么send先檢查協議是否正在發送sockfd的發送緩沖區中的數據，如果是就等待協議把數據發送完，如果協議還沒有開始發送sockfd的發送緩沖區中的數據或者sockfd的發送緩沖區中沒有數據，那么send就比較sockfd的發送緩沖區的剩余空間和nbytes

 3) 如果 nbytes > 套接字sockfd的發送緩沖區剩余空間的長度，send就一起等待協議把套接字sockfd的發送緩沖區中的數據發送完

 4) 如果 nbytes < 套接字sockfd的發送緩沖區剩余空間大小，send就僅僅把buf中的數據copy到剩余空間里(注意並不是send把套接字sockfd的發送緩沖區中的數據傳到連接的另一端的，而是協議傳送的，send僅僅是把buf中的數據copy到套接字sockfd的發送緩沖區的剩余空間里)。

 5) 如果send函數copy成功，就返回實際copy的字節數，如果send在copy數據時出現錯誤，那么send就返回SOCKET_ERROR; 如果在等待協議傳送數據時網絡斷開，send函數也返回SOCKET_ERROR。

 6) send函數把buff中的數據成功copy到sockfd的改善緩沖區的剩余空間后它就返回了，但是此時這些數據並不一定馬上被傳到連接的另一端。如果協議在后續的傳送過程中出現網絡錯誤的話，那么下一個socket函數就會返回SOCKET_ERROR。（每一個除send的socket函數在執行的最開始總要先等待套接字的發送緩沖區中的數據被協議傳遞完畢才能繼續，如果在等待時出現網絡錯誤那么該socket函數就返回SOCKET_ERROR）

 7) 在unix系統下，如果send在等待協議傳送數據時網絡斷開，調用send的進程會接收到一個SIGPIPE信號，進程對該信號的處理是進程終止。

2.recv函數

sockfd: 接收端套接字描述符

buff：   用來存放recv函數接收到的數據的緩沖區

nbytes: 指明buff的長度

flags:   一般置為0

 1) recv先等待s的發送緩沖區的數據被協議傳送完畢，如果協議在傳送sock的發送緩沖區中的數據時出現網絡錯誤，那么recv函數返回SOCKET_ERROR

 2) 如果套接字sockfd的發送緩沖區中沒有數據或者數據被協議成功發送完畢后，recv先檢查套接字sockfd的接收緩沖區，如果sockfd的接收緩沖區中沒有數據或者協議正在接收數據，那么recv就一起等待，直到把數據接收完畢。當協議把數據接收完畢，recv函數就把s的接收緩沖區中的數據copy到buff中（注意協議接收到的數據可能大於buff的長度，所以在這種情況下要調用幾次recv函數才能把sockfd的接收緩沖區中的數據copy完。recv函數僅僅是copy數據，真正的接收數據是協議來完成的）

 3) recv函數返回其實際copy的字節數，如果recv在copy時出錯，那么它返回SOCKET_ERROR。如果recv函數在等待協議接收數據時網絡中斷了，那么它返回0。

 4) 在unix系統下，如果recv函數在等待協議接收數據時網絡斷開了，那么調用 recv的進程會接收到一個SIGPIPE信號，進程對該信號的默認處理是進程終止。

 

  1. //client.c  
  2. #include <stdio.h>  
  3. #include <stdlib.h>  
  4. #include <string.h>  
  5. #include <unistd.h>  
  6. #include <sys/types.h>  
  7. #include <sys/socket.h>  
  8. #include <arpa/inet.h>  
  9. #include <netinet/in.h>  
  10. #include <fcntl.h>  
  11.   
  12. #define N 256  
  13.   
  14. typedef struct sockaddr SA;  
  15.   
  16. void commd_help();  
  17. void commd_exit();  
  18. void commd_ls(struct sockaddr_in, char *);  
  19. void commd_get(struct sockaddr_in , char *);  
  20. void commd_put(struct sockaddr_in , char *);  
  21.   
  22. int main(int argc, char *argv[])  
  23. {  
  24.     char commd[N];  
  25.     struct sockaddr_in addr;  
  26.     int len;  
  27.     bzero(&addr, sizeof(addr));     //將＆addr中的前sizeof（addr）字節置為0，包括'\0'  
  28.     addr.sin_family = AF_INET;      //AF_INET代表TCP／IP協議  
  29.     addr.sin_addr.s_addr = inet_addr("127.0.0.1"); //將點間隔地址轉換為網絡字節順序  
  30.     addr.sin_port = htons(8989);    //轉換為網絡字節順序  
  31.     len = sizeof(addr);  
  32.   
  33.     while(1)  
  34.     {  
  35.         printf("ftp>");  
  36.         bzero(commd,N);  
  37.         //fgets函數從stdin流中讀取N-1個字符放入commd中  
  38.         if(fgets(commd,N,stdin) == NULL)  
  39.         {  
  40.             printf("Fgets Error!\n");  
  41.             return -1;  
  42.         }  
  43.   
  44.         commd[strlen(commd)-1]='\0';    //fgets函數讀取的最后一個字符為換行符，此處將其替換為'\0'  
  45.   
  46.         printf("Input Command Is [ %s ]\n",commd);  
  47.   
  48.         if(strncmp(commd,"help",4) == 0) //比較兩個字符串前4個字節，若相等則返回0  
  49.         {  
  50.             commd_help();  
  51.         }else if(strncmp(commd, "exit",4) == 0)  
  52.         {  
  53.             commd_exit();  
  54.             exit(0);   //結束進程  
  55.         }else if(strncmp(commd, "ls" , 2) == 0)  
  56.         {  
  57.             commd_ls(addr, commd);  
  58.         }else if(strncmp(commd, "get" , 3) == 0)  
  59.         {  
  60.             commd_get(addr, commd);  
  61.         }else if(strncmp(commd, "put", 3) ==0 )  
  62.         {  
  63.             commd_put(addr, commd);  
  64.         }else  
  65.         {  
  66.             printf("Command Is Error!Please Try Again!\n");  
  67.         }  
  68.   
  69.     }  
  70.     return 0;  
  71. }  
  72.   
  73. void commd_help()  
  74. {  
  75.   
  76.     printf("\n=------------------- Welcome to Use the Ftp ----------------=\n");  
  77.     printf("|                                                           |\n");  
  78.     printf("|  help : Display All Command for the Server                |\n");  
  79.     printf("|                                                           |\n");  
  80.     printf("|   exit: Quit The Sever                                    |\n");  
  81.     printf("|                                                           |\n");  
  82.     printf("|   ls : Display All file On the Ftp Server                 |\n");  
  83.     printf("|                                                           |\n");  
  84.     printf("| get <file>: Download FIle from the Ftp Server             |\n");  
  85.     printf("|                                                           |\n");  
  86.     printf("| put <file>: Upload FIle to the Ftp Server                 |\n");  
  87.     printf("|                                                           |\n");  
  88.     printf("=-----------------------------------------------------------=\n");  
  89.   
  90.     return ;  
  91. }  
  92.   
  93. void commd_exit()  
  94. {  
  95.     printf("Byte!\n");  
  96. }  
  97.   
  98. void commd_ls(struct sockaddr_in addr, char *commd)  
  99. {  
  100.     int sockfd;  
  101.     //創建套接字  
  102.     if((sockfd=socket(AF_INET, SOCK_STREAM, 0)) < 0)  
  103.     {  
  104.         printf("Socket Error!\n");  
  105.         exit(1);  
  106.     }  
  107.   
  108.     if(connect(sockfd, (SA *)&addr, sizeof(addr)) < 0)  
  109.     {  
  110.         printf("Connect Error!\n");  
  111.         exit(1);  
  112.     }  
  113.     //將commd指向的內容寫入到sockfd所指的文件中，此處即指套接字  
  114.     if(write(sockfd, commd, N) < 0)  
  115.     {  
  116.         printf("Write Error!\n");  
  117.         exit(1);  
  118.     }  
  119.   
  120.     while(read(sockfd, commd, N) > 0)  //從sockfd中讀取N字節內容放入commd中，  
  121.     {                                   //返回值為讀取的字節數  
  122.         printf(" %s ",commd);  
  123.     }  
  124.     printf("\n");  
  125.   
  126.     close(sockfd);  
  127.     return ;  
  128. }  
  129. /**************************************************/  
  130. /*函數功能:實現文件的下載                            */  
  131. /**************************************************/  
  132. void commd_get(struct sockaddr_in addr, char *commd)  
  133. {  
  134.     int fd;  
  135.     int sockfd;  
  136.     char buffer[N];  
  137.     int nbytes;  
  138.     //創建套接字，並進行錯誤檢測  
  139.     if((sockfd=socket(AF_INET, SOCK_STREAM, 0)) < 0)  
  140.     {  
  141.         printf("Socket Error!\n");  
  142.         exit(1);  
  143.     }  
  144.     //connect函數用於實現客戶端與服務端的連接,此處還進行了錯誤檢測  
  145.     if(connect(sockfd, (SA *)&addr, sizeof(addr)) < 0)  
  146.     {  
  147.         printf("Connect Error!\n");  
  148.         exit(1);  
  149.     }  
  150.     //通過write函數向服務端發送數據  
  151.     if(write(sockfd, commd, N) < 0)  
  152.     {  
  153.         printf("Write Error!At commd_get 1\n");  
  154.         exit(1);  
  155.     }  
  156.     //利用read函數來接受服務器發來的數據  
  157.     if(read(sockfd, buffer, N) < 0)  
  158.     {  
  159.         printf("Read Error!At commd_get 1\n");  
  160.         exit(1);  
  161.     }  
  162.     //用於檢測服務器端文件是否打開成功  
  163.     if(buffer[0] =='N')  
  164.     {  
  165.         close(sockfd);  
  166.         printf("Can't Open The File!\n");  
  167.         return ;  
  168.     }  
  169.     //open函數創建一個文件，文件地址為(commd+4)，該地址從命令行輸入獲取  
  170.     if((fd=open(commd+4, O_WRONLY|O_CREAT|O_TRUNC, 0644)) < 0)  
  171.     {  
  172.         printf("Open Error!\n");  
  173.         exit(1);  
  174.     }  
  175.     //read函數從套接字中獲取N字節數據放入buffer中，返回值為讀取的字節數  
  176.     while((nbytes=read(sockfd, buffer, N)) > 0)  
  177.     {  
  178.         //write函數將buffer中的內容讀取出來寫入fd所指向的文件，返回值為實際寫入的字節數  
  179.         if(write(fd, buffer, nbytes) < 0)  
  180.         {  
  181.             printf("Write Error!At commd_get 2");  
  182.         }  
  183.     }  
  184.   
  185.     close(fd);  
  186.     close(sockfd);  
  187.   
  188.     return ;  
  189.   
  190. }  
  191. /**************************************************/  
  192. /*函數功能:實現文件的上傳                            */  
  193. /**************************************************/  
  194. void commd_put(struct sockaddr_in addr, char *commd)  
  195. {  
  196.     int fd;  
  197.     int sockfd;  
  198.     char buffer[N];  
  199.     int nbytes;  
  200.     //創建套接字  
  201.     if((sockfd=socket(AF_INET, SOCK_STREAM, 0)) < 0)  
  202.     {  
  203.         printf("Socket Error!\n");  
  204.         exit(1);  
  205.     }  
  206.     //客戶端與服務端連接  
  207.     if(connect(sockfd, (SA *)&addr, sizeof(addr)) < 0)  
  208.     {  
  209.         printf("Connect Error!\n");  
  210.         exit(1);  
  211.     }  
  212.     //從commd中讀取N字節數據，寫入套接字中  
  213.     if(write(sockfd, commd, N)<0)  
  214.     {  
  215.         printf("Wrtie Error!At commd_put 1\n");  
  216.         exit(1);  
  217.     }  
  218.     //open函數從(commd+4)中，讀取文件路徑，以只讀的方式打開  
  219.     if((fd=open(commd+4, O_RDONLY)) < 0)  
  220.     {  
  221.         printf("Open Error!\n");  
  222.         exit(1);  
  223.     }  
  224.     //從fd指向的文件中讀取N個字節數據  
  225.     while((nbytes=read(fd, buffer, N)) > 0)  
  226.     {  
  227.         //從buffer中讀取nbytes字節數據，寫入套接字中  
  228.         if(write(sockfd, buffer, nbytes) < 0)  
  229.         {  
  230.             printf("Write Error!At commd_put 2");  
  231.         }  
  232.     }  
  233.   
  234.     close(fd);  
  235.     close(sockfd);  
  236.   
  237.     return ;  
  238. }  

 

    下面server.c中后面有些注釋沒加，感覺功能上跟client相似，就沒加，可以參看前面的

 

[cpp]  view plain  copy
 
  1. //server.c  
  2. #include <stdio.h>  
  3. #include <stdlib.h>  
  4. #include <unistd.h>  
  5. #include <string.h>  
  6. #include <sys/types.h>  
  7. #include <sys/socket.h>  
  8. #include <arpa/inet.h>  
  9. #include <dirent.h>  
  10. #include <fcntl.h>  
  11.   
  12. #define N 256  
  13.   
  14. typedef struct sockaddr SA;  
  15.   
  16. void commd_ls(int);  
  17. void commd_get(int, char *);  
  18. void commd_put(int, char *);  
  19.   
  20. int main(int arg, char *argv[])  
  21. {  
  22.     int ser_sockfd,cli_sockfd;  
  23.     struct sockaddr_in ser_addr,cli_addr;  
  24.     int ser_len, cli_len;  
  25.     char commd [N];  
  26.     bzero(commd,N);//將commd所指向的字符串的前N個字節置為0，包括'\0'  
  27.   
  28.     if((ser_sockfd=socket(AF_INET, SOCK_STREAM, 0) ) < 0)  
  29.     {  
  30.         printf("Sokcet Error!\n");  
  31.         return -1;  
  32.     }  
  33.   
  34.     bzero(&ser_addr,sizeof(ser_addr));  
  35.     ser_addr.sin_family = AF_INET;  
  36.     ser_addr.sin_addr.s_addr = htonl(INADDR_ANY);//在TCP連接中，此處類似於自動獲取ip地址  
  37.                                                 //在綁定ip時，自動選擇ip地址  
  38.     ser_addr.sin_port = htons ( 8989 );  
  39.     ser_len = sizeof(ser_addr);  
  40.     //將ip地址與套接字綁定  
  41.     if((bind(ser_sockfd, (SA *)&ser_addr, ser_len)) < 0)  
  42.     {  
  43.         printf("Bind Error!\n");  
  44.         return -1;  
  45.     }  
  46.     //服務器端監聽  
  47.     if(listen(ser_sockfd, 5) < 0)  
  48.     {  
  49.         printf("Linsten Error!\n");  
  50.         return -1;  
  51.     }  
  52.   
  53.     bzero(&cli_addr, sizeof(cli_addr));  
  54.     ser_len = sizeof(cli_addr);  
  55.   
  56.     while(1)  
  57.     {  
  58.         printf("server_ftp>");  
  59.         //服務器端接受來自客戶端的連接，返回一個套接字，此套接字為新建的一個，並將客戶端的地址等信息存入cli_addr中  
  60.         //原來的套接字仍處於監聽中  
  61.         if((cli_sockfd=accept(ser_sockfd, (SA *)&cli_addr, &cli_len)) < 0)  
  62.         {  
  63.             printf("Accept Error!\n");  
  64.             exit(1);  
  65.         }  
  66.         //由套接字接收數據時，套接字把接收的數據放在套接字緩沖區，再由用戶程序把它們復制到用戶緩沖區，然后由read函數讀取  
  67.         //write函數同理  
  68.         if(read(cli_sockfd, commd, N) < 0)  //read函數從cli_sockfd中讀取N個字節數據放入commd中  
  69.         {  
  70.             printf("Read Error!\n");  
  71.             exit(1);  
  72.         }  
  73.   
  74.         printf("recvd [ %s ]\n",commd);  
  75.   
  76.         if(strncmp(commd,"ls",2) == 0)  
  77.         {  
  78.             commd_ls(cli_sockfd);  
  79.         }else if(strncmp(commd,"get", 3) == 0 )  
  80.         {  
  81.             commd_get(cli_sockfd, commd+4);  
  82.         }else if(strncmp(commd, "put", 3) == 0)  
  83.         {  
  84.             commd_put(cli_sockfd, commd+4);  
  85.         }else  
  86.         {  
  87.             printf("Error!Command Error!\n");  
  88.         }  
  89.     }  
  90.   
  91.     return 0;  
  92. }  
  93.   
  94. void commd_ls(int sockfd)  
  95. {  
  96.     DIR * mydir =NULL;  
  97.     struct dirent *myitem = NULL;  
  98.     char commd[N] ;  
  99.     bzero(commd, N);  
  100.     //opendir為目錄操作函數，類似於open函數  
  101.     //mydir中存有相關目錄的信息（有待學習）  
  102.     if((mydir=opendir(".")) == NULL)  
  103.     {  
  104.         printf("OpenDir Error!\n");  
  105.         exit(1);  
  106.     }  
  107.   
  108.     while((myitem = readdir(mydir)) != NULL)  
  109.     {  
  110.         if(sprintf(commd, myitem->d_name, N) < 0)  
  111.         {  
  112.             printf("Sprintf Error!\n");  
  113.             exit(1);  
  114.         }  
  115.   
  116.         if(write(sockfd, commd, N) < 0 )  
  117.         {  
  118.             printf("Write Error!\n");  
  119.             exit(1);  
  120.         }  
  121.     }  
  122.   
  123.     closedir(mydir);  
  124.     close(sockfd);  
  125.   
  126.     return ;  
  127. }  
  128.   
  129. void commd_get(int sockfd, char *filename)  
  130. {  
  131.     int fd, nbytes;  
  132.     char buffer[N];  
  133.     bzero(buffer, N);  
  134.   
  135.     printf("get filename : [ %s ]\n",filename);  
  136.     if((fd=open(filename, O_RDONLY)) < 0)  
  137.     {  
  138.         printf("Open file Error!\n");  
  139.         buffer[0]='N';  
  140.         if(write(sockfd, buffer, N) <0)  
  141.         {  
  142.             printf("Write Error!At commd_get 1\n");  
  143.             exit(1);  
  144.         }  
  145.         return ;  
  146.     }  
  147.   
  148.     buffer[0] = 'Y';    //此處標示出文件讀取成功  
  149.     if(write(sockfd, buffer, N) <0)  
  150.     {  
  151.         printf("Write Error! At commd_get 2!\n");  
  152.         close(fd);  
  153.         exit(1);  
  154.     }  
  155.   
  156.     while((nbytes=read(fd, buffer, N)) > 0)  
  157.     {  
  158.         if(write(sockfd, buffer, nbytes) < 0)  
  159.         {  
  160.             printf("Write Error! At commd_get 3!\n");  
  161.             close(fd);  
  162.             exit(1);  
  163.         }  
  164.     }  
  165.   
  166.     close(fd);  
  167.     close(sockfd);  
  168.   
  169.     return ;  
  170. }  
  171.   
  172. void commd_put(int sockfd, char *filename)  
  173. {  
  174.     int fd, nbytes;  
  175.     char buffer[N];  
  176.     bzero(buffer, N);  
  177.   
  178.     printf("get filename : [ %s ]\n",filename);  
  179.     if((fd=open(filename, O_WRONLY|O_CREAT|O_TRUNC, 0644)) < 0)  
  180.     {  
  181.         printf("Open file Error!\n");  
  182.         return ;  
  183.     }  
  184.   
  185.     while((nbytes=read(sockfd, buffer, N)) > 0)  
  186.     {  
  187.         if(write(fd, buffer, nbytes) < 0)  
  188.         {  
  189.             printf("Write Error! At commd_put 1!\n");  
  190.             close(fd);  
  191.             exit(1);  
  192.         }  
  193.     }  
  194.   
  195.     close(fd);  
  196.     close(sockfd);  
  197.   
  198.     return ;  
  199. }  

    1. 一、 服務器server的寫法：

      1. 創建 socket 套接字：

      網絡編程接口 socket(family = AF_INET , type = SOCKET_STREM，proto = 0, fileno = None)   提供了多種socket family。AF_INET 是默認的family，需要綁定IP和端口。 127.0.0.1是一個特殊的IP地址，表示本機地址。如果綁定到這個地址，客戶端必須同時在本機運行才能連接，也就是說，外部的計算機無法連接進來。

      不同的協議family使用的地址形式不同，通常來說我們使用的是AF_INET-----地址是以(IP,PORT)形式存。在type 類型，我們常用的有兩種 SOCKET_STREM ，流式套接字，表示基於連接的TCP套接字，SOCKET_DGRAM, 數據報套接字，基於無連接的（UDP)接口。　如果不設定，默認就是 SOCKET_STREM 。

      2. bind 綁定     

      使用方法：socket.bind(address)  把套接字綁定在 address 上，address的形式 根據 family 來設定。不管是client還是server，創建socket的時候都是通過一個本地的文件來進行的。　　

      3. listen 監聽      

      使用方法：socket.listen([backlog])　　使能 socket 接收連接請求，listen(self,backlog = None) ，backlog需要大於0，指定了可以緩存的連接請求的數量。

      4. accept 接受請求連接

      在等待一個即將來臨的連接，會返回一個代表連接的新的socket，還會返回一個地址(host和port)，可以用兩個東西接收，前一個代表新的socket,后一個就是接收地址。

      寫的方法：connet_socket,client_addr = srv.accept() connet_socket就是新的socket，然后connet_socket開始接下來的傳輸。connet_socket,client_addr，前者表示接收的新的socket，后者就是地址，具體看程序第10行。

      5. 接收數據　　

      使用方法：socket.recv(bufsize[,flags])　　從 socket 中接收數據，返回的是 bytes ，是接收到的內容。bufsize指定了一次最多接收多少個數據,如果沒有數據接收，程序會阻塞，一直到有數據或者遠程終端斷開連接.

      6. 發送數據　　

      使用方法：socket.send(bytes[, flags])　　你的socket必須和遠程的socket建立了聯系，返回值是發送的數量，可以判斷你的數據是否發送完畢，如果沒有，繼續send余下來的數據

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      import socket
      hostname = '127.0.0.1' #設置主機名
      port = 6666  #設置端口號 要確保這個端口號沒有被使用，可以在cmd里面查看
      addr = (hostname,port)
      srv = socket.socket() #創建一個socket
      srv.bind(addr)
      srv.listen( 5 )
      print ( "waitting connect" )
      while True :
        connect_socket,client_addr = srv.accept()
        print (client_addr)
        recevent = connect_socket.recv( 1024 )
        print ( str (recevent,encoding = 'gbk' ))
        connect_socket.send.send(bytes( "你好，數據傳輸完成，這里是gaby-yan--server" ,encoding = 'gbk' ))
        connect_socket.close()

      二、 客戶端client的寫法：

      客戶端的寫法相對比較簡單，只有

      1.創建socket　　

      2. 建立連接 connect　　

      3. 發送 send　　

      4. 接收recv　　

      這是由於他們的傳遞編程框架不同造成的，如圖。

       

      ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      import socket
      hostname = '127.0.0.1'
      port = 7777
      addr = (hostname,port)
       
      clientsock = socket.socket() ## 創建一個socket
      clientsock.connect(addr) # 建立連接
       
      say = input ( "輸入你想傳送的消息：" )
      clientsock.send(bytes(say,encoding = 'gbk' )) #發送消息
      recvdata = clientsock.recv( 1024 )  #接收消息 recvdata 是bytes形式的
      print ( str (recvdata,encoding = 'gbk' )) # 我們看不懂bytes，所以轉化為 str
      clientsock.close()

      注意：先運行server的代碼，再運行client的代碼。


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 socket端口重定向（python示例） ioctl在socket中的一些用法及示例 python中的socket Python中socket編程 Python中socket解讀 Python中的socket 模塊 python中的socket模塊 Python Socket 編程——聊天室示例程序 Python--網絡編程-----socket編程示例--打電話 python中socket模塊詳解
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM