码迷，mamicode.com
首页 > 其他好文 > 详细

unix网络编程各种TCP客户-服务器程序设计实例附环境搭建和编译方法（一）

时间：2015-07-12 11:20:29      阅读：170      评论：0      收藏：0      [点我收藏+]

标签：struts

一，到http://download.csdn.net/detail/ts173383201/4505201去下载源代码，然后解压；

二，cd到你解压后的文件夹下，就是有configure的那个目录下，执行命令./configure；

三，执行cd lib跳到lib目录下，执行make命令，会在上层目录（就是刚才有configure那个目录）生成libunp.a文件

四，复制这个静态库libunp.a到/usr/lib/和/usr/lib64/中;

五，接下来在目录中找到unp.h和config.h，在以后的代码中我们都要用到这两个头文件，将他们复制到和我们的源代码同一个路径下；

这样我们的环境就搭建好了，是不是很简单啊，但是以后编译的时候在gcc的最后加上-lunp导入静态库就可以了。下面我们就来看这些例子：

技术分享

第一种：TCP迭代服务器程序：迭代服务器总是在完全处理了一个客户的请求后才响应下一个客户的请求。

客户端程序：daytimetcpcli.c

  1. #include    "unp.h"  
  2.   
  3. int  
  4. main(int argc, char **argv)  
  5. {  
  6.     int                 sockfd, n;  
  7.     char                recvline[MAXLINE + 1];  
  8.     struct sockaddr_in  servaddr;  
  9.   
  10.     if (argc != 2)  
  11.         err_quit("usage: a.out <IPaddress>");  
  12.   
  13.     if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0)  
  14.         err_sys("socket error");  
  15.   
  16.     bzero(&servaddr, sizeof(servaddr));  
  17.     servaddr.sin_family = AF_INET;  
  18.     servaddr.sin_port   = htons(13);    /* daytime server */  
  19.     if (inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0)  
  20.         err_quit("inet_pton error for %s", argv[1]);  
  21.   
  22.     if (connect(sockfd, (SA *) &servaddr, sizeof(servaddr)) < 0)  
  23.         err_sys("connect error");  
  24.   
  25.     while ( (n = read(sockfd, recvline, MAXLINE)) > 0) {  
  26.         recvline[n] = 0;    /* null terminate */  
  27.         if (fputs(recvline, stdout) == EOF)  
  28.             err_sys("fputs error");  
  29.     }  
  30.     if (n < 0)  
  31.         err_sys("read error");  
  32.   
  33.     exit(0);  
  34. }  

服务器程序：daytimetcpsrv.c

  1. #include    "unp.h"  
  2. #include    <time.h>  
  3.   
  4. int  
  5. main(int argc, char **argv)  
  6. {  
  7.     int                 listenfd, connfd;  
  8.     struct sockaddr_in  servaddr;  
  9.     char                buff[MAXLINE];  
  10.     time_t              ticks;  
  11.   
  12.     listenfd = Socket(AF_INET, SOCK_STREAM, 0);  
  13.   
  14.     bzero(&servaddr, sizeof(servaddr));  
  15.     servaddr.sin_family      = AF_INET;  
  16.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  
  17.     servaddr.sin_port        = htons(13);   /* daytime server */  
  18.   
  19.     Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));  
  20.   
  21.     Listen(listenfd, LISTENQ);  
  22.   
  23.     for ( ; ; ) {  
  24.         connfd = Accept(listenfd, (SA *) NULL, NULL);  
  25.   
  26.         ticks = time(NULL);  
  27.         snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks));  
  28.         Write(connfd, buff, strlen(buff));  
  29.   
  30.         Close(connfd);  
  31.     }  
  32. }  

好，现在我们接着上面的步骤，将这两个源文件放到我们喜欢的目录下，再复制unp.h和config.h两个文件到同一个目录下；

执行下面的命令：

技术分享
生成了server和client程序，运行server和client程序如下图，顺利成功：
技术分享
 

第二种：TCP并发服务器程序,每个客户一个子进程

