linuxc下tcp循環read實例

❶ linux C語言 TCP 多線程 簡易聊天室

你accept得到一個新的連接後，再創建線程（把連接socket傳給線程），用這個線程專門接收這個連接的數據，就不會有問題了。

❷ linux網路編程中如何實現伺服器端多個read（）和客戶端write( )

TCP通信的模式如下圖，比較固定，對著圖編代碼就可以了：

因為客戶端沒有指定IP地址和埠，所以其IP和埠都是內核隨機分配的。

❸ Linux C系統編程中的文件傳輸問題:只能傳送文本文件，不能傳送二進制文件。（TCP+文件I/O實現）

下面這段是發送文件內容及其16進制編碼的。

file = fopen("w:\\temp.dat","rb");
if(file)
{
buffer[0]=0;
char temp[64];
while(1)
{
r = fread(buffer,1,16,file);
buffer[r]=0;
int index=0;
for(index=0;index<r;index++)
{
sprintf(temp,"%02x ",(unsigned char)buffer[index]);
printf(temp);
send(AcceptSocket,temp,strlen(temp),0);
}
for(index=r;index<16;index++)
{
sprintf(temp," ");
printf(temp);
send(AcceptSocket,temp,strlen(temp),0);
}
for(index=0;index<r;index++)
{
if((unsigned char)buffer[index]>=0x20)
{
sprintf(temp,"%c",(unsigned char)buffer[index]);
printf(temp);
send(AcceptSocket,temp,strlen(temp),0);
}else
{
sprintf(temp,".");
printf(temp);
send(AcceptSocket,temp,strlen(temp),0);
}
}
sprintf(temp,"\r\n");
printf(temp);
send(AcceptSocket,temp,strlen(temp),0);
//send(AcceptSocket,buffer,r,0);
if (r<16) break;
}

printf("(end)\r\n");

fclose(file);
}

❹ 計算機網路socket linux下用c或c++寫

/*伺服器*/
#include <arpa/inet.h>
#include <errno.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/io.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/times.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#define szSTR 256
#define SERVERPORT 21429 /*please modify the port with your id*/

int do_listen(const int port, const int bTcp)
{
int s = 0, r = 0, o = 1;
struct sockaddr_in h;
memset(&h, 0, sizeof(h));
h.sin_family = AF_INET; h.sin_port = htons(port);
h.sin_addr.s_addr = INADDR_ANY;
s = socket(AF_INET, bTcp?SOCK_STREAM:SOCK_DGRAM, 0);
if (s < 1) { perror("socket(listen)"); return 0;}
r = setsockopt(s, SOL_SOCKET,SO_REUSEADDR, (char *)&o, sizeof(int));
if (r == -1) { perror("setsockopt(listen)"); return 0;}
r = bind(s, (struct sockaddr *)&h, sizeof(h));
if (r == -1) { perror("bind(listen)"); return 0;}
if (bTcp) {
r = listen(s, SOMAXCONN);
if (r == -1) { perror("listen()"); return 0;}
}/*end if*/
/*signal(SIGPIPE, SIG_IGN);*/
return s;
}/*end do_listen*/

void response(int sck, struct sockaddr_in * host)
{
FILE * f = 0; char cmd[szSTR]; time_t now;
struct tm * t = 0;
f = fdopen(sck, "w+");
while(!feof(f)) {
memset(cmd, 0, szSTR);
fgets(cmd, szSTR -1, f);
time(&now);
t = localtime(&now);
if(strstr(cmd, "DATE")) {
fprintf(stderr, "Query Type: Date\n");
fprintf(f, "Date: %d %d, %d\n", t->tm_mon + 1, t->tm_mday, t->tm_year + 1900);
continue;
}/*end if*/
if(strstr(cmd, "TIME")) {
fprintf(stderr, "Query Type: Time\n");
fprintf(f, "Time: %02d::%02d::%02d\n", t->tm_hour, t->tm_min, t->tm_sec);
continue;
}/*end if*/
if(strstr(cmd, "EXIT")) break;
fprintf(f, "commands: DATE, TIME, EXIT.\n");
}/*end while*/
shutdown(sck, SHUT_RDWR);
close(sck);
fclose(f);
return ;
}/*end response*/

