linuxudp套接字編程

A. linux網路編程的介紹

《Linux網路編程》是2010年清華大學出版社出版的圖書，作者是宋敬彬、孫海濱。linux是目前最流行的開源操作系統，網路功能在linux下佔有核心的地位。本書循序漸進地從應用層到linux內核、從基本知識點到綜合案例，向讀者介紹如何在linux下進行網路程序設計。本書內容分為4個部分：linux程序設計基礎部分、linux用戶空間網路編程部分、linux內核網路編程部分以及綜合案例部分。內容包含linux系統概述、linux編程環境、linux文件系統簡介、linux下的進程和線程、tcp/ip協議族、應用層網路服務程序、tcp編程、主機信息獲取、數據io復用、udp編程、高級套接字、套接字選項、原始套接字、伺服器模型、ipv6、linux 內核網路部分結構及分布、netfilter框架內報文處理。

B. linux下udp編程如何同時獲取源IP和埠及目的IP和埠

http://www.cnblogs.com/kissazi2/p/3158603.html

C. 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);

D. linux 套接字編程 如何發送自己定義協議的數據包註：IP層之上是自己定義的新協議，不是tcp、udp之類的

socket編程只有三種方式TCP、UDP、和RAW。既然你已經知道不是TCP、UDP之類的，那一定就是RAW了，不過RAW是需要root滴...

E. linux socket編程後是tcp還是udp

Linux socket編程既可以是TCP連接，也可以是UDP連接。Linux socket編程首先要用socket系統調用創建一個套接字，socket系統調用的原型是：
int socket(int domain, int type, int protocol);
當socket函數的type參數指定為SOCK_STREAM時，就相當於建立的是個TCP連接；當type參數指定為SOCK_DGRAM時，建立的就是一個UDP連接。當建立TCP或者UDP連接的時候，注意把第一個參數domain指定為AF_INET。

F. 求linux socket網路編程代碼

Linux是多任務的操作系統，可在運行在Intel 80386及更高檔次的PC機、ARMS、MIPS和PowerPC等多種計算機平台，已成為應用廣泛、可靠性高、功能強大的計算機操作系統，Linux具有內核小、效率高、源代碼開放等優點，還內含了TCP/IP網路協議，很適合在伺服器領域使用，而伺服器主要用途之一就是進行網路通信，隨著計算機辦公自動化處理技術的應用與推廣，網路的不斷普及，傳統的紙張式文件傳輸方式已經不再適合發展的需要，人們更期待一種便捷、高效、環保、安全的網路傳輸方式.

協議概述TCP/IP即傳輸控制協議/網路協議[1]（Transmission Control Protocol/Internet Protocol），是一個由多種協議組成的協議族，他定義了計算機通過網路互相通信及協議族各層次之間通信的規范，圖1描述了Linux對IP協議族的實現機制[2]。

Linux支持BSD的套接字和全部的TCP/IP協議，是通過網路協議將其視為一組相連的軟體層來實現的，BSD套接字（BSD Socket）由通用的套接字管理軟體支持，該軟體是INET套接字層，用來管理基於IP的TCP與UDP埠到埠的互聯問題，從協議分層來看，IP是網路層協議，TCP是一個可靠的埠到埠的傳輸層協議，他是利用IP層進行傳接報文的，同時也是面向連接的，通過建立一條虛擬電路在不同的網路間傳輸報文，保證所傳輸報文的無丟失性和無重復性。用戶數據報文協議（User Datagram Protocol，UDP）也是利用IP層傳輸報文，但他是一個非面向連接的傳輸層協議，利用IP層傳輸報文時，當目的方網際協議層收到IP報文後，必須識別出該報文所使用的上層協議（即傳輸層協議），因此，在IP報頭上中，設有一個"協議"域（Protocol）。通過該域的值，即可判明其上層協議類型，傳輸層與網路層在功能說的最大區別是前者提供進程通信能力，而後者則不能，在進程通信的意義上，網路通信的最終地址不僅僅是主機地址，還包括可以描述進程的某種標識符，為此，TCP/UDP提出了協議埠（Protocol Port）的概念，用於標識通信的進程，例如，Web伺服器進程通常使用埠80，在/etc/services文件中有這些注冊了的埠地址。

