當前位置:首頁 » 操作系統 » linux進程socket通信

linux進程socket通信

發布時間: 2023-07-12 22:34:06

『壹』 linux在子進程中,client與server進行socket通信,客戶端socket斷開後不能與server連接,求高手指點

在不間斷的建立連接過程中,每一次的連接斷開會經過TCP狀態的time_wait狀態,這個狀態的作用就是延遲一段時間,然後保證下一次連接的不會被當成上一次的連接。所以第二次的連接建立時如果沒有經過一段時間第二次的連接會失敗,報錯會顯示address in use這兒就是time_wait狀態。你如果是在不同主機上進行不間斷的連接肯定會出現上面的報錯。

『貳』 linux c語言編程,socket實現的即使通訊系統

Socket通信創建步驟:

(1)通過socket()函數創建socket
(2)通過bind函數綁定socket於設備地址
(3)進行讀寫操作read/recv/recvfrom write/send/sendto
(4)close方法關閉套接字


例子如下:

test1.c

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<netinet/in.h>
#include<arpa/inet.h>

intmain(void)
{
//createsocket
intfd=socket(AF_INET,SOCK_DGRAM,0);
if(fd==-1)
{
perror("socket ");
exit(-1);
}
printf("socketfd=%d ",fd);

//buildconnectionaddress
structsockaddr_inaddr;
addr.sin_family=AF_INET;
addr.sin_port=htons(6666);
addr.sin_addr.s_addr=inet_addr("127.0.0.1");

intr;
r=bind(fd,(structsockaddr*)&addr,sizeof(addr));
if(r==-1)
{
perror("bind");
close(fd);
exit(-1);
}
printf("bindaddresssuccessful! ");
//acceptorsendmessage
charbuf[255];
structsockaddr_infrom;
socklen_tlen;
len=sizeof(from);
while(1)
{
r=recvfrom(fd,buf,sizeof(buf)-1,0,(structsockaddr*)&from,&len);
if(r>0)
{
buf[r]=0;
printf("Themessagefrom%sis:%s ",inet_ntoa(from.sin_addr),buf);
}
else
{
break;
}
}
//closesocket
close(fd);
return0;
}

test2.c

java">#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>

intmain(void)
{
//createsocket
intfd=socket(AF_INET,SOCK_DGRAM,0);
if(fd==-1)
{
perror("socket");
exit(-1);
}
printf("createsocketOK! ");
//createansendaddress
structsockaddr_inaddr={};
addr.sin_family=AF_INET;
addr.sin_port=htons(6666);
addr.sin_addr.s_addr=inet_addr("127.0.0.1");
//
intr;
charbuf[255];
while(1)
{
r=read(0,buf,sizeof(buf)-1);
if(r<=0)
break;
sendto(fd,buf,r,0,(structsockaddr*)&addr,sizeof(addr));
}
//closesocket
close(fd);
return0;
}

先運行test1.c,然後運行test2.c,在test2.c運行後輸入內容,在test1.c所在終端中就會顯示信息

運行結果如下:

『叄』 Linux C 網路編程....使用socket通訊...

你可能使用的是TCP連接,這是基於連接發送,是流式傳輸,沒有邊界。
不過一般都有一個緩沖區,滿了後才發送出去,要想沒滿就發送的話,就得使用推。

一個很重要的原因可能是你send的時候傳入的第3個實參有問題。

另外有一點可能是低潮限製造成的。
可以用SO_SNDLOWAT套接字選項設置一個大一點的低潮。

另外你這樣發送,可能會有主機大小端影響。最好是作為文本串來傳輸。

『肆』 Linux編程socket通信疑問

什麼是Socket
Socket介面是TCP/IP網路的API,Socket介面定義了許多函數或常式,程序員可以用它們來開發TCP/IP網路上的應用程序。要學Internet上的TCP/IP網路編程,必須理解Socket介面。

Socket介面設計者......
答案就在這里:linux
socket
通信編程
----------------------Hi,地球人,我是問答機器人小S,上面的內容就是我狂拽酷炫叼炸天的答案,除了贊同,你還有別的選擇嗎?

『伍』 linux進程間通信 socket 共享內存 哪個快

