linuxsocket本地通信

⑴ linux C語言編程,socket實現的即使通訊系統

//服務端server.c
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#define SERVPORT 6000 /*伺服器監聽埠號 */
#define BACKLOG 10 /* 最大同時連接請求數 */
#define MAXDATASIZE 100

main()
{
char buf[MAXDATASIZE];
int sockfd,client_fd; /*sock_fd：監聽socket；client_fd：數據傳輸socket */
struct sockaddr_in my_addr; /* 本機地址信息 */
struct sockaddr_in remote_addr; /* 客戶端地址信息 */

if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
perror("socket創建出錯！");
exit(1);
}
my_addr.sin_family=AF_INET;
my_addr.sin_port=htons(SERVPORT);
my_addr.sin_addr.s_addr = INADDR_ANY;
bzero(&(my_addr.sin_zero),8);
if (bind(sockfd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1)
{
perror("bind出錯！");
exit(1);
}
if (listen(sockfd, BACKLOG) == -1)
{
perror("listen出錯！");
exit(1);
}
while(1)
{
sin_size = sizeof(struct sockaddr_in);
if ((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size)) == -1)
{
perror("accept出錯");
continue;
}
printf("received a connection from %s\n", inet_ntoa(remote_addr.sin_addr));
if (!fork())
{ /* 子進程代碼段 */
if ((recvbytes=recv(client_fd, buf, MAXDATASIZE, 0)) ==-1)
{
perror("recv出錯！");
close(client_fd);
exit(0);
}
buf[recvbytes] = '\0';
printf("from client Received: %s",buf);

if (send(client_fd, "thanks!\n", 8, 0) == -1)
perror("send出錯！");
close(client_fd);
exit(0);
}
close(client_fd);
}
}

//客戶端client.c
#include<stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <netdb.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/socket.h>
#define SERVPORT 6000
#define MAXDATASIZE 100

main(int argc, char *argv[])
{
int sockfd, recvbytes;
char buf[MAXDATASIZE];
struct hostent *host;
struct sockaddr_in serv_addr;
if (argc < 2)
{
fprintf(stderr,"Please enter the server's hostname!\n");
exit(1);
}
if((host=gethostbyname(argv[1]))==NULL)
{
herror("gethostbyname出錯！");
exit(1);
}
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
{
perror("socket創建出錯！");
exit(1);
}
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(SERVPORT);
serv_addr.sin_addr = *((struct in_addr *)host->h_addr);
bzero(&(serv_addr.sin_zero),8);
if (connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr)) == -1)
{
perror("connect出錯！");
exit(1);
}

if (send(sockfd, "hello!\n", 7, 0) == -1)
{
perror("send出錯！");
exit(1);
}

if ((recvbytes=recv(sockfd, buf, MAXDATASIZE, 0)) ==-1)
{
perror("recv出錯！");
exit(1);
}
buf[recvbytes] = '\0';
printf("Received: %s",buf);
close(sockfd);
}

⑵ Linux中本機和本機Socket通信會走網卡嗎

我寫一個測試程序，結論是：不需要走網卡。
我生成了一個5G的大文件。同時傳輸的過程中，我把網卡拔掉，最後數據傳輸完畢。
不過這是一個很傻逼的行為，因為直接把網卡拔掉就可以測試。

至於原因 @pansz已經提到了。 雖然我行為是傻逼了點，不過寫這個程序的過程中還是收獲不少呢，因為剛學網路編程，多挖幾個坑還自己還是有好處的。

代碼如下：
生成文件的代碼：

#define SIZE 5000000
#define OPEN_MODE 00777

int main(int argc,char **argv){
srand(time(NULL));
int fd=open("output.txt",O_APPEND|O_RDWR);
int n=0;
char buf[1024]={0};

for(int i=0;i<SIZE;i++){
for(int j=0;j<1023;j++){
buf[j]=(char)(rand()%94+32);
}
buf[1023]='\0';
n=write(fd,buf,1024);
}
close(fd);
return 0;
}

Client