對於TCP傳輸，傳輸節點間先要建立連接，然後通過該連接傳輸已排好序的報文，以保證傳輸的正確性，IP層中的代碼用於實現網際協議，這些代碼將IP頭增加到傳輸數據中，同時也把收到的IP報文正確的傳送到TCP層或UDP層。TCP是一個面向連接協議，而UDP則是一個非面向連接協議，當一個UDP報文發送出去後，Linux並不知道也不去關心他是否成功地到達了目的的主機，IP層之下，是支持所有Linux網路應用的網路設備層，例如點到點協議（Point to Point Protocol，PPP）和乙太網層。網路設備並非總代表物理設備，其中有一些（例如回送設備）則是純粹的軟體設備，網路設備與標準的Linux設備不同，他們不是通過Mknod命令創建的，必須是底層軟體找到並進行了初始化之後，這些設備才被創建並可用。因此只有當啟動了正確設置的乙太網設備驅動程序的內核後，才會有/dev/eth0文件，ARP協議位於IP層和支持地址解析的協議層之間。

網路通信原理所有的網路通信就其實現技術可以分為兩種，線路交換和包交換，計算機網路一般採用包交換，TCP使用了包交換通信技術，計算機網路中所傳輸的數據，全部都以包（Packet）這個單位來發送，包由"報頭"和"報文"組成，結構如圖2所示，在"報頭"中記載有發送主機地址，接收主機地址及與報文內容相關的信息等，在"報文"中記載有需要發送的數據，網路中的每個主機和路由器中都有一個路由定址表，根據這個路由表，包就可以通過網路傳送到相應的目的主機。

網路通信中的一個非常重要的概念就是套接字（Socket）[3，4]，簡單地說，套接字就是網路進程的ID，網路通信歸根到底是進程的通信，在網路中，每個節點有一個網路地址（即IP地址），兩個進程通信時，首先要確定各自所在網路節點的網路地址，但是，網路地址只能確定進程所在的計算機，而一台計算機上可能同時有多個網路進程，還不能確定到底是其中的哪個進程，由此套接字中還要有其他的信息，那就是埠號（Port），在一台計算機中，一個埠一次只能分配給一個進程，即埠號與進程是一一對應的關系，所以，埠號和網路地址就能唯一地確定Internet中的一個網路進程。可以認為：套接字=網路地址+埠號系統調用一個Socket（）得到一個套接字描述符，然後就可以通過他進行網路通信了。

套接字有很多種類，最常用的就有兩種；流式套接字和數據報套接字。在Linux中分別稱之為"SOCK_STREAM"和"SOCK_DGRAM）"他們分別使用不同的協議，流式套接字使用TCP協議，數據報套接字使用UDP協議，本文所使用的是流式套接字協議。

網路通信原理在文件傳輸程序設計中的應用網路上的絕大多數通信採用的都是客戶機/伺服器機制（Client/Server），即伺服器提供服務，客戶是這些服務的使用者，伺服器首先創建一個Socket，然後將該Socket與本地地址/埠號綁定（Bind（）），成功之後就在相應的Socket上監聽（Listen（）） 。當Accept（）函數捕捉到一個連接服務（Connect（））請求時，接受並生成一個新的Socket,並通過這個新的Socket與客戶端通信，客戶端同樣也要創建一個Socket，將該Socket與本地地址/埠號綁定，還需要指定伺服器端的地址與埠號，隨後向伺服器端發出Connect（），請求被伺服器端接受後，可以通過Socket與伺服器端通信。

TCP是一種面向連接的、可靠的、雙向的通信數據流，說他可靠，是因為他使用3段握手協議傳輸數據，並且在傳輸時採用"重傳肯定確認"機制保證數據的正確發送：接收端收到的數據後要發出一個肯定確認，而發送端必須要能接受到這個肯定信號，否則就要將數據重發。在此原理基礎之上，設計了基於Linux操作系統下TCP/IP編程實現文件傳輸的實例。我們採用客戶機/伺服器模式通信時，通信雙方發送/接收數據的工作流程如圖3所示。

