bounded buffer

Hi,

  I am writing a little application to capture audio data from a wavein
device and broadcast it to the

internet over http protocol. My application is basically divided into two
segments:

Capturing Thread:
-> waveCapture // waveCapture.h (class)
-> mp3Encoding // mp3Encoder.h (class)

Broadcasting Thread:
-> httpServer // httpServer (class)

So in a nutshell, the capturing thread is the "Producer" and the
broadcasting thread is the "Consumer".

In order to link them I need to code a buffer. The producer will put data on
it whereas the consumer will

retrieve data from it.

I would like to post some code about the server (barebones) so I can get to
the main point later on:

unsigned int __stdcall handleClient(void* a)
{
 Socket* s = (Socket*) a;
 while(1)
 {
  string r = s->ReceiveLine();
  if (r.empty())
   break;

  s->SendLine("Hello, I am the server!");
  break;
 }

 // Disconnect
 s->close();

 delete s;
 return 0;
}

int main()
{
 // Server: set up
 SocketServer in(8000,5);

 while(1)
 {
  // Server: wait for incoming connections
  Socket* s=in.Accept();
  cout << "a client connected..." << endl;

  // Server: spawn a new thread to deal with the client
  unsigned int ret;
  _beginthreadex(0,0,handleClient,s,0,&ret);
 }

 system("pause");
 return EXIT_SUCCESS;
}

As you can see, the server waits for incoming connections and spawns a
thread to deal with a single client each time it connects.

Now, in the handleClient() thread I should retrieve data from the buffer
(being written by the "producer") and send it to the client...

Here comes the pain! Since I have to deal with several connections at the
same time I don't know if they should read from one single buffer or
something else...for instance the producer should write to severl instances
of the buffer...

any idea how I should work this out?

thanks