vxworks下socket编程 TCP 通信

时间：2025-03-12 21:10:14

vxworks 下socket编程 TCP 通信头文件 

#ifndef  _INC_TCPSOCKET_H
#define  _INC_TCPSOCKET_H

 

#ifdef  _cplusplus

   extern   "C"  {

#endif
   
#include<>
#include <>
   
#define SERVER_PORT_NUM 5432 /* server's port number for bind() */
#define SERVER_WORK_PRIORITY 100 /* priority of server's work task */
#define SERVER_STACK_SIZE 10000 /* stack size of server's work task */
#define SERVER_MAX_CONNECTIONS 4 /* max clients connected at a time */
#define REQUEST_MSG_SIZE 1024 /* max size of request message */
#define REPLY_MSG_SIZE 500 /* max size of reply message */
/* structure for requests from clients to server */
   
   
  
struct request
{
int reply; /* TRUE = request reply from server */
int msgLen; /* length of message text */
char message[REQUEST_MSG_SIZE]; /* message buffer */
};

 


#ifdef __cplusplus
}
#endif
  
#endif



vxworks下socket编程 TCP 通信服务器端 . 

#ifndef  _INC_TCPSOCKET_SERVER_H
#define  _INC_TCPSOCKET_SERVER_H

 

#ifdef  _cplusplus

   extern   "C"  {

#endif
   
#include ""
#include ""
#include ""     //inet_
#include ""     //包含sockaddr
#include ""
#include ""
#include ""
#include ""
#include ""
#include ""

/* function declarations */
VOID tcpServerWorkTask (int sFd, char * address, u_short port);
/****************************************************************************
*
* tcpServer - accept and process requests over a TCP socket
*
* This routine creates a TCP socket, and accepts connections over the socket
* from clients. 【Each client connection is handled by spawning a separate
* task to handle client requests.】
*
* This routine may be invoked as follows:
* -> sp tcpServer
* task spawned: id = 0x3a6f1c, name = t1
* value = 3829532 = 0x3a6f1c
* -> MESSAGE FROM CLIENT (Internet Address 150.12.0.10, port 1027):
* Hello out there
*
* RETURNS: Never, or ERROR if a resources could not be allocated.
*/


typedef  int STATUS  ;

 

STATUS tcpServer (void)
{

struct sockaddr_in serverAddr;
struct sockaddr_in clientAddr;

int sockAddrSize;
int sFd;
int newFd;
int ix = 0;
char workName[16];

/* set up the local address */
sockAddrSize = sizeof (struct sockaddr_in);
bzero ((char *) &serverAddr, sockAddrSize);
//memset(void *)&serverAddr,0, sockAddrSize);

serverAddr.sin_family = AF_INET;
//serverAddr.sin_len = (u_char) sockAddrSize;
serverAddr.sin_port = htons (SERVER_PORT_NUM);
//serverAddr.sin_port = htons (0);  /*----看下这样配置是什么效果---*/

serverAddr.sin_addr.s_addr = htonl (INADDR_ANY);   /*---server  上的任意地址---*/

//serverAddr.sin_addr.s_addr = htonl ("10.168.7.1");

/* create a TCP-based socket */
if ((sFd = socket (AF_INET, SOCK_STREAM, 0)) == ERROR)    /*---这里有个flag 可以设置---*/
{
     printf("creat socket error\n");
 
      return (ERROR);
}
/* bind socket to local address */
if (bind (sFd, (struct sockaddr *) &serverAddr, sockAddrSize) == ERROR)
{
        printf("server bind error\n");
        close (sFd);  /*---绑定失败要关掉socket-----*/
     return (ERROR);
}

/* create queue for client connection requests */
if (listen (sFd, SERVER_MAX_CONNECTIONS) == ERROR)      /*---一次监听4个---*/
{
    printf("listen error\n");
     close (sFd);
      return (ERROR);
}
/* accept new connect requests and spawn tasks to process them */


FOREVER
{

  /*--accept  成功会返回一个新的socket id ，原来的id  继续监听链路上的要求---*/
if ((newFd = accept (sFd, (struct sockaddr *) &clientAddr,   /*----这里保存客户端的地址，但是并没有初始化---*/
&sockAddrSize)) == ERROR)
{
    printf("accept error\n");
    close (sFd);
    return (ERROR);
}

# if 0
else
{
   /*--这里打印下客户端的地址信息，验证下----*/
 printf("client sockaddress info :\n");
    printf("client address : %s\t   port  %d\n ",inet_ntoa (clientAddr.sin_addr),ntohs (clientAddr.sin_port));

     /*---端口号是50043，ip地址是“10.168.7.1”----*/ 
   
     /*----这里还说明了客户端和服务器端的端口号是不同的，基于不同的端口发消息---*/
}

#endif

sprintf (workName, "tTcpWork%d", ix++);
printf("workName %s\n",workName);

if (taskSpawn(workName, SERVER_WORK_PRIORITY, 0, SERVER_STACK_SIZE,
(FUNCPTR) tcpServerWorkTask, newFd,
(int) inet_ntoa (clientAddr.sin_addr), ntohs (clientAddr.sin_port),   /*---终于明白了，这里的三个参数传递---*/
0, 0, 0, 0, 0, 0, 0) == ERROR)
{
/* if taskSpawn fails, close fd and return to top of loop */
    printf("tcptask creat failed\n");
    close (newFd);
}
}
}

#if 0

/****************************************************************************
*
* tcpServerWorkTask - process client requests
*
* This routine reads from the server's socket, and processes client
* requests. If the client requests a reply message, this routine
* will send a reply to the client.
*
* RETURNS: N/A.
*/

VOID tcpServerWorkTask
(
int sFd, /* server's socket fd */
char * address, /* client's socket address */
u_short port /* client's socket port */
)
{


char recvbuf[2048];

int recvbytes;


while(1)
{

  recvbytes= recv(sFd, recvbuf, sizeof(recvbuf), 0);

   recvbuf[recvbytes-1]='\0';

   if (recvbytes!=0)
    {
       printf("server recv msg  len %d\n",recvbytes);
   
          printf("msg content  %s\n",recvbuf);
    }
  

   break;
  
 
}
  
  
  
}


#endif

 

 

/****************************************************************************
*
* tcpServerWorkTask - process client requests
*
* This routine reads from the server's socket, and processes client
* requests. If the client requests a reply message, this routine
* will send a reply to the client.
*
* RETURNS: N/A.
*/
VOID tcpServerWorkTask
(
int sFd, /* server's socket fd */
char * address, /* client's socket address */
u_short port /* client's socket port */
)
{

struct request clientRequest; /* request/message from client */
int nRead; /* number of bytes read */
//static char replyMsg[] = "Server received your message";
static  char replyMsg[]="hello,client";
/* read client request, display message */

char recvbuf[2048];

int recvbytes;


while ((nRead = fioRead (sFd, (char *) &clientRequest,
sizeof (clientRequest))) > 0)
{
printf ("MESSAGE FROM CLIENT (Internet Address %s, port %d):\n%s\n",
address, port, );
if ()
if (write (sFd, replyMsg, sizeof (replyMsg)) == ERROR)
perror ("write");
}
if (nRead == ERROR) /* error from read() */
perror ("read");
close (sFd); /* close server socket connection */


}

#ifdef __cplusplus
}
#endif
  
