void listenForClients()
{
listener_ = openListener(port_);
maximumClientDescriptor_ = listener_;
FD_SET(listener_, &clientsSet_);
while(true)
{
temporarySet_ = clientsSet_;
select(maximumClientDescriptor_+1, &temporarySet_, NULL, NULL, NULL);
if(FD_ISSET(listener_, &temporarySet_))
{
std::cout << "New client connection..." << std::endl;
struct sockaddr_in addr;
socklen_t len = sizeof(addr);
SSL *ssl;
int client = accept(listener_, (struct sockaddr*)&addr, &len);
ssl = SSL_new(serverContext_);
SSL_set_fd(ssl, client);
if ( SSL_accept(ssl) == FAIL )
{
ERR_print_errors_fp(stderr);
}
ClientDesc desc;
desc.descriptor = client;
desc.ssl = ssl;
std::cout << "Connected client real name: " << getClientCN(ssl) << std::endl;
desc.canBroadcast = isNameOnBroadcastList(getClientCN(ssl));
clientDescriptors_[client] = desc;
FD_SET(client, &clientsSet_);
if(client > maximumClientDescriptor_) maximumClientDescriptor_ = client;
}
for (auto client : clientDescriptors_)
{
temporarySet_ = clientsSet_;
select(maximumClientDescriptor_+1, &temporarySet_, NULL, NULL, NULL);
if(FD_ISSET(client.second.descriptor, &temporarySet_))
{
serveClient(client.second);
}
}
}
}
int main(int argc, char *argv[]){
struct sockaddr_in serverAddr, clientAddr; /*server and client addr*/
int serverport; /*server port*/
int serverfd,clientfd;
unsigned int addrLength;
if (argc>2){
fprintf(stderr,"Usage: %s <server port>\n",argv[0]);
exit(SUCCESS);
}
if(argv[1] == NULL)
serverport = SERVER_PORT;
else serverport = atoi(argv[1]);
serverfd = socket(PF_INET,SOCK_STREAM,IPPROTO_TCP);
if(serverfd < 0){
serverErr("Socket() creation failed!");
}
memset(&serverAddr, 0, sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
serverAddr.sin_port = htons(serverport);
if(bind(serverfd, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) < 0)
serverErr("Failed to bind()");
if(listen(serverfd, MAXPENDING) < 0)
serverErr("Failed to listen()");
while(1){
addrLength = sizeof(clientAddr);
if((clientfd = accept(serverfd, (struct sockaddr *)&clientAddr,&addrLength)) < 0)
serverErr("Failed to accept()");
serveClient(clientfd, (struct sockaddr_in *) &clientAddr);
}
//return 0; no exit => server runs forever
}
int main(int argc, char* argv[])
{
if (!(argc == 3 && isnumber(argv[1])))
{
printf("Usage:\n");
return EXIT_FAILURE;
}
int port = atoi(argv[1]);
struct stat sb;
if (!(stat(argv[2],&sb) == 0 && S_ISDIR(sb.st_mode)))
{
fprintf(stderr,"Folder does not exist\n");
return EXIT_FAILURE;
}
int sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd<0)
{
fprintf(stderr,"socket error: %s\n",strerror(errno));
return EXIT_FAILURE;
}
struct sockaddr_in serverAddr;
memset(&serverAddr, 0, sizeof(struct sockaddr_in));
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(port);
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(sockfd,(struct sockaddr*)&serverAddr,sizeof(serverAddr)) < 0)
{
fprintf(stderr,"bind error: %s\n",strerror(errno));
return EXIT_FAILURE;
}
if (listen(sockfd, 64) < 0)
{
fprintf(stderr,"listen error: %s\n",strerror(errno));
return EXIT_FAILURE;
}
printf("starting Kwasne Powidelko Server v0.6.6.6\n");
while (1)
{
int connSockfd = accept(sockfd, NULL, NULL);
int cpid = fork();
if (cpid==0)
{
printf("new connection, waiter ID: %d\n",getpid());
int serveRes = serveClient(connSockfd, argv[2]);
shutdown(connSockfd,SHUT_RDWR);
close(connSockfd);
if (serveRes<0)
printf("waiter %d terminating after a failure\n",getpid());
else
printf("waiter %d terminating with success\n",getpid());
return EXIT_SUCCESS;
}
if (cpid<0)
{
fprintf(stderr,"fork error: %s\n",strerror(errno));
}
}
}
int main(int argc, char* argv[]){
char* host = "127.0.0.1";
if (argc != 2){
std::cerr << "Usage: client <host>" << std::endl;
return 1;
}else{
host = argv[1];
}
PaStreamParameters outputParameters;
PaStream *stream;
PaError err;
sAudioBuffer* audiobuf;
audiobuf = new sAudioBuffer();
audiobuf->dec = opus_decoder_create(SAMPLE_RATE, 2, &audiobuf->error);
if(audiobuf->error != OPUS_OK){
std::cerr << "opus: could not create decoder" << std::endl;
return 2;
}
printf("SR = %d, BufSize = %d\n", SAMPLE_RATE, FRAMES_PER_BUFFER);
audiobuf->readerIndex = 0;
err = Pa_Initialize();
if( err != paNoError ) goto error;
outputParameters.device = Pa_GetDefaultOutputDevice();
if (outputParameters.device == paNoDevice){
fprintf(stderr,"Error: No default output device.\n");
goto error;
}
outputParameters.channelCount = 2;
outputParameters.sampleFormat = paFloat32;
outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;
outputParameters.hostApiSpecificStreamInfo = NULL;
err = Pa_OpenStream(
&stream,
NULL,
&outputParameters,
SAMPLE_RATE,
FRAMES_PER_BUFFER,
paClipOff,
audioCallback,
audiobuf);
if( err != paNoError ) goto error;
err = Pa_SetStreamFinishedCallback( stream, &StreamFinished );
if( err != paNoError ) goto error;
err = Pa_StartStream( stream );
if( err != paNoError ) goto error;
try{
serveClient(host, audiobuf);
}catch (std::exception& e){
std::cerr << e.what() << std::endl;
}
err = Pa_StopStream( stream );
if( err != paNoError ) goto error;
err = Pa_CloseStream( stream );
if( err != paNoError ) goto error;
Pa_Terminate();
delete audiobuf;
return 0;
error:
Pa_Terminate();
fprintf( stderr, "An error occured while using the portaudio stream\n" );
fprintf( stderr, "Error number: %d\n", err );
fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
return err;
}
