嵌入式成长轨迹25 【Linux应用编程强化】【Linux下的C编程 下】【实例：客户端/服务器端程序】

给出一个客户/服务器程序开发的案例，实现从服务器状态的远程监视功能。同时，客户端采用图形界面来显示数据。这个案例涵盖了网络编程和GUI编程的相关知识，读者应该注意其中的结合点。具体内容包括：

服务器端程序设计

客户端程序设计

 

 

一  服务器端程序设计

服务器端程序的功能是接受客户端的连接，然后提供其状态信息，例如CPU的使用率、内存的分配情况等，这些信息我们通过访问/proc文件系统来获得。

 

/* server.c */

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <errno.h>

#include <string.h>

#include <sys/types.h>

#include <netinet/in.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#define SERV_PORT 2395    /* 服务器监听端口号 */

#define BACKLOG 10          /* 请求队列的长度数 */

#define BUF_SIZE 1024              /* 缓冲区的长度 */

#define MEM_SIZE 32

 

struct cpustatus

{

  long total;                       /* 系统从启动到现在的总时间 */

  float user;                        /* 系统从启动到现在用户态的CPU时间（百分比） */

  float nice;                        /* 系统从启动到现在nice值为负的进程所占用的CPU时间（百分比） */

  float system;                    /* 系统从启动到现在核心态的CPU时间（百分比） */

  float idle;                        /* 系统从启动到现在除I/O等待以外的其他等待时间（百分比） */

};

struct meminfo

{

  char total[MEM_SIZE];           /* 系统的总内存空间 */

  char free[MEM_SIZE];           /* 系统的空闲内存空间 */

};

void get_cpu_status(struct cpustatus *); /* 获取处理器信息 */

void get_mem_info(struct meminfo *); /* 获取内存信息 */

 

int main()

{

  int ret;

  int pid;                                                 /* 定义进程标识符 */

  int sockfd;                                      /* 定义监听Socket描述符 */

  int clientsfd;                                          /* 定义数据传输Socket描述符 */

  struct sockaddr_in host_addr;           /* 本机IP地址和端口号信息 */

  struct sockaddr_in client_addr;               /* 客户端IP地址和端口号信息 */

  unsigned int addrlen;

  char buf[BUF_SIZE];                            /* 定义缓冲区 */

  struct cpustatus cpu_stat;

  struct meminfo mem_info;

  int cnt;

  int size;

  /* 创建套接字 */

  sockfd = socket(AF_INET, SOCK_STREAM, 0);

  if(sockfd == -1)                                    /* 如果套接字创建失败，输出错误信息并退出 */

  {

    printf("socket error\n");

    exit(1);

  }

  /* 将套接字与IP地址和端口号进行绑定 */

  host_addr.sin_family = AF_INET;                         /* TCP/IP协议 */

  host_addr.sin_port = htons(SERV_PORT);              /* 让系统随机选择一个未被占用的端口号 */

  host_addr.sin_addr.s_addr = INADDR_ANY;          /* 本机IP地址 */

  bzero(&(host_addr.sin_zero), 8);                           /* 清零 */

  ret = bind(sockfd, (struct sockaddr *)&host_addr, sizeof(struct sockaddr));   /* 绑定 */

  if(ret == -1)                                                       /* 如果套接字绑定失败，输出错误信息并退出 */

  {

    printf("bind error\n");

    exit(1);

  }

  /* 将套接字设为监听模式，以等待连接请求 */

  ret = listen(sockfd, BACKLOG);

  if(ret == -1) {

    perror("listen error\n");

    exit(1);

  }

  printf("Waiting for the client connection.\n ");

  /* 循环处理客户端的请求 */

  while(1)

  {

    addrlen = sizeof(struct sockaddr_in);

    clientsfd = accept(sockfd, (struct sockaddr *)&client_addr, &addrlen);             /* 接受一个客户端连接 */

    if(clientsfd == -1)

    {

      perror("accept error\n");

      continue;

    }

    pid = fork();                               /* 创建子进程 */

    if(pid<0)                                          /* 如果进程创建失败，输出错误信息并退出 */

    {

      perror("fork error\n");

      exit(1);

    }

    if(pid==0)                                        /* 子进程，处理客户端的请求*/

    {

      close(sockfd);                                 /* 关闭父进程的套接字 */

      printf("Client IP : %s\n", inet_ntoa(client_addr.sin_addr));            /* 输出客户端IP地址 */

      /* 获取处理器信息 */

      get_cpu_status(&cpu_stat);

      size  = sizeof(struct cpustatus);

      memcpy(buf, &cpu_stat, size);

      /* 获取内存信息 */

      get_mem_info(&mem_info);

      memcpy(buf+size, &mem_info, sizeof(struct meminfo));

      /* 发送数据 */

      cnt = send(clientsfd, buf, BUF_SIZE, 0);

      if(cnt == -1)

      {

        perror("send error\n");

        exit(1);

      }

      printf("Done!\n", buf);                   /* 程序测试使用 */

      close(clientsfd);                       /* 关闭当前客户端连接 */

      exit(0);                                         /* 子进程退出 */

    }

    close(clientsfd);                                  /* 父进程，关闭子进程的套接字，准备接受下一个客户端连接 */

  }

  return 0;

}

 

