Linux TCP Echo Server/Client Example Code

本篇主要在紀錄 TCP/IP 的程式範例。為什麼要紀錄呢？因為年紀大了，很多程式都想撿現成的來改就好了。要用的時候還要找就太麻煩了，所以乾脆找一個自己想要的版本紀錄起來，以後要用就有了。這次的紀錄重點，包含了：
  1. Linux Socket Programming.
  2. Select Usage.
範例程式主要來自下面這本書：

TCP/IP Sockets in C: Practical Guide for Programmers, Second Edition (ISBN: 978-0-12-374540-8) by Kenneth L. Calvert and Michael J. Donahoo

其實我根本沒買書啦，反正網路上有範例程式可以下載，我就直接拿來改囉。

下面就是改寫後的程式碼。改寫的部份主要是風格的問題，以及不想讓 client 傳完一個句子就關閉 socket。

Server:

#include <stdio.h>          // for printf() and fprintf() 
#include <sys/socket.h>     // for socket(), bind(), and connect() 
#include <arpa/inet.h>      // for sockaddr_in and inet_ntoa() 
#include <stdlib.h>         // for atoi() and exit() 
#include <string.h>         // for memset() 
#include <unistd.h>         // for close() 
#include <sys/time.h>       // for struct timeval {} 
#include <fcntl.h>          // for fcntl() 

#define MAXPENDING 5        // Maximum outstanding connection requests
#define MAXCLIENT  100      // Maximum client connections
#define RCVBUFSIZE 1024     // Size of receive buffer 

int     CreateTCPServerSocket( unsigned short );
int     AcceptTCPConnection( int );
int     HandleTCPClient( int );