文件傳輸就是基於客戶機/伺服器模型而設計的，客戶機和伺服器之間利用TCP建立連續，因文件傳輸是一個互動式會話系統，客戶機每次執行文件傳輸，都需要與伺服器建立控制連接和數據連接，其中控制連接負責傳輸控制信息、利用控制命令、客戶機可以向伺服器提出無限次的請求，客戶機每次提出的請求，伺服器與客戶機建立一個數據連接，進行實際的數據傳輸，數據傳輸完畢後，對應的數據連接被清除，控制連接依然保持，等待客戶機發出新的傳輸請求，直到客戶機撤銷控制連接，結束會話。

當進行文件傳輸時，首先向伺服器發出連接請求，伺服器驗證身份後，與客戶端建立連接，雙方進入會話狀態，這時只要客戶端向伺服器端發出數據連接請求，建立起數據連接後，雙方就進入數據傳輸狀態，數據傳輸完畢後，數據連接被撤銷，如此循環反復，直到會話結束，從而實現將文件從伺服器端傳輸至客戶機端。

文件傳輸程序設計流程[5，客戶端的TCP應用程序流程（1）先用Socket（）創建本地套介面，給伺服器端套介面地址結構賦值。

（2）用Connect（）函數使本地套介面向伺服器端套介面發出建立連接請求，經3次握手建立TCP連接。

（3）用Read（）函數讀取所要接收的文件名以及存放在內存里的文件內容。

（4）用Open（）函數打開客戶端新建立的目標文件，如果沒有建立，該函數會自動生成目標文件，等待存放文件內容。

（5）最後用Write（）函數將讀取的文件內容存放在新的目標文件中，以實現伺服器端向客戶端的文件傳輸。

（6）通信結束，用Close（）關閉套介面，停止接收文件。

伺服器端的TCP應用程序流程（1）先用Open（）函數打開等待傳輸的可讀文件；（2）用Socket（）創建套介面，並給套介面地址結構賦值；（3）用Bind（）函數綁定套介面；（4）用Listen（）函數在該套介面上監聽請求；（5）用Accept（）函數接受請求，產生新的套介面及描述字，並與客戶端連接；（6）用Lseek（）函數是為了在每次接受客戶機連接時，將用於讀的源文件指針移到文件頭；（7）用Read（）函數讀取一定長度的源文件數據；（8）最後用Write（）函數將讀取的源文件數據存放在內存中，以便客戶端讀取；（9）傳輸完畢時，用Close（）關閉所有進程，結束文件傳輸。

結語Linux操作系統在網路應用方面具有很強的開發潛力，同時Linux也是可靠性、安全性非常高的系統，因此在基於TCP/IP網路通信的研究與開發中，通常選用Linux操作系統作為開發平台

G. linux C 發送udp包 構造udp報頭

要用原始套接字raw，才能接觸到網路層

我看這幾天時間吧。。。

希望你真不是懶人。。。

H. linux網路編程是個什麼樣的東西

Linux 網路編程是一個基於客戶端/伺服器（即：client/server）的套接字編程結構（即：socket 編程）。
在Linux網路編程的過程中，使用到的協議主要有：TCP/IP（基於連接的協議）、UDP（基於無連接的協議）、ICMP（通常我們在 DOS 狀態下通過使用 ping 命令，檢查網路的通斷，就是依靠該協議）。
在Linux系統的套接字編程中，有標準的 socket( )、client( ) 代碼的編寫風格。涉及到的主要庫函數有：bind( )、listen( )、accept( )、read( )、write( ) 等。
至於說要想學習詳細的Linux網路編程技術實現細節，你可以參考《TCP/IP詳解》一書。一套共三本。

I. 基於Linux的遠程指令系統（使用udp而不是tcp）

一. Linux下UDP編程框架

使用UDP進行程序設計可以分為客戶端和伺服器端兩部分。
1.伺服器端程序包括：
? 建立套接字
? 將套接字地址結構進行綁定
? 讀寫數據
? 關閉套接字
2.客戶端程序包括：
? 建立套接字
? 讀寫數據
? 關閉套接字
3.伺服器端和客戶端程序之間的差別
伺服器端和客戶端兩個流程之間的主要差別在於對地址的綁定函數（bind()函數），而客戶端可以不用進行地址和埠的綁定操作。

二.Linux中UDP套接字函數

從圖可知，UDP協議的服務端程序設計的流程分為套接字建立，套接字與地址結構進行綁定，收發數據，關閉套接字;客戶端程序流程為套接字建立，收發數據，關閉套接字等過程。它們分別對應socket(),bind(),sendto(),recvfrom(),和close()函數。
網路程序通過調用socket（）函數，會返回一個用於通信的套接字描述符。Linux應用程序在執行任何形式的I/O操作的時候，程序是在讀或者寫一個文件描述符。因此，可以把創建的套接字描述符看成普通的描述符來操作，並通過讀寫套接字描述符來實現網路之間的數據交流。
1. socket
1> 函數原型:
int socket(int domain,int type,int protocol)
2> 函數功能：
函數socket()用於創建一個套接字描述符。
3> 形參：
? domain:用於指定創建套接字所使用的協議族，在頭文件
中定義。
常見的協議族如下：
AF_UNIX:創建只在本機內進行通信的套接字。
AF_INET:使用IPv4 TCP/IP協議
AF_INET6:使用IPv6 TCP/IP協議
說明：
AF_UNIX只能用於單一的UNIX系統進程間通信，而AF_INET是針對Interne的，因而可以允許在遠程主機之間通信。一般把它賦為AF_INET。
? type:指明套接的類型，對應的參數如下
SOCK_STREAM:創建TCP流套接字
SOCK_DGRAM:創建UDP數據報套接字
SOCK_RAW:創建原始套接字
? protocol:
參數protocol通常設置為0，表示通過參數domain指定的協議族和參數type指定的套接字類型來確定使用的協議。當為原始套接字時，系統無法唯一的確定協議，此時就需要使用使用該參數指定所使用的協議。
4> 返回值：執行成功後返回一個新創建的套接字；若有錯誤發生則返回一個-1，錯誤代碼存入errno中。
5> 舉例：調用socket函數創建一個UDP套接字
int sock_fd;
sock_fd = socket(AF_INET,SOCK_DGRAM,0);
if(sock_fd < 0){
perror(「socket」);
exit(1);
}
2. bind
1> 函數原型：
int bind(int sockfd,struct sockaddr *my_addr,socklen_taddrlen)
2> 函數功能
函數bind()的作用是將一個套接字文件描述符與一個本地地址綁定在一起。
3> 形參：
? sockfd:sockfd是調用socket函數返回的文件描述符；
? addrlen是sockaddr結構的長度。
? my_addr: 是一個指向sockaddr結構的指針，它保存著本地套接字的地址（即埠和IP地址）信息。不過由於系統兼容性的問題，一般不使用這個結構，而使用另外一個結構(struct sockaddr_in)來代替
4> 套接字地址結構：
(1)structsockaddr:
結構struct sockaddr定義了一種通用的套接字地址，它在
Linux/socket.h 中定義。
struct sockaddr{
unsigned short sa_family;/*地址類型，AF_XXX*/
char sa_data[14];/*14位元組的協議地址*/
}
a. sin_family：表示地址類型，對於使用TCP/IP協議進行的網路編程，該值只能是AF_INET.
b. sa_data：存儲具體的協議地址。
(2)sockaddr_in
每種協議族都有自己的協議地址格式，TCP/IP協議組的地址格式為結構體struct sockaddr_in,它在netinet/in.h頭文件中定義。
struct sockaddr_in{
unsigned short sin_family;/*地址類型*/
unsigned short sin_port;/*埠號*/
struct in_addr sin_addr;/*IP地址*/
unsigned char sin_zero[8];/*填充位元組，一般賦值為0*/
}
a. sin_family：表示地址類型，對於使用TCP/IP協議進行的網路編程，該值只能是AF_INET.
b. sin_port:是埠號
c. sin_addr:用來存儲32位的IP地址。
d. 數組sin_zero為填充欄位，一般賦值為0.
e. structin_addr的定義如下：
struct in_addr{
unsignedlong s_addr;
}
結構體sockaddr的長度為16位元組，結構體sockaddr_in的長度為16位元組。可以將參數my_addr的sin_addr設置為INADDR_ANY而不是某個確定的IP地址就可以綁定到任何網路介面。對於只有一IP地址的計算機，INADDR_ANY對應的就是它的IP地址；對於多宿主主機(擁有多個網卡)，INADDR_ANY表示本伺服器程序將處理來自所有網路介面上相應埠的連接請求
5> 返回值：
函數成功後返回0，當有錯誤發生時則返回-1，錯誤代碼存入errno中。
6>舉例：調用socket函數創建一個UDP套接字
struct sockaddr_in addr_serv,addr_client;/*本地的地址信息*/
memset(&serv_addr,0,sizeof(struct sockaddr_in));
addr_serv.sin_family = AF_INET;/*協議族*/
addr_serv.sin_port = htons(SERV_PORT);/*本地埠號*/
addr_serv.sin_addr.s_addr = htonl(INADDR_ANY); /*任意本地地址*/
/*套接字綁定*/
if(bind(sock_fd,(struct sockaddr *)&addr_serv),sizeof(structsockaddr_in)) <0)
{
perror(「bind」);
exit(1);
}
3.close
1>函數原型：
int close(intfd);
2>函數功能：
函數close用來關閉一個套接字描述符。
3>函數形參：
? 參數fd為一個套接字描述符。
4>返回值：
執行成功返回0，出錯則返回-1.錯誤代碼存入errno中。
說明：
以上三個函數中，前兩個要包含頭文件
#include
#include
後一個包含：
#include
4.sendto
1>函數原型：
#include
#include
ssize_t sendo(ints,const void *msg,size_t len,int flags,const struct sockaddr *to,socklen_ttolen);
2>函數功能：
向目標主機發送消息
3>函數形參：
? s:套接字描述符。
? *msg:發送緩沖區
? len:待發送數據的長度
? flags:控制選項，一般設置為0或取下面的值
(1)MSG_OOB:在指定的套接字上發送帶外數據(out-of-band data),該類型的套接字必須支持帶外數據（eg:SOCK_STREAM）.
(2)MSG_DONTROUTE:通過最直接的路徑發送數據，而忽略下層協議的路由設置。
? to:用於指定目的地址
? tolen:目的地址的長度。
4>函數返回值：
執行成功後返回實際發送數據的位元組數，出錯返回-1，錯誤代碼存入errno中。
5>函數舉例：
char send_buf[BUFFERSIZE];
struct sockaddr_in addr_client;

