1.send函數
ssize_t send( SOCKET s, const char *buf, size_t len, int flags );
（1）send先比較待發送數據的長度len和套接字s的發送緩沖的長度， 如果len大於s的發送緩沖區的長度，該函數返回SOCKET_ERROR；
（2）如果len小於或者等於s的發送緩沖區的長度，那麼send先檢查協議是否正在發送s的發送緩沖中的數據，如果是就等待協議把數據發送完，如果協議還沒有開始發送s的發送緩沖中的數據或者s的發送緩沖中沒有數據，那麼send就比較s的發送緩沖區的剩餘空間和len；
（3）如果len大於剩餘空間大小，send就一直等待協議把s的發送緩沖中的數據發送完；
（4）如果len小於剩餘空間大小，send就僅僅把buf中的數據到剩餘空間里（注意並不是send把s的發送緩沖中的數據傳到連接的另一端的，而是協議傳送的，send僅僅是把buf中的數據到s的發送緩沖區的剩餘空間里）。
注意：
（1）如果send函數數據成功，就返回實際的位元組數，如果send在數據時出現錯誤，那麼send就返回SOCKET_ERROR；如果send在等待協議傳送數據時網路斷開的話，那麼send函數也返回SOCKET_ERROR。
（2）要注意send函數把buf中的數據成功到s的發送緩沖的剩餘空間里後它就返回了，但是此時這些數據並不一定馬上被傳到連接的另一端。如果協議在後續的傳送過程中出現網路錯誤的話，那麼下一個Socket函數就會返回SOCKET_ERROR。（每一個除send外的Socket函數在執行的最開始總要先等待套接字的發送緩沖中的數據被協議傳送完畢才能繼續，如果在等待時出現網路錯誤，那麼該Socket函數就返回 SOCKET_ERROR）
（3）在Unix系統下，如果send在等待協議傳送數據時網路斷開的話，調用send的進程會接收到一個SIGPIPE信號，進程對該信號的默認處理是進程終止。
2.recv函數
ssize_t recv(int s, char *buf, size_t len, int flags);
（1）recv先等待s的發送緩沖中的數據被協議傳送完畢，如果協議在傳送s的發送緩沖
中的數據時出現網路錯誤，那麼recv函數返回SOCKET_ERROR。
（2）如果s的發送緩沖中沒有數據或者數據被協議成功發送完畢後，recv先檢查套接字s的接收緩沖區，如果s接收緩沖區中沒有數據或者協議正在接收數 據，那麼recv就一直等待，直到協議把數據接收完畢。當協議把數據接收完畢，recv函數就把s的接收緩沖中的數據到buf中。（注意：協議接收到的數據可能大於buf的長度，所以 在這種情況下要調用幾次recv函數才能把s的接收緩沖中的數據完。recv函數僅僅是數據，真正的接收數據是協議來完成的）
（3）recv函數返回其實際的位元組數。如果recv在時出錯，那麼它返回SOCKET_ERROR；如果recv函數在等待協議接收數據時網路中斷了，那麼它返回0。
注意：在Unix系統下，如果recv函數在等待協議接收數據時網路斷開了，那麼調用recv的進程會接收到一個SIGPIPE信號，進程對該信號的默認處理是進程終止。
Q&A：
（1）兩次send一次recv會發生什麼？
一次性讀取兩次send的內容。
（2）recv之後，接收緩沖區會被清空嗎？
是的。
B. 求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操作系統作為開發平台
C. linux下socket 網路編程(客戶端向伺服器端發送文件) 求源代碼 大哥大姐幫幫忙 ,。。謝謝
源代碼奉上，流程圖。。。這個太簡單了，你自己看看。。。。。。。
//TCP
//伺服器端程序
#include< stdio.h >
#include< stdlib.h >
#include< windows.h >
#include< winsock.h >
#include< string.h >
#pragma comment( lib, "ws2_32.lib" )
#define PORT 2046
#define BACKLOG 10
#define TRUE 1
void main( void )
{
int iServerSock;
int iClientSock;
char *buf = "hello, world!\n";
struct sockaddr_in ServerAddr;
struct sockaddr_in ClientAddr;
int sin_size;
WSADATA WSAData;
if( WSAStartup( MAKEWORD( 1, 1 ), &WSAData ) )//初始化
{
printf( "initializationing error!\n" );
WSACleanup( );
exit( 0 );
}
if( ( iServerSock = socket( AF_INET, SOCK_STREAM, 0 ) ) == INVALID_SOCKET )
{
printf( "創建套接字失敗!\n" );
WSACleanup( );
exit( 0 );
}
ServerAddr.sin_family = AF_INET;
ServerAddr.sin_port = htons( PORT );//監視的埠號
ServerAddr.sin_addr.s_addr = INADDR_ANY;//本地IP
memset( & ( ServerAddr.sin_zero ), 0, sizeof( ServerAddr.sin_zero ) );
if( bind( iServerSock, ( struct sockaddr * )&ServerAddr, sizeof( struct sockaddr ) ) == -1 )
{
printf( "bind調用失敗!\n" );
WSACleanup( );
exit( 0 );
}
if( listen( iServerSock, BACKLOG ) == -1 )
{
printf( "listen調用失敗!\n" );
WSACleanup( );
exit( 0 );
}
while( TRUE )
{
sin_size = sizeof( struct sockaddr_in );
iClientSock = accept( iServerSock, ( struct sockaddr * )&ClientAddr, &sin_size );
if( iClientSock == -1 )
{
printf( "accept調用失敗!\n" );
WSACleanup( );
exit( 0 );
}
printf( "伺服器連接到%s\n", inet_ntoa( ClientAddr.sin_addr ) );
if( send( iClientSock, buf, strlen( buf ), 0 ) == -1 )
{
printf( "send調用失敗!" );
closesocket( iClientSock );
WSACleanup( );
exit( 0 );
}
}
}
/////客戶端程序
#include< stdio.h >
#include< stdlib.h >
#include< windows.h >
#include< winsock.h >
#include< string.h >
#pragma comment( lib, "ws2_32.lib" )
#define PORT 2046
#define BACKLOG 10
#define TRUE 1
#define MAXDATASIZE 100
void main( void )
{
int iClientSock;
char buf[ MAXDATASIZE ];
struct sockaddr_in ServerAddr;
int numbytes;
// struct hostent *he;
WSADATA WSAData;
// int sin_size;
/* if( ( he = gethostbyname( "liuys" ) ) == NULL )
{
printf( "gethostbyname調用失敗!" );
WSACleanup( );
exit( 0 );
}
*/
if( WSAStartup( MAKEWORD( 1, 1 ), &WSAData ) )//初始化
{
printf( "initializationing error!\n" );
WSACleanup( );
exit( 0 );
}
if( ( iClientSock = socket( AF_INET, SOCK_STREAM, 0 ) ) == INVALID_SOCKET )
{
printf( "創建套接字失敗!\n" );
WSACleanup( );
exit( 0 );
}
ServerAddr.sin_family = AF_INET;
ServerAddr.sin_port = htons( PORT );
// ServerAddr.sin_addr = *( ( struct in_addr * )he->h_addr );
ServerAddr.sin_addr.s_addr = inet_addr( "192.168.2.194" );//記得換IP
memset( &( ServerAddr.sin_zero ), 0, sizeof( ServerAddr.sin_zero ) );
if( connect( iClientSock, ( struct sockaddr * ) & ServerAddr, sizeof( struct sockaddr ) ) == -1 )
{
printf( "connect失敗!" );
WSACleanup( );
exit( 0 );
}
numbytes = recv( iClientSock, buf, MAXDATASIZE, 0 );
if( numbytes == -1 )
{
printf( "recv失敗!" );
WSACleanup( );
exit( 0 );
}
buf[ numbytes ] = '\0';
printf( "Received: %s", buf );
closesocket( iClientSock );
WSACleanup( );
}
/////UDP
//伺服器
#include< stdio.h >
#include< string.h >
#include< winsock.h >
#include< windows.h >
#pragma comment( lib, "ws2_32.lib" )
#define PORT 2046
#define BACKLOG 10
#define TRUE 1
#define MAXDATASIZE 1000
void main( void )
{
int iServerSock;
// int iClientSock;
int addr_len;
int numbytes;
char buf[ MAXDATASIZE ];
struct sockaddr_in ServerAddr;
struct sockaddr_in ClientAddr;
WSADATA WSAData;
if( WSAStartup( MAKEWORD( 1, 1 ), &WSAData ) )
{
printf( "initializationing error!\n" );
WSACleanup( );
exit( 0 );
}
iServerSock = socket( AF_INET, SOCK_DGRAM, 0 );
if( iServerSock == INVALID_SOCKET )
{
printf( "創建套接字失敗!\n" );
WSACleanup( );
exit( 0 );
}
ServerAddr.sin_family = AF_INET;
ServerAddr.sin_port = htons( PORT );//監視的埠號
ServerAddr.sin_addr.s_addr = INADDR_ANY;//本地IP
memset( & ( ServerAddr.sin_zero ), 0, sizeof( ServerAddr.sin_zero ) );
if( bind( iServerSock, ( struct sockaddr * )&ServerAddr, sizeof( struct sockaddr ) ) == -1 )
{
printf( "bind調用失敗!\n" );
WSACleanup( );
exit( 0 );
}
addr_len = sizeof( struct sockaddr );
numbytes = recvfrom( iServerSock, buf, MAXDATASIZE, 0, ( struct sockaddr * ) & ClientAddr, &addr_len );
if( numbytes == -1 )
{
printf( "recvfrom調用失敗!\n" );
WSACleanup( );
exit( 0 );
}
printf( "got packet from %s\n", inet_ntoa( ClientAddr.sin_addr ) );
printf( "packet is %d bytes long\n", numbytes );
buf[ numbytes ] = '\0';
printf( "packet contains \"%s\"\n", buf );
closesocket( iServerSock );
WSACleanup( );
}
//客戶端
#include< stdio.h >
#include< stdlib.h >
#include< windows.h >
#include< winsock.h >
#include< string.h >
#pragma comment( lib, "ws2_32.lib" )
#define PORT 2046
#define MAXDATASIZE 100
void main( void )
{
int iClientSock;
struct sockaddr_in ServerAddr;
int numbytes;
char buf[ MAXDATASIZE ] = { 0 };
WSADATA WSAData;
if( WSAStartup( MAKEWORD( 1, 1 ), &WSAData ) )
{
printf( "initializationing error!\n" );
WSACleanup( );
exit( 0 );
}
if( ( iClientSock = socket( AF_INET, SOCK_DGRAM, 0 ) ) == -1 )
{
printf( "創建套接字失敗!\n" );
WSACleanup( );
exit( 0 );
}
ServerAddr.sin_family = AF_INET;
ServerAddr.sin_port = htons( PORT );
ServerAddr.sin_addr.s_addr = inet_addr( "192.168.2.194" );//記得換IP
memset( &( ServerAddr.sin_zero ), 0, sizeof( ServerAddr.sin_zero ) );
numbytes = sendto( iClientSock, buf, strlen( buf ), 0, ( struct sockaddr * ) & ServerAddr, sizeof( struct sockaddr ) );
if( numbytes == -1 )
{
printf( "sendto調用失敗!\n" );
WSACleanup( );
exit( 0 );
}
printf( "sent %d bytes to %s\n", numbytes, inet_ntoa( ServerAddr.sin_addr ) );
closesocket( iClientSock );
WSACleanup( );
}
D. linux下socket 網路編程(客戶端向伺服器端發送文件) 求源代碼 大哥大姐幫幫忙 。。謝謝
server:
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <syslog.h>
#include <sys/time.h>
#include <string.h>
#include <fcntl.h>
#include <sys/wait.h>
#define MAXDATASIZE 1024
#define SERVPORT 19999
#define BACKLOG 10
int SendFileToServ(const char *path, const char *FileName, const char *ip)
{
#define PORT 20002
int sockfd;
int recvbytes;
char buf[MAXDATASIZE];
char send_str[MAXDATASIZE];
char filepath[128] = {0};
struct sockaddr_in serv_addr;
FILE *fp;
sprintf(filepath, "%s%s", path, FileName);
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("socket");
return 1;
}
bzero(&serv_addr,sizeof(struct sockaddr_in));
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(PORT);
inet_aton(ip, &serv_addr.sin_addr);
int IErrCount = 0;
again:
if(connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(struct sockaddr))==-1)
{
if (5 == IErrCount)
return 1;
IErrCount++;
perror("connect");
sleep(2);
goto again;
}
//if ((fp = fopen(FileName, "rb")) == NULL)
if ((fp = fopen(filepath, "rb")) == NULL)
{
perror("fopen ");
return 1;
}
recvbytes = write(sockfd, FileName, strlen(FileName));
recvbytes = read(sockfd, buf, MAXDATASIZE);
if (!memcmp(buf, "sendmsg", 7))
{
while(fgets(send_str, MAXDATASIZE, fp))
{
recvbytes = write(sockfd, send_str, strlen(send_str));
recvbytes = read(sockfd, buf, MAXDATASIZE);
if (recvbytes <= 0)
{
fclose(fp);
close(sockfd);
return 1;
}
if (memcmp(buf, "goon", 4))
{
fclose(fp);
close(sockfd);
return 1;
}
}
recvbytes = write(sockfd, "end", 3);
}
else
{
fclose(fp);
close(sockfd);
return 1;
}
memset(buf, 0, MAXDATASIZE);
if (read(sockfd, buf, MAXDATASIZE) <= 0)
{
close(sockfd);
return 2;
}
char *Eptr = "nginx reload error";
//printf("bf[%s]\n", buf);
int ret;
ret = strncmp(buf, Eptr, strlen(Eptr));
//printf("%d\n", ret);
if (!ret)
{
close(sockfd);
return 2;
}
close(sockfd);
return 0;
}
int mysyslog(const char * msg)
{
FILE *fp;
if ((fp = fopen("/tmp/tmp.log", "a+")) == NULL)
{
return 0;
}
fprintf(fp, "[%s]\n", msg);
fclose(fp);
return 0;
}
static void quit_handler(int signal)
{
kill(0, SIGUSR2);
syslog( LOG_NOTICE, "apuserv quit...");
// do something exit thing ,such as close socket ,close mysql,free list
// .....
//i end
exit(0);
}
static int re_conf = 0;
static void reconf_handler(int signal)
{
re_conf=1;
syslog(LOG_NOTICE,"apuserv reload configure file .");
// 請在循環體中判斷，如果re_conf == 1，請再次載入配置文件。
}
static int isrunning(void)
{
int fd;
int ret;
struct flock lock;
lock.l_type = F_WRLCK;
lock.l_whence = 0;
lock.l_start = 0;
lock.l_len = 0;
const char *lckfile = "/tmp/apuserv.lock";
fd = open(lckfile,O_WRONLY|O_CREAT);
if (fd < 0) {
syslog(LOG_ERR,"can not create lock file: %s\n",lckfile);
return 1;
}
if ((ret = fcntl(fd,F_SETLK,&lock)) < 0) {
ret = fcntl(fd,F_GETLK,&lock);
if (lock.l_type != F_UNLCK) {
close(fd);
return lock.l_pid;
}
else {
fcntl(fd,F_SETLK,&lock);
}
}
return 0;
}
int MyHandleBuff(const char *buf, char *str, char *FileName, char *pth)
{
sscanf(buf, "%s %s %s", pth, FileName, str);
printf("path=%s\nfilename=%s\nip=%s\n", pth, FileName, str);
return 0;
}
int main(int argc, char **argv)
{
int sockfd,client_fd;
socklen_t sin_size;
struct sockaddr_in my_addr,remote_addr;
char buff[MAXDATASIZE];
int recvbytes;
#if 1
int pid ;
char ch ;
int ret;
int debug = 0;
signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGTERM, quit_handler);
syslog(LOG_NOTICE,"apuserver start....");
while ((ch = getopt(argc, argv, "dhV")) != -1) {
switch (ch) {
case 'd':
debug = 1;
break;
case 'V':
printf("Version:%s\n","1.0.0");
return 0;
case 'h':
printf(" -d use daemon mode\n");
printf(" -V show version\n");
return 0;
default:
printf(" -d use daemon mode\n");
printf(" -V show version\n");
}
}
if (debug && daemon(0,0 ) ) {
return -1;
}
if (isrunning()) {
fprintf(stderr, "apuserv is already running\n");
syslog(LOG_INFO,"apuserv is already running\n");
exit(0);
}
while (1) {
pid = fork();
if (pid < 0)
return -1;
if (pid == 0)
break;
while ((ret = waitpid(pid, NULL, 0)) != pid) {
syslog(LOG_NOTICE, "waitpid want %d, but got %d", pid, ret);
if (ret < 0)
syslog(LOG_NOTICE, "waitpid errno:%d", errno);
}
kill(0, SIGUSR2);
sleep(1);
syslog(LOG_NOTICE,"restart apuserver");
}
signal(SIGHUP, reconf_handler);
signal(SIGPIPE, SIG_IGN);
signal(SIGUSR1,SIG_IGN);
signal(SIGUSR2, SIG_DFL);
signal(SIGTERM, SIG_DFL);
#endif
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("socket");
exit(1);
}
bzero(&my_addr,sizeof(struct sockaddr_in));
my_addr.sin_family=AF_INET;
my_addr.sin_port=htons(SERVPORT);
my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind(sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))==-1)
{
perror("bind");
exit(1);
}
if(listen(sockfd,BACKLOG)==-1)
{
perror("listen");
exit(1);
}
int nret;
while(1)
{
sin_size = sizeof(struct sockaddr_in);
if((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size))==-1)
{
perror("falied accept");
continue;
}
memset(buff, 0, MAXDATASIZE);
recvbytes = read(client_fd, buff, MAXDATASIZE);
char str[16] = {0};
char FileName[128] = {0};
char path[128] = {0};
MyHandleBuff(buff, str, FileName, path);
if (recvbytes > 0)
{
nret = SendFileToServ(path, FileName, str);
printf("nret[%d]\n", nret);
if (1 == nret)
write(client_fd, "send file error", 15);
else if(2 == nret)
write(client_fd, "reload nginx error", 18);
else
write(client_fd, "succ", 4);
}
close(client_fd);
}
}
_________________________________________________
client:
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <syslog.h>
#include <sys/time.h>
#include <string.h>
#include <fcntl.h>
#include <sys/wait.h>
#define MAXDATASIZE 1024
#define SERVPORT 20002
#define BACKLOG 10
int mysyslog(const char * msg)
{
FILE *fp;
if ((fp = fopen("/tmp/tmp.log", "a+")) == NULL)
{
return 0;
}
fprintf(fp, "[%s]\n", msg);
fclose(fp);
return 0;
}
static void quit_handler(int signal)
{
kill(0, SIGUSR2);
syslog( LOG_NOTICE, "apuserv quit...");
// do something exit thing ,such as close socket ,close mysql,free list
// .....
//i end
exit(0);
}
static int re_conf = 0;
static void reconf_handler(int signal)
{
re_conf=1;
syslog(LOG_NOTICE,"apuserv reload configure file .");
// ????·???????1nf == 1￡???′μ?????
static int isrunning(void)
{
int fd;
int ret;
struct flock lock;
lock.l_type = F_WRLCK;
lock.l_whence = 0;
lock.l_start = 0;
lock.l_len = 0;
const char *lckfile = "/tmp/dstserver.lock";
fd = open(lckfile,O_WRONLY|O_CREAT);
if (fd < 0) {
syslog(LOG_ERR,"can not create lock file: %s\n",lckfile);
return 1;
}
if ((ret = fcntl(fd,F_SETLK,&lock)) < 0) {
ret = fcntl(fd,F_GETLK,&lock);
if (lock.l_type != F_UNLCK) {
close(fd);
return lock.l_pid;
}
else {
fcntl(fd,F_SETLK,&lock);
}
}
return 0;
}
int main(int argc, char **argv)
{
int sockfd,client_fd;
socklen_t sin_size;
struct sockaddr_in my_addr,remote_addr;
char buff[MAXDATASIZE];
int recvbytes;
#if 1
int pid ;
char ch ;
int ret;
int debug = 0;
signal(SIGUSR1, SIG_IGN);
signal(SIGUSR2, SIG_IGN);
signal(SIGHUP, SIG_IGN);
signal(SIGTERM, quit_handler);
syslog(LOG_NOTICE,"dstserver start....");
while ((ch = getopt(argc, argv, "dhV")) != -1) {
switch (ch) {
case 'd':
debug = 1;
break;
case 'V':
printf("Version:%s\n","1.0.0");
return 0;
case 'h':
printf(" -d use daemon mode\n");
printf(" -V show version\n");
return 0;
default:
printf(" -d use daemon mode\n");
printf(" -V show version\n");
}
}
if (debug && daemon(0,0 ) ) {
return -1;
}
if (isrunning()) {
fprintf(stderr, "dstserver is already running\n");
syslog(LOG_INFO,"dstserver is already running\n");
exit(0);
}
while (1) {
pid = fork();
if (pid < 0)
return -1;
if (pid == 0)
break;
while ((ret = waitpid(pid, NULL, 0)) != pid) {
syslog(LOG_NOTICE, "waitpid want %d, but got %d", pid, ret);
if (ret < 0)
syslog(LOG_NOTICE, "waitpid errno:%d", errno);
}
kill(0, SIGUSR2);
sleep(1);
syslog(LOG_NOTICE,"restart apuserver");
}
signal(SIGHUP, reconf_handler);
signal(SIGPIPE, SIG_IGN);
signal(SIGUSR1,SIG_IGN);
signal(SIGUSR2, SIG_DFL);
signal(SIGTERM, SIG_DFL);
#endif
if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1)
{
perror("socket");
exit(1);
}
bzero(&my_addr,sizeof(struct sockaddr_in));
my_addr.sin_family=AF_INET;
my_addr.sin_port=htons(SERVPORT);
my_addr.sin_addr.s_addr = htonl(INADDR_ANY);
if(bind(sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))==-1)
{
perror("bind");
exit(1);
}
if(listen(sockfd,BACKLOG)==-1)
{
perror("listen");
exit(1);
}
char filepath[MAXDATASIZE]= {0};
FILE *fp;
while(1)
{
sin_size = sizeof(struct sockaddr_in);
if((client_fd = accept(sockfd, (struct sockaddr *)&remote_addr, &sin_size))==-1)
{
perror("falied accept");
continue;
}
memset(buff, 0, MAXDATASIZE);
recvbytes = read(client_fd, buff, MAXDATASIZE);
sprintf(filepath, "/etc/nginx/url_rule/%s", buff);
if ((fp = fopen(filepath, "wb")) == NULL)
{
perror("fopen");
close(client_fd);
continue;
}
write(client_fd, "sendmsg", 7);
while(read(client_fd, buff, MAXDATASIZE))
{
if (!memcmp(buff, "end", 3))
{
fclose(fp);
break;
}
else
{
fprintf(fp, "%s", buff);
write(client_fd, "goon", 4);
}
}
//system("nginx -s reload");
char *Sptr = "nginx reload succ";
char *Eptr = "nginx reload error";
int ret;
ret = system("nginx -s reload");
printf("ret[%d]\n", ret);
if (ret != 0)
{
write(client_fd, Eptr, strlen(Eptr));
}
else
{
write(client_fd, Sptr, strlen(Sptr));
}
close(client_fd);
}
}
以前寫的：內容忘記了。不是很復雜你可以自己看！
E. 請比較Linux與Windows在網路編程方面的特點
找了一段，大致涉及到了您的問題：
一、socket的模式
socket一般有兩種模式：同步和非同步（windows網路編程技術中也可叫鎖定和非鎖定，Linux網路編程叫阻塞和非阻塞）。
二、socket的類型
socket一般有三種類型，基於TCP的流式套接字，基於UDP的數據報套接字和原始套接字。
三、socket的IO模型
socket
的IO模型是編程中使用socket兩種模式的策略，它們適用的場合不同，在不同的操作系統上支持的模型也不同，例如windows從NT版本才開始支持
完成埠模型。Linux和Windows所支持的模型也有區別，當然也有相同的地方，可能叫法不一樣，但大致思路是一樣的，下面分別介紹windows
和Linux的IO模型
1、 Windows下的套接字IO模型：
A、 Select(選擇)模型
用於同步socket的狀態檢測模型，又叫（Linux）多路復用，可以同時檢測多個socket的狀態
B、 WSAAsyncSelect（非同步選擇）模型
用於非同步socket的非同步事件設置，它是基於Windows消息的模型，必須先打開一個窗口，然後把窗口和socket的消息綁定，這樣，在socket有消息通知時，操作系統便通知窗口，然後在窗口進行處理。
C、 WSAEventSelect(非同步事件)模型
用
於非同步socket的非同步事件，它是基於網路事件的模型，先使用CreateEvent創建一個事件，然後使用WSAEventSelect進行事件綁
定，然後可以使用WaitForMultipleObject（Event）進行事件監聽，可以同時監聽多個事件，不光是socket的，比如可以監聽使
用CreateWaitableTimer創建的Timer等。
D、 重疊IO模型
用
於非同步socket,在創建socket時需要在創建函數WSASocket中使用WSA_FLAG_OVERLAPPED標志，然後在投遞IO請求的時
候將一個Overlapped結構體指針賦給投遞函數，可以使用WSAWaitForMultipleObject來監聽事件，然後使用
WSAGetOverlappedResult來獲取IO的狀態，也可以在Overlapped結構體中使用完成常式來處理，即在投遞函數中把完成常式賦
給投遞函數。
E、 完成埠模型
它
是迄今為止最復雜的一種IO模型，當應用程序需要管理眾多的套接字並且希望隨著系統內安裝的CPU數目的增多，應用程序的性能也可以線性增加，就可以使用
這種模型，它的原理是每個CPU可以單獨負責一個線程的執行，避免線程的頻繁切換。使用這種模型往往可以達到最佳的系統性能。
首
先需要使用CreateIOCompletePort來創建完成埠，然後將IO句柄和此埠綁定，綁定也是使用此函數，當然也可以一次完成。接著是創建
工作者線程，工作者線程會使用GetQueuedCompletionStatus進入完成埠維護的線程池，當有完成事件時，會激活一個線程。
2、 Linux下的IO模型
A、阻塞IO
B、非阻塞IO
C、IO多路復用(選擇)
D、信號驅動
用於非同步socket,首先設定信號處理函數,然後使用fcntl函數設定socket的擁有者，像windows下使用WSAAsncSelect設定socket的窗口一樣。使用這種模型，當內核操作可以被操作的時候通知我們的應用程序
E、非同步IO
當內核在所有操作完成後才會通知應用程序
四、socket的一些使用上的優化
A、緩沖區的優化，可以考慮讓應用程序使用比較小的緩沖區，但同時使用多個WSARecv
B、使用socket選項SO_SNDBUF和SO_RCVBUF設置socket緩沖區大小，如果設為0，操作體系統會使用應用程序的緩沖區，這樣避免了從系統緩沖區向用戶區復制的開銷
五、注意這些IO模型有些不光是針對socket的，其他的IO操作也可以使用，最常用使用的是WriteFile,ReadFile等函數。
其它查考網址：
http://blog.163.com/tianle_han/blog/static/6617826200821522743948/
http://blog.csdn.net/yibulianhua/article/details/5374317