每个客户一个子进程：传统上，并发服务器调用fork派生一个子进程来处理每个客户。这使得服务器可在同一时间为多个客户提供服务。

回射服务器：

1， 客户从标准输入读一行文本，写到服务器上；

2， 服务器从网络输入读此行，并回射给客户；

3， 客户度此回射行并写到标准输出；

  1. #include    "unp.h"  
  2.   
  3. void  
  4. sig_chld(int signo)  
  5. {  
  6.     pid_t   pid;  
  7.     int     stat;  
  8.   
  9.     while ( (pid = waitpid(-1, &stat, WNOHANG)) > 0)  
  10.         printf("child %d terminated\n", pid);  
  11.     return;  
  12. }  
  13.   
  14. int  
  15. main(int argc, char **argv)  
  16. {  
  17.     int                 listenfd, connfd;  
  18.     pid_t               childpid;  
  19.     socklen_t           clilen;  
  20.     struct sockaddr_in  cliaddr, servaddr;  
  21.     void                sig_chld(int);  
  22.   
  23.     listenfd = Socket(AF_INET, SOCK_STREAM, 0);  
  24.   
  25.     bzero(&servaddr, sizeof(servaddr));  
  26.     servaddr.sin_family      = AF_INET;  
  27.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  
  28.     servaddr.sin_port        = htons(SERV_PORT);  
  29.   
  30.     Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));  
  31.   
  32.     Listen(listenfd, LISTENQ);  
  33.   
  34.     Signal(SIGCHLD, sig_chld);  /* must call waitpid() */  
  35.   
  36.     for ( ; ; ) {  
  37.         clilen = sizeof(cliaddr);  
  38.         if ( (connfd = accept(listenfd, (SA *) &cliaddr, &clilen)) < 0) {  
  39.             if (errno == EINTR)  
  40.                 continue;       /* back to for() */  
  41.             else  
  42.                 err_sys("accept error");  
  43.         }  
  44.   
  45.         if ( (childpid = Fork()) == 0) {    /* child process */  
  46.             Close(listenfd);    /* close listening socket */  
  47.             str_echo(connfd);   /* process the request */  
  48.             exit(0);  
  49.         }  
  50.         Close(connfd);          /* parent closes connected socket */  
  51.     }  
  52. }  
  1. str_echo.c:  
  1. <p>#include "unp.h"</p><p>void  
  2. str_echo(int sockfd)  
  3. {  
  4.  ssize_t  n;  
  5.  char  buf[MAXLINE];</p><p>again:  
  6.  while ( (n = read(sockfd, buf, MAXLINE)) > 0)  
  7.   Writen(sockfd, buf, n);</p><p> if (n < 0 && errno == EINTR)  
  8.   goto again;  
  9.  else if (n < 0)  
  10.   err_sys("str_echo: read error");  
  11. }</p>  

注意：上面的Signal(SIGCHLD, sig_chld);是为了捕捉信号SIGCHLD并处理僵尸进程，有关僵尸进程的介绍请大家参看博文unix网络编程之基本套接口编程while ( (pid = waitpid(-1, &stat, WNOHANG)) > 0),这里我们不能用wait，由于wait会阻塞于没有子进程终止的情况所有不能用while循环每个终止信号。

客户端程序：

  1. #include    "unp.h"  
  2.   
  3. int  
  4. main(int argc, char **argv)  
  5. {  
  6.     int                 sockfd;  
  7.     struct sockaddr_in  servaddr;  
  8.   
  9.     if (argc != 2)  
  10.         err_quit("usage: tcpcli <IPaddress>");  
  11.   
  12.     sockfd = Socket(AF_INET, SOCK_STREAM, 0);  
  13.   
  14.     bzero(&servaddr, sizeof(servaddr));  
  15.     servaddr.sin_family = AF_INET;  
  16.     servaddr.sin_port = htons(SERV_PORT);  
  17.     Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);  
  18.   
  19.     Connect(sockfd, (SA *) &servaddr, sizeof(servaddr));  
  20.   
  21.     str_cli(stdin, sockfd);     /* do it all */  
  22.   
  23.     exit(0);  
  24. }  