進程間通訊進程間通信就是不同進程之間傳播或交換信息,進程的用戶空間是互相獨立的,進程之間可以利用系統空間交換信息。 管道(pipe)管道是一種半雙工的通信方式,數據只能單向流動。如果要進行雙工通信,需要建立兩個管道。 管道只能在具有親緣關系的進程間使用,例如父子進程或兄弟進程。 有名管道(named pipe) 有名管道也是雙半工的通信方式,但它允許無親緣關系的進程間使用。 信號量(semophore) 信號量常用來作為一種鎖機制來使用,它是一個記數器,用來控制多進程對共享資源的訪問,防止多個進程同時訪問一個共享資源。信號量主要用作為進程間或同一進程間不同線程之間的同步手段。 信號(sinal) 信號是一種比較復雜的通信方式,用於通知接收進程某些事件已經發生,要注意信號處理中調用的函數是否為信號安全。 消息隊列(message queue) 消息隊列是由消息的鏈表組成,存放在內核中並由消息隊列標識符標識。 共享內存(shared memory) 共享內存就是映射一段被其他進程所訪問的內存,這段共享內存由一個進程創建,可由多個進程訪問。共享內存是最快的IPC方式,它是針對其他進程間通信方式的低運行效率而專門設計的。它往往與其他通信機制,如信號量,配合使用,來實現進程間的同步和通信。 套接字(socket) 套接字也是進程間通信的一種方式,與其他方式不同的是,它可以用在不同主機間的進程通信(也是它的主要用途)。 幾種方式的缺點 管道: 速度慢,容量有限,只能用於親緣關系進程間通信。 有名管道: 同管道,不過允許無親緣關系進程間通信。 消息隊列: 容量受系統限制,隊列中會遺留數據,讀時要考慮到這些未讀完的數據。 信號量: 主要用於同步,無法傳遞復雜的數據信息。

『陸』 Linux下Socket編程 怎樣實現客戶端之間互相通信

  1. 網路的Socket數據傳輸是一種特殊的I/O,Socket也是一種文件描述符。Socket也具有一個類似於打開文件的函數調用Socket(),該函數返回一個整型的Socket描述符,隨後的連接建立、數據傳輸等操作都是通過該Socket實現的。

  2. 下面用Socket實現一個windows下的c語言socket通信例子,這里我們客戶端傳遞一個字元串,伺服器端進行接收。

【伺服器端】
#include"stdafx.h"
#include<stdio.h>
#include<winsock2.h>
#include<winsock2.h>
#defineSERVER_PORT5208//偵聽埠
voidmain()
{
WORDwVersionRequested;
WSADATAwsaData;
intret,nLeft,length;
SOCKETsListen,sServer;//偵聽套接字,連接套接字
structsockaddr_insaServer,saClient;//地址信息
char*ptr;//用於遍歷信息的指針
//WinSock初始化
wVersionRequested=MAKEWORD(2,2);//希望使用的WinSockDLL的版本
ret=WSAStartup(wVersionRequested,&wsaData);
if(ret!=0)
{
printf("WSAStartup()failed! ");
return;
}
//創建Socket,使用TCP協議
sListen=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(sListen==INVALID_SOCKET)
{
WSACleanup();
printf("socket()faild! ");
return;
}
//構建本地地址信息
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,(structsockaddr*)&saServer,sizeof(saServer));
if(ret==SOCKET_ERROR)
{
printf("bind()faild!code:%d ",WSAGetLastError());
closesocket(sListen);//關閉套接字
WSACleanup();
return;
}

//偵聽連接請求
ret=listen(sListen,5);
if(ret==SOCKET_ERROR)
{
printf("listen()faild!code:%d ",WSAGetLastError());
closesocket(sListen);//關閉套接字
return;
}

