实现最简单的网络服务器［作业］

要求：

1.客户端与服务端可以通过TCP通信；

2.处理常见的信号（SIGINT, SIGQUIT, SIGHUP, SIGPIPE, SIGCHLD）；

3.服务器在后台运行；

4.使用C++实现；

/**
  defs.h
*/
#ifndef _DEFS_H_
#define _DEFS_H_

#include <signal.h>
#include <assert.h>
#include <iostream>

#define PORT 8111
#define MSG_LEN 1024

typedef enum NETWORK_TYPE
{
    NETWORK_TCP = 0,
    NETWORK_UDP = 1
} NETWORK_TYPE;

#endif    // _DEFS_H_

 

/**
  server.h
*/
#ifndef _CSERVER_H_
#define _CSERVER_H_

#include "defs.h"

namespace webrtc {

class CServer
{
public:
    CServer(int port, NETWORK_TYPE type);
    ~CServer();

public:
    void registerSignals(int sig, void(*handle)(int));
    void run();

private:
    class CInternal;
    CInternal*    m_internal;
};

}

#endif    // _CSERVER_H_

/**
  internal.h
*/
#ifndef _INTERNAL_H_
#define _INTERNAL_H_

#include "server.h"
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

namespace webrtc
{

class CServer::CInternal
{
public:
    CInternal(int port, NETWORK_TYPE type);
    ~CInternal();
    
public:
    void registerSignals(int sig, void(*handle)(int));
    bool start();
    void run();

private:
    int m_port;
    NETWORK_TYPE m_type;
    int m_socket_fd;
    char *m_buff;
    struct sockaddr_in m_local_addr;
};

}    // end webrtc

#endif    // _INTERNAL_H_

/**
  server.cpp
*/
#include "internal.h"
#include <signal.h>

