简介
这是我在做一个要用UDP方式进行数据传输时，自己写的一个多线程的UDP数据接收服务器，
它能将接收到的UDP数据包存成文件，并提供数据包接收时间监测；
还支持键盘命令响应，以将数据写到新的文件，和退出程序；
闲言少述，直接上代码;


代码：
/*
 ******************************************************************************
 * \File
 *   udp_server.c
 * \Descript
 *   Receive udp datas and write into file, implement by multi-threads
 * \Author
 *   Anderson Yan
 * \Create
 *   2013-9-18
 ******************************************************************************
 */


#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <pthread.h>
#include <sys/time.h>
#include <unistd.h>


#include <getopt.h>
/* For signal response */
#include <signal.h>
#include <limits.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <termios.h>


static struct termios oldtty;
static int q_pressed = 0;
static int verbose = 0;
static int using_stdin = 0;
static int run_as_daemon = 0;




static volatile int received_sigterm = 0;


static void term_init(void);
static void term_exit(void);
static void sigterm_handler(int sig);
static int read_key(void);
/* end */


/* For parsing command-line parameters */
extern char* optarg;
extern int   opterr;
struct option opts[] = 
{
  {"port", required_argument, NULL, 'p'},
  {"out",  required_argument, NULL, 'o'},
  {"help", required_argument, NULL, 'h'},
  {0,0,0,0}
};


int parse_params(int agrc, char** argv, int* port, char* f);
/* end */


#define SERVPORT 10000
#define MAXDATASIZE 2048
FILE* fp_udp = NULL;
void *sock_recv_udp(void *arg);


static int bTerminalFlag = 0;
​

int main(int argc, char** argv)
{
  int file_number = 0;
  int  udp_port = SERVPORT;
  char filename[128] = "test.dat";
  char filename_new[256] = {0};


  int res;
  pthread_t tid_sock;
  void *thread_result;


  /* 命令行输入参数解析 */
  if (argc < 2)
  {
    printf("Usage: \n");
    printf("-p port : set listern port\n");
    printf("-o file : set output filename\n");
    printf("-h      : print help infomation\n");
    printf("eg :\n");
    printf("$./udp_server -p 10001 -o test.dat\n"); 
    exit(1);
  }
  parse_params(argc, argv, &udp_port, filename); 


  /* SIGNAL，键盘命令响应的初始化 */
  int key;
  if (!using_stdin)
  {
    if (verbose >=0)
      printf("Press [q] to stop, [?] for help, [n] for creating new file\n");
  }
  term_init();
  /* end */


  fp_udp = fopen(filename, "wb");
  if (fp_udp == NULL)
  {
    perror("Open file failed");
    exit(EXIT_FAILURE);
  }


  res = pthread_create(&tid_sock, NULL, sock_recv_udp, (void*)&udp_port);
  if (res != 0)
  {
    perror("Thread creation failed");
    exit(EXIT_FAILURE);
  }


  /* Response for keyboard */
  for(; received_sigterm == 0;)
  {
    if (verbose != file_number)
    {
      file_number = verbose;
      bTerminalFlag = 0;
      snprintf(filename_new, sizeof(filename_new),"%s.%d",filename, file_number);
      printf("Create new file : %s\n", filename_new);


      fp_udp = fopen(filename_new, "wb");
      if (fp_udp == NULL)
      {
        perror("Open file failed");
        exit(EXIT_FAILURE);
      }


      res = pthread_create(&tid_sock, NULL, sock_recv_udp, (void*)&udp_port);
      if (res != 0)
      {
        perror("Thread creation failed");
        exit(EXIT_FAILURE);
      }
    }
    /* if 'q' pressed, exits */
    if (!using_stdin)
    {
      if (q_pressed)
        break;


      /* read_key() returns 0 on EOF */
      key = read_key();
      if (key == 'q')
      {
        printf("quit\n");
        bTerminalFlag = 1;
        break;
      }
      if (key == 'n')
      {
        verbose++;
        printf("verbose = %d\n", verbose);


        bTerminalFlag = 1;
        printf("Waiting for thread to finish...\n");
        res = pthread_join(tid_sock, &thread_result);
        if (res != 0)
        {
          perror("Thread join failed");
          exit(EXIT_FAILURE);
        }
        printf("Thread joined, it returned %s\n", (char*)thread_result);


        memset(filename_new, 0, sizeof(filename_new));
        fflush(fp_udp);
        fclose(fp_udp);
      }
      if (key == '?')
      {
        printf("key function\n"
               "? show this help\n"
               "n create new file\n"
               "q quit\n");
      }
    }
  }
  /* end */


  printf("Waiting for thread to finish...\n");
  res = pthread_join(tid_sock, &thread_result);
  if (res != 0)
  {
    perror("Thread join failed");
    exit(EXIT_FAILURE);
  }
  printf("Thread joined, it returned %s\n", (char*)thread_result);


  fflush(fp_udp);
  fclose(fp_udp);


  return 0;
}




