基于Linux的socket编程模板

最新推荐文章于 2024-11-13 12:50:03 发布
最新推荐文章于 2024-11-13 12:50:03 发布
阅读量510 收藏
点赞数
分类专栏： Socket编程 文章标签： socket 服务器 TCPIP
基于Linux的socket编程模板

    在网络编程编程中，我们经常会遇到这样一种C/S架构，服务器端（Server）监听客户端（Client）发送过来的命令，然后解析该命令，并做对应的处理，

最后返回处理结果（例如成功或者失败及原因）给客户端。


    最近，在Linux下做网络编程，涉及的就是上面的这种需求，简单地整理了下自己的代码，分享在这里吧，供初学者参考。
    首先说一下编程思路吧。


    在这种情况客户端必须实现的的接口有：连接服务器、发送、断开连接。
    服务器端，有一个主线程，用于监听客户端的连接请求，一旦有新客户端连接，则创建一个新的socket及线程专门服务这个客户端。这个服务线程专门监听该客户端的命令，并且解析命令进行服务器，直到客户端断开连接或者发送关闭连接的命令。
    另外，需要涉及一个通信协议，约定命令的包头、命令的识别码、命令的参数。
    思路就说到这儿了，下面的相关代码，附件中有完整的代码，包含了Makefile文件。


 一、通信协议设计
//
//  COPYRIGHT NOTICE
//  Copyright (c) 2011, 华中科技大学 ticktick（版权声明）
//  All rights reserved.
// 
/// @file    Command.h  
/// @brief   命令包声明文件
///
/// 定义各种TCP命令包以及相关结构体
///
/// @version 1.0   
/// @author  lujun 
/// @E-mail  lujun.hust@gmail.com
/// @date    2011/08/21
//
//
//  修订说明：
//
#ifndef COMMAND_H_
#define COMMAND_H_

typedef unsigned char uint8_t;

// TCP CMD header len
#define TCP_CMD_HEADER_LEN 8

// CMD header
static uint8_t TCP_CMD_HEADER_STR[TCP_CMD_HEADER_LEN] = { 0xAA,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xFF };

// max user name len 
#define MAX_USER_NAME_LEN 20

// server cmd struct
typedef enum _ServerCMD
{
    CMD_SAVE_USER_NAME,         // save user name
    CMD_SAVE_USER_AGE,          // save user age

}ServerCMD;

// return cmd 
typedef enum _ReturnCMD
{
    DVS_RETURN_SUCCESS = 0,      
    DVS_RETURN_FAIL,             
    DVS_RETURN_TIMEOUT,          
    DVS_RETURN_INVLID_HEADER,    
    DVS_RETURN_INVLID_CMD,       
    DVS_RETURN_INVLID_PRM,       

}ReturnCMD;

// 1bytes aligning
#pragma pack( push, 1 )

// server pack from client
typedef struct _ServerPack 
{
    // cmd header
    uint8_t cmdHeader[TCP_CMD_HEADER_LEN];

    // command id
    ServerCMD serverCMD;

    // cmd param
    union
    {
        // save user name
          struct
          {
              // user name
            char username[MAX_USER_NAME_LEN];

          }UserName;

          // save user age
          struct
          {
              // user age
            int userage;

          }UserAge;

    }Parameters;

}ServerPack;

// return pack from server
typedef struct _ReturnPack
{
    // cmd header
    uint8_t cmdHeader[TCP_CMD_HEADER_LEN];

    // return cmd 
    ReturnCMD returnCMD;

}ReturnPack;

#pragma pack( pop )

#define SERVER_PACK_LEN sizeof(ServerPack)
#define RETURN_PACK_LEN sizeof(ReturnPack)

#endif // COMMAND_H_
二、客户端代码
//
//  COPYRIGHT NOTICE
//  Copyright (c) 2011, 华中科技大学 ticktick（版权声明）
//  All rights reserved.
// 
/// @file    client.c  
/// @brief   tcp客户端代码
///
/// 实现tcp客户端的相关接口
///
/// @version 1.0   
/// @author  lujun 
/// @E-mail  lujun.hust@gmail.com
/// @date    2011/08/21
//
//
//  修订说明：
//

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

// socket handle
int g_hSocket;