int main(void)
{
socklen_t sklen = 0;int sck = 0, i = 0, listener = 0;
struct sockaddr_in client; pid_t proc = 0;
system("ifconfig");
listener = do_listen(SERVERPORT, 1);
if(listener < 1) { perror("listen()"); return 0; }
for(i=0;i<2;i++) {
memset(&client, 0, sizeof(client));
sklen = sizeof(client);
sck = accept(listener, (struct sockaddr *)&client, &sklen);
if(sck < 1) break;
proc = fork();
if (proc == -1) { perror("fork()"); break ; }
if(proc) continue;
response(sck, &client);
break;
}/*next*/
close(listener);
return 0;
}/*end main*/

/*客戶機*/
#include <arpa/inet.h>
#include <errno.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/io.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/times.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#define szSTR 256
#define SERVERPORT 21429 /*please modify the port with your id*/
int cnn(const char * ip, const int port)
{
struct sockaddr_in h; memset(&h, 0, sizeof(h));
h.sin_family = AF_INET; h.sin_port = htons(port);
h.sin_addr.s_addr = inet_addr(ip);
int s = socket(AF_INET, SOCK_STREAM, 0);
if (s < 1) { perror("socket(tcp)"); return 0;}
int r = connect(s, (struct sockaddr *)&h, sizeof(h));
if (r == 0) return s;
perror("connect()");
return 0;
}//end cnn

int main(void)
{
int sck = 0; FILE * f = 0; char ip[szSTR]="127.0.0.1";
fprintf(stderr, "Please input the calendar server ip:");
fgets(ip, szSTR - 1, stdin);
sck = cnn(ip, SERVERPORT);
if(sck < 1) return 0;
f = fdopen(sck, "w+");
fprintf(f, "DATE\r\n");
fgets(ip, szSTR -1 , f);
fprintf(stderr, "%s\n", ip);
fprintf(f, "TIME\r\n");
fgets(ip, szSTR -1 , f);
fprintf(stderr, "%s\n", ip);
fprintf(f, "EXIT\r\n");
fclose(f);
close(sck);
return 0;
}/*end main*/

❺ linux c socket 客戶端循環十次向伺服器發送數據（tcp連接），為啥只能接受第一次的求代碼

只是做這些動作的話不需要多線程

找了下以前寫的 改成了你說的10次發送
client.c:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>

int main(int argc,char **argv)
{
char wbuf[] = "hello server";
char rbuf[128];
int i;
int sock;
struct sockaddr_in server = {0};
struct timeval timeo;

timeo.tv_sec = 0;
timeo.tv_usec = 1000 * 1000; //
socklen_t len = sizeof(timeo);
if( argc != 2)
{
printf("usage: ./client <ipaddress>\n");
return -1;
}

sock = socket(AF_INET, SOCK_STREAM, 0);
if(sock < 0)
{
perror("Create TCP Socket");

return -1;
}

setsockopt(sock, SOL_SOCKET, SO_SNDTIMEO, &timeo, len);

server.sin_family = AF_INET;
server.sin_port = htons(30000);
inet_pton(AF_INET, argv[1], &(server.sin_addr));

int res = connect(sock, (struct sockaddr*)&server, sizeof(server));
if (res < 0)
{
if(res == EINPROGRESS)
perror("connecting stream socket time out:");
else
perror("connecting stream socket error:");
close(sock);
return -1;
}
else
{
printf("Connect Server@%s\n",argv[1]);
for(i=0;i<10;i++)
{
int wsize = send(sock,wbuf,sizeof(wbuf),0);
if(wsize<=0)
{

perror("write error:");
close(sock);
return -1;
}
printf("1111111i=%d\n",i);
while(1)
{
int rsize=recv(sock,rbuf,sizeof(rbuf),0);
if(rsize>0)
{
rbuf[rsize]='\0';
printf("recv msg from server: %s\n",rbuf);
break;
}
if(rsize<0)
{
close(sock);
perror("read error:");
return -1;
}
}

}
close(sock);
return 0;
}

}

server.c:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<errno.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>

int main(int argc, char** argv)
{
int listenfd, connfd;
struct sockaddr_in servaddr = {0};
char rbuf[128];
char wbuf[] = "hello client";
int n;

if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1 )
{
perror("Create TCP Socket");
return -1;
}

servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(30000);

if( bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1)
{
perror("bind socket error:");
return -1;
}