printf("Waitingforclientconnecting! ");
printf("Tips:Ctrl+ctoquit! ");
//阻塞等待接受客戶端連接
while(1)//循環監聽客戶端,永遠不停止,所以,在本項目中,我們沒有心跳包。
{
length=sizeof(saClient);
sServer=accept(sListen,(structsockaddr*)&saClient,&length);
if(sServer==INVALID_SOCKET)
{
printf("accept()faild!code:%d ",WSAGetLastError());
closesocket(sListen);//關閉套接字
WSACleanup();
return;
}
charreceiveMessage[5000];
nLeft=sizeof(receiveMessage);
ptr=(char*)&receiveMessage;
while(nLeft>0)
{
//接收數據
ret=recv(sServer,ptr,5000,0);
if(ret==SOCKET_ERROR)
{
printf("recv()failed! ");
return;
}
if(ret==0)//客戶端已經關閉連接
{
printf("Clienthasclosedtheconnection ");
break;
}
nLeft-=ret;
ptr+=ret;
}
printf("receivemessage:%s ",receiveMessage);//列印我們接收到的消息。

}
//closesocket(sListen);
//closesocket(sServer);
//WSACleanup();
}
【客戶端】
#include"stdafx.h"
#include<stdio.h>
#include<stdlib.h>
#include<winsock2.h>
#defineSERVER_PORT5208//偵聽埠
voidmain()
{
WORDwVersionRequested;
WSADATAwsaData;
intret;
SOCKETsClient;//連接套接字
structsockaddr_insaServer;//地址信息
char*ptr;
BOOLfSuccess=TRUE;
//WinSock初始化
wVersionRequested=MAKEWORD(2,2);//希望使用的WinSockDLL的版本
ret=WSAStartup(wVersionRequested,&wsaData);
if(ret!=0)
{
printf("WSAStartup()failed! ");
return;
}
//確認WinSockDLL支持版本2.2
if(LOBYTE(wsaData.wVersion)!=2||HIBYTE(wsaData.wVersion)!=2)
{
WSACleanup();
printf("InvalidWinSockversion! ");
return;
}
//創建Socket,使用TCP協議
sClient=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(sClient==INVALID_SOCKET)
{
WSACleanup();
printf("socket()failed! ");
return;
}
//構建伺服器地址信息
saServer.sin_family=AF_INET;//地址家族
saServer.sin_port=htons(SERVER_PORT);//注意轉化為網路節序
saServer.sin_addr.S_un.S_addr=inet_addr("192.168.1.127");
//連接伺服器
ret=connect(sClient,(structsockaddr*)&saServer,sizeof(saServer));
if(ret==SOCKET_ERROR)
{
printf("connect()failed! ");
closesocket(sClient);//關閉套接字
WSACleanup();
return;
}


charsendMessage[]="hellothisisclientmessage!";
ret=send(sClient,(char*)&sendMessage,sizeof(sendMessage),0);
if(ret==SOCKET_ERROR)
{
printf("send()failed! ");
}
else
printf("clientinfohasbeensent!");
closesocket(sClient);//關閉套接字
WSACleanup();
}