void get_cpu_status(struct cpustatus *cpu_stat)

{

  long total;

  float user, nice, system, idle;

  long cpu[21];

  char text[201];

  FILE *fp;

  fp = fopen("/proc/stat", "r");                   /* 如果/proc/stat文件 */

  if (fp == NULL)                                   /* 如果文件打开失败，输出错误信息并退出 */

  {

    printf("open stat failed\n");

    exit(1);

  }

  while(fgets(text, 200, fp) != NULL)        /* 提取处理器信息 */

  {

    if(strstr(text, "cpu"))

    {

      sscanf(text, "%s %f %f %f %f", cpu, &user, &nice, &system, &idle);

    }

  }

  fclose(fp);                                     /* 关闭文件 */

  /* 进行各类CPU时间 */

  total = user + nice + system + idle;

  user = (user / total) * 100;

  nice = (nice / total) * 100;

  system = (system / total) * 100;

  idle = (idle / total) * 100;

  /* 对结构体各成员进行赋值 */

  cpu_stat->total = total;

  cpu_stat->user = user;

  cpu_stat->nice = nice;

  cpu_stat->system = system;

  cpu_stat->idle = idle;

  return;

}

 

void get_mem_info(struct meminfo *minfo)

{

  int i, j;

  char total[MEM_SIZE];

  char free[MEM_SIZE];

  char temp[MEM_SIZE*2];

  FILE *fp;

  fp = fopen("/proc/meminfo", "r");           /* 如果/proc/meminfo文件 */

  if (fp == NULL)                                   /* 如果文件打开失败，输出错误信息并退出 */

  {

    printf("open meminfo failed\n");

    exit(1);

  }

  fgets(temp, MEM_SIZE*2, fp);

  strcpy(total, temp);                         /* 系统的总内存空间信息（字符串） */

  fgets(temp, MEM_SIZE*2, fp);

  strcpy(free, temp);                               /* 系统的空闲内存空间信息（字符串） */

  fclose(fp);                                     /* 关闭文件 */

  if(strlen(total) > 0)                         /* 提取总内存空间信息字符串中的数值部分 */

  {

    for(i=0,j=0; i<strlen(total); i++)

    {

      if(isdigit(total[i]))

        minfo->total[j++] = total[i];

    }

    minfo->total[j] = '\0';                         /* 字符串结束符 */

  }

  if(strlen(free) > 0)                                 /* 提取空闲内存空间信息字符串中的数值部分 */

  {

    for(i=0,j=0; i<strlen(free); i++)

    {

      if(isdigit(free[i]))

        minfo->free[j++] = free[i];

    }

    minfo->free[j] = '\0';                          /* 字符串结束符 */

  }

  return;

}

 

 

 

二  客户端程序设计

客户端程序我们分两步来实现，首先在字符界面下设计实现，调试通过后，再设计开发图形界面。

 

1         字符界面客户端程序

首先开发字符界面下的客户端程序，该程序的功能比较简单，连接服务器，获取其状态信息，并输出到屏幕。

 

/* client.c */

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <errno.h>

#include <string.h>

#include <sys/types.h>

#include <netinet/in.h>

#include <sys/socket.h>

#define SERV_PORT 2395                  /* 服务器监听端口号 */

#define BUF_SIZE 1024                            /* 缓冲区的长度 */

#define MEM_SIZE 32

 

struct cpustatus                                   /* 处理器信息 */

{

  long total;

  float user;

  float nice;