str_cli.c:

  1. #include    "unp.h"  
  2.   
  3. void  
  4. str_cli(FILE *fp, int sockfd)  
  5. {  
  6.     char    sendline[MAXLINE], recvline[MAXLINE];  
  7.   
  8.     while (Fgets(sendline, MAXLINE, fp) != NULL) {  
  9.   
  10.         Writen(sockfd, sendline, strlen(sendline));  
  11.   
  12.         if (Readline(sockfd, recvline, MAXLINE) == 0)  
  13.             err_quit("str_cli: server terminated prematurely");  
  14.   
  15.         Fputs(recvline, stdout);  
  16.     }  
  17. }  

最后像上面一样编译后运行即可，效果：

技术分享
 
第三种：使用单进程和select/poll的TCP服务器程序

这种方法是用select来处理任意数目的客户的单进程程序，而不是像上面为每个客户派生一个子进程，在给出具体代码之前，让我们介绍一下背景知识，以及对用以跟踪客户的数据结构进行仔细的分析；

如果一个或多个I/O条件满足（例如，输入已准备好被读，或者描述字可以承接更多的输出）时，我们就被通知到。这个能力被称为I/O复用，是由函数select和poll支持的。

 

先介绍一下各种I/O模型：

阻塞I/O，非阻塞I/O，I/O复用，信号驱动I/O（SIGIO），异步I/O

对于一个套接口上的输入操作，第一步一般是等待数据到达网络，当分组到达时，它被拷贝到内核中的某个缓冲区，第二步是将数据从内核缓冲区拷贝到应用缓冲区。

技术分享

select函数：

这个函数运行进程指示内核等待多个事件中的任一个发生，并仅在一个或多个事件发生或经过某指定的时间后才唤醒。

作为一个例子，我们可以调用函数select并通知内核仅在下列情况发生时才返回：

集合{1，4,5}中的任何描述字准备好读，或

集合{2,7}中任何描述字准备好些，或

集合{1,4}中的任何描述字有异常条件待处理，或

已经过了10.2秒

也就是说通知内核我们对哪些描述字感兴趣以及等待多长时间我们所关心的描述字不受限于套接口任何描述字都可用select来测试.

数据结构图示：

技术分享

 其中client[]用来揭露已连接描述字，而reset为读描述字集。