#endif


vxworks下socket编程TCP 客户端  

#ifndef  _INC_TCPSOCKET_CLIENT_H
#define  _INC_TCPSOCKET_CLINET_H

 

#ifdef  _cplusplus

   extern   "C"  {

#endif
   

/*----4.10 基于TCP 的客户端和服务器在板子上顺利调通----
 *
 *  server 是个永久任务，人工启动之后挂起，接收到 client
 * 
 *  的请求后发出响应
 *
 *
 *
 * *************************************************/   
   

/* - TCP client example */
/*
DESCRIPTION
This file contains the client-side of the VxWorks TCP example code.
The example code demonstrates the usage of several BSD 4.4-style
socket routine calls.
*/
/* includes */
#include ""
#include ""
#include ""
#include ""
#include ""
#include ""
#include ""
#include  ""
/****************************************************************************
*
* tcpClient - send requests to server over a TCP socket
*
* This routine connects over a TCP socket to a server, and sends a
* user-provided message to the server. Optionally, this routine
* waits for the server's reply message.
*
* This routine may be invoked as follows:
* -> tcpClient "remoteSystem"
* Message to send:
* Hello out there
* Would you like a reply (Y or N):
* y
* value = 0 = 0x0
* -> MESSAGE FROM SERVER:
* Server received your message
*
* RETURNS: OK, or ERROR if the message could not be sent to the server.
Wind River VxWorks Platforms
Getting Started, 3.8
42
*/
STATUS tcpClient
(
char * serverName /* name or IP address of server */
)
{
struct request myRequest; /* request to send to server */
struct sockaddr_in serverAddr; /* server's socket address */
char replyBuf[REPLY_MSG_SIZE]; /* buffer for reply */
char reply; /* if TRUE, expect reply back */
int sockAddrSize; /* size of socket address structure */
int sFd; /* socket file descriptor */
int mlen; /* length of message */
/* create client's socket */

 

if ((sFd = socket (AF_INET, SOCK_STREAM, 0)) == ERROR)
{
    printf("socket client error\n");
   return (ERROR);
}
/* bind not required - port number is dynamic */


/* build server socket address */

  /*---填充server 地址---*/
sockAddrSize = sizeof (struct sockaddr_in);
bzero ((char *) &serverAddr, sockAddrSize);
serverAddr.sin_family = AF_INET;
serverAddr.sin_len = (u_char) sockAddrSize;
serverAddr.sin_port = htons (SERVER_PORT_NUM);

if (((serverAddr.sin_addr.s_addr = inet_addr (serverName)) == ERROR) &&
((serverAddr.sin_addr.s_addr = hostGetByName (serverName)) == ERROR))
{
   printf("get server address error\n");
  
close (sFd);
return (ERROR);
}
/* connect to server */
if (connect (sFd, (struct sockaddr *) &serverAddr, sockAddrSize) == ERROR)
{
       printf("connet to server error \n");
   
       close (sFd);
       return (ERROR);
}


/* build request, prompting user for message */
printf ("Message to send: \n");
mlen = read (STD_IN, , REQUEST_MSG_SIZE);    /*-------------这个要注意----------------*/
= mlen;
[mlen - 1] = '\0';
printf ("Would you like a reply (Y or N): \n");
read (STD_IN, &reply, 1);
switch (reply)
{
case 'y':
case 'Y': = TRUE;
break;
default: = FALSE;
break;
}
/* send request to server */
if (write (sFd, (char *) &myRequest, sizeof (myRequest)) == ERROR)    /*---这里用的是read ，write 接口---*/
{
    printf("write error\n");
 
     close (sFd);
return (ERROR);
}


if () /* if expecting reply, read and display it */
{
if (read (sFd, replyBuf, REPLY_MSG_SIZE) < 0)
{
       printf("read error\n");
close (sFd);
return (ERROR);
}
printf ("MESSAGE FROM SERVER:\n%s\n", replyBuf);
}
close (sFd);
return (OK);
}


#ifdef __cplusplus
}
#endif
#endif