int len=0;
while((len=read(fd,sendline,1024))){
if( send(sockfd,sendline,strlen(sendline), 0) < 0)
{
printf("send msg error: %s(errno: %d)\n", strerror(errno), errno);
exit(0);
}
if((rec_len = recv(sockfd, buf, MAXLINE,0)) == -1) {
perror("recv error");
exit(1);
}
memset(sendline,0,1024);
buf[rec_len] = '\0';
printf("Received : %s ",buf);
}
close(sockfd);

Server

void Server::EventLoop(){
int fd=open("re.txt",O_APPEND | O_RDWR);

cout<<"waiting for client's request."<<endl;

if((cfd=accept(sfd,reinterpret_cast<struct sockaddr*>(NULL),NULL))==-1){
std::cerr<<"acceprt error!"<<endl;
}

while(1){
nread=recv(cfd,buf,BUF_SIZE,0);
buf[nread]='\0';

write(fd,buf,nread);
printf("the size is: %zd\n",nread);

if(send(cfd,"Yeah I have receive your message.\n",40,0)==-1){
std::cerr<<"send error."<<endl;
exit(-1);
}
}
close(sfd);
}

⑶ linux系統的進程間通信有哪幾種方式

一、方式

1、管道（Pipe）及有名管道（ mkpipe）：

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

2、信號（Signal）：

信號是比較復雜的通信方式，用於通知接受進程有某種事件發生，除了用於進程間通信外，進程還可以發送信號給進程本身。

linux除了支持Unix早期信號語義函數sigal外，還支持語義符合Posix.1標準的信號函數sigaction。

實際上，該函數是基於BSD的，BSD為了實現可靠信號機制，又能夠統一對外介面，用sigaction函數重新實現了signal函數。

3、消息隊列（Message）：

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

4、共享內存：

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

5、信號量（semaphore）：

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

6、套介面（Socket）：

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

二、概念

進程間通信概念：

IPC—-InterProcess Communication

每個進程各自有不同的用戶地址空間,任何一個進程的全局變數在另一個進程中都看不到所以進程之間要交換數據必須通過內核。

在內核中開辟一塊緩沖區,進程1把數據從用戶空間拷到內核緩沖區,進程2再從內核緩沖區把數據讀走,內核提供的這種機制稱為進程間通信。

(3)linuxsocket本地通信擴展閱讀

1）無名管道:

管道是半雙工的，數據只能向一個方向流動；需要雙方通信時，需要建立起兩個管道；只能用於父子進程或者兄弟進程之間（具有親緣關系的進程）。

管道對於管道兩端的進程而言，就是一個文件，但它不是普通的文件，它不屬於某種文件系統，構成兩進程間通信的一個媒介。

數據的讀出和寫入：一個進程向管道中寫的內容被管道另一端的進程讀出。寫入的內容每次都添加在管道緩沖區的末尾，並且每次都是從緩沖區的頭部讀出數據。

2）有名管道：

不同於管道之處在於它提供一個路徑名與之關聯，以FIFO的文件形式存在於文件系統中。這樣，即使與FIFO的創建進程不存在親緣關系的進程，只要可以訪問該路徑，就能夠彼此通過FIFO相互通信（能夠訪問該路徑的進程以及FIFO的創建進程之間）。

因此，通過FIFO不相關的進程也能交換數據。值得注意的是，FIFO嚴格遵循先進先出（first in first out），對管道及FIFO的讀總是從開始處返回數據，對它們的寫則把數據添加到末尾。它們不支持諸如lseek()等文件定位操作。

⑷ 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編程socket通信疑問

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

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

⑹ Linux C 網路編程....使用socket通訊...

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

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

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

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

⑺ 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與伺服器建立連接。

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

⑻ linux下實現簡單的socket通信，運行client端時需要傳入哪些參數

你程序里寫得很清楚啊,需要傳入伺服器IP地址

不帶參數時 argc 為1
argv[0] 里放的是程序的路徑
加了參數以後 argc = 輸入參數的個數加1
argv[1] 開始才是用戶輸入的參數