服务器程序：

  1. /* include fig01 */  
  2. #include    "unp.h"  
  3.   
  4. int  
  5. main(int argc, char **argv)  
  6. {  
  7.     int                 i, maxi, maxfd, listenfd, connfd, sockfd;  
  8.     int                 nready, client[FD_SETSIZE];  
  9.     ssize_t             n;  
  10.     fd_set              rset, allset;  
  11.     char                buf[MAXLINE];  
  12.     socklen_t           clilen;  
  13.     struct sockaddr_in  cliaddr, servaddr;  
  14.   
  15.     listenfd = Socket(AF_INET, SOCK_STREAM, 0);  
  16.   
  17.     bzero(&servaddr, sizeof(servaddr));  
  18.     servaddr.sin_family      = AF_INET;  
  19.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  
  20.     servaddr.sin_port        = htons(SERV_PORT);  
  21.   
  22.     Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));  
  23.   
  24.     Listen(listenfd, LISTENQ);  
  25.   
  26.     maxfd = listenfd;           /* initialize */  
  27.     maxi = -1;                  /* index into client[] array */  
  28.     for (i = 0; i < FD_SETSIZE; i++)  
  29.         client[i] = -1;         /* -1 indicates available entry */  
  30.     FD_ZERO(&allset);  
  31.     FD_SET(listenfd, &allset);  
  32. /* end fig01 */  
  33.   
  34. /* include fig02 */  
  35.     for ( ; ; ) {  
  36.         rset = allset;      /* structure assignment */  
  37.         nready = Select(maxfd+1, &rset, NULL, NULL, NULL);  
  38.   
  39.         if (FD_ISSET(listenfd, &rset)) {    /* new client connection */  
  40.             clilen = sizeof(cliaddr);  
  41.             connfd = Accept(listenfd, (SA *) &cliaddr, &clilen);  
  42. #ifdef  NOTDEF  
  43.             printf("new client: %s, port %d\n",  
  44.                     Inet_ntop(AF_INET, &cliaddr.sin_addr, 4, NULL),  
  45.                     ntohs(cliaddr.sin_port));  
  46. #endif  
  47.   
  48.             for (i = 0; i < FD_SETSIZE; i++)  
  49.                 if (client[i] < 0) {  
  50.                     client[i] = connfd; /* save descriptor */  
  51.                     break;  
  52.                 }  
  53.             if (i == FD_SETSIZE)  
  54.                 err_quit("too many clients");  
  55.   
  56.             FD_SET(connfd, &allset);    /* add new descriptor to set */  
  57.             if (connfd > maxfd)  
  58.                 maxfd = connfd;         /* for select */  
  59.             if (i > maxi)  
  60.                 maxi = i;               /* max index in client[] array */  
  61.   
  62.             if (--nready <= 0)  
  63.                 continue;               /* no more readable descriptors */  
  64.         }  
  65.   
  66.         for (i = 0; i <= maxi; i++) {    /* check all clients for data */  
  67.             if ( (sockfd = client[i]) < 0)  
  68.                 continue;  
  69.             if (FD_ISSET(sockfd, &rset)) {  
  70.                 if ( (n = Read(sockfd, buf, MAXLINE)) == 0) {  
  71.                         /*4connection closed by client */  
  72.                     Close(sockfd);  
  73.                     FD_CLR(sockfd, &allset);  
  74.                     client[i] = -1;  
  75.                 } else  
  76.                     Writen(sockfd, buf, n);  
  77.   
  78.                 if (--nready <= 0)  
  79.                     break;              /* no more readable descriptors */  
  80.             }  
  81.         }  
  82.     }  
  83. }  
  84. /* end fig02 */  

使用poll的服务器程序：

  1. /* include fig01 */  
  2. #include    "unp.h"  
  3. #include    <limits.h>        /* for OPEN_MAX */  
  4.   
  5. int  
  6. main(int argc, char **argv)  
  7. {  
  8.     int                 i, maxi, listenfd, connfd, sockfd;  
  9.     int                 nready;  
  10.     ssize_t             n;  
  11.     char                buf[MAXLINE];  
  12.     socklen_t           clilen;  
  13.     struct pollfd       client[OPEN_MAX];  
  14.     struct sockaddr_in  cliaddr, servaddr;  
  15.   
  16.     listenfd = Socket(AF_INET, SOCK_STREAM, 0);  
  17.   
  18.     bzero(&servaddr, sizeof(servaddr));  
  19.     servaddr.sin_family      = AF_INET;  
  20.     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);  
  21.     servaddr.sin_port        = htons(SERV_PORT);  
  22.   
  23.     Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));  
  24.   
  25.     Listen(listenfd, LISTENQ);  
  26.   
  27.     client[0].fd = listenfd;  
  28.     client[0].events = POLLRDNORM;  
  29.     for (i = 1; i < OPEN_MAX; i++)  
  30.         client[i].fd = -1;      /* -1 indicates available entry */  
  31.     maxi = 0;                   /* max index into client[] array */  
  32. /* end fig01 */  
  33.   
  34. /* include fig02 */  
  35.     for ( ; ; ) {  
  36.         nready = Poll(client, maxi+1, INFTIM);  
  37.   
  38.         if (client[0].revents & POLLRDNORM) {   /* new client connection */  
  39.             clilen = sizeof(cliaddr);  
  40.             connfd = Accept(listenfd, (SA *) &cliaddr, &clilen);  
  41. #ifdef  NOTDEF  
  42.             printf("new client: %s\n", Sock_ntop((SA *) &cliaddr, clilen));  
  43. #endif  
  44.   
  45.             for (i = 1; i < OPEN_MAX; i++)  
  46.                 if (client[i].fd < 0) {  
  47.                     client[i].fd = connfd;  /* save descriptor */  
  48.                     break;  
  49.                 }  
  50.             if (i == OPEN_MAX)  
  51.                 err_quit("too many clients");  
  52.   
  53.             client[i].events = POLLRDNORM;  
  54.             if (i > maxi)  
  55.                 maxi = i;               /* max index in client[] array */  
  56.   
  57.             if (--nready <= 0)  
  58.                 continue;               /* no more readable descriptors */  
  59.         }  
  60.   
  61.         for (i = 1; i <= maxi; i++) {    /* check all clients for data */  
  62.             if ( (sockfd = client[i].fd) < 0)  
  63.                 continue;  
  64.             if (client[i].revents & (POLLRDNORM | POLLERR)) {  
  65.                 if ( (n = read(sockfd, buf, MAXLINE)) < 0) {  
  66.                     if (errno == ECONNRESET) {  
  67.                             /*4connection reset by client */  
  68. #ifdef  NOTDEF  
  69.                         printf("client[%d] aborted connection\n", i);  
  70. #endif  
  71.                         Close(sockfd);  
  72.                         client[i].fd = -1;  
  73.                     } else  
  74.                         err_sys("read error");  
  75.                 } else if (n == 0) {  
  76.                         /*4connection closed by client */  
  77. #ifdef  NOTDEF  
  78.                     printf("client[%d] closed connection\n", i);  
  79. #endif  
  80.                     Close(sockfd);  
  81.                     client[i].fd = -1;  
  82.                 } else  
  83.                     Writen(sockfd, buf, n);  
  84.   
  85.                 if (--nready <= 0)  
  86.                     break;              /* no more readable descriptors */  
  87.             }  
  88.         }  
  89.     }  
  90. }  
  91. /* end fig02 */  

 