  float system;

  float idle;

};

struct meminfo                                          /* 内存信息 */

{

  char total[MEM_SIZE];

  char free[MEM_SIZE];

};

 

int main(int argc, char **argv)

{

  int ret;

  int sockfd;                                     /* 定义Socket描述符 */

  struct sockaddr_in serv_addr;          /* 服务器IP地址和端口号信息 */

  char buf[BUF_SIZE];                            /* 定义缓冲区 */

  struct cpustatus cpu_stat;

  struct meminfo mem_info;

  int cnt;

  int size;

  if(argc != 2)                                         /* 检查命令行参数个数是否正确 */

  {

    printf("arguments error.\n");

    exit(1);

  }

  /* 创建套接字 */

  sockfd = socket(AF_INET, SOCK_STREAM, 0);

  if(sockfd == -1)                                                  /* 如果套接字创建失败，输出错误信息并退出 */

  {

    printf("socket error\n");

    exit(1);

  }

  /* 向服务器发出连接请求 */

  serv_addr.sin_family = AF_INET;                         /* TCP/IP协议 */

  serv_addr.sin_port = htons(SERV_PORT);             /* 服务器端口号，并转换为网络字节顺序 */

  serv_addr.sin_addr.s_addr = inet_addr(argv[1]);     /* 服务器的IP地址 */

  bzero(&(serv_addr.sin_zero), 8);                          /* 清零 */

  ret = connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr));     /* 连接 */

  if(ret == -1)                                                       /* 如果连接失败，输出错误信息并退出 */

  {

    printf("connect error\n");

    exit(1);

  }

  /* 接收数据 */

  cnt = recv(sockfd, buf, BUF_SIZE, 0);

  if(cnt == -1)

  {

    perror("recv error\n");

    exit(1);

  }

  size  = sizeof(struct cpustatus);

  memcpy(&cpu_stat, buf, size);

  memcpy(&mem_info, buf+size, sizeof(struct meminfo));

  /* 输出接收到数据 */

  printf("CPU Information\n");

  printf("------------------------\n");

  printf("user :\t\t %.2f\%\n", cpu_stat.user);

  printf("nice :\t\t %.2f\%\n", cpu_stat.nice);

  printf("system :\t %.2f\%\n", cpu_stat.system);

  printf("idle :\t\t %.2f\%\n", cpu_stat.idle);

  printf("Memory Information\n");

  printf("------------------------\n");

  printf("total :\t\t %s kB\n",mem_info.total);

  printf("free :\t\t %s kB \n",mem_info.free);

  close(sockfd);                                /* 关闭套接字 */

  return 0;

}

 

 

 

2         图形界面客户端程序

接下来设计开发客户端的图形界面，这里使用Glade来协助完成。

 

 

/*

 * Initial main.c file generated by Glade. Edit as required.

 * Glade will not overwrite this file.

 */

 

#ifdef HAVE_CONFIG_H

#  include <config.h>

#endif

 

#include <gtk/gtk.h>

 

#include "interface.h"

#include "support.h"

 

GtkWidget *entry1;

GtkWidget *textview1;

  int

main (int argc, char *argv[])

{

  GtkWidget *window1;

 

#ifdef ENABLE_NLS

  bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);

  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");

  textdomain (GETTEXT_PACKAGE);

#endif

 

  gtk_set_locale ();

  gtk_init (&argc, &argv);

 

  add_pixmap_directory (PACKAGE_DATA_DIR "/" PACKAGE "/pixmaps");

 

  /*

   * The following code was added by Glade to create one of each component

   * (except popup menus), just so that you see something after building

   * the project. Delete any components that you don't want shown initially.

   */

  window1 = create_window1 ();

  gtk_widget_show (window1);

 

  gtk_main ();

  return 0;

}

 

/*

 * DO NOT EDIT THIS FILE - it is generated by Glade.

 */

 

#ifdef HAVE_CONFIG_H

#  include <config.h>

#endif

 

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>

#include <string.h>

#include <stdio.h>

 

#include <gdk/gdkkeysyms.h>

#include <gtk/gtk.h>

 

#include "callbacks.h"

#include "interface.h"

#include "support.h"

 

#define GLADE_HOOKUP_OBJECT(component,widget,name) \

  g_object_set_data_full (G_OBJECT (component), name, \

      gtk_widget_ref (widget), (GDestroyNotify) gtk_widget_unref)

 