int connect_server( char *destIp, int destPort )
{
    int result;
    struct sockaddr_in address;

    // create a socket
    g_hSocket = socket(AF_INET,SOCK_STREAM,0);

    // set server addr
    address.sin_family = AF_INET;

    // use server ip and listen port to connect
    address.sin_addr.s_addr = inet_addr( destIp );
    address.sin_port        = htons(destPort);
    
    // connect tcp server
    result = connect(g_hSocket,(struct sockaddr *)&address,sizeof(address) );
    if( result == -1 )
    {
        printf("[tcp client] can't connect server !\n");
          return -1;
    }
    
    return 0;
}

int close_connect()
{
    printf("close connect with server !\n ");

    close(g_hSocket);

    return 0;
}

int send_cmd( ServerPack sPack )
{
    int recvBytes = 0;
    int sendBytes = 0;
    ReturnPack rPack;

    // add cmd header
    memcpy(sPack.cmdHeader,TCP_CMD_HEADER_STR,TCP_CMD_HEADER_LEN);

    // send cmd
    while(1)
    {
        sendBytes = send(g_hSocket,(uint8_t *)&sPack,SERVER_PACK_LEN,0);
        
        if( sendBytes == SERVER_PACK_LEN )
        {
            printf("successfully send bytes %d\n",SERVER_PACK_LEN);
            break;
        }
        else if( sendBytes <= 0 && errno != EINTR && errno != EWOULDBLOCK && errno != EAGAIN)
        {
            printf("disconnected or other errors!\n");
              return -1;
        }
        else
        {
            continue;
        }
    }

    // recv process result from server
    while(1)
    {
        recvBytes = recv(g_hSocket,(uint8_t *)&rPack,RETURN_PACK_LEN,0);

          if( recvBytes == RETURN_PACK_LEN )
          {
              break;
          }
          else if( recvBytes <=0 && errno != EINTR && errno != EWOULDBLOCK && errno != EAGAIN )
          {
              printf("disconnected or error occur!\n close the socket!\n");
              return -1;
          }
          else
          { 
              continue;
          }
    }

    // check header
    if ( memcmp( rPack.cmdHeader, TCP_CMD_HEADER_STR, TCP_CMD_HEADER_LEN ) != 0 )
    {
        printf("return pack header errror!\n");
        return -2;
    }

    // get return status
    if( rPack.returnCMD != DVS_RETURN_SUCCESS )
    {
        printf("return status : fail!\n");
        return -3;
    }
    
    return 0;    
}


三、服务器主线程代码
//
//  COPYRIGHT NOTICE
//  Copyright (c) 2011, 华中科技大学 ticktick（版权声明）
//  All rights reserved.
// 
/// @file    server.c 
/// @brief   tcp服务器主线程代码
///
/// 实现tcp服务端监听线程相关函数
///
/// @version 1.0   
/// @author  lujun 
/// @E-mail  lujun.hust@gmail.com
/// @date    2011/08/21
//
//
//  修订说明：
//

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>

#include <netinet/in.h>
#include <unistd.h>

#include "serverIf.h"

int g_hServerSocket;

int open_port( int localport )
{
    int result;
    int clientSocket,client_len;

    struct sockaddr_in server_addr;
    struct sockaddr_in client_addr;

    // create a socket obj for server
    g_hServerSocket = socket(AF_INET,SOCK_STREAM,0);

    // bind tcp port
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(localport);

    result = bind(g_hServerSocket,(struct sockaddr *)&server_addr,sizeof(server_addr) );
    if( result != 0 ) 
    {
           printf("[tcp server] bind error!\n ");    
           return -1;
    }

    // begin to listen
    result = listen(g_hServerSocket,5);
    if( result != 0 )
    {
        printf("[tcp server] listen error!\n ");
          return -1;
    }

    // 注: ServerEnv用于给服务线程传参，定义于serverIf.h中
    ServerEnv env;
    while(1)
    {
          client_len = sizeof(client_addr);
          clientSocket = accept(g_hServerSocket,(struct sockaddr *)&client_addr,&client_len );

          if( clientSocket < 0 )
          {
              printf("[tcp server] accept error!\n" );
              return -1;
          }
           
          env.m_hSocket = clientSocket;
          
          // add new tcp server thread
          add_new_tcp_process_thr(&env);
    }

    return 0;
}