客服端程序：

  1. #include    "unp.h"  
  2.   
  3. void  
  4. str_cli1(FILE *fp, int sockfd)  
  5. {  
  6.     int         maxfdp1, stdineof;  
  7.     fd_set      rset;  
  8.     char        buf[MAXLINE];  
  9.     int     n;  
  10.   
  11.     stdineof = 0;  
  12.     FD_ZERO(&rset);  
  13.     for ( ; ; ) {  
  14.         if (stdineof == 0)  
  15.             FD_SET(fileno(fp), &rset);  
  16.         FD_SET(sockfd, &rset);  
  17.         maxfdp1 = max(fileno(fp), sockfd) + 1;  
  18.         Select(maxfdp1, &rset, NULL, NULL, NULL);  
  19.   
  20.         if (FD_ISSET(sockfd, &rset)) {  /* socket is readable */  
  21.             if ( (n = Read(sockfd, buf, MAXLINE)) == 0) {  
  22.                 if (stdineof == 1)  
  23.                     return;     /* normal termination */  
  24.                 else  
  25.                     err_quit("str_cli: server terminated prematurely");  
  26.             }  
  27.   
  28.             Write(fileno(stdout), buf, n);  
  29.         }  
  30.   
  31.         if (FD_ISSET(fileno(fp), &rset)) {  /* input is readable */  
  32.             if ( (n = Read(fileno(fp), buf, MAXLINE)) == 0) {  
  33.                 stdineof = 1;  
  34.                 Shutdown(sockfd, SHUT_WR);  /* send FIN */  
  35.                 FD_CLR(fileno(fp), &rset);  
  36.                 continue;  
  37.             }  
  38.   
  39.             Writen(sockfd, buf, n);  
  40.         }  
  41.     }  
  42. }  
  43.   
  44. int  
  45. main(int argc, char **argv)  
  46. {  
  47.     int                 sockfd;  
  48.     struct sockaddr_in  servaddr;  
  49.   
  50.     if (argc != 2)  
  51.         err_quit("usage: tcpcli <IPaddress>");  
  52.   
  53.     sockfd = Socket(AF_INET, SOCK_STREAM, 0);  
  54.   
  55.     bzero(&servaddr, sizeof(servaddr));  
  56.     servaddr.sin_family = AF_INET;  
  57.     servaddr.sin_port = htons(SERV_PORT);  
  58.     Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);  
  59.   
  60.     Connect(sockfd, (SA *) &servaddr, sizeof(servaddr));  
  61.   
  62.     str_cli1(stdin, sockfd);        /* do it all */  
  63.   
  64.     exit(0);  
  65. }  