『柒』 linux系統的進程間通信有哪幾種方式

  • 數據傳輸
    一個進程需要將它的數據發送給另一個進程,發送的數據量在一個位元組到幾M位元組之間

  • 共享數據
    多個進程想要操作共享數據,一個進程對共享數據

  • 通知事
    一個進程需要向另一個或一組進程發送消息,通知它(它們)發生了某種事件(如進程終止時要通知父進程)。

  • 資源共享
    多個進程之間共享同樣的資源。為了作到這一點,需要內核提供鎖和同步機制。

  • 進程式控制制
    有些進程希望完全控制另一個進程的執行(如Debug進程),此時控制進程希望能夠攔截另一個進程的所有陷入和異常,並能夠及時知道它的狀態改變。

  • Linux 進程間通信(IPC)的發展

    linux下的進程通信手段基本上是從Unix平台上的進程通信手段繼承而來的。而對Unix發展做出重大貢獻的兩大主力AT&T的貝爾實驗室及BSD(加州大學伯克利分校的伯克利軟體發布中心)在進程間通信方面的側重點有所不同。

    前者對Unix早期的進程間通信手段進行了系統的改進和擴充,形成了「system V IPC」,通信進程局限在單個計算機內;

    後者則跳過了該限制,形成了基於套介面(socket)的進程間通信機制。

    Linux則把兩者繼承了下來

  • 早期UNIX進程間通信

  • 基於System V進程間通信

  • 基於Socket進程間通信

  • POSIX進程間通信。

  • UNIX進程間通信方式包括:管道、FIFO、信號。

    System V進程間通信方式包括:System V消息隊列、System V信號燈、System V共享內存

    POSIX進程間通信包括:posix消息隊列、posix信號燈、posix共享內存。

    由於Unix版本的多樣性,電子電氣工程協會(IEEE)開發了一個獨立的Unix標准,這個新的ANSI Unix標准被稱為計算機環境的可移植性操作系統界面(PSOIX)。現有大部分Unix和流行版本都是遵循POSIX標準的,而Linux從一開始就遵循POSIX標准;

    BSD並不是沒有涉足單機內的進程間通信(socket本身就可以用於單機內的進程間通信)。事實上,很多Unix版本的單機IPC留有BSD的痕跡,如4.4BSD支持的匿名內存映射、4.3+BSD對可靠信號語義的實現等等。

    linux使用的進程間通信方式

  • 管道(pipe),流管道(s_pipe)和有名管道(FIFO)

  • 信號(signal)

  • 消息隊列

  • 共享內存

  • 信號量

  • 套接字(socket)

  • 管道( pipe )

    管道這種通訊方式有兩種限制,一是半雙工的通信,數據只能單向流動,二是只能在具有親緣關系的進程間使用。進程的親緣關系通常是指父子進程關系。

    流管道s_pipe: 去除了第一種限制,可以雙向傳輸.

    管道可用於具有親緣關系進程間的通信,命名管道:name_pipe克服了管道沒有名字的限制,因此,除具有管道所具有的功能外,它還允許無親緣關系進程間的通信;

    信號量( semophore )

    信號量是一個計數器,可以用來控制多個進程對共享資源的訪問。它常作為一種鎖機制,防止某進程正在訪問共享資源時,其他進程也訪問該資源。因此,主要作為進程間以及同一進程內不同線程之間的同步手段。

    信號是比較復雜的通信方式,用於通知接受進程有某種事件發生,除了用於進程間通信外,進程還可以發送信號給進程本身;linux除了支持Unix早期信號語義函數sigal外,還支持語義符合Posix.1標準的信號函數sigaction(實際上,該函數是基於BSD的,BSD為了實現可靠信號機制,又能夠統一對外介面,用sigaction函數重新實現了signal函數);

    消息隊列( message queue )

    消息隊列是由消息的鏈表,存放在內核中並由消息隊列標識符標識。消息隊列克服了信號傳遞信息少、管道只能承載無格式位元組流以及緩沖區大小受限等缺點。

    消息隊列是消息的鏈接表,包括Posix消息隊列system V消息隊列。有足夠許可權的進程可以向隊列中添加消息,被賦予讀許可權的進程則可以讀走隊列中的消息。消息隊列克服了信號承載信息量少,管道只能承載無格式位元組流以及緩沖區大小受限等缺點。

    信號 ( singal )

    信號是一種比較復雜的通信方式,用於通知接收進程某個事件已經發生。

    主要作為進程間以及同一進程不同線程之間的同步手段。

    共享內存( shared memory )

    共享內存就是映射一段能被其他進程所訪問的內存,這段共享內存由一個進程創建,但多個進程都可以訪問。共享內存是最快的 IPC 方式,它是針對其他進程間通信方式運行效率低而專門設計的。它往往與其他通信機制,如信號量,配合使用,來實現進程間的同步和通信。

    使得多個進程可以訪問同一塊內存空間,是最快的可用IPC形式。是針對其他通信機制運行效率較低而設計的。往往與其它通信機制,如信號量結合使用,來達到進程間的同步及互斥。

    套接字( socket )

    套解口也是一種進程間通信機制,與其他通信機制不同的是,它可用於不同機器間的進程通信

    更為一般的進程間通信機制,可用於不同機器之間的進程間通信。起初是由Unix系統的BSD分支開發出來的,但現在一般可以移植到其它類Unix系統上:Linux和System V的變種都支持套接字。

    進程間通信各種方式效率比較

    類型

    無連接

    可靠

    流控制

    記錄消息類型

    優先順序

    普通PIPE N Y Y N

    流PIPE N Y Y N

    命名PIPE(FIFO) N Y Y N

    消息隊列 N Y Y Y

    信號量 N Y Y Y

    共享存儲 N Y Y Y

    UNIX流SOCKET N Y Y N

    UNIX數據包SOCKET Y Y N N

    注:無連接: 指無需調用某種形式的OPEN,就有發送消息的能力流控制:

    如果系統資源短缺或者不能接收更多消息,則發送進程能進行流量控制

    各種通信方式的比較和優缺點

  • 管道:速度慢,容量有限,只有父子進程能通訊

  • FIFO:任何進程間都能通訊,但速度慢

  • 消息隊列:容量受到系統限制,且要注意第一次讀的時候,要考慮上一次沒有讀完數據的問題

  • 信號量:不能傳遞復雜消息,只能用來同步

  • 共享內存區:能夠很容易控制容量,速度快,但要保持同步,比如一個進程在寫的時候,另一個進程要注意讀寫的問題,相當於線程中的線程安全,當然,共享內存區同樣可以用作線程間通訊,不過沒這個必要,線程間本來就已經共享了同一進程內的一塊內存

  • 如果用戶傳遞的信息較少或是需要通過信號來觸發某些行為.前文提到的軟中斷信號機制不失為一種簡捷有效的進程間通信方式.

    但若是進程間要求傳遞的信息量比較大或者進程間存在交換數據的要求,那就需要考慮別的通信方式了。

    無名管道簡單方便.但局限於單向通信的工作方式.並且只能在創建它的進程及其子孫進程之間實現管道的共享:

    有名管道雖然可以提供給任意關系的進程使用.但是由於其長期存在於系統之中,使用不當容易出錯.所以普通用戶一般不建議使用。

    消息緩沖可以不再局限於父子進程,而允許任意進程通過共享消息隊列來實現進程間通信,並由系統調用函數來實現消息發送和接收之間的同步,從而使得用戶在使用消息緩沖進行通信時不再需要考慮同步問題,使用方便,但是信息的復制需要額外消耗CPU的時間,不適宜於信息量大或操作頻繁的場合。

    共享內存針對消息緩沖的缺點改而利用內存緩沖區直接交換信息,無須復制,快捷、信息量大是其優點。

    但是共享內存的通信方式是通過將共享的內存緩沖區直接附加到進程的虛擬地址空間中來實現的,因此,這些進程之間的讀寫操作的同步問題操作系統無法實現。必須由各進程利用其他同步工具解決。另外,由於內存實體存在於計算機系統中,所以只能由處於同一個計算機系統中的諸進程共享。不方便網路通信。

    共享內存塊提供了在任意數量的進程之間進行高效雙向通信的機制。每個使用者都可以讀取寫入數據,但是所有程序之間必須達成並遵守一定的協議,以防止諸如在讀取信息之前覆寫內存空間等競爭狀態的出現。

    不幸的是,Linux無法嚴格保證提供對共享內存塊的獨占訪問,甚至是在您通過使用IPC_PRIVATE創建新的共享內存塊的時候也不能保證訪問的獨占性。 同時,多個使用共享內存塊的進程之間必須協調使用同一個鍵值。