memset(&addr_client,0,sizeof(struct sockaddr_in));
addr_client.sin_family = AF_INET;
addr_client.sin_port = htons(DEST_PORT);
if(inet_aton(「172.17.242.131」,&addr_client.sin_addr)<0){
perror(「inet_aton」);
exit(1);
}
if(sendto(sock_fd,send_buf,len,0,(strut sockaddr*)&addr_client,sizeof(struct sockaddr_in)) <0){
perror(「sendto」);
exit(1);
}
5.recvfrom
1>函數原型：
#include
#include
ssize_t recvfrom(int s,void *buf,size_t len,intflags,struct sockaddr *from,socklen_t *fromlen);
2>函數功能：接收數據
3>函數形參：
? int s:套接字描述符
? buf:指向接收緩沖區，接收到的數據將放在這個指針所指向的內存空間。
? len:指定了緩沖區的大小。
? flags:控制選項,一般設置為0或取以下值
(1)MSG_OOB:請求接收帶外數據
(2)MSG_PEEK:只查看數據而不讀出
(3)MSG_WAITALL:只在接收緩沖區時才返回。
? *from:保存了接收數據報的源地址。
? *fromlen:參數fromlen在調用recvfrom前為參數from的長度，調用recvfrom後將保存from的實際大小。
4>函數返回值：
執行成功後返回實際接收到數據的位元組數，出錯時則返回-1，錯誤代碼存入errno中。
5>函數實例：
char recv_buf[BUFFERSIZE];
struct sockaddr_in addr_client;
int src_len;
src_len = sizeof(struct sockaddr_in);
int src_len;
src_len = sizeof(struct sockaddr_in);
if(recvfrom(sock_fd,recv_buf,sizeof(recv_buf),0,(structsockaddr *)&src_addr,&src_len)<0){
perror(「again_recvfrom」);
exit(1);
}
三.UDP編程實例