if( listen(listenfd, 10) == -1)
{
perror("listen socket error:");
return -1;
}

printf("======waiting for client's request======\n");
while(1)
{
if( (connfd = accept(listenfd, (struct sockaddr*)NULL, NULL)) == -1)
{
perror("accept socket error:");
continue;
}
while(1)
{
n = recv(connfd, rbuf, sizeof(rbuf), 0);
if(n>0)
{
rbuf[n] = '\0';
printf("recvmsg from client: %s\n", rbuf);
n = send(connfd, wbuf, sizeof(wbuf),0);
if(n<=0)
{
perror("sned error:");
close(connfd);
break;
}
}
else if(n < 0)
{
perror("recv error:");
close(connfd);
break;
}
}
close(connfd);
}
close(listenfd);
return 0;
}

運行的時候 client
./client 你的serverip
埠我用的30000 寫死在程序里了

❻ Linux C語言網路編程問題！

unsigned int dir(char * server) {
int sck;//套接字變數
struct sockaddr_in serv_adr; //遠程主機的地址
struct hostent *host; //指向遠程主機的指針
unsigned char databuf[FILEBUF_SIZE]; //數據
int bytes = 0, bytesread = 0; //位元組數，讀取到的位元組數

host = gethostbyname(server); //根據遠程主機的主機名，得到指向遠程主機的指針
if (host == (struct hostent *) NULL) { //如果得到指向遠程主機的指針失敗，報告錯誤，並返回
perror("gethostbyname failed");
return 0;
}memset(&serv_adr, 0, sizeof(serv_adr)); //初始化遠程主機的地址，結構體內所有成員清零
serv_adr.sin_family = AF_INET; //設置地址類型
memcpy(&serv_adr.sin_addr, host->h_addr, host->h_length);//取出指向遠程主機的指針中包含的地址信息，賦給遠程主機地址變數
serv_adr.sin_port = htons(SERVICE_PORT);//設置埠號，比如http服務對應80埠，ftp對應21埠

if ((sck = socket(AF_INET, SOCK_STREAM, 0)) < 0) { //如果建立TCP協議的套接字失敗，報告錯誤，並返回
perror("error on socket()");
return 0;
}
if (connect(sck, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) < 0) {//如果使用該套接字連接到遠程主機失敗，報告錯誤，並返回
perror("error on connect()");
return 0;
}write(sck, "DI\n\n", 4); //連接成功，發送內容為"DI\n\n"的消息，遠程主機收到該消息，解析後生成目錄列表，並將目錄列表信息傳遞回來
printf("Remote directory listing:\n");//輸出提示信息「遠程主機正在生成目錄列表」
while ((bytes = read(sck, databuf, FILEBUF_SIZE)) > 0) { //從套接字的數據流中讀取遠程主機的返回信息（即目錄列表），每次讀取FILEBUF_SIZE個位元組，直到全部讀取完畢
write(fileno(stdout), databuf, bytes);//將每次讀到的數據，輸出到標准輸出流(stdout)，即屏幕上
bytesread += bytes;//接收到的位元組數累加
}

close(sck); /* Close the socket */ //通信完成，關閉套接字，關閉連接

return bytesread; //返回讀取到的位元組數（即遠程主機返回的信息的大小）
}

❼ 關於linux系統下TCP通信 伺服器read函數一直讀取數據卻什麼都讀不到的問題

採用多線程編程，主進程負責等待連接到來，收到連接請求後父進程派生一個線程去處理該版通信過程，權通信處理交給該線程，父進程繼續循環等待連接請求。通信結束，該線程結束。
當然也可以採用信號觸發方式，當連接請求到來時，觸發父進程派生一個線程去處理該請求。

❽ linux中關於流式套接字編程代碼的解釋，求大神把每行代碼加上注釋，具體一點

伺服器端
#include<sys/types.h>
#include<sys/socket.h>
#include<stdio.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>
#include<stdlib.h>

