string udp = "0C EF AF C4 07 00 00 01 00 00 0C EF AF C4 07 00 03 2A 02 00 32 30 31 38 36 35 39 31 34 32 33 00 00 00 00 00 02 00 00 00 B9 00 00 00 00 00 00 00 00 01 0C 51 01 5D 5C 4E 00 01 00 01 00 00";

            var arr = Regex.Matches(udp, @"\w{2}").Cast<Match>().Select(s => Convert.ToByte(s.Value, 16)).ToArray();

            Console.WriteLine(Encoding.UTF8.GetString(arr));

   ************************************************************************* 

 > File Name: server.c 

 > Author: SongLee 

 ************************************************************************/

#include<sys/types.h> 

#include<sys/socket.h> 

#include<unistd.h> 

#include<netinet/in.h> 

#include<arpa/inet.h> 

#include<stdio.h> 

#include<stdlib.h> 

#include<errno.h> 

#include<netdb.h> 

#include<stdarg.h> 

#include<string.h> 

  

#define SERVER_PORT 2222 

#define BUFFER_SIZE 1024 

#define FILE_NAME_MAX_SIZE 512 



struct cliprobe_data {

        unsigned char Apmac[6];

        unsigned short int Vendorid;

        unsigned short int Reserved1;

        unsigned char Bssid[6];

        unsigned char Radiotype;

        unsigned char Channel;

        unsigned char Associated;

        unsigned char Messagetype;

        char Timestamp[14];

        unsigned short int Reserved2;

        unsigned char Mutype;

        unsigned short int Reserved3;

        char Rssi;

        unsigned short int Reserved4;

        unsigned char Noisefloor;

        unsigned short int Reserved5;

        unsigned char Datarate;

        unsigned char MPDUflags;

        unsigned char Mumac[6];

        unsigned short int Framecontrol;

        unsigned short int Sequencecontrol;

        unsigned short int Reserved6;

};



int main() 

{ 

 /* 创建UDP套接口 */

 int i;

 struct cliprobe_data *package_data;

 struct sockaddr_in server_addr; 

 bzero(&server_addr, sizeof(server_addr)); 

 server_addr.sin_family = AF_INET; 

 server_addr.sin_addr.s_addr = htonl(INADDR_ANY); 

 server_addr.sin_port = htons(SERVER_PORT); 

  

 /* 创建socket */

 int server_socket_fd = socket(AF_INET, SOCK_DGRAM, 0); 

 if(server_socket_fd == -1) 

 { 

  perror("Create Socket Failed:"); 

  exit(1); 

 } 

  

 /* 绑定套接口 */

 if(-1 == (bind(server_socket_fd,(struct sockaddr*)&server_addr,sizeof(server_addr)))) 

 { 

  perror("Server Bind Failed:"); 

  exit(1); 

 } 

  

 /* 数据传输 */

 while(1) 

 {  

  /* 定义一个地址，用于捕获客户端地址 */

  struct sockaddr_in client_addr; 

  socklen_t client_addr_length = sizeof(client_addr); 

  

  /* 接收数据 */

  char buffer[BUFFER_SIZE]; 

  bzero(buffer, BUFFER_SIZE); 

  if(recvfrom(server_socket_fd, buffer, BUFFER_SIZE,0,(struct sockaddr*)&client_addr, &client_addr_length) == -1) 

  { 

   perror("Receive Data Failed:"); 

   exit(1); 

  } 

  

  /* 从buffer中拷贝出file_name */

  //char file_name[FILE_NAME_MAX_SIZE+1]; 

  //bzero(file_name,FILE_NAME_MAX_SIZE+1); 

  //strncpy(file_name, buffer, strlen(buffer)>FILE_NAME_MAX_SIZE?FILE_NAME_MAX_SIZE:strlen(buffer)); 

  package_data = (struct cliprobe_data *) buffer;

  printf("APMAC:%02X%02X%02X%02X%02X%02X\n", package_data->Apmac[0], package_data->Apmac[1], package_data->Apmac[2], \

                package_data->Apmac[3], package_data->Apmac[4], package_data->Apmac[5]);



  printf("BSSID:%02X%02X%02X%02X%02X%02X\n", package_data->Bssid[0], package_data->Bssid[1], package_data->Bssid[2], \

                package_data->Bssid[3], package_data->Bssid[4], package_data->Bssid[5]);

  printf("Radiotyep:%02X\n", package_data->Radiotype);

  printf("Channel:%d\n", package_data->Channel);

  printf("Timestamp:");

  for (i=0;i<14;i++) {

  	printf("%c", package_data->Timestamp[i]);

  }

  printf("\n");

  printf("Rssi:%d\n", package_data->Rssi);

  printf("Climac:%02X%02X%02X%02X%02X%02X\n", package_data->Mumac[0], package_data->Mumac[1], package_data->Mumac[2], \

                package_data->Mumac[3], package_data->Mumac[4], package_data->Mumac[5]);

 } 

 close(server_socket_fd); 

 return 0; 

} 

 string hexValues = "0C EF AF C4 07 00 00 01 00 00 0C EF AF C4 07 00 03 2A 02 00 32 30 31 38 36 35 39 31 34 32 33 00 00 00 00 00 02 00 00 00 B9 00 00 00 00 00 00 00 00 01 0C 51 01 5D 5C 4E 00 01 00 01 00 00";

 string[] hexValuesSplit = hexValues.Split(' ');



 private string HexStringToString(string hs)

    {

		//string stringValue=null;

		char charValue=null;		

		foreach (String hex in hs)

		{

		// Convert the number expressed in base-16 to an integer.

		int value = Convert.ToInt32(hex, 16);

		// Get the character corresponding to the integral value.

		//stringValue =+ Char.ConvertFromUtf32(value);

		charValue =+ (char)value;			

		}

		return charValue;

      

    }

            string udp = "0C EF AF C4 07 00 00 01 00 00 0C EF AF C4 07 00 03 2A 02 00 32 30 31 38 36 35 39 31 34 32 33 00 00 00 00 00 02 00 00 00 B9 00 00 00 00 00 00 00 00 01 0C 51 01 5D 5C 4E 00 01 00 01 00 00";

            var b = udp.Split(' ').Select(x => Convert.ToByte(x, 16)).ToArray();

            Console.WriteLine("结构长:{0}", Marshal.SizeOf(new cliprobe_data()));

            var obj = (cliprobe_data)BytesToStuct(b, typeof(cliprobe_data));



            Console.WriteLine("APMAC:{0}", BitConverter.ToString(obj.Apmac,0).Replace("-",""));

            Console.WriteLine("BSSID:{0}", BitConverter.ToString(obj.Bssid, 0).Replace("-", ""));

            Console.WriteLine("Climac:{0}", BitConverter.ToString(obj.Mumac, 0).Replace("-", ""));

            Console.WriteLine("Timestamp:{0}", new string(obj.Timestamp.Select(c=>(char)c).ToArray()));