int close_port()
{
    printf("close server port, stop listen!\n");

    close(g_hServerSocket);

    return 0;
}
四、服务器端服务线程代码
//
//  COPYRIGHT NOTICE
//  Copyright (c) 2011, 华中科技大学 ticktick（版权声明）
//  All rights reserved.
// 
/// @file    serverIf.c  
/// @brief   tcp服务线程代码
///
/// 实现tcp服务线程相关接口
///
/// @version 1.0   
/// @author  lujun 
/// @E-mail  lujun.hust@gmail.com
/// @date    2011/08/21
//
//
//  修订说明：
//

#include "serverIf.h"
#include "../include/Command.h"
#include <sys/socket.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>

int add_new_tcp_process_thr( ServerEnv *envp )
{
    pthread_t tcpThr;

    if( pthread_create( &tcpThr,NULL,tcpServerThrFxn,envp ) )
    {
        printf("tcp thread create fail!\n");
        return -1;
    }

    printf("tcp thread has been created!\n");

    return 0;
}

int save_user_name( char * pUsername )
{
    printf("ok,user name saved,username=%s\n",pUsername);

    return 0;
}

int save_user_age( int age )
{
    printf("ok,user age saved,userage=%d\n",age);

    return 0;
}

void * tcpServerThrFxn( void * arg )
{
    ServerEnv * envp = (ServerEnv *)arg;
    int socketfd = envp->m_hSocket;
    int returnBytes;

    ServerPack sPack;
    ReturnPack rPack;
    memcpy(rPack.cmdHeader,TCP_CMD_HEADER_STR,TCP_CMD_HEADER_LEN);

    while(1)
    {
          // read cmd from client
          returnBytes = recv(socketfd,(uint8_t *)&sPack,SERVER_PACK_LEN,0);
          if( returnBytes == SERVER_PACK_LEN )
          {
              //printf("ok,recv %d bytes! \n",SERVER_PACK_LEN);
          }
          else if( returnBytes <= 0 && errno != EINTR && errno != EWOULDBLOCK && errno != EAGAIN )
          {
              printf("disconnected or error occur! errno=%d\n ",errno);
              break;
          }
          else
          {
              continue;
          }

          // check the header
          if ( memcmp( sPack.cmdHeader, TCP_CMD_HEADER_STR, TCP_CMD_HEADER_LEN ) != 0 )
          {
              rPack.returnCMD = DVS_RETURN_INVLID_HEADER;

              // return error info to client
              returnBytes = send(socketfd,(uint8_t *)&rPack,RETURN_PACK_LEN,0 ) ;
              if( returnBytes < RETURN_PACK_LEN)
              {
                  printf("send error!\n");
                    continue;
              }
          }

          // analyse cmd
          rPack.returnCMD = DVS_RETURN_SUCCESS;
          switch( sPack.serverCMD )
          {
          case CMD_SAVE_USER_NAME:
               {  
                     if( save_user_name(sPack.Parameters.UserName.username) != 0)
                     {
                         rPack.returnCMD = DVS_RETURN_FAIL;
                     }
               }
          break;
          case CMD_SAVE_USER_AGE:
              {
                   if( save_user_age(sPack.Parameters.UserAge.userage) != 0)
                     { 
                         rPack.returnCMD = DVS_RETURN_FAIL;
                     }
              }
          break;
          default:
             {  
                   rPack.returnCMD = DVS_RETURN_INVLID_CMD;
             }
          break;
          } 
    
          // return result info to client
          returnBytes = send(socketfd,(uint8_t *)&rPack,RETURN_PACK_LEN,0 );
          if( returnBytes < RETURN_PACK_LEN )
          {
            printf("send error!\n");
            continue;       
          }
    }

    printf("close session socket!");

    // close socket
    close(socketfd);

    return (void*)0;
}
五、客户端测试代码
//
//  COPYRIGHT NOTICE
//  Copyright (c) 2011, 华中科技大学 ticktick（版权声明）
//  All rights reserved.
// 
/// @file    main.c  
/// @brief   tcp客户端测试代码
///
/// 实现 tcp客户端测试
///
/// @version 1.0   
/// @author  lujun 
/// @E-mail  lujun.hust@gmail.com
/// @date    2011/08/21
//
//
//  修订说明：
//

#include <stdio.h>

#include "client.h"

#define LOCAL_IP_STR "127.0.0.1"
#define DEST_IP_STR  "192.201.0.8"
#define DEST_PORT    8000