void *sock_recv_udp(void *arg)
{
  int port = *(int*)arg;


  int sockfd, recvbytes;
  char rcv_buf[MAXDATASIZE], snd_buf[MAXDATASIZE];
  struct sockaddr_in server_addr;
  socklen_t addr_size=sizeof(server_addr);
  int pkt_cnt = 0;


  struct timeval start_time, end_time;
  double time_used;


  int optval;
  printf("PORT : %d\n", port);


  if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
  {
    perror("socket:");
    exit(1);
  }


  server_addr.sin_family = AF_INET;
  server_addr.sin_port = htons(port);
  server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
  memset(&(server_addr.sin_zero), 0, 8);


  if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(struct sockaddr))==-1)
  {
    perror("bind:");
    exit(1);
  }


  optval = 1;
  int ret = setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));


  while(!bTerminalFlag)
  {
    addr_size = sizeof(struct sockaddr);
    gettimeofday(&start_time, 0);


    /* receive the data from "server_addr" by "sockfd" and store into "rcv_buf" */
    if ((recvbytes = recvfrom(sockfd, rcv_buf, MAXDATASIZE, 0,
(struct sockaddr*)&server_addr, &addr_size)) == -1)
    {
      perror("recv:");
      exit(1);
    }


    fwrite(rcv_buf, 1, recvbytes, fp_udp);
    fflush(fp_udp);


    gettimeofday(&end_time, 0);
    time_used = 1000000 * (end_time.tv_sec - start_time.tv_sec)
                + end_time.tv_usec - start_time.tv_usec;
    time_used /= 1000;
    printf("recv:%s:%d : pkt_cnt = %6d :  %4d bytes : time(ms) = %f\n", 
  inet_ntoa(server_addr.sin_addr), ntohs(server_addr.sin_port), 
  pkt_cnt, recvbytes, time_used);


    pkt_cnt++;
  }
  close(sockfd);


  pthread_exit("thread sock_recv_udp over\n");
}


完整的代码可以在这里下载:
http://download.csdn.net/detail/fireroll/6286649

​

一、TCP概述


TCP（Transmission Control Protocol 传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。



TCP 具有以下特点：

1）电话系统服务模式的抽象

2）每一次完整的数据传输都要经过建立连接、使用连接、终止连接的过程

3）可靠、出错重传、且每收到一个数据都要给出相应的确认，保证数据传输的可靠性


                                    

二、TCP 编程的 C/S 架构


基于 TCP 的网络编程开发分为服务器端和客户端两部分，常见的核心步骤和流程如下：


                                       

三、TCP 客户端编程


对于 TCP 客户端编程流程，有点类似于打电话过程：

1.找个可以通话的手机(socket() )

2.拨通对方号码并确定对方是自己要找的人（ connect() ）

3.主动聊天（ send() 或 write() ）

4.或者，接收对方的回话（ recv() 或read() ）

5.通信结束后，双方说再见挂电话（close() ）

所需头文件：#include <sys/socket.h>

int socket(int family,int type,int protocol);

功能：

创建一个用于网络通信的 socket套接字（描述符），详细用法，请看《套接字的介绍》

参数：


family：本示例写 AF_INET，代表 IPv4

type：本示例写 SOCK_STREAM，代表 TCP 数据流

protocol：这里写 0，设为 0 表示使用默认协议


返回值：


成功：套接字

失败 < 0 


int connect( int sockfd, const struct sockaddr *addr, socklen_t len );

功能：


主动跟服务器建立连接，有点类似于，我们给别人电话，主动拨对方的电话号码，具体是怎么一个过程，请《connect()、listen()和accept()三者之间的关系》。


参数：


sockfd：socket()返回的套接字

addr：连接的服务器地址结构

len：地址结构体长度


返回值：


成功：0    

失败：-1


connect() 函数相当于拨号码，只有拨通号码并且确定对方是自己要找的人（三次握手）才能进行下一步的通信。

ssize_t send(int sockfd, const void* buf, size_t nbytes, int flags);

功能：


