c++ libwebsocket库应用开发2

本文主要是介绍c++ libwebsocket库应用开发2，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1.向web端发送二进制数据与文本数据时注意

//lws_write(wsi, data->buf+LWS_PRE, isz, LWS_WRITE_BINARY);
//lws_write(wsi, data->buf+LWS_PRE, isz, LWS_WRITE_TEXT);
2.使用信号量一生产者一消费者同步

3.未尝试将senddata数据直接拷贝到data->buf+ LWS_PRE后面区域，而不借助成员变量.

map<long,string>map_wsi_token;// 存wsi指针为key， token为字符串

static volatile int exit_sig = 0;
#define MAX_PAYLOAD_SIZE 13 * 1024

void sighdl(int sig) {
lwsl_notice("%d traped", sig);
exit_sig = 1;
}

// 传输图像
struct lws* g_wsi = NULL;
long g_wsi_port = 9000;
char* g_wsi_protocolname = "hello";
MyThread * g_pThread = NULL;
/**
* 会话上下文对象，结构根据需要自定义
*/
struct session_data {
int msg_count;
unsigned char buf[LWS_PRE + MAX_PAYLOAD_SIZE];
int len;
bool bin;
bool fin;
};

static int protocol_my_callback(struct lws* wsi, enum lws_callback_reasons reason, void* user, void* in, size_t len) {

struct session_data* data = (struct session_data*)user;
switch (reason)
   {
       case LWS_CALLBACK_FILTER_PROTOCOL_CONNECTION: //这里的wsi中才有url内容
       // 客户端连上来看看是否最新token
       {
           char content_length_str[200] = {0};
           lws_hdr_copy(wsi,content_length_str,200,(lws_token_indexes)0);
           char chartoken[200] = {0};
           g_pThread->GetNewToken(chartoken);
           if (chartoken[0]=='\0') // 没有最新的token
           {
               return -1;
           }
           else
           {
               if(strstr(content_length_str,chartoken) != NULL)
               {
                   map_wsi_token.insert(pair<long,string>(long(wsi),string(content_length_str)));
                   g_wsi = wsi;
                   OutputDebugStringA("PROTOCOL_CONNECTION \r\n");
               }
               else
                   return -1;
           }
       }
       break;
case LWS_CALLBACK_ESTABLISHED: // 当服务器和客户端完成握手后
    OutputDebugStringA("LWS_CALLBACK_ESTABLISHED \r\n");
break;
case LWS_CALLBACK_RECEIVE: // 当接收到客户端发来的帧，首先验证token是否有效
           {
               map<long,string>::iterator iter = map_wsi_token.find(long(wsi));
               if(iter != map_wsi_token.end())
               {
                   char chartoken[200] = {0};
                   g_pThread->GetNewToken(chartoken);
                   string strtoken = iter->second;
                   if(strtoken.find(chartoken) == -1)
                   {
                       return -1;
                   }
               }
               else
               {
                   return -1;
               }
           }
break;
case LWS_CALLBACK_SERVER_WRITEABLE: // 当此连接可写时
       OutputDebugStringA("write WaitForSingleObject g_hFullBufferSemaphore\r\n");
       WaitForSingleObject(g_pThread->g_hFullBufferSemaphore, INFINITE); // 等待是否已经生产了产品
       if(g_pThread->_outputbuf != NULL)
       {
           // 前面LWS_PRE个字节必须留给LWS
           int isz = g_pThread->_outsize;//sizeof(g_pThread->_outputbuf);
           memset(data->buf+ LWS_PRE, 0, isz);

           memcpy(data->buf+ LWS_PRE, g_pThread->_outputbuf, isz);
           data->len = isz;
           lws_write(wsi, data->buf+LWS_PRE, isz, (lws_write_protocol)g_pThread->_datatype);

           // 下面的调用允许在此连接上接收数据;
           lws_rx_flow_control(wsi, 1);
           g_pThread->_outsize = 0;
       }
       ReleaseSemaphore(g_pThread->g_hEmptyBufferSemaphore, 1, NULL); // 我消费完了，通知生产者

break;
   case LWS_CALLBACK_LOCK_POLL:
   case LWS_CALLBACK_UNLOCK_POLL:
       break;
   case LWS_CALLBACK_WS_PEER_INITIATED_CLOSE: // 客户端断了链接
       {
          map<long,string>::iterator iter = map_wsi_token.find(long(wsi));
           if(iter != map_wsi_token.end())
           {
               map_wsi_token.erase(iter);
               g_wsi = NULL;
           }
       }
       break;
}
// 回调函数最终要返回0，否则无法创建服务器
return 0;
}
struct lws_protocols protocols[] = {
{
//协议名称，协议回调，接收缓冲区大小，有效负载限制
g_wsi_protocolname, protocol_my_callback, sizeof(struct session_data), MAX_PAYLOAD_SIZE,
},
{

NULL, NULL, 0 // 最后一个元素固定为此格式
}
};

