void * runShellServiceThread(void * arg){
if(isInfoEnabled()){
info("Quedando a la espera de conecciones Shell");
}
ServerSocket * serverSocket = openServerConnection(getShellPort());
setShellServerSocket(serverSocket);
ListenSocket listenSocket;
ClientConnection * clientConnection;
Thread thread;
RuntimeErrorValidator * validator = NULL;
do{
listenSocket = acceptConnection(serverSocket);
validator = buildErrorSuccessValidator();
doHandshake(listenSocket , SHELL_HANDSHAKE , validator);
if(!hasError(validator)){
clientConnection = buildClientConnection(listenSocket);
pthread_create(&thread , NULL , runServiceShellThread , clientConnection);
clientConnection->servingThread = thread;
}else{
error("No se pudo lograr el handhsake entre el kss y el proceso remoto Shell");
}
}while(isKssRunningStatus());
close(getShellServerSocket());
return EXIT_SUCCESS;
}
void WebSocket::listen() {
EthernetClient cli;
if (cli = server.available()) {
if (cli == true) {
if (state == DISCONNECTED ) {
client = cli;
if (doHandshake() == true) {
state = CONNECTED;
if (onConnect) {
onConnect(*this);
}
}
} else {
if (getFrame() == false) {
// Got unhandled frame, disconnect
#ifdef DEBUG
Serial.println("Disconnecting");
#endif
disconnectStream();
state = DISCONNECTED;
if (onDisconnect) {
onDisconnect(*this);
}
}
}
}
}
}
/*---------------------------------------------------------------------*/
int main(int argc, char *argv[]){
int oldStatus, status;
initShmControl();
setControlVar(CFG_SRV_HST_SHM_SIZE, HMSIZE*1024*1000);
hst_size = HMSIZE*1024*1000;
initShmHisto();
setControlVar(CFG_SRV_CFG_VALID, CFG_VALID);
oldStatus = doHandshake();
printf("Mini Filler Started with DAQ = %d\n", oldStatus);
while(1){
sleep(1);
status = doHandshake();
if(status != oldStatus){
printf("DAQ switched from %d to %d\n", oldStatus, status);
oldStatus = status;
}
}
exit(0);
}
WebSocket::WebSocket( WebSocketServer *server, EthernetClient cli ) :
m_server(server),
client(cli)
{
if( doHandshake() )
{
state = CONNECTED;
if( m_server->onConnect )
m_server->onConnect(*this);
return;
}
disconnectStream();
}
int createConnection (char* ipAddress, int port) {
struct sockaddr_in address;
int on = 1;
/* Create the socket */
if ((fd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
errorMessage = "Error creating socket";
return -1;
}
if (debug) {
printf ("**DEBUG: Initializing socket...\n");
}
/* Connect to the server
* Blank the inet address struture and then populate it */
bzero (&address, sizeof (address));
address.sin_family = AF_INET;
address.sin_port = htons (port);
#ifdef IPv6
if (inet_pton (AF_INET, ipAddress, &address.sin_addr) < 0) {
errorMessage = "Problem converting address";
return -1;
}
#else
if ((address.sin_addr.s_addr = inet_addr (ipAddress)) < 0) {
errorMessage = "Problem converting address";
return -1;
}
#endif
if (debug) {
printf ("**DEBUG: Opening socket...\n");
}
/* Open the connection */
if (connect (fd, (struct sockaddr*)&address, sizeof (address)) < 0) {
errorMessage = "Unable to connect to server";
return -1;
}
if (doHandshake () < 0) {
return -1;
}
return 0;
}
void * runFtpServiceThread(void * arg){
ServerSocket * serverSocket = openServerConnection(getFtpsPort());
setFtpServerSocket(serverSocket);
ListenSocket listenSocket;
ClientConnection * clientConnection;
RuntimeErrorValidator * validator = buildErrorSuccessValidator();
Thread thread;
do{
if(isKssOperationalStatus()){
if(isInfoEnabled()){
info("Quedando a la espera de conecciones FTP");
}
listenSocket = acceptConnection(serverSocket);
doHandshake(listenSocket , FTP_HANDSHAKE , validator);
if(hasError(validator)){
error("No se pudo lograr el handhsake entre el kss y el proceso remoto FTPS.");
} else {
clientConnection = malloc(sizeof(ClientConnection));
clientConnection->clientSocket = listenSocket;
pthread_create(&thread , NULL , runServiceFtpsThread , clientConnection);
clientConnection->servingThread = thread;
}
}else{
if(isInfoEnabled()){
info("Aguardando por estado operacional");
}
sleep(5);
}
}while(isKssRunningStatus());
close(getFtpServerSocket());
return EXIT_SUCCESS;
}
void * runFssServiceThread(void * arg) {
if(isInfoEnabled()){
info("Quedando a la espera de conecciones FSS");
}
RuntimeErrorValidator * validator = buildErrorSuccessValidator();
ServerSocket * serverSocket = openServerConnection(getFssListenPort());
setFssServerSocket(serverSocket);
ListenSocket clientSocket = acceptConnection(serverSocket);
doHandshake(clientSocket , FSS_HANDSHAKE, validator);
if(hasError(validator)){
error(validator->errorDescription);
return NULL;
}
setFileSystemConnection(clientSocket );
close(serverSocket);
return EXIT_SUCCESS;
}
void
AsyncCDDBPLookup::read()
{
switch ( state_ )
{
case WaitingForGreeting:
if ( !parseGreeting( readLine() ) )
{
result_ = ServerError;
doQuit();
return;
}
doHandshake();
break;
case WaitingForHandshake:
if ( !parseHandshake( readLine() ) )
{
result_ = ServerError;
doQuit();
return;
}
doProto();
break;
case WaitingForProtoResponse:
// Ignore the response for now
readLine();
doQuery();
break;
case WaitingForQueryResponse:
result_ = parseQuery( readLine() );
switch ( result_ )
{
case Success:
requestCDInfoForMatch();
break;
case MultipleRecordFound:
state_ = WaitingForMoreMatches;
break;
default: // Error :(
doQuit();
return;
}
break;
case WaitingForMoreMatches:
{
QString line = readLine();
if (line.startsWith(QLatin1String( "." )))
requestCDInfoForMatch();
else
parseExtraMatch( line );
}
break;
case WaitingForCDInfoResponse:
{
Result result = parseRead( readLine() );
if ( Success != result )
{
result_ = result;
doQuit();
return;
}
state_ = WaitingForCDInfoData;
}
break;
case WaitingForCDInfoData:
{
QString line = readLine();
if (line.startsWith(QLatin1String( "." )))
{
parseCDInfoData();
requestCDInfoForMatch();
}
else
cdInfoBuffer_ << line;
}
break;
case WaitingForQuitResponse:
state_ = Idle;
char c;
while ( socket_->bytesAvailable() )
socket_->getChar(&c);
close();
emit finished( result_ );
break;
default:
break;
}
}
int main(int argc, char *argv[])
{
char *servhost = (char *)HOST;
long port = PORT;
unsigned long numOfBlocks = 0;
int flag = 1;
if (argc >= 2)
{
if (isalpha(argv[1][0]) || argv[1][0] == '?')
{
cout << "pclient [numOfBlocks = 10] [numOfChallenges=50] [Server Name = localhost] [Port = 8888]" << endl;
exit(0);
}
else if(argv[1][0] == '-')
flag= 0;
else
numOfBlocks = atoi(argv[1]);
}
int numOfChallenges = CHALLNUM;
if (argc >=3)
numOfChallenges = atoi(argv[2]);
if (argc >=4)
servhost = argv[3];
if (argc >= 5)
if (atoi(argv[4]) > 1024)
port = atoi(argv[4]);
/* no of challenges in the challenge set */
unsigned l;
unsigned long indexSize = getPrimeKeys();
if (numOfBlocks > 0 && numOfBlocks<indexSize)
l = numOfBlocks;
else
l = BLOCKNUM;
int sock = clientConnect(servhost, port);
doHandshake(numOfChallenges, flag, sock);
FILE *foutput = prepareOutput(servhost, l, flag);
char output[1024] = {0};
bool res = false;
uint64_t elapsed = 0;
for (int i=0; i<numOfChallenges; i++)
{
elapsed = 0;
if (flag)
res = challengeResponse(sock, l, &elapsed);
else
res=FileRet(sock, &elapsed);
if (res)
snprintf(output, 15, "%s", "Data Verified");
else
snprintf(output, 15, "%s", "Data lost");
fprintf(foutput, "%llu \t\t\t %s \n", elapsed, output);
//write the results
}
fclose(foutput);
closeSocket(sock);
return 0;
}