#define GLADE_HOOKUP_OBJECT_NO_REF(component,widget,name) \

  g_object_set_data (G_OBJECT (component), name, widget)

 

  GtkWidget*

create_window1 (void)

{

  GtkWidget *window1;

  GtkWidget *fixed1;

  GtkWidget *fixed2;

  extern GtkWidget *entry1;

  extern GtkWidget *textview1;

  GtkWidget *label2;

  GtkWidget *label1;

  GtkWidget *button1;

 

  window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);

  gtk_window_set_title (GTK_WINDOW (window1), _("remote monitor"));

 

  fixed1 = gtk_fixed_new ();

  gtk_widget_show (fixed1);

  gtk_container_add (GTK_CONTAINER (window1), fixed1);

  gtk_widget_set_size_request (fixed1, 264, 302);

 

  fixed2 = gtk_fixed_new ();

  gtk_widget_show (fixed2);

  gtk_fixed_put (GTK_FIXED (fixed1), fixed2, 136, 104);

  gtk_widget_set_size_request (fixed2, 50, 50);

 

  entry1 = gtk_entry_new ();

  gtk_widget_show (entry1);

  gtk_fixed_put (GTK_FIXED (fixed1), entry1, 104, 224);

  gtk_widget_set_size_request (entry1, 144, 24);

  gtk_entry_set_invisible_char (GTK_ENTRY (entry1), 8226);

 

  textview1 = gtk_text_view_new ();

  gtk_widget_show (textview1);

  gtk_fixed_put (GTK_FIXED (fixed1), textview1, 16, 42);

  gtk_widget_set_size_request (textview1, 232, 172);

 

  label2 = gtk_label_new (_("Server Information :"));

  gtk_widget_show (label2);

  gtk_fixed_put (GTK_FIXED (fixed1), label2, 10, 16);

  gtk_widget_set_size_request (label2, 160, 24);

 

  label1 = gtk_label_new (_("IP Address:\n"));

  gtk_widget_show (label1);

  gtk_fixed_put (GTK_FIXED (fixed1), label1, 16, 227);

  gtk_widget_set_size_request (label1, 80, 20);

  gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_CENTER);

 

  button1 = gtk_button_new_with_mnemonic (_("Update"));

  gtk_widget_show (button1);

  gtk_fixed_put (GTK_FIXED (fixed1), button1, 176, 256);

  gtk_widget_set_size_request (button1, 70, 29);

 

  g_signal_connect ((gpointer) entry1, "activate",

      G_CALLBACK (on_entry1_activate),

      NULL);

  g_signal_connect ((gpointer) button1, "clicked",

      G_CALLBACK (on_button1_clicked),

      NULL);

 

  /* Store pointers to all widgets, for use by lookup_widget(). */

  GLADE_HOOKUP_OBJECT_NO_REF (window1, window1, "window1");

  GLADE_HOOKUP_OBJECT (window1, fixed1, "fixed1");

  GLADE_HOOKUP_OBJECT (window1, fixed2, "fixed2");

  GLADE_HOOKUP_OBJECT (window1, entry1, "entry1");

  GLADE_HOOKUP_OBJECT (window1, textview1, "textview1");

  GLADE_HOOKUP_OBJECT (window1, label2, "label2");

  GLADE_HOOKUP_OBJECT (window1, label1, "label1");

  GLADE_HOOKUP_OBJECT (window1, button1, "button1");

 

  return window1;

}

 

#ifdef HAVE_CONFIG_H

#  include <config.h>

#endif

 

#include <gtk/gtk.h>

 

#include "callbacks.h"

#include "interface.h"

#include "support.h"

 

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <errno.h>

#include <string.h>

#include <sys/types.h>

#include <netinet/in.h>

#include <sys/socket.h>

#define SERV_PORT 2395                  /* 服务器监听端口号 */

#define BUF_SIZE 1024                            /* 缓冲区的长度 */

#define MEM_SIZE 32

 

 

 

struct cpustatus                                   /* 处理器信息 */

{

  long total;

  float user;

  float nice;

  float system;

  float idle;

};

struct meminfo                                          /* 内存信息 */

{

  char total[MEM_SIZE];

  char free[MEM_SIZE];

};

 

 

 

 

  void

on_button1_clicked                     (GtkButton       *button,

    gpointer         user_data)