namespace webrtc 
{

CServer::CInternal::CInternal(int port, NETWORK_TYPE type)
    : m_port(port)
    , m_type(type)
    , m_socket_fd(-1)
    , m_buff(NULL)
{
    m_buff = new char[MSG_LEN];
}

CServer::CInternal::~CInternal()
{
    if (m_buff != NULL) {
        delete[] m_buff;
        m_buff = NULL;
    }

    if (m_socket_fd > 0) {
        close(m_socket_fd);
        m_socket_fd = -1;
    }
}

bool CServer::CInternal::start()
{
    m_socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (socket_fd == -1) {
        printf("can't create socket fd\n");
        return false;
    }

    int on = 1;
    int ret = setsockopt(m_socket_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
    if (ret == -1) {
        printf("faild to set socket option\n");
    }

    bzero(&m_local_addr, sizeof(m_local_addr));
    m_local_addr.sin_family = AF_INET;
    m_local_addr.sin_port = htons(m_port);
    m_local_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    socklen_t addr_len = sizeof(struct sockaddr_in);
    ret = bind(m_socket_fd, (struct sockaddr *)&m_local_addr, addr_len);
    if (ret == -1) {
        printf("failed to bind addr\n");
        return false;
    }

    int backlog = 10;
    ret = listen(m_socket_fd, backlog);
    if (ret == -1) {
        printf("failed listen\n");
        return false;
    }
    printf("listening on port[%d]\n", m_port);

    return true;
}

void CServer::CInternal::registerSignals(int sig, void(*handle)(int))
{
    std::cout << "register sig:" << sig << std::endl;
    signal(sig, handle);
}

void CServer::CInternal::run()
{
    if (!start()) {
        printf("start server failed, port[%d].\n", m_po);
        return;
    }

    std::cout << "run..." << std::endl;
    int ret = -1;
    int accept_fd;
    struct sockaddr_in remote_addr;
    bzero(&remote_addr, sizeof(remote_addr));
    socklen_t addr_len = sizeof(struct sockaddr_in);
    while (true) {
        accept_fd = accept(m_socket_fd, (struct sockaddr *)&remoteaddr, &addr_len);
        if (accept_fd <= 0) 
            continue;

        while (true) {
            memset(m_buff, 0, sizeof(m_buff));
            ret = recv(accept_fd, (void *)in_buff, MESSAGE_LEN, 0);
            if (ret == 0) 
                break;

            printf("recv:%s\n", in_buff);
            send(accept_fd, (void *)in_buff, MESSAGE_LEN, 0);
        } // end while

        close(accept_fd);
    } //end while
}

CServer::CServer(int port, NETWORK_TYPE type)
    : m_internal(NULL)
{
    m_internal = new CInternal(port, type);
    assert(m_internal != NULL);
}

CServer::~CServer()
{
    delete m_internal;
    m_internal = NULL;
}

void CServer::registerSignals(int sig, void(*handle)(int))
{
    if (m_internal != NULL)
    {
        m_internal->registerSignals(sig, handle);
    }
}

void CServer::run()
{
    if (m_internal != NULL)
    {
        m_internal->run();
    }
}

}    // end webrtc

/**
  tcpserver.cpp
*/
#include <iostream>
#include "server.h"

using namespace webrtc;

void sighandle(int sig) 
{
    std::cout << "sig:" << sig << std::endl;
    if (sig == SIGINT)
    {
        _exit(0);
    }
}

int main(int argc, char* argv[])
{
    CServer* server = new CServer(PORT, NETWORK_TCP);
    server->registerSignals(SIGINT, sighandle);
    server->registerSignals(SIGQUIT, sighandle);
    server->registerSignals(SIGCHLD, sighandle);
    server->registerSignals(SIGPIPE, sighandle);
    server->registerSignals(SIGHUP, sighandle);

    server->run();

    return 0;
}

# g++ -std=c++11 -g -o tcpserver tcpserver.cpp server.cpp
# ./tcpserver

 

/**
  client.h
*/
#ifndef _CCLIENT_H_
#define _CCLIENT_H_

#include "defs.h"
#include <iostream>

namespace webrtc {

class CClient
{
public:
    CClient();
    ~CClient();

public:
    bool connect(const std::string& address, int port);
    void run();

private:
    int m_socket_fd;
};

}

#endif

/**
  client.cpp
*/
#include "client.h"
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

namespace webrtc
{

CClient::CClient()
    : m_socket_fd(-1)
{}

CClient::~CClient()
{}

bool CClient::connect(const std::string& address, int port)
{
    int ret = -1;
    struct sockaddr_in server_addr;
    socklen_t addr_len;

    m_socket_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (m_socket_fd < 0) {
        printf("failed create socket\n");
        return false;
    }

    bzero(&server_addr, sizeof(server_addr));
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(port);
    server_addr.sin_addr.s_addr = inet_addr(address.c_str());
    addr_len  = sizeof(struct sockaddr_in);
    ret = ::connect(m_socket_fd, (struct sockaddr *)&server_addr, addr_len);
    if (ret < 0) {;
        return false;
    }
    printf("connect to server[%s:%d] success.\n", address.c_str(), port);

    return true;
}

void CClient::run()
{
    int ret = -1;
    char send_buf[MSG_LEN] = { 0 };
    char recv_buf[MSG_LEN] = { 0 };
    while (1) {
        memset(send_buf, 0, sizeof(send_buf));
        memset(recv_buf, 0, sizeof(recv_buf));
        gets(send_buf);
        if (strncmp(send_buf, "quit", 4) == 0)
            break;

        ret = send(m_socket_fd, send_buf, strlen(send_buf), 0);
        if (ret <= 0) {
            printf("failed send msg[%s]\n", send_buf);
            break;
        }

        ret = recv(m_socket_fd, recv_buf, sizeof(recv_buf), 0);
        recv_buf[ret] = '\0';
        if (ret <= 0) {
            printf("recv zero msg\n");
            continue;
        }

        printf("recv msg[%s]\n", recv_buf);
    } // end while

    close(m_socket_fd);
}

}

/**
  tcpclient.cpp
*/
#include "defs.h"
#include "client.h"
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void sighandler(int sig)
{
    printf("received signal:%d\n", sig);
    _exit(1);
}

int main(int argc, char* argv[])
{
    if (argc != 3) {
        printf("usage ./client <ip address> <host port>\n");
        return 1;
    }

    struct sigaction act, oact;
    act.sa_handler = sighandler;
    sigfillset(&act.sa_mask);
    act.sa_flags = 0;
    sigaction(SIGINT, &act, &oact);
    sigaction(SIGQUIT, &act, &oact);

    webrtc::CClient client;
    if (!client.connect(argv[1], atoi(argv[2]))) {
        printf("connect to server[%s:%s] failed.\n", argv[1], argv[2]);
        return 2;
    }

    client.run();

    return 0;
}

# g++ -std=c++11 -g -o tcpclient tcpclient.cpp client.cpp
# ./tcpclient 127.0.0.1 8111