客戶端向伺服器發送字元串Hello tiger,伺服器接收到數據後將接收到字元串發送回客戶端。

1.伺服器端程序
1 #include
2 #include
3 #include
4 #include
5 #include
6 #include
7 #include
8 #include
9
10 #define SERV_PORT 3000
11
12 int main()
13 {
14 int sock_fd; //套接子描述符號
15 int recv_num;
16 int send_num;
17 int client_len;
18 char recv_buf[20];
19 struct sockaddr_in addr_serv;
20 struct sockaddr_in addr_client;//伺服器和客戶端地址
21 sock_fd = socket(AF_INET,SOCK_DGRAM,0);
22 if(sock_fd < 0){
23 perror("socket");
24 exit(1);
25 } else{
26
27 printf("sock sucessful\n");
28 }
29 //初始化伺服器斷地址
30 memset(&addr_serv,0,sizeof(struct sockaddr_in));
31 addr_serv.sin_family = AF_INET;//協議族
32 addr_serv.sin_port = htons(SERV_PORT);
33 addr_serv.sin_addr.s_addr = htonl(INADDR_ANY);//任意本地址
34
35 client_len = sizeof(struct sockaddr_in);
36 /*綁定套接子*/
37 if(bind(sock_fd,(struct sockaddr *)&addr_serv,sizeof(struct sockaddr_in))<0 ){
38 perror("bind");
39 exit(1);

40 } else{
41
42 printf("bind sucess\n");
43 }
44 while(1){
45 printf("begin recv:\n");
46 recv_num = recvfrom(sock_fd,recv_buf,sizeof(recv_buf),0,(struct sockaddr *)&addr_client,&client_len);
47 if(recv_num < 0){
48 printf("bad\n");
49 perror("again recvfrom");
50 exit(1);
51 } else{
52 recv_buf[recv_num]='\0';
53 printf("recv sucess:%s\n",recv_buf);
54 }
55 printf("begin send:\n");
56 send_num = sendto(sock_fd,recv_buf,recv_num,0,(struct sockaddr *)&addr_client,client_len);
57 if(send_num < 0){
58 perror("sendto");
59 exit(1);
60 } else{
61 printf("send sucessful\n");
62 }
63 }
64 close(sock_fd);
65 return 0;
66 }