vxworks的线程及互斥锁 

vxworks5.5开始支持POSIX线程实时扩展

vxworks本质只包括系统和任务两个概念，线程以任务形式实现。线程不属于任何进程，只属于整个系统，因而pthread在整个系统范围内竞争。

<1>vxworks任务在同一实地址空间运行，无任何保护机制，任何任务可以直接访问其他任务数据，POSIX中进程共享相关函数未实现。

<2>vxworks无用户和组概念，无进程概念。


创建 pthread_create

等待 ptherad_join

退出 pthread_exit

[cpp] view plain copy print ?
  1. #include<>    
  2. #include<>    
  3. #include<>   
  4. #include<>   
  5. /*线程1*/  
  6. void thread1() {  
  7.     int i=0;  
  8.   
  9.     while (1) {  
  10.         printf("thread1:%d\n", i);  
  11.         if (i>3)  
  12.             pthread_exit(0);  
  13.         i++;  
  14.         sleep(1);  
  15.     }  
  16. }  
  17.   
  18. /*线程2*/  
  19. void thread2() {  
  20.     int i=0;  
  21.   
  22.     while (1) {  
  23.         printf("thread2:%d\n", i);  
  24.         if (i>5)  
  25.             pthread_exit(0);  
  26.         i++;  
  27.         sleep(1);  
  28.     }  
  29. }  
  30. int taskDemo() {  
  31.     pthread_t t1, t2;  
  32.     /*创建线程*/  
  33.     pthread_create(&t1, NULL, (void *)thread1, NULL);  
  34.     pthread_create(&t2, NULL, (void *)thread2, NULL);  
  35.     /*等待线程退出*/  
  36.     pthread_join(t1, NULL);  
  37.     pthread_join(t2, NULL);  
  38.     return 0;  
  39. }  
