Re: WaitForSingleObject

"Ulrich Eckhardt" <eckhardt@satorlaser.com> ha scritto nel messaggio
news:5bu837-5f.ln1@satorlaser.homedns.org...


I tried that, but it is not working like I was expecting...I still get a run
time error when I disconnect from the server (I'm using telnet)

/*
 *
 * Streaming Server v1.1 by THEARTOFWEB Software
 *
 */

#include <iostream>
#include <string>
#include <map>
#include <algorithm>
#include <process.h>
#include <cstdlib>
#include <ctime>
#include "socket.h"
#include <boost/circular_buffer.hpp>
using namespace std;
using namespace boost;

const string CRLF = "\r\n";
const int numbuff = 3;

unsigned int __stdcall Consumer(void* sock);
unsigned int __stdcall Producer(void*);

void getDateTime(char * szTime);

enum buffer_status
{
 BUFF_DONE = 1,
 BUFF_EMPTY = 0
};

struct buffer
{
 unsigned char data[1024];
 int bytesRecorded;
 int flag;
 buffer(const unsigned char * data_, const int bytesRecorded_, const int
flag_) :
  bytesRecorded(bytesRecorded_), flag(flag_)
  {
   copy(data_, data_ + bytesRecorded_, data);
  }
};

struct circular
{
 circular_buffer<buffer> cb;
};

// Global maps

map<int, circular> users;
map<int, circular>::iterator uit;
map<int, HANDLE> eventi;
map<int, HANDLE>::iterator eit;

// Declare Procuder && Cosumer CS

CRITICAL_SECTION csProducer;
CRITICAL_SECTION csConsumer;

int main()
{
 // Initialize the critical section
 InitializeCriticalSection(&csProducer);

 // Launch Producer Thread
 unsigned int prodRet;
 _beginthreadex(0,0,Producer,NULL,0,&prodRet);
 if(prodRet)
  cout << "Launched Producer Thread!" << endl;

 // Server.
 // Set up server (port: 8000, maxconn: 10)
 //
 SocketServer sockIn(8000, 10);

 while(1)
 {
  // ...wait for incoming connections...
  Socket* s = sockIn.Accept();

  // Initialize the critical section
  InitializeCriticalSection(&csConsumer);

  // Spawn a new Consumr Thread each
  // time a client connects.
  unsigned int sockRet;
  _beginthreadex(0,0,Consumer,s,0,&sockRet);
  if(sockRet)
   cout << "Spawned a new thread!" << endl;

 }

 sockIn.Close();

 return EXIT_SUCCESS;
}

// Consumer Thread
unsigned int __stdcall Consumer(void* sock)
{
 Socket* s = (Socket*) sock;

 s->SendBytes("Hello World!" + CRLF);

 int threadid = (int)GetCurrentThreadId();

 // Create Event && Push it in the event map
 HANDLE hevent = CreateEvent(NULL,FALSE,FALSE,NULL);

 EnterCriticalSection(&csConsumer);
 eventi.insert(make_pair(threadid,hevent));
 LeaveCriticalSection(&csConsumer);

 // Prepare && Add circular buffer to the map
 circular c;
 c.cb.set_capacity(numbuff);

 for(int i = 0; i<numbuff; i++)
 {
  c.cb.push_back(buffer(NULL,0,BUFF_EMPTY));
 }

 EnterCriticalSection(&csConsumer);
 users.insert(make_pair(threadid, c));
 LeaveCriticalSection(&csConsumer);

 //
 // Read data from the buffer
 // and send it to the client
 //
 // When using push_back the oldest
 // element in the circular buffer
 // will be in the index 0
 //

 Sleep(500);

 while(1)
 {
  // CALLBACK EVENT
  if(eventi[threadid])
  {
   WaitForSingleObject(eventi[threadid], INFINITE);
  } else {
   DeleteCriticalSection(&csConsumer);
   return 0;
  }

  EnterCriticalSection(&csConsumer);
  if(users[threadid].cb.at(0).flag == BUFF_DONE)
  {
   string line = (char*)users[threadid].cb.at(0).data;
   int ret = s->SendBytes(line + CRLF);
   if(SOCKET_ERROR == ret)
    break;
  }
  LeaveCriticalSection(&csConsumer);
 }

 // Close & remove event from event map
 CloseHandle(eventi[threadid]);

 EnterCriticalSection(&csConsumer);
 eventi.erase(threadid);
 LeaveCriticalSection(&csConsumer);

 // Remove buffer from the map
 EnterCriticalSection(&csConsumer);
 users.erase(threadid);
 LeaveCriticalSection(&csConsumer);

 // Say bye to the client
 s->SendBytes("Bye bye!" + CRLF);

 // Disconnect client
 cout << "Closing thread..." << endl;

 // Release resources used by the critical section object.
 DeleteCriticalSection(&csConsumer);
 s->Close();
 delete s;
 return 0;
}

// Producer Thread
unsigned int __stdcall Producer(void*)
{
 while(1)
 {
  Sleep(1000);
  char szTime[30]; getDateTime(szTime);

  // Request ownership of the critical section.
  EnterCriticalSection(&csProducer);

  for(uit=users.begin(); uit!=users.end(); ++uit)
  {
   users[uit->first].cb.push_back(buffer((unsigned char*)szTime, 30,
BUFF_DONE));

   if(eventi[uit->first])
    SetEvent(eventi[uit->first]);

   cout << "Producer is writing to: " << uit->first << endl;
  }

  // Release ownership of the critical section.
  LeaveCriticalSection(&csProducer);
 }
 // Release resources used by the critical section object.
 DeleteCriticalSection(&csProducer);
 return 0;
}

void getDateTime(char * szTime)
{
 time_t rawtime = time(NULL);
 struct tm timeinfo;
 gmtime_s(&timeinfo, &rawtime);
 strftime(szTime, 30, "%a, %d %b %Y %X GMT", &timeinfo);
}