int main( int argc, char *argv[] )
{
    int             *servSock;        // Socket descriptors for server 
    int             maxDescriptor;    // Maximum socket descriptor value 
    fd_set          sockSet;          // Set of socket descriptors for select() 
    long            timeout;          // Timeout value given on command-line 
    struct timeval  selTimeout;       // Timeout for select() 
    
    int cliSock[MAXCLIENT];           // Client Socket Set
    
    int running = 1;                 // 1 if server should be running; 0 otherwise 
    
    int noPorts;                     // Number of port specified on command-line 
    int port;                        // Looping variable for ports 
    unsigned short portNo;           // Actual port number 
    
    int i;                           // For loop use
    
    // Test for correct number of arguments
    
    if ( argc < 3 )     
    {
        fprintf( stderr, "Usage:  %s <Timeout (secs.)> <Port 1> ...\n", argv[0]);
        exit(1);
    }

    timeout = atol(argv[1]);        // First arg: Timeout 
    noPorts = argc - 2;             // Number of ports is argument count minus 2 

    // Allocate list of sockets for incoming connections 
    servSock = (int *) malloc( noPorts * sizeof(int) );    
  
    // Create list of ports and sockets to handle ports 
    for ( port = 0; port < noPorts; port++ )
    {
        // Add port to port list, skip first two arguments 
        portNo = atoi( argv[port + 2] ); 

        // Create port socket 
        servSock[port] = CreateTCPServerSocket( portNo );        
    }
    
    // Initialize the client socket pool
    for( i = 0 ; i < MAXCLIENT ; i++ )
    {
        cliSock[i] = -1;
    }

    printf( "Starting server:  Hit return to shutdown\n" );
    while ( running )
    {
        // Zero socket descriptor vector and set for server sockets 
        // This must be reset every time select() is called 
        FD_ZERO( &sockSet );
        
        // Add keyboard to descriptor vector 
        FD_SET( STDIN_FILENO, &sockSet );
        
        // Initialize maxDescriptor for use by select() 
        maxDescriptor = -1;
        
        // Add server sockets to descriptor vector 
        for ( port = 0; port < noPorts; port++ )
        {
            FD_SET( servSock[port], &sockSet );
            
            // Determine if new descriptor is the largest 
            if ( servSock[port] > maxDescriptor ) 
            {
                maxDescriptor = servSock[port];
            }
        }
        
        // Add client sockets to descriptor vector 
        for ( i = 0; i < MAXCLIENT; i++ )
        {
            if ( cliSock[i] > 0 ) 
            {
                FD_SET( cliSock[i], &sockSet );
            }
            
            if ( cliSock[i] > maxDescriptor ) 
            {
                maxDescriptor = cliSock[i];
            }
        }
        
        // Timeout specification 
        // This must be reset every time select() is called 
        selTimeout.tv_sec = timeout;       // timeout (secs.) 
        selTimeout.tv_usec = 0;            // 0 microseconds 

        // Suspend program until descriptor is ready or timeout 
        if ( select( maxDescriptor + 1, &sockSet, NULL, NULL, &selTimeout ) == 0 )
        {
            printf("No echo requests for %ld secs...Server still alive\n", timeout);
        }
        else 
        {
            // Check keyboard 
            if (FD_ISSET(0, &sockSet)) 
            {
                printf("Shutting down server\n");
                getchar();
                running = 0;
                continue;
            }
            
            // Check Listening Sockets
            for ( port = 0; port < noPorts; port++ )
            {
                if (FD_ISSET( servSock[port], &sockSet ) )
                {
                    printf("Request on port %d:  ", port);
                    for( i = 0 ; i < MAXCLIENT ; i++ )
                    {
                        if( cliSock[i] < 0 ) 
                        {
                            cliSock[i] = AcceptTCPConnection( servSock[port] );
                            i = MAXCLIENT;
                        }
                    }
                }
            }
            
            // Check Client Sockets
            for ( i = 0 ; i < MAXCLIENT ; i++ )
            {
                if ( FD_ISSET( cliSock[i], &sockSet ) )
                {
                    if( HandleTCPClient( cliSock[i] ) == 0 )
                    {
                        printf( "Connection %d Shudown.\n", cliSock[i] );
                        close( cliSock[i] );
                        cliSock[i] = -1;
                    }
                }
            }
        }
    }

    // Close sockets 
    for ( port = 0; port < noPorts; port++ )
    {
        close( servSock[port] );
    }
    
    for ( i = 0; i < MAXCLIENT; i++ )
    {
        if( cliSock[i] > 0 )
        {
            close( cliSock[i] );
        }
    }
    
    // Free list of sockets 
    free( servSock );

    return 0;
}

int CreateTCPServerSocket(unsigned short port)
{
    int sock;                        // socket to create 
    struct sockaddr_in echoServAddr; // Local address 

    // Create socket for incoming connections 
    if ( ( sock = socket( PF_INET, SOCK_STREAM, IPPROTO_TCP ) ) < 0 )
    {
        perror( "socket() failed" );
        exit(1);
    }
      
    // Construct local address structure 
    memset( &echoServAddr, 0, sizeof( echoServAddr ) );     // Zero out structure 
    echoServAddr.sin_family = AF_INET;                      // Internet address family 
    echoServAddr.sin_addr.s_addr = htonl( INADDR_ANY );     // Any incoming interface 
    echoServAddr.sin_port = htons( port );                  // Local port 

    // Bind to the local address 
    if ( bind(sock, (struct sockaddr *) &echoServAddr, sizeof( echoServAddr ) ) < 0 )
    {
        perror( "bind() failed" );
        exit(1);
    }
    
    // Mark the socket so it will listen for incoming connections 
    if ( listen( sock, MAXPENDING ) < 0 )
    {
        perror( "listen() failed" );
        exit(1);
    }
    
    return sock;
}

int AcceptTCPConnection( int servSock )
{
    int                 clntSock;     // Socket descriptor for client 
    struct sockaddr_in  echoClntAddr; // Client address 
    unsigned int        clntLen;      // Length of client address data structure 

    // Set the size of the in-out parameter 
    clntLen = sizeof( echoClntAddr );
    
    // Wait for a client to connect 
    if ( ( clntSock = accept( servSock, (struct sockaddr *) &echoClntAddr, &clntLen ) ) < 0 )
    {
        perror("accept() failed");
        exit(1);
    }
    
    // clntSock is connected to a client! 
    
    printf("Handling client %s(%d)\n", inet_ntoa( echoClntAddr.sin_addr ), clntSock );

    return clntSock;
}