#include<> 
#include<> 
#include<>
#include<>
/*线程1*/
void thread1() {
	int i=0;

	while (1) {
		printf("thread1:%d\n", i);
		if (i>3)
			pthread_exit(0);
		i++;
		sleep(1);
	}
}

/*线程2*/
void thread2() {
	int i=0;

	while (1) {
		printf("thread2:%d\n", i);
		if (i>5)
			pthread_exit(0);
		i++;
		sleep(1);
	}
}
int taskDemo() {
	pthread_t t1, t2;
	/*创建线程*/
	pthread_create(&t1, NULL, (void *)thread1, NULL);
	pthread_create(&t2, NULL, (void *)thread2, NULL);
	/*等待线程退出*/
	pthread_join(t1, NULL);
	pthread_join(t2, NULL);
	return 0;
}

运行

thread1:0
thread2:0
thread1:1
thread2:1
thread1:2
thread2:2
thread1:3
thread2:3
thread1:4
thread2:4
thread2:5
thread2:6

 

互斥锁

 互斥锁的操作主要包括以下几个步骤。
· 互斥锁初始化：pthread_mutex_init
· 互斥锁上锁：pthread_mutex_lock
· 互斥锁判断上锁：pthread_mutex_trylock
· 互斥锁接锁：pthread_mutex_unlock
· 消除互斥锁：pthread_mutex_destroy

[cpp] view plain copy print ?
  1. #include<>   
  2. #include<>    
  3. #include<>     
  4. #include<>   
  5. int i=0;/*共享变量*/  
  6. static pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;/*互斥锁*/  
  7.   
  8. void thread1() {  
  9.     int ret;  
  10.   
  11.     while (1) {  
  12.   
  13.         ret=pthread_mutex_trylock(&mutex);/*判断上锁 ret==0 */  
  14.   
  15.         if (ret!=EBUSY) {  
  16.             pthread_mutex_unlock(&mutex);/*解锁*/  
  17.             pthread_mutex_lock(&mutex);/*上锁*/  
  18.             printf("This is thread1:%d\n", i);  
  19.             i++;  
  20.             pthread_mutex_unlock(&mutex);/*解锁*/  
  21.         }  
  22.         sleep(1);  
  23.     }  
  24. }  
  25.   
  26. void thread2() {  
  27.     int ret;  
  28.     while (1) {  
  29.         ret=pthread_mutex_trylock(&mutex);  
  30.         if (ret!=EBUSY) {  
  31.             pthread_mutex_unlock(&mutex);/*解锁*/  
  32.             pthread_mutex_lock(&mutex);  
  33.             printf("This is thread2:%d\n", i);  
  34.             i++;  
  35.             pthread_mutex_unlock(&mutex);  
  36.         }  
  37.         sleep(1);  
  38.     }  
  39. }  
  40. int taskDemo() {  
  41.     pthread_t t1, t2;  
  42.     pthread_mutex_init(&mutex,NULL);  
  43.     pthread_create(&t1, NULL, (void *)thread1, NULL);  
  44.     pthread_create(&t2, NULL, (void *)thread2, NULL);  
  45.   
  46.     pthread_join(t1, NULL);  
  47.     pthread_join(t2, NULL);  
  48.     pthread_mutex_destroy(&mutex);  
  49.     return 0;  
  50. }  