『捌』 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;
}

『玖』 Linux 進程間套接字通信(Socket)基礎知識

姓名:羅學元    學號:21181214375    學院:廣州研究院

【嵌牛導讀】Linux進程間套接字通信基礎

【嵌牛鼻子】Linux 進程間套接字及通信介紹

【嵌牛提問】Linux進程間套接字包含哪些內容,如何實現通信

一、套接字(Socket)通信原理

套接字通信允許互聯的位於不同計算機上的進程之間實現通信功能。

二、套接字的屬性

套接字的特性由3個屬性確定,它們分別是:域、類型和協議。

1. 套接字的域

它指定套接字通信中使用的網路介質,最常見的套接字域是AF_INET,它指的是Internet網路。當客戶使用套接字進行跨網路的連接時,它就需要用到伺服器計算機的IP地址和埠來指定一台聯網機器上的某個特定服務,所以在使用socket作為通信的終點,伺服器應用程序必須在開始通信之前綁定一個埠,伺服器在指定的埠等待客戶的連接。

另一個域AF_UNIX表示UNIX文件系統,就是文件輸入/輸出,它的地址就是文件名。

2. 套接字類型

網際網路提供了兩種通信機制:流(stream)和數據報(datagram),因而套接字的類型也就分為流套接字和數據報套接字。我們主要看流套接字。