结构长:59

APMAC:0CEFAFC40700

BSSID:0CEFAFC40700

Climac:0000010C5101

Timestamp:20186591423

        [StructLayoutAttribute(LayoutKind.Sequential, CharSet = CharSet.Ansi, Pack = 1)]

        public struct cliprobe_data

        {

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]

            public byte[] Apmac;

            public UInt16 Vendorid;

            public UInt16 Reserved1;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]

            public byte[] Bssid;

            public byte Radiotype;

            public byte Channel;

            public byte Associated;

            public byte Messagetype;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 14)]

            public byte[] Timestamp;

            public UInt16 Reserved2;

            public byte Mutype;

            public UInt16 Reserved3;

            public byte Rssi;

            public UInt16 Reserved4;

            public byte Noisefloor;

            public UInt16 Reserved5;

            public byte Datarate;

            public byte MPDUflags;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]

            public byte[] Mumac;

            public UInt16 Framecontrol;

            public UInt16 Sequencecontrol;

            public UInt16 Reserved6;

        }

        //// <summary>

        /// 结构体转byte数组

        /// </summary>

        /// <param name="structObj">要转换的结构体</param>

        /// <returns>转换后的byte数组</returns>

        public static byte[] StructToBytes(object structObj)

        {

            //得到结构体的大小

            int size = Marshal.SizeOf(structObj);

            //创建byte数组

            byte[] bytes = new byte[size];

            //分配结构体大小的内存空间

            IntPtr structPtr = Marshal.AllocHGlobal(size);

            //将结构体拷到分配好的内存空间

            Marshal.StructureToPtr(structObj, structPtr, false);

            //从内存空间拷到byte数组

            Marshal.Copy(structPtr, bytes, 0, size);

            //释放内存空间

            Marshal.FreeHGlobal(structPtr);

            //返回byte数组

            return bytes;

        }



        /// <summary>

        /// byte数组转结构体

        /// </summary>

        /// <param name="bytes">byte数组</param>

        /// <param name="type">结构体类型</param>

        /// <returns>转换后的结构体</returns>

        public static object BytesToStuct(byte[] bytes, Type type)

        {

            //得到结构体的大小

            int size = Marshal.SizeOf(type);

            //byte数组长度小于结构体的大小

            if (size > bytes.Length)

            {

                //返回空

                return null;

            }

            //分配结构体大小的内存空间

            IntPtr structPtr = Marshal.AllocHGlobal(size);

            //将byte数组拷到分配好的内存空间

            Marshal.Copy(bytes, 0, structPtr, size);

            //将内存空间转换为目标结构体

            object obj = Marshal.PtrToStructure(structPtr, type);

            //释放内存空间

            Marshal.FreeHGlobal(structPtr);

            //返回结构体

            return obj;

        }