#include<>
#include<> 
#include<>  
#include<>
int i=0;/*共享变量*/
static pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;/*互斥锁*/

void thread1() {
	int ret;

	while (1) {

		ret=pthread_mutex_trylock(&mutex);/*判断上锁 ret==0 */

		if (ret!=EBUSY) {
			pthread_mutex_unlock(&mutex);/*解锁*/
			pthread_mutex_lock(&mutex);/*上锁*/
			printf("This is thread1:%d\n", i);
			i++;
			pthread_mutex_unlock(&mutex);/*解锁*/
		}
		sleep(1);
	}
}

void thread2() {
	int ret;
	while (1) {
		ret=pthread_mutex_trylock(&mutex);
		if (ret!=EBUSY) {
			pthread_mutex_unlock(&mutex);/*解锁*/
			pthread_mutex_lock(&mutex);
			printf("This is thread2:%d\n", i);
			i++;
			pthread_mutex_unlock(&mutex);
		}
		sleep(1);
	}
}
int taskDemo() {
	pthread_t t1, t2;
	pthread_mutex_init(&mutex,NULL);
	pthread_create(&t1, NULL, (void *)thread1, NULL);
	pthread_create(&t2, NULL, (void *)thread2, NULL);

	pthread_join(t1, NULL);
	pthread_join(t2, NULL);
	pthread_mutex_destroy(&mutex);
	return 0;
}


This is thread1:0
This is thread2:1
This is thread1:2
This is thread2:3
This is thread1:4
This is thread2:5
This is thread1:6
This is thread2:7
This is thread1:8
This is thread2:9
This is thread1:10


vxworks网络通信socket-TCP  

  1. /*Socket基础 
  2.  * A与B发送消息 
  3.  * */  
  4. #include<>   
  5.   
  6. #include<>   
  7. #include<>   
  8. #include<>   
  9. #include<netinet/>   
  10. #include<>   
  11. #include<>   
  12. #define TASK_PRIORITY_A 130   
  13. #define TASK_PRIORITY_B 130   
  14. #define STACK_SIZE 225   
  15. #define PORT 3733   
  16. int taskId_A, taskId_B;  
  17.   
  18. /*定义两个Task*/  
  19. void taskA(void);  
  20. void taskB(void);  
  21.   
  22. /*服务器ip地址*/  
  23. char ip[]="127.0.0.1";  
  24. /*服务端地址与客户端地址*/  
  25. struct sockaddr_in serAddr, cliAddr;  
  26. int len=sizeof(struct sockaddr_in);  
  27.   
  28. int taskDemo() {  
  29.   
  30.     /*创建任务:taskSpawn创建并激活任务*/  
  31.     taskId_A=taskSpawn("taskA", TASK_PRIORITY_A, VX_FP_TASK, STACK_SIZE,  
  32.             (FUNCPTR)taskA, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);  
  33.     taskId_B=taskSpawn("taskB", TASK_PRIORITY_B, VX_FP_TASK, STACK_SIZE,  
  34.             (FUNCPTR)taskB, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);  
  35.     if (taskId_A==ERROR)  
  36.         printf("taskA taskSpawn() failed!\n");  
  37.     if (taskId_B==ERROR)  
  38.         printf("taskB taskSpawn() failed!\n");  
  39.   
  40. }  
  41.   
  42. /*服务端*/  
  43. void taskA() {  
  44.     int sockFd, newFd;  
  45.     char msg[]="hello";  
  46.   
  47.     /*创建套接字*/  
  48.     sockFd=socket(AF_INET,SOCK_STREAM,0);  
  49.   
  50.     /**************************************************************** 
  51.      * 设置套接字要绑定的网络地址，通过对结构体struct sockaddr_in seraddr赋值*/  
  52.     serAddr.sin_family=AF_INET;/*协议族 为ip协议族*/  
  53.     serAddr.sin_port=PORT;/*端口号*/  
  54.     inet_aton(ip, &(serAddr.sin_addr));/*将ip地址转为32位整数*/  
  55.     memset(serAddr.sin_zero, 0, 8);  
  56.     /****************************************************************/  
  57.     /*socket与地址绑定*/  
  58.     bind(sockFd, (struct sockaddr*)&serAddr, len);  
  59.    /*监听*/  
  60.     listen(sockFd, 10);  
  61.    /*接受连接*/  
  62.     newFd=accept(sockFd, (struct sockaddr *)&cliAddr, &len);  
  63.   
  64.     printf("[server]Get connect!\n");  
  65.    /*发送消息*/  
  66.     write(newFd, msg, sizeof(msg));  
  67.   
  68.     printf("[Server]Send message!\n");  
  69. }  
  70.   
  71. /*客户端*/  
  72. void taskB() {  
  73.     int sockFd, rLen;  
  74.     char buf[100];  
  75.     /*创建socket*/  
  76.     sockFd=socket(AF_INET,SOCK_STREAM,0);  
  77.     /*连接*/  
  78.     if (connect(sockFd, (struct sockaddr*)&serAddr, len)==OK)  
  79.         printf("[client]Connected\n");  
  80.     memset(buf, 0, 100);  
  81.    /*读取消息*/  
  82.     rLen=read(sockFd, buf, 255);  
  83.     buf[rLen]='\0';  
  84.     printf("[client]Get message:%s\n", buf);  
  85. }  