int main(int argc, char **argv)
{
    int i =0;

    printf("tcp test start!\n");

    if( connect_server(DEST_IP_STR,DEST_PORT) != 0)
    {
        return -1;
    }

    ServerPack sPack;
    sPack.serverCMD = CMD_SAVE_USER_AGE;
    sPack.Parameters.UserAge.userage = 20;

    if( send_cmd(sPack) == -1 )
      {
          printf("send cmd fail!\n");
      }

    getchar();
    getchar();

    close_connect();

    printf("tcp test pass!\n");

    return 0;
}
六、服务器端测试代码
//
//  COPYRIGHT NOTICE
//  Copyright (c) 2011, 华中科技大学 ticktick（版权声明）
//  All rights reserved.
// 
/// @file    main.c  
/// @brief   tcp客户端代码
///
/// 实现tcp服务器端测试的代码
///
/// @version 1.0   
/// @author  lujun 
/// @E-mail  lujun.hust@gmail.com
/// @date    2011/08/21
//
//
//  修订说明：
//

#include <stdio.h>

#include "server.h"
#include "serverIf.h"

#define LOCAL_PORT 8000

int main(int argc, char **argv)
{
    printf("tcp test start!\n");

    if( open_port(LOCAL_PORT) != 0)
    {
        return -1;
    }

    close_port();

    printf(" close port !\n");

    return 0;
}
七、总结和说明
    本文后面的附件中有完整的代码，欢迎下载使用。编译方法，把代码文件夹都拷贝到linux下，在本代码文件夹的根目录下，运行make，

即可生成对应的可执行文件。在运行测试程序的时候，请先执行server.out，然后执行client.out

 如果发现本代码的任何bug或者有任何建议，欢迎留言或者来信交流。