{

 

  int ret;

  int sockfd;                                     /* 定义Socket描述符 */

  struct sockaddr_in serv_addr;          /* 服务器IP地址和端口号信息 */

  char buf[BUF_SIZE];                            /* 定义缓冲区 */

  struct cpustatus cpu_stat;

  struct meminfo mem_info;

  int i, cnt;

  int size;

  char out[6][MEM_SIZE];

  sockfd = socket(AF_INET, SOCK_STREAM, 0);

  if(sockfd == -1)                                                  /* 如果套接字创建失败，输出错误信息并退出 */

  {

    printf("socket error\n");

    exit(1);

  }

 

  extern GtkWidget *entry1;

 

  const gchar *entry_text;

  entry_text = gtk_entry_get_text(entry1);

 

 

  /* 向服务器发出连接请求 */

  serv_addr.sin_family = AF_INET;                         /* TCP/IP协议 */

  serv_addr.sin_port = htons(SERV_PORT);             /* 服务器端口号，并转换为网络字节顺序 */

  serv_addr.sin_addr.s_addr = inet_addr(entry_text);        /* 服务器的IP地址 */

  bzero(&(serv_addr.sin_zero), 8);                          /* 清零 */

  ret = connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(struct sockaddr));     /* 连接 */

  if(ret == -1)                                                       /* 如果连接失败，输出错误信息并退出 */

  {

    printf("connect error\n");

    exit(1);

  }

  /* 接收数据 */

  cnt = recv(sockfd, buf, BUF_SIZE, 0);

  if(cnt == -1)

  {

    perror("recv error\n");

    exit(1);

  }

  size  = sizeof(struct cpustatus);

  memcpy(&cpu_stat, buf, size);

  memcpy(&mem_info, buf+size, sizeof(struct meminfo));

  /* 输出接收到数据 */

 

  printf("Entry contents : %s\n", entry_text);

  extern GtkWidget *textview1;

  // const gchar *entry_text;

  GtkTextBuffer *buffer;

  buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW (textview1));//取得文本缓冲区 

 

  //PangoFontDescription *fontDesc;

  // fontDesc = pango_font_description_from_string("Courier Pitch Bold 12");

 

  // gtk_widget_modify_font(textview1, fontDesc);

  GtkTextIter start, end;

  //gtk_text_buffer_get_start_iter(buffer,&end); 

  //gtk_text_buffer_get_end_iter(buffer,&end);

  //end = start;

 

  sprintf(out[0],"user :\t\t %.2f\%\n", cpu_stat.user);

  sprintf(out[1],"nice :\t\t %.2f\%\n", cpu_stat.nice);

  sprintf(out[2],"system :\t %.2f\%\n", cpu_stat.system);

  sprintf(out[3],"idle :\t\t %.2f\%\n", cpu_stat.idle);

 

  sprintf(out[4],"total :\t\t %s kB\n",mem_info.total);

  sprintf(out[5],"free :\t\t %s kB \n",mem_info.free);

  gtk_text_buffer_get_start_iter(buffer,&end);   

 

  for(i=5; i>=0; i--)

  {

 

    gtk_text_buffer_get_start_iter(buffer,&end);   

 

    if(i == 3)

    {

      gtk_text_buffer_insert(buffer,&end, "Memory\n-------------------------\n", -1);     

      gtk_text_buffer_get_start_iter(buffer,&end);   

    }

    gtk_text_buffer_insert(buffer,&end, out[i], -1);/*  gtk_text_insert (GTK_TEXT_VIEW(textview1), NULL, &textview1->style->black, NULL, "Supports ", -1);*/

 

  }

  gtk_text_buffer_get_start_iter(buffer,&end);   

  gtk_text_buffer_insert(buffer,&end, "CPU\n-------------------------\n", -1);

  close(sockfd);                                /* 关闭套接字 */

  return 0;

 

 

}

  void

on_entry1_activate  (GtkEntry        *entry,    gpointer         user_data)

{

  const gchar *entry_text;

  entry_text = gtk_entry_get_text(entry);

  printf("Entry contents : %s\n", entry_text);

}

 

 

 

 

三小结

这里基于网络编程和GUI编程技术设计实现了一个客户/服务器程序。总的来说，程序还是比较简单、容易理解的。感兴趣的同学还可以在该程序的基础上进行优化，例如将界面加工得更为美观，或添加一些新的功能。