/*Socket基础
 * A与B发送消息
 * */
#include<>

#include<>
#include<>
#include<>
#include<netinet/>
#include<>
#include<>
#define TASK_PRIORITY_A 130
#define TASK_PRIORITY_B 130
#define STACK_SIZE 225
#define PORT 3733
int taskId_A, taskId_B;

/*定义两个Task*/
void taskA(void);
void taskB(void);

/*服务器ip地址*/
char ip[]="127.0.0.1";
/*服务端地址与客户端地址*/
struct sockaddr_in serAddr, cliAddr;
int len=sizeof(struct sockaddr_in);

int taskDemo() {

	/*创建任务:taskSpawn创建并激活任务*/
	taskId_A=taskSpawn("taskA", TASK_PRIORITY_A, VX_FP_TASK, STACK_SIZE,
			(FUNCPTR)taskA, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	taskId_B=taskSpawn("taskB", TASK_PRIORITY_B, VX_FP_TASK, STACK_SIZE,
			(FUNCPTR)taskB, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
	if (taskId_A==ERROR)
		printf("taskA taskSpawn() failed!\n");
	if (taskId_B==ERROR)
		printf("taskB taskSpawn() failed!\n");

}

/*服务端*/
void taskA() {
	int sockFd, newFd;
	char msg[]="hello";

	/*创建套接字*/
	sockFd=socket(AF_INET,SOCK_STREAM,0);

	/****************************************************************
	 * 设置套接字要绑定的网络地址，通过对结构体struct sockaddr_in seraddr赋值*/
	serAddr.sin_family=AF_INET;/*协议族 为ip协议族*/
	serAddr.sin_port=PORT;/*端口号*/
	inet_aton(ip, &(serAddr.sin_addr));/*将ip地址转为32位整数*/
	memset(serAddr.sin_zero, 0, 8);
	/****************************************************************/
	/*socket与地址绑定*/
	bind(sockFd, (struct sockaddr*)&serAddr, len);
   /*监听*/
	listen(sockFd, 10);
   /*接受连接*/
	newFd=accept(sockFd, (struct sockaddr *)&cliAddr, &len);

	printf("[server]Get connect!\n");
   /*发送消息*/
	write(newFd, msg, sizeof(msg));

	printf("[Server]Send message!\n");
}

/*客户端*/
void taskB() {
	int sockFd, rLen;
	char buf[100];
	/*创建socket*/
	sockFd=socket(AF_INET,SOCK_STREAM,0);
    /*连接*/
   	if (connect(sockFd, (struct sockaddr*)&serAddr, len)==OK)
		printf("[client]Connected\n");
	memset(buf, 0, 100);
   /*读取消息*/
	rLen=read(sockFd, buf, 255);
	buf[rLen]='\0';
	printf("[client]Get message:%s\n", buf);
}


运行

[client]Connected
[server]Get connect!
[Server]Send message!
[client]Get message:hello


vxworks 下select 机制 

vxworks下select()的使用  

2008-05-20 13:19:24|  分类： 嵌入系统 |  标签： |字号大中小 订阅

select()作用是挂起一系列的文件描述符，其API为：

int select
    (
    int              width,      /* number of bits to examine from 0 */
    fd_set *         pReadFds,   /* read fds */
    fd_set *         pWriteFds, /* write fds */
    fd_set *         pExceptFds, /* exception fds (unsupported) */
    struct timeval * pTimeOut    /* max time to wait, NULL = forever */
    )
该函数允许一个任务挂起一系列的文件描述符，直到文件描述符已经准备好时，再将其唤醒。参数pReadFds, pWriteFds, and pExceptFds 分别指向相应的文件描述符，每一个 bit对应一个文件描述符。pReadFds置位将会使select() 挂起读文件描述符，直到相应的文件描述符有数据准备好时才释放。同样pWriteFds将会引起写文件描述符发生相关的操作。pExceptFds在vxworks中没有用到。

下边的一些宏用于设置fd_set()

    FD_SET(fd, &fdset)
    FD_CLR(fd, &fdset)
    FD_ZERO(&fdset)

width为设置的bit数，可以是最大文件描述符数+1,或者FD_SETSIZE。当函数select返回时，将准备好的文件描述符对应的bit 置位，其他的清0。可以使用FD_ISSET 来检查那些被置位。

例： vxworks下基于select的tcp服务器端设计

#include <>
#include <>
#include <>
#include <>

#define DEFAULT_SERVER_PORT   6699
int server;
SEM_ID Server_SM;
/*
* Start the function Server() as a task in AppInit() like this:
* int ret = 0;
* ret = taskSpawn("tServer", 165, 0x0002, 1024,(FUNCPTR) Server,
*                                 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
*/
void Server()
{
    int rc = 0,sd = 0;
    int addr_len = 0;
    int server_sock = 0;
    struct sockaddr_in server_addr,client_addr;
   
    memset(&server_addr,0,sizeof(struct sockaddr_in));
    memset(&client_addr,0,sizeof(struct sockaddr_in));
    server_sock = socket(AF_INET,SOCK_STREAM,0);
    if(server_sock < 0)
    {
    printf("Failed to create Socket.\n");
        return;
    }
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(DEFAULT_SERVER_PORT);
    rc = bind(server_sock,(struct sockaddr *)&server_addr,sizeof(struct sockaddr_in));
    if(rc == -1)
    {
    close(server_sock);
    printf("Failed to bind socket\n");
    return;
    }
    rc = listen(server_sock,2);
    if(rc == -1)
    {
    printf("socket listen error\n");
    return;
    }  
    printf("TCP server is ready for receive connection request\n");
    while(1)
    {
        addr_len = sizeof(struct sockaddr_in);
    sd = accept(server_sock,(struct sockaddr *)&client_addr,&addr_len);
    if(sd <= 0)
    {
         printf("socket accept error\n");
         return;
    }
    else
    {
         printf("Socket connect success\n");
         server = sd;
         server_proc(sd);
    }
    }
}
    
void server_proc(int sock)
{
    int rc = 0;
    char buffer[32];
    fd_set socket;
    struct timeval wait;
   
    wait.tv_sec = 0;
    wait.tv_usec = 500000;
   
    while(server > 0)
    {
    FD_ZERO(&socket);
    FD_SET(sock,&socket);
   
    rc = select(FD_SETSIZE,&socket,(fd_set *)0,(fd_set *)0,&wait);
    if(rc == 0)
         continue;
    if(FD_ISSET(sock,&socket))
    {
         semTake(Server_SM, WAIT_FOREVER);
         memset(buffer,0,sizeof(buffer));
         rc = recv(sock,buffer,sizeof(buffer),0);
         if(rc > 0)
         {
         /* you can add your application specific code here */
             printf("RecvMsg:%s\n",buffer);
             semGive(Server_SM);
         }
         else
         {
         printf("Socket closed\n");
         close(sock);
         server = 0;
         semGive(Server_SM);
         break;
         }
    }  
    taskDelay(10);
    }
    
}

/* end of the file */




相关文章