2.客戶端程序
1 #include
2 #include
3 #include
4 #include
5 #include
6
7 #include
8 #include
9 #include
10
11 #define DEST_PORT 3000
12 #define DSET_IP_ADDRESS "192.168.1.103"
13
14 int main()
15 {
16 int sock_fd;/*套接字文件描述符*/
17 int send_num;
18 int recv_num;
19 int dest_len;
20 char send_buf[20]={"hello tiger"};
21 char recv_buf[20];
22 struct sockaddr_in addr_serv;/*服務端地址，客戶端地址*/
23
24 sock_fd = socket(AF_INET,SOCK_DGRAM,0);//創建套接子
25 //初始化伺服器端地址
26 memset(&addr_serv,0,sizeof(addr_serv));
27 addr_serv.sin_family = AF_INET;
28 addr_serv.sin_addr.s_addr = inet_addr(DSET_IP_ADDRESS);
29 addr_serv.sin_port = htons(DEST_PORT);
30
31 dest_len = sizeof(struct sockaddr_in);
32 printf("begin send:\n");
33 send_num = sendto(sock_fd,send_buf,sizeof(send_buf),0,(struct sockaddr *)&addr_serv,dest_len);
34 if(send_num < 0){
35 perror("sendto");
36 exit(1);
37 } else{
38
39 printf("send sucessful:%s\n",send_buf);

40 }
41 recv_num = recvfrom(sock_fd,recv_buf,sizeof(recv_buf),0,(struct sockaddr *)&addr_serv,&dest_len);
42 if(recv_num <0 ){
43
44 perror("recv_from");
45 exit(1);
46 } else{
47 printf("recv sucessful\n");
48 }
49 recv_buf[recv_num]='\0';
50 printf("the receive:%s\n",recv_buf);
51 close(sock_fd);
52 return 0;
53 }

J. linux 下用socket 文件傳輸問題(UDP)