流套接字由類型SOCK_STREAM指定,它們是在AF_INET域中通過TCP/IP連接實現,同時也是AF_UNIX中常用的套接字類型。

流套接字提供的是一個有序、可靠、雙向位元組流的連接,因此發送的數據可以確保不會丟失、重復或亂序到達,而且它還有一定的出錯後重新發送的機制。

與流套接字相對的是由類型SOCK_DGRAM指定的數據報套接字,它不需要建立連接和維持一個連接,它們在AF_INET中通常是通過UDP/IP實現的。它對可以發送的數據的長度有限制,數據報作為一個單獨的網路消息被傳輸,它可能丟失、復制或錯亂到達,UDP不是一個可靠的協議,但是它的速度比較高,因為它並不需要總是要建立和維持一個連接。

3.套接字協議

只要底層的傳輸機制允許不止一個協議來提供要求的套接字類型,我們就可以為套接字選擇一個特定的協議。通常只需要使用默認值。

三、套接字地址

每個套接字都有其自己的地址格式,對於AF_UNIX域套接字來說,它的地址由結構sockaddr_un來描述,該結構定義在頭文件

struct sockaddr_un{

sa_family_t sun_family;  //AF_UNIX,它是一個短整型

char sum_path[];  //路徑名

};

對於AF_INET域套接字來說,它的地址結構由sockaddr_in來描述,它至少包括以下幾個成員:

struct sockaddr_in{

short int sin_family;  //AN_INET

unsigned short int sin_port;  //埠號

struct in_addr sin_addr;    //IP地址

}

而in_addr被定義為:

struct in_addr{

unsigned long int s_addr;

}

四、基於流套接字的客戶/伺服器的工作流程

使用socket進行進程通信的進程採用的客戶/伺服器系統是如何工作的呢?

1.伺服器端

首先,伺服器應用程序用系統調用socket來創建一個套接字,它是系統分配給該伺服器進程的類似文件描述符的資源,它不能與其他的進程共享。

接下來,伺服器進程會給套接字起個名字,我們使用系統調用bind來給套接字命名。然後伺服器進程就開始等待客戶連接到這個套接字。

然後,系統調用listen來創建一個隊列,並將其用於存放來自客戶的進入連接。

最後,伺服器通過系統調用accept來接受客戶的連接。它會創建一個與原有的命名套接不同的新套接字,這個套接字只用於與這個特定客戶端進行通信,而命名套接字(即原先的套接字)則被保留下來繼續處理來自其他客戶的連接。

2.客戶端

基於socket的客戶端比伺服器端簡單。同樣,客戶應用程序首先調用socket來創建一個未命名的套接字,然後講伺服器的命名套接字作為一個地址來調用connect與伺服器建立連接。

一旦連接建立,我們就可以像使用底層的文件描述符那樣用套接字來實現雙向數據的通信。

熱點內容
安卓手機如何繞過緩存軟體 發布:2025-03-16 22:35:16 瀏覽:241
c語言求職 發布:2025-03-16 22:34:23 瀏覽:429
在線教育培訓源碼 發布:2025-03-16 22:31:57 瀏覽:233
反編譯vb工具 發布:2025-03-16 22:27:04 瀏覽:353
安卓流程為什麼越來越多 發布:2025-03-16 22:26:50 瀏覽:933
五軸編程模型 發布:2025-03-16 22:17:48 瀏覽:181
linuxc函數庫 發布:2025-03-16 22:03:33 瀏覽:921
iphone最新版系統從哪裡改密碼 發布:2025-03-16 21:56:19 瀏覽:596
python的execute 發布:2025-03-16 21:40:24 瀏覽:767
今天的訪問量就靠你了 發布:2025-03-16 21:39:35 瀏覽:430