这里客服端程序用了shutdown关闭套接口来代替close；下面就来介绍一下两者的区别：

shutdown可以分别关闭读写或者同时关闭读写

如果关闭读，则接受缓冲区的未读出的所有数据都将丢失，以后不会再接受任何数据

如果关闭写，如果输出缓冲区内有数据，则所有的数据将发送出去后将发送一个FIN信号

而close则是关闭该socket，马上发送FIN信号，所有的未完成发送或者接受的数据都将被丢失

对于慢速网络，应该先进行shutdown，然后一定的时间延迟，再close该socket.

(在你已经发送成功后，而对方如果没有接受完毕，你此时如果关闭socket则对方将收到FIN信号，将不能在接收数据，因此容易出现数据丢失的问题，这是 我以前写聊天室时遇到的一个错误，客户端经常报一个与服务器的连接被重置，后来加了一个时间延迟就好了)

#include<sys/socket.h>

int shutdown(int sockfd,int how);

how 的方式有三种分别是

SHUT_RD（0）：关闭sockfd上的读功能，此选项将不允许sockfd进行读操作。

SHUT_WR（1）： 关闭sockfd的写功能，此选项将不允许sockfd进行写操作。

SHUT_RDWR（2）：关闭sockfd的读写功能。

成 功则返回0，错误返回-1，错误码errno：EBADF表示sockfd不是一个有效描述符；ENOTCONN表示sockfd未连 接；ENOTSOCK表示sockfd是一个文件描述符而不是socket描述符。

close的定义如下：

#include<unistd.h>

int close(int fd);

关闭读写。

成功则返回0，错误返回-1，错误码errno：EBADF表示fd不是一个有效 描述符；EINTR表示close函数被信号中断；EIO表示一个IO错误。

下面摘用网上的一段话来说明二者的区别：

close----- 关闭本进程的socket id，但链接还是开着的，用这个socket id的其它进程还能用这个链接，能读或写这个socket id

shutdown-- 则破坏了socket 链接，读的时候可能侦探到EOF结束符，写的时候可能会收到一个SIGPIPE信号.

1>. 如果有多个进程共享一个套接字，close每被调用一次，计数减1，直到计数为0时，也就是所用进程都调用了close，套接字将被释放。

2>. 在多进程中如果一个进程中shutdown(sfd, SHUT_RDWR)后其它的进程将无法进行通信. 如果一个进程close(sfd)将不会影响到其它进程

 

拒绝服务性攻击：

当一个服务器正在处理多个客户时，服务器决不能阻塞于只与单个客户相关函数调用。如果这样的话，服务器悬挂并拒绝为所有其他客户提供服务，这称为拒绝服务攻击,当一个服务器正在处理多个客户时，服务器决不能阻塞于只与单个客户相关的函数调用。如果这样的话，服务器将悬挂并拒绝为所有其他客户提供服务，这称为拒绝服务型攻击。可能解决的办法有：使用非阻塞I/O模型；让每个客户由单独的控制线程提供服务；对I/O操作设置超时；

非阻塞I/O：

缺省状态下，套接口是阻塞方式的。这意味着当一个套接口调用不能立即完成时，进程进入睡眠状态，等待操作的完成。我们将可能阻塞的套接口调用分成四种。

技术分享

技术分享

技术分享

非阻塞connect：

在一个TCP套接口被设置为非阻塞后调用connect，connect会立即返回一个EINPROCESS错误，但TCP的三路握手继续进行。在这之后我们可以用select检查这个链接是否建立成功。

 

版权声明：本文为博主http://www.zuiniusn.com原创文章，未经博主允许不得转载。

unix网络编程各种TCP客户-服务器程序设计实例附环境搭建和编译方法（一）

标签：struts

原文地址：http://blog.csdn.net/u013948190/article/details/46848497
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！