int HandleTCPClient( int clntSocket )
{
    char    echoBuffer[RCVBUFSIZE];        // Buffer for echo string 
    int     recvMsgSize;                   // Size of received message 
    
    bzero( echoBuffer, RCVBUFSIZE );
    // Receive message from client 
    if ( ( recvMsgSize = recv( clntSocket, echoBuffer, RCVBUFSIZE, 0 ) ) < 0 )
    {
        perror("recv() failed");
        exit(1);
    }

    // Send received string and receive again until end of transmission 
    if ( recvMsgSize > 0 )      // zero indicates end of transmission 
    {
        // Echo message back to client 
        if ( send( clntSocket, echoBuffer, recvMsgSize, 0) != recvMsgSize )
        {
            perror( "send() failed" );
            exit(1);
        }
    }
    
    return recvMsgSize;
}


Client:

#include <stdio.h>      // for printf() and fprintf() 
#include <sys/socket.h> // for socket(), connect(), send(), and recv() 
#include <arpa/inet.h>  // for sockaddr_in and inet_addr() 
#include <stdlib.h>     // for atoi() and exit() 
#include <string.h>     // for memset() 
#include <unistd.h>     // for close() 

#define STRBUFSIZE 1024 // Size of receive buffer 

void DieWithError(char *errorMessage);  // Error handling function 

int main(int argc, char *argv[])
{
    int sock;                        // Socket descriptor 
    struct sockaddr_in echoServAddr; // Echo server address 
    unsigned short echoServPort;     // Echo server port 
    char *servIP;                    // Server IP address (dotted quad)
    char echoString[STRBUFSIZE];     // Buffer for echo string  
    char echoBuffer[STRBUFSIZE];     // Buffer for echo string 
    unsigned int echoStringLen;      // Length of string to echo 
    int bytesRcvd, totalBytesRcvd;   // Bytes read in single recv() and total bytes read 
    int running = 1;                 // Check the loop state

    if ( ( argc < 2 ) || (argc > 3 ) )    // Test for correct number of arguments 
    {
       fprintf( stderr, "Usage: %s <Server IP> [<Echo Port>]\n", argv[0] );
       exit(1);
    }

    servIP = argv[1];             // First arg: server IP address (dotted quad) 

    if ( argc == 3 )
    {
        // Use given port, if any 
        echoServPort = atoi(argv[2]); 
    }
    else
    {
        // 7 is the well-known port for the echo service
        echoServPort = 7;  
    } 

    // Create a reliable, stream socket using TCP 
    if ( ( sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP ) ) < 0 )
    {
        perror("socket() failed");
        exit(1);
    }
    
    // Construct the server address structure 
    memset(&echoServAddr, 0, sizeof(echoServAddr));     // Zero out structure 
    echoServAddr.sin_family      = AF_INET;             // Internet address family 
    echoServAddr.sin_addr.s_addr = inet_addr(servIP);   // Server IP address 
    echoServAddr.sin_port        = htons(echoServPort); // Server port 

    // Establish the connection to the echo server 
    if ( connect( sock, (struct sockaddr *) &echoServAddr, sizeof( echoServAddr ) ) < 0 )
    {
        perror( "connect() failed" );
        exit(1);
    }
    
    while ( running )
    {
        bzero( echoString, STRBUFSIZE );
        bzero( echoBuffer, STRBUFSIZE );
        
        printf("Enter(q for exit): \n"); 
        
        fgets( echoString, STRBUFSIZE, stdin ); 
        
        echoStringLen = strlen( echoString );
        
        if ( echoStringLen == 2 && echoString[0] == 'q' && echoString[1] == '\n' )
        {
            running = 0;
            continue;
        }
        
        if ( send(sock, echoString, echoStringLen, 0) != echoStringLen )
        {
            perror( "send() sent a different number of bytes than expected");
            exit(1);
        }
        
        printf("Received"); 
        
        if ( ( bytesRcvd = recv( sock, echoBuffer, STRBUFSIZE - 1, 0) ) <= 0 )
        {
            perror("recv() failed or connection closed prematurely");
            exit(1);
        }
        printf( "(%d): ", bytesRcvd );
        printf( "%s", echoBuffer);      // Print the echo buffer 
        
    }
    
    printf("\n");    // Print a final linefeed 

    close(sock);
    return 0;
}