intmain(intargc,char*argv)
{
intserver_sockfd,client_sockfd;
intserver_len,client_len;
structsockaddr_inserver_address;
structsockaddr_inclient_address;

//獲得一個socket文件描述符，使用tcpip協議
server_sockfd=socket(AF_INET,SOCK_STREAM,0);
server_address.sin_family=AF_INET;
//設置伺服器端接受任何主機的請求
server_address.sin_addr.s_addr=htonl(INADDR_ANY);
//使用埠9734來接受請求
server_address.sin_port=htons(9734);
server_len=sizeof(server_address);
//綁定socket
bind(server_sockfd,(structsockaddr*)&server_address,server_len);

//監聽連接請求，連接請求隊列大小為5
listen(server_sockfd,5);

while(1)
{
charch;
printf("serverwaiting
");

client_len=sizeof(client_address);

//接受client端的連接請求，如果沒有連接請求，該進程將阻塞
client_sockfd=accept(server_sockfd,(structsockaddr*)&client_address,&client_len);
//讀數據
read(client_sockfd,&ch,1);
ch++;
//寫數據
write(client_sockfd,&ch,1);

//關閉與client端的連接
close(client_sockfd);

}
}

客戶端
#include<sys/types.h>
#include<sys/socket.h>
#include<stdio.h>
#include<stdlib.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<unistd.h>

intmain(intargc,char*argv)
{
intsockfd;
intlen;
structsockaddr_inaddress;
intresult;
charch='A';

//設置需要連接伺服器的ipport
sockfd=socket(AF_INET,SOCK_STREAM,0);
address.sin_family=AF_INET;
address.sin_addr.s_addr=inet_addr("127.0.0.1");
address.sin_port=htons(9734);
len=sizeof(address);

//連接伺服器
result=connect(sockfd,(structsockaddr*)&address,len);
if(result==-1)
{
perror("oops:client3");
exit(1);
}

//寫數據
write(sockfd,&ch,1);
//讀數據
read(sockfd,&ch,1);
printf("charfromserver=%c
",ch);
//關閉與伺服器的連接
close(sockfd);
exit(0);

}

關於你的問題：
1.簡單的方法，設置socket套接字為非阻塞模式，然後輪詢，並查看是否超時。

或者是使用select poll 等方法 ，設置超時時間。

或者 使用 alarm 信號，都可以。

2..每當接收到一個client 端的連接請求，就開辟一個線程為之服務。

或者使用select poll epoll等方法，推薦這個。

3.你是指的是處理信號嗎？這個有專門的函數 signal 可以處理。

❾ 暢談linux下TCP（上）

tcp 協議 是互聯網中最常用的協議 ， 開發人員基本上天天和它打交道，對它進行深入了解。 可以幫助我們排查定位bug和進行程序優化。下面我將就TCP幾個點做深入的探討

客戶端：收到 ack 後 分配連接資源。 發送數據
伺服器 : 收到 syn 後立即 分配連接資源

客戶端：收到ACK， 立即分配資源
伺服器：收到ACK， 立即分配資源

既然三次握手也不是100%可靠， 那四次，五次，六次。。。呢? 其實都一樣，不管多少次都有丟包問題。

client 只發送一個 SYN， server 分配一個tcb， 放入syn隊列中。 這時候連接叫 半連接 狀態；如果server 收不到 client 的ACK， 會不停重試 發送 ACK-SYN 給client 。重試間隔 為 2 的 N 次方 疊加（2^0 , 2^1, 2^2 ....）；直至超時才釋放syn隊列中的這個 TCB;
在半連接狀態下， 一方面會佔用隊列配額資源，另一方面佔用內存資源。我們應該讓半連接狀態存在時間盡可能的小

當client 向一個未打開的埠發起連接請求時，會收到一個RST回復包

當listen 的 backlog 和 somaxconn 都設置了得時候， 取兩者min值

Recv-Q 是accept 隊列當前個數， Send-Q 設置最大值

這種SYN洪水攻擊是一種常見攻擊方式，就是利用半連接隊列特性，占滿syn 隊列的 資源，導致 client無法連接上。
解決方案:

為什麼不像握手那樣合並成三次揮手? 因為和剛開始連接情況，連接是大家都從0開始， 關閉時有歷史包袱的。server(被動關閉方) 收到 client(主動關閉方) 的關閉請求FIN包。 這時候可能還有未發送完的數據，不能丟棄。 所以需要分開。事實可能是這樣

當然，在沒有待發數據，並且允許 Delay ACK 情況下， FIN-ACK合並還是非常常見的事情，這是三次揮手是可以的。

同上

CLOSE_WAIT 是被動關閉方才有的狀態 。

被動關閉方 [收到 FIN 包 發送 ACK 應答] 到 [發送FIN， 收到ACK ] 期間的狀態為 CLOSE_WAIT， 這個狀態仍然能發送數據。 我們叫做 半關閉 , 下面用個例子來分析:

這個是我實際生產環境碰到的一個問題，長連接會話場景，server端收到client的rpc call 請求1，處理發現請求包有問題，就強制關閉結束這次會話， 但是 因為client 發送 第二次請求之前，並沒有去調用recv，所以並不知道 這個連接被server關閉， 繼續發送 請求2 ， 此時是半連接，能夠成功發送到對端機器，但是recv結果後，遇到連接已經關閉錯誤。

如果 client 和 server 恰好同時發起關閉連接。這種情況下，兩邊都是主動連接，都會進入 TIME_WAIT狀態

1、 被動關閉方在LAST_ACK狀態(已經發送FIN)，等待主動關閉方的ACK應答，但是 ACK丟掉， 主動方並不知道，以為成功關閉。因為沒有TIME_WAIT等待時間，可以立即創建新的連接， 新的連接發送SYN到前面那個未關閉的被動方，被動方認為是收到錯誤指令，會發送RST。導致創建連接失敗。

2、 主動關閉方斷開連接，如果沒有TIME_WAIT等待時間，可以馬上建立一個新的連接，但是前一個已經斷開連接的，延遲到達的數據包。 被新建的連接接收，如果剛好seq 和 ack欄位 都正確, seq在滑動窗口范圍內(只能說機率非常小，但是還是有可能會發生)，會被當成正確數據包接收，導致數據串包。 如果不在window范圍內，則沒有影響( 發送一個確認報文（ack 欄位為期望ack的序列號，seq為當前發送序列號），狀態變保持原樣)

TIME_WAIT 問題比較比較常見，特別是CGI機器，並發量高，大量連接後段服務的tcp短連接。因此也衍生出了多種手段解決。雖然每種方法解決不是那麼完美，但是帶來的好處一般多於壞處。還是在日常工作中會使用。
1、改短TIME_WAIT 等待時間

這個是第一個想到的解決辦法，既然等待時間太長，就改成時間短，快速回收埠。但是實際情況往往不樂觀，對於並發的機器，你改多短才能保證回收速度呢，有時候幾秒鍾就幾萬個連接。太短的話，就會有前面兩種問題小概率發生。

2、禁止Socket lingering

這種情況下關閉連接，會直接拋棄緩沖區中待發送的數據，會發送一個RST給對端，相當於直接拋棄TIME_WAIT， 進入CLOSE狀態。同樣因為取消了 TIME_WAIT 狀態，會有前面兩種問題小概率發生。

3、tcp_tw_reuse
net.ipv4.tcp_tw_reuse選項是 從 TIME_WAIT 狀態的隊列中，選取條件：1、remote 的 ip 和埠相同， 2、選取一個時間戳小於當前時間戳； 用來解決埠不足的尷尬。

現在埠可以復用了，看看如何面對前面TIME_WAIT 那兩種問題。 我們仔細回顧用一下前面兩種問題。 都是在新建連接中收到老連接的包導致的問題 ， 那麼如果我能在新連接中識別出此包為非法包，是不是就可以丟掉這些無用包，解決問題呢。

需要實現這些功能，需要擴展一下tcp 包頭。 增加 時間戳欄位。 發送者 在每次發送的時候。 在tcp包頭裡面帶上發送時候的時間戳。 當接收者接收的時候，在ACK應答中除了TCP包頭中帶自己此時發送的時間戳，並且把收到的時間戳附加在後面。也就是說ACK包中有兩個時間戳欄位。結構如下:

那我們接下來一個個分析tcp_tw_reuse是如何解決TIME_WAIT的兩個問題的

4、tcp_tw_recycle

tcp_tw_recycle 也是藉助 timestamp機制。顧名思義， tcp_tw_reuse 是復用 埠，並不會減少 TIME-WAIT 數量。你去查詢機器上TIME-WAIT 數量，還是 幾千幾萬個，這點對有強迫症的同學感覺很不舒服。tcp_tw_recycle 是 提前 回收 TIME-WAIT資源。會減少 機器上 TIME-WAIT 數量。

tcp_tw_recycle 工作原理是。