发送数据，最后一个参数为 0 时，可以用 write() 替代（ send 等同于 write ）。注意：不能用 TCP 协议发送 0 长度的数据包。假如，数据没有发送成功，内核会自动重发。


参数：


sockfd： 已建立连接的套接字

buf： 发送数据的地址

nbytes： 发送缓数据的大小(以字节为单位)

flags： 套接字标志（常为 0）


返回值：


成功：成功发送的字节数

失败 < 0


 



3.1-实例1：tcp 客户端发送数据：



#include <stdio.h>  
#include <unistd.h>  
#include <string.h>  
#include <stdlib.h>  
#include <arpa/inet.h>  
#include <sys/socket.h>  
#include <netinet/in.h>  
int main(int argc,  char *argv[])  
{  
    unsigned short port = 8080;             // 服务器的端口号  
    char *server_ip = "192.168.1.7";       // 服务器ip地址  
      
    if( argc > 1 )       //函数传参，可以更改服务器的ip地址                                   
    {         
        server_ip = argv[1];  
    }     
    if( argc > 2 )      //函数传参，可以更改服务器的端口号                                     
    {  
        port = atoi(argv[2]);  
    }  
  
    int sockfd;  
    sockfd = socket(AF_INET, SOCK_STREAM, 0);// 创建通信端点：套接字  
    if(sockfd < 0)  
    {  
        perror("socket");  
        exit(-1);  
    }  
      
    // 设置服务器地址结构体  
    struct sockaddr_in server_addr;  
    bzero(&server_addr,sizeof(server_addr)); // 初始化服务器地址  
    server_addr.sin_family = AF_INET;   // IPv4  
    server_addr.sin_port = htons(port); // 端口  
    inet_pton(AF_INET, server_ip, &server_addr.sin_addr.s_addr);    // ip  
      
     // 主动连接服务器  
    int err_log = connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));       
    if(err_log != 0)  
    {  
        perror("connect");  
        close(sockfd);  
        exit(-1);  
    }  
      
    char send_buf[512] = {'a','n'};  
    printf("send data to %s:%d\n",server_ip,port);  
    while(1)  
    {  
        printf("send:");  
        fgets(send_buf,sizeof(send_buf),stdin); // 输入内容  
        send_buf[strlen(send_buf)-1]='\0';  
        send(sockfd, send_buf, strlen(send_buf), 0);   // 向服务器发送信息  
    }  
  
    close(sockfd);  
      
    return 0;  
}  
运行结果：




3.2  tcp客户端接收数据，接收来自服务器回显的数据

tcp接收数据会用到recv()

ssize_t recv(int sockfd, void *buf,  size_t nbytes, int flags);

功能：


接收网络数据，默认的情况下，如果没有接收到数据，这个函数会阻塞，直到有数据到来。


参数：


sockfd：套接字

buf：接收网络数据的缓冲区的地址

nbytes：接收缓冲区的大小（以字节为单位）

flags：套接字标志（常为 0 ）


返回值：


成功：成功接收的字节数

失败 < 0


测试代码如下：

#include <stdio.h>  
#include <unistd.h>  
#include <string.h>  
#include <stdlib.h>  
#include <arpa/inet.h>  
#include <sys/socket.h>  
#include <netinet/in.h>  
int main(int argc, char *argv[])  
{  
    unsigned short port = 8080;             // 服务器的端口号  
    char *server_ip = "192.168.1.7";       // 服务器ip地址  
      
    if( argc > 1 )       //函数传参，可以更改服务器的ip地址                                   
    {         
        server_ip = argv[1];  
    }     
    if( argc > 2 )      //函数传参，可以更改服务器的端口号                                     
    {  
        port = atoi(argv[2]);  
    }  
  
    int sockfd;  
    sockfd = socket(AF_INET, SOCK_STREAM, 0);// 创建通信端点：套接字  
    if(sockfd < 0)  
    {  
        perror("socket");  
        exit(-1);  
    }  
      
    // 设置服务器地址结构体  
    struct sockaddr_in server_addr;  
    bzero(&server_addr,sizeof(server_addr)); // 初始化服务器地址  
    server_addr.sin_family = AF_INET;   // IPv4  
    server_addr.sin_port = htons(port); // 端口  
    //inet_pton(AF_INET, server_ip, &server_addr.sin_addr); // ip  
    server_addr.sin_addr.s_addr = inet_addr(server_ip);//与inet_pton等价  
      
     // 主动连接服务器  
    int err_log = connect(sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));       
    if(err_log != 0)  
    {  
        perror("connect");  
        close(sockfd);  
        exit(-1);  
    }  
      
      
    printf("send data to %s:%d\n",server_ip,port);  
      
    char send_buf[512] = "this is send data";  
    printf("send data \"%s \" to %s:%d\n",send_buf,server_ip,port);  
    send(sockfd, send_buf, strlen(send_buf), 0);   // 向服务器发送信息  
      
    char recv_buf[512] = {0};  
    recv(sockfd, recv_buf, sizeof(send_buf), 0); // 接收数据  
    printf("%s\n", recv_buf);  
  
    close(sockfd);  
      
    return 0;  
}  