留言

張貼留言

這個網誌中的熱門文章

如何將Linux打造成OpenFlow Switch：Openvswitch

圖片
因為工作上被指派去做SDN，自然需要SDN的網路設備才可以。問題是SDN Switch賣的超級貴的，一台差不多要30萬台幣。這跟當初推廣SDN的人說法完全不一樣！他們當初說SDN網路設備會變得比較便宜，因為網路設備上不需要在堆疊這麼多的網路協定，因此硬體可以Cost Down，也可以省下軟體的錢。問題是，如果單單賣純種SDN Switch根本是不可能的事情啊，因為缺少可以在上面跑的軟體和控制器，所以只好保留傳統設備上的功能，再多加OpenFlow的支援，並提供給使用者選擇的開關。這樣當然只會更貴不會便宜啊！！ 在沒錢、沒人、沒資源的情況下，要怎麼辦呢？用模擬軟體？可惜要Demo的時候行不通。那就只好自己來打造一台SDN Switch了。雖然沒有晶片的支援，但只要不牽扯到效能的話，應該沒太多問題。下面是我和同事想過的一些解決方案： 自己打造OpenFlow的Agent，反正OpenFlow的網路協定並不複雜，然後透過Linux Kernel的netfilter來模擬晶片的行為。因為是用軟體模擬，所以效率會比較差，但反過來說，因為是軟體，所以我可以滿足所有OpenFlow的要求，不會有做不到的事情。不過這個提案被一個PM的同事封殺了，理由是這不能賣錢 ...  有一個同事找到一個有趣的專案 FlowForwarding 。這個專案提供了Open Source的OpenFlow Agent: LINC。LINC是用Erlang所開發的軟體。雖然我根本不會Erlang，但程式語言不是我考慮的重點，我好奇的是它要怎麼模擬晶片來處理封包。從網頁上看到，LINC在使用上需要libpcap的函式庫，初步猜測，LINC應該是把所有的封包透過libpcap攔截到user space以後進行修改。這樣做的效率應該會比我的解決方案更差。 OpenVswitch 。這是大部份產品的解決方案。我聽過一堆公司宣稱自己有了SDN Switch，而內容只不過是把Openvswitch移植到自己原有的產品上罷了。一樣，我好奇它要怎麼模擬晶片來處理封包，看了編譯過程，它會產生openvswitch.ko，在加上它利用bridge的特性，所以應該是在linux bridge那邊進行hook後修改。 考量到移植的方便性，所以後來我個人選擇openvswitch作為SDN Switch...
閱讀完整內容

我弟家的新居感恩禮拜分享：善頌善禱