要下班了，時間急，不寫代碼了先給你一個思路
1 實現最簡單的udp socket 模型，實現發送一個字元串。
2 實現一個簡單的打開文件，讀取文件的例子，如用fgets(),類似的函數有很多，然後再把讀取的文件內容忘另一個文件里寫(相關函數fopen(),write(),read())。
3 把上面兩個函數結合到一起，在客戶端實現打開要傳送的文件，按一定的大小讀取，讀取後調用sendto（）發送到伺服器端。在伺服器端創建一個文件，然後調用recvfrom（）接受客戶端發送過來的數據，向來是創建的那個文件中寫。
下面是改好的udp發送文件的例子。

伺服器端程序的編譯
gcc -o file_server  file_server
客戶端程序的編譯
gcc -o file_client  file_client.c
伺服器程序和客戶端程應當分別運行在2台計算機上.
伺服器端程序的運行,在一個計算機的終端執行
./file_server
客戶端程序的運行,在另一個計算機的終端中執行
./file_client  運行伺服器程序的計算機的IP地址
根據提示輸入要傳輸的伺服器上的文件，該文件在伺服器的運行目錄上
在實際編程和測試中,可以用2個終端代替2個計算機,這樣就可以在一台計算機上測試網路程序,
伺服器端程序的運行,在一個終端執行
./file_server
客戶端程序的運行,在另一個終端中執行
./file_client  127.0.0.1
說明: 任何計算機都可以通過127.0.0.1訪問自己. 也可以用計算機的實際IP地址代替127.0.0.1
//////////////////////////////////////////////////////////////////////////////////////
// file_server.c  文件傳輸順序伺服器示例
//////////////////////////////////////////////////////////////////////////////////////
//本文件是伺服器的代碼
#include <netinet/in.h>    // for sockaddr_in
#include <sys/types.h>    // for socket
#include <sys/socket.h>    // for socket
#include <stdio.h>        // for printf
#include <stdlib.h>        // for exit
#include <string.h>        // for bzero
/*
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
*/
#define HELLO_WORLD_SERVER_PORT    6666
#define LENGTH_OF_LISTEN_QUEUE  20
#define BUFFER_SIZE 1024
#define FILE_NAME_MAX_SIZE 512

int main(int argc, char **argv)
{
    //設置一個socket地址結構server_addr,代表伺服器internet地址, 埠
    struct sockaddr_in server_addr， pcliaddr;
    bzero(&server_addr,sizeof(server_addr)); //把一段內存區的內容全部設置為0
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htons(INADDR_ANY);
    server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);

    //創建用於internet的據報套接字（UDPt,用server_socket代表伺服器socket

// 創建數據報套接字（UDP）
    int server_socket = socket(PF_INET,SOCK_DGRAM,0);
    if( server_socket < 0)
    {
        printf("Create Socket Failed!");
        exit(1);
    }
   
    //把socket和socket地址結構聯系起來
    if( bind(server_socket,(struct sockaddr*)&server_addr,sizeof(server_addr)))
    {
        printf("Server Bind Port : %d Failed!", HELLO_WORLD_SERVER_PORT);
        exit(1);
    }
   
    while (1) //伺服器端要一直運行
    {
        //定義客戶端的socket地址結構client_addr
        struct sockaddr_in client_addr;
        socklen_t n = sizeof(client_addr) ;
int length;

        char buffer[BUFFER_SIZE];
        bzero(buffer, BUFFER_SIZE);
        length = recvfrom(new_server_socket,buffer,BUFFER_SIZE,0,&pcliaddr,&n);
        if (length < 0)
        {
            printf("Server Recieve Data Failed!\n");
            break;
        }
        char file_name[FILE_NAME_MAX_SIZE+1];
        bzero(file_name, FILE_NAME_MAX_SIZE+1);
        strncpy(file_name, buffer, strlen(buffer)>FILE_NAME_MAX_SIZE?FILE_NAME_MAX_SIZE:strlen(buffer));
//        int fp = open(file_name, O_RDONLY);
//        if( fp < 0 )
        FILE * fp = fopen(file_name,"r");
        if(NULL == fp )
        {
            printf("File:\t%s Not Found\n", file_name);
        }
        else
        {
            bzero(buffer, BUFFER_SIZE);
            int file_block_length = 0;
//            while( (file_block_length = read(fp,buffer,BUFFER_SIZE))>0)
            while( (file_block_length = fread(buffer,sizeof(char),BUFFER_SIZE,fp))>0)
            {
                printf("file_block_length = %d\n",file_block_length);
                //發送buffer中的字元串到new_server_socket,實際是給客戶端
                if(send(new_server_socket,buffer,file_block_length,0)<0)
                {
                    printf("Send File:\t%s Failed\n", file_name);
                    break;
                }
                bzero(buffer, BUFFER_SIZE);
            }
//            close(fp);
            fclose(fp);
            printf("File:\t%s Transfer Finished\n",file_name);
        }
    }
}