​​​​​​
运行结果：

采用UDP方式实现数据接收功能，与TCP接收服务器功能一致。但没有accep和listen操作。
#include "stdafx.h"
#include "ace/ace.h"
#include "ace/SOCK_Dgram.h"
#include "ace/INET_Addr.h"
#include "ace/Log_Msg.h"
#include "ace/OS.h"
#define BUF_SIZE 11
/*
*UDP数据接收端
*此程序负责接收来自UDP数据发送端的数据，并将其显示在输出设备上。
*采用一个ACE_SOCK_Dgram和两个ACE_INET_Addr对象
*调用recv函数后程序进入等待状态，直到有客户端发送的UDP数据到达。
*/
class UDPServer
{
public:
	UDPServer(int nPort):iaLocal(nPort),sdDgram(iaLocal)
	{}
	~UDPServer(){}
	//接收来自UDP客户端发送的数据
	int Recv()
	{
		int nCount = -1;
		memset(szData,0,BUF_SIZE);
		while((nCount = sdDgram.recv(szData,BUF_SIZE,iaRemote)) != -1 || nCount != 0)
		{
			szData[nCount] = 0;
			ACE_DEBUG((LM_DEBUG,ACE_TEXT("%s/n"),szData));
			ACE_OS::sleep(1);
			memset(szData,0,BUF_SIZE);
		}
		return 0;
	}
private:
	char szData[BUF_SIZE];
	ACE_INET_Addr iaLocal;
	ACE_INET_Addr iaRemote;
	ACE_SOCK_Dgram sdDgram;
};
int ACE_TMAIN(int argc, ACE_TCHAR* argv[])
{
	UDPServer udpServer(27002);
	udpServer.Recv();
	return 0;
}

从服务器接收数据
ajax
实际例子具体了解一下


首先了解一下什么是服务器
服务器是能够提供某种服务的机器（计算机）。

常见的服务器有：

文件服务器，数据库服务器，邮件服务器，HTTP服务器，，，等


HTTP服务器

即是网站服务器，主要提供文档（文本、图片、视频、音频）浏览器服务。

HTTP服务器可以结合某一编程语言处理业务逻辑，由此进行的开发，通常称之为服务端开发。

常见的服务端编程语言包括：PHP、Jsp、Asp、Python、Ruby、Perl、NodeJS。对于这些编程语言最少要精确掌握一门

什么是客户端

具有向服务器发出索取服务能力的终端。如手机、电脑等

这是以浏览器为宿主环境，结合HTML、CSS、Javascript的技术，而进行的一系列开发通常称之为前端开发。
网络基础

IP地址：每个连接在互联网上的主机分配的一个地址
域名：一个IP地址对应的一个域名
DNS服务：记录了IP地址和域名的映射关系
端口：是计算机与外界通讯交流的出口，每个端口号对应不同的服务。

:  取值范围从0到655535

ajax
（Asynchronous JavaScript and XML 的简称）是无刷新技术
实际例子具体了解一下

创建请求对象

var xhr = new XMLHttpRequest();

用XMLHttpRequest 通过原生JS代码向服务器发送请求

打开链接

xhr.open("GET", "http://localhost:9000");

get与post的区别

get：若有请求参数，将数据串到地址内

get方式的提交的数据大小有限制

get方式不太安全

post需要将请求数据写入到请求体中

发送请求

 xhr.send();


接收服务器响应（用异步事件响应）

 //当readystate的值发生改变时，会触发该事件
            xhr.onreadystatechange = function () {
                // console.log(this.readyState);
                //服务器响应完毕
                //状态值的变化， 当状态值等于200时，事件顺利执行
                if (this.readyState == 4 && this.status == 200) {
                    // console.log(this.responseText); 
                    //将接收到的服务器数据，显示到控制台
                    document.querySelector('div').innerHTML=this.responseText;
                }
            };