語本禮記·檀弓下：「晉獻文子成室，晉大夫發焉。張老曰：『美哉輪焉！美哉奐焉！歌於斯，哭於斯，聚國族於斯。』文子曰：『武也，得歌於斯，哭於斯，聚國族於斯，是全要領以從先大夫於九京也。』北面再拜稽首。君子謂之：『善頌善禱』。」 不知為什麼，我一直對禮記中的這一篇印象深刻，大概是小時候記憶力比較好，所以一直刻劃在心中吧。之前有天我弟要我把時間留下來，要參加他們家的家庭禮拜，結果到了以後才發現原來是新居感恩禮拜（我說，你們小倆口根本已經搬進去很久了吧），然後居然還要說些祝福的話（喂喂，下次這種事要先講，我本來抱定只聽只吃不說話的態度啊），在想要講什麼的時候，第一個浮出的念頭就是「善頌善禱」的這個故事 ... ㄜ ... 不是聖經經文啊，所以就想找找，在聖經中哪一段有「新居落成」的相關經節，可以作為分享，結果就是以下面這段文章來做分享： 王上9：1-10 所羅門建造耶和華殿和王宮，並一切所願意建造的都完畢了，耶和華就二次向所羅門顯現，如先前在基遍向他顯現一樣，對他說：「你向我所禱告祈求的，我都應允了。我已將你所建的這殿分別為聖，使我的名永遠在其中；我的眼、我的心也必常在那裡。你若效法你父大衛，存誠實正直的心行在我面前，遵行我一切所吩咐你的，謹守我的律例典章，我就必堅固你的國位在以色列中，直到永遠，正如我應許你父大衛說：你的子孫必不斷人坐以色列的國位。倘若你們和你們的子孫轉去不跟從我，不守我指示你們的誡命律例，去事奉敬拜別神，我就必將以色列人從我賜給他們的地上剪除，並且我為己名所分別為聖的殿也必捨棄不顧，使以色列人在萬民中作笑談，被譏誚。這殿雖然甚高，將來經過的人必驚訝、嗤笑，說：耶和華為何向這地和這殿如此行呢？人必回答說：是因此地的人離棄領他們列祖出埃及地之耶和華─他們的神，去親近別神，事奉敬拜他，所以耶和華使這一切災禍臨到他們。」所羅門建造耶和華殿和王宮，這兩所二十年才完畢了。 在列王記上的記載裏面，所羅門花了二十年的時間完成了聖殿和皇宮的建造，而現在上帝來參加這個「新居感恩禮拜」。上帝說：「 我已將你所建的這殿分別為聖，使我的名永遠在其中；我的眼、我的心也必常在那裡。 」感謝上帝，這是上帝同在的保證，這是基督徒最喜歡傳講平安的福音：「以馬內利，上帝與我們同在」，以上帝給的祝福來說，沒有比這更大的。可是等等，接下來的話是新居落成時所該給的祝福嗎？一開始還好，可...
閱讀完整內容

Linux Virtual Interface: TUN/TAP

圖片
今天要介紹的，不是什麼新技術，只是之前沒碰過，而現在工作有用到，所以做個私人紀錄。 問題描述以及過去的解決方案 工作上面遇到的問題，如何建立一張虛擬的網路介面，並且讓封包經過該介面後額外封裝一個新的 Header。建立虛擬網路介面不難，但要如何去撈封包（使封包經過該介面）呢？並且之後封包的處理又是如何？之前在公司曾經用過幾種招數： 第一個作法是透過 Bridge 來將網卡綁在一起，然後去修改 Bridge 的程式碼做自己想做的事情。第二個作法是透過 Netfilter 來攔截封包，做完事情以後再硬導到正確的網卡。這兩個作法很 亂來 ，我的亂來指的是不理會 Linux 內部封包處理流程，隨意的處理並安插封包，但我可沒說這樣做不到啊。第3種方法很好，完全符合 Linux 核心的封包處理程序，代表的例子就是 GRE，問題是現在的封裝技術亂七八糟（這個詞純粹是為了抱怨用），並不一定是單純的 IP-in-IP ，所以這個架構不一定適用。正當決定來亂搞的時候，有人提供了一個新的方向（應該是說自己孤陋寡聞）：TUN/TAP。 TUN/TAP: Virtual Network Kernel Device 我們先抄一下 Wiki 上的說明： In computer networking, TUN and TAP are virtual-network kernel devices . Being network devices supported entirely in software, they differ from ordinary network devices which are backed up by hardware network adapters. TUN (namely network TUNnel) simulates a network layer device and it operates with layer 3 packets like IP packets . TAP (namely network tap) simulates a link layer device and it operates with layer 2 packets like Ethernet frames . TUN is used...
閱讀完整內容