socketudp編程
㈠ UDP和Socket通信步驟
這是在網上找到的，希望對你有所幫助。
sockets（套接字）編程有三種，流式套接字（SOCK_STREAM），數據報套接字（SOCK_DGRAM），原始套接字（SOCK_RAW）；
WINDOWS環境下TCP/UDP編程步驟：
1. 基於TCP的socket編程是採用的流式套接字。
在這個程序中，將兩個工程添加到一個工作區。要鏈接一個ws2_32.lib的庫文件。
伺服器端編程的步驟：
1：載入套接字型檔，創建套接字(WSAStartup()/socket())；
2：綁定套接字到一個IP地址和一個埠上(bind())；
3：將套接字設置為監聽模式等待連接請求(listen())；
4：請求到來後，接受連接請求，返回一個新的對應於此次連接的套接字(accept())；
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();
}
2.基於UDP的socket編程是採用的數據報套接字。
在這個程序中，將兩個工程添加到一個工作區。同時還要鏈接一個ws2_32.lib的庫文件。
伺服器端編程的步驟：
1：載入套接字型檔，創建套接字(WSAStartup()/socket())；
2：綁定套接字到一個IP地址和一個埠上(bind())；
3：等待和接收數據(sendto()/recvfrom())；
4：關閉套接字，關閉載入的套接字型檔(closesocket()/WSACleanup())。
伺服器端代碼如下：
#include <winsock2.h>
#include <stdio.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_DGRAM,0);
SOCKADDR_IN addrSrv;
addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
addrSrv.sin_family=AF_INET;
addrSrv.sin_port=htons(7003);
bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));
char recvBuf[50];
SOCKADDR addrClient;
int len=sizeof(SOCKADDR);
recvfrom(sockSrv,recvBuf,50,0,(SOCKADDR*)&addrClient,&len);
printf("%s\n",recvBuf);
closesocket(sockSrv);
WSACleanup();
}
對於基於UDP的socket客戶端來說，要進行如下步驟：
1：創建一個套接字(socket)；
2：向伺服器發送數據(sendto);
3：關閉套接字；
代碼如下：
#include <winsock2.h>
#include <stdio.h>
void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 2, 2 );
err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 ) {
return;
}
if ( LOBYTE( wsaData.wVersion ) != 2 ||
HIBYTE( wsaData.wVersion ) != 2 ) {
WSACleanup( );
return;
}
SOCKET sockClient=socket(AF_INET,SOCK_DGRAM,0);
SOCKADDR_IN addrClient;
addrClient.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
addrClient.sin_family=AF_INET;
addrClient.sin_port=htons(8889);
SOCKADDR_IN addrSrv;
sendto(sockClient,"hi",3,0,(SOCKADDR*)&addrClient,sizeof(SOCKADDR));
}
LINUX環境下TCP/UDP編程步驟：
TCP編程步驟：
一. 服務端：
1.socket(int domain,int type,int protocol):建立套接字；
2 .bind(int sockid,struct sockaddr *addrp,socklen_t addrlen):把本機地址和埠跟上一步建立的socket綁定在一起；
3.listen(int sockid,int qsize):監聽某套接字;
4.fd=accept(int sockid,struct sockaddr *callerid,socklen_t *addrlenp):等待某套接字接收信息；
5.recv(int fd,void *buf,size_t nbytes,int flags):從套接字接收數據;
6.close(fd) 和close(sockid)
二.客戶端：
1. socket():建立套接字；
2.connect(int sockid,struct sockaddr *serv_addrp,socklen_t addrlen):連接到伺服器；
3. send(int sockfd,const void *buf,size_t nbytes,int flags):發送數據到伺服器.
4. close(sockid);
UDP編程步驟：
一，服務端：
1. socket():同上；
2. bind():同上；
3. recvfrom(int sockfd,void*buff,size_t nbytes,int flags,struct sockaddr*from,socklen_t*addrlen):在套接字口接收數據，並且記錄下接收到的數據來源;一定要注意這里的參數addrlen，它不僅是函數的輸出，也是函數的輸入！所以要在調用該函數之前對addrlen賦值sizeof(struct sockaddr)。否則返回的地址from將會出錯！
4. close(sockfd);
二. 客戶端：
1. socket();同上；
2. sendto(int sockfd,const void*buff,size_t nbytes,int flags,const struct sockaddr*to,socklen_t addrlen):往指定的地址發送數據；
3. close(sockfd);
㈡ TCP 和 UDP 在socket編程中的區別
UDP和TCP編程步驟也有些不同，如下：
TCP編程的伺服器端一般步驟是：
1、創建一個socket，用函數socket()；
2、設置socket屬性，用函數setsockopt(); * 可選
3、綁定IP地址、埠等信息到socket上，用函數bind();
4、開啟監聽，用函數listen()；
5、接收客戶端上來的連接，用函數accept()；
6、收發數據，用函數send()和recv()，或者read()和write();
7、關閉網路連接；
8、關閉監聽；
TCP編程的客戶端一般步驟是：
1、創建一個socket，用函數socket()；
2、設置socket屬性，用函數setsockopt();* 可選
3、綁定IP地址、埠等信息到socket上，用函數bind();* 可選
4、設置要連接的對方的IP地址和埠等屬性；
5、連接伺服器，用函數connect()；
6、收發數據，用函數send()和recv()，或者read()和write();
7、關閉網路連接；
與之對應的UDP編程步驟要簡單許多，分別如下：
UDP編程的伺服器端一般步驟是：
1、創建一個socket，用函數socket()；
2、設置socket屬性，用函數setsockopt();* 可選
3、綁定IP地址、埠等信息到socket上，用函數bind();
4、循環接收數據，用函數recvfrom();
5、關閉網路連接；
UDP編程的客戶端一般步驟是：
1、創建一個socket，用函數socket()；
2、設置socket屬性，用函數setsockopt();* 可選
3、綁定IP地址、埠等信息到socket上，用函數bind();* 可選
4、設置對方的IP地址和埠等屬性;
5、發送數據，用函數sendto();
6、關閉網路連接；
㈢ C語言 UDP socket 簡單客戶端 編程，急
提一下，你那個地址不好用，換成了127.0.0.1，埠可以用，完全按照要求寫的，編譯沒錯誤，調試通過：
gcc server.c -o server
gcc client.c -o client
打開2個控制台：一個運行 ./server 另一個運行 ./client
server.c:
========================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <errno.h>
#define BUFFERSIZE 1024
typedef struct sockaddr SA;
int main(void)
{
char buf[BUFFERSIZE];
struct sockaddr_in addr_s;
struct sockaddr_in addr_c;
int sockfd;
socklen_t length;
int i;
if((sockfd = socket(AF_INET,SOCK_DGRAM,0)) == -1)
{
perror("socket fail");
return -1;
}
memset(&addr_s,0,sizeof(addr_s));
addr_s.sin_family = AF_INET;
addr_s.sin_addr.s_addr = inet_addr("127.0.0.1");
addr_s.sin_port = htons(31180);
if(bind(sockfd,(SA *)&addr_s,sizeof(addr_s)) == -1)
{
perror("bind fail");
return -1;
}
length = sizeof(addr_c);
memset(buf,'\0',sizeof(buf));
if(recvfrom(sockfd,buf,sizeof(buf),0
,(SA *)&addr_c,&length) == -1)
{
perror("recvfrom fail");
}
printf("recvfrom client:%s\n",buf);
sendto(sockfd,buf,sizeof(buf),0,(SA *)&addr_c,sizeof(addr_c));
close(sockfd);
}
====================================
client.c:
====================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <errno.h>
#define BUFFERSIZE 1024
typedef struct sockaddr SA;
int main(void)
{
int sockfd;
char buf[BUFFERSIZE];
struct sockaddr_in addr_s;
if((sockfd = socket(AF_INET,SOCK_DGRAM,0)) == -1)
{
perror("socket fail");
return -1;
}
memset(&addr_s,0,sizeof(addr_s));
addr_s.sin_family = AF_INET;
addr_s.sin_addr.s_addr = inet_addr("127.0.0.1");
addr_s.sin_port = htons(31180);
memset(buf,'\0',sizeof(buf));
sprintf(buf,"abcde");
if(sendto(sockfd,buf,sizeof(buf)
,0,(SA *)&addr_s,sizeof(addr_s)) < 0)
{
perror("sendto fail");
}
memset(buf,'\0',sizeof(buf));
recvfrom(sockfd,buf,sizeof(buf),0,NULL,NULL);
printf("recvfrom server:%s\n",buf);
close(sockfd);
}
㈣ 簡述基於TCP和UDP的Socket編程的異同
Socket有兩種主要的操作方式：面向連接的和無連接的。無連接的操作使用UDP數據報協議，這個操作不需要連接一個目的的socket，它只是簡單地投出數據報，快速高效，但缺少數據安全性。面向連接的操作使用TCP協議，一個這個模式的socket必須在發送數據之前與目的地的socket取得一個連接，一旦連接建立了，socket就可以使用一個流介面：打開-讀-寫-關閉，所有的發送的信息都會在另一端以同樣的順序被接收，面向連接的操作比無連接的操作效率要低，但數據的安全性更高。基於TCP的socket編程是採用的流式套接字(SOCK_STREAM)。基於UDP採用的數據報套接字(SOCK_DGRAM).
流式套接字的設計是針對面向連接的網路應用，在數據傳輸之前需要預先建立連接，在數據傳輸過程中需要維持連接，在數據傳輸結束後需要釋放連接。由於採用校驗和、確認與超時等差錯控制手段，因此流式套接字可以保證數據傳輸的正確性。
數據報套接字（SOCK_DGRAM）提供無連接的、不可靠的數據傳輸服務，實際上它是基於TCP/IP協議族中的UDP協議實現的。數據報套接字提供無序、有差錯與有重復的數據流服務。數據報套接字的設計是針對無連接的網路應用，在數據傳輸之前不需要預先建立連接。由於只採用很有限的差錯控制手段，因此數據報套接字無法保證數據傳輸的正確性。
㈤ CSocket之UDP編程
#include <stdio.h>
#include <Winsock2.h>
#pragma comment(lib,"ws2_32.lib")
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 sersocket=socket(AF_INET,SOCK_DGRAM,0);
SOCKADDR_IN seraddr;
seraddr.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
seraddr.sin_family=AF_INET;
seraddr.sin_port=htons(5000);
bind(sersocket,(SOCKADDR*)&seraddr,sizeof(SOCKADDR));
SOCKADDR clientaddr;
int len=sizeof(SOCKADDR);
char revbuf[100];
char sendbuf[100];
recvfrom(sersocket,revbuf,100,0,(SOCKADDR*)&clientaddr,&len);
printf("%s\n",revbuf);
scanf("%s",&sendbuf);
sendto(sersocket,sendbuf,strlen(sendbuf)+1,0,(SOCKADDR*)&clientaddr,len);
closesocket(sersocket);
WSACleanup();
}
#include <stdio.h>
#include <Winsock2.h>
#pragma comment(lib,"ws2_32.lib")
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_DGRAM,0);
SOCKADDR_IN clientaddr;
clientaddr.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");
clientaddr.sin_family=AF_INET;
clientaddr.sin_port=htons(5000);
int len=sizeof(SOCKADDR);
char revbuf[100];
char sendbuf[100];
printf("請輸入內容：\n");
while(1)
{
scanf("%s",&sendbuf);
sendto(sockclient,sendbuf,strlen(sendbuf)+1,0,(SOCKADDR*)&clientaddr,len);
recvfrom(sockclient,revbuf,100,0,(SOCKADDR*)&clientaddr,&len);
printf("%s\n",revbuf);
}
closesocket(sockclient);
WSACleanup();
}
大同小異，CSocket只是進行了封裝而已，原理是一樣的，編程要思路靈活才行。
㈥ socket編程到底是什麼
socket 其實就是操作系統提供給程序員操作「網路協議棧」的介面，說人話就是，你能通過socket 的介面，來控制協議找工作，從而實現網路通信，達到跨主機通信。
協議棧的上半部分有兩塊，分別是負責收發數據的 TCP 和 UDP 協議，它們兩會接受應用層的委託執行收發數據的操作。
協議棧的下面一半是用 IP 協議控制網路包收發操作，在互聯網上傳數據時，數據會被切分成一塊塊的網路包，而將網路包發送給對方的操作就是由 IP 負責的。這里需要注意的是，服務端調用 accept 時，連接成功了會返回一個已完成連接的 socket，後續用來傳輸數據。
所以，監聽的 socket 和真正用來傳送數據的 socket，是「兩個」 socket，一個叫作監聽 socket，一個叫作已完成連接 socket。成功連接建立之後，雙方開始通過 read 和 write 函數來讀寫數據，就像往一個文件流裡面寫東西一樣。
㈦ python socket udp編程的小問題
從錯誤代碼an
integer
is
required來看，需要提供一個整形。
要做的是改成
port0
=
21567，而不是
port0
=
』21567『。
希望能幫到你，有疑問請追問！
㈧ python中使用socket編程，如何能夠通過UDP傳遞一個列表類型的數據
Python中的 list 或者 dict 都可以轉成JSON字元串來發送，接收後再轉回來。
首先
importjson
然後，把 list 或 dict 轉成 JSON
json_string=json.mps(list_or_dict)
如果你用的是Python3，這里的 json_string 會是 str 類型（即Python2的unicode類型），可能需要編碼一下：
if type(json_string) == six.text_type:
json_string = json_string.encode('UTF-8')
用socket發送過去，例如
s.sendto(json_string,address)
對方用socket接收，例如
json_string,addr=s.recvfrom(2048)
把JSON轉成 list 或 dict
list_or_dict=json.loads(json_string)
下面是個完整的例子：
client.py
#!/usr/bin/envpython
#-*-coding:UTF-8-*-
importsocket
importjson
importsix
address=('127.0.0.1',31500)
s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
mylist=[1,2,3,4,5,6,7,8,9,10]
json_string=json.mps(mylist)
iftype(json_string)==six.text_type:
json_string=json_string.encode('UTF-8')
s.sendto(json_string,address)
s.close()
server.py
#!/usr/bin/envpython
#-*-coding:UTF-8-*-
importsocket
importjson
address=('127.0.0.1',31500)
s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
s.bind(address)
json_string,addr=s.recvfrom(2048)
mylist=json.loads(json_string)
print(mylist)
s.close()
請先運行server.py，再運行client.py
㈨ socket網路編程
bzero() 函數的功能是將一塊內存清零。
bzero((char *) sendpkt, sizeof (struct udprecord)); 功能是將 sendpkt 指向的內存清零。
和 memset(sendpkt, 0, sizeof(struct udpprecord)); 的功能是一樣的。
㈩ 用SOCKET,UDP編程時,要發送的數據放在數組裡面進行發送即數組長度可變,請問如何設置接收端數組長度
最好的socket編程方式是在頭部前4個位元組放整個數據長度，再4個位元組消息類型，4個位元組列號，==再內容。即是消息頭部長度固定，內容部分可變。如果每次發送數據大小超過單次發送量，數據會被分包發送。在接收端還要做組包處理。組包也是根據數據長度去組包。這些是2年電信大數據開發得出的實際經驗。