MyThread::MyThread(void)
{
   irun = true;
   memset(newtoken,0,128);
   _outputbuf= NULL;
   _datatype = 0;

}

MyThread::~MyThread(void)
{
StartThread(false);

   CloseHandle(g_hEmptyBufferSemaphore);
   CloseHandle(g_hFullBufferSemaphore);
   if(_outputbuf != NULL)
   {
       free (_outputbuf);
       _outputbuf = NULL;
   }
}
void MyThread::Run()
{
   // 信号处理函数
signal(SIGTERM, sighdl);

struct lws_context_creation_info ctx_info = { 0 };
ctx_info.port = g_wsi_port;
ctx_info.iface = NULL; // 在所有网络接口上监听
ctx_info.protocols = protocols;
ctx_info.gid = -1;
ctx_info.uid = -1;
ctx_info.options = LWS_SERVER_OPTION_VALIDATE_UTF8;

struct lws_context* context = lws_create_context(&ctx_info);
while (!exit_sig) {
lws_service(context, 50);
if(g_wsi != NULL)
lws_callback_on_writable(g_wsi);

       OutputDebugStringA("lws_service 100\r\n");
}

   OutputDebugStringA("lws_service exit_sig\r\n");

lws_context_destroy(context);
}
int MyThread::SendData(unsigned char *outbuffer,int size,int datatype)
{
OutputDebugStringA("WaitForSingleObject g_hEmptyBufferSemaphore \r\n");

   // 等待消费线程，之后等来时计数-1，初始该信号为1，
   WaitForSingleObject(g_hEmptyBufferSemaphore, INFINITE);

   if(isznote <size)
   {
       isznote = size;
       _outputbuf = (unsigned char*)realloc(_outputbuf,isznote*sizeof(unsigned char));
       memset(_outputbuf,0,isznote*sizeof(unsigned char));
       char info[100] = {0};
       sprintf(info,"**sz:%d \r\n",isznote*sizeof(unsigned char));
       OutputDebugStringA(info);
   }

   _datatype = datatype;
   memcpy(_outputbuf,outbuffer,size*sizeof(unsigned char));
   _outsize = size;

   if(g_wsi != NULL)
       lws_callback_on_writable(g_wsi);   //需要给客户端应答时，触发一次写回调

   ReleaseSemaphore(g_hFullBufferSemaphore, 1, NULL); //通知消费线程，信号+1，

   OutputDebugStringA("ReleaseSemaphore g_hFullBufferSemaphore \r\n");

return 0;
}

void MyThread::GetNewToken(char* info)
{
   strcpy(info,newtoken);
}
void MyThread::SetNewToken(const char* info)
{
   memset(newtoken,0,128);
   strcpy(newtoken,info);
}

int MyThread::ThreadInit(long port,const char* protocolname)
{
g_event = CreateEvent(NULL, false, false, NULL); //创建一个匿名事件,当参数bManualReset设置为false时
g_pThread = this;

   g_wsi_protocolname = (char*)protocolname;
   protocols[0].name = g_wsi_protocolname;
   g_wsi_port = port;

   if(_outputbuf == NULL)
   {
       isznote = 4096;
       _outputbuf = (unsigned char*)malloc(isznote*sizeof(unsigned char*));
   }

g_hEmptyBufferSemaphore = CreateSemaphore( NULL, 1, 1, NULL); //创建信号量1
g_hFullBufferSemaphore = CreateSemaphore( NULL, 0, 1, NULL); //

return 0;
}

void MyThread::StartThread(bool brun)
{
   if(brun)
   {
   thread=new CThreadHandler(this);//线程类
       thread->Start();//启动线程
   }
   else
   {
       exit_sig = 0;// 设置退出信号

       int code = thread->Join(5000);
       if(code == STILL_ACTIVE)
       {
           bool bstop = thread->Terminate(code);
           if(bstop== false)
           {
               printf("thread is not terminate \r\n");
           }
       }
       else
       {
           printf("thread is not STILL_ACTIVE \r\n");
       }
   }
}

这篇关于c++ libwebsocket库应用开发2的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

C/C++教程

c++ libwebsocket库应用开发2

前端开发

后端开发

移动端开发

数据库

服务器运维

人工智能

区块链

游戏开发

网站运营

大数据/云计算

软件工程

软件/开发工具使用

资讯