//////////////////////////////////////////////////////////////////////////////////////
// file_client.c  文件傳輸客戶端程序示例
//////////////////////////////////////////////////////////////////////////////////////
//本文件是客戶機的代碼
#include <netinet/in.h>    // for sockaddr_in
#include <sys/types.h>    // for socket
#include <sys/socket.h>    // for socket
#include <stdio.h>        // for printf
#include <stdlib.h>        // for exit
#include <string.h>        // for bzero
/*
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
*/

#define HELLO_WORLD_SERVER_PORT    6666
#define BUFFER_SIZE 1024
#define FILE_NAME_MAX_SIZE 512

int main(int argc, char **argv)
{
    if (argc != 2)
    {
        printf("Usage: ./%s ServerIPAddress\n",argv[0]);
        exit(1);
    }

    //設置一個socket地址結構client_addr,代表客戶機internet地址, 埠
    struct sockaddr_in client_addr;
    bzero(&client_addr,sizeof(client_addr)); //把一段內存區的內容全部設置為0
    client_addr.sin_family = AF_INET;    //internet協議族
    client_addr.sin_addr.s_addr = htons(INADDR_ANY);//INADDR_ANY表示自動獲取本機地址
    client_addr.sin_port = htons(0);    //0表示讓系統自動分配一個空閑埠
    //創建用於internet的流協議(TCP)socket,用client_socket代表客戶機socket
    int client_socket = socket(AF_INET,SOCK_DGRAM,0);
    if( client_socket < 0)
    {
        printf("Create Socket Failed!\n");
        exit(1);
    }

    //設置一個socket地址結構server_addr,代表伺服器的internet地址, 埠
    struct sockaddr_in server_addr;
    bzero(&server_addr,sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    if(inet_aton(argv[1],&server_addr.sin_addr) == 0) //伺服器的IP地址來自程序的參數
    {
        printf("Server IP Address Error!\n");
        exit(1);
    }
    server_addr.sin_port = htons(HELLO_WORLD_SERVER_PORT);
    socklen_t server_addr_length = sizeof(server_addr);

    char file_name[FILE_NAME_MAX_SIZE+1];
    bzero(file_name, FILE_NAME_MAX_SIZE+1);
    printf("Please Input File Name On Server:\t");
    scanf("%s", file_name);
   
    char buffer[BUFFER_SIZE];
    bzero(buffer,BUFFER_SIZE);
    strncpy(buffer, file_name, strlen(file_name)>BUFFER_SIZE?BUFFER_SIZE:strlen(file_name));
    //向伺服器發送buffer中的數據
     socklen_t n = sizeof(server_addr) ;
    sendto(client_socket,buffer,BUFFER_SIZE,0,(struct sockaddr*)&server_addr,n);

//    int fp = open(file_name, O_WRONLY|O_CREAT);
//    if( fp < 0 )
    FILE * fp = fopen(file_name,"w");
    if(NULL == fp )
    {
        printf("File:\t%s Can Not Open To Write\n", file_name);
        exit(1);
    }
   
    //從伺服器接收數據到buffer中
    bzero(buffer,BUFFER_SIZE);
    int length = 0;
    while( length = recv(client_socket,buffer,BUFFER_SIZE,0))
    {
        if(length < 0)
        {
            printf("Recieve Data From Server %s Failed!\n", argv[1]);
            break;
        }
//        int write_length = write(fp, buffer,length);
        int write_length = fwrite(buffer,sizeof(char),length,fp);
        if (write_length<length)
        {
            printf("File:\t%s Write Failed\n", file_name);
            break;
        }
        bzero(buffer,BUFFER_SIZE);   
    }
    printf("Recieve File:\t %s From Server[%s] Finished\n",file_name, argv[1]);
    return 0;
}