丢丢来
关注
专栏目录
Linux网络编程 | socket选项设定 及 网络信息API
Jormungand_V的博客
10-02 622
文章目录socket 接口 socket 接口 1. 地址信息函数 我们可以知道一个连接 socket 的 本端socket地址 ，以及 远端socket 地址 。 #include<sys/socket.h> int getsockname(int sockfd, struct sockaddr* address, socklen_t* address_len); // 获取 sockfd 对应的socket地址 int getpeername(int sockfd, struct so
Linux网络编程 | 基本套接字（Socket）编程
ZY-JIMMY
04-16 2086
网络中进程如何通信、Socket简介、socket套接字、套接字描述符、Socket基础API、创建socket、命名socket、监听socket、接受连接、发起连接、关闭连接、TCP数据读写、UDP数据读写、主机字节序和网络字节序、客户端 / 服务器模式及编程流程
SOCKET模板 C/S通信
08-03
简单的SOCKET通信，关于用户端和服务器端的相互通信，一个简单的实验。
简单的socket编程模版
Mradxz的专栏
06-21 654
#include "stdafx.h"#include "winsock2.h" #include "stdio.h"#pragma comment(lib,"wsock32.lib")演示一个简单的和网易Email服务器对话的过程。1、网络基本概念讲解QQ的基本原理讲解浏览器上网的基本原理服务器：Server。提供服务的计算机。客户端：Client。和服务器端交互的一个设备。IP地址：计算机在网
socket编程模型
sinat_38515986的博客
04-29 1085
这篇文章是关于socket网络编程的全面介绍，涵盖了TCP/IP协议中的基本概念，如IP地址、端口号、大端小端以及网络字节序。文章详细讲解了TCP服务器和客户端的创建、绑定、监听、三次握手连接过程，以及数据的读写和连接的关闭。此外，还探讨了多线程和多进程模型，以及IO多路复用技术，包括select、poll和epoll，这些技术允许服务器端单线程处理多个客户端连接。最后，文章通过伪代码展示了如何利用这些技术构建高效的网络服务器。
Java中socket的代码模板
hubbybob1专栏
07-10 1659
java的的socket的代码编写与C 语言的不太一样，C 语言的代码简练有深度，java的写起来复杂，但是不是那么难懂，因此在这里记录一下模板，防止以后忘记，总共四个文件，分别是ServiceServer.java（用于创建socket服务器），ServiceTask.java（服务器所提供的业务），DataProcess.java（服务器业务数据处理），ServiceCliect.java（s...
Linux--Socket编程TCP
m0_74068921的博客
07-28 1828
通过多进程的方法，让父进程只负责监听，子进程负责连接，孙进程负责服务，由于孙进程是孤儿进程，相当于线程分离，这样处理服务时就不会受到父子进程的影响了；启动服务器之后，通过循环让服务端不断运行着，在循环里面，服务端可能接收到多个客户端请求的连接，所以accpet要在循环中不断接收看是否有对应的连接；初始化服务端，主要完成套接字的创建绑定，已经完成对应的监听客户端，因为Tcp是有连接的，所以需要监听客户端是否有请求连接的需求；直接通过多线程的方法，将创建的线程进行分离，完成对应的服务任务。
Linux —— Socket编程（二）
学习C++的小陈同学
09-28 1169
本篇重点是延续上一篇，进一步改造了udp服务端，简单的补充和添加了几个功能，并且提供了代码进行参考。
linux 基础c 语言基础 c++ 基础 数据结构基础 socket编程基础
06-08
在IT领域，Linux、C语言、C++以及数据结构和Socket编程是计算机科学与软件工程的基础，对于任何希望深入理解操作系统、系统级编程或者网络应用开发的开发者来说，这些都是不可或缺的知识点。 首先，我们来详细了解...
linux下socket模板函数发送与接受
06-14
在Linux操作系统中，Socket编程是实现网络通信的基础。Socket接口提供了丰富的函数，使得开发者能够创建、连接、发送和接收数据。本教程将深入探讨Linux下的Socket模板函数，以帮助你理解如何有效地进行发送和接收...
基于QT的TCP socket通信编程 .doc
03-26
* 丰富的API：QT包括多达250个以上的C++类，还提供基于模板的collections，serialization，file，I/O device，directory management，date/time类。甚至还包括正则表达式的处理功能。 * 跨平台支持：QT支持多种操作...
Unix/Linux网络编程实验二：TCP套接字编程模板（python版）
wzx66803的博客
12-20 601
文章目录0.写在最前面系列文章的作用1.最基本的服务器与客户端1.1 套接字：通信端点1.1.1 套接字1.1.1.1 基于文件的套接字（网络通讯不用管这方面的知识）1.1.1.2 面向网络的套接字（重点掌握）1.1.2 套接字地址：主机-端口对1.1.3 面向连接的套接字与无连接的套接字1.1.3.1 面向连接的套接字1.1.3.2 无连接的套接字1.2 socket 模块函数套接字对象（内置）部分方法1.4 创建客户端1.4.1 一般通用模板14-1实验(python版本)客户端服务端核心代码解释客户端
Linux C聊天机器人客户端socket编程模板
u012640537的博客
08-02 157
呵呵 #include <stdio.h> #include <stdlib.h> #include <sys/types.h> /* See NOTES */ #include <sys/socket.h> //字节序转换头文件 #include <netinet/in.h> #include <arpa/inet.h> #include <string.h> #include <unistd.
Socket编程简单示例
BASK2312的博客
02-18 1005
但是该实现也有一个问题：虽然客户端的连接过程不会阻塞了，但是客户端发送数据会阻塞服务端。如果客户端发送数据过大，假设要10秒，那服务端调用read方法读取数据就要等待客户端至少10秒。selector的服务端如下，这是要给单线程的服务端。传统BIO会阻塞，使用NIO通道编程可以设置服务器为非阻塞，当未获取到连接时，可以处理其他的逻辑。下面是服务端代码，客户端代码不变，采用BIO的即可。缺点是单线程执行，如果一个线程抢到读就绪事件并且处理的很慢，就会影响整体性能。传统BIO是阻塞的，举个烧水的例子来理解。
linux c 编程模板总结（二）
benpaobagzb的博客
02-29 754
01）linux下的c语言开发（网络编程） 02）linux下的c语言开发（线程互斥） 03）linux下的c语言开发（线程等待） 04）linux下的c语言开发（多线程编程） 05）linux下的c语言开发（管道通信） 06）linux下的c语言开发（信号处理） 07）linux下的c语言开发（进程等待） 08）linux下的c语言开发（进程创建） 09）
ThinkServer SR658H V2服务器BMC做raid与装系统
最新发布
Lzcsfg的博客
11-13 447
要求： 1. 将两个894G的磁盘做成raid1 2. 将两块14902G的磁盘各自做成raid0
【服务器】本地安装X11 服务器-Windows
WW、forever的博客
11-12 1271
【服务器】本地安装X11 服务器-Windows
Linux网络编程：TCP服务器模板与四层模型详解
本文档是一份关于Linux网络编程的TCP服务器模板，它展示了如何在Linux环境下创建一个TCP服务器的基本结构。首先，通过`socket()`函数创建套接字，如果失败，会捕获错误并退出程序。然后，使